home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Columbia Kermit
/
kermit.zip
/
ccdos
/
ccsset.asm
< prev
next >
Wrap
Assembly Source File
|
2020-01-01
|
109KB
|
2,701 lines
NAME ccsset
; File CCSSET.ASM
;CHINESE1
ifdef MSDOS
include mssset1.dat
else
include ccsset1.dat
endif
code segment public 'code'
extrn prserr:near, comnd:near, dobaud:near, cmblnk:near, locate:near
extrn prompt:near, coms:near, defkey:near, cwdir:near
extrn prtscr:near, getbaud:near, isfile:near, strlen:near
extrn strcpy:near, cnvlin:near, katoi:near, decout:near
extrn vts:near, vtstat:near, shomodem:near, setalrm:near
assume cs:code, ds:datas, es:nothing
; DO defined macro command
; DO macname variable variable also defines variables \%1, \%2, ...\%9
DOCOM PROC NEAR
mov dx,offset mcctab ; table of macro defs
mov bx,0 ; help is table
mov ah,cmkey ; get key word (macro name)
call comnd ; get pointer to keyword structure
ret
nop
nop
mov comand.cmquiet,0 ; permit command echoing
mov domacptr,bx ; address of definition string
; note: remtab updates domacptr because substitutions many modify the table
mov bx,offset decbuf ; point to borrowed work buffer
mov word ptr[bx],0 ; clear buffer
; mov dx,offset dohlp ; help
mcmsg dohlp,cdohlp
mov comand.cmblen,length rdbuf ; length of analysis buffer
mov ah,cmtxt ; get line of text, if any
call comnd
ret
nop
nop
mov al,ah
mov ah,0
mov deftemp,ax ; save byte count of command args
cmp al,0 ; anything given?
je docom9 ; e = no, just do the macro
mov word ptr rdbuf+3,' 1' ; number of first variable
docom8: mov rdbuf,0 ; clear length field, install \%x name
mov word ptr rdbuf+1,'%\' ; start with '\%1 '
mov word ptr rdbuf+5,0 ; clear text field
mov tempptr,offset rdbuf+5 ; pointer to location of found word
mov ch,0 ; make cx = 1 - 9
mov cl,rdbuf+3 ; cx = word # of interest, for getwrd
sub cl,'0' ; remove ascii bias
mov si,offset decbuf ; source = work buffer (borrowed)
call getwrd ; get CX-th word from work buf (1-9)
cmp deftemp,0 ; length of word, was it found?
je docom9 ; e = no, end variable definition part
add deftemp,4 ; count '\%n ' in command line length
call dodecom ; add keyword+def using DEF MAC below
nop
nop
nop
inc rdbuf+3 ; inc number of variable in '\%n '
cmp rdbuf+3,'9'
jbe docom8 ; do '1' through '9', if available
; DO the macro itself
docom9: cmp taklev,maxtak ; room in take level?
jl docom2 ; l = yes, continue
; mov dx,offset ermes4 ; else complain
mcmsg ermes4,cermes4
jmp reterr
docom2: inc taklev ; increment take level
add takadr,size takinfo
mov bx,takadr ; point to current buffer
mov si,domacptr ; address of macro definition string
mov [bx].takbuf,si ; remember in Take structure
mov cl,[si] ; length of definition
mov ch,0
inc si ; point to actual definition
mov [bx].taktyp,0ffh ; flag as a macro
mov [bx].takptr,si ; point to beginning of def
mov [bx].takcnt,cx ; # of chars in buffer
jmp rskp
DOCOM ENDP
; Extract CX-th word (cx = 1-9) from buffer (DI). Enter with si = source
; string and tempptr pointing at destination. Returns deftemp (count) of
; transferred characters. Allow string in curly braces to exist as a word.
; Adjacent curly braced strings are separate "words":
; {this is word-one}{this is word-two}word-three.
; All registers preserved.
getwrd proc near
push ax
push cx
push dx
push si
push di
push es
push ds
pop es ; set es to datas segment
getwr1: push cx ; save word counter (1-9)
mov deftemp,0 ; no bytes transferred yet
mov di,tempptr ; where to store word/string
mov byte ptr [di],0 ; clear destination
mov dx,si ; start looking here in work buf
call strlen ; cx = remaining length of work buf
jcxz getwr6 ; z = nothing there, quit
getwr2: lodsb
cmp al,' ' ; skip leading whitespace
loope getwr2
dec si ; return to break char
; Parse curly brace delimited string
; end with si after closing brace
mov dl,0 ; assume "opening brace" is a null
mov dh,' ' ; assume "closing brace" is a space
mov cx,1 ; we are at brace level 1
cmp byte ptr [si],braceop ; starting with a real opening brace?
jne getwr3 ; ne = no
inc si ; skip opening brace
mov dl,braceop ; opening brace (we count them up)
mov dh,bracecl ; closing brace (we count them down)
getwr3: cld ; search forward
lodsb ; read a char
stosb ; store in output buffer
cmp al,0 ; at end of text?
jne getwr3a ; ne = no
dec si ; stay at null terminator
dec di
jmp short getwr6 ; we are done with this "word"
getwr3a:inc deftemp ; count copied char
cmp al,dl ; an opening brace?
jne getwr4 ; ne = no
inc cx ; yes, increment brace level
jmp short getwr3 ; and continue scanning
getwr4: cmp al,dh ; closing brace?
jne getwr3 ; ne = no, continue scanning
dec cx ; yes, decrement brace level
cmp byte ptr [si],0 ; have we just read the last char?
jne getwr5 ; no, continue scanning
mov cx,0 ; yes, this is the closing brace
getwr5: cmp cx,0 ; at level 0?
jne getwr3 ; ne = no, #opening <> #closing braces
mov byte ptr [di-1],0 ; plant terminator on closing brace
dec deftemp ; do not count closing brace
getwr6: pop cx ; recover word counter
mov byte ptr [di],0
jcxz getwrx ; just in case
loop getwr1 ; do until desired word is copied
getwrx: pop es
pop di
pop si
pop dx
pop cx
pop ax
ret
getwrd endp
; DEFINE and ASSIGN macro commands
; Data structures comments. Macro name is stored in table mcctab as if we
; had used macro mkeyw, such as mkeyw 'mymac',offset my_definition.
; In detail: db length of name
; db 'name'
; db '$'
; dw offset of definition string
; Mcctab begins with a byte holding the number of macros in the table; one,
; IBM, is established at assembly time. Mcctab is 10*macmax bytes long.
; Pointer mccptr holds the offset of the next free byte in mcctab.
; Definition strings are stored in table macbuf as
; db length of definition string below
; db 'definition string'
; Pointer macptr holds the offset of the next free byte in macbuf. Macbuf
; is nominally 100*macmax bytes long.
; A new definition is read into buffer rdbuf+1, where byte rdbuf is reserved
; to hold the length of the macro's name during intermediate processing.
; If the definition is absent then the macro is removed from the tables.
; Rewritten 13 June 1987 [jrd]
;
; ASSIGN is equivalent to DEFINE, except in the definition string substitution
; variable names are expanded to their definitions. This becomes a copy cmd.
; DEFINE does not expand substitution variables.
ASSIGN PROC NEAR
mov temp,0 ; flag command as ASSIGN, vs DEFINE
jmp dodefcom ; common code
ASSIGN ENDP
DODEF PROC NEAR
mov temp,1 ; flag command as DEFINE, vs ASSIGN
DODEFCOM:
mov comand.cmper,1 ; do not react to '\%' in macro name
mov ah,cmfile
mov dx,offset rdbuf+1 ; buffer for macro name
mov word ptr rdbuf,0
; mov bx,offset macmsg
mcmsgb macmsg,cmacmsg
call comnd ; get macro name
ret
nop
nop
cmp ah,0 ; null entry?
jne dodef1 ; ne = no
; mov dx,offset ermes6 ; more parameters needed
mcmsg ermes6,cermes6
jmp reterr
dodef1: mov bx,dx ; updated pointer
mov byte ptr [bx-1],' ' ; replace null with space separator
mov word ptr [bx],0 ; terminator, in case no command
mov ax,temp ; get ASSIGN/DEFINE flag
mov comand.cmper,al ; react (DEF) to '\%' in definition
mov ah,cmtxt ; get a line of text
; mov dx,offset macmsg
mcmsg macmsg,cmacmsg
mov comand.cmblen,length rdbuf ; our buffer length
sub comand.cmblen,al ; minus part used
dec comand.cmblen ; space separator
call comnd ; get macro name
ret
nop
nop
sub bx,offset rdbuf ; length of command line
dec bx ; minus count byte
mov deftemp,bx ; save length of command line
;; jmp dodecom ; common code below
DODEF ENDP
; DODECOM called by DO mac above
; accepts rdbuf+1 et seq = <macro name><spaces><arg><spaces><arg> ...
; byte rdbuf computed here as length of keyword
DODECOM PROC NEAR
push si ; macro name in rdbuf+1 et seq
push di ; cmd line length in deftemp
push es
push ds ; address data segment
pop es
mov cx,deftemp ; cmd line len, cx = running counter
mov rdbuf,0 ; number of chars in keyword so far
; uppercase the keyword, look for end
mov si,offset rdbuf+1 ; point at macro name text
cld ; strings go forward
dode2: lodsb ; get a byte, dec cx
cmp al,'a' ; map lower case to upper
jb dode3
cmp al,'z'
ja dode3
sub al,'a'-'A'
mov [si-1],al ; uppercase if necessary
dode3: inc rdbuf ; increment char count of keyword
cmp al,' ' ; is this the break character?
loopne dode2 ; no, loop thru rest of word
jne dode4 ; ne = did not end with break char
dec rdbuf ; yes, don't count in length
dode4: push di
mov di,offset rdbuf ; point at mac name length byte
call remtab ; remove any duplicate keyword
pop di
jcxz dode6 ; cx = 0 means no keyword
; check for free space for keyword and string
mov al,rdbuf ; keyword text length
add al,4 ; plus overhead bytes
xor ah,ah
add ax,mccptr ; add to free space pointer
cmp ax,offset mcctab+mcclen ; enough room for name?
jb dode5 ; b = yes
; mov dx,offset ermes1 ; too many macro names
mcmsg ermes1,cermes1
pop es
pop di
pop si
jmp reterr
dode5:
mov di,si ; si = source address
add di,cx ; length of string
dec di ; omit null terminator
std
mov al,' ' ; scan off trailing spaces
repe scasb
add di,2 ; backup to terminator slot
cld
mov byte ptr [di],0 ; plant new terminator
mov dx,si
call strlen ; get new length into cx
mov di,si ; scan after keyword name
mov al,' ' ; remove leading spaces in string
repe scasb
je dode6 ; e = all spaces
inc cx ; offset auto decrement of rep
dec di ; offset auto increment of rep
mov si,di ; point to start of string text
mov dx,di ; source of definition text
call strlen ; get length of string into cx
mov ax,cx ; length of string
mov deftemp,cx ; remember it here
inc ax ; plus its count byte
add ax,macptr ; plus free space pointer
cmp ax,offset macbuf+maclen ; enough room for definition string?
jb dode7 ; b = yes
pop es
pop di
pop si
; mov dx,offset ermes2 ; no room for definition
mcmsg ermes2,cermes2
jmp reterr
dode6: pop es
pop di
pop si
jmp rskp
; install new keyword in mcctab
dode7: cmp deftemp,0 ; deftemp = length of definition
je dode10 ; e = no def, exit now
mov bx,offset mcctab
mov dx,offset rdbuf ; count byte + name string
call addtab
; copy definition into buffer, changing commas to CRs
mov di,macptr ; free space in string buffer
mov cx,deftemp ; length of definition string
mov byte ptr[di],cl ; store length of string
inc di ; skip over count byte
dode8: lodsb ; get a byte
cmp al,',' ; comma?
jne dode9 ; no, keep going
mov al,cr ; else replace with cr
dode9: stosb
loop dode8 ; keep copying
mov macptr,di ; update free ptr
dode10: pop es
pop di
pop si
jmp rskp
DODECOM ENDP
; ASK <variable or macro name> <prompt string>
; Defines indicated variable/macro with text from user at keyboard or pipe
; (but not from a Take/macro). Prompt string is required. [jrd]
ASK PROC NEAR
mov dx,offset rdbuf+1 ; point to work buffer
mov word ptr rdbuf,0
; mov bx,offset askhlp1 ; help
mcmsgb askhlp1,caskhlp1
mov comand.cmper,1 ; do not expand variable name
mov ah,cmfile ; get variable name
call comnd
jmp r
nop
cmp ah,0 ; anything given?
jne ask2 ; ne = yes
; mov dx,offset ermes6 ; more parameters needed
mcmsg ermes6,cermes6
jmp reterr
ask2: xchg ah,al
mov ah,0
mov bx,offset rdbuf+1 ; start of name
add bx,ax ; plus length of variable name
mov byte ptr [bx],' ' ; put space separator after name
inc ax ; count space
mov temp,ax ; remember length here
; get ASK command prompt string
inc bx ; put prompt string here
mov byte ptr [bx],0 ; safety terminator
; mov dx,offset askhlp2
mcmsg askhlp2,caskhlp2
mov comand.cmblen,127 ; our buffer length
sub comand.cmblen,al ; minus part used above
mov ah,cmtxt ; get prompt string
call comnd
jmp r
nop
cmp ah,0 ; anything given?
jne ask4 ; ne = yes
; mov dx,offset ermes6 ; more parameters needed
mcmsg ermes6,cermes6
jmp reterr
ask4: mov ax,takadr ; we could be in a macro or Take file
mov temp2,ax ; save Take address
mov al,taklev
mov ah,0
mov temp1,ax ; and Take level
mov dx,size takinfo ; bytes for each current Take
mul dx ; times number of active Take/macros
sub takadr,ax ; clear Take address as if no
mov taklev,0 ; Take/macro were active so that
; user input is from kbd or pipe
mov word ptr [bx],'$ ' ; printing terminator for prompt
mov dx,offset rdbuf+1
add dx,temp ; prompt for input string
mov si,dx
mov di,offset rdbuf+129 ; temporary destination
push dx ; save source
call cnvlin ; parse backslash numbers etc
pop dx ; destination is old source location
mov si,di ; copy back to lower part of rdbuf
add di,cx ; go to null terminator
mov word ptr [di],'$ ' ; dollar sign/space for DOS printing
mov byte ptr [di+2],0
mov di,dx
call strcpy
call prompt ; buf = <var name>< ><prompt string>
mov bx,offset rdbuf+129 ; use this buffer for raw user input
mov word ptr [bx],0 ; insert terminator
; mov dx,offset askhlp3 ; help for user input
mcmsg askhlp3,caskhlp3
mov ah,cmtxt ; read user's input string
call comnd
jmp ask9 ; exit now on ^C from user
nop
mov cl,ah ; length of entry
mov ch,0
jcxz ask8 ; z = empty
mov si,offset rdbuf+129 ; source string
mov di,offset rdbuf+1 ; start of variable name
add di,temp ; di points to final user string
push es ; save es
push ds
pop es ; set es to datas segment
cld
ask6: lodsb ; read original user string char
cmp al,',' ; literal comma?
jne ask7 ; ne = no
mov ax,'{\' ; yes. Replace literal comma
stosw ; with numerical equivalent \{44}
mov ax,'44' ; to permit commas in macro def
stosw
add temp,4
mov al,'}'
ask7: stosb ; store string character
inc temp ; length of <variable>< ><user string>
loop ask6
pop es
ask8: mov ax,temp ; length of <variable>< ><user string>
mov deftemp,ax ; put here for dodecom usage
mov ax,temp2
mov takadr,ax ; restore Take address
mov ax,temp1
mov taklev,al ; restore Take level
jmp DODECOM ; define the macro/variable and exit
ask9: mov ax,temp2 ; failure path
mov takadr,ax ; restore Take address
mov ax,temp1
mov taklev,al ; restore Take level
ret ; return command failure
ASK ENDP
; Open a disk based Take file buffer. Define macro named "<null>T<'taklev'>",
; allocate 128 byte uninitiated buffer in mcctab for disk i/o. Leading null
; is to prevent user from employing the same name accidentally. Return offset
; of buffer in [takadr].takbuf and set [takadr].takptr pointing to it.
; Return carry clear for success, carry set for failure.
TAKOPEN PROC NEAR
push ax
push bx
push dx
push di
; mov dx,offset ermes2 ; says no room for defintions
mcmsg ermes2,cermes2
mov ax,dmasiz+1 ; count byte plus length of buffer
add ax,macptr ; plus free space pointer
cmp ax,offset macbuf+maclen ; enough room for definition string?
jae takopen1 ; ae = no, complain
cmp taklev,maxtak ; room in take level?
jl takopen2 ; l = yes, continue
; mov dx,offset ermes4 ; say too many Take files
mcmsg ermes4,cermes4
takopen1:mov ah,prstr
int dos
pop di
pop dx
pop bx
pop ax
stc ; set carry for failure
ret
takopen2:inc taklev ; next Take
add takadr,size takinfo ; pointer to Take structure
mov rdbuf,3 ; length of name, 3 bytes <null>Tn
mov rdbuf+1,0
mov rdbuf+2,'T' ; name of <null>Tn
mov al,taklev ; Take level digit
add al,'0' ; add ascii bias
mov rdbuf+3,al ; last of the name
mov di,offset rdbuf ; pointer for remtab
call remtab ; remove possible old macro
mov bx,offset mcctab ; table to use
mov dx,offset rdbuf ; count and mac name to enter
call addtab ; returns string pointer in macptr
mov di,macptr
add macptr,dmasiz+1 ; set new free byte into pointer
mov byte ptr [di],dmasiz ; string length (128 bytes)
mov bx,takadr ; pointer to Take structure
mov [bx].takbuf,di ; offset of Take buffer
inc di ; skip count byte in takbuf
mov [bx].takptr,di ; init pointer to definition itself
pop di
pop dx
pop bx
pop ax
clc ; carry clear for success
ret
TAKOPEN ENDP
; Close Take file. Enter at Take level to be closed. Removes pseudo macro
; name <null>Tn and its buffer, closes disk file, pops Take level.
TAKCLOS PROC NEAR
cmp taklev,0 ; anything to close?
jle takclo2 ; le = no
push ax
push bx
mov bx,takadr ; point to Take structure
cmp [bx].taktyp,0feh ; disk file (vs macro)?
jne takclo1 ; ne = no, no buffer to deallocate
mov rdbuf,3 ; length of name
mov rdbuf+1,0
mov rdbuf+2,'T' ; name of <null>Tn
mov al,taklev ; Take level digit
add al,'0' ; add ascii bias
mov rdbuf+3,al ; last of the name
push di
mov di,offset rdbuf ; pointer for remtab
call remtab ; remove possible old macro
pop di
mov bx,[bx].takhnd ; get file handle
mov ah,close2 ; close file
int dos
; both disk and macro Takes
takclo1:dec taklev ; pop Take level
mov ah,taklev ; get current Take level
mov intake,ah ; remember here for later callers
sub takadr,size takinfo ; get previous Take's address
pop bx
pop ax
takclo2:ret
TAKCLOS ENDP
; add an entry to a keyword table
; enter with bx = table address, dx = ptr to new entry, macptr = string offset,
; mccptr = offset of free bytes in table mcctab.
; no check is made to see if the entry fits in the table.
addtab proc near
push cx
push si
push es
cld
mov ax,ds
mov es,ax ; address data segment
mov bp,bx ; remember where tbl starts
mov cl,[bx] ; pick up length of table
mov ch,0
inc bx ; point to actual table
jcxz addta4 ; cx = 0 if table is presently empty
addta1: push cx ; preserve count
mov si,dx ; point to entry
lodsb ; get length of new entry
mov cl,[bx] ; and length of table entry
mov ah,0 ; assume they're the same size
cmp al,cl ; are they the same?
lahf ; remember result of comparison
jae addta2 ; is new smaller? no, use table length
mov cl,al ; else use length of new entry
addta2: mov ch,0
lea di,[bx+1] ; point to actual keyword
repe cmpsb ; compare strings
pop cx ; restore count
jb addta4 ; below, insert before this one
jne addta3 ; not below or same, keep going
sahf ; same. get back result of length comparison
jb addta4 ; if new len is smaller, insert here
jne addta3 ; if not same size, keep going
mov si,bx ; else this is where entry goes
jmp short addta6 ; no insertion required
addta3: mov al,[bx]
mov ah,0
add bx,ax ; skip this entry
add bx,4 ; len + $ + value
loop addta1 ; and keep looking
addta4: mov si,bx ; this is first location to move
mov di,bx
inc ds:byte ptr [bp] ; remember we're adding one
jcxz addta6 ; no more entries, forget this stuff
mov bh,0 ; this stays 0
addta5: mov bl,[di] ; get length
lea di,[bx+di+4] ; end is origin + length + 4 for len, $, value
loop addta5 ; loop thru remaining keywords
mov cx,di
sub cx,si ; compute # of bytes to move
push si ; preserve loc for new entry
mov si,di ; first to move is last
dec si ; minus one
mov di,dx ; new entry
mov bl,[di] ; get length
lea di,[bx+si+4] ; dest is source + length of new + 4
std ; move backward
rep movsb ; move the table down (compress it)
cld ; put flag back
pop si
addta6: mov di,si ; this is where new entry goes
mov si,dx ; this is where it comes from
mov cl,[si] ; length
mov ch,0
add cx,1 ; include count byte
add mccptr,cx ; update free space pointer: cnt+name
add mccptr,3 ; plus '$' and pointer to string
rep movsb ; stick it in
mov al,'$' ; add printing terminator
stosb
mov ax,macptr ; and string offset
stosw
pop es
pop si
pop cx
ret
addtab endp
; If new keyword matches an existing one then remove existing keyword,
; its string definition, compress tables mcctab and macbuf, readjust string
; pointers for each macro name, reduce number of macro table entries by one.
; DO MAC pointer (domacptr) is adjusted to follow deletion.
; Enter with DI pointing at length byte of mac name (followed by mac name).
; Otherwise, exit with no changes. 13 June 1987 [jrd]
remtab proc near
push ax
push bx
push cx
push si
push di
mov bx,offset mcctab+1 ; table of macro keywords
mov temp,0 ; temp = current keyword
cmp byte ptr mcctab,0 ; any macros defined?
jne remta1 ; ne = yes
jmp remtax ; else exit now
remta1: ; match table keyword and text word
mov si,di ; pointer to user's cnt+name
mov cl,[si] ; length of user's macro name
xor ch,ch
inc si ; point to new macro name
cmp cl,[bx] ; compare length vs table keyword
jne remta4 ; ne = not equal lengths, try another
push si ; lengths match, how about spelling?
push bx
inc bx ; point at start of keyword
remta2: mov ah,[bx] ; keyword char
mov al,[si] ; new text char
cmp al,ah ; test characters
jne remta3 ; ne = no match
inc si ; move to next char
inc bx
loop remta2 ; loop through entire length
remta3: pop bx
pop si
jcxz remta6 ; z: cx = 0, exit with match;
; else select next keyword
remta4: inc temp ; number of keyword to test next
mov cx,temp
cmp cl,mcctab ; all done? Recall, temp starts at 0
jb remta5 ; b = not yet
jmp remtax ; exhausted search, unsuccessfully
remta5: mov al,[bx] ; cnt (keyword length from macro)
xor ah,ah
add ax,4 ; skip over '$' and two byte value
add bx,ax ; bx = start of next keyword slot
jmp remta1 ; do another comparison
; new name already present as a macro
remta6: cld ; clear macro string and macro name
push ds
pop es ; set es to datas segment
mov temp,bx ; save ptr to found keyword
mov al,[bx] ; cnt (keyword length of macro)
xor ah,ah
add ax,2 ; skip cnt and '$'
add bx,ax ; point to string offset field
add ax,2 ; count offset field bytes
sub mccptr,ax ; readjust free space ptr for names
push bx
mov bx,[bx]
mov temp1,bx ; temp1 = offset of old string
mov al,[bx] ; length of old string
xor ah,ah
inc ax ; plus its count byte
mov temp2,ax ; save here
pop bx
; clear keyword table mcctab
add bx,2 ; compute source = next keyword
mov si,bx ; address of next keyword
mov di,temp ; address of found keyword
mov cx,offset mcctab+mcclen ; address of buffer end
sub cx,si ; amount to move
jcxz remtax ; cx = 0 means none
rep movsb ; move down keywords (deletes current)
; revise other string offsets
mov si,offset mcctab ; table of string offsets
inc si ; skip count byte
mov cl,mcctab ; current number of table entries
xor ch,ch
dec mcctab ; one less keyword
mov dx,temp1 ; address of old string
remta7: mov al,[si] ; cnt of first keyword
add al,2 ; plus cnt and '$'
xor ah,ah
add si,ax ; look at string offset
cmp dx,[si] ; old address vs this string
ja remta8 ; a = address not affected
mov ax,temp2 ; size of old string
sub [si],ax ; adjust offset downward
remta8: add si,2 ; point to next table entry
loop remta7
cmp dx,domacptr ; DO <macro> definition affected?
ja remta8a ; a = no (occurs before removal)
mov ax,temp2 ; get length being removed from table
sub domacptr,ax ; revise pointer downward also
remta8a:mov cl,taklev ; consider all Take files
mov ch,0
jcxz remta9 ; z = no active Take file
; revise Take file def pointers
mov bx,takadr ; Take structure
remta8b:mov ax,[bx].takbuf ; pointer to definition
cmp dx,ax ; is this structure affected?
ja remta8d ; a = no
mov ax,temp2 ; length being removed from table
sub [bx].takbuf,ax ; adjust string structure downward
sub [bx].takptr,ax ; ditto for active read pointer
remta8d:sub bx,size takinfo ; preceeding Take file
loop remta8b
; remove old string
remta9: mov di,temp1 ; address of old string = destination
mov ax,temp2 ; size of old string field
mov si,di
add si,ax ; plus length: source = next string
sub macptr,ax ; readjust top of buf free string ptr
mov cx,offset macbuf+maclen ; end of buffer
sub cx,si ; number of bytes to move
jcxz remtax ; cx = 0 means none
rep movsb ; move old strings (garbage collect)
remtax: pop di
pop si
pop cx
pop bx
pop ax
ret
remtab endp
; Common Get keyword + Get Confirm sequence. Call with dx = keyword table,
; bx = help message offset. Returns result in BX. Modifies AX, BX and temp.
; Returns rskp if sucessful or ret if failure. Used in many places below.
keyend proc near
mov ah,cmkey
call comnd
ret
nop
nop
mov temp,bx
mov ah,cmcfm
call comnd
ret
nop
nop
mov bx,temp
jmp rskp
keyend endp
srvdsa proc near ; DISABLE Server commands
mov dx,offset srvdetab
; mov bx,offset sdshlp
mcmsgb sdshlp,csdshlp
call keyend
ret
nop
nop
or denyflg,bx ; turn on bit (deny) for that item
jmp rskp ; return successfully
srvdsa endp
srvena proc near ; ENABLE Server commands
mov dx,offset srvdetab ; keyword table
; mov bx,offset sdshlp ; help on keywords
mcmsgb sdshlp,csdshlp
call keyend
ret
nop
nop
not bx ; invert bits
and denyflg,bx ; turn off (enable) selected item
jmp rskp
srvena endp
; This is the SET command
; Called analyzers return rskp for success, else ret for failure
SETCOM PROC NEAR ; Dispatch all SET commands from here
mov kstatus,0 ; global status, success
mov dx,offset settab ; Parse a keyword from the set table
; mov bx,offset sethlp
mcmsgb sethlp,csethlp
mov ah,cmkey
call comnd
ret
nop
nop
jmp bx ; execute analyzer routine
; returns rskp for success, else ret
SETCOM endp
; SET BAUD or SET SPEED
BAUDST PROC NEAR
mov dx,offset bdtab
mov bx,0
call keyend
ret
nop
nop
mov si,portval
mov ax,[si].baud ; Remember original value
mov [si].baud,bx ; Set the baud rate
call dobaud ; Use common code
jmp rskp
BAUDST ENDP
; SET BELL on or off
BELLST PROC NEAR
mov dx,offset ontab
mov bx,0
call keyend
ret
nop
nop
mov flags.belflg,bl
jmp rskp
BELLST ENDP
; SET BLOCK-CHECK
BLKSET PROC NEAR
mov dx,offset blktab
mov bx,0
call keyend
ret
nop
nop
mov trans.chklen,bl ; Use this char as the handshake
mov inichk,bl ; Save here too
jmp rskp
BLKSET ENDP
; SET COUNTER number for script IF COUNTER number <command>
TAKECTR PROC NEAR
mov min,0 ; get decimal char code
mov max,65535 ; range is 0 to 65535 decimal
mov numhlp,offset takchlp ; help message
;-------------- Sept.12,1990 [zqf]
cmp isccdos,0 ; if in CCDOS ?
je takect1 ; e = no. in MSDOS
mov numhlp,offset ctakchlp ; help message
takect1:
;--------------
mov numerr,0 ; error message
call num0 ; convert number, return it in ax
jc takect2 ; c = error
mov temp,ax ; recover numerical code
mov ah,cmcfm
call comnd ; Get a confirm
ret ; Didn't get a confirm
nop
nop
mov ax,temp ; recover bx
cmp taklev,0 ; in a Take file?
je takect4 ; e = no
push bx
mov bx,takadr
mov [bx].takctr,ax ; set COUNT value
pop bx
takect2:jmp rskp
takect4:
; mov dx,offset takcerr ; say must be in Take file
mcmsg takcerr,ctakcerr
jmp reterr ; display msg and jmp rskp
TAKECTR ENDP
; SET DEBUG {OFF | ON | SESSSION | PACKETS}
DEBST PROC NEAR
mov dx,offset debtab
; mov bx,offset debhlp
mcmsgb debhlp,cdebhlp
call keyend
ret
nop
nop
or flags.debug,bl ; set the mode, except for Off
cmp bx,0 ; OFF?
jne deb0 ; ne = no
mov flags.debug,0 ; Set the DEBUG flags off
deb0: jmp rskp
DEBST ENDP
; SET DESTINATION of incoming files
DESSET PROC NEAR
mov dx,offset destab
mov bx,0
call keyend
ret
nop
nop
mov flags.destflg,bl ; Set the destination flag
cmp bl,2 ; Is dest the screen?
jne desa ; No, then done
mov flags.xflg,1 ; Remember it here
jmp rskp
desa: mov flags.xflg,0 ; Don't write to screen
jmp rskp
DESSET ENDP
; SET DEFAULT-DISK for sending/receiving, etc
; See cwdir in file mssker
; SET DELAY seconds Used only for SEND command in local mode
SETDELY PROC NEAR
mov min,0 ; smallest acceptable value
mov max,63 ; largest acceptable value
mov numhlp,offset delyhlp ; help message
;-------------- Sept.12,1990 [zqf]
cmp isccdos,0 ; if in CCDOS ?
je setdly2 ; e = no. in MSDOS
mov numhlp,offset cdelyhlp ; help message
setdly2:
;--------------
mov numerr,0 ; complaint message
call num0 ; parse numerical input
jc setdly1 ; c = error
mov trans.sdelay,al
setdly1:jmp rskp ; success or failure
SETDELY ENDP
; SET DISPLAY Quiet/Regular/Serial/7-Bit/8-Bit (inverse of Set Remote on/off)
; Accepts two keywords in one command
disply proc near
mov ah,cmkey
mov dx,offset distab
; mov bx,offset dishlp
mcmsgb dishlp,cdishlp
call comnd
ret
nop
nop
mov temp1,bx ; save parsed value
mov temp2,0ffffh ; assume no second keyword
mov comand.cmcr,1 ; bare CR's are allowed
mov ah,cmkey ; parse for second keyword
mov dx,offset distab
; mov bx,offset dishlp
mcmsgb dishlp,cdishlp
call comnd
jmp short displ1 ; no keyword
nop
mov temp2,bx ; get key value
displ1: mov comand.cmcr,0 ; bare CR's are not allowed
mov ah,cmcfm
call comnd ; confirm
ret ; return on failure
nop
nop
mov ax,temp1 ; examine first key value
call dispcom ; do common code
mov ax,temp2 ; examine second key value
call dispcom
jmp rskp
dispcom:cmp ax,0 ; check range
jle displ3 ; le = not legal, ignore
cmp al,7 ; 7-8 bit value?
jge displ2 ; ge = yes
and flags.remflg,not(dquiet+dregular+dserial)
or flags.remflg,al ; set display mode
ret ; check next key value
displ2: cmp al,8 ; set 8-bit wide display?
ja displ3 ; a = bad value
and flags.remflg,not d8bit ; assume want 7 bit mode
cmp al,7 ; really want 7 bit mode?
je displ3 ; e = yes
or flags.remflg,d8bit ; set 8 bit flag
displ3: ret ; end of display common code
disply endp
; Set Dump filename for saving screen images on disk. [jrd]
; Puts filename in global string dmpname
setdmp proc near
mov dx,offset rdbuf ; work area
mov rdbuf,0 ; clear it
; mov bx,offset dmphlp ; help message
mcmsgb dmphlp,cdmphlp
mov ah,cmfile ; allow paths
call comnd
ret
nop
nop
mov ah,cmcfm
call comnd
ret
nop
nop
mov dx,offset rdbuf ; assume we will use this text
call strlen ; filename given?
mov si,dx ; for strcpy
cmp cx,0 ; length of user's filename
jg setdmp1 ; g = filename is given
mov si,offset dmpdefnam ; no name, use default instead
setdmp1:mov di,offset dmpname ; copy to globally available loc
call strcpy
jmp rskp
setdmp endp
; SET EOF
SETEOF PROC NEAR
mov bx,0
mov dx,offset seoftab
call keyend
ret
nop
nop
mov flags.eofcz,bl ; set value
jmp rskp
SETEOF ENDP
; SET EOL char (for Sent packets)
; Archic, here for downward compatibility
EOLSET PROC NEAR
mov stflg,'S' ; set send/receive flag to Send
jmp sreol ; use Set Send/Rec routine do the work
EOLSET ENDP
; SET ERRORLEVEL number
SETERL PROC NEAR
mov numhlp,offset erlhlp ; help
;-------------- Sept.12,1990 [zqf]
cmp isccdos,0 ; if in CCDOS ?
je seterl2 ; e = no. in MSDOS
mov numhlp,offset cerlhlp ; help message
seterl2:
;--------------
mov numerr,0 ; error message
mov min,0 ; smallest number
mov max,255 ; largest magnitude
call num0 ; parse numerical input
jc seterl1 ; c = error
mov errlev,al ; store result
seterl1:jmp rskp ; success or failure
SETERL ENDP
; SET ESCAPE character.
; Accept literal control codes and \### numbers. [jrd] 18 Oct 1987
ESCSET PROC NEAR
mov ah,cmfile
mov dx,offset rdbuf ; work space
mov word ptr rdbuf,0 ; clear it
; mov bx,offset eschlp ; help
mcmsgb eschlp,ceschlp
call comnd
ret
nop
nop
cmp ah,0 ; anything given?
jne escse1 ; ne = yes
; mov dx,offset ermes6 ; more parameters needed
mcmsg ermes6,cermes6
jmp reterr
escse1: mov ah,cmcfm ; get a confirm
call comnd
ret
nop
nop
mov si,offset rdbuf ; source of chars
call katoi ; convert escaped numbers to binary
cmp ax,spc ; is it a control code?
jae escse2 ; ae = no, complain
cmp ax,0 ; non-zero too?
je escse2 ; e = zero
mov trans.escchr,al ; Save new value.
jmp rskp
escse2:
; mov dx,offset escerr
mcmsg escerr,cescerr
jmp reterr
ESCSET ENDP
SETATT PROC NEAR ; Set attributes on | off
mov dx,offset ontab
mov bx,0
call keyend
ret
nop
nop
mov flags.attflg,bl
jmp rskp
SETATT ENDP
; SET FILEWARNING
FILWAR PROC NEAR
mov dx,offset ontab
mov bx,0
call keyend
ret
nop
nop
mov flags.flwflg,bl ; Set the filewarning flag
jmp rskp
FILWAR ENDP
; SET FLOW-CONTROL
FLOSET PROC NEAR
mov dx,offset flotab
xor bx,bx
call keyend
ret
nop
nop
mov si,portval
mov [si].flowc,bx ; Flow control value
mov [si].floflg,bl ; Say if doing flow control
jmp rskp
FLOSET ENDP
; SET HANDSHAKE
; Add ability to accept general decimal code. [jrd]
HNDSET PROC NEAR
mov dx,offset hndtab ; table to scan
; mov bx,offset hnd1hlp ; help message
mcmsgb hnd1hlp,chnd1hlp
mov ah,cmkey
call comnd
ret
nop
nop
cmp bl,0ffh ; want a general char code?
jne hnd1 ; ne = no
mov min,0 ; get decimal char code
mov max,31 ; range is 0 to 31 decimal
mov numhlp,offset ctlhlp ; help message
;-------------- Sept.12,1990 [zqf]
cmp isccdos,0 ; if in CCDOS ?
je hnd3 ; e = no. in MSDOS
mov numhlp,offset cctlhlp ; help message
hnd3:
;--------------
mov numerr,0 ; error message
call num0 ; convert number, return it in ax
jc hnd2 ; c = error
mov bx,ax ; recover numerical code
hnd1:
mov temp,bx ; handshake type
mov ah,cmcfm
call comnd ; Get a confirm
ret ; Didn't get a confirm
nop
nop
mov bx,temp ; recover bx
mov si,portval
cmp bl,0 ; Setting handshake off?
je hnd0 ; Yes
mov [si].hndflg,1 ; And turn on handshaking
mov [si].hands,bl ; Use this char as the handshake
jmp rskp
hnd0: mov [si].hndflg,0 ; No handshaking
hnd2: jmp rskp
HNDSET ENDP
; SET INCOMPLETE file disposition
ABFSET PROC NEAR
mov dx,offset abftab
mov bx,0
call keyend
ret
nop
nop
mov flags.abfflg,bl ; Set the aborted file flag
jmp rskp
ABFSET ENDP
;
; Set Input commands (default-timeout, timeout-action, case, echo)
; By Jim Strudevant [jrs]
INPSET PROC NEAR
mov ah,cmkey ; key word
mov dx,offset inptab ; from inputtable
mov bx,0 ; no hints
call comnd ; get the word
ret ; they blew it
nop
nop
jmp bx ; do the sub command
;
; Set Input Default-timeout in seconds
;
inptmo: mov numhlp,offset intoms ; help
;-------------- Sept.12,1990 [zqf]
cmp isccdos,0 ; if in CCDOS ?
je inptmo2 ; e = no. in MSDOS
mov numhlp,offset cintoms ; help message
inptmo2:
;--------------
mov numerr,0 ; error message
mov min,0 ; smallest number
mov max,-1 ; largest magnitude
call num0 ; parse numerical input
jc inptmo1 ; c = error
mov script.indfto,ax ; store result
inptmo1:jmp rskp ; success or failure
;
; Set Input Timeout action (proceed or quit)
;
inpact: mov dx,offset inactb ; from this list
mov bx,0 ; no hints
call keyend ; get it
ret ; bad input
nop
nop
mov script.inactv,bl ; save the action
jmp rskp ; good return
;
; Set Input Echo on or off
;
inpeco: mov dx,offset ontab ; from this list
mov bx,0 ; no hints
call keyend ; get it
ret ; bad input
nop
nop
mov script.inecho,bl ; save the action
jmp rskp ; good return
;
; Set Input Case observe or ignore
;
inpcas: mov dx,offset incstb ; from this list
mov bx,0 ; no hints
call keyend ; get it
ret ; bad input
nop
nop
mov script.incasv,bl ; save the action
jmp rskp ; good return
INPSET ENDP
; SET KEY
; Jumps to new Set Key routine
setkey proc near
cmp stkadr,0 ; keyboard translator present?
je setk4 ; e = no, use this routine
mov bx,stkadr ; yes, get offset of procedure
jmp bx ; jump to keyboard translator
setk4:
; mov dx,offset ermes5
mcmsg ermes5,cermes5
jmp reterr ; else print error message
setkey endp
; SET LOCAL-ECHO {ON | OFF}
LCAL PROC NEAR
mov dx,offset ontab
mov bx,0
call keyend
ret
nop
nop
mov si,portval
mov [si].ecoflg,bl ; Set the local echo flag
jmp rskp
LCAL ENDP
; LOG {PACKETS | SESSION | TRANSACTION} filename
setcpt proc near
mov dx,offset logtab ; kinds of logging
; mov bx,offset loghlp ; help on kind of logging
mcmsgb loghlp,cloghlp
mov ah,cmkey ; parse keyword
call comnd
ret
nop
nop
mov temp,bx ; Save the parsed value
mov dx,offset rdbuf ; holds the complete filename
mov rdbuf,0 ; clear buffer
; mov bx,offset filhlp ; ask for filename
mcmsgb filhlp,cfilhlp
mov ah,cmfile ; allow paths
call comnd
ret
nop
nop
mov ah,cmcfm
call comnd ; Get a confirm
ret ; Didn't get a confirm
nop
nop
mov bx,temp ; recover kind of logging
mov dx,offset rdbuf ; length of filename to cx
call strlen ; length of given filename
test bl,logpkt ; packet logging?
jz setcp2 ; z = no, try others
mov dx,offset lpktnam ; filename
jcxz setcp1 ; z = no filename given
mov si,offset rdbuf ; get new name
mov di,dx ; destination
call strcpy ; replace old name
setcp1: cmp ploghnd,-1 ; packet log file already open?
je setcp6 ; e = no, open it
jmp setcp16 ; say file is open already
setcp2: test bl,logses ; session logging?
jz setcp4 ; z = no, try others
mov dx,offset lsesnam ; use default name
jcxz setcp3 ; z = no filename given
mov si,offset rdbuf ; get new name
mov di,dx ; destination
call strcpy ; replace old name
setcp3: cmp sloghnd,-1 ; transaction file already open?
je setcp6 ; e = no, open it
jmp setcp16 ; say file is open already
setcp4: test bl,logtrn ; transaction logging?
jz setcp14 ; z = no, error
mov dx,offset ltranam ; use default name
jcxz setcp5 ; z = no filename given
mov si,offset rdbuf ; get new name
mov di,dx ; destination
call strcpy ; replace old name
setcp5: cmp tloghnd,-1 ; transaction file already open?
je setcp6 ; e = no, open it
jmp setcp16 ; say file is open already
setcp6: mov ax,dx ; place for filename for isfile
call isfile ; does file exist already?
jc setcp7 ; c = does not exist so use create
test byte ptr filtst.dta+21,1fh ; file attributes, ok to write?
jnz setcp14 ; nz = no, use error exit
mov ah,open2 ; open existing file
mov al,1+1 ; for writing and reading
int dos
jc setcp14 ; if carry then error
mov bx,ax ; file handle for seeking
mov cx,0 ; high order displacement
mov dx,0 ; low order part of displacement
mov ah,lseek ; seek to EOF (to do appending)
mov al,2 ; says to EOF
int dos
jmp short setcp8
setcp7: test filtst.fstat,80h ; access problem?
jnz setcp14 ; nz = yes, stop here
mov ah,creat2 ; function is create
mov cl,20H ; turn on archive bit
mov ch,0
int dos ; create the file, DOS 2.0
jc setcp14 ; if carry bit set then error
mov bx,ax ; file handle
setcp8: cmp temp,logpkt ; packet logging?
jne setcp9 ; ne = no
mov ploghnd,bx ; save transaction log handle here
jmp short setcp12
setcp9: cmp temp,logses ; session logging?
jne setcp10 ; ne = no
mov sloghnd,bx ; save session log handle here
jmp short setcp12
setcp10:mov tloghnd,bx ; save transaction log handle here
setcp12:mov ax,temp ; kind of Logging
or flags.capflg,al ; accumulate kinds of logging
jmp rskp ; and return
setcp14:
; mov dx,offset errcap ; give error message
mcmsg errcap,cerrcap
jmp reterr ; and display it
setcp16:mov ah,prstr ; file already open
; mov dx,offset erropn
mcmsg erropn,cerropn
int dos
jmp rskp ; return success
setcpt endp
; SET MODE LINE
MODL PROC NEAR
mov dx,offset ontab ; parse an on or off
mov bx,0 ; no special help
call keyend
ret
nop
nop
mov flags.modflg,bl ; set flag appropriately
jmp rskp
MODL ENDP
; SET PARITY
SETPAR PROC NEAR
mov dx,offset partab
mov bx,0
call keyend
ret
nop
nop
mov si,portval
mov [si].parflg,bl ; Set the parity flag
cmp bl,parnon ; Resetting parity to none?
je setp0 ; e = yes, reset 8 bit quote character
mov trans.ebquot,dqbin ; we want quoting, active
mov dtrans.ebquot,dqbin ; we want quoting, our default
jmp short setp1
setp0: mov trans.ebquot,'Y' ; say will quote upon request
mov dtrans.ebquot,'Y' ; and our default
setp1: jmp rskp
SETPAR ENDP
; SET PROMPT Allow user to change the "Kermit-MS>" prompt
; {string} and \number notation permitted to represent special chars. [jrd]
PROMSET PROC NEAR
mov ah,cmtxt
mov bx,offset rdbuf ; Read in the prompt
mov word ptr [bx],0 ; clear buffer
; mov dx,offset prmmsg
mcmsg prmmsg,cprmmsg
call comnd
ret
nop
nop
cmp rdbuf,0 ; Just a bare CR?
jne prom0 ; ne = no
mov ax,offset kerm ; yes, restore default prompt
jmp prom1
prom0: push si ; parse \### constants into
push di ; 1 byte binary numbers inline
mov si,offset rdbuf ; source = new prompt string
mov byte ptr [si-1+length rdbuf],0 ; plant null terminator
mov di,offset prm ; destination
call cnvlin ; convert \### in string to binary
pop di
pop si
mov bx,cx ; get byte count
add bx,offset prm ; point to null terminator
mov byte ptr [bx],'$' ; End of string
mov ax,offset prm
prom1: mov prmptr,ax ; Remember it
jmp rskp
PROMSET ENDP
; SET SERVER TIMEOUT
SETSRV PROC NEAR
mov dx,offset srvtab ; set server table
mov bx,0 ; use table for help
mov ah,cmkey ; get keyword
call comnd
ret
nop
nop
mov min,0 ; smallest acceptable value
mov max,255 ; largest acceptable value, one byte
mov numhlp,offset srvthlp ; help message
;-------------- Sept.12,1990 [zqf]
cmp isccdos,0 ; if in CCDOS ?
je setsrv2 ; e = no. in MSDOS
mov numhlp,offset csrvthlp ; help message
setsrv2:
;--------------
mov numerr,0 ; complaint message
call num0 ; parse numerical input
jc setsrv1 ; c = error
mov srvtmo,al ; store timeout value
setsrv1:jmp rskp
SETSRV ENDP
; SET RETRY value. Changes the packet retry limit. [jrd]
RETRYSET PROC NEAR
mov min,1 ; smallest acceptable value
mov max,63 ; largest acceptable value
mov numhlp,offset retryhlp ; help message
;-------------- Sept.12,1990 [zqf]
cmp isccdos,0 ; if in CCDOS ?
je retrys2 ; e = no. in MSDOS
mov numhlp,offset cretryhlp ; help message
retrys2:
;--------------
mov numerr,0 ; complaint message
call num0 ; parse numerical input
jc retrys1 ; c = error
mov maxtry,al
shl al,1 ; quick multiply by two or three
mov imxtry,al ; keep that much
add al,maxtry ; try three times
js retrys1 ; s = sign bit set, too much
mov imxtry,al ; I packets get 3 times as many tries
retrys1:jmp rskp
RETRYSET ENDP
; SET TAKE-ECHO on or off
TAKSET PROC NEAR
mov dx,offset ontab
mov bx,0
call keyend
ret
nop
nop
mov flags.takflg,bl
jmp rskp
TAKSET ENDP
; SET TIMER on or off during file transfer
TIMSET PROC NEAR
mov dx,offset ontab
mov bx,0
call keyend
ret
nop
nop
mov flags.timflg,bl
jmp rskp
TIMSET ENDP
; SET SEND parameters
SENDSET PROC NEAR
mov stflg,'S' ; Setting SEND parameter
sndst0: mov dx,offset stsrtb ; Parse a keyword
mov bx,0 ; no specific help
mov ah,cmkey
call comnd
ret ; bad user text
nop
nop
jmp bx ; do the action routine
SENDSET ENDP
; SET RECEIVE parameters
recset: mov stflg,'R' ; Setting RECEIVE paramter
jmp sndst0
remset proc near ; Set REMOTE ON/OFF
mov dx,offset ontab
; mov bx,offset remhlp
mcmsgb remhlp,cremhlp
call keyend
ret
nop
nop
and flags.remflg,not (dquiet+dserial+dregular) ; no display bits
or bl,bl ; want off state? (same as regular)
jz remset1 ; z = yes
or flags.remflg,dquiet ; else on = quiet display
jmp short remset2
remset1:or flags.remflg,dregular ; off = regular display
remset2:jmp rskp
remset endp
; SET Send and Receive EOL char
sreol PROC NEAR
mov min,0 ; lowest acceptable value
mov max,1FH ; largest acceptable value
mov numhlp,offset ctlhlp ; Reuse help message
;-------------- Sept.12,1990 [zqf]
cmp isccdos,0 ; if in CCDOS ?
je sreol4 ; e = no. in MSDOS
mov numhlp,offset cctlhlp ; help message
sreol4:
;--------------
mov numerr,0 ; error message address
call num0 ; get numerical input
jc sreol3 ; c = error
cmp stflg,'S' ; Setting SEND paramter?
je sreol1
mov trans.reol,al
jmp short sreol2
sreol1: mov dtrans.seol,al
sreol2: mov ah,dtrans.seol
mov trans.seol,ah
sreol3: jmp rskp
sreol ENDP
; SET SEND and RECEIVE start-of-header
srsoh: mov min,0
mov max,1FH
mov numhlp,offset ctlhlp ; Reuse help message
;-------------- Sept.12,1990 [zqf]
cmp isccdos,0 ; if in CCDOS ?
je srsoh3 ; e = no. in MSDOS
mov numhlp,offset cctlhlp ; help message
srsoh3:
;--------------
mov numerr,0 ; error message
call num0 ; Common routine for parsing numerical input
jc srsoh2 ; c = error
cmp stflg,'S' ; Setting SEND paramter?
je srsoh1
mov trans.rsoh,al ; set Receive soh
jmp short srsoh2
srsoh1: mov trans.ssoh,al ; set Send soh
srsoh2: jmp rskp ; success or failure
; SET SEND and RECEIVE TIMEOUT
srtim: mov min,0
mov max,94
mov numhlp,offset timhlp ; Reuse help message
;-------------- Sept.12,1990 [zqf]
cmp isccdos,0 ; if in CCDOS ?
je srtim4 ; e = no. in MSDOS
mov numhlp,offset ctimhlp ; help message
srtim4:
;--------------
mov numerr,0 ; error message
call num0 ; Common routine for parsing numerical input
jc srtim3 ; c = error
cmp stflg,'S' ; Setting SEND paramter?
je srtim1
mov trans.rtime,al
jmp short srtim2
srtim1: mov dtrans.stime,al
srtim2: mov ah,dtrans.stime
mov trans.stime,ah
srtim3: jmp rskp
; SET SEND and RECEIVE PACKET LENGTH
srpack: mov min,20
mov max,maxpack
mov numhlp,offset pakhlp ; help
;-------------- Sept.12,1990 [zqf]
cmp isccdos,0 ; if in CCDOS ?
je srpak5 ; e = no. in MSDOS
mov numhlp,offset cpakhlp ; help message
srpak5:
;--------------
mov numerr,offset pakerr ; error message
;-------------- Sept.12,1990 [zqf]
cmp isccdos,0 ; if in CCDOS ?
je srpak6 ; e = no. in MSDOS
mov numerr,offset cpakerr ; help message
srpak6:
;--------------
call num0
jc srpak2 ; c = error
cmp stflg,'S' ; setting send value?
jne srpakr ; ne = receive
mov trans.slongp,ax ; set send value
mov trans.slong,ax ; and remember what we Set
cmp ax,94 ; within normal packet range?
ja srpak2 ; a = no
mov trans.spsiz,al ; yes. update regular pkt size too
srpak2: jmp rskp ; success or failure
srpakr: mov trans.rlongp,ax ; set receive value
cmp ax,94 ; within normal packet range?
ja srpak4 ; a = no
mov trans.rpsiz,al ; yes. update regular pkt size too
srpak4: jmp rskp
; SET SEND and RECEIVE number of padding characters
srnpd: mov min,0
mov max,99
mov numhlp,offset padhlp ; help message
;-------------- Sept.12,1990 [zqf]
cmp isccdos,0 ; if in CCDOS ?
je srnpd4 ; e = no. in MSDOS
mov numhlp,offset cpadhlp ; help message
srnpd4:
;--------------
mov numerr,0 ; error message
call num0 ; Parse numerical input
jc srnpd3 ; c = error
cmp stflg,'S' ; Setting SEND paramter?
je srnpd1 ; e = yes
mov trans.rpad,al ; set Receive padding
jmp short srnpd2
srnpd1: mov dtrans.spad,al ; set default Send padding
srnpd2: mov al,dtrans.spad
mov trans.spad,al ; update active array for I and S pkts
srnpd3: jmp rskp ; success or failure
; SET SEND and RECEIVE padding character
srpad: mov min,0
mov max,127
mov numhlp,offset padhlp
;-------------- Sept.12,1990 [zqf]
cmp isccdos,0 ; if in CCDOS ?
je srpad5 ; e = no. in MSDOS
mov numhlp,offset cpadhlp ; help message
srpad5:
;--------------
mov numerr,offset padhlp
;-------------- Sept.12,1990 [zqf]
cmp isccdos,0 ; if in CCDOS ?
je srpad6 ; e = no. in MSDOS
mov numerr,offset cpadhlp ; help message
srpad6:
;--------------
call num0 ; Parse numerical input
jc srpad4 ; c = error
cmp ah,127 ; This is allowed
je srpad1
cmp ah,32
jb srpad1 ; Between 0 and 31 is OK too
mov ah,prstr
; mov dx,offset padhlp
mcmsg padhlp,cpadhlp
int dos
srpad1: cmp stflg,'S' ; Send?
je srpad2 ; e = yes, else Receive
mov trans.rpadch,al ; store receive pad char
jmp short srpad3
srpad2: mov dtrans.spadch,al ; store Send pad char
srpad3: mov ah,dtrans.spadch
mov trans.spadch,ah ; update active array for I and S pkts
srpad4: jmp rskp
; SET SEND and RECEIVE control character prefix
srquo: mov min,33
mov max,126
mov numhlp,offset quohlp ; help message
;-------------- Sept.12,1990 [zqf]
cmp isccdos,0 ; if in CCDOS ?
je srquo4 ; e = no. in MSDOS
mov numhlp,offset cquohlp ; help message
srquo4:
;--------------
mov numerr,0 ; error message
call num0 ; Parse numerical input
jc srquo3 ; c = error
cmp stflg,'S' ; Setting outgoing quote char?
je srquo1
mov trans.rquote,al ; set Receive quote char
jmp short srquo2
srquo1: mov dtrans.squote,al ; set Send quote char
srquo2: mov ah,dtrans.spadch
mov trans.spadch,ah ; update active array for I and S pkts
srquo3: jmp rskp
; SET SEND Pause number of milliseconds
srpaus: mov min,0
mov max,127
mov numhlp,offset pauhlp ; help
;-------------- Sept.12,1990 [zqf]
cmp isccdos,0 ; if in CCDOS ?
je srpau4 ; e = no. in MSDOS
mov numhlp,offset cpauhlp ; help message
srpau4:
;--------------
mov numerr,0
call num0 ; Parse numerical input
pushf ; save carry for error state
cmp stflg,'S' ; Setting SEND paramter?
je srpau0
popf
; mov dx,offset ermes5 ; "Not implemented" msg
mcmsg ermes5,cermes5
jmp reterr ; print error message
srpau0: popf
jc srpau1 ; c = error
mov spause,al ; store value
srpau1: jmp rskp
; SET TRANSLATION INPUT Connect mode translate incoming characters
; SET TRANS IN {Original-byte New-byte | ON | OFF}
SETRX PROC NEAR ; translate incoming serial port char
mov ah,cmkey
mov dx,offset trnstab ; direction table (just one entry)
mov bx,0 ; no help
call comnd
ret
nop
nop
mov dx,offset rdbuf ; our work space
mov word ptr rdbuf,0 ; insert terminator
; mov bx,offset srxhlp1 ; first help message
mcmsgb srxhlp1,csrxhlp1
mov ah,cmfile ; parse a word
call comnd ; get incoming byte pattern
ret ; error if none
nop
nop
or ah,ah ; any text given?
jz setr6 ; nz = no
mov temp,ax ; save byte count here
mov ax,word ptr rdbuf ; get first two characters
or ax,2020h ; convert upper to lower case
cmp ax,'fo' ; first part of word OFF?
je setr6 ; e = yes, go analyze
cmp ax,'no' ; word ON?
je setr6 ; e = yes, go do it
mov si,offset rdbuf ; convert text to number
call katoi ; number converter procedure, to ax
jnc setr1 ; nc = success
cmp byte ptr temp+1,1 ; just one character given?
jne setr6 ; ne = no, so bad code
setr1: mov min,ax ; save byte code here
mov dx,offset rdbuf ; our work space
mov word ptr rdbuf,0 ; insert terminator
; mov bx,offset srxhlp1 ; first help message
mcmsgb srxhlp1,csrxhlp1
mov ah,cmfile ; parse a word
call comnd ; get incoming byte pattern
ret
nop
nop
or ah,ah ; any text given?
jz setr6 ; z = no
mov temp,ax ; save byte count here
mov si,offset rdbuf ; convert text to number
call katoi ; number converter procedure
jnc setr3 ; nc = success
cmp byte ptr temp+1,1 ; just one character given?
jne setr6 ; ne = no, so bad code or ON/OFF
setr3: mov max,ax ; save byte code here
mov ah,cmcfm ; get a confirm
call comnd
ret ; no confirm
nop
nop
mov bx,min ; bl = incoming byte code
xor bh,bh
mov ax,max ; al = local (translated) byte code
mov rxtable [bx],al ; store in rx translate table
jmp rskp
setr6: mov ah,cmcfm ; get a confirm
call comnd
ret
nop
nop
; mov dx,offset badrx ; assume bad construction
mcmsg badrx,cbadrx
or word ptr rdbuf,2020h ; convert to lower case
or rdbuf+2,20h ; first three chars
cmp word ptr rdbuf,'fo' ; key word OFF?
jne setr8 ; ne = no
cmp rdbuf+2,'f' ; last letter of OFF?
jne setr8
mov rxtable+256,0 ; OFF is status byte = zero
; mov dx,offset rxoffmsg ; say translation is turned off
mcmsg rxoffmsg,crxoffmsg
jmp setr9
setr8: cmp word ptr rdbuf,'no' ; keyword ON?
jne setr9a ; ne = no, error
mov rxtable+256,1 ; ON is status byte non-zero
; mov dx,offset rxonmsg ; say translation is turned on
mcmsg rxonmsg,crxonmsg
setr9: cmp intake,0 ; executing from a Take file?
je setr9a ; e = no
cmp flags.takflg,0 ; echo contents of Take file?
je setr10 ; e = no
setr9a: mov ah,prstr ; bad number message
int dos
setr10: jmp rskp
SETRX ENDP
; SHOW TRANSLATE-RECEIVE
; Display characters being changed for Connect mode serial receive translator
SHORX PROC NEAR ; show translate table of incoming
; chars, only those changed
mov ah,cmcfm ; get a confirm
call comnd
ret ; no confirm
nop
nop
mov ah,prstr
; mov dx,offset rxoffmsg ; assume translation is off
mcmsg rxoffmsg,crxoffmsg
cmp rxtable+256,0 ; is translation off?
je shorx0 ; e = yes
; mov dx,offset rxonmsg ; say translation is on
mcmsg rxonmsg,crxonmsg
shorx0: int dos
; mov dx,offset shormsg ; give title line
mcmsg shormsg,cshormsg
int dos
xor cx,cx ; formatted line counter
xor bx,bx ; entry subscript
shorx1: cmp rxtable[bx],bl ; entry same as normal?
je shorx2 ; e = yes, skip it
call shoprt ; print the entry
shorx2: inc bx ; next entry
cmp bx,255 ; done all entries yet?
jbe shorx1 ; be = not yet
mov ah,prstr
mov dx,offset crlf ; end with cr/lf
int dos
jmp rskp
shoprt: cmp cx,4 ; done five entries for this line?
jb shopr1 ; b = no
mov ah,prstr
mov dx,offset crlf ; break line now
int dos
xor cx,cx
shopr1: mov ah,prstr
mov dx,offset shopm1 ; start of display
int dos
xor ah,ah
mov al,bl ; original byte code
call decout ; display its value
mov ah,prstr
mov dx,offset shopm2 ; intermediate part of display
int dos
xor ah,ah
mov al,rxtable[bx] ; new byte code
call decout ; display its value
mov ah,prstr
mov dx,offset shopm3 ; last part of display
int dos
inc cx ; count item displayed
ret
SHORX ENDP
; SHOW MACRO [macro name]
SHOMAC PROC NEAR
mov ah,cmfile
mov dx,offset rdbuf
; mov bx,offset shmmsg
mcmsgb shmmsg,cshmmsg
mov comand.cmper,1 ; don't react to \%x variables
call comnd
ret
nop
nop
mov al,ah
mov ah,0
mov shmcnt,ax ; save length of user spec
mov ah,cmcfm
call comnd
ret
nop
nop
mov si,offset mcctab ; table of macro names
cld
lodsb
mov cl,al ; number of macro entries
mov ch,0
jcxz shom6 ; z = none
mov temp,0 ; count of macros displayed
shom2: push cx ; save loop counter
lodsb ; length of macro name
mov ah,0
mov cx,shmcnt ; length of user's string
jcxz shom4 ; show all names
cmp al,cl ; mac name shorter that user spec?
jb shom5 ; b = yes, no match
push ax
push si ; save these around match test
mov di,offset rdbuf ; user's string
shom3: mov ah,[di]
inc di
lodsb ; al = mac name char, ah = user char
and ax,not 2020h ; clear bits (uppercase chars)
cmp ah,al ; same?
loope shom3 ; while equal, do more
pop si ; restore regs
pop ax
jne shom5 ; ne = no match
shom4: call shom9 ; show this name
shom5: add si,ax ; no match, skip name
add si,3 ; and '$', and string pointer
pop cx ; recover loop counter
loop shom2 ; one less macro to examine
cmp temp,0 ; did we show any macros?
jne shom7 ; ne = yes
shom6: mov ah,prstr
; mov dx,offset shom9m3 ; no entries found
mcmsg shom9m3,cshom9m3
int dos
shom7: mov ah,prstr ; Summary line
; mov dx,offset shom9m1 ; free space: name entries
mcmsg shom9m1,cshom9m1
int dos
mov ax,offset mcctab+mcclen
sub ax,mccptr ; compute # of free name bytes
call decout
mov ah,prstr
; mov dx,offset shom9m2 ; body characters
mcmsg shom9m2,cshom9m2
int dos
mov ax,offset macbuf+maclen
sub ax,macptr
call decout
mov ah,prstr
mov dx,offset crlf
int dos
jmp rskp ; return successfully to caller
; worker, show mac name and def
shom9: push ax ; call with si pointing at macro
push si ; name, byte ptr [si-1] = length
cmp byte ptr[si],0 ; name starts with null char?
je shom9e ; yes, TAKE file, ignore
mov ah,prstr
mov dx,offset crlfsp ; go to new line
int dos
inc temp ; count displayed macros
mov dx,si ; Print macro name
int dos
mov dx,offset eqs ; display equals sign
int dos
mov al,[si-1] ; length of macro name
mov ah,0
add si,ax ; skip over name
add si,1 ; skip '$' field
mov si,[si] ; si = offset of count + string
mov cl,byte ptr [si] ; length of string
mov ch,0
inc si ; si = offset of string text proper
shom9a: lodsb ; get a byte into al
cmp al,' ' ; control char?
jae shom9c ; ae = no
cmp al,cr ; carriage return?
jne shom9b ; ne = no
mov ah,prstr
mov dx,offset shom9m4 ; show <cr>
int dos
cmp cx,1 ; more to show?
je shom9d ; e = no
mov dx,offset crlfsp ; show cr,lf,space,space
int dos
cmp byte ptr[si],lf ; cr followed by linefeed?
jne short shom9d
inc si ; skip the leading lf
dec cx
jmp short shom9d
shom9b: push ax
mov ah,conout
mov dl,5eh ; caret
int dos
pop ax
add al,'A'-1 ; add offset to make printable letter
shom9c: mov ah,conout
mov dl,al ; display it
int dos
shom9d: loop shom9a ; do whole string
shom9e: pop si
pop ax
ret
SHOMAC ENDP
SHCOM PROC NEAR ; Show Modem
mov ah,cmcfm
call comnd ; Get a confirm
ret ; Didn't get a confirm
nop
nop
mov dx,offset crlf
mov ah,prstr
int dos ; print a crlf
; mov bx,offset stcom ; table of items to be shown
mcmsgb stcom,cstcom
call statc ; finish in common code
nop
nop
nop
call shomodem
nop
nop
nop
jmp rskp
SHCOM ENDP
SHFILE PROC NEAR ; Show File
mov ah,cmcfm
call comnd ; Get a confirm
ret ; Didn't get a confirm
nop
nop
mov dx,offset crlf
mov ah,prstr
int dos ; print a crlf
; mov bx,offset stfile ; table of items to be shown
mcmsgb stfile,cstfile
jmp statc ; finish in common code
SHFILE ENDP
SHLOG PROC NEAR ; Show Log
mov ah,cmcfm
call comnd ; Get a confirm
ret
nop
nop
mov dx,offset crlf
mov ah,prstr
int dos ; print a crlf
; mov bx,offset stlog ; table of items to be shown
mcmsgb stlog,cstlog
jmp statc ; finish in common code
SHLOG ENDP
SHPRO PROC NEAR ; Show Protocol
mov ah,cmcfm
call comnd ; Get a confirm
ret
nop
nop
mov dx,offset crlf
mov ah,prstr
int dos ; print a crlf
; mov bx,offset stpro ; table of items to be shown
mcmsgb stpro,cstpro
jmp statc ; finish in common code
SHPRO ENDP
SHSCPT PROC NEAR ; Show Script
mov ah,cmcfm
call comnd ; Get a confirm
ret
nop
nop
mov dx,offset crlf
mov ah,prstr
int dos ; print a crlf
; mov bx,offset stscpt ; table of items to be shown
mcmsgb stscpt,cstscpt
jmp statc ; finish in common code
SHSCPT ENDP
SHSERV PROC NEAR ; Show Server
mov ah,cmcfm
call comnd ; Get a confirm
ret
nop
nop
mov dx,offset crlf
mov ah,prstr
int dos ; print a crlf
; mov bx,offset stserv2 ; do heartbeak item
mcmsgb stserv2,cstserv2
call statc
nop
nop
nop
mov dx,offset crlf
mov ah,prstr
int dos
; mov bx,offset stserv ; table of items to be shown
mcmsgb stserv,cstserv
jmp statc ; finish in common code
SHSERV ENDP
SHTERM PROC NEAR ; Show Terminal
mov ah,cmcfm
call comnd ; Get a confirm
ret
nop
nop
mov dx,offset crlf
mov ah,prstr
int dos ; print a crlf
; mov bx,offset stterm ; table of items to be shown
mcmsgb stterm,cstterm
jmp statc ; use common code
SHTERM ENDP
; STATUS command. Revised by [jrd]
STATUS PROC NEAR
mov ah,cmcfm
call comnd ; Get a confirm
ret
nop
nop
mov dx,offset crlf
mov ah,prstr
int dos ; print a crlf
STAT0: call cmblnk ; clear the screen
call locate ; home the cursor
; mov bx,offset sttab ; table to control printing
mcmsgb sttab,csttab
STATC: push es ; STAT0 is an external ref (in mster)
push di
mov cx,ds
mov es,cx
cld
xor cx,cx ; column counter
stat1: cmp word ptr [bx],0 ; end of table?
je statx ; e = yes
cld ; string direction is forward
mov di,offset rdbuf ; point to destination buffer
mov byte ptr[di],spc ; start with two spaces
inc di
mov byte ptr[di],spc
inc di
push cx ; save column number
push bx
call [bx].sttyp ; call appropriate routine
pop bx
pop cx
sub di,offset rdbuf ; number of bytes used
add cx,di ; new line col count
push cx ; save col number around print
mov cx,di ; how much to print now
mov di,offset rdbuf ; source text
cmp cx,2 ; nothing besides our two spaces?
jbe stat5 ; e = yes, forget it
call prtscr ; print counted string
stat5: pop cx
add bx,size stent ; look at next entry
cmp word ptr [bx],0 ; at end of table?
je statx ; e = yes
cmp cx,38 ; place for second display?
jbe stat2 ; be = only half full
mov dx,offset crlf ; over half full. send cr/lf
mov ah,prstr
int dos
xor cx,cx ; say line is empty now
jmp stat1
stat2: mov ax,cx
mov cx,38 ; where we want to be next time
sub cx,ax ; compute number of filler spaces
or cx,cx
jle stat4 ; nothing to do
mov ah,conout
mov dl,' '
stat3: int dos ; fill with spaces
loop stat3 ; do cx times
stat4: mov cx,38 ; current column number
jmp stat1 ; and do it
statx: pop di
pop es
jmp rskp
STATUS ENDP
; handler routines for status
; all are called with di/ destination buffer, bx/ stat ptr. They can change
; any register except es:, must update di to the end of the buffer.
; copy the message into the buffer
stmsg proc near
push ds
pop es ; ensure es points to datas segment
mov si,[bx].msg ; get message address
stms1: lodsb ; get a byte
stosb ; drop it off
cmp al,'$' ; end of message?
jne stms1 ; no, keep going
dec di ; else back up ptr
ret
stmsg endp
; get address of test value in stent. Returns address in si
stval proc near
mov si,[bx].basval ; get base value
cmp si,0 ; any there?
je stva1 ; no, keep going
mov si,[si] ; yes, use as base address
stva1: add si,[bx].tstcel ; add offset of test cell
ret ; and return it
stval endp
; print a single character
onechr proc near
call stmsg ; copy message part first
call stval ; pick up test value address
mov al,[si] ; this is char to print
cmp al,' ' ; printable?
jae onech1 ; yes, keep going
add al,64 ; make printable
mov byte ptr [di],5eh ; caret
inc di ; note ctrl char
onech1: stosb ; drop char off
ret
onechr endp
; numeric field
stnum proc near ; for 8 bit numbers
call stmsg ; copy message
call stval ; pick up value address
mov al,[si] ; get value
mov ah,0 ; high order is 0
call outnum ; put number into buffer
ret
stnum endp
stlnum proc near ; for 16 bit numbers [jrd]
call stmsg ; copy message
call stval ; pick up value address
mov ax,[si] ; get value
call outnum ; put number into buffer
ret
stlnum endp
; Common routine for parsing numerical input
; Enter with numhlp = offset of help message, numerr = offset of optional
; error message, min, max = allowable range of values.
; Returns value in ax, or does parse error return.
; Changes ax,bx,dx,si. [jrd] 18 Oct 1987
num0: mov dx,offset rdbuf+1 ; were to put text
mov word ptr rdbuf,0 ; clear the buffer
mov bx,numhlp ; help text
mov ah,cmfile ; get a word
call comnd
ret
nop
nop
mov ah,cmcfm
call comnd ; Get a confirm
ret
nop
nop
mov si,offset rdbuf+1
cmp rdbuf+1,'\' ; already quoted?
je num0a ; e = yes
mov rdbuf,'\' ; add a numerical quote
dec si ; point to our escape char
num0a: call katoi ; convert number in rdbuf
jc num0er ; c = no number, error
cmp ax,max ; largest permitted value
ja num0er ; a = error
cmp ax,min ; smallest permitted value
jb num0er ; b = error
clc
ret ; return value in ax
num0er: mov ah,prstr
mov dx,numerr ; comand-specific error message, if any
cmp dx,0 ; was any given?
je num0e1 ; e = no, use generic msg
int dos ; show given error message
jmp short num0e2
num0e1:
; mov dx,offset nummsg1 ; get address of numeric error message
mcmsg nummsg1,cnummsg1
int dos
mov ax,min ; smallest permitted number
call decout ; display decimal number in ax
mov ah,prstr
; mov dx,offset nummsg2 ; "and"
mcmsg nummsg2,cnummsg2
int dos
mov ax,max ; largest permitted number
call decout
num0e2: stc
ret
num0e3: mov ah,prstr
; mov dx,offset ermes7 ; say command not executed
mcmsg ermes7,cermes7
int dos
stc
ret
; translate the number in ax
outnum proc near
mov dx,0
mov bx,10
div bx ; divide to get digit
push dx ; save remainder digit
or ax,ax ; test quotient
jz outnu1 ; zero, no more of number
call outnum ; else call for rest of number
outnu1: pop ax ; get digit back
add al,'0' ; make printable
stosb ; drop it off
ret
outnum endp
; on/off field
onoff proc near
call stmsg ; copy message
call stval ; get value cell
mov al,[si]
mov si,offset onmsg
mov cx,2 ; assume 2-byte 'ON' message
or al,al ; test value
jnz onof1 ; on, have right msg
mov si,offset offmsg
mov cx,3
onof1: rep movsb ; copy right message in
ret
onoff endp
; print first message if false, second if true
msg2 proc near
call stval ; get value cell
mov al,[si]
mov si,[bx].msg ; assume off
or al,al ; is it?
jz msg21 ; yes, continue
mov si,[bx].val2 ; else use alternate message
msg21: jmp stms1 ; handle copy and return
msg2 endp
; search a keyword table for a value, print that value
srchkw proc near
call stmsg ; first print message
call stval
mov al,[si] ; get value to hunt for
mov ah,0 ; high order is 0
mov bx,[bx].val2 ; this is table address
jmp prttab ; and look in table
srchkw endp
; search a keyword table for a bit value, print that value. [jrd]
srchkb proc near
call stmsg ; first print message
call stbval ; get bit set or reset
mov ah,0 ; al has 0/1, high order is 0
mov bx,[bx].val2 ; this is table address
jmp prttab ; and look in table
srchkb endp
; get address of test value in stent. Returns address in si. [jrd]
stbval proc near
mov si,[bx].basval ; get address of test value
cmp si,0 ; any there?
je stbva1 ; no, quit with no match
mov ax,[si] ; get value
test ax,[bx].tstcel ; bit test value against data word
jz stbva1 ; z = they don't match
mov ax,1 ; match
ret
stbva1: mov ax,0 ; no match
ret ; and return it
stbval endp
; Print the drive name
drnum proc near
call stmsg ; copy message part first
call stval ; pick up test value address
mov ah,gcurdsk ; Get current disk
int dos
inc al ; We want 1 == A (not zero)
mov curdsk,al
add al,'@' ; Make it printable
cld
stosb
mov word ptr [di],'\:'
add di,2 ; end with a colon and backslash
mov byte ptr [di],0 ; terminate in case drive is not ready
mov dl,0 ; get current drive
mov ah,gcd ; get current directory
mov si,di ; current working buffer position
int dos
push cx
push dx
mov dx,di ; directory string
call strlen ; length of path part to cx
cmp cx,26 ; too long to show the whole thing?
jbe drnum3 ; be = is ok, show the whole path
push di ; scan backward for last backslash
mov al,'\' ; thing to search for
std ; backward
mov di,si ; start of buffer
add di,cx ; length of string
repne scasb ; scan backward for a backslash
jcxz drnum2 ; should not happen, but then again
repne scasb ; do again for second to last path part
drnum2: cld ; reset direction flag
dec di ; move di two places preceding backslash
mov [di],'--' ; insert a missing path indicator
dec di
mov byte ptr [di],'-'
mov si,di ; we will show just this part
pop di ; recover main status pointer
drnum3: pop dx
pop cx
drnum4: lodsb ; copy until null terminator
stosb
cmp al,0 ; end of string?
jne drnum4 ; ne = no
dec di ; offset inc of stosb
ret
drnum endp
; Print the screen-dump filename [jrd]
pasz proc near
call stmsg ; copy message part
mov si,[bx].val2 ; address of asciiz string
pasz1: lodsb ; get a byte
cmp al,0 ; at end yet?
je pasz2 ; e = yes
stosb ; store in buffer
jmp short pasz1 ; keep storing non-null chars
pasz2: ret
pasz endp
; print the End-of-Line characters
preol proc near
call stmsg ; display leadin part of message
mov al,dtrans.seol ; send eol char
add al,40H ; make it printable
stosb
mov si,offset mseol2 ; second part of message
call stms1 ; add that
mov al,trans.reol ; receive eol char
add al,40H ; make it printable
stosb
ret
preol endp
; print Send Delay and Pause
prsnd proc near
call stmsg ; display leadin part of msg
mov al,trans.sdelay ; Send Delay (sec)
xor ah,ah
call outnum
; mov si,offset sndmsg2 ; second part of msg
mcmsgsi sndmsg2,csndmsg2
call stms1 ; add that
mov al,spause ; Send Pause (millisec)
call outnum
; mov si,offset sndmsg3 ; last part of msg
mcmsgsi sndmsg3,csndmsg3
call stms1 ; add it too
ret
prsnd endp
; Print the handshake
prhnd:
; mov si,offset handst ; copy in initial message
mcmsgsi handst,chandst
call stms1
; mov si,offset nonmsg ; assume no handshake
mcmsgsi nonmsg,cnonmsg
mov bx,portval
cmp [bx].hndflg,0 ; Is handshaking in effect?
jne prh0 ; Yes, print what we're using
jmp stms1 ; no, say so and return
prh0: mov al,5eh ; Doing handshaking with control char
stosb
mov al,[bx].hands
add al,40H ; Make printable
stosb ; put in buffer
ret ; and return
; Print the pad character in AL
prpad: cmp al,127 ; Are they using a delete?
jne prpad0
mov ah,prstr
; mov dx,offset delmsg
mcmsg delmsg,cdelmsg
int dos
ret
prpad0: mov dl,5eh ; caret
mov ah,conout
push ax
int dos
pop ax
mov dl,al
add dl,40H ; Make printable
int dos
ret
; Print value from table. BX/address of table, AL/value of variable
prttab: push cx ; save column count
mov cl,[bx] ; Number of entries in our table
inc bx ; Point to the data
prtt0: mov dl,[bx] ; Length of keyword
inc bx ; Point to keyword
mov dh,0
inc dx ; Account for "$" in table
mov si,dx ; Put to index register
cmp ax,[bx+si] ; Is this the one?
je prtt1
add bx,dx ; Go to end of keyword
add bx,2 ; Point to next keyword
dec cl ; Any more keywords to check?
jnz prtt0 ; Yes, go to it
; mov bx,offset prterr
mcmsgb prterr,cprterr
prtt1: mov si,bx
pop cx ; recover column count
jmp stms1 ; copy in message
; Print the baud rate
BAUDPRT PROC NEAR
; mov si,offset baudrt ; "Baud rate is"
mcmsgsi baudrt,cbaudrt
call stms1 ; display that part
call getbaud ; read baud rate first
mov bx,portval
mov ax,[bx].baud
cmp al,byte ptr bdtab ; number of table entries
jb bdprt5 ; b = in table
; mov si,offset unrec ; say unrecognized value
mcmsgsi unrec,cunrec
jmp stms1 ; display text and return
bdprt5: mov bx,offset bdtab ; show ascii rate from table
call prttab
ret
BAUDPRT ENDP
; display Take/Macro COUNT
stcnt proc near
call stmsg ; display leadin part of msg
cmp taklev,0 ; in a Take file or macro?
jne stcnt1 ; ne = yes
; mov si,offset nonemsg ; say none
mcmsgsi nonemsg,cnonemsg
call stms1
ret
stcnt1: push bx
mov bx,takadr ; current Take structure
mov ax,[bx].takctr ; get COUNT
pop bx
call outnum
ret
stcnt endp
; ALARM time
stalr proc near
call stmsg ; display leading part of msg
push bx ; preserve register
mov bx,0 ; position index
stalr1: push bx ; save around calls
cmp alrhms[bx],10 ; two digits?
jae stalr2 ; ae = yes
mov al,'0'
stosb ; show leading zero
stalr2: mov al,alrhms[bx] ; show time component
mov ah,0
call outnum
pop bx ; recover index
inc bx
cmp bx,3 ; done all fields?
jae stalr3 ; ae = yes
mov al,':'
stosb
jmp short stalr1 ; do next field
stalr3: pop bx
ret
stalr endp
; Jumping to this location is like retskp. It assumes the instruction
; after the call is a jmp addr
RSKP PROC NEAR
pop bp
add bp,3
push bp
ret
RSKP ENDP
; Jumping here is the same as a ret
R PROC NEAR
ret
R ENDP
; routine to print an error message, then retskp
; expects message in dx
reterr proc near
mov ah,prstr
int dos
jmp rskp
reterr endp
code ends
;CHINESE2
ifdef MSDOS
include mssset2.dat
else
include ccsset2.dat
endif
if1
%out [End of pass 1]
else
%out [End of assembly]
endif
end
