.title	KRTSHO	The SHOW command
	.ident	"V03.62"

; /62/	27-Jul-93  Billy Youdelman
;
;	added SHO BAUD, DTR, DUPLEX, END_OF_LINE, FLOW_CONTROL, HOME, LD:,
;	LOCAL_ECHO, LOGFILE, LONG_PACKETS, RANDOM, RECEIVE, SEED, SEND, SPEED
;	cleanup, condense logging (debug) modes display
;	display current_block_number and size_of logfile in SHO DEBUG
;	move SETTLE_TIME to SHO DIAL
;	conform to major sinit stuff update in KRTINI.MAC
;	include last number dialed in SH PHONE
;	add SHOW CL, EOF

; /BBS/	 1-Dec-91  Billy Youdelman  V03.61
;
;	SHOW command with no args displays assigns ala RT-11
;	sho$all - shortened up
;	added sho$attributes
;	added sho$devices - displays the bbs access permission list only
;	added sho$submounts, using TSX emts
;	added sho$vl - displays status of vlswch under TSX+
;	add DEC_Multinational type to sho$file
;	moved release notes to the help text file
;	sho$packet - display "^A" notation in addition to octal numbers
;	also lists long_packets max length, set length, rec'd length
;	add xtime for spiffier transfer time display, other small fixes
;	sho$file - indicate if file name conversion disabled, lower case on
;	added home directory to sho$default
;	fixed display formatting for sho$phone_numbers
;	sho$params indicates if SET LONG OFF or SET NOLONG
;	added MILNET to SHO CONSOLE
;	added c$print
;	moved sho$line to krtcm1
;	added SHO TERMINAL
;	added SHO RETRY, TIME_OUT, made PACKET do parameters, not stats
;	add SHOW INCOMPLETE_FILE_DISPOSITION
;	add SHO MEMORY, display remaining handler free space under RT-11
;	add SHO SL, SHO UPDATE, added LOCAL_ECHO, BREAK to SHO CONSOLE
;	add SHO REPEAT_CHAR, SERVER
;	pass file date/time/prot to COPY output file
;	use DEC method of version numbering for SHO VERSION

;	31-Jan-84  08:28:16  Brian Nelson
;
;	Remove SHOW code from KRTCMD.MAC for placement into an overlay.


	.include "IN:KRTMAC.MAC"
	.iif ndf  KRTINC  .error	<; .include for IN:KRTMAC.MAC failed>
	.include "IN:KRTCDF.MAC"
	.iif ndf  KRTCDF  .error 	<; .include for IN:KRTCDF.MAC failed>

	.mcall	.PURGE			; /62/


	.psect	$code
	.sbttl	SHOW command processor
	.enabl	lsb

c$show::tstb	@argbuf			; /BBS/ any arg there?
	beq	103$			; /BBS/ no, do devs ala RT-11
	upcase	argbuf			; /BBS/ upper case the args
	calls	getcm0	,<argbuf,#sholst> ; look for a valid command
	tst	r0			; find one?
	bmi	110$			; no
	tst	wasnul			; /BBS/ were commands listed via "?"
	bne	199$			; /BBS/ ya
	jsr	pc	,@r1		; dispatch the command
199$:	clr	r0			; /62/
	return

103$:	call	sho$df			; /BBS/ display default disk ala RT-11
	br	199$			; /62/

110$:	cmp	r0	,#cmd$un	; /BBS/ ambiguous?
	bne	189$			; /BBS/ no
	mov	#er$tam	,r0		; /62/ ya, make it ambiguous topic
	br	190$			; /62/
189$:	mov	#er$tun	,r0		; /62/ unrecognizable topic
190$:	direrr	r0			; /62/
	return

	.dsabl	lsb

	$CMGLOB	= 1			; globalize these commands

command	sholst	,ALL		,2	,sho$al
command	sholst	,ASSIGNS	,2	,sho$df
command	sholst	,ATTRIBUTES	,2	,sho$at	; /BBS/ wuz missing..
command	sholst	,BAUD		,2	,sho$li	; /62/
command	sholst	,BINARY_TYPE	,2	,sho$bt
command	sholst	,BLOCK_CHECK_TYPE,2	,sho$bl
command	sholst	,CL:		,2	,sho$cl	; /62/
command	sholst	,CONSOLE	,2	,sho$co
command	sholst	,DATE		,2	,sho$da
command	sholst	,DEBUG		,3	,sho$de
command	sholst	,DEFAULT	,3	,sho$df
command	sholst	,DELAY		,3	,sho$dl
;comman	sholst	,DEVICES	,3	,sho$dv	; /BBS/ devlst only!!
command	sholst	,DIAL		,2	,sho$dp
command	sholst	,DTR		,2	,sho$li	; /62/
command	sholst	,DUPLEX		,2	,sho$co	; /62/
command	sholst	,END_OF_LINE	,2	,sho$pa	; /62/
command	sholst	,EOF		,2	,sho$eo	; /62/
command	sholst	,ESCAPE		,2	,sho$es
command	sholst	,FILE_TYPE	,2	,sho$fi
command	sholst	,FLOW_CONTROL	,2	,sho$li	; /62/
command	sholst	,HANDSHAKE	,2	,sho$ha
command	sholst	,HOME		,2	,sho$df	; /62/
command	sholst	,INCOMPLETE_FILE_DISPOSITION ,1 ,sho$in
command	sholst	,LD:		,2	,sho$su	; /62/
command	sholst	,LINE		,2	,sho$li
command	sholst	,LOCAL_ECHO	,3	,sho$co	; /62/
command	sholst	,LOGFILE	,3	,sho$de	; /62/
command	sholst	,LONG_PACKETS	,3	,sho$pk	; /62/
command	sholst	,MEMORY		,2	,sho$me
command	sholst	,MODEM_TYPE	,2	,sho$dp
command	sholst	,PACKETS	,3	,sho$pk
command	sholst	,PARAMETERS	,3	,sho$pa
command	sholst	,PARITY		,3	,sho$pr
command	sholst	,PAUSE		,3	,sho$ps
command	sholst	,PHONE		,2	,sho$ph
command	sholst	,RANDOM		,2	,sho$de	; /62/
command	sholst	,RECEIVE	,3	,sho$pa	; /62/
command	sholst	,REPEAT_QUOTING	,3	,sho$rp
command	sholst	,RETRY		,3	,sho$rt
command	sholst	,SEED		,3	,sho$de	; /62/
command	sholst	,SEND		,3	,sho$pa	; /62/
command	sholst	,SERVER		,3	,sho$sv
command	sholst	,SL		,2	,sho$sl
command	sholst	,SPEED		,2	,sho$li	; /62/
command	sholst	,START_OF_PACKET,2	,sho$so
command	sholst	,SUBMOUNTS	,2	,sho$su
command	sholst	,TERMINAL	,1	,sho$tt
command	sholst	,TIME		,2	,sho$ti
command	sholst	,TIME_OUTS	,5	,sho$to
command	sholst	,TT:		,2	,sho$tt
command	sholst	,UPDATE		,1	,sho$up
command	sholst	,VERSION	,2	,sho$ve
command	sholst	,VLSWCH		,2	,sho$vl
command	sholst


	.sbttl	SHOW ALL		; /BBS/ rearranged..

