.TITLE RNCMD
	.IDENT	/M02/
	.IDENT	/M02.1/

;
; COPYRIGHT (C) 1976
; DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS.
;
; THIS SOFTWARE IS FURNISHED UNDER  A LICENSE FOR USE ONLY  ON  A
; SINGLE COMPUTER SYSTEM AND MAY BE  COPIED ONLY WITH  THE INCLU-
; SION OF  THE  ABOVE  COPYRIGHT NOTICE.  THIS SOFTWARE,  OR  ANY
; OTHER COPIES THEREOF, MAY NOT BE  PROVIDED  OR  OTHERWISE  MADE
; AVAILABLE TO ANY OTHER PERSON EXCEPT  FOR  USE  ON  SUCH SYSTEM
; AND TO  ONE WHO AGREES  TO  THESE LICENSE  TERMS.  TITLE TO AND
; OWNERSHIP OF THE SOFTWARE SHALL AT ALL TIMES REMAIN IN DEC.
;
; THE INFORMATION IN THIS SOFTWARE  IS  SUBJECT TO CHANGE WITHOUT
; NOTICE AND SHOULD NOT BE CONSTRUED  AS  A COMMITMENT BY DIGITAL
; EQUIPMENT CORPORATION.
;
; DEC ASSUMES NO RESPONSIBILITY FOR THE USE OR RELIABILITY OF ITS
; SOFTWARE ON EQUIPMENT WHICH IS NOT SUPPLIED BY DEC.
;
; VERSION M02
;
; AUTHOR: L. WADE 1-JUN-72
;
; MODIFIED BY:
;
;	E. POLLACK U. OF W. 19-DEC-73
;
;	D. N. CUTLER 27-JUL-75
;
; RUNOFF COMMANDS
;
; CARTS LUG MODIFICATIONS
;
;	CAR  1 --> ADDED CHANGE BAR COMMANDS, FIXED BUG WITH SKIP AND BLANK
;			WITH NEGATIVE NUMBERS AND, ADDED RELATIVE MARGEN 
;			ADJUSTMENT (+ OR -) CAUSES RELATIVE NORMAL OTHERWISE
;
; CHANGES BY J. CLEMENT		AUGUST 1982
;	ADD  EXTRA FLAGS (SPACE,ACCEPT...)
;	MAKE ALL ENABLE/DISABLE COMMANDS THE SAME LOGIC
;
;
; ALL COMMAND ROUTINES ARE ENTERED WITH:
;
;	R4=ADDRESS OF NUMBER CONVERSION ROUTINE.
;
	.PSECT	$TABL	LCL,D,RO,CON
	.PSECT	$VARS	LCL,D,RW,CON
ESCCNT:	.WORD	0	; TEMPORARY VARIABLE
LITCNT:	.WORD	0
LITADD:	.WORD	0

	.PSECT	$CODE	LCL,I,RO,CON
;
; ENABLE/DISABLE CHANGE BAR COMMADS (ALSO ON AND OFF)	
;
;							
ENCBR::	BICB	#200,$CBRSW	; ENABLE BAR
	MOV	#CBNSP,EBSIZ	; SET UP BAR OFFSET
	RETURN
DSCBR::	BISB	#200,$CBRSW	; DISABLE BAR	
	RETURN
ENBAR::	BISB	#100,$CBRSW	; BAR OFF	
	RETURN						
BGBAR::	BICB	#100,$CBRSW	; BAR OFF
	RETURN
;							
; AUTOPARAGRAPH COMMANDS
;
AUTOP::	MOVB	#-1,$AUTSW	;SET AUTOPARAGRAPH MODE
	RETURN			;
NAUTO::	CLRB	$AUTSW		;CLEAR AUTOPARAGRAPH MODE
	RETURN			;
;
;	AUTOHYPHENATE commands
;
AUHYP::	BICB	#200,$AUHYP	; Set autohyphenate enabled
	RETURN
NAUHYP:: BISB	#200,$AUHYP	; Set autohyphenate disabled
	RETURN

;
;	RESET ESCAPE COMMAND
;
RSESC::	MOV	#ESCBF,R3	; ESCAPE TABLE	
	JMP	CLRBF		; CLEAR IT OUT	

;
;	DEFINE ESCAPE COMMANDS
;
	.ENABL	LSB
