;
;ADM=1	;INCLUDE IF ADM TERMINAL IS TO BE SUPPORTED
;
	.TITLE	ATS - ATL SCAN (5101)
	.MCALL	EXIT$C,DIR$,QIO$,QIOW$,GTIM$S,GMCR$,ASTX$C
	.MCALL	MRKT$S,WTSE$S,.INH0,.ENB0
;
;	PROGRAM NAME:  SYSTEM STATUS DISPLAY PROGRAM (ATS).
;
;	AUTHOR:  B. BRADSHAW       JUN 80.
;
;	FUNCTIONAL DESCRIPTION:
;		THIS PROGRAM DISPLAYS TO 5101 DISPLAY TERMINAL
;	IAS SYSTEM STATUS IN THE FORM OF NUMBER OF FREE NODES
;	(TOTAL AND LARGEST HOLE) AND THE LIST OF CURRENTLY ACTIVE
;	TASKS (ATL).  THE DISPLAYED IS UPDATED EVERY 30 CLOCK
;	TICKS.  THE PROGRAM ALSO MONITORS THE NODE POOL AND REPORTS
;	WARNING MESSAGES WHEN THE NODE COUNT FALLS BELOW A THRESHOLD
;	LEVEL.  TWO THRESHOLD LEVELS ARE MAINTAINED: RED LEVEL (BELOW
;	THE VALUE IN "REDLMT") AND YELLOW LEVEL (BELOW THE VALUE IN
;	"YLWLMT").  THE THRESHOLD VALUES CAN BE SET AT TASK BUILD TIME 
;	(REFER TO TASK BUILD REQUIREMENTS).
;
;
;
;	TASK BUILD REQUIREMENTS:
;
;	ATS/PR/-FP/MU,ATS/-SP/MA/-SH=ATS,[1,1]EXEC.STB
;	/
;	TASK=...ATS
;	LIBR=SYSRES:RO
;	PRI=150
;	ASG=TI:5:6
;	GBLDEF=REDLMT:62
;	GBLDEF=YELLMT:110
;	//
;*****************************************************************
;       EDITS
;
; INCLUDED IAS 3.1 STATUS
; CHANGED RED AND YELLOW STACK CODE TO WORK FOR NODES NOT BYTES
; CHANGED TO INCLUDE IDLE TASK
; CHANGED TO NOT LEAVE LAST TASK ON SCREEN AFTER UPDATE
; CHANGES ABOVE MADE BY B.REED@ADCOM
;
;
;
;
TILUN	=5
BEL	=7
EF1 	=3
EF2	=4
;
ESC	=33
;
; VT52 CURSOR CONTROLS
;
HOM	='H
EOS	='J
EOL	='K
EOP	='Y
BLNK	='^
DCA	='Y
	.IF DF,ADM
;
; ADM TERMINAL CURSOR CONTROLS
;
HOM	=36
EOS	='*
EOL	='T
EOP	='Y
BLNK	='^
DCA	='=
	.ENDC
TRW	=40
TCL	=40
FRW	=3+TRW
FCL	=2+TCL
MAXROW	=20.+TRW
NXCOL	=21.		;OFFSET TO START OF NEXT ROW.
STAOFF	=11.		;OFFSET TO START OF STATUS
MAXCOL	=80.+TCL	; MAXIMUM COLUMN NUMBER
;
;
RBE	=MAXROW+1	; ROW NUMBER FOR DISPLAY OF BFR OVERFLOW MSG
CBE	=FCL		; COLUMN NUMBER FOR DISPLAY OF BFR OVERFLOW MSG
;
;	ROW AND COLUMN NUMBERS FOR NODE DISPLAYS
;
NRW	=TRW		; ROW FOR NODE HEADER
NCL	=TCL+24.	; COLUMN FOR NODE HEADER
NOC	=NCL+OF1	; FOR TOTAL COUNT
HOC	=NCL+OF2	; FOR TOTAL HOLE COUNT.
WNRW	=MAXROW+2	;ROW FOR RED AND YELLOW MSGS
WNCL	=FCL		;COL FOR RED AND YELLOW MSGS
	.PAGE
	.SBTTL	START OF CODE: ATL AND NODE POOL SCAN
START:
	DIR$	#GETMCR		; GET THE MCR BUFFER
	DIR$	#CLRSCN		; CLEAR THE SCREEN
	CALL	UPDTIM		; AND UPDATE THE TIME
5$:
	MOV	#TSKTBL,R5	; IN CORE TASK TABLE (USED TO COMPARE TO ATL)
	MOV	#.ATLLH,R4	; ACTIVE TASK LIST LIST HEAD
