title k20par - Kermit-20 Parsing and Semantic Action Routines

; All parsing was removed from k20mit and moved to this module as part
; of Edit 194 to address the issue of a very large single source file
; that unexpectedly began generating MCRNEC errors.  Most user level
; parsing happens here accept what has been moved into other modules,
; viz:
;
;    k20mac - Kermit macro support, extensive rewrite to catch bugs
;	      and enhancements.
;
;    k20ioc - Kermit INPUT/OUTPUT/TRANSMIT support, extensive rewrite
;	      to better support a batch job, fixes bugs, efficiency.
;	      Also has parity parsing, (table driven) generation and
;	      checking.
;	      
;    k20srv - Kermit LOCAL/REMOTE/SERVER support.
;
; Also has many semantic action routines to keep k20sub from swelling.
; Most semantic action routines are a handful of lines to simply set
; the variables that were confirmed by the user during parsing.  Others
; are longer, it not always being clear cut where something should go,
; k20net or k20sub or ...
;
; As a general rule, the majority of the code to handle the protocol
; itself remains in K20MIT.
;
; During this time, some code was rewritten to decrease symbol table
; usage, to (hopefully) clean up control flow and provide for
; additional checking and better recovery.  Speed ups were not avoided
; where possible, typically space being traded for time.  However,
; this was not done at the expense of clarity, maintainability being
; of paramount concern.  At least it's supposed to be more clear...

	subttl Preliminaries

	search monsym,macsym,cmd,k20unv ;[194]
	cmdacs			; Clean up p1-p4 definitions
	cmdunv		;[248] 	; CMDSTG externals and definitions

	sall			; Tidy listing
	.directive flblst	; We don't need to see all the ASCIZ bytes...

	remark common parsing external data

	extern pars1		; Data from first parse.
	extern pars2		; Data from second parse.
	extern pars3		; Data from third parse.
	extern pars4		; Data from fourth parse.
	extern pars5		;[41] ...
	extern pars6		;[218] 
	extern pars7		;[236] 
	extern pars8		;[245] If debugging MOVSTU
	extern pars9		;[247] If debugging IACIAC
	extern parsx		;[203] For zeroing the above between parses

	extern setcsb		; Set up command state block
	extern buffer		; Used for foreign file names

	extern vtermf		; Set if remote line is a virtual terminal

	remark Linkages to commands parsed and executed in k20srv

	extern .bye, $bye	;[220] Cause remote to Logout/Logoff
	extern .finis, $finis	;[220] Force remote to exit server mode
	extern .ycdup,$ycdup	;[254] LOCAL Change to Upper (Superior) Directory
	extern .ycwd,$ycwd	;[220] LOCAL Change Working Directory (I.E., Connect)
	extern .ydele,$ydele	;[220] LOCAL file delete (remove files)
	extern .ydire,$ydire	;[220] LOCAL directory (list files)
	extern .ydisk,$ydisk	;[220] LOCAL Space command (show used and quota)
	extern .ypwd,$ypwd	;[220] LOCAL Print Working Directory (see CWD)
	extern .yrun,$yrun	;[220] LOCAL Run a program (in a subfork)
	extern .stat,$stat	;[220] Parsing is in k20srv, semantic is in k20dsp
	extern .ytype,$ytype	;[220] LOCAL type file

	remark tables we fill or use for parsing

	extern jobtab		; Our job information
	extern filjfn		; A file JFN
	extern rufork		; run fork handle
	extern takjfn		; Current JFN in take file
	extern takep		; Take file stack pointer
	extern iniflg		; If we're doing an INI file

	remark Some JFN handling
	extern clsjfn		;[194] In k20net
	extern tlgjfn		;[264] Transaction log JFN in k20mit
	extern sesjfn		;[264] Session log JFN in k20mit
	extern sesflg		;[264] Active session logging in k20mit
	extern qlog		;[264] Quiet session logging in k20mit
	extern rlog		;[264] Resume session loggin in k20mit

	remark support routines and hard data

	extern putc		;[217] Print a control character
	extern isnulj		; Is this JFN pointing to NUL:?
	extern movstu		; Move string, chewing leading whitespace
	extern parity		;[223] Holds a parity ROUTINE address
	extern crlf		; Carriage return line feed
	extern crlflf		; Carriage return line feed line feed
	extern ifcrlf		; Maybe type a carriage return line feed
	extern nul4		; Pointer to NUL: constant and length
	extern %%jser		; JSYS error handler
	extern %wtlog		; Logging support
	extern %%smsg		;[216] smsg support
	extern errptr		; Error pointer
	extern capas		;[217] Enabled capabilities

	.psect code/ronly	;[190] Don't allow stores

	subttl Top-Level commands available to remote KERMIT

;N.B., When parsing for .cmtxt and .cmcfm, .cmcfm must come first!!!!

	%table(cmdtab,G)	;[194] Declare for main parser
	%keyf4 <bye>, .bye, $bye, cm%inv ;[11]
	%keyf3 <c>, %conn, <cm%inv!cm%abr>
	%key3 <capture>, .captu##, $captu## ;[268] in k20ioc
	%keyf4 <cd>, .ycwd, $ycwd, cm%inv ;[145] ;[194] 
	%key3 <cdup>, .ycdup, $ycdup ;[254]
	%keyf4 <cld>, .clear, $clear, cm%inv ;[209] 
	%key3 <clear>, .clear, $clear ;[162] ;[194] 
	%key3 <close>, .close, $close ;[194] 
	%keyf4 <clr>, .clear, $clear, cm%inv ;[209] 
	%keyf4 <cls>, .clear, $clear, cm%inv ;[209] 
%conn:	%key3 <connect>, .conne, $conne##	;[186] ;[194] 
	%key3 <cwd>, .ycwd, $ycwd ;[145] ;[194] 
	%key3 <define>, .defin##, $defin## ;[77] ;[194] ;[203] 
	%key3 <delete>, .ydele, $ydele  ;[145] ;[194] 
	%key3 <directory>, .ydire, $ydire ;[145] ;[194] 
	%keyf3 <e>, %exit, <cm%inv!cm%abr>
	%key3 <echo>, .echo, $echo ;[194] 
%exit:	%key3 <exit>, .exit, $exit
	%keyf4 <finish>, .finis, $finis, cm%inv ;[28] ;[194] 
	%keyf4 <get>, .get, $get##, cm%inv ;[11] ;[194] 
	%key3 <help>, .help, $help ;[194] 
	%keyf4 <input>, .input##, $input##, cm%inv ;[159] ;[194] 
	%key3 <local>, .local, $local ;[56] ;[194] 
	%key3 <log>, .log, $log ;[125]  ;[194] 
	%keyf4 <output>, .outpu##, $outpu##, cm%inv ;[159] ;[194] 
	%keyf4 <pause>, .pause, $pause, cm%inv ;[159] ;[194] 
	%keyf4 <prompt>, .promp, $promp, cm%inv ;[194] 
	%keyf3 <pu>, %push, <cm%inv!cm%abr>
%push:	%key3 <push>, .push, $push## ;[152] ;[194] 
	%keyf4 <put>, .send, $send## ,cm%inv ; Sleepy Tom keeps typing this...
	%key3 <pwd>, .ypwd, $ypwd ;[188] ;[194] 
	%key3 <quit>, .exit, $exit
	%keyf3 <r>, %recv, <cm%inv!cm%abr> ;[56]
%recv:	%key3 <receive>, .recv, $recv## ;[194] 
	%keyf4 <remote>, .remot, $remot, cm%inv ;[56] ;[194] 
	%key3 <return>, .retur, $retur	;[237] 
	%key3 <run>, .yrun, $yrun ;[145] ;[194] 
	%keyf3 <s>, %send, <cm%inv!cm%abr>
%send:	%key3 <send>, .send, $send## ;[194] 
	%key3 <server>, .serve, $serve ;[194] 
	%key3 <set>, .set, $set
	%key3 <show>, .show, $show ;[194] 
	%key3 <space>, .ydisk, $ydisk ;[145] ;[194] 
	%key3 <statistics>, .stat, $stat ;[194] 
	%key3 <take>, .take, $take ;[78] ;[194] 
	%keyf4 <time>, .time##, $time##, cm%inv ;[210] 
	%key3 <toggle>, .toggl, $toggl	;[264] 
	%keyf4 <transmit>, .trans##, $trans##, cm%inv ;[165] ;[194] (allow debugging)
	%key3 <type>, .ytype, $ytype ;[145] ;[194] 
	%keyf4 <xmit>, .trans##, $trans##, cm%inv ;[165] ;[194] C-Kermit synonym
	%tbend

	cleans(<%conn,%exit,%push,%recv,%send>)

	subttl Top level commands available to local KERMIT.

	%table(cmdtb2,G)	;[194] Declare for main parser
	%key3 <bye>, .bye, $bye ;[11]	;[194] 
	%keyf3 <c>, %conn2, <cm%inv!cm%abr>
	%key3 <capture>, .captu##, $captu## ;[268] in k20ioc
	%keyf4 <cd>, .ycwd, $ycwd, cm%inv ;[145] ;[194] Sleepy Tom...
	%key3 <cdup>, .ycdup, $ycdup ;[254]
	%keyf4 <cld>, .clear, $clear, cm%inv ;[209] 
	%key3 <clear>, .clear, $clear ;[162] ;[194] 
	%key3 <close>, .close, $close	;[194] 
	%keyf4 <clr>, .clear, $clear, cm%inv ;[209] 
	%keyf4 <cls>, .clear, $clear, cm%inv ;[209] 
%conn2:	%key3 <connect>, .conne, $conne##	;[194] 
	%key3 <cwd>, .ycwd,$ycwd ;[145] ;[194] 
	%key3 <define>, .defin, $defin ;[77] ;[194] 
	%key3 <delete>, .ydele, $ydele ;[145] ;[194] 
	%key3 <directory>, .ydire, $ydire ;[145]
	%keyf3 <e>, %exit2, <cm%inv!cm%abr>
	%key3 <echo>, .echo, $echo ;[194] 
%exit2:	%key3 <exit>, .exit, $exit ;[194] 
	%key3 <finish>, .finis, $finis ;[28] ;[194] 
	%key3 <get>, .get, $get##	;[11] ;[194] 
	%key3 <help>, .help, $help ;[194] 
	%key3 <input>, .input##, $input## ;[159] ;[194] 
	%key3 <local>, .local, $local ;[56] ;[194] 
	%key3 <log>, .log, $log ;[125] ;[194] 
	%key3 <output>, .outpu##, $outpu## ;[159] ;[194] 
	%key3 <pause>, .pause, $pause ;[159] ;[194] 
	%keyf4 <prompt>, .promp, $promp, cm%inv ;[194] 
	%keyf3 <pu>, %pus1, <cm%inv!cm%abr>
%pus1:	%key3 <push>, .push, $push## ;[152] ;[194] 
	%keyf4 <put>, .send, $send##,cm%inv ; Sleepy Tom keeps typing this...
	%key3 <pwd>, .ypwd, $ypwd ;[188] ;[194] 
	%key3 <quit>, .exit, $exit ;[194] 
	%keyf3 <r>, %recv2, <cm%inv!cm%abr> ;[56]
%recv2:	%key3 <receive>, .recv, $recv## ;[194] 
	%key3 <remote>, .remot, $remot ;[56] ;[194] 
	%key3 <return>, .retur, $retur	;[237] 
	%key3 <run>, .yrun, $yrun ;[145] ;[194] 
	%keyf3 <s>, %snd2, <cm%inv!cm%abr>
%snd2:	%key3 <send>, .send, $send ;[194] 
	%keyf4 <server>, .serve, $serve, cm%inv ;[194] 
	%key3 <set>, .set, $set ;[194] 
	%key3 <show>, .show, $show ;[194] 
	%key3 <space>, .ydisk, $ydisk ;[145] ;[194] 
	%key3 <statistics>, .stat, $stat ;[194] 
	%key3 <take>, .take, $take ;[78] ;[194] 
	%keyf4 <time>, .time##, $time##, cm%inv ;[210] 
	%key3 <toggle>, .toggl, $toggl	;[264] 
	%key3 <transmit>, .trans##, $trans## ;[165] ;[194] 
	%key3 <type>, .ytype, $ytype ;[145] ;[194] 
	%keyf4 <xmit>, .trans##, $trans##, cm%inv ;[165] ;[194] C-Kermit synonym
	%tbend

	cleans(<%conn2,%exit2,%pus1,%recv2,%snd2>)


	subttl Check to see if floating number is reasonable

; Converts floating seconds to milliseconds
;
; Call:
;
;  t2/	Candidate floating point seconds
;
; Returns:
;
; +1/	Failure
;
;     pars4/	0
;     pars5/	0
;
; +2/	Sucess
;
;     pars4/	Integer milliseconds
;     pars5/	Floating seconds as parsed
;
; Single point precision is sufficient as double precision would only
; give us resolution in the sub-microsecond range, which is below
; Tops-20's scheduling quantum (1 ms).
;
; Since such accuracy is not of paramount concern, a rounding multiply
; is used as it will round up.  This is more conservative, which is
; not a bad idea if you are using a system, front end, router or
; network that is choking on you.
;
; However, we do the math conservatively in case there is some joker
; giving us a silly number. 

; Various processor flags for mathmatical conditions 

arithf==PC%OVF!PC%CY0!PC%CY1!PC%FOV!PC%ATN!PC%FUF!PC%NDV

	remark			;[214] Actual code 

chksec:	entry chksec		;[214] Also used by k20ioc
	remark t2, .cmflt	;[196] Has result of .cmflt
	ife. t2			;[212] Special case floating zero
	  dmove t1, [   0	;[212] Use a special talsiman to trigger
		      .infin  ]	;[212] 		the proper double store
	  dmovem t1, pars4	;[212] Store special cased parse items
	  retskp		;[212] Return a successful conversion
	endif.
				;[214] Set up a stack frame for better control flow
	block.			;[212] Doing anything, anyway?
	  xsfm t3		;[196] Grab flags
	  txz t3, arithf	;[196] Whack the arithmetic flags
	  xmovei t4, .+2	;[196] Continues after the xjrstf
	  xjrstf t3		;[196] Clear the flags
	  move t4, t2		;[196] Let's make a copy of it for display
	  fmprx t2, 1000.	;[196] Convert to milliseconds
	  xsfm t3		;[196] Load all the flags
	  txne t3, arithf	;[196] Did we set any of the arithmetic flags?
	   ret			;[196] Sadly, yes.  Punt
	  fixr t1, t2		;[196] Now convert to integer
	  xsfm t3		;[196] But!!! Maybe we better check the math 
	  txne t3, arithf	;[196] Did we set any of the arithmetic flags?
	   ret			;[196] Sadly, yes.  Punt
	  ifn. t4		;[196] Any floating value?
	    skipe t1		;[196] But!!  Too small for a single millisecond?
	  anskp.		;[196] No, just use calculated value
	    movei t1, ^d1	;[196] Too itty-bitty, so use one millisecond
	  endif.		;[196] End case round check
	  retskp		;[196] Return successful conversion
	endbk.			;[212] End of block context
	ifskp.			;[212] If we worked
	  movem t1, pars4	;[196] Store the integer milliseconds
	  movem t4, pars5	;[196] And also the floating point seconds
	  retskp		;[212] And depart, another happy customer
	else.			;[212] Otherwise, failed somehow
	  setzb t1, t2		;[212] Cons up a bunch of zeros
	  dmovem t1, pars4	;[212] And stomp parse storage
	  ret			;[212] Give failure return, +1
	endif.			;[212] End checks

	ret			;[196] Should never get here, so fail

	subttl LOCAL commands

;[56] LOCAL and REMOTE commands added as edit 56

	extern loctab		;[220] Moved to k20srv

	chgsec(code,const)	;;FDB's don't go in code, they go in const
locfdb:	flddb. .cmkey,,loctab
	retsec			;;Restore .PSECT

.local:	extern lcflg		; If command is local or remotely executed
	setom lcflg		; -1 = local
	movei t1, locfdb 	; LOCAL ... what?
	jrst .remo2		; Go parse the rest.

	remark Local command execution

$local:	move t2, pars2		; Get back data value.
	hrrz t1, (t2)		; Get evaluation routine.
	call (t1)		; Call it.
	ret

	subttl REMOTE command main parser

	extern remtab		;[220] Moved to k20srv to help organize module

.remot:	extern lcflg		; If command is local or remotely executed
	setzm lcflg		; 0 = remote
	movei t1, [flddb. .cmkey,,remtab] ; REMOTE exection

.remo2:	call rfield		; Parse a keyword.
	hrrz t2, (t2)		; Get the command routine addresses.
	movem t2, pars2		; Save into pars2.
	hlrz t1, (t2)		; Get the next level routine.
	call (t1)		; Call it.
	ret

	remark REMOTE command execution

$remot:	extern takdep, local	;[194] In k20mit
	skipe takdep		;[177] OK from TAKE file
	 jrst $local		;[177]
	ifme. local		;[194] Are we running remote?
	  emsg <Must SET LINE before issuing a REMOTE command> ;[187] 
	  ret
	endif.			;[194] 

	callret $local

	subttl RETURN command parsing and execution

.retur:	guide (<from processing the current command file>) ;[237] 
	confrm			;[237] Tie off the line
	ret			;[237] Done with this easy parse

$retur:	ifme. takdep		;[237] First of all, are we even in a take file?
	  txmsg <% Not currently taking commands from a file, ignored.
>				;[237] No harm, no foul
	  ret			;[237] Done
	endif.			;[237] End case not in a take file

	hrrz t1, takjfn		;[237] Load JFN of take file
	seto t2,		;[237] Set End-of-File talisman 
	SFPTR%			;[237] Try to force End-of-File
	 %jserr(<Unable to force End-of-File on current TAKE file>,r) ;[237] 
	ret			;[237] Finally done

	subttl CLEAR command parse tables

;[211] Entirely rewritten to handle enhanced buffer clearing

	%table(clrswi)
	%keyf3 <d>, %cld, <cm%inv!cm%abr>
%cld:	%key2 <display>, $clrbd	 ; Show actual characters cleared
	%keyf3 <dsp>, $clrbd, cm%inv ; Tom's fat fingers
	%key2 <estimate>, $clrbe ; Show monitor's buffer size counts
	%key2 <flush>, $clrbf	 ; Default, if confirmed
	%key2 <peek>, $clrbp	 ; Show what is in buffered input
	%tbend

	cleans(<%cld>)		;;Clean up generated symbol

	chgsec(code,const)	;;Chained FDB's are not in code, they're in const
clrfdb:	flddb. .cmswi,,clrswi,,,clrfd1
clrfd1:	flddb. .cmcfm,,,<to flush all characters,>
	retsec			;;Back to where-ever we started from
	cleans(<clrfd1>)

	%table(repswi)
	%key2 <always>, .clral	 ; Show summary on each iteration
	%key2 <repeat>, $clrbr	 ; How many times to repeat the clear
	%tbend

	chgsec(code,const)	;;Chained FDB's are not in code, they're in const
repfdb:	flddb. .cmswi,,repswi,,,repfd1
repfd1:	flddb. .cmcfm,,,<to execute the clear,>

cntfdb:	flddb. .cmcfm,,,<to default /repeat to five times,>,,cntfd1
cntfd1:	flddb. .cmnum,,^d10,<Number of times to issue clear,>,<5>

cmafdb:	flddb. .cmcfm,,,<to default the delay to one second,>,,cmafd1
cmafd1:	flddb. .cmcma,,,<to specify a delay interval,>

clrflt:	flddb. .cmflt,,^d10,<Number of seconds to pause between clears,>,<1>

	retsec			;;Back to where-ever we started from
	cleans(<repfd1,cntfd1,cmafd1>)

	subttl CLEAR command primary parsing

.clear:	guide <line>
	setzb t2, t3		; No repetition, so no delay
	dmovem t2, pars3	; Make sure downstream is not confused
	dmovem t2, pars5	;	...By anything...

	movei t1, clrfdb	; Parse a primary switch
	call rfield		; Try to figure out what they want...
	hrrz t2, (t2)		; Pick up semantic action
	ldb t3, [pointr (.cmfnp(t3),cm%fnc)] ; Get function code.

	caie t3, .cmcfm		; Confirmation?
	ifskp.			; Yes, default is to flush everything
	  movei t2, $clrbf	; So pretend we parsed that
	  movem t2, pars2	; Store routine to call
	  ret			; We're done
	endif.			; End case taking default

	saveac <q1,q2,q3,q4>	; Need another register for a complex parse
	move q1, t2		; Store the primary action
	setz q4,		; Assume never repeating

	do.			; Enter loop context
	  movei t1, repfdb	; See if they want to repeat the command
	  call rfield		; Go see what they picked
	  ldb t3, [pointr (.cmfnp(t3),cm%fnc)] ; Get function code.
	  caie t3, .cmcfm	; Confirmed?
	  ifskp.		; Yes, then didn't want to repeat repeat
	    movem q1, pars2	; Store original routine to call
	    ret			; We're done
	  endif.		; End case no /REPEAT
	  cain t3, .cmswi	; Otherwise, better be a switch
	  ifskp.		; Yet wasn't
	    emsg <Unknown parse item for CLEAR switch>
	    jrst cmder1		; Allow reparse
	  endif.		; End case parse inconsistency
	  hrrz t4, (t2)		; Pick up switch semantic action
	  cain t4, $clrbr	; Wants to tie off switch with /REPEAT?
	   exit.		;  Yes, so fall out of loop and parse that
	  call (t4)		; Otherwise, call the rest of the parse
	  loop.			; Go back and do something else
	enddo.			; End of loop lexical context

	movei t1, cntfdb	; See if they want to specify count (always)
	call rfield		; Go see what they picked
	ldb t3, [pointr (.cmfnp(t3),cm%fnc)] ; Get function code.

	caie t3, .cmcfm		; Confirmed?
	ifskp.			; Then taking repeat defaults
	  movei t1, $clrbr	; Load address of wrapper
	  movem t1, pars2	; We will call this routine
	  movem q1, pars3	; And it will call the requested routine
	  dmove q2, [exp ^d5,^d1000] ; Load default repeat and delay
	  dmovem q2, pars4	; Store both
	  movem q4, pars6	; Pass always display flag in
	  ret			; We're done
	endif.			; End case no /REPEAT arguments

	move q2, t2		; Save repeat count
	ifl. t2			; Is this a silly number?
	  emsg <Negative repeats are not logical>
	  jrst cmder1		; Allow reparse
	endif.

	movei t1, cmafdb	; See if they want to specify delay
	call rfield		; Go see what they picked
	hrrz t2, (t2)		; Pick up semantic action
	ldb t3, [pointr (.cmfnp(t3),cm%fnc)] ; Get function code.

	caie t3, .cmcfm		; Confirmed?
	ifskp.			; Then taking default delay
	  movei t1, $clrbr	; Load address of wrapper
	  movem t1, pars2	; We will call this routine
	  movem q1, pars3	; And it will call the requested routine
	  remark q2, t2		; Repeat count from above
	  movei q3, ^d1000	; Load default delay
	  dmovem q2, pars4	; Store both
	  movem q4, pars6	; Pass always display flag in
	  ret			; We're done
	endif.			; End case no /REPEAT arguments

	movei t1, clrflt	; Pick up the delay
	call rfield		; Go see what they picked

	ifl. t2			; Is this a silly number
	  emsg <Negative repeat intervals are not logical>
	  jrst cmder1		; Allow reparse
	endif.

	remark			; When chksec works, it works completely
	call chksec		; Ensure number is in correct range
	ifskp.			; Check and convert OK?
	  confrm		; It did, tie off the line
	else.			;[196] Otherwise, couldn't swallow something
	  emsg <Pause is out of range> ;[196] 
	  jrst cmder1		;[196] Allow reparse
	endif.			;[196] End case checking and conversion

	movei t1, $clrbr	; Load address of wrapper
	movem t1, pars2		; We will call this routine
	move q3, pars4		; Pick up the milliseconds
	dmovem q1, pars3	; Requested routine and repetition
	dmovem q3, pars5	; Delay in milliseconds and always
	ret			; Done with the parse

.clral:	remark			; Here to parse rest of /ALWAYS
	seto q4,		; Flag always displaying summary
	ret			; That was easy enough...

	remark Begin execution of CLEAR command

$clear:	saveac <q1>		; All need an extra register
	move t1, pars2		; Load routine to call
	callret (t1)		; Hand off execution, appropriately

	subttl Repeatedly execute a CLEAR command

	chgsec(code,data)	;;Get out of code because need some storage
ichrcn:	block 1			; Initial character count
$clrit:	block 1			; Loop iterations
$clraf:	block 1			; Always flag
	retsec			;;Back in code

	extern ccon,ccoff	; Used to break out of the loop
	extern cyon, cyoff	; Turn Control-Y on and off
	extern cyseen		; Control-Y typed
	extern statim		; Start timing
	extern vchrcn		;[211] Virtual characters cleared

$clrbr:	saveac <q1,q2,q3,q4>	; Will need some registers for control

	dmove q2, pars3		; Load routine and repetition count
	move q4, pars5		; Ditto interval duration
	move t1, pars6		; Load always flag
	movem t1, $clraf	; Store same

	move t1, vchrcn		; Load grand total characters ever flushed
	movem t1, ichrcn	; Store as our initial count
	setzm $clrit		; No iterations

	call ccon		; Allow us to stop doing this
	 jrst $clrb1		; Turn it off and get out of here
	ifme. $clraf		; Always displaying?
	  call cyon		; No, so hook to give us some small statistics
	   jrst $clrb1		; Then display and don't hook ^Y
	endif.			; End case doing /ALWAYS
	call statim		; Record start time of loop

	do.			; Enter loop context
	  remark q1,		; Do *NOT* use q1 as these routine smash it
	  skipn $clraf		; If doing /ALWAYS, then pretend hit a ^Y
	   skipe cyseen		; Typed a Control-Y?
	    call $clrby		; Go give us a status report
	  aos $clrit		; Count a loop iteration
	  call (q2)		; Go do whatever we got told to do
	  sojle q3, endlp.	; Exit loop if count exhausted
	  txmsg <Reps: >
	  movei t1, .priou	; This terminal (of course)
	  move t2, q3		; Load the loop counter
	  movei t3, ^d10	; It's always in base ten
	  NOUT%
	   erjmpr .+1		; Catch and ignore error
	  txmsg <, Pau: >
	  skipg t2, q4		; Load the sleep interval
	  ifskp.		; Positive, so type it
	    movei t1, .priou	; Still this terminal (of course)
	    move t2, q4		; Load the loop counter
	    remark t3, ^d10	; It's still there
	    NOUT%
	     erjmpr .+1		; Catch and ignore error
	    txmsg < ms
>				; It's in milliseconds
	    move t1, q4		; Load sleep
	    skipn cyseen	; Don't sleep if Control-Y typed
	     DISMS%		; Nite nite!
	    $clrbs==:.		; Location of JSYS as reported
	  else.			; Unless there isn't one
	    txmsg < None
>				; Make that obvious
	  endif.		; End user update
	  loop.			; And flush some more
	enddo.			; End of loop lexical context

	call ccoff		; Turn ^C back off; not needed now
	skipn $clraf		; If never turned it on, don't need to turn it off
	 call cyoff		; Turn ^Y off, no loop information anymore
	call $clrby		; Give summary
	ret			; And done

	remark Error handler

$clrb1:	call ccoff		; Turn ^C back off; not needed now
	call cyoff		; Turn ^Y off, no loop information now
	movei t1, .priou	; This terminal's output stream
	CFOBF%			; Toss the rest of the output
	 %jserr (<Unable to discard local output on early termination>,)
	txmsg <^C
>				; Flushes the interrupt message
	movei t1, .priin	; This terminal's input stream
	CFIBF%
	ret

	subttl Clear Buffer Loop status report

	extern endtim		; End timing
	extern elptim		; Computes elapsed time
	extern durtim		; Prints the duration (of elapsed time)
	extern ewallt		; Wall time structure

$clrby:	saveac <t1,t2,t3,t4,q1>	; Don't touch any registers

	txmsg <Iterations: >	; Begin the blat
	movei t1, .priou	; This terminal
	move t2, $clrit		; Load iterations
	movei t3, ^d10		; In base 10
	NOUT%			; Print them
	 %jserr(,)		;  Or not, but carry on

	txmsg <, Cleared: >
	move t2, vchrcn		; Load grand total characters ever flushed
	sub t2, ichrcn		; Subtract inital count
	ifg. t2			; Have we cleared anything?
	  movei t1, .priou	; We have, print it
	  movei t3, ^d10	; In base 10
	  NOUT%
	   %jserr(,)		;  Or not, but carry on
	else.			; Otherwise, haven't done too much
	  txmsg <None>		; Oh well...
	endif.

	call endtim		; Take a snapshot from right now
	call elptim		; Calculates elapsed time

	movei q1, ewallt	; Resolve address of elapsted DK10 double word
	dmove t2, .datus(q1)	; Load the actual value
	or t2, t3		; Checking for non-zero either word
	ifn. t2			; Did this take any time, actually?
	  txmsg <, Elapsed: >	; Seperate from characters cleared
	  movei t1, .priou	; Going to terminal
	  move t2, q1		; Load pointer to time structure
	  call durtim		; Nicely print the duration
	   nop			; Ignore any goofy return
	endif.			; End case positive elapsed time

	hrroi t1, crlf		; Tie off the line
	PSOUT%
	setzm cyseen		; Last thing is to clear the flag
	ret			; In case typed while we're printing

	subttl Execute the CLEAR /FLUSH command

