.PSECT	KWC
	.TITLE	KWiC - KWIC INDEX
	.IDENT	/790621/
;
;    THIS CODE HAS BEEN DEVELOPED BY THE COMPUTING
;    GROUP OF THE ATMOSPHERIC SCIENCES DIVISION,
;    ALBERTA RESEARCH. THIS WORK FUNDED BY THE
;    ALBERTA WEATHER MODIFICATION BOARD.
;
;    THERE IS EXPLICITLY NO COPYRIGHT ON THIS SOFTWARE,
;    AND ITS DISTRIBUTION IS ENCOURAGED. NO RESPONSIBILITY
;    NOR GUARANTEE IS MADE OR ASSUMED BY THE AUTHOR, OR
;    BY ALBERTA RESEARCH.
;
;    SUGGESTIONS OR CHANGES ARE INVITED, AND WILL BE
;    DISTRIBUTED TO OTHER USERS OF THIS SOFTWARE THROUGH
;    THE DECUS IAS/RSX SPECIAL INTEREST GROUP.
;
;
; VERSION:	790621
; WRITTEN BY:	DALE SEMCHISHEN
; DATE WRITTEN:	21-JUN-79
; 
;	
;
; MODIFICATIONS:
;
; CODE		NAME		DATE
;

;
	.SBTTL	FCS, CSI, AND GCML
;
;
	.MCALL	TINIT,GCML,EXIT$S,FINIT$,OPEN$R,OPEN$W,CSI$,RCML$,CSI$SV
	.MCALL	FDBDF$,FDOP$A,ALUN$S,FDRC$A,FDAT$A,NMBLK$,CSI2,TTYOUT,PDEC
	.MCALL	FSRSZ$,PSTR,GCMLB$,CSI1G,GET$,CLOSE$,PUT$,FCSMC$,CSI$SW,PCRLF
;
;
	FCSMC$
	FSRSZ$	3
;
;
TABLE:	CSI$SW	LF,SW.LF,SWITCH,SET,NEG	; LF=SHELF NUMBER ON LEFT SIDE
	CSI$SW	WD,SW.WD,SWITCH,,,WDVAL	; WD=PAGE WIDTH
	CSI$SW	IC,SW.IC,SWITCH,,,ICVAL	; IC=INDEX COLUMN POSTION
	CSI$SW	IN,SW.NO,SWITCH,CLEAR,NEG  ; NO=NO INSIGNIFICANT WORD FILE
	SW.LF=1
	SW.WD=2
	SW.IC=4
	SW.NO=10
;
WDVAL:	CSI$SV	DECIMAL,WDTH,2
ICVAL:	CSI$SV	DECIMAL,INDCL,2
;
INTBL:	CSI$SW	IN,SW.IN,SWITCH,SET,NEG	; IN=INSIGNIFICANT WORD FILE
	CSI$SW	SG,SW.SG,SWITCH,SET,NEG	; SG=SIGNIFICANT WORD FILE
	SW.IN=20
	SW.SG=40
	.EVEN
;
INTPOS:	.WORD	0
INMAX:	.WORD	0			; MAXIMUM INDEX COULMN VALUE
STATS:	.WORD	0			; STATUS OF OUTPUT LINE
INSEND:	.WORD	0			; END ADDRESS OF INSIGNIFICANT WORD FILE TEXT
LINE:	.WORD	0		; WHICH LINE WE ARE AT IN 'INPUTFILE' (FOR ERROR MESSAGE)
SWITCH:	.WORD	0			; WHERE SWITCHES ARE STORED
WDTH:	.WORD	0			; PAGE WIDTH
POINT:	.WORD	0			; POINTER FOR TEXT MANIPULATION
TBEG:	.WORD	0			; LOCATION POINTER OF TEXT IN OBUF
FLAG:	.WORD	0
RMARG:	.WORD	0			; RIGHT MARGIN
LMARG:	.WORD	0			; LEFT MARGIN
SHELF:	.WORD	0			; WHERE SHELF NUMBER IS TO BE PLACED ON PAGE
BEND:	.WORD	0			; ABSOLUTE END ADDRESS OF TEXT IN BUF
WST:	.WORD	0			; INPUT WORD POINTER
SPSAVE:	.WORD	0			; STACK POINTER SAVE
INDCL:	.WORD	0
INSWRD:	.BLKB	512.			; INSIGNIFICANT WORD FILE
BUF:	.BLKB	512.			; INPUT LINE BUFFER
OBUF:	.BLKB	512.			; OUTPUT LINE BUFFER
UICBUF:	.BLKB	12.
CSDS:	.BLKB	20
COMA=',					; INSIGNIFICANT WORD SEPERATOR
BKSL='\					; COMMENT INDICATOR
ARROW='^				; CONTINUATION CHARCTER
AT='@					; SHELF NUMBER TERMINATOR
BLANK=40				; SPACE CHARCTER
TAB=11					; TAB CHARCTER
;
TLUN=1					; TERMINAL LOGICAL UNIT #
GCLUN=2
TEVF=1
;
	.EVEN
;
;
FDBOUT:	FDBDF$				; OUTPUT FILE FDB
	FDOP$A	4,CSIBLK+C.DSDS,NOUT,FO.WRT
	FDRC$A
	FDAT$A	R.VAR,FD.CR,,-2,-1
	FDBF$A	32
NOUT:	NMBLK$	KWIC,TMP,,SY,0		; DEFAULT OUTPUT FILE 
;
	CSI$
	.EVEN
CSIBLK:	.BLKB	C.SIZE
	.EVEN
;
FDBIN:	FDBDF$				; INPUT FILE FDB
	FDOP$A	3,CSIBLK+C.DSDS,NIN,FO.RD
	FDRC$A	
	FDBF$A	30
NIN:	NMBLK$	,KWC,,SY,0		; DEFAULT INPUT FILE 
;
FDBISG:	FDBDF$				; INSIGNIFICANT FILE FDB
	FDOP$A	2,CSIBLK+C.DSDS,NMWORD,FO.RD
	FDRC$A
	FDBF$A	27