10$:
	MOV	(R4),R4		; GET LIST ENTRY POINTER.
;
;	PROCESS THE ATL NODE ENTRY
;
	MOV	A.TI(R4),R2	; GET PUD ADDRESS
	MOV	A.TD(R4),R3	; GET STD ADDRESS
	CLRB	TB.IOS(R5)	; CLEAR TASK TABLE ENTRY STATUS WORD.
;
;	CHECK CURRENT ATL ENTRY TO TABLE ENTRY
;
	CMP	S.TN(R3),TB.TSK(R5)	; ARE TASK NAMES THE SAME?
	BNE	20$
	CMP	S.TN+2(R3),TB.TSK+2(R5)	; CHECK BOTH WORDS.
	BNE	20$
	CMP	U.DN(R2),TB.TIN(R5)	; IS THE TERMINAL ID THE SAME?
	BNE	30$
	CMPB	U.UN(R2),TB.TIU(R5)	; AND UNIT NUMBER?
	BNE	30$
	CMPB	A.TS(R4),TB.STA(R5)	; IS THE STATUS THE SAME?
	BNE	40$			;
	BR	100$
;
;	UPDATE THE INTERNAL TABLE WITH ITEMS FROM THE ATL NODE
;	THAT HAVE CHANGED (TASK NAME, TI OR STATUS).
;
20$:
	BISB	#1,TB.IOS(R5)		; FLAG THAT THIS IS A NEW TASK.
	CMP	(R4),#.ATLLH		; IS THIS THE NULTSK
	BNE	25$			; NO
	MOV	#^RNUL,TB.TSK(R5)	; MOV IN NULTKS NAME
	MOV	#^RTSK,TB.TSK+2(R5)	; SECOND HALF
	CLRB	TB.PRI(R5)		; AND PRI
	BR	30$
25$:	MOV	S.TN(R3),TB.TSK(R5)	; UPDATE TASK NAME INTO TABLE
	MOV	S.TN+2(R3),TB.TSK+2(R5)	;
	MOVB	A.RP(R4),TB.PRI(R5)	; AND TASK RUN PRIORITY
30$:
	CMP	(R4),#.ATLLH		; IS THIS THE NULTSK
	BNE	35$
	MOV	#"  ,TB.TIN(R5)		; BLANK TI NAME
	CLRB	TB.TIU(R5)		; AND ZERO UNIT NUMBER
	BR	40$
35$:	MOV	U.DN(R2),TB.TIN(R5)	; UPDATE TI NAME
	MOVB	U.UN(R2),TB.TIU(R5)	; AND UNIT NUMBER
40$:
	BISB	#2,TB.IOS(R5)		; INDICATE THAT STATUS HAS CHANGED.
	MOVB	A.TS(R4),TB.STA(R5)	; UPDATE TASK STATUS.
100$:
	ADD	#TB.SIZ,R5		; UPDATE TO NEXT TABLE ENTRY.
	CMP	R5,#TBLEND		; ARE WE AT END OF TABLE?
	BHIS	110$
	CMP	(R4),#.ATLLH	; ARE WE AT END OF LIST?
	BEQ	200$		; IF YES, TERMINATE SCAN
	JMP	10$			; CONTINUE SCAN IF NOT
110$:

;
	BIS	#1,ERRFLG		; SET FLAG INDICATING BUFFER OVERFLOW
200$:
;
;	CLEAR OUT REMAINING TASK TABLE
;
205$:
	CMP	R5,#TBLEND		; AT END?
	BHIS	210$			; TERMINATE IF YES.
	CLR	(R5)+			; CONTINUE CLEARING
	BR	205$
;
;
;	NOW DETERMINE NUMBER OF FREE NODES IN THE SYSTEM.
;
;**********************************************************:
210$:
	CLR	R3			; CLEAR THE COUNTERS
	CLR	R5			; R3 = LARGEST HOLE AND R5 = TOTAL.
	.INH0				; DISABLE TASK SWITCHING. ******
	MOV	.POLLH,R4		; GET POOL LIST HEAD.
215$:
	ADD	2(R4),R5		; GET COUNT
	CMP	2(R4),R3		; COMPARE TO CURRENT TOTAL
	BLOS	217$			; IF LESS, KEEP SAME.
	MOV	2(R4),R3		; ELSE, USE NEW.
217$:
	TST	(R4)			; MORE ENTRIES??
	BEQ	219$
	MOV	@R4,R4			; ELSE GET NEXT POINTER.
	BR	215$			; AND CONTINUE.
219$:
	.ENB0				; ENABLE TASK SWITCHING ******