DFESC::	MOV	#ESCBF,R3	; ESCAPE BUFFER
	CALL	ENDBF		; START AT END OF BUFFER READY FOR PUT
	MOV	BF.FUL(R3),-(SP) ; CURRENT TABLE SIZE
	CLR	R1
	CALL	PBYT		; null will be count later
	CLR	LITCNT
	CLR	LITADD		; CLEAR POINTERS
	CLR	ESCCNT		; COUNT NUMBER OF CHARS
	CALL	LITNO		; GET INPUT first escape char
	BCS	70$		; ERROR/NO INPUT
	CALL	ESCSAV		; SAVE FLAG CHAR
	CALL	LITNO		; GET CHAR TO COMPARE second escape char
	BCS	70$		; NONE=ERROR
	CALL	ESCSAV		; SAVE CHAR FOR TABLE
	CALL	LITNO		; GET FIRST CHAR IN ESCAPE SEQ
	BCS	70$		; NONE=ERROR
	CALL	ESCSAV		; SAVE CHAR FOR TABLE
20$:	CALL	LITNO		; GET NEXT CHAR	
	BCS	30$		; NO MORE	
	CALL	ESCSAV		; SAVE IT	
	BR	20$		; GET MORE	
30$:	MOV	(SP)+,R1	; point to start of sequence
	MOV	#ESCBF,R3
	CALL	FNDBF		; find this location
	MOV	ESCCNT,R1	; escape count
	CALL	PBYT		; fill it in
	RETURN
ESCSAV:	MOV	#ESCBF,R3	; BUFFER	
	CMP	R1,#377		; too big?
	BHI	60$		; yes
	TSTEQ	R1,60$		; null?
	CALL	PBYT		; PUT CHAR INTO BUFFER
	BCS	60$		; ERROR		
	INC	ESCCNT		; COUNT NUMBER OF CHAR ADDED
	RETURN
60$:	TST	(SP)+
70$:	MOV	(SP)+,R1	; INDEX TO LAST LOCATION
	MOV	#ESCBF,R3
	CALL	RSTBF		; RESTORE TOP OF TABLE
	JMP	ILCM			; ILLEGAL COMMAND
	.DSABL	LSB
LITNO:	TSTNE	LITCNT,10$	; LITERAL ALREADY FOUND?
	CALL	GETLIT		; TRY FIRST TO FIND LITERAL
	BCS	30$		; NONE		
	MOV	R2,LITADD	; ADDRESS OF LITERAL
	MOV	R1,LITCNT	; SIZE		
10$:	MOVB	@LITADD,R1	; GET CHAR	
	INC	LITADD		; POINTS TO NEXT VALUE
	DEC	LITCNT		; DECREMENT # CHAR REMAINING
20$:	CLC			; SUCCESS	
	RETURN			;		
30$:	CALL	RCNO		; TRY FOR NUMBER
	JMP	40$		; NONE		
	MOV	R3,R1		; NUMBER FOUND	
	BR	20$		; RETURN WITH SUCCESS
40$:	SEC			; FAILURE	
	RETURN			;		

;
;	reset substitute
;
RSSUB::	MOV	#BUFADD+2,R2	; first header address is herer
	MOV	#3,R4		; number of headers
10$:	MOV	(R2)+,R3	; Header
	CALL	CLRBF		; clear it
	SOB	R4,10$		; till done
	RETURN
;
;	DEFINE SUBSTITUTE COMMANDS
;
DFMAC::	CLRB	SUBSTK		; reset substitution  stack
	MOV	BUFADD+2,R3	; SUBSTITUTE BUFFER
	CALL	ENDBF		; START AT END OF BUFFER READY FOR PUT
	MOV	BF.FUL(R3),-(SP) ; CURRENT TABLE SIZE
	CLR	R1
	CALL	PBYT		; null will be count later
10$:	CALL	CCIN		; get input data
	CMPEQB	R1,#TAB,10$	; skip tabs
	CMPEQB	R1,#SPC,10$	; skip spaces
	BLT	70$		; no label
	MOV	R1,-(SP)	; save delimiter
	CLR	R4		; counter of name size
20$:	CALL	CCIN		; get next char
	CMP	R1,#SPC		; printable character?
	BLE	60$		; no embedded spaces etc. allowed
	CMPEQ	R1,(SP),30$	; done?
	CALL	PBYT		; save in buffer
	INC	R4		; name size
	BR	20$		; continue till done
