.TITLE	...PMP - PARTITION MAPPING PROGRAM
	.IDENT	/23DEC7/
;
;	PROGRAM NAME	- ...PMP
;
;	SYSTEM/MACHINE	- RSX-11D / PDP-11/45
;
;	AUTHOR		- RICHARD KITTELL, LASL MP-1
;
;	DATE		- FEBRUARY 1975
;
;	TYPE/LANGUAGE	- MCR TASK / MACRO-11
;
;	MODIFICATIONS	- SEPTEMBER 5, 1975: RICHARD KITTELL
;			   UPGRADED TO VERSION 6A OF RSX-11D.
;			  OCTOBER 15, 1975: RICHARD KITTELL
;			   FIXED BUG IN LENGTH DISPLAY.
;			  DECEMBER 8, 1975: RICHARD KITTELL
;			   FIXED BUG CAUSING CRASH OF RSX SYSTEM.
;			  DECEMBER 22, 1975: RICHARD KITTELL
;			   FIXED BUG IN REPORTING LOST CORE.
;			  FEBRUARY 9, 1976: RSK
;			   CHANGED TO USE NEW CALL MACRO, SPLIT UP
;			   INTO PURE AND IMPURE AREAS, AND MADE MU.
;			  MARCH 29, 1977: RSK
;			   ADDED "ALL" PARTITION DISPLAY.
;			  20-MAY-77 (MK)
;			    REMOVE .DATAB MACRO REFERENCE
;			    CALL STANDARD SYSLIB RAD50/ASCII CONVERSION
;			    INSTEAD OF FORTRAN ROUTINES
;			  21-MAY-77 (MK)
;			    RE-DO TASK STRUCTURE
;			    REDUCE TYPEOUT TIME
;			  23-MAY-77 (MK)
;			    DON'T DO HOLE CHECK FOR USER-CONTROLLED
;			    PARTITION
;			  15-DEC-77 (MK)
;			    PRINT 7 DIGITS FOR ADDRESSES AND LENGTHS
;			    TO ALLOW USE ON 11/70 WITH >128K
;			  23-DEC-77 (MK)
;			    HANDLE LINE WITH ALTMODE TERMINATOR CORRECTLY
;
;	BUILD FILE	- PMP/PR/-FP/MU,PMP/CR/-SP=PMP
;			  [1,1]EXEC.STB/SS
;			  /
;			  TASK=...PMP
;			  ASG=TI:1
;			  LIBR=SYSRES:RO
;			  STACK=32
;			  /
;
;
;
;	ABSTRACT	- WILL EXAMINE SYSTEM TABLES AND LISTS, AND WILL,
; FOR A SPECIFIED PARTITION, DISPLAY LOADED TASKS AND HOLES IN THEIR
; RELATIVE POSITIONS, ALONG WITH THE BEGINNING AND END ADDRESSES AND
; LENGTH OF EACH. SGA'S AND MULTI-USER PURE ROOTS ARE ALSO DISPLAYED.
;
;
;
; 1. INTERFACE
;
;   1.1  EXECUTION--
;
;	MCM>PMP	PARNAM
;
;   1.2  INPUT--
;
;	PARNAM	= NAME OF PARTITION TO BE MAPPED, OR "ALL"
;
;   1.3  TERMINATION--
;
;	WILL EXIT WHEN CNTRL-Z IS ENTERED.

; 2. PROGRAM DETAIL
;
;   2.1  MACROS--
;
	.MCALL	QIOW$,DIR$,EXIT$S,GMCR$
	.MCALL	PUSH,POP
;
;   2.2  SYMBOL DEFINTIONS--
;
	EF=24			;EVENT FLAG FOR I/O
	LUN=1			;LUN FOR I/O
	DSW=0			;DIRECTIVE STATUS WORD
	ENTLEN=5		;LENGTH FOR EACH ENTRY IN STORE ARRAY
				; (WORDS)
	ENTS=64.		;# OF ENTRIES IN STORE ARRAY
	PARNAM=GMCR+G.MCRB+4	;NAME BUFFER
	HOLLEN=60002
	NEXHOL=60000
	PDR3=177606
	PAR3=177646
	PR3=140
;
;   2.3  STORAGE ALLOCATION AND INITIALIZATION--
;
	.PSECT	$IDATA,D
QIO:	QIOW$	IO.WVB,LUN,EF,,IOST,,<0,0,40>
	.PSECT	$PDATA,RO,D
ALL:	.RAD50	/ALL/
PROMPT:	.ASCII	/PMP>/
	.PSECT	$IDATA