$clrbf:	extern ttxon,clrbuf	; clrbuf is in k20net
	extern inpclr		; whereas inpclr is in k20ioc
	saveac <q1>

	ifme. vtermf		; Physical line?
	  call ttxon		; Clear output buffer, send XON, etc.
	endif.

	call clrbuf		; Also clear terminal buffers
	 ret			; Error, go no further
	move q1, t1		; Otherwise, save character count

	call inpclr		; Clear any stuff waiting for INPUT
	ifskp.			; Worked??
	  add q1, t1		; Yes, add to total
	endif.

	txmsg <Characters flushed: > ; Begin blat
	movei t1, .priou	; Continue on terminal
	move t2, q1		; Load count of characters flush
	movx t3, fld(^d10,no%rdx) ;Base ten
	NOUT%			; Type it
	 erjmpr .+1		; Catch and ignore error
	hrroi t1, crlf		; Tie off line
	PSOUT% 
	ret

	subttl Print an estimate of characters we could flush

; N.B., Tops-20 only knows what is in its buffers, not the other
;	system.

$clrbe:	extern clrest		; Found in k20net
	call clrest		; Get an estimate
	 ret			; Just return, already complained

	move q1, t1		; Otherwise, save character count
	txmsg <Estimated flush: > ; Begin blat
	movei t1, .priou	; Continue on terminal
	move t2, q1		; Load estimated character count
	movx t3, fld(^d10,no%rdx) ; Base ten
	NOUT%			; Type it
	 erjmpr .+1		; Catch and ignore error

	txmsg < chars
>
	ret

	subttl Clear and display text

	extern clread		; Clear buffer and return contents
	extern s8ccv7		; Convert 8 bit to controlified ASCII

$clrbd:	remark q1,		; Already saved
	saveac <q2, q3, q4>	; Need ever more registers ...

	dmove q1, inpcnt	; Set register context for inpbfc
	ifg. q1			; Anything to toss?
	  call $clrbp		; Print it
	anskp.			; Failed, it's gone
	  call inpclr		; Otherwise, chuck it
	   nop			; ??  $clrbp should have check already
	endif.			; Either way, carry on

	remark			; Now get the data out of the monitor
	setz q1,		; Assume had nothing to flush

	do.			; Enter loop context
	  call clread		; Return characters we tossed
	   exit.		; Failed, get out of here
	  jumpe t1, endlp.	; Nothing there?  We're done
	  add q1, t1		; Otherwise add to tally
	  move q2, t2		; Store buffer pointer
	  do.			; Enter inner loop
	    call s8ccv7		; Convert as much as we can
	     exit.		;  Or not
	    move q3, t1		; Store remaining length
	    move q4, t4		; And updated pointer
	    movei t1, .priou	; This terminal
	    SOUT%		; Counted SOUT%
	     %jserr (<Couldn't display cleared characters>,r)
	    jumpe q3, endlp.	; Leave inner if we typed all of it
	    dmove t1, q3	; Otherwise, updated pointers are new input
	    loop.		; And convert the rest of them
	  enddo.		; End inner conversion and display loop
	  loop.			; See if anything else to flush
	enddo.			; Exit loop context

	txmsg <
Characters cleared: >		; Begin blat
	movei t1, .priou	; Continue on terminal
	move t2, q1		; Load character count
	movx t3, fld(^d10,no%rdx) ; Base ten
	NOUT%			; Type it
	 erjmpr .+1		; Catch and ignore error
	hrroi t1, crlf		; Tie off line
	PSOUT% 
	ret

;[211] End of rewrite

	subttl Peek at Buffered input from OUTPUT for INPUT

;[209] Begin code insertion

; Does some buffer checks and corrections

	extern inpcnt		; Double word character count/append pointer
	extern inpbfc		; Checks INPUT buffer consistency

$clrbp:	saveac <q1,q2,q3>	; Needs some registers
	dmove q1, inpcnt	; Load current contents and pair
	call inpbfc		; See if anything is phonky
	 ret			; It is, too bad
	move q3, t1		; Save the text pointer
	ife. q1			; Nothing to do?
	  txmsg <% No buffered input waiting for INPUT command
>				; Advise that there will be nothing to see
	  ret			; That was easy...
	endif.

	txmsg <Buffered: >	; Start the blat
	remark			; Remarkably like prnbuf in k20ioc...
	movei t1, .priou	; This terminal
	move t2, q1		; Load the character count
	movei t3, ^d10		; Which is in decimal
	NOUT%			; Type it
	 %jserr (<Could not display buffered input count>,r) ; Odd, but carry on
	txmsg <, '>		; And prepare for the contents
	movei t1, .priou	; Still going to the terminal
	move t2, q3		; And pointer to the beginning of text
	movn t3, q1		; Negative length for counted SOUT%
	SOUT%			; Because a counted SOUT% is faster
	 %jserr (<Could not display buffered input>,r) ; Odd, but carry on
	txmsg <'

>				; Tie off the line
	ret			; Done

;[209] End code insertion


	subttl CLOSE command

	%table(clstab)
	%key2 <all>,$closa		;[198] Close all log files
	%key2 <debugging>,$closd	;[198] 	;[143]
	%key2 <session>,$closs		;[198] Close session log
	%key2 <transactions>,$clost	;[198] Close transaction log
	%tbend

	chgsec(code,const)	;;Chained FDB's are not in code, they're in const
clsfdb:	flddb. .cmkey,,clstab,,,clsfd1
clsfd1:	flddb. .cmcfm,,,<to close all logs,>
	retsec			;;Back to where-ever we started from
	cleans(<clsfd1>)

.close:	guide (logging of)
	movei t1, clsfdb	;[198] Parse what kind of log.
	call rfield
	hrrz t2, (t2)		;[198] Pick up semantic action
	ldb t3, [pointr (.cmfnp(t3),cm%fnc)] ;[198] Get function code.
	caie t3, .cmcfm		;[198] Confirmation?
	ifskp.			;[198] Yes, default is to close ALL of them
	  movei t2, $closa	;[198] So pretend we parsed that
	  movem t2, pars2	;[198] Store routine to call
	else.			;[198] Otherwise, use whatever we parsed
	  movem t2, pars2	;[198] So store the routine to call
	  confrm		;[198] and confirm the line
	endif.
	ret

	subttl Execute CLOSE command

$close:	move t4, pars2		; Load routine to call
	setz t1,		; Make a zero.
	callret (t4)		;[198] Switch execution appropriately

	subttl Driver to close all logs

;[198] Begin code insertion

$closa:	saveac <q1,q2>		; Used for loop control and call targets
	hlrz q1, clstab		; Load count of entries in keyword table
	ife. q1			; Sanity check; did we pick up any nonsense?
	  emsg <CLOSE ALL given an impossible table to process>
	  hrroi t1, crlf	; Tie off the line
	  PSOUT
	  ret			; Get out of here
	else.			; Otherwise, assume at least that part is right
	  movei q2, <clstab+1>	; Load address of first TBLUK% entry
	endif.

	do.			; Enter loop context
	  hrrz t4, (q2)		; Pick up semantic action
	  caie t4, $closa	; Do not infinitely recurse ourself!!
	   call (t4)		;  Otherwise, get something closed
	  movei q2, 1(q2)	; Bump to next table entry
	  sojg q1, top.		; Step to the next log file type
	enddo.			; End loop lexical context

	ret			; Finally done

;[198] End code insertion

	subttl Log closing prologues

$clost:	setz t1,		; Stomp t1 to whack tlgjfn
	exch t1, tlgjfn		; Load transaction log JFN and zero it.
	sxtext (t3,<Transaction>) ;[198] some more granular blat
	jrst $closx		;[198] Hit common code

$closs:	entry $closs		;[198] Also hit if failure when session logging
	setz t1,		; Stomp t1 to whack sesjfn
	exch t1, sesjfn		; Load session log JFN and zero it.
	sxtext (t3,<Session>)	;[198] some more granular blat
	setzm sesflg		;[195] Whether open or not, no longer active
	jrst $closx		;[198] Hit common code

$closd:	entry $closd		;[198] Also hit if debugging log failure
	setz t1,		; Stomp t1 to whack logjfn
	exch t1, logjfn		; Load debugging log JFN and zero it.
	sxtext (t3,<Debugging>)	;[198] some more granular blat
	remark $closx		;[198] Hit common code (falls through)

	subttl Log closure common code

$closx:	skiple t2, t1		;[198] Move JFN to t2 for JFNS, check for validity.
	ifskp.			;[198] If no valid JFN, give this message.
	  movx t1, "%"		;[198] Flag a comment, not an error
	  PBOUT%
	  move t1, t3		;[198] Load logging in question
	  PSOUT%		;[198] Blat about it
	  txmsg < logging was not being done> ;[187]
	  hrroi t1, crlf	;[198] End the line
	  PSOUT
	  ret			
	else.			;[198] Otherwise, assume OK
	  tlz t2, -1		;[198] But bonk any flags, just in case
	  cain t2, .priou	;[221] Wait a second, was this primary output?
	   ret			;[221] Just shut up and get on with it
	  saveac <q1,q2>	;[198] Save some accumulators
	  move q1, t3		;[198] Save the logging type
	endif.			;[198] 

	txmsg <[Closed log: >	;[198] JFN looks OK - opening bracket for message.
	move t1, q1		;[198] Load the log type
	PSOUT%			;[198] And type it
	txmsg <; >		;[198] Offset the device or file name
	movei t1, .priou	; Type the filename to primary output
	caie t2, .nulio		;[198] Was just dumping it?
	ifskp.			;[198] Yes, no sense flogging the 'JFN'
	  dmove t2, nul4	;[198] Counted constant string
	  SOUT%			;[198] Blat
	   %jserr (,)		;[198] Complain, but continue
	  seto q2,		;[198] .nulio doesn't count bytes
	else.			;[198] Otherwise, a real file to close
	  setzb t3, t4		;[198] No goofy prefix
	  JFNS
	   %jserr (,)		;[198] Sigh ...
	  move t1, t2		; JFN back to t1 for other JSYS's.
	  move t3, t2		; Save the JFN here, too.
	  RFPTR			; Get file position.
	  ifje. r		;[198] Catch and ignore error
	    seto q2,		;  On error, substitute -1.
	    move t1, t3		;[198] Reload the JFN
	  else.			;[198] Otherwise, got something
	    move q2, t2		;[198] Save the quantity
	  endif.		;[198] 
	  call frclos		;[198] Force the file closed
	   %ermsg (<Unable to close log file>,) ;[198] Yet couldn't...
	endif.			;[198] End .nulio special case

	block.			;[198] Enter block context for better control flow
	  ifle. q2		;[198] Nothing, failure or simulated?
	    movei t1, "]"	;[198] Then don't worry about the quantity
	    PBOUT%		;[198] just close the message
	    ret			;[198] End of this case
	  endif.		;[198] 

	  caie q2, ^d1		;[198] Just did one dinky byte?
	  ifskp.		;[198] Yes, special case that
	    txmsg <, a single Byte Written]> ;[198] 
	    ret			;[198] End of singular case
	  endif.		;[198] 

	  txmsg <, >		;[198] Plural case, then
	  movei t1, .priou	;[198] Going to primary output like everything else
	  move t2, q2		;[198] Load amount written
	  movei t3, ^d10	;[198] Base 10
	  NOUT%			;[198] Type that
	   erjmpr .+1		;[198] 
	  txmsg < Bytes Written]> ;[198] Properly inflected phrase
	endbk.			;[198] Exit block context

	hrroi t1, crlf		;[198] 
	PSOUT%			;[198] 
	ret

	subttl ECHO command switch handlers

	remark First, some dinky switches

echsdb:	setom pars5		;[256] Flag copying into debug log
	ret			;[256] Get another switch
echsia:	setom pars9		;[256] debugging iac doubling
	ret			;[256] Get another switch
echses:	setom pars6		;[256] Flag copying into session log
	ret			;[256] Get another switch
echtrn:	setom pars7		;[256] Flag copying into transaction log
	ret			;[256] Get another switch
echUPP:	setom pars8		;[256] Chew whitespace and UPPERCASE
	ret			;[256] Get another switch

	remark N.B. Semantic action expects the address "none" equals none of the below

	%table(echpsk)		;;[256] Parity switch keyword table
	%key2  <even>, .parev	;;[256] Override to even parity
	%key2  <mark>, .parmk	;;[256] Override to mark (bit 8 always one)
	%key2  <none>, .parno	;;[256] Override to no parity (effectively space)
	%key2  <odd>,  .parod	;;[256] Override to odd parity
	%key2  <space>,.parsp	;;[256] Override to space (bit 8 always zero)
	%tbend			;;[256] End of table

	remark A little more complex parsing for parity override

echfps:	flddb. .cmkey,,echpsk,<To override parity processing,>,,

echpar:	movei t1, echfps	;[256] Load address of parity switch fdb
	call rfield		;[256] Ask him to pick one
	hrrz t1, (t2)		;[256] Pick up switch's associated parity routine
	movem t1, pars2		;[256] Pass to semantic action
	ret			;[256] Get another switch

	subttl ECHO command parsing

	remark 			;;[242] Switch tables
	%table(echswi)		;;[242] Echo switches
	%key2 <debug>, echsdb	;;[256] Copy into debug log
	%keyf3 <IAC>, echsia, cm%inv ;;[256] If debugging iaciac
	%keyf3 <parity:>, echpar, cm%inv ;;[256] Override parity
	%key2 <session>, echses	;;[256] Copy into session log
	%key2 <transaction>, echtrn ;;[256] Copy into transaction log
	%keyf3 <UPPERCASE>, echUPP, cm%inv ;;[256] If debugging MOVSTU
	%tbend			;;[242] End of ECHO switch table

	chgsec(code,const)	;;Chained FDB's are not in code, they're in const
echfdb:	flddb. .cmswi,,echswi,<To also echo text into a LOG file,>,,echfd1 ;;[242] 
echfd1:	flddb. .cmcfm,,,<To echo a blank line,>,,echfd2		;;[242] 
echfd2:	flddb. .cmqst,,,<String for Kermit-20 to echo,>,,echfd3	;;[242] 
echfd3:	flddb. .cmtxt,,,<text for kermit-20 to echo,>		;;[242] 
	retsec			;;Back to where-ever we started from
	cleans(<echfd1,echfd2,echfd3>) ;;[242] 

	extern asczcp		;[226] Only used to return a count

.echo:	guide <text at terminal> ;Issue guide words
	do.			;[242] Enter loop context
	  setzb t1, t2		;[194] Cons up a ten NUL's
	  dmovem t1, atmbuf	;[194] Stomp a bit of the atom buffer
	  movei t1, echfdb
	  call rfield		; Get the string into the atom buffer.
	  ldb t4, [pointr (.cmfnp(t3),cm%fnc)] ; Get function code.
	  caie t4, .cmswi	;[242] Do we get a switch?
	   exit.		;[242] No, we didn't, so break the loop
	  hrrz t1, (t2)		;[242] Pick up switch's variable's address
	  call (t1)		;[256] And flag an echo to a log file
	  loop.			;[242] Get some more switches or text
	enddo.			;[242] End loop lexical context

	caie t4, .cmcfm		;[194] Confirmation?
	 confrm			;[194] No, so tie off the line

	dmove t1, [		;[226] Overwritting the atom buffer in place
	    point 7, atmbuf	;[226] So the source is the atom buffer and
	    point 7, atmbuf  ]	;[226] 		the destination is the atom buffer
	call asczcp		;[226] Move the string on top of itself, returning count
	move t2,[point 7,atmbuf];[226] Load address of string to (expand and) echo
	sosge t3		;[242] Don't count the NUL at the end!!
	 setz t3,		;[242] Stomp if went negative
	dmovem t2, pars3	;[226] Store for semantic action
	skipe tvtflg		;[247] Doing TVT binary?
	 setom pars9		;[247] Yes, force a parse of /IAC
	ret

	subttl ECHO command semantic action [167] + [226] + [242]

	extern movsuc		;[245] Count and uppercase, munching initial space
	extern chrtab		;[226] A translation table for expansion
	extern cescxp		;[226] Routine which uses it to do C expansions
	extern strbuf		;[226] A *really large* output buffer
	extern putpaa		;[256] Routine to forced parity generation
	extern iaciac		;[247] Handle IAC
	extern tvtbuf		;[247] Buffer to handle IAC doubling


	remark			;[256] Parity globals
	extern none		;[226] Routine to do absolutely nothing
	extern stpart		;[256] String based parity tables
	extern genint		;[256] Constructed instruction to generate parity

	remark			;[242] Parse variable usage
	remark pars3		;[242] Pointer to text to echo
	remark pars4		;[242] Length of text to echo

$echo:	saveac <q1,q2,q3>	;[226] Wants some registers

	dmove t2, pars3		;[242] Pointer and length
	ifg. t3			;[242] Reasonable length?
	  move t1, t3		;[242] So can use the length
	  adjbp t1, t2		;[242] Get to the end
	  move t2, t1		;[242] Use that as new pointer
	  addi t3, ^d2		;[242] Will be appending two bytes
	else.			;[242] Otherwise, was a bare .cmcfm
	  movei t3, ^d2		;[242] So will just have two bytes
	endif.			;[242] End case
	movem t3, pars4		;[242] Store updated length, just in case
				;[242] Load CRLF in the right place, backwards
	movx t1, <BYTE (1) 0 (7) 0,0,.CHNUL,.CHLFD,.CHCRT> ;;[242] 
	idpb t1, t2		;[242] Deposit .CHCRT
	lsh t1, -^d7		;[242] Shift in next byte (a .CHLFD)
	idpb t1, t2		;[242] Deposit .CHLFD
	lsh t1, -^d7		;[242] Shift in next byte (a .CHNUL)
	move t4, t2		;[242] Copy of pointer to allow append
	idpb t1, t2		;[242] Deposit .CHNUL (tie off string)
	remark t3,		;[242] But don't count it

	move q2,[point 8,strbuf];[226] Destination is eight bits!!!!
	skipn q3, pars2		;[256] Load any override and skip
	 move q3, parity	;[226] Load current parity setting
	move t1, q2		;[226] Load destination (eight bits)
	move t2, pars3		;[226] Pick up the source pointer
	movei t4, chrtab	;[226] Respect case on expansion
        call cescxp		;[226] Expand string before printing it
         %ermsg (<Error on echo string expansion>,r) ;[226] Don't go any further
        skipg q1, t3		;[226] Save and check final destination length
         %ermsg (<Inconsistency on echo string expansion length>,r)  ;;[242] 

	remark			;[245] This must happen after C escape expansions
	ifmn. pars8		;[245] Debugging MOVSTU?
	  move t1, q2		;[245] Load source
	  move t2, q2		;[245] Load destination
	  call movsuc		;[245] Yes, use that instead of just the counter
	  skipg q1, t3		;[245] Update and check final length
	   ret			;[245] Squeezed everthing out...
	endif.			;[245] End case uppercase

	cain q3, none		;[226] But!!  Are we doing any parity?
	ifskp.			;[247] This must be applied before any IAC
	  camn q3, parity	;[256] Overriding parity?
	  ifskp.		;[256] Yes, must pick the correct table
	    push p, genint	;[256] Save current parity generation, if any
	    push p, t4		;[256] Save for addressing
	    move t4,pars2	;[256] Offset into string based parity table
	    hlrz t2, stpart(t4)	;[256] Load generating table for this parity
	    pop p, t4		;[256] Restore
	    ifn. t2		;[256] Doing anything?
	      hrli t2, (movst 0,0) ;[256] Drop in the extended opcodes
	    endif.		;[256] End case extended instruction construction
	    movem t2, genint	;[256] Override parity checking
	  endif.		;[256] End parity override handler
	  move t2, q2		;[226] Load eight bit source
	  movn t3, q1		;[226] Load negative length for faster SOUT%
	  call putpaa		;[256] Force some kind of parity
	  came q3, parity	;[256] Were we overriding parity?
	   pop p, genint	;[256] Yes, restore what we were doing
	endif.			;[247] End case parity

	ifmn. pars9			;[247] Doing IAC?
	  dmove t1, q1			;[247] Load length and 8 bit source
	  move t3, [point 8, tvtbuf]	;[247] Special buffer for IAC doubling
	  call iaciac			;[247] Go double any IAC's
	   %ermsg (<Unable to double IAC's>,) ;;[247] ??
	  move q1, t4			;[247] Load length of final string
	  move q2, [point 8, tvtbuf]	;[247] Load pointer to final string
	endif.				;[247] End case IAC

	move t1, ttyjfn		;[226] Going to terminal in eight bit mode
	move t2, q2		;[226] Load eight bit source
	movn t3, q1		;[226] Load negative length for faster SOUT%
	setz t4,		;[226] Zero unchecked and unnecessary terminator
	SOUT%			;[226] And spew
	 %jserr(<SOUT% error when trying to echo>,r) ;[226] Don't go any further

	subttl Put ECHO text in indicated log files

	remark			;[242] Parse variable usage
	remark pars5		;[242] Also ECHO to DEBUG log
	remark pars6		;[242] Also ECHO to SESSION log
	remark pars7		;[242] Also ECHO to TRANSACTION log
	extern fintim		;[242] Print fine grained time of day (in k20tim)

	movx q3,<BYTE (7) ":",.CHSPC,.CHNUL> ;[242] Handy string to write

	ifmn. pars5		;[242] ECHO to DEBUG log?
	  skipg t1, logjfn	;[242] Yes, but do we have one open?
	anskp.			;[242] No, we do not, so nothing to do
	  cain t1, .nulio	;[242] Just tossing it?
	anskp.			;[242] Fine, it's tossed
	  smsg (<C,>)		;[242] "C" is for comment (leaving "E" for Error)
	  block.		;[242] Create a stack frame
	    saveac <t1,p3>	;[242] Create register context for fintim
	    move p3, t1		;[242] Put JFN where fintim wants it to be
	    call fintim		;[242] Get some fine grained time
	     %ermsg (<Unable to write fine grained time to debug log>,)	;[242] 
	  endbk.		;[242] Restore registers, tearing down frame
	  dmove t2, [ -1,,q3	;[242] Point to some punctuation
			-2 ]	;[242] Two byte
	  setz t4,		;[242] Zero unchecked and unnecessary terminator
	  SOUT%			;[242] And spew
	   %jserr(<SOUT% error when trying punctuate debug log>,) ;[242] 
	  move t2, q2		;[242] Load eight bit source
	  movn t3, q1		;[242] Load negative length for faster SOUT%
	  SOUT%			;[242] And spew
	   %jserr(<SOUT% error when trying to echo to debug log>,) ;[242] 
	endif.			;[242] End case ECHO to DEBUG log?

	ifmn. pars6		;[242] ECHO to SESSION log?
	  skipg t1, sesjfn	;[242] Yes, but do we have one open?
	anskp.			;[242] No, we do not, so nothing to do
	  cain t1, .nulio	;[242] Just tossing it?
	anskp.			;[242] Fine, it's tossed
	  dmove t2,[ -1		;[242] Time is right now
		ot%nda ]	;[242] No date
	  ODTIM%		;[242] Timestamp the line
	   %jserr(<ODTIM% error to session log>,) ;[242] 
	  dmove t2, [ -1,,q3	;[242] Point to some punctuation
			-2 ]	;[242] Two byte
	  setz t4,		;[242] Zero unchecked and unnecessary terminator
	  SOUT%			;[242] And spew
	   %jserr(<SOUT% error when trying punctuate session log>,) ;[242] 
	  move t2, q2		;[242] Load eight bit source
	  movn t3, q1		;[242] Load negative length for faster SOUT%
	  SOUT%			;[242] And spew
	   %jserr(<SOUT% error when trying to echo to session log>,) ;[242] 
	endif.			;[242] End case ECHO to SESSION log

	ifmn. pars7		;[242] ECHO to TRANSACTION log?
	  skipg t1, tlgjfn	;[242] Yes, but do we have one open?
	anskp.			;[242] No, we do not, so nothing to do
	  cain t1, .nulio	;[242] Just tossing it?
	anskp.			;[242] Fine, it's tossed
	  dmove t2,[ -1		;[242] Time is right now
		ot%nda ]	;[242] No date
	  ODTIM%		;[242] Timestamp the line
	   %jserr(<ODTIM% error to transaction log>,) ;[242] 
	  dmove t2, [ -1,,q3	;[242] Point to some punctuation
			-2 ]	;[242] Two byte
	  setz t4,		;[242] Zero unchecked and unnecessary terminator
	  SOUT%			;[242] And spew
	   %jserr(<SOUT% error when trying punctuate transaction log>,) ;[242] 
	  move t2, q2		;[242] Load eight bit source
	  movn t3, q1		;[242] Load negative length for faster SOUT%
	  SOUT%			;[242] And spew
	   %jserr(<SOUT% error when trying to echo to transaction log>,) ;[242] 
	endif.			;[242] End case ECHO to TRANSACTION log

	ret


	subttl EXIT command

.exit:	entry .exit
	guide <from Kermit>
	confrm			; Confirm.
	ret

	remark Execute the EXIT or QUIT command.

	extern f$exit

$exit:	entry $exit
	setom f$exit		; Set exit flag.
	ret			; (that's all)

	subttl EXIT and QUIT support (which are the same)

; Routine to clean up any open files or devices.

clenup:	entry clenup		;[194] Invoked by k20mit

	saveac <q1>		;[194] Extra scratch
	call clsjfn		; Whack any open JFN

	skipg q1, logjfn	; Do we have a debugging log?
	ifskp.			;[194] Yes, close it
	  hrrzs t1, q1		;[193] Load it, stripping flags
	  setzm logjfn		;[193] Either way, forget about it,
	  cain t1, .priou	;[221] Wait a second, was this primary output?
	anskp.			;[221] Just shut up and get on with it
	  cain t1, .nulio	;[193] Just dumping it?
	anskp.			;[193] Yes, doesn't need closure
	  RFPTR%		;[144] Get file position
	  ifje. r		;[194] Failed??  (NOT IFSKP.!!!!!)
	    move t4, t1		;[194] Save the error code, might be useful
	    move t1, q1		;[194] Reload the JFN
	    setz t2,		;[194] Say we never wrote anything
	  endif.
	  skipg t2		;[144] Anything written?
	   txo t1, cz%abt	;[144] None, don't bother keeping the log.
	  CLOSF			; Close it.
	  ifje. r		;[194] Catch and ignore error
	    move t4, t1		;[194] Save for debuggers
	  endif.		;[194] End case ignored close failure
	endif.			;[194] End case closing log JFN

	skipg q1, tlgjfn	;[126] Transaction log was open?
	ifskp.			;[194] It was, close it
	  wtlog (<Closed Transaction Log>,tlgjfn) ;[194] Log closure
	  setzm tlgjfn		;[194] No more transaction log
	  hrrzs t1, q1		;[193] Load JFN, stripping flags
	  cain t1, .priou	;[221] Wait a second, was this primary output?
	anskp.			;[221] Just shut up and get on with it
	  cain t1, .nulio	;[193] Just dumping it?
	anskp.			;[193] Yes, doesn't need closure
	  move t1, q1		;[194] Reload the JFN (wtlog trashes t1)
	  CLOSF
	  ifje. r		;[194] Catch and ignore error
	    move t4, t1		;[194] Save for debuggers
	  endif.		;[194] End case ignored close failure
	endif.

	skipg q1, filjfn	;[194] Any file transfer JFNs hanging around?
	ifskp.			;[194] Apparently so
	  setzm filjfn		;[194] Whatever happens, it's gone
	  hrrzs t1, q1		;[193] Load JFN, stripping flags
	  cain t1, .priou	;[221] Wait a second, was this primary output?
	anskp.			;[221] Just shut up and get on with it
	  cain t1, .nulio	;[193] Just dumping the data?
	anskp.			;[193] Yes, doesn't need closure
	  CLOSF
	  ifje. r		;[194] Catch and ignore error
	    move t4, t1		;[194] Save for debuggers
	  endif.		;[194] End case ignored close failure
	endif.			;[194] 

	skipg q1, sesjfn	;[195] How about a session log?
	ifskp.			;[194] Open, so close it
	  setzm sesjfn		;[194] Whatever happens, it's gone
	  setzm sesflg		;[195] Whack flag, just in case
	  hrrzs t1, q1		;[193] Load JFN, stripping flags
	  cain t1, .priou	;[221] Wait a second, was this primary output?
	anskp.			;[221] Just shut up and get on with it
	  cain t1, .nulio	;[193] Just dumping the data?
	anskp.			;[193] Yes, doesn't need closure
	  CLOSF%
	  ifje. r		;[194] Catch and ignore error
	    move t4, t1		;[194] Save for debuggers
	  endif.		;[194] End case ignored close failure
	endif.			;[194] 

	ret			; Note, we DON'T turn off interrupt system.

	subttl GET command

;[148] Rewritten to allow source & destination files specified separately.
;[208] Rewritten some more to make this a little easier

	extern remfil		;[208] Remote file storage area

	chgsec(code,const)	;;Chained FDB's are not in code, they're in const
getfdb:	flddb. .cmcfm,cm%sdh,,,,getfd1
getfd1:	flddb. .cmqst,,,<Remote file specification in remote host's own syntax,>,,getfd2
getfd2:	flddb. .cmtxt,cm%sdh,,<Remote file specification in remote host's own syntax
 (Use CTRL-V to quote otherwise illegal characters like "!", "?", and "@"),
 or carriage return to enter source and destination names separately.> ;[208] 

getfd4:	flddb. .cmofi		 ;[208] Don't cleans this!!
	retsec			;;Back to where-ever we started from
	cleans(<getfd1,getfd2>)

.get:	guide <remote files>	; Parse the rest of the GET command.
	setzm pars2		; Make sure these are zero...
	setzm pars3

	movei t1, getfdb
	call rfield
	ldb t3, [pointr (.cmfnp(t3),cm%fnc)] ; Get function code.
	cain t3, .cmcfm		; Parsed a CR?
	 jrst .get2		;  Yes, go prompt.

	caie t3, .cmqst		;[208] How about a quoted string?
	ifskp.			;[208] Yes!  Parse everything on one line
	  movx t1, cmdbln	;[208] Length of atom buffer
	  dmove t2, [exp atmbuf,remfil]	;[208] Load source and destination
	  xblt. t1		;[208] Copy it all over, wee!!
	  move t1, [point 7,remfil] ;[208] Point to new remote file
	  movem t1, pars2	;[208] Store for symantic action
	  guide <to local destination file> ;[208] Prompt is now a guide
	  jrst .get4		;[208] And go parse for the output file
	endif.			;[208] End case quoted string

	confrm			; No, so go GET the specified file(s).
	move t1, [point 7, atmbuf] ; Let $GET know where to find the string.
	movem t1, pars2
	setzm filjfn
	ret

; Prompt separately for source and destination filespecs.

.get2:	txmsg < Remote Source File: > ;[194] Prompt for remote filespec
	move t1, [point 7, buffer]
	setzm buffer
	movem t1, pars2		; Let $GET know where to find the string.
	move t2, [rd%crf+rd%bel+<MAXBUF>]
	sxtext (t3,< Remote Source File: >)
	RDTTY
	 %jserr (,r)
	setz t2,		; Write a zero over the terminating linefeed.
	dpb t2, t1
	skipn buffer		; If they typed nothing, then skip next part.
	 ret

; Now get local filespec for storing the incoming file.

.get3:	sxtext (t1,< Local Destination File: >)
	call dpromp
.get4:	movei t1, getfd4
	call cfield
	movem t2, pars3
	move t1, t2		;[193] Load the JFN
	call isnulj		;[193] Find out if it's NUL:
	 ret			;[193]  No, it isn't, so we're done
	movem t1, pars3		;[193] Overwrite old parsed JFN
	move t2, t1		;[193] Reposition for downstream
	ret

	subttl HELP command parsing

	extern hlptab,sethlp,hset ;[194] Moved to K20HLP

	chgsec(code,const)	;;Tables and fdb's go in const psect
hsfdb1: flddb. .cmkey,,mactab,<SET macro,>,<summary>,hsfdb2
hsfdb2:	flddb. .cmkey,,sethlp,<SET option,>,<summary>

	cleans(<hsfdb2>)

;[214] Begin table and linkage definitions

; Commands which require additional sub-commands or more granular help
; can be dealt with by:
;
;   1)	Creating an additional entry in the sub-help (subhlp) table
;	with the hclip macro. 
;   2)	Creating function descriptor block with pointers to the
;	default help and to individual help text keyword (or switch)
;	tables.
;   3)	The parse tables for individual help are then created in
;	k20hlp.
;   4)	Wonderfully informative help text is written.
;	[That's the goal, anyway]
;
; The block. statement with the nested do. functions conceptually as a
; kind of a cross between a switch statement and a skip chain yet
; effectively executes as a skip chain.  The efficiency of this linear
; approach may need to be revisited if we create a lot of multi-level
; help (Tops-10 Kermit does this)

$hdefi:	flddb. .cmcfm,,,<for general help on DEFINE,>,,$hdef1
$hdef1:	flddb. .cmswi,,defhlp##,<a DEFINE switch,>,,

$hclea:	flddb. .cmcfm,,,<for general help on CLEAR,>,,$hcle1
$hcle1:	flddb. .cmswi,,clrhlp##,<a CLEAR switch,>,,

$hloca:	flddb. .cmcfm,,,<for general help on LOCAL,>,,$hloc1
$hloc1:	flddb. .cmkey,,lclhlp##,<a LOCAL keyword,>,,

$hremo:	flddb. .cmcfm,,,<for general help on REMOTE,>,,$hrem1
$hrem1:	flddb. .cmkey,,remhlp##,<a REMOTE keyword,>,,

$htime:	flddb. .cmcfm,,,<for general help on TIME,>,,$htim1
$htim1:	flddb. .cmswi,,timhlp##,<a TIME switch,>,,

	cleans(<$hdef1,$hcle1,$hloc1,$hrem1,$htim1>)

; N.B., Although most help text resides in section one, the TBLUK%
;    table only stores 18 bit addresses.  Therefore, we must clip the
;    section number or LINK will remind us that it is doing it for us.
;
;    Such action may or may not be desired.  In our case, it is
;    exactly what we want, so we clip the address here to keep from 
;    constantly seeing LINK's advisory messages.

define hclip (hbase,%hb,%fb) <	;;All 214, used to add secondary help
	extern hbase		;;All should be found in k20hlp, section 1
	%hb==<<'hbase>&.rhalf>	;;Clip down to 18 bits (we know the section)
	%fb==<<$'hbase>&.rhalf>	;;Clip down to 18 bits (we know the section)
	xwd %hb,%fb		;;Make a table entry
	cleans(<%hb,%fb>)	;;Clean up generated symbols
>
subhlp:	hclip (hdefin)		;;Sub-help for DEFINE command
	hclip (hclear)		;;Sub-help for CLEAR command
	hclip (hlocal)		;;Sub-help for LOCAL command
	hclip (hremot)		;;Sub-help for REMOTE command
	hclip (htime)		;;Sub-help for TIME command
subcnt==.-subhlp		; Number of items in sub-help table

hlpfdb:	flddb. .cmkey,,hlptab,,<kermit>
	retsec			;;Back in code

;[214] End table and linkage definitions

.help:	guide <about>		;[18] HELP
	movei t1, hlpfdb
	call rfield		;[67]
	move t2, (t2)		; Get help text address.
	movem t2, pars3
	setzm pars4		;[214] Let's assume it isn't a macro
	hrrzs t2		;[67]
	movx t4, subcnt-1	;[214] Load count of sub-help tables
				;[214] Used as an index, actually
	remark			;[214] Note, SET must be last because of macros
	block.			;[214] Enter block context for better control
	  do.			;[214] Enter loop context
	    hlrz t3, subhlp(t4)	;[214] Load sub-help table in section offset
	    came t2, t3 	;[214] Secondary help we know about?
	    ifskp.		;[214] Yes, handle that
	      guide <item>	;[214] Tell them they can ask about sub-commands
	      hrrz t1, subhlp(t4) ;[214] Load secondary help fdb
	      call rfield	;[214] Maybe get item they want help for
	      ldb t1, [pointr (.cmfnp(t3),cm%fnc)] ;[214] Get function code.
	      caie t1, .cmcfm	;[214] Wanted general help?
	      ifskp.		;[214] They did
	        hlrz t2, subhlp(t4) ;[214] So load the general help again
		retskp		;[214] Signal completely done with parse
	      endif.		;[214] End case general REMOTE help
	      hrrz t2, (t2)	;[214] Get switch help text address.
	      ret		;[214] Break out of the block, non-skip
	    endif.		;[214] End case REMOTE picked
	    sojge t4, top.	;[214] Try next sub-help
	  enddo.		;[214] End loop logical context

	  remark		;[214] If none of the above, do SET last
	  caie t2, hset		;[214] Do they want help for SET?
	  ifskp.		;[214] They did
	    guide <parameter>	;[67] Yes, give guide word.
	    movei t1, hsfdb1	;[77] Parse from macro or SET keyword table.
	    call rfield		;[67] Get SET option they want help for.
	    hrrzs t3		;[77] Which function descriptor block was used?
	    caie t3, hsfdb1	;[77] The macro table?
	    ifskp.		;[214] Yes, let semantic action know
	      setom pars4	;[214] More of a flag than a parse product
	    else.		;[214] Otherwise, it was a SET option
	      move t2, (t2)	;[67]  Yes, don't do indirection
	    endif.		;[214] End case macro name or keywork
	    ret			;[214] Break out of the block.
	  endif.		;[214] End case of set
	endbk.			;[214] End of block frame
	ifskp.			;[214] +2 means completely done
	  remark		;[214] so DON'T confirm
	else.			;[214] Otherwise it must be confirmed first
	  confrm		;[67]
	endif.

	movem t2, pars3		;[67] SET...
	ret

	subttl HELP command semantic action

	remark The below is out of date, see [214], above

; N.B., DEPENDs on help text not having the same in-section address
;  as the macro table.  In a single section program, this is, of course,
;  impossble.  However, the help text is now in section one, so it can't
;  occupy the same set of in-section (18 bit) addresses.  This is a form
;  aliasing and is addressed by judicious .PSECT layout.

	remark Display a macro, if that is what they want help on

;[214]	extern mactbx		;[203] Moved to K20MAC

$help:	hrrz t3, pars3		;[77] Special case for help about macro.
	skipn pars4		;[214] Is it macro keyword?
	 jrst $help2		;[214]  Nope, just type the text
repeat 0,<			;[214] Remove address decisioning
	cail t3, mactab+1
	 caile t3, mactbx
	 jrst $help2
>;;repeat 0			;[214] End address decisioning removal
	txmsg <
">
	hlro t1, (t3)
	PSOUT
	txmsg <" is a SET macro defined to be:
   >
	hrro t1, (t3)
	PSOUT
	txmsg <
>
	ret

	remark Otherwise, display the help text

; N.B., The comparison code is actually a kind of a kludge because it
;    uses 18 bit addresses.  Since hset is in section 0 in the TEXT
;    .PSECT, whereas ALL other help text is in section one, how can we
;    handle possible inter-section address clash?
;
;    The answer is to keep the data in completely different parts of
;    the respective sections so that there is no possibility of clash.
;
;    1)	hset is VERY high in section zero's address space, past what
;	would be called the "high segment" in Tops-10; something after
;	page 500.
;
;    2)	The HELP .PSECT starts in section one, page 1, which gives us
;	some 510 pages for help text which may be enough to help Frank
;	write another book. 

