Columbia Kermit/kermit.zip/archives/msr313src.zip/msscmd.asm

Assembly Source File | 1993-07-12 | 78KB | 2,483 lines

    NAME    msscmd
; File MSSCMD.ASM
    include mssdef.h
;  Copyright (C) 1985, 1993, Trustees of Columbia University in the
;  City of New York.  Permission is granted to any individual or institution
;  to use this software as long as it is not sold for profit.  This copyright
;  notice must be retained.  This software may not be included in commercial
;  products without written permission of Columbia University.
;
; Edit history:
; 27 August 1992 version 3.13
; 6 Sept 1991 version 3.11
; 13 March 1991 version 3.10
; Last edit 21 Oct 1992
; 5 Jan 1991 Add \$(Environment variable) substitution.
; 9 Sept 1990 Add \v(named variable) substitution.
; 21 Nov 1988 Version 2.32
; 17 Oct 1988 Make command keyword search failure yield global kstatus of
;  failure status, to inform Take/Macros of a defective command.
; 4 Aug 1988 Fix keyword count initialization in help display.
; 1 July 1988 Version 2.31
; 7 June 1988 Add comand.impdo flag to permit a keyword search failure to
;  retry as a DO cmd (macro table). Used only by main Kermit command level.
; 27 May 1988 Allow "-<cr>" as line continuation pair and let "\-<cr>"
;  stand for "-<end of line>". Add comand.cmblen to sense buffer overflow on
;  calls to cmtxt; if comand.cmblen is left at zero then use 128 byte limit
;  (comand.cmblen is cleared at command end).
; 15 May 1988 Make :label keywords no-ops, make query ordinary char in TAKEs.
; 6 May 1988 Show ambiguous keywords at parse time, do graceful interaction.
; 28 March 1988 Permit '\%x' (x = '0' or above) in commands as 'variables'
;  (substituted string of text). Words are obtained from Macro table mcctab.
;  DEF MAC and DO MAC define variables. DEF macro uses comand.cmper > 0 to
;  allow '\%x'to be stored as a literal. Variables work in any command except
;  DEF MAC. Major redesign of whole parser. [jrd]
; 4 March 1988 Rewrite keyword parsing to permit non-alphabetized tables
;  and 8-bit characters. Add byte comand.cmwhite which when non-zero permits
;  leading whitespace in cmline and cmword commands; it is reset at command
;  completion. Move procedure Prompt here from mssker. [jrd]
; 27 Feb 1988 Add capability of stdin being a file. [jrd]
; 1 Jan 1988 version 2.30

     public comnd, comand, isdev, iseof, prompt, tolowr, valbuf, valtab
    public parstate, pardone, parfail, nparam, param, lparam, ninter
    public inter, atparse, atpclr, atdispat, cspb, dspb, mprompt, nvaltoa
    public savepoff, saveplen, keyboard, fwrtdir, cspb1

env    equ    2CH            ; environment address in psp
braceop    equ    7bh            ; opening curly brace
bracecl    equ    7dh            ; closing curly brace

data     segment
    extrn    flags:byte, taklev:byte, takadr:word, mcctab:byte
    extrn    kstatus:word, oldtak:byte, errlev:byte, psp:word
    extrn    portval:word, bdtab:byte, tdfmt:byte, machnam:byte
    extrn    verident:word, kstatus:word, errlev:byte, comptab:byte
    extrn    termtb:byte, sescur:word, dosnum:word

                ; Start Patch structure. Must be first.
    even
dspb    dw    code        ; segment values for patcher
    dw    code1
    dw    code2
    dw    data
    db    64 dup (0)    ; data segment patch buffer
                ;  with space for other material, if req'd
                ; end of Patch structure
progm    db    'MS-DOS_KERMIT$'    ; for \v(program)
system    db    'MS-DOS$'        ; for \v(system)
keyboard dw    88            ; \v(keyboard) kind of keybd 88/101

comand    cmdinfo    <>
cmer00  db      cr,lf,'?Program internal error, recovering$'
cmer01    db    cr,lf,'?More parameters are needed$'
cmer02    db    cr,lf,'?Word "$'
cmer03    db    '" is not usable here$'
cmer04    db    '" is ambiguous$'
cmer07    db    cr,lf,'?Ignoring extra characters "$'
cmer08    db    '"$'
cmer09    db    cr,lf,'?Text exceeded available buffer capacity$'
cmin00  db      ' Press ENTER to execute command$'
cmin01    db    ' Use one of the following words in this position:',cr,lf,'$'
stkmsg    db    cr,lf,bell,'?Exhausted work space! Circular definition?$'
crlf    db      cr,lf,'$'
ctcmsg    db    5eh,'C$'
cmunk    db    'unknown'
errflag    db    0            ; non-zero to suppress cmcfrm errors
kwstat    db    0            ; get-keyword status
prevch    db    0            ; previous char read by cmgetc
noparse    db    0            ; semicolons not special, if non-zero
subcnt    db    0            ; count of chars matched in '\%'
subtype db    0            ; kind of sub (% or v)
bracecnt db    0            ; curly brace counter
cmsflg    db    0            ; Non-zero when last char was a space
cmdbuf    db    cmdblen dup (0)        ; Buffer for command parsing
    even
cmdstk    dw    0            ; stack pointer at comand call time
cmptab    dw    0            ; Address of present keyword table
cmhlp    dw    0            ; Address of present help
cmwptr    dw    0            ; Pointer for next char write
cmrptr    dw    0            ; Pointer for next char read
cmsiz    dw    0            ; Size info of user input
cmsptr    dw    0            ; Place to save a pointer
mcmprmp    dw    0            ; master prompt, string address
mcmrprs    dd    0            ; master prompt, reparse address
mcmostp    dw    0            ; master prompt, stack pointer
temp    dw    0            ; temp (counts char/line so far)

valtab    db    1+19            ; table of values for \v(value)
    mkeyw    'argc)',1
    mkeyw    'count)',2
    mkeyw    'date)',3
    mkeyw    'ndate)',14
    mkeyw    'directory)',5
    mkeyw    'dosversion)',19
    mkeyw    'errorlevel)',4
    mkeyw    'keyboard)',10
    mkeyw    'line)',15
    mkeyw    'platform)',8
    mkeyw    'port)',15
    mkeyw    'program)',12
    mkeyw    'session)',17
    mkeyw    'speed)',11
    mkeyw    'status)',13
    mkeyw    'system)',9
    mkeyw    'terminal)',16
    mkeyw    'time)',6
    mkeyw    'ntime)',18
    mkeyw    'version)',7

envtab    db    1                     ; \$(..) Environment table
    mkeyw    'An Environment variable)',0    ; reserve 0 in valtab

valtmp    dw    0
valbuf    db    130 dup (0)        ; storage of variable definition

    even
envadr    dd    0            ; seg:offset of a string in Environemt
envlen    dw    0            ; length of envadr's string

    even                ; Control sequence storage area
maxparam equ    16            ; number of ESC and DCS Parameters
maxinter equ    16            ; number of ESC and DCS Intermediates

savepoff label    word            ; Start per session save area
parstate dw    0            ; parser state, init to startup
pardone dw    0            ; where to jmp after Final char seen
parfail    dw    0            ; where to jmp if parser fails
nparam    dw    0            ; number of received Parameters
param    dw    maxparam dup (0)    ; Parameters for ESC
lparam    db    0            ; a single letter Parameter for ESC
ninter    dw    0            ; number of received Intermediates
inter    db    maxinter dup (0),0    ; Intermediates for ESC, + guard
saveplen dw    ($-savepoff)

pcmcfrm    dd    cmcfrm             ; FAR pointers to main parser procs
pcmkeyw    dd    cmkeyw             ; located in code segment code1
pcmtext    dd    cmtext
pcmfil0    dd    cmfil0
pprserr    dd    prserr
pcmexit    dd    cm6
pfvaltoa dd    fvaltoa
data    ends

code1    segment
cspb1    equ    this byte
    db    (256-($-cspb1)) dup (0)    ; code1 segment patch buffer
                ; end of Patch area
code1    ends

code    segment
    extrn    ctlu:near, cmblnk:near, locate:near, takrd:near, dec2di:near
    extrn    takclos:near, docom:near, prtasz:near, getenv:near
    extrn    getbaud:near, strlen:near, prtscr:near

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

                ; Patch area. Must be first in MSK's Code Seg
cspb    equ    this byte
    dw    seg code1
    dw    seg code2
    dw    seg data
    dw    seg data1
    db    (256-($-cspb)) dup (0)    ; code segment patch buffer
                ; end of Patch area

fctlu    proc    far        ; FAR callable versions of items in seg code
    call    ctlu        ;  for calling from code segment code1 below
    ret
fctlu    endp
fcmblnk    proc    far
    call    cmblnk
    ret
fcmblnk    endp
fgetbaud proc    far
    call    getbaud
    ret
fgetbaud endp
fgetenv    proc    far
    call    getenv
    ret
fgetenv    endp
flocate    proc    far
    call    locate
    ret
flocate    endp
ftakrd    proc    far
    call    takrd
    ret
ftakrd    endp
fdec2di    proc    far
    call    dec2di
    ret
fdec2di    endp
fstrlen    proc    far
    call    strlen
    ret
fstrlen    endp
ftakclos proc    far
    call    takclos
    ret
ftakclos endp
fprtasz    proc    far
    call    prtasz
    ret
fprtasz    endp
fprtscr    proc    far
    call    prtscr
    ret
fprtscr    endp
fisdev    proc    far
    call    isdev
    ret
fisdev    endp
fiseof    proc    far
    call    iseof
    ret
fiseof    endp
ftolowr    proc    far
    call    tolowr
    ret
ftolowr    endp
nvaltoa    proc    near
    call    dword ptr pfvaltoa
    ret
nvaltoa    endp

;       This routine parses the specified function in AH. Any additional
;       information is in DX and BX.
;       Returns carry clear on success and carry set on failure

COMND    PROC NEAR
    mov    cmdstk,sp        ; save stack ptr for longjmp exit
    mov    noparse,0          ; recognize semicolons in Take files
    mov    bracecnt,0        ; curly brace counter
    mov    al,taklev        ; Take level now
    mov    oldtak,al        ; remember past internal takclos call
    cmp    ah,cmeol        ; Parse a confirm?
    jne    cm2            ; nz = no
    call    dword ptr pcmcfrm    ; get a Carriage Return end of line
    ret
cm2:     cmp    ah,cmkey        ; Parse a keyword?
    jne    cm3
    call    dword ptr pcmkeyw    ; try and get one
    ret
cm3:    cmp    ah,cmline        ; parse line of text
    jne    cm4
    call    dword ptr pcmtext
    ret
cm4:    cmp    ah,cmword        ; parse arbitrary word
    jne    cm5
    call    dword ptr pcmfil0
    ret
cm5:    mov    ah,prstr        ; else give error
    mov    dx,offset cmer00    ; "?Program internal error"
    int    dos
    jmp    dword ptr pprserr    ; reparse
                    ; Control-C exit path (far to near)
cm6:    mov    sp,cmdstk        ; restore command entry stack pointer
    stc
    ret                ;  and fail immediately (a longjmp)

COMND    ENDP
code    ends

code1    segment
    assume    cs:code1

; This routine parses a keyword from the table pointed at by DX, help text
; point to by BX. Format of the table is as follows (use macro mkeyw):
;    addr:    db    N      ; Where N is the # of entries in the table
;        dw    M      ; M is the size of the keyword
;        db    'string'  ; String is the keyword
;        dw    value      ; Value is data to be returned
; Keywords may be in any order and in mixed case.
; Return is rskp for success and ret for failure.

; cmptab: pointer to keyword table (supplied by caller)
; cmhlp: pointer to help message (supplied by caller)
; cmsptr: pointer to current user word text
; cmsiz: length of user text, excluding terminator
; comand.cmcr: 0 = empty lines not allowed, 1 = empty lines allowed
; comand.cmwhite: non-zero allows leading whitespace for cmline and cmword,
;                 reset automatically at end of call
; cmwptr: buffer write pointer to next free byte
; cmrptr: buffer read pointer for next free byte
; comand.cmper:    0 to do \%x substitution. Set to 0 at end of call
; comand.impdo: non-zero permits keyword failure to retry as DO command, reset
;         automatically at time of failure.
cmkeyw    proc    far
    mov    cmsiz,0            ; user word length
    mov    ax,cmrptr        ; get command reading pointer
    mov    cmsptr,ax        ; set pointer for start of user word
    mov    cmhlp,bx        ; save the help pointer
        mov    cmptab,dx        ; save the beginning of keyword table
    mov    bx,dx
    cmp    byte ptr[bx],0        ; get number of entries in table
    jne    cmky1
    jmp    cmky7            ; e = no keywords to check, error