sho$al:	call	sho$ve			; version
	call	sho$li			; line
	call	sho$tt			; terminal
	tst	tsxsav			; running under TSX?
	beq	1$			; skip sho$vl if not TSX
	call	sho$vl			; vlswch
1$:	call	sho$es			; escape
	call	sho$at			; attributes
	call	sho$bt			; binary_types
	call	sho$de			; debugging
	call	sho$fi			; file
	call	sho$in			; incomplete_file_disposition
	call	sho$bl			; block_check_type
	call	sho$pa			; parameters
	jmp	sho$yy			; /62/ default disk


	.sbttl	SHOW DIAL

sho$dp:	tst	(sp)+			; dump the return address then call
	jmp	xxsdia			; this to load an adjacent overlay..


	.sbttl	SHOW DEBUG		; /62/ major revision
	.enabl	lsb

sho$de:	clr	r0			; index := 0
20$:	tst	200$(r0)		; end of the list yet?
	beq	70$			; yes, go check file name
	wrtall	205$(r0)		; print the header
	bit	200$(r0),trace		; see if a bit is turned on
	beq	30$			; no
	wrtall	#300$			; "ENABLED"  ya, say so then
	br	40$			; next please
30$:	wrtall	#310$			; "disabled"  it's off
40$:	.newline
	tst	(r0)+			; bump to next entry please
	br	20$			; go do it

70$:	wrtall	#260$			; "RANDOM error insertion is:"
	tst	ranerr			; doing random errors?
	bne	71$			; ya
	wrtall	#310$			; no  "disabled"
	br	72$
71$:	wrtall	#300$			; ya "ENABLED"
72$:	wrtall	#270$			; "  SEED = "
	mov	seed	,r0		; get a copy of the seed
	call	L10266			; display it
	wrtall	#280$			; "."<cr><lf>
	bit	#log$op	,trace		; is a file open?
	beq	73$			; no
	wrtall	#320$			; "Logfile is "
	wrtall	#logfil			; include file name
	wrtall	#330$			; ", cur/max blk: "
	mov	#lun.lo	,r1		; logfile lun
	asl	r1			; word indexing
	mov	blknum(r1),r0		; recover current block number
	call	L10266			; dump it to TT
	wrtall	#340$			; "/"
	mov	sizof(r1),r0		; recover file size
	call	L10266			; dump that to TT too
	br	79$			; 
73$:	wrtall	#350$			; "No LOGFILE is open"
79$:	.newline
100$:	return

	.save
	.psect	$pdata
200$:	.word	log$co	,log$pa	,log$io	,log$rp	,log$de	,0
205$:	.word	210$	,220$	,230$	,240$	,250$
210$:	.asciz	"CONNECT session logging:"
220$:	.asciz	"PACKET exchange logging:"
230$:	.asciz	"RAW  binary I/O logging:"
240$:	.asciz	"RPACK rec packets to TT:"
250$:	.asciz	"TERMINAL  debug display:"
260$:	.asciz	"RANDOM error generation:"
270$:	.asciz	"  SEED = "
280$:	.asciz	"."<cr><lf>
300$:	.asciz	" ENABLED"
310$:	.asciz	" disabled"
320$:	.asciz	"Logfile is "
330$:	.asciz	", cur/max blk: "
340$:	.asciz	"/"
350$:	.asciz	"No LOGFILE is open"
	.even
	.restore

	.dsabl	lsb


	.sbttl	SHOW TIME, SHOW DATE, SHOW DEFAULT, SHOW HOME
	.enabl	lsb			; /62/

sho$ti::calls	asctim	,<#errtxt,#0>	; get time of day into a buffer
	wrtall	#errtxt			; display it
	wrtall	#raslug			; /62/ "  ("
	mov	clkflg	,r0		; /62/ pass line time clock rate
	call	L10266			; /62/ dump it to terminal
	wrtall	#ratag			; /62/ "Hz)"<cr><lf>
	br	1$			; /62/

sho$da::calls	ascdat	,<#errtxt,#-1>	; /62/ get date into a buffer
	wrtall	#errtxt			; display it
	.newline
	br	1$			; /62/

c$pwd::	call	sho$df			; /62/ display default disk
	tst	tsxsav			; /62/ running under TSX?
	beq	1$			; /62/ no, can't do this under RT-11
	call	sho$su			; /62/ show submounts
1$:	clr	r0			; /62/
	return

sho$df::call	sho$xx			; /BBS/ allow separate access
	br	sho$yy			; /62/ to each function alone

sho$xx:	wrtall	#hoslug			; /BBS/ print prefix
	wrtall	#dkname			; then show HOME dir
	.newline
	br	1$			; /62/

c$home::strcpy	#defdir	,#dkname	; /62/ write home device into default
sho$yy::wrtall	#dkslug			; /BBS/ print prefix
	wrtall	#defdir			; then show DK
	.newline
	br	1$			; /62/

	.save
	.psect	$pdata
raslug:	.asciz	"  ("			; /62/
ratag:	.asciz	"Hz)"<cr><lf>		; /62/
hoslug:	.asciz	"HOME--> "		; /BBS/
dkslug:	.asciz	"DK  --> "		; /BBS/
	.even
	.restore

	.dsabl	lsb			; /62/


	.sbttl	SHOW SUBMOUNTS		; /BBS/ all new routine..
	.enabl	lsb

	F.NAM1	=  2		; offset to first word of file name
	F.NAM2	=  4		; second word of file name
	F.TYPE	=  6		; file type
	F.FLAG	= 10		; file flags
	NOTHERE	=  2		; not there bit
	READONLY=  1		; read only bit

sho$su::tst	tsxsav			; running under TSX?
	bne	1$			; ya
	mov	#er$tsx	,r0		; no, can't do this
	br	9$
1$:	cmp	tsxver	,#620.		; does the right emt exist here?
	bhis	3$			; ya
	mov	#er$v62	,r0		; no
9$:	direrr	r0			; say why it can't happen..
	return

