.TITLE FMTCM
	.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: D. N. CUTLER 22-SEP-75
;
;
; CARTS LUG MODIFICATIONS
;
;	CAR 1 --> ADD CHANGE BAR AND RIGHT SHIFT
;
; J. CLEMENT - MODIFACATIONS	NOV 1982
;	ADDED DISPLAY COMMANDS
;	MODIFIED FOR COMMON SUBROUTINE USAGE
;
; RUNOFF COMMANDS
;
; ALL COMMAND ROUTINES ARE ENTERED WITH:
;
;	R4=ADDRESS OF NUMBER CONVERSION ROUTINE.
;

; LOCAL DATA
;
; OUTPUT TEXT
;

	.PSECT	TEXT,RO,D,LCL,CON
APNMG:	.ASCIZ	/APPENDIX /	; APPENDIX HEADING PROTOTYPE
CHAPT:	.ASCIZ	/CHAPTER /	; CHAPTER HEADING PROTOTYPE
LOWER:	.ASCIZ	/LOWER/		;LOWER CASE PAGE
	.ASCIZ	/page /
MIXED:	.ASCIZ	/MIXED/		;MIXED CASE PAGE
	.ASCIZ	/Page /
UPPER:	.ASCIZ	/UPPER/		;UPPER CASE PAGE
	.ASCIZ	/PAGE /
NOTET:	.ASCIZ	/NOTE/		; NOTE HEADING PROTOTYPE
	.EVEN
	.PSECT	$TABL,RO,D,CON,LCL
LAYTB:	.BYTE	7		; Max value
	.BYTE	0			; 0 layout
	.BYTE	LAY.NB!LAY.CT!LAY.CP	; 1
	.BYTE	LAY.NB!LAY.CP!LAY.LR	; 2
	.BYTE	LAY.NB!LAY.CP		; 3
	.BYTE	LAY.NB			; 4
	.BYTE	LAY.NB!LAY.CT		; 5
	.BYTE	LAY.NB!LAY.CT!LAY.LR	; 6
	.BYTE	LAY.NB!LAY.LR		; 7
	.EVEN

	.PSECT	$CODE,RO,I,LCL,CON
;
;	lock parameters command
;
LOCKP::	MOV	SP,$LOCK	; lock many params to current value
	RETURN
;
;	LAYOUT	command
;
LAYOU::	CALL	(R4)		; Get layout number
	  MOV	#0,R3		; Default to 0
	CLR	$EOPSP		; Clear default spacing
	CMPB	R3,LAYTB	; Too big?
	BLOS	5$		; No
1$:	JMP	ILCM		; Yes, give error
5$:	MOVB	LAYTB+1(R3),$LAYOU	; Set layout
	BEQ	10$		; Layout 0?
	CALL	(R4)		; Get end-of-page spacing
	  MOV	#2,R3		; Default
	CMP	R3,#6		; Too big
	BHI	1$		; Yes!
	INC	R3		; Add 1 for number itself
	MOV	R3,$EOPSP	; End of page space
10$:	RETURN
;
; APPENDIX COMMAND
;
APNDX::	CLR	-(SP)		; end for number conversion
	INCB	APNNX		; increment appendix number
	MOVB	APNNX,APNDN	; current appendix number
	MOVB	APNNX,-(SP)
	CLRB	1(SP)
	BIS	APNDSP,(SP)	; set format
	MOV	#APNMG,-(SP)	; SET ADDRESS OF APPENDIX HEADING
	BR	CHAP1		; 
;
; CHAPTER COMMAND
;
CHPTR::	CLR	-(SP)		; end of numbers
	INCB	CHPNX		; incrment chapter number
	MOVB	CHPNX,CHPTN	; current number
	MOV	CHPNX,-(SP)	; for output
	CLRB	1(SP)
	BIS	CHPDSP,(SP)	; format
	MOV	#CHAPT,-(SP)	; SET ADDRESS OF CHAPTER HEADING

