.TITLE	DOCEXT	DOCUMENTATION EXTRACTOR
	.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:
;
;
; MACRO DEFINITIONS
;

	.MCALL	CLOSE$		;CLOSE A FILE
	.MCALL	CSI$1		;COMMAND STRING SYNTAX CHECK
	.MCALL	CSI$2		;COMMAND STRING FILENAME PARSER
	.MCALL	DELET$		;DELETE A FILE
	.MCALL	EXIT$S		;EXIT TASK
	.MCALL	FDAT$R		;FDB DATA INITIALIZATION (RUN TIME)
	.MCALL	FDOP$R		;FDB OPEN SECTION INIT. (RUN TIME)
	.MCALL	FINIT$		;FILE I/O INITIALIZATION
	.MCALL	GET$		;READ A RECORD
	.MCALL	GCML$		;GET A COMMAND LINE
	.MCALL	GTIM$C		;GET TIME
	.MCALL	OPEN$R		;OPEN A FILE (READ)
	.MCALL	OPEN$W		;OPEN A FILE (WRITE)
	.MCALL	PRINT$		;SPOOL A FILE
	.MCALL	PUT$		;WRITE A RECORD
	.MCALL	RCML$		;RESET INDIRECT COMMAND FILE SCAN
	.MCALL	RQST$C		;REQUEST A TASK TO RUN
	.MCALL	SDAT$C		;SEND DATA BLOCK TO ANOTHER TASK


	.MACRO	ERRMSG,MSG	;ERROR MESSAGE MACRO
	JSR	R5,ERROR	;CALL ERROR MESSAGE ROUTINE
	.WORD	MSG'ER		;ERROR MESSAGE ADDRESS
	.WORD	MSG'LN		;ERROR MESSAGE LENGTH
	.ENDM

;
; LOCAL SYMBOLS
;
; LOCAL DATA
;
	.PAGE
	.SBTTL	DOCEXT - DOCUMENTATION EXTRACTOR

;@ DOCUMENTATION EXTRACTOR
;+
;* -DOCEXT - DOCUMENTATION EXTRACTOR
;
; THIS PROGRAM EXTRACTS DOCUMENTATION FROM A SET OF SOURCE FILES.  THE
; FOLLOWING CHARACTERS, WHEN APPEARING IN COLUMN #2 AFTER A COMMENT DELIMITER
; IN COLUMN #1, PROVIDE THE FOLLOWING FEATURES:
;
;	+	START DOCUMENTATION EXTRACTION
;	=	STOP DOCUMENTATION EXTRACTION
;	-	STOP DOCUMENTATION EXTRACTION AND GENERATE FORM-FEED
;	/	GENERATE FORM FEED IN DOCUMENTATION LISTING
;	@	TITLE FOR GROUP OF RELATED ROUTINES
;	*	TITLE OF A ROUTINE
;	$	NAME & DESCRIPTION OF SUBROUTINE CALLED BY THIS ROUTINE
;
; THE DOCUMENTATION LISTING IS DIVIDED INTO SECTIONS.  EACH "@" COMMENT LINE
; BEGINS A NEW SECTION.  THE TABLE OF CONTENTS AND THE INDEX GIVE THE SECTION
; AND PAGE NUMBERS FOR EACH ROUTINE.
;
; THE PROGRAM IS RUN BY ENTERING:
;
;    DOC OUTPUT-FILE[/SW...]=INPUT-FILE-1[/SW...][,INPUT-FILE-2[/SW...],...]
;
; WHERE:
;
;    OUTPUT-FILENAME	IS THE NAME OF THE DOCUMENTATON LISTING TO BE PRODUCED
;    INPUT-FILE-N	IS THE NAME OF THE NTH INPUT SOURCE FILE
;    /SW                IS A SWITCH
;
; INPUT FILES MAY BE ENTERED ON SEPARATE COMMAND LINES, OR SEVERAL (SEPARATED
; BY COMMAS) ON ONE OR MORE LINES.  A SLASH ("/") AS THE FIRST CHARACTER OF
; THE COMMAND LINE TERMINATES READING OF INPUT FILE NAMES.
;
; IF A OUTPUT FILENAME IS NOT SPECIFIED, THE DOCUMENTATION LISTING IS WRITTEN
; TO A FILE NAMED "DOCUMENT.DOC".  IF AN EXTENT (FILE TYPE) IS NOT SPECIFIED
; FOR THE OUTPUT FILE, THE DEFAULT IS ".DOC".  DEFAULT FILE EXTENTS FOR INPUT
; FILES ARE:
;
;	.ASM	FOR Z80 SOURCE CODE,
;	.MAC	FOR PDP SOURCE CODE, OR
;	.FTN	FOR FORTRAN SOURCE CODE.
;
; THE PROGRAM CAN ALSO BE RUN BY ENTERING:
;
;	DOC <CR>
;
; AND ALLOWING THE PROGRAM TO PROMPT FOR FILE NAMES, OR BY ENTERING:
;
;	DOC @COMMAND-FILE <CR>
;
; WHERE COMMAND-FILE IS THE NAME OF A FILE CONTAINING THE FILE SPECIFIERS.
;/
	.PAGE
