Columbia Kermit/kermit.zip/mskermit/msxhpx.asm

Assembly Source File | 2020-01-01 | 71KB | 2,522 lines

    name msxhpx
; File MSXHPX.ASM
    include mssdef.h
;       Copyright (C) 1982,1991, Trustees of Columbia University in the
;       City of New York.  Permission is granted to any individual or
;       institution to use, copy, or redistribute this software as long as
;       it is not sold for profit and this copyright notice is retained.
; Edit history:
; 2 March 1991 version 3.10
; 2 Dec 2, 1990 Modify serhng so hangup works on serial port in connect mode.
; Nov. 24, 1990. Reemove reference to prserr to make link happy.
; Last edit Aug. 17, 1990
; August 9, 1990. Fix klogon and klogof.
; July 1990. Put in correct delay times for breaks. Thanks to Fred Lipschultz.
; June 1990. Install screen save for HP 110 and fixup dial command.[jan]
; February 1990. Major rewrite. Fix up for tektronix grapahics and 3.0.
; John Nyenhuis, Purdue EE 317-494-3524 [e-mail]
; Binary works on both 110 and Plus.
; Change naming of ports to serial, modem, and 82164A
; Read keyboard less often and use BIOS screen write on plus for speed.
; 1 July 1988 Version 2.31
; 1 Jan 1988 version 2.30
; 25 May 1987 Add keyboard translator, input translation, cleanups. [jrd]
; 1 Oct 86 Version 2.29a
; 30 Sept 1986 Reject DEL char at serial port reception level to avoid
;  problems when DEL is used as a filler char (by Emacs). [jrd]
; 28 Sept 1986 Revise procedure Term to permit capturing, printer ready
;  testing, debug display. Revised other port procedures slightly too;
;  especially to set port into binary mode via ioctl. [jrd]
; 22 Sept 1986 Add modifications from Mike Mellinger: outchr, serhng.
;   Introduce COM3 as additional choice. Startup 8 bits, no parity. [jrd]
; 4 Sept 1986 Add Bob Goeke's change to move comms port table to a system
;   dependent module (typ msx---) to allow 3+ ports and localized idents. [jrd]

; Date: 15 Oct 85
; HP Portable Kermit
;    for HP110 and HP Portable Plus
;    Port 1: Serial, Port 2: internal modem
;    Defaults: even parity, 1200 baud: serial, 1200 internal modem
;    Internal modem code only works on HP Portable Plus
;    15 Nov 85:
;       Added code to shut off serial port and modem when quitting Kermit
;    11 Jan 86;
;       change msdefs.h to mssdef.h for kermit 2.28 jrd
;
; Add global entry point vtstat for use by Status in mssset.
; Also trimmed off trailing commas in publics. Joe R. Doupnik 12 March 1986
; Add global procedures ihosts and ihostr to handle host initialization
; when packets are to be sent or received by us,resp. 24 March 1986
; Add global procedure dtrlow (without worker serhng) to force DTR & RTS low
; in support of Kermit command Hangup. Says Not Yet Implemented. [jrd]
; Add global procedure Dumpscr, called by Ter in file msster, to dump screen
;   to a file. Just does a beep for now. 13 April 1986 [jrd]
; In proc Outchr add override of xon from chkxon sending routine.
;   This makes a hand typed Xoff supress the xon flow control character sent
;   automatically as the receiver buffer empties. 20 April 1986 [jrd]
; Fix port selector table, comptab, (from original version) to properly
;   hold port name AUX. 23 April 1986 [jrd]
;
;    Fixed error in resetting the serial port, 25 April 1986
;
        page    80,132


; mov a string     all registers preserved
   movsmac macro xsource,  xdestination, xlength
    push cx
    push di
    push si
    mov       si,offset xsource
    mov       di, offset xdestination
    mov       cx,xlength
    cld              ; move forward
    rep movsb          ; do the move
    pop      si
    pop      di
    pop      cx
endm
writechar   macro saying
    push  dx
    push  ax
    mov      ah,2
    mov      dl,saying
    int      dos
    pop      ax
    pop      dx
endm

writestring   macro saying
    push ax
    push dx
    mov  ah,prstr
    mov  dx,offset saying
    int  dos
    pop  dx
    pop  ax
 endm

saveregs macro
      pushf
      push  ax
      push  bx
      push  cx
      push  dx
      push  es
      push  di
      push  si
      push  ds
      push  bp
endm

restoreregs  macro
     pop   bp
     pop   ds
     pop   si
     pop   di
     pop   es
     pop   dx
     pop   cx
     pop   bx
     pop   ax
     popf
endm

mul10  macro register  ; multiply register other then ax by 10
    push ax
    mov ax,register
    mov temp1,ax
    shl ax,1
    shl ax,1
    shl ax,1
    add ax,temp1
    add ax,temp1
      mov temp1,ax
    pop ax
      mov register,temp1
endm

  delay macro number
   push ax
   push cx
   mov ax,number
   call pcwait
   pop cx
   pop ax
   endm


; structure for status information table sttab.
stent    struc
sttyp    dw  ?       ; type (actually routine to call)
msg    dw  ?       ; message to print
val2    dw  ?       ; needed value: another message, or tbl addr
tstcel    dw  ?       ; address of cell to test, in data segment
basval    dw  0       ; base value, if non-zero
stent    ends



;; below 40 publics are the minimum necessary
       public  baudst,ihostr,bdtab,getbaud,chrout
       public  pcwait,putmod,serrst,trnprs,prtchr
       public  poscur,outchr,dtrlow,vts,puthlp
       public    vtstat,coms,cquery,ctlu,shomodem
       public  portval,getmodem,term,dumpscr,cmblnk
       public  cquit,locate,clearl,machnam,lclini
       public  sendbl,comptab,sendbr,clrmod,cstatus
       public  termtb,serhng,clrbuf,beep, serini
;;additional system dependent publics
    public    klogon,kdos,snull,klogof
    public bigscreen        ; bigscreen=1 if it's big [jan]
    public    termtog            ; toggle terminal types [jan]
    public    kclrscn, ourhelp, getflgs, dial_number, sethpkey, setaltkey
    public    setkeyboard, vtstbl, setchtab

false    equ    0
true    equ    1
instat    equ    6
print_out equ    05h            ; dos function to print to printer
prtscr    equ    80h            ; print screen pressed
hpkeynum    equ  11
altkeynum    equ  12
tekonnum    equ  13
tekoffnum    equ  14

data   segment public 'data'
    extrn    flags:byte, trans:byte
    extrn    dmpname:byte
    extrn    kbdflg:byte, rxtable:byte
    extrn    lclexit:word       ; call when quitting kermit
    extrn    lclsusp:word       ; call when pushing to dos
    extrn    lclrest:word       ; call when exiting from dos
    extrn    tekflg:byte,denyflg:word
    extrn    dosnum:word
    extrn    repflg:byte, diskio:byte  ; for replay feature
    extrn    kbdflg:byte  ;    in telnet

; hp110/ portable plus specific
machnam db    'Can Not Identify Terminal ','$'  ; should never see this
hp110_name db       'HP_110$'
lenhp110_name equ   $-hp110_name
plus_name   db 'HP_Portable_Plus$'
lenplus_name equ $-plus_name

; num_rows and bigscreen must be set by lclini everything else is
; determined by the program
;; everybody defaults to 110
num_rows    dw      16        ; default
bigscreen    db      1        ; 1 for plus 0 for 110
graph_bytes    dw      25*60*8    ; size of graphics screen

erms20    db    cr,lf,'?Warning: System has no disk drives$'
erms40    db    cr,lf,'?Warning: Unrecognized baud rate$'
erms41    db    cr,lf,'?Warning: Cannot open com port$'
erms50    db    cr,lf,'Error reading from device$'
serierr db    cr,lf,'Can not initialize port $'
write2err db    cr,lf,'Can not write to com port $'
badbd    db    cr,lf,'Unimplemented baud rate$'
badpar    db    cr,lf,'Unimplemented parity$'
noimp    db    cr,lf,'Command not implemented.$'
hngmsg    db    cr,lf,' The phone should have hungup.',cr,lf,'$'
hnghlp    db    cr,lf,' The modem control lines DTR and RTS for the current'
    db    ' port are forced low (off)'
    db    cr,lf,' to hangup the phone. Normally, Kermit leaves them'
    db    ' high (on) when it exits.'
    db    cr,lf,'$'
msmsg1    db    cr,lf,' Communications port is not ready.$'
msmsg2    db    cr,lf,' Communications port is ready.$'
rdbuf    db    80 dup (?)        ; temp buf
shkmsg    db    'Not implemented.'
shklen    equ    $-shkmsg
baudstr db    'SB'            ; string used in setting baud rate
baudx    db    0,';' ,'$'
flo_str db    'C'            ; string used to set flow
flo_x    db    '0',';','$'        ; 0=no flow 2=xon/xoff
brk_on    db    'B1;'            ; start sending breaks
brk_off db    'B0;'            ; stop sending breaks
chk_msg db    0BFH,';'        ; check serial buffer
ask_cursor    db escape,'[6n','$'
badcursor     db 'Unable to get cursor position ',cr,lf,'$'
ask_modem_status db 'MS;'
transmiton    db 'Transmit On ',cr,lf,'$'
offhook          db 'Modem is off hook ',cr,lf,'$'
modemenabled       db 'Modem is Enabled  ',cr,lf,'$'
dial_msg db    'MR;'
$m0    db    'M0;SW0;P4;SS0;LI1;'
len_$m0     equ $-$m0
$m1    db    'M1;SW0;P4;SS0;LI1;'
len_$m1     equ $-$m1
$off_m    db    'C2;P0;SS0;SW1;M3;M5;'    ; turn off portable plus
off_len equ    $-$off_m
$off_m110  db  'C2;P0;SS0;SW1;MH;'    ; string to turn off 110 modem
len$off_m110  equ $-$off_m110
need_to_set_baud db  true           ; only set baud when needed
;;need_to_set_flow db  true         ; need to update flow control
;
setktab db    0
setkhlp db    0
crlf    db    cr,lf,'$'
delstr    db    BS,escape,'P','$'
clrlin    db    cr,ESCAPE,'K$'
clreol    db    ESCAPE,'K$'
hpkey    db    escape,'&k0\$'        ; hp keyboard
altkey    db    escape,'&k1\$'        ; alternate keyboard
tekstatustxt db 'Tek Auto Entry: $'
tekbyte db tekonnum
keystatustxt db 'Keyboard: $'
keyflg    db   altkeynum
; escape sequences for turning on the alpha display
; on the 110, we also need to load the character set
; id_terminal will decide which one to use