cmky1:    mov    cmsflg,0ffh        ; skip leading spaces/tabs
    call    cmgtch            ; get char from the user into ah
    jc    cmky3            ; c = terminator
    mov    dx,cmrptr        ; next byte to read
    dec    dx            ; where we just read a char
    mov    cmsptr,dx        ; remember start of keyword
    inc    cmsiz            ; start counting user chars
cmky2:    call    cmgtch            ; read until terminator
    jc    cmky3            ; c = terminator
    inc    cmsiz            ; count user chars
    jmp    short cmky2        ; no terminator yet

cmky3:    cmp    ah,'?'                  ; need help?
    jne    cmky4            ; ne = no
    jmp    cmkyhlp            ; do help and exit
cmky4:    cmp    ah,escape        ; escape?
    jne    cmky6            ; ne = no
    call    cmkyesc            ; process escape
    jc    cmky5            ; c = failure (no unique keyword yet)
    mov    comand.cmper,0        ; reset to variable recognition
    mov    comand.cmkeep,0
    mov    comand.impdo,0        ; clear flag to prevent loops
    mov    comand.cmquiet,0    ; permit echoing again
    clc
    ret                ; return successfully to user

cmky5:    cmp    cmsiz,0            ; started a word yet?
    je    cmky1            ; e = no, ignore escape, keep looking
    jmp    cmkyhlp            ; ne = yes, show type of error

cmky6:    cmp    cmsiz,0            ; length of user's text, empty?
    je    cmky7            ; e = yes, parse error
    push    bx
    mov    bx,cmsptr        ; point at first user character
    cmp    byte ptr[bx],':'    ; start of a label?
    pop    bx
    jne    cmky6a            ; ne = no, return success
    mov    cmsiz,1            ; say just one byte
cmky6a:    call    getkw            ; get unique kw, point to it with bx
    jc    cmky8            ; c = not found
    add    bx,[bx]            ; add length of keyword text (CNT)
    add    bx,2            ; point at value field
    mov    bx,[bx]            ; bx = return value following keyword
    xor    ax,ax
    mov    comand.cmper,al        ; reset to variable recognition
    mov    comand.cmkeep,al
    mov    comand.impdo,al        ; clear flag to prevent loops
    mov    comand.cmquiet,al    ; permit echoing again
    mov    errflag,al
    clc
    ret                ; return successfully
                    ; all other terminators come here
cmky7:    cmp    cmsiz,0            ; empty table or empty user's text?
    jne    cmky8            ; ne = no
    cmp    comand.cmcr,0        ; empty lines allowed?
    jne    cmky10            ; ne = yes, do not complain
    push    dx
    mov    ah,prstr
    mov    dx,offset cmer01    ; command word expected
    int    dos
    pop    dx
    xor    al,al
    mov    comand.cmquiet,al    ; permit echoing again
    mov    comand.impdo,al        ; clear flag to prevent loops
    stc                ; failure
    ret

cmky8:    cmp    comand.impdo,0        ; failed here, ok to try Macro table?
    je    cmky8a            ; e = no, use regular exit path
    mov    comand.impdo,0        ; yes, but clear flag to prevent loops
    mov    cmrptr,offset cmdbuf    ; reinit read pointer
    mov    comand.cmquiet,1    ; suppress echoing of same keyword
    mov    bx,offset docom        ; return DO as "found" keyword
    clc
    ret                ; return success to invoke DO

cmky8a:    mov    errflag,1        ; say already doing error recovery
    or    kstatus,ksgen        ; global command status, failure
    mov    comand.cmquiet,0    ; permit echoing again
    call    fisdev            ; reading pretyped lines?
    jnc    cmky9            ; nc = yes, consume rest of line
    cmp    taklev,0        ; in a Take file?
    jne    cmky9            ; ne = yes
    call    cmskw            ; display offending keyword
    dec    cmrptr            ; interactive, backup to terminator
    mov    bx,cmrptr        ; look at it
    cmp    byte ptr [bx],' '    ; got here on space terminator?
    jne    cmky10            ; ne = no, (cr,lf,ff) exit failure
    mov    ah,prstr        ; start a fresh line
    mov    dx,offset crlf
    int    dos
    call    bufreset        ; cut back buffer to just before term
    jmp    repars            ; reparse interactive lines

cmky9:    call    dword ptr pcmcfrm    ; get formal end of command line
                    ;  to maintain illusion of typeahead
                    ;  and let user backspace to correct
                    ;  mistakes (we reparse everything)
    call    cmskw            ; display offending keyword
cmky10:    mov    comand.cmquiet,0    ; permit echoing again
    stc                ; say failure
    ret
cmkeyw    endp

;;;;;; start support routines for keyword parsing.

cmkyesc    proc    near            ; deal with escape terminator
    call    bufreset        ; reset buffer to end just before ESC
    cmp    cmsiz,0         ; user word length, empty?
    jne    cmkye2            ; ne = have user text, else complain
cmkye1:    call    esceoc            ; do normal escape end-of-command
    stc                ; say failure to fill out word
    ret
                    ; add unique keyword to buffer
cmkye2:    call    getkw            ; is there a matching keyword?
    jc    cmkye1            ; c = ambiguous or not found
    push    bx            ; unique, bx points to structure
    push    si
    mov    cx,[bx]            ; length of keyword
    add    bx,2            ; point to first letter
    mov    si,cmwptr        ; where next char goes
    mov    dx,cmsiz        ; length of user word
    add    bx,dx            ; add chars known so far
    sub    cx,dx            ; calculate number yet to add
    add    cmsiz,cx
    jcxz    cmkye4            ; z = none
    mov    ah,conout        ; display new char
cmkye3:    mov    al,[bx]            ; get a keyword letter
    inc    bx
    call    ftolowr            ; lowercase
    mov    [si],al            ; store it
    inc    si
    mov    dl,al
    int    dos            ; display it
    loop    cmkye3            ; do all new chars
cmkye4:    mov    byte ptr[si],' '    ; insert space terminator in buffer
    mov    dl,' '            ; display it
    mov    ah,conout
    int    dos
    inc    si
    mov    cmrptr,si        ; move token pointer after the space
    mov    cmwptr,si        ; next free slot is after the space
    mov    cmsflg,0ffh        ; set space-seen flag
    pop    si
    pop    bx            ; bx = keyword structure
    add    bx,[bx]            ; add length of keyword text
    add    bx,2            ; point at value field
    mov    bx,[bx]            ; bx = return value following keyword
    clc                ; carry clear for success
    ret
cmkyesc    endp

esceoc    proc    near            ; do normal escape end-of-command
    push    ax
    push    dx
    mov    ah,conout        ; ring the bell
    mov    dl,bell
    int    dos
    pop    dx
    pop    ax
    call    bufreset        ; reset buffer
    stc                ; say error condition
    ret
esceoc    endp

; Help. Question mark entered by user.  Display all the keywords that match
; user text. If text is null then use external help if available; otherwise,
; display all keywords in the table. Removes question mark from buffer and
; invokes reparse of command line to-date. User word starts at cmsptr and
; is cmsiz bytes long.
cmkyhlp    proc    near
    xor    cx,cx            ; clear number of keyword (none yet)
    cmp    cmsiz,0            ; user text given?
    jne    cmkyh1            ; ne = yes, use matching keywords
    cmp    cmhlp,0            ; external help given?
    jne    cmkyh6            ; yes, use it instead of full table
cmkyh1:    mov    temp,0            ; count # chars printed on this line
    mov    bx,cmptab        ; beginning of kw table
    mov    ch,[bx]            ; length of table
    xor    cl,cl            ; no keywords or help displayed yet
    inc    bx            ; point at CNT field
cmkyh2:    cmp    cmsiz,0            ; length of user word
    je    cmkyh3            ; e = null, use full table
    call    cmpwrd            ; compare keyword with user word
    jc    cmkyh5            ; c = no match, get another keyword
cmkyh3:    mov    ax,[bx]            ; length of table keyword
    add    byte ptr temp,al    ; count chars printed so far
    cmp    temp,76            ; will this take us beyond column 78?
    jbe    cmkyh4            ; be = no, line has more room
    mov    byte ptr temp,al    ; reset the count
    mov    ah,prstr
    mov    dx,offset crlf        ; break the line
    int    dos
cmkyh4:    or    cl,cl            ; any keywords found yet?
    jnz    cmkyh4a            ; nz = yes
    mov    dx,offset cmin01    ; start with One of the following: msg
    mov    ah,prstr
    int    dos
    inc    cl            ; say one keyword has been found
cmkyh4a:mov    dl,spc            ; put two spaces before each keyword
    mov    ah,conout
    int    dos
    int    dos
    add    temp,2            ; count output chars
    mov    di,bx            ; get current keyword structure
    add    di,2            ; text part
    push    cx
    mov    cx,[bx]            ; string length to cx, offset to di
    call    fprtscr            ; display counted string
    pop    cx
cmkyh5:    dec    ch            ; are we at end of table?
    jle    cmkyh7            ; le = yes, quit now
    add    bx,[bx]            ; next keyword, add CNT chars to bx
    add    bx,4            ; skip CNT and 16 bit value
    jmp    cmkyh2            ; go examine this keyword

cmkyh6:    mov    dx,cmhlp        ; external help text
    mov    ah,prstr
    int    dos
    inc    cl            ; say gave help already
cmkyh7:    or    cl,cl            ; found any keywords?
    jnz    cmkyh9            ; nz = yes
    mov    cx,cmsiz        ; length of word
    or    cx,cx
    jg    cmkyh8            ; g = something to show
    push    dx
    mov    ah,prstr
    mov    dx,offset cmer01    ; command word expected
    int    dos
    pop    dx
    jmp    prserr
cmkyh8:    mov    kwstat,0        ; set keyword not-found status
    call    cmskw            ; display offending keyword
cmkyh9:    mov    ah,prstr        ; start a fresh line
    mov    dx,offset crlf
    int    dos
    call    bufreset        ; cut back buffer to just before '?'
        jmp    repars
cmkyhlp    endp

; See if keyword is ambiguous or not from what the user has typed in.
; Return carry set if word is ambiguous or not found, carry clear otherwise.
; Uses table pointed at by cmptab, user text pointed at by cmsptr and length
; in cmsiz.
cmambg    proc    near
    push    bx
    push    cx
    push    dx
    xor    dl,dl            ; count keyword matches so far
    mov    bx,cmptab        ; look at start of keyword table
    mov    cl,[bx]            ; get number of entries in table
    xor    ch,ch            ; use cx as a counter
    jcxz    cmamb8            ; z = no table so always ambiguous
    inc    bx            ; look at CNT byte of keyword
cmamb4:    call    cmpwrd            ; user vs table words, same?
    jc    cmamb6            ; c = no match
    inc    dl            ; count this as a match
    cmp    dl,1            ; more than one match?
    ja    cmamb8            ; a = yes, quit now
cmamb6:    add    bx,[bx]            ; add CNT chars to bx
    add    bx,4            ; skip CNT and 16 bit value
    loop    cmamb4            ; do rest of keyword table
    cmp    dl,1            ; how many matches were found?
    jne    cmamb8            ; ne = none or more than 1: ambiguous
    pop    dx            ; restore main registers
    pop    cx
    pop    bx
    clc
    ret                ; ret = not ambiguous
cmamb8:    pop    dx            ; restore main registers
    pop    cx
    pop    bx
    stc
    ret                ; return ambiguous or not found
cmambg    endp

; Compare user text with keyword, abbreviations are considered a match.
; Enter with bx pointing at keyword table CNT field for a keyword.
; Return carry clear if they match, set if they do not match. User text
; pointed at by cmsptr and length is in cmsiz.
; Registers preserved.

cmpwrd    proc    near
    push    cx
    mov    cx,cmsiz        ; length of user's text
    jcxz    cmpwrd2            ; z: null user word matches no keyword
    cmp    cx,[bx]            ; user's text longer than keyword?
    ja    cmpwrd2            ; a = yes, no match
    push    ax
    push    bx
    push    si
    add    bx,2                ; point at table's keyword text
    mov    si,cmsptr        ; buffer ptr to user input
    cld