;
; SWITCHES ARE AS FOLLOWS:
;
;    OUTPUT FILE:
;
;	/CM	LIST ONLY COMMENT LINES APPEARING BETWEEN "+" AND "=" OR "-"
;		COMMENT LINES
;	/CR	CROSS REFERENCE SUBROUTINE NAMES
;	/IN	GENERATE AN INDEX OF ROUTINE NAMES
;	/LI	LIST THE DOCUMENTATION (ONLY USED IN THE NEGATIVE SETTING,
;		WHEN ONLY THE CROSS REFERENCE AND/OR INDEX IS DESIRED)
;	/SB	LIST ONLY THE ROUTINE NAMES, AND THE SUBROUTINES CALLED BY
;		EACH ROUTINE (USING "*" AND "$" COMMENT LINES)
;	/SP	SPOOL THE OUTPUT FILE
;	/TC	GENERATE A TABLE OF CONTENTS, USING THE TITLES FROM "@" AND
;		"*" COMMENT LINES
;
;		NOTE:	ANY OF THE ABOVE SWITCHES MAY BE TURNED OFF BY TYPING
;			A MINUS SIGN OR "NO" AFTER THE SLASH (E.G., "/-SP" OR
;			"/NOSP" TO NOT SPOOL THE OUTPUT FILE).
;
;    INPUT FILE(S):
;
;	/CM	LIST ONLY COMMENT LINES APPEARING BETWEEN "+" AND "=" OR "-"
;		COMMENT LINES
;	/FT	FORTRAN SOURCE CODE
;	/PD	PDP (MACRO-11) SOURCE CODE
;	/SB	LIST ONLY THE ROUTINE NAMES, AND THE SUBROUTINES CALLED BY
;		EACH ROUTINE (USING "*" AND "$" COMMENT LINES)
;	/Z8	Z80 ASSEMBLER SOURCE CODE
;
;		NOTE:	EITHER THE "/SB" OR "/CM" SWITCH MAY BE TURNED OFF BY
;			TYPING A MINUS SIGN OR "NO" AFTER THE SLASH
;
; IF THE "/SB" AND/OR THE "/CM" SWITCH IS APPENDED TO THE OUTPUT FILE
; DESCRIPTOR, IT APPLIES TO ALL INPUT FILES.  IF EITHER OR BOTH OF THESE
; SWITCHES ARE APPENDED TO AN INPUT FILE DESCRIPTOR, THEY APPLY TO THAT INPUT
; FILE AND ALL SUBSEQUENT INPUT FILES UNLESS CHANGED.
;
; DEFAULT SWITCH SETTINGS ARE:
;
;	/TC/IN/CR/LI/SP		ON THE OUTPUT FILE, AND
;	/PD/-SB/CM		ON THE FIRST INPUT FILE
;				(SUBSEQUENT INPUT FILES USE THE SETTING FOR
;				THE PREVIOUS INPUT FILE UNLESS CHANGED)
;/
	.PAGE
	.SBTTL	DOCEXT - DRIVER LOOP FOR DOCUMENTATION EXTRACTOR

;*-DOCEXT - DRIVER LOOP FOR DOCUMENTATION EXTRACTOR
;
; THIS ROUTINE CALLS THE APPROPRIATE ROUTINES TO GET THE DOCUMENTATION.
;
;
; INPUTS:
;
;	NONE
;
;
; OUTPUTS:
;
;	NONE
;
;
; EFFECTS:
;
;	DOCUMENTATION FILE CREATED (MAY BE SPOOLED TO PRINTER)
;
;
; SUBROUTINES CALLED:
;
;$	GMCR   - GET A COMMAND LINE
;$	GNXTF  - GET NEXT INPUT FILENAME
;$	INIT   - INITIALIZE FILES, AND OPEN WORK FILES
;$	OPENIN - OPEN INPUT FILE
;$	PROCES - PROCESS A RECORD
;$	TERM   - TERMINATE DOCUMENTATION EXTRACTION
;-

DOCEXT::
	FINIT$			;INITIALIZE THE FSR'S
	CALL	GMCR		;GET A COMMAND LINE
	CALL	INIT		;INITIALIZE ALL FILES, AND OPEN WORK FILES
10$:
	CALL	OPENIN		;OPEN AN INPUT FILE
	BCS	60$		;JUMP IF ERROR
20$:
	MOV	#INFDB,R0	;R0 = INPUT FILE DESC. BLOCK
	CALL	READ		;READ A RECORD
	BCS	50$		;JUMP IF END-OF-FILE OR ERROR
	BIT	#CMMSK,OUTFLG	;CHECK FOR GLOBAL "COMMENTARY ONLY" SWITCH
	BNE	30$		;JUMP IF "COMMENTARY ONLY" IS ON
	BIT	#CMMSK,INFLG	;CHECK FOR LOCAL "COMMENTARY ONLY" SWITCH
	BEQ	40$		;JUMP IF "COMMENTARY ONLY" IS OFF
30$:
	CMPB	COMENT,RECBUF
	BNE	20$		;SKIP THIS RECORD IF NOT COMMENT
40$:
	CALL	PROCES		;PROCESS THE RECORD
	BR	20$		;GET THE NEXT RECORD
50$:
	CLOSE$	#INFDB,IOERR	;CLOSE THE INPUT FILE
	MOVB	#.FALS.,PRINT	;TURN OFF THE EXTRACTOR
	BCS	70$		;JUMP IF ERROR
60$:
	CALL	GNXTF		;GET THE NEXT INPUT FILENAME
	BCC	10$		;LOOP UNTIL NO MORE FILES
70$:
	CALL	TERM		;TERMINATE THIS DOCUMENTATION LIST
	CMPB	#.TRUE.,ENDRUN
	BNE	DOCEXT		;LOOK FOR MORE WORK IF NOT FINISHED
	EXIT$S			;ELSE STOP HERE
	.PAGE
	.SBTTL	GMCR  	GET A COMMAND LINE

;+
;*-GMCR   - GET A COMMAND LINE
;
; THIS ROUTINE GETS A COMMAND LINE FROM THE TERMINAL, AND PARSES THE
; OUTPUT AND INPUT FILE SPECIFIERS.
;
;
; INPUTS:
;
;	NONE
;
;
; OUTPUTS:
;
;	OUTDS  - OUTPUT FILE DATASET DESCRIPTOR
;	CSIBLK - FIRST INPUT FILENAME
;
;
; SUBROUTINES CALLED:
;
;$	GNXTF  - GET NEXT INPUT FILE NAME
;-

