.title	fmtcm
;
;
;
; J. CLEMENT - 1983
;	Rewrote most of the code
;
; RUNOFF COMMANDS
;	CHAPTER
;	APPENDIX
;	NOTE
;	LIST, LIST ELEMENT, END LIST
;	TITLE, SUBTITLE
;	HEADER page commands
;	HEADER LEVEL
;
;
; ALL COMMAND ROUTINES ARE ENTERED WITH:
;
;	R4=ADDRESS OF NUMBER CONVERSION ROUTINE.
;

; LOCAL DATA
;
; OUTPUT TEXT
;
	.TEXT
LOWER:	.ASCIZ	/page /
MIXED:	.ASCIZ	/Page /
UPPER:	.ASCIZ	/PAGE /
NOTET:	.ASCIZ	/NOTE/			; NOTE HEADING PROTOTYPE
MRGERR:	.ASCIZ	/RNO -- Can't Reduce margins/
IFTXT:	.BYTE	TOCX,200
	.ASCIZ	/.IF TOC/
EITXT:	.BYTE	TOCX,200
	.ASCIZ	/.ENDIF TOC/
	.EVEN
;
;	Local variables
;
	.VARS
LSAV:	.WORDA	0
SAVA:	.WORDA	0
SAVB:	.WORDA	0
LSTAT:	.WORDA	0
	.CODE
;
;	APPENDIX COMMAND
;
APNDX::	CALL	CHAP0		; Pre chapter actions
	CLR	CHPTN		; Clear current chapter number
	MOV	#APNM2,-(SP)	; Post header
	CLR	-(SP)		; end for number conversion
	MOV	APNNX,R1	; Next appendix number
	MOV	R1,APNDN	; current appendix number
	MOV	R1,-(SP)	; For output
	BIC	#^C<NM.MSK>,R1	; Clear extra bits
	INC	R1		; increment appendix number
	BNE	10$		; Non zero?
	INC	R1		; Make it 1
10$:	MOV	R1,APNNX
	BIS	APNDSP,(SP)	; set format
	MOV	#APNMG,-(SP)	; SET ADDRESS OF APPENDIX HEADING
	MOV	#APSTAT,R2	; Appendix status
	BR	CHAP1		; 
;
;	CHAPTER COMMAND
;
CHPTR::	CALL	CHAP0		; Pre chapter actions
	CLR	APNDN		; No appendix now !!!
	MOV	#CHPM2,-(SP)	; Post header
	CLR	-(SP)		; end of numbers
	MOV	CHPNX,R1	; Next chapter number
	MOV	R1,CHPTN	; current number
	MOV	R1,-(SP)	; For output
	BIC	#^C<NM.MSK>,R1	; Clear extra bits
	INC	R1		; increment appendix number
	BNE	10$		; Non zero?
	INC	R1		; Make it 1
10$:	MOV	R1,CHPNX	; Next chapter number
	BIS	CHPDSP,(SP)	; format
	MOV	#CHPMG,-(SP)	; SET ADDRESS OF CHAPTER HEADING
	MOV	#CHSTAT,R2	; Set for chapter status
	BR	CHAP1
;
;	Common code for .CHAPTER or .APPENDIX
;
CHAP0:	BICB	#SW.TDS,$PAGNG	; Enable paging
	CALL	TXDMP		; Dump all deferred text
	CLRB	LEVEL		; Current level #
	CALL	ESCCLR		; Clear escapes and underlining
	CLR	LEVNM		; And clear current header level
	MOV	#STLBF,R3	; CLEAR SUBTITLE BUFFER
	CALL	CLRBF
	TSTNEB	$AUTTL,5$	; No auto title?
	CALL	TTLSV		; Save title
5$:	CALL	$FRCND		; Start at beginning of title
	TSTEQB	$TOCBE,6$	; TOC not in progress ??
	RETURN
6$:	MOV	PTMRG,TMARG	; SET TOP MARGIN
	MOV	PLMRG,LMARG	; Left margin
	MOV	PRMRG,RMARG	; SET RIGHT MARGIN
	CLRB	$CENSW		; Clear centering just in case
	CALL	STCMRG		; Set center margin
	MOV	PSPNG,NSPNG	; SET INITIAL SPACING
	BIS	#FILLF!JUSTF!PJUSTF,F.1 ;SET FILL AND JUSTIFY FLAGS
	TSTEQB	$ODPAG,10$	; Odd page not enabled ?
	BITNE	#1,PAGNX,10$	; Next page odd ?
	CALL	PAGRST
	INCB	$PAGBR		; Set no current page
