.TITLE	PROCES	PROCESS A DOCUMENTATION RECORD
	.IDENT	/01/

; 
; THIS PROGRAM IS PROVIDED ON AN "AS IS" BASIS ONLY.  DIGITAL  EQUIPMENT
; CORPORATION  USER'S  SOCIETY,  DIGITAL EQUIPMENT CORPORATION, ROCKWELL
; INTERNATIONAL  AND THE AUTHOR DISCLAIM ALL WARRANTIES ON THE  PROGRAM,
; INCLUDING WITHOUT LIMITATION, ALL IMPLIED WARRANTIES OF MERCHANTABLITY
; AND FITNESS.  
; 
; FULL PERMISSION AND CONSENT IS HEREBY GIVEN TO DECUS AND TO THE  DECUS
; SPECIAL INTEREST GROUPS TO REPRODUCE, DISTRIBUTE, AND PUBLISH AND PER-
; MIT OTHERS TO REPRODUCE IN WHOLE OR IN PART, IN ANY FORM  AND  WITHOUT
; RESTRICTION, THIS PROGRAM AND ANY INFORMATION RELATING TO IT.
;
; 
; AUTHOR:
;
;	UNKNOWN
;
;
; MODIFIED BY:
;
	.PAGE
;
; MACRO DEFINITIONS
;

	.MCALL	PUT$		;WRITE A RECORD

;
; LOCAL MACROS
;

	.MACRO	WRITE,RECORD,HEADRC,COUNTR,FLAG
				;OUTPUT MACRO
	JSR	R5,OUTPUT	;CALL OUTPUT ROUTINE
	.WORD	RECORD		;ADDR OF RECORD TO BE WRITTEN
	.WORD	HEADRC		;ADDR OF TITLE (IF PAGINATION OCCURS)
	.WORD	COUNTR		;ADDR OF LINE COUNTER TO BE UPDATED
	.WORD	FLAG		;LOGICAL FLAG FOR PAGE NUMBERING
	.ENDM

;
; LOCAL SYMBOLS
;
; LOCAL DATA
;
	.PAGE
	.SBTTL	PROCES PROCESS A RECORD
;@ RECORD PROCESSING FOR DOCUMENTATION
;+
;*-PROCES - PROCESS A RECORD
;
; THIS ROUTINE TAKES A DOCUMENTATION RECORD PASSED TO IT BY "DOCEXT",
; AND DETERMINES WHAT ROUTINE TO CALL, BASED ON THE COMMAND CHARACTER
; IN COLUMN TWO.  ROUTINE ACCESS IS GOVERNED BY TWO TABLES: "COMAND",
; A TABLE OF THE COMMAND CHARACTERS,  AND  "ADRTBL",  A  TABLE OF THE
; ROUTINE ADDRESSES CORRESPONDING TO THE COMMAND CHARACTERS.
;
;
; INPUTS:
;
;	RECBUF - DOCUMENTATION RECORD
;
;
; OUTPUTS:
;
;	NONE
;
;
; EFFECTS:
;
;	NECESSARY EDITING IS PERFORMED, AND THE RECORD WRITTEN TO THE
;	APPROPRIATE FILES, DEPENDING ON THE STATES OF VARIOUS FLAGS
;
;
; SUBROUTINES CALLED:
;
;$	ASTRSK - TITLE OF CURRENT ROUTINE
;$	AT     - TITLE FOR A GROUP OF RELATED ROUTINES
;$	BLANK  - REGULAR DOCUMENTATION
;$	DOLLAR - SUBROUTINE CALLED BY CURRENT ROUTINE
;$	EQUAL  - STOP DOCUMENTATION EXTRACTION
;$	MINUS  - STOP DOCUMENTATION EXTRACTION AND FORM FEED
;$	PLUS   - START DOCUMENTATION EXTRACTION
;$	SLASH  - FORM FEED
;-
	
PROCES::
	MOV	R1,-(SP)	;SAVE REGISTER 1
	CMPB	COMENT,RECBUF
	BEQ	10$		;JUMP IF 1ST CHAR = COMMENT DELIMITER
	MOV	#MAXCMD,R1	;ELSE TREAT AS IF ";" ("C ")
	BR	30$
10$:
	CLR	R1		;INIT FOR TABLE SEARCH
20$:
	CMPB	COMAND(R1),RECBUF+1
	BEQ	30$		;JUMP IF MATCHING CHAR FOUND
	INC	R1		;BUMP OFFSET
	CMP	#MAXCMD,R1	;CHECK FOR END OF TABLE
	BNE	20$		;ELSE LOOP UNTIL MATCH FOUND
30$:
	ASL	R1		;CONVERT BYTE OFFSET TO WORD OFFSET
	CALL	@ADRTBL(R1)	;CALL APPROPRIATE ROUTINE
	MOV	(SP)+,R1	;RESTORE REGISTER 1
	RETURN
	.PAGE
	.SBTTL	PLUS  	START DOCUMENTATION EXTRACTION
;+
;* -PLUS  -  START DOCUMENTATION EXTRACTION
;
; THIS ROUTINE PROCESSES ";+" ("C+") RECORDS.  THIS TYPE OF RECORD IS USED
; TO TURN THE EXTRACTOR ON.  IF THE LINE COUNTER INDICATES THAT THE EXTRAC-
; TOR IS CURRENTLY AT TOP-OF-FORM, THE PAGE HEADER IS PRINTED.
;
;
; INPUTS:
;
;	RECBUF - DOCUMENTATION RECORD
;
;
; OUTPUTS:
;
;	PRINT  - SET TO ".TRUE." TO TURN EXTRACTOR ON
;
;
; EFFECTS:
;
;	RECORD(S) WRITTEN TO THE DOCUMENTATION FILE
;
;
; SUBROUTINES CALLED:
;
;$	HEADER - WRITE PAGE HEADER
;-
	
PLUS::
	MOV	R0,-(SP)	;SAVE REGISTERS
	MOV	R1,-(SP)

