Columbia Kermit/kermit.zip/extra/nyenhuis2.arc/MSXHP1.ASM

Assembly Source File | 1988-07-01 | 23KB | 898 lines

    name msxhp1
; File MSXHP1.ASM
; System dependent module for HP150.
; Use with file MSUHP1.ASM (keyboard translator)
; Last edit: 12 June 1988
; 1 July 1988 Version 2.31
; 11 Jan 1988 update to 2.30 consistency level.
; 1 Jan 1988 version 2.30

    public    serini, serrst, clrbuf, outchr, coms, vts, vtstat, dodel, ctlu
    public    cmblnk, locate, prtchr, dobaud, clearl, lclini
    public    dodisk, getbaud, beep, setkhlp, setktab
    public    machnam, xofsnt, term, poscur, termtb, shomodem, getmodem
    public    clrmod, putmod, puthlp, sendbr, sendbl, showkey, pcwait
    public    ihosts, ihostr, dtrlow, serhng, dumpscr, comptab
    public    chrout, cstatus, cquit
    public    cquery, trnprs, snull, klogon, klogof, kdos

    include mssdef.h

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

wrdev    equ    40H
rddev    equ    3fH
open    equ    3dH
close    equ    3eH
rdchan    equ    2
e_send_break equ 6
e_ioctl    equ    44h        ; DOS i/o control function
passall    equ    0803h        ; Port transparency mode [WHM]

datas     segment    public 'datas'
    extrn    drives:byte, flags:byte, trans:byte
    extrn    portval:word, port1:byte, port2:byte, dmpname:byte
    extrn    kbdflg:byte, rxtable:byte

machnam    db    'HP-150$'
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$'
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
setktab    db    0
setkhlp    db    0
shkmsg    db    '?Not implemented.'
shklen    equ    $-shkmsg
crlf    db      cr,lf,'$'
delstr  db      BS,BS,'  ',BS,BS,'$'     ; Delete string
clrlin  db      cr,ESCAPE,'K$'
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 mode
ivlseq    db    80 dup (' '),ESCAPE,'A','$' ; [ak] Make a line inverse video
tmp    db    ?,'$'
temp    dw    0
temp1   dw      ?               ; Temporary storage
temp2   dw      ?               ; Temporary storage

; Entries for choosing communications port

comptab    db    4            ; four entries
    mkeyw    '1',1
    mkeyw    '2',2
    mkeyw    'COM1',1
    mkeyw    'COM2',2

termtb    db    tttypes            ; entries for Status, not Set
    mkeyw    'Heath-19',ttheath
    mkeyw    'none',ttgenrc
    mkeyw    'Tek4014',tttek
    mkeyw    'VT102',ttvt100
    mkeyw    'VT52',ttvt52

; variables for serial interrupt handler

source    db    bufsiz DUP(?)    ; Buffer for data from port
bufout    dw    0        ; buffer removal ptr
count    dw    0        ; Number of chars in int buffer
bufin    dw    0        ; buffer insertion ptr
telflg    db    0        ; Are we acting as a terminal
clreol    db    ESCAPE,'K$'
prttab    dw    com1,com2    ; rationalized by [jrd]
com1    db    'COM1',0
com2    db    'COM2',0
blank    db    ESCAPE,'H',ESCAPE,'J$'
movcur    db    ESCAPE,'&a'
colno    db    20 dup (?)
ten    db    10
prthnd    dw    0
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(?)
ourarg    termarg    <>
datas    ends

code    segment    public 'code'
    extrn    comnd:near, dopar:near, prserr:near, atoi:near, prompt:near
    extrn    sleep:near
    extrn    msuinit:near, keybd:near        ; in msuhp1.asm
    assume    cs:code, ds:datas, es:nothing

; See how many disk drives we have
DODISK    PROC    NEAR
    mov ah,gcurdsk            ; Current disk value to AL
    int dos
    mov dl,al            ; Put current disk in DL
    mov ah,seldsk            ; Select current disk
    int dos                ; Get number of drives in AL
    mov drives,al
    ret