10$:	BISB	#SW.TDS,$HDRSW	; no header at begin chapters/appendix
	MOVB	CHLAY,R0	; Any chapter layout ?
	BLT	20$		; No ?
	MOVB	R0,NXLAY	; Next layout
	MOV	CHEPSP,NXEPSP	; And end of page spacing
20$:	CALL	PAGRST		; Break page + reset subpage
	RETURN
CHAP1:	CALL	RSTAT		; Restore status if available
	CALL	BUFTOC		; Send command to TOC
	MOVB	CHSK1,R2	; SET LINE COUNT
	CALL	SKIPN		; Skip lines
	TSTEQB	$TOCBE,10$	; TOC not in progress ??
	MOV	PARPT,R1	; use paragraph test page
	CALL	TESTT		; To test page
10$:	CALL	LINBEG		; Start new line
	MOVB	CHSP1,R2	; First space count
	CALL	CENCH		; Use em
	CALL	SETINS		; Get input temporary
	MOV	(SP)+,R0	; chap/appendix pre-heading
	CALL	PSTRZB
	CALL	PAGCV		; convert numbers
	MOV	(SP)+,R0	; chap/appendix pre-heading
	CALL	PSTRZB
	CALL	INOUT
	TSTB	CHSK2		; Next one on same line?
	BMI	20$		; Yes
	CALL	OUTNJ		; No
	MOVB	CHSK2,R2	; Number of line
	CALL	SKIPN		; Skip them
20$:	CALL	LINBEG
	MOVB	CHSP2,R2	; Second space count
	CALL	CENCH		; Use em
	BISB	#SW.IDS,$AUHYP	; Prevent automatic hyphenation
	CALL	LINUC		; Transfer lines to buffer
	BICB	#SW.IDS,$AUHYP	; Now allow it again
	CALL	ENDESC
	TSTB	CHSK3		; Next one on same line?
	BMI	30$		; Yes
	CALL	OUTNJ		; Output it
	MOVB	CHSK3,R2	; Lines to skip
	CALL	SKIPN		; Skip them
30$:	JMP	LGO		; Next line
;
;	Clear escape sequences pending & underlining
;
ENDESC:	TSTEQ	BF.HED(R3),ESCCLR	; No buffer ?
	MOV	ESMSK,R4	; Escape sequences on
	CALL	ESCEND		; End them
ESCCLR:	CLR	ESMSK		; Clear escapes
	MOV	#1,PHSP		; Reset permanent spacing
	BISB	#SW.TDS,$UNLSW	; Set temporary disable
	RETURN

;
;	Set up centering or margin
;
CENCH:	TST	R2		; Type of spacing
	BEQ	40$		; None ?
	BGT	20$		; No centering?
	CMPNE	R2,#-1,10$	; Not centering?
	BISB	#SW.TDS,$CENSW	; Set to center
	RETURN
10$:	BISB	#SW.TDS,$RIGSW	; Set to right justify
	RETURN
20$:	CALL	BRKSV		; Set break here
30$:	MOV	#NXS,R1		; Output N spaces
	CALL	PUBYT
	SOB	R2,30$
40$:	RETURN
;
;	Save TITLE in uppercase
;
TTLSV:	TSTNEB	$TOCBE,STLSV2	; TOC in progress?
	MOV	BUFADD,R0	; Input buffer
	MOV	BF.FUL(R0),-(SP)	; Save current location
	CALL	UCTTL		; Save current input in tittle
	BR	STLSV1
STLSV:	TSTNEB	$TOCBE,STLSV2	; TOC in progress?
	MOV	CASE,STLCAS
	MOV	BUFADD,R0	; Input buffer
	MOV	BF.FUL(R0),-(SP); Save current location
	CALL	SETST1		; Save current input in tittle
STLSV1:	MOV	(SP)+,R1	; Location to back to
	MOV	BUFADD,R3	; Input buffer
	CALL	FNDBF		; Go back to previous location
	MOV	#TX2BF,R3	; Restore output buffer