3$:	clr	r4			; init # of units counter
	clr	r5			; init anything there counter
10$:	movb	r4	,ld$num		; load unit # into stats emt

	mov	#ld$stat,r0		; load emt arg pointer
	emt	375			; get status of this LD unit

	tst	ld$buf			; anybody home??
	beq	70$			; next

	mov	r4	,r0		; save copy
	add	#'0	,r0		; convert to ascii character
	movb	r0	,<ld$data+2>	; stick into display buffer

;	input:	r2	= buffer for the result
;		r3	= current directory entry pointer

	mov	#ld$name,r2		; pointer to output buffer
	mov	#ld$buf	,r3		; point to .rad50 LD file name
	calls	rdtoa	,<r2,(r3)>	; convert the device name please
	add	#3	,r2		; skip past it
	movb	#':	,(r2)+		; and insert a colon
	calls	rdtoa	,<r2,f.nam1(r3)> ; convert first 3 file name to ascii
	add	#3	,r2		; and skip over those three characters
	calls	rdtoa	,<r2,f.nam2(r3)> ; now get the rest of the file name
	add	#3	,r2		; point to place a dot into the name
	movb	#'.	,(r2)+		; a dot
	calls	rdtoa	,<r2,f.type(r3)> ; get the file type at last
	add	#7	,r2		; bump to the "O" or "W" byte
	bit	#readonly,f.flag(r3)	; read only?
	bne	30$			; ya..
	movb	#'W	,(r2)+		; no, say it's "R/W"
	br	40$
30$:	movb	#'O	,(r2)+		; say it's "R/O"
40$:	bit	#nothere,f.flag(r3)	; able to locate file?
	bne	50$			; nope..
	clrb	(r2)			; ya, so off not avail message
	br	60$
50$:	movb	#space	,(r2)		; put space where null wuz..
60$:	wrtall	#ld$data		; display entry for this LD unit
	.newline
	inc	r5			; flag some LD unit was found
70$:	inc	r4			; bump LD unit number
	cmp	r4	,#7		; done all 8. yet?
	ble	10$			; no
	tst	r5			; ya, was anything found?
	bne	80$			; ya
	message	<No logical disks are mounted>,cr
80$:	return

	.save
	.psect	$rwdata	,rw,d,lcl,rel,con
ld$stat:.byte	4 ,135			; get status of
ld$num:	.byte	0 ,0			; this LD unit
	.word	ld$buf			; and put it here
ld$buf:	.word	0 ,0 ,0 ,0 ,0		; ld$num emt writes data here
ld$data:.ascii	"LD0 --> "
ld$name:.asciz	"DU5:JAYSEN.DSK  R/O  [not available]"
	.even
	.restore

	.dsabl	lsb


	.sbttl	SHOW VERSION
	.enabl	lsb			; /BBS/ slightly enhanced..

sho$ve::wrtall	#100$			; /62/ display name and if for EIS
	tst	imgtyp			; /62/ virtual overlay image running?
	beq	27$			; no
	wrtall	#110$			; /62/ ya, say so
	br	29$
27$:	wrtall	#120$			; /62/ it's the low memory image
29$:	wrtall	#130$			; /62/ tag with "/TSX-Plus  "
	wrtall	#sho.ve			; /62/ release, ver, last edit date
	.newline
	return

	.save
	.psect	$pdata
100$:	.ascii	"Kermit-11 ("		; /62/
	.if df	NONEIS			; /62/ include which
	.ascii	"non"			; /62/ instruction set
	.endc				; /62/ Kermit contains
	.asciz	"EIS) for RT-11"	; /62/
110$:	.asciz	"XB,XM,ZB,ZM"		; /62-3/
120$:	.asciz	"FB,SB,SJ"		; /62-3/
130$:	.asciz	"/TSX-Plus  "		; /62-3/
	.even
	.restore

	.dsabl	lsb


	.sbttl	SHOW FILE_TYPE
	.enabl	lsb			; /62/ cleaned up

sho$fi:	wrtall	#210$			; "FILE_TYPE set to"
	tst	doauto			; is auto mode enabled?
	beq	1$			; no
	mov	#220$	,r0		; ya, "Auto ASCII/Binary"
	br	20$			; go display it
1$:	mov	$image	,r0		; recover current file_type
	asl	r0			; word indexing
	mov	200$(r0),r0		; where it is in data below..
20$:	wrtall	r0			; dump file_type to TT
	.newline
	wrtall	#260$			; "Existing file protection: "
	tst	filprot			; is it on?
	beq	26$			; no
	mov	#270$	,r0		; "ENABLED"
	br	27$
26$:	mov	#300$	,r0		; "disabled"
27$:	wrtall	r0			; say which
	.newline
	wrtall	#310$			; "File naming conversion: "
	tst	rawfil			; is it on?
	beq	28$			; no
	mov	#320$	,r0		; "DISABLED"
	br	29$
28$:	mov	#330$	,r0		; "enabled"
29$:	wrtall	r0			; say which
	.newline
	wrtall	#340$			; "Lower case file naming: "
	tst	locase			; is it on?
	beq	30$			; no
	mov	#270$	,r0		; "ENABLED"
	br	99$
30$:	mov	#300$	,r0		; "disabled"
99$:	wrtall	r0			; say which
	.newline
	wrtall	#350$			; "Volume verification is: "
	tst	rtvol			; is it on?
	beq	130$			; no
	mov	#330$	,r0		; "enabled"
	br	139$
130$:	mov	#320$	,r0		; "DISABLED"
139$:	wrtall	r0			; say which
	.newline
	wrtall	#360$			; /62/ "Local CSI comma parsing:  "
	tst	csi.fake		; /62/ which is it?
	beq	140$			; /62/
	mov	#400$	,r0		; /62/ "EMULATED"
	br	199$			; /62/
140$:	mov	#370$	,r0		; /62/ "real"
199$:	wrtall	r0			; /62/ say which
	.newline
	wrtall	#410$			; "File create_size blocks: "
	mov	en$siz	,r0		; copy of size
	call	L10266			; write integer as ascii on terminal
	.newline
	wrtall	#420$			; /62/ "Init file: "
	wrtall	#ininam			; /62/ and its name
	.newline			; /62/
	return

	.save
	.psect	$pdata
