.TITLE	BLK -- FIND LOGICAL BLOCKS
	.SBTTL	TITLE PAGE
	.IDENT	-000100-
;+
; 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:/BL:M:N
;
;	WHERE DEV: IS THE DEVICE ON WHICH THE SCAN IS TO BE
;	DONE (DEV: DEFAULTS TO SY:) AND "/BL:M:N" SPECIFIES
;	THE HIGH AND LOW LOGICAL (PHYSICAL) BLOCK NUMBER TO
;	BE SCANNED FOR. BOTH "DEV" AND "/BL:M:N" ARE OPTIONAL,
;	BUT ONE OR THE OTHER MUST BE SPECIFIED. IF "/BL:M:N"
;	IS NOT SPECIFIED, IT DEFAULTS TO "/BL:0:0" (THE BOOT-
;	STRAP BLOCK).
;		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 MUCH MORE STUFF. ALSO, BLK DOES NOT
;	DO ANYTHING ANALOGOUS TO THE "VFY" CONSISTENCY CHECK
;	OR LOST FILE SCAN.
;
; 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
; VERIFIED: 26-MAY-78, -0.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
	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
	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 ;
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
	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	SEE IF REQUESTED BLOCK IS IN THIS FILE
;
; 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.
	CLR	INDEX+F.BKVB	;CLEAR HI ORDER BLOCK
	MOV	R0,INDEX+F.BKVB+2 ;INIT LOW ORDER BLOCK
	READ$	#INDEX,#HEADER,#1000 ;READ DATA
	  ONERR	ERROR
	WAIT$	R0		;
	  ONERR	ERROR
	CMP	R5,HEADER+H.FNUM ;CORRECT FID?
	BEQ	20$		;YES -- NO MESSAGE
	CALL	BADHDR		;NO -- PRINT NASTY MESSAGE
20$:	MOV	#HEADER,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,HEADER+H.FLEV ;CORRECT VERSION?
	BEQ	12$		;NO
	CALL	LEVHDR		;HEADER LEVEL MISMATCH
12$:	MOVB	HEADER+H.IDOF,R0 ;GET ID OFFSET
	ASL	R0
	CMP	R0,#1000-S.IDHD-S.MPHD ;TOO BIG?
	BLO	15$		;NO
	CALL	BIDHDR		;YES
15$:	CMPB	HEADER+H.IDOF,#27 ;'NORMAL' VALUE?
	BEQ	16$		;YES
	CALL	NIDHDR		;NO
16$:	BITB	#UC.DLK,HEADER+H.UCHA ;LOCKED FILE?
	BEQ	21$		;NO
	CALL	DLKHDR		;PRINT MESSAGE
21$:	BITB	#SC.MDL,HEADER+H.SCHA ;MARKED FOR DELETE?
	BEQ	22$		;NO
	CALL	DELHDR		;PRINT MESSAGE
22$:	BITB	#SC.BAD,HEADER+H.SCHA ;BAD BLOCK IN FILE?
	BEQ	23$		;NO
	CALL	BLKHDR		;PRINT MESSAGE
23$:	MOVB	HEADER+H.MPOF,R0 ;GET MAP AREA OFFSET
	ASL	R0		;ADJUST FOR WORDS
	BIC	#^C777,R0
	ADD	#HEADER,R0	;
	MOVB	M.USE(R0),R1	;GET # USED
	BIC	#^C377,R1	;CLEAR HI BYTE
	ASL	R1		;
	ADD	R0,R1		;COMPUTE END OF MAP AREA
	CMP	R1,#HEADER+1000-2-S.MPHD ;OVER TOP?
	BLOS	25$		;HEADER OK
	CALL	MAPHDR		;
	BR	CHECKE		;
25$:	CMPB	HEADER+H.MPOF,#56 ;IS IT NORMAL?
	BEQ	26$		;YES
	CALL	NMPHDR		;NO
26$:	MOVB	M.USE(R0),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(R0)	;OVER MAX # THIS HEADER BLK?
	BLOS	28$		;NO -- OK