; Define 30 bit address section portion of ASCII pointer (also used in k20mit)
hlpntr==:<.P07!<hlporg&<-1,,0>>> ;;Forces LINK polish fix-up

$help2:	hrrz t1, pars3		;[194] Load in-section portion of address
	caie t1, hset##		;[194] They want help for SET?
	ifskp.			;[194] Yes, this is here we use in section 0
	  tlo t1, -1		;[194] So let Tops-20 handle it
	else.			;[194] Otherwise, it's an inter-section reference
	  txo t1, hlpntr	;[194] Turn into a one word global pointer
	endif.			;[194] PSOUT% should be happy with either

	PSOUT
	hrroi t1, crlf
	PSOUT
	ret


	subttl LOG command tables

	%table(logtab)
	%key2 <debugging>,2	;[143]
	%key2 <session>,1
	%key2 <transactions>,0
	%tbend

	%table(dbstab)		;[41] (this table)
	%key2 <7>,7
	%key2 <8>,8
	%tbend

;[222] Default command filespec fields for .CMFIL: 

	chgsec(code,const)	;;Table is not in code, it's in const
logbk:	gj%fou!gj%new!gj%flg!fld(-1,.rhalf) ;[222] Must NOT be an existing file!!
	0		;[222] 	; .gjsrc: Leave JFN's alone
	0		;[222] 	; .gjdev: Use default for device
	0		;[222] 	; .gjdir: Use default for directory
	0		;[222] 	; .gjnam: Will be filled in
	cascii (<LOG>)	;[222] 	; .gjext: Default extension is .LOG
	0		;[222] 	; .gjpro: Use system or directory default protection
	0		;[222] 	; .gjact: Use job default account
logbkl==<.-logbk>	;[222] 	; Length of this GTJFN argument block.

lognam:	cascii (<TRANSACTION>)	;[222] Default transaction log
	cascii (<SESSION>)	;[222] Default session log
	cascii (<DEBUGGING>)	;[222]  & default debugging log
	retsec			;;Back to where-ever we started from

	subttl LOG command parsing

	chgsec(code,const)	;;Chained FDB's are not in code, they're in const
logfdb:	flddb. .cmkey,,logtab,,<session> ; Parse what kind of log.
lgfidb:	flddb. .cmfil
lgbzfd:	flddb. .cmkey,,dbstab,<log-file bits per byte,>,7 ;[41]
	retsec			;;Back to where-ever we started from

.log:	guide <what>		; Give guide word
	movei t1, logfdb
	call rfield
	hrrz t2, (t2)
	movem t2, pars2

	skipe t1, pars3		; Release any piled up JFNs from reparsing
	 RLJFN
	  erjmpr .+1		; Catch and ignore any error
	setzm pars3		;[194] Either way, no JFN parsed

	guide <to file>		; Guide
	movx t1, logbkl		;[222] Space for GTJFN% block
	dmove t2, [ logbk	;[222] Source is our default GTJFN% block
		    cjfnbk ]	;[222] Destination is COMND% GTJFN block
	xblt. t1		;[222] Pop it into place

	move t2, pars2		;[222] Load the log table type
	move t1, lognam(t2)	;[222] Pick up the pointer for that
	movem t1, cjfnbk+.gjnam	;[222] Store as the default filename
	movei t1, lgfidb	;[222] Parse general file properly defaulted
	call rfield		; Parse log filespec.

	hrrz t1, t2		;[222] Load the JFN we got
	call isnulj		;[222] Is it NUL:?
	 nop			;[222] No, but that's fine
	hrrzm t1, pars3		;[222] Stash JFN here
	move t2, pars2		;[143] Debugging log?
	cain t2, 2		;[194] If not debugging
	ifskp.			;[194] Then nothing further to parse
	  confrm		;[143] No, get confirmation	
	  ret			;[143] and return.
	endif.			;[194] 

	guide <with file byte size> ;[41] Yes, parse the file byte size.
	movei t1, lgbzfd
	call rfield		;[41] Parse it.  Defaults to 7.
	hrrz t2, (t2)		;[41] Get result.
	movem t2, pars4 	;[41] Save it.
	guide <bits>		;[41] Comforting guide...
	confrm
	ret

	subttl Open the desired log.

	extern logbsz		;[194] Log file byte size
	extern frclos		;[194] Force close

logdsp:	remark			;[194] Log open dispatch table
	$logt			;[194] Open transaction log
	$logs			;[194] Open Session log
	$logd			;[194] Open debugging log
logmax==.-logdsp		;[194] Maximum log file type

$log:	skipl t1, pars2		; What kind of log?
	ifskp.			;[194] The bad kind ...
	  emsg <Negative logging offset indicates defective parse> ;[194] 
	  ret			;[194] Go no further
	endif.			;[194] 
	caige t1, logmax	;[194] Out of range?
	ifskp.			;[194] Yeah, probably out of date
	  emsg <Logging table offset out of range> ;[194] 
	  ret			;[194] Go no further
	endif.			;[194] 

	remark			;[194] Otherwise, safe to dispatch
	saveac <q1>		;[198] Save q1 for everybody to play with
	jrst @logdsp(t1) 	; Dispatch	

	subttl Open transaction log semantic action

;[126] Begin code addition

$logt:	saveac <q1>		;[221] Stores final JFN we're going to try
	skipg t1, tlgjfn	;[195] Already had a transaction log open?
	ifskp.			;[195] We did
	  setzm tlgjfn		; In case of failure.
	  call frclos		;[194] Force close
	   ermsg% (<Unable to close previous transaction log>, r)
	endif.			;[195] 

	call nulogj		;[198] Go figure out the logging JFN
	 ret			;[198] Failed; we've already whined about it
	move q1, t1		;[221] Store whatever we're going to use
	ifxe. t3, gs%opn	;[198] Not open?
	  cain t1, .nulio	;[221] Special JFN?
	anskp.			;[221] Doesn't need to be opened
	  move t3, t2		;[222] Otherwise, store the OPENF% bits
	  OPENF			;[198] and try to open it
	  ifje. r		;[198] Failed??
	    caie t1, opnx1	; Already open?
	    ifskp.		;[195] Yes, that's odd, but OK...
	      move t1, q1	;[194] Restore the JFN and carry on
	    else.		;[194] Otherwise, a worse error
	      caie t1, opnx9	;[222] Invalid simulaneous access???
	      ifskp.		;[222] Yep, gj%new!gj%new didn't work
		call nxthgh	;[222] Get and open the next highest JFN
	      anskp.		;[222] But couldn't
		remark		;[222] Otherwise, falls out to movem
	      else.		;[222] Otherwise, so other kind of error
		move t4, t1	;[194] Save error for a debugger
		%ermsg (<Unable to open transaction log>,$loge) ;[221]
	      endif.		;[222] End attempted opnx9 recovery
	    endif.		;[194] End OPENF% error recovery
	  endif.		;[194] End OPENF% error analysis
	endif.			;[194] End case opening the transaction log

	movem t1, tlgjfn	; Save the jfn.
	smsg (<KERMIT-20 Transaction Log File, >)
	dmove t2, [ -1		; Write header in log file.
		ot%ntm!ot%day!ot%fdy!ot%fmn!ot%4yr]
	ODTIM
	dmove t2, [exp <-1,,crlflf>, -^d4 ]
	SOUT			;[194] Counted tie off
	wtlog (<Opened Log: >, tlgjfn)
	ret

;[126] End of addition.

	subttl Open session log semantic action

;[194] If log is opened again without being closed beforehand, then
; JFN's can wind up being lost.

$logs:	saveac <q1>		;[221] Needs an accumulator
	skipg t1, sesjfn	;[195] Already had a session log open?
	ifskp.			;[195] We did
	  setzm sesjfn		; In case of failure.
	  setzm sesflg		;[198] Stomp session flag, too
	  call frclos		;[194] Force close
	   ermsg% (<Unable to close previous session log>, r)
	else.			;[198] Otherwise, decondition further logic
	  setzm sesflg		;[198] Stomp session flag
	endif.			;[195] 

	call nulogj		;[198] Go figure out the logging JFN
	 ret			;[198] Failed; we've already whined about it
	move q1, t1		;[221] Save whatever we're going to use
	ifxe. t3, gs%opn	;[198] Not open?
	  cain t1, .nulio	;[221] Special JFN?
	anskp.			;[221] Doesn't need to be opened
	  move t3, t2		;[222] Otherwise, store the OPENF% bits
	  OPENF			; Open now, avoid being stomped by CLZFFs.
	  ifje. r		;[198] Failed??
	    caie t1, opnx1	; Already open?
	    ifskp.		;[195] Yes, that's odd, but OK...
	      move t1, q1	;[194] Restore the JFN and carry on
	    else.		;[194] Otherwise, a worse error
	      caie t1, opnx9	;[222] Invalid simulaneous access???
	      ifskp.		;[222] Yep, gj%new!gj%new didn't work
		call nxthgh	;[222] Get and open the next highest JFN
	      anskp.		;[222] But couldn't
		remark		;[222] Otherwise, falls out to movem
	      else.		;[222] Otherwise, so other kind of error
		move t4, t1	;[194] Save error for a debugger
		%ermsg (<Unable to open session log>,$loge) ;[221] 
	      endif.		;[222] End opnx9 recovery
	    endif.		;[194] End OPENF% error recovery
	  endif.		;[194] End OPENF% error analysis
	endif.			;[198] End case opening the session log

	remark			;[195] Otherwise, everything is dandy
	hrrzm t1, sesjfn	;[195] Save the open JFN.
	setom sesflg		;[195] Flag session logging is active
	ret

	subttl Open debugging log semantic action

$logd:	saveac <q1>		;[221] Accumulator for JFN
	skipg t1, logjfn	;[195] Already had a debugging log open?
	ifskp.			;[195] We did
	  setzm logjfn		; In case of failure.
	  call frclos		;[194] Force close
	   ermsg% (<Unable to close previous debugging log>, r)
	endif.			;[195] 

	call nulogj		;[198] Go figure out the logging JFN
	 ret			;[198] Failed; we've already whined about it
	move q1, t1		;[221] Save the accumulator
	move t4, pars4	 ;[198]	;[41] Load the bytesize we wanted.
	movem t4, logbsz 	;[41] Save bytesize for SHOW command.
	ifxe. t3, gs%opn	;[198] Not open?
	  caie t4, ^d8		;[41] 8-bit requested?
	  ifskp.		;[198] Whoops, better fix the mode word
	    dpb t4,[pointr (t2,of%bsz)];[198] Overwrite the 7...
	  endif.		;[198] End case byte size fix up
	  cain t1, .nulio	;[221] Special JFN?
	anskp.			;[221] Doesn't need to be opened
	  move t3, t2		;[222] Otherwise, store the OPENF% bits
	  OPENF%		;[38]
	  ifje. r		;[198] Failed??
	    caie t1, opnx1	; Already open?
	    ifskp.		;[195] Yes, that's odd, but OK...
	      move t1, q1	;[194] Restore the JFN and carry on
	    else.		;[194] Otherwise, a worse error
	      caie t1, opnx9	;[222] Invalid simulaneous access???
	      ifskp.		;[222] Yep, gj%new!gj%new didn't work
		call nxthgh	;[222] Get and open the next highest JFN
	      anskp.		;[222] But couldn't
		remark		;[222] Otherwise, falls out to movem
	      else.		;[222] Otherwise, so other kind of error
		move t4, t1	;[194] Save error for a debugger
		%ermsg (<Unable to open debugging log>,$loge) ;[221] 
	      endif.		;[222] End opnx9 error recovery
	    endif.		;[194] End OPENF% error recovery
	  endif.		;[194] End OPENF% error analysis
	endif.			;[198] End case opening the session log

	remark			;[195] Otherwise, everything is dandy
	movem t1, logjfn 	;[38] Opened OK, save it.
	skipn debug		;[41] Was debugging asked for?
	 movei debug, 1		;[41] Not yet, so set default debugging.
	ret

	subttl Get next higher generation

; gj%new!gj%fou will only work for a file which has been saved at
; least once.  Otherwise, the file does not exist on disk yet and
; GTJFN% can return the JFN of a file that is actually already open
; (in another job).

; Call:
;
;  q1/	JFN that failed open with opnx9
;  t3/	Failing OPENF%'s bits
;
; Return:
;
;  +1/	Failed, q1 unchanged
;  +2/	Worked, q1 has an OPEN JFN

; Fields for file with no generation number

fnogen==fld(.jsaof, js%dev)		;[222] Always want device
fnogen==fnogen!fld(.jsaof, js%dir)	;[222] Full directory
fnogen==fnogen!fld(.jsaof, js%nam)	;[222] File Name
fnogen==fnogen!fld(.jsaof, js%typ)	;[222] File Type (or Extension)
fnogen==fnogen!js%paf			;[222] Punctuate all fields

nxthgh:	saveac <q2,q3,q4>	;[222] Needs some control variables
	move q2, t3		;[222] Save the OPENF% bits
	hrroi t1, atmbuf	;[222] Get a place to do JFNS%
	hrrz t2, q1		;[222] Load the JFN
	dmove t3, [ fld(.jsaof, js%gen)	;[222] Just want the (bad) generation number
			0  ]	;[222] No goofy prefix, whatever that is
	JFNS%			;[222] Get just that
	 %jsErr (<JFNS% failed trying to recover from invalid simultaneous access>,r)
	hrroi t1, atmbuf	;[222] Point at the atom buffer again
	movei t3, ^d10		;[222] Generations are in base 10
	NIN%			;[222] Convert to internal binary format
	 %jsErr (<NIN% failed trying to recover from invalid simultaneous access>,r)
	aos q3, t2		;[222] Calculate and save the next highest
	hrroi t1, atmbuf	;[222] Get a place to do another JFNS%
	hrrz t2, q1		;[222] Load the JFN again
	dmove t3, [ fnogen	;[222] Do everything EXCEPT the generation
			0  ]	;[222] No goofy prefix, whatever that is
	JFNS%			;[222] Get just that
	 %jsErr (<2nd JFNS% failure recovering from invalid simultaneous access>,r)
	movei t3, "."		;[222] Punctuation for generation number to come
	idpb t3, t1		;[222] Append it
	move q4, t1		;[222] Save where to append the generation
	movei t4, ^d30		;[222] Only try 30 generations

	do.			;[222] Enter loop context
	  move t1, q4		;[222] Where to append the current generation
	  move t2, q3		;[222] Load current highest generation
	  movei t3, ^d10	;[222] Output in base 10
	  NOUT%			;[222] Convert to internal binary format
	   %jsErr (<NOUT% failed trying to recover from invalid simultaneous access>,r)
	  dmove t1, [		;[222] May no catch existing files, but...
		gj%new!gj%flg	;[222] New file, return flags
		-1,,atmbuf ]	;[222] Point to what we just built
	  GTJFN%		;[222] Get a JFN on the next highest generation
	   %jsErr (<GTJFN% failed trying to recover from invalid simultaneous access>,r)
	  hllz t3, t1		;[222] Grab the flags
	  tlz t1, -1		;[222] Stomp them
	  exch t1, q1		;[222] Use as current JFN
	  RLJFN%		;[222] Toss the one that didn't work
	   %jsErr (<RLJFN% failed trying to recover from invalid simultaneous access>,r)
	  hrrz t1, q1		;[222] Load the new JFN
	  move t2, q2		;[222] Load original OPENF% bits
	  OPENF%		;[222] And try it again
	  ifje. r		;[222]  But failed
	    caie t1, opnx9	;[222] Bumped into another one?
	     %ermsg (<OPENF% failed recoveriing from invalid simultaneous access>,r)
	    sojle t4, r		;[222] Only do this so many times
	    aoja q3, top.	;[222] Otherwise, try another generation
	  else.			;[222] Otherwise, worked
	    retskp		;[222] Return success
	  endif.		;[222] End OPENF% analysis
	enddo.			;[222] End loop context

	subttl Handle log file open errors

; Assumes Q1 has a JFN

$loge:	hrrz t1, q1		;[221] Load the JFN
	jumpe t1, R		;[222] Don't try to release gubbish
	call frclos		;[221] Force it closed or release it
	 nop			;[221] Ignore error return when trying to recover
	ret			;[221] Done

	subttl Set up a log file JFN, special casing NUL:

; Call:
;
;  pars3/   Some kind of JFN, which is very carefully checked
;
;   +1	Failed
;   +2	t1/  JFN ready to be opened or .nulio
;	t2/  OPENF% bits, basically of%wr and maybe of%app
;	     Assumes 7 bit mode, which would need to be overriden
;	t3/  Results of GTSTS% (which are simulated for .nulio)
;    pars3/  Updated in case of .nulio

nulogj:	saveac <q1, q2>		;[198] Saves a copy of the JFN

	block.			;[194] Enter block context for better control flow
	  skipg q1, pars3	;[194] Load and check the parsed JFN
	   ret			;[194] It was junk...
	  tlz q1, -1		;[194] Shut off any flags
	  jumpe q1, r		;[194] Zero is junk, too
	  retskp		;[194] Otherwise, passes lexical checks
	endbk.			;[194] Exit block. context
	ifskp.			;[194] Passed?
	  move t1, q1		;[194] Yes, do some further checking
	else.			;[194] Otherwise, something wasn't right
	  ermsg% (<Open log not given a valid JFN>, r)	 
	endif.			;[194] End sanity check

	remark t1, q1		;[194] t1 is loaded at this point
	call isnulj		;[194] Allow them to log to NUL: quickly
	ifskp.			;[194] It's NUL:
	  hrrzs q1, t1		;[194] Clear 'flags' and cache JFN
	  movem t1, pars3	;[194] Store .nulio as parse item
	  movx q2, <gs%nam!gs%opn!gs%wrf!gs%eof> ;[198] Pretend some likley bits
	else.			;[194] Otherwise, a real file
	  GTSTS%		;[198] Let's have a look at the file
	   %jserr (<Unable to determine log JFN status>,r) ;[198] 
	  move q2, t2		;[198] Save the status
	  ifxe. t2, gs%nam	;[198] Some kind of gubbish?
	    ermsg% (<Open log not given a bound JFN>, r) ;[198] 
	  endif.		;[198] 
	  ifxn. t2, gs%err	;[198] Some kind of error?
	    ermsg% (<Open log given a JFN which may be in error>, r) ;[198] 
	  endif.		;[198] 
	  txne t2, gs%opn	;[198] Is it already open?
	anskp.			;[198] It is, so we're done
	  DVCHR%		;[198] Let's find out about the device
	   %jserr (<Open log JFN can not be resolved to a device>,r) ;[198] 
	  ldb t3,[pointr t2, dv%typ] ;[198] Pick up the device type
	  caie t3, .dvdsk	;[198] Is this a disk?
	  ifskp.		;[198] Yes, safe to query the fdb (I hope)
	    move t1, q1		;[198] Load the JFN
	    dmove t2, [1,,.fbctl ;[198] Get the file descriptor control word
			t4 ]	;[198] Put it in t4
	    GTFDB%		;[198] Pull it from the file descriptor block.
	    ifje. r		;[198] Sigh...
	      move t3, t1	;[198] Save the error for debuggers
	      seto t2,		;[198] Assume not appending
	      move t1, q1	;[198] Reload the JFN
	    endif.		;[198] 
	    txne t2, fb%nex	;[198] Doesn't exist yet?
	  anskp.		;[198] Then it is silly to try to append
	    remark fb%nxf!fb%wnc ;[198] Not closed in some way; try not to overwrite
	    remark t1, q1	;[198] t1 is still loaded (or reloaded) at this point
	    movx t2, of%wr!of%app!fld(7,of%bsz) ;[198] Write/append access, 7-bit bytes.
	  else.			;[198] Otherwise, assume not appending
	    move t1, q1		;[198] Reload load the JFN
	    movx t2, of%wr!fld(7,of%bsz) ;[198] Write access, 7-bit bytes.
	  endif.		;[198] 
	endif.			;[198] End .nulio special casing
	move t3, q2		;[198] Return GTSTS%

	retskp			;[198] Succeeded at something, anyway...

	subttl PAUSE command