;
;
;	R5 NOW CONTAINS THE TOTAL NUMBER OF FREE NODES AND
;	R3 CONTAINS THE LARGEST CONTIGUOUS BLOCK.
;
	MOV	R3,HOLNO1		; SAVE THE LARGEST HOLE
	MOV	R5,TOTNO1		; AND THE TOTAL COUNT.
	.PAGE
	.SBTTL	DISPLAY UPDATE PROCESSING AND EXIT
;
; 	THIS SECTION OF CODE WRITES TO THE TERMINAL THE NUMBER OF FREE 
;	NODES (TOTAL AND LARGEST HOLE) AND UPDATES THE LIST OF ACTIVE
;	TASKS.
;
	CALL	WRTNOD			; UPDATE THE NODE DISPLAY IF NECESSARY.
	MOV	#TSKTBL,R5		; START OF TABLE
	MOVB	#FRW-1,ROW1		; INIT ROW AND
	MOVB	#FCL,COL1		; AND COLUMN NUMBERS.
	CLR	NBRCNT			; THIS COUNTER IS USED TO COUNT
					; THE NUMBER OF TASKS IN THE ATL.
220$:
	INC	NBRCNT			; INCREMENT THE TASK COUNTER.
	CALL	UPDRNC			; UPDATE ROW AND COLUMN COUNTERS.
	TSTB	TB.IOS(R5)		; ANY CHANGES FOR THIS ENTRY?
	BEQ	230$
	CALL	WRTLIN			; IF YES, UPDATE THE DISPLAY.
230$:
	ADD	#TB.SIZ,R5		; OFFSET TO NEXT ENTRY.
	TST	(R5)			; MORE ENTRIES?
	BNE	220$
;
;
;	TASK TABLE HAS BEEN SCANNED.  NOW WE MUST PERFORM ENDING
;	FUNCTIONS.
;
	CALL	ENDSUB			; MAJOR ENDING OPERATIONS.
	DIR$	#RDSC			; HANG A READ FOR CTRL Z OR "R"
	MRKT$S	#EF2,#30.,#1		; MARK TIME FOR 30 TICKS.
	WTSE$S	#EF2			; WAIT FOR IT.
	TSTB	RDSTAT			; CTRL Z TYPED?
	BMI	EXIT
;
;	LOOK FOR "R".  IF TYPED, WE RE-FRESH THE SCREEN.
;
	CMPB	#'R,DUMMY		; "R" TYPED?
	BNE	250$			; CONTINUE IF NOT.
	CLR	DUMMY			; CLEAR THE DUMMY WORD.
	DIR$	#CLRSCN			; CLEAR SCREEN IF YES.
	MOV	#TSKTBL,R5		; AND BLANK OUT TASK TABLE
240$:
	CLR	(R5)+			; CLEAR IT.
	CMP	R5,#TBLEND		; AT END?
	BLO	240$			; LOOP IF NOT.
	CLR	TOTNO1			; CLEAR NODE COUNTS.
	CLR	TOTNO2
	CLR	HOLNO2
	CLR	HOLNO1
	CLR	SAVTIM			; FORCE NEW TIME DISPLAY ALSO.
250$:
	DIR$	#KILLRD			; KILL READ AND
	CALL	UPDTIM			; RESTART SCAN
	JMP	5$
EXIT:
	DIR$	#CLRSCN			; CLEAR SCREEN
	EXIT$C				; AND GET OUT.
	.PAGE
	.SBTTL	UPDATE ROW AND COLUMN NUMBER SUBROUTINE
UPDRNC:
	INCB	ROW1		; INCREMENT ROW NUMBER
	CMPB	ROW1,#MAXROW	; ARE WE AT END OF ROW?
	BLE	30$		;
	MOVB	COL1,DUMMY	; TEMP STORAGE
	ADD	#NXCOL,DUMMY	; OFFSET TO START OF NEXT COLUMN
	ADD	#LINE1S,DUMMY	; PLUS LENGTH OF AN OUTPUT LINE
	CMP	DUMMY,#MAXCOL	; HAVE WE EXCEEDED AN OUTPUT PAGE?
	BLE	10$		; LESS IF NOT.
;
;
	BIS	#1,ERRFLG	; SET ERROR FLAG.
10$:
	MOVB	#FRW,ROW1	; IF NOT, RESET ROW NUMBER AND
	SUB	#LINE1S,DUMMY	; AND COLUMN NUMBER
	MOVB	DUMMY,COL1	; PERMANENT STORAGE.
30$:
	RTS	PC		; RETURN TO MAIN LOOP.
	.PAGE
	.SBTTL	ENDING SUBROUTINE
