.TITLE	RMDEMO
	.IDENT	/01/                                                            
 
;
; 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
;
; RSX11M DEMO PROGRAM TO SHOW TASK SWAPPING AND LOADING
;
; MACRO LIBRARY CALLS
;

	.MCALL	DIR$,GTIM$S,MRKT$S,WTSE$S
	.MCALL	PCBDF$,TCBDF$
	PCBDF$			;DEFINE PARTITION CONTROL BLOCK OFFSETS
	TCBDF$			;DEFINE TASK CONTROL BLOCK OFFSETS

;
; EQUATED SYMBOLS
;

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

;
; LOCAL DATA
;
; DISPLAY OUTPUT MESSAGES
;

CORLN1:	.ASCII	<33>/Y/<31.+11.><0><31.+1.>// ;
	.ASCII	/0*******8*******16******24******32******40******/ ;
	.ASCIZ	/48******56******/ ;
CORLN2:	.ASCII	<33>/Y/<31.+12.><0><31.+1>// ;
	.ASCII	/+-------+-------+-------+-------+-------+-------/ ;
	.ASCIZ	/+-------+-------/ ;
CORLN3:	.ASCII	<33>/Y/<31.+13.><0><31.+1.>// ;
	.ASCII	/64******72******80******88******96******104*****/ ;
	.ASCIZ	/112*****120*****/ ;
HDRMG1:	.ASCII	<33>/Y/<31.+1><0><31.+7.>/RSX-11M V02 BL/ ;
SYSID:	.ASCIZ	/XXXX/		;
HDRMG2:	.ASCII	<33>/Y/<31.+2><0><31.+26.>// ;
	.ASCIZ	/SYSTEM TASK ACTIVITY/ ;
PARMG1:	.ASCII	<33>/Y/<31.+3.><0><31.+63.>// ;
	.ASCIZ	/PARTITIONS/	;
PARMG2:	.ASCIZ	/XXXXXX:T/	;
TASLFT:	.ASCIZ	/</		;
TASRHT:	.ASCIZ	/>/		;
TIMLOC:	.ASCIZ	<33>/Y/<31.+1.><0><31.+46.> ;
TIMMSG:	.BLKB	20.		;
	.EVEN

;
; DISPLAY OUTPUT BUFFER
;

DSBUF:	.BLKB	64.*4		;ROOM FOR FOUR FULL LINES

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

CURIMG=.-1			;CURRENT IMAGE DISPLAY PROTOTYPE
	.BLKB	64.*14.		;
DISIMG=.-1			;NEXT IMAGE DISPLAY PROTOTYPE
	.BLKB	64.*14.		;

;
; DISPLAY OUTPUT QIO DPB
;

DSQIO:	.BYTE	1,12.		;DIC AND SIZE OF DPB
	.WORD	IO.WAL		;FUNCTION CODE (WRITE PASS ALL)
	.BYTE	1		;LUN 1
	.BLKB	1		;UNUSED BYTE
	.BYTE	1		;EVENT FLAG 1
	.BLKB	1		;UNUSED BYTE
	.WORD	0		;NO I/O STATUS DOUBLE WORD
	.WORD	0		;NO AST SERVICE ROUTINE
BUFPTR:	.WORD	DSBUF		;OUTPUT BUFFER ADDRESS AND POINTER
BUFCTR:	.WORD	0		;LENGTH OF BUFFER TO OUTPUT
	.WORD	0		;NO CARRIAGE CONTROL
	.BLKW	3		;THREE UNUSED WORDS

;
; 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		;ZERO SENTINEL WORD
TSKLST:	.BLKW	20.*4		;STORAGE SPACE FOR TEN TASKS

;+
; **-RMDEMO-RSX11M TASK SWAPPING AND LOADING DISPLAY PROGRAM
;-

RMDEMO:	MOV	#33,R2		;HOME CURSOR TO BEGIN
	CALL	OUTSPC		;OUTPUT SPECIAL CHARACTER
	MOV	#'H,R2		;
	CALL	OUTSPC		;
	MOV	#33,R2		;ERASE TO END OF SCREEN
	CALL	OUTSPC		;OUTPUT SPECIAL CHARACTER
	MOV	#'J,R2		;
	CALL	OUTSPC		;

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

