.TITLE	DAC -- DISK ACCOUNTING
	.SBTTL	TITLE PAGE
	.IDENT	-010200-
;+
; ABSTRACT:	DAC
;
;	THIS PROGRAM WILL PRODUCE A FILE CONTAINING THE DISK
; ACCOUNTING INFORMATION FOR EACH UIC.
;
; OPERATING PROCEDURES:
;
;	THIS TASK CAN BE RUN EITHER AS AN MCR COMMAND OR BY
;	SAYING RUN $DAC$. IT PROMPTS WITH
;
;		DAC>
;
;	AND EXPECTS A COMMAND STRING OF THE FORM:
;
;		FILE=DEV:
;
;	WHERE DEV: IS THE DEVICE ON WHICH THE SCAN IS TO BE
;	DONE (DEV: DEFAULTS TO SY:) AND "FILE" IS THE FILE
;	TO WHICH THE INFORMATION IS TO BE WRITTEN.
;		DAC WILL ALSO DO A CURSORY CHECK OF THE FILE
;	HEADERS ON THE INDEX FILE WHILE IT IS IN THERE ANYWAY.
;	THE INFORMATION IS GENERALLY CLOSE TO THAT WHICH YOU
;	MIGHT GET FROM RUNNING "VFY" IN READ CHECK MODE, BUT
;	RUNS FASTER. "VFY" IS ABLE TO FIND MORE ERRORS OF COURSE
;	SINCE IT LOOKS AT WHETHER THE BLOCKS ARE PHYSICALLY
;	READABLE (AS WELL AS WHETHER THE INDEX FILE IS INTACT).
;	DAC DOES NOT DO ANYTHING ANALOGOUS TO THE "VFY"
;	CONSISTENCY CHECK OR LOST FILE SCAN.
;
; TASK:		DAC
;
; WRITTEN: 07-SEP-78, -0.0.0-, BRUCE C. WRIGHT
; MODIFIED: 23-JUN-80, -1.0.0-, BRUCE C. WRIGHT
;	CHANGED TO USE MULTI-BLOCK I/O
; MODIFIED: 12-JUL-80, -1.1.0-, BRUCE C. WRIGHT
;	INCREASED THE NUMBER OF UIC'S TO 800.
; Modified: 08-Jan-1981, -1.2.0-, Bruce C. Wright and Glenda Begeman
;	Corrected running off end of file if index file almost full
; Verified: 07-May-1981, -1.2.0-, Bruce C. Wright
;-

	.SBTTL	MACRO CALLS
	.MCALL	QIOW$,WSIG$S,EXIT$S
	.MCALL	OPNS$R,OPEN$W,READ$,WAIT$,CLOSE$,PUT$
	.MCALL	CSI$,CSI$1,CSI$2
	.MCALL	GCML$,GCMLB$
	.MCALL	FDAT$A,FDBF$A,FDRC$A,FDBK$A,FDOP$A
	.MCALL	FDBDF$,FSRSZ$,NMBLK$
	.MCALL	FDOF$L,FCSBT$,FHDOF$,HMBOF$
	FDOF$L
	FCSBT$
	FHDOF$	DEF$L
	HMBOF$	DEF$L
 
CMDLUN=1
CMDEVF=1
INDLUN=2
INDEVF=2
MSGLUN=3
MSGEVF=3
UICLUN=4
UICEVF=4
;
N.UIC	=	800.	; RESERVE SPACE FOR 800. UIC'S
N.BLK	=	16.	; DO 16-BLOCK MULTI-BLOCK I/O
 
	.SBTTL	MACRO DEFINITIONS
 
	.MACRO	MSG	ARG
	.NCHR	$$$,<ARG>
	.WORD	$$$
	.ASCII	"ARG"
	.EVEN
	.ENDM
 
	.MACRO	TYPE	STR,LEN
	MOV	STR,-(SP)
	MOV	LEN,-(SP)
	CALL	TYPE
	CMP	(SP)+,(SP)+
	.ENDM
 
	.MACRO	TYPMSG	ARG
	TYPE	#ARG+2,ARG
	.ENDM
 
	.MACRO	ONERR	ARG
	BCC	.+6
	JMP	ARG
	.ENDM
 
 

	.SBTTL	MAIN LINE CODE
	.PSECT	CODE,RO,I
BEGIN::	MOV	SP,SPSAVE
	GCML$	#CMLBLK		;
	BCC	GETOK		;GOT A LINE
	CMPB	CMLBLK+G.ERR,#GE.EOF ;EOF?
	BNE	10$		;NO
	EXIT$S			;YES
10$:	CMPB	CMLBLK+G.ERR,#GE.IOR ;I/O ERROR?
	BNE	20$		;NO
	TYPMSG	M.IOR
	EXIT$S			;THIS IS FATAL
20$:	CMPB	CMLBLK+G.ERR,#GE.OPR ;OPEN ERROR?
	BNE	30$
	TYPMSG	M.OPR
	BR	BEGIN
30$:	CMPB	CMLBLK+G.ERR,#GE.BIF ;SYNTAX ERROR?
	BNE	40$		;NO
	TYPMSG	M.BIF
	BR	BEGIN
40$:	CMPB	CMLBLK+G.ERR,#GE.MDE ;MAX @ DEPTH?
	BNE	50$
	TYPMSG	M.MDE
	BR	BEGIN
50$:	TYPMSG	M.UNK		;UNKNOWN ERROR
	EXIT$S			;AND LEAVE
GETOK:	TST	CMLBLK+G.CMLD	;INPUT?
	BEQ	BEGIN		;NO
	CSI$1	#CSIBLK,CMLBLK+G.CMLD+2,CMLBLK+G.CMLD ;
	BCC	10$
	TYPMSG	M.PS1
	BR	BEGIN
