.TITLE RUNOFF
	.IDENT	/M02/
	.IDENT	/M02.1/
	.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
;
; SIG MODIFICATIONS								;**NEW**
;	SIG01		CLEAN UP OPERATOR WAIT					;**NEW**
;	SIG02		RSTS CHANGES						;**NEW**
;
; CARTS LUG MODIFICATIONS
;	CAR  1			ADD CHANGE BARS AND RIGHT SHIFT FUNCTION
;
; B.F.BRUCE / CAMB. COMPUTER ASST. AUG 81 /M02.2/
;	/BT FOR BOOK STYLE TITLING
;	/SC FOR DIABLO / NEC SPINWRITER SHIFTING 1/120" FOR BOLDING
;
; THIS PROGRAM WAS TRANSLATED FROM THE PDP-10 VERSION OF RUNOFF
; AUTHORED BY B. CLEMENTS.
;
;	LOCAL MACROS
;
	.MACRO	MSGPUT	NAM
	CALL	$ERMSG
	.WORD	MG'NAM
	.ENDM
;
; SIMULATED ACCUMULATOR DEFINITIONS

F.1::	.WORD	0
S1::	.WORD	0

;
; FLAG BITS IN F.1
;
;	NOTE: THE LOW ORDER BYTE CORRESPONDS TO A LEGAL COMMAND MASK
;		THAT IS TESTED AGAINST THE TRAILING BYTE OF THE
;		APPROPRIATE COMMAND NAME.
;

NOTF==1				;NOTE PROCESSING ACTIVE
FOTF==2				;FOOTNOTE PROCESSING ACTIVE
RELF==4				;RELATIVE NUMBER CONVERSION (1=YES)
FPGF==20			;FLUSH PENDING PAGE (1=YES)
ENDF==40			;CORRESPONDS TO END FLAG IN TRAILING BYTE
BRKF==100			;CORRESPONDS TO BREAK FLAG IN TRAILING BYTE
JUSTF==400
PJUSTF==1000
FILLF==2000
LITFG==4000			;LITERAL PROCESSING FLAG
SPECF==20000			;SPECIAL COMMAND PROCESSING

;
; SWITCH WORD FLAG BIT DEFINITIONS
;

FFDSW==1			;SIMULATE FORM FEEDS (0=YES)
HYPSW==2			;HYPHENATE OUTPUT TEXT (1=YES)
PAUSW==4			;PAUSE BETWEEN PAGES (1=YES)
SPLSW==10			;SPOOL TEXT FILE (1=YES)
UPCSW==20			;FORCE ALL TEXT TO UPPER CASE (1=YES)
CBBIT==1			;CHANGE BAR ON					;CAR  1
CBFBT==2			;CHANGE BAR JUST TURNED OFF			;CAR  1

;
; SWITCH WORD FLAG BIT DEFINITIONS FOR $SWTC2
;

DIABSW==1			; DIABLO / NEC SPINWRITER WITH VARIABLE PITCH
BKTNSW==2			; BOOK TITLING NORMAL (OFF = REVERSED)
BKTISW==4			; BOOK TITLING ON IF SET
BSMSK == 10			;use backspaces for emphasis
ULMSK == 20			;no underlining
DKMSK == 40			;no dark
UDMSK == 100			;convert underlines to dark
DUMSK == 200			;convert dark to underlined
DSMSK == 400			;underline via dashes

;
; SWITCH FLAGS (BYTE)
;

$HDSSW::.BLKB	1		;DISABLE PAGE HEADER (0=NO)
$GCISW::.BLKB	1		;INPUT FROM REREAD BUFFER (0=NO)
$SDISW::.BLKB	1		;INPUT FROM SECONDARY INPUT BUFFER (0=NO)
$ULMSW::.BLKB	1		;UNDERLINE MODE (0=NO BACKSPACE)
$ULNSW::.BLKB	1		;UNDERLINE SUPPRESS (0=NO)
$ULSSW::.BLKB	1		;UNDERLINE SIMULATE (0=NO)
	.EVEN

;
; SWITCH FLAGS (WORD)
;

HPHSW:	.BLKW	1		;HYPHENATION ENABLED FOR OUTPUT (0=NO)
TJFSW:	.BLKW	1		;TEMPORARY JUSTIFY FLAG (0=NO)
$AUTSW::.BLKW	1		;AUTOPARAGRAPH ACTIVE (0=NO)
$CFLSW::.BLKW	1		;FLAG CAPITALIZE ENABLE (0=NO)
$HDRSW::.BLKW	1		;PRINT PAGE HEADERS (0=NO)
$HFLSW::.BLKW	1		;FLAG HYPHENATE ENABLE (0=NO)
$HPHSW::.BLKW	1		;HYPHENATION ACTIVE (0=NO)
$NUMSW::.BLKW	1		;NUMBER PAGES (0=NO)
$PGPSW::.BLKW	1		;PAGE PENDING (0=NO)
$PERSW::.BLKW	1		;PUNCTUATION DOUBLE SPACING (0=NO)
$SBPSW::.BLKW	1		;SUBPAGE MODE ACTIVE (0=NO)
$ULLSW::.BLKW	1		;UNDERLINE LOCK ON (0=NO)
$ULDSH::.BLKW	1		;underline with dashes (next line)
$CBON::	.BLKW	1		;CHANGE BAR ON ( 0=NO)				;CAR  1
$SWTC2::.BLKW	1		;NEW FEATURES SWITCH, SEE BITS ABOVE
BKTITP::.BLKW	1		;'N' OR 'R' FROM /TI:, IF SPECIFIED.

;IMPURE STORAGE


RMARG::	.WORD	0
LMARG::	.WORD	0
PRMRG::	.BLKW	1		;PERMANENT RIGHT MARGIN
CAS::	.WORD	0
WCAS::	.BLKW	1		;WORD CAPITALIZE CONVERSION VALUE
APNDN::	.BLKW	1		;CURRENT APPENDIX LETTER
CHPTN::	.BLKB	2		;CURRENT CHAPTER NUMBER
	.BLKB	10.		;CURRENT HEADING LEVEL NUMBERS
CMADR::	.BLKW	1		;SPECIAL PROCESSING COMMAND ADDRESS
PAGENO::.WORD	0
PARPT::	.BLKW	1		;PARAGRAPH PAGE TEST COUNT
PARSP::	.BLKW	1		;PARAGRAPH SPACING COUNT
PARIND::.WORD	0
NSPNG::	.WORD	0
LINEC::	.WORD	0
SUBPGE::.WORD	0
LITCM::	.BLKW	1		;SAVED EXPECTED COMMAND ADDRESS (LITERAL)
LITSV::	.BLKW	1		;SAVED FLAGS MASK ON LITERAL PROCESSING
LSTPT::	.BLKW	1		;LIST ELEMENT PAGE TEST COUNT
LSTVS::	.BLKW	1		;LIST ELEMENT VERTICLE SPACING
LSTKP::	.BLKW	1		;CURRENT LIST STACK POINTER
LSTK::	.BLKW	5*3		;LIST STACK (5 ENTRIES)
LSTCT::	.BLKW	1		;CURRENT LIST ELEMENT COUNT
NOTCM::	.BLKW	1		;SAVED EXPECTED COMMAND ADDRESS (NOTE)
NOTLM::	.BLKW	1		;NOTE SAVED LEFT MARGIN
NOTRM::	.BLKW	1		;NOTE SAVED RIGHT MARGIN
NOTSV::	.BLKW	1		;SAVED FLAG WORD ON NOTE PROCESSING
EBSIZ:: .BLKW	1		;NUMBER OF CHANGE BAR INITAL SPACES		;CAR  1
				; -1 => NEG, +1 => POS, 0 => NONE		;CAR  1


TABTL==32.
TABTAB::.BLKB	TABTL
NTABS::	.WORD	0

NLPG::	.WORD	0
PNLPG::	.WORD	0

IDXINP::	0		;non-0 => index in process
FOOTC::		0
$FLOW::		0		;non-0 => flow in effect
$TAB::		0		;number of saved tabs (line to line)
XISECT::	0
XJSECT::	0
XKSECT::	0
XLSECT::	0
XMSECT::	0
FNSECT::	0
TCSECT::	0
WKSTOP::	0
WKBYSZ::	0
WKSCSZ::	0
CWSECT::	0
FOOTWB::.BLKB	322.								;CAR  1
FOOTS1::.WORD	FOOTWB-1							;CAR  1
FOOTS2::.WORD	FOOTWB-1							;CAR  1
	.WORD	FOOTWB+322.							;CAR  1


; USER-SET TEMPS

INDCT::	.WORD	0
TTLIN==72.
TTBUF::	.BLKB	TTLIN
TTILIN==82.
TTIBUF::.BLKB	TTILIN
HFIN::	.WORD	320.,0,0							;CAR  1
INBUF::	.BLKB	322.								;CAR  1
HFOUT::	.WORD	256.,0,0							;**-2
OUBUF::	.BLKB	256.
; GENERAL

T1::	.WORD	0
T2::	.WORD	0

LCH::	.WORD	0
NCNT::	.WORD	0
LOWPAG::.WORD	0		;LOWEST PAGE TO PRINT
HGHPAG::.WORD	0		;HIGHEST PAGE TO PRINT
PAGHD::	.BLKB	6		;PAGE NUMBER TEXT PROTOTYPE
LPPG::	.BLKW	1		;HARDWARE LINES PER PAGE
HWLPP::	.WORD	HWPLN		;INITIAL VALUE FOR LPPG
INI$SW::.WORD	HYPSW!SPLSW	;INITIAL VALUE FOR $SWTCH
IUL::	.WORD	'N		;INITIAL UNDERLINE SWITCH



; LINE TEMPS
LINBK::	.WORD	0
SPCNT::	.WORD	0
LSTSP::	.WORD	0
LINNSC::.WORD	0

LNIN1::	.WORD	LINBF-1
LNIN2::	.WORD	LINBF-1
	.WORD	LINBF+320.							;CAR  1
LOUT1::	.WORD	0								;CAR  1
LOUT2::	.WORD	0								;CAR  1
LINBF::	.WORD	0								;CAR  1
	.BLKB	322.								;CAR  1
										;**-5
GCINP::	.WORD	0
GCIN2::	.WORD	0
GCSCH::	.BLKB	1		;SAVED CHARACTER FOR REPROCESSING
ULMCH::	.BLKB	1		;SAVED CHARACTER FOR UNDERLINING

SDINP::	.WORD	SDBUF-1		;SECONDARY INPUT LINE DESCRIPTOR
	.WORD	SDBUF-1		;
	.WORD	SDBUF+132.	;SECONDARY INPUT BUFFER GUARD WORD
SDBUF::	.BLKB	134.		;SECONDARY INPUT BUFFER

CMSTP::	.WORD	CMBF-1
CMST2::	.WORD	CMBF-1
	.WORD	CMBF+132.
CMBF::	.BLKB	134.
ECMBF=.-1