ENDSUB:
;
;	THIS SUBROTINE PERFORMS REQUIRED ENDING FUNCTIONS
;	AT THE COMPLETION OF THE TASK TABLE SCAN.  ALL DISPLAYED
;	TASKS NO LONGER IN THE TASK TABLE ARE ERASED FROM THE 
;	DISPLAY.
;
;	WE COMPARE THE VALUE IN "NBRCNT" TO THE VALUE IN "SAVCNT".
;	IF "NBRCNT" IS LESS THAN "SAVCNT", WE ERASE ALL DISPLAYED
;	LINES UP TO "SAVCNT" (THE DIFFERENCE BETWEEN NBRCNT AND
;	SAVCNT).
;
;
;
;
;	FIRST WE DISPLAY (OR ERASE) THE BUFFER OVERFLOW MESSAGE.
;
	BIT	#3,ERRFLG	; ANY PROCESSING REQUIRED?
	BEQ	10$
	BIT	#1,ERRFLG	; IF YES, WAS ERROR ON THIS PASS?
	BEQ	5$		; IF NOT, WE ERASE THE EXISTING DISPLAY.
	BIT	#2,ERRFLG	; IF YES, WE DETERMINE IF MSG IS ALREADY DSPLYD
	BEQ	8$		; IF NOT, WE WRITE.
	BIC	#1,ERRFLG	; IF YES, WE SIMPLY CLEAR INDICATION AND
	BR	10$		; CONTINUE.
5$:
	DIR$	#EBFOVF		; ERASE THE MESSAGE AND
	BIC	#2,ERRFLG	; CLEAR BIT TO INDICATE THAT MSG IS ERASED.
	BR	10$		; AND CONTINUE.
8$:
	DIR$	#BUFOVF		; WRITE THE MESSAGE AND
	BIS	#2,ERRFLG	; SET BIT INDICATING THAT MESSAGE IS THERE
	BIC	#1,ERRFLG	; AND CLEAR ERROR BIT.
10$:
	MOV	NBRCNT,R1	; GET THE TOTAL TASKS IN THE ATL (THIS PASS)
	MOV	SAVCNT,R2	; AND THE NUMBER TASKS (LAST PASS)
	SUB	R1,R2		; COMPUTE DIFFERENCE.
	BMI	80$		; IF MINUS OR
	BEQ	80$		; ZERO NO NEED TO ERASE.
20$:
	INCB	ROW1		; BUMP TO NEXT ROW.
	CMPB	ROW1,#MAXROW	; ARE WE AT LAST ROW IN A COLUMN?
	BLE	30$
	MOVB	COL1,DUMMY	; BUMP UP COLUMN
	ADD	#NXCOL,DUMMY	;
	MOVB	DUMMY,COL1	;
	MOVB	#FRW,ROW1	; AND RESET ROW POINTER.
30$:
	MOVB	ROW1,ROW3	; SET ROW AND
	MOVB	COL1,COL3	; COLUMN FOR ERASE
	DIR$	#ETOEND		; AND ERASE THE LINE
	SOB	R2,20$		; LOOP TO ERASE ALL LINES.
80$:
	MOV	NBRCNT,SAVCNT	; SAVE TOTAL COUNT FOR NEXT PASS.
	RTS	PC
	.PAGE
	.SBTTL	QIO READ AST
AST:
	MOV	(SP)+,R1	; GET STATUS BUFFER ADDRESS
	TSTB	(R1)		; CHECK STATUS
	BMI	10$		; IF CTRL Z BYPASS READ REISSUE
	DIR$	#RDSC		; REISSUE READ
10$:
	ASTX$C			; EXIT THE AST
	.PAGE
	.SBTTL	UPDATE TIME SUBROUTINE
UPDTIM:
	.IRP	X,<R0,R1,R2,R3,R4,R5>
	MOV	X,-(SP)
	.ENDM
	GTIM$S	#TIMBUF		; GET TIME OF SYSTEM
	MOV	#6,R1		; CHECK DATE AND TIME
	MOV	#SAVTIM,R2
	MOV	#TIMBUF,R3	;
10$:
	CMP	(R2)+,(R3)+	; ANY TIME CHANGE??
	BNE	50$
	SOB	R1,10$
	JMP	100$
50$:
	MOV	#6,R1		;IF CHANGE, SAVE CURRENT TIME
	MOV	#SAVTIM,R2	; SAVE AREA
	MOV	#TIMBUF,R3
55$:
	MOV	(R3)+,(R2)+	; SAVE THE TIME...
	SOB	R1,55$