alpha_disp  db     escape,'[=8h',escape,'[10m','$','xxxxxxxxxxx','$'  ; default
alpha_110  db    escape,'[=8h',escape,'[10m','$'     ; for 110
lenalpha_110 equ $-alpha_110               ; Its length
alpha_plus   db escape,'[=8h',escape,'*dK','$'               ; for plus
lenalpha_plus    equ $-alpha_plus          ; Its length
cursav        db    escape,'[s','$'        ; save the cursor
curres        db    escape,'[u','$'        ; restore cursor
curon        db    escape,'*dQ','$'       ; turn on cursor
curoff        db    escape,'*dR','$'       ; turn off the cursor
old_cursor  dw    ?         ; store alpha cursor position
transfcn    db    escape,'&s0A$'     ; transmit functions,
dialcode    db    32  ;  16 for pulse 32 for tone
termidfail  db escape,'Kermit can not identify terminal type ',cr,lf,'$'
ask_id        db    escape,'*s^','$'   ; is it 110 or plus
dial_saying db 'Enter Number to dial ,=delay ;=cancel P=pulse T=tone.',cr,lf,'$'

rdbuffstrt  dw     ?   ; start of rdbuff for dial_number
canceldial  db    'Dial Cancelled ',cr,lf,'$'
modem_saying db     'Set port to internal modem before dialing ',cr,lf,'$'
onhook_saying db 'Modem is already connected  ',cr,lf,'$'
w_ioctlerr   db cr,lf,'Error in writing to ioctl  ',7,'$'
r_ioctlerr   db cr,lf,'Error in reading ioctl ',7,'$'
io_notready  db cr,lf,'Not ready to write to ioctl ','$'
helpini         db cr,lf,'Press Extended f1 for help in connect mode ',cr,lf,'$'
ourhelptxt   db cr,lf ,'Some Special Keys in Connect Mode: '
         db cr,lf,'Menu clears screen'
   db cr,lf,'User System toggles between alpha and tektronix screens. '
   db cr,lf,'Extended B sends a break ','$'
helpplus  db cr,lf, 'Extended = also clears the screen '
  db cr,lf,'Extended - also toggles between alpha and tektronix screens','$'
help110      db cr,lf, 'Press Extended D to dial a number ','$'
helpend      db  cr,lf,cr,lf,'Press any key to return to connect mode','$'
telflg    db    0        ; non-zero if we're a terminal
xofsnt    db    0        ; Say if we sent an XOFF
xofrcv    db    0        ; Say if we received an XOFF
invseq    db    ESCAPE,'&dB$'    ; Reverse video
nrmseq    db    ESCAPE,'&d@$'    ; Normal video
ivlseq    db    80 dup (' '),cr,'$'    ; make line inverse video
prthnd    dw    0        ; Port handle
argadr    dw    ?        ; address of arg blk from msster.asm
parmsk    db    ?        ; 8/7 bit parity mask, for reception
flowoff db    ?        ; flow-off char, Xoff or null (if no flow)
flowon    db    ?        ; flow-on char, Xon or null
captrtn dw    ?        ; routine to call for captured output
tempbuf dw    10 dup(?)
prttab    dw    com1,com2,com3
com1    db    'COM1',0
com2    db    'COM1',0    ; this gets changed on plus
com3    db    'COM2',0
blank    db    ESCAPE,'H',ESCAPE,'J$'
movcur    db    ESCAPE,'&a'
colno    db    20 dup(?)
ten    db    10
temp    dw    0
temp1    dw    0        ; Temporary storage
temp2    dw    0        ; Temporary storage
tempbyte db    0

;;new stuff to scan escape sequences from comm port  [jan]
stringtab     dw    tekst1,tekst2     ; strings for matching
         dw    badst1,badst2
numstrings    equ   4            ; number of strings to match
disptab        dw    toteknoplay,totekplay      ; dispatch table
        dw    ignoreall, ignoreall
tekst1        db    escape,'[?38h',0    ;1st string to get into tek mode [jan]
tekst2        db    escape,FF,0    ;2nd string to get into tek mode [jan]

badst1 db   escape,'[=8h',0        ; ignore alpha on sequence
badst2 db   escape,'[=10h',0        ; ignore graph on sequence

stringchekbuff       db     16 dup (0)
stringchekcnt       dw     0           ;characters already in buffer
matchsofar    dw    false        ; no match yet
match        dw    0
playem        db    false        ;don't play back switch characters
; end of data for string scannine
prtrdy           db   true         ; if false, we get out of connect mode

keydelay    dw    0

scrsavseg    dw  ?             ; segment of screen memory
line_len    dw  ?             ; words in a line
line_ofs    dw  ?             ; ofset between adjacent lines
num_lines    dw  ?             ; number of lines in screen memory

ints_set       db    false         ; interrupts vectors set?
need_break     db    false
brk_int        equ  58h         ; break key interrupt
savbrko        dw   ?             ; save offset of break interrupt
savbrks        dw   ?             ; save segment of break interrupt

vtstbl    stent <srchkw,keystatustxt,termtb,keyflg> ; tell keyboard for status
    stent <srchkw,tekstatustxt,termtb,tekbyte> ; tell keyboard for status
    dw    0                ; end of table

; Entries for choosing communications port. [19b]
comptab db    3        ; 7 entries. Rewritten by [jrd]
    mkeyw    'Serial',1
    mkeyw    'Modem',2
    mkeyw    '82164A',3         ; 3 is hpil

setchtab  db 1      ; set file character-set table
    mkeyw  'CP437',437

termtb    db    6
    mkeyw    'HP2621',ttgenrc
    mkeyw    'Tek4010',tttek
    mkeyw    'HpKeyBoard',hpkeynum
    mkeyw    'AltKeyBoard',altkeynum
    mkeyw    'EnableTek', tekonnum
    mkeyw    'DisableTek',tekoffnum

defbaud equ  7                ; default baud rate
port1    prtinfo <defbaud,0,defpar,1,0,defhand,floxon,0>
port2    prtinfo <defbaud,0,defpar,1,0,defhand,floxon,0>
port3    prtinfo <defbaud,0,defpar,1,0,defhand,floxon,0>
portval dw    port2            ; Default is to use port 1

bdtab    db    15            ; Baud rate table

    mkeyw    '50',0
    mkeyw    '75',1
    mkeyw    '110',2
    mkeyw    '134',3
    mkeyw    '150',4
    mkeyw    '300',5
    mkeyw    '600',6
    mkeyw    '1200',7
    mkeyw    '1800',8
    mkeyw    '2400',9
    mkeyw    '3600',10
    mkeyw    '4800',11
    mkeyw    '7200',12
    mkeyw    '9600',13
    mkeyw    '19200',14
ourbdtab db '1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'

;    variables for serial interupt handler

source    db    260  DUP(?)  ; buffer for data from port
bufout    dw    0        ; buffer removal pointer
count    dw    0        ; number of chars in int buffer
bufin    dw    0        ; buffer insertion pointer
; variable for fast write on plus
plus_char  db 'R',0

ourarg    termarg <>
asciitab  db '0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'


data   ends

code    segment public 'code'
    extrn    comnd:near, dopar:near, atoi:near, prompt:near
    extrn    sleep:near
    extrn    tekcls:near
    extrn    msuinit:near, keybd:near    ; in msuhpx
    extrn    tekemu:near,tekini:near
    extrn    sbrk:near            ; memory allocator
    extrn    statc:near, srchkw:near

    assume    cs:code,ds:data,es:data

;check string to see if we need to do something special

stringchek  proc  near
       cmp   stringchekcnt,0     ; nobody in yet?
       jne   stringchek1     ; ne => already have characters
       cmp   al,escape         ; is this escape?
       je    stringchek1     ; it is escape, so go and process
       cmp   al,escape+80h     ; in case parity is odd
       je    stringchek1     ; process escape
       stc             ; display the character
       ret             ; return quickly if nothing to do
stringchek1:             ; here is escape already in
       saveregs
       and     al,07fh         ;strip high bit
       mov     bx,stringchekcnt
       mov     stringchekbuff[bx],al  ;put character in buffer
       inc     stringchekcnt          ;one more character in buffer
       call    stringtest     ; does the string in stringchekbuff match?
       cmp    match,0         ; 0 means no match
       je      stringchek2
       mov     si,match           ; here means we have a match
       shl     si,1           ; multiply by 2
       dec     si
       dec     si           ; 1=0, 2=1 etc
       call    disptab[si]       ; call appropriate function
       call    stringbuffplay          ; play back the buffer
       clc               ; don't display
       jmp     stringchek3       ; return and don't display character
stringchek2:
     clc              ; don not display
     cmp   matchsofar,true      ; do we have a match so far
     je    stringchek3         ; e=true , get out
     mov   playem,true
     call  stringbuffplay           ; clean out the buffer
     clc               ; don't display character
stringchek3:
     restoreregs
     ret
stringchek   endp

;test to see if input string is a match to toggle terminal  [jan]


; stringtab gives addresses of 0 terminated strings
; teststring in stringchekbuff
;numstrings is the number to checked
; matchsofar will have be true if there is a possilbe match
; match will be non-zero 1, 2, 3 indicating number of match if a match
; if no match yet, match will be 0
; severaal registers get destroyed
stringtest proc near
    mov    matchsofar, false      ; assume no match
    mov    match,0            ; no match
    xor    si,si            ; pointer to string tab
    dec    si
    dec    si            ; step back 1 item
    mov    cx,0            ; cx points to number of string
strtst1:
    inc    cx            ; strings number
    cmp    cx,numstrings        ; done parsing table?
    ja    strtst5            ; we're done, get out of here
    mov    di, offset stringchekbuff
    inc    si
    inc    si            ; point to next item
    mov    bx,stringtab[si]    ; offset of string
strtst2:
    mov    al,[di]            ; stringchekbuff in al
    mov    ah,[bx]            ; string element to test in ah
    cmp    al,0            ; end of stringchekbuff
    jne    strtst2a        ; ne=> not at end of buffer
    mov    matchsofar,true        ; we have a match so far
    jmp    strtst5            ; return to caller
strtst2a:
    cmp    ah,0            ; at end of string?
    je    strtst1            ; failure, go to next string
    cmp    ah,al            ; match?
    jne    strtst1            ; no match, on to next string
                    ; here if match
    mov    ah,[bx+1]        ; next byte from string
    cmp    ah,0            ; are we done with string?
    je    strtst3            ; e => yes, a match
    inc    bx            ; next element in string
    inc    di            ; next character in stringchekbuff
    jmp    strtst2            ; check next item in string