TWIDE:	.WORD	0		; TITLE LINE WIDTH
PGSTRL:	.WORD	0		; LEN OF DATA IN PGSTR
PGSTR:	.BLKB	20.		; PAGE NO. STRING "PAGE... " - ASCIIZ

TRUTTL:	.WORD	0		; LENGTH OF TITLE ON LINE (SPACE USED)
TTLP1::	.WORD	TTLBUF-1
TTLP2::	.WORD	TTLBUF-1
	.WORD	TTLBUF+132.
TTLBUF::.BLKB	134.
STTLP1::.WORD	STTLBF-1
STTLP2::.WORD	STTLBF-1
	.WORD	STTLBF+132.
STTLBF::.BLKB	134.
EXSP1::	.WORD	0
EXSP2::	.WORD	0
EXSP3::	.WORD	0

; FOR TOC									;CAR  1
MXTOCN::	0
										;CAR  1
; HOW TO EMPHASIZE FIELD CURRENTLY BEING UNDERLINED				;CAR  1
ULTYP::	.WORD 0		; 0 = UNDERSCORE					;CAR  1
			; NZ = OVERPRINT					;CAR  1
										;CAR  1
; HOW TO EMPHASIZE UNDERLINED FIELDS MARKED BY					;CAR  1
; INSTREAM SOMMAND CHARACTERS ("&").						;CAR  1
DFULT::	.WORD	0	; 0 = UNDERSCORE					;CAR  1
			; NZ = OVERPRINT					;CAR  1
										;CAR  1
; TO TRACK THE CHARACTER TO BE PRINTED FOR UNDERSCORE (OR OVERPRINT)		;CAR  1
ULCHRX:	.WORD	0								;CAR  1
DKCHRX:	.WORD	0
DSCHRX:	.WORD	0
										;CAR  1
; SWITCH USED IN OUTPUT, TO HANDLE UNDERSCORE JUNK				;CAR  1
ULCASE:	.WORD	0	; 0 = JUST PRINT THE CHARACTER				;CAR  1
			; 1 = OVERPRINT THE CHAR BY BACKSPACE			;CAR  1
			; 2 = SIMULATE UNDERSCORE BY DASH ON NEXT LINE		;CAR  1
			; 3 = OVERPRINT UNDERSCORE ON SAME LINE			;CAR  1
			; 4 = OVERPRINT THE CHAR ON SAME LINE (DARK)		;CAR  1
			; 5 = Underline by backspacing
										;CAR  1
CHSAVE:	.WORD	0	; TEMP SAVE CHAR					;CAR  1
RELTAB::.WORD	-1	; THE COLUMN TO MAKE TABS RELATIVE TO (NORMALLY 0)	;CAR  1
STDLM::	.WORD	ILMRG	; STANDARD LEFT MARGIN					;CAR  1
ABSPAG::.WORD	1	; THE ABSOLUTE PAGE NUMBER FOR /PA SWITCH		;CAR  1
CPI::	.WORD	0	; FOR LA120 SIZE					;CAR  1
NSLA120::.WORD	0	; NZ = LA120 SIZE CHANGED---MUST RESTORE IT		;CAR  1
FIGSAV::.WORD	0	; FIGURE HELD OVER FOR NEXT PAGE			;CAR  1
NSPCH::	.WORD	0	; NON SPACING CHARACTER COUNT
LSTNSP::.WORD	0
ULPOS::	.WORD	0
CPOS::	.WORD	0
ULPBF::	.BLKB	200.	; don't know why, but at 132. code below gets smushed.

;PARAMETERS

SHUP=='^			;UPPER CASE INDICATOR
SHDN=='\			;LOWER CASE INDICATOR
CWARN=='_			;QUOTE NEXT CHARACTER
ULCHI=='&			;UNDERLINE COMMAND IN INPUT DATA
ULCHS==32			;UNDERLINE CHARACTER IN INTERNAL STORAGE
				; MUST BE .LT. QTS
DKCHS==31			;dark char. in internal buffer
QTSP=='#			;QUOTED (NONEXPANDABLE) SPACE IN INPUT FILE

HWPLN==66.			;HARDWARE LINES PER PAGE
ILSTTP==2			;INITIAL LIST ELEMENT PAGE TEST COUNT
ILSTVS==1			;INITIAL LIST ELEMENT VERTICLE SPACING
IPARIN==5			;INITIAL PARAGRAPH INDENT
IPARTP==2			;INITIAL PARAGRAPH PAGE TEST
IPARVS==1			;INITIAL PARAGRAPH VERTICLE SPACING
LOLMAR==9.			;INITIAL LEFT MARGIN INDENT ON LISTS		;**-3
LFSPAC==1			;FINAL VERTICAL SPACING ON LISTS
LSLMAR==4			;LEFT MARGIN INDENT ON EMBEDDED LISTS
NASPAC==1			;VERTICLE SPACING AFTER NOTES
NFSPAC==2			;FINAL VERTICLE SPACING AFTER NOTES
NHSPAC==2			;INITIAL VERTICLE SPACING BEFORE NOTES
NPMARG==15.			;PRIMARY MARGIN CHANGE ON NOTES
NSMARG==5			;SECONDARY MARGIN CHANGE ON NOTES
SPCNG==1			;STANDARD LINE SPACING
CBNSP==3			;CHAR OFFSET FOR CHANGE BARS			;CAR  1
										;CAR  1

;CHARACTERS FOR CREF

CR==15
LF==12
SPC==40
FF==14
TAB==11
CMA==',
ALT==33
BS==10				;BACKSPACE CHARACTER
NXS==177			;NON-EXPANDABLE	SPACE (INTERNAL)
QTS==37				;QUOTED SPACE. MUST BE SPC-1 FOR COMPARES
PD=='.				;PERIOD. FOR SPECIAL SPACING AFTER PERIOD
EOF=='Z-100			;END OF FILE
LPUS=='_			;LINE-PRINTER UNDERSCORE IN OUTPUT FILE
SEMI==';			;SEMICOLON
WCAP=='<			;WORD CAPITALIZE CHARACTER
BAR==0174				;BAR FOR CHANGE BAR			;CAR  1


;INPUT LINE

LIN::	CALL	GCIN		;READ CHARACTER WITH PRE-TRANSLATE
	CMPEQ	R1,#TAB,LTAB	;TAB?						;**-1
10$:	CMPNE	R1,#CR,20$	;NOT CARRIAGE RETURN?
	BIC	#2,$ULLSW							;CAR  1
	JMP	LCR		;YES. GO LOOK FOR LF
20$:	CMPEQ	R1,#NXS,LPACZ	;NON EXPANDABLE	SPACE?
	CMPEQ	R1,#SPC,LPACZ	;REGULAR SPACE?
	CMP	R1,#QTS		;SOME OTHER CONTROL CHARACTER?
	BGE	LIN3		;IF GE NO
	INC	LINBK		;ACCOUNT FOR NONSPACING CHARACTER
	INC	LINNSC		;
LIN3:	CALL	WLNIN1		;WRITE CHAR IN INPUT BUFFER
	MOV	R1,LCH		;SAVE AS LAST CHARACTER
	DEC	LINBK		;TIME TO BREAK LINE YET?
	BGE	LIN		;NO. LOOP FOR MORE
LIN3Z:


	.IF DF	H$$PHN

	CLR	HPHSW		;CLEAR HYPHENATE ENABLE
	TSTEQ	$HPHSW,LIN3A	;NO HYPHENATION ACTIVE?
	BITEQ	#JUSTF,F.1,LIN3A ;NO JUSTIFICATION?
	BITEQ	#HYPSW,$SWTCH,LIN3A ;NO HYPHENATION SELECTED?
	MOV	LNIN2,-(SP)	;REMEMBER END OF LINE
FIN10:	CALL	GCIN		;GET A CHARACTER
	MOV	R1,R2		;COPY CHARACTER
	BIC	#^C<177>,R2	;CLEAR ALL EXTRANEOUS BITS
	CALL	ALPH2		;ALPHABETIC?
	BCS	FINEX		;IF CS NO
	CALL	WLNIN1		;PUT CHARACTER IN BUFFER
	MOV	R1,LCH
	BR	FIN10
FINEX:	MOV	LSTSP,R0	;GET ADDRESS OF LAST WORD
	CMPB	(R0)+,(R0)+	;
	TSTB	(R0)		;IS WORD TO BE HYPHENATED IF POSSIBLE?
	BMI	FIN06		;IF MI NO
	MOV	R1,-(SP)	;SAVE LAST CHARACTER
	MOV	LNIN2,R1	;CONVERT LAST WORD TO ASCIZ
	CLRB	1(R1)		;
10$:	BICB	#200,(R1)	;ERASE ALL POSSIBLE HYPHENATE DISABLES
	DEC	R1		;BACKUP ONE BYTE
	CMP	R1,LNIN1	;AT FRONT OF LINE?
	BHI	10$		;IF HI NO
	MOV	SP,HPHSW	;ENABLE HYPHENATE ON OUTPUT
	CALL	HYPHEN		;TRY TO HYPHENATE THE WORD
	MOV	LSTSP,R1	;ADDRESS OF LAST SPACE
	MOV	2(SP),R0	;ADDRESS OF REAL END OF LINE
FIN02:	TSTB	-(R0)		;IS THIS A PLACE TO INSERT A HYPHEN?
	BMI	FIN03		;YES
	CMP	R0,R1		;NO, SHOULD I LOOK FARTHER?
	BHI	FIN02		;YES
	CLR	R1		;CLEAR MASK
	BR	FIN05
FIN03:	DEC	R0
	MOV	R0,LSTSP	;SET POINTER TO FAKE SPACE
	INC	SPCNT		;COUNT THE FAKE SPACE
	MOV	R1,R0		;GET START OF WORD
	MOV	#200,R1		;SET BIT	MASK
FIN05:	BICB	#200,(R0)+	;CLEAR HYPHEN FLAG AND TEST
	BNE	FIN05		;IF NE MORE TO GO
FIN04:	BISB	R1,@LSTSP	;RESET THE DESIRED ONE ONLY
	MOV	(SP)+,R1	;RETRIEVE SAVED CHARACTER
FIN06:	TST	(SP)+		;CLEAN STACK
	CALL	WLNIN1		;WRITE CHARACTER INTO BUFFER
LIN3A:

	.ENDC


	CALL	OUTLJ		;OUTPUT LINE,JUSTIFIED IF FLAGS
	BR	LIN		;PROCESS NEXT LINE.

;SPECIAL CHARACTERS DURING LINE INPUT

	.ENABL	LSB
LTAB:	MOV	LNIN2,R2	;DETERMINE PRESENT POSITION
	SUB	LNIN1,R2
	SUB	LINNSC,R2
	ADD	LMARG,R2
	ADD	INDCT,R2
	CALL	TABB		;FIND WHERE NEXT TAB STOP IS
	CMP	R2,LINBK	;WOULD THAT MANY EQUAL OR EXCEED LINE SIZE?
	BGE	22$		;YES. TREAT AS SPACE, NOT TAB
	SUB	R2,LINBK	;AND DECREMENT LINBK COUNT BY THAT AMOUNT
	MOV	#QTS,R1		;PUT N QUOTED SPACES IN BUFFER