;
; TURN EXTRACTOR ON.
;

	MOVB	#.TRUE.,PRINT

;
; IF TOP-OF-FORM, PRINT HEADER.
;

	MOV	#DOCFDB,R0	;R0 = DOCUMENTATION FILE DESC. BLOCK
	TST	DOCLCT
	BMI	10$		;JUMP IF HEADER ALREADY WRITTEN
	BNE	20$		;JUMP IF NOT TOP-OF-FORM
	MOV	#TITLE,R1	;R1 = TITLE RECORD
	CALL	HEADER		;WRITE PAGE HEADER
	BCS	30$		;JUMP IF ERROR
	BR	20$		;ELSE WRITE THE RECORD
10$:
	CLR	DOCLCT		;SET TO TOP-OF-FORM

;
; WRITE THE RECORD.
;

20$:
	WRITE	RECBUF,TITLE,DOCLCT,.TRUE.
30$:
	MOV	(SP)+,R1	;RESTORE REGISTERS
	MOV	(SP)+,R0
	RETURN
	.PAGE
	.SBTTL	MINUS 	STOP DOCUMENTATION EXTRACTION AND FORM FEED
;+
;* -MINUS -  STOP DOCUMENTATION EXTRACTOR AND FORM FEED
;
; THIS ROUTINE PROCESSES ";-" ("C-") RECORDS.  THIS TYPE OF RECORD IS USED
; TO STOP DOCUMENTATION EXTRACTION, AND TO GENERATE A FORM FEED IN THE DOCU-
; MENTATION LISTING.  IF, HOWEVER, THE "SUBROUTINES CALLED ONLY" SWITCH
; ("/SB") IS PRESENT, A BLANK LINE RATHER THAN A FORM FEED IS INSERTED IN THE
; LISTING.
;
;
; INPUTS:
;
;	RECBUF - DOCUMENTATION RECORD
;
;
; OUTPUTS:
;
;	PRINT  - SET TO ".FALS." TO TURN EXTRACTOR OFF
;
;
; EFFECTS:
;
;	RECORD(S) WRITTEN TO DOCUMENTATION FILE
;
;
; SUBROUTINES CALLED:
;
;$	PUTPAG - INSERT SECTION AND PAGE NUMBERS INTO RECORD
;$	WRITBL - WRITE BLANK LINE
;$	WRITFF - WRITE FORM FEED
;-
	
MINUS::
	MOV	R0,-(SP)	;SAVE REGISTERS
	MOV	R1,-(SP)

;
; WRITE THE RECORD.
;

	MOV	#DOCFDB,R0	;R0 = DOCUMENTATION FILE DESC. BLOCK
	WRITE	RECBUF,TITLE,DOCLCT,.TRUE.
	BCS	20$		;JUMP IF ERROR

;
; TURN EXTRACTOR OFF.
;

	MOVB	#.FALS.,PRINT

;
; IF "/SB" SWITCH NOT PRESENT, GENERATE A FORM FEED.
;

	BIT	#SBMSK,OUTFLG	;CHECK FOR GLOBAL "SUBROUTINES CALLED"
	BNE	10$		;JUMP IF "/SB" ON
	BIT	#SBMSK,INFLG	;CHECK FOR LOCAL "SUBROUTINES CALLED"
	BNE	10$		;JUMP IF "/SB" ON
	INC	PAGECT		;BUMP PAGE COUNTER
	MOV	#TITLE,R1	;R1 = TITLE RECORD
	CALL	PUTPAG		;UPDATE PAGE NUMBER IN TITLE
	CALL	WRITFF		;WRITE FORM FEED RECORD
	BCS	20$		;JUMP IF ERROR
	CLR	DOCLCT		;RESET LINE COUNTER
	BR	20$

;
; IF "/SB" SWITCH PRESENT, GENERATE A LINE FEED.
;

10$:
	CALL	WRITBL		;WRITE BLANK LINE
	BCS	20$		;JUMP IF ERROR
	INC	DOCLCT		;BUMP LINE COUNTER
20$:
	MOV	(SP)+,R1	;RESTORE REGISTERS
	MOV	(SP)+,R0
	RETURN
	.PAGE
	.SBTTL	AT    	TITLE FOR A GROUP OF RELATED ROUTINES
;+
;* -AT    -  TITLE FOR A GROUP OF RELATED ROUTINES
;
; THIS ROUTINE PROCESSES ";@" ("C@") RECORDS.  THIS TYPE OF RECORD IS USED
; TO GENERATE A TITLE FOR A GROUP OF RELATED ROUTINES.  THIS TITLE IS PRINTED
; WHEN THIS LINE IS PROCESSED AS WELL AS EVERY TOP-OF-FORM AFTER IT, SO IT
; SHOULD ALWAYS FOLLOW A TOP-OF-FORM COMMAND (";-" OR ";/").  NOTE:  TABS
; SHOULD NOT BE USED IN A ";@" ("C@") LINE, AS THE EXTRACTOR WILL COUNT A TAB
; AS ONE CHARACTER BUT PRINT IT AS SEVERAL SPACES, THUS MISALIGNING THE TITLE.
;
;
; INPUTS:
;
;	RECBUF - DOCUMENTATION RECORD
;
;
; OUTPUTS:
;
;	TITLE  - TITLE RECORD UPDATED
;
;
; EFFECTS:
;
;	RECORD(S) WRITTEN TO THE DOCUMENTATION FILE AND TABLE-OF-CONTENTS FILE
;
;
; SUBROUTINES CALLED:
;
;$	HEADER - WRITE PAGE HEADER
;$	PUTPAG - INSERT SECTION AND PAGE NUMBERS INTO RECORD
;$	WRITBL - WRITE BLANK LINE
;$	WRITFF - WRITE FORM FEED
;-
	
AT::
	MOV	R0,-(SP)	;SAVE REGISTERS
	MOV	R1,-(SP)