strtst3:                ; here if we have a match
     mov    match,cx        ;
     mov    matchsofar,true        ;
strtst5:
    ret
stringtest endp



;play back characters in string buffer ..called by stringchek
stringbuffplay proc near
      xor      bx,bx          ;bx=0
      mov      cx,stringchekcnt
stringbuffplay1:
      mov      al,stringchekbuff[bx]
      cmp      playem,true    ;playback characters?
      jne      stringbuffplay2     ;ne = no don't play back
      push     bx          ; save index
      push     cx          ; save count
      call     outtty          ; print the character
      pop      cx          ; restore count
      pop      bx          ; restore index
stringbuffplay2:
     mov      stringchekbuff[bx],0  ;set to 0
     inc      bx          ;point to next character
     loop     stringbuffplay1     ;repeat until buffer is empty
     mov      stringchekcnt,0     ;now no characters in buffer
     ret
stringbuffplay endp

ignoretek proc near           ; ignore this escape sequence in tek mode
    mov playem,false
    cmp flags.vtflg,tttek      ; are in in tek emulation
    je    ignoretek1           ; e=yes do not play back
    mov playem,true
ignoretek1:
     ret
ignoretek endp

ignoreall proc near   ; always ignore this escape sequence
     mov playem,false
     writechar bell
     ret
ignoreall endp

totekplay proc near           ; turn on tektronix
      mov playem,true           ; play back characters
      jmp totek
totekplay endp

toteknoplay proc near
     mov playem,false
     jmp  totek
toteknoplay endp


totek proc near           ; turn on tektronix
       test    denyflg,tekxflg     ;tek auto entry enabled?
       jz     totek1
       mov playem,true        ; play back characters
       ret
totek1:

   cmp    flags.vtflg,tttek    ; already doing tek
   je    totek2
   call termtog            ; toggle to tektronix
totek2:
    ret
totek endp


setkeyboard proc   near         ; set appropriate keyboard
     cmp   keyflg,altkeynum    ; want alternate keyboard
     je      setkbd1        ; e=> set altkeyboard
     call  sethpkey
     ret
setkbd1:call setaltkey
     ret
setkeyboard endp

sethpkey  proc    near
    writestring hpkey
    ret
sethpkey  endp

setaltkey proc near
     writestring altkey
     ret
setaltkey endp

scrsavinit   proc  near         ; set up memory block to save screen memory [jan]
    saveregs
    mov         ax,num_rows

    mov         cl,9
    shl         ax,cl
    mov         bx,ax         ; bx=512*num_rows
    mov         ax,num_rows
    mov         cl,7
    shl         ax,cl         ; ax=128*num_rows
    add         ax, bx         ; ax=640*numrows
    mov         cx,ax         ; save num bytes in cx
    push     cx
    call     sbrk         ; memory manager
    pop         cx             ; recover number of bytes
    shr         cx,1         ; cx has number of words
    mov         scrsavseg,ax    ; save it
    xor         ax,ax
    mov         di,ax
    mov         es,scrsavseg
    rep         stosw
    restoreregs
    clc
    ret
scrsavinit endp

savescr         proc     near    ; save dislply memory
     saveregs            ; save the registers
     mov    di,0        ; tek page by default
     mov    line_len,60        ; bytes in tek line
     mov    line_ofs,64        ; bytes between adjacent tek lines
     mov    ax, num_rows    ; number of rows
     shl    ax,1          ; each row has 8 lines
     shl    ax,1          ; so multipy by 8
     shl    ax,1
     mov    num_lines,ax
     xor    si,si        ; tek display starts at 8000:0000
     xor    dx,dx        ; dx points to offset of current line
     cmp    flags.vtflg,tttek    ; doing tek emulation?

     je        savesc1        ; je means yes we are doing tek
     cmp    bigscreen,0        ; don't save for 110
     jne     savesca        ; ne=> we have a plus
;;    here if saving for hp110
      mov di,graph_bytes   ; here if saving 110 screen
      mov    line_len,128     ; each line is 128 bytes
      mov    line_ofs, 128    ; lines offset by 128 bytes
     call    askcursor        ; cursor location in dx
     mov    old_cursor,dx     ; save old cursora
     writestring  curoff    ; turn off the cursor
     in        al,0e6h         ; get row number at display top
      and     al,63        ; insurance
     xor     ah,ah
     mov     cl,7
     shl     ax,cl
     mov     dx,ax
     mov     si,dx
     mov     ax,num_rows
     mov     num_lines,ax
     jmp     savesc1        ; do the save
savesca:
     mov    di,graph_bytes      ; here if saving alpha screen
     mov    line_len,160    ; bytes in alpha line
     mov    line_ofs,256    ; bytes between adjacent alpha lines
     call    askcursor        ; cursor location in dx
     mov    old_cursor,dx     ; save old cursora
     writestring  curoff    ; turn off the cursor
     in        al,83h        ; get row number of display top
     mov    ah,al        ; multiply by 256 to get byte number
     xor    al,al
     mov    dx,ax         ; offset of alpha display start in dx
     mov    si,dx
     mov    ax,num_rows
     mov    num_lines,ax     ; each row is one line in alpha
savesc1:
     mov     ax,scrsavseg      ; screen save segment
     mov     es,ax
     mov     cx,num_lines
savesc2:
     push    cx             ; save number of lines
     mov     cx,line_len
     shr     cx,1         ; words = bytes/2
     mov     ax,8000h         ; screen memory segment
     push    ds
     mov     ds,ax
     cld
     rep     movsw         ; move line
     pop     ds             ; get back kermit's ds
     pop     cx             ; get back line number
     add     dx,line_ofs     ; point to beginning of next line
;  check for wrap on hp110
     cmp     bigscreen,1     ; is it a plus?
     je         savesc2a         ; = means yes, it is a plus
     cmp     flags.vtflg,tttek     ; tek emulation?
     je         savesc2a         ; e=> yes, don't worry about wrap
     cmp     dx,128*48         ; ready to wrap around on hp110?
     jb        savesc2a        ; ne=> not there yet
     mov     dx,0         ; point to first line on hp110 display
;  end of wrap check on hp110
savesc2a:
     mov     si,dx
     loop savesc2         ; do the next line
     cmp    flags.vtflg,tttek     ; doing tek emulation
     je        savesc3         ; yes, don't turn on cursor

     writestring  curon         ; turn on the cursor
savesc3:
savescrex:
     restoreregs         ; restore the registers
     clc             ; all ok
     ret
savescr     endp


restscr         proc     near    ; move ds:si(memory)  to es:di (screen)
     saveregs            ; save the registers
     mov    si,0        ; tek page by default
     mov    line_len,60        ; bytes in tek line
     mov    line_ofs,64        ; bytes between adjacent tek lines
     mov    ax, num_rows    ; number of rows
     shl    ax,1          ; each row has 8 lines
     shl    ax,1          ; so multipy by 8
     shl    ax,1
     mov    num_lines,ax
     xor    di,di        ; tek starts at 8000:0000
     xor    dx,dx        ; dx points to offset of current line
     cmp    flags.vtflg,tttek    ; doing tek emulation?
     je        restsc1        ; je means yes we are doing tek
     writestring alpha_disp      ; reload the hp character set
     cmp     bigscreen,0     ; using the 110  ?
     jne     restsca         ; ne=> we have the plus
     call    cmblnk        ; blank display     on 110
     writestring  curoff    ; turn off the cursor

     mov    si,graph_bytes      ; here if restoring alpha screen
     mov    line_len,128    ; bytes in alpha line
     mov    line_ofs,128    ; bytes between adjacent alpha lines
     in        al,0e6h         ; get row number of display top
    and  al,63        ; insurance
     mov    cl,7           ; multiply by 128 to get byte number
     xor    ah,ah
     shl    ax,cl
     mov    dx,ax         ; dx points to start of line
     mov    di,dx         ; offset of alpha display start
     mov    ax,num_rows
     mov    num_lines,ax
     jmp    restsc1

restsca:
     call    cmblnk        ; blank display
     writestring  curoff    ; turn off the cursor

     mov    si,graph_bytes      ; here if restoring alpha screen
     mov    line_len,160    ; bytes in alpha line
     mov    line_ofs,256    ; bytes between adjacent alpha lines
     in        al,83h        ; get row number of display top
     mov    ah,al        ; multiply by 256 to get byte number
     xor    al,al
     mov    di,ax          ; offset of alpha display start
     mov    dx,di         ; dx points to start of line
     mov    ax,num_rows
     mov    num_lines,ax
restsc1:
     mov     cx,num_lines
restsc2:
     push    cx             ; save number of lines
     mov     cx,line_len
     shr     cx,1         ; words = bytes/2
     mov     ax,8000h         ; screen memory segment
     mov     es,ax         ; es:di points to display memory
     cld
     mov     ax,scrsavseg     ;
     push    ds             ; save kermit's ds
     mov     ds,ax         ; ds points to screen save memory
     rep     movsw         ; move line
     pop     ds             ; get back kermit's ds
     pop     cx             ; get back line number
     add     dx,line_ofs     ; dx points to begin of next lien
     mov     di,dx         ; point to next line in desplay
;  check for wrap around on hp110
     cmp     bigscreen,1     ; using a plus
     je         restsc2a         ;  e=> yes its a plus
     cmp     flags.vtflg,tttek     ; doing tek
     je         restsc2a         ; e=> yes, dont worry about 110 wrap
     cmp     dx,48*128         ; need to wrap
     jb        restsc2a        ; ne=> no
     mov     dx,0
     mov     di,dx
; end of wrap around check on hp110
restsc2a:
     loop restsc2         ; do the next line
     cmp   flags.vtflg,tttek     ; doing tek emulation
     je       restsc3         ; yes, skip the cursor stuff

      mov  dx,old_cursor
      call  poscur
     writestring  curon         ; turn on the cursor
restsc3:
restscrex:
     restoreregs         ; restore the registers
     clc             ; all ok
     ret
restscr     endp

;  identify wether we have hp110 or portable plus
;  if plus then bigscreen = 1 else bigscreen =0
id_terminal proc near
      saveregs
      call clear_key_buffer        ; clear the keyboard buffer if needed
      writestring ask_id        ; ansi termial ask string
      push     ds
      pop      es            ; es=ds for string moves
      call     getkey            ; first key in string is 1 or 4
      cmp  al,'1'            ; 1 for hp110
      jne  id_ter2            ; ne means its a plus
      mov  bigscreen,0
      mov  num_rows,16            ; it's a 110
      mov  graph_bytes,16*60*8          ; bytes in graphics screen
      movsmac hp110_name, machnam, lenhp110_name  ; move name
      movsmac alpha_110, alpha_disp, lenalpha_110  ; mov alpha message
      jmp id_ter4            ; normal exit
