.TITLE RNCMD
	.IDENT	/M02.2/

;
; 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	$TEMP,D,RW,GBL,OVR
TABSV:	.BLKB	TABTL

	.PSECT	$CODE	LCL,I,RO,CON
;
; PERIOD SPACING COMMANDS
;
PERSP::	BISB	#SW.DIS,$PERSW	; ENABLE TWO SPACES AFTER PUNCTUATION
	MOV	#CH.PER,R5	; Bits to set/clear
PERSET:	CALL	GETLIT		; Get literal
	BCS	30$		; None ?
	TSTEQ	R1,30$		; No characters ?
20$:	MOVB	(R2)+,R0	; Get character
	BISB	R5,CHTABL(R0)	; Set the bit
	SOB	R1,20$		; Continue till done
30$:	RETURN			; 
NPERS::	CLRB	$PERSW		; DISABLE TWO SPACES AFTER PUNCTUATION
	MOV	#CH.PER,R5	; Bits to set/clear
PERCLR:	CALL	GETLIT		; Get literal
	BCS	30$		; None ?
	TSTEQ	R1,30$		; No characters ?
20$:	MOVB	(R2)+,R0	; Get character
	BICB	R5,CHTABL(R0)	; Set the bit
	SOB	R1,20$		; Continue till done
30$:	RETURN			; 
	RETURN			; 
;
; ENABLE/DISABLE CHANGE BAR COMMADS (ALSO ON AND OFF)	
;
ENCBR::	BICB	#SW.DIS,$CBRSW	; ENABLE BAR
	CALL	(R4)		; Get first indent
	  MOV	#0,R3		; Default
	CMP	R3,#10.		; Test size
	BHI	20$		; Too big ?
	MOV	R3,EBSIZ1	; First indent
	CALL	(R4)		; Second indent
	  MOV	#CBNSP,R3	; Default second offset
	CMP	R3,#10.		; Test size
	BHI	20$		; Too big ?
	MOV	R3,EBSIZ2
	RETURN
20$:	MOV	#4.,R0		; Param too big or negative
	JMP	ILCMA
DSCBR::	TSTNEB	$CBRSW,10$	; Already disabled ?
	BISB	#SW.DIS,$CBRSW	; DISABLE BAR	
10$:	RETURN
ENBAR::	BISB	#100,$CBRSW	; BAR OFF	
	RETURN						
BGBAR::	BICB	#100,$CBRSW	; BAR OFF
	RETURN
;
;	KEEP COMMANDS
;
KEEPN::	BISB	#SW.DIS,$KEPSW
	RETURN
NKEEP::	BICB	#SW.DIS,$KEPSW
	RETURN
;							
; AUTOPARAGRAPH COMMANDS
;
AUTOP::	MOVB	#-1,$AUTSW	;SET AUTOPARAGRAPH MODE
	RETURN			;
NAUTO::	CLRB	$AUTSW		;CLEAR AUTOPARAGRAPH MODE
	RETURN			;
;
;	AUTOHYPHENATE commands
;
AUHYP::	BICB	#SW.DIS,$AUHYP	; Set autohyphenate enabled
	CALL	RCNR		; Get initial char count
	JMP	10$		; None ?
	MOVB	R3,HYPSV	; Char saved ?
10$:	CALL	RCNR		; Get initial char count
	JMP	20$		; None ?
	MOVB	R3,HYPLO	; Initial char count
20$:	CALL	RCNR		; Get Final char count
	JMP	30$		; None ?
	MOVB	R3,HYPHI	; Final char count
30$:	CALL	RCNR		; Get Option
	JMP	40$		; None ?
	MOVB	R3,HYPOP	; Save hyphenation option
40$:	MOV	HYPLO,R0	; Get lo value
	ADD	HYPHI,R0	; Add on final char count
	NEG	R0		; Make it the negative
	MOV	R0,HYPSZ	; Save as size
	MOV	#CH.PNC,R5	; Set up punctuations
	JMP	PERSET