30$:	TST	(SP)+		; pop delimiter
	CLR	R1		; null ends the name
	CMP	R4,#10.		; name too big?
	BGT	70$		; yes
40$:	CALL	PBYT		; save 1 char
	CALL	CCIN		; char for macro
	CMPNEB	R1,#CR,40$	; done?
	CLR	R1		; fill in with null
	CALL	PBYT		; into buffer
	MOV	(SP)+,R1	; counter
	MOV	BF.FUL(R3),R2	; current index
	SUB	R1,R2		; total byte count
	DEC	R2
	BITNE	#^C<377>,R2,70$	; only 256 bytes allowed.
	CALL	FNDBF		; find it
	MOV	R2,R1
	CALL	PBYT		; save byte count
	CALL	ENDBF		; go to end of buffer
	MOV	BF.FUL(R3),R2	; end of buffer
	MOV	BUFADD+4,R3	; next stack header
	MOV	R2,BF.MAX(R3)	; fill in max
	MOV	BUFADD+6,R3	; next stack header
	MOV	R2,BF.MAX(R3)	; fill in max
	RETURN
60$:	TST	(SP)+		; pop delimiter
70$:	MOV	(SP)+,R1	; old index
	CALL	RSTBF		; reset to beginning
	JMP	ILCM		; ILLEGAL COMMAND

;
;	ENABLE/DISABLE COMMANDS
;
;		0=ENABLED	NONZERO=DISABLED
;
ENESC::	BICB	#200,$ESCSW	; ENABLE ESCAPE SEQ.
	RETURN
DSESC::	BISB	#200,$ESCSW	; DISABLE ESCAPE SEQ.
	RETURN
ENSUB:: BICB	#200,$SUBSW	; enable substitution
	RETURN
DSSUB:: BISB	#200,$SUBSW	; disable substitution
	RETURN
ENUNL::	BICB	#200,$UNLSW	; ENABLE UNDERLINE SEQ.
	RETURN
DSUNL::	BISB	#200,$UNLSW	; DISABLE UNDERLININE 
	RETURN
ENOVR::	BICB	#200,$OVRSW	; ENABLE OVERSTRIKING
	RETURN
DSOVR::	BISB	#200,$OVRSW	; DISBLE OVERSTRIKING
	RETURN
ENHYP::	BICB	#200,$HYPSW	; ENABLE HYPHENATION
	RETURN
DSHYP::	BISB	#200,$HYPSW	; DISABLE HYPHENATION
	RETURN
ENINX::	BICB	#200,$INXSW	; ENABLE INDEXING
	RETURN
DSINX::	BISB	#200,$INXSW	; DISABLE INDEXING
	RETURN

;
;	ENABLE ALL FLAGS
;
ENAFL:: MOV	#40000,R4	; BITS TO CLEAR
ENAFL1:	MOV	#$AFLSW,R2	; ADDRESS OF FIRST FLAG
	MOV	#NFLAG,R3	; NUMBER OF FLAG WORDS
10$:	CALL	NWFLG		; SET UP TABLE ENTRY
	TST	(R2)+		; NEXT FLAG
	SOB	R3,10$		; CONTINUE TILL DONE
	RETURN
;
; DISABLE ALL FLAGS
;

DSAFL::	MOV	#40000,R4	; BITS TO SET/RESET
DSAFL1:	MOV	#$AFLSW,R2	; ADDRESS OF FIRST FLAG
	MOV	#NFLAG,R3	; NUMBER OF FLAG WORDS
10$:	CALL	KLFLG		; KILL TABLE
	TST	(R2)+
	SOB	R3,10$		; CONTINUE TILL DONE
	RETURN			;
 
;
;	FLAGS ACCEPT COMMANDS (QUOTING CHARACTERS)
;
ENACFL:: MOV	#$AFLSW,R2	; ACCEPT FLAG	
	BR	NEWFLG		; GET AND ENABLE IT
DSACFL::MOV	#$AFLSW,R2	; DISABLE ACCEPT FLAG
	BR	KILFLG
	RETURN			;		
 
;
;	FLAGS SPACE COMMANDS    (QUOTED SPACE)
;
ENQFL::	MOV	#$QFLSW,R2	; QUOTED SPACE FLAG
	BR	NEWFLG		; GET AND ENABLE FLAG