cmpwrd1:lodsb                ; user text
    mov    ah,[bx]            ; keyword text
    inc    bx            ; next keyword letter
    call    ftolowr            ; force lower case on both chars
    cmp    ah,al            ; same?
    loope    cmpwrd1            ; e = same so far
    pop    si
    pop    bx
    pop    ax
    jne    cmpwrd2            ; ne = mismatch
    pop    cx            ; recover keyword counter
    clc                ; they match
    ret
cmpwrd2:pop    cx            ; recover keyword counter
    stc                ; they do not match
    ret
cmpwrd    endp

; Get pointer to keyword structure using user text. Uses keyword table
; pointed at by cmptab and cmsiz holding length of user's keyword (cmpwrd
; needs comand.cmsptr pointing at user's keyword and length of cmsiz).
; Structure pointer returned in BX.
; Return carry clear for success and carry set for failure. Modifies BX.
getkw    proc    near
    push    cx
    mov    kwstat,0        ; keyword status, set to not-found
    cmp    cmsiz,0            ; length of user word, empty?
    je    getkw3            ; e = yes, fail
    mov    bx,cmptab        ; table of keywords
    mov    cl,[bx]            ; number of keywords in table
    xor    ch,ch
    jcxz    getkw3            ; z = none, fail
    inc    bx            ; point to first
getkw1:    call    cmpwrd            ; compare user vs table words
    jc    getkw2            ; c = failed to match word, try next
    mov    kwstat,1        ; say found one keyword, maybe more
    push    dx
    mov    dx,cmsiz        ; users word length
    cmp    [bx],dx            ; same length (end of keyword)?
    pop    dx
    je    getkw4            ; e = yes, exact match. Done
    call    cmambg            ; ambiguous?
    jnc    getkw4            ; nc = unique, done, return with bx
    mov    kwstat,2        ; say more than one such keyword
getkw2:    add    bx,[bx]            ; next keyword, add CNT chars to bx
    add    bx,4            ; skip CNT and 16 bit value
    loop    getkw1            ; do all, exhaustion = failure
getkw3:    pop    cx
    stc                ; return failure
    ret
getkw4:    pop    cx
    clc                ; return success
    ret
getkw    endp

; show offending keyword message. Cmsptr points to user word,
; cmsiz has length. Modifies AX, CX, and DX.
cmskw    proc    near
    cmp    comand.cmquiet,0    ; Quiet mode?
    je    cmskw0            ; e = no, regular mode
    ret                ; else say nothing
cmskw0:    mov    ah,prstr        ; not one of the above terminators
    mov    dx,offset cmer02    ; '?Word "'
    int    dos
    mov    ah,conout
    mov    cx,cmsiz        ; length of word
    jcxz    cmskw3            ; z = null
    mov    ah,conout
    push    si
    mov    si,cmsptr        ; point to word
    cld
cmskw1:    lodsb
    cmp    al,' '            ; control code?
    jae    cmskw2            ; ae = no
    push    ax
    mov    dl,5eh            ; caret
    int    dos
    pop    ax
    add    al,'A'-1        ; plus ascii bias
cmskw2:    mov    dl,al            ; display chars in word
    int    dos
    loop    cmskw1
    pop    si
cmskw3:    mov    dx,offset cmer03    ; '" not usable here.'
    cmp    kwstat,1        ; kywd status from getkw, not found?
    jb    cmskw4            ; b = not found, a = ambiguous
    mov    dx,offset cmer04    ; '" ambiguous'
cmskw4:    mov    ah,prstr
        int    dos
    ret
cmskw    endp
;;;;;;;;;; end of support routines for keyword parsing.

; Parse    arbitrary text up to a CR. Enter with BX = pointer to output buffer,
; DX pointing to help text. Produces asciiz string. Return updated pointer in
; BX and output size in AX. Leading spaces are omitted unless comand.cmwhite
; is non-zero (cleared upon exit). It does not need to be followed by the
; usual call to confirm the line. Byte comand.cmblen can be used to specify
; the length of the caller's buffer; cleared to zero by this command to
; imply a length of 127 bytes (default) and if zero at startup use 127 bytes.
cmtext    proc    far
    mov    cmptab,bx        ; save pointer to data buffer
    mov    cmhlp,dx        ; save the help message
    xor    cx,cx            ; init the char count
    cmp    comand.cmblen,0        ; length of user's buffer given?
    jne    cmtxt0            ; ne = yes
    mov    comand.cmblen,127    ; else set 127 byte limit plus null
cmtxt0:    mov    cmsflg,0ffh        ; skip initial spaces
    cmp    comand.cmwhite,0    ; allow leading whitespace?
    je    cmtxt1a            ; e = no
cmtxt1:    mov    cmsflg,0        ; get all spaces
cmtxt1a:call    cmgtch            ; get a char
    jnc    cmtxt5            ; nc = non-terminator, put in buffer
    cmp    ah,' '            ; space?
    je    cmtxt5            ; e = yes, record it
    cmp    ah,escape        ; escape?
    jne    cmtxt2            ; ne = no
    call    esceoc            ; do normal escape end-of-command
    jmp    short cmtxt0        ; try again

cmtxt2:    cmp    ah,'?'            ; asking a question?
    je    cmtxt3            ; e = yes
    cmp    ah,cr            ; formal carriage return?
    je    cmtxt2a            ; e = yes
    inc    cmrptr            ; accept char into buffer
    jmp    short cmtxt5        ;  and record the char
cmtxt2a:mov    bx,cmptab        ; return updated pointer
    xor    ax,ax
    mov    byte ptr[bx],al        ; put terminator into the buffer
    mov    comand.cmwhite,al    ; clear leading whitespace flag
    mov    comand.cmper,al        ; reset to variable recognition
    mov    comand.cmblen,ax    ; set user buffer length to unknown
    mov    comand.cmkeep,al
    mov    ax,cx            ; return count in AX
    call    rprompt            ; restore master prompt level
    clc
    ret
                    ; Help processor
cmtxt3:    inc    cmrptr            ; count the ?
    or    cx,cx            ; is "?" the first char?
    jnz    cmtxt5            ; nz = no, just add to buffer
    dec    cmrptr
    mov    cmsiz,0            ; no keyword for help
    mov    comand.cmwhite,0    ; clear leading whitespace flag
    cmp    cmhlp,0            ; external help given?
    jne    cmtxt3a            ; ne = yes
    mov    cmhlp,offset cmin00    ; confirm with c/r msg
    mov    comand.cmblen,0        ; set user buf length to unknown
cmtxt3a:jmp    cmkyhlp            ; do help process

cmtxt5:    inc    cx            ; increment the count
    mov    bx,cmptab        ; pointer into destination array
    mov    [bx],ah            ; put char into the buffer
    inc    bx
    xor    al,al
    mov    [bx],al            ; insert null terminator
    mov    cmptab,bx
    cmp    cx,comand.cmblen    ; buffer filled?
    ja    cmtxt6            ; a = yes, declare error
    jb    cmtxt5a            ; a = not filled yet
    mov    ah,conout        ; notify user that the buffer is full
    mov    dl,bell
    int    dos
cmtxt5a:jmp    cmtxt1
cmtxt6:    mov    ah,prstr
    mov    dx,offset cmer09
    int    dos
    jmp    prserr            ; declare parse error
cmtext    endp


; Parse arbitrary text up to whitespace.  Enter with DX pointing to output
; buffer and BX pointing to help text. Produces asciiz string. Return updated
; pointer in DX and input size in AH. Skips leading whitespace unless
; comand.cmwhite is non-zero (cleared upon exit). Does a return skip exit.

cmfil0    proc    far
    mov    cmptab,dx        ; save pointer to data buffer
    mov    cmhlp,bx        ; save the help message
    mov    cmsiz,0            ; init the char count
    cmp    comand.cmblen,0        ; length of user's buffer given?
    jne    cmfil0a            ; ne = yes
    mov    comand.cmblen,127    ; else set 127 byte limit plus null
cmfil0a:cmp    comand.cmwhite,0    ; allow leading whitespace?
    jne    cmfil1            ; ne = yes
    mov    cmsflg,0ffh        ; omit leading space
cmfil1:    call    cmgtch            ; get a char
    jc    cmfi1a            ; c = terminator
    jmp    short cmfil5        ; put char into the buffer
cmfi1a:    cmp    ah,escape        ; escape?
    je    cmfi1b            ; e = yes
    jmp    short cmfil2        ; process other terminators
cmfi1b:    call    esceoc            ; do normal escape end-of-command
    jmp    short cmfil0a        ; try again

cmfil2:    cmp    ah,'?'            ; asking a question?
    je    cmfil3            ; e = yes
    xchg    dx,bx            ; re-interchange bx and dx
    xor    ax,ax
    mov    comand.cmwhite,al    ; clear whitespace flag
    mov    comand.cmper,al        ; reset to variable recognition
    mov    comand.cmkeep,al    ; do not keep Take file open
    mov    comand.cmblen,ax    ; set user buffer length to unknown
    mov    bx,cmptab        ; pointer into destination array
    mov    byte ptr[bx],al        ; put null terminator into the buffer
    inc    bx
    mov    ax,cmsiz        ; return count in AX
    mov    dx,cmptab        ; return updated pointer
    xchg    dx,bx            ; re-interchange bx and dx
    call    rprompt            ; restore master prompt level
    clc
    ret                ; return success

cmfil3:    inc    cmrptr            ; count the ?
    cmp    cmsiz,0            ; Is "?" first char?
    jne    cmfil5            ; ne = no, just add to buffer
    dec    cmrptr
    mov    cmsiz,0
    cmp    cmhlp,0            ; external help given?
    jne    cmfil3a            ; ne = yes
    mov    cmhlp,offset cmin00    ; confirm with c/r msg
cmfil3a:jmp    cmkyhlp            ; do help process

cmfil5:    inc    cmsiz            ; increment the count
    mov    bx,cmptab        ; pointer into destination array
    mov    [bx],ah            ; put char into the buffer
    inc    bx
    mov    cmptab,bx
    mov    cx,cmsiz        ; length of command so far
    cmp    cx,comand.cmblen    ; buffer filled?
    ja    cmfil7            ; a = yes, declare error
    jb    cmfil6            ; a = not filled yet
    mov    ah,conout        ; notify user that the buffer is full
    mov    dl,bell
    int    dos
cmfil6:    jmp    cmfil1

cmfil7:    mov    ah,prstr
    mov    dx,offset cmer09
    int    dos
    jmp    prserr            ; declare parse error
cmfil0    endp

; This routine gets a confirm (CR) and displays any extra non-blank text.
; errflag non-zero means suppress "extra text" display in this routine
; because another routine is handling errors.
cmcfrm    proc    far
    mov    comand.cmper,1        ; do not react to \%x substitutions
cmcfr1:    mov    cmsflg,0ffh        ; set space-seen flag (skip spaces)
    call    cmgtch            ; get a char
    push    cmrptr
    pop    temp            ; remember first non-space position
    jc    cmcfr4            ; c = terminator
    dec    temp            ; backup to text char
cmcfr3:    mov    cmsflg,0ffh        ; set space-seen flag (skip spaces)
    call    cmgtch
    jnc    cmcfr3            ; read until terminator
cmcfr4:    cmp    ah,' '
    je    cmcfr3            ; ignore ending on space
    cmp    ah,escape        ; escape?
    jne    cmcfr5            ; ne = no
    call    esceoc            ; do standard end of cmd on escape
    mov    ax,cmrptr
    cmp    ax,temp            ; started text yet?
    je    cmcfr1            ; e = no
    jmp    short cmcfr3        ; try again
cmcfr5: cmp    ah,'?'            ; curious?
        jne    cmcfr6            ; ne = no
    mov    cmhlp,offset cmin00    ; msg Confirm with c/r
    mov    cmsiz,0            ; no keyword
    mov    errflag,0
    jmp    cmkyhlp            ; do help