NAUHYP:: BISB	#SW.DIS,$AUHYP	; Set autohyphenate disabled
	MOV	#CH.PNC,R5	; Set up punctuations
	JMP	PERCLR
ELIPS::	BISB	#SW.DIS,$ELIPS	; Set ellipses flag
	RETURN
NELIP::	CLRB	$ELIPS		; Clear ellipses flag
	RETURN
TABRI::	BISB	#SW.DIS,$TABLF	; Set up for right justify tabs
	RETURN
TABLF::	CLRB	$TABLF		; Left justify tabs
	RETURN

;
;	ENABLE/DISABLE COMMANDS
;
;		0=ENABLED	NONZERO=DISABLED
;
ENESC::	BICB	#SW.DIS,$ESCSW	; ENABLE ESCAPE SEQ.
	RETURN
DSESC::	BISB	#SW.DIS,$ESCSW	; DISABLE ESCAPE SEQ.
	RETURN
ENSUB:: BICB	#SW.DIS,$SUBSW	; enable substitution
	RETURN
DSSUB:: BISB	#SW.DIS,$SUBSW	; disable substitution
	RETURN
ENTAB::	BICB	#SW.DIS,$TABSW	; Enable tabs
	RETURN
DSTAB::	BISB	#SW.DIS,$TABSW	; Disable tabs
	RETURN
ENUNL::	BICB	#SW.DIS,$UNLSW	; ENABLE UNDERLINE SEQ.
	RETURN
DSUNL::	BISB	#SW.DIS,$UNLSW	; DISABLE UNDERLININE 
	RETURN
ENOVR::	BICB	#SW.DIS,$OVRSW	; ENABLE OVERSTRIKING
	RETURN
DSOVR::	BISB	#SW.DIS,$OVRSW	; DISBLE OVERSTRIKING
	RETURN
ENHYP::	BICB	#SW.DIS,$HYPSW	; ENABLE HYPHENATION
	RETURN
DSHYP::	BISB	#SW.DIS,$HYPSW	; DISABLE HYPHENATION
	RETURN
ENINX::	BICB	#SW.DIS,$INXSW	; ENABLE INDEXING
	RETURN
DSINX::	BISB	#SW.DIS,$INXSW	; DISABLE INDEXING
	RETURN
;
; INDENT COMMAND
;
INDENT::TSTEQB	$CENSW,10$	; No Centering ?
	JMP	ERRCON		; Conflicting command
10$:	CALL	(R4)		; READ SIGNED DECIMAL NUMBER
	  MOV	PARIND,R3	; NONE. USE CURRENT VALUE
INDCK:	MOV	LMARG,R0	; Compare if legit
	NEG	R0		; 
	TSTNEB	$RIGSW,10$	; Right margin ?
	CMP	R3,R0
	BLT	ERRLT		; Yes!
10$:	SUB	R3,R0		; Is it less than left margin
	ADD	RMARG,R0	; Space available
	CMP	R0,#MINLN	; Now compare with line minimum
	BLT	ERRGT		; Indent too big ?
	CMP	R0,#255.	; Compare with max char per line
	BHI	ERRLT		; Indent too small
	MOV	R3,INDCT	; Save indentation
	RETURN

;
; MARGIN SELECTION COMMANDS
;
SETTM::	MOV	TMARG,R3	; GET CURRENT TOP MARGIN
	CALL	(R4)		; GET RELATIVE ARGUMENT
	  JMP	10$		; Take default
	CALL	CVSP		; Convert to half spacing
	BR	20$		; Now check it
10$:	MOV	PTMRG,R3
20$:	ADD	#MINPG,R3	; MINPG lines minimum on page
	CMP	R3,PNLPG	; MUST BE LESS THAN PAGE LENGTH?
	BGE	ERRGT		; IF GE NO
	SUB	#MINPG,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
	ADD	#MINLN,R3	; Add on minimum line length
	CMP	R3,RMARG	; MUST BE LESS THAN RIGHT MARGIN?
	BGE	ERRGT		; IF GE NO
	SUB	#MINLN,R3	; Restore
	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
	SUB	#MINLN,R3	; Subtract min line length
	CMP	R3,LMARG	; MUST BE RIGHT OF LEFT MARGIN
	BLT	ERRLT		; IF GT OKAY
	ADD	#MINLN,R3	; Restore
	MOV	R3,RMARG	; SAVE IT
	RETURN