SAVE:	.BLKW	1
NULL:	.BYTE	0
MCR:	.BYTE	0
PMPALL:	.BYTE	0
HEADER:	.ASCII	/ PARTITION = /
HEDNAM:	.BLKB	6
HEDEND:
LINBUF:	.ASCII	/       /
FWABUF:	.ASCII	/0000000/
	.ASCII	/ /
LWABUF:	.ASCII	/7777777/
	.ASCII	/ /
LENBUF:	.ASCII	/0000000/
LNEND1:
	.ASCII	/ /
FIXBUF:	.ASCII	/     /
LINEND:
	.PSECT	$PDATA
FIXED:	.ASCII	/FIXED/
COM:	.ASCII	/COMM /
LIB:	.ASCII	/LIBR /
LOST:	.ASCII	/LOST /
HOL:	.ASCII	/HOLE /
ROOT:	.ASCII	/PROOT/
	.PSECT	$IDATA
	.NLIST	BEX
NOPAR:	.ASCII	/ NO PARTITION NAMED /
NONAM:	.ASCII	/      /
NOEND:
	.PSECT	$PDATA
NOROOM:	.ASCII	/ NOT ENOUGH ROOM IN STORE ARRAY - REASSEMBLE/
NOREND:
NOTSKS:	.ASCII	/ NO TASKS IN THIS PARTITION/
NOTEND:
KEY:	.ASCII	/ NAME    FBA     LBA    BYTES/
KEYEND:
	.PSECT	$IDATA
BIGBUF:	.ASCII	/ BIGGEST HOLE IS /
BIGNUM:	.ASCII	/0000000/
	.ASCII	/ BYTES/
BIGEND:
	.EVEN
	.LIST	BEX
	.PSECT	$PDATA
LF:	.BYTE	40,15
	.EVEN
	.PSECT	$IDATA
STORE:	.BLKW	ENTS*ENTLEN
RADNAM:	.BLKW	2
PARADD:	0
PARLWA:	0
	.PSECT	$PDATA
BLANK:	.ASCII	/      /
	.PSECT	$IDATA
STORND:	STORE+<2*ENTS*ENTLEN>
IOST:	.BLKW	2
LASFWA:	.WORD	0
	.PSECT	$PDATA
NONAME:	.RAD50	/   /
MCRTSK:	.RAD50	/.../
	.PSECT	$IDATA
GMCR:	GMCR$
BIGLEN:	0

;   2.4  PROGRAM FLOW--
;
;	BLANK OUT PARTITION NAME BUFFER
;
	.PSECT	$CODE1,RO
ENTRY:	MOV	#15,R0		;# OF CHARS
	MOV	#PARNAM,R1	;PARTITION NAME ADDR
10$:	MOVB	#40,(R1)+
	SOB	R0,10$
	MOV	#LINEND-FIXBUF,R0 ;# OF CHARS
	MOV	#FIXBUF,R1
20$:	MOVB	#40,(R1)+	;CLEAR END OF LINE
	SOB	R0,20$
	CLRB	PMPALL		;CLEAR "ALL" FLAG
;
;	GET PARTITION NAME FROM OPERATOR, OR EXIT
;
	TSTB	MCR		;HAVE WE TRIED THE MCR LINE?
	BEQ	GET		;NO
	TSTB	NULL		;WAS MCR LINE NULL?
	BNE	ASK		;YES
	EXIT$S			;NO - EXIT FROM ONE-LINER
GET:	DIR$	#GMCR		;GET MCR BUFFER
	INCB	MCR		;SET FLAG
	SUB	#4,DSW		;IS THIS LINE NULL?
	BGT	GOT		;NO
	INCB	NULL		;YES, SET FLAG
ASK:	MOV	#PROMPT,QIO+Q.IOPL ;PUT OUT PROMPT STRING
	MOV	#4,QIO+Q.IOPL+2
	MOV	#'$,QIO+Q.IOPL+4 ;SET CARRIAGE CONTROL
	DIR$	#QIO
	MOV	#IO.RVB,QIO+Q.IOFN ;SET READ FUNCTION
	MOV	#PARNAM,QIO+Q.IOPL
	MOV	#80.,QIO+Q.IOPL+2
	DIR$	#QIO		;READ A LINE
	MOV	#IO.WVB,QIO+Q.IOFN ;RESTORE WRITE FUNCTION
	MOV	#40,QIO+Q.IOPL+4 ;RESTORE CARRIAGE CONTROL
	CMPB	IOST,#-12	;CNTRL-Z?
	BNE	10$		;NO
	EXIT$S
