.TITLE	BLK -- FIND LOGICAL BLOCKS
	.SBTTL	TITLE PAGE
	.IDENT	-010100-
;+
; ABSTRACT:	BLK
;
;	THIS PROGRAM IS USED TO FIND LOGICAL BLOCKS (PHYSICAL
; BLOCKS) ON A DEVICE. THE IDEA IS TO FIND OUT WHICH FILES
; USE THE SPECIFIED BLOCK SO THAT AN ESTIMATE CAN BE MADE ON
; WHICH FILES MIGHT BE CORRUPTED BY A DISK HARDWARE ERROR.
;
; OPERATING PROCEDURES:
;
;	THIS TASK CAN BE RUN EITHER AS AN MCR COMMAND OR BY
;	SAYING RUN $BLK$. IT PROMPTS WITH
;
;		BLK>
;
;	AND EXPECTS A COMMAND STRING OF THE FORM:
;
;		DEV:/SWITCHES
;
;	WHERE DEV: IS THE DEVICE ON WHICH THE SCAN IS TO BE
;	DONE (DEV: DEFAULTS TO SY:).
;		BLK 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).
;	BLK DOES NOT DO ANYTHING ANALOGOUS TO THE "VFY"
;	CONSISTENCY CHECK OR LOST FILE SCAN.
;
;
; SWITCHES:
;
;	/CK	PRINT OUT INCORRECT FILE CHECKSUMS
;	/BI	USE THE INDEX FILE BITMAP TO DETERMINE
;		WHICH FILES TO EXAMINE.  THIS IS THE
;		DEFAULT, BUT ALL FILE HEADER NUMBERS
;		FROM 1 THROUGH THE NUMBER MAPPED IN
;		THE FILE CAN BE EXAMINED BY /-BI.
;		THIS IS NORMALLY ONLY USEFUL IF THE
;		INDEX FILE HAS BEEN CLOBBERED FOR SOME
;		REASON.
;	/BL:N:M	THE BLOCK NUMBER TO SEARCH FOR.  N IS THE
;		HIGH ORDER 16 BITS OF THE LOGICAL (PHYSICAL)
;		BLOCK NUMBER, AND M IS THE LOW ORDER 16 BITS
;		OF THE BLOCK NUMBER.  THIS SWITCH IS OPTIONAL;
;		IF UNSPECIFIED, IT DEFAULTS TO /BL:0:0 (THE
;		BOOTSTRAP BLOCK).
;
; TASK:		BLK
;
; WRITTEN: 02-MAY-78, -0.0.0-, BRUCE C. WRIGHT
; MODIFIED: 17-MAY-78, -0.0.1-, BRUCE C. WRIGHT
;	CHANGED SO WOULD NOT DEFAULT TO BLOCK 0 IF NO BLOCK SPECIFIED
; MODIFIED: 26-MAY-78, -0.1.0-, BRUCE C. WRIGHT
;	FIXED BUG IN POINTER OFFSET CHECKING LOGIC
; MODIFIED: 23-JUN-80, -1.0.0-, BRUCE C. WRIGHT
;	CHANGED TO USE MULTI-BLOCK I/O
; Modified: 07-May-1981, -1.1.0-, Bruce C. Wright
;	Corrected running off end of file if index file almost full
; Verified: 07-May-1981, -1.1.0-, Bruce C. Wright
;-

	.SBTTL	MACRO CALLS
	.MCALL	QIOW$,WSIG$S,EXIT$S
	.MCALL	OPNS$R,READ$,WAIT$,CLOSE$
	.MCALL	CSI$,CSI$1,CSI$2,CSI$SW,CSI$SV,CSI$ND
	.MCALL	GCML$,GCMLB$
	.MCALL	FDBDF$,FSRSZ$,FDRC$A,FDBK$A,FDOP$A
	.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
 
	.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
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
	MOV	#SW.BI,SWORD	; DEFAULT TO /BI
	CSI$1	#CSIBLK,CMLBLK+G.CMLD+2,CMLBLK+G.CMLD ;
	BCC	10$
	TYPMSG	M.PS1
	BR	BEGIN
10$:	CSI$2	#CSIBLK,OUTPUT,#SWTAB ;
	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.EQU!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	OPEN		;NO
	MOV	CSIBLK+C.DEVD,DSPT ;MOVE IN DEVICE DESC.
	MOV	CSIBLK+C.DEVD+2,DSPT+2