DSCON:	MOV	#$SYSID,R0	;POINT TO SYSTEM IDENTIFICATION
	MOV	#SYSID,R1	;POINT TO DISPLAY PROTOTYPE
	.REPT	4
	MOVB	(R0)+,(R1)+	;MOVE IDENTIFICATION TO DISPLAY
	.ENDR
	MOV	#HDRMG1,R3	;POINT TO FIRST HEADER MESSAGE
	CALL	OUTLIN		;DISPLAY LINE
	MOV	#HDRMG2,R3	;POINT TO SECOND HEADER MESSAGE
	CALL	OUTLIN		;DISPLAY LINE
	MOV	#CORLN1,R3	;POINT TO FIRST MEMORY DISPLAY LINE
	CALL	OUTLIN		;DISPLAY LINE
	MOV	#CORLN2,R3	;POINT TO SECOND MEMORY DISPLAY LINE
	CALL	OUTLIN		;DISPLAY LINE
	MOV	#CORLN3,R3	;POINT TO THIRD MEMORY DISPLAY LINE
	CALL	OUTLIN		;DISPLAY LINE

;+
; **-DSPAR-DISPLAY PARTITION CONFIGURATION
;-

DSPAR:	MOV	#PARMG1,R3	;POINT TO PARTITION DISPLAY HEADER
	CALL	OUTLIN		;DISPLAY LINE
	MOV	#31.+5.,R5	;SET INITIAL 'Y' COORDINATE
	MOV	$PARHD,R4	;GET ADDRESS OF FIRST PARTITION PCB
10$:	MOV	#PARMG2,R0	;POINT TO PARTITION DISPLAY PROTOTYPE
	MOV	P.NAM(R4),R1	;GET FIRST HALF OF PARTITION NAME
	CALL	$C5TA		;CONVERT TO ASCII
	MOV	P.NAM+2(R4),R1	;GET SECOND HALF OF PARTITION NAME
	CALL	$C5TA		;CONVERT TO ASCII
	INC	R0		;STEP OVER ':'
	MOVB	P.STAT(R4),R1	;GET PARTITION STATUS BYTE
	MOVB	#'D,(R0)	;ASSUME SYSTEM CONTROLLED PARTITION
	BITB	#PS.SYS,R1	;SYSTEM CONTROLLED PARTITION?
	BNE	20$		;IF NE YES
	MOVB	#'C,(R0)	;ASSUME COMMON PARTITION
	BITB	#PS.COM,R1	;COMMON PARTITION?
	BNE	20$		;IF NE YES
	MOVB	#'T,(R0)	;ASSUME MAIN PARTITION
	CMP	R4,P.MAIN(R4)	;MAIN PARTITION?
	BEQ	20$		;IF EQ YES
	MOVB	#'S,(R0)	;SET SUBPARTITION
20$:	MOV	#33,R2		;GET CURSOR DISPLAY CHARACTER
	CALL	OUTSPC		;OUTPUT CONTROL CHARACTER
	MOV	#'Y,R2		;ESC Y IS CURSOR	CALL	OUTCHR		;
	MOV	R5,R2		;SET 'Y' COORDINATE
	INC	R5		;UPDATE CORDINATE VALUE
	CALL	OUTSPC		;OUTPUT SPECIAL CHARACTER
	MOV	#31.+65.,R2	;SET 'X' COORDINATE
	CALL	OUTCHR		;OUTPUT CHARACTER
	MOV	#PARMG2,R3	;POINT TO PARTITION DISPLAY
	CALL	OUTLN2		;DISPLAY LINE
	MOV	(R4),R4		;GET ADDRESS OF NEXT PCB
	BNE	10$		;IF NE MORE TO GO

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

DSCTL:	CALL	INIBUF		;INITIALIZE OUTPUT DISPLAY PROTOTYPES
10$:	MRKT$S	#2,#1,#2	;MARK TIME FOR 1 SECOND
	CALL	INIDIS		;INITIALIZE NEXT DISPLAY PROTOTYPE
	CALL	DSTIM		;DISPLAY TIME AND TASKS
	WTSE$S	#2		;WAIT FOR 1 SECOND
	BR	10$		;


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