10$:	CSI$2	#CSIBLK,INPUT	;
	BCC	20$		;OK?
	TYPMSG	M.PS2		;NO
	BR	BEGIN		;RESTART
20$:	MOV	#DEVLEN,DSPT	;SET UP DSPT
	MOV	#DEVSTR,DSPT+2	;FOR THE OPEN MACRO
	BITB	#CS.NMF!CS.DIF!CS.WLD!CS.MOR,CSIBLK+C.STAT
	BEQ	30$		;ANY ILLEGAL BITS SET?
	TYPMSG	M.BAD		;YES -- BAD PARAMETERS
	JMP	BEGIN		;
30$:	BITB	#CS.DVF,CSIBLK+C.STAT ;DEV STRING?
	BEQ	40$		;NO
	MOV	CSIBLK+C.DEVD,DSPT ;MOVE IN DEVICE DESC.
	MOV	CSIBLK+C.DEVD+2,DSPT+2
40$:	OPNS$R	#INDEX,,#DSPT	;OPEN THE INDEX FILE
	  ONERR	ERROR		;SKIP IF ERROR
	CSI$2	#CSIBLK,OUTPUT
	BCC	50$		;ERROR?
	TYPMSG	M.PS2		;YES
	CLOSE$	#INDEX		;CLOSE INDEX FILE
	JMP	BEGIN		;AND LOOP.
50$:	BITB	#CS.WLD!CS.MOR,CSIBLK+C.STAT ;ILLEGAL PARAMETERS?
	BEQ	60$		;NO
	TYPMSG	M.BAD		;YES
	CLOSE$	#INDEX
	JMP	BEGIN