;
;
	MOV	#DATOUT,R0	; OUTPUT ARES FOR DATE
	MOV	#TIMBUF,R1	; OUR CURRENT TIME
	CALL	$DAT		; CONVERT TO ASCII
	MOV	#TIMOUT,R0	; OUTPUT AREA FOR TIME
	MOV	#3,R2		; FORMAT IS HH:MM:SS
	CALL	$TIM		; CONVERT TO ASCII
	DIR$	#DTOUT		; WRITE OUT DATE AND TIME
100$:
	.IRP	X,<R5,R4,R3,R2,R1,R0>	; RESTORE
	MOV	(SP)+,X
	.ENDM
	RTS	PC
	.PAGE
	.SBTTL	WRTLIN - WRITE LINE TO TERMINAL SUBROUTINE
WRTLIN:
	BITB	#1,TB.IOS(R5)		;IS THIS A NEW LINE?
	BEQ	50$			; IF NOT, STATUS ONLY CHANGED.
	MOV	#LN1OUT,LINE+Q.IOPL	; IF YES, USE FULL LINE
	MOV	#LINE1S,LINE+Q.IOPL+2	; AND SIZE.
	MOV	#TSKOUT,R0		; OUTPUT AREA FOR TASK NAME.
	MOV	TB.TSK(R5),R1		; GET FIRST WORD.
	CALL	$C5TA			; CONVERT TO ASCII (FROM RAD50)
	MOV	TB.TSK+2(R5),R1		; AND NEXT WORD.
	CALL	$C5TA			; CONVERT TO ASCII.
;
;	NOW UPDATE TI.
;
	MOV	#WORK,R0		; WORK AREA
	MOVB	TB.TIU(R5),R1		; GET TI UNIT NUMBER
	MOV	#1,R2			; DONT ZERO SUPPRESS.
	CALL	$CBOMG			; CONVERT TO OCTAL ASCII
	MOV	#TIOUT,R0		; OUTPUT AREA FOR TI.
	MOVB	TB.TIN(R5),(R0)+	; MOVE NAME AND NUMBER TO OUTPUT AREA
	MOVB	TB.TIN+1(R5),(R0)+	;
	MOVB	WORK+4,(R0)+		; UNIT NUMBER
	MOVB	WORK+5,(R0)+		;
	MOV	#WORK,R0		; WORK AREA
	MOVB	TB.PRI(R5),R1		; GET PRIORITY
	BIC	#177400,R1		; CLEAR OUT HIGH BYTE
	CALL	$CBDMG			; CONVERT TO OCTAL ASCII
	MOV	#TSKPRI,R0		; OUTPUT AREA FOR IT
	MOVB	WORK+2,(R0)+		; PRIORITY
	MOVB	WORK+3,(R0)+
	MOVB	WORK+4,(R0)+
	BR	60$
;
;	USE SHORT LINE ONLY TO UPDATE STATUS ON DISPLAY.
;
50$:
	MOV	#LN2OUT,LINE+Q.IOPL	; USE SHORT LINE
	MOV	#LINE2S,LINE+Q.IOPL+2	; LENGTH OF LINE.
	MOVB	ROW1,ROW2		; USE SAME ROW.
	MOVB	COL1,DUMMY		; USE COL1 + STAOFF.
	ADD	#STAOFF,DUMMY		; ADD OFFSET
	MOVB	DUMMY,COL2		; MOVE TO NEW COLUMN NUMBER.
;
;	SEARCH STATUS TABLE TO FIND MATCH...
;
60$:
	MOVB	TB.STA(R5),R1		; GET STATUS.
	MOV	#STATBL,R2		; START OF TABLE
70$:
	CMP	R1,(R2)+		; MATCH??
	BEQ	80$			; YES.
	ADD	#2,R2			; IF NOT, OFFSET TO NEXT ENTRY.
	CMP	(R2),#144444		;END OF LIST?
	BNE	70$			;BR IF YES
	TST	(R2)+			;NO--POINT TO 'XXX'
80$:
	MOV	#STAOT1,R0		; ADDRESS OF OUTPUT AREA.
	MOV	(R2),R1			; GET RAD50 STATUS
	CALL	$C5TA			; CONVERT TO ASCII
	CMPB	STAOT1,#'I		; COULD THIS BE THE NULL TASK
	BNE	85$			; NO
	CMPB	STAOT1+1,#'D		; IS IT
	BNE	85$			; NO
	MOVB	#' ,TIOUT+2		; BLANK OUT UNIT NUMBER
	MOVB	#' ,TIOUT+3
85$:	MOVB	STAOT1,STAOT2		; SECOND OUTPUT AREA
	MOVB	STAOT1+1,STAOT2+1
	MOVB	STAOT1+2,STAOT2+2
100$:
	DIR$	#LINE			; WRITE THE LINE OUT