;
; COPY TEXT OF RECORD INTO TITLE RECORD.
;

	MOV	#LENGTH,R1	         ;R1 = LENGTH OF TEXT PORTION
10$:
	MOVB	RECBUF+1(R1),TITLE-1(R1) ;COPY TEXT, STRIPPING ";@"
	SOB	R1,10$

;
; START OF NEW SECTION:  INCREMENT SECTION NUMBER.
;

	CMPB	#.TRUE.,SECFLG
	BEQ	20$		;JUMP IF FIRST SECTION
	INC	SECTCT		;ELSE BUMP SECTION NUMBER
20$:
	MOVB	#.FALS.,SECFLG	;NO LONGER FIRST SECTION
	MOV	#1,PAGECT	;RESET PAGE COUNTER
	MOV	#TITLE,R1	;R1 = TITLE RECORD
	CALL	PUTPAG		;PUT PAGE NUMBER IT IT

;
; IF A TABLE OF CONTENTS IS BEING GENERATED, ENTER THIS RECORD.
;

	BIT	#TCMSK,OUTFLG
	BEQ	30$		;JUMP IF "/TC" OFF
	MOV	#TOCFDB,R0	;R0 = TABLE OF CONTENTS F.D.B.
	CALL	WRITBL		;BLANK LINE SEPARATOR
	BCS	60$		;JUMP IF ERROR
	INC	TOCLCT		;COUNT BLANK LINE
	WRITE	TITLE,TABCON,TOCLCT,.FALS.
	BCS	60$		;JUMP IF ERROR

;
; WRITE THE HEADER.
;

30$:
	MOV	#DOCFDB,R0	;R0 = DOCUMENTATION FILE DESC. BLOCK
	BIT	#SBMSK,OUTFLG	;CHECK FOR GLOBAL "SUBROUTINES CALLED"
	BNE	40$		;JUMP IF "/SB" ON
	BIT	#SBMSK,INFLG	;CHECK FOR LOCAL "SUBROUTINES CALLED"
	BEQ	50$		;JUMP IF "/SB" OFF
40$:
	CALL	WRITFF		;FORM FEED FOR SUBR ONLY LIST
	BCS	60$		;JUMP IF ERROR
50$:
	MOV	#TITLE,R1	;R1 = TITLE RECORD
	CALL	HEADER		;WRITE PAGE HEADER
	BCS	60$		;JUMP IF ERROR
	MOV	#-1,DOCLCT	;SET LINE COUNT FOR HEADER ALREADY WRITTEN
60$:
	MOV	(SP)+,R1	;RESTORE REGISTERS
	MOV	(SP)+,R0
	RETURN
	.PAGE
	.SBTTL	DOLLAR	SUBROUTINE CALLED BY THE CURRENT ROUTINE
;+
;* -DOLLAR-  SUBROUTINE CALLED BY THE CURRENT ROUTINE
;
; THIS ROUTINE PROCESSES ";$" ("C$") RECORDS.  THIS TYPE OF RECORD IS USED
; TO LIST SUBROUTINES CALLED BY THE CURRENT ROUTINE.  THE SUBROUTINE LIST CAN
; BE GENERATED BY ITSELF BY USE OF THE "/SB" SWITCH.  ALSO, SUBROUTINES CAN
; BE CROSS-REFERENCED BY USE OF THE "/CR" SWITCH.
;
;
; INPUTS:
;
;	RECBUF - DOCUMENTATION RECORD
;
;
; OUTPUTS:
;
;	SUBRTN - SUBROUTINE NAME
;
;
; EFFECTS:
;
;	RECORD(S) WRITTEN TO THE DOCUMENTATION FILE AND THE CROSS-REFERENCE
;	FILE
;
;
; SUBROUTINES CALLED:
;
;$	$CAT5B - CONVERT ASCII (WITH BLANKS) TO RADIX-50
;$	PULNAM - PULL NAME OUT OF DOCUMENTATION RECORD
;-
	
DOLLAR::
	MOV	R0,-(SP)	;SAVE REGISTERS
	MOV	R1,-(SP)
	CMPB	#.TRUE.,PRINT
	BNE	10$		;JUMP IF EXTRACTOR OFF
	MOV	#DOCFDB,R0	;R0 = DOCUMENTATION FILE DESC. BLOCK
	WRITE	RECBUF,TITLE,DOCLCT,.TRUE.
	BCS	30$		;JUMP IF ERROR

;
; IF A CROSS-REFERENCE IS BEING GENERATED, ENTER THIS RECORD.
;

10$:
	BIT	#CRMSK,OUTFLG
	BEQ	30$		;JUMP IF "/CR" OFF
	MOV	#6,R1		;SET UP FOR CLEARING NAME
20$:
	MOVB	#CR.SPA,SUBRTN-1(R1)
				;SPACE OUT NAME BUFFER
	SOB	R1,20$
	MOV	#SUBRTN,R1	;R1 = SUBROUTINE NAME BUFFER
	CALL	PULNAM		;PULL SUBROUTINE NAME OUT
	MOV	#SUBRTN,R0	;R0 = SUBROUTINE NAME BUFFER
	MOV	#1,R1		;R1 = PERIOD IS VALID CHAR
	CALL	$CAT5B		;CONVERT ASCII TO RAD50
	MOV	R1,CRFREC+XR.NAM;STORE 1ST HALF OF SUB NAME
	MOV	#1,R1
	CALL	$CAT5B
	MOV	R1,CRFREC+XR.NAM+2
				;STORE 2ND HALF OF SUB NAME
	MOV	#1,R1
	CALL	$CAT5B
	MOV	R1,CRFREC+XR.REF;STORE 1ST HALF OF RTN NAME
	MOV	#1,R1
	CALL	$CAT5B
	MOV	R1,CRFREC+XR.REF+2
				;STORE 2ND HALF OF RTN NAME
	CLRB	CRFREC+XR.FOR	;FORMAT #0
	PUT$	#CRFFDB,#CRFREC,#CRFRLN,IOERR
