	.title	k11st1	the SET command,overlay one
	.ident	/2.0.43/

	.include	/IN:K11MAC.MAC/
	.include	/IN:K11CDF.MAC/

	.macro	decout	val
	mov	val	,-(sp)
	call	numout
	.endm	decout

	.enabl	gbl
	.enabl	lc
	.psect	$code

	$cmglob	=	0

;	Copyright (C) 1984  Change Software, Inc.
;
;	31-Jan-84  15:13:45  Brian Nelson
;
;	Removed SET command code from K11CMD.MAC for space saving via
;	placement into an overlay.



	global	<argbuf,argpnt>


	.psect	$code


	.sbttl	things from k11st0 needed in k11st1
	.enabl	lsb



sd$off:	bic	#log$al	,trace		; clear all debug bits now
	bit	#log$op	,trace		; is there a log file open ?
	beq	20$			; no
	calls	close	,<#lun.lo>	; close it
	bic	#log$op	,trace		; say it's closed please
	message	<Debug file closed>,cr
20$:	clr	r0
	return

ttchk:	tstb	ttname			; insure a line is set
	beq	10$			; ok
	clc
	return
10$:	message	<Please use the SET LINE command>,cr
	sec
	return

	.dsabl	lsb


	.sbttl	set block-check-type



set$bl::calls	getcm0	,<argpnt,#blklst>; find out which option was given
	tst	r0			; did we find one
	bmi	110$			; no
	jsr	pc	,@r1		; dispatch now
	clr	r0			; no errors
110$:	return



	$cmglob	=	0

	command	blklst	,1_CHARACTER_CHECKSUM	,1	,sbl$1
	command	blklst	,2_CHARACTER_CHECKSUM	,1	,sbl$2
	command	blklst	,3_CHARACTER_CRC_CCITT	,1	,sbl$3
	command	blklst	,1-CHARACTER-CHECKSUM	,1	,sbl$1
	command	blklst	,2-CHARACTER-CHECKSUM	,1	,sbl$2
	command	blklst	,3-CHARACTER-CRC-CCITT	,1	,sbl$3
	command	blklst	,ONE_CHARACTER_CHECKSUM	,3	,sbl$1
	command	blklst	,TWO_CHARACTER_CHECKSUM	,3	,sbl$2
	command	blklst	,THREE_CHARACTER_CRC_CCITT,3	,sbl$3
	command	blklst	,ONE-CHARACTER-CHECKSUM	,3	,sbl$1
	command	blklst	,TWO-CHARACTER-CHECKSUM	,3	,sbl$2
	command	blklst	,THREE-CHARACTER-CRC-CCITT,3	,sbl$3
	command	blklst



sbl$1:	movb	#'1	,setrec+p.chkt
	movb	#'1	,setsen+p.chkt
	return


sbl$2:	movb	#'2	,setrec+p.chkt
	movb	#'2	,setsen+p.chkt
	return


sbl$3:	movb	#'3	,setrec+p.chkt
	movb	#'3	,setsen+p.chkt
	return

	global	<argbuf	,conpar	,setrec	,setsen	,senpar>






	.sbttl	set dtr and hangup line


set$dt::call	ttchk			; must have already done a SET LINE
	bcs	100$			; oops
	calls	ttydtr	,<#ttname>	; try to raise DTR on the line
	tst	r0			; did it work ?
	beq	100$			; yes
	direrr	r0			; no, emit a message as to why
100$:	clr	r0			; and exit
	return



c$disc::
c$hang::$name	<HAN>
set$hu::call	ttchk			; must have already done a SET LINE
	bcs	100$			; oops
	calls	ttyhang	,<#ttname>	; try to hang up the line
	tst	r0			; did it work ?
	beq	100$			; yes
	direrr	r0			; no, emit a message as to why
	clr	r0
	return
100$:	message	<KERMIT link >
	print	#ttname
	message	< disconnected>,cr
	return

	global	<ttname>




	.sbttl	set filetype


set$fi::calls	getcm0	,<argpnt,#setfil>
	tst	r0			; did we find a keyword ?
	bmi	100$			; no
	jsr	pc	,@r1		; yes, dispatch on it please
100$:	return