NMWORD:	NMBLK$	INSIG,TXT,,SY,0
;
INSDSC:	.WORD	IDEVL,IDEV			;STSTEM DATASET DESCRIPTOR BLOCK
	.WORD	IUICL,IUIC
	.WORD	INSIGL,INSIG
;
	.EVEN
IDEV:	.ASCII	/LB0:/
IDEVL=.-IDEV
IUIC:	.ASCII	/[1,2]/
IUICL=.-IUIC
INSIG:	.ASCII	/INSIG.TXT/
INSIGL=.-INSIG
;
STRNG:	.ASCIZ	/%X/				; $EDMSG STRING CONVERION INDICATOR
	.EVEN
	.PAGE
TERMIN:	EXIT$S				; TERMINATION OF PROGRAM
GCLBLK:	GCMLB$	,KWC,,GCLUN
ERRPFX::PSTR	^*<CR><LF>/KWC -- /*
	RETURN
DIE::	CLOSE$	#FDBIN
	CLOSE$	#FDBOUT
	CLOSE$	#FDBISG
	BR	RSTART
;
;
	.SBTTL	>>	MAIN PROGRAM
;
;
START:	MOV	SP,SPSAVE		; SAVE STACK POINTER
	FINIT$				; FCS INITIALIZATION
	TINIT	TLUN,TEVF		; TERMINAL INITIALIZATION FOR OUTPUT
	ALUN$S	#GCLUN,#"TI,#0		; ASSIGN LUN TO USER TERMINAL
	BR	GOTOIT
RSTART:	MOV	SPSAVE,SP		; RESTORE STACK POINTER
	RCML$	#GCLBLK
GOTOIT:	CLR	SWITCH				; ZERO SWITCH VALUES
	GCML	#GCLBLK,,,TERMIN,GCERR		; SNATCH THE LINE
	CSI1G	#CSIBLK,GCLBLK,CS1ERR		; BREAK IT UP BOYS
	CALL	OUTOPE				; OPEN OUTPUT FILE IF PRESENT
	BCS	RSTART				; IF CS NOTHING IS TO BE PROCESSED
	CALL	INTOPE				; OPEN, READ, AND CLOSE INSIGNIFICANT
						; WORD FILE AND OPEN INPUT FILE
	CALL	OPTIONS				; ARE THERE ANY SWITCHES
	BR	8$
1$:	CSI2	#CSIBLK,INPUT,#INTBL,CS2ERR
	CALL	WILD				; INITIALIZE FOR WILD CARDS IF ANY
	OPEN$R	#FDBIN,,,,,,IOERR
	CALL	TSTUIC				; IS  IT A DEFAULT UIC
	BR	8$
; MAIN LOOP
2$:	CALL	TWOREG				; FILL REGISTERS R0, R1 WITH DATA
	CALL	.FIND				; FIND NEXT INPUT FILE TO PROCESS
	BCS	49$				; IF CS ERROR CONDTION EXITS
	OPEN$R	#FDBIN,,,,,,IOERR		; OPEN INPUT FILE
8$:	CLR	LINE				; ZERO INPUT LINE POINTER
	CALL	PRCESS				; MOVE ALL LINES FROM INPUT TO OUTPUT FILES
	CLOSE$	#FDBIN				; CLOSE INPUT FILE
	MOV	#FDBIN+F.FNB,R1
	BIT	#NB.SNM,N.STAT(R1)		; IS THERE A WILDCARD LOCATED IN INPUT FILE
	BNE	2$				; IF NE WILDCARD PRESENT
	BR	50$				; SO GET NEXT INPUT FILE
49$:	CMPB	F.ERR(R0),#IE.NSF		; DID WE PROCESS ALL INPUT FILES
	BEQ	50$				; IF EQ ALL IS DONE
	CALL	IOERR				; SOME OTHER ERROR IS PRESENT
50$:	BITB	#CS.MOR,CSIBLK+C.STAT		; ARE THER MORE INPUT FILES
	BNE	1$				; IF NE MORE TO COME
	CLOSE$	#FDBOUT				; CLOSE OUTPUT FILE
	BR	RSTART
	.PAGE
;
	.SBTTL >	INITIALIZTION AND OPENING SUBROUTINES
;
OUTOPE:	TST	CSIBLK+C.CMLD			; IS THERE ANYTHING IN COMMAND LINE
	BNE	2$				; IF NE SOMTHING IS THERE
	SEC					; INDICATE PROGRAM IS NOT TO PROCEED
	RETURN
2$:	CALL	AMBIG				; IS THERE SOMTHING FUNNY, HA HA
	BITB	#CS.OUT,CSIBLK+C.TYPR		; IS THERE SOMTHING ON THE LEFT SIDE
						; OF THE = SIGN
	BNE	33$				; IF NE USE DEFAULT
	CSI2	#CSIBLK,OUTPUT,#TABLE,CS2ERR	; PARSE HIS OUTPUT FILE
	CALL	AMBIG				; ARE THERE ANY AMBIGIOUS SWITCHES
33$:	OPEN$W	#FDBOUT,,,,,,IOERR		; OPEN FILE
40$:	RETURN
;
INSGET:	MOV	#INSWRD,R1		; LOCATION OF INSIG. FILE BUFFER
	MOV	#FDBISG,R0		; INISGNIFICANT FDB
20$:	GET$	R0,R1,#512.		; GRAB ONE LINE OF INPUT FILE
	BCS	25$			; BRANCH IF WE DID NOT GET LINE OKAY
	ADD	F.NRBD(R0),R1		; MOVE POINTER TO END OF LINE
	MOVB	#COMA,(R1)+		; INSERT COMA TO SEPERATE WORDS
	BR	20$
25$:	CALL	ERRCHK			; CHECK ON POSSIBLE ERRORS
	MOV	R1,INSEND		; SAVE ABSOLUTE END ADDRESS OF INSIG. WORD FILE
	CLOSE$	R0			; CLOSE WORD FILE
	RETURN
;
;
AMBIG:	BIT	#SW.IN,SWITCH		; WAS THE INSIGNIFICANT WORD FILE SWITCH SET
	BEQ	30$			; IF EQ IT WAS NOT
	BIT	#SW.NO,SWITCH		; DID WE WANT TO SKIP INSIG. FILE
	BEQ	29$			; IF EQ THEN EVERY THING IS NORMAL
28$:	CALL	ERRPFX
	PSTR	^*/ AMBIGIOUS SWITCHES /<CR><LF>*
	JMP	DIE