30$:
	MOV	(SP)+,R1	;RESTORE REGISTERS
	MOV	(SP)+,R0
	RETURN
	.PAGE
	.SBTTL	ASTRSK	TITLE FOR A ROUTINE
;+
;* -ASTRSK-  TITLE FOR A ROUTINE
;
; THIS ROUTINE PROCESSES ";*" ("C*") RECORDS.  THIS TYPE OF RECORD IS USED
; TO NAME A ROUTINE.  THE NAME IS USED IN THE TABLE OF CONTENTS, AS WELL AS
; THE CROSS-REFERENCE AND INDEX.
;
;
; INPUTS:
;
;	RECBUF - DOCUMENTATION RECORD
;
;
; OUTPUTS:
;
;	ROUTIN - ROUTINE NAME
;
;
; EFFECTS:
;
;	RECORD(S) WRITTEN TO THE DOCUMENTATION FILE, TABLE-OF-CONTENTS FILE,
;	AND CROSS-REFERENCE FILE.
;
;
; SUBROUTINES CALLED:
;
;$	$CAT5B - CONVERT ASCII (WITH BLANKS) TO RADIX-50
;$	PULNAM - PULL ROUTINE NAME OUT OF RECORD
;$	PUTPAG - INSERT SECTION AND PAGE NUMBERS INTO RECORD
;-
	
ASTRSK::
	MOV	R0,-(SP)	;SAVE REGISTERS
	MOV	R1,-(SP)
	CMPB	#.TRUE.,PRINT
	BNE	10$		;JUMP IF EXTRACTOR OFF
	MOV	#DOCFDB,R0	;R0 = DOCUMENTATION FILE DESC. BLOCK
	WRITE	RECBUF,TITLE,DOCLCT,.TRUE.
	BCS	20$		;JUMP IF ERROR

;
; IF A TABLE OF CONTENTS IS BEING GENERATED, ENTER THIS RECORD.
;

	BIT	#TCMSK,OUTFLG
	BEQ	10$		;JUMP IF "/TC" OFF
	MOV	#TOCFDB,R0	;R0 = TABLE-OF-CONTENTS FILE DESC. BLOCK
	MOV	#RECBUF,R1	;R1 = DOCUMENTATION RECORD
	CALL	PUTPAG		;INSERT SECTION AND PAGE NUMBERS
	WRITE	RECBUF,TABCON,TOCLCT,.FALS.
	BCS	20$		;JUMP IF ERROR

;
; IF AN INDEX OR A CROSS-REFERENCE IS BEING GENERATED, GET THE ROUTINE NAME.
;

10$:
	BIT	#INMSK!CRMSK,OUTFLG
	BEQ	20$		;JUMP IF NO CREF FILE
	MOV	#ROUTIN,R1	;R1 = ROUTINE NAME BUFFER
	CALL	PULNAM		;PULL THE NAME OUT

;
; IF AN INDEX IS BEING GENERATED, ENTER THIS RECORD.
;

	BIT	#INMSK,OUTFLG
	BEQ	20$		;JUMP IF "/IN" OFF
	MOV	#ROUTIN,R0	;R0 = ROUTINE NAME BUFFER
	MOV	#1,R1		;R1 = PERIOD IS VALID CHAR
	CALL	$CAT5B		;CONVERT ASCII TO RAD50
	MOV	R1,CRFREC+XR.NAM;STORE 1ST HALF OF RTN NAME
	MOV	#1,R1
	CALL	$CAT5B
	MOV	R1,CRFREC+XR.NAM+2
				;STORE 2ND HALF OF RTN NAME
	MOV	SECTCT,CRFREC+XR.SEC
				;STORE SECTION NUMBER
	MOV	PAGECT,CRFREC+XR.PAG
				;STORE PAGE NUMBER
	MOVB	#1,CRFREC+XR.FOR;FORMAT #1
	PUT$	#CRFFDB,#CRFREC,#CRFRLN,IOERR
20$:
	MOV	(SP)+,R1	;RESTORE REGISTERS
	MOV	(SP)+,R0
	RETURN
	.PAGE
	.SBTTL	SLASH 	FORM FEED
;+
;* -SLASH -  FORM FEED
;
; THIS ROUTINE PROCESSES ";/" ("C/") RECORDS.  THIS TYPE OF RECORD IS USED
; TO GENERATE A FORM FEED IN THE DOCUMENTATION LISTING, UNLESS ONLY THE
; SUBROUTINES CALLED ARE LISTED, IN WHICH CASE A BLANK LINE IS GENERATED.
;
;
; INPUTS:
;
;	RECBUF - DOCUMENTATION RECORD
;
;
; OUTPUTS:
;
;	NONE
;
;
; EFFECTS:
;
;	RECORD(S) WRITTEN TO THE DOCUMENTATION FILE
;
;
; SUBROUTINES CALLED:
;
;$	HEADER - WRITE PAGE HEADER
;$	PUTPAG - INSERT SECTION AND PAGE NUMBERS INTO RECORD
;$	WRITBL - WRITE BLANK LINE
;$	WRITFF - WRITE FORM FEED
;-
	
SLASH::
	MOV	R0,-(SP)	;SAVE REGISTERS
	MOV	R1,-(SP)
	CMPB	#.TRUE.,PRINT
	BNE	20$		;JUMP IF EXTRACTOR OFF
	MOV	#DOCFDB,R0	;R0 = DOCUMENTATION FILE DESC. BLOCK
	WRITE	RECBUF,TITLE,DOCLCT,.TRUE.
	BCS	20$		;JUMP IF ERROR