sf$typ:	mov	argpnt	,r0		; this is a KLUDGE, ignore 'TYPE'
10$:	tstb	@r0			; find EOS as of yet ?
	beq	90$			; yes, exit with an error
	cmpb	(r0)+	,#40		; found a delimiter yet ?
	bne	10$			; no, keep looking
	calls	getcm0	,<r0,#setfil>	; yes, recheck the table for type
	tst	r0			; did it work ?
	bmi	90$			; no
	jsr	pc	,@r1		; yes, dispatch on it please
	clr	r0			; no errors
	br	100$			; exit
90$:	mov	#-1	,r0		; error
100$:	return



sf$asc:	mov	#text	,$image		; imagemode := false
	message	<Ascii text mode set>,cr; confirm it
	clr	r0			; no errors
	return				; bye



sf$bin:	call	xbin
	mov	#binary	,$image		; imagemode := true
	message	<Binary mode set>,cr	; confirm it
	clr	r0			; no errors
	return				; bye



sf$dec:	call	xbin			; SF$DEC added /52/
	MESSAGE	<DEC_Multinational mode set>,CR
	mov	#DECNAT	,$image
	clr	r0			; No errors
	return				; Exit

sf$aut:	mov	sp	,doauto		; allow checking of file type and
	clr	r0			; attributes to see if the file should
	return				; be sent as a binary file

sf$noa:	clr	doauto			; never check the file out
	clr	r0			; no errors
	return


sf$sup:	clr	filprot			; supercede created files
	clr	r0
	return

sf$nos:	mov	sp	,filprot	; do not supercede files
	clr	r0
	return

	.enabl	lsb

xbin:	tstb	parity
	beq	100$
	cmpb	parity	,#par$no	; has it been set to none ?
	beq	100$			; yes
	message	<The other Kermit must be able to support 8 bit prefixing>,cr
	message	<Without this feature, the high bit will be lost on every>,cr
	message	<character sent>,cr
	message
100$:	return

	.dsabl	lsb


	command	setfil	,SUPERCEDE	,2	,sf$sup
	command	setfil	,NOPROTECT	,3	,sf$sup
	command	setfil	,NOSUPERCEDE	,3	,sf$nos
	command	setfil	,PROTECT	,2	,sf$nos

	command	setfil	,7_BIT		,1	,sf$asc
	command	setfil	,7-BIT		,1	,sf$asc
	command	setfil	,8_BIT		,1	,sf$bin
	command	setfil	,8-BIT		,1	,sf$bin
	command	setfil	,ASCII		,2	,sf$asc
	command	setfil	,BINARY		,2	,sf$bin
	command	setfil	,EIGHT		,2	,sf$bin
	command	setfil	,SEVEN		,2	,sf$asc
	command	setfil	,EIGHT_BIT	,2	,sf$bin
	command	setfil	,SEVEN_BIT	,2	,sf$asc
	command	setfil	,EIGHT-BIT	,2	,sf$bin
	command	setfil	,SEVEN-BIT	,2	,sf$asc
	command	setfil	,FIXED		,2	,sf$bin
	command	setfil	,IMAGE		,2	,sf$bin
	command	setfil	,AUTO		,3	,sf$aut
	command	setfil	,NOAUTO		,3	,sf$noa
	command	setfil	,TYPE		,3	,sf$typ
	command	setfil	,TEXT		,2	,sf$asc
	command	setfil	,TXT		,2	,sf$asc
	command	setfil	,DEC_MULTINATIONAL,2	,sf$dec

;	The following two added /54/ 09-Sep-86  14:48:42 to resolve
;	problems accessing decnet files. 

	command	setfil	,NAMES		,2	,sf$nam
	command	setfil	,NAMING		,2	,sf$nam
	command	setfil


	.ASSUME	TEXT	EQ	0
	.ASSUME	BINARY	EQ	1
	.ASSUME	DECNAT	EQ	2

	global	<argbuf	,$image>



	.sbttl	SET FILE NAM option	; Added /54/ 09-Sep-86  14:46:48


