.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 01-JUN-78 F.BORGER ADAPT TO SOROCS & BEEHIVES ; 025 09-JUL-80 JEFF GOODENOUGH RESET VT100 IN ANSI MODE TO VT52 ; ARNOLD HAY AND RESTORE ON EXIT ; 033 08-AUB-83 F. BORGER KEEP TRACK OF MAX MEMORY USED ; .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 ; .MCALL TTSYM$ ; TTSYM$ DEF$G TTSYM$ ; EQUATED SYMBOLS ; DSW=0 ;DSW IS LOCATION 0 FASTER=0 ;IF NON-ZERO - USE WSIG$ NOT WTSE$ OFFSET=31. ;CURSOR CAD OFFSET MRLX=67. ;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 ; +++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 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 \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 ; FIRTTY::.WORD 0 ;PUD ADDRESS FOR TT1: NUMTTY::.WORD 0 ;NUMBER OF TTY'S (NOT INCL TT0) VT05FG::.WORD 0 ;++002 FLAG SET IF OUTPUT TO VT05 VT50FG::.WORD 0 ;++006 FLAG SET IF OUTPUT TO VT50 VT52FG::.WORD 0 ;F. B. FLAG FOR A TRUE VT52 V100FG::.WORD 0 ;++025 FLAG FOR VT100 RESET TO VT52 DISCO: .WORD 0 EXFLG: .WORD 0 ;++003 CTRL-C AST SEEN - EXIT UIFLG: .WORD 0 ;++008 SET ON UNSOLICITED INPUT SEEN LOGFLG: .WORD 0 ;FB FLAG THAT LOGGED ON LINE MUST BE RE-SENT LASTX: .WORD 0 ;++004 X COORD OF LAST CHAR LASTY: .WORD 0 ;++004 Y COORD OF LAST CHAR GRAIN:: .WORD 24. ;++006 SIZE IN BYTES OF ONE COLUMN SNDLST: .WORD 0 ;FB SHOWS SNDITM OR SNDNUL SENT LAST TIME 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+ ;++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 MAXFLG: .WORD 1 ;++033FRB FLAG THAT MAX MEMORY HAS CHANGED MAXVAL: .WORD 0 ;++033FRB MAXIMUM MEMORY VALUE (BLOCKS) ; ; DISPLAY OUTPUT MESSAGES ; .NLIST BEX CLR50: .ASCIZ /E/ ;++019 HOME AND CLEAR FOR BEEHIVE CLR52: .ASCIZ /*//= / ;++002 HOME AND CLEAR FOR SOROC ;ADDED SPACES DUE TO SCOPE ERROR AT LOW SPEED CLR52T: .ASCIZ /H//J/ ; F.B. HOME AND CLEAR FOR VT52 MODE52: .ASCIZ /[?2/<154> ;++025 SET TO VT52 MDE100: .ASCIZ //[1;1/<150> ;++025 SET TO VT100 LUNMSG: .ASCII <7>/OUTPUT LUN ERROR - CHECK LUN 1/ LUNSIZ=.-LUNMSG TRMMSG: .ASCII /INVALID TERMINAL TYPE/ ;++008 TRMSIZ=.-TRMMSG NODLN1: ITEM 2,26., NODLN2: ITEM 2,39., NODAD1: ITEM 2,32.,< > NODAD2: ITEM 2,48.,< > CORLN1: ITEM 11.,1.,<****************************************************************> CORLN2: ITEM 12.,1.,<+-------+-------+-------+-------+-------+-------+-------+-------> CORLN3: ITEM 13.,1.,<****************************************************************> LOGLN1: ITEM 22.,1., LOGLN2: ITEM 23.,1., LOGLN3: ITEM 24.,10.,< > MAXMEM: ITEM 2,54., ;++033FRB MAX MEMORY ITEM ;.IF DF IAS ; +++001 HDRMG1: ITEM 1,60., ;++002 +++018 ;.IFF ;HDRMG1: ITEM 1,60., ;++015 ;.ENDC HDRMG2: ITEM 1,32., ;++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,67., ;++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 DAYTAG: .ASCII /SUNDAY MONDAY TUESDAY WEDNESDAY / .ASCII /THURSDAY FRIDAY SATURDAY / .EVEN BEGADR:: .WORD 2400 ;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 ; ; 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,,,, ;++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!TF.TMO,1,1,,IOSB,, ;++008/014 MKTDPB: MRKT$ 2,0,2 ;++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,,,, EXIT$S TRMERR: QIOW$C IO.WVB,5,5,,,, EXIT$S ;+ ; **-RDDEMO-RSX11D TASK SWAPPING AND LOADING DISPLAY PROGRAM ;- 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 CMPB IOSB+2,#T.V100 ;++025 VT100 ? BNE 111$ ;++025 BR IF NOT MOV #T.VT52,IOSB+2 ;++025 YES, FAKE US OUT INC V100FG ;++025 SHOW WE CHANGED TERMINAL MOV #MODE52,R3 ;++025 CHANGE SCOPE TO VT52 MODE CALL OUTLN2 ;++025 BUFFER IT CALL OUTBUF ;++025 AND OUTPUT IT 111$: ;++025 CMPB IOSB+2,#T.VT52 ;A VT52 ? BNE 222$ ;NO MOV #1,VT52FG ;YES SHOW IT 222$: 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 2$ ;++019 ASSUME NO 12 LINE TERMINALS CMPB IOSB+2,#T.BEEH ;++019 OR A BEEHIVE ? BEQ 2$ ;++019 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.USR1 ;++002,019 USR1 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 #*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 MOV .PUDBA,R2 ;START AT FIRST PUD 444$: CMP (R2),#"TT ;FOUND A TERMINAL ? BNE 666$ ;BR IF NOT TST NUMTTY ;IS THIS FIRST TT PUD FOUND ? BNE 555$ ;BR IF NOT MOVB 2(R2),NUMTTY ;ELSE REMEMBER NUMBER OF TTY'S 555$: CMPB 2(R2),#1 ;IS IT TTY #1 ? BEQ 777$ ;BR IF IT IS 666$: ADD #U.SZ,R2 ;BUMP PUD POINTER TO NEXT PUD CMP R2,.PUDEA ;ARE WE STILL IN THE PUD ? BLOS 444$ ;BR IF OK 777$: MOV R2,FIRTTY ;SET ADDRESS OF FIRST TTY CLR R2 ;++012 INIT R1 JUST IN CASE DIR$ #GETMCR ;GET THE COMMAND LINE BCS RESTRT ;IF NONE JUST START MOV DSW,R5 ;GET CHAR COUNT OF MCR COMMAND LINE SUB #3,R5 ;ANY MORE THAN TASK NAME BEQ RESTRT ;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 RESTRT ;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 ;++019 NO 12 LINE TERMINALS ; 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) ;++019 ASSUME NO 12 LINE TERMINALS ; 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 INC MAXFLG ;++033FRB RE-DISPLAY MAXIMUM MEMORY ;+ ; **-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 ;++019 ASSUME NO 12 LINE TERMINALS ; 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 TST VT05FG ;+++FB IF A VT05, IT WON'T FIT BNE 222$ MOV #LOGLN1,R3 ;DISPLAY LOGGED ON TERMINAL LINES CALL OUTITM MOV #LOGLN2,R3 CALL OUTITM 222$: INC LOGFLG ;SET FLAG CAUSE THIS COULD BE A REASTART 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 @#KP.AR1,R5 ;GET PAR 1 SUB @#KP.AR0,R5 ;SUB START OF EXEC MOV @#KP.DR1,R4 ;GET PAGE DESC REGISTER ASH #-10,R4 ;NUMBER OF BLOCKS READABLE BY PAR1 INC R4 ;ADJUST CAUSE 0 MEANS ONE BLOCK OF ACCESS ADD R4,R5 ;ADD, NOW HAVE EXEC BLOCK SIZE 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 ;+ ; **-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 TST V100FG ;++025 DID WE CHANGE VT100 TO VT52 ? BEQ 10$ ;++025 BR IF NOT MOV #MDE100,R3 ;++025 ELSE RESET TO VT100 CALL OUTLN2 ;++025 BUFFER IT CALL OUTBUF ;++025 AND OUTPUT IT 10$: ;++025 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 #TIMBUF,R1 ;POINT TO TIME BUFFER JSR PC,DAYOFW ;CALC DAY OF WEEK IN R1 MUL #10.,R1 ;MAKE R1 OFFSET ADD #DAYTAG,R1 ;INTO DAY NAMES BUFFER MOV #10.,R3 ;USE R3 AS COUNTER 111$: MOVB (R1)+,(R0)+ ;FILL IN DAY SOB R3,111$ ;UNTIL DONE 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 LOGGED ON TERMINALS ; DSLOG: MOV #LOGLN3+2,R0 ;R0 POINTS TO LINE TO FILL MOVB #40,(R0)+ ;MOVE IN A SPACE MOV NUMTTY,R1 ;R1 CONTAINS COUNT MOV FIRTTY,R2 ;R2 POINTS TO FIRST TTY PUD ADD #U.TF,R2 ;BUMP TO TERMINAL FLAGS WORD CLR DISCO CLR R4 ;CLEAR CHANGE COUNT LOOP: BITB #UT.LG,(R2) ;IS HE LOGGED ON ? BNE 1$ ;BR IF HE IS MOVB #40,R3 ;ELSE PUT IN A SPACE BR 2$ 1$: MOVB #'*,R3 ;A STAR IF LOGGED ON BITB #UT.PR,(R2) ;IS HE PRIVILEGED ? BEQ 11$ ;NO MOVB #'P,R3 ;IF SO, CHANGE INDICATOR 11$: BITB #10,(R2) ;IS HE HOSTILE BEQ 2$ ;NO MOVB #'H,R3 ;YES 2$: CMPB R3,(R0) ;DID THIS TERMINAL'S STATUS CHANGE ? BEQ 22$ ;NO INC R4 ;SHOW CHANGE 22$: MOVB R3,(R0)+ ;PUT IN CHARACTER INC DISCO CMP DISCO,#7 BNE 24$ 23$: MOVB #40,(R0)+ ;A SPACE MOVB #40,(R0)+ ;A SPACE MOVB #40,(R0)+ ;A SPACE JMP 27$ 24$: CMP DISCO,#17 BNE 25$ BR 23$ 25$: CMP DISCO,#27 BNE 26$ BR 23$ 26$: CMP DISCO,#37 BNE 27$ BR 23$ 27$: SUB #U.SZ,R2 ;BUMP TO NEXT TTY PUD ;PUDS ARE LISTED IN REVERSE ORDER SOB R1,LOOP ;DO THIS FOR N TERMINALS TST LOGFLG ;RESTART MAKE OUTPUT MANDATORY ? BNE 33$ ;BRANCH IF YES TST R4 ;DID ANYTHING CHANGE BEQ 44$ ;++033FRB BR IF NOTHING CHANGED 33$: TST VT05FG ;+++FB OR WON'T IT FIT BNE 44$ ;++033FRB MOV #LOGLN3,R3 ;ELSE OUTPUT THE ITEM CALL OUTITM CLR LOGFLG ;AND CLEAR RESTART FLAG 44$: TST MAXFLG ;++033FRB DID MAX CHANGE ? BEQ DSTSK ;++033FRB BR IF NOT MOV MAXVAL,R1 ;++033FRB ELSE CONVERT VALUE ASH #-5,R1 ;++033FRB FROM BLOCKS TO K-WORDS CLR R2 ;++033FRB SUPRESS LEADING 0'S MOV #MAXMEM+11.,R0 ;++033FRB POINT TO ITEM TO RECEIVE ASCII CALL $CBDMG ;++033FRB CONVERT VALUE MOV @#.SWSWR,R1 ;++033FRB NOW GET ALL-TIME MAX ASH #-5,R1 ;++033FRB CONVERT IT TOO MOVB #'K,(R0)+ ;++033FRB PUT IN A "K" MOVB #'/,(R0)+ ;++033FRB AND A SLASH CALL $CBDMG ;++033FRB CONVERT MAX EVER VALUE TO ASCII MOV #MAXMEM,R3 ;++033FRB POINT TO ITEM CALL OUTITM ;++033FRB AND OUTPUT IT CLR MAXFLG ;++033FRB SHOW WE DID 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 BIT #AF.IA!AF.CP,A.TF(R4) ;; +++018 A TIMESHARING TASK? ;OR A REAL-TIME TASK THAT'S CKPOINTED ? BEQ 10$ ;; +++018 YES IF NE BIT #AF.CP,A.TF(R4) ;IS IT A CHECKPOINTED REAL-TIME TASK ? BNE 20$ ;IF IT IS, PUT IT IN OUR MRL LIST CMPB A.TS(R4),#TS.MRL ;; +++018 A 'MEMORY REQUIRED' STATE? BEQ 20$ ;; +++018 YES IF EQ CMPB A.TS(R4),#TS.MRE ;; +++018 BNE 10$ ;; +++018 NO IF NE 20$: ;; +++018 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 MOV G.BA(R4),R3 ;++033FRB CALCULATE END OF REGION ADD G.CZ(R4),R3 ;++033FRB AS START PLUS SIZE CMP R3,MAXVAL ;++033FRB IS THIS BIGGEST THING YET ??? BLE 999$ ;++033FRB BR IF NOT MOV R3,MAXVAL ;++033FRB IF BIGGEST, SAVE FOR LATER INC MAXFLG ;++033FRB AND SHOW CHANGE CMP R3,@#.SWSWR ;++033FRB BIGGEST EVER ? BLE 999$ ;++033FRB SKIP IF NOT MOV R3,@#.SWSWR ;++033FRB SAVE IT, (SCREEN UPDATE ALREADY SET) 999$: ;++033FRB 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 MOV A.HA(R4),R3 ;++033FRB CALCULATE END OF TASK ADD A.TZ(R4),R3 ;++033FRB AS START PLUS SIZE CMP R3,MAXVAL ;++033FRB IS THIS BIGGEST THING YET ??? BLE 999$ ;++033FRB BR IF NOT MOV R3,MAXVAL ;++033FRB IF BIGGEST, SAVE FOR LATER INC MAXFLG ;++033FRB AND SHOW CHANGE CMP R3,@#.SWSWR ;++033FRB BIGGEST EVER ? BLE 999$ ;++033FRB SKIP IF NOT MOV R3,@#.SWSWR ;++033FRB SAVE IT, (SCREEN UPDATE ALREADY SET) 999$: ;++033FRB 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 CMPB A.TS(R4),#TS.MRL ;; +++018 A MEMORY REQUIRED STATE? BEQ 10$ ;; +++018 YES IF EQ CMPB A.TS(R4),#TS.MRE ;; +++018 A MEMORY REQUIRED STATE? BEQ 10$ ;; +++018 YES IF EQ BIT #AF.CP,A.TF(R4) ;IS IT A REAL TIME TASK THAT'S CHECKPOINTED BNE 10$ ;IF SO, DON'T SHOW IT IN MAIN MEMORY 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 MOV A.HA(R4),R0 ;; ++024 GET START ADDRESS ADD A.TZ(R4),R0 ;; ++024 FORM END ADDRESS CMP R0,BEGADR ;; ++024 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 A.TZ(R4),(R5)+ ;; ++021 GET TASK SIZE MOV A.HA(R4),(R5)+ ;;GET STARTING ADDR OF TASK BR 10$ ;; +++018 ;; +++018 36 LINES DELETED DSFTL: ;++033FRB NOTE THAT WE DON'T THINK FIXED TASKS ;++033FRB WILL BE LAST THING IN MEMORY, EVER 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 A.TZ(R4),(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: .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$: CMP R3,SNDLST ;FB WAS LINE THE SAME LAST TIME ? BEQ 38$ ;BRANCH IF YES MOV R3,SNDLST ;REMEMBER FOR NEXT TIME CALL OUTITM ;OUTPUT THE CHANGED ITEM BR 40$ ;AND CONTINUE 38$: MOV R3,SNDLST ;REMEMBER FOR NEXT TIME 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 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$: ; MOV #HO,R2 ;SET TO HIOME CURSOR MOV #0,R2 ;++019 DIFFERENT HOME FOR SOROCS 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 ;--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 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 9$: 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 MOV #'Y,R2 ;++002 TST VT52FG ;F.B. A REAL VT52 ? BNE 11$ ; BR IF TRUE MOV #'=,R2 ;++019 DIRECT ADDRESS DIFFERENT FOR SOROCS 11$: 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 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: TST VT05FG ;++002 RUNNING ON VT05? BEQ 20$ ;++002 J IF NOT MOV #HO,R2 ;HOME CURSOR TO BEGIN CALL OUTSPC ;OUTPUT SPECIAL CHARACTER MOV #ES,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 TST VT50FG ;++019 BUT COULD BE A BEEHIVE BEQ 21$ ;++019 BR IF NOT A BEEHIVE MOV #CLR50,R3 ;++019 ELSE CHANGE STARTUP 21$: TST VT52FG ; F. B. A REAL VT52 ? BEQ 22$ ; NO MOV #CLR52T,R3 ; YES, USE VT52 SEQUENCE 22$: CALL OUTLN2 ; OUTPUT THE SEQUENCE 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