ASMB,R,Q,C * NAME: EXEC * SOURCE: 92070-18136 * RELOC: 92070-16136 * PGMR: HLC * * * **************************************************************** * * (C) COPYRIGHT HEWLETT-PACKARD COMPANY 1979. ALL RIGHTS * * * RESERVED. NO PART OF THIS PROGRAM MAY BE PHOTOCOPIED, * * * REPRODUCED OR TRANSLATED TO ANOTHER PROGRAM LANGUAGE WITHOUT * * * THE PRIOR WRITTEN CONSENT OF HEWLETT-PACKARD COMPANY. * * **************************************************************** * * NAM EXEC,0 92070-16136 REV.2040 800715 * ENT EXEC ENT $A,$B,$BCOM ENT $BGBP,$BGRS,$BL,$BOOT ENT $CKSM,$CL,$CLCK,$CLTA ENT $CON,$CSEG,$CVT1,$CVT3,$DATC ENT $DISC,$DN,$DS1K ENT $DSCS,$DVT#,$DVTA ENT $EO,$ERAB,$EXEX ENT $FWBG,$FWRT,$HIBP ENT $HIGH,$ID#,$IDA ENT $IDNO,$IDSQ,$IDSZ ENT $IFT#,$IFTA,$INT#,$INTA ENT $LCOM,$LD,$LUT#,$LUTA ENT $LIBR,$LIBX,$LIST,$LK ENT $LOBP,$LOW,$MM ENT $MP,$MPFN,$N1.2 ENT $N3.4,$N5.F,$NAME ENT $OPSY,$OPXX,$PENT ENT $PIMK,$PNAM,$PRAM ENT $PRIO,$PVCN,$QU,$RES ENT $RLIB,$RN,$RNTA,$ROM,$RQCT ENT $RQP1,$RQP2,$RQP3 ENT $RQP4,$RQP5,$RQP6 ENT $RQP7,$RQP8,$RQP9 ENT $RQRT,$RTBP,$SAM ENT $SC,$SCHD,$SCXX ENT $SECT,$SISZ,$SR,$STAT ENT $STRT,$SUSP,$SWTA,$SYBP ENT $TDB,$TEST,$TIM1,$TIM2 ENT $TIME,$TLNK,$TM,$TMP1,$TMP2 ENT $TMP3,$TMP4,$TMP5 ENT $TRAK,$UIT,$WORK,$WRKS,$XEQ ENT $XEQ1,$XQSB,$XQT ENT $ZPCN,$ZZZZ * EXT $CVT,PI.43 EXT $DREL,$ERMG EXT $EX08 EXT $EX09,$EX10,$EX11 EXT $EX12,$EX14,$EX23 EXT $EX24,$EX28,$F.CL,$G.CL,$IORQ EXT $IRT,$LDRS,$MAX,$MPTF EXT $RTN,$RTNS,$STMG EXT $TLST,$TRRN,$WTSC,$XEQ2 * A EQU 0 B EQU 1 SC.00 EQU 0 SC.02 EQU 2 SC.03 EQU 3 SC.04 EQU 4 SC.06 EQU 6 SC.07 EQU 7 SKP * $DATC DEC 2040 REV. CODE OF OPERATING SYSTEM * EXEC RPL 101712B 'JSB EXEC' OP CODE EXECC OCT 101712 * * * * * BASE PAGE CONSTANTS * ORB JSBLR JSB $LIBR FORCES BASE PAGE LINKING DPOWR DEF PI.43 POWER FAIL/AUTORESTART DRIVER ORR * * * ID SEGMENT POINTERS OVERLAY SYSTEM INITIALIZATION CODE * $XQT NOP POINTERS TO CURRENTLY EXECUTING PROGRAM $TMP1 EQU $XQT+1 $TMP2 EQU $XQT+2 $TMP3 EQU $XQT+3 $TMP4 EQU $XQT+4 $TMP5 EQU $XQT+5 $PRIO EQU $XQT+6 $PENT EQU $XQT+7 $SUSP EQU $XQT+8 $A EQU $XQT+9 $B EQU $XQT+10 $EO EQU $XQT+11 $N1.2 EQU $XQT+12 $N3.4 EQU $XQT+13 $N5.F EQU $XQT+14 $STAT EQU $XQT+15 $TLNK EQU $XQT+16 $RES EQU $XQT+17 $TIM1 EQU $XQT+18 $TIM2 EQU $XQT+19 $LOW EQU $XQT+20 $HIGH EQU $XQT+21 $CSEG EQU $XQT+22 $LOBP EQU $XQT+23 $HIBP EQU $XQT+24 $SECT EQU $XQT+25 $TRAK EQU $XQT+26 $DISC EQU $XQT+27 $CON EQU $XQT+28 $TDB EQU $XQT+29 * * * EXEC REQUEST PARAMETERS * $RQCT EQU $XQT+30 $RQP1 EQU $XQT+31 $RQP2 EQU $XQT+32 $RQP3 EQU $XQT+33 $RQP4 EQU $XQT+34 $RQP5 EQU $XQT+35 $RQP6 EQU $XQT+36 $RQP7 EQU $XQT+37 $RQP8 EQU $XQT+38 $RQP9 EQU $XQT+39 $RQRT EQU $XQT+40 * * * SYSTEM INITIALIZATION CODE OVERLAID BY ID SEGMENT POINTERS * $STRT CLC SC.00,C MASTER RESET DST ASAVE LDA $PIMK OTA SC.00 SET INTERRUPT MASK LDA JSBPF SET TO ENTER POWER-FAIL DRIVER SFS SC.04 JMP *-2 WAIT FOR POWER TO STABILIZE STA SC.04 * LDA HLT.2 STA SC.02 PUT HALT IN LOCATION 2 LDA JMP.2 STA SC.03 LOOP FOREVER IF 2 IS EXECUTED * STF SC.00 ALLOW PRIVILEGED INTERRUPTS STC SC.06,C START TBG * * LDA $SAM STA SAM0 START OF SAM CMA,INA ADA $RLIB STA SAMSZ SIZE OF SAM CMA ONE'S COMPLEMENT OF STA $MAX MAXIMUM EVER AVAILABLE JSB $RTN INITIALIZE SAM SAM0 NOP SAMSZ NOP * * LDB $BOOT IS THERE A BOOT-UP PROGRAM? SZB,RSS JMP $STMG NO, PRINT THE STARTING MESSAGE * ADB =D9 LDA ASAVE STA B,I PASS ORIGINAL A & B REGS TO START INB LDA BSAVE STA B,I * LDB $BOOT JSB $LIST YES, SCHEDULE THE BOOT-UP PROGRAM OCT 60 JMP $STMG AND THEN PRINT THE MESSAGE * JSBPF JSB DPOWR,I IF LOCATION 4 IS ZERO, BOOTSTRAP FAILED * HLT.2 HLT 2 * JMP.2 JMP 2 * ASAVE NOP BSAVE NOP * * END OF SYSTEM INITIALIZATION AREA * * THE INITIALIZATION CODE MUST BE AT LEAST 40 * WORDS LONG TO ALLOW ROOM FOR THE ID SEGMENT * POINTERS AND EXEC REQUEST PARAMETERS * SIZE EQU *-$STRT-40 * * * * * SKP * * * * * THE FOLLOWING VALUES ARE INITIALIZED BY THE GENERATOR * $BCOM NOP START OF BLANK COMMON $BGBP NOP START OF BACKGROUND BASE PAGE $BGRS NOP BACKGROUND RESIDENT PROGRAM $BOOT NOP START-UP PROGRAM $CKSM NOP SYSTEM ENTRY POINT CHECKSUM $CLTA NOP START OF CLASS TABLE $DVT# NOP NUMBER OF DEVICE TABLES $DVTA NOP POINTER TO FIRST DEVICE TABLE $FWBG NOP START OF BACKGROUND AREA $FWRT NOP START OF REAL TIME AREA $ID# NOP NUMBER OF ID SEGMENTS IN SYSTEM $IDA NOP POINTER TO FIRST ID SEGMENT $IFT# NOP NUMBER OF INTERFACE TABLES $IFTA NOP POINTER TO FIRST INTERFACE TABLE $INT# NOP NUMBER OF INTERRUPT TABLE ENTRIES $INTA NOP POINTER TO THE INTERRUPT TABLE $LCOM NOP START OF LABELED COMMON $LUT# NOP NUMBER OF LU TABLE ENTRIES $LUTA NOP POINTER TO THE LU TABLE $PIMK NOP PRIVILEGED INTERRUPT MASK $RLIB NOP START OF MEMORY RESIDENT LIBRARY $RNTA NOP POINTER TO THE RESOURCE NUMBER TABLE $ROM NOP START OF ROM-RESERVED MEMORY $RTBP NOP START OF REAL TIME BASEPPAGE $SAM NOP START OF SYSTEM AVAILABLE MEMORY $SWTA NOP POINTER TO THE SWAP TABLE $SYBP NOP START OF SYSTEM BASE PAGE * * * END OF GENERATOR-INITIALIZED AREA * * * * $OPSY DEC -31 SYSTEM IDENTIFICATION $DSCS DEC -1 SESSION MONITOR SOFTWARE NOT AVAILABLE $IDSZ DEC 30 SIZE OF ID SEGMENT $SISZ DEC 8 SIZE OF SEGMENT IDENTIFIER $MPFN NOP CURRENT MEMORY PROTECT FENCE VALUE $PVCN NOP PRIVILEGED SUBROUTINE NESTING LEVEL $ZPCN NOP .ZPRV SUBROUTINE NESTING LEVEL $TEST NOP ID SEGMENT OF LAST PROGRAM DISPATCHED $WORK NOP ID SEGMENT OF LAST PROGRAM NAME FOUND $WRKS NOP STATUS ADDRESS OF LAST PROGRAM NAME FOUND $ZZZZ NOP ID SEGMENT OF LAST PROGRAM TERMINATED * * * * * * * * * PROGRAM LIST HEADERS * $TM NOP (47) TIME SUSPEND $LK NOP (50) LOCKED DEVICE LIST $RN NOP (51) RESOURCE NUMBER LIST $CL NOP (52) CLASS LIST $QU NOP (53) QUEUE LIST $DN NOP (54) DOWN DEVICE LIST $BL NOP (55) BUFFER LIMIT LIST $LD NOP (56) LOAD LIST $SR NOP (57) SHARED SUBROUTINE LIST $SC NOP (60) SCHEDULED LIST $MM NOP (61) MEMORY LIST * * * HED MEMORY PROTECT HANDLER * $MP NOP CLC SC.04 TURN OFF INTERRUPTS STA $A,I SAVE A LDA $PIMK OTA SC.00 MASK ALL NON-PRIVILEGED INTERRUPTS STC SC.04 TURN ON INTERRUPTS * INTERRUPTS HELD OFF UNTIL AFTER 'ISZ $MPTF' ISZ $MPTF INDICATE INTERRUPTS MASKED LIA SC.07,C VIOLATION ADDRESS STA $LIBR STA $SUSP,I POINT OF SUSPENSION ISZ A CPA $MP JMP MPERR NOT A JSB * LDA $MP DESTINATION OF VIOLATING JSB CPA LIBRA JMP OK JSB $LIBR CPA LIBXA JMP OK JSB $LIBX LDA A,I CPA JSBLR JMP OK JSB TO RESIDENT LIBRARY MPERR LDA =AMP ERMSG LDB =A JSB $ERMG PRINT 'PROGA ABORTED MP 37732' JMP $XEQ * LIBRA DEF $LIBR+1 LIBXA DEF $LIBX+1 * * HED MEMORY RESIDENT LIBRARY ENTRY AND EXIT * * $LIBR NOP STA $A,I LDA $LIBR,I SZA JMP ZPRV? ISZ $PVCN LEAVE MEMORY PROTECT OFF BUMPL ISZ $LIBR AND MASK NON-PRIVILEGED INTERRUPTS OK LDA $A,I RESTORE A JMP $LIBR,I * * ZPRV? SSA,RSS JMP ZRNT? ISZ $ZPCN DO NOT DISPATCH ANY OTHER PROGRAM LDA $PVCN SZA JMP BUMPL MEMORY PROTECT IS OFF JSB SAVEB SAVE B, E, AND O REGISTERS BUMPS LDA $LIBR INA STA $SUSP,I ENTRY POINT TO SUBROUTINE LDA $RLIB SET MEMORY PROTECT FENCE JMP FENCE TO BASE OF LIBRARY * * SAVEB NOP SAVE B, E, AND O REGISTERS STB $B,I ERB,BLS SOC INB STB $EO,I JMP SAVEB,I * * ZRNT? JSB SAVEB SAVE B, E, AND O REGISTERS * * MAKE SURE THE TDB IS IN SYSTEM COMMON * OR THE RESIDENT LIBRARY * LDB $RLIB DETERMINE THE SIZE OF SYSTEM COMMON CMB,INB AND THE RESIDENT LIBRARY ADB $FWRT STB SC# * LDB $RLIB CMB,INB ADB A SSB JMP SRER1 STARTS BELOW RESIDENT LIBRARY * CMB ADB SC# SSB JMP SRER1 STARTS ABOVE SYSTEM COMMON * LDB $RLIB ADB SC# CMB ADB =D3 (SIZE OF TDB HEADER) ADB A SSB,RSS JMP SRER1 EXTENDS PAST END OF SYSTEM COMMON * LDB $ZPCN ADB $PVCN SZB JMP SRER1 ILLEGAL SUBROUTINE CALL ADA D2 LDB A,I GET RETURN ADDRESS FROM TDB SZB,RSS JMP ENTER SUBROUTINE NOT OCCUPIED LDB $XQT JSB $LIST SUSPEND HIM OCT 57 JMP $XEQ * * ENTER LDB $LIBR ADB =D-2 LDB B,I GET SUBROUTINE RETURN ADDRESS STB A,I AND SAVE IT IN THE TDB LDA $LIBR,I LDB $TDB,I STB A,I UPDATE LIST OF TDB'S STA $TDB,I STARTING IN ID SEGMENT JMP BUMPS BUMP THE POINT OF SUSPENSION * * SRER1 LDA $LIBR UPDATE THE POINT OF SUSPENSION RSS SRER2 LDA $LIBX ADA =D-1 STA $SUSP,I SRER3 LDA =ASR JMP ERMSG PRINT 'PROGA ABORTED SR 34475' * * SC# NOP * SKP * * $LIBX NOP EXIT FROM LIBRARY ROUTINE STA $A,I SAVE A LDA $LIBX,I SSA JMP ZPEX? .ZPRV ROUTINE DONE LDA $PVCN SZA,RSS JMP ZREX? INTERRUPTS ARE ON CMA,INA INTERRUPTS ARE OFF CMA,SZA,RSS SUBTRACT 1 WITHOUT AFFECTING E AND O JMP PVEX NEED TO RESTORE INTERRUPTS STA $PVCN STILL IN PRIVILEGED ROUTINE LDA $LIBX,I LDA A,I STA $LIBR GET RETURN ADDRESS JMP OK * * PVEX STA $PVCN NESTING COUNT IS ZERO JSB SAVEB SAVE B, E, AND O LDA $LIBX,I LDA A,I STA $SUSP,I SAVE POINT OF SUSPENSION JMP $IRT RESTORE INTERRUPTS * * ZPEX? ELA,CLE,ERA CLEAR INDIRECT BIT LDA A,I STA $LIBR RETURN ADDRESS LDA $ZPCN SZA,RSS JMP SRER2 EXIT BEFORE ENTRY CMA,INA SUBTRACT ONE WITHOUT CHANGING E & O CMA STA $ZPCN LDA $PVCN SZA JMP OK INTERRUPTS OFF JSB SAVEB SAVE B, E, AND O REGISTERS LDA $LIBR STA $SUSP,I ADVANCE POINT OF SUSPENSION JMP $XEQ * * ZREX? JSB SAVEB SAVE B, E, AND O REGISTERS LDB $ZPCN LDA $TDB,I CPA $LIBX,I SZB MUST NOT BE PRIVILEGED JMP SRER2 ILLEGAL EXIT ORDER ADA D2 LDA A,I ISZ $LIBX ADD CONSTANT TO RETURN ADDRESS ADA $LIBX,I STA $SUSP,I SAVE POINT OF SUSPENSION LDA $TDB,I JSB POP UNLOCK TOP ROUTINE ON STACK JMP ZREX SET UP FENCE * * POP NOP UNLOCK LAST ENTERED REENTRANT ROUTINE LDB A,I STB $TDB,I UPDATE POINTER IN ID SEGMENT ADA D2 CLB STB A,I CLEAR RETURN ADDRESS (LOCK FLAG) JSB $SCHD SCHEDULE WAITERS FOR THIS ROUTINE OCT 57 JMP POP,I * HED UNIMPLEMENTED INSTRUCTION HANDLER * $UIT NOP UNIMPLEMENTED INSTRUCTION TRAP CLC SC.04 TURN OFF INTERRUPTS STA $A,I SAVE A-REGISTER LDA $PIMK OTA SC.00 PRIVILEGED INTERRUPT MASK STC SC.04 RESTORE INTERRUPTS ISZ $MPTF INDICATE THAT MEMORY PROTECT IS OFF * * INTERRUPTS ARE HELD OFF UNTIL AFTER 'ISZ $MPTF' * JSB SAVEB SAVE B, E, AND O REGISTERS CCA ADA $UIT STA $SUSP,I SAVE ADDRESS OF VIOLATION LDA A,I CPA EXECC JMP EXECP PROCESS 'JSB EXEC' LDA =AUI JMP ERMSG PRINT 'PROGA ABORTED UI 56111' * * HED EXEC CALL PROCESSOR * * EXECP LDA $PVCN IOR $ZPCN SZA JMP SRER3 ILLEGAL SUBROUTINE CALL LDA $UIT,I ISZ $UIT STA $RQRT SAVE RETURN ADDRESS LDB $UIT CMB,CLE ADB A STB $RQCT NUMBER OF PARAMETERS STB A CMB,SEZ,RSS JMP RQERR BAD NO. OF PARAMETERS OR RETURN ADDRESS CLE ADA =D-9 CLA,SEZ JMP RQERR BAD NO. OF PARAMETERS OR RETURN ADDRESS STA $RQP2 STA $RQP3 STA $RQP4 STA $RQP5 STA $RQP6 STA $RQP7 STA $RQP8 STA $RQP9 * * *CHECK LEGALITY OF REQUEST CODE * LDA $UIT,I REMOVE THE 'NS' (NO-SUSPEND) BIT LDA A,I AND =B137777 FROM THE REQUEST CODE LDB A * LDA $STAT,I RBL,CLE,SLB,ERB CHECK ABORT OPTION BIT JMP NO.AB NO ABORT AND =B137777 CLEAR 'NA' BIT RQP1 STB $RQP1 SAVE THE REQUEST CODE. STA $STAT,I AND THE 'NA' BIT SZB IF ZERO SKIP TO REJECT ADB CODE# IF RQUEST CODE IS NOT DEFINED SSB,RSS -THEN JMP RQERR UNDEFINED EXEC REQUEST CODE * ADB RQTBL GET ADDRESS OF PROCESSOR TO A LDA B,I GET ADDRESS * STA NEXT SAVE THE ADDRESS * * RELEASE STRING IF NOT REQUESTED * * LDA $STAT,I RAL,RAL SSA,RSS JMP NORTN NO STRING (OR 'SAVST' WAS CALLED) LDB $RQP1 CPB =D14 JMP NORTN EXEC 14, SAVE STRING CPB =D8 JMP NORTN EXEC 8, SAVE STRING LDB $XQT JSB $RTNS DISCARD STRING * NORTN LDB DRQP2 ADDRESS OF SECOND PARAMETER STB POP LDA $RQCT CMA,INA,SZA,RSS JMP NEXT,I JUMP TO PROCESSOR STA TEMP * LDB $RQP1 USE REQUEST CODE CLE,ERB TO INDEX INTO ADB RQTBL THE BY NAME TABLE LDB B,I GET THE FLAG WORD SEZ,RSS BLF,BLF PROPER BYTE * R2D2 ISZ $UIT LDA $UIT GET ADDR OF PARAM ADDR R1D1 LDA A,I GET ACTUAL PARAM ADDR SZA CPA =D1 IS IT POINTING TO A OR B REGS? JMP MPERR YES, REGISTERS CANNOT BE EXEC PARAMETERS RAL,CLE,SLA,ERA INDIRECT? JMP R1D1 GO GET DIRECT ADDR * STA POP,I SAVE DIRECT ADDR CMA,CLE READY TO SUBTR FROM FENCE SLB,RBR NEED TO TEST AGAINST MP FENCE? ADA $MPFN YES, SUBTRACT SEZ. SEZ PARAM ADDR < FENCE? JMP MPERR MEMORY PROTECT ERROR * ISZ POP NEXT PARAMETER ISZ TEMP DONE YET? JMP R2D2 NO JMP NEXT,I YES, DO THE REQUEST * * NO.AB IOR =B40000 SET 'NA' BIT ISZ $RQRT AND BUMP RETURN ADDRESS JMP RQP1 * * * * RQERR LDA =ARQ JMP ERMSG PRINT 'PROGA ABORTED RQ 57622' * * CODE# ABS TBL-TBLE-1 NEGATIVE OF NUMBER OF REQUEST+1 RQTBL DEF TBLE ADDRESS INDIRECT OF LAST + 1. DRQP2 DEF $RQP2 * * HED * EXEC -- REQUEST CODE TABLE * *** REQUEST CODE TABLE *** * * EACH WORD CONTAINS THE ENTRY POINT ADDRESS * OF THE PROCESSOR CORRESPONDING TO THE REQUEST CODE. * TBL DEF $IORQ CODE 1 I/O READ DEF $IORQ CODE 2 I/O WRITE DEF $IORQ CODE 3 I/O CONTROL DEF RQERR CODE 4 (DISC TRACK ALLOCATION) DEF RQERR CODE 5 (DISC TRACK RELEASE) DEF EX06 CODE 6 PROGRAM COMPLETION DEF EX07 CODE 7 OPERATOR SUSPENSION DEF $EX08 CODE 8 LOAD PROGRAM SEGMENT DEF $EX09 CODE 9 SCHEDULE WITH WAIT DEF $EX10 CODE 10 SCHEDULE PROGRAM DEF $EX11 CODE 11 REAL TIME/DATE DEF $EX12 CODE 12 TIME SCHEDULE DEF $IORQ CODE 13 I/O DEVICE STATUS DEF $EX14 CODE 14 PARAMETER STRING DEF RQERR CODE 15 (GLOBAL TRACK ASSIGNMENT) DEF RQERR CODE 16 (GLOBAL TRACK RELEASE) DEF $IORQ CODE 17 READ CLASS I/O DEF $IORQ CODE 18 WRITE CLASS I/O DEF $IORQ CODE 19 CONTROL CLASS I/O DEF $IORQ CODE 20 WRITE-READ CLASS I/O DEF $G.CL CODE 21 GET CLASS I/O DEF $EXEX CODE 22 SWAP/CORE USAGE REQUEST DEF $EX23 CODE 23 SCHEDULE WITH WAIT/WAIT DEF $EX24 CODE 24 SCHEDULE NO WAIT/WAIT DEF RQERR CODE 25 (PARTITION STATUS) DEF RQERR CODE 26 (MEMORY STATUS) DEF RQERR CODE 27 (UNDEFINED) DEF $EX28 CODE 28 PROGRAM LOAD * * * -ADDITIONAL REQUESTS MAY BE INSERTED * AT THIS POINT. * -ALSO ADD AN ENTRY TO THE NAME TABLE FOR EACH * ADDITIONAL REQUEST SKP * * THE NAME TABLE WHICH FOLLOWS CONTAINS A BIT FOR EACH PRAMETER * IN AN EXEC CALL WHICH SHOULD BE CALLED BY NAME...THAT IS * THE SYSTEM WILL NORMALLY STORE INTO THE LOCATION DEFINED * BY THE PRAMETER. THIS TABLE IS USED TO CHECK SUCH * PRAMETERS TO SEE IF THEY ARE ABOVE THE CURRENT * FENCE ADDRESS. * * 8 BITS ARE DEVOTED TO EACH CALL. THE LEAST BIT REFERS * TO PRAMETER NUMBER TWO AND SO ON. * THE 'L' AND 'H' NUMBERS ARE SET UP TO REFER TO EACH * PRAMETER BY NUMBER WHERE L REFERS TO THE LOW OR ODD * CALL FOR EACH WORD AND H REFERS TO THE HIGH OR EVEN CALL. * H = HIGH(EVEN CALL) * L = LOW(ODD CALL) * TBLE EQU * END OF JUMP TABLE, START OF BIT TABLE * D2 ABS L3 0/1 (READ BUFFER) ABS 0 2/3 ABS 0 4/5 ABS 0 6/7 ABS 0 8/9 ABS L2+L3 10/11 (TIME VALUES) ABS L3+L4+L5 12/13 (STAT RETURN) ABS H3 14/15 (STRING BUFFER) ABS L7 16/17 (CLASSWORD) ABS H7+L4 18/19 (CLASSWORD) ABS H7+L3+L5+L6+L7 20/21 (CLASSWORD,BUFFER,AND OPT PRAMS) ABS 0 22/23 ABS 0 24/25 ABS 0 26/27 ABS 0 28/29 SPC 2 L2 EQU 1 L3 EQU 2 L4 EQU 4 L5 EQU 10B L6 EQU 20B L7 EQU 40B L8 EQU 100B H2 EQU 400B H3 EQU 1000B H4 EQU 2000B H5 EQU 4000B H6 EQU 10000B H7 EQU 20000B H8 EQU 40000B HED EXEC 7 PROCESSOR (PAUSE) * * EX07 LDB $XQT JSB $LIST SUSPEND CURRENT PROGRAM OCT 7 JMP $EXEX DONE * * * * EX06 LDB $XQT JSB $PRAM PASS PARAMETERS TO CALLER DEF $RQP4,I CLA LDA $RQP3,I CPA =D1 JMP SAVER SAVE RESOURCES TERMINATION LDA $XQT STA $ZZZZ NORMAL TERMINATION JSB $F.CL SOFT TERMINATION OF CLASS I/O NOP JMP $EXEX * * SAVER JSB $WTSC SCHEDULE WAITING PROGRAMS * $EXEX LDA $RQRT STA $SUSP,I ADVANCE POINT OF SUSPENSION * * FALL THROUGH TO $XEQ * HED DISPATCHER * * $XEQ LDB $ZZZZ SZB JMP ABORT PROGRAM TERMINATED, CLEAN IT UP CPB $LIST JMP $IRT NO NEW PROGRAMS IN SCHEDULED LIST LDA $ZPCN SZA JMP ZP DISPATCH CURRENT PRIVILEGED PROGRAM STA $LIST LDA $SC TOP OF LIST XEQ1 STA $TEST SZA,RSS JMP IDLE CANNOT DISPATCH ANY PROGRAM NOW ADA =D15 LDA A,I STATUS LDB $TEST SSA,RSS TEST 'MR' BIT JMP $XEQ2 PROGRAM NOT IN MEMORY JSB $IDSQ SET UP POINTERS TO ID SEGMENT JSB $DREL RELEASE ANY SWAP TRACKS OWNED LDA $SUSP,I LDB $PENT,I SZA,RSS STB $SUSP,I FIRST DISPATCH, SET POINT OF SUSPENSION ZREX LDA $RLIB POSSIBLE MP FENCE VALUE LDB $TDB,I SZB JMP FENCE REENTRANT SUBROUTINE IN CONTROL LDA $LOW,I LDB $STAT,I BLF SSB LDA $LCOM PROGRAM ACCESSES SYSTEM COMMON FENCE OTA SC.07 STA $MPFN SAVE FENCE VALUE JMP $IRT RESTORE INTERRUPTS * * * ZP LDB $TEST JSB $IDSQ SET UP POINTERS TO ID SEGMENT JMP $IRT GO DISPATCH IT * $XEQ1 LDA $TEST,I NEXT PROGRAM IN LIST JMP XEQ1 * SKP * IDLE STA $XQT LDB DUMID SET UP POINTERS TO DUMMY ID STB $SUSP FOR REGISTER SAVE INB STB $A STB $B STB $EO JMP FENCE DROP FENCE TO ZERO * JSTAR ASL 16 JMP JSTAR * DUMID DEF *+1 DEF JSTAR OCT 0 REGISTERS FOR IDLE LOOP OCT 0 * * $IDSQ NOP SET UP POINTERS TO ID SEGMENT CPB $XQT JMP $IDSQ,I ASSUME ALL SET IF FIRST IS SET LDA DXQT IDSQL STB A,I CPA DTDB JMP $IDSQ,I DONE INB INA JMP IDSQL DXQT DEF $XQT DTDB DEF $TDB * * HED PROGRAM TERMINATION PROCESSOR * ABORT JSB $IDSQ SET UP POINTERS TO ID $DS1K NOP DISTRIBUTED SYSTEMS ABORT PROCESSOR JSB $WTSC SET PROGRAM DORMANT AND SCHEDULE WAITERS LDA $STAT,I ALF,ALF SLA,RSS JMP NORM NORMAL TERMINATION LDB $XQT JSB $PRAM ABORT, CLEAR PARAMETERS DEC 0 NORM CLA STA $SUSP,I STA $ZZZZ LDB $XQT CPB $TEST STA $ZPCN THE CURRENT PRIVILEGED PROGRAM WAS ABORTED JSB $RTNS RELEASE ANY OWNED STRING JSB $TRRN RELEASE ANY OWNED OR LOCKED RN'S LDA $HIGH,I STA $CSEG,I RESET START OF FREE MEMORY (CLEAR AM BIT) LDA $STAT,I AND =B167377 CLEAR THE 'BR' AND 'OF' BITS LDB $DISC,I IF THE PROGRAM WAS LOADED FROM THE DISC, SZB RAL,CLE,ERA CLEAR THE 'MR' BIT LDB $RES,I BLF,ERB T BIT IN E-REG CME LDB $STAT,I BLF,RBL ID BIT IN SIGN SEZ,SSB SKIP IF ID BIT NOT SET, OR IN TIME LIST JMP IDCLR CLEAR ID SEGMENT STA STA $STAT,I ELA 'MR' BIT IN E-REG LDA $XQT IF THE ABORTED PROGRAM XOR $BGRS IS THE BACKGROUND RESIDENT SEZ,SZA,RSS AND ITS 'MR' BIT IS CLEAR STA $BGRS CLEAR THE BACKGROUND RESIDENT FLAG JSB $DREL RELEASE ANY OWNED SWAP TRACKS RELP LDA $TDB,I CLEAR ANY LOCKED REENTRANT ROUTINES SZA,RSS JMP *+3 NO MORE JSB POP CLEAR ONE SUBROUTINE JMP RELP LDA $CON,I ADA =B10000 INCREMENT SEQUENCE COUNT STA $CON,I JMP $XEQ * IDCLR CLA STA $N1.2,I STA $N3.4,I STA $N5.F,I JMP STA * * * HED LIST PROCESSOR * $LIST DEC 1 NON-ZERO FOR BOOT-UP STB ID SET UP POINTERS TO ID SEGMENT INB STB TEMP ADB =D5 STB PRIO ADB =D9 STB STAT STA B LDA $LIST,I CPA B60 JMP SCHD SCHEDULE REQUEST SSA JMP PRSW PRIORITY SWITCH AND B60 CPA =B40 IF STATE 40-57, STB TEMP,I STORE RESOURCE IDENTIFIER NOSW LDA $LIST,I SWTCH STA TEMP NEW STATE LDA STAT,I AND =B77 STA B B=OLD STATE XOR STAT,I IOR TEMP STA STAT,I AND =B77 A=NEW STATE * RRR 5 SLB SKIP IF OLD STATE 0-37 (NOT LINKED) JMP REMOV REMOVE FROM OLD STATE ADCHK SLA SKIP IF NEW STAT 0-37 (NOT LINKED) JMP ADD ADD TO NEW STATE LIST EXIT ISZ $LIST JMP $LIST,I * * SKP * REMOV RRL 5 ADB LIS0 POINTER TO LIST HEADERS RLP STB TEMP LDB B,I CPB ID RSS FOUND IT, REMOVE FROM LIST JMP RLP KEEP LOOKING LDB B,I STB TEMP,I RRR 5 JMP ADCHK * * ADD RRL 5 ADA LIS0 POINTER TO LIST HEADERS ADLP STA TEMP LDA A,I SZA,RSS JMP ADDIT END OF LIST, ADD IT HERE STA B ADB =D6 LDB B,I COMPARE PRIORITIES CMB,INB ADB PRIO,I SSB,RSS JMP ADLP KEEP LOOKING ADDIT STA ID,I LDA ID STA TEMP,I LINK IT IN JMP EXIT DONE * * ID NOP TEMP NOP PRIO NOP STAT NOP LIS0 DEF $SC-60B POINTER TO LIST HEADERS * SKP * * SCHD LDA STAT,I CHECK OF AND SS BITS ALF,ALF SLA JMP OF OF BIT SET, ABORT HIM SSA,RSS JMP NOSW RAL,CLE,ERA CLEAR SS BIT ALF,ALF POSITION IT STA STAT,I LDA =B6 NEW STATE 6 JMP SWTCH * OF LDB ID SET TO ABORT CPB $LDRS RSS UNLESS BEING SWAPPED STB $ZZZZ CLA,INA FORCE TO 'AB' STATE (1) JMP SWTCH MAKE IT DORMANT * * PRSW STB PRIO,I STORE NEW PRIORITY LDA STAT,I RE-LINK IN OLD STATE BY NEW PRIORITY AND =B77 JMP SWTCH * * HED PARAMETER PASSING * $PRAM NOP STORE PARAMETERS IN ID SEGMENT INB STB ID DESTINATION ADDRESS ADB =D9 LDA ID STA B,I SET B-REG TO POINT TO TEMPS LDA =D-5 STA TEMP LDB $PRAM,I SOURCE ADDRESS ISZ $PRAM PLP CLA LDA B,I IF THE ADDRESS IS ZERO, STA ID,I STORE ZERO ISZ ID BUMP THE DESTINATION ADDRESS SZB IF THE ADDRESS IS ZERO, DON'T CHANGE IT INB BUMP THE SOURCE ADDRESS ISZ TEMP JMP PLP JMP $PRAM,I * * HED SCHEDULING OF SUSPENDED PROGRAMS * $SCHD NOP SCHEDULE ALL PROGRAMS WAITING FOR RESOURCE STA RES SAVE RESOURCE IDENTIFIER LDB $SCHD,I ISZ $SCHD ADB LIS0 POINTER TO LIST HEADERS SLP LDB B,I SZB,RSS JMP $SCHD,I END OF LIST LDA B INA LDA A,I COMPARE RESOURCE IDENTIFIERS CPA RES RSS JMP SLP LDA B,I STA NEXT SAVE POINTER TO NEXT PROGRAM JSB $LIST SCHEDULE IT B60 OCT 60 LDB NEXT JMP SLP+1 * * HED SCHEDULING OF DORMANT PROGRAMS * $XQSB NOP SCHEDULE THE PROGRAM IF IT IS DORMANT LDB $XQSB,I ISZ $XQSB STB RES POINTER TO PROGRAM NAME LDB $XQSB,I ISZ $XQSB STB NEXT POINTER TO PARAMETERS JSB $NAME FIND ID SEGMENT ADDRESS RES NOP SZA JMP OUT NOT DORMANT OR NOT FOUND * LDA B ADA =D27 INDEX TO DISC LU LDA A,I AND =B377 SZA,RSS JMP MEM IN MEMORY ONLY, NOT ON DISC * ADA =D-1 ADA $LUTA LDA A,I DVT ADDRESS ADA =D5 LDA A,I RAL SSA JMP OUT DISC LU FOR THIS PROGRAM IS DOWN * MEM JSB $LIST SCHEDULE IT OCT 60 LDB $WORK JSB $PRAM PASS PARAMETERS NEXT NOP LDB $WORK LDA $XQSB,I SZA,RSS JMP OUT DO NOT CHANGE TERMINAL LU ADB =D28 LDA B,I AND =B177400 MASK OLD LU IOR $XQSB,I AND INCLUDE NEW LU STA B,I CLA LDB $WORK OUT ISZ $XQSB JMP $XQSB,I * * HED FIND PROGRAM NAME * $NAME NOP SEARCH ID SEGMENTS LDB $NAME ISZ $NAME LDB B,I RBL,CLE,SLB,ERB REMOVE INDIRECT REFERENCES JMP *-2 SZB,RSS JMP NOTFN NO NAME PASSED STB ID INB STB PRIO INB LDA B,I AND =B177400 STA STAT LDB $IDA ADDRESS OF FIRST ID SEGMENT NLP STB $WORK ADB =D12 LDA B,I CPA ID,I SZA,RSS ZERO IF NO PROGRAM IN THIS ID JMP NEXTP NOT THIS ONE INB LDA B,I CPA PRIO,I INB,RSS SO FAR, SO GOOD JMP NEXTP NOT THIS ONE LDA B,I AND =B177400 CPA STAT JMP FND FOUND IT! NEXTP LDB $WORK ADB $IDSZ CPB $SWTA END OF TABLE? CLB,RSS YES JMP NLP TRY NEXT ID NOTFN CCA JMP $NAME,I * * FND INB STB $WRKS LDA B,I AND =B77 STATUS IN A LDB $WORK ID SEGMENT ADDRESS IN B JMP $NAME,I * HED INTEGER TO ASCII CONVERSION * * * INTEGER TO ASCII CONVERSION * RESULTS IN $CVT, $CVT+1, AND $CVT+2 * LEADING 0'S SUPPRESSED * $CVT3 NOP STB STAT SAVE B-REG LDB DCVT2 INIT LOCATION OF BUFFER STB TEMP LDB =A SET BUFFER=ASCII =A 'S STB $CVT STB $CVT+1 STB $CVT+2 LDB =D8 ASSUME BASE EIGHT SEZ LDB =D10 SET UP FOR BASE TEN STB PRIO SET CONVERSION PRIO ADDRESS CLE DPCRL CLB START CONVERSION DIV PRIO DIVIDE BY PRIO ADB =B20 CONVERT TO ASCII-BLANK SEZ IF HIGH DIGIT BLF,BLF ROTATE ADB TEMP,I ADD CURRENT VALUE STB TEMP,I STORE THE CONVERTED VALUE CCB,SEZ PREPARE FOR SUBTRACT ADB TEMP IF HIGH CHAR. BACKUP SEZ STB TEMP THE BUFFER POINTER CME,SZA IF MORE DIGITS JMP DPCRL GO SET THE NEXT ONE * CCE LDA DCVT LDB STAT RESTORE B JMP $CVT3,I RETURN * DCVT DEF $CVT DCVT2 DEF $CVT+2 * * $CVT1 NOP RETURN LEAST SIGNIFICANT 2 DIGITS IN A-REG JSB $CVT3 CONVERT TO ASCII LDA $CVT+2 JMP $CVT1,I * * HED NUMERIC ERROR MESSAGES * * ABORT WITH NUMERIC ERROR MESSAGE * $OPXX LDA =AOP OPTIONAL EXEC CALL NOT PRESENT LDB $RQP1 RSS $SCXX LDA =ASC SCHEDULING ERROR $ERAB SWP DECIMAL CONVERSION, PUT VALUE IN A CCE JSB $CVT1 CONVERT NUMBER TO ASCII IOR =B10000 CHANGE LEADING SPACE TO ZERO SWP JSB $ERMG ABORT PROGRAM JMP $XEQ * * * * HED CONVERSION OF ID SEG NO. TO ID ADDRESS * $IDNO NOP CONVERT NUMBER TO ADDRESS LDA $IDA CMA,INA ADA B CLB DIV $IDSZ INA STA B JMP $IDNO,I * * HED MOVE PROGRAM NAME TO BUFFER * $PNAM NOP MOVE PROGRAM NAME TO BUFFER LDA $PNAM,I ISZ $PNAM STA TEMP ADDRESS OF BUFFER ADB =D12 LDA B,I FIRST TWO CHARS STA TEMP,I INB ISZ TEMP LDA B,I THIRD & FOURTH CHARS STA TEMP,I INB ISZ TEMP LDA B,I LAST CHAR ALF,ALF LDB =A RRL 8 PUT BLANK IN LOW BYTE STA TEMP,I JMP $PNAM,I * * HED TBG INTERRUPT PROCESSING * $CLCK EQU * ISZ $TIME JMP $TLST CHASE TIME LIST ISZ $TIME+1 BUMP TIME JMP $TLST CHASE TIME LIST LDA RS1 RESET THE COUNTER LDB RS2 TO THE FULL STA $TIME DAY'S WORTH OF STB $TIME+1 TENS OF MS ISZ $TIME+2 NEXT DAY LDA $TIME+2 CLB,CLE DIV =D366 COMPUTE YEAR AND =B3 ADB =D-365 SEZ,SZA IF DAY 365 AND NOT LEAP YEAR ISZ $TIME+2 MAKE UP FOR FEB 29 JMP $TLST CHASE TIME LIST * * $TIME OCT 25000 NUMBER OF TBG TICKS UNTIL MIDNIGHT OCT 177574 (2-WORD NEGATIVE INTEGER) NOP (YEAR - 1976) * 366 + (DAYS SINCE JAN 1) * RS1 OCT 25000 RS2 OCT 177574 * END