OPEN:	CLR	FNDFLG		;CLEAR BLOCK FOUND FLAG
	MOV	#-1,CURBLK	;SET CURRENT BLOCK POINTER.
	CLR	CURCNT		;AND CURRENT BLOCK COUNT.
	OPNS$R	#INDEX,,#DSPT	;OPEN THE INDEX FILE
	  ONERR	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$	R0,#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	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 ;
	BIT	#SW.BI,SWORD	;USE BITMAP?
	BEQ	300$		; J IF NOT.
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
300$:	MOV	#1,CURID	; START AT BEGINNING.
400$:	MOV	CURID,R5	; GET CURRENT ID NUMBER.
	CALL	CHECK		; CHECK THE FILE ID
	INC	CURID		; INCREMENT TO NEXT ITEM
	MOV	CURID,R5	; GET NEXT ID NUMBER.
	ADD	HOME+H.IBSZ,R5	; GET BITMAP SIZE
	ADD	#2,R5		; ADD IN BASE ADDRESS
	CMP	R5,INDEX+F.EFBK+2 ; OVER TOP OF INDEX FILE?
	BLO	400$		; J IF NOT.
900$:	CLOSE$	#INDEX
	TST	FNDFLG		;ANY FOUND?
	BNE	910$		;YES
	CMP	HIBK,#-1	;HI BLOCK TO BE SEARCHED = -1?
	BNE	905$		;NO
	CMP	LOBK,#-1	;AND LO BLOCK?
	BEQ	910$		;YES
905$:	TYPMSG	M.BLK		;NO -- PRINT MESSAGE
910$:	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
	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
	BIT	#SW.CK,SWORD	;PRINT OUT BAD CHECKSUMS?
	BEQ	10$		; J IF NOT.
	MOV	R0,-(SP)	; SAVE R0
	MOV	R3,R1		; GET CHECKSUM INTO R1
	MOV	#BUFFER,R0	; POINT TO BUFFER.
	MOV	#1,R2		; SHOW NO 0 SUPPRESS.
	CALL	$CBOMG		; CONVERT TO OCTAL.
	SUB	#BUFFER,R0	; GET CHECKSUM.
	TYPE	#BUFFER,R0	; PRINT CHECKSUM.
	MOV	(SP)+,R0	; RECOVER R0
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
	TST	R4		;0 RETRIEVAL POINTERS?
	BEQ	CHECKE
	MOV	R5,-(SP)	; SAVE R5
30$:	MOV	(R1)+,R2	;GET COUNT AND HIGH LBN
	MOV	(R1)+,R3	;GET LOW LBN
	MOV	R2,R5		;GET COUNT INTO R5
	BIC	#^C377,R2	;CLEAR COUNT OUT OF R2
	CLRB	R5		;CLEAR HI LBN OFF R5
	SWAB	R5		;GET COUNT INTO LOW PART OF R5
	CMP	HIBK,R2		;IS SEARCH BLK LOWER THAN LOWEST ADDR?
	BLO	40$		;YES
	BHI	31$		;IGNORE LOW BLOCK IF THIS ONE HIGH
	CMP	LOBK,R3		;LOW ORDER COMPARE
	BLO	40$		;YES
31$:	ADD	R5,R3		;ADD IN LOW ORDER
	ADC	R2		;ADD IT IN TO HIGH ORDER IF ANY
	CMP	HIBK,R2		;IS SEARCH BLK HIGHER THAN HIGHEST?
	BHI	40$		;YES
	BLO	32$		;IGNORE LOW BLOCK IF THIS LOW
	CMP	LOBK,R3		;LOW ORDER COMPARE
	BHI	40$		;YES
32$:	MOV	(SP),R5		; RECOVER R5
	CALL	FOUND		;FOUND A FILE WITH THE BLOCK
40$:	SUB	#2,R4		;DEC WORD COUNT
	BGT	30$		;LOOP IF MORE
	MOV	(SP)+,R5	;RECOVER R5
CHECKE:	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 HAS THE BLOCK
;
;THIS SUBROUTINE NOTES THAT THE FILE HAS THE BLOCK
;
FOUND:	MOV	R0,-(SP)	;SAVE R0
	MOV	R1,-(SP)	;SAVE R1
	MOV	R2,-(SP)	;
	MOV	R3,-(SP)
	MOV	#FNDMSG,R2	;
	INC	FNDFLG		;NOTE AS FOUND.
	JMP	PRTMSG		;PRINT THE MESSAGE
 
	.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


	.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 number.
	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 ; Set the block number.
	clr	index+f.bkvb	; Clear high order block number.
	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$		; And leave.
180$:	cmpb	#ie.eof,f.err(r0) ; End-of-file?
	beq	190$		; J if so.
185$:	jmp	error		; Error if something worse
190$:	sub	#1000,r1	; Reduce buffer size
	dec	curcnt		; Reduce block count
	beq	185$		; Gone to 0, report error.
	br	160$		; And retry the operation.
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	20000		; SPACE FOR 16 INDEX BLOCKS
	.PSECT	INDEX2,RW,D
INDEND:
;
	.SBTTL	DATA AREA