29$:	BIT	#SW.SG,SWITCH		; WAS A SIGNIFICANT WORD FILE SPAECIFIES
	BNE	28$			; IF NE ERROR CONDTION EXITS
30$:	RETURN
;
CLRCSI:	MOV	#6,R1
	MOV	#CSIBLK+C.DSDS,R0		; BLANK THE DATA SET DESCRIPTOR
7$:	CLR	(R0)+				; AND TAKE DEFAULT FILE
	SOB	R1,7$
	RETURN
;
;
;
INTOPE:	CSI2	#CSIBLK,INPUT,#INTBL,CS2ERR
	CALL	AMBIG
	BIT	#SW.SG,SWITCH			; IS THIS A SIGNIFICANT WORD FILE
	BNE	10$				; IF NE IT IS SIGNIFICANT
	BIT	#SW.IN,SWITCH			; IS THIS AN INSIGNIFICANT WORD FILE
	BEQ	30$				; IF EQ USE DEFAULT WORD FILE
	BIT	#SW.NO,SWITCH			; SHOULD WE USE INSIGNIFICANT WORD FILE
	BNE	42$				; IF NE DO NOT READ IN WORD FILE
	BR	40$
10$:	CALL	TSTUIC				; IS THIS A DEFAULT UIC
	OPEN$R	#FDBISG,,,,,,IOERR
	CALL	SIGNAM				; WRITE OUT NAME OF FILE
	CALL	INSGET				; READ AND CLOSE WORD FILE
	BR	41$
30$:	CALL	SVCSI				; SAVE CSI DATASET DESCRIPTOR
	CALL	CLRCSI				; CLEAR OUT CSIBLK SO WE CAN GET A DEFAULT
32$:	OPEN$R	#FDBISG,,,,,,35$		; IF 35$ LOOK FOR SYSTEM FILE
	CALL	INSNAM				; WRITE OUT NAME OF FILE
34$:	CALL	INSGET				; READ AND CLOSE WORD FILE
	CALL	UNCSI				; RESTORE CSI DATASET DESCRIPTOR
	BR	42$
35$:	MOV	#6,R1
	MOV	#CSIBLK+C.DSDS,R0
	MOV	#INSDSC,R2
7$:	MOV	(R2)+,(R0)+			; MOVE IN SYSTEM DATA SET DESCIPTOR
	SOB	R1,7$
	OPEN$R	#FDBISG,,,,,,IOERR		; OPEN SYSTEM FILE
	MOV	#UICBUF,R1			; WHERE UIC SHALL LIVE
	MOV	#IUICL,R0			; SYSTEM UIC LENGTH
	MOV	R0,(R1)+			; MOVE IN LENGTH
	MOV	#IUIC,R2				; START OF UIC
1$:	MOVB	(R2)+,(R1)+			; TRANSFER UIC
	SOB	R0,1$
;
	RETURN					; CONTINUE JUST AFTER ERROR CONDITION
						; FOLLOWING 32$
;
40$:	CALL	TSTUIC				; IS THIS A DEFAULT UIC
	OPEN$R	#FDBISG,,,,,,IOERR
	CALL	INSGET				; READ AND CLOSE WORD FILE
	CALL	INSNAM				; WRITE OUT NAME OF FILE
41$:	CSI2	#CSIBLK,INPUT,#INTBL,CS2ERR
42$:	CALL	TSTUIC				; ARE WE USING A DEFAULT UIC
	CALL	WILD
	CALL	AMBIG				; IS THERE SOMTHING FUNNY
	OPEN$R	#FDBIN,,,,,,IOERR
	BIT	#SW.NO,SWITCH			; DID WE WANT TO USE INSIG. FILE
	BEQ	48$				; IF EQ THEN TRUE
	PSTR	^*<LF>/ NO INSIGNIFICANT WORD FILE USED /<CR><LF>*
48$:	RETURN
;
TSTUIC:	MOV	#UICBUF,R0
	MOV	CSIBLK+C.DIRD,(R0)+		; MOVE IN CSILENGTH
	BEQ	44$				; IF EQ USE DEFAULT UIC
	MOV	UICBUF,R1			; LENGTH
	MOV	CSIBLK+C.DIRD+2,R2		; ADDRESS
43$:	MOVB	(R2)+,(R0)+			; MOVE IT IN
	SOB	R1,43$
44$:	RETURN
;
SVCSI:	MOV	#6,R1
	MOV	#CSDS,R2
	MOV	#CSIBLK+C.DSDS,R0
7$:	MOV	(R0)+,(R2)+
	SOB	R1,7$
	RETURN
;
UNCSI:	MOV	#6,R1
	MOV	#CSDS,R2
	MOV	#CSIBLK+C.DSDS,R0
7$:	MOV	(R2)+,(R0)+
	SOB	R1,7$
	RETURN
;
WILD:	CALL	REG				; INITILIZE R0 TO R4
	CALL	.PARSE
	BIT	#NB.SNM,N.STAT(R1)		; DO WE HAVE A WILD CARD
	BEQ	5$				; IF EQ NO WILDCARD
	BIS	#NB.SVR,N.STAT(R1)		; SET VERSION NUMBER TO--> *
						; REQUIRED ELSE ONLY ONE INPUT FILE
						; WILL BR PROCESSED IF * IN FILENAME
5$:	CALL	.FIND
	RETURN
;
REG:	CALL	TWOREG			; INITIALIZE R0, R1
	MOV	F.DSPT(R0),R2		; DATASET DESCRIPTOR
	MOV	F.DFNB(R0),R3		; DEFAULT FILENAME BLOCK
	RETURN
