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