;
; STANDARD COMMAND
;

STAND::	MOV	#ISPNG*LINSP,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*LINSP,R3	; SET INITIAL PAGE LENGTH PARAMETER
	BIS	#FILLF!JUSTF!PJUSTF,F.1 ;SET TO FILL AND JUSTIFY
	BR	SETPG1		; FINISH IN COMMON CODE
;
; PAGE SIZE COMMAND
;
SETPG::	CLRB	$PAGNG		; Enable paging
	MOV	PNLPG,R3	; GET CURRENT PAGE LENGTH
	CALL	(R4)		; GET RELATIVE ARGUMENT
	  JMP	10$		; Take default
	CALL	CVSP		; Convert to half spacing
	CMP	R3,#MINPG	; LONG ENOUGH TO BE REASONABLE	FOR HEADING
	BLE	ERRLT		; Too small ?
	CMP	R3,#377		; Check max size
	BGT	ERRGT		; Too big ?
	BR	SETPG1
10$:	MOV	PNLPG,R3	; Default to current length
SETPG1:	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
	CALL	SSP		; Set permenant spacing
	MOV	R3,PSPNG	; Save permenant spacing
	RETURN			; 
;
;	The error returns
;
ERRGT:	MOV	#1,R0		; Param too big
	BR	ERR
ERRLT:	MOV	#2,R0		; Param too small
	BR	ERR
ERRHI:	MOV	#8.,R0		; Param too big or negative
	BR	ERR
ERRCON:	MOV	#43.,R0
ERR:	JMP	ILCMA		; Output the message
;
;	SET PARAGRAPH COMMAND
;
SETPR::	MOV	#PARIND,R5	; Address of paragraph variables
	CALL	(R4)		; OPTIONAL IDENTING ARGUMENT
	  MOV	PARIND,R3	; NO. USE OLD VALUE
	MOV	RMARG,R1	; Get line size
	SUB	LMARG,R1
	CMP	R3,R1		; REASONABLE VALUE?
	BGT	ERRGT		; IF GT NO
	MOV	R3,(R5)+	; STORE PARA INDENT VALUE
	CALL	10$
	CALL	10$
	CALL	10$
	RETURN
10$:	CALL	(R4)		; GET COUNT
	  MOV	(R5),R3		; Default
	  SEC
	CMP	R3,#MAXPS	; Within reason ??
	BHI	ERRHI
	MOV	R3,(R5)+	; Save the value
	RETURN
;
; SPACING command
;
SSP::	CLR	R3		; No initial value
	CALL	(R4)		; GET ARGUMENT OF SPACING command
	  JMP	10$		; Take default
	CALL	CVSP		; Convert to half spacing
	CMP	R3,#MAXPS*LINSP	; MUST BE IN RANGE 1 to max paragraph spacing
	BGT	ERRGT
	CMP	R3,#LINSP	; Must be at least 1 line
	BLT	ERRLT		; Zero or negative ?
	BR	20$		; Save spacing
10$:	MOV	PSPNG,R3	; Restore permanent spacing
20$:	MOV	R3,NSPNG	; OK. STORE AS NORMAL SPACING
	RETURN			; 
;
;	PARAGRAPH COMMAND
;
PARAG::	CALL	SETPR		; GET PARAMS
	JMP	PARTP		; And do the paragraph

;
;	TEST TEXT command
;
TSTTX::	CALL	10$		; Get top test
	MOV	R1,R5		; Save value
	CALL	10$		; Bottom test
	MOV	R1,R4		; Bottom test
	JMP	PARTS		; Now test the arguments
