   	NAME	msscmd
; File MSSCMD.ASM
	include mssdef.h
;	Copyright (C) 1982, 1997, Trustees of Columbia University in the 
;	City of New York.  The MS-DOS Kermit software may not be, in whole 
;	or in part, licensed or sold for profit as a software product itself,
;	nor may it be included in or distributed with commercial products
;	or otherwise distributed by commercial concerns to their clients 
;	or customers without written permission of the Office of Kermit 
;	Development and Distribution, Columbia University.  This copyright 
;	notice must not be removed, altered, or obscured.
;
; Edit history
; 12 Jan 1995 version 3.14
; Last edit
; 12 Jan 1995

 	public comnd, comand, isdev, iseof, prompt, tolowr, toupr, valtab
	public parstate, pardone, parfail, nparam, param, lparam, ninter
	public inter, atparse, atpclr, atdispat, cspb, dspb, mprompt, nvaltoa
	public savepoff, saveplen, keyboard, fwrtdir, cspb1, filetdate
	public	fqryenv, ifelse, oldifelse, retbuf, vfile

env	equ	2CH			; environment address in psp
braceop	equ	7bh			; opening curly brace
bracecl	equ	7dh			; closing curly brace

; codes for various \fxxx(arg list) operations
F_char		equ	1
F_code		equ	2
F_contents 	equ	3
F_definition	equ	4
;F_eval		equ	5
F_exec		equ	6
F_files		equ	7
F_index		equ	8
F_length	equ	9
F_literal	equ	10
F_lower		equ	11
F_lpad		equ	12
F_maximum 	equ	13
F_minimum 	equ	14
F_nextfile	equ	15
F_repeat 	equ	16
F_reverse	equ	17
F_right		equ	18
F_rpad		equ	19
F_substr	equ	20
F_upper		equ	21
F_date		equ	22
F_size		equ	23
F_replace	equ	24
F_eval		equ	25
F_rindex	equ	26
F_verify	equ	27
F_ipaddr	equ	28
F_tod2secs	equ	29
F_chksum	equ	30
F_basename	equ	31

; Constants for valtoa 
V_environ	equ	0
V_argc		equ	1
V_carrier	equ	22
V_charset	equ	33
V_console	equ	27
V_count		equ	2
V_cmdlevel	equ	29
V_cps		equ	24
V_date		equ	3
V_ndate		equ	14
V_dir		equ	5
V_dosver	equ	19
V_errlev	equ	4
V_kbd		equ	10
V_line		equ	15
V_monitor 	equ	28
V_parity 	equ	21
V_platform 	equ	8
V_port 		equ	15
V_program 	equ	12
V_prompt 	equ	23
V_query		equ	31
V_session 	equ	17
V_tcpip		equ	20
V_space 	equ	25
V_speed 	equ	11
V_startup 	equ	26
V_status 	equ	13
V_sysid		equ	32
V_system 	equ	9
V_terminal 	equ	16
V_time		equ	6
V_ntime 	equ	18
V_version 	equ	7
V_input		equ	30
V_inpath	equ	34
V_disk		equ	35
V_cmdfile	equ	36
V_inidir	equ	37
V_instatus	equ	38
V_minput	equ	39
V_return	equ	40
V_connection	equ	41
V_filespec	equ	42

; Like main filest, but shorter for local usage.
fileiost struc
dta	db 26 dup(0)	; DOS, 21 resev'd bytes, file attr, 2 each date & time
sizelo	dw 0		; DOS, file size double word
sizehi	dw 0
fname	db 13 dup(0)	; DOS, filename, asciiz, with dot. End of DOS section
fileiost ends

data 	segment
	extrn	flags:byte, taklev:byte, takadr:word, mcctab:byte
	extrn	kstatus:word, errlev:byte, psp:word, fsta:word
	extrn	portval:word, bdtab:byte, tdfmt:byte, machnam:byte
	extrn	verident:word, kstatus:word, errlev:byte, comptab:byte
	extrn	termtb:byte, dosnum:word, prmptr:word, startup:byte
	extrn	crt_mode:byte, tmpbuf:byte, buff:byte, minpcnt:word
	extrn	decbuf:byte, encbuf:byte, queryseg:word, inpath_seg:word
	extrn	cmdfile:byte, inidir:byte, dos_bottom:byte, marray:word
	extrn	input_status:word, domath_ptr:word, domath_cnt:word
	extrn	domath_msg:word, atoibyte:byte, atoi_err:byte, atoi_cnt:word

ifndef	no_tcp
	extrn	sescur:word, tcp_status:word
endif	; no_tcp

				; Start Patch structure. Must be first.
	even
dspb	dw	code		; segment values for patcher
	dw	code1
	dw	code2
	dw	data
	dw	data1
	dw	_TEXT
	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
ten	db	10			; for times ten

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$'
cmin01	db	' Use one of the following words in this position:',cr,lf,'$'
stkmsg	db	cr,lf,bell,'?Exhausted work space! Circular definition?$'
moremsg	db	'... more, press a key to continue ...$'
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
subcnt	db	0			; count of chars matched in '\%'
subtype db	0			; kind of sub (% or v)
evaltype dw	0			; evaltoa kind
bracecnt db	0			; curly brace counter
parencnt db	0			; parenthesis counter
report_binary db 0			; subst reporting \number directly
argptr	dw	3 dup (0)		; \fxxx() argument pointers
arglen	dw	3 dup (0)		; \fxxx() argument lengths
replay_cnt dw	0			; report to app, no echo
replay_skip db	0			; non-zero to skip subst for replays
retbuf	db	130 dup (0)		; \v(return) buffer
vfile	db	65 dup (0)		; \v(filespec) buffer
fileio	fileiost <>			; find first/next support
cmsflg	db	0			; Non-zero when last char was a space
cmkind	db	0			; command kind request (cmkey etc)
in_showprompt db 0			; Non-zero when in showprompt
cmdbuf	db	cmdblen dup (0)		; Buffer for command parsing
rawbuf	db	cmdblen dup (0)		; input, what user provided
read_source db	0			; channel whence we read
endedbackslash db 0
in_reparse db	0
	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)
cmrawptr dw	0			; non-substitution level, write ptr

ifndef	no_tcp
valtab	db	1+42			; table of values for \v(value)
else
valtab	db	1+42 - 2
endif	; no_tcp
	mkeyw	'argc)',V_argc
	mkeyw	'carrier)',V_carrier
	mkeyw	'charset)',V_charset
	mkeyw	'cmdfile)',V_cmdfile
	mkeyw	'connection)',V_connection
	mkeyw	'console)',V_console
	mkeyw	'count)',V_count
	mkeyw	'cmdlevel)',V_cmdlevel
	mkeyw	'cps)',V_cps
	mkeyw	'date)',V_date
	mkeyw	'ndate)',V_ndate
	mkeyw	'directory)',V_dir
	mkeyw	'dosversion)',V_dosver
	mkeyw	'disk)',V_disk
	mkeyw	'errorlevel)',V_errlev
	mkeyw	'filespec)',V_filespec
	mkeyw	'inidir)',V_inidir
	mkeyw	'inpath)',V_inpath
	mkeyw	'input)',V_input
	mkeyw	'instatus)',V_instatus
	mkeyw	'keyboard)',V_kbd
	mkeyw	'line)',V_port
	mkeyw	'minput)',V_minput
	mkeyw	'monitor)',V_monitor
	mkeyw	'parity)',V_parity
	mkeyw	'platform)',V_platform
	mkeyw	'port)',V_port
	mkeyw	'program)',V_program
	mkeyw	'prompt)',V_prompt
	mkeyw	'query)',V_query
	mkeyw	'return)',V_return
ifndef	no_tcp
	mkeyw	'session)',V_session
	mkeyw	'tcpip_status)',V_tcpip
endif	; no_tcp
	mkeyw	'space)',V_space
	mkeyw	'speed)',V_speed
	mkeyw	'startup)',V_startup
	mkeyw	'status)',V_status
	mkeyw	'sysid)',V_sysid
	mkeyw	'system)',V_system
	mkeyw	'terminal)',V_terminal
	mkeyw	'time)',V_time
	mkeyw	'ntime)',V_ntime
	mkeyw	'version)',V_version


evaltab	db	29			; \fverb(args)
	mkeyw	'basename(',F_basename
	mkeyw	'character(',F_char
	mkeyw	'checksum(',F_chksum
	mkeyw	'code(',F_code
	mkeyw	'contents(',F_contents
	mkeyw	'date(',F_date
	mkeyw	'definition(',F_definition
	mkeyw	'eval(',F_eval
	mkeyw	'files(',F_files
	mkeyw	'index(',F_index
	mkeyw	'ipaddr(',F_ipaddr
	mkeyw	'length(',F_length
	mkeyw	'literal(',F_literal
	mkeyw	'lower(',F_lower
	mkeyw	'lpad(',F_lpad
	mkeyw	'maximum(',F_maximum
	mkeyw	'minimum(',F_minimum
	mkeyw	'nextfile(',F_nextfile
	mkeyw	'rindex(',F_rindex
	mkeyw	'repeat(',F_repeat
	mkeyw	'replace(',F_replace
	mkeyw	'reverse(',F_reverse
	mkeyw	'right(',F_right
	mkeyw	'rpad(',F_rpad
	mkeyw	'size(',F_size
	mkeyw	'substr(',F_substr
	mkeyw	'tod2secs(',F_tod2secs
	mkeyw	'verify(',F_verify
	mkeyw	'upper(',F_upper
; not implemented in MS-DOS Kermit
;	mkeyw	'execute(',F_exec

envtab	db	1			     	; \$(..) Environment table
	mkeyw	'An Environment variable)',0	; reserve 0 in valtab

numtab  db      1                               ; \number help table
        mkeyw   'a number such as \123',0

						; table of Parity strings
parmsgtab dw	parevnmsg,parmrkmsg,parnonmsg,paroddmsg,parspcmsg
parevnmsg db	'EVEN',0
parmrkmsg db	'MARK',0
parnonmsg db	'NONE',0
paroddmsg db	'ODD',0
parspcmsg db	'SPACE',0

onoffmsgtab dw	offmsg,onmsg		; on/off table, asciiz
offmsg	db	'OFF',0
onmsg	db	'ON',0

ansiword db	'ANSI',0		; \v(console) ASCIIZ strings
noneword db	'NONE',0
colormsg db	'COLOR',0		; \v(monitor) ASCIIZ strings
monomsg	db	'MONO',0
connmsg	db	'local',0		; \v(connection) state

valtmp	dw	0
numtmp	dw	0

	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)
ifelse	db	0		; non-zero if last IF statement failed
oldifelse db	0		; copy of ifelse from previous command
month	db	'Jan ','Feb ','Mar ','Apr ','May ','Jun '
	db	'Jul ','Aug ','Sep ','Oct ','Nov ','Dec '
data	ends

data1	segment
	db	0			; so error msg has non-zero offset
cmin00  db      ' Press ENTER to execute command$'
f1hlp	db	' number$'
f2hlp	db	' char$'
f3hlp	db	' variable or macro name$'
f8hlp	db	' pattern-text, string, start-position$'
f9hlp	db	' text$'
f12hlp	db	' text, pad-length, pad-char$'
f15hlp	db	' no argument$'
f16hlp	db	' repeat-text, repeat-count$'
f18hlp	db	' text, right-most count$'
f20hlp	db	' text, start-position, substring len$'
f22hlp	db	' filename$'
f24hlp	db	' source, pattern, replacement$'
f25hlp	db	' arithmetic expression$'
f30hlp	db	' string$'
n1hlp	db	' digits of a number whose value fits into one byte$'
data1	ends

ifndef	no_terminal
ifndef	no_tcp
_TEXT	segment
	extrn	cpatch:far
_TEXT	ends
endif	; no_tcp
endif	; no_terminal

code1	segment
	assume 	cs:code1
	extrn	shovarcps:near, dskspace:far, fparse:far
	extrn	strlen:far, prtscr:far, strcpy:far, prtasz:far
	extrn	dec2di:far, decout:far, malloc:far, domath:far
        extrn   atoi:far, takrd:far, buflog:far, tod2secs:far

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
	extrn	takclos:far, docom:near, getenv:near
	extrn	getbaud:near, lnout:near, takopen_sub:far
	extrn	takopen_macro:far

	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
	dw	seg _TEXT
	dw	seg _DATA

ifndef	no_terminal
ifndef	no_tcp
	dw	offset cpatch
endif	; no_tcp
endif	; no_terminal
	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

fdec2di	proc	far
	push	cx
	push	ds
	mov	cx,es
	mov	ds,cx
	call	dec2di
	pop	ds
	pop	cx
	ret
fdec2di	endp
ftakclos proc	far
	call	takclos
	ret
ftakclos endp

nvaltoa	proc	near
	push	es
	mov	ax,ds
	mov	es,ax
	call	fvaltoa
	pop	es
	ret
nvaltoa	endp
flnout	proc	far
	call	lnout
	ret
flnout	endp
fdskspace proc	far
	call	dskspace
	ret
fdskspace 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	bracecnt,0		; curly brace counter
	cmp	ah,cmeol		; Parse a confirm?
	jne	cm2			; nz = no
	call	cmcfrm			; get a Carriage Return end of line
	ret
cm2:	mov	cmkind,ah		; remember for {} line continuation
	cmp	ah,cmkey		; Parse a keyword?
	jne	cm3			; ne = no
	xor	al,al			; get a zero/clear
	xchg	al,ifelse		; get current ifelse state
	mov	oldifelse,al		; remember here (one cmd delay)
	call	cmkeyw			; get keyword
	ret
cm3:	cmp	ah,cmline		; parse line of text
	jne	cm4
	call	cmtxt
	ret
cm4:	cmp	ah,cmword		; parse arbitrary word
	jne	cm5
	call	cmtxt
	ret
cm5:	mov	ah,prstr		; else give error
	mov	dx,offset cmer00	; "?Program internal error"
	int	dos
	jmp	prserr			; reparse
					; Control-C exit path (far to near)
cmexit	label	far
	mov	sp,cmdstk		; restore command entry stack pointer
	stc
	retn				;  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 carry clear for success and carry set 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
	call	cmkyhlp			; display help
	jmp	repars
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
	mov	comand.cmcnvkind,cmcnv_none ; default is no conversion
	clc
	ret				; return successfully to user

cmky5:	cmp	cmsiz,0			; started a word yet?
	je	cmky1			; e = no, ignore escape, keep looking
	call	cmkyhlp			; display help
	jmp	repars

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
	call	optionclr		; clear parser options
	mov	errflag,0
	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	isdev			; 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
	mov	comand.impdo,0		; clear flag to prevent loops
	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	bufdel			; cut back buffer to last good char
	jmp	repars			; reparse interactive lines

cmky9:	call	cmcfrm			; 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
	push	cmrptr			; points at ESC
	pop	cmwptr			; pointed one byte beyond 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
	dec	cmrawptr		; overwrite ESC
	mov	si,cmrawptr		; where raw writes go
	mov	dx,cmsiz		; length of user word
	add	bx,dx			; add chars known so far
	sub	cx,dx			; calculate number yet to add
	jcxz	cmkye4			; z = none
cmkye3:	mov	al,[bx]			; get a keyword letter
	inc	bx
	call	tolowr			; lowercase
	mov	[si],al			; store it
	inc	si
	loop	cmkye3			; do all new chars
cmkye4:	mov	word ptr [si],'  '	; add trailing space, clear old next
	inc	si
	mov	cmrawptr,si
	pop	si
	pop	bx			; bx = keyword structure
	inc	cmrawptr		; bufdel backs up one char
	jmp	bufdel
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	prtscr			; 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	si,cmhlp		; external help text in seg data1
	xor	bx,bx			; line counter
	push	es
	mov	ax,seg data1		; all help text is in data1
	mov	es,ax
	cld
cmkyh10:mov	al,es:[si]		; read a help msg byte
	inc	si
	cmp	al,'$'			; end of message?
	je	cmkyh14			; e = yes, stop
cmkyh11:mov	ah,conout
	mov	dl,al
	int	dos			; display byte
	cmp	dl,LF			; line break?
	jne	cmkyh10			; ne = no
	inc	bl			; count line
	cmp	bl,dos_bottom		; (24) time for a more msg?
	jbe	cmkyh10			; be = not yet
	xor	bl,bl			; reset line count
	call	iseof			; are we at EOF, such as from disk?
	jc	cmkyh10			; c = yes, ignore more msg
	mov	ah,prstr
	mov	dx,offset moremsg	; "... more..." msg
	int	dos
cmkyh13:mov	ah,coninq		; read the char from file, not device
	int	dos
	cmp	al,3			; a ^C?
	je	short cmkyh14		; e = yes, stop the display
	push	bx			; save line counter
	push	es			; and read pointer
	push	si
	call	fctlu			; clear display's line, reuse it
	pop	si
	pop	es
	pop	bx
	jmp	short cmkyh10		; continue