;
; GENERATE FORM FEED FOR REGULAR LISTING.
;

	BIT	#SBMSK,OUTFLG	;CHECK FOR GLOBAL "SUBROUTINES CALLED"
	BNE	10$		;JUMP IF "/SB" ON
	BIT	#SBMSK,INFLG	;CHECK FOR LOCAL "SUBROUTINES CALLED"
	BNE	10$		;JUMP IF "/SB" ON
	CALL	WRITFF		;GENERATE A FORM FEED
	BCS	20$		;JUMP IF ERROR
	INC	PAGECT		;BUMP PAGE COUNTER
	MOV	#TITLE,R1	;R1 = TITLE RECORD
	CALL	PUTPAG		;PUT SECTION AND PAGE NUMBERS IN
	CALL	HEADER		;WRITE PAGE HEADER
	BCS	20$		;JUMP IF ERROR
	CLR	DOCLCT		;RESET LINE COUNTER
	BR	20$

;
; GENERATE LINE FEED FOR SUBROUTINES CALLED LISTING.
;

10$:
	CALL	WRITBL		;WRITE BLANK LINE
	BCS	20$		;JUMP IF ERROR
	INC	DOCLCT		;BUMP LINE COUNTER
20$:
	MOV	(SP)+,R1	;RESTORE REGISTERS
	MOV	(SP)+,R0
	RETURN
	.PAGE
	.SBTTL	EQUAL 	STOP DOCUMENTATION EXTRACTION
;+
;* -EQUAL -  STOP DOCUMENTATION EXTRACTION
;
; THIS ROUTINE PROCESSES ";=" ("C=") RECORDS.  THIS TYPE OF RECORD IS USED
; TO STOP DOCUMENTATION EXTRACTION, WITHOUT GENERATING A FORM FEED.
;
;
; INPUTS:
;
;	RECBUF - DOCUMENTATION RECORD
;
;
; OUTPUTS:
;
;	PRINT  - SET TO ".FALS." TO TURN EXTRACTOR OFF
;
;
; EFFECTS:
;
;	RECORD(S) WRITTEN TO THE DOCUMENTATION FILE
;-
	
EQUAL::
	MOV	R0,-(SP)	;SAVE REGISTER 0
	CMPB	#.TRUE.,PRINT
	BNE	10$		;JUMP IF EXTRACTOR OFF
	MOV	#DOCFDB,R0	;R0 = DOCUMENTATION FILE DESC. BLOCK
	WRITE	RECBUF,TITLE,DOCLCT,.TRUE.
	BCS	10$		;JUMP IF ERROR
	MOVB	#.FALS.,PRINT	;TURN EXTRACTOR OFF
10$:
	MOV	(SP)+,R0	;RESTORE REGISTER 0
	RETURN
	.PAGE
	.SBTTL	BLANK 	REGULAR DOCUMENTATION
;+
;* -BLANK -  REGULAR DOCUMENTATION
;
; THIS ROUTINE PROCESSES ";" ("C ") RECORDS.  THIS TYPE OF RECORD IS USED
; FOR REGULAR DOCUMENTATION.  ANY LINE NOT COVERED BY ONE OF THE COMMAND
; TYPES ABOVE IS HANDLED BY THIS ROUTINE.
;
;
; INPUTS:
;
;	RECBUF - DOCUMENTATION RECORD
;
;
; OUTPUTS:
;
;	NONE
;
;
; EFFECTS:
;
;	RECORD(S) WRITTEN TO THE DOCUMENTATION FILE
;-
	
BLANK::
	MOV	R0,-(SP)	;SAVE REGISTER 0
	CMPB	#.TRUE.,PRINT
	BNE	10$		;JUMP IF EXTRACTOR OFF
	BIT	#SBMSK,OUTFLG	;CHECK FOR GLOBAL "SUBROUTINES CALLED"
	BNE	10$		;JUMP IF "/SB" ON
	BIT	#SBMSK,INFLG	;CHECK FOR LOCAL "SUBROUTINES CALLED"
	BNE	10$	 	;JUMP IF "/SB" ON
	MOV	#DOCFDB,R0	;R0 = DOCUMENTATION FILE DESC. BLOCK
	WRITE	RECBUF,TITLE,DOCLCT,.TRUE.
10$:
	MOV	(SP)+,R0	;RESTORE REGISTER 0
	RETURN
	.PAGE
	.SBTTL	HEADER	WRITE PAGE HEADER
;@ WORK ROUTINES
;+
;* -HEADER-  WRITE PAGE HEADER
;
; THIS ROUTINE WRITES THE PAGE HEADER TO THE APPROPRIATE FILE. THE PAGE
; HEADER CONSISTS OF:
;
;	GENERAL TITLE - "AUTOMATIC DOCUMENTATION EXTRACTOR"
;	SPECIFIC TITLE - "TABLE OF CONTENTS" OR ;@ TITLE
;	A BLANK LINE
;
;
; INPUTS:
;
;	R0     - ADDRESS OF FILE DESCRIPTOR BLOCK
;	R1     - ADDRESS OF SPECIFIC TITLE RECORD
;
;
; OUTPUTS:
;
;	R0, R1 NOT CHANGED
;
;
; EFFECTS:
;
;	PAGE HEADER WRITTEN TO THE FILE
;-
	
HEADER::
	BIT	#LIMSK,OUTFLG
	BEQ	10$		;JUMP IF "/LI" SWITCH OFF
	PUT$	,#HEAD,#RECLN,IOERR
				;WRITE GENERAL TITLE
	BCS	10$		;JUMP IF ERROR
	PUT$	,R1,#RECLN,IOERR;WRITE SPECIFIC TITLE
	BCS	10$		;JUMP IF ERROR
	PUT$	,#BLNKLN,#1.,IOERR
				;A BLANK LINE
10$:
	RETURN
	.PAGE
	.SBTTL	OUTPUT	WRITE A RECORD