;
;	Common code for .CHAPTER or .APPENDIX
;
CHAP1:	MOV	#TTLBF,R3	; CLEAR TITLE BUFFER
	CALL	CLRBF
	MOV	#STLBF,R3	; CLEAR SUBTITLE BUFFER
	CALL	CLRBF
	MOV	PLMRG,LMARG	; SET LEFT MARGIN
	MOV	PTMRG,TMARG	; SET TOP MARGIN
	MOV	PRMRG,RMARG	; SET RIGHT MARGIN
	MOV	#SPCNG,NSPNG	; SET INITIAL SPACING
	BIS	#FILLF!JUSTF!PJUSTF,F.1 ;SET FILL AND JUSTIFY FLAGS
	BISB	#1,$HDRSW	; no header at begin chapters/appendix
	CALL	PAGRST		; Break page + reset subpage
	MOV	#7.,R2		; SET LINE COUNT
	CALL	SKIPN		; SKIP SEVEN LINES
	MOV	#TTBF,R3	; temporary buffer
	CALL	CLRBF		; clear it
	MOV	(SP)+,R0	; chap/appendix heading
	CALL	PSTRZB		; into buffer
	CALL	PAGCV		; convert numbers
	MOV	RMARG,R2	; CALCULATE SPACE COUNT TO HEADING
	ADD	LMARG,R2	; plus left margin
	SUB	BF.FUL(R3),R2	; minus header size
	ASR	R2		; 
	ADD	EBSIZ,R2	; SHIFT FOR CHANGE BAR	
	ADD	RIGSHI,R2	; ADD SPACE FOR RIGHT SHIFT
	CALL	NSPAC		; SPACE TO CHAPTER HEADING
	MOV	#TTBF,R3
	CALL	PSTRPA		; output the header
	MOVB	#1,LEVEL	; Reset current header level
	CLRB	CHPTN+1		; And clear current header level
30$:	MOV	#2.,R2		; SET LINE COUNT
	CALL	SKIPN		; SKIP TWO LINES
	CALL	UCTTL		; MOVE TITLE TO BUFFER IN CAPS
	MOV	RMARG,R2	; CALCULATE SPACE TO CENTER TEXT
	MOV	#TTLBF,R3	; TITLE BUFFER			; ***
	ADD	LMARG,R2	; plus left margin
	SUB	BF.SPC(R3),R2	; SUBTRACT OFF NUMBER OF CHAR
	ASR	R2		; divide by 2
	ADD	EBSIZ,R2	; SHIFT FOR CHANGE BAR	
	ADD	RIGSHI,R2	; ADD SPACE FOR RIGHT SHIFT
	CALL	NSPAC		; SPACE TO START OF TEXT
	MOV	#TTLBF,R3	; POINT TO TITLE DESCRIPTOR
	CALL	PSTRPA		; OUTPUT CONTENTS OF TITLE BUFFER
	MOV	#4.,R2		; SET LINE COUNT
	JMP	SKIPN		; SKIP FOUR LINES

;
; HEADER COMMAND
;
	.ENABL	LSB

HEADP:: TSTNE	$LOCK,20$	; parameters locked
	CALL	$FRCND		; FORCE TO LOGICAL END OF LINE
	MOV	#UPPER,R2	; ASSUME UPPER CASE SPECIFIED
	CMPEQ	#CR,R1,25$	; CARRIAGE RETURN?
	CMPEQ	#SEMI,R1,25$	; SEMICOLON?
	CALL	50$		; READ FIRST CHARACTER
	CMPEQB	R1,(R2)+,10$	; FIRST CHARACTER MATCH?
	MOV	#MIXED,R2	; ASSUME 'MIXED' KEYWORD
	CMPEQB	R1,(R2)+,10$	; FIRST CHARACTER MATCH?
	MOV	#LOWER,R2	; ASSUME 'LOWER' KEYWORD
	CMPNEB	R1,(R2)+,10$	; FIRST CHARACTER MISMATCH?