10$:	CALL	(R4)		; Get argument
	  MOV	#1,R3		; Default if no argument
	MOV	R3,R1		; Number to mul
	CALL	MULSP		; Find actual adjusted line spacing
	RETURN
NOARG:	MOV	#7,R0		; Missing argument
	JMP	ILCMA
;
;	TEST PAGE command
;
TSTPG::	CALL	(R4)		; GET ARGUMENT OF TEST
	  MOV	#1,R3		; Default
	CALL	CVSP		; Convert to half spacing
	MOV	R3,R5		; Save result
	CALL	(R4)		; GET ARGUMENT OF TEST
	  MOV	#1,R3		; Default
	CALL	CVSP		; Convert to half spacing
	MOV	R3,R4
	JMP	PARTS		; Now test the params
;
;	HALF SPACING command
;
NHSPSW:: BISB	#SW.DIS,$HSPSW		; Disable half spacing
	RETURN
HSPSW:: BICB	#SW.DIS,$HSPSW		; Enable half spacing
;
;	SKIP command
;
SKIP::	CALL	(R4)		; GET OPTIONAL ARGUMENT
	  MOV	#1,R3		; IF NONE, ASSUME 1
	MOV	R3,R1		; Set up to multiply lines x line spacing
	CALL	MULSP		; Find actual adjusted line spacing
	MOV	R1,R2
	BR	LINSK1
;
;	BLANK command
;
LINSKP:: CALL	(R4)		; GET OPTIONAL ARGUMENT
	  MOV	#1,R3		; IF NONE, ASSUME 1
	CALL	CVSP		; Convert to half spacing
	MOV	R3,R2		; Skip count
LINSK1:	CMP	R2,#377		; Check size
	BLE	10$
	JMP	ERRGT
10$:	TSTNEB	$PAGNG,11$	; No paging
	BITEQ	#FOTF!TEXF,F.1,15$; Not currently footnote or text ?
11$:	CMP	R2,#MAXPS*LINSP	; Max if footnote
	BLOS	30$		; Ok?
	JMP	ERRHI		; No
15$:	TST	R2		; CHECK IF ARGUMENT IS NEG
	BMI	20$		; IF NEGATIVE DO NOT MAKE TOP OF PAGE CHECK
	TSTEQB	$PAGBR,50$	; AT TOP OF PAGE?
	BR	30$
20$:	ADD	LINEC3,R2	; Skip from bottom
25$:	BGT	45$		; Ok ?
	MOV	#LINSP,R2	; ELSE JUST SKIP 1 LINE	
30$:	TSTNEB	$PAGNG,45$	; No paging ?
	TSTB	$PFOOT		; Permanent footnote in progress?
	BMI	45$		; Yes
	CMP	R2,LINEC3	; Test room on page
	BLE	40$		; Room still left ?
	MOV	R2,-(SP)	; Save skip
	CALL	BPAGE		; No! make a new page
	MOV	(SP)+,R2	; Restore
40$:	BIS	#100000,R2	; Mark it as optional skip
45$:	JMP	SKIPN		; YES. SPACE OUT C(R2) LINES
50$:	RETURN			; 

;
;	FIGURE COMMAND
;
FIGUR::	CALL	(R4)		; GET ARGUMENT
	  MOV	#1,R3		; IF NONE, ASSUME ONE LINE
	CALL	CVSP		; Convert to half spacing
10$:	CMP	R3,#377		; Check size
	BLOS	11$
	JMP	ERRHI
11$:	MOV	R3,-(SP)	; SAVE DESIRED SPACE
	MOV	R3,R1
	CALL	TESTP		; TEST IF PAGE SHOULD BE BROKEN
	MOV	(SP)+,R2	; GET BACK DESIRED SIZE
	JMP	SKIPN		; SPACE THAT OUT
;
;	FIGURE DEFERRED command
;
FIGDF::	CALL	(R4)		; GET ARGUMENT
	  MOV	#1,R3		; IF NONE, ASSUME ONE LINE
	CALL	CVSP		; Convert to half spacing
10$:	CMP	R3,#377		; Check size
	BLOS	11$
	JMP	ERRHI