DSQFL::	MOV	#$QFLSW,R2	; DISABLE QUOTED SPACE
	BR	KILFLG
	RETURN					
;
;	FLAGS UNDERLINE COMMANDS
;
ENUFL::	MOV	#$UFLSW,R2	; UNDERLINE FLAG
	BR	NEWFLG		; GET AND ENABLE NEW FLAG
DSUFL::	MOV	#$UFLSW,R2	; DISABLE UNDERLINE FLAG
	BR	KILFLG
	RETURN
;
;	FLAGS INDEX
;
ENIFL::	MOV	#$IFLSW,R2
	BR	NEWFLG		; ENABLE INDEX FLAG
DSIFL::	MOV	#$IFLSW,R2	; DISABLE INDEX FLAG
	BR	KILFLG
;
;	Substitution flag commands
;
ENSBFL:: MOV	#$SBFSW,R2	; substitution flag enable
	BR	NEWFLG
DSSBFL:: MOV	#$SBFSW,R2	; substitutuion flag disable
	BR	KILFLG
;
;	FLAGS OVERSTRIKE COMMANDS
;
ENOFL::	MOV	#$OFLSW,R2	; ADDRESS TO PUT NEW FLAG
NEWFLG:	CALL	KILFLG		; FIRST KILL OLD FLAG
1$:	CALL	CCIN		; GET CHAR	
	CMPEQ	R1,#SPC,1$	; IF SPACE, CONTINUE SEARCH
	CMPEQ	R1,#TAB,1$	; DITTO FOR TAB	
	CMPEQ	R1,#CR,10$	; IF CR, END SEARCH
	CMPEQ	R1,#SEMI,10$	; DITTO FOR SEMICOLON
	CMPEQ	R1,$NFLSW,10$	; IS IT 'CONTROL' CHARACTER
	BITEQB	#CH.FLC,CHTABL(R1),2$ ; NOT LEGIT FOR FLAG??
	BITEQB	#CH.FLG,CHTABL(R1),5$ ; CHAR FREE FOR FLAGGING?
2$:	JMP	ILCM
5$:	MOVB	R1,(R2)		; SAVE NEW FLAG	
	BR	12$		; COMPLETE PROCESS
10$:	CALL	BKSPI		; BACKUP 1 CHAR
12$:	MOV	#100000,R4	; ENABLE FLAG BITS
	MOVB	(R2),R0		; flag character
	BISB	#CH.FLG,CHTABL(R0) ; SET FLAG THIS CHAR
NWFLG:	BIC	R4,(R2)		; CLEAR DISABLE BITS
	TSTNEB	1(R2),10$	; FLAG NOT ENABLED?
	MOVB	(R2),R0		; GET FLAG CHAR
	BEQ	10$		; NONE SO SKIP REST
	MOV	R2,R1		; GET ADDRESS
	SUB	#$AFLSW-GC.AFL,R1 ; FLAG CODE
	MOVB	R1,GCTABL(R0)	; INTO TABLE
10$:	RETURN					
DSOFL::	MOV	#$OFLSW,R2	; DISABLE OVERSTRIKE FLAG
KILFLG: MOV	#100000,R4	; BITS TO SET IN FLAG WORD
	MOVB	(R2),R0		; flag character
	BICB	#CH.FLG,CHTABL(R0) ; SET NO FLAG THIS CHAR
KLFLG:	MOVB	(R2),R0		; GET OLD FLAG
	BEQ	10$		; NONE
	MOVB	#GC.MSC,GCTABL(R0) ; KILL FLAG IN TABLE
10$:	BIS	R4,(R2)		; NOW KILL THE FLAG
	RETURN

;
; FLAG CAPITALIZE COMMANDS
;
DSCFL::	MOV	#$CFLSW,R2	; DISABLE WORD CAPITALIZE
	BR	KILFLG
	RETURN
ENCFL::	MOV	#$CFLSW,R2	; SET UP FOR NEW FLAG
	CALL	UPCAS		; CLEAR CASE CONVERSION VALUE
	BR	NEWFLG		; SET NEW FLAG	
	RETURN 			;
;
;	FLAGS UPPERCASE COMMANDS
;
ENSFL::	MOV	#$SFLSW,R2	; UPPERCASE SHIFT FLAG
	BR	NEWFLG		; GET FLAG AND SET IT ON