;
;
	CLRB	TB.IOS(R5)		; CLEAR STATUS FOR THIS TBL ENTRY.
	RTS	PC			; RETURN TO MAIN.
	.PAGE
	.SBTTL	WRTNOD - UPDATE NODE DISPLAY SUBROUTINE
WRTNOD:
	TST	TOTNO2		; THIS THE FIRST TIME HERE?
	BNE	10$
	DIR$	#NODHED		; WRITE IT.
10$:
	CMP	TOTNO1,TOTNO2	; ANY CHANGE IN TOTAL NODE COUNT?
	BEQ	50$		; IF NOT, SKIP WRITE.
;
;
	MOV	#NODOUT,R2	; BLANK OUT OUTPUT AREA
	MOV	#5,R1
15$:
	MOVB	#040,(R2)+	;
	SOB	R1,15$
;
	CLR	R2		; ZERO SUPPRESS.
	MOV	TOTNO1,R1	; THE TOTAL COUNT.
	ASH	#-4,R1		; DIVIDE BY 16.
	MOV	R1,DUMMY1
	MOV	#NODOUT,R0	; PUT THE ASCII CHARS HERE.
	CALL	$CBDMG		; CONVERT TO ASCII
	DIR$	#NODMSG		; AND WRITE THE COUNT
	MOV	TOTNO1,TOTNO2	; SAVE THE CURRENT TOTAL
50$:
	CMP	HOLNO1,HOLNO2	; WAS THERE A CHANGE IN LARGEST HOLE?
	BEQ	100$
	MOV	#HOLOUT,R2	; IF YES,  BLANK OUT OUTPUT AREA
	MOV	#5,R1
55$:
	MOVB	#040,(R2)+	;
	SOB	R1,55$
	CLR	R2		; ZERO SUPPRESS
	MOV	HOLNO1,R1	; GET THE COUNT.
	ASH	#-4,R1		; DIVIDE BY 16.
	MOV	#HOLOUT,R0	; PUT THE CHARACTERS HERE.
	CALL	$CBDMG		; CONVERT TO ASCII
	DIR$	#HOLMSG		; AND WRITE THE LINE.
	MOV	HOLNO1,HOLNO2	; SAVE THE CURRENT HOLE COUNT.
100$:
;
;
;	PERFORM YELLOW AND RED WARNING PROECSSING HERE.
;
	CMP	DUMMY1,#REDLMT		; RED LIMIT REACHED??
	BGT	150$			; NO
;
;	RED LIMIT REACHED!!!!!!!!
;
	BIT	#10,ERRFLG		; ERROR MSG ALREADY DISPLAYED?
	BNE	180$			; YES.
	DIR$	#REDMSG			; IF NOT, DISPLAY IT.
	BIS	#10,ERRFLG		; AND SET ERR FLG.
	BR	180$
150$:
;
;	CHECK YELLOW THRESHOLD
;
	CMP	DUMMY1,#YELLMT		; YELLOW LIMIT?
	BGT	160$			; NO
;
;	YELLOW LIMIT REACHED!!!!!!!!!
;
	BIT	#4,ERRFLG		; ERROR MSG ALREADY DISPLAYED?
	BNE	180$			; YES.
	DIR$	#YELMSG			; IF NOT, DISPLAY IT.
	BIS	#4,ERRFLG		; AND SET FLAG.
	BR	180$
160$:
	BIT	#14,ERRFLG		; WE HAVE ENOUGH NODES, WERE THE
	BEQ	180$			; MSGS PREVIOUSLY DISPLAYED??
	DIR$	#EWRMSG			; IF YES, ERASE IT.
	BIC	#14,ERRFLG		; AND CLEAR BITS
180$:
	RTS	PC
	.PAGE
	.SBTTL	DATA DEFINITIONS