11$:	MOV	R3,-(SP)	; Save
	CALL	TEXTD
	MOV	(SP)+,R2	; Get skip count
	CALL	SKIPN		; Skip lines
	JMP	ENTEX
;
;	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
	MOV	#0,-(SP)	; Set up test value
	MOV	LMARG,R3	; Initial starting point
10$:	CALL	(R4)		; GET ANOTHER STOP IF ANY
	  TST	(SP)+		; Unstack
	  RETURN		; 
	CMP	R3,#256.	; Too big?
	BGE	20$		; Yes
	CMP	R3,(SP)		; Too small?
	BLE	20$		; Yes
	INC	NTABS		; Next tab stop
	MOV	NTABS,R0
	MOVB	R3,TABTAB-1(R0)	; STORE THIS TABSTOP
	MOV	R3,(SP)		; Save it for next time
	CMP	R0,#TABTL-1	; CHECK TABLE SIZE
	BLO	10$		; OK.
20$:	MOV	#32.,R0		; Too many tabs
	JMP	ILCMA		;
;
;	TAB PROPORTIONAL command
;
TABPR::	CALL	(R4)		; Get proportion
1$:	JMP	ILCM		; Illegal command
	DEC	R3		; Number of stops = n-1
	BLE	61$		; Too small
	CMP	R3,#TABTL	; Check number of tabs
	BHI	60$		; Too big ?
	MOV	R3,NTABS	; Number of tabs
	MOV	RMARG,-(SP)	; Get right margin
	SUB	LMARG,(SP)	; Minus the left
	CLR	R5		; Tab pointer
	CLR	R2		; Number of default tabs
10$:	CLRB	TABSV(R5)	; Clear tab status
	CALL	(R4)		; Get tab
	JMP	12$
	BCC	13$		; Not + or -
	INCB	TABSV(R5)	; Mark it as + or -
12$:	INC	R2
13$:	CMP	R3,#127.	; Check on size
	BGT	61$		; too big tab stop ?
	CMP	R3,#-127.	; Check msgnitude
	BLT	61$		; Too big ?
	MOVB	R3,TABTAB(R5)	; STORE THIS TABSTOP
	SUB	R3,(SP)
	BLE	61$		; Stop too big ?
	INC	R5
	CMP	R5,NTABS	; At end of tabs
	BLE	10$		; Not yet
	TSTEQ	R2,1$		; No default tabs ?
	.ifdf	$EIS
	MOV	(SP)+,R1	; Number of spaces left
	CLR	R0
	DIV	R2,R0		; Divide by default tabs
	.iff
	MOV	(SP)+,R0	; Number of spaces left
	MOV	R2,R1		; Default tabs
	CALL	$DIV
	.endc
15$:	CLR	R5		; Tab pointer
	MOV	LMARG,R4	; Get current left margin
;
;	Now set up tab loop
;
20$:	MOVB	TABTAB(R5),R2	; Get entry
	BEQ	30$		; Got one ?
	TSTEQB	TABSV(R5),40$	; Absolute tab stop ?
30$:	ADD	R0,R2		; Save this tab
	DEC	R1		; Decrement remainder
	BLT	40$		; None ?
	INC	R2		; Add 1 to stop
	BLT	61$		; Not Big enough ?
40$:	ADD	R2,R4		; Add to current position
	MOVB	R4,TABTAB(R5)	; Save tab
	INC	R5
	CMP	R5,NTABS	; Not done yet ?
	BLE	20$
	RETURN
60$:	JMP	ERRGT		; Value to big
61$:	JMP	ERRLT		; Value too small
;
; CENTER COMMAND
;
CENTRT:: BISB	#SW.DIS,$CENSW	; CENTER LINES TILL END
CENTER:: BISB	#SW.TDS,$CENSW	; Set up temporary center this line
	TSTNE	INDCT,5$	; Currently set indentation ?
	TSTEQB	$RIGSW,10$	; Not right justified ?
5$:	CLRB	$CENSW		; Clear centering
	JMP	ERRCON