27$:	CALL	PTRHDR		;ERROR MESSAGE
28$:	CMPB	M.CTSZ(R0),#1	;SIZE OF BLOCK COUNT UNUSUAL?
	BEQ	C1		;NO
	CALL	BCFHDR		;YES
C1:	CMPB	M.LBSZ(R0),#3	;LOGICAL BLOCK UNUSUAL?
	BEQ	10$		;NO
	CALL	LBNHDR		;YES
10$:	CMPB	M.MAX(R0),#<1000-S.HDHD-S.IDHD-S.MPHD-2>/2
				;MAX # OF POINTERS NORMAL?
	BEQ	20$		;YES
	CALL	MAXHDR		;
20$:	ADD	#M.RTRV,R0	;GET START OF POINTERS
	TST	R4		;0 RETRIEVAL POINTERS?
	BEQ	CHECKE
30$:	MOV	(R0)+,R1	;GET COUNT AND HIGH LBN
	MOV	(R0)+,R2	;GET LOW LBN
	MOV	R1,R3		;GET COUNT INTO R3
	BIC	#^C377,R1	;CLEAR COUNT OUT OF R1
	CLRB	R3		;CLEAR HI LBN OFF R3
	SWAB	R3		;GET COUNT INTO LOW PART OF R3
	CMP	HIBK,R1		;IS SEARCH BLK LOWER THAN LOWEST ADDR?
	BLO	40$		;YES
	BHI	31$		;IGNORE LOW BLOCK IF THIS ONE HIGH
	CMP	LOBK,R2		;LOW ORDER COMPARE
	BLO	40$		;YES
31$:	ADD	R3,R2		;ADD IN LOW ORDER
	ADC	R1		;ADD IT IN TO HIGH ORDER IF ANY
	CMP	HIBK,R1		;IS SEARCH BLK HIGHER THAN HIGHEST?
	BHI	40$		;YES
	BLO	32$		;IGNORE LOW BLOCK IF THIS LOW
	CMP	LOBK,R2		;LOW ORDER COMPARE
	BHI	40$		;YES
32$:	CALL	FOUND		;FOUND A FILE WITH THE BLOCK
40$:	SUB	#2,R4		;DEC WORD COUNT
	BGT	30$		;LOOP IF MORE
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	#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	HEADER+H.FNUM,R1
	CALL	$CBOMG		;BINARY MAGNITUDE
	MOVB	#',,(R0)+
	MOV	HEADER+H.FSEQ,R1
	CALL	$CBOMG		;
	MOVB	#' ,(R0)+
	MOVB	#' ,(R0)+
	MOVB	#'[,(R0)+	;GET UIC
	MOVB	HEADER+H.PROJ,R1
	BIC	#^C377,R1
	CLR	R2
	CALL	$CBOMG		;CONVERT GROUP CODE
	MOVB	#',,(R0)+	;
	MOVB	HEADER+H.PROG,R1
	BIC	#^C377,R1
	CLR	R2
	CALL	$CBOMG
	MOVB	#'],(R0)+
	MOVB	HEADER+H.IDOF,R3 ;GET HEADER ID OFFSET
	ASL	R3		;CONVERT TO BYTES
	ADD	#HEADER,R3	;POINT TO IT
	CLR	R2
	MOV	I.FNAM(R3),R1	;
	CALL	$C5TA
	MOV	I.FNAM+2(R3),R1
	CALL	$C5TA
	MOV	I.FNAM+4(R3),R1
	CALL	$C5TA
10$:	CMPB	-(R0),#' 	;IS IT BLANK?
	BEQ	10$		;YES
	INC	R0		;INC TO NEXT LOCATION.
	MOVB	#'.,(R0)+
	MOV	I.FTYP(R3),R1
	CALL	$C5TA		;GET FILE TYPE
20$:	CMPB	-(R0),#' 	;BLANK?
	BEQ	20$		;YES
	INC	R0		;
	MOV	I.FVER(R3),R1	;GET VERSION #
	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	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	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
HEADER:	.BLKB	1000	;HEADER BLOCK AREA
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$ND
BLKDSC:	CSI$SV	OCTAL,HIBK,2
	CSI$SV	OCTAL,LOBK,2
	CSI$ND
SW.BLK	=	1
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