TOTNO1:	.WORD	0		; HOLD FOR CURRENT TOTAL COUNT (THIS PASS)
TOTNO2:	.WORD	0		; HOLD FOR PREVIOUS PASS TOTAL NODE COUNT
HOLNO1:	.WORD	0		; HOLD FOR LARGEST HOLE THIS PASS
HOLNO2:	.WORD	0		; HOLD FOR LARGEST HOLE LAST PASS
TIMBUF:	.BLKW	8.
WORK:	.BLKB	6
SAVTIM:	.BLKW	8.
IOSTAT:	.BLKW	2
RDSTAT:	.BLKW	2		;I/O STATUS FOR READ
NEWFLG:	.WORD	0
ERRFLG:	.WORD	0		; SET TO 1 IF BUFFER OVERFLOW OCCURS
NBRCNT:	.WORD	0		; COUNTER FOR NUMBER OF TASKS IN ATL
SAVCNT:	.WORD	0		; SAVE FOR ABOVE COUNT.
;
;
NENTRY	= <<<MAXCOL-TCL>-<FCL-TCL>>/NXCOL>*<MAXROW-TCL>
TBLSIZ	=	NENTRY*5	; 5 WORDS PER ENTRY
;
;	FORMAT OF TABLE IS AS FOLLOWS:
;
TB.TSK	=	0		; FIRST 2 WORDS ARE TASK NAME (RAD50)
TB.TIN	=	4		; 3RD WORD IS TI NAME (ASCII)
TB.TIU	=	6		; 4TH WORD IS TI UNIT (BINARY) AND
TB.STA	=	7		; TASK STATUS (BINARY)
TB.IOS	=	10		; 5TH WORD IS STATUS OF ENTRY (BITMAP)
TB.PRI	=	11		; TASK PRIORITY
TB.SIZ	=	TB.IOS+2	; SIZE OF EACH ENTRY.
;
;
;
TSKTBL:	.BLKW	TBLSIZ		;TASK TABLE - CORE IMAGE OF ATL DISPLAY
TBLEND	=.			;ESTABLISH END OF TABLE ADDRESS
;
;
	.MACRO	STAM	P1	;MACRO FOR DEFINING ENTRIES IN STATUS TABLE
	.WORD	TS.'P1
	.RAD50	/P1/
	.ENDM	STAM
;
;
STATBL:				; STATUS TYPES TABLE
	STAM	LRP		; LOAD REQUEST PENDING
	STAM	LRQ		; LOAD REQUEST QUEUED
	STAM	LRS		; LOAD REQUEST SUCCESSFUL
	STAM	LRF		; LOAD REQUEST FAILED
	STAM	LRG		;
	STAM	DIF		;
	STAM	DOL		;
	STAM	DOT		;
	STAM	IDL		;
	STAM	INS		;
	STAM	MRE		;
	STAM	MRR		;
	STAM	MRL		;
	STAM	RUN		; TASK RUNNABLE
	STAM	AST		; TASK SERVICING AST
	STAM	SUS		; TASK SUSPENDED
	STAM	STP		;
	STAM	ST0		;
	STAM	ST1		;
	STAM	ST2		;
	STAM	ST3		;
	STAM	ST4		;
	STAM	WF0		; WAIT FOR EVENT FLAG GRP 0
	STAM	WF1		; WAIT FOR EVENT FLAG GRP 1
	STAM	WF2		; WAIT FOR EVENT FLAG GRP 2
	STAM	WF3		; WAIT FOR EVENT FLAG GRP 3
	STAM	WF4		; WAIT FOR EVENT FLAG GRP 4
	STAM	EXT		; TASK EXITED
	STAM	IR1		; I/O RUNDOWN REQUESTED
	STAM	IR2		; I/O RUNDOWN PENDING
	STAM	IR3		; I/O RUNDOWN COMPLETED
	STAM	IR4		; I/O RUNDOWN FAILED
	STAM	TFF		; EXECUTION FAULT/TERMINATION
	STAM	TNR		; TERMINATION REQUESTES
	STAM	TSE		;
	STAM	TS1		;
	STAM	TS2		;
	STAM	USE		;
	STAM	WDI		;
	STAM	WND		;
	STAM	WSM		;
	STAM	STN		; SUSPENDED UNTIL TERMINATION NOTICE
	STAM	SFC		; SUSPENDED FOR CHECKPOINTING
	STAM	RRQ		; RECORD REQUEST QUEUED
	STAM	RRS		; RECORD REQUEST SUCCESSFUL
	STAM	RRF		; RECORD REQUEST FAILED
	STAM	PAR		; PARITY ERROR (TASK SUSPENDED)
	STAM	EX1		; EXIT ENTRY AFTER ACCOUNTING WRITE
	STAM	WAC		; WAITING FOR ACCOUNTING WRITE
	STAM	RLA		; RELOADED FOR AST CHECK
	STAM	MEX
	.WORD	144444			;END OF LIST
	.RAD50	/XXX/