DODISK    ENDP

; Clear the input buffer before sending a packet

CLRBUF    PROC    NEAR
    cli
    mov ax,offset source
    mov bufin,ax
    mov bufout,ax
    mov count,0
    sti
    cmp prthnd,0        ; have a port handle yet?
    jne clrb1        ; ne = yes, read chars
    ret            ; else just return
clrb1:    call prtchr        ; get a character
     jmp clrb1        ; until there aren't any more
     nop
    ret
CLRBUF    ENDP

; Common routine to clear to end-of-line

CLEARL    PROC    NEAR
    push    ax        ; save regs
    push    dx
    mov    dx,offset clreol
    mov    ah,prstr
    int    dos
    pop    dx        ; restore regs
    pop    ax
    ret
CLEARL    ENDP

dobaud    proc    near        ; updated by [jrd] to set baud
    mov ah,prstr
    mov dx,offset noimp    ; Say it's not implemented
    int dos
    push bx            ; save reg
    mov bx,portval
    mov [bx].baud,0FFFFH    ; So it's not a recognized value
    pop bx
    ret            ; Must be set before starting Kermit
dobaud    endp

; Send the break signal out data comm
sendbl:                    ; long break (same as regular here)
sendbr:    mov    al,e_send_break        ; regular break
    call    dc_ioctl
    clc                ; clear carry bit (stay in Connect)
    ret

; Set some data comm ioctl option.  AL has function code
dc_ioctl proc    near
    push    ax            ; save regs
    push    bx
    push    cx
    push    dx
    mov    ah,8h
    mov    tempbuf,ax
    mov    dx,offset tempbuf
    mov    ah,e_ioctl
    mov    al,3
    mov    bx,prthnd
    mov    cx,2
    int    dos
    pop    dx            ; restore regs
    pop    cx
    pop    bx
    pop    ax
    ret
dc_ioctl endp

shomodem proc    near
    mov    ah,cmcfm    ; get a confirm
    call    comnd
     jmp    r        ; no confirm
     nop
    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
    jmp    rskp
shomodem endp

getmodem proc near
    mov    al,0
    ret
getmodem endp

; Put the char in AH to the serial port.  This assumes the
; port has been initialized.  Should honor xon/xoff.  Skip returns on
; success, returns normally if the character cannot be written

outchr: 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
    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
    jmp    rskp

; 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" or "COM2".
opnprt:    mov al,flags.comflg
    dec al            ; flags.comflg is 1 for com1, 2 for com2
    mov ah,0
    push si
    mov si,ax
    shl si,1        ; double index
    mov dx,prttab[si]
    pop si
    mov ah,open2
    mov al,2
    int dos
    jnc opnpr2
    mov ah,prstr        ; It didn't like the string
    mov dx,offset erms41
    int dos
    ret
opnpr2:    mov prthnd,ax        ; Call succeeded
    mov ah,ioctl
    mov al,00h        ; get device info
    xor dx,dx
    mov bx,prthnd        ; port's handle
    int dos
    or dl,20h        ; set binary mode in device info
    mov dh,0
    mov ah,ioctl
    mov al,01h        ; set device info
    int dos
    ret

; This routine blanks the screen.

CMBLNK    PROC    NEAR        ; This is stolen from the IBM example
    push ax
    push dx
    mov ah,prstr
    mov dx,offset blank
    int dos
    pop dx
    pop ax
    ret
CMBLNK  ENDP

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

GETBAUD    PROC    NEAR
    ret
GETBAUD    ENDP


; skip returns if no character available at port,
; otherwise returns with char in al, # of chars in buffer in dx.

PRTCHR    PROC    NEAR
    push bx
    push cx
    push si
    cmp prthnd,0        ; have a handle yet?
    jne prtch1        ; yes, keep going
    call opnprt