sf$nam:	mov	argpnt	,r0		; /54/ Get current pointer
10$:	tstb	@r0			; /54/ Find EOS as of yet ?
	beq	90$			; /54/ Yes, exit with an error
	cmpb	(r0)+	,#40		; /54/ Found a delimiter yet ?
	bne	10$			; /54/ No, keep looking
	calls	getcm0	,<r0,#sfname>	; /54/ Yes, recheck the table for type
	tst	r0			; /54/ Did it work ?
	bmi	90$			; /54/ No
	jsr	pc	,@r1		; /54/ Yes, dispatch on it please
	clr	r0			; /54/ No errors
	br	100$			; /54/ Exit
90$:	mov	#-1	,r0		; /54/ Error
100$:	return


sfn$tr:	clr	rawfil			; /54/ The default, always convert
	return				; /54/ Exit

sfn$fu:	mov	sp	,rawfil		; /54/ Don't remove extra stuff, like
	return				; /54/ node names and so on.

	command	sfname	,CONVERTED	,1	,sfn$tr
	command	sfname	,FULL		,1	,sfn$fu
	command	sfname	,LITERAL	,1	,sfn$fu
	command	sfname	,TRANSLATED	,1	,sfn$tr
	command	sfname

	GLOBAL	<rawfil>		; End /54/ edits



	.sbttl	set BINARY-TYPE .ext
	.enabl	lsb


set$bi::save	<r1,r2,r3>		; save work registers please
	sub	#100	,sp		; allocate some work space
	mov	sp	,r3		; and a pointer to it please
	clrb	@r3			; insure .asciz
	mov	argpnt	,r2		; get the argbuf pointer now
	cmpb	@r2	,#'.		; is there a leading dot ?
	beq	10$			; yes
	movb	#'.	,(r3)+		; no, insert one please
	clrb	@r3			; asciz please
10$:	strcat	r3	,r2		; concat the filetype now
	mov	sp	,r3		; point back to the buffer
	strlen	r3			; get the length
	cmp	r0	,#4		; it must be exactly 4 chars
	beq	20$			; ok
	message	<The filetype must be of the form .xyz>,cr
	message	<as in: SET BIN .SAV  or  SET BIN .TSK>,cr
	br	90$			; error exit
20$:	tst	binset			; have we been here before
	bne	30$			; yes
	message	<The default binary filetype list has been deleted>,cr
	mov	bintyp	,r1
	clrb	@r1			; insure that it's been done
	mov	sp	,binset		; flag we have been here before
30$:	strcat	bintyp	,r3		; concat the new one onto the list
	clr	r0			; exit with success
	br	100$			; exit

90$:	mov	#-1	,r0		; failure
100$:	add	#100	,sp		; pop local buffer and then ....
	unsave	<r3,r2,r1>		; pop registers
	return				; bye


	.dsabl	lsb




	.sbttl	more set routines

;	SET$DF	set a default filename string for all file opens
;	and creates.



	.enabl	lsb

set$df::copyz	argpnt	,#defdir,#filsiz; setup a default directory
	calls	fparse	,<#200$,#filnam>; try to parse it to see if
	tst	r0			; if the string is valid
	beq	10$			; ok
	message	<Error from $PARSE - >	;
	direrr	r0			; no, print the error out
	clrb	defdir
	br	100$

10$:	message	<Directory for files set to >
	print	#defdir
	message
100$:	clr	r0
	return

	.save
	.psect	$PDATA	,D
200$:	.asciz	/JUNK.DAT/
	.even
	.restore

	global	<filsiz>

	.dsabl	lsb


set$ho::clrb	defdir
	message	<Directory set back to none (SY:)>,cr
	clr	r0
	return


;	S E T $ L O
;
;	SET LOGFILE filespec
;
;	set and create the logfile
	
	.enabl	lsb

c$logf::
set$lo::call	sd$off			; insure previous file is closed
	tst	logapp			; /41/ Append log files?
	bne	10$			; /41/ Yes
	calls	create	,<argpnt,#lun.lo,#text>; handle SET DEBUG FILE filename
	br	20$			; /41/ Check for errors
10$:	calls	append	,<argpnt,#lun.lo,#text>; handle SET DEBUG FILE filename
20$:	tst	r0			; did the logfile create work ?
	beq	30$			; yes
	direrr	r0			; no,print the error out
	return