200$:	.word	230$ ,240$ ,250$
210$:	.asciz	"FILE_TYPE set to "
220$:	.asciz	"Auto ASCII/Binary"
230$:	.asciz	"ASCII"
240$:	.asciz	"BINARY (fixed 512, no carriage control)"
250$:	.asciz	"DEC_Multinational (8-bit text)"
260$:	.asciz	"Existing file protection: "
270$:	.asciz	"ENABLED"
300$:	.asciz	"disabled"
310$:	.asciz	"File  naming  conversion: "
320$:	.asciz	"DISABLED"
330$:	.asciz	"enabled"
340$:	.asciz	"Lower case  file  naming: "
350$:	.asciz	"Volume  verification  is: "
360$:	.asciz	"Local comma CSI_Parsing:  "	; /62/
370$:	.asciz	"real"				; /62/
400$:	.asciz	"EMULATED"			; /62/
410$:	.asciz	"File create_size blocks:  "
420$:	.asciz	"Init file: "			; /62/
	.even
	.restore

	.dsabl	lsb


	.sbttl	 SHOW BLOCK_CHECK_TYPE
	.enabl	lsb

sho$bl:	wrtall	#105$			; /62/ "Block_check_type: "
	movb	setchkt	,r0		; /62/ get the checksum type please
	sub	#'1	,r0		; convert to an index for printing
	asl	r0			; word indexing
	wrtall	100$(r0)		; display it
	.newline
	return

	.save
	.psect	$pdata
100$:	.word	110$ ,120$ ,130$
105$:	.asciz	"Block_check_type: "
110$:	.asciz	"1_Byte_Checksum"
120$:	.asciz	"2_Byte_Checksum"
130$:	.asciz	"3_Byte_CRC_CCITT"
	.even
	.restore

	.dsabl	lsb


	.sbttl	SHOW END_OF_FILE	; /62/ all new..
	.enabl	lsb

sho$eof:message	<Take file EOF action: >
	tst	exieof			; is it on?
	bne	1$			; ya
	message	<NO>
1$:	message	<EXIT>,cr
	return

	.dsabl	lsb


	.sbttl	SHOW INCOMPLETE_FILE_DISPOSITION ; /BBS/ all new..
	.enabl	lsb

sho$in:	message	<Incomplete_file_disposition: >
	tst	incfile			; is it on?
	bne	1$			; no
	message	<KEEP>			; ya
	br	3$
1$:	message	<discard>
3$:	.newline
	return

	.dsabl	lsb


	.sbttl	SHOW ESCAPE		; /BBS/ modified..
	.enabl	lsb

sho$es::message	<ESCAPE connect command char  >
	mov	conesc	,-(sp)		; copy escape char to a tiny buffer
	mov	sp	,r0		; point to the tiny buffer
	call	unfmts			; convert to "\000" notation first
	wrtall	r0			; display that
	call	tag.it			; then do the "^\" notation
	tst	(sp)+			; pop the tiny buffer
	return


	.sbttl	SHOW PARAMETERS

sho$pa:	call	sho$pk			; packets
	call	sho$dl			; delay
	call	sho$ps			; pause
	call	sho$to			; time_out
	jmp	sho$rt			; /62/ retries


	.sbttl	SHOW PACKET		; /BBS/ extensively modified

sho$pk:	call	sho$so			; show SOH first
	message	<RECEIVE  conpar+p.eol   EOL  >
	clr	-(sp)			; a one word buffer
	bisb	conpar+p.eol,@sp	; copy receive EOL char
	mov	sp	,r0		; point to buffer
	call	unfmts			; convert to "\000" notation
	wrtall	r0			; display that
	call	tag.it			; then tag with "^M" notation
	clr	(sp)			; init the tiny buffer again
	bisb	senpar+p.eol,@sp	; /62/ copy send EOL char
	message	<SEND     senpar+p.eol   EOL  >	; /62/
	mov	sp	,r0		; point to buffer
	call	unfmts			; convert to "\000" notation
	wrtall	r0			; display it
	call	tag.it			; then tag with "^M" notation
	tst	(sp)+			; pop tiny buffer
	message	<RECEIVE nominal packet  LEN>
	movb	conpar+p.spsiz,r0	; /62/ recover packet length
	decout	r0			; display it
	.newline
	message	<SEND    nominal packet  LEN>
	movb	senpar+p.spsiz,r0	; /62/ recover packet length
	decout	r0			; display it
	.newline
	message	<SEND  set packet limit  LEN> ;/62/
	decout	senlen			; /62/ display SET SEND PACKET length
	.newline
	message	<LONG_PACKETS set locally to>
	tst	dolong			; are long_packets enabled?
	bne	1$			; ya
	message	<   OFF>		; nope..
	br	2$
1$:	decout	reclng			; display locally set long_packet len
2$:	.newline
	message	<LONG_PACKETS _received_ LEN>
	decout	senlng			; received (from other Kermit) length
	.newline
	message	<LONG_PACKETS max avail buff>
	decout	#maxlng			; the maximum possible packet length
	.newline
	return


	.sbttl	SHOW TIME_OUT	; /62/ enhanced..

sho$to:	message	<TIME_OUT  REC  seconds wait>
	decout	rectim				; SET value
	.newline
	message	<TIME_OUT  SEND seconds wait>
	decout	sentim				; SET value
	.newline
	message	<TIME_OUT _received_ seconds>
	movb	conpar+p.time,r0		; RECEIVED (from other Kermit)
	decout	r0				; value
	.newline
	return


	.sbttl	SHOW RETRY

sho$rt:	message	<RETRY initial_connect limit>
	decout	initry
	.newline
	message	<RETRY max for other packets>
	decout	maxtry
	.newline
	return

	.dsabl	lsb


	.sbttl	Display a control char in "^n" notation

tag.it:	message	<  ^>			; /BBS/ added..
	mov	2(sp)	,r0
	movb	lis.ct(r0),r0
	call	writ1char
	.newline
	return

	.save
	.psect	$pdata
lis.ct:	.ascii	"@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]~?"
	.even
	.restore


	.sbttl	STATUS
	.enabl	lsb

c$stat::sub	#120	,sp		; /43/ allocate a buffer please
	wrtall	#300$			; /43/ a header
	clr	r3			; /43/ current item to Dump
	mov	#27.	,r4		; /43/ number items to dump
	mov	sp	,r5		; /BBS/ init buffer pointer
	br	15$			; /BBS/ do totals, even zeros..

10$:	mov	sp	,r5		; /43/ restore buffer pointer
	tst	pcnt.r+2(r3)		; /43/ anything there to dump?
	bne	15$			; /43/ yes
	tst	pcnt.s+2(r3)		; /43/ no, what about sent packets?
	bne	15$			; /BBS/ ya
	mov	totp.s	,r1		; /BBS/ check "prev" totals too
	add	r3	,r1		; point to this type's sent total
	tst	2(r1)			; anything in low word?
	bne	15$			; ya, there's something to do
	mov	totp.r	,r1		; top of the received data table
	add	r3	,r1		; point to this type's rec'd total
	tst	2(r1)			; anything in low word?
	beq	90$			; no, skip the empty individual types