10$:	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
;	END RIGHT command
;
ECENT::	BICB	#SW.DIS,$CENSW	; CLEAR CENTERIN SWITCH
ERIGHT::BICB	#SW.DIS,$RIGSW	; Reset permanent right shift
	CLR	INDCT
	RETURN
;
;	Right justify command
;
RIGHT::	BISB	#SW.DIS,$RIGSW	; Set permanent right justify switch
RIGHJ::	BISB	#SW.TDS,$RIGSW	; Set temporary righj justify switch
	TSTEQB	$CENSW,10$	; Not centered justified ?
	CLRB	$RIGSW		; Clear right justify
	JMP	ERRCON
10$:	CALL	(R4)		; Get shift
	  MOV	#0,R3		; Default
	JMP	INDCK		; Check indent

;
;	PERMANENT FOOTNOTE command
;
PERFN::	TSTNEB	$PAGNG,ILLEG	; No paging ?
	TSTNEB	$FOTPD,10$	; Footnote pending?
	MOVB	#-1,$PFOOT	; Indicate permanent footnote
	MOV	#FOTBF,R3	; Get footnote buffer
	CALL	CLRBF		; Clear it
	CLR	FOTLN		; Clear number of lines of footnote
	CLR	PFOTHD		; Clear permanent footnote header
	BR	FOOT1		; Do not set pending
10$:	MOV	#33.,R0		; Can't do permanent footnote
	JMP	ILCMA
ILLEG:	JMP	ILCM
;
;	FOOTNOTE command
;
FOOTN::	TSTNEB	$PAGNG,ILLEG	; No paging ?
	TSTNEB	$FOTPD,10$	; No footnote pending?
	DECB	$FOTPD		; Footnote now pending
	SUB	FOTLN,LINEC3	; Test if enough room
	MOV	FOTLN,FOTBF+BF.VSP	; Set up footnote size
10$:	MOV	NSPNG,R1	; Number of blanks/line
	CALL	TESTP		; Test it
FOOT1:	MOV	#FOTSV,R0	; FOOTNOTE SAVE BUFFER
	MOV	#SAVBEG,R1	; PARAMS TO SAVE
	MOV	#SAVSZ,R2	; SIZE OF SAVE BUFFER
10$:	MOVB	(R1)+,(R0)+	; SAVE EM
	SOB	R2,10$		; TILL DONE
	CLR	INDCT		; CLEAR INDENTATION
	TSTB	$PFOOT		; Permanent params?
	BLE	30$		; No ?
	MOV	#PFTSV,R0	; Footnote permanent save buffer
	MOV	#PFSBEG,R1	; Table to restore
	MOV	#PFSIZ,R2	; # of bytes to save
20$:	MOVB	(R0)+,(R1)+	; SAVE EM
	SOB	R2,20$		; TILL DONE
30$:	BIS	#FOTF,F.1	; PUT OUTPUT INTO FOOTNOTE BUFFER
	RETURN			; 
;
;	END FOOTNOTE
;
FOOTE::	BITEQ	#FOTF,F.1,20$	; Footnote not in progress?
	CALL	OUTAD		; Get footnote buffer
	TSTB	$PFOOT		; Permanent footnote in progress?
	BGE	5$		; No?
	MOV	BF.VSP(R3),R0	; Get footnote size
	CMP	R0,#12.		; Check size
	BLOS	1$		; OK ?
	CALL	CLRBF		; Clear the footnote buffer
	MOV	#ILCMA,-(SP)	; How to end
1$:	MOVB	#1,$PFOOT	; Set not in progress, but on
	MOV	BF.VSP(R3),FOTLN; Save permanent footnote size
	MOV	BF.FUL(R3),PFOTHD; Save header address
	MOV	#PFTSV,R0	; Footnote permanent save buffer
	MOV	#PFSBEG,R1	; Table to save
	MOV	#PFSIZ,R2	; # of bytes to save
3$:	MOVB	(R1)+,(R0)+	; SAVE EM
	SOB	R2,3$		; TILL DONE