;
;
;
;
;
GETMCR:	GMCR$
CLRSCN:	QIOW$	IO.WLB!TF.WAL,TILUN,EF1,,IOSTAT,,<CLRIT,CLRS,0>
LINE:	QIOW$	IO.WLB!TF.WAL,TILUN,EF1,,IOSTAT,,<0,0,0>
DTOUT:	QIOW$	IO.WLB!TF.WAL,TILUN,EF1,,IOSTAT,,<DATLIN,DATSIZ,0>
RDSC:	QIO$	IO.RNE,TILUN,,,RDSTAT,AST,<DUMMY,1>
KILLRD:	QIOW$	IO.KIL,TILUN,EF1,,RDSTAT
ETOEND:	QIOW$	IO.WLB!TF.WAL,TILUN,EF1,,IOSTAT,,<CLREST,CLRSIZ,0>
BUFOVF:	QIOW$	IO.WLB!TF.WAL,TILUN,EF1,,IOSTAT,,<BERR,BERRS,0>
EBFOVF:	QIOW$	IO.WLB!TF.WAL,TILUN,EF1,,IOSTAT,,<EBERR,EBERRS,0>
NODHED:	QIOW$	IO.WLB!TF.WAL,TILUN,EF1,,IOSTAT,,<NODH,NODHS,0>
NODMSG:	QIOW$	IO.WLB!TF.WAL,TILUN,EF1,,IOSTAT,,<NODM,NODS,0>
HOLMSG:	QIOW$	IO.WLB!TF.WAL,TILUN,EF1,,IOSTAT,,<HOLM,HOLS,0>
REDMSG:	QIOW$	IO.WLB!TF.WAL,TILUN,EF1,,IOSTAT,,<REDM,REDMS,0>
YELMSG:	QIOW$	IO.WLB!TF.WAL,TILUN,EF1,,IOSTAT,,<YELM,YELMS,0>
EWRMSG:	QIOW$	IO.WLB!TF.WAL,TILUN,EF1,,IOSTAT,,<WMERA,WMERAS>
;
;
;	NODE DISPLAY STRINGS...
;
NODH:	.BYTE	ESC,DCA,NRW,NCL
	.ASCII	/* TOTAL FREE NODES = /
OF1	=.-NODH-4
	.ASCII	/00000/
	.ASCII	/   LARGEST HOLE = /
OF2	=.-NODH-4
	.ASCII	/00000 */
NODHS	=.-NODH
;
NODM:	.BYTE	ESC,DCA,NRW,NOC
NODOUT:	.BLKB	5
NODS	=.-NODM
;
HOLM:	.BYTE	ESC,DCA,NRW,HOC
HOLOUT:	.BLKB	5
HOLS	=.-HOLM
;
;
REDM:	.BYTE	ESC,DCA,WNRW,WNCL
	.ASCII	<BEL> /***** WARNING - /
	.BYTE	ESC,BLNK
	.ASCII	/RED/
	.BYTE	ESC,BLNK
	.ASCII	/ LEVEL NODE CONDITION *****/
REDMS	=.-REDM
;
YELM:	.BYTE 	ESC,DCA,WNRW,WNCL
	.ASCII	<BEL> /***** WARNING - /
	.BYTE	ESC,BLNK
	.ASCII	/YELLOW/
	.BYTE	ESC,BLNK
	.ASCII	/ LEVEL NODE CONDITION *****/
YELMS	=.-YELM
;
;
WMERA:	.BYTE	ESC,DCA,WNRW,WNCL,ESC,EOL
WMERAS	=.-WMERA
;
;
;
	.EVEN
DUMMY:	.WORD	0
DUMMY1:	.WORD	0
;
;
CLREST:	.BYTE	ESC,DCA
ROW3:	.BYTE	0
COL3:	.BYTE	0
	.BYTE	ESC,EOL
CLRSIZ	=.-CLREST
;
;
LN1OUT:	.BYTE	ESC,DCA
ROW1:	.BYTE	0
COL1:	.BYTE	0
TSKOUT:	.BLKB	6
	.ASCII	/ /
TSKPRI:	.BLKB	3
	.ASCII	/ /
STAOT1:	.BLKB	3
	.ASCII	/ /
TIOUT:	.BLKB	4
LINE1S	=.-LN1OUT
	.EVEN
LN2OUT:	.BYTE	ESC,DCA
ROW2:	.BYTE	0
COL2:	.BYTE	0
STAOT2:	.BLKB	3
LINE2S	=.-LN2OUT
	.EVEN
;
;
CLRIT:	.BYTE	ESC,HOM,ESC,EOS
CLRS	=.-CLRIT
;
;
;
DATLIN:	.BYTE	ESC,HOM
DATOUT:	.BLKB	9.		;THIS FOR THE CURRENT DAY
	.ASCII	/ /
TIMOUT:	.BLKB	8.		;THIS IS FOR THE CURRENT TIME
DATSIZ	=.-DATLIN
;
;
;
;
BERR:	.BYTE	ESC,DCA,RBE,CBE
	.ASCII	/** DISPLAY LIMIT REACHED **/
BERRS	=.-BERR
;
;
EBERR:	.BYTE	ESC,DCA,RBE,CBE
	.BYTE	ESC,EOL
EBERRS	=.-EBERR
	.EVEN
	.END	START