prtch1:    cmp count,0        ; no characters?
    jne prtch2        ; no, go fill buffer
    mov bx,prthnd
    mov al,rdchan
    mov ah,ioctl
    mov dx,offset source    ; buffer to read into
    mov cx,bufsiz        ; length of buffer
    int dos
    jc prtch4        ; c = error
    mov count,ax        ; reset count
    mov dx,ax        ; needed to obey rules
    or ax,ax
    jz prtch4        ; still no chars
    mov bufout,offset source ; this is output ptr
prtch2:    dec count
    mov dx,count        ; return count in dx
    mov si,bufout
    cld
    lodsb            ; get character
    mov bufout,si        ; update ptr
prtch3:    pop si
    pop cx
    pop bx
    ret            ; exit success
prtch4:    pop si
    pop cx
    pop bx
    jmp rskp        ; no chars
PRTCHR  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,cmtxt        ; 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
     jmp r
; not yet imp.    call serhng        ; drop DTR and RTS
    mov ah,prstr        ; give a nice message
; not yet imp.    mov dx,offset hngmsg
    mov dx,offset noimp    ; for now
    int dos
    clc
    jmp rskp
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.
; SERHNG is Not Yet Implemented.
SERHNG    PROC    NEAR
    ret
SERHNG    ENDP

; Position the cursor according to contents of DX

POSCUR    PROC    NEAR
    push    ax            ; save regs
    push    dx
    push    di
    push    es
    mov    ax,ds
    mov    es,ax            ; address data segment
    cld
    mov    di,offset colno
    mov    al,dl            ; column
    call    nout
    mov    al,'c'
    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    es            ; restore regs
    pop    di
    pop    dx
    pop    ax
    ret
POSCUR    ENDP

NOUT    PROC    NEAR
    cbw            ; extend to word
    div    byte ptr ten    ; divide by 10
    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
    ret            ; put in buffer and return
NOUT    endp

; Write a line in inverse video 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,24 * 100H    ; line 24
    call    poscur
    mov    dx,offset invseq ; put into inverse video
    mov    ah,prstr
    int    dos
    pop    dx
    int     dos
    mov    dx,offset nrmseq ; normal videw
    int    dos
    ret            ; and return
putmod    endp

; Clear the mode line written by putmod.  Returns normally.
clrmod    proc    near
    mov    dx,24 * 100H
    call    poscur
    call    clearl
    ret
clrmod    endp

; Put a help message one the screen in reverse video.  Pass
; the message in AX, terminated by a null.  Returns normally.
; The message is put wherever the cursor currently is located.
puthlp    proc    near
    push ax            ; save some regs
    push si
    push dx
    push ax
    mov ah,prstr        ; Leave some room before the message
    mov dx,offset crlf
    int dos
    pop si            ; Put message address here
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
    cmp al,0        ; Terminated with a null
    je puth2
    mov dl,al
    mov ah,conout
    int dos
    cmp al,lf        ; Line feed?
    je puth0        ; Yes, clear the next line
    jmp puth1        ; Else, just keep on writing
puth2:    mov dx,offset crlf
    mov ah,prstr
    int dos
    mov dx,offset nrmseq        ; Normal video
    int dos
    pop si                ; restore regs
    pop dx
    pop ax
    ret
puthlp    endp

; Perform a delete.

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

; Perform a Control-U.

CTLU    PROC    NEAR
    push ax
    push dx
    mov ah,prstr
    mov dx,offset clrlin
    int dos
    pop dx
    pop ax
    ret
CTLU    ENDP

COMS    PROC    NEAR
        mov dx,offset comptab        ; comms port table
        mov bx,0            ; use keywords as help
        mov ah,cmkey            ; parse keyword
        call comnd
         jmp r                ; failed
        push bx
        mov ah,cmcfm
        call comnd            ; Get a confirm
         jmp comx            ;  Didn't get a confirm
     nop
        pop bx
        mov flags.comflg,bl        ; Set the comm port flag
    cmp flags.comflg,1        ; Using Com 1?
    jne coms2            ; Nope
    mov portval,offset port1
    ret
coms2:    mov portval,offset port2    ; use Com2
    ret