30$:	bis	#log$op	,trace		; yes, say it's open please
	copyz	argpnt	,#logfil,#30	; save the debug filename for show
	tst	infomsg			; /41/ Verbose today?
	beq	100$			; /41/ No
	message	<Opened Log_file >	; /41/ say we did it
	print	argpnt			; at last, confirm the logfile name
	message				; crlf
100$:	return				; exit

	global	<argbuf	,defdir,logapp>

	.dsabl	lsb






	.sbttl	set send and set receive
	.enabl	lsb

set$wi::message	<Kermit-11 supports the LONG PACKET extension.>,cr
	message	<It does not support SLIDING WINDOWS>,cr
	clr	r0
	return


set$rc::mov	#reclst	,r3
	call	200$
	tst	r0
	beq	10$
	message	<%SET-W Unknown option in SET RECEIVE>,cr
10$:	return

set$sn::mov	#senlst	,r3
	call	200$
	tst	r0
	beq	20$
	message	<%SET-W Unknown option in SET SEND>,cr
20$:	return


200$:	calls	getcm0	,<argpnt,r3>	; find out which option was given
	tst	r0			; did we find the option ?
	bmi	300$			; no
220$:	calls	getcm1	,<argpnt,r3,r0>	; yes, look for value clause now
	tst	r0			; find it (or read it?)
	bmi	300$			; no
	mov	argbuf	,argpnt		; yes. GETCM1 always returns in ARGBUF
	jsr	pc	,@r1		; dispatch to correct action
	br	310$			; and exit
300$:	mov	#1	,r0		; exit on error
310$:	mov	argbuf	,argpnt		; insure argpnt is reset to default
	return				; exit

	.dsabl	lsb

command	reclst	,END-OF-LINE	,3	,set$eo,<EOLN char ? >,string
command	reclst	,PACKET-SIZE	,3	,str$pl,<Packet Length ? >,decnum
command	reclst	,PACKET-LENGTH	,3	,str$pl,<Packet Length ? >,decnum
command	reclst	,PAUSE		,3	,set$ps,<Pause time ? >,decnum
command	reclst	,START-OF-PACKET,3	,str$so,<Octal valule of SOH ? >,octnum
command	reclst	,START_OF_PACKET,3	,str$so,<Octal valule of SOH ? >,octnum
command	reclst	,TIMEOUT	,3	,set$ti,<Packet timeout ? >,decnum
command	reclst

command	senlst	,END-OF-LINE	,3	,set$eo,<EOLN char ? >,string
command	senlst	,PACKET-LENGTH	,3	,sts$pl,<Packet Length ? >,decnum
command	senlst	,PACKET-SIZE	,3	,sts$pl,<Packet Length ? >,decnum
command	senlst	,PAUSE		,3	,set$ps,<Pause time ? >,decnum
command	senlst	,START-OF-PACKET,3	,sts$so,<Octal valule of SOH ? >,octnum
command	senlst	,START_OF_PACKET,3	,sts$so,<Octal valule of SOH ? >,octnum
command	senlst	,TIMEOUT	,3	,set$ti,<Packet timeout ? >,decnum
command	senlst	,XON		,3	,sts$xo
command	senlst	,NOXON		,3	,sts$nx
command	senlst





	.sbttl	set end-of-line octalvalue, set packetlength and set pause

sts$so:	call	setsop
	tst	r0
	bne	100$
	mov	r1	,sensop
100$:	return

str$so:	call	setsop
	tst	r0
	bne	100$
	mov	r1	,recsop
100$:	return

set$so::call	setsop
	tst	r0
	bne	100$
	mov	r1	,recsop
	mov	r1	,sensop
100$:	return

setsop:	calls	octval	,<argpnt>	; get the octal value
	tst	r0			; check for errors
	bne	80$			; exit if so
	tst	r1			; insure in range 1..36
	beq	90$			; no, exit
	cmp	r1	,#36		; ...
	bgt	90$			; ...
80$:	return
90$:	message	<The SOH character must be between 1 and 36 octal>,cr
	mov	#1	,r0
	return


	global	<recsop	,sensop>

sts$xo:	mov	sp	,prexon		; /53/ Prefix packets with XON
	clr	r0			; /53/ Success
	return				; /53/ Exit