GMCR::
	MOV	R0,-(SP)	;SAVE REGISTERS
	MOV	R1,-(SP)
	MOV	R2,-(SP)
	MOV	R3,-(SP)

;
; GET A COMMAND LINE FROM THE TERMINAL.  COMMENT LINES ARE IGNORED.
; IF "@" IS THE FIRST CHARACTER, THE SPECIFIED INDIRECT COMMAND FILE
; IS OPENED, AND THE FIRST LINE IN IT IS RETURNED.
;

	MOV	#OUTDEF,OUTFLG	;SET OUTPUT FILE SWITCH DEFAULTS
	MOV	#INDEF,INFLG	;SET INPUT FILE SWITCH DEFAULTS
	BICB	#GE.CLO,CMDLCB+G.MODE
				;DON'T CLOSE THE COMMAND FILE
	GCML$	#CMDLCB		;GET A COMMAND LINE
	BCC	20$		;JUMP IF NO ERRORS
	CMPB	G.ERR(R0),#GE.EOF
	BEQ	10$		;JUMP IF END-OF-FILE
	ERRMSG	GCL		;ELSE "COMMAND LINE ERROR"
10$:
	EXIT$S			;FINISHED

;
; CHECK THE COMMAND LINE FOR CORRECT SYNTAX.
;

20$:
	MOVB	#.TRUE.,FSTCMD	;FIRST COMMAND LINE
	CMPB	#CR.SLA,@G.CMLD+2(R0)
				;"/" AS 1ST CHAR = E-O-F
	BEQ	10$		;JUMP IF E-O-F
	CSI$1	#CSIBLK,CMDLCB+G.CMLD+2,CMDLCB+G.CMLD
				;CHECK COMMAND STRING SYNTAX
	BCC	30$		;JUMP IF NO ERROR
	JMP	160$		;TOO FAR FOR "BCS 160$"
30$:
	BITB	#CS.EQU,C.STAT(R0)
	BNE	40$		;JUMP IF EQUAL SIGN
	JMP	140$		;JUMP IF NO EQUAL SIGN

;
; GET THE OUTPUT FILENAME, AND CHECK IT FOR CORRECT FORMAT.  IF CORRECT,
; STORE THE INFORMATION IN THE OUTPUT DATASET DESCRIPTOR.
;

40$:
	CSI$2	,OUTPUT,#OUTSWT	;PARSE THE OUTPUT FILENAME
	BCC	50$		;JUMP IF NO ERROR
	JMP	150$		;JUMP IF PARSING ERROR
50$:
	BIT	#SBMSK,OUTFLG
	BEQ	60$		;JUMP IF "/SB" TURNED OFF
	BIT	#CMMSK,OUTFLG
	BNE	60$		;JUMP IF SWITCHES ALRIGHT
	JMP	170$		;JUMP IF "/SB/-CM" IN SWITCHES
60$:
	BITB	#CS.WLD!CS.MOR,C.STAT(R0)
	BNE	150$		;JUMP IF WILDCARD OR MORE THAN 1 FILE
	BITB	#CS.DVF,C.STAT(R0)
	BEQ	70$		;JUMP IF NO DEVICE SPECIFIED
	MOV	C.DEVD(R0),OUTDS+N.DEVD
				;STORE DEVICE STRING LENGTH
	MOV	C.DEVD+2(R0),OUTDS+N.DEVD+2
				;STORE DEVICE STRING ADDRESS
70$:
	BITB	#CS.DIF,C.STAT(R0)
	BEQ	80$		;JUMP IF NO DIRECTORY SPECIFIED
	MOV	C.DIRD(R0),OUTDS+N.DIRD
				;STORE DIRECTORY STRING LENGTH
	MOV	C.DIRD+2(R0),OUTDS+N.DIRD+2
				;STORE DIRECTORY STRING ADDRESS
80$:
	BITB	#CS.NMF,C.STAT(R0)
	BEQ	90$		;JUMP IF NO FILENAME SPECIFIED
	MOV	C.FILD(R0),OUTDS+N.FNMD
				;STORE FILENAME STRING LENGTH
	MOV	C.FILD+2(R0),OUTDS+N.FNMD+2
				;STORE FILENAME STRING ADDRESS
;
; SET UP THE OUTPUT FILE DESCRIPTOR BLOCK:  FIXED LENGTH RECORDS OF 80 BYTES,
; PRECEEDED BY <LF> AND TERMINATED BY <CR>, AND SET APPROPRIATE LUN AND
; FILENAME.
;

90$:
	FDAT$R	#OUTFDB,#R.VAR,#FD.CR
	FDOP$R	#OUTFDB,#OUTLUN,#OUTDS,#OUTNB
	OPEN$W	#OUTFDB,,,,#RECBUF,#RECLN,IOERX

;
; COPY THE FILENAME OF THE OUTPUT FILE INTO THE DEFAULT NAME BLOCK
; FOR THE CROSS REFERENCE FILE, BECAUSE "XRF..." EXPECTS THE SAME NAME.
;

	MOV	#OUTFDB+F.FNB+N.FNAM,R1
				;R1 = ADDRESS OF OUTPUT FILE NAME
	MOV	#CRFNB+N.FNAM,R2
			 	;R2 = ADDR IN CRF NAME BLOCK
	MOV	#3,R3		;FILE NAME IS THREE WORDS LONG
100$:
	MOV	(R1)+,(R2)+	;COPY FILE NAME
	SOB	R3,100$

;
; GET THE FIRST INPUT FILENAME, AND CHECK IT FOR CORRECT FORMAT.
;

	CSI$2	#CSIBLK,INPUT,#INSWT
				;PARSE INPUT FILENAME
	BCS	130$		;JUMP IF PARSING ERROR
	BITB	#CS.NMF,C.STAT(R0)
	BNE	110$		;JUMP IF FILENAME PRESENT
	CALL	GNXTF		;GET A NEW COMMAND LINE
	BR	180$