;
TWOREG:	MOV	#FDBIN,R0		; INPUT FILE DESCRIPTOR BLOCK
	MOV	#FDBIN+F.FNB,R1		; FILE NAME BLOCK
	RETURN
;
INSNAM:	CALL	INTNAM
	PSTR	^*/   AS AN INSIGNIFICANT WORD FILE /<CR><LF>*
	RETURN
;
SIGNAM:	CALL	INTNAM
	PSTR	^*/   AS A SIGNIFICANT WORD FILE /<CR><LF>*
	RETURN
;
INTNAM:	PSTR	^*<CR><LF>/ USING   /*
	MOV	#OBUF,R0				; WHERE FILESPEC WILL BE STORED
	MOVB	FDBISG+F.FNB+N.DVNM,(R0)+	; MOVE IN DEVICE NAME
	MOVB	FDBISG+F.FNB+N.DVNM+1,(R0)+
	MOV	FDBISG+F.FNB+N.UNIT,R1		; AND UNIT NUMBER
	CLR	R2				; SUPRESS LEADING ZEROS
	CALL	$CBOMG				; CONVERT BINARY UNIT NUMBER TO ASCII
	MOVB	#':,(R0)+
	CALL	FUIC				; FILL IN THE UIC
	MOV	#FDBISG+F.FNB+N.FNAM,R2		; FILE NAME BLOCK
	CALL	FLNAM				; MOVE REST IN AND WRITE
	RETURN
;
;
ERRCHK:	CMPB	F.ERR(R0),#IE.EOF	; HAVE WE ENCOUNTERED END OF FILE
	BEQ	7$			; 7$ IF YES
	TSTB	F.ERR+1(R0)		; ELSE DO WE HAVE I/O ERROR
	BEQ	5$			; BRANCH IF TRUE
	CALL	DIRERR
5$:	CALL	IOERR
7$:	RETURN
	.PAGE
	.SBTTL  >	SWITCH CHECKS AND INPUT FILE PROCESSING
OPTIONS:MOV	#OBUF,LMARG
	MOV	#OBUF,SHELF
	BIT	#SW.WD,SWITCH		; IS PAGE WIDTH SPECIFIDED
	BNE	3$			; IF NE USER WANTS TO SET WIDTH
	MOV	#132.,WDTH		; DEFAULT PAGE WIDTH
	BR	10$			; SEE IF ANY OTHER SWITCHES
3$:	CMP	#50.,WDTH		; IS HE TRYING TO CRAMP OUR STYLE
	BGT	25$			; IF GT WIDTH IS TOO SMALL
	CMP	#132.,WDTH		; IS HE ASKING FOR TOO MUCH
	BLT	25$			; IF LT WIDTH TOO LARGE
10$:	MOV	WDTH,INMAX
	SUB	#22.,INMAX		; DETERMINE MAX. INDEX COLUMN
	BIT	#SW.LF,SWITCH		; DO WE WANT SHELF NUMBER ON THE LEFT
	BNE	18$			; IF NE YES WE WANT IT ON THE LEFT
	ADD	WDTH,SHELF		; MOVE SHELF POSTION OVER
	SUB	#9.,SHELF		; START OF SHELF LOCATION
	MOV	SHELF,RMARG
	SUB	#3.,RMARG		; LEAVE A LITTLE ROOM
	BR	20$
18$:	MOV	#OBUF,RMARG		; SHELF NUMBER IS TO BE ON LEFT
	ADD	WDTH,RMARG		; MOVE RIGHT MARGIN AS FAR AS HE WANTS
	DEC	RMARG
	ADD	#12.,LMARG		; SHELF # ON LEFT OF PAGE
20$:	BIT	#SW.IC,SWITCH		; WAS INDEX COLUMN SPECIFIED
	BNE	22$			; IF NE USER HAS SPECIFIED A POSTION
	MOV	RMARG,INDCL
	SUB	LMARG,INDCL		; FIND MAX LENGTH OF TEXT LINE
	ASR	INDCL			; DIVIDE BY 2
	ADD	LMARG,INDCL		; FIND MIDPOINT IN TEXT OUTPUT
	BR	30$
22$:	CMP	INDCL,#10.		; IS VALUE FOR INDEX COLUMN TOO SMALL
	BLT	25$			; IF LT VALUE IS TOO SMALL
	CMP	INDCL,INMAX		; IS IT TOO LARGE
	BGE	25$			; IF GE THEN INDEX COLUMN TOO LARGE
	ADD	LMARG,INDCL
30$:	RETURN
25$:	CALL	ERRPFX
	PSTR	^*/ INVALID SWITCH VALUE(S) /<LF>*
	JMP	DIE
;
;
PRCESS:	MOV	#FDBIN,R0
	MOV	#BUF,R1			; INPUT TEXT BUFFER
20$:	GET$	R0,R1,#512.		; OBTAIN ONE LINE OF INPUT
	BCC	1$			; 1$ IF EVERYTHING SEEMS OKAY
	CALL	ERRCHK			; CHECK FOR ANY ERRORS PRESENT
	RETURN
;
1$:	INC	LINE
	ADD	F.NRBD(R0),R1		; INCREMENT BUF POINTER SO WE CAN TACK
					; THE NEXT LINE ONTO THE END OF THE
					; PREVIOUS LINE
	CMPB	-1(R1),#ARROW		; HAVE WE ENCOUNTERED A CONT. LINE
	BEQ	2$			; IF EQ WE HAVE A CONTINUE
	CALL	LINPRS			; PROCESS THIS LINE
	BR	PRCESS			; LOOK FOR MORE INPUT LINES
2$:	MOVB	#BLANK,-1(R1)		; MASK ^ WITH A BLANK
	BR	20$			; MOVE NEXT LINE IN RIGHT AFTER PREVIOUS ONE
	.PAGE
	.SBTTL	>  INPUT LINE PROCESSING ( LINPRS, PARSE, LOOP )