sts$nx:	clr	prexon			; /53/ Don't prefix with XON
	clr	r0			; /53/ Success
	return				; /53/ Exit

	GLOBAL	<PREXON>		; /53/ Defined in K11DAT



set$eo::calls	octval	,<argpnt>	; get the octal value now
	tst	r0			; did it work ?
	bne	100$			; no
	movb	r1	,senpar+p.eol	; yes,stuff it in there please
	movb	r1	,setsen+p.eol	; yes,stuff it in there please
	clr	r0
100$:	return				; bye




set$ps::calls	l$val	,<argpnt>	; get the value
	tst	r0			; well ?
	bne	100$			; no, bad value
	mov	r1	,pauset		; ok
100$:	return

set$dl::calls	l$val	,<argpnt>	; get the value
	tst	r0			; well ?
	bne	100$			; no, bad value
	mov	r1	,sendly		; ok
100$:	return



	global	<argbuf	,conpar	,conesc	,pauset	,sendly>









	.sbttl	set rec pac and set sen pac

	.enabl	lsb

str$pl:	strcmp	argpnt	,#ps$max	; /43/ Was it SET REC PAC MAX?
	tst	r0			; /43/ Well?
	bne	5$			; /43/ No
	call	inqbuf			; /43/ Yes, find out what this
	mov	r0	,r1		; /43/ Save it here and then be
	tst	infomsg			; /43/ Being verbose today?
	beq	10$			; /43/ Not really.
	message	<Receive buffer size set to > ; /43/ 
	decout	r1			; /43/ Tell user what we set it to
	message				; /43/ 
	br	10$			; /43/ be off to common code.
5$:	calls	l$val	,<argpnt>	; /43/ Get the user's size
	tst	r0			; /43/ Successful?
	bne	100$			; /43/ No, just exit then
	cmp	r1	,#96.		; /43/ huge packets today?
	bgt	10$			; /43/ Yes
	movb	r1	,setrec+p.spsiz	; /43/ set up it
	movb	r1	,senpar+p.spsiz	; /43/ It actually goes HERE
	clr	reclng			; /43/ Clear this
	br	30$			; /43/ And reset MAXL1 and MAXL2

10$:	call	inqbuf			; /43/ Find out MAX buffer size
	cmp	r0	,#MAXLNG	; /43/ Will this fit internally?
	blos	15$			; /43/ Yes
	mov	#MAXLNG	,r0		; /43/ No, reset it please
15$:	cmp	r1	,#MAXLNG	; /43/ Will this fit within the
	blos	16$			; /43/ Kermit-11 internal buffers?
	mov	#MAXLNG	,r1		; /43/ No, reset to max we allow.
	message	<This size exceeds Kermit-11's internal buffering of >,cr
	decout	r1			; /43/ Inform them and reset it
	message	< bytes. It has been reset to that value>,cr ; /43/ Warning
16$:	cmp	r1	,r0		; /43/ Will the user's size fit?
	blos	20$			; /43/ Yes
	tst	infomsg			; /43/ Really print this message?
	beq	20$			; /43/ No
	message	<This packet size exceeds the host's input buffer size of>,cr
	decout	r0			; /43/
	message	< bytes.  This may cause the line/port driver to loose>,cr
	message	<data at rates greater than 2400 baud.>,cr
20$:	mov	r1	,reclng		; /43/ Setup this parameter
30$:	clr	r0			; /43/ Now setup for divide by 95
	div	#95.	,r0		; /43/ Simple
	movb	r0	,setrec+p.mxl1	; /43/ Insert it into parameters
	movb	r0	,senpar+p.mxl1	; /43/ Insert it into parameters
	movb	r1	,setrec+p.mxl2	; /43/ Insert it into parameters
	movb	r1	,senpar+p.mxl2	; /43/ Insert it into parameters
	clr	r0			; /43/ No errors
100$:	return				; /43/ Exit

	.dsabl	lsb


sts$pl:	call	plc			; /43/ Get the value
	bcs	100$			; /43/ Oops
	movb	r1	,setsen+p.spsiz	; /43/ set up it
	movb	r1	,conpar+p.spsiz	; /43/ It actually goes HERE