10$:	TSTEQB	(R2),30$	; NO MORE CHARACTERS TO MATCH?
	CALL	50$		; READ ANOTHER CHARACTER
	CMPEQB	R1,(R2)+,10$	; CHARACTER MATCH?
20$:	JMP	ILCM		; ILLEGAL COMMAND
25$:	TSTNEB	(R2)+,25$	; SEARCH FOR END OF STRING
	DEC	R2		; ADJUST FOR FOLLOWING INCREMENT
30$:	INC	R2		; POINT TO PAGE PROTOTYPE
	MOV	#PAGHD,R1	; POINT TO PAGE HEADER AREA
40$:	MOVB	(R2)+,(R1)+	; MOVE PROTOTYPE
	BNE	40$		; IF NE MORE TO GO
	CLRB	$HDRSW		; SET TO PRINT PAGE HEADERS
	RETURN			; 
50$:	CALL	CCIN		; READ NEXT CHARACTER
	CMPNEB	GCTABL(R1),#GC.LC,60$ ; not lower case?
	BIC	#40,R1		; CONVERT TO UPPER CASE
60$:	RETURN			; 
;
; NOHEADER COMMAND
;
NHEAD:: TSTNE	$LOCK,20$	; parameters locked?
	BISB	#200,$HDRSW	; SET TO NOT PRINT PAGE HEADERS
	RETURN			; 
	.DSABL	LSB
	.ENABL	LSB
;
;	HEADER PAGE COMMANDS
;
HPAGE::	TSTNE	$LOCK,5$	; params locked?
	CLRB	$PAGSW		; SET 'PAGE' ON
	RETURN			; 
HNOPG:: TSTNE	$LOCK,5$	; parameters locked
	MOVB	#-1,$PAGSW	; SET 'PAGE' OUTPUT OFF
	RETURN			; 
;
;	HEADER SPACING
;
HEDSP:: TSTNE	$LOCK,5$	; params locked?
	CALL	(R4)		; GET PARAMETER
	 MOV	NSPNG,R3	; USE LINE SPACING AS DEFAULT
	CMP	R3,#6		; TOO BIG?
	BLOS	10$		; NO
5$:	JMP	ILCM		; YES GIVE ERROR
10$:	MOV	R3,HSPAC	; SAVE HEADER SPACING
	RETURN
	.DSABL	LSB

;
; HEADER LEVEL COMMAND
;
HEADR::	MOVB	LEVEL,R3	; Initial level #
	CALL	(R4)		; GET HEADING LEVEL NUMBER
	  MOVB	LEVEL,R3	; Default is current level
	TST	R3		; Is level too small?
	BGT	10$		; No
5$:	JMP	ILCM		; Yes, give error
10$:	CMP	R3,#6.		; Level too big?
	BHI	5$		; IF HI NO
	MOVB	LEVEL,R2	; Previous level
	MOVB	R3,LEVEL	; Save level number
	ADD	#CHPTN,R3	; Point to current level
	ADD	#CHPTN+1,R2	; Point to previous level + 1
	INCB	(R3)		; Increment current level
	CLRB	1(R3)		; Clear next level
	CMP	R3,R2		; Current > previous
	BLO	20$		; No
15$:	MOVB	#1,(R2)+	; Set levels to 1
	CMP	R2,R3		; Past current level?
	BLOS	15$		; Not yet
20$:	MOVB	BEGLV,R2	; SET LINE COUNT
	BEQ	21$		; None
	CALL	SKIPN		; SKIP THREE LINES
21$:	MOVB	TPGLV,R3	; SET TEST PAGE VALUE
	CALL	TESTP		; Test if room on current page
30$:	MOV	#TX2BF,R3	; GET ADDRESS OF SECONDARY BUFFER DESCRIPTOR
	MOV	BF.FUL(R3),-(SP) ; save char count
	CMPB	LEVEL,NONLV	; No number level
	BGE	70$		; Yes
	MOV	#CHPTN,R2	; POINT TO CHAPTER/LEVEL TABLE
	CLR	-(SP)		; end of numbers
	MOVB	APNDN,R1	; Current appendix number
	BEQ	40$		; IF EQ NONE
	MOV	R1,-(SP)	; appendix to convert
	BIS	APNDSP,(SP)	; format
	BR	45$		; Continue with rest of levels