10$:	CALL	WLNIN1		; ..
	DEC	R2		; ..
	BGT	10$
20$:	JMP	LIN
 
22$:	TST	NTABS		;any tabs?
LPACZ:	BEQ	LSPAC		;if none, convert to space
	INC	$TAB		;saved tab
	CALL	OUTNJ		;break line
	JMP	LIN		;and try next

;HERE ON SPACE IN INPUT FILE, OR ON NON-EXPANDABLE	SPACE. ALSO HERE ON
;TAB WHICH COULDN'T BE SATISFIED SO IS MADE A SPACE
;NOT HERE ON QUOTED SPACES.

LSPAC:	BITEQ	#FILLF,F.1,30$	;NO FILLING INPUT BEYOND BREAKS?
	MOV	LNIN2,R2	;FILTER OUT LEADING SPACES
	DEC	R2		;GET START OF BUFFER MINUS ONE
	CMP	R2,LSTSP	;IS THAT WHERE LAST SPACE IS?
	BLOS	20$		;IF LOS YES
	MOV	LCH,R1		;GET PREVIOUS CHARACTER WHAT WAS IT?
	CMPEQ	R1,#SPC,20$	;SPACE?
	CMPEQ	R1,#NXS,20$	;NON-EXPANDABLE	SPACE?
	CMPEQ	R1,#QTS,20$	;QUOTED SPACE?
	TSTEQ	$PERSW,30$	;ONE SPACE AFTER PUNCTUATION?
	CMPEQ	#':,R1,25$	;COLON FOLLOWED BY A SPACE?
	CMPEQ	#SEMI,R1,25$	;SEMICOLON FOLLOWED BY A SPACE?
	CMPEQ	#'!,R1,25$	;EXCLAMATION POINT FOLLOWED BY A SPACE?
	CMPEQ	#'?,R1,25$	;QUESTION MARK FOLLOWED BY A SPACE?
	CMPNE	R1,#PD,30$	;NOT PERIOD FOLLOWED BY SPACE?
25$:	TST	LINBK		;YES. ANY MORE ROOM LEFT?
	BLOS	30$		;NO. JUST STORE THE SPACE
	CALL	50$		;
	CALL	WLNIN1		; ..
	DEC	LINBK		;AND COUNT FOLLOWING CHARACTER
	MOV	#NXS,R1		;NON-EXPANDABLE	SPACE
	BR	40$		;
30$:	CALL	50$		;
40$:	JMP	LIN3		;
50$:	MOV	LNIN2,LSTSP	;HERE TO STORE AND COUNT A SPACE
	MOV	LINNSC,LSTNSP	;AND NON-SPACING CHAR POSN
	INC	SPCNT		;COUNT THIS SPACE
	MOV	#SPC,R1		;SPACE CHARACTER (EXPANDABLE)
	RETURN			;
	.DSABL	LSB

;+
; ENDBCM--END OF BREAK COMMAND
;-

	.ENABL	LSB
ENDBCM::CALL	LINSET		;SET FOR NEW LINE (BREAK COMMAND)

;+
; ENDCM--END OF COMMAND
;-

ENDCM::	CALL	$FRCND		;FORCE TO LOGICAL END OF LINE
	CMPEQ	#PD,R1,LGO	;PERIOD NEXT CHARACTER?
	CMPEQ	#SEMI,R1,LGO	;MORE TEXT ON LINE?
	BR	LCR		;

;+
; END OF LINE PROCESSING
;-

COMNT::	TST	(SP)+		;REMOVE RETURN FROM STACK
LCR::	CALL	GCIN		;GET FILE CHARACTER
LCR1:	CMPNE	R1,#LF,LCR	;NOT A LINEFEED?

;+
; READ AND PROCESS NEXT LINE
;-

LGO::	MOV	SPSAV,SP	;RELOAD STACK POINTER
	CALL	CCIN		;READ INITIAL CHARACTER ON LINE
5$:	MOV	#F.1,R5		;POINT TO FLAG MASK WORD
	CMPNE	R1,#EOF,20$	;NOT END OF FILE?
	BITEQ	#FOTF,(R5),10$	;NOT PROCESSING FOOTNOTE?
	MOV	FNSECT,-(SP)
	CALL	LDWRKS		;load work space
	JMP	FOOTND		;GO FINISH FOOTNOTE PROCESSING
10$:	CALL	OUTNJ		;FLUSH OUT LAST LINE
	CALL	DOINXI
	CALL	DOINXJ
	CALL	DOINXK
	CALL	DOINXL
	CALL	DOINX		; FORCE INDEX IF ANYTHING THERE			;CAR  1
15$:	CALL	DOTOC		; PRINT THE TABLE OF CONTENTS			;CAR  1
	JMP	ENDFIL		;END OF FILE
20$:	CMPEQ	R1,#FF,LGO	;FORMFEED ON INPUT?
	BITNE	#LITFG,(R5),70$	;PROCESSING LITERAL?
	BITEQ	#FILLF,(R5),60$	;NOT FILLING FROM INPUT FILE?
	TSTEQ	$AUTSW,60$	;AUTOPARAGRAPH NOT ACTIVE?
	CMPEQ	#CR,R1,40$	;NULL LINE?
	CMPEQ	#TAB,R1,30$	;LEADING TAB?
	CMPNE	#SPC,R1,70$	;NOT LEADING SPACE?
30$:	CALL	CCIN		;READ NEXT CHARACTER
	CMPEQ	#SPC,R1,30$	;SPACE?
	CMPEQ	#TAB,R1,30$	;TAB?
	CMPNE	#CR,R1,50$	;NOT CARRIAGE RETURN?
40$:	CALL	CCIN		;BYPASS LINE FEED
45$:	CALL	CCIN		;READ NEXT CHARACTER
	CMPEQ	#SPC,R1,45$	;SPACE?
	CMPEQ	#TAB,R1,45$	;TAB?
	CMPEQ	#PD,R1,90$	;LEADING PERIOD?
50$:	MOVB	R1,GCSCH	;SAVE FIRST CHARACTER
	CALL	OUTNJ		;BREAK CURRENT LINE
	CALL	PARTP		;PERFORM PARAGRAPH BREAK
	MOV	PARIND,INDCT	;SET PARAGRAPH INDENT
	CALL	LINSET		;RESET LINE PARAMETERS
	BR	TEXT		;PROCESS TEXT
60$:	CMPEQ	#CR,R1,LCR	;NULL LINE?
70$:	CMPEQ	R1,#PD,90$	;PERIOD AS FIRST CHAR?
	MOVB	R1,GCSCH	;SAVE CHARACTER
TEXT::	TSTEQ	$PGPSW,80$	;NO PAGE PENDING?
	CALL	PAGEC		;BREAK PAGE
80$:	BITNE	#FILLF,F.1,85$	;FILLING FROM INPUT FILE?
	CALL	OUTLIN		;OUTPUT LINE
	JMP	LIN		;AND START ANOTHER
85$:	TST	$FLOW		;flow in effect?
	BNE	87$		;if yes, skip
	JMP	LSPAC		;automatic space on new line
87$:
	JMP	LIN		;no automatic space if flowing
 
90$:	CALL	CMN		;PARSE COMMAND
	MOV	#ENDCM,-(SP)	;ASSUME NONBREAK COMMAND
	MOV	(R3),-(SP)	;SET ADDRESS OF COMMAND ROUTINE
	MOVB	(R2),-(SP)	;GET FLAG BYTE
	BITEQB	#BRKF,(SP),100$	;NOT BREAK COMMAND?
	CALL	OUTNJ		;BREAK CURRENT LINE
	MOV	#ENDBCM,4(SP)	;SET FOR BREAK COMMAND
100$:	BITEQB	#FPGF,(SP),110$	;DON'T PERFORM PENDING PAGE?
	TSTEQ	$PGPSW,110$	;NO PAGE PENDING?
	CALL	PAGEC		;PERFORM PAGE OPERATION
110$:	MOV	#RCNO,R4	;SET ADDRESS OF NUMBER CONVERSION ROUTINE
	BITEQB	#RELF,(SP)+,120$ ;ABSOLUTE CONVERSION REQUIRED?
	MOV	#RCNR,R4	;SET ADDRESS OF RELATIVE CONVERSION ROUTINE
120$:	JMP	@(SP)+		;DISPATCH TO COMMAND ROUTINE
	.DSABL	LSB

;
; ILLEGAL COMMAND
;

ILCM::	CALL	$ERMSG		;ILLEGAL COMMAND
	+ILCMM
	MOV	#PD,R1		;SET TO OUTPUT A PERIOD
10$:	CALL	TTC1		;OUTPUT CHARACTER
	MOV	#CMSTP,R4	;READ OUT COMMAND BUFFER
	CALL	GCI		; TO TELETYPE
	.WORD	20$		;END OF LINE
	BR	10$		;LOOP FOR WHOLE LINE
20$:	CALL	TTC33
	MOV	#LCR,-(SP)	;SET EXIT ADDRESS
ONPAG::	CALL	$ERMSG		;OUTPUT ERROR MESSAGE
	+ILCMM2
	MOV	APNDN,R1	;GET CURRENT APPENDIX LEVEL
	BEQ	10$		;IF EQ NONE
	ADD	#'A-1,R1	;CONVERT TO ASCII LETTER
	CALL	TTC1		;OUTPUT LETTER
	BR	20$		;
10$:	MOV	CHPTN,R0	;GET CURRENT CHAPTER NUMBER
	BEQ	30$		;IF EQ NONE
	CALL	DECTY		;OUTPUT CHAPTER NUMBER
20$:	MOV	#'-,R1		;OUTPUT A DASH
	CALL	TTC1		;
30$:	MOV	PAGENO,R0
	MOV	#TTC33,-(SP)	;SET EXIT ADDRESS
DECTY:	MOV	#12,R1		;SET DIVISOR
	CALL	$DIV		;DIVIDE
	MOV	R1,-(SP)	;SAVE REMAINDER
	TSTEQ	R0,10$		;NO MORE DIGITS TO CONVERT?
	CALL	DECTY
10$:	MOV	(SP)+,R1
	ADD	#60,R1
	JMP	TTC1

;
; EXPAND MEMORY
;

EXPAND::CALL	$ERMSG		;OUTPUT ERROR MESSAGE
	.WORD	CORERR		;
	JMP	ENDFIL		;

;+
; ROUTINE TO CHECK A CHARACTER FOR UPPER OR LOWER CASE
;	ALPHABETICS
;-

ALPH1::	MOV	R2,-(SP)	;SAVE R2
	MOV	R1,R2		;SET CHARACTER TO CHECK
	CALL	ALPH2		;CHECK FOR ALPHABETIC
	MOV	(SP)+,R2	;RESTORE R2
	RETURN			;
ALPH::	MOVB	(R0),R2		;GET CHARACTER TO CHECK
ALPH2::	CMP	R2,#'A
	BLO	20$
	CMP	R2,#'Z
	BLOS	10$
	CMP	R2,#'A+40
	BLO	20$
	CMP	R2,#'Z+40
	BHI	20$