110$:
	BIT	#SBMSK!CMMSK,OUTFLG
				;CHECK FOR GLOBAL SWITCHES
	BNE	120$		;JUMP IF EITHER "/SB" OR "/CM" SET
	BIT	#SBMSK,INFLG	;CHECK FOR LOCAL "SUBROUTINES CALLED"
	BEQ	120$		;JUMP IF "SUBROUTINES CALLED ONLY" OFF
	BIT	#CMMSK,INFLG	;CHECK FOR LOCAL "COMMENTARY ONLY"
	BEQ	170$		;JUMP IF "/SB/-CM" IN LOCAL SWITCHES
120$:
	BITB	#CS.WLD,C.STAT(R0)
	BEQ	180$		;JUMP IF WILDCARD NOT PRESENT

;
; ERROR MESSAGES
;

130$:
	ERRMSG	IIF		;"INVALID INPUT FILE"
	JMP	GMCR
140$:
	ERRMSG	NIF		;"NO INPUT FILE SPECIFIED"
	JMP	GMCR
150$:
	ERRMSG	IOF		;"INVALID OUTPUT FILE"
	JMP	GMCR
160$:
	ERRMSG	SYN		;"SYNTAX ERROR"
	JMP	GMCR
170$:
	ERRMSG	SWT		;"INVALID SWITCH COMBINATION"
	JMP	GMCR
180$:
	MOV	(SP)+,R3	;RESTORE REGISTERS
	MOV	(SP)+,R2
	MOV	(SP)+,R1
	MOV	(SP)+,R0
	RETURN
	.PAGE
	.SBTTL	GNXTF 	GET NEXT INPUT FILENAME

;+
;*-GNXTF  - GET NEXT INPUT FILENAME
;
; THIS ROUTINE GETS THE NAME OF THE NEXT FILE TO HAVE ITS DOCUMENTATION
; EXTRACTED.  IF THE "MORE FILES FOLLOWING" BIT WAS SET FOR THE PREVIOUS
; INPUT FILE, THE NEXT INPUT FILENAME IS PARSED FROM THE CURRENT COMMAND
; LINE.  IF THE "MORE FILES FOLLOWING" BIT WAS NOT SET, AND THE "CONTIN-
; UATION" SWITCH WAS PRESENT ON THE CURRENT COMMAND LINE, THE NEXT COMMAND
; LINE WILL BE READ, AND THE FIRST INPUT FILENAME PARSED FROM IT.
;
;
; INPUTS:
;
;	NONE
;
;
; OUTPUTS:
;
;	CSIBLK - NEXT INPUT FILENAME
;
;
; SUBROUTINES CALLED:
;
;	NONE
;-

GNXTF::
	MOV	R0,-(SP)	;SAVE REGISTER 0
	MOV	#CSIBLK,R0	;POINT TO CSI BLOCK
	BITB	#CS.MOR,C.STAT(R0)
	BEQ	20$		;JUMP IF NO MORE FILES ON THIS LINE
	CMPB	#.TRUE.,FSTCMD
	BNE	40$		;JUMP IF NOT FIRST COMMAND LINE

;
; GET NEXT INPUT FILENAME FROM THIS COMMAND LINE, AND CHECK IT FOR CORRECT
; FORMAT.
;

	CSI$2	,INPUT,#INSWT	;PARSE THE NEXT FILENAME
	BCS	60$		;JUMP IF PARSING ERROR
	BIT	#SBMSK!CMMSK,OUTFLG
				;CHECK FOR GLOBAL SWITCHES
	BNE	10$		;JUMP IF EITHER "/SB" OR "/CM" SET
	BIT	#SBMSK,INFLG	;CHECK FOR LOCAL "SUBROUTINES CALLED"
	BEQ	10$		;JUMP IF "SUBROUTINES CALLED ONLY" OFF
	BIT	#CMMSK,INFLG	;CHECK FOR LOCAL "COMMENTARY ONLY"
	BEQ	90$		;JUMP IF "/SB/-CM" IN LOCAL SWITCHES
10$:
	BITB	#CS.NMF,C.STAT(R0)
	BEQ	70$		;JUMP IF NO FILENAME
	BITB	#CS.WLD,C.STAT(R0)
	BNE	60$		;JUMP IF WILDCARD PRESENT
	CLC			;RETURNING WITH FILENAME
	BR	120$

;
; GET ANOTHER COMMAND LINE.
;

20$:
	GCML$	#CMDLCB		;GET ANOTHER COMMAND LINE
	BCC	30$		;JUMP IF NO ERRORS
	CMPB	G.ERR(R0),#GE.EOF
	BEQ	100$		;JUMP IF END-OF-FILE
	ERRMSG	GCL		;ELSE "COMMAND LINE ERROR"
	EXIT$S			;FINISHED

;
; CHECK IT FOR CORRECT SYNTAX.
;

30$:
	MOVB	#.FALS.,FSTCMD	;NO LONGER FIRST COMMAND LINE
	CMPB	#CR.SLA,@G.CMLD+2(R0)
				;"/" AS 1ST CHAR = E-O-F
	BEQ	110$		;JUMP IF E-O-F
	CSI$1	#CSIBLK,CMDLCB+G.CMLD+2,CMDLCB+G.CMLD
				;CHECK THE SYNTAX
	BCS	80$		;JUMP IF SYNTAX ERROR
	BITB	#CS.EQU,C.STAT(R0)
	BNE	80$		;JUMP IF EQUAL SIGN FOUND

;
; GET THE FIRST FILENAME FROM THIS COMMAND LINE, AND CHECK IT FOR CORRECT
; FORMAT.
;