40$:	TSTNEB	(R2),50$	; Chapter oriented document?
45$:	INC	R2		; Skip chapter number
50$:	MOVB	(R2)+,R1	; Current chapter or level number
	BEQ	60$		; Last one?
	MOV	R1,-(SP)	; save for conversion
	MOVB	CHPDSP-CHPTN(R2),1(SP)	; set display format
	BR	50$		; more
60$:	MOVB	#'.,$SEPR	; digit separator
	CALL	PAGCV		; convert the numbers
	TSTNEB	APNDN,65$	; Chapter oriented?
	CMPNEB	LEVEL,#1,65$	; Not first level?
	TSTNEB	CHPTN,65$	; Chapter oriented?
	MOVB	#'.,R1		; Output .0
	CALL	PBYT		; Now .
	MOVB	#'0,R1		; Output 0
	CALL	PBYT		; Now 0
65$:	MOVB	SPCLV,R4	; Get number of spaces to indent
	BLE	70$		; None!
	MOV	#NXS,R1		; Get quoted space to write
68$:	CALL	PBYT		; 
	SOB	R4,68$		; Output all spaces
70$:	MOV	BF.FUL(R3),R2	; chars added
	SUB	(SP)+,R2	; Subtract old number of chars
	ADD	R2,SPCH		; spacing chars
	SUB	R2,LINBK	; line break point
	MOV	LMARG,-(SP)	; Save margin
	MOV	(SP),R0		; And into R0
	MOV	CASE,-(SP)	; Save current case
	CMPB	LEVEL,MIXLV	; Capitalize first char?
	BGT	85$		; No
	BIS	#1002,CASE	; Yes
85$:	CMPB	LEVEL,CAPLV	; Higher than min capitalize level
	BGT	90$		; Yes
	MOV	#401,CASE	; Shift to upper case
90$:	CMPB	LEVEL,CENLV	; Not center it?
	BLT	91$		; Yes
	CMPB	LEVEL,LINLV	; Run in level
	BGE	91$		; Yes, do not center it
	BISB	#3,$CENSW	; Set to center it
	BR	92$
91$:	MOV	SPCH,R2		; Check on total char count
	ADD	R2,R0		; new? left margin
	ADD	#16.,R0		; Test if too big
	CMP	R0,RMARG	; Too big?
	BHI	92$		; Yes skip margin change
	ADD	R2,LMARG
	NEG	R2
	MOV	R2,INDCT	; Negative indentation first time
92$:	BISB	#2,$AUHYP	; Prevent hyphenation
	CALL	LIN		; Transfer lines to buffer
	BICB	#2,$AUHYP	; Now allow it again
	MOV	(SP)+,R1	; Old case
	CMPNE	CASE,#401,95$	; Changed?
	MOV	R1,CASE		; No, restore previous
	MOV	R1,CASSAV	; And saved case
95$:	CMPB	LEVEL,LINLV	; Level >= run on line value
	BGE	110$		; Yes
	CALL	OUTNJ		; OUTPUT HEADING LINE
	BICB	#2,$CENSW	; Reset centering
	MOVB	ENDLV,R2	; SET LINE COUNT
	BEQ	100$		; None
	CALL	SKIPN		; Skip lines
100$:	MOV	(SP)+,LMARG	; Restore margin
	JMP	LGO
110$:	CMP	LINBK,#3	; Room for 3 more?
	BLE	120$		; No
	MOVB	#NXS,R1		; insert space
	CALL	CCBYT
	MOVB	#'-,R1		; insert  dash
	CALL	CCBYT
	MOV	#NXS,R1		; insert space
	CALL	CCBYT
120$:	ADD	LMARG,INDCT	; Now set up indentation
	SUB	(SP),INDCT	; = current - old margin + Old indentation
	BR	100$