;   INTIALIZATION FOR PARSE CALL
;
LINPRS:	MOVB	#BLANK,(R1)		; ADD BLANK TO END OF TEXT
	SUB	#BUF,R1			; DETERMINE LENGTH OF INPUT LINE
	MOV	#BUF,R0			; SET POINTERS FOR PARSE CALL
	MOV	R1,-(SP)		; SAVE LENGTH
	MOV	#10.,R2
1$:	CMPB	(R0)+,#AT		; SEARCH FOR A LEGAL LENGTH SHELF NUMBER
	BEQ	4$			; IF EQ WE FOUND IT
	SOB	R2,1$
	SUB	#9.,R1
	CALL	ERRPFX			; SOMTHING IS WRONG
2$:	CMPB	(R0)+,#AT		; LOOK FOR SHELF NUMBER TERMINATOR
	BEQ	3$			; IF EQ WE FOUND IT
	SOB	R1,2$
	PSTR	^*/ SHELF NUMBER TERMINATOR MISSING /<CR><LF>*
	BR	20$
3$:	PSTR	^*/ SHELF NUMBER TOO LONG /<CR><LF>*
20$:	CALL	INNAM			; PRINT OUT INPUT FILE NAME
	PSTR	^*<CR><LF>/ LINE: /*
	PDEC	LINE
	PCRLF
	CLR	(SP)+
	BR	5$
4$:	MOV	(SP)+,R1		; RESTORE LENGTH OF INPUT LINE
	MOV	#BUF,R0			; WHERE OUR INPUT IS
	MOV	R0,R2			; INTILIALIZE OUTPUT POINTER
	CALL	PARSE			; ELIMINATE MULT. BLANKS AND TABS
	; R0 WILL RETURN FROM THIS CALL CONTAINING LOCATION OF 
	; LAST CHARCTER IN BUF
	;
	BCS	5$			; IF CS THEN LINE WAS ALL BLANKS OR TABS
	MOV	R0,BEND			; SAVE ABSOLUTE BUF END
	CALL	OUTPUT			; SINCE LINE CONTAINS SOMTHING MOVE IT TO
					; THE OUTPUT FILE HOWEVER MANY TIMES IT NEED BE
5$:	RETURN
;
INNAM:	PSTR	^*/ FILE: /*
	MOV	#OBUF,R0			; WHERE OUTPUT WILL LIVE
	MOVB	FDBIN+F.FNB+N.DVNM,(R0)+	; MOVE IN DEVICE NAME
	MOVB	FDBIN+F.FNB+N.DVNM+1,(R0)+
	MOV	FDBIN+F.FNB+N.UNIT,R1
	CLR	R2
	CALL	$CBOMG				; CONVERT BINARY TO ASCII
	MOVB	#':,(R0)+
	CALL	FUIC				; IF IN UIC INFO
	MOV	#FDBIN+F.FNB+N.FNAM,R2		; FILE NAME BLOCK
	CALL	FLNAM			; DISPLAY FILE WHERE ERROR OCCURED
	RETURN
;
;
FUIC:	TST	UICBUF
	BEQ	11$			; IF EQ USE DEFAULT UIC
	MOV	UICBUF,R1		; GET LENGTH
	MOV	#UICBUF+2,R2		; ADDRESS
	BR	12$
11$:	CLR	R1
	CALL	.GTUIC			; GET DEFAULT UIC
	BR	20$
12$:	MOVB	(R2)+,(R0)+
	SOB	R1,12$
20$:	RETURN
	.PAGE
PARSE:	CMPB	(R2),#BLANK		; THIS CODE DETERMINES IF THERE ARE BLANKS OR
					; TABS AT THE BEGINNING OF A LINE
					; AND SKIPS OVER THEM
	BEQ	2$			; IF EQ WE HAVE A BLANK, SO IGNORE IT
	CMPB	(R2),#TAB		; IS THERE A TAB
	BNE	10$			; IF NE THEN OUR FIRST TEXT CHARCTER WAS ENCOUNTERED
2$:	INC	R2			; BUMP POINTER UP ONE TO SKIP BLANK OR TAB
	SOB	R1,PARSE
	SEC				; IF WE ARE THIS FAR THEN THE INPUT
					; LINE IS ALL BLANKS OR TABS

	RETURN
10$:	CALL	LOOP			; GET RID OF ALL OTHER MULT. BLANKS AND TABS
	CLC				; CLC REQUIRED TO TELL LINPRS THAT THIS LINE
					; CONTAINED INFORMATION
	RETURN
;
FLNAM:	MOV	#STRNG,R1		; INDICATE A STRING CONVERSION
	CALL	$EDMSG			; CONVERT RAD50 FILENAME TO A STRING
	SUB	#OBUF,R0			; FIND LENGTH OF FILESPECS TO BE PUT OUT
	TTYOUT	#OBUF,R0			; DISPLAY FILESPECS
	RETURN
;
;
;  R1 CONTAINS LENGTH OF INPUT RECORD
;  R0  AND R2 ARE POINTERS TO IN AND OUT BUFFER ( SAME ONE )
LOOP:	CMPB	(R2),#BKSL		; HAVE WE FOUND A COMMENT CHARCTER
	BEQ	40$			; IF EQ REST OF INPUT LINE TO BE IGNORED, SO RETURN
	MOVB	(R2)+,(R0)+		; SHIFT CHARCTER IN OBUF
	DEC	R1			; R1 CONTAINS CHARCTERS LEFT IN BUF TO PROCESS
	BLE	40$			; IF LE THEN NO CHARCTERS LEFT
	CMPB	(R2),#TAB		; IS NEXT CHARCTER A TAB
	BNE	8$			; IF NE LOOK AT CHARCTER NEXT TO THIS ONE
	MOVB	#BLANK,(R2)		; MASK TABS WITH BLANKS
8$:	CMPB	-1(R0),(R2)		; DO WE HAVE TWO OF THE SAME CHARCTERS
	BNE	LOOP			; BRANCH IF FALSE ( THUS NO MULT. BLANKS )
10$:	CMPB	(R2),#TAB		; IS NEXT CHARCTER A TAB
	BEQ	15$			; IF EQ SKIP OVER IT
	CMPB	(R2),#BLANK		; ARE THEY BLANKS ?
	BNE	LOOP			; BRANCH IF SOMTHING ELSE
15$:	INC	R2			; SKIP OVER ONE BLANK
	SOB	R1,10$			; SEARCH FOR MORE MULTIPLE BLANKS
	DEC	R0			; MOVE POINTER TO LAST CHARCTER
40$:	RETURN
	.PAGE
	.SBTTL	>	OUTPUT SUBROUTINES ( OUTPUT, SIGOUT )
OUTPUT:	MOV	#BUF,R0			; SET R0 TO BEGINNING OF TEXT
1$:	CMPB	(R0)+,#BLANK		; LOOK FOR FIRST OCCURING BLANK
	BNE	1$
	MOV	R0,WST
	BIT	#SW.SG,SWITCH		; WAS A SIGNIFICANT FILE SPECIFIED
	BNE	555$
2$:	BIT	#SW.NO,SWITCH		; DO WE WANT TO USE AN INSIG. WORD FILE
	BNE	35$			; IF NE PRINT OUT EVERY WORD
	MOV	#INSWRD,R1		; LOCATE INSIGNIFICANT WORD FILE
	CALL	CMPWRD			; COMPARE INPUT WORD WITH WORD FILE
	BCC	100$
35$:	CALL	SIGOUT			; PUT THE SIGNIFICANT WORD TO CENTER
					; OF PAGE
100$:	CALL	NXTWD			; LOCATE MEXT WORD
	BCC	2$
	RETURN
;
555$:	MOV	#INSWRD,R1
	CALL	CMPWRD			; COMPARE INPUT WORD WITH WORD FILE
	BCS	600$			; IF CS WORD IS NOT SIGNIFICANT
	CALL	SIGOUT
600$:	CALL	NXTWD
	BCC	555$			; IF CC MORE WORDS TO PROCESS
	RETURN
;
CMPWRD:	MOV	WST,R0			; RESTORE WORD START LOCATION TO
6$:	CMPB	(R0)+,(R1)+		; COMPARE INPUT WORD WITH  WORD FILE
	BEQ	6$
	; ONCE PROGRAM FALLS THOUGH HERE, WAS IT BECAUSE [ TEXT WAS DIFFERENT ]
	; OR [ A BLANK AND COMA WERE COMPARED ]
	CMPB	-1(R0),#BLANK		; DID WE COMPARE A COMPLETE INPUT WORD
	BNE	30$			; IF NE THEN LOOK AT NEXT  WORD (TEXT IS DIFFERENT)
;
	CMPB	-1(R1),#COMA		; WAS AN ENTIRE  WORD TESTED
	BEQ	100$			; IF EQ THEN SKIP OVER INPUT WORD 
;
30$:	CMPB	(R1)+,#COMA		; MOVE POINTER TO NEXT  WORD
	BNE	30$
	CMP	R1,INSEND		; HAS ENTIRE WORD FILE BEEN CHECKED
	BLT	CMPWRD			; IF LT LOOK AT REST OF WORD FILE
	CALL	LSTFD			; FIND LOCATION OF NEXT INPUT WORD
	BIT	#SW.SG,SWITCH		; WAS A SIGNIFICANT WORD FILE SPECIFIED
	BNE	99$			; IF NE THEN TRUE
	SUB	WST,R3			; FIND LENGTH OF INPUT WORD + TRAILNG BLANK
	CMP	R3,#3			; IS IT 1 OR 2 CHARCTERS IN LENGTH
	BLE	100$
99$:	SEC
	RETURN
100$:	CLC
	RETURN
;
NXTWD:	CALL	LSTFD			; FIND LOCATION OF NEXT INPUT WORD
	CMP	R3,BEND			; HAVE WE REACHED END OF INPUT LINE
	BGE	15$			; IF GE THEN NO INPUT LINE LEFT
	MOV	R3,WST			; SAVE LOCATION OF NEXT INPUT WORD
	CLC
	RETURN
15$:	SEC
	RETURN
;
SIGOUT:	CALL	BNKTOT			; FILL OUTPUT BUFFER WITH BLANKS
	CLR	STATS			; CLEAR STATUS WORD
	CALL	LFILL			; FILL LEFT SIDE OF PAGE WITH TEXT
	CALL	RFILL			; FILL RIGHT SIDE OF PAGE WITH TEXT AND IF
					; NESSARY WRAP TO LEFT SIDE
	BCS	155$			; IF CS OBUF HAS BEEN TRANSFERED TO OUTPUT FILE
	CMP	TBEG,LMARG		; WHERE DOES OUR TEXT BEGIN ( DID WE HAVE TO STOP
					; BEFORE ALL TEXT WAS MOVED TO LEFT SIDE OF PAGE)
	BGT	122$			; IF GT NO NEED TO WRAP TO LEFT SIDE
	CALL	RWRAP			; WRAP TEXT FROM LEFT TO RIGHT SIDE OF PAGE
122$:	CALL	OFILE			; TRANSFER OBUF TO OUTPUT FILE
155$:	RETURN
	.PAGE
	.SBTTL	>	FILL IN OBUF
LFILL:	CALL	CENTR			; SET POINTER TO CENTER OF OBUF
	DEC	R4
	DEC	R1
	DEC	R1			; LEAVE EXTRA BLANK IN CENTER OF OBUF
	INC	LMARG			; NEEDED TO STOP OUTPUT ONE LINE BEFORE LMARG
10$:	MOVB	-(R4),-(R1)		; FILL OUTPUT BUFFER TO THE LEFT OF CENTER
	CMPB	(R4),#AT		; HAVE WE ENCOUNTERED THE SHELF # TERMINATOR
	BEQ	30$			; IF EQ THEN TEXT HAS BEEN PUT OUT TO
					; THE BEGINNING OF THE FIRST INPUT WORD
	CMP	LMARG,R1		; HAS ALL SPACE ON LEFT SIDE BEEN USED
	BLT	10$			; IF LT MORE ROOM LEFT
	; NOW THERE IS NO ROOM REMAINING ON LEFT SIDE OF PAGE
	BIS	#2,STATS
	DEC	LMARG			; RESET TO ORGINAL VALUE
	MOV	R4,POINT		; SAVE POINTER TO TEXT INCASE WE HAVE
					; ROOM TO WRAP TO THE RIGHT SIDE
	MOV	LMARG,TBEG		; STORE LOCATION OF WHERE TEXT LEFT OFF
	RETURN
30$:	MOV	R1,R2			; NEEDED FOR ARRWS CALL
	DEC	LMARG			; RESET TO ORGINAL VALUE
	MOV	LMARG,R1
	CALL	ARRWS			; PUT OUT TITLE START INDICATORS
	RETURN
RFILL:	CALL	CENTR			; SET POINTER TO CENTER OF OBUF
20$:	MOVB	(R4)+,(R1)+		; MOVE TEXT INTO OBUF
					; FILL OUTPUT BUFFER TO THE RIGHT OF CENTER
	CMP	R1,RMARG		; CAN WE STILL MOVE TEXT TO OBUF
	BGE	21$			; IF GE NO ROOM LEFT ON RIGHT SIDE
	CMP	BEND,R4			; ARE WE AT THE END OF THE INPUT LINE
	BGT	20$			; IF GT END OF INPUT LINE ENCOUNTERED
	CLC				; INDICATE THAT MORE WORK IS TO BE DONE
	RETURN
	; NOW THERE IS NO ROOM ON THE RIGHT SIDE OF PAGE
21$:	BIT	#1,STATS
	BNE	300$
	BIT	#2,STATS		; WAS LEADING TEXT TRUNCATED
	BNE	160$			; IF NE NO ROOM LEFT
	MOV	LMARG,R2
	INC	R2			; THIS IS WHERE TEXT WILL CONTINUE FROM
22$:	CMP	BEND,R4			; ARE WE AT END OF INPUT LINE
	BLE	168$			; IF LE THEN ALL TEXT FIT ON ONE LINE
	CMP	R2,TBEG			; KEEP PUTTING TEXT TO OBUF UNTILL NO ROOM LOFT
	BGE	23$			; IF GE MORE ROOM
	MOVB	(R4)+,(R2)+		; WRAP TEXT TO LEFT SIDE OF PAGE
	BR	22$
;
	; NO MORE ROOM ON EITHER SIDE NOW
23$:	DEC	R2
	DEC	R2
	DEC	R2			; LEAVE A LITTLE ROOM
25$:	CMPB	-(R2),#BLANK
	BNE	25$
109$:	CMP	R2,LMARG		; IS THER ANY TEXT ON THE LEFT MARGIN
	BGT	115$			; IF GT THERE IS STILL TEXT LEFT
110$:	MOVB	#BLANK,(R2)+	; BLANK OUT TRUNCATED WORD
	CMP	R2,TBEG			; STOP WHEN BEGINNING TEXT IS FOUND
	BEQ	300$
	BR	110$
115$:	MOV	R2,-(SP)		; SAVE R2
200$:	MOVB	#BLANK,(R2)+		; GET RID OF UNWANTED TEXT
	CMP	R2,TBEG
	BNE	200$			; IF NE MORE TO BLANK OUT
	MOV	(SP)+,R2		; RESTORE R2
	MOVB	#'.,(R2)+
	MOVB	#'.,(R2)+
	MOVB	#'.,(R2)+
	CALL	DASH			; SEE IF ANY WORDS ARE BROKEN
	BR	169$
300$:	CALL	RDOT			; CONTINUATION DOTS ON RIGHT SIDE
	BR	169$
;
160$:	CALL	LDOT			; PUT IN CONT. DOTS ON RIGHT SIDE OF PAGE
	CALL	RDOT			; PUT IN DOTS ON LEFT SIDE
	CMP	INTPOS,INDCL		; WAS SIG. WORD TO LONG
	BLE	222$			; IF LE ERROR CONDITION
	BR	169$
168$:	CALL	DASH			; SEE IF ANY WORDS HAVE BEEN BROKEN BY WRAP AROUND
169$:	CALL	OFILE			; MOVE OBUF TO OUTPUT FILE
	SEC				; INDICATE OBUF HAS BEEN MOVED TO OUTPUT FILE
	RETURN
;
222$:	CALL	ERRPFX
	PSTR	^*/ SIGNIFICANT WORD TOO LONG FOR PAGE WIDTH /<CR><LF>*
	CALL	INNAM			; PRINT OUT INPUT NAME
	PCRLF
	PCRLF
	MOV	WST,R0
	SUB	#BUF,R0			; LEADING LENGTH
	TTYOUT	#BUF,R0			; PUT OUT FIRST PART
	PSTR	^*/##/*			; INDICATE WHICH WORD IS TOO LONG
	MOV	BEND,R0
	SUB	WST,R0			; TRAILING LENGTH
	TTYOUT	WST,R0			; PUT OUT REST OF LINE
	SEC				; SAY NOTHING MORE IS TO BE DONE
	RETURN
	.PAGE