cmcfr6:    cmp    ah,cr            ; the confirmation char?
    jne    cmcfr3            ; ne = no
    cmp    errflag,0        ; already doing one error?
    jne    cmcfr7            ; ne = yes, skip this one
    mov    cx,cmrptr        ; pointer to terminator
    mov    dx,temp            ; starting place
    sub    cx,dx            ; end minus starting point = length
    jle    cmcfr7            ; le = nothing to display
    push    dx            ; save source pointer
    mov    ah,prstr
    mov    dx,offset cmer07    ; ?Ignoring extras
    int    dos
    pop    dx
    mov    bx,1            ; stdout handle, cx=count, dx=src ptr
    mov    ah,write2        ; allow embedded dollar signs
    int    dos
    mov    ah,prstr
    mov    dx,offset cmer08    ; trailer msg
    int    dos
cmcfr7:    mov    errflag,0
    mov    comand.cmper,0        ; reset to variable recognition
    mov    comand.cmkeep,0
    call    rprompt            ; restore master prompt level
    clc                ; return confirmed
    ret
cmcfrm    endp

;;; Routines to get and edit incoming text.

; Detect '\%x' (x = '0' or above) and substitute the matching Macro string
; in place of the '\%x' phrase in the user's buffer. If comand.cmper != 0
; then treat '\%' as literal characters. If no matching parameter exists
; just remove '\%x'. Ditto for \v(variable). Returns carry clear if nothing
; done, else carry set and new text already placed in user's buffer.
; Includes \v(variable) and \$(Environment variable) and \m(macro name).
; Uses depth-first recursion algorithm. All registers preserved.
subst    proc    near
    cmp    comand.cmper,0        ; recognize '\%','\v(','\$(','\m(' ?
    jne    subst2            ; ne = no, treat as literals
    cmp    ah,'\'            ; is it the first char of the pattern?
    jne    subst1            ; ne = no, try next
    mov    subcnt,1        ; say first is matched
    mov    subtype,0
    jmp    short subst2        ; exit successfully
subst1:    cmp    subcnt,1        ; first char matched already?
    ja    subst3            ; a = first two have been matched
    jb    subst2            ; b = none yet
    inc    subcnt            ; assume a match follows
    mov    subtype,ah        ; remember kind of substitution
    or    subtype,20h        ; convert to lower case
    cmp    ah,'%'            ; second match char, same?
    je    subst2            ; e = yes
    cmp    subtype,'v'        ; \v(...)?
    je    subst2            ; e = yes
    cmp    subtype,'$'        ; \$(..)?
    je    subst2
    cmp    subtype,'m'        ; \m(..)?
    je    subst2
subst1a:mov    subcnt,0        ; mismatch, clear match counter
    mov    subtype,0        ; clear substitution kind
subst2:    clc                ; carry clear = no substitution done
    ret
subst3:    cmp    subtype,'v'        ; doing \v(..)?
    je    subst3a            ; e = yes
    cmp    subtype,'$'        ; doing \$(..)?
    je    subst3a            ; e = yes
    cmp    subtype,'m'        ; doing \m(..)?
    jne    subst3b            ; ne = no, do \%<char>
subst3a:cmp    ah,'('            ; have leading parenthesis?
    jne    subst1a            ; ne = no, mismatch, exit
    jmp    subst10            ; process \v(..), \$(..), \m(..)
subst3b:mov    subcnt,0        ; do \%<char>, clear match counter
    cmp    ah,'0'            ; third char is '0' or above?
    jb    subst1a            ; b = out of range, no match
    push    bx            ; save working regs
    push    cx
    push    es
    sub    cmrptr,3        ; reread commands where backslash was
    call    bufreset        ; reset buffer to this point
    push    cmptab            ; save current keyword parsing parms
    push    cmsptr
    push    cmsiz
    mov    bx,cmrptr        ; points at backslash
    mov    cmsptr,bx        ; direct keyword routine to it
    mov    cmsiz,3            ; three bytes (\%x) of user text
    mov    cmptab,offset mcctab     ; use Macro table for new text
    call    getkw            ; get ptr, bx, to matching keyword
    pop    cmsiz            ; restore borrowed keyword parameters
    pop    cmsptr
    pop    cmptab
    jc    substx            ; c = not found, keep after pops
    cmp    taklev,maxtak        ; room in take level?
    jae    subst6            ; ae = no
    mov    cx,[bx]            ; length of found word
    add    cx,2            ; plus count field
    add    bx,cx            ; point to 16 bit value (string ptr)
    mov    es,[bx]            ; point to string structure segment
    xor    bx,bx
    mov    cx,es:[bx]        ; length of string
    add    takadr,size takinfo    ; pointer to new Take structure
    inc    taklev
    mov    bx,takadr        ; pointer to new Take structure
    mov    [bx].takbuf,es        ; segment of Take buffer
    mov    [bx].takcnt,cx        ; number of unread bytes
    mov    [bx].taktyp,0fdh    ; flag as an internal macro
    mov    [bx].takptr,2        ; init pointer to definition itself
substx:    pop    es
    pop    cx
    pop    bx
    stc                ; set carry to say have stored chars
    ret

subst6:    mov    ah,prstr
    mov    dx,offset stkmsg    ; out of work space msg
    int    dos
    jmp    prserr            ; and declare parse error

                    ; \m(..), \v(..), \$(..)
subst10:push    bx            ; save working regs
    push    cx
    push    es
    push    cmptab            ; save current keyword parsing parms
    push    cmsptr
    push    cmsiz
    push    cmhlp
    push    dx
    mov    subcnt,0        ; clear match counter
    mov    cmhlp,0
    mov    ax,cmrptr
    mov    valtmp,ax        ; remember current read pointer
    mov    cmsptr,ax        ; start of word
    mov    cmptab,offset valtab    ; table of keywords for \v(..)
    cmp    subtype,'v'        ; \v(..)?
    je    subst10a        ; e = yes
    mov    cmptab,offset envtab    ; Environment variable table \$(..)
    cmp    subtype,'$'        ; \$(..)?
    je    subst10a        ; e = yes
    mov    cmptab,offset mcctab    ; main Macro table for \m(..)
subst10a:mov    cmsflg,0        ; see leading spaces/tabs
    mov    cmsiz,0            ; word size
subst11:call    cmgtch            ; read a character into ah
    jnc    subst13            ; nc = non-terminator
    cmp    ah,'?'            ; need help?
    jne    subst11a        ; ne = no
    jmp    cmkyhlp            ; do help and exit
subst11a:cmp    ah,escape        ; escape?
    jne    subst12            ; ne = no
    mov    bx,cmsptr        ; where word started
    mov    cmrptr,bx        ; omit word to date
    mov    cmwptr,bx
    call    cmkyesc            ; process escape
    mov    dx,1            ; signal valtoa to add trailing space
    jnc    subst14            ; nc = success (found the keyword)
                    ;
subst12:mov    bx,cmsptr        ; where word started
    sub    bx,3            ; back over "\v(" pr "\$(" part
    mov    cmrptr,bx        ; omit "\v(..." or "\$(..." to date
    mov    cmwptr,bx        ;  and "\m(..." too
    jmp    repars            ; reparse command without \v(...
                    ;
subst13:inc    cmsiz            ; count user chars
    cmp    ah,')'            ; end bracket?
    jne    subst11            ; ne = no, keep looking
    dec    cmsiz            ; omit user's ')' from tests
    cmp    subtype,'$'        ; \$(..)?
    je    subst13a        ; e = yes, no keyword in table
    call    getkw            ; \m(..) and \v(..) test for keyword
    jc    subst12            ; c = failure
    jmp    short subst13b        ; success

subst13a:call    envvar            ; search Environment for the word
    jc    subst12            ; c = failure
    mov    bx,offset envtab+1    ; Environment data structure

subst13b:mov    ax,valtmp        ; where word started
    mov    cmrptr,ax
    sub    ax,3            ; backup to "\v(" or "\$("
    mov    cmrptr,ax        ; write output where backslash was
    mov    cmwptr,ax
    mov    cx,[bx]            ; bx = structure pointer, cx=keyw len
    add    cx,2            ; skip count byte
    add    bx,cx            ; point at 16 bit value field
    mov    bx,[bx]            ; get value to bx for valtoa
    xor    dx,dx            ; signal valtoa to not add trailing sp
subst14:
    cmp    taklev,maxtak        ; room in take level?
    jb    subst15            ; b = yes
    mov    dx,offset stkmsg    ; out of work space msg
    mov    ah,prstr        ; display error message
    int    dos
    jmp    short subst17
subst15:push    di
    call    valtoa            ; make text be an internal macro
    jc    subst16            ; c = failed
    add    takadr,size takinfo    ; pointer to new Take structure
    inc    taklev            ; next Take level
    push    bx
    mov    bx,takadr        ; address of take structure
    mov    ax,ds
    mov    [bx].takbuf,ax        ; segment of Take buffer
    mov    [bx].takptr,offset valbuf+2 ; offset of beginning of def text
    mov    [bx].takcnt,di        ; # of chars in buffer
    mov    [bx].taktyp,0fdh    ; flag as an internal macro
    pop    bx
subst16:pop    di
subst17:pop    dx
    pop    cmhlp
    pop    cmsiz            ; restore borrowed keyword parameters
    pop    cmsptr
    pop    cmptab
    jmp    repars            ; reparse cmd line with new material
subst    endp

; Make an internal macro defined as the text for one of the value variables.
; Use incoming DX as trailing space suppression flag, if null.
valtoa    proc    near
    push    dx            ; save trailing space flag
    mov    di,offset valbuf+2    ; start text here
    mov    word ptr [di],0        ; fill buffer with sweet nothings
                    ; BX has index of variable
    cmp    bx,0            ; Environment?
    jne    valtoa1            ; ne = no
    mov    cx,envlen        ; string length
    jcxz    valtoa0            ; z = empty
    push    es
    push    ds
    mov    ax,ds
    mov    es,ax            ; destination is es:di
    lds    si,envadr        ; ds:si is source from Environment
    cld
    rep    movsb            ; copy string
    pop    ds            ; recover ds
    pop    es
valtoa0:jmp    valtoa30

valtoa1:cmp    bx,1            ; ARGC?
    jne    valtoa2            ; ne = no
    call    wrtargc            ; write argc
    jmp    valtoa30
valtoa2:cmp    bx,2            ; COUNT?
    jne    valtoa3            ; ne = no
    call    wrtcnt            ; write it
    jmp    valtoa30
valtoa3:cmp    bx,3            ; DATE?
    jne    valtoa4
    call    wrtdate
    jmp    valtoa30
valtoa4:cmp    bx,4            ; ERRORLEVEL?
    jne    valtoa5            ; ne = no
    call    wrterr
    jmp    valtoa30
valtoa5:cmp    bx,5            ; DIR?
    jne    valtoa6
    call    wrtdir
    jmp    valtoa30
valtoa6:cmp    bx,6            ; TIME?
    jne    valtoa7
    call    wrttime
    jmp    valtoa30
valtoa7:cmp    bx,7            ; VERSION?
    jne    valtoa8            ; ne = no
    mov    ax,version        ; get version such as 300
    call    fdec2di            ; convert binary to asciiz
    mov    word ptr [di],0020h    ; space, null
    inc    di
    jmp    valtoa30
valtoa8:cmp    bx,8            ; PLATFORM?
    jne    valtoa9            ; ne = no
    call    wrtplat            ; get machine name, e.g. "IBM-PC"
    jmp    valtoa30
valtoa9:cmp    bx,9            ; SYSTEM?
    jne    valtoa10        ; ne = no
    call    wrtsystem        ; get "MS-DOS" string
    jmp    valtoa30
valtoa10:cmp    bx,10            ; KEYBOARD?
    jne    valtoa11        ; ne = no
    call    wrtkbd            ; 88 or 101 value
    jmp    valtoa30
valtoa11:cmp    bx,11            ; SPEED?
    jne    valtoa12        ; ne = no
    push    di
    call    fgetbaud        ; read baud rate from hardware
    pop    di
    mov    bx,portval
    mov    ax,[bx].baud
    cmp    al,byte ptr bdtab    ; index versus number of table entries
    jb    valtoa11a        ; b = index is in the table
    mov    si,offset cmunk-2    ; unrecognized value, say "unknown"
    mov    bx,7            ; length of string
    jmp    short valtoa11c
valtoa11a:mov    si,offset bdtab        ; ascii rate table
    mov    cl,[si]            ; number of entries
    inc    si            ; point to an entry
valtoa11b:
    mov    bx,[si]            ; length of text string
    cmp    ax,[si+bx+2]        ; our index vs table entry index
    je    valtoa11c        ; e = match
    add    si,bx            ; skip text
    add    si,4            ; skip count and index word
    loop    valtoa11b        ; look again
    mov    si,offset cmunk-2    ; unrecognized value, say "unknown"
    mov    bx,7            ; length of string