;
;	STYLE HEADERS COMMAND
;
STYHD:: MOV	#LINLV,-(SP)	; Current variable
	TSTNE	$LOCK,20$	; Page format locked?
10$:	CALL	(R4)		; Get header level number
	  MOVB	@(SP),R3	; keep old value as default
	TST	R3		; Waste 1 instruction
	CMP	R3,#20.		; Too big?
	BHI	20$		; Yes
	MOVB	R3,@(SP)	; Save it
	INC	(SP)		; Next variable
	CMP	(SP),#SPCLV	; End?
	BLOS	10$		; Not yet
	TST	(SP)+		; Pop
	RETURN
20$:	JMP	ILCM		; Bad input params

;
; LIST COMMAND
;
LISTC:: CALL	(R4)		; Get list vertical spacing
	  MOV	PARSP,R3	; DEFAULT TO CURRENT SPACING
	CMP	R3,#5		; LEGAL VALUE?
	BHI	LSTER		; IF HI NO
	MOV	LSTKP,R0	; GET CURRENT LIST STACK POINTER
	CMP	R0,#TKPEND 	; LIST STACK OVERFLOW?
	BHIS	LSTER		; IF HI YES
	MOV	#LSLMAR,R4	; ASSUME EMBEDDED LIST INDENT
	CMPNE	#LSTK,R0,10$	; NOT FIRST ITEM IN STACK?
	MOV	#LOLMAR,R4	; SET FOR INITIAL LIST INDENT
10$:	ADD	LMARG,R4	; CALCULATE NEW LEFT MARGIN
	CMP	(R0)+,(R0)+	; Make room for Display formats
	MOV	LSTVS,(R0)+	; Save current vertical spacing
	MOVB	LMARG,(R0)+	; SAVE LEFT MARGIN
	MOVB	LSTCT,(R0)+	; SAVE LIST ELEMENT COUNT
	MOV	R0,LSTKP	; SAVE NEW LIST STACK POINTER
	MOV	R3,LSTVS	; SET NEW LIST VERTICAL SPACING
	CLRB	LSTCT		; CLEAR CURRENT LIST ELEMENT NUMBER
	CMP	R4,RMARG	; OVERLAP RIGHT MARGIN?
	BLT	20$		; IF LT NO
	CALL	$ERMSG		; WARN USER ABOUT OVERLAP
	.WORD	LSTERR		; 
	CALL	ILCM1		; INDICATE WHICH PAGE IT WAS ON
	MOV	LMARG,R4	; REINITIALIZE TO LEFT MARGIN
20$:	MOV	R4,LMARG	; SET NEW LEFT MARGIN
	RETURN			; 
LSTER:	JMP	ILCM		; 
;
; END LIST COMMAND
;
ELIST::	CALL	(R4)		; GET LIST VERTICAL SPACING
	  MOV	PARSP,R3	; DEFAULT TO CURRENT SPACING
	MOV	LSTKP,R0	; GET CURRENT LIST STACK POINTER
	CLR	LSTCT		; Clear current list count
	CMP	R0,#LSTK	; Unexpected end?
	BLOS	LSTER		; Yes, Do not unstack
	MOVB	-(R0),LSTCT	; RESTORE PREVIOUS LIST ELEMENT NUMBER
	MOVB	-(R0),LMARG	; RESTORE PREVIOUS LEFT MARGIN
	MOV	-(R0),LSTVS	; Restore previous vertical spacing
	CMP	-(R0),-(R0)	; Skip formats
	MOV	R0,LSTKP	; SAVE NEW LIST STACK POINTER
	MOV	R3,R2		; Final skip count
	JMP	SKIPN		; SKIP LINES