40$:
	CSI$2	,OUTPUT,#INSWT	;"OUTPUT" BECAUSE NO EQUAL SIGN
	BCS	60$		;JUMP IF PARSING ERROR
	BIT	#SBMSK!CMMSK,OUTFLG
				;CHECK FOR GLOBAL SWITCHES
	BNE	50$		;JUMP IF EITHER "/SB" OR "/CM" SET
	BIT	#SBMSK,INFLG	;CHECK FOR LOCAL "SUBROUTINES CALLED"
	BEQ	50$		;JUMP IF "SUBROUTINES CALLED ONLY" OFF
	BIT	#CMMSK,INFLG	;CHECK FOR LOCAL "COMMENTARY ONLY"
	BEQ	90$		;JUMP IF "/SB/-CM" IN LOCAL SWITCHES
50$:
	BITB	#CS.NMF,C.STAT(R0)
	BEQ	70$		;JUMP IF NO FILENAME
	BITB	#CS.WLD,C.STAT(R0)
	BNE	60$		;JUMP IF WILDCARD PRESENT
	CLC			;RETURNING WITH FILENAME
	BR	120$

;
; ERROR MESSAGES
;

60$:
	ERRMSG	IIF		;"INVALID INPUT FILE"
	JMP	GNXTF
70$:
	ERRMSG	NIF		;"NO INPUT FILE SPECIFIED"
	JMP	GNXTF
80$:
	ERRMSG	SYN		;"SYNTAX ERROR"
	JMP	GNXTF
90$:
	ERRMSG	SWT		;"INVALID SWITCH COMBINATION"
	JMP	GNXTF

;
; EXIT
;

100$:
	MOVB	#.TRUE.,ENDRUN	;SET END RUN FLAG
110$:
	RCML$	#CMDLCB		;CLOSE THE INDIRECT COMMAND FILE
	SEC			;RETURNING WITH END-OF-FILE
120$:
	MOV	(SP)+,R0	;RESTORE REGISTER 0
	RETURN
	.PAGE
	.SBTTL	INIT  	INITIALIZE ALL FILES, AND OPEN WORK FILES

;+
;*-INIT   - INITIALIZE ALL FILES, AND OPEN WORK FILES
;
; THIS ROUTINE INITIALIZES THE FILE DESCRIPTOR BLOCKS FOR ALL OF THE FILES
; USED BY "...DOC".  THESE CONSIST OF:
;
;	INPUT FILE(S) - ONE FDB USED FOR ALL INPUT FILES
;	WORK FILE 1   - USED TO STORE TABLE OF CONTENTS, IF "/TC" SWITCH SET
;	WORK FILE 2   - USED TO STORE ACTUAL DOCUMENTATION
;	WORK FILE 3   - USED TO STORE INFORMATION FOR "XRF...", IF "/IN" OR
;		        "/CR" SWITCHES SET
;
; THE APPROPRIATE WORK FILES ARE ALSO OPENED BY THIS ROUTINE.  ALSO, THIS
; ROUTINE BUILDS THE DATA BLOCK TO BE SENT TO "XRF..." TO DO THE INDEX AND
; CROSS REFERENCE (IF REQUESTED).
;
;
; INPUTS:
;
;	NONE
;
;
; OUTPUTS:
;
;	ALL APPROPRIATE FDB'S INITIALIZED
;	WORK FILES OPENED ON DISK
;
;
; SUBROUTINES CALLED:
;
;$	$DAT   - CONVERT BINARY DATE TO ASCII
;$	$TIM   - CONVERT BINARY TIME TO ASCII
;$	HEADER - WRITE PAGE HEADER
;-

	.ENABL	LSB
INIT::
	MOV	R0,-(SP)	;SAVE REGISTERS
	MOV	R1,-(SP)
	MOV	R2,-(SP)
	MOV	R3,-(SP)

;
; GET THE DATE AND TIME, AND PUT THEM INTO THE HEADER RECORD.
;

	GTIM$C	TIME		;PUT TIME INFO INTO TIME BLOCK
	MOV	#TIME,R1	;STORE DATE IN HEADER RECORD
	MOV	#HEAD+48.,R0
	CALL	$DAT		;CONVERT TO ASCII
	MOV	#HEAD+65.,R0	;STORE TIME IN HEADER RECORD
	MOV	#3,R2		;FORM IS HH:MM:SS
	CALL	$TIM		;CONVERT TO ASCII

;
; SET UP THE INPUT FILE DESCRIPTOR BLOCK:  VARIABLE LENGTH RECORDS, PRECEEDED
; BY <LF> AND TERMINATED BY <CR>.
;

	FDAT$R	#INFDB,#R.VAR,#FD.CR

;
; SET UP THE TABLE OF CONTENTS FILE DESCRIPTOR BLOCK:  FIXED LENGTH RECORDS OF
; 80 BYTES, PRECEEDED BY <LF> AND TERMINATED BY <CR>.  SET THE L.U.N. AND
; FILENAME, AND OPEN THE FILE FOR WRITE ACCESS.
;

	BIT	#TCMSK,OUTFLG
	BEQ	20$		;JUMP IF TABLE OF CONTENTS NOT REQUESTED
	FDAT$R	#TOCFDB,#R.VAR,#FD.CR
	FDOP$R	#TOCFDB,#TOCLUN,,#TOCNB
	OPEN$W	#TOCFDB,,,,#RECBUF,#RECLN,IOERX
	MOV	#TABCON,R1	;R1 = TABLE OF CONTENTS TITLE
	CALL	HEADER		;WRITE PAGE HEADER
	BCC	10$		;JUMP IF NO ERRORS
	EXIT$S			;EXIT TASK
10$:
	MOVB	#.TRUE.,FIRST	;SET FIRST FILE FLAG TRUE
	CLR	TOCLCT		;T-O-C LINE COUNT = 0

;
; SET UP THE DOCUMENTATION FILE DESCRIPTOR BLOCK (SAME FORMAT AS T-O-C).
;