;
;
;
RWRAP:	MOV	POINT,R5		; RESTORE LOCATION OF WHERE WE LEFT OFF
	MOV	RMARG,R2		; WHERE WE CAN GO NO FURTHER
41$:	MOVB	-(R5),-(R2)		; WRAP TO RIGHT SIDE OF PAGE
	CMPB	(R5),#AT		; HAVE WE REACHED THE BEGINNING OF TEXT
	BEQ	48$			; IF EQ WE MANAGED TO WRAP THE ENTIRE REMAINING LINE
	CMP	R2,R1			; HAVE WE USED UP ALL REMAINING SPACE
	BGT	41$			; IF GT MORE SPACE IS AVAILABLE TO WRAP
	INC	R2
	INC	R2
	INC	R2			; LEAVE A LITTLE ROOM
100$:	CMPB	(R2)+,#BLANK
	BNE	100$
	CMP	R2,RMARG
	BLT	120$			; IF LT SOME TEXT STILL REMAINS ON RIGHT SIDE
110$:	MOVB	#BLANK,-(R2)		; BLANK OUT TRUNCATED WORD
	CMP	R2,R1			; ARE WE BACK TO USABLE TEXT
	BEQ	300$			; IF EQ ALL FINISHED
	BR	110$
120$:	MOV	R2,-(SP)		; SAVE R2
200$:	MOVB	#BLANK,-(R2)		; BLANK OUT ONLY ONE WORD
	CMP	R2,R1			; STOP WHEN AT TEXT
	BNE	200$			; IF NE KEEP GOING
	MOV	(SP)+,R2		; RESTORE R2
	MOVB	#'.,-(R2)
	MOVB	#'.,-(R2)
	MOVB	#'.,-(R2)		; CONTINUATION DOTS
	BR	49$