DSSFL::	MOV	#$SFLSW,R2	; DISABLE UPPERCASE FLAG
	BR	KILFLG
	RETURN
;
;	FLAGS BREAK
;
ENBRFL:: MOV	#$BRFSW,R2	; enable break flag
	BR	NEWFLG
DSBRFL:: MOV	#$BRFSW,R2	; disable break flag
	BR	KILFLG
;
;	FLAGS LOWERCASE COMMANDS
;
ENLFL::	MOV	#$LFLSW,R2	; LOWER CASE SHIFT FLAG 
	BR	NEWFLG		; GET FLAG AND SET IT 
DSLFL::	MOV	#$LFLSW,R2	; DISABLE LOWERCASE FLAG		
	BR	KILFLG
	RETURN
;
;	FLAGS ESCAPE
;
ENEFL::	MOV	#$EFLSW,R2	; GGET ESCAPE FLAG
	BR	NEWFLG
DSEFL::	MOV	#$EFLSW,R2	; DISABLE ESCAPE FLAG
	BR	KILFLG
;
;	CONTROL FLAG
;
ENNFL::	MOV	#$NFLSW,R2	; CONTROL FLAG
	BR	NEWFLG
DSNFL::	MOV	#$NFLSW,R2	; DISABLE CONTROL FLAG (NO MORE COMMANDS)
	BR	KILFLG		; KILL IT

;
; FLAG HYPHENATE COMMANDS
;

ENHFL::	MOV	#$HFLSW,R2	; HYPHENATE FLAG
	BR	NEWFLG		; GET NEW FLAG AND ENABLE
DSHFL::	MOV	#$HFLSW,R2	; DISABLE HYPHENATION
	BR	KILFLG
	RETURN			;

;
; INDENT COMMAND
;
INDENT::CALL	(R4)		; READ SIGNED DECIMAL NUMBER
	  MOV	PARIND,R3	; NONE. USE CURRENT VALUE
	JMP	INDTST		; Test and store indentation
;
;	underlining commands
;
UNLSP::	MOV	SP,$UNLSP	; set up to underline spaces
	RETURN
UNLNS::	CLR	$UNLSP		; set up no underline spaces
	RETURN

;
; MARGIN SELECTION COMMANDS
;

	.ENABL	LSB
SETTM:: TSTNE	$LOCK,10$	; params locked
	MOV	TMARG,R3	; GET CURRENT TOP MARGIN
	CALL	(R4)		; GET RELATIVE ARGUMENT
	  MOV	PTMRG,R3	; IF NONE, INITIALIZE
	ADD	#5,R3		; DEMAND 5 LINES MIN
	CMP	R3,PNLPG	; MUST BE LESS THAN PAGE LENGTH?
	BGE	10$		; IF GE NO
	SUB	#5,R3		; TAKE DEMANDED LINE OUT
	MOV	R3,TMARG	; OK SAVE AS TOP MARGIN
	RETURN			; 
 
SETLM::	MOV	LMARG,R3	; GET CURRENT LEFT MARGIN
	CALL	(R4)		; GET RELATIVE ARGUMENT
	  MOV	PLMRG,R3	; IF NONE, INITIALIZE
	CMP	R3,RMARG	; MUST BE LESS THAN RIGHT MARGIN?
	BGE	10$		; IF GE NO
	MOV	R3,LMARG	; OK SAVE AS LEFT MARGIN
	RETURN			; 

SETRM::	MOV	RMARG,R3	; GET CURRENT RIGHT MARGIN
	CALL	(R4)		; GET RELATIVE ARGUMENT
	  MOV	PRMRG,R3	; IF NONE, INITIALIZE
	CMP	R3,LMARG	; MUST BE RIGHT OF LEFT MARGIN
	BGT	20$		; IF GT OKAY
10$:	JMP	ILCM		; ILLEGAL COMMAND
20$:	MOV	R3,RMARG	; SAVE IT
	RETURN
;
; STANDARD COMMAND
;

