home *** CD-ROM | disk | FTP | other *** search
/ Columbia Kermit / kermit.zip / extra / nyenhuis3.arc / MSSTER.ASM < prev    next >
Assembly Source File  |  1990-01-14  |  35KB  |  1,192 lines
  1.      NAME    msster
  2. ; File MSSTER.ASM
  3.     include mssdef.h
  4. ; Last edit 14 Jan 1990
  5.  
  6.     public    clscpt, defkey, clscpi, ploghnd, sloghnd, tloghnd
  7.     public  dopar, shokey, cptchr, pktcpt, targ, replay, repflg
  8.     public    kbdflg, shkadr, telnet, ttyact, write, dec2di
  9.     public    cnvlin, katoi, decout, valout, atoi, cnvstr
  10.  
  11. braceop    equ    7bh            ; opening curly brace
  12. bracecl    equ    7dh            ; closing curly brace
  13.  
  14. data     segment    public 'data'
  15.     extrn    flags:byte, trans:byte, portval:word, taklev:byte, takadr:word
  16.     extrn    comand:byte, verident:byte, rdbuf:byte, errlev:byte
  17.     extrn    dosnum:word, diskio:byte
  18.  
  19. targ    termarg    <0,1,cptchr,0,parnon>
  20. crlf    db      cr,lf,'$'
  21. tmsg1    db    cr,lf,'(Connecting to host, type $' 
  22. tmsg3    db    ' C to return to PC)',cr,lf,cr,lf,cr,lf,'$'
  23. erms25    db    cr,lf,'?Input must be numeric$' 
  24. erms22    db    cr,lf,'?No open logging file$'
  25. erms23    db    cr,lf,'?Error writing session log, suspending capture.'
  26.     db    cr,lf,'$'
  27. erms24    db    cr,lf,'?Error writing Packet log$'
  28. esctl    db    'Control-$'
  29. repflg    db    0        ; REPLAY or SET TERM REPLAY filespec flag
  30. rephlp    db    'name of file to playback$'
  31. reperr    db    cr,lf,'?File not found$'    ; for REPLAY command
  32. msgtxt    db    'optional text, if any$'
  33.  
  34. inthlp db cr,lf,'  ?  This message                    F  Dump screen to file'
  35.        db cr,lf,'  C  Close the connection            P  Push to DOS'
  36.        db cr,lf,'  S  Status of the connection        Q  Quit logging'
  37.        db cr,lf,'  M  Toggle mode line                R  Resume logging'
  38.        db cr,lf,'  B  Send a Break                    0  Send a null'
  39.        db cr,lf,'  L  Send a long 1.8 s Break         H  Hangup phone'
  40.        db cr,lf,'  Typing the escape character will send it to the host'
  41.        db 0          ; this short-form obscures less screen area [jrd]
  42.  
  43. intprm    db    'Command> $'
  44. intclet    db    'B','C','F','H','L'    ; single letter commands
  45.     db    'M','P','Q','R','S'    ; must parallel dispatch table intcjmp
  46.     db    '?','0'
  47. numlet    equ    $ - intclet        ; number of entries
  48.     even
  49. intcjmp    dw    intchb,intchc,intchf,intchh,intchl
  50.     dw    intchm,intchp,intchq,intchr,intchs
  51.     dw    intchu,intchn
  52.  
  53. pktbuf    db    cptsiz dup (?)    ; packet logging buffer
  54. pktbp    dw    pktbuf        ; buffer pointer to next free byte
  55. pktlft    dw    cptsiz        ; number free bytes left
  56. capbuf    db    cptsiz dup (?)    ; session logging buffer
  57. capbp    dw    capbuf        ; buffer pointer to next free byte
  58. caplft    dw    cptsiz        ; number free bytes left
  59.     even
  60. ploghnd    dw    -1        ; packet logging handle
  61. sloghnd    dw    -1        ; session logging handle
  62. tloghnd    dw    -1        ; transaction logging handle
  63.  
  64. clotab    db    4
  65.     mkeyw    'All',logpkt+logses+logtrn
  66.     mkeyw    'Packets',logpkt
  67.     mkeyw    'Session',logses
  68.     mkeyw    'Transaction',logtrn
  69.  
  70. clseslog db    cr,lf,' Closing Session log$'
  71. clpktlog db    cr,lf,' Closing Packet log$'
  72. cltrnlog db    cr,lf,' Closing Transaction log$'
  73. clohlp    db    cr,lf,' One of the following log files:'
  74.     db    cr,lf,' ALL, Packets, Session, Transaction$'
  75.  
  76. writetab db    4            ; Write command log file types
  77.     mkeyw    'Packet',logpkt
  78.     mkeyw    'Screen',80h        ; unused value, to say screen
  79.     mkeyw    'Session',logses
  80.     mkeyw    'Transaction',logtrn
  81.  
  82. wrtobj    db    9            ; table of objects to be written
  83.     mkeyw    'ARGC',wrtargc        ; Argument count
  84.     mkeyw    'COUNT',wrtcnt        ; loop COUNT
  85.     mkeyw    'Date',wrtdate        ; DOS date
  86.     mkeyw    'Errorlevel',wrterr    ; Errorlevel
  87.     mkeyw    'INPUT-buffer',wrtinp    ; Input command's circular buffer
  88.     mkeyw    'Path',wrtpath        ; current DOS path
  89.     mkeyw    'Text',wrttxt        ; text
  90.     mkeyw    'Time',wrttime        ; DOS time of day
  91.     mkeyw    'Version',wrtver    ; version of MS Kermit
  92.  
  93. sttmsg    db    cr,lf,'Press space to continue ...$'
  94. kbdflg    db    0            ; non-zero means char here from Term
  95. ttyact    db    0            ; Connect mode active, if non-zero
  96. shkadr    dw    0            ; offset of replacement Show Key cmd
  97. ten    dw    10            ; multiplier for setatoi
  98. nbase    dw    ?            ; currently active number base
  99. numset    db    '0123456789ABCDEF'    ; number conversion alphabet
  100. temp    dw    0
  101. tmp    db    0
  102. data    ends
  103.  
  104. code    segment    public 'code'
  105.     extrn     comnd:near, outchr:near, stat0:near, iseof:near
  106.     extrn    term:near, strlen:near, buflog:near
  107.     extrn    beep:near, puthlp:near, getbaud:near, serhng:near
  108.     extrn    serini:near,serrst:near, sendbr:near
  109.     extrn    fpush:near, dumpscr:near, sendbl:near
  110.     assume    cs:code, ds:data, es:nothing
  111.  
  112. ; the show key command
  113. shokey    proc    near
  114.     cmp    shkadr,0        ; keyboard translator present?
  115.     je    shokey1            ; e = no, use regular routines
  116.     mov    bx,shkadr        ; get offset of replacement routine
  117.     jmp    bx            ; and execute it rather than us
  118. shokey1:clc
  119.     ret
  120. shokey    endp
  121. ; enter with ax/scan code to define, si/ pointer to definition, cx/ length
  122. ; of definition.  Defines it in definition table. Obsolete.
  123. defkey    proc    near
  124.     ret
  125. defkey    endp
  126.  
  127. ; This is the CONNECT command
  128.  
  129. TELNET     PROC    NEAR
  130.     mov    ah,cmeol
  131.     call    comnd            ; get a confirm
  132.     jnc    teln2            ; nc = success
  133.     ret
  134. teln2:    mov    ah,prstr
  135.     mov    dx,offset crlf        ; output a crlf
  136.     int    dos
  137.     cmp    flags.vtflg,0        ; emulating a terminal?
  138.     jne    teln1            ; ne= yes, skip    flashing message
  139.     call    domsg            ; Reassure user
  140. teln1:    call    serini            ; ensure port is inited now
  141.     mov    al,0            ; initial flags
  142.     mov    ttyact,1        ; say telnet is active
  143.     cmp    flags.vtflg,0        ; emulating a terminal?
  144.     je    teln3            ; e = no, say mode line is to be off
  145.     cmp    flags.modflg,0        ; mode line enabled?
  146.     jne    tel010            ; ne = yes
  147. teln3:    or    al,modoff        ; no, make sure it stays off
  148.  
  149. tel010:    test    flags.debug,logses    ; debug mode?
  150.     jz    tel0            ; z = no, keep going
  151.     or    al,trnctl        ; yes, show control chars
  152. tel0:    cmp    flags.vtflg,0        ; emulating a terminal?
  153.     je    tel1            ; e = no
  154.     or    al,emheath        ; say emulating some kind of terminal
  155. tel1:    mov    bx,portval
  156.     cmp    [bx].ecoflg,0        ; echoing?
  157.     jz    tel2
  158.     or    al,lclecho
  159. tel2:    call    getbaud            ; pickup current baud rate for port
  160.     mov    targ.flgs,al        ; store flags
  161.     mov    ah,flags.comflg        ; COMs port identifier
  162.     mov    targ.prt,ah        ; Port 1 or 2, etc
  163.     mov    ah,[bx].parflg        ; parity flag
  164.     mov    targ.parity,ah
  165.     mov    ax,[bx].baud        ; baud rate identifier
  166.     mov    targ.baudb,al
  167.     xor    ah,ah
  168.     test    flags.capflg,logses    ; select session logging flag bit
  169.     jz    tel3            ; z = no logging
  170.     mov    ah,capt            ; set capture flag
  171. tel3:    or    targ.flgs,ah
  172.  
  173. TEM:    call    serini            ; init serial port
  174.     jnc    tem1            ; nc = success
  175.     mov    ttyact,0        ; say we are no longer active
  176.     clc
  177.     ret                ; and exit Connect mode
  178.  
  179. tem1:    mov    dx,offset crlf        ; give user an indication that we are
  180.     mov    ah,prstr        ; entering terminal mode
  181.     int    dos
  182.     mov    ax,offset targ        ; Point to terminal arguments
  183.     call    term            ; Call the main Terminal procedure
  184.     mov    al,kbdflg        ; get the char from Term, if any
  185.     mov    kbdflg,0        ; clear    the flag
  186.     cmp    al,0            ; was there a char from Term?
  187.     jne    intch2            ; ne = yes, else ask for one from kbd
  188.  
  189. intchar:call    iseof            ; stdin at eof?
  190.     jnc    intch1            ; nc = not eof, get more
  191.     mov    al,'C'            ; use C when file is empty
  192.     jmp    intchc            ;  to provide an exit
  193. intch1:    mov    ah,coninq        ; read keyboard, no echo
  194.     int    dos            ; get a char
  195.     cmp    al,0            ; scan code indicator?
  196.     jne    intch2            ; ne = no, ascii
  197.     mov    ah,coninq        ; read and discard scan code
  198.     int    dos
  199.     jmp    short intch1        ; try again
  200. intch2:    cmp    al,' '            ; space?
  201.     je    tem            ; e = yes, ignore it
  202.     cmp    al,cr            ; check ^M (cr) against plain ascii M
  203.     je    tem            ; exit on cr
  204.     cmp    al,trans.escchr        ; Is it the escape char?
  205.     jne    intch3            ; ne = no
  206.     mov    ah,al
  207.     call    outchr
  208.     jmp    tem            ; Return, we are done here
  209. intch3:    push    es
  210.     push    ds
  211.     pop    es
  212.     mov    di,offset intclet    ; command letters
  213.     mov    cx,numlet        ; quantity of them
  214.     cmp    al,' '            ; control code?
  215.     jae    intch3a            ; ae = no
  216.     or    al,40H            ; convert control chars to printable
  217. intch3a:cmp    al,96            ; lower case?
  218.     jb    intch3b            ; b = no
  219.     and    al,not (20h)        ; move to upper case
  220. intch3b:cld
  221.     repne    scasb            ; find the matching letter
  222.     pop    es
  223.     jne    intch4            ; ne = not found, beep and get another
  224.     dec    di            ; back up to letter
  225.     sub    di,offset intclet    ; get letter number
  226.     shl    di,1            ; make it a word index
  227.     jmp    intcjmp[di]        ; dispatch to it
  228. intch4:    call    beep            ; say illegal character
  229.     jmp    intchar
  230.  
  231. intchb:    call    sendbr            ; 'B' send a break
  232.     jmp    tem            ; And return
  233.  
  234. intchc:    mov    ttyact,0        ; 'C' say we are no longer active
  235.     clc                ; and exit Connect mode
  236.     ret
  237.  
  238. intchf:    call    dumpscr            ; 'F' dump screen, use msy routine
  239.     jmp    tem            ; and return
  240.  
  241. intchh:    call    serhng            ; 'H' hangup phone
  242.     call    serrst            ; turn off port
  243.     jmp    tem
  244.  
  245. intchl:    call    sendbl            ; 'L' send a long break
  246.     jmp    tem
  247.  
  248. intchm:    cmp    flags.modflg,1        ; 'M' toggle mode line, enabled?
  249.     jne    intchma            ; ne = no, leave it alone
  250.     xor    targ.flgs,modoff    ; enabled, toggle its state
  251. intchma:jmp    tem            ; and reconnect
  252.  
  253. intchp:    call    fpush            ; 'P' push to DOS
  254.     mov    dx,offset sttmsg    ; say we have returned
  255.     mov    ah,prstr
  256.     int    dos
  257.     jmp    intchsb            ; wait for a space
  258.  
  259. intchq:    test    targ.flgs,capt        ; 'Q' suspend logging. Logging active?
  260.     jz    intchq1            ; z = no
  261.     and    targ.flgs,not capt    ; stop capturing
  262. intchq1:jmp    tem            ; and resume
  263.  
  264. intchr:    test    flags.capflg,logses    ; 'R' resume logging. Can we capture?
  265.     jz    intchr1            ; z = no
  266.     test    targ.flgs,capt        ; already capturing?
  267.     jnz    intchr1            ; yes, can't toggle back on then
  268.     or    targ.flgs,capt        ; else turn flag on
  269. intchr1:jmp    tem            ; and resume
  270.  
  271. intchs:    call    stat0            ; 'S' status, call stat0
  272.     mov    dx,offset sttmsg
  273.     mov    ah,prstr
  274.     int    dos
  275. intchsa:call    iseof            ; is stdin at eof?
  276.     jnc    intchsb            ; nc = not eof, get more
  277.     jmp    tem            ; resume if EOF
  278. intchsb:mov    ah,coninq        ; console input, no echo
  279.     int    dos
  280.     cmp    al,' '            ; space?
  281.     jne    intchsa
  282.     jmp    tem
  283.  
  284. intchu:    mov    ax,offset inthlp    ; '?' get help message
  285.     call    puthlp            ; write help msg
  286.     mov    dx,offset intprm
  287.     mov    ah,prstr        ; Print it
  288.     int    dos
  289.     jmp    intchar            ; Get another char
  290.  
  291. intchn:    mov    ah,0            ; '0' send a null
  292.     call    outchr
  293.     jmp    tem
  294. TELNET  ENDP
  295.  
  296. ; Reassure user    about connection to the host. Tell him what escape sequence
  297. ; to use to return and the communications port and baud; rate being used
  298.  
  299. DOMSG    PROC    NEAR
  300.     mov    ah,prstr
  301.     mov    dx,offset tmsg1
  302.     int    dos
  303.     call    escprt
  304.     mov    ah,prstr
  305.     mov    dx,offset tmsg3
  306.     int    dos
  307.     ret
  308. DOMSG    ENDP
  309.  
  310. ; print    the escape character in readable format.  
  311.  
  312. ESCPRT    PROC    NEAR
  313.     mov    dl,trans.escchr
  314.     cmp    dl,' '
  315.     jge    escpr2
  316.     push    dx
  317.     mov    ah,prstr
  318.     mov    dx,offset esctl
  319.     int    dos
  320.     pop    dx
  321.     add    dl,040H        ; Make it printable
  322. escpr2:    mov    ah,conout
  323.     int    dos
  324.     ret
  325. ESCPRT    ENDP
  326.  
  327.  
  328. ; Set parity for character in Register AL
  329.  
  330. dopar:    push    bx
  331.     mov    bx,portval
  332.     mov    bl,[bx].parflg        ; get parity flag byte
  333.     cmp    bl,parnon        ; No parity?
  334.     je    parret            ; Just return
  335.     and    al,07FH            ; Strip parity. Same as Space parity
  336.     cmp    bl,parspc        ; Space parity?
  337.     je    parret            ; e = yes, then we are done here
  338.     cmp    bl,parevn        ; Even parity?
  339.     jne    dopar0            ; ne = no
  340.     or    al,al
  341.     jpe    parret            ; pe = even parity now
  342.     xor    al,080H            ; Make it even parity
  343.     jmp    short parret
  344. dopar0:    cmp    bl,parmrk        ; Mark parity?
  345.     jne    dopar1            ; ne = no
  346.     or    al,080H            ; Turn on the parity bit
  347.     jmp    short parret
  348. dopar1:    cmp    bl,parodd        ; Odd parity?    
  349.     or    al,al
  350.     jpo    parret            ; Already odd, leave it
  351.     xor    al,080H            ; Make it odd parity
  352. parret:    pop    bx
  353.     ret
  354.  
  355. ; REPLAY filespec  through terminal emulator
  356. replay    proc    near
  357.     mov    dx,offset rdbuf        ; place for filename
  358.     mov    bx,offset rephlp    ; help
  359.     mov    repflg,0        ; clear the replay active flag
  360.     mov    ah,cmword        ; get filename
  361.     call    comnd
  362.     jc    replay2            ; c = failure
  363.     mov    ah,cmeol        ; get an EOL confirm
  364.     call    comnd
  365.     jc    replay2            ; c = failure
  366.     mov    ah,open2        ; open file
  367.     xor    al,al            ; open readonly
  368.     cmp    dosnum,200h        ; above DOS 2?
  369.     jna    replay1            ; na = no, so no shared access
  370.     mov    al,0+40h        ; open readonly, deny none
  371. replay1:mov    dx,offset rdbuf        ; asciiz filename
  372.     int    dos
  373.     jnc    replay3            ; nc = success
  374.     mov    ah,prstr
  375.     mov    dx,offset reperr    ; Cannot open that file
  376.     int    dos
  377.     clc
  378. replay2:ret
  379. replay3:mov    diskio.handle,ax    ; file handle
  380.     mov    repflg,1        ; set replay flag
  381.     call    telnet            ; enter Connect mode
  382.     mov    bx,diskio.handle
  383.     mov    ah,close2        ; close the file
  384.     int    dos
  385.     mov    repflg,0        ; clear the flag
  386.     clc
  387.     ret
  388. replay    endp
  389.  
  390. cptchr    proc    near            ; session capture routine, char in al
  391.     push    di
  392.     mov    di,capbp        ; buffer pointer
  393.     mov    byte ptr [di],al
  394.     inc    capbp
  395.     pop    di
  396.     dec    caplft            ; decrement chars remaining
  397.     jg    cptch1            ; more room, forget this part
  398.     call    cptdmp            ; dump the info
  399. cptch1:    ret
  400. cptchr    endp
  401.  
  402. cptdmp    proc    near            ; empty the capture buffer
  403.     push    ax
  404.     push    bx
  405.     push    cx
  406.     push    dx
  407.     mov    bx,sloghnd        ; get file handle
  408.     cmp    bx,0            ; is file open?
  409.     jle    cptdm1            ; le = no, skip it
  410.     mov    cx,cptsiz        ; original buffer size
  411.     sub    cx,caplft        ; minus number remaining
  412.     jl    cptdm2            ; means error
  413.     jcxz    cptdm1            ; z = nothing to do
  414.     mov    dx,offset capbuf    ; the capture routine buffer
  415.     mov    ah,write2        ; write with filehandle
  416.     int    dos            ; write out the block
  417.     jc    cptdm2            ; carry set means error
  418.     mov    capbp,offset capbuf
  419.     mov    caplft,cptsiz        ; init buffer ptr & chrs left
  420.     jmp    short cptdm1
  421. cptdm2:    and    flags.capflg,not logses    ; so please stop capturing
  422.     and    targ.flgs,not capt    ; so please stop capturing
  423.     mov    dx,offset erms23    ; tell user the bad news
  424.     mov    ah,prstr
  425.     int    dos
  426. cptdm1:    pop    dx
  427.     pop    cx
  428.     pop    bx
  429.     pop    ax
  430.     ret
  431. cptdmp    endp
  432.  
  433. pktcpt    proc    near            ; packet log routine, char in al
  434.     push    di
  435.     mov    di,pktbp        ; buffer pointer
  436.     mov    [di],al            ; store char in buffer
  437.     inc    pktbp            ; move pointer to next free byte
  438.     pop    di
  439.     dec    pktlft            ; decrement chars remaining
  440.     jg    pktcp1            ; g = more room, forget this part
  441.     call    pktdmp            ; dump the info
  442. pktcp1:    ret
  443. pktcpt    endp
  444.  
  445. pktdmp    proc    near            ; empty the capture buffer
  446.     push    ax
  447.     push    bx
  448.     push    cx
  449.     push    dx
  450.     mov    bx,ploghnd        ; get file handle
  451.     cmp    bx,0            ; is file open?
  452.     jle    cptdm1            ; le = no, skip it
  453.     mov    cx,cptsiz        ; original buffer size
  454.     sub    cx,pktlft        ; minus number remaining
  455.     jl    pktdm2            ; l means error
  456.     jcxz    pktdm1            ; z = nothing to do
  457.     mov    dx,offset pktbuf    ; the capture routine buffer
  458.     mov    ah,write2        ; write with filehandle
  459.     int    dos            ; write out the block
  460.     jc    pktdm2            ; carry set means error
  461.     mov    pktbp,offset pktbuf
  462.     mov    pktlft,cptsiz        ; init buffer ptr & chrs left
  463.     jmp    short pktdm1
  464. pktdm2:    and    flags.capflg,not logpkt    ; so please stop capturing
  465.     mov    dx,offset erms24    ; tell user the bad news
  466.     mov    ah,prstr
  467.     int    dos
  468.     call    clscp4            ; close the packet log
  469. pktdm1:    pop    dx
  470.     pop    cx
  471.     pop    bx
  472.     pop    ax
  473.     ret
  474. pktdmp    endp
  475.  
  476. ; CLOSE command
  477.  
  478. clscpt    proc    near
  479.     mov    ah,cmkey
  480.     mov    dx,offset clotab    ; close table
  481.     mov    bx,offset clohlp    ; help
  482.     call    comnd
  483.            jc    clscp2            ; c = failure
  484.     mov    tmp,bl
  485.     mov    ah,cmeol
  486.     call    comnd
  487.            jc    clscp2            ; c = failure
  488.     mov    bl,tmp
  489.     test    flags.capflg,0FFH    ; are any kinds active?
  490.     jz    clscp1            ; z = no
  491.            cmp    bl,logpkt+logses+logtrn    ; close all?
  492.     je    clscpi            ; e = yes
  493.     cmp    bl,logpkt        ; just packet?
  494.     je    clscp4
  495.     cmp    bl,logses        ; just session?
  496.     je    clscp6
  497.     cmp    bl,logtrn        ; just session?
  498.     je    clscp8
  499. clscp1:    mov    dx,offset erms22    ; say none active
  500.     mov    ah,prstr
  501.     int    dos
  502.     clc
  503. clscp2:    ret
  504.                     ; CLSCPI called at Kermit exit
  505. CLSCPI:    call    clscp4            ; close packet log
  506.     call    clscp6            ; close session log
  507.     call    clscp8            ; close transaction log
  508.     clc                ; return success
  509.     ret
  510.  
  511. clscp4:    push    bx            ; PACKET LOG
  512.     mov    bx,ploghnd        ; packet log handle
  513.     cmp    bx,0            ; is it open?
  514.     jle    clscp5            ; e = no
  515.     call    pktdmp            ; dump buffer
  516.     mov    ah,close2
  517.     int    dos
  518.     mov    ah,prstr
  519.     mov    dx,offset clpktlog    ; tell what we are doing
  520.     int    dos
  521. clscp5:    mov    ploghnd,-1        ; say handle is invalid
  522.     pop    bx
  523.     and    flags.capflg,not logpkt    ; say this log is closed
  524.     ret
  525.  
  526. clscp6:    push    bx            ; SESSION LOG
  527.     mov    bx,sloghnd        ; session log handle
  528.     cmp    bx,0            ; is it open?
  529.     jle    clscp7            ; e = no
  530.     call    cptdmp            ; dump buffer
  531.     mov    ah,close2
  532.     int    dos
  533.     mov    ah,prstr
  534.     mov    dx,offset clseslog    ; tell what we are doing
  535.     int    dos
  536. clscp7:    mov    sloghnd,-1        ; say handle is invalid
  537.     pop    bx
  538.     and    flags.capflg,not logses    ; say this log is closed
  539.     ret
  540.  
  541. clscp8:    push    bx            ; TRANSACTION LOG
  542.     mov    bx,tloghnd        ; transaction log handle
  543.     cmp    bx,0            ; is it open?
  544.     jle    clscp9            ; e = no
  545.     mov    ah,close2
  546.     int    dos
  547.     mov    ah,prstr
  548.     mov    dx,offset cltrnlog    ; tell what we are doing
  549.     int    dos
  550. clscp9:    mov    tloghnd,-1        ; say handle is invalid
  551.     pop    bx
  552.     and    flags.capflg,not logtrn    ; say this log is closed
  553.     ret
  554. clscpt    endp
  555.  
  556. ; worker: copy line from si to di, first removing trailing spaces, second
  557. ; parsing out curly braced strings, then third converting \{b##} in strings
  558. ; to binary numbers. Returns carry set if error; else carry clear, with byte
  559. ; count in cx. Braces are optional but must occur in pairs.
  560. ; Items which cannot be converted to legal numbers are copied verbatium
  561. ; to the output string (ex: \{c}  is copied as \{c}  but \{x0d} is hex 0dh).
  562. cnvlin    proc    near
  563.     push    ax
  564.     push    si            ; source ptr
  565.     push    di            ; destination ptr
  566.     push    es            ; end of save regs
  567.     push    ds            ; move ds into es
  568.     pop    es            ; use data segment for es:di
  569.     call    cnvstr            ; trim trailing, parse curly braces
  570.     xor    cx,cx            ; initialize returned byte count
  571. cnvln1:    cmp    byte ptr [si],0        ; at end of string?
  572.     je    cnvln2            ; e = yes, exit
  573.     call    katoi            ; read char, convert ascii to binary
  574.     cld
  575.     stosb                ; save the char
  576.     inc    cx            ; and count it
  577.     or    ah,ah            ; is returned number > 255?
  578.     jz    cnvln1            ; z = no, do more chars
  579.     push    ax
  580.     stosb                ; save high order byte next
  581.     pop    ax
  582.     inc    cx
  583.     jmp    short cnvln1        ; do more chars
  584. cnvln2:    mov    byte ptr [di],0        ; plant terminator
  585.     clc                ; clear c bit, success
  586.     pop    es            ; restore regs
  587.     pop    di            ; destination ptr
  588.     pop    si            ; source ptr
  589.     pop    ax
  590.     ret
  591. cnvlin    endp
  592.  
  593. ; Convert string by first remove trailing spaces and then removing surrounding
  594. ; curly brace delimiter pair. Converts text in place.
  595. ; Enter with source ptr in si.
  596. ; Preserves all registers, uses byte tmp. 9 Oct 1987 [jrd]
  597. ; 
  598. cnvstr    proc    near
  599.     push    ax
  600.     push    cx
  601.     push    dx
  602.     push    si            ; save start of source string
  603.     push    di
  604.     push    es
  605.                     ; 1. Trim trailing spaces
  606.     mov    dx,si            ; source address
  607.     call    strlen            ; get current length to cx
  608.     jcxz    cnvst4            ; z = nothing there
  609.     mov    di,si            ; set di to source address
  610.     add    di,cx            ; start at end of string
  611.     dec    di            ; ignore terminator
  612.     mov    al,spc            ; scan while spaces
  613.     push    ds
  614.     pop    es            ; set es to data segment
  615.     std                ; search backward
  616.     repe    scasb            ; scan off trailing spaces
  617.     mov    byte ptr [di+2],0    ; terminate string after last text
  618.     cld
  619.     mov    di,si            ; set destination address to source
  620.                     ; 2. Parse off curly brace delimiters
  621.     cmp    byte ptr [si],braceop    ; opening brace?
  622.     jne    cnvst4            ; ne = no, ignore brace-matching code
  623.     inc    si            ; skip opening brace
  624.     mov    dl,braceop        ; opening brace (we count them up)
  625.     mov    dh,bracecl        ; closing brace (we count them down)
  626.     mov    tmp,1            ; we are at brace level 1
  627. cnvst1:    cld                ; search forward
  628.     lodsb                ; read a string char
  629.     stosb                ; store char (skips opening brace)
  630.     cmp    al,0            ; at end of string?
  631.     je    cnvst4            ; e = yes, we are done
  632.     cmp    al,dl            ; an opening brace?
  633.     jne    cnvst2            ; ne = no
  634.     inc    tmp            ; yes, increment brace level
  635.     jmp    short cnvst1        ;  and continue scanning
  636.  
  637. cnvst2:    cmp    al,dh            ; closing brace?
  638.     jne    cnvst1            ; ne = no, continue scanning
  639.     dec    tmp            ; yes, decrement brace level
  640.     cmp    byte ptr [si],0        ; have we just read the last char?
  641.     jne    cnvst3            ; no, continue scanning
  642.     mov    tmp,0            ; yes, this is the closing brace
  643. cnvst3:    cmp    tmp,0            ; at level 0?
  644.     jne    cnvst1            ; ne = no, #opening > #closing braces
  645.     mov    byte ptr [di-1],0    ; plant terminator on closing brace
  646.  
  647. cnvst4:    pop    es            ; recover original registers
  648.     pop    di
  649.     pop    si
  650.     pop    dx
  651.     pop    cx
  652.     pop    ax
  653.     ret
  654. cnvstr    endp
  655.  
  656. ; Convert ascii strings of the form "\{bnnn}" to a binary word in ax.
  657. ; The braces are optional but must occur in pairs. Numeric base indicator "b"
  658. ; is O or o or X or x or D or d or missing, for octal, hex, or decimal (def).
  659. ; Enter with si pointing at "\".
  660. ; Returns binary value in ax with carry clear and si to right of "}" or at
  661. ; terminating non-numeric char if successful; otherwise, a failure,
  662. ; return carry set with si = entry value + 1 and first read char in al.
  663.  
  664. katoi    proc    near
  665.     cld
  666.     lodsb                ; get first char
  667.     xor    ah,ah            ; clear high order field
  668.     push    cx            ; save working reg
  669.     push    si            ; save entry si+1
  670.     push    bx
  671.     push    ax            ; save read char
  672.     cmp    al,0            ; end of text?
  673.     je    katoi1a            ; e = yes, exit failure
  674.     cmp    al,'\'            ; escape char?
  675.     je    katoi1b            ; e = yes
  676. katoi1a:jmp    katoix            ; common jump point to exit failure
  677. katoi1b:lodsb                ; get next char, maybe brace
  678.     cmp    al,0            ; premature end?
  679.     je    katoi1a            ; e = yes, exit failure
  680.     xor    bx,bx            ; no conv yet, assume no opening brace
  681.     cmp    al,braceop        ; opening brace?
  682.     jne    katoi2            ; ne = no, have number or base
  683.     mov    bl,bracecl        ; remember a closing brace is needed
  684.     lodsb                ; get number base, if any
  685. katoi2:    xor    cx,cx            ; temporary place for binary value
  686.     mov    nbase,10        ; assume decimal numbers
  687.     cmp    al,0            ; premature end?
  688.     je    katoix            ; e = yes, exit failure
  689.     cmp    al,'a'            ; lower case?
  690.     jb    katoi3            ; b = no
  691.     cmp    al,'z'            ; in range of lower case?
  692.     ja    katoi3            ; a = no
  693.     and    al,5fh            ; map to upper case
  694. katoi3:    cmp    al,'O'            ; octal?
  695.     jne    katoi4            ; ne = no
  696.     mov    nbase,8            ; set number base
  697.     jmp    short katoi6
  698. katoi4:    cmp    al,'X'            ; hex?
  699.     jne    katoi5            ; ne = no
  700.     mov    nbase,16
  701.     jmp    short katoi6
  702. katoi5:    cmp    al,'D'            ; decimal?
  703.     jne    katoi7            ; ne = no base char, assume decimal
  704.     mov    nbase,10
  705. katoi6:    lodsb                ; get a digit
  706. katoi7:    cmp    al,0            ; premature end?
  707.     je    katoi8a            ; e = yes, use it as a normal end
  708.     cmp    al,bl            ; closing brace?
  709.     je    katoi9            ; e = yes
  710.     call    cnvdig            ; convert ascii to binary digit
  711.     jc    katoi8            ; c = cannot convert
  712.     inc    bh            ; say we did a successful conversion
  713.     xor    ah,ah            ; clear high order value
  714.     push    ax            ; save this byte's value
  715.     xchg    ax,cx            ; put binary summation in ax
  716.     mul    nbase            ; scale up current sum
  717.     xchg    ax,cx            ; put binary back in cx
  718.     pop    ax            ; recover binary digit
  719.     add    cx,ax            ; form running sum
  720.     jc    katoix            ; c = overflow error, exit
  721.     cmp    dx,0            ; overflow?
  722.     jne    katoix            ; ne = yes, exit with error
  723.     jmp    short katoi6        ; get more
  724.  
  725. katoi8:    cmp    bl,0            ; closing brace needed?
  726.     jne    katoix            ; ne = yes, but not found
  727. katoi8a:dec    si            ; backup to reread terminator
  728. katoi9:    cmp    bh,0            ; did we do any conversion?
  729.     je    katoix            ; e = no, exit failure
  730.     pop    ax            ; throw away old saved ax
  731.     pop    bx            ; restore bx
  732.     pop    ax            ; throw away starting si, keep current
  733.     mov    ax,cx            ; return final value in ax
  734.     pop    cx            ; restore old cx
  735.     clc                ; clear carry for success
  736.     ret
  737. katoix:    pop    ax            ; restore first read al
  738.     pop    bx
  739.     pop    si            ; restore start value + 1
  740.     pop    cx            ; restore old cx
  741.     stc                ; set carry for failure
  742.     ret
  743. katoi    endp
  744.  
  745. cnvdig    proc    near            ; convert ascii code in al to binary
  746.     push    cx            ; return carry set if cannot
  747.     push    es            ; nbase has numeric base
  748.     push    di
  749.     push    ax
  750.     cmp    al,'a'            ; lower case?
  751.     jb    cnvdig1            ; b = no
  752.     cmp    al,'f'            ; highest hex digit
  753.     ja    cnvdigx            ; a = illegal symbol
  754.     sub    al,'a'-'A'        ; convert 'a' to 'f' to upper case
  755. cnvdig1:mov    di,offset numset    ; set of legal number symbols
  756.     mov    cx,nbase        ; number of legal symbols in this base
  757.     cmp    cx,cx            ; preset z flag
  758.     push    ds
  759.     pop    es            ; point es at data segment
  760.     cld                ; scan forward
  761.     repne    scasb            ; find character in set
  762.     jne    cnvdigx            ; ne = not found
  763.     inc    cx            ; offset auto-dec of repne scasb above
  764.     sub    cx,nbase        ; counted off minus length
  765.     neg    cx            ; two's complement = final value
  766.     pop    ax            ; saved ax
  767.     mov    ax,cx            ; return binary in al
  768.     clc                ; c clear for success
  769.     jmp    short cnvdixx        ; exit
  770. cnvdigx:stc                ; c set for failure
  771.     pop    ax
  772. cnvdixx:pop    di
  773.     pop    es
  774.     pop    cx
  775.     ret
  776. cnvdig    endp    
  777.  
  778. decout    proc    near        ; display decimal number in ax
  779.     push    ax
  780.     push    cx
  781.     push    dx
  782.     mov    cx,10        ; set the numeric base
  783.     call    valout        ; convert and output value
  784.     pop    dx
  785.     pop    cx
  786.     pop    ax
  787.     ret
  788. decout    endp
  789.  
  790. valout    proc    near        ; output number in ax using base in cx
  791.                 ; corrupts ax and dx
  792.     xor    dx,dx        ; clear high word of numerator
  793.     div    cx        ; (ax / cx), remainder = dx, quotient = ax
  794.     push    dx        ; save remainder for outputting later
  795.     or    ax,ax        ; any quotient left?
  796.     jz    valout1        ; z = no
  797.     call    valout        ; yes, recurse
  798. valout1:pop    dx        ; get remainder
  799.     add    dl,'0'        ; make digit printable
  800.     cmp    dl,'9'        ; above 9?
  801.     jbe    valout2        ; be = no
  802.     add    dl,'A'-1-'9'    ; use 'A'--'F' for values above 9
  803. valout2:mov    ah,conout
  804.     int    dos
  805.     ret
  806. valout    endp
  807.  
  808. ; Convert input in buffer pointed to by SI to real number which is returned
  809. ; in AX.  Enter with string size in AH.
  810. ; Return carry set on failure, carry clear on success.
  811. ATOI    PROC    NEAR
  812.     mov    bx,0        ; high order of this stays 0
  813.     mov    tmp,0        ; No input yet
  814.     mov    cl,ah        ; Number of chars of input
  815.     mov    ch,0        ; size of string
  816.     mov    ax,0        ; init sum
  817.     cld
  818. atoi0:    jcxz    atoi4        ; Fail on no input
  819.     lodsb            ; get an input char
  820.     dec    cx        ; count number remaining
  821.     cmp    al,' '        ; leading space?
  822.     je    atoi0        ; e = yes, skip it
  823.     cmp    al,','        ; comma separator?
  824.     je    atoi0        ; e = yes, skip it
  825.     dec    si        ; back up source pointer for reread below
  826.     inc    cx        ; and readjust byte counter
  827.     mov    ax,0        ; clear sum
  828. atoi1:    push    ax        ; save sum
  829.     lodsb            ; read a byte into al
  830.     mov    bl,al        ; put it into bl
  831.     pop    ax        ; regain sum
  832.     cmp    bl,'9'        ; check range for '0' to '9'
  833.     ja    atoi2        ; above '9'
  834.     cmp    bl,'0'
  835.     jb    atoi2        ; below '0'
  836.     sub    bl,'0'        ; take away ascii bias
  837.     mul    ten        ; sum * 10. dx = high, ax = low
  838.     add    ax,bx        ; add current value
  839.     mov    tmp,1        ; say have sum being computed
  840.     loop    atoi1
  841.     inc    si        ; inc for dec below
  842. atoi2:    dec    si        ; point at terminator
  843.     cmp    tmp,0        ; were any digits discovered?
  844.     je    atoi4        ; e = no, fail
  845.     clc            ; success
  846.     ret
  847. atoi4:    mov    dx,offset erms25 ; Input must be numeric
  848.     stc            ; failure
  849.     ret
  850. ATOI    ENDP
  851.  
  852. ; Write binary number in AX as decimal asciiz to buffer pointer DI.
  853. dec2di    proc    near        ; output number in ax using base in cx
  854.                 ; corrupts ax, cx, and dx
  855.     mov    cx,10
  856. dec2di1:xor    dx,dx        ; clear high word of numerator
  857.     div    cx        ; (ax / cx), remainder = dx, quotient = ax
  858.     push    dx        ; save remainder for outputting later
  859.     or    ax,ax        ; any quotient left?
  860.     jz    dec2di2        ; z = no
  861.     call    dec2di1        ; yes, recurse
  862. dec2di2:pop    dx        ; get remainder
  863.     add    dl,'0'        ; make digit printable
  864.     mov    [di],dl        ; store char in buffer
  865.     inc    di
  866.     mov    byte ptr[di],0    ; add terminator
  867.     ret
  868. dec2di    endp
  869.  
  870. ; WRITE {log} {object} {optional text}
  871. Write    proc    near
  872.     mov    ah,cmkey        ; get kind of log file
  873.     mov    dx,offset writetab    ; table of possibilities
  874.     xor    bx,bx            ; help, when we get there
  875.     call    comnd
  876.     jc    write1            ; c = failure
  877.     mov    tmp,bl            ; save log file kind
  878.     mov    ah,cmkey        ; get kind of object to write
  879.     mov    comand.cmkeep,1        ; keep Take/Macro open after this call
  880.     mov    dx,offset wrtobj    ; table of objects
  881.     xor    bx,bx
  882.     call    comnd
  883.     jc    write1            ; c = failure
  884.     jmp    bx            ; do the routine to do the writing
  885. write1:    ret
  886. write    endp                ; jmp rskp is success, ret is fail
  887.  
  888.  
  889. ; WRITE <log> ARGC
  890. wrtargc    proc    near
  891.     xor    ax,ax
  892.     mov    di,offset rdbuf        ; where to write the buffer
  893.     cmp    taklev,0        ; in a Take/Macro?
  894.     je    wrtarg1            ; e = no
  895.     mov    bx,takadr        ; current Take structure
  896.     mov    ax,[bx].takargc        ; get ARGC
  897. wrtarg1:call    dec2di            ; write as ascii
  898.     mov    word ptr [di],0020h    ; space and null terminator
  899.     inc    di
  900.     mov    temp,di            ; place for additional text
  901.     jmp    wrttxt1            ; add any trailing text
  902. wrtargc    endp
  903.  
  904. ; WRITE <log> COUNT
  905. wrtcnt    proc    near
  906.     xor    ax,ax
  907.     mov    di,offset rdbuf        ; where to write the buffer
  908.     cmp    taklev,0        ; in a Take/Macro?
  909.     je    wrtcnt1            ; e = no
  910.     mov    bx,takadr        ; current Take structure
  911.     mov    ax,[bx].takctr        ; get COUNT
  912. wrtcnt1:call    dec2di            ; write as ascii
  913.     mov    word ptr [di],0020h    ; space and null terminator
  914.     inc    di
  915.     mov    temp,di            ; place for additional text
  916.     jmp    wrttxt1            ; add any trailing text
  917. wrtcnt    endp
  918.  
  919. ; Write <log> DATE <optional text>
  920. wrtdate    proc    near
  921.     mov    ah,getdate        ; DOS date (cx= yyyy, dh= mm, dl= dd)
  922.     int    dos
  923.     mov    di,offset rdbuf
  924.     push    cx            ; save cx
  925.     push    dx            ; save dx
  926.     xor    ah,ah
  927.     mov    al,dh            ; Months
  928.     cmp    al,10            ; leading tens digit present?
  929.     jae    wrtdat1            ; ae = yes
  930.     mov    byte ptr [di],'0'    ; insert leading 0
  931.     inc    di
  932. wrtdat1:call    dec2di            ; write decimal asciiz to buffer
  933.     mov    byte ptr [di],'-'
  934.     inc    di
  935.     pop    dx            ; recover dx
  936.     xor    ah,ah
  937.     mov    al,dl            ; Days
  938.     cmp    al,10            ; leading digit?
  939.     jae    wrtdat2            ; ae = yes
  940.     mov    byte ptr [di],'0'    ; make our own
  941.     inc    di
  942. wrtdat2:call    dec2di            ; write decimal asciiz to buffer
  943.     mov    byte ptr [di],'-'
  944.     inc    di
  945.     pop    cx            ; recover cx
  946.     mov    ax,cx            ; Year (omit century)
  947.     call    dec2di            ; write decimal asciiz to buffer
  948.     mov    word ptr [di],0020h    ; space and null terminator
  949.     inc    di
  950.     mov    temp,di            ; place for additional text
  951.     jmp    wrttxt1            ; add any trailing text
  952. wrtdate    endp
  953.  
  954. ; WRITE <log> ERRORLEVEL
  955. wrterr    proc    near
  956.     mov    di,offset rdbuf        ; where to write the buffer
  957.     mov    al,errlev        ; current Errorlevel
  958.     xor    ah,ah
  959.     call    dec2di            ; write as ascii
  960.     mov    word ptr [di],0020h    ; space and null terminator
  961.     inc    di
  962.     mov    temp,di            ; place for additional text
  963.     jmp    wrttxt1            ; add any trailing text
  964. wrterr    endp
  965.  
  966. ; Write <log> INPUT-buffer (no trailing text)
  967. wrtinp    proc    near
  968.     mov    ah,cmeol        ; get a confirm
  969.     call    comnd
  970.     jnc    wrtin6            ; nc = success
  971.     ret                ; failure
  972. wrtin6:    push    es
  973.     call    buflog            ; get INPUT buffer pointers
  974.     mov    bx,cx            ; length of buffer (and max offset)
  975.     mov    di,offset rdbuf        ; where to write the buffer
  976.     mov    byte ptr [di],'<'    ; start with "<# unread chars>"
  977.     inc    di
  978.     push    cx
  979.     push    dx
  980.     call    dec2di            ; ax has unread count, bufcnt
  981.     pop    dx
  982.     pop    cx
  983.     mov    byte ptr [di],'>'
  984.     inc    di
  985. wrtin1:    mov    al,es:[si]        ; extract a buffer char into al
  986.     inc    si            ; move pointer to next byte
  987.     test    al,80h            ; high bit set?
  988.     jz    wrtin2            ; z = no
  989.     mov    byte ptr [di],'~'    ; yes, show a tilde
  990.     inc    di
  991. wrtin2:    and    al,7fh            ; strip eighth bit
  992.     cmp    al,' '            ; control code?
  993.     jae    wrtin3            ; ae = no
  994.     mov    byte ptr [di],'^'    ; yes, show caret
  995.     inc    di
  996.     or    al,40h            ; convert char to upper case letter
  997. wrtin3:    mov    [di],al
  998.     inc    di            ; where to write next byte
  999.     cmp    di,offset rdbuf+78    ; line full?
  1000.     jb    wrtin4            ; b = no, have more room
  1001.     mov    word ptr [di],0a0dh    ; add cr/lf
  1002.     mov    byte ptr [di+2],0
  1003.     push    bx
  1004.     push    cx
  1005.     push    dx
  1006.     push    si
  1007.     push    es
  1008.     call    wrtcom            ; dump what we have
  1009.     pop    es
  1010.     pop    si
  1011.     pop    dx
  1012.     pop    cx
  1013.     pop    bx
  1014.     mov    di,offset rdbuf        ; reset to start of our local buffer
  1015. wrtin4:    cmp    si,bx            ; beyond end of Input buffer?
  1016.     jb    wrtin5            ; b = not yet
  1017.     xor    si,si            ; reset to start of INPUT-buf (wrap)
  1018. wrtin5:    loop    wrtin1
  1019.     mov    word ptr [di],0a0dh    ; add cr/lf
  1020.     mov    byte ptr [di+2],0
  1021.     pop    es
  1022.     jmp    wrtcom            ; write the last of INPUT buffer
  1023. wrtinp    endp
  1024.  
  1025. ; Write <log> PATH <optional text>
  1026. wrtpath    proc    near
  1027.     mov    si,offset rdbuf        ; work buffer
  1028.     mov    ah,gcurdsk        ; get current disk
  1029.     int    dos
  1030.     add    al,'A'            ; make al = 0 == 'A'
  1031.     mov    [si],al
  1032.     mov    word ptr [si+1],'\:'
  1033.     add    si,3            ; end with a colon and backslash
  1034.     mov    ah,gcd            ; get current directory (path really)
  1035.     xor    dl,dl            ; use current drive
  1036.     int    dos            ; get ds:si = asciiz path (no drive)
  1037.     mov    dx,si
  1038.     call    strlen
  1039.     add    si,cx
  1040.     mov    word ptr [si],0020h    ; space and null terminator
  1041.     inc    di
  1042.     mov    temp,di            ; place for additional text
  1043.     jmp    wrttxt1            ; add any trailing text
  1044. wrtpath    endp
  1045.  
  1046. ; Write <log> TIME <optional text>
  1047. wrttime    proc    near
  1048.     mov    ah,gettim        ; DOS tod (ch=hh, cl=mm, dh=ss, dl=.s)
  1049.     int    dos
  1050.     mov    di,offset rdbuf
  1051.     push    dx            ; save dx
  1052.     xor    ah,ah
  1053.     mov    al,ch            ; Hours
  1054.     cmp    al,10            ; leading digit?
  1055.     jae    wrttim1            ; ae = yes
  1056.     mov    byte ptr [di],'0'    ; make our own
  1057.     inc    di
  1058. wrttim1:push    cx
  1059.     call    dec2di            ; write decimal asciiz to buffer
  1060.     pop    cx
  1061.     mov    byte ptr [di],':'
  1062.     inc    di
  1063.     xor    ah,ah
  1064.     mov    al,cl            ; Minutes
  1065.     cmp    al,10            ; leading digit?
  1066.     jae    wrttim2            ; ae = yes
  1067.     mov    byte ptr [di],'0'    ; make our own
  1068.     inc    di
  1069. wrttim2:call    dec2di            ; write decimal asciiz to buffer
  1070.     mov    byte ptr [di],':'
  1071.     inc    di
  1072.     pop    dx
  1073.     push    dx
  1074.     xor    ah,ah
  1075.     mov    al,dh            ; Seconds
  1076.     cmp    al,10            ; leading digit?
  1077.     jae    wrttim3            ; ae = yes
  1078.     mov    byte ptr [di],'0'    ; make our own
  1079.     inc    di
  1080. wrttim3:call    dec2di            ; write decimal asciiz to buffer
  1081.     mov    byte ptr [di],'.'
  1082.     inc    di
  1083.     pop    dx
  1084.     xor    ah,ah
  1085.     mov    al,dl            ; Hundredths of seconds
  1086.     cmp    al,10            ; leading digit?
  1087.     jae    wrttim4            ; ae = yes
  1088.     mov    byte ptr [di],'0'    ; make our own
  1089.     inc    di
  1090. wrttim4:call    dec2di            ; write decimal asciiz to buffer
  1091.     mov    word ptr [di],0020h    ; space and null terminator
  1092.     inc    di
  1093.     mov    temp,di            ; place for additional text
  1094.     jmp    wrttxt1            ; add any trailing text
  1095. wrttime    endp
  1096.  
  1097. ; Write <log> Version (no optional text)
  1098. wrtver    proc    near
  1099.     mov    si,offset verident    ; MS Kermit version string in mssker
  1100.     mov    di,offset rdbuf
  1101.     cld
  1102. wrtver1:lodsb
  1103.     mov    [di],al
  1104.     inc    di
  1105.     cmp    al,'$'            ; end of string?
  1106.     jne    wrtver1            ; ne = no, continue copying
  1107.     dec    di
  1108.     mov    word ptr [di],0020h    ; space and null terminator
  1109.     inc    di
  1110.     mov    temp,di            ; place for additional text
  1111.     jmp    wrttxt1            ; add any trailing text
  1112. wrtver    endp
  1113.  
  1114. ; Write <log> TEXT <optional text>
  1115. wrttxt    proc    near            ; write string of text
  1116.     mov    comand.cmcr,1        ; bare cr's allowed without error
  1117.     mov    temp,offset rdbuf    ; our buffer
  1118. wrttxt1:mov    ah,cmline        ; get string to be written
  1119.     mov    bx,temp            ; where to put text
  1120.     mov    dx,offset rdbuf + 255   ; length rdbuf, end of buffer
  1121.     sub    dx,bx            ; minus used part of buffer, yields
  1122.     cmp    dx,127            ;  length remaining in buffer
  1123.     jbe    wrttxt2            ; be = regular buffer length
  1124.     mov    dl,127            ; cut back to that size
  1125. wrttxt2:mov    comand.cmblen,dl    ;  length remaining in buffer
  1126.     mov    dx,offset msgtxt    ; help
  1127.     call    comnd
  1128.     mov    si,temp            ; start of text in buffer
  1129.     mov    di,si            ; convert in-place, to asciiz
  1130.     call    cnvlin
  1131.     jmp    wrtcom            ; finish in common write code
  1132. wrttxt    endp
  1133.  
  1134. ; Writes contents of buffer rdbuf (asciiz) to log file kind held in tmp
  1135. ; and returns to command parser
  1136. wrtcom    proc    near            ; common write code
  1137.     mov    ah,cmeol
  1138.     call    comnd
  1139.     jnc    wpkt0
  1140.     ret                ; c = failure
  1141. wpkt0:    mov    bl,tmp            ; log file kind
  1142.     cmp    bl,logpkt        ; Packet log?
  1143.     jne    wses1            ; ne = no
  1144.     mov    si,offset rdbuf
  1145.     mov    dx,si
  1146.     call    strlen
  1147.     jcxz    wpkt2            ; z = no chars to write
  1148. wpkt1:    lodsb                ; get byte to al
  1149.     call    pktcpt            ; write to packet log
  1150.     loop    wpkt1
  1151. wpkt2:    clc                ; say success
  1152.     ret
  1153.  
  1154. wses1:    cmp    bl,logses        ; Session log?
  1155.     jne    wtrn1            ; ne = no
  1156.     mov    si,offset rdbuf
  1157.     mov    dx,si
  1158.     call    strlen
  1159.     jcxz    wses3            ; z = no chars to write
  1160. wses2:    lodsb                ; get byte to al
  1161.     call    cptchr            ; write to log
  1162.     loop    wses2            ; do cx chars
  1163. wses3:    clc                ; say success
  1164.     ret
  1165.  
  1166. wtrn1:    cmp    bl,logtrn        ; Transaction log?
  1167.     jne    wtscn            ; ne = no
  1168.     mov    bx,tloghnd        ; file open?
  1169.     cmp    bx,0
  1170.     jle    wtrn2            ; le = no, forget it
  1171.     mov    dx,offset rdbuf
  1172.     call    strlen            ; length to cx
  1173.     jcxz    wtrn2            ; z = nothing to write
  1174.     mov    ah,write2        ; write to file handle in bx
  1175.     int    dos
  1176. wtrn2:    clc                ; success
  1177.     ret
  1178. wtscn:    cmp    bl,80h            ; write screen?
  1179.     jne    wtscn1            ; ne = no
  1180.     mov    dx,offset rdbuf
  1181.     call    strlen            ; length to cx
  1182.     jcxz    wtrn2            ; z = nothing to write
  1183.     xor    bx,bx            ; handle is stdout
  1184.     mov    ah,write2        ; write to file handle in bx
  1185.     int    dos
  1186. wtscn1:    clc
  1187.     ret
  1188. wrtcom    endp
  1189.  
  1190. code    ends 
  1191.     end
  1192.