STLSV2:	RETURN
;
;	Output buffer to TOC
;
BUFTOC:	TSTNEB	$TOCSW,10$		; No TOC?
	MOV	BUFADD,R3		; Get input buffer address
	MOV	BF.VSP(r3),R1		; Start of command ERRORSTRING
	ADD	BF.CAD(r3),R1		; Now is address
	ADD	#BFLNK+1,R1		; Correct for header
	MOV	BF.CNT(R3),R2		; String count
	ADD	BF.ADD(R3),R2
	SUB	R1,R2
	DEC	R2			; Omit CR,LF
	CALL	OUTTOC			; Output to TOC file
	MOV	#TTBF,R3		; Get temporary buffer
	CALL	CLRBF
	MOV	#TAB,R1			; Tab to output
	CALL	PBYT			; To temporary buffer
	CALL	PUTPAG			; Page number into buffer
	MOV	BF.FUL(R3),R2		; Count
	MOV	BF.ADD(R3),R1		; Address
	INC	R1			; Plus 1
	SUB	R2,R1			; Start address
	JMP	OUTTOC			; Output to TOC
10$:	RETURN

;
; HEADER COMMAND
;
	.ENABL	LSB

HEADU::	MOV	#UPPER,R0	; Header upper
	BR	HEAD1
HEADM::	MOV	#MIXED,R0	; Header mixed
	BR	HEAD1
HEADL::	MOV	#LOWER,R0	; Header lower
HEAD1:	MOV	#PAGHD,R1	; POINT TO PAGE HEADER AREA
40$:	MOVB	(R0)+,(R1)+	; MOVE PROTOTYPE
	BNE	40$		; IF NE MORE TO GO
HEADP::	BICB	R5,$HDRSW	; Set to print page headers
	RETURN			; 
50$:	CALL	CCIN		; READ NEXT CHARACTER
	CMPNEB	(R0),#GC.LC,60$	; not lower case?
	BIC	#^o40,R1	; CONVERT TO UPPER CASE
60$:	RETURN			; 
;
; NOHEADER COMMAND
;
NHEAD::	BISB	R5,$HDRSW	; SET TO NOT PRINT PAGE HEADERS
	RETURN			; 
	.DSABL	LSB
	.ENABL	LSB
;
;	HEADER PAGE COMMANDS
;
HPAGE::	CLRB	$PAGSW		; SET 'PAGE' ON
	RETURN			; 
HNOPG::	MOVB	#-1,$PAGSW	; SET 'PAGE' OUTPUT OFF
	RETURN			; 
;
;	HEADER SPACING
;
HEDSP::	CALL	(R4)		; GET PARAMETER
	BCS	10$		; Default
	CALL	CVSP		; Convert vertical spacing
	BR	20$
10$:	MOV	NSPNG,R3	; USE LINE SPACING AS DEFAULT
20$:	CMP	R3,#MAXPS*LINSP	; TOO BIG?
	BGT	ERRGT		; Too big  ?
	CMP	R3,#LINSP	; Check lower bound
	BGE	30$		; Big enough ?
	MOV	#LINSP,R3	; Set it to line spacing
30$:	MOV	R3,HSPAC	; SAVE HEADER SPACING
	RETURN
ERRGT:	MOV	#1.,R0		; Param error message
	BR	ERR
ERRLT:	MOV	#2,R0		; Too small error message
ERR:	JMP	ILCMA
	.DSABL	LSB

;
;	HEADER LEVEL COMMAND
;
HEADR::	MOVB	LEVEL,R3	; Initial level #
	MOV	R3,R2		; And save it
	BNE	1$		; Not zero ?
	INC	R3		; Make it 1
1$:	CALL	(R4)		; GET HEADING LEVEL NUMBER
	CMP	R3,#LEVSIZ	; Level too big?
	BGT	6$		; Param too big
	TST	R3		; Is level too small?
	BGT	10$		; No
	MOV	#2,R0		; Param too small
	BR	7$
6$:	MOV	#3,R0		; Param too big
7$:	JMP	ILCMA
10$:	MOVB	R3,LEVEL	; Save level number
	INDXA	R2		; Now index address
	INDXA	R3
	ADD	#LEVNM,R3	; Point to current level + 1
	ADD	#LEVNM,R2	; Point to previous level + 1
	CLR	(R3)		; Clear next level
	INC	-(R3)		; Increment current level
	MOV	R3,LSAV		; Current level
15$:	CMP	R3,R2		; Current > previous
	BLO	20$		; No
	MOV	#1,(R2)+	; Set levels to 1
	BR	15$		; Not yet
20$:	CMPB	LEVEL,OUTLV	; Current level too big?
	BLE	25$		; Level number is ok
	JMP	COMNT		; Kill text at end of command.
25$:	TSTEQB	$AUSTL,27$	; No autosubtitle?
	CMPB	LEVEL,STLLV	; Level low enuf?
	BGT	27$		; No
	MOV	CASE,-(SP)	; Save current case
	CALL	SETCAS		; Set correct case
	CALL	STLSV		; Set up subtitle
	MOV	(SP)+,CASE	; Restore
