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