valtoa11c:mov    cx,bx            ; length of string
    add    si,2            ; point at string
    rep    movsb            ; copy string
    jmp    valtoa30

valtoa12:cmp    bx,12            ; PROGRAM?
    jne    valtoa13        ; ne = no
    call    wrtprog            ; get "MS-DOS_KERMIT" string
    jmp    valtoa30
valtoa13:cmp    bx,13            ; STATUS?
    jne    valtoa14        ; ne = no
    call    wrtstat            ; compose status string
    jmp    valtoa30
valtoa14:cmp    bx,14            ; NDATE?
    jne    valtoa15        ; ne = no
    call    wrtndate
    jmp    valtoa30
valtoa15:cmp    bx,15            ; LINE, PORT?
    jne    valtoa16        ; ne = no
    call    wrtport
    jmp    valtoa30
valtoa16:cmp    bx,16            ; TERMINAL?
    jne    valtoa17        ; ne = no
    call    wrtterm
    jmp    valtoa30
valtoa17:cmp    bx,17            ; SESSION (internal Telnet)?
    jne    valtoa18        ; ne = no
    mov    ax,sescur        ; get internal Telnet session ident
    inc    ax            ; count from 1 for users (0 == none)
    call    fdec2di            ; convert binary to asciiz
    mov    word ptr [di],0020h    ; space, null
    inc    di
    jmp    valtoa30
valtoa18:cmp    bx,18            ; \v(ntime) (seconds in day)?
    jne    valtoa19        ; ne = no
    mov    ah,gettim        ; get DOS time of day
    int    dos            ; ch=hh, cl=mm, dh=ss, dl=0.01 sec
    mov    bx,60
    mov    al,ch            ; hours
    mul    bl            ; to minutes
    xor    ch,ch
    add    ax,cx            ; plus minutes
    mov    cl,dh            ; preserve seconds
    mul    bx            ; need carry out to DX
    add    ax,cx            ; add seconds
    adc    dx,0
    mov    cx,10            ; down to 16 bit size
    div    cx
    call    fdec2di            ; convert binary to asciiz
    xchg    ax,dx
    call    fdec2di            ; convert binary to asciiz
    mov    word ptr [di],0020h    ; space, null
    inc    di
    jmp    short valtoa30
valtoa19:cmp    bx,19            ; \v(dosversion)?
    jne    valtoa29        ; ne = no
    mov    ax,dosnum        ; DOS verson, major high, minor low
    push    ax
    xchg    ah,al
    xor    ah,ah
    call    fdec2di            ; write major
    pop    ax
    xor    ah,ah
    cmp    al,10            ; less than 10?
    ja    valtoa19a        ; a = no
    mov    byte ptr [di],'0'    ; use two digits for minor
    inc    di
valtoa19a:call    fdec2di            ; write minor
    mov    word ptr [di],0020h    ; space, null
    inc    di
    jmp    short valtoa30
valtoa29:pop    dx            ; assume an internal Macro
    add    takadr,size takinfo    ; pointer to new Take structure
    inc    taklev            ; next Take level
    push    bx
    mov    ax,bx            ; save seg of string here
    mov    bx,takadr        ; address of take structure
    mov    [bx].takbuf,ax        ; segment of Take buffer
    mov    [bx].takptr,2         ; offset of beginning of def text
    push    es
    mov    es,ax            ; segment of string definition
    mov    di,es:[0]        ; get length of string text (count)
    pop    es
    mov    [bx].takcnt,di        ; # of chars in buffer
    mov    [bx].taktyp,0fdh    ; flag as an internal macro
    pop    bx
    jmp    short valtoax        ; exit early with CARRY SET(!)

valtoa30:pop    dx            ; trailing space flag
    or    dx,dx            ; leave the spaces?
    jnz    valtoa31        ; nz = yes
    cmp    word ptr [di-1],0020h    ; trailing space?
    jne    valtoa31        ; ne = no
    dec    di            ; remove space
valtoa31:sub    di,offset valbuf+2    ; di = length of the buffer contents
    clc
    ret
valtoax:stc
    ret
valtoa    endp

; Far callable version
fvaltoa    proc    far
    call    valtoa
    ret
fvaltoa    endp
; Set envadr to the string following the <variable=> keyword in the
; Environment and set envlen to its length after removing leading and
; trailing whitespace.
; <variable> starts at ds:<valtmp>, of length cmsiz-1, and can be mixed case.
; Return carry set if can't find the <variable=> line in the Environment.
envvar    proc    near
    push    es
    mov    bx,valtmp        ; start of variable name
    mov    cx,cmsiz        ; length of variable name, w/o ')'
    or    cx,cx            ; empty?
    jle    envvar3            ; le = nothing to look for, fail
    push    bx
    push    cx
envvar1:mov    al,byte ptr [bx]    ; scan variable name in our buffer
    cmp    al,'a'            ; lower case
    jb    envvar2            ; b = no
    cmp    al,'z'            ; still in lower case range?
    ja    envvar2            ; a = no
    and    al,not 20h        ; convert to DOS's upper case
    mov    byte ptr [bx],al    ; replace char
envvar2:inc    bx
    loop    envvar1
    pop    cx
    pop    bx            ; find "<variable>=" in Environment
    call    fgetenv            ; dx = offset in Environment of "="
    jnc    envvar4            ; nc = success
envvar3:pop    es            ; no such variable
    stc                ; c = failure
    ret
; dx has offset in Environment of char "="
; ds:valtmp is start of variable name, cmsiz is length + 1 of the name.
; Return seg:offset and length variables so we can copy from there in valtoa
envvar4:push    di
    push    si
    xor    ax,ax
    mov    word ptr envadr,ax    ; offset in env of variable's string
    mov    word ptr envadr+2,ax    ; seg of same
    mov    envlen,ax        ; length of string
    mov    es,psp            ; our Prog Seg Prefix segment
    mov    ax,es:word ptr[env]    ; pick up Environment address
    mov    es,ax            ; set es: to Environment segment
    mov    di,dx            ; line scan pointer
    cmp    byte ptr es:[di],'='    ; did we stop on this?
    jne    envvar5            ; ne = no
    inc    di            ; skip the "=" char
envvar5:mov    al,es:[di]        ; scan over leading white space
    inc    di
    or    al,al            ; end of line terminator?
    jz    envvarf            ; z = yes, fail
    cmp    al,TAB            ; HT?
    jne    envvar6            ; ne = no
    mov    al,' '            ; HT becomes a space
envvar6:cmp    al,' '            ; white space?
    je    envvar5            ; scan off white space
    dec    di            ; backup to non-white char
    mov    word ptr envadr,di    ; offset of string in Environment
    mov    word ptr envadr+2,es    ; seg of string in Environment
    mov    si,di            ; remember starting offset here
                    ; remove trailing spaces from string
    xor    al,al            ; a null
    mov    cx,127            ; max length to search
    cld
    repne    scasb            ; skip over non-nulls
    dec    di            ; backup to null
    dec    di            ; backup to last string char
    mov    cx,di            ; ending offset
    inc    cx            ; count the char
    sub    cx,si            ; minus starting offset yields length
    jcxz    envvar9            ; z = empty string
envvar7:mov    al,es:[di]        ; last char
    dec    di            ; backup one char
    cmp    al,' '            ; space?
    je    envvar8            ; e = yes
    cmp    al,TAB            ; HT?
    jne    envvar9            ; ne = no, end of white space
envvar8:loop    envvar7            ; keep looking
envvar9:mov    envlen,cx        ; store the length
    clc                ; say success
    jmp    short envvarx
envvarf:stc                ; say failure
envvarx:pop    si
    pop    di
    pop    es
    ret
envvar    endp

; Read chars from Take file, keyboard, or redirected stdin. Edit and remove
; BS & DEL, Tab becomes space, act on Control-C, pass Control-U and Control-W.
; Do echoing unless comand.cmquiet is non-zero. Do semicolon comments in Take
; and indirect stdin files (\; means literal semicolon). Return char in AL.
CMGETC    proc    near            ; Basic raw character reader
cmget01:cmp    prevch,0        ; left over char yet to be exported?
    je    cmget02            ; e = no
    mov    al,prevch        ; get old char
    mov    prevch,0        ; clear storage
    jmp    cmget6            ; analyze it
cmget02:cmp    taklev,0        ; in a Take file?
    jne    cmget1            ; ne = yes, do Take reader section
    call    fisdev            ; is stdin a device or a file?
    jnc    cmget20            ; nc = file (redirection of stdin)
    jmp    cmget10            ; c = device, do separately

cmget20:call    fiseof            ; see if file is empty
    jc    cmget21            ; c = EOF on disk file
    mov    ah,coninq        ; read the char from file, not device
    int    dos
    cmp    al,cr            ; is it a cr?
    je    cmget01            ; yes, ignore and read next char
    cmp    al,ctlz            ; Control-Z?
    je    cmget21            ; e = yes, same as EOF here
    cmp    al,lf            ; LF's end lines from disk files
    jne    cmget8            ; ne = not LF, pass along as is
    mov    al,cr            ; make LF a CR for this parser
    call    fiseof            ; see if this is the last char in file
    jnc    cmget8            ; nc = not EOF, process new CR
cmget21:mov    flags.extflg,1        ; EOF on disk file, set exit flag
    jmp    short cmget6        ; do echoing and return

cmget1:    push    bx            ; read from Take file
    mov    bx,takadr        ; offset of this Take structure
    cmp    [bx].takcnt,0        ; bytes remaining in Take buffer
    jne    cmget4            ; ne = not empty
    cmp    [bx].taktyp,0feh    ; type of Take (file?)
    jne    cmget3            ; ne = no (macro)
    call    ftakrd            ; read another buffer
    cmp    [bx].takcnt,0        ; anything in the buffer?
    jne    cmget4            ; ne = yes
cmget3:    pop    bx            ; clear stack
    jmp    short cmget5        ; close take file

cmget4:    push    si
    push    es
    mov    es,[bx].takbuf        ; segment of Take buffer
    mov    si,[bx].takptr        ; current offset in Take buffer
    mov    al,es:[si]        ; read a char from Take buffer
    inc    si
    mov    [bx].takptr,si        ; move buffer pointer
    dec    [bx].takcnt        ; decrease number of bytes remaining
    pop    es
    pop    si
    pop    bx
    cmp    al,ctlz            ; Control-Z?
    jne    cmget6            ; ne = no
cmget5:    push    bx
    mov    bx,takadr        ; offset of this Take structure
    mov    ah,[bx].taktyp        ; save kind of Take/macro
    pop    bx
    cmp    ah,0fdh            ; internal macro?
    je    cmget5b            ; e = yes, close but no auto-CR
    cmp    comand.cmkeep,0        ; keep Take/macro open after eof?
    jne    cmget5a            ; ne = yes
cmget5b:push    ax
    call    ftakclos        ; close take file
    pop    ax
    cmp    ah,0fdh            ; internal macro?
    jne    cmget5a            ; ne = no, file or regular macro
    jmp    cmgetc            ; internal macros have no auto CR
cmget5a:mov    al,cr            ; report cr as last char
    mov    noparse,0        ; and say end of comment
                    ; start common code
cmget6:
    cmp    al,lf            ; line feed?
    jne    cmget8            ; ne = no
    jmp    cmget01            ; yes, ignore and read another char
                    ; handle comments (echo but not parse)
cmget8:    cmp    noparse,0        ; parsing?
    jne    cmget9            ; ne = yes, do echo and no parse
    cmp    prevch,0        ; have previous char to analyze?
    jne    cmget8c            ; ne = yes
    cmp    taklev,0        ; in a Take file or Macro?
    je    cmget8e            ; e = no, use ";" as a literal
    push    bx            ; treat ";" as literal in int macros
    mov    bx,takadr        ; offset of this Take structure
    cmp    [bx].taktyp,0fdh    ; internal macro?
    pop    bx
    je    cmget8e            ; e = yes, semicolons are literals
    cmp    al,'\'            ; start of '\;'?
    jne    cmget8a            ; ne = no
    mov    prevch,al        ; yes, maybe. save '\' til later
    jmp    cmget02            ; read next char