10$:	TST	IOST+2		;ANY CHARS?
	BEQ	ASK		;NO
;
;	PAD WITH BLANKS
;
	.ENABL	LSB
GOT:	MOV	#6,R1		;# OF CHARS
	CLR	R2		;INDEX
20$:	CMPB	#15,PARNAM(R2)	;IS THIS CHAR A CR?
	BEQ	25$		;YES
	CMPB	#33,PARNAM(R2)	;HOW ABOUT ALTMODE?
	BNE	30$		;NO
25$:	MOVB	#40,PARNAM(R2)	;YES, MAKE IT A BLANK
	INC	R2
	SOB	R1,25$
	BR	40$
30$:	INC	R2		;NEXT CHAR
	SOB	R1,20$
;
;	CONVERT ASCII PARTITION NAME TO RAD50
;
40$:	MOV	#PARNAM,R0	;POINT TO NAME BUFFER
	MOV	PC,R1		;SET R1.NE.0 (DOT IS RAD50 CHAR)
	CALL	$CAT5		;CONVERT 3 CHARS
	MOV	R1,RADNAM	;STORE
	MOV	PC,R1
	CALL	$CAT5		;CONVERT 3 CHARS
	MOV	R1,RADNAM+2	;STORE
;
;	CHECK FOR "ALL" REQUEST
;
	CMP	RADNAM,ALL	;ARE 1ST 3 CHARS "ALL"?
	BNE	42$		;NO, PROCESS PARTITION NAME
	TST	RADNAM+2	;ARE LAST 3 CHARS BLANK?
	BNE	42$		;BRANCH IF NOT
	INCB	PMPALL		;SET "ALL" FLAG
;
;	SEARCH TPD FOR THIS NAME
;
42$:
	MOV	.TPDBA,R0	;TPD BASE ADDRESS
50$:
	TSTB	PMPALL		;ARE WE DOING AN "ALL"?
	BEQ	52$		;BRANCH IF NOT AND TEST NAME
	MOV	R0,R3		;SAVE R0
	MOV	#PARNAM,R0	;POINT TO NAME BUFFER
	MOV	(R3),R1		;GET 1ST HALF OF RAD50 NAME
	CALL	$C5TA		;CONVERT TO ASCII
	MOV	2(R3),R1	;GET 2ND HALF
	CALL	$C5TA		;CONVERT TO ASCII
	MOV	R3,R0		;RESTORE R0
	CALL	DOPAR		;DO THE PARTITION
	BR	60$		;GET NEXT PARTITION
52$:
	CMP	(R0),RADNAM	;DOES 1ST HALF MATCH?
	BNE	60$		;NO
	CMP	2(R0),RADNAM+2	;DOES 2ND HALF MATCH?
	BNE	60$		;NO
	CALL	DOPAR		;YES - DO THE PARTITION
	BR	80$		;ALL DONE
60$:	ADD	#T.SZ,R0	;LENGTH OF TPD ENTRY
	CMP	R0,.TPDEA	;ANY MORE ENTRIES?
	BLO	50$		;YES
	TSTB	PMPALL		;ARE WE PROCESSING "ALL"?
	BNE	80$		;YES - SKIP THE NASTY MESSAGE
;
;	SPECIFIED PARTITION NOT IN TPD
;
	MOV	#6,R0		;PUT PARTITION NAME IN MSG BUFFER
	MOV	#PARNAM,R1
	MOV	#NONAM,R2
70$:	MOVB	(R1)+,(R2)+
	SOB	R0,70$
	MOV	#NOPAR,QIO+Q.IOPL
	MOV	#NOEND-NOPAR,QIO+Q.IOPL+2
	DIR$	#QIO
80$:	JMP	ENTRY
	.DSABL	LSB

; DO A PARTITION
;
; THIS CODE HAS BEEN MADE INTO A SUBROUTINE TO IMPROVE THE TASK
; STRUCTURE.
;
; INPUT:
;	R0:	TPD ENTRY ADDRESS
;
;	CALL	DOPAR
;
;	R0 IS PRESERVED
;	ALL OTHER REGISTERS DESTROYED
;
;	SAVE THE TPD ENTRY ADDRESS FOR THIS PARTITION AND INITIALIZE
;
DOPAR:	MOV	R0,PARADD
	MOV	#QIO+Q.IOPL,R0
	MOV	#LF,(R0)	;SKIP A LINE
	MOV	#2,2(R0)
	DIR$	#QIO
	MOV	#6,R1		;MOVE PARTITION NAME TO MSG BUFFER
	MOV	#PARNAM,R2
	MOV	#HEDNAM,R3