DSTIM:	GTIM$S	#TIMBUF		;GET CURRENT TIME PARAMETERS
	MOV	#TIMLOC,R3	;POINT TO TIME LOCATE STRING
	CALL	OUTLIN		;OUTPUT LOCATE STRING
	MOV	#TIMMSG,R0	;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
	CALL	OUTLN2		;OUTPUT CURRENT TIME PARAMETERS

;+
; **-DISPLAY ACTIVE TASKS THAT ARE IN MEMORY
;-

DSTSK:	CALL	$SWSTK,40$	;SWITCH TO SYSTEM STATE
	MOV	#TSKLST,R5	;POINT TO TASK PARAMETER TEMP STORAGE
	MOV	$TSKHD,R4	;GET ADDRESS OF FIRST TCB
10$:	TST	T.STAT(R4)	;TASK ACTIVE?
	BMI	20$		;IF MI NO
	BIT	#TS.OUT,T.STAT(R4) ;TASK IN MEMORY?
	BNE	20$		;IF NE NO
	MOV	T.PCB(R4),R3	;GET ADDRESS OF TASK PCB
	MOV	T.NAM+2(R4),(R5)+ ;INSERT TASKNAME
	MOV	T.NAM(R4),(R5)+	;
	MOV	P.SIZE(R3),(R5)+ ;INSERT SIZE OF PARTITION IN BYTES
	MOV	P.REL(R3),(R5)+	;INSERT BASE ADDRESS OF PARTITION
	CMP	R5,#TSKLST+<20.*8.> ;END OF TEMPORARY STORAGE?
	BHIS	30$		;IF HIS YES
20$:	MOV	T.TCBL(R4),R4	;GET ADDRESS OF NEXT TCB
	TST	T.TCBL(R4)	;NULL TASK?
	BNE	10$		;IF NE NO
30$:	MOV	@$HEADR,R0	;GET ADDRESS OF SAVED STACK POINTER
	MOV	R5,2(R0)	;SET RETURN R5
	RETURN			;RETURN TO USER STATE

;
; EDIT ACTIVE TASKS FOR DISPLAY
;

40$:	MOV	-(R5),R2	;GET BASE ADDRESS OF NEXT PARTITION
	BEQ	DSPLY		;IF EQ NO MORE TASKS TO EDIT
 
 
	.IF NDF	M$$MGE
 
	ROR	R2		;CONVERT TO 32W BLOCKS
	.REPT	5
	ASR	R2		;
	.ENDR
 
	.ENDC
 
 
	ADD	#15.,R2		;ROUND UP TO NEXT 1K BOUNDRY
	.REPT	5
	ASR	R2		;CALCULATE STARTING COLUMN POSITION
	.ENDR
	MOV	R2,R0		;SAVE STARTING COLUMN POSITION
	MOV	#DISIMG+1+<64.*6.>,R1 ;SET DISPLAY BUFFER OFFSET
	MOV	#TASLFT,R3	;POINT TO TASK MESSAGE
	CALL	XFRVER		;TRANSFER VERTICLE MESSAGE
	MOV	-(R5),R2	;GET SIZE OF PARTITION IN BYTES
	CLRB	R2		;DIVIDE RESULT BY 256.
	SWAB	R2		;
	ADD	#3.,R2		;ROUND UP TO NEXT 1K BOUNDRY
	ASR	R2		;DIVIDE BY 8.
	ASR	R2		;
	ASR	R2		;
	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
	DEC	R2		;BACKUP COLUMN NUMBER BY ONE
	ASR	(SP)		;CALCULATE MIDWAY POINT
	ADD	R0,(SP)		;
	ADD	R1,R0		;CALCULATE ADDRESS IN BUFFER
	INC	R0		;
50$:	DEC	R4		;ANY MORE BYTES TO FILL?
	BLT	60$		;IF LT NO
	MOVB	#'-,(R0)+	;INSERT FILL BYTE
	BR	50$		;
60$:	MOV	#TASRHT,R3	;POINT TO TASK MESSAGE
	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

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

