home *** CD-ROM | disk | FTP | other *** search
/ Columbia Kermit / kermit.zip / mskermit / msuz10.asm < prev    next >
Assembly Source File  |  2020-01-01  |  96KB  |  2,007 lines
  1.         NAME    msuz10
  2. ; file MSUZ10.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. ; Kermit system dependent module for Heath/Zenith Z100
  9. ; Keyboard translator, by Joe R. Doupnik, Dec 1986
  10. ;  with contributions from David L. Knoell.
  11. ; Adapted for the Z-100 by Bo G. Gedda, May 1990
  12. ; Edit history
  13. ; 2 March 1991 version 3.10
  14. ; Last edit 20 August 1992
  15. ; Kverb \kscroll (F11) added
  16. ; Bo Gedda
  17. ;
  18. ;
  19.  
  20.         public  keybd, dfkey, shkey, msuinit, kbcodes, keycom, dosflg, dosflg1
  21.  
  22. ; some definitions
  23.  
  24. shift   equ     200h                    ; IBM, synonym for right or left shift
  25. control equ     400h                    ; IBM, synonym for control shift
  26. alt     equ     800h                    ; IBM, synonym for alt shift
  27.  
  28. maxkeys equ     200                     ; maximum number of key definitions
  29. maxstng equ     128                     ; maximum number of multi-char strings
  30. stbuflen equ    1000                    ; length of string buffer (bytes)
  31.  
  32. verb    equ     8000h                   ; dirlist flag: use verb action table
  33. strng   equ     4000h                   ; dirlist flag: use string action table
  34. scan    equ     100h                    ; keycode flag: code is scan not ascii
  35. braceop equ     7bh                     ; opening curly brace
  36. bracecl equ     7dh                     ; closing curly brace
  37.  
  38. ; Z-100 Keyboard ports
  39. keydat  equ     0f4h            ; data
  40. keycmd  equ     0f5h            ; command
  41. keystat equ     keycmd          ; status
  42.  
  43. ; Z-100 Keyboard status masks
  44. KPR     equ     2               ; 00000010b, ready if this is NOT set
  45. KDA     equ     1               ; 00000001b, data available if set
  46.  
  47. ; Z-100 Keyboard commands
  48. keyrst  equ     00h             ; reset
  49. keyrpon equ     01h             ; auto repeat on
  50. keyrpof equ     02h             ; auto repeat off
  51. keyclon equ     03h             ; click on
  52. keyclof equ     04h             ; click off
  53. keyclr  equ     05h             ; clear buffer
  54. keycli  equ     06h             ; make key click
  55. keybel  equ     07h             ; make bell sound
  56. keyena  equ     08h             ; enable keyboard
  57. keydis  equ     09h             ; disable keyboard
  58. keyeve  equ     0ah             ; make keyboard event driven (up/down mode)
  59. keyasc  equ     0bh             ; make keyboard scan ascii
  60. keyiena equ     0ch             ; enable interrupt
  61. keyidis equ     0dh             ; disable interrupt
  62.  
  63. data    segment
  64.         extrn taklev:byte, comand:byte, flags:byte
  65.         extrn shkadr:word, stkadr:word, trans:byte, ttyact:byte
  66.                                                 ; system dependent references
  67.     extrn vtmacname:word, vtmaclen:word    ; external macro, in msyibm
  68.         extrn vtemu:byte                ; emulator data
  69.         
  70. ;;;     System Independent local storage
  71.  
  72. tranbuf db      132 dup (?)             ; 132 byte translator work buffer
  73. crlf    db      cr,lf,'$'
  74. dfhelp1 db    cr,lf,' Enter key',27h,'s identification as a character',cr,lf
  75.         db      '  or as its numerical equivalent \{b##} of ascii',cr,lf
  76.         db      '  or as its scan code \{b##}'
  77.         db      cr,lf,'  or as SCAN followed by its scan code',cr,lf
  78.         db      '    where b is O for octal, X for hex, or D for decimal'
  79.         db      ' (default).',cr,lf,'    Braces {} are optional.'
  80.         db      cr,lf,'    Follow the identification with the new definition.'
  81.         db      cr,lf,' or CLEAR to restore initial key settings'
  82.         db      cr,lf,' or ON (def) to use SCAN CODES, OFF to use ASCII.$';Z100
  83. dfaskky db      cr,lf,' Push key to be defined: $'
  84. dfaskdf db      ' Enter new definition: ',0             ; asciiz for prompt
  85. verbbad db      cr,lf,' No such verb',cr,lf,'$'
  86. strbad  db      cr,lf,' Not enough space for new string',cr,lf,'$'
  87. keyfull db      cr,lf,' No more space to define keys',cr,lf,'$'
  88. dfkoops db      cr,lf,' Oops! That is Kermit',27h,'s Escape Char.'
  89.         db      ' Translation is not permitted.',cr,lf,'$'
  90. shkmsg1 db      cr,lf,'Push key to be shown (? shows all): $'
  91. shkmsg2 db      ' decimal is defined as',cr,lf,'$'
  92. shkmsg3 db      cr,lf,'... more, press a key to continue ...$'
  93. kwarnmsg db     cr,lf,' Notice: this form of Set Key is obsolete$'
  94.  
  95. ascmsg  db      ' Ascii char: $'
  96. scanmsg db      ' Scan Code $'
  97. strngmsg db     ' String: $'
  98. verbmsg db      ' Verb: $'
  99. noxmsg  db      ' Self, no translation.$'
  100. fremsg  db      cr,lf,' Free space: $'
  101. kyfrdef db      ' key and $'
  102. stfrdef db      ' string definitions, $'
  103. stfrspc db      ' string characters.',cr,lf,'$'
  104.                                         ; translation tables
  105. keylist dw      maxkeys dup (0)         ; 16 bit keycodes, paralled by dirlist
  106. dirlist dw      maxkeys dup (0)         ; director {v+s} + {index | new char}
  107. sptable dw      maxstng dup (0)         ; list of asciiz string offsets
  108. stbuf   dw      stbuflen dup (0)        ; buffer for strings
  109. strmax  dw      stbuf                   ; first free byte in stbuf
  110. listptr dw      ?                       ; item number for keylist and dirlist
  111. nkeys   dw      0                       ; number of actively defined keys
  112. keycode dw      ?                       ; ascii/scan code for key
  113. kbtemp  dw      ?                       ; scratch storage for translator
  114. brace   db      ?                       ; brace detected flag byte
  115. oldform db      0                       ; old form Set Key, if non-zero
  116. verblen dw      ?                       ; length of user's verb (work temp)
  117. kwcnt   dw      ?                       ; number of keywords (work temp)
  118. msutake db      ?                       ; if being run from take file or not
  119. stringcnt dw    0                       ; qty of string chars to be processed
  120. stringptr dw    0                       ; address of next string char
  121. twelve  dw      11d                 ; sorry, one less than that for Z-100
  122. dosflg  db      0
  123. ;;;     End System Independent Data Area
  124.  
  125. ;;;     System Dependent Data Area
  126. dosflg1 db      0               ; scan codes enabled/key extension disabled=1
  127. nrcptr  dw      0               ; pointer to code page to NRC table
  128. latinptr dw     0               ; pointer to code page to Latin1 table
  129. DECmnptr dw     0               ; pointer to code page to DEC-MCS table
  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. VT52 keys (arrows and keypad):',cr,lf
  140.         db   '   uparr, dnarr, lfarr, rtarr, kpminus, kpcoma, kpdot, kpenter,'
  141.         db      cr,lf
  142.         db   '   Gold (same as PF1), PF1, PF2, PF3, PF4, kp0, ... kp9'
  143.     db      cr,lf,' Z-100/Heath-19 function and special key actions:',cr,lf
  144.     db   '   F0, ... F12, SF0, ... SF11, i_chr, d_chr, i_line, d_line'
  145.         db      cr,lf,' Kermit screen control and actions:',cr,lf
  146.         db   '   upscn, dnscn, homscn, endscn, upone, dnone, prtscn, dump,'
  147.         db      cr,lf
  148.     db   '   scroll, logoff, logon, modeline, break, lbreak,'
  149.         db      cr,lf
  150. ;        db   '   logoff, logon, termtype, reset, modeline, break,'
  151.  ;       db      ' lbreak, nethold,'
  152.   ;      db      cr,lf
  153.         db   '   hangup, null (send one), DOS, help,'
  154.         db   ' status, exit'
  155.         db      cr,lf,'$'
  156.  
  157.         ; Z-100 scan codes, used for setting keycode shift and control flags
  158.         ; column 1 unshift, column 2 shift, column 3 control, column 4
  159.         ; shift-control
  160. z10keyl equ     this byte
  161.         db      30h,29h,30h,29h         ; 0,)
  162.         db      31h,21h,31h,21h         ; 1,!
  163.         db      32h,40h,32h,00h         ; 2,@
  164.         db      33h,23h,33h,23h         ; 3,#
  165.         db      34h,24h,34h,24h         ; 4,$
  166.         db      35h,25h,35h,25h         ; 5,%
  167.         db      36h,5eh,36h,1eh         ; 6,^
  168.         db      37h,26h,37h,26h         ; 7,&
  169.         db      38h,2ah,38h,2ah         ; 8,*
  170.         db      39h,28h,39h,28h         ; 9,(
  171.         db      61h,41h,01h,01h         ; a,A
  172.         db      62h,42h,02h,02h         ; b,B
  173.         db      63h,43h,03h,03h         ; c,C
  174.         db      64h,44h,04h,04h         ; d,D
  175.         db      65h,45h,05h,05h         ; e,E
  176.         db      66h,46h,06h,06h         ; f,F
  177.         db      67h,47h,07h,07h         ; g,G
  178.         db      68h,48h,08h,08h         ; h,H
  179.         db      69h,49h,09h,09h         ; i,I
  180.         db      6ah,4ah,0ah,0ah         ; j,J
  181.         db      6bh,4bh,0bh,0bh         ; k,K
  182.         db      6ch,4ch,0ch,0ch         ; l,L
  183.         db      6dh,4dh,0dh,0dh         ; m,M
  184.         db      6eh,4eh,0eh,0eh         ; n,N
  185.         db      6fh,4fh,0fh,0fh         ; o,O
  186.         db      70h,50h,10h,10h         ; p,P
  187.         db      71h,51h,11h,11h         ; q,Q
  188.         db      72h,52h,12h,12h         ; r,R
  189.         db      73h,53h,13h,13h         ; s,S
  190.         db      74h,54h,14h,14h         ; t,T
  191.         db      75h,55h,15h,15h         ; u,U
  192.         db      76h,56h,16h,16h         ; v,V
  193.         db      77h,57h,17h,17h         ; w,W
  194.         db      78h,58h,18h,18h         ; x,X
  195.         db      79h,59h,19h,19h         ; y,Y
  196.         db      7ah,5ah,1ah,1ah         ; z,Z
  197.         db      08h,08h,08h,08h         ; BACKSPACE
  198.         db      09h,09h,09h,09h         ; TAB
  199.         db      0ah,0ah,0ah,0ah         ; LINE FEED
  200.         db      0dh,0dh,0dh,0dh         ; RETURN
  201.         db      1bh,1bh,1bh,1bh         ; ESC
  202.         db      20h,20h,20h,20h         ; SPACE
  203.         db      27h,22h,27h,22h         ; ',"
  204.         db      2ch,3ch,2ch,3ch         ; ,,<
  205.         db      2dh,5fh,2dh,1fh         ; -,_
  206.         db      2eh,3eh,2eh,3eh         ; .,>
  207.         db      2fh,3fh,2fh,3fh         ; /,?
  208.         db      3bh,3ah,3bh,3ah         ; ;,:
  209.         db      3dh,2bh,3dh,2bh         ; =,+
  210.         db      5bh,7bh,1bh,7bh         ; [,{
  211.         db      5ch,7ch,1ch,7ch         ; \,|
  212.         db      5dh,7dh,1dh,7dh         ; ],}
  213.         db      60h,7eh,60h,7eh         ; `,~
  214.         db      7fh,7fh,7fh,7fh         ; DELETE
  215.         db      8dh,0cdh,8dh,0cdh       ; ENTER
  216.         db      95h,0d5h,95h,0c5h       ; HELP
  217.         db      96h,0d6h,96h,0d6h       ; F0
  218.         db      97h,0d7h,97h,0d7h       ; F1
  219.         db      98h,0d8h,98h,0d8h       ; F2
  220.         db      99h,0d9h,99h,0d9h       ; F3
  221.         db      9ah,0dah,9ah,0dah       ; F4
  222.         db      9bh,0dbh,9bh,0dbh       ; F5
  223.         db      9ch,0dch,9ch,0dch       ; F6
  224.         db      9dh,0ddh,9dh,0ddh       ; F7
  225.         db      9eh,0deh,9eh,0deh       ; F8
  226.         db      9fh,0dfh,9fh,0dfh       ; F9
  227.         db      0a0h,0e0h,0a0h,0e0h     ; F10
  228.         db      0a1h,0e1h,0a1h,0e1h     ; F11
  229.         db      0a2h,0e2h,0a2h,0e2h     ; F12
  230.         db      0a3h,0e3h,0a3h,0e3h     ; I CHR, D CHR
  231.         db      0a4h,0e4h,0a4h,0e4h     ; I LINE, D LINE
  232.         db      0a5h,0e5h,0a5h,0e5h     ; UP ARROW
  233.         db      0a6h,0e6h,0a6h,0e6h     ; DOWN ARROW
  234.         db      0a7h,0e7h,0a7h,0e7h     ; RIGHT ARROW
  235.         db      0a8h,0e8h,0a8h,0e8h     ; LEFT ARROW
  236.         db      0a9h,0e9h,0a9h,0e9h     ; HOME
  237.         db      0aah,0eah,0aah,0eah     ; BREAK
  238.         db      0adh,0edh,0adh,0edh     ; keypad -
  239.         db      0aeh,0eeh,0aeh,0eeh     ; keypad .
  240.         db      0b0h,0f0h,0b0h,0f0h     ; keypad 0
  241.         db      0b1h,0f1h,0b1h,0f1h     ; keypad 1
  242.         db      0b2h,0f2h,0b2h,0f2h     ; keypad 2
  243.         db      0b3h,0f3h,0b3h,0f3h     ; keypad 3
  244.         db      0b4h,0f4h,0b4h,0f4h     ; keypad 4
  245.         db      0b5h,0f5h,0b5h,0f5h     ; keypad 5
  246.         db      0b6h,0f6h,0b6h,0f6h     ; keypad 6
  247.         db      0b7h,0f7h,0b7h,0f7h     ; keypad 7
  248.         db      0b8h,0f8h,0b8h,0f8h     ; keypad 8
  249.         db      0b9h,0f9h,0b9h,0f9h     ; keypad 9
  250. lz10keyl equ    $ - z10keyl
  251.  
  252. kverbs  db      72                      ; number of table entries below
  253.         mkeyw   'uparr',uparrw          ; independent of ordering and case!
  254.         mkeyw   'dnarr',dnarrw          ; mkeyw 'name',procedure entry point
  255.         mkeyw   'lfarr',lfarr
  256.         mkeyw   'rtarr',rtarr
  257.         mkeyw   'Gold',pf1
  258.         mkeyw   'PF1',pf1
  259.         mkeyw   'PF2',pf2
  260.         mkeyw   'PF3',pf3
  261.         mkeyw   'PF4',pf4
  262.         mkeyw   'KP0',kp0
  263.         mkeyw   'KP1',kp1
  264.         mkeyw   'KP2',kp2
  265.         mkeyw   'KP3',kp3
  266.         mkeyw   'KP4',kp4
  267.         mkeyw   'KP5',kp5
  268.         mkeyw   'KP6',kp6
  269.         mkeyw   'KP7',kp7
  270.         mkeyw   'KP8',kp8
  271.         mkeyw   'KP9',kp9
  272.         mkeyw   'kpminus',kpminus
  273.         mkeyw   'kpcoma',kpcoma
  274.         mkeyw   'kpenter',kpenter
  275.         mkeyw   'kpdot',kpdot
  276.         mkeyw   'F0',f0
  277.         mkeyw   'F1',f1
  278.         mkeyw   'F2',f2
  279.         mkeyw   'F3',f3
  280.         mkeyw   'F4',f4
  281.         mkeyw   'F5',f5
  282.         mkeyw   'F6',f6
  283.         mkeyw   'F7',f7
  284.         mkeyw   'F8',f8
  285.         mkeyw   'F9',f9
  286.         mkeyw   'F10',f10
  287.         mkeyw   'F11',f11
  288.         mkeyw   'F12',f12
  289.         mkeyw   'SF0',sf0
  290.         mkeyw   'SF1',sf1
  291.         mkeyw   'SF2',sf2
  292.         mkeyw   'SF3',sf3
  293.         mkeyw   'SF4',sf4
  294.         mkeyw   'SF5',sf5
  295.         mkeyw   'SF6',sf6
  296.         mkeyw   'SF7',sf7
  297.         mkeyw   'SF8',sf8
  298.         mkeyw   'SF9',sf9
  299.         mkeyw   'SF10',sf10
  300.         mkeyw   'SF11',sf11
  301.         mkeyw   'i_chr',i_chr
  302.         mkeyw   'd_chr',d_chr
  303.         mkeyw   'i_line',i_line
  304.         mkeyw   'd_line',d_line
  305. comment @
  306.         mkeyw   'decF6',decf6
  307.         mkeyw   'decF7',decf7
  308.         mkeyw   'decF8',decf8
  309.         mkeyw   'decF9',decf9
  310.         mkeyw   'decF10',decf10
  311.         mkeyw   'decF11',decf11
  312.         mkeyw   'decF12',decf12
  313.         mkeyw   'decF13',decf13
  314.         mkeyw   'decF14',decf14
  315.         mkeyw   'decHelp',dechelp
  316.         mkeyw   'decDo',decdo
  317.         mkeyw   'decF17',decf17
  318.         mkeyw   'decF18',decf18
  319.         mkeyw   'decF19',decf19
  320.         mkeyw   'decF20',decf20
  321.         mkeyw   'decFind',decfind
  322.         mkeyw   'decInsert',decinsert
  323.         mkeyw   'decRemove',decremove
  324.         mkeyw   'decSelect',decselect
  325.         mkeyw   'decPrev',decprev
  326.         mkeyw   'decNext',decnext
  327.         mkeyw   'termtype',vtans52
  328.         mkeyw   'reset',vtinit
  329. end comment @
  330.         mkeyw   'dnscn',dnwpg
  331.         mkeyw   'upscn',upwpg
  332.         mkeyw   'endscn',endwnd
  333.         mkeyw   'upone',upone
  334.         mkeyw   'dnone',dnone
  335.         mkeyw   'prtscn',trnprs
  336.         mkeyw   'dump',dmpscn
  337.         mkeyw   'homscn',homwnd
  338.         mkeyw   'modeline',trnmod
  339.         mkeyw   'break',sendbr
  340.         mkeyw   'lbreak',sendbl
  341.         mkeyw   'hangup',chang
  342.         mkeyw   'null',snull
  343.         mkeyw   'logon',klogon
  344.         mkeyw   'logoff',klogof
  345.         mkeyw   'DOS',cdos
  346.         mkeyw   'help',cquery
  347.         mkeyw   'status',cstatus
  348.         mkeyw   'exit',cquit
  349.     mkeyw    'scroll',scroll
  350.  
  351.                                         ; Kermit Z-100 Initialization keypad
  352.                                         ;  data.
  353.                                         ; PF1 to PF4 are shifted home,
  354.                                         ;  leftarrow, rightarrow and uparrow
  355.                                         ; first the Z-100 numeric keypad
  356. kbdinlst equ    this byte               ; mkeyw 'definition',keycode
  357.         mkeyw   '\khomscn',scan+0a9h    ; home key
  358.         mkeyw   '\klfarr',scan+0a8h     ; leftarrow
  359.         mkeyw   '\krtarr',scan+0a7h     ; rightarrow
  360.         mkeyw   '\kuparr',scan+0a5h     ; uparrow
  361.         mkeyw   '\kkp7',scan+0b7h       ; kp7
  362.         mkeyw   '\kkp8',scan+0b8h       ; kp8
  363.         mkeyw   '\kkp9',scan+0b9h       ; kp9
  364.         mkeyw   '\kdnarr',scan+0a6h     ; downarrow
  365.         mkeyw   '\kkp4',scan+0b4h       ; kp4
  366.         mkeyw   '\kkp5',scan+0b5h       ; kp5
  367.         mkeyw   '\kkp6',scan+0b6h       ; kp6
  368.         mkeyw   '\kkpminus',scan+0adh   ; kp minus
  369.         mkeyw   '\kkp1',scan+0b1h       ; kp1
  370.         mkeyw   '\kkp2',scan+0b2h       ; kp2
  371.         mkeyw   '\kkp3',scan+0b3h       ; kp3
  372.         mkeyw   '\kkpenter',scan+08dh   ; Enter key
  373.         mkeyw   '\kkp0',scan+0b0h       ; kp0
  374.         mkeyw   '\kkpdot',scan+0aeh     ; kp dot
  375.         mkeyw   '\kgold',scan+shift+0e9h; shifted home key      => VT100 gold
  376.         mkeyw   '\kpf2',scan+shift+0e8h ; shifted left arrow    => VT100 PF2
  377.         mkeyw   '\kpf3',scan+shift+0e7h ; shifted right arrow   => VT100 PF3
  378.         mkeyw   '\kpf4',scan+shift+0e5h ; shifted up arrow      => VT100 PF4
  379.         mkeyw   '\kd_chr',scan+shift+0f7h   ; shifted kp7
  380.         mkeyw   '\kuparr',scan+shift+0f8h   ; shifted kp8
  381.         mkeyw   '\ki_chr',scan+shift+0f9h   ; shifted kp9
  382.         mkeyw   '\kkpminus',scan+shift+0e6h ; shifted down arrow => VT100 minus
  383.         mkeyw   '\klfarr',scan+shift+0f4h   ; shifted kp4
  384.         mkeyw   '\khomscn',scan+shift+0f5h  ; shifted kp5
  385.         mkeyw   '\krtarr',scan+shift+0f6h   ; shifted kp6
  386.         mkeyw   '\kkpcoma',scan+shift+0edh  ; shifted kp minus   => VT100 comma
  387.         mkeyw   '\ki_line',scan+shift+0f1h  ; shifted kp1
  388.         mkeyw   '\kdnarr',scan+shift+0f2h   ; shifted kp2
  389.         mkeyw   '\kd_line',scan+shift+0f3h  ; shifted kp3
  390.         mkeyw   '\x0d',scan+shift+0cdh      ; shifted enter
  391.         mkeyw   '0',scan+shift+0f0h         ; shifted kp0
  392.         mkeyw   '.',scan+shift+0eeh         ; shifted kp dot
  393.                                         ; Some function keys
  394.                                         ; VT100 function keys
  395.         mkeyw   '\kf0',scan+096h        ; F0
  396.         mkeyw   '\kf1',scan+097h        ; F1
  397.         mkeyw   '\kf2',scan+098h        ; F2
  398.         mkeyw   '\kf3',scan+099h        ; F3
  399.         mkeyw   '\kf4',scan+09ah        ; F4
  400.         mkeyw   '\kf5',scan+09bh        ; F5
  401.         mkeyw   '\kf6',scan+09ch        ; F6
  402.         mkeyw   '\kf7',scan+09dh        ; F7
  403.         mkeyw   '\kf8',scan+09eh        ; F8
  404.         mkeyw   '\kf9',scan+09fh        ; F9
  405.         mkeyw   '\kf10',scan+0a0h       ; F10
  406.     mkeyw    '\kscroll',scan+0a1h    ; F11 Recover last screen
  407.         mkeyw   '\kprtscn',scan+0a2h    ; F12 Kermit toggle prn scrn
  408.         mkeyw   '\ksf0',scan+shift+0d6h ; SF0
  409.         mkeyw   '\ksf1',scan+shift+0d7h ; SF1
  410.         mkeyw   '\ksf2',scan+shift+0d8h ; SF2
  411.         mkeyw   '\ksf3',scan+shift+0d9h ; SF3
  412.         mkeyw   '\ksf4',scan+shift+0dah ; SF4
  413.         mkeyw   '\ksf5',scan+shift+0dbh ; SF5
  414.         mkeyw   '\ksf6',scan+shift+0dch ; SF6
  415.         mkeyw   '\ksf7',scan+shift+0ddh ; SF7
  416.         mkeyw   '\ksf8',scan+shift+0deh ; SF8
  417.         mkeyw   '\ksf9',scan+shift+0dfh ; SF9
  418.         mkeyw   '\ksf10',scan+shift+0e0h; SF10
  419.         mkeyw   '\kdump',scan+shift+0e1h; SF11 Kermit Dump Screen
  420.                     ; SF12 not available, used by DOS prtscr
  421.                                         ; Some special keys
  422.         mkeyw   '\klbreak',scan+shift+0eah; Shift-Break sends a Long Break
  423.         mkeyw   '\khelp',scan+095h        ; Connect mode drop down menu
  424.         mkeyw   '\kstatus',scan+shift+0d5h; Display Status
  425. ;       mkeyw   '\kdnone',scan+0a3h       ; I CHR  scrolls down 1 line
  426. ;       mkeyw   '\kupone',scan+shift+0e3h ; D CHR  scrolls up   1 line
  427. ;       mkeyw   '\kdnscn',scan+0a4h       ; I LINE scrolls down 1 page
  428. ;       mkeyw   '\kupscn',scan+shift+0e4h ; D LINE scrolls up   1 page
  429.         mkeyw   '\ki_chr',scan+0a3h       ; I CHR  sends ESC @ or ESC O
  430.         mkeyw   '\kd_chr',scan+shift+0e3h ; D CHR  sends ESC N
  431.         mkeyw   '\ki_line',scan+0a4h      ; I LINE sends ESC L
  432.         mkeyw   '\kd_line',scan+shift+0e4h; D LINE sends ESC M
  433.         dw      0                       ; end of table marker
  434.  
  435. kbcodes dw      80h                     ; keyboard read codes, 80h=not inited
  436.  
  437. data    ends
  438.  
  439. ;                       Documentation
  440. ;Translating a key:
  441. ;   The translator is called to obtain keyboard input; it sends characters to
  442. ; the serial port through standard controlled echo procedures or invokes
  443. ; named procedures. It returns carry clear when its operation is completed
  444. ; for normal actions and carry set when Connect mode must be exited. When
  445. ; Connect mode is exited the just read char should be passed in Kbdflg 
  446. ; to msster.asm for invoking actions such as Status, send a break,
  447. ; quit connect mode; system dependent procedure Term is responsible for this. 
  448. ;
  449. ;  Principal procedures are -
  450. ;       msuinit         Initializes keyboard translator in this file when
  451. ;                       Kermit first begins. Installs dfkey and shkey as the
  452. ;                       procedures used for Set Key and Show Key. Sys Indep.
  453. ;                       Called from msx or msy init procs. System Independent.
  454. ;       keybd           Performs the translation, outputs chars to the serial
  455. ;                       port or invokes a Kermit action routine. Sys Indep.
  456. ;       dfkey           Defines a key's translation. Reads command line
  457. ;                       via Kermit's command parser comnd. System Independent.
  458. ;       shkey           Shows translation of a key. Requests user to push
  459. ;                       selected key. System Independent.
  460. ;
  461. ;       kbdinit         optional. Initializes the translation tables when
  462. ;                       Kermit starts up. Called by msuinit. System Dependent.
  463. ;       getkey          Performs the keyboard read and returns results in
  464. ;                       a standardized system independent format. Sys Depend.
  465. ;       postkey         called by active translator after obtaining a keycode.
  466. ;                       Used to provide extra local actions (keyclick) only
  467. ;                       in Connect mode (not during Set/Show key commands).
  468. ;                       Called by keybd. System dependent.
  469. ; Supporting system independent procedures are -
  470. ; shkfre (show string free space), tstkeyw (finds user's keyword in the verb
  471. ; table), insertst (insert string in buffer), remstr (delete string in buffer).
  472. ;
  473. ;   System dependent procedure Getkey reads a keycode (usually via a Bios
  474. ; call). On IBM compatible machines this yields <ah=scan code, al=ascii>
  475. ; for ordinary keys, or <ah=scan code, al=0> for special keys such as F1,
  476. ; or <ah=0, al=###> when Alt### is used.
  477. ; For any system, the canonical output form is the key's code in Keycode.
  478. ; Place the ascii code (or scan code if none) in byte Keycode and ancillary
  479. ; info (shift states plus marker bit for scan codes) in byte Keycode + 1.
  480. ; 
  481. ;    Procedure Keybd calls Getkey for the Keycode, checks list of translatable
  482. ; keys Keylist, and then either sends an ascii string (one or more characters)
  483. ; or invokes a Kermit action verb. List Dirlist indicates what kind of 
  484. ; translation to do. Keybd is system independent but may contain system
  485. ; dependent special actions such as echoing keyclicks. Keybd calls system
  486. ; dependent procedure Postkey just after calling getkey so local actions
  487. ; such as keyclicks can be activated only during Connect mode operations.
  488. ;
  489. ;    Keylist is a packed but unordered list of 16 bit keycodes which need
  490. ; translation. The lower order byte holds a key code (ascii char or scan code)
  491. ; while the high byte holds a scan code marker bit (0 if ascii code in low
  492. ; byte) plus any ancillary keyboard information such as Control/Shift/Alt/Meta
  493. ; keys being held down; these are of use in Show Key presentations.
  494. ;    Dirlist parallels Keylist to provide the kind of translation, verb or
  495. ; string, in the two highest bits with the other bits holding either
  496. ; a single new replacement character or the item number in lists of verbs
  497. ; or strings. If neither verb nor strng type bits are set in a dirlist
  498. ; word then the translation is a single new character held in the lower
  499. ; eight bits of that dirlist word.
  500. ;
  501. ;    The number of key translations is assembly constant Maxkeys (def 128).
  502. ;    The maximum number of strings is assembly constant Maxstngs (def 64).
  503. ;    The maximum number of verbs is 256 and is set by building table Kverbs.
  504. ;
  505. ;   For verbs, use the Item number from the Director table Dirlist to select
  506. ; a procedure offset from the structured list Kverbs and jump to that offset.
  507. ; Most verb procedures return carry clear to stay within Connect mode.
  508. ; Verbs requiring exiting Connect mode return carry set and may set byte
  509. ; Kbdflg to a char code which will be read by msster.asm for activating a
  510. ; transient Kermit action such as send a break (Kbdflg = 'b').
  511. ; Kbdflg is stored in msster.asm (as zero initially, meaning ignore it).
  512. ; Action verb procedures are normally located in a system dependent file.
  513. ;
  514. ;   For multi-char strings, use Item number from Director table Dirlist to
  515. ; select a pointer to a string. The list of string pointers is Sptable
  516. ; (string pointer table) which holds the offset in the data segment of the
  517. ; strings stored in buffer Stbuf. In stbuf strings are held as: one byte of
  518. ; length of following text and then the text itself (permits embedded nulls).
  519. ;  Use Chrout to send each string character, and finally return from Keybd
  520. ; with carry clear.
  521. ;
  522. ;   For single character replacements obtain the new character from the lower
  523. ; order byte of Director table Dirlist. If the character is Kermit's present
  524. ; escape character return from Keybd carry set to leave connect mode.
  525. ; Otherwise, send the character via Chrout and return from Keybd carry clear.
  526.  
  527. ; Keylist table format:
  528. ;    7 bits   1 bit   8 bits
  529. ; +----------+----+------------+ scan bit = 1 if key's code is non-ascii
  530. ; | aux info |scan| key's code | aux info = system dependent, used only to
  531. ; +----------+----+------------+            help identify key
  532. ;
  533. ; Dirlist table format            v s   meaning
  534. ;   1   1      14 bits            0 0   copy out one byte translation
  535. ; +---+---+--------------------+  1 0   copy out multi-char string number Item
  536. ; | v | s | item # or new char |  0 1   do action verb number Item
  537. ; +---+---+--------------------+  1 1   (not used)
  538. ;
  539. ; Table kverbs is organized by macro mkeyw as -
  540. ;       kverbs  db      number of table entries
  541. ;       (each entry is in the form below:)
  542. ;               db      number of bytes in verbname
  543. ;               db      'verbname'              variable length
  544. ;               db      '$'                     for printing
  545. ;               dw      value                   offset of procedure
  546. ;
  547. ;
  548. ;   Dfkey defines a key to be itself (undefines it) or a single replacement
  549. ; character or a character string or a Kermit action verb. Dfkey requires
  550. ; a command line so that it may be invoked by Take files but can be forced
  551. ; to prompt an interactive user to push a key. Syntax is discussed below.
  552. ; Note that redefined keys have their old definitions cleared so that
  553. ; old string space is reclaimed automatically.
  554. ;
  555. ;   Shkey displays a key's definition and the user is asked to push the
  556. ; selected key. The free space for strings is always shown afterward. See
  557. ; below for syntax.
  558. ;
  559. ;   Kbdinit is an optional routine called when Kermit starts up. It fills in
  560. ; the translation tables with desirable default values to save having to
  561. ; use long mskermit.ini files. The default values are stored in a structured
  562. ; table similar to (but not the same as) Dfkey's command lines; the keycode
  563. ; values are preset by hand to 16 bit numbers.
  564.  
  565. ;Defining a key:
  566. ; Command is SET KEY <key ident><whitespace><definition>
  567. ;
  568. ; <key ident> is
  569. ;               a single ordinary ascii char or
  570. ;               the numerical equivalent of an ascii char or
  571. ;               a Scan Code written as a number or
  572. ;               keyword SCAN followed by a number.
  573. ;               ?       Displays help message.
  574. ;       Numbers and Binary codes are of the form
  575. ;               \123    a decimal number
  576. ;               \o456   an octal number         base letters o, d, x can be
  577. ;               \d213   a decimal number        upper or lower case
  578. ;               \x0d    a hex number
  579. ;               \{b###}  braces around above material following slash.
  580. ;
  581. ; <whitespace> is one or more spaces and or tabs.
  582. ;
  583. ; <definition> is
  584. ;       missing altogether which "undefines" a key.
  585. ;       \Kverb          for a Kermit action verb; upper or lower case K is ok
  586. ;       \{Kverb}        ditto. Verb is the name of an action verb.
  587. ;       text            a string with allowed embedded whitespace and embedded
  588. ;                       binary chars as above. This kind of string may not
  589. ;                       commence with sequences \K or \{K; use braces below.
  590. ;       {text}          string confined to material within but excluding
  591. ;                       the braces. Note, where the number of opening braces
  592. ;                       exceeds the number of closing braces the end of line
  593. ;                       terminates the string: {ab{}{{c}d ==> ab{}{{c}d
  594. ;                       but  {ab}{{c}d ==> ab.
  595. ;       ?               Displays help message and lists all action verbs.
  596. ;
  597. ;       If Set Key is given interactively, as opposed to within a Take
  598. ;       file, the system will prompt for inputs if none is on the command
  599. ;       line. The response to Push key to be defined cannot be edited.
  600. ;
  601. ;       Text which reduces to a single replacement character is put into a
  602. ;       table separate from the multi-character strings (maxstng of these).
  603. ;       A key may be translated into any single 8 bit code.
  604. ;       
  605. ;       Comments can follow a Kermit action verb or a braced string; no
  606. ;       semicolon is required since all are stripped out by the Take file
  607. ;       reader before the defining text is seen by SET KEY.
  608. ;
  609. ;       The current Kermit escape character cannot be translated without
  610. ;       subtrafuge.
  611. ;
  612. ;       Examples:
  613. ;               Set Key q z
  614. ;                               makes key q send character z
  615. ;               Set Key \7 \27[0m
  616. ;                               makes key Control G send the four byte
  617. ;                               string  ESC [ 0 m
  618. ;               Set Key q
  619. ;                               undefines key q so it sends itself (q) again.
  620. ;               Set Key \2349 \kexit
  621. ;                               defines IBM Alt-X to invoke the leave connect
  622. ;                               mode verb "exit" (Kermit's escape-char ^] C).
  623. ;               Set Key \x0c Login \{x0d}myname\{x0d}mypass\x0d
  624. ;                               defines Control L to send the string
  625. ;                               Login <cr>myname<cr>mypass<cr>
  626. ;
  627. ; Alternative Set Key syntax for backward compatibility with previous versions
  628. ;       The same forms as above except the key identification number must
  629. ;       be decimal and must Not have a leading backslash. Example:
  630. ;       Set Key Scan 59 This is the F1 key
  631. ;
  632. ;       If the definition is omitted it may be placed on the following line;
  633. ;       if that line is also empty the key is undefined (defined as Self).
  634. ;       A warning message about obsolete syntax will be given followed by
  635. ;       the key's modern numerical value and new definition. Only "special"
  636. ;       keys (those not producing ascii codes) are compatible with this
  637. ;       translator.
  638. ;
  639. ;Showing a key:
  640. ; Command is SHOW KEY <cr>
  641. ; System prompts user to press a key and shows the definition plus the
  642. ; free space for strings. Query response results in showing all definitions.
  643. ;                       End Documentation
  644.  
  645. code    segment
  646.                 ; system independent external items
  647.         extrn   comnd:near, prompt:near, iseof:near     ; in msscmd
  648.         extrn   strlen:near, prtscr:near        ; in mssfil
  649.         extrn   cnvlin:near, katoi:near, decout:near    ; in msster
  650.                 ; system dependent external items
  651.         extrn   beep:near, ena_scan:near, dis_scan:near ; in msxz10
  652.         extrn   vclick:near                             ; in msxz10
  653.                 ; these are system dependent action verbs, in msxibm & msyibm 
  654.         extrn   f0:near, f1:near, f2:near, f3:near, f4:near, f5:near, f6:near
  655.         extrn   f7:near, f8:near, f9:near, f10:near, f11:near, f12:near
  656.         extrn   sf0:near, sf1:near, sf2:near, sf3:near, sf4:near, sf5:near
  657.         extrn   sf6:near, sf7:near, sf8:near, sf9:near, sf10:near, sf11:near
  658.         extrn   i_chr:near, d_chr:near, i_line:near, d_line:near
  659.         extrn   uparrw:near, dnarrw:near, rtarr:near, lfarr:near
  660.         extrn   pf1:near, pf2:near, pf3:near, pf4:near, kp0:near, kp1:near
  661.         extrn   kp2:near, kp3:near, kp4:near, kp5:near, kp6:near, kp7:near
  662.         extrn   kp8:near, kp9:near, kpminus:near, kpcoma:near, kpenter:near
  663.         extrn   kpdot:near, dnwpg:near, upwpg:near, scroll:near
  664. comment @
  665.         extrn   kpdot:near, decf6:near, decf7:near, decf8:near, decf9:near
  666.         extrn   decf10:near, decf11:near, decf12:near, decf13:near
  667.         extrn   decf14:near, dechelp:near, decdo:near, decf17:near
  668.         extrn   decf18:near, decf19:near, decf20:near, udkclear:near
  669.         extrn   decfind:near, decinsert:near, decremove:near
  670.         extrn   decselect:near, decprev:near, decnext:near
  671.         extrn   chrout:near, cstatus:near, cquit:near, cquery:near
  672.         extrn   vtans52:near, vtinit:near, dnwpg:near, upwpg:near
  673. end comment @
  674.         extrn   endwnd:near, homwnd:near, upone:near, dnone:near, trnprs:near
  675.         extrn   chang:near, klogon:near, klogof:near
  676.         extrn   trnmod:near, sendbr:near, sendbl:near, dmpscn:near, snull:near
  677.         extrn   cplatin:near, nrc2cp:near
  678.         extrn   cpdecsg:near, cdos:near, cquery:near, cstatus:near
  679.         extrn   chrout:near, cquit:near, udkclear:near, extmacro:near
  680.         assume  cs:code, ds:data, es:data
  681.  
  682. ; Begin system independent Keyboard Translator code
  683.  
  684. ; MSUINIT performs Kermit startup initialization for this file.
  685. ; Note, shkadr and stkadr are pointers tested by Set/Show Key calls. If they
  686. ; are not initialized here then the older Set/Show Key procedures are called.
  687. MSUINIT PROC    NEAR                    ; call from msx/msy init code
  688.         call    kbdinit                 ; optional: init translator tables
  689.         mov     shkadr,offset shkey     ; declare keyboard translator present
  690.         mov     stkadr,offset dfkey     ; via Show and Set Key proc addresses
  691.         ret
  692. MSUINIT ENDP
  693.  
  694. ; Call Keybd to read a keyboard char (just returns carry clear if none) and
  695. ; 1) send the replacement string (or original char if not translated)
  696. ;    out the serial port, or
  697. ; 2) execute a Kermit action verb.
  698. ; Returns carry set if Connect mode is to be exited, else carry clear.
  699. ; Modifies registers ax and bx. 
  700. KEYBD   PROC    NEAR                    ; active translator
  701.         mov     ttyact,1                ; doing single char output
  702.         cmp     stringcnt,0             ; any leftover string chars?
  703.         je      keybd0                  ; e = no
  704.         jmp     keyst2                  ; yes, finish string
  705. keybd0: call    getkey                  ; read keyboard
  706.         jnc     keybd1                  ; nc = data available
  707.         jmp     keybdx                  ; else just return carry clear
  708. keybd1: call    postkey                 ; call system dependent post processor
  709.         cmp     nkeys,0                 ; is number of keys defined = 0?
  710.         jz      keybd3                  ; z = none defined
  711.         push    di                      ; search keylist for this keycode
  712.         push    cx                      ; save some registers   
  713.         push    es
  714.         mov     di,offset keylist       ; list of defined keycode words
  715.         mov     ax,keycode              ; present keycode
  716.         mov     cx,nkeys                ; number of words to examine
  717.         push    ds
  718.         pop     es                      ; make es:di point to data segment
  719.         cld
  720.         repne   scasw                   ; find keycode in list
  721.         pop     es                      ; restore regs
  722.         pop     cx
  723.         je      keybd1b                 ; e = found, work with present di
  724.         pop     di                      ; restore original di
  725.         test    keycode,scan            ; is this a scan code?
  726.         jz      keybd3                  ; z = no, it's ascii, use al as char
  727.         call    beep                    ; say key is a dead one
  728.         clc
  729.         ret                             ; and exit with no action
  730.  
  731. keybd1b:sub     di,2                    ; correct for auto increment
  732.         sub     di,offset keylist       ; subtract start of list ==> listptr
  733.         mov     ax,dirlist[di]          ; ax = contents of director word
  734.         pop     di                      ; restore original di
  735.                                         ; dispatch on Director code
  736.         test    ax,verb                 ; verb only?
  737.         jnz     keyvb                   ; e = yes
  738.         test    ax,strng                ; multi-char string only?
  739.         jnz     keyst                   ; e = yes, else single char & no xlat.
  740.                                         ;
  741.                                         ; do single CHAR output (char in al)
  742. keybd3: cmp     al,trans.escchr         ; Kermit's escape char?
  743.         je      keybd3a                 ; e = yes, handle separately
  744.         call    xltkey                  ; do character set translation
  745.         call    chrout                  ; transmit the char
  746.         clc                             ; return success
  747.         ret
  748. keybd3a:stc                             ; set carry for jump to Quit
  749.         ret
  750.  
  751. keyvb:  and     ax,not(verb+strng)      ; VERB (ax=index, remove type bits)
  752.         mov     bx,offset kverbs        ; start of verb table
  753.         cmp     al,byte ptr [bx]        ; index > number of entries?
  754.         jae     keybdx                  ; ae = illegal, indices start at 0
  755.         inc     bx                      ; bx points to first entry
  756.         push    cx                      ; save reg
  757.         mov     cx,ax                   ; save the index in cx
  758.         inc     cx                      ; counter, indices start at 0
  759. keyvb1: mov     ax,[bx]            ; cnt value
  760.         add     ax,4                    ; skip text and value word
  761.         add     bx,ax                   ; look at next slot
  762.         loop    keyvb1                  ; walk to correct slot
  763.         sub     bx,2                    ; backup to value field
  764.         pop     cx                      ; restore reg
  765.         mov     bx,[bx]                 ; get value field of this slot
  766.         or    bx,bx            ; jump address defined?
  767.         jz      keybdx                  ; z = no, skip the action
  768.         jmp     bx                      ; perform the function
  769.  
  770. keyst:  and     ax,not(verb+strng)      ; STRING (ax=index, remove type bits)
  771.         shl     ax,1                    ; convert to word index
  772.         push    si                      ; save working reg
  773.         mov     si,ax                   ; word subscript in table
  774.         mov     si,sptable[si]          ; memory offset of selected string
  775.         xor     cx,cx                   ; init string length to null
  776.         or    si,si            ; is there a string pointer present?
  777.         jz      keyst1                  ; z = no, skip operation
  778.         cld                             ; scan forward
  779.         mov     cx,[si]            ; get string length
  780.         add     si,2
  781. keyst1: mov     stringcnt,cx
  782.         mov     stringptr,si
  783.         pop     si
  784.         jcxz    keybdx                  ; z = null length
  785.  
  786. keyst2: push    si
  787.         mov     si,stringptr            ; pointer to next string char
  788.         cld
  789.         lodsb                           ; get new string char into al
  790.         pop     si
  791.         dec     stringcnt               ; string chars remaining
  792.         inc     stringptr
  793.     call    keysv            ; scan for embedded verbs
  794.     jc    keyst4            ; c = not found, al has string char
  795.     jmp    bx            ; perform the verb (bx = address)
  796. keyst4:    cmp     stringcnt,0             ; end of the string?
  797.         jne     keyst5                  ; ne = no
  798.         mov     ttyact,0                ; pretend not single char output
  799. keyst5:    jmp     chrout                  ; send out the char in al
  800.  
  801. keybdx: clc                             ; return success (nothing to do)
  802.         ret
  803. KEYBD   ENDP
  804.  
  805. ; Scan for keyboard verbs embedded in outgoing string. If found update
  806. ; string pointer and count to just beyond the verb and return action routine
  807. ; address in bx with carry clear. If failure return carry set and no change.
  808.  
  809. keysv   proc    near
  810.         push    ax
  811.         push    si
  812.         push    di
  813.         cmp     al,'\'                  ; escape?
  814.         jne     keysv7                  ; ne = no
  815.         mov     cx,stringcnt            ; chars remaining
  816.         mov     si,stringptr            ; address of next char to read
  817.         mov     brace,0                 ; assume not using braces
  818.         cmp     byte ptr [si],braceop   ; starts with \{?
  819.         jne     keysv1                  ; ne = no
  820.         inc     si                      ; skip the opening brace
  821.         dec     cx
  822.         mov     brace,bracecl           ; expect closing brace
  823. keysv1: cmp     byte ptr [si],'K'       ; starts with \{K or \K?
  824.         je      keysv2                  ; e = yes
  825.         cmp     byte ptr [si],'k'       ; starts as \{k or \k?
  826.         jne     keysv7                  ; ne = no, then it's a string
  827. keysv2: inc     si                      ; yes, skip the K too
  828.         dec     cx
  829.         mov     di,offset tranbuf       ; copy verb name to this work buffer
  830.         xor     ax,ax
  831.         mov     [di],ax                 ; init the buffer to empty
  832. keysv3: cld
  833.         jcxz    keysv4                  ; z = no more string chars
  834.         lodsb                           ; scan til closing brace or w/s or end
  835.         dec     cx
  836.         cmp     al,brace                ; closing brace?
  837.         je      keysv4                  ; e = yes
  838.         cmp     al,spc                  ; white space or control char?
  839.         jbe     keysv3                  ; be = yes
  840.         mov     [di],ax                 ; copy to tranbuf and terminate
  841.         inc     di
  842.         jmp     short keysv3
  843. keysv4:    push    si            ; save input reading position
  844.     mov    si,offset tranbuf    ; where verb starts (needs si)
  845.     call    tstkeyw            ; find keyword, bx = action routine
  846.     pop    si
  847.     jnc    keysv4a            ; nc = found the verb
  848.     call    keysv8            ; invoke EXTMACRO worker for unknown
  849.     jc    keysv7            ; carry = no verb to operate upon
  850. keysv4a:cmp    brace,0            ; need to end on a brace?
  851.     je    keysv6            ; e = no
  852.     dec    si            ; break position
  853.     inc    cx
  854.     cld
  855. keysv5:    jcxz    keysv6            ; z = no more string characters
  856.     lodsb                ; read string char
  857.     dec    cx
  858.     cmp    al,brace        ; the brace?
  859.     jne    keysv5            ; ne = no, repeat until it is found
  860. keysv6:    mov    stringptr,si        ; where we finished+1
  861.     mov    stringcnt,cx        ; new count of remaining chars
  862.     pop    di
  863.     pop    si            ; original si, starting place
  864.     pop    ax            ; original ax
  865.     clc
  866.     ret
  867. keysv7:    pop    di            ; verb not found
  868.     pop    si
  869.     pop    ax
  870.     stc
  871.     ret
  872. ; Worker. Unknown verb name as string {\kverb} or {\k{verb}}. Use EXTMACRO
  873. ; procedure (in msyibm typically), point to verb name with vtmacname, length
  874. ; of it in byte vtmaclen, address of EXTMACRO to BX. Upper case the verb.
  875. ; Enter with tranbuf holding the verb, asciiz, without \K and braces.
  876. ; Returns BX set to EXTMACRO proc, vtmacname pointing to verb (uppercased)
  877. ; and vtmaclen holding the length of verb.
  878. keysv8:    mov    bx,offset extmacro    ; use this external macro pointer
  879.     mov    vtmacname,offset tranbuf; select extmacro procedure address
  880.     mov    dx,offset tranbuf    ; point to name for extmacro
  881.     push    cx
  882.     call    strlen            ; get its length
  883.     mov    vtmaclen,cx        ; length for extmacro
  884.     jcxz    keysv11            ; z = none
  885.     push    si            ; convert verb name to upper case
  886.     mov    si,dx            ; verb, without leading \K stuff
  887.     cld
  888. keysv9:    lodsb                ; read a name byte
  889.     cmp    al,'a'            ; before lower case?
  890.     jb    keysv10            ; e = yes
  891.     cmp    al,'z'            ; above lower case?
  892.     ja    keysv10            ; a = yes
  893.     and    al,not 20h        ; convert to upper case
  894.     mov    [si-1],al        ; put it back
  895. keysv10:loop    keysv9            ; do all bytes, asciiz
  896.     pop    si
  897.     pop    cx
  898.     clc                ; carry clear = ready to execute
  899.     ret
  900. keysv11:stc                ; carry set = no verb, do nothing
  901.     pop    cx
  902.     ret
  903. keysv   endp
  904.  
  905. ; SET KEY - define a key   (procedure dfkey)
  906. ; SET KEY <key ident><whitespace><new meaning>
  907. ; Call from Kermit level. Returns as ret if failure or as rskp if success.
  908. ;  
  909. DFKEY   PROC    NEAR                    ; define a key as a verb or a string
  910.         mov     keycode,0               ; clear keycode
  911.         mov     oldform,0               ; say no old form Set Key yet
  912.         or      byte ptr kbcodes,80h    ; say kbcodes not-initiated
  913.         mov     dx,offset tranbuf       ; our work space
  914.         mov     word ptr tranbuf,0      ; insert terminator
  915.         mov     bx,offset dfhelp1       ; first help message
  916.         mov     ah,cmword               ; parse a word
  917.         call    comnd                   ; get key code or original ascii char
  918.         mov     cl,taklev               ; reading from Take file
  919.         mov     msutake,cl              ; save here
  920.         or      ax,ax                   ; any text given?
  921.         jnz     dfkey12                 ; nz = yes, so don't consider prompts
  922.                                         ; interactive key request
  923.         cmp     taklev,0                ; in a Take file?
  924.         je      dfkey10                 ; e = no, prompt for keystroke
  925.         jmp     dfkey0                  ;  else say bad syntax
  926. dfkey10:mov     ah,prstr
  927.         mov     dx,offset dfaskky       ; ask for key to be pressed
  928.         int     dos
  929. dfkey11:call    getkey                  ; read key ident from keyboard
  930.         jc      dfkey11                 ; c = no response, wait for keystroke
  931.         mov     ah,prstr                ; display cr/lf
  932.         mov     dx,offset crlf
  933.         int     dos
  934.         call    shkey0                  ; show current definition (in SHKEY)
  935.         jmp     dfkey1e                 ; prompt for and process definition
  936.  
  937. dfkey12:                                ; Look for word SCAN and ignore it
  938.         mov     dx,word ptr tranbuf     ; get first two characters
  939.         or      dx,2020h                ; map upper to lower case
  940.         cmp     dx,'cs'                 ; first two letters of word "scan"?
  941.         je      dfkey                   ; e = yes, skip the word
  942.         cmp     dx,'lc'                 ; first two letters of word "clear"?
  943.         je      dfkey15                 ; e = yes, reinit keyboard [2.31]
  944.         cmp     dx,'fo'                 ; first two letters of "off"
  945.         je      dfkey13                 ; e = yes, use DOS keyboard calls
  946.         cmp     dx,'no'                 ; first two letters of "on"
  947.         je      dfkey14                 ; e = yes, use standard kbd calls
  948.     cmp    ax,1            ; number of characters received
  949.     jbe    dfkey12a        ; be = stay here
  950.     jmp    dfkey1            ; a = more than one, decode
  951. dfkey12a:mov    ah,byte ptr tranbuf    ; get the single char
  952.     mov    byte ptr keycode,ah    ; store as ascii keycode
  953.     jmp    dfkey1b            ; go get definition
  954. dfkey13:push    dx            ; save command letters
  955.     mov    ah,cmeol        ; get end of line confirmation
  956.     call    comnd
  957.     pop    dx
  958.     jnc    dfkey14            ; nc = success
  959.     ret
  960. dfkey14:mov    al,0ffh            ; set DOS keyboard read flag
  961.     cmp    dx,'fo'            ; first two letters of "off"
  962.     je    dfkey14a        ; e = yes, use DOS keyboard calls
  963.     xor    al,al            ; clear DOS keyboard read flag
  964.     cmp    dx,'no'            ; first two letters of "on"
  965.     je    dfkey14a        ; e = yes, use standard kbd calls
  966.     mov    al,dosflg        ; get current flag
  967. dfkey14a:mov    dosflg,al        ; store new keyboard flag
  968.     ret
  969.  
  970.  
  971. dfkey15:mov     ah,cmeol
  972.         call    comnd                   ; confirm request before proceeding
  973.         jnc     dfkeyc                  ; nc = success
  974.         ret                             ; failure
  975.  
  976. dfkey0: mov     dx,offset dfhelp1       ; say bad definition command
  977.         mov     ah,prstr
  978.         int     dos
  979.         stc                             ; failure
  980.         ret
  981.  
  982. dfkeyc:                                 ; CLEAR key defs, restore startup defs
  983.         mov     cx,maxkeys              ; size of keycode tables
  984.         push    es                      ; save register
  985.         push    ds
  986.         pop     es                      ; make es point to data segment
  987.         xor    ax,ax                   ; null, value to be stored
  988.         mov     di,offset dirlist       ; director table
  989.         cld
  990.         rep     stosw                   ; clear it
  991.         mov     cx,maxkeys
  992.         mov     di,offset keylist       ; keycode table
  993.         rep     stosw                   ; clear it
  994.         mov     cx,maxstng
  995.         mov     di,offset sptable       ; string pointer table
  996.         rep     stosw                   ; clear it
  997.         pop     es                      ; recover register
  998.         mov     strmax,offset stbuf     ; clear string buffer, free space ptr
  999.         mov     stbuf,0                 ; first element of buffer 
  1000.         mov     nkeys,0                 ; clear number of defined keys
  1001.         call    msuinit                 ; restore startup definitions
  1002.         clc                             ; success
  1003.         ret
  1004.                                         ; Multi-char key identification
  1005. dfkey1: mov     si,offset tranbuf       ; point to key ident text
  1006.         cmp     byte ptr [si],'0'       ; is first character numeric?
  1007.         jb      dfkey1a                 ; b = no
  1008.         cmp     byte ptr [si],'9'       ; in numbers?
  1009.         ja      dfkey1a                 ; a = no
  1010.         mov     keycode,scan            ; setup keycode for scan value
  1011.         mov     dx,si                   ; get length of string in cx
  1012.         call    strlen
  1013.         push    ds
  1014.         pop     es                      ; make es point to data segment
  1015.         push    si
  1016.         add     si,cx                   ; point at string terminator
  1017.         mov     di,si
  1018.         inc     di                      ; place to store string (1 byte later)
  1019.         inc     cx                      ; include null terminator
  1020.         std                             ; work backward
  1021.         rep     movsb                   ; move string one place later
  1022.         cld
  1023.         pop     si
  1024.         mov     byte ptr [si],'\'       ; make ascii digits into \nnn form
  1025.         mov     oldform,0ffh            ; set old form flag
  1026.         mov     dx,offset kwarnmsg      ; tell user this is old form
  1027.         mov     ah,prstr
  1028.         int     dos
  1029. dfkey1a:call    katoi                   ; convert ascii number to binary in ax
  1030.         jc      dfkey0                  ; c = no number converted
  1031.         or      keycode,ax              ; store in keycode
  1032.  
  1033. dfkey1b:                                ; Get Definition proper
  1034.         test    oldform,0ffh            ; old form Set Key active?
  1035.         jz      dfkey1f                 ; z = no
  1036.         mov     bx,offset tranbuf       ; get new definition on main cmd line
  1037.         mov     word ptr [bx],0         ; insert terminator
  1038.         mov     dx,offset dfhelp2       ; help for definition of key
  1039.         mov     ah,cmline               ; read rest of line into tranbuf
  1040.         call    comnd                   ; allow null definitions
  1041.         or      ax,ax                   ; char count zero?
  1042.         jz      dfkey1e                 ; z = zero, prompt for definition
  1043.         jmp     dfkey1g                 ; process definition
  1044.  
  1045. dfkey1e:mov     ah,prstr
  1046.         mov     dx,offset crlf
  1047.         int     dos
  1048.         mov     dx,offset dfaskdf       ; prompt for definition string
  1049.         call    prompt                  ; Kermit prompt routine
  1050.         mov     comand.cmcr,1           ; permit bare carriage returns
  1051.         mov     comand.cmwhite,1        ; allow leading whitespace
  1052. dfkey1f:mov     bx,offset tranbuf       ; get new definition
  1053.         mov     word ptr [bx],0         ; insert terminator
  1054.         mov     dx,offset dfhelp2       ; help for definition of key
  1055.         mov     ah,cmline               ; read rest of line into tranbuf
  1056.         call    comnd
  1057.         jc      dfkey1x                 ; exit now on ^C from user
  1058.         cmp     comand.cmcr,0           ; prompting for definition?
  1059.         je      dfkey1g                 ; e = no, trim leading whitespace
  1060.         mov     comand.cmcr,0           ; turn off allowance for bare c/r's
  1061.         jmp     dfkey2                  ; interactive, allow leading whitespace
  1062. dfkey1x:ret                             ; failure exit
  1063.  
  1064. dfkey1g:push    ax            ; save count
  1065.         mov     ah,cmeol                ; get a confirm
  1066.         call    comnd
  1067.         pop     cx            ; string length
  1068.         jc      dfkey1x                 ; none so declare parse error
  1069.         
  1070. dfkey2:                                 ; Examine translation
  1071.         mov     al,trans.escchr         ; current escape char (port dependent)
  1072.         cmp     al,byte ptr keycode     ; is this Kermit's escape char?
  1073.         jne     dfkey2a                 ; ne = no
  1074.         test    keycode,scan            ; see if scan code
  1075.         jnz     dfkey2a                 ; nz = scan, so not ascii esc char
  1076.         mov     dx,offset dfkoops       ; Oops! msg
  1077.         mov     ah,prstr                ; complain and don't redefine
  1078.         int     dos
  1079.         stc                             ; failure
  1080.         ret
  1081.  
  1082. dfkey2a:push    di                      ; get a director code for this key
  1083.         push    cx      
  1084.         mov     di,offset keylist       ; list of keycodes
  1085.         mov     cx,nkeys                ; number currently defined
  1086.         mov     ax,keycode              ; present keycode
  1087.         jcxz    dfkey2b                 ; cx = 0 means none defined yet
  1088.         cld
  1089.         push    ds
  1090.         pop     es
  1091.         repne   scasw                   ; is current keycode in the list?
  1092.         jne     dfkey2b                 ; ne = not in list
  1093.         sub     di,2                    ; correct for auto increment
  1094.         sub     di,offset keylist
  1095.         mov     listptr,di              ; list pointer for existing definition
  1096.         pop     cx
  1097.         pop     di
  1098.         jmp     dfkey3                  ; go process definition
  1099.  
  1100. dfkey2b:pop     cx                      ; key not currently defined so
  1101.         pop     di                      ;  make a new director entry for it
  1102.         mov     bx,nkeys                ; number of keys previously defined
  1103.         cmp     bx,maxkeys              ; enough space?
  1104.         jae     dfkey2c                 ; ae = no, complain
  1105.         shl     bx,1                    ; count words
  1106.         mov     listptr,bx              ; index into word list
  1107.         mov     ax,keycode              ; get key's code
  1108.         mov     keylist[bx],ax          ; store it in list of keycodes
  1109.         mov     dirlist[bx],0           ; clear the new director entry
  1110.         inc     nkeys                   ; new number of keys
  1111.         jmp     dfkey3                  ; go process definition
  1112.  
  1113. dfkey2c:mov     dx,offset keyfull       ; say key space is full already
  1114.         mov     ah,prstr
  1115.         int     dos
  1116.         stc                             ; failure
  1117.         ret
  1118.  
  1119. ; listptr has element number in keylist or dirlist; keycode has key's code.
  1120.  
  1121. ; Parse new definition. First look for Kermit verbs as a line beginning
  1122. ; as \K or \{K. Otherwise, consider the line to be a string.
  1123. ; In any case, update the Director table for the new definition.
  1124.  
  1125. dfkey3: mov     brace,0                 ; assume not using braces
  1126.         mov     si,offset tranbuf       ; start of definition text
  1127.         cmp     byte ptr [si],'\'       ; starts with escape char?
  1128.         jne     dfkey5                  ; ne = no, so we have a string
  1129.         inc     si                      ; skip the backslash
  1130.         cmp     byte ptr [si],braceop   ; starts with \{?
  1131.         jne     dfkey3a                 ; ne = no
  1132.         inc     si                      ; skip the opening brace
  1133.         mov     brace,bracecl           ; expect closing brace
  1134. dfkey3a:cmp     byte ptr [si],'K'       ; starts with \{K or \K?
  1135.         je      dfkey3b                 ; e = yes
  1136.         cmp     byte ptr [si],'k'       ; starts as \{k or \k?
  1137.         jne     dfkey5                  ; ne = no, then it's a string
  1138. dfkey3b:inc     si                      ; yes, skip the K too
  1139.                                         ; Kermit action VERBS
  1140.         push    si                      ; save verb name start address
  1141. dfkey4: cld
  1142.         lodsb                           ; scan til closing brace or w/s or end
  1143.         or    al,al            ; premature end?
  1144.         jz      dfkey4b                 ; z = yes, accept without brace
  1145.         cmp     al,brace                ; closing brace?
  1146.         je      dfkey4b                 ; e = yes
  1147.         cmp     al,spc                  ; white space or control char?
  1148.         ja      short dfkey4            ; a = no, so not at end yet
  1149. dfkey4b:mov     byte ptr[si-1],0        ; insert null terminator
  1150.         pop     si                      ; recover start address
  1151.         call    tstkeyw                 ; find keyword, kw # returned in kbtemp
  1152.         jc      dfkey4d                 ; c = no keyword found, complain
  1153.         call    remstr                  ; clear old string, if string
  1154.         mov     ax,kbtemp               ; save keyword number
  1155.         and     ax,not(verb+strng)      ; clear verb / string field
  1156.         or      ax,verb                 ; set verb ident
  1157.         mov     si,listptr
  1158.         mov     dirlist[si],ax          ; store info in Director table
  1159.         jmp     dfkey7                  ; show results and return success
  1160.  
  1161. dfkey4d:mov     dx,offset verbbad       ; say no such verb
  1162.         mov     ah,prstr
  1163.         int     dos
  1164.         stc                             ; failure
  1165.         ret
  1166.  
  1167. ; Here we are left with the definition string; si points to its start, and
  1168. ; kbtemp holds its length (number of bytes). Null termination. If the string
  1169. ; begins with an opening brace it terminates on a matching closing brace
  1170. ; or the end of line, whichever occurs first. Trailing whitespace removed
  1171. ; before examining braces.
  1172. ; Null length strings mean define key as Self.
  1173.                                         ; STRING definitions
  1174. dfkey5: call    remstr                  ; first, clear old string, if any
  1175.         mov     si,offset tranbuf       ; si=source, di=dest, convert in-place
  1176.         mov     di,si
  1177.         call    cnvlin                  ; convert numbers, cx gets line length
  1178.         mov     si,offset tranbuf       ; provide address of new string
  1179.         cmp     cx,1                    ; just zero or one byte to do?
  1180.         jbe     dfkey6                  ; e = yes, do as a char
  1181.         call    insertst                ; insert new string, returns reg cx.
  1182.         jc      dfkey5h                 ; c = could not do insert
  1183.         mov     si,listptr              ; cx has type and string number
  1184.         mov     dirlist[si],cx          ; update Director table from insertst
  1185.         jmp     dfkey7                  ; show results and return success
  1186.  
  1187. dfkey5h:mov     dx,offset strbad        ; display complaint
  1188.         mov     ah,prstr
  1189.         int     dos
  1190.         stc                             ; failure
  1191.         ret
  1192.  
  1193.                 ; define SINGLE CHAR replacement or CLEAR a key definition.
  1194.                 ; cx has char count 1 (normal) or 0 (to undefine the key).
  1195. dfkey6: jcxz    dfkey6c                 ; z = cx= 0, clear definition
  1196.         mov     al,byte ptr [si]        ; get first byte from definition
  1197.         xor     ah,ah                   ; set the type bits to Char
  1198.         mov     si,listptr
  1199.         mov     dirlist[si],ax          ; store type and key's new code
  1200.         jmp     dfkey7                  ; return success
  1201.  
  1202. dfkey6c:push    si                      ; clear a definition,
  1203.         push    di                      ; listptr points to current def
  1204.         mov     si,listptr              ; starting address to clear
  1205.         add     si,offset dirlist
  1206.         mov     di,si                   ; destination
  1207.         add     si,2                    ; source is next word
  1208.         mov     cx,nkeys                ; current number of keys defined
  1209.         add     cx,cx                   ; double for listptr being words
  1210.         sub     cx,listptr              ; cx = number of words to move
  1211.         shr     cx,1                    ; convert to actual number of moves
  1212.         jcxz    dfkey6d                 ; z = none, just remove last word
  1213.         push    es
  1214.         push    ds
  1215.         pop     es                      ; make es:di point to data segment
  1216.         cld
  1217.         push    cx                      ; save cx
  1218.         rep     movsw                   ; move down higher list items
  1219.         pop     cx
  1220.         mov     si,listptr              ; do keylist too, same way
  1221.         add     si,offset keylist
  1222.         mov     di,si
  1223.         add     si,2
  1224.         rep     movsw
  1225.         pop     es
  1226. dfkey6d:mov     si,nkeys                ; clear old highest list element
  1227.         shl     si,1                    ; address words
  1228.         mov     dirlist[si],0           ; null the element
  1229.         mov     keylist[si],0           ; null the element
  1230.         dec     nkeys                   ; say one less key defined now
  1231.         pop     di                      ; restore saved registers
  1232.         pop     si
  1233.  
  1234. dfkey7: mov     ah,msutake              ; Finish up. In a Take file?
  1235.         or      ah,taklev               ; or even directly
  1236.         or    ah,ah
  1237.         jz    dfkey7a                 ; z = no
  1238.         cmp     flags.takflg,0          ; echo Take commands?
  1239.         je      dfkey7b                 ; e = no
  1240. dfkey7a:mov     ah,prstr                ; display cr/lf
  1241.         mov     dx,offset crlf
  1242.         int     dos
  1243.         call    shkey0                  ; show new definition (in SHKEY)
  1244.         call    shkfre                  ; show free string space
  1245. dfkey7b:clc                             ; return success
  1246.         ret
  1247. DFKEY   ENDP
  1248.  
  1249. ; SHOW KEY <cr> command. Call from Kermit level. Vectored here by SHOW
  1250. ; command. Replaces obsolete procedure in msx---.
  1251. ; Prompts for a key and shows that key's (or all if ? entered) keycode,
  1252. ; definition, and the key definition free space remaining.
  1253.  
  1254. SHKEY   PROC    NEAR                    ; Show key's definition command
  1255.         mov     ah,cmeol                ; get a confirm
  1256.         call    comnd                   ; ignore any additional text
  1257.         push    bx
  1258.         mov     dx,offset shkmsg1       ; ask for original key
  1259.         mov     ah,prstr
  1260.         int     dos
  1261.         or      byte ptr kbcodes,80h    ; say kbcodes not-initiated
  1262. shky0:  call    getkey                  ; read keyboard, output to keycode
  1263.         jc      shky0                   ; wait for a key (c = nothing there)
  1264.         cmp     byte ptr keycode,'?'    ; query for all keys?
  1265.         jne     shky0a                  ; ne = no, not a query
  1266.         test    keycode,scan            ; is this a scan code, vs ascii query?
  1267.         jz      shky0c                  ; z = no Scan, so it is a query
  1268.  
  1269. shky0a: mov     ah,prstr                ; show single key. Setup display
  1270.         mov     dx,offset crlf
  1271.         int     dos
  1272.         call    shkey0                  ; show just one key
  1273. shky0b: call    shkfre                  ; show free string space
  1274.         jmp     shkeyx                  ; exit
  1275.  
  1276. shky0c: mov     cx,nkeys                ; Show all keys. nkeys = number defined
  1277.         jcxz    shky0b                  ; z = none to show
  1278.         mov     si,offset keylist       ; list of definitions
  1279.         push    si                      ; save pointer
  1280. shky1:  pop     si                      ; recover pointer
  1281.         cld
  1282.         lodsw                           ; get a keycode
  1283.         push    si                      ; save pointer
  1284.         push    cx                      ; save counter
  1285.         mov     keycode,ax              ; save new keycode
  1286.         mov     ah,prstr
  1287.         mov     dx,offset crlf
  1288.         int     dos
  1289.         call    shkey0                  ; show this keycode
  1290.  
  1291.         pop     cx                      ; pause between screens, recover cntr
  1292.         push    cx                      ; save it again
  1293.         dec     cx                      ; number yet to be shown
  1294.         jcxz    shky1b                  ; z = have now shown all of them
  1295.         mov     ax,nkeys                ; number of defined keys
  1296.         sub     ax,cx                   ; minus number yet to be displayed
  1297.         xor     dx,dx                   ; clear extended numerator
  1298.         div     twelve                  ; two lines per definition display
  1299.         or      dx,dx                   ; remainder zero (12 defs shown)?
  1300.         jnz     shky1b                  ; nz = no, not yet so keep going
  1301.         mov     ah,prstr
  1302.         mov     dx,offset shkmsg3       ; "push any key to continue" msg
  1303.         int     dos
  1304. shky1a:    mov    ah,0bh            ; check console, check ^C
  1305.     int    dos
  1306.     cmp    flags.cxzflg,'C'    ; a ^C?
  1307.     je    shky1b            ; e = yes, quit
  1308.     or    al,al
  1309.     jz    shky1a            ; z = nothing
  1310.     call    getkey            ; get any key
  1311.     jc    shky1a            ; c = nothing at keyboard yet, wait
  1312. shky1b:    pop    cx            ; resume loop
  1313.     cmp    flags.cxzflg,'C'    ; a ^C?
  1314.     je    shky1c            ; e = yes, quit
  1315.     loop    shky1
  1316. shky1c:    pop    si            ; clean stack
  1317.     call    shkfre            ; show free string space
  1318.     jmp    shkeyx            ; exit
  1319.  
  1320.                 ; show key worker routine, called from above
  1321.                                         ; SHKEY0 called by DFKEY just above
  1322. SHKEY0: test    keycode,scan            ; scan code?
  1323.         jz      shkey1                  ; z = no, regular ascii
  1324.  
  1325.                                         ; SCAN codes
  1326.         mov     dx,offset scanmsg       ; say Scan Code:
  1327.         mov     ah,prstr
  1328.         int     dos
  1329.         mov     ah,conout
  1330.         mov     dl,'\'                  ; add backslash before number
  1331.         int     dos
  1332.         mov     ax,keycode              ; get key's code again
  1333.         call    decout                  ; display 16 bit decimal keycode
  1334.         jmp     shkey2                  ; go get definition
  1335.  
  1336. shkey1: mov     dx,offset ascmsg        ; say ASCII CHAR
  1337.         mov     ah,prstr
  1338.         int     dos
  1339.         mov     dl,byte ptr keycode     ; get ascii code (al part of input)
  1340.         mov     ah,conout
  1341.         cmp     dl,spc                  ; control code?
  1342.         jae     shkey1a                 ; ae = no
  1343.         push    dx                      ; save char
  1344.         mov     dl,5eh                  ; show caret first
  1345.         int     dos
  1346.         pop     dx
  1347.         add     dl,'A'-1                ; ascii bias
  1348. shkey1a:cmp     dl,del                  ; DEL?
  1349.         jne     shkey1b                 ; ne = no
  1350.         mov     dl,'D'                  ; spell out DEL
  1351.         int     dos
  1352.         mov     dl,'E'
  1353.         int     dos
  1354.         mov     dl,'L'
  1355. shkey1b:int     dos
  1356.         mov     dl,spc                  ; add a couple of spaces
  1357.         int     dos
  1358.         int     dos
  1359.         mov     dl,'\'                  ; add backslash before number
  1360.         int     dos
  1361.         mov     ax,keycode              ; show 16 bit keycode in decimal
  1362.         call    decout                  ; and go get definiton
  1363.  
  1364.                                         ; Display defintion
  1365. shkey2: mov     dx,offset shkmsg2       ; intermediate part of reply
  1366.         mov     ah,prstr                ; " is defined as "
  1367.         int     dos
  1368.         push    di                      ; get a director code for this key
  1369.         push    cx      
  1370.         mov     di,offset keylist       ; list of keycodes
  1371.         mov     cx,nkeys                ; number currently defined
  1372.         jcxz    shkey2a                 ; z = none
  1373.         mov     ax,keycode              ; present keycode
  1374.         push    ds
  1375.         pop     es                      ; use data segment for es:di
  1376.         cld
  1377.         repne   scasw                   ; is current keycode in the list?
  1378.         jne     shkey2a                 ; ne = not in list
  1379.         sub     di,2                    ; correct for auto increment
  1380.         sub     di,offset keylist
  1381.         mov     listptr,di              ; list pointer for existing definition
  1382.         pop     cx
  1383.         pop     di
  1384.         jmp     shkey3                  ; go process definition
  1385.  
  1386. shkey2a:pop     cx
  1387.         pop     di
  1388.         mov     dx,offset noxmsg        ; say Self (no translation)
  1389.         mov     ah,prstr
  1390.         int     dos
  1391.         ret                             ; return to main show key loop
  1392.  
  1393. shkey3:                                 ; translations, get kind of.
  1394.         mov     si,listptr
  1395.         test    dirlist[si],verb        ; defined as verb?
  1396.         jnz     shkey6                  ; nz = yes, go do that one
  1397.         test    dirlist[si],strng       ; defined as string?
  1398.         jz      shkey3a                 ; z = no
  1399.         jmp     shkey8                  ; yes, do string display
  1400. shkey3a:
  1401.         mov     dx,offset ascmsg        ; CHAR. say 'Ascii char:'
  1402.         mov     ah,prstr
  1403.         int     dos
  1404.         mov     ax,dirlist [si]         ; get type and char
  1405.         mov     dl,al                   ; put char here for display
  1406.         push    ax                      ; save here too
  1407.         mov     ah,conout
  1408.         cmp     dl,spc                  ; control code?
  1409.         jae     shkey4                  ; ae = no
  1410.         push    dx
  1411.         mov     dl,5eh                  ; show caret
  1412.         int     dos
  1413.         pop     dx
  1414.         add     dl,'A'-1                ; add ascii bias
  1415. shkey4: cmp     dl,del                  ; DEL?
  1416.         jne     shkey4a                 ; ne = no
  1417.         mov     dl,'D'                  ; spell out DEL
  1418.         int     dos
  1419.         mov     dl,'E'
  1420.         int     dos
  1421.         mov     dl,'L'
  1422. shkey4a:int     dos
  1423.         mov     dl,spc                  ; add a couple of spaces
  1424.         mov     ah,conout
  1425.         int     dos
  1426.         int     dos
  1427.         mov     dl,'\'                  ; add backslash before number
  1428.         int     dos
  1429.         pop     ax                      ; recover char
  1430.         xor     ah,ah                   ; clear high byte
  1431.         call    decout                  ; show decimal value
  1432.         ret                             ; return to main show key loop
  1433.  
  1434. shkey6: mov     ah,prstr                ; VERB
  1435.         mov     dx,offset verbmsg       ; say 'verb'
  1436.         int     dos
  1437.         mov     si,listptr              ; get verb index from director
  1438.         mov     dx,dirlist[si]
  1439.         and     dx,not(verb+strng)      ; remove type bits, leaves verb number
  1440.         mov     bx,offset kverbs        ; table of verbs & actions
  1441.         mov     al,byte ptr [bx]        ; number of keywords
  1442.         xor     ah,ah
  1443.         dec     ax
  1444.         mov     kwcnt,ax                ; save number of last one here
  1445.         cmp     dx,ax                   ; asking for more than we have?
  1446.         ja      shkeyx                  ; a = yes, exit bad
  1447.         inc     bx                      ; point to first slot
  1448.         xor    cx,cx            ; current slot number
  1449. shkey6b:cmp     cx,dx                   ; this slot?
  1450.         je      shkey6c                 ; e = yes, print the text part
  1451.         ja      shkeyx                  ; a = beyond, exit bad
  1452.         mov     ax,[bx]                ; get cnt (keyword length)
  1453.         add     ax,4                    ; skip count and two byte value
  1454.         add     bx,ax                   ; bx = start of next keyword slot
  1455.         inc     cx                      ; current keyword number
  1456.         jmp     short shkey6b           ; try another
  1457. shkey6c:push    cx
  1458.     mov    cx,[bx]            ; length of definition
  1459.     add    bx,2            ; look at text field
  1460.     mov    di,bx            ; offset for printing
  1461.     call    prtscr            ; print counted string
  1462.     mov    ah,conout
  1463.     mov    dl,spc            ; add a couple of spaces
  1464.     int    dos
  1465.     int    dos
  1466.     mov    dl,'\'            ; show verb name as \Kverb
  1467.     int    dos
  1468.     mov    dl,'K'
  1469.     int    dos
  1470.     call    prtscr            ; print counted string, again
  1471.     pop    cx
  1472.     ret                ; return to main show key loop
  1473.  
  1474. shkey8: mov     ah,prstr                ; STRING
  1475.         mov     dx,offset strngmsg      ; say String:
  1476.         int     dos
  1477.         mov     si,listptr              ; get index from director
  1478.         mov     bx,dirlist[si]
  1479.         and     bx,not(verb+strng)      ; remove type bits
  1480.         shl     bx,1                    ; index words
  1481.         mov     si,sptable[bx]          ; table of string offsets
  1482.         mov     cx,word ptr [si]        ; get string length
  1483.         add     si,2            ; point to string text
  1484.         mov     ah,conout
  1485. shkey8a:cld
  1486.         lodsb                           ; get a byte
  1487.         cmp     al,spc                  ; control code?
  1488.         jae     shkey8b                 ; ae = no
  1489.         push    ax
  1490.         mov     dl,5eh                  ; show caret first
  1491.         int     dos
  1492.         pop     ax
  1493.         add     al,40h                  ; convert to printable for display
  1494. shkey8b:mov     dl,al
  1495.         int     dos                     ; display it
  1496.         loop    shkey8a                 ; do another
  1497.         ret                             ; return to main show key loop
  1498.         
  1499. shkeyx: pop     bx                      ; restore reg
  1500.         clc                             ; return success
  1501.         ret
  1502. SHKEY   ENDP
  1503.  
  1504. ;;;     keyboard translator local support procedures, system independent
  1505.  
  1506. ; Tstkeyw checks text word pointed to by si against table of keywords (pointed
  1507. ; to by kverbs, made by mkeyw macro); returns in bx either action value or 0.
  1508. ; Returns in kbtemp the number of the keyword and carry clear, or if failure
  1509. ; returns kbtemp zero and carry set.
  1510. ; Keyword structure is:         dw      cnt     (length of string 'word')
  1511. ;                               db      'word'  (keyword string)
  1512. ;                               dw      value   (value returned in bx)
  1513. ; Make these with macro mkeyw such as   mkeyw 'test',15   with the list of
  1514. ; such keywords headed by a byte giving the number of keywords in the list.
  1515. tstkeyw proc    near
  1516.         push    ax
  1517.         push    cx
  1518.         push    si
  1519.         mov     verblen,0               ; verblen will hold verb length
  1520.         push    si                      ; save user's verb pointer
  1521. tstkw1: cld
  1522.         lodsb                           ; get a verb character
  1523.         cmp     al,spc                  ; verbs are all non-spaces and above
  1524.         jbe     tstkw2                  ; be = done (space or control char)
  1525.         inc     verblen                 ; count verb length
  1526.         jmp     short tstkw1            ; printable char, look for more
  1527. tstkw2: pop     si                      ; pointer to verb
  1528.         mov     bx,offset kverbs        ; table of Kermit verb keywords
  1529.         mov     al,byte ptr [bx]        ; number of keywords
  1530.         xor     ah,ah
  1531.         mov     kwcnt,ax                ; save number of keywords here
  1532.         inc     bx                      ; point bx to first slot
  1533.         mov     kbtemp,0                ; remember which keyword
  1534.  
  1535. tstkw3:                                 ; match table keyword and text word
  1536.         mov     cx,verblen              ; length of user's verb
  1537.         cmp     [bx],cx                ; compare length vs table keyword
  1538.         jne     tstkw4                  ; ne = not equal lengths, try another
  1539.         push    si                      ; lengths match, how about spelling?
  1540.         push    bx
  1541.         add     bx,2            ; point at start of keyword
  1542. tstkw3a:mov     ah,byte ptr [bx]        ; keyword char
  1543.         mov     al,byte ptr [si]        ; text char
  1544.         cmp     ah,'A'
  1545.         jb      tstkw3b                 ; b = control chars
  1546.         cmp     ah,'Z'
  1547.         ja      tstkw3b                 ; a = not upper case alpha
  1548.         add     ah,'a'-'A'              ; convert upper case to lower case
  1549. tstkw3b:cmp     al,'A'
  1550.         jb      tstkw3c
  1551.         cmp     al,'Z'
  1552.         ja      tstkw3c
  1553.         add     al,'a'-'A'              ; convert upper case to lower case
  1554. tstkw3c:cmp     al,ah                   ; test characters
  1555.         jne     tstkw3d                 ; ne = no match
  1556.         inc     si                      ; move to next char
  1557.         inc     bx
  1558.         loop    tstkw3a                 ; loop through entire length
  1559. tstkw3d:pop     bx
  1560.         pop     si
  1561.         jcxz    tstkw5                  ; z: cx = 0, exit with match;
  1562.                                         ;  else select next keyword
  1563. tstkw4: inc     kbtemp                  ; number of keyword to test next
  1564.         mov     cx,kbtemp
  1565.         cmp     cx,kwcnt                ; all done? Recall kbtemp starts at 0
  1566.         jae     tstkwx                  ;ae = exhausted search, unsuccessfully
  1567.         mov     ax,[bx]            ; cnt (keyword length from macro)
  1568.         add     ax,4                    ; skip over count and two byte value
  1569.         add     bx,ax                   ; bx = start of next keyword slot
  1570.         jmp     tstkw3                  ; do another comparison
  1571.  
  1572. tstkw5:                                 ; get action pointer
  1573.         mov     ax,[bx]                ; cnt (keyword length from macro)
  1574.         add     ax,2                    ; skip over count
  1575.         add     bx,ax                   ; now bx points to dispatch value
  1576.         mov     bx,[bx]                 ; bx holds dispatch value
  1577.         clc                             ; carry clear for success
  1578.         jmp     short tstkwxx           ; exit
  1579.         ret
  1580. tstkwx: xor     bx,bx                   ; exit when no match
  1581.         mov     kbtemp,bx               ; make verb number be zero too
  1582.         stc                             ; carry set for failure
  1583. tstkwxx:pop     si
  1584.         pop     cx
  1585.         pop     ax
  1586.         ret
  1587. tstkeyw endp
  1588.  
  1589. ; Insert asciiz string pointed to by si into string buffer stbuf.
  1590. ; Reg cx has string length upon entry.
  1591. ; Success: returns offset of first free byte (strmax) in string buffer stbuf,
  1592. ; cx = type and Index of new string, and carry clear.
  1593. ; Failure = carry set.
  1594. insertst proc   near
  1595.         push    bx
  1596.         push    dx
  1597.         push    si
  1598.         push    di
  1599.         push    kbtemp          ; save this variable too
  1600.         mov     dx,cx           ; save length of incoming string in dx
  1601.         mov     bx,offset sptable ; table of string offsets
  1602.         mov     kbtemp,0        ; slot number
  1603.         mov     cx,maxstng      ; number of entries, find an empty slot
  1604. insert1:cmp     word ptr[bx],0  ; slot empty?
  1605.         je      insert2         ; e = yes
  1606.         inc     kbtemp          ; remember slot number
  1607.         add     bx,2            ; look at next slot
  1608.         loop    insert1         ; keep looking
  1609.         jmp     short insert4   ; get here if no empty slots
  1610. insert2:                        ; see if stbuf has sufficient space
  1611.         mov     cx,dx           ; length of new string to cx
  1612.         mov     di,strmax       ; offset of first free byte in stbuf
  1613.         add     di,cx           ; di = address where this string would end
  1614.         cmp     di,offset stbuf+stbuflen ; beyond end of buffer?
  1615.         jae     insert4         ; ae = yes, not enough room
  1616.         mov     di,strmax       ; point to first free slot in stbuf
  1617.         mov     [bx],di         ; fill slot with address offset of buffer
  1618.         push    es
  1619.         push    ds
  1620.         pop     es              ; point es:di to data segment
  1621.         cld
  1622.         mov     [di],cx     ; length of text for new string
  1623.         add     di,2        ; move to next storage slot
  1624.         rep     movsb           ; copy string text
  1625.         pop     es
  1626.         mov     strmax,di       ; offset of next free byte
  1627.         mov     cx,kbtemp       ; return new slot number with Director Index
  1628.         and     cx,not(strng+verb) ; clear type bits
  1629.         or      cx,strng        ; say type is multi-char string
  1630.         clc                     ; say success
  1631.         jmp     short insertx   ; exit
  1632. insert4:stc                     ; say no-can-do
  1633. insertx:pop     kbtemp
  1634.         pop     di
  1635.         pop     si
  1636.         pop     dx
  1637.         pop     bx
  1638.         ret
  1639. insertst endp
  1640.  
  1641. ; Remove (delete) string. Enter with listptr preset for director entry.
  1642. ; Acts only on existing multi-char strings; recovers freed space.
  1643. ; All registers preserved.
  1644. remstr  proc    near            
  1645.         push    si
  1646.         mov     si,listptr              ; list pointer
  1647.         test    dirlist[si],strng       ; multi-char string?
  1648.         pop     si
  1649.         jnz     remst1                  ; nz = a multi-char string
  1650.         ret                             ; else do nothing
  1651. remst1: push    ax
  1652.         push    bx
  1653.         push    cx
  1654.         push    dx
  1655.         push    si
  1656.         mov     si,listptr
  1657.         mov     ax,dirlist[si]          ; Director table entry
  1658.         and     ax,not(strng+verb) ; clear type bits, leave string's pointer
  1659.         mov     dirlist[si],0           ; clear Director table entry
  1660.         shl     ax,1                    ; index words not bytes
  1661.         mov     si,offset sptable       ; list of string offsets in stbuf
  1662.         add     si,ax                   ; plus index = current slot
  1663.         mov     bx,[si]                 ; get offset of string to be deleted
  1664.         mov     dx,bx                   ; save in dx for later
  1665.         mov     cx,[bx]                ; get length of subject string
  1666.         add     cx,2            ; length word too, cx has whole length
  1667.         sub     strmax,cx       ; count space to be freed (adj end-of-buf ptr)
  1668.         mov     word ptr [si],0 ; clear sptable of subject string address
  1669.         push    cx                      ; save length of purged string
  1670.         push    di                      ; save di
  1671.         push    si
  1672.         push    es                      ; save es
  1673.         push    ds
  1674.         pop     es              ; setup es:di to be ds:offset of string
  1675.         mov     di,dx           ; destination = start address of purged string
  1676.         mov     si,dx           ; source = start address of purged string
  1677.         add     si,cx           ;  plus string length of purged string.
  1678.         mov     cx,offset stbuf+stbuflen ; 1 + address of buffer end
  1679.         sub     cx,si                   ; 1 + number of bytes to move
  1680.         dec     cx                      ; number of bytes to move
  1681.         jcxz    remst2                  ; z = none
  1682.         cld                             ; direction is forward
  1683.         rep     movsb                   ; move down preserved strings
  1684. remst2: pop     es                      ; restore regs
  1685.         pop     di
  1686.         pop     si
  1687.         pop     ax              ; recover length of purged string (was in cx)
  1688.         mov     bx,offset sptable       ; string pointer table
  1689.         mov     cx,maxstng              ; max mumber of entries
  1690. remst4: cmp     [bx],dx         ; does this entry occur before purged string?
  1691.         jbe     remst5          ; be = before or equal, so leave it alone
  1692.         sub     [bx],ax         ; recompute address (remove old string space)
  1693. remst5: add     bx,2                    ; look at next list entry
  1694.         loop    remst4                  ; do all entries in sptable
  1695.         pop     si
  1696.         pop     dx
  1697.         pop     cx
  1698.         pop     bx
  1699.         pop     ax
  1700.         ret
  1701. remstr  endp
  1702.  
  1703. shkfre  proc    near                    ; show free key & string defs & space
  1704.         push    ax                      ; preserves all registers.
  1705.         push    bx
  1706.         push    cx
  1707.         push    dx
  1708.         push    kbtemp
  1709.         mov     dx,offset fremsg
  1710.         mov     ah,prstr
  1711.         int     dos
  1712.         mov     ax,maxkeys              ; max number of key defs
  1713.         sub     ax,nkeys                ; number currently used
  1714.         call    decout                  ; show the value
  1715.         mov     ah,prstr
  1716.         mov     dx,offset kyfrdef       ; give key defs msg
  1717.         int     dos
  1718.         mov     bx,offset sptable       ; table of string pointers
  1719.         mov     cx,maxstng              ; number of pointers
  1720.         mov     kbtemp,0                ; number free
  1721. shkfr1: cmp     word ptr [bx],0         ; slot empty?
  1722.         jne     shkfr2                  ; ne = no
  1723.         inc     kbtemp                  ; count free defs
  1724. shkfr2: add     bx,2                    ; look at next slot
  1725.         loop    shkfr1                  ; do all of them
  1726.         mov     ax,kbtemp               ; number of free defs
  1727.         call    decout                  ; display
  1728.         mov     dx,offset stfrdef       ; say free string defs
  1729.         mov     ah,prstr
  1730.         int     dos
  1731.         mov     ax,offset stbuf+stbuflen+1 ; 1 + last byte in stbuf
  1732.         sub     ax,strmax               ; offset of last free byte in stbuf
  1733.         call    decout
  1734.         mov     dx,offset stfrspc       ; give free space part of msg
  1735.         mov     ah,prstr
  1736.         int     dos
  1737.         pop     kbtemp
  1738.         pop     dx
  1739.         pop     cx
  1740.         pop     bx
  1741.         pop     ax
  1742.         ret
  1743. shkfre  endp
  1744.  
  1745. ; Initialize the keyboard tables at Kermit startup time. Optional procedure.
  1746. ; Requires kbdinlst to be configured with mkeyw macro in the form
  1747. ;       mkeyw   'definition',keytype*256+keycode
  1748. ; keytype is 0 for scan codes and non-zero for ascii.
  1749. ; Returns normally.
  1750. kbdinit proc    near                    ; read keyword kbdinlst and setup
  1751.         or      byte ptr kbcodes,80h    ; say kbcodes not-initiated
  1752.         push    ds                      ;  initial keyboard assignments.
  1753.         pop     es                      ; set es:di to data segment
  1754.         inc     taklev                  ; pretend that we are in Take file
  1755. kbdini0:mov     si,offset kbdinlst      ; start of list of definitions
  1756. kbdini1:mov     cx,[si]            ; cnt field (keyword length of macro)
  1757.         jcxz    kbdinix                 ; z = null cnt field = end of list
  1758.         add     si,2            ; look at text field
  1759.         mov     di,offset tranbuf       ; where defkey expects text
  1760.         cld
  1761.         rep     movsb                   ; copy cx chars to tranbuf
  1762.         mov     byte ptr [di],0         ; insert null terminator
  1763.         mov     ax,word ptr [si]        ; get value field
  1764.         mov     keycode,ax              ; set key ident value
  1765.     push    si
  1766.         call    dfkey2                  ; put dfkey to work
  1767.         pop     si
  1768.         add     si,2                    ; point to next entry
  1769.         jmp     kbdini1                 ; keep working
  1770. kbdinix:dec     taklev                  ; reset Take file level
  1771.         call    udkclear                ; clear User Definable Keys
  1772.         ret
  1773. kbdinit endp
  1774. ;;;     End of System Independent Procedures
  1775.  
  1776. ;;;     Begin System Dependent Procedures
  1777.  
  1778. ; Read keyboard. System dependent.
  1779. ; Return carry set if nothing at keyboard.
  1780. ; If char present return carry clear with key's code in Keycode.
  1781. ; If key is ascii put that in the low byte of Keycode and clear bit Scan in
  1782. ; the high byte; otherwise, put the scan code in the lower byte and set bit
  1783. ; Scan in the high byte.  Uses dos keyboard reading.
  1784. ; Modifies register ax.
  1785. getkey  proc    near
  1786.         mov     keycode,0               ; clear old keycode
  1787.         cmp     dosflg,0                ; do ascii keyboard reading?
  1788.         jnz     getky7                  ; nz = yes, ascii
  1789.         jmp     getky6                  ; do scan code form
  1790.                                         ; ;;;;;;;; A S C I I ;;;;;;;;;
  1791. getky7: test    dosflg1,1               ; scan codes enabled?
  1792.         jz      getky7a                 ; z = no, continue
  1793.         call    dis_scan                ; disable them
  1794. getky7a:test    byte ptr kbcodes,80h    ; kbcodes initiated?            [dan]
  1795.         jz      getky5                  ; z = yes                       [dan]
  1796.         push    si
  1797.         call    nrc2cp                  ; point SI at this code page to NRC
  1798.         mov     nrcptr,si
  1799.         pop     si
  1800.         push    bx
  1801.         call    cplatin                 ; code page to Latin1, BX gets ptr
  1802.         mov     latinptr,bx
  1803.         call    cpdecsg                 ; code page to DEC-MCS, BX gets ptr
  1804.         mov     decmnptr,bx
  1805.         pop     bx
  1806.         and     byte ptr kbcodes,not 80h ; say kbcodes initiated
  1807. getky5: call    iseof                   ; is stdin at eof?
  1808.         jnc     getky5k                 ; nc = not eof, get more
  1809.         mov     al,trans.escchr         ; Kermit's escape char
  1810.         mov     byte ptr keycode,al     ; save ascii char
  1811.         clc                             ;  to get out gracefully at EOF
  1812.         ret                             ; and exit
  1813.  
  1814. getky5k:push    dx
  1815.         mov     dl,0ffh                 ; DOS read operation
  1816.         mov     ah,dconio               ; from stdin
  1817.         int     dos
  1818.         pop     dx
  1819.         jnz     getky5a                 ; nz = char available
  1820.         stc                             ; carry set = nothing available
  1821.         ret                             ; exit on no char
  1822. getky5a:xor     ah,ah
  1823.         cmp     al,16                   ; Control P?
  1824.         jne     getky5b                 ; ne = no
  1825.         mov     al,0a2h                 ; force F12 scan code, put on printer
  1826.         or      keycode,scan            ; ensure scan bit is set
  1827.         jmp     short getky5c
  1828. getky5b:cmp     al,BS                   ; backspace key?
  1829.         jne     getky5c                 ; ne = no
  1830. ;       or      keycode,scan            ; ensure scan bit is set
  1831. getky5c:mov     byte ptr keycode,al     ; save ascii char
  1832.         clc                             ; carry clear = got a char
  1833.         ret                             ; and exit
  1834.                                         ; ;;;;;; S C A N C O D E ;;;;;;
  1835. getky6: test    dosflg1,1               ; scan codes enabled?
  1836.         jnz     getky6a                 ; nz = yes, continue
  1837.         call    ena_scan                ; enable them
  1838. getky6a:test    byte ptr kbcodes,80h    ; kbcodes initiated?            [dan]
  1839.         jz      getky6b                 ; z = yes                       [dan]
  1840.         mov     kbcodes,0001h           ; low byte = status, high = read char
  1841.         push    si
  1842.         call    nrc2cp                  ; point SI at this code page to NRC
  1843.         mov     nrcptr,si
  1844.         pop     si
  1845.         push    bx
  1846.         call    cplatin                 ; code page to Latin1, BX gets ptr
  1847.         mov     latinptr,bx
  1848.         call    cpdecsg                 ; code page to DEC-MCS, BX gets ptr
  1849.         mov     decmnptr,bx
  1850.         pop     bx
  1851. getky6b:call    iseof                   ; is stdin at eof?
  1852.         jnc     getky6c                 ; nc = not eof, get more
  1853.         mov     al,trans.escchr         ; Kermit's escape char
  1854.         mov     byte ptr keycode,al     ; save ascii char
  1855.         clc                             ;  to get out gracefully at EOF
  1856.         ret                             ; and exit
  1857. getky6c:push    dx
  1858.         mov     dl,0ffh                 ; DOS read operation
  1859.         mov     ah,dconio               ; from stdin
  1860.         int     dos
  1861.         pop     dx
  1862.         jnz     getky6d                 ; nz = char available
  1863.         stc                             ; carry set = nothing available
  1864.         ret                             ; exit on no char
  1865. getky6d:call    fixflg                  ; go set keycode flags in ax
  1866.         cmp     al,80h                  ; start of special keys
  1867.         jb      getky6g                 ; go make these pure ascii
  1868. getky6e:or      ax,scan                 ; set the scan bit
  1869. getky6f:mov     keycode,ax
  1870.         clc
  1871.         ret
  1872. getky6g:push    cx
  1873.         mov     cx,shift
  1874.         or      cx,control
  1875.         not     cx
  1876.         and     ax,cx                   ; clear shift and control bits
  1877.         pop     cx
  1878.         jmp     short getky6f
  1879. getkey  endp
  1880.  
  1881. ; Return modified char code, depending on SET TERM CHAR-SET and active
  1882. ; Code Page. Enter and exit with char in AL.
  1883. xltkey  proc    near
  1884.     cmp    al,' '            ; control character?
  1885.     jb    xltkey2            ; b = yes, do not translate
  1886.         cmp     flags.xltkbd,0          ; keyboard translation is off?
  1887.         je      xltkey2                 ; e = yes
  1888.         cmp     vtemu.vtchset,0         ; NRC's, using ASCII already?
  1889.         je      xltkey2                 ; e = yes, use char in AL
  1890.         cmp     vtemu.vtchset,12        ; 1-12 for NCRs?
  1891.         ja      xltkey3                 ; a = no
  1892.         push    si
  1893.         push    di
  1894.         push    ax
  1895.         mov     si,nrcptr               ; point SI at this code page to NRC
  1896.         pop     ax
  1897.         mov     di,si                   ; start of table are ASCII chars
  1898.         mov     cl,vtemu.vtchset        ; get set number (1-12)
  1899.         xor     ch,ch
  1900.         sub     di,cx                   ; minus one byte per set
  1901.         shl     cx,1                    ; 15 bytes per NRC entry
  1902.         shl     cx,1
  1903.         shl     cx,1
  1904.         shl     cx,1
  1905.         add     di,cx                   ; +16, source, point at this entry
  1906.         mov     cx,12                   ; do first 12 bytes of them
  1907.         push    es
  1908.         push    ds
  1909.         pop     es
  1910.         cld
  1911.         repne   scasb                   ; look for this byte code in table
  1912.         pop     es
  1913.         jne     xltkey1                 ; ne = not found, use char in AL
  1914.         inc     cx
  1915.         sub     cx,12                   ; compute char index
  1916.         neg     cx
  1917.         add     si,cx                   ; index into ASCII table
  1918.         mov     al,[si]                 ; get matching ASCII char (set 0)
  1919. xltkey1:pop     di
  1920.         pop     si
  1921. xltkey2:ret
  1922.                                         ; LATIN1 set
  1923. xltkey3:test    al,80h                  ; high bit set?
  1924.         jz      xltkey2                 ; z = no, no translation
  1925.         cmp     vtemu.vtchset,15        ; set term character-set LATIN1?
  1926.         jne     xltkey4                 ; ne = no
  1927.         and     al,not 80h              ; remove high bit
  1928.         push    bx
  1929.         mov     bx,latinptr             ; Code Page to Latin1
  1930.         xlatb                           ; translate to Latin1 in AL
  1931.         pop     bx
  1932.         ret
  1933. xltkey4:cmp     vtemu.vtchset,16        ; set term character-set DEC-MCS?
  1934.         jne     xltkey2                 ; ne = no
  1935.         and     al,not 80h              ; remove high bit
  1936.         push    bx
  1937.         mov     bx,DECmnptr             ; Code Page to DEC-MCS
  1938.         xlatb                           ; translate to DEC-MCS in AL
  1939.         pop     bx
  1940.         ret
  1941. xltkey  endp
  1942.  
  1943.  
  1944. ; Do any local processing after reading a key during active translation
  1945. ; Avoids same actions if a key is being defined or shown.
  1946. postkey proc    near
  1947.                                         ; Key Click code for VT102 emulator
  1948.         cmp     flags.vtflg,0           ; emulating? (0 = no)
  1949.         je      postke1                 ; e = extra clicks not available
  1950.         test    vtemu.vtflgst,vskeyclick ; flags from SET TERM
  1951.         jz      postke1                 ; z = extra clicks not wanted
  1952.         call    vclick                  ; click, what else?
  1953. postke1:ret
  1954. postkey endp
  1955.  
  1956. ;keycom sends commands in dl to the Z-100 keyboard processor
  1957. keycom  proc    near
  1958.         in      al,keystat              ; check status
  1959.         test    al,KPR                  ; keyboard ready?
  1960.         jnz     keycom                  ; keep trying if not ready
  1961.         mov     al,dl                   ; we need command here
  1962.         out     keycmd,al               ; do it
  1963.         ret
  1964. keycom  endp
  1965.  
  1966. ;fixflg updates ax by seting the proper shift keycode flags in ah
  1967. ;enter with true Z-100 ascii scan code in al
  1968. ;returns with ax updated per keycode standards, except bit scan not set  
  1969. fixflg  proc    near
  1970.         xor     ah,ah                   ; we need it clean
  1971.         push    di                      ; search list z10keyl for this keycode
  1972.         push    cx                      ; save some registers   
  1973.         push    es
  1974.         mov     di,offset z10keyl       ; list of defined keycode bytes
  1975.         mov     cx,lz10keyl             ; number of bytes to examine
  1976.         push    ds
  1977.         pop     es                      ; make es:di point to data segment
  1978.         cld
  1979.         repne   scasb                   ; find keycode in list
  1980.         pop     es                      ; restore regs
  1981.         je      fixflg1                 ; e = found, work with present di
  1982.         pop     cx                      ; restore original cx
  1983.         pop     di                      ; restore original di
  1984.         ret                             ; char is already in al
  1985. fixflg1:neg     cx                      ; subtract cx from
  1986.         add     cx,lz10keyl             ; we went this far into the table
  1987.         and     cx,3                    ; we need these bits
  1988.         cmp     cx,1                    ; nothing?
  1989.         jz      fixflg4                 ; done
  1990.         cmp     cx,2                    ; shift?
  1991.         jnz     fixflg2                 ; no, go check control
  1992.         or      ax,shift                ; shift, set 200
  1993.         jmp     fixflg4                 ; done
  1994. fixflg2:cmp     cx,3                    ; control?
  1995.         jnz     fixflg3                 ; no, jump
  1996.         or      ax,control              ; yes, control, set 400
  1997.         jmp     fixflg4                 ; done
  1998. fixflg3:or      ax,shift                ; must be
  1999.         or      ax,control              ;  both of these
  2000. fixflg4:pop     cx
  2001.         pop     di
  2002.         ret
  2003. fixflg  endp
  2004.  
  2005. code    ends
  2006.         end
  2007.