;	THIS MACRO-11 PROGRAM "FREBLK" FINDS THE CONTIGUOUS FREE BLOCKS
;	ON A DISK AND PRESENTS THE RESULTS IN HISTOGRAM DATA FORMAT
;
;	THE NECESSARY INFORMATION IS OBTAINED FROM THE FILE BITMAP.SYS
;
;	"FREBLK" CALLS 2 FORTRAN SUBROUTINES, "RPR" AND "WNB".  "RPR"
;	ALLOWS THE USER TO SPECIFY THE HISTOGRAM PARAMETERS AND HE
;	CAN ALSO SPECIFIES EITHER DISK UNIT 0 OR UNIT 1 TO BE ACCESSED
;	----IF A NON-EXISTING DISK UNIT IS SPECIFIED, THE TASK
;	     WILL DO NOTHING AND WILL EXIT TO PDS
;
;	"WNB" PRINTS THE HISTOGRAM DATA ON THE TERMINAL
;
;
;	"FREBLK" READS 1 BLOCK OF THE BITMAP FILE AT A TIME,
;	BUILDS UP A PARTIAL SET OF HISTOGRAM DATA EVERY TIME A BLOCK
;	IS READ.  THIS PROCESS IS REPEATED UNTIL ALL THE BLOCKS IN BITMAP.SYS
;	ARE PROCESSED, AT WHICH TIME A COMPLETE SET OF HISTOGRAM DATA
;	IS CONSTRUCTED.  THEN "WNB" TAKES OVER AND PRINTS THE RESULTS
;
;	IN THE BITMAP.SYS FILE, A "0" MEANS THAT THE CORRESPONDING
;	DISK BLOCK IS USED; A "1" MEANS THAT THE CORRESDONING DISK
;	BLOCK IS FREE.	THUS, FOR INSTANCE, 2 ADJACENT "1'S" MEAN THAT 2
;	CONTIGUOUS FREE DISK BLOCKS ARE AVAILABLE.
;
;	THE PROGRAM HAS BEEN SET UP TO ALLOW A MAX. OF 50 CLASS INTERVALS
;
;	IF MORE INTERVALS ARE DESIRED, FOLLOW THIS PROCEDURES:-
;
;	1 - CHANGE THE LINE NITV=50.  TO
;			    NITV=VALUE YOU PREFER. (DECIMAL)
;
;	2 - IN SUBROUTINE "RPR", AT THE LINE WITH STATEMENT #
;	    8888, CHANGE THE VALUE 50 TO WHATEVER VALUE YOU SPECIFIED IN THE
;	    STEP ABOVE
;
;	3 - ASSEMBLE THE PROGRAMS AND RE-BUILD THE TASK
;
;
;
;	THE FILES REQUIRED TO BUILD THE TASK ARE:-
;
;		1 - BM.MAC
;		2 - BMFTN.FTN
;
;
;
;
;-------OPERATING PROCEDURES:-
;
;	1 - ASSEMBLE BM.MAC
;	2 - COMPILE BMFTN.FTN
;	3 - TASK BUILD USING THE OBJECT OUTPUT FILES
;
;
;	THE TASK BM.TSK IS AVAILABLE UNDER THE SAME UIC SO THAT THE USER CAN
;	SKIP THE STEPS ABOVE
;
;-------INPUT REQUIREMENTS:-
;
;	ALL THE USER HAS TO DO IS TO INPUT THE HISTOGRAM PARAMETERS
;	AND DISK UNIT NUMBER(0 OR 1)IN RESPONDING TO PROMPTING
;	MESSAGES PRINTED OUT BY THE PROGRAM
;
;
;-------OUTPUT FORMAT:-
;
;	THE OUTPUT TAKES THE FORM OF THE HISTOGRAM DATA
;	FORMAT, AS FOLLOW:-
;
;	# OF CONTIGUOUS FREE BLOCKS PER HOLE	       FREQUENCY
;	 INITIAL CLASS LIMIT - END CLASS LIMIT		COUNT
;		"			"		  "
;		"			"		  "
;		ETC			ETC		 ETC
;
;
;
;
;	ALBERT LEUNG  30-SEP-76
;
;	MODIFIED:
;
;	M. BLAKE-KNOX	JULY 77		IMPROVE HUMAN ENGINEERING
;					MAKE BM A SUBROUTINE
;					ADD FCS ERROR REPORTING
;					CALCULATE MAXIMUM HOLE SIZE
;					CORRECT BLOCK END HANDLING
;
;
;
        .TITLE  FREBLK
;
;  SPECIFY MACROS USED IN THE PROGRAM
	.MCALL	FDBDF$,FDOP$A,OPEN$R,FDRC$A,FDBK$A,READ$
	.MCALL	CLOSE$,WAIT$
	.MCALL	EXIT$S