72$:	MOVB	(R2)+,(R3)+
	SOB	R1,72$
	MOV	#HEADER,(R0)	;WRITE HEADER
	MOV	#HEDEND-HEADER,2(R0)
	DIR$	#QIO
	MOV	#LF,(R0)	;SKIP ANOTHER LINE
	MOV	#2,2(R0)
	DIR$	#QIO
	MOV	#KEY,@R0
	MOV	#KEYEND-KEY,2(R0)
	DIR$	#QIO
	MOV	#6,R1		;MOVE PARTITION NAME TO MSG BUFFER
	MOV	#PARNAM,R2
	MOV	#LINBUF,R3
73$:	MOVB	(R2)+,(R3)+
	SOB	R1,73$
	MOV	PARADD,R3	;START OF TPD ENTRY FOR THIS PARTITION
	MOV	T.BA(R3),R1	;PARTITION BASE ADDRESS
	MOV	R1,R4		;SAVE FWA
	MOV	#FWABUF,R2
	MOV	#5,R0
	CALL	BIN2O		;PUT ASCII CHARS IN BUFFER
	MOV	T.PZ(R3),R1	;PARTITION SIZE
	MOV	R1,R3		;SAVE LENGTH
	MOV	#LENBUF,R2
	MOV	#5,R0
	CALL	BIN2O		;PUT ASCII CHARS IN BUFFER
	MOV	R3,R1		;TAKE THE LENGTH...
	ADD	R4,R1		;ADD THE BASE ADDRESS...
	DEC	R1		;AND SUBTRACT 1 FOR THE LWA
	MOV	R1,PARLWA
	MOV	#LWABUF,R2
	MOV	#5,R0
	CALL	BIN2O
	MOV	#LINBUF,QIO+Q.IOPL
	MOV	#LNEND1-LINBUF,QIO+Q.IOPL+2
	DIR$	#QIO
	MOV	#LF,QIO+Q.IOPL
	MOV	#2,QIO+Q.IOPL+2
	DIR$	#QIO

;	DISABLE TASK SWITCHING, AND FIND EVERYTHING THAT IS USING
;	 MEMORY IN THIS PARTITION (THAT THE SYSTEM KNOWS ABOUT). ALSO
;	 FIND THE HOLES THAT THE SYSTEM KNOWS ABOUT. FOR EACH, SAVE:
;
;	(1)	LOAD ADDRESS
;	(2)	LENGTH
;	(3)	STATUS CODE:
;		 0 = ACTIVE TASK
;		 1 = FIXED TASK
;		 2 = LIBRARY
;		 3 = COMMON
;		 4 = HOLE
;		 5 = PURE ROOT OF MULTI-USER TASK
;	(4)	NAME (2 WORDS)
;
	MOV	#STORE,R0	;BEGINNING OF STORAGE TABLE
	MOV	#.ATLLH,R1	;ATL LIST HEAD
	MOV	#STORE+<ENTS*ENTLEN*2>,STORND ;TABLE LIMIT
	CALL	SDSABL		;DISABLE TASK SWITCHING
ATLOOP:	MOV	2(R1),R1	;;GET NEXT ATL ENTRY
	CMP	R1,#.ATLLH	;;OUT OF ENTRIES?
	BEQ	FIXCK		;;YES
	CMP	A.PD(R1),PARADD ;; IS THIS TASK RUNNING IN THE PARTITION
				;;   WE ARE MAPPING?
	BNE	ATLOOP		;;NO
	CMP	R0,STORND	;;DO WE HAVE ROOM IN THE STORE ARRAY?
	BLO	OK		;;YES
NORM:	CALL	SENABL		;ENABLE TASK SWITCHING
	MOV	#NOROOM,QIO+Q.IOPL ;WRITE MESSAGE
	MOV	#NOREND-NOROOM,QIO+Q.IOPL+2 
	DIR$	#QIO		
	JMP	DOPRND		
OK:	MOV	A.HA(R1),(R0)+	;;SAVE LOAD ADDRESS
	MOV	A.TD(R1),R2	;;STD POINTER
	MOV	S.TZ(R2),(R0)+	;;SAVE TASK SIZE
	CLR	R3		;;ACTIVE TASK CODE
	BIT	#SF.FX,S.FW(R2)	;;IS THIS TASK FIXED?
	BEQ	20$		;;NO
	MOV	#1,R3		;;FIXED TASK CODE