STAND:: TSTNE	$LOCK,10$	; params locked?
	MOV	#SPCNG,NSPNG	; SET STANDARD SPACING
	MOV	#ILMRG,	LMARG	; INITIALIZE LEFT MARGIN
	MOV	#ITMRG, TMARG	; TOP MARGIN	
	MOV	#IRMRG, RMARG	; RIGHT MARGIN	
	MOV	IPARIN,PARIND	; SET INITIAL PARAGRAPH INDENT
	MOV	#INLPG,R3	; SET INITIAL PAGE LENGTH PARAMETER
	BIS	#FILLF!JUSTF!PJUSTF,F.1 ;SET TO FILL AND JUSTIFY
	BR	15$		; FINISH IN COMMON CODE

;
; PAGE SIZE COMMAND
;

SETPG:: TSTNE	$LOCK,10$	; parameters locked?
	MOV	PNLPG,R3	; GET CURRENT PAGE LENGTH
	CALL	(R4)		; GET RELATIVE ARGUMENT
	MOV	PNLPG,R3	; DEFAULT TO CURRENT LENGTH
	CMP	R3,#12		; LONG ENOUGH TO BE REASONABLE	FOR HEADING
	BLE	10$		; IF LE ERROR
15$:	MOV	R3,NLPG		; SAVE AS LENGTH OF THIS PAGE
	MOV	R3,PNLPG	; AND PERMANENT PAGE LENGTH
	CALL	SETRM		; SET RIGHT MARGIN
	MOV	R3,PRMRG	; SET NEW PERMANENT MARGIN
	CALL	SETLM		; GET LEFT MARGIN
	MOV	R3,PLMRG	; SET PERMANENT LEFT
	CALL	SETTM		; GET TOP MARGIN
	MOV	R3,PTMRG	; SET PERMANENT TOP
	RETURN			; 

;
; PARAGRAPH COMMAND
;

SETPR::	CALL	(R4)		; OPTIONAL IDENTING ARGUMENT
	  MOV	PARIND,R3	; NO. USE OLD VALUE
	CMP	R3,RMARG	; REASONABLE VALUE?
	BGT	10$		; IF GT NO
	MOV	R3,PARIND	; STORE PARA INDENT VALUE
	CALL	(R4)		; GET PARAGRAPH SPACING
	  MOV	PARSP,R3	; DEFAULT TO NORMAL SPACING
	CMP	R3,#5		; LEGAL VALUE?
	BHI	10$		; IF HI NO
	MOV	R3,PARSP	; SET NEW PARAGRAPH SPACING
	CALL	(R4)		; GET TEST PAGE COUNT
	  JMP	30$		; IF NONE NO TEST
	CMP	R3,PNLPG	; VALUE WITHIN REASON?
	BHI	10$		; IF HI NO
	MOV	R3,PARPT	; SET NEW PARAGRAPH PAGE TEST COUNT
	RETURN
30$:	CLR	R3		; NO TEST PAGE
	RETURN
PARAG::	CALL	SETPR		; GET PARAMS
	TST	R3		; TEST PAGE VALUE?
	BEQ	35$		; NO PAGE TO TEST
PARTP::	MOV	PARPT,R3	; GET PAGE TEST COUNT
	ADD	PARSP,R3	; And the spacing
	CALL	TESTP		; TEST IF ROOM ON PAGE
35$:	MOV	PARIND,INDCT	; SET INDENTATION
	MOV	PARSP,R1	; GET CURRENT PARAGRAPH SPACING
	JMP	LSTTP
	.DSABL	LSB
LSTTP:	BEQ	40$		; IF EQ NO SPACING
	MOV	NSPNG,R0	; GET LINES PER LINE
	CALL	$MUL		; CALCULATE ACTUAL NUMBER OF LINES TO SKIP
	TSTEQB	$PAGBR,40$	; PAGE ALREADY BROKEN?
	MOV	R1,R2		; SET LINE SKIP COUNT
	CALL	SKIPN		; SKIP LINES
40$:	RETURN			; 

;
; TEST PAGE COMMAND
;

	.ENABL	LSB
TSTPG::	CALL	(R4)		; GET ARGUMENT OF TEST
	  JMP	ILCM		; MUST BE ONE
	CMP	R3,PNLPG	; VALUE WITHIN REASON?
	BHI	10$		; IF HI NO
	JMP	TESTP		; TEST AND OUTPUT PAGE IF NECESSARY
;
; SPACING COMMAND
;

SSP::	CALL	(R4)		; GET ARGUMENT OF SPACING COMMAND
10$:	  JMP	ILCM		; MUST BE ONE
	CMP	R3,#5		; MUST BE IN RANGE 1 TO 5
	BHI	10$
	TSTEQ	R3,10$		; ILLEGAL VALUE?
	MOV	R3,NSPNG	; OK. STORE AS NORMAL SPACING