;
; LIST ELEMENT COMMAND
;
LSTEL::	MOV	PARPT,R3	; Get paragraph test page count
	CALL	TESTP		; Break page if necessary
	TSTEQB	$PAGBR,10$	; PAGE ALREADY BROKEN?
	MOV	LSTVS,R1	; GET LIST ELEMENT VERTICAL SPACING
	BEQ	10$		; IF EQ NO SPACING
	MOV	NSPNG,R0	; GET LINES PER LINE
	CALL	$MUL		; CALCULATE ACTUAL NUMBER OF LINES TO SKIP
	MOV	R1,R2		; SET LINE SKIP COUNT
	CALL	SKIPN		; SKIP LINES
10$:	INCB	LSTCT		; INCREMENT LIST ELEMENT NUMBER
	MOV	#TX2BF,R3	; POINT TO SECONDARY INPUT LINE DESCRIPTOR
	MOV	LSTKP,R4	; Current list stack
	MOV	BF.FUL(R3),-(SP) ; Save stored char count
	MOVB	(R4)+,R1	; Get first char
	CMP	R1,#SPC		; Space or less?
	BLE	20$		; Yes, do not output it
	CALL	PBYT		; Save it
20$:	CLR	-(SP)		; chock
	MOVB	LSTCT,-(SP)	; GET CURRENT ELEMENT NUMBER
	MOVB	(R4)+,1(SP)	; List element format
	CALL	PAGCV		; CONVERT NUMBER TO ASCII
	MOV	LSTKP,R4	; Restore
	MOVB	2(R4),R1	; Second char
	CMP	R1,#SPC		; Space or less?
	BGT	30$		; No, char is OK
	MOV	#'.,R1		; GET PERIOD
30$:	CALL	PBYT		; WRITE PERIOD INTO BUFFER
	MOV	#NXS,R1		; GET NON EXPANDABLE SPACE
	CALL	PBYT		; WRITE QUOTED SPACE INTO BUFFER
	CALL	PBYT		; WRITE ANOTHER QUOTED SPACE
	MOV	BF.FUL(R3),R1	; Current char count
	SUB	(SP)+,R1	; Number of chars stored
	ADD	R1,SPCH		; Add to char count
	MOV	LMARG,R0	; Check left margin
	SUB	PLMRG,R0	; Find difference from permenant margin
	BLT	40$		; smaller
	SUB	R1,R0		; Is indent too large?
	BGE	40$		; No
	ADD	R0,R1		; Yes, correct it
	ADD	R0,LINBK	; Subtract extra from line counter
40$:	NEG	R1		; Indent to left of current margin
	MOV	R1,INDCT	; Indentation
	CALL	$FRCND		; FORCE TO LOGICAL END OF COMMAND
LINEP:	TST	(SP)+		; CLEAN STACK
	CALL	CCIN		; GET BREAK CHAR
	JMP	TEXT		; PROCESS TEXT

;
; NOTE COMMAND
;

NOTE::	MOV	#8.,R3		; SET PAGE TEST COUNT
	CALL	TESTP		; TEST IF PAGE SHOULD BE BROKEN
	BCC	3$		; YES BROKEN
	MOV	#NHSPAC,R2	; SET LINE COUNT
	CALL	SKIPN		; SKIP LINES
3$:	MOV	#NPMARG*2,R3	; ASSUME AT LEFT MARGIN
	MOV	#RMARG,R4	; POINT TO RIGHT MARGIN COUNT
	MOV	(R4)+,-(SP)	; CALCULATE SPREAD IN MARGINS
	TSTEQ	(R4),7$		; AT LEFT MARGIN?
	MOV	#NSMARG*2,R3	; SET SECONDARY INDENT VALUE
7$:	SUB	(R4),(SP)	; 
	CMP	R3,(SP)+	; SPREAD LARGE ENOUGH?
	BLT	10$		; IF LT YES
	CALL	$ERMSG		; WARN USER ABOUT MARGIN
	.WORD	NOTERR		; 
	CALL	ILCM1		; OUTPUT PAGE NUMBER
	CLR	R3		; INDICATE NO ADJUSTMENT