;+
;* -OUTPUT-  WRITE A RECORD
;
; THIS ROUTINE WRITES A GENERAL RECORD TO THE APPROPRIATE FILE.  PROPER
; ENTRY IS BY USE OF THE "WRITE" MACRO, WHICH IS IN THE FOLLOWING FORM:
;
;	WRITE	RECORD,HEADRC,COUNTR,FLAG
;
;	WHERE:	RECORD	IS THE ADDRESS OF THE RECORD TO BE WRITTEN,
;		HEADRC	IS THE ADDRESS OF THE TITLE RECORD TO BE USED IF
;			PAGINATION OCCURS AND A HEADER MUST BE WRITTEN,
;		COUNTR	IS THE ADDRESS OF THE LINE COUNTER TO BE UPDATED, AND
;		FLAG	IS A LOGICAL FLAG (.TRUE. OR .FALS.) TO INDICATE
;			WHETHER OR NOT THE PAGE NUMBER IS TO BE INSERTED INTO
;			THE HEADER RECORD.
;
;
; INPUTS:
;
;	R0     - ADDRESS OF FILE DESCRIPTOR BLOCK
;
;
; OUTPUTS:
;
;	R0 NOT CHANGED
;
;
; EFFECTS:
;
;	RECORD(S) WRITTEN TO THE APPROPRIATE FILE
;
;
; SUBROUTINES CALLED:
;
;$	HEADER - WRITE PAGE HEADER
;$	PUTPAG - INSERT SECTION AND PAGE NUMBERS INTO RECORD
;$	WRITFF - WRITE FORM FEED
;-
	
OUTPUT::
	MOV	R1,-(SP)	;SAVE REGISTERS
	MOV	R2,-(SP)
	MOV	R3,-(SP)
	MOV	R4,-(SP)
	MOV	(R5)+,R2	;R2 = RECORD ADDRESS
	MOV	(R5)+,R1	;R1 = TITLE RECORD ADDRESS
	MOV	(R5)+,R3	;R3 = LINE COUNTER ADDRESS
	MOV	(R5)+,R4	;R4 = PAGE NUMBER FLAG

;
; PAGINATE IF NECESSARY.
;

	CMP	(R3),#MAXLIN
	BLT	20$		;JUMP IF LINE COUNT < MAX
	CMP	#.TRUE.,R4
	BNE	10$		;JUMP IF PAGE NUMBER NOT WANTED
	INC	PAGECT		;BUMP PAGE COUNTER
	CALL	PUTPAG		;INSERT SECTION AND PAGE NUMBERS
10$:
	CALL	WRITFF		;GENERATE A FORM FEED
	BCS	90$		;JUMP IF ERROR
	CALL	HEADER		;WRITE PAGE HEADER
	BCS	90$		;JUMP IF ERROR
	CLR	(R3)		;RESET LINE COUNTER

;
; EDIT OUT COMMENT DELIMITER AND COMMAND CHARACTER.
;

20$:
	CMPB	COMENT,(R2)
	BNE	30$		;JUMP IF NOT COMMENT
	MOVB	#CR.SPA,(R2)	;SPACE OUT DELIMITER
	CMPB	#CR.TAB,1(R2)
	BEQ	30$		;JUMP IF TAB CHARACTER
	MOVB	#CR.SPA,1(R2)	;ELSE SPACE IT OUT

;
; GET THE RECORD LENGTH.
;

30$:
	MOV	#LENTBL,R4	;R4 = RECORD LENGTH TABLE
40$:
	CMP	R2,(R4)+	;SEARCH TABLE FOR RECORD ADDR
	BEQ	50$		;JUMP WHEN RECORD FOUND
	TST	(R4)+		;BUMP R4 FOR RECORD LENGTH
	BR	40$		;AND LOOP
50$:
	TST	(R4)		;TEST RECORD LENGTH
	BEQ	60$		;JUMP IF LENGTH = 0
	MOV	(R4),R4		;ELSE R4 = RECORD LENGTH FROM TABLE
	BR	70$
60$:
	MOV	RLNGTH,R4	;R4 = VARIABLE RECORD LENGTH

;
; WRITE THE RECORD.
;

70$:
	BIT	#LIMSK,OUTFLG
	BEQ	80$		;JUMP IF "/LI" SWITCH OFF
	PUT$	,R2,R4,IOERR
	BCS	90$		;JUMP IF ERROR
80$:
	INC	(R3)		;BUMP LINE COUNTER
90$:
	MOV	(SP)+,R4	;RESTORE REGISTERS
	MOV	(SP)+,R3
	MOV	(SP)+,R2
	MOV	(SP)+,R1
	RTS	R5
	.PAGE
	.SBTTL	SETTLE	SET FILENAME INTO TITLE RECORD
;+
;* -SETTLE-  SET FILENAME INTO TITLE RECORD
;
; THIS ROUTINE PUTS THE CURRENT INPUT FILENAME INTO THE TITLE RECORD
; FOR THE TABLE OF CONTENTS AND PAGE HEADERS.
;
;
; INPUTS:
;
;	R0     - ADDRESS OF FILE DESCRIPTOR BLOCK
;
;
; OUTPUTS:
;
;	R0 NOT CHANGED
;	FILNAM - CURRENT INPUT FILENAME
;
;
; EFFECTS:
;
;	FILENAME INSERTED INTO TITLE RECORD.
;
;
; SUBROUTINES CALLED:
;
;$	$C5TA  - CONVERT RADIX-50 TO ASCII
;-
	
SETTLE::
	MOV	R0,-(SP)	;SAVE REGISTERS
	MOV	R1,-(SP)
	MOV	R3,-(SP)

;
; SET TITLE TO DEFAULT.
;

	MOV	#RECLN,R1	         ;R1 = RECORD LENGTH
10$:
	MOVB	DEFAUL-1(R1),TITLE-1(R1) ;COPY DEFAULT INTO TITLE
	SOB	R1,10$

;
; COPY IN NAME PORTION OF FILENAME.
;

	MOV	R0,R3		;R3 = ADDR OF FILE DESC. BLOCK
	MOV	#FILNAM,R0	;R0 = FILENAME BUFFER
	MOV	F.FNB+N.FNAM(R3),R1
				;GET 1ST THREE CHARACTERS
	CALL	$C5TA		;CONVERT RAD50 TO ASCII
	MOV	F.FNB+N.FNAM+2(R3),R1
				;GET NEXT THREE CHARACTERS
	CALL	$C5TA
	MOV	F.FNB+N.FNAM+4(R3),R1
				;GET LAST THREE CHARACTERS
	CALL	$C5TA