id_ter2: mov bigscreen,1         ; its a plus
    mov num_rows,25
    mov graph_bytes,25*60*8        ; bytes in graphics screen
    movsmac plus_name machnam lenplus_name ; move machine name
    movsmac alpha_plus alpha_disp lenalpha_plus ; alpha message
    mov   bx,offset com2
    mov   al,'3'
    mov   [bx+3],al         ; com2 is always modem
      jmp id_ter4             ; normal exit
id_tererr: writestring termidfail
id_ter4: call clear_key_buffer
    restoreregs
    clc
    ret
id_terminal  endp

modem_status_byte proc     near  ; get status byte on 110
    cmp    bigscreen,0         ; is this a 110
    je     modembyte1         ; => yes it is
    mov    al,0             ; no status on plus
    ret
modembyte1:
    saveregs
    mov    dx, offset ask_modem_status
    mov    cx,3                ; 3 bytes
    call   w_ioctl                ; ask the status
    mov    cx,1                ; 1 byte to read
    call   r_ioctl
    restoreregs
    mov    ax, tempbuf           ; retrive the status byte
    clc
    ret
modem_status_byte  endp

modem_status proc near    ; get modem status
       saveregs
       call    modem_status_byte       ; al will contain status
       test   al,2               ; transmit enabled
       jz     modem_stat1
       writestring transmiton
modem_stat1:
       test   al,8              ; is modem off hook?
       jz  modem_stat2
      writestring offhook
modem_stat2:
       test   al,128            ; is the modem enabled?
       jz  modem_stat3
       writestring  modemenabled
modem_stat3:
       restoreregs
       clc
       ret
modem_status endp

dial_number proc near        ; dial a number
    cmp     bigscreen,0          ; is this a 110?
    je     dial_numa          ; e=> yes, do the dial
 ;;   ret            ; don't do anything if its a plus
dial_numa:              ; start code which runs only on 110
    saveregs
    call savescr
    writestring alpha_disp
 ;;   call cmblnk           ; give a nice screen to work with

    cmp     flags.comflg,2           ; using port 2?
    je dial_num0          ; e => yes, we are

    writestring modem_saying   ;
    mov      ax,500           ; wait a second
    call  pcwait
    jmp dial_ex              ; can't dial until port set right
dial_num0:
       call modem_status_byte
       test    al,128           ; is the modem on?
       jz      dial_num1       ; it's not on so ok to dial
       writestring onhook_saying ; tell user he can't dial with modem on
       mov    ax,500
       call   pcwait
       jmp    dial_ex
dial_num1:
      call modem_status
      mov ax,offset rdbuf   ; rdbuf is work buffer
      push ds
      pop es             ; es points to data segment
      mov di,ax               ; let rdbuf be our buffer
      call clear_key_buffer
      writestring dial_saying
      mov    al,'M'
      mov    [di],al
      inc    di
       mov    al,'D'
       mov    [di],al
       inc    di
    mov   rdbuffstrt,di        ; the start location of new characters
      mov    dl,16            ; tone dial is default
dial_num2:
      call getkey            ; get key from user
      cmp   al,8            ; backspace?
      je   dial_num2b            ;  backspace, so erase previous char.
      cmp   al,127            ; delete is also legal backspace
      jne   dial_num2c            ; ne => no backspace
;  here to handle backspace
dial_num2b:
      cmp   di,rdbuffstrt       ; any characters in the command buffer?
      je    dial_num2           ; nobody in yet, so do nothing
      call  dodel           ; write a backspace
      dec   di               ; remove last character from buffer
      jmp   dial_num2           ; get the next character
; end of backspace handler
dial_num2c:
  ;;    writechar al               ; display for user
      cmp  al,cr            ; are we done
      je dial_num8
      cmp  al,';'            ; ':' cancels dial command
      je   dial_num2c1
       cmp al,3                ; control c cancels
      je   dial_num2c1
       cmp  al,escape            ; escape also cancels
       je  dial_num2c1
       jmp  dial_num2d            ; continue
dial_num2c1:       jmp    dial_ex        ; cancel dial command
dial_num2d:
      cmp  al,','            ; pause command
      jne  dial_num2e
      writechar      al            ; write comma to screen
      mov  al,2                ; 2 second delay
      mov  [di],al
      inc  di               ; point to next byte in rdbuf
      jmp  dial_num2
dial_num2e:
      cmp  al,'p'            ; pulse?
      jne  dial_num3
      mov  dl,32
dial_num3: cmp al,'P'           ; pulse ?
     jne dial_num4
      mov  dl,32
dial_num4: cmp al,'t'            ; tone?
       jne dial_num5
     mov dl,16
dial_num5: cmp al,'T'            ; again tone
    jne dial_num6
    mov dl,16
dial_num6: cmp al,'0'
    jb dial_num2          ; ignore this one
     cmp al,'9'          ; is it too big
     ja dial_num2          ; yes, too big, so ignore
     writechar al          ; write it on screen
     sub  al,'0'          ; convert ascii to binary
     add   al,dl          ; add dial code
     mov [di],al          ; put in the read buffer
     inc di              ; next byte in readbuffer
       jmp dial_num2          ; get next key from user
dial_num8:
      mov al,2          ; 2 second delay
      mov  [di],al
       inc    di
       mov al,80          ; enable transmit tone
       mov    [di],al
       inc    di
       mov al,64           ; enable originate mode
       mov    [di],al
        inc di
       mov    al,255           ; terminate dial sequence
        mov [di],al
       inc di
        mov al,';'          ; add semicolon
       mov [di],al
       inc di
       mov al,' '           ; finish with a blank
       mov    [di],al
         inc di
         mov al,'$'
         mov [di],al
      ;;  writestring rdbuf

;; now dial string is safely in rdbuf and size in dh
      mov cx,di
      mov  ax,offset rdbuf         ; start of string
      sub  cx,ax         ; cx has bytes in buffer
     push  cx        ; save the number to write
     mov   dx, offset dial_msg
     mov   cx,3
     call  w_ioctl     ; tell pc we want to dial a number
     mov ax,50     ; wait to let things settle
     call pcwait         ; wait 50 ms
     mov  dx,offset     rdbuf
     pop  cx         ; number of byres
     call  w_ioctl
      call modem_status    ; tell user the status

      jmp dial_ok        ; all ok
dial_ex: writestring canceldial
dial_ok:

     mov ax,1000        ; give user time to read message
     call pcwait        ; wait a short while
     cmp  flags.vtflg,tttek ; doing tek
     jne  dial_tog
     call tekini        ; need to reinitialize emulator
dial_tog:
     call restscr
     restoreregs
     clc              ; stay in connect
     ret
dial_number  endp



     askcursor proc near       ; return curor row in dh, column in dl
       mov dx,257           ; default
       saveregs
      call clear_key_buffer    ;
      writestring ask_cursor        ; ansi ask cursor message
       mov ax,50
       call pcwait            ; wait a whill
       xor cx,cx
askcur1:
       call getkey
       inc cx
       cmp cx,20
       ja askcurex
       cmp al,'['
       jne askcur1
      xor bx,bx             ; keep row number in bx

askcur2:
      call getkey
      cmp al,';'           ; this signifies start of column report
      je askcur3
      sub al,'0'           ; make binary
      mul10 bx               ; multiply by 10
      add bl,al
       inc cx
       cmp cx,20
       ja askcurex
      jmp askcur2           ; repeat until done

askcur3: mov dh,bl           ; row in dh
       xor bx,bx           ; now get column
askcur4:  call getkey
      cmp al,'R'           ; this signifies start of column report
      je askcur5
      sub al,'0'           ; make binary
      mul10 bx               ; multiply by 10
      add bl,al
    inc cx
    cmp cx,20
    ja askcurex
      jmp askcur4           ; repeat until done
askcur5: mov dl,bl            ; column in dl
      jmp askcur7
askcurex: writestring badcursor
askcur7: clc
     mov temp1,dx
     restoreregs
      mov dx,temp1
      dec  dh   ; map (1,1) to (0,0)
      dec  dl
     ret
askcursor endp


 getkey proc near    ; wait for a key to be typed
  mov ah,7
  int dos
  ret
getkey endp

clear_key_buffer  proc    near
       saveregs
clear_key1:
       mov ax,0600h
       mov dx,0ffffh
       int dos
       jnz clear_key1
       restoreregs
       clc
       ret
clear_key_buffer  endp

ourhelp proc near   ; give user some help
     saveregs
     call savescr     ; save current screen
     writestring alpha_disp; be sure alpha is on
     call cmblnk    ; blank the screen
     writestring  ourhelptxt
     cmp  bigscreen,1       ; do we have a plus ?
     je      ourhelp1
     writestring   help110
     jmp  ourhelp2
ourhelp1: writestring helpplus
ourhelp2: writestring  helpend
      call getkey     ; user types a key when done reading
      cmp   flags.vtflg,tttek  ; doing tek emulation
      jne   ourhelp3           ; ne => we're doing alpha screen
      call  tekini           ; need to reinitialize the emulator
ourhelp3:
      call restscr     ; give him back his previous screen
      restoreregs
      clc         ; stat in connect mode
      ret
ourhelp endp

getrepchr proc    near          ; get replay character for file
      mov    ah,readf2          ; read from replay file
      mov    bx,diskio.handle
      mov    cx,1          ; read 1 character
      mov    dx,offset rdbuf  ; to this buffer
      int    dos
      jc     getrepchr1          ; c => failure
      cmp    ax,cx          ; read the byte?
      jne    getrepchr1
      mov    al,rdbuf          ; al has character
      clc              ; character available in al
      ret


getrepchr1:
      call   beep         ; announce file is done
      call   beep
      call   getkey         ; wait for a key to be pressed
      mov    prtrdy,false    ; so we exit connect mode
      stc
      ret             ; no character available
getrepchr    endp

repchrout  proc     near        ; process key in al  while replaying
    and   al,7fh        ; strip parity
repchrout1:
    cmp   al,'C'-40h    ; Control C?(to exit playback mode)
    je    repchrout3    ; e=> yes, return failure
    cmp   al,XOFF        ; user wants to stop?
    jne   repchrout2    ; ne => ok to continue
    call  getkey        ; wait and get a key
    jmp   repchrout1    ; now process this key
repchrout2:
    clc            ; return success
    ret
repchrout3:
    mov   prtrdy,false    ; exit terminal
    stc            ; exit connect mode
    ret
repchrout  endp


