.TITLE	DEMO
	.IDENT	/12/
 
;
; COPYRIGHT   1975,  DIGITAL  EQUIPMENT  CORP.,  MAYNARD,   MASS.
;
; THIS SOFTWARE IS FURNISHED TO PURCHASER UNDER A LICENSE FOR USE
; ON A  SINGLE COMPUTER SYSTEM AND CAN BE COPIED (WITH INCLUSION
; OF DEC'S COPYRIGHT NOTICE) ONLY FOR USE IN SUCH SYSTEM, EXCEPT
; AS MAY OTHERWISE BE PROVIDED IN WRITING BY DEC.
;
; THE  INFORMATION IN THIS DOCUMENT IS SUBJECT TO CHANGE WITHOUT
; NOTICE AND  SHOULD NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL
; EQUIPMENT CORPORATION.
;
; DEC  ASSUMES NO  RESPONSIBILITY  FOR  THE  USE  OR RELIABILITY
; OF ITS  SOFTWARE ON  EQUIPMENT WHICH  IS NOT SUPPLIED BY DEC.
;
; VERSION 01
;
; D. N. CUTLER 7/JUN-75
;
; MODIFIED BY
;
; BRUCE BOSWELL 19 AUG 75
;
;
;	MODIFICATIONS:
;
; NO.	DATE		PROGRAMMER	PURPOSE
; ---	----		----------	-------
;
; 001	23-FEB-76	R. NEWLAND	CONDITIONLISE IAS VERSION
; 002	18-AUG-76	JOHN HARPER	ADD VT52 SUPPORT
; 003	18-AUG-76	JOHN HARPER	EXIT ON CTRL-C
; 004	18-AUG-76	JOHN HARPER	SPEED UP DISPLAY
; 005	18-AUG-76	JOHN HARPER	ADD ACTIVE TASK
; 006	19-AUG-76	JOHN HARPER	ADD VT50 SUPPORT
; 007	19-AUG-76	JOHN HARPER	CLEANING UP
; 008	06-SEP-76	JOHN HARPER	REVERSE AST DPB, TERMINATE ON ^Z
; 009	16-SEP-76	JOHN HARPER	CANCEL MARKTIMES ON INPUT AST
; 010	22-SEP-76	JOHN HARPER	CHECK FOR START OF TASK OFF SCREEN
; 011	22-SEP-76	JOHN HARPER	ADD 'COMMANDS' WHILE UNDER WAY
; 012	23-SEP-76	JOHN HARPER	ADD B AND G COMMANDS
; 013	17-OCT-76	JOHN HARPER	FIX UP FOR IAS
; 014	10-FEB-77	JOHN HARPER	ADD 'I' AND 'E' COMMANDS
; 015	10-FEB-77	JOHN HARPER	DIFFERENT DISPLAY FORMAT
; 016	15-APR-77	JOHN HARPER	USE EXTTSK, SOME CLEANING UP
; 017	13-JUN-77	JOHN HARPER	FIX BUGS WITH STRANGE DISPLAY PARAMETERS
; 018	03-SEP-77	RICHARD NEWLAND	CHANGES FOR IAS V03
; 019	14-JUN-78	RAY FRENCH	EXPAND MRL DISPLAY TO TWO COLUMNS
;					AND ADD TIMESHARED TASKS TO IT
; 020	14-JUN-78	RAY FRENCH	ADD SYSTEM UTILIZATION STATISTICS (IAS)
;
.PAGE
; RSX11D/IAS DEMO PROGRAM TO SHOW TASK SWAPPING AND LOADING
;
;	STARTUP PROCEDURE:
;
;		MCR>DEM [ADDR]
;
;			WHERE ADDR IS THE LOWEST ADDRESS TO
;			DISPLAY.  'ADDR' IS SPECIFIED IN OCTAL
;			BLOCKS.  IF NONE IS SPECIFIED, DISPLAY
;			WILL START AT LOCATION 0.
;
;
;	OPTIONS:
;
;		128K DISPLAY WINDOW STARTING WITH ADDRESS
;		SPECIFIED AT STARTUP (SEE ABOVE).
;
;		VARIABLE TIME FOR SNAPSHOT.  VALUE FOR MARK
;		TIME IS SPECIFIED AT TASK BUILD.
;
;		SNAPSHOT CAN BE EVERY 'N' SECONDS OR, WITH CONDITIONAL
;		ASSEMBLY, CAN BE EVERY SIGNIFICANT EVENT.
;		CONDITIONAL ASSEMBLY PARAMETER IS 'FASTER'.
;
;		IAS VERSION USES 'C' FORM OF MACROS INSTEAD
;		OF 'S' FORM.
;
;
;	OUTPUT IS ON LUN 1. THE DEVICE ASSIGNED TO THIS LUN
;	MUST BE A VT05.
;
;
;
; MACRO LIBRARY CALLS
;

	.MCALL	DIR$,GTIM$S,MRKT$,WSIG$C,QIOW$,ASTX$C
	.MCALL	WTSE$S,MRKT$S,QIOW$C,GMCR$,EXIT$C,GLUN$
	.MCALL	EXIT$S,GTSK$S,	.INH0,	.ENB0
	.MCALL	MRKT$C,	WTSE$C
	.MCALL	SETF$S,ASTX$S,QIO$,CMKT$S				;++009
	.MCALL	MRKT$,WTSE$S						;++014
;
; EQUATED SYMBOLS
;

DSW=0				;DSW IS LOCATION 0
FASTER=0			;IF NON-ZERO - USE WSIG$ NOT WTSE$
OFFSET=31.			;CURSOR CAD OFFSET
MRLX=66.			;MRL X COORD IN DISPLAY FILE
MRLY=5.				;++002 MRL Y COORD IN DISPLAY FILE
MAXMRL=32.			;++019 MAX MRL TASKS TO DISPLAY
MAXM50=8.			;++007 MAX MRL TASKS FOR VT50
MRLBUF=8.*MAXMRL		;MENU BUFFER SIZE
				; +++018 1 LINE DELETED
SPLIT=11.			;++002 SCREEN SPLIT COORD
TASKY=4.			;++002 TASK Y COORD
DISBUF=64.*14.			;DISPLAY BUFFER SIZE
CD=16				;CURSOR DISPLAY
CR=15				;CARRIAGE RETURN
EL=36				;ERASE TO END OF LINE
ES=37				;ERASE TO END OF SCREEN
LF=12				;LINE FEED
HO=35				;HOME CURSOR
NULL=0				;NULL CHAR
ED=10				;EXPANSION DIRECTION BIT
ESC=33				;++002 ESCAPE FOR VT52
BUFSIZ=64.*8.			;++002 SIZE OF OUTPUT BUFFER
SPA=40				;++004 CODE FOR SPACE
BS=10				;++004 CODE FOR BACKSPACE
;
;
;
;++002
; MACRO TO SET UP ITEM WITH CURSOR POSITION FOR USE BY 'OUTITM'
;--002
 
	.MACRO	ITEM	X,Y,STR
	.ASCIZ	<X><Y>\STR\
	.ENDM	ITEM
 
;++015
; MACRO TO SET UP ITEM TYPE TO BE USED IN FORMATTING DISPLAY.  EACH
; ITEM TYPE HAS A NAME OF THE FORM 'DI.XXX' AND THREE CHRACTERS BEING
; RESPECTIVELY THE LEFT BRACKET, LINE AND RIGHT BRACKET CHARACTER.
;-
 
	.MACRO	DI	NAME,STR
DI.'NAME:
	.IRPC	X,^\STR\
	.ASCIZ	/X/
	.ENDR
	.ENDM	DI
 
;+
; NOW DEFINE THE ITEMS
;-
 
	DI	TSK,^/<->/	; ACTIVE TASK
	DI	FXD,^/[-]/	; FIXED INACTIVE TASK
	DI	PUR,^/<=>/	; PURE AREA
	DI	SGA,^/[=]/	; SGA
	DI	FTK,^/<+>/	; NON-CHECKPOINTABLE TASK
 
	.EVEN

;
; LOCAL DATA
;
VT05FG::.WORD	0		;++002 FLAG SET IF OUTPUT TO VT05
VT50FG::.WORD	0		;++006 FLAG SET IF OUTPUT TO VT50
EXFLG:	.WORD	0		;++003 CTRL-C AST SEEN - EXIT
UIFLG:	.WORD	0		;++008 SET ON UNSOLICITED INPUT SEEN
LASTX:	.WORD	0		;++004 X COORD OF LAST CHAR
LASTY:	.WORD	0		;++004 Y COORD OF LAST CHAR
GRAIN::	.WORD	32.		;++006 SIZE IN BYTES OF ONE COLUMN
SNDFLG:	.BYTE	0		;++016 FLAG SET IF SOME TASKS NOT DISPLAYED
TSFLG:	.BYTE	0		;++016 FLAG SET IF RUNNING AS T/S TASK
COLS:	.WORD	128.		;++006 # COLS IN DISPLAY (64 FOR VT50)
IMGSZE:	.WORD	DISBUF		;++010 IMAGE SIZE
MRLTOP:	.WORD	MRLLST+<MAXMRL*4> ;++007 TOP OF LEGAL SPACE FOR MRL
				;++007 (ALTERED FOR VT50)
CURTSK:	.RAD50	/TSKNAM/	;++005 AREA FOR NAME AND...
	.ASCII	/TT/		;++005 TI AND...
	.ASCII	/77/		;++005 UNIT NUMBER OF ACTIVE TASK
;
; DISPLAY OUTPUT MESSAGES
;

	.NLIST	BEX
CLR52:	.ASCIZ	<ESC>/H/<ESC>/J/ ;++002 HOME AND CLEAR FOR VT52
LUNMSG:	.ASCII	<7>/OUTPUT LUN ERROR - CHECK LUN 1/
LUNSIZ=.-LUNMSG
TRMMSG:	.ASCII	/INVALID TERMINAL TYPE/		;++008
TRMSIZ=.-TRMMSG
NODLN1:	ITEM	2,27.,<NODES=>
NODLN2:	ITEM	2,40.,<MAX HOLE=>
NODAD1:	ITEM	2,33.,<      >
NODAD2:	ITEM	2,49.,<      >
CORLN1:	ITEM	11.,1.,<****************************************************************>
CORLN2:	ITEM	12.,1.,<+-------+-------+-------+-------+-------+-------+-------+------->
CORLN3:	ITEM	13.,1.,<****************************************************************>
.IF DF IAS		; +++001
HDRMG1:	ITEM	1,60.,<IAS V03.0>		;++002 +++018
UTILHD:	ITEM	22.,1,< PDS  BATCH NULL  SWAP  REAL> ;+020 STATISTICS HEADER
.IFF
HDRMG1:	ITEM	1,60.,<RSX-11D V06.3>		;++015
.ENDC
HDRMG2:	ITEM	1,27.,<SYSTEM TASK ACTIVITY>	;++002
TSKLN1:	ITEM	2,1,<ACTIVE TASK=>				;++005
TSKITM:	ITEM	2,13.,<TSKNAM TT77>				;++005
RDITM:	ITEM	3,1,<                                >		;++008
RDITM2:	ITEM	3,1,< >						;++008
NTKITM:	ITEM	2,13.,<NULL TASK  >				;++005

MRLMG1:	ITEM	3,67.,<MRL:>			;++002
MRLMG2:	.ASCIZ	/XXXXXX/
	.EVEN
						;++015 SEVERAL LINES DELETED
TIMLOC:	ITEM	1,1,<                    >
SNDITM:	ITEM	3,22.,<*** SOME TASKS NOT DISPLAYED ***>		;++016
SNDNUL:	ITEM	3,22.,<                                >		;++016
	.EVEN
BEGADR:	.WORD	0		;BEGINNING SCREEN ADDRESS
ENDADR:	.WORD	0		;ENDING SCREEN ADDRESS
NODES:	.WORD	0		;NUMBER OF NODES IN THE SYSTEM
HOLE:	.WORD	0		;LARGEST HOLE SIZE
INTRVL:	.WORD	1		;++014 INTERVAL IN SECONDS BETWEEN DISPLAYS
EXTENT:	.WORD	0		;++014 AMOUNT OF MEMORY TO DISPLAY
	.EVEN
;
	.IF	DF,IAS		;+020
STATMT:	MRKT$	3,1,2		;+020 MARK TIME FOR 1 SEC ON EF 3
TOTAL1:	.BLKW	2
NULL1:	.BLKW	2
USERS1:	.BLKW	2
SWAP1:	.BLKW	2
BATCH1:	.BLKW	2
;
TOTAL2:	.BLKW	2
NULL2:	.BLKW	2
USERS2:	.BLKW	2
SWAP2:	.BLKW	2
BATCH2:	.BLKW	2
;
DTOTAL:	.BLKW	1
DNULL:	.BLKW	1
DUSERS:	.BLKW	1
DSWAP:	.BLKW	1
DBATCH:	.BLKW	1
;
UTLDAT:	.BYTE	23.,1
USRDAT:	.ASCII	/   %  /
BATDAT:	.ASCII	/   %  /
NULDAT:	.ASCII	/   %  /
SWPDAT:	.ASCII	/   %  /
OTHDAT:	.ASCIZ	/   %/
	.EVEN
	.ENDC			;+020

;
; DISPLAY OUTPUT BUFFER
;

DSBUF:	.BLKB	BUFSIZ		;++002 ROOM FOR FOUR FULL LINES

;
; CURRENT AND NEXT IMAGE DISPLAY PROTOTYPES-ADJACENCY ASSUMED
;

	.EVEN
CURIMG=.-1			;CURRENT IMAGE DISPLAY PROTOTYPE
	.BLKB	DISBUF		;
	.EVEN
DISIMG=.-1			;NEXT IMAGE DISPLAY PROTOTYPE
	.BLKB	DISBUF		;


						;++014 SEVERAL LINES DELETED
;
; DISPLAY OUTPUT QIO DPB
;
DSQIO:	QIOW$	IO.WLB!IO.WAL,1,1,,,,<DSBUF,0,0>	;++002
BUFPTR=DSQIO+Q.IOPL+0
BUFCTR=DSQIO+Q.IOPL+2
;
; GET MCR COMMAND LINE DPB
;
GETMCR:	GMCR$
;
; GET TERMINAL DPB AND IOSB
;
GETTYP:	QIOW$	SF.GSC,1,1,,IOSB,,<TC.TTP>
IOSB:	.BLKW	2
 
	.IF	DF,IAS
ATTDPB:	QIOW$	IO.ATA,1,1,,,,<,UIAST>			;++008
	.IFF
ATTDPB:	QIOW$	IO.ATA,1,1,,,,<CCAST,UIAST>		;++008
	.ENDC
DETDPB:	QIOW$	IO.DET,1,1				;++003
 
INPDPB:	QIOW$	IO.RLB!TF.TMO!TF.RNE,1,1,,IOSB,,<GETMCR+2,32.,0> ;++008/014
 
;RBFMKTDPB:	MRKT$	2,0,2				;++014 MARKTIME DPB
MKTDPB:	MRKT$	2,0,1				;++014 MARKTIME DPB

;
; TEMPORARY STORAGE FOR TIME PARAMETERS
;

TIMBUF:	.BLKW	8.		;

;
; TEMPORARY STORAGE FOR TASK LIST PARAMETERS-ADJACENCY ASSUMED
;

TSKNAM:	.BLKB	6		;TEMPORARY STORAGE FOR ASCII TASKNAME
	.WORD	0		; STOPPER
				; +++018 1 LINE DELETED
MRLLST:				;BEGINNING ADDR OF MRL STORAGE
	.BLKW	MAXMRL*2	;MRL BUFFER SPACE - 2 WORDS PER ENTRY
	.WORD	0		;FLAG WORD
	.EVEN
CURMRL=.-1
	.BLKB	MRLBUF		;CURRENT MENU DISPLAY PROTO
	.EVEN
DISMRL=.-1
	.BLKB	MRLBUF		;NEXT IMAGE DISPLAY PROTO
 
LIMIT:	.LIMIT			;++016 TOP OF TASK, I.E. START OF ATL BUFFER
BUFSTT=LIMIT+2			;++016
 
FXDBUF:	.WORD	0		;++016 END OF FIXED PART OF BUFFER
BUFEND:	.WORD	0		;++016 ADDRESS OF END OF BUFFER
 
;+
; COMMAND DECODE TABLE.  EACH ENTRY OCCUPIES TWO WORDS, AS FOLLOWS:
;
;	BYTE 00   FIRST CHARACTER OF COMMAND
;	BYTE 01   SPARE - MAY BE USED BY PROCESSOR
;	WORD 01	  ADDRESS OF PROCESSOR
;-
 
	.MACRO	COMAND	NAME,RTN,SPARE					;++011
	.BYTE	''NAME,SPARE
	.WORD	RTN
	.ENDM	COMAND
 
CMDTBL:	COMAND	B,CMDB			;++012 B - SET BASE ADDRESS
	COMAND	C,RESTRT		;++011 C - CLEAR SCREEN AND START OVER
	COMAND	E,CMDE			;++014 E - SET EXTENT OF DISPLAY
	COMAND	G,CMDG			;++012 G - SET GRANULARITY
	COMAND	I,CMDI			;++014 SET DISPLAY INTERVAL
	COMAND	X,EXIT			;++011 X - EXIT
	.WORD	0			;++011 TERMINATOR

.PAGE
;+
; **-LUNERR-ROUTINE TO OUTPUT LUN ERROR MESSAGE
;-
LUNERR:
	QIOW$C	IO.WVB,5,5,,,,<LUNMSG,LUNSIZ,40>
	EXIT$S
TRMERR:	QIOW$C	IO.WVB,5,5,,,,<TRMMSG,TRMSIZ,40>
	EXIT$S
;+
; **-RDDEMO-RSX11D TASK SWAPPING AND LOADING DISPLAY PROGRAM
;-

DEMO::	INC	VT05FG		;RBF - MAKE IT THINK IT'S A VT05
	BR	2$		;RBF - SKIP TERMINAL CHECKING
;DEMO::	DIR$	#GETTYP		;++002 GET TERMINAL TYPE
	BCS	LUNERR		;++002 J IF LUN NOT ASSIGNED
	CMPB	IOSB,#IE.IFC	;++002 FUNCTION NOT RECOGNISED?
	BEQ	2$		;++002 J IF SO, ASSUME AS BUILT
	MOV	#1,VT05FG	;++002 ASSUME VT05
	CMPB	IOSB+2,#T.VT05	;++002 VT05?
	BEQ	2$		;++002 J IF SO
	CLR	VT05FG		;++006 CLEAR VT05 FLAG
	MOV	#1,VT50FG	;++006 ASSUME VT50
	CMPB	IOSB+2,#T.VT50	;++006 WELL?
	BEQ	1$		;++006 J IF CORRECT
	CLR	VT50FG		;++006 ELSE CLEAR THE FLAG
	CMPB	IOSB+2,#T.VT52	;++002 VT52 OR HIGHER?
	BLO	TRMERR		;++002 J IF NOT, ILLEGAL TYPE
	CMPB	IOSB+2,#T.VT61	;++002 VT61 OR LESS?
	BHI	TRMERR		;++002 J IF NOT
	BR	2$		;++006 SKIP VT50 CODE
1$:	ASR	COLS		;++006 DIVIDE # COLS BY 2 FOR VT50
	SUB	#<MAXMRL-MAXM50>*4,MRLTOP ;++007 REDUCE MAX MRL ENTRIES
	ASR	IMGSZE		;++010 REDUCE MAX IMAGE SIZE
2$:	GTSK$S	#DSBUF		;++016 GET TASK SIZE
	MOV	DSBUF+G.TSTS,BUFEND ;++016 REMEMBER END OF BUFFER
	SUB	#10.,BUFEND	;++016 OFFSET BY SIZE OF ONE ATL BUFFER ENTRY
	CLRB	TSFLG		;++016 ASSUME RUNNING IN REALTIME
	MOV	.CRTSK,R0	;++016 GET MY ATL ADDRESS
	BIT	#AF.IA,A.TF(R0)	;++016 TS OR REALTIME?
	BEQ	25$		;++016 REALTIME
	INCB	TSFLG		;++016 REMEMBER THAT WE'RE TIMESHARING
25$:	DIR$	#ATTDPB		;++003 ATTACH TO THE TERMINAL AND DECLARE AST'S
	MOV	.MSIZE,EXTENT	;++014 SET INITIAL EXTENT
	CLR	R2		;++012 INIT R1 JUST IN CASE
	DIR$	#GETMCR		;GET THE COMMAND LINE
	BCS	10$		;IF NONE JUST START
	MOV	DSW,R5		;GET CHAR COUNT OF MCR COMMAND LINE
	SUB	#3,R5		;ANY MORE THAN TASK NAME
	BEQ	10$		;BR IF NO - START
	MOV	#GETMCR+G.MCRB+3,R1 ;++012ADDR OF 1ST CHAR AFTER TASK NAME
3$:
	CMPB	#' ,(R1)+	;++012 IS IT A BLANK
	BEQ	5$		;BR IF YES - FOUND
	SOB	R5,3$		;LOOP TIL DONE OR FOUND
	BR	10$		;NO BLANK FOUND - START
5$:
	CALL	CMTB		;++012 CONVERT MEMORY TO BINARY
10$:
	MOV	R2,BEGADR	;++012 SAVE BEGINNING ADDR
	SUB	R2,EXTENT	;++014 AND DISPLAY TO TOP OF MEMORY
RESTRT:	MOV	BEGADR,ENDADR	;++012 SAVE ENDING
	MOV	EXTENT,R3	;++014 EXPLICIT EXTENT?
	BEQ	15$		;++014 J IF NOT
	ADD	R3,ENDADR	;++014 ELSE SET END ADR
	ASH	#-6,R3		;++014 CONVERT TO # COLUMNS
	TST	VT50FG		;++014 RUNNING FOR VT50?
	BNE	13$		;++014 J IF NOT
	ASR	R3		;++014 ELSE WE HAVE ONLY 1/2 THE COLS
13$:	MOV	R3,GRAIN	;++014 SET DISPLAY GRANULARITY
	BR	30$		;++014 DON'T PROCESS GRAIN STUFF
15$:	MOV	GRAIN,R3	;++006 GET SIZE OF ONE COLUMN
	ASH	#6,R3		;++006 MULTIPLY BY 64 (#COLUMNS)
	TST	VT50FG		;++006 RUNNING ON VT50?
	BNE	20$		;++006 J IF SO
	ASL	R3		;++006 ELSE WE HAVE 128 COLUMNS
20$:	ADD	R3,ENDADR	;++006 MOVE UP TO ENDING ADDRESS
30$:	MOV	BEGADR,R1	;++012 PICK UP START ADDRESS
				;++017 LINE DELETED
	MOV	#CORLN1+2,R4	;++002 ADDR OF MESSAGE
	CALL	LINGEN		;GENERATE ADDRESS LINE
	MOV	#CORLN3+2,R4	;++002 ADDR OF MESSAGE
	MOV	R3,R1		;RECYCLE LAST ADDRESS USED IN LINGEN
	CALL	LINGEN		;GENERATE 2ND ADDRESS LINE
	CALL	CLRSCR		;++011 CLEAR THE SCREEN

;+
; **-DSCON-DISPLAY CONSTANT PART OF IMAGE
;-

DSCON:
	MOV	#HDRMG2,R3	;++007 DISPLAY FIRST HEADER MESS
	CALL	OUTITM		;++007 DISPLAY THE ITEM
	MOV	#HDRMG1,R3	;++007 DISPLAY SYSTEM IDENTIFICATION
	CALL	OUTITM		;++007 DISPLAY THE ITEM
	TSTB	TSFLG		;++016 RUNNING IN T/S?
	BNE	2$		;++016 J IF SO, NO ACTIVE TASK DISPLAY
	MOV	#TSKLN1,R3	;++007 'ACTIVE TASK='
	CALL	OUTITM		;++007 DISPLAY THE ITEM
2$:	MOV	#NODLN1,R3	;++007 'NODES='
	CALL	OUTITM		;++007 DISPLAY THE ITEM
	MOV	#NODLN2,R3	;++007 'MAX HOLE='
	CALL	OUTITM		;++007 DISPLAY THE ITEM
	MOV	#CORLN1,R3	;POINT TO FIRST MEMORY DISPLAY LINE
	CALL	OUTITM		;++002 DISPLAY LINE
	MOV	#CORLN2,R3	;POINT TO SECOND MEMORY DISPLAY LINE
	CALL	OUTITM		;++002 DISPLAY LINE
	TST	VT50FG		;++006 RUNNING ON VT50?
	BNE	3$		;++006 YES, DON'T PRINT SECOND LINE
	MOV	#CORLN3,R3	;POINT TO THIRD MEMORY DISPLAY LINE
	CALL	OUTITM		;++002 DISPLAY LINE
3$:
	MOV	BUFSTT,R0	;++016 GET ATL BUFFER START
	CLR	(R0)+		;++016 CLEAR FLAG AT START
	CMP	@#KP.AR0,BEGADR	;++016 WILL THE EXEC FIT ON THE DISPLAY?
	BLO	5$		;++016 J IF NOT
	MOV	#^RC  ,(R0)+	;++016 ELSE SET UP EXEC ENTRY
	MOV	#^REXE,(R0)+	;++016 ...
	MOV	#DI.FTK,(R0)+	;++016 DISPLAY AS NON-CHECKPOINTABLE TASK
	MOV	#.SG.EX,R5	;++016 GET EXEC SIZE IN BYTES
	ADD	#77,R5		;++016 ROUND TO 32-WD BLOCK BOUNDARY
	ASH	#-6,R5		;++016 MAKE BLOCKS
	MOV	R5,(R0)+	;++016 AND STORE IN BUFFER
	MOV	@#KP.AR0,(R0)	;++017 SET UP EXEC START ADDRESS
	ADD	(R0)+,R5	;++017 MAKE END ADDRESS
	CMP	R5,ENDADR	;++017 EXEC OFF END OF SCREEN?
	BLOS	5$		;++017 J IF NOT
	SUB	#10.,R0		;++017 ELSE BACK OFF FROM EXEC
5$:	MOV	#KP.DR7,R5	;++016 NOW LOOK FOR SCOMM...
	MOV	#3,R4		;++016 GET MAX # APRS
	MOV	#200,R3		;++017 SET SCOM TO 4K INITIALLY
10$:	BIT	#ED,-(R5)	;++016 FOUND SCOM BASE YET?
	BNE	20$		;++016 J IF SO
	ADD	#200,R3		;++016 ELSE ADD ANOTHER APR'S WORTH
	SOB	R4,10$		;++016 AND KEEP GOING
20$:	MOVB	1(R5),R4	;++016 GET SIZE OF FIRST SCOM APR
	INC	R4		;++016 ALLOW FOR HARDWARE PFFSET
	SUB	R4,R3		;++016 SUBTRACT OUT FROM TOTAL SIZE
	CMP	40(R5),BEGADR	;++016 BASE OF SCOM OFF SCREEN?
	BLO	30$		;++016 J IF SO, DON'T DISPLAY IT
	MOV	#^RM  ,(R0)+	;++016 SET UP SCOM NAME
	MOV	#^RSCO,(R0)+	;++016 ...
	MOV	#DI.FTK,(R0)+	;++016 DISPLAY AS FIXED TASK
	MOV	R3,(R0)+	;++016 SET SIZE
	MOV	40(R5),(R0)	;++017 AND BASE
	ADD	(R0)+,R3	;++017 FORM END ADDRESS
	CMP	R3,ENDADR	;++017 BEYOND END OF DISPLAY?
	BLOS	30$		;++017 J IF NOT
	SUB	#10.,R0		;++017 ELSE BACK OFF FROM SCOMM
30$:
	MOV	R0,FXDBUF	;++016 REMEMBER END OF THIS PART
;
	.IF	DF,IAS		;+020
	MOV	#UTILHD,R3	;+020 DISPLAY UTILIZATION HEADER
	CALL	OUTITM		;+020
;+020 NOW READ THE INITIAL VALUES OF IAS STATISTICS
	MOV	#.SSTIM,R0	;+020 POINT TO START OF STATISTICS
	MOV	#TOTAL1,R1	;+020 AND WHERE TO PUT THEM
	MOV	#10.,R2		;+020 TOTAL OF 10. WORDS
	.INH0			;+020 INHIBIT TASK SWITCHING TO READ THEM
40$:	MOV	(R0)+,(R1)+	;+020 SAVE 'EM
	SOB	R2,40$		;+020
	CALL	..ENB0		;+020 AND ENABLE TASK SWITCHING
	DIR$	#STATMT		;+020 ISSUE STATISTICS MARK TIME
	.ENDC			;+020
;
;+
; **-DSPAR-DISPLAY PARTITION CONFIGURATION AND SET UP MRL LISTHEADS
;-

DSPAR:

	MOV	#MRLMG1,R3	;POINT TO MRL DISPLAY HEADER
	CALL	OUTITM		;++002 DISPLAY LINE
				; +++018 13 LINES DELETED

;+
; **-DSCON-DISPLAY CONTROL
;-

DSCTL:	CALL	INIBUF		;INITIALIZE OUTPUT DISPLAY PROTOTYPES
MKT:	MOV	INTRVL,MKTDPB+M.KTMG ;++014 SET MARKTIME INTERVAL
	BEQ	5$		;++014 J IF NO INTERVAL
	DIR$	#MKTDPB		;++014 ELSE MARK TIME
5$:
	CALL	INIDIS		;INITIALIZE NEXT DISPLAY PROTOTYPE
	CALL	DSTIM		;DISPLAY TIME AND TASKS
	TST	INTRVL		;++0014 MARKING TIME?
	BEQ	10$		;++014 DON'T WAIT IF NOT
	WTSE$S	#2		;++014 ELSE WAIT
10$:	TST	EXFLG		;++003 EXIT REQUIRED?
	BNE	EXIT		;++003 J IF SO
	TST	UIFLG		;++008 UNSOLICITED INPUT SEEN?
	BEQ	MKT		;++016 J IF NOT
RDINPT:	CLR	UIFLG		;++008 CLEAR FLAG FOR NEXT TIME
	CMKT$S			;++009 CANCEL OUTSTANDING MARKTIMES
	MOV	#RDITM,R3	;++008 CLEAR READ AREA OF SCREEN
	CALL	OUTITM
	MOV	#RDITM2,R3	;++008 NOW REPOSITION THE CURSOR
	CALL	OUTITM		;++008
	CALL	OUTBUF		;++008 FLUSH THE BUFFER
	DIR$	#INPDPB		;++008 READ A LINE
				;++012 LINES DELETED
	CMPB	IOSB,#IE.EOF	;++008 WAS IT CONTROL-Z?
	BEQ	EXIT		;++011 STRAIGHT OUT IF SO
	CMPB	IOSB,#IS.TMO	;++014 NO COMPLETE LINE?
	BEQ	MKT		;++014 IGNORE LINE IF SO, MUST BE ODD
	JMP	COMAND		;++011 ELSE GO DECODE COMMAND

EXIT:	CALL	CLRSCR		;++003 CLEAR THE SCREEN
	CALL	OUTBUF		;++004 FLUSH OUTPUT BUFFER
	DIR$	#DETDPB		;++003 DETACH FROM THE TERMINAL
	EXIT$S			;++003 FAREWELL!
 

;+
; **-DSTIM-DISPLAY CURRENT TIME OF DAY
;-

DSTIM:				; +++001
	GTIM$S	#TIMBUF		;++002 GET CURRENT TIME PARAMETERS
	MOV	#TIMLOC+2,R0	;++002 POINT TO CONVERSION BUFFER
	MOV	R0,R3		;COPY ADDRESS OF CONVERSION BUFFER
	MOV	#TIMBUF,R1	;POINT TO TIME PARAMETERS
	CALL	$DAT		;CONVERT DATE
	MOVB	#' ,(R0)+	;INSERT A SPACE
	MOV	#3,R2		;;SET TO CONVERT HOURS, MINUTES, AND SEC
	CALL	$TIM		;CONVERT TIME PARAMETERS TO ASCII
	CLRB	(R0)		;SET ZERO SENTINEL BYTE
	MOV	#TIMLOC,R3	;++002 GET TIME STRING
	CALL	OUTITM		;++002 AND OUTPUT IT

;+
; **-DISPLAY ACTIVE TASKS THAT ARE IN MEMORY AND ON THE MRL
;-

DSTSK:
	.INH0			;INHIBIT TASK SWITCHING
DSPOOL:
	MOV	.POLLH,R4	;;GET POOL LISTHEAD
	CLR	R3		;;CLEAR 'LARGEST HOLE' COUNT
	CLR	R5		;;CLEAR TOTAL NODES COUNT
10$:
	ADD	2(R4),R5	;;ADD IN NEW HOLE SIZE
	CMP	2(R4),R3	;;IS THIS THE LARGEST HOLE SO FAR
	BLOS	20$		;;BR IF NO
	MOV	2(R4),R3	;;GET NEW SIZE
20$:
	TST	(R4)		;;DONE
	BEQ	30$		;;BR IF YES
	MOV	@R4,R4		;;MOVE TO NEXT HOLE
	BR	10$		;;LOOP TIL DONE
30$:
	MOV	R3,HOLE		;;SAVE MAX HOLE SIZE
	MOV	R5,NODES	;;SAVE TOTAL NODE COUNT
DSMRL:
	MOV	#MRLLST,R5	;;ADDR OF MRL TEMP STORAGE
	MOV	#.ATLLH,R4	;; +++018 ADDR OF ATL LISTHEAD
10$:
	MOV	(R4),R4		;; +++018 GET ATL NODE ADDRESS
	CMP	R4,.ATLLH+2	;; +++018 AT REAL-TIME NULL JOB?
	BEQ	30$		;; +++018 YES IF EQ
	MOV	A.TD(R4),R3	;; +++018 GET STD ADDRESS
	BEQ	10$		;; +++018 IF EQ THEN .T1ATL, .T2ATL OR .TNATL
;-019	BIT	#AF.IA,A.TF(R4)	;; +++018 A TIMESHARING TASK?
;-019	BNE	10$		;; +++018 YES IF NE
;RBF	CMPB	A.TS(R4),#TS.MRL ;; +++018 A 'MEMORY REQUIRED' STATE?
;RBF	BEQ	20$		;; +++018 YES IF EQ
;RBF	CMPB	A.TS(R4),#TS.MRE ;; +++018
;RBF	BNE	10$		;; +++018 NO IF NE
;RBF20$:				;; +++018
	BIT	#AF.CP,A.TF(R4)	;;RBF - TASK CHECKPOINTED?
	BEQ	10$		;;RBF - IF NOT, IGNORE IT
	MOV	S.TN+0(R3),(R5)+ ;; +++018 GET TASK NAME
	MOV	S.TN+2(R3),(R5)+ ;; +++018
	CMP	R5,MRLTOP	;;++007 BUFFER FULL?
	BLO	10$		;; +++018 BR IF NO
30$:				;; +++018
	CLR	(R5)		;; +++018 FLAG END OF MRL DATA
;+
; **-DISPLAY RESIDENT REGIONS
;-
;
DSRGN:				;; +++018
	CLRB	SNDFLG		;; +++018 SHOW NO TASKS NOT DISPLAYED YET
	MOV	FXDBUF,R5	;; +++018 ADDR OF TEMP STORAGE
	MOV	#.GCDLH,R4	;; +++018 GET GCD LISTHEAD ADDRESS
10$:				;; +++018
	MOV	(R4),R4		;; +++018 GET NEXT GCD NODE
	CMP	R4,#.GCDLH	;; +++018 END OF LIST?
	BEQ	DSATL		;; +++018 YES IF EQ
;
	TST	G.BA(R4)	;; +++018 IS REGION IN MEMORY?
	BEQ	10$		;; +++018 NO IF EQ
	CMP	G.BA(R4),BEGADR	;; +++018 IS REGION OFF SCREEN?
	BLO	10$		;; +++018 YES IF LO
	CMP	G.BA(R4),ENDADR	;; +++018 IS REGION OFF SCREEN?
	BHIS	10$		;; +++018 YES IF HIS
;
	TST	G.BN+0(R4)	;; +++018 DOES REGION HAVE A NAME?
	BNE	40$		;; +++018 YES IF NE
	BIT	#GF.PA,G.FW(R4)	;; +++018 IS IT A TASK PURE-AREA?
	BEQ	25$		;; +++018 NO IF EQ
	MOV	.STDTA,R0	;; +++018 SCAN STD TO GET TASK NAME
	MOV	.STDTZ,R1	;; +++018
	ASR	R1		;; +++018
	INC	R1		;; +++018
20$:				;; +++018
	MOV	(R0)+,R2	;; +++018 GET STD ADDRESS
	CMP	R4,S.PA(R2)	;; +++018 PURE AREA FOR THIS TASK?
	BEQ	30$		;; +++018 YES IF EQ
	SOB	R1,20$		;; +++018 SCAN STD UNTILL DONE
25$:				;; +++018
	MOV	#^R...,(R5)+	;; +++018 UNAMED REGION
	MOV	#^R...,(R5)+	;; +++018 DISPLAY AS '......'
	BR	50$		;; +++018
30$:				;; +++018
	MOV	S.TN+2(R2),(R5)+ ;; +++018 GET TASK NAME
	MOV	S.TN+0(R2),(R5)+ ;; +++018
	MOV	#DI.PUR,(R5)+	;; +++018 AND MARK AS PURE AREA
	BR	60$		;; +++018
40$:				;; +++018
	MOV	G.BN+2(R4),(R5)+ ;; +++018 GET REGION NAME
	MOV	G.BN+0(R4),(R5)+ ;; +++018
50$:				;; +++018
	MOV	#DI.SGA,(R5)+	;; +++018 MARK AS REGION (SGA)
60$:				;; +++018
	MOV	G.CZ(R4),(R5)+	;; +++018 GET REGION SIZE
	MOV	G.BA(R4),(R5)+	;; +++018 AND BASE ADDRESS
;
	CMP	R5,BUFEND	;; +++018 STILL ROOM IN BUFFER?
	BLO	10$		;; +++018 YES IF LO
;
;
DSATL:
				;; +++018 3 LINES DELETED
	MOV	#.ATLLH,R4	;;ADDR OF ATL LISTHEAD
	MOV	#-1,CURTSK	;;++005 DON'T LOOK BEFORE ...DEM
10$:
	CMP	R4,.CRTSK	;;++005 JUST PASSING MYSELF?
	BNE	101$		;;++005 J IF  NOT
	CLR	CURTSK		;;++005 ELSE LOOK FOR ACTIVE TASK
101$:	MOV	@R4,R4		;;GET NEXT ATL NODE
	CMP	R4,.ATLLH+2	;;DONE
	BEQ	DSFTL		;; +++018 YES IF EQ, DO FTL
	CMP	R5,BUFEND	;;++016 ANY MOOR ROOM?
	BLO	102$		;;++013 SKIP IF SO
	JMP	DSFMT1		;;++013 ELSE IGNORE THE REST
102$:	MOV	A.TD(R4),R3	;;++013 GET THE STD
	BEQ	10$		;; +++018 IF EQ THEN .T1ATL, .T2ATL OF .TNATL
;RBF	CMPB	A.TS(R4),#TS.MRL ;; +++018 A MEMORY REQUIRED STATE?
;RBF	BEQ	10$		;; +++018 YES IF EQ
;RBF	CMPB	A.TS(R4),#TS.MRE ;; +++018 A MEMORY REQUIRED STATE?
;RBF	BEQ	10$		;; +++018 YES IF EQ
	BIT	#AF.CP,A.TF(R4)	;;RBF - TASK CHECKPOINTED?
	BNE	10$		;;RBF - THEN IGNORE IT
	TST	A.HA(R4)	;; +++018 MEMORY ALLOCATED?
	BEQ	10$		;; +++018 NO IF EQ
	CMPB	A.TS(R4),#TS.RUN ;; +++018 IS 'RUN' STATE?
	BNE	12$		;; +++018 NO IF NE
	TST	CURTSK		;;++005 LOOKING FOR ACTIVE TASK?
	BNE	12$		;;++005 J IF NOT
	TST	R3		;;++005 IS THIS NULL TASK?
	BEQ	12$		;;++005 J IF SO
	MOV	#CURTSK,R0	;;++005 GET BUFFER
	MOV	S.TN(R3),(R0)+	;;++005 GET TASK NAME
	MOV	S.TN+2(R3),(R0)+ ;;++005
	MOV	A.TI(R4),R1	;;++005 GET PUD FOR TI
	MOV	U.DN(R1),(R0)+	;;++005 STORE DEV NAME
	MOVB	U.UN(R1),(R0)+	;;++005 AND UNIT
	BR	12$		;;++005 SKIP NEXT BIT
				;; +++018 2 LINES DELETED
12$:				;; +++001
	CMP	A.HA(R4),BEGADR	;;IS THE TASK OFF SCREEN
	BLO	10$		;; +++018 BR IF YES - IGNORE IT
	CMP	A.HA(R4),ENDADR	;;IS THE TASK OFF SCREEN
	BHIS	10$		;; +++018 BR IF YES - IGNORE IT
	MOV	S.TN+2(R3),(R5)+;;GET TASK
	MOV	S.TN(R3),(R5)+	;;  NAME
	MOV	#DI.TSK,(R5)+	;;++015 SHOW THIS IS A TASK
	BIT	#SF.XC,S.FW(R3)	;;++015 TASK NON-CHECKPOINTABLE?
	BEQ	121$		;;++015 J IF NOT
	BIT	#AF.IA,A.TF(R4)	;;++015 AH, BUT IS IT A T/S TASK?
	BNE	121$		;;++015 J IF SO, MUST BE SWAPPABLE
	MOV	#DI.FTK,-2(R5)	;;++015 ELSE MARK AS SUCH
121$:	MOV	S.TZ(R3),(R5)+	;;GET TASK SIZE
	MOV	A.HA(R4),(R5)+	;;GET STARTING ADDR OF TASK
	BR	10$		;; +++018
				;; +++018 36 LINES DELETED
DSFTL:
	MOV	#.FTLLH,R4	;;ADDR OF FTL LISTHEAD
40$:
	MOV	@R4,R4		;;GET NEXT FTL NODE
	CMP	#.FTLLH,R4	;;DONE
	BEQ	DSFMT		;;BR IF YES
	CMP	R5,BUFEND	;;++016 ANY MORE ROOM?
	BHIS	DSFMT1		;;BR IF NO
	CMP	A.HA(R4),BEGADR	;;IS THE FIXED TASK OFF SCREEN
	BLO	40$		;;BR IF YES - IGNORE IT
	CMP	A.HA(R4),ENDADR	;;IS THE FIXED TASK OFF SCREEN
	BHIS	40$		;;BR IF YES - IGNORE IT
	MOV	A.TD(R4),R3	;;GET STD ADDR
	MOV	S.TN+2(R3),(R5)+ ;;++015 GET 'FIXED'
	MOV	S.TN(R3),(R5)+	;;++015  TASK NAME
	MOV	#DI.FXD,(R5)+	;;++015 AND TYPE
	MOV	S.TZ(R3),(R5)+	;;GET TASK SIZE
	MOV	A.HA(R4),(R5)+	;;GET STARTING ADDR OF TASK
	BR	40$		;;LOOP TIL DONE
;
; EDIT ACTIVE TASKS FOR DISPLAY
;

DSFMT1:	INCB	SNDFLG		;;++016 NO ROOM FOR MORE TASKS
DSFMT:
	.IF	DF,IAS		;;+020 IF IAS, READ UTILIZATION STATISTICS
	MOV	#.SSTIM,R0	;;+020 POINT TO STATISTICS
	MOV	#TOTAL2,R1	;;+020 AND WHERE TO PUT THEM
	MOV	#10.,R2		;;+020 TOTAL OF 10. WORDS
1$:	MOV	(R0)+,(R1)+	;;+020 SAVE 'EM
	SOB	R2,1$		;;+020
	.ENDC			;;+020
	.ENB0			;;ENABLE TASK SWITCHING
				;++007 LINES DELETED
	TSTB	TSFLG		;++016 RUNNING AS T/S TASK?
	BNE	35$		;++016 J IF SO, NO ACTIVE TASK DISPLAY
	MOV	#TSKITM+2,R0	;++005 GET BUFFER FOR ACTIVE TASK
	MOV	#CURTSK,R3	;++005 GET INFO BUFFER
	MOV	(R3)+,R1	;++005 GET FIRST WORD OF NAME
	BEQ	20$		;++005 J IF NULL JOB
	.IF	DF,IAS
	CMP	R1,#^R.TS	;++005 IS .TSSN., T/S NULL JOB?
	BNE	10$		;++005 J IF NOT
	CMP	(R3),#^RSN.	;++005 LOOK AT SECOND WORD
	BEQ	20$		;++005 J IF IT IS
	.ENDC
10$:	CALL	$C5TA		;++005 UNPACK FIRST WORD
	MOV	(R3)+,R1	;++005 GET SECOND
	CALL	$C5TA		;++005 AND UNPACK
	MOVB	#SPA,(R0)+	;++005 LEAVE A SPACE
	MOVB	(R3)+,(R0)+	;++005 PLANT THE DEV NAME
	MOVB	(R3)+,(R0)+	;++005
	MOVB	#SPA,(R0)	;++005 CLEAR SPACE FOR NUMBER
	MOVB	(R0),1(R0)	;++005
	CLR	R2		;++005 SHOW ZERO SUPPRESSION WANTED
	MOVB	(R3)+,R1	;++005 PICK UP UNIT
	CALL	$CBOMG		;++005 UNPACK
	MOV	#TSKITM,R3	;++005 GET STRING AGAIN
	BR	30$		;++005 GO OUTPUT
20$:	MOV	#NTKITM,R3	;++005 NULL TASK ITEM
30$:	CALL	OUTITM		;++005 OUTPUT IT
35$:				;++016
	MOV	NODES,R1	;++007 GET NUMBER OF TOTAL NODES
	MOV	#NODAD1,R3	;++007 ADDRESS OF OUTPUT LINE
	CALL	MOVNOD		;++007 MOVE THE DATA
	MOV	HOLE,R1		;GET MAX HOLE SIZE
	MOV	#NODAD2,R3	;ADDRESS OF OUTPUT LINE
	CALL	MOVNOD		;MOVE THE DATA
	MOV	#SNDNUL,R3	;++016 ASSUME ALL TAKS DISPLAYED
	TSTB	SNDFLG		;++016 WELL
	BEQ	37$		;++016 J IF CORRECT
	MOV	#SNDITM,R3	;++016 ELSE GET MESSAGE
37$:	CALL	OUTITM		;++016 DISPLAY THE MESSAGE
;
	.IF	DF,IAS		;+020
	MOV	.CRTSK,R0	;+020 GET OUR ATL NODE
	BIT	#4,A.EF(R0)	;+020 AND CHECK MARK TIME FLAG
	BNE	29$		;+020 IF SET, GO DO STATISTICS
	JMP	40$		;+020 OTHERWISE SKIP IT
29$:	MOV	R5,-(SP)	;+020 SAVE R5
	MOV	#TOTAL2,R0	;+020 POINT TO CURRENT STATISTICS
	MOV	#DTOTAL,R1	;+020 AND TO DELTA BLOCK
	MOV	#5,R2		;+020 5 VALUES
31$:	TST	(R0)+		;+020 STEP TO 2ND WORD
	MOV	(R0)+,(R1)+	;+020 SAVE IT
	SOB	R2,31$		;+020
	SUB	TOTAL1+2,DTOTAL	;+020 DENOMINATOR IN DTOTAL
	MOV	#NULL1,R0	;+020 POINT TO OLD STATISTICS
	MOV	#DNULL,R1	;+020 AND TO DELTAS
	MOV	#4,R2		;+020 4 VALUES
32$:	MOV	(R1),R5		;+020 GET A VALUE
	TST	(R0)+		;+020
	SUB	(R0)+,R5	;+020 SUBTRACT (ASSUME NO MORE THAN 1 CARRY)
	MUL	#100.,R5	;+020 CONVERT TO PERCENT
	CLR	R4		;+020
	DIV	DTOTAL,R4	;+020 DIVIDE BY TOTAL TIME AVAILABLE
	ASL	R5		;+020 CHECK FOR ROUND OFF
	CMP	R5,DTOTAL	;+020 ROUND UP NEEDED?
	BLT	33$		;+020
	INC	R4		;+020 ROUND UP
33$:	MOV	R4,(R1)+	;+020 SAVE THE RESULT
	SOB	R2,32$		;+020
;
	CLR	R2		;+020 NO ZEROS
	MOV	#USRDAT,R0	;+020 USER POINTER IN BUFFER
	MOV	DUSERS,R1
	SUB	DBATCH,R1	;+020 SUBTRACT BATCH TIME
	CMP	#100.,R1	;+020 100 PERCENT?
	BEQ	34$
	MOVB	#' ,(R0)+	;+020 PUT IN A BLANK
	CMP	#10.,R1		;+020 2 DIGITS?
	BLE	34$
	MOVB	#' ,(R0)+	;+020 IF NOT, MAKE SURE 1ST IS BLANK
34$:	JSR	PC,$CBDMG	;+020 CONVERT IT
;
	MOV	#BATDAT,R0	;+020 BATCH POINTER IN BUFFER
	MOV	DBATCH,R1
	CMP	#100.,R1	;+020 100 PERCENT?
	BEQ	55$

	MOVB	#' ,(R0)+	;+020 PUT IN A BLANK
	CMP	#10.,R1		;+020 2 DIGITS?
	BLE	55$
	MOVB	#' ,(R0)+	;+020 IF NOT, MAKE SURE 1ST IS BLANK
55$:	JSR	PC,$CBDMG	;+020 CONVERT IT
;
	MOV	#NULDAT,R0	;+020 NULL POINTER IN BUFFER
	MOV	DNULL,R1
	SUB	DSWAP,R1	;+020 SUBTRACT SWAP TIME
	CMP	#100.,R1	;+020 100 PERCENT?
	BEQ	36$
	MOVB	#' ,(R0)+	;+020 PUT IN A BLANK
	CMP	#10.,R1		;+020 2 DIGITS?
	BLE	36$
	MOVB	#' ,(R0)+	;+020 IF NOT, MAKE SURE 1ST IS BLANK
36$:	JSR	PC,$CBDMG	;+020 CONVERT IT
;
	MOV	#SWPDAT,R0	;+020 SWAP POINTER IN BUFFER
	MOV	DSWAP,R1
	CMP	#100.,R1	;+020 100 PERCENT?
	BEQ	57$
	MOVB	#' ,(R0)+	;+020 PUT IN A BLANK
	CMP	#10.,R1		;+020 2 DIGITS?
	BLE	57$
	MOVB	#' ,(R0)+	;+020 IF NOT, MAKE SURE 1ST IS BLANK
57$:	JSR	PC,$CBDMG	;+020 CONVERT IT
;
	MOV	#OTHDAT,R0	;+020 OTHER POINTER IN BUFFER
	MOV	#100.,R1
	SUB	DUSERS,R1
	BPL	41$		;+020 CHECK FOR OVERFLOW
	CLR	R1		;+020 IF NEGATIVE, MAKE ZERO
	BR	42$		;+020 AND SKIP THE REST
41$:	SUB	DNULL,R1
	BPL	42$		;+020 CHECK FOR OVERFLOW
	CLR	R1		;+020 IF NEGATIVE, MAKE ZERO
42$:	CMP	#100.,R1	;+020 100 PERCENT?
	BEQ	38$
	MOVB	#' ,(R0)+	;+020 PUT IN A BLANK
	CMP	#10.,R1		;+020 2 DIGITS?
	BLE	38$
	MOVB	#' ,(R0)+	;+020 IF NOT, MAKE SURE 1ST IS BLANK
38$:	JSR	PC,$CBDMG	;+020 CONVERT IT
;
	MOV	#UTLDAT,R3	;+020
	CALL	OUTITM		;+020
;
	MOV	#TOTAL1,R0	;+020 POINT TO OLD STATISTICS
	MOV	#TOTAL2,R1	;+020 AND TO CURRENT STATISTICS
	MOV	#10.,R2		;+020 10. WORDS
39$:	MOV	(R1)+,(R0)+	;+020 UPDATE OLD STATISTICS
	SOB	R2,39$		;+020
;
	MOV	(SP)+,R5	;+020 RESTORE R5
	DIR$	#STATMT		;+020 REISSUE THE STATISTICS MARK TIME
	.ENDC			;+020
;
40$:
	MOV	-(R5),R3	;++006 GET BASE ADDRESS OF NEXT TASK
	BEQ	70$		;IF EQ NO MORE TASKS TO EDIT
	SUB	BEGADR,R3	;++006 NORMALIZE ADDR TO SCREEN
	ADD	GRAIN,R3	;++006 ROUND TO 1K BOUNDARY
	DEC	R3		;++006 ...
	CLR	R2		;++006 READY FOR DIVIDE
	DIV	GRAIN,R2	;++006 CONVERT BLOCKS TO COLUMNS
	CMP	R2,COLS		;++010 START OFF THE END OF THE SCREEN?
	BLO	43$		;++012 J IF NOT
	SUB	#10,R5		;++012 ELSE START NEXT TASK
	BR	40$		;++012 AND LOOP
43$:	MOV	R2,R0		;SAVE STARTING COLUMN POSITION
	MOV	#DISIMG+1+<64.*6.>,R1 ;SET DISPLAY BUFFER OFFSET
	MOV	-4(R5),R3	;++015 GET DESCRIPTOR STRING
	CALL	XFRVER		;TRANSFER VERTICLE MESSAGE
	MOV	-(R5),R3	;++006 GET SIZE OF TASK IN BLOCKS
				;++015 TWO LINES DELETED
	CLR	R2		;++006 READY FOR DIVIDE
	DIV	GRAIN,R2	;++006 CONVERT BLOCKS TO COLUMNS
	MOV	R2,-(SP)	;SAVE NUMBER OF COLUMNS
	MOV	R2,R4		;COPY NUMBER OF COLUMNS
	DEC	R4		;CALCULATE FILL COUNT
	ADD	R0,R2		;CALCULATE ENDING COLUMN NUMBER
	MOV	-(R5),R3	;++015 GET DESCRIPTOR AGAIN
	ADD	#4,R3		;++015 POINT TO TERMINATOR CHARACTER
	CMP	COLS,R2		;++006 IS THE END OFF SCREEN
	BHIS	45$		;BR IF NO
	SUB	COLS,R2		;++006 GET HOW MUCH OFF
	SUB	R2,(SP)		;CORRECT NUMBER OF COLUMNS
	SUB	R2,R4		;CORRECT NUMBER OF COLUMNS
	MOV	COLS,R2		;++006 SET ENDING COLUMN NUMBER
	SUB	#2,R3		;++015 POINT BACK TO INTERMEDIATE CHAR
45$:
	DEC	R2		;BACKUP COLUMN NUMBER BY ONE
	ASR	(SP)		;CALCULATE MIDWAY POINT
	ADD	R0,(SP)		;
	ADD	R1,R0		;CALCULATE ADDRESS IN BUFFER
	INC	R0		;
	MOV	R3,-(SP)	;++015 SAVE R3
	MOV	(R5),R3		;++015 GET FILL CHARACTER
	ADD	#2,R3		;++015 POINT AT IT
50$:	DEC	R4		;ANY MORE BYTES TO FILL?
	BLT	60$		;IF LT NO
	MOVB	(R3),(R0)+	;++015 INSERT FILL BYTE
	BR	50$		;
60$:
	MOV	(SP)+,R3	;++015 RETRIEVE R3
	CALL	XFRVER		;TRANSFER VERTICLE MESSAGE
	MOV	#TSKNAM,R0	;POINT TO TASKNAME TEMPORARY STORAGE
	MOV	-(R5),R1	;GET FIRST HALF OF TASK NAME
	CALL	$C5TA		;CONVERT TO ASCII
	MOV	-(R5),R1	;GET SECOND HALF OF TASK NAME
	CALL	$C5TA		;CONVERT TO ASCII
	MOV	#DISIMG+1,R1	;SET DISPLAY OFFSET
	MOV	(SP)+,R2	;RETRIEVE ADDRESS TO STORE TASKNAME
	MOV	#TSKNAM,R3	;POINT TO CONVERTED TASK NAME
	CALL	XFRVER		;TRANSFER VERTICLE MESSAGE
	BR	40$		;GO AGAIN
70$:

	MOV	#DISMRL+1,R4	;SET UP DISPLAY OFFSET
	MOV	#MRLLST,R5	;GET ADDR OF LISTHEADS
80$:
	MOV	#TSKNAM,R0	;ADDR OF TEMP STORAGE
	MOV	(R5)+,R1	;GET 1ST HALF OF TASK NAME
	BEQ	DSPLY		;IF ZERO - DONE
	CALL	$C5TA		;CONVERT IT TO ASCII
	MOV	(R5)+,R1	;GET 2ND HALF OF TASK NAME
	CALL	$C5TA		;CONVERT IT TO ASCII
	MOV	#TSKNAM,R3	;ADDR OF TASK NAME
	MOV	R4,R2		;SET UP FOR XFRHOR CALL
	CALL	XFRHOR		;TRANSFER HORIZONTAL MESSAGE
	ADD	#8.,R4		;MOVE TO NEXT LINE
	BR	80$		;GET NEXT

;+
; **-DSPLY-DISPLAY NEXT IMAGE
;-

DSPLY:	MOV	#1,R4		;SET INITIAL IMAGE PROTOTYPE INDEX
	MOV	#64.,R3		;SET UP DIVISOR FOR COORD
10$:	CMP	R4,IMGSZE	;++010 FINISHED WITH SCAN?
	BHI	40$		;IF HI YES
	CMPB	CURIMG(R4),DISIMG(R4) ;DISPLAY PROTOTYPES IDENTICAL?
	BNE	20$		;IF NE NO
	INC	R4		;INCREMENT PROTOTYPE INDEX
	BR	10$		;GO AGAIN
20$:	CALL	COORD		;CALCULATE 'X' AND 'Y' CO-ORDINATES
	INC	R1		;++002 BUMP X COORD
	ADD	#TASKY,R0	;++002 ADD COORDINATE OFFSET VALUE
	CMP	#SPLIT,R0	;AT SCREEN SPLIT?
	BHI	30$		;IF HI NO
	ADD	#3.,R0		;ADJUST DOWN THREE LINES
30$:	CALL	OUTCP		;++002 OUTPUT COORDINATES
	CALL	OUTCON		;OUTPUT NON-IDENTICAL CHARACTER
	BR	10$		;GO AGAIN
40$:
	MOV	#1,R4		;SET INITIAL IMIGAE PROTO INDEX
	MOV	#8.,R3		;SET UP DIVISOR FOR COORD
50$:
	CMP	R4,#MRLBUF	;FINISHED WITH MENU SCAN
	BHI	80$		;BR IF YES
	CMPB	CURMRL(R4),DISMRL(R4) ;DISPLAY PROTO IDENTICAL
	BNE	60$		;BR IF NO
	INC	R4		;INC PROTO INDEX
	BR	50$		;AGAIN
60$:
	CALL	COORD		;CALC 'X' AND 'Y' COORD
	CMP	#16.,R0		;+019 1ST COLUMN FULL YET?
	BGT	70$		;+019 BR IF NOT
	SUB	#16.,R0		;+019 ADJUST THE POINTERS
	ADD	#7,R1		;+019
70$:				;+019
	ADD	#MRLX,R1	;++002 MAKE MRL DISPLAY AREA OFFSET
	ADD	#MRLY,R0	;++002
	CALL	OUTCP		;++002 OUTPUT CURSOR CONTROL
	CALL	OUTMRL		;OUTPUT NON-IDENTICAL CHAR
	BR	50$		;AGAIN
80$:
;RBF	MOV	#HO,R2		;SET TO HIOME CURSOR
;RBF	CALL	OUTSPC		;OUTPUT HOME CURSOR CONTROL CHARACTER
	CALL	OUTBUF		;FLUSH DISPLAY BUFFER
	RETURN

;+
; **-LINGEN-GENERATE MEMORY LINE FOR DISPLAY
;
; INPUTS:
;
;	R1=ADDRESS TO CONVERT AND INSERT
;	R4=ADDRESS OF LINE OF '*'S
;
;-
LINGEN:
	MOV	#64.,R2		;++012 FIRST CLEAR LINE TO ALL STARS
	ADD	R2,R4		;++012 POINT PAST END OF BUFFER
10$:	MOVB	#'*,-(R4)	;++012 MOVE IN A STAR
	SOB	R2,10$		;++012 LOOP TIL DONE
	MOV	R1,R3		;SAVE R3 FOR LATER MODIFICATION
	CLR	R2		;ZERO SUPRESS $CBDMG
	MOV	#8.,R5		;SET UP LOOP COUNT
20$:
	MOV	R3,R1		;SET UP ADDRESS TO CONVERT
	ASH	#-5,R1		;++017 CONVERT FROM BLOCKS TO K
	MOV	R4,R0		;SET UP BUFFER ADDRESS
	CALL	$CBDMG		;CONVERT BINARY TO DECIMAL
	MOV	GRAIN,R1	;++006 GET BLOCKS PER SINGLE COLUMN
	ASH	#3,R1		;++017 MULT BY 8 FOR DISPLAY
	ADD	R1,R3		;++017 AND UPDATE CURRENT POSITION
	ADD	#8.,R4		;ADD 8 TO BUFFER ADDRESS
	SOB	R5,20$		;LOOP TIL DONE
	RETURN
;+
; **MOVNOD-MOVE THE NODE INFO INTO THE DISPLAY BUFFER
;
; INPUTS:
;
;	R0=OUTPUT BUFFER ADDRESS
;	R1=NUMBER TO BE CONVERTED AND INSERTED
;
;-
MOVNOD:
	MOV	R3,R0		;++002 GET MESSAGE ADR
	ADD	#2,R0		;++002
	CLR	R2		;ZERO SUPRESS
	ASH	#-4,R1		;DIVIDE BY 16 FOR CORRECT COUNT
	MOV	#6,-(SP)	;++002 CLEAR SIX BYTES
10$:	MOVB	#SPA,(R0)+	;++002 CLEAR ONE
	DEC	(SP)		;++002 DEC THE COUNT
	BGT	10$		;++002 LOOP TIL DONE
	TST	(SP)+		;++002 CLEAN THE STACK
	SUB	#6,R0		;++002 RESTORE POINTER
	CALL	$CBDMG		;CONVERT DATA
	CALL	OUTITM		;++002 OUTPUT THE LINE
	RETURN
;+
; **-COORD-CALCULATE DISPLAY CO-ORDINATE VALUES
;
; INPUTS:
;
;	R4=PROTOTYPE DISPLAY INDEX.
;-

COORD:	MOV	R4,R1		;SET DIVIDEND
	DEC	R1		;BACK OFF BY 1
	CLR	R0		;CLEAR FOR DIVIDE
	DIV	R3,R0		;CALCULATE CO-ORDINATE VALUES
	RETURN

;+
; **-INIBUF-INITIALIZE OUTPUT IMAGE DISPLAY PROTOTYPES
;
; INPUTS:
;
;	NONE.
;-

	.ENABL	LSB
INIBUF:	MOV	#CURIMG+1,R0	;POINT TO CURRENT IMAGE DISPLAY PROTO
	MOV	#CURMRL+1,R2	;POINT TO CURRENT IMAGE MENU PROTO
	CALL	10$		;INITIALIZE CURRENT IMAGE DISPLAY
INIDIS:	MOV	#DISIMG+1,R0	;POINT TO NEXT IMAGE DISPLAY PROTO
	MOV	#DISMRL+1,R2	;POINT TO NEXT IMAGE MENU PROTO
10$:	MOV	#DISBUF/2,R1	;SET SIZE OF BUFFER
20$:	MOV	#"  ,(R0)+	;INSERT BLANKS IN PROTOTYPE
	SOB	R1,20$		;LOOP TIL DONE
	MOV	#MRLBUF/2,R1	;SET SIZE OF BUFFER
30$:
	MOV	#"  ,(R2)+	;INSERT BLANKS IN PROTO
	SOB	R1,30$		;LOOP TIL DONE
	RETURN			;
	.DSABL	LSB

;+
; **-OUTBUF-OUTPUT DISPLAY BUFFER
;
; INPUTS:
;
;	BUFCTR=NUMBER OF BYTES TO OUTPUT.
;-

OUTBUF:	MOV	#DSBUF,BUFPTR	;RESET CURRENT BUFFER POINTER
	DIR$	#DSQIO		;OUTPUT DISPLAY LINE
10$:	CLR	BUFCTR		;CLEAR BUFFER BYTE COUNT
	RETURN			;

;+
; **-OUTCHR-OUTPUT CHARACTER TO DISPLAY BUFFER
;
; INPUTS:
;
;	R2=CHARACTER TO BE OUTPUT.
;-

OUTCHR:	MOVB	R2,@BUFPTR	;INSERT BYTE IN DISPLAY BUFFER
	BEQ	5$		;++006 J IF NULL BYTE
	INC	LASTX		;++006 ELSE BUMP CHARACTER POSITION
5$:	INC	BUFPTR		;INCREMENT BUFFER POINTER
	INC	BUFCTR		;INCREMENT BYTE COUNT
	CMP	#BUFSIZ,BUFCTR	;++002 BUFFER FULL?
	BHI	10$		;IF HI NO
	CALL	OUTBUF		;FLUSH OUTPUT BUFFER
10$:	RETURN			;

;+
; **-OUTCON-OUTPUT NON-IDENTICAL CHARACTER
;
; INPUTS:
;
;	R4=PROTOTYPE DISPLAY INDEX.
;-

OUTCON:	MOVB	DISIMG(R4),R2	;GET CHARACTER TO OUTPUT
	MOVB	R2,CURIMG(R4)	;STORE BYTE IN CURRENT IMAGE
OUTCO1:
	CALL	OUTCHR		;OUTPUT CHARACTER
	INC	R4		;INCREMENT PROTOTYPE IMAGE INDEX
	RETURN			;
;
;
;
OUTMRL:
	MOVB	DISMRL(R4),R2	;GET CHAR TO OUTPUT
	MOVB	R2,CURMRL(R4)	;STORE BYTE IN CURRENT IMAGE
	BR	OUTCO1		;REST THE SAME

;+
; **-OUTLIN-OUTPUT DOUBLE ASCIZ STRING TO DISPLAY BUFFER
;
; INPUTS:
;
;	R3=ADDRESS OF DOUBLE ASCIZ STRING TO BE OUTPUT.
;-

OUTLIN:	MOVB	(R3)+,R2	;GET NEXT CHARACTER TO OUTPUT
	BEQ	10$		;IF EQ END OF FIRST STRING
	CALL	OUTCHR		;OUTPUT CHARACTER
	BR	OUTLIN		;GO AGAIN
10$:	CALL	OUTFIL		;OUTPUT FILL CHARACTERS

;+
; **-OUTLN2-OUTPUT ASCIZ STRING TO DISPLAY BUFFER
;
; INPUTS:
;
;	R3=ADDRESS OF ASCIZ STRING TO BE OUTPUT.
;-

OUTLN2:	MOVB	(R3)+,R2	;GET NEXT CHARACTER TO OUTPUT
	BEQ	10$		;IF EQ DONE
	CALL	OUTCHR		;OUTPUT CHARACTER
	BR	OUTLN2		;GO AGAIN
10$:	RETURN			;
 
;++002
; OUTSPC - OUTPUT SPECIAL CHARACTER WITH FILL
;
; INPUTS:
;
;	R2	CHARACTER TO BE OUTPUT
;-
 
OUTSPC:	CALL	OUTCHR		;++002 OUTPUT THE BYTE
OUTFIL:	TST	VT05FG		;++002 RUNNING ON VT05?
	BEQ	20$		;++002 J IF NOT, NO FILL
	MOV	#6,-(SP)	;++002 ELSE GET THE COUNT
	CLR	R2		;++002 GET THE FILL BYTE
10$:	CALL	OUTCHR		;++002 OUTPUT A FILLER
	DEC	(SP)		;++002 DEC THE COUNT
	BGT	10$		;++002 LOOP TIL DONE
	TST	(SP)+		;++002 CLEAN THE STACK
20$:	RETURN			;++002 GO AWAY
 
;++002
; OUTCP - OUTPUT CURSOR CONTROL TO MOVE CURSOR
;
; INPUTS:
;
;	R0	X COORDINATE
;	R1	Y COORDINATE
;	R2	<DESTROYED>
;--002
 
OUTCP:	CMP	R0,LASTY	;++004 SAME LINE AS BEFORE?
	BNE	2$		;++004 J IF NOT
	MOV	R1,R2		;++004 COPY POSITION ON LINE
	CMP	R2,LASTX	;++004 NEXT CHARACTER?
	BEQ	999$		;++004 J IF SO, NO POSITIONING NEEDED
	BR	9$		;++004 AND GET OUT
2$:	CMP	R1,LASTX	;++004 SAME COLUMN AS BEFORE?
	BNE	9$		;++004 J IF NOT
	MOV	R0,R2		;++004 GET COPY OF VERTICAL POS
	DEC	R2		;++004 JUST ON NEXT LINE?
	CMP	R2,LASTY	;++004 WELL?
	BNE	9$		;++004 J IF NOT
;RBF
9$:	BR	10$		;RBF
;RBF
	TST	VT05FG		;++004 ON VT05?
	BEQ	9$		;++004 J IF NOT, DO IT THE HARD WAY
	MOV	#BS,R2		;++004 ELSE OUTPUT BACKSPACE
	CALL	OUTCHR		;++004
	MOV	#LF,R2		;++004 AND A LINE-FEED
	CALL	OUTSPC		;++004
	BR	999$		;++004 NOW GET OUT
;RBF9$:	TST	VT50FG		;++006 RUNNING ON VT50?
	BNE	30$		;++006 J IF SO
	TST	VT05FG		;++002 RUNNING ON VT05?
	BEQ	10$		;++002 J IF NOT
	MOV	#CD,R2		;++002 GET START OF CURSOR CONTROL SEQ
	CALL	OUTCHR		;++002 AND OUTPUT IT
	BR	20$		;++002 SKIP VT52 STUFF
10$:	MOV	#ESC,R2		;++002 OUTPUT ESCSEQ TO VT52
	CALL	OUTCHR		;++002
;RBF	MOV	#'Y,R2		;++002
	MOV	#'F,R2		;++002
	CALL	OUTCHR		;++002
20$:	MOV	R0,R2		;++002 OUTPUT X COORD
	ADD	#OFFSET,R2	;++002 ADD OFFSET
	CALL	OUTSPC		;++002
	MOV	R1,R2		;++002 AND Y -COORD
	ADD	#OFFSET,R2	;++002 ADD OFFSET
	CALL	OUTCHR		;++002
	BR	999$		;++006 GET OUT
30$:	MOV	R3,-(SP)	;++006 VT50 - SAVE SOME SCRATCH
	CMP	R0,#1		;++006 GOING TO LINE 1?
	BNE	40$		;++006 J IF NOT
	MOV	#ESC,R2		;++006 ELSE DO CURSOR HOME
	CALL	OUTCHR		;++006
	MOV	#'H,R2		;++006 (ESC H)
	CALL	OUTCHR		;++006
	MOV	#1,LASTX	;++006 AND SHOW WHERE WE ARE
	MOV	#1,LASTY	;++006
40$:	MOV	R1,R3		;++006 COPY REQD HORIZ POS
	SUB	LASTX,R3	;++006 SUBTRACT CURRENT POS
	BEQ	80$		;++006 J IF IN THE RIGHT PLACE
	BPL	60$		;++006 J IF GOING FORWARDS - MUST USE SPACE
	NEG	R3		;++006 MAKE DIFFERENCE POSITIVE
	CMP	R3,R1		;++006 GOING BACK MORE THAN HALF WAY?
	BHI	50$		;++006 J IF SO, USE CR THEN SPACES
	MOV	#BS,R2		;++006 GET CHARACTER
	BR	70$		;++006 AND J TO DO IT
50$:	MOV	#CR,R2		;++006 DO A CR
	CALL	OUTCHR		;++006
	MOV	R1,R3		;++006 NOW GET # OF SPACES
	DEC	R3		;++006 START AT ZERO
	BEQ	80$		;++006 J IF FIRST COL REQD
60$:	MOV	#ESC,R2		;++006 DO 'CURSOR FORWARD'
	CALL	OUTCHR		;++006 WHICH IS 'ESC C'
	MOV	#'C,R2		;++006
	CALL	OUTCHR		;++006
	SOB	R3,60$		;++006 LOOP TIL DONE
	BR	80$		;++006 AND SKIP
70$:	CALL	OUTCHR		;++006 OUTPUT THE BYTE
	SOB	R3,70$		;++006 AND LOOP
80$:	MOV	R0,R3		;++006 GET REQD VERTICAL POS
	SUB	LASTY,R3	;++006 SUBTRACT CURRENT POS
	BEQ	110$		;++006 J IF NOTHING TO DO
	BPL	100$		;++006 J IF MOVING DOWN
	NEG	R3		;++006 ELSE MUST DO 'CURSOR UP'S
90$:	MOV	#ESC,R2		;++006 WHICH IS 'ESC A'
	CALL	OUTCHR		;++006
	MOV	#'A,R2		;++006
	CALL	OUTCHR		;++006
	SOB	R3,90$		;++006 LOOP TIL DONE
	BR	110$		;++006 NOW GET OUT
100$:	MOV	#LF,R2		;++006 MOVE CURSOR DOWN...
	CALL	OUTCHR		;++006
	SOB	R3,100$		;++006
110$:	MOV	(SP)+,R3	;++006 RESTORE R3
999$:	MOV	R0,LASTY	;++004 SAVE Y COORD
	MOV	R1,LASTX	;++004 AND X
	RETURN			;++002 AND GO AWAY
 
;++002
; OUTITM - OUTPUT ITEM GENERATED BY 'ITEM' MACRO
;
; INPUTS:
;
;	R3	ADDRESS OF ITEM
;-
 
OUTITM:	MOVB	(R3)+,R0	;++002 GET X COORD
	MOVB	(R3)+,R1	;++002 GET Y COORD
	CALL	OUTCP		;++002 OUTPUT CURSOR CONTROL
	CALL	OUTLN2		;++002 OUTPUT THE LINE
	RETURN			;++002 GO AWAY
;+
; **-XFRHOR-TRANSFER HORIZONAL MESSAGE TO DISPLAY BUFFER
;
; INPUTS:
;
; 	R2=ADDRESS OF FIRST CHARACTER IN DISPLAY BUFFER.
;	R3=ADDRESS OF ASCIZ STRING TO BE INSERTED HORIZONALLY IN THE
;		DISPLAY BUFFER.
;-

XFRHOR:
10$:
	MOVB	(R3)+,(R2)+	;MOVE A CHAR INTO DISPLAY BUFFER
	TSTB	(R3)		;ANY MORE CHARACTERS TO MOVE?
	BNE	10$		;IF NE YES
	RETURN			;

;+
; **-XFRVER-TRANSFER VERTICLE MESSAGE TO DISPLAY BUFFER
;
; INPUTS:
;
;	R2=ADDRESS OF FIRST CHARACTER IN DISPLAY BUFFER.
;	R3=ADDRESS OF ASCIZ STRING TO BE INSERTED VERTICALLY IN THE
;		DISPLAY BUFFER.
;-

XFRVER:	CMP	#64.,R2		;UPPER PART OF DISPLAY?
	BHI	10$		;IF HI YES
	ADD	#<64.*8.>-64.,R2 ;ASSUME TASK NAME
	CMP	#TSKNAM,R3	;TASK NAME?
	BEQ	10$		;IF EQ YES
	SUB	#<64.*7.>,R2 	;ADJUST FOR TASK DELINEATION
10$:	ADD	R1,R2		;ADD DISPLAY OFFSET VALUE
20$:	MOVB	(R3)+,(R2)	;MOVE A CHARACTER TO DISPLAY BUFFER
	ADD	#64.,R2		;ADVANCE TO NEXT DISPLAY LINE
	TSTB	(R3)		;ANY MORE CHARACTERS TO MOVE?
	BNE	20$		;IF NE YES
	RETURN			;
 
;+
; ROUTINE TO READ A MEMORY SIZE IN OCTAL BLOCKS OR K AND CONVERT TO
; OCTAL BLOCKS.  FORMAT IS <OCTAL # OF OCTAL BLOCKS> OR <DECIMAL # OF K>K.
; A DECIMAL NUMBER WITHOUT A 'K' ON THE END IS TREATED AS 32-WORD BLOCKS.
;
; INPUTS:
;
;	R1	POINTER TO FIRST CHAR OF NUMBER
;
; OUTPUTS:
;
;	R1	TERMINATOR ADDRESS
;	R2	NUMBER OF 32-WORD BLOCKS
;-
 
CMTB:	MOV	R0,-(SP)	;++012 SAVE R0
	MOV	R1,R0		;++012 COPY BUFFER ADDRESS
	MOV	R1,R5		;++012 AND SAVE IT
	CALL	$COTB		;++012 ASSUME OCTAL AT FIRST
	CMPB	-(R0),#'K	;++012 TERMINATED ON 'K'?
	BEQ	10$		;++012 DECIMAL IF SO
	CMPB	(R0),#'8	;++012 TERMINATED ON DECIMAL DIGIT?
	BEQ	10$		;++012 J IF SO
	CMPB	(R0),#'9	;++012 TRY THE OTHER...
	BNE	20$		;++012 J IF NOT, MUST BE OCTAL BLOCKS
10$:	MOV	R5,R0		;++012 GET START ADR AGAIN
	CALL	$CDTB		;++012 CONVERT AS DECIMAL
	CMPB	-(R0),#'K	;++012 FINISH ON 'K'?
	BNE	20$		;++012 J IF NOT
	INC	R0		;++012 ELSE SKIP THE K
	ASH	#5,R1		;++012 CONVERT TO BLOCKS
20$:	MOV	R1,R2		;++012 COPY RESULT
	MOV	R0,R1		;++012 AND BUFF POINTER
	MOV	(SP)+,R0	;++012 RETRIEVE R0
	RETURN			;++012 GO AWAY
 
;++003
; CLRSCR - CLEAR SCREEN BEFORE STARTING OR EXITING
;--003
 
CLRSCR:	TST	VT05FG		;++002 RUNNING ON VT05?
	BEQ	20$		;++002 J IF NOT
;RBF	MOV	#HO,R2		;HOME CURSOR TO BEGIN
	MOV	#ESC,R2		;HOME CURSOR TO BEGIN
	CALL	OUTSPC		;OUTPUT SPECIAL CHARACTER
;RBF	MOV	#ES,R2		;ERASE TO END OF SCREEN
	MOV	#'E,R2		;ERASE TO END OF SCREEN
	CALL	OUTSPC		;OUTPUT SPECIAL CHARACTER
	BR	30$		;++002 SKIP VT52 STUFF
20$:	MOV	#CLR52,R3	;++002 GET VT52 START UP
	CALL	OUTLN2		;++002 AND DO IT
30$:	MOV	#1,LASTX	;++006 SET UP CURSOR POS
	MOV	#1,LASTY	;++006
	RETURN			;++003 GO AWAY
 
;++003
; FOR UNSOLICITED INPUT OR CONTROL-C (RSX ONLY) WAKE UP THE TASK.
;--003
 
	.IF	NDF,IAS
CCAST:	INC	EXFLG		;++008 SHOW EXIT REQUIRED
	BR	ASTCOM		;++008 GO TO COMMON CODE
	.ENDC
 
UIAST:	INC	UIFLG		;++008 SHOW UNSOLICITED INPUT SEEN
ASTCOM:	SETF$S	#2		;++008 WAKE UP THE TASK
	ASTX$S			;++003 AND GO AWAY

.PAGE
;+
; HERE IS THE COMMAND DECODER.  WHILE DEMO IS RUNNING IT USES UNSOLICITED
; INPUT AST'S TO DETECT COMMANDS.  COMMANDS ARE RECOGNIZED BY THE
; FIRST LETTER AND THE DISPATCHER JUMPS TO THE APPROPRIATE HANDLER.
; R1 CONTAINS THE FIRST NON-BLANK CHARACTER AFTER THE COMMAND.
; THE DECODER IS DRIVEN BY THE TABLE AT 'CMDTBL'.
;-
 
COMAND:	MOV	#GETMCR+2,R1	;++011 GET INPUT BUFFER
	MOV	IOSB+2,R0	;++011 GET LENGTH OF COMMAND
	BEQ	35$		;++011 IGNORE IF ZERO LENGTH
	ADD	R1,R0		;++011 POINT PAST COMMAND
	MOVB	#40,(R0)+	;++011 PLANT TERMINATOR
10$:	CMPB	(R1)+,#40	;++011 FOUND A SPACE YET?
	BNE	10$		;++011 LOOP IF NOT
20$:	CMPB	(R1)+,#40	;++011 STILL LOOKING AT SPACES?
	BEQ	20$		;++011 LOOP IF SO
	DEC	R1		;++011 BACK OVER NON-SPACE
	MOV	#CMDTBL,R0	;++011 GET COMMAND TABLE
30$:	CMPB	GETMCR+2,(R0)	;++011 THIS THE RIGHT COMMAND?
	BEQ	40$		;++011 J IF SO
	CMP	(R0)+,(R0)+	;++011 ELSE SKIP TO NEXT ENTRY
	TST	(R0)		;++011 AT THE END YET?
	BNE	30$		;++011 LOOP IF NOT
35$:	JMP	MKT		;++011 IGNORE IF ILLEGAL
40$:	JMP	@2(R0)		;++011 DISPATCH FOR COMMAND
 
;+
; B COMMAND - RESET BEGINNING ADR.  FORMAT IS 'BEGIN NNNK'
;-
 
CMDB:	CALL	CMTB		;++012 GET MEMORY BASE
	MOV	R2,BEGADR	;++012 SET UP
	JMP	RESTRT		;++012 AND START AGAIN
 
;+
; G COMMAND - SET 'GRANULARITY'.  FORMAT IS 'GRAIN NNNK'.  GRAIN MUST
; NOT BE LESS THAN 10 OCTAL BLOCKS.
;-
 
CMDG:	CLR	EXTENT		;++014 SHOW NO EXPLICIT EXTENT
	CALL	CMTB		;++012 GET SIZE
				;++017 LINE DELETED
	MOV	R2,GRAIN	;++012 ELSE SET UP GRAIN
	JMP	RESTRT		;++012 AND GO AGAIN
 
;+
; E COMMAND - SET 'EXTENT' (I.E. SIZE) OF WHOLE DISPLAY. FORMAT IS
; 'EXTENT NNNK' OR 'EXTENT ALL' TO SHOW ALL MEMORY
;-
 
CMDE:	CMPB	(R1),#'A	;++014 IS THIS 'ALL'?
	BNE	10$		;++014 J IF NOT, ASSUME NUMBER
	MOV	.MSIZE,EXTENT	;++014 ELSE SET SIZE
	CLR	BEGADR		;++014 AND START AT THE BEGINNING
	BR	20$		;++014 SKIP OTHER STUFF
10$:	CALL	CMTB		;++014 GET SIZE
	MOV	R2,EXTENT	;++014 AND REMEMBER IT
20$:	JMP	RESTRT		;++014 GO AGAIN
 
;+
; I COMMAND - SET NUMBER OF SECONDS BETWEEN UPDATING DISPLAY
;		IF VALUE IS ZERO, UPDATE DISPLAY CONTINUOUSLY
;-
 
CMDI:	MOV	R1,R0		;++014 COPY BUFF POINTER
	CALL	$CDTB		;++014 CONVERT DECIMAL NUMBER
	MOV	R1,INTRVL	;++014 SET UP
	JMP	MKT		;++014 AND GO AGAIN
	.END	DEMO