;  FILE DESCRIPTOR BLOCK SPECIFICATION.  BLOCK I/O AND READ ONLY
T1:
	FDBDF$
	FDOP$A	1,T2,,FO.RD
	FDRC$A	FD.RWM
	FDBK$A	SPACE,512.
T2:	.WORD  SYL,SY,DIRL,DIR,BYL,BY
;
;	DON'T SEPARATE NEXT TWO LINES
PARMS:	.WORD  SPACE,512.,0		;PARAMETERS TO QIO
VBN:	.WORD  0,0			;ALSO PART OF PARAMETERS TO QIO
;
;
;
SY:	.BLKB  10.			;SPACE TO FILL IN DISK NAME
SYL=	.-SY
;
DIR:    .ASCII  /[0,0]/
DIRL=	.-DIR
;
BY:     .ASCII  /BITMAP.SYS/            ;BITMAP FILE NAME
BYL=	.-BY
;
;
IOCA=	2048.				;1 BLOCK=4096 BITS.  WORST CASE TAKES
					;UP 2048 WORDS IN THE BIN TABLE KBIN.
					;(1 AND 0 ALTERNATE ALL THE WAY)
NITV=	50.
	.EVEN
CVS:	.BLKW  NITV+2			;CLASS LIMIT STABLE
NINT:	.BLKW  NITV			;FREQ VALUES TABLE
HIGH:	.WORD  0			;UPPER BOUND
FLAG:	.WORD  0			;FLAG=1 FOR 1 DETECED.	FLAG=0 FOR 0
					;DETECTED
LBFLAG: .WORD  0			;LBFLAG=1 FOR LAST BIT OF BLOCK=1.
					;CLEAR OTHERWISE
SFLAG:	.WORD  0			;SFLAG=0 TO INDICATE PROCESSING OF 1ST
					;BLOCK
BYCTR:	.WORD  0			;BYTE CTR
BCTR:	.WORD  0			;BLOCK CTR
CT:	.WORD  1			;FOR COUNTING # OF BINS USED IN TABLE
					;KBIN
TEMPF:	.WORD  0			;TO SAVE POINTER OF A CLASS VALUE
TEMPC:	.WORD  0			;TO STORE THE # OF 1'S(LAST SERIES) IN
					;A BLOCK
KNS:	.WORD  0			;TO STORE # OF CLASS INTERVAL
MAXHOL: .WORD  0			;MAXIMUM HOLE SIZE
SPACE:	.BLKB  512.			;BUFFER TO HOLD 1 BLK OF DATA FROM
					;BITMAP.SYS
;
;
PARA:	.BYTE  5,0			;TO PRINT RESULTS. SUBR "WNB"
	.WORD  CVS
	.WORD  INTL
	.WORD  NINT
	.WORD  KNUMI
	.WORD  MAXHOL
;
;
VAL:	.BYTE  6,0			;PARAMETER FOR OBTAINING PARAMETERS.
					;SUBR "RPR"
	.WORD  KSTR
	.WORD  INTL
	.WORD  KEND
	.WORD  KNUMI
	.WORD  SY
	.WORD  T2
;
;
ERRP:	.BYTE  1,0			;PARAMETER LIST FOR FCS ERROR MESSAGE
					;(SUBR ERRPRT)
	.WORD  ERR
;
ERR:	.WORD  0
KSTR:	.WORD  0			;START VALUE
INTL:	.WORD  0			;INTERVAL VALUE
KEND:	.WORD  0			;END VALUE
KNUMI:	.WORD  0			;# OF INTERVAL
KSTRQ:	.WORD  0
;
;
BM::
;
;
;
	MOV  #VAL,R5			;GO GET HISTOGRAM PARAMETER
	JSR  PC,RPR			;SUBROUTINE "RPR"
;
;
D0:
	INC  KNUMI			;CREATE ONE MORE INTERVAL FOR TABLE CVS
	MOV  KNUMI,R2			;THIS IS USEFUL IN BUILDING THE
					;HISTOGRAM DATA
	MOV  #CVS,R0			;SET UP POINTER TO CLASS VALUE TABLE
	MOV  KSTR,KSTRQ 		;SAVE START VALUE
KB:
	MOV  KSTRQ,(R0)+		;CREATE THE CLASS VALUE TABLE
	ADD  INTL,KSTRQ 		;CLASS LIMIT NON-OVERLAPPING
	INC  KSTRQ			;CREATE ANOTHER INITIAL VALUE IN A CLASS
	SOB  R2,KB
	DEC  KNUMI			;REMAKE ORIGINAL # OF INTERVAL
	OPEN$R	#T1,#1,#T2,#FD.RWM,#SPACE,#512.
	BCS  FCSERR			;ERROR
	CLR  LBFLAG
	CLR  SFLAG
	CLR  KBIN			;FIRST BLOCK HAS 0 LENGTH