; Clear the input buffer. This throws away all the characters in the
; serial interrupt buffer.    This is particularly important when
; talking to servers, since NAKs can accumulate in the buffer.
; Returns normally.

CLRBUF    PROC    NEAR
    cmp    repflg,0  ; don't clear if replaying
    je    clrbuf0
    ret
clrbuf0:
    push    ax      ; necessary for msghpx
    mov    bufin,offset source
    mov    bufout,offset source
    mov    count,0
clrbuf1: call prtchr    ; empty out firmware buffer
     jnc clrbuf1
     pop  ax
     ret
CLRBUF    ENDP

; Clear to the end of the current line.     Returns normally.

CLEARL    PROC    NEAR
    push    ax            ; save regs
    push    dx
    mov    ah,prstr
    mov    dx,offset clreol
    int    dos
    pop    dx
    pop    ax
    ret
CLEARL    ENDP
; Put the char in AH to the serial port.  This assumes the
; port has been initialized.  Should honor xon/xoff.
; clc upon success (for 3.00)
OUTCHR     PROC  NEAR
     push cx         ; save regs
    or ah,ah        ; sending a null?
    jz outch2        ; z = yes
    xor cx,cx        ; clear counter
    cmp ah,flowoff        ; sending xoff?
    jne outch1        ; ne = no
    mov xofsnt,false    ; supress xon from chkxon buffer routine
outch1: cmp xofrcv,true        ; Are we being held?
    jne outch2        ; No - it's OK to go on
    loop outch1        ; held, try for a while
    mov xofrcv,false    ; timed out, force it off and fall thru
outch2: push dx            ; Save register
    mov al,ah        ; Parity routine works on AL
    call dopar        ; Set parity appropriately
                ; Begin revised output routine
      ;;  and al,07fh
    mov byte ptr temp,al    ; put data there
    cmp prthnd,0        ; Got a handle yet?
    jne outch3        ; Yup just go on
    call opnprt        ; Else 'open' the port
outch3: push    bx
    mov    bx,prthnd    ; port handle
    mov    cx,1        ; one byte to write
    mov    dx,offset temp    ; place where data will be found
    mov    ah,write2    ; dos 2 write to file/device
    int    dos
    pop    bx        ; end of revised routine
    pop dx
    pop cx
    jc   outch4        ; stc => failure
    clc            ; clc for success
    ret
outch4: writestring write2err
    stc
    ret
OUTCHR    ENDP
; This routine blanks the screen.   Returns normally.

CMBLNK    PROC    NEAR
    push    ax        ; save regs
    push    dx
    mov    ah,prstr
    mov    dx,offset blank
    int    dos
    pop    dx
    pop    ax
    ret
CMBLNK    ENDP

; Homes the cursor.    Returns normally.

LOCATE    PROC    NEAR
    mov    dx,0        ; Go to top left corner of screen
    jmp    poscur
LOCATE    ENDP

; Write a line at the bottom of the screen...
; the line is passed in dx, terminated by a $.    Returns normally.
putmod    proc    near
    push    dx        ; preserve message
    mov    dx,1800H    ; assume plus
     cmp    bigscreen,0    ; is it a 110?
     jne    putmod1        ; ne => its a plus
    mov    dx,0F00H    ; now address line 15
putmod1:
    call    poscur
    mov    dx,offset invseq    ; put into inverse video
    mov    ah,prstr
    int    dos
    pop    dx        ; get message back
    int    dos        ; print it
    mov    dx,offset nrmseq    ; normal video
    int    dos
    ret
putmod    endp

; clear the mode line written by putmod.  Returns normally.
clrmod    proc    near
    mov    dx,1800H       ; plus by default
    cmp    bigscreen,0    ; is it a 110?
    jne    clrmod1           ; ne => it is a plus
    mov    dx,0F00H
clrmod1:
    call    poscur        ; Go to bottom row
    call    clearl        ; Clear to end of line
    ret
clrmod    endp

; Put a help message on the screen.
; Pass the message in ax, terminated by a null.     Returns normally.
puthlp    proc    near
    push    dx        ; save regs
    push    si
    push    ax        ; preserve this
    mov    ah,prstr
    mov    dx,offset crlf
    int    dos
    pop    si        ; point to string again
puth0:    mov    ah,prstr
    mov    dx,offset invseq    ; put into reverse video
    int    dos
    mov    ah,prstr
    mov    dx,offset ivlseq    ; make line inverse video
    int    dos
    cld
puth1:    lodsb            ; get a byte
    cmp    al,0        ; end of string?
    je    puth2
    mov    dl,al
    mov    ah,conout
    int    dos        ; else write to screen
    cmp    al,lf        ; line feed?
    je    puth0        ; yes, clear the next line
    jmp    puth1
puth2:    mov    ah,prstr
    mov    dx,offset crlf
    int    dos
    mov    dx,offset nrmseq    ; normal video
    int    dos
    pop    si
    pop    dx
    ret
puthlp    endp


; Set the baud rate for the current port, based on the value
; in the portinfo structure.  Returns carry clear.

BAUDST    PROC    NEAR
      saveregs
    mov    dx,offset bdtab        ; baud rate table, ascii
    xor    bx,bx            ; help is the table itself
    mov    ah,cmkey        ; get keyword
    call    comnd
    jc    baudst3            ; c = failure
    push    bx            ; save result
    mov    ah,cmeol        ; get confirmation
    call    comnd
    pop    bx
    jc    baudst3            ; c = failure
    mov    si,portval
    mov    ax, offset port2
    cmp    ax,si            ; using the modem?
    jne     baudst2         ; ne => no
    cmp    bigscreen,1        ; using plus?
    je    baudst1            ; e => yes
    mov    bx,5              ; only 300 baud legal on 110 modem
    jmp    baudst2
baudst1:cmp    bx,5              ; 300 baud
    je    baudst2            ; 300 baud is ok
    mov    bx,7              ; if not 300, then it's 1200
baudst2:
    mov    ax,[si].baud        ; remember original value
    mov    [si].baud,bx        ; set the baud rate
      ;;  call      dobaud          ; use common code
      ; we set baud rate in SERINI
    mov need_to_set_baud, true    ; we need to update the baud rate

    clc
baudst3: restoreregs
     ret
BAUDST    ENDP

; Set the baud rate for the current port, based on the value
; in the portinfo structure.      Returns normally.
; it is assumed the port is open else w_ioctl returns error

DOBAUD    PROC    NEAR
    cmp  need_to_set_baud, true    ; do we need to update the baud ?
    je  dobaud1               ; e=> yes, update baud rate
    clc                   ; success
    ret                   ; return if not needed
dobaud1:saveregs
    mov    bx,portval
    mov    dx,[bx].baud
    mov    bx,offset ourbdtab
    add    bx,dx             ; point to character in baud tabble
    mov    dx,[bx]
    mov    baudx,dl        ; put into baud rate messge
    mov    cx,4
    mov    dx,offset baudstr    ; point to message
    call w_ioctl
    mov need_to_set_baud, false    ; don't need to reset baud rate
    restoreregs
    ret                ; Must be set before starting Kermit
DOBAUD    ENDP

; USe hardware flow control [jan]... it is assumed the port is open
DOFLOW PROC   NEAR
    saveregs
    mov    bx,portval
    mov  dl,'0'               ; default is no flow control
    cmp  [bx].floflg,0           ; doing flow control ?
    je   doflow1               ; e => no flow control
    mov    dl,'2'
doflow1:mov   flo_x,dl
    mov    dx, offset flo_str    ; C is first character
    mov    cx,3            ; 3 lettters in string
       ;;  writestring flo_str
    call w_ioctl
    restoreregs
    clc                 ; success
    ret
doflow     endp

; Get the current baud rate from the serial card and set it
; in the portinfo structure for the current port.   Returns normally.
; This is used during initialization.

GETBAUD PROC    NEAR
    ret            ; Can't do this
GETBAUD ENDP

; SHOW MODEM - displays status of modem lines DSR, CD, CTS, in this case
; it just says whether or not the port is ready for i/o.
shomodem proc    near
    mov    ah,CMEOL    ; get a confirm
    call    comnd
    jnc    shmod00        ; nc=> success
    ret            ; get out if failure
shmod00:
    cmp    prthnd,0    ; Got a handle yet?
    jne    shmod0        ; Yup just go on
    call    opnprt        ; Else 'open' the port
shmod0: mov    dx,offset msmsg1 ; say port is not ready
    mov    bx,prthnd
    mov    al,7        ; output status command
    mov    ah,ioctl    ; ask DOS to look for us
    int    dos
    jc    shmod1        ; c = call failed, device not ready
    or    al,al
    jz    shmod1        ; not ready
    mov    dx,offset msmsg2 ; say port is ready
shmod1: mov    ah,prstr
    int    dos
     stc
     ret              ; carry set upon failure
shomodem endp

getmodem proc    near
    mov    al,0        ; no modem status
    ret
getmodem endp


; this is not used, but is left in to aid future debugging
printal proc near   ; print the value in al
push di
push ax
push bx
push dx
push ax
push ax
; print a leading space
mov ah,2
mov dl,' '
int dos
;
pop  ax
and  al, 0f0h    ; high nibble
shr al,1
shr al,1
shr al,1
shr al,1  ; high nibble to low nibble
mov di, offset asciitab
xor bx, bx   ; bx=0
mov bl, al
mov dl, [di+bx]
mov ah,2   ; print char
int dos               ; print high nibble
; now the low nibble
pop ax     ; get back original char
and al, 0fh
mov bl,al
mov dl, [di+bx]
mov ah, 2
int dos           ; print low nibble
pop dx
pop bx
pop ax
pop di
ret
printal endp

;;end of msxhpx.h include file
;
;    write cx bytes to ioctl of serial port
;
W_IOCTL PROC    NEAR
    cmp    prthnd,0    ; port opened?
    jne    w_ioctl1b    ; ne => yes it is open
    writechar 'I'
    ret
w_ioctl1b:
    push    ax        ; save regs
    push    bx
    push    cx
    mov    cx,1000        ; knock at port until ready
w_ioctla:

       mov     ah,ioctl           ; first check
    mov    bx, prthnd
    mov    al,7        ; check status
    int    dos
    cmp    al,0ffh        ; ok?
    loopne     w_ioctla    ; try again
    cmp     al,0ffh
    jne    w_ioctl3    ;ne =>     error
    pop    cx        ; retrieve number to write
    mov    ah, ioctl    ; now do write
    mov       al,3
    mov    bx,prthnd
    int    dos
    jnc    w_ioctl2
w_ioctl1:
    writestring w_ioctlerr    ; failure
    stc            ; failure
    jmp   w_ioctl2