cmkyh14:pop	es
	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	bufdel			; unwrite the "?" (cmrptr is there)
	ret
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	tolowr			; 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 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.

; CMLINE: Parse	arbitrary text up to a CR.
; CMWORD: Parse text up to first trailing space, or if starts with ()
;  then consume the line.
; 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.
; If the line starts with an opening curly brace, then physical lines are
; automatically continued until the closing curly brace is obtained.
; Continuation breaks are a comma in the data stream and a CR/LF to the
; visual screen. Material after the closing brace is discarded.
;
; Lines and words starting on a curly brace and ending on a matching
; curly brace plus optional whitespace have the trailing whitespace
; omitted and both outer braces removed.
cmtxt	proc	far
	mov	cmptab,bx		; save pointer to data buffer
	xor	ax,ax
	mov	word ptr [bx],ax	; clear result buffer
	mov	cmhlp,dx		; save the help message
	mov	cmsiz,ax		; init the char count
	mov	parencnt,al		; clear count of parentheses
	cmp	comand.cmblen,ax	; length of user's buffer given?
	jne	cmtxt1			; ne = yes
	mov	comand.cmblen,127	; else set 127 byte limit plus null
cmtxt1:	cmp	comand.cmwhite,al	; allow leading whitespace?
	jne	cmtxt2			; ne = yes
	mov	cmsflg,0ffh		; omit leading space
cmtxt2:	call	cmgtch			; get a char
	jc	cmtxt3			; c = terminator 
	jmp	cmtxt10			; put char into the buffer

cmtxt3:	cmp	ah,' '			; space terminator?
	jne	cmtxt4			; ne = no
	cmp	cmkind,cmline		; parsing lines?
	je	cmtxt10			; e = yes, put space in the buffer
	mov	bx,cmptab		; words, check on () delimiters
	sub	bx,cmsiz
	cmp	byte ptr [bx],'('	; started word with paren?
	jne	cmtxt6			; ne = no, it's a terminator
	cmp	parencnt,0		; outside parens?
	jne	cmtxt10			; ne = no, use as data inside (..)
	jmp	cmtxt6			; space is terminator

cmtxt4:	cmp	ah,escape		; escape?
	jne	cmtxt5			; ne = no
	call	esceoc			; do normal escape end-of-command
	jmp	short cmtxt1		; try again

cmtxt5:	cmp	ah,'?'			; asking a question?
	je	cmtxt8			; e = yes
	cmp	ah,CR			; bare CR?
	je	cmtxt6			; e = yes, always a terminator
	cmp	cmkind,cmline		; reading a line?
	je	cmtxt10			; e = yes, other terms go into buffer
					; else terminators terminate words

cmtxt6:	mov	bx,cmptab		; pointer into destination array
	mov	byte ptr[bx],0		; put null terminator into the buffer
	xchg	ax,cmsiz		; return count in AX
	or	ax,ax			; empty?
	jz	cmtxt7a			; z = yes

cmtxt7:	push	si			; remove terminating curly braces
	mov	si,cmptab		; where next output byte goes
	sub	si,ax			; minus read, equals start of buffer
	mov	cx,ax			; count to cx for unbrace
	call	unbrace			; outer curly brace remover
	mov	ax,cx			; returned length back to AX
	mov	bx,si
	add	bx,ax			; bx points to null terminator
	pop	si
cmtxt7a:call	optionclr		; clear parser options
	cmp	cmkind,cmline		; lines?
	jne	cmtxt7f			; ne = no, words
	call	rprompt			; restore master prompt level
cmtxt7f:clc
	ret

cmtxt8:	inc	cmrptr			; count the ?
	cmp	cmsiz,0			; Is "?" first char?
	jne	cmtxt10			; ne = no, just add to buffer
	dec	cmrptr
	cmp	cmhlp,0			; external help given?
	jne	cmtxt9			; ne = yes
	mov	cmhlp,offset cmin00	; confirm with c/r msg
cmtxt9:	push	cmsiz
	mov	cmsiz,0			; so we do not use keyword table
	call	cmkyhlp			; use our help message
	pop	cmsiz
	jmp	cmtxt2

cmtxt10:inc	cmsiz			; increment the output count
	mov	bx,cmptab		; pointer into destination array
	mov	[bx],ah			; put char into the buffer
	cmp	cmkind,cmword		; word?
	jne	cmtxt12			; ne = no, line
	cmp	ah,'('			; opening paren?
	jne	cmtxt11			; ne = no
	inc	parencnt		; count up parens
	jmp	short cmtxt12
cmtxt11:cmp	ah,')'			; closing paren?
	jne	cmtxt12			; ne = no
	sub	parencnt,1
	jns	cmtxt12			; ns = no underflow
	mov	parencnt,1		; don't underflow
cmtxt12:inc	bx
	mov	cmptab,bx
	mov	cx,cmsiz		; length of command so far
	cmp	cx,4			; got four chars?
	jne	cmtxt12a		; ne = no
	cmp	comand.cmarray,0	; worry about \&<char> as destination?
	je	cmtxt12a		; e = no
	cmp	word ptr [bx-4],'&\'	; starts with array indicator?
	jne	cmtxt12a		; ne = no
	mov	comand.cmper,0		; allow substitution in [...]
	mov	comand.cmarray,0	; say have done array destination test
cmtxt12a:
	cmp	cx,comand.cmblen	; buffer filled?
	ja	cmtxt14			; a = yes, declare error
	jb	cmtxt13			; a = not filled yet
	mov	ah,conout		; notify user that the buffer is full
	mov	dl,bell
	int	dos
	jmp	cmtxt6			; quit

cmtxt13:jmp	cmtxt2

cmtxt14:mov	ah,prstr
	mov	dx,offset cmer09
	int	dos
	jmp	prserr			; declare parse error
cmtxt	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	bracecnt,0
	mov	comand.cmper,1		; do not react to \%x substitutions
	cmp	cmrptr,offset cmdbuf	; empty buffer?
	je	cmcfr7			; e = yes
	mov	bx,cmrptr		; where to read next
	dec	bx			; last read byte
	cmp	byte ptr [bx],CR	; terminated already?
	je	cmcfr7			; e = yes

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:	xor	ax,ax
	mov	errflag,al
	call	optionclr		; clear parser options
	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	subst0			; ne = no, treat as literals
	cmp	taklev,0		; in a Take file?
	je	subst0a			; e = no
	push	bx
	mov	bx,takadr
	cmp	[bx].takper,0		; expand macros?
	pop	bx
	je	subst0a			; e = yes
subst0:	clc				; report out to application
	ret
subst0a:cmp	subtype,'0'		; doing \numbers already?
	jne	subst0b			; ne = no
	jmp	subst30			; continue to parse digits

subst0b:cmp	ah,'\'			; is it the first char of the pattern?
	jne	subst1			; ne = no, try next
	cmp	subcnt,1		; \\?
	jne	subst0c			; ne = no
	mov	subcnt,0		; clear state and pass back one \
	clc
	ret
subst0c:cmp	endedbackslash,0	; ended sub macro on backslash?
	jne	subst1a			; ne = yes
	inc	subcnt			; say first char (\) is matched
	and	subcnt,1		; modulo 2
	mov	subtype,ah
	stc				; do not pass to application
	ret

subst1:	cmp	subcnt,1		; first char matched already?
	ja	subst3			; a = first two have been matched
	jb	subst0			; b = none yet
	mov	al,ah			; test kind of substitution
	or	al,20h			; convert to lower case
	cmp	ah,'%'			; second match char, same?
	je	subst2			; e = yes
	cmp	al,'v'			; \v(...)?
	je	subst2			; e = yes
	cmp	al,'$'			; \$(..)?
	je	subst2			; e = yes
	cmp	al,'m'			; \m(..)?
	je	subst2			; e = yes
	cmp	comand.cmarray,0	; allow array recognition?
	jne	subst1d			; ne = no
	cmp	al,'&'			; \&<char>[..]?
	je	subst2			; e = yes
subst1d:				; start \number
	cmp	comand.cmdonum,0	; convert \numbers allowed?
	je	subst1c			; e = no
	cmp	ah,'{'			; \{number}?
	je	subst1b			; e = yes
	cmp	al,'d'			; \Dnumber?
	je	subst1b			; e = yes
	cmp	al,'o'			; \Onumber?
	je	subst1b			; e = yes
	cmp	al,'x'			; \Xnumber?
	je	subst1b			; e = yes
	cmp	ah,'0'			; in range for numbers?
	jb	subst1c			; b = no
	cmp	ah,'9'
	ja	subst1c			; a = no
subst1b:mov	subtype,'0'		; mark as numeric
	mov	subcnt,2		; matched second introducer
	push	bx
	mov	bx,cmrptr
	sub	bx,2			; point at \
	mov	numtmp,bx		; where \number starts
	pop	bx
	stc				; do not pass to application
	ret
					; end \number
subst1c:cmp	al,'f'			; \fname(..)?
	jne	subst1a			; ne = no
	mov	subtype,al		; remember type
	inc	subcnt			; count match
	jmp	subst10			; read more bytes internally

subst1a:push	ax			; replay bytes as literals
	mov	al,subcnt		; previously matched bytes
	xor	ah,ah
	inc	ax			; plus current byte
	sub	cmrptr,ax
	mov	replay_cnt,ax		; trailer bytes, amount to replay
	pop	ax
	mov	subcnt,0		; mismatch, clear match counter
	mov	subtype,0
	mov	endedbackslash,0
	stc				; reread from input
	ret

subst2:	cmp	al,'%'			; starting \%?
	jne	subst2b			; ne = no
	cmp	subtype,'v'		; doing \v(..)? (dirs of c:\%foobar)
;;;	je	subst1a			; e = yes, don't expand \% inside

subst2b:mov	subtype,al		; remember kind of substitution
	inc	subcnt			; count match
	cmp	al,'%'
	je	subst10
	cmp	al,'&'			; doing \&<char>[..]?
	je	subst10			; e = yes
	stc				; do not pass to application
	ret

subst3:	cmp	subtype,'v'		; doing \v(..)?
	je	subst3a			; e = yes
	cmp	subtype,'$'		; doing \$(..)?
	je	subst3a			; e = yes
	cmp	subtype,'m'		; doing \m(..)?
	je	subst3a			; e = yes
	mov	subcnt,0		; clear match counter
	jmp	subst1a			; no match

subst3a:cmp	ah,'('			; have leading parenthesis?
	jne	subst1a			; ne = no, mismatch, exit
	jmp	subst10			; process \v(..), \$(..), \m(..)

					; \fname(..), \m(..), \v(..), \$(..)
subst10:push	bx			; save working regs
	push	cx
	push	es
	push	cmptab			; save current keyword parsing parms
	push	cmsptr
	push	cmsiz
	push	valtmp
	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 evaltab	; evaluate (name) table
	cmp	subtype,'f'		; \fname()?
	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:mov	ch,subtype		; save \type
	push	cx
	call	cmgtch			; read a character into ah
	rcl	al,1			; put carry bit into low bit of al
	pop	cx
	xchg	ch,subtype		; recover \type
	rcr	al,1			; recover carry bit
	jnc	subst13			; nc = non-terminator

	cmp	subtype,'%'		; \%<char>?
	jne	subst11d		; ne = no
	cmp	ah,' '			; question or similar?
	jbe	subst13			; be = no, a funny
	inc	cmrptr			; accept the terminator as data
	jmp	subst13
subst11d:
	cmp	subtype,'m'		; discard trailing spaces for these
	je	subst11b
	cmp	subtype,'v'
	je	subst11b
	cmp	subtype,'&'
	je	subst11b
	cmp	subtype,'$'
	jne	subst11c
subst11b:cmp	ah,' '			; space terminator?
	je	subst11			; e = yes, ignore it
subst11c:cmp	ah,'?'			; need help?
	jne	subst11a		; ne = no
	call	cmkyhlp			; display help information
	jmp	short subst11

subst11a:cmp	ah,escape		; escape?
	jne	subst12			; ne = no
	cmp	in_showprompt,0		; making new prompt?
	jne	subst12			; ne = yes, include literal escape
	call	cmkyesc			; process escape
	jmp	short subst11		; failed, ignore esc, read more
					;
subst12:cmp	subtype,'f'		; \fname(..)?
	je	subst12a		; e = yes, else no need to replay
	jmp	subst17

subst12a:mov	bx,cmsptr		; where \fname() word started
	sub	bx,2			; back over "\f" part
	mov	cx,cmrptr		; last read + 1
	sub	cx,bx			; bytes in \foobar
	mov	cmrptr,bx		; reread point is the \
	add	replay_cnt,cx		; bytes to reread (+external \ fails)
	jmp	subst17

subst13:inc	cmsiz			; count user chars
	cmp	subtype,'%'		; \%<char>?
	jne	subst13j		; ne = no
	cmp	ah,'0'			; large enough?
	jb	subst17			; b = no, fail
	mov	cmsiz,3+1		; size is three bytes, plus dec below
	sub	cmsptr,2		; backup to \
	jmp	short subst13b
subst13j:cmp	subtype,'f'		; \fname(...)?
	jne	subst13a		; ne = no
	cmp	ah,'('			; look for "(" as terminator
	je	subst13b		; e = found, lookup "name" as keyword
	cmp	ah,'0'			; numeric?
	jb	subst12a		; b = no, end of string
	cmp	ah,'9'
	jbe	subst11			; be = yes, keep reading
	call	tolowr			; to lower case
	cmp	ah,'z'
	ja	subst12a		; a = non-alpha, end of string
	cmp	ah,'a'
	jae	subst11			; ae = alpha, keep reading
	jmp	short subst12a		; yes, stop here

subst13a:cmp	subtype,'&'		; \&c[..]?
	jne	subst13i		; ne = no
	cmp	ah,']'			; end bracket?
	jne	subst11			; ne = no, keep going
	jmp	short subst13b		; have it
subst13i:cmp	ah,')'			; end bracket?
	jne	subst11			; ne = no, keep looking
subst13b:dec	cmsiz			; omit user's ')' from tests
	cmp	subtype,'&'		; \&char[..]?
	je	subst20			; e = yes, have all bytes
	cmp	subtype,'$'		; \$(..)?
	je	subst13c		; e = yes, no keyword in table
	push	cmsptr			; save pointer
subst13g:mov	bx,cmsptr
	cmp	byte ptr [bx],' '	; leading spaces?
	jne	subst13h		; ne = no
	inc	cmsptr			; look at next char
	jmp	short subst13g
subst13h:call	getkw			; \m(..) and \v(..) test for keyword
	pop	cmsptr
	jc	subst12			; c = failure
	jmp	short subst13d		; success

subst13c:call	envvar			; search Environment for the word
	jc	subst12			; c = failure
	mov	bx,V_environ		; set bx to kind of value for valtoa
	jmp	short subst13f

subst13d:cmp	subtype,'f'		; doing \fname(...)?
	jne	subst13f		; ne = no
	mov	subcnt,0		; clear \f match indicator
	add	bx,[bx]			; add length of keyword text (CNT)
	add	bx,2			; point at value field
	mov	bx,[bx]			; get value
subst13e:mov	evaltype,bx		; remember kind of operation
	call	evaltoa			; do \fname argument evaluation
	jc	subst12a		; error, reparse
	jmp	subst17

subst13f:mov	ax,valtmp		; where word started
	sub	ax,3			; backup to "\v(" or "\$("
	cmp	subtype,'%'		; doing \%<char>?
	jne	subst13k		; ne = no
	inc	ax			; one less field byte than others
subst13k:mov	cmrptr,ax		; write output where backslash was
	call	bufreset		; resets cmwptr too
	xor	dx,dx			; signal valtoa to not add trailing sp
	cmp	subtype,'$'		; \$(..)?
	je	subst14			; e = yes, no keyword structure
	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
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	subst17

					; \&char[..]
subst20:mov	ax,valtmp		; where <char> started
	mov	bx,ax
	cmp	byte ptr [bx+1],'['
	jne	subst12a

	sub	ax,2			; backup to "\&<char>["
	mov	cmrptr,ax		; write output where backslash was
	add	cmsptr,2		; point after "[" for index math
	call	bufreset		; resets cmwptr too
	push	si
	mov	si,cmsptr		; start of string after "["
	mov	cx,1024			; cmsiz ignores leading spaces
subst20a:cmp	byte ptr [si],' '	; remove leading spaces
	jne	subst20b
	inc	si
	loop	subst20a
subst20b:push	si			; save starting point
	mov	cx,1024			; assumed max string in [..]
	xor	bx,bx
	cld
subst20c:lodsb
	cmp	al,']'			; terminator?
	je	subst20e		; e = yes
	inc	bx			; count string chars