;
; DATA AREA FOR THE INDEX FILE SCANNER PROGRAM.
;
SPSAVE:	.WORD	0	;SAVE AREA FOR SP
IOST:	.WORD	0,0	;IO STATUS BLOCK
BITADR:	.WORD	0	;CURRENT BLOCK # OF INDEX FILE BITMAP
CURID:	.WORD	0	;CURRENT FILE ID BEING PROCESSED
HIBK:	.WORD	-1	;HI ORDER BLOCK TO BE SEARCHED FOR
LOBK:	.WORD	-1	;LOW ORDER BLOCK TO BE SEARCHED FOR
FNDFLG:	.WORD	0	;BLOCK HAS BEEN FOUND
BITMAP:	.BLKB	1000	;BITMAP BUFFER AREA
BITEND:			;END OF BITMAP AREA
CURBLK:	.WORD	0	; CURRENT BLOCK NUMBER
CURCNT:	.WORD	0	; CURRENT BLOCK COUNT
HOME:	.BLKB	1000	;HOME BLOCK AREA
 
	.NLIST	BEX
HDRMSG:	.ASCIZ	/BLK -- BAD FILE HEADER FILE /
PTRMSG:	.ASCIZ	/BLK -- BAD RETRIEVAL POINTER /
CHKMSG:	.ASCIZ	/BLK -- HEADER CHECKSUM ERROR FILE /
MAPMSG:	.ASCIZ	/BLK -- BAD MAP OFFSET FILE /
BIDMSG:	.ASCIZ	/BLK -- BAD ID OFFSET FILE /
NIDMSG:	.ASCIZ	/BLK -- SUSPICIOUS ID OFFSET FILE /
NMPMSG:	.ASCIZ	/BLK -- SUSPICIOUS MAP OFFSET FILE /
LEVMSG:	.ASCIZ	/BLK -- ILLEGAL STRUCTURE LEVEL FILE /
BCFMSG:	.ASCIZ	/BLK -- ILLEGAL BLOCK COUNT FILE /
LBNMSG:	.ASCIZ	/BLK -- ILLEGAL LBN SIZE FILE /
MAXMSG:	.ASCIZ	/BLK -- ILLEGAL MAX PTR # FILE /
FNDMSG:	.ASCIZ	/BLK -- BLOCK REFERENCED FILE /
DLKMSG:	.ASCIZ	/BLK -- FILE LOCKED FILE /
DELMSG:	.ASCIZ	/BLK -- FILE MARKED FOR DELETE /
BLKMSG:	.ASCIZ	/BLK -- BAD BLOCK IN FILE /
	.LIST	BEX
 
	.EVEN
BUFFER:	.BLKB	132.
 
M.IOR:	MSG	<BLK -- I/O ERROR ON @ FILE>
M.OPR:	MSG	<BLK -- OPEN FAILURE ON @ FILE>
M.BIF:	MSG	<BLK -- SYNTAX ERROR FOR @ FILE>
M.MDE:	MSG	<BLK -- MAX @ FILE DEPTH EXCEEDED>
M.UNK:	MSG	<BLK -- UNKNOWN COMMAND ERROR>
M.PS1:	MSG	<BLK -- SYNTAX ERROR>
M.PS2:	MSG	<BLK -- ILLEGAL SWITCH>
M.BAD:	MSG	<BLK -- ILLEGAL PARAMETERS>
M.BLK:	MSG	<BLK -- NO SUCH BLOCK FOUND>
 
BLKPR:	.ASCII	/BLK/
BLKSZ	=	.-BLKPR
	.EVEN
 
 
INDEX:	FDBDF$		;FDB FOR INDEX FILE
	FDRC$A	FD.RWM	;USE BLOCK IO
	FDBK$A	,1000,,INDEVF,IOST
	FDOP$A	INDLUN
	FSRSZ$	1	;NO BLOCKING BUFFERS NEEDED
 
CMLBLK:	GCMLB$	2,BLK,USRBUF,CMDLUN
USRBUF:	.BLKB	82.
	.EVEN
	CSI$
CSIBLK:	.BLKB	C.SIZE
	.EVEN
SWTAB:	CSI$SW	BL,SW.BLK,SWORD,SET,,BLKDSC
	CSI$SW	CK,SW.CK,SWORD,SET,NEG
	CSI$SW	BI,SW.BI,SWORD,SET,NEG
	CSI$ND
BLKDSC:	CSI$SV	OCTAL,HIBK,2
	CSI$SV	OCTAL,LOBK,2
	CSI$ND
SW.BLK	=	000001	;/BL: SWITCH
SW.CK	=	000002	;/CK SWITCH
SW.BI	=	000004	;/BI SWITCH
SWORD:	.WORD
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
	.END	BEGIN