20$:	MOV	R3,(R0)+	;;SAVE STATUS
	MOV	S.TN(R2),(R0)+	;;SAVE 1ST HALF OF NAME
	CALL	TI		;;DISPLAY TI # OF MCR TASK
	MOV	S.TN+2(R2),(R0)+ ;;SAVE 2ND HALF OF NAME
	CALL	ROOTCK		;;CHECK FOR PURE ROOT
	BR	ATLOOP		;;
FIXCK:	MOV	#.FTLLH,R1	;;FIXED TASK LIST HEAD
10$:	MOV	2(R1),R1	;;GET NEXT ENTRY
	CMP	R1,#.FTLLH	;;ARE WE AT END OF LIST?
	BEQ	GCDCK		;;YES
	CMP	A.PD(R1),PARADD ;;IS THIS TASK FIXED IN OUR PARTITION?
	BNE	10$		;;NO
	CMP	R0,STORND	;;DO WE HAVE ROOM?
	BHIS	NORM		;;NO
	MOV	A.HA(R1),(R0)+	;;SAVE LOAD ADDR
	MOV	A.TD(R1),R2	;;STD ADDR
	MOV	S.TZ(R2),(R0)+	;;TASK SIZE
	MOV	#1,(R0)+	;;FIXED TASK CODE
	MOV	S.TN(R2),(R0)+	;;1ST HALF OF TASK NAME
	CALL	TI		;;DISPLAY TI # OF MCR TASK
	MOV	S.TN+2(R2),(R0)+ ;;2ND HALF OF TASK NAME
	CALL	ROOTCK		;;CHECK FOR PURE ROOT
	BR	10$		;;GO TILL END OF LIST
GCDCK:	MOV	#.GCDLH,R1	;;GLOBAL COMMON DIRECTORY LIST HEAD
10$:	MOV	2(R1),R1	;;GET NEXT ENTRY
	CMP	R1,#.GCDLH	;;ARE WE AT END OF LIST?
	BEQ	HOLCK		;;YES
	TSTB	G.GS(R1)	;;IS THIS SGA IN USE?
	BEQ	10$		;;NO
	CMP	G.PD(R1),PARADD	;;IS THE SGA LOADED IN OUR PARTITION?
	BNE	10$		;;NO
	CMP	R0,STORND	;;DO WE HAVE ROOM?
	BHIS	NORM		;;NO
	MOV	G.BA(R1),(R0)+	;;SAVE LOAD ADDR
	MOV	G.CZ(R1),(R0)+	;;SAVE SGA SIZE
	MOV	#2,R3		;;LIBRARY CODE
	BITB	#GF.LI,G.FB(R1)	;;IS IT A LIBRARY?
	BNE	20$		;;YES
	MOV	#3,R3		;;COMMON CODE
20$:	MOV	R3,(R0)+	;;SAVE STATUS CODE
	MOV	G.BN(R1),(R0)+	;;SAVE 1ST HALF OF NAME
	MOV	G.BN+2(R1),(R0)+ ;;SAVE 2ND HALF OF NAME
	BR	10$		;;GO TILL DONE WITH GCD
HOLCK:	MOV	PARADD,R1	;;ADDR OF TPD
	BIT	#TF.UC,T.FW(R1)	;;USER-CONTROLLED PARTITION?
	BNE	PROCES		;;YES - DON'T LOOK FOR HOLES
	MOV	T.HP(R1),R1	;;POINTER TO HOLE
	BEQ	PROCES		;;IF NO HOLES IN PARTITION
	MOV	#2,@#PDR3	;;READ ONLY ACCESS TO HOLE CHAIN
10$:	CMP	R0,STORND	;;DO WE HAVE ROOM FOR ANOTHER?
	BHIS	NORM		;;NO
	MOV	R1,@#PAR3	;;BASE ADDR
	MOV	R1,(R0)+	;;SAVE BASE ADDR
	MOV	@#HOLLEN,(R0)+	;;SAVE HOLE LENGTH
	MOV	#4,(R0)+	;;SAVE HOLE STATUS CODE
	MOV	NONAME,(R0)+	;;SAVE BLANK NAME
	MOV	NONAME,(R0)+
	MOV	@#NEXHOL,R1	;;BASE ADDR OF NEXT HOLE
	BNE	10$		;;GET IT IF THERE IS ONE

;	WE'VE GOT THE VOLITILE DATA; RE-ENABLE TASK SWITCHING AND
; START PROCESSING ENTRIES
;
PROCES:	CALL	SENABL		;RE-ENABLE TASK SWITCHING
	MOV	R0,STORND	;SAVE LAST STORE ENTRY ADDR