subst20d:loop	subst20c
subst20e:pop	si			; recover starting point
	push	si
	mov	domath_ptr,si		; ptr to string
	mov	domath_cnt,bx		; length of string
	call	domath			; string to binary in dx:ax
	pop	si
	mov	si,cmsptr		; points just after "\&<char>["
	mov	bl,[si-2]		; back up to <char>
	cmp	bl,'_'			; arg list \$_[list element]?
	jne	subst20g		; ne = no
	pop	si			; clean stack
	cmp	ax,9			; too large?
	ja	subst17			; a = yes, do nothing
	push	ax
	mov	ax,4+2			; want four bytes plus count
	call	malloc			; to seg in ax
	mov	es,ax
	pop	ax
	mov	word ptr es:[2],'%\'	; compose string \%<digit>
	add	al,'0'			; use index of 0..9
	xor	ah,ah
	mov	word ptr es:[4],ax	; null terminate
	mov	cx,3
	mov	word ptr es:[0],cx	; three bytes of text
	mov	ax,es			; setup for below
	jmp	short subst20h		; compose the macro

subst20g:and	bl,not 20h		; upper case it
	cmp	bl,'Z'			; last <char>
	ja	subst20f		; a = out of range
	sub	bl,'@'			; remove bias
	xor	bh,bh
	shl	bx,1			; address words
	mov	si,marray[bx]		; get segment of string storage
	or	si,si			; any?
	jz	subst20f		; z = none
	mov	es,si			; look at segment of array
	cmp	es:[0],ax		; number of elements vs index above
	jbe	subst20f		; be = out of range, quit
	mov	si,ax
	shl	si,1			; index words
	mov	ax,es:[si+2]		; get definition string segment to ax
	pop	si
	or	ax,ax			; any?
	jz	subst17			; z = no, empty
subst20h:mov	es,ax			; string seg
	mov	cx,es:[0]		; length of definition
	jcxz	subst17			; z = empty
	call	takopen_sub		; open take as text substitution
	jc	subst17			; c = cannot open
	mov	bx,takadr		; pointer to new Take structure
	mov	[bx].takbuf,es		; segment of Take buffer
	mov	[bx].takcnt,cx		; number of unread bytes
	jmp	subst17

subst20f:pop	si			; failure
	jmp	subst17

subst15:mov	subcnt,0		; clear match indicator
	call	takopen_sub		; open take as text substitution
	jc	subst17			; c = failed
	mov	cx,bx			; value command kind, save
	mov	ax,tbufsiz		; bytes of buffer space wanted
	call	malloc
	jc	subst17			; c = failed
	mov	bx,takadr		; point to structure
	or	[bx].takattr,take_malloc ; remember to dispose via takclos
	mov	[bx].takbuf,ax		; seg of buffer
	mov	es,ax			; ES:DI will be buffer pointer
	mov	di,[bx].takptr		; where to write next
	mov	[bx].takper,0		; expand macros
	cmp	subtype,'m'		; \m(..)?
	jne	subst16a		; ne = no
	mov	[bx].takper,1		; do not expand macros in \m(..)
subst16a:mov	bx,cx			; value command
	call	valtoa			; make text be an internal macro
	mov	bx,takadr
	mov	[bx].takcnt,di		; length
subst17:
	pop	dx
	mov	subtype,0
	pop	valtmp
	pop	cmsiz			; restore borrowed keyword parameters
	pop	cmsptr
	pop	cmptab
	pop	es
	pop	cx
	pop	bx
	stc				; carry = signal reread source
	ret
					; convert \number
subst30:cmp	ah,'?'			; asking for help?
	jne	subst30a		; ne = no
	mov	cmsiz,0			; no keyword to expand
	push	cmhlp			; save existing help
	mov	cmhlp,offset n1hlp	; our message
	call	cmkyhlp			; display help message
	pop	cmhlp			; restore old help
	stc				; buffer has been cleaned by cmkyhlp
	ret
subst30a:push	si
	mov	si,numtmp		; where \ starts
	mov	atoibyte,1		; convert only one character
	mov	cx,cmrptr
	sub	cx,numtmp		; byte count to examine
	mov	atoi_cnt,cx		; tell atoi the count
	call    atoi			; value to dx:ax
	mov	cmsflg,0		; clear space-seen flag
	jnc	subst31			; nc = converted a value
	cmp	atoi_err,4		; insufficient bytes to resolve
	je	subst30b		; e = yes, get more
	mov	cx,cmrptr		; replay complete failure
	sub	cx,numtmp		; where \ started
	add	replay_cnt,cx		; count to replay
	mov	si,numtmp
	mov	cmrptr,si		; replay from here
	mov	subcnt,0		; mismatch, clear match counter
	mov	subtype,0		; and substitution type 
	mov	endedbackslash,0	; general principles
subst30b:pop	si
	stc				; carry set to read more bytes
	ret
subst31:pop	si
	cmp	atoi_err,1		; success and terminated?
	jne	subst31a		; ne = no
	mov	ah,al			; ah now has value for app
	mov	subtype,0
	mov	subcnt,0
	inc	report_binary		; signal have number to report to app
	clc
	ret

subst31a:cmp	atoi_err,0		; success, can accept more data?
	jne	subst32			; ne = no
	stc				; c = return to read more data
	ret
subst32:mov	ah,al			; ah now has value for app
	mov	subtype,0
	mov	subcnt,0
	push	ax
	dec	cmrptr			; reread break byte
	mov	replay_cnt,1		; for non-\
	push	bx
	mov	bx,cmrptr		; last read byte
	mov	ah,[bx]			; get break byte
	pop	bx
	inc	report_binary		; signal have number to report to app
	cmp	ah,'\'			; substitution introducer?
	jne	subst34			; ne = no, pass it to app
	inc	cmrptr			; step over read byte
	mov	replay_cnt,0		; no replay
	mov	subcnt,1		; mark \ introducer as have been read
subst34:pop	ax
	clc
	ret
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	di			; save starting di
	push	dx			; save trailing space flag
	mov	word ptr es:[di],0	; fill buffer with sweet nothings
					; BX has index of variable
	cmp	bx,V_environ		; \$() Environment?
	jne	valtoa1			; ne = no
	mov	cx,envlen		; string length
	jcxz	valtoa0			; z = empty
	cmp	cx,tbufsiz-2		; greater than current buffer?
	jbe	valtoa0a		; be = no
	push	cx
	mov	ax,[bx].takbuf		; old buffer
	mov	es,ax			; new ES from above
	mov	ah,freemem		; free it
	int	dos
	mov	ax,cx			; bytes wanted
	call	malloc			; get more space
	mov	bx,takadr
	mov	[bx].takbuf,ax		; seg of macro def
	mov	ES,ax			; new ES
	or	[bx].takattr,take_malloc ; remember to dispose via takclos
	pop	cx
valtoa0a:
	push	si
	push	ds
	lds	si,envadr		; ds:si is source from Environment
	cld
	rep	movsb			; copy string
	pop	ds
	pop	si
valtoa0:jmp	valtoa90
	
valtoa1:cmp	bx,V_argc		; \v(argc)?
	jne	valtoa2			; ne = no
	call	wrtargc			; write argc
	jmp	valtoa90
valtoa2:cmp	bx,V_count		; \v(count)?
	jne	valtoa3			; ne = no
	call	wrtcnt			; write it
	jmp	valtoa90
valtoa3:cmp	bx,V_date		; \v(date)?
	jne	valtoa4
	call	wrtdate
	jmp	valtoa90
valtoa4:cmp	bx,V_errlev		; \v(errorlevel)?
	jne	valtoa5			; ne = no
	call	wrterr
	jmp	valtoa90
valtoa5:cmp	bx,V_dir		; \v(dir)?
	jne	valtoa6
	call	wrtdir
	jmp	valtoa90
valtoa6:cmp	bx,V_time		; \v(time)?
	jne	valtoa7
	call	wrttime
	jmp	valtoa90
valtoa7:cmp	bx,V_version		; \v(version)?
	jne	valtoa8			; ne = no
	mov	ax,version		; get version such as 300
	call	fdec2di			; convert binary to asciiz
	jmp	valtoa90
valtoa8:cmp	bx,V_platform		; \v(platform)?
	jne	valtoa9			; ne = no
	call	wrtplat			; get machine name, e.g. "IBM-PC"
	jmp	valtoa90
valtoa9:cmp	bx,V_system		; \v(system)?
	jne	valtoa10		; ne = no
	call	wrtsystem		; get "MS-DOS" string
	jmp	valtoa90
valtoa10:cmp	bx,V_kbd		; \v(keyboard)?
	jne	valtoa11		; ne = no
	call	wrtkbd			; 88 or 101 value
	jmp	valtoa90