27$:	MOVB	BEGLV,R2	; SET LINE COUNT
	BEQ	30$		; None
	CALL	SKPNIF		; Skip lines by line count
30$:	MOVB	TPGLV,R1	; SET TEST PAGE VALUE
	CALL	TESTT		; Test if room on current page
	CMPB	LEVEL,TOCLV	; Do TOC this level?
	BGT	35$		; No !!
	CALL	BUFTOC		; Output command to TOC
35$:	MOV	RMARG,-(SP)	; Save right margin
	MOV	LMARG,-(SP)	; Save margin
	MOVB	LIDLV,R1	; Margin changes
	MOVB	RIDLV,R2
	CALL	SETMRG		; Set them
	CALL	LINBEG		; Start new line
	MOV	#LVSTAT,R2	; Level status buffer
	CALL	RSTAT		; Restore status
	MOV	#CHPMG,SAVA	; Points to Headers
	MOV	#CHPM2,SAVB
	MOVB	LEVEL,R0	; Current level
36$:	ADD	#CH.HD1+1,SAVA	; Next entry
	ADD	#CH.HD2+1,SAVB	; "
	SOB	R0,36$		; Find current level
	CALL	SETINS		; Get input temporary
	TSTNEB	@SAVA,37$	; Header ??
	TSTEQB	@SAVB,38$	; No second header ??
37$:	CALL	ESCCLR		; Set No escapes or underlining
	INC	LSTAT		; Set escape set
	MOV	SAVA,R0		; heading
	CALL	PSTRZB		; Into temporary input
38$:	MOVB	LEVEL,R0	; Get level #
	CMPB	R0,NONLV	; Check No number level
	BLT	39$		; Number level ?
	JMP	66$		; No
39$:	CLR	-(SP)		; end of numbers
	MOV	LSAV,R2		; Get index
	CMPB	R0,UNILV	; Unitary level number
	BGT	50$		; unitary ??
	MOV	#APNDN,R2	; POINT TO CHAPTER/LEVEL TABLE
	MOV	(R2)+,R1	; Current appendix number
	BEQ	40$		; IF EQ NONE
	BIS	APNDSP,R1	; format
	MOV	R1,-(SP)	; appendix to convert
	BR	45$		; Continue with rest of levels
40$:	TSTNE	(R2),50$	; Chapter oriented document?
45$:	TST	(R2)+		; Skip chapter number
50$:	MOV	(R2)+,R1	; Current chapter or level number
	BEQ	60$		; Last one?
	BIS	CHPDSP-CHPTN-$WORDL(R2),R1	; set display format
	MOV	R1,-(SP)	; save for conversion
	BR	50$		; more
60$:	CMPB	LEVEL,UNILV	; Unitary level number
	BGT	65$		; Unitary ??
	TSTNE	APNDN,65$	; Chapter oriented?
	CMPNEB	LEVEL,#1,65$	; Not first level?
	TSTNE	CHPTN,65$	; Chapter oriented?
	TSTNEB	$TRZER,65$	; No trailing zeroes ?
	MOV	#NM.DEC,-(SP)	; Terminating 0
65$:	MOVB	#PD,$SEPR	; digit separator
	CALL	PAGCV		; convert numbers
	BGT	66$		; Yes, no header
	MOV	SAVB,R0		; post-heading
	CALL	PSTRZB		; Into input
66$:	CALL	INOUT		; Output the number
	MOVB	LEVEL,R2	; Level index
	CMPB	R2,NONLV	; No number level
	BGE	80$
	MOVB	SPCLV,R4	; Get number of spaces to indent
	CMPB	R2,LINLV	; Run in level
	BGE	67$		; Yes ?
	CMPB	R2,CENLV	; Centered level
	BGE	70$		; Yes ?
67$:	MOVB	TIDLV-1(R2),R0	; Absolute indent
	SUB	SPCH,R0		; Subtract off number of chars.
	CMP	R4,R0		; compare spaces with offset
	BGT	70$		; Spaces larger ?
	MOV	R0,R4		; Use offset
70$:	TST	R4		; Test result
	BLE	80$		; None!
	MOV	#NXS,R1		; Get quoted space to write
75$:	TST	LINBK
	BLE	80$		; Done ??
	CALL	CCBYT		; 
	SOB	R4,75$		; Output all spaces