;
; SORT ENTRIES INTO ASCENDING ORDER OF FWA (BUBBLE SORT METHOD)
;
SORT:	CMP	#STORE,STORND	;DO WE HAVE ANY ENTRIES TO SORT?
	BLO	PASS		;YES, GO TO IT
	MOV	#QIO+Q.IOPL,R0	;WRITE MESSAGE AND TRY AGAIN
	MOV	#LF,@R0
	MOV	#2,2(R0)
	DIR$	#QIO		;SKIP A LINE
	MOV	#NOTSKS,@R0
	MOV	#NOTEND-NOTSKS,2(R0)
	DIR$	#QIO		;WRITE MESSAGE
	JMP	DOPRND		;THAT'S ALL FOR THIS GUY
PASS:	CLR	R0		;"WE'VE DONE A SWITCH" FLAG
	MOV	#STORE,R2	;SECONDARY ADDR
20$:	MOV	R2,R1		;NEXT PRIMARY
	ADD	#ENTLEN*2,R2	;NEXT SECONDARY
30$:	CMP	R2,STORND	;ARE WE AT THE END?
	BEQ	CKPASS		;YES
	CMP	@R1,@R2		;IS THE SECONDARY BIGGER OR SAME?
	BLOS	20$		;YES, MOVE ON
	.REPT	ENTLEN
	MOV	(R1),-(SP)	;SWITCH PRIMARY AND SECONDARY
	MOV	(R2),(R1)+
	MOV	(SP)+,(R2)+
	.ENDR
	INC	R0		;SET FLAG
	BR	30$		;MOVE ON
CKPASS:	TST	R0		;DID WE SWITCH ON THE LAST PASS?
	BNE	PASS		;YES, MAKE ANOTHER PASS

;	FOR EACH ENTRY, WE HAVE THE VITAL STATS.
; NOW WE GO THROUGH THE ENTRIES, AND WHENEVER
; A ENTRY'S FWA IS GREATER THAN THE PREVIOUS ENTRY'S LWA+1, WE'VE GOT A
; HOLE, AND WE CAN COMPUTE IT'S SIZE.
;
PRE:	CLR	BIGLEN		;TO FIND BIGGEST HOLE
	CLR	LASFWA		;TO SKIP DUPLICATES
	MOV	PARADD,R0	;USE PARTITION FWA-1 AS LWA
	MOV	T.BA(R0),R0
	DEC	R0
	MOV	#STORE-<ENTLEN*2>,R1 ;ENTRY POINTER
DURING:	ADD	#ENTLEN*2,R1	;NEXT ENTRY
	CMP	R1,STORND	;ARE WE OUT OF ENTRIES?
	BEQ	POST		;YES
RETRY:	MOV	@R1,R2		;FWA OF ENTRY TO R2
	CMP	LASFWA,R2	;HAVE WE ALREADY HAD THIS ENTRY?
	BEQ	DURING		;YES
	DEC	R2		;SUBTRACT 1
	CMP	R0,R2		;CONTIGUOUS?
	BNE	10$		;NO
	MOV	@R1,LASFWA	;SAVE FWA
	CALL	TASK		;YES
	BR	DURING
10$:	CALL	HOLE
	BR	RETRY
POST:	CMP	R0,PARLWA	;ARE WE AT END OF PARTITION?
	BEQ	10$
	MOV	PARLWA,@R1	;FOOL HOLE TO THINK JUST ANOTHER HOLE
	INC	@R1
	CALL	HOLE
10$:	MOV	#LF,QIO+Q.IOPL
	MOV	#2,QIO+Q.IOPL+2
	DIR$	#QIO
	TST	BIGLEN		;ANY HOLES IN THIS PARTITION?
	BEQ	20$		;NO
	MOV	#5,R0		;PRINT THE SIZE OF THE BIGGEST HOLE
	MOV	BIGLEN,R1
	MOV	#BIGNUM,R2
	CALL	BIN2O
	MOV	#BIGBUF,QIO+Q.IOPL
	MOV	#BIGEND-BIGBUF,QIO+Q.IOPL+2
	DIR$	#QIO
20$:	MOV	#LF,QIO+Q.IOPL
	MOV	#2,QIO+Q.IOPL+2
	DIR$	#QIO
	DIR$	#QIO
DOPRND:	MOV	PARADD,R0	;RESTORE R0
	RETURN