100$:	return				; /43/ Exit


	.enabl	lsb

plc:	calls	l$val	,<argpnt>	; set the arguement now
	tst	r0			; did it work ?
	bne	120$			; no
	cmp	r1	,#20.		; minimum of twenty
	blo	110$			; too small
	cmp	r1	,#96.		; /43/ Large ?
	blo	90$			; /43/ No
	br	110$			; /43/
90$:	clr	r0
100$:	return

110$:	message	<The packet size must normally be in the range 20..94>,cr
120$:	sec
	return


	.save
	.psect	$PDATA,d
ps$max:	.asciz	/MAX/
	.even
	.restore
	.dsabl	lsb






	.sbttl	set escape whatever and set retry
	.enabl	lsb


set$es::calls	octval	,<argpnt>	; get the octal value now
	tst	r0			; did it work ?
	bne	100$			; no
	cmpb	r1	,#40		; must be a control character
	blo	10$			; ok
	message	<The escape character must be a control character>,cr
	br	20$			; exit
10$:	mov	r1	,conesc		; store it
20$:	return



set$re::calls	l$val	,<argpnt>	; SET RETRY decimal number
	tst	r0			; well ?
	bne	100$			; no, bad value
	cmp	r1	,#3		; a reasonable minimum ?
	bhis	30$			; ok
	message	<RETRY should be between 3 and 30>,cr
	return
30$:	mov	r1	,maxtry		; ok
40$:	return



set$ti::calls	l$val	,<argpnt>	; SET TIMEOUT decimal number
	tst	r0			; well ?
	bne	100$			; no, bad value
	cmp	r1	,#4		; a reasonable minimum ?
	blo	50$			; ok
	cmp	r1	,#60.		; a reasonable maximum ?
	blos	60$			; yes
50$:	message	<TIMEOUT should be between 4 and 60>,cr
	return
60$:	movb	r1	,conpar+p.time	; alter remotes sinit default
	movb	r1	,setrec+p.time	; show thats it's been set
100$:	return

	global	<argbuf	,conesc	,conpar	,maxtry	,setrec>

	.dsabl	lsb

	.sbttl	set record-format (highly RMS11 dependant)


set$rf::calls	getcm0	,<argpnt,#rfmlst>; find out which option was given
	tst	r0
	bmi	100$
	jsr	pc	,@r1
	clr	r0
100$:	return


srf$st:	clr	df$rat			; stream ascii please for RSTS?
	movb	#fb$stm	,df$rfm		; say so and exit
	return

srf$va:	movb	#fb$cr	,df$rat		; must have this for RSX?
	movb	#fb$var	,df$rfm		; r.var and fd.cr
	return

	global	<df$rat	,df$rfm	,fb$cr	,fb$stm	,fb$var>

	command	rfmlst	,STREAM	 ,3	,srf$st
	command	rfmlst	,VARIABLE,3	,srf$va
	command	rfmlst



	.sbttl	enable or disable attribute packet transmission


set$at::calls	getcm0	,<argpnt,#onoff>; find out which option was given
	tst	r0			; did we find one
	bmi	110$			; no
	jsr	pc	,@r1		; dispatch now
	mov	r0	,sendat		; /42/
	clr	r0			; /42/
110$:	return


set$lp::calls	getcm0	,<argpnt,#onoff>; /42/ find out which option was given
	tst	r0			; /42/ did we find one
	bmi	110$			; /42/ no
	jsr	pc	,@r1		; /42/ dispatch now
	mov	r0	,dolong		; /42/
	clr	r0			; /42/
110$:	return

st$nat::clr	doattr
	clr	r0
	return

st$nlp::clr	dolong
	clr	r0
	return

	cm$glob	=	0

	command	onoff	,OFF	,3	,s$of	; /42/ Change names
	command	onoff	,ON	,2	,s$on	; /42/ Change names
	command	onoff	,NONE	,3	,s$of	; /42/ Change names
	command	onoff				; /42/ Change names


s$of:	clr	r0
	return

s$on:	mov	sp	,r0
	return


	global	<sendat	,dolong>