20$:
	FDAT$R	#DOCFDB,#R.VAR,#FD.CR
	FDOP$R	#DOCFDB,#DOCLUN,,#DOCNB
	OPEN$W	#DOCFDB,,,,#RECBUF,#RECLN,IOERX

;
; SET UP THE CREF FILE DESCRIPTOR BLOCK:  FIXED LENGTH RECORDS OF 18 BYTES,
; PRECEEDED BY <LF> AND TERMINATED BY <CR>.  SET L.U.N. AND FILENAME, AND
; OPEN THE FILE FOR WRITE ACCESS.
;

	BIT	#INMSK!CRMSK,OUTFLG
	BNE	30$		;JUMP IF CREF FILE NECESSARY
	JMP	80$		;GOTTA DO THIS 'CAUSE IT'S TOO FAR FOR BEQ
30$:
	FDAT$R	#CRFFDB,#R.FIX,#FD.CR,#CRFHLN
	FDOP$R	#CRFFDB,#CRFLUN,,#CRFNB
	OPEN$W	#CRFFDB,,,,#CRFHED,#CRFHLN,IOERX

;
; PUT THE TIME INTO THE CREF FILE HEADER BLOCK.
;

	MOV	#5,R1		;SET UP FOR TRANSFER
	MOV	#TIME,R2
	MOV	#CRFTIM,R3
40$:
	MOV	(R2)+,(R3)+	;TRANSFER TIME TO HEADER RECORD
	SOB	R1,40$
	PUT$	#CRFFDB,#CRFHED,#CRFHLN,IOERX
				;WRITE THE HEADER RECORD

;
; CREATE DATA BLOCK FOR "XRF..." TASK.
;

	MOV	#5,R1		;SET UP FOR TRANSFER
	MOV	#OUTFDB+F.FNB+N.FNAM,R2
	MOV	#CRFBLK+XS.NAM,R3
50$:
	MOV	(R2)+,(R3)+	;TRANSFER FILE NAME, TYPE, & VERSION
	SOB	R1,50$
	MOV	#5,R1		;SET UP FOR TRANSFER
	MOV	#OUTFDB+F.FNB+N.DID,R2
60$:
	MOV	(R2)+,(R3)+	;TRANSFER DIRECTORY, DEVICE, & UNIT
	SOB	R1,60$
	MOV	CRFFDB+F.FNB+N.FVER,(R3)+
				;TRANSFER CREF FILE VERSION
	CLR	(R3)+		;CREF DEVICE IS UNUSED
	MOV	CRFFDB+F.FNB+N.UNIT,(R3)+
				;TRANSFER CREF UNIT
	CLRB	CRFBLK+XS.FL2
				;2ND FLAG BYTE ALWAYS = 0
	BIT	#SPMSK,OUTFLG
	BNE	70$		;JUMP IF "SPOOL" SWITCH ON
	CLRB	CRFBLK+XS.FL1
				;1ST FLAG BYTE = 0 FOR "NO SPOOL"
	BR	80$
70$:
	MOVB	#1,CRFBLK+XS.FL1
				;1ST FLAG BYTE = 1 FOR "SPOOL"
80$:
	CLR	SECTCT		;INIT THE SECTION NUMBER
	MOVB	#.FALS.,SECFLG	;SET SECTION FLAG FALSE
	MOVB	#.FALS.,PRINT	;TURN OFF THE EXTRACTOR
	MOV	(SP)+,R3	;RESTORE REGISTERS
	MOV	(SP)+,R2
	MOV	(SP)+,R1
	MOV	(SP)+,R0
	RETURN
	.DSABL	LSB
	.PAGE
	.SBTTL	OPENIN	OPEN INPUT FILE

;+
;*-OPENIN - OPEN INPUT FILE
;
; THIS ROUTINE OPENS THE INPUT FILE POINTED AT BY THE CSI BLOCK.
;
;
; INPUTS:
;
;	CSIBLK - POINTERS TO INPUT FILE NAME
;
;
; OUTPUTS:
;
;	COMENT - COMMENT DELIMITER (";" FOR Z80 OR PDP, "C" FOR FORTRAN)
;
;
; EFFECTS:
;
;	INPUT FILE IS OPENED
;
;
; SUBROUTINES CALLED:
;
;$	HEADER - WRITE PAGE HEADER
;$	PUTPAG - PUT PAGE NUMBER INTO RECORD
;$	SETTLE - SET FILENAME INTO TITLE RECORD
;$	WRITBL - WRITE BLANK LINE
;$	WRITFF - WRITE FORM FEED
;-

OPENIN::
	MOV	R0,-(SP)	;SAVE REGISTERS
	MOV	R1,-(SP)

;
; SET UP FOR FORTRAN SOURCE FILES (USE ".FTN" FOR DEFAULT FILE TYPE, AND
; "C" FOR COMMENT DELIMITER).
;

	BIT	#Z8MSK,INFLG
	BNE	10$		;JUMP IF ASSEMBLY LANGUAGE SOURCE FILES
	FDOP$R	#INFDB,#INLUN,#CSIBLK+C.DSDS,#FTNNB
	MOVB	#'C,COMENT	;SET COMMENT DELIMITER FOR FORTRAN
	BR	30$

;
; SET UP FOR Z80 ASSEMBLER SOURCE FILES (USE ".ASM" FOR DEFAULT FILE TYPE,
; AND ";" FOR COMMENT DELIMITER).
;

10$:
	MOVB	#';,COMENT	;SET COMMENT DELIMITER FOR Z80/PDP
	BIT	#PDMSK,INFLG
	BNE	20$		;JUMP IF PDP SOURCE CODE
	FDOP$R	#INFDB,#INLUN,#CSIBLK+C.DSDS,#Z80NB
	BR	30$