20$:	RETURN			; 
	.DSABL	LSB

;
; LINE SKIPPING COMMANDS
;

	.ENABL	LSB
SKIPL::	MOV	NSPNG,-(SP)	; SKIP COMMAND. N CURRENT LINES
	BR	10$
LINSKP::MOV	#1,-(SP)	; BLANK COMMAND. N REAL LINES
10$:	CALL	(R4)		; GET OPTIONAL ARGUMENT
	  MOV	#1,R3		; IF NONE, ASSUME 1
	MOV	(SP)+,R0	; RETRIEVE NUMBER OF LINE TO SKIP
	TST	R3		; CHECK IF ARGUMENT IS NEG
	BMI	15$		; IF NEGATIVE DO NOT MAKE TOP OF PAGE CHECK
	TSTEQB	$PAGBR,30$	; AT TOP OF PAGE?
15$:	MOV	R3,R1					
	CALL	$MUL		; MULTIPLY		
	TST	R1		; CHECK IF RESULT IS +	
	BPL	17$		; AND IF SO CONTINUE AS NORMAL
	MOV	R1,R2		; GET THE NUMBER OF LINES FROM END OF PAGE
	ADD	NLPG,R2		; R2 NOW HAS LINE NUMBER THAT WE WANT TO GET TO
	CMP	R2,LINEC	; BUT CHECK IF WE HAVE ALREADY PASSED THAT POINT
	BGT	16$		; IF GT OK		
							
	MOV	#1,R2		; ELSE JUST SKIP 1 LINE	
	BR	20$		; 			
							
16$:	SUB	LINEC,R2	; GENERATE NUMBER OF LINES TO SKIP
	BR	20$					
							
17$:	MOV	R1,R2		; CHECK IF ROOM ON PAGE	
	ADD	LINEC,R1	; ADD CURRENT LINE				; **-5
	CMP	R1,NLPG		; ROOM FOR ANOTHER?
	BLE	20$
	JMP	BPAGE		; NO. MAKE A NEW PAGE
20$:	CALL	SKIPN		; YES. SPACE OUT C(R2) LINES
30$:	RETURN			; 
	.DSABL	LSB

;
; FIGURE COMMAND
;

FIGUR::	CALL	(R4)		; GET ARGUMENT
	  MOV	#1,R3		; IF NONE, ASSUME ONE LINE
	CMP	R3,PNLPG	; CHECK FOR RATIONAL ARGUMENT
	BLOS	10$		; IF LOS OKAY
	JMP	ILCM		; ERROR
10$:	MOV	R3,-(SP)	; SAVE DESIRED SPACE
	CALL	TESTP		; TEST IF PAGE SHOULD BE BROKEN
	MOV	(SP)+,R2	; GET BACK DESIRED SIZE
	JMP	SKIPN		; SPACE THAT OUT

;
; LITERAL COMMAND
;

LITRL::	MOV	F.1,LITSV	; SAVE CURRENT FLAGS WORD
	BIS	#LITFG!SPECF,F.1 ;SET LITERAL FLAG
	MOV	CMADR,LITCM	; SAVE CURRENT EXPECTED COMMAND ADDRESS
	MOV	ELCMD,CMADR	; SET ADDRESS OF EXPECTED COMMAND
	MOV	#400,R4		; DISABLE FLAGS BITS
	CALL	KLFLG		; KILL THEM
	BR	FILOF		; TURN OFF FILL AND JUSTIFY

;
; END LITERAL COMMAND
;

ELTRL::	MOV	LITSV,F.1	; RESTORE PREVIOUS FLAGS WORD
	MOV	LITCM,CMADR	; RESTORE PREVIOUS EXPECTED COMMAND ADDRESS
	MOV	#400,R4		; FLAGS BITS TO CLEAR
	JMP	NWFLG		; ENABLE FLAGS AGAIN

;
; FILL AND JUSTIFY COMMANDS
;

JUSTN::	BIS	#JUSTF+PJUSTF,F.1 ;TURN ON JUSTIFYING
	RETURN			; 
JUSOF::	BIC	#PJUSTF+JUSTF,F.1 ;TURN OFF JUSTIFY BITS
	RETURN			; 
