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