valtoa11:cmp	bx,V_speed		; \v(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	valtoa90

valtoa12:cmp	bx,V_program		; \v(program)?
	jne	valtoa13		; ne = no
	call	wrtprog			; get "MS-DOS_KERMIT" string
	jmp	valtoa90
valtoa13:cmp	bx,V_status		; \v(status)?
	jne	valtoa14		; ne = no
	call	wrtstat			; compose status string
	jmp	valtoa90
valtoa14:cmp	bx,V_ndate		; \v(ndate)?
	jne	valtoa15		; ne = no
	call	wrtndate
	jmp	valtoa90
valtoa15:cmp	bx,V_port		; \v(port)? or \v(line)?
	jne	valtoa16		; ne = no
	call	wrtport
	jmp	valtoa90
valtoa16:cmp	bx,V_terminal		; \v(terminal)?
	jne	valtoa17		; ne = no
	call	wrtterm
	jmp	valtoa90
valtoa17:
ifndef	no_tcp
	cmp	bx,V_session		; \v(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
	jmp	valtoa90
endif	; no_tcp
valtoa18:cmp	bx,V_ntime		; \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
	push	di
	push	es
	mov	di,ds
	mov	es,di
	mov	di,offset cmdbuf-30-cmdblen
	call	flnout			; 32 bit converter
	mov	dx,offset cmdbuf-30-cmdblen
	call	strlen
	mov	si,dx
	pop	es
	pop	di
	cld
	rep	movsb
	mov	word ptr [di],0020h	; space, null
	jmp	valtoa90

valtoa19:cmp	bx,V_dosver		; \v(dosversion)?
	jne	valtoa20		; 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 es:[di],'0'	; use two digits for minor
	inc	di
valtoa19a:
	call	fdec2di			; write minor
	jmp	valtoa90
valtoa20:
ifndef	no_tcp
	cmp	bx,V_tcpip		; \v(tcp_status)?
	jne	valtoa21		; ne = no
					; SUCCESS	0
					; NO_DRIVER	1
					; NO_LOCAL_ADDRESS 2
					; BOOTP_FAILED	3
					; RARP_FAILED	4
					; BAD_SUBNET_MASK 5
					; SESSIONS_EXCEEDED 6
					; HOST_UNKNOWN	7
					; HOST_UNREACHABLE 8
					; CONNECTION_REJECTED 9
	mov	ax,tcp_status		; get tcp status, if any
	call	fdec2di			; write value
	jmp	valtoa90
endif	; no_tcp

valtoa21:cmp	bx,V_parity		; \v(parity)?
	jne	valtoa22		; ne = no
	mov	bx,portval
	mov	bl,[bx].parflg		; parity
	xor	bh,bh
	shl	bx,1			; address words
	cld
	mov	si,parmsgtab[bx]	; offset of parity name string
valtoa21a:lodsb
	stosb
	or	al,al			; end of string?
	jnz	valtoa21a		; nz = no
	mov	word ptr es:[di-1],0020h ; space, null
	jmp	valtoa90

valtoa22:cmp	bx,V_carrier		; \v(carrier)?
	jne	valtoa23		; ne = no
	mov	bl,flags.carrier	; carrier
	and	bl,1			; just one bit
	xor	bh,bh
	shl	bx,1			; address words
	cld
	mov	si,onoffmsgtab[bx]	; offset of carrier string
valtoa22a:lodsb
	stosb
	or	al,al			; end of string?
	jnz	valtoa22a		; nz = no
	mov	word ptr es:[di-1],0020h ; space, null
	jmp	valtoa90

valtoa23:cmp	bx,V_prompt		; \v(prompt)?
	jne	valtoa24		; ne = no
	push	si
	mov	si,prmptr		; current prompt raw text
	cld
valtoa23a:lodsb				; read a byte
	stosb				; store
	or	al,al			; end of string?
	jnz	valtoa23a		; z = no
	pop	si
	dec	di			; don't show trailing null
	mov	word ptr es:[di],0020h	; space, null
	jmp	valtoa90

valtoa24:cmp	bx,V_cps		; \v(cps)?
	jne	valtoa25		; ne = no
	push	di
	mov	di,offset decbuf+200	; must be in DS data seg
	call	shovarcps		; use worker in msssho.asm
	mov	si,offset decbuf+200	; copy this buffer to es:di buffer
	pop	di
	cld
	mov	cx,7			; limit loop
valtoa24a:lodsb				; read result
	or	al,al			; terminator?
	jz	valtoa24b		; z = yes, stop
	stosb
	loop	valtoa24a
valtoa24b:jmp	valtoa90

valtoa25:cmp	bx,V_space		; \v(space)?
	jne	valtoa26		; ne = no
	xor	cx,cx			; drive letter (null means current)
	call	fdskspace		; compute space, get letter into CL
	jnc	valtoa25a		; nc = success
	xor	ax,ax
	xor	dx,dx
valtoa25a:
	push	di
	push	es
	mov	di,ds
	mov	es,di
	mov	di,offset cmdbuf-30-cmdblen
	call	flnout
	mov	dx,offset cmdbuf-30-cmdblen
	call	strlen
	mov	si,dx
	pop	es
	pop	di
	cld
	rep	movsb
	mov	word ptr [di],0020h	; space, null
	jmp	valtoa90

valtoa26:cmp	bx,V_startup		; \v(startup)?
	jne	valtoa27		; ne = no
	push	si
	mov	si,offset startup	; startup directory string
	mov	dx,si
	call	strlen			; get length to cx
	rep	movsb			; copy string
	pop	si
	mov	word ptr es:[di],0020h	; space, null
	jmp	valtoa90

valtoa27:cmp	bx,V_console		; \v(console)?
	jne	valtoa28		; ne = no
	mov	ax,1a00h		; get ANSI.SYS installed state
	int	2fh
	mov	si,offset ansiword	; assume installed
	or	al,al			; installed?
	jnz	valtoa27a		; nz = yes
	mov	si,offset noneword	; say "NONE"
valtoa27a:lodsb				; read a byte
	stosb				; store a byte
	or	al,al			; at end of string?
	jnz	valtoa27a		; nz = no
	mov	word ptr es:[di-1],0020h ; space, null
	jmp	valtoa90

valtoa28:cmp	bx,V_monitor		; \v(monitor)?
	jne	valtoa29		; ne = no
	mov	si,offset colormsg	; assume color monitor
	cmp	crt_mode,7		; mono text
	jne	valtoa28a		; ne = no
	mov	si,offset monomsg	; say mono
valtoa28a:jmp	short valtoa27a		; copy material

valtoa29:cmp	bx,V_cmdlevel		; \v(cmdlevel)?
	jne	valtoa30		; ne = no
	mov	al,taklev		; take level
	xor	ah,ah
	call	fdec2di			; write value
	jmp	valtoa90

valtoa30:cmp	bx,V_input		; \v(input)?
	jne	valtoa31		; ne = no
	push	temp
	push	si
	push	DS
	push	es
	call	buflog			; get INPUT buffer pointers
	mov	ax,es			; seg of input buffer
	pop	es
	jcxz	valtoa30b		; z = empty
	cmp	cx,tbufsiz-2-1		; buffer plus null terminator
	jbe	valtoa30a		; be = enough space to hold text
	mov	cx,tbufsiz-2-1		; limit text
valtoa30a:mov	DS,ax			; ds:si is input buffer
	cld
	rep	movsb
	xor	al,al
	mov	es:[di],al		; null terminator
valtoa30b:pop	DS
	pop	si
	pop	temp
	jmp	valtoa90

valtoa31:cmp	bx,V_query		; \v(query)?
	jne	valtoa32		; ne = no
	mov	word ptr es:[di],0020h 	; space, null
	cmp	queryseg,0		; is there an malloc'd seg to use?
	je	valtoa90		; e = no
	push	es
	mov	si,queryseg
	mov	es,si
	mov	cx,es:[0]		; get length of string
	pop	es
	push	si
	cmp	cx,tbufsiz-2		; greater than current buffer?
	jbe	valtoa31a		; be = no
	push	cx
	mov	ax,[bx].takbuf		; old buffer
	mov	es,ax			; new ES from above
	mov	ah,freemem		; free it
	int	dos
	mov	ax,cx			; bytes wanted
	call	malloc			; get more space
	mov	bx,takadr
	mov	[bx].takbuf,ax		; seg of macro def
	mov	ES,ax			; new ES
	or	[bx].takattr,take_malloc ; remember to dispose via takclos
	pop	cx

valtoa31a:push	ds
	mov	si,queryseg		; get segment of query string
	mov	ds,si
	mov	si,2			; skip count word
	cld
	rep	movsb			; copy to es:di
	pop	ds
	pop	si
	jmp	valtoa90

valtoa32:cmp	bx,V_sysid		; \v(sysid)?
	jne	valtoa33		; ne = no
	mov	ax,'8U'			; always report U8
	stosw
	jmp	valtoa90

valtoa33:cmp	bx,V_charset		; \v(charset)?
	jne	valtoa34		; ne = no
	mov	ax,'PC'
	stosw				; CP prefix
	mov	ax,flags.chrset		; get current Code Page
	call	fdec2di
	jmp	valtoa90

valtoa34:cmp	bx,V_inpath		; \v(inpath)?
	jne	valtoa35		; ne = no
	mov	si,inpath_seg		; get segment of in_path string
	or	si,si			; anything there?
	jz	valtoa34b		; z = no
	push	ds
	mov	ds,si
	xor	si,si
	cld
	lodsw				; get count word
	mov	cx,ax
	cmp	cx,64			; keep it reasonable
	jbe	valtoa34a		; be = ok
	mov	cx,64
valtoa34a:rep	movsb			; copy to es:di
	dec	di			; don't include trailing null from env
	pop	ds
valtoa34b:jmp	valtoa90

valtoa35:cmp	bx,V_disk		; \v(disk)?
	jne	valtoa36		; ne = no
	mov	ah,gcurdsk		; get current disk
	int	dos
	add	al,'A'			; make 1 == A (not zero)
	cld
	stosb
	xor	al,al
	mov	es:[di],al
	jmp	valtoa90

valtoa36:cmp	bx,V_cmdfile		; \v(cmdfile)?
	jne	valtoa37		; ne = no
	mov	si,offset cmdfile	; path of last Take file
	mov	dx,si
	call	strlen
	cld
	rep	movsb
	jmp	valtoa90

valtoa37:cmp	bx,V_inidir		; \v(inidir)?
	jne	valtoa38		; ne = no
	mov	si,offset inidir	; path of mskermit.ini
	mov	dx,si
	call	strlen
	cld
	rep	movsb
	jmp	valtoa90

valtoa38:cmp	bx,V_instatus		; \v(instatus)?
	jne	valtoa39		; ne = no
	mov	ax,input_status		; special INPUT status word
	cmp	ax,0			; negative?
	jge	valtoa38a		; ge = no
	mov	byte ptr es:[di],'-'
	inc	di
	neg	ax
valtoa38a:call	fdec2di
	jmp	valtoa90

valtoa39:cmp	bx,V_minput		; \v(minput)?
	jne	valtoa40		; ne = no
	mov	ax,minpcnt		; get minput match count
	call	fdec2di			; convert to decimal
	jmp	short valtoa90		; done

valtoa40:cmp	bx,V_return		; \v(return)?
	jne	valtoa41		; ne = no
	mov	si,offset retbuf	; <word count><string from RETURN>
	mov	cx,[si]			; get count word
	add	si,2			; point at string
	cld
	rep	movsb			; copy to variable buffer
	jmp	short valtoa90		; done

valtoa41:cmp	bx,V_connection		; \v(connection)?
	jne	valtoa42		; ne = no
	mov	si,offset connmsg	; word "local"
	mov	dx,si
	call	strlen			; length to cx
	cld
	rep	movsb			; copy to variable buffer
	jmp	short valtoa90		; done

valtoa42:cmp	bx,V_filespec		; \v(filespec)?
	jne	valtoa80		; ne = no
	mov	si,offset vfile		; last used file transfer name
	mov	dx,si
	call	strlen			; length to cx
	cld
	rep	movsb			; copy to variable buffer
	jmp	short valtoa90		; done

valtoa80:push	bx			; \m(macro_name)
	push	es
	mov	di,bx			; save seg of macro def
	mov	bx,takadr
	test	[bx].takattr,take_malloc ; buffer already allocated?
	jz	valtoa80a		; z = no
	push	es
	mov	ax,[bx].takbuf		; old buffer
	or	ax,ax			; if any allocated
	jz	valtoa80b		; z = none
	mov	es,ax
	mov	ah,freemem		; free it
	int	dos
valtoa80b:and	[bx].takattr,not take_malloc ; say no more freeing needed
	pop	es
valtoa80a:
	mov	[bx].takbuf,di		; seg of macro def
	mov	[bx].takptr,2		; offset of two
	mov	es,di
	mov	cx,es:[0]		; get length of string
	pop	es
	pop	bx
	pop	dx
	pop	di
	mov	di,cx			; report length in di
	clc
	ret
valtoa90:pop	dx			; trailing space flag
	or	dx,dx			; leave the spaces?
	jnz	valtoa91		; nz = yes
	cmp	word ptr es:[di-1],0020h ; trailing space?
	jne	valtoa91		; ne = no
	dec	di			; remove space
valtoa91:pop	ax			; saved starting di
	sub	di,ax			; di = length of the buffer contents
	clc
	ret
valtoa	endp

; Far callable version
fvaltoa	proc	far
	call	valtoa
	ret
fvaltoa	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.
; BX has keyword value (table envtab)
; If these fail they consume their text quietly.
evaltoa	proc	near
	push	dx			; save trailing space flag
	push	si
	push	temp			; save work variable
	mov	al,comand.cmdonum
	push	ax
	mov	comand.cmdonum,0	; kill \number conversion
	call	evarg			; get argument array
	pop	ax
	mov	comand.cmdonum,al	; restore \number conversion state
	mov	ax,valtmp		; where '\fname' started
	sub	ax,2			; back over \f
	mov	cmwptr,ax		; where to write new output
        mov     cmrptr,ax               ; readjust read pointer too
	call	takopen_sub		; open take as text substitution
	jnc	evalt5c			; nc = success
evalt5b:jmp	evalt99			; fail
evalt5c:mov	bx,takadr		; Take structure
	mov	ax,tbufsiz		; bytes of buffer space wanted
	call	malloc
	jc	evalt5b			; c = failed
	mov	[bx].takbuf,ax		; seg of allocated buffer
	or	[bx].takattr,take_malloc ; remember to dispose via takclos
	mov	es,ax
	mov	word ptr es:[0],tbufsiz
	mov	di,[bx].takptr		; where to start writing
	mov	[bx].takcnt,0		; number of unread bytes
	mov	[bx].takper,0
	cmp	evaltype,F_contents	; \fcontents(macro)?
	je	evalt5d			; e = yes
	cmp	evaltype,F_definition	; \fdefinition(macro)?
	je	evalt5d			; e = yes
	cmp	evaltype,F_literal	; \fliteral(string)?
	jne	evalt5e			; ne = no
evalt5d:mov	[bx].takper,1		; treat macro names as literals

evalt5e:mov	bx,takadr
	mov	di,[bx].takptr		; destination for replacment text
	cmp	evaltype,F_length	; \flength(text)?
	jne	evalt6			; ne = no
	mov	ax,arglen		; length of variable name
	call	fdec2di			; convert to ASCII string
	mov	bx,takadr
	sub	di,[bx].takptr		; end minus start
	mov	[bx].takcnt,di		; string length
	jmp	evalt99

evalt6:	cmp	evaltype,F_upper	; \fupper(text)?
	je	evalt6a			; e = yes
	cmp	evaltype,F_lower	; \flower(text)?
	jne	evalt7			; ne = no
evalt6a:mov	si,argptr		; point to argument
	mov	cx,arglen		; length of string
	jcxz	evalt6e			; z = empty
	cld
evalt6b:lodsb				; read from parse buffer
	cmp	evaltype,F_lower	; to lower?
	ja	evalt6c			; a = no, upper
	call	tolowr			; move to lower case
	jmp	short evalt6d
evalt6c:call	toupr			; move to upper case
evalt6d:stosb				; write byte to Take buffer
	loop	evalt6b
evalt6e:mov	bx,takadr
	mov	cx,arglen		; argument length
	mov	[bx].takcnt,cx		; count entered bytes
	jmp	evalt99

evalt7:	cmp	evaltype,F_char		; \fcharacter(n)?
	jne	evalt8			; ne = no
	mov	si,argptr		; point at text of number
	mov	domath_ptr,si
	mov	ax,arglen
	mov	domath_cnt,ax
	call	domath
	jc	evalt7d			; c = failed
	cld
	stosb				; store single byte
	mov	bx,takadr
	mov	[bx].takcnt,1		; one byte as result
evalt7d:jmp	evalt99

evalt8:	cmp	evaltype,F_substr	; \fsubstr(text, n1, n2)?
	jne	evalt9			; ne = no
	xor	ax,ax
	mov	si,argptr[2]		; point to n1 string
	mov	domath_ptr,si
	mov	ax,arglen[2]
	mov	domath_cnt,ax
	call	domath
	jnc	evalt8g			; nc = got a number
evalt8f:xor	ax,ax
	xor	dx,dx
	jmp	short evalt8a
evalt8g:or	dx,dx			; number overflowed to high word?
	jnz	evalt8f			; nz = yes, reset number to zero
	or	ax,ax			; zero?
	jz	evalt8a			; z = yes
	dec	ax			; count from 0 internally
evalt8a:mov	si,argptr		; point at text
	add	si,ax			; point at text[n1]
	mov	cx,arglen		; length of 'text'
	sub	cx,ax			; bytes remaining in 'text'
	jle	evalt8d			; le = nothing left to extract
	push	si
	mov	si,argptr[4]		; point to n2 string
	mov	domath_ptr,si
	mov	ax,arglen[4]
	mov	domath_cnt,ax
	call	domath
	pop	si
	jnc	evalt8b			; nc = got a number
	mov	ax,arglen		; default to full string
	xor	dx,dx
evalt8b:or	dx,dx			; number overflowed to high word?
	jnz	evalt8d			; nz = yes
	cmp	cx,ax			; length available more than needed?
	jbe	evalt8c			; be = no
	mov	cx,ax			; use smaller n2
evalt8c:mov	bx,tbufsiz-2		; unused buffer capacity (tbufsiz-2)
	cmp	cx,bx			; n larger than buffer?
	jbe	evalt8e			; be = no
	mov	ax,cx			; remember amount wanted
	call	evmem			; get more memory, want CX bytes
	xchg	ax,cx			; now ax=amount available, cx=wanted
	cmp	cx,ax			; wanted > available?
	jbe	evalt8e			; be = no
	mov	cx,ax			; limit to available memory
evalt8e:mov	bx,takadr
	mov	[bx].takcnt,cx		; count of bytes
	cld
	rep	movsb			; copy bytes to Take buffer
evalt8d:jmp	evalt99

evalt9:	cmp	evaltype,F_right	; \fright(text, n)?
	jne	evalt10			; ne = no
	mov	si,argptr[2]		; point to n string
	mov	domath_ptr,si
	mov	ax,arglen[2]
	or	ax,ax			; empty field?
	jz	evalt9d			; z = yes, use whole string
	mov	domath_cnt,ax
	call	domath
	cmp	domath_cnt,0
	je	evalt9a			; e = consummed whole string
	mov	arglen,0		; force 0
evalt9d:mov	ax,arglen		; default to full string
	xor	dx,dx
evalt9a:or	dx,dx			; number overflowed to high word?
	jnz	evalt9c			; nz = yes
	mov	cx,arglen		; length of 'text'
	cmp	cx,ax			; length available more than needed?
	jbe	evalt9b			; be = no
	mov	cx,ax			; use smaller n
evalt9b:mov	si,argptr		; start of 'text'
	add	si,arglen		; point at last + 1 byte of 'text'
	sub	si,cx			; minus bytes to be copied
	mov	bx,takadr
	mov	[bx].takcnt,cx		; count of bytes
	cld
	rep	movsb			; copy bytes to Take buffer
evalt9c:jmp	evalt99

evalt10:cmp	evaltype,F_literal	; \fliteral(text)?
	jne	evalt11			; ne = no
	mov	si,argptr		; start of string
	mov	cx,arglen		; length of text (inc leading spaces)
	mov	bx,takadr
	mov	[bx].takcnt,cx		; count of bytes
	cld
	rep	movsb			; copy bytes to Take buffer
	jmp	evalt99

evalt11:cmp	evaltype,F_rpad		; \frpad(text, n, c)?
	jne	evalt12
	mov	si,argptr[2]		; get n
	mov	domath_ptr,si
	mov	ax,arglen[2]
	mov	domath_cnt,ax
	call	domath
	jc	evalt11d		; c = error
	or	dx,dx			; numeric overflow to high word?
	jne	evalt11d		; ne = yes
	mov	bx,takadr
	mov	cx,tbufsiz-2		; unused buffer capacity (tbufsiz-2)
	cmp	ax,cx			; n larger than buffer?
	jbe	evalt11a		; be = no
	call	evmem			; get more memory
	jc	evalt11d		; c = fail
	cmp	ax,cx			; enough?
	jbe	evalt11a		; be = yes
	mov	ax,cx
evalt11a:mov	cx,arglen		; length of text
	cmp	ax,cx			; field (n) shorter than text?
	jae	evalt11b		; ae = no, use full text
	mov	cx,ax			; copy just n of text
evalt11b:sub	ax,cx			; available minus used bytes
	mov	bx,takadr
	mov	[bx].takcnt,cx		; count of bytes
	mov	si,argptr		; text
	cld
	rep	movsb			; copy bytes to Take buffer
	mov	cx,ax			; padding bytes
	jcxz	evalt11d		; z = none
	add	[bx].takcnt,cx		; increase count of bytes
	mov	bx,argptr+4		; point to c
	mov	al,[bx]			; padding character, if any
	cmp	arglen+4,0		; any char given?
	jne	evalt11c		; ne = yes
	mov	al,' '			; else default to space
evalt11c:cld
	rep	stosb			; append byte to Take buffer
evalt11d:jmp	evalt99

evalt12:cmp	evaltype,F_lpad		; \flpad(text, n, c)?
	jne	evalt13
	push	si
	mov	si,argptr[2]		; get n
	mov	domath_ptr,si
	mov	ax,arglen[2]
	mov	domath_cnt,ax
	call	domath
	pop	si
	jc	evalt12e		; c = error
	or	dx,dx			; numeric overflow to high word?
	jne	evalt12e		; ne = yes
	mov	bx,takadr
	mov	cx,tbufsiz-2		; unused buffer capacity (tbufsiz-2)
	cmp	ax,cx			; n larger than buffer?
	jbe	evalt12a		; be = no
	call	evmem			; get more memory
	cmp	ax,cx			; wanted > available?
	jbe	evalt12a		; be = no
	mov	ax,cx			; limit text
evalt12a:sub	ax,arglen		; n - length of 'text'
	jns	evalt12b		; ns = no underflow
	xor	ax,ax			; else omit padding
evalt12b:mov	cx,ax			; padding count
	mov	[bx].takcnt,cx		; count of bytes
	mov	bx,argptr+4		; point to c
	mov	al,[bx]			; padding character, if any
	cmp	arglen+4,0		; any char given?
	jne	evalt12c		; ne = yes
	mov	al,' '			; default to space
evalt12c:cld
	rep	stosb			; copy byte to Take buffer
	mov	cx,arglen		; length of text
	mov	cx,tbufsiz-2		; buffer capacity
	mov	bx,takadr
	sub	cx,[bx].takcnt		; minus bytes written so far
	mov	ax,arglen		; length of 'text'
	cmp	ax,cx			; n larger than buffer?
	jbe	evalt12d		; be = no
	mov	ax,cx
evalt12d:mov	cx,ax			; append count
	mov	bx,takadr
	add	[bx].takcnt,cx		; increase count of bytes
	mov	si,argptr		; start of text
	cld
	rep	movsb			; append byte to Take buffer
evalt12e:jmp	evalt99

evalt13:cmp	evaltype,F_code		; \fcode(char)?
	jne	evalt14			; ne = no
	mov	bx,argptr		; point to char address
	mov	al,[bx]			; original char
	xor	ah,ah
	call	fdec2di			; convert to ASCII string, no '\'
	mov	bx,takadr		;   prefix
	sub	di,[bx].takptr		; end minus start
	mov	[bx].takcnt,di		; string length
	jmp	evalt99

evalt14:cmp	evaltype,F_definition	; \fdefinition(macro)?
	je	evalt14i		; e = yes
	cmp	evaltype,F_contents	; \fcontents(macro)
	jne	evalt15
evalt14i:cmp	arglen,0		; any name?
	jne	evalt14a		; e = yes
	jmp	evalt14x		; fail
evalt14a:mov	si,argptr		; trim trailing spaces from user name
	mov	cx,arglen		; length of raw user string
	mov	bx,si
	add	bx,cx
evalt14j:cmp	byte ptr [bx-1],' '	; trailing space?
	jne	evalt14k		; ne = no
	dec	arglen			; remove it
	dec	bx			; preceeding char
	loop	evalt14j
evalt14k:
	mov	si,offset mcctab	; table of macro names
	cld
	lodsb
	mov	cl,al			; number of macro entries
	xor	ch,ch
	jcxz	evalt14x		; z = none
evalt14b:push	cx			; save loop counter
	lodsw				; length of macro name
	mov	cx,arglen		; length of user's string
	cmp	ax,cx			; mac name shorter that user spec?
	jb	evalt14d		; b = yes, no match
	push	ax
	push	si			; save these around match test
	push	di
	mov	di,argptr		; user's string
evalt14c:mov	ah,[di]
	inc	di
	lodsb				; al = mac name char, ah = user char
	and	ax,not 2020h		; clear bits (uppercase chars)
	cmp	ah,al			; same?
	loope	evalt14c		; while equal, do more
	pop	di
	pop	si			; restore regs
	pop	ax
	je	evalt14e		; e = a match
evalt14d:add	si,ax			; point to next name, add name length
	add	si,2			;  and string pointer
	pop	cx			; recover loop counter
	loop	evalt14b		; one less macro to examine
evalt14x:jmp	evalt99

evalt14e:pop	cx			; pop loop counter above
	cmp	byte ptr[si],0		; name starts with null char?
	jne	evalt14f		; ne = no
	jmp	evalt99			; yes, TAKE file, ignore
evalt14f:mov	ax,[si-2]		; length of macro name
	add	si,ax			; skip over name
	push	es
	mov	es,[si]			; segment of string structure
	xor	si,si			; es:si = address of count + string
	mov	ax,es
	mov	cx,es:[si]		; length of string
	mov	arglen+2,cx		; save length here
	mov	argptr+2,ax		; save es of es:si here
	pop	es
	call	evmem			; get new memory, set new ES:DI
	cmp	cx,arglen+2		; enough to hold material?
	jae	evalt14h		; ae = yes
	mov	arglen+2,cx		; shrink string size too

evalt14h:push	ds
	mov	bx,takadr
	mov	cx,arglen+2		; length of string
	mov	[bx].takcnt,cx		; macro length
	mov	[bx].takptr,2		; offset of text in destination
	mov	ax,argptr+2		; seg of string
	mov	ds,ax
	mov	si,2			; offset of string
	cld
	rep	movsb			; copy string
	pop	ds
	jmp	evalt99

evalt15:cmp	evaltype,F_maximum	; \fmaximum(n1, n2)?
	je	evalt15a		; e = yes
	cmp	evaltype,F_minimum	; \fminimum(n1, n2)?
	jne	evalt16			; ne = no
evalt15a:push	si
	mov	si,argptr[0]		; point to n1 string
	mov	domath_ptr,si
	mov	ax,arglen[0]
	mov	domath_cnt,ax
	call	domath
	pop	si
	jc	evalt15x		; c = failure
	push	ax			; save result
	push	dx
	push	si
	mov	si,argptr[2]		; point to n2 string
	mov	domath_ptr,si
	mov	ax,arglen[2]
	mov	domath_cnt,ax
	call	domath
	pop	si
	pop	cx			; high first value
	pop	bx			; low first value
	jc	evalt15x		; c = failure
	mov	temp,0			; assume reporting n1, subscript 0
	cmp	cx,dx			; n1 > n2?
	jg	evalt15e		; g = yes
	jl	evalt15d		; l = no, but less than
	cmp	bx,ax			; low order n1 >= n2?
	jge	evalt15e		; ge = yes
evalt15d:mov	temp,2			; say n2 is larger
evalt15e:cmp	evaltype,F_maximum	; return max of the pair?
	je	evalt15f		; e = yes
	xor	temp,2			; change subscript
evalt15f:push	si
	mov	bx,temp			; get subscript of reportable
	mov	si,argptr[bx]
	mov	cx,arglen[bx]
	cld
	rep	movsb			; copy original string
	xor	al,al
	stosb				; and null terminate
	pop	si
	mov	bx,takadr
	sub	di,[bx].takptr		; bytes consumed
	mov	[bx].takcnt,di
evalt15x:jmp	evalt99

evalt16:cmp	evaltype,F_index	; \findex(pat, string, [offset])
	je	evalt16common
	cmp	evaltype,F_rindex	; \frindex(pat, string, [offset])
	jne	evalt17
evalt16common:				; used for \frindex too
	cmp	arglen+4,0		; optional offset given?
	je	evalt16a		; e = no, use userlevel 1
	push	si
	mov	si,argptr[4]		; evaluate optional offset
	mov	domath_ptr,si
	mov	ax,arglen[4]
	mov	domath_cnt,ax
	call	domath
	pop	si
	jnc	evalt16b		; nc = got a number
evalt16a:mov	ax,1			; default to one (user style)
	xor	dx,dx
evalt16b:or	dx,dx			; too large?
	jnz	evalt16x		; nz = too large, fail
	dec	ax			; offset from start (0 base it)
	mov	temp,ax			; remember offset
	cmp	evaltype,F_rindex	; \frindex?
	jne	evalt16g		; ne = no
	mov	cx,arglen+2		; length of string
	sub	cx,arglen		; minus length of pattern
	sub	cx,ax			; minus displacement from right
	mov	temp,cx			; new effective offset
	mov	ax,cx
evalt16g:
	push	es
	push	di
	mov	di,ds			; string is in DS seg
	mov	es,di
	mov	cx,arglen+2		; length of string
	sub	cx,arglen		; minus length of pattern
	cmp	ax,cx			; offset larger than this?
	jbe	evalt16c		; be = no
	mov	temp,-1			; to report zero
	jmp	short evalt16e		;  fail
evalt16c:mov	si,argptr		; pattern
	mov	di,argptr+2		; string
	add	di,temp			; plus offset
	mov	cx,arglen		; pattern length
	mov	ax,cx
	add	ax,temp			; plus offset
	cmp	ax,arglen+2		; more than string?
	jbe	evalt16d		; be = no, keep going
	mov	temp,-1			; to report zero
	jmp	short evalt16e		; a = no match
evalt16d:push	cx
	cld
	repe	cmpsb			; compare strings
	pop	cx
	je	evalt16e		; e = matched
	inc	temp			; move pattern right one place
	cmp	evaltype,F_rindex	; \frindex?
	jne	evalt16c		; ne = no
	sub	temp,2			; work to the left instead
	jmp	short evalt16c		; try again
evalt16e:pop	di
	pop	es
	mov	ax,temp			; report out number
	inc	ax			; show 0 as 1 to user
	mov	bx,takadr
	call	fdec2di			; binary to ASCIIZ
	mov	bx,takadr
	sub	di,[bx].takptr
	mov	[bx].takcnt,di		; length of ASCIIZ result
evalt16x:jmp	evalt99

evalt17:cmp	evaltype,F_repeat	; \frepeat(text,n)?
	jne	evalt18			; ne = no
	cmp	arglen+2,0		; number given?
	je	evalt17g		; e = no, fail
	mov	si,argptr[2]		; n
	mov	domath_ptr,si
	mov	ax,arglen[2]
	mov	domath_cnt,ax
	call	domath
	jc	evalt17g		; c = fail
	or	dx,dx			; number overflowed?
	jz	evalt17a		; z = no
	mov	ax,1			; default number
evalt17a:mov	arglen+2,ax		; save reasonable value here
	mul	arglen			; string length * repeats
	or	dx,dx			; overflowed (> 64KB)?
	jnz	evalt17b		; nz = yes
	cmp	ax,cmdblen		; more than parse buffer?
	jbe	evalt17c		; be = no
evalt17b:mov	ax,cmdblen		; should be plenty (1000)
evalt17c:mov	cx,ax			; bytes wanted
	call	evmem			; allocate memory 
	mov	dx,cx			; buffer length available
evalt17d:mov	cx,arglen		; length of text
	cmp	cx,dx			; length vs buffer capacity
	jbe	evalt17e		; be = capacity exceeds string
	mov	cx,dx			; chop string to fit
evalt17e:sub	dx,cx			; deduct amount done
	mov	si,argptr		; point at string
	cld
	rep	movsb
	dec	arglen+2		; repeat count
	cmp	arglen+2,0		; any more repeats to do?
	je	evalt17f		; e = no
	or	dx,dx			; any space left?
	jg	evalt17d		; g = yes
evalt17f:mov	bx,takadr
	sub	di,[bx].takptr		; end minus start
	mov	[bx].takcnt,di		; string length
evalt17g:jmp	evalt99

evalt18:cmp	evaltype,F_reverse	; \freverse(text)?
	jne	evalt19			; ne = no
	mov	cx,arglen		; length of string
	mov	si,argptr		; string
	add	di,cx
	dec	di			; last byte in output string
	mov	bx,takadr
	mov	[bx].takcnt,cx		; length of output to buffer
	jcxz	evalt18b		; z = empty string
evalt18a:cld
	lodsb				; read left
	std
	stosb				; write left, displaced, backward
	cld
	loop	evalt18a
evalt18b:jmp	evalt99

evalt19:cmp	evaltype,F_date		; \fdate(filename)?
	je	evalt19a		; e = yes
	cmp	evaltype,F_size		; \fsize(filename)?
	jne	evalt20			; ne = no
evalt19a:push	di
	mov	di,offset tmpbuf	; work buffer in this data seg
	mov	byte ptr [di],0		; terminator
	call	filedate		; get info
	mov	dx,offset tmpbuf
	call	strlen			; get length of results to CX
	pop	di
	mov	bx,takadr
	mov	[bx].takcnt,cx		; length of results
	mov	si,offset tmpbuf
	cld
	rep	movsb			; copy to Take buffer
	jmp	evalt99

evalt20:cmp	evaltype,F_files	; \ffiles(filespec)?
	jne	evalt21			; ne = no
	mov	temp,0			; count found files
	call	filedate		; find first
	jc	evalt20d		; c = none
	push	di
	push	es
	inc	temp			; count found file
	mov	dx,offset fileio.dta	; point at dta
	mov	ah,setdma		; set the dta address
	int	dos
evalt20b:mov	ah,next2		; DOS 2.0 search for next
	int	dos
	jc	evalt20c		; c = no more
	inc	temp			; count found file
	jmp	short evalt20b		; try for next
evalt20c:mov	ah,setdma		; restore dta
	mov	dx,offset buff
	int	dos
	pop	es
	pop	di
	call	filedate		; go back to find first again
evalt20d:mov	ax,temp			; count of files found
	call	fdec2di			; convert to ASCII string
	mov	bx,takadr
	sub	di,[bx].takptr		; end minus start
	mov	[bx].takcnt,di		; string length
	jmp	evalt99

evalt21:cmp	evaltype,F_nextfile	; \fnextfile()?
	jne	evalt24			; ne = no
	mov	si,offset fileio.fname	; current filename from DOS
	mov	dx,si
	call	strlen			; length of name
	mov	bx,takadr
	mov	[bx].takcnt,cx		; length of result
	rep	movsb			; copy to Take buffer
	push	di
	push	es
	mov	dx,offset fileio.dta	; point at dta
	mov	ah,setdma		; set the dta address
	int	dos
	mov	ah,next2		; DOS 2.0 search for next
	int	dos
	mov	ah,setdma		; restore dta
	mov	dx,offset buff
	int	dos
	pop	es
	pop	di
evalt21b:jmp	evalt99

evalt24:cmp	evaltype,F_replace	; \freplace(source,pat,replacement)?
	jne	evalt25			; ne = no
	cmp	arglen+2,0		; arg2 omitted?
	jne	evalt24a		; ne = no
	mov	cx,arglen		; source length
	mov	si,argptr		; source
	jmp	evalt24g		; copy source to output

evalt24a:push	es			; provided Take buffer, save
	push	di
	mov	ax,seg decbuf		; use local temp buf
	mov	es,ax
	mov	di,offset decbuf	; as es:di
	mov	si,argptr		; make source ds:si
	mov	cx,arglen		; length of source
	cld
evalt24b:push	cx			; save source counter
	push	si			; save source pointer
	cmp	cx,arglen+2		; fewer source bytes than pattern?
	jb	evalt24e		; b = yes, no replacement possible
	mov	bx,argptr+2		; pattern
	mov	cx,arglen+2		; length of pattern

evalt24c:mov	ah,[bx]			; pattern byte
	cmp	[si],ah			; same as source byte?
	jne	evalt24e		; ne = no, no match
	inc	si			; next bytes to match
	inc	bx
	loop	evalt24c		; do all pattern bytes
	mov	si,argptr+4		; get replacement pattern
	mov	cx,arglen+4		; its length
	mov	ax,di			; starting offset in temp buffer
	sub	ax,offset decbuf	; minus start of buffer
	add	ax,cx			; count of bytes to be in buffer
	cmp	ax,decbuflen		; longer than buffer?
	jbe	evalt24d		; be = no overflow
	sub	ax,cx			; get back bytes already in buffer
	sub	ax,decbuflen
	neg	ax			; bytes available
	mov	cx,ax			; move just that many
evalt24d:rep	movsb			; copy to output (may be nothing)
	pop	si
	pop	cx
	add	si,arglen+2		; length of pattern
	sub	cx,arglen+2		; bytes left in source
	jmp	short evalt24f

evalt24e:pop	si			; mismatch comes here
	pop	cx
	movsb				; write source byte to output buffer
	dec	cx			; one less source byte
evalt24f:or	cx,cx			; qty of source bytes remaining
	jg	evalt24b		; g = more source bytes to examine
	sub	di,offset decbuf	; length of output material
	mov	cx,di
	mov	ax,cx			; save length in ax
	pop	di
	pop	es			; original Take buffer
	call	evmem			; allocate new Take buffer, len cx
	mov	si,offset decbuf
	mov	cx,ax			; length used in decbuf
evalt24g:cld
	rep	movsb			; copy decbuf to Take buffer
	mov	bx,takadr
	sub	di,[bx].takptr
	mov	[bx].takcnt,di		; length of ASCIIZ result
	jmp	evalt99

evalt25:cmp	evaltype,F_eval		; \feval(string)?
	jne	evalt26			; ne = no
	mov	ax,argptr
	mov	domath_ptr,ax
	mov	ax,arglen
	or	ax,ax
	jz	evalt25b		; z = no argument
	mov	domath_cnt,ax
	call	domath			; return value in DX:AX
	jc	evalt25b		; c = error, no value will be written
	push	di			; save string destination es:di
	mov	di,offset decbuf	; temp work space
	mov	word ptr [di],0		; clear it
	or	dx,dx			; is result negative?
	jns	evalt25a		; ns = no, positive or zero
	neg	dx			; flip sign
	neg	ax
	sbb	dx,0
	mov	byte ptr [di],'-'	; show minus sign
	inc	di

evalt25a:call	flnout			; convert DX:AX to ASCIIZ in DS:DI
	pop	di			; recover original di
	mov	dx,offset decbuf
	mov	si,dx			; save as source pointer too
	call	strlen			; get length of string to cx
	cld
	rep	movsb			; copy to final buffer
	mov	bx,takadr
	sub	di,[bx].takptr		; end minus start
	mov	[bx].takcnt,di		; string length
evalt25b:jmp	evalt99

evalt26:cmp	evaltype,F_verify	; \fverify(pattern,string,offset)?
	jne	evalt27			; ne = no
	cld
	push	es
	push	di
	mov	si,ds
	mov	es,si
	mov	di,argptr		; pattern pointer
	mov	si,argptr+4		; offset
	mov	ax,arglen+4		; length of offset string
	call	domath
	jc	evalt26b		; c = error
	mov	bx,ax			; offset
	mov	si,argptr+2		; string
	add	si,bx			; string plus offset
	mov	cx,arglen+2		; length of string
	sub	cx,bx			; minus offset
	jg	evalt26a		; g = have string left to compare
	mov	bx,-1			; error, report -1 for no string
	jmp	short evalt26b
evalt26a:push	di
	lodsb				; get a byte of string
	inc	bx			; count based 1 for users
	push	cx			; one less string byte
	mov	cx,arglen		; length of pattern
	repne	scasb			; scan for match
	pop	cx
	pop	di
	jne	evalt26b		; ne = mismatch
	loop	evalt26a		; next string char
	xor	bx,bx			; report 0 if all match
evalt26b:mov	ax,bx			; char position of first mismatch
	pop	di
	pop	es
	call	fdec2di			; convert to ASCII string
	mov	bx,takadr
	sub	di,[bx].takptr		; end minus start
	mov	[bx].takcnt,di		; string length
	jmp	evalt99

evalt27:cmp	evaltype,F_ipaddr	; \fipaddr(string, offset)?
	jne	evalt29			; ne = no
	mov	si,argptr+2		; offset
	mov	ax,arglen+2		; length of offset string
	mov	domath_ptr,si		; convert offset to binary
	mov	domath_cnt,ax
	call	domath			; failure means use zero
	add	argptr,ax
	sub	arglen,ax
evalt27a:mov	si,argptr		; scan string
	mov	cx,arglen
	cmp	cx,7			; enough bytes to qualify?
	jl	evalt27x		; l = no, quit
	cld
evalt27b:lodsb				; trim leading spaces
	sub	al,'0'			; remove ASCII bias
	cmp	al,9			; numeric?
	jbe	evalt27c		; be = yes
	loop	evalt27b
evalt27c:dec	si			; break char
	inc	cx			; byte count remaining
	mov	argptr,si		; remember start of real text
	mov	arglen,cx		; and its length
	call	evalt27w		; scan for digits
	jc	evalt27x		; c = fail
	cmp	byte ptr [si],'.'	; looking at dot now?
	jne	evalt27x		; ne = fail
	inc	si
	call	evalt27w		; scan for digits
	jc	evalt27x		; c = fail
	cmp	byte ptr [si],'.'	; looking at dot now?
	jne	evalt27x		; ne = fail
	inc	si
	call	evalt27w		; scan for digits
	jc	evalt27x		; c = fail
	cmp	byte ptr [si],'.'	; looking at dot now?
	jne	evalt27x		; ne = fail
	inc	si
	call	evalt27w		; scan for digits
	jc	evalt27x		; c = fail
	mov	al,[si]			; break byte
	sub	al,'0'			; remove ASCII bias
	cmp	al,9
	jbe	evalt27x		; be = is still numberic, fail
	mov	cx,si			; break postion
	sub	cx,argptr		; minus start
	jle	evalt27x		; le = problems, fail
	mov	si,argptr		; start
	rep	movsb			; copy string to destination
	mov	bx,takadr
	sub	di,[bx].takptr		; end minus start
	mov	[bx].takcnt,di		; string length
	jmp	evalt99

evalt27x:inc	argptr			; step to next source byte
	dec	arglen			; one less to examine
	cmp	arglen,7		; any string left?
	jge	evalt27a		; ge = yes, try again
	jmp	evalt99

evalt27w proc	near			; worker to read digits, check range
	mov	cx,3			; three digits
	xor	dx,dx			; value of digits
evalt27w1:
	mov	ax,dx
	mul	ten			; previous times ten to ax
	mov	dx,ax
	lodsb
	sub	al,'0'			; remove ASCII bias
	cmp	al,9			; validate decimal
	ja	evalt27w2		; a = no
	add	dl,al			; number so far
	jc	evalt27w3		; c = overflow, fail
	loop	evalt27w1		; while in digits
	inc	si			; inc to offset dec below
evalt27w2:
	dec	si			; back up to break byte
	cmp	cx,3			; must have at least one digit
	je	evalt27w3		; e = none, fail
	clc				; success, have digits
	ret
evalt27w3:
	stc				; fail
	ret
evalt27w endp

evalt29:cmp	evaltype,F_tod2secs	; \ftod2secs(hh:mm:ss)?
	jne	evalt30			; ne = no
	mov	si,argptr		; hh:mm:ss string
	mov	bx,arglen
	mov	byte ptr [si+bx],0	; terminate string
	call	tod2secs		; convert to ASCII long in es:di
	jc	evalt99			; c = failed to convert
	mov	bx,takadr
	sub	di,[bx].takptr		; end minus start
	mov	[bx].takcnt,di		; string length
	jmp	evalt99

evalt30:cmp	evaltype,F_chksum	; \fchecksum(string)?
	jne	evalt31
	mov	si,argptr		; string
	mov	cx,arglen
	xor	bx,bx			; running sum, low and high portions
	xor	dx,dx
	cld
evalt30a:lodsb
	add	bl,al			; accumulate checksum
	adc	bh,0			; with carry
	adc	dx,0
	loop	evalt30a
	mov	ax,bx
	push	di
	push	es
	mov	di,ds
	mov	es,di
	mov	di,offset argptr
	call	flnout			; 32 bit converter
	mov	dx,offset argptr
	call	strlen
	mov	si,dx
	pop	es
	pop	di
	cld
	rep	movsb
	mov	bx,takadr
	sub	di,[bx].takptr		; end minus start
	mov	[bx].takcnt,di		; string length
	jmp	evalt99

evalt31:cmp	evaltype,F_basename	; \fbasename(string)?
	jne	evalt99
	mov	dx,argptr		; string
	mov	cx,arglen
	mov	si,dx
	add	si,cx
	mov	byte ptr [si],0		; force null termination
	push	di
	mov	di,offset decbuf+100	; place for path part
	mov	si,offset decbuf	; place for filename part
	call	fparse			; split pieces
	pop	di
	mov	dx,si			; look only at filename
	call	strlen
	rep	movsb			; copy to result buffer
	mov	bx,takadr
	sub	di,[bx].takptr		; end minus start
	mov	[bx].takcnt,di		; string length
	jmp	evalt99

evalt99:pop	temp
	pop	si
	pop	dx			; trailing space flag
	clc				; success or fail, consume source
	ret
evaltoa	endp

; Worker for evaltoa. 
; Given start of string in DS:SI and string length in CMSIZ.
; Return pointers to up to three arguments (as offset of start of their
; non-white space) and the lengths of each argument field. Arrays argptr
; and arglen hold these 16 bit values.
; Bare commas separate arguments, curly braces and parentheses protect commas,
; curly braces protect strings, starting with a curly brace is considered to 
; mean use material within braces. A closing curly brace closes parens.
evarg	proc	near
	push	ax
	push	bx
	push	cx
	push	dx
	push	si
	push	temp
	mov	al,taklev
	xor	ah,ah
	mov	temp,ax
	xor	ax,ax
	mov	argptr,ax		; clear arg pointer list
	mov	argptr+2,ax
	mov	argptr+4,ax
	mov	arglen,ax		; clear arg length list
	mov	arglen+2,ax
	mov	arglen+4,ax
	xor	bx,bx			; index of argument
					; read start of argument
evarg10:mov	si,cmrptr		; last byte + 1 read
	xor	dx,dx			; paren and curly brace counters
	mov	argptr[bx],si		; where argument string starts
	mov	cmsiz,0			; argument length counter

evarg12:mov	cl,comand.cmper		; read next argument byte
	push	cx			; preserve comand.cmper around call
	push	temp			; preserve take level monitor
	push	evaltype		; preserve, reading may recurse
	push	bx			; preserve argument counter
	push	dx			; preserve curly brace counter
	push	cmsiz
	mov	cmsflg,0		; see leading spaces/tabs
	push	argptr			; save our working variables
	push	argptr+2
	push	argptr+4
	push	arglen
	push	arglen+2
	push	arglen+4
	cmp	evaltype,F_contents	; \fcontents(macro)?
	je	evarg13			; e = yes
	cmp	evaltype,F_literal	; \fliteral(string)?
	jne	evarg14			; ne = no
evarg13:mov	comand.cmper,1		; arg, treat macros as literals
evarg14:call	cmgtch			; recursively read a character into ah
	pop	arglen+4
	pop	arglen+2
	pop	arglen
	pop	argptr+4
	pop	argptr+2
	pop	argptr
	pop	cmsiz
	pop	dx
	pop	bx
	pop	evaltype
	pop	temp
	pop	cx
	mov	comand.cmper,cl		; restore macro expansion state
	pushf				; save carry flag from cmgtch
	inc	cmsiz			; count argument byte
	push	bx
	mov	bl,taklev		; current take level
	cmp	bl,byte ptr temp	; react to specials?
	pop	bx
	jbe	evarg15			; be = yes, else in macro/take
	popf				; clear stack of cmgtch carry status
	jmp	evarg12			; read another byte

evarg15:popf				; recover cmgtch carry status
	jnc	evarg50			; nc = non-terminator
	cmp	ah,' '			; just a space?
	jne	evarg17			; ne = no
	cmp	cmsiz,1			; is it a leading space?
	jne	evarg12			; ne = no, consider it to be data
	cmp	evaltype,F_literal	; \fliteral(string)?
	je	evarg12			; e = yes, keep leading spaces
	jmp	evarg10			; skip space, get first arg byte
	
evarg17:cmp	ah,'?'			; need help?
	jne	evarg20			; ne = no
	call	fcmdhlp			; compute cmhlp to proper string
	mov	cmsiz,0			; so help is with provided text
	call	cmkyhlp
	jmp	repars

evarg20:dec	cmsiz			; omit byte from count
	cmp	ah,escape		; ESC?
	jne	evarg22			; ne = no
	cmp	evaltype,F_contents	; \fcontents(macro)?
	je	evarg21			; e = yes
	cmp	evaltype,F_definition	; \fdefinition(macro)?
	jne	evarg22			; ne = no
evarg21:push	cmptab			; save working pointers
	push	cmsptr
	mov	cmptab,offset mcctab	; look at table of macro names
	mov	cx,argptr[bx]		; look at whole word todate
	mov	cmsptr,cx		; start of word
	push	bx
	call	cmkyesc			; do escape word completion
	pop	bx
	pop	cmsptr
	pop	cmptab
	xor	ah,ah			; in case no match
evarg22:call	bufreset		; reset cmwptr
	cmp	ah,escape		; escape?
	jne	evarg30			; ne = no
	push	ax
	push	dx
	mov	ah,conout		; ring the bell
	mov	dl,bell
	int	dos
	pop	dx
	pop	ax
	jmp	evarg12			; get next arg byte
evarg30:jmp	repars			; reparse command

evarg50:cmp	ah,braceop		; opening curly brace?
	jne	evarg52			; ne = no
	inc	dl			; count up curly brace
	jmp	evarg12			; get next argument byte
evarg52:cmp	ah,bracecl		; closing curly brace?
	jne	evarg60			; ne = no
	sub	dl,1			; count down curly braces
	jge	evarg54			; ge = no underflow
 	xor	dx,dx			; clamp at zero
evarg54:jmp	evarg12

evarg60:or	dl,dl			; within curly braces
	jnz	evarg3			; nz = yes, don't count parens there
	cmp	ah,'('			; opening paren?
	jne	evarg62			; ne = no
	inc	dh			; count up paren
	jmp	evarg12			; get next byte of argument

evarg62:cmp	ah,')'			; closing paren?
	jne	evarg3			; ne = no
	sub	dh,1			; count down closing paren
	jl	evarg64			; l = reached terminator
	jmp	evarg12			; get next byte of argument

evarg64:mov	cx,cmsiz
	dec	cx			; don't count closing paren
	mov	arglen[bx],cx
	cmp	evaltype,F_literal	; \fliteral(string)?
	je	evarg66			; e = yes, keep trailing spaces
	mov	si,argptr[bx]		; start of argument
	add	si,cx
	dec	si			; last byte of argument
	jcxz	evarg66			; z = no text to trim
evarg65:cmp	byte ptr [si],' '	; trailing space?
	jne	evarg66			; ne = no
	dec	si
	dec	arglen[bx]		; one less argument byte
	loop	evarg65
evarg66:jmp	evarg7			; ")" marks END of function

evarg3:	cmp	ah,','			; possible argument terminator?
	jne	evarg5			; ne = no
	or	dx,dx			; within paren or curly braces?
	jne	evarg5			; ne = yes, treat commas as data
	cmp	evaltype,F_literal	; doing \fliteral()?
	je	evarg5			; e = yes, commas are data
	cmp	evaltype,F_eval		; doing \feval()?
	je	evarg5			; e = yes, commas are data
	dec	cmsiz			; do not count comma
evarg4:	mov	cx,cmsiz
	cmp	bx,3*2			; done three args?
	jae	evarg4a			; ae = yes, add no more args
	mov	arglen[bx],cx		; mark argument length
	add	bx,2			; next arg array element
evarg4a:jmp	evarg10			; get next argument

evarg5:	jmp	evarg12			; get next byte in argument

evarg7:	pop	temp
	pop	si
	pop	dx
	pop	cx
	pop	bx
	pop	ax
	clc
	ret
evarg	endp

; Reallocates more memory than provided in the default takopen 128 byte buffer.
; Enter with desired byte quantity in CX and a Take structure already
; present at takadr. Returns with new buffer length in CX, ES:DI pointing
; at buffer+2 ([bx].takbuf:[bx].takptr)
evmem	proc	near
	push	ax
	push	bx
	push	cx
	mov	bx,takadr
	mov	ax,[bx].takbuf		; segment of preallocated memory
	mov	bx,cx			; string length, in bytes
	add	bx,2+1+15		; count + null term + round up
	mov	cl,4
	shr	bx,cl			; convert to paragraphs (divide by 16)
	mov	cx,bx			; remember desired paragraphs
	mov	ah,alloc		; allocate a memory block
	int	dos			; ax=seg, bx=paragraphs
	jc	evmem3			; c = error, not enough memory
 	cmp	bx,cx			; obtained vs wanted
	jae	evmem2			; ae = enough
	push	bx
	mov	bx,takadr
	mov	cx,[bx].takcnt		; old unread-bytes
	shr	cx,1
	shr	cx,1
	shr	cx,1
	shr	cx,1			; to paragraphs
	pop	bx
	cmp	bx,cx			; more than we had originally?
	ja	evmem2			; a = yes, so use the new larger buff
	push	es
	mov	es,ax			; new allocated segment
	mov	ah,freemem		; free it
	int	dos
	pop	es
	jmp	short evmem3		; use original segment

evmem2:	mov	cl,4
	shl	bx,cl			; paragraphs to bytes
	mov	cx,bx			; return new bytes in CX
	sub	cx,2			; minus two for len field
	mov	es,ax			; set new segment
	mov	bx,takadr
	xchg	[bx].takbuf,ax		; new segment, swap with old seg
	or	ax,ax			; if any allocated
	jz	evmem2a			; z = none
	push	es
	mov	es,ax			; old allocated segment
	mov	ah,freemem		; free old segment
	int	dos
	pop	es
evmem2a:mov	di,2			; new offset
	mov	bx,takadr
	mov	[bx].takptr,di		; new offset
	mov	[bx].takcnt,0		; total buffer, unread bytes
	or	[bx].takattr,take_malloc ; malloc'd buffer to remove later
	pop	bx			; discard old cx, return new cx
	pop	bx
	pop	ax
	ret

evmem3:	pop	cx			; return original values
	pop	bx
	pop	ax
	ret
evmem	endp

; Worker for evaltoa. Sets cmhlp to help string matching evaltype
fcmdhlp	proc	near
	mov	ax,evaltype		; kind of \f command
	mov	bx,offset f1hlp		; number
	cmp	ax,F_char		; go through types
	je	fcmdh1			; e = matched
	cmp	ax,F_maximum
	je	fcmdh1
	cmp	ax,F_minimum
	je	fcmdh1
	mov	bx,offset f2hlp		; char
	cmp	ax,F_code
	je	fcmdh1
	mov	bx,offset f3hlp
	cmp	ax,F_contents
	je	fcmdh1
	cmp	ax,F_definition
	je	fcmdh1
	mov	bx,offset f8hlp
	cmp	ax,F_index
	je	fcmdh1
	mov	bx,offset f12hlp
	cmp	ax,F_lpad
	je	fcmdh1
	cmp	ax,F_rpad
	je	fcmdh1
	mov	bx,offset f15hlp
	cmp	ax,F_nextfile
	je	fcmdh1
	mov	bx,offset f16hlp
	cmp	ax,F_repeat
	je	fcmdh1
	mov	bx,offset f18hlp
	cmp	ax,F_right
	je	fcmdh1
	mov	bx,offset f20hlp
	cmp	ax,F_substr
	je	fcmdh1
	mov	bx,offset f22hlp
	cmp	ax,F_date
	je	fcmdh1
	cmp	ax,F_basename
	je	fcmdh1
	cmp	ax,F_size
	je	fcmdh1
	cmp	ax,F_files
	je	fcmdh1
	mov	bx,offset f25hlp
	cmp	ax,F_eval
	je	fcmdh1
	mov	bx,offset f8hlp
	cmp	ax,F_rindex
	je	fcmdh1
	mov	bx,offset f30hlp
	cmp	ax,F_chksum
	je	fcmdh1
	mov	bx,offset f9hlp		; default to text
fcmdh1:	mov	cmhlp,bx		; set help text pointer
	ret
fcmdhlp	endp


filedate proc	near
	push	di
	push	es
	mov	dx,offset fileio.dta	; data transfer address
	mov	ah,setdma		; set disk transfer address
	int	dos
	mov	bx,argptr		; filename
	mov	dx,bx			; for file open
	add	bx,arglen		; length of it
	mov	byte ptr [bx],0		; make it ASCIIZ
	xor	cx,cx			; attributes: find only normal files
	mov	ah,first2		; DOS 2.0 search for first
	int	dos			; get file's characteristics
	pushf				; save status
	mov	ah,setdma		; restore dta
	mov	dx,offset buff
	int	dos
	popf				; get status
	pop	es
	pop	di
	jnc	filed1			; nc = success
	ret				; fail
filed1:	cmp	evaltype,F_date		; want date/time stamp?
	je	filed3			; e = yes
	cmp	evaltype,F_size		; want file length?
	jne	filed2			; ne = no (probably \ffiles(..))
	mov	ax,fileio.sizelo	; file size to dx:ax
	mov	dx,fileio.sizehi
	call	flnout			; convert to ASCII
	mov	byte ptr [di],0		; terminate
filed2:	clc
	ret

filed3:	mov	bx,offset fileio.dta	; set work pointer
	call	filetdate		; do the work
	ret
filedate endp

; Write file date and timestamp to ds:di, given DTA in ds:bx.
filetdate proc	far
	push	es			; time/date stamp yyyymmdd hh:mm:ss
	mov	ax,ds
	mov	es,ax
	xor	ah,ah
	mov	al,[bx+25]		; yyyyyyym from DOS via file open
	shr	al,1			; get year
	add	ax,1980			; add bias
	xor	dx,dx
	call	flnout			; put year (1990) in buffer
	mov	ax,[bx+24]		; yyyyyyyym mmmddddd  year+month+day
	shr	ax,1			; month to al
	xor	ah,ah
	mov	cl,4
	shr	al,cl			; month to low nibble
	mov	byte ptr[di],'0'	; leading digit
	inc	di
	cmp	al,9			; more than one digit?
	jbe	filed4			; be = no
	mov	byte ptr[di-1],'1'	; new leading digit
	sub	al,10			; get remainder
filed4:	add	al,'0'			; to ascii
	stosb				; end of month
	mov	al,[bx+24]		; get day of month
	and	al,1fh			; select day bits
	xor	ah,ah
	mov	cl,10
	div	cl			; quot = al, rem = ah
	add	ax,'00'			; add ascii bias
	stosw				; leading digit and end of date
	mov	al,' '			; space separator
	stosb
	mov	al,[bx+23]		; hours  hhhhhmmm
	mov	cl,3
	shr	al,cl			; move to low nibble
	xor	ah,ah
	mov	cl,10
	div	cl			; quot = al, rem = ah
	add	ax,'00'			; add ascii bias
	stosw				; store hours
	mov	al,':'			; separator
	stosb
	mov	ax,[bx+22]		; get minutes: hhhhhmmm mmmsssss
	mov	cl,5
	shr	ax,cl			; minutes to low byte
	and	al,3fh			; six bits for minutes
	xor	ah,ah
	mov	cl,10
	div	cl
	add	ax,'00'			; add ascii bias
	stosw
	mov	al,':'			; separator
	stosb
	mov	al,[bx+22]		; get seconds (double secs really)
	and	al,1fh
	shl	al,1			; DOS counts by two sec increments
	xor	ah,ah
	mov	cl,10
	div	cl
	add	ax,'00'			; add ascii bias
	stosw
	mov	byte ptr [di],0		; terminate
	pop	es
	ret
filetdate endp

; Set envadr to the string following the <variable=> keyword in the DOS
; 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

	push	bx
	push	cx
envvar1a:mov	al,byte ptr [bx]	; scan variable name in our buffer
	cmp	al,'A'			; upper case
	jb	envvar2a		; b = no
	cmp	al,'Z'			; still in upper case range?
	ja	envvar2a		; a = no
	or	al,20h			; convert to DOS's lower case
	mov	byte ptr [bx],al	; replace char
envvar2a:inc	bx
	loop	envvar1a
	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

; Worker for Remote Query System name in mssser.
; Enter with variable name in decbuf+6 et seq, name length byte in decbuf+5
; with ' ' bias.
fqryenv	proc	far
	mov	valtmp,offset decbuf+6	; start of variable name
	mov	cl,decbuf+5		; name length plus bias
	sub	cl,' '			; remove bias
	xor	ch,ch
	mov	cmsiz,cx		; name length
	call	envvar			; get address of environmental string
	jnc	fqryenv1		; nc = success
	xor	cx,cx			; failure
	ret

fqryenv1:mov	cx,envlen		; length of string in environment
	push	es
	push	ds
	lds	si,envadr		; pointer to string
	mov	di,seg encbuf		; destination buffer
	mov	es,di
	mov	di,offset encbuf
	cld
	rep	movsb			; copy string
	pop	ds
	pop	es
	mov	cx,envlen		; string length again
	ret
fqryenv	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
	mov	read_source,0		; assume direct reading
	mov	endedbackslash,0	; clear end of sub scan flag
cmget01:cmp	comand.cmdirect,0	; read directly?
	jne	cmget02			; ne = yes
	cmp	taklev,0		; in a Take file?
	jne	cmget1			; ne = yes, do Take reader section
cmget02:call	isdev			; is stdin a device or a file?
	jnc	cmget20			; nc = file (redirection of stdin)
	jmp	cmget10			; c = device, do separately

cmget20:call	iseof			; 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	cmget12			; ne = not LF, pass along as is
	mov	al,cr			; make LF a CR for this parser
	call	iseof			; see if this is the last char in file
	jnc	cmget12			; nc = not EOF, process new CR
cmget21:mov	flags.extflg,1		; EOF on disk file, set exit flag
	jmp	cmget12			; do echoing and return

cmget1:	push	bx			; read from Take file
	mov	bx,takadr		; offset of this Take structure
	mov	al,[bx].taktyp
	mov	read_source,al
	cmp	[bx].takcnt,0		; bytes remaining in Take buffer
	jne	cmget4			; ne = not empty
	cmp	al,take_file		; type of Take (file?)
	jne	cmget3			; ne = no (macro)
	call	takrd			; read another buffer
	cmp	[bx].takcnt,0		; anything in the buffer?
	jne	cmget4			; ne = yes
cmget3:	pop	bx			; clear stack
	jmp	short cmget5		; close the Take file

cmget4:	push	si			; read from Take non-empty buffer
	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
	pop	es
	inc	si
	mov	[bx].takptr,si		; move buffer pointer
	pop	si
	dec	[bx].takcnt		; decrease number of bytes remaining
	cmp	read_source,take_sub	; substitution macro?
	jne	cmget4b			; ne = no
	cmp	[bx].takcnt,0		; read last byte?
	jne	cmget4b			; ne = no
	cmp	al,'\'			; ended on a backsash?
	jne	cmget4b			; ne = no
	mov	endedbackslash,al	; setup break end of sub scan
cmget4b:pop	bx

	cmp	read_source,take_file	; kind of Take/macro, file?
	jne	cmget12			; ne = no, not a file
	cmp	al,LF			; LF?
	je	cmget01			; e = yes, ignore
	cmp	al,ctlz			; Control-Z?
	jne	cmget12			; ne = no, else ^Z = EOF

cmget5:	push	bx			; end of file on Take buffer
	mov	bx,takadr		; offset of this Take structure
	mov	ah,[bx].takattr		; save kind of autoCR
	pop	bx
	cmp	read_source,take_sub	; text subsititution?
	je	cmget5a			; e = yes, cannot keep open
	cmp	comand.cmkeep,0		; keep Take/macro open after eof?
	jne	cmget5b			; ne = yes
cmget5a:push	ax
	call	ftakclos		; close take file
	pop	ax
	test	ah,take_autocr		; add CR on EOF?
	jnz	cmget5b			; nz = yes
	jmp	cmgetc			; internal macros have no auto CR
cmget5b:mov	al,CR			; report CR as last char
	jmp	short cmget12
					; read from tty device
cmget10:mov	ah,coninq		; Get a char from device, not file
	int	dos			;  with no echoing
	or	al,al
	jnz	cmget11			; ignore null bytes of special keys
	int	dos			; read and discard scan code byte
	jmp	short cmget10		; try again
cmget11:cmp	al,LF			; LF?
	jne	cmget12			; ne = no
	mov	al,CR			; replace interactive LF with CR

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,' '
cmget13:ret				; normal exit, char is in AL

cmget14:cmp	in_showprompt,0		; Non-zero when in showprompt
	jne	cmget13			; ne = yes, no editing
	test	read_source,take_sub+take_macro	; substitution or macro?
	jnz	cmget13			; nz = yes, do not edit line
	mov	bracecnt,0
	mov	ah,prstr		; Control-C handler
	push	dx
	mov	dx,offset ctcmsg	; show Control-C
	int	dos
	pop	dx
	mov	flags.cxzflg,'C'	; tell others the news
	jmp	cmexit			; 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'
	cmp	read_source,take_sub	; substitution?
	je	cminb1a			; e = yes
	push	bx
	mov	bx,cmrawptr		; where raw writes go (inc remakes)
	mov	[bx],ah			; store byte
	inc	cmrawptr
	pop	bx
cminb1a:
	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	in_showprompt,0		; Non-zero when in showprompt
	jne	cminb5			; ne = yes, no editing
	test	read_source,take_sub+take_macro	; substitution or macro?
	jnz	cminb4			; nz = yes, do not edit line
	cmp	ah,'W' and 1fh		; is it a ^W?
	jne	cminb3			; ne = no
	call	cntrlw			; kill the previous word
	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
	mov	cmrptr,offset cmdbuf
	mov	cmrawptr,offset rawbuf	; clear raw buffer
	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
	call	crprot			; protect CR?
	jnc	cminb4e			; nc = no
					; cmtxt {continued lines} section
	dec	cmwptr			; back over CR for both buffers
	dec	cmrptr
	mov	bx,cmwptr
	mov	ah,','			; replace CR with comma
	mov	[bx-1],ah
	mov	bx,cmrawptr
	mov	[bx-1],ah
	mov	bx,cmrptr
	mov	[bx],ah
					; deal with echoing
	cmp	comand.cmquiet,0	; quiet mode?
	jne	cminb4g			; yes, skip echoing
	cmp	comand.cmdirect,0	; direct reading?
	jne	cminb4f			; ne = yes, do echoing
	cmp	taklev,0		; in a take file?
	je	cminb4f			; e = no
	cmp	read_source,take_comand	; command reread macro?
	je	cminb4f			; e = yes, echo
	cmp	flags.takflg,0		; echo take file?
	je	cminb4g			; e = no
	cmp	read_source,take_sub	; don't echo string substitution
	je	cminb4g
cminb4f:
	push	ax
	push	dx
	mov	dl,ah
	mov	ah,conout		; echo comma to screen now
	int 	dos
	mov	ah,prstr		; and then visually break the line
	mov	dx,offset crlf
	int	dos
	pop	dx
	pop	ax
cminb4g:pop	bx
	clc				; returns ah = comma
	ret
					; start regular hyphenation part
cminb4e: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
	sub	cmwptr,2		; back over -<cr> for both buffers
	sub	cmrawptr,2
	jmp	repars			; reparse what we now have
cminb4b:pop	bx
					; Echoing done here
	cmp	comand.cmquiet,0	; quiet mode?
	jne	cminb5			; yes, skip echoing
	cmp	comand.cmdirect,0	; direct reading?
	jne	cminb4a			; ne = yes, do echoing
	cmp	taklev,0		; in a take file?
	je	cminb4a			; e = no

	cmp	read_source,take_comand	; command reread macro?
	je	cminb4a			; e = yes, echo
	cmp	flags.takflg,0		; echo take file?
	je	cminb5			; e = no
	cmp	read_source,take_sub	; don't echo string substitution
	je	cminb5

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			; e = yes
	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', and \numbers are detected and expanded.
; Return char in AH.
; If a \blah parse fails then report the \ to the caller and start over, 
; without echo, on the char following that \. Replay_skip does the \
; passage without calling subst, replay_cnt rereads bytes after it.
CMGTCH	proc	near			; return char in AH, from rescan buf
	cmp	replay_cnt,0		; starting a replay?
	je	cmgtc5			; e = no
	mov	replay_skip,1		; set latch to skip subst on 1st byte
cmgtc5:	cmp	in_reparse,0		; replaying material?
	je	cmgtc0			; e = no
	call	remake			; remake command line as macro

cmgtc0:	cmp	replay_cnt,0		; replay with no echo?
	jne	cmgtc1			; ne = yes, have in cmdbuf now
	call	cminbf			; get char from buffer or user
cmgtc1:	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
	cmp	replay_cnt,0		; replaying?
	jne	cmgtc6			; ne = yes, don't take the branch
	cmp	bx,cmwptr		; still reading analyzed text?
cmgtc6:	pop	bx
	jb	cmgtc2			; b = yes, don't reexpand
	cmp	replay_skip,0		; replay latch set?
	je	cmgtc7			; e = no, re-read new bytes in subst
	mov	replay_skip,0 		; clear latch after the first re-read byte
	jmp	cmgtc2			; and skip subst on that first byte
	cmp	replay_cnt,0		; replaying?
	jne	cmgtc2			; ne = yes
cmgtc7:
	call	subst			; examine for text substitution
	jc	cmgtch			; c = reread input material
	cmp	report_binary,0		; report binary number directly?
	je	cmgtc2b			; e = no
	mov	report_binary,0		; clear flag
	clc				; value is in ah, non-terminator
	ret

cmgtc2:	push	bx
	mov	bx,replay_cnt		; count down replay bytes
	or	bx,bx	
	jz	cmgtc2a			; z = empty 
	dec	replay_cnt
cmgtc2a:pop	bx
cmgtc2b:cmp	ah,','			; comma?
	jne	cmgtc2c			; ne = no
	cmp	comand.cmcomma,0	; comma is space equivalent?
	je	cmgtc2c			; e = no
	mov	ah,' '			; convert comma to space
cmgtc2c:cmp	ah,' '			; space?
	jne	cmgtc3			; ne = no
	cmp	cmsiz,0			; started user data?
	je	cmgtc2d			; e = no, this is a leading space
	cmp	cmkind,cmline		; doing full lines of text?
	je	cmgtc3			; e = yes, retain all spaces
cmgtc2d: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
	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
					; terminators remain in buffer but
					;  are ready to be overwritten
cmgtc3c:test	read_source,take_sub	; substitution macro?
	jnz	cmgtc3d			; nz = yes, pass all bytes as data
	cmp	ah,escape		; Escape expander?
	jne	cmgtc3e			; ne = no
	cmp	read_source,0		; reading from keyboard directly?
	jne	cmgtc4			; ne = no, escape is regular char

cmgtc3e: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			; these terminators?
	je	cmgtc4			; e = yes
	cmp	ah,LF
	je	cmgtc4
	cmp	ah,FF
	je	cmgtc4
	cmp	ah,ESCAPE
	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 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
	xor	ah,ah			; get a null
	sub	cx,si			; length to examine
	jle	bufres3a		; le = nothing to scan
	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
bufres3a:cmp	bracecnt,ah		; negative?
	jge	bufres4			; ge = no
	mov	bracecnt,ah
bufres4:mov	word ptr [si],0		; terminate buffer
	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
	cmp	read_source,take_sub	; substitution macro?
	je	bufdel0			; e = yes, does not change cmrawptr
	cmp	cmrawptr,offset rawbuf	; anything written to base level buf?
	ja	bufdel7			; a = yes
	mov	cmrawptr,offset rawbuf	; safety
	mov	ax,offset cmdbuf
	mov	cmrptr,ax
	mov	cmwptr,ax
	clc				; do nothing
	ret
bufdel7:dec	cmrawptr		; backup one byte
	push	bx
	mov	bx,cmrawptr
	cmp	byte ptr [bx],BS	; last read was BackSpace?
	pop	bx
	jne	bufdel8			; ne = not BS
	dec	cmrawptr		; backup write pointer over BS too
bufdel8:cmp	cmrawptr,offset rawbuf	; sanity check, back too far?
	jae	bufdel9			; ae = not too far
	mov	cmrawptr,offset rawbuf	; reset to start of buffer
bufdel9:cmp	comand.cmdirect,0	; doing direct reading?
	jne	bufdel0			; ne = yes
	mov	ax,offset cmdbuf
	mov	cmwptr,ax		; reset normal parse buffer
	mov	cmrptr,ax
	mov	bx,ax
	mov	word ptr [bx],0		; terminate buffer
	mov	in_reparse,1		; say need to replay from rawbuf
	jmp	repars			; reparse command

bufdel0:cmp	cmrptr,offset cmdbuf	; at start of buffer now?
	jbe	bufdel5			; be = yes
	push	ax
	push	si
	mov	si,cmrptr
	mov	al,[si]
	dec	si
	xor	ah,ah			; get a null
	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,ah		; negative?
	jge	bufdel3			; ge = no
	mov	bracecnt,ah
bufdel3:pop	si
	pop	ax
	mov	replay_cnt,0		; clear protected replay byte count
	dec	cmrptr			; remove previous char from buffer
	cmp	cmrptr,offset cmdbuf	; back too far?
	jae	bufdel4			; ae = no, material can be erased
	mov	cmrptr,offset cmdbuf	; set to start of buffer
	mov	bracecnt,ah		; ensure this is now cleared
bufdel5:call	bufreset		; reset buffer
	clc				; say no erasure
	ret
bufdel4:call	bufreset		; reset buffer
	stc				; say did erasure
	ret
bufdel	endp

; Remake the current command line, omitting substitution macro contents,
; as a macro (kind is comand, almost "macro"). Current command line is
; in rawbuf, with cmrawptr pointing next place to write.
; Closes currently active substitution macros.
remake	proc	near
	push	bx
	push	cx
	push	dx
	push	di
	mov	cmrptr,offset cmdbuf
	mov	cmwptr,offset cmdbuf	; clear work buffer
	mov	cx,cmrawptr		; where to write next
	mov	cmrawptr,offset rawbuf
	sub	cx,offset rawbuf	; length of string
	jle	remake3			; le = nothing to do
remake1:cmp	taklev,0		; in a take file?
	je	remake2			; e = no
	mov	bx,takadr
	cmp	[bx].taktyp,take_sub	; sub macro?
	jne	remake2			; ne = no
	push	cx
	call	ftakclos		; close sub macros
	pop	cx
	jmp	short remake1		; next victim
remake2:call	takopen_macro		; open take as macro (comand kind)
	mov	bx,takadr		; pointer to new Take structure
	mov	[bx].taktyp,take_comand ; that's us
	and	[bx].takattr,not take_autocr ; no CR at end of macro please
	mov	[bx].takcnt,cx		; number of unread bytes
	mov	[bx].takbuf,seg rawbuf	; segment of Take buffer
	mov	cx,offset rawbuf
	mov	[bx].takptr,cx 		; offset to read from
	mov	cmrawptr,cx
remake3:mov	in_reparse,0		; clear our flag
	mov	bracecnt,0
	mov	replay_cnt,0
	mov	comand.cmkeep,0
	pop	di
	pop	dx
	pop	cx
	pop	bx
	ret
remake 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	si,cmwptr		; assumed source pointer
	mov	cx,cmrptr		; read pointer
	sub	cx,offset cmdbuf	; compute chars in buffer
	cmp	comand.cmdirect,0	; direct reading?
	jne	cntrl3			; ne = yes, only one buffer

	dec	cmrawptr		; back over ^W
	mov	si,cmrawptr		; use raw buf as source pointer
	mov	cx,si			; point at last written byte
	sub	cx,offset rawbuf	; count of bytes before ^W
	jle	ctlw2			; le = none
cntrl3:	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,si			; 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
	cmp	comand.cmdirect,0	; direct reading?
	jne	ctlw2			; ne = yes, only one buffer
	inc	di			; leave a char for bufdel
	mov	cmrawptr,di		; setup delete initial byte of word
	call 	bufdel			; delete item, reparse
ctlw2:	pop	dx
	pop	cx
	pop	ax
	ret
cntrlw	endp

; returns carry set if CR is to be protected
; returns carry clear if CR is unprotected
crprot proc near			; cmtxt {continued lines} section
	cmp	comand.cmcnvkind,cmcnv_crprot	; braces span lines?
	jne	crprotx			; ne = no, do regular hyphenation
	cmp	cmkind,cmkey
	je	crprotx
	cmp	bracecnt,0		; are curly braces matched yet?
	je	crprotx			; e = yes, then this is ignorable
	stc				; CR needs protection
	ret
crprotx:clc
	ret
crprot	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 FAR
	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
	xor	ax,ax
	mov	cmsflg,0ffh		; strip leading spaces
	mov	subcnt,al		; clear substitution state variables
	mov	subtype,al
	mov	bracecnt,al
	call	optionclr		; clear parser options
	cmp	in_showprompt,al	; redoing the prompt itself?
	jne	prser3			; ne = yes, suppress display
	cmp	comand.cmdirect,al	; doing direct reading?
	jne	prser2			; ne = yes
	cmp	taklev,al		; in Take cmd?
	je	prser2			; e = no
	cmp	flags.takflg,al		; 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	prtasz
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 after 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			; Must preserve AX
	mov	replay_cnt,0
	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
	mov	cmrawptr,offset rawbuf	; base/raw buffer write ptr, reset
	mov	in_reparse,0		; clear buffer remake flag
rprompt1:pop	ax
	ret
RPROMPT	endp

; Clear comand.* options to defaults
optionclr proc	near
	push	ax
	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.impdo,al		; clear flag to prevent loops
	mov	comand.cmquiet,al	; permit echoing again
	mov	comand.cmblen,ax	; set user buffer length to unknown
	mov	comand.cmdonum,al	; defeat \number expansion
	mov	comand.cmcomma,al	; comma is not a space
	mov	comand.cmarray,al	; disallow sub in [..]
	mov	comand.cmcnvkind,cmcnv_none ; default is no conversion
	pop	ax
	ret
optionclr 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 es:[di],0020h	; space and null terminator
	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
	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
	mov	al,dl			; day
	call	wrtdat5
	mov	byte ptr es:[di],' '
	inc	di
	xor	bh,bh
	mov	bl,dh			; month
	dec	bx			; count from zero
	shl	bx,1			; count four byte groups
	shl	bx,1
	mov	ax,word ptr month[bx]
	stosw
	mov	ax,word ptr month[bx+2]
	stosw
	mov	ax,cx			; year
wrtdat3:call	wrtdat5
	mov	word ptr es:[di],0020h	; space and null terminator
	pop	dx
	pop	cx
	ret

wrtdat5:cmp	ax,10			; leading tens digit present?
	jae	wrtdat6			; ae = yes
	mov	byte ptr es:[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 es:[di],0020h	; space and null terminator
	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 es:[di],0020h	; space and null terminator
	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 es:[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 es:[di],'0'	; leading 0
	inc	di
wrtndat2:call	fdec2di
	mov	word ptr es:[di],0020h	; space and null terminator
	ret
wrtndate endp

; write \v(DIRECTORY) text to es:di
wrtdir	proc	near
	push	si
	mov	ah,gcurdsk		; get current disk
	int	dos
	add	al,'A'			; make al = 0 == 'A'
	stosb
	mov	ax,'\:'
	stosw
	mov	si,di			; work buffer
	push	ds
	mov	cx,es
	mov	ds,cx
	mov	ah,gcd			; get current directory
	xor	dl,dl			; use current drive
	int	dos			; get ds:si = asciiz path (no drive)
	pop	ds
	mov	dx,si
	push	ds
	mov	cx,es
	mov	ds,cx
	call	strlen
	pop	ds
	add	di,cx
wrtdir1:mov	word ptr es:[di],0020h	; space and null terminator
	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
	stosb				; store char
	jmp	short wrtplat1		; keep going
wrtplat2:mov	word ptr es:[di],0020h	; space and null terminator
	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
	cld
	rep	movsb			; copy to DS:DI
wrtpor5:mov	word ptr es:[di],0020h	; space and null terminator
	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
	stosb				; store the char
	jmp	short wrtprg1
wrtprg2:mov	word ptr es:[di],0020h	; space and null terminator
	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 es:[di],0020h	; space and null terminator
	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 es:[di],'0'	; make our own
	inc	di
wrttim1:call	fdec2di			; write decimal asciiz to buffer
	mov	byte ptr es:[di],':'
	inc	di
	xor	ah,ah
	mov	al,cl			; Minutes
	cmp	al,10			; leading digit?
	jae	wrttim2			; ae = yes
	mov	byte ptr es:[di],'0'	; make our own
	inc	di
wrttim2:call	fdec2di			; write decimal asciiz to buffer
	mov	byte ptr es:[di],':'
	inc	di
	pop	dx
	xor	ah,ah
	mov	al,dh			; Seconds
	cmp	al,10			; leading digit?
	jae	wrttim3			; ae = yes
	mov	byte ptr es:[di],'0'	; make our own
	inc	di
wrttim3:call	fdec2di			; write decimal asciiz to buffer
	mov	word ptr es:[di],0020h	; space and null terminator
	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
	stosb
	cmp	al,'$'			; end of string?
	jne	wrtver1			; ne = no, continue copying
	dec	di
	mov	word ptr es:[di],0020h	; space and null terminator
	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
	rep	movsb
wrtter4:mov	word ptr es:[di],0020h	; space and null terminator
	ret
wrtterm	endp

fcmgtch	proc	far
	call	cmgtch
	ret
fcmgtch	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
	mov	comand.cmdirect,0	; read normally (vs force to kbd/file)
	mov	cmrawptr,offset rawbuf	; base/raw buffer write ptr, reset
	mov	cmwptr,offset cmdbuf
	mov	cmrptr,offset cmdbuf
MPROMPT	endp

; This routine prints the prompt and specifies the reparse address.
; Enter with pointer to prompt string in dx. 
PROMPT	PROC  NEAR
	xor	ax,ax			; get a zero
	xchg	al,comand.cmdirect	; set cmdirect to zero for showprompt
	xchg	ah,comand.cmper
	push	ax
	xor	al,al
	xchg	al,flags.takflg		; take echo flag, off in showprompt
	push	ax
	call	showprompt		; convert string with variables
	pop	ax
	xchg	al,flags.takflg		; restore take echo flag
	pop	ax
	mov	comand.cmdirect,al	; restore direct mode (if any)
	mov	comand.cmper,ah
	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	cmrptr,ax		; reset buffer read/write pointers
	mov	cmwptr,ax
	mov	cmrawptr,offset rawbuf
	mov	in_reparse,0
	xor	ax,ax
	mov	subcnt,al		; substitution variable state info
	mov	subtype,al
	mov	bracecnt,al
	mov	replay_cnt,ax
	mov	cmsiz,ax
	mov	comand.cmper,al		; allow substitutions
	mov	cmsflg,0ffh		; remove leading spaces
	cmp	comand.cmdirect,al	; doing direct reading?
	jne	promp1			; ne = yes
	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			; e = no, keep going
	clc
	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

; Convert ASCIIZ prompt string given in DS:DX to string in DS:comand.cmprmp
; with expansion of substitution variables. Final prompt is in DX and in
; comand.cmprmp = offset cmdbuf+cmdblen/2 (of a 1000 byte total buffer).
showprompt proc far
	cmp	in_showprompt,0		; doing this routine already?
	je	showp0			; e = no
	mov	dx,comand.cmprmp	; yes, return current prompt string
	ret
showp0:	mov	word ptr cmdbuf+cmdblen/2,0	; clear final prompt string
	mov	comand.cmprmp,offset cmdbuf+cmdblen/2 ; prompt pointer
	mov	si,dx			; raw prompt string ds:dx
	call	strlen			; get string length
	or	cx,cx			; empty?
	jnz	showp1			; nz = no
	ret				; return empty prompt string
showp1:	inc	cx			; include null in length
	mov	al,taklev		; entering taklev
	cmp	al,maxtak		; room in take level?
	jb	showp2			; b = yes
	mov	comand.cmprmp,dx	; original raw prompt offset
	ret				; return it

showp2:	push	ax			; save take level
	mov	si,offset cmdbuf	; reset parse buffer pointers
	mov	cmrptr,si
	mov	cmwptr,si
	mov	cmrawptr,offset rawbuf
	xor	ax,ax
	mov	subcnt,al		; clear substitution state variables
	mov	subtype,al
	mov	bracecnt,al
	call	takopen_sub		; open take as text substitution
	mov	bx,takadr		; address of take structure
	mov	ax,ds
	mov	[bx].takbuf,ax		; segment of Take buffer
	mov	[bx].takptr,dx 		; offset of beginning of def text
	mov	[bx].takcnt,cx		; # of chars in buffer (includes NUL)
	or	[bx].takattr,take_autocr ; imply CR at end of prompt
	mov	in_showprompt,1		; say making new prompt
	xor	ax,ax
	mov	cmsflg,al		; get all spaces
	mov	comand.cmper,al		; reset to variable recognition
	mov	comand.cmquiet,1	; no echo
	mov	comand.cmwhite,1	; leading white space is ok
	mov	comand.cmcr,1		; bare cr's allowed
	mov	comand.cmostp,sp	; set reprompt stack pointer here
	mov	comand.cmcnvkind,cmcnv_none ; default is no conversion
	mov	cmkind,cmword		; say getting a word, not a line
	mov	comand.cmdonum,0	; disable \number expansion
	mov	word ptr comand.cmrprs,offset showp3 ; offset for reparse
	mov	ax,cs			; our current code segment
	mov	word ptr comand.cmrprs+2,ax ; segment of reparse address

showp3:	mov	cmptab,offset cmdbuf+cmdblen/2 ; buffer for new string
	mov	comand.cmblen,(cmdblen/2)-100 ; length of our buffer (plenty)

showp4:	call	fcmgtch			; get a char
	jnc	showp5			; nc = non-terminator
	cmp	ah,' '			; space terminator?
	je	showp5			; e = yes
	inc	cmrptr			; 'read' other kinds of terminator
showp5:	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	bx,offset cmdbuf+cmdblen ; end of buffer?
	jae	showp6			; ae = end of buffer, terminate
	mov	cmsflg,0		; still get spaces
	or	ah,ah			; this terminator?
	jnz	showp4			; nz = no, keep reading

showp6:	pop	ax			; saved entering taklev
	cmp	al,taklev		; saved versus current taklev
	jae	showp7			; ae = nothing new to be removed
	push	ax			; save again for loop
	call	takclos			; close Take file
	jmp	showp6			; keep at it
showp7:	xor	ax,ax
	mov	comand.cmwhite,al	; clear leading whitespace flag
	mov	comand.cmblen,ax	; set user buffer length to unknown
	mov	comand.cmquiet,al	; enable echo
	mov	comand.cmcr,al		; bare cr's not allowed
	mov	comand.cmdonum,al	; disable \number expansion
	mov	in_showprompt,al	; done making new prompt
	mov	dx,offset cmdbuf+cmdblen/2 ; return in DX
	mov	comand.cmprmp,dx	 ; returned prompt pointer
	mov	subcnt,al
	mov	subtype,al
	ret
showprompt endp
code	ends

code1	segment
	assume	cs:code1

ISDEV	PROC	FAR			; 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	FAR			; 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 FAR
	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 lower case
tolow2:	ret
TOLOWR	endp

TOUPR PROC FAR
	cmp	ah,'a'			; less that lower A?
	jb	toup1			; l = yes. leave untouched
	cmp	ah,'z'			; more than lower Z?
	ja	toup1			; ns = yes
	and	ah,not 20H		; convert to upper case
toup1:	cmp	al,'a'			; less that lower A?
	jb	toup2			; l = yes. leave untouched
	cmp	al,'z'			; more than lower Z?
	ja	toup2			; ns = yes
	and	al,not 20H		; convert to upper case
toup2:	ret
TOUPR	endp

; Revise string in ds:si et seq. Expect incoming length to be in CX.
; Controlled by comand.cmcnvkind.
; Original string modified to replace bare commas with Carriage Returns.
; Top level braces removed, but only if the string begins with an 
; opening brace, and hence commas revealed are also converted to CR.
; Converted text has a forced null termination to assist callers of cmtxt
; which don't remember returned byte count.
; All registers preserved except CX (returned length).
unbrace	proc	far
	or	cx,cx			; count of zero or less?
	jg	unbrac1			; g = no, but could be huge
	ret
unbrac1:push	ax
	push	si			; src and dest are ds:si
	push	di
	mov	di,si			; si = source
	add	di,cx			; skip to end of line + 1
unbrac2:cmp	byte ptr [di-1],' '	; trailing space?
	jne	unbrac3			; ne = no
	dec	di			; backup another byte
	loop	unbrac2
unbrac3:cmp	byte ptr [si],braceop	; now opens with brace?
	jne	unbrac4			; ne = no, nothing to do
	cmp	byte ptr [di-1],bracecl	; ended on brace?
	jne	unbrac4			; ne = no, nothing to do
	mov	cx,di			; ending spot
	sub	cx,si			; minus start
	mov	di,si			; destination
	sub	cx,2			; minus opening and closing braces
	inc	si			; skip opening brace
	push	cx
	push	es
	mov	ax,ds
	mov	es,ax
	cld
	rep	movsb			; copy down text inside braces
	xor	al,al
	mov	bx,di			; report null in BX
	stosb				; forced null terminator
	pop	es
	pop	cx
unbrac4:pop	di
	pop	si
	pop	ax
	clc
	ret
unbrace	endp

; 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
