home *** CD-ROM | disk | FTP | other *** search
/ Columbia Kermit / kermit.zip / extra / nyenhuis3.arc / MSGIBM.ASM < prev    next >
Assembly Source File  |  1990-01-16  |  154KB  |  4,748 lines
  1.      Name msgibm
  2. ; File MSGIBM.ASM
  3.     include mssdef.h
  4. ; Tektronix emulator for use with MS Kermit/IBM.
  5. ; Edit history:
  6. ; Last edit 16 Jan 1990
  7. ; 8 June 1989 Added Wyse-700 support from Mikko Laanti.
  8. ; 21 Nov 1988 Version 2.32
  9. ; 1 Nov 1987 Heavy rewrite to integrate code into regular MS Kermit/IBM
  10. ;  material. [jrd]
  11. ;==============================================================================
  12. ; Original version for TI Pro computers by
  13. ; 12-Dec-84  Joe Smith, CSM Computing Center, Golden CO 80401
  14. ; adapted to IBM PC June 1987 by    Brian Holley,
  15. ;                    Faculty of Economics and Politics
  16. ;                    University of Cambridge, England
  17. ;                    Email: BJH6@UK.AC.CAM.PHX
  18. ; Upgraded and integrated into MS Kermit 2.30 by Joe Doupnik, Utah State Univ.
  19. ;
  20. ;           Description of Tektronix commands
  21. ;
  22. ; ESC CONTROL-E (ENQ) requests a status report
  23. ; ESC FORMFEED erases the screen.
  24. ; ESC CONTROL-X turns on bypass mode (no screen characters).
  25. ; ESC CONTROL-Z turns on the crosshairs (not on 4006 or 4025)
  26. ; ESC ? is replaced by DEL code, to assist line plots with 7 bit systems.
  27. ; ESC [ Pn ; Pn m  set screen colors. Pn = 30 + sum of colors for foregnd,
  28. ;  40 + sum of colors for background, Pn = 0 sets b/w, Pn = 1 for high
  29. ;  intensity. Colors are red = 1, green = 2, blue = 4.
  30. ; ESC [ ? 3 8 l  exits Tek mode and returns to host text terminal type
  31. ;  (VT102 if none defined yet). This is an extension from DEC VT340's.
  32. ; ESC [ ? 256 n  invokes a screen size report, for Word Perfect. Report is
  33. ;   ESC [ ? 256; height; width; num colors n   where num colors is 0, 1 or
  34. ;   16; report ESC [ ? 24; 80; 0 n  for pure text mono systems.
  35. ; ESC @  through  ESC M  sets default fill pattern as below (1=@...).
  36. ; ESC Z  report terminal type (as VT320)
  37. ; ESC [ 2; 2 $ u  host request color palette report.
  38. ; ESC / xhome;yhome;xwidth;yheight x           draw an empty rectangle
  39. ; ESC / xhome;yhome;xwidth;yheight;pattern y   fill rectangle with pattern
  40. ; ESC / xhome;yhome;xwidth;yheight;pattern z   fill rect with pattern+border
  41. ;  where x/yhome is the lower left Tek corner, xwidth and yheight are the
  42. ;  Tek width and height. All values are decimal numbers.
  43. ;  Patterns 0:use default, 1:solid, 2:grey, 3:left to right slant, 4:right to
  44. ;  left slant, 5:horizontal lines, 6:vertical lines, 7:slanted cross-hatch,
  45. ;  8:vertical cross-hatch, 9:checkerboard; 10:dotted, 11:horiz herringbone,
  46. ;  12:vertical herringbone,13 and above:border without fill. All are tiling
  47. ;  8x8 pixel patterns.
  48. ; ESC / param a, ... ESC / param c  set user definable line drawing pattern
  49. ;  to 16 bit value of param; plot as lsb first.
  50. ; ESC / 2 h or l,  ESC / 9 h or l. h is set, l is reset, 2 is destructive
  51. ;  space and 9 is destructive backspace. Defaults are reset.
  52. ; ESC x  ESC y  ESC z   selects one of these user definable patterns above.
  53. ; ESC P  P1; P2; P3 q string ESC \        a Sixel Graphics command
  54. ;   P1 and P3 ignored, P1 = 1 means draw 0 bits in background, else skip them.
  55. ;   string is
  56. ;     sixel chars (3fh..7eh, lower 6 bits+3fh, displayed lsb at the top)
  57. ;     ! Pn sixel char        where Pn is a repeat count
  58. ;     " Pc; Pad; Ph; Pv        raster attributes (all ignored for now)
  59. ;     # Pc; Pu; Px; Py; Pz  coloring as follows
  60. ;    Pc is color palette, 0-15
  61. ;    Pu is color units, 1=HLS, 2=RGB
  62. ;    For Hue Lightness Saturation:
  63. ;        Px = Hue angle, 0-360 degrees. The colors are mapped around
  64. ;        the color wheel in 60 degree segments as Hues:
  65. ;        0-29 deg = blue, 30-89 = magenta (blue + red), 90-149 = red,
  66. ;        150-209 = yellow (red + green), 210-269 = green,
  67. ;        270-329 = cyan (green + blue), 330-359 = blue.
  68. ;        Py = Lightness, 0-100%, Pz = Saturation, 0-100%
  69. ;          Lightness    Sat = 51-100    Sat = 11-50     Sat = 0-10
  70. ;          86-100    bold white    bold white     bold white
  71. ;          71-85        bold hue    bold white     bold white
  72. ;          57-70        bold hue    grey (dim white) grey
  73. ;          43-56        bold hue    dim hue         black
  74. ;          29-42        dim hue        grey         grey
  75. ;          14-28        dim hue        black         black
  76. ;           0-13     black        black         black
  77. ;        Note that Py = Pz = 50 gives the widest spectrum.
  78. ;    For RGB: Px = red, 0-100%, Py = green, 0-100%, Pz = blue, 0-100%
  79. ;        If any color exceeds 50% then the bold bit is turned on for
  80. ;        the ensemble (IBM ega display adapter constraint for RGBi).
  81. ;
  82. ;    Palette registers can be selected by the substring
  83. ;        # Pc    followed by a non-numeric char other than ";"
  84. ;            and Pc is the palette register, 0-15.
  85. ;
  86. ;     $  (dollar sign )     meaning go to left margin
  87. ;     -  (minus)         meaning go to left margin 6 dots down.
  88. ;   This command yields one or more sets of 6 vertically arranged dots. They
  89. ;   are placed starting at the top and left side of the current text cell.
  90. ;   Escape sequences are permitted within string and occur without disruption.
  91. ; CONTROL-] (GS) turns on plot mode, the first move will be with beam off.
  92. ; CONTROL-^ (RS) turns on incremental plot mode. RS space means move pen up
  93. ;  RS P means move pen down, following letters:A, E, D, F, B, J, H, I mean
  94. ;  move right, right and up, up, left and up, left, left and down, down, and
  95. ;  right and down, respectively. Ex: RS <space> J J J  means move three Tek
  96. ;  positions left and down with the pen up (invisibly).
  97. ; CONTROL-UNDERLINE (US) turns off plot mode, as does CR (for all but 4025).
  98. ; CONTROL-X switches from TEKTRONIX sub mode to NORMAL alpha mode but is
  99. ;  ignored if we are emulating a full Tek terminal rather than a sub mode
  100. ;  of DEC or Heath.
  101. ; FF erases screen.
  102. ; ESC letter, where letter is accent grave (`), a-e sets the line drawing
  103. ;   pattern until reset to solid lines (same as escape accent) by command or
  104. ;   a terminal reset.
  105. ; 
  106. ;    ENQ = Control E
  107. ;    ESC = Control [ (left square bracket)
  108. ;    FF = Control L
  109. ;    FS = Control \ (backslash)
  110. ;    GS = Control ] (right square bracket)
  111. ;    RS = Control ^ (caret)
  112. ;    US = Control _ (underscore)
  113. ;
  114. ; The plot commands are characters which specify the absolute position to move
  115. ; the beam.  All moves except the one immediately after the GS character
  116. ; (Control-]) are with a visible trace.
  117. ;
  118. ; For 4010-like devices - The positions are from 0 to 1023 for both X and Y,
  119. ; although only 0 to 780 are visible for Y due to screen geometry.  The screen
  120. ; is 10.23 by 7.80 inches, and coordinates are sent as 1 to 4 characters.
  121. ;
  122. ; For 4014-like devices - The positions are from 0 to 4096, but each movement
  123. ; is a multiple of 4 positions unless the high-resolution LSBXY are sent.  This
  124. ; makes it compatible with the 4010 in that a full sized plot fills the screen.
  125. ;
  126. ; HIX,HIY = High-order 5 bits of position
  127. ; LOX,LOY = Middle-order 5 bits of position
  128. ; LSBXY      = Low-order 2 bits of X + low-order 2 bits of Y (4014 mode)
  129. ;
  130. ; Hi Y      Lo Y      Hi X      LSBXY      Characters sent (Lo-X always sent)
  131. ; ----      ----      ----      -----      ----------------------------------
  132. ; Same      Same      Same      Same                 Lo-X
  133. ; Same      Same      Same      Diff        LSB, Lo-Y,     Lo-X    4014
  134. ; Same      Same      Diff      Same             Lo-Y, Hi-X, Lo-X
  135. ; Same      Same      Diff      Diff        LSB, Lo-Y, Hi-X, Lo-X    4014
  136. ; Same      Diff      Same      Same             Lo-Y,     Lo-X
  137. ; Same      Diff      Same      Diff        LSB, Lo-Y,     Lo-X    4014
  138. ; Same      Diff      Diff      Same             Lo-Y, Hi-X, Lo-X
  139. ; Same      Diff      Diff      Diff        LSB, Lo-Y, Hi-X, Lo-X    4014
  140. ; Diff      Same      Same      Same      Hi-Y,             Lo-X
  141. ; Diff      Same      Same      Diff      Hi-Y, LSB, Lo-Y,     Lo-X    4014
  142. ; Diff      Same      Diff      Same      Hi-Y,         Lo-Y, Hi-X, Lo-X
  143. ; Diff      Same      Diff      Diff      Hi-Y, LSB, Lo-Y, Hi-X, Lo-X    4014
  144. ; Diff      Diff      Same      Same      Hi-Y,         Lo-Y,     Lo-X
  145. ; Diff      Diff      Same      Diff      Hi-Y, LSB, Lo-Y,     Lo-X    4014
  146. ; Diff      Diff      Diff      Same      Hi-y,         Lo-Y, Hi-X, Lo-X
  147. ; Diff      Diff      Diff      Diff      Hi-y, LSB, Lo-Y, Hi-X, Lo-X    4014
  148. ; Offset for byte:          20h    60h  60h   20h     40h
  149. ;
  150. ; Note that LO-Y must be sent if HI-X has changed so that the TEKTRONIX knows
  151. ; the HI-X byte (in the range of 20h-3fh) is HI-X and not HI-Y.     LO-Y must
  152. ; also be sent if LSBXY has changed, so that the 4010 will ignore LSBXY and
  153. ; accept LO-Y.    The LSBXY byte is 60h + MARGIN*10h + LSBY*4 + LSBX. (MARGIN=0)
  154. ;
  155. ;
  156. ;
  157. ; External variable tekflg and calls to tekini, tekemu, tekesc, tekcls:
  158. ; Byte TEKFLG is non-zero when the Tek emulator is active; it is set by the
  159. ; startup code in tekini and is maintained in this file. Internal variable
  160. ; inited remembers if we have a graphics screen saved, etc.
  161. ; TEKINI must be called when entering the emulator to establish the graphics
  162. ; screen mode and to calculate the screen dimensions.
  163. ; TEKRINT reinitialize complete emulator.
  164. ; TEKESC is called from say mszibm.asm to invoke Tek emulation when the
  165. ; external procedures have detected an Escape Control-L sequence. An implicit
  166. ; initialization is done if necessary.
  167. ; TEKEMU is the normal entry point to pass a received character to the emulator.
  168. ; It too will do an implicit initialization, if required.
  169. ; TEKCLS clears the graphics screen, but only if the emulator is active.
  170. ; The emulator remains active during Connect mode Help, Status, and other
  171. ; interrupts which do not change the terminal type.
  172.  
  173.      
  174.     public    tekemu,tekini,tekrint,tekend,tekgraf ; Terminal emulation
  175.         public    tekflg, tekdmp, tekinq, tekpal    ;  used by mszibm file
  176.     public    chcontrol            ; used by msyibm file
  177.  
  178. ENQ    equ    05h            ; ^E ENQ for TEK enquiries
  179. CAN    equ    18h            ; ^X to return to ANSI mode
  180. ESCZ    equ    1Ah            ; SUB, ESC-^Z triggers crosshairs
  181. VT    equ    0bh            ; ^K go up one line
  182. FS    equ    1ch            ; ^\ for point plot mode
  183. GS    equ    1Dh            ; ^] draw line (1st move is invisible)
  184. RS    equ    1Eh                   ; ^^ for incremental line plot mode
  185. US    equ    1Fh            ; ^_ (underscore) returns to text mode
  186. accent    equ    60h            ; accent grave
  187.  
  188. txtmode    equ    4            ; text mode for TEKTRONIX status
  189. maxtekx equ    1024            ; horizontal and
  190. maxteky equ    780            ; vertical resolution of TEK 4010
  191.      
  192. screen    equ    10h            ; IBM Bios screen call
  193.      
  194. uparr    equ    72            ; DOS scan codes for arrow keys
  195. dnarr    equ    80
  196. lftarr    equ    75
  197. rgtarr    equ    77
  198. homscn    equ    71            ; DOS home screen scan code
  199. shuparr    equ    '8'            ; ascii codes for shifted arrows
  200. shdnarr    equ    '2'
  201. shlftarr equ    '4'
  202. shrgtarr equ    '6'
  203.      
  204.                     ; Graph_mode for different systems:
  205. cga    equ    6            ; highest resolution mode for CGA
  206. mono    equ    7            ; real monochrome display adapter
  207. colorega equ    14            ; Low-res mode, color EGA
  208. monoega equ    15            ; mono ega needs mode 15
  209. ega    equ    16            ; Hi-res mode - EGA
  210. olivetti equ    72            ; Olivetti's Hi-res - 50 lines text
  211. toshiba    equ    74h            ; Toshiba T3100, like Olivetti
  212. vaxmate    equ    0D0h            ; DEC VAXmate II, like Olivetti
  213. wyse700 equ    0D3h            ; Wyse-700 1280 * 400
  214. hercules equ    255            ; pseudo mode for Hercules graphics
  215. ; Note: IBM VGA modes 17 & 18, 640 by 480, can be used by setting "ega" above
  216. ; to 17 or 18 and modifying ybot to be 479 and ymult to be 48 at label tekin5.
  217. ; The code will scale everything appropriately for the new screen size, but
  218. ; there will be insufficient memory to retain the entire graphics image.
  219. ; Manual override SET TERMINAL GRAPHICS VGA accomplishes these two steps.
  220. ;
  221. ; Note: WYSE-700 mode 1024 * 780 and 1280 * 800 can be set only by
  222. ; manual override SET TERMINAL GRAPHICS WYSET or WYSEA, respectively.
  223. ; No automatic sensing for Wyse.
  224.  
  225. segega    equ    0a000h            ; segments of display memory, EGA,VGA
  226. segcga    equ    0b800h            ; CGA, AT&T/Olivetti and relatives
  227. seghga    equ    0b000h            ; HGA
  228. segmono    equ    0b000h            ; Monochrome
  229. segwyse equ    0a000h            ; wyse-700, both banks start from here
  230.                     ; Wyse equates:
  231. wystoff equ    03ddh            ; set bank start offset
  232. wystseg equ    03deh            ; set bank start base
  233. wymode    equ    03dfh            ; register to select mode & bank
  234. wybeven equ    0c8h            ; mask for R/W even bank
  235. wybodd    equ    0cbh            ; mask for R/W odd bank
  236.  
  237.                     ; Hercules equates:
  238. index    equ    03b4h            ; 6845 index register
  239. cntrl    equ    03b8h            ; Display mode control port
  240. hstatus    equ    03bah            ; status port
  241. scrn_on equ    8            ; bit to turn screen on
  242. grph    equ    2            ; graphics mode
  243. text    equ    20h            ; text mode
  244. config    equ    03bfh            ; configuration port
  245. genable equ    1+2            ; enable graphics (1) on two pages (2) 
  246. rgbbold    equ    80            ; nor/bold threshold for RGB intensity
  247. hiy    equ    1            ; codes for Tek graphics components
  248. loy    equ    2
  249. hix    equ    4
  250. lox    equ    3
  251. ; maxparam and maxinter must agree with the prime equ's in file mszibm.asm
  252. maxparam equ    10            ; number of ESC and DCS Parameters
  253. maxinter equ    10            ; number of ESC and DCS Intermediates
  254.  
  255.                     ; Pixel basic operation codes
  256. pixor    equ    1            ; write as foreground OR current dot
  257. pixbak    equ    2            ; write as absolute background color
  258. pixxor    equ    4            ; write as foreground XOR current dot 
  259. pixfor    equ    8            ; write absolute foreground color
  260.  
  261. data    segment public 'data'
  262.     extrn    flags:byte, portval:word, rxtable:byte, vtemu:byte     
  263.     extrn    tv_mode:byte, yflags:byte, low_rgt:byte
  264.     extrn    param:word, nparam:word, inter:byte, ninter:word, lparam:byte
  265.     extrn    parstate:word, pardone:word, parfail:word
  266.     extrn    dnparam:word, dparam:word, dlparam:byte, dninter:word
  267.     extrn    dinter:byte, dcsstrf:byte, emubufc:word, emubuf:byte
  268.     extrn    emubufl:word
  269.  
  270. ; required for Hercules screen handling
  271.      
  272. gtable    db    35h,2dh,2eh,7        ; bytes for 6845 controller
  273.     db    5bh,2,57h,57h        ; - graphics mode
  274.     db    2,3,0,0
  275.      
  276. ttable    db    61h,50h,52h,0fh        ; bytes for 6845 controller
  277.     db    19h,6,19h,19h        ; - text mode
  278.     db    2,0dh,0bh,0ch
  279.  
  280. attlogo    db    'OLIVETTI'        ; Olivetti M24/28, AT&T 6300 rom id
  281. attllen    equ    $-attlogo        ; length
  282. toshlogo db    '  TT33110000  TTOOSSHHIIBBAA' ; Toshiba T3100 logo
  283. toshlen    equ    $-toshlogo        ; length
  284. declogo    db    'Copyright Digital Equipment Corp' ; DEC VAXmate
  285. declen    equ    $-declogo
  286. dumpname db    'TEKPLT.TIF',0        ; dump name
  287. dumplen    equ    $-dumpname
  288. tempname db    84 dup (0)        ; temp work area
  289. dhandle    dw    -1            ; dump file handle
  290.  
  291. ttstate    dw    tektxt            ; state machine control pointer
  292. prestate dw    0            ; previous state, across interruptions
  293. visible db    0            ; 0 to move, 1 to draw a line
  294. tek_hiy dw    0            ; Y coordinate in Tektronix mode
  295. tek_loy db    0
  296. tek_hix dw    0            ; X coordinate in Tektronix mode
  297. tek_lox db    0
  298. tek_lsb db    0            ; Low-order 2 bits of X + low Y
  299.                     ;    (4014 mode)
  300. status    db    0
  301. lastc    db    0            ; last x/y coord fragment seen       
  302. bnkchan db    0            ; a flag so we can select which bank
  303.                     ; to write in Wyse 1280*800 mode
  304. colpal    db    0,9,0ch,0ah        ; VT340 color palette table, IRGB
  305.     db    0dh,0bh,0eh,7, 8,1,4,2, 5,3,6,0fh ; 16 bytes, active table
  306. coldef    db    0,9,0ch,0ah, 0dh,0bh,0eh,7, 8,1,4,2, 5,3,6,0fh ; color def
  307. mondef    db    0,7 dup (0fh), 8 dup (7) ; monochrome default "colors"
  308. masktab db    80h,40h,20h,10h,8,4,2,1 ; quicker than calculations!
  309.                     ; dashed line patterns
  310. linetab    dw    0ffffh            ; ESC accent    11111111 11111111
  311.     dw    0aaaah            ; ESC a        10101010 10101010
  312.     dw    0f0f0h            ; ESC b        11110000 11110000
  313.     dw    0fafah            ; ESC c        11111010 11111010
  314.     dw    0ffcch            ; ESC d        11111111 11001100
  315.     dw    0fc92h            ; ESC e        11111100 10010010
  316.     dw    0            ; ESC x    user defined
  317.     dw    0            ; ESC y user defined
  318.     dw    0            ; ESC z user defined
  319. linepat    dw    0ffffh            ; active line pattern, from above
  320.  
  321. tekid    db    escape,'[?63;1;2;4;8;9;15c',0; VT320, level 3, etc
  322. ;End of init data
  323.  
  324.     even
  325. xmult    dw    1            ; scaling factor for x is
  326. xdiv    dw    1            ;     xmult/xdiv
  327. ymult    dw    1            ; scaling factor for y is
  328. ydiv    dw    1            ;     ymult/ydiv
  329. xmax    dw    1            ;
  330. ybot    dw    1            ;
  331. x_coord dw    0            ; Tek text char X coordinate
  332. y_coord dw    0            ; Tek text char Y coordinate
  333. xcross    dw    0            ; cross hairs to start at centre
  334. ycross    dw    0
  335. oldx    dw    0            ; Tek coordinates of last point
  336. oldy    dw    767            ;  initially top left
  337. scalex    dw    0            ; PC coord for scaled x value
  338. scaley    dw    0            ;  for scaled y value
  339. rectx1    dw    0            ; Rectangle PC x lower left corner
  340. recty1    dw    0            ; Rectangle PC y lower left corner
  341. rectx2    dw    0            ; Rectangle PC x width
  342. recty2    dw    0            ; Rectangle PC y height
  343. numlines dw    0            ; number of lines to fill
  344.                     ; area fill material
  345. fill    db    0            ; current fill byte pattern
  346. fillptr    dw    filpat1            ; pointer to current fill pattern
  347. fillist    dw    filpat1,filpat2,filpat3,filpat4,filpat5,filpat6,filpat7
  348.     dw    filpat8,filpat9,filpat10,filpat11,filpat12,filpat13
  349.     dw    filpat14
  350. numfil    equ    ($-fillist)/2        ; number of fill patterns
  351.     ; fill patterns, 8 bits wide, first byte is at top of PC screen
  352.     ; 8 bytes per pattern for 8 scan line repetition
  353. filpat1    db    8 dup (0ffh)        ; solid fill
  354. filpat2    db    4 dup (0aah, 55h)    ; grey (alternating dots)
  355. filpat3    db    80h,01h,02h,04h, 08h,10h,20h,40h ; right to left slant up
  356. filpat4    db    80h,40h,20h,10h, 08h,04h,02h,01h ; left to right slant up
  357. filpat5 db    2 dup (0,0,0aah,0)    ; horizontal lines
  358. filpat6    db    8 dup (44h)        ; vertical lines
  359. filpat7    db    80h,41h,22h,14h, 08h,14h,22h,41h   ; slanted crosshatch
  360. filpat8    db    2 dup (0aah,80h,80h,80h)  ; vertical crosshatch
  361. filpat9    db    4 dup (0f0h), 4 dup (0fh) ; checkerboard
  362. filpat10 db    4 dup (44h, 11h)    ; dots
  363. filpat11 db    2 dup (10h,28h,44h,82h)    ; horizontal herringbone
  364. filpat12 db    80h,40h,20h,10h,08h,10h,20h,40h ; vertical herringbone
  365. filpat13 db    8 dup (0)        ; first user definable fill
  366. filpat14 db    8 dup (0)        ; second user definable fill
  367.                     ; end of area fill material
  368. curmode    db    0            ; screen mode before graphics
  369. tekgraf    db    0        ; Tek graphics board selection (def=auto)
  370.                 ; local variables for LINE plotting routine
  371. graph_mode db    0            ; graphics video mode, default is none
  372. cursor    dw    0            ; saved text cursor
  373. inited    db    0            ; non-zero if inited (retains page)
  374. tekflg    db    0            ; Tek mode active flag
  375.                     ;  1=Tek reads serial port
  376.                     ;  2=VT300 emulator reads serial port
  377. tekident db    0            ; Tek ident request flag
  378. flow    dw    0            ; flow control word
  379. gpage    db    0            ; display adapter graphics page
  380. gfcol    db    15            ; graphics foreground colour
  381. gbcol    db    0            ; graphics background color
  382. tfcol    db    0            ; temp foreground color
  383. tbcol    db    0            ; temp background color
  384. colortb    db    0,4,2,6,1,5,3,7        ; color reversed-bit setting bytes
  385. ccode    db    pixfor            ; temp for holding plot color code
  386. bypass    db    0            ; GIN mode bypass condition (0=off)
  387. esctype    db    0
  388. bscontrol db    0            ; non-zero for destructive BS
  389. spcontrol db    0            ; non-zero for destructive SPACE
  390. chcontrol db    0            ; char-writing, 1=opaque,0=transparent
  391.     even
  392. putc    dw    mputc            ; ptr to plot a character routine
  393. psetup    dw    psetupm            ; ptr to plot setup routine
  394. pincy    dw    pincym            ; ptr to inc y routine
  395. plotptr    dw    pltmon            ; ptr to dot plot routine
  396. gcplot    dw    gcgen            ; ptr to char plot routine
  397. gfplot    dw    bpltmon            ; ptr to area-fill plot routine
  398. segscn    dw    0b800h            ; actual screen segment to use
  399. doneptr    dw    offset xpardone,seg xpardone ; far pointer for tpardone use
  400. dumpptr    dw    offset dump,seg dump    ; far pointer for dump use
  401. initptr    dw    offset tekini,seg tekini
  402. rptptr    dw    offset tekrpt,seg tekrpt
  403. endptr    dw    offset tekend,seg tekend
  404. linelen    dw    0            ; offset increment between scan lines
  405. ten    dw    10            ; word 10 for multiplying
  406. temp    dw    0
  407.  
  408. ; 8*8 font for Hercules and such, CGA, and EGA
  409. ; - allows 43 lines, and 80 (90 for Hercules) chars per line.
  410. ; all printing (?) characters from <space> to <del> - two characters per line
  411. ; 8 bits per scan line, top line given first, 8 scan lines.    
  412. font    db    0,0,0,0,0,0,0,0,           18h,18h,18h,18h,18h,0,18h,0
  413.     db    6ch,6ch,6ch,0,0,0,0,0,           36h,36h,7fh,36h,7fh,36h,36h,0
  414.     db    0ch,3fh,68h,3eh,0bh,7eh,18h,0, 60h,66h,0ch,18h,30h,66h,06h,0
  415.     db    38h,6ch,6ch,38h,6dh,66h,3bh,0, 0ch,18h,30h,0,0,0,0,0
  416.     db    0ch,18h,30h,30h,30h,18h,0ch,0, 30h,18h,0ch,0ch,0ch,18h,30h,0
  417.     db    0,18h,7eh,3ch,7eh,18h,0,0,     0,18h,18h,7eh,18h,18h,0,0
  418.     db    0,0,0,0,0,18h,18h,30h,           0,0,0,7eh,0,0,0,0
  419.     db    0,0,0,0,0,18h,18h,0,           0,06h,0ch,18h,30h,60h,0,0
  420.     db    3ch,66h,6eh,7eh,76h,66h,3ch,0, 18h,38h,18h,18h,18h,18h,7eh,0
  421.     db    3ch,66h,06h,0ch,18h,30h,7eh,0, 3ch,66h,06h,1ch,06h,66h,3ch,0
  422.     db    0ch,1ch,3ch,6ch,7eh,0ch,0ch,0, 7eh,60h,7ch,06h,06h,66h,3ch,0
  423.     db    1ch,30h,60h,7ch,66h,66h,3ch,0, 7eh,06h,0ch,18h,30h,30h,30h,0
  424.     db    3ch,66h,66h,3ch,66h,66h,3ch,0, 3ch,66h,66h,3eh,06h,0ch,38h,0
  425.     db    0,0,18h,18h,0,18h,18h,0,       0,0,18h,18h,0,18h,18h,30h
  426.     db    0ch,18h,30h,60h,30h,18h,0ch,   0,0,0,7eh,0,7eh,0,0,0
  427.     db    30h,18h,0ch,06h,0ch,18h,30h,   0,3ch,66h,0ch,18h,18h,0,18h,0
  428.     db    3ch,66h,6eh,6ah,6eh,60h,3ch,   0,3ch,66h,66h,7eh,66h,66h,66h,0
  429.     db    7ch,66h,66h,7ch,66h,66h,7ch,   0,3ch,66h,60h,60h,60h,66h,3ch,0
  430.     db    78h,6ch,66h,66h,66h,6ch,78h,   0,7eh,60h,60h,7ch,60h,60h,7eh,0
  431.     db    7eh,60h,60h,7ch,60h,60h,60h,   0,3ch,66h,60h,6eh,66h,66h,3ch,0
  432.     db    66h,66h,66h,7eh,66h,66h,66h,   0,7eh,18h,18h,18h,18h,18h,7eh,0
  433.     db    3eh,0ch,0ch,0ch,0ch,6ch,38h,   0,66h,6ch,78h,70h,78h,6ch,66h,0
  434.     db    60h,60h,60h,60h,60h,60h,7eh,   0,63h,77h,7fh,6bh,6bh,63h,63h,0
  435.     db    66h,66h,76h,7eh,6eh,66h,66h,   0,3ch,66h,66h,66h,66h,66h,3ch,0
  436.     db    7ch,66h,66h,7ch,60h,60h,60h,   0,3ch,66h,66h,66h,6ah,6ch,36h,0
  437.     db    7ch,66h,66h,7ch,6ch,66h,66h,   0,3ch,66h,60h,3ch,06h,66h,3ch,0
  438.     db    7eh,18h,18h,18h,18h,18h,18h,   0,66h,66h,66h,66h,66h,66h,3ch,0
  439.     db    66h,66h,66h,66h,66h,3ch,18h,   0,63h,63h,6bh,6bh,7fh,77h,63h,0
  440.     db    66h,66h,3ch,18h,3ch,66h,66h,   0,66h,66h,66h,3ch,18h,18h,18h,0
  441.     db    7eh,06h,0ch,18h,30h,60h,7eh,   0,7ch,60h,60h,60h,60h,60h,7ch,0
  442.     db    0,60h,30h,18h,0ch,06h,0,0,     3eh,06h,06h,06h,06h,06h,3eh,0
  443.     db    18h,3ch,66h,42h,0,0,0,0,       0,0,0,0,0,0,0,0ffh
  444.     db    30h,18h,0ch,0,0,0,0,0,           0,0,3ch,06h,3eh,66h,3eh,0
  445.     db    60h,60h,7ch,66h,66h,66h,7ch,0, 0,0,3ch,66h,60h,66h,3ch,0
  446.     db    06h,06h,3eh,66h,66h,66h,3eh,0, 0,0,3ch,66h,7eh,60h,3ch,0
  447.     db    0eh,18h,18h,3ch,18h,18h,18h,0, 0,0,3eh,66h,66h,3eh,06h,3ch
  448.     db    60h,60h,7ch,66h,66h,66h,66h,0, 18h,0,38h,18h,18h,18h,3ch,0
  449.     db    18h,0,38h,18h,18h,18h,18h,70h, 60h,60h,66h,6ch,78h,6ch,66h,0
  450.     db    38h,18h,18h,18h,18h,18h,3ch,0, 0,0,76h,7fh,6bh,6bh,63h,0
  451.     db    0,0,7ch,66h,66h,66h,66h,0,     0,0,3ch,66h,66h,66h,3ch,0
  452.     db    0,0,7ch,66h,66h,7ch,60h,60h,0, 0,3eh,66h,66h,3eh,06h,07h
  453.     db    0,0,6ch,76h,60h,60h,60h,0,     0,0,3eh,60h,3ch,06h,7ch,0
  454.     db    30h,30h,7ch,30h,30h,30h,1ch,0, 0,0,66h,66h,66h,66h,3eh,0
  455.     db    0,0,66h,66h,66h,3ch,18h,0,     0,0,63h,6bh,6bh,7fh,36h,0
  456.     db    0,0,66h,3ch,18h,3ch,66h,0,     0,0,66h,66h,66h,3eh,06h,3ch
  457.     db    0,0,7eh,0ch,18h,30h,7eh,0,     0ch,18h,18h,70h,18h,18h,0ch,0
  458.     db    18h,18h,18h,0,18h,18h,18h,0,   30h,18h,18h,0eh,18h,18h,30h,0
  459.     db    31h,6bh,46h,0,0,0,0,0,           8 dup (0ffh)
  460.  
  461. ; TIFF version 5.0 data fields
  462. ; Reference: Aldus/Microsoft Technical Memorandum dated 8/8/88
  463.                     ; TIFF data item size indicators
  464. uchar    equ    1            ; unsigned byte
  465. ascii    equ    2            ; asciiz string byte
  466. integer    equ    3            ; 16 bit unsigned integer
  467. long    equ    4            ; 32 bit unsigned integer
  468. rational equ    5            ; 32 bit numerator, 32 bit denominator
  469.  
  470. entry    struc                ; 12 byte image file directory entries
  471.     dw    ?            ; tag
  472.     dw    integer            ; type, of data item
  473. entcnt    dd    1            ; length, count of data items
  474. entval    dw    0            ; long value or long offset to value
  475.     dw    0
  476. entry    ends
  477.     
  478.     even                ; TIFF 5.0,  8 byte header
  479. header    dw    4949h            ; 'll', low byte stored first
  480.     dw    42            ; TIFF identification, 42 decimal
  481.     dw    nentry-header,0        ; long offset to image file directory
  482.                     ; Image File Directory
  483. nentry    dw    entrycnt        ; number of entries to follow
  484.                     ; 12-byte directory entries
  485. newsub    entry    <0feh,long>        ; new subfield type
  486. iwidth    entry    <100h,integer>        ; image width,  integer for WP 5
  487. ilength entry    <101h,integer>        ; image length, integer for WP 5
  488. bps    entry    <102h,,,4>         ; bits per sample, 4=iRGB, 1=B/W
  489. comp    entry    <103h,,,1>        ; compression, none
  490. photo     entry    <106h,,,3>        ; photometric interpret, palette 
  491. strip     entry    <111h,long,25,stripoff-header> ; offset to long strip offsets
  492. spp    entry    <115h,,,1>        ; samples/pixel, 1
  493. rps    entry    <116h,long,1,25>    ; long rows per strip
  494. sbc    entry    <117h,integer,25,stripbc-header> ; offset to strip byte counts
  495. xres    entry    <11ah,rational,1,xresval-header> ; x axis resolution
  496. yres    entry    <11bh,rational,1,yresval-header> ; y axis resolution
  497. resunit entry    <128h,integer,1,1>    ; resolution unit, no absolute units
  498. soft    entry    <131h,ascii,proglen,prog-header> ; software ident
  499. stamp    entry    <132h,ascii,dtlen,dandt-header>  ; date and time stamp
  500. cmap    entry    <140h,integer,3*16,colmap-header> ; palette color map
  501. entrycnt equ    ($-nentry-2+11)/12    ; compute number of entries for nentry
  502.     dd    0            ; long offset of next directory (none)
  503.                     ; supporting data pointed at above
  504. prog    db    'MS Kermit 300',0    ; originating program, asciiz
  505. proglen equ    $-prog
  506. dandt    db    '1989:12:25 00:00:01',0    ; date and time format
  507. dtlen    equ    $-dandt
  508. xresval dw    0,0,1,0            ; two double words (top / bottom)
  509. yresval dw    0,0,1,0            ; two double words (top / bottom)
  510. stripoff dd    25 dup (0)        ; long file offset for each strip
  511. stripbc dw    25 dup (0)        ; integer byte count for each strip
  512.     ; color map for red, green, blue; index by IRGB bits from ega sample
  513. colmap    dw    4 dup (0), 4 dup (007ffh), 4 dup (0), 4 dup (0ffffh) ; red
  514.     dw    2 dup (0,0,007ffh,007ffh), 2 dup (0,0,0ffffh,0ffffh) ; green
  515.     dw    2 dup (0,007ffh,0,007ffh), 2 dup (0,0ffffh,0,0ffffh) ; blue
  516. tifflen equ    $-header         ; length of header + directory + info
  517. pixdata equ    $              ; pixel data start here on disk
  518.                     ; end of TIFF information
  519.  
  520. esctab    db    33            ; table of ESC <char> dispatches
  521.     dw    escjmp            ; address of table for action routines
  522.     db    ENQ,FF,CAN,CTLZ,'/'            ; ^E,^L,^X,^Z,/
  523.     db    '@ABCD','EFGHI','JKLM'
  524.     db    3fh,'PZ[\'                ; '?PZ[\'
  525.     db    60h,'abcde','xyz'            ; accent, a..e,x,y,z
  526.  
  527. ; Dispatch for esctab table
  528.     even
  529. escjmp    dw    tekenq, tekcls,tekcan, tekgin,tekeseq    ; ^E,^L,^X,^Z,/
  530.     dw    14 dup (tekfill)            ; '@ABCDEFGHIJKLM'
  531.     dw    tekqury,tekeseq,sendid,tekeseq,tekgotst ; '?PZ[\'
  532.     dw    9 dup (teklpat)                ; accent, a..e,x,y,z
  533.  
  534. ; Final char table for ANSI escape sequences
  535. anstab    db    21            ; number of entries
  536.     dw    ansjmp            ; address of action routines
  537.     db    '@ABCD','EFGHJ','KXade','fhlmn','u'
  538.  
  539. ; Dispatch for anstab table
  540.     even
  541. ansjmp    dw    ansich, atcuu,   atcud,   atcuf,  atcub        ; '@ABCD'
  542.     dw    atcnl,  atcpl,   atcha,   atcup,  ated        ; 'EFGHJ'
  543.     dw    atel,   atech,   atcuf,   atcva,  atcud        ; 'KXade'
  544.     dw    atcup,  escexit, escexit, tekcol, tekrid    ; 'fhlmn'
  545.     dw    tekprpt                        ; 'u'
  546. data    ends
  547.  
  548. code    segment public 'code'        ; main body code segment
  549.     extrn    outchr:near, beep:near, scrseg:near, cmblnk:near
  550.     extrn    savescr:near, restscr:near, cptchr:near, clrbuf:near
  551.     extrn    iseof:near, atparse:near, unique:near
  552.     extrn    chgdsp:near, pcwait:near, vtrmac:near, vtsmac:near
  553.  
  554.     assume    cs:code, ds:data, es:nothing
  555.  
  556. ; These far routines are called by the Tek emulator; they are here to provide
  557. ; a bridge to the main code segment near procedures.
  558.      
  559. ; Procedures for calling to the main body of MS Kermit. Most are FAR and
  560. ; must be in in code segment named code, not in code2.
  561.  
  562. outmodem proc    far            ; send Tek char out serial port
  563.     push    ax
  564.     mov    ah,al
  565.     call    outchr            ; outchr reads from ah
  566.     pop    ax
  567.     ret
  568. outmodem ENDP
  569.  
  570. tekbeep    proc    far            ; sound a beep from Tek mode
  571.     call    beep
  572.     ret
  573. tekbeep    endp
  574.  
  575. tcmblnk    proc    far            ; blank the screen from Tek mode
  576.     call    cmblnk
  577.     ret
  578. tcmblnk    endp
  579.  
  580. tsavescr proc    far            ; save text screen while in Tek mode
  581.     call    savescr
  582.     ret
  583. tsavescr endp
  584.  
  585. trestscr proc    far            ;restore text screen while in Tek mode
  586.     cmp    low_rgt,80        ; were we in 80 column mode?
  587.     jbe    trestsc1        ; be = yes
  588.     mov    al,1            ; set to 132 columns
  589.     call    chgdsp            ; msyibm routine to change screen
  590. trestsc1:
  591.     call    restscr
  592.     ret
  593. trestscr endp
  594.  
  595. tscrseg    proc    far            ; get video segment while in Tek mode
  596.     call    scrseg
  597.     ret
  598. tscrseg    endp
  599.  
  600. tclrbuf    proc    far            ; clear serial port buf while in Tek
  601.     call    clrbuf            ;  mode
  602.     ret
  603. tclrbuf    endp
  604.  
  605. tcptchr    proc    far            ; call session logger while in Tek
  606.     call    cptchr            ;  mode
  607.     ret
  608. tcptchr    endp
  609.  
  610. tiseof    proc    far            ; call iseof while in Tek mode
  611.     call    iseof
  612.     ret
  613. tiseof    endp
  614.  
  615. tparstart proc    far            ; start escape sequence parser
  616.     mov    parstate,0        ; set to initialize automatically
  617.     mov    pardone,offset tpardone    ; jmp to this when completed
  618.     mov    parfail,0        ; no failure case jump
  619.     ret
  620. tparstart endp
  621.  
  622. tparser    proc    far
  623.     call    atparse            ; reach to real parser
  624.     ret
  625. tparser    endp
  626.  
  627. tpardone proc    near            ; called by real parser
  628.     call    dword ptr doneptr    ; far call xpardone, old MASM way
  629.     ret
  630. tpardone endp
  631.  
  632. tunique    proc    far            ; reach to real unique name procedure
  633.     call    unique            ;  while in Tek mode
  634.     ret
  635. tunique    endp
  636.  
  637. tekwait    proc    far            ; call pcwait while in Tek mode
  638.     call    pcwait
  639.     ret
  640. tekwait    endp
  641.  
  642.  
  643. ; Return screen info for Tek screen report: ax=screen height, bx=width,
  644. ; cx=number of colors (0=none for pure text, 1=b/w, 16=ega)
  645. tekinq    proc    near
  646.     mov    tekident,1        ; say this is an ident request
  647.     call    dword ptr initptr    ; do init steps to get screen sizes
  648.     mov    ax,ybot            ; lowest screen line
  649.     inc    ax            ; screen height, in lines
  650.     mov    bx,xmax
  651.     add    bx,8            ; screen width, in dots
  652.     cmp    graph_mode,mono        ; pure text mono (no graphics at all)?
  653.     jne    tekinq1            ; ne = no
  654.     mov    ax,24            ; bottom screen line
  655.     mov    bx,80            ; screen width
  656.     xor    cx,cx            ; pure mono, say 0 colors
  657.     jmp    short tekinq2
  658. tekinq1:mov    cx,1            ; say b/w screen
  659.     cmp    plotptr,offset pltcga    ; using CGA style graphics?
  660.     je    tekinq2            ; e = yes
  661.     cmp    graph_mode,monoega    ; monochrome monitor on ega?
  662.     je    tekinq2            ; e = yes
  663.     mov    cx,16            ; say 16 colors
  664. tekinq2:mov    tekident,0
  665.     ret
  666. tekinq    endp
  667.  
  668. ; These routines can be called by either the main body or from within Tek
  669. ; mode.
  670. tekdmp    proc    near            ; Tek screen dump routine
  671.     call    dword ptr dumpptr    ; callable from main body
  672.     clc
  673.     ret
  674. tekdmp    endp
  675.  
  676. tekmac    proc    far            ; invoke vtrmac or vtsmac
  677.     or    ax,ax            ; which macro?
  678.     jz    tekmacr            ; z = the R flavor
  679.     call    vtsmac            ; do TerminalS, in msyibm
  680.     ret
  681. tekmacr:call    vtrmac            ; do TerminalR, in msyibm
  682.     ret                ; only if they fail
  683. tekmac    endp
  684.  
  685. tekpal    proc    near            ; do palette report tekrpt
  686.     call    dword ptr rptptr    ; callable from main body
  687.     ret
  688. tekpal    endp
  689. code    ends                ; main body code segment
  690.  
  691. ; Code segment code2 is allocated to Tektronix emulation
  692. code2    segment public 'code2'        ; supplementary code segment
  693.  
  694.     assume    cs:code2, ds:data, es:nothing
  695.  
  696. ; Initialise TEK mode by setting high resolution screen, etc
  697. tekini    proc    far
  698.     push    ax            ; do presence tests
  699.     push    bx
  700.     push    cx
  701.     push    dx
  702.     push    si
  703.     push    di
  704.     push    es
  705.     mov    bx,portval        ; get port flow control chars:
  706.     mov    bx,[bx].flowc        ; bh=xon, bl=xoff or both are nulls
  707.     mov    flow,bx            ; save here
  708.     mov    ax,bx            ; get flow control word
  709.     cmp    al,0            ; able to do xoff?
  710.     je    tekin0            ; e = no
  711.     call    outmodem        ; tell host xoff while we change modes
  712. tekin0:    mov    bx,vtemu.att_ptr    ; emulator screen color ptr
  713.     mov    al,[bx]
  714.     mov    gfcol,al        ; save foreground color
  715.     and    gfcol,0fh        ; save just foreground bits
  716.     and    al,70h            ; select background color, no bold
  717.     mov    cl,4
  718.     shr    al,cl            ; get background colors
  719.     mov    gbcol,al        ; set graphics background color    
  720.     mov    ah,15            ; get current screen mode
  721.     int    screen
  722.     cmp    al,mono            ; mono text mode (7)?
  723.     je    tekin1            ; e = yes
  724.     cmp    tekident,0        ; doing an ident request?
  725.     jne    tekin2            ; ne = yes, don't mess with screen
  726.     test    tekflg,1        ; are we active as Tek device now?
  727.     jz    tekin1            ; z = no
  728.     jmp    tekin13            ; yes, don't redo graphics setup
  729. tekin1:    mov    curmode,al        ; save mode here
  730.     mov    ah,3            ; get cursor position
  731.     xor    bh,bh            ; page 0
  732.     int    screen
  733.     mov    cursor,dx        ; save position
  734.     call    tsavescr        ; save text screen
  735.                     ; Presence tests.
  736. tekin2:    mov    graph_mode,cga        ; Color. Assume CGA
  737.     mov    segscn,segcga        ; assume cga screen segment
  738.     mov    gpage,0            ; graphics page 0 but no page 1
  739.     mov    putc,offset gputc    ; CGA character display routine
  740.     mov    gcplot,offset gcgen    ; General character plot routine
  741.     mov    gfplot,offset bpltcga    ; CGA area fill routine
  742.     mov    psetup,offset psetupc    ; CGA plot setup routine
  743.     mov    plotptr,offset pltcga    ; CGA dot plot routine
  744.     mov    pincy,offset pincyc    ; CGA inc y routine
  745.     mov    xmult,5            ; CGA. Scale TEK to PC by 640/1024
  746.     mov    xdiv,8            ;  so that 0-1023 converts to 0-639
  747.     mov    xmax,640-8        ; x-coord of rightmost character
  748.     mov    ymult,10        ; vertical scale for IBM is 200/780
  749.     mov    ydiv,39            ;
  750.     mov    ybot,199        ; Bottom of screen is Y=199
  751.     mov    al,tekgraf        ; user video board specification
  752.     cmp    al,0            ; auto-sensing?
  753.     jne    tekin2d            ; ne = no
  754.     jmp    tekin2c            ; yes (default)
  755. tekin2d:cmp    al,1            ; user wants CGA?
  756.     jne    tekin2a            ; ne = no
  757.     call    crossini        ; preset crosshairs for new screen
  758.     jmp    tekin13            ; do CGA
  759. tekin2a:cmp    al,4            ; user wants Hercules?
  760.     jne    tekin2b            ; ne = no
  761.     jmp    tekin8            ; do Hercules
  762. tekin2b:cmp    al,5            ; user wants AT&T style?
  763.     jne    tekinwy            ; ne = no
  764.     jmp    tekin7            ; do AT&T kind
  765.                     ; Wyse-700
  766. tekinwy:cmp    al,8            ; user wants Wyse-700 1024*780 ?
  767.     jne    tekinw0            ; ne = no
  768.     call    chkwyse            ; presence test
  769.     jc    tekinwf            ; c = failed
  770.     mov    xmax,1024-8        ; x-coord of rightmost character
  771.     mov    ybot,779        ; Bottom of screen is Y=780
  772.     mov    xmult,1            ; Wyse. Scale TEK to PC by 1024/1024
  773.     mov    xdiv,1            ;  so that 0-1023 converts to 0-1023
  774.     mov    ymult,1            ; vertical scale is 780/780
  775.     mov    ydiv,1            ;
  776.     jmp    short tekinw2        ;
  777. tekinw0:cmp    al,7            ; user wants Wyse-700 1280*780 ?
  778.     jne    tekinw1            ; ne = no
  779.     call    chkwyse            ; presence test
  780.     jc    tekinwf            ; c = failed
  781.     mov    xmax,1280-8        ; x-coord of rightmost character
  782.     mov    ybot,779        ; Bottom of screen is Y=800
  783.     mov    xmult,10        ; Wyse. Scale TEK to PC by 1280/1024
  784.     mov    xdiv,8            ;  so that 0-1023 converts to 0-1279
  785.     mov    ymult,1            ; vertical scale is 780/780
  786.     mov    ydiv,1            ;
  787.     jmp    short tekinw2        ;
  788. tekinwf:jmp    tekin2c            ; failure jump point
  789. tekinw1:cmp    al,6            ; user wants Wyse-700 1280*800 ?
  790.     jne    tekin2c            ; no = no
  791.     call    chkwyse            ; presence test
  792.     jc    tekinwf            ; c = failed
  793.     mov    xmax,1280-8        ; x-coord of rightmost character
  794.     mov    ybot,799        ; Bottom of screen is Y=800
  795.     mov    xmult,10        ; Wyse. Scale TEK to PC by 1280/1024
  796.     mov    xdiv,8            ;  so that 0-1023 converts to 0-1279
  797.     mov    ymult,40        ; vertical scale for IBM is 800/780
  798.     mov    ydiv,39            ;  so scale those 20 pixels more
  799. tekinw2:mov    graph_mode,wyse700    ; Assume Wyse Graphics
  800.     mov    segscn,segwyse        ; assume wyse screen segment
  801.     mov    gpage,0            ; only one graphics page 0
  802.     mov    putc,offset gputc    ; CGA character display routine
  803.     mov    gcplot,offset gcgen    ; CGA character plot routine
  804.     mov    psetup,offset psetupw    ; Wyse plot setup routine
  805.     mov    plotptr,offset pltcga    ; CGA dot plot routine
  806.     mov    pincy,offset pincyw    ; Wyse inc y routine
  807.     jmp    tekin13            ; do Wyse
  808.                     ; do auto-sensing of display board
  809.                     ; test for EGA
  810. tekin2c:mov    ax,1200H        ; EGA: Bios alternate select
  811.     mov    bl,10H                  ; Ask for EGA info
  812.     mov    bh,0ffH            ; Bad info, for testing
  813.     mov    cl,0fH            ; Reserved switch settings
  814.     int    screen            ; EGA, are you there?
  815.     and    cl,0fh            ; four lower switches
  816.     cmp    cl,0cH            ; Test reserved switch settings
  817.     jb    tekin3            ; b = ega present
  818.     jmp    tekin7            ; else no EGA, check other adapters
  819.  
  820. tekin3:    mov    ax,40h            ; check Bios 40:87h for ega being
  821.     mov    es,ax            ;  the active display adapter
  822.     test    byte ptr es:[87h],8    ; is ega active?
  823.     jz    tekin3a            ; z = yes
  824.     jmp    tekin7            ; ega is inactive, check others
  825. tekin3a:cmp    bl,1            ; is there 128KB on ega board?
  826.     jb    tekin4            ; b = less, so no screen saves
  827.     mov    gpage,1            ; >=128 KB, use two graphics pages
  828. tekin4:    mov    graph_mode,ega        ; assume high resolution color
  829.     cmp    cl,3            ; high resolution color?
  830.     je    tekin5            ; e = yes
  831.     cmp    cl,9            ; high resolution color?
  832.     je    tekin5            ; e = yes
  833.     mov    graph_mode,monoega    ; assume mono monitor on ega board
  834.     test    bh,1            ; ega mono mode in effect?
  835.      jnz    tekin5            ; nz = yes
  836.     mov    graph_mode,colorega    ; say ordinary cga on ega board, 64KB
  837.     mov    gpage,1            ; is enough memory with 200 scan lines
  838.     jmp    short tekin5a        ; use current cga parameters
  839. tekin5:    mov    ybot,349        ; text screen bottom is 349 on EGA
  840.     mov    ymult,35        ;
  841.     mov    ydiv,78            ; scale y by 350/780
  842. tekin5a:mov    segscn,segega        ; use ega screen segment
  843.     mov    psetup,offset psetupe    ; plot setup routine
  844.     mov    plotptr,offset pltega    ; ega dot plot routine
  845.     mov    gfplot,offset bpltega    ; ega area fill routine
  846.     mov    pincy,offset pincye    ; inc y routine
  847.     mov    putc,offset gputc    ; character display routine
  848.     mov    gcplot,offset gcega    ; EGA character plot routine
  849.     call    crossini        ; preset crosshairs for new screen
  850.     jmp    tekin13            ; end of EGA part, do VGA tests below
  851.  
  852. tekin7:    mov    ax,0fc00h        ; Olivetti/AT&T 6300, check rom id
  853.     mov    es,ax
  854.     mov    di,0            ; start here
  855.     mov    graph_mode,olivetti    ; Olivetti
  856.     mov    cx,attllen        ; length of logo
  857.     mov    si,offset ATTLOGO    ; master string
  858.     repe    cmpsb            ; do a match
  859.     je    tekin7c            ; e = a match
  860.     mov    di,0050h        ; look here too
  861.     mov    si,offset ATTLOGO
  862.     mov    cx,attllen
  863.     repe    cmpsb
  864.     je    tekin7c            ; e = a match
  865.     mov    di,2014h        ; and look here
  866.     mov    si,offset ATTLOGO
  867.     mov    cx,attllen
  868.     repe    cmpsb            ; do a match
  869.     je    tekin7c            ; e = a match, else try other types
  870. tekin7a:mov    graph_mode,toshiba
  871.     mov    ax,0f000h        ; Check for Toshiba T3100, rom scan
  872.     mov    es,ax
  873.     mov    di,0014h        ; start here
  874.     mov    si,offset TOSHLOGO    ; master string
  875.     mov    cx,toshlen        ; length
  876.     repe    cmpsb            ; do a match
  877.     je    tekin7c            ; e = a match, else try other types
  878. tekin7b:mov    graph_mode,vaxmate    ; DEC VAXmate II
  879.     mov    ax,0f000h        ; Check for VAXmate II rom signature
  880.     mov    es,ax
  881.     mov    di,0e000h        ; start here
  882.     mov    si,offset DECLOGO    ; master string
  883.     mov    cx,declen        ; length
  884.     repe    cmpsb            ; do a match
  885.     jne    tekin7d            ; ne = mismatch, try other types
  886.  
  887.                     ; Olivetti/AT&T, Toshiba, VAXmate
  888. tekin7c:mov    gpage,0            ; only page 0 with 640 by 400 mode
  889.     mov    segscn,segcga        ; use cga screen segment (0b800h)
  890.     mov    psetup,offset psetupo    ; plot setup routine
  891.     mov    plotptr,offset pltcga    ; cga dot plot routine
  892.     mov    gfplot,offset bpltcga    ; area fill plot routine
  893.     mov    pincy,offset pincyh    ; inc y routine (Herc style addresses)
  894.     mov    putc,offset gputc    ; character display routine
  895.     mov    gcplot,offset gcgen    ; General character plot routine
  896.     mov    ybot,399        ; bottom of screen is y = 399
  897.     mov    ymult,20        ; vertical scale = 400/780
  898.     mov    ydiv,39            ; same as cga setup
  899.     call    crossini        ; preset crosshairs for new screen
  900.     jmp    tekin13
  901.  
  902. tekin7d:cmp    curmode,mono        ; mono text mode?
  903.     je    tekin8            ; e = yes
  904.     jmp    tekin11            ; ne = no, try cga
  905.                     ; test for Hercules
  906. tekin8:    call    tscrseg            ; get screen segment, test Environment
  907.     cmp    tv_mode,0        ; Environment active?
  908.     je    tekin8a            ; e = no, ok to test for Hercules
  909.     jmp    tekin10            ; don't do Herc mode, do Mono
  910. tekin8a:mov    dx,hstatus        ; Herc status port
  911.     in    al,dx            ; read it
  912.     mov    bl,al            ; save here
  913.     and    bl,80h            ; remember retrace bit
  914.     mov    cx,0ffffh        ; do many times (for fast machines)
  915. tekin8b:mov    dx,hstatus        ; check status port
  916.     in    al,dx
  917.     and    al,80h            ; select bit
  918.     jmp    $+2            ; use a little time
  919.     cmp    bl,al            ; did it change?
  920.     loope    tekin8b            ; test again if not
  921.     je    tekin10            ; e = no change in bit, not Herc
  922.     mov    graph_mode,hercules    ; say have Herc board
  923.     mov    segscn,seghga        ; assume hga screen segment
  924.     mov    putc,offset gputc    ; character display routine
  925.     mov    gcplot,offset gcgen    ; general character plot routine
  926.     mov    gfplot,offset bpltcga    ; area fill plot routine
  927.     mov    psetup,offset psetuph    ; plot setup routine to use
  928.     mov    plotptr,offset pltcga    ; use cga dot plot routine for Herc
  929.     mov    pincy,offset pincyh    ; inc y routine
  930.     mov    xmult,45        ; Scale TEK to Hercules by 720/1024
  931.     mov    xdiv,64            ;  so that 0-1023 converts to 0-719
  932.     mov    xmax,720-8        ; x-coord of rightmost character
  933.     mov    ymult,87        ; vertical scale for Hercules is
  934.     mov    ydiv,195        ;  348/780
  935.     mov    ybot,347        ; bottom of screen is y = 347
  936.     mov    ax,seghga        ; segment of Herc video display
  937.     mov    es,ax
  938.     mov    al,es:[8000h]        ; read original contents, page 1
  939.     not    byte ptr es:[8000h]    ; write new pattern
  940.     mov    ah,es:[8000h]        ; read back
  941.     not    byte ptr es:[8000h]    ; restore original contents
  942.     not    ah            ; invert this too
  943.     cmp    ah,al            ; same (memory present?)
  944.     jne    tekin9            ; ne = not same, no memory there
  945.     mov    gpage,1            ; say two pages of display memory
  946. tekin9:    call    crossini        ; preset crosshairs
  947.     jmp    tekin13
  948.                     ; set to MONO
  949. tekin10:mov    graph_mode,mono        ; force monochrome adapter text
  950.     mov    segscn,segmono        ; assume mono screen segment
  951.     call    tscrseg            ; Environments: get virtual screen
  952.     mov    segscn,ax        ;  seg returned in ax and es:di
  953.     mov    gpage,0
  954.     mov    putc,offset mputc    ; character display routine
  955.     mov    psetup,offset psetupm    ; plot setup routine to use
  956.     mov    gfplot,offset bpltmon    ; area fill plot routine
  957.     mov    plotptr,offset pltmon    ; use hga dot plot routine
  958.     mov    pincy,offset pincym    ; inc y routine
  959.     mov    xmult,5            ; Scale TEK to mono by 640/1024
  960.     mov    xdiv,8            ;  so that 0-1023 converts to 0-639
  961.     mov    xmax,640-8        ; x-coord of rightmost character
  962.     mov    ymult,10        ; vertical scale for mono is 200/780
  963.     mov    ydiv,39
  964.     mov    ybot,200        ; bottom of screen is y = 200 for Bios
  965.     call    crossini        ; preset crosshairs for new screen
  966.     jmp    tekin13            ; Uses TEXT mode, for safety
  967.  
  968.                     ; test for CGA
  969. tekin11:mov    graph_mode,cga        ; set CGA high resolution graphics
  970.     mov    segscn,segcga        ; CGA screen segment
  971.     call    crossini        ; preset crosshairs for new screen
  972.     jmp    tekin13
  973.  
  974.                     ; Set Graphics mode
  975. tekin13:cmp    graph_mode,wyse700    ; Wyse ?
  976.     jne    tekin13a        ; ne = no
  977.     call    wygraf            ; set Wyse graphics mode, clear regen
  978.     jmp    short tekin16        ; restore screen
  979. tekin13a:cmp    graph_mode,hercules    ; Hercules?
  980.     jne    tekin14            ; ne = no
  981.     cmp    tekident,0        ; just identifying?
  982.     jne    tekin16            ; ne = yes
  983.     call    hgraf            ; set Herc graphics mode, clear regen
  984.     or    tekflg,1        ; say doing Tekmode
  985.     jmp    short tekin16        ; restore screen
  986. tekin14:mov    ah,0            ; set screen mode
  987.     mov    al,graph_mode        ;  to this screen mode
  988.     cmp    tekgraf,3        ; user wants "VGA" modes (640x480)?
  989.     jne    tekin14a        ; ne = no
  990.     cmp    al,monoega        ; yes, allow high resolution stuff?
  991.     jb    tekin14a        ; b = no
  992.     cmp    al,ega            ; ditto
  993.     ja    tekin14a        ; a = no
  994.     add    al,2            ; use modes 17(b/w) and 18(10)(color)
  995.     mov    ybot,479        ; text screen bottom is 479 on VGA
  996.     mov    ymult,48
  997. tekin14a:cmp    tekident,0        ; just identifying screen size etc?
  998.     jne    tekin16            ; ne = yes, do not invoke graphics
  999.     cmp    gpage,0            ; only page 0 available?
  1000.     je    tekin15            ; e = yes, and watch for Bios errors
  1001.     cmp    inited,0        ; first time through?
  1002.     je    tekin15            ; e = yes, clear the page of old junk
  1003.     or    al,80h            ; save regen buffer (save area too)
  1004. tekin15:int    screen            ; Bios Set Mode.
  1005.     or    tekflg,1        ; say doing Tekmode
  1006.  
  1007. tekin16:cmp    tekident,0        ; just identifying?
  1008.     jne    tekin16a        ; ne = yes
  1009.     cmp    inited,0        ; inited yet?
  1010.     jne    tekin19            ; ne = yes, restore screen
  1011.     mov    ttstate,offset tektxt    ; do displayable text
  1012.     mov    prestate,offset tektxt    ; set a previous state of text
  1013.     mov    inited,1        ; say we have initialized
  1014. tekin16a:mov    si,offset mondef    ; default monochrome colors
  1015.     cmp    plotptr,offset pltcga    ; using CGA style graphics?
  1016.     je    tekin17            ; e = yes
  1017.     cmp    graph_mode,mono        ; pure mono text system?
  1018.     je    tekin17            ; e = yes
  1019.     cmp    graph_mode,monoega    ; ega, but monochrome?
  1020.     je    tekin17            ; e = no
  1021.     mov    si,offset coldef    ; use color palette
  1022. tekin17:mov    al,[si+7]        ; foreground color = palette 7
  1023.     mov    gfcol,al
  1024.     mov    al,[si]            ; background color = palette 0
  1025.     mov    gbcol,al
  1026.     mov    cx,16
  1027.     mov    di,offset colpal    ; VT340 active color palette
  1028.     push    es
  1029.     push    ds
  1030.     pop    es
  1031.     cld
  1032.     rep    movsb            ; reinit palette entries
  1033.     pop    es
  1034.     call    fixcolor        ; correct color mapping for some bds
  1035.     mov    al,gfcol
  1036.     mov    tfcol,al        ; remember current coloring
  1037.     mov    al,gbcol
  1038.     mov    tbcol,al
  1039.     cmp    tekident,0        ; just identifying?
  1040.     jne    tekin20            ; ne = yes
  1041.     call    tekcls            ; clear screen, for ega coloring
  1042.     jmp    short tekin20
  1043. tekin19:call    tekrest            ; restore old graphics screen
  1044.     mov    al,tfcol        ; and coloring
  1045.     mov    gfcol,al
  1046.     mov    al,tbcol
  1047.     mov    gbcol,al
  1048. tekin20:mov    ax,250
  1049.     call    tekwait            ; 250 ms wait for display adapter
  1050.     mov    ax,flow            ; get flow control word
  1051.     xchg    ah,al            ; get xon into al
  1052.     cmp    al,0            ; able to send xon?
  1053.     je    tekin21            ; e = no
  1054.     call    outmodem        ; tell host xon
  1055. tekin21:mov    al,chcontrol        ; opaque/transparent char writing
  1056.     mov    bscontrol,al        ; set destructive BS control
  1057.     mov    spcontrol,al        ; set destructive SPACE control
  1058.     mov    tekident,0
  1059.     clc                ; clear carry for success
  1060.     pop    es
  1061.     pop    di
  1062.     pop    si
  1063.     pop    dx
  1064.     pop    cx
  1065.     pop    bx
  1066.     pop    ax
  1067.     ret
  1068. tekini    endp
  1069.  
  1070. TEKRINT proc    far            ; Tek reinitialization entry point
  1071.     call    dword ptr endptr    ; exit cleanly if alread in Tek mode
  1072.     mov    inited,0        ; do complete reinitialization
  1073.     mov    tekflg,0
  1074.     call    tekini
  1075.     ret
  1076. TEKRINT    endp
  1077.  
  1078. ; End TEK emulation, recover previous screen
  1079. TEKEND    proc    far
  1080.     mov    ttstate,offset tektxt    ; set an initial state
  1081.     mov    prestate,offset tektxt    ; and a previous state
  1082.     test    tekflg,1        ; running as a Tek terminal now?
  1083.     jnz    teknd1            ; nz = yes
  1084.     mov    tekflg,0        ; returning to text emulator
  1085.     ret                ; else return as is
  1086. teknd1:    call    teksave            ; save graphics screen to page 1
  1087.     cmp    graph_mode,hercules    ; Hercules?
  1088.     jne    teknd2            ; ne = no
  1089.     call    htext            ; yes then set up Hercules text mode
  1090. teknd2:    mov    ah,0            ; set video mode
  1091.     mov    al,curmode        ; restore previous screen mode
  1092.     int    screen            ; revert to text screen
  1093.     call    trestscr        ; restore text screen
  1094.     mov    dx,cursor        ; saved cursor position
  1095.     mov    bh,0            ; page 0
  1096.     mov    ah,2            ; set cursor
  1097.     int    screen
  1098.     mov    tekflg,0        ; returning to text emulator
  1099.     mov    lastc,0
  1100.     mov    bypass,0        ; reset bypass condition
  1101.     mov    visible,0        ; next move is invisible
  1102.     clc
  1103.     ret
  1104. TEKEND    ENDP
  1105.  
  1106.  
  1107. ;Terminal emulation. Enter with received character in AL.
  1108. TEKEMU    proc    far            ; main emulator
  1109.     call    tektt            ; local emulator routine
  1110.     ret
  1111. TEKEMU    endp
  1112.  
  1113. tektt    proc    near
  1114.     test    tekflg,1        ; running as a Tek device?
  1115.     jnz    tektt1            ; nz = yes
  1116.     push    ax
  1117.     call    tekini            ; init now
  1118.     pop    ax
  1119.     mov    ttstate,offset tektxt    ; initial state
  1120.     mov    prestate,offset tektxt    ; set a previous state of text
  1121.     jnc    tektt1            ; nc = succeeded
  1122.     ret                ; else failed to init, just return
  1123. tektt1:    test    al,80h            ; high bit set?
  1124.     jz    tektt1a            ; z = no
  1125.     cmp    al,9fh            ; in range for C1 controls?
  1126.     ja    tektt1a            ; a = no
  1127.     push    ax            ; save the char
  1128.     mov    al,escape        ; make 7-bit control version
  1129.     call    tektt2            ; act on escape
  1130.     pop    ax
  1131.     sub    al,40h            ; get second char of 7-bit control
  1132.  
  1133. tektt1a:and    al,7fh            ; force Tek chars to be 7 bits
  1134.     or    al,al            ; NUL char?
  1135.     jnz    tektt2            ; nz = no
  1136.     ret                ; yes, ignore it (before logging)
  1137. tektt2:    test    yflags,capt        ; capturing output?
  1138.     jz    tektt4            ; z = no, forget this part
  1139.     push    ax            ; save char
  1140.     call    tcptchr            ; give it captured character
  1141.     pop    ax            ; restore character and keep going
  1142. tektt4:    test    yflags,trnctl        ; debug? if so use tty mode
  1143.     jz    tektt5            ; z = no
  1144.     cmp    al,DEL            ; DEL char?
  1145.     jne    tektt4a            ; ne = no
  1146.     mov    al,5eh            ; make DEL a caret query mark
  1147.     call    outscrn
  1148.     mov    al,3fh            ; the query mark
  1149.     call    outscrn
  1150.     ret
  1151. tektt4a:cmp    al,' '            ; control char?
  1152.     jae    tektt4b            ; ne = no
  1153.     push    ax
  1154.     mov    al,5eh            ; caret
  1155.     call    outscrn
  1156.     pop    ax
  1157.     add    al,'A'-1        ; make char printable
  1158. tektt4b:call    outscrn
  1159.     ret
  1160.  
  1161. tektt5:    call    ttstate            ; do current state
  1162.     ret
  1163. tektt    endp
  1164.      
  1165. TEKTXT    proc    near            ; Dispatch on text characters
  1166.     mov    ttstate,offset tektxt    ; this is our state
  1167.     cmp    al,DEL            ; RUBOUT?
  1168.     jne    tektx1            ; ne = no
  1169.     mov    al,bs            ; make BS
  1170.     jmp    short tektx7
  1171. tektx1:    cmp    al,CR            ; carriage return (^M)?
  1172.     je    tektx9            ; e = yes
  1173.     cmp    al,LF            ; line feed (^J)?
  1174.     je    tektx9            ; e = yes
  1175.     cmp    al,FF            ; form feed (^L)?
  1176.     jne    tektx4            ; ne = no
  1177.     call    tekcls            ; clear the screen
  1178.     ret
  1179. tektx4:    cmp    al,VT            ; vertical tab (^K)?
  1180.     je    tektx7
  1181.     cmp    al,bell            ; bell (^G)?
  1182.     jne    tektx5            ; ne = no
  1183.     call    tekbeep
  1184.     mov    bypass,0        ; clear GIN mode bypass condition
  1185.     ret
  1186. tektx5:    cmp    al,tab            ; horizontal tab (^I)?
  1187.     je    tektx7            ; e = yes
  1188.     cmp    al,BS            ; backspace (^H)?
  1189.     je    tektx7            ; e = yes
  1190.     cmp    al,' '            ; control char?
  1191.     jae    tektx7            ; ae = no
  1192.     jmp    tekctl            ; process control char
  1193. tektx7:    cmp    bypass,0        ; bypass mode off?
  1194.     jne    tektx8            ; ne = no, it's on so skip display
  1195.     call    outscrn            ; output character to the screen
  1196. tektx8:    ret
  1197. tektx9:    mov    bypass,0        ; clear GIN mode bypass condition
  1198.     jmp    short tektx7
  1199. TEKTXT    endp
  1200.  
  1201.  
  1202. tekctl    proc    near            ; Control characters:
  1203.     cmp    al,GS            ; Line plot command?
  1204.     jne    tekctl1            ; ne = no
  1205.     mov    visible,0        ; next move is invisible
  1206.     and    status,not txtmode    ; set status report byte
  1207.     mov    ttstate,offset tekline    ; expect coordinates next
  1208.     jmp    tekctl7
  1209. tekctl1:cmp    al,RS            ; Incremental dot command?
  1210.     jne    tekctl2            ; ne = no
  1211.     and    status,not txtmode    ; set status report
  1212.     mov    ttstate,offset tekrlin    ; expect pen command next
  1213.     jmp    tekctl7
  1214. tekctl2:cmp    al,FS            ; Point plot command?
  1215.     jne    tekctl3            ; ne = no
  1216.     mov    visible,0        ; next move is invisible
  1217.     and    status,not txtmode    ; set status report byte
  1218.     mov    ttstate,offset tekpnt
  1219.     jmp    tekctl7
  1220. tekctl3:cmp    al,US            ; assert text mode? [bjh]
  1221.     jne    tekctl4            ; ne = no
  1222.     or    status,txtmode        ; set status report byte
  1223.     mov    ttstate,offset tektxt    ; go to TEKTXT next time
  1224.     mov    bypass,0        ; reset bypass condition
  1225.     mov    visible,0        ; next move is invisible
  1226.     jmp    tekctl7
  1227. tekctl4:cmp    al,ESCAPE        ; Escape?
  1228.     jne    tekctl5            ; ne = no
  1229.     or    status,txtmode        ; set status report byte
  1230.     cmp    ttstate,offset tekesc    ; already in escape state?
  1231.     je    tekctl7            ; e = yes, nest no further
  1232.     push    ttstate            ; current state
  1233.     pop    prestate        ; save here as previous state
  1234.     mov    ttstate,offset tekesc    ; next state parses escapes
  1235.     ret
  1236.  
  1237. tekctl5:cmp    al,CAN            ; Control X? (exits Tek sub mode)
  1238.     jne    tekctl7            ; ne = no, stay in current state
  1239.     mov    ttstate,offset tektxt    ; back to text mode
  1240.     cmp    flags.vtflg,tttek    ; main Tek emulator?
  1241.     je    tekctl6            ; e = yes, ignore the ^X
  1242.     call    tekend            ; else exit sub mode
  1243.     mov    visible,0        ; next move is invisible
  1244. tekctl6:mov    prestate,offset tektxt    ; make previous state text
  1245. tekctl7:ret
  1246. tekctl    endp
  1247.  
  1248. TEKESC    proc    near            ; Process ESC <following text>
  1249.     mov    bypass,0        ; clear GIN mode bypass condition
  1250.     mov    ttstate,offset tekesc    ; in case get here from msz file
  1251.     cmp    inited,0        ; inited yet? (msz call)
  1252.     jne    tekesc1            ; ne = yes
  1253.     call    tekini            ; init now
  1254.     mov    prestate,offset tektxt    ; set a previous state of text
  1255.     jnc    tekesc1            ; nc = succeeded
  1256.     ret                ; else failed to init, just return
  1257.     
  1258. tekesc1:cmp    al,20h            ; in intermediates, column 2?
  1259.     jb    tekesc3            ; b = no
  1260.     cmp    al,2fh
  1261.     ja    tekesc3            ; a = no
  1262.     mov    ttstate,offset tekesc1    ; stay in this state while intermeds
  1263.     mov    bx,ninter        ; number of intermediates
  1264.     cmp    bx,maxinter        ; done enough already?
  1265.     jae    tekesc2            ; ae = yes, ignore the excess
  1266.     mov    inter[bx],al        ; store this one
  1267.     inc    ninter            ; one more
  1268.     cmp    inter,'/'        ; HDS2000/3000 Final char?
  1269.     je    tekesc3            ; e = yes, process specially like '['
  1270. tekesc2:ret                ; get more input
  1271.     
  1272.                     ; Final char is in AL, dispatch on it
  1273. tekesc3:mov    ttstate,offset tektxt    ; set new state
  1274.     mov    esctype,al        ; save kind of escape sequence
  1275.     mov    bx,offset esctab    ; ESC dispatch table
  1276.     call    atdispat        ; dispatch on AL
  1277.     ret
  1278. TEKESC    endp    
  1279.  
  1280. tekeseq    proc    near            ; process Escape and Device Contrl seq
  1281.     call    tparstart        ; init escape sequence parser
  1282.     mov    ttstate,offset escparse    ; do parsing next
  1283.     ret
  1284. tekeseq    endp
  1285.  
  1286. ; State for gathering text to feed escape sequence parser
  1287. escparse proc    near
  1288.     cmp    al,' '            ; embedded control code?
  1289.     jb    escpar2            ; b = yes, process now
  1290.     call    tparser            ; far call, to call real parser
  1291.     jnc    escpar1            ; nc = success
  1292.     push    prestate        ; recover previous state
  1293.     pop    ttstate
  1294.     stc
  1295. escpar1:ret
  1296. escpar2:call    tekctl            ; process embedded control code
  1297.     push    prestate        ; get previous state
  1298.     pop    ttstate            ; restore it
  1299.     ret
  1300. escparse endp
  1301.  
  1302. ; Escape sequence parser completion routine
  1303. ; AL has Final character of escape sequence
  1304. XPARDONE PROC    FAR            ; called by tpardone when done
  1305.     cmp    esctype,'['        ; ansi escape sequence (ESC [)?
  1306.     jne    xpardo3            ; ne = no
  1307.     mov    bx,offset anstab    ; ANSI ESC [ table
  1308.     call    atdispat        ; dispatch on Final char in AL
  1309.     jmp    short xpardo5
  1310.  
  1311. xpardo3:cmp    esctype,'/'        ; HDS escape sequence (ESC /)?
  1312.     jne    xpardo4            ; ne = no
  1313.     call    hdsesc            ; analyze
  1314.     jmp    short xpardo5
  1315.  
  1316. xpardo4:cmp    esctype,'P'        ; DCS introducer?
  1317.     jne    xpardo5            ; ne = no
  1318.     call    tekdcs            ; grab parameters etc, prep strings
  1319.     ret
  1320.  
  1321. xpardo5:push    prestate        ; recover previous state
  1322.     pop    ttstate
  1323.     ret
  1324. XPARDONE ENDP
  1325.                 ; ESC <char> action routines
  1326.                 ; exit each by putting prestate into ttstate
  1327.  
  1328. tekenq    proc    near            ; ESC-^E Enquiry for cursor position
  1329.     mov    bypass,1        ; set bypass mode
  1330.     call    sendstat        ; send status
  1331.     push    prestate        ; get previous state
  1332.     pop    ttstate            ; restore it
  1333.     ret
  1334. tekenq    endp
  1335.  
  1336. tekcan    proc    near            ; ESC ^X
  1337.     push    prestate        ; get previous state
  1338.     pop    ttstate            ; restore it
  1339.     jmp    tekctl            ; process in controls section
  1340. tekcan    endp
  1341.  
  1342. tekgin    proc    near            ; ESC-^Z Enter GIN mode
  1343.     cmp    graph_mode,mono        ; Monochrome text mode?
  1344.     je    tekgin1            ; e = yes, no crosshairs in text mode
  1345.     mov    bypass,1        ; turn on GIN mode bypass conditon
  1346.     call    croshair        ; activate the cross-hairs
  1347.     jmp    short tekgin2
  1348. tekgin1:call    tekbeep            ; tell the user we are unhappy
  1349. tekgin2:push    prestate        ; get previous state
  1350.     pop    ttstate            ; restore it
  1351.     ret
  1352. tekgin    endp
  1353.  
  1354. tekqury    proc    near            ; query mark (ESC ? means DEL)
  1355.     mov    al,DEL            ; replace with DEL code
  1356.     push    prestate        ; get previous state
  1357.     pop    ttstate            ; restore it
  1358.     ret
  1359. tekqury    endp
  1360.  
  1361. tekfill    proc    near            ; Fill series ESC @ .. ESC M
  1362.     sub    al,'@'            ; remove bias
  1363.     mov    bl,al
  1364.     xor    bh,bh
  1365.     shl    bx,1            ; make a word index
  1366.     mov    bx,fillist[bx]        ; get pointer to the pattern from list
  1367.     mov    fillptr,bx        ; assign this pattern pointer
  1368.     push    prestate        ; get previous state
  1369.     pop    ttstate            ; restore it
  1370.     ret
  1371. tekfill    endp
  1372.  
  1373. teklpat    proc    near            ; ESC accent grave line pattern series
  1374.     cmp    al,'e'            ; accent ... lowercase e?
  1375.     jbe    teklpa1            ; be = yes
  1376.     sub    al,'x'-'f'        ; user sets,map x to f, y to g, z to h
  1377. teklpa1:push    bx
  1378.     mov    bl,al
  1379.     sub    bl,accent        ; remove bias
  1380.     cmp    bl,8            ; nine patterns, ignore others
  1381.     ja    teklpa2            ; a = illegal
  1382.     xor    bh,bh
  1383.     shl    bx,1            ; make this a word index
  1384.     mov    bx,linetab[bx]        ; get line pattern word
  1385.     mov    linepat,bx        ; save in active word
  1386. teklpa2:pop    bx            ; return to previous mode
  1387.     push    prestate        ; get previous state
  1388.     pop    ttstate            ; restore it
  1389.     ret
  1390. teklpat    endp
  1391.  
  1392. ; Detect exit Tek submode command ESC [ ? 38 l  from VT340's
  1393. escexit    proc    near
  1394.     cmp    lparam,'?'        ; possible "ESC [ ? 38 l"?
  1395.     jne    escex2            ; ne = no
  1396.     cmp    nparam,1        ; just one numeric parameter?
  1397.     jne    escex2            ; ne = no
  1398.     cmp    al,'l'            ; ESC [ ? Pn l?
  1399.     jne    escex4            ; ne = no, try 'h'
  1400.     cmp    param,38        ; correct value?
  1401.     jne    escex3            ; ne = no
  1402.     cmp    flags.vtflg,tttek    ; are we a full Tek terminal now?
  1403.     je    escex1            ; e = yes, stay that way
  1404.     call    dword ptr endptr    ; call far tekend
  1405.     ret
  1406. escex1:    mov    ttstate,offset tektxt
  1407.     mov    al,CAN            ; simulate arrival of Control-X
  1408.     jmp    tektxt            ; process char as text
  1409. escex2:    ret
  1410. escex3:    cmp    param,34        ; ESC [ ? 34 l?
  1411.     jne    escex2            ; ne = no
  1412.     call    tekend            ; play save and restore text mode
  1413.     xor    ax,ax            ; tell tekmac it's a Reset flavor
  1414.     call    tekmac            ; returns only if successful
  1415.     ret
  1416. escex4:    cmp    al,'h'            ; ESC ... l?
  1417.     jne    escex3            ; ne = no
  1418.     cmp    param,34        ; ESC [ ? 34 h?
  1419.     jne    escex2            ; ne = no
  1420.     call    tekend            ; play save and restore text mode
  1421.     mov    ax,1            ; tell tekmac it's a Set flavor
  1422.     call    tekmac            ; returns only if successful
  1423.     ret
  1424. escexit    endp
  1425.  
  1426. ; Human Data Systems 2000 style escape sequences (ESC / params Final)
  1427. hdsesc    proc    near
  1428.     cmp    al,'x'            ; draw an empty rectangle?
  1429.     jne    hdsesc0            ; ne = no
  1430.     call    rectdraw
  1431.     jmp    short hdsesc2a
  1432. hdsesc0:cmp    al,'y'            ; draw a filled rectangle?
  1433.     jne    hdsesc1            ; ne = no
  1434.     call    rectfil            ;do xhome,yhome,xwidth,yheight,pattern
  1435.     jmp    short hdsesc2a
  1436. hdsesc1:cmp    al,'z'            ; draw and fill rectangle?
  1437.     jne    hdsesc2            ; ne = no
  1438.     call    rectfil            ; do fill before border
  1439.     call    rectdraw        ; do border
  1440.     jmp    short hdsesc2a
  1441. hdsesc2:cmp    ninter,0        ; any intermediates?
  1442.     jne    hdsesc2a        ; ne = yes, failure
  1443.     cmp    lparam,0        ; letter parameter?
  1444.     jne    hdsesc2a        ; ne = yes, failure
  1445.     cmp    nparam,1        ; just zero or one numeric parameter?
  1446.     ja    hdsesc9            ; a = no
  1447.     cmp    al,'a'            ; user defined pattern?
  1448.     jb    hdsesc3            ; b = no
  1449.     cmp    al,'c'
  1450.     ja    hdsesc3            ; a = no
  1451.     sub    al,'a'            ; 'a' is first of three user patterns
  1452.     xor    ah,ah            ;  store as 'f,g,h' in the series
  1453.     mov    bx,ax
  1454.     shl    bx,1            ; make a word index
  1455.     mov    ax,param[0]        ; get the 16-bit pattern
  1456.     mov    linetab[bx+12],ax    ; store in user defined pattern
  1457. hdsesc2a:push    prestate        ; get previous state
  1458.     pop    ttstate            ; restore it
  1459.     ret
  1460.  
  1461. hdsesc3:cmp    al,'d'            ; "Data Level" (pixel ops)?
  1462.     jne    hdsesc4            ; ne = no
  1463.     mov    cx,param        ; get the parameter value
  1464.     mov    al,pixfor        ; assume foreground only ESC / 0 d
  1465.     cmp    cl,1            ; something else?
  1466.     jb    hdsesc3a        ; b = no
  1467.     mov    al,pixbak        ; assume background only ESC / 1 d
  1468.     cmp    cl,2            ; something else?
  1469.     jb    hdsesc3a        ; b = no
  1470.     mov    al,pixxor        ; assume XOR  ESC / 2 d
  1471.     cmp    cl,3            ; something else?
  1472.     jb    hdsesc3a        ; b = no
  1473.     ja    hdsesc3b        ; a = unknown, ignore
  1474.     mov    al,pixfor+pixbak    ; write both absolute  ESC / 3 d
  1475. hdsesc3a:mov    ccode,al        ; use as pixel op coding
  1476. hdsesc3b:push    prestate        ; get previous state
  1477.     pop    ttstate            ; restore it
  1478.     ret
  1479.  
  1480. hdsesc4:cmp    al,'h'            ; set space, backspace control?
  1481.     je    hdsesc4a        ; e = yes
  1482.     cmp    al,'l'            ; reset space, backspace control?
  1483.     jne    hdsesc9            ; ne = no
  1484.     xor    ah,ah            ; say resetting
  1485.     jmp    short hdsesc5
  1486. hdsesc4a:mov    ah,1            ; say setting
  1487. hdsesc5:cmp    param,2            ; space control?
  1488.     jne    hdsesc5a        ; ne = no
  1489.     mov    spcontrol,ah        ; reset (0) or set destructive SPACE
  1490.     push    prestate        ; get previous state
  1491.     pop    ttstate            ; restore it
  1492.     ret
  1493. hdsesc5a:cmp    param,9            ; destructive backspace?
  1494.     jne    hdsesc13        ; ne = no
  1495.     mov    bscontrol,ah        ; reset (0) or set destructive BS
  1496.  
  1497. hdsesc9:cmp    al,'C'            ; user defined fill pattern #1?
  1498.     jne    hdsesc10        ; ne = no
  1499.     mov    di,offset filpat13    ; storage area for user pattern #1
  1500.     jmp    short hdsesc11
  1501. hdsesc10:cmp    al,'D'            ; user defined fill pattern #2?
  1502.     jne    hdsesc11        ; ne = no
  1503.     mov    di,offset filpat14    ; storage area for user pattern #2
  1504. hdsesc11:mov    cx,8            ; do 8 paramters
  1505.     xor    bx,bx
  1506. hdsesc12:mov    ax,param[bx]        ; copy 8 bit fill pattern
  1507.     mov    [di],al            ; to array
  1508.     add    bx,2
  1509.     inc    di
  1510.     loop    hdsesc12
  1511. hdsesc13:push    prestate        ; get previous state
  1512.     pop    ttstate            ; restore it
  1513.     ret
  1514. hdsesc    endp
  1515.  
  1516. ; Analyze ESC [ Pn ; Pn m  color command    
  1517. ; where Pn = 30-37 foreground color, 40-47 background color, ANSI standard
  1518. ; Enter with escape sequence already parsed.
  1519. TEKCOL    proc    near
  1520.     push    si
  1521.     cld
  1522.     mov    si,offset param        ; parameters from parser
  1523.     mov    cx,nparam        ; number of parameters
  1524. tekco1:    jcxz    tekco5            ; z = none left
  1525.     lodsw                ; parameter to ax
  1526.     dec    cx
  1527.     or    ax,ax            ; 0, remove intensity, set b/w?
  1528.     jnz    tekco2            ; nz = no
  1529.     mov    tfcol,7            ; regular white
  1530.     mov    tbcol,0            ;  on black
  1531.     jmp    short tekco1
  1532.  
  1533. tekco2:    cmp    ax,1            ; intensity bit?
  1534.     jne    tekco3            ; ne = no
  1535.     or    tfcol,8            ; set foreground intensity
  1536.     jmp    short tekco1
  1537.     
  1538. tekco3:    cmp    ax,30            ; foreground series?
  1539.     jb    tekco1            ; b = no
  1540.     cmp    ax,37
  1541.     ja    tekco4            ; a = no
  1542.     sub    ax,30            ; remove bias
  1543.     push    bx
  1544.     mov    bl,al
  1545.     xor    bh,bh
  1546.     mov    al,byte ptr colortb[bx]    ; reverse coloring
  1547.     pop    bx
  1548.     and    tfcol,not (7)        ; retain intensity bit
  1549.     or    tfcol,al        ; remember foreground color
  1550.     jmp    short tekco1
  1551.  
  1552. tekco4:    cmp    ax,40
  1553.     jb    tekco1
  1554.     cmp    ax,47            ; legal value?
  1555.     ja    tekco1            ; a = no
  1556.     sub    al,40
  1557.     push    bx
  1558.     mov    bl,al
  1559.     xor    bh,bh
  1560.     mov    al,byte ptr colortb[bx]    ; reverse coloring
  1561.     pop    bx
  1562.     mov    tbcol,al        ; remember background color
  1563.     jmp    short tekco1
  1564.  
  1565. tekco5:    cmp    ninter,0        ; intermediates?
  1566.     jne    tekco7            ; ne = yes, no go
  1567.     cmp    lparam,0        ; letter parameter?
  1568.     jne    tekco7            ; ne = yes, no go
  1569.     cmp    nparam,0        ; number of ansi arguments, zero?
  1570.     ja    tekco6            ; a = no, got some
  1571.     mov    tbcol,0            ; none is same as 0, set b/w
  1572.     mov    tfcol,7
  1573. tekco6:    mov    al,tbcol        ; success, store coloring
  1574.     mov    gbcol,al        ; set background color
  1575.     mov    al,tfcol
  1576.     mov    gfcol,al        ; set foreground color
  1577.     call    fixcolor        ; do special ega corrections
  1578.     mov    al,gfcol        ; update these in case error
  1579.     mov    tfcol,al
  1580.     mov    colpal[7],al        ; foreground goes here
  1581.     mov    al,gbcol
  1582.     mov    tbcol,al
  1583.     mov    colpal[0],al        ; background goes here
  1584. tekco7:    pop    si
  1585.     clc
  1586.     ret
  1587. TEKCOL    endp
  1588.  
  1589. ; Revise screen color codes for ega boards with mono displays and limited
  1590. ; memory.
  1591. fixcolor proc    near
  1592.     cmp    graph_mode,ega        ; one of these ega modes?
  1593.     je    fixcol6            ; e = yes
  1594.     cmp    graph_mode,colorega
  1595.     je    fixcol6
  1596.     cmp    graph_mode,monoega
  1597.     je    fixcol6
  1598.     cmp    plotptr,offset pltcga    ; using CGA style graphics?
  1599.     jne    fixcol5            ; ne = no
  1600.     and    gfcol,7            ; strip intensity
  1601.     jmp    short fixcol6        ; keep colors different
  1602. fixcol5:ret                ; else ignore color corrections
  1603. fixcol6:mov    ah,gfcol
  1604.     mov    al,gbcol
  1605.     cmp    graph_mode,monoega    ; monochrome ega display?
  1606.     jne    fixcol3            ; ne = no
  1607.     test    al,7            ; bright backgound?
  1608.     jnz    fixcol1            ; nz = yes
  1609.     mov    ah,1            ; normal foreground
  1610.     test    gfcol,8            ; intensity on?
  1611.     jz    fixcol1            ; z = no
  1612.     mov    ah,5            ; say bright foreground
  1613. fixcol1:test    al,7            ; black backgound?
  1614.     jz    fixcol2            ; z = yes
  1615.     mov    al,1            ; regular video
  1616. fixcol2:cmp    ah,al            ; same color in both?
  1617.     jne    fixcol3            ; ne = no
  1618.     mov    ah,1            ; make foreground regular
  1619.     xor    al,al            ;  and background black
  1620. fixcol3:mov    gfcol,ah
  1621.     mov    gbcol,al
  1622.     cmp    gpage,0            ; minimal memory (64KB mono and ega)?
  1623.     ja    fixcol4            ; a = no, enough, else strange mapping
  1624.     mov    al,gfcol        ; fix coloring to map planes C0 to C1
  1625.     and    al,5            ; and C2 to C3 (as 0, 3, 0Ch, or 0Fh)
  1626.     mov    ah,al            ; make a copy
  1627.     shl    ah,1            ; duplicate planes C0, C2 in C1, C3
  1628.     or    al,ah            ; merge the bits
  1629.     mov    gfcol,al        ; store proper foreground color
  1630.     mov    al,gbcol        ; repeat for background color
  1631.     and    al,5
  1632.     mov    ah,al
  1633.     shl    ah,1
  1634.     or    al,ah
  1635.     mov    gbcol,al
  1636. fixcol4:ret
  1637. fixcolor endp
  1638.  
  1639. tekrid    proc    near            ; report Tek screen parameters
  1640.     cmp    lparam,'?'        ; possible "ESC [ ? 38 l"?
  1641.     jne    tekridx            ; ne = no
  1642.     cmp    nparam,1        ; just one numeric parameter?
  1643.     jne    tekridx            ; ne = no
  1644.     cmp    param,256        ; correct value?
  1645.     je    tekrid            ; e = yes
  1646. tekridx:ret
  1647. tekrid1:push    es            ; as ESC [ ? 256; height; len; #col n
  1648.     push    ds
  1649.     pop    es
  1650.     cld
  1651.     mov    di,offset tempname    ; a temp buffer
  1652.     mov    al,escape        ; report
  1653.     stosb
  1654.     mov    al,'['
  1655.     stosb
  1656.     mov    al,'?'
  1657.     stosb
  1658.     mov    ax,256
  1659.     call    dec2di            ; write ascii digits
  1660.     mov    al,';'
  1661.     stosb
  1662.     mov    ax,ybot            ; do height
  1663.     inc    ax
  1664.     cmp    graph_mode,mono        ; pure mono text system?
  1665.     jne    tekrid7a        ; ne = no
  1666.     mov    ax,24
  1667. tekrid7a:call    dec2di
  1668.     mov    al,';'            ; separator
  1669.     stosb
  1670.     mov    ax,xmax            ; width
  1671.     add    ax,8            ; in dots
  1672.     cmp    graph_mode,mono        ; pure mono text system?
  1673.     jne    tekrid7b        ; ne = no
  1674.     mov    ax,80
  1675. tekrid7b:call    dec2di
  1676.     mov    al,';'            ; separator
  1677.     stosb
  1678.     mov    al,'1'            ; screen colors, assume 1
  1679.     stosb
  1680.     cmp    plotptr,offset pltcga    ; using CGA style graphics?
  1681.     je    tekrid4            ; e = yes
  1682.     cmp    graph_mode,monoega    ; monochrome monitor on ega?
  1683.     je    tekrid4            ; e = yes
  1684.     cmp    graph_mode,mono        ; pure mono text system?
  1685.     jne    tekrid3
  1686.     mov    byte ptr [di-1],'0'    ; say zero colors
  1687.     jmp    short tekrid4
  1688. tekrid3:mov    al,'6'
  1689.     stosb                ; say 16
  1690. tekrid4:mov    al,'n'            ; end of string
  1691.     stosb
  1692.     call    outstrng        ; send the string
  1693.     pop    es
  1694.     ret
  1695. tekrid    endp
  1696.  
  1697. tekprpt    proc    near
  1698.     cmp    nparam,1        ; one or more numeric parameters?
  1699.     jb    tekrprx            ; b = no
  1700.     cmp    param,2            ; "CSI 2 $ u"?
  1701.     jne    tekrprx            ; ne = no
  1702.     cmp    inter,'$'        ; correct Intermediate?
  1703.     jne    tekrprx            ; ne = no
  1704.     call    dword ptr rptptr    ; invoke the palette report generator
  1705. tekrprx:ret
  1706. tekprpt    endp
  1707.  
  1708. tekrpt    proc    FAR            ; report VT340 color palette
  1709.     push    es            ; DECRQTSR(request), DECCTR(response)
  1710.     push    ds
  1711.     pop    es
  1712.     push    di
  1713.     push    bx
  1714.     cld
  1715.     mov    di,offset tempname    ; a temp buffer
  1716.     mov    al,escape        ; report
  1717.     stosb
  1718.     cmp    plotptr,offset pltcga    ; using CGA style graphics?
  1719.     je    tekrpt9            ; e = yes
  1720.     cmp    graph_mode,mono        ; pure mono text system?
  1721.     je    tekrpt9            ; e = yes
  1722.     cmp    graph_mode,monoega    ; monochrome monitor on ega?
  1723.     jne    tekrpt10        ; ne = no
  1724. tekrpt9:mov    ax,'0P'            ; b/w systems report DCS 0 $ s ST
  1725.     stosw
  1726.     mov    ax,'s$'
  1727.     stosw
  1728.     call    outstrng
  1729.     jmp    tekrpt8
  1730.  
  1731. tekrpt10:mov    ax,'2P'            ; color systems report DCS 2 $ s...ST
  1732.     stosw
  1733.     mov    ax,'s$'
  1734.     stosw                ; "ESC [ 2 $ s"
  1735.     call    outstrng        ; output this string
  1736.     mov    cx,16            ; number of palette registers to do
  1737.     xor    bx,bx            ; begin with color palette 0
  1738. tekrpt1:push    bx            ; save palette index
  1739.     push    cx            ; save loop counter
  1740.     mov    di,offset tempname    ; buffer
  1741.     mov    ax,bx            ; palette number
  1742.     call    dec2di            ; palette register, to buffer
  1743.     mov    ax,'2;'            ; ";2;" means sending RGB values
  1744.     stosw
  1745.     mov    al,';'
  1746.     stosb
  1747.     mov    ah,colpal[bx]        ; get palette iRGB
  1748.     mov    al,rgbbold/4        ; assume dark red for bold black
  1749.     cmp    ah,8            ; bold black?
  1750.     je    tekrpt2            ; e = yes
  1751.     xor    al,al
  1752.     test    ah,4            ; red?
  1753.     jz    tekrpt2            ; z = no
  1754.     mov    al,rgbbold/2        ; say red, 40%
  1755.     test    ah,8            ; bold?
  1756.     jz    tekrpt2            ; z = no
  1757.     mov    al,rgbbold        ; more if bold
  1758. tekrpt2:push    ax
  1759.     xor    ah,ah            ; clear high byte
  1760.     call    dec2di            ; store red
  1761.     pop    ax
  1762.     mov    al,';'            ; separator
  1763.     stosb
  1764.     mov    al,rgbbold/4        ; assume dark green for bold black
  1765.     cmp    ah,8            ; bold black?
  1766.     je    tekrpt4            ; e = yes
  1767.     xor    al,al
  1768.     test    ah,2            ; green?
  1769.     jz    tekrpt4            ; z = no
  1770.     mov    al,rgbbold/2        ; say green, 40%
  1771.     test    ah,8            ; bold?
  1772.     jz    tekrpt4            ; z = no
  1773.     mov    al,rgbbold        ; more if bold
  1774. tekrpt4:push    ax
  1775.     xor    ah,ah            ; clear high byte
  1776.     call    dec2di            ; store green
  1777.     pop    ax
  1778.     mov    al,';'            ; separator
  1779.     stosb
  1780.     mov    al,rgbbold/4        ; assume dark blue for bold black
  1781.     cmp    ah,8            ; bold black?
  1782.     je    tekrpt6            ; e = yes
  1783.     xor    al,al
  1784.     test    ah,1            ; blue?
  1785.     jz    tekrpt6            ; z = no
  1786.     mov    al,rgbbold/2        ; say blue, 40%
  1787.     test    ah,8            ; bold?
  1788.     jz    tekrpt6            ; z = no
  1789.     mov    al,rgbbold        ; more if bold
  1790. tekrpt6:xor    ah,ah            ; clear high byte
  1791.     call    dec2di            ; store blue
  1792.     pop    cx            ; recover loop counter
  1793.     cmp    cx,1            ; doing last item?
  1794.     je    tekrpt7            ; e = yes, do not send another "/"
  1795.     mov    al,'/'            ; separator
  1796.     stosb
  1797. tekrpt7:push    cx
  1798.     call    outstrng        ; output this string
  1799.     pop    cx
  1800.     pop    bx            ; recover palette index
  1801.     inc    bx            ; ready for next palette
  1802.     dec    cx
  1803.     jz    tekrpt8            ; z = done
  1804.     jmp    tekrpt1            ; do all palettes
  1805. tekrpt8:mov    al,escape        ; DCS terminator ST
  1806.     call    outmodem
  1807.     mov    al,'\'
  1808.     call    outmodem
  1809.     pop    bx
  1810.     pop    di
  1811.     pop    es
  1812.     ret
  1813. tekrpt    endp
  1814.  
  1815. ; Output string in tempname. Enter with di pointing at last byte+1. Return
  1816. ; with di at the same place.
  1817. outstrng proc    near
  1818.     push    cx
  1819.     mov    cx,di            ; compute length
  1820.     mov    di,offset tempname    ; start of buffer
  1821.     sub    cx,di            ; start of buffer
  1822. outstn1:mov    al,[di]
  1823.     inc    di
  1824.     call    outmodem        ; send the byte
  1825.     loop    outstn1            ; do the string
  1826.     pop    cx
  1827.     ret
  1828. outstrng endp
  1829.  
  1830. ; Process Device Control Strings (DCS or ESC P lead-in chars, parameters,
  1831. ; and Final character already read). Prepare to gather strings.
  1832. tekdcs    proc    near
  1833.     mov    dcsstrf,al        ; record Final char
  1834.     mov    emubufc,0        ; clear string count
  1835.     mov    cx,maxparam        ; number of DCS parameters
  1836.     push    si            ; copy these to the DCS area so that
  1837.     push    di            ;  they are not lost when an ST is
  1838.     push    es            ;  parsed (parser clears ESC items)
  1839.     push    ds
  1840.     pop    es
  1841.     mov    si,offset param        ; ESC paramater storage area, numeric
  1842.     mov    di,offset dparam    ; DCS parameter storage area, numeric
  1843.     cld
  1844.     rep    movsw            ; copy set to DCS storage area
  1845.     mov    cl,lparam         ; copy letter Paramter
  1846.     mov    dlparam,cl
  1847.     mov    cx,maxinter        ; number of intermediate characters
  1848.     mov    si,offset inter        ; source
  1849.     mov    di,offset dinter    ; destination
  1850.     rep    movsb
  1851.     mov    si,nparam        ; number of parameters
  1852.     mov    dnparam,si
  1853.     mov    si,ninter
  1854.     mov    dninter,si        ; number of intermediates
  1855.     pop    es
  1856.     pop    di
  1857.     pop    si
  1858.     cmp    dcsstrf,'q'        ; Sixel Graphics?
  1859.     jne    tekdcs1            ; ne = no
  1860.     mov    ttstate,offset tekgets    ; get string as next state
  1861.     ret
  1862.  
  1863. tekdcs1:mov    ttstate,offset tekdcsnul ; consume unknown DCS
  1864.     ret
  1865. tekdcs    endp
  1866.  
  1867. ; Read and discard OSC (ESC ]), PM (ESC ^), APC (ESC _) control sequences
  1868. ; through final ST (ESC \) terminator.
  1869. tekdcsnul proc    near
  1870.     mov    dcsstrf,0        ; simulate a null (dummy) Final char
  1871.     cmp    al,20h            ; control char?
  1872.     jae    tekdcsnu1        ; ae = no, skip
  1873.     jmp    tekctl            ; do control char
  1874. tekdcsnu1:ret
  1875. tekdcsnul endp
  1876.  
  1877. ; State machine to process DCS strings of type "q" (Sixel Command and Data)
  1878. ; Enter with new char in AL.
  1879. tekgets    proc    near
  1880.     mov    ttstate,offset tekgets    ; set state to ourselves
  1881.     mov    nparam,0        ; say no pending control sequences
  1882.     cmp    al,20h            ; control character?
  1883.     jae    tekgsch            ; ae = no, analyze
  1884.     jmp    tekctl            ; do control char
  1885.                     ; single sixel char state
  1886. tekgsch:cmp    al,3fh            ; legal sixel data char?
  1887.     jb    tekgrpt            ; b = no, try repeated char
  1888.     mov    cx,1            ; repeat count of 1
  1889.     jmp    sixplt            ; plot the six dots
  1890.  
  1891. tekgrpt:cmp    al,'!'            ; repeated char?
  1892.     jne    tekgera            ; ne = no
  1893.     mov    ttstate,offset tekgrpt0    ; next state is get repeat parameter
  1894.     mov    param,0
  1895.     mov    nparam,0
  1896.     ret
  1897.  
  1898. tekgrpt0:cmp    al,' '            ; control char?
  1899.     jae    tekgrpt1        ; ae = no
  1900.     jmp    tekctl            ; process control char
  1901. tekgrpt1:mov    cx,param        ; first param is used here
  1902.     call    getdec            ; accumulate repeat count to cx
  1903.     mov    param,cx        ; retain current count
  1904.     jc    tekgrpt2        ; c = ended on non-numeric
  1905.     ret                ; get more characters
  1906. tekgrpt2:cmp    al,3fh            ; break char, is it a sixel datum?
  1907.     jb    tekgrpt3        ; b = no, it is illegal, quit
  1908.     call    sixplt            ; plot cx versions of the six bits
  1909.     mov    ttstate,offset tekgets    ; return to sixel idle state
  1910.     ret
  1911. tekgrpt3:jmp    short tekgets        ; reprocess break character
  1912.  
  1913. tekgera:cmp    al,22h            ; double quote raster attribute?
  1914.     jne    tekgco            ; ne = no, try color
  1915.     mov    param,0            ; clear parameters, Pan
  1916.     mov    param[2],0        ; Pad
  1917.     mov    param[4],0        ; Ph
  1918.     mov    param[6],0        ; Pv
  1919.     mov    nparam,0        ; work on initial parameter first
  1920.     mov    ttstate,offset tekgra1    ; next state is get parameter
  1921.     ret
  1922. tekgra1:cmp    al,' '            ; control char?
  1923.     jb    tekgra2            ; b = yes, finish this work first
  1924.     push    bx
  1925.     mov    bx,nparam        ; parameter number
  1926.     shl    bx,1            ; make it a word index
  1927.     mov    cx,param[bx]        ; accumulated parameter
  1928.     call    getdec            ; accumulate decimal value into cx
  1929.     mov    param[bx],cx        ; remember accumulation
  1930.     pop    bx
  1931.     jc    tekgra2            ; c = failure to get a digit char
  1932.     ret
  1933. tekgra2:inc    nparam            ; say have another complete parameter
  1934.     cmp    nparam,4        ; got all four params Pan,Pad,Ph,Pv?
  1935.     je    tekgra4            ; e = yes
  1936.     cmp    al,';'            ; break char is separator?
  1937.     jne    tekgra3            ; ne = no, quit now
  1938.     ret                ; get more characters
  1939. tekgra3:jmp    tekgets            ; restart with the break char
  1940.  
  1941. tekgra4:;;; perform raster attributes work here
  1942.     mov    ttstate,offset tekgets
  1943.     ret
  1944.  
  1945. tekgco:    cmp    al,'#'            ; color introducer?
  1946.     je    tekgco0            ; e = yes
  1947.     jmp    tekgcr            ; ne = no
  1948. tekgco0:mov    ttstate,offset tekgco1    ; next state is get parameter
  1949.     mov    param,0            ; clear parameters, Pc
  1950.     mov    param[2],0        ; Pu
  1951.     mov    param[4],0        ; Px
  1952.     mov    param[6],0        ; Py
  1953.     mov    param[8],0        ; Pz
  1954.     mov    nparam,0        ; work on initial parameter first
  1955.     ret
  1956. tekgco1:cmp    al,' '            ; control char?
  1957.     jb    tekgco2            ; b = yes, finish this work first
  1958.     push    bx
  1959.     mov    bx,nparam        ; parameter number
  1960.     shl    bx,1            ; make it a word index
  1961.     mov    cx,param[bx]        ; accumulated parameter
  1962.     call    getdec            ; accumulate decimal value
  1963.     mov    param[bx],cx        ; remember accumulation
  1964.     pop    bx
  1965.     jc    tekgco2            ; c = failure to get a digit char
  1966.     ret
  1967. tekgco2:inc    nparam            ; say have another complete parameter
  1968.     cmp    al,';'            ; break char is separator?
  1969.     jne    tekgco3            ; ne = no, decode current sequence
  1970.     cmp    nparam,5        ; have 5 params already?
  1971.     jae    tekgco3            ; ae = yes, process them now
  1972.     ret                ;  else get more parameters
  1973. tekgco3:cmp    nparam,1        ; just one parameter?
  1974.     je    tekgco3a        ; e = yes, select from palette
  1975.     jb    tekgco3b        ; b = none, reprocess as sixel
  1976.     call    tekgco4            ; process parameters
  1977.     mov    nparam,0        ; clear parameters
  1978.     jmp    tekgets            ; reprocess char as sixel
  1979.  
  1980. tekgco3a:push    bx            ; select color from palette
  1981.     mov    bx,param[0]        ; get color number
  1982.     and    bx,000fh        ; get 0-15
  1983.     mov    bl,colpal[bx]        ; get color from palette
  1984.     mov    gfcol,bl        ; set active foreground color
  1985.     pop    bx
  1986.     push    ax            ; save char in al
  1987.     call    fixcolor        ; fix color too, if req'd
  1988.     pop    ax
  1989. tekgco3b:mov    nparam,0        ; clear parameters
  1990.     jmp    tekgets            ; reprocess char as sixel
  1991.  
  1992.                     ; set IRGB/HLS color to color palette
  1993. tekgco4:cmp    param[2],2        ; Pu (1-2), wanted RBG?
  1994.     je    tekgco4b        ; e = yes
  1995.     cmp    param[2],1        ; Pu, wanted HLS?
  1996.     jne    tekgco4a        ; ne = no
  1997.     jmp    tekgco9            ; do HLS scheme
  1998. tekgco4a:mov    nparam,0        ; clear parameters
  1999.     ret                ; return without doing work
  2000. tekgco4b:push    ax            ; iRGB, save break char in al
  2001.     mov    ax,param[4]        ; red
  2002.     mov    bx,param[6]        ; green
  2003.     mov    dx,param[8]        ; blue
  2004.     xor    cx,cx            ; cl has final color index, 0-15
  2005.     or    ch,al
  2006.     or    ch,bl
  2007.     or    ch,dl            ; any color?
  2008.     jcxz    tekgco7            ; z = no, use cl = 0 black
  2009.     cmp    ax,rgbbold        ; setting red bold?
  2010.     jae    tekgco4c        ; ae = yes
  2011.     cmp    bx,rgbbold        ; setting green bold?
  2012.     jae    tekgco4c        ; ae = yes
  2013.     cmp    dx,rgbbold        ; setting blue bold?
  2014.     jb    tekgco4d        ; b = no
  2015. tekgco4c:mov    cl,8            ; set the bold bit
  2016.     jmp    tekgco4e        ; do hues
  2017. tekgco4d:cmp    ax,rgbbold/2        ; all in dim intensities?
  2018.     jae    tekgco4e        ; ae = no
  2019.     cmp    bx,rgbbold/2        ; green?
  2020.     jae    tekgco4e        ; ae = no
  2021.     cmp    dx,rgbbold/2        ; blue
  2022.     jae    tekgco4e        ; ae = no
  2023.     mov    cl,8            ; use bold black (dark grey)
  2024.     jmp    tekgco7
  2025. tekgco4e:or    ax,ax            ; Hues, any red?
  2026.     jz    tekgco5            ; z = no
  2027.     or    cl,4            ; set red bit
  2028.     cmp    ax,rgbbold/2        ; dim?
  2029.     jae    tekgco5            ; ae = no
  2030.     test    cl,8            ; doing bold?
  2031.     jz    tekgco5            ; z = no
  2032.     xor    cl,4            ; clear dim red
  2033. tekgco5:or    bx,bx            ; any green?
  2034.     jz    tekgco6            ; z = no
  2035.     or    cl,2            ; set green bit
  2036.     cmp    bx,rgbbold/2        ; dim?
  2037.     jae    tekgco6            ; ae = no
  2038.     test    cl,8            ; doing bold?
  2039.     jz    tekgco6            ; z = no
  2040.     xor    cl,2            ; clear dim green
  2041. tekgco6:or    dx,dx            ; any blue?
  2042.     jz    tekgco7            ; z = no
  2043.     or    cl,1            ; set blue bit
  2044.     cmp    dx,rgbbold/2        ; dim?
  2045.     jae    tekgco7            ; ae = no
  2046.     test    cl,8            ; doing bold?
  2047.     jz    tekgco7            ; z = no
  2048.     xor    cl,1            ; clear dim blue
  2049. tekgco7:push    bx
  2050.     mov    bx,param[0]        ; Pc, color palette being defined
  2051.     and    bx,000fh        ; get 0-15
  2052.     mov    colpal[bx],cl        ; store color code in palette
  2053.     pop    bx
  2054.     mov    nparam,0        ; say done with this sequence
  2055.     pop    ax            ; recover break char in al
  2056.     ret
  2057.  
  2058.                     ; Hue, Lightness, Saturation
  2059. tekgco9:push    ax            ; save break char
  2060.     xor    cl,cl            ; assummed color of black
  2061.     mov    ax,param[4]        ; Px, Hue, 60 degree slices
  2062.     push    cx
  2063.     mov    cx,360            ; do modulo 360
  2064.     xor    dx,dx            ; clear high order numerator
  2065.     div    cx            ; dx has remainder
  2066.     pop    cx
  2067.     mov    ax,dx            ; put remainder in ax
  2068.     cmp    ax,30            ; blue?
  2069.     jae    tekgco10        ; ae = no
  2070.     or    cl,1            ; blue
  2071.     jmp    short tekgco15
  2072. tekgco10:cmp    ax,90            ; magenta?
  2073.     jae    tekgco11        ; ae = no
  2074.     or    cl,1+4            ; magenta = blue + red
  2075.     jmp    short tekgco15
  2076. tekgco11:cmp    ax,150            ; red?
  2077.     jae    tekgco12        ; ae = no
  2078.     or    cl,4            ; red
  2079.     jmp    short tekgco15
  2080. tekgco12:cmp    ax,210            ; yellow?
  2081.     jae    tekgco13        ; ae = no
  2082.     or    cl,4+2            ; yellow = reg + green
  2083.     jmp    short tekgco15
  2084. tekgco13:cmp    ax,270            ; cyan?
  2085.     jae    tekgco14        ; ae = no
  2086.     or    cl,2+1            ; cyan = green+blue
  2087.     jmp    short tekgco15
  2088. tekgco14:or    cl,1            ; blue
  2089.  
  2090. tekgco15:mov    ax,param[6]        ; Py, Lightness
  2091.     mov    dx,param[8]        ; Pz, Saturation
  2092.     cmp    ax,86            ; lightness is max?
  2093.     jb    tekgco16        ; b = no
  2094.     mov    cl,0fh            ; greater than 85% means bold white
  2095.     jmp    short tekgco22
  2096. tekgco16:cmp    ax,71            ; high lightness?
  2097.     jb    tekgco17        ; b = not that light
  2098.     or    cl,8            ; turn on bold bit
  2099.     cmp    dx,51            ; saturated?
  2100.     jae    tekgco22        ; ae = yes
  2101.     mov    cl,0fh            ; low saturation yields bold white
  2102.     jmp    short tekgco22
  2103. tekgco17:cmp    ax,57            ; central coloring, upper?
  2104.     jb    tekgco18        ; b = no
  2105.     or    cl,8            ; turn on bold bit
  2106.     cmp    dx,51            ; saturated?
  2107.     jae    tekgco22        ; ae = yes, use bold colors
  2108.     mov    cl,7            ; s < 50 is dim white
  2109.     cmp    dx,11            ; saturated less than 11%
  2110.     jae    tekgco22        ; ae = no
  2111.     xor    cl,cl            ; s < 11 is black here
  2112.     jmp    short tekgco22
  2113. tekgco18:cmp    ax,43            ; dim colors, upper?
  2114.     jb    tekgco19        ; b = no
  2115.     or    cl,8            ; turn on bold bit
  2116.     cmp    dx,51            ; saturated?
  2117.     jae    tekgco22        ; ae = yes, use bold colors
  2118.     and    cl,not 8        ; use dim colors
  2119.     jmp    short tekgco22
  2120. tekgco19:cmp    ax,29            ; dim colors, lower?
  2121.     jb    tekgco20        ; b = no
  2122.     cmp    dx,51            ; saturated?
  2123.     jae    tekgco22        ; ae = yes
  2124.     mov    cl,7            ; use dim white
  2125.     jmp    short tekgco22
  2126. tekgco20:cmp    ax,14            ; dark colors?
  2127.     jb    tekgco21        ; b = no
  2128.     cmp    dx,51            ; saturated?
  2129.     jae    tekgco22        ; ae = yes
  2130. tekgco21:xor    cl,cl            ; use black
  2131. tekgco22:push    bx
  2132.     mov    bx,param[0]        ; Pc, color palette being defined
  2133.     and    bx,000fh        ; get palette 0-15
  2134.     mov    colpal[bx],cl        ; store color code in palette
  2135.     pop    bx
  2136.     mov    nparam,0        ; say done with this sequence
  2137.     pop    ax            ; recover break char
  2138.     ret
  2139.  
  2140. tekgcr:    cmp    al,'$'            ; graphics carriage return?
  2141.     jne    tekgnl            ; ne = no
  2142.     mov    x_coord,0        ; go to left margin, no line feed
  2143.     ret
  2144. tekgnl:    cmp    al,'-'            ; graphics new line?
  2145.     jne    tekgunk            ; ne = no
  2146.     mov    x_coord,0        ; go to left margin, no line feed
  2147.     mov    ax,y_coord        ; bottom of char cell
  2148.     add    ax,6            ; go down 6 dots
  2149.     cmp    ax,ybot            ; wrapping below bottom?
  2150.     jbe    tekgnl1            ; be = no
  2151.     mov    ax,ybot            ; stop at bottom (leaves 2 dots free!)
  2152. tekgnl1:mov    y_coord,ax
  2153.     ret
  2154. tekgunk:mov    ttstate,offset tekgets    ; unknown char
  2155.     cmp    al,' '            ; control char?
  2156.     jae    tekgun1            ; ae = no
  2157.     jmp    tektxt            ; process control char
  2158. tekgun1:ret                ; ignore the unknown char
  2159. tekgets    endp
  2160.  
  2161. ; Accumulate decimal value in CX using ascii char in al.
  2162. ; Return with value in CX. Return carry clear if ended on a digit,
  2163. ; return carry set and ascii char in al if ended on a non-digit.
  2164. getdec    proc    near
  2165.     cmp    al,'0'            ; a number?
  2166.     jb    getdecx            ; b = no, quit
  2167.     cmp    al,'9'
  2168.     ja    getdecx            ; a = not a number, quit
  2169.     sub    al,'0'            ; remove ascii bias
  2170.     xchg    cx,ax            ; put char in cx, decimal value in ax
  2171.     push    dx            ; save reg
  2172.     mul    ten            ; times ten for a new digit
  2173.     pop    dx            ; recover reg, ignore overflow
  2174.     add    al,cl            ; add current digit
  2175.     adc    ah,0            ; 16 bits worth
  2176.     xchg    ax,cx            ; rpt cnt back to cx
  2177.     clc                ; say found a digit
  2178.     ret
  2179. getdecx:stc                ; say non-digit (in al)
  2180.     ret
  2181. getdec    endp
  2182.  
  2183. ; Display lower six bits of AL in a column, a sixel datum. Do CX times.
  2184. ; Location is PC text cursor, x_coord, y_coord, with least significant bit
  2185. ; at the top (at y_coord+8). Increments x_coord by one for each interation
  2186. ; but stops at right margin and does not change y_coord. If dparam[2], P2,
  2187. ; is 1 then color pattern 0 bits in current background, else skip them.
  2188. sixplt    proc    near
  2189.     cmp    cx,0            ; repeat count present?
  2190.     jne    sixplt1            ; ne = yes
  2191.     ret
  2192. sixplt1:push    ax
  2193.     push    bx
  2194.     push    linepat            ; save line pattern
  2195.     sub    al,3fh            ; remove ascii bias from sixel char
  2196.     xor    ah,ah
  2197.     mov    linepat,ax        ; our dot pattern in lower 6 bits
  2198.     mov    di,y_coord        ; text bottom cell line
  2199.     sub    di,8            ; go to top of 8 high char cell
  2200.     jnc    sixplt2            ; nc = no wrap over top
  2201.     xor    di,di            ; limit to screen top
  2202. sixplt2:mov    bx,di            ; bx = ending y
  2203.     add    bx,5            ; plus our six dots (goes down screen)
  2204.     cmp    bx,ybot            ; wrapping below bottom?
  2205.     jbe    sixplt3            ; be = no
  2206.     mov    bx,ybot            ; stop at bottom
  2207. sixplt3:mov    ax,x_coord        ; left edge of text cell
  2208.     mov    si,ax            ; si=starting, ax=ending PC x coord
  2209.     add    xmax,7            ; refer to right edge, not right char
  2210.     push    es            ; set up for dot plotting, save regs
  2211.     push    si
  2212.     push    di
  2213.     push    dx
  2214.     push    bp
  2215.     mov    dl,ccode        ; existing pixel op code
  2216.     push    dx            ; save ccode around line drawing
  2217.     mov    ccode,pixor        ; set OR pixel op for use by plot()
  2218.     cmp    gfcol,0            ; all black dots?
  2219.     jne    sixplt3a        ; ne = no
  2220.     mov    ccode,pixfor        ; yes, force overwriting to nulls
  2221. sixplt3a:push    cx
  2222.     call    psetup            ; setup display and es:di and es:si
  2223.     pop    cx
  2224.                     ; start sixel repeat loop
  2225. sixplt4:push    cx            ; save sixel repeat count
  2226.     push    di            ; save y starting screen address
  2227.     mov    bp,linepat        ; store active line pattern word in BP
  2228.     mov    cx,6            ; six dots per sixel
  2229.                     ; start six dot loop
  2230. sixplt5:push    cx            ; save dot count
  2231.     mov    cl,pixFor        ; assume foreground coloring
  2232.     test    bp,1            ; bit to be plotted, is it a 1?
  2233.     jnz    sixplt6            ; nz = yes, plot in foreground color
  2234.     cmp    dparam[2],1        ; P2 = 1, skip over 0's?
  2235.     je    sixplt6            ; e = yes
  2236.     mov    cl,pixbak        ; use background write pixel op
  2237.     or    bp,1            ; set pattern bit so we see a pixel
  2238. sixplt6:mov    ccode,cl        ; desired pixel op
  2239.     call    plotptr            ; plot a dot if it is a 1
  2240.     call    pincy            ; next dot down the screen (di)
  2241.     pop    cx            ; recover dot counter
  2242.     loop    sixplt5            ; do each of 6 dots
  2243.                     ;
  2244.     pop    di            ; recover starting y screen coord
  2245.     pop    cx            ; recover repeat count
  2246.     cmp    ax,xmax            ; off right edge?
  2247.     jae    sixplt8            ; ae = yes
  2248.     inc    ax            ; move right one pixel
  2249.     inc    si            ; start and stop x's
  2250. sixplt8:loop    sixplt4            ; repeat sixel cx times
  2251.     pop    dx
  2252.     mov    ccode,dl        ; recover main color code
  2253.     pop    bp
  2254.     pop    dx
  2255.     pop    di
  2256.     pop    si
  2257.     pop    es
  2258.     mov    x_coord,ax        ; new text starting x coord
  2259.     sub    xmax,7            ; restore to right most char cell
  2260.     pop    linepat            ; restore normal line pattern
  2261.     pop    bx
  2262.     pop    ax
  2263.     ret
  2264. sixplt    endp
  2265.  
  2266. ; Process ST or ESC \  String Terminator.
  2267. tekgotst proc    near
  2268.     mov    dcsstrf,0        ; clear DCS Final char
  2269.     mov    nparam,0
  2270.     mov    ninter,0
  2271.     mov    al,colpal[7]        ; reset foreground to palette 7
  2272.     mov    gfcol,al
  2273.     mov    al,colpal[0]        ; and background to palette 0
  2274.     mov    gbcol,al
  2275.     call    fixcolor        ; and fix up coloring, if req'd
  2276.     mov    prestate,offset tektxt    ; reset state of emulator to normal
  2277.     mov    ttstate,offset tektxt
  2278.     ret
  2279. tekgotst endp
  2280.  
  2281. TEKLINE    proc    near            ; GS line drawing
  2282.     cmp    al,' '            ; control char?
  2283.     jae    teklin3            ; ae = no
  2284.     cmp    al,CR            ; exit drawing on CR,LF,RS,US,FS,CAN
  2285.     je    teklin2            ; e = yes, a cr
  2286.     cmp    al,LF            ; these terminate line drawing cmds
  2287.     je    teklin2
  2288.     cmp    al,FS            ; <FS>
  2289.     je    teklin2
  2290.     cmp    al,GS            ; <GS>
  2291.     je    teklin2
  2292.     cmp    al,RS            ; <RS>
  2293.     je    teklin2
  2294.     cmp    al,US            ; <US>
  2295.     je    teklin2
  2296.     cmp    al,CAN            ; and <CAN>
  2297.     je    teklin2            ; BUT ignore other control chars
  2298.     cmp    al,escape        ; escape?
  2299.     je    teklin1            ; e = yes, come back to this state
  2300.     ret                ; ignore stray control char
  2301. teklin1:jmp    tekctl            ; process control char
  2302. teklin2:mov    lastc,0            ; clear last drawing coordinate flag
  2303.     mov    visible,0        ; invisible again
  2304.     jmp    tektxt            ; process char under text mode
  2305.  
  2306. teklin3:call    tekxyc            ; parse coordinates from input bytes
  2307.     jc    teklin4            ; c = done, do the plotting
  2308.     ret                ; nc = not done yet
  2309. teklin4:mov    cl,visible        ; get moveto or drawto variable
  2310.     call    tekdraw            ; move that point
  2311.     mov    visible,1        ; say next time we draw
  2312.     ret
  2313. TEKLINE    endp
  2314.     
  2315. TEKPNT    proc    near            ; FS plot single point
  2316.     cmp    al,' '            ; control char?
  2317.     jae    tekpnt3            ; ae = no
  2318.     cmp    al,CR            ; exit drawing on CR,LF,RS,US,FS,CAN
  2319.     je    tekpnt2            ; e = yes, a cr
  2320.     cmp    al,LF             ; these terminate line drawing cmds
  2321.     je    tekpnt2
  2322.     cmp    al,FS            ; <FS>
  2323.     je    tekpnt2
  2324.     cmp    al,GS            ; <GS>
  2325.     je    tekpnt2
  2326.     cmp    al,RS            ; <RS>
  2327.     je    tekpnt2
  2328.     cmp    al,US            ; <US>
  2329.     je    tekpnt2
  2330.     cmp    al,CAN            ; and <CAN>
  2331.     je    tekpnt2            ; BUT ignore other control chars
  2332.     cmp    al,escape        ; escape?
  2333.     je    tekpnt1            ; e = yes
  2334.     clc
  2335.     ret                ; ignore stray control char
  2336. tekpnt1:jmp    tekctl            ; process control char
  2337. tekpnt2:mov    lastc,0            ; clear last drawing coordinate flag
  2338.     mov    visible,0        ; invisible again
  2339.     jmp    tektxt            ; process char under text mode
  2340.  
  2341. tekpnt3:call    tekxyc            ; parse coordinates
  2342.     jc    tekpnt4            ; c = done, do the plotting
  2343.     ret                ; nc = not done yet
  2344. tekpnt4:xor    cl,cl            ; do not draw
  2345.     call    tekdraw            ; move to the point
  2346.     mov    ax,si            ; copy starting point to end point
  2347.     mov    bx,di            ; ax,bx,si,di are in PC coordinates
  2348.     mov    cl,1            ; make plot visible
  2349.     call    line            ; draw the dot
  2350.     mov    visible,0        ; return to invisibility
  2351.     clc
  2352.     ret
  2353. TEKPNT    endp
  2354.  
  2355. ; Decode graphics x,y components. Returns carry set to say have all
  2356. ; components for a line, else carry clear. Understands 4014 lsb extensions.
  2357. ; Permits embedded escape sequences.
  2358. TEKXYC    proc    near
  2359.     cmp    al,40h
  2360.     jb    tekgh2            ; 20-3F are HIX or HIY
  2361.     cmp    al,60h            ; 40-5F are LOX (causes beam movement)
  2362.     jb    tekgh4            ; 60-7F are LOY
  2363.                     ; extract low-order 5 bits of Y coord
  2364.     mov    ah,tek_loy        ; copy previous LOY to MSB (4014)
  2365.     mov    tek_lsb,ah
  2366.     and    al,1Fh            ; LOY is 5 bits
  2367.     mov    tek_loy,al
  2368.     cmp    lastc,loy        ; 2nd LOY in a row?
  2369.     je    tekgh1            ; e = yes, then LSB is valid
  2370.     mov    tek_lsb,0        ; 1st one, clear LSB
  2371. tekgh1:    mov    lastc,loy        ; LOY seen, expect HIX (instead of HIY)
  2372. tekgh0:    clc                ; c clear = not completed yet
  2373.     ret
  2374. tekghx:    mov    ttstate,offset tektxt    ; go to TEKTXT next time
  2375.     mov    lastc,0            ; clear last drawing coordinate flag
  2376.     or    status,txtmode        ; set text mode in status byte
  2377.     clc                ; carry clear means done
  2378.     ret
  2379.  
  2380.             ; Extract high-order 5 bits (X or Y, depending on lastc)
  2381. tekgh2: and    ax,1Fh            ; just 5 bits
  2382.     mov    cl,5
  2383.     shl    ax,cl            ; shift over 5 bits
  2384.     cmp    lastc,loy        ; was last coordinate a low-y?
  2385.     je    tekgh3            ; e = yes, parse hix
  2386.     mov    tek_hiy,ax        ; this byte has HIY
  2387.     mov    lastc,hiy
  2388.     clc
  2389.     ret
  2390. tekgh3: mov    tek_hix,ax        ; this byte has HIX
  2391.     mov    lastc,hix
  2392.     clc
  2393.     ret
  2394. tekgh4: and    al,1Fh            ; just 5 bits
  2395.     mov    tek_lox,al
  2396.     mov    lastc,lox
  2397.     mov    ax,tek_hix        ; combine HIX*32
  2398.     or    al,tek_lox        ;  with LOX
  2399.     mov    bx,tek_hiy        ; same for Y
  2400.     or    bl,tek_loy
  2401.     stc                ; set c to say completed operation
  2402.     ret
  2403. TEKXYC    endp
  2404.  
  2405. TEKRLIN    proc    near            ; RS relative line drawing
  2406.     cmp    al,' '            ; control char?
  2407.     jae    tekrli1            ; ae = no
  2408.     jmp    tektxt            ; process control char
  2409. tekrli1:cmp    al,' '            ; pen up command?
  2410.     jne    tekrli2            ; ne = no, try pen down
  2411.     mov    visible,0        ; do invisible movements
  2412.     jmp    short tekrli3        ; do the command
  2413. tekrli2:cmp    al,'P'            ; pen down command?
  2414.     jne    tekrli4            ; ne = no, return to text mode
  2415.     mov    visible,1        ; set visible moves
  2416.  
  2417. tekrli3:mov    ax,x_coord        ; PC x coordinate of pen
  2418.     mov    bx,y_coord        ;    y coordinate
  2419.     call    pctotek            ; get current pen position in Tek coor
  2420.     xor    cl,cl            ; invisible, moveto
  2421.     call    tekdraw            ; move that point, set oldx and oldy
  2422.     mov    ttstate,offset tekinc    ; next get incremental movement cmds
  2423.     ret
  2424.  
  2425. tekrli4:mov    visible,0        ; bad char, reset visibility
  2426.     mov    ttstate,offset tektxt    ; assume text
  2427. tekrli5:jmp    ttstate            ; deal with bad char
  2428. TEKRLIN    endp
  2429.                     ; interpret RS inc plot command byte
  2430. TEKINC    proc    near            ; get movement character and do cmd
  2431.     cmp    al,' '            ; control char?
  2432.     jae    tekinc1            ; ae = no
  2433.     jmp    tektxt            ; process control char
  2434. tekinc1:mov    bx,oldx
  2435.     mov    cx,oldy
  2436.     test    al,1            ; 'A', 'E', 'I'?  Do by bit fields
  2437.     jz    tekinc2            ; z = no
  2438.     inc    bx            ; adjust beam position
  2439. tekinc2:test    al,2            ; 'B', 'F', 'J'?
  2440.     jz    tekinc4
  2441.     dec    bx
  2442. tekinc4:test    al,4            ; 'D', 'E', 'F'?
  2443.     jz    tekinc8            ; z = no
  2444.     inc    cx
  2445. tekinc8:test    al,8            ; 'H', 'I', 'J'?
  2446.     jz    tekinc9
  2447.     dec    cx
  2448. tekinc9:cmp    bx,0            ; too far left?
  2449.     jge    tekinc10        ; ge = no
  2450.     xor    bx,bx            ; else stop at the left margin
  2451. tekinc10:cmp    bx,maxtekx-1        ; too far left?
  2452.     jle    tekinc11        ; le = no
  2453.     mov    bx,maxtekx-1        ; else stop that the left margin
  2454. tekinc11:cmp    cx,maxteky-1        ; above the top?
  2455.     jle    tekinc12        ; le = not above the top
  2456.     mov    cx,maxteky-1        ; else stop at the top
  2457. tekinc12:cmp    cx,0            ; below bottom?
  2458.     jge    tekinc13        ; ge = not below bottom
  2459.     xor    cx,cx            ; else stop at the bottom
  2460. tekinc13:mov    ax,bx            ; ax is vector x end point
  2461.     mov    oldx,bx
  2462.     mov    bx,cx            ; bx is vector y end point
  2463.     mov    oldy,cx
  2464.     mov    cl,visible
  2465.     jmp    tekdraw            ; move/draw to that point
  2466. tekincb:mov    visible,0
  2467.     jmp    tektxt            ; reparse the bad char
  2468. TEKINC    endp
  2469.     
  2470.  
  2471. crossini proc    near            ; set crosshairs for initial screen
  2472.     mov    ax,xmax            ; right margin minus 7 dots
  2473.     add    ax,7            ; right most dot
  2474.     shr    ax,1            ; central position
  2475.     mov    xcross,ax        ; save PC coord for crosshair
  2476.     mov    ax,ybot            ; last scan line
  2477.     shr    ax,1
  2478.     mov    ycross,ax        ; this is the center of the screen
  2479.     ret
  2480. crossini endp
  2481.  
  2482. ; Routine to trigger the crosshairs, wait for a key to be struck, and send
  2483. ; the typed char (if printable ascii) plus four Tek encoded x,y position
  2484. ; coordinates and then a carriage return.
  2485. ; ax, cx, xcross, ycross operate in PC coordinates.
  2486.      
  2487. CROSHAIR PROC NEAR
  2488.     push    linepat            ; save line drawing pattern
  2489.     mov    linepat,0ffffh        ; reset line type to solid
  2490.  
  2491.     mov    ax,xmax            ; right margin minus 7 dots
  2492.     add    ax,7
  2493.     mov    temp,ax            ; right margin dot
  2494. crosha1:call    crosdraw        ; draw the cross-hairs
  2495.     call    tiseof            ; is stdin at EOF?
  2496.     jc    crosha2            ; c = yes, exit this mode now
  2497.     mov    ah,coninq        ; DOS, quiet read char
  2498.     int    dos
  2499.     push    ax            ; save char for later
  2500.     call    crosdraw        ; erase cross hairs
  2501.     pop    ax
  2502.     or    al,al            ; ascii or scan code returned
  2503.     jnz    arrow5            ; nz = ascii char returned
  2504.  
  2505.     call    tiseof            ; is stdin at EOF?
  2506.     jc    crosha2            ; c = yes, exit this mode now
  2507.     mov    ah,coninq        ; read scan code
  2508.     int    dos
  2509.     or    al,al            ; Control-Break?
  2510.     jnz    crosha3            ; nz = no, something else
  2511. crosha2:pop    linepat            ; restore line pattern
  2512.     ret                ; exit crosshairs mode
  2513.  
  2514. crosha3:cmp    al,homscn        ; is it 'home'?
  2515.     jne    arrow1            ; ne = no, try other keys
  2516.     mov    ax,temp            ; right margin
  2517.     shr    ax,1            ; central position
  2518.     mov    xcross,ax        ; save PC coord for crosshair
  2519.     mov    ax,ybot            ; last scan line
  2520.     shr    ax,1
  2521.     mov    ycross,ax        ; this is the center of the screen
  2522.     jmp    crosha1            ; home the crosshairs
  2523.  
  2524. arrow1:    cmp    al,lftarr        ; left arrow?
  2525.     jne    arrow2            ; ne = no
  2526.     mov    cx,-1            ; left shift
  2527.     jmp    short xkeys
  2528. arrow2:    cmp    al,rgtarr        ; right arrow?
  2529.     jne    arrow3            ; ne = no
  2530.     mov    cx,1            ; right shift
  2531.     jmp    short xkeys
  2532. arrow3:    cmp    al,uparr        ; up arrow?
  2533.     jne    arrow4            ; ne = no
  2534.     mov    cx,-1            ; up shift
  2535.     jmp    short vertkey
  2536. arrow4:    cmp    al,dnarr        ; down arrow?
  2537.     jne    badkey            ; ne = no, ignore it
  2538.     mov    cx,1                  ; down shift
  2539.     jmp    short vertkey
  2540.  
  2541. badkey:    call    tekbeep            ; tell user we don't understand
  2542.     jmp    crosha1            ; keep going
  2543.  
  2544.                     ; Shifted keys yield ascii keycodes
  2545. arrow5:    cmp    al,'C' and 1fh        ; Control-C?
  2546.     je    crosha2            ; e = yes, exit crosshairs mode now
  2547.     cmp    al,shlftarr        ; shifted left arrow?
  2548.     jne    arrow6            ; ne = no
  2549.     mov    cx,-10            ; big left shift
  2550.     jmp    short xkeys
  2551. arrow6:    cmp    al,shrgtarr        ; shifted right arrow?
  2552.     jne    arrow7            ; ne = no
  2553.     mov    cx,10            ; big right shift
  2554.     jmp    short xkeys
  2555. arrow7:    cmp    al,shuparr        ; shifted up arrow?
  2556.     jne    arrow8            ; ne = no
  2557.     mov    cx,-10            ; big up shift
  2558.     jmp    short vertkey
  2559. arrow8:    cmp    al,shdnarr        ; shifted down arrow?
  2560.     jne    charkey            ; ne = no, send this key as is
  2561.     mov    cx,10            ; big down shift
  2562.     jmp    short vertkey
  2563.  
  2564. xkeys:     add    cx,xcross        ; add increment
  2565.     jns    noxc            ; gone too far negative?
  2566.     mov    cx,0            ; s = yes, make it 0
  2567. noxc:    cmp    cx,temp            ; too far right?
  2568.     jb    xdraw9            ; b = no
  2569.     mov    cx,temp            ; yes, make it the right
  2570. xdraw9: mov    xcross,cx        ; new x value for cross hairs
  2571.     jmp    crosha1            ; and redraw
  2572.      
  2573. vertkey:add    cx,ycross        ; adjust cx
  2574.     jns    noyc            ; gone negative?
  2575.     mov    cx,0            ; s = yes then make 0
  2576. noyc:    cmp    cx,ybot            ; too high?
  2577.     jb    yok            ; b = no
  2578.     mov    cx,ybot            ; make it maximum
  2579. yok:    mov    ycross,cx        ; save new y crosshair
  2580.     jmp    crosha1            ; and redraw
  2581.      
  2582. charkey:push    ax            ; preserve char in al
  2583.     call    tclrbuf            ; purge received data to date
  2584.     pop    ax
  2585.     call    outmodem        ; send the break character
  2586.     mov    ax,xcross        ; set beam to xcross,ycross
  2587.     mov    bx,ycross        ; must convert to Tek coordinates
  2588.     call    pctotek            ; scale from PC screen coord to Tek
  2589.     push    ax            ; save around drawing
  2590.     push    bx
  2591.     xor    cx,cx            ; just a move
  2592.     call    tekdraw            ; moveto ax,bx in Tek coord
  2593.     pop    bx            ; recover Tek y
  2594.     pop    ax            ; recover Tek x
  2595.     call    sendpos            ; send position report to host
  2596.     pop    linepat            ; recover current line drawing pattern
  2597.     mov    ttstate,offset tektxt    ; go to TEKTXT next time
  2598.     mov    lastc,0            ; clear last drawing coordinate flag
  2599.     or    status,txtmode        ; set text mode in status byte
  2600.     ret
  2601. CROSHAIR ENDP
  2602.      
  2603. ; CROSDRAW draws cross-hairs by XORing cross with picture.
  2604. ; xcross and ycross are in PC coordinates.     
  2605. CROSDRAW PROC    NEAR
  2606.     mov    al,ccode        ; save current pixel op
  2607.     push    ax
  2608.     mov    si,xcross        ; move to (xcross, ycross-10)
  2609.     mov    di,ycross
  2610.     sub    di,10            ; half the size of the cross
  2611.     jns    crosd1            ; no sign bit means ok
  2612.     xor    di,di            ; else limit to start of screen
  2613. crosd1:    mov    ax,si            ; next, draw to (xcross, ycross+10)
  2614.     mov    bx,ycross        ; make bottom stroke
  2615.     add    bx,10
  2616.     cmp    bx,ybot            ; too large?
  2617.     jbe    crosd2            ; be = no
  2618.     mov    bx,ybot            ; vertical line to (xcross,ybot)
  2619. crosd2:    mov    cl,pixxor        ; xor pixels
  2620.     call    line            ; and draw vertical
  2621.     sub    si,12            ; move to (xcross-12, ycross)
  2622.     jns    crosd3            ; no sign means ok
  2623.     xor    si,si            ; else limit to start of line
  2624. crosd3:    mov    di,ycross
  2625.     mov    bx,di
  2626.     mov    ax,xcross        ; draw to (xcross+12, ycross)
  2627.     add    ax,12
  2628.     cmp    ax,temp            ; temp is right margin, too large?
  2629.     jbe    crosd4            ; be = no, ok
  2630.     mov    ax,temp            ; max x value
  2631. crosd4:    mov    cl,pixxor        ; set XOR code
  2632.     call    line            ; draw to (xcross+12, ycross)
  2633.     pop    ax            ; recover current pixel op
  2634.     mov    ccode,al        ; restore it
  2635.     ret
  2636. CROSDRAW ENDP
  2637.      
  2638. ; SENDPOS sends position of cross-hairs to the host.
  2639. ; ax has Tek X and bx has Tek Y coord of center of crosshair     
  2640. SENDPOS PROC NEAR
  2641.     push    bx            ; preserve register
  2642.     call    sendxy            ; send x coord
  2643.     pop    ax
  2644.     call    sendxy            ; send y coord
  2645.     mov    al,cr            ; follow up with cr
  2646.     call    outmodem
  2647.     ret
  2648. SENDPOS ENDP
  2649.  
  2650. ; Write binary number in AX as decimal asciiz to buffer pointer DI.
  2651. dec2di    proc    near        ; output number in ax using base in cx
  2652.                 ; corrupts ax, cx, and dx
  2653.     mov    cx,10
  2654. dec2di1:xor    dx,dx        ; clear high word of numerator
  2655.     div    cx        ; (ax / cx), remainder = dx, quotient = ax
  2656.     push    dx        ; save remainder for outputting later
  2657.     or    ax,ax        ; any quotient left?
  2658.     jz    dec2di2        ; z = no
  2659.     call    dec2di1        ; yes, recurse
  2660. dec2di2:pop    dx        ; get remainder
  2661.     add    dl,'0'        ; make digit printable
  2662.     mov    [di],dl        ; store char in buffer
  2663.     inc    di
  2664.     mov    byte ptr[di],0    ; add terminator
  2665.     ret
  2666. dec2di    endp
  2667.      
  2668. ; SENDXY sends value of ax as Tek encoded bytes
  2669. ; ax is in Tek coordinates     
  2670. SENDXY    PROC    NEAR
  2671.     shl    ax,1
  2672.     shl    ax,1            ; move all but lower 5 bits to ah
  2673.     shl    ax,1
  2674.     shr    al,1
  2675.     shr    al,1            ; move low five bits to low 5 bits
  2676.     shr    al,1
  2677.     or    ah,20h            ; make it a printing char as per TEK
  2678.     xchg    al,ah            ; send high 5 bits first
  2679.     call    outmodem
  2680.     xchg    al,ah            ; then low five bits
  2681.     or    al,20h
  2682.     call    outmodem
  2683.     xchg    ah,al            ; al is first sent byte
  2684.     ret
  2685. SENDXY    ENDP
  2686.      
  2687.      
  2688. SENDID    PROC NEAR            ; pretend VT340
  2689.     mov    bx,offset tekid        ; VT320 identification string
  2690. sndid1: mov    al,[bx]            ; get char from sequence
  2691.     or    al,al            ; end of sequence?
  2692.     jz    sndid0            ; z = yes, return
  2693.     call    outmodem        ; send it out the port
  2694.     inc    bx
  2695.     jmp    sndid1
  2696. sndid0:    ret
  2697. SENDID    ENDP
  2698.      
  2699. ; SENDSTAT - send status and cursor position to host
  2700.      
  2701. SENDSTAT PROC NEAR
  2702.     mov    al,STATUS        ; get tek status
  2703.     or    al,20h            ; make it printable
  2704.     call    OUTMODEM        ; and send it
  2705.     mov    ax,oldx            ; now send x coordinate (oldx is Tek)
  2706.     call    SENDXY
  2707.     mov    ax,oldy            ; and y coordinate (oldy is Tek coord)
  2708.     call    SENDXY
  2709.     mov    al,cr            ; end with a cr
  2710.     call    OUTMODEM
  2711.     ret
  2712. SENDSTAT ENDP
  2713.      
  2714.  
  2715. ; Convert X and Y from PC coordinates to Tek coordinates. AX = X, BX = Y
  2716. ; for both input and output.
  2717. pctotek    proc    near
  2718.     mul    xdiv            ; scale from PC screen coord to Tek
  2719.     div    xmult
  2720.     xchg    bx,ax            ; save Tek x coord in bx
  2721.     neg    ax            ; y axis. Turn upside down for Tek
  2722.     add    ax,ybot
  2723.     mul    ydiv            ; scale y from PC screen coord to Tek
  2724.     div    ymult
  2725.     xchg    ax,bx            ; ax has X, bx has Y in Tek coords
  2726.     ret
  2727. pctotek    endp
  2728.  
  2729. ; Routine to output character in AL to the screen.
  2730.  
  2731. OUTSCRN PROC NEAR            ; put one character to the screen
  2732.     cmp    bypass,0        ; GIN mode bypass off?
  2733.     je    outscr1            ; e = yes
  2734.     ret                ;  else ignore characters
  2735.                     ; Set Translation Input filter
  2736. outscr1:cmp    rxtable+256,0        ; translation turned off?
  2737.     je    outscr2            ; e = yes, no translation
  2738.     push    bx
  2739.     mov    bx,offset rxtable    ; address of translate table
  2740.     xlatb                ; new char is in al
  2741.     and    al,7fh            ; retain only lower seven bits
  2742.     pop    bx
  2743. outscr2:mov    ccode,pixor        ; assume transparent chars
  2744.     cmp    chcontrol,0        ; transparent chars?
  2745.     je    outscr3            ; e = yes
  2746.     mov    ccode,pixfor        ; write in foreground
  2747. outscr3:cmp    al,lf            ; this moves down the screen
  2748.     je    outscr4            ; e = yes, a lf
  2749.     cmp    al,' '            ; printable?
  2750.     jb    outscr5            ; b = no
  2751. outscr4:call    testfull        ; check for full screen
  2752. outscr5:call    putc            ; routine to draw characters
  2753.     ret
  2754. OUTSCRN ENDP
  2755.      
  2756. ; Test if screen is full. If full sound beep, wait for any keyboard input
  2757. ; (skip kbd reading if stdin is redirected).
  2758. testfull proc    near
  2759.     push    ax
  2760.     mov    ax,x_coord
  2761.     cmp    ax,xmax            ; at end of the line?
  2762.     jbe    testfu1            ; be = no
  2763.     mov    x_coord,0        ; wrap to next line
  2764.     add    y_coord,8        ; next row
  2765. testfu1:mov    ax,ybot            ; get last scan line
  2766.     inc    ax            ; number of scan lines
  2767.     cmp    ax,y_coord        ; minus where char bottom needs to go
  2768.     jae    testfu3            ; ae = enough space for char
  2769.     call    tekbeep            ; tell the user we are waiting
  2770.     call    tiseof            ; EOF on redirected stdin?
  2771.     jc    testfu2            ; c = yes, proceed anyway
  2772.     mov    ah,coninq        ; read keyboad via DOS
  2773.     int    dos            ; wait for keystroke
  2774.     or    al,al            ; scan code being returned?
  2775.     jne    testfu2            ; ne = no
  2776.     mov    ah,coninq        ; clear away scan code too
  2777.     int    dos
  2778. testfu2:call    tekcls            ; clear the screen
  2779.     mov    x_coord,0
  2780.     mov    y_coord,0
  2781. testfu3:pop    ax            ; recover current character
  2782.     ret
  2783. testfull endp
  2784.       
  2785. ; TEKCLS routine to clear the screen.
  2786. ; Entry point tekcls1 clears screen without resetting current point.     
  2787. TEKCLS    PROC    NEAR
  2788.     cmp    flags.vtflg,tttek    ; regular Tek terminal?
  2789.     je    tekcls0            ; e = yes
  2790.     test    tekflg,1        ; Tek mode active yet?
  2791.     jnz    tekcls0            ; nz = yes
  2792.     ret                ; else ignore this call
  2793. tekcls0:mov    x_coord,0        ; starting text coordinates
  2794.     mov    y_coord,0
  2795.     mov    oldx,0            ; assumed cursor starting location
  2796.     mov    oldy,maxteky        ;  top right corner (Tek coord)
  2797.     mov    scalex,0        ; clear last plotted point (PC coord)
  2798.     mov    scaley,0
  2799.     mov    lastc,0            ; last parsed x,y coordinate
  2800.     mov    visible,0        ; make lines invisible
  2801.     mov    bypass,0        ; clear bypass condition
  2802.     mov    ttstate,offset tektxt    ; do displayable text
  2803.     mov    prestate,offset tektxt
  2804.  
  2805. tekcls1:push    ax            ; save registers
  2806.     push    cx
  2807.     mov    bl,ccode        ; save pixel op code
  2808.     push    bx
  2809.     cmp    graph_mode,hercules    ; Hercules?
  2810.     jne    tekclsw            ; ne = no
  2811.     call    hgraf            ; set Hercules board to Graphics mode
  2812.     jmp    tekcls7
  2813.  
  2814. tekclsw:cmp    graph_mode,wyse700    ; Wyse 700?
  2815.     jne    tekcls2            ; ne = no
  2816.     call    wygraf            ; set board to Graphics mode & cls
  2817.     jmp    tekcls7
  2818.  
  2819. tekcls2:mov    di,0            ; point to start of screen, di=row
  2820.     mov    ccode,pixbak        ; write in background
  2821.     call    psetup            ; setup graphics routine and es:di
  2822.     mov    cx,4000h        ; CGA, 200 lines times 80 bytes worth
  2823.     cmp    graph_mode,cga        ; cga?
  2824.     je    tekcls3            ; e = yes
  2825.     mov    cx,8000h        ; Olivetti, 400 lines times 80 bytes
  2826.     cmp    graph_mode,olivetti    ; AT&T-Olivetti?
  2827.     je    tekcls3            ; e = yes
  2828.     cmp    graph_mode,toshiba    ; Toshiba?
  2829.     je    tekcls3            ; e = yes
  2830.     cmp    graph_mode,vaxmate    ; VAXmate?
  2831.     jne    tekcls4            ; ne = no
  2832. tekcls3:cld                ; clear screen directly of text stuff
  2833.     xor    ax,ax
  2834.     test    gbcol,7            ; background is dark?
  2835.     jz    tekcls3a        ; z = yes
  2836.     mov    ax,0ffffh        ; light, set all pixels
  2837. tekcls3a:shr    cx,1            ; do words
  2838.     rep    stosw            ; clear the words
  2839.     jmp    short tekcls7
  2840.  
  2841. tekcls4:cmp    graph_mode,ega        ; EGA?
  2842.     je    tekcls5            ; e = yes
  2843.     cmp    graph_mode,monoega    ; EGA with mono display?
  2844.     je    tekcls5            ; e = yes
  2845.     cmp    graph_mode,colorega    ; EGA with medium resolution monitor?
  2846.     je    tekcls5            ; e = yes
  2847.     jmp    short tekcls6        ; else use Bios
  2848.  
  2849. tekcls5:                ; EGA clear screen quickly
  2850.     mov    ax,0ff08h        ; set all 8 bits to be changed
  2851.     call    ega_gc            ; set bit mask register accordingly
  2852.     mov    ax,0003h        ; data rotate reg, write unmodified
  2853.     call    ega_gc            ; 
  2854.     mov    cx,ybot            ; last scan line
  2855.     inc    cx            ; number of scan lines
  2856.     mov    ax,80/2            ; words (2*bytes) per scan line
  2857.     mul    cx
  2858.     mov    cx,ax            ; cx = number of bytes to clear
  2859.     call    fixcolor        ; fix colors first, if req'd
  2860.     mov    al,gbcol        ; select background colour
  2861.     mov    ah,al            ; copy for word stores
  2862.     cld
  2863.     rep    stosw            ; write backgound color
  2864.     jmp    short tekcls7
  2865.  
  2866. tekcls6:push    es            ; clear screen by scrolling up
  2867.     call    tcmblnk            ; clear screen, for Environments
  2868.     pop    es
  2869.  
  2870. tekcls7:xor    si,si            ; starting x  (in case screen is
  2871.     xor    di,di            ; starting y    cleared by user)
  2872.     pop    bx
  2873.     mov    ccode,bl        ; restore pixel op code
  2874.     pop    cx
  2875.     pop    ax
  2876.     ret
  2877. TEKCLS    ENDP
  2878.      
  2879. ; Routine to draw a line on the screen, using TEKTRONIX coordinates.
  2880. ; X coordinate in AX, 0=left edge of screen, 1023=right edge of screen.
  2881. ; Y coordinate in BX, 0=bottom of screen, 779=top of screen.
  2882. ; CL=0 - invisible move, else draw in foreground colors
  2883.      
  2884. TEKDRAW PROC NEAR
  2885.     mov    si,scalex        ; get old x already scaled
  2886.     mov    di,scaley        ; get old y already scaled
  2887.     call    scale             ; scale new end point to PC coords
  2888.     cmp    cl,0            ; invisible drawing?
  2889.     je    moveto            ; z = just move, skip draw part
  2890.     mov    cl,pixfor        ; draw in foreground color
  2891.     call    LINE            ; draw the line
  2892. moveto:    mov    x_coord,ax        ; update text coordinates to match
  2893.     mov    y_coord,bx        ;  last drawn point
  2894.     ret
  2895. TEKDRAW ENDP
  2896.      
  2897. ; Scale TEKTRONIX coordinates to the currently defined screen coordinates
  2898. ; AX holds X axis, BX holds Y axis. Both are changed from Tektronix coord
  2899. ; to PC coordinates by this procedure.
  2900. SCALE    PROC    NEAR
  2901.     push    dx
  2902.     push    si
  2903.     cmp    ax,1023            ; limit x axis
  2904.     jbe    scale1            ; be = not out of bounds
  2905.     mov    ax,1023
  2906. scale1:    cmp    bx,779            ; limit y axix
  2907.     jbe    scale2            ; be = not out of bounds
  2908.     mov    bx,779
  2909. scale2:    mov    oldx,ax            ; save current Tek x for next draw
  2910.     mov    oldy,bx            ; save current Tek y for next draw
  2911.     mul    xmult            ; scale x-coord
  2912.     mov    si,xdiv            ; get the divisor
  2913.     shr    si,1            ; halve it
  2914.     add    ax,si            ; add in - to round to nearest integer
  2915.     adc    dx,0
  2916.     div    xdiv
  2917.     push    ax
  2918.     mov    ax,bx
  2919.     mul    ymult            ; scale y-coord
  2920.     mov    si,ydiv            ; get divisor
  2921.     shr    si,1            ; halve it
  2922.     add    ax,si            ; add in - to round to nearest integer
  2923.     adc    dx,0
  2924.     div    ydiv
  2925.     mov    bx,ybot
  2926.     sub    bx,ax            ; put new Y in right reg
  2927.     jns    scale3            ; ns = not too far
  2928.     xor    bx,bx
  2929. scale3:    pop    ax            ; put new X in right reg
  2930.     mov    scalex,ax        ; save scaled values
  2931.     mov    scaley,bx
  2932.     pop    si
  2933.     pop    dx
  2934.     ret
  2935. SCALE    ENDP
  2936.       
  2937. ; LINE    Subroutine to plot a line with endpoints in AX,BX and SI,DI.
  2938. ;    fast line drawing routine for the IBM PC
  2939. ;
  2940. ; Registers at CALL
  2941. ; -----------------
  2942. ; SI=Start X coord, all in PC coordinates
  2943. ; DI=Start Y coord
  2944. ; AX=End X coord
  2945. ; BX=End Y coord
  2946. ; CCODE=pixel operation code
  2947. ; BP= line drawing pattern (is changed here by rotation)
  2948. ; registers are all unchanged
  2949.      
  2950. LINE    PROC    NEAR
  2951.     push    ax
  2952.     push    bx
  2953.     push    cx
  2954.     push    dx
  2955.     push    si
  2956.     push    di
  2957.     push    es
  2958.     mov    bp,linepat        ; store active line pattern word in BP
  2959.     mov    dl,ccode        ; existing pixel op code
  2960.     push    dx            ; save around line drawing
  2961.     mov    ccode,cl    ; save color code in ccode for use by plot()
  2962.             ; first get coord to achieve increasing x; deltax >= 0
  2963.     sub    ax,si            ; deltax = x2 - x1
  2964.     jge    line1            ; ge = going to the right, as desired
  2965.     neg    ax            ; make deltax non-negative
  2966.     sub    si,ax            ; swap the x coordinates
  2967.     xchg    bx,di            ; swap the y coordinates too
  2968.                 ; second, compute deltay. ax = deltax, si = x1
  2969. line1:    sub    bx,di            ; deltay = y2 - y1
  2970.     call    psetup            ; setup display adapter for plotting
  2971.                     ;  and setup es:di to screen memory
  2972.   ; Choose algorithm based on |deltay| < |deltax| (use shallow) else steep.
  2973.   ; We arrange matters such that both deltas are non-negative.
  2974.     cmp    bx,0            ; deltay
  2975.     jge    line2            ; ge = non-negative
  2976.     neg    linelen
  2977.     neg    bx            ; make non-negative
  2978. line2:    cmp    bx,ax            ; |deltay| versus |deltax|
  2979.     jbe    shallow            ; be = do shallow algorithm
  2980.     jmp    steep            ; else do steep algorithm
  2981.  
  2982.     ; shallow algorithm, move along x, di=y1, bx=deltay, si=x1, ax=deltax
  2983. shallow:add    bx,bx            ; bx = 2*deltay
  2984.     mov    cx,ax            ; cx = number of steps (deltax here)
  2985.     inc    cx            ; loop dec's cx before testing
  2986.     mov    dx,bx            ; dx holds error
  2987.     sub    dx,ax            ; error = 2*deltay - deltax
  2988.     add    ax,ax            ; ax = 2*|deltax|
  2989. shal1:    call    plotptr            ; Plot(x,y)
  2990.     cmp    dx,0
  2991.     jle    shal2            ; le =     error <= 0
  2992.     call    pincy            ; increment y by one scan line
  2993.     sub    dx,ax            ; error = error - 2*deltax
  2994. shal2:    add    dx,bx            ; error = error + 2*deltay
  2995.     inc    si            ; x = next dot right
  2996.     loop    shal1
  2997.     jmp    short plotex
  2998.  
  2999.     ; steep algorithm, move along y, di=y1, bx=deltay, si=x1, ax=deltax
  3000. steep:    add    ax,ax            ; ax = 2*deltax
  3001.     mov    dx,ax            ; dx holds error
  3002.     sub    dx,bx            ; error = 2*deltax(bx) - deltay (bx)
  3003.     mov    cx,bx            ; cx = number of steps (deltay here)
  3004.     inc    cx            ; loop dec's cx before testing
  3005.     add    bx,bx            ; bx = 2*|deltay|
  3006. stee1:    call    plotptr            ; Plot(x,y) x = ax, y = di
  3007.     cmp    dx,0
  3008.     jle    stee2            ; le  error <= 0
  3009.     inc    si            ; x = next dot right
  3010.     sub    dx,bx            ; error = error - 2*deltay
  3011. stee2:    add    dx,ax            ; error = error + 2*deltax
  3012.     call    pincy            ; increment y
  3013.     loop    stee1
  3014. ;;;    jmp    plotex
  3015.  
  3016. plotex:    pop    dx            ; al has orginal pixel op
  3017.     mov    ccode,dl        ; restore it
  3018.     pop    es
  3019.     pop    di
  3020.     pop    si
  3021.     pop    dx            ; restore the world
  3022.     pop    cx
  3023.     pop    bx
  3024.     pop    ax
  3025.     ret
  3026. LINE    ENDP
  3027.  
  3028. ; Draw a rectangle.
  3029. ;  lower left corner: x = param[0], y = param[2], Tek coordinates
  3030. ;  distance: dx = param[4], dy = param[6], Tek coordinates, all positive
  3031. rectdraw proc    near
  3032.     push    x_coord
  3033.     push    y_coord
  3034.     mov    ax,param[0]        ; lower left corner is start, x part
  3035.     mov    bx,param[2]        ; y part
  3036.     push    ax            ; x0
  3037.     push    bx            ; y0
  3038.     mov    cl,0            ; moveto
  3039.     call    tekdraw
  3040.     pop    bx
  3041.     pop    ax
  3042.     add    bx,param[6]        ; y0 + dy
  3043.     mov    cl,1            ; draw x0,y0  to  x0,y0+dy
  3044.     push    ax
  3045.     push    bx
  3046.     call    tekdraw
  3047.     pop    bx
  3048.     pop    ax
  3049.     add    ax,param[4]        ; x0+dx
  3050.     mov    cl,1            ; draw x0,y0+dy  to  x0+dx,y0+dy
  3051.     push    ax
  3052.     call    tekdraw
  3053.     pop    ax
  3054.     mov    bx,param[2]        ; y0
  3055.     push    bx
  3056.     mov    cl,1
  3057.     call    tekdraw
  3058.     pop    bx
  3059.     mov    ax,param[0]        ; x0
  3060.     mov    cl,1
  3061.     call    tekdraw            ; complete the box
  3062.     pop    y_coord
  3063.     pop    x_coord
  3064.     ret
  3065. rectdraw endp
  3066.  
  3067. ; Fill a rectangle with a given pattern.
  3068. ;  lower left corner: x = param[0], y = param[2], Tek coordinates
  3069. ;  distance: dx = param[4], dy = param[6], Tek coordinates, all positive
  3070. ;  fill pattern = param[8]
  3071. rectfil    proc    near
  3072.     push    oldx
  3073.     push    oldy            ; save regular point/line old coords
  3074.     mov    ax,param        ; get Tek X coord of lower left corner
  3075.     mov    bx,param[2]        ; get Tek Y coord
  3076.     call    scale            ; convert to PC in ax,bx, scalex/y
  3077.     mov    rectx1,ax        ; lower left corner in PC coords
  3078.     mov    recty1,bx
  3079.     mov    ax,param        ; convert ending points, start Tek X
  3080.     add    ax,param[4]        ; Tek X + DX
  3081.     mov    bx,param[2]        ; start Tek Y
  3082.     add    bx,param[6]        ; Tek Y + DY
  3083.     call    scale
  3084.     pop    oldy
  3085.     pop    oldx
  3086.     mov    rectx2,ax        ; upper right corner PC X coord
  3087.     mov    recty2,bx        ; upper right corner PC Y coord
  3088.     mov    si,rectx1        ; starting x PC coord to si
  3089.     mov    di,recty2        ; starting y PC coord to di
  3090.     mov    cx,recty1        ; plotting from top down on screen
  3091.     sub    cx,bx            ; cx = # scan lines - 1
  3092.     mov    numlines,cx        ; remember here
  3093.     mov    bx,param[8]        ; fill pattern number
  3094.     or    bx,bx            ; zero?
  3095.     jz    rectfi1            ; z = yes, use current pointer
  3096.     cmp    bx,numfil        ; pattern number is too large?
  3097.     ja    rectfi1            ; a = yes, use current pointer
  3098.     dec    bx            ; count internally from 0
  3099.     shl    bx,1            ; make this a word pointer
  3100.     mov    bx,fillist[bx]        ; get pointer to pattern
  3101.     mov    fillptr,bx        ; remember it here
  3102. rectfi1:mov    cx,rectx2        ; ending x coord
  3103.     sub    cx,rectx1        ; number of horizontal pixels - 1
  3104.     inc    cx            ; number of horizontal pixels
  3105.     call    psetup            ; set up dsp and di to screen offset
  3106.             ; di points to whole byte, do bits in byte in gfplot
  3107. rectfi2:push    bx
  3108.      mov    bx,recty1        ; lower screen y (larger value)
  3109.     sub    bx,numlines        ; alignment: global screen sync
  3110.     and    bx,7            ; modulo 8
  3111.     add    bx,fillptr        ; offset of fill pattern start
  3112.     mov    bl,[bx]            ; pattern byte
  3113.     mov    fill,bl            ; save here for gfplot
  3114.     pop    bx
  3115.     call    gfplot            ; line fill routine
  3116.     call    pincy            ; next line
  3117.     dec    numlines
  3118.     jns    rectfi2            ; ns = more to do
  3119.     ret
  3120. rectfil    endp
  3121.  
  3122. ;;;;;;; EGA plot support routines
  3123. psetupe    proc    near            ; EGA setup for plotting
  3124.     push    ax
  3125.     mov    linelen,80        ; for y going down screen by pincy
  3126.     mov    ax,segscn        ; set es to screen memory segment
  3127.     mov    es,ax
  3128.     mov    ax,0205h        ; mode: write mode 2
  3129.     call    ega_gc
  3130.     mov    ax,0003h        ; assume writing bits directly
  3131.     test    ccode,pixfor+pixbak    ; direct foreground/background write?
  3132.     jnz    psete2            ; nz = yes
  3133.     mov    ax,1003h        ; assume OR
  3134.     test    ccode,pixor        ; OR?
  3135.     jnz    psete2            ; nz = yes
  3136.     mov    ax,1803h        ; assume XOR
  3137.     test    ccode,pixxor        ; inverting bits?
  3138.     jnz    psete2            ; nz = yes
  3139.     mov    ax,0803h        ; then use AND
  3140. psete2:    call    ega_gc            ; set controller
  3141.     mov    ax,80            ; compute starting point in regen buff
  3142.     mul    di
  3143.     mov    di,ax            ; di = di * 80
  3144.     pop    ax
  3145.     ret
  3146. psetupe    endp
  3147.  
  3148. pincye    proc    near            ; EGA inc y
  3149.     add    di,linelen        ; includes sign of deltay
  3150.     ret
  3151. pincye    endp
  3152.  
  3153. pltega    proc    near        ; EGA plot(x,y). x is in si, y is in di
  3154.     ror    bp,1            ; rotate line pattern
  3155.     jc    pltega1            ; c = a 1 bit to be plotted
  3156.     cmp    ccode,pixfor+pixbak    ; plot both 1's and 0's?
  3157.     je    pltega1            ; e = yes
  3158.     ret                ; else ignore the 0 bit
  3159. pltega1:push    bx
  3160.     push    si
  3161.     push    di
  3162.     mov    bx,si            ; want si/8 for bytes along line
  3163.     shr    si,1
  3164.     shr    si,1
  3165.     shr    si,1
  3166.     add    di,si            ; starting point in regen buffer
  3167.     and    bx,0007h        ; leave lower 3 bits for bit in byte
  3168.     mov    bh,masktab[bx]        ; 0-7 into bit mask in byte, x pos
  3169.     mov    bl,ccode        ; get line type code
  3170.     call    ega_plt
  3171.     pop    di
  3172.     pop    si
  3173.     pop    bx
  3174.     ret
  3175. pltega    endp
  3176.  
  3177. ; Plot bit pattern in "fill" as 8 horizontal pixels, starting at x,y (si,di)
  3178. ; and continuing across the line for cx pixels. psetupe has been called.
  3179. bpltega    proc    near        ; EGA plot(x,y). x is in si, y is in di
  3180.     push    bx
  3181.     push    cx
  3182.     push    si
  3183.     push    di
  3184.     mov    bx,si            ; want si/8 for bytes along line
  3185.     shr    si,1
  3186.     shr    si,1
  3187.     shr    si,1
  3188.     add    di,si            ; starting byte in regen buffer
  3189.                     ; di = offset in regen buffer
  3190.     and    bl,7            ; get bit in byte (di = byte aligned)
  3191.     jz    bplteg1            ; z = aligned already
  3192.     xchg    bl,cl            ; get shift to cl, low count to bl
  3193.     mov    bh,fill            ; 8-bit fill pattern
  3194.     mov    al,bh            ; get complement of pattern too
  3195.     not    al
  3196.     shl    bh,cl            ; trim cl bits from the left
  3197.     shr    bh,cl
  3198.     shl    al,cl            ; trim them from the right edge
  3199.     shr    al,cl            ; restore pattern
  3200.     xchg    cl,bl            ; put count back in cx
  3201.     add    cl,bl            ; add bits taken care of
  3202.     adc    ch,0
  3203.     jmp    short bplteg2        ; do this partial byte now
  3204.  
  3205. bplteg1:mov    bh,fill            ; fill pattern
  3206.     mov    al,bh            ; make inverted pattern
  3207.     not    al
  3208.     cmp    cx,8            ; do all 8 bits?
  3209.     jae    bplteg2            ; ae = yes
  3210.     push    cx            ; final byte fixup
  3211.     sub    cl,8            ; cl = - (number of bits to omit)
  3212.     neg    cl            ; cl = number of bits to omit
  3213.     mov    al,bh            ; get complement of pattern too
  3214.     not    al
  3215.     shr    bh,cl            ; trim them from the right edge
  3216.     shl    bh,cl            ; restore pattern
  3217.     shr    al,cl            ; trim them from the right edge
  3218.     shl    al,cl            ; restore pattern
  3219.     pop    cx
  3220. bplteg2:push    ax
  3221.     cmp    ccode,pixfor+pixbak    ; do both fore and background?
  3222.     jne    bplteg2a        ; ne = no
  3223.     push    bx
  3224.     mov    bh,al            ; get complemented pattern
  3225.     mov    bl,pixbak        ; write background
  3226.     call    ega_plt
  3227.     pop    bx
  3228. bplteg2a:mov    bl,ccode        ; get line type code
  3229.     call    ega_plt
  3230. bplteg3:pop    ax
  3231.     inc    di            ; next byte right
  3232.     sub    cx,8            ; did these
  3233.     cmp    cx,0            ; anything left to do?
  3234.     jg    bplteg1            ; a = yes, repeat
  3235.     pop    di
  3236.     pop    si
  3237.     pop    cx
  3238.     pop    bx
  3239.     ret
  3240. bpltega    endp
  3241.  
  3242. ;;;;;;;; CGA plot support routines
  3243. ; The CGA graphics memory mapping in mode 6 (640 by 200) is 8 dots per byte,
  3244. ; left most dot in the high bit, 80 bytes per scan line, scan line segments
  3245. ; alternating between 0b800h (even lines 0, 2, ...) and 0ba00h (odd lines).
  3246. psetupc    proc    near            ; CGA setup for plotting
  3247.     push    ax
  3248.     push    cx
  3249.     mov    linelen,80        ; 80 bytes per scan line
  3250.     mov    cx,segscn
  3251.     mov    es,cx
  3252.     mov    cx,di            ; save copy of di, start y line
  3253.                     ; compute starting point in regen buff
  3254.     shr    di,1            ; half the lines in each bank
  3255.     mov    ax,80            ; 80 bytes per line
  3256.     mul    di
  3257.     mov    di,ax            ; di = di * 80 / 2
  3258.     test    cx,1            ; even or odd line
  3259.     jz    psetc1            ; z = even
  3260.     add    di,2000h        ; offset to odd bank (seg 0ba00h)
  3261. psetc1:    and    di,3fffh
  3262.     pop    cx
  3263.     pop    ax
  3264.     ret
  3265. psetupc    endp
  3266.  
  3267. pincyc    proc    near            ; CGA inc y
  3268.     cmp    linelen,0        ; increasing or decreasing y?
  3269.     jl    pinyc2            ; l = decreasing
  3270.     cmp    di,2000h        ; in upper bank now?
  3271.     jb    pinyc1            ; b = no, in lower bank
  3272.     add    di,linelen        ; add a line
  3273. pinyc1:    add    di,2000h        ; switch banks
  3274.     and    di,3fffh        ; roll over address
  3275.     ret
  3276. pinyc2:    cmp    di,2000h        ; in upper bank now?
  3277.     jae    pinyc4            ; ae = yes
  3278.     add    di,linelen        ; subtract a line
  3279. pinyc4:    add    di,2000h        ; switch banks
  3280.     and    di,3fffh        ; roll over address
  3281.     ret
  3282. pincyc    endp
  3283.  
  3284. pltcga    proc    near        ; CGA plot(x,y). x is in si, y is in di
  3285.     push    bx        ; used for HGA and Wyse plots also.
  3286.     push    si
  3287.     push    di
  3288.     ror    bp,1            ; rotate line pattern
  3289.     jc    pltcg6            ; c = 1 bit to be plotted
  3290.     cmp    ccode,pixfor+pixbak    ; plot both 1's and 0's?
  3291.     jne    pltcg3            ; ne = no
  3292.  
  3293. pltcg6:    mov    bx,si            ; want si/8 for bytes along line
  3294.     shr    si,1
  3295.     shr    si,1
  3296.     shr    si,1
  3297.     add    di,si            ; starting point in regen buffer
  3298.     and    bx,0007h        ; leave lower 3 bits for bit in byte
  3299.                     ; di = offset in regen buffer
  3300.     mov    bh,masktab[bx]        ; 0-7 into bit mask in byte. x position
  3301.     mov    bl,ccode        ; get line type code
  3302.     test    bl,pixfor+pixor        ; draw in foreground color or OR?
  3303.     jz    pltcg1            ; z = no
  3304.     test    bl,pixor        ; OR?
  3305.     jnz    pltcg5            ; nz = yes
  3306.     test    gfcol,7            ; is foreground dark?
  3307.     jz    pltcg4            ; z = yes, punch a hole
  3308. pltcg5:    or    es:[di],bh        ; drawn
  3309.     jmp    short pltcg3
  3310. pltcg1:    test    bl,pixbak        ; draw in background (erase)?
  3311.     jz    pltcg2            ; z = no
  3312.     test    gbcol,7            ; is background light?
  3313.     jnz    pltcg5            ; nz = yes
  3314. pltcg4:    not    bh            ; invert the bit
  3315.     and    es:[di],bh        ; erase the dot
  3316.     jmp    short pltcg3
  3317. pltcg2:    xor    es:[di],bh        ; xor in this color
  3318. pltcg3:    pop    di
  3319.     pop    si
  3320.     pop    bx
  3321.     ret
  3322. pltcga    endp
  3323.  
  3324. ; Plot bit pattern in fill as 8 horizontal pixels, starting at x,y (si,di)
  3325. ; and continuing across the line for cx pixels. psetupc has been called.
  3326. bpltcga    proc    near        ; CGA plot(x,y). x is in si, y is in di
  3327.     push    bx        ; used for HGA and Wyse plots also.
  3328.     push    cx
  3329.     push    si
  3330.     push    di
  3331.     mov    bx,si            ; want si/8 for bytes along line
  3332.     shr    si,1
  3333.     shr    si,1
  3334.     shr    si,1
  3335.     add    di,si            ; starting byte in regen buffer
  3336.                     ; di = offset in regen buffer
  3337.     and    bl,7            ; get bit in byte (di = byte aligned)
  3338.     jz    bpltcg5            ; z = aligned already
  3339.     xchg    bl,cl            ; get shift to cl, low count to bl
  3340.     mov    bh,fill            ; 8-bit fill pattern
  3341.     mov    al,bh            ; get complement of pattern too
  3342.     not    al
  3343.     shl    bh,cl            ; trim cl bits from the left
  3344.     shr    bh,cl
  3345.     shl    al,cl            ; trim them from the right edge
  3346.     shr    al,cl            ; restore pattern
  3347.     xchg    cl,bl            ; put count back in cx
  3348.     add    cl,bl            ; add bits taken care of
  3349.     adc    ch,0
  3350.     jmp    short bpltcg4        ; do this partial byte now
  3351.  
  3352. bpltcg5:mov    bh,fill            ; fill pattern
  3353.     mov    al,bh            ; make inverted pattern
  3354.     not    al
  3355.     cmp    cx,8            ; do all 8 bits?
  3356.     jae    bpltcg4            ; ae = yes
  3357.     push    cx            ; final byte fixup
  3358.     sub    cl,8            ; cl = - (number of bits to omit)
  3359.     neg    cl            ; cl = number of bits to omit
  3360.     mov    al,bh            ; get complement of pattern too
  3361.     not    al
  3362.     shr    bh,cl            ; trim them from the right edge
  3363.     shl    bh,cl            ; restore pattern
  3364.     shr    al,cl            ; trim them from the right edge
  3365.     shl    al,cl            ; restore pattern
  3366.     pop    cx
  3367. bpltcg4:mov    bl,ccode        ; get line type code
  3368.     test    bl,pixfor+pixor        ; draw in foreground?
  3369.     jz    bpltcg1            ; z = no
  3370.     test    bl,pixor        ; OR?
  3371.     jnz    bpltcg7            ; nz = yes
  3372.     test    gfcol,7            ; is foreground dark?
  3373.     jz    bpltcg6            ; z = yes, punch a hole
  3374. bpltcg7:or    es:[di],bh        ; drawn
  3375.     jmp    short bpltcg3
  3376. bpltcg1:test    bl,pixbak        ; draw as background (erase)?
  3377.     jz    bpltcg2            ; z= do not draw as background (erase)
  3378.     test    gbcol,7            ; is background light?
  3379.     jnz    bpltcg7            ; nz = yes
  3380. bpltcg6:not    bh
  3381.     and    es:[di],bh        ; erase the dots
  3382.     jmp    short bpltcg3
  3383. bpltcg2:xor    es:[di],bh        ; xor in this color
  3384. bpltcg3:inc    di            ; next byte right
  3385.     sub    cx,8            ; did these
  3386.     cmp    cx,0            ; anything left to do?
  3387.     jg    bpltcg5            ; a = yes, repeat
  3388.     pop    di
  3389.     pop    si
  3390.     pop    cx
  3391.     pop    bx
  3392.     ret
  3393. bpltcga    endp
  3394.  
  3395. ;;;;;;; Wyse-700 plot support routines
  3396. ; The Wyse graphics memory map in mode 0D3h (1280 by 800) is 8 dots per byte,
  3397. ; left most dot in the high bit, 160 bytes per scan line, scan line segments
  3398. ; sequence as 0a000h even lines, and same for odd lines
  3399. psetupw proc    near            ; Wyse setup for plotting
  3400.     push    ax
  3401.     push    cx
  3402.     push    dx
  3403.     mov    linelen,160        ; for y going down screen by incy
  3404.     mov    ax,segscn        ; base segment of display memory
  3405.     mov    es,ax
  3406.     mov    cx,di            ; save copy of di, start y line
  3407.                     ; compute starting point in regen buff
  3408.     shr    di,1            ; half the lines in each bank
  3409.     mov    ax,160
  3410.     mul    di
  3411.     mov    di,ax            ; di = di * 160 / 2
  3412.     mov    dx,wymode
  3413.     shr    cx,1            ; compute bank from 1 lsb of line num
  3414.     jnc    psetw2            ; nc = it is in bank 0 (0b000h)
  3415.     mov    ax,wybodd        ; select odd bank
  3416.     out    dx,al
  3417.     jmp    short psetw3
  3418. psetw2: mov    ax,wybeven        ; select even bank
  3419.     out    dx,al
  3420. psetw3: mov    bnkchan, al        ; bank has changed
  3421.     pop    dx
  3422.     pop    cx
  3423.     pop    ax
  3424.     ret
  3425. psetupw endp
  3426.  
  3427. ;
  3428. ; Wyse-700 has two banks. Line 0, 2, 4 ... are in bank 0, and 1, 3, 5 ... are
  3429. ; in bank 1. Lines 0 and 1 have same addresses, lines 2 and 3 have same
  3430. ; addresses etc. We have to change bank every time Y changes but we
  3431. ; have to count new address only after two Y-value changes. Variable
  3432. ; bnkchan is a flag for us to know into which bank to write.
  3433. ;
  3434. pincyw    proc    near            ; Wyse inc y, step offset of line
  3435.     push    ax
  3436.     push    dx
  3437.     mov    dx,wymode        ; Wyse conrol register
  3438.     mov    al,wybeven        ;
  3439.     cmp    bnkchan,wybeven        ; was last write into even bank ?
  3440.     jne    pincywe            ; ne = no
  3441.     mov    al,wybodd        ; yes, set ready for odd bank
  3442.     out    dx,al            ;
  3443.     mov    bnkchan,al        ; set to odd
  3444.     jmp    short pincywo
  3445. pincywe:mov    al,wybeven        ; set ready foe even bank
  3446.     out    dx,al            ; select it
  3447.     mov    bnkchan,al        ; set to odd
  3448. pincywo:cmp    linelen,0        ; increasing y?
  3449.     jg    pinyw2            ; g = yes
  3450.     cmp    al,wybeven        ; from high (1) to low (0) bank ?
  3451.     je    pinyw4            ; e = yes
  3452.     add    di,linelen        ; no, add a line
  3453.     jmp    short pinyw4
  3454. pinyw2: cmp    al,wybodd        ; from low (0) to high (1) bank ?
  3455.     je    pinyw4            ; e = yes
  3456.     add    di,linelen        ; no, add a line
  3457. pinyw4: and    di,0ffffh        ; roll over address
  3458.     pop    dx
  3459.     pop    ax
  3460.     ret
  3461. pincyw    endp
  3462.  
  3463. ;;;;;;; HGA plot support routines
  3464. ; The HGA graphics memory mapping in mode 255 (720 by 348) is 8 dots per byte,
  3465. ; left most dot in the high bit, 90 bytes per scan line, scan line segments
  3466. ; sequence as 0b000h, 0b200h, 0b400h, 0b800h for lines 0-3 and repeat 90 bytes
  3467. ; higher for the rest.
  3468. psetuph    proc    near            ; HGA setup for plotting
  3469.     push    ax
  3470.     push    cx
  3471.     mov    linelen,90        ; for y going down screen by incy
  3472.     mov    ax,segscn        ; base segment of display memory
  3473.     mov    es,ax
  3474.     mov    cx,di            ; save copy of di, start y line
  3475.                     ; compute starting point in regen buff
  3476.     shr    di,1            ; quarter the lines in each bank
  3477.     shr    di,1
  3478.     mov    ax,90
  3479.     mul    di
  3480.     mov    di,ax            ; di = di * 90 / 4
  3481.     and    cx,3            ; compute bank from 2 lsb of line num
  3482.     jcxz    pseth2            ; z means it is in bank 0 (0b000h)
  3483. pseth1:    add    di,2000h        ; add offset for each bank
  3484.     loop    pseth1            ; do cx times
  3485. pseth2:    pop    cx
  3486.     pop    ax
  3487.     ret
  3488. psetuph    endp
  3489.  
  3490. pincyh    proc    near            ; HGA inc y, step offset of line
  3491.     cmp    linelen,0        ; increasing y?
  3492.     jg    pinyh2            ; g = yes
  3493.     cmp    di,2000h        ; in lowest for four banks?
  3494.     ja    pinyh1            ; a = no
  3495.     add    di,linelen        ; yes, add a line
  3496. pinyh1:    add    di,6000h        ; move back by adding a lot
  3497.     and    di,7fffh        ; roll over address
  3498.     ret
  3499. pinyh2:    cmp    di,6000h        ; in top most bank?
  3500.     jb    pinyh4            ; b = no
  3501.     add    di,linelen        ; yes, first add a line
  3502. pinyh4:    add    di,2000h        ; switch to next bank
  3503.     and    di,7fffh        ; roll over address
  3504.     ret
  3505. pincyh    endp
  3506.  
  3507. ;;;;;;; AT&T-Olivetti, Toshiba, VAXmate Graphics Adapter plot support routines
  3508. ; The graphics memory mapping in 640 by 400 mode is 8 dots per byte,
  3509. ; left most dot in the high bit, 80 bytes per scan line, scan line segments
  3510. ; sequence as 0b800h, 0ba00h, 0bc00h, 0be00h for lines 0-3 and repeat 80 bytes
  3511. ; higher for the rest. Use Hercules line incrementing (inc y) and CGA dot
  3512. ; writing. This is a monographic display.
  3513. psetupo    proc    near            ; setup for plotting
  3514.     push    ax
  3515.     push    cx
  3516.     mov    linelen,80        ; for y going down screen by incy
  3517.     mov    ax,segscn        ; base segment of display memory
  3518.     mov    es,ax
  3519.     mov    cx,di            ; save copy of di, start y line
  3520.                     ; compute starting point in regen buff
  3521.     shr    di,1            ; quarter the lines in each bank
  3522.     shr    di,1
  3523.     mov    ax,80
  3524.     mul    di
  3525.     mov    di,ax            ; di = di * 80 / 4
  3526.     and    cx,3            ; compute bank from 2 lsb of line num
  3527.     jcxz    pseto2            ; z means it is in bank 0 (0b800h)
  3528. pseto1:    add    di,2000h        ; add offset for each bank
  3529.     loop    pseto1            ; do cx times
  3530. pseto2:    pop    cx
  3531.     pop    ax
  3532.     ret
  3533. psetupo    endp
  3534.  
  3535. ;;;;;;;; Monochrome, simulate dots with text char
  3536. psetupm    proc    near
  3537.     mov    linelen,1        ; 80 characters but one line
  3538.     ret
  3539. psetupm    endp
  3540.  
  3541. pltmon    proc    near            ; Monochrome dot plot
  3542.     mov    x_coord,si        ; put dot at row=di, col=si, PC Coord
  3543.     mov    y_coord,di
  3544.     push    ax
  3545.     mov    al,'+'            ; our dot character
  3546.     call    mputc            ; display text char
  3547.     pop    ax
  3548.     ret
  3549. pltmon    endp
  3550.  
  3551. ; Plot bit pattern in fill as 8 horizontal pixels, starting at x,y (si,di)
  3552. ; and continuing across the line for cx pixels. Destroys CX.
  3553. bpltmon    proc    near        ; Mono plot(x,y). x is in si, y is in di
  3554.     jmp    pltmon        ; a dummy for the present
  3555. bpltmon    endp
  3556.  
  3557. pincym    proc    near            ; Monochrome inc y
  3558.     add    di,linelen        ; includes sign
  3559.     ret
  3560. pincym    endp
  3561.  
  3562. ; GPUTC - a routine to send text characters from font to true graphics boards
  3563. ; such as EGA, Hercules or CGA. Char is in al. Drawing routine ptr is gcplot.
  3564.      
  3565. gputc    proc    near
  3566.     cmp    al,' '            ; control character or space?
  3567.     ja    gputc1            ; a = no, display the char
  3568.     jmp    putctrl            ; else handle controls at putctrl
  3569. gputc1:    push    ax            ; first save some registers
  3570.     push    bx
  3571.     push    cx
  3572.     push    es
  3573.     push    di
  3574.      mov    bl,al            ; now BL has char to be displayed
  3575.     and    bl,7fh            ; no high bits allowed here
  3576.                     ; set board mode
  3577.     mov    di,y_coord        ; get current y coord (char bottom)
  3578.     sub    di,7            ; start 7 lines higher
  3579.     jnc    gputc2            ; nc = ok
  3580.     xor    di,di            ; move up to first line
  3581.     mov    y_coord,7        ; and reset scan line indicator
  3582. gputc2:    call    psetup    ; enter with di=line number, sets es:di to start of
  3583.             ; line in regen buffer and sets byte-wide plot mode
  3584.     mov    ax,x_coord        ; compute regen buffer byte
  3585.     shr    ax,1            ; want x_coord/8 for bytes along line
  3586.     shr    ax,1
  3587.     shr    ax,1
  3588.     add    di,ax            ; byte in regen buffer
  3589.     xor    bh,bh
  3590.     sub    bx,32            ; characters in font start at 32
  3591.     shl    bx,1
  3592.     shl    bx,1            ; 8 bytes per char, hence * 8
  3593.     shl    bx,1
  3594.     mov    cx,8            ; 8 bytes (scan lines) to transfer
  3595.     call    gcplot            ; call character plot routine
  3596.     call    incx            ; move to next char position
  3597.     pop    di
  3598.     pop    es
  3599.     pop    cx
  3600.     pop    bx
  3601.     pop    ax
  3602.     ret
  3603. gputc    endp
  3604.  
  3605. putctrl    proc    near            ; CONTROL CHARS = cursor movement     
  3606.     push    ax            ; save character
  3607.     cmp    al,FF            ; formfeed?
  3608.      jne    putct0            ; ne = no
  3609.     call    TEKCLS            ; FF clears the screen
  3610.     jmp    putctx
  3611. putct0:    cmp    al,BS            ; BS? sends (logical) cursor back one
  3612.     jne    putct2            ; ne = no, try next
  3613.     sub    x_coord,8        ; delete 8 dots (move left)
  3614.     jnc    putct1            ; nc = ok
  3615.     mov    x_coord,0        ; limit to left margin
  3616. putct1:    cmp    bscontrol,0        ; non-destructive backspace?
  3617.     je    putctx            ; e = yes
  3618.     push    x_coord
  3619.     mov    ah,ccode
  3620.     push    ax
  3621.     mov    ccode,pixbak        ; write in background
  3622.     mov    al,7fh            ; do all dots in background
  3623.     call    putc
  3624.     pop    ax
  3625.     mov    ccode,ah
  3626.     pop    x_coord            ; restore cursor
  3627.     jmp    short putctx
  3628. putct2:    cmp    al,TAB            ; tabs move forward one char position
  3629.     jne    putct4            ; ne = not a tab
  3630.     call    incx            ; let incx move cursor right one col
  3631.     jmp    putctx
  3632. putct4:    cmp    al,CR            ; <CR> means go to beginning of line
  3633.     jne    putct5
  3634.     mov    x_coord,0        ; zero the x coordinate
  3635.     jmp    putctx
  3636. putct5:    cmp    al,LF            ; <LF> means go down 8 pixels (1 line)
  3637.     jne    putct7            ; ne = not LF
  3638.     add    y_coord,8        ; border managed by outscrn and incx
  3639.     jmp    putctx
  3640. putct7:    cmp    al,VT            ; <VT> move up screen 1 line (8 pixels)
  3641.     jne    putct8
  3642.     sub    y_coord,8        ; subtract one line (8 pixels)
  3643.     jnc    putctx            ; nc = space left
  3644.     mov    y_coord,8        ; else set to top of screen
  3645.     jmp    short putctx
  3646.  
  3647. putct8:    cmp    al,' '            ; space?
  3648.     jne    putctx            ; ne = no
  3649.     cmp    spcontrol,0        ; non-destructive space?
  3650.     je    putct8a            ; e = yes
  3651.     mov    ah,ccode
  3652.     push    ax
  3653.     mov    ccode,pixbak        ; write in background
  3654.     mov    al,07fh            ; do all dots in background
  3655.     call    putc
  3656.     pop    ax
  3657.     mov    ccode,ah
  3658.     jmp    short putctx
  3659. putct8a:call    testfull        ; check on full screen
  3660.     call    incx
  3661. putctx:    pop    ax
  3662.     ret
  3663. putctrl    endp
  3664.  
  3665. mputc    proc    near            ; MONO put char in AL via Bios
  3666.     push    ax            ; updates x_coord,y_coord with
  3667.     push    bx            ; new cursor position
  3668.     push    cx
  3669.     push    dx
  3670.     xor    ah,ah            ; marker for cursor setting not needed
  3671.     cmp    al,' '            ; control code?
  3672.     jae    mputc1            ; ae = no, printable
  3673.     call    putctrl            ; do cursor arithmetic
  3674.     mov    ah,1            ; marker to set cursor but no display
  3675.  
  3676. mputc1:    push    ax            ; save char and marker
  3677.     mov    cl,3            ; char cell is 8 x 8 dots
  3678.     mov    ax,x_coord        ; get resulting cursor PC positions
  3679.     shr    ax,cl
  3680.     mov    dl,al            ; column
  3681.     mov    ax,y_coord
  3682.     sub    ax,7            ; minus 7 dots, like other modes
  3683.     jnc    mputc2            ; nc = non-negative
  3684.     mov    ax,7            ; else start at the top
  3685.     mov    y_coord,ax        ; here too
  3686. mputc2:    shr    ax,cl
  3687.     mov    dh,al            ; row
  3688.     mov    ah,2            ; set cursor to x_coord,y_coord
  3689.     xor    bh,bh            ; page 0
  3690.     int    screen
  3691.     pop    ax
  3692.     or    ah,ah            ; write a char in al?
  3693.     jnz    mputcx            ; nz = no
  3694.     mov    ah,09h            ; write char at cursor postion
  3695.     mov    cx,1            ; just one char
  3696.     xor    bh,bh            ; page 0
  3697.     mov    bl,gfcol        ; foreground coloring
  3698.     int    screen
  3699.     inc    dl            ; next column
  3700.     mov    ah,2            ; set real cursor ahead of last char
  3701.     int    screen
  3702.     call    incx            ; move logical cursor
  3703. mputcx:    pop    dx
  3704.     pop    cx
  3705.     pop    bx
  3706.     pop    ax
  3707.     ret
  3708. mputc    endp
  3709.  
  3710. incx    proc    near            ; move the logical cursor right
  3711.     mov    ax,xmax
  3712.     add    ax,8            ; last column+1
  3713.     cmp    ax,x_coord        ; beyond right most column?
  3714.     jae    incx1            ; ae = no
  3715.     mov    x_coord,ax        ; set up for wrap
  3716.     ret
  3717. incx1:    add    x_coord,8        ; shift the (logical) cursor right
  3718.     ret                ;  one character cell
  3719. incx    endp
  3720.  
  3721. ; EGA Character plot routine. Enter with bx pointing at font array for char
  3722. ; cx = number of bytes in char font, es:di = screen memory. Worker for gputc.
  3723. ; ccode: pixbak=plot in backgrd colors, pixfor=foregrd, pixxor=xor with screen
  3724. gcega    proc    near
  3725. gcega1:    mov    al,font[bx]        ; EGA byte plot: get bits from font
  3726.     push    bx
  3727.     cmp    chcontrol,0        ; transparent char writing?
  3728.     je    gcega2            ; e = yes
  3729.     mov    bh,0ffh            ; write these bits to clear field
  3730.     mov    bl,pixbak        ; in background coloring
  3731.     call    ega_plt            ; plot a byte
  3732. gcega2:    mov    bh,al            ; set bit pattern of character
  3733.     mov    bl,ccode        ; plot in back/fore/xor (ccode) colors
  3734.     call    ega_plt            ; byte plot routine for EGA systems
  3735.     pop    bx
  3736.     inc    bx            ; next byte of char pattern
  3737.     call    pincy            ; next scan line (linelen is preset)
  3738.     loop    gcega1
  3739.     ret
  3740. gcega    endp
  3741.  
  3742. ; General Character plot routine. Enter with bx pointing at font array for
  3743. ; char, cx = number of bytes in char font, es:di = screen memory.
  3744. ; Worker for gputc.
  3745.  
  3746. gcgen    proc    near
  3747. gcgen1:    mov    al,font[bx]        ; Non-EGA systems: get bits from font
  3748.     cmp    ccode,pixfor+pixbak    ; write both fore and back?
  3749.     jne    gcgen2            ; ne = no
  3750.     cmp    gfcol,0            ; is foreground dark?
  3751.     jne    gcgen1            ; ne = yes
  3752.     not    al            ; invert bits
  3753. gcgen1a:mov    es:[di],al        ; write bits directly
  3754.     jmp    short gcgen5
  3755. gcgen2:    test    ccode,pixfor+pixor    ; OR or write in foreground?
  3756.     jz    gcgen3            ; z = no
  3757.     not    al
  3758.     and    es:[di],al        ; clear bits to be written
  3759.     cmp    gfcol,0            ; is foreground dark?
  3760.     je    gcgen5            ; e = yes, done
  3761.     not    al
  3762.     or    es:[di],al        ; insert bits
  3763.     jmp    short gcgen5
  3764. gcgen3:    test    ccode,pixxor        ; XOR?
  3765.     jz    gcgen5            ; z = no
  3766.     xor    es:[di],al
  3767.     jmp    short gcgen5
  3768. gcgen4:    not    al            ; background write
  3769.     and    es:[di],al        ; clear bits
  3770.     cmp    gbcol,0            ; is background dark?
  3771.     je    gcgen5            ; e = yes
  3772.     not    al
  3773.     or    es:[di],al        ; write light bits
  3774. gcgen5:    inc    bx            ; point to next byte of char pattern
  3775.     call    pincy            ; next scan line (linelen is preset)
  3776.     loop    gcgen1            ; and repeat until complete
  3777.     ret
  3778. gcgen    endp
  3779.  
  3780. ; routines to manipulate ega graphics controller and mode register
  3781. ; command code in al, value in ah - destroys al and dx
  3782.      
  3783. ega_gc    proc    near            ; ega graphics controller
  3784.     mov    dx,3ceh
  3785.     out    dx,al            ; output command code
  3786.     inc    dx            ; dx is now data port
  3787.     mov    al,ah            ; get value to al
  3788.     out    dx,al            ; output value
  3789.     ret
  3790. ega_gc    endp
  3791. ega_md    proc    near            ; ega mode controller
  3792.     mov    dx,3c4h
  3793.     out    dx,al            ; output command code
  3794.     inc    dx            ; dx is now data port
  3795.     mov    al,ah            ; get value to al
  3796.     out    dx,al            ; output value
  3797.     ret
  3798. ega_md endp
  3799.      
  3800. ; Plot eight pixels using an EGA board
  3801. ; Enter with ES:[DI] pointing to screen address of byte,
  3802. ; bh has pattern of bits to be set, bl has attributes:
  3803. ;  pixbak = draw in background color, pixfor = draw in foreground color,
  3804. ;  pixor = OR with foreground color, pixxor = XOR with foreground color.
  3805. ; registers preserved
  3806. ; Note: this function operates on 8 pixels. One bits in bh select pixels to
  3807. ; be changed, bl determines which color planes will be affected for every
  3808. ; selected pixel.
  3809. ega_plt proc    near
  3810.     push    ax
  3811.     push    dx
  3812.     mov    dx,3ceh            ; (ega_gc) unprotect the bit positions
  3813.     mov    al,8            ; command to set bit mask register
  3814.     out    dx,al            ; output command code
  3815.     inc    dx            ; dx is now data port
  3816.     mov    al,bh            ; get pixels to be modified (1's)
  3817.     out    dx,al            ; output value (end of ega_gc)
  3818.     pop    dx
  3819.  
  3820.     mov    ah,gfcol        ; foreground color bit planes
  3821. ega1:    test    bl,pixfor+pixor        ; write foreground or OR?
  3822.     jnz    ega3            ; nz = yes
  3823.     mov    ah,gbcol        ; background color bit planes
  3824.     test    bl,pixbak        ; write in background coloring?
  3825.     jnz    ega3            ; nz = yes
  3826.     mov    ah,0fh            ; xor, touch each bit plane
  3827. ega3:    mov    al,es:[di]        ; latch byte
  3828.     mov    es:[di],ah        ; merge with untouched bits
  3829.     pop    ax
  3830.     ret
  3831. ega_plt endp
  3832.  
  3833. ; Presence test for Wyse-700: info in B000h and B800h are supposed to be equal
  3834. chkwyse    proc    near
  3835.     push    es
  3836.     push    ds
  3837.     mov    ax,0b800h        ; CGA segment
  3838.     mov    es,ax
  3839.     mov    ax,0b000h        ; Mono segment
  3840.     mov    ds,ax
  3841.     mov    ch,byte ptr es:[0]    ; CGA seg
  3842.     mov    cl,byte ptr ds:[0]    ; Mono seg
  3843.     push    cx            ; save original contents
  3844.     mov    byte ptr ds:[0],ch    ; copy CGA to Mono
  3845.     cmp    byte ptr ds:[0],ch    ; if different then not Wyse
  3846.     jne    chkwys1            ; ne = not Wyse
  3847.     not    byte ptr es:[0]        ; change CGA contents
  3848.     not    ch            ; and original pattern
  3849.     cmp    ch,byte ptr ds:[0]    ; if different then not Wyse
  3850.     jne    chkwys1            ; ne = not Wyse
  3851.     pop    cx
  3852.     mov    byte ptr es:[0],ch    ; restore CGA
  3853.     mov    byte ptr ds:[0],cl    ; restore Mono
  3854.     pop    ds
  3855.     pop    es
  3856.     clc
  3857.     ret
  3858.  
  3859. chkwys1:pop    cx
  3860.     mov    byte ptr es:[0],ch    ; restore CGA
  3861.     mov    byte ptr ds:[0],cl    ; restore Mono
  3862.     pop    ds
  3863.     pop    es
  3864.     stc
  3865.     ret
  3866. chkwyse    endp
  3867. ;
  3868. ; routine to set Wyse-700 board to graphics mode - 1280 * 800 & cls
  3869. ;
  3870. WYGRAF    PROC    NEAR
  3871.     push    ax
  3872.     push    bx            ; save used registers
  3873.     push    cx
  3874.     push    dx
  3875.     push    di
  3876.     xor    al,al
  3877.     mov    dx,wystoff        ; map video memory offset to zero
  3878.     out    dx,al            ;
  3879.     mov    dx,wystseg        ; map video memory segment to zero
  3880.     out    dx,al            ;
  3881.     mov    ax,segwyse        ; set es to Wyse start segment
  3882.     mov    es,ax            ;
  3883.     mov    al,wybeven        ; graph mode - even bank
  3884.     mov    dx,wymode        ; Wyse mode control register
  3885.     out    dx,al            ; select even bank
  3886.     cld
  3887.     xor    ax,ax            ; zero ax
  3888.     xor    di,di            ; start from zero
  3889.     mov    cx,0ffffh        ; clear 10000h bytes, whole even bank
  3890.     rep    stosb            ; store blanking char in whole screen
  3891.     mov    al,wybodd        ; graph mode - odd bank
  3892.     mov    dx,wymode        ; select it
  3893.     out    dx,al            ;
  3894.     xor    ax,ax            ; zero ax
  3895.     xor    di,di            ;
  3896.     mov    cx,0ffffh        ; clear 10000h bytes, whole odd bank
  3897.     rep    stosb            ; store blanking char in whole screen
  3898.     mov    bnkchan, 0        ; assume bank 0
  3899.     pop    di            ; restore regs
  3900.     pop    dx
  3901.     pop    cx
  3902.     pop    bx
  3903.     pop    ax
  3904.     ret
  3905. WYGRAF    ENDP
  3906.  
  3907. ; routine to set Hercules card to graphics mode - both pages are enabled
  3908.      
  3909. HGRAF    PROC    NEAR
  3910.     push    ax
  3911.     push    bx            ; save used registers
  3912.     push    cx
  3913.     push    si
  3914.     mov    al,grph            ; graph mode
  3915.     lea    si,gtable        ;  requires graphics table
  3916.     xor    bx,bx
  3917.     mov    cx,4000h        ; clear 4000h words
  3918.     call    setmd            ; and set the mode
  3919.     pop    si
  3920.     pop    cx
  3921.     pop    bx
  3922.     pop    ax
  3923.     ret
  3924. HGRAF    ENDP
  3925.      
  3926. ; set Hercules card to text mode
  3927.      
  3928. HTEXT    PROC    NEAR
  3929.     push    ax
  3930.     push    bx
  3931.     push    cx
  3932.     push    si
  3933.     mov    al,text            ; text mode
  3934.     lea    si,ttable        ; requires text table
  3935.     mov    bx,0720h        ; blank value (space, white on black)
  3936.     mov    cx,2000            ; whole screen to clear (80*25)
  3937.     call    setmd            ; set the mode
  3938.     pop    si
  3939.     pop    cx
  3940.     pop    bx
  3941.     pop    ax
  3942.     ret
  3943. HTEXT    ENDP
  3944.      
  3945. ; Hercules mode set - called from HTEXT and HGRAF
  3946.      
  3947. SETMD    PROC    NEAR
  3948.     push    dx
  3949.     push    ax
  3950.     mov    dx,config        ; configuration port
  3951.     mov    al,genable        ; allow graphics mode to be set
  3952.     out    dx,al
  3953.     pop    ax
  3954.     push    ax
  3955.     push    cx            ; save count
  3956.     mov    dx,cntrl        ; control port
  3957.     out    dx,al            ; set to text or graphics
  3958.     mov    dx,index        ; send 12 bytes from table to 6845
  3959.     mov    cx,12            ; number of registers to load
  3960.     xor    ah,ah            ; start with register 0 of 6845
  3961.     cld
  3962. setmd1:    jmp    $+2            ; small pause for hardware
  3963.     mov    al,ah            ; ah is counter
  3964.     out    dx,al            ; set register
  3965.     inc    dx            ; point to data port
  3966.     lodsb                ; get next byte in table
  3967.     jmp    $+2            ; small pause for hardware
  3968.     out    dx,al            ; and send to 6845
  3969.     inc    ah            ; next register
  3970.     dec    dx            ; point to register port
  3971.     loop    setmd1            ; and continue 'til cx=0
  3972.     pop    cx            ; recover count
  3973.     cld
  3974.     push    di
  3975.     push    es
  3976.     mov    ax,segscn        ; start of screen
  3977.     mov    es,ax
  3978.     xor    di,di
  3979.     mov    ax,bx            ; get blanking character
  3980.     rep    stosw            ; store blanking char in whole screen
  3981.     pop    es
  3982.     pop    di
  3983.     mov    dx,cntrl        ; now to re-enable screen
  3984.     pop    ax            ; get mode
  3985.     or    al,scrn_on        ; enable screen
  3986.     out    dx,al
  3987.     pop    dx
  3988.     ret
  3989. SETMD    ENDP
  3990.      
  3991. teksave    proc    near        ; saves graphics screen from page 0 to page 1
  3992.     push    si
  3993.     push    di
  3994.     cmp    gpage,0        ; only graphics page 0 on display board?
  3995.     je    teksavx        ; e = yes, no saving possible here
  3996.     mov    si,segscn    ; segment (!) of current screen
  3997.     cmp    graph_mode,ega
  3998.     je    teksav1
  3999.     cmp    graph_mode,monoega
  4000.     je    teksav1
  4001.     cmp    graph_mode,colorega
  4002.     je    teksav1
  4003.     cmp    graph_mode,hercules
  4004.     je    teksav2
  4005.     jmp    short teksavx    ; else nothing
  4006. teksav1:mov    di,segega+800h    ; EGA page 1 screen segment
  4007.     call    egasr        ; call common save/restore code
  4008.     jmp    short teksavx
  4009. teksav2:mov    di,seghga+800h    ; Hercules page 1 screen segment
  4010.     call    hgasr        ; call common save/restore code
  4011. teksavx:pop    di
  4012.     pop    si
  4013.     ret
  4014. teksave    endp
  4015.  
  4016. tekrest    proc    near        ; saves graphics screen of page 0 in page 1
  4017.     push    si
  4018.     push    di
  4019.     cmp    gpage,0        ; only graphics page 0 on display board?
  4020.      jne    tekres0        ; ne = no, more so work to do here
  4021.     call    tekcls1        ;  else clear the screen to color it
  4022.     jmp    short tekresx    ;  and exit
  4023. tekres0:mov    di,segscn    ; segment (!) of new graphics screen
  4024.     cmp    graph_mode,ega
  4025.     je    tekres1
  4026.     cmp    graph_mode,monoega
  4027.     je    tekres1
  4028.     cmp    graph_mode,colorega
  4029.     je    tekres1
  4030.     cmp    graph_mode,hercules
  4031.     je    tekres2
  4032.     jmp    short tekresx    ; else nothing
  4033. tekres1:mov    si,segega+800h    ; segment of EGA page 1
  4034.     call    egasr        ; call common save/restore code
  4035.     jmp    short tekresx
  4036. tekres2:mov    si,seghga+800h    ; segment of Hercules page 1
  4037.     call    hgasr        ; call common save/restore code
  4038. tekresx:pop    di
  4039.     pop    si
  4040.     ret
  4041. tekrest    endp
  4042.  
  4043. egasr    proc    near        ; common code for Tek ega save/restore ops
  4044.     push    ax
  4045.     push    cx
  4046.     push    dx
  4047.     mov    ax,0f00h    ; enable 4 plane set/resets
  4048.     call    ega_gc        ; set controller
  4049.     mov    ax,0f01h    ; enable Set/Reset register
  4050.     call    ega_gc
  4051.     mov    ax,0f02h    ; set color compare register for 4 planes
  4052.     call    ega_gc
  4053.     mov    ax,0905h    ; set mode reg: write latches, read mode
  4054.     call    ega_gc
  4055.     mov    ax,0ff02h    ; enable all planes
  4056.     call    ega_md
  4057.     mov    cx,ybot        ; last scan line
  4058.     inc    cx        ; number of scan lines
  4059.     mov    ax,80        ; bytes per scan line
  4060.     mul    cx
  4061.     mov    cx,ax
  4062.     push    es        ; save es
  4063.     push    ds        ; save ds
  4064.     mov    es,di        ; destination, set es to video memory
  4065.     mov    ds,si        ; source, set ds to video memory
  4066.     xor    si,si        ; clear offset fields
  4067.     xor    di,di
  4068.     cld            ; byte moves for ega adaptor
  4069.     rep    movsb        ; copy from page (ds:si) to page (es:di)
  4070.     pop    ds        ; recover ds
  4071.     pop    es        ; and other registers
  4072.     mov    ax,0000h    ; disable 4 plane set/resets
  4073.     call    ega_gc        ; set controller
  4074.     mov    ax,0001h    ; disable Set/Reset register
  4075.     call    ega_gc        ; set controller
  4076.     mov    ax,0002h    ; disable color compare register
  4077.     call    ega_gc
  4078.     mov    ax,1005h    ; set mode reg: write latches, odd/even
  4079.     call    ega_gc
  4080.     pop    dx
  4081.     pop    cx
  4082.     pop    ax
  4083.     ret
  4084. egasr    endp
  4085.  
  4086. hgasr    proc    near        ; Hercules save restore screen
  4087.     push    cx
  4088.     mov    cx,4000h    ; number of words to move
  4089.     push    es        ; save es
  4090.     push    ds        ; save ds
  4091.     mov    es,di        ; destination, set es to video memory
  4092.     mov    ds,si        ; source, set ds to video memory
  4093.     xor    si,si        ; clear offset fields
  4094.     xor    di,di
  4095.     cld
  4096.     rep    movsw        ; copy from page [si] to page [di]
  4097.     pop    ds        ; recover ds
  4098.     pop    es        ; and other registers
  4099.     pop    cx
  4100.     ret
  4101. hgasr    endp
  4102.  
  4103. dump    proc    far            ; Write screen as TIFF v5.0 file
  4104.     push    ax
  4105.     push    bx
  4106.     push    cx
  4107.     push    dx
  4108.     push    si
  4109.     push    di
  4110.     mov    si,offset dumpname    ; name of dump file
  4111.     mov    di,offset tempname    ; destination
  4112.     push    es
  4113.     push    ds
  4114.     pop    es
  4115.     mov    cx,dumplen        ; length of dump name
  4116.     cld
  4117.     repnz    movsb            ; copy it, asciiz
  4118.     pop    es
  4119.     mov    ax,offset tempname    ; address to ax for unique
  4120.     call    tunique            ; get unique name into ax
  4121.     mov    dx,ax            ; ds:dx is asciiz filename
  4122.     xor    cx,cx            ; normal attributes
  4123.     mov    ah,creat2        ; create the file
  4124.     int    dos
  4125.     jc    dmp2            ; c = failure
  4126. dmp1:    mov    dhandle,ax        ; file handle
  4127.     call    dmpdate            ; do time stamp
  4128.     cmp    plotptr,offset pltcga    ; using CGA style graphics?
  4129.     jne    dmp2            ; ne = no
  4130.     call    cgadmp            ; do CGA style dump routine
  4131.     jmp    short dmp3
  4132. dmp2:    call    egadmp
  4133. dmp3:    pop    di
  4134.     pop    si
  4135.     pop    dx
  4136.     pop    cx
  4137.     pop    bx
  4138.     pop    ax
  4139.     ret
  4140. dump    endp
  4141.  
  4142. ; CGA TIFF 5.0 screen-to-file dump routine
  4143. cgadmp    proc    near
  4144.     push    es            ; do the bookkeeping math first
  4145.     mov    bps.entval,1        ; bits/sample, mono
  4146.     mov    photo.entval,1        ; mono, one bit after the other
  4147.     mov    word ptr cmap.entcnt,0    ; no palette color map entries
  4148.     mov    ax,xmax            ; image width - 8 pixels
  4149.     add    ax,8            ; plus 8, for pixels per line
  4150.     mov    iwidth.entval,ax    ; store in directory
  4151.     mov    xresval,ax        ; x resolution
  4152.     mov    xresval+2,0        ; high order part
  4153.     mov    ax,ybot            ; lines per screen - 1
  4154.     inc    ax            ; lines per screen
  4155.     mov    ilength.entval,ax    ; image length, scan lines
  4156.     mov    yresval,ax        ; y resolution
  4157.     mov    yresval+2,0        ; high order part
  4158.     mov    cx,25            ; try dividing into this many strips
  4159. cgadmp5:xor    dx,dx            ; image pixels
  4160.     mov    ax,yresval        ; number of scan lines
  4161.     div    cx            ; try dividing into 25 strips,ax=quo
  4162.     or    dx,dx            ; did we get null remainder?
  4163.     loopnz    cgadmp5            ; nz = no, try again with fewer strips
  4164.     inc    cx            ; inc for dec by loop, cx = # strips
  4165.     mov    word ptr strip.entcnt,cx ; store number of strips
  4166.     mov    word ptr sbc.entcnt,cx    ; store number of strip byte counts
  4167.     mov    rps.entval,ax        ; rows per strip
  4168.     mul    linelen            ; rows/strip * bytes/row = bytes/strip
  4169.     push    cx            ; save strip count for loop below
  4170.     push    ds            ; ax = bytes per strip
  4171.     pop    es            ; es:di to our data segment
  4172.     mov    di,offset stripbc    ; where to write strip byte counts
  4173.     cld
  4174.     rep    stosw            ; write ax as bytes/strip, cx times
  4175.     pop    cx            
  4176.     mov    dx,ax            ; bytes/strip = increment, put here
  4177.     mov    di,offset stripoff    ; where we write
  4178.     mov    ax,offset pixdata-offset header ; where first strip starts
  4179. cgadmp4:stosw                ; write strip file offset
  4180.     mov    word ptr [di],0        ; high order part
  4181.     add    di,2            ; next double word
  4182.     add    ax,dx            ; next file strip offset
  4183.     loop    cgadmp4            ; do all strip offsets
  4184.                     ; file i/o starts here
  4185.     mov    bx,dhandle        ; dump's file handle
  4186.     mov    dx,offset header    ; write TIFF header and directory
  4187.     mov    cx,tifflen        ; length of header plus directory
  4188.     mov    ah,write2
  4189.     int    dos
  4190.     jc    cgadmp2            ; c = failure
  4191.     xor    di,di            ; start at y = top
  4192.     call    psetup            ; setup cga and di
  4193.     mov    cx,ybot            ; number of scan lines-1
  4194.     inc    cx            ; number of scan lines
  4195. cgadmp1:push    cx
  4196.     mov    cx,linelen        ; line length, bytes
  4197.     mov    dx,di            ; offset in screen buffer
  4198.     mov    bx,dhandle        ; file handle
  4199.     push    ds
  4200.     mov    ax,segscn        ; screen seg
  4201.     mov    ds,ax
  4202.     mov    ah,write2        ; write directly from screen memory
  4203.     int    dos
  4204.     pop    ds
  4205.     jc    cgadmp2            ; c = failure
  4206.     call    pincy            ; next line down, y = y + 1
  4207.     pop    cx
  4208.     loop    cgadmp1            ; do all scan lines
  4209. cgadmp2:mov    ah,close2        ; close the file
  4210.     int    dos
  4211.     mov    dhandle,-1        ; set handle to unused
  4212.     pop    es
  4213.     ret
  4214. cgadmp    endp
  4215.  
  4216. ; EGA TIFF 5.0 screen-to-file dump routine
  4217. egadmp    proc    near
  4218.     push    es            ; do the bookkeeping math first
  4219.     mov    bps.entval,4        ; bits/sample, iRGB
  4220.     mov    photo.entval,3        ; photo interp, palette
  4221.     mov    word ptr cmap.entcnt,3*16 ; palette color map entries
  4222.     mov    ax,xmax            ; image width - 8 pixels
  4223.     add    ax,8            ; plus 8, for pixels per line
  4224.     mov    iwidth.entval,ax    ; store in directory
  4225.     mov    xresval,ax        ; x resolution
  4226.     mov    xresval+2,0        ; high order part
  4227.     mov    ax,ybot            ; lines per screen - 1
  4228.     inc    ax            ; lines per screen
  4229.     mov    ilength.entval,ax    ; image length, scan lines
  4230.     mov    yresval,ax        ; y resolution
  4231.     mov    yresval+2,0        ; high order part
  4232.     mov    cx,25            ; try dividing into this many strips
  4233. egadmp10:xor    dx,dx            ; image pixels
  4234.     mov    ax,yresval        ; number of scan lines
  4235.     div    cx            ; try dividing into 25 strips, ax=quo
  4236.     or    dx,dx            ; did we get null remainder?
  4237.     loopnz    egadmp10        ; nz = no, try again with fewer strips
  4238.     inc    cx            ; inc for dec by loop, cx = # strips
  4239.     mov    word ptr strip.entcnt,cx ; store number of strips
  4240.     mov    word ptr sbc.entcnt,cx    ; store number of strip byte counts
  4241.     mov    rps.entval,ax        ; rows per strip
  4242.     shl    ax,1
  4243.     shl    ax,1            ; times 4 bits / pixel
  4244.     mul    linelen            ; rows/strip * bytes/row = bytes/strip
  4245.     push    cx            ; save strip count for loop below
  4246.     push    ds            ; ax = bytes per strip
  4247.     pop    es            ; es:di to our data segment
  4248.     mov    di,offset stripbc    ; where to write strip byte counts
  4249.     cld
  4250.     rep    stosw            ; write ax as bytes/strip, cx times
  4251.     pop    cx            
  4252.     mov    dx,ax            ; bytes/strip = increment, put here
  4253.     mov    di,offset stripoff    ; where we write
  4254.     mov    ax,offset pixdata-offset header ; where first strip starts
  4255.     xor    bx,bx
  4256. egadmp11:stosw                ; write strip file offset
  4257.     mov    es:[di],bx        ; high order part
  4258.     add    di,2            ; next double word
  4259.     add    ax,dx            ; next file strip offset
  4260.     adc    bx,0
  4261.     loop    egadmp11        ; do all strip offsets
  4262.                     ; screen to file i/o starts here
  4263.     mov    bx,dhandle        ; dump's file handle
  4264.     mov    dx,offset header    ; write TIFF header and directory
  4265.     mov    cx,tifflen        ; length of header plus directory
  4266.     mov    ah,write2
  4267.     int    dos
  4268.     jnc    egadmp12
  4269.     jmp    egadmp9            ; c = failure
  4270. egadmp12:
  4271.     xor    di,di            ; start at y = top
  4272.     call    psetup            ; setup adapter and es:di
  4273.     xor    di,di
  4274.     mov    bx,offset tempname    ; set buffer address
  4275.     mov    cx,ybot            ; number of scan lines-1
  4276.     inc    cx            ; number of scan lines
  4277. egadmp1:push    cx            ; save scan line counter
  4278.     mov    cx,linelen        ; 8*dots across the screen (640)
  4279. egadmp2:push    cx            ; save counter of inner loops
  4280.     mov    cx,4            ; number of planes to do
  4281.     mov    word ptr [bx],0        ; clear the four bytes for this loop
  4282.     mov    word ptr [bx+2],0
  4283. egadmp3:push    cx            ; save plane counter
  4284.     push    bx            ; don't advance buffer pointer here
  4285.     mov    dx,3ceh            ; (ega_gc)
  4286.     mov    al,4            ; command to select read map register
  4287.     out    dx,al            ; output command code
  4288.     inc    dx            ; dx is now data port
  4289.     mov    al,cl            ; do planes 3(I), then 2(R),1(G),0(B)
  4290.     dec    al            ; cx is one higher than plane
  4291.     out    dx,al            ; output value (end of ega_gc)
  4292.     mov    al,es:[di]        ; latch byte
  4293.                     ; got 8 bits from a plane
  4294.     mov    cx,4            ; do this for four output bytes
  4295. egadmp4:mov    ah,[bx]            ; eventually iRGB in each nibble
  4296.     shl    al,1            ; get left most pixel bit in plane
  4297.     jnc    egadmp5
  4298.     or    ah,8            ; set high nibble least sig bit
  4299. egadmp5:shl    al,1            ; odd numbered pixel
  4300.      rcl    ah,1            ; set low nibble least sig bit if c
  4301.     mov    [bx],ah
  4302.     inc    bx            ; next byte
  4303.     loop    egadmp4            ; do all four bytes
  4304.  
  4305.     pop    bx
  4306.     pop    cx            ; restore plane counter
  4307.     loop    egadmp3            ; do all planes
  4308.  
  4309.     inc    di            ; next screen memory address
  4310.     add    bx,4            ; just did four bytes
  4311.     cmp    bx,offset tempname+80    ; at end of 80 bytes?
  4312.     jb    egadmp6            ; b = no
  4313.     call    egadmpw            ; write the buffer
  4314.     mov    bx,offset tempname    ; reset buffer address
  4315.     jnc    egadmp6            ; nc = success
  4316.     pop    cx            ; clean stack
  4317.     pop    cx
  4318.     jmp    egadmp9            ; error
  4319.  
  4320. egadmp6:pop    cx            ; recover bytes per line counter
  4321.     loop    egadmp2            ; next group across scan line
  4322.     pop    cx            ; recover scan line counter
  4323.     loop    egadmp1            ; do next scan line
  4324.     call    egadmpw            ; flush the buffer for last scan line
  4325. egadmp9:mov    ah,close2        ; close the file
  4326.     mov    bx,dhandle
  4327.     int    dos
  4328.     mov    dhandle,-1        ; set handle to unused
  4329.     xor    di,di
  4330.     call    psetup
  4331.     pop    es
  4332.     ret
  4333.                        ; local worker
  4334. egadmpw:push    bx            ; write tempbuf from start to [bx-1]
  4335.     push    cx
  4336.     mov    dx,offset tempname    ; work buffer
  4337.     mov    cx,bx            ; buffer pointer to next free byte
  4338.     sub    cx,dx            ; buffer size to write
  4339.     cmp    cx,0
  4340.     jle    egadmpw1        ; le = nothing to write
  4341.     mov    bx,dhandle        ; file handle
  4342.     mov    ah,write2        ; write cx bytes from tempname
  4343.     int    dos
  4344.     jc    egadmpw2        ; c = error
  4345.     cmp    ax,cx            ; wrote all?
  4346.     jne    egadmpw2        ; ne = no
  4347. egadmpw1:clc                ; clc
  4348.     pop    cx
  4349.     pop    bx
  4350.     ret
  4351. egadmpw2:stc                ; carry set for failure
  4352.     pop    cx
  4353.     pop    bx
  4354.     ret
  4355.  
  4356. egadmp    endp
  4357.  
  4358. ; Worker. Write Kermit version and current date and time in TIFF header
  4359. dmpdate    proc    near
  4360.     mov    di,offset prog+10    ; place for version in prog field
  4361.     mov    ax,version        ; Kermit version
  4362.     call    dec2di            ; write the version
  4363.     mov    ah,getdate        ; DOS date (cx= yyyy, dh= mm, dl= dd)
  4364.     int    dos
  4365.     mov    di,offset dandt        ; where to write
  4366.     mov    ax,cx            ; get yyyy
  4367.     push    dx
  4368.     call    dec2di            ; write to buffer
  4369.     pop    dx
  4370.     mov    byte ptr [di],':'
  4371.     inc    di
  4372.     mov    al,dh            ; mm
  4373.     cmp    al,10            ; leading digit?
  4374.     jae    dmpdat1            ; ae = yes
  4375.     mov    byte ptr [di],'0'    ; make our own
  4376.     inc    di
  4377. dmpdat1:xor    ah,ah
  4378.     push    dx
  4379.     call    dec2di
  4380.     mov    byte ptr [di],':'
  4381.     pop    dx
  4382.     inc    di
  4383.     mov    al,dl            ; dd
  4384.     cmp    al,10            ; leading digit?
  4385.     jae    dmpdat2            ; ae = yes
  4386.     mov    byte ptr [di],'0'    ; make our own
  4387.     inc    di
  4388. dmpdat2:xor    ah,ah
  4389.     call    dec2di
  4390.     mov    byte ptr [di],' '
  4391.     inc    di
  4392.     mov    ah,gettim        ; DOS tod (ch=hh, cl=mm, dh=ss, dl=.s)
  4393.     int    dos
  4394.     push    dx            ; save dx
  4395.     xor    ah,ah
  4396.     mov    al,ch            ; Hours
  4397.     cmp    al,10            ; leading digit?
  4398.     jae    dmpdat3            ; ae = yes
  4399.     mov    byte ptr [di],'0'    ; make our own
  4400.     inc    di
  4401. dmpdat3:push    cx
  4402.     call    dec2di            ; write decimal asciiz to buffer
  4403.     pop    cx
  4404.     mov    byte ptr [di],':'
  4405.     inc    di
  4406.     xor    ah,ah
  4407.     mov    al,cl            ; Minutes
  4408.     cmp    al,10            ; leading digit?
  4409.     jae    dmpdat4            ; ae = yes
  4410.     mov    byte ptr [di],'0'    ; make our own
  4411.     inc    di
  4412. dmpdat4:call    dec2di            ; write decimal asciiz to buffer
  4413.     mov    byte ptr [di],':'
  4414.     inc    di
  4415.     pop    dx
  4416.     xor    ah,ah
  4417.     mov    al,dh            ; Seconds
  4418.     cmp    al,10            ; leading digit?
  4419.     jae    dmpdat5            ; ae = yes
  4420.     mov    byte ptr [di],'0'    ; make our own
  4421.     inc    di
  4422. dmpdat5:call    dec2di            ; write decimal asciiz to buffer
  4423.     inc    di
  4424.     ret
  4425. dmpdate    endp
  4426.  
  4427. ; Dispatch table processor. Enter with BX pointing at table of {char count,
  4428. ; address of action routines, characters}. Jump to matching routine or return.
  4429. ; Enter with AL holding received Final char.
  4430. atdispat proc near
  4431.     mov    cl,[bx]            ; get table length from first byte
  4432.     xor    ch,ch
  4433.     mov    di,bx            ; main table
  4434.     add    di,3            ; point di at first char in table
  4435.     push    es
  4436.     push    ds
  4437.     pop    es            ; use data segment for es:di below
  4438.     cld                ; set direction forward
  4439.     repne    scasb            ; find matching character
  4440.     pop    es
  4441.     je    atdisp2            ; e = found a match, get action addr
  4442.     cmp    al,' '            ; control char?
  4443.     jb    atdisp1            ; b = yes
  4444.     ret                ; ignore escape sequence
  4445. atdisp1:jmp    tekctl            ; process control char
  4446. atdisp2:sub    di,bx            ; distance scanned in table
  4447.     sub    di,4            ; skip count byte, address word, inc
  4448.     shl    di,1            ; convert to word index
  4449.     inc    bx            ; point to address of action routines
  4450.     mov    bx,[bx]            ; get address of action table
  4451.     jmp    word ptr [bx+di]    ; dispatch to the routine
  4452. atdispat endp
  4453.  
  4454. ansich    proc    near            ; insert Pn spaces at and after cursor
  4455.     mov    cx,param        ; get Pn
  4456.     or    cx,cx
  4457.     jnz    ansich1            ; got a value
  4458.     inc    cx            ; zero means one
  4459. ansich1:push    x_coord
  4460.     push    y_coord
  4461.     mov    al,spcontrol        ; preserve space control
  4462.     mov    tempname,al        ; save here
  4463.     mov    spcontrol,1        ; turn on destructive space
  4464.     and    x_coord,not 7        ; modulo 8x8 cells
  4465.     mov    ax,xmax            ; start of last cell
  4466.     sub    ax,x_coord        ; start of current cell
  4467.     shr    ax,1            ; divide by 8 dots per char
  4468.     shr    ax,1
  4469.     shr    ax,1
  4470.     cmp    ax,cx            ; want more spaces than are on line?
  4471.     jae    ansich2            ; ae = no
  4472.     mov    cx,ax            ; clip to right margin
  4473.     jcxz    ansich3            ; z = nothing to do
  4474. ansich2:push    cx
  4475.     mov    al,' '            ; a space
  4476.     call    outscrn            ; write to screen (BYPASS check??)
  4477.     pop    cx
  4478.     loop    ansich2            ; do them
  4479. ansich3:mov    al,tempname        ; space control
  4480.     mov    spcontrol,al        ; restored
  4481.     pop    x_coord
  4482.     pop    y_coord
  4483.     ret
  4484. ansich    endp
  4485.                     ; scaled by text screen height
  4486. atcuu    proc    near            ; cursor up Pn lines
  4487.     cmp    param,0            ; empty arg?
  4488.     jne    atcuu1            ; got a value
  4489.     inc    param            ; zero means one
  4490. atcuu1:    mov    ax,y_coord        ; where we are now
  4491.     add    ax,4            ; round up a smidge
  4492.     mov    cl,byte ptr low_rgt+1    ; highest text line
  4493.     xor    ch,ch
  4494.     mul    cx            ; proportion
  4495.     xor    dx,dx
  4496.     mov    cx,ybot            ; highest scan line
  4497.     div    cx            ; end, estimate currren text line
  4498.     sub    ax,param
  4499.     inc    ax            ; count lines from 1 again
  4500.     mov    param,ax        ; new text row
  4501.     jmp    atcva            ; do as absolute
  4502. atcuu    endp
  4503.  
  4504.                     ; scaled by text screen height
  4505. atcud    proc    near            ; cursor down Pn lines
  4506.     cmp    param,0            ; get Pn
  4507.     jne    atcud1            ; ne = got a value
  4508.     inc    param            ; zero means one
  4509. atcud1:    mov    ax,y_coord        ; where we are now
  4510.     add    ax,4            ; round up a smidge
  4511.     mov    cl,byte ptr low_rgt+1    ; highest text line
  4512.     xor    ch,ch
  4513.     mul    cx            ; proportion
  4514.     xor    dx,dx
  4515.     mov    cx,ybot            ; highest scan line
  4516.     div    cx            ; end, estimate currren text line
  4517.     inc    ax            ; count lines from 1 again
  4518.     add    param,ax        ; new text row
  4519.     jmp    atcva            ; do as absolute
  4520. atcud    endp
  4521.  
  4522. atcuf    proc    near            ; cursor forward Pn columns
  4523.     mov    ax,param        ; get Pn
  4524.     or    ax,ax
  4525.     jnz    atcuf1            ; got a value
  4526.     inc    ax            ; zero means one
  4527. atcuf1:    shl    ax,1            ; times 8 dots per char cell
  4528.     shl    ax,1
  4529.     shl    ax,1            ; Tek columns worth
  4530.     and    x_coord,not 7        ; modulo 8x8 cells
  4531.     add    x_coord,ax        ; forward to absolute column
  4532.     mov    ax,xmax
  4533.     cmp    x_coord,ax        ; beyond right most cell?
  4534.     jbe    atcuf2            ; be = no
  4535.     mov    x_coord,ax        ; limit to right
  4536. atcuf2:    ret
  4537. atcuf    endp
  4538.  
  4539. atcub    proc    near            ; cursor left/back Pn columns
  4540.     mov    ax,param        ; get Pn
  4541.     or    ax,ax
  4542.     jnz    atcub1            ; got a value
  4543.     inc    ax            ; zero means one
  4544. atcub1:    shl    ax,1
  4545.     shl    ax,1
  4546.     shl    ax,1            ; times 8 dots per cell
  4547.     and    x_coord,not 7        ; modulo 8x8 cells
  4548.     mov    cx,xmax
  4549.     cmp    x_coord,cx        ; beyond last col (wrap pending)?
  4550.     jbe    atcub3            ; be = no
  4551.     mov    x_coord,cx        ; set to last col
  4552. atcub3:    sub    x_coord,ax        ; back up
  4553.     jnc    atcub2            ; nc = ok
  4554.     mov    x_coord,0        ; stop in column zero
  4555. atcub2:    ret
  4556. atcub    endp
  4557.  
  4558. atcnl    proc    near            ; do Pn cr/lf's
  4559.     mov    x_coord,0        ; to left margin
  4560.     jmp    atcud            ; do the cursor downs
  4561. atcnl    endp
  4562.  
  4563. atcpl    proc    near            ; do Pn cursor ups
  4564.     jmp    atcuu            ; do the cursor ups
  4565. atcpl    endp
  4566.  
  4567.                     ; scaled by text screen width
  4568. atcha    proc    near            ; cursor to absolute column
  4569.     and    x_coord,not 7        ; modulo 8x8 cells
  4570.     mov    ax,param        ; get Pn
  4571.     or    ax,ax
  4572.     jz    atcha1            ; z = zero already
  4573.     dec    param            ; count columns from 0
  4574.     mov    ax,xmax            ; number of Tek dots/row
  4575.     mul    param            ; times columns they want
  4576.     mov    cl,byte ptr low_rgt    ; number of last text column
  4577.     xor    ch,ch
  4578.     xor    dx,dx
  4579.     div    cx            ; scale to ~80 column screen
  4580.     cmp    ax,xmax            ; too far?
  4581.     jbe    atcha1            ; be = no
  4582.     mov    ax,xmax            ; right most column
  4583. atcha1:    mov    x_coord,ax
  4584.     ret
  4585. atcha    endp
  4586.                     ; scaled by text screen height
  4587. atcva    proc    near            ; cursor to absolute row
  4588.     dec    param            ; count from 0
  4589.     mov    ax,param        ; desired text row
  4590.     or    ax,ax            ; zero or now -1?
  4591.     jg    atcva1            ; g = no, further down
  4592.     mov    ax,7            ; bottom of top text cell
  4593.     jmp    short atcva2
  4594. atcva1:    mov    ax,ybot
  4595.     inc    ax            ; number of scan lines on screen
  4596. ;;;;    and    ax,not 7        ; whole 8x8 char cells
  4597.     mul    param            ; times row they want
  4598.     mov    cl,byte ptr low_rgt+1    ; number of last text line (0..23)
  4599.     xor    ch,ch
  4600.     xor    dx,dx
  4601.     div    cx            ; scale to ~24 line screen 
  4602.     mov    cx,ybot
  4603. ;;;;    and    cx,not 7        ; whole 8x8 char cells
  4604.     cmp    ax,cx            ; too far?
  4605.     jbe    atcva2            ; be = no
  4606.     mov    ax,cx
  4607. atcva2:    mov    y_coord,ax        ; go to that line
  4608.     ret
  4609. atcva    endp
  4610.     
  4611. atcup    proc    near            ; cursor to absolute row, column
  4612.     call    atcva            ; process param[0] as absolute row
  4613.     push    param[2]        ; column
  4614.     pop    param
  4615.     jmp    atcha            ; process param[2] as absolute column
  4616. atcup    endp
  4617.  
  4618. ated    proc    near            ; erase display
  4619.     mov    al,spcontrol        ; preserve space control
  4620.     mov    tempname,al        ; save here
  4621.     mov    spcontrol,1        ; turn on destructive space
  4622.     push    x_coord
  4623.     push    y_coord            ; save cursor
  4624.     cmp    param,0            ; cursor to end of screen?
  4625.     je    ated1            ; e = yes
  4626.     cmp    param,1            ; start of screen to cursor?
  4627.     je    ated3            ; e = yes
  4628.     cmp    param,2            ; entire screen?
  4629.     je    ated5            ; e = yes
  4630.     ret                ; else ignore
  4631.  
  4632. ated1:    mov    param,0            ; cursor to end of this line
  4633.     call    atel            ; erase cursor to end of line
  4634.     add    y_coord,8        ; look at next line
  4635.     mov    ax,ybot
  4636.     cmp    y_coord,ax        ; are we at the end now?
  4637.     ja    ated6            ; a = yes
  4638.     mov    x_coord,0        ; start of line is here
  4639.     jmp    ated1            ; do through last line
  4640.  
  4641. ated3:    and    y_coord,not 7        ; modulo 8x8 char cells
  4642.     mov    cx,y_coord        ; start of screen to cursor
  4643.     shr    cx,1            ; char lines at 8 dots/char
  4644.     shr    cx,1
  4645.     shr    cx,1
  4646.     dec    cx            ; omit current line= # whole lines
  4647.     or    cx,cx            ; any whole lines?
  4648.     jle    ated3b            ; le = no
  4649.     mov    y_coord,7        ; start at the top line
  4650. ated3a:    push    cx
  4651.     mov    param,2            ; entire line
  4652.     call    atel            ; erase entire line
  4653.     add    y_coord,8        ; next line
  4654.     pop    cx
  4655.     loop    ated3a
  4656. ated3b:    mov    param,1            ; start of line to cursor
  4657.     call    atel            ; erase to cursor on this (last) line
  4658.     jmp    short ated6
  4659.  
  4660. ated5:    call    tekcls            ; erase whole screen
  4661.  
  4662. ated6:    mov    al,tempname        ; spacing control
  4663.     mov    spcontrol,al
  4664.     pop    y_coord
  4665.     pop    x_coord
  4666.     ret
  4667. ated    endp
  4668.  
  4669. atech    proc    near            ; erase Pn chars from cursor to eol
  4670.     mov    al,spcontrol        ; preserve space control
  4671.     mov    tempname,al        ; save here
  4672.     mov    spcontrol,1        ; turn on destructive space
  4673.     push    x_coord
  4674.     push    y_coord            ; save cursor
  4675.     mov    cx,x_coord
  4676.     and    cx,not 7        ; modulo 8x8 cells
  4677.     mov    ax,xmax
  4678.     sub    ax,cx            ; number of chars remaining on line
  4679.     shr    ax,1
  4680.     shr    ax,1
  4681.     shr    ax,1
  4682.     inc    ax            ; count cursor cell
  4683.     mov    cx,param        ; how many chars to erase
  4684.     or    cx,cx
  4685.     jz    atech1            ; z = zero, use one
  4686.     inc    cx
  4687. atech1:    cmp    ax,cx            ; want more than line length?
  4688.     jae    atech2            ; ae = no
  4689.     mov    cx,ax            ; clip at right margin
  4690.     or    cx,cx
  4691.     jle    atech3            ; le = nothing to do
  4692. atech2:    push    cx
  4693.     mov    al,' '
  4694.     call    outscrn            ; write spaces
  4695.     pop    cx
  4696.     loop    atech2
  4697. atech3:    mov    al,tempname        ; spacing control
  4698.     mov    spcontrol,al
  4699.     pop    y_coord
  4700.     pop    x_coord
  4701.     ret
  4702. atech    endp
  4703.  
  4704. atel    proc    near            ; erase on this line
  4705.     push    x_coord
  4706.     push    y_coord
  4707.     cmp    param,0            ; cursor to end of line?
  4708.     je    atel1            ; e = yes
  4709.     cmp    param,1            ; start of line to cursor?
  4710.     je    atel3            ; e = yes
  4711.     cmp    param,2            ; whole line?
  4712.     jne    atel5            ; ne = no, fail
  4713.     mov    x_coord,0        ; erase entire line
  4714.  
  4715. atel1:    mov    cx,xmax            ; cursor to end of line
  4716.     mov    ax,x_coord
  4717.     and    ax,not 7        ; modulo 8x8 cells
  4718.     sub    cx,ax
  4719.     shr    cx,1
  4720.     shr    cx,1
  4721.     shr    cx,1            ; 8 dots/char
  4722.     inc    cx            ; count the cursor cell
  4723.     or    cx,cx
  4724.     jle    atel5            ; le = do nothing
  4725.     mov    al,spcontrol        ; preserve space control
  4726.     mov    tempname,al        ; save here
  4727.     mov    spcontrol,1        ; turn on destructive space
  4728. atel2:    push    cx            ; start of line to cursor
  4729.     mov    al,' '
  4730.     call    outscrn
  4731.     pop    cx
  4732.     loop    atel2
  4733.     mov    al,tempname        ; space control
  4734.     mov    spcontrol,al        ; restored
  4735. atel5:    pop    y_coord
  4736.     pop    x_coord
  4737.     ret
  4738. atel3:    mov    cx,x_coord        ; start of line to cursor
  4739.     shr    cx,1
  4740.     shr    cx,1
  4741.     shr    cx,1
  4742.     inc    cx            ; count cursor cell
  4743.     mov    x_coord,0        ; go to start of line
  4744.     jmp    atel2            ; do the loops
  4745. atel    endp
  4746. code2    ends
  4747.     end
  4748.