; RT-11 V02B MONITOR ; ; CHERNOFF-FRIEDMAN-MAURER-VELTEN ; ; DEC-11-ORMNA-D ; ; COPYRIGHT (C) 1975 ; ; DIGITAL EQUIPMENT CORPORATION ; MAYNARD, MASSACHUSETTS 01754 ; ; THIS SOFTWARE IS FURNISHED UNDER A LICENSE FOR USE ONLY ; ON A SINGLE COMPUTER SYSTEM AND MAY BE COPIED ONLY WITH ; THE INCLUSION OF THE ABOVE COPYRIGHT NOTICE. THIS ; SOFTWARE, OR ANY OTHER COPIES THEREOF, MAY NOT BE PROVIDED ; OR OTHERWISE MADE AVAILABLE TO ANY OTHER PERSON EXCEPT ; FOR USE ON SUCH SYSTEM AND TO ONE WHO AGREES TO THESE ; LICENSE TERMS. TITLE TO AND OWNERSHIP OF THE SOFTWARE ; SHALL AT ALL TIMES REMAIN IN DIGITAL. ; ; THE INFORMATION IN THIS DOCUMENT IS SUBJECT TO ; CHANGE WITHOUT NOTICE AND SHOULD NOT BE CONSTRUED ; AS A COMMITMENT BY DIGITAL EQUIPMENT CORPORATION. ; DIGITAL ASSUMES NO RESPONSIBILITY FOR ANY ERRORS THAT ; MAY APPEAR IN THIS DOCUMENT ; ; DIGITAL ASSUMES NO RESPONSIBILITY FOR THE USE ; OR RELIABILITY OF ITS SOFTWARE ON EQUIPMENT ; WHICH IS NOT SUPPLIED BY DIGITAL. .IF DF $RXPRO ;### ; MACROS FOR ASSEMBLING UNDER RT-11 ; THESE ARE 'EQUIVALENT' OF RSX MACROS .MACRO ENAR$S ;### JSR PC,@#ENABL ;### .ENDM ;### .MACRO DSAR$S ;### JSR PC,@#DSABL ;### TTIEX6=DPBBAS+540 ;### XAST=DPBBAS+630 ;### .ENDM ;### .MACRO ASTX$S ERR ;### MOV (PC)+,-(SP) ;### .BYTE 115.,1 ;### EMT 377 ;### .IF NB ERR ;### BCC .+6 ;### JSR PC,ERR ;### .IFF ;### BCC .+4 ;### HALT ;### .ENDC ;ERR ;### .ENDM ;### .MACRO DIR$ DPB,ERR ;### MOV @#$DSW,-(SP) ;(SAVE DSW AROUND DIRECTIVES) ;### MOV DPB,-(SP) ;### EMT 377 ;### .IF NB ERR ;### BCC .+6 ;### JSR PC,ERR ;### .IFF ;### BCC .+4 ;### HALT ;### .ENDC ;ERR ;### MOV (SP)+,@#$DSW ;### .ENDM ;### .SBTTL DEFINITIONS FOR RSX QIO ;### ; DEFINITIONS FOR RSX QIO $DSW= 46 ;### Q.IOAE=12 ;### Q.IOEF=6 ;### Q.IOFN=2 ;### Q.IOLU=4 ;### Q.IOPL=14 ;### Q.IOPR=7 ;### Q.IOSB=10 ;### H.BUFA=0 ;### H.BUFS=2 ;### H.LBN=6 ;### IO.RLB=1000 ;### IO.WLB=400 ;### .SBTTL ADDRESS LINKS TO RSX TASK ;### ; ; NOTE:**** 'DPBBAS' IS NOW DEFINED IN CONDITIONAL ASSEMBLY FILE ; **** 'RSX.MAC' OR 'RSX24K.MAC'. ; **** THIS FACILITATES CREATION OF DIFERENT SIZE SYSTEMS.**** ; ;;;;DPBBAS=102204 ;### KBBUF=DPBBAS+422 ;### RSTTDN=DPBBAS+600 ;### NULOUT=DPBBAS+700 ;### R4OUT=DPBBAS+706 ;### TICHK=DPBBAS+1400 ;### TTEXIT=DPBBAS+1542 ;### TSTANP=DPBBAS+1500 ;### ENABL=DPBBAS+500 ;### DSABL=DPBBAS+440 ;### .ENDC ;$RXPRO ;### ; .IIF DF NLKMON, .NLIST ;KMON UPDATE LEVEL 016 .IIF NDF BF, BF=0 ;BF = 0 => SINGLE USER, =1 => F/B UPDATE = 05. .RADIX 10. .IRP ...,<\UPDATE> .IF NE BF .TITLE RT-11FB V02B-0'... .IFF .TITLE RT-11SJ V02B-0'... .ENDC .ENDR .RADIX 8. .IF DF DF$RXPRO ;### .SBTTL RSX MACROS ;### ; MACROS FOR ASSEMBLING UNDER RT-11 ; THESE ARE 'EQUIVALENT' OF RSX MACROS .MACRO ENAR$S ERR ;### MOV $DSW,-(SP) ;SAVE DSW AROUND DIRECTIVES ;### MOV (PC)+,-(SP) ;### .BYTE 101.,1 ;### EMT 377 ;### .IF NB ERR ;### BCC .+6 ;### JSR PC,ERR ;### .IFF ;### BCC .+4 ;### HALT ;### .ENDC ;ERR ;### MOV (SP)+,$DSW ;### .ENDM ;### .MACRO DSAR$S ERR ;### MOV $DSW,-(SP) ;SAVE DSW AROUND DIRECTIVES ;### MOV (PC)+,-(SP) ;### .BYTE 99.,1 ;### EMT 377 ;### .IF NB ERR ;### BCC .+6 ;### JSR PC,ERR ;### .IFF ;### BCC .+4 ;### HALT ;### .ENDC ;ERR ;### MOV (SP)+,$DSW ;### .ENDM ;### .MACRO ASTX$S ERR ;### MOV $DSW,-(SP) ;SAVE DSW AROUND DIRECTIVES ;### MOV (PC)+,-(SP) ;### .BYTE 115.,1 ;### EMT 377 ;### .IF NB ERR ;### BCC .+6 ;### JSR PC,ERR ;### .IFF ;### BCC .+4 ;### HALT ;### .ENDC ;ERR ;### MOV (SP)+,$DSW ;### .ENDM ;### .MACRO DIR$ DPB,ERR ;### MOV $DSW,-(SP) ;SAVE DSW AROUND DIRECTIVES ;### MOV DPB,-(SP) ;### EMT 377 ;### .IF NB ERR ;### BCC .+6 ;### JSR PC,ERR ;### .IFF ;### BCC .+4 ;### HALT ;### .ENDC ;ERR ;### MOV (SP)+,$DSW ;### .ENDM ;### .MACRO RESET ;### NOP ;### .ENDM ;### .ENDC ;$RXPRO ;### .SBTTL MACROS .MCALL ..V1.. ..V1.. .MCALL .CLOSE, .DSTATUS, .ENTER, .EXIT, .FETCH, .HRESET .MCALL .LOCK, .LOOKUP,.PRINT, .RCTRLO,.READW, .RELEASE .MCALL .SETTOP,.SRESET,.TTYIN, .TTYOUT,.UNLOCK,.WAIT, .WRITW ; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; THIS MACRO GENERATES A CALL TO THE KMON ERROR ROUTINE .MACRO KMEROR TEXT .IF GE OVLYN OJSR R0,MSGKM .IFF JSR R0,MSGKM .ENDC .ASCIZ "?TEXT?" .EVEN .ENDM KMEROR ; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; THIS MACRO COMPUTES AN ADDRESS IN A POSITION-INDEPENDENT MANNER ; IT CAN PUT THE ADDRESS IN A REGISTER OR ON THE STACK, ; AND CAN SAVE THE REGISTER FIRST ; ADR IS THE ADDRESS TO COMPUTE ; REG IS THE REGISTER (SP IF IT IS TO BE PUSHED) ; PUSH IS BLANK, 'ADD', OR 'PUSH' .MACRO ADDR ADR,REG,PUSH .IF IDN REG,SP MOV PC,-(SP) ADD #ADR-.,(SP) .IFF .IF B PUSH MOV PC,REG .IFF .IF IDN PUSH, ADD PC,REG .IFF JSR REG,(PC) .ENDC .ENDC ADD #ADR-.,REG .ENDC .ENDM ADDR ; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; THIS MACRO GENERATES A BLOCK OF ZERO WORDS IN CORE .MACRO BSS COUNT .NLIST .REPT COUNT .WORD 0 .ENDR .LIST .ENDM BSS ; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; THIS MACRO GENERATES A FATAL MONITOR ERROR CALL .IF EQ BF .MACRO MONERR CODE,LEVEL,FTL EMT 376 .BYTE LEVEL .IF IDN , .BYTE ^C .IFF .BYTE CODE .ENDC .ENDM MONERR .IFF .MACRO MONERR CODE,LEVEL,FTL EMT 376 .BYTE LEVEL .IF IDN , .BYTE ^C .IFF .BYTE CODE'.E .ENDC .ENDM MONERR .ENDC ; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; MACRO TO GENERATE AN ERROR FROM THE CSI .MACRO CSIERR TEXT,CODE .NLIST JSR R0,MSG .BYTE CODE .ASCIZ "?TEXT?" .EVEN .LIST .ENDM CSIERR ; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; MACRO TO CHANGE PRIORITY LEVEL .MACRO SPL PRIO .IF NE PRIO MOVB #PRIO*40,@#PS .IFF CLRB @#PS .ENDC .ENDM SPL ; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; MACRO TO LINK TO A KMON OVERLAY ; NOTE - THIS MACRO SHOULD ONLY BE USED FROM A KMON COMMAND .MACRO OVLINK CMD .IF GE OVLYN OJSR R2,OVLINK .IFF JSR R2,OVLINK .ENDC .BYTE N.'CMD,O.'CMD/2 .ENDM OVLINK ; ; MACROS DEFINED ELSEWHERE ARE ONLY USED IN THE VICINITY OF ; THEIR DEFINITION .SBTTL GLOBAL DEFINITIONS ; GLOBAL REFERENCES FOR SYSTEM DEVICE HANDLERS .GLOBL SYINDO, $PNAMO, SYENTO .GLOBL DTSYS,RFSYS,RKSYS,DPSYS,DXSYS ;DEFINED IN THE SYSTEM HANDLERS .GLOBL DSSYS ;THEY MAKE THE APPROPRIATE HANDLER ;RESIDENT IN ADDITION TO SY AND DK .GLOBL BLKEY, CHKEY, RTORG, $CSW .GLOBL TTIBUF, TTOBUF, TTYIN, TTYOUT ; THESE GLOBALS ARE FOR THE BOOTSTRAP MODULE .GLOBL $DVREC, $ENTRY, $PNAME ;SYSTEM TABLES .GLOBL $MONBL, $SWPBL, SYSLOW, KMLOC, QCOMP .GLOBL $USRLC, $SLOT, $KMLOC ;LOCS. TO MOVE .GLOBL BSTRNG, CORPTR, DKASSG, FILLER, HWDSP$, HWFPU$ .GLOBL KMON, KMONSZ, KW11L$, MAPOFF, RMONSZ, RT11SZ, RTLEN .GLOBL RTSIZE, USRSZ, SWAPSZ, SYASSG, SYNCH, USRLOC, $INTEN .GLOBL MAXSYH .IF NE BF ; GLOBALS STRICTLY FOR B/F: .GLOBL BCNTXT, BKGND1, BKGND2, BKGND3, BLIMIT, CNTXT, FPPINT .GLOBL FUDGE1, FUDGE2, MSGENT, RMONSP, SWIPTR, SWOPTR, TTIUSR .GLOBL TTOUSR, .$CRTN .IFF ; GLOBALS FOR BACKGROUND ONLY MONITOR .GLOBL I.CSW, FPPADD, FPPIGN, MONLOC, TRAPLC, TRAPER .GLOBL TTOCLO, TTILCT, AVAIL, MONCAL .ENDC .SBTTL SYSTEM PARAMETERS ; REGISTER DEFINITIONS: R0=%0 R1=%1 R2=%2 R3=%3 R4=%4 R5=%5 SP=%6 PC=%7 PS=177776 SR=177570 ; ASCII DEFINITIONS BELL = 7 BS = 10 TAB = 11 LF = 12 FF = 14 CR = 15 ESCAPE = 33 RUBOUT = 177 ; INTERRUPT PRIORITY DEFINITIONS: PR0 = 0 PR4 = 200 PR7 = 340 ; CONDITIONAL ASSEMBLY PARAMETERS .IIF NDF CLOCK, CLOCK=60. ; FOR 60 CYCLE .IF NDF $SLOT ;DEFAULT 14 DEVICES (DEFINE ONLY IN PASS 1) $SLOT = 14. .IIF DF BANDW, $SLOT = 18. .ENDC ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; THE WORD CONFIG (IN RMON) GIVES INFO ON THE OVERALL STATE ; AND CONFIGURATION OF THE SYSTEM. THE BITS CURRENTLY DEFINED ARE: ; ; BIT # MEANING ; ----- ------- ; 0 0 => THIS IS THE B ONLY MONITOR ; 1 => THIS IS F/B MONITOR ; 1 1 => TTY HAS HARDWARE TABS ; 2 1 => GT40 HARDWARE EXISTS ; 3 1 => BATCH IS RUNNING ; 4 1 => VT05 IS TERMINAL ; 5 1 => 50 CYCLE CLOCK ; 6 1 => FPU HARDWARE ; 7 0 => NO F JOB IS RUNNING ; 1 => A F JOB IS NOW RUNNING ; 8 1 => USER LINKED TO GT40 SCROLLER ; 9 1 => USR MAY NOT BE SET TO SWAP ; 10 1 => BATCH IS RUNNING ; 15 1 => KW11L CLOCK EXISTS FBMON$ = 1 HWDSP$ = 4 BATCH$ = 10 CLK50$ = 40 HWFPU$ = 100 FJOB$ = 200 GTLNK$ = 400 USR$ = 1000 KW11L$ = 100000 .IF EQ CLOCK-50 CLK50 = CLK50$ .IFF CLK50 = 0 .ENDC ; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; THESE ARE PARAMETERS USED IN THE USR ; FOR SPECIAL DEVICES; E.G. CASSETTE AND MAGTAPE LOOK.. = 3 ;LOOKUP DELE.. = 2 ;DELETE CLOS.. = 1 ;CLOSE ENTR.. = 4 ;ENTER ; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; THE MONITOR USES WORDS 40-56 IN LOW CORE TO HOLD PARAMETER ; INFORMATION ON THE RUNNING JOB ; THESE LOCATIONS CONTAIN THE FOLLOWING INFORMATION: ; ; ADDRESS BIT(S) MEANING ; ------- ------ ------------------------------------------ ; 40 START ADDRESS OF PROGRAM ; 42 INITIAL STACK POINTER ; 44 JOB STATUS WORD ; 15 1 => USR DOES NOT NEED TO SWAP ; 0 => PROGRAM OVERLAYS USR ; 14 1 => UPPER CASE CONVERSION DISABLED ; 13 1 => PROGRAM MAY BE RESTARTED ; 12 1 => SPECIAL TTY INPUT MODE ; SINGLE CHAR. INPUT, WITH ONLY ^C ; AND ^O BEING INTERPRETED ; 9 1 => JOB IS AN OVERLAY JOB ; 8 1 => JOB WAS CHAINED TO ; 7 1 => HALT ON HARD ERROR FROM DEVICE (SU ONLY) ; 6 1 => IN F/B, .TTYIN/OUT RETURNS CARRY INSTEAD ; OF WAITING IF NOTHING IS AVAILABLE ; 46 LOCATION OF FLOATING USR. ; 0 => USR IS AT STANDARD LOCATION ; 50 HIGHEST ADDRESS OF USER PROGRAM ; 52 0-7 ERROR CODE ON RETURN FROM EMT ; 54 POINTER TO RMON ; 56 0-7 CHARACTER AFTER WHICH TO INSERT FILL ; CHARACTERS (NULLS) WHEN DOING OUTPUT TO ; THE CONSOLE DEVICE. 0 => NO FILLS ; 8-15 NUMBER OF FILL CHARACTERS ; REQUIRED FILLS ARE: ; LA30 -- 9 FILLS AFTER CR ; VT05 @ 2400 BAUD -- 4 FILLS AFTER LF ; VT05 @ 1200 BAUD -- 2 FILLS AFTER LF ; VT05 @ 600 BAUD -- 1 FILL AFTER LF PARMS = 40 USERPC = 40 USERSP = 42 JSW = 44 USWAP$ = 100000 TTLC$ = 40000 RSTRT$ = 20000 TTSPC$ = 10000 OVLY$ = 1000 CHAIN$ = 400 ;CAUTION - CHAIN$ MUST BE 400!!!! HLTER = 200 TCBIT$ = 100 UFLOAT = 46 USERTOP = 50 ERRBYT = 52 SYSPTR = 54 TTFILL = 56 TTNFIL = 57 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; ; A DIRECTORY ENTRY FOR A FILE STRUCTURED DEVICE'S DIRECTORY ; IS ORGANIZED AS FOLLOWS: ; ; OFFSET MEANING ; ------ ------- ; 0 STATUS WORD ; 4000 = END OF DIRECTORY SEGMENT MARKER ; 2000 = PERMANENT FILE ; 1000 = EMPTY ENTRY ; 400 = TENTATIVE ENTRY ON CHANNEL ; 2-7 FILNAM.EXT IN RADIX 50 ; 10 LENGTH OF HOLE ALLOCATED ON DEVICE ; 12 DATA LENGTH (HIGHEST BLOCK USED) ; 12 IS ALSO USED IN ENTER TO HOLD ADDRESS WHICH ; FLAGS A TENTATIVE ENTRY, AND IDENTIFIES IT FOR CLOSE ; 14 CREATION DATE ; ; THESE WORDS MAY BE FOLLOWED BY EXTRA 'USER' WORDS ; ENDBLK = 4000 ;END OF BLOCK MARKER PERM = 2000 ;PERMANENT FILE EMPTY = 1000 ;EMPTY ENTRY TENT = 400 ;TENTATIVE FILE DOFSET = 4 ;DIRECTORY SEGMENT #1 STARTS AT BLOCK 6 E.NAME = 2 ;FILNAM.EXT STARTS AT WORD 2 E.LENG = 10 ;SIZE OF HOLE ALLOCATED E.USED = 12 ;HIGHEST BLOCK WRITTEN (NOW 0) E.CHAN = 12 ;WHILE TENTATIVE, HOLDS CHANNEL NUMBER E.JNUM = 13 ;FOR BF, HOLDS JOB NUM E.DATE = 14 ;CREATION DATE L.ENTR = 16 ;LENGTH OF DIR ENTRY ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; ; THE ONLY DEVICES BESIDES THE SYSTEM DEVICE WHICH ARE ASSUMED ; TO BE PRESENT ARE THE TTY AND THE LINE-FREQUENCY CLOCK ; DEFINITIONS OF TTY STATUS WORDS: ; TKS = 177560 ;READER STATUS TKB = 177562 ;READER BUFFER TPS = 177564 ;PUNCH STATUS TPB = 177566 ;PUNCH BUFFER V.TKB = 60 ;KEYBOARD VECTOR V.TPS = 64 ;PRINTER VECTOR V.FPP = 244 ;FPP AND FIS VECTOR .IF EQ BF TTYIN = 82. ;82 CHARACTER INPUT RING TTYOUT = 32. ;32 CHARACTER OUTPUT RING .IFF TTYIN = 100. ;100 CHARACTER INPUT RING TTYOUT = 40. ;40 CHARACTER OUTPUT RING .ENDC ; ; DEFINITIONS OF LINE CLOCK STATUS WORDS: ; .IF DF $RXPRO ;### LKCS=DPBBAS+1240 ;### .IFF ;### LKCS = 177546 ;CLOCK STATUS REGISTER .ENDC ;$RXPRO ;### LKVEC = 100 ;CLOCK VECTOR LOCATION ; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; ; THE FOLLOWING MACRO AND MACRO CALLS GENERATE EQUATES ; FOR THE SIZE (IN BYTES) OF THE HANDLERS FOR EACH DEVICE ; IN THE SYSTEM ; HANDLERS WHICH ARE VALID SYSTEM DEVICES MUST HAVE TYPE 'SYS' ; OTHER HANDLERS FROM WHICH PROGRAMS CAN BE RUN MUST HAVE TYPE 'RUN' .MACRO HSIZE HAN,BYT,TYPE HAN'SIZE = BYT .IF NB TYPE .IIF GT BYT-MAXHAN, MAXHAN = BYT .ENDC .IF IDN , .GLOBL HAN'SIZE .IIF GT BYT-MAXSYH, MAXSYH = BYT .ENDC .ENDM HSIZE MAXHAN = 0 ;MAXHAN CONTAINS THE MAXIMUM HANDLER SIZE MAXSYH = 0 ;MAXSYH CONTAINS THE MAXIMUM SYS HANDLER SIZE HSIZE TT,470 HSIZE RK,342,SYS HSIZE DP,434,SYS HSIZE RF,270,SYS HSIZE PR,174 HSIZE PP,160 HSIZE MT,4300 HSIZE LP,306 HSIZE DT,324,SYS HSIZE CT,3710 HSIZE CR,1326 HSIZE BA,4000 HSIZE DX,660,SYS HSIZE DS,240,SYS .IIF NDF BANDW, .NLIST .IF DF BANDW HSIZE AM,214,RUN .ENDC .IIF NDF BANDW, .LIST .IF NE BF OVLYSZ = 2 ;2 BLOCK OVERLAYS IN FB .IFF OVLYSZ = 1 ;1 BLOCK OVERLAYS IN SU .ENDC OVLYN = -OVLYSZ ;NO OVERLAYS YET EMTERR = 17*20+EMT ;ERROR SETTING EMT IENABL = 100 ;INTERRUPT ENABLE BIT .SBTTL ASECT - INITIAL VECTORS .ASECT . = 4 .WORD TRAP4,0 .WORD TRAP10,0 . = 24 .WORD 26,0 ;HALT ON POWER FAIL . = 30 .WORD EMTPRO,0 ;EMT TRAP . = 54 .WORD $RMON ;POINTER TO RESIDENT . = V.TKB .WORD TTIINT,PR7 ;KEYBOARD INTERRUPT . = V.TPS .WORD TTOINT ;TELETYPE INTERRUPT .IIF NE BF, PR7 ;BF IN AT LEVEL 7 .IIF EQ BF, PR4 ;SU IN AT PR4 . = 100 .WORD LKINT,PR7+1 ;TIMER VECTOR, PRIO=7, CARRY SET . = 114 .WORD 116,0 ;HALT ON MEMORY PARITY ERROR . = 300 BSTRNG: .IF DF $RXPRO ;### .ASCII <15><12>"RT/RSX X01-01" ;### .ENDC ;$RXPRO ;### .ASCII <15><12>"RT-11" .RADIX 10. .IRP ...,<\UPDATE> .IF NE BF .ASCIZ "FB V02B-0'..." .IFF .ASCIZ "SJ V02B-0'..." .ENDC .ENDR .RADIX 8. .EVEN . = V.FPP FPPINT PR7 .SBTTL SLIDE KMON/USR UP OR DOWN .CSECT SWAP ;MAKE THE SWAP BLOCKS COME FIRST .CSECT RT11 ;PUT KMON & USR HERE ; "THE AWFUL SHADOW OF SOME UNSEEN POWER ; FLOATS, THO' UNSEEN, AMONGST US" ; - SHELLEY, "HYMN TO INTELLECTUAL BEAUTY" ; KUMOVE IS RESPONSIBLE FOR MOVING THE KMON AND USR ; EITHER UP OR DOWN WHEN A HANDLER IS LOADED OR UNLOADED, ; OR WHEN A FOREGROUND JOB IS INSTALLED OR REMOVED. ; CALLING SEQUENCE: ; R0 = AMOUNT TO MOVE (<0 => DOWN; >0 => UP) ; RETURNS: ; R4 -> KMON IF DOWN ; START OF FREED AREA IF UP ; DESTROYS R1, (R3 IF DOWN) KMON: .WORD 0 ;THIS WORD STOPS THE MOVE LOOP KUMOVE: MOV PC,R4 ;POINT R4 TO KMON CMP -(R4),-(R4) ;(MUST BE 3RD INSTRUCTION) JSR PC,CLRLOW ;CLEAR OUT 40-53 MOV R4,R1 ;COPY KMON PTR. ASL R0 ;FIX R0 TO BYTES. MOVE UP OR DOWN ? BCS 1$ ;DOWN, GO CALL MOVER ADD R0,R4 ;R4 IS DESTINATION PTR ADD #KMSIZE+USRSIZ,R1 ;CHANGE POINTERS TO TOP OF USR ADD #KMSIZE+USRSIZ,R4 ; AND TOP OF DESTINATION CLR -(SP) ;WORD TO FLAG WHEN WE PASS STACK TOP 2$: MOV -(R1),-(R4) ;MOVE A WORD BNE 2$ ;LOOP WHILE NON-0 CMP R1,PC ;WAS THE 0 WORD BELOW HERE ? BLO 4$ ;YES. DONE ! CMP R1,SP ;WAS IT STACK TOP ? BNE 2$ ;NO, JUST A STRANGE 0 MOV R4,SP ;MAKE THE NEW STACK POINTER TST (SP)+ ;PURGE THAT 0 WORD BR 2$ ;MOVE THE REST 4$: MOV R0,R1 ;MUST RELOCATE ADDR BR 3$ 1$: ADD R0,R4 ;R4 IS DESTINATION PTR BCC MEMERR ;CARRY CLEAR => TOO MUCH ASKED CMP R4,#1000 ;ARE WE MOVING TOO LOW ? BLO MEMERR ;YES. ERROR JSR PC,MOVEDN ;CALL MOVER-DOWNER CLR R1 ;NO NEED TO RELOCATE ADDR 3$: ADDR RELIST,R1,ADD ;POINT TO STUFF TO RELOCATE .REPT 5 ;RELOCATE POINTERS WITHIN RMON ADD R0,@(R1)+ .ENDR ADD R0,(R1)+ ;RELOCATE .USRBU ADD R0,(R1)+ ; AND .USRBO ADD R0,@R1 ; AND .USRTO ADD R0,SYSIOB-.USRTO(R1) ; AND POINTER TO USRBUF ADD R0,@SP ;RELOCATE RETURN ADDRESS RTS PC ;RETURN MEMERR: JMP OVERC .SBTTL COMMAND DISPATCHER ; THE FOLLOWING CODE IS CLEANUP AFTER AN EXIT HAS BEEN DONE. ; MEXIT IS CALLED WHEN THE USR HAS BEEN FRESHLY READ AND HAS ; POINTERS WHICH MUST BE RELOCATED. ; MEXIT2 IS USED WHEN A GOOD USR COPY IS IN THE STANDARD PLACE IN CORE MEXIT: JSR PC,LOCATE ;SET POINTERS INTO RMON MEXIT2: .IF EQ BF JSR PC,QRESET ;RESET THE IO QUEUE CLR @.RECURS ;NO COMPLETION ROUTINES ACTIVE CLR @.DFLG ;CLEAR ^C DELAY SWITCH MOV @#SYSPTR,R0 ;POINT TO SYSTEM CLR MONCAL-$RMON(R0) ;GET RID OF LINGERING MONITOR CALLS .IFTF MOV @.$KMLO,@.KMLOC ;KMON IS NOW IN CONTROL BIC #TTSPC$+TTLC$,@#JSW ;CLEAR OUT SPECIAL TTY MODE CLR GETCNT ;NO GETS YET MOV @#SYSPTR,R3 ;POINT TO RMON (NOT CONTIGUOUS WITH USR) MOV SP,KMONIN-$RMON(R3) ;KMON IS IN CONTROL CLR BLKEY-$RMON(R3) ;NO DIRECTORY IS IN CORE .IFT JSR PC,CLRHND ;RELEASE ALL NON-RES HANDLERS CLR $SYSCH+10-$RMON(R3) ;CLEAR SYS IO COUNT CLR EXTFLG-$RMON(R3) ;"EXIT" IS DONE NOW CLR TTIPRE-$RMON(R3) ;SO THAT ^C WON'T WAIT ON EXIT CLRB TTILCT+1-$RMON(R3) ;CLEAR TT: ^C FLAG .IFF MOV CNTXT-$RMON(R3),R2 ;ANOTHER ^C WILL NOT ABORT US CLR I.PTTI(R2) CLR EXTFLG-$RMON(R3) ;CLEAR EXIT IN PROGRESS FLAG .ENDC TST (SP)+ ;WHAT KIND OF EXIT ? BNE KCHAIN ;TEMPORARY INIT: JSR PC,CLRLOW ;CLEAR CCB IN MONITOR .HRESET ;SYSTEM RESET (HARDWARE & SOFTWARE) CTRLCK: BIC #CHAIN$,@#JSW ;STANDARD KMON LOOP IS NO CHAIN KCHAIN: MOV .USRBUF,R0 ;SET UP KMON STACK MOV R0,SYSIOB ;KMSTAK IS THE SAME AS BUFFER MOV R0,SP ;PUT NEW SP INTO REG 6 .IF NE BF .UNLOCK .ENDC .RCTRLO ;DISABLE CTRL/O ADDR KMCBUF,R5 ;POINT TO KMON COMMAND BUFFER MOV R5,R3 ;COPY POINTER BIT #CHAIN$,@#JSW ;IS THIS A CHAIN ENTRY? BEQ 19$ ;NO .IF NE BF .LOCK .ENDC JMP RUN ;YES. SIMULATE A RUN 19$: JSR PC,KCRLF ;RETURN THE CARRIAGE 2$: .RCTRLO MOV .$ENTR,R0 ;R0 -> $ENTRY TABLE MOV BA.NUM(R0),R0 ;R0 -> BA.SYS ENTRY BEQ 40$ ;BR IF NOT IN MEMORY TST 6(R0) ;IS IT ACTIVE? BNE 41$ ;BR IF ACTIVE, TO PRETTY UP LOG 40$: .TTYOUT #'. ;PRINT A DOT 41$: MOV #72.,R1 ;72. CHARS/LINE .IF EQ BF MOV #' ,@R5 ;PUT IN A BLANK FOR COMPARISON .ENDC 3$: .TTYIN ;GET CHAR FROM TTY CMPB #TAB,R0 ;IF IT IS A TAB BNE 31$ MOVB @R5,R0 ;CHANGE IT TO A SPACE 31$: CMPB @R5,R0 ;IF IT IS A SPACE BNE 32$ CMPB @R3,R0 ;AND WE ARE POINTING TO A SPACE BEQ 3$ ;THEN IGNORE IT 32$: CMPB #CR,R0 ;IGNORE CARRIAGE RETURNS BEQ 3$ DEC R1 ;ROOM FOR IT ? BMI 4$ ;NO, KEEP SKIPPING MOVB R0,-(R3) ;PUT BYTE IN BUFFER 4$: CMP #LF,R0 ;IS IT END OF LINE ? BNE 3$ ;NOT YET TST R1 ;DID BUFFER OVERFLOW ? BMI BADCOM ;YES, GIVE AN ERROR 45$: CLRB (R3)+ ;CHANGE THE LF TO A NULL CMP R5,R3 ;ANYTHING IN THE LINE ?? BEQ 2$ ;NO, GET A NEW LINE MOV R5,R3 ;SAVE START OF LINE PTR MOV -(R5),R1 ;GET FIRST TWO CHARS INC R5 ;START WITH THE SECOND CHAR 5$: TSTB (R5)+ ;IS THIS THE END OF THE LINE? BEQ 7$ ;YES. LEAVE R5 JUST BEFORE THE NULL DEC R5 ;NO. FIX R5 CMPB @R3,-(R5) ;AND IS THE NEXT CHAR BLANK? BNE 5$ ;NO, KEEP SKIPPING 7$: ADDR COMLST,R2 ;SETUP POINTER TO COMMAND LIST 10$: TST (R2) ;END OF LIST ? BEQ 20$ ;YES, TRY OVERLAYS CMP R1,(R2)+ ;IS THIS IT ?? BNE 10$ ;NO, KEEP TRYING MOV PC,R3 ;RELOCATE COMMAND ADDRESS XX=. ADD COMLSZ-2(R2),R3 ;JUMP TO COMMAND HANDLER BR 30$ ;GO CALL COMMAND 20$: MOV R5,R1 ;SAVE END OF COMMAND POINTER MOV R3,R5 ;POINT TO START OF CMD TST (R2)+ ;MOVE OVER 0 WORD JSR PC,GETNAM ;CONVERT TO RAD 50 MOV (R2)+,R3 ;R3 = COMMAND IN RAD 50 TST (R2)+ ;UNUSED PART OF NAME 21$: TST (R2) ;END OF LIST ? BEQ BADCOM ;YES, EVIL CMP R3,(R2)+ ;IS THIS IT ? BNE 21$ ;NOT YET ADD #OCOMSZ-2,R2 ;PUSH ON TO BLOCK # JSR PC,OVREAD ;READ IN THE OVERLAY 30$: CLR SAVSWT ;CLEAR SAVED INDICATOR IF E OR D .IF NE BF .LOCK .ENDC JSR PC,@R3 ;GO GO GO BR CTRLCK ;DONE MSGKM: .PRINT ;PRINT THE MESSAGE .EXIT BADCOM: KMEROR KCRLF: MOV PC,R0 ;GET A NULL BYTE MOV R0,R0 ;NO-OP WHOSE BOTTOM BYTE IS 0!!!!! .PRINT ;PRINTING NULLSTRING IS A CRLF RTS PC .SBTTL READ OVERLAY, LINK TO OVERLAY OVREAD: MOVB (R2)+,R0 ;GET RELATIVE OVLY BLOCK ADD @.$SWPBL,R0 ;MAKE IT ABSOLUTE CLR -(SP) ;MAKE ROOM FOR OFFSET MOVB (R2)+,@SP ;AND PUT IT IN ADDR OVLIOB,R5 ;IOB FOR OVERLAY I/O ADDR OVLY,R3 ;CORE ADDRESS CMP R0,(R5) ;IS BLOCK ALREADY IN ? BEQ 1$ ;YES, DON'T DO I/O MOV R0,(R5)+ ;REMEMBER WHICH OVLY IS IN MOV R3,@R5 ;SET CORE ADDR JSR PC,@.$SYS ;DO I/O FROM SYSTEM DEVICE BCS 10$ ;ERROR READING OVLY 1$: MOV R1,R5 ;REPOINT TO CMD ARGUMENTS ASL @SP ;REAL OFFSET ADD (SP)+,R3 ;POINT IT INTO BLOCK RTS PC ;RETURN 10$: CLR -(R5) ;NO OVERLAY IS IN KMEROR ; THIS ROUTINE IS USED TO LINK FROM ONE OVERLAY TO ANOTHER ; OVER THE LINK, R0, R1, AND R3 ARE DESTROYED. ; R2, R4, R5, AND THE STACK ARE PRESERVED OVLINK: MOV R5,R1 ;PRESERVE R5 OVER THE LINK JSR PC,OVREAD ;GO READ IN THE OVERLAY MOV (SP)+,R2 ;RESTORE R2 JMP @R3 ;ENTER THE OVERLAY .SBTTL BASE, EXAMINE .ENABL LSB B: JSR PC,OCTNUM ;GET THE BASE BIC #1,(SP) ;ONLY EVEN BASES MOV (SP)+,BASE ;SAVE IT 10$: RTS PC ;BACK TO KMON E: MOV BASE,R3 ;GET THE BASE ADDRESS JSR PC,OCTNUM ;GET FIRST ADDRESS BIC #1,(SP) ;EVEN ADDRESSES ONLY CLR R1 ;CLEAR COUNT (IN CASE ONLY 1) CMPB #'-,(R5) ;IS IT A DASH ?? BNE 1$ ;NO, JUST EXAMINE ONE WORD JSR PC,OCTNUM ;GET UPPER LIMIT MOV (SP)+,R1 ;MOVE IT TO COUNT REG SUB (SP),R1 ;GET COUNT BLO BADCOM ;BACKWARDS IS A NO-NO ROR R1 ;R1 HAS WORD COUNT - 1 1$: ADD (SP)+,R3 ;GET ADDRESS (BASE+GIVEN ADDRESS) 2$: MOV #10,R4 ;DISPLAY 8 WORDS PER LINE 3$: JSR PC,ADTRAN ;TRANSLATE ADDRESS IN CASE VIRT CORE TST (R3)+ ;BUMP ADDRESS FOR NEXT TIME MOV (R2),R2 ;GET THE WORD OPRINT: MOV #30,R0 ;CONVERT WORD TO OCTAL AND PRINT IT SEC 4$: ROL R2 ;DON'T TRY TO UNDERSTAND THIS ROUTINE ROLB R0 ; JUST USE IT & LOVE IT .TTYOUT MOV #206,R0 5$: ASL R2 ;DONE YET ? BEQ 6$ ;YES ROLB R0 BCS 5$ BR 4$ 6$: DEC R1 ;ANY MORE TO DO ? BMI 10$ ;NO, GO HOME .TTYOUT #40 ;PRINT SEPARATOR DEC R4 ;8/LINE BNE 3$ JSR PC,KCRLF ;PRINT CR LF BR 2$ .SBTTL DEPOSIT D: MOV BASE,R3 ;GET BASE ADDRESS JSR PC,OCTNUM ;GET LOCATION ADD (SP)+,R3 ;GET DESIRED ADDRESS BIC #1,R3 ;MAKE SURE ITS EVEN 7$: TSTB @R5 ;END OF LINE? BEQ SAVEVC ;YES, DONE MOV R3,R2 ;COPY DEPOSIT ADDRESS MOV @#SYSPTR,R0 ;POINT TO PERM CCB ADD #CCB-$RMON,R0 JSR PC,SETBIT ;SET BIT IN CCB JSR PC,ADTRAN ;TRANSLATE ADDRESS CMP R3,R2 ;WAS THIS ADDR IN VIRT CORE ?? BEQ 8$ ;NO, NOT IF THEY'RE THE SAME INC SAVSWT ;YES, SAVE THIS BLOCK LATER 8$: JSR PC,OCTNUM ;GET NEXT VALUE MOV (SP)+,(R2) ;STORE IT TST (R3)+ ;INCREMENT ADDRESS BR 7$ ;LOOP .DSABL LSB .SBTTL ADTRAN & SAVEVC .ENABL LSB ADTRAN: MOV @#SYSPTR,R2 ;POINT TO RESIDENT CMP R3,SYSLOW-$RMON(R2) ;IS ADDRESS IN RANGE? BHIS 3$ ;NO, GIVE ERROR ADDR KMON,R2 ;SETUP POINTER TO KMON BIC #777,R2 ;FORCE TO A BLOCK BOUNDARY SUB R3,R2 ;IS ADDRESS IN VIRT. CORE ? BLOS 1$ ;YES, GO DO VIRT. CORE MOV R3,R2 ;NO, REAL CORE IS EASY RTS PC 1$: ADDR SYSIOB-2,R5,PUSH ;SAVE R5, POINT TO SYS IOB NEG R2 ;GET DISPLACEMENT INTO VIRT. CORE CLRB R2 ;ZERO LOWER 8 BITS SWAB R2 ;GET THE BLOCK NUMBER IN SYS SCRATCH ASR R2 CMP R2,(R5)+ ;IS IT THE BLOCK WE'VE GOT ? BEQ 2$ ;YES JSR PC,SAVEVC ;SAVE VIRT CORE IF MODIFIED NEG 2(R5) ;MAKE WORD COUNT POSITIVE MOV R2,R0 ;GET DESIRED BLOCK NUMBER MOV R0,BLOKWG ;SAVE THIS JSR PC,SYSK ;READ FROM SYS SCRATCH AREA 2$: MOV R3,R2 ;GET REAL ADDRESS BIC #177000,R2 ;GET ADDRESS WITHIN BUFFER ADD (R5),R2 ;ADD START OF BUFFER BR 10$ ;POP R5 AND RETURN 3$: KMEROR SAVEVC: MOV #-400,SYSIOB+2 ;MAKE A ONE BLOCK WRITE ADDR SAVSWT,R5,PUSH ;SAVE R5, POINT TO SYSIOB-4 TST (R5)+ ;DID WE ALTER THIS ONE ? BEQ 10$ ;NO MOV (R5)+,R0 ;GET BLOCK NUMBER OF BLOCK IN CORE JSR PC,SYSK ;WRITE INTO SCRATCH AREA 10$: MOV (SP)+,R5 ;RESTORE POINTER TO SYS IO BLOCK RTS PC .DSABL LSB .SBTTL R (RUN FROM SY:) R: MOV (PC)+,R3 ;SET DEFAULT DEVICE TO SY: .RAD50 /SY / JSR PC,FILE ;GET THE FILE DESCRIPTOR CMP (PC)+,(R3) ;WAS ANOTHER DEVICE SPECIFIED ? .RAD50 /SY / BNE BCLNK ;YES, THAT'S A NO-NO .LOOKUP 17 ;OPEN IT ON CHANNEL 17 BCS NOTFND ;FILE NOT FOUND CLR @#USERTOP ;MAKE SURE USERTOP GETS SET BY CCBB0 JSR PC,CCBB0 ;GET CCB AND BLOCK 0 1$: MOV (R2)+,(R3)+ ;MOVE IN CCB DEC R1 ;DONE? BNE 1$ MOV SB17-(R3),R1 ;GET START BLOCK OF FILE ON SY INC R1 ;GET FIRST BLOCK TO READ MOV @#USERPC,R2 ;GET STARTING ADDRESS MOV #1000,R3 ;GET FIRST ADDRESS TO READ BEGIN: BIT #CHAIN$,@#JSW ;ARE WE CHAINED TO ? BNE 5$ ;YES, DO NOT RESET .SRESET ;NO, RESET ALL (EXCEPT MAYBE 17) 5$: MOV @#SYSPTR,R5 ;GET START OF RMON MOV @#USERTOP,R4 ;GET HIGHEST ADDRESS OF USER CORE TST @#USERSP ;IS USER STACK DEFINED ?? BNE 1$ ;YES, IF ITS NON-ZERO MOV #1000,@#USERSP ;NO STACK GIVEN, DEFAULT TO 1000 1$: MOV SYSLOW-$RMON(R5),R0 ;HIGHEST TOP IF USR CAN SWAP BIT #USR$,CONFIG-$RMON(R5) ;CAN THE USR SWAP? BEQ 3$ ;YES, LUCKY US MOV $USRLC-$RMON(R5),R0 ;NO, HIGHEST TOP IS THE USR 3$: CMP R0,R4 ;DOES IT OVERLAY TOP? BLOS OVERC ;FILE IS TOO BIG. GIVE ERROR .SETTOP R4 ;SET NEW TOP OF CORE SUB R3,R4 ;GET TOP - START = REMAINDER TO READ BCS 2$ ;IF NEGATIVE, NO READ NECESSARY ADD #KMBLK+4-$RMON,R5 ;POINT R5 TO KMBLK+4 IN RMON ROR R4 ;MAKE IT A WORD COUNT INC R4 ;DON'T FORGET LAST WORD MOV R4,-(R5) ;PUT REMAINDER WORD COUNT INTO I/O BLOCK MOV R3,-(R5) ;PUT BUFFER ADDRESS INTO I/O BLOCK MOV R1,R0 ;GET STARTING BLOCK OF FILE MOV R5,R1 ;SETUP POINTER TO RMON STACK ADD #SPTR-KMBLK,R1 ;RECALL WHERE R5 POINTS MOV R1,SP ;USE SYSTEM TEMPORARY STACK JMP RDOVLY-KMBLK(R5) ;GO READ IN THE PROGRAM 2$: JMP ENTRPG-$RMON(R5) ;SET STACK AND ENTER PROG NOTFND: KMEROR SFERR: KMEROR BCLNK: JMP BADCOM .SBTTL REENTER, RUN & START REENTR: BIT #RSTRT$,@#JSW ;IS PROG REENTERABLE ? BEQ BCLNK ;NO, ILLEGAL COMMAND MOV #-2,R2 ;USE START ADDRESS MINUS TWO BR STRE RUN: JSR PC,GET ;GET THE SAVE IMAGE CLR R2 ;USE THE START ADDRESS BR STRE STARTK: JSR PC,OCTNUM ;GET THE DESIRED STARTING ADDRESS MOV (SP)+,R2 BNE GOTADR STRE: ADD @#USERPC,R2 ;USE STARTING ADDRESS FROM CCB IF 0 GOTADR: ADDR KMON,R3 ;SETUP FIRST ADDRESS TO READ BIC #777,R3 ;ROUND TO A BLOCK MOV @.$SWPBL,R1 ;SETUP FIRST BLOCK TO READ BR BEGIN .SBTTL GET (ALSO USED BY RUN) OVERC: CLR @#USERTOP ;FILE WAS TOO BIG. CLEAR TOP KMEROR ;OF CORE FOR NEXT KMON CMD. GET: TST GETCNT ;SEE IF THIS IS FIRST GET. BNE 1$ ;N TH GET. LEAVE 50 ALONE JSR PC,CLRCCB ;CLEAR CCB AND USRTOP BIC #RSTRT$,@#JSW ;MAKE IT NOT RESTARTABLE INC GETCNT ;MARK A GET DONE 1$: JSR PC,GETHAN ;GET THE DEVICE HANDLER .LOOKUP 17 ;LOOKUP FILE TO BE GOT BCS NOTFND ;FILE NOT FOUND JSR PC,CCBB0 ;GET CCB AND BLOCK 0 CLR R5 ;ZERO THE BLOCK NUMBER ASL R1 ;SET CCB BYTE COUNT TO 16 MOV #200,R4 ;INITIALIZE TEST BIT (START AT BLOCK 1) CLRSB: CLR R0 ;CLEAR THE STARTING BLOCK NUMBER GETBIT: RORB R4 ;SHIFT TEST BIT BCS ORCCB ;IF CARRY SET, DONE WITH THIS BYTE INC R5 ;INCREMENT BLOCK NUMBER BITB R4,(R2) ;TEST BIT OF SAVE FILE'S CCB BEQ 4$ ;THIS BLOCK NOT USED TST R0 ;IS THIS FIRST BLOCK OF A SEQUENCE ? BNE GETBIT ;NO, STARTING BLOCK ALREADY SET MOV R5,R0 ;YES, SET STARTING BLOCK OF SEQUENCE BR GETBIT ;GO LOOK AT NEXT BIT OF MAP 4$: TST R0 ;WAS PRECEEDING BLOCK(S) USED ? BEQ GETBIT ;NO, NO READS ADDR KMON,R4,PUSH ;SAVE R4, POINT TO KMON MOV R5,-(SP) ;SAVE BLOCK NUMBER FOR LATER CLRB R4 ;MAKE IT AN EXACT BLOCK SWAB R4 ASR R4 ;MAKE IT A BLOCK NUMBER CMP R5,R4 ;DOES THIS SET OF BLOCKS OVERLAY KMON ? BLE NOSCRA ;NO, NOTHING INTO THE SYSTEM SCRATCH CMP R0,R4 ;DOES STARTING BLOCK OVERLAY KMON ? BGE ALSCRA ;YES, ALL INTO SYSTEM SCRATCH AREA MOV R4,R5 ;THIS SET OF BLOCKS LAYS ACROSS BOUNDARY JSR PC,READSF ;READ PART THAT FITS INTO REAL CORE MOV R4,R0 ;SET START BLOCK TO START OF VIRT CORE ALSCRA: SUB R4,R0 ;GET BLOCK # IN VIRT CORE INTO R0 ADD R0,R4 ;R4 HAS STARTING BLOCK IN FILE ALSCR1: MOV (SP),R5 ;GET NUMBER OF LAST BLOCK + 1 SUB R4,R5 ;NUMBER OF BLOCKS REMAINING TO GET BLE ENDSCR ;NONE LEFT IN THIS SEQUENCE CMP R5,#SWAPSZ ;SEE IF FILE FITS IN SCRATCH BGT OVERC ;IT DOESN'T GIVE ERROR MOV R0,-(SP) ;SAVE VIRT CORE BLOCK # MOV R4,R0 ;R0 CONTAINS BLOCK TO READ IN SAVE FILE CLR -(SP) ;USE WAIT I/O MOV #1000,-(SP) ;READ TWO BLOCKS DEC R5 ;IF THERE ARE TWO LEFT BNE 7$ ASR (SP) ;NOPE, ONLY ONE LEFT 7$: ADDR SYSIOB+2,R5 ;SETUP POINTER TO SYSTEM IO BLOCK MOV (SP),(R5) ;COPY WORD COUNT INTO SYS IO BLOCK NEG (R5) ;MAKE IT NEG.--A WRITE OPERATION MOV -(R5),-(SP) ;COPY BUFFER POINTER TO STACK EMT 200+17 ;READ FROM SAVE FILE SFELNK: BCS SFERR ;ERROR READING SAVE FILE MOV (SP),R0 ;RESTORE BLOCK # IN VIRT CORE TO R0 JSR PC,SYSK ;WRITE INTO SYS SCRATCH MOV (SP)+,R0 ;RESTORE STARTING BLOCK AGAIN CMPB (R0)+,(R0)+ ;INCREMENT IT BY TWO CMPB (R4)+,(R4)+ ;INCREMENT INPUT BLOCK # AS WELL BR ALSCR1 ;GO DO NEXT 2 BLOCKS NOSCRA: JSR PC,READSF ;READ FROM SAVE FILE DIRECT TO CORE ENDSCR: MOV (SP)+,R5 ;RESTORE CURRENT BLOCK NUMBER MOV (SP)+,R4 ;ALSO RESTORE MASK BR CLRSB ;GO TEST NEXT BIT ORCCB: BISB (R2)+,(R3)+ ;SET BITS IN RESIDENT CCB DEC R1 ;ANY MORE BYTES ? BNE GETBIT ;YES (NOTE CARRY IS STILL SET) RTS PC READSF: CLR -(SP) ;USE WAIT I/O SUB R0,R5 ;NUMBER OF BLOCKS SWAB R5 ;GET WORD COUNT MOV R5,-(SP) ;ONTO STACK MOV R0,-(SP) ;STARTING BLOCK NUMBER TO STACK SWAB (SP) ;MAKE IT AN ADDRESS ASL (SP) EMT 200+17 ;READ THE FILE BCS SFELNK ;ERROR READING FILE RTS PC .SBTTL SYSK, CLRCCB, CLRLOW ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; ; SYSK IS USED TO DO I/O FROM/TO THE SYSTEM SCRATCH AREA. ; IT IS CALLED WITH R0 CONTAINING THE RELATIVE BLOCK NUMBER ; TO BE USED, AND R5 POINTING TO A THREE WORD BLOCK CONTAINING ; THE BUFFER ADDRESS, THE WORD COUNT (NEGATIVE FOR WRITE), ; AND A ZERO. ; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; .ENABL LSB SYSK: CLR @.BLKEY ;TELL USR THAT DIR NOT IN CORE MOV @.$SWPBL,-(SP) ;CHECK TO MAKE SURE WE ARE NOT ;READING/WRITING TOO MANY SCRATCH ;BLOCKS. THIS CODE COMPARES THE BLOCK ;TO BE WRITTEN WITH THE START OF ;THE MONITOR, AND ;WILL FAIL IF TOO MANY ARE REQUESTED. ADD (SP),R0 ;MAKE R0 ABSOLUTE BLOCK ADD #SWAPSZ,(SP) ;POINT TO START OF MONITOR MOV 2(R5),-(SP) ;COMPUTE HIGHEST SCRATCH TO WRITE BPL 5$ ;>0 IS READ NEG (SP) 5$: SWAB (SP) ;# BLOCKS TO WRITE. (1 OR 2) ADD R0,(SP) ;MAKE IT ABSOLUTE CMP (SP)+,(SP)+ ;GOING TOO FAR? BHI OVERC ;YES. QUIT. JSR PC,@.$SYS ;USE SYSTEM HANDLER BCC 10$ ;OK, RETURN SYIOER: KMEROR CLRLOW: MOV #PARMS,R1 2$: CLR (R1)+ ;CLEAR OUT 40-53 CMP R1,#PARMS+14 BLO 2$ CLRCCB: MOV @#SYSPTR,R1 ;POINT TO SYSTEM ADD #CCB-$RMON,R1 ;POINT TO CCB MOV #10,-(SP) ;10 WORDS TO CLEAR 1$: CLR (R1)+ DEC @SP BNE 1$ MOV (SP)+,@#USERTOP ;POP COUNT, USE IT TO CLEAR USERTOP 10$: RTS PC .DSABL LSB .SBTTL FILE ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; ; FILE IS USED TO INTERFACE WITH THE CSI ROUTINE GETFD, ; USING THE DEFAULT EXTENSION .SAV ; NULL FILE NAME IS REJECTED WITH AN ERROR MESSAGE ; CALLING SEQUENCE: ; R3 = DEFAULT DEVICE NAME ; R5 -> INPUT STRING (BACKWARDS) ; RETURNS: ; R5 -> DELIMITING CHARACTER ; R3 -> 4-WORD FILE DESCRIPTOR AT LOCATION 'BLOCK' ; R0 = R3 -> 'BLOCK' FOR FILE-REFERENCING EMT'S ; DESTROYS: ; R2 ; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; .ENABL LSB FILE: JSR R1,1$ ;SAVE R1, POINT TO "SAV" .RAD50 "SAV" 1$: MOV #3*400+17,R0 ;CODE FOR PURGE CHANNEL 17 EMT 374 ;DO THE PURGE MOV R3,DEV1 ;PUT IN PROPER DEFAULT DEVICE NAME MOV #500,R0 ;SET R0 IN CASE OF CHAIN BIT @#JSW,#CHAIN$ ;IS CHAIN$ ON? BNE 2$ ;YES, DEV:FILNAM.EXT IS AT 400 ADDR BLOCK,R2 ;SETUP POINTER TO FILE DESCRIPTOR JSR PC,GETFD ;GET THE FILE DESCRIPTOR (R0 -> BLOCK) 2$: MOV (SP)+,R1 ;RESTORE R1 MOV R0,R3 ;PUT F.D. POINTER INTO R3 TST (R3) ;WAS IT A NULL FILE ?? BEQ 3$ ;YES, THATS BAD TST 2(R3) ;FILE MUST BE SPECIFIED BNE RTS7 ;IT WAS 3$: KMEROR RFILE: JSR R1,1$ .RAD50 "REL" .DSABL LSB .SBTTL CCBB0 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; ; CCBB0 IS USED TO READ IN BLOCK 0 OF A SAVE FILE. THIS ; BLOCK IS READ INTO THE USR BUFFER AND THEN SELECTIVELY ; MOVED INTO THE ZEROETH BLOCK OF CORE (ONLY CERTAIN WORDS ; ARE MOVED, THIS PROTECTS THE SYSTEMS TRAP VECTORS). ; THE USRTOP LOCATION IS SET TO THE MAXIMUM OF THE TOP OF ; THE CURRENT CONTENTS OF CORE AND THE TOP OF THE SAVE ; FILE BEING LOADED. ; RETURNS: ; R1 = 8. ; R2 -> LOCAL COPY OF CCB ; R3 -> CCB COPY IN RMON ; DESTROYS: R0, R5 ; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; CCBB0: MOV SYSIOB,R5 ;GET POINTER TO BUFFER CLR R0 ;READ FROM RELATIVE BLOCK 0 CLR @.BLKEY ;TELL USR THAT DIR NOT IN CORE .READW 17,R5,#400 ;READ ONE BLOCK INTO BUFFER BCS SFELNK ;ERROR WHILE READING MOV @#SYSPTR,R3 ;POINT TO RESIDENT LOW CORE MAP ADD #LOWMAP-$RMON,R3 CLR R1 ;R1 POINTS TO LOW CORE MOV #JSW,R0 ;R0 -> JSW MOV @R0,-(SP) ;SAVE OLD JSW BIC #^C,@SP ;SAVE ONLY CHAIN INDICATION (BIT 400) 1$: MOVB (R3)+,@SP ;GET NEXT MAP BYTE SEC ;SET STOPPER ROLB @SP ;GET FIRST BIT 2$: BCS 3$ ;BIT ON => SKIP IT MOV @R5,@R1 ;MOVE IN A GOOD WORD 3$: CMP (R5)+,(R1)+ ;SKIP A WORD IN EACH ASLB @SP ;GET NEXT BIT BNE 2$ ; IF ANY CMP #500,R1 ;IS LOW PTR = 500 YET? BNE 1$ ;YES TST @SP ;ARE WE IN THE MIDST OF A CAHIN? BEQ 45$ ;NO, COPY 400-776 BIT @R0,#CHAIN$ ;DOES NEW JSW SAY PROTECT 500-776? BEQ 6$ ;NO 45$: BIC #CHAIN$,@R0 ;CLEAR CHAIN INDICATION IF ON 5$: MOV (R5)+,(R1)+ ;NOW MOVE IN THE OTHER 128. WORDS TSTB R1 ;IS LOW PTR = 1000 YET ? BNE 5$ 6$: BIS (SP)+,(R0)+ ;SET SAVED CHAIN INDICATION IN JSW TST (R0)+ ;R0 = 50 -> USERTOP SUB R1,R5 ;CORRECT R5 FOR AMT MOVED (400 OR 1000) ADD R0,R5 ;ADD 50, SO R5 -> NEW USERTOP CMP @R5,@R0 ;IS NEW USERTOP BIGGER THAN OLD? BLOS 7$ ;NO MOV @R5,@R0 ;YES, FIX IT UP 7$: ADD #400-USERTOP,R5 ;R5 -> TOP OF CCB IN FILE ADDR BLOCK+16.,R2 ;R2 -> TOP OF OUR CCB COPY MOV #8.*400+8.,R1 ;MOVE TWO 8'S TO R1 8$: MOV -(R5),-(R2) ;MOVE IN THE CCB DECB R1 ;DONE? BNE 8$ MOV @#SYSPTR,R3 ;POINT TO CCB IN RMON ADD #CCB-$RMON,R3 SWAB R1 ;GET 8 INTO R1 RTS PC .SBTTL GETHAN ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; ; GETHAN IS USED BY GET, RUN, AND SAVE TO GET A FILE DESCRIPTOR ; AND THEN LOAD THE PROPER DEVICE HANDLER INTO THE KMON ; HANDLER AREA. IT USES SUBROUTINE 'FILE' WITH DEFAULT ; DEVICE DSK: TO GET THE FILE DESCRIPTOR. THE ROUTINE EXITS ; WITH THE HANDLER CORRESPONDING TO THE DEVICE NAMED IN ; THE FILE DESCRIPTOR IN CORE. IT LEAVES BOTH R0, AND R3 ; POINTING TO THE FILE DESCRIPTOR. NO UNNECESSARY HANDLER ; FETCHES ARE PERFORMED SINCE THE ROUTINE REMEMBERS THE ; NAME OF THE CURRENT HANDLER IN CORE. R5 IS LEFT POINTING AT ; THE CHARACTER THAT DELIMITED THE F.D. ; R1, R2, AND R4 ARE USED AS TEMPORARIES. ; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; GETHAN: MOV (PC)+,R3 ;USE DK: AS DEFAULT DEVICE .RAD50 /DK / JSR PC,FILE ;GET FILE DESCRIPTOR ; ENTRY FOR REL FILES FROM FRUN OVERLAY GETHAR: ADDR DEVSTS,SP ;POINT TO DEV STATUS BLOCK EMT 342 ;IS HANDLER PRESENT ?? BCS BADHAN ;ERROR - NO SUCH DEVICE TST (R0)+ ;IS IT A DIRECTORY DEVICE ? BPL BADHAN ;NO, THATS ILLEGAL TST 2(R0) ;IS HANDLER RESIDENT ?? BNE HANIN ;YES CMP #MAXHAN,@R0 ;WILL IT FIT ?? BLT BADHAN ;NO ADD #OLDHAN-,R0 ;POINT TO OLD HANDLER NAME .RELEAS ;RELEASE OLD HANDLER MOV @R3,OLDHAN ;SAVE NEW HANDLER NAME ADDR HANDLR,SP ;POINT TO HANDLER SPACE ON STACK MOV R3,R0 ;POINT TO F.D. EMT 343 ;FETCH THE NEW HANDLER BCS BADHAN ;THE DEVICE MAY HAVE A NAME, BUT NOT ;A DEVICE HANDLER HANIN: MOV R3,R0 ;POINT TO F.D. RTS7: RTS PC BADHAN: KMEROR .SBTTL SETBIT ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; ; SETBIT IS USED TO SET BITS IN THE CORE CONTROL BLOCK ; AND TO UPDATE (IF NECESSARY) THE USERTOP (TOP OF USER ; CORE) LOCATION OF THE PARAMETER BLOCK. IT IS CALLED ; WITH THE ADDRESS CORRESPONDING TO THE FIRST BIT TO ; BE SET IN R2. THE ENTRY POINT NAMED SETBTS ; IS USED WHEN A SEQUENCE OF BITS IS TO BE SET. IN THIS ; CASE, R4 CONTAINS THE ADDRESS CORRESPONDING TO THE ; LAST BIT TO BE SET. R0 SHOULD CONTAIN A POINTER ; TO THE CCB TO BE ALTERED. ; R0, R1, R2, AND R4 ARE USED BY THIS ROUTINE. ; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; SETBIT: MOV R2,R4 ;ONLY SET ONE BIT (LAST=FIRST) SETBTS: CMP @#USERTOP,R4 ;IS IT HIGHER THAN OLD TOP ?? BHI NOTHIR ;NO MOV R4,@#USERTOP ;YES, MAKE IT THE NEW TOP NOTHIR: BIS #777,R4 ;ROUND R4 TO TOP OF BLOCK DEC R4 ;ON A WORD BOUNDARY SUB R2,R4 ;GET ADDRESS DIFFERENCE CLRB R4 ;NOW MAKE THIS THE BIT COUNT - 1 SWAB R4 ASR R4 SWAB R2 ;MAKE THIS A BLOCK NUMBER SETBT2: ASR R2 MOV R2,R1 ;SAVE IT BIC #177407,R2 ;THIS BYTE IS INDEX INTO CCB (*20.) BIC #177770,R1 ;THIS IS BIT NUMBER WITHIN BYTE ASR R2 ;MAKE IT A BYTE INDEX INTO CCB ASR R2 ASR R2 ADD R0,R2 ;ADD ADDRESS OF DESIRED CCB ONEBIT: CLR R0 ;CLEAR MASK REGISTER SEC ;START WITH CARRY BIT SETMSK: RORB R0 ;ROTATE DEC R1 ;COUNT BPL SETMSK ;MASK NOT READY YET SETCCB: BISB R0,(R2) ;SET BIT IN CORRECT CCB DEC R4 ;ANY MORE BLOCKS (BITS) TO SET IN USE ? BMI RTS7 ;NO, RETURN RORB R0 ;SHIFT BIT AGAIN BCC SETCCB ;SET NEXT BIT IN THIS WORD INC R2 ;GO TO NEXT BYTE BR ONEBIT ;GO INITIALIZE PATTERN .SBTTL COMMAND LIST, STACK, AND HANDLER SPACE ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; THIS MACRO GENERATES A TABLE ENTRY FOR A RESIDENT KMON COMMAND .MACRO CTBL CMD .WORD CMD-XX .ENDM CTBL ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; THIS MACRO GENERATES A TABLE ENTRY FOR AN OVERLAY COMMAND ; THE ENTRY IS 1 BYTE OF OVERLAY #, AND 1 BYTE OF WORD OFFSET ; INTO THE OVERLAY .MACRO OTBL CMD .BYTE N.'CMD,O.'CMD/2 .ENDM OTBL COMLST: .ASCII " RUREG E D BTSERNI" .WORD 0 .WORD 0,0 ;ROOM FOR RAD 50 CONVERSION OCOMLS: .RAD50 /DAT/ .RAD50 /TIM/ .RAD50 /SAV/ .RAD50 /ASS/ .RAD50 /LOA/ .RAD50 /UNL/ .RAD50 /CLO/ .RAD50 /GT / .RAD50 /SET/ .IF NE BF .RAD50 /FRU/ .RAD50 /SUS/ .RAD50 /RSU/ .ENDC .IIF NDF BANDW, .NLIST .IF DF BANDW .IF NE BF .RAD50 /TEC/ .RAD50 /MAK/ .ENDC .ENDC .IIF NDF BANDW, .LIST .WORD 0 COMLSZ = . - COMLST CTBL R CTBL RUN CTBL GET CTBL E CTBL D CTBL B CTBL STARTK CTBL REENTR CTBL INIT OCOMSZ = . - OCOMLS OTBL DATE OTBL TIME OTBL SAVEK OTBL ASSIGN OTBL LOAD OTBL UNLOAD OTBL CLOSEK OTBL GT OTBL SET .IF NE BF OTBL FRUN OTBL SPND OTBL RSUME .ENDC .IIF NDF BANDW, .NLIST .IF DF BANDW .IF NE BF OTBL TECO OTBL MAKE .ENDC .ENDC .IIF NDF BANDW, .LIST OVLIOB: .WORD 0 ;BLOCK NUMBER CURRENTLY IN CORE .WORD 0 ;AREA TO READ INTO .WORD 400*OVLYSZ ;READ ONE OR TWO BLOCKS .WORD 0 ;WAIT I/O BASE: .WORD 0 GETCNT: .WORD 0 SAVSWT: .WORD 0 BLOKWG: .WORD 0 SYSIOB: BSS 3 ;BLOCK FOR SYSTEM I/O OLDHAN: .BLKW 1 ;OLD HANDLER NAME (USED BY GET) BLOCK: .BLKW 8. ;USED FOR SAVE STATUS AND F.D. BLOCK OVLY: .BLKW 400*OVLYSZ ;AREA FOR OVERLAYS HANDLR: .BLKW MAXHAN/2 ;HANDLER FOR GET, RUN, SAVE .BLKW 34. ;MINIMUM SIZE OF KMON STACK KMONSZ = .-KMON+777/1000 ;SIZE OF KMON IN BLOCKS KMSIZE = KMONSZ*1000 ;SIZE OF KMON IN BYTES KMLEN = KMONSZ*400 ;SIZE OF KMON IN WORDS . = KMON + KMSIZE ;ROUND US UP TO A BLOCK .IIF DF NLKMON, .LIST