10$:	MOV	(R4),NOTLM	; SAVE CURRENT LEFT MARGIN
	MOV	-(R4),NOTRM	; SAVE CURRENT RIGHT MARGIN
	ASR	R3		; REDUCE TO ACTUAL MARGIN REDUCTION
	SUB	R3,(R4)+	; REDUCE RIGHT MARGIN
	ADD	R3,(R4)		; INCREASE LEFT MARGIN
	MOV	F.1,NOTSV	; SAVE CURRENT FLAGS WORD
	BIS	#FILLF!JUSTF!PJUSTF!SPECF!NOTF,F.1 ;SET FLAGS
	MOV	CMADR,NOTCM	; SAVE CURRENT EXPECTED COMMAND ADDRESS
	MOV	ENOTE,CMADR	; SET EXPECTED COMMAND ADDRESS
	MOV	#TX2BF,R3	; SECONDARY BUFFER			; ***
	CALL	SETB2		; TRANSFER TEXT TO BUFF
	MOV	BF.SPC(R3),SPCH	; SIZE OF TEXT
	BNE	30$		; ANY GIVEN?
	MOV	#NOTET,R0	; POINT TO NOTE TEXT PROTOTYPE
	CLR	R2		; CHARACTER COUNT
	CALL	PSTRZB		; PUT TEXT INTO BUFFER
	MOV	R2,SPCH		; TOTAL NUMBER OF CHARS.
30$:	BISB	#1,$CENSW	; SET UP TO CENTER TEXT
	MOV	RMARG,R2	; RIGHT
	ADD	LMARG,R2	; PLUS LEFT MARGINS
	ASR	R2		; DIVIDED BY 2
	MOV	R2,CMARG	; IS CENTERING MARGIN
	CALL	OUTNJ		; OUTPUT THE TEXT
	MOV	#NASPAC+1,R2	; SET LINE COUNT
	JMP	SKIPN		; SKIP LINES

;
; END NOTE COMMAND
;

ENOTC::	MOV	NOTSV,F.1	; RESTORE FLAGS WORD
	MOV	NOTCM,CMADR	; RESTORE PREVIOUS EXPECTED COMMAND ADDRESS
	MOV	NOTRM,RMARG	; INCREASE RIGHT MARGIN
	MOV	NOTLM,LMARG	; DECREASE LEFT MARGIN
	MOV	#NFSPAC,R2	; SET SKIP COUNT
	JMP	SKIPN		; SKIP LINES

;
; NUMBER APPENDIX COMMAND
;
NAPDX::	MOVB	APNNX,R3	; old appendix value
	CALL	NUPAG		; get new value
	CMP	R3,#255.	; too big
	BLO	10$		; no
	JMP	ILCM		; yes
10$:	MOVB	R3,APNNX	;  save next value
	RETURN			; 
;
;	NUMBER CHAPTER COMMAND
;
NCHPT::	MOVB	CHPNX,R3	; current chapter number
	CALL	NUPAG		; GET CHAPTER NUMBER
	CMP	R3,#255.	; LEGAL CHAPTER NUMBER?
	BLO	10$		; IF LOS NO
	JMP	ILCM
10$:	MOVB	R3,CHPNX	; SET FOR NEXT CHAPTER COMMAND
	TSTNE	$LOCK,20$	; parameters locked
	CLR	$CHPSW		; enable chapter numbers
20$:	RETURN			; 
NOCHP:: TSTNE	$LOCK,10$	; params locked
	BIS	#1,$CHPSW	; disable chapter numbers
	CLR	CHPTN		; turn off chapter/appendix numbers
	CLR	APNDN
10$:	RETURN
;
; PAGE NUMBER SELECTION COMMANDS
;
NUMON:: MOV	PAGENO,R3	; get original page number
	CALL	NUPAG		;NUMBER PAGES.  ANY PARTICULAR NUMBER?
	MOV	R3,PAGNX	; next page number
	TSTNE	$LOCK,10$	; params locked?
	MOV	SP,$NUMSW	;TURN ON FLAG TO CAUSE NUMBERING
10$:	RETURN			;
NUMOF::	TSTNE	$LOCK,10$	; params locked?
	CLR	$NUMSW		;TURN OFF NUMBERING.