10$:	CLC			;INDICATE ALPHABETIC
	RETURN			;
20$:	SEC			;INDICATE NONALPHABETIC
	RETURN			;

;SUBROUTINE TO INITIALIZE COUNTS AND POINTERS FOR A NEW LINE

LINSET::MOV	RMARG,R2	;COMPUTE REAL WIDTH OF LINE
	SUB	LMARG,R2	;AS DIFFERENCE OF MARGINS
	SUB	INDCT,R2	;MINUS INDENTING
	MOV	R2,LINBK	;STORE IN LINE-BREAK COUNT
	MOV	#-1,SPCNT	;INITIAL COUNTS OF SPACING
	CLR	NSPCH		; AND NON-SPACING CHARS
	CLR	CPOS		;CARRIAGE POSITION IS FAR LEFT
	CLR	LINNSC		;NO NON-SPACING CHARACTERS
	MOV	LNIN1,LNIN2	;CLEAR LINE INPUT BUFFER
	MOV	LNIN1,LSTSP	;SET LAST SPACING CHARACTER BACK HERE
	DEC	LSTSP		;MINUS ONE, SO OFF START OF BUFFER
ULBSET::MOV	#ULPBF,ULPOS	;RESET UNDERLINE POSITION BUFFER
	CLR	ULCHRX								;CAR  1
	CLR	DSCHRX
	CLR	DKCHRX
	RETURN			;

;+
; RCNR--RELATIVE DECIMAL CONVERSION ROUTINE
;
; INPUTS:
;
;	R3=BASE VALUE TO BE AUGMENTED.
;
; OUTPUTS:
;
;	NONSKIP RETURN IF NO NUMBER IS PRESENT.
;
;	SKIP RETURN WITH R3 UPDATED TO NEW VALUE.
;-

	.ENABL	LSB
RCNR::	MOV	R3,-(SP)	;SAVE BASE VALUE
	CALL	RCNO		;CONVERT DECIMAL NUMBER
	JMP	40$		;NONSKIP RETURN IF NULL
	BEQ	30$		;IF EQ NO SIGN SPECIFIED
	ADD	(SP),R3		;AUGMENT BASE VALUE
	BR	30$		;SKIP RETURN

;
; READ SIGNED DECIMAL NUMBER FOR COMMAND DECODER
; NON-SKIP RETURN IF NONE FOUND
;

RCNO::	CLR	R3		;CLEAR ANSWER AC
	CLR	-(SP)		;AND SIGN FLAG
RCN1:	CALL	CCIN		;READ CHARACTER FROM COMMAND LINE
	CMPEQ	R1,#CR,RCN5	;LEADING CARRIAGE RETURN?
	CMPEQ	#PD,R1,RCN5	;LEADING PERIOD?
	CMPEQ	#SEMI,R1,RCN5	;LEADING CHARACTER SEMICOLON?
	CMPEQ	R1,#CMA,40$	;LEADING COMMA?
	CMPEQ	R1,#SPC,RCN1	;SPACES AND TABS?
	CMPEQ	R1,#TAB,RCN1	;LEADING TAB?
	CMPNE	#'+,R1,10$	;NOT PLUS SIGN?
	INC	(SP)		;SET PLUS SIGN PRESENT
10$:	CMPNE	R1,#'-,20$	;NOT MINUS SIGN?
	COM	(SP)		;SET NEGATE FLAG
20$:	TSTEQ	(SP),RCN2	;SIGN NOT SPECIFIED?
RCN3:	CALL	CCIN		;READ ANOTHER CHARACTER
RCN2:	CMP	R1,#'9		;THIS CHAR A DIGIT?
	BGT	RCN4
	CMP	R1,#'0		; ..
	BLT	RCN4		;NO.  STOP HERE.
	ASL	R3		;MULTIPLY BY 10.
	MOV	R3,-(SP)	;
	ASL	R3		;
	ASL	R3		;
	ADD	(SP)+,R3	;
	SUB	#60,R1		;SUBTRACT OUT CHARACTER BIAS
	ADD	R1,R3		;ADD IN DIGIT
	BR	RCN3		;AND LOOP FOR MORE.
RCN4:	CMPNE	R1,#CMA,25$	;NOT COMMA?
	CALL	CCIN		;READ NEXT CHARACTER
25$:	TST	(SP)		;SIGN NEGATIVE?
	BPL	30$		;IF PL NO
	NEG	R3		;NEGATE NUMBER
30$:	ADD	#4,2(SP)	;SET SKIP RETURN
RCN5:	MOVB	R1,GCSCH	;STORE BREAK CHARACTER
40$:	TST	(SP)+		;CLEAN STACK
	RETURN			;
	.DSABL	LSB

;+
; $FRCND-FORCE TO LOGICAL END OF COMMAND
;-

$FRCND::CALL	CCIN		;READ CHARACTER FROM FILE
	CMPEQ	#SPC,R1,$FRCND	;SPACE?
	CMPEQ	#TAB,R1,$FRCND	;TAB?
	CMPEQ	#SEMI,R1,10$	;SEMICOLON?
	MOVB	R1,GCSCH	;SAVE BREAK CHARACTER
10$:	RETURN			;

;LINE OUTPUT ROUTINE. THREE ENTRY POINTS

OUTNJ::	MOV	LNIN2,R2	;HERE TO OUTPUT CURRENT LINE, NOT JUSTIFIED
	CALL	OUTNJ2		;CALL BODY OF ROUTINE
	CLR	EXSP3		;CLEAR LEFT RIGHT SPACING FLAG
OUTNJ3:	RETURN			;
OUTLJ:	MOV	LSTSP,R2	;END OF LINE IS LAST SPACE, IF ANY
	CMP	R2,LNIN1	;..
	BHI	..036
OUTLIN:	MOV	LNIN2,R2	;ELSE END OF INPUT LINE
..036:	MOV	SP,TJFSW	;COPY JUSTIFY FLAG
	BITNE	#JUSTF,F.1,..037 ;JUSTIFYING?
OUTNJ2: CLR	TJFSW		;CLEAR JUSTIFY FLAG


	.IF DF	H$$PHN

	CLR	HPHSW		;CLEAR HYPHENATE ENABLE

	.IFTF

..037:	MOV	R2,LOUT2	;SAVE END OF LINE TO CONSIDER
	MOV	LNIN1,LOUT1	;AND BEGINNING.
	CMP	R2,LOUT1	;LINE EMPTY?
	BHI	5$								;CAR  1
	JMP	OUTFTC		; DON'T FORGET POSSIBLE FOOTNOTES		;CAR  1
5$:										;CAR  1
	TSTEQ	TJFSW,OUTNJ1	;NOT JUSTIFYING LINE?				;**-1
	TST	SPCNT		;YES, ANY SPACES IN LINE?
	BGT	30$		;IF GT YES
	CALL	$ERMSG		;OUTPUT ERROR MESSAGE
	.WORD	JUSRM1		;
	MOV	LOUT1,T1	;COPY LINE DESCRIPTOR
	MOV	LOUT2,T2	;
10$:	MOV	#T1,R4		;READ A CHARACTER FROM LINE
	CALL	GCI		;
	.WORD	20$		;END OF LINE
	CALL	TTC1		;OUTPUT CHARACTER
	BR	10$		;
20$:	CALL	TTC33		;FORCE LINE OUT
	CALL	ONPAG		;INDICATE WHAT PAGE
	CLR	TJFSW		;CLEAR JUSTIFICATION
	BR	OUTNJ1		;
30$:	MOV	RMARG,R0	;YES. COMPUTE WHERE TO EXPAND THEM
	SUB	LMARG,R0	;SIZE OF LINE
	SUB	INDCT,R0	; ..
	ADD	LOUT1,R0	;SUBTRACT SIZE OF DATA
	SUB	LOUT2,R0	;..
	ADD	LSTNSP,R0	;COMPENSATE FOR NON-SPACING CHARACTERS

	.IFT

	TSTEQ	HPHSW,..040	;NO HYPHENATION ON OUTPUT?
	TSTB	@LSTSP		;DO WE ACCOUNT FOR A HYPHEN?
	BPL	..040		;IF PL NO
	DEC	R0		;YES, DECREMENT COUNT
..040:

	.IFTF

	MOV	SPCNT,R1	;NOW FIND HOW MANY MULT SPACES EACH SPACE IS
	CALL	$DIV		;DIVIDE
	MOV	R0,EXSP1	;MULTIPLIER FOR ALL SPACES
	TSTNE	EXSP3,10$	;EXTRAS TO LEFT?
	NEG	R1		;RIGHT. GET SPACES BEFORE EXTRAS
	ADD	SPCNT,R1	;..
10$:	MOV	R1,EXSP2	;STORE FOR LATER
OUTNJ1:	MOV	RIGSHI,R2	;GET RIGHT SHIFT				;CAR  1
	CALL	NSPAC		;DO IT						;CAR  1
	MOV	INDCT,R2	;GET INDENTING IN CASE OF PARAGRAPH		;CAR  1
	CLR	INDCT		;(ONCE ONLY)					;CAR  1
	ADD	LMARG,R2	;PLUS LEFT MARGIN				;CAR  1
	ADD	EBSIZ,R2	;ADD ON CHANGE BAR SIZE				;CAR  1
	TST	EBSIZ		;CHECK IF  BAR ENABLED				;CAR  1
	BEQ	10$		;NO SO SKIP BAR INSERTION			;CAR  1
	TST	$CBON		;CHECK IF CHANGE BAR ON				;CAR  1
	BEQ	10$		;IF EQ NO					;CAR  1
	BIC	#CBFBT,$CBON	;CLEAR THE LAST BAR BIT				;CAR  1
	MOV	R1,-(SP)	;SAVE R1 AS I DON'T KNOW IF ITS USED		;CAR  1
	MOV	#BAR,R1		;GET A BAR					;CAR  1
	CALL	CCOUT		;AND OUTPUT IT					;CAR  1
	MOV	(SP)+,R1	;GET R1 BACK					;CAR  1
	DEC	R2		;1 CHAR IS OUT SO STOP ITS SPACE		;CAR  1
10$:	CALL	NSPAC		;OUTPUT THAT MANY SPACES			;CAR  1
OUTL1:	CALL	GLOUT		;READ A CHARACTER FROM OUTPUT BUFFER		;**-4
	.WORD	OUTLE		;END OF OUTPUT BUFFER
	CMPEQ	R1,#SPC,OUTSP	;REAL SPACE?
	CMPNE	R1,#NXS,10$	;NOT NON-EXPANDABLE SPACE?
	MOV	#SPC,R1		;YES. MAKE IT ONE SPACE