80$:	CALL	$FRCND
	CMPNEB	R1,#CR,81$	; Not end of line ?
	JMP	120$		; End of line?
81$:	MOV	CASE,-(SP)	; Save current case
	CALL	SETCAS		; Set correct case
	CMPB	LEVEL,CENLV	; Not center it?
	BLT	90$		; Yes
	CMPB	LEVEL,LINLV	; Run in level
	BGE	90$		; Yes, do not center it
	BISB	#SW.TDS,$CENSW	; Set to center it
	BR	92$
90$:	MOV	SPCH,R1		; Check on total char count
	CLR	R2		; No right margin change
	CALL	SETMRG		; Try to reset margin
	BCS	92$		; Yes skip margin change
	ADD	R1,LINBK	; Reset chars/line
	NEG	R1
	MOV	R1,INDCT	; Negative indentation first time
92$:	BISB	#SW.IDS,$AUHYP	; Prevent hyphenation
	BISB	#SW.IDS,$IFLSW+1; Prevent indexing
	CALL	LIN		; Transfer lines to buffer
	MOVB	LEVEL,R2	; GET LEVEL #
	DEC	R2
	INDXA	R2		; Now have word index
	TSTEQ	LSTAT,93$	; Pre-header not used ??
	CALL	ENDESC
93$:	BICB	#SW.IDS,$AUHYP	; Now allow it again
	BICB	#SW.IDS,$IFLSW+1; Now allow it again
	MOV	(SP)+,R1	; Old case
	MOV	R1,CASE		; No, restore previous
	MOV	R1,CASSAV	; And saved case
95$:	TSTNEB	$TOCBE,120$	; TOC in progress?
	CMPB	LEVEL,LINLV	; Level >= run on line value
	BGE	110$		; Yes
	CALL	OUTNJ		; OUTPUT HEADING LINE
	BICB	#SW.TDS,$CENSW	; Reset centering
	MOVB	ENDLV,R2	; SET LINE COUNT
	BEQ	100$		; None
	CALL	SKPNIF		; Skip lines
100$:	MOV	(SP)+,LMARG	; Restore margins
	ADD	(SP),LINBK	; Reset line length
	SUB	RMARG,LINBK	; 
	MOV	(SP)+,RMARG	;
	JMP	LGO
110$:	CALL	LINBEG
	CMP	LINBK,#3	; Room for 3 more?
	BLE	120$		; No
	MOVB	#NXS,R1		; insert space
	CALL	CCBYT
	MOVB	#MINUS,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$
;
;	routine to set correct case
;
SETCAS:	CMPB	LEVEL,MIXLV	; Capitalize first char?
	BGT	10$		; No
	BIS	#^o1002,CASE	; Yes
10$:	CMPB	LEVEL,CAPLV	; Higher than min capitalize level
	BGT	20$		; Yes
	MOV	#^o401,CASE	; Shift to upper case
20$:	RETURN

;
;	LIST command
;
LISTC::	MOV	LSTKP,R0	; GET CURRENT LIST STACK POINTER
	CMP	R0,#TKPEND 	; LIST STACK OVERFLOW?
	BHIS	40$		; IF HI YES
	MOV	LMARG,LS.MRG(R0); SAVE LEFT MARGIN
	ADD	#LS.SIZ,R0
	CLR	(R0)		; CLEAR CURRENT LIST ELEMENT NUMBER
	MOV	R0,LSTKP	; New stack address
	CALL	GETVS		; Get list vertical spacing
	MOV	LSTKP,R0	; GET CURRENT LIST STACK POINTER
	MOVB	R3,LS.VSP(R0)	; SET NEW LIST VERTICAL SPACING
	MOV	#LSLMAR,R1	; ASSUME EMBEDDED LIST INDENT
	CMPNE	#LSTK+LS.SIZ,R0,10$	; NOT FIRST ITEM IN STACK?
	MOV	#LOLMAR,R1	; SET FOR INITIAL LIST INDENT
10$:	CLR	R2		; No right margin change
	CALL	SETMRG		; Set margin
	BCS	30$		; Bad ?
	CALL	GETLIT		; Now get literal
	BCS	20$		; None ?
	MOV	R0,R2		; Character address
	MOV	LSTKP,R0	; GET CURRENT LIST STACK POINTER
	MOVB	(R2),LS.CHR(R0)	; Save character
	CMP	R1,#1		; Is number of chars too many ?
	BLOS	20$		; No
	MOV	#51.,r0		; Literal too long
	JMP	ILCMA