DSPLY:	MOV	#1,R4		;SET INITIAL IMAGE PROTOTYPE INDEX
10$:	CMP	R4,#64.*14.	;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
	MOV	#33,R2		;GET CURSOR ADDRESS CONTROL CHARACTER
	CALL	OUTSPC		;
	MOV	#'Y,R2		;
	CALL	OUTCHR		;OUTPUT CURSOR ADDRESS CONTROL CHARACTER
	ADD	#31.+4.,R0	;ADD COORDINATE OFFSET VALUE
	CMP	#31.+11.,R0	;AT SCREEN SPLIT?
	BHI	30$		;IF HI NO
	ADD	#3.,R0		;ADJUST DOWN THREE LINES
30$:	MOV	R0,R2		;COPY CO-ORDINATE VALUE
	CALL	OUTSPC		;OUTPUT SPECIAL CHARACTER
	ADD	#40,R1		;CALCULATE 'X' CO-ORDINATE
	MOV	R1,R2		;COPY CO-ORDINATE VALUE
	CALL	OUTCHR		;OUTPUT CO-ORDINATE CHARACTER
	CALL	OUTCON		;OUTPUT NON-IDENTICAL CHARACTER
	BR	10$		;GO AGAIN
40$:	MOV	#HO,R2		;SET TO HOME CURSOR
	CALL	OUTSPC		;OUTPUT HOME CURSOR CONTROL CHARACTER
	CALLR	OUTBUF		;FLUSH DISPLAY BUFFER

;+
; **-COORD-CALCULATE DISPLAY CO-ORDINATE VALUES
;
; INPUTS:
;
;	R4=PROTOTYPE DISPLAY INDEX.
;-

COORD:	MOV	R4,R0		;SET DIVIDEND
	DEC	R0		;BACK OFF BY 1
	MOV	#64.,R1		;SET DIVISOR
	CALLR	$DIV		;CALCULATE CO-ORDINATE VALUES

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

	.ENABL	LSB
INIBUF:	MOV	#CURIMG+1,R0	;POINT TO CURRENT IMAGE DISPLAY PROTO
	CALL	10$		;INITIALIZE CURRENT IMAGE DISPLAY
INIDIS:	MOV	#DISIMG+1,R0	;POINT TO NEXT IMAGE DISPLAY PROTO
10$:	MOV	#64.*14.,R1	;SET SIZE OF BUFFER IN BYTES
20$:	MOVB	#' ,(R0)+	;INSERT A BLANK IN PROTOTYPE
	DEC	R1		;ANY MORE BYTES TO BLANK?
	BGT	20$		;IF GT YES
	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
	BCS	10$		;IF CS DIRECTIVE ERROR
	WTSE$S	#1		;WAIT FOR I/O TO COMPLETE
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
	INC	BUFPTR		;INCREMENT BUFFER POINTER
	INC	BUFCTR		;INCREMENT BYTE COUNT
	CMP	#64.*4,BUFCTR	;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
	CALL	OUTCHR		;OUTPUT CHARACTER
	INC	R4		;INCREMENT PROTOTYPE IMAGE INDEX
	RETURN			;

;+
; **-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			;

;+
; **-OUTSPC-OUTPUT SPECIAL CHARACTER WITH FILL
;
; INPUTS:
;
;	R2=CHARACTER TO BE OUTPUT WITH FILL.
;-

OUTSPC:	CALL	OUTCHR		;OUTPUT CHARACTER
OUTFIL:	MOV	#F$LNUM,-(SP)	;SET FILL COUNT
	CLR	R2		;SET FILL CHARACTER TO NULL
10$:	CALL	OUTCHR		;OUTPUT A FILL CHARACTER
	DEC	(SP)		;ANY MORE TO OUTPUT?
	BGT	10$		;IF GT YES
	TST	(SP)+		;REMOVE COUNT FROM STACK
	RETURN			;

;+
; **-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:	MOVB	(R3)+,(R2)+	;MOVE A CHARACTER TO DISPLAY BUFFER
	TSTB	(R3)		;ANY MORE CHARACTERS TO MOVE?
	BNE	XFRHOR		;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 PARTITION 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			;

 
	.END	RMDEMO