home *** CD-ROM | disk | FTP | other *** search
/ Columbia Kermit / kermit.zip / extra / nyenhuis2.arc / MSUGEN.ASM < prev    next >
Assembly Source File  |  1989-05-14  |  50KB  |  1,381 lines
  1.     NAME    msugen
  2. ; File MSUGEN.ASM 
  3.     include mssdef.h
  4. ; Keyboard translator, by Joe R. Doupnik, Dec 1986
  5. ;  with contributions from David L. Knoell.
  6. ; For Generic keyboard reading (via DOS)
  7. ; edit history:
  8. ; Last edit 14 May 1989
  9. ; 1 July 1988 Version 2.31
  10. ; 4 June 1988 Revise material under dfkey12, add test to read from files.
  11. ; 1 Jan 1988 version 2.30
  12.  
  13.     public    keybd, dfkey, shkey, msuinit
  14.  
  15. ; some definitions
  16.  
  17. maxkeys    equ    128            ; maximum number of key definitions
  18. maxstng    equ    64            ; maximum number of multi-char strings
  19. stbuflen equ    1000            ; length of string buffer (bytes)
  20.  
  21. verb    equ    8000h            ; dirlist flag: use verb action table
  22. strng    equ    4000h            ; dirlist flag: use string action table
  23. scan    equ    100h            ; keycode flag: code is scan not ascii
  24. braceop    equ    7bh            ; opening curly brace
  25. bracecl    equ    7dh            ; closing curly brace
  26.  
  27. data    segment    public 'data'
  28.     extrn    taklev:byte, comand:byte, flags:byte
  29.     extrn    shkadr:word, stkadr:word, trans:byte
  30.                         ; system dependent references
  31.     
  32. ;;;    System Independent local storage
  33.  
  34. tranbuf    db    132 dup (?)        ; 132 byte translator work buffer
  35. crlf    db    cr,lf,'$'
  36. dfhelp1    db    cr,lf,' Enter key',27h,'s identification as a character',cr,lf
  37.     db    '  or as its numerical equivalent \{b##} of ascii',cr,lf
  38.     db    '  or as its scan code \{b##}'
  39.     db    cr,lf,'  or as SCAN followed by its scan code',cr,lf
  40.     db    '    where b is O for octal, X for hex, or D for decimal'
  41.     db    ' (default).',cr,lf,'    Braces {} are optional.'
  42.     db    cr,lf,'    Follow the identification with the new definition.'
  43.     db    cr,lf,' or CLEAR to restore initial key settings.$'
  44. dfaskky    db    cr,lf,' Push key to be defined: $'
  45. dfaskdf    db    ' Enter new definition: $'
  46. verbbad    db    cr,lf,' No such verb',cr,lf,'$'
  47. strbad    db    cr,lf,' Not enough space for new string',cr,lf,'$'
  48. keyfull    db    cr,lf,' No more space to define keys',cr,lf,'$'
  49. dfkopps    db    cr,lf,' Opps! That is Kermit',27h,'s Escape Char.'
  50.     db    ' Translation is not permitted.',cr,lf,'$'
  51. shkmsg1    db    cr,lf,'Push key to be shown (? shows all): $'
  52. shkmsg2    db    ' decimal is defined as',cr,lf,'$'
  53. shkmsg3    db    cr,lf,'... more, push any key to continue ...$'
  54. kwarnmsg db    cr,lf,' Notice: this form of Set Key is obsolete$'
  55.  
  56. ascmsg    db    ' Ascii char: $'
  57. scanmsg    db    ' Scan Code $'
  58. strngmsg db    ' String: $'
  59. verbmsg    db    ' Verb: $'
  60. noxmsg    db    ' Self, no translation.$'
  61. fremsg    db    cr,lf,' Free space: $'
  62. kyfrdef    db    ' key and $'
  63. stfrdef db    ' string definitions, $'
  64. stfrspc    db    ' string characters.',cr,lf,'$'
  65.                     ; translation tables
  66. keylist    dw    maxkeys dup (0)        ; 16 bit keycodes, paralled by dirlist
  67. dirlist    dw    maxkeys dup (0)        ; director {v+s} + {index | new char}
  68. sptable    dw    maxstng dup (0)        ; list of asciiz string offsets
  69. stbuf    dw    stbuflen dup (0)    ; buffer for strings
  70. strmax    dw    stbuf            ; first free byte in stbuf
  71. listptr    dw    0            ; item number for keylist and dirlist
  72. nkeys    dw    0            ; number of actively defined keys
  73. keycode    dw    0            ; ascii/scan code for key
  74. kbtemp    dw    0            ; scratch storage for translator
  75. brace    db    0            ; brace detected flag byte
  76. oldform    db    0            ; old form Set Key, if non-zero
  77. verblen    dw    0            ; length of user's verb (work temp)
  78. kwcnt    dw    0            ; number of keywords (work temp)
  79. msutake    db    0            ; if being run from take file or not
  80. twelve    dw    12d
  81. dosflg    db    0
  82. ;;;    End System Independent Data Area
  83.  
  84. ;;;    System Dependent Data Area
  85. ;    edit dfhelp2 to include nice list of verbs for this system.
  86. dfhelp2 db    cr,lf,' Enter either \{Kverb}  for a Kermit action verb',cr,lf
  87.     db    ' or a replacement string  (single byte binary numbers are'
  88.     db    ' \{b##})',cr,lf,' or nothing at all to undefine a key.'
  89.     db    cr,lf,' Braces {} are optional, and strings maybe enclosed in'
  90.     db    ' them.',cr,lf,' Strings may not begin with the character'
  91.     db    ' combinations of  \k  or  \{k',cr,lf
  92.     db    '    (start with a { brace instead).',cr,lf,lf
  93.     db    ' Verbs are as follows:',cr,lf
  94.     db    ' Logoff (suspend logging), Logon (resume logging),'
  95.     db    ' DOS (push to), null (send a)',cr,lf
  96.     db    ' break, help, prtscn, status, exit'
  97.     db    cr,lf,'$'
  98.  
  99.     ; Aliaskey: keys having aliases - same ascii code but more than one
  100.     ; scan code, as on auxillary keypads. Use just scan codes with these.
  101.     ; Alternative use: force ascii keys to report out just scan codes.
  102.     ; Table format: high byte = scan code, low byte = ascii code. 
  103.     ; Contents are machine dependent.
  104. aliaskey db    0
  105. aliaslen equ    ($-aliaskey) shr 1    ; number of words in aliaskey table
  106.  
  107. kverbs    db    10            ; number of table entries below
  108.     mkeyw    'prtscn',trnprs        ; independent of ordering and case!
  109.     mkeyw    'break',sendbr        ; mkeyw 'name',procedure entry point
  110.     mkeyw    'Hangup',chang
  111.     mkeyw    'null',snull
  112.     mkeyw    'help',cquery
  113.     mkeyw    'status',cstatus
  114.     mkeyw    'exit',cquit
  115.     mkeyw    'DOS',kdos
  116.     mkeyw    'Logoff',klogof
  117.     mkeyw    'Logon',klogon
  118.                 ; Initialization data.
  119. kbdinlst equ    this byte     ; Kermit IBM initialization time keyboard setup
  120.     mkeyw    '\x7f',8    ; Backspace key sends DEL
  121.     dw    0        ; end of table marker
  122.  
  123. data    ends
  124.  
  125. ;            Documentation
  126. ;Translating a key:
  127. ;   The translator is called to obtain keyboard input; it sends characters to
  128. ; the serial port through standard controlled echo procedures or invokes
  129. ; named procedures. It returns carry clear when its operation is completed
  130. ; for normal actions and carry set when Connect mode must be exited. When
  131. ; Connect mode is exited the just read char should be passed in Kbdflg 
  132. ; to msster.asm for invoking actions such as Status, send a break,
  133. ; quit connect mode; system dependent procedure Term is responsible for this. 
  134. ;
  135. ;  Principal procedures are -
  136. ;    msuinit        Initializes keyboard translator in this file when
  137. ;            Kermit first begins. Installs dfkey and shkey as the
  138. ;            procedures used for Set Key and Show Key. Sys Indep.
  139. ;            Called from msx or msy init procs. System Independent.
  140. ;    keybd        Performs the translation, outputs chars to the serial
  141. ;            port or invokes a Kermit action routine. Sys Indep.
  142. ;    dfkey        Defines a key's translation. Reads command line
  143. ;            via Kermit's command parser comnd. System Independent.
  144. ;    shkey        Shows translation of a key. Requests user to push
  145. ;            selected key. System Independent.
  146. ;
  147. ;    kbdinit        optional. Initializes the translation tables when
  148. ;            Kermit starts up. Called by msuinit. System Dependent.
  149. ;    getkey        Performs the keyboard read and returns results in
  150. ;            a standardized system independent format. Sys Depend.
  151. ;    postkey        called by active translator after obtaining a keycode.
  152. ;            Used to provide extra local actions (keyclick) only
  153. ;            in Connect mode (not during Set/Show key commands).
  154. ;            Called by keybd. System dependent.
  155. ; Supporting system independent procedures are -
  156. ; shkfre (show string free space), tstkeyw (finds user's keyword in the verb
  157. ; table), insertst (insert string in buffer), remstr (delete string in buffer).
  158. ;
  159. ;   System dependent procedure Getkey reads a keycode (usually via a Bios
  160. ; call). On IBM compatible machines this yields <ah=scan code, al=ascii>
  161. ; for ordinary keys, or <ah=scan code, al=0> for special keys such as F1,
  162. ; or <ah=0, al=###> when Alt### is used.
  163. ; For any system, the canonical output form is the key's code in Keycode.
  164. ; Place the ascii code (or scan code if none) in byte Keycode and ancillary
  165. ; info (shift states plus marker bit for scan codes) in byte Keycode + 1.
  166. ; 
  167. ;   Table Aliaskey is a list of scan code/ascii codes for keys which appear
  168. ; more than once on a keyboard. This list is examined to distinguish such
  169. ; aliased keys (those on an auxillary keypad) from an ordinary ascii key,
  170. ; and the aliased key is then referenced by its scan code rather than by
  171. ; the ordinary ascii code. Aliaskey is machine and keyboard dependent.
  172. ;
  173. ;    Procedure Keybd calls Getkey for the Keycode, checks list of translatable
  174. ; keys Keylist, and then either sends an ascii string (one or more characters)
  175. ; or invokes a Kermit action verb. List Dirlist indicates what kind of 
  176. ; translation to do. Keybd is system independent but may contain system
  177. ; dependent special actions such as echoing keyclicks. Keybd calls system
  178. ; dependent procedure Postkey just after calling getkey so local actions
  179. ; such as keyclicks can be activated only during Connect mode operations.
  180. ;
  181. ;    Keylist is a packed but unordered list of 16 bit keycodes which need
  182. ; translation. The lower order byte holds a key code (ascii char or scan code)
  183. ; while the high byte holds a scan code marker bit (0 if ascii code in low
  184. ; byte) plus any ancillary keyboard information such as Control/Shift/Alt/Meta
  185. ; keys being held down; these are of use in Show Key presentations.
  186. ;    Dirlist parallels Keylist to provide the kind of translation, verb or
  187. ; string, in the two highest bits with the other bits holding either
  188. ; a single new replacement character or the item number in lists of verbs
  189. ; or strings. If neither verb nor strng type bits are set in a dirlist
  190. ; word then the translation is a single new character held in the lower
  191. ; eight bits of that dirlist word.
  192. ;
  193. ;    The number of key translations is assembly constant Maxkeys (def 128).
  194. ;    The maximum number of strings is assembly constant Maxstngs (def 64).
  195. ;    The maximum number of verbs is 256 and is set by building table Kverbs.
  196. ;
  197. ;   For verbs, use the Item number from the Director table Dirlist to select
  198. ; a procedure offset from the structured list Kverbs and jump to that offset.
  199. ; Most verb procedures return carry clear to stay within Connect mode.
  200. ; Verbs requiring exiting Connect mode return carry set and may set byte
  201. ; Kbdflg to a char code which will be read by msster.asm for activating a
  202. ; transient Kermit action such as send a break (Kbdflg = 'b').
  203. ; Kbdflg is stored in msster.asm (as zero initially, meaning ignore it).
  204. ; Action verb procedures are normally located in a system dependent file.
  205. ;
  206. ;   For multi-char strings, use Item number from Director table Dirlist to
  207. ; select a pointer to a string. The list of string pointers is Sptable
  208. ; (string pointer table) which holds the offset in the data segment of the
  209. ; strings stored in buffer Stbuf. In stbuf strings are held as: one byte of
  210. ; length of following text and then the text itself (permits embedded nulls).
  211. ;  Use Chrout to send each string character, and finally return from Keybd
  212. ; with carry clear.
  213. ;
  214. ;   For single character replacements obtain the new character from the lower
  215. ; order byte of Director table Dirlist. If the character is Kermit's present
  216. ; escape character return from Keybd carry set to leave connect mode.
  217. ; Otherwise, send the character via Chrout and return from Keybd carry clear.
  218.  
  219. ; Keylist table format:
  220. ;    7 bits   1 bit   8 bits
  221. ; +----------+----+------------+ scan bit = 1 if key's code is non-ascii
  222. ; | aux info |scan| key's code | aux info = system dependent, used only to
  223. ; +----------+----+------------+            help identify key
  224. ;
  225. ; Dirlist table format          v s    meaning
  226. ;   1   1      14 bits         0 0    copy out one byte translation
  227. ; +---+---+--------------------+  1 0    copy out multi-char string number Item
  228. ; | v | s | item # or new char |  0 1    do action verb number Item
  229. ; +---+---+--------------------+  1 1    (not used)
  230. ;
  231. ; Table kverbs is organized by macro mkeyw as -
  232. ;    kverbs    db    number of table entries
  233. ;    (each entry is in the form below:)
  234. ;        db    number of bytes in verbname
  235. ;        db    'verbname'        variable length
  236. ;        db    '$'            for printing
  237. ;        dw    value            offset of procedure
  238. ;
  239. ;
  240. ;   Dfkey defines a key to be itself (undefines it) or a single replacement
  241. ; character or a character string or a Kermit action verb. Dfkey requires
  242. ; a command line so that it may be invoked by Take files but can be forced
  243. ; to prompt an interactive user to push a key. Syntax is discussed below.
  244. ; Note that redefined keys have their old definitions cleared so that
  245. ; old string space is reclaimed automatically.
  246. ;
  247. ;   Shkey displays a key's definition and the user is asked to push the
  248. ; selected key. The free space for strings is always shown afterward. See
  249. ; below for syntax.
  250. ;
  251. ;   Kbdinit is an optional routine called when Kermit starts up. It fills in
  252. ; the translation tables with desirable default values to save having to
  253. ; use long mskermit.ini files. The default values are stored in a structured
  254. ; table similar to (but not the same as) Dfkey's command lines; the keycode
  255. ; values are preset by hand to 16 bit numbers.
  256.  
  257. ;Defining a key:
  258. ; Command is SET KEY <key ident><whitespace><definition>
  259. ;
  260. ; <key ident> is
  261. ;        a single ordinary ascii char or
  262. ;        the numerical equivalent of an ascii char or
  263. ;        a Scan Code written as a number or
  264. ;        keyword SCAN followed by a number.
  265. ;        ?    Displays help message.
  266. ;    Numbers and Binary codes are of the form
  267. ;        \123    a decimal number
  268. ;        \o456    an octal number        base letters o, d, x can be
  269. ;        \d213    a decimal number    upper or lower case
  270. ;        \x0d    a hex number
  271. ;        \{b###}  braces around above material following slash.
  272. ;
  273. ; <whitespace> is one or more spaces and or tabs.
  274. ;
  275. ; <definition> is
  276. ;    missing altogether which "undefines" a key.
  277. ;    \Kverb        for a Kermit action verb; upper or lower case K is ok
  278. ;    \{Kverb}    ditto. Verb is the name of an action verb.
  279. ;    text        a string with allowed embedded whitespace and embedded
  280. ;            binary chars as above. This kind of string may not
  281. ;            commence with sequences \K or \{K; use braces below.
  282. ;    {text}        string confined to material within but excluding
  283. ;            the braces. Note, where the number of opening braces
  284. ;            exceeds the number of closing braces the end of line
  285. ;            terminates the string: {ab{}{{c}d ==> ab{}{{c}d
  286. ;            but  {ab}{{c}d ==> ab.
  287. ;    ?        Displays help message and lists all action verbs.
  288. ;
  289. ;    If Set Key is given interactively, as opposed to within a Take
  290. ;    file, the system will prompt for inputs if none is on the command
  291. ;    line. The response to Push key to be defined cannot be edited.
  292. ;
  293. ;    Text which reduces to a single replacement character is put into a
  294. ;    table separate from the multi-character strings (maxstng of these).
  295. ;    A key may be translated into any single 8 bit code.
  296. ;    
  297. ;    Comments can follow a Kermit action verb or a braced string; no
  298. ;    semicolon is required since all are stripped out by the Take file
  299. ;    reader before the defining text is seen by SET KEY.
  300. ;
  301. ;    The current Kermit escape character cannot be translated without
  302. ;    subtrafuge.
  303. ;
  304. ;    Examples:
  305. ;        Set Key q z
  306. ;                makes key q send character z
  307. ;        Set Key \7 \27[0m
  308. ;                makes key Control G send the four byte
  309. ;                string  ESC [ 0 m
  310. ;        Set Key q
  311. ;                undefines key q so it sends itself (q) again.
  312. ;        Set Key \2349 \kexit
  313. ;                defines IBM Alt-X to invoke the leave connect
  314. ;                mode verb "exit" (Kermit's escape-char ^] C).
  315. ;        Set Key \x0c Login \{x0d}myname\{x0d}mypass\x0d
  316. ;                defines Control L to send the string
  317. ;                Login <cr>myname<cr>mypass<cr>
  318. ;
  319. ; Alternative Set Key syntax for backward compatibility with previous versions
  320. ;    The same forms as above except the key identification number must
  321. ;    be decimal and must Not have a leading backslash. Example:
  322. ;    Set Key Scan 59 This is the F1 key
  323. ;
  324. ;    If the definition is omitted it may be placed on the following line;
  325. ;    if that line is also empty the key is undefined (defined as Self).
  326. ;    A warning message about obsolete syntax will be given followed by
  327. ;    the key's modern numerical value and new definition. Only "special"
  328. ;    keys (those not producing ascii codes) are compatible with this
  329. ;    translator.
  330. ;
  331. ;Showing a key:
  332. ; Command is SHOW KEY <cr>
  333. ; System prompts user to press a key and shows the definition plus the
  334. ; free space for strings. Query response results in showing all definitions.
  335. ;            End Documentation
  336.  
  337. code    segment    public 'code'
  338.         ; system independent external items
  339.     extrn    comnd:near, prompt:near, iseof:near    ; in msscmd
  340.     extrn    strlen:near                ; in mssfil
  341.     extrn    cnvlin:near, katoi:near, decout:near    ; in msster
  342.         ; system dependent external items
  343.         ; these are system dependent action verbs, in msxgen
  344.     extrn    beep:near, trnprs:near, sendbr:near
  345.     extrn    chrout:near, cstatus:near, cquit:near, cquery:near
  346.     extrn    klogon:near, klogof:near, kdos:near, snull:near, chang:near
  347.  
  348.     assume    cs:code, ds:data, es:data
  349.  
  350. ; Begin system independent Keyboard Translator code
  351.  
  352. ; MSUINIT performs Kermit startup initialization for this file.
  353. ; Note, shkadr and stkadr are pointers tested by Set/Show Key calls. If they
  354. ; are not initialized here then the older Set/Show Key procedures are called.
  355. MSUINIT    PROC    NEAR            ; call from msx/msy init code
  356.     call    kbdinit            ; optional: init translator tables
  357.     mov    shkadr,offset shkey    ; declare keyboard translator present
  358.     mov    stkadr,offset dfkey    ; via Show and Set Key proc addresses
  359.     ret
  360. MSUINIT    ENDP
  361.  
  362. ; Call Keybd to read a keyboard char (just returns carry clear if none) and
  363. ; 1) send the replacement string (or original char if not translated)
  364. ;    out the serial port, or
  365. ; 2) execute a Kermit action verb.
  366. ; Returns carry set if Connect mode is to be exited, else carry clear.
  367. ; Modifies registers ax and bx.
  368. KEYBD    PROC    NEAR            ; active translator
  369.     call    getkey            ; read keyboard
  370.     jnc    keybd1            ; nc = data available
  371.     jmp    keybdx            ; else just return carry clear
  372. keybd1:    call    postkey            ; call system dependent post processor
  373.     cmp    nkeys,0            ; is number of keys defined = 0?
  374.     jz    keybd3            ; z = none defined
  375.     push    di            ; search keylist for this keycode
  376.     push    cx            ; save some registers    
  377.     push    es
  378.     mov    di,offset keylist    ; list of defined keycode words
  379.     mov    ax,keycode        ; present keycode
  380.     mov    cx,nkeys        ; number of words to examine
  381.     push    ds
  382.     pop    es            ; make es:di point to data segment
  383.     cld
  384.     repne    scasw            ; find keycode in list
  385.     pop    es            ; restore regs
  386.     pop    cx
  387.     je    keybd1b            ; e = found, work with present di
  388.     pop    di            ; restore original di
  389.     test    keycode,scan        ; is this a scan code?
  390.     jz    keybd3            ; z = no, it's ascii, use al as char
  391.     call    beep            ; say key is a dead one
  392.     clc
  393.     ret                ; and exit with no action
  394.  
  395. keybd1b:sub    di,2            ; correct for auto increment
  396.     sub    di,offset keylist    ; subtract start of list ==> listptr
  397.     mov    ax,dirlist[di]        ; ax = contents of director word
  398.     pop    di            ; restore original di
  399.                     ; dispatch on Director code
  400.     test    ax,verb            ; verb only?
  401.     jnz    keyvb            ; e = yes
  402.     test    ax,strng        ; multi-char string only?
  403.     jnz    keyst            ; e = yes, else single char & no xlat.
  404.                     ;
  405.                     ; do single CHAR output (char in al)
  406. keybd3:    cmp    al,trans.escchr        ; Kermit's escape char?
  407.     je    keybd3a            ; e = yes, handle separately
  408.     call    chrout            ; transmit the char
  409.     clc                ; return success
  410.     ret
  411. keybd3a:stc                ; set carry for jump to Quit
  412.     ret
  413.  
  414. keyvb:    and    ax,not(verb+strng)    ; VERB (ax=index, remove type bits)
  415.     mov    bx,offset kverbs    ; start of verb table
  416.     cmp    al,byte ptr [bx]    ; index > number of entries?
  417.     jae    keybdx            ; ae = illegal, indices start at 0
  418.     inc    bx            ; bx points to first entry
  419.     push    cx            ; save reg
  420.     mov    cx,ax            ; save the index in cx
  421.     inc     cx            ; counter, indices start at 0
  422. keyvb1:    mov    al,byte ptr [bx]    ; cnt value
  423.     xor    ah,ah
  424.     add    ax,4            ; skip text and '?' and value word
  425.     add    bx,ax            ; look at next slot
  426.     loop    keyvb1            ; walk to correct slot
  427.     sub    bx,2            ; backup to value field
  428. keyvb2:    pop    cx            ; restore reg
  429.     mov    bx,[bx]            ; get value field of this slot
  430.     cmp    bx,0            ; jump address defined?
  431.     je    keybdx            ; e = no, skip the action
  432.     jmp    bx            ; perform the function
  433.  
  434. keyst:    and    ax,not(verb+strng)    ; STRING (ax=index, remove type bits)
  435.     shl    ax,1            ; convert to word index
  436.     push    si            ; save working reg
  437.     mov    si,ax            ; word subscript in table
  438.     mov    si,sptable[si]        ; memory offset of selected string
  439.     cmp    si,0            ; is there a string pointer present?
  440.     je    keyst3            ; e = no, skip operation
  441.     cld                ; scan forward
  442.     lodsb                ; get string length byte
  443.     mov    cl,al
  444.     xor    ch,ch            ; to cx for looping
  445.     jcxz    keybdx            ; z = null length
  446. keyst2:    lodsb                ; get new string char into al
  447.     push    si            ; save si and cx around call
  448.     push    cx
  449.     call    chrout            ; send out the char in al
  450.     pop    cx            ; recover regs
  451.     pop    si
  452.     loop    keyst2            ; loop through whole string
  453. keyst3:    pop    si            ; restore reg
  454.  
  455. keybdx:    clc                ; return success
  456.     ret
  457. KEYBD    ENDP
  458.  
  459. ; SET KEY - define a key   (procedure dfkey)
  460. ; SET KEY <key ident><whitespace><new meaning>
  461. ; Call from Kermit level. Returns as ret if failure or as rskp if success.
  462. ;  
  463. DFKEY    PROC    NEAR            ; define a key as a verb or a string
  464.     mov    keycode,0        ; clear keycode
  465.     mov    oldform,0        ; say no old form Set Key yet
  466.     mov    dx,offset tranbuf    ; our work space
  467.     mov    word ptr tranbuf,0    ; insert terminator
  468.     mov    bx,offset dfhelp1    ; first help message
  469.     mov    ah,cmword        ; parse a word
  470.     call    comnd            ; get key code or original ascii char
  471.     mov    al,taklev        ; reading from Take file
  472.     mov    msutake,al        ; save here
  473.     or    ah,ah            ; any text given?
  474.     jnz    dfkey12            ; nz = yes, so don't consider prompts
  475.                     ; interactive key request
  476.     cmp    taklev,0        ; in a Take file?
  477.     je    dfkey10            ; e = no, prompt for keystroke
  478.     jmp    dfkey0            ;  else say bad syntax
  479. dfkey10:mov    ah,prstr
  480.     mov    dx,offset dfaskky    ; ask for key to be pressed
  481.     int    dos
  482. dfkey11:call    getkey            ; read key ident from keyboard
  483.     jc    dfkey11            ; c = no response, wait for keystroke
  484.     mov    ah,prstr        ; display cr/lf
  485.     mov    dx,offset crlf
  486.     int    dos
  487.     call    shkey0            ; show current definition (in SHKEY)
  488.     jmp    dfkey1e            ; prompt for and process definition
  489.  
  490. dfkey12:                ; Look for word SCAN and ignore it
  491.     mov    dx,word ptr tranbuf    ; get first two characters
  492.     or    dx,2020h        ; map upper to lower case
  493.     cmp    dx,'cs'            ; first two letters of word "scan"?
  494.     je    dfkey            ; e = yes, skip the word
  495.     cmp    dx,'lc'            ; first two letters of word "clear"?
  496.     je    dfkey15            ; e = yes, reinit keyboard [2.31]
  497.     cmp    dx,'fo'            ; first two letters of "off"
  498.     je    dfkey13            ; e = yes, use DOS keyboard calls
  499.     cmp    dx,'no'            ; first two letters of "on"
  500.     je    dfkey14            ; e = yes, use standard kbd calls
  501.     cmp    ah,1            ; number of characters received
  502.     ja    dfkey1            ; a = more than one, decode
  503.     mov    ah,byte ptr tranbuf    ; get the single char
  504.     mov    byte ptr keycode,ah    ; store as ascii keycode
  505.     jmp    dfkey1b            ; go get definition
  506.  
  507. dfkey13:mov    dosflg,0ffh        ; set DOS keyboard read flag
  508.     jmp    short dfkey14a
  509. dfkey14:mov    dosflg,0        ; clear DOS keyboard read flag
  510. dfkey14a:mov    ah,cmeol        ; get end of line confirmation
  511.     call    comnd
  512.     ret
  513.  
  514. dfkey15:mov    ah,cmeol
  515.     call    comnd            ; confirm request before proceeding
  516.     jnc    dfkeyc            ; nc = success
  517.     ret                ; failure
  518.  
  519. dfkey0:    mov    dx,offset dfhelp1    ; say bad definition command
  520.     mov    ah,prstr
  521.     int    dos
  522.     stc                ; failure
  523.     ret
  524.  
  525. dfkeyc:                    ; CLEAR key defs, restore startup defs
  526.     mov    cx,maxkeys        ; size of keycode tables
  527.     push    es            ; save register
  528.     push    ds
  529.     pop    es            ; make es point to data segment
  530.     mov    ax,0            ; null, value to be stored
  531.     mov    di,offset dirlist    ; director table
  532.     cld
  533.     rep    stosw            ; clear it
  534.     mov    cx,maxkeys
  535.     mov    di,offset keylist    ; keycode table
  536.     rep    stosw            ; clear it
  537.     mov    cx,maxstng
  538.     mov    di,offset sptable    ; string pointer table
  539.     rep    stosw            ; clear it
  540.     pop    es            ; recover register
  541.     mov    strmax,offset stbuf    ; clear string buffer, free space ptr
  542.     mov    stbuf,0            ; first element of buffer 
  543.     mov    nkeys,0            ; clear number of defined keys
  544.     call    msuinit            ; restore startup definitions
  545.     clc                ; success
  546.     ret
  547.                     ; Multi-char key identification
  548. dfkey1:    mov    si,offset tranbuf    ; point to key ident text
  549.     cmp    byte ptr [si],'0'    ; is first character numeric?
  550.     jb    dfkey1a            ; b = no
  551.     cmp    byte ptr [si],'9'    ; in numbers?
  552.     ja    dfkey1a            ; a = no
  553.     mov    keycode,scan        ; setup keycode for scan value
  554.     mov    dx,si            ; get length of string in cx
  555.     call    strlen
  556.     push    ds
  557.     pop    es            ; make es point to data segment
  558.     push    si
  559.     add    si,cx            ; point at string terminator
  560.     mov    di,si
  561.     inc    di            ; place to store string (1 byte later)
  562.     inc    cx            ; include null terminator
  563.     std                ; work backward
  564.     rep    movsb            ; move string one place later
  565.     cld
  566.     pop    si
  567.     mov    byte ptr [si],'\'    ; make ascii digits into \nnn form
  568.     mov    oldform,0ffh        ; set old form flag
  569.     mov    dx,offset kwarnmsg    ; tell user this is old form
  570.     mov    ah,prstr
  571.     int    dos
  572. dfkey1a:call    katoi            ; convert ascii number to binary in ax
  573.     jc    dfkey0            ; c = no number converted
  574.     or    keycode,ax        ; store in keycode
  575.  
  576. dfkey1b:                ; Get Definition proper
  577.     test    oldform,0ffh        ; old form Set Key active?
  578.     jz    dfkey1f            ; z = no
  579.     mov    bx,offset tranbuf    ; get new definition on main cmd line
  580.     mov    word ptr [bx],0        ; insert terminator
  581.     mov    dx,offset dfhelp2    ; help for definition of key
  582.     mov    ah,cmline        ; read rest of line into tranbuf
  583.     call    comnd            ; allow null definitions
  584.     or    ah,ah            ; char count zero?
  585.     jz    dfkey1e            ; z = zero, prompt for definition
  586.     jmp    dfkey1g            ; process definition
  587.  
  588. dfkey1e:mov    ah,prstr
  589.     mov    dx,offset crlf
  590.     int    dos
  591.     mov    dx,offset dfaskdf    ; prompt for definition string
  592.      call    prompt            ; Kermit prompt routine
  593.     mov    comand.cmcr,1        ; permit bare carriage returns
  594.     mov    comand.cmwhite,1    ; allow leading whitespace
  595. dfkey1f:mov    bx,offset tranbuf    ; get new definition
  596.     mov    word ptr [bx],0        ; insert terminator
  597.     mov    dx,offset dfhelp2    ; help for definition of key
  598.     mov    ah,cmline        ; read rest of line into tranbuf
  599.     call    comnd
  600.     jc    dfkey1x            ; exit now on ^C from user
  601.     cmp    comand.cmcr,0        ; prompting for definition?
  602.     je    dfkey1g            ; e = no, trim leading whitespace
  603.     mov    comand.cmcr,0        ; turn off allowance for bare c/r's
  604.     jmp    dfkey2            ; interactive, allow leading whitespace
  605. dfkey1x:ret                ; failure exit
  606.  
  607. dfkey1g:xchg    ah,al            ; put byte count in al
  608.     xor    ah,ah            ; clear high byte
  609.     mov    kbtemp,ax        ; and save count in kbtemp
  610.     mov    ah,cmeol        ; get a confirm
  611.     call    comnd
  612.     jc    dfkey1x            ; none so declare parse error
  613.     mov    cx,kbtemp        ; string length
  614.     
  615. dfkey2:                    ; Examine translation
  616.     mov    al,trans.escchr        ; current escape char (port dependent)
  617.     cmp    al,byte ptr keycode    ; is this Kermit's escape char?
  618.     jne    dfkey2a            ; ne = no
  619.     test    keycode,scan        ; see if scan code
  620.     jnz    dfkey2a            ; nz = scan, so not ascii esc char
  621.     mov    dx,offset dfkopps    ; Opps! msg
  622.     mov    ah,prstr        ; complain and don't redefine
  623.     int    dos
  624.     stc                ; failure
  625.     ret
  626.  
  627. dfkey2a:push    di            ; get a director code for this key
  628.     push    cx    
  629.     mov    di,offset keylist    ; list of keycodes
  630.     mov    cx,nkeys        ; number currently defined
  631.     mov    ax,keycode        ; present keycode
  632.     jcxz    dfkey2b            ; cx = 0 means none defined yet
  633.     cld
  634.     push    ds
  635.     pop    es
  636.     repne    scasw            ; is current keycode in the list?
  637.     jne    dfkey2b            ; ne = not in list
  638.     sub    di,2            ; correct for auto increment
  639.     sub    di,offset keylist
  640.     mov    listptr,di        ; list pointer for existing definition
  641.     pop    cx
  642.     pop    di
  643.     jmp    dfkey3            ; go process definition
  644.  
  645. dfkey2b:pop    cx            ; key not currently defined so
  646.     pop    di            ;  make a new director entry for it
  647.     mov    bx,nkeys        ; number of keys previously defined
  648.     cmp    bx,maxkeys        ; enough space?
  649.     jae    dfkey2c            ; ae = no, complain
  650.     shl    bx,1            ; count words
  651.     mov    listptr,bx        ; index into word list
  652.     mov    ax,keycode        ; get key's code
  653.     mov    keylist[bx],ax        ; store it in list of keycodes
  654.     mov    dirlist[bx],0        ; clear the new director entry
  655.     inc    nkeys            ; new number of keys
  656.     jmp    dfkey3            ; go process definition
  657.  
  658. dfkey2c:mov    dx,offset keyfull    ; say key space is full already
  659.     mov    ah,prstr
  660.     int    dos
  661.     stc                ; failure
  662.     ret
  663.  
  664. ; listptr has element number in keylist or dirlist; keycode has key's code.
  665.  
  666. ; Parse new definition. First look for Kermit verbs as a line beginning
  667. ; as \K or \{K. Otherwise, consider the line to be a string.
  668. ; In any case, update the Director table for the new definition.
  669.  
  670. dfkey3:    mov    brace,0            ; assume not using braces
  671.     mov    si,offset tranbuf    ; start of definition text
  672.     cmp    byte ptr [si],'\'    ; starts with escape char?
  673.     jne    dfkey5            ; ne = no, so we have a string
  674.     inc    si            ; skip the backslash
  675.     cmp    byte ptr [si],braceop    ; starts with \{?
  676.     jne    dfkey3a            ; ne = no
  677.     inc    si            ; skip the opening brace
  678.     mov    brace,bracecl        ; expect closing brace
  679. dfkey3a:cmp    byte ptr [si],'K'    ; starts with \{K or \K?
  680.     je    dfkey3b            ; e = yes
  681.     cmp    byte ptr [si],'k'    ; starts as \{k or \k?
  682.     jne    dfkey5            ; ne = no, then it's a string
  683. dfkey3b:inc    si            ; yes, skip the K too
  684.                     ; Kermit action VERBS
  685.     push    si            ; save verb name start address
  686. dfkey4:    cld
  687.     lodsb                ; scan til closing brace or w/s or end
  688.     cmp    al,0            ; premature end?
  689.     je    dfkey4b            ; e = yes, accept without brace
  690.     cmp    al,brace        ; closing brace?
  691.     je    dfkey4b            ; e = yes
  692.     cmp    al,spc            ; white space or control char?
  693.     ja    short dfkey4        ; a = no, so not at end yet
  694. dfkey4b:mov    byte ptr[si-1],0    ; insert null terminator
  695.     pop    si            ; recover start address
  696.     call    tstkeyw            ; find keyword, kw # returned in kbtemp
  697.     jc    dfkey4d            ; c = no keyword found, complain
  698.     call    remstr            ; clear old string, if string
  699.     mov    ax,kbtemp        ; save keyword number
  700.     and    ax,not(verb+strng)    ; clear verb / string field
  701.     or    ax,verb            ; set verb ident
  702.     mov    si,listptr
  703.     mov    dirlist[si],ax        ; store info in Director table
  704.     jmp    dfkey7            ; show results and return success
  705.  
  706. dfkey4d:mov    dx,offset verbbad    ; say no such verb
  707.     mov    ah,prstr
  708.     int    dos
  709.     stc                ; failure
  710.     ret
  711.  
  712. ; Here we are left with the definition string; si points to its start, and
  713. ; kbtemp holds its length (number of bytes). Null termination. If the string
  714. ; begins with an opening brace it terminates on a matching closing brace
  715. ; or the end of line, whichever occurs first. Trailing whitespace removed
  716. ; before examining braces.
  717. ; Null length strings mean define key as Self.
  718.                     ; STRING definitions
  719. dfkey5:    call    remstr            ; first, clear old string, if any
  720.     mov    si,offset tranbuf    ; si=source, di=dest, convert in-place
  721.     mov    di,si
  722.     call    cnvlin            ; convert numbers, cx gets line length
  723.     mov    si,offset tranbuf    ; provide address of new string
  724.     cmp    cx,1            ; just zero or one byte to do?
  725.     jbe    dfkey6            ; e = yes, do as a char
  726.     call    insertst        ; insert new string, returns reg cx.
  727.     jc    dfkey5h            ; c = could not do insert
  728.     mov    si,listptr        ; cx has type and string number
  729.     mov    dirlist[si],cx        ; update Director table from insertst
  730.     jmp    dfkey7            ; show results and return success
  731.  
  732. dfkey5h:mov    dx,offset strbad    ; display complaint
  733.     mov    ah,prstr
  734.     int    dos
  735. dfkeyx:    stc                ; failure
  736.     ret
  737.  
  738.         ; define SINGLE CHAR replacement or CLEAR a key definition.
  739.         ; cx has char count 1 (normal) or 0 (to undefine the key).
  740. dfkey6:    jcxz    dfkey6c            ; z = cx= 0, clear definition
  741.     mov    al,byte ptr [si]    ; get first byte from definition
  742.     xor    ah,ah            ; set the type bits to Char
  743.     mov    si,listptr
  744.     mov    dirlist[si],ax        ; store type and key's new code
  745.     jmp    dfkey7            ; return success
  746.  
  747. dfkey6c:push    si            ; clear a definition,
  748.     push    di            ; listptr points to current def
  749.     mov    si,listptr        ; starting address to clear
  750.     add    si,offset dirlist
  751.     mov    di,si            ; destination
  752.     add    si,2            ; source is next word
  753.     mov    cx,nkeys        ; current number of keys defined
  754.     add    cx,cx            ; double for listptr being words
  755.     sub    cx,listptr        ; cx = number of words to move
  756.     shr    cx,1            ; convert to actual number of moves
  757.     jcxz    dfkey6d            ; z = none, just remove last word
  758.     push    es
  759.     push    ds
  760.     pop    es            ; make es:di point to data segment
  761.     cld
  762.     push    cx            ; save cx
  763.     rep    movsw            ; move down higher list items
  764.     pop    cx
  765.     mov    si,listptr        ; do keylist too, same way
  766.     add    si,offset keylist
  767.     mov    di,si
  768.     add    si,2
  769.     rep    movsw
  770.     pop    es
  771. dfkey6d:mov    si,nkeys        ; clear old highest list element
  772.     shl    si,1            ; address words
  773.     mov    dirlist[si],0        ; null the element
  774.     mov    keylist[si],0        ; null the element
  775.     dec    nkeys            ; say one less key defined now
  776.     pop    di            ; restore saved registers
  777.     pop    si
  778.  
  779. dfkey7:    mov    ah,msutake        ; Finish up. In a Take file?
  780.     or    ah,taklev        ; or even directly
  781.     cmp    ah,0
  782.     je    dfkey7a            ; e = no
  783.     cmp    flags.takflg,0        ; echo Take commands?
  784.     je    dfkey7b            ; e = no
  785. dfkey7a:mov    ah,prstr        ; display cr/lf
  786.     mov    dx,offset crlf
  787.     int    dos
  788.     call    shkey0            ; show new definition (in SHKEY)
  789.     call    shkfre            ; show free string space
  790. dfkey7b:clc                ; return success
  791.     ret
  792. DFKEY    ENDP
  793.  
  794. ; SHOW KEY <cr> command. Call from Kermit level. Vectored here by SHOW
  795. ; command. Replaces obsolete procedure in msx---.
  796. ; Prompts for a key and shows that key's (or all if ? entered) keycode,
  797. ; definition, and the key definition free space remaining.
  798.  
  799. SHKEY    PROC    NEAR            ; Show key's definition command
  800.     mov    ah,cmeol        ; get a confirm
  801.     call    comnd            ; ignore any additional text
  802.     push    bx
  803.     mov    dx,offset shkmsg1    ; ask for original key
  804.     mov    ah,prstr
  805.     int    dos
  806. shky0:    call    getkey            ; read keyboard, output to keycode
  807.     jc    shky0            ; wait for a key (c = nothing there)
  808.     cmp    byte ptr keycode,'?'    ; query for all keys?
  809.     jne    shky0a            ; ne = no, not a query
  810.     test    keycode,scan        ; is this a scan code, vs ascii query?
  811.     jz    shky0c            ; z = no Scan, so it is a query
  812.  
  813. shky0a:    mov    ah,prstr        ; show single key. Setup display
  814.     mov    dx,offset crlf
  815.     int    dos
  816.     call    shkey0            ; show just one key
  817. shky0b:    call    shkfre            ; show free string space
  818.     jmp    shkeyx            ; exit
  819.  
  820. shky0c:    mov    cx,nkeys        ; Show all keys. nkeys = number defined
  821.     jcxz    shky0b            ; z = none to show
  822.     mov    si,offset keylist    ; list of definitions
  823.     push    si            ; save pointer
  824. shky1:    pop    si            ; recover pointer
  825.     cld
  826.     lodsw                ; get a keycode
  827.     push    si            ; save pointer
  828.     push    cx            ; save counter
  829.     mov    keycode,ax        ; save new keycode
  830.     mov    ah,prstr
  831.     mov    dx,offset crlf
  832.     int    dos
  833.     call    shkey0            ; show this keycode
  834.  
  835.     pop    cx            ; pause between screens, recover cntr
  836.     push    cx            ; save it again
  837.     dec    cx            ; number yet to be shown
  838.     jcxz    shky1b            ; z = have now shown all of them
  839.     mov    ax,nkeys        ; number of defined keys
  840.     sub    ax,cx            ; minus number yet to be displayed
  841.     xor    dx,dx            ; clear extended numerator
  842.     div    twelve            ; two lines per definition display
  843.     or    dx,dx            ; remainder zero (12 defs shown)?
  844.     jnz    shky1b            ; nz = no, not yet so keep going
  845.     mov    ah,prstr
  846.     mov    dx,offset shkmsg3    ; "push any key to continue" msg
  847.     int    dos
  848. shky1a:    call    getkey            ; get any key
  849.     jc    shky1a            ; c = nothing at keyboard yet, wait
  850. shky1b:    pop    cx            ; resume loop
  851.     loop    shky1
  852.     pop    si            ; clean stack
  853.     call    shkfre            ; show free string space
  854.     jmp    shkeyx            ; exit
  855.  
  856.         ; show key worker routine, called from above
  857.                     ; SHKEY0 called by DFKEY just above
  858. SHKEY0:    test    keycode,scan        ; scan code?
  859.     jz    shkey1            ; z = no, regular ascii
  860.  
  861.                     ; SCAN codes
  862.     mov    dx,offset scanmsg    ; say Scan Code:
  863.     mov    ah,prstr
  864.     int    dos
  865.     mov    ah,conout
  866.     mov    dl,'\'            ; add backslash before number
  867.     int    dos
  868.     mov    ax,keycode        ; get key's code again
  869.     call    decout            ; display 16 bit decimal keycode
  870.     jmp    shkey2            ; go get definition
  871.  
  872. shkey1:    mov    dx,offset ascmsg    ; say ASCII CHAR
  873.     mov    ah,prstr
  874.     int    dos
  875.     mov    dl,byte ptr keycode    ; get ascii code (al part of input)
  876.     mov    ah,conout
  877.     cmp    dl,spc            ; control code?
  878.     jae    shkey1a            ; ae = no
  879.     push    dx            ; save char
  880.     mov    dl,5eh            ; show caret first
  881.     int    dos
  882.     pop    dx
  883.     add    dl,'A'-1        ; ascii bias
  884. shkey1a:cmp    dl,del            ; DEL?
  885.     jne    shkey1b            ; ne = no
  886.     mov    dl,'D'            ; spell out DEL
  887.     int    dos
  888.     mov    dl,'E'
  889.     int    dos
  890.     mov    dl,'L'
  891. shkey1b:int    dos
  892.     mov    dl,spc            ; add a couple of spaces
  893.     int    dos
  894.     int    dos
  895.     mov    dl,'\'            ; add backslash before number
  896.     int    dos
  897.     mov    ax,keycode        ; show 16 bit keycode in decimal
  898.     call    decout            ; and go get definiton
  899.  
  900.                     ; Display defintion
  901. shkey2:    mov    dx,offset shkmsg2    ; intermediate part of reply
  902.     mov    ah,prstr        ; " is defined as "
  903.     int    dos
  904.     push    di            ; get a director code for this key
  905.     push    cx    
  906.     mov    di,offset keylist    ; list of keycodes
  907.     mov    cx,nkeys        ; number currently defined
  908.     jcxz    shkey2a            ; z = none
  909.     mov    ax,keycode        ; present keycode
  910.     push    ds
  911.     pop    es            ; use data segment for es:di
  912.     cld
  913.     repne    scasw            ; is current keycode in the list?
  914.     jne    shkey2a            ; ne = not in list
  915.     sub    di,2            ; correct for auto increment
  916.     sub    di,offset keylist
  917.     mov    listptr,di        ; list pointer for existing definition
  918.     pop    cx
  919.     pop    di
  920.     jmp    shkey3            ; go process definition
  921.  
  922. shkey2a:pop    cx
  923.     pop    di
  924.     mov    dx,offset noxmsg    ; say Self (no translation)
  925.     mov    ah,prstr
  926.     int    dos
  927.     ret                ; return to main show key loop
  928.  
  929. shkey3:                    ; translations, get kind of.
  930.     mov    si,listptr
  931.     test    dirlist[si],verb    ; defined as verb?
  932.     jnz    shkey6            ; nz = yes, go do that one
  933.     test    dirlist[si],strng    ; defined as string?
  934.     jz    shkey3a            ; z = no
  935.     jmp    shkey8            ; yes, do string display
  936. shkey3a:
  937.     mov    dx,offset ascmsg    ; CHAR. say 'Ascii char:'
  938.     mov    ah,prstr
  939.     int    dos
  940.     mov    ax,dirlist [si]        ; get type and char
  941.     mov    dl,al            ; put char here for display
  942.     push    ax            ; save here too
  943.     mov    ah,conout
  944.     cmp    dl,spc            ; control code?
  945.     jae    shkey4            ; ae = no
  946.     push    dx
  947.     mov    dl,5eh            ; show caret
  948.     int    dos
  949.     pop    dx
  950.     add    dl,'A'-1        ; add ascii bias
  951. shkey4:    cmp    dl,del            ; DEL?
  952.     jne    shkey4a            ; ne = no
  953.     mov    dl,'D'            ; spell out DEL
  954.     int    dos
  955.     mov    dl,'E'
  956.     int    dos
  957.     mov    dl,'L'
  958. shkey4a:int    dos
  959.     mov    dl,spc            ; add a couple of spaces
  960.     mov    ah,conout
  961.     int    dos
  962.     int    dos
  963.     mov    dl,'\'            ; add backslash before number
  964.     int    dos
  965.     pop    ax            ; recover char
  966.     xor    ah,ah            ; clear high byte
  967.     call    decout            ; show decimal value
  968.     ret                ; return to main show key loop
  969.  
  970. shkey6:    mov    ah,prstr        ; VERB
  971.     mov    dx,offset verbmsg    ; say 'verb'
  972.     int    dos
  973.     mov    si,listptr        ; get verb index from director
  974.     mov    dx,dirlist[si]
  975.     and    dx,not(verb+strng)    ; remove type bits, leaves verb number
  976.     mov    bx,offset kverbs    ; table of verbs & actions
  977.     mov    al,byte ptr [bx]    ; number of keywords
  978.     xor    ah,ah
  979.     dec    ax
  980.     mov    kwcnt,ax        ; save number of last one here
  981.     cmp    dx,ax            ; asking for more than we have?
  982.     ja    shkeyx            ; a = yes, exit bad
  983.     inc    bx            ; point to first slot
  984.     mov    cx,0            ; current slot number
  985. shkey6b:cmp    cx,dx            ; this slot?
  986.     je    shkey6c            ; e = yes, print the text part
  987.     ja    shkeyx            ; a = beyond, exit bad
  988.     mov    al,byte ptr [bx]    ; get cnt (keyword length)
  989.     xor    ah,ah
  990.     add    ax,4            ; skip over '$' and two byte value
  991.     add    bx,ax            ; bx = start of next keyword slot
  992.     inc    cx            ; current keyword number
  993.     jmp    short shkey6b        ; try another
  994. shkey6c:inc    bx            ; look at text field
  995.     mov    dx,bx            ; offset for printing
  996.     mov    ah,prstr
  997.     int    dos
  998.     mov    ah,conout
  999.     mov    dl,spc            ; add a couple of spaces
  1000.     int    dos
  1001.     int    dos
  1002.     mov    dl,'\'            ; show verb name as \Kverb
  1003.     int    dos
  1004.     mov    dl,'K'
  1005.     int    dos
  1006.     mov    ah,prstr
  1007.     mov    dx,bx            ; show name part again
  1008.     int    dos
  1009.     ret                ; return to main show key loop
  1010.  
  1011. shkey8:    mov    ah,prstr        ; STRING
  1012.     mov    dx,offset strngmsg    ; say String:
  1013.     int    dos
  1014.     mov    si,listptr        ; get index from director
  1015.     mov    bx,dirlist[si]
  1016.     and    bx,not(verb+strng)    ; remove type bits
  1017.     shl    bx,1            ; index words
  1018.     mov    si,sptable[bx]        ; table of string offsets
  1019.     mov    cl,byte ptr [si]    ; get string length byte
  1020.     xor    ch,ch
  1021.     inc    si            ; point to string text
  1022.     mov    ah,conout
  1023. shkey8a:cld
  1024.     lodsb                ; get a byte
  1025.     cmp    al,spc            ; control code?
  1026.     jae    shkey8b            ; ae = no
  1027.     push    ax
  1028.     mov    dl,5eh            ; show caret first
  1029.     int    dos
  1030.     pop    ax
  1031.     add    al,40h            ; convert to printable for display
  1032. shkey8b:mov    dl,al
  1033.     int    dos            ; display it
  1034.     loop    shkey8a            ; do another
  1035.     ret                ; return to main show key loop
  1036.     
  1037. shkeyx:    pop    bx            ; restore reg
  1038.     clc                ; return success
  1039.     ret
  1040. SHKEY    ENDP
  1041.  
  1042. ;;;    keyboard translator local support procedures, system independent
  1043.  
  1044. ; Tstkeyw checks text word pointed to by si against table of keywords (pointed
  1045. ; to by kverbs, made by mkeyw macro); returns in bx either action value or 0.
  1046. ; Returns in kbtemp the number of the keyword and carry clear, or if failure
  1047. ; returns kbtemp zero and carry set.
  1048. ; Keyword structure is:         db    cnt    (length of string 'word')
  1049. ;                 db    'word'    (keyword string)
  1050. ;                 db    '$'    (printing terminator)
  1051. ;                 dw    value    (value returned in bx)
  1052. ; Make these with macro mkeyw such as   mkeyw 'test',15   with the list of
  1053. ; such keywords headed by a byte giving the number of keywords in the list.
  1054. tstkeyw    proc    near
  1055.     push    ax
  1056.     push    cx
  1057.     push    si
  1058.     mov    verblen,0        ; verblen will hold verb length
  1059.     push    si            ; save user's verb pointer
  1060. tstkw1:    cld
  1061.     lodsb                ; get a verb character
  1062.     cmp    al,spc            ; verbs are all non-spaces and above
  1063.     jbe    tstkw2            ; be = done (space or control char)
  1064.     inc    verblen            ; count verb length
  1065.     jmp    short tstkw1        ; printable char, look for more
  1066. tstkw2:    pop    si            ; pointer to verb
  1067.     mov    bx,offset kverbs    ; table of Kermit verb keywords
  1068.     mov    al,byte ptr [bx]    ; number of keywords
  1069.     xor    ah,ah
  1070.     mov    kwcnt,ax        ; save number of keywords here
  1071.     inc    bx            ; point bx to first slot
  1072.     mov    kbtemp,0        ; remember which keyword
  1073.  
  1074. tstkw3:                    ; match table keyword and text word
  1075.     mov    cx,verblen        ; length of user's verb
  1076.     cmp    byte ptr [bx],cl    ; compare length vs table keyword
  1077.     jne    tstkw4            ; ne = not equal lengths, try another
  1078.     push    si            ; lengths match, how about spelling?
  1079.     push    bx
  1080.     inc    bx            ; point at start of keyword
  1081. tstkw3a:mov    ah,byte ptr [bx]    ; keyword char
  1082.     mov    al,byte ptr [si]    ; text char
  1083.     cmp    ah,'A'
  1084.     jb    tstkw3b            ; b = control chars
  1085.     cmp    ah,'Z'
  1086.     ja    tstkw3b            ; a = not upper case alpha
  1087.     add    ah,'a'-'A'        ; convert upper case to lower case
  1088. tstkw3b:cmp    al,'A'
  1089.     jb    tstkw3c
  1090.     cmp    al,'Z'
  1091.     ja    tstkw3c
  1092.     add    al,'a'-'A'        ; convert upper case to lower case
  1093. tstkw3c:cmp    al,ah            ; test characters
  1094.     jne    tstkw3d            ; ne = no match
  1095.     inc     si            ; move to next char
  1096.     inc    bx
  1097.     loop    tstkw3a            ; loop through entire length
  1098. tstkw3d:pop    bx
  1099.     pop    si
  1100.     jcxz    tstkw5            ; z: cx = 0, exit with match;
  1101.                     ;  else select next keyword
  1102. tstkw4:    inc    kbtemp            ; number of keyword to test next
  1103.     mov    cx,kbtemp
  1104.     cmp    cx,kwcnt        ; all done? Recall kbtemp starts at 0
  1105.     jae    tstkwx            ;ae = exhausted search, unsuccessfully
  1106.     mov    al,byte ptr [bx]    ; cnt (keyword length from macro)
  1107.     xor    ah,ah
  1108.     add    ax,4            ; skip over '$' and two byte value
  1109.     add    bx,ax            ; bx = start of next keyword slot
  1110.     jmp    tstkw3            ; do another comparison
  1111.  
  1112. tstkw5:                    ; get action pointer
  1113.     mov    al,byte ptr [bx]    ; cnt (keyword length from macro)
  1114.     xor    ah,ah
  1115.     add    ax,2            ; skip over '$'
  1116.     add    bx,ax            ; now bx points to dispatch value
  1117.     mov    bx,[bx]            ; bx holds dispatch value
  1118.     clc                ; carry clear for success
  1119.     jmp    short tstkwxx        ; exit
  1120.     ret
  1121. tstkwx:    xor    bx,bx            ; exit when no match
  1122.     mov    kbtemp,bx        ; make verb number be zero too
  1123.     stc                ; carry set for failure
  1124. tstkwxx:pop    si
  1125.     pop    cx
  1126.     pop    ax
  1127.     ret
  1128. tstkeyw    endp
  1129.  
  1130. ; Insert asciiz string pointed to by si into string buffer stbuf.
  1131. ; Reg cx has string length upon entry.
  1132. ; Success: returns offset of first free byte (strmax) in string buffer stbuf,
  1133. ; cx = type and Index of new string, and carry clear.
  1134. ; Failure = carry set.
  1135. insertst proc    near
  1136.     push    bx
  1137.     push    dx
  1138.     push    si
  1139.     push    di
  1140.     push    kbtemp        ; save this variable too
  1141.     mov    dx,cx        ; save length of incoming string in dx
  1142.     mov    bx,offset sptable ; table of string offsets
  1143.     mov    kbtemp,0    ; slot number
  1144.     mov    cx,maxstng    ; number of entries, find an empty slot
  1145. insert1:cmp    word ptr[bx],0    ; slot empty?
  1146.     je    insert2        ; e = yes
  1147.     inc    kbtemp        ; remember slot number
  1148.     add    bx,2        ; look at next slot
  1149.     loop    insert1        ; keep looking
  1150.     jmp    short insert4    ; get here if no empty slots
  1151. insert2:            ; see if stbuf has sufficient space
  1152.     mov    cx,dx        ; length of new string to cx
  1153.     mov    di,strmax    ; offset of first free byte in stbuf
  1154.     add    di,cx        ; di = address where this string would end
  1155.     cmp    di,offset stbuf+stbuflen ; beyond end of buffer?
  1156.     jae    insert4        ; ae = yes, not enough room
  1157.     mov    di,strmax    ; point to first free slot in stbuf
  1158.     mov    [bx],di        ; fill slot with address offset of buffer
  1159.     push    es
  1160.     push    ds
  1161.     pop    es        ; point es:di to data segment
  1162.     cld
  1163.     mov    byte ptr [di],cl ; length of text for new string
  1164.     inc    di        ; move to next storage slot
  1165.     rep    movsb        ; copy string text
  1166.     pop    es
  1167.     mov    strmax,di    ; offset of next free byte
  1168.     mov    cx,kbtemp    ; return new slot number with Director Index
  1169.     and    cx,not(strng+verb) ; clear type bits
  1170.     or    cx,strng    ; say type is multi-char string
  1171.     clc            ; say success
  1172.     jmp    short insertx    ; exit
  1173. insert4:stc            ; say no-can-do
  1174. insertx:pop    kbtemp
  1175.     pop    di
  1176.     pop    si
  1177.     pop    dx
  1178.     pop    bx
  1179.     ret
  1180. insertst endp
  1181.  
  1182. ; Remove (delete) string. Enter with listptr preset for director entry.
  1183. ; Acts only on existing multi-char strings; recovers freed space.
  1184. ; All registers preserved.
  1185. remstr    proc    near        
  1186.     push    si
  1187.     mov    si,listptr        ; list pointer
  1188.     test    dirlist[si],strng    ; multi-char string?
  1189.     pop    si
  1190.     jnz    remst1            ; nz = a multi-char string
  1191.     ret                ; else do nothing
  1192. remst1:    push    ax
  1193.     push    bx
  1194.     push    cx
  1195.     push    dx
  1196.     push    si
  1197.     mov    si,listptr
  1198.     mov    ax,dirlist[si]         ; Director table entry
  1199.     and    ax,not(strng+verb) ; clear type bits, leave string's pointer
  1200.     mov    dirlist[si],0        ; clear Director table entry
  1201.     shl    ax,1            ; index words not bytes
  1202.     mov    si,offset sptable     ; list of string offsets in stbuf
  1203.     add    si,ax            ; plus index = current slot
  1204.     mov    bx,[si]            ; get offset of string to be deleted
  1205.     mov    dx,bx            ; save in dx for later
  1206.     mov    cl,byte ptr [bx]    ; get length byte
  1207.     xor    ch,ch            ; get length of subject string
  1208.     inc    cx            ; length byte too, cx has whole length
  1209.     sub    strmax,cx    ; count space to be freed (adj end-of-buf ptr)
  1210.     mov    word ptr [si],0    ; clear sptable of subject string address
  1211.     push    cx            ; save length of purged string
  1212.     push    di            ; save di
  1213.     push    si
  1214.     push    es            ; save es
  1215.     push    ds
  1216.     pop    es        ; setup es:di to be ds:offset of string
  1217.     mov    di,dx        ; destination = start address of purged string
  1218.     mov    si,dx        ; source = start address of purged string
  1219.     add    si,cx        ;  plus string length of purged string.
  1220.     mov    cx,offset stbuf+stbuflen ; 1 + address of buffer end
  1221.     sub    cx,si            ; 1 + number of bytes to move
  1222.     dec    cx            ; number of bytes to move
  1223.     jcxz    remst2            ; z = none
  1224.     cld                ; direction is forward
  1225.     rep    movsb            ; move down preserved strings
  1226. remst2:    pop    es            ; restore regs
  1227.     pop    di
  1228.     pop    si
  1229.     pop    ax        ; recover length of purged string (was in cx)
  1230.     mov    bx,offset sptable     ; string pointer table
  1231.     mov    cx,maxstng        ; max mumber of entries
  1232. remst4:    cmp    [bx],dx        ; does this entry occur before purged string?
  1233.     jbe    remst5        ; be = before or equal, so leave it alone
  1234.     sub    [bx],ax        ; recompute address (remove old string space)
  1235. remst5:    add    bx,2            ; look at next list entry
  1236.     loop    remst4            ; do all entries in sptable
  1237.     pop    si
  1238.     pop    dx
  1239.     pop    cx
  1240.     pop    bx
  1241.     pop    ax
  1242.     ret
  1243. remstr    endp
  1244.  
  1245. shkfre    proc    near            ; show free key & string defs & space
  1246.     push    ax            ; preserves all registers.
  1247.     push    bx
  1248.     push    cx
  1249.     push    dx
  1250.     push    kbtemp
  1251.     mov    dx,offset fremsg
  1252.     mov    ah,prstr
  1253.     int    dos
  1254.     mov    ax,maxkeys        ; max number of key defs
  1255.     sub    ax,nkeys        ; number currently used
  1256.     call    decout            ; show the value
  1257.     mov    ah,prstr
  1258.     mov    dx,offset kyfrdef    ; give key defs msg
  1259.     int    dos
  1260.     mov    bx,offset sptable    ; table of string pointers
  1261.     mov    cx,maxstng        ; number of pointers
  1262.     mov    kbtemp,0        ; number free
  1263. shkfr1:    cmp    word ptr [bx],0        ; slot empty?
  1264.     jne    shkfr2            ; ne = no
  1265.     inc    kbtemp            ; count free defs
  1266. shkfr2:    add    bx,2            ; look at next slot
  1267.     loop    shkfr1            ; do all of them
  1268.     mov    ax,kbtemp        ; number of free defs
  1269.     call    decout            ; display
  1270.     mov    dx,offset stfrdef    ; say free string defs
  1271.     mov    ah,prstr
  1272.     int    dos
  1273.     mov    ax,offset stbuf+stbuflen ; 1 + last byte in stbuf
  1274.     sub    ax,strmax        ; offset of last free byte in stbuf
  1275.     call    decout
  1276.     mov    dx,offset stfrspc    ; give free space part of msg
  1277.     mov    ah,prstr
  1278.     int    dos
  1279.     pop    kbtemp
  1280.     pop    dx
  1281.     pop    cx
  1282.     pop    bx
  1283.     pop    ax
  1284.     ret
  1285. shkfre    endp
  1286.  
  1287. ; Initialize the keyboard tables at Kermit startup time. Optional procedure.
  1288. ; Requires kbdinlst to be configured with mkeyw macro in the form
  1289. ;    mkeyw    'definition',keytype*256+keycode
  1290. ; keytype is 0 for scan codes and non-zero for ascii.
  1291. ; Returns normally.
  1292. kbdinit    proc     near            ; read keyword kbdinlst and setup
  1293.     push    ds            ;  initial keyboard assignments.
  1294.     pop    es            ; set es:di to data segment
  1295.     inc    taklev            ; pretend that we are in Take file
  1296.     mov    si,offset kbdinlst    ; start of list of definitions
  1297. kbdini1:mov    cl,byte ptr [si]    ; cnt field (keyword length of macro)
  1298.     xor    ch,ch
  1299.     jcxz    kbdinix            ; z = null cnt field = end of list
  1300.     inc    si            ; look at text field
  1301.     mov    di,offset tranbuf    ; where defkey expects text
  1302.     cld
  1303.     rep    movsb            ; copy cx chars to tranbuf
  1304.     mov    byte ptr [di],0        ; insert null terminator
  1305.     inc    si            ; skip '$' field
  1306.     mov    ax,word ptr [si]    ; get value field
  1307.     mov    keycode,ax        ; set key ident value
  1308.     push    si
  1309.     call    dfkey2            ; put dfkey to work
  1310.     pop    si
  1311.     add    si,2            ; point to next entry
  1312.     jmp    kbdini1            ; keep working
  1313. kbdinix:dec    taklev            ; reset Take file level
  1314.     ret
  1315. kbdinit    endp
  1316. ;;;    End of System Independent Procedures
  1317.  
  1318. ;;;    Begin System Dependent Procedures
  1319.  
  1320. ; Read keyboard. System dependent.
  1321. ; Return carry set if nothing at keyboard.
  1322. ; If char present return carry clear with key's code in Keycode.
  1323. ; If key is ascii put that in the low byte of Keycode and clear bit Scan in
  1324. ; the high byte; otherwise, put the scan code in the lower byte and set bit
  1325. ; Scan in the high byte.
  1326. ; Bit Scan is set if key is not an ascii code.
  1327. ; Modifies register ax.
  1328. getkey    proc    near
  1329.     mov    keycode,0
  1330.     call    iseof            ; is stdin at eof?
  1331.     jnc    getky5            ; nc = not eof, get more
  1332.      mov    al,trans.escchr        ; Kermit's escape char
  1333.     mov    byte ptr keycode,al    ; save ascii char
  1334.     clc                ;  to get out gracefully at EOF
  1335.     ret                ; and exit
  1336. getky5:    mov    ah,dconio        ; check console
  1337.     mov    dl,0ffh            ; input desired
  1338.     int    dos
  1339.     jnz    getky1            ; nz = char available
  1340.     stc                ; carry set = nothing available
  1341.     jmp    short getkyx        ; exit on no char available
  1342. getky1:    cmp    al,0            ; scan code being returned?
  1343.     jne    getky1a            ; ne = no
  1344.     mov    ah,dconio        ; read second byte (scan code)
  1345.     mov    dl,0ffh
  1346.     int    dos
  1347.     jz    getkyx            ; z = nothing there
  1348.     mov    ah,al            ; scan code goes here
  1349.     mov    al,0            ; ascii code goes here
  1350. getky1a:
  1351.     push    di            ; check key (ax) for aliases
  1352.     push    cx
  1353.     push    es
  1354.     mov    di,offset aliaskey    ; list of aliased keys
  1355.     mov    cx,aliaslen        ; number of entries
  1356.     jcxz    getky2            ; z = no entries
  1357.     push    ds
  1358.     pop    es            ; make es:di point to data segment
  1359.     cld
  1360.     repne    scasw            ; look for a match
  1361.     jne    getky2            ; ne = not there
  1362.     mov    al,0            ; force use of scan code (in ah)
  1363. getky2:    pop    es
  1364.     pop    cx
  1365.     pop    di
  1366.     or    al,al            ; scan code being returned?
  1367.     jnz    getky3            ; nz = no
  1368.     xchg    ah,al            ; put scan code in ident area
  1369.     or    keycode,scan        ; set scan flag (vs ascii)
  1370. getky3:    mov    byte ptr keycode,al    ; return key's code (usually ascii)
  1371.     clc                ; carry clear = got a char
  1372. getkyx:    ret
  1373. getkey    endp
  1374.  
  1375. postkey    proc    near            ; do sys dep action after reading 
  1376.     ret                ; key during active translation
  1377. postkey    endp
  1378.  
  1379. code    ends
  1380.     end
  1381.