w_ioctl3:writestring io_notready
     pop  cx
     stc
w_ioctl2:
    pop    bx
    pop    ax
    ret
W_IOCTL ENDP
;
;    read cx bytes from ioctl of serial port to tempbuf
;
R_IOCTL PROC    NEAR
    cmp    prthnd,0        ; port opened?
    jne    r_ioctl0        ; ne => it is open
    writechar 'R'
    ret
r_ioctl0:
    push    ax            ; save regs
    push    bx
    mov    ah,ioctl
    mov    al,2
    mov    bx,prthnd
    mov    dx,offset tempbuf
    int    dos
    jnc    r_ioctl1       ; all ok
    writestring r_ioctlerr
r_ioctl1:
    pop    bx
    pop    ax
    ret
R_IOCTL ENDP
;
;    check serial port for characters and return number in al
;
CHK_BUFF PROC    NEAR
    push    cx
    push    dx
    mov    dx,offset chk_msg
    mov    cx,2
    call    w_ioctl
    jc    chk_buff1      ; failure
    mov    cx,1
    call    r_ioctl
    jc    chk_buff1    ; failure
    mov    ax,tempbuf
    pop    dx
    pop    cx
    ret
chk_buff1: pop    dx
       pop    cx
       xor    ax,ax        ; no characters upon failure
       ret
CHK_BUFF ENDP


; Use for DOS 2.0 and above. Check the port status. If no data, skip
; return.   Else, read in a char and return.
PRTCHR    PROC    NEAR
    cmp    repflg,0        ; doing replay?
    je    prtch0            ; e => not doing replay
    jmp    getrepchr        ; get replay character if in replay
prtch0:
    push    bx
    push    cx
    push    si
    cmp    prthnd,0        ; got a handle
    jne    prtch1            ; ne = yes
    call    opnprt            ; open port if not
    jc     prt3x            ; exit if error
prtch1: cmp    count,0            ; any chars in buffer?
    jne    prtch2            ; ...yes, get one
    call    chk_buff        ; any chars at port?
    or    al,al            ; ax has characters available
    jz    prtch4            ; no, go to skip return
    mov    ah,0
     mov    cx,ax            ; read as many as are available
;     mov     cx,1             ; read one char
    mov    count,cx
    mov    bx,prthnd
    mov    ah,readf2        ; DOS read from file/device
    mov    dx,offset source
    int    dos
    jc    prt3x            ; c = failure
    mov    count,ax        ; number of bytes read
    mov    bufout,offset source
prtch2: dec    count
    mov    si,bufout
    cld
    lodsb
    mov    bufout,si
prtch3: ;;call printal     ; print character from port
    pop    si
    pop    cx
    pop    bx
    clc
    ret                ; return success
prt3x:    mov    ah,prstr
    mov    dx,offset erms50
    int    dos
prtch4: pop    si
    pop    cx
    pop    bx
    stc                     ; stc means no characters
    ret
PRTCHR    ENDP

tprn  proc near
     ret
tprn endp

breakkey proc near               ; handle pressing of break key
    push  ax
    push  ds
    mov  ax,data
    mov  ds,ax               ; get correct data segment
    mov  need_break,true           ; flag that break needs setting
    pop   ds
    pop   ax
    iret
breakkey endp

; Send a break out the current serial port.    Returns normally.
; sendbrw is worker routine time in milliseconds in ax
SENDBRW     PROC     NEAR
    push    cx
    push    dx
    push    ax         ; save time of break
    mov    dx,offset brk_on
    mov    cx,3
    call    w_ioctl
    pop    ax         ; restore time
    call    pcwait         ; delay the appropriate time
    mov    dx,offset brk_off
    mov    cx,3
    call    w_ioctl
    pop    dx
    pop    cx
    mov  need_break,false         ; don't need to do break
sendbrw1: clc                 ; clear carry to stay in Connect mode
    ret
SENDBRW     ENDP

SENDBR    PROC    NEAR            ; Send a Break
    mov    ax,275            ; 275 ms for normal break
    jmp    sendbrw            ; go to worker routine
SENDBR    ENDP

SENDBL    PROC    NEAR            ; Send a Long Break
    mov    ax,1800            ; 1800 ms for long break
    jmp    sendbrw            ; go to worker routine
SENDBL    ENDP

; IHOSTS - Initialize the host by sending XON, or equivalent, and enter the
; cycle of clear input buffer, wait 1 second, test if buffer empty then exit
; else repeat cycle. Requires that the port be initialized before hand.
; Ihosts is used by the local send-file routine just after initializing
; the serial port.
; 22 March 1986 [jrd]