; INTERNAL SUBROUTINES
;
;
;	WE'VE GOT A TASK, PRINT THE INFORMATION
;
TASK:	PUSH	R1		;SAVE THE ENTRY POINTER
	MOV	#LINBUF,R0	;ADDR OF BUFFER
	MOV	6(R1),R1	;1ST HALF OF RAD50 NAME
	CALL	$C5TA		;CONVERT TO ASCII
	MOV	(SP),R1		;ENTRY POINTER
	MOV	10(R1),R1	;2ND HALF OF RAD50 NAME
	CALL	$C5TA		;CONVERT TO ASCII
	POP	R3		;ENTRY POINTER
	MOV	#5,R0		;NUMBER OF CHARS TO CONVERT
	MOV	@R3,R1		;FWA
	MOV	#FWABUF,R2	;BUFFER ADDRESS
	CALL	BIN2O		;PUT FWA IN BUFFER
	MOV	#5,R0
	MOV	2(R3),R1	;LENGTH
	CMP	#4,4(R3)	;IS THIS ENTRY A HOLE?
	BNE	60$		;NO
	CMP	R1,BIGLEN	;IS THIS THE BIGGEST HOLE?
	BLE	60$		;NO
	MOV	R1,BIGLEN	;SAVE LENGTH
60$:	MOV	R1,R4		;SAVE TASK SIZE
	MOV	#LENBUF,R2
	CALL	BIN2O
	MOV	#5,R0
	MOV	R4,R1		;TASK SIZE
	ADD	@R3,R1		;ADD THE FWA
	DEC	R1		;SUBTRACT 1 FOR THE LWA
	MOV	R1,R4		;SAVE LWA
	MOV	#LWABUF,R2
	CALL	BIN2O
	MOV	#LNEND1-LINBUF,QIO+Q.IOPL+2 ;SET UP FOR SHORT LINE
	TST	4(R3)		;IS STATUS = ACTIVE TASK?
	BEQ	7$		;YES
	MOV	#LINEND-LINBUF,QIO+Q.IOPL+2 ;SET UP FOR FULL LINE
	CMP	#1,4(R3)	;IS STATUS = FIXED TASK?
	BNE	1$		;NO
	MOV	#FIXED,R1
	BR	5$
1$:	CMP	#2,4(R3)	;IS STATUS = LIBRARY?
	BNE	2$		;NO
	MOV	#LIB,R1
	BR	5$
2$:	CMP	#3,4(R3)	;IS STATUS = COMMON?
	BNE	3$
	MOV	#COM,R1
	BR	5$
3$:	CMP	#4,4(R3)	;IS STATUS = HOLE?
	BNE	4$		;NO
	MOV	#HOL,R1
	BR	5$
4$:	MOV	#ROOT,R1
5$:	MOV	#5,R0
	MOV	#FIXBUF,R2
6$:	MOVB	(R1)+,(R2)+
	SOB	R0,6$
7$:	MOV	#LINBUF,QIO+Q.IOPL
	DIR$	#QIO
	MOV	R4,R0		;NEW LWA
	MOV	R3,R1		;RESTORE ENTRY POINTER
10$:	RETURN

;	WE'VE GOT A HOLE, FIGURE OUT IT'S LIMITS AND PRINT THEM
;
HOLE:	INC	R0		;FWA OF HOLE
	MOV	@R1,R3		;FWA OF NEXT TASK
	MOV	R3,R4
	SUB	R0,R4		;LENGTH OF HOLE
	DEC	R3		;LWA OF HOLE
	PUSH	<R1,R3>
	MOV	R0,R1
	MOV	#6,R0		;BLANK THE NAME BUFFER
	MOV	#BLANK,R2
	MOV	#LINBUF,R5
10$:	MOVB	(R2)+,(R5)+
	SOB	R0,10$
	MOV	#5,R0		;PUT FWA INTO BUFFER
	MOV	#FWABUF,R2
	CALL	BIN2O
	MOV	#5,R0
	MOV	R4,R1		;LENGTH
	MOV	#LENBUF,R2
	CALL	BIN2O
	MOV	#5,R0
	MOV	R3,R1		;LWA
	MOV	#LWABUF,R2
	CALL	BIN2O
	MOV	#LOST,R0
	MOV	#FIXBUF,R1
	MOV	#5,R2
20$:	MOVB	(R0)+,(R1)+
	SOB	R2,20$
	MOV	#LINBUF,QIO+Q.IOPL
	MOV	#LINEND-LINBUF,QIO+Q.IOPL+2
	DIR$	#QIO
	POP	<R0,R1>		;SET LWA AND RESTORE POINTER
	RETURN

;	R2 = ADDR OF STD ENTRY, CHECK FOR PURE ROOT
;
ROOTCK:	PUSH	R2
	MOV	#3,R3		;;NORMAL LIMIT IS 3 SGA'S
	BIT	#SF.24,S.FW(R2)	;;IS STD NODE EXTENDED?
	BEQ	9$		;;NO
	MOV	#7,R3		;;YES -- WE CAN HAVE 7 SGA'S