20$:	RETURN
30$:	MOV	#13.,R0		; Warn user about overlap error
	BR	50$
40$:	MOV	#35.,R0		; List level overflow
50$:	JMP	ILCMA		; Output error message
;
;	Get the vertical spacing
;
GETVS:	CALL	(R4)		; Get list vertical spacing
	BCC	1$		; Found number ?
	  MOV	PARSP,R3	; Default spacing
1$:	CMP	R3,#MAXPS	; LEGAL VALUE?
	BLOS	20$		; yes ?
	JMP	ERRHI		; IF HI NO
	RETURN
10$:	MOV	PARSP,R3	; Paragraph spacing
20$:	RETURN
ERRHI:	MOV	#8.,R0		; Param too big or negative
	JMP	ILCMA
;
; END LIST COMMAND
;
ELIST::	CALL	GETVS		; Get final vertical spacing
	MOV	LSTKP,R4	; GET CURRENT LIST STACK POINTER
	CMP	R4,#LSTK	; Unexpected end?
	BLOS	20$		; Yes, Do not unstack
	SUB	#LS.SIZ,R4	; New address
	MOV	R4,LSTKP	; SAVE NEW LIST STACK POINTER
	MOV	LS.MRG(R4),LMARG ; Restore left margin
	MOV	R3,R1		; Final skip count
	JMP	SKPLIF		; Skip lines if not at top of page
20$:	MOV	#30.,R0		; Unexpected endlist
	JMP	ILCMA		; Output error message

;
;	LIST ELEMENT COMMAND
;
LSTEL::	MOV	LSTKP,R4	; Get stack pointer
	MOVB	LS.VSP(R4),R1	; GET LIST ELEMENT VERTICAL SPACING
	CALL	SKPLIF		; SKIP LINES
	CALL	PART0		; Break page if necessary
	MOV	LSTKP,R4	; Get stack pointer
	INC	(R4)		; INCREMENT LIST ELEMENT NUMBER
	BNE	10$		; Non zero?
	INC	(R4)		; INCREMENT LIST ELEMENT NUMBER
10$:	CMP	(R4),#4000.	; Too big ?
	BLO	15$		; No
	MOV	#1,(R4)		; Reset it
