.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	$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	#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
;							
; 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
	RETURN
NAUHYP:: BISB	#SW.DIS,$AUHYP	; Set autohyphenate disabled
	RETURN
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::CALL	(R4)		; READ SIGNED DECIMAL NUMBER
	  MOV	PARIND,R3	; NONE. USE CURRENT VALUE
	JMP	INDTST		; Test and store indentation
;
;	underlining commands
;
UNLSP::	BISB	#SW.DIS,$UNLSP	; set up to underline spaces
	RETURN
UNLNS::	CLRB	$UNLSP		; set up no underline spaces
	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,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	SETPG1		; FINISH IN COMMON CODE

;
; PAGE SIZE COMMAND
;

SETPG::	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		; IF LE ERROR
	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
ERR:	JMP	ILCMA		; Output the message
;
; PARAGRAPH COMMAND
;
SETPR::	CALL	(R4)		; OPTIONAL IDENTING ARGUMENT
	  MOV	PARIND,R3	; NO. USE OLD VALUE
	CMP	R3,LINBK	; REASONABLE VALUE?
	BGT	ERRGT		; IF GT NO
	MOV	R3,PARIND	; STORE PARA INDENT VALUE
	CALL	(R4)		; Get list vertical spacing
	  MOV	PARSP,R3	; Paragraph spacing
	CMP	R3,#MAXPS	; LEGAL VALUE?
	BHI	ERRHI		; IF HI NO
	MOV	R3,PARSP	; SET NEW PARAGRAPH SPACING
	CALL	(R4)		; GET test page COUNT
	  MOV	PARPT,R3	; Default to previous value
	CMP	R3,#MAXPS	; VALUE WITHIN REASON?
	BHI	ERRHI		; IF HI NO
	MOV	R3,PARPT	; SET NEW PARAGRAPH PAGE TEST COUNT
	RETURN
PARAG::	CALL	SETPR		; GET PARAMS
PARTP::	MOV	PARSP,R1	; Paragraph line spacing
	CALL	SKPLIF		; Skip if not at top of page
	MOV	PARPT,R1	; Get test page count
	CALL	TESTT		; TEST IF ROOM ON PAGE
	MOV	PARIND,INDCT	; SET INDENTATION
	RETURN			;

;
;	TEST TEXT command
;
TSTTX::	CALL	(R4)		; Get argument
	MOV	#1,R3		; Default if no argument
	MOV	R3,R1		; Number to mul
	CALL	MULSP		; Find actual adjusted line spacing
	BR	TSTPG1		;
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,R1
TSTPG1:	TSTEQB	$PAGBR,10$	; Already at top of page?
	JMP	TESTP		; TEST AND OUTPUT PAGE IF NECESSARY
10$:	RETURN
;
;	TEXT and END TEXT commands
;
TEXTC::	CALL	ENTEX		; Output previous text
	TSTEQB	$PAGBR,10$	; Already at top of page?
	BIS	#TEXF,F.1	; Deferred text flag
10$:	RETURN
ENTEX::	BIC	#TEXF,F.1	; Deferred text off
	CLR	TEXLN		; Clear deferred line count
	CALL	OUTL0		; Output all deferred text
	JMP	LINSET		; Now set up new line
;
;	HALF SPACING command
;
NHSPSW:: BISB	#SW.DIS,$HSPSW		; Disable half spacing
	RETURN
HSPSW:: BICB	#SW.DIS,$HSPSW		; Enable half spacing
;
; 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			; 
;
; LINE SKIPPING commandS
;
	.ENABL	LSB
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	10$
LINSKP:: CALL	(R4)		; GET OPTIONAL ARGUMENT
	  MOV	#1,R3		; IF NONE, ASSUME 1
	CALL	CVSP		; Convert to half spacing
	MOV	R3,R2		; Skip count
10$:	BITEQ	#FOTF,F.1,15$	; Not currently footnote?
	CMP	R2,#MAXPS*LINSP	; Max if footnote
	BLOS	20$		; 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
	BGT	40$		; Ok ?
	MOV	#LINSP,R2	; ELSE JUST SKIP 1 LINE	
	BR	40$		; 			