REPEAT:
	INC  VBN+2			;POINT TO NEXT BLOCK OF THE INDEX FILE
	MOV  #T1,R0			;FDB ADDRESS
	MOV  #IO.RVB,R1 		;READ A BLOCK
	MOV  #5,R2			;5 LOF THEM
	MOV  #PARMS,R3			;PARAMETERS
	CALL  .XQIO			;READ IN THE BLOCK
	BCC  10$			;OK
	CMPB  #IE.EOF,F.ERR(R0) 	;END OF FILE?
	BNE  FCSERR			;GO HANDLE ERROR
	JMP  CLO			;CLOSE FILE AND PRINT RESULTS
10$:
	TST  SFLAG			;SEE IF FIRST BLOCK HAS BEEN PROCESSED
	BEQ  FLW
	JMP  PROB			;YES. THEN PROCESS 2ND, 3RD.....43RD
					;BLOCKS
;
FCSERR:
	MOVB  F.ERR(R0),R1
	MOV  R1,ERR			;NOTE FCS ERROR CODE
	MOV  #ERRP,R5			;PARAMETER LIST
	CALL  ERRPRT			;AND PRINT IDT OUT
	RETURN
FLW:
	INC  SFLAG			;NO. THEN THE 1ST BLOCK IS NOW PROCESSED
;
;CHECK LAST BIT IN THE BLOCK JUST READ IN
;THIS INFORMATION IS USED TO DETERMINE THE # OF CONTIGUOUS
;BLOCK WHEN THE LAST BIT OF THE CURRENT BLOCK AND THE 1ST
;BIT OF NEXT BLOCK ARE BOTH SET
;
TLB:
	MOV  #SPACE+510.,R0		;GET ADDR OF LAST WORD IN THE BLOCK
	BIT  #100000,(R0)		;TEST THE LAST BIT
	BNE  LB1			;THE LAST BIT IS 1
	CLR  LBFLAG			;THE LAST BIT IS 0
AB:
	MOV  #KBIN,R3			;POINTER TO TABLE KBIN WHICH STORES THE 
					;CONTIG. BLOCKS
	MOV  #256.,BYCTR		;SET UP CTR FOR ONE BLOCK OF BYTES
	MOV  #SPACE,R0			;SET UP ADDR PTR TO BUFFER AREA
	MOV  #16.,R2			;SET UP CTR FOR TESTING 1 BYTE
;
;
	CLR  FLAG
GAW:
	MOV  (R0)+,R1			;MOVE IN A BYTE TO R1 FOR BIT TESTING
CHECK:
	ROR  R1 			;SHIFT INTO C BIT
	BCC  CZERO			;"0" DETECTED
	INC  @R3			;"1" DETECTED. THEN INCREMENT THE BIN
	MOV  #1,FLAG			;FLAG=1 FOR "1" DETECTED
TEST:
	SOB  R2,CHECK
	DEC  BYCTR			;DECREMENT THE BYTE COUNTER
	BEQ  HISTOG			;CONSTRUCT HISTOGRAM FOR A BLOCK
	MOV  #16., R2			;SET UP BIT CTR AGAIN
	JMP  GAW
;
;  COME HERE IF 0 IS DETECTED
CZERO:
	TST  FLAG			;WAS THE BIT BEFORE THIS 0 A 1 ?
	BEQ  TEST			;NO IT WAS A 0. DO NOT RECORD ANYTHING
;
;  IF A 0 WAS DETECTED AND FLAG INDICATED THAT THE BIT BEFORE
;  THIS 0 IS A 1, THEN WE HAVE TO STEP TO THE NEXT BIN
	TST  (R3)+			;STEP TO NEXT BIN IN TABLE
	CLR  (R3)			;AND INITIALIZE IT
	INC  CT 			;COUNT # OF BINS USED
	CLR  FLAG
	JMP  TEST
LB1:
	INC  LBFLAG			;LBFLAG=1 FOR A 1 DETECTED IN LAST BIT
					;OF BLOCK
	JMP  AB
;
;
;
;
;  COMPUTE HISTOGRAM DATA
;
;  THE 6 INSTRUCTIONS BELOW ESTABLISH THE LARGEST CLASS LIMIT
;  (UPPER BOUND) FROM DATA ALREADY COMPUTED IN THE CLASS LIMIT
;  TABLE CVS
HISTOG:
	MOV  #CVS-2,R1
	MOV  KNUMI,KNS			;SAVE CONTENT OF KNUMI FOR LATER USE
	ASL  KNS			;2 X OFFSET TO GET PTR TO LAST CVS ENTRY
	ADD  KNS,R1
	MOV  INTL,HIGH
	ADD  @R1,HIGH			;CALCULATE UPPER BOUND OF HISTOGRAM
	MOV  #KBIN,R0			;SET UP POINTER TO BIN TABLE