9$:	ADD	#S.GC,R2	;;POINT TO SGA POINTERS
10$:	MOV	(R2)+,R4	;;POINT TO SGA NODE
	BEQ	20$		;;NO MORE SGA'S
	TST	(R4)		;;IS THIS A ROOT (NO FWD POINTER)?
	BNE	19$		;;NO
	TSTB	G.GS(R4)	;;IS ROOT IN USE?
	BEQ	19$		;;NO
	CMP	R0,STORND	;;DO WE HAVE ROOM?
	BLO	15$		;;YES
	CMP	(SP)+,(SP)+	;;NO - KEEP STACK IN SYNC
	JMP	NORM
15$:	MOV	G.BA(R4),(R0)+	;;SAVE LOAD ADDR
	MOV	G.CZ(R4),(R0)+	;;SAVE LENGTH
	MOV	#5,(R0)+	;;SET TYPE (PROOT)
	MOV	(SP),R4		;;GET STD NODE ADDR
	MOV	S.TN(R4),(R0)+	;;SAVE TASK NAME
	MOV	S.TN+2(R4),(R0)+
19$:	SOB	R3,10$		;;TRY ANOTHER SGA POINTER
20$:	POP	R2		;;THAT'S ALL
	RETURN
;
;	IF THE TASK IS AN MCR TASK (...NAM), REPLACE THE MIDDLE DOT
;	 WITH THE TI NUMBER
;
TI:	CMP	-2(R0),MCRTSK	;;IS 1ST HALF OF NAME ...?
	BNE	10$		;;NO
	MOV	A.TI(R1),R5	;;ADDR OF TI PUD
	MOVB	U.UN(R5),R5	;;UNIT NUMBER
	CMP	R5,#10		;;2 DIGITS?
	BLT	5$		;;NO
	MOV	R5,R4		;;YES
	BIC	#177707,R4	;;MSAK TO HIGH DIGIT
	ASL	R4
	ASL	R4
	ADD	R4,R5		;;FORM 50*HIGH+LOW
	ADD	#120,R5		;;OFFSET FROM PERIOD TO HIGH DIGIT
5$:	ADD	#2,R5		;;OFFSET FROM PERIOD TO LOW DIGIT
	MUL	#50,R5		;;TIMES FIFTY
	ADD	R5,-2(R0)	;;PUT RAD50 UNIT NUMBER INTO NAME
10$:	RETURN
;
;BIN2O:  CONVERT ONE WORD TO OCTAL CHARACTERS
;	YES, IT'S A STUPID WAY TO DO IT
;CALLING SEQUENCE:
;	R0 -- CHARACTER COUNT
;	R1 -- DATA WORD
;	R2 -- OUTPUT BUFFER POINTER
;
;
BIN2O:	PUSH	<R3,R4,R5>	;SAVE WORKING REGISTERS
	MOV	R0,R3	;COPY CHARACTER COUNT
	MOV	R1,R5	;SET DATA WORD IN DIVIDE REGISTER
20$:	CLR	R4	;CLEAR HIGH ORDER DIVIDEND
	DIV	#10,R4	;DIVIDE OUT THE DIGIT
	ADD	#60,R5	;MAKE REMAINDER INTO A CHARACTER
	PUSH	R5	;SAVE THE DIGIT
	MOV	R4,R5
	SOB	R3,20$
30$:	MOVB	(SP)+,(R2)+	;RETURN DIGITS TO USER
	SOB	R0,30$
	POP	<R5,R4,R3>	;RESTORE THOSE REGISTERS
	RETURN
;
;	CALL SENABL - TO ENABLE TASK SWICTHING
;	CALL SDSABL - TO DISABLE TASK SWITCHING
;
;
;
SENABL:
	TST	SAVE		;;HAS STATUS BEEN SAVED BY CALL TO 
				;; SDSABL?
	BEQ	RETURN		;;NO, RETURN
	PUSH	SAVE		;;PUT OLD STATUS ON STACK
	CLR	SAVE		;;ZERO SAVE TO PREVENT RE-ENABLE
	CALL	..ENB0		;REENABLE TASK SWITCHING
	BR	RETURN
;
;
SDSABL:
	MOV	@#PS.EXP,SAVE		;SAVE CURRENT PROCESSOR STATUS
	BIS	#140,@#PS.EXP		;;DISABLE TASK SWITCHING
;
;
RETURN:	RETURN
	.END	ENTRY