30$:	TSTB	$PFOOT		; Permanent footnote in progress?
	BMI	40$		; Yes
	CMP	R2,LINEC3	; Test room on page
	BLE	40$		;  Room still left ?
	JMP	BPAGE		; NO. MAKE A NEW PAGE
40$:	CALL	SKIPN		; YES. SPACE OUT C(R2) LINES
50$:	RETURN			; 
	.DSABL	LSB

;
; FIGURE COMMAND
;
FIGUR::	CALL	(R4)		; GET ARGUMENT
	  MOV	#1,R3		; IF NONE, ASSUME ONE LINE
	CALL	CVSP		; Convert to half spacing
	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
	MOV	R3,R2		; Save
	CMP	R2,LINEC3	; Too many to fit on this page ?
	BGT	10$		; Too many ?
	JMP	SKIPN		; Skip lines
10$:	ADD	$FIGDF,R2	; Total next page
	MOV	R2,$FIGDF	; Save it
	ADD	TMARG,R2	; Find total
	ADD	HSPAC,R2
	ADD	$EOPSP,R2	; End of page spacing
	CMP	R2,NLPG		; Compared with available space ?
	BGT	FIGERR		; Too big ?
	RETURN
FIGERR:	JMP	ERRGT		; ERROR
;
; 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
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		;

;
; CENTER COMMAND
;
CENTRT:: BISB	#SW.DIS,$CENSW	; CENTER LINES TILL END
CENTER:: BISB	#SW.TDS,$CENSW	; Set up temporary center this 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	#SW.DIS,$CENSW	; CLEAR CENTERIN SWITCH
	RETURN
;
;	Right justify command
;
RIGHJ::	BISB	#SW.TDS,$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	ERRGT

;
;	PERMANENT FOOTNOTE
;
PERFN::	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
	BR	FOOT1		; Do not set pending
10$:	MOV	#33.,R0		; Can't do permanent footnote
	JMP	ILCMA
;
;	FOOTNOTE
;
FOOTN::	TSTNEB	$FOTPD,10$	; No footnote pending?
	DECB	$FOTPD		; Footnote now pending
	SUB	FOTLN,LINEC3	; Test if enough room
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
	MOV	F.1,(R0)+	; FIRST SAVE STATUS
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
	MOV	(R0)+,F.1	; FIRST RESTORE STATUS
20$:	MOVB	(R0)+,(R1)+	; SAVE EM
	SOB	R2,20$		; TILL DONE
30$:	BIS	#FOTF,F.1	; PUT OUTPUT INTO FOOTNOTE BUFFER
	JMP	LINSET		; NOW SET UP FOOTNOTE BUFFER
 
;
;	END FOOTNOTE
;
FOOTE::	BITEQ	#FOTF,F.1,20$	; Footnote not in progress?
	CALL	OUTNJ		; BREAK CURRENT LINE
	TSTB	$PFOOT		; Permanent footnote in progress?
	BGE	5$		; No?
	MOVB	#1,$PFOOT	; Set not in progress, but on
	MOV	#FOTBF,R0	; Get footnote buffer
	MOV	BF.FUL(R0),PFOTX	; Save current index
	MOV	BF.HED(R0),PFOTHD	; Save header address
	MOV	#PFTSV,R0	; Footnote permanent save buffer
	MOV	#PFSBEG,R1	; Table to save
	MOV	#PFSIZ,R2	; # of bytes to save
	MOV	F.1,(R0)+	; FIRST SAVE STATUS
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
	MOV	(R0)+,F.1	; FIRST RESTORE STATUS
10$:	MOVB	(R0)+,(R1)+	; RESTORE EM
	SOB	R2,10$		; TILL DONE
	RETURN			; 
20$:	MOV	#28.,R0		; Unexpected END FOOTNOTE
	JMP	ILCMA		; Output error message
;
; PERIOD SPACING COMMANDS
;
PERSP::	BISB	#SW.DIS,$PERSW	; ENABLE TWO SPACES AFTER PUNCTUATION
	RETURN			; 
NPERS::	CLRB	$PERSW		; DISABLE TWO SPACES AFTER PUNCTUATION
	RETURN			; 
	.END