48$:	CALL	ARRWS			; PUT OUT BEGINNING OF TITLE INDICATORS
49$:	CALL	DASH			; SEE IF ANY WORDS ARE BROKEN AT EDGE OF PAGE
	RETURN
300$:	CALL LDOT
	RETURN
;
;
DASH:	MOV	LMARG,R3
	INC	R3
	CMPB	(R3),#BLANK		; WAS  CHARCTER NEXT TO LEFT BORDER A BLANK
	BEQ	50$			; IF EQ THEN A WORD WAS NOT BROKEN
	CMPB	(R3),#'.
	BEQ	50$
	MOV	RMARG,R3
	DEC	R3			; LOCATE RIGHT EDGE OF TEXT
	CMPB	(R3),#BLANK		; IS THERE A BLANK NEXT TO THE RIGHT BORDER
	BEQ	50$			; IF EQ THEN NO WORD WAS BROKEN
	CMPB	(R3),#'.
	BEQ	50$
	MOVB	#'-,@LMARG		; WE'VE GOT A BROKEN WORD
	MOVB	#'-,@RMARG
50$:	RETURN
;
;
OFILE:	CALL	SHFOUT			; MOVE SHELF NUMBER TO OBUF
	PUT$	#FDBOUT,#OBUF,WDTH	; PUT OBUF INTO OUTPUT FILE
	RETURN