cmget8a:cmp    al,';'            ; possible start of comment?
    jne    cmget8e            ; no, export al
    mov    al,' '            ; replace ';' with space for comment
    jmp    short cmget9        ; go start a comment

cmget8c:cmp    al,';'            ; end of '\;'?
    je    cmget8d            ; e = yes, omit leading backslash
    xchg    prevch,al        ; no, save new, recover old '\'
    jmp    short cmget8e        ; export '\'
cmget8d:mov    prevch,0        ; clear old '\'
cmget8e:jmp    short cmget12        ; do parsing

                    ; echo comment
cmget9:    cmp    flags.takflg,0        ; echoing take files?
    je    cmget9a            ; e = no
    push    ax
    push    dx
    mov    ah,conout        ; echo current char
    mov    dl,al
    int    dos
    pop    dx
    pop    ax
cmget9a:mov    noparse,0        ; cr ends comment
    cmp    al,cr            ; end of comment?
    je    cmget13            ; e = yes, export cr
    mov    noparse,1        ; still in comment
    jmp    cmget01            ; read more chars

                    ; read from tty device
cmget10:mov    ah,coninq        ; Get a char from device, not file
    int    dos            ;  with no echoing
    or    al,al
    jnz    cmget12            ; ignore null bytes of special keys
    int    dos            ; read and discard scan code byte
    jmp    short cmget10        ; try again

cmget12:cmp    al,'C'and 1Fh        ; Control-C?
    je    cmget14            ; e = yes
    cmp    al,TAB            ; tab is replaced by space
    jne    cmget13            ; ne = not tab
    mov    al,' '
    ret
cmget13:cmp    al,LF            ; LF becomes CR interactively
    jne    cmget13a
    mov    al,CR
cmget13a:ret                ; normal exit, char is in AL

cmget14:mov    ah,prstr        ; Control-C handler
    push    dx
    mov    dx,offset ctcmsg    ; show Control-C
    int    dos
    pop    dx
    mov    prevch,0
    mov    flags.cxzflg,'C'    ; tell others the news
    jmp    dword ptr pcmexit    ; fail immediately via longjmp
cmgetc    endp

; Read chars from user (cmgetc). Detect terminators. Reads from buffer
; cmbuf. Set read pointer cmrptr to next free buffer byte if
; char is not a terminator: chars CR, LF, FF, '?' (returns carry set for
; terminators). Do ^U, ^W editing, convert FF to CR plus clear screen.
; Edit "-<cr>" as line continuation, "\-<cr>" as "-<end of line>".
; Return char in AH.
CMINBF    proc    near            ; Buffer reader, final editor
    cmp    cmwptr,offset cmdbuf+size cmdbuf-3 ; max buffer size - 3
    jb    cminb1            ; b = not full for writing
    mov    ah,conout        ; almost full, notify user
    push    dx
    mov    dl,bell
    int    dos
    pop    dx
    cmp    cmrptr,offset cmdbuf+size cmdbuf ; reading beyond buffer?
    jb    cminb1            ; b = no
    mov    ah,prstr
    mov    dx,offset cmer09    ; command too long
    int    dos
    jmp    prserr            ; overflow = parse error

cminb1:    push    bx
    mov    bx,cmrptr        ; read pointer
    mov    ah,[bx]            ; get current command char while here
    cmp    bx,cmwptr        ; do we need to read more?
    pop    bx            ; no if cmrptr < cmwptr
    jb    cminb2            ; b: cmrptr < cmwptr (have extra here)
    call    cmgetc            ; no readahead, read another into al
    mov    ah,al            ; keep char in 'ah'
    push    bx
    mov    bx,cmwptr        ; get the pointer into the buffer
    mov    [bx],ah            ; put it in the buffer
    inc    bx
    mov    cmwptr,bx        ; inc write pointer
    pop    bx
    jmp    short cminb1        ; call cmgetc until cmwptr >= cmrptr
                    ; Char to be delivered is in ah
cminb2:    cmp    ah,'W' and 1fh        ; is it a ^W?
    jne    cminb3
    call    cntrlw            ; kill the previous word
    jnc    cminbf            ; nc = no change, get another char
    jmp    repars            ; need a new command scan (cleans stk)

cminb3:    cmp    ah,'U' and 1fh        ; is it a ^U?
    jne    cminb3a            ; ne = no
    mov    cmwptr,offset cmdbuf    ; reset buffer write pointer
    jmp    repars            ; go start over (cleans stack)
                    ; BS and DEL
cminb3a:cmp    ah,DEL            ; delete code?
    je    cminb3b            ; e = yes
    cmp    ah,BS            ; Backspace (a delete operator)?
    jne    cminb4            ; ne = no
cminb3b:call    bufdel            ; delete char from buffer
    jc    cminb3c            ; c = did erasure
    jmp    cminbf            ; no erasure, ignore BS, get more
cminb3c:jmp    repars            ; could have deleted previous token

cminb4:    push    bx            ; look for hyphen or \hyphen
    cmp    ah,cr            ; check for hyphen line continuation
    jne    cminb4b            ; ne = not end of line
    mov    bx,cmwptr        ; get the pointer into the buffer
    cmp    bx,offset cmdbuf-2    ; do we have a previous char?
    jb    cminb4b            ; b = no
    cmp    byte ptr[bx-2],'-'    ; previous char was a hyphen?
    jne    cminb4b            ; ne = no
    pop    bx
    call    bufdel            ; delete the hyphen
    jmp    repars
cminb4b:pop    bx
                    ; Echoing done here
    cmp    comand.cmquiet,0    ; quiet mode?
    jne    cminb5            ; yes, skip echoing
    cmp    taklev,0        ; in a take file?
    je    cminb4a            ; e = no
    cmp    flags.takflg,0        ; echo take file?
    je    cminb5            ; e = no
cminb4a:push    ax            ; save the char
    cmp    ah,' '            ; printable?
    jae    cminb4c            ; yes, no translation needed
    cmp    ah,cr            ; this is printable
    je    cminb4c
    cmp    ah,lf
    je    cminb4c
    cmp    ah,escape        ; escape?
    je    cminb4d            ; do not echo this character
    push    ax            ; show controls as caret char
    push    dx
    mov    dl,5eh            ; caret
    mov    ah,conout
    int    dos
    pop    dx
    pop    ax
    add    ah,'A'-1        ; make control code printable
cminb4c:push    dx
    mov    dl,ah
    mov    ah,conout
    int    dos            ; echo it ourselves
    pop    dx
cminb4d:pop    ax            ; and return char in ah

cminb5:    cmp    ah,cr            ; carriage return?
    je    cminb6
    cmp    ah,lf            ; line feed?
    je    cminb6
    cmp    ah,ff            ; formfeed?
    jne    cminb7            ; none of the above, report bare char
    call    fcmblnk            ; FF: clear the screen and
    push    bx
    push    cx
    push    dx
    call    flocate            ; Home the cursor
    mov    bx,cmwptr        ; make the FF parse like a cr
    mov    byte ptr [bx-1],cr    ; pretend a carriage return were typed
    pop    dx
    pop    cx
    pop    bx
cminb6: cmp    cmwptr,offset cmdbuf    ; parsed any chars yet?
    jne    cminb7            ; ne = yes
    cmp    comand.cmcr,0        ; bare cr's allowed?
    jne    cminb7            ; ne = yes
    jmp    prserr            ; If not, just start over
cminb7:    clc
    ret
cminbf    endp

; Read chars from cminbf. Cmrptr points to next char to be read.
; Compresses repeated spaces if cmsflg is non-zero. Exit with cmrptr pointing
; at a terminator or otherwise at next free slot.
; Non-space then space acts as a terminator but cmrptr is incremented.
; Substitution variables, '\%x', are detected and expanded. Return char in AH.

CMGTCH    proc    near            ; return char in AH, from rescan buf
    call    cminbf            ; get char from buffer or user
    push    bx
    mov    bx,cmrptr        ; get read pointer into the buffer
    mov    ah,[bx]            ; read the next char
    inc    bx
    mov    cmrptr,bx        ; where to read next time
    pop    bx
    call    subst            ; examine for text substitution
    jnc    cmgtc1            ; nc = no substitutions done
    jmp    repars            ; reparse line with new material

cmgtc1:    cmp    ah,' '            ; space?
    jne    cmgtc3            ; ne = no
    cmp    bracecnt,0        ; are we within braces?
    jne    cmgtc3            ; ne = yes, treat space as literal
    cmp    cmsflg,0        ; space flag, was last char a space?
    jne    cmgtch            ; ne = yes, get another char
    mov    cmsflg,0FFH        ; Set the space(s)-seen flag
    mov    ah,' '            ; character for caller
    stc                ; set carry for terminator
    ret                ; return space as a terminator
cmgtc3: mov    cmsflg,0        ; clear the space-seen flag
    cmp    ah,braceop        ; opening brace?
    jne    cmgtc3b            ; ne = no
    inc    bracecnt        ; count it
    jmp    short cmgtc3c
cmgtc3b:cmp    ah,bracecl        ; closing brace?
    jne    cmgtc3c            ; ne = no
    sub    bracecnt,1        ; count down and get a sign bit
    jns    cmgtc3c            ; ns = no underflow
    mov    bracecnt,0        ; catch underflows
cmgtc3c:cmp    ah,escape        ; terminators remain in buffer but
    je    cmgtc4            ;  are ready to be overwritten
    cmp    ah,'?'            ; is the user curious?
    jne    cmgtc3a            ; ne = no
    cmp    taklev,0        ; in a Take file?
    jne    cmgtc3d            ; ne = yes, make query ordinary char
    je    cmgtc4
cmgtc3a:cmp    ah,cr
    je    cmgtc4
    cmp    ah,lf
    je    cmgtc4
    cmp    ah,ff
    je    cmgtc4
cmgtc3d:clc                ; carry clear for non-terminator
    ret
cmgtc4: dec    cmrptr            ; point at terminating char
    stc                ; set carry to say it is a terminator
    ret
cmgtch    endp

; Reset comand.cmdbuf write pointer (cmwptr) to where the read pointer
; (cmrptr) is now. Discards material not yet read.
bufreset proc    near
    push    cmrptr            ; where next visible char is read
    push    ax            ; count removed curly braces
    push    si
    mov    si,cmrptr        ; where to look
    mov    cx,cmwptr        ; last place being removed
    sub    cx,si            ; length to examine
    cld
bufres1:lodsb
    cmp    al,braceop        ; opening brace, counted already?
    jne    bufres2            ; ne = no
    dec    bracecnt        ; uncount it
    jmp    short bufres3
bufres2:cmp    al,bracecl        ; closing brace, counted already?
    jne    bufres3            ; jne = no
    inc    bracecnt        ; uncount it
bufres3:loop    bufres1
    cmp    bracecnt,0        ; negative?
    jge    bufres4            ; ge = no
    mov    bracecnt,0
bufres4:pop    si
    pop    ax
    pop    cmwptr            ; where new char goes in buffer
    ret
bufreset endp

; Delete character from screen and adjust buffer. Returns carry clear if
; no erasure, carry set otherwise.
bufdel    proc    near
    push    ax
    push    si
    mov    si,cmrptr
    mov    al,[si]
    cmp    al,braceop        ; opening brace, counted already?
    jne    bufdel1            ; ne = no
    dec    bracecnt        ; uncount it
    jmp    short bufdel2
bufdel1:cmp    al,bracecl        ; closing brace?
    jne    bufdel2            ; ne = no
    inc    bracecnt        ; uncount it
bufdel2:cmp    bracecnt,0        ; negative?
    jge    bufdel3            ; ge = no
    mov    bracecnt,0
bufdel3:pop    si
    pop    ax
    dec    cmrptr            ; remove previous char from buffer
    cmp    cmrptr,offset cmdbuf    ; back too far?
    jae    bufde2            ; ae = no, material can be erased
    mov    cmrptr,offset cmdbuf    ; set to start of buffer
    call    bufreset        ; reset buffer
    mov    bracecnt,0        ; ensure this is now cleared
    clc                ; say no erasure
    ret
bufde2:    call    bufreset        ; reset buffer
    stc                ; say did erasure
    ret
bufdel    endp

