home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Columbia Kermit
/
kermit.zip
/
ccdos
/
ccuibm.asm
< prev
next >
Wrap
Assembly Source File
|
2020-01-01
|
62KB
|
1,276 lines
NAME ccuibm
; File CCUIBM.ASM
;CHINESE
ifdef MSDOS
include msuibm.dat
else
include ccuibm.dat
endif
code segment public 'code'
; system independent external items
extrn comnd:near, prompt:near, iseof:near ; in msscmd
extrn strlen:near ; in mssfil
extrn cnvlin:near, katoi:near, decout:near ; in msster
; system dependent external items
extrn beep:near, prtchr:near, khold:near ; in msxibm &msyibm
extrn anskbi:near, vclick:near ; in mszibm
; these are system dependent action verbs, in msxibm & msyibm
extrn uparrw:near, dnarrw:near, rtarr:near, lfarr:near
extrn pf1:near, pf2:near, pf3:near, pf4:near, kp0:near, kp1:near
extrn kp2:near, kp3:near, kp4:near, kp5:near, kp6:near, kp7:near
extrn kp8:near, kp9:near, kpminus:near, kpcoma:near, kpenter:near
extrn kpdot:near
extrn chrout:near, cstatus:near, cquit:near, cquery:near
extrn vtans52:near, vtinit:near, dnwpg:near, upwpg:near
extrn endwnd:near, homwnd:near, upone:near, dnone:near, trnprs:near
extrn trnmod:near, sendbr:near, sendbl:near, dmpscn:near, snull:near
extrn chang:near, klogon:near, klogof:near, cdos:near
extrn vtrmac:near, vtsmac:near
ifdef DEBG
extrn debgp:near
endif
assume cs:code, ds:datas, es:datas
; Begin system independent Keyboard Translator code
; MSUINIT performs Kermit startup initialization for this file.
; Note, shkadr and stkadr are pointers tested by Set/Show Key calls. If they
; are not initialized here then the older Set/Show Key procedures are called.
MSUINIT PROC NEAR ; call from msx/msy init code
call kbdinit ; optional: init translator tables
mov shkadr,offset shkey ; declare keyboard translator present
mov stkadr,offset dfkey ; via Show and Set Key proc addresses
ret
MSUINIT ENDP
; Call Keybd to read a keyboard char (just returns carry clear if none) and
; 1) send the replacement string (or original char if not translated)
; out the serial port, or
; 2) execute a Kermit action verb.
; Returns carry set if Connect mode is to be exited, else carry clear.
; Modifies registers ax and bx.
KEYBD PROC NEAR ; active translator
call getkey ; read keyboard
jnc keybd1 ; nc = data available
jmp keybdx ; else just return carry clear
keybd1: call postkey ; call system dependent post processor
cmp nkeys,0 ; is number of keys defined = 0?
jz keybd3 ; z = none defined
push di ; search keylist for this keycode
push cx ; save some registers
push es
mov di,offset keylist ; list of defined keycode words
mov ax,keycode ; present keycode
mov cx,nkeys ; number of words to examine
push ds
pop es ; make es:di point to datas segment
cld
repne scasw ; find keycode in list
pop es ; restore regs
pop cx
je keybd1b ; e = found, work with present di
pop di ; restore original di
test keycode,scan ; is this a scan code?
jz keybd3 ; z = no, it's ascii, use al as char
call beep ; say key is a dead one
clc
ret ; and exit with no action
keybd1b:sub di,2 ; correct for auto increment
sub di,offset keylist ; subtract start of list ==> listptr
mov ax,dirlist[di] ; ax = contents of director word
pop di ; restore original di
; dispatch on Director code
test ax,verb ; verb only?
jnz keyvb ; e = yes
test ax,strng ; multi-char string only?
jnz keyst ; e = yes, else single char & no xlat.
;
; do single CHAR output (char in al)
keybd3: cmp al,trans.escchr ; Kermit's escape char?
je keybd3a ; e = yes, handle separately
call chrout ; transmit the char
clc ; return success
ret
keybd3a:stc ; set carry for jump to Quit
ret
keyvb: and ax,not(verb+strng) ; VERB (ax=index, remove type bits)
mov bx,offset kverbs ; start of verb table
cmp al,byte ptr [bx] ; index > number of entries?
jae keybdx ; ae = illegal, indices start at 0
inc bx ; bx points to first entry
push cx ; save reg
mov cx,ax ; save the index in cx
inc cx ; counter, indices start at 0
keyvb1: mov al,byte ptr [bx] ; cnt value
xor ah,ah
add ax,4 ; skip text and '?' and value word
add bx,ax ; look at next slot
loop keyvb1 ; walk to correct slot
sub bx,2 ; backup to value field
keyvb2: pop cx ; restore reg
mov bx,[bx] ; get value field of this slot
cmp bx,0 ; jump address defined?
je keybdx ; e = no, skip the action
jmp bx ; perform the function
keyst: and ax,not(verb+strng) ; STRING (ax=index, remove type bits)
shl ax,1 ; convert to word index
push si ; save working reg
mov si,ax ; word subscript in table
mov si,sptable[si] ; memory offset of selected string
cmp si,0 ; is there a string pointer present?
je keyst3 ; e = no, skip operation
cld ; scan forward
lodsb ; get string length byte
mov cl,al
xor ch,ch ; to cx for looping
jcxz keybdx ; z = null length
keyst2: lodsb ; get new string char into al
push si ; save si and cx around call
push cx
call chrout ; send out the char in al
pop cx ; recover regs
pop si
loop keyst2 ; loop through whole string
keyst3: pop si ; restore reg
keybdx: clc ; return success
ret
KEYBD ENDP
; SET KEY - define a key (procedure dfkey)
; SET KEY <key ident><whitespace><new meaning>
; Call from Kermit level. Returns as ret if failure or as rskp if success.
;
DFKEY PROC NEAR ; define a key as a verb or a string
mov keycode,0 ; clear keycode
mov oldform,0 ; say no old form Set Key yet
mov dx,offset tranbuf ; our work space
mov word ptr tranbuf,0 ; insert terminator
; mov bx,offset dfhelp1 ; first help message
mcmsgb dfhelp1,cdfhelp1
mov ah,cmfile ; parse a word
call comnd ; get key code or original ascii char
nop
nop
nop
mov al,intake ; reading from Take file indirectly
or al,taklev ; ditto, directly
mov msutake,al ; save here
or ah,ah ; any text given?
jnz dfkey12 ; nz = yes, so don't consider prompts
; interactive key request
cmp intake,0 ; in a Take file?
je dfkey10 ; e = no, prompt for keystroke
jmp dfkey0 ; else say bad syntax
dfkey10:mov ah,prstr
; mov dx,offset dfaskky ; ask for key to be pressed
mcmsg dfaskky,cdfaskky
int dos
dfkey11:call getkey ; read key ident from keyboard
jc dfkey11 ; c = no response, wait for keystroke
mov ah,prstr ; display cr/lf
mov dx,offset crlf
int dos
call shkey0 ; show current definition (in SHKEY)
jmp dfkey1e ; prompt for and process definition
dfkey12: ; Look for word SCAN and ignore it
mov dx,word ptr tranbuf ; get first two characters
or dx,2020h ; map upper to lower case
cmp dx,'cs' ; first two letters of word "scan"?
je dfkey ; e = yes, skip the word
cmp dx,'lc' ; first two letters of word "clear"?
je dfkey15 ; e = yes, reinit keyboard [2.31]
cmp dx,'fo' ; first two letters of "off"
je dfkey13 ; e = yes, use DOS keyboard calls
cmp dx,'no' ; first two letters of "on"
je dfkey14 ; e = yes, use standard kbd calls
cmp ah,1 ; number of characters received
ja dfkey1 ; a = more than one, decode
mov ah,byte ptr tranbuf ; get the single char
mov byte ptr keycode,ah ; store as ascii keycode
jmp dfkey1b ; go get definition
dfkey13:mov dosflg,0ffh ; set DOS keyboard read flag
jmp short dfkey14a
dfkey14:mov dosflg,0 ; clear DOS keyboard read flag
dfkey14a:mov ah,cmcfm ; added after version 2.30
call comnd
jmp r
nop
jmp rskp
dfkey15:mov ah,cmcfm ; added after version 2.30
call comnd ; confirm request before proceeding
jmp r
nop
jmp short dfkeyc ; execute command
dfkey0:
; mov dx,offset dfhelp1 ; say bad definition command
mcmsg dfhelp1,cdfhelp1
mov ah,prstr
int dos
jmp rskp
dfkeyc: ; CLEAR key defs, restore startup defs
mov cx,maxkeys ; size of keycode tables
push es ; save register
push ds
pop es ; make es point to datas segment
mov ax,0 ; null, value to be stored
mov di,offset dirlist ; director table
cld
rep stosw ; clear it
mov cx,maxkeys
mov di,offset keylist ; keycode table
rep stosw ; clear it
mov cx,maxstng
mov di,offset sptable ; string pointer table
rep stosw ; clear it
pop es ; recover register
mov strmax,offset stbuf ; clear string buffer, free space ptr
mov stbuf,0 ; first element of buffer
mov nkeys,0 ; clear number of defined keys
call msuinit ; restore startup definitions
jmp rskp
; Multi-char key identification
dfkey1: mov si,offset tranbuf ; point to key ident text
cmp byte ptr [si],'0' ; is first character numeric?
jb dfkey1a ; b = no
cmp byte ptr [si],'9' ; in numbers?
ja dfkey1a ; a = no
mov keycode,scan ; setup keycode for scan value
mov dx,si ; get length of string in cx
call strlen
push ds
pop es ; make es point to datas segment
push si
add si,cx ; point at string terminator
mov di,si
inc di ; place to store string (1 byte later)
inc cx ; include null terminator
std ; work backward
rep movsb ; move string one place later
cld
pop si
mov byte ptr [si],'\' ; make ascii digits into \nnn form
mov oldform,0ffh ; set old form flag
; mov dx,offset kwarnmsg ; tell user this is old form
mcmsg kwarnmsg,ckwarnmsg
mov ah,prstr
int dos
dfkey1a:call katoi ; convert ascii number to binary in ax
jnc dfkey1h
jmp dfkey0 ; c = no number converted
dfkey1h:
or keycode,ax ; store in keycode
dfkey1b: ; Get Definition proper
test oldform,0ffh ; old form Set Key active?
jz dfkey1f ; z = no
mov bx,offset tranbuf ; get new definition on main cmd line
mov word ptr [bx],0 ; insert terminator
; mov dx,offset dfhelp2 ; help for definition of key
mcmsg dfhelp2,cdfhelp2
mov ah,cmtxt ; read rest of line into tranbuf
call comnd
nop ; allow null definitions
nop
nop
or ah,ah ; char count zero?
jz dfkey1e ; z = zero, prompt for definition
jmp dfkey1g ; process definition
dfkey1e:mov ah,prstr
mov dx,offset crlf
int dos
; mov dx,offset dfaskdf ; prompt for definition string
mcmsg dfaskdf,cdfaskdf
call prompt ; Kermit prompt routine
mov comand.cmcr,1 ; permit bare carriage returns
mov comand.cmwhite,1 ; allow leading whitespace
dfkey1f:mov bx,offset tranbuf ; get new definition
mov word ptr [bx],0 ; insert terminator
; mov dx,offset dfhelp2 ; help for definition of key
mcmsg dfhelp2,cdfhelp2
mov ah,cmtxt ; read rest of line into tranbuf
call comnd
jmp r ; exit now on ^C from user
nop
cmp comand.cmcr,0 ; prompting for definition?
je dfkey1g ; e = no, trim leading whitespace
mov comand.cmcr,0 ; turn off allowance for bare c/r's
jmp dfkey2 ; interactive, allow leading whitespace
dfkey1g:xchg ah,al ; put byte count in al
xor ah,ah ; clear high byte
mov kbtemp,ax ; and save count in kbtemp
mov ah,cmcfm ; get a confirm
call comnd
jmp r ; none so declare parse error
nop ; round out to three bytes
mov cx,kbtemp ; string length
dfkey2: ; Examine translation
mov al,trans.escchr ; current escape char (port dependent)
cmp al,byte ptr keycode ; is this Kermit's escape char?
jne dfkey2a ; ne = no
test keycode,scan ; see if scan code
jnz dfkey2a ; nz = scan, so not ascii esc char
; mov dx,offset dfkopps ; Opps! msg
mcmsg dfkopps,cdfkopps
mov ah,prstr ; complain and don't redefine
int dos
jmp rskp
dfkey2a:push di ; get a director code for this key
push cx
mov di,offset keylist ; list of keycodes
mov cx,nkeys ; number currently defined
mov ax,keycode ; present keycode
jcxz dfkey2b ; cx = 0 means none defined yet
cld
push ds
pop es
repne scasw ; is current keycode in the list?
jne dfkey2b ; ne = not in list
sub di,2 ; correct for auto increment
sub di,offset keylist
mov listptr,di ; list pointer for existing definition
pop cx
pop di
jmp dfkey3 ; go process definition
dfkey2b:pop cx ; key not currently defined so
pop di ; make a new director entry for it
mov bx,nkeys ; number of keys previously defined
cmp bx,maxkeys ; enough space?
jae dfkey2c ; ae = no, complain
shl bx,1 ; count words
mov listptr,bx ; index into word list
mov ax,keycode ; get key's code
mov keylist[bx],ax ; store it in list of keycodes
mov dirlist[bx],0 ; clear the new director entry
inc nkeys ; new number of keys
jmp dfkey3 ; go process definition
dfkey2c:
; mov dx,offset keyfull ; say key space is full already
mcmsg keyfull,ckeyfull
mov ah,prstr
int dos
jmp rskp ; tell parser we are happy
; listptr has element number in keylist or dirlist; keycode has key's code.
; Parse new definition. First look for Kermit verbs as a line beginning
; as \K or \{K. Otherwise, consider the line to be a string.
; In any case, update the Director table for the new definition.
dfkey3: mov brace,0 ; assume not using braces
mov si,offset tranbuf ; start of definition text
cmp byte ptr [si],'\' ; starts with escape char?
jne dfkey5 ; ne = no, so we have a string
inc si ; skip the backslash
cmp byte ptr [si],braceop ; starts with \{?
jne dfkey3a ; ne = no
inc si ; skip the opening brace
mov brace,bracecl ; expect closing brace
dfkey3a:cmp byte ptr [si],'K' ; starts with \{K or \K?
je dfkey3b ; e = yes
cmp byte ptr [si],'k' ; starts as \{k or \k?
jne dfkey5 ; ne = no, then it's a string
dfkey3b:inc si ; yes, skip the K too
; Kermit action VERBS
push si ; save verb name start address
dfkey4: cld
lodsb ; scan til closing brace or w/s or end
cmp al,0 ; premature end?
je dfkey4b ; e = yes, accept without brace
cmp al,brace ; closing brace?
je dfkey4b ; e = yes
cmp al,spc ; white space or control char?
ja short dfkey4 ; a = no, so not at end yet
dfkey4b:mov byte ptr[si-1],0 ; insert null terminator
pop si ; recover start address
call tstkeyw ; find keyword, kw # returned in kbtemp
jc dfkey4d ; c = no keyword found, complain
call remstr ; clear old string, if string
mov ax,kbtemp ; save keyword number
and ax,not(verb+strng) ; clear verb / string field
or ax,verb ; set verb ident
mov si,listptr
mov dirlist[si],ax ; store info in Director table
jmp dfkey7 ; show results and return success
dfkey4d:
; mov dx,offset verbbad ; say no such verb
mcmsg verbbad,cverbbad
mov ah,prstr
int dos
jmp rskp
; Here we are left with the definition string; si points to its start, and
; kbtemp holds its length (number of bytes). Null termination. If the string
; begins with an opening brace it terminates on a matching closing brace
; or the end of line, whichever occurs first. Trailing whitespace removed
; before examining braces.
; Null length strings mean define key as Self.
; STRING definitions
dfkey5: call remstr ; first, clear old string, if any
mov si,offset tranbuf ; si=source, di=dest, convert in-place
mov di,si
call cnvlin ; convert numbers, cx gets line length
mov si,offset tranbuf ; provide address of new string
cmp cx,1 ; just zero or one byte to do?
jbe dfkey6 ; e = yes, do as a char
call insertst ; insert new string, returns reg cx.
jc dfkey5h ; c = could not do insert
mov si,listptr ; cx has type and string number
mov dirlist[si],cx ; update Director table from insertst
jmp dfkey7 ; show results and return success
dfkey5h:
; mov dx,offset strbad ; display complaint
mcmsg strbad,cstrbad
mov ah,prstr
int dos
dfkeyx: jmp rskp
; define SINGLE CHAR replacement or CLEAR a key definition.
; cx has char count 1 (normal) or 0 (to undefine the key).
dfkey6: jcxz dfkey6c ; z = cx= 0, clear definition
mov al,byte ptr [si] ; get first byte from definition
xor ah,ah ; set the type bits to Char
mov si,listptr
mov dirlist[si],ax ; store type and key's new code
jmp dfkey7 ; return success
dfkey6c:push si ; clear a definition,
push di ; listptr points to current def
mov si,listptr ; starting address to clear
add si,offset dirlist
mov di,si ; destination
add si,2 ; source is next word
mov cx,nkeys ; current number of keys defined
add cx,cx ; double for listptr being words
sub cx,listptr ; cx = number of words to move
shr cx,1 ; convert to actual number of moves
jcxz dfkey6d ; z = none, just remove last word
push es
push ds
pop es ; make es:di point to datas segment
cld
push cx ; save cx
rep movsw ; move down higher list items
pop cx
mov si,listptr ; do keylist too, same way
add si,offset keylist
mov di,si
add si,2
rep movsw
pop es
dfkey6d:mov si,nkeys ; clear old highest list element
shl si,1 ; address words
mov dirlist[si],0 ; null the element
mov keylist[si],0 ; null the element
dec nkeys ; say one less key defined now
pop di ; restore saved registers
pop si
dfkey7: mov ah,msutake ; Finish up. In a Take file?
or ah,taklev ; or even directly
cmp ah,0
je dfkey7a ; e = no
cmp flags.takflg,0 ; echo Take commands?
je dfkey7b ; e = no
dfkey7a:mov ah,prstr ; display cr/lf
mov dx,offset crlf
int dos
call shkey0 ; show new definition (in SHKEY)
call shkfre ; show free string space
dfkey7b:jmp rskp ; return success
DFKEY ENDP
; SHOW KEY <cr> command. Call from Kermit level. Vectored here by SHOW
; command. Replaces obsolete procedure in msx---.
; Prompts for a key and shows that key's (or all if ? entered) keycode,
; definition, and the key definition free space remaining.
SHKEY PROC NEAR ; Show key's definition command
mov ah,cmcfm ; get a confirm
call comnd
nop ; ignore any additional text
nop
nop
push bx
; mov dx,offset shkmsg1 ; ask for original key
mcmsg shkmsg1,cshkmsg1
mov ah,prstr
int dos
shky0: call getkey ; read keyboard, output to keycode
jc shky0 ; wait for a key (c = nothing there)
cmp byte ptr keycode,'?' ; query for all keys?
jne shky0a ; ne = no, not a query
test keycode,scan ; is this a scan code, vs ascii query?
jz shky0c ; z = no Scan, so it is a query
shky0a: mov ah,prstr ; show single key. Setup display
mov dx,offset crlf
int dos
call shkey0 ; show just one key
shky0b: call shkfre ; show free string space
jmp shkeyx ; exit
shky0c: mov cx,nkeys ; Show all keys. nkeys = number defined
jcxz shky0b ; z = none to show
mov si,offset keylist ; list of definitions
push si ; save pointer
shky1: pop si ; recover pointer
cld
lodsw ; get a keycode
push si ; save pointer
push cx ; save counter
mov keycode,ax ; save new keycode
mov ah,prstr
mov dx,offset crlf
int dos
call shkey0 ; show this keycode
pop cx ; pause between screens, recover cntr
push cx ; save it again
dec cx ; number yet to be shown
jcxz shky1b ; z = have now shown all of them
mov ax,nkeys ; number of defined keys
sub ax,cx ; minus number yet to be displayed
xor dx,dx ; clear extended numerator
div twelve ; two lines per definition display
or dx,dx ; remainder zero (12 defs shown)?
jnz shky1b ; nz = no, not yet so keep going
mov ah,prstr
; mov dx,offset shkmsg3 ; "push any key to continue" msg
mcmsg shkmsg3,cshkmsg3
int dos
shky1a: call getkey ; get any key
jc shky1a ; c = nothing at keyboard yet, wait
shky1b: pop cx ; resume loop
loop shky1
pop si ; clean stack
call shkfre ; show free string space
jmp shkeyx ; exit
; show key worker routine, called from above
; SHKEY0 called by DFKEY just above
SHKEY0: test keycode,scan ; scan code?
jz shkey1 ; z = no, regular ascii
; SCAN codes
; mov dx,offset scanmsg ; say Scan Code:
mcmsg scanmsg,cscanmsg
mov ah,prstr
int dos
mov ah,conout
mov dl,'\' ; add backslash before number
int dos
mov ax,keycode ; get key's code again
call decout ; display 16 bit decimal keycode
jmp shkey2 ; go get definition
shkey1:
; mov dx,offset ascmsg ; say ASCII CHAR
mcmsg ascmsg,cascmsg
mov ah,prstr
int dos
mov dl,byte ptr keycode ; get ascii code (al part of input)
mov ah,conout
cmp dl,spc ; control code?
jae shkey1a ; ae = no
push dx ; save char
mov dl,5eh ; show caret first
int dos
pop dx
add dl,'A'-1 ; ascii bias
shkey1a:cmp dl,del ; DEL?
jne shkey1b ; ne = no
mov dl,'D' ; spell out DEL
int dos
mov dl,'E'
int dos
mov dl,'L'
shkey1b:int dos
mov dl,spc ; add a couple of spaces
int dos
int dos
mov dl,'\' ; add backslash before number
int dos
mov ax,keycode ; show 16 bit keycode in decimal
call decout ; and go get definiton
; Display defintion
shkey2:
; mov dx,offset shkmsg2 ; intermediate part of reply
mcmsg shkmsg2,cshkmsg2
mov ah,prstr ; " is defined as "
int dos
push di ; get a director code for this key
push cx
mov di,offset keylist ; list of keycodes
mov cx,nkeys ; number currently defined
jcxz shkey2a ; z = none
mov ax,keycode ; present keycode
push ds
pop es ; use datas segment for es:di
cld
repne scasw ; is current keycode in the list?
jne shkey2a ; ne = not in list
sub di,2 ; correct for auto increment
sub di,offset keylist
mov listptr,di ; list pointer for existing definition
pop cx
pop di
jmp shkey3 ; go process definition
shkey2a:pop cx
pop di
; mov dx,offset noxmsg ; say Self (no translation)
mcmsg noxmsg,cnoxmsg
mov ah,prstr
int dos
ret ; return to main show key loop
shkey3: ; translations, get kind of.
mov si,listptr
test dirlist[si],verb ; defined as verb?
jnz shkey6 ; nz = yes, go do that one
test dirlist[si],strng ; defined as string?
jz shkey3a ; z = no
jmp shkey8 ; yes, do string display
shkey3a:
; mov dx,offset ascmsg ; CHAR. say 'Ascii char:'
mcmsg ascmsg,cascmsg
mov ah,prstr
int dos
mov ax,dirlist [si] ; get type and char
mov dl,al ; put char here for display
push ax ; save here too
mov ah,conout
cmp dl,spc ; control code?
jae shkey4 ; ae = no
push dx
mov dl,5eh ; show caret
int dos
pop dx
add dl,'A'-1 ; add ascii bias
shkey4: cmp dl,del ; DEL?
jne shkey4a ; ne = no
mov dl,'D' ; spell out DEL
int dos
mov dl,'E'
int dos
mov dl,'L'
shkey4a:int dos
mov dl,spc ; add a couple of spaces
mov ah,conout
int dos
int dos
mov dl,'\' ; add backslash before number
int dos
pop ax ; recover char
xor ah,ah ; clear high byte
call decout ; show decimal value
ret ; return to main show key loop
shkey6: mov ah,prstr ; VERB
; mov dx,offset verbmsg ; say 'verb'
mcmsg verbmsg,cverbmsg
int dos
mov si,listptr ; get verb index from director
mov dx,dirlist[si]
and dx,not(verb+strng) ; remove type bits, leaves verb number
mov bx,offset kverbs ; table of verbs & actions
mov al,byte ptr [bx] ; number of keywords
xor ah,ah
dec ax
mov kwcnt,ax ; save number of last one here
cmp dx,ax ; asking for more than we have?
ja shkeyx ; a = yes, exit bad
inc bx ; point to first slot
mov cx,0 ; current slot number
shkey6b:cmp cx,dx ; this slot?
je shkey6c ; e = yes, print the text part
ja shkeyx ; a = beyond, exit bad
mov al,byte ptr [bx] ; get cnt (keyword length)
xor ah,ah
add ax,4 ; skip over '$' and two byte value
add bx,ax ; bx = start of next keyword slot
inc cx ; current keyword number
jmp short shkey6b ; try another
shkey6c:inc bx ; look at text field
mov dx,bx ; offset for printing
mov ah,prstr
int dos
mov ah,conout
mov dl,spc ; add a couple of spaces
int dos
int dos
mov dl,'\' ; show verb name as \Kverb
int dos
mov dl,'K'
int dos
mov ah,prstr
mov dx,bx ; show name part again
int dos
ret ; return to main show key loop
shkey8: mov ah,prstr ; STRING
; mov dx,offset strngmsg ; say String:
mcmsg strngmsg,cstrngmsg
int dos
mov si,listptr ; get index from director
mov bx,dirlist[si]
and bx,not(verb+strng) ; remove type bits
shl bx,1 ; index words
mov si,sptable[bx] ; table of string offsets
mov cl,byte ptr [si] ; get string length byte
xor ch,ch
inc si ; point to string text
mov ah,conout
shkey8a:cld
lodsb ; get a byte
cmp al,spc ; control code?
jae shkey8b ; ae = no
push ax
mov dl,5eh ; show caret first
int dos
pop ax
add al,40h ; convert to printable for display
shkey8b:mov dl,al
int dos ; display it
loop shkey8a ; do another
ret ; return to main show key loop
shkeyx: pop bx ; restore reg
jmp rskp ; return success
SHKEY ENDP
;;; keyboard translator local support procedures, system independent
; Tstkeyw checks text word pointed to by si against table of keywords (pointed
; to by kverbs, made by mkeyw macro); returns in bx either action value or 0.
; Returns in kbtemp the number of the keyword and carry clear, or if failure
; returns kbtemp zero and carry set.
; Keyword structure is: db cnt (length of string 'word')
; db 'word' (keyword string)
; db '$' (printing terminator)
; dw value (value returned in bx)
; Make these with macro mkeyw such as mkeyw 'test',15 with the list of
; such keywords headed by a byte giving the number of keywords in the list.
tstkeyw proc near
push ax
push cx
push si
mov verblen,0 ; verblen will hold verb length
push si ; save user's verb pointer
tstkw1: cld
lodsb ; get a verb character
cmp al,spc ; verbs are all non-spaces and above
jbe tstkw2 ; be = done (space or control char)
inc verblen ; count verb length
jmp short tstkw1 ; printable char, look for more
tstkw2: pop si ; pointer to verb
mov bx,offset kverbs ; table of Kermit verb keywords
mov al,byte ptr [bx] ; number of keywords
xor ah,ah
mov kwcnt,ax ; save number of keywords here
inc bx ; point bx to first slot
mov kbtemp,0 ; remember which keyword
tstkw3: ; match table keyword and text word
mov cx,verblen ; length of user's verb
cmp byte ptr [bx],cl ; compare length vs table keyword
jne tstkw4 ; ne = not equal lengths, try another
push si ; lengths match, how about spelling?
push bx
inc bx ; point at start of keyword
tstkw3a:mov ah,byte ptr [bx] ; keyword char
mov al,byte ptr [si] ; text char
cmp ah,'A'
jb tstkw3b ; b = control chars
cmp ah,'Z'
ja tstkw3b ; a = not upper case alpha
add ah,'a'-'A' ; convert upper case to lower case
tstkw3b:cmp al,'A'
jb tstkw3c
cmp al,'Z'
ja tstkw3c
add al,'a'-'A' ; convert upper case to lower case
tstkw3c:cmp al,ah ; test characters
jne tstkw3d ; ne = no match
inc si ; move to next char
inc bx
loop tstkw3a ; loop through entire length
tstkw3d:pop bx
pop si
jcxz tstkw5 ; z: cx = 0, exit with match;
; else select next keyword
tstkw4: inc kbtemp ; number of keyword to test next
mov cx,kbtemp
cmp cx,kwcnt ; all done? Recall kbtemp starts at 0
jae tstkwx ;ae = exhausted search, unsuccessfully
mov al,byte ptr [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 tstkw3 ; do another comparison
tstkw5: ; get action pointer
mov al,byte ptr [bx] ; cnt (keyword length from macro)
xor ah,ah
add ax,2 ; skip over '$'
add bx,ax ; now bx points to dispatch value
mov bx,[bx] ; bx holds dispatch value
clc ; carry clear for success
jmp short tstkwxx ; exit
ret
tstkwx: xor bx,bx ; exit when no match
mov kbtemp,bx ; make verb number be zero too
stc ; carry set for failure
tstkwxx:pop si
pop cx
pop ax
ret
tstkeyw endp
; Insert asciiz string pointed to by si into string buffer stbuf.
; Reg cx has string length upon entry.
; Success: returns offset of first free byte (strmax) in string buffer stbuf,
; cx = type and Index of new string, and carry clear.
; Failure = carry set.
insertst proc near
push bx
push dx
push si
push di
push kbtemp ; save this variable too
mov dx,cx ; save length of incoming string in dx
mov bx,offset sptable ; table of string offsets
mov kbtemp,0 ; slot number
mov cx,maxstng ; number of entries, find an empty slot
insert1:cmp word ptr[bx],0 ; slot empty?
je insert2 ; e = yes
inc kbtemp ; remember slot number
add bx,2 ; look at next slot
loop insert1 ; keep looking
jmp short insert4 ; get here if no empty slots
insert2: ; see if stbuf has sufficient space
mov cx,dx ; length of new string to cx
mov di,strmax ; offset of first free byte in stbuf
add di,cx ; di = address where this string would end
cmp di,offset stbuf+stbuflen ; beyond end of buffer?
jae insert4 ; ae = yes, not enough room
mov di,strmax ; point to first free slot in stbuf
mov [bx],di ; fill slot with address offset of buffer
push es
push ds
pop es ; point es:di to datas segment
cld
mov byte ptr [di],cl ; length of text for new string
inc di ; move to next storage slot
rep movsb ; copy string text
pop es
mov strmax,di ; offset of next free byte
mov cx,kbtemp ; return new slot number with Director Index
and cx,not(strng+verb) ; clear type bits
or cx,strng ; say type is multi-char string
clc ; say success
jmp short insertx ; exit
insert4:stc ; say no-can-do
insertx:pop kbtemp
pop di
pop si
pop dx
pop bx
ret
insertst endp
; Remove (delete) string. Enter with listptr preset for director entry.
; Acts only on existing multi-char strings; recovers freed space.
; All registers preserved.
remstr proc near
push si
mov si,listptr ; list pointer
test dirlist[si],strng ; multi-char string?
pop si
jnz remst1 ; nz = a multi-char string
ret ; else do nothing
remst1: push ax
push bx
push cx
push dx
push si
mov si,listptr
mov ax,dirlist[si] ; Director table entry
and ax,not(strng+verb) ; clear type bits, leave string's pointer
mov dirlist[si],0 ; clear Director table entry
shl ax,1 ; index words not bytes
mov si,offset sptable ; list of string offsets in stbuf
add si,ax ; plus index = current slot
mov bx,[si] ; get offset of string to be deleted
mov dx,bx ; save in dx for later
mov cl,byte ptr [bx] ; get length byte
xor ch,ch ; get length of subject string
inc cx ; length byte too, cx has whole length
sub strmax,cx ; count space to be freed (adj end-of-buf ptr)
mov word ptr [si],0 ; clear sptable of subject string address
push cx ; save length of purged string
push di ; save di
push si
push es ; save es
push ds
pop es ; setup es:di to be ds:offset of string
mov di,dx ; destination = start address of purged string
mov si,dx ; source = start address of purged string
add si,cx ; plus string length of purged string.
mov cx,offset stbuf+stbuflen ; 1 + address of buffer end
sub cx,si ; 1 + number of bytes to move
dec cx ; number of bytes to move
jcxz remst2 ; z = none
cld ; direction is forward
rep movsb ; move down preserved strings
remst2: pop es ; restore regs
pop di
pop si
pop ax ; recover length of purged string (was in cx)
mov bx,offset sptable ; string pointer table
mov cx,maxstng ; max mumber of entries
remst4: cmp [bx],dx ; does this entry occur before purged string?
jbe remst5 ; be = before or equal, so leave it alone
sub [bx],ax ; recompute address (remove old string space)
remst5: add bx,2 ; look at next list entry
loop remst4 ; do all entries in sptable
pop si
pop dx
pop cx
pop bx
pop ax
ret
remstr endp
shkfre proc near ; show free key & string defs & space
push ax ; preserves all registers.
push bx
push cx
push dx
push kbtemp
; mov dx,offset fremsg
mcmsg fremsg,cfremsg
mov ah,prstr
int dos
mov ax,maxkeys ; max number of key defs
sub ax,nkeys ; number currently used
call decout ; show the value
mov ah,prstr
; mov dx,offset kyfrdef ; give key defs msg
mcmsg kyfrdef,ckyfrdef
int dos
mov bx,offset sptable ; table of string pointers
mov cx,maxstng ; number of pointers
mov kbtemp,0 ; number free
shkfr1: cmp word ptr [bx],0 ; slot empty?
jne shkfr2 ; ne = no
inc kbtemp ; count free defs
shkfr2: add bx,2 ; look at next slot
loop shkfr1 ; do all of them
mov ax,kbtemp ; number of free defs
call decout ; display
; mov dx,offset stfrdef ; say free string defs
mcmsg stfrdef,cstfrdef
mov ah,prstr
int dos
mov ax,offset stbuf+stbuflen ; 1 + last byte in stbuf
sub ax,strmax ; offset of last free byte in stbuf
call decout
; mov dx,offset stfrspc ; give free space part of msg
mcmsg stfrspc,cstfrspc
mov ah,prstr
int dos
pop kbtemp
pop dx
pop cx
pop bx
pop ax
ret
shkfre endp
; Initialize the keyboard tables at Kermit startup time. Optional procedure.
; Requires kbdinlst to be configured with mkeyw macro in the form
; mkeyw 'definition',keytype*256+keycode
; keytype is 0 for scan codes and non-zero for ascii.
; Returns normally.
kbdinit proc near ; read keyword kbdinlst and setup
push ds ; initial keyboard assignments.
pop es ; set es:di to datas segment
inc taklev ; pretend that we are in Take file
mov si,offset kbdinlst ; start of list of definitions
kbdini1:mov cl,byte ptr [si] ; cnt field (keyword length of macro)
xor ch,ch
jcxz kbdinix ; z = null cnt field = end of list
inc si ; look at text field
mov di,offset tranbuf ; where defkey expects text
cld
rep movsb ; copy cx chars to tranbuf
mov byte ptr [di],0 ; insert null terminator
inc si ; skip '$' field
mov ax,word ptr [si] ; get value field
mov keycode,ax ; set key ident value
push si
call dfkey2 ; put dfkey to work
nop
nop
nop
pop si
add si,2 ; point to next entry
jmp kbdini1 ; keep working
kbdinix:dec taklev ; reset Take file level
ret
kbdinit endp
;;; End of System Independent Procedures
;;; Begin System Dependent Procedures
; Read keyboard. System dependent.
; Return carry set if nothing at keyboard.
; If char present return carry clear with key's code in Keycode.
; If key is ascii put that in the low byte of Keycode and clear bit Scan in
; the high byte; otherwise, put the scan code in the lower byte and set bit
; Scan in the high byte.
; Bit Scan is set if key is not an ascii code.
; Two methods are used: Bios reading for Set Key ON, and DOS reading for
; Set Key OFF. DOS scan codes are coerced to Bios values as much as possible.
; Modifies register ax.
getkey proc near
mov keycode,0 ; clear old keycode
cmp dosflg,0 ; do DOS keyboard reading?
jne getky5 ; ne = yes, DOS
jmp getky6 ; do full Bios form
; ;;;;;;;; D O S ;;;;;;;;;;
getky5:
call iseof ; is stdin at eof?
jnc getky5k ; nc = not eof, get more
mov al,trans.escchr ; Kermit's escape char
mov byte ptr keycode,al ; save ascii char
clc ; to get out gracefully at EOF
ret ; and exit
getky5k:mov dl,0ffh ; DOS read operation
mov ah,dconio ; from stdin
int dos
jnz getky5a ; nz = char available
stc ; carry set = nothing available
ret ; exit on no char
getky5a:cmp al,0 ; scan code precursor?
je getky5d ; e = yes
cmp al,16 ; Control P?
jne getky5b ; ne = no
mov al,114 ; force Control PrtSc scan code
jmp short getky5e ; process as scan code
getky5b:cmp al,BS ; backspace key?
jne getky5c ; ne = no
mov al,14 ; force scan code for BS key
jmp short getky5e ; process as scan code
getky5c:mov byte ptr keycode,al ; save ascii char
clc ; say have an ascii keycode
ret ; and exit
getky5d:mov dl,0ffh ; read second byte (actual scan code)
mov ah,dconio ; read via DOS
int dos
jnz getky5e ; nz = got a char
stc ; none, declare bad read
ret
; Check and modify to Bios scan codes
getky5e:mov byte ptr keycode,al ; save char code
cmp al,1 ; Alt escape
je getkya ; set Alt bit
cmp al,16 ; back tab
jb getky5g ; these remain unchanged
cmp al,50 ; start of meta keys
jb getkya ; b = set Alt bit
cmp al,84 ; Shift F1
jb getky5g ; b = no change
cmp al,94 ; Control F1
jb getkys ; set Shift bit
cmp al,104 ; Alt F1
jb getkyc ; set Control bit
cmp al,114 ; Control PrtSc
jb getkya ; set Alt bit
cmp al,120 ; Alt top rank
jb getkyc ; set Control bit
cmp al,132 ; Control PgUp
jb getkya ; set Alt bit
je getkyc ; set Control bit
cmp al,135 ; Shift F11, for Enhanced keyboard
jb getky5g ; no change
cmp al,137 ; Control F11
jb getkys ; set Shift bit
cmp al,139 ; Alt F11
jb getky5c ; set Control bit
cmp al,141 ; Control Up
jb getkya ; set Alt bit
cmp al,151 ; Alt Home
jb getkyc ; set Control bit
jmp short getkya ; set Alt bit
getkyc: or keycode,control ; set Control bit
jmp short getky5g
getkys: or keycode,shift ; set Shift bit
jmp short getky5g
getkya: or keycode,alt ; set Alt bit
getky5g:or keycode,scan ; ensure scan bit is set
clc ; report we have a scan keycode
ret ; and exit
; ;;;;;;;;;; B I O S ;;;;;;;;;;;;;
getky6: ; full BIOS keyboard reading
mov kbtemp,0001h ; low byte = status, high = read char
push cx ; save registers
push es
mov cx,40h ; segment 40h
mov es,cx
mov cl,byte ptr es:[96h] ; kbd_flag_3, Enhanced keyboard area
and cl,10h ; select Enhanced kbd presence bit
mov ch,cl ; copy, for both status and read
or kbtemp,cx ; 0 = regular kbd, 10h = enhanced kbd
pop es
pop cx
;+++++++++++++++++++++++ Change Check Keyboard Method, Sept.3,1990 [zqf].
mov ah,0bh
int 21h
cmp al,0
; mov ah,byte ptr kbtemp ; anything at keyboard?
; int kbint ; Bios keyboard interrupt
;+++++++++++++++++++++++
jnz getky1 ; nz = char available
stc ; carry set = nothing available
jmp short getkyx ; exit on no char available
getky1: mov ah,byte ptr kbtemp+1 ; read, no echo, wait til done
int kbint ; ==> ah = scan code, al = char value
or ax,ax ; Both bytes null for Control-Break?
jnz getky1a ; nz = no
push ax ; clear DOS buffer of Control-C by
mov ah,coninq ; doing DOS level read operation
int dos
pop ax ; restore reg
getky1a:cmp ah,0 ; keycode entered by ALT ###?
je getky1c ; e = yes, not enhanced
cmp ah,0e0h ; Enhanced kbd Enter, fwd slash keys?
jne getky1b ; ne = no
xchg ah,al ; interchange scan and ascii fields
getky1b:cmp al,0E0h ; enhanced key hidden code?
jne getky1c ; ne = no
mov byte ptr keycode,ah ; retain scan code, supress 0e0h
or keycode,scan+enhanced ; set scan and enhanced idents
mov ah,2 ; use regular keyboard op code here
int kbint ; get current shift state
mov bl,al ; copy for a moment
and bl,rgt_shift ; mask out all but right shift
shl bl,1 ; move right shift to left shift pos
or al,bl ; collapse shift bits
and al,(lft_shift + alt_shift + ctl_shift)
or byte ptr keycode+1,al ; store in type field of keycode
clc ; say have a keystroke
jmp getkyx ; Enhanced kbd end. Skip other tests
getky1c:push cx
mov cx,aliaslen ; number of aliased keys
or cx,cx
pop cx
jz getky2 ; z = none
push di ; check key (ax) for aliases
push cx
push es
push ds
pop es ; make es:di refer to datas segment
mov di,offset aliaskey ; list of aliased keys
mov cx,aliaslen ; number of entries
cld
repne scasw ; look for a match
pop es
pop cx
pop di
jne getky2 ; ne = not there
mov al,0 ; force use of scan code (in ah)
getky2: or al,al ; scan code being returned?
jnz getky3 ; nz = no
mov byte ptr keycode,ah ; store scan code for gsh
push ax
push bx
call gsh ; get modified shift state
or byte ptr keycode+1,al ; store in type field of keycode
pop bx
pop ax
xchg ah,al ; put scan code in al
or keycode,scan ; set scan flag (vs ascii)
getky3: mov byte ptr keycode,al ; return key's code (usually ascii)
clc ; carry clear = got a char
getkyx: ret
getkey endp
; get shift state into al. We care about only shift, ctl, and alt keys.
; right shift is collapsed into left shift. NumLock offsets Shift on keypad
; white keys.
gsh proc near
mov ah,2
int kbint ; get current shift state
mov bl,al ; copy for a moment
and bl,rgt_shift ; mask out all but right shift
shl bl,1 ; move right shift to left shift pos
or al,bl ; collapse shift bits
cmp byte ptr keycode,71 ; below numeric key pad?
jb gsh1 ; b = yes
cmp byte ptr keycode,83 ; above numeric key pad?
ja gsh1 ; a = yes
cmp byte ptr keycode,74 ; grey - key ?
je gsh1 ; e = yes
cmp byte ptr keycode,78 ; grey + key
je gsh1 ; e = yes
test al,numlock ; numlock set?
jz gsh1 ; z = no
xor al,lft_shift ; numlock offsets shift and vice versa
gsh1: and al,(lft_shift + alt_shift + ctl_shift)
ret
gsh endp
; Do any local processing after reading a key during active translation
; Avoids same actions if a key is being defined or shown.
postkey proc near
; Key Click code for VT102 emulator
cmp flags.vtflg,0 ; emulating? (0 = no)
je postke1 ; e = extra clicks not available
test vtemu.vtflgst,vskeyclick ; flags from SET TERM
jz postke1 ; z = extra clicks not wanted
call vclick ; click, what else?
postke1:ret
postkey 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
code ends
end