FILLN::	BIS	#FILLF+JUSTF,F.1 ;TURN ON FILLING, COPY PJUSTF TO JUSTF
	BITNE	#PJUSTF,F.1,10$ ;COPY PERMANENT FLAG
	BIC	#JUSTF,F.1	; TO CURRENT ONE.
10$:	RETURN			; 
FILOF::	BIC	#FILLF+JUSTF,F.1 ;TURN OFF FILLING AND JUSTIFYING
	RETURN			;

;
; TAB STOP SELECTION COMMAND
;

SETTAB::CLR	NTABS		;CLEAR NUMBER OF TABS
SETT1:	CALL	(R4)		;GET ANOTHER STOP IF ANY
	NOP			;
	RETURN			;
	INC	NTABS		;POINT TO NEXT ITEM
	MOV	NTABS,R0
	MOVB	R3,TABTAB-1(R0)	;STORE THIS TABSTOP
	CMP	R0,#TABTL-1	;CHECK TABLE SIZE
	BLO	SETT1		;OK.
	JMP	ILCM		;TOO MANY TABS

;
; CENTER COMMAND
;
CENTRT:: BISB	#200,$CENSW	; CENTER LINES TILL END
CENTER:: BISB	#1,$CENSW	; SET UP TO CENTER NEXT LINE
	MOV	RMARG,R3	; RIGHT
	ADD	LMARG,R3	; PLUS LEFT
	CLC
	ASR	R3		; DIVIDED BY 2
	MOV	R3,CMARG	; DEFAULT
	CALL	(R4)		; GET RELATIVE ARG
	  MOV	CMARG,R3	;DEFAULT
	MOV	R3,CMARG	; CENTERING MARGIN
	RETURN
;	END CENTER COMMAND
ECENT::	BICB	#200,$CENSW	; CLEAR CENTERIN SWITCH
	RETURN
;
;	Right justify command
;
RIGHJ::	BISB	#1,$RIGSW	; Set temporary righj justify switch
	CALL	(R4)		; Get shift
	  MOV	#0,R3		; Default
INDTST:	MOV	LMARG,R0	; Compare if legit
	NEG	R0		;
	CMP	R3,R0		; Is it less than left margin
	BLT	10$		; Yes!
	ADD	RMARG,R0	; Space available
	CMP	R3,R0		; too big?
	BGE	10$		; Yes!
	MOV	R3,INDCT	; Save indentation
	RETURN
10$:	JMP	ILCM
;
; FOOTNOTE COMMANDS
;
FOOTN::	MOV	#FOTSV,R0	; FOOTNOTE SAVE BUFFER
	MOV	#SAVBEG,R1	; PARAMS TO SAVE
	MOV	#SAVSZ,R2	; SIZE OF SAVE BUFFER
	MOV	F.1,(R0)+	; FIRST SAVE STATUS
10$:	MOVB	(R1)+,(R0)+	; SAVE EM
	SOB	R2,10$		; TILL DONE
	BIS	#FOTF,F.1	; PUT OUTPUT INTO FOOTNOTE BUFFER
	DECB	$FOTPD		; FOOTNOTE PENDING
	CLR	INDCT		; CLEAR INDENTATION
	JMP	LINSET		; NOW SET UP FOOTNOTE BUFFER
 
FOOTE::	BITNE	#FOTF,F.1,5$	; FOOTNOTE IN PROGRESS?
	JMP	ILCM		; NO!!! CAN'T END IT CAN WE
5$:	CALL	OUTNJ		; BREAK CURRENT LINE
	MOV	#FOTSV,R0	; FOOTNOTE SAVE BUFFER
	MOV	#SAVBEG,R1	; PARAMS TO RESTORE
	MOV	#SAVSZ,R2	; SIZE OF SAVE BUFFER
	MOV	(R0)+,F.1	; FIRST RESTORE STATUS
10$:	MOVB	(R0)+,(R1)+	; RESTORE EM
	SOB	R2,10$		; TILL DONE
	RETURN			;

;
; PERIOD SPACING COMMANDS
;

PERSP::	MOV	SP,$PERSW	;ENABLE TWO SPACES AFTER PUNCTUATION
	RETURN			;
NPERS::	CLR	$PERSW		;DISABLE TWO SPACES AFTER PUNCTUATION
	RETURN			;

	.END