RSCAN:
	MOV  #NINT-2,R1 		;SET UP POINTER TO FREQ TABLE
	MOV  #CVS,R2			;SET UP POINTER TO CLASS LIMIT TABLE
	CMP  @R0,MAXHOL 		;LARGEST HOLE SO FAR?
	BLOS  10$			;NO
	MOV  @R0,MAXHOL 		;YES, UPDATE
10$:
;
;  EACH ENTRY IN TABLE KBIN IS SCANNED TO SEE IF IT FALLS WITHIN
;  THE RANGE AS SPECIFIED BY THE USER.	IF NOT IT IS REJECTED
;  AND IS NOT ALLOWED TO ALTER THE FREQ TABLE NINT
TR:
	CMP  @R0,KSTR			;START COMPARING TALLY IN KBIN WITH THE 
					;2 BOUND VALUES
	BLO  NEXT			;LESS THAN THE LOWER BOUND
	CMP  @R0,HIGH
	BHI  NEXT			;LARGER THAN THE UPPER BOUND
GT:
	TST  (R2)+			;POINT TO NEXT ENTRY IN TABLE CVS(CLASS 
					;LIMIT)
	TST  (R1)+			;POINT TO NEXT ENTRY IN TABLE
					;NINT(FREQUENCY)
	CMP  @R0,@R2			;COMPARE KBIN ENTRY WITH CLASS ENTRY
	BHIS  GT
	INC  (R1)			;INCREMENT THE APPROPRIATE FREQ ENTRY
					;IN TABLE NINT
NEXT:
	DEC  CT 			;DECREMENT BIN COUNT
	BEQ  FOB			;FINISH ONE BLOCK
	TST  (R0)+			;UPDATE POINTER TO NEXT BIN
	JMP  RSCAN
;
;
;
FOB:
	TST  LBFLAG			;CHECK LAST BIT OF CURRENT BLOCK
	BNE  SAVE			;LAST BIT IS 1
CB:
	MOV  #1,CT
	JMP  REPEAT
CLO:
	CLOSE$	#T1
	JMP  PRT			;HAVING PROCESSED ALL THE BLOCKS, PRINT 
					;RESULTS
;
;
SAVE:
	MOV  R1,TEMPF			;SAVE PTR TO LAST FREQ CLASS
	MOV  @R0,TEMPC			;SAVE TALLY IN THE ABOVE FREQ
	JMP  CB
;
;  TASK WILL EXIT TO PDS AT THIS POINT IF USER SPECIFIED A NON-EXISTING DISK
PRT:
	MOV  #PARA,R5			;PASS PARAMETERS
	JSR  PC,WNB			;JSR TO FORTRAN SUB WNB
	RETURN
;
;
;
;
;  THE FOLLOWING CODES ARE ENTERED AFTER A BLOCK IS READ, EXCEPT THE 1ST
;  BLOCK.  THE CODES CHECK TO SEE IF THE LAST BIT OF THE PREVIOUS BLOCK
;  AND THE 1ST BIT OF THE CURRENT BLOCK ARE BOTH SET.  IF YES, THE
;  APPROPRIATE FREQUENCY COUNT IN THE TABLE NINT HAS TO BE DECREMENTED
;  AND THE CORRESPONDING TALLY HAS TO BE ADDED TO THE COUNT OF THE 1
;  SERIES OF 1'S OF THE CURRENT BLOCK
;
PROB:
	TST  LBFLAG			;CHECK LAST BIT FLAG OF PREVIOUS BLOCK
	BNE  KT 			;THE LAST BIT IS 1
	CLR  KBIN			;SIZE OF HOLE=0
	JMP  TLB
KT:
	BIT  #1,SPACE			;THEN CHECK 1ST BIT OF CURRENT BLK
	BNE  DZ 			;IT IS ALSO A 1
	JMP  TLB
DZ:
	MOV  #SPACE+510.,R3		;CHECK LAST BIT OF CURRENT BLOCK
	BIT  #100000,(R3)
	BEQ  NR 			;LAST BIT IS 0
	INC  LBFLAG			;LAST BIT IS 1
	BR  NL
NR:
	CLR  LBFLAG
NL:
	DEC  @TEMPF			;SUBTRACT 1 FROM APPR. ENTRY IN NINT
					;TABLE
	MOV  TEMPC,KBIN 		;PUT THE COUNT IN 1ST ENTRY OF KBIN
	JMP  AB
;
;
;
KBIN:	.BLKW  IOCA			;DATA AREA
;
;
	.END