comx:    pop bx
    ret
COMS    ENDP

VTS    PROC    NEAR            ; Set Term code
    jmp notimp
VTS    ENDP


VTSTAT    PROC    NEAR    ; For Status display [jrd]
    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


notimp:    mov    ah,prstr
    mov    dx,offset noimp
    int    dos
    jmp    prserr

lclini:    mov    flags.vtflg,0        ; no terminal emulation. [jrd]
    mov    prthnd,0        ; no port handle yet. [jrd]
    call    msuinit            ; initialize keyboard module msugen
    ret


showkey:
    mov    ax,offset shkmsg
    mov    cx,shklen
    ret

; 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

; Initialization for using serial port.  Returns normally.
; Attempts to put port device in binary mode. [jrd]
SERINI    PROC    NEAR
    cld            ; Do increments in string operations
    cmp prthnd,0        ; Got a handle yet?
    jne serin0        ; ne = yes, just go on
    push bx
    call opnprt        ; Else 'open' the port
    mov ax,passall        ; set for transparency mode [WHM]
    call dc_ioctl        ; use DOS function [WHM]
    pop bx
serin0:    push bx
    mov bx,portval        ; get port [jrd]
    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
SERINI    ENDP

SERRST    PROC    NEAR
    push bx            ; save reg
    mov bx,prthnd
    cmp bx,0        ; none there?
    je serrs1        ; no, don't try to close
    mov ah,close
    int dos            ; close handle
    mov prthnd,0
serrs1: pop bx
    ret            ; All done
SERRST    ENDP

; Generate a short beep.

BEEP    PROC    NEAR
    mov dl,bell
    mov ah,conout
    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
    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            ; make es point to datas segment
    mov cx,size termarg
    cld
    rep movsb        ; copy into our arg blk
    pop es            ; recover reg
    and ourarg.flgs,not (prtscr) ; no screen printing at startup
    mov ax,ourarg.captr
    mov captrtn,ax        ; buffer capture routine

    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:    call portchr        ; get char from port, apply parity mask
    jnc short term2        ; nc = no char, go on
    call outtty        ; display and capture char
term2:    call    keybd        ; call keyboard translator in msu
    jnc    term1        ; nc = no char or have processed it
                     ; carry set = quit Connect mode
term4:    ret
term    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
    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
    mov    bx,offset rxtable    ; address of translate table
    xlatb                ; new char is in al
    pop    bx
outnp7:
    push    bx
    mov    bx,argadr        ; args from msster directly
    test    [bx].flgs,capt        ; capturing output? Can be shut off
    pop    bx            ;  if out dev becomes not ready
    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    outnp4            ; 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)?
    jne    outnp5            ; ne = no
    jmp    beep            ; use short beep, avoid char loss
outnop1:
outnp5:    mov    ah,conout        ; dostty screen mode
    mov    dl,al            ; write without intervention
    int    dos            ; else let dos display char
    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
     nop
     nop
     nop                ; skip returns
    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?
     jmp    short portc1        ; yes, go handle
     nop                ; skip return is stupid
portc0:    clc                ; no carry -> no character
    ret                ; and return
portc1:    and    al,parmsk        ; apply 8/7 bit parity mask
    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)

chrout: call    outprt            ; put char in al to serial port
    clc                ; stay in Connect mode
    ret

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
klogn:    clc
    ret
klogon    endp

klogof    proc    near            ; suspend logging (if any)
    and    argadr.flgs,not capt    ; stop capturing
klogo:    clc
    ret
klogof    endp

snull:    mov    ah,0            ; send a null
    call    outchr            ; send without echo or logging
     nop
     nop
     nop
    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
                    ;; end of action routines

; Jumping to this location is like retskp.  It assumes the instruction
;   after the call is a jmp addr.

RSKP    PROC    NEAR
    pop    bp
    add    bp,3
    push    bp
        ret
RSKP    ENDP

; Jumping here is the same as a ret.

R       PROC    NEAR
        ret
R       ENDP

code    ends
    end