;
; APPEND EXTENT PORTION OF FILENAME.
;

20$:
	CMPB	#CR.SPA,-(R0)	;BACK UP UNTIL NON-SPACE FOUND
	BEQ	20$
	INC	R0		;R0 = ADDR OF 1ST SPACE
	MOVB	#CR.PER,(R0)+	;STUFF PERIOD SEPARATOR
	MOV	F.FNB+N.FTYP(R3),R1
				;GET FILE EXTENT
	CALL	$C5TA		;CONVERT RAD50 TO ASCII

;
; COPY FILENAME INTO TITLE RECORD, RIGHT-JUSTIFYING IT.
;

	MOV	#66.,R1		;R1 = OFFSET FOR END OF NAME
30$:
	MOVB	-(R0),TITLE(R1)	;COPY ONE CHARACTER
	DEC	R1		;DECR OFFSET
	CMP	#FILNAM,R0
	BNE	30$		;LOOP UNTIL FINISHED
	MOV	(SP)+,R3	;RESTORE REGISTERS
	MOV	(SP)+,R1
	MOV	(SP)+,R0
	RETURN
	.PAGE
	.SBTTL	PUTPAG	INSERT SECTION AND PAGE NUMBERS INTO RECORD
;+
;* -PUTPAG-  INSERT SECTION AND PAGE NUMBERS INTO RECORD
;
; THIS ROUTINE CONVERTS THE SECTION AND PAGE NUMBERS INTO ASCII, AND STUFFS
; THEM INTO THE RECORD.
;
;
; INPUTS:
;
;	R1     - ADDRESS OF RECORD
;
;
; OUTPUTS:
;
;	R1 NOT CHANGED
;	ASCIIS - SECTION NUMBER (ASCII)
;	ASCIIP - PAGE NUMBER (ASCII)
;
;
; EFFECTS:
;
;	SECTION AND PAGE NUMBERS INSERTED INTO RECORD
;
;
; SUBROUTINES CALLED:
;
;$	$CBDMG - CONVERT BINARY TO ASCII DECIMAL MAGNITUDE
;-
	
PUTPAG::
	MOV	R0,-(SP)	;SAVE REGISTERS
	MOV	R1,-(SP)
	MOV	R2,-(SP)
	MOV	R3,-(SP)
	MOV	R1,R3		;R3 = RECORD ADDRESS

;
; SPACE OUT ASCII FIELDS.
;

	MOV	#ASCIIS,R0	;SPACE FILL SECTION NO. FIELD
	MOV	#5,R1
10$:
	MOVB	#CR.SPA,(R0)+
	SOB	R1,10$
	MOV	#ASCIIP,R0	;SPACE FILL PAGE NO. FIELD
	MOV	#5,R1
20$:
	MOVB	#CR.SPA,(R0)+
	SOB	R1,20$

;
; CONVERT SECTION AND PAGE NUMBERS TO ASCII.
;

	MOV	#ASCIIP,R0	;R0 = ADDR FOR ASCII PAGE NO.
	MOV	PAGECT,R1	;R1 = PAGE COUNT
	CLR	R2		;R2 = ZERO SUPPRESSION
	CALL	$CBDMG		;CONVERT BINARY TO DECIMAL
	MOV	#ASCIIS,R0	;R0 = ADDR FOR ASCII SECTION NO.
	MOV	SECTCT,R1	;R1 = SECTION NUMBER
	CLR	R2
	CALL	$CBDMG

;
; COPY PAGE NUMBER FORMAT (" PAGE XXX-XXX") INTO RECORD.
;

	MOV	#PAGENO,R0	;R0 = ADDR OF PAGE NUMBER FORMAT
	MOV	#67.,R1
	ADD	R3,R1		;R1 = ADDR IN RECORD FOR FORMAT
	MOV	#PAGELN,R2	;R2 = LENGTH OF FORMAT
30$:
	MOVB	(R0)+,(R1)+	;COPY ONE CHARACTER
	SOB	R2,30$

;
; COPY SECTION NUMBER INTO RECORD, RIGHT-JUSTIFYING IT AGAINST THE "-".
;

	MOV	#ASCIIS,R0	;R0 = ADDR OF ASCII SECTION NO.
	MOV	#76.,R1
	ADD	R3,R1		;R1 = ADDR IN RECORD FOR SECTION NO.
40$:
	CMPB	#CR.SPA,(R0)+
	BNE	40$		;LOOP UNTIL SPACE FOUND
	DEC	R0		;BACK UP TO SPACE
50$:
	MOVB	-(R0),-(R1)	;COPY ONE DIGIT
	CMP	#ASCIIS,R0
	BLT	50$		;LOOP UNTIL FINISHED

;
; COPY PAGE NUMBER INTO RECORD , LEFT-JUSTIFYING IT AGAINST THE "-".
;

	MOV	#ASCIIP,R0	;R0 = ADDR OF ASCII PAGE NO.
	MOV	#77.,R1
	ADD	R3,R1		;R1 = ADDR IN RECORD FOR PAGE NO.
60$:
	MOVB	(R0)+,(R1)+	;COPY ONE DIGIT
	CMPB	#CR.SPA,(R0)
	BNE	60$		;LOOP UNTIL FINISHED

;
; IF THIS IS THE GENERAL RECORD BUFFER, SET VARIABLE RECORD LENGTH TO
; MAXIMUM.
;

	CMP	R3,#RECBUF
	BNE	70$		;JUMP IF NOT GENERAL RECORD BUFFER
	MOV	#RECLN,RLNGTH	;VARIABLE RECORD LENGTH = MAXIMUM
70$:
	MOV	(SP)+,R3	;RESTORE REGISTERS
	MOV	(SP)+,R2
	MOV	(SP)+,R1
	MOV	(SP)+,R0
	RETURN
	.PAGE
	.SBTTL	PULNAM	PULL NAME OUT OF RECORD