10$:

	.IFT

	MOV	R1,-(SP)
	BIC	#200,R1		;CLEAR POSSIBLE HYPHENATION FLAG

	.IFTF

	CALL	CCOUT		;OUTPUT THE CHARACTER

	.IFT

	TSTB	(SP)+		;SHOULD HYPHEN BE TYPED?
	BPL	OUTL1		;IF PL NO
	TSTEQ	HPHSW,OUTL1	;NO HYPHENATION ON OUTPUT?
	MOV	#'-,R1
	CALL	CCOUT		;OUTPUT IT

	.ENDC


	BR	OUTL1		;LOOP BACK FOR MORE.
OUTSP:	CALL	CCSPC		;OUTPUT A SPACE
	TSTEQ	TJFSW,OUTL1	;NOT JUSTIFYING LINE?
	MOV	EXSP1,R2	;YES. HOW MANY MULTIPLE SPACES?
	CALL	NSPAC		;IF ANY, SEND THEM.
	DEC	EXSP2		;TO EXTRA BLANKS YET?
	BGE	OUTS1		;NO.
	TSTEQ	EXSP3,OUTS2	;SPACES TO RIGHT?
	BR	OUTL1		;LEFT. NO MORE EXTRAS, JUST LOOP
OUTS1:	TSTEQ	EXSP3,OUTL1	;NO SPACES LEFT OR RIGHT?
OUTS2:	CALL	CCSPC		;OUTPUT A SPACE
	BR	OUTL1		;AND LOOP FOR REST OF LINE

;END OF LINE, AND FOOTNOTE PROCESSING

OUTLE:	COM	EXSP3		;COMPLEMENT LEFT RIGHT FLAG
	MOV	LNIN2,R2
	MOV	LNIN1,LNIN2
	CMP	R2,LOUT2	;ANY LEFT TO OUTPUT?
	BLOS	OUTLE4		;NO.
	MOV	R2,GCIN2	;YES. SAVE POINTER
	MOV	LOUT2,GCINP	;FOR GET CHARACTER ROUTINE
	COMB	$GCISW		;SET TO REREAD BUFFER
OUTLE4:	CALL	SKIPS		; ..
OUTFTC:										;CAR  1
	TSTEQ	FOOTC,OUTFT1	;NO FOOTNOTE LINE COMMANDS DECLARED?
OUTFT:	BITNE	#FOTF,F.1,OUTFT1 ;DOING THEM ALREADY?
	MOV	NLPG,R2		;GET STARTING FOOTNOTE LINE
	SUB	FOOTC,R2	;REDUCE BY REQUESTED LINES
	CLR	FOOTC		;CLEAR REQUESTED LINES
	MOV	R2,NLPG		;SAVE STARTING FOOTNOTE LINE
	SUB	NSPNG,R2	;MINUS NORMAL SPACING
	CMP	R2,LINEC	;ROOM ON THIS PAGE FOR FOOTNOTE?
	BHI	OUTFT1		;IF HI YES
	CALL	BPAGE		;BREAK PAGE HERE.
OUTFT1:	JMP	LINSET		;RESET LINE PARAMATERS


;SUBROUTINE TO SKIP N LINES ON OUTPUT FILE

	.ENABL	LSB
SKIPS::	MOV	NSPNG,R2	;SET TO SKIP TO NEXT LINE
	BR	SKIPN		;
SKIP1::	MOV	#1,R2		;SET TO SKIP ONE LINE
SKIPN::	MOV	R3,-(SP)	;SAVE R3
	MOV	R2,-(SP)	; SAVE R2					;CAR  1
	MOV	DKCHRX,-(SP)
	BIS	ULCHRX,(SP)+	;any underlines or darks?
	BEQ	20$		;if neither, skip
	MOV	#3,R2		; # OF TIMES TO OVERPRINT FOR DARK		;CAR  1
	TST	DKCHRX		;any dark?
	BNE	5$		;if yes, need three loops
	MOV	#1,R2		;only one loop needed
5$:	CALL	OVPRNT		;print
10$:	DEC	R2
	BNE	5$		;loop
20$:	TST	DSCHRX		;dashes?
	BEQ	30$		;if not, skip
	CLR	R2
	CALL	OVPRNT
30$:	MOV	(SP)+,R2	;no. of skips
	CALL	ULBSET		;init. underline buffer for next line
50$:	ADD	R2,LINEC	;COUNT LINES					;**-24
	CLR	NSPCH		;CLEAR PER-LINE COUNTS
	CLR	CPOS		; ..
60$:	CALL	CRLF		;SPACE TO NEXT LINE
	DEC	R2		;OUTPUT AS MANY AS REQUESTED
	BGT	60$		;IF GT YES
	CALL	OUTPUT		;OUTPUT LOGICAL LINE
	MOV	NSPNG,R3	;GET SPACING COUNT TO NEXT LINE
	CALL	TESTP		;TEST IF PAGE SHOULD BE BROKEN
	MOV	(SP)+,R3	;RESTORE R3
70$:	RETURN			;

;
; ROUTINE TO OUTPUT SPACES TO FILE
;

NSPAC::	DEC	R2		;ANY MORE SPACES TO OUTPUT?
	BLT	70$		;IF LT NO
	CALL	CCSPC		;OUTPUT A SPACE
	BR	NSPAC		;

;
; ROUTINES TO OUTPUT A STRING TO THE OUTPUT FILE
;

PSTRPA::MOV	(R4)+,S1	;GET ADDRESS OF STRING MINUS 1
	MOV	(R4),R4		;GET ENDING ADDRESS OF STRING MINUS 1
	CLRB	1(R4)		;SET SENTINEL BYTE
80$:	INC	S1		;POINT TO NEXT BYTE
PSTRAZ::MOVB	@S1,R1		;GET A CHARACTER
	BEQ	70$		;IF EQ END OF STRING
	CALL	CCOUT		;OUTPUT TO FILE
	BR	80$		;LOOP FOR WHOLE STRING
										;CAR  1
										;CAR  1
										;CAR  1
	.DSABL	LSB
	.PAGE									;CAR  1
; PRINT THE UNDERLINE BUFFER IF THERE IS ANYTHING IN IT.			;CAR  1
; KEEP TRACK OF CHARS TO OVERPRINT (DARK) JUST LIKE CCOUT DOES.			;CAR  1
;										;CAR  1
; VALUES OF BYTES IN THE UNDERLINE BUFFER (ULPBF):				;CAR  1
;	0 = THAT'S ALL, FOLKS !!!						;CAR  1
;	1 = UNDERSCORE								;CAR  1
;	2 = DASH								;CAR  1
;	3 = BLANK								;CAR  1
;	OTHER = THE ACTUAL CHAR TO PRINT					;CAR  1
;										;CAR  1
; CAN USE R1 & R3								;CAR  1
; R2 HAS LOOP COUNTER								;CAR  1
;	on 2 or greater, we only print overstrikes (char. > 3)
;	on 1 we print overstrikes and underscores
;	on 0 we go to new line and only print dashes
										;CAR  1
OVPRNT:					;start
	MOV	#ULPBF,R3		;buffer
	MOV	#CR,R1			;carriage return
	CALL	FOUT
	TST	R2			;dash call?
	BNE	30$			;if not, skip
	MOV	#LF,R1			;next line
	CALL	FOUT
	INC	LINEC
10$:	CMP	R3,DSCHRX		;beyond end?
	BHI	20$			;if yes, skip (done)
	MOVB	(3)+,R1			;character from buffer
	CMPB	#2,R1			;dash?
	BEQ	15$			;if yes, skip
	MOVB	#40,R1			;space needed to get to next dash
	BR	18$
15$:
	MOVB	#'-,R1
	MOVB	#3,-1(3)		;no longer need mark in buffer
18$:	CALL	FOUT			;output char.
	BR	10$			;and loop
 
20$:	RETURN
 
30$:					;combined underscore-dark path
	TST	ULCHRX			;any underlines?
	BEQ	40$			;if not, skip
	CMP	R3,ULCHRX		;beyond last?
	BHI	40$
	CMPB	(3),#1			;underscore order?
	BNE	50$			;if not, skip
	INC	R3
	CMP	#1,R2			;path for underscores?
	BNE	65$			;if not, we will use space
	MOV	#'_,R1
	MOVB	#3,-1(3)		;no longer needed
	BR	68$
40$:
	TST	DKCHRX			;test with no more underscores
	BEQ	20$			;so if by dashes, we are done
	CMP	R3,DKCHRX
	BHI	20$
50$:	TST	DKCHRX			;test with more underscores
	BEQ	60$
	CMP	R3,DKCHRX
	BLOS	70$
60$:	INC	R3			;next address
65$:	MOV	#40,R1
68$:	CALL	FOUT
	BR	30$			;loop
70$:
	MOVB	(3)+,R1			;character
	CMP	R1,#3			;overstrike?
	BLOS	65$			;if not, space
	CMP	R2,#1			;last loop?
	BNE	68$
75$:	MOVB	#3,-1(3)		;no longer want command
	BR	68$
	.PAGE									;CAR  1
; SUBROUTINE TO PRINT THE CHARACTER IN R1					;CAR  1
; ALSO FIGURES OUT WHAT TO DO FOR UNDERLINE & DARK				;CAR  1
; BY BOTH BACKSPACE, OVERPRINT, AND SIMULATE					;CAR  1
										;CAR  1
	.ENABL	LSB
 
CCSPC::	MOV	#SPC,R1		; PRINT A SPACE					;CAR  1
CCOUT:	CMPNE	R1,#ULCHS,1$	; EMPHASIZE THE *NEXT* CHAR			;CAR  1
	JMP	230$
1$:
	CMPEQ	R1,#DKCHS,200$	;is next dark?
	CMPEQ	R1,#QTS,CCSPC	; QUOTED SPACE BECOMES REAL SPACE		;CAR  1
										;CAR  1
	MOVB	#3,@ULPOS							;CAR  1
	CMPEQ	R1,#SPC,50$	; NEVER EMPHASIZE BLANK				;CAR  1
	TSTEQ	ULCASE,50$	; NORMAL--JUST PRINT IT				;CAR  1
	CMPEQ	ULCASE,#5,5$	;underline via bs?
	CMPNE	ULCASE,#1,10$							;CAR  1
;
;	THIS CODE IS STUCK IN TO TRY THE NEC BOLD FEATURES. BFB
;	THE 1200 BAUD SPIN WRITER CRAWLS WITH ALL THESE CHARS.
;	IT IS BETTER TO USE UL:L FOR BOLD...
;
	BITEQ	#DIABSW,$SWTC2,5$	; BR IF NOT A SPINWRITER
	MOV	R1,CHSAVE	; SAVE CHAR
	CALL	HSP0		; NOSPACING
	CALL	FOUT		; OUTPUT CHAR
	CALL	HSP1		; SET SPACING 1 / 120 "
	MOV	CHSAVE,R1
	CALL	FOUT		; PRINT IT + ADVANCE 1 / 120
	CALL	HSP0		; NOSPACING
	MOV	CHSAVE,R1
	CALL	FOUT		; OUTPUT CHAR
	CALL	HSP11		; SET SPACING 11 / 120 "
	MOV	CHSAVE,R1
	CALL	FOUT		; BOLD + REST OF CHARACTER SPACING
	CALL	HSP12		; SET SPACING NORMAL = 1 / 10 "
	CLR	ULCASE
	INC	CPOS
	INC	ULPOS
	RETURN
