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