15$:	mov	r5	,r1		; /43/ fill the buffer with spaces
	mov	#110	,r2		; /43/ count for the fill
20$:	movb	#space	,(r1)+		; /43/ stuff a space
	sob	r2	,20$		; /43/ and go back for more
	mov	r3	,r1		; /43/ current type
	beq	30$			; /43/ so skip type field (it's empty)
	asr	r1			; /43/ divide by two
	asr	r1			; /43/ again
	add	#100	,r1		; /43/ get the letter type now
	movb	r1	,(r5)+		; /43/ insert into the buffer
	br	40$			; /43/ insert data now
30$:	movb	#'A&137	,(r5)+		; /62/ the word "ALL" for totals
	movb	#'L&137	,(r5)
	movb	#'L&137	,1(r5)
40$:	add	#5	,r5		; /43/ skip over a couple spaces
	mov	#pcnt.s	,r1		; /43/ sent packet count
	call	200$			; /43/ convert double quantity
	mov	#pcnt.r	,r1		; /43/ received packet count
	call	200$			; /43/ convert double quantity
	mov	totp.s	,r1		; /43/ total sent packet count
	call	200$			; /43/ convert double quantity
	mov	totp.r	,r1		; /43/ total received packet count
	call	200$			; /43/ convert double quantity
	movb	#cr	,(r0)+		; /43/ insert carriage control
	movb	#lf	,(r0)+		; /43/
	clrb	@r0			; /43/ all done, .asciz
	mov	sp	,r0		; /43/ now dump it
	wrtall	r0			; /43/ simple
90$:	add	#4	,r3		; /43/ move up to next entry
	dec	r4			; /BBS/ wuz sob r4 ,10$ (too big now)
	beq	99$
	jmp	10$

99$:	clr	txflag			; /62/ init transfer direction flag
	wrtall	#310$			; /43/ a header, dump character counts
	mov	sp	,r4		; /43/ buffer address
	message	<Bytes >		; /BBS/ prefix
	tst	charout			; /BBS/ anything sent?
	bne	70$			; /BBS/	ya
	tst	charout+2		; /BBS/	check low word
	beq	77$			; /BBS/ nope..
70$:	message	<sent:    >		; /BBS/ ya..
	mov	#charout,r1		; /43/ data characters in
	mov	sp	,txflag		; /BBS/ flag for "Chars per read: "
	br	79$			; /BBS/ print it
77$:	message	<received:>		; /BBS/ format display..
	mov	#charin	,r1		; /43/ point to it
79$:	call	190$			; /43/ and dump

	message	<For data bytes:>	; /BBS/ display this one too..
	tst	txflag			; sending this time?
	bne	83$
	mov	#filein	,r1		; no, use in char count
	br	85$
83$:	mov	#fileout,r1		; ya, use out char count
85$:	call	190$			; display whichever..

	message	<Time to transfer: >	; /BBS/ print a header and then
	call	xtime			; /BBS/ format the transfer time
	call	brate			; /43/ data rates also
	add	#120	,sp		; /43/ pop local buffer
	clr	r0			; /62/ return no error
	return

190$:	clr	r2			; /43/ convert for character counts
	mov	r4	,r0		; /43/ buffer address
	call	$cddmg			; /43/ convert 32-bit integer
	movb	#cr	,(r0)+		; /BBS/ then tag number
	movb	#lf	,(r0)+		; /BBS/ with a CR/LF
	clrb	@r0			; /43/ .asciz
	sub	r4	,r0		; /BBS/ get length
	sub	#15	,r0		; /BBS/ how much to pad?
	neg	r0			; /BBS/ need pos number
	mov	r0	,r2		; /BBS/ copy # of pad chars
	mov	#space	,r0		; /BBS/ a space
193$:	call	writ1ch			; /BBS/ dump it to the screen
	sob	r2	,193$		; /BBS/ pad as needed
	wrtall	r4			; /43/ dump and exit
	return

200$:	add	r3	,r1		; /43/ get address to convert
	clr	r2			; /43/ ensure no leading zeroes
	mov	r5	,r0		; /43/ set buffer address
	call	$cddmg			; /43/ convert
	add	#14	,r5		; /43/ position for next time
	return

xtime:	mov	#conn	,r0		; /BBS/ display xfr time as HH:MM:SS
	movb	#space	,(r0)+		; write spaces
	movb	#space	,(r0)+		; to clear possible
	movb	#space	,(r0)		; leftover hours & colon

	mov	times+4	,r0		; hi word, incremental time from stats
	mov	times+6	,r1		; lo word,		"
	div	#60.	,r0		;; good for up to 18.2 hours
	mov	r1	,C4		; save secs
	mov	r0	,r1		; prep for
	clr	r0			; next divide
	div	#60.	,r0		; get hours and mins
	mov	r1	,C3		; save mins

	mov	r0	,C2		; save copy of hours
	beq	741$			; skip if no hours

	mov	r0	,r1		; where hrs need to be for dec2
	mov	#conn	,r2		; where dec2 will write hours
	call	dec2			; convert hours to ascii
	movb	#':	,conn+2		; colon after hours

	cmpb	#'0	,conn		; iz hours "tens" digit a zero?
	bne	741$			; no
	movb	#space	,conn		; blank leading zero

741$:	mov	C3	,r1		; do mins
	mov	#conn+3	,r2		; put 'em here
	call	dec2			; convert mins to ascii
	tst	C2			; do hours exist?
	bne	750$			; ya, so leave leading zero in mins

	cmpb	#'0	,conn+3		; iz mins "tens" digit a zero?
	bne	750$			; nope..
	movb	#space	,conn+3		; ya, blank leading zero

750$:	mov	C4	,r1		; recover secs
	mov	#conn+6	,r2		; to here
	call	dec2			; convert to ascii

	wrtall	#conn			; done, dump buff to screen
	return

dec2:	clr	r0			; integer in r1 -> two digit ascii
	div	#10.	,r0		; get values of digits
	add	#'0	,r0		; convert ones to ascii
	movb	r0	,(r2)+		; put ascii number in buffer
	add	#'0	,r1		; get tens digit
	movb	r1	,(r2)		; two digits only
	rts	pc

	.save
	.psect	$rwdata	,rw,d,lcl,rel,con ; /BBS/ time stuff added for stats
txflag:	.word	0			; /BBS/ if <>, sending
C2:	.word	0			; hours
C3:	.word	0			; mins
C4:	.word	0			; secs
conn:	.asciz	"     :00"<cr><lf>	; write converted time here
	.even

	.psect	$pdata			; /BBS/
300$:	.ascii	" ----------------- Packet Stats -----------------"<cr><lf>
	.asciz	"Type  Last Sent   Last Rec    Prev Sent   Prev Rec"<cr><lf>
310$:	.asciz	" --- Last Transaction ---"<cr><lf>
	.even
	.restore

	.dsabl	lsb
	.enabl	lsb

brate:	mov	charout+2,r1		; /43/ compute effective baud rate
	mov	charout+0,r0		; /43/ for the last transaction
	add	charin+2,r1		; /43/ don't care which way it was
	adc	r0			; /43/ overflow?
	add	charin	,r0		; /43/ done
	div	times+6	,r0		; /43/ at last (forget the 16 high)
	ble	100$			; /BBS/ nothing to display
	message	<Physical data rate: >	; /BBS/ a header
	decout	r0			; /43/ dump the data
	message	< chars/second>,cr	; /43/
	mov	fileout+2,r1		; /43/ compute effective baud rate
	mov	fileout+0,r0		; /43/ for the last transaction
	add	filein+2,r1		; /43/ don't care which way it was
	adc	r0			; /43/ overflow?
	add	filein	,r0		; /43/ done
	div	times+6,r0		; /43/ at last (forget the 16 high)
	message	<File transfer rate: >	; /BBS/ a header
	decout	r0			; /43/ dump the data
	message	< chars/second>,cr	; /43/
	tst	txflag			; /BBS/ reading this time?
	beq	100$			; /BBS/ nope
	mov	rdrate+2,r1		; /56/ ya, low word of chars read
	mov	rdrate+0,r0		; /56/ high word of chars read
	div	rdrate+4,r0		; /56/ divided by number of reads done
	ble	100$			; /BBS/ nothing to display
	message	<Chars per read:     >	; /BBS/ format display
	decout	r0			; /56/ write number to TT
	.newline			; /56/
100$:	return

	.dsabl	lsb


	.sbttl	SHOW DELAY, SHOW PAUSE

sho$ps:	message	<PAUSE secs before send_pack>
	decout	pauset			; write decimal value to TT
	.newline
	return

sho$dl:	message	<DELAY secs before send_init>
	decout	sendly			; write decimal value to TT
	.newline
	return


	.sbttl	SHOW HANDSHAKE		; /BBS/ cleaned up
	.enabl	lsb

sho$ha:	movb	handch	,r0		; recover handshake character
	bne	1$			; got it
	message	<No handshaking in use>	; nothing there
	br	100$
1$:	message	<Handshake set to >
	cmp	r0	,#space		; /62/ is it some control char?
	bge	30$			; /62/ no
	message	< ^>			; /62/ ya
	movb	lis.ct(r0),r0		; /62/ make it displayable
30$:	call	writ1char		; dump the handshake char now
100$:	.newline
	return

	.dsabl	lsb


	.sbttl	SHOW PARITY

sho$pr:	message	<S/W Parity is set >
	mov	parity	,r0		; recover parity
	asl	r0			; word indexing for list below
	wrtall	parlst(r0)		; display what it is
	.newline
	return

	.save
	.psect	$pdata
parlst:	.word	5$ ,10$ ,20$ ,30$ ,40$
5$:	.asciz	"NONE"
10$:	.asciz	"ODD"
20$:	.asciz	"EVEN"
30$:	.asciz	"MARK"
40$:	.asciz	"SPACE"
	.even
	.restore


	.sbttl	SHOW TERMINAL, SHOW CONSOLE, SHOW ATTRIBUTES
	.enabl	lsb			; /BBS/ modified somewhat..

sho$tt:	mov	vttype	,r0		; recover terminal type
	message	<Terminal is set >
	asl	r0			; word indexing
	wrtall	ttlst(r0)		; display it
	message	<, >
	tst	infomsg			; check SET TT [NO]QUIET status
	beq	10$			; it's QUIET
	message	<NO>			; it's NOQUIET
10$:	message	<QUIET, >
	call	sho$sl			; show SL editor status

sho$co:	message	<Console is set >
	tst	con8bit			; is 8-bit mode enabled?
	bne	30$
	message	<7>			; no
	br	33$
30$:	message	<8>			; ya
33$:	message	<-bit, >
	tst	duplex			; what is DUPLEX doing?
	bne	35$			; it's HALF
	message	<Full>			; it's FULL
	br	36$
35$:	message	<HALF>
36$:	message	< Duplex, MILNET XON is >
	tst	milnet			; and the MILNET mode?
	bne	37$
	message	<off>			; not on
	br	38$
37$:	message	<ENABLED>		; on
38$:	message	<, BREAK is >
	cmp	break+2	,#18.		; check break length
	bgt	381$			; it's long
	message	<short>
	br	40$
381$:	message	<LONG>
	br	40$

sho$at:	message	<Attribute packet transmission is >
	tst	doattr			; are attributes on?
	bne	39$			; ya..
	message	<DISABLED>
	br	40$
39$:	message	<ENABLED>
40$:	.newline
	return

	.save
	.psect	$pdata
ttlst:	.word	1$ ,2$ ,3$ ,4$
1$:	.asciz	"NOSCOPE"
2$:	.asciz	"TTY"
3$:	.asciz	"VT100"
4$:	.asciz	"VT200"
	.even
	.restore

	.dsabl	lsb


	.sbttl	SHOW CL:		; /62/ all new
	.enabl	lsb

sho$cl:	tst	tsxsav			; running under TSX?
	bne	1$			; ya
	direrr	#er$tsx			; no, can't do this
	br	99$
1$:	wrtall	#110$			; "CL PORTS: "
	tstb	ports
	bne	3$
	wrtall	#130$			; nothing SET
	br	5$
3$:	wrtall	#ports
5$:	.newline
	wrtall	#120$			; "CL UNITS: "
	tstb	units
	bne	7$
	wrtall	#130$			; nothing SET
	br	9$
7$:	wrtall	#units
9$:	.newline
99$:	return

	.save
	.psect	$pdata
110$:	.asciz	"CL PORTS: "
120$:	.asciz	"CL UNITS: "
130$:	.asciz	"Nothing SET"
	.even
	.restore

	.dsabl	lsb


	.sbttl	SHOW START_OF_PACKET

sho$so:	message	<RECEIVE start of packet SOH  >
	mov	recsop	,-(sp)		; recover SOH char to a tiny buffer
	bic	#^c177	,@sp		; hose parity
	mov	sp	,r0		; point to where it is on stack
	call	unfmts			; convert to "\000" format
	wrtall	r0			; display that
	call	tag.it			; tag with "^A" notation
	message	<SEND    start of packet SOH  >
	mov	sensop	,@sp		; recover SOH char
	bic	#^c177	,@sp		; hose parity
	mov	sp	,r0		; point to where it is on stack
	call	unfmts			; convert to "\000" format
	wrtall	r0			; display that
	call	tag.it			; tag with "^A" notation
	tst	(sp)+			; pop tiny buffer
	return


	.sbttl	SHOW BINARY_TYPE
	.enabl	lsb

	HOWIDE	=	10.		; /62/ how many per line to list..

sho$bt:	message	<BINARY_TYPE file extents: > ; /62/
	mov	bintyp	,r1		; get the address of the list
20$:	mov	#howide	,r2		; /BBS/ list is simply a concatenated
	.newline			; string of file types rather than
30$:	tstb	@r1			; the more general one of a list
	beq	40$			; of pointers
	message	< *>			; format it into *.xyz
	mov	#4	,r3		; looping for 4 bytes
33$:	movb	(r1)+	,r0		; /BBS/ replaces print to a length..
	call	writ1char
	sob	r3	,33$
	sob	r2	,30$		; and print the next one
	br	20$			; insert a newline
40$:	cmp	#howide	,r2		; /BBS/ already done a new line?
	beq	100$			; /BBS/ ya, so why do another?
	.newline
100$:	return

	.dsabl	lsb


;	.sbttl	SHOW DEVICES (allowed through chkdev)
;	.enabl	lsb

;sho$dv:message	<Accessable devices:>
;10$:	mov	#devlst	,r1		; get the address of the list
;20$:	mov	#15.	,r2		; the list is simply a concatenated
;	.newline			; string of file types rather than
;30$:	tstb	@r1			; the more general one of a list
;	beq	40$			; of pointers
;  ;;	cmp	#15.	,r2		; at start of a line?
;  ;;	beq	33$			; ya..
;	movb	#space			; /62/
;	call	writ1char		; /62/
;33$:	mov	#4	,r3		; loop for 4 bytes
;37$:	movb	(r1)+	,r0		; /BBS/ replaces print to a length..
;	call	writ1char
;	sob	r3	,37$
;	sob	r2	,30$		; and print the next one
;	br	20$			; insert a newline
;40$:	cmp	#15.	,r2		; /BBS/ already done a new line?
;	beq	100$			; /BBS/ ya, so why do another?
;	.newline
;100$:	jmp	sho$su			; /62/ then show submounts

;	.dsabl	lsb


	.sbttl	SHOW PHONE		; /BBS/ modified..
	.enabl	lsb

sho$ph:	mov	#pnhead	,r2		; pointer to list of numbers
	tst	(r2)			; /48/ anything there?
	bne	10$			; /48/ yes
	message	<None defined>,cr	; /48/ no
	br	20$			; /48/ exit
10$:	mov	(r2)	,r2		; /48/ get pointer to next
	beq	20$			; /48/ nothing
	mov	r2	,r3		; /48/ copy pointer
	add	#2	,r3		; /48/ point to the text
	clr	r4			; init a flag
17$:	clr	r1			; init a counter

11$:	movb	(r3)+	,r0		; get a byte
	beq	19$			; done
	call	writ1char		; dump byte to TT
	cmpb	r0	,#space		; wuz it a space?
	beq	13$			; ya
	inc	r1			; no, bump char count
	br	11$			; and continue

13$:	tst	r4			; been here before?
	bne	11$			; ya, leave other spaces as is
	mov	sp	,r4		; only use 1st space in string
	sub	#20.	,r1		; ya, compute padding req'd
	neg	r1			; make it a positive value
	ble	17$			; if not, leave it and continue
	movb	#space	,r0		; load a space
12$:	call	writ1char		; then type it out
	sob	r1	,12$		; this many times..
	br	11$			; then on to the next string

19$:	.newline
	br	10$			; /48/ next please
20$:	mov	phnum	,r0		; /62/ address of phone number
	tstb	@r0			; /62/ anything dialed yet?
	beq	30$			; /62/ no
	message	<Last number dialed:  >	; /62/ ya
	wrtall	r0			; /62/ display the phone number
	.newline
30$:	return

	.dsabl	lsb


	.sbttl	SHOW VLSWCH
	.enabl	lsb			; /BBS/ all new..

sho$vl:	tst	tsxsav			; running under TSX?
	bne	1$			; ya
	message	<Not available under RT-11> ; /62/
	br	90$

1$:	message	<VLSWCH (^W,^B) during CONNECT is set >
	tstb	vlflag			; the answer is..
	beq	10$			; 0 = local
	message	<REMOTE>		; <> = remote
	br	90$
10$:	message	<LOCAL>
90$:	.newline
	return

	.dsabl	lsb


	.sbttl	SHOW SL			; /BBS/ added..
	.enabl	lsb

sho$sl::message	<SL status: >
	tst	sl.on			; is it on?
	bne	1$			; ya
	message	<OFF>			; no
	br	2$
1$:	message	<ON>
2$:	mov	#comma	,r0		; a comma
	call	writ1char		; between options
	tst	sl.ked			; is KED mode on?
	bne	3$			; ya
	message	<NO>			; no
3$:	message	<KED>
	.newline
	return

	.dsabl	lsb


	.sbttl	SHOW MEMORY	; /BBS/ all new
	.enabl	lsb

sho$me:	tst	tsxsav			; running under TSX?
	beq	1$			; /62/ no
	message	<TSX-Plus keeps all handlers resident>
	br	9$
1$:	tst	jobsts			; /62/ FRUNed?
	beq	3$			; /62/ no
	message	<RT-11 can't fetch from an FRUNed program> ; /62/ ya, warn
	br	9$
3$:	tst	vbgexe			; /62/ is VBGEXE running this program?
	beq	5$			; /62/ no
	message	<VBGEXE is running this program> ; /62/ ya
	br	9$
5$:	mov	fetptmax,-(sp)		; this is top of memory
	sub	@fetpt	,@sp		; minus top of program + handlers
	mov	(sp)+	,r0		; equals what's left..
	asr	r0			; convert to words
	mov	r0	,r1		; save a copy
	call	L10266			; display it
	message	<. word>
	dec	r1			; was it just one word?
	beq	7$			; ya
	mov	#'s!40	,r0		; no, use this "s" to
	call	writ1char		; make "word" into "words"
7$:	message	< free to load handlers>
9$:	.newline			; /62/
	return

	.dsabl	lsb


	.sbttl	SHOW UPDATE		; /BBS/ added

sho$up:	message	<Packets between display updates: >
	mov	blip	,r0		; the interval in question
	call	L10266			; write it to TT
	.newline
	return


	.sbttl	SHOW SERVER		; /BBS/ added

sho$sv:	message	<Server time_out: >
	mov	serwait	,r0		; the time_out value
	call	L10266			; write it to TT
	message	< seconds>,cr
	return


	.sbttl	SHOW REPEAT_QUOTING	; /BBS/ added
	.enabl	lsb

sho$rp:	message	<Repeated character quoting: >
	tst	setrpt			; is it on?
	bne	10$			; ya..
	message	<DISABLED>
	br	100$
10$:	message	<enabled>
100$:	.newline
	return

	.dsabl	lsb


	.sbttl	The RENAME command	; /BBS/ heavily hacked..
	.enabl	lsb

c$rena::upcase	argbuf			; upper case all args
	call	gettwo			; ensure a "to:" argument is here
	tst	r0			; did it work out ok?
	bne	100$			; no
	upcase	argbuf			; /62/ in case from kybd "To:" prompt
	calls	rename	,<cmdbuf,argbuf> ; do the rename now
	tst	r0			; did it work?
	bne	90$			; no
	tst	infomsg			; SET TT QUIET?
	beq	100$			; ya, skip result message
	wrtall	#srcnam			; no wildcarding
	wrtall	#290$			; simplifies
	wrtall	#filnam			; things
	.newline
	br	100$
90$:	direrr	r0			; handle error
100$:	return

	.save
	.psect	$pdata
290$:	.asciz	" renamed to "
	.even
	.restore

	.dsabl	lsb


	.sbttl	The DELETE command	; /BBS/ heavily hacked..
	.enabl	lsb

c$del::	upcase	argbuf			; upper case the argument
	calls	delete	,<argbuf>	; try to delete the file
	tst	r0			; did it work?
	bne	90$			; no
	tst	infomsg			; SET TT QUIET?
	beq	100$			; ya, skip result message
	wrtall	#srcnam			; no wildcarding
	wrtall	#290$			; simplifies things
	br	100$
90$:	direrr	r0			; handle error
100$:	return

	.save
	.psect	$pdata
290$:	.asciz	" deleted"<cr><lf>
	.even
	.restore

	.dsabl	lsb


	.sbttl	PRINT, COPY commands	; /BBS/ heavily hacked..
	.enabl	lsb			; share some of COPY's code

c$prin::upcase	argbuf			; upper case all args
	strcpy	cmdbuf	,argbuf		; /62/ and put input file name here
	scan	#'.	,cmdbuf		; is there a dot in the name?
	tst	r0
	bne	2$			; ya..
	strcat	cmdbuf	,#typdef	; no, add .LST to it
2$:	strcpy	argbuf	,#200$		; /62/ make LP: the output device
	br	c.print

c$copy::upcase	argbuf			; upper case all args
	call	gettwo			; ensure the "to:" argument is here
	tst	r0			; did it work out ok?
	bne	100$			; nope..
	upcase	argbuf			; /62/ in case from kybd "To:" prompt

c.print:mov	argbuf	,r2		; save a few bytes, use a reg
	mov	rawfil	,-(sp)		; save current setting
	clr	rawfil			; enable namcvt
	calls	namcvt	,<r2,#spare1>	; extract "file.typ"
	tstb	spare1			; anything left?
	bne	19$			; ya, continue
	calls	namcvt	,<cmdbuf,#spare1> ; no, get inp "file.typ"
	strcat	r2	,#spare1	; concat in_file_name to out_dev
19$:	mov	(sp)+	,rawfil		; back to where it wuz..
	calls	fparse	,<cmdbuf,#srcnam> ; /62/ get attrs here as lookup is
	clr	index			; /62/ in another overlay  init index
	calls   lookup  ,<#srcnam,#spare1> ; /62/ load input file attributes
	.purge	#lun.sr			; /62/ dump lookup channel
	calls	copy	,<cmdbuf,r2>	; do the copy now
	tst	r0			; did it work?
	bne	40$			; no
	tst	infomsg			; SET TT QUIET?
	beq	100$			; ya, skip result message
	mov	r1	,r0		; print the
	call	L10266			; block count
	wrtall	#210$			; and a header
	dec	r1			; how many blocks were moved?
	beq	30$			; had to be just one, skip "s"
	mov	#'s!40	,r0		; not 1, so make it plural
	call	writ1char		; by sticking in an "s" here..
30$:	wrtall	#220$			; then do the next part of log
	wrtall	#filnam			; /62/ message and where it went
	.newline
	clr	r0			; /62/ no error
	br	100$
40$:	direrr	r0			; handle error
100$:	return

	.save
	.psect	$pdata
200$:	.asciz	"LP:"			; where PRINT sends a file
210$:	.asciz	" block"
220$:	.asciz	" copied to "
typdef:	.asciz	".LST"			; default extent for type, print
	.even
	.restore

	.dsabl	lsb


	.sbttl	Get second argument for a command
	.enabl	lsb

;	input:	argbuf	= command args
;	output:	cmdbuf	= first arg
;		argbuf	= second arg
;		 r0	= if <>, error code

	CVTARG	= C.CRLF ! C.LSPA ! C.SSPA ! C.TSPA ; /62/ don't upper case

gettwo::save	<r1,r2>
	mov	argbuf	,r2		; point to the argument buffer
	tstb	@r2			; anything there (should be)?
	beq	100$			; no
	dec	r2			; ya, init so following loop runs..
10$:	inc	r2			; next byte
	tstb	@r2			; We have to finish parsing this
	beq	20$			; end of it, prompt for "To:"
	cmpb	@r2	,#space		; find a space yet?
	bne	10$			; no
	clrb	(r2)+			; yes, make it .asciz
	strcpy	cmdbuf	,argbuf		; /62/ save the first part of the arg
	strcpy	argbuf	,r2		; /62/ return arg number two in argbuf
	br	30$			; got old and new so we are all set

20$:	mov	argbuf	,r2		; where the "to:" arg will be read in
	strcpy	cmdbuf	,r2		; /62/ save old arg as first part
	calls	readcmd	,<r2,#200$>	; /BBS/ use SL editor..
	tst	r0			; did it work?
	bne	100$			; /62/ no
	calls	cvt$$	,<r2,r1,#cvtarg> ; /62/ don't upper case it yet!
	tst	r0			; anything left?
	beq	20$			; no
	add	r2	,r0		; yes, point to end
	clrb	@r0			; and make it .asciz
30$:	clr	r0			; no errors please
100$:	unsave	<r2,r1>
	return

	.save
	.psect	$pdata
200$:	.asciz	"To: "
	.even
	.restore

	.dsabl	lsb

	.end