;
; SET UP FOR PDP (MACRO-11) SOURCE FILES (USE ".MAC" FOR DEFAULT FILE TYPE,
; AND ";" FOR COMMENT DELIMITER).
;

20$:
	FDOP$R	#INFDB,#INLUN,#CSIBLK+C.DSDS,#PDPNB

;
; OPEN THE FILE FOR READ ONLY ACCESS.
;

30$:
	OPEN$R	#INFDB,,,,#RECBUF,#RECLN,IOERR
	BCS	80$		;JUMP IF ERROR

;
; SET UP THE TITLE RECORD.
;

	CALL	SETTLE		;SET FILENAME INTO TITLE
	CLR	DOCLCT		;DOC. LINE COUNT = 0
	MOV	#1,PAGECT	;DOC. PAGE COUNT = 1
	INC	SECTCT		;BUMP SECTION COUNTER
	MOVB	#.TRUE.,SECFLG	;SET SECTION FLAG TRUE
	MOV	#TITLE,R1	;R1 = TITLE RECORD
	CALL	PUTPAG		;INSERT SECTION AND PAGE NUMBERS

;
; PUT TITLE LINE INTO TABLE OF CONTENTS, FIRST CHECKING FOR BOTTOM OF
; PAGE.
;

	BIT	#TCMSK,OUTFLG
	BEQ	70$		;JUMP IF NO TABLE OF CONTENTS
	MOV	#TOCFDB,R0	;GET T-O-C FILE DESC. BLOCK
	CMP	TOCLCT,#MAXLIN-10.
	BLE	40$		;JUMP IF NOT BOTTOM OF PAGE
	CALL	WRITFF		;WRITE FORM FEED RECORD
	BCS	90$		;EXIT IF ERROR
	MOV	#TABCON,R1	;R1 = TABLE OF CONTENTS TITLE
	CALL	HEADER		;WRITE PAGE HEADER
	BCS	90$		;EXIT IF ERROR
	CLR	TOCLCT		;T-O-C LINE COUNT = 0
	BR	50$
40$:
	CMPB	#.TRUE.,FIRST
	BEQ	50$		;JUMP IF FIRST FILE
	CALL	WRITBL		;A BLANK LINE TO SEPARATE FILES
	BCS	90$		;EXIT IF ERROR
	INC	TOCLCT		;BUMP T-O-C LINE COUNT
50$:
	MOVB	#.FALS.,FIRST	;NO LONGER FIRST FILE
	BIT	#LIMSK,OUTFLG
	BEQ	60$		;JUMP IF "/LI" SWITCH OFF
	PUT$	,#BLNKLN,#1.,IOERX
				;BLANK LINE, TITLE, BLANK LINE
	PUT$	,#TITLE,#RECLN,IOERX
	PUT$	,#BLNKLN,#1.,IOERX
60$:
	ADD	#3,TOCLCT	;BUMP T-O-C LINE COUNT
70$:
	CLC			;GOOD RETURN
80$:
	MOV	(SP)+,R1	;RESTORE REGISTERS
	MOV	(SP)+,R0
	RETURN
90$:
	EXIT$S			;TOOK A HIT!
	.PAGE
	.SBTTL	READ  	READ A RECORD

;+
;*-READ   - READ A RECORD
;
; THIS ROUTINE READS A RECORD FROM THE CURRENT INPUT FILE.  THE INPUT/OUTPUT
; RECORD BUFFER IS FIRST CLEARED.
;
;
; INPUTS:
;
;	R0     - ADDRESS OF FILE DESCRIPTOR BLOCK
;
;
; OUTPUTS:
;
;	R0 NOT CHANGED
;	RECBUF - RECORD FROM INPUT FILE
;
;
; SUBROUTINES CALLED:
;
;	NONE
;-
	
READ::
	MOV	R1,-(SP)	;SAVE REGISTERS
	MOV	R2,-(SP)
	MOV	#RECBUF,R2	;R2 = ADDR OF INPUT BUFFER
	MOV	#RECLN,R1	;R1 = LENGTH OF BUFFER
10$:
	MOVB	#CR.SPA,(R2)+	;SPACE IT OUT
	SOB	R1,10$
	GET$	,#RECBUF,#RECLN,IOERR
				;READ A RECORD
	MOV	F.NRBD(R0),RLNGTH
				;SAVE RECORD LENGTH
	BCC	30$		;JUMP IF NO ERRORS
	CMPB	#IE.EOF,F.ERR(R0)
	BEQ	20$		;JUMP IF END-OF-FILE
	EXIT$S			;EXIT ON HARD ERROR
20$:
	SEC			;SET CARRY FOR END-OF-FILE
30$:
	MOV	(SP)+,R2	;RESTORE REGISTERS
	MOV	(SP)+,R1
	RETURN
	.PAGE
	.SBTTL	TERM  	TERMINATE DOCUMENTATION EXTRACTION

;+
;* -TERM  -  TERMINATE DOCUMENTATION EXTRACTION
;
; THIS ROUTINE CLOSES THE WORK FILES, MERGES THE TABLE OF CONTENTS FILE (IF
; PRESENT) WITH THE DOCUMENTATION FILE TO FORM THE OUTPUT FILE, AND SENDS
; "XRF..." THE CROSS REFERENCE FILE (IF PRESENT).  IF "XRF..." IS CALLED TO
; DO THE INDEX AND/OR CROSS REFERENCE, IT WILL TAKE CARE OF SPOOLING OR NOT
; SPOOLING THE OUTPUT FILE.  IF IT IS NOT CALLED, THIS ROUTINE TAKES THE
; APPROPRIATE ACTION.
;
;
; INPUTS:
;
;	WORK FILES
;
;
; OUTPUTS:
;
;	OUTPUT FILE (MAY BE SPOOLED)
;
;
; SUBROUTINES CALLED:
;
;$	READ   - READ A RECORD
;$	WRITFF - WRITE FORM FEED
;-
	
	.ENABL	LSB