;+
;* -PULNAM-  PULL NAME OUT OF RECORD
;
; THIS ROUTINE PULLS A ROUTINE OR SUBROUTINE NAME OUT OF A DOCUMENTATION
; RECORD.  SPACES, TABS, AND HYPHENS ARE LEGAL DELIMITERS FOR THE NAME.
; THE NAME IS ASSUMED TO BE SIX OR LESS VALID RADIX-50 CHARACTERS (A - Z,
; 0 - 9, $, AND .).
;
;
; INPUTS:
;
;	R1     - ADDRESS OF NAME BUFFER
;	RECBUF - DOCUMENTATION RECORD
;
;
; OUTPUTS:
;
;	R1 NOT CHANGED
;	(R1)   - NAME
;
;
; SUBROUTINES CALLED:
;
;$	RAD50  - CONVERT NAME CHARACTERS TO VALID RADIX-50 CHARACTERS
;-
	
PULNAM::
	MOV	R0,-(SP)	;SAVE REGISTERS
	MOV	R2,-(SP)
	MOV	R1,-(SP)

;
; CLEAR OUT THE NAME BUFFER FIRST.
;

	MOV	R1,-(SP)	;SAVE START ADDR OF NAME BUFFER
	MOV	#6,R2		;R2 = MAXIMUM LENGTH OF NAME
10$:
	MOVB	#CR.SPA,(R1)+	;SPACE IT OUT
	SOB	R2,10$		;LOOP UNTIL DONE
	MOV	(SP)+,R1	;RETRIEVE START ADDR FOR FILLING

;
; SKIP PAST COMMENT DELIMITER, COMMAND CHARACTER, SPACES, TABS, AND HYPHENS.
;

	MOV	#RECBUF+2,R0	;R0 = RECORD POINTER (SKIP DELIM & COMND)
	MOV	#6,R2		;R2 = MAXIMUM LENGTH OF NAME
20$:
	CMPB	#CR.SPA,(R0)
	BEQ	30$		;JUMP IF SPACE
	CMPB	#CR.TAB,(R0)
	BEQ	30$		;JUMP IF TAB
	CMPB	#CR.MIN,(R0)
	BNE	40$		;JUMP IF NOT HYPHEN (MINUS)
30$:
	INC	R0		;BUMP POINTER
	CMP	R0,#RECBUF+RECLN
	BEQ	50$		;JUMP IF RECORD EXHAUSTED
	BR	20$		;ELSE LOOP

;
; COPY NAME UNTIL A SPACE, TAB, OR HYPHEN IS FOUND (FOR A MAXIMUM OF 6
; CHARACTERS).
;

40$:
	CMPB	#CR.SPA,(R0)
	BEQ	50$		;JUMP IF SPACE
	CMPB	#CR.TAB,(R0)
	BEQ	50$		;JUMP IF TAB
	CMPB	#CR.MIN,(R0)
	BEQ	50$		;JUMP IF HYPHEN (MINUS)
	MOVB	(R0)+,(R1)+	;COPY CHARACTER
	SOB	R2,40$		;LOOP UNTIL FINISHED

;
; MAKE SURE ALL CHARACTERS IN NAME ARE VALID RADIX-50 CHARACTERS (UPPER CASE
; ALPHABETIC, NUMERALS, PERIOD, DOLLAR SIGN, OR SPACE).
;

50$:
	MOV	(SP)+,R1	;RETRIEVE NAME BUFFER ADDR
	CALL	RAD50		;VERIFY RADIX-50 CHARACTERS
	MOV	(SP)+,R2	;RESTORE REGISTERS
	MOV	(SP)+,R0
	RETURN
	.PAGE
	.SBTTL	RAD50	VERIFY VALID RADIX-50 CHARACTERS
;+
;* -RAD50 -  VERIFY VALID RADIX-50 CHARACTERS
;
; THIS ROUTINE CHECKS THE NAME BUFFER (AFTER  "PULNAM"  HAS PLACED A NAME
; IN IT)  FOR VALID RADIX-50 CHARACTERS (UPPER CASE ALPHABETIC, NUMERALS,
; PERIOD, DOLLAR  SIGN, AND SPACE).  IF A NON-RADIX-50 CHARACTER IS FOUND
; IN THE NAME, IT IS CONVERTED TO A PERIOD.  NOTE:  THIS ONLY AFFECTS THE
; NAME BUFFER,  USED  FOR THE INDEX AND SUBROUTINE CROSS REFERENCE ("/IN"
; AND  "/CR"  SWITCHES);  IT  DOES  NOT  AFFECT  THE TABLE OF CONTENTS OR
; DOCUMENTATION.
;
;
; INPUTS:
;
;	R1     - NAME BUFFER
;
;
; OUTPUTS:
;
;	R1 NOT CHANGED
;	(R1)   - NAME, ONLY VALID RADIX-50 CHARACTERS
;-
	
RAD50::
	MOV	R0,-(SP)	;SAVE REGISTERS
	MOV	R1,-(SP)
	MOV	R2,-(SP)
	MOV	#6,R0		;R0 = MAXIMUM NUMBER OF CHAR IN NAME
10$:
	MOV	#R50TBL,R2	;R2 = RADIX-50 CHARACTER TABLE
20$:
	CMPB	(R1),(R2)+	;CHECK FOR CHARACTER MATCH
	BEQ	30$		;JUMP IF VALID RADIX-50 CHARACTER
	TSTB	(R2)
	BNE	20$		;LOOP UNTIL END OF TABLE (ZERO)
	MOVB	#CR.PER,(R1)	;REPLACE INVALID CHAR WITH PERIOD
30$:
	INC	R1		;BUMP NAME POINTER
	SOB	R0,10$		;LOOP UNTIL NAME VERIFIED
	MOV	(SP)+,R2	;RESTORE REGISTERS
	MOV	(SP)+,R1
	MOV	(SP)+,R0
	RETURN
	.END