.TITLE DEMO .IDENT /15/ ; ; 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 13-DEC-77 RAY FRENCH MODIFIED FOR BEEHIVE TERMINAL ; 014 14-DEC-77 RAY FRENCH CORRECT ERRORS FOR FASTER=1 ; 015 12-JAN-78 RAY FRENCH ADD SWAP FILE TASKS TO DISPLAY ; .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,CALL,RETURN,QIOW$,ASTX$C .MCALL WTSE$S,MRKT$S,QIOW$C,GMCR$,EXIT$C,GLUN$ .MCALL EXIT$S .MCALL MRKT$C, WTSE$C, GTIM$C .MCALL SETF$S,ASTX$S,QIO$,CMKT$S ;++009 ; ; EQUATED SYMBOLS ; IAS=0 ;DEFAULT TO IAS 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=16. ;MAX MRL TASKS TO DISPLAY MAXM50=8. ;++007 MAX MRL TASKS FOR VT50 MRLBUF=8.*20. ;MENU BUFFER SIZE MAXPAR=20. ;MAX PARTITIONS SPLIT=11. ;++002 SCREEN SPLIT COORD TASKY=4. ;++002 TASK Y COORD DISBUF=64.*14. ;DISPLAY BUFFER SIZE CD=106 ;CURSOR DISPLAY CR=15 ;CARRIAGE RETURN EL=113 ;ERASE TO END OF LINE ES=112 ;ERASE TO END OF SCREEN LF=12 ;LINE FEED HO=110 ;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 ; ; ; ; LOCAL MACROS ; .MACRO INH0 MOV PS.EXP,-(SP) BIS #140,PS.EXP .ENDM ;++002 ; MACRO TO SET UP ITEM WITH CURSOR POSITION FOR USE BY 'OUTITM' ;--002 .MACRO ITEM X,Y,STR .ASCIZ \STR\ .ENDM ITEM ; ; 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 COLS: .WORD 128. ;++006 # COLS IN DISPLAY (64 FOR VT50) IMGSZE: .WORD DISBUF ;++010 IMAGE SIZE MRLTOP: .WORD MRLLST+ ;++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 ; ;CLR52: .ASCIZ /H//J/ ;++002 HOME AND CLEAR FOR VT52 CLR52: .ASCIZ /E/ ;++013 - CLEAR BEEHIVE TERMINAL LUNMSG: .ASCII <7>/OUTPUT LUN ERROR - CHECK LUN 1/ LUNSIZ=.-LUNMSG TRMMSG: .ASCII /INVALID TERMINAL TYPE/ ;++008 TRMSIZ=.-TRMMSG NODLN1: ITEM 2,27., NODLN2: ITEM 2,40., 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., ;++002 .IFF HDRMG1: ITEM 1,60., ;++002 .ENDC HDRMG2: ITEM 1,26., ;++002 TSKLN1: ITEM 2,1, ;++005 TSKITM: ITEM 2,13., ;++005 RDITM: ITEM 3,1,< > ;++008 RDITM2: ITEM 3,1,< > ;++008 NTKITM: ITEM 2,13., ;++005 MRLMG1: ITEM 3,68., ;++002 MRLMG2: .ASCIZ /XXXXXX/ .EVEN FIX: .RAD50 /FIX/ .RAD50 /ED / PUR: .RAD50 /PUR/ TASLFT: .ASCIZ // ; TASOFF: .ASCIZ /-/ TIMLOC: ITEM 1,1,< > .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 .EVEN ; ; 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 ; .IF NZ FASTER MRKT: MRKT$ 2,TIME,1,MTAST .ENDC ; ; DISPLAY OUTPUT QIO DPB ; DSQIO: QIOW$ IO.WLB!IO.WAL,1,1,,,, ;++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,, IOSB: .BLKW 2 .IF DF,IAS ATTDPB: QIOW$ IO.ATA,1,1,,,,<,UIAST> ;++008 .IFF ATTDPB: QIOW$ IO.ATA,1,1,,,, ;++008 .ENDC DETDPB: QIOW$ IO.DET,1,1 ;++003 INPDPB: QIOW$ IO.RLB,1,1,,IOSB,, ;++008 ; ; 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 .PSECT ATLBUF,CON .WORD 0 ;ZERO SENTINEL WORD EXECNA: .RAD50 /C / ;DISPLAY FOR EXECME: .RAD50 /EXE/ ; EXEC EXECSZ: .WORD .SG.EX ;EXEC SIZE EXECBA: .WORD 0 ;EXEC BEGINNING ADDR SCOMNA: .RAD50 /M / ;DISPLAY FOR SCOMME: .RAD50 /SCO/ ; SCOM SCOMSZ: .WORD 0 ;SCOM SIZE SCOMBA: .WORD 0 ;SCOM BEGINNING ADDR TSKLST: ;BEGINNING ADDR OF ATL STORAGE ; 4 WORDS PER ENTRY - ALLOCATED ; AT TASK BUILD TIME .PSECT SWAP: .BLKW 1 ;+015 - SCRATCH WORD MRLLH: .BLKW MAXPAR ;BUFFER SPACE FOR MRL LISTHEADS 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 ;+ ; 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 G,CMDG ;++012 G - SET GRANULARITY 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,,,, EXIT$S TRMERR: QIOW$C IO.WVB,5,5,,,, EXIT$S ;+ ; **-RDDEMO-RSX11D TASK SWAPPING AND LOADING DISPLAY PROGRAM ;- DEMO:: ;++013 DIR$ #GETTYP ;++002 GET TERMINAL TYPE ;++013 BCS LUNERR ;++002 J IF LUN NOT ASSIGNED ;++013 CMPB IOSB,#IE.IFC ;++002 FUNCTION NOT RECOGNISED? ;++013 BEQ 2$ ;++002 J IF SO, ASSUME AS BUILT ;++013 MOV #1,VT05FG ;++002 ASSUME VT05 ;++013 CMPB IOSB+2,#T.VT05 ;++002 VT05? ;++013 BEQ 2$ ;++002 J IF SO ;++013 CLR VT05FG ;++006 CLEAR VT05 FLAG ;++013 MOV #1,VT50FG ;++006 ASSUME VT50 ;++013 CMPB IOSB+2,#T.VT50 ;++006 WELL? ;++013 BEQ 1$ ;++006 J IF CORRECT ;++013 CLR VT50FG ;++006 ELSE CLEAR THE FLAG ;++013 CMPB IOSB+2,#T.VT52 ;++002 VT52 OR HIGHER? ;++013 BLO TRMERR ;++002 J IF NOT, ILLEGAL TYPE ;++013 CMPB IOSB+2,#T.VT61 ;++002 VT61 OR LESS? ;++013 BHI TRMERR ;++002 J IF NOT ;++013 BR 2$ ;++006 SKIP VT50 CODE ;++0131$: ASR COLS ;++006 DIVIDE # COLS BY 2 FOR VT50 ;++013 SUB #*4,MRLTOP ;++007 REDUCE MAX MRL ENTRIES ;++013 ASR IMGSZE ;++010 REDUCE MAX IMAGE SIZE 2$: DIR$ #ATTDPB ;++003 ATTACH TO THE TERMINAL AND DECLARE AST'S 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 RESTRT: MOV BEGADR,ENDADR ;++012 SAVE ENDING MOV GRAIN,R3 ;++006 GET SIZE OF ONE COLUMN ASH #6,R3 ;++006 MULTIPLY BY 64 (#COLUMNS) ;++013 TST VT50FG ;++006 RUNNING ON VT50? ;++013 BNE 20$ ;++006 J IF SO ;++013 ASL R3 ;++006 ELSE WE HAVE 128 COLUMNS 20$: ADD R3,ENDADR ;++006 MOVE UP TO ENDING ADDRESS MOV BEGADR,R1 ;++012 PICK UP START ADDRESS ASH #-5,R1 ;CONVERT BLOCKS TO DECIMAL K 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 CLR SCOMSZ ;++011 RESET SIZE OF SCOM ;+ ; **-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 MOV #TSKLN1,R3 ;++007 'ACTIVE TASK=' CALL OUTITM ;++007 DISPLAY THE ITEM 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 ;++014 TST VT50FG ;++006 RUNNING ON VT50? ;++013 BNE 3$ ;++006 YES, DON'T PRINT SECOND LINE MOV #CORLN3,R3 ;POINT TO THIRD MEMORY DISPLAY LINE CALL OUTITM ;++002 DISPLAY LINE 3$: CMP KP.AR0,BEGADR ;IS THE EXEC OFF SCREEN BLO 5$ ;BR IF YES MOV #.SG.EX,R5 ;GET EXEC SIZE IN BYTES ADD #77,R5 ;ROUND TO NEXT BLOCK ASH #-6,R5 ;MAKE IT BLOCKS MOV R5,EXECSZ ;SAVE SIZE MOV KP.AR0,EXECBA ;GET THE EXEC BEGINNING ADDR 5$: MOV #KP.DR7,R5 ;ADDR OF KERNAL PDR 7 MOV #3,R4 ;MAX LOOP COUNT 10$: ADD #200,SCOMSZ ;CALC THE SIZE OF SCOM BIT #ED,-(R5) ;IS THIS PAGE EXPANDING DOWN BNE 20$ ;BR IF YES SOB R4,10$ ;LOOP TIL DONE BR DSPAR ;CONTINUE 20$: CLR R4 ;SET UP FOR BISB BISB 1(R5),R4 ;GET PAGE LENGTH FIELD SUB R4,SCOMSZ ;CALC RIGHT SIZE MOV 40(R5),SCOMBA ;GET THE BEGINNING ADDR OF SCOM ADD R4,SCOMBA ;CALC RIGHT SIZE MOV #^RM ,SCOMNA ;++012 ASSUME SCOM WILL BE DISPLAYED MOV #^RSCO,SCOMME ;++012 CMP SCOMBA,BEGADR ;IS SCOM BEGINNING ADDRESS OFF SCREEN BHIS 30$ ;BR IF NO CLR SCOMBA ;FLAG END OF DATA TST EXECBA ;ARE WE TO DISPLAY THE EXEC BEQ 30$ ;BR IF NO MOV EXECBA,SCOMBA ;MOVE THE MOV EXECSZ,SCOMSZ ; EXEC INFO MOV EXECNA,SCOMNA ; UP SO IT MOV EXECME,SCOMME ; WILL SHOW UP CLR EXECBA ;FLAG END OF DATA 30$: ;+ ; **-DSPAR-DISPLAY PARTITION CONFIGURATION AND SET UP MRL LISTHEADS ;- DSPAR: MOV #MRLMG1,R3 ;POINT TO MRL DISPLAY HEADER CALL OUTITM ;++002 DISPLAY LINE MOV #MRLLH,R3 ;SET UP POINTER MOV .TPDBA,R4 ;GET TPD BEGINNING ADDR MOV #MAXPAR,R1 ;GET BUFFER SIZE BR 15$ 10$: ADD #T.SZ,R4 ;MOVE TO NEXT TPD ENTRY CMP .TPDEA,R4 ;DONE BLOS DSCTL ;BR IF YES 15$: MOV R4,(R3) ;SAVE MRL LISTHEAD ADD #T.RF,(R3)+ ; ADDR FOR LATER CLR (R3) ;FLAG END JUST IN CASE DONE SOB R1,10$ ;LOOP TIL DONE ;+ ; **-DSCON-DISPLAY CONTROL ;- .IF Z FASTER DSCTL: CALL INIBUF ;INITIALIZE OUTPUT DISPLAY PROTOTYPES MKT: MRKT$C 2,TIME,1 ; +++001 MARK TIME FOR SPECIFIED TIME CALL INIDIS ;INITIALIZE NEXT DISPLAY PROTOTYPE CALL DSTIM ;DISPLAY TIME AND TASKS WTSE$C 2 ; +++001 WAIT FOR MARK TIME TST EXFLG ;++003 EXIT REQUIRED? BNE EXIT ;++003 J IF SO TST UIFLG ;++008 UNSOLICITED INPUT SEEN? BNE RDINPT ;++008 GO LOOK AT IF SO BR MKT ; +++001 .ENDC .IF NZ FASTER DSCTL: CALL INIBUF ;INITIALIZE OUTPUT DISPLAY PROTO DIR$ #MRKT ;ISSUE STARTING MARK TIME DSCTL1: CALL INIDIS ;INITIALIZE NEXT DISPLAY PROTO CALL DSTIM ;DISPLAY TIME AND TASKS WSIG$C ;WAIT FOR NEXT SIG EVENT TST EXFLG ;++003 EXIT REQUIRED? BNE EXIT ;++003 GET OUT IF SO ;++013 NEXT TWO LINES ADDED TST UIFLG ;++008 UNSOLICITED INPUT SEEN? BNE RDINPT ;++008 GO LOOK AT IF SO BR DSCTL1 ;DO IT ALL AGAIN ; ; ; MTAST: TST (SP)+ ;CLEAN UP THE STACK DIR$ #MRKT ;REISSUE MARK TIME ASTX$C ;EXIT THE AST .ENDC 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 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$C 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 #MRLLH,R0 ;;ADDR OF MRL LISTHEAD LIST 10$: MOV (R0),R4 ;;GET LIST HEAD ADDR BEQ DSATL ;;BR IF DONE MOV (R0)+,R1 ;;GET LISTHEAD ADDR 20$: MOV @R4,R4 ;;GET NEXT ENTRY CMP R1,R4 ;;DONE BEQ 10$ ;;BR IF YES MOV A.TD(R4),R3 ;;GET STD ADDRESS MOV S.TN(R3),(R5)+ ;;GET TASK MOV S.TN+2(R3),(R5)+;; NAME CMP R5,MRLTOP ;;++007 BUFFER FULL? BLO 20$ ;;BR IF NO DSATL: MOV R5,SWAP ;;+015 - SAVE MRL POINTER CLR (R5) ;;FLAG END OF MRL DATA MOV #TSKLST,R5 ;;ADDR OF ATL TEMP STORAGE 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 ;015 BEQ DSFTL ;;BR IF YES BNE 102$ ;;+015 JMP DSFTL ;;+015 102$: ;;+015 CMP R5,#TSKLST+;;ANY MORE ROOM BHIS 17$ ;;BR IF NO MOV A.TD(R4),R3 ;; +++001 GET THE STD .IF DF,IAS ;;++001/005 BIT #AF.IA,A.TF(R4) ;; +++001 IS IT TIMESHARING TASK? BEQ 11$ ;; +++001 NO CMPB #TS.RRS,A.TS(R4);; +++001 SWAP COMPLETE? ;015 BEQ 13$ ;; +++001 YES: GET NEXT BNE 52$ ;;+015 50$: MOV SWAP,R2 ;;+015 BEQ 13$ ;;+015 MOV S.TN(R3),(R2)+ ;;+015 MOV S.TN+2(R3),(R2)+ ;;+015 CLR (R2) ;;+015 CMP R2,MRLTOP ;;+015 BLO 51$ ;;+015 CLR SWAP ;;+015 BR 13$ ;;+015 51$: MOV R2,SWAP ;;+015 BR 13$ ;;+015 52$: ;;+015 CMPB #TS.LRQ,A.TS(R4);; +++001 LOAD QUEUED? BNE 11$ ;; +++001 NO +015 12$ TO 11$ TST A.HA(R4) ;; +++001 MEMORY OBTAINED? BEQ 50$ ;; +++001 +015 10$ TO 50$ BR 11$ ;; +++001 +015 12$ TO 11$ 11$: ;; +++001 .ENDC ;;++005 CMPB #TS.RUN,A.TS(R4);;++001 TASK RUNNABLE OR MORE? BHI 10$ ;;++001 J IF NOT BNE 115$ ;;++005 J IF NOT ACTUALLY RUNNABLE 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 115$: CMPB #TS.WF4,A.TS(R4);;++005 LESS THAN W4? BLO 10$ ;;++005 J IF NOT 12$: ;; +++001 CMP A.HA(R4),BEGADR ;;IS THE TASK OFF SCREEN BLO 13$ ;;BR IF YES - IGNORE IT CMP A.HA(R4),ENDADR ;;IS THE TASK OFF SCREEN BHIS 13$ ;;BR IF YES - IGNORE IT MOV S.TN+2(R3),(R5)+;;GET TASK MOV S.TN(R3),(R5)+ ;; NAME MOV S.TZ(R3),(R5)+ ;;GET TASK SIZE MOV A.HA(R4),(R5)+ ;;GET STARTING ADDR OF TASK 13$: TST S.GC(R3) ;;ANY SGAS BEQ 10$ ;;BR IF NO MOV R3,R0 ;;SET UP ADD #S.GC,R0 ;; SGA POINTER MOV #3,R2 ;;ASSUME 16 WORD STD BIT #SF.24,S.FW(R3) ;;IS IT 24 WORDS BEQ 15$ ;;BR IF NO MOV #7,R2 ;SET COUNT FOR 24 WORD STD 15$: CMP R5,#TSKLST+;;ANY MORE ROOM 17$: BHIS DSFMT ;;BR IF NO MOV (R0)+,R1 ;;GET SGA POINTER BEQ 10$ ;;IF ZERO - DONE CMPB #GS.LRS,G.GS(R1);;IS THE SGA LOADED BNE 30$ ;;BR IF NO CMP G.BA(R1),BEGADR ;;IS THE SGA OFF SCREEN BLO 30$ ;;BR IF YES - IGNORE IT CMP G.BA(R1),ENDADR ;;IS THE SGA OFF SCREEN BHIS 30$ ;;BR IF YES - IGNORE IT CMP #35,G.BN(R1) ;;IS IT A PURE ROOT BNE 20$ ;;BR IF NO MOV S.TN+2(R3),(R5)+;;USE LAST THREE CHARS OF TASK NAME MOV PUR,(R5)+ ;;USE 'PUR' FOR RO ROOT BR 25$ 20$: MOV G.BN+2(R1),(R5)+;;GET SGA MOV G.BN(R1),(R5)+ ;; NAME 25$: MOV G.CZ(R1),(R5)+ ;;GET SGA SIZE MOV G.BA(R1),(R5)+ ;;GET STARTING ADDR OF SGA 30$: SOB R2,15$ ;;LOOP FOR MORE JMP 10$ ;;GET NEXT ENTRY 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,#TSKLST+;;ANY MORE ROOM BHIS DSFMT ;;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 FIX+2,(R5)+ ;;GET 'FIXED' MOV FIX,(R5)+ ;; TASK NAME 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 ; DSFMT: CALL ..ENB0 ;;ENABLE TASK SWITCHING ;++007 LINES DELETED 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 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 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 #6,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 #TASLFT,R3 ;POINT TO TASK MESSAGE CALL XFRVER ;TRANSFER VERTICLE MESSAGE MOV -(R5),R3 ;++006 GET SIZE OF TASK IN BLOCKS ADD GRAIN,R3 ;++006 ROUND UP AFTER DIVIDE... DEC R3 ;++006 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 #TASRHT,R3 ;POINT TO '>' 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 MOV #TASOFF,R3 ;POINT TO 'X' FOR OFF SCREEN 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 ; 50$: DEC R4 ;ANY MORE BYTES TO FILL? BLT 60$ ;IF LT NO MOVB #'-,(R0)+ ;INSERT FILL BYTE BR 50$ ; 60$: 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 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$: ;013 MOV #HO,R2 ;SET TO HIOME CURSOR ;013 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 MOV R4,R0 ;SET UP BUFFER ADDRESS CALL $CBDMG ;CONVERT BINARY TO DECIMAL MOV GRAIN,R1 ;++006 GET BLOCKS PER SINGLE COLUMN ASH #-2,R1 ;++006 MAKE INTO K FOR 8 COLS ADC R1 ;++006 ROUND ADD R1,R3 ;++006 AND ADD TO CURRENT ADDRESS 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 ;--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? ;++013 BNE 9$ ;++004 J IF NOT ;++013 TST VT05FG ;++004 ON VT05? ;++013 BEQ 9$ ;++004 J IF NOT, DO IT THE HARD WAY ;++013 MOV #BS,R2 ;++004 ELSE OUTPUT BACKSPACE ;++013 CALL OUTCHR ;++004 ;++013 MOV #LF,R2 ;++004 AND A LINE-FEED ;++013 CALL OUTSPC ;++004 ;++013 BR 999$ ;++004 NOW GET OUT 9$: ;++0139$: TST VT50FG ;++006 RUNNING ON VT50? ;++013 BNE 30$ ;++006 J IF SO ;++013 TST VT05FG ;++002 RUNNING ON VT05? ;++013 BEQ 10$ ;++002 J IF NOT ;++013 MOV #CD,R2 ;++002 GET START OF CURSOR CONTROL SEQ ;++013 CALL OUTCHR ;++002 AND OUTPUT IT ;++013 BR 20$ ;++002 SKIP VT52 STUFF 10$: MOV #ESC,R2 ;++002 OUTPUT ESCSEQ TO VT52 CALL OUTCHR ;++002 MOV #'F,R2 ;++013 CALL OUTCHR ;++013 ;++013 MOV #'Y,R2 ;++002 ;++013 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 ;++013 BR 999$ ;++006 GET OUT ;++01330$: MOV R3,-(SP) ;++006 VT50 - SAVE SOME SCRATCH ;++013 CMP R0,#1 ;++006 GOING TO LINE 1? ;++013 BNE 40$ ;++006 J IF NOT ;++013 MOV #ESC,R2 ;++006 ELSE DO CURSOR HOME ;++013 CALL OUTCHR ;++006 ;++013 MOV #'H,R2 ;++006 (ESC H) ;++013 CALL OUTCHR ;++006 ;++013 MOV #1,LASTX ;++006 AND SHOW WHERE WE ARE ;++013 MOV #1,LASTY ;++006 ;++01340$: MOV R1,R3 ;++006 COPY REQD HORIZ POS ;++013 SUB LASTX,R3 ;++006 SUBTRACT CURRENT POS ;++013 BEQ 80$ ;++006 J IF IN THE RIGHT PLACE ;++013 BPL 60$ ;++006 J IF GOING FORWARDS - MUST USE SPACE ;++013 NEG R3 ;++006 MAKE DIFFERENCE POSITIVE ;++013 CMP R3,R1 ;++006 GOING BACK MORE THAN HALF WAY? ;++013 BHI 50$ ;++006 J IF SO, USE CR THEN SPACES ;++013 MOV #BS,R2 ;++006 GET CHARACTER ;++013 BR 70$ ;++006 AND J TO DO IT ;++01350$: MOV #CR,R2 ;++006 DO A CR ;++013 CALL OUTCHR ;++006 ;++013 MOV R1,R3 ;++006 NOW GET # OF SPACES ;++013 DEC R3 ;++006 START AT ZERO ;++013 BEQ 80$ ;++006 J IF FIRST COL REQD ;++01360$: MOV #ESC,R2 ;++006 DO 'CURSOR FORWARD' ;++013 CALL OUTCHR ;++006 WHICH IS 'ESC C' ;++013 MOV #'C,R2 ;++006 ;++013 CALL OUTCHR ;++006 ;++013 SOB R3,60$ ;++006 LOOP TIL DONE ;++013 BR 80$ ;++006 AND SKIP ;++01370$: CALL OUTCHR ;++006 OUTPUT THE BYTE ;++013 SOB R3,70$ ;++006 AND LOOP ;++01380$: MOV R0,R3 ;++006 GET REQD VERTICAL POS ;++013 SUB LASTY,R3 ;++006 SUBTRACT CURRENT POS ;++013 BEQ 110$ ;++006 J IF NOTHING TO DO ;++013 BPL 100$ ;++006 J IF MOVING DOWN ;++013 NEG R3 ;++006 ELSE MUST DO 'CURSOR UP'S ;++01390$: MOV #ESC,R2 ;++006 WHICH IS 'ESC A' ;++013 CALL OUTCHR ;++006 ;++013 MOV #'A,R2 ;++006 ;++013 CALL OUTCHR ;++006 ;++013 SOB R3,90$ ;++006 LOOP TIL DONE ;++013 BR 110$ ;++006 NOW GET OUT ;++013100$: MOV #LF,R2 ;++006 MOVE CURSOR DOWN... ;++013 CALL OUTCHR ;++006 ;++013 SOB R3,100$ ;++006 ;++013110$: 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 OR 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: ;++013CLRSCR: TST VT05FG ;++002 RUNNING ON VT05? ;++013 BEQ 20$ ;++002 J IF NOT ;++013 MOV #HO,R2 ;HOME CURSOR TO BEGIN ;++013 CALL OUTSPC ;OUTPUT SPECIAL CHARACTER ;++013 MOV #ES,R2 ;ERASE TO END OF SCREEN ;++013 CALL OUTSPC ;OUTPUT SPECIAL CHARACTER ;++013 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 35$: ;++013 .IF Z FASTER ;++013 JMP MKT ;++013 .IFF ;++013 JMP DSCTL1 ;++013 .ENDC ;++013 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: CALL CMTB ;++012 GET SIZE CMP R2,#10 ;++012 LESS THAN 10? BLO 10$ ;++012 IGNORE IF SO MOV R2,GRAIN ;++012 ELSE SET UP GRAIN JMP RESTRT ;++012 AND GO AGAIN ;10$: JMP MKT ;++012 CARRY ON 10$: ;++013 .IF Z FASTER ;++013 JMP MKT ;++013 .IFF ;++013 JMP DSCTL1 ;++013 .ENDC ;++013 .END DEMO