;
;	END OF INSERTION
;
										;CAR  1
; UNDERLINE CASE 1-----OVERPRINT BY BACKSPACE					;CAR  1
5$:	MOV	R1,CHSAVE	; CHAR						;CAR  1
	CALL	FOUT								;CAR  1
	MOV	#BS,R1		; BACKSPACE					;CAR  1
	CALL	FOUT								;CAR  1
	MOV	#LPUS,R1	;assume underscore
	CMP	ULCASE,#5
	BEQ	50$		;if yes, skip
	MOV	CHSAVE,R1	; CHAR						;CAR  1
	CALL	FOUT								;CAR  1
	MOV	#BS,R1		; BACKSPACE					;CAR  1
	CALL	FOUT								;CAR  1
	MOV	CHSAVE,R1	; CHAR						;CAR  1
	CALL	FOUT								;CAR  1
	MOV	#BS,R1		; BACKSPACE					;CAR  1
	CALL	FOUT								;CAR  1
	MOV	CHSAVE,R1	; CHAR						;CAR  1
	BR	50$								;CAR  1
										;CAR  1
										;CAR  1
10$:	CMPNE	ULCASE,#2,20$							;CAR  1
; UNDERLINE CASE 2 ---- SIMULATE BY DASH ON NEXT LINE				;CAR  1
	MOVB	#2,@ULPOS							;CAR  1
	MOV	ULPOS,DSCHRX		;last dash
	BR	50$								;CAR  1
										;CAR  1
20$:	CMPNE	ULCASE,#3,30$							;CAR  1
; UNDERLINE CASE 3 ---- OVERPRINT AN UNDERSCORE CHARACTER			;CAR  1
	MOVB	#1,@ULPOS							;CAR  1
	MOV	ULPOS,ULCHRX
	BR	50$								;CAR  1
										;CAR  1
; UNDERLINE CASE 4 ---- OVERPRINT THE CHARACTER					;CAR  1
30$:	MOVB	R1,@ULPOS							;CAR  1
40$:	MOV	ULPOS,DKCHRX; REMEMBER WHERE WE PUT THE LAST SIGNIFICANT CHAR	;CAR  1
50$:	CLR	ULCASE								;CAR  1
	INC	CPOS		; BUMP CARRIAGE POSITION			;CAR  1
	INC	ULPOS								;CAR  1
	JMP	FOUT								;CAR  1
										;CAR  1
										;CAR  1
;***************************************************				;CAR  1
; NEXT CHAR IS TO BE EMPHASIZED BY ------					;CAR  1
;
200$:	BIT	#DUMSK,$SWTC2		;dark converted to underline?
	BNE	235$			;if yes, skip
205$:	BIT	#DKMSK,$SWTC2		;underline suppressed?
	BNE	210$			;if yes, skip
	BIT	#BSMSK,$SWTC2		;use backspace?
	BEQ	220$			;if not, skip
	MOV	#1,ULCASE		;dark via BS
210$:	RETURN
 
220$:	MOV	#4,ULCASE		;dark via overprint
	RETURN
 
230$:	BIT	#UDMSK,$SWTC2		;underline cnverted to dark?
	BNE	205$			;if yes, skip
235$:	BIT	#ULMSK,$SWTC2		;underline in use
	BNE	210$			;if yes, done
	BIT	#DSMSK,$SWTC2		;via dash?
	BEQ	240$			;if not, skip
	MOV	#2,ULCASE		;ul via dash
	RETURN
240$:
	BIT	#BSMSK,$SWTC2		;use backspace?
	BNE	250$			;if yes, skip
	MOV	#3,ULCASE		;overprint with underline
	RETURN
250$:
	MOV	#5,ULCASE		;backspace and underline
	RETURN
;
	.DSABL	LSB
; SUBROUTINES TO CHANGE NEC SPINWRITER SPACING
;
	.ENABLE	LSB
HSP0:	CALL	$SAVAL		; BE SAFE
	MOV	#1,-(SP)	; CODE FOR SPACING
	BR	10$
HSP1:	CALL	$SAVAL		; BE SAFE
	MOV	#2,-(SP)	; CODE FOR SPACING
	BR	10$
HSP11:	CALL	$SAVAL		; BE SAFE
	MOV	#14,-(SP)	; CODE FOR SPACING
	BR	10$
HSP12:	CALL	$SAVAL		; BE SAFE
	MOV	#15,-(SP)	; CODE FOR SPACING
10$:	MOV	#33,R1		; ESC
	CALL	FOUT
	MOV	#37,R1		; US
	CALL	FOUT
	MOV	(SP)+,R1	; SPACING CODE
;	CALLR	FOUT
	JMP	FOUT
	.DSABL	LSB


;GET INPUT CHARACTER FROM SOURCE FILE

	.ENABL	LSB
 
GCIN::
	TST	$TAB		;saved tab?
	BEQ	5$		;if not, skip
	DEC	$TAB		;one less
	MOV	#TAB,R1
	RETURN
5$:
	TSTEQB	$GCISW,GCIN3	;NOT REREADING FROM BUFFER?
	CALL	GGCINP		;GET  CHARACTER FROM BUFFER
	.WORD	10$		;NONE
	RETURN			;
10$:	CLRB	$GCISW		;CLEAR REREAD FLAG
GCIN3:	TSTNEB	GCSCH,GCIN5	;SAVED CHARACTER?
	MOVB	ULMCH,R1	;SAVED UNDERLINE CHARACTER?
	BEQ	GCIN5		;IF EQ NO
	CLRB	ULMCH		;CLEAR SAVED UNDERLINE CHARACTER
	BR	80$		;
GCIN5:	CALL	CCIN		;NO.  GET CHARACTER FROM FILE.
GCIN6:	CMP	#'Z+40,R1	;LOWER CASE?
	BLO	30$		;IF LO NO
	CMP	#'A+40,R1	;LOWER CASE?
	BHI	20$		;IF HI NO
	SUB	WCAS,R1		;CONVERT CASE IF NECESSARY
	BR	GCINR		;
20$:	CMP	#'A,R1		;UPPER CASE?
	BHI	30$		;IF HI NO
	CMP	#'Z,R1		;UPPER CASE?
	BLO	30$		;IF LO NO
	TSTNE	WCAS,GCINR	;CONVERTING TO UPPER CASE FOR THIS WORD?
	ADD	CAS,R1		;CONVERT TO LOWER CASE IF NECESSARY
	BR	GCINR		;
30$:	TSTEQ	$CFLSW,60$	;FLAGS CAPITALIZE NOT ENABLED?
	CMPEQ	#QTSP,R1,40$	;QUOTED SPACE?
	CMPEQ	#SPC,R1,40$	;SPACE?
	CMPEQ	#TAB,R1,40$	;TAB?
	CMPNE	#LF,R1,50$	;NOT LINE FEED?
40$:	CLR	WCAS		;CLEAR WORD CASE CONVERSION
50$:	CMPNE	#WCAP,R1,60$	;NOT WORD CAPITALIZE?
	MOV	#40,WCAS	;SET WORD CAPITALIZE CONVERSION VALUE
	BR	GCIN3		;
60$:	BITNE	#LITFG,F.1,80$	; NO SPECIAL CHARS IN A LITERAL			;CAR  1
	CMPEQ	R1,#CWARN,CWR1	;QUOTING A CHARACTER? (_)
	CMPEQ	R1,#SHUP,SHFUP	;UPSHIFT CHARACTER? (^)
	CMPEQ	R1,#SHDN,SHFDN	;DOWNSHIFT CHARACTER? (\)
	CMPEQ	R1,#ULCHI,ULCHX; INSTREAM UNDERLINE REQUEST? (&)
										;**-1

	.IF DF	H$$PHN

	TSTEQ	$HFLSW,70$	;FLAGS HYPHENATE NOT ENABLED?
	CMPEQ	#'=,R1,FLHYP	;FLAGS HYPHENATE?

	.IFTF

70$:	CMPNE	R1,#QTSP,GCINR	;NOT QUOTED SPACE?
	MOV	#QTS,R1		;SET QUOTED SPACE
GCINR:	TSTEQ	$ULLSW,80$	;UNDERLINE SHIFT-LOCK NOT ON?
	BIC	#4,$ULLSW	;clear one character flag
	CMPEQ	#QTS,R1,80$	;QUOTED SPACE?
	CMP	#SPC,R1		;PRINTING CHARACTER?
	BGE	80$		;IF GE NO
	MOVB	R1,ULMCH	;SAVE UNDERLINED CHARACTER
ULCH:	MOV	#ULCHS,R1	;SET TO UNDERLINE CHARACTER
	TST	ULTYP		;underlining?
	BEQ	75$		;if yes, skip
	MOV	#DKCHS,R1	;store dark control then char.
75$:
	INC	NSPCH		;COUNT NONSPACING CHARACTERS
80$:	RETURN			;
	.DSABL	LSB

	.IFT

;
; FLAG HYPHENATE CHARACTER
;

FLHYP:	CALL	GCIN		;GET NEXT CHARACTER WITH TRANSLATE
	CALL	ALPH1		;ALPHABETIC CHARACTER?
	BCS	GCINR		;IF CS NO
	BISB	#200,R1		;DISABLE HYPHENATION ON THIS WORD
	BR	GCINR		;

	.ENDC


;SPECIAL CASES OF INPUT CHARACTER

CWR1:	CALL	CCIN		;READ CHARACTER  NO TRANSLATION
	BR	GCINR		;AND RETURN IT.  MAYBE UNDERLINED

;MORE SPECIAL CASES OF GET-CHARACTER ROUTINE

	.ENABL	LSB
SHFUP:	CALL	CCIN		;READ A CHARACTER
	CMPEQ	R1,#ULCHI,ULMON	;LOCK ON UNDERLINE?
	CMPNE	R1,#SHUP,20$	;NOT DOUBLE UPSHIFT?
	CALL	UPCAS		;SET UPPER CASE
10$:	JMP	GCIN3		;AND GO READ ANOTHER CHARACTER
20$:	CALL	ALPH1		;ALPHABETIC CHARACTER?
30$:	BCS	GCIN6		;IF CS NO
	CMP	#'A+40,R1	;LOWER CASE?
40$:	BHI	GCINR		;IF HI NO
	CMP	#'Z+40,R1	;LOWER CASE?
50$:	BLO	GCINR		;IF LO NO
	SUB	#40,R1		;CONVERT TO UPPER CASE
	BR	GCINR		;
SHFDN:	CALL	CCIN		;GET ANOTHER CHARACTER
	CMPEQ	R1,#ULCHI,ULMOF	;UNLOCK UNDERLINE?
	CMPNE	R1,#SHDN,60$	;NOT SECOND DOWNSHIFT?
	CALL	LWCAS		;SET LOWER CASE
	BR	10$		;