60$:	OPEN$W	#UICFDB,,#CSIBLK+C.DSDS
	  ONERR	ERROR		;ERROR?

	CLR	INDEX+F.EFBK	;FIXUP FDB OF INDEX FILE
	MOV	#3,INDEX+F.EFBK+2 ;SO WE DON'T GET AN EOF
	CLR	INDEX+F.HIBK
	MOV	#3,INDEX+F.HIBK+2 ;DITTO
	CLR	INDEX+F.BKVB	;CLEAR HI ORDER BLOCK #
	MOV	#2,INDEX+F.BKVB+2 ;INIT LO ORDER BLOCK #
	READ$	#INDEX,#HOME,#1000 ;READ HOME BLOCK
	  ONERR	ERROR
	WAIT$	R0		;WAIT FOR IO
	  ONERR	ERROR
	CLR	BITADR		;CLEAR BITMAP OFFSET #
	CLR	CURID		;INIT CURRENT FILE ID
	MOV	#-1,CURBLK	; INIT CURRENT BLOCK NO.
	CLR	CURCNT		; INIT CURRENT NUMBER OF BLOCKS.
	MOV	HOME+H.IBSZ,R1	;NOW FIXUP REAL LENGTH OF INDEX FILE
	ADD	HOME+H.FMAX,R1	;ADD INDEX FILE SIZE + MAX # OF FILES
	ADD	#3,R1		;PLUS BASE = INDEX FILE SIZE + 1
	MOV	R1,INDEX+F.HIBK+2 ; (WE DON'T WANT TO GET EOF)
	MOV	R1,INDEX+F.EFBK+2 ;
	MOV	#UICAREA,MAXUIC	;CLEAR UIC BUFFER ALLOC AREA.
100$:	MOV	BITADR,R1	;GET BITMAP OFFSET BLOCK
	INC	BITADR		;INC IT FOR NEXT TIME.
	CMP	R1,HOME+H.IBSZ	;OVER BITMAP SIZE?
	BHIS	900$		;YES -- LEAVE.
	ADD	#3,R1		;CONVERT IT TO VIRTUAL BLOCK #
	CLR	INDEX+F.BKVB	;CLEAR HI BLOCK #
	MOV	R1,INDEX+F.BKVB+2 ;INIT LOW BLOCK #
	READ$	#INDEX,#BITMAP,#1000 ;READ INDEX FILE
	  ONERR	ERROR
	WAIT$	R0		;WAIT
	  ONERR	ERROR
	MOV	#BITMAP,R1	;POINT TO BITMAP.
120$:	MOV	(R1)+,R2	;GET A WORD OF BITMAP
	BEQ	200$		;SKIP IF NO FILES HERE
	CLR	R3		;GET OFFSET OFF OF CURID
125$:	INC	R3		;INC COUNTER
	ROR	R2		;GET NEXT FILE ID
	BCC	130$		;SKIP IF NONE THERE
	MOV	R3,R5		;GET OFFSET OFF CURID
	ADD	CURID,R5	;ADD IN CURRENT ID #
	CALL	CHECK		;CHECK THIS FILE ID
	TST	R2		;SEE IF R2 HAS ANYTHING IN IT
130$:	BNE	125$		;LOOP UNTIL THIS GOES TO 0
200$:	ADD	#20,CURID	;INC CURRENT FILE ID BASE
	CMP	R1,#BITEND	;OFF END OF BITMAP?
	BLO	120$		;NO -- LOOP OVER BITMAP
	BR	100$		;YES -- NEXT BLOCK
900$:	CLOSE$	#INDEX
	MOV	#UICAREA,R5	;GET UIC AREA.
SORT1:	CMP	R5,MAXUIC	;AT END OF UIC TABLE?
	BHIS	ENDSOR		;YES
	MOV	R5,R4		;GET SORT POSITION.
	MOV	(R5),R3		;GET KEY.
SORT:	ADD	#UIC.S,R4	;GET R4 TO NEXT ENTRY.
	CMP	R4,MAXUIC	;AT END OF UIC TABLE?
	BHIS	ENDS0		;YES
	MOV	(R4),R2		;GET THE NEXT ENTRY
	CMP	R2,R3		;MOVE IT?
	BHIS	10$		;NO.
	MOV	R2,R3		;YES -- CHANGE KEY
	MOV	(R5),-(SP)	;
	MOV	(R4),(R5)	;
	MOV	2(R5),-(SP)	;
	MOV	2(R4),2(R5)	;
	MOV	4(R5),-(SP)	;
	MOV	4(R4),4(R5)	;
	MOV	(SP)+,4(R4)	;
	MOV	(SP)+,2(R4)	;
	MOV	(SP)+,(R4)	;
10$:	BR	SORT		;AND LOOP OVER THE RECORDS.
ENDS0:	ADD	#UIC.S,R5	;GET TO NEXT REC FOR R5
	BR	SORT1		;AND SORT
ENDSOR:	MOV	#UICAREA,R5	;
910$:	CMP	R5,MAXUIC	;AT END OF MAX UIC?
	BHIS	920$		;YES -- LEAVE.
	MOV	#BUFFER,R0	;POINT TO THE BUFFER.
	MOVB	#'[,(R0)+	;OUTPUT A [
	MOVB	1(R5),R1	;GET THE UIC
	BIC	#^C377,R1	;CLEAN OUT HI GARBAGE
	CALL	OUTUIC		;OUTPUT UIC
	MOVB	#',,(R0)+	;OUTPUT A ,
	MOVB	(R5),R1		;GET THE NEXT PART OF UIC
	BIC	#^C377,R1	;CLEAN OUT HI ORDER AGAIN
	CALL	OUTUIC		;CONVERT UIC
	MOVB	#'],(R0)+	;OUTPUT
	MOVB	#'	,(R0)+	;OUTPUT A TAB.
	MOV	R5,R1		;POINT TO THE DBL WORD
	ADD	#2,R1		;BUMP POINTER TO WORD.
	CLR	R2		;
	CALL	$C2DMG		;CONVERT IT.
	SUB	#BUFFER,R0	;COMPUTE LENGTH OF BUFFER
	MOV	R0,R1		;MOVE INTO R1
	PUT$	#UICFDB,#BUFFER,R1 ;PUT OUT THE DATA.
	  ONERR	ERROR		;ON ERROR, LEAVE.
	ADD	#UIC.S,R5	;INC POINTER.
	BR	910$		;AND LOOP.
920$:	CLOSE$	#UICFDB
	JMP	BEGIN		;RESTART
ERROR:	MOV	#BLKPR,R1
	MOV	#BLKSZ,R2
	TST	@#$DSW		;ERROR IN DSW?
	BPL	10$		;NO
	MOV	@#$DSW,F.ERR(R0) ;MOVE DSW INTO ERROR CODE
10$:	CALL	.PRFCS		;PRINT FCS ERROR CODE
	CLOSE$	#INDEX
	CLOSE$	#UICFDB		;
	MOV	SPSAVE,SP	;RESTORE SP
	JMP	BEGIN		;AND RESTART EXECUTION

	.SBTTL	ACCOUNT THIS FILE'S BLOCKS
;
; ENTER SUBROUTINE WITH:
;
;	R5	FILE ID OF BLOCK
;
;	R0 AND R4 ARE MODIFIED;  ALL OTHER REGISTERS ARE
;		PRESERVED.
;
CHECK:
	MOV	R1,-(SP)	;SAVE R1
	MOV	R2,-(SP)	;SAVE R2
	MOV	R3,-(SP)	;SAVE R3
	MOV	R5,R0		;GET FILE ID
	ADD	HOME+H.IBSZ,R0	;GET FIRST BLOCK #
	ADD	#2,R0		;  + 2 FOR ORIGIN.
	CALL	GETBLK		; GET THE BLOCK
				; (RETURN ADDR IN R0)
	CMP	R5,H.FNUM(R0) ;CORRECT FID?
	BEQ	20$		;YES -- NO MESSAGE
	CALL	BADHDR		;NO -- PRINT NASTY MESSAGE
20$:	MOV	R0,R1		;POINT TO HEADER
	MOV	#400-1,R2	;GET COUNT
	CLR	R3		;CLEAR CHECKSUM
C0:	ADD	(R1)+,R3	;ADD IN CHECKSUM
	SOB	R2,C0		;
	CMP	(R1)+,R3	;EQUAL TO CKSUM?
	BEQ	10$		;YES
	CALL	CHKHDR		;NO
10$:	CMP	#401,H.FLEV(R0) ;CORRECT VERSION?
	BEQ	12$		;NO
	CALL	LEVHDR		;HEADER LEVEL MISMATCH
12$:	MOVB	H.IDOF(R0),R1 ;GET ID OFFSET
	ASL	R1
	CMP	R1,#1000-S.IDHD-S.MPHD ;TOO BIG?
	BLO	15$		;NO
	CALL	BIDHDR		;YES
15$:	CMPB	H.IDOF(R0),#27 ;'NORMAL' VALUE?
	BEQ	16$		;YES
	CALL	NIDHDR		;NO
16$:	BITB	#UC.DLK,H.UCHA(R0) ;LOCKED FILE?
	BEQ	21$		;NO
	CALL	DLKHDR		;PRINT MESSAGE
21$:	BITB	#SC.MDL,H.SCHA(R0) ;MARKED FOR DELETE?
	BEQ	22$		;NO
	CALL	DELHDR		;PRINT MESSAGE
22$:	BITB	#SC.BAD,H.SCHA(R0) ;BAD BLOCK IN FILE?
	BEQ	23$		;NO
	CALL	BLKHDR		;PRINT MESSAGE
23$:	MOVB	H.MPOF(R0),R1 ;GET MAP AREA OFFSET
	ASL	R1		;ADJUST FOR WORDS
	BIC	#^C777,R1
	ADD	R0,R1		; ABSOLUTISE
	MOVB	M.USE(R1),R2	;GET # USED
	BIC	#^C377,R2	;CLEAR HI BYTE
	ASL	R2		;
	ADD	R1,R2		;COMPUTE END OF MAP AREA
	MOV	R0,-(SP)	;SAVE BEGINNING OF BUFFER
	ADD	#1000-2-S.MPHD,(SP) ; COMPUTE END OF BUFFER.
	CMP	R2,(SP)+	; OVER TOP?
	BLOS	25$		;HEADER OK
	CALL	MAPHDR		;
	BR	CHECKE		;
25$:	CMPB	H.MPOF(R0),#56 ;IS IT NORMAL?
	BEQ	26$		;YES
	CALL	NMPHDR		;NO
26$:	MOVB	M.USE(R1),R4	;GET NUMBER OF PTRS IN USE
	BIC	#^C377,R4	;CLEAN GARBAGE
	CMP	R4,#<1000-S.IDHD-S.MPHD-S.HDHD-2>/2 ;OVER MAX # OF POINTERS?
	BHI	27$		;YES -- ERROR
	CMPB	R4,M.MAX(R1)	;OVER MAX # THIS HEADER BLK?
	BLOS	28$		;NO -- OK
27$:	CALL	PTRHDR		;ERROR MESSAGE
28$:	CMPB	M.CTSZ(R1),#1	;SIZE OF BLOCK COUNT UNUSUAL?
	BEQ	C1		;NO
	CALL	BCFHDR		;YES
C1:	CMPB	M.LBSZ(R1),#3	;LOGICAL BLOCK UNUSUAL?
	BEQ	10$		;NO
	CALL	LBNHDR		;YES
10$:	CMPB	M.MAX(R1),#<1000-S.HDHD-S.IDHD-S.MPHD-2>/2
				;MAX # OF POINTERS NORMAL?
	BEQ	20$		;YES
	CALL	MAXHDR		;
20$:	ADD	#M.RTRV,R1	;GET START OF POINTERS
	CLR	R2		;CLEAR NUMBER OF BLOCKS
	CLR	R3		;AND HI ORDER
	TST	R4		;0 RETRIEVAL POINTERS?
	BEQ	CHECKE
	MOV	R5,-(SP)	; SAVE R5
30$:	MOV	(R1)+,R5	; GET COUNT AND HIGH LBN
	ADD	#2,R1		; SKIP LOW LBN
	CLRB	R5		;CLEAR HI LBN OFF R3
	SWAB	R5		;GET COUNT INTO LOW PART OF R3
	INC	R5		;INC COUNT.
	ADD	R5,R2		;ADD IN LOW ORDER.
	ADC	R3		;ADD IT IN TO HIGH ORDER IF ANY
	SUB	#2,R4		;DEC WORD COUNT
	BGT	30$		;LOOP IF MORE
	MOV	(SP)+,R5	; RECOVER R5
CHECKE:	MOV	#UICAREA,R1	;POINT TO THE DATA AREA.
10$:	CMP	R1,MAXUIC	;OVER MAX USED PORTION?
	BHIS	100$		;YES -- ADD THIS UIC.
	CMP	UIC.UI(R1),H.PROG(R0) ;UIC MATCH?
	BEQ	200$		;YES -- ACCUM BLOCKS THIS UIC
	ADD	#UIC.S,R1	;NO -- GET TO NEXT UIC ENTRY
	BR	10$		;AND LOOP.
100$:	ADD	#UIC.S,R1	;ALLOCATE THE AREA TO BE USED.
	CMP	R1,#UICEND	;OVER DATA AREA?
	BHIS	120$		;YES -- ERROR
	MOV	R1,MAXUIC	;SAVE MAX UIC ADDR
	SUB	#UIC.S,R1	;POINT TO LAST UIC BLOCK
	MOV	H.PROG(R0),UIC.UI(R1) ;MOVE IN THE UIC.
	CLR	UIC.BL(R1)	;CLEAR MAX USED BLOCKS
	CLR	UIC.BL+2(R1)	;AND LOW ORDER
	BR	200$		;AND JOIN ALLOCATED CODE
120$:	TYPMSG	M.UIC		;NO SPACE TO ADD UIC.
	MOV	SPSAVE,SP	;RECOVER SP
	CLOSE$	#INDEX		;CLOSE INDEX FILE
	CLOSE$	#UICFDB		;AND UIC OUTPUT FILE
	JMP	BEGIN		;AND LOOP
200$:	ADD	R2,UIC.BL+2(R1)	;INC LOW ORDER # BLOCKS THIS UIC
	ADC	UIC.BL(R1)	;HANDLE OVERFLOW
	ADD	R3,UIC.BL(R1)	;ADD IN THE HIGH ORDER.
	MOV	(SP)+,R3	;RECOVER R3
	MOV	(SP)+,R2	;RECOVER R2
	MOV	(SP)+,R1	;RECOVER R1
	RETURN			;AND RETURN

	.SBTTL	NOTE THAT THIS BLOCK HAS A BAD HEADER
;
; THIS SUBROUTINE NOTES THAT THE HEADER FOR THIS BLOCK IS BAD
;
BADHDR:	MOV	R0,-(SP)	;SAVE R0
	MOV	R1,-(SP)	;SAVE R1
	MOV	R2,-(SP)	;
	MOV	R3,-(SP)
	MOV	#HDRMSG,R2	;SAVE START OF BUFFER
PRTMSG:	MOV	R0,R3		;REMEMBER BEGINNING OF BUFFER.
	MOV	#BUFFER,R0	;GET DST ADDR
5$:	MOVB	(R2)+,(R0)+	;MOVE IN CHARS
	BNE	5$		;LOOP WHILE MORE.
	DEC	R0		;DECREMENT TO LAST MOVED 0.
	MOV	R5,R1		;GET REAL NUMBER
	MOV	#1,R2
	CALL	$CBOMG		;
	MOVB	#'/,(R0)+
	MOV	H.FNUM(R3),R1
	CALL	$CBOMG		;BINARY MAGNITUDE
	MOVB	#',,(R0)+
	MOV	H.FSEQ(R3),R1
	CALL	$CBOMG		;
	MOVB	#' ,(R0)+
	MOVB	#' ,(R0)+
	MOVB	#'[,(R0)+	;GET UIC
	MOVB	H.PROJ(R3),R1
	BIC	#^C377,R1
	CLR	R2
	CALL	$CBOMG		;CONVERT GROUP CODE
	MOVB	#',,(R0)+	;
	MOVB	H.PROG(R3),R1
	BIC	#^C377,R1
	CLR	R2
	CALL	$CBOMG
	MOVB	#'],(R0)+
	MOV	R4,-(SP)	; SAVE R4
	MOVB	H.IDOF(R3),R4 ;GET HEADER ID OFFSET
	ASL	R4		;CONVERT TO BYTES
	ADD	R3,R4		; ABSOLUTISE
	CLR	R2
	MOV	I.FNAM(R4),R1	;
	CALL	$C5TA
	MOV	I.FNAM+2(R4),R1
	CALL	$C5TA
	MOV	I.FNAM+4(R4),R1
	CALL	$C5TA
10$:	CMPB	-(R0),#' 	;IS IT BLANK?
	BEQ	10$		;YES
	INC	R0		;INC TO NEXT LOCATION.
	MOVB	#'.,(R0)+
	MOV	I.FTYP(R4),R1
	CALL	$C5TA		;GET FILE TYPE
20$:	CMPB	-(R0),#' 	;BLANK?
	BEQ	20$		;YES
	INC	R0		;
	MOV	I.FVER(R4),R1	;GET VERSION #
	MOV	(SP)+,R4	; RECOVER R4
	MOVB	#';,(R0)+
	CLR	R2		;
	CALL	$CBOSG		;TO OCTAL
	SUB	#BUFFER,R0
	TYPE	#BUFFER,R0	;TYPE MESSAGE
	MOV	(SP)+,R3
	MOV	(SP)+,R2	;RECOVER R2
	MOV	(SP)+,R1
	MOV	(SP)+,R0
	RETURN			;AND RETURN

	.SBTTL	NOTE THAT THIS FILE HAS AN ILLEGAL MAX POINTERS
;
; THIS SUBROUTINE NOTES THAT THE FILE HAS AN ILLEGAL MAX # OF
; RETRIEVAL POINTERS.
;
MAXHDR:	MOV	R0,-(SP)
	MOV	R1,-(SP)
	MOV	R2,-(SP)
	MOV	R3,-(SP)
	MOV	#MAXMSG,R2
	JMP	PRTMSG
 
	.SBTTL	NOTE THAT THIS FILE HAS AN ILLEGAL STRUCTURE LEVEL
;
; THIS SUBROUTINE NOTES THAT THE FILE HAS AN ILLEGAL STRUCTURE
; LEVEL. THIS NUMBER CAN CHANGE IF FILES-11 IS CHANGED.
;
LEVHDR:	MOV	R0,-(SP)
	MOV	R1,-(SP)
	MOV	R2,-(SP)
	MOV	R3,-(SP)
	MOV	#LEVMSG,R2
	JMP	PRTMSG

	.SBTTL	NOTE THAT THIS FILE HAS A BAD POINTER
;
; THIS SUBROUTINE NOTES THAT A FILE HAS A BAD INDEX RETRIEVAL
; POINTER VALUE.
;
PTRHDR:	MOV	R0,-(SP)
	MOV	R1,-(SP)
	MOV	R2,-(SP)
	MOV	R3,-(SP)
	MOV	#PTRMSG,R2
	JMP	PRTMSG
 
	.SBTTL	NOTE THAT THIS FILE HAS A CHECKSUM ERROR
;
; THIS SUBROUTINE NOTES THAT A FILE HEADER HAS A CHECKSUM
; ERROR.
;
CHKHDR:	MOV	R0,-(SP)
	MOV	R1,-(SP)
	MOV	R2,-(SP)
	MOV	R3,-(SP)
	MOV	#CHKMSG,R2
	JMP	PRTMSG
 
	.SBTTL	NOTE THAT THIS FILE HAS A BAD MAP OFFSET
;
; THIS SUBROUTINE NOTES THAT A FILE HAS A BAD MAP AREA OFFSET
;
MAPHDR:	MOV	R0,-(SP)
	MOV	R1,-(SP)
	MOV	R2,-(SP)
	MOV	R3,-(SP)
	MOV	#MAPMSG,R2
	JMP	PRTMSG
 
	.SBTTL	NOTE THAT THIS FIE HAS A BAD ID OFFSET
;
; THIS SUBROUTINE NOTES THAT A FILE HAS A BAD ID AREA OFFSET
;
BIDHDR:	MOV	R0,-(SP)
	MOV	R1,-(SP)
	MOV	R2,-(SP)
	MOV	R3,-(SP)
	MOV	#BIDMSG,R2
	JMP	PRTMSG

	.SBTTL	NOTE THAT THIS FILE HAS A SUSPICIOUS MAP OFFSET
;
; THIS SUBROUTINE NOTES THAT A FILE HAS A 'SUSPICIOUS' MAP OFFSET
; NUMBER. THE 'NORMAL' MAP OFFSET IS 56 (OCTAL), BUT THIS MIGHT
; CHANGE WITH DIFFERENT VERSIONS OF FILES-11
;
NMPHDR:	MOV	R0,-(SP)
	MOV	R1,-(SP)
	MOV	R2,-(SP)
	MOV	R3,-(SP)
	MOV	#NMPMSG,R2
	JMP	PRTMSG
 
	.SBTTL	NOTE THAT THIS FILE HAS A SUSPICIOUS ID OFFSET
;
; THIS SUBROUTINE NOTES THAT A FILE HAS A 'SUSPICIOUS' ID OFFSET
; THE 'NORMAL' OFFSET IS 27, BUT THIS MIGHT CHANGE WITH DIFFERENT
; VERSIONS OF FILES-11
;
NIDHDR:	MOV	R0,-(SP)
	MOV	R1,-(SP)
	MOV	R2,-(SP)
	MOV	R3,-(SP)
	MOV	#NIDMSG,R2
	JMP	PRTMSG
 
	.SBTTL	NOTE THAT THIS FILE HAS AN ILLEGAL BLK-CNT FIELD
;
; THIS SUBROUTINE NOTES THAT THE FILE HAS AN ILLEGAL BLOCK COUNT
; FIELD.
;
BCFHDR:	MOV	R0,-(SP)
	MOV	R1,-(SP)
	MOV	R2,-(SP)
	MOV	R3,-(SP)
	MOV	#BCFMSG,R2
	JMP	PRTMSG
 
	.SBTTL	NOTE THAT THIS FILE HAS AN ILLEGAL LBN SIZE
;
; THIS SUBROUTINE NOTES THAT THE FILE HAS AN ILLEGAL VALUE FOR THE
; LBN SIZE FOR THE RETRIEVAL POINTERS
;
LBNHDR:	MOV	R0,-(SP)
	MOV	R1,-(SP)
	MOV	R2,-(SP)
	MOV	R3,-(SP)
	MOV	#LBNMSG,R2
	JMP	PRTMSG
 

	.SBTTL	NOTE THAT THIS FILE IS LOCKED
;
; NOTE THAT THE FILE BLOCK IN CORE IS A LOCKED FILE
;
DLKHDR:	MOV	R0,-(SP)
	MOV	R1,-(SP)
	MOV	R2,-(SP)
	MOV	R3,-(SP)
	MOV	#DLKMSG,R2	;
	JMP	PRTMSG		;PRINT MESSAGE
 
	.SBTTL	NOTE THAT FILE IS MARKED FOR DELETE
;
; THIS SUBROUTINE NOTES THAT THE FILE HEADER IN CORE IS MARKED FOR
; DELETE
;
DELHDR:	MOV	R0,-(SP)
	MOV	R1,-(SP)
	MOV	R2,-(SP)
	MOV	R3,-(SP)
	MOV	#DELMSG,R2
	JMP	PRTMSG		;AND PRINT MESSAGE
 
	.SBTTL	NOTE THAT FILE HAS BAD BLOCK
;
; THIS SUBROUTINE NOTES THAT THE SYSTEM BAD BLOCK IN FILE BIT
; IS SET.
;
BLKHDR:	MOV	R0,-(SP)
	MOV	R1,-(SP)
	MOV	R2,-(SP)
	MOV	R3,-(SP)
	MOV	#BLKMSG,R2
	JMP	PRTMSG

;
; SUBROUTINE TO OUTPUT A 3-DIGIT UIC.
;
; R1 HAS UIC CODE TO BE OUTPUT
; R0 HAS ADDR TO PUT CODE
;
OUTUIC:
	MOV	R1,-(SP)	;SAVE R2
	ASH	#-6,R1		;SHIFT TO RIGHT BITS.
	MOVB	R1,(R0)		;GET FIRST DIGIT
	BICB	#370,(R0)	;
	BISB	#'0,(R0)+	;MAKE IT NUMERIC
	MOV	(SP),R1		;RECOVER R1
	ASH	#-3,R1		;
	MOVB	R1,(R0)		;GET SECOND DIGIT
	BICB	#370,(R0)	;
	BISB	#'0,(R0)+	;MAKE IT NUMERIC
	MOV	(SP)+,R1	;RESTORE R1
	MOVB	R1,(R0)		;SAVE THIRD DIGIT
	BICB	#370,(R0)	;CLEAN GARBAGE
	BISB	#'0,(R0)+	;MAKE IT NUMERIC
	RETURN			;AND RETURN TO CALLER.
;
; THE FOLLOWING PROGRAM WILL CONVERT A BINARY NUMBER
; INTO DECIMAL. THE NUMBER MUST BE DOUBLE PRECISION.
;
; R0	THE ADDRESS AT WHICH TO PLACE THE DECIMAL RESULT.
; R1	A POINTER TO A 2-WORD BLOCK OF MEMORY WITH THE NUMBER.
; R2	= 0 MEANS SUPPRESS LEADING ZERO'S.
;
$C2DMG:
	MOV	R5,-(SP)	;SAVE REGISTERS.
	MOV	R4,-(SP)	;
	MOV	R3,-(SP)	;
	MOV	R2,-(SP)	;SAVE R2
	MOV	R1,-(SP)	;
	MOV	R0,R5		;R5 WILL BE TEMP. R0.
	MOV	2(R1),R2	;GET THE LOW ORDER.
	MOV	(R1),R1		;FIXUP LOW ORDER.
	CLR	R4		;CLEAR LENGTH OF STRING.
10$:	MOV	#10.,R0		;GET DIVISOR.
	CALL	$DDIV		;DIVIDE THE NUMBER.
	ADD	#'0,R0		;MAKE IT A NUMERIC.
	MOVB	R0,(R5)		;MOVE INTO THE STRING.
	TST	R1		;IS QUOTIENT NON-0?
	BNE	20$		;NO
	TST	R2		;CHECK LOW ORDER.
	BEQ	40$		;YES -- LEAVE.
20$:	INC	R4		;GET STRING LENGTH.
	MOV	R4,R3		;SAVE INTO A TEMP.
	ADD	R3,R5		;POINT TO END OF BUFFER.
30$:	MOVB	-1(R5),(R5)	;MOVE IN A BYTE.
	DEC	R5		;POINT TO PREVIOUS BYTE.
	SOB	R3,30$		;AND LOOP.
	BR	10$		;AND CONVERT ANOTHER BYTE.
40$:	ADD	R4,R5		;POINT R5 TO NEXT BYTE.
	MOV	R5,R0		;RETURN IN R0.
	INC	R0		;POINT TO ONE PAST LAST BYTE.
	MOV	(SP)+,R1
	MOV	(SP)+,R2
	MOV	(SP)+,R3
	MOV	(SP)+,R4
	MOV	(SP)+,R5
	RTS	PC

	.SBTTL	GETBLK - GET BLOCK FROM INDEX FILE
;
; THIS SUBROUTINE GETS A BLOCK FROM THE INDEX FILE.
; ON INPUT,
;
;	R0 = BLOCK NUMBER TO RETRIEVE FROM INDEX FILE
;
; ON EXIT,
;
;	R0 = ADDRESS OF BUFFER CONTAINING BLOCK
;
GETBLK:
	MOV	R1,-(SP)	; SAVE R1
	MOV	CURBLK,R1	; GET CURRENT BLOCK
	CMP	R0,R1		; IS THIS < THE CURRENT BLOCK?
	BLO	100$		; J IF SO, MUST READ IN NEW BLOCK.
	ADD	CURCNT,R1	; ADD IN CURRENT NUMBER OF BLOCKS.
	CMP	R0,R1		; IS THIS > THE LAST BLOCK?
	BLO	200$		; J IF NOT, CAN USE IN CORE BUFFER.
100$:	MOV	R0,-(SP)	; SAVE R0 FOR FCS CALL
	MOV	R0,R1		; GET THE BLOCK TO READ.
	ADD	#<INDEND-INDBUF>/1000,R1 ; GET 1+ENDING BLOCK NUMBER.
	CMP	R1,INDEX+F.EFBK+2 ; IS IT TOO LARGE?
	BLOS	150$		; J IF NOT.
	MOV	INDEX+F.EFBK+2,R1 ; GET THE LAST BLOCK NO.
150$:	MOV	R0,CURBLK	; ALSO REMEMBER CURRENT BLOCK NO.
	SUB	R0,R1		; COMPUTE SIZE (IN BLOCKS) OF BUFFER.
	MOV	R1,CURCNT	; REMEMBER IN CURRENT BUFFER SIZE.
	ASH	#9.,R1		; COMPUTE SIZE (IN BYTES) OF BUFFER.
160$:	MOV	(SP),INDEX+F.BKVB+2
	CLR	INDEX+F.BKVB
	READ$	#INDEX,#INDBUF,R1 ; READ IN THE BUFFER.
	BCS	180$		;EOF?
	WAIT$	R0		; WAIT FOR THE READ TO COMPLETE.
	BCS	180$		;EOF?
	MOV	(SP)+,R0	; RECOVER R0
	BR	200$
180$:	CMPB	#IE.EOF,F.ERR(R0) ;EOF?
	BEQ	190$		;YES
185$:	JMP	ERROR
190$:	SUB	#1000,R1	;REDUCE BUFFER SIZE
	DEC	CURCNT
	BEQ	185$		;SIZE NOW 0
	BR 	160$		;SIZE STILL VALID
200$:	SUB	CURBLK,R0	; COMPUTE OFFSET WITHIN BUFFER.
	ASH	#9.,R0		; COMPUTE BYTE OFFSET WITHIN BUFFER.
	ADD	#INDBUF,R0	; ABSOLUTISE ADDRESS OF BLOCK
	MOV	(SP)+,R1	; RECOVER R1
	RETURN			; AND RETURN TO THE CALLER.

	.SBTTL	TYPE MESSAGE TO THE TERMINAL
;
; THIS SUBROUTINE TYPES A MESSAGE TO THE TERMINAL
;
TYPE:	MOV	2(SP),QMSG+Q.IOPL+2 ;LENGTH
	MOV	4(SP),QMSG+Q.IOPL ;BUFFER ADDRESS
	MOV	#QMSG,-(SP)	;DO I/O
	CALL	.DIRDL		;
	BCS	10$		;
	RETURN			;RETURN TO CALLER
10$:	BPT			;ERROR?

	.SBTTL	INDEX FILE BUFFER AREA
;
; THE INDEX FILE IS BUFFERED SEVERAL BLOCKS AT A TIME.
; THIS BUFFER SIZE MAY BE INCREASED BY A TASK BUILD
; EXTENSION OF THE FOLLOWING PSECT.
;
	.PSECT	INDEX1,RW,D
INDBUF:	.BLKB	N.BLK*1000	; SPACE FOR INDEX BLOCKS
	.PSECT	INDEX2,RW,D
INDEND:
	.SBTTL	UIC STORAGE AREA BUFFER AREA
;
; THE DISK USAGE PER UIC IS STORED IN THIS AREA. IT CAN
; BE INCREASED AT TASK BUILD TIME TO ANY VALUE WHICH WILL
; FIT IN THE AVAILABLE TASK IMAGE SPACE, BY EXTENDING THE
; 'UIC1' P-SECTION.
;
	.PSECT	UIC1,RW,D
UIC.UI	=	0
UIC.BL	=	2
UIC.S	=	6
UICAREA:.BLKB	UIC.S*N.UIC	;BUFFER AREA.
	.PSECT	UIC2,RW,D
UICEND:	.BLKB	UIC.S		;EXTRA SPACE IN CASE OF OVERFLOW.
;
	.SBTTL	DATA AREA
	.PSECT	IDATA,RW,D
;
; DATA AREA FOR THE INDEX FILE SCANNER PROGRAM.
;
BUFFER:	.BLKB	132.	;BUFFER FOR MESSAGES.
SPSAVE:	.WORD	0	;SAVE AREA FOR SP
CURBLK:	.WORD	0	;CURRENT BLOCK NO. ON INDEX FILE
CURCNT:	.WORD	0	;CURRENT NUMBER OF BLOCKS IN BUFFER
IOST:	.WORD	0,0	;IO STATUS BLOCK
BITADR:	.WORD	0	;CURRENT BLOCK # OF INDEX FILE BITMAP
CURID:	.WORD	0	;CURRENT FILE ID BEING PROCESSED
BITMAP:	.BLKB	1000	;BITMAP BUFFER AREA
BITEND:			;END OF BITMAP AREA
HOME:	.BLKB	1000	;HOME BLOCK AREA
MAXUIC:	.WORD	0		;MAX ALLOCATED AREA IN BUFFER.
 
	.NLIST	BEX
	.PSECT	PDATA,RO,D
HDRMSG:	.ASCIZ	/DAC -- BAD FILE HEADER FILE /
PTRMSG:	.ASCIZ	/DAC -- BAD RETRIEVAL POINTER /
CHKMSG:	.ASCIZ	/DAC -- HEADER CHECKSUM ERROR FILE /
MAPMSG:	.ASCIZ	/DAC -- BAD MAP OFFSET FILE /
BIDMSG:	.ASCIZ	/DAC -- BAD ID OFFSET FILE /
NIDMSG:	.ASCIZ	/DAC -- SUSPICIOUS ID OFFSET FILE /
NMPMSG:	.ASCIZ	/DAC -- SUSPICIOUS MAP OFFSET FILE /
LEVMSG:	.ASCIZ	/DAC -- ILLEGAL STRUCTURE LEVEL FILE /
BCFMSG:	.ASCIZ	/DAC -- ILLEGAL BLOCK COUNT FILE /
LBNMSG:	.ASCIZ	/DAC -- ILLEGAL LBN SIZE FILE /
MAXMSG:	.ASCIZ	/DAC -- ILLEGAL MAX PTR # FILE /
FNDMSG:	.ASCIZ	/DAC -- BLOCK REFERENCED FILE /
DLKMSG:	.ASCIZ	/DAC -- FILE LOCKED FILE /
DELMSG:	.ASCIZ	/DAC -- FILE MARKED FOR DELETE /
BLKMSG:	.ASCIZ	/DAC -- BAD BLOCK IN FILE /
	.LIST	BEX
 
	.EVEN
 
M.IOR:	MSG	<DAC -- I/O ERROR ON @ FILE>
M.OPR:	MSG	<DAC -- OPEN FAILURE ON @ FILE>
M.BIF:	MSG	<DAC -- SYNTAX ERROR FOR @ FILE>
M.MDE:	MSG	<DAC -- MAX @ FILE DEPTH EXCEEDED>
M.UNK:	MSG	<DAC -- UNKNOWN COMMAND ERROR>
M.PS1:	MSG	<DAC -- SYNTAX ERROR>
M.PS2:	MSG	<DAC -- ILLEGAL SWITCH>
M.BAD:	MSG	<DAC -- ILLEGAL PARAMETERS>
M.BLK:	MSG	<DAC -- NO SUCH BLOCK FOUND>
M.UIC:	MSG	<DAC -- UIC AREA OVERFLOW>
 
BLKPR:	.ASCII	/DAC/
BLKSZ	=	.-BLKPR
	.EVEN
 
 
	.PSECT	IDATA,RW,D
UICFDB:	FDBDF$			;FDB FOR UIC FILE
	FDAT$A	R.VAR,FD.CR
	FDRC$A	,,UIC.S		;USE GET/PUT I/O
	FDOP$A	UICLUN,DFNB	;
	FDBF$A	UICEVF
 
INDEX:	FDBDF$			;FDB FOR INDEX FILE
	FDRC$A	FD.RWM		;USE BLOCK IO
	FDBK$A	,1000,,INDEVF,IOST
	FDOP$A	INDLUN
 
	FSRSZ$	2,2*<S.BFHD+512.>
 
CMLBLK:	GCMLB$	2,DAC,USRBUF,CMDLUN
USRBUF:	.BLKB	82.
	.EVEN
	CSI$
CSIBLK:	.BLKB	C.SIZE
	.EVEN
QMSG:	QIOW$	IO.WVB,MSGLUN,MSGEVF,,IOST,,<0,0,40>
DSPT:	.WORD	DEVLEN,DEVSTR
	.WORD	UICLEN,UICSTR
	.WORD	FILLEN,FILSTR
DEVSTR:	.ASCII	/SY0:/
DEVLEN	=	.-DEVSTR
	.EVEN
UICSTR:	.ASCII	/[0,0]/
UICLEN	=	.-UICSTR
	.EVEN
FILSTR:	.ASCII	/INDEXF.SYS/
FILLEN	=	.-FILSTR
	.EVEN
DFNB:	NMBLK$	ACCLOG,DAC,,SY,0
	.END	BEGIN