TERM::
	MOV	R0,-(SP)	;SAVE REGISTER 0

;
; IF THE TABLE OF CONTENTS WAS REQUESTED, COPY THE TABLE OF CONTENTS WORK
; FILE TO THE OUTPUT FILE.
;

	BIT	#TCMSK,OUTFLG
	BEQ	30$		;JUMP IF NO TABLE OF CONTENTS
	CLOSE$	#TOCFDB,IOERX	;CLOSE THE T-O-C WORK FILE
	OPEN$R	#TOCFDB,,,,#RECBUF,#RECLN,IOERX
				;AND RE-OPEN IT FOR READING
10$:
	MOV	#TOCFDB,R0	;R0 = TABLE OF CONTENTS FILE DESC. BLOCK
	CALL	READ		;READ A RECORD FROM T-O-C
	BCS	20$		;JUMP IF E-O-F
	PUT$	#OUTFDB,#RECBUF,RLNGTH,IOERX
				;WRITE THE RECORD TO THE OUTPUT
	BR	10$		;AND LOOP UNTIL DONE
20$:
	DELET$	#TOCFDB,IOERX	;CLOSE & DELETE THE T-O-C FILE

;
; SEPARATE THE TABLE OF CONTENTS FROM THE ACTUAL DOCUMENTATION BY A
; FORM FEED.
;

	MOV	#OUTFDB,R0	;GET OUTPUT FILE DESC. BLOCK
	CALL	WRITFF		;WRITE FORM FEED RECORD
	BCC	30$		;JUMP IF NO ERRORS
	EXIT$S			;EXIT TASK

;
; COPY THE DOCUMENTATION TO THE OUTPUT FILE.
;

30$:
	CLOSE$	#DOCFDB,IOERX	;CLOSE THE DOCUMENTATION WORK FILE
	OPEN$R	#DOCFDB,,,,#RECBUF,#RECLN,IOERX
				;OPEN DOCUMENTATION FILE FOR READING
40$:
	MOV	#DOCFDB,R0	;R0 = DOCUMENTATION FILE DESC. BLOCK
	CALL	READ		;READ A RECORD FROM DOC. FILE
	BCS	50$		;JUMP IF E-O-F
	PUT$	#OUTFDB,#RECBUF,RLNGTH,IOERX
				;WRITE THE RECORD TO THE OUTPUT
	BR	40$		;AND LOOP UNTIL DONE
50$:
	DELET$	#DOCFDB,IOERX	;CLOSE & DELETE THE DOC. WORK FILE

;
; IF THE INDEX AND/OR THE CROSS REFERENCE WERE REQUESTED, CLOSE THE CREF
; FILE AND SEND THE DATA BLOCK TO "XRF..." TO LET HIM DO THE INDEX/CROSS
; REFERENCE.
;

	BIT	#INMSK!CRMSK,OUTFLG
	BEQ	60$		;JUMP IF NO CREF FILE
	CLOSE$	#OUTFDB,IOERX	;CLOSE THE OUTPUT FILE
	CLOSE$	#CRFFDB,IOERX	;CLOSE THE CREF FILE
	SDAT$C	XRF...,CRFBLK	;SEND THE DATA TO XRF...
	RQST$C	XRF...		;AND REQUEST HIM TO RUN
	BR	80$

;
; IF "XRF..." IS NOT USED, THIS ROUTINE MUST TAKE CARE OF SPOOLING OR NOT
; SPOOLING THE OUTPUT FILE.
;

60$:
	BIT	#SPMSK,OUTFLG
	BEQ	70$		;JUMP IF "NO SPOOL" REQUESTED
	PRINT$	#OUTFDB,IOERX	;SPOOL THE OUTPUT FILE
	BR	80$
70$:
	CLOSE$	#OUTFDB,IOERX	;ELSE CLOSE THE OUTPUT FILE
80$:
	MOV	(SP)+,R0	;RESTORE REGISTER 0
	RETURN
	.DSABL	LSB
	.PAGE
	.SBTTL	WRITBL	WRITE BLANK LINE

;+
;*-WRITBL - WRITE BLANK LINE
;
; THIS ROUTINE WRITES A BLANK LINE RECORD, IF THE "/LI" SWITCH IS ON.
; IF THE "/LI" SWITCH IS OFF, NO WRITING OCCURS.
;
;
; INPUTS:
;
;	R0     - FILE DESCRIPTOR BLOCK
;
;
; OUTPUTS:
;
;	R0 NOT CHANGED
;
;
; EFFECTS:
;
;	A BLANK LINE MAY BE WRITTEN
;
;
; SUBROUTINES CALLED:
;
;	NONE
;-
	
WRITBL::
	BIT	#LIMSK,OUTFLG
	BEQ	10$		;JUMP IF "/LI" SWITCH OFF
	PUT$	,#BLNKLN,#1.,IOERR
				;WRITE A BLANK LINE
10$:
	RETURN
	.PAGE
	.SBTTL	WRITFF	WRITE FORM FEED

;+
;*-WRITFF -  WRITE FORM FEED
;
; THIS ROUTINE WRITES A FORM FEED RECORD, IF THE "/LI" SWITCH IS ON.
; IF THE "/LI" SWITCH IS OFF, NO WRITING OCCURS.
;
;
; INPUTS:
;
;	R0     - FILE DESCRIPTOR BLOCK
;
;
; OUTPUTS:
;
;	R0 NOT CHANGED
;
;
; EFFECTS:
;
;	A FORM FEED MAY BE WRITTEN
;-
	
WRITFF::
	BIT	#LIMSK,OUTFLG
	BEQ	10$		;JUMP IF "/LI" SWITCH OFF
	PUT$	,#FFREC,#1.,IOERR
				;WRITE A FORM FEED
10$:
	RETURN

	.END	DOCEXT