; Come here is user types ^W when during input. Remove word from buffer.
cntrlw    proc    near
    push    ax
    push    cx
    push    dx
    call    bufreset        ; truncate buffer at cmrptr
    mov    cx,cmrptr        ; read pointer
    sub    cx,offset cmdbuf    ; compute chars in buffer
    clc                ; say have not yet modified line
    jcxz    ctlw2            ; z = nothing to do, exit no-carry
    push    es
    std                ; scan backward
    mov    ax,ds
    mov    es,ax            ; point to the data are
    mov    di,cmwptr        ; looking from here
    dec    di
    mov    al,' '
    repe    scasb            ; look for non-space
    je    ctlw1            ; all spaces, nothing to do
    inc    di            ; move back to non-space
    inc    cx
    repne    scasb            ; look for a space
    jne    ctlw1            ; no space, leave ptrs alone
    inc    di
    inc    cx            ; skip back over space
ctlw1:    inc    di
    pop    es
    cld                ; reset    direction flag
    mov    cmwptr,di        ; update pointer
    stc                ; set carry to say modified line
ctlw2:    pop    dx
    pop    cx
    pop    ax
    ret
cntrlw    endp

; Jump to REPARS to do a rescan of the existing buffer.
; Jump to PRSERR on a parsing error (quits command, clears old read material)

PRSERR    PROC NEAR
    mov    cmwptr,offset cmdbuf    ; initialize write pointer
    mov    ah,prstr
    mov    dx,offset crlf        ; leave old line, start a new one
    int    dos
    call    rprompt            ; restore master prompt level
                    ; reparse current line
REPARS:    mov    cmrptr,offset cmdbuf    ; reinit read pointer
    mov    comand.cmper,0        ; reset to variable recognition
    mov    cmsflg,0ffh        ; strip leading spaces
    mov    subcnt,0        ; clear substitution state variables
    mov    subtype,0
    mov    bracecnt,0
    cmp    taklev,0        ; in Take cmd?
    je    prser2            ; e = no
    cmp    flags.takflg,0        ; echo contents of Take file?
    je    prser3            ; e = no
prser2:    call    fctlu            ; clear display's line, reuse it
    mov    dx,comand.cmprmp    ; display the asciiz prompt
    call    fprtasz
prser3:    mov    bx,0ffffh        ; returned keyword value
    mov    sp,comand.cmostp    ; set new sp to old one
    jmp    dword ptr comand.cmrprs    ; jump to just before the prompt call
PRSERR    ENDP

; Restore prompt material to that of the master prompt. This removes settings
; of local PROMPT calls so we can reprompt at the main Kermit level.
RPROMPT    proc    near
    push    ax
    mov    ax,mcmprmp        ; address of prompt string
    or    ax,ax            ; any address given yet?
    jz    rprompt1        ; z = none, not inited yet
    mov    comand.cmprmp,ax    ; set current address ptr
    mov    ax,word ptr mcmrprs    ; offset of reparse address
    mov    word ptr comand.cmrprs,ax
    mov    ax,word ptr mcmrprs+2    ; segment of reparse address
    mov    word ptr comand.cmrprs+2,ax
    mov    ax,mcmostp        ; stack ptr at reparse time
    mov    comand.cmostp,ax
rprompt1:pop    ax
    ret
RPROMPT    endp



; write \v(ARGC) contents to ds:di
wrtargc    proc    near
    xor    ax,ax
    cmp    taklev,0        ; in a Take/Macro?
    je    wrtarg1            ; e = no
    mov    bx,takadr        ; current Take structure
    mov    ax,[bx].takargc        ; get ARGC
wrtarg1:call    fdec2di            ; write as ascii
    mov    word ptr [di],0020h    ; space and null terminator
    inc    di
    ret
wrtargc    endp

; write \v(COUNT) text to ds:di
wrtcnt    proc    near
    xor    ax,ax
    cmp    taklev,0        ; in a Take/Macro?
    je    wrtcnt1            ; e = no
    mov    bx,takadr        ; current Take structure
    mov    ax,[bx].takctr        ; get COUNT
wrtcnt1:call    fdec2di            ; write as ascii
    mov    word ptr [di],0020h    ; space and null terminator
    inc    di
    ret
wrtcnt    endp

; write \v(DATE) text to ds:di
wrtdate    proc    near
    push    cx
    push    dx
    mov    ah,getdate        ; DOS date (cx= yyyy, dh= mm, dl= dd)
    int    dos
    xor    ah,ah
    cmp    tdfmt,0            ; USA standard mm/dd/yyyy?
    jne    wrtdat1            ; ne = no
    xor    ah,ah
    mov    al,dh            ; month
    call    wrtdat5            ; output
    mov    byte ptr [di],'/'    ; separate
    inc    di
    xor    ah,ah
    mov    al,dl            ; day
    call    wrtdat5
    mov    byte ptr [di],'/'
    inc    di
    mov    ax,cx
    jmp    short wrtdat3

wrtdat1:cmp    tdfmt,1            ; European standard dd/mm/yyyy?
    jne    wrtdat2            ; ne = no
    xor    ah,ah
    mov    al,dl            ; day
    call    wrtdat5
    mov    byte ptr [di],'/'
    inc    di
    xor    ah,ah
    mov    al,dh            ; month
    call    wrtdat5
    mov    byte ptr [di],'/'
    inc    di
    mov    ax,cx
    jmp    short wrtdat3

wrtdat2:mov    ax,cx            ; Japan yyyy:mm:dd,   year
    call    wrtdat5
    mov    byte ptr [di],':'
    inc    di
    xor    ah,ah
    mov    al,dh            ; month
    call    wrtdat5
    mov    byte ptr [di],':'
    inc    di
    xor    ah,ah
    mov    al,dl            ; day
wrtdat3:call    wrtdat5
    mov    word ptr [di],0020h    ; space and null terminator
    inc    di
    pop    dx
    pop    cx
    ret
    ret

wrtdat5:cmp    ax,10            ; leading tens digit present?
    jae    wrtdat6            ; ae = yes
    mov    byte ptr [di],'0'    ; insert leading 0
    inc    di
wrtdat6:call    fdec2di            ; write decimal asciiz to buffer
    ret

wrtdate    endp

; write \v(ERRORLEVEL) text to ds:di
wrterr    proc    near
    mov    al,errlev        ; current Errorlevel
    xor    ah,ah
    call    fdec2di            ; write as ascii
    mov    word ptr [di],0020h    ; space and null terminator
    inc    di
    ret
wrterr    endp

; write \v(KEYBOARD) text to ds:di
wrtkbd    proc    near
    mov    ax,keyboard        ; 88 or 101 keyboard keys
    call    fdec2di            ; write as ascii
    mov    word ptr [di],0020h    ; space and null terminator
    inc    di
    ret
wrtkbd    endp

; write \v(NDATE) text to ds:di
; where NDATE is YYYYMMDD
wrtndate proc    near
    mov    ah,getdate        ; DOS date (cx= yyyy, dh= mm, dl= dd)
    int    dos
    push    dx            ; save dx
    mov    ax,cx            ; year
    call    fdec2di            ; convert it
    pop    dx            ; get mm:dd
    push    dx
    mov    al,dh            ; months are next
    xor    ah,ah
    cmp    al,10            ; less than 10?
    jae    wrtndat1        ; ae = no
    mov    byte ptr [di],'0'    ; leading 0
    inc    di
wrtndat1:call    fdec2di
    pop    dx
    mov    al,dl            ; get days
    xor    ah,ah
    cmp    al,10            ; less than 10?
    jae    wrtndat2        ; ae = no
    mov    byte ptr [di],'0'    ; leading 0
    inc    di
wrtndat2:call    fdec2di
    mov    word ptr [di],0020h    ; space and null terminator
    inc    di
    ret
wrtndate endp

; write \v(DIRECTORY) text to ds:di
wrtdir    proc    near
    push    si
    mov    ah,gcurdsk        ; get current disk
    int    dos
    add    al,'A'            ; make al = 0 == 'A'
    mov    [di],al
    mov    word ptr [di+1],'\:'
    mov    si,di            ; work buffer
    add    si,3            ; end with a colon and backslash
    mov    ah,gcd            ; get current directory
    xor    dl,dl            ; use current drive
    int    dos            ; get ds:si = asciiz path (no drive)
    mov    dx,di
    call    fstrlen
    add    di,cx
    cmp    cx,3            ; directory added?
    je    wrtdir1            ; e = no
    mov    byte ptr [di],'\'    ; add slash terminator so filenames
    inc    di            ;  can be appended easily
wrtdir1:mov    word ptr [di],0020h    ; space and null terminator
    inc    di
    pop    si
    ret
wrtdir    endp

fwrtdir    proc    far
    call    wrtdir
    ret
fwrtdir    endp

; write \v(PLATFORM) text to ds:di
wrtplat    proc    near
    push    si
    mov    si,offset machnam    ; machine name in sys dep file
    cld
wrtplat1:lodsb                ; get a char
    cmp    al,'$'            ; terminator?
    je    wrtplat2        ; e = yes
    mov    [di],al            ; store char
    inc    di
    jmp    short wrtplat1        ; keep going
wrtplat2:mov    word ptr [di],0020h    ; space and null terminator
    inc    di
    mov    temp,di            ; place for additional text
    pop    si
    ret
wrtplat    endp

; write \v(PORT) text to ds:di
wrtport    proc    near
    push    bx
    push    si
    mov    al,flags.comflg        ; get coms port indicator
    mov    bx,offset comptab    ; table of comms ports
    mov    cl,[bx]            ; number of entries
    xor    ch,ch
    inc    bx
wrtpor3:mov    dx,[bx]            ; length of this entry
    mov    si,bx
    add    si,2            ; points to entry text string
    add    si,dx            ; point to qualifier
    cmp    [si],al            ; our port?
    je    wrtpor4            ; e = yes
    add    bx,[bx]            ; add text length
    add    bx,4            ; plus count and qualifier
    loop    wrtpor3            ; next entry
    jmp    short wrtpor5        ; no match, curious
wrtpor4:mov    si,bx            ; point at entry
    add    si,2            ; point at string
    mov    cx,[bx]            ; length of string
    push    es
    mov    ax,ds
    mov    es,ax
    cld
    rep    movsb            ; copy to DS:DI
    pop    es
wrtpor5:mov    word ptr [di],0020h    ; space and null terminator
    inc    di
    pop    si
    pop    bx
    ret
wrtport    endp

; write \v(PROGRAM) text to ds:si
wrtprog    proc    near
    push    si
    mov    si,offset progm        ; source string
    cld
wrtprg1:lodsb
    cmp    al,'$'            ; terminator?
    je    wrtprg2            ; e = yes
    mov    [di],al            ; store the char
    inc    di
    jmp    short wrtprg1
wrtprg2:mov    word ptr [di],0020h    ; space and null terminator
    inc    di
    mov    temp,di            ; place for additional text
    pop    si
    ret
wrtprog    endp

; write \v(STATUS) text to ds:di
wrtstat    proc    near
    mov    ax,kstatus        ; Kermit status word
    call    fdec2di
    mov    word ptr [di],0020h    ; space and null terminator
    inc    di
    mov    temp,di            ; place for additional text
    ret
wrtstat    endp

; write \v(SYSTEM) text to ds:di
wrtsystem proc    near
    push    si
    mov    si,offset system    ; system string "MS-DOS", dollar sign
    cld
    jmp    wrtplat1        ; use some common code
wrtsystem endp

; write \v(TIME) text to ds:di
wrttime    proc    near
    mov    ah,gettim        ; DOS tod (ch=hh, cl=mm, dh=ss, dl=.s)
    int    dos
    push    dx            ; save dx
    xor    ah,ah
    mov    al,ch            ; Hours
    cmp    al,10            ; leading digit?
    jae    wrttim1            ; ae = yes
    mov    byte ptr [di],'0'    ; make our own
    inc    di
wrttim1:push    cx
    call    fdec2di            ; write decimal asciiz to buffer
    pop    cx
    mov    byte ptr [di],':'
    inc    di
    xor    ah,ah
    mov    al,cl            ; Minutes
    cmp    al,10            ; leading digit?
    jae    wrttim2            ; ae = yes
    mov    byte ptr [di],'0'    ; make our own
    inc    di
wrttim2:call    fdec2di            ; write decimal asciiz to buffer
    mov    byte ptr [di],':'
    inc    di
    pop    dx
    xor    ah,ah
    mov    al,dh            ; Seconds
    cmp    al,10            ; leading digit?
    jae    wrttim3            ; ae = yes
    mov    byte ptr [di],'0'    ; make our own
    inc    di