5$:	MOV	#FOTSV,R0	; FOOTNOTE SAVE BUFFER
	MOV	#SAVBEG,R1	; PARAMS TO RESTORE
	MOV	#SAVSZ,R2	; SIZE OF SAVE BUFFER
10$:	MOVB	(R0)+,(R1)+	; RESTORE EM
	SOB	R2,10$		; TILL DONE
	MOV	#47.,R0		; Error message
	RETURN			; 
20$:	MOV	#28.,R0		; Unexpected END FOOTNOTE
	JMP	ILCMA		; Output error message
;
;	TEXT commands
;
TEXTC::	TSTNEB	$PAGNG,TXRET	; No paging ?
	CALL	ENTEX		; Output previous text
	TSTEQB	$PAGBR,TXRET	; Already at top of page?
	BIS	#TEXF,F.1	; Deferred text flag
TXRET:	RETURN
;
;	END TEXT command
;
ENTEX::	TSTNEB	$PAGNG,TXRET	; No paging ?
	TSTNEB	$SBPSW,ERRSBP	; Subpage ?
	BITEQ	#TEXF,F.1,TXRET	; Not in text mode ?
	BITNE	#TXDEF,F.1,10$	; Currently text deferred ?
	BIC	#TEXF,F.1	; No longer
	JMP	OUTNJ		; Now output the text
10$:	CALL	TXDEND		; End the deferred text
	CALL	TXDOUT		; And any deferred text
	RETURN			; 
ERRSBP:	MOV	#37.,R0		; Illegal during subpage
	JMP	ILCMA
;
;	TEXT DEFERRED command
;
TEXTD::	TSTNEB	$PAGNG,10$	; No paging ?
	CALL	ENTEX
	TSTEQB	$PAGBR,10$	; Already at top of page?
	BIS	#TXDEF!TEXF,F.1	; Set up for deferred text
	MOV	LINEC3,LN3SAV	; Save current number of lines
	MOV	NLPG,R0		; Number of lines
	SUB	TMARG,R0	; Minus top margin
	SUB	#LINSP,R0	; Minus title
	SUB	HSPAC,R0	; Minus subtitle
	SUB	$EOPSP,R0	; Minus space at bottom
	MOV	R0,LINEC3	; Now potential lines
	CALL	OUTAD		; Get buffer address
	CALL	ENDBF		; Go to end of buffer
	CLR	BF.VSP(R3)	; No vertical spacing yet
	MOV	BF.FUL(R3),TXDHED ; Save header
	MOV	#HD.TXD*400,R1	; Will be line count
	CALL	PWRD		; Save text defered header
10$:	RETURN
;
;	PAGE command - produces a new page
;
NEWP0:	TSTEQB	$SBPSW,NEWPAG	; Not Subpage ?
	JMP	ERRSBP
NEWPAG::BITEQ	#TEXF,F.1,20$	; NOT in text or text def section ?
	CALL	OUTAD
	MOV	LINEC3,R2	; Skip to end of page
	CALL	SKIPN
	JMP	ENTEX		; End the text section
20$:	MOVB	$PAGNG,-(SP)	; Save paging status
	CLRB	$PAGNG		; Set paging on
	CALL	CPAGE		; Start new page
	MOVB	(SP)+,$PAGNG	; Restore paging status
	RETURN
;
;	Produce even numbered page
;
PAGEV::	CALL	NEWP0		; Start new page
	BITNE	#1,PAGENO,SKPAG	; Page odd ?
	RETURN
;
;	Produce odd numbered page
;
PAGOD::	CALL	NEWP0		; Start new page
	BITEQ	#1,PAGENO,SKPAG	; Current page even ?
	RETURN
SKPAG:	JMP	BPAGE		; Bread for page
;
;	ENABLE ODD pages
;
ENODD::	BISB	#SW.TDS,$ODPAG	; ENable odd pages
	RETURN
DISODD::BICB	#SW.TDS,$ODPAG	; Disable odd pages
	RETURN
	.END