60$:	CALL	ALPH1		;ALPHABETIC CHARACTER?
	BCS	30$		;IF CS NO
	CMP	#'A,R1		;IN RANGE FOR LOWERING?
	BHI	40$		;IF HI NO
	CMP	#'Z,R1		;IN RANGE FOR LOWERING?
	BLO	50$		;IF LO NO
	ADD	#40,R1		;YES.  MAKE IT LOWER CASE
	BR	GCINR		;
	.PAGE									;CAR  1
ULMON:	BIS	#1,$ULLSW	; INSTREAM UNDERLINE REQUEST			;CAR  1
	BR	ULCHX								;CAR  1
										;CAR  1
ULMOF:	BIC	#1,$ULLSW	; INSTREAM UNDERLINE REQUEST OFF		;CAR  1
	BR	ULCHX2
 
ULCHX:	BIS	#4,$ULLSW	;always at least one character
ULCHX2:	MOV	DFULT,ULTYP	; UNDERSCORE OR OVERPRINT FLAG			;CAR  1
	BR	10$								;CAR  1
	.DSABL	LSB								;**-4

;ROUTINE TO READ INPUT FROM FILE OR FOOTNOTE AS APPROPRIATE

CCIN::	MOVB	GCSCH,R1	;ANY CHARACTER SAVED FROM EARLIER PASS?
	BNE	30$		;IF NE YES
	TSTEQB	$SDISW,20$	;INPUT NOT FROM SECONDARY BUFFER?
	MOV	#SDINP,R4	;SET ADDRESS OF LINE DESCRIPTOR
	CALL	GCI		;GET CHARACTER FROM BUFFER
	.WORD	10$		;NONE
	RETURN			;
10$:	CLRB	$SDISW		;CLEAR INPUT FROM SECONDARY BUFFER
20$:	BITNE	#FOTF,F.1,40$	;CHARACTERS COMING FROM FOOTNOTE?
	JMP	FIN		;NO.  READ FROM FILE
30$:	CLRB	GCSCH		;CLEAR SAVED CHARACTER
	RETURN			;
40$:	MOV	#FOOTP1,R4	;GET CHARACTER FROM FOOTNOTE STRING
	CALL	GCI		;GET THE CHARACTER
	.WORD	50$		;NONE LEFT
 	RETURN			;
50$:	CALL	$ERMSG		;GIVE THE HALT MESSAGE
	+HALTM
	JMP	RUNOFF		;RESTART RUNOFF


;ROUTINE TO FIND NEXT TABSTOP FOR OUTLIN ROUTINE.

TABB:	CLR	R0		;START AT FIRST TABSTOP
	TST	RELTAB								;CAR  1
	BMI	5$								;CAR  1
	SUB	RELTAB,R2	; RELATIVE TO ABSOLUTE COLUMN NUMBER		;CAR  1
	BR	20$								;CAR  1
										;CAR  1
5$:	SUB	LMARG,R2	; RELATIVE TO CURRENT LEFT MARGIN		;CAR  1
	BR	20$		;PRE-ENDCHECK, IN CASE NONE.
10$:	MOVB	TABTAB-1(R0),R4	;GET CURRENT TAB STOP
	CMP	R2,R4		;THIS STOP BEYOND CURRENT POS?
	BLO	40$		;YES.  GET DIFFERENCE
20$:	CMP	R0,NTABS	;LOOKED AT ALL TAB STOPS?
	BHIS	30$
	INC	R0		;ADVANCE TO NEXT ENTRY
	BR	10$
30$:	MOV	RMARG,R4	;YES.  ASSUME A TABSTOP AT RIGHT END
40$:	SUB	R2,R4		;GET DISTANCE TO TABSTOP
	MOV	R4,R2		;ANSWER IN A
	RETURN			;


;ROUTINE TO SPACE TO TOP OF FORM

FORM:	MOV	LINEC,R2	;GET CURRENT LINE POSITION
	BEQ	50$		;IF EQ ALREADY AT TOP
	CALL	FFEED		;SPACE TO TOP OF FORM				;SIG01
	TSTNE	$SBPSW,40$	;SUBPAGE?					;SIG01
	INC	PAGENO		;COUNT PAGE NUMBER				;SIG01
	inc	abspag								;CAR  1
40$:	CALL	OPRWAT		;WAIT FOR OPERATOR TO POSITION FORMS		;SIG01
50$:	RETURN									;SIG01

;ROUTINE TO BREAK PAGE AND OUTPUT HEADING

	.ENABL	LSB
PAGEC::	CLR	$SBPSW		;CLEAR SUBPAGE FLAG
	MOV	#SPC,SUBPGE	;RESET SUBPAGE NUMBER
	BR	BPAGE		;
TPAGE::	MOV	SP,$SBPSW	;SET SUBPAGE FLAG
	INC	SUBPGE		;INCREMENT SUBPAGE
BPAGE::	CLR	$PGPSW		;CLEAR PAGE PENDING FLAG
	TST	IDXINP		;index in progress?
	BNE	50$		;if yes, skip footnote checks
	BITNE	#FOTF,F.1,50$	;ALREADY PROCESSING A FOOTNOTE?
	MOV	FNSECT,-(SP)
	CALL	LDWRKS		;load work space
	CMPEQ	FOOTP1,FOOTP2,50$ ;NO DATA IN FOOTNOTE BUFFER?
	MOV	NLPG,R2		;GET STARTING FOOTNOTE LINE
	MOV	#100.,NLPG	;SET LARGE COUNT
	SUB	LINEC,R2	;CALCULATE DISTANCE TO FIRST FOOTNOTE
	BLOS	10$		;IF LOS SOME LEFT TO GO
	CALL	SKIPN		; SKIP TO END OF PAGE BEFORE FOOTNOTES
10$:	MOV	R5,-(SP)	;SAVE REGISTER R5
	MOV	#F.1,R5		;POINT TO FLAG WORD
	MOV	$CBON,-(SP)	;SAVE THE BAR STATUS				;CAR  1
	MOV	RMARG,-(SP)	;SAVE THESE ITEMS OVER FOOTNOTE PROCESSING
	MOV	LMARG,-(SP)
	MOV	PARIND,-(SP)	;SAVE PARA INDENTING
	MOV	NSPNG,-(SP)
	MOVB	GCSCH,-(SP)
	MOV	INDCT,-(SP)	;OCCASSIONALLY WE NEED TO SAVE THIS
	MOV	(R5),-(SP)	;SAVE CURRENT FLAG WORD
	CLR	INDCT		;CLEAR IT FOR RANDOM FAILURES
	CLR	$CBON		;CLEAR THE BAR BITS				;CAR  1
	MOV	STDLM,LMARG	; RESET LM TO STANDARD				;CAR  1
	MOV	PRMRG,RMARG	;RESET RIGHT MARGIN				;**-1
	CLRB	GCSCH		;CLEAR SAVED CHARACTER
	MOV	FOOTS1,FOOTS2	;BUFFER IS EMPTY
	MOVB	$GCISW,-(SP)	;SAVE REREAD FLAG
	BEQ	30$		;IF EQ NOT SET
20$:	CALL	GGCINP		;GET A CHARACTER FROM SAVED BUFFER
	.WORD	30$		;NONE LEFT
	MOV	#FOOTS1,R4	;SAVE BUFFER
	CALL	WCI
	BR	20$		;LOOP UNTIL SAVED BUFFER ALL MOVED
30$:	CLRB	$GCISW		;CLEAR REREAD BUFFER FLAG
	MOV	SPSAV,-(SP)	;SAVE BASE OF STACK
	MOV	SP,SPSAV	;SET NEW STACK BASE
	BIS	#FOTF,(R5)	;SET FOOTNOTE PROCESSING ACTIVE
	CALL	LINSET		;INITIALIZE LINE FOR START OF FOOTNOTE
40$:	JMP	LGO		;AND GO PROCESS SAVED FOOTNOTE COMMANDS

;
; END OF FOOTNOTE PROCESSING
;

FOOTND:	CALL	OUTNJ		;YES. FINISH UP LINE
	CMPNE	FOOTP1,FOOTP2,40$ ;ANY MORE FOOTNOTES TO PROCESS?
	MOV	FOOTP3,FOOTP1	;RESET FOOTNOTE BUFFER POINTERS
	MOV	FOOTP3,FOOTP2	;
	CLR	EXSP3		;CLEAR LEFT RIGHT FLAG
	MOV	SPSAV,SP	;RESET STACK TO CURRENT BASE
	MOV	(SP)+,SPSAV	;RESTORE OLD STACK BASE
	MOVB	(SP)+,$GCISW	;RESTORE REREAD FLAG
	MOV	(SP)+,(R5)	;RESTORE FLAG WORD
	MOV	(SP)+,INDCT	;RESTORE INDENT COUNT
	MOVB	(SP)+,GCSCH	;RESTORE SAVED CHARACTER
	MOV	(SP)+,NSPNG	;RESTORE CURRENT SPACING
	MOV	(SP)+,PARIND	;RESTORE PARAGRAPH INDENT
	MOV	(SP)+,LMARG	;RESTORE LEFT MARGIN
	MOV	(SP)+,RMARG	;RESTORE RIGHT MARGIN
	MOV	(SP)+,$CBON	;RESTORE BAR STATUS				;CAR  1
	BIC	#FOTF,(R5)	;CLEAR FOOTNOTE PROCESSING FLAG
	MOV	(SP)+,R5	;RESTORE REGISTER R5
	MOV	PNLPG,NLPG	;RESET LENGTH OF PAGE
	MOV	FOOTS1,GCINP	;RESTORE REREAD DESCRIPTOR
	MOV	FOOTS2,GCINP+2	;
50$:	CALL	FORM		;OUTPUT FORMFEEDS OR LINEFEEDS
	TSTEQ	$HDRSW,135$							;CAR  1
	CALL	SKIP1		;SKIP ONE LINE					;**-1
	MOV	#4,R2		;ASSUME HEADER NOT ENABLED
	TSTNEB	$HDSSW,130$	;HEADER DISABLED?
	MOV	EBSIZ,R2	;ADD ON SPACE FOR CHANGE BAR OFFSET		;CAR  1
	MOV	RMARG,R3
	BITEQ	#SPECF,F.1,60$	;NO SPECIAL HANDLING IN PROGRESS?
	CMPNE	ENOTE,CMADR,60$	;NOT PROCESSING A NOTE?
	MOV	NOTRM,R3	;GET RIGHT MARGIN BEFORE NOTE
60$:	SUB	R2,R3
	MOV	R3,TWIDE	; WIDTH OF TITLE LINE
	ADD	RIGSHI,R2	;ADD SPACE FOR RIGHT SHIFT			;CAR  1
	CALL	NSPAC		; SPACES TO MARGIN ON COUNT IN R2

	TSTEQ	$NUMSW,70$	; NO PAGE NUMBER?
	CALL	PGPG		; SETUP AND SIZE PAGE NO. STRING
;
;	IF /BT (BOOK TITLE) WAS SPECIFIED, REVERSE TITLE ON ALTERNATE PAGES
;	NORMALLY ODD PAGES HAVE PAGE NO. ON RIGHT, BUT /BT:R REVERSES THAT.
;
	BITEQ	#BKTISW,$SWTC2,70$	; BR IF NO BOOK TITLING
