.TITLE RMDEMO .IDENT /03.3X/ .SBTTL INTRODUCTION ; ; ; Originaly created by the DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS. ; Modified, updated, enhanced and distriubted by ; ; James G. Downward. ; KMS FUSION, INC. ; PO Box 1567 ; Ann Arbor, Mich. 48016 ; ; ; This is the last release of the old RMDEMO. A new RMDEMO supporting ; most terminals via a table driven driver is now actively supported ; by DIGITAL. This version of RMDEMO bears no internal resemblence to ; the new one. It is not now, and will not be in the future supported ; by DEC. It is the version of RMDEMO used for BL25(V3.2 field test) ; of RSX11M. It works well(no bugs) and has the following advantage. ; the new RMDEMO is about twice the size of this version. Users with ; small systems or with insufficient core may have trouble justifying ; running the new RMDEMO. This version maintains the original small ; size of RMDEMO and modifies the display page to provide the same ; information as the new rmdemo(ie worst case pool statistics). ; ; Note well users with good ideas. DEC does take suggestions. ; Worst case pool display in this RMDEMO was implemented when V3.1 came out. ; The suggestion that it would be good to incorporate it into RMDEMO ; was sent to DEC. They thought it was a good idea, and now it is in ; the new table driven RMDEMO. So if you have a good idea, pass it along. ; It may help you and the user community in the long run. ; ; In addition this version provides the same facility to replot ; the screen or exit via a keyboard command. If an 'R' is typed, ; RMD52 or RMD100 will reschedule itself to run in 2 sec and will exit. ; If an 'X' is typed it will exit. ; ; The RSX11M development group explicitly releases this version for ; use by the RSX community. It should run on any VT52 or VT100 in ; VT52 mode on either V3.1 or V3.2. The enhancements to the display, ; etc, are brought to you courtisy of KMS FUSION, INC. ; ; VERSION 01 ; ; D. N. CUTLER 7-JUN-75 ; ; PREVERSION 3.05 MODIFICATIONS BY: ; ; E. L. BAATZ ; K. E. KINNEAR ; C. A. D'ELIA ; ; MODIFIED BY: ; ; ERIC BAATZ 9-JUN-78 ; EB125 -- ALLOW FOR FIVE DIGIT POOL NUMBERS ; ; ERIC BAATZ 9-JUN-78 ; EB138 -- HANDLE SYSTEM SIZES GREATER THAN A MEGABYTE ; ; ERIC BAATZ 9-JUN-78 ; EB146 -- CORRECTLY WRITE OUT MEMORY LINE ; ; ERIC BAATZ 17-SEP-78 ; EB162 -- SHOUT V3.2 FROM THE ROOFTOP ; ; ERIC BAATZ 5-OCT-78 ; EB170 -- DO NOT DISPLAY THINGS THAT ARE OFF THE SCREEN ; ; JAMES G. DOWNWARD 1-MAY-79 ; 21-JAN-81 ; JGD -- PLACE DEVICE DISPLAY ON LINE 22 OF VT52 ; (CODE WON'T WORK FOR VT05) AND PROVIDE ; FOR A DISPLAY OF THE MINIMUM CONTIGUOUS ; BLOCKSIZE, AND MIN. TOTAL POOL, AS WELL AS ; FOR A DISPLAY OF THE MAXIMUM NUMBER OF POOL ; FRAGMENTS. SINCE THE DEVICE DISPLAY IS ON THE ; LAST LINE, INCREASE THE NUMBER OF RK05 DISKS ; DISPLAYED TO 6.(CAN'T BE THIS HIGH FOR BIGGER ; DISKS.) ; ; JGD02 -- IF AN UNSOLICITIDED INPUT CHARACTER IS INPUT ; CHECK TO SEE WHICH ONE. IF IT IS AN 'X', THEN ; EXIT. IF ITS IS AN 'R', RESCHEDULE OURSELVES ; TO RUN IN 1 SECOND AND EXIT. THE METHOD USED ; WILL FAIL IF RMDEMO IS RUNNING AS AN MCR ; EXTERNAL FUNCTION (IE XYZTTN). ; ; JGD03 -- ADD SUPPORT FOR VT100'S OPERATING IN ANSI MODE. ; IF VT100 IS DEFINED, ISSUE AN INITIAL COMMAND ; TO SET TERMINAL TO VT52 MODE. ON EXIT RESET ; TERMINAL TO ANSI MODE. WHEN A ^R IS RECEIVED ; USE THE SPAWN COMMAND RATHER THAN RQST WHICH ; WILL START RMDEMO RUNNING ON CO: IF ITS LUN ; ASSIGNMENTS ARE POINTING TO TI: RATHER THAN ; A SPECIFIC TERMINAL. ; ; JGD04 -- KILL PENDING I/O BEFORE EXITING ; ; JGD05 -- AS OF BL27 RSX11M MOVED THE EVENT FLAG MASK FROM ; THE TASK HEADER INTO THE TCB. THIS WAS DONE TO ; SOLVE PROBLEMS WITH DELETING GROUP GLOBAL EVENT ; FLAG GROUPS WHILE TASKS HAD WAITS OUTSTANDING ON ; A GGEF. ANYWAY, THE CODE WITH THE AUDIT TRAIL ; JGD04 WILL ONLY WORK ON RSX11M BL27 OR LATER SYSTEMS ; AND WILL NOT WORK ON RSX11M-PLUS SYSTEMS UNLESS ; A SIMILAR CHANGE IS MADE IN MPLUS(IT PROBABLY WILL). ; ; JGD06 -- MOVE UP 'PARS' DISPLAY TO ACCOMIDATE MAX # OF PARTITIONS ; ; JGD07 -- DISABLE CHECKPOINTING DURING OUTPUT AND CHANGE QIO'S TO ; QIOW'S TO REDUCE THRASHING IN BL28. ; ; JGD08 -- MODIFIED TO ALSO RUN USING A M7142 SERIAL VIDEO MODULE ; OUTPUT BOARD ; ; JGD09 -- IF RUNNING ON A VT100 IN VT52 MODE, USE SREA$ TO CATCH ; AN ABORT TO RETURN THE VT100 TO ANSI MODE. ; ; JGD10 -- Use STSE rather than WTSE$ after marktime sor RMD100 is ; checkpointable. ; ; JGD11 -- Optionally display %system utilization if KMS accounting ; is active. ; ; RSX-11M DEMO PROGRAM TO SHOW TASK SWAPPING AND LOADING ; ON A VT05 OR VT52. THE DISPLAY HAS THE GENERAL FORM OF: ; .PAGE ; ; STYPE VERS BL SSIZE UP N.M HRS DATE TIME ; TSKNAM POOL=LRG:TOT:FRGS MIN POOL=MINLRG:MINTOT:MAXFRGS ; JGD ; P T PARS ;IN: A S PARNM1:T ;N R K PARNM2:C ;MMMK N N PARNM3:T ;OUT: M M PARNM4:D ;N 2 1 ;MMMK (=) <-----------> ; 0*******8*******16******24******32******40*****... ; E------PC--T---D-------------------------------... ; ----------------------:------------------------... ; 64******72******80******88******96*******104***... ; [===========] : ; T : ; S : ; K : ; N : ; M : ERRSEQ ; 2 : 1. ;FREE=SY0:BLKS,DEV1:BLKS.....DEV5:BLKS ; JGD ; ; WHERE ; STYPE = THE SYSTEM TYPE (RSX-11M OR RSX-11S) ; VER = THE SYSTEM VERSION NUMBER (THIS TASK MUST BE RUN ; ON AT LEAST A RSX11M V02 OR RSX11S V01 SYSTEM BECAUSE ; $LOCKL AND $CDDMG). ; BL = SYSTEM BASE LEVEL ; SSIZE = TOTAL MAIN MEMORY AVAILABLE TO SYSTEM ; UP FOR N.M HRS= THE NUMBER OF HOURS THAT RMDEMO HAS BEEN RUNNING ; IN HOURS AND TENTHS. ; DATE = THE CURRENT DATE ; TIME = THE CURRENT TIME OF THE CURRENT DATE ; TSKNAM = NAME OF NEXT RUNNABLE TASK (OR *IDLE* ) ; IN:N=NUMBER OF ACTIVE TASKS IN MEMORY. ; IN:MMMK=AMOUNT OF MEMORY USED BY IN:N TASKS (IN "K"). ; OUT:N=NUMBER OF ACTIVE TASKS NOT IN MEMORY (CHECKPOINTED). ; OUT:MMMK=AMOUNT OF MEMORY USED BY OUT:N TASKS (IN "K"). ; POOL=LRG = THE SIZE (DECIMAL NUMBER OF WORDS) OF THE ; LARGEST FRAGMENT OF SYSTEM DYNAMIC MEMORY ; (POOL). IT IS ASSUMED THAT THE TOTAL NUMBER OF ; DIGITS ACCOUNTED FOR BY LRG, TOT, AND FRGS WILL ; NOT BE MORE THAN 13. ; TOT = THE DECIMAL NUMBER OF TOTAL AVAILABLE WORDS OF ; SYSTEM DYNAMIC MEMORY ; FRAGS = THE DECIMAL NUMBER OF FRAGMENTS IN SYSTEM ; DYNAMIC MEMORY ; MIN POOL = IN ORDER TO MEASURE PEAK LOAD ; JGD ; AND TO ANTICIPATE WHETHER OR NOT THE ; JGD ; IS EVER COMMING CLOSE TO RUNNING OUT OF ; JGD ; MEMORY(THE FABLED 'YELLOW WARNING'!) RMD52 ; JGD ; DISPLAY THE LOWEST VALUE OF CONTIGUOUS POOL ; JGD ; AND TOTAL POOL SPACE REACHED WHILE IT IS ; JGD ; ALSO IT WILL DISPLAY THE MAXIMUM NUMBER ; JGD ; FRAGMENTS POOL IS EVER BROKEN ; JGD ; MINLRG = THE LOWEST VALUE REACHED FOR ; JGD ; DYNAMIC ; JGD ; MINTOT = THE LOWEST TOTAL POOL ; JGD ; MAXFRGS = THE MAXIMUM NUMBER OF ; JGD ; SY0:BLKS = IF THE SYSTEM IS RSX-11M, BLKS IS EITHER ; DMO (INDICATING DISMOUNTED) OR THE DECIMAL ; NUMBER OF FREE BLOCKS AVAILABLE ON SY: ; BLKS CAN BE UP TO 6 DIGITS, THEREFORE THE ; ENTIRE FREE BLOCKS DISPLAY (SEE BELOW FOR THE ; FORMAT OF THE REST OF THE DISPLAY) CAN ; POTENTIALLY OCCUPY ALL OF THE SECOND LINE OF THE ; DISPLAY IF THREE DEVICES ARE MOUNTED. IF THAT ; IS KNOWN NOT TO BE THE CASE, MORE FILES-11 ; DEVICES CAN BE DISPLAYED BY CHANGING RMDEMO ; (SEE THE SYMBOL MAXF11). ; DEV:BLKS,DEV:BLKS = IF THE SYSTEM IS RSX-11M, THE ; DECIMAL NUMBER OF FREE BLOCKS OF UP TO TWO ; MOUNTED FILES-11 DEVICES ; PARNM1:C = THE PARTITION NAME AND TYPE ("D" IS SYS ; PAR (DYNAMIC), "C" IS COMMON, "T" IS MAIN ; (TASK), AND "S" IS SUB) OF EVERY PARTITION ; IN THE SYSTEM WHEN RMDEMO WAS INITIALLY RUN ; PARNM2 = THE NAME OF THE COMMON PARTITION OCCUPYING ; MAIN MEMORY LOCATIONS 8.K THROUGH 10.K. ; SOMETHING IS LOADED IN IT OR ELSE PARNM2 ; WOULD ONLY BE DISPLAYED UNDER PARS. ; (=) = THE PARENTHESES INDICATE THE SIZE OF THE ; COMMON PARTITION PARNM2, AND THE ; "=" INDICATES THAT THOSE LOCATIONS MUST BE ; EXPLICITLY DEALLOCATED. ; TSKNM1 = THE NAME OF THE TASK CURRENTLY OCCUPYING ; MAIN MEMORY LOCATIONS 15.K THROUGH 27.K ; <---> = INDICATES WHAT MAIN MEMORY LOCATIONS THE ; TASK TASNM1 OCCUPIES (15.K THROUGH 27.K). ; THE ANGLED BRACKETS INDICATE THAT TASNM1 IS ; ACTIVELY COMPETING FOR SYSTEM RESOURCES. ; THE ---'S INDICATE THAT TSKNM1 ; DOES NOT EXPLICITLY HAVE TO BE REMOVED IN ; ORDER TO RELEASE ITS MAIN MEMORY TO THE SYSTEM, ; AS WOULD A FIXED TASK ; E------P = AN INDICATION OF THE MAIN MEMORY THE ; EXECUTIVE INSTRUCTIONS OCCUPY. IN THIS CASE, ; TO THE START OF THE SYSTEM DYNAMIC ; MEMORY POOL. ; C--T---D- = THE PARTITION TYPE LETTER (SEE ; PARNAME:C) MARKS THE LOCATION IN MAIN ; MEMORY WHERE A PARTITION STARTS. IN THIS CASE ; (PRESUMING THAT PARNAME IS THE LOADER, WHICH IS ; NOT SHOWN ON MAPPED SYSTEMS) PARNM2 IS 3K LONG, PARNM3 ; IS 4K LONG, AND PARNM4 OCCUPIES THE REST OF THE ; MACHINE. THE USEFULNESS OF THIS DISPLAY DEPENDS ; TO A LARGE DEGREE UPON PARTITIONS BEING ; CONTIGUOUS. ; TSKNM2 = THE NAME OF THE TASK OCCUPYING LOCATIONS 65.K ; THROUGH 76.K ; [===] = THE SQUARE BRACKETS INDICATE THAT TSKNM2 ; OCCUPIES MEMORY LOCATIONS 65.K THROUGH 77.K BUT ; IS NOT ACTIVELY COMPETING FOR SYSTEM RESOURCES. ; THE ==='S INDICATE THAT TSKNM2 IS FIXED IN ; MEMORY. ; :::: = THE END OF THE AVAILABLE MAIN MEMORY. THIS ; VISUAL REPRESENTATION OF $SYSIZ IS MARKED AS A ; CEILING (ONE QUANTUM HIGHER THAN THE MACHINE SIZE). ; IF THE MACHINE SIZE IS AN EXACT MULTIPLE OF THE ; SCREEN SIZE, THEN THIS DOESN'T APPEAR. ; ; ; THE PROGRAM AUTOMATICALLY SCALES THE DISPLAY TO ; FIT THE NEXT HIGHER POWER OF TWO FROM THE $SYSIZ. ; NOW THE RESOLUTION IS 1K WORDS ONLY FOR SYSTEMS ; GREATER THAN 64K AND LESS THAN 128K. ; IN THE REST OF THIS DOCUMENT, THE MEMORY SIZE ; FOR EACH CHARACTER POSITION HORIZONTALLY ON THE ; SCREEN IS CALLED A QUANTUM. ; ; NOTE: RESOLUTION OF THE DISPLAY IS ONE QUANTUM WORDS ; AND THEREFORE ANY TASKS AND PARTITIONS ; THAT ARE ONE QUANTUM WORDS OR LESS IN LENGTH ; MAY NOT BE DISPLAYED PROPERLY. THIS ; IS A BASIC PROBLEM WITH THE STRUCTURE ; OF THE PROGRAM, AND SHOULD BE CONSID- ; ERED A FEATURE INSTEAD OF A BUG. FOR ; COMMENTS ABOUT THE ROUNDING USED TO ; DISPLAY TASKS AND PARTITION BOUNDARIES, ; SEE THE COMMENT AFTER 45$. ; ERRSEQ = THE SEQUENCE NUMBER OF THE LAST RECORD WRITTEN TO THE ERROR ; LOG FILE. THIS IS GENERALLY CLOSE TO THE TOTAL NUMBER OF ; DEVICE AND TIMEOUT ERRORS AND NONSENSE INTERRUPTS LOGGED ; FOR THE SYSTEM. ; ; ; THE VT05 HAS 1440 CHARACTER POSITIONS NUMBERED FROM ; (31.+1,31.+1) IN THE UPPER LEFT HAND CORNER OF THE ; SCREEN TO (31.+72.,31.+20.) IN THE LOWER RIGHT ; HAND CORNER OF THE SCREEN. A CHARACTER IS DISPLAYED ; BY SENDING A STRING OF THE FORM: ; A CURSOR DISPLAY CHARACTER (16 OCTAL) ; Y COORDINATE OFFSET BY 31. ; NULL FILL ; X COORDINATE OFFSET BY 31. ; THE CHARS TO BE DISPLAYED HORIZONTALLY STARTING ; AT THE DESIGNATED CHARACTER POSTION ; THE AMOUNT OF REQUIRED FILL DEPENDS UPON THE SPEED ; OF THE RECEIVING TERMINAL, WITH 4 BEING THE MAXIMUM ; NEEDED (2400 BAUD TERMINAL). FILL IS ALSO NEEDED ; AFTER LINE FEEDS, CURSOR DOWN, HOME (GOTO UPPER ; LEFT HAND CORNER OF SCREEN), CURSOR UP, AND ERASE ; SCREEN. ; ; A FEW WORDS ABOUT THE PROGRAM ORGANIZATION. ; 1) DSBUF (FROM DSBUF THROUGH CURIMG) IS THE BUFFER ; THAT IS WRITTEN BY A QIO TO THE VT05B TO PRODUCE ; THE DISPLAY. AS SUCH IT CONTAINS CURSOR CONTROL ; CHARACTERS AND ALPHANUMERICS FOR DISPLAY AS ; DESCRIBED ABOVE. WHEN RMDEMO IS STARTED, IT ; IS FULL OF CHARACTERS REPRESENTING PART OF THE ; CONSTANT (NEVER CHANGED) PORTION OF THE ; DISPLAY. ONCE THAT INFORMATION IS WRITTEN OUT ; (SEE "CALL OUTBUF" AFTER RMDEMO:), IT IS ; LOST FOREVER. ; 2) CURIMG (LOCATIONS CURIMG THROUGH DISIMG) IS ; THE BUFFER OF THE CURRENTLY SHOWN TASK ; DISPLAY (THE TASK NAMES AND MEMORY LOCATIONS ; OF THE CURRENTLY ACTIVE TASKS). IT IS ; UPDATED BY THE CODE AFTER DSPLY IF ; DISIMG DIFFERS FROM IT (I.E., IF DSPLY HAS ; DETERMINED THAT PART OF THE TASK DISPLAY ; NEEDS UPDATING). HOWEVER, INITIALLY CURIMG ; CONTAINS ONCE ONLY CODE TO COMPLETE THE ; INITIALIZATION OF THE CONSTANT AREAS OF THE ; DISPLAY THAT WOULD NOT FIT INITIALLY IN DSBUF. ; 3) DISIMG (SEE CURIMG FOR GENERAL RUNTIME ; EXPLANATION) INITIALLY CONTAINS ONCE ONLY ; CODE TO INITIALIZE CURIMG TO ITS GENERAL ; RUNTIME CONDITION. ; 4) THE GENERAL PROGRAM FLOW STARTS AT DSCTL1. ; THERE A ONE SECOND MARK TIME REQUEST IS ; MADE OF THE SYSTEM AND THE TIME DISPLAY ; IS UPDATED. THE POOL INFORMATION IS THEN ; GATHERED, AND IF IT HAS CHANGED FROM ; THE LAST DISPLAY, THE POOL DISPLAY IS UPDATED. ; THEN THE ACTIVE TASK INFORMATION IS GATHERED ; AND DISIMG IS MODIFIED TO REFLECT THE MOST ; RECENT INFORMATION. IF THAT IS NOT THE SAME, ; THE DIFFERING INFORMATION IS MOVED TO DSBUF ; AND DISPLAYED WHEN THE DISPLAY IS UPDATED ; AT 40$ AFTER DSPLY. IF THE NONCURSOR ; ADDRESSABLE OPTIONS ARE IN EFFECT (SEE ALL ; COMMENTS ABOUT B$$SCR AND P$$RNT, ESPECIALLY ; AFTER UPDATB), THE LINEAR DISPLAY BUFFER IS ; UPDATED EVERY TIME THE DSBUF IS WRITTEN ; TO THE SCREEN. THE MARK TIME FLAG IS ; THEN WAITED FOR AND THE PROCESS REPEATS ; ITSELF. ; ; ;============================================================ ; ; TO BUILD YOUR FAVORITE FLAVOR OF RMDEMO ; USE RMDEMO.CMD AND ANSWER THE APPROPRIATE ; QUESTIONS. ; ; ;============================================================= ; ; ; ; ; A NOTE ABOUT PROGRAM CONFIGURATION. ; ; THIS PROGRAM HAS THREE BASIC VERSIONS AVAILABLE FROM ; CONSTANTS. THEY ARE: ; ; NEITHER B$$SCR NOR P$$RNT DEFINED. ; ; THIS IS THE TRADITIONAL PROGRAM WHICH WHEN RUN ; ON A VT05 WILL CYCLE A DISPLAY OF SYSTEM ; ACTIVITY. IF IT IS RUN FROM SOME TERMINAL ; OTHER THAN A VT05, THEN IT WILL SIMPLY EXIT ; WITH NO ACTIVITY. ; ; ; B$$SCR DEFINED, P$$RNT NOT DEFINED. ; ; THIS PROGRAM WILL DISPLAY SYSTEM ACTIVITY IN THE ; USUAL MANNER WHEN RUN FROM A VT05, AND CYCLE ; THIS DISPLAY INDEFINITELY. HOWEVER, WHEN RUN ; FROM A TERMINAL THAT IS NOT A VT05 BUT IS RECORD ; ORIENTED, IT WILL DISPLAY ONE 20 LINE SCREENFUL ; AND EXIT. ; ; ; BOTH B$$SCR DEFINED AND P$$RNT DEFINED. ; ; THIS PROGRAM WILL ONLY DISPLAY ONE SCREEN FULL ; WHEN RUN FROM EITHER A VT05 OR SOME OTHER ; TYPE OF TERMINAL. IN ADDITION IT WILL PRINT ; A COPY OF THAT DISPLAY ON THE FILE LS:RMDLOG.LST. ; ; ; ; ASSEMBLY CONSTANTS: ; ; B$$SCR=0 ;FOR BUFFER SCREEN ; P$$RNT=0 ;FOR PRINT OPTION (REQUIRES B$$SCR) ; D$$POO=0 ;DISPLAY POOL INFORMATION ; D$$F11=0 ;DISPLAY DISK STATUS FOR RSX-11M ; ;SYSTEMS. 11S HAS NO FILE SYSTEM. ; VT52=0 ;PROGRAM WILL RUN ON VT52 ONLY. ; ; VT100 OR THE M7142 VIDEO MODULE ; ;IF NOT DEFINED, DISPLAY DEVICE IS ; ;A VT05. ; UPTIME=0 ;DISPLAY TOTAL UPTIME IN HOURS AND TENTHS ; UTLIZ=0 ; Display System % Utilization ; JGD11 ; INOUT=0 ;MEMORY USAGE DISPLAYED FOR TASKS ; ;OUT OF MEMORY ; ERRSEQ=0 ;DISPLAY THE SYSTEM ERROR SEQUENCE ; ;NUMBER ; L$$DRV=0 ;FOR LOADABLE DRIVER SUPPORT ; ;NOT UNDER USER CONTROL - FOUND IN ; ;RSXMC.MAC FROM SYSGEN. ; R$$11S=0 ;RSX-11S SYSTEM (DITTO ABOVE) ; M$$MGE=0 ;SYSTEM HAS MEMORY MANAGEMENT (DITTO) ; E$$DVC=0 ;LOG DEVICE ERRORS AND TIMEOUTS ; ;(DITTO) ; E$$NSI=0 ;LOG UNDEFINED INTERRUPTS (DITTO) ; ;- .PAGE .SBTTL ASSEMBLY CONSTANTS AND SYMBOL DEFINITIONS D$$POO=0 ;DISPLAY POOL STATISTICS ;UPTIME=0 ;DISPLAY UPTIME D$$F11=0 ;DSIPLAY FILE SYSTEM ERRSEQ=0 ;DISPLAY ERROR SEQUENCE NUMBER INOUT=0 ;SHOW MEMORY USAGE .IF DF P$$RNT .IF NDF B$$SCR ;B$$SCR=0 ;P$$RNT NEEDS ; JGD .ENDC .ENDC .IF DF INOUT&R$$11S .ERROR ;CANNOT USE INOUT WITH RSX-11S SYSTEM .ENDC .IF DF R$$11S&D$$F11 .ERROR ;RSX-11S HAS NO FILE SYSTEM .ENDC .IF DF VT52&B$$SCR .ERROR ;CANNOT USE B$$SCR WITH A VT52 .ENDC ; ; MACRO LIBRARY CALLS ; .MCALL PCBDF$ PCBDF$ ;DEFINE PARTITION CONTROL BLOCK OFFSETS .IF DF D$$F11 .MCALL F11DF$ F11DF$ ;DEFINE FILES-11 OFFSETS .ENDC .IF DF P$$RNT .MCALL FDBDF$,FDAT$A,FDOP$A,FSRSZ$ .MCALL OPEN$W,PUT$S,CLOSE$ .MCALL NMBLK$,FINIT$,FDBF$A .ENDC .MCALL GTSK$S,EXIT$S,GLUN$S,QIO$S .MCALL DIR$,GTIM$S,QIO$,MRKT$,WTSE$ .MCALL RUN$,EXIT$S,ASTX$S,GTSK$ .MCALL ENCP$S,DSCP$S,QIOW$ ;JGD07 .MCALL SREA$ ;JGD09 .MCALL STSE$ ;JGD10 .MCALL MRKT$S ; ; EQUATED SYMBOLS ; COMFLG=1 ;PARTITION IS A COMMON (1=YES) DRVFLG=2 ;PARTITION CONTAINS A DRIVER (1=YES) EXEFLG=4 ;PARTITION CONTAINS ACTIVE TASK (1=NO) FXDFLG=10 ;PARTITION CONTENTS ARE FIXED (1=YES) .IF DF VT52 ESC=33 ; ESCAPE ; JGD08 CD=131 ; A 'Y' ; JGD08 ES=112 ; A 'J' ; JGD08 HO=110 ; A 'H' ; JGD08 .IFF ESC=1 ;WHEN VT52 NOT DEFINED CD=16 ;CURSOR DISPLAY ES=37 ;ERASE TO END OF SCREEN HO=35 ;HOME CURSOR CUP=16 ;CURSOR UP CODE CDN=13 ;CURSOR DOWN CODE CLT=10 ;CURSOR LEFT CODE CRT=30 ;CURSOR RIGHT CODE .ENDC .IFDF V$IDEO ; JGD08 ES=14 ; A FORM FEED ; JGD08 .ENDC ; JGD08 ; JGD08 CR=15 ;CARRIAGE RETURN LF=12 ;LINE FEED EL=36 ;ERASE TO END OF LINE BL=40 ;BLANK ;+ ; CONFIGURATION DEPENDENT ASSEMBLY CONSTANTS ; ; MAXF11 IS THE MAXIMUM NUMBER OF FILES-11 TYPE ; DEVICES THAT WILL HAVE THEIR FREE BLOCK ; COUNT DISPLAYED. BECAUSE EACH DEVICE ; POTENTIALLY REQUIRES 12 CHARACTERS ; (THE FORM IS "DDU:NNNNNN.,"), THE MAXIMUM ; RECOMMENDED VALUE IS 3. ; ; MINTSK IS THE MINIMUM NUMBER OF TASKS THAT MAY BE ; DISPLAYED AT ANY ONE TIME ON THE TASK ; DISPLAY. THIS SYMBOL REQUIRES BUFFER SPACE ; AT A COST OF 5 WORDS PER EACH DISPLAYABLE ; TASK. THE BUFFER IS ALLOCATED BY USING ; ALL OF MEMORY BETWEEN THE END OF THE TASK ; CODE AND THE END OF THE PARTITION (ADDRESS ; SPACE). THERE IS NO INTRINSIC UPPER LIMIT ; TO THE MAXIMUM NUMBER OF TASKS DISPLAYABLE ; EXCEPT THE PRACTICAL LIMIT OF THE MAXIMUM ; THAT MAY RUN ON THE MACHINE AT ONCE. ; ; WIDTH IS THE NUMBER OF CHARACTER POSITIONS ON ; EACH LINE OF THE SCREEN. IT IS USED ONLY BY ; THE B$$SCR BUFFERING ROUTINES AND THE P$$RNT ; PRINTING ROUTINES. ; ; HIGHT IS THE NUMBER OF LINES ON THE SCREEN, LIKEWISE ; USED ONLY BY B$$SCR CODE AND P$$RNT CODE. ; ; PNTLUN IS THE LUN USED BY THE P$$RNT CODE FOR THE ; FILE OUTPUT. ; ; PNTFLG IS THE EVENT FLG USED BY THE P$$RNT FOR ; FILE I/O CALLS. ; ; VT5LUN IS THE LUN USED FOR THE DISPLAY DEVICE ; ; VT5EFG IS THE EVENT FLAG USED FOR I/O ON VT5LUN ; ; XINO, YINO : IT IS POSSIBLE TO LOCATE THE IN:/OUT: ; MESSAGE BLOCK IN ANY POSITION ON THE "TASK- ; DISPLAY" PORTION OF THE SCREEN. THE DEFAULT ; POSITION IS ABOVE THE EXEC BECAUSE, ON MOST ; SYSTEMS, THE COMBINATION OF EXEC SIZE AND ; MEMORY SIZE (THEREBY SCREEN QUANTUM SIZE) LEAVES ; ENOUGH ROOM THERE. FOR SYSTEMS THAT HAVE VERY ; LARGE AMOUNTS OF MEMORY, THIS MAY NOT BE THE ; CASE. FOR THOSE SYSTEMS THAT DO NOT HAVE EXACTLY ; AN EVEN (POWER OF 2)K WORDS OF MEMORY, IT IS ; ENTIRELY REASONABLE TO PLACE THIS BLOCK OF ; DATA IN THE LOWER RIGHT PORTION OF THE DISPLAY. ; ; A YINO=15. WILL PUT THE BOX IN THE LOWER PORTION ; OF THE TASK DISPLAY, AND ON A 128K SYSTEM, AN ; XINO=49. PUTS IT DIRECTLY UNDER THE FIRST "1" IN ; "112". IN A SYSTEM WITH LESS THAN NINE PARTITIONS, ; ONE WOULD THINK THAT IT COULD GO UNDER THE PARTITIONS. ; ; T H I S I S N O T T H E C A S E ! ; ; CAREFUL EXAMINATION OF THE PROGRAM WILL REVEAL THAT ; THE "TASK-DISPLAY" PORTION OF THE SCREEN COMPRISES ; ONLY THE 7*64. SECTION OF THE UPPER TASK DISPLAY AND ; THE 7*64. SECTION OF THE LOWER TASK DISPLAY. IN ; PARTICULAR, IT DOES NOT EXTEND INTO THE PARTION ; LISTING AREA. FURTHERMORE, THE LINES WITH THE ; MEMORY NUMBERS AND PARTITION TICK MARKS LIKEWISE ; ARE NOT PART OF THE CONSTANT REFRESH PART OF THE ; DISPLAY. ; >>>>>>>>>>>>>>>>> NOTE <<<<<<<<<<<<<<<<<<<<<< ; ; IT IS RATHER EASY TO NOT ONLY DESTROY RMDEMO ; BUT TO CRASH THE SYSTEM BY INCORRECT SETTINGS ; OF THESE SYMBOLS. SOME CURSORY CHECKS ARE ; MADE TO TRY TO MINIMIZE THIS PROBLEM, BUT THE ; SAFEST WAY TO HANDLE IT IS TO GET AN ASSEMBLY ; LISTING AND SEE IF THE SYMBOLS INNL, INML, OUTNL ; AND OUTML ARE ALL WITHIN DISIMG. ; ; LET THE USER BEWARE! ; ; >>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<< ; THE SYMBOLS XINO AND YINO SPECIFY THE "X" AND ; "Y" COORDINATES OF THE UPPER LEFT HAND PORTION ; OF THE MESSAGE BLOCK (I.E. THE LOCATION OF THE ; "I" IN THE "IN:") ; ; ;- MAXF11=4 ;MAX FILES-11 ; JGD ; FOR RK05 SYSTEMS 6 IS MAX # THAT CAN ; JGD ; BE DISPLAYED. SET TO 4 FOR BIG DISKS.; JGD MINTSK=20. ;MINIMUM NUMBER OF TASKS WIDTH=72. ;WIDTH OF SCREEN HIGHT=20. ;HEIGHT OF SCREEN VT5LUN=1 ;LUN FOR VT05 DEVICE VT5EFG=1 ;EVENT FLG FOR VT05 I/O TILUN=2 ;LUN FOR INITIAL ERROR MESSAGE WAITT=1 ;SECONDS BETWEEN EACH REFRESH XINO=1. ;X COORD OF IN:/OUT: BLOCK DEFAULT=1. YINO=4. ;Y COORD OF IN:/OUT: BLOCK DEFAULT=4. .IF DF P$$RNT PNTLUN=3 ;LUN FOR PRINTED OUTPUT PNTFLG=3 ;EVENT FLAG FOR PRINTED OUTPUT .ENDC RUN: RUN$ ...RMD,,,,,1,2 ; RUN OURSELVES 1 SECOND AFTER ; JGD02 GETTSK: GTSK$ GTSKBF ; TO GET OUT ; JGD02 GTSKBF: .BLKW 16. ; GET TASK ; JGD02 .PAGE .SBTTL ONCE ONLY CODE IN RUNTIME BUFFERS ; ; LOCAL DATA ; ; DISPLAY OUTPUT MESSAGES ; .NLIST BEX DSBUF=. ;DISPLAY BUFFER .IFDF VT100 ; IF A VT100 ; JGD03 .ASCII <33>/[?2/<154> ; ESC [?2l SET TO VT52; JGD03 .ENDC ; END VT100 ; JGD03 ; JGD08 .IFNDF V$IDEO ; JGD08 .BYTE ESC,HO,0,0,0,0 .BYTE ESC,ES,0,0,0,0 ; .IFF ; IF VIDEO BOARD ; JGD08 ; .BYTE ES,0,0,0,0,0 ; FF FEED TO RESET; JGD08 .ENDC ; JGD08 .IFNDF V$IDEO ; JGD08 .BYTE ESC,CD,31.+11.,0,0,0,0,31.+1 ; .IFF ; JGD08 ; .REPT 20. ; SOME DELAY ; JGD08 ; .BYTE 0 ; FOR VIDEO BOARD; JGD08 ; .ENDR ; JGD08 .BYTE ESC,CD,31.+11.,31.+1,0,0,0,0 ; ; JGD08 .ENDC ; JGD08 ; JGD08 .REPT 64. .ASCII /-/ ; .ENDR .BYTE 0 ; .IFNDF V$IDEO ; JGD08 .BYTE ESC,CD,31.+12.,0,0,0,0,31.+1 ; .IFF ; JGD08 .BYTE ESC,CD,31.+12.,31.+1,0,0,0,0 ; JGD08 .ENDC ; JGD08 .REPT 64. ; JGD08 .ASCII /-/ ; ; JGD08 .ENDR ; JGD08 ; JGD08 .BYTE 0 .IF DF D$$POO .IF NDF V$IDEO ; JGD0D8 .BYTE ESC,CD,31.+2,0,0,0,0,31.+9. ; .ASCII /POOL=/ ; JGD MINPOL: .ASCIZ <31.+2.><0><31.+34.>/MIN POOL=/; JGD .IFF ; JGD08 .BYTE ESC,CD,31.+2,31.+9.,0,0,0,0 ; JGD08 .ASCII /POOL=/ ; JGD08 MINPOL: .ASCIZ <31.+2.><31.+34.><0>/MIN POOL=/ ; JGD08 .ENDC ; JGD08 .ENDC ; ; STORAGE FOR MEMORY NUMBER LINES -- ADJACENCY ASSUMED ; UNTIL AFTER MLIN2: ; .IF NDF V$IDEO ; JGD08 MDLIN2: .ASCIZ <31.+13.><0><31.+1> MDLIN1: .ASCII <31.+10.><0><31.+1.> .IFF ; JGD08 MDLIN2: .ASCIZ <31.+13.><31.+1><0> ; JGD08 MDLIN1: .ASCII <31.+10.><31.+1.><0> ; JGD08 .ENDC ; JGD08 MLIN1: ;REFERENCE LABEL .REPT 8. .ASCII /********/ .ENDR MLIN2: ;REFERENCE LABEL .REPT 8. .ASCII /********/ .ENDR .BYTE 0 .EVEN MEMINC: .WORD 0 ;AMOUNT OF MEMORY BETWEEN NUMBERS MEMPOS: .WORD MLIN1 ;FIRST NUMBER GOES HERE NUMD: .WORD 16. ;SIXTEEN NUMBERS MEMNUM: .WORD 0 ;STARTING WITH ZERO ; ; MACRO TO CONVERT MEMORY 32. WORD UNITS IN ARG INTO ; SCREEN SPACES IN THE X DIMENSION ; .MACRO CNVR ARG,?A ADD SYSRND,ARG MOV SYSHFT,SYSTMP A: CLC ; EB170 ROR ARG ; EB170 DEC SYSTMP BNE A .ENDM .IFNDF V$IDEO ; JGD08 HDRMG1: .ASCII <31.+1><0><31.+1> ; .IFF ; JGD08 HDRMG1: .ASCII <31.+1><31.+1><0> ; ; JGD08 .ENDC ; JGD08 .IF DF R$$11S .ASCII /RSX-11S V2.2 BL/ ; ; EB162 .IFF .ASCII /RSX-11M V4.0 BL/ ; ; EB162 .ENDC SYSID: .ASCIZ /XXXX / ; 1 MORE SPACE TO INCREMENT BL ; JGD PARMG1: ; .IF DF VT52 .IFNDF V$IDEO ; JGD08 .ASCII <31.+1.><0><31.+70.>// ; JGD MORE ROOM .IFF ; JGD08 .ASCII <31.+1.><31.+70.><0>// ; JGD MORE ROOM ; JGD08 .ENDC ; JGD08 .IFF .ASCII <31.+3.><0><31.+67.>// ; .ENDC .ASCIZ /PARS/ ; PARMG2: .ASCIZ /XXXXXX:T/ ; .IFNDF V$IDEO ; JGD08 PARMRK: .ASCIZ <0><0><0>/P/ ; EXEC: .ASCIZ <31.+11.><0><31.+1.>/E/ ; .IFF ; JGD08 PARMRK: .ASCIZ <0><0><0>/P/ ; ; JGD08 EXEC: .ASCIZ <31.+11.><31.+1.><0>/E/ ; ; JGD08 .ENDC ; JGD08 ; JGD08 .IF DF D$$F11 .IFNDF V$IDEO ; JGD08 FREE: .ASCIZ <31.+21.><0><31.+1.>/FREE=SY0:/ .IFF ; JGD08 FREE: .ASCIZ <31.+21.><31.+1.><0>/FREE=SY0:/ ; JGD08 .ENDC ; JGD08 .ENDC .IF DF INOUT .IFNDF V$IDEO ; JGD08 INMSG: .ASCIZ <31.+YINO><0><31.+XINO>/IN:/ OUTMSG: .ASCIZ <31.+3.+YINO><0><31.+XINO>/OUT:/ .IFF ; JGD08 INMSG: .ASCIZ <31.+YINO><31.+XINO><0>/IN:/ ; JGD08 OUTMSG: .ASCIZ <31.+3.+YINO><31.+XINO><0>/OUT:/ ; JGD08 .ENDC ; JGD08 ; JGD08 .ENDC .IF DF ERRSEQ .IF DF E$$DVC!E$$NSI ERRMSG: ;REF LABEL .IF DF VT52 .IFNDF V$IDEO ; JGD08 .ASCIZ <31.+19.><0><31.+69.>/ERRSEQ/ ; .IFF ; JGD08 .ASCIZ <31.+19.><31.+69.><0>/ERRSEQ/ ; ; JGD08 .ENDC ; JGD08 .IFF .ASCIZ <31.+19.><0><31.+66.>/ERRSEQ/ ; .ENDC .ENDC .ENDC ; ; STARTUP ERROR MESSAGE ; MEMSG: .ASCII / - INSUFFICIENT TASK LIST BUFFER SPACE/ .ASCII / INSTALL TASK WITH A LARGER INCREMENT/ MEMLEN=.-MEMSG .EVEN ; ; ERROR MESSAGE DPB'S ; MSGIO: QIO$ IO.WVB,TILUN,2,,,, MSGWT: WTSE$ 2 ; ; MISCELLANEOUS INITIALIZATION BUFFERS ; ALIMIT: .LIMIT ;TKB DEFINED ADDRESS LIMITS TSKB: ; LUNB: .BLKW 16. ;BUFFER FOR GTSK$S/GLUN$S ; ; DEFINE IMAGE BUFFER ADDRESSES ; CURIMG=DSBUF+<64.*4>-1 ;CURRENT IMAGE DISPLAY DISIMG=CURIMG+<64.*14.> ;DISPLAY IMAGE (ASSUMED ;ADJANCENCY WITH CURIMG) .LIST BEX .ENABL LSB RMDEMO: GTSK$S #TSKB ;GET TASK PARAMETERS MOV #MEMSG,R0 ;POINT R0 TO ERROR MESSAGE MOV #TSKB+G.TSTN,R3 ;POINT R3 TO TASK NAME (RAD50) MOV (R3)+,R1 ;GET FIRST HALF OF TASK NAME CALL $C5TA ;CONVERT TO ASCII AND INTO MESSAGE MOV (R3),R1 ;GET SECOND HALF OF TASK NAME CALL $C5TA ;CONVERT IT TOO MOV #TSKLND,R0 ;GET ADDRESS OF END-OF-LIST PTR MOV TSKB+G.TSTS,(R0) ;GET TASK SIZE CALL $SWSTK,3$ ;SWITCH TO SYSTEM STATE MOV $TKTCB,R1 ;POINT AT RMDEMO TCB MOV T.UCB(R1),R2 ;POINT AT TI: UCB BIT #U2.PRV,U.CW2(R2) ;IS THE INITIATING TERMINAL PRIVILEGED? BNE 2$ ;IF NE YES BIC #T3.PRV,T.ST3(R1) ;MAKE RMDEMO LOOK UNPRIVILEGED 2$: MOV $HEADR,R1 ;GET ADDRESS OF TASK HEADER MOV H.WND(R1),R1 ;GET WINDOW POINTER ADD W.BLVR+2(R1),(R0) ;CALC ADDR OF END OF TASK SPACE RETURN ;RETURN TO TASK STATE 3$: SUB #2*<5+2>,(R0) ;ALLOCATE A BUFFER SAFETY ZONE AT END MOV (R0),R0 ;COPY END OF BUFFER ADDRESS MOV ALIMIT+2,R1 ;GET ADDRESS OF END OF TASK CODE CLR (R1)+ ;SET START OF BUFFER GUARD WORD MOV R1,TSKLST ;SET START OF TASK LIST ADDRESS SUB R1,R0 ;CALCULATE SIZE OF BUFFER BLT NOMEM ;IF SIZE NEGATIVE, CLEARLY TOO SMALL CMP #MINTSK*<5*2>,R0 ;IS IT BIG ENOUGH? BLO 5$ ;IF LO YES NOMEM: DIR$ #MSGIO ;SEND MESSAGE TO INITIATING TERMINAL BCS EXIT ;IF CS JUST EXIT DIR$ #MSGWT ;WAIT FOR MESSAGE TO COMPLETE EXIT: EXIT$S ; 5$: ;REF LABEL .IF DF D$$F11 MOV R1,F11TMP ;SET START OF FILES-11 DATA BUFFER ADDR ADD #MAXF11*<2*2>+2,R1 ;POINT R1 TO SECOND HALF OF BUFFER MOV R1,F11TDV ;SET START OF FILES-11 DEVICE NAME BUFFER CMP #MAXF11*<4*2>+2,R0 ;IS BUFFER BIG ENOUGH? BHI NOMEM ;IF HI NO .ENDC .IF DF UTLIZ ; IF REALTIME % UTLIZ DISPLAY ; JGD11 .IF DF S$$ACC ; IF KMS ACCOUNTING SELECTED ; JGD11 CLR $UTLIZ ; CLEAR THE CPU ACTIVE COUNTER ; JGD11 MOV $TKPS,R1 ; GET # TICS/SEC ; JGD11 MOV #WAITT,R0 ; GET # SEC BETWEEN REFRESHES ; JGD11 CALL $MUL ; MULTIPLY OUT ; JGD11 MOV R1,UTLC1 ; SAVE CONSTANT FOR LATER ; JGD11 .ENDC ; END S$$ACC .ENDC ; END UTLIZ ; JGD11 GLUN$S #VT5LUN,#LUNB ;FIND OUT IF IT IS VT05 BCS 30$ ;IF ERROR ASSUME VT05 BIT #FD.TTY,G.LUCW+LUNB ;IS IT TERMINAL BNE 10$ ;IF NE YES BIT #FD.REC,G.LUCW+LUNB ;RECORD ORIENTED? ; EB125 BNE 20$ ;IF NE YES .IF DF B$$SCR&P$$RNT MOV #-1,VT5FLG ;SET NOT RECORD ORIENTED DEVICE FLAG BR 30$ ;GO ON WITH REST .IFF BR EXIT ;EXIT IF NOT PRINTING .ENDC 10$: BIT #U2.VT5,G.LUCW+2+LUNB ;IS IT VT05 BNE 30$ ;IF NE YES 20$: ;REFERENCE LABEL .IF DF B$$SCR CLR VT5FLG ;SAY NO VT05 DEVICE MOV #IO.WVB,DSFUN ;SET UP QIO DPB MOV #' ,DSCCR ;SET BLANK CCONT .IFF .IF NDF VT52 EXIT$S ;IF NO B$$SCR AND NOT .ENDC ;VT05 THEN NOTHING TO ;DO.......... .ENDC 30$: ;REFERENCE LABEL .DSABL LSB .IF DF B$$SCR&P$$RNT FINIT$ OPEN$W #FDBPNT .ENDC ; ; GET MEMORY SIZE AND FIGURE OUT NEXT POWER OF TWO ; SIZE BIGGER. THEN SAVE SHIFT COUNT FOR REST OF ; PROGRAM AND PRINT OUT LINES WITH MEM NUMBERS ON THEM ; MOV $SYSIZ,R2 ;GET SIZE DEC R2 ;FIX IT UP TO BE LAST WORD ;IN MEMORY CLC ;DON'T SIGN EXTEND ROR R2 MOV #1,R3 ;INITIALIZE COUNT OF SHIFTS 50$: INC R3 ;ONE MORE SHIFT ASR R2 ;DO IT BNE 50$ ;MORE LEFT INC R2 ;PUT A ONE IN SO WE CAN SHIFT ;IT BACK UP MOV R3,SYSHFT ;SAVE IT SUB #5,R3 ;CONVERT TO 1K SECTIONS SUB #4,R3 ;EFFECTIVE DIVIDE BY 16. 60$: ASL R2 ;MOVE IT BACK UP DEC R3 ;ANY MORE BNE 60$ ;IF NE YES MOV R2,MEMINC ;SAVE IT SUB #7.,SYSHFT ;ADJUST SYSTEM SHIFT COUNT SO THAT ;IT WILL CONVERT 32. WORD UNITS INTO ;WHATEVER UNITS THAT WILL TAKE ;UP ONE SPACE ON SCREEN. MOV SYSHFT,R1 ;CALCULATE SYSTEM ROUND DEC R1 CLR R0 BR 71$ 70$: ASL R0 ;SHIFT IT UP AND OVER 71$: INC R0 ;PUT A ONE IN LOWER POSITION DEC R1 ;ANY MORE TO GO BNE 70$ ;IF NE YES MOV R0,SYSRND ;SAVE IT FOR LATER ; ; HERE WE ACTUALLY GENERATE THE NUMBERS INTO THE **** PROTOTYPES ; THE HARD WORK IS OVER ; 80$: MOV MEMPOS,R0 ;GET NEXT POSITION MOV MEMNUM,R1 ;NUMBER FOR CBDMG CLR R2 ;NO LEADING ZEROS CALL $CBDMG ;CONVERT IT ADD #8.,MEMPOS ;MOVE TO NEXT POSITION ADD MEMINC,MEMNUM ;NEW MEMORY NUMBER DEC NUMD ;THRU ? (ONLY 16. OF THESE) BNE 80$ ;IF NE YES ; ; DISPLAY THE ACTUAL LINES HERE ; 90$: .IFDF VT100 ; ; JGD09 DIR$ #ABORT ; CATCH ABORTS POLITELY ; JGD09 .ENDC ; .ENDC VT100 ; JGD09 QIO$S #IO.ATA!TF.XCC,#VT5LUN,#VT5EFG,,,,<#INPAST> ;ATTACH TI:; JGD02 BCS 91$ ;IF NOT ACCEPTED DIR$ #DSWT ;WAIT FOR COMPLETION 91$: .IFDF V$IDEO ; ; JGD08 DIR$ #ERSQIO ; ERASE SCREEN WITH A FORMFEED IF M7142; JGD08 MRKT$S #2,#10,#1 ; MARK TIME 10 TICS ; JGD08 DIR$ #MARKWT ; WAIT TILL DONE ; JGD08 .ENDC ; ; JGD08 CALL OUTBUF ;SEND PREPACKAGED BUFFER OUT MOV #MDLIN2,R3 ;POSITION CURSON CALL OUTLIN MOV #MLIN2,R3 ;REST OF BOTTOM LINE CALL OUTLN2 ; ; EB146 CLRB MLIN2 ;TERMINATE FIRST LINE MOV #MDLIN1,R3 ;SEND ALL OUT AT ONCE CALL OUTLIN MOV #$SYSID,R0 ;MOVE SYSTEM ID MOV #SYSID,R1 ;TO DISPLAY .REPT 4 MOVB (R0)+,(R1)+ ;PROTOTYPE .ENDR TSTB (R1)+ ; SKIP A SPACE ; JGD MOV R1,R0 ;COPY FOR $CBDMG MOV $SYSIZ,R1 ;SIZE OF CURRENT SYSTEM CLR R2 ;SUPPRESS LEADING ZEROS (C=0) ; EB138 ROR R1 ;CONVERT $SYSIZ TO 1K UNITS ; EB138 ASR R1 ; ; EB138 ASR R1 ; ; EB138 ASR R1 ; ; EB138 ASR R1 ; ; EB138 CALL $CBDMG ;SHOVE INTO PROTOTYPE MOV R0,R1 ;RESTORE POINTER MOVB #'K,(R1)+ ;ADD UNITS MOV #HDRMG1,R3 ;DISPLAY SYSTEM TYPE CALL OUTLIN ;AND SIZE MOV #EXEC,R3 ;LABEL PART OF CALL OUTLIN ;MEM LINE AS EXEC'S MOV $CRAVL,R1 ;START OF CORE POOL ADD #37,R1 ;ROUND TO 32. WORD CLC ;UNITS ROR R1 ;CHANGE TO 32. WORD .REPT 5 ASR R1 ;UNITS .ENDR CALL MEMARK ;MARK MEMORY LINE MOV #PARMG1,R3 ;DISPLAY PARTITION CALL OUTLIN ;HEADER .IF DF D$$F11 MOV #FREE,R3 ;DISPLAY FREE BLOCKS CALL OUTLIN ;HEADER .ENDC ; ; **-DSPAR-DISPLAY PARTITION CONFIGURATION ; MOVB #':,PARMRK+5 ;WRITE END OF MEMORY FENCE FIRST, MOV $SYSIZ,R1 ; SO PARTITION TICK MARKS CAN CALL MEMARK ; OVERWRITE IT IF NECESSARY DSPAR: MOV #31.+2.,R5 ;INITIAL 'Y' COORD(UP 2 HIGHER) ; JGD06 CALL $LOCKL ;LOCK ACCESS TO SYSTEM LISTS MOV $PARHD,R4 ;ADDR OF FIRST PCB 10$: MOV #PARMG2,R0 ;PAR NAME PROTOTYPE MOV P.NAM(R4),R1 ;1ST HALF OF PAR NAME CALL $C5TA ;CONVERT TO ASCII MOV P.NAM+2(R4),R1 ;SAME FOR THE CALL $C5TA ;2ND HALF INC R0 ;STEP OVER ':' MOV P.STAT(R4),R1 ;GET PARTITION STATUS WORD MOVB #'D,(R0) ;ASSUME SYSTEM CONTROLLED BIT #PS.SYS,R1 ;IS IT? BNE 20$ ;IF NE YES MOVB #'C,(R0) ;ASSUME COMMON PAR BIT #PS.COM,R1 ;COMMON PARTITION? BNE 20$ ;IF NE YES MOVB #'T,(R0) ;ASSUME MAIN PAR CMP R4,P.MAIN(R4) ;MAIN PARTITION? BEQ 20$ ;IF EQ YES MOVB #'S,(R0) ;SET SUBPARTITION 20$: MOVB (R0),PARMRK+5 ;SET PARTITION TICK MARK .IF DF VT52 MOV #ESC,R2 ;SEND ESCAPE TO VT52 CALL OUTCHR .ENDC MOV #CD,R2 ;FLAG STRING TO CALL OUTCHR ;DISPLAY PAR LETTER MOV R5,R2 ;SET 'Y' COORDINATE INC R5 ;UPDATE IT .IFNDF V$IDEO ; JGD08 CALL OUTSPC ;OUTPUT SPECIAL CHAR .IFF ; JGD08 CALL OUTCHR ;OUTPUT Y COORD ; JGD08 .ENDC ; JGD08 .IF DF VT52 MOV #31.+68.,R2 ;SET X FOR 80 COL VT52 .IFF MOV #31.+65.,R2 ;SET X FOR 72 COL VT05 .ENDC CALL OUTCHR ;OUTPUT CHARACTER MOV #PARMG2,R3 ;DISPLAY PAR NAME CALL OUTLN2 ;AND LETTER CMP R4,P.MAIN(R4) ;IS THIS A MAIN PARTITION? BEQ 25$ ;IF EQ YES MOV P.MAIN(R4),R1 ;GET MAIN PARTITION PCB ADDRESS CMP P.REL(R4),P.REL(R1) ;SAVE BASE ADDRESS? BEQ 30$ ;IF EQ YES -- DON'T OVERWIRTE 25$: MOV P.REL(R4),R1 ;START OF PAR BEQ 30$ ;IGNORE LOADER .IF NDF M$$MGE CLC ;CONVERT TO ROR R1 ;32.W UNITS .REPT 5 ASR R1 ; .ENDR .ENDC CALL MEMARK ;MARK MEMORY LINE ;TO CORRESPOND 30$: MOV (R4),R4 ;POINT AT NEXT PCB BNE 10$ ;IF NE MORE TO GO CALL $UNLKL ;UNLOCK SYSTEM LISTS .IF DF INOUT MOV #INMSG,R3 ;DISPLAY IN: MESSAGE ONCE ONLY CALL OUTLIN MOV #OUTMSG,R3 ;DISPLAY OUT: MESSAGE NOW CALL OUTLIN .ENDC .IF DF ERRSEQ .IF DF E$$DVC!E$$NSI MOV #ERRMSG,R3 ;DISPLAY ERRORS MESSAGE CALL OUTLIN ; .ENDC .ENDC JMP DSCTL ;NO MORE EXECUTING IN ;THIS BUFFER ; ; **-MEMARK-MARK THE MEMORY LINE WITH A LETTER ; INDICATING THE TYPE OF PARTITION THAT ; STARTS AT THE INDICATED MAIN MEMORY ; LOCATION ; ; INPUTS: ; ; R1=MEMORY ADDR IN 32. WORD UNITS ; ; JGD08 ; PARMRK+5=ASCII CHAR TO MARK WITH ; JGD08 ; OR PARMRK+4 IF VIDEO BOARD ; JGD08 ; MEMARK: ADD SYSRND,R1 ;ROUND UP ; EB170 ; EB170 ; ; EB170 ; DO THE CNVR MACRO BY HAND SO THE OVERFLOW CASE CAN BE ; EB170 ; CAUGHT ; EB170 ; ; EB170 ; EB170 BCS 20$ ;IF CS OVERFLOW ; EB170 MOV SYSHFT,R2 ;GET SHIFT COUNT ; EB170 2$: CLC ;DO NOT PROPAGATE SIGN BIT ; EB170 ROR R1 ;WHILE SHIFTING ; EB170 DEC R2 ;DONE SHIFTING? ; EB170 BNE 2$ ;IF NE NO ; EB170 MOV #31.+11.,R2 ;ASSUME LOWER 64K CMP #64.,R1 ;IS IT? BHI 5$ ;YES INC R2 ;ONE LINE LOWER SUB #64.,R1 ;X CHANGES ALSO CMP R1,#63. ;ARE WE OFF SCREEN BHIS 20$ ;IF HIS YES ; EB170 5$: MOVB R2,PARMRK+2 ;Y COORD TO CHANGE ADD #31.+1.,R1 ;X COORD TO CHANGE .IFNDF V$IDEO ; JGD08 MOVB R1,PARMRK+4 ; .IFF ; JGD08 MOVB R1,PARMRK+3 ; ; JGD08 .ENDC ; JGD08 ; JGD08 MOV #PARMRK,R3 ;DISPLAY THE MARK ON CALL OUTLIN ;THE PAR MEMORY LINE 20$: RETURN ; ; EB170 .IF LT .-DISIMG .=DISIMG .ENDC DSCTL: MOV #CURIMG+1,R0 ;INITIALIZE CURIMG MOV #64.*14.,R1 ;TO BLANKS 10$: MOVB #' ,(R0)+ ;BLANK A BYTE DEC R1 ;MORE LEFT TO BLANK? BGT 10$ ;YES .IF DF D$$F11 MOV #$DEVHD,R3 ;POINT AT DCB CHAIN 20$: MOV (R3),R3 ;POINT AT NEXT DCB BNE 30$ ;IF NE HAVE ANOTHER DCB IOT ;CRASH -- SYSTEM SHOULD HAVE A SY: 30$: CMP #"SY,D.NAM(R3) ;IS DEVICE NAME SY? BNE 20$ ;IF NE NO ADD #D.UCB,R3 ;POINT AT START OF UCB MOV R3,SY0 ;SAVE INITIAL UCB POINTER .ENDC JMP DSCTL1 ;NO MORE CODE IN ;THIS BUFFER .IF LT .-DSBUF-<64.*32.> .=DSBUF+<64.*32.> .IFF .ERROR ;TOO MUCH CODE IN DISPLAY BUFFER .ENDC ;======================================================= ; ; END OF ONCE ONLY CODE. ALL CODE AND DATA ABOVE ; THIS POINT IS USED ONLY AT INITIALIZATION. ; ;======================================================= .PAGE .SBTTL RUNTIME VARIABLES .NLIST BEX ; ; STORAGE OF BRACKETS USED IN DELINIATION OF TASKS ; AND PARTITIONS. ; ; ADJACENCY ASSUMED ; ; .EVEN .WORD 10. ;IN CASE DISIMG OVERFLOWS (USER ERR) ANGBKT: .ASCII /<>/ ;FOR EXECUTING TASKS SQRBKT: .ASCII /[]/ ;FOR NOT EXECUTING TASKS RNDBKT: .ASCII /()/ ;FOR COMMON PARTITIONS ; ; STORAGE FOR OPTIMIZTION MEMORY CELLS ; LASTX: .WORD 0 ;LAST VT05 X COORD LASTY: .WORD 0 ;LAST Y COORD ; ; CELLS TO SUPPORT AUTO MEMORY SIZE ALGORITHM ; SYSHFT: .WORD 0 ;NUMBER OF BITS ONE MUST ;SHIFT RIGHT TO MAKE 32. WORD ;CHUNKS INTO SCREEN CHUNKS (ON ;128. K SYSTEM THIS WAS 5). SYSRND: .WORD 0 ;ROUNDING FACTOR FOR ABOVE SYSTMP: .WORD 0 ;FOR MACRO TEMPORARY STORAGE .IFNDF V$IDEO ; JGD08 TIMLOC: .ASCIZ <31.+1.><0><31.+45.> ; .IFF ; JGD08 TIMLOC: .ASCIZ <31.+1.><31.+45.><0> ; ; JGD08 .ENDC ; JGD08 ; JGD08 TIMMSG: .BLKB 22. ;TIME AND DATE DISPLAY .IF DF D$$POO .IFNDF V$IDEO ; JGD08 POOLOC: .ASCII <31.+2><0><31.+14.> ; .IFF ; JGD08 POOLOC: .ASCII <31.+2><31.+14.><0> ; ; JGD08 .ENDC ; JGD08 .REPT 19. .ASCII / / ;POOL DISPLAY .ENDR .BYTE 0 ;POOL DISPLAY SENTINEL ; JGD08 .IFNDF V$IDEO ; JGD08 MINLOC: .ASCII <31.+2><0><31.+43.> ; DISPLAY OF THE MIN POOL .IFF ; JGD08 MINLOC: .ASCII <31.+2><31.+43.><0> ; DIS OF THE MIN POOL ; JGD08 .ENDC ; JGD08 ; THE SYSTEM HAS REACHED SO FAR .REPT 17. ; JGD .ASCII / / ; SPACE FOR DISPLAY ; JGD .ENDR ; JGD .BYTE 0 ; SENTINAL ; JGD .ENDC FENCE: .ASCIZ /::::::/ ;LIMIT OF MAIN MEMORY MARKER .IFNDF V$IDEO ; JGD08 TSKLOC: .ASCIZ <31.+2><0><31.+1> ;SCOPE LOCN OF NEXT RUNNABLE TASK .IFF ; JGD08 TSKLOC: .ASCIZ <31.+2><31.+1><0> ;LOCN OF NEXT TASK ; JGD08 .ENDC ; JGD08 NULTSK: .ASCIZ /*IDLE*/ ;DISPLAYED IF NULL TASK IS NEXT RUNNABLE TSKMSG=TIMMSG ;SHARE WITH TIME BUFFER .EVEN EXETSK: .BLKW 2 ;HOLDS RAD50 NAME OF NEXT RUNNABLE TASK CURTSK: .WORD -1,-1 ;HOLDS NAME OF LAST DISPLAYED TASK .IF DF D$$F11 .IFNDF V$IDEO ; JGD08 FREEN: .BYTE ESC,CD,31.+21.,0,31.+10. ; FILES-11 MOVE TO BOT OF PAGE .IFF ; JGD08 FREEN: .BYTE ESC,CD,31.+21.,31.+10.,0 ; FILES-11 MOVE TO BOT OF PAGE; JGD08 .ENDC ; JGD08 .REPT 81. ; DEVICES FREE BLOCKS .ASCII / / ;DISPLAY .ENDR .BYTE 0 ;SENTINEL .ENDC .IF DF INOUT ; ; DEFINE THE POSITIONS OF THE INOUT SIZE MESSAGES ; .IF GT YINO-13. YIN=YINO-4. .IFF YIN=YINO .ENDC INNL=<1.+YIN-3.>*64.+XINO+DISIMG ;NUMBER OF IN: TASKS INML=<2.+YIN-3.>*64.+XINO+DISIMG ;TOTAL MEMORY FOR IN: TASKS OUTNL=<4.+YIN-3.>*64.+XINO+DISIMG ;NUMBER OF OUT: TASKS OUTML=<5.+YIN-3.>*64.+XINO+DISIMG ;MEMORY FOR OUT: TASKS .IF GT OUTML-ANGBKT .ERROR ;BAD DEFINITIONS OF YINO, OR XINO .ENDC ; ; LOCAL MEMORY FOR INOUT OPTION ; COVER: .ASCIZ / / ;COVERUP MESSAGE TO WIPE OUT .IF DF ERRSEQ .IF DF E$$DVC!E$$NSI ; ; TEMPLATE FOR LOGGED ERROR COUNT ; ERRSQ: ;REF LABEL .IF DF VT52 .IFNDF V$IDEO ; JGD08 .ASCII <31.+20.><0><31.+69.> ; .IFF ; JGD08 .ASCII <31.+20.><31.+69.><0> ; ; JGD08 .ENDC ; JGD08 .IFF .ASCII <31.+20.><0><31.+66.> ; .ENDC .ASCIZ / / .ENDC .ENDC .EVEN ;OLD NUMBERS INN: .WORD 0 ;NUMBER OF TASKS IN INM: .WORD 0 ;MEMORY OF TASKS IN: IN 128. WORD ;CHUNKS OUTN: .WORD 0 ;NUMBER OF TASKS OUT OUTM: .WORD 0 ;MEMORY FOR TASKS OUT: (SAME AS ABOVE) .ENDC .LIST BEX .EVEN ; ; VT5FLG IS A CELL THAT IS SET TO SHOW WHETHER THE ; PRIMARY DISPLAY DEVICE ON LUN VT5LUN IS A VT05 OR ; NOT. IT HAS THREE PROPER VALUES: ; ; 1 THE DISPLAY DEVICE IS A VT05 ; 0 THE DISPLAY DEVICE IS NOT A VT05 BUT IT ; IS A RECORD ORIENTED DEVICE ; -1 THE DISPLAY DEVICE IS NOT A VT05 OR A RECORD ; ORIENTED DEVICE EITHER. ; ; INITIALLY VT05 TYPE DEVICE IS ASSUMED. ; VT5FLG: .WORD 1 ; ; DISPLAY OUTPUT QIO DPB ; DSQIO: QIOW$ IO.WAL,VT5LUN,VT5EFG,,,, ; JGD07 DSFUN=DSQIO+Q.IOFN ;ADDRESS OF FUNCTION CODE BUFPTR=DSQIO+Q.IOPL+0 ;ADDRESS OF OUTPUT BUFFER ADDR BUFCTR=DSQIO+Q.IOPL+2 ;ADDRESS OF BYTES IN BUFFER DSCCR=DSQIO+Q.IOPL+4 ;ADDRESS OF CARRIAGE CONTROL CODE .IFDF V$IDEO FRMFED: .BYTE ES,0 ERSQIO: QIOW$ IO.WAL,VT5LUN,VT5EFG,,,, .ENDC DSWT: WTSE$ VT5EFG ; ; MARK TIME DPB'S ; MARK1S: MRKT$ 2,WAITT,2 ;ONE SECOND USING EFN 2 MARKWT: .IFNDF S$$TOP ; IF STOP DIRECTIVE NOT PRESENT ;JGD10 WTSE$ 2 ; .IFF ; ;JGD10 STSE$ 2 ; STOP FOR EVENT FLAG ;JGD10 .ENDC ; ;JGD10 ; ; MISCELLANEOUS TEMPORARY STORAGE ; TIMBUF: .BLKW 8. ;TIME PARAMETERS .IF DF D$$F11 SY0: .WORD 0 ;POINTER TO UCB OF SY0: F11DEV: .WORD 0,0 ;FREE BLOCKS ON SY: .REPT MAXF11-1 ;FREE BLOCKS FOR .WORD -1,-1 ;OTHER MOUNTED .ENDR ;FILES-11 DEVICES LASTC: .WORD -1 ;THE LAST VALUE OF COUNT LASPOS: .WORD FREEN ;LAST END POSITION ON SCREEN .ENDC .IF DF D$$POO POOL: .BLKW 3 ;RAW DATA ON POOL STATISTICS MAXBS: .WORD 0 ;MAX CONTIGUOUS BLOCK IN POOL TOTALS: .WORD 0 ;TOTAL FREE WORDS IN POOL FRAGS: .WORD 0 ;NUMBER OF POOL FRAGMENTS MINBS: .WORD 40000 ;MIN CONTIG. BLOCK WHEN POOL SIZE SMALLEST ; JGD MINTOT: .WORD 40000 ;MIN TOTAL FREE BYTES REACHED IN POOL ; JGD MAXFRG: .WORD 0 ;MAXIMUM NUMBER OF POOL FRAGMENTS EVER ; JGD FLAG: .WORD 0 ;PRINT FLAG ; JGD .ENDC .IF DF ERRSEQ .IF DF E$$DVC!E$$NSI ERRS: .WORD -1 ;SEQUENCE NUMBER OF NEXT ERROR .ENDC .ENDC .IF DF UPTIME .IF DF UTLIZ .ERROR ; UPTIME AND UTILIZATION DISPLAYS CONFLICT ; JGD11 .ENDC SEC: .WORD -360. ;SECOND COUNT-DOWN FOR TENTHS OF HOURS OLDSEC: .WORD 0 ;SECONDS OF MINUTE LAST TIME THRU NEWSEC: .WORD 0 ;SECONDS OF MINUTE THIS TIME HRTEN: .WORD 0 ;TENTHS OF HOURS ACCUMULATOR HOURS: .WORD 0 ;HOURS .IFNDF V$IDEO ; JGD08 UPTIM: .ASCII <31.+1><0><31.+28.>/UP / .IFF ; JGD08 UPTIM: .ASCII <31.+1><31.+28.><0>/UP / ; JGD08 .ENDC ; JGD08 UPNUM: .BLKB 10. ;LEAVE ROOM FOR HOURS AND TENTHS HRM: .ASCIZ / HRS/ ;THE END OF THE MESSAGE (WILL FLOAT) .EVEN ;JUST TO MAKE SURE .ENDC ; .ENDC UPTIM .IF DF UTLIZ ; DISPLAY SYSTEM % UTILIZ ; JGD11 .IFNDF V$IDEO ; JGD11 UTIL: .ASCII <31.+1><0><31.+28.>/% UTIL=/ ; JGD11 .IFF ; JGD11 UTIL: .ASCII <31.+1><31.+28.><0>/% UTIL=/ ; JGD11 .ENDC ; JGD11 UTLNM: .BLKB 6. ; LEAVE ROOM FOR VALUE ; JGD11 .EVEN ; PLACE ON WORD BOUNDRY ; JGD11 UTLC1: .WORD 0 ; EVERYONE NEEDS A CONSTANT OR TWO ; JGD11 .ENDC ; .ENDC UTLIZ ;+ ; TEMPORARY STORAGE FOR TASK LIST PARAMETERS ; (ADJACENCY ASSUMED) ; ; EACH TASK IN MEMORY HAS A FIVE WORD ENTRY IN ; THIS TEMPORARY STORAGE AREA. THE ENTRIES HAVE ; THE FOLLOWING FORM: ; ; ------------------------------------------------- ; ! SECOND TASK NAME WORD, 3 CHARS RAD50 ! ; ------------------------------------------------- ; ! FIRST TASK NAME WORD, 3 CHARS RAD50 ! ; ------------------------------------------------- ; ! SIZE OF PARTITION IN BYTES ! ; ------------------------------------------------- ; ! TASK STATUS WORD ! ; ------------------------------------------------- ; ! BASE ADDRESS OF PARTITION ! ; ------------------------------------------------- ; ; ENTRIES ARE ADDED FROM THE TOP DOWN, REMOVED FROM THE ; BOTTOM UP. WHEN THE FIRST WORD REMOVED IN AN ENTRY IS ; ZERO (I.E., THE SENTINEL WORD) THEN REMOVAL STOPS. ; THIS ALSO STOPS IF BASE OF PARTITION IS ZERO. ;- TSKSAT: .WORD 0 ;TASK STATUS WORD TSKNAM: .BLKB 6 ;ASCII TASKNAME .WORD 0 ;MUST HAVE A ZERO GUARD WORD TSKLST: .BLKW 1 ;ADDRESS OF TASK LIST BUFFER TSKLND: .BLKW 1 ;ADDRESS OF BUFFER END .IF DF D$$F11 ; ; TEMPORARY STORAGE FOR FREE BLOCK DISPLAY (OVERLAPS TASK LIST BUFFER) ; F11TMP: .BLKW 1 ;ADDRESS OF FREE BLOCK LIST BUFFER F11TDV: .BLKW 1 ;ADDRESS OF DEVICE NAME BUFFER COUNT: .BLKW 1 ;FILES-11 DEVICE COUNTER .ENDC .PAGE .SBTTL MAIN DISPLAY LOOP ; ; **-DSCTL1-DISPLAY CONTROL ; DSCTL1: DIR$ #MARK1S ;MARK TIME FOR 1 SEC CALL INIDIS ;INITIALIZE DISIMG TO BLANKS CALL DSTIM ;DISPLAY TIME AND TASKS DIR$ #MARKWT ;WAIT FOR 1 SECOND .IF DF B$$SCR TST VT5FLG ;NON-VT05 YET RECORD? BNE 20$ ;IF NE NO ; ; DISPLAY BUFFER ON REGULAR TERMINAL DEVICE W/O CURSOR ; CONTROL. MUST HAVE B$$SCR OPTION WITH THIS ; MOV SCRP,R1 ;SET UP FIRST LINE FWA MOV #WIDTH,R2 ;LENGTH EACH LINE MOV #HIGHT,R3 ;NUMBER OF LINES MOV #NULLIN,BUFPTR ;SET UP FWA FIRST LNE MOV #1,BUFCTR ;SET UP LENGTH DIR$ #DSQIO ;DO QIO BCS 20$ ;IF ERROR EXIT ; DIR$ #DSWT ;WAIT FOR I/O ; JGD07 ; BCS 20$ ;IF ERROR EXIT ; JGD07 10$: MOV R2,R4 ;SET UP WIDTH ADD R1,R4 ;LAST CHAR+1 IN LINE 12$: CMPB #' ,-(R4) ;IS IT A BLANK BNE 14$ ;IF NE NO CMP R1,R4 ;AT START OF LINE YET BNE 12$ ;IF NE NO 14$: INC R4 ;ADJUST FOR AT LEAST ONE SUB R1,R4 ;CALC LENGTH OF LINE MOV R1,BUFPTR ;SET START OF LINE MOV R4,BUFCTR ;SET LENGTH OF LINE DIR$ #DSQIO ;PRINT LINE BCS 20$ ;IF ERROR EXIT ; DIR$ #DSWT ;WAIT FOR I/O ; JGD07 ; BCS 20$ ;IF ERROR EXIT ; JGD07 ADD R2,R1 ;BUMP TO NEXT LINE DEC R3 ;ANY MORE LEFT BGT 10$ ;IF GT YES 20$: ;REFERENCE LABEL .IF DF P$$RNT CALL PNTBUF ;PRINT BUFFER CLOSE$ #FDBPNT ;CLOSE FILE EXIT$S ;ONCE ONLY .ENDC TST VT5FLG ;IS IT VT05 DEVICE BNE DSCTL1 ;YES EXIT$S ;NO, THIS IS IT .IFF BR DSCTL1 ;GO BACK FOR MORE .ENDC .PAGE .SBTTL DISPLAY DATE AND TIME ; ; **-DSTIM-DISPLAY CURRENT TIME OF DAY ; DSTIM: GTIM$S #TIMBUF ;GET TIME PARAMETERS .IF DF UPTIME MOV TIMBUF+G.TISC,NEWSEC ;GET THE SECOND COUNT THIS TIME .ENDC MOV #TIMLOC,R3 ;MOVE CURSOR TO TIME CALL OUTLIN ;AREA OF SCREEN MOV #TIMMSG,R0 ;CONVERSION BUFFER MOV R0,R3 ;SAVE ITS ADDR MOV #TIMBUF,R1 ;TIME PARAMETERS CALL $DAT ;CONVERT DATE MOVB #' ,(R0)+ ;INSERT A SPACE MOV #3,R2 ;CONVERT ASCII OF CALL $TIM ;HOURS, MINS, AND SEC MOVB #' ,(R0)+ ;ONE SPACE FOR THE FIRST ;OF THE MONTH CLRB (R0) ;SET SENTINEL BYTE CALL OUTLN2 ;OUTPUT CURRENT TIME .IF DF UTLIZ ; JGD11 .IF DF S$$ACC ; IF KMS ACCOUNTING GENNED IN ; JGD11 TST $ACMSK ; IS ACCOUNTING ACTIVE ; JGD11 BEQ 101$ ; IF EQ 0, NO, SKIP ; JGD11 MOV $UTLIZ,R1 ; GET THE # ACTIVE TICS ; JGD11 CLR $UTLIZ ; RESET THE COUNTER ; JGD11 MOV #100.,R0 ; MULT BY 100 TO CNVRT TO % ; JGD11 CALL $MUL ; MULTIPLY(ANS IN R1) ; JGD11 MOV R1,R0 ; MAKE ANSWER THE DIVIDEND ; JGD11 MOV UTLC1,R1 ; GET THE DIVISOR ; JGD11 CALL $DIV ; DIVIDE (RESULT IN R0) ; JGD11 CMP R0,#100. ; CAN'T HAVE >100% UTILIZ, SO CHECK ; JGD11 BLE 1$ ; IF LE, OK ; JGD11 MOV #100.,R0 ; NO, THEN FORCE TO BE KOSHER ; JGD11 1$: MOV R0,R1 ; ANSWER INTO R1 FOR $CBTA ; JGD11 MOV #27012,R2 ; SET FOR DEC, BLANK FILL, 3 DIGITS ; JGD11 MOV #UTLNM,R0 ; WHERE TO PUT RESULT ; JGD11 CALL $CBTA ; CONVERT TO DECIMAL ASCII ; JGD11 CLRB (R0) ; TERMINATE WITH NULL ; JGD11 MOV #UTIL,R3 ; STRING TO OUTPUT ; JGD11 CALL OUTLIN ; OUTPUT THE LINE ; JGD11 .ENDC ; END S$$ACC ; JGD11 .ENDC ; END UTLIZ ; JGD11 101$: .PAGE .SBTTL DISPLAY SYSTEM ERROR COUNT ; EB015 .IF DF ERRSEQ .IF DF E$$DVC!E$$NSI MOV $ERRSQ,R1 ;PICK UP ERROR SEQUENCE NUMBER CMP R1,ERRS ;HAS IT CHANGED? BEQ ERREND ;IF EQ NO MOV R1,ERRS ;SAVE NEW SEQUENCE NUMBER MOV #ERRSQ+5,R0 ;POINT AT ERROR NUMBER TEMPLATE CLR R2 ;SUPPRESS LEADING ZEROS CALL $CBDMG ;CONVERT NUMBER OF ERRORS TO ASCII MOVB #'.,(R0)+ ;ADD DECIMAL POINT 2$: MOVB #' ,(R0)+ ;OVERWRITE ANY OLD TRAILING DIGITS TSTB (R0) ;FOUND END OF TEMPLATE? BNE 2$ ;IF NE NO MOV #ERRSQ,R3 ;WRITE OUT THE NEW NUMBER OF ERRORS CALL OUTLIN ; ERREND: ;REF LABEL .ENDC .ENDC .PAGE .SBTTL DISPLAY TOTAL UPTIME FOR RMDEMO .IF DF UPTIME ; ; ADD UP THE SECONDS TO 360 THEN UPDATE THE 10TH HOUR COUNTER. ; WHENEVER THAT OVERFLOWS UPDATE THE HOUR COUNTER AND DISPLAY ; THE LINE. ; ; ; NEW ALGORITHM FOR SECOND UPDATES -- IT LOOKS AT THE SECOND COUNT ; THIS TIME AND COMPARES WITH THE SECOND COUNT LAST TIME, ADJUSTING ; FOR PASSING GO (60 SECONDS). THIS DIFFERENCE IS HOW MUCH TIME HAS ; PASSED. THIS MAKES THE UPTIME ALGORITHM SELF-CORRECTING AS LONG ; AS RMDEMO'S MARK-TIME TAKES LESS THEN 60 SECS TO COMPLETE (E.G. ; PRESSING COPY ON A VT52 WITH COPIER) YET PEOPLE PLAYING WITH THE ; TIME COMMAND CANNOT AFFECT THE UPTIME COUNT BY MORE THAN A MINUTE ; EVERY TIME THEY PLAY (SO THEY SHOULD'T BOTHER). MOV NEWSEC,R1 ;PICK UP THIS TIMES SECONDS CMP R1,OLDSEC ;HAS THE SECOND HAND PASSED THE 12 BGE 5$ ;IF GE NO ; ; THE SKINNY HAND HAS PASSED THE 12, ADJUST IT ; ADD #60.,R1 5$: SUB OLDSEC,R1 ;HOW LONG HAS IT BEEN MOV NEWSEC,OLDSEC ;SAVE THIS FOR LAST ADD R1,SEC ;COUNT DOWN BMI 30$ ;IF NOT TO ZERO YET SUB #360.,SEC ;RESET THE TIMER FOR 1 10TH HOUR INC HRTEN ;ADD ANOTHER TENTH HOUR CMP #10.,HRTEN ;UP THERE YET BNE 10$ ;IF NE NO INC HOURS ;ONE MORE HOUR CLR HRTEN ;NO TENTHS 10$: MOV #UPNUM,R0 ;THIS IS WHERE WE CONVERT INTO MOV HOURS,R1 ;DO THE HOURS BEQ 15$ ;NO HOURS, SKIP IT CLR R2 ;WATCH OUT FOR LEADING ZEROS CALL $CBDMG 15$: MOVB #'.,(R0)+ ;INSERT THE DECIMAL POINT MOV HRTEN,R1 ;GET THE NUMBER OF TENTHS CLR R2 CALL $CBDMG CLRB (R0) ;TERMINATE STRING MOV #UPTIM,R3 ;SEND OUT STRING CALL OUTLIN MOV #HRM,R3 ;AND THE HOURS CALL OUTLN2 30$: .ENDC .PAGE .SBTTL DISPLAY NAME OF NEXT RUNNABLE TASK MOV #EXETSK,R5 ;POINT TO NEXT RUNNABLE TASK BUFFER CALL $SWSTK,110$ ;SWITCH TO SYSTEM STATE MOV $RQSCH,R0 ;IS THERE A RESCHEDULE REQUEST? BNE 40$ ;IF NE YES MOV $TKTCB,R0 ;ELSE, GET OUR OWN TCB ADDRESS 40$: CMP R0,$TKTCB ;ARE WE LOOKING AT THIS TASK BEQ 60$ ;IF EQ YES -- IGNORE IT TST T.STAT(R0) ;IS THE TASK BLOCKED? BNE 60$ ;IF NE YES TST T.ASTL(R0) ;IS AN AST QUEUED FOR THE TASK? BEQ 50$ ;IF EQ NO BIT #T2.AST!T2.DST,T.ST2(R0) ;IN AST OR AST'S DISABLED? BEQ 80$ ;IF EQ NO 50$: BIT #T2.STP!T2.SPN,T.ST2(R0) ;IS TASK STOPPED OR SUSPENDED? BNE 60$ ;IF NE YES BIT #T2.WFR,T.ST2(R0) ;IS TASK IN WAITFOR STATE? BEQ 80$ ;IF EQ NO .IF DF BL26 MOV T.PCB(R0),R4 ;GET TASK'S PCB ADDRESS ; JGD05 MOV P.HDR(R4),R4 ;GET TASK'S HEADER ADDRESS ; JGD05 BIT H.EFLM(R4),@H.EFLM+2(R4) ;IS THE WAITFOR SATISFIED? ; JGD05 .ENDC ; JGD05 .IF DF BL27 ; JGD05 BIT T.EFLM(R0),@T.EFLM+2(R0) ; IS THE WAITFOR SATISFIED? ; JGD05 .ENDC ; JGD05 BNE 80$ ;IF NE YES 60$: MOV T.ACTL(R0),R0 ;GET TCB ADDRESS OF NEXT TASK IN ATL BNE 40$ ;IF NE THERE IS ONE CLR (R5)+ ;STORE 0 FOR NULL TASK NAME CLR (R5)+ ; BR 100$ ; 80$: MOV T.NAM(R0),(R5)+ ;STORE TASK NAME MOV T.NAM+2(R0),(R5)+ ; 100$: RETURN ;RETURN TO TASK STATE 110$: MOV #CURTSK,R4 ;POINT TO LAST RUNNABLE TASK NAME CMP (R5)+,(R4)+ ;IS IT THE SAME TASK? BNE 120$ ;IF NE NO CMP (R5),(R4) ; BEQ EXEDN ;IF EQ YES 120$: MOV #TSKLOC,R3 ;POINT TO LOCN INFO FOR TASK DISPLAY CALL OUTLIN ;PUT IN BUFFER MOV (R5),(R4) ;SAVE NAME OF DISPLAYED TASK MOV (R5),-(SP) ; MOV -(R5),-(R4) ; BIS (R5),(SP)+ ;IS IT THE NULL TASK? BNE 125$ ;IF NE NO MOV #NULTSK,R3 ;POINT TO NULL TASK DISPLAY STRING BR 130$ ; 125$: MOV #TSKMSG,R0 ;GET CONVERSION BUFFER ADDRESS MOV R0,R3 ;COPY ADDRESS INTO R3 MOV (R5)+,R1 ;GET FIRST HALF OF TASK NAME CALL $C5TA ;CONVERT TO ASCII AND STORE MOV (R5)+,R1 ;GET LAST HALF CALL $C5TA ;CONVERT AND STORE CLRB (R0) ;STORE ZERO BYTE TERMINATOR (ASCIZ) 130$: CALL OUTLN2 ;OUTPUT NEXT RUNNABLE TASK NAME EXEDN: ;REF LABEL .PAGE .SBTTL DISPLAY POOL INFORMATION ; ; **-DISPLAY THE DECIMAL NUMBER OF WORDS IN THE ; LARGEST POOL BLOCK, THE DECIMAL NUMBER OF ; FREE WORDS IN POOL, AND THE NUMBER OF ; FREE BLOCKS IN POOL ; .IF DF D$$POO MOV #POOL,R1 ;POINT TO POOL RAW DATA BUFFER CLR (R1)+ ;CLEAR NUMBER OF FRAGMENTS CLR (R1)+ ;CLEAR TOTAL POOL CLR (R1) ;CLEAR MAXIMUM PIECE CALL $SWSTK,32$ ;SWITCH TO SYSTEM STATE MOV #$CRAVL,R4 ;GET ADDRESS OF POOL LISTHEAD BR 31$ ;BRANCH INTO LOOP 20$: CMP (R1),2(R4) ;IS MAX > THIS BLOCK? BHIS 30$ ;IF HIS YES MOV 2(R4),(R1) ;NO, SET NEW MAX 30$: ADD 2(R4),-(R1) ;ADD THIS SPACE TO TOTAL INC -(R1) ;INCREMENT NUMBER OF POOL FRAGMENTS CMP (R1)+,(R1)+ ;POINT R1 TO END OF RAW DATA BUFFER 31$: MOV (R4),R4 ;GET ADDR OF NEXT BLOCK BNE 20$ ;IF NE MORE TO EXAMINE RETURN ;ELSE, RETURN TO TASK STATE 32$: CMP (R1),MAXBS ;DID MAXIMUM BLOCK CHANGE? BNE 33$ ;IF NE YES CMP -(R1),TOTALS ;DID TOTAL POOL CHANGE? BNE 33$ ;IF NE YES CMP -(R1),FRAGS ;DID NUMBER OF FRAGMENTS CHANGE? BEQ 40$ ;IF EQ NO 33$: ; JGD08 MOV #POOLOC+5,R0 ;POINT INTO POOL DISPLAY BUFFER ; JGD08 MOV #POOL+4,R4 ;POINT INTO RAW DATA BUFFER ;**-1 MOV (R4),MAXBS ;STORE NEW MAXIMUM BLOCK VALUE MOV (R4),R1 ;AND PUT A COPY IN R1 ASR R1 ;CONVERT TO WORDS CLR R2 ;SUPPRESS LEADING ZEROES CALL $CBDMG ;CONVERT TO DECIMAL MOVB #'.,(R0)+ ;STORE DECIMAL POINT MOVB #':,(R0)+ ;AND FIELD TERMINATOR MOV -(R4),TOTALS ;STORE NEW TOTAL POOL VALUE MOV (R4),R1 ;AND PUT A COPY IN R1 ASR R1 ;CONVERT TO WORDS CLR R2 ;SUPPRESS LEADING ZEROES CALL $CBDMG ;CONVERT TO DECIMAL MOVB #'.,(R0)+ ;STORE DECIMAL POINT MOVB #':,(R0)+ ;AND FIELD TERMINATOR MOV -(R4),FRAGS ;STORE NEW POOL FRAGMENTS VALUE MOV (R4),R1 ;AND PUT A COPY IN R1 CLR R2 ;SUPPRESS LEADING ZEROES CALL $CBDMG ;CONVERT TO DECIMAL MOVB #'.,(R0)+ ;STORE DECIMAL POINT 35$: MOVB #' ,(R0)+ ;ERASE ANY OLD STATISTICS TSTB (R0) ;AT END-OF-BUFFER? BNE 35$ ;IF NE NO MOV #POOLOC,R3 ;UPDATE DISPLAY CALL OUTLIN ; CLR FLAG ; RESET THE PRINT WORST CASE POOL FLAG ; JGD CMP TOTALS,MINTOT ; IS THE TOTAL POOL LT BEFORE? ; JGD BGE 350$ ; IF GE NO ; JGD MOV TOTALS,MINTOT ; USE NEW VALUE FOR MIN TOT POOL ; JGD INC FLAG ; AND BE SURE TO PRINT IT ; JGD 350$: CMP FRAGS,MAXFRG ; DID NUMBER OF FRAGMENTS GO UP ; JGD BLE 351$ ; IF LE, NO ; JGD MOV FRAGS,MAXFRG ; YES,USE NEW VALUE ; JGD INC FLAG ; AND BE SURE TO PRINT IT ; JGD 351$: CMP MAXBS,MINBS ; DID CONTIGUOUS SIZE DECREASE ; JGD BGT 3511$ ; IF GT, NO ; JGD MOV MAXBS,MINBS ; YES IT DID ; JGD INC FLAG ; SO BE SURE TO PRINT IT ; JGD 3511$: TST FLAG ; DO WE PRINT WORST CASE POOL STAT. ; JGD BEQ 40$ ; IF EQ 0, NO ; JGD MOV #MINLOC+5,R0 ; GET ADDRESS OF WHERE TO STUFF DATA ; JGD MOV MINBS,R1 ; GET BLK SIZE AT MIN POOL ; JGD ASR R1 ; CONVERT BYTES TO WORDS ; JGD CLR R2 ; SUPRESS LEADING ZEROS ; JGD CALL $CBDMG ; CONVERT TO DECIMAL ; JGD MOVB #'.,(R0)+ ; MOVE IN A "." ; JGD MOVB #':,(R0)+ ; AND THEN A ":" ; JGD MOV MINTOT,R1 ; GET MIN POOL SIZE ; JGD ASR R1 ; CONVERT TO WORDS ; JGD CLR R2 ; STILL SUPRESS LEADING ZEROS ; JGD CALL $CBDMG ; AND CONVERT TO DECIMAL ; JGD MOVB #'.,(R0)+ ; MOVE IN A "." ; JGD MOVB #':,(R0)+ ; AND THEN A ":" ; JGD MOV MAXFRG,R1 ; NOW GET THE NUMBER OF FRAGMENTS ; JGD CLR R2 ; SUPRESS LEADING ZEROS ; JGD CALL $CBDMG ; CONVERT TO DECIMAL ; JGD MOVB #'.,(R0)+ ; STORE DECIMAL POINT ; JGD 352$: MOVB #' ,(R0)+ ; ERASE ANY OLD STATISTICS ; JGD TSTB (R0) ; REACHED SENTINAL YET? ; JGD BNE 352$ ; IF NE, NO, SO ZERO SOME MORE ; JGD MOV #MINLOC,R3 ; GET BUFFER FOR PRINTING ; JGD CALL OUTLIN ; AND PRINT IT OUT ; JGD 40$: ; .ENDC .PAGE .SBTTL DISPLAY FILES-11 INFORMATION .IF DF D$$F11 .IF GT MAXF11 MOV #MAXF11,COUNT ;MAX NUM OF FILES-11 ;DEVICES FOR FREE BLOCK ;DISPLAY MOV F11TDV,R1 ;GET ADDR OF DEVICE NAME BUFFER MOV @SY0,R2 ;ADDR OF SYSTEM DEVICE UCB 50$: MOV R2,R5 ;REMEMBER IT MOV U.RED(R2),R2 ;REDIRECTED? CMP R2,R5 ; BNE 50$ ;YES MOV SP,TIMBUF ;SAVE STACK POSITION ;IN TEMPORARY MOV #$SCDVT,-(SP) ;PREPARE TO LOOK ;AT ALL UCB'S MOV F11TMP,R0 ;GET ADDR OF FREE BLOCK STORAGE MOV U.VCB(R5),R3 ;SY: MOUNTED? BIT #DV.F11,U.CW1(R5) ;FILES-11 DEVICE (COULD BE 11S) BEQ 55$ ;IF EQ NO BITB #US.MNT,U.STS(R5) ;MOUNTED?? BEQ 130$ ;IF EQ YES 55$: MOV #-1,(R0)+ ;SAY IT IS CLR (R0)+ ; .IF EQ MAXF11-1 BR 132$ ; .IFF DEC COUNT ;THIS IS A DEVICE LIKE ALL OTHERS 60$: CALL @(SP)+ ;GET NEXT UCB ADDR BCS 133$ ;NO MORE TO LOOK AT CMP R5,R2 ;IS IT SY:? BEQ 60$ ;YES BIT #DV.F11,U.CW1(R5) ;FILES-11 DEVICE? BEQ 60$ ;NO BITB #US.MNT,U.STS(R5) ;MOUNTED? BNE 60$ ;NO MOV D.NAM(R3),(R1)+ ;GET ASCII DEVICE ;NAME MOVB U.UNIT(R5),(R1) ;MOVE UNIT NUMBER BICB #370,(R1) ;ASSUME ONE OCTAL BISB #60,(R1)+ ;DIGIT FOR UNIT NUMBER MOVB #':,(R1)+ ; MOV U.VCB(R5),R3 ; .IFTF 130$: MOVB V.FRBK(R3),(R0)+ ;SAVE NUMBER OF CLRB (R0)+ ;FREE BLOCKS MOV V.LRUC+1(R3),(R0)+ ;ON THIS DEVICE DEC COUNT ;CAN HANDLE MORE? .IFF BNE 60$ ;YES .IFTF 132$: MOV TIMBUF,SP ;KILL $SCDVT 133$: MOV #-1,(R0) ;SET SENTINEL MOV F11TMP,R5 ;FREE BLOCKS NOW MOV #F11DEV,R3 ;FREE BLOCKS BEFORE CMP COUNT,LASTC ;LOSE OR GAIN A ;DEVICE SINCE BEFORE? BNE 145$ ;YES, CHANGE DISPLAY 135$: CMP (R5)+,(R3)+ ;CHANGE IN FREE ;BLOCKS? BNE 140$ ;YES, NEW DISPLAY CMP (R5)+,(R3)+ ;CHANGE IN 2ND WORD? BEQ 165$ ;NO CMP -(R5),-(R3) ; 140$: CMP -(R5),-(R3) ;MOVE AT LEAST THE 145$: MOV (R5)+,(R3)+ ;CHANGE FROM MOV (R5)+,(R3)+ ;TEMPORARY STORAGE TST (R5) ;TO PERMANENT BPL 145$ ;IF NOT YET MOVED ;ENOUGH CLR R2 ;NO LEADING ZEROES MOV F11TDV,R4 ;DEVICE NAMES MOV F11TMP,R5 ;FREE BLOCK COUNTS MOV #FREEN+5,R0 ;WHERE TO PUT ASCII ;EQUIVALENT STRINGS TST (R5) ;SY: DISMOUNTED? BPL 155$ ;NO MOVB #'D,(R0)+ ;SHOW AS MOVB #'M,(R0)+ ;DISMOUNTED MOVB #'O,(R0)+ MOVB #',,(R0)+ BR 157$ ;DO OTHER DEVICES 150$: MOVB (R4)+,(R0)+ ;TRANSFER DEVICE MOVB (R4)+,(R0)+ ;NAME AND MOVB (R4)+,(R0)+ ;UNIT MOVB (R4)+,(R0)+ ; 155$: MOV R5,R1 ;POINT AT FREE ;BLOCKS WORDS CLR R2 ;MAKE SURE ABOUT ZEROS CALL $CDDMG ;TO DECIMAL MOVB #'.,(R0)+ ; MOVB #',,(R0)+ ; 157$: CMP (R5)+,(R5)+ ;BUMP POINTER TST (R5) ;DONE WITH DISPLAY? BPL 150$ ;NO TSTB -(R0) ;CRUSH THE COMMA CMP LASPOS,R0 ;IS THIS ONE LONGER BHI 159$ ;IF HIS NO CLRB (R0) ;NEED NEW TERMINATOR 159$: MOV R0,LASPOS ;SAVE THIS LENGTH 160$: TSTB (R0) ;IS THIS THE END BEQ 161$ ;IF EQ YES MOVB #' ,(R0)+ ;FILL A BLANK BR 160$ ;GO BACK FOR MORE 161$: ;REFERENCE LABEL MOV #FREEN,R3 ;DISPLAY THE CALL OUTLIN ;NEW LINE 165$: TST (R5) ;DONE WITH COMPARE? BPL 135$ ;NO MOV COUNT,LASTC ;SAVE MOUNTED DEVICE ;COUNTER .ENDC .ENDC .ENDC .PAGE .SBTTL DISPLAY BUSY PARTITIONS ; ; **-DISPLAY CONTENTS OF BUSY PARTITIONS ; ; THE INFORMATION DISPLAYED INCLUDES ACTIVE TASKS, ; NON-ACTIVE FIXED TASKS, LOADED COMMONS, AND ; LOADED DEVICE DRIVERS. ; DSTSK: CALL $SWSTK,40$ ;SWITCH TO SYSTEM STATE MOV TSKLST,R5 ;POINT R5 TO TASK LIST BUFFER MOV #$PARHD,R4 ;POINT R4 TO PARTITION LIST HEAD 5$: MOV (R4),R4 ;GET ADDRESS OF NEXT PCB BEQ 35$ ;IF EQ NONE LEFT BITB P.BUSY(R4),P.BUSY+1(R4) ;IS PARTITION BUSY? BEQ 5$ ;IF EQ NO .IF DF M$$MGE CLR R0 ;ASSUME NOT SYSTEM CONTROLLED PARTITION .IFTF BIT #PS.COM,P.STAT(R4) ;IS THIS A COMMON PARTITION? BEQ 10$ ;IF EQ NO 8$: MOV P.NAM+2(R4),(R5)+ ;STORE PARTITION NAME AS THE MOV P.NAM(R4),(R5)+ ; TASK NAME MOV P.SIZE(R4),(R5)+ ;STORE PARTITION SIZE MOV #COMFLG,(R5)+ ;STORE COMMON FLAG BR 30$ ;FINISH UP IN COMMON CODE 10$: ; .IFT BIT #PS.SYS,P.STAT(R4) ;SYSTEM CONTROLLED PARTITION? BEQ 20$ ;IF EQ NO MOV R4,R0 ;SAVE MAIN PCB ADDRESS 15$: MOV P.SUB(R4),R4 ;GET SUB-PARTITION PCB ADDRESS BNE 18$ ;IF NE GOT ONE MOV R0,R4 ;ELSE, RESTORE MAIN PCB ADDRESS BR 5$ ;REENTER MAIN LOOP 18$: BIT #PS.COM,P.STAT(R4) ;IS THIS A DYNAMIC COMMON? BNE 8$ ;IF NE YES 20$: ; .IFTF MOV P.TCB(R4),R3 ;GET TCB ADDRESS .IF DF L$$DRV BIT #PS.DRV,P.STAT(R4) ;IS THIS A LOADED DRIVER? BEQ 25$ ;IF EQ NO MOV D.NAM(R3),(R5)+ ;STORE (ASCII) DEVICE NAME CLR (R5)+ ; MOV P.SIZE(R4),(R5)+ ;STORE PARTITION SIZE MOV #DRVFLG,(R5)+ ;STORE DRIVER FLAG BR 30$ ;FINISH UP IN COMMON CODE .ENDC 25$: ; .IF NDF R$$11S CMP R4,$LDRPT ;IS THIS THE LOADER? BEQ 5$ ;IF EQ YES, DON'T DISPLAY .ENDC MOV T.NAM+2(R3),(R5)+ ;STORE TASK NAME MOV T.NAM(R3),(R5)+ ; MOV P.SIZE(R4),(R5)+ ;STORE PARTITION SIZE CLR -(SP) ;INIT FLAGS WORD BIT #TS.EXE,T.STAT(R3) ;IS THIS TASK ACTIVE? BEQ 26$ ;IF EQ YES BIS #EXEFLG,(SP) ;SET NOT EXECUTING FLAG 26$: BIT #T2.FXD,T.ST2(R3) ;IS THIS TASK FIXED IN MEMORY? BEQ 28$ ;IF EQ NO BIS #FXDFLG,(SP) ;SET FIXED FLAG 28$: MOV (SP)+,(R5)+ ;STORE FLAGS 30$: MOV P.REL(R4),(R5)+ ;STORE PARTITION BASE ADDRESS CMP R5,TSKLND ;ARE WE AT END OF TASK INFO BUFFER? .IFT BHIS 35$ ;IF HIS YES TST R0 ;PROCESSING SYSTEM CONTROLLED PARTITION? BNE 15$ ;IF NE YES BR 5$ ;ELSE, USE MAIN LOOP .IFF BLO 5$ ;IF LO NO .ENDC ; (.IF DF M$$MGE) 35$: MOV @$HEADR,R0 ;GET ADDR 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 ;BASE ADDR OF NEXT PAR BEQ INOT ;NO MORE TASKS TO EDIT .IF NDF M$$MGE CLC ; ROR R2 ;CONVERT TO 32.W BLOCKS .REPT 5 ASR R2 ; .ENDR .ENDC MOV R2,-(SP) ;SAVE BASE ADDR MOV #SQRBKT,R1 ;ASSUME TASK IS NOT EXECUTING MOV -(R5),TSKSAT ;SAVE STATUS BIT #EXEFLG,(R5) ;IS TASK ACTIVE? BNE 44$ ;IF NE NO MOV #ANGBKT,R1 ;USE ANGLE BRACKETS 44$: BIT #COMFLG,(R5) ;IS THIS A COMMON PARTITION? BEQ 45$ ;IF EQ NO MOV #RNDBKT,R1 ;USE ROUND BRACKETS ; EB170 ; ; EB170 ; DO THE CNVR MACRO BY HAND SO OVERFLOW CASES CAN BE CAUGHT ; EB170 ; ; EB170 ; EB170 45$: ADD SYSRND,R2 ;ADD IN ROUNDING FACTOR ; EB170 BCS 4520$ ;IF CS OVERFLOW ; EB170 MOV SYSHFT,R0 ;GET SHIFT COUNT ; EB170 4510$: CLC ;DO NOT PROPAGATE SIGN BIT ; EB170 ROR R2 ;DURING SHIFTING ; EB170 DEC R0 ;DONE SHIFTING? ; EB170 BNE 4510$ ;IF NE NO ; EB170 CMP R2,#129. ;IS IT TOO BIG? ; EB170 BLO 4530$ ;IF LO NO ; EB170 4520$: TST -(R5) ;START CLEANING OFF STACK ; EB170 BR 4550$ ;SKIP THIS ENTRY ; EB170 4530$: MOV R2,R0 ;SAVE SCREEN SPACES ; EB170 ADD #DISIMG+1+<64.*6.>,R2 ;DISPLAY CELL ;ON OUR LEFT ;+ ; A FEW WORDS ABOUT TASK DISPLAY. THE LEFT BRACKET ; UNDERNEATH THE TASK NAME (INDICATING WHAT ; PORTION OF MEMORY THE TASK OCCUPIES) IS THE BASE ; OF ITS PARTITION ROUNDED TO THE NEAREST QUANTUM (OCTAL) ; BOUNDARY. THE LEFT BRACKET WILL NOT OVERWRITE ; ANY CHARACTER IN THE DISPLAY. IN PARTICULAR IT ; WILL NOT OVERWRITE THE RIGHT BRACKET OF A TASK ; ADJACENT IN MEMORY. HOWEVER THE RIGHT BRACKET OF ; A TASK WILL OVERWRITE THE RIGHT BRACKET OF A ; TASK ADJACENT ON THE LEFT. THIS IMPLIES THAT ; ALL TASKS WILL HAVE SOME SORT OF REPRESENTATION ; IN THE DISPLAY AS LONG AS TWO ADJACENT TASKS DO ; NOT START AT THE SAME ROUNDED ADDRESS AND BOTH ; ARE NOT VERY SMALL. THE DISPLAYED SIZE OF THE ; A TASK IS ONE QUANTUM SMALLER THAN IT REALLY IS TO ; AVOID THE CLASH OF LEFT AND RIGHT BRACKETS ; OF ADJACENT TASKS (THE LEFT BRACKET OF ; THE TASK ON THE RIGHT WOULD NORMALLY NOT BE ; WRITTEN). ;- MOV -(R5),R4 ;GET SIZE OF PARTITION .IF NDF M$$MGE CLC ; ROR R4 ;CONVERT TO 32. .REPT 5 ASR R4 ;WORD UNITS .ENDR .ENDC ADD (SP),R4 ;FIRST+LENGTH=ADDR OF PARTITION END BCS 4550$ ;IF CS OVERFLOW ; EB170 CNVR R4 ;CONVERT MEMORY TO SCREEN SPACES CMP R4,#129. ;PARTITION OFF OF SCREEN? BLO 46$ ;IF LO NO 4550$: CMP -(R5),-(R5) ;DO NOT DISPLAY IT ; EB170 TST (SP)+ ;FINISH CLEANING UP BR 40$ ; 46$: CMPB #' ,(R2) ;ANYONE ON OUR LEFT? BNE 47$ ;IF NE YES, SKIP IT MOVB (R1),(R2) ;PLACE LEFT OCCUPATION BRACKET 47$: ;REF LABEL MOV R0,(SP) ;MIDDLE COLUMN IF ;TASK HAS NO WIDTH SUB R0,R4 ;ENDING COLUMN # - FIRST ;COLUMN # = # OF ;COLUMNS TO FILL + 1 ;OR ZERO DEC R4 ; BLE 60$ ;SHOW TASK AS 1K LONG MOV R4,(SP) ;SAVE TASK WIDTH INC (SP) ;TASK NAME IS ON RIGHT ;SIDE OF MIDDLE IF ;TASK WIDTH IS EVEN ASR (SP) ;MIDDLE OF FILL ADD R0,(SP) ;MIDDLE COLUMN OF TASK CMP #63.,(SP) ;IS TASK NAME CRUNCHED UP ON ;PARTITIONS??? BNE 48$ ;IF NE NO DEC (SP) ;YES - MOVE IT ONE LEFT 48$: INC R2 ;POINT AT POSITION FOR ;RIGHT BRACKET OR FILL MOV #'-,R3 ;ASSUME NOT FIXED BIT #FXDFLG,TSKSAT ;IS IT FIXED BEQ 50$ ;IF EQ NO MOV #'=,R3 ;USE == IF FIXED 50$: DEC R4 ;ANY MORE BYTES TO FILL? BEQ 60$ ;IF LT NO MOVB R3,(R2)+ ;INSERT FILL BYTE BR 50$ ; 60$: INC R1 ;WORK WITH RIGHT MOVB (R1),(R2) ;OCCUPATION BRACKET MOV #TSKNAM,R0 ;TEMPORARY STORAGE .IF DF L$$DRV BIT #DRVFLG,TSKSAT ;IS THIS A LOADED DRIVER? BEQ 67$ ;IF EQ NO TST -(R5) ;SKIP EMPTY WORD OF NAME MOV -(R5),(R0)+ ;GET DEVICE NAME (ASCII) MOV #": ,(R0)+ ;FILL IN PROPER TERMINATORS MOV #" ,(R0)+ ; BR 70$ ;CONTINUE IN COMMON CODE .ENDC 67$: MOV -(R5),R1 ;FIRST HALF OF TASK NAME CALL $C5TA ;CONVERT TO ASCII MOV -(R5),R1 ;2ND HALF OF TASK NAME CALL $C5TA ;CONVERT TO ASCII 70$: MOV #DISIMG+1,R1 ;SET DISPLAY OFFSET MOV (SP)+,R2 ;COLUMN POSITION TO STORE TASK NAME MOV #TSKNAM,R3 ;DISPLAY TASKNAME CALL XFRVER ;VERTICALLY BR 40$ ;GO AGAIN .PAGE .SBTTL DISPLAY TASKS IN AND OUT OF MEMORY WITH MEMORY USAGE INOT: ;REFERENCE LABEL .IF DF INOUT ; ; DISPLAY THE NUMBER OF ACTIVE TASKS OUT OF MEMORY AND THEIR TOTAL ; SIZE, AND THE NUMBER OF TASKS IN MEMORY WITH THEIR TOTAL SIZE. ; ; ; INITIALIZE THE COUNTERS ; CLR INM ;MEMORY FOR IN TASKS CLR INN ;NUMBER OF TASKS IN CLR OUTM ;MEMORY FOR TASKS OUT CLR OUTN ;NUMBER OF TASKS OUT ; ; NOW SCAN TASK LIST AND LOOK FOR ACTIVE TASKS ; CALL $SWSTK,40$ ;SYSTEM STATE MOV #$TSKHD-T.TCBL,R3 ;FIRST POINTER 10$: MOV R3,R4 ;SET UP FOR NEXT TCB MOV T.TCBL(R4),R3 ;GET NEXT TCB ADDRESS CMP #$HEADR,R3 ;IS IT NULL TASK BEQ 30$ ;IF EQ YES BIT #TS.EXE,T.STAT(R3) ;IS TASK NOT ACTIVE BNE 10$ ;IF NE YES CMP R3,$LDRPT ;IS IT LOADR BEQ 10$ ;IF EQ YES, SKIP IT MOV T.PCB(R3),R4 ;GET PCB ADDRESS MOV P.SIZE(R4),-(SP) .IF NDF M$$MGE ; ; CONVERT TO 32. WORD UNITS FOR TO BE STANDARD WITH MAPPED SYSTEM ; CLC ROR (SP) .REPT 5 ASR (SP) .ENDR .ENDC ASR (SP) ;MAKE IT 64.WORD UNIT INC (SP) ;ROUND IT UP A LITTLE ASR (SP) ;NOW 128. WORD UNITS BIT #TS.OUT,T.STAT(R3) ;IS IT IN MEMORY BNE 20$ ;IF NE NO ; ; TASK IS IN MEMORY ; INC INN ;ONE MORE TASK IN MEMORY ADD (SP)+,INM ;MORE MEMORY IN 128. WORD UNITS BR 10$ ;GO BACK FOR MORE ; ; TASK IS NOT IN MEMORY ; 20$: INC OUTN ;MORE OUT OF MEMORY ADD (SP)+,OUTM ;MORE MEMORY BR 10$ ;GO BACK FOR MORE 30$: RETURN ;NO MORE LEFT TO DO -- FOUND NULL ;TASK 100$: MOV #COVER,R2 ;SET UP TO ZERO OUT THINGS 101$: MOVB (R2)+,(R1)+ ;MOVE BLANK TSTB (R2) ;IS THE NEXT CHARACTER ZERO ;I.E. IS THIS END OF STRING? BNE 101$ RETURN ; ; HERE WE ARE OUT OF SYSTEM STATE. NOW WE WILL WIPE OUT ; THE NUMBERS CURRENTLY THERE. ; 40$: MOV #INNL,R1 ;WIPE OUT IN NUMBER OF TASKS CALL 100$ MOV #INML,R1 ;WIPE MEMORY IN TASKS CALL 100$ MOV #OUTNL,R1 ;WIPE NUMBER OF OUT TASKS CALL 100$ MOV #OUTML,R1 ;WIPE MEMORY OUT TASKS CALL 100$ ; ; HERE WE DISPLAY THE NUMBERS FOR THE TASKS ; MOV #INNL,R0 ;THE ADDRESS FOR THE CONVERSION MOV INN,R1 ;THE NUMBER CLR R2 CALL $CBDMG ;CONVERT THE NUMBER TO DECIMAL MOV #INML,R0 ;THE ADDRESS FOR MEMORY AMOUNT MOV INM,R1 ;THE AMOUNT OF MEMORY IN 128. WORD ;UNITS ASR R1 ;256 WORD UNITS ASR R1 ;512 WORD UNITS INC R1 ;SORT OF ROUND ASR R1 ;1024 WORD UNITS CLR R2 ;NO LEADING ZEROS CALL $CBDMG ;CONVERT THE NUMBER MOVB #'K,(R0) ;LABEL THE NUMBER MOV #OUTNL,R0 ;NUMBER OF TASKS OUT MOV OUTN,R1 ;NUMBER CLR R2 ;NO ZEROS CALL $CBDMG MOV #OUTML,R0 MOV OUTM,R1 ;MEMORY FOR OUT TASKS ASR R1 ;256 WORD UNITS ASR R1 ;512 WORD UNITS INC R1 ;SORT OF ROUNTD ASR R1 ;1024 WORD UNITS CLR R2 ;NO ZEROS CALL $CBDMG MOVB #'K,(R0) ;LABEL IT WITH "K" .ENDC .PAGE .SBTTL MISCELLANEOUS DISPLAY SUBROUTINES ; ; **-DSPLY-DISPLAY NEXT IMAGE ; DSPLY: MOV #1,R4 ;INITIAL INDEX IN ;PROTOTYPE IMAGE MOV #-2,LASTX ;INITIALIZE LAST X COORD MOV #-2,LASTY ;SAME FOR Y 10$: CMP R4,#64.*14. ;FINISHED WITH SCAN? BHI 40$ ;IF HI YES CMPB CURIMG(R4),DISIMG(R4) ; ;PROTOTYPES IDENTICAL? BNE 20$ ;IF NE NO INC R4 ;INCREMENT INDEX BR 10$ ;GO AGAIN 20$: CALL COORD ;CALCULATE COORDS OF ;OF DIFFERENCE ADD #31.+3.,R0 ;ADD COORDINATE OFFSET CMP #31.+10.,R0 ;AT SCREEN SPLIT? BHI 30$ ;IF HI NO ADD #4.,R0 ;ADJUST DOWN FOUR LINES 30$: INC LASTX ;WE ARE ONE TO THE LEFT NOW ADD #32.,R1 ;CALC X COORD CMP R0,LASTY ;MOVED UP OR DOWN? BNE 35$ ;IF NE YES CMP R1,LASTX ;MOVED ONE TO THE RIGHT BEQ 37$ ;IF EQ YES - SKIP POSITIONING 35$: ;REFERENCE LABEL .IF DF VT52 MOV #ESC,R2 CALL OUTCHR .ENDC MOV #CD,R2 ;SEND CURSOR CONTROL CALL OUTCHR MOV R0,R2 ;SEND Y COORD .IF DF VT52 CMP R2,LASTY ;ANY CHANGE IN Y COORD BNE 36$ ;IF NE YES ; ; HERE WE WILL SEND THE VT52 A Y COORD THAT IS TOO BIG ; SO AS TO AVOID FLICKER AS MUCH AS POSSIBLE ; .IFNDF V$IDEO ; JGD08 MOV #70,R2 ;A TOO BIG COORD .ENDC ; JGD08 36$: ;REFERENCE LABEL .ENDC .IFNDF V$IDEO ; JGD08 CALL OUTSPC ;WITH FILL .IFF ; JGD08 CALL OUTCHR ;SEND Y ; JGD08 .ENDC ; JGD08 MOV R1,R2 ;SEND X CALL OUTCHR 37$: MOV R1,LASTX ;SAVE CURRENT X MOV R0,LASTY ;ABOVE FOR Y CALL OUTCON ;OUTPUT CHANGED CHARACTER BR 10$ ;GO BACK FOR MORE 40$: ;REFERENCE LABEL .IF DF VT52 MOV #ESC,R2 CALL OUTCHR .ENDC .IFNDF V$IDEO ; JGD08 MOV #HO,R2 ;SEND CURSOR CONTROL CALL OUTSPC ; ; JGD08 .IFF ; JGD08 MOV #CD,R2 ; SEND 'Y' ; JGD08 CALL OUTCHR ; SEND IT ; JGD08 MOV #40,R2 ; SET TO ROW 0 ; JGD08 CALL OUTCHR ; SEND Y=0 ; JGD08 MOV #40,R2 ; SET TO COL 0 ; JGD08 CALL OUTCHR ; SEND X=0 ; JGD08 .ENDC ; JGD08 BR OUTBUF ;FLUSH DISPLAY BUFFER ; ; **-COORD-CALCULATE DISPLAY COORDINATE 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 COORD VALUES ; ; **-INIDIS-INITIALIZE DISIMG DISPLAY PROTOTYPE ; TO BLANKS AND THE MEMORY FENCE ; ; INPUTS: ; ; NONE. ; INIDIS: MOV #DISIMG+1,R0 ;INITIALIZE DISIMG MOV #64.*14.,R1 ;SIZE OF BUFFER 20$: MOVB #' ,(R0)+ ;BLANK A BYTE DEC R1 ;MORE LEFT? BGT 20$ ;IF GT YES ; ; PUT A LINE ABOVE THE SIZE OF THE SYSTEM ; MOV $SYSIZ,R2 ;SIZE IN 32.W CHUNKS CNVR R2 ;CONVERT MEMORY SIZE ;THAN MACHINE SIZE CMP R2,#128. ;OFF THE SCREEN BLO 25$ ;IF LO NO RETURN ;YES 25$: MOVB #':,DISIMG+1+<64.*6>(R2) ;PUT PART OF ;FENCE WHERE TASK FILL ;CHARS NORMALLY GO MOV #DISIMG+1,R1 ;WHICH BUFFER WE ARE IN MOV #FENCE,R3 ;POINT AT REST OF LINE BR XFRVER ;WRITE IT VERTICALLY ; ; **-OUTBUF-OUTPUT DISPLAY BUFFER ; ; INPUTS: ; ; BUFCTR=NUMBER OF BYTES TO OUTPUT. ; OUTBUF: MOV #DSBUF,BUFPTR ;RESET BUFFER POINTER CMP #1,VT5FLG ;IS OUTPUT VT05 DEVICE BNE 5$ ;IF NE NO DSCP$S ; DISABLE CHECKPOINTING ; JGD07 DIR$ #DSQIO ;OUTPUT DISPLAY LINE BCS 5$ ;IF CS DIRECTIVE ERROR .IF DF B$$SCR CALL UPDATB ;UPDATE BUFFER .ENDC ; DIR$ #DSWT ;WAIT FOR COMPLETE ; JGD07 .IF DF B$$SCR BR 10$ ;SKIP ANOTHER UPDATE 5$: CALL UPDATB ;UPDATE BUFFER .IFF 5$: ;REFERENCE LABEL .ENDC 10$: ENCP$S ; ENABLE CHECKPOINTING ; JGD07 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 BUFFER INC BUFPTR ;BUMP BUFFER POINTER INC BUFCTR ;AND 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 CHAR TO OUTPUT MOVB R2,CURIMG(R4) ;STORE BYTE IN CURIMG CALL OUTCHR ;OUTPUT CHARACTER INC R4 ;BUMP PROTOTYPE INDEX RETURN ; ; ; **-OUTLIN-OUTPUT DOUBLE ASCIZ STRING TO DISPLAY BUFFER ; ; INPUTS: ; ; R3=ADDRESS OF DOUBLE ASCIZ STRING TO BE OUTPUT. ; OUTLIN: MOVB (R3)+,R2 ;NEXT CHAR TO OUTPUT BEQ 10$ ;END OF FIRST STRING CALL OUTCHR ;OUTPUT CHARACTER BR OUTLIN ;GO AGAIN 10$: CALL OUTFIL ;OUTPUT FILL CHARS ; ; **-OUTLN2-OUTPUT ASCIZ STRING TO DISPLAY BUFFER ; ; INPUTS: ; ; R3=ADDRESS OF ASCIZ STRING TO BE OUTPUT. ; OUTLN2: MOVB (R3)+,R2 ;NEXT CHAR 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 BEQ 12$ ;IF NO FILL, THEN NO FILL CLR R2 ;SET FILL CHAR TO NULL 10$: CALL OUTCHR ;OUTPUT A FILL CHAR DEC (SP) ;ANY MORE TO OUTPUT? BGT 10$ ;IF GT YES 12$: TST (SP)+ ;REMOVE COUNT FROM STACK RETURN ; ; ; **-XFRVER-TRANSFER VERTICAL MESSAGE TO DISPLAY BUFFER ; ; INPUTS: ; ; R1=DISPLAY OFFSET ; R2=ADDRESS OF FIRST CHARACTER IN DISPLAY BUFFER. ; R3=ADDR 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 ;DIDDLE WITH COORD 10$: ADD R1,R2 ;ADD DISPLAY OFFSET 20$: MOVB (R3)+,(R2) ;CHAR TO DISPLAY BUFFER ADD #64.,R2 ;TO NEXT DISPLAY LINE TSTB (R3) ;ANY MORE CHARS? BNE 20$ ;IF NE YES RETURN ; .PAGE .SBTTL NONCURSOR ADDRESSABLE ROUTINES ; ; **-UPDATB-UPDATE BUFFER WITH VT05 OUTPUT STRING ; ; INPUTS: ; ; BUFPTR IS THE START OF THE BUFFER. ; BUFCTR IS THE NUMBER OF CHARACTERS IN THE BUFFER. ; ; OUTPUTS: ; ; THE BUFFER POINTED TO BY SCRP HAS BEEN UPDATED. ; ; SAVES ALL REGISTERS ; ; .IF DF B$$SCR .ENABL LSB UPDATB: CALL $SAVAL ;SAVE ALL THE REGISTERS ;AND COROUTINE MOV BUFPTR,R1 ;SETUP BUFFER POINTERS MOV BUFCTR,R2 ;NUMBER OF CHARACTERS BNE NXTCHR ;YES, THERE ARE SOME 5$: RETURN ;NO CHARACTERS NXTCHR: TST R2 ;ANY CHARS LEFT BEQ 5$ ;IF EQ NO MOVB (R1)+,R3 ;GET NEXT CHARACTER DEC R2 ;ONE LESS CHARACTER BIC #177600,R3 ;MASK OFF HIGH BITS BEQ NXTCHR ;IF EQ NULL IGNORE FILLS JMP @NXT ;GO PROCESSING ROUTINE ; ; HERE WE HAVE A Y COORDINATE FROM A CURSOR ; CONTROL SEQUENCE. ; YCORD: SUB #40,R3 ;SUB OFF BIAS BLT 30$ ;IF LT TOO SMALL CMP #HIGHT,R3 ;IS IT TOO BIG BLE 30$ ;IF LE TOO BIG MOV SCRP,POSIT ;INITIALIZE POSIT MOV R3,YC ;SET Y COORD 20$: DEC R3 ;BUMP Y COORD DOWN BLT 30$ ;IF LT NO MORE TO GO ADD #WIDTH,POSIT ;DO MULTIPLICATION BY ;REPEATED ADDITION BR 20$ ;ANY MORE 30$: MOV #XCORD,NXT ;WE EXPECT X COORDINATE JMP NXTCHR ;GO FETCH NEXT CHARACTER ; ; X COORDINATE INTERPRETATION ROUTINE. ; XCORD: SUB #40,R3 ;SUB OFF BIAS,TOO SMALL? BLT 40$ ;IF LT YES CMP #WIDTH,R3 ;TOO BIG? BLE 40$ ;IF LE YES ADD R3,POSIT ;FIX DISPLACEMENT MOV R3,XC ;SET X COORDINATE 40$: MOV #NORM,NXT ;NORMAL CHARACTER NEXT JMP NXTCHR ;FETCH NEXT CHARACTER .DSABL LSB ; ; NORMAL CHARACTER PROCESSING SECTION. ; ; THERE IS A TABLE WITH TWO WORD ENTRIES WHICH ; IS SCANNED FOR EVERY OSTENSIBLY NORMAL CHARACTER, ; AND IF THE CHARACTER IS NOT IN THE TABLE IT IS ; CONSIDERED A NORMAL CHARACTER. IF IT IS IN THE TABLE, ; A JUMP IS MAKE TO THE PROCESSING ROUTINE ; WHICH IS IN THE SECOND WORD OF THE ENTRIES. ; .ENABL LSB NORM: MOV #CHRTAB,R4 ;SET UP SCAN MOV #CHRL,R5 ;SET UP LENGTH OF TABLE 10$: CMP (R4)+,R3 ;IS IT A MATCH BNE 14$ ;IF NE NO JMP @(R4) ;YES,DISPATCH TO CORRECT ;SECTION 14$: TST (R4)+ ;SKIP THE JUMP DEC R5 ;ONE LESS TABLE ENTRY BNE 10$ ;IF NE NOT THROUGH YET MOVB R3,@POSIT ;INSERT CHAR IN BUFFER JMP 70$ ;EXIT THRU CURSOR RIGHT ; ; TABLE FOR SPECIAL CHARACTER SCAN ; .MACRO TABENT CHAR,ADDR .WORD CHAR .WORD ADDR .ENDM CHRTAB: TABENT CD,35$ TABENT CUP,40$ TABENT CDN,50$ TABENT LF,50$ TABENT CLT,60$ TABENT CRT,70$ TABENT CR,110$ TABENT HO,120$ TABENT ES,130$ TABENT EL,140$ TABENT ESC,100$ ;IGNORE THE ESC IN VT05 MODE CHRL=<.-CHRTAB>/4 ;NUMBER OF TABLE ENTRIES ; ; CNTL N (CD) CHARACTER. SET NEXT CHARACTER AS YCOORD ; 35$: MOV #YCORD,NXT ;NEXT CHARACTER IS YCORD BR 100$ ;EXIT ; ; CURSOR UP ; 40$: TST YC ;ARE WE AT TOP ALREADY BLE 100$ ;IF LE YES, EXIT DEC YC ;1 LINE HIGHER ON SCREEN SUB #WIDTH,POSIT ;HERE TOO BR 100$ ;EXIT ; ; CURSOR DOWN ; 50$: CMP #HIGHT-1,YC ;ARE WE AT BOTTOM BLE 100$ ;IF LE YES INC YC ;ADD ONE TO Y COORD ADD #WIDTH,POSIT ;ONE MORE LINE DOWN BR 100$ ;EXIT ; ; CURSOR LEFT (BACKSPACE) ; 60$: TST XC ;AT LEFT MARGIN ALREADY BLE 100$ ;IF LE YES DEC XC ;ONE CHAR TO LEFT DEC POSIT ;HERE TOO BR 100$ ;EXIT ; ; CURSOR RIGHT, ALSO AFTER EVERY CHARACTER ; 70$: CMP #WIDTH-1,XC ;ALREADY AT RIGHT? BLE 100$ ;IF LE YES INC XC ;ADD 1 TO X COORD INC POSIT ;ADD 1 TO PLACE IN SCREEN 100$: JMP NXTCHR ;EXIT ; ; CARRIAGE RETURN ; 110$: SUB XC,POSIT ;MOVE TO START OF LINE CLR XC ;CLEAR X COORD BR 100$ ;EXIT ; ; HOME ; 120$: MOV SCRP,POSIT ;START AT TOP OF SCREEN CLR XC ;XC = 0 CLR YC ;YC = 0 BR 100$ ;EXIT ; ; ERASE SCREEN ; 130$: MOV POSIT,R3 ;SET UP START OF SCREEN MOV SCRP,R4 ; ADD #,R4 ;R4=LWA+1 OF SCREEN 135$: CMP R3,R4 ;ARE WE AT END OF SCREEN BEQ 100$ ;IF EQ YES MOVB #BL,(R3)+ ;INSERT CHARACTER BR 135$ ;GO BACK FOR MORE ; ; ERASE TO END OF LINE ; 140$: MOV XC,R3 ;SETUP NUMBER OF CHARS ;IN LINE NEG R3 ; ADD #WIDTH,R3 ;R3=NUMBER OF CHARACTER ;LEFT IN LINE MOV POSIT,R4 ;GET CURRENT POSITION 145$: MOVB #BL,(R4)+ ;MOVE BLANK INTO BUFFER DEC R3 ;ONE LESS TO GO BGT 145$ ;IF GT MORE TO GO BR 100$ ;EXIT .DSABL LSB ;+ ; BUFFER AREA FOR B$$SCR BUFFERING. ; ; BUFFER AREA FOR RETAINING AN ENTIRE COPY OF THE SCREEN ; IN A FORM THAT IS ALWAYS CURRENT. THERE IS A ROUTINE ; THAT SITS BETWEEN THE PROGRAM AND THE OUTPUT DEVICE. ; THIS ROUTINE INTERPRETS ALL THE VT05 CONTROL CODES ; AND KEEPS UPDATING THE BUFFER SO THAT IT MIRRORS THE ; SCREEN, ENTIRELY INDEPENDENTLY FROM ANY OTHER DATA ; STRUCTURE IN THE PROGRAM. THIS BUFFER IS THE ONE USED ; TO PRODUCE PRINTED OUTPUT IF THIS IS DESIRED. ; THE ACTUAL BUFFERING IS CONTROLLED BY THE ; SYMBOL B$$SCR, AND THE PRINT OPTION IS CONTROLLED ; BY THE SYMBOL P$$RNT. ; ; THE BUFFER IS KEPT IN ROW ORDER, SO THAT THERE ARE ; "HIGHT" LINES EACH OF "WIDTH" CHARACTERS PLACED END ; TO END IN MEMORY. ;- .EVEN SCRP: .WORD SCREEN ;POINTER TO CURRENT ;SCREEN BUFFER POSIT: .WORD SCREEN ;POSITION IN SCREEN XC: .WORD 0 ;X CHARACTER POSITION YC: .WORD 0 ;Y CHARACTER POSITION NXT: .WORD NORM ;NEXT CHARACTER ;RECOGNIZER ROUTINE NULLIN: .ASCIZ / / ;NULL LINE SCREEN: .BLKB WIDTH*HIGHT ;SCREEN BUFFER .EVEN ; ; PRINT OPTION P$$RNT ; ; ; **-PNTBUF-PRINT BUFFER ON FILE ; ; INPUTS: ; SCRP POINTS TO BUFFER TO BE PRINTED. PNTBUF ; ASSUMES BUFFER HAS OF "HIGHT" LINES ; EACH "WIDTH" CHARS LONG, STORED IN ROW ; ORDER. ; ; OUTPUTS: ; BUFFER IS PRINTED ON LS:RMDLOG.LST ; ; ALL REGISTERS ARE SAVED ; .IF DF P$$RNT FSRSZ$ 1 FDBPNT: FDBDF$ ;OUTPUT FDB FDAT$A R.VAR,FD.CR FDOP$A PNTLUN,,PNTNAM FDBF$A PNTFLG,132. PNTNAM: NMBLK$ RMDLOG,LST,,LS,0 PNTBUF: CALL $SAVAL MOV SCRP,R1 ;SET UP FIRST LINE FWA MOV #WIDTH,R2 ;LENGTH EACH LINE MOV #HIGHT,R3 ;NUMBER OF LINES PUT$S #FDBPNT,#NULLIN,#1 ;PRINT NULL LINE BCS 20$ 10$: MOV R2,R4 ;SET UP WIDTH ADD R1,R4 ;LAST CHAR + 1 IN LINE 12$: CMPB #' ,-(R4) ;IS IT A BLANK BNE 14$ ;IF NE NO CMP R1,R4 ;AT START OF LINE YET BNE 12$ ;IF NE NO, ANOTHER CHAR 14$: INC R4 ;AT LEAST ONE CHAR SUB R1,R4 ;CALC LENGTH OF LINE PUT$S #FDBPNT,R1,R4 ;PRINT LINE BCS 20$ ADD R2,R1 ;BUMP TO NEXT LINE DEC R3 ;ANY MOVE LEFT BGT 10$ ;IF GT YES 20$: RETURN .ENDC .ENDC ;+ ; JGD02 ; INPAST - CATCH AN UNCSOLICITED INPUT AST ; JGD02 ; IF ONE OCCURS, RESCHEDULE RMD TO RUN IN 2 SEC AND ABORT THE ; JGD02 ; CURRENT TASK, ; JGD02 ; ; JGD02 INPAST: ; REF LABLE ; JGD02 BIC #177400,(SP) ; CLEAR OFF HIGH BYTE ; JGD02 CMP (SP),#'X ; IS IT AN 'X' ( FOR EXIT)? ; JGD02 BEQ 20$ ; IF EQ, YES ; JGD02 CMP (SP),#'R ; IS IT AN 'R' (FOR REPEAT)? ; JGD02 BNE 40$ ; IF NE, NO, RANDOM INPUT, IGNORE ; JGD02 DIR$ #GETTSK ; GET OUR TASKNAME ; JGD02 MOV #RUNCMD+4,R0 ; POINT TO WHERE TO PUT TASKNAME ; JGD03 MOV GTSKBF,R1 ; POINT TO FIRST HALF OF RAD50 TASKNAME; JGD03 CALL $C5TA ; CONVERT TO 3 BYTES ASCII ; JGD03 MOV GTSKBF+2,R1 ; POINT TO 2ND HALF OF RAD50 TASKNAME ; JGD03 CALL $C5TA ; CONVERT TO ASCII ; JGD03 DIR$ #KILL ; KILL ANY PENDING I/O ; JGD04 .IFDF VT100 ; ; JGD03 DIR$ #RESET ; RESET TO VT100 MODE ; JGD03 .ENDC ; ; JGD03 DIR$ #SPWN ; SEND OFF COMMAND AND EXIT ; JGD03 TST (SP)+ ; POP SP FOR GOOD MEASURE ; JGD03 EXIT$S ; EXIT PROMPTLY ; JGD03 20$: TST (SP)+ ; POP SP FOR GOOD MEASURE ; JGD02 DIR$ #KILL ; KILL ANY LEFT OVER I/O ; JGD04 .IFDF VT100 ; ; JGD03 DIR$ #RESET ; RESET TO VT100 MODE ; JGD03 .ENDC ; ; JGD03 EXIT$S ; ALL DONE SO EXIT ; JGD02 40$: TST (SP)+ ; POP SP ; JGD02 ASTX$S ; AND EXIT AST SERVICE ROUTINE ; JGD02 .IFDF VT100 ; ; JGD09 ABRT: DIR$ #KILL ; KILL ANY LEFT OVER I/O ; JGD09 DIR$ #RESET ; RETURN TO VT100 MODE ; JGD09 EXIT$S ; EXIT POLITELY ; JGD09 .ENDC ; .ENDC VT100 ; JGD09 .MCALL SPWN$ ; JGD03 SPWN: SPWN$ MCR...,,,,,,,,RUNCMD,RUNLEN ; JGD03 KILL: QIOW$ IO.KILL,1,1 ; JGD04 .IFDF VT100 ; ; JGD03 RESET: QIOW$ IO.WAL,1,1,,,, ; JGD03 RMSG: .BYTE ESC,HO,0,0,0,0 ; GO TO HOME ; JGD03 .BYTE ESC,ES,0,0,0,0 ; ERASE SCREEN ; JGD03 .ASCII <33>/