IHOSTS    PROC    NEAR
    push    ax        ; save the registers
    push    bx
    push    cx
    push    dx
    mov    bx,portval    ; port indicator
    mov    ax,[bx].flowc    ; put Go-ahead flow control char in ah
    or    ah,ah        ; don't send null if flow = none
    jz    ihosts1        ; z = null
    call    outchr        ; send it (release Host's output queue)
     nop            ; outchr can do skip return
     nop
     nop
ihosts1:call    clrbuf        ; clear out interrupt buffer
    pop    dx        ; empty buffer. we are done here
    pop    cx
    pop    bx
    pop    ax
    ret
IHOSTS    ENDP

; IHOSTR - initialize the remote host for our reception of a file by
; sending the flow-on character (XON typically) to release any held
; data. Called by receive-file code just after initializing the serial
; port.        22 March 1986 [jrd]
IHOSTR    PROC    NEAR
    push    ax        ; save regs
    push    bx
    push    cx
    mov    bx,portval    ; port indicator
    mov    ax,[bx].flowc    ; put Go-ahead flow control char in ah
    or    ah,ah        ; don't send null if flow = none
    jz    ihostr1        ; z = null
    call    outchr        ; send it (release Host's output queue)
     nop            ; outchr can do skip return
     nop
     nop
ihostr1:pop    cx
    pop    bx
    pop    ax
    ret
IHOSTR    ENDP

DTRLOW    PROC    NEAR        ; Global proc to Hangup the Phone by making
                ; DTR and RTS low.
    mov ah,CMLINE        ; allow text to be able to display help
    mov bx,offset rdbuf    ; dummy buffer
    mov dx,offset hnghlp    ; help message
    call comnd        ; get a confirm
    jnc  dtrlow1        ; nc => success
    ret            ; get out if failure
dtrlow1:
    call serhng        ; drop DTR and RTS
    mov ah,prstr        ; give a nice message
    mov dx,offset hngmsg
    int dos
    clc               ; carry clear for success
    ret
DTRLOW    ENDP

; Hang up the Phone. Similar to SERRST except it just forces DTR and RTS low
; to terminate the connection. 29 March 1986 [jrd]
; Calling this twice without intervening calls to serini should be harmless.
; Returns normally.
; Adapted from recommendation by Mike Mellinger. [jrd]
SERHNG    PROC    NEAR
    saveregs
    cmp    prthnd,0    ; is the port open
    je    serhn1        ; e => it is closed
      ;     mov     ax,offset port3
      ;     cmp     ax,portval
      ; je    serhn4        ; don't do anything for 82164A
    cmp    bigscreen,1    ; do we have the plus?
    je    serhn2        ; yes we do
    mov    dx,offset $off_m110  ; separate hangup for 110
    mov    cx,len$off_m110
    jmp    serhn3
serhn2:
    mov    dx,offset $off_m ; magic words to turn off DTR
    mov    cx,off_len    ; their length
serhn3:
     call w_ioctl         ; write them
serhn4:     mov     bx,prthnd      ; close port
     mov     ah,close2     ; close the device
    int    dos
    mov    prthnd,0    ; port no longer open
    mov    ax,1000
    call    pcwait         ; delay so hangup can work
serhn1:
    restoreregs
    ret
SERHNG    ENDP

; Wait for the # of milliseconds in ax, for non-IBM compatibles.
; Thanks to Bernie Eiben for this one.
pcwait    proc    near
    mov    cx,240        ; inner loop counter for 1 millisecond
pcwai1: sub    cx,1        ; inner loop takes 20 clock cycles
    jnz    pcwai1
    dec    ax        ; outer loop counter
    jnz    pcwait        ; wait another millisecond
    ret
pcwait    endp


; Position the cursor according to contents of DX:
; DH contains row, DL contains column.    Returns normally.
POSCUR    PROC    NEAR
    push    ax            ; save regs
    push    dx
    push    di
    mov    ax,ds
    mov    es,ax            ; address data segment!!
    cld
    mov    di,offset colno
    mov    al,dl            ; column
    call    nout
    mov    al,'x'
    stosb
    mov    al,dh            ; row
    call    nout
    mov    al,'Y'
    stosb
    mov    al,'$'
    stosb
    mov    dx,offset movcur
    mov    ah,prstr
    int    dos            ; print the sequence
    pop    di
    pop    dx
    pop    ax
    ret
POSCUR    ENDP

NOUT    PROC    NEAR
    cbw            ; extend the word
    div    byte ptr ten    ; divide by ten
    or    al,al        ; any quotient?
    jz    nout1        ; no, forget this
    push    ax        ; save current result
    call    nout        ; output high order
    pop    ax        ; restore
nout1:    mov    al,ah        ; get digit
    add    al,'0'        ; make printable
    stosb            ; put in buffer
    ret            ; and return
NOUT    ENDP

; Delete a character from the terminal.     This works by printing
; backspaces and spaces.  Returns normally.

DODEL    PROC    NEAR
    push    ax            ; save regs
    push    dx
    mov    ah,prstr
    mov    dx,offset delstr    ; Erase weird character
    int    dos
    pop    dx
    pop    ax
    ret
DODEL    ENDP

; Move the cursor to the left margin, then clear to end of line.
; Returns normally.

CTLU    PROC    NEAR
    push    ax            ; save regs
    push    dx
    mov    ah,prstr
    mov    dx,offset clrlin
    int    dos
    call    clearl
    pop    dx
    pop    ax
    ret
CTLU    ENDP

; Set the current port.

COMS    PROC    NEAR
    mov    dx,offset comptab    ; table of comms ports
    mov    bx,0            ; use keywords as help
    mov    ah,cmkey        ; parse a keyword
    call    comnd
    jnc    coms1            ; nc => success
    ret                ; get out if failure
coms1:    push    bx
    mov    ah,CMEOL
    call    comnd            ; Get a confirm
    jc   comx               ; carry => failure

    call    serr_x            ; force close on serial port

    pop    bx
    mov    flags.comflg,bl        ; Set the comm port flag
    cmp    flags.comflg,1        ; Using Com 1?
    jne    coms2            ; ne = no
    mov    portval,offset port1
    clc                ; carry clear for success
    ret
coms2:    cmp    bl,2            ; using com2?
    jne    coms3            ; ne = no
    mov    portval,offset port2
    clc                ; success [jan]
    ret
coms3:
    mov    portval,offset port3
    clc                 ; success [jan]
    ret
comx:    pop    bx
    stc                 ; carry set for failure [jan]
    ret
COMS    ENDP

; Set tektronix emulation on/off

VTS    PROC    NEAR
      mov     dx,offset termtb
      mov     bx,0
      mov     ah,cmkey
      call    comnd
      jnc    vts00          ; nc => success
      ret              ; return if failure
vts00: push    bx
      mov     ah,CMEOL
      call    comnd          ; Get a confirm
      jc      vtx          ; carry => didn't get a confirm
      pop     bx
      cmp     bl,hpkeynum      ; want hpkeyboard
      jne     vts0          ; ne => no
      mov     keyflg,hpkeynum
      call    setkeyboard
      clc
      ret
vts0: cmp     bl,altkeynum       ; want alt keyboard?
      jne     vts0a           ; ne=> no
      mov     keyflg,altkeynum       ; turn on altkeyboard
      call    setkeyboard
      clc
      ret
vts0a:    cmp   bl, tekonnum       ; enable tek ?
      jne   vts0b           ; ne => don't enable
      and   denyflg, not tekxflg   ; clear tekxflgbit
      mov tekbyte, bl           ; for status display
      clc
      ret
vts0b: cmp bl, tekoffnum       ; disable tek ?
    jne vts1           ; ne=> don't disable
    or  denyflg, tekxflg       ; set deny tek bit
    mov  tekbyte, bl       ; for status
    clc
    ret
vts1:
      mov     flags.vtflg,bl       ; Set the Tektronix emulation flag [jan]
      mov     tekflg,0           ;need to re-initialize tek emulator [jan]
      clc               ; success
      ret
vtx:  pop bx
      stc              ; carry set => failure
      ret
VTS    ENDP

VTSTAT    PROC    NEAR    ; For Status display [jrd]
       mov  bx,offset vtstbl  ; table of things to show
       jmp  statc          ; common status code
      ;;  ret          ; no emulator status to display
VTSTAT    ENDP

; Save the screen to a buffer and then append buffer to a disk file. [jrd]
; Default filename is Kermit.scn; actual file can be a device too. Filename
; is determined by mssset and is passed as pointer dmpname.

DUMPSCR PROC    NEAR    ; Dumps screen contents to a file. Just Beeps here
    call    beep
    ret
DUMPSCR ENDP


; Initialize variables to values used by the generic MS DOS version.
lclose    proc  near
     call sethpkey       ; turn on hp keyboard
     ret
lclose     endp

lpop     proc  near          ; executed when returing from dos
     call  setkeyboard    ; turn on the appropriate keyboard
     ret
lpop     endp

lpush    proc  near       ; call before pushing to dos
    call  sethpkey    ; turn on hp keyboard
    ret
lpush    endp

lclini     proc    near
    saveregs
    mov    dosnum,200h    ; force dosnum to 2.00 so replay proc works
    mov    prtrdy,true    ; port is ready
    call    msuinit        ; init keyboard translator
    mov    lclexit, offset lclose ; let mssker know that lclose exists
    mov    lclsusp, offset lpush  ; for mssker (optional)
    mov    lclrest, offset lpop
    mov    flags.vtflg,0    ; Don't do terminal emulation
 ;;    mov    prthnd,0      ; no port handle yet. [jrd]
 ;;    call    opnprt          ; Get file handle for comm port
;;    mov portval, offset port2
;;    mov flags.comflg,2    ; modem on at startup
    mov    portval, offset port1
    mov    flags.comflg, 1      ; serial port is default at startup
    call    setkeyboard    ; turn on keyboard
    call    id_terminal    ; do we have 110 or portable plus?
    cmp    bigscreen,1    ; using a plus
    je    lclini1           ; e=> yes we are
    mov    bx,offset port2
    mov    [bx].baud,5    ; modem on 110 = 300 baud

lclini1:
    call    scrsavinit       ; initialize memory for screen save
    writestring alpha_disp       ; turn on the alpha display
    call    savescr           ; save an alpha screen to initialize
    writestring helpini
    restoreregs
    clc
    ret

lclini     endp

; Get a file handle for the communications port.  Use DOS call to get the
; next available handle.  If it fails, ask user what value to use (there
; should be a predefined handle for the port, generally 3).    The open
; will fail if the system uses names other than "COM1", "COM2", "COM3","AUX".
opnprt proc near
    call serr_x        ; close port if already open
    mov    ax, portval
    cmp    ax, offset port1
    jne    opnprt0
    mov    flags.comflg,1
    jmp    opnprt0d      ; proceed with the open
opnprt0:
    mov    ax, portval
    cmp    ax, offset port2
    jne    opnprt0a
    mov    flags.comflg,2
    jmp    opnprt0d      ; proceed with the open
opnprt0a:
    mov    ax, portval
    cmp    ax, offset port3
    jne    opnprt0b
    mov    flags.comflg,3
    jmp    opnprt0d      ; proceed with the open
opnprt0b: mov portval, offset port1  ; if all else fails
      mov flags.comflg, 1

opnprt0d:
    mov    al,flags.comflg


    dec    al        ; flags.comflg = 1 for com1, 2 com2, 3 com3
    mov    ah,0
    mov    si,ax
    shl    si,1            ; double index
    mov    dx,prttab[si]
    mov    ah,open2
    mov    al,2
    int    dos
    jnc    opnpr1
    mov    ah,prstr        ; It didn't like the string
    mov    dx,offset erms41
    int    dos
    mov    prthnd,0        ; clear port file handle
    stc                ; carry set for failure
    ret
opnpr1: mov    prthnd,ax        ; Call succeeded
    mov    ah,ioctl
    mov    al,00h            ; get device info
    xor    dx,dx
    xor    cx,cx            ; 0 bytes to read/write
    mov    bx,prthnd        ; port's handle
    int    dos
    or    dl,20h            ; set binary mode in device info
    xor    cx,cx            ; 0 bytes to read/write
    mov    dh,0
    mov    ah,ioctl
    mov    al,01h            ; set device info
    int    dos
    mov    ax,portval
    cmp    ax,offset port3        ; using 82164A
    jne     opnpr2
    clc             ; don't need to write to 82164a
    ret
opnpr2:
    cmp    ax,offset port1        ; using port1 (serial) ?
    jne     opnpr3              ; ne => no, not using port 1
    mov    dx,offset $m1
    mov    cx,len_$m1
    call     w_ioctl
    clc
    ret
opnpr3: cmp ax, offset port2          ; using modem
    jne   opnpr4              ; ne => not using modem
     mov     dx,offset $m0
    mov    cx,len_$m0
    call    w_ioctl
    clc
    ret

opnpr4: clc
    ret                ; carry clear for success
opnprt     endp

  ; set the interrupt vectors

setints       proc     near
;    save break vector and set to breakkey
;    first save the break existing interrupt
    cmp    ints_set,true           ; interrupt vectors set?
    je    setints1           ; je=>yes, don't reset!
    push    ax
    push    bx
    push    dx
    push    es
    mov    al, brk_int
    mov    ah,35h               ; get interrupt vector
    int    dos               ; es:bx has long pointer
    mov    savbrko,bx           ; offset of routine
    mov    savbrks,es           ; segment
    pop    es
; now set the break interrupt
    push    ds
    mov    dx,offset breakkey     ; address of interrupt routine
    push    cs               ; segment of breakkey is code
    pop    ds               ; ds=cs
    mov    ah,25h               ; set vector call
    mov    al,brk_int           ; break key interrupt
    int    21h               ; set the vector
    pop    ds               ; restore data segment
; end of setting break vector
setints1:
       mov  ints_set,true         ; we have set the interrupts
       pop     dx
       pop     bx
       pop     ax
       clc
       ret
setints     endp

restoreints  proc near            ; restore interrupts
       cmp   ints_set,false        ; have we set interrupts?
       je     restoreints1        ; don't restore if not set!

;     resotore break key interrupt
       push   ds
       mov    dx,savbrko          ; original offset
       mov    ax,savbrks          ; original segment
       mov    ds,ax              ; original segment to ds
       mov     ah,25h              ;
       mov    al,brk_int
       int    dos              ; restore original interrupt
       pop    ds
;;end of restore


restoreints1: mov ints_set,false
          clc
          ret
restoreints   endp



; Initialization for using serial port.     Returns normally.
SERINI    PROC    NEAR
    cld                ; Do increments in string operations
    cmp    prthnd,0        ; Got Handle already?
    jne    ser_x            ; ne = yes, skip open
    ;;    call    setints            ; set interrupt vectors
    call    opnprt            ; open handle
    jc    serin2            ; carry set = failure

ser_x:
    call    dobaud            ; set baud rate
    jc    serin2
    call    doflow             ; set hardware flow control
    jc    serin2
    push    bx
    mov    bx,portval        ; get port
    mov    parmsk,0ffh        ; parity mask, assume parity is None
    cmp    [bx].parflg,parnon    ; is it None?
    je    serin1            ; e = yes
    mov    parmsk,07fh        ; no, pass lower 7 bits as data
serin1: mov    bx,[bx].flowc        ; get flow control chars
    mov    flowoff,bl        ; xoff or null
    mov    flowon,bh        ; xon or null
    pop    bx

    clc                   ; carry clear for success
    ret
serin2: writestring serierr           ; error message

    call serr_x               ; force close on bad port
    stc
    ret
SERINI    ENDP


; Reset the serial port.  This is the opposite of serini.   Calling
; this twice without intervening calls to serini should be harmless.
; Returns normally.

SERRST    PROC    NEAR
    cmp    flags.extflg,0
    jne    serr_x
    ret
serr_x: call serhng        ; close files and hangup
    ;;      mov  need_to_set_flow, true ; need to update flow control
    mov  need_to_set_baud, true ; need to update baud rate
    ret
SERRST    ENDP

; Produce a short beep.     The PC DOS bell is long enough to cause a loss
; of data at the port.    Returns normally.

BEEP    PROC    NEAR
    mov    dl,bell
    mov    ah,dconio
    int    dos
    ret
BEEP    ENDP

; Dumb terminal emulator.  Doesn't work too well above 1200 baud (and
; even at 1200 baud you sometimes lose the first one or two characters
; on a line). Does capture (logging), local echo, debug display, tests
; for printer/logging device not ready. 27 Sept 86 [jrd].
term    proc    near
    saveregs

    mov    argadr,ax        ; save argument ptr
    mov    si,ax            ; this is source
    mov    di,offset ourarg    ; place to store arguments
    push    es            ; save register
    push    ds
    pop    es            ; set es to data segment
    mov    cx,size termarg
    cld
    rep    movsb            ; copy into our arg blk
    pop    es            ; restore reg
    and    ourarg.flgs,not (prtscr) ; no screen printing at startup
    mov    ax,ourarg.captr
    mov    captrtn,ax        ; buffer capture routine
    call    setints            ; set interrupts for connect mode
term0a:
    cmp    flags.vtflg,tttek      ; tek emulation on?
    jne    term0
     call tekini
term0:
    call    restscr            ; restore the screen
    mov    parmsk,0ffh        ; parity mask, assume parity = None
    cmp    ourarg.parity,parnon    ; is parity None?
    je    term1            ; e = yes, keep all 8 bits
    mov    parmsk,07fh        ; else keep lower 7 bits

term1:
    cmp prtrdy,false         ; ready to read port?
    je  term5            ; get out
    call    portchr            ; read char from serial port
    jnc    short term3        ; nc = no char, go on
    cmp    flags.vtflg,tttek    ; doing tek emulation?
    je    term1a               ;e=yes, already doing tek
    call stringchek            ; check for special escape strings
    jnc   short term3        ; nc => don't display
term1a: call    outtty         ; display and capture char [jrd]
term3:
    inc keydelay               ;just check keyboard once
    mov ax,keydelay               ;each eight reads of the port
    and ax,7               ;should speed things up
    jnz term1              ;at higher baud rates [jan]
    cmp    need_break,false      ; do we need to send a break?
    je     term3a              ;e=> no, get next key
    call sendbr              ; do the required break
term3a:
    call    keybd            ; call keyboard xlator, send results
    jnc    term1            ; nc = stay in Connect mode
term5:                    ; [gaw@prc]
    call    savescr            ; save screen [gaw@prc]
    cmp   flags.vtflg,tttek
    jne   term6               ; skip string write if not in tek
    writestring  alpha_disp        ; turn on alpha display for kermit
term6:
    cmp   prtrdy, true        ; need to set kbdflg if wierd exit
    je    term7
    mov  kbdflg,'C'               ; so we exit connect mode
    mov  prtrdy,true
term7:
    call  restoreints        ; restore connect mode interrupts
    restoreregs
    ret                ; and return to caller
term    endp


termtog proc  near        ; toggle terminal type [jan]
    call    savescr        ; save present screen
    cmp    flags.vtflg,tttek ; doing tek emulation ?
    jne    termtog1      ; ne means  doing tek
    writestring  alpha_disp
    mov    flags.vtflg,ttgenrc ; turn on alpha display
    call    restscr           ; restore previous alpha display
    clc
    ret
termtog1:
    mov    flags.vtflg,tttek  ; turn on tek display
    call tekini
    call    restscr        ; restore the previous screen
    clc            ; do not exit Connect mode [jrd]
    ret            ; stay in connect mode
termtog endp

kclrscn proc    near        ; clear screen in text or Tek mode [jrd]
    cmp    flags.vtflg,tttek ; doing Tek emulation?
    jne    kclrsc1        ; ne = no
    call    tekcls        ; blank and some more
    clc            ; stay in Connect mode
    ret
kclrsc1:call    cmblnk        ; blank screen
    clc            ; stay in Connect mode
    ret
kclrscn endp

getflgs     proc  near
     mov al,ourarg.flgs           ;supply flags for msggri [jan]
     ret
getflgs     endp

; put the character in al to the screen, do capture and printing,
; does translation for Set Input command.
; Adapted from msyibm.asm [jrd]
outtty    proc    near
    cmp    flags.vtflg,tttek    ; doing tektronix emulation?
    jne    outtty1            ; ne= not doing tek emulation
    jmp    tekemu            ; do tekemu and return
outtty1:
   ;;      call printal              ; debug
    test    flags.remflg,d8bit    ; keep 8 bits for displays?
    jnz    outnp8            ; nz = yes, 8 bits if possible
    and    al,7fh            ; remove high bit
outnp8: cmp    rxtable+256,0        ; is translation off?
    je    outnp7            ; e = yes, off
    push    bx            ; Translate incoming char [jrd]
    mov    bx,offset rxtable    ; address of translate table [jrd]
    xlatb                ; new char is in al
    pop    bx
outnp7:
    test    ourarg.flgs,capt    ; capturing output? Can be shut off
    jz    outnoc            ; no, forget this part
    push    ax            ; save char
    call    captrtn            ; give it captured character
    pop    ax            ; restore character and keep going
outnoc: test    ourarg.flgs,prtscr    ; should we be printing?
    jz    outnop            ; no, keep going
    push    ax
    mov    ah,print_out        ; write to system printer device
    mov    dl,al
    int    dos
    pop    ax
    jnc    outnop            ; nc = successful print
    push    ax
    call    beep            ; else make a noise and
    call    trnprs            ;  turn off printing
    pop    ax
outnop: cmp    flags.vtflg,0        ; emulating a terminal?
    jnz    outnop1            ; nz = yup, go do something smart
    test    ourarg.flgs,trnctl    ; debug? if so use dos tty mode
    jz    outnp5            ; z = no
    mov    ah,conout
    cmp    al,7fh            ; Ascii Del char or greater?
    jb    outnp1            ; b = no
    je    outnp0            ; e = Del char
    push    ax            ; save the char
    mov    dl,7eh            ; output a tilde for 8th bit
    int    dos
    pop    ax            ; restore char
    and    al,7fh            ; strip high bit
outnp0: cmp    al,7fh            ; is char now a DEL?
    jne    outnp1            ; ne = no
    and    al,3fH            ; strip next highest bit (Del --> '?')
    jmp    outnp2            ; send, preceded by caret
outnp1: cmp    al,' '            ; control char?
    jae    outnp3            ; ae = no
    add    al,'A'-1        ; make visible
outnp2: push    ax            ; save char
    mov    dl,5eh            ; caret
    int    dos            ; display it
    pop    ax            ; recover the non-printable char
outnp3: mov    dl,al
    int    dos
    ret
;outnp4: ;cmp      al,bell          ; bell (Control G)? [jrd]
    ;jne     outnp5             ; ne = no
       ; jmp     beep             ; use short beep, avoid char loss.
outnop1:
outnp5:
    cmp    bigscreen, 1        ; do we have the plus
    jne    outnp5a            ; ne => we just have a 110
    cmp    al,14            ; is the character CTRL N?
    je    outnp6            ; e=> yes, do not print CTRL N
                    ; (CTRL N on Plus messes up character
                    ; set)
    push     si            ; print character on plus
    mov    plus_char,al        ; where si expects it
    mov    bx,6            ; don't know why
    mov    si,offset plus_char    ; write the character
    int    50h            ; special interrupt
    pop    si
    ret

outnp5a:
    mov    ah,conout        ; dostty screen mode
    mov    dl,al            ; write without intervention.
    int    dos            ; else let dos display char
outnp6: ret                ; and return
outtty    endp



; send the character in al out to the serial port; handle echoing.
; Can send an 8 bit char while displaying only 7 bits locally.
outprt    proc    near
    test    ourarg.flgs,lclecho    ; echoing?
    jz    outpr1            ; z = no, forget it
    push    ax            ; save char
    call    outtty            ; print it
    pop    ax            ; restore
outpr1: mov    ah,al            ; this is where outchr expects it
    call    outchr            ; output to the port
    ret
outprt    endp

; Get a char from the serial port manager
; returns with carry on if a character is available
portchr proc    near
    call    prtchr            ; character at port?
    jnc   portc1
portc0: clc                ; no carry -> no character
    ret                ; and return
portc1: and    al,parmsk        ; apply 8/7 bit parity mask
; don't catch anybody [jan]
       ; or     al,al             ; catch nulls
       ; jz     portc0             ; z = null, ignore it
       ; cmp     al,del             ; catch dels
       ; je     portc0             ; e = del, ignore it
    stc                ; have a character
    ret                ; and return
portchr endp

;; keyboard translator action routines, system dependent, called from msugen.
; These are invoked by a jump instruction. Return carry clear for normal
; processing, return carry set to exit Connect mode (kbdflg has transfer char)

;  msu calls this to send keystroke out the port
chrout    proc  near
    cmp    repflg,0        ; in replay mode?
    je    chrout1            ; e=> not doing replay
    jmp    repchrout          ; display the replay character
chrout1:call    outprt               ; put char in al to serial port
    clc                ; stay in Connect mode
    ret
chrout    endp

trnprs: push    ax            ; toggle Copy screen to printer
    test    ourarg.flgs,prtscr    ; are we currently printing?
    jnz    trnpr2            ; nz = yes, its on and going off
    mov    ah,ioctl
    mov    al,7            ; get output status of printer
    push    bx
    mov    bx,4            ; file handle for system printer
    int    dos
    pop    bx
    jc    trnpr1            ; c = printer not ready
    cmp    al,0ffh            ; Ready status?
    je    trnpr2            ; e = Ready
trnpr1: call    beep            ; Not Ready, complain
    jmp    trnpr3            ; and ignore request
trnpr2: xor    ourarg.flgs,prtscr    ; flip the flag
trnpr3: pop    ax
    clc
    ret

klogon    proc    near            ; resume logging (if any)
    test    flags.capflg,logses    ; session logging enabled?
    jz    klogn            ; z = no, forget it
    or    ourarg.flgs,capt    ; turn on capture flag
    push    bx
    mov    bx, argadr        ; update kermits capture flag
    or    [bx].flgs, capt
    pop    bx
klogn:    clc
    ret
klogon    endp

klogof    proc    near            ; suspend logging (if any)
    and    ourarg.flgs,not capt    ; stop capturing
    push    bx
    mov    bx, argadr
    and    [bx].flgs, not capt     ; update kermits capture flag
    pop    bx

klogo:    clc
    ret
klogof    endp

snull:    mov    ah,0            ; send a null
    call    outchr            ; send without echo or logging
    clc
    ret

kdos:    mov    al,'P'            ; Push to DOS
    jmp    short cmdcom
cstatus:mov    al,'S'            ; these commands exit Connect mode
    jmp    short cmdcom
cquit:    mov    al,'C'
    jmp    short cmdcom
cquery: mov    al,'?'
    jmp    short cmdcom
cmdcom: mov    kbdflg,al        ; pass char to msster.asm via kbdflg
    stc                ; say exit Connect mode
    ret

; Jumping here is the same as a ret.

R    PROC    NEAR
    ret
R    ENDP

code    ends
    end