;[194] Enhanced to parse a floating point number so that we can specify
;    milliseconds, which are used for greater granularity when testing.
;    Also carefully checks for overflow when converting from floating
;    point seconds to integer milliseconds.

	chgsec(code,const)	;;FDB's are not in code, they're in const
paufdb:	flddb. .cmflt,,^d10,<Number of seconds to pause,>,<1>
	retsec			;;Back to where-ever we started from

.pause:	guide (seconds)
	movei t1, paufdb
	call rfield		;[194] Parse for the floating number

	ifl. t2			;[194] Is the number in the right range?
	  emsg <Negative pauses are not logical> ;[187] 
	  jrst cmder1		;[194] Allow reparse
	endif.			;[194] 

	remark			;[212] When chksec works, it works completely
	call chksec		;[196] Ensure number is in correct range
	ifskp.			;[196] Check and convert OK?
	  skipn definf		;[212] Yes; in a DEFINE command?
	   confrm		;[212] No, confirm the line
	  ret			;[212] And done
	else.			;[196] Otherwise, couldn't swallow something
	  emsg <Pause is out of range> ;[196] 
	  jrst cmder1		;[196] Allow reparse
	endif.			;[196] End case checking and conversion

	remark Pause semantic action

$pause:	skipg t1, pars4		;[196] Load the milliseconds
	 ret			;[196]  Unless there weren't any
	DISMS			; Sleep.
	 erjmpr .+1		;[194] Catch and ignore error
	ret

	subttl PROMPT command

; Parse the rest of the PROMPT command.

.promp:	confrm			; Confirm.
	ret

	remark PROMPT command execution.

$promp:	setzm f$exit		; Reset exit flag.
	ret

	subttl PUSH command

.push:	confrm
	ret

	subttl RECEIVE command

	chgsec(code,const)	;;Chained FDB's are not in code, they're in const
recfdb:	flddb. .cmofi,cm%sdh,,<local output file specification>,,recfd1 ;[231] 
recfd1:	flddb. .cmcfm,cm%sdh,,<confirm to use remote filespec>
reccfm:	flddb. .cmcfm
	retsec			;;Back to where-ever we started from
	cleans(<recfd1>)

; Parse a filespec or just confirmation.

.recv:	guide <into file>	; First, issue guide word.
	movei t1, recfdb
	call rfield		; Parse a file spec or a confirm.
	ldb t3, [pointr (.cmfnp(t3),cm%fnc)] ; Get function code.
	caie t3, .cmofi		; Is it an input file spec?
	 ret			;  If not it must be a confirm, so done.

	movem t2, filjfn	; Filespec, so save the JFN,
	movei t1, reccfm	; and parse the confirmation.
	call rflde
	ifskp.			;[193] Confirmed!
	  hrrz t1, filjfn	;[193] Load output file JFN
	  call isnulj		;[193] Is it NUL:?
	   ret			;[193]  No, we're done
	  movem t1, filjfn	;[193] Stomp in as JFN
	  move t2, t1		;[193] And also for anyone who wants it, downstream
	  ret			;[193] Finally get out of here
	endif.			;[193] End case .CMCFM

; Parse error handler.

	skipg t1, filjfn	; Release any JFN.
	ifskp.			;[193] Have...something
	  cain t1, .nulio	;[193] Special NUL:?
	anskp.			;[193] Yes, that does not need releasing
	  RLJFN%
	   erjmpr .+1		;[193] Retrieve and ignore any errors.
	endif.			;[193] End case releasing a JFN
	setzm filjfn		; Zero the JFN to indicate we don't have one.
	emsg <Not confirmed>	;[187] Issue our own parse message
	jrst cmder1		;  and get back inside CMD to clean up.

	subttl SHOW command parser

	remark SHOW keyword table

; All display routines moved to k20dsp

	%table(shotab)			;[39] (this whole keyword table)
	%key2 <all>,0
	%key2 <daytime>,$shday##	;[194] 
	%key2 <debugging>,$shdeb## ;[194] 
	%key2 <file-info>,$shfil## ;[194] 
	%key2 <input-info>,$shinp## ;[160] ;[194] 
	%key2 <line>,$shlin##	;[194] 
	%key2 <macros>,$shmac##	;[77] ;[194] 
	%key2 <packet-info>,$shpkt## ;[194] 
	%keyf3 <statistics>,$stat##, cm%inv ;[186] Tom gets sleepy...
	%key2 <timing-info>,$shtim## ;[194] 
	%key2 <transmit-capture>,$shtrc## ;[266] 
	%key2 <version>,$shver## ;[194] 
	%tbend

	remark SHOW command parser

	chgsec(code,const)	;;Chained FDB's are not in code, they're in const
shomac:	flddb. .cmkey,,mactab,<macro,>,,shofdb
shofdb:	flddb. .cmkey,,shotab,<parameter,>,<all>,shcnfm
shcnfm:	flddb. .cmcfm,,,<to show all parameters,> ;[201] Macros and allow confirm
	retsec			;;Back to where-ever we started from
	cleans(<shcnfm>)

.show:	hlrz t4, mactab		;[201] Load count of items (macros) in table
	ife. t4			;[201] No macros defined?
	  guide <parameters>	; SHOW command
	  movei t1, shofdb	;[201] Just show parameter table
	else.			;[201] Otherwise, could select a macro
	  guide <parameters or macro> ;[201] 
	  movei t1, shomac	;[201] Either macro or parameter
	endif.			;[201] 
	call rfield		;[201] Try to parse something
	ldb t4, [pointr (.cmfnp(t3),cm%fnc)] ;[201] Get function code.
	caie t4, .cmcfm		;[201] Was this a confirm?
	ifskp.			;[201] It was, so
	  setz t2,		;[201] Load talisman for all
	  dmovem t2, pars2	;[201] Save tweaked parse results
	  movem t4, pars4	;[201] Also the function code
	else.			;[201] No, so tie off the line
	  dmovem t2, pars2	;[201] Save raw parse results
	  movem t4, pars4	;[201] Also the function code
	  confrm		;[201] Does not modify t1, t2, t3, t4
	endif.			;[201] End case line not confirmed

	ret

	subttl SHOW command semantic action driver

$show:	seto t1,		;[201] Assume showing macros
	dmove t2, pars2		;[201] Load raw (or tweaked) results
	move t4, pars4		;[201] and the function code

	caie t4, .cmcfm		;[201] Just a confirm?
	ifskp.			;[201] Yes, phony that up
	  setzb t1, t2		;[201] Say a keyword from parameter table
	else.			;[201] No, let's look a little further
	  tlz t3, -1		;[201] Stomp given address
	  caie t3, shofdb	;[201] Wanted to show a parameter?
	anskp.			;[201] No, a macro
	  hrrz t2, (t2)		;[201] Pick up the key table entry data
	  setz t1,		;[201] Flag that it is a parameter
	endif.			;[201] End case keyword table decode

	ife. t1			;[201] Was this a parameter?
	  ife. t2		;[201] All (or confirm)?
	    hrlzi q1,(<nop 0,>)	;[201] Never return from each one
	    callret $shtop##	;[201] Start from the top and do all
	  endif.		;[201] End case All or Confirm
	  move q1, [ret]	;[201] A single item, so return after it
	  hrroi t1, crlf	;[39] Single SHOW item.
	  PSOUT%		;[201] Emit blank line,
	  jrst (t2)		;[39] then go show the requested stuff.
	endif.			;[201] 

	txmsg <  >		;[201] Space over twice
	hlro t1, (t2)		;[201] Point to macro name.
	PSOUT%			;[201] Print it.
	txmsg < = >		;[201] Show equivalence
	hrro t1, (t2)		;[201] Point to body of macro
	PSOUT%			;[201] Print that
	call ifcrlf		;[201] Maybe do a CRLF
	  
	ret			;[201] Finally done

	subttl TAKE command parsing

; Default command filespec fields for .CMFIL:

	chgsec(code,const)	;;FDB's are not in code, they're in const
defbk:	gj%old			; Must be existing file.
	repeat 4,<0>		; Normal defaults for dev:<dir>name.
	cascii (<CMD>)		; Default extension is .CMD.
	0			; Default protection,
	0			;  and account.
defbkl==<.-defbk>		; Length of this GTJFN argument block.

takfdb:	flddb. .cmfil
	retsec			;;Back to where-ever we started from

.take:	movx t1, cz%ncl!.fhslf	; Release non-open jfn's.
	CLZFF
	guide <commands from file>
	move t1, [defbk,,cjfnbk] ; Insert our file parsing defaults.	
	blt t1, cjfnbk+defbkl
	movei t1, takfdb
	call cfield
	movem t2, pars2		; Here's the JFN just parsed.
	ret

	subttl TAKE command semantic action

; added as edit 78.

$take:	move t1, takdep		; How deep are we?
	caig t1, takel		;[194] Too deep?
	ifskp.			;[194] Indeed
	  emsg <TAKE command file stack overflow> ;[187]
	  ret			;[194] don't do it.
	endif.			;[194] 
	move t1, takjfn		; There's room, get current TAKE file jfn.
	move t2, takep		; Push it on the stack
	push t2, t1		; ...
	movem t2, takep		; ...
	aos takdep		; Remember what level we're on.

	move t1, pars2		; Get JFN that was parsed
	movem t1, takjfn	;  ...
	movx t2, fld(7,of%bsz)!of%rd ; 7-bit i/o, read access.
	OPENF
	 %jserr (,$takex)
	callret setcsb		; Opened OK, go set up command state block.

; Error opening command file.

$takex: call popjfn		; Remove offending JFN from TAKE stack.
	ifnsk.			;[194] 
	  emsg <TAKE file stack underflow> ;[187] 
	  ret
	endif.			;[194] 

	movx t1, cz%ncl!.fhslf	; Release extraneous JFNs.
	CLZFF
	 erjmp .+1
	ret

	subttl POPJFN

; Routine to pop a command file JFN off the JFN stack.
;
; Enter with current command file jfn in TAKJFN.
;
; Returns:
;  +1 if stack empty,
;  +2 otherwise, with popped jfn in TAKJFN.

popjfn:	entry popjfn		; Also found in K20IOC
	skipg takdep		; Back at top level?
	 ret			;  Yes, return silently.

; Close current command file.

	skipg t1, takjfn	;[209] Load the JFN (if there is one)
	ifskp.			;[209] There is, so let's get on with it
	  setzm takjfn		;[209] Stomp it, no matter what
	  tlz t1, -1		;[209] Whack any flags
	  cain t1, .nulio	;[209] This kind of confusion??
	anskp.			;[209] Actually, yes, so don't bother
	  CLOSF			;[209] Real enough; close it
	   %jserr (,)		; Just print message on error.
	endif.			;[209] Either way, carry on

; Return to previous one.

	move t2, takep		; Get the TAKE stack pointer
	pop t2, t1		;  and the previous TAKE file JFN,
	movem t2, takep		;  restore them,
	movem t1, takjfn	;  ...
	call setcsb		;  and also restore the command state block.
	sos takdep		; Decrement the depth indicator
	retskp			; Return successfully.


	subttl Process initialization file.

;[79] INIFIL added
;
;[85] Returns +1 if there was no init file, +2 if there was.
;
;[220] Rewritten to not assume PS: is the login structure
;      Also unrolled the loop (prior to maybe redoing with movslj)

	remark    1   2   3   4   5
kerini:	byte (7) "K","E","R","M","I"
	byte (7) "T",".","I","N","I"

inifil:	entry inifil		;[220] Invoked by k20mit
	saveac <q1>		;[220] Needs an index variable
	anstkv (q1,dirmxw)	;[220] Allocate space for login directory

	hrro t1, q1		;[220] Build Tops-20 pointer to stack
	move t2, .jilno+jobtab	;[220] Job's logged in directory number
	DIRST%			;[220] Build the entire directory
	 %jserr (<Unable to build login directory string>,r) ;[220] Punt

	dmove t3, kerini	 ;[220] Load file name
	repeat ^d5,<		;;[220] Do the first word
	    lshc t2, ^d7	;;[220] Load a character in t2
	    idpb t2, t1		;;[220] Append to directory specification
>				;;[220] End of first word
	repeat ^d5,<		;;[220] Do the second word
	    lshc t3, ^d7	;;[220] Load a character in t3
	    idpb t3, t1		;;[220] Append to directory specification
>				;;[220] End of first word
	setz t3,		 ;[220] Cons up a zero
	idpb t3, t1		 ;[220] Tie off the file specification

	movx t1, gj%old!gj%sht	;[220] Existing file, only
	hrro t2, q1		;[220] Build Tops-20 pointer to completed specification
	GTJFN%			;[220] Get JFN on it.
	 erjmpr r		;[220]  If we can't, return silently.
	hrrzm t1, pars2		; Got one, pretend we parsed it.
	setom iniflg		;[83] Flag that we're doing init file.
	call $take		; Go TAKE the file.
	retskp			;[85]

	subttl SEND command

	chgsec(code,const)	;;Chained FDB's are not in code, they're in const
sndfdb:	flddb. .cmfil,,,<local file spec (possibly wild),>,,
sasfdb:	flddb. .cmcfm,,,<to send with this name,>,,sasfd1
sasfd1:	flddb. .cmqst,,,<to specify file name to use on target system,>,,sasfd2
sasfd2:	flddb. .cmtxt,,,<to specify file name to use on target system,>
saifdb:	flddb. .cmcfm,,,<to send them all,>,,saifd1
saifd1:	flddb. .cmfil,,,<to specify initial file to send,>
sndcfm:	flddb. .cmcfm
	retsec			;;Back to where-ever we started from
	cleans(<sasfd1,sasfd2,saifd1>)

.send:	guide <from files>	; Issue guide words.
	move t2, cjfnbk+.gjgen	; Get the JFN flag bits.
	txo t2, gj%ifg!gj%old	; Old file(s), allow wild cards.
	trz t2, -1		;[172] Default to most recent generation only.
	movem t2, cjfnbk+.gjgen	; Return the JFN flag bits.
	setzm cjfnbk+.gjext	;[172] No default extension.

	movei t1, sndfdb
	call rfield		; Parse a file spec or a confirm.
	move t1, t2		;[193] Position the JFN
	call isnulj		;[193] Find out if it's NUL:
	 nop			;[193]  No, it isn't, but we don't care
	movem t1, pars2		;[193]

	ifxe. t1, gj%wld	;[193] Any wildcards in it?
	  guide <as>		;[96] No, then let them choose a new name.
	  movei t1, sasfdb
	else.			;[194] Otherwise, something was wildcarded
	  guide <initial>	; prompt for initial.
	  movei t1, saifdb
	endif.			;[194] 

	call rflde		; Parse the field.
	 jrst .sende		;[63] Handle errors explicitly.
	ldb t3, [pointr (.cmfnp(t3),cm%fnc)] ; Get function code.
	cain t3, .cmqst		;[208] Quoted string?
	 movei t3, .cmtxt	;[208] Pretend it's text (because it is)
	movem t3, pars3		;[96] Save it for execution.

	cain t3, .cmcfm		; Confirmation?
	 ret			;  Yes, just return.

	caie t3, .cmfil		;[96] File?
	ifskp.			;[194] Yes
	  move t1, t2		;[193] Position the JFN
	  call isnulj		;[193] Find out if it's NUL:
	   skipa		;[193]  No, it isn't, but we don't care
	    move t2, t1		;[193] Reposition so stored properly
	  hrrm t2, pars2	;[117] Initial filespec - substitute it.
	  movei t1, sndcfm	; Get command confirmation.
	  call rflde
	   jrst .sende		;[194] Didn't confirm, parse error
	  ret
	endif.			;[194]

;[96] If they gave an alternate name, copy it out of the atom buffer.

	caie t3, .cmtxt		; Text?
	 jrst .sende		;  No, error.
				; Copy the string out of the atom buffer.
	dmove t1, [point 7, atmbuf
		   point 7, buffer]
	setzm buffer
	call movstu
	ife. t3			;[194] If nothing, act like we parsed a confirm.
	  movei t3, .cmcfm
	  movem t3, pars3
	endif.			;[194] 
	confrm			;[208] And tie off the line
	ret

.sende:	skiple t1, filjfn	;[194] Error - get the JFN.
	RLJFN%			; Release it.
	 erjmpr .+1		;[194]  Catch and ignore any errors.
	setzm filjfn		; Nullify the JFN.
	emsg <Not confirmed>
	jrst cmder1

	subttl SERVER command

.serve:	confrm			; Confirm.
	ret

	remark Execute the SERVER command.

;[144] Remove test for remote mode operation.  KERMIT-20 works fine as
; a server over an assigned line, although the messages may look a bit
; strange.

$serve:	extern getcom
	call getcom		; Go serve.
;[137]	setzm f$exit		;[110] Return to command mode if they ^C out.
	ret

	subttl CONNECT command, kind of like SET LINE

	remark CONNECT Parsing tables and function descriptor blocks

;N.B., Remove abbreviation if we ever do pipes

	%table(pseutb)		;[186] 
	%keyf3 <p>, %pseud, <cm%inv!cm%abr>
;	%key2 <pipe>, .dvpip	;[186] Loopback to same job (subfork)
%pseud:	%key2 <pseudo-terminal>, .dvpty ;[186] Loopback to another job
	%keyf3 <pty>, .dvpty, cm%inv ;[186] another way of saying pseudo
	%tbend			;[186] 

	cleans(<%pseud>)	;;Clean up working symbol

	%table(mantab)		;[205] 
	%key2 <close>,.dvnul	;[205] Close open connection (if open)
	%key2 <kill>,.fhinf	;[205] Clobber terminal fork
	%tbend			;[205] 

	%table(conswi)		;[205] 
	%key2 <forkless>,swifrk	;[236] Wants Tops-20 to handle NRT
	%key2 <stay>,swista	;[205] Don't create (or resume) transfer fork
	%keyf3 <t>,   %tim, <cm%inv!cm%abr> ;[218] 
	%keyf3 <ti>,  %tim, <cm%inv!cm%abr> ;[218] 
	%keyf3 <tim>, %tim, <cm%inv!cm%abr> ;[218] 
%tim:	%key2 <timeout>,switim	;[218] Override default timeout
	%keyf3 <timout>,switim, cm%inv ;[218] Another way I mistype this
	%tbend			;[205] 

	cleans(<%tim>)		;;Clean up working symbol

	chgsec(code,const)	;;Chained FDB's are not in code, they're in const
confdb:	flddb. .cmnum,,^d8,<terminal line number to connect to,>,,confd1
confd1:	flddb. .cmkey,,pseutb,<local host loopback connection,>,,confd2
confd2:	flddb. .cmkey,,mantab,<to manage the connection,>,,confd3
confd3:	flddb. .cmnod,cm%nsf,,<Tops-10/20 DECnet host,>,,confd4
confd4:	flddb. .cmcfm,,,<to reconnect to an open connection,>

cswfdb:	flddb. .cmswi,,conswi,,,cswfd1
cswfd1:	flddb. .cmcfm,,,<to proceed with connection,> ;[218] 
scmfdb:	flddb. .cmcma,cm%sdh,,<Comma for another SET parameter>,,scmfd1
scmfd1:	flddb. .cmcfm
	retsec			;;Back to where-ever we started from
	cleans(<confd1,confd2,confd3,confd4,cswfd1,scmfd1>)

	SUBTTL CONNECT command parsing Switch

swista:	REMARK			;[205] Parse for /STAY
	setom pars5		;[205] Flag connection to stay at Kermit command level
	ret			;[205] That's easy enough


swifrk:	REMARK			;[236] Parse for /FORKLESS
	setom pars7		;[236] Flag that we're doing .MOSNH
	ret			;[236] Go parse something else worthwhile


switim:	REMARK			;[218] Parse for /TIMEOUT	
	saveac <t4,q1,q2,q3>	;[218] Needs some registers
	dmove q1, pars4		;[218] Save whatever might already be parsed
	move q3, definf		;[218] Save the define context
	setom definf		;[218] Stomp, so it doesn't parse a confirm
	call .setim		;[218] Parse a floating point time
	move t1, pars4		;[218] Load computed milliseconds
	movem t1, pars6		;[218] Hand it off to waitcn
	dmovem q1, pars4	;[218] Store what might allready be parsed
	movem q3, definf	;[218] Restore whatever the define context was
	ret			;[218] Return, restoring parsing context

	REMARK CONNECT command main parsing

.conne:	setom pars3		;[186] Let's assume parsing fails
	setom pars4		;[186] Fails completely, actually
	setzm pars5		;[205] Assume will connect immediately
	setzm pars6		;[218] Assume not overriding timeout
	setzm pars7		;[236] Assume not using MTOPR%'s .MOSNH

	guide <to tty or DECnet node>
	remark			;[205] Don't reorder the flddb.'s!
	movei t1, confdb
	call rfield		;[205] Parse a tty number (or something...)
	ldb t4, [pointr (.cmfnp(t3),cm%fnc)] ; Get function code.

.conn1:	saveac <t5,q2>		;[205] Needs another temporary
	anstkv (q2,^d4)		;[205] Copy of node name, if parsed

	cain t4, .cmkey		;[186] Any kind of keyword has a device type
	 hrrz t5, (t2)		;[186] Get the requested device type
	cain t4, .cmnod		;[186] Parsed a node?
	 movei t5, .dvdcn	;[186] Force DECnet client
	cain t4, .cmnum		;[186] Is it a number?
	 move t5, t2		;[186] Put in the terminal line number

	caie t4, .cmcfm		;[186] Just gave us a confirm?
	ifskp.			;[186] That's fine, means reconnect
	  dmovem t4, pars3	;[186] Store parse type and device type or unit
	  ret			;[186] Done with parse
	endif.
	skipe definf		;[205] Not in a DEFINE?
	 jrst .conn2		;[205] No, we are; so go get cute with that
				;[205] Store 20 characters of atom buffer
	dmove t1, atmbuf	;[205] Load first ten characters of the atom buffer
	dmovem t1, 0(q2)	;[205] Tuck them away
	dmove t1, atmbuf+2	;[205] Next ten characters of the atom buffer
	dmovem t1, 2(q2)	;[205] Tuck those away

	do.			;[218] Enter loop context to parse switches
	  movei t1, cswfdb
	  call rfield		;[218] Parse something
	  ldb t3, [pointr (.cmfnp(t3),cm%fnc)] ; Get function code.
	  cain t3, .cmcfm	;[218] Finally confirmed?
	   exit.		;[218] Yes, break out of the loop
	  hrrz t1, (t2)		;[236] Pick up the switch parsing routine
	  call (t1)		;[236] Go parse some more
	  loop.			;[218] And go around for more switchs
	enddo.			;[218] End of loop lexical context

	dmove t1, 0(q2)		;[205] Load ten characters of the saved atom buffer
	dmovem t1, atmbuf	;[205] And put them back
	dmove t1, 2(q2)		;[205] Next ten characters of the saved atom buffer
	dmovem t1, atmbuf+2	;[205] And put those back
	setzm atmbuf+5		;[205] Make sure string is tied off

	dmovem t4, pars3	;[186] Store parse type and device type or unit
	ret

.conn2:	remark			;[205] Handle /stay in a define
	dmovem t4, pars3	;[186] Store parse type and device type or unit
	ret

	subttl SET keyword table

	%table(settab,G)	;[203] Also used by K20MAC
	%key3 <blip>, .setbl,$setbl	;[277] 
	%key3 <block-check>, .setbc, $setbc ;[98]
	%key3 <break>, .setbr, $setbr
;;;;	%key3 <capture>, .setcp, $setcp	;;[266] (currently uses TRANSMIT?)
	%key3 <debugging>, .setdb, $setdb
	%key3 <delay>, .setdl, $setdl ;[194] 
	%key3 <duplex>, .setdu, $setdu ;[194] 
	%key3 <escape>, .setes, $setes ;[194] 
	%key3 <expunge>, .setex, $setex ;[143] ;[194] 
	%key3 <file>, .setfi, $setfi ;[194] 
	%key3 <flow-control>, .setfl, $setfl ;[143] ;[194]
	%key3 <handshake>, .setha, $setha ;[76]
	%key3 <host>, .seths, $setln##	;[194] 
	%key3 <incomplete>, .setab, $setab ;[194] 
	%key3 <input>, .setin##, $setrs ;[160] ;[194] 
	%key3 <ITS-binary>, .setit, $setit ;[194] 
	%key3 <line>, .setln, $setln## ;[186] ;[194] 
	%key3 <parity>, .setpa##, $setpa## ;[194] 
	%key3 <prompt>, .setpr, $setpr ;[194] 
	%key3 <receive>, .setrc, $setrs ;[194] 
	%key3 <retry>, .setre, $setre ;[194] 
	%keyf3 <se>, %snd3, <cm%inv!cm%abr>
%snd3:	%key3 <send>, .setsn, $setrs ;[194] 
	%keyf4 <server-timeout>, .setim, $setst, cm%inv  ;[212] Tops-10 has it here
	%key3 <speed>, .setxp, $setsp ;[194] 
	%keyf4 <srv-timeout>,	 .setim, $setst, cm%inv  ;[212] keep typing this..
	%key3 <transmit>, .setra, $setrs ;;[266] 
	%key3 <TVT-Binary>, .setta, $setta ;[129] ;[194] 
	%tbend

	cleans(<%snd3>)			;;Clean up generated symbol

	subttl	SET command

;[77] Parse SET command.  (This routine rewritten for edit 77.)

	extern mactab		;[203] Macro table is in K20MAC

	chgsec(code,const)	;;Chained FDB's are not in code, they're in const
sfdb1:	flddb. .cmkey,,mactab,<SET macro,>,,sfdb2
sfdb2:	flddb. .cmkey,,settab
	retsec			;;Back to where-ever we started from

.set:	hlrz t2, mactab		; Anything in macro table?
	ifn. t2			;[194] If so, include them too.
	  skipe definf		; Unless we're defining a macro.
	anskp.			;[194] Don't allow recursive definitions!
	  skipe mdone		;[203] Not expanding the macro?
	anskp.			;[203]  No, we are; so only do keywords
	  movei t1, sfdb1	; Macro table is searched first.
	else.			;[194] No macros or defining one
	  movei t1, sfdb2	; Normal SET command table.
	endif.			;[194] 
	call rfield		; Parse a keyword.

.set2:	entry .set2		;[203] Linkage from K20MAC
	hrrzs t3		; See which function descriptor block was used.
	caie t3, sfdb1		;[194] The macro table?
	ifskp.			;[194] Indeed
	  hrrz t1, (t2)		;[194] Yes, get the data.
	  hrli t1, (point 7,) 	; This will be a pointer to the macro text.
	  movem t1, pars2	; Save it.
	  confrm		; Get confirmation.
	  setom macrof		; Set the macro flag.
	  ret 			; No more to do.
	else.			;[194] Not from macro table
	  setzm macrof		; Assume regular SET keyword was parsed.
	endif.			;[194] End case parsing a macro name

	hrrz t2, (t2)		; Get the command routine addresses.
	movem t2, pars2		; Save into pars2.
	hlrz t1, (t2)		; Get the next level routine.
	call (t1)		; Call it.

; If doing a DEFINE, loop through SET commands until CR typed.

	skipn definf		; Doing DEFINE?  If so, allow comma here.
	 ret
	movei t1, scmfdb
	call rfield
	ldb t3, [pointr (.cmfnp(t3),cm%fnc)] ; Get function code.
	cain t3, .cmcma		; Comma?
 	 jrst .set	 	;  Yes, go back & get another SET parameter.
	ret			; Confirmation, done.

	subttl SET command action routines.

; SET ... command dispatcher.

$set:	entry $set		;[194] Maybe move this?
	ifme. macrof		;[203] If no macro used, just do the set
	  move t2, pars2	; Get back data value.
	  hrrz t1, (t2)		; Get evaluation routine.
	  call (t1)		; Call it.
	  ret
	endif.			;[203] 

$set2:	move t1, pars2 		; Pointer to macro text (SET operands)
	movem t1, macxp
;*	PSOUT			; echo it for debugging...
	setom mdone		; Say macro not done yet.

; Loop to copy one set command into the command buffer.