;	BIT	#1,PAGENO	; EVEN PAGE ?
	BIT	#1,ABSPAG	; EVEN PAGE ?
	BNE	64$		; NO
	BITEQ	#BKTNSW,$SWTC2,70$	; NOT NORMAL (REVERSED) ?
	BR	66$
64$:	BITNE	#BKTNSW,$SWTC2,70$	; NORMAL ?
;
66$:	MOV	#PGSTR,R0	; OUTPUT PAGE NO FIRST ON THIS PAGE
	CALL	COUTZ		; OUTPUT ASCIIZ STRING
	CALL	TIFILL		; BLANKS UNTIL LOCATION FOR TITLE
	CALL	DOTI
	BR	120$

70$:	CALL	DOTI		; DO TITLE FIRST
	TSTEQ	$NUMSW,120$	; PAGE NUMBERING ?
	TST	CHPTN		;chapter or appendix?
	BNE	75$		;if yes, always page
	CMPEQ	#1,PAGENO,120$	;if not and on page 1, no title
75$:
	CALL	TIFILL		; BLANKS UNTIL LOCATION FOR TITLE
	MOV	#PGSTR,R0	; OUTPUT PAGE #
	CALL	COUTZ

120$:	CALL	SKIP1		;SKIP ONE LINE
	MOV	RIGSHI,R2	;ADD SPACE FOR RIGHT SHIFT			;CAR  1
	ADD	EBSIZ,R2	;ADD ON SPACE FOR CHANGE BAR OFFSET		;CAR  1
	CALL	NSPAC		;SPACE TO MARGIN				;CAR  1
	MOV	#STTLP1,R4	;OUTPUT THE SUBTITLE, IF ANY
	CALL	PSTRPA		;..
	MOV	#3,R2		;AND OUTPUT THIS LINE.
130$:	CLRB	$HDSSW		;ENABLE HEADER
	CALL	SKIPN		; INCLUDING SUBTITLE				;CAR  1
135$:	MOV	FIGSAV,R2	; SPACE FOR FIGURE HELD OFF BECAUSE IT		;CAR  1
	BEQ	136$		; WOULDN'T FIT ON THE PREV PAGE			;CAR  1
	CLR	FIGSAV								;CAR  1
	CALL	SKIPN								;CAR  1
136$:	RETURN									;CAR  1
	.DSABL	LSB
	.ENABL	LSB
;
;	BUILD PAGE NUMBER STRING AS AN ASCIIZ STRING AND SAVE ITS SIZE
;	
PGPG:	CALL	$SAVAL
	MOV	#PGSTR,R0	; BUILD PAGE # STRING HERE
	MOV	#PAGHD,R1	; "PAGE " MOST LIKELY
	CALL	MOVZ		; MOVE TIL END OF ASCIIZ
	MOV	CHPTN,R3	; GET CURRENT CHAPTER NUMBER
	BEQ	110$		; NO CHAPTER OR APPENDIX SPECIFIED?
	MOV	APNDN,R1	; GET CURRENT APPENDIX LETTER
	BEQ	90$		; IF EQ NONE SPECIFIED
	ADD	#'A-1,R1	; CONVERT TO UPPER CASE ASCII
	MOVB	R1,(R0)+	; APPENDIX LETTER
	BR	100$		;
90$:	MOV	R3,R1		; SET CHAPTER NUMBER
	CLR	R2		; ZERO SUPPRESS
	CALL	$CBDMG		; CONVERT TO DECIMAL
100$:	MOVB	#'-,(R0)+	; OUTPUT A DASH
110$:	MOV	PAGENO,R1	; GET CURRENT PAGE NUMBER
	CLR	R2		; ZERO SUPPRESS
	CALL	$CBDMG		; CONVERT TO DECIMAL
	TSTEQ	$SBPSW,115$	; NO SUBPAGE?
	MOV	SUBPGE,R1	; RETRIEVE THE LETTER
	ADD	#' ,R1		; MAKE AN ASCII LETTER
	MOVB	R1,(R0)+	; GET IT INTO WORK BUFFER
115$:	CLRB	(R0)		; FLAG END OF STRING
	SUB	#PGSTR,R0	; LENGTH OF STRING
	MOV	R0,PGSTRL	; SAVED FOR HOUSKEEPING
120$:	RETURN
;
;	OUTPUT TITLE STRING AND SEE WHAT THE EFFECTIVE LENGTH WAS
;	THE MERE TITLE STRING LENGTH IS APT TO BE BIASED BY BOLD/UNDERLINE
;	FLAGS, ETC.
;
DOTI:	MOV	#TTLP1,R4	; OUTPUT TITLE TO FILE
	CALL	PSTRPA		; PRINT STRING FROM PA
	RETURN
;
; COUNT SPACING CHARACTERS IN STRING
;
SPCT:	MOV	(R4)+,S1	;GET ADDRESS OF STRING MINUS 1
	MOV	(R4),R4		;GET ENDING ADDRESS OF STRING MINUS 1
	CLRB	1(R4)		;SET SENTINEL BYTE
	CLR	TRUTTL		; ZERO COUNT
80$:	INC	S1		;POINT TO NEXT BYTE
	MOVB	@S1,R1		;GET A CHARACTER
	BEQ	120$		;IF EQ END OF STRING
	CMPEQ	R1,#ULCHS,80$	; DONT COUNT FLAG CHAR
	INC	TRUTTL		; COUNT CHARS CAUSING SPACING
	BR	80$		;LOOP FOR WHOLE STRING
;
;	DO THE SPACING BETWEEN THE TITLE AND THE PAGE NUMBER FIELDS
;	REGUARDLESS OF WHICH IS AT WHICH END OF THE LINE.
;
TIFILL:	MOV	TWIDE,R2	; WIDTH OF TITLE LINE IN USE
	SUB	PGSTRL,R2	; LESS LENGTH OF PAGE NUMBER STRING
	MOV	#TTLP1,R4
	CALL	SPCT		; COUNT EFFECTIVE LENGTH OF TITLE
	SUB	TRUTTL,R2	; LESS LEN OF TITLE
	BLE	130$		; ANY SPACES TO DO?
	CALL	NSPAC		; OUTPUT THAT MANY BLANKS
	RETURN
;
;	MOV AN ASCIIZ STRING UNTIL THE NULL
;
MOVZ::	MOVB	(R1)+,(R0)+	; NEXT CHAR, IS IT A NULL
	BNE	MOVZ		; BR NO
	DEC	R0		; LEAVE R0 AFTER LAST VALID CHAR
130$:	RETURN
;
;	OUTPUT CHARS FROM ASCIIZ STRING UNTIL NULL
;
COUTZ::	MOVB	(R0)+,R1	; EACH CHAR TILL NULL
	BEQ	130$
	CALL	CCOUT		; OUTPUT THE CHAR
	BR	COUTZ		; LOOP FOR MORE
;
	.DSABL	LSB

DECPRT::MOV	#12,R1		;STANDARD DECIMAL PRINT ROUTINE
	CALL	$DIV		;DIVIDE
	MOV	R1,-(SP)
	TSTEQ	R0,10$		;NO MORE DIGITS TO CONVERT?
	CALL	DECPRT		;NO
10$:	MOV	(SP)+,R1	;GET A DIGIT
	ADD	#60,R1		;MAKE ASCII DIGIT
	JMP	FOUT		;OUTPUT TO FILE.
;										;SIG01
;	ROUTINE TO SPACE TO TOP OF FORM						;SIG01
;										;SIG01
FFEED::;									;SIG01
	BITEQ	#FFDSW,$SWTCH,10$ ;SPACING WITH LINE FEEDS?			;SIG01
	MOV	#FF,R1		;OUTPUT A FORMFEED				;SIG01
	CALL	FOUT								;SIG01
	BR	30$		;ADJUST COUNTS					;SIG01
10$:	MOV	LINEC,R2	;GET LINE POSITION				;SIG01
15$:	SUB	LPPG,	R2	;GET - NUMBER OF LINES TO TOP OF PAGE		;SIG01
	BPL	15$		;IF PL LOOP					;SIG01
20$:	CALL	CRLF		;SPACE TO NEXT LINE				;SIG01
	INC	R2								;SIG01
	BLT	20$								;SIG01
30$:	CLR	LINEC		;CURRENT LINE NOW ZERO				;SIG01
	RETURN									;SIG01
;										;SIG01
;	ROUTINE TO PROMPT OPERATOR AND WAIT FOR SIGNAL TO			;SIG01
;	CONTINUE								;SIG01
;										;SIG01
OPRWAT::;									;SIG01
	BITEQ	#PAUSW,$SWTCH,50$ ;DON'T WAIT FOR NEW PAPER?			;SIG01
	BITEQB	#FD.TTY,TTBLK+F.RCTL,50$ ;IS TI: DEVICE A TERMINAL		;SIG01
	CALL	OUTPUT		;FLUSH ANY OUTPUT				;SIG01
	BICB	#FD.CR,TTBLK+F.RATT ;KEEP FCS FROM ADDING LINE FEED		;SIG01
	MSGPUT	WIGL		;WAKE THE OPERATOR UP				;SIG01
	BISB	#FD.CR,TTBLK+F.RATT ;RE-ENABLE CARRIAGE CONTROL			;SIG01
	CALL	TTC4N		;READ A CHARACTER				;SIG01
50$:	RETURN			;RETURN						;SIG01

; ROUTINES TO GET CHARACTER AND INCREMENT STRING POINTER

GGCINP:	MOV	#GCINP,R4
	BR	GCI
GLOUT:	MOV	#LOUT1,R4	;PARTICULAR ARGUMENT
GCI::	CMP	(R4)+,(R4)	;ANYTHING IN STRING
	BHIS	10$		;IF HIS NO
	INC	-(R4)		;YES.  COUNT AND GET FIRST POINTER
	CLR	R1		;PICKUP NEXT CHARACTER
	BISB	@(R4)+,R1	;
	ADD	#2,(SP)		;FORCE SKIP RETURN
	RETURN			;
10$:	MOV	@(SP)+,PC	;SET SKIP RETURN

;ROUTINES TO WRITE CHARACTER AND INCREMENT POINTERS

WCIFTN::MOV	#FOOTP1,R4	;POINT TO FOOTNOTE DESCRIPTOR
	BR	WCI		;
WLNIN1::MOV	#LNIN1,R4	;STANDARD ARG
WCI::	TST	(R4)+		;POINT TO SECOND WORD OF DESCRIPTOR
	INC	(R4)		;INCREMENT TO NEXT BYTE
	CMP	(R4)+,(R4)	;BUFFER OVERFLOW?
	BHIS	10$		;IF HIS YES
	MOVB	R1,@-(R4)	;STORE BYTE
	RETURN			;
10$:	CALL	$ERMSG		;OUTPUT ERROR MESSAGE
	.WORD	BFOVF		;
	JMP	RUNOFF		;

;
; START OF RUNOFF
;


START:	JMP	$START		;

	.END START