15$:	CALL	LINBEG		; Begin new line
	CALL	SETINS		; Get input temporary
	MOV	LSTKP,R4	; Current list stack
	MOVB	LS.CHR(R4),R1	; Get list character
	BNE	30$		; Any ?
	MOVB	LS.PRE(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
	MOV	(R4),-(SP)	; GET CURRENT ELEMENT NUMBER
	BIS	LS.FMT(R4),(SP)	; Set the format bits
	CALL	PAGCV		; convert numbers
	MOVB	LS.PST(R4),R1	; Second char
	CMP	R1,#SPC		; Space or less?
	BGE	30$		; No, char is OK
	MOV	#PD,R1		; GET PERIOD
30$:	CALL	PBYT		; WRITE PERIOD INTO BUFFER
	CALL	INOUT		; Output number
	MOV	#NXS,R1		; GET NON EXPANDABLE SPACE
	CALL	CCBYT		; WRITE QUOTED SPACE INTO BUFFER
	CALL	CCBYT		; WRITE ANOTHER QUOTED SPACE
	MOV	SPCH,R1		; Char count
	MOV	LMARG,R0	; Check left margin
	ADD	INDCT,R0	; Add in indentation
	SUB	PLMRG,R0	; Find difference from permanent margin
	BLE	50$		; smaller
	SUB	R1,R0		; Is indent too large?
	BGE	40$		; No
	ADD	R0,R1		; Yes, correct it
40$:	ADD	R1,LINBK	; Add extra to line counter
	SUB	R1,INDCT	; Indentation
50$:	CALL	$FRCND		; FORCE TO LOGICAL END OF COMMAND
	TST	(SP)+		; CLEAN STACK
	JMP	TEXTF		; Process text immediately

;
;	END NOTE COMMAND
;
ENOTC::	BITEQ	#NOTF,F.1,20$	; Note not in progress?
	MOV	NOTSV,F.1	; RESTORE FLAGS WORD
	MOV	NOTRM,RMARG	; INCREASE RIGHT MARGIN
	MOV	NOTLM,LMARG	; DECREASE LEFT MARGIN
	CALL	(R4)		; Get skip after note
	BCC	1$		; Found number ?
	  MOV	#NFSPAC,R3	; SET SKIP COUNT
1$:	MOV	R3,R1
	CMP	R1,#MAXPS	; Compare with maximum paragraph spacing
	BLOS	10$		; Ok ?
	JMP	ERRHI		; Too big ?
10$:	JMP	SKPLIF		; SKIP LINES
20$:	MOV	#29.,R0		; Message number
	JMP	ILCMA		; Bad end note
;
;	NOTE COMMAND
;
NOTE::	MOV	#NHSPAC,R1	; Pre line count 
	CALL	SKPLIF		; SKIP LINES
	MOV	LMARG,NOTLM	; Save margins
	MOV	RMARG,NOTRM	; Save margins
	MOV	RMARG,R0	; Get right margin
	SUB	LMARG,R0	; Minus left margin
	ASR	R0		; Half of difference
	ASR	R0		; One fourth of difference
	ASR	R0		; Now 1/8
	MOV	#NPMARG,R1	; Note margin
5$:	CMP	R0,R1		; Margin too wide?
	BGE	10$		; No ?
	SUB	#NSMARG,R1	; Secondary indent
	BGT	5$		; Not zero
	ADD	#NSMARG,R1	; Secondary indent
10$:	CALL	SETMRS		; Margins set?
	BCC	20$		; Yes
15$:	MOV	#MRGERR,R0	; Error message
	CALL	ILCMC		; Output error
20$:	MOV	F.1,NOTSV	; SAVE CURRENT FLAGS WORD
	BIS	#FILLF!JUSTF!PJUSTF!NOTF,F.1 ;SET FLAGS
	MOV	#NASPAC+1,R1	; post line count
	ADD	PARPT,R1	; Plus test page count
	CALL	PART1		; Use paragraph test page
	CALL	LINBEG		; Start new line
	BISB	#SW.TDS,$CENSW	; SET UP TO CENTER TEXT
	BISB	#SW.IDS,$IFLSW+1; Prevent indexing
	CALL	$FRCND
	CMPEQ	R1,#CR,25$	; End of line ?
	CALL	GCIN		; Get line
	CALL	BKSPI		; Backspace to LF
	TSTNE	SPCH,30$	; Any text ?
25$:	MOV	#NOTET,R2	; POINT TO NOTE TEXT PROTOTYPE
	CALL	TMPIN		; Set up in buffer
	CALL	GCIN
30$:	BICB	#SW.IDS,$IFLSW+1; Now allow it again
	MOV	#NASPAC,R1
	CALL	MULSP		; Get line adjusted
	MOV	R1,EQBOT	; SET bottom LINE COUNT
	JMP	OUTLIN		; OUTPUT THE TEXT
;
;	Routine to reduce margins
;
;		R1=left reduction
;		r2=right reduction
;		r0=destroyed
;
SETMRS:	MOV	R1,R2		; Both left and right
SETMRG: MOV	RMARG,R0
	SUB	LMARG,R0
	SUB	R1,R0
	SUB	R2,R0		; Total margins
	CMP	R0,#MINLN	; Too small??
	BGE	1$		; No
	SEC
	RETURN
1$:	MOV	#LMARG,R0	; Margin
	ADD	R1,(R0)		; New left
	CMP	(R0)+,PLMRG	; Is left margin big enough?
	BGE	10$		; Yes
	ADD	-(R0),R1	; Compensate R1
	SUB	PLMRG,R1	; Now is actual indent
	MOV	PLMRG,(R0)+	; And is permanent margin
10$:	SUB	R2,(R0)		; New right
	CMP	(R0),PRMRG	; Is right margin small enough?
	BLE	20$		; Yes
	SUB	(R0),R2		; Compensate R2
	ADD	PRMRG,R2	; Now is actual indent
	MOV	PRMRG,(R0)	; And is permenant margin
20$:	SUB	R1,LINBK	; New char count
	SUB	R2,LINBK	; New char count
	CALL	STCMRG		; No!
	CLC
	RETURN
;
;	Set up center margin
;
STCMRG:	MOV	RMARG,R0	; Get right margin
	ADD	LMARG,R0	; Sum of right and left margins
	ASR	R0		; Divide by 2
	MOV	R0,CMARG	; Set for center margin
	RETURN

;
;	put byte and incrment counter
;
CCBYT:	CMPNEB	R1,#SPC,10$	; not space?
	CALL	BRKSV		; Set break here
	INC	SPCNT		; increment space count
	MOV	#SPC,R1		; Save space
10$:	JMP	PUBYT		; Put underlined byte
;
; SUBTITLE COMMAND
;
SETSTL::CLR	STLCAS
SETST1:	MOV	#STLBF,R3	; SUBTITLE BUFFER
	MOV	#STLHD2,-(SP)	; Header addresses
	MOV	#STLHD1,-(SP)	; Header addresses
	BR	SETBF		; 
;
;	no title command
;
NTITL::	MOVB	#-1,$NTITL	; set no title print
	RETURN
;
;	FIRST TITLE COMMAND
;
UCTTL:	MOV	#^o401,TTLCAS	; Shift to upper case
	BR	SETTL1
FTITL::	BITNE	#LCKF,F.1,SETTL	; Params locked?
	CLRB	$HDRSW		; ENABLE HEADER ON FIRST PAGE
;
;	TITLE COMMAND
;
SETTL::	CLR	TTLCAS		; No title case
settl1:	MOV	#TTLBF,R3	; SET FOR TITLE BUFFER
	BITEQ	#LCKF,F.1,10$	; param not locked?
	CLRB	$NTITL		; set for print of titles
10$:	MOV	#TTLHD2,-(SP)	; Header addresses
	MOV	#TTLHD1,-(SP)	; Header addresses
SETBF:	CALL	CLRBF		; SET BUFFER EMPTY
	MOV	(SP)+,R0	; Get pre-header
	CALL	PSTRZB
	CALL	$FRCND		; FORCE TO LOGICAL END OF COMMAND
	CLR	BF.SPC(r3)
10$:	CALL	CCIN		; READ TITLE OR SUBTITLE
	CMPEQB	R1,#CR,15$	; Done ??
	CALL	PBYT		; Save the char
	INC	BF.SPC(r3)
	BR	10$		; Continue with more
15$:	MOV	(SP)+,R0	; Get pre-header
	CALL	PSTRZB
	TSTNE	BF.SPC(R3),17$	; Any chars stored ??
	CALL	CLRBF
	BR	20$		; No title/subtitle
17$:	MOV	BF.FUL(R3),BF.SPC(R3)	; Get total char count
	TSTNEB	$HDSTS,20$	; Permanent status set ?
	MOV	#HDSTAT,R2	; No, save status
	CALL	SSTAT
20$:	RETURN			;
;
;	SEND PAGE TOC command
;
SENPTC::CALL	(R4)		; get parameter
	BCC	1$		; Found number ?
	  CLR	R3		; Default value
1$:	CMP	R3,#9.		; Check max
	BLOS	2$		; OK ?
	JMP	ERRHI
2$:	TSTEQB	$TOCSW,3$	; TOC?
	JMP	COMNT		; No, treat text as comment
3$:	MOV	R3,R5		; Save param
	CALL	LINFAK		; Get output buffer address in R3
	MOV	#IFTXT,R2	; Get if text
	CALL	IFOUT
	CALL	$FRCND		; Get beginning of line
	MOV	#TOCX,R1	; TOC flag
	CALL	PBYT
	MOV	#1,R1		; Output status
	CALL	PBYT		; Set to output number
	MOV	#72.,R4		; Max number of chars
10$:	CALL	CCIN		; Get input
	CMPEQB	R1,#CR,20$	; End ??
	CALL	PBYT		; Save it
	SOB	R4,10$		; Till full
20$:	CALL	CBYT		; Done
	MOV	#EITXT,R2	; Now end if text
	TSTNE	BF.HED(R3),IFOUT; Header exists ?
	CALL	IFOUT
	CALL	CBYT		; Chock line
	RETURN
IFOUT:	TSTEQ	R5,10$		; No param or null ?
1$:	MOVB	(R2)+,R1	; Get byte to trans
	BEQ	5$		; Done ??
	CALL	PBYT		; Put into output
	BR	1$
5$:	MOV	R5,R1		; With number
	ADD	#zero,R1	; Convert to number
	CALL	PBYT
	CALL	CBYT		; to chock end
10$:	RETURN
;
;	Output a number
;
INOUT:	MOV	#LF,R1
	CALL	PBYT
	MOV	BF.SPC(R3),R1	; Get beginning of string
	CALL	FNDBF		; Reset to beginning
	CALL	OUTAD		; Get output buffer
	MOV	F.1,-(SP)	; Save status
	BIC	#FILLF,F.1	; Set no fill
	BISB	#^o40,$NOSPC	; Set no spaces
	CALL	GCIN		; Get number
	BICB	#^o40,$NOSPC	; Restore
	MOV	(SP)+,F.1	; Restore
	JMP	POPINS		; Pop input
	.END