set$pr::copyz	argpnt	,#prompt,#20.
	clr	r0
	return

	global	<prompt	,argbuf>



	.sbttl	error debugging


set$se::calls	l$val	,<argpnt>	; SET SEED decimal number
	tst	r0			; well ?
	bne	100$			; no, bad value
	mov	r1	,testc		; save it
100$:	return


set$ra::calls	getcm0	,<argpnt,#ranlst>; find out which option was given
	tst	r0			; did we find one
	bmi	110$			; no
	jsr	pc	,@r1		; dispatch now
	mov	r0	,ranerr		; save for the show command
100$:	clr	r0			; exit with no error set
110$:	return




	cm$glob	=	0


	command	ranlst	,OFF	,3	,sra$of
	command	ranlst	,ON	,2	,sra$on
	command	ranlst	,NONE	,3	,sra$of
	command	ranlst


sra$of:	clr	r0
	return

sra$on:	mov	sp	,r0
	return

	global	<ranerr	,testc>




	.sbttl	set repeat on/off or to something (?)



set$rp::calls	getcm0	,<argpnt,#relst>; find out which option was given
	tst	r0			; did we find one
	bmi	110$			; no
	jsr	pc	,@r1		; dispatch now
	mov	r0	,setrpt		; save for the show command
100$:	clr	r0			; exit with no error set
110$:	return


	cm$glob	=	0
	command	relst	,OFF	,3	,rep$of
	command	relst	,ON	,2	,rep$on
	command	relst


rep$of:	clr	r0
	return

rep$on:	mov	#-1	,r0
	return

	global	<setrpt>



	.sbttl	set local terminal type


set$tt::calls	getcm0	,<argpnt,#ttlst>; find out which option was given
	tst	r0			; did we find one
	bmi	110$			; no
	jsr	pc	,@r1		; dispatch now
	mov	r0	,vttype		; save for the show command
100$:	clr	r0			; exit with no error set
110$:	return



	cm$glob	=	0
	command	ttlst	,TTY	,3	,svt$tt
	command	ttlst	,VT100	,3	,svt$vt
	command	ttlst	,VT101	,3	,svt$vt
	command	ttlst	,VT102	,3	,svt$vt
	command	ttlst	,VT200	,3	,svt$22
	command	ttlst	,VT220	,3	,svt$22
	command	ttlst


svt$tt:	clr	r0
	return

svt$vt:	mov	#vt100	,r0
	return

svt$22:	mov	#vt200	,r0
	return


	global	<vttype>



	.sbttl	set various things for the console terminal


set$co::calls	getcm0	,<argpnt,#colst>; find out which option was given
	tst	r0			; did we find one
	bmi	110$			; no
	jsr	pc	,@r1		; dispatch now
100$:	clr	r0			; exit with no error set
110$:	return



	cm$glob	=	0
	command	colst	,8-BIT	,1	,sco$8
	command	colst	,7-BIT	,1	,sco$7
	command	colst	,8BIT	,1	,sco$8
	command	colst	,7BIT	,1	,sco$7
	command	colst	,8_BIT	,1	,sco$8
	command	colst	,7_BIT	,1	,sco$7
	command	colst	,PASSALL,3	,sco$8
	command	colst


sco$7:	clr	con8bit
	return

sco$8:	mov	sp	,con8bit
	return

	global	<con8bit>


numout:	save	<r0,r1,r2>		; /43/ Better formatting
	mov	2+<3*2>(sp),r1		; /43/ Get value please
	mov	r1	,-(sp)		; /43/ Stuff it in
	clr	-(sp)			; /43/ Double conversion
	mov	sp	,r1		; /43/ Address of word to convert
	sub	#20	,sp		; /43/ A buffer to use
	mov	sp	,r0		; /43/ A pointer to it
	clr	r2			; /43/ Leading zero/space suppress
	call	$cddmg			; /43/ Convert
	clrb	@r0			; /43/ .Asciz
	mov	sp	,r1		; /43/ Reset pointer
	print	r1			; /43/ Dump please
	add	#20+4	,sp		; /43/ Pop Junk
	unsave	<r2,r1,r0>		; /43/ Pop registers
	mov	(sp)+	,(sp)		; /43/ Move return address up
	return				; /43/ Exit

	.end