10$:	RETURN			;
;
;	number subpage
;
NSPAG::	MOV	SUBNX,R3	; current subpage
	CALL	NUPAG		; get new value
	CMP	R3,#255.	; too big?
	BLO	10$		; no
	JMP	ILCM		; yes
10$:	MOV	R3,SUBNX	; save next subpage number
	MOV	SP,$SBPSW	; start subpage
	RETURN
;
;	get new page/chapter/appendix number
;
NUPAG::	MOV	R3,-(SP)
	CALL	ALPGT		; get letter code?
	BCS	20$		; none
10$:	TST	(SP)+		; pop saved value
	DEC	R3		; value - 1 for next page
	RETURN
20$:	MOV	(SP),R3		; saved value for increment
	CALL	RCNR		; get numeric value
	  JMP	30$		; none
	BR	10$		; success
30$:	MOV	(SP)+,R3	; keep old value
	RETURN

;
;	Display page command
;
DSPTAB:	.WORD	'D-'@
	.WORD	0
LU:	.WORD	26.*<'L-'@> + 'U-'A
	.WORD	100000
	.WORD	26.*<'L-'@> + 'L-'A
	.WORD	120000
	.WORD	26.*<'L-'@> + 'M-'A
	.WORD	130000
	.WORD	26.*<'R-'@> + 'U-'A
	.WORD	140000
	.WORD	26.*<'R-'@> + 'L-'A
	.WORD	160000
	.WORD	26.*<'R-'@> + 'M-'A
	.WORD	170000
	.WORD	0		; end of table
DSELE::  MOV	LSTKP,R4	; Current list
	CALL	GETLIT		; Get a literal
	BCS	10$		; None!
	MOVB	(R2),(R4)	; save character
10$:	INC	R4
	CALL	DSPGT0		; Get Display value
	SWAB	R3		; Get value in lower byte
	MOVB	R3,(R4)+	; Save display format
	CALL	GETLIT		; Final literal
	BCS	20$		; none
	MOVB	(R2),(R4)	; save character
20$:	RETURN
	BCS	10$		; None so take default
;
;	DISPLAY LEVELS COMMAND
;
DSLEV::	MOV	#CHPDSP+2,R4	; First level display format
10$:	CALL	DSPGT0		; get display
	SWAB	R3		; get lower byte
	MOVB	R3,(R4)+	; Save display format
	CMP	R4,#CHPDSP+8.	; Done?
	BLOS	10$		; no
	RETURN
DSNUM::	CALL	DSPGT0		; get display
	MOV	R3,PAGDSP	; save it
	RETURN
;
;	Display chapter command
;
DSCHP::	CALL	DSPGT0		; get
	MOV	R3,CHPDSP	; save
	RETURN
;
;	Display appendix command
;
DSAPN::	MOV	LU,R3		; default
	CALL	DSPGT
	MOV	R3,APNDSP
	RETURN
;
;	Display subpage command
;
DSSUBP:: MOV	LU,R3		; default
	CALL	DSPGT
	MOV	R3,SUBDSP	; save type
	RETURN
;
;	routine to parse display command
;
DSPGT0:	MOV	DSPTAB,R3	; Decimal default
DSPGT:	TSTNE	$LOCK,17$	; params locked?
	CALL	ALPGT		; get 2 char sequence
	MOV	#DSPTAB,R0	; table to search
10$:	TST	(R0)		; at end of table?
	BNE	15$		; no
17$:	JMP	ILCM		; bad input
15$:	CMPEQ	R3,(R0)+,18$	; match?
	TST	(R0)+		; NO
	BR	10$		; continue
18$:	MOV	(R0),R3		; get code
20$:	RETURN
;
;	put byte and incrment counter
;
CCBYT:	INC	SPCH
	DEC	LINBK		; line break counter
	CMPNEB	R1,#SPC,10$	; not space?
	INC	SPCNT		; increment space count
10$:	JMP	PBYT
	.END