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