;
CENTR:	MOV	WST,R4			; FIND OUR SIGNIFICANT WORD
	MOV	INDCL,R1		; LOCATION OF INDEX COLUMN
	RETURN
;
ARRWS:	INC	R2
	MOV	#3,R0			; COUNTER FOR ARROWS
40$:	MOVB	#'>,-(R2)		; MOVE YOUR ARROW
	CMP	R1,R2			; IS THERE STILL ROOM FOR ARROWS
	BGE	11$			; IF GE NO SPACE LEFT FOR ANYTHING
	SOB	R0,40$
	MOV	R2,TBEG			; SAVE WHERE WE LEFT OFF
	BR	16$				; RETURN
11$:	BIS	#1,STATS
	MOV	LMARG,TBEG		; SAVE WHERE WE LEFT OFF
	INC	TBEG
16$:	RETURN
	.PAGE
	.SBTTL	>	( BNKTOT, SHFOUT, LSTFD, RDOT, LDOT, DOT )
BNKTOT:	MOV	#OBUF,R4			; LOCATION OF OUTPUT BUFFER
	MOV	#132.,R1		; SET COUNTER FOR NUMBER OF BLANKS
12$:	MOVB	#BLANK,(R4)+		; FILL ENTIRE OUTPUT BUFFER WITH BLANKS
	SOB	R1,12$
	RETURN
;
;
SHFOUT:	MOV	#BUF,R1			; LOCATION OF BEGINNING OF SHELF NUMBER
	MOV	SHELF,R2		; POSTION IN OBUF TO PUT IT
25$:	MOVB	(R1)+,(R2)+		; MOVE IT TO OBUF
	CMPB	(R1),#AT		; KEEP GOING UNTILL SHELF # TERMINATOR FOUND
	BNE	25$
	RETURN
;
LSTFD:	MOV	WST,R3			; BEGINNING OF INPUT WORD
2$:	CMPB	(R3)+,#BLANK		; SEARCH FOR THE TRAILING BLANK
	BNE	2$			; IF NE NOT AT END OF WORD YET
	RETURN				; RETURN WHEN END OF INPUT WORD FOUND
;
;
RDOT:	MOV	RMARG,R5		;  FOR INITIAL LEFTWARD MOVEMENT
	MOV	#-1,R3			; OF DOT CALL
	CALL	DOT			; PUT OUT CONTINUATION DOTS
	RETURN
;
LDOT:	MOV	LMARG,R5		;  FOR INITIAL RIGHTWARD MOVEMENT
	MOV	#1,R3			; OF DOT CALL
	CALL	DOT			; CONTINUATION DOTS
	RETURN
;
;
DOT:	MOV	R5,R4			; SAVE FOR COMPARISONS
	CLR	R0			; COUNTER FOR HOW FAR WE HAD TO LOOK FOR A BLANK
3$:	INC	R0			; KEEP TRACK OF HOW MANY ITERATIONS
	ADD	R3,R5		; R3 IS ( -1 OR +1 ) LEFT OR RIGHT MOVEMENT RESPECTIVLY
	CMPB	(R5),#BLANK		; KEEP LOOKING UNTILL WE FIND A BLANK
	BNE	3$			; IF NE KEEP LOOKING
	; NOW WE SHALL PROCEED IN THE OPPOSITE DIRECTION
	MOV	R5,INTPOS		; SAVE POSITION OF DOTS
	MOV	#3,R0			; NUMBER OF CONTINUATION DOTS
5$:	CMP	R5,R4
	BEQ	11$
	MOVB	#'.,(R5)		; MOVE IN THE DOTS
	SUB	R3,R5		; R3 IS ( -1 OR +1 ) RIGHT OR LEFT MOVEMENT RESPECTIVLY
	SOB	R0,5$
;
6$:	CMP	R5,R4			; IS THERE STILL ROOM
	BEQ	8$			; IF EQ STOP NOW
	MOVB	#BLANK,(R5)
	SUB	R3,R5
	BR	6$			; DO IT AGAIN
8$:	MOVB	#BLANK,(R5)
11$:	RETURN
	.END	START