$set3:	movei t1,cmdbln*5	;[192] Max characters in command buffer
	movem t1,sbk+.cmcnt	;[192] Say it's completely empty
	setzm sbk+.cminc	;[192] No unparsed characters yet
	move t1, [ascii/set  /]	; Fake a SET command (don't nul terminate)
	movem t1, cmdbuf
	movei t2, ^d4		;[192] Characters in "SET "
	addm t2, sbk+.cminc	;[192] Bump count of UNparsed characters
	movni t2, ^d4		;[192] Characters in "SET "
	addm t2, sbk+.cmcnt	;[192] Reduce remaining space
	move t2, [point 7, cmdbuf, 27] ; Copy them to after "set "
	movem t2, sbk+.cmptr

; Loop for each character.

; To do: why are we putting a line feed back into the buffer?

$set4:	do.			;[203] Enter loop context
	  ildb t1, macxp	; Get a character from the macro text
	  cain t1, .chcrt	;[192] A carriage return?
	   movei t1, ","	;[192]  Hi!  Guess what, now you're a comma!
	  cain t1, .chlfd	;[192] A line feed?
	   loop.		;[192]  Silently swallow it
	  jumpe t1, endlp.	;[192] If null, done.
	  caie t1, ","		;[194] A comma?
	  ifskp.		;[194] It is
	    movei t1, .chcrt 	;[194] Substitute a carriage return.
	    idpb t1, t2		;[203] Drop into command buffer
	    aos sbk+.cminc	;[203] Account for character in there
	    sos sbk+.cmcnt	;[203] Subtract from remaining
	    movei t1, .chlfd	 ; And a linefeed...
	    idpb t1, t2		;[203] Drop that into command buffer, too
	    aos sbk+.cminc	;[203] Account for character in there
	    sos sbk+.cmcnt	;[203] Subtract from remaining
	    setz t1,		; And a null...
	    idpb t1, t2		;[203] Tie off the line
	    jrst $set6		; Go execute this part of the macro
	  endif.		;[194] 
	  idpb t1, t2		; Not a comma, copy the character.
	  aos sbk+.cminc	;[192] Account for it in the CSB
	  sos sbk+.cmcnt	;[192]  and decrement remaining count
	  loop.			;[203] And copy some more, wee!!
	enddo.			;[203] Exit loop lexical context

; Get here at end of null-terminated macro body.

$set5:	remark			;[192] Fix the CSB back up
	move t1, [point 7, cmdbuf] ;[192] Point to beginning of command buffer
	movem t1, sbk+.cmptr	;[192] Stomp that in; nothing to parse
	movei t1,cmdbln*5	;[192] Max characters in command buffer
	movem t1,sbk+.cmcnt	;[192] Say it's completely empty
	setzm sbk+.cminc	;[192] No unparsed characters yet
	setzb t1, t2		;[192] Cons up ten .CHNUL's
	dmovem t1, cmdbuf	;[192] Scrub the atom buffer an itty bit
	hllm t1, sbk		;[192] Zero the CSB flags.
	setzm mdone		;[192] Flag that we're done interpreting the macro.
	ret			;[192] Get out of here

$set6:	setzm pars1		;[203] Expanding a macro doesn't hit parse: in
	move t1, [pars1,,pars2]	;[203]  the main parsing loop, so we must clean
	blt t1, parsx		;[203]   out the previous parse values here

;*	hrroi t1, cmdbuf	; Echo the command.
;*	PSOUT			; ...

	hrrzs sbk		;[203] Zero the CSB flags.
	call .set		; Go parse the string.
	call $set		; Go execute what was parsed.
	skipe mdone		;[203] No more?
	 jrst $set3		;[203]	Nope, go do the rest of them.
	ret			; Otherwise, all done

	subttl SET BLIP command

;[277] Begin code insertion

	chgsec(code,const)	;;FDB's are not in code, they're in const
sblfdb:	flddb. .cmcfm,,,<To reset to default blip packet count,>,,sblfd1
sblfd1:	flddb. .cmnum,,^d10,<number of packets per blip,>
	retsec			;;Back to where-ever we started from

.setbl:	guide (packet count)	; Prompt for our necessaries
	movei t1, sblfdb	; Allows a confirm to reset to default
	skipe definf		; But!! In DEFINE?
	 movei t1, sblfd1	;  Then don't allow a confirm
	call rfield		; Try to get some input
				; Worked!!
	ldb t1, [pointr (.cmfnp(t3),cm%fnc)] ; Get function code.
	caie t1, .cmcfm		; Just confirmed?
	ifskp.			; We did, so use default value
	  movx t2, dblip	; Load default blip count
	  ret			; Done with parse, no need to confirm
	endif.			; as it is de-facto confirmed

	ifl. t2			; Negative blips are silly
	  emsg <A negative blip count is illogical>
	  jrst cmder1
	else.			; Otherwise, use it, including zero
	  movem t2, pars3	; Store for semantic action to find
	endif.

	skipn definf		; In DEFINE?
	 confrm			;  No, get confirmation.
	ret			; Done with parse

	remark SET BLIP command execution.

$setbl:	extern blip		; Defined in K20MIT
	move t2, pars3		; Execute SET BLIP
	movem t2, blip		; Update global variable
	ret			; Done with semantic action

;[277] End code insertion

	subttl SET BLOCK-CHECK command

;[98]  (This command added as part of edit 98)

	%table(bctab)
	%key2 <1-character-checksum>, "1"
	%key2 <2-character-checksum>, "2"
	%key2 <3-character-crc>, "3"
	%tbend

	chgsec(code,const)	;;FDB's are not in code, they're in const
sbcfdb:	flddb. .cmkey,,bctab,,<1>
	retsec			;;Back to where-ever we started from

.setbc:	guide <type to>		; Issue guide words
	movei t1, sbcfdb
	call rfield		; Parse keyword, default is "1".
	hrrz t2, (t2)		; Save the value we parsed.
	movem t2, pars3
	skipn definf		; In a DEFINE command?
	 confrm			;  No, make them type a carriage return.
	ret

	remark SET BLOCK-CHECK command execution.

$setbc:	extern bctr		; Our necessary
	move t1, pars3		; Get what was parsed.
	movem t1, bctr		; Save it as "block check type requested".
	ret

	subttl SET BREAK command

	chgsec(code,const)	;;FDB's are not in code, they're in const
sbrfdb:	flddb. .cmnum,,^d10,<Number of nulls at 50 baud to simulate BREAK, >
	retsec			;;Back to where-ever we started from

.setbr:	guide (nulls)
	movei t1, sbrfdb
	call rfield

	ifl. t2			;[194] Negative nulls are silly
	  emsg <A negative break count is illogical> ;[194] 
	  jrst cmder1		;[194] 
	endif.			;[194] 

	caig t2, maxnul		;[194] 
	ifskp.			;[194] Exceeded maximum
	  emsg <Too many nulls, maximum is > ;[194] 
	  numout [maxnul]	;[194] 
	  jrst cmder1		;[194] 
	endif.			;[194] 

	movem t2, pars3
	skipn definf		;[77] In DEFINE?
	 confrm			;[77]  No, get confirmation.
	ret

	remark SET BREAK command execution.

$setbr:	extern brk		; Our necessary
	move t2, pars3		; Execute SET BREAK.
	movem t2, brk
	ret

	subttl SET DEBUG command

	%table(dbgswi)		;[221] 
	%key2 <decode>, 0	;[221] If setting decode flag
	%tbend			;[221] 

	%table(dbgtab)
	%key2 <off>, 0
	%key2 <packets>, 2	;[22]
	%key2 <states>, 1	;[22]
	%tbend

	chgsec(code,const)	;;Chained FDB's are not in code, they're in const
sdbfdb:	flddb. .cmkey,,dbgtab,,states
sdbswi:	flddb. .cmswi,,dbgswi,<to decode packets in log,>,,sdbsw1
sdbsw1:	flddb. .cmcfm		;[221] Parse either the switch or a confirm
sdbswo:	flddb. .cmswi,,dbgswi,<to decode packets in log, /decode
or Comma for another SET parameter
or confirm with carriage return>,,	;;[221] 
	retsec			;;Back to where-ever we started from
	cleans(<sdbsw1>)

.setdb:	guide <option>		; SET DEBUGGING
	movei t1, sdbfdb
	call rfield		; Parse a keyword.
	hrrz t2, (t2)		; Get the value for the keyword.
	movem t2, pars3		; Save into pars3.
	setzm pars4		;[221] Clear debug decode parse flag

	cain t2, 2		;[221] Not debugging packets?
	ifskp.			;[221] Nope, so don't parse for the switch
	  skipn definf		;[77] In DEFINE?
	   confrm		;[77]  No, get confirmation.
	  ret			;[221] Done
	endif.			;[221] 

	ifme. definf		;[221] Not in a DEFINE?
	  movei t1, sdbswi	;[221] No, so we can parse for a confirm
	  call rfield		;[221] See if somebody has a switch for us
	  ldb t3, [pointr (.cmfnp(t3),cm%fnc)] ;[221] Get function code.
	  caie t3, .cmswi	;[221] A switch?
	  ifskp.		;[221] Yep, wants decoding
	    setom pars4		;[221] So set the parse variable
	    confrm		;[221] But have to confirm
	  endif.		;[221] End parse actioning
	  ret			;[221] And done parsing
	endif.			;[221] Done with non-DEFINE case

; This is a trick the EXEC uses: we only want to check for whether a
; switch is there, however: it is OPTIONAL.  The way we do that is by
; trying to parse the switch and, if we fail, hand off to the caller
; to try something else.  If we succeed, then we note that in the
; parse variable and hand off to the caller for further parsing.
;
; The way we make the question mark help come out correctly is by
; simply lying about what we're looking to parse for.  Tricky...

	movei t1, sdbswo	;[221] Switch optional
	call rflde		;[221] Try to parse for the switch
	 ret			;[221] Couldn't, so try something else
	setom pars4		;[221] Worked!!
	ret			;[221] Done; DEFINE will confirm for us


	remark SET DEBUGGING semantic action

$setdb:	extern logjfn		; Our necessary
	block.			;[221] Makes value analysis easier
	  skipge t4, pars3	;[221] Load and pre-check debug value
	   ret			;[221] Negative is impossible
	  cain t4, 2		;[221] Debugging packets?
	   retskp		;[221]  Yes, a valid value
	  cain t4, 1		;[221] Debugging states?
	   retskp		;[221]  Yes, a valid value
	  cain t4, 0		;[221] Wants debugging off?
	   retskp		;[221]  Yes, a valid value
	  ret			;[221] None of the above, +1 failure
	endbk.			;[221] Exit block context
	ifskp.			;[221] Valid value, +2
	  move t1, pars4	;[221] Assume that switch value will also be valid
	  movem t1, pdcodf	;[221] 		and store as the packet coding flag
	  skipe debug, t4	;[221] Side effect global register
	   ret			;[221] If still debugging, done
	else.			;[221] Otherwise, +1, bad
	  emsg <Invalid debugging parse value: > ;[221] Begin whining
	  movei t1, .priou	;[221] Still going to terminal
	  move t2, t4		;[221] Load the bad parse value
	  movei t3, ^d10	;[221] It will be in base 10
	  NOUT%			;[221] Type it
	   erjmpr .+1		;[221] Catch and ignore error
	  hrroi t1, crlf	;[221] Tie off
	  PSOUT%		;[221] 		the line
	  ret			;[221] Return failure and go no further
	endif.			;[221] End analysis

	skipn t1, logjfn	;[38] Did we have a log?
	 ret			;[38] No, done.

	setzm logjfn		;[38] Zero this so we know...
	tlz t1, -1		;[193] Stomp any flags
	cain t1, .nulio		;[193] Logging to never-never land?
	 ret			;[193] Yes, we're done; nothing to close

	RFPTR			;[144] Yes, any bytes written?
	ifje. s			;[194] Suppress error code
	  txo t1, cz%abt	;[221] Chuck the log; probably bad
	  setz t2,		;[194] Pretend nothing written
	else.			;[221] Otherwise, worked
	  skipg t2		;[144] So, did we ever write anything?
	   txo t1, cz%abt	;[144] No, don't bother keeping the log.
	endif.			;[194] 

	CLOSF			;[38] Close it.
	 erjmpr .+1		;[144] Ignore errors, may already be closed
	ret			;[194] by previous EXIT command.

	subttl SET DELAY command

	chgsec(code,const)	;;FDB's are not in code, they're in const
sdlfdb:	flddb. .cmflt,,,<seconds before sending first packet,>,<10>
	retsec			;;Back to where-ever we started from
.setdl:	guide <to>
	movei t1, sdlfdb
	call rfield		; Parse a number.

	ifl. t2			;[194] Is the number in the right range?
	  emsg <Negative delays are Illogical> ;[187] 
	  jrst cmder1		;[194] Allow reparse
	endif.			;[194] 

	remark			;[212] When chksec works, it works completely
	call chksec		;[196] Ensure number is in correct range
	ifskp.			;[196] Check and convert OK?
	  skipn definf		;[77] In DEFINE?
	   confrm		;[77]  No, get confirmation.
	  ret
	else.			;[196] Otherwise, couldn't swallow something
	  emsg <Delay interval is out of range> ;[196] 
	  jrst cmder1		;[196] Allow reparse
	endif.			;[196] End case checking and conversion

	remark SET DELAY semantic action

$setdl:	extern delay, odelay	; Our necessaries
	dmove t1, pars4	 ;[194] ; DELAY. Get the number of milliseconds to delay.
	camn t2, [ .infin ]	;[212] Talisman for floating zero?
	 setz t2,		;[212]  Yes, make one for real (boo)
	dmovem t1, delay ;[194] ; Save the delay time.
	dmovem t1, odelay;[194] ;[27] Here too, for saving & restoring.
	ret

	subttl the SET DUPLEX command

; N.B., Some systems (such as Tops-20 itself) have the idea of
;	"line" half-duplex.  This code does not support that.

	%table(duptab)		;[18] Table of legal duplexes
	%key2 <full>,dxfull
	%key2 <half>,dxhalf
	%tbend

	chgsec(code,const)	;;FDB's are not in code, they're in const
sdufdb:	flddb. .cmkey,,duptab,,<full>
	retsec			;;Back to where-ever we started from

.setdu:	guide <to>
	movei t1, sdufdb
	call rfield
	hrrz t2, (t2)
	movem t2, pars3
	skipn definf		;[77] In DEFINE?
	 confrm			;[77]  No, get confirmation.
	ret

	remark Execute SET DUPLEX semantic action

$setdu:	extern duplex		; And of our necessary
	move t1, pars3		;[18] DUPLEX.  Get what was parsed.
	movem t1, duplex
	ret

	subttl SET ESCAPE command

;[217] Begin table and fdb insertion
;
;N.B., These tables are also used by other parsing routines that want
;    to get control characters, such as SET HANDSHAKE

define eschrs (c) <		;;[217] Define macro to populate the table
    xlist			;;[217] Don't need to see this in the listing
    irpc c,<			;;[217] Go through all the characters
	%key2 <'c>,<<"'c">-"@">	;;[217] Emit character and its control equivalent
>;;irpc				;;[217] End of argument expansion
    list			;;[217] Turn the listing back on
>;;eschrs			;;[217] End of macro definition

	%table(eschtb)		;[217] Table of 'easy' to parse control characters
	eschrs (ABCDEFGHIJKLMNOPQRSTUVWXYZ) ;;[217] 'Easy' control characters
	%tbend			;[217] End of 'easy' table

	chgsec(code,const)	;;Chained FDB's are not in code, they're in const
escfdm:	flddb. .cmcma,cm%sdh,,,,escfdb	;[260] Used when unwinding a macro
escfdb:	flddb. .cmnum,,^d8,<to specify the value of an ASCII control character,>,,escfd1
escfd1:	flddb. .cmtok,,token(<^>),<to specify an ASCII control character, type a>,,escfd2
escfd2:	flddb. .cmcfm,,,<to reset to the default Control-Backslash (^\),>

	cleans(<escfd1,escfd2>)

esctkn:	intern esctkn		;[217] Many selections, sigh...
	flddb. .cmkey,,eschtb,<ASCII control character>,,etk1
etk1:! flddb. .cmtok,,token(<@>),<to specify the NUL character, type>,,etk2
etk2:! flddb. .cmtok,,token(<[>),<to specify the ESCAPE character, type>,,etk3
etk3:! flddb. .cmtok,,token(<\>),<to specify the file separator character, type>,,etk4
etk4:! flddb. .cmtok,,token(<]>),<to specify the group separator character, type>,,etk5
etk5:! flddb. .cmtok,,token(<^>),<to specify the record separator character, type>,,etk6
etk6:! flddb. .cmtok,,token(<_>),<to specify the unit separator character, type>,,etk7
etk7:! flddb. .cmtok,,token(</>),<to specify the rubout or delete character, type>,,

	tokcln(<etk>,<.xcref>,<1234567>)   ;;[217] Keep silly symbols off cross reference
	tokcln(<etk>,<suppress>,<1234567>) ;;[217] Don't need in symbol table listing
if2  <	tokcln(<etk>,<purge>,<1234567>)	   ;;[217] Don't need at all after second pass
>;if2
	retsec			;;Get back to previous .psect

	remark SET ESCAPE command parsing

.setes:	saveac <q1,q2,q3,q4>	;[217] 
	guide <character for connect>

	movei t1, escfdb	;[217] Parse either a number or a
	skipe mdone		;[217] Unwinding a macro?
	 movei t1, escfdm	;[217]  Yes, allow a comma to squeak through

	call rflde		;[217] Try to get one of them
	ifskp.			;[217] Worked!!
	  dmove q2, t2		;[217] Partiall save the parse results
	  ldb q1, [pointr (.cmfnp(q3),cm%fnc)] ;[217] Get function code.
	  move q4, q1		;[217] Save a copy for downstream
	else.			;[217] Otherwise, failed the parse
	  skipn definf		;[217] In DEFINE?
	   jrst cmderr		;[217] No, then a definite parse error; allow retry
	  ret			;[217] Return into DEFINE and see if that chokes
	endif.			;[217] End handling COMND% returns

	caie q1, .cmcma		;[217] Parsed a comma?
	ifskp.			;[217] We did, so must be unwinding a macro
	  movei q1, .cmcfm	;[217] Turn it into a confirm and carry on
	  move q4, q1		;[217] Stomp it here, too
	endif.

	caie q1, .cmcfm		;[217] Wants the default?
	ifskp.			;[217] Yep, give 'em ol' reliable
	  movei t2, .chcbs	;[217] 		which is control backslash
	  movei q1, .cmnum	;[217] 		    and say we parsed a number
	  remark q4,		;[217] But leave the original parse item alone
	  jrst .sets1		;[217] Check for clash
	endif.			;[217] 

	cain q1, .cmnum		;[217] Parsed a number
	 jrst .sets1		;[217] Go check it

	remark			;[217] Otherwise, wants this a little easier
	dmove t1, [ esctkn	;[217] Possible mnemonics
		    cm%xif ]	;[217] Load the no indirection flag
	orm t2, sbk+.cmflg	;[217] And dink the COMND% state block
	call rflde		;[217] Try to get one of them
	ifskp.			;[217] Worked!!
	  ldb q1, [pointr (.cmfnp(t3),cm%fnc)] ;[217] Get function code.
	  dmove q2, t2		;[217] Save parse data and fdb selection
	  movx t3, cm%xif	;[217] Load indirection flag again
	  andcam t3, sbk+.cmflg	;[217] And restore the COMND% state block
	else.			;[217] Otherwise, failed the parse
	  movx t3, cm%xif	;[217] Load indirection flag again
	  andcam t3, sbk+.cmflg	;[217]     restore the COMND% state block
	  jrst cmderr		;[217] And handle the parse error, allowing reparse
	endif.			;[217] End handling COMND% returns

	caie q1, .cmkey		;[217] Was this relatively easy? 
	ifskp.			;[217] Yep, let's grab and convert the character
	  hrrz t2, (q2)		;[217] Pick up what would be the jump address
	  movei q1, .cmnum	;[217] Pretend we parsed a number
	  jrst .sets1		;[217] Now let's check it
	endif.

	remark q1, .cmtok	;[217] A token is a little hairy
	tlz  q3, -1		;[217] Isolate fdb we actually used
	move q2, .cmdat(q3)	;[217] Pick up the byte pointer to the character
	ildb t2, q2		;[217] Load the token character (only one)
	subi t2, "@"		;[217] Bring down to control character range
	camn t2, [-21]		;[217] Was this our rubout hack?
	 movei t2, 177		;[217] Stomp in the correct value
	movei q1, .cmnum	;[217] Pretend we parsed a number
	remark .sets1		;[217] Now let's check it (falls through)

.sets1:	move q2, t2		;[217] Here when we finally have something
	block.			;[217] Enter block context for easier control flow
	  ifl. q2		;[217] True gubbish?
	    emsg <A negative number is illogical as a control character> ;[217] 
	    ret			;[217] Failure return
	  endif.		;[217] 

	  caige q2, 200		;[217] Absurdly large?
	  ifskp.		;[217] Give that a special squawk
	    emsg <A numeric value of octal 200 or higher is not valid ASCII> ;[217] 
	    ret			;[217] Failure return
	  endif.		;[217] 

	  cain q2, 177		;[194] But!  Maybe a rubout?
	   retskp		;[217] It is, this is fine

	  caie q2, .chcnc	;[217] ^C?
	  ifskp.		;[217] That is never a good idea
	    emsg <May not use a Control-C as an escape character> ;[217] 
	    ret			;[217] Failure return
	  endif.		;[217] 

	  skipn t4, handsh	;[217] Are we doing handshaking?
	  ifskp.		;[217] We are, so check if this conflicts
	    came q2, t4		;[217] Same thing?
	  anskp.		;[217] Nope, but still need to check further
	    emsg <May not use Control->	;[217] 
	    move t1, q2		;[217] Load the control character
	    addi t1, "@"	;[217] Bring into printable range
	    PBOUT%		;[217]				and type it
	    txmsg < as an escape character because this is the handshake character>
	    ret			;[217] Failure return
	  endif.		;[217] 

	  caie q2, .chbel	;[217] ^G?
	  ifskp.		;[217] That is never a good idea
	    move t1, capas	;[217] Pick up our capabilities
	    txne t1, sc%ctc	;[217] Do we have ^C?
	     retskp		;[217] Yes, this is fine
	    ifmn. <jobtab+.jibat> ;[217] Are we a batch frob?
	      emsg <May not use Control-G as an escape character in a batch job> ;[217] 
	    else.		;[217] Otherwise, slightly different message
	      emsg <May not use Control-G as an escape character when no Control-C capability>
	    endif.		;[217] Either way, it's bad...
	    ret			;[217] Failure return
	  endif.		;[217] 

	  caie q2, .chcns	;[217] ^S?
	  ifskp.		;[217] Not not be available
	    skipn flow		;[217] Are we running XON-XOFF?
	     retskp		;[217] Nope, so that's fine
	    emsg <May not use Control-S as an escape character when running with flow control>
	    ret			;[217] Failure return
	  endif.		;[217] 

	  caie q2, .chcnq	;[217] ^Q?
	  ifskp.		;[217] Not not be available
	    skipn flow		;[217] Are we running XON-XOFF?
	     retskp		;[217] Nope, so that's fine
	    emsg <May not use Control-Q as an escape character when running with flow control>
	    ret			;[217] Failure return
	  endif.		;[217] 

	  caig q2, .chcun	;[217] Past Control-_ (underscore)?
	   retskp		;[217]  No, so it's passed all the checks

	  emsg <">		;[217] Begin the blat
	  move t1, q2		;[217] Load the proposed control
	  PBOUT%		;[217]			 character and type it
	  txmsg <" is not in ASCII control range, 0-37 or 177>
	  ret			;[217] Failure return
	endbk.			;[217] End block context
	ifskp.			;[217] Passed +2 means passed muster
	  movem q2, pars3	;[217] So let's use it
	  cain q4, .cmcfm	;[217] Original intent was to default everything?
	   ret			;[217] It was, so don't confirm the confirm.
	else.			;[217] Otherwise, we've complained
	  jrst cmder1		;[217] Allow ^H
	endif.			;[217] Otherwise, fall through

	skipn definf		;[77] In DEFINE?
	 confrm			;[77]  No, get confirmation.
	ret

	remark SET ESCAPE comand semantic action

$setes:	extern escape		; Our necessary
	move t1, pars3		;[16] ESCAPE.  Get what we parsed.
	movem t1, escape
	ret

	subttl SET EXPUNGE command

	%table(offon)		; Table for parsing ON or OFF.
	%key2 <off>, 0
	%key2 <on>, 1
	%tbend

	chgsec(code,const)	;;FDB's are not in code, they're in const
stxfdb:	flddb. .cmkey,,offon,,on
	retsec			;;Back to where-ever we started from

	intern stxfdb		;[273] Used by /SILENCE in K20PAR

.setex:	guide <deleted files automatically>
	movei t1, stxfdb	; Yet consistent naming, sigh...
	call rfield		; Parse a keyword.
	hrrz t2, (t2)		; Get the value for the keyword (0 or 1).
	movem t2, pars3		; Save into pars3.
	skipn definf		;[77] In DEFINE?
	 confrm			;[77]  No, get confirmation.
	ret	

	remark SET EXPUNGE semantic action

$setex:	extern expung		; Our necessary
	move t1, pars3		;[143] SET EXPUNGE
	movem t1, expung
	ret

	subttl SET FILE parse tables

	%table(sfitab)		; Table of file parameters to SET.
	%key2 <bytesize>,0
	%key2 <naming>,1
	%tbend

	%table(sfbtab)		; file bytesize keyword table.
	%key2 <36-bit>, 2	;[232] 
	%key2 <7-bit>, 0
	%key2 <8-bit>, 1
	%key2 <auto>, 3		;[232] 
	%key2 <eight-bit>, 1
	%key2 <seven-bit>, 0
	%key2 <thirty-six-bit>, 2 ;[232] 
	%tbend

	%table(fntab)		;[194] ; file name translation keywords.
	%key2 <normal-form>,1	;[194] 
	%key2 <untranslated>,0	;[194] 
	%tbend			;[194] 

	subttl SET FILE command

; The following ruse using chained FDB's allows the old-style command to
; be parsed most of the time, like "SET FILE 8".

	chgsec(code,const)	;;Chained FDB's are not in code, they're in const
sfifd1: flddb. .cmkey,,sfitab,,<bytesize>,sfifd2
sfifd2:	flddb. .cmkey,,sfbtab,<DEC-20 file byte size,>,<auto>
sftfd3:	flddb. .cmkey,,fntab,,<untranslated> ;[84]
	retsec			;;Back to where-ever we started from

.setfi:	guide <parameter>	;[84] SET FILE
	movei t1, sfifd1
	call rfield
	hrrz t2, (t2)
	hrrzs t3		;[84] Which function descriptor block was used?
	setzm pars3		;[84] Assume they specified a bytesize.
	cain t3, sfifd2		;[84] They specified a bytesize?
	ifskp.			;[194] Nope, parse for it
	  movem t2, pars3
	  guide <to>
	  movei t1, sfifd2	;[194] Let's assume didn't specify the bytesize, yet
	  skipe pars3		;[84] But!!  Did they?
	    movei t1,sftfd3	;[194] They did, so parse the filename translation
	  call rfield		; Parse a keyword.
	  hrrz t2, (t2)		; Get the value for the keyword (0 or 1).
	endif.			;[196] Otherwise, so don't parse it again.

	movem t2, pars4		;[84] Save here.
	skipn definf		;[77] In DEFINE?
	 confrm			;[77]  No, get confirmation.
	ret

	remark SET FILE semantic action

$setfi:	skipn t1, pars3		;[84] Which file parameter are we setting?
	 jrst $setf8		;[84] Bytesize, go do that.
	remark $setfn		;[194] Beware! Falls through to $setfn

	subttl FILE NAMING semantic action

$setfn:	remark $setfn		; Called by...  NOBODY!! (see above)
	extern xfnflg		; and of our necessary
	sosn t1			;[194] Do we have to get a little fancier?
	ifskp.			;[194] Yep, looks like it
	  emsg <Impossible parse value> ;[187] if more file parameters
	  ret 			;[84] are added...
	endif.			;[194] 
	move t1, pars4		;[84] OK, get the value.
	movem t1, xfnflg	;[84] Save it.
	ret			;[84] Done.

	subttl FILE BYTESIZE semantic action

$setf8:	remark $setf8		; Jumped to by $setfi
	extern autbyt, ebtflg, tbtflg	; Our necessaries
	move t1, pars4		; BYTESIZE... Get the value of the flag.
	jrst @fbytet(t1)	;[232] Go set the variables appropriately

fbytet:	fbyte7			;[232] Seven bit files
	fbyte8			;[232] Eight bit files
	fbyt36			;[232] Thirty-six bit files
	fbytea			;[232] Auto-byte (only 7 or 8 for now)

fbyte7:	remark			;[232] Here to force 7 bit
	setzm autbyt		;[232] Never autobyting
	setzm ebtflg		;[232] Clear eight bit flag
	setzm tbtflg		;[232] Clear 36 bit flag
	ret			;[232] Done

fbyte8:	remark			;[232] Here to force 8 bit files
	setzm autbyt		;[232] Never autobyting
	setom ebtflg		;[232] Set eight bit flag
	setzm tbtflg		;[232] Clear 36 bit flag
	ret			;[232] Done

fbyt36:	remark			;[232] Here if forceing thirty-six bit files
	setzm itsflg		;[232] Clear ITS Binary
	setzm autbyt		;[232] Never autobyting
	setzm ebtflg		;[232] Clear eight bit flag
	setom tbtflg		;[232] Set 36 bit flag
	ret			;[232] Done

fbytea:	remark			;[232] Here for 7/8 bit auto-byte
	setom autbyt		;[194]  If so, say so,
	setzm ebtflg		;  and say this not so.
	setzm tbtflg		;[232] If autobyte, then never 36 bit
	ret			;[232] Done

	subttl SET FLOW-CONTROL command

	%table(flotab)		; Flow-Control keywords
	%key2 <none>, 0
	%keyf3 <off>, 0, cm%inv
	%keyf3 <on>, 1, cm%inv
	%key2 <XON-XOFF>, 1
	%tbend

	chgsec(code,const)	;;FDB's are not in code, they're in const
sflfdb:	flddb. .cmkey,,flotab,,XON-XOFF
	retsec			;;Back to where-ever we started from

.setfl:	movei t1, sflfdb
	call rfield		; Parse a keyword.
	hrrz t2, (t2)		; Get the value for the keyword (0 or 1).
	movem t2, pars3		; Save into pars3.
	skipn definf		; In DEFINE?
	 confrm			;  No, get confirmation.
	ret

	remark SET FLOW-CONTROL semantic action

$setfl:	extern handsh, flow	; And of our necessaries
	skipe t1, pars3		; Get flow control option.
	 setzm handsh		; If nonzero, turn off handshake.
	movem t1, flow
	ret

	subttl SET HANDSHAKE command

;[217] Although little used and probably rarely necessary, make entering
;    a character here as 'easy' as it is for changing the escape character.

	%table(hshtab)		; Handshake keywords (recommended)
	%key2 <bell>, .chbel	;[217] ^G
	%key2 <CR>, .chcrt	;[217] ^M or carriage return
	%key2 <ESC>, .chesc	;[217] Escape or "altmode"
	%key2 <LF>, .chlfd	;[217] ^J or line-feed
	%key2 <none>, .chnul	;[217] Special cased
	%key2 <XOFF>, .chcns	;[217] ^S
	%key2 <XON>, .chcnq	;[217] ^Q
	%tbend

	chgsec(code,const)	;;FDB's are not in code, they're in const
hndfdm:	flddb. .cmcma,cm%sdh,,,,hndfdb	;[217] Used when unwinding a macro
hndfdb:	flddb. .cmcfm,,,<to reset to the default ^S (XOFF),>,,hndfd1
hndfd1:	flddb. .cmkey,,hshtab,<a common handshake character mnemonic,>,,hndfd2
hndfd2:	flddb. .cmnum,,^d8,<to specify the value of an ASCII control character,>,,hndfd3
hndfd3:	flddb. .cmtok,,token(<^>),<to specify an ASCII control character, type a>,,
	retsec			;;Back to where-ever we started from

	cleans(<hndfd1,hndfd2,hndfd3>)

.setha:	saveac <q1,q2,q3,q4>	;[217] Needs registers
	guide <character for line turnaround>	;[217] 

	movei t1, hndfdb	;[217] Parse a couple of alternatives
	skipe mdone		;[217] Unwinding a macro?
	 movei t1, hndfdm	;[217]  Yes, allow a comma to squeak through

	call rflde		;[217] Try to get one of them
	ifskp.			;[217] Worked!!
	  dmove q2, t2		;[217] Save partial parse results
	  ldb q1, [pointr (.cmfnp(q3),cm%fnc)] ;[217] Get function code.
	  move q4, q1		;[217] Save for downstream
	else.			;[217] Otherwise, failed the parse
	  skipn definf		;[217] In DEFINE?
	   jrst cmderr		;[217] No, then a definite parse error; allow retry
	  ret			;[217] Return into DEFINE and see if that chokes
	endif.			;[217] End handling COMND% returns

	caie q1, .cmcma		;[217] Parsed a comma?
	ifskp.			;[217] We did, so must be unwinding a macro
	  movei q1, .cmcfm	;[217] Turn it into a confirm and carry on
	  move q4, q1		;[217] Stomp into downstream, too
	endif.

	caie q1, .cmcfm		;[217] A confirm is very special cased
	ifskp.			;[217] It was, so default it
	  movei t2, .chcns	;[217] Replace parse value with ^S
	  movem t2, pars3	;[217] Save where $setha wants to find it
	  ret			;[217] Done, nothing left to parse
	endif.			;[217] 

	caie q1, .cmkey		;[217] Common mnemonic?
	ifskp.			;[217] It was, so translate it by getting
	  hrrz t2, (q2)		;[217] 		the keyword's associated value.
	  jrst .seth1		;[217] Make sure nothing bad leaked through
	endif.			;[217] 

	cain q1, .cmnum		;[217] Number?
	 jrst .seth1		;[217]     Must range check user specified value

	remark q1, .cmtok	;[217] Otherwise, must have been a token
	dmove t1, [ esctkn	;[217] Possible mnemonics
		    cm%xif ]	;[217] Load the no indirection flag
	orm t2, sbk+.cmflg	;[217] And dink the COMND% state block
	call rflde		;[217] Try to get one of them
	ifskp.			;[217] Worked!!
	  ldb q1, [pointr (.cmfnp(t3),cm%fnc)] ;[217] Get function code.
	  dmove q2, t2		;[217] Save parse data and fdb selection
	  remark q4,		;[217] But don't touch original parse
	  movx t4, cm%xif	;[217] Load indirection flag again
	  andcam t4, sbk+.cmflg	;[217] And restore the COMND% state block
	else.			;[217] Otherwise, failed the parse
	  movx t4, cm%xif	;[217] Load indirection flag again
	  andcam t4, sbk+.cmflg	;[217]     restore the COMND% state block
	  jrst cmderr		;[217] And handle the parse error, allowing reparse
	endif.			;[217] End handling COMND% returns

	caie q1, .cmkey		;[217] Was this relatively easy? 
	ifskp.			;[217] Yep, let's grab and convert the character
	  hrrz t2, (q2)		;[217] Pick up what would be the jump address
	  jrst .seth1		;[217] Make sure nothing bad leaked through
	endif.

	remark q1, .cmtok	;[217] A token is somewhat more difficult
	tlz  q3, -1		;[217] Isolate fdb we actually used
	move q2, .cmdat(q3)	;[217] Pick up the byte pointer to the character
	ildb t2, q2		;[217] Load the token character (only one)
	subi t2, "@"		;[217] Bring down to control character range
	camn t2, [-21]		;[217] Was this our rubout hack?
	 movei t2, 177		;[217] Stomp in the correct value
	remark .seth1		;[217] Make sure nothing bad leaked through

.seth1:	remark			;[217] Expects character to check in t2
	ifl. t2			;[217] True gubbish?
	  emsg <A negative number is illogical as an ASCII control character> ;[217] 
	  jrst cmder1		;[217] Failure, but allow reparse
	endif.			;[217] 

	caige t2, 200		;[217] Absurdly large?
	ifskp.			;[217] Give that a special squawk
	  emsg <7 bit ASCII is not defined for values of octal 200 or above> ;[217] 
	  jrst cmder1		;[217] Failure, but allow reparse
	endif.			;[217] 

	caig t2, 37		; Control character?
	ifskp.			; Isn't
	  cain t2, 177		; Rubout?
	anskp.			; It is, so that's fine
	  move t4, t2		;[217] Isn't so let's start complaining
	  emsg <">	;"	;[217] Begin with a double quote
	  move t1, t4		;[217] Load the poor character
	  PBOUT%		;[217] Display what is wrong
	  txmsg <" is not in ASCII control range, 0-37 or 177> ;[187] " Font crock
	  jrst cmder1		;[194] 
	endif.			;[194] 

.seth2:	movem t2, pars3		; Save into pars3.
	cain q4, .cmcfm		;[217] Original intent was to default everything?
	 ret			;[217]  Yes, do not confirm the confirmation
	skipn definf		;[77] In DEFINE?
	 confrm			;[77]  No, get confirmation.
	ret


	remark SET HANDSHAKE semantic action

$setha:	remark flow, handsh	; Necessaries defined above
	skipe t1, pars3		;[143] Get the handshake option.
	 setzm flow		;[143] If nonzero, turn off flow control.
	call @parity		;[223] Compute any parity
	movem t1, handsh	; Save it.
	ret			; Done.

	subttl SET HOST command initial parsing

;[186] SET HOST is basically a restricted form of SET LINE with no .CMNUM

	chgsec(code,const)	;;Chained FDB's are not in code, they're in const
shsfdb:	flddb. .cmkey,,pseutb,<host loopback,>,,shsfd1
shsfd1:	flddb. .cmnod,cm%nsf,,<Tops-10/20 DECnet host to transfer files over,>,,shsfd2
shsfd2:	flddb. .cmcfm,cm%sdh,,<confirm to reset connection>,, ;[186] 
	retsec			;;Back to where-ever we started from
	cleans(<shsfd1,shsfd2>)

.seths:	guide <local host loopback or DECnet node> ;[186] 
	setzb t1,t2		;[186] Cons up 10 .CHNUL's
	dmovem t1,atmbuf	;[186] Scrub a bit of the atom buffer
	movei t1, shsfdb	;[186] Allow NRT and pseudo-terminal
	call rfield		; Parse a keyword or node (NO CONFIRM!) ;[186] 
	ldb t4, [pointr (.cmfnp(t3),cm%fnc)] ;[186] Get function code.
	callret .setl1		;[186] Same parsing semantics

	subttl SET LINE command parsing

	chgsec(code,const)	;;Chained FDB's are not in code, they're in const
slnfdb:	flddb. .cmnum,,^d8,<TTY to transfer files over,>,,slnfd1
slnfd1:	flddb. .cmkey,,pseutb,<host loopback,>,,slnfd2
slnfd2:	flddb. .cmnod,cm%nsf,,<Tops-10/20 DECnet host to transfer files over,>,,slnfd3
slnfd3:	flddb. .cmcfm,cm%sdh,,<confirm to reset>,,
	retsec			;;Back to where-ever we started from
	cleans(<slnfd1,slnfd2,slnfd3>)

.setln:	guide <to physical line, pseudo-terminal or DECnet node>
	setzb t1,t2		;[186] Cons up 10 .CHNUL's
	dmovem t1,atmbuf	;[186] Scrub a bit of the atom buffer
	movei t1, slnfdb	;[186] Allow NRT and pseudo-terminal
	call rfield		; Parse a tty number.
	ldb t4, [pointr (.cmfnp(t3),cm%fnc)] ; Get function code.

.setl1:	cain t4, .cmkey		;[186] Parsed a keyword
	 callret .conn1		;[186] Handle as in CONNECT
	cain t4, .cmnod		;[186] Is it a DECnet node?
	 callret .conn1		;[186] Handle as in CONNECT
	cain t4, .cmnum		; Is it a TTY number?
	 callret .conn1		;[186] Handle as in CONNECT
	caie t4, .cmcfm		;[186] Confirmed?
	ifskp.			;[186] Break the connection
	  dmove t1, [ .cmcfm	;[186] Pass that special situation back
		      .dvnul ]	;[186] And that the keyword was "close"
	  dmovem t1, pars3	;[186] Side effect the parse variables
	  ret			;[186] Done
	endif.			;[186] 

	ermsg% (<Unknown parse type for SET LINE>,r) ;[186] 

	subttl SET INCOMPLETE command

	%table(inctab)		;[194] 
	%key2 <discard>, 0	;[194] 
	%key2 <keep>, 1		;[194] 
	%tbend			;[194] 

	chgsec(code,const)	;;FDB's are not in code, they're in const
stbfdb:	flddb. .cmkey,,inctab,,<discard>,, ;[194] 
	retsec			;;Back to where-ever we started from

.setab:	guide <file disposition> ;[42] SET INCOMPLETE (file disposition)
	movei t1, stbfdb	;[194]
	call rfield		; Parse & confirm.
	hrrz t2, (t2)
	movem t2, pars3
	skipn definf		;[77] In DEFINE?
	 confrm			;[77]  No, get confirmation.
	ret

	remark SET INCOMPLETE semantic action

$setab:	extern abtfil		; Our necessary
	move t1, pars3		; Just save what we parsed.
	movem t1, abtfil
	ret

	subttl SET SEND/RECEIVE command dispatcher.

$setrs:	hrrz t1, @pars3	 ;[223]	; SEND/RECEIVE.  Address of variable to set.
	move t2, pars4		; The value that was parsed.
	skipn t3, pars5		;[196] Do we have a tertiary (double) value?
	ifskp.			;[196] Yes
	  camn t3, [ .infin ]	;[212] Our talsiman for zero?
	   setz t3,		;[212] Stomp appropriately
	  dmovem t2, (t1)	;[196] Save a double value
	else.			;[196] No, it's a single value
	  movem t2, (t1)	; Save the value.
	endif.			;[196] 
	ret

	subttl SET ITS-BINARY command

	chgsec(code,const)	;;FDB's are not in code, they're in const
sitfdb:	flddb. .cmkey,,offon,,on
	retsec			;;Back to where-ever we started from

.setit:	guide <format>		; Issue guide word.
	movei t1, sitfdb
	call rfield		; Parse a keyword.
	hrrz t2, (t2)		; Get the value for the keyword (0 or 1).
	movem t2, pars3		; Save into pars3.
	skipn definf		;[77] In DEFINE?
	 confrm			;[77]  No, get confirmation.
	ret

	remark SET ITS-BINARY semantic action

$setit:	extern itsflg		; and of our necessary
	move t1, pars3		; Just save the value in the ITS flag.
	movem t1, itsflg
	setom autbyt		;[232] Force auto-byte
	setzm tbtflg		;[232] Clear 36 bit byte size
	setzm ebtflg		;[232] Clear 8 bit byte size
	ret

	subttl Storage for SET PROMPT prompt processing

	chgsec(code,data)	;[248] Writable storage is in DATA .PSECT

prompx:	intern prompx		;[248] Only used by K20MIT, actually
	block atmbln		;[248] Allow a foolishly long prompt
	block 1			;[248] And space for the right pointy bracket
	%eoprm==.		;[248] Save end or prompt location
	reloc prompx		;[248] Get back to the beginning
				;[248]			to overwrite with default
	asciz/Kermit-20>/	; Program prompt text (replacable)
	reloc %eoprm		;[248] Back to allocating regular storage
	%prmln==%eoprm-prompx	;[248] Save length of area in words

tpromp: block %prmln		;[248] Temporary staging area for parsed prompt
	retsec			;[248] Back to code

	cleans(<%eoprm,%prmln>)	;[248] Clean up working symbols


	subttl SET prompt command parsing tables

; Originally [137], but greatly rewritten here.  Also allows prompt 
; to be part of DEFINE.  The advantage is that you can have the macro 
; set the prompt to be the name of the macro, which can help you recall
; what parameters you have in effect.
;
; Added C-escape-sequence expansion to actually count the string in
; the atom buffer.  Added character counting and limits to eliminate
; the dreaded Charlie C. Kim effect, an early indication of the necessity
; of the Kermit protocol.

; N.B., Note how argument is passed in .CMDEF, this is a MACRO limitation

	chgsec(code,const)	;;FDB's are not in code, they're in const
kprmpt:	fld(.cmqst,cm%fnc)!cm%hpp!cm%dpp!kprmp1	;[190] .cmfnp
	0					;[190] .cmdat (none)
	cascii (<KERMIT-20 command prompt,>)	;[190] .cmhlp
	cascii ("Kermit-20>")			;[190] .cmdef
kprmp1:	fld(.cmtxt,cm%fnc)!cm%hpp		;[190] .cmfnp
	0					;[190] .cmdat (none)
	cascii (<KERMIT-20 command prompt,>)	;[190] .cmhlp
	retsec			;;Restore psects

	subttl SET prompt command dynamic prompt builder

	remark		;[270] 	; Below are set in K20NET
	extern myprom	;[270] 	; Prompt prefix built off system name, if DECnet
	extern ttynam	;[270] 	; Prompt prefix built off terminal, if serial
	extern ptynam	;[270] 	; Prompt prefix built off pseudo-terminal, if PTY

	extern ttyflg	;[270] 	; Flag for doing a real terminal
	extern ptyflg	;[270] 	; Flag for doing a pseudo-terminal
	extern nrtflg	;[270] 	; Flag for doing DECnet Network Remote Terminal!!

	chgsec(code,data)	;[270] Storage for the constructed prompt
newprm:	block 6			;[270] 29 characters, maximum
	retsec			;[270] Back to code

dyprom:	saveac <q3,q4,q5>	;[270] Will need a few extra registers
	setzb q3, q5		;[270] Let's assume we can't figure anything out
	skipn q4, t1		;[270] Load and check kprmpt+.cmdef (default prompt)
	 ret			;[270] Wasn't any, leave
	skipn local		;[270] Ah, we're supposed to be here, right?
	 ret			;[270] No, leave

	block.			;[270] Enter block mode for better control flow
	  ifme. vtermf		;[270] Not on a virtual terminal?
	    skipn ttyflg	;[270] Then it better be a real terminal
	     ret		;[270] It's not, so let's forget about this
	    movei q3, ttynam	;[270] Use the terminal line
	    retskp		;[270] Return success
	  endif.		;[270] End case serial line
	  ifmn. ptyflg		;[270] Pseudo-terminal?
	    movei q3, ptynam	;[270] Use the PTY device name and
	    movei q5, ttynam	;[273] 		its associated terminal line
	    retskp		;[270] Return success
	  endif.		;[270] End case serial line
	  ifmn. nrtflg		;[270] Network remote terminal
	    movei q3, myprom	;[270] Use the local system name
	    retskp		;[270] Return success
	  endif.		;[270] End case serial line
	  remark		;[270] If get here, we don't know...  bug!!
	endbk.			;[270] End decision block for prefix
	ifskp.			;[270] Determined the prefix?
	  hrli q3,(point 7,0)	;[270] Yes!  Turn it into a hardware pointer
	  move t2, q3		;[270] Load as the 'prefix'
	else.			;[270] Otherwise, couldn't figure it out
	  ret			;[270] So signal to just use the default
	endif.			;[270] End determination result handling
				;[270] Otherwise, start building the prompt
	move t1,[point 7,newprm]
	move t4, t1		;[270] Save a copy of destination
	movei t3, .chdbq	;[270] Start begining of default with a double quote
	idpb t3, t1		;[270] Deposit it in
				;[270] N.B., some pointers are OWGP's to section
	do.			;[270] one, which EXTEND chokes on in section zero
	  ildb t3, t2		;[270] Pick up a byte
	  jumpe t3, endlp.	;[270] If NUL, done
	  idpb t3, t1		;[270] Deposit
	  loop.			;[270] Get some more, wee!!
	enddo.			;[270] End loop lexical context 
	skipn t2, q5		;[270] Two part device prefix?
	ifskp.			;[270] Yes, append that, too
	  movei t3, .chlpa	;[270] Load left parenthesis
	  dpb t3, t1		;[270] Overwrite the trailing colen
	  hrli t2,(point 7,0)	;[270] Turn address into a hardware pointer
	  ibp t2		;[270] Skip the first T of TTY
	   ibp t2		;[270] Skip the second T of TTY
	    ibp t2		;[270] Skip the first Y of TTY
	  do.			;[270] one, which EXTEND chokes on in section zero
	    ildb t3, t2		;[270] Pick up a byte
	    jumpe t3, endlp.	;[270] If NUL, done
	    idpb t3, t1		;[270] Deposit
	    loop.		;[270] Get some more, wee!!
	  enddo.		;[270] End loop lexical context 
	  movei t3, .chrpa	;[270] Load the right parenthesis
	  dpb t3, t1		;[270] Overwrite the trailing colen
	  movei t3, ":"		;[270] Load the device punctuation
	  idpb t3, t1		;[270] Append it to the end
	endif.			;[270] End possible secondary prefix
	move t2, q4		;[270] Now point to the 'suffix'
	ibp t2			;[270] Skip the initial double quote, we already did it
	do.			;[270] one, which EXTEND chokes on in section zero
	  ildb t3, t2		;[270] Pick up a byte
	  jumpe t3, endlp.	;[270] If NUL, done
	  idpb t3, t1		;[270] Deposit
	  loop.			;[270] Get some more, wee!!
	enddo.			;[270] End loop lexical context 

	setz t3,		;[270] Cons up a NUL
	idpb t3, t1		;[270] Tie off the string
	move t2, t4		;[270] Return pointer to cuspy new default prompt
	retskp			;[270] Won!

	subttl SET prompt command parsing

.setpr:	guide <to>		; Parse the rest of the SET PROMPT command.
	setzb t1, t2		;[190] Cons up some .chnul
	dmovem t1, atmbuf	;[190] Give the atom buffer a scrub a dub
	ifmn. local		;[270] Is it local?
	  saveac <q1,q2>	;[248] Dynamic FDB needs an extra AC
	  anstkv (q1,^d4)	;[190] Build the fdb on the fly
	  dmove t1, kprmpt	;[190] Load fdb and default (none)
	  dmovem t1, .cmfnp(q1)	;[190] Store both in dynamic block
	  move t1,kprmpt+.cmdef	;[270] Will always be the suffix
	  call dyprom		;[270] Build a dynamic prompt
	anskp.			;[270] If didn't work, just go with old reliable
	  move t1,kprmpt+.cmhlp	;[190] Load the help text pointer
	  remark t2, dyprom	;[270] Returned result in t2
  	  dmovem t1, .cmhlp(q1)	;[190] Store both in dynamic block
	  move t1, q1		;[190] Load pointer to new fdb
	else.			;[190] Otherwise use vanilla default
	  saveac <q2>		;[248] And will only need one register
	  movei t1, kprmpt	;[190] Original prompt
	endif.			;[190] End dynamic fdb build

	move q2, [		;[248] Load temporary prompt working area
	    point 7, tpromp ]	;[248] For later work by semantic action

	call rfield		;[190] Parse for some kind of string
	move t1, [		;[248] Copy and count the parsed string
	    point 7, atmbuf ]	;[248] From the atom buffer
	move t2, q2		;[248] 			into temporary prompt
	call asczcp		;[248] Move the string on top of itself, returning count
	sosle t3		;[248] Don't count the NUL at the end!!
	ifskp.			;[248] Didn't get anything, so fix that up
	  setzm tpromp		;[248] No temporary prompt
	  setz t3,		;[248] Clamp to zero length
	endif.			;[248] End case post count fix up

	move t4, q2		;[248] Load pointer to string to expand
	dmovem t3, pars3	;[248] Pass into semantic action
	skipn definf		;[77] In DEFINE?
	 confrm			;[77]  No, get confirmation.

	ret

	subttl Execute the SET PROMPT command.

; Rewritten for [194], [203] and [248]

	chgsec(code,const)	;[248] String constants go in CONST .PSECT
defkpr:	^d3			;[248] Two words of text plus trailing NUL
	defkpt			;[248] Address of prompt text
defkpt:	asciz "Kermit-20>"	;[248] Default Kermit prompt text

; Quickly copies the length checked string that .setpr built in the
; temporary prompt holding area, expanding as appropriate.

movprm:	movslj 0,0		;[203] Move string left justified (fastest)
	       .chnul		;[203] No fill, actually
	retsec			;[248] Back into code

	extern chrtab, cescxp	;[203] C-escape-sequence expansion

$setpr:	saveac <q1,q2,q3,q4>	;[248] Don't let piggy movslj trash these
	dmove q3, pars3		;[248] Load parsed string

	skiple t3, q3		;[248] Load and test length
	ifskp.			;[248] Zero length or gubbish?
	  dmove t1, defkpr	;[248] Fine, ignore it
	  movei t3, prompx	;[248] Putting default into prompt
	  xblt. t1		;[248] Drop it in
	  ret			;[248] We're done
	endif.			;[248] End case of no prompt or gubbish

	move t1, q4		;[248] Source string
	move t2, q4		;[248] Will be expanding (I.E., shrinking) in place
	remark t3, q3		;[248] Loaded and checked by skiple, above
	movei t4, chrtab	;[248] Not doing upper casing

	call cescxp		;[203] Expand any C-escape-sequences
	 %ermsg (<Set PROMPT could not expand string>,r) ;[248] Failed??
	skipg t1, t3		;[248] Load and check updated length
	 %ermsg (<Set PROMPT expanded into nothing>,r) ;[248] Failed??

	move t2, q4		;[248] Load source
	setzb t3, q2		;[203] Section local pointers
	move t4, t1		;[203] Equal lengths; no filling
	move q1,[point 7, prompx] ;[203] What dpromp will use
	extend t1, movprm	;[203] Copy the string over, wee!!
	 nop			;[203] Ignore +1 which should never happen
	idpb t3, q1		;[248] Tie off the prompt
	ret			;[203] That's it, really

	subttl SET RETRY command

	%table(retrtb)			;[194] 
	%key2 <initial-connection>,0	;[194] 
	%key2 <packets>,1		;[194] 
	%tbend				;[194] 

	chgsec(code,const)	;;FDB's are not in code, they're in const
srefdb:	flddb. .cmkey,,retrtb,,<packets>,, ;[194] 
srifdb:	flddb. .cmnum,,^d10,<times to retry initial-connection before giving up,>,5,,
srpfdb:	flddb. .cmnum,,^d10,<times to retry sending a packet before giving up,>,16
	retsec			;;Back to where-ever we started from

.setre:	guide <maximum for>	;[37] SET RETRY
	movei t1, srefdb	;[194] 
	call rfield
	hrrz t2, (t2)		; Get the keyword index
	movem t2, pars3
	guide <to>		; Prompt for the value
	movei t1, srifdb	;[194] Let's assume it was initial-connection
	skipe pars3		;[194] But!!  Was it?
	 movei t1, srpfdb	;[194]  No, doing it for packets
	call rfield
	movem t2, pars4

	ifl. t2			;[194] Negative counts are silly
	  emsg <A negative retry count for >	;[187] 
	  ifmn. pars3				;[194] Set if packets
	    txmsg <packet resends>		;[194] 
	  else.			;[187] 
	    txmsg <initial connection attempts>	;[194] 
	  endif.		;[187] 
	  txmsg < is illogical>	;[194] Go tell 'em, Spock-o
	  jrst cmder1		;[194] 
	endif.			;[194] 

	skipn definf		;[77] In DEFINE?
	 confrm			;[77]  No, get confirmation.
	ret

	remark SET RETRY semantic action

$setre:	extern imxtry, maxtry	; Our necessaries
	dmove t1, pars3		;[37] SET RETRY
	remark t2, pars4	;[194] 
	movem t2, @[exp imxtry, maxtry](t1)
	ret

	subttl SET SPEED (BAUD RATE)

	%table(baudtb)		;Table of DH11 supported speeds
	%key2 <110>,^d110
	%key2 <1200>,^d1200
	%key2 <150>,^d150
	%key2 <1800>,^d1800
	%key2 <2000>,^d2000
	%key2 <2400>,^d2400
	%key2 <300>,^d300
	%key2 <3600>,^d3600
	%key2 <4800>,^d4800
	%key2 <600>,^d600
	%key2 <7200>,^d7200
	%key2 <9600>,^d9600
	%tbend

	chgsec(code,const)	;;FDB's are not in code, they're in const
sxpfdb:	flddb. .cmkey,,baudtb
	retsec			;;Back to where-ever we started from

.setxp:	guide <to>
	movei t1, sxpfdb
	call rfield
	hrrz t2, (t2)		; Get the value for the keyword (0 or 1).
	movem t2, pars3		; Save into pars3.
	skipn definf		;[77] In DEFINE?
	 confrm			;[77]  No, get confirmation.
	ret	

	remark SET SPEED semantic action

$setsp:	extern netjfn, vtermf	;[194] Our necessaries
	extern speed, setspd	;[194] These, too
	extern ttyjfn		;[186] 

	ifmn. vtermf		;[186] SET SPEED is senseless if virtual
	  setom speed		;[186] These have no speed
	  setom setspd		;[186] Kind of set the speed...
	  %ermsg (<Can not set speed for a host or pseudo connection>,r)
	endif.			;[186] End case non-physical terminal

	move t3, pars3		; Get the speed that was parsed.
	movem t3, speed		; Record it.
	skipg t1, netjfn	;[186] Get the output terminal JFN.
	 move t1, ttyjfn	;[186]  Unless using local terminal
	movx t2, .mospd		; Speed to set.
	hrl t3, speed		; Input and output speeds the same.
	MTOPR			; Attempt to set it.
	 %jserr (,r)
	setom setspd		;[161] Flag that speed was explicitly set.
	ret

	subttl SET SERVER-TIMEOUT semantic action

; Command is at a higher level because this is where Kermit-10 puts it
; and I keep mixing the two up.
;
; Further, it seems counter-intuitive to put server-timeout in as a
; receive option when what is actually happening is that the server is
; *sending* and not recieving.
;
; None the less, this way to do it is invisible and the other is
; visible because that's the way it's always been.
;
; Parse is handled by common .setim.

$setst:	dmove t1, pars4		;[217] Load milliseconds and floating seconds
	dmovem t1, srvtim##	;[217] Store them
	ret			;[217] That's it, really


	subttl SET TRANSMIT parameter parsing, all [266] 

;[266] By rights, this really should have gone in K20IOC, but that
;    module is getting large, so it went in here.

;[266] Do NOT order these data entries!

	chgsec(code,data)	;[266] Storage for variables we sety
teofch::   Z  ;** DO NOT	;[266] Transmit EOF character (defaults to none)
tsilen::   Z  ;  REORDER **	;[266] Whether to allow blat from parsing
tmaxln:: strbl8			;[266] Maximum line we'll try to force
timeou:: exp Z,Z		;[266] If timing out the SIN(R)%/SOUT(R)%
tpause:: exp Z,Z		;[266] Amount to pause, assume nothing
tobser::   Z			;[273] Whether observing case in searches
tsetsd::   Z			;[275] Settings defaults come from SET INPUT
tdefpl::   Z			;[272] Length of remote prompt, if using one
tdefpp::   Z			;[272] Pointer to remote prompt, if using one
tdefps:: block strblw		;[272] Block for remote string string
	retsec

	%table(tratbl)		;[266] Transmit parameter table
	%key3 <case>, .setca, tobser		;[273] 
	%key3 <default-remote-prompt>, .setdf, tdefpl	;[272] 
	%key3 <EOF>, .setef, teofch		;[266] 
	%key3 <maximum-length>, .setmx, tmaxln	;[266] 
	%key3 <pause>, .setpu, tpause		;[266] 
	%key3 <settings-defaults>, .setsd, tsetsd ;[275] 
	%key3 <silent>, .setsi, tsilen		;[266] 
	%key3 <timeout>, .setmo, timeou		;[266] 
	%tbend

	chgsec(code,const)	;;FDB's are not in code, they're in const
trafdb:	flddb. .cmkey,,tratbl,,,
	retsec			;;Back to where-ever we started from

.setra:	guide <parameter>	;[266] Inform them we're changing a setting
	movei t1, trafdb	;[266] Settings we can change for transmit
	call rfield		;[266] Go parse something
	hrrz t2, (t2)		;[266] Get the secondary routine addresses
	movem t2, pars3		;[266] Save both for later parsing and semantic action
	hlrz t1, (t2)		;[266] Load the secondary parsing routine address
	callret (t1)		;[266] Go do something wonderful

	subttl SET TRANSMIT CASE [ observe | ignore ]

	extern castab		;[273] SET INPUT CASE in K20IOC

	chgsec(code,const)	;;FDB's go in const .psect
casfdb:	flddb. .cmcfm,,,<to reset to the default of ignore,>,,cadfdb
cadfdb: flddb. .cmkey,,castab,,,
	retsec			;;Get back into code .psect

.setca:	guide <for matching remote system responses>
	saveac <q1>		;[273] Need to remember function code

	movei t1, casfdb	;[273] Looks just like 
	skipe definf		;[273] Not in a DEFINE?
	 movei t1, cadfdb	;[273]  No, we are, so don't parse for a confirm
	call rfield		;[273] Parse a keyword or default
				;[273] Got something, so pick up function code
.setc1:	remark			;[275] Linkage from SETTINGS-DEFAULTS
	ldb q1, [pointr (.cmfnp(t3),cm%fnc)]
	caie q1, .cmcfm		;[273] Wants the default?
	ifskp.			;[273] That's easy, give him the default (ignore)
	  setz t2,		;[273] This is the parse value for "ignore"
	else.			;[273] Otherwise, handle the keyword
	  hrrz t2, (t2)		;[273] Get the value for the keyword (0 or 1).
	endif.			;[273] End parse determination and handling

	movem t2, pars4		;[273] Save as the integer value
	setzm pars5		;[273] It's a single value, not a float

	cain q1, .cmcfm		;[273] Was default requested?
	 ret			;[273] It was, so don't reconfirm a confirmation
	skipn definf		;[273] In DEFINE?
	 confrm			;[273] No, get confirmation.
	ret			;[273] Done

	subttl SET TRANSMIT settings-defaults

	%table(tsdtbl)		;[275] Transmit settings before table
	%key2 <input>, 0	;[275] Settings come from SET INPUT
	%key2 <transmit>, -1	;[275] Settings come from SET TRANSMIT
	%tbend			;[275] 

	chgsec(code,const)	;;FDB's go in const .psect
tsdfdb:	flddb. .cmcfm,,,<to reset to settings defaults from SET INPUT,>,<input>,tsdfd1
tsdfd1: flddb. .cmkey,,tsdtbl,,,
	retsec			;;Get back into code .psect

.setsd:	guide <to track INPUT or TRANSMIT context>
	saveac <q1>		;[275] Will need to preserve for downstream function code

	movei t1, tsdfdb	;[275] Looks a lot like SET CASE
	skipe definf		;[275] Not in a DEFINE?
	 movei t1, tsdfd1	;[275]  No, we are, so don't parse for a confirm
	call rfield		;[275] Parse a keyword or default
	callret .setc1		;[275] Join .setc1 to analyze parse

	subttl SET TRANSMIT DEFAULT-REMOTE-PROMPT secondary parsing tables and constants

; Gets a string, counts it and stashes it in a temporary area.  Then
; tries to expand any C-escape characters and gives parse error if it
; can't, which allows the user to type a ^H and edit.
;
; It then hijacks the rest of the parse to get our own semantic action
; routine called instead of using the default to set a single or
; double value, which won't work for strings.
;
; Because of the design of the main parser to allow macro definitions
; and to be compliant with that paradigm, this involves an extra level
; of indirection, as seen below.
;
; We pull these same kind of shenanigans for SET INPUT SEARCH-DEFAULT
; in K20IOC (see .sinse:)

	chgsec(code,const)	;;FDB's are not in code, they're in const
dfpfdb:	flddb. .cmcfm,,,<To clear the current default remote prompt,>,,dfpfdt ;;[272] 
dfpfdt:	flddb. .cmqst,,,<to set a default remote prompt to search for,>,,dfpfd1 ;;[272] 
dfpfd1:	flddb. .cmtxt,,,<to not use double quotes for the default remote prompt,>,,
	cleans(<dfpfd1>)	;;[272] 

$setdi:	$setdf			;;[272] Indirect call for semantic action
	retsec			;;Back to where-ever we started from

mxdpln==strblc-3		;[272] Maximum length, minus 2 .chdql & .chnul

	subttl SET TRANSMIT DEFAULT-PROMPT secondary parsing

	extern incase		;[273] Defined in K20IOC, INPUT case matching
	extern chrtup		;[273] Defined in K20IOC, UPPER casing translation

.setdf:	guide <to>		;[272] Prompt for a limited character
	saveac <q1,q2,q3,q4>	;[272] Will need to save some parse results
	movei t1, dfpfdb	;[272] Parse for something to do
	skipe definf		;[272] We're not doing a DEFINE, are we?
	 movei t1, dfpfdt	;[272]  It doesn't work to use confirm, then
	call rfield		;[272] Go try to get something

	move q3, t3		;[272] Save original parse result
	ldb q2, [pointr (.cmfnp(q3),cm%fnc)] ;[264] Get what it parsed
	move q4, q2		;[272] Save a copy, too
	ldb q1, [point 7,atmbuf,6] ;[272] Load first byte of atom buffer

	skipe definf		;[272] Not in a DEFINE?
	ifskp.			;[272] No, let's look at the atom buffer
	ande. q1		;[272] Nothing in there??
	  movei q2, .cmcfm	;[272] Turn it into a confirm, then
	endif.			;[272] End case an empty string

	caie q2, .cmcfm		;[272] Confirmation?
	ifskp.			;[272] Yes, we're done
	  setzb t2, t3		;[272] No count and no pointer
	  dmovem t2, pars3	;[272] Store for semantic action
	else.			;[272] Otherwise, count the string
	  dmove t1, [		;[272] Overwritting the atom buffer in place
	    point 7, atmbuf	;[272] So the source is the atom buffer and
	    point 7, atmbuf  ]	;[272] 		the destination is the atom buffer
	  call asczcp		;[272] Move the string on top of itself, returning count
	  sosle t3		;[272] Don't count the NUL at the end!!
	  ifskp.		;[272] If went negative, then clear the default
	    setzb t2, t3	;[272] No count and no pointer
	    dmovem t2, pars3	;[272] Store for semantic action
	  else.			;[272] Otherwise, try to expand
	    dmove t1, [		;[272] Now get it out of the atom buffer
	    point 7, strbuf	;[272] So the destination is the string buffer
	    point 7, atmbuf  ]	;[272] 		and the source is the atom buffer
	    caile t3, mxdpln	;[272] Typed his brains out?
	     movx t3, mxdpln	;[272] Fine, but don't overwrite our storage
	    block.		;[273] Set up block context for better control flow
	      ifme. tsetsd	;[273] Where are our defaults coming from?
		move t4, incase	;[273] Case sensitivity comes from SET INPUT CASE
	      else.		;[273] Otherwise, comes from SET TRANSMIT CASE
		move t4, tobser	;[273] So that's a different variable
	      endif.		;[273] Now have somebody's case observance setting
	      jumpn t4, RSKP	;[273] Set means observing case, skip return
	      ret		;[273] Otherwise, case INsensitive, non-skip return
	    endbk.		;[273] End of block context
	    ifskp.		;[273] Skip return is Case Sensitive compare
	      movei t4, chrtab	;[273] Translate table does not UPPER case
	    else.		;[273] Otherwise CASE INSENSITIVE
	      movei t4, chrtup 	;[273] Upper case everything and match against it
	    endif.		;[273] End translation table determination
	    call cescxp		;[272] Expand any C-escape-sequences
	     %ermsg (<SET TRANSMIT DEFAULT-PROMPT could not expand string>,cmder1)
	    ife. t3		;[272] Let's just double check the result
	      %ermsg (<SET TRANSMIT DEFAULT-PROMPT expanded into nothing>,cmder1)
	    endif.		;[272] Otherwise, good count
	    move t4, [point 7, strbuf] ;[272] Pointer to expanded string
	    dmovem t3, pars3	;[272] Store for semantic action
	  endif.		;[272] End case non-zero counted string
	endif.			;[272] End case .cmqst or .cmtxt

	remark			;[272] Now set up for some magic semantic action!
	hllz t1, @pars2		;[272] Load invoking keyword (SET INPUT)
	hrri t1, $setdi		;[272] Load indirected address of our semantic action
	movem t1, pars2		;[272] 	and take over the rest of the parse

	remark			;[272] Now finish up the moby parse
	cain q4, .cmcfm		;[272] Original wasn't a confirm?
	ifskp.			;[272] Nope, we might have to confirm
	  skipe definf		;[272] Not in a DEFINE command?
	anskp.			;[272] No, we are, so confirm will break macro
	  confrm		;[266] Not in a DEFINE, so must confirm the command
	endif.			;[272] End case potentially confirming string
	ret			;[272] Return ...somewhere...

	subttl SET TRANSMIT DEFAULT-PROMPT semantic action

;[272] The code surrounds the string with double quotes so that an escape
;    will fill in the search string for us when parsing TRANSMIT.

$setdf:	saveac <q1,q2,q3,q4>	;[272] movslj needs plenty registers!
	dmove q3, pars3		;[272] Load the parse results, length and
	remark q4		;[272] 		pointer ...

	ifg. q3			;[272] Got anything?
	  move q2, q4		;[272] Yes, let's have a quick peek
	  ildb t3, q2		;[272] Grab the first character
	andn. t3		;[272] Treat a NUL as clearing the default
	  caile q3, mxdpln	;[272] Got some crazy length?
	   movx q3, mxdpln	;[272]  Yes, clip it down; don't overwrite our storage
	  move t4, q3		;[272] Will only transfer the string
	  move t1, t4		;[272] So they'll be the same length
	  move t2, q4			;[272] Load the source
	  move q1, [point 7, tdefps]	;[272] 		and the destination
	  cain t3, .chdbq	;[272] First character NOT a double quote?
	  ifskp.		;[272] No, so let's put one in
	    movei t3, .chdbq	;[272] Load a double quote
	    idpb t3, q1		;[272] Store it
	    addi q3, ^d1	;[272] Increase final total length
	  endif.		;[272] End case quoting the string
	  setzb t3, q2		;[272] Section local pointers!!!
	  extend t1, movprm	;[272] Copy the string over, wee!!
	   %jsErr (<SET TRANSMIT DEFAULT-PROMPT could not set prompt>,r) ;;[272] ??
	  ldb t3, q1		;[272] Grab the final character
	  cain t3, .chdbq	;[272] Final character NOT a double quote?
	  ifskp.		;[272] No, so let's put one in
	    movei t3, .chdbq	;[272] Load a double quote
	    idpb t3, q1		;[272] Store it
	    addi q3, ^d1	;[272] Increase final total length
	  endif.		;[272] End case quoting the string
	  move q4, [point 7, tdefps]	;[272] Load pointer to default string
	  dmovem q3, tdefpl		;[272] Store length and pointer
	  ildb t1, q1		;[272] Tie off the string, just in case
	  ret			;[272] Done setting up the default!
	else.			;[272] Otherwise, empty string
	  setzb t1, t2		;[272] Cons up ten handy NUL's
	  dmovem t1, tdefpl	;[272] Yes, so clear the length and pointer
	  dmovem t1, tdefps	;[272] Stomp a bit of the buffer, too, just in case
	  ret			;[272] Done with this easy case
	endif.			;[272] End case clearing the default

	ret			;[272] Should never get here, but just in case...


	subttl SET TRANSMIT EOF secondary parsing

.setef:	extern tranft		;[266] Transmit EOF token FDB is in K20IOC
	guide <character to>	;[266] Prompt for a limited character
	movei t1, tranft	;[265] Look for an EOF token
	call rfield		;[265] Ask them to type one of them
	tlz  t3, -1		;[265] Isolate fdb we actually used
	move t2, .cmdat(t3)	;[265] Pick up the byte pointer to the character
	ildb t1, t2		;[265] Load the token character (only one)
	cain t1, "$"		;[266] Our goofy escape synonym?
	 movei t1, .chesc	;[266]  Yes, transmogrify it
	call @parity		;[266] And put parity on it (if doing parity)
	movem t1, pars4		;[266] Save EOF character
	setzm pars5		;[266] It's a single value
	skipn definf		;[266] In a DEFINE command?
	 confrm			;[266]  No, must confirm the command
	ret			;[266] Return to hit semantic action


	subttl SET TRANSMIT maximum-length secondary parsing

.setmx:	extern maxfdb		;[266] Transmit maximum length FDB is in K20IOC
	guide <of characters to transmit to> ;[266] 
	movei t1, maxfdb	;[265] Look for an integer count of characters
	call rfield		;[265] Ask them to type one it

	ifl. t2			;[265] Is the number delusional?
	  emsg <A negative maximum line length is not logical> ;[265] Silly...
	  jrst cmder1		;[265] Yet allow reparse
	endif.			;[265] End initial sanity checking

	cail t2, strbl8		;[265] Larger than largest we can spew?
	ifskp.			;[265] Nope, let's use it
	  ife. t2		;[265] Typed a zero?
	    movei t2, strbl8	;[265] Load maximum buffer can hold
	  endif.		;[265] Make life easier...
	  movem t2, pars4	;[265] Return parsed value, imagined or not
	  setzm pars5		;[266] It's a single value
	  skipn definf		;[266] In a DEFINE command?
	   confrm		;[266]  No, must confirm the command
	  ret			;[266] Return to hit semantic action
	endif.			;[266] Done checking

	emsg <Specified value for maximum length value is out of range>	;[265] 
	jrst cmder1		;[265] Yet allow reparse

	subttl SET TRANSMIT pause secondary parsing

	chgsec(code,const)	;;FDB's are not in code, they're in const
trapau::flddb. .cmflt,,,<seconds to pause after sending a line of text,>,<0>
	retsec			;;Back to where-ever we started from

.setpu:	guide <between lines to> ;[266] 
	movei t1, trapau	;[266] Load address of pause fdb
	call rfield		;[266] pause parsing common code.
	guide <seconds>		;[266] Remind them what they typed

	ifl. t2			;[266] Is the number in the right range?
	  emsg <Negative pauses are not logical> ;[266] In fact, they're down silly
	  jrst cmder1		;[266] Allow reparse in case we did an oopsie
	endif.			;[266] 
				;[266] Convert to integer and range check
	remark			;[266] When chksec works, it works completely
	call chksec		;[266] Ensure number is in correct range
	ifskp.			;[266] Does it check and did it convert OK?
	  remark		;[266] Yes, must confirm later, maybe
	else.			;[266] Otherwise, couldn't swallow something
	  emsg <Inter-line pause interval is out of range> ;[266]
	  jrst cmder1		;[266] Allow reparse
	endif.			;[266] End range check

	skipg t1, pars4		;[266] Load non-zero milliseconds
	ifskp.			;[266] Let's range check that
	  caig t1, maxtim	;[266] Over 94 seconds?
	anskp.			;[266] Nope, safe to use
	  emsg <Pause interval exceeds maximum> ;[266] 
	  jrst cmder1		;[266] Allow reparse
	endif.

	skipn definf		;[266] In a DEFINE command?
	 confrm			;[266]  No, must confirm the command
	ret			;[266] Return to hit semantic action


	subttl SET TRANSMIT silent secondary parsing

	chgsec(code,const)	;;FDB's are not in code, they're in const
silfdb:	flddb. .cmkey,,offon,,on
	retsec			;;Back to where-ever we started from

.setsi:	guide <to suppress remote system responses> ;[266] 
	movei t1, silfdb	;[266] Point to the FDB for On/Off
	call rfield		;[266] Parse one of them
	hrrz t2, (t2)		;[266] Get the value for the keyword (0 or 1)
	movem t2, pars4		;[265] Return parsed value of keyword
	setzm pars5		;[266] It's a single value
	skipn definf		;[266] In a DEFINE command?
	 confrm			;[266]  No, must confirm the command
	ret			;[266] Return to hit semantic action

	subttl SET TRANSMIT timeout secondary parsing

	chgsec(code,const)	;;FDB's are not in code, they're in const
traout:	flddb. .cmflt,,,<seconds to wait before timing out,>,<0>
	retsec			;;Back to where-ever we started from

.setmo:	guide <expiration to break out of a transmit> ;[266] 
	movei t1, traout	;[266] Load address of timeout fdb
	call rfield		;[266] pause parsing common code.
	guide <seconds>		;[266] Remind them what they typed

	ifl. t2			;[266] Is the number in the right range?
	  emsg <Negative timeouts are not logical> ;[266] They're downright silly
	  jrst cmder1		;[266] Allow reparse in case we did an oopsie
	endif.			;[266] 
				;[266] Convert to integer and range check
	remark			;[266] When chksec works, it works completely
	call chksec		;[266] Ensure number is in correct range
	ifskp.			;[266] Does it check and did it convert OK?
	  remark		;[266] Yes, must confirm later, maybe
	else.			;[266] Otherwise, couldn't swallow something
	  emsg <Time out interval is out of range> ;[266]
	  jrst cmder1		;[266] Allow reparse
	endif.			;[266] End range check

	skipg t1, pars4		;[266] Load non-zero milliseconds
	ifskp.			;[266] Let's range check that
	  caig t1, maxtim	;[266] Over 94 seconds?
	anskp.			;[266] Nope, safe to use
	  emsg <Time out interval exceeds maximum> ;[266] 
	  jrst cmder1		;[266] Allow reparse
	endif.

	skipn definf		;[266] In a DEFINE command?
	 confrm			;[266]  No, must confirm the command
	ret			;[266] Done with secondary parse


	subttl SET TVT-BINARY command parsing

	%table(tvtkey)		;[182] Table for parsing TVT keywords
	%key3 <automatic>, 0, 1	;[182] Figure it out for me
	%key3 <off>, 0, 0	;[182] Override to never negotiate
	%key3 <on>, 1, 0	;[182] Override to ALWAYS negotiate
	%tbend			;[182] Which will break on LAT, CTERM, etc..

	%table(dscswi)		;[271] Discovery switch table
	%key2 <discover>, 1	;[271] If forcing a discovery if TVT fitness
	%tbend			;[271] Otherwise, it is differed

	chgsec(code,const)	;;FDB's are not in code, they're in const
stafdb:	flddb. .cmkey,,tvtkey,,<automatic> ;;[271] 
tvscfm:	flddb. .cmcfm,,,<to differ line condition,>,,tvsdsf ;;[271] 
tvsdsf:	flddb. .cmswi,,dscswi,<to immediately determine line condition, type>,,	;;[271] 
	retsec			;;Back to where-ever we started from

.setta:	guide <negotiation>
	movei t1, stafdb	;[182]
	call rfield		; Parse a keyword.
	hrrz t2, (t2)		; Get the value for the keyword (0 or 1).
	movem t2, pars3		; Save into pars3.

	move t1, (t2)		;[271] De-reference %key3 parse item to get values
	hrrz t3, t1		;[271] Right halfword is automatic mode
	ife. t3			;[271] Are we NOT setting automatic mode?
	  skipn definf		;[77] In DEFINE?
	   confrm		;[77]  No, get confirmation.
	  ret
	endif.			;[271] End simple parse case of forcing mode

	saveac <q1, q2, q3>	;[271] Save some more registers
	movei t1, tvscfm	;[271] Either confirm or get the switch
	skipe definf		;[271] NOT in a macro DEFINE?
	 movei t1, tvsdsf	;[271] Actually, we are so just try for the switch

	call rflde		;[271] Try to get one of them
	ifskp.			;[271] Worked!!
	  dmove q2, t2		;[271] Save intermediate parse results
	  ldb q1, [pointr (.cmfnp(q3),cm%fnc)] ;[271] Get function code.
	else.			;[271] Otherwise, failed the parse
	  skipn definf		;[271] But!!  In DEFINE?
	   jrst cmderr		;[271] No, then a definite parse error; allow retry
	  ret			;[271] Return into DEFINE and see if that chokes
	endif.			;[271] End handling COMND% returns

	caie q1, .cmcfm		;[271] So, did we simply confirmed the SET?
	ifskp.			;[271] Yep, so not doing immediate discovery
	  setzm pars4		;[271] So flag that that
	  ret			;[271] Done, nothing left to parse
	endif.			;[271] 

	caie q1, .cmswi		;[271] Parsed a switch?  (only one of them)
	ifskp.			;[271] Yep, so forcing immediate discovery
	  setom pars4		;[271] So flag that that
	  skipn definf		;[271] Just in case, are we in a DEFINE?
	   confrm		;[271]  No, so must confirm
	  ret			;[271] Done, nothing left to parse
	endif.			;[271] 

	jrst cmderr		;[271] No, then a definite parse error; allow retry


	subttl SET TVT-BINARY semantic action

; Request binary-mode negotion with ARPAnet TAC.
;
;[129] This command added as part of edit 129.
;[182] Help message updated for automatic mode
;[271] Adds ability to force discovery

	remark			;[271] Routines found in k20net
	extern chktvt		;[271] See if current connection is a TVT
	extern doarpa		;[271] Turn on TVT binary mode
	extern unarpa		;[271] Turn TVT binary mode off

	remark			;[271] Ariables and storage found in k20net
	extern tvtflg		;[271] Set if we are on a TVT
	extern tvtchk		;[271] If doing TVT binary discovery
	extern tvtbin		;[271] If used or forced binary mode
	extern tvtunk		;[271] If doing discovery, if we know we can do binary
	extern ntihst		;[271] Remote Internet host name (59 characters)

$setta:	move t1, pars3		; Get the value that was parsed.
	move t2, (t1)		;[182] De-reference to get values
	hrrz t3, t2		;[182] Right halfword is automatic mode
	hlrz t2, t2		;[182] Left halfword is the TVT-Binary mode
	ife. t3			;[194] Setting automatic mode?
	  setzm tvtchk		;[271] No, we are overriding
	  movem t2, tvtbin	;[271] So force the value
	  setzm tvtunk		;[271] Which we now know
	  ret			;[182] Return with line discovery off
	endif.			;[194] 

	exch t3, tvtchk		;[182] Update TVT checking mode, get old mode
	ifn. t3			;[271] Wants automatic but already had it set?
	  skipe pars4		;[271] AND isn't forcing discovery?
	anskp.			;[271] No, forcing discover, so go try to do it
	  ret			;[271] Otherwise, we're done, so get out of hee
	endif.			;[271] End case determining whether to proceed

	remark			;[271] At this point, we are in automatic mode
	skipe vtermf		;[186] Virtual terminal?
	 ret			;[186]  NRT and PTY don't do TVT

	subttl TVT-Binary /DISCOVER processing

	call chktvt		;[271] Check if we are on a TVT
	ifme. tvtflg		;[271] Well, are we?
	  txmsg <%Can not force discovery on a non-Telnet Virtual Terminal
>				;[271] You silly ...
	  ret			;[271] Get out of here
	endif.			;[271] and don't do any binary IAC's

	remark Report Progress	;[271] These routines will complain on failure
	txmsg <[KERMIT-20: Turning TVT binary mode on>	;[271] 
	call doarpa		;[271] Try turning it binary mode on
	txmsg <, Pause>		;[271] Let them know we're doing nothing
	movei t1, ^d2500	;[271] Just wait a bit
	DISMS%			;[271] So ancient TAC can catch its breath
	txmsg <, Turning TVT binary mode off> ;[271] 
	call unarpa		;[271] Now turn it back off
	txmsg <]

>				;[271] Signal end of test

	remark Print results of test

	ifmn. tvtunk		;[271] So, did we actually find anything out?
	  txmsg <%TVT Binary mode is still unknown!
>				;[271] THAT should not have happened
	endif.			;[271] 

	remark			;[271] Might have worked, tell use about the host
	ifmn. tvtbin		;[271] Did it work?
	  hrroi t1, ntihst	;[271] Point to remote Internet host name
	  PSOUT%		;[271] 
	  txmsg < supports setting binary mode
>				;[271] Give us the good news
	else.			;[271] Otherwise, didn't work
	  hrroi t1, ntihst	;[271] Point to remote Internet host name
	  ESOUT%		;[271] That's really an error
	  txmsg < did NOT support setting binary mode!
>				;[271] Give us the good news
	endif.			;[271] End case reporting the test results

	ret			; Done.

	subttl SET RECEIVE parameters

	%table(srtabl)
	%key3 <end-of-line>, .seteo, reolch##
	%key3 <packet-length>, .setpk, rpsiz##
	%key3 <padchar>, .setpc, rpadch##
	%key3 <padding>, .setpd, rpadn##
	%key3 <pause>, .srpau, rpause## ;[36]
	%key3 <quote>, .setqu, rquote##
	%key3 <server-timeout>, .setim, srvtim## ;[137]
	%keyf4 <srv-timeout>, .setim, srvtim##, cm%inv ;[212] keep typing this..
	%key3 <start-of-packet>, .setsp, rsthdr## ;[18]
	%key3 <timeout>, .setim, rtimou##
	%tbend

	chgsec(code,const)	;;FDB's are not in code, they're in const
srcfdb:	flddb. .cmkey,,srtabl,,,
	retsec			;;Back to where-ever we started from

.setrc:	movei t1, srcfdb	; SET RECEIVE ...
	call rfield		; Parse a keyword.
	hrrz t2, (t2)		; Get the command routine addresses.
	movem t2, pars3		; Save into pars3.
	hlrz t1, (t2)		; Get the next level routine.
	call (t1)		; Call it.
	ret

	subttl SET SEND parameters

	%table(sstabl)
	%key3 <end-of-line>, .seteo, seolch##
	%key3 <packet-length>, .setpk, spsiz##
	%key3 <padchar>, .setpc, spadch##
	%key3 <padding>, .setpd, spadn##
	%key3 <pause>, .sspau, spause## ;[35]
	%key3 <quote>, .setqu, squote##
	%key3 <start-of-packet>, .setsp, ssthdr## ;[18]
	%key3 <timeout>, .setim, stimou##
	%tbend

	chgsec(code,const)	;;FDB's are not in code, they're in const
ssnfdb:	flddb. .cmkey,,sstabl,,,
	retsec			;;Back to where-ever we started from

.setsn:	movei t1, ssnfdb	; SET SEND ...
	call rfield		; Parse a keyword.
	hrrz t2, (t2)		; Get the command routine addresses.
	movem t2, pars3		; Save into pars3.
	hlrz t1, (t2)		; Get the next level routine.
	call (t1)		; Call it.
	ret

	subttl SET SEND/RECEIVE END-OF-LINE secondary parsing

	chgsec(code,const)	;;Chained FDB's are not in code, they're in const
eolfdm:	flddb. .cmcma,cm%sdh,,,,eolfdb	;[217] Used when unwinding a macro
eolfdb:	flddb. .cmcfm,,,<to reset to the default (carriage return),>,,eolfd1
eolfd1:	flddb. .cmnum,,^d8,<to specify the value of an ASCII control character,>,,eolfd2
eolfd2:	flddb. .cmtok,,token(<^>),<to specify an ASCII control character, type a>,,
	retsec			;;Back to where-ever we started from
	cleans(<eolfd1,eolfd2>)

.seteo:	saveac <q1,q2,q3,q4>	;[217] Needs registers
	guide <to>
	movei t1, eolfdb	;[217] Point to enhanced parse list
	skipe mdone		;[217] Unwinding a macro?
	 movei t1, eolfdm	;[217]  Yes, allow a comma to squeak through

	call rflde		;[217] Try to get one of them
	ifskp.			;[217] Worked!!
	  dmove q2, t2		;[217] Save some of the parse results
	  ldb q1, [pointr (.cmfnp(q3),cm%fnc)] ;[217] Get function code.
	  move q4, q1		;[217] Save original parse
	else.			;[217] Otherwise, failed the parse
	  skipn definf		;[217] In DEFINE?
	   jrst cmderr		;[217] No, then a definite parse error; allow retry
	  ret			;[217] Return into DEFINE and see if that chokes
	endif.			;[217] End handling COMND% returns

	caie q1, .cmcma		;[217] Parsed a comma?
	ifskp.			;[217] We did, so must be unwinding a macro
	  movei q1, .cmcfm	;[217] Turn it into a confirm and carry on
	  move q4, q1		;[217] Stomp it in as a confirm
	endif.

	caie q1, .cmcfm		;[217] A confirm is very special cased
	ifskp.			;[217] It was, so default it
	  movei t1, .chcrt	;[217] Replace parse value with carriage return
	  call @parity		;[223] Put any necessary parity on it
	  movem t1, pars4	;[217] Save the EOL char we parsed.
	  ret			;[217] Done, nothing left to parse
	endif.			;[217] 

	cain q1, .cmnum		;[217] Number?
	 jrst .sete1		;[217] Yes, this must be checked

	remark q1, .cmtok	;[217] Otherwise, must have been a token
	dmove t1, [ esctkn	;[217] Possible mnemonics
		    cm%xif ]	;[217] Load the no indirection flag
	orm t2, sbk+.cmflg	;[217] And dink the COMND% state block
	call rflde		;[217] Try to get one of them
	ifskp.			;[217] Worked!!
	  ldb q1, [pointr (.cmfnp(t3),cm%fnc)] ;[217] Get function code.
	  dmove q2, t2		;[217] Save parse data and fdb selection
	  remark q4,		;[217] Leave original parse item alone
	  movx t4, cm%xif	;[217] Load indirection flag again
	  andcam t4, sbk+.cmflg	;[217] And restore the COMND% state block
	else.			;[217] Otherwise, failed the parse
	  movx t4, cm%xif	;[217] Load indirection flag again
	  andcam t4, sbk+.cmflg	;[217]     restore the COMND% state block
	  jrst cmderr		;[217] And handle the parse error, allowing reparse
	endif.			;[217] End handling COMND% returns

	caie q1, .cmkey		;[217] Was this relatively easy? 
	ifskp.			;[217] Yep, let's grab and convert the character
	  hrrz t2, (q2)		;[217] Pick up what would be the jump address
	  jrst .sete1		;[217] Make sure a valid choice
	endif.

	remark q1, .cmtok	;[217] A token is somewhat more difficult
	tlz  q3, -1		;[217] Isolate fdb we actually used
	move q2, .cmdat(q3)	;[217] Pick up the byte pointer to the character
	ildb t2, q2		;[217] Load the token character (only one)
	subi t2, "@"		;[217] Bring down to control character range
	came t2, [-21]		;[217] Typed a rubout?
	ifskp.			;[217] Not valid as EOL
	  emsg <May not use rubout as an end of line character>	;[217] Whine
	  jrst cmder1		;[217] Allow a retry
	endif.			;[217] Otherwise, no need to check hardwired values
	remark .sete1		;[217] Double check for other funnyness

.sete1:	ifl. t2			;[194] A negative ASCII character value is silly
	  emsg <Negative ASCII is illogical> ;[217] So whine about it
	  jrst cmder1		;[217] Allow retry (^H)
	endif.			;[217] 

	caige t2, 200		;[217] Out of ASCII range?
	ifskp.			;[217] Yep, can't handle that, either
	  emsg <ANSI 7 bit ASCII not defined for values over 200 octal> ;[217] Complain
	  jrst cmder1		;[217] Allow retry (^H)
	endif.			;[217] 

	caile t2, .chcun	;[194] Is the number in the right range? (^o37)
	 jrst seteor		;[194]  No, give error message

.sete2:	remark			;[217] Here when we don't need to check (or just did)
	move t1, t2		;[223] Load the character
	call @parity		;[223] Put any necessary parity on it
	movem t1, pars4		;[223] Save the EOL char we parsed.
	remark			;[217] These two instructions are unnecessary, but...
	cain q4, .cmcfm		;[217] Wanted default?
	 ret			;[217] Yes, don't confirm the confirmation
	skipn definf		;[77] In DEFINE?
	 confrm			;[77]  No, get confirmation.
	ret

seteor:	move t4, t2		;[217] Let's tuck that poor character out of the way
	emsg <">	;"	;[217] Fire up the complaint department
	move t1, t4		;[217] Let's expose the bad character
	call putc		;[217] Print it
	txmsg <" is an invalid EOL character> ;[217] " Font crock
	jrst cmder1		;[194] Allow command retry

	subttl SET SEND/RECEIVE PACKET-LENGTH secondary parsing

	chgsec(code,const)	;;FDB's are not in code, they're in const
spkfdb:	flddb. .cmnum,cm%sdh,^d10,<Decimal number between 10 and 9000>,, ;[194] 
	retsec			;;Back to where-ever we started from

.setpk:	guide <to>
	movei t1, spkfdb	;[194] 
	call rfield		; Parse the packet size.
	caig t2, ^d10		;[194] Is the number in the right range?
	 jrst setpke		;[194] Too small
	caile t2, ^d9000	;[179] (was ^d94)
	 jrst setpke		;[194] Too big
	movem t2, pars4		; Save the packet size.
	skipn definf		;[77] In DEFINE?
	 confrm			;[77]  No, get confirmation.
	ret

setpke:	emsg <Illegal packet size> ;[187] 
	remark			;Maybe type the bad size?
	jrst cmder1

	subttl SET SEND/RECEIVE PADCHAR secondary parsing

	chgsec(code,const)	;;Chained FDB's are not in code, they're in const
pdcfdm:	flddb. .cmcma,cm%sdh,,,,pdcfdb	;[217] Used when unwinding a macro
pdcfdb:	flddb. .cmcfm,,,<to set default padding character (ASCII 0)>,,pdcfd1
pdcfd1:	flddb. .cmnum,,^d8,<value of ASCII character, 0 to 37, or 177,,>,,pdcfd2
pdcfd2:	flddb. .cmtok,,token(<^>),<to specify an ASCII control character, type a>,,
	retsec
	cleans(<pdcfd1,pdcfd2>)

.setpc:	saveac <q1,q2,q3,q4>	;[217] Needs registers
	guide <to>
	movei t1, pdcfdb	;[217] Point to enhanced parse list
	skipe mdone		;[217] Unwinding a macro?
	 movei t1, pdcfdm	;[217]  Yes, allow a comma to squeak through

	call rflde		;[217] Try to get something
	ifskp.			;[217] Worked!!
	  dmove q2, t2		;[217] Partially save the parse results
	  ldb q1, [pointr (.cmfnp(q3),cm%fnc)] ;[217] Get function code.
	  move q4, q1		;[217] Save a copy for downstream
	else.			;[217] Otherwise, failed the parse
	  skipn definf		;[217] In DEFINE?
	   jrst cmderr		;[217] No, then a definite parse error; allow retry
	  ret			;[217] Return into DEFINE and see if that chokes
	endif.			;[217] End handling COMND% returns

	caie q1, .cmcma		;[217] Parsed a comma?
	ifskp.			;[217] We did, so must be unwinding a macro
	  movei q1, .cmcfm	;[217] Turn it into a confirm and carry on
	  move q4, q1		;[217] Stomp for downstream
	endif.

	caie q1, .cmcfm		;[217] A confirm is very special cased
	ifskp.			;[217] It was, so default it
	  movei t1, .chnul	;[217] Replace parse value with NUL (ASCII 0)
	  call @parity		;[223] Apply any necessary parity
	  movem t1, pars4	;[217] Save the EOL char we parsed.
	  ret			;[217] Done, nothing left to parse
	endif.			;[217] 

	cain q1, .cmnum		;[217] Number?
	 jrst .setp1		;[217] Yes, this must be checked

	remark q1, .cmtok	;[217] Otherwise, must have been a token
	dmove t1, [ esctkn	;[217] Possible mnemonics
		    cm%xif ]	;[217] Load the no indirection flag
	orm t2, sbk+.cmflg	;[217] And dink the COMND% state block
	call rflde		;[217] Try to get one of them
	ifskp.			;[217] Worked!!
	  ldb q1, [pointr (.cmfnp(t3),cm%fnc)] ;[217] Get function code.
	  dmove q2, t2		;[217] Save parse data and fdb selection
	  remark q4,		;[217] Don't touch!!
	  movx t4, cm%xif	;[217] Load indirection flag again
	  andcam t4, sbk+.cmflg	;[217] And restore the COMND% state block
	else.			;[217] Otherwise, failed the parse
	  movx t4, cm%xif	;[217] Load indirection flag again
	  andcam t4, sbk+.cmflg	;[217]     restore the COMND% state block
	  jrst cmderr		;[217] And handle the parse error, allowing reparse
	endif.			;[217] End handling COMND% returns

	caie q1, .cmkey		;[217] Was this relatively easy? 
	ifskp.			;[217] Yep, let's grab and convert the character
	  hrrz t2, (q2)		;[217] Pick up what would be the jump address
	  jrst .setp1		;[217] No need to check, these are all fine
	endif.

	remark q1, .cmtok	;[217] A token is somewhat more difficult
	tlz  q3, -1		;[217] Isolate fdb we actually used
	move q2, .cmdat(q3)	;[217] Pick up the byte pointer to the character
	ildb t2, q2		;[217] Load the token character (only one)
	subi t2, "@"		;[217] Bring down to control character range
	camn t2, [-21]		;[217] Was this our rubout hack?
	 movei t2, 177		;[217] Stomp in the correct value
	remark .setp1		;[217] Falls through to check

.setp1:	ifl. t2			;[194] A negative ASCII character value is silly
	  emsg <Negative ASCII is illogical> ;[217] So whine about it
	  jrst cmder1		;[217] Allow retry (^H)
	endif.			;[217] 

	caige t2, 200		;[217] Out of ASCII range?
	ifskp.			;[217] Yep, can't handle that, either
	  emsg <ANSI 7 bit ASCII not defined for values over 177 octal> ;[217] Complain
	  jrst cmder1		;[217] Allow retry (^H)
	endif.			;[217] 

	caig t2, .chcun		; ...37 octal?
	ifskp.			;[194] Out of control character range
	  cain t2, .chdel	;[149] But!!  Is it a DEL?
	anskp.			;[194] It is, so that's fine
	  jrst setpce		;[194] Otherwise, give error message
	endif.			;[194] 

.setp2:	move t1, t2		;[223] Load the character
	call @parity		;[223] Compute any parity
	movem t1, pars4		;[223] Save the padding char
	cain q4, .cmcfm		;[217] Did we already take all defaults?
	 ret			;[217] Yes, don't confirm the confirmation
	skipn definf		;[77] In DEFINE?
	 confrm			;[77]  No, get confirmation.
	ret			; Yes, OK.

setpce:	move t4, t2		;[217] Save the poor character
	emsg <">     ;"		;[217] Begin whining
	move t1, t4		;[217] Load the failing character
	call putc		;[217] Expose it to the world
	txmsg <" is not a valid padding character> ;[217] "Font crock
	jrst cmder1		;[194] and allow command retry.

	subttl SET SEND/RECEIVE PADDING <count> secondary parsing

	chgsec(code,const)	;;FDB's are not in code, they're in const
spdfdb:	flddb. .cmnum,,^d10,<positive number of padding characters, >,<0>,
	retsec			;;Back to where-ever we started from

.setpd:	guide <to>
	movei t1, spdfdb
	call rfield		; Parse the number of padding chars.
	ifl. t2			;[194] Negative padding is silly
	  emsg <A negative padding count is not logical> ;[194] 
	  jrst cmder1		;[194] 
	endif.			;[194] 
	caig t2, dpadmx		;[194] Rediculously large?
	ifskp.			;[194] Yep, we could go days before sending
	  emsg <Maximum padding count exceeded>
	  jrst cmder1		;[194] Allow reparse
	endif.			;[194] 
	movem t2, pars4		; Save the number.
	skipn definf		;[77] In DEFINE?
	 confrm			;[77]  No, get confirmation.
	ret

	subttl SET SEND/RECEIVE pause secondary parsing

;[196] Do the calculation from floating (fractional) seconds to
; integer milliseconds ONCE, here.  Doing it every single packet is a
; pretty gauche use of the processor as it does have other things to
; do...

	chgsec(code,const)	;;FDB's are not in code, they're in const
fsrpau:	flddb. .cmflt,,,<seconds to pause after receiving a packet,>,<0>
fsspau:	flddb. .cmflt,,,<seconds to pause before sending a packet,>,<0>
	retsec			;;Back to where-ever we started from

.srpau:	skipa t1, [fsrpau]	;[196] Address of receive pause fdb
.sspau:	 movei t1, fsspau	;[196] Address of send pause fdb	 
	guide <between packets to> ;[194] 

	call rfield		;[266] pause parsing common code.
	guide <seconds>

	ifl. t2			;[194] Is the number in the right range?
	  emsg <Negative pauses are not logical> ;[187] 
	  jrst cmder1		;[194] Allow reparse
	endif.			;[194] 

	remark			;[212] When chksec works, it works completely
	call chksec		;[196] Ensure number is in correct range
	ifskp.			;[196] Check and convert OK?
	  remark		;[196] Yes, must confirm later, maybe
	else.			;[196] Otherwise, couldn't swallow something
	  emsg <Inter-packet pause interval is out of range> ;[187]
	  jrst cmder1		;[194] Allow reparse
	endif.			;[212] End range check

	skipg t1, pars4		;[212] Load non-zero milliseconds
	ifskp.			;[212] Let's range check that
	  caig t1, maxtim	;[212] Over 94 seconds?
	anskp.			;[212] Nope, safe to use
	  emsg <Pause interval exceeds maximum> ;[212] 
	  jrst cmder1		;[212] Out
	endif.

	skipn definf		;[77] In DEFINE?
	 confrm			;[77]  No, get confirmation.
	ret

	subttl SET SEND/RECEIVE QUOTE character tables and token definitions

define qchrs (c) <		;;[217] Define macro to populate the table
    xlist			;;[217] Don't need to see this in the listing
    irpc c,<			;;[217] Go through all the characters
	%key2 <'c>,<"'c">	;;[217] Emit character and its ASCII code
>;;irpc				;;[217] End of argument expansion
    list			;;[217] Turn the listing back on
>;;qchrs			;;[217] End of macro definition

	%table(qchtb)		;;[217] Printable character table
	qchrs (0123456789) 	;;[217] 'Easy' printable numerals
	qchrs (ABCDEFGHIJKLMNOPQRSTUVWXYZ) ;;[217] 'Easy' printable characters
	%tbend			;[217] End of 'easy' table

;N.B., a number of characters simply do NOT work as tokens

	%table(<toktab>)		;;[217] Token mnemonics
	%key2 <at-sign>,<-"@">		;[217] Kind of chokes on this sometimes
	%key2 <comma>,<-",">		;[217] Clashes with define
	%key2 <dash>,<-"-">		;[217] Parsed as line continuation, always
	%key2 <exclamation-mark>,<-"!">	;[217] Parsed as comment, always...
	%keyf3 <minus-sign>,<-"-">,cm%inv ;[217] Parsed as line continuation, always
	%key2 <question-mark>,<-"?">	;[217] Parsed as choices display, always...
	%key2 <semicolen>,<-";">	;[217] Parsed as comment, always...
	%tbend			;[217] End of mnemonic table

	chgsec(code,const)	;;Chained FDB's are not in code, they're in const

	extern gtkT		;;[258] Grammar Token Table in K20IOC

qoufdm:	flddb. .cmcma,cm%sdh,,,,qoufdb	;[217] Used when unwinding a macro
qoufdb:	remark			;[217] First parse the 'easy' stuff...
     flddb. .cmcfm,,,<to reset the quote character to the default (#),>,,qf1
qf1: flddb. .cmnum,,^d8,<to specify the value of an ASCII printable character,>,,qf2
qf2: flddb. .cmkey,,qchtb,<a printable character,>,,qf3
qf3: flddb. .cmkey,,toktab,<to specify a printable character mnemonic, type>,,gtkT
	cleans(<qf1,qf2,qf3>)	

qchrpt:	point 7, atmbuf, 6	;[217] Character in atom buffer
	retsec			;[217] Finally back in code

	subttl SET SEND/RECEIVE QUOTE secondary parsing

.setqu:	saveac <q1,q2,q3,q4>	;[217] Wants some registers
	guide <to>
	dmove t1, [ qoufdb	;[217] Point to our parsing extravaganza
		    cm%xif ]	;[217] Load the no indirection flag
	orm t2, sbk+.cmflg	;[217] And dink the COMND% state block
	skipe mdone		;[217] Unwinding a macro?
	 movei t1, qoufdm 	;[217] If unwinding a macro, allow a comma

	call rflde		;[217] Try to get one of them
	ifskp.			;[217] Worked!!
	  dmove q2, t2		;[217] Save some of the parse results
	  ldb q1, [pointr (.cmfnp(q3),cm%fnc)] ;[217] Pick up the function code
	  move q4, q1		;[217] Save a copy for downstream
	  movx t4, cm%xif	;[217] Load indirection flag again
	  andcam t4, sbk+.cmflg	;[217] And restore the COMND% state block
	else.			;[217] Otherwise, failed the parse
	  movx t4, cm%xif	;[217] Load indirection flag again
	  andcam t4, sbk+.cmflg	;[217]     restore the COMND% state block
	  jrst cmderr		;[217] And handle the parse error, allowing reparse
	endif.			;[217] End handling COMND% returns

	caie q1, .cmcma		;[217] A comma? (must be unwinding)
	ifskp.			;[217] Yes, so handle it like a default
	  movei q1, .cmcfm	;[217] Just turn it into a confirm
	  move q4, q1		;[217] Update downstream's copy
	endif.			;[217] 		and let the confirm code handle it

	caie q1, .cmcfm		;[217] Wants the default?
	ifskp.			;[217] Yes, that's easy
	  movei t2, "#"		;[217] Default quote character
	  movem t2, pars4	;[217] Pass to semantic action
	  ret			;[217] Done, no need to parse further
	endif.			;[217] End case .cmcfm

	caie q1, .cmkey		;[217] A keyword?
	ifskp.			;[217] It is, let's investigate
	  hrre t4,(q2)		;[217] Pick up the dispatch address
	  ifl. t4		;[217] Negative?
	    movn t2, t4		;[217] It's one of our mnemonics
	  else.			;[217] Otherwise, go grab the
	    ldb t2, qchrpt 	;[217] 	      character from the atom buffer
	  endif.		;[217] Either way, have something
	  jrst .setq1		;[217] 				so go check it
	endif.			;[217] End case .cmkey

	caie q1, .cmtok		;[217] Something from the long list of tokens?
	ifskp.			;[217] Yes, hairy, but doable
	  tlz  q3, -1		;[217] Isolate fdb we actually used
	  move t4, .cmdat(q3)	;[217] Pick up the byte pointer to the character
	  ildb t2, t4		;[217] Load the token character (only one)
	  jrst .setq1		;[217] Go check it
	endif.			;[217] End case .cmtok

	caie q1, .cmnum		;[217] Specified it as an octal number?
	ifskp.			;[217] He did
	  jrst .setq1		;[217] So let's check it
	endif.			;[217] End case .cmnum

	emsg <SET QUOTE parsing inconsistency> ;[217] OK, we're confused...
	jrst cmder1		;[217] Allow a reparse

.setq1:	caig t2, .chspc		;[21] Printable?
	 jrst setque		;[194] No (N.B., does not allow space)
	caile t2, "~"		;[21] Past squiggle?
	 jrst setque		;[194] Yes, then can't use it
	movem t2, pars4		;[21] OK, stash it.
	cain q4, .cmcfm		;[217] Defaulted everything?
	 ret			;[217] Yes, don't reconfirm the confirm
	skipn definf		;[77] In DEFINE?
	 confrm			;[77]  No, get confirmation.
	ret

setque:	move t4, t2		;[217] Get the poor character out of the way
	ifl. t4			;[194] A negative ASCII character value is silly
	  emsg <Negative ASCII is illogical> ;[217] So whine about it
	  jrst cmder1		;[217] Allow retry (^H)
	endif.			;[217] 

	caige t4, 200		;[217] Out of ASCII range?
	ifskp.			;[217] Yep, can't handle that, either
	  emsg <ANSI 7 bit ASCII not defined for values over 177 octal> ;[217] Complain
	  jrst cmder1		;[217] Allow retry (^H)
	endif.			;[217] 

	remark			;[217] Otherwise, handle general case
	emsg <A quote character must be printable (I.E., in the range 41-176), "> ;"
	move t1, t4		;[217] Load the poor character
	call putc		;[217] Print it
	txmsg <" is not.>	;[217] " Font crock mode
	jrst cmder1		;[194] and allow command retry.

	subttl SET SEND/RECEIVE TIMEOUT secondary parsing

	chgsec(code,const)	;;FDB's are not in code, they're in const
stifdb:	flddb. .cmflt,,^d10,<Number of seconds before timing out, 1 to 94,>
	retsec			;;Back to where-ever we started from

.setim:	guide <to>
	movei t1, stifdb	;[212] 
	call rfield		; Parse the number.
	guide <seconds>

	ifl. t2			;[212] Is the number in the right range?
	  emsg <Negative timeouts are not logical> ;[212] 
	  jrst cmder1		;[212] allow reparse
	endif.			;[212] 

	remark			;[212] When chksec works, it works completely
	call chksec		;[212] Ensure number is in correct range
	ifskp.			;[196] Check and convert OK?
	  remark		;[196] Yes, must confirm later, maybe
	else.			;[196] Otherwise, couldn't swallow something
	  emsg <Time out is out of range> ;[187]
	  jrst cmder1		;[194] Allow reparse
	endif.			;[212] End range check

	skipg t2, pars4		;[212] Need to range check?
	ifskp.			;[212] No, it got zeroed
	  caig t2, maxtim	;[212] Greater than 94 seconds?
	anskp.			;[212] Nope it's fine
	  emsg <Timeout exceeds maximum> ;[212] Complain
	  jrst cmder1		;[212] However, allow a reparse
	endif.			;[212] End case checking

	skipn definf		;[77] In DEFINE?
	 confrm			;[77]  No, get confirmation.
	ret

	subttl  SET SEND/RECEIVE START-OF-PACKET character secondary parsing

; To do: The code as it stands allows .CHNUL as start of packet.  That's
;	 probably a bad idea, right?  Disallow it?

	chgsec(code,const)	;;Chained FDB's are not in code, they're in const
sohfdm:	flddb. .cmcma,cm%sdh,,,,eolfdb	;[217] Used when unwinding a macro
sohfdb:	flddb. .cmcfm,,,<to reset to the default (Control-A, SOH),>,,sohfd1
sohfd1:	flddb. .cmnum,,^d8,<to specify the value of an ASCII control character,>,,sohfd2
sohfd2:	flddb. .cmtok,,token(<^>),<to specify an ASCII control character, type a>,,
	retsec			;;Back to where-ever we started from
	cleans(<sohfd1,sohfd2>)

.setsp:	saveac <q1,q2,q3,q4>	;[217] Needs registers
	guide <to>		;[18] START-OF-PACKET
	movei t1, sohfdb	;[217] Point to enhanced parse list
	skipe mdone		;[217] Unwinding a macro?
	 movei t1, sohfdm	;[217]  Yes, allow a comma to squeak through

	call rflde		;[217] Try to get one of them
	ifskp.			;[217] Worked!!
	  dmove q2, t2		;[217] Save some of the parse results
	  ldb q1, [pointr (.cmfnp(q3),cm%fnc)] ;[217] Get function code.
	  move q4, q1		;[217] Save original parse
	else.			;[217] Otherwise, failed the parse
	  skipn definf		;[217] In DEFINE?
	   jrst cmderr		;[217] No, then a definite parse error; allow retry
	  ret			;[217] Return into DEFINE and see if that chokes
	endif.			;[217] End handling COMND% returns

	caie q1, .cmcma		;[217] Parsed a comma?
	ifskp.			;[217] We did, so must be unwinding a macro
	  movei q1, .cmcfm	;[217] Turn it into a confirm and carry on
	  move q4, q1		;[217] Stomp it in as a confirm
	endif.

	caie q1, .cmcfm		;[217] A confirm is very special cased
	ifskp.			;[217] It was, so default it
	  movei t1, .chcna	;[217] Replace parse value with SOH (^A)
	  call @parity		;[223] Compute any parity
	  movem t1, pars4	;[217] Save the EOL char we parsed.
	  ret			;[217] Done, nothing left to parse
	endif.			;[217] 

	cain q1, .cmnum		;[217] Number?
	 jrst .seto1		;[217] Yes, this must be checked

	remark q1, .cmtok	;[217] Otherwise, must have been a token
	dmove t1, [ esctkn	;[217] Possible mnemonics
		    cm%xif ]	;[217] Load the no indirection flag
	orm t2, sbk+.cmflg	;[217] And dink the COMND% state block
	call rflde		;[217] Try to get one of them
	ifskp.			;[217] Worked!!
	  ldb q1, [pointr (.cmfnp(t3),cm%fnc)] ;[217] Get function code.
	  dmove q2, t2		;[217] Save parse data and fdb selection
	  remark q4,		;[217] Leave original parse item alone
	  movx t4, cm%xif	;[217] Load indirection flag again
	  andcam t4, sbk+.cmflg	;[217] And restore the COMND% state block
	else.			;[217] Otherwise, failed the parse
	  movx t4, cm%xif	;[217] Load indirection flag again
	  andcam t4, sbk+.cmflg	;[217]     restore the COMND% state block
	  jrst cmderr		;[217] And handle the parse error, allowing reparse
	endif.			;[217] End handling COMND% returns

	caie q1, .cmkey		;[217] Was this relatively easy? 
	ifskp.			;[217] Yep, let's grab and convert the character
	  hrrz t2, (q2)		;[217] Pick up what would be the jump address
	  jrst .seto1		;[217] Make sure a valid choice
	endif.

	remark q1, .cmtok	;[217] A token is somewhat more difficult
	tlz  q3, -1		;[217] Isolate fdb we actually used
	move q2, .cmdat(q3)	;[217] Pick up the byte pointer to the character
	ildb t2, q2		;[217] Load the token character (only one)
	subi t2, "@"		;[217] Bring down to control character range

	came t2, [-21]		;[217] Typed a rubout?
	ifskp.			;[217] Not valid as EOL
	  emsg <May not use rubout as a start of packet line character>	;[217] Whine
	  jrst cmder1		;[217] Allow a retry
	endif.			;[217] Otherwise, no need to check hardwired values

.seto1:	ifl. t2			;[194] A negative ASCII character value is silly
	  emsg <Negative ASCII is illogical> ;[217] So whine about it
	  jrst cmder1		;[217] Allow retry (^H)
	endif.			;[217] 

	caige t2, 200		;[217] Out of ASCII range?
	ifskp.			;[217] Yep, can't handle that, either
	  emsg <ANSI 7 bit ASCII not defined for values over 200 octal> ;[217] Complain
	  jrst cmder1		;[217] Allow retry (^H)
	endif.			;[217] 

	remark			;[217] Otherwise, see if in correct control range
	caile t2, ^o37		;[194] Fix to compare correctly.
	 jrst setspe		;[194]  No, give error message

	move t1, t2		;[223] Load the character
	call @parity		;[223] Put any necessary parity on it
	movem t1, pars4		;[217] All OK, so pass on
	remark			;[217] These two instructions are unnecessary, but...
	cain q4, .cmcfm		;[217] Wanted default?
	 ret			;[217] Yes, don't confirm the confirmation
	skipn definf		;[77] In DEFINE?
	 confrm			;[77]  No, get confirmation.
	ret

setspe:	move t4, t2		;[217] Let's tuck that poor character out of the way
	emsg <">	;"	;[217] Fire up the complaint department
	move t1, t4		;[217] Let's expose the bad character
	call putc		;[217] Print it
	txmsg <" is an invalid start of packet character> ;[217] " Font crock
	jrst cmder1		;[194] and allow command retry.

	subttl session toggling parsing from command line [264]

	%table(toffon)		; Table for parsing ON or OFF.
	%key2 <off>, 0		; Appropriate for off
	%key2 <on>, -1		; Must be sign extended, like SETOM
	%tbend

	chgsec(code,const)	;;FDB's are not in code, they're in const
togfdb:	flddb. .cmcfm,,,<to toggle any current session logging,>,,togfd1
togfd1:	flddb. .cmkey,,toffon,,on
	retsec			;;Back to where-ever we started from

	cleans(<togfd1>)	;[264] 

.toggl:	guide (<session logging>) ;[264] 

	movei t1, togfdb	;[264] Try to find out what they want
	call rfield		;[264] Go parse something
	ldb t3, [pointr (.cmfnp(t3),cm%fnc)] ;[264] Get what it got

	caie t3, .cmcfm		;[264] Just wants to flip it?
	ifskp.			;[264] OK, so flip it
	  setcm t1, sesflg	;[264] Load the complement of session flag
	  movem t1, pars3	;[264] Store it as if a keyword was parsed
	  ret			;[264] Done with this ornerous parse
	endif.			;[264] End simple case of flipping setting

	hrre t2, (t2)		;[264] Interprete the value of the keyword (0 or -1)
	movem t2, pars3		;[264] Save into pars3 for semantic action to grovel
	confrm			;[264] And they should be sure about their choice
	ret			;[264] Done with this ornerous task

	subttl semantic action for TOGGLE [264]

$toggl:	skiple t1, sesjfn	;[264] Load and check the JFN
	ifskp.			;[264] That's no JFN, so nothing to toggle
	  txmsg <%KERMIT-20 was not logging the session, so nothing to toggle
>				;[264] Gently chide them
	  ret			;[264] All done
	endif.			;[264] End case not actually logging
				;[264] Might something there, let's check
	block.			;[264] Enter block context for better control flow
	  cain t1, .priou	;[264] Terminal?
	   retskp		;[264] That works
	  cain t1, .nulio	;[264] Tossing it?
	   retskp		;[264] That works, too
	  GTSTS%		;[264] Let's have a look at it
	   %jserr (<Unable to determine session log JFN status>,r) ;[264] 
	  ifxe. t2, gs%nam	;[264] Some kind of gubbish?
	    ermsg% (<Session log JFN is not bound (valid)>, r) ;[264] 
	  endif.		;[264] Nothing there, actually
	  ifxn. t2, gs%err	;[264] Some kind of error?
	    ermsg% (<Session log JFN may be in error>, r) ;[264] 
	  endif.		;[264] Not safe to use
	  ifxe. t2, gs%opn	;[264] Is it not open?
	    ermsg% (<Session log JFN is not open>, r) ;[264] 
	  endif.		;[264] Must be open, even if not active
	  retskp		;[264] Passed our inspection, so assume OK to use
	endbk.			;[264] End block context
	ifskp.			;[264] Skip means JFN is OK to toggle
	  skipe t1, pars3	;[264] Wants it off?
	   callret rlog		;[264] No, turn it on
	  callret qlog		;[264] Yes, time to shut up
	else.			;[264] Otherwise, some kind of oddity
	  ret			;[264] Already whined, so don't do anything else
	endif.			;[264] Done

	remark			;[264] Never gets here

	subttl Finishing items

	xlist			; Save the trees!!
	 lit			; Dump the literals
	list			; Resume listing

if2  <	purge token  >		;;[217] No need to keep macro in memory
	.endps code		; Close the code .psect

	subttl Module local storage

	.psect data		; Combine in data .psect

pdcodf:: 0			;[221] Packet Decode Flag

	extern definf, undeff	;[203] Must be whacked on EVERY parse

	remark DEFINE handles these

mdone:	0			;[77] Flag for macro execution done.
macrof:	0			;[77] Flag on if executing a SET macro.

extern macptr			;[203] In k20mac
macxp:	0			;[77] Macro execution pointer.

	.endps data		; Close data psect

	.xcmsy			;[194] Ditch any MACSYM junk

	end

; Local Modes:
; Mode:MACRO
; Comment Column:32
; Comment Start:;[277] 
; Comment Begin:;[277] 
; Auto Fill Mode: 0
; End: