.TITLE	MDPAGE
	.IDENT	/V01.03/
;
; COPYRIGHT (C) 1978
; DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS.
;
;         

; VERSION:	1.03
; AUTHOR:	ALAN GROUPE
; DATE:		8-DEC-78
;
; MODIFICATIONS:
;
;	8-FEB-80 ALAN GROUPE
;	AG039A	SKIP FIRST PCB IF RESIDENT LOADER
;
; THIS SEGMENT CONTAINS THE DYNAMIC (LOOPING) CODE FOR THE MEMORY DISPLAY
; PAGE OF RMDEMO.


; LOCAL MACRO DEFINITIONS

	.MACRO	FLAG,DD
	BISB	#200,DD
	.ENDM

	.MACRO	CHECK,DD
	BITB	#200,DD
	.ENDM

	.MACRO	MVN,FROM,TO,LEN,?A,?B	; MOVE NEW CHARS ONTO SCREEN
	MOV	#LEN,R0		; LENGTH OF STRING
	MOV	FROM,R1	; SENDING STRING
	MOV	TO,R2		; ADDRESS OF POSITION IN SCREEN BUFFER
A:	CMPB	(R1)+,(R2)+	; CHARACTER CHANGED
	BEQ	B		; NO
	MOVB	-1(R1),-1(R2)	; YES, MOVE IT IN
	FLAG	-1(R2)		; AND FLAG IT AS CHANGED
B:	SOB	R0,A
	.ENDM

	.MACRO	OUTC	FROM,TO,?A	; MOVE A CHAR TO SCREEN
	CMPB	FROM,TO		; NEW CHAR
	BEQ	A		; NO
	MOVB	FROM,TO
	FLAG	TO
A:
	.ENDM

	.MCALL	PCBDF$,HDRDF$,F11DF$,TCBDF$,UCBDF$,DCBDF$,HWDDF$,GTIM$S
	PCBDF$
	HDRDF$
	F11DF$
	TCBDF$
	UCBDF$
	DCBDF$
	HWDDF$


	.PAGE
	.SBTTL	LOCAL DATA
	.PSECT	OFFSET,ABS
TASKS:	.BLKW	8.		; LIST OF TASK NAMES ON 4 CPUS
CPLRG:	.BLKW	1		; LARGEST BLOCK IN CURRENT POOL
CPTOT:	.BLKW	1		; TOTAL POOL CURRENTLY AVAILABLE
CPFRG:	.BLKW	1		; NUMBER OF FRAGMENTS CURRENTLY IN POOL
	.BLKW	1		; HIGH ORDER TIME
ABTIM:	.BLKW	1		; LOW ORDER TIME
FREE:	.BLKW	8.		; 4 DOUBLE PRECISION FREE BLOCK COUNTS
INN:	.BLKW	1		; NUMBER OF TASKS IN MEMORY
OUTN:	.BLKW	1		; NUMBER OF TASKS CHECKPOINTED
INM:	.BLKW	1		; AMOUNT OF MEMORY USED BY TASKS IN MEMORY
OUTM:	.BLKW	1		; AMOUNT OF MEMORY USED BY CHECKPOINTED TASKS
ERRORS:	.BLKW	1		; NUMBER OF ERRORS
PARSTR:	.BLKW	1		; ADDRESS OF FIRST PARTITION
PARLST:	.BLKW	485.		; LIST OF SUBPARTION ID'S
	.PSECT	PAGE,OVR,I,LCL

	.WORD	UPDATE		; ENTRY ADDRESS, FIRST WORD


PMASK:	.WORD	0
EDTBUF:	.BLKW	9.		; BUFFER FOR EDITTING
TIMBUF:	.BLKW	8.		; TO HOLD TIME AND DATE
MAIN:	.WORD	0		; SAVE AREA FOR MAIN PARTITION ADDRESS
DAY:	.WORD	0		; 3 WORDS FOR SYSTEM UP TIME
HOUR:	.WORD	0
MIN:	.WORD	0
MARKER:	.BYTE	0		; - OR = FOR UNFIXED, OR FIXED

	.EVEN
	.PAGE
	.SBTTL	SYSTEM TABLE DATA CAPTURE

UPDATE:	CALL	$SWSTK,OUT	; ENTER SYSTEM STATE
	MOV	#10,R0		;; 10 WORDS
	MOV	#$MDBUF+TASKS,R1 ;; LIST OF 4 ACTIVE TASKS
5$:	CLR	(R1)+		;; INIT TO SPACES
	SOB	R0,5$		;; LOOP TO CLEAR
	MOV	#$MDBUF+TASKS,R5 ;; WHERE TO STORE TASK NAMES

	.IF	DF,R$$MPL
	BITB	#F2.MP,$FMASK+2 ;; ARE WE MULTIPROCESSOR?
	BNE	28$		;; YES
	.ENDC

; SINGLE PROCESSOR (NEXT) ACTIVE TASK GET

	.IF	DF,R$$MPL
	MOV	@$RQSCH,R0	;; IS THERE A RESCHEDULE REQUEST
	.IFF
	MOV	$RQSCH,R0	;; IS THERE A RESCHEDULE REQUEST
	.ENDC

	BNE	10$		;; YES
	MOV	$TKTCB,R0	;; GET OWN TCB
10$:
	CMP	R0,$TKTCB	;; LOOKING AT ME
	BEQ	18$		;; GET NEXT
15$:	CALL	RUNABL		;; CHECK RUN ELIGIBILITY
	BCC	20$		;; RUNNABLE
18$:	MOV	T.ACTL(R0),R0	;; GET NEXT TASK
	BNE	15$		;;
	BR	25$		;; SAY IDLE
20$:	MOV	T.NAM(R0),(R5)+ ;; STORE TASK NAME
	MOV	T.NAM+2(R0),(R5);;
	BR	60$		;; NEXT DATA ITEM
25$:	MOV	#-1,(R5)	;; MARK AS IDLE
	BR	60$		;; NEXT DATA ITEM

	.IF	DF,R$$MPL
; MULTIPROCESSOR (NEXT?) ACTIVE TASK GET

28$:	MOV	#4,R2		;; LOOP COUNTER
	MOV	#$TKTAB,R1	;; CURRENT TASK TABLE
	MOV	$URMST,PMASK	;; PROCESSOR MASK
30$:	MOV	(R1)+,R3	;; GET CURRENT TASK FOR PROCESSOR
	ASR	PMASK		;; SHIFT OFF PROCESSOR BIT
	BCC	50$		;; PROCESSOR OFFLINE
	MOV	$RQTAB-$TKTAB-2(R1),R0 ;; RESCHEDULE POINTER
	BNE	35$		;; WAS ONE
	MOV	R3,R0		;; USE CURRENT TASK
	BEQ	45$		;; NONE
35$:	CMP	$TKTCB,R0	;; IS IT ME
	BEQ	38$		;; IF YES, SKIP
	TST	T.ACTL(R0)	;; NULL TASK
	BEQ	45$		;; SHOW IDLE
37$:	CALL	RUNABL		;; CHECK RUN ELIGIBILITY
	BCC	40$		;; CAN BE RUN
38$:	MOV	T.ACTL(R0),R0	;; NEXT TASK IN LIST
	BNE	37$		;; CHECK THIS ONE
	BR	45$		;; NONE - SHOW IDLE
40$:	MOV	T.NAM(R0),(R5)+	;; STORE TASK NAME
	MOV	T.NAM+2(R0),(R5)+ ;;
	SOB	R2,30$		;; NEXT PROCESSOR
	BR	60$		;; NEXT DATA ITEM
45$:	MOV	#-1,(R5)+	;; FLAG AS IDLE
50$:	ADD	#2,R5		;; NEXT LOC IN BUFFER
	SOB	R2,30$		;; NEXT PROCESSOR
	.ENDC

; CURRENT POOL STATISTICS

60$:	MOV	#$MDBUF+CPLRG,R0	;; CURRENT POOL DATA BUFFER
	CLR	(R0)+		;; CLEAR IT
	CLR	(R0)+		;;
	CLR	(R0)+		;;
	MOV	#$MDBUF+CPLRG,R0	;;
	MOV	#$CRAVL,R4	;; START OF SYSTEM POOL
	BR	75$		;; BRANCH INTO LOOP
65$:	CMP	(R0),2(R4)	;; IS MAX > THIS BLOCK
	BHIS	70$		;; YES
	MOV	2(R4),(R0)	;; MOVE IN NEW MAX
70$:	ADD	2(R4),2(R0)	;; ADD BLOCK TO TOTAL
	INC	4(R0)		;; INC # OF FRAGMENTS
75$:	MOV	(R4),R4		;; NEXT BLOCK
	BNE	65$		;; IF NOT AT END
;
; WORST YET POOL STATISTICS
;
	MOV	$MDWPT,R1	;;
	BIS	$MDWPF,R1	;; IF BOTH ZERO, FILL IN WITH CURRENT INFO
	BNE	80$		;; VALID, UPDATE IF NEEDED
	MOV	(R0)+,$MDWPL	;; WORST LARGEST FRAGMENT
	MOV	(R0)+,$MDWPT	;; SMALLEST POOL HAS GOTTEN
	MOV	(R0)+,$MDWPF	;; WORST FRAGMENTATION SO FAR
	BR	95$		;; ENOUGH DEPRESSING STUFF
80$:	CMP	(R0)+,$MDWPL	;; WORST LARGEST FRAG CHANGED
	BHIS	85$		;; NO
	MOV	-2(R0),$MDWPL	;; UPDATE
85$:	CMP	(R0)+,$MDWPT	;; SHRUNK BELOW WORST YET
	BHIS	90$		;; NO
	MOV	-2(R0),$MDWPT	;; UPDATE
90$:	CMP	(R0)+,$MDWPF	;; MORE FRAGMENTATION THAN WORST
	BLOS	95$		;; NO
	MOV	-2(R0),$MDWPF

95$:
	.IF	DF,R$$MPL
	MOV	$ABTIM-2,$MDBUF+ABTIM-2
	MOV	$ABTIM,$MDBUF+ABTIM	;; COPY CURRENT SYSTEM TIME
	.ENDC
; DEVICE FREE BLOCKS

100$:	MOV	#$MDDEV+4,R1	;; UCB ADDRESS OF FIRST DEVICE TO SHOW
	MOV	#$MDBUF+FREE,R2	;;
	MOV	#4,R0		;; 4 FILES-11 DEVICES
105$:	CMPB	#1,-1(R1)	;; REQUESTED DEVICE THERE?
	BEQ	110$		;; IF NOT, LEAVE FREE BLOCKS BLANK
	MOV	(R1),R4		;; UCB ADDRESS OF DEVICE
	BIT	#DV.F11,U.CW1(R4) ;; FILES-11 DEVICE
	BEQ	110$		;; NO - MAKE BLANK
	BITB	#US.MNT,U.STS(R4) ;; MOUNTED
	BNE	115$		;; NO

	.IF	DF,R$$MPL
	BITB	#US.FOR,U.STS(R4) ;; MOUNTED AS FOREIGN
	BEQ	107$
	MOVB	#3,-1(R1)	;; MARK AS FOREIGN
	BR	110$
107$:
	.ENDC

	MOV	U.VCB(R4),R3	;; VCB HOLDS COUNT OF FREE BLOCKS
	MOV	V.FRBK(R3),(R2)+;; HIGH BYTE OF BLOCK COUNT AND LRUC
	CLRB	-1(R2)		;; CLEAR OUT LRUC
	MOV	V.FRBK+2(R3),(R2)+ ;; LOW ORDER WORD OF BLOCK COUNT
	CLRB	-1(R1)		;; CLEAR DISMOUNT FLAG
	ADD	#6,R1		;; NEXT DEVICE UCB ADDRESS
	SOB	R0,105$		;; LOOP FOR REST OF DEVICES
	BR	120$
115$:	MOVB	#2,-1(R1)	;; FLAG AS DISMOUNTED
110$:	CMP	(R2)+,(R2)+	;; ADD 4 FOR NEXT D-WORD
	ADD	#6,R1		;; NEXT UCB ADDRESS
	SOB	R0,105$


; TASKS IN & OUT OF MEMORY

120$:	MOV	#$MDBUF+INN,R0	; CLEAR 4 WORDS
	CLR	(R0)+
	CLR	(R0)+
	CLR	(R0)+
	CLR	(R0)
	MOV	#$TSKHD-T.TCBL,R1 ;; FIRST POINTER
125$:	MOV	T.TCBL(R1),R1	;; GET FIRST
	TST	T.TCBL(R1)	;; NULL TASK
	BEQ	135$		;; DONE
	BIT	#TS.EXE,T.STAT(R1) ;; TASK NOT ACTIVE
	BNE	125$		;;
	CMP	R1,$LDRPT	;; DON'T COUNT LOADER
	BEQ	125$
	MOV	T.PCB(R1),R2	;; SUBPARTION IDENTIFIED WITH IT

	.IF	DF,R$$MPL	;;
	BIT	#PS.OUT,P.STAT(R2) ;; IN MEMORY

	.IFF
	BIT	#TS.OUT,T.STAT(R1) ;;

	.ENDC

	BNE	130$		;; NO
	INC	$MDBUF+INN	;; INC NUMBER IN
	ADD	P.SIZE(R2),$MDBUF+INM ;; ADD IN SIZE
	BR	125$
130$:	INC	$MDBUF+OUTN	;; INC NUMBER OUT
	ADD	P.SIZE(R2),$MDBUF+OUTM ;; ADD IN SIZE
	BR	125$

; ERROR SEQUENCES

135$:	MOV	$ERRSQ,$MDBUF+ERRORS ;; ERROR SEQUENCE NUMBER

; FILL BUSY PARTITON LIST

140$:	MOV	$PARHD,R4	;; STORE ADDRESS OF FIRST
141$:	TST	P.REL(R4)	;; PARTITION					;AG039A
	BNE	142$		;; NOT LOADER					;AG039A
	MOV	(R4),R4		;; SKIP LOADER					;AG039A
	BR	141$		;; USE NEXT PCB (ASSUME ONE THERE)		;AG039A
142$:	MOV	P.REL(R4),R4							;AG039A
										;**-1
	.IF	NDF,M$$MGE
	CLC
	ROR	R4		;; CONVERT TO 32WD
	.REPT	5
	ASR	R4
	.ENDR
	.ENDC

	MOV	R4,$MDBUF+PARSTR

	MOV	#$PARHD,R4	;; HEAD OF PARTITION LIST
	MOV	#$MDBUF+PARLST,R5 ;; WHERE TO STORE
145$:	MOV	(R4),R4		;; GET NEXT PCB
	BNE	146$		;;
	JMP	200$		;; END OF LIST
146$:				;; REFERENCE LABEL
	TST	P.REL(R4)	;; IS IT THE LOADER?				;AG039A
	BEQ	145$		;; YES, SKIP IT					;AG039A


	.IF	DF,R$$MPL

	MOV	R4,-(SP)	;; SAVE MAIN PARTITION ADDRESS
150$:	MOV	P.SUB(R4),R4	;; SUB PARTITION PCB
	BNE	153$		;; THERE IS ONE
152$:	MOV	(SP)+,R4		;; RESTORE MAIN PCB
	BR	145$
153$:	BIT	#PS.COM,P.STAT(R4) ;; DYNAMIC COMMON
	BEQ	175$		;; NO, TASK
	BIT	#P2.DRV,P.ST2(R4) ;; LOADED (DRUNK?) DRIVER
	BEQ	155$		;; NO
	MOV	P.OWN(R4),R3	;; DCB ADDRESS
	MOV	D.NAM(R3),(R5)+	;; DEVICE NAME
	CLR	(R5)+		;; IN ASCII
	MOV	#"(),(R5)+	;; BRACKETING CHARS
	BR	180$		;; FINISH IN COMMON CODE
155$:	MOV	P.NAM(R4),-(SP)
	BIS	P.NAM+2(R4),(SP)+ ;; UNNAMED COMMON
	BEQ	160$		;; YES
	MOV	P.NAM(R4),(R5)+	;; NAME
	MOV	P.NAM+2(R4),(R5)+
	MOV	#"!!,(R5)+	;; BRACKETING CHARS
	BR	180$		;; COMMON CODE
160$:	MOV	P.OWN(R4),R2	;; OWNING TASK
	TST	P.DPCB(R4)	;; IS THERE A DISK PCB
	BNE	168$		;; YES, P.OWN IS A TCB
	MOV	P.ATT(R4),R2	;; NO, GET ATTACHMENT LIST
	BEQ	165$		;; NOBODY ATTACHED, LEAVE NAME BLANK
	MOV	A.TCB(R2),R2	;; GET TCB ADDRESS
	BR	168$		;; MOVE NAME
165$:	CLR	(R5)+		;; BLANK NAME
	CLR	(R5)+
	BR	170$
168$:	MOV	T.NAM(R2),(R5)+	;; ASSOCIATED TASK'S NAME
	MOV	T.NAM+2(R2),(R5)+
170$:	MOV	#"++,(R5)+	;; BRACKETING CHARS
	BR	180$		;; COMMON CODE
175$:	MOV	P.TCB(R4),R3	;; TCB ADDRESS

	.IFF

	BITB	P.BUSY(R4),P.BUSY+1(R4) ;; IS PARTITION BUSY
	BEQ	145$		;; NO
	CLR	MAIN		;; ASSUME NOT SYSTEM CONTROLLED
	BIT	#PS.COM,P.STAT(R4) ;; IS THIS A COMMON PARTITION
	BEQ	153$		;; NO
150$:	MOV	P.NAM(R4),-(SP)	;;
	BIS	P.NAM+2(R4),(SP)+;; IS NAME BLANK
	BEQ	151$		;; YES, GET NAME OF ASSOCIATED TASK
	MOV	P.NAM(R4),(R5)+	;; STORE PARTITION NAME AS TASK NAME
	MOV	P.NAM+2(R4),(R5)+
	MOV	#"!!,(R5)+	;; BRACKETING CHARACTERS
	BR	180$		;; FINISH IN COMMON CODE
151$:	MOV	P.ATT(R4),R2	;; ANYONE ATTACHED
	BNE	152$		;; YES
	CLR	(R5)+		;; NO, LEAVE NAME BLANK
	CLR	(R5)+
	BR	1525$
152$:	MOV	A.TCB(R2),R2	;; GET TCB OF FIRST TASK TO ATTACH
	MOV	T.NAM(R2),(R5)+	;; TASK NAME
	MOV	T.NAM+2(R2),(R5)+
1525$:	MOV	#"++,(R5)+	;; FLAG AS UNNAMED COMMON
	BR	180$
153$:	BIT	#PS.SYS,P.STAT(R4) ;; SYSTEM CONTROLLED PARTITION
	BEQ	163$		;; NO
	MOV	R4,MAIN		;; SAVE MAIN PCB ADDRESS
156$:	MOV	P.SUB(R4),R4	;; GET SUBPARTITION PCB ADDRESS
	BNE	160$		;; GOT ONE
	MOV	MAIN,R4		;; RESTORE MAIN PCB ADDRESS
	BR	145$		;; REENTER MAIN LOOP
160$:	BIT	#PS.COM,P.STAT(R4) ;; IS THIS A DYNAMIC COMMON
	BNE	150$		;; YES
163$:	MOV	P.TCB(R4),R3	;; GET TCB ADDRESS
	BIT	#PS.DRV,P.STAT(R4) ;; IS THIS A LOADED DRIVER
	BEQ	178$		;; NO
	MOV	D.NAM(R3),(R5)+	;; MOVE ASCII DEVICE NAME
	CLR	(R5)+
	MOV	#"(),(R5)+	;; BRACKETING CHARACTERS
	BR	180$		;; COMMON CODE

	.ENDC


178$:	MOV	T.NAM(R3),(R5)+	;; TASK NAME
	MOV	T.NAM+2(R3),(R5)+
	MOV	#"<>,(R5)+	;; ASSUME ACTIVE
	BIT	#TS.EXE,T.STAT(R3) ;; IS IT
	BEQ	180$		;; YES
	MOV	#"[],-2(R5)

	.IF	NDF,R$$MPL
	BIT	#T2.FXD,T.ST2(R3) ;; FIXED TASK ON M IS DIFFERENT
	BEQ	185$
	BIS	#200,-2(R5)	;; FLAG AS FIXED
	BR	185$
	.ENDC

180$:	BIT	#PS.FXD,P.STAT(R4) ;; PARTITION FIXED IN MEMORY
	BEQ	185$		;; NO
	BIS	#200,-2(R5)	;; SET FIXED FLAG
185$:	MOV	P.REL(R4),R1	;; BASE ADDRESS

	.IF	NDF,M$$MGE
	CLC
	ROR	R1		;; CONVERT TO 32 WD
	.REPT	5
	ASR	R1
	.ENDR
	.ENDC

	CALL	$MDA2M		;; ADDRESS ON MEMORY LINE
	BPL	187$		;; ON BOTTOM MEMORY LINE
	SUB	$WIDTH,R0	;; ONE LINE UP
	BR	189$
187$:	ADD	$WIDTH,R0	;; ONE LINE DOWN
189$:	MOV	R0,(R5)+
	MOV	P.REL(R4),R1
	ADD	P.SIZE(R4),R1	;; END ADDRESS OF PARTITION
	DEC	R1		;;

	.IF	NDF,M$$MGE
	CLC
	ROR	R1		;; CONVERT TO 32 WD
	.REPT	5
	ASR	R1
	.ENDR
	.ENDC

	CALL	$MDA2M
	BPL	190$		;; ON BOTTOM MEMORY LINE
	SUB	$WIDTH,R0	;; ONE LINE UP
	BR	192$
190$:	ADD	$WIDTH,R0	;; ONE LINE DOWN
192$:	MOV	R0,(R5)+


	.IF	DF,R$$MPL

	BR	150$		;; LOOP FOR NEXT SUB PARTITION

	.IFF

	TST	MAIN		;; PROCESSING SYSTEM CONTROLLED PARTITION
	BNE	156$		;; YES
	JMP	145$

	.ENDC


200$:	MOV	#-1,(R5)+	;; FLAG END
	RETURN




; SUBROUTINE TO CHECK WHETHER A TASK IS RUNABLE
; TCB ADDRESS IN R0
; DOES NOT DO CPU AFFINITY CHECK YET

RUNABL:	BIT	#^C<TS.RUN>,T.STAT(R0) ;; IS TASK BLOCKED
	BNE	40$		;; YES

	.IF	DF,R$$MPL
	BIT	#F2.MP,$FMASK+2	;; MULTIPROCESSOR
	BEQ	10$		;; NO
	BIT	#TS.RUN,T.STAT(R0) ;; IS IT RUN BIT
	BEQ	10$		;; NO
	CMP	R0,R3		;; IS THIS CURRENT TASK
	BNE	40$		;; IF NOT CURRENT, TS.RUN IS BLOCK BIT
	.ENDC

10$:	TST	T.ASTL(R0)	;; AST QUEUED FOR TASK
	BEQ	20$		;; NO
	BIT	#T2.AST!T2.DST,T.ST2(R0) ;; IN AST OR AST'S DISABLED
	BEQ	30$
20$:	BIT	#T2.STP!T2.SPN,T.ST2(R0) ;; STOPPED OR SUSPENDED
	BNE	40$
	BIT	#T2.WFR,T.ST2(R0) ;; IN WAITFOR STATE
	BEQ	30$
	MOV	T.PCB(R0),R4	;; TASK PCB
	MOV	P.HDR(R4),R4	;; HEADER ADDRESS
	BIT	H.EFLM(R4),@H.EFLM+2(R4) ;; WAITFOR SATISFIED
	BEQ	40$
30$:	CLC
	RETURN
40$:	SEC
	RETURN
	.PAGE
	.SBTTL	PAGE FILL
; START FILLING IN SCREEN BUFFER

OUT:
	GTIM$S	#TIMBUF		; GET TIME AND DATE
	TST	$MDDAT		; DO WE WANT DATE
	BEQ	10$		; NO
	MOV	#"  ,EDTBUF+8.	; FOR WHEN DAY IS LESS THAN 10
	MOV	#EDTBUF,R0	; OUTPUT FROM CONVERSION
	MOV	#TIMBUF,R1	; INPUT BUFFER
	CALL	$DAT		; CONVERT DATE TO ASCII
	MVN	#EDTBUF,$MDDAT,9. ; MOVE ONTO SCREEN BUFFER

10$:	TST	$MDTIM		; DO WE WANT TIME DISPLAYED
	BEQ	15$		; NO
	MOV	#"  ,EDTBUF+6	; FOR BEFORE 10 O'CLOCK
	MOV	#EDTBUF,R0	; OUTPUT FROM CONVERSION
	MOV	#TIMBUF+6,R1	; INPUT BUFFER
	MOV	#3,R2		; HH:MM:SS FORMAT
	CALL	$TIM		; CONVERT TIME TO ASCII
	MVN	#EDTBUF,$MDTIM,8. ; MOVE ONTO SCREEN

15$:
	TST	$MDALV		; DO WE WANT TIME ALIVE DISPLAYED
	BEQ	16$		; NO
	MOV	#"  ,EDTBUF+6	; FOR BEFORE 10 O'CLOCK
	MOV	#EDTBUF,R0	; OUTPUT FROM CONVERSION
	MOV	#TIMBUF+6,R1	; INPUT BUFFER
	MOV	#3,R2		; HH:MM:SS FORMAT
	CALL	$TIM		; CONVERT TIME TO ASCII
	MVN	#EDTBUF,$MDALV,8. ; MOVE ONTO SCREEN
	CLR	$MDALV		; TURN OFF
16$:
	.IF	DF,R$$MPL
	TST	$MDALV+2
	BEQ	20$
	MOV	$MDBUF+ABTIM,R1	; CURRENT TIME
	SUB	$MDBTM,R1	; LOW ORDER DIFFERENCE
	MOV	$MDBUF+ABTIM-2,R0
	SBC	R0		; BORROW FROM LOW ORDER
	SUB	$MDBTM-2,R0
	DIV	#K$$TPS*60.,R0	; IN MINUTES
	MOV	R0,R1
	CLR	R0
	DIV	#60.,R0		; NOW IN HOURS
	MOV	R1,MIN		; REMAINDER IS MINUTES
	MOV	R0,R1
	CLR	R0
	DIV	#24.,R0		; NOW IN DAYS
	MOV	R1,HOUR		; REMAINDER IS HOURS
	MOV	R0,DAY
	MOV	#EDTBUF,R0	; EDIT BUFFER FOR OUTPUT
	MOV	DAY,R1		; NUMBER OF DAYS UP
	MOV	#6666.,R2	; 3 DIGITS - LITTLE LESS THAN 3 YEARS
	CALL	$CBTA
	MOVB	#':,(R0)+
	MOV	HOUR,R1
	MOV	#4618.,R2	; 2 DIGITS
	CALL	$CBTA
	MOVB	#':,(R0)+
	MOV	MIN,R1
	MOV	#4618.,R2
	CALL	$CBTA
	MVN	#EDTBUF,$MDALV+2,9.
	.ENDC

20$:	MOV	#16.,R5		; 16 BYTES IN 4 RAD50 TASKNAMES
	MOV	#6,R4		; ADDRESSES TO PUT THEM
21$:	TST	$MDTSK(R4)	; DO WE WANT TO SHOW TASK ON THIS CPU
	BEQ	27$		; NO
	MOV	#EDTBUF,R0
	CMP	#-1,$MDBUF+TASKS-4(R5)	; IDLE
	BEQ	23$		; YES
	MOV	$MDBUF+TASKS-4(R5),R1	; FIRST HALF OF TASK NAME
	CALL	$C5TA		; CONVERTED TO ASCII
	MOV	$MDBUF+TASKS-2(R5),R1	; SECOND HALF OF TASK NAME
	CALL	$C5TA		; ALSO CONVERTED
	BR	25$		; MOVE TO SCREEN
23$:	MOV	#"*I,(R0)+	; MOVE *IDLE* INTO BUFFER
	MOV	#"DL,(R0)+
	MOV	#"E*,(R0)+
25$:	MVN	#EDTBUF,$MDTSK(R4),6 ; MOVE TASK NAME
27$:	TST	-(R4)		; SUBTRACT 2
	SUB	#4,R5
	BNE	21$

30$:	TST	$MDPLC		; DO WE WANT CURRENT POOL STATS
	BEQ	40$		; NO
	MOV	#9.,R0		; CLEAR OUT EDIT BUFFER
	MOV	#EDTBUF,R1	; SO THAT IF DATA TAKES LESS THAN 17
31$:	MOV	#"  ,(R1)+	; COLUMNS, SPACES WILL BE DISPLAYED
	SOB	R0,31$
	MOV	#EDTBUF,R0	; OUTPUT EDIT BUFFER
	MOV	$MDBUF+CPLRG,R1	; LARGEST PIECE OF POOL
	ASR	R1		; CONVERT TO WORDS
	CLR	R2		; LEFT JUSTIFY
	CALL	$CBDMG		; CONVERT TO ASCII
	MOVB	#'.,(R0)+	; INSERT SEPARATERS
	MOVB	#':,(R0)+
	MOV	$MDBUF+CPTOT,R1	; TOTAL AMOUNT OF POOL AVAILABLE
	ASR	R1		; CONVERT TO WORDS
	CLR	R2
	CALL	$CBDMG
	MOVB	#'.,(R0)+
	MOVB	#':,(R0)+
	MOV	$MDBUF+CPFRG,R1	; NUMBER OF FRAGMENTS IN POOL
	CLR	R2
	CALL	$CBDMG
	MOVB	#'.,(R0)
	MVN	#EDTBUF,$MDPLC,17. ; MOVE INTO SCREEN BUFFER

40$:	TST	$MDPLW		; DO WE WANT WORST POOL STATS
	BEQ	50$		; NO
	MOV	#9.,R0		; CLEAR OUT EDIT BUFFER
	MOV	#EDTBUF,R1	; SO THAT IF DATA TAKES LESS THAN 17
41$:	MOV	#"  ,(R1)+	; COLUMNS, SPACES WILL BE DISPLAYED
	SOB	R0,41$
	MOV	#EDTBUF,R0	; OUTPUT EDIT BUFFER
	MOV	$MDWPL,R1	; LARGEST PIECE OF POOL
	ASR	R1		; CONVERT TO WORDS
	CLR	R2		; LEFT JUSTIFY
	CALL	$CBDMG		; CONVERT TO ASCII
	MOVB	#'.,(R0)+	; INSERT SEPARATERS
	MOVB	#':,(R0)+
	MOV	$MDWPT,R1	; TOTAL AMOUNT OF POOL AVAILABLE
	ASR	R1		; CONVERT TO WORDS
	CLR	R2
	CALL	$CBDMG
	MOVB	#'.,(R0)+
	MOVB	#':,(R0)+
	MOV	$MDWPF,R1	; NUMBER OF FRAGMENTS IN POOL
	CLR	R2
	CALL	$CBDMG
	MOVB	#'.,(R0)
	MVN	#EDTBUF,$MDPLW,17. ; MOVE INTO SCREEN BUFFER

50$:	MOV	#24.,R5		; 24 BYTES IN 4 6 WORD DEVICE ENTRIES
	MOV	#6,R4		; 4 WORD ENTRIES
51$:	MOV	#EDTBUF,R1	; OUTPUT EDIT BUFFER
	MOV	#9.,R0		; 9 WORDS LONG
52$:	MOV	#"  ,(R1)+	; SPACE FILL BUFFER
	SOB	R0,52$
53$:	TST	$MDFRE(R4)	; SHALL WE SHOW THIS ONE
	BEQ	57$		; NO
	MOV	#EDTBUF,R0	; OUTPUT BUFFER AGAIN
	MOV	$MDDEV-6(R5),(R0)+ ; DEVICE NAME
	MOVB	$MDDEV-4(R5),R1	; UNIT NUMBER
	ADD	#'0,R1		; NOW IN ASCII
	MOVB	R1,(R0)+
	MOVB	#':,(R0)+
	CMPB	#1,$MDDEV-3(R5) ; STATUS FLAG
	BEQ	55$		; DEVICE WAS NOT FOUND IN SEARCH

	.IF	DF,R$$MPL
	CMPB	#2,$MDDEV-3(R5)	; DEVICE NOT MOUNTED
	BEQ	54$
	BLT	545$		; (3) DEVICE MOUNTED FOREIGN
	.IFF
	BLT	54$		; (2) DEVICE NOT MOUNTED
	.ENDC

	MOV	#$MDBUF+FREE,R1	; DOUBLEWORD OF FREE BLOCK COUNT
	ADD	R4,R1
	ADD	R4,R1		; OFFSET
	CLR	R2		; LEFT JUSTIFY
	CALL	$CDDMG		; CONVERT TO ASCII
	MOVB	#'.,(R0)	; DECIMAL
	BR	55$		; MOVE TO SCREEN
54$:	MOVB	#'D,(R0)+	; DEVICE DISMOUNTED
	MOVB	#'M,(R0)+
	MOVB	#'O,(R0)

	.IF	DF,R$$MPL
	BR	55$
545$:	MOVB	#'F,(R0)+	; DEVICE MOUNTED FOREIGN
	MOVB	#'O,(R0)+
	MOVB	#'R,(R0)+
	.ENDC

55$:	MVN	#EDTBUF,$MDFRE(R4),11.	; MOVE TO SCREEN
57$:	TST	-(R4)		; SUBTRACT 2
	SUB	#6,R5
	BNE	51$

60$:	TST	$MDINN		; SHOW NUMBER OF TASKS IN MEMORY
	BEQ	701$		; NO
	MOV	#"  ,EDTBUF	; CLEAR EDIT BUFFER
	MOV	#"  ,EDTBUF+2
	MOV	#EDTBUF,R0
	MOV	$MDBUF+INN,R1
	CLR	R2
	CALL	$CBDMG		; CONVERT TO ASCII
	MVN	#EDTBUF,$MDINN,3

701$:	TST	$MDINK		; SHOW MEMORY TAKEN UP BY TASKS IN MEMORY
	BEQ	801$		; NO
	MOV	#"  ,EDTBUF	; CLEAR EDIT BUFFER
	MOV	#"  ,EDTBUF+2
	MOV	#"  ,EDTBUF+4
	MOV	#"  ,EDTBUF+6
	MOV	#EDTBUF,R0
	MOV	$MDBUFF+INM,R1	; IN 32 WD UNITS

	.IF	NDF,M$$MGE
	CLC
	ROR	R1		; OR MAKE IT SO NOW
	.REPT	5
	ASR	R1
	.ENDR
	.ENDC


	.IF	DF,R$$EIS
	ASH	#-5,R1		; CONVERT TO K WORDS

	.IFF
	.REPT	5
	ASR	R1
	.ENDR
	.ENDC

	ADC	R1		; ROUND SORT OF
	CLR	R2		; ZERO SUPPRESSION
	CALL	$CBDMG
	MOVB	#'K,(R0)
	MVN	#EDTBUF,$MDINK,5	; MOVE ONTO SCREEN

801$:	TST	$MDOTN		; SHO NUMBER OF CHECKPOINTED TASKS
	BEQ	90$		; NO
	MOV	#"  ,EDTBUF	; CLEAR EDIT BUFFER
	MOV	#"  ,EDTBUF+2
	MOV	#EDTBUF,R0
	MOV	$MDBUF+OUTN,R1
	CLR	R2
	CALL	$CBDMG		; CONVERT TO ASCII
	MVN	#EDTBUF,$MDOTN,3

90$:	TST	$MDOTK		; SHOW MEMORY REQUIREMENTS OF CHECKPONTED TASKS
	BEQ	100$		; NO
	MOV	#"  ,EDTBUF	; CLEAR EDIT BUFFER
	MOV	#"  ,EDTBUF+2
	MOV	#"  ,EDTBUF+4
	MOV	#"  ,EDTBUF+6
	MOV	#EDTBUF,R0
	MOV	$MDBUF+OUTM,R1	; IN 32 WD UNITS

	.IF	NDF,M$$MGE
	CLC
	ROR	R1		; OR MAKE IT SO NOW
	.REPT	5
	ASR	R1
	.ENDR
	.ENDC


	.IF	DF,R$$EIS
	ASH	#-5,R1		; CONVERT TO K WORDS

	.IFF
	.REPT	5
	ASR	R1
	.ENDR
	.ENDC

	ADC	R1		; ROUND SORT OF
	CLR	R2		; ZERO SUPPRESSION
	CALL	$CBDMG
	MOVB	#'K,(R0)
	MVN	#EDTBUF,$MDOTK,5	; MOVE ONTO SCREEN

100$:	MOV	$MDBUF+PARSTR,R1 ; ADDRESS OF FIRST PARTITION
	CALL	$MDA2M		; GET ADDRESS ON MEMORY LINE
	BMI	105$		; ON TOP LINE, SKIP
	MOV	#$MDBUF+PARLST,R1 ; LIST OF PARTITION ID'S
	CLR	R3		; CLEAR CENTER MARKER
	BR	110$
105$:	MOV	#$MDBUF+PARLST,R1 ; LIST OF PARTITION ID'S
	SUB	$WIDTH,R0	; MOVE 1 LINE UP
	MOV	$MDML0,R2	; START OF LINE
	SUB	$WIDTH,R2	; MOVE 1 LINE UP
	ADD	$MDMLN,R2	; END OF LINE
	MOV	$MD6W,R4	; 6 * $WIDTH FOR START OF TASKS
	NEG	R4		; 6 LINES UP
	CLR	R3		; CLEAR CENTER MARKER
	CALL	MFILL		; FILL IN MEMORY LINE

	MOV	$MDML1,R0	; SECOND MEMORY LINE
	BEQ	120$		; NO, JUMP OUT
110$:	ADD	$WIDTH,R0	; 1 LINE DOWN
	MOV	$MDML1,R2	; START OF LINE
	ADD	$WIDTH,R2	; MOVE 1 LINE DOWN
	ADD	$MDMLN,R2	; END OF LINE
	MOV	$WIDTH,R4	; FOR START OF TASKS
	CALL	MFILL		; FILL SECOND MEMORY LINE

120$:	TST	$MDERR
	BEQ	130$		; SHO ERROR SEQUENCES
	MOV	#"  ,EDTBUF	; CLEAR EDIT BUFFER
	MOV	#"  ,EDTBUF+2
	MOV	#"  ,EDTBUF+4
	MOV	#EDTBUF,R0
	MOV	$MDBUF+ERRORS,R1
	CLR	R2
	CALL	$CBDMG
	MOVB	#'.,(R0)
	MVN	#EDTBUF,$MDERR,6

130$:

	RETURN

;+
; SUBROUTINE MFILL - FILL IN A MEMORY LINE
;
; INPUTS -
;	R0 - ADDRESS IN SCREEN BUFFER OF CURRENT POSITION
;	R1 - POINTER TO CURRENT PARTITION IDENTIFIER (IN $MDBUF)
;	R2 - 1 PAST LAST POSITION ON CURRENT LINE (END OF LINE FLAG)
;	R4 - AMOUNT ADDED TO R0 TO GIVE ADDRESS TO START PARTITION NAME AT
;
; OUTPUTS -
;	R1 - POINTER TO CURRENT PARTITION IDENTIFIER (IN $MDBUF)
;-

MFILL:	CMP	#-1,(R1)	; END OF PARTITIONS
	BNE	1$
	JMP	701$		; YES, BLANK REST OF MEM LINES
1$:	CMP	10(R1),R0	; ALREADY PAST IT
	BHIS	1500$
	JMP	30$		; YES
; FIND "MIDDLE" OF PARTITION TO CENTER NAME
1500$:	CMP	R3,R0		; DO WE ALREADY HAVE A MIDDLE FOR THIS ONE
	BHIS	20$		; IF SO, NO NEED TO RECOMPUTE
	CMP	6(R1),$MDML1	; PARTITION START ON BOTTOM LINE
	BHIS	2$		; YES
	CMP	10(R1),$MDML1	; PARTITION END ON BOTTOM LINE
	BHIS	4$		; START AND END ON DIFFERENT LINES
2$:	MOV	10(R1),R3	; END OF PARTITION
	ADD	6(R1),R3	; START + END
	INC	R3		; BIAS TOWARDS END
	ROR	R3		; (START + END)/2
	BR	6$
; PARTITION STARTS ON TOP LINE AND ENDS ON BOTTOM - LITTLE MORE WORK
4$:	MOV	10(R1),R3	; END OF PARTITION
	SUB	$MDML1,R3	; WHY TOP MEMORY LINE MUST BE ABOVE BOTTOM
	SUB	$WIDTH,R3	; THAT EXTRA LINE
	ADD	6(R1),R3	; START + END
	ADD	R2,R3		; MAKING MEMORY LINES LOOK CONTIGUOUS
	INC	R3		; CORRECTION
	ROR	R3		; (START + END)/2
	CMP	R3,R2		; MIDDLE ON TOP LINE
	BLO	6$		; YES, DONE
	ADD	$MDML1,R3	; ADD CORRECTION TO PUT ON LOWER LINE
	ADD	$WIDTH,R3
	SUB	R2,R3

6$:	MOVB	#'=,MARKER	; ASSUME FIXED
	TSTB	4(R1)		; IS IT
	BMI	10$		; YES
	MOVB	#'-,MARKER	; NO
10$:	BICB	#200,4(R1)	; CLEAR NEW CHAR FLAG
20$:	CMP	R0,R2		; AT END OF LINE
	BLO	215$		; NO
	JMP	80$		; YES, RETURN
; FILL IN PARTITION NAME
215$:	CMP	R0,R3		; AT "MIDDLE"
	BNE	24$		; JUST FILL WITH SPACES
	MOV	R0,R5		; SAVE FOR OUTPUT LOCATION
	MOV	R0,-(SP)	; SAVE
	MOV	R1,-(SP)	;      THE
	MOV	R2,-(SP)	;          REGS
	CMPB	#'),5(R1)	; LOADED DRIVER
	BEQ	23$		; YES, NAME IN DIFFERENT FORMAT
	MOV	(R1),R1		; FIRST WORD OF NAME
	MOV	#EDTBUF,R0	; EDIT BUFFER
	CALL	$C5TA		; CONVERT TO ASCII
	MOV	2(SP),R1	; POINTER TO PARTITION ID
	MOV	2(R1),R1	; LAST HALF OF NAME
	CALL	$C5TA		; CONVERT IT
21$:	MOV	#6,R0		; 6 CHARS
	MOV	#EDTBUF,R1
	ADD	R4,R5		; WHERE TO PUT NAME
22$:	OUTC	(R1),(R5)	; OUTPUT A CHAR TO SCREEN (INTERNAL BUFFER)
	ADD	$WIDTH,R5	; NEXT LINE
	INC	R1		; NEXT CHAR
	SOB	R0,22$		; LOOP
	MOV	(SP)+,R2	; RESTORE
	MOV	(SP)+,R1	;         THE
	MOV	(SP)+,R0	;             REGS
	BR	28$
; LOADED DRIVER NAME
23$:	MOV	(R1),EDTBUF	; DRIVER DEVICE NAME
	MOV	#": ,EDTBUF+2	; REST OF IT
	MOV	#"  ,EDTBUF+4
	BR	21$		; FINISH UP NAME
; NOT CENTER, JUST OUTPUT SPACES
24$:	MOV	R0,-(SP)	; SAVE
	ADD	R4,R0		; WHERE TO PUT SPACE
	MOV	#6,R5		; 6 SPACES
26$:	OUTC	#40,(R0)	; OUTPUT SPACE TO SCREEN BUFFER
	ADD	$WIDTH,R0	; NEXT LINE
	SOB	R5,26$
	MOV	(SP)+,R0	; RESTORE

; REGION MARKERS
28$:	CMP	R0,10(R1)	; AT END OF REGION
	BHI	30$		; PAST IT
	BLO	40$		; BEFORE IT
	OUTC	5(R1),(R0)	; CLOSE BRACKET
	INC	R0		; NEXT SPACE
30$:	ADD	#12,R1		; NEXT REGION
	JMP	MFILL
40$:	CMP	R0,6(R1)	; AT START OF REGION
	BEQ	50$		; YES
	BLO	60$		; BEFORE IT
	OUTC	MARKER,(R0)	; IN REGION
	INC	R0		; NEXT SPACE
	BR	20$
50$:	OUTC	4(R1),(R0)	; OPEN BRACKET
	INC	R0		; NEXT SPACE
	BR	20$
60$:	OUTC	#40,(R0)	; EMPTY SPACE
	INC	R0		; NEXT SPACE
	BR	20$
701$:	CMP	R0,R2		; EOL
	BHIS	80$		; RETURN
	MOV	R0,-(SP)	; SAVE
	ADD	R4,R0		; WHERE TO PUT SPACE
	MOV	#6,R5		; 6 SPACES
75$:	OUTC	#40,(R0)	; OUTPUT SPACE TO SCREEN BUFFER
	ADD	$WIDTH,R0	; NEXT LINE
	SOB	R5,75$
	MOV	(SP)+,R0	; RESTORE
	OUTC	#40,(R0)	; CLEAR
	INC	R0
	BR	701$
80$:	RETURN
	.END