wrttim3:call    fdec2di            ; write decimal asciiz to buffer
    mov    word ptr [di],0020h    ; space and null terminator
    inc    di
    mov    temp,di            ; place for additional text
    ret
wrttime    endp

; write \v(Version) text to ds:di
wrtver    proc    near
    mov    si,offset verident    ; MS Kermit version string in mssker
    cld
wrtver1:lodsb
    mov    [di],al
    inc    di
    cmp    al,'$'            ; end of string?
    jne    wrtver1            ; ne = no, continue copying
    dec    di
    mov    word ptr [di],0020h    ; space and null terminator
    inc    di
    mov    temp,di            ; place for additional text
    ret
wrtver    endp

; write \v(TERMINAL) text to ds:di
wrtterm    proc    near
    mov    ax,flags.vtflg        ; current terminal type
    mov    bx,offset termtb    ; terminal type table msx...
    mov    cl,[bx]            ; number of entries in our table
    xor    ch,ch
    inc    bx            ; point to the data
wrtter1:mov    si,[bx]            ; length of keyword
    cmp    ax,[bx+si+2]        ; value fields match?
    je    wrtter2            ; e = yes
    add    bx,si            ; add word length
    add    bx,4            ; skip count and value fields
    loop    wrtter1            ; keep searching
    jmp    short wrtter4        ; no match, use just a space
wrtter2:mov    cx,[bx]            ; get length of counted string
    mov    si,bx
    add    si,2            ; look at text
    cld
wrtter3:lodsb
    mov    [di],al            ; from ds:si to ds:di
    inc    di
    loop    wrtter3
wrtter4:mov    word ptr [di],0020h    ; space and null terminator
    inc    di
    mov    temp,di            ; place for additional text
    ret
wrtterm    endp

code1    ends

code    segment
    assume    cs:code

; Set master prompt level. Enter with DX = offset of prompt string
MPROMPT    proc    near
    mov    mcmprmp,dx        ; offset of prompt string
    pop    ax            ; get the return address
    mov    word ptr mcmrprs,ax     ; offset to go to on reparse
    mov    mcmostp,sp        ; stack pointer at reparse time
    push    ax            ; put it on the stack again
    mov    ax,cs            ; our current code segment
    mov    word ptr mcmrprs+2,ax     ; segment of reparse address
    jmp    short prompt        ; now set the active prompt material
MPROMPT    endp

; This routine prints the prompt and specifies the reparse address.
; Enter with pointer to prompt string in dx.
PROMPT    PROC  NEAR
    mov    comand.cmprmp,dx    ; save the prompt
    pop    ax            ; get the return address
    mov    word ptr comand.cmrprs,ax ; offset to go to on reparse
    mov    comand.cmostp,sp    ; save for later restoration
    push    ax            ; put it on the stack again
    mov    ax,cs            ; our current code segment
    mov    word ptr comand.cmrprs+2,ax ; segment of reparse address
    mov    ax,offset cmdbuf
    mov    cmwptr,ax        ; reset buffer read/write pointers
    mov    cmrptr,ax
    xor    al,al
    mov    comand.cmper,al        ; allow substitutions
    mov    cmsflg,0ffh        ; remove leading spaces
    cmp    flags.takflg,al        ; look at Take flag, zero?
    jne    promp1            ; ne=supposed to echo, skip this check
    cmp    taklev,al        ; inside a take file?
    je    promp1            ; no, keep going
    ret                ; yes, return
promp1:    mov    ah,prstr
    mov    dx,offset crlf
    int    dos
    mov    dx,comand.cmprmp    ; prompt pointer
    call    prtasz            ; show asciiz prompt string
    clc
    ret
PROMPT    ENDP

ISDEV    PROC    NEAR            ; Set carry if STDIN is non-disk
    push    ax
    push    bx
    push    dx
    xor    bx,bx            ; handle 0 is stdin
    xor    al,al            ; get device info
    mov    ah,ioctl
    int    dos
    rcl    dl,1            ; put ISDEV bit into the carry bit
    pop    dx            ; carry is set if device
    pop    bx
    pop    ax
    ret                ; carry set if device
ISDEV    ENDP

ISEOF    PROC    NEAR            ; Set carry if STDIN is at EOF
    push    ax            ;  but only if stdin is a non-device
    push    bx
    push    dx
    xor    bx,bx            ; handle 0 is stdin
    xor    al,al            ; get device info
    mov    ah,ioctl
    int    dos
    mov    ah,ioctl
    mov    al,6            ; get handle input status, set al
    test    dl,80h            ; bit set if handle is for a device
    jnz    iseof1            ; nz = device, always ready (al != 0)
    int    dos
iseof1:    or    al,al            ; EOF?
    pop    dx
    pop    bx
    pop    ax
    jnz    iseof2            ; nz = no
    stc                ; set carry for eof
    ret
iseof2:    clc                ; clear carry for not-eof
    ret
ISEOF    ENDP

; Convert ascii characters in al and ah to lowercase.
; All registers are preserved except AX, of course.

TOLOWR PROC NEAR
    cmp    ah,'A'            ; less that cap A?
    jl    tolow1            ; l = yes. leave untouched
    cmp    ah,'Z'+1        ; more than cap Z?
    jns    tolow1            ; ns = yes
    or    ah,20H            ; convert to lowercase
tolow1:    cmp    al,'A'            ; less that cap A?
    jl    tolow2            ; l = yes. leave untouched
    cmp    al,'Z'+1        ; more than cap Z?
    jns    tolow2            ; ns = yes
    or    al,20H            ; convert to lowercase
tolow2:    ret
TOLOWR    endp
code    ends

code1    segment
    assume    cs:code1

; Parse control sequences and device control strings.
; Expect CSI, Escape [, or DCS lead-in characters to have been read.
; Puts numerical Parameters in array param (16 bits, count is nparam) and
;  a single letter Parameter in lparam, (Parameters are all ASCII column 3)
;  Intermediate characters in array inter (count is ninter), (ASCII column 2)
;  Final character in AL (ASCII columns 4-7).
; Invoke by setting state to offset atparse, set pardone to offset of
; procedure to jump to after reading Final char (0 means do just ret)
; and optionally setting parfail to address to jump to if parsing failure.
; When the Final char has been accepted this routine jumps to label held in
; pardone for final action. Before the Final char has been read successful
; operations return carry clear.
; Failure exits are carry set, and an optional jump through parfail (if
; non-zero) or a return.

atparse    proc    near
    mov    bx,parstate        ; get parsing state
    or    bx,bx            ; have any state?
    jnz    atpars1            ; nz = have a state
    call    atpclr            ; do initialization
    mov    bx,parstate        ; get initial state
atpars1:call    bx            ; execute it
    jc    atpfail            ; c = failure
    cmp    parstate,offset atpdone    ; parsed final char?
    je    atpdone            ; e = yes
    ret                ; no, wait for another char

                ; successful conclusion, final char is in AL
atpdone:mov    parstate,0        ; reset parsing state
    cmp    pardone,0        ; separate return address defined?
    jne    atpdon1            ; ne = yes
    clc
    ret                ; else just return
atpdon1:clc
    jmp    pardone            ; jmp to supplied action routine

atpfail:mov    parstate,0        ; failed, reset parser to normal state
    cmp    parfail,0        ; jump address specified?
    je    atpfail1        ; e = no
    jmp    parfail            ; yes, exit this way
atpfail1:stc
    ret
                    ; parsing workers
atparm:    cmp    ninter,0        ; Parameter, started intermediate yet?
    jne    atinter            ; ne = yes, no more parameters
    cmp    al,';'            ; argument separator?
    jne    atparm3            ; ne = no
    mov    ax,nparam        ; number of Parameters
    inc    ax            ; say a new one
    cmp    ax,maxparam        ; too many?
    jb    atparm2            ; b = no, continue
    stc                ; set carry to say failed
    ret                ; too many, ignore remainder
atparm2:mov    nparam,ax        ; say doing another Parameter
    clc
    ret

atparm3:mov    ah,al            ; copy char
    and    ah,not 0fh        ; ignore low nibble
    cmp    ah,30h            ; column 3, row 0? (30h='0')
    jne    atparm6            ; ne = no, check Intermediate/Final
    cmp    al,'9'            ; digit?
    ja    atparm5            ; a = no, check letter Parameters
    sub    al,'0'            ; ascii to binary
    mov    bx,nparam        ; current parameter number
    shl    bx,1            ; convert to word index
    mov    cx,param[bx]        ; current parameter value
    shl    cx,1            ; multiply by 10.  2 * cl
    push    bx
    mov    bx,cx            ; save 2 * cl
    shl    cx,1            ; 4 * cl
    shl    cx,1            ; 8 * cl
    add    cx,bx            ; 10 * cl
    pop    bx
    add    cl,al            ; add new digit
    adc    ch,0
    jnc    atparm4            ; nc = no carry out (65K or below)
    mov    cx,0ffffh        ; set to max value
atparm4:mov    param[bx],cx        ; current Parameter value
    clc
    ret
                    ; check non-numeric Parameters
atparm5:cmp    al,'?'            ; within column 3?
    ja    atfinal            ; a = no, check Final char
    mov    lparam,al        ; store non-numeric Parameter
    clc
    ret

atparm6:cmp    nparam,0        ; started a parameter yet?
    jne    atparm7            ; ne = yes
    cmp    param,0            ; got anything for param[0]?
    je    atinter            ; e = no
atparm7:inc    nparam            ; yes, say finished with another

atinter:mov    parstate,offset atinter    ; next state (intermediate)
    cmp    al,';'            ; argument separator?
    jne    atinte1            ; ne = no
    cmp    ninter,maxinter        ; too many intermediates?
    jb    atinte2            ; b = no, continue
    stc                ; carry = failed
    ret                ; too many, ignore remainder
atinte1:test    al,not 2fh        ; column two = 20h - 2fh?
    jnz    atfinal            ; nz = not an Intermediate, try Final
    cmp    ninter,maxinter        ; too many intermediates?
    jb    atinte1a        ; b = no, continue
    stc                ; carry = failed
    ret                ; too many, ignore remainder
atinte1a:mov    bx,ninter        ; current Intermediate slot number
    mov    inter[bx],al        ; current Intermediate value
atinte2:inc    ninter            ; say doing another Intermediate
    clc
    ret

atfinal:cmp    al,40h            ; Final character, range is 40h to 7fh
    jb    atfina1            ; b = out of range
    cmp    al,7fh
    ja    atfina1            ; a = out of range
    mov    parstate,offset atpdone    ; next state is "done"
    clc                ; success, final char is in AL
    ret
atfina1:stc                ; c = failed
    ret
atparse    endp

; Clear Parameter, Intermediate arrays in preparation for parsing
atpclr    proc    near
    push    ax
    push    cx
    push    di
    push    es
    xor    ax,ax            ; get a null
    mov    parstate,offset atparm    ; init parser state
    mov    lparam,al        ; clear letter Parameter
    mov    nparam,ax        ; clear Parameter count
    mov    cx,maxparam        ; number of Parameter slots
    mov    di,offset param        ; Parameter slots
    push    ds
    pop    es            ; use data segment for es:di below
    cld                ; set direction forward
    rep    stosw            ; clear the slots
    mov    ninter,ax        ; clear Intermediate count
    mov    cx,maxinter        ; number of Intermediate slots
    mov    di,offset inter        ; Intermediate slots
    rep    stosb            ; clear the slots
    pop    es
    pop    di
    pop    cx
    pop    ax
    ret
atpclr    endp

; Dispatch table processor. Enter with BX pointing at table of {char count,
; address of action routines, characters}. Jump to matching routine or return.
; Enter with AL holding received Final char.
atdispat proc near
    mov    cl,[bx]            ; get table length from first byte
    xor    ch,ch
    mov    di,bx            ; main table
    add    di,3            ; point di at first char in table
    push    es
    push    ds
    pop    es            ; use data segment for es:di below
    cld                ; set direction forward
    repne    scasb            ; find matching character
    pop    es
    je    atdisp2            ; e = found a match, get action addr
    ret                ; ignore escape sequence
atdisp2:sub    di,bx            ; distance scanned in table
    sub    di,4            ; skip count byte, address word, inc
    shl    di,1            ; convert to word index
    inc    bx            ; point to address of action routines
    mov    bx,[bx]            ; get address of action table
    jmp    word ptr [bx+di]    ; dispatch to the routine
atdispat endp
code1    ends
    end