IDENT SUBPROC ERR SORRY. SEE VV TITLE SUBPROCESS OPERATIONS TITLE SUBPROCESS CREATION * THIS ROUTINE CREATES A SUBPROCESS * INTSYS XTEXT PROCSYM XTEXT SPACE 5 EXT E.ECS,DISASTR EXT REFER,ENDSYS,REALLOC,MAPOUT,MAPIN EXT S.USRB1,S.USERA,SYSRET WECS MACRO A + WE A RJ E.ECS WECS ENDM RECS MACRO A + RE A RJ E.ECS RECS ENDM FATHPTR EQU P.TEMP5 INCORE EQU P.TEMP6 PATH EQU P.TEMP7 CLIST EQU P.SCR2+5 ECSMAC XTEXT CBLOCK MICRO 1,,*/ESUBP/* ORG 0 * PARAMETER MNEUMONICS SP.CLCD BSS 2 SUBPROCESS NAME (CLASS CODE) SP.FACC BSS 2 NAME OF SUBPROCESS FATHER(CLASS CODE) SP.MAP BSS 1 NUMBER OF MAP ENTRIES SP.COMP BSS 1 SPACE FOR COMPILED MAP SP.FL BSS 1 SUBPROCESS FIELD LENGTH SP.ENTRY BSS 1 SUBPROCESS ENTRY POINT SP.CLIST BSS 2 SUBPROCESS LOCAL C-LIST USE * SPACE 5 * ECSCODE MKSUB CRESUBP SA3 B1+P.PARAM+SP.CLCD+1 TEST FOR DUPLICATE SUBPROCESS SB7 CRESUB1 NAME JP FINDSUBP CRESUB1 SB6 A5-B1 SB7 A6-B1 NE B6,B7,CRESUB26 ERROR..DUPLICATE SUBPROCESS NAME * SA3 B1+P.PARAM+SP.FACC+1 FIND SUBPROCESS FATHER SB7 CRESUB2 JP FINDSUBP CRESUB2 SB6 A5-B1 SB7 A6-B1 EQ B6,B7,CRESUB27 ERROR - NO SUCH SUBP * SA1 A5-1 WD 0 OF FATHER SX6 B6-1 SAVE OLD POINTER TO FATHER SA6 B1+FATHPTR LX1 6+18 SA4 B1+P.PARAM+SP.FL SX1 X1 RA+FL OF FATHER IX1 X1+X4 RA+FL OF NEW SUBP SA3 B1+P.ROHEAD CHECK FOR INCREASE OF INCORE SX6 X3 PROCESS SIZE IX6 X1-X6 PL X6,CRESUB3 JP IF INCREASE BX6 X6-X6 CRESUB3 SA6 B1+INCORE NG X4,CRESUB34 ERROR - SUBP FL NEGATIVE * SA1 B1+P.PARAM+SP.ENTRY TEST SUBP ENTRY POINT SX2 X1-6 NG X2,CRESUB28 ERROR-ENTRY POINTLESS THAN 6 IX1 X1-X4 PL X1,CRE28X .ERROR-ENTRY .GE. FL * SA1 A5+5 CHECK OF INCREASED FULL C-LIST SA2 B1+P.STACK TABLE SX1 X1 MAX STACK PTR (FATHER) LX2 6+18 SX2 X2 END OF STACK POINTER IX1 X2-X1 LX1 60-1 SX1 X1+1 PATH LENGTH FROM ROOT THRU NEW SUBP SA2 B1+P.CTABLE SUBP LX2 6+36 SX2 X2 MAX PATH IN C-LIST TABLE IX1 X2-X1 BX6 X6-X6 PL X1,CRESUB4 JP IF NO EXPANSION SX6 2 CRESUB4 SA6 B1+PATH * SA1 B1+P.PARAM+SP.COMP SX1 X1 SX2 X1-3 NG X2,CRESUB31 * * COMPUTE ADDITIONAL SPACE NEEDED SA2 B1+P.PARAM+SP.MAP SX3 X2 BX2 X3 LX3 1 SX4 X2-1 NG X4,CRESUB35 ERROR - LESS THAN 1 MAP ENTRY IX3 X2+X3 IX1 X1+X3 LOGICAL MAP + COMP MAP (ALMOST) SX1 X1+1+1+8 ADD END OF MAP, SUBPROCESS SA2 B1+PATH DISCRIPTOR AND ESM IX1 X1+X2 X1=ADDITIONAL ECS NEEDED * SA2 B1+P.PARAM+SP.CLIST+1 COMPUTE LENGTH OF LOCAL C-LIS SX0 X2 SA0 B1 + RE 1 READ MOT RJ E.ECS SA3 A0 MX6 39 BX2 X2-X3 CHECK UNIQUE NAME BX2 X6*X2 NZ X2,CRESUB33 BX0 -X6*X3 + RE 1 READ LENGTH RJ E.ECS SA2 A0 BX6 X2 SA6 B1+CLIST SA3 B1+P.CTABLE LX3 6+18 SX3 X3 IX2 X3-X2 BX3 X3-X3 PL X2,CRESUB7 BX3 -X2 LX3 1 ADDITIONAL CORE NEEDED FOR C-LIST CRESUB7 SA4 B1+INCORE BUFFER IX4 X4+X3 TEST FOR ROOM FOR PROCESS IN CORE IX4 X4+X1 TOTAL INCREASE IN CM SPACE BX6 X4 SA6 A4 SX2 ENDSYS BX2 -X2 SA3 S.CMFL CORE AVAILABLE IX2 X2+X3 SA3 B1+P.ROHEAD SX3 X3 IX2 X2-X3 SUBTRACT ALREADY USED CM IX2 X2-X4 SUBTRACT NEEDED CM NG X2,CRESUB32 ERROR - PROCESS BECOMES TOO BIG * * ALLOCATE ADDITIONAL SPACE AS SPECIFIED BY X1 * SX6 CRESUB75 RETURN LINK SA2 B1+P.ROHEAD GET MOT OF PROCESS LX2 6+36 SX2 X2 JP REALLOC * * SWAP OUT ALL MAPS * CRESUB75 SA1 B1+P.MAPSIN SB3 B0 SB4 B0 INSURE NON-NEGATIVE B REG FOR MAPOUT SB5 B0 SB7 CRESUB9 MX2 1 LX2 59 CRESUB8 SA3 B1+X1 BX6 -X2*X3 CLEAR MAP IN FLAG SA6 A3 SB2 A3 ABS ADDR OF SUBP BEING SWAPPED OUT SA5 A3+3 JP MAPOUT CRESUB9 SA1 B2+7 POINTER TO NEXT SUBP NZ X1,CRESUB8 * * COMPUTE RELOCATION FACTOR R1 (RELOCATION OF SUBP TABLE) CRESUB10 SA1 B1+CLIST SA2 B1+P.CTABLE LX2 6+18 SX3 X2 BX5 X5-X5 IX4 X3-X1 PL X4,CRESUB11 JP IF NO INCREASE IN C-LIST BUFFER BX5 -X4 LX5 1 X5=RELOCATION DUE TO C-LIST INCREASE BX6 X2-X3 FIX UP P.CTABLE BX6 X6+X1 LX6 36 SA6 A2 * * GET NEW ECS ADDR OF PROCESS CRESUB11 SA1 B1+P.ROHEAD LX1 6+36 SX0 X1 SA0 B1 MX7 39 + RE 1 READ MOT RJ E.ECS SA1 A0 BX0 -X7*X1 SA2 B1+P.ROHEAD+1 FIND C-TABLE IN ECS LX2 6+36 SX2 X2 IX0 X0+X2 * SA1 B1+P.CTABLE GET C-TABLE DATA SA0 B1+X1 ORIG (TOP) OF C-TABLE LX1 6+36+1 SIZE OF C-TABLE SB2 X1 SA2 B1+PATH SKIP IF C-TABLE ZR X2,CRESUB12 DIDNT GROW SX5 X5+2 BUMP RELOCATION FACTOR R1 SB2 B2+2 BUMP SIZE OF C-TABLE LX1 60-1 FIX UP SIZE IN MX7 59 P.CTABLE IX6 X1-X7 LX6 18 SA6 A1 CRESUB12 SA0 A0-B2 BEGINNING OF C-TABLE IN CM WECS B2+1 WRITE C-TABLE, INCL 0 WORD * SA1 B1+P.CLIST RELOCATE ^P.CLIST^ IX6 X1+X5 SA6 A1 SA1 B1+P.CTABLE RLOCATE ^P.CTABLE^ ( ORIG ) IX6 X1+X5 SA6 A1 LX1 6+36+1 SX1 X1+1 INCREMENT ECS ADDR IX0 X0+X1 * * FIX UP STACK * SA1 B1+P.STACK ZR X5,CRESUB15 SKIP RELOCTATION IF R1 = 0 SB2 X1 STACK PTR LX1 6+36 SB3 X1 STACK ORIG BX7 X5 FORM RELOCATION MASK LX7 18 BX7 X7+X5 CRESUB14 SA2 B1+B3 IX6 X2+X7 SA6 A2 SB3 B3+2 GE B2,B3,CRESUB14 LOOP UNTIL FINISHED LX1 18 RELOCATE STACK POINTERS LX7 18 BX7 X7+X5 IX6 X1+X7 SA6 A1 * CRESUB15 LX1 6+36 SB3 X1 WRITE OUT STACK LX1 6+36 SB4 X1 END OF STACK SB5 B4-B3 SB5 B5+2 WORD COUNT OUT SA0 B1+B3 + WE B5 RJ E.ECS SX2 B5 STEP ECS ADDR IX0 X0+X2 * * RELOCATE SUBPROCESS TABLE * SA1 B1+P.PARAM+SP.MAP COMPUTE RELOCATION FACTORS SX2 X1 LX2 1 IX2 X2+X1 SX2 X2+1+1+8 ADD LOG MAP, ESM, AND IX4 X2+X5 SUBP DISCRIPTOR=R3(X4) * R3=RELOCATION OF COMPILED MAP AREA SA1 B1+P.PARAM+SP.COMP IX3 X4+X1 R4=RELOCATION OF USER CODE ( X3 ) * * RELOCATE SUBPROCESS TABLE AND RESET GARBAGE COUNTS * SA1 B1+P.SUBPDT LX1 3 SB3 X1 NUM SUBP*8 LX1 15+6+18 SB6 B1+X1 ABS ORIG OF SUBPTABLE SB4 8 * SB2 3 KILL GARBAGE COLLECTION COUNTS MX7 60-18 LX7 18 CRESUB16 SA1 B6+B2 . PICK UP NEXT MAPWORD SA1 X1+B1 . FIRST WORD OF MAP BX6 -X7*X1 . SAVE REMAINING BUFFER SPACE FIELD SA6 A1 SB2 B2+B4 LT B2,B3,CRESUB16 * CRESUB17 SB2 B0 RELOCATE WORD 0 BX7 X3 RELOCATION MASK (R4,R4,R1) LX7 18 BX7 X7+X3 LX7 18 BX7 X7+X5 SB5 CRESUB18 SA1 B6+B2 MUST DO 1ST SUBPROC HERE TO AVOID MX6 6+36 RELOCATING THE ZERO BACKPOINTER IX1 X7+X1 BX6 X6*X1 SA6 A1 SB2 B2+B4 GE B2,B3,CRESUB18 JP RELOCAT * CRESUB18 SB2 3 RELOCATE WORD 3 SX7 X5+8 RELOCATION MASK (0,R2,R3) LX7 18 BX7 X7+X4 SB5 CRESUB19 JP RELOCAT * CRESUB19 SB2 6 RELOCATE WORD 6 SX7 X5+8 RELOCATION MASK (R2,0,R1) LX7 36 BX7 X7+X5 SB5 CRESUB20 JP RELOCAT * * CONSTRUCT NEW SUBP DISCRIPTOR * WORD 0 CRESUB20 SA1 B1+FATHPTR POINTER TO FATHER (WD 0) IX7 X1+X5 RELOCATE BACKPOINTER BY R1 SA1 B1+X1 LX1 6+18 SX1 X1 RA (NEW) = RA+FL(FATHER) SA2 B1+P.PARAM+SP.FL IX6 X2+X1 RA+FL(NEW) LX6 18 BX6 X6+X1 LX6 18 BX6 X6+X7 SA6 B1 * WORD 1 SA2 B1+P.PARAM+SP.CLCD+1 CLASSCODE (SUBP NAME) BX6 X2 SA6 A6+1 * WORD 2 SA2 B1+P.PARAM+SP.ENTRY SX6 X2 LX6 36 SA1 A1+2 MAP AND C-LIST ORIG (FATHER) SA2 A1+2 MAP AND C-LIST LEN (FATHER) IX1 X1+X2 MX2 6+18 BX1 -X2*X1 BX6 X6+X1 SA6 A6+1 * WORD 3 SA1 B1+P.PARAM+SP.COMP SX6 X1 COMPILED MAP SPACE LX6 18 SA1 B1+P.MAPESM LX1 6+18 ORIG OF COMP MAP (OLD) = SX2 X1 ORIG OF NEW LOG MAP(+RELOCATION R2) LX1 18 SX1 X1 LEN OF OLD COMP MAP AREA IX1 X1+X2 ORIG OF NEW COMP MAP(+RELOCATION R3) IX2 X2+X5 SX2 X2+8 MAP POINTER BX6 X6+X2 LX6 18 IX1 X1+X4 ADD R3 BX6 X6+X1 SA6 A6+1 * WORD 4 SA1 B1+P.PARAM+SP.MAP SX6 X1 LX6 18 SA1 B1+CLIST LOCAL C-LIST LENGTH BX6 X6+X1 SA6 A6+1 * WORD 5 SA1 B1+P.PARAM+SP.CLIST+1 BX6 X1 SB3 B3+1 RESET BUFFER POINTER SA6 A6+1 * SB7 X3 SAVE R4 ( RELOCATION FACTOR) * * WORD 6 SA1 B1+P.PARAM+SP.MAP COMPUTE ESM POINTER SX3 X1 LX3 1 IX1 X1+X3 SX1 X1+1 IX6 X1+X2 NOTE..USE HERE MAP ORIG COMPUTED FOR * WORD 3 LX6 18 SX7 32 NUM OF ESM ERRORS BX6 X6+X7 LX6 18 SA1 B1+FATHPTR COMPUTE MAX STACK POINTER SB2 X1+6 = 2 LESS THAN MAX STACK OF FATHER SA1 B1+B2 SX1 X1-2 BX6 X1+X6 SA6 A6+1 * WORD 7 BX6 X6-X6 SA6 A6+1 * * WRITE OUT SUBP TABLE * SA2 B1+P.SUBPDT LX2 3 NUM SUBP*8 (OLD) SB3 X2 LX2 3+36 SA0 B1+X2 ORIG OF SUBP TABLE SB6 A0 + WE B3 RJ E.ECS SX1 B3 IX0 X0+X1 SA0 B1 WRITE OUT NEW SUBP + WE 8 RJ E.ECS SX1 10 IX0 X0+X1 SA0 B6+B3 UPDATE CM ADDR SA0 A0+2 * * RELOCATE SUBP TABLE POINTERS BY R1 LX2 18 SX7 X5+8 LX7 18 BX7 X7+X5 LX7 18 SX6 1 BX7 X6+X7 IX6 X2+X7 SA6 A2 * * RELOCATE MAP/ESM POINTERS * SA1 B1+P.MAPESM BX7 X4 RELOCATION MASK (R3,0,0) LX7 18 SA2 B1+P.PARAM+SP.COMP BX7 X7+X2 RELOCATE LX7 18 SA2 B1+P.PARAM+SP.MAP SX6 X2 LX6 1 IX2 X2+X6 SX2 X2+1+1 SPACE FOR NEW MAP AND ESM BX7 X7+X2 IX6 X1+X7 SA6 A1 * * WRITE OUT MAPS * SB2 X1 LEN OF OLD MAP/ESM + WE B2 WRITE OLD MAPS AND ESM RJ E.ECS SX6 B2 IX0 X0+X6 SA0 B1+P.SCR2 BX6 X6-X6 CLEAR REST OF MAP ENTRIES SA6 B1+P.SCR2 SA6 B1+P.SCR2+1 SA6 B1+P.SCR2+2 SA2 B1+P.PARAM+SP.MAP SX3 3 CRESUB21 WE 3 RJ E.ECS IX0 X0+X3 . CLEAR LOGICAL MAP SX2 X2-1 NZ X2,CRESUB21 * BX6 -X6+X6 . WRITE END OF MAP FLAG (=-0) SA6 B1 BX6 X6-X6 NEW ESM = 0 SA6 B1+1 SA0 B1 + WE 2 RJ E.ECS SX6 2 IX0 X6+X0 * * WRITE COMP MAPS * LX1 6+18 OLD ORIG OF COMP MAPS SA0 B1+X1 LX1 18 SB2 X1 NUM WDS + WE B2 RJ E.ECS SX2 B2 WRITE A ZERO FOR NEW IX0 X0+X2 COMP MAP SA0 B1+P.SCR2 SA2 B1+P.PARAM+SP.COMP BX6 X2 . STORE COMPILED SPACE LEFT SX6 X6-2 LX6 18 SA6 A0 + WE 1 RJ E.ECS * * FIX UP PROC READ/ONLY DESCRIPTOR * * READ THE READ/ONLY DESCRIPTOR SA2 B1+P.ROHEAD GET ECS ADDR SA0 B1 LX2 6+36 SX0 X2 + RE 1 READ MOT RJ E.ECS MX6 39 SA1 A0 BX0 -X6*X1 SA0 A2 + RE P.PROCRO RJ E.ECS * SA1 A0 INCORE LENGTH SA2 B1+INCORE IX6 X1+X2 SA6 A1 * SA1 B1+PATH INCREASE IN VARIABLE DESCRIPTOR = SX7 X1+B7 R4 - R1 + PATH IX7 X7-X5 SA1 B1+P.ROHEAD+1 * IX6 X1+X7 SA6 A1 * * WRITE FIXED LENGTH DESCRIPTOR * * NOTE... PPU INTERUPT LOCK OUT WHILE DIDLING * PROC READ ONLY DISCRIPTOR NOT NECESSARY * SINCE PPU INTERRUPTS DON^T DIDLE A RUNNING PROCE * ...BEWARE.. IF SYSTEM RUNNING ON TWO CPU (INTER- * PROCESS INTERRUPTS MAY STRIKE ) * * + WE P.PROCRO+P.PROCRW RJ E.ECS * * SWAP PROCESS BACK IN * SA1 B1+P.ROHEAD COMPUTE B1 SB2 X1 SA2 S.CMFL SB1 X2 SB1 B1-B2 SX6 B1 SA6 S.USRB1 BX6 X6-X6 SA6 S.USERA * FIX LENGTH DESCRIPTOR SA0 B1+P.ROHEAD + RE P.PROCRO+P.PROCRW RJ E.ECS * VARIABLE LENGTH DESCRIPTOR SA2 B1+P.ROHEAD+1 SB2 X2 LX2 6+36 SX2 X2 IX0 X0+X2 SA2 B1+P.CTABLE COMPUTE ROOM FOR LOCAL C-LIST BUFFER LX2 6+18+1 SX2 X2+P.LOCALC SA0 B1+X2 + RE B2 RJ E.ECS * SWAP IN FULL PATH SA1 B1+P.STACK SA1 B1+X1 SB2 X1 CURRENT SUBP INDEX LX1 6+36 SB5 B0 SB3 X1 TOP OF PATH INDEX MX2 1 LX2 60-1 MASK FOR MAP IN FLAG SB4 P.MAPSIN SB7 CRESUB23 * CRESUB23 SA1 B1+B3 WD 0 OF SUBP OF INTEREST BX6 X2+X1 SET MAP IN FLAG SA6 A1 SX7 B3 CHAIN INTO MAP SA7 B1+B4 SB4 B3+7 NE B3,B2,CRESUB24 SB7 CRESUB25 CRESUB24 SA5 A1+3 GET POINTERS FOR ^MAPIN^ SB3 X1+0 STEP SUBP OF INTEREST JP MAPIN CRESUB25 BX6 X6-X6 STORE 0 AT END OF MAP CHAIN SA6 B1+B4 * * BRING IN LOCAL C-LIST * SA1 B1+B2 SA3 A1+5 SX0 X3 SA0 B1 SA4 A1+4 LX4 1 SB5 X4+1 MX5 39 + RE 1 READ MOT RJ E.ECS SA2 A0 BX3 X3-X2 CHECK UNIQUE NAME BX3 X5*X3 NZ X3,CRESUB33 BX0 -X5*X2 SA0 B1+P.LOCALC-1 + RE B5 RJ E.ECS * * DO RA, FL, AND MA IN EXCHANGE PACKAGE * SA2 B1+P.XPACK+1 RA LX1 6+36 X1 = WD 0 OF SUBP) SX7 X1+B1 SA7 S.USERA SET USER RA FOR PPU LX7 36 MX5 6+18 SA3 B1+P.XPACK+2 BX2 -X5*X2 CLEAR OLD RA BX6 X2+X7 NEW RA SA6 A2 SX7 X1 LX1 6+36 SX6 X1 IX6 X6-X7 NEW FL LX6 36 SA4 B1+P.XPACK+6 MA BX3 -X5*X3 CLEAR OLD FL BX6 X3+X6 SA6 A3 SX7 B1+P.XPACK NEW MA BX4 -X5*X4 LX7 36 BX6 X7+X4 SA6 A4 * RETURN TO USER JP SYSRET ENDECS MKSUB EJECT * ERRORS * * ERRORS CRESUB34 SX1 4 EQ ERR20 CRESUB28 SX1 5 EQ ERR20 CRESUB29 SX1 8 EQ ERR20 CRESUB35 SX1 2 ERR20 SX7 E.NEGPT EQ CL2 ERR21 SX7 E.BIGPT EQ CL2 CRE28X SX1 5 SX7 E.BIGPAR EQ CL2 CL2 LX1 18 MX3 42 BX1 X1*X3 BX7 X1+X7 SX6 E.PARMS EQ E.ERROR CRESUB33 SX7 E.CLMOT SX6 E.MISCE EQ E.ERROR CRESUB26 SX7 E.SAMNA EQ CL4 CRESUB27 SX7 E.NOFATH EQ CL4 CRESUB30 SX7 E.NOBLOC EQ CL4 CRESUB31 SX7 E.COMP EQ CL4 CRESUB32 SX7 E.MACSZ CL4 SX6 E.SUBP EQ E.ERROR BADNEWS RJ DISASTR EJECT TITLE DELETE SUBPROCESS * * PARAM = C: CLASS CODE (SUBPROCESS NAME) * * ECSCODE DLSUB * DELSUBP SA3 B1+P.PARAM+1 GET SUBPROCESS NAME SB7 DELSUBP1 JP FINDSUBP * DELSUBP1 SB6 A5-B1 INDEX +1 OF SUBPROCESS FOUND SB7 A6-B1 INDEX +1 OF END OF SUBP TABLE EQ B6,B7,SUBPC15 ERROR - NO SUCH SUBPROCESS * * * REG ALLOC * B2 = SUBP INDEX OF DEL SUBP * SB2 B6-1 SA1 B1+B2 SB7 X1 EQ B0,B7,DELSUB31 ERROR - DEL SUBP ROOT OF SUBP TREE * * MAKE SURE DEL SUBP IS TREE LEAF * SA2 B1+P.SUBPDT SB3 X2 NUM SUBP LX2 6+36 SB7 X2+0 SUBP TABLE ORIGIN * * * REG ALLOC * B4 = CONST 8 * SB4 8 DELSUBP2 SA1 B1+B7 SB5 X1 EQ B5,B2,DELSUB31 ERROR - SOME SUBP POINTS TO DEL SUBP SB7 B7+B4 SB3 B3-1 NE B3,B0,DELSUBP2 * * CHECK STACK FOR DEL SUBP * SA1 B1+P.STACK SB7 X1 STACK POINTER LX1 6+36 SB3 X1 STACK ORIGIN DELSUBP3 SA1 B1+B7 SB5 X1 EQ B5,B2,DELSUB27 ERROR - DEL SUBP IN STACK SB7 B7-2 GE B7,B3,DELSUBP3 LOOP TO STACK ORIG * * CHECK FOR SUBP MAP IN * SA1 B1+B2 LX1 1 PL X1,DELSUBP4 JP IF MAP NOT IN * SB7 DELSUBP4 SA2 B1+P.MAPSIN PATCH UP MAP CHAIN DELSUB35 SB3 X2+0 EQ B3,B2,DELSUB36 JP WHEN FOUND PREV SUBP IN CHAIN SB3 B3+7 SA2 B1+B3 JP DELSUB35 DELSUB36 SB5 B3+7 PATCH PREVIOUS POINTER SA4 B1+B5 BX6 X4 SA6 A2 * SA5 A1+3 SWAP OUT THE MAP JP MAPOUT * * DECREMENT REFERENCE COUNTS ON MAP * DELSUBP4 SB3 B2+3 SA1 B1+B3 GET MAP POINTER LX1 6+36 SX6 X1-3 INNITIALIZE PTR FOR LOG MAP ENTRIES SA6 B1+P.TEMP1 MX5 59 INCREMENT REF COUNTS BY -1 SB4 DELSUB28 ERROR - NO FRETURN EXPECTED SB6 DELSUB45 SB7 DELSUB28 ERROR - ERROR RETURN NOT EXPECTED * DELSUB45 SA1 B1+P.TEMP1 RECOVER LAST LOG MAP ADDR SX1 X1+3 DELSUBP5 SA2 B1+X1 CHECK FOR SWAPPING DIRECTIVE NZ X2,DELSUBP6 JP IF GOT MAP ENTRY NG X2,DELSUBP7 JP IF END OF LOGICAL MAP SX1 X1+3 JP DELSUBP5 DELSUBP6 BX6 X1 SAVE SWAPPING DIRECTIVE ADDR SA6 A1 SX4 377777B SET HEGE FL JP REFER * * CHECK FOR DECREASE IN PROCESS CM SIZE DUE TO * DEL SUBP ADDRESS SPACE * DELSUBP7 SA1 B1+P.SUBPDT * * * REG ALLOC * B4 = CONST 8 * SB4 8 LX1 6+18 SB3 X1-1 INDEX +8 OF LAST SUBP LX1 18 SB5 X1+0 ORIG OF SUBP TABLE SB6 B0+0 MAX RA+FL MX3 60-18 MASK TO CLEAR GARBAGE COUNT * DELSUBP8 SA1 B1+B5 RA+FL EQ B5,B2,DELSUBP9 SKIP IF DEL SUBP LX1 6+18 SB7 X1 LT B7,B6,DELSUBP9 SKIP IF NOT NEW MAX SB6 B7 DELSUBP9 SB5 B5+B4 * SA1 A1+3 RESET GARBAGE COUNT ON SA1 B1+X1 COMPILED MAP BX6 X1*X3 SA6 A1 * NE B5,B3,DELSUBP8 LOOP TO END OF SUBP TABLE * SA3 B1+B2 LX3 6+18 SB7 X3 RA+FL OF DEL SUBP LT B7,B6,DELSUB10 JP IF NO CM SIZE DECREASE HERE SA1 B1+P.ROHEAD SB6 B7-B6 CHANGE IN CM SIZE SX6 B6 IX6 X1-X6 SA6 A1 * * COMPUTE RELOCATION FACTORS * DELSUB10 SA5 A3+3 * * * REG ALLOC * X5 = WD 3 OF DEL SUBP * SA4 A3+4 LX5 6+18 1) SHIFT TO WDS COMP BUF LX4 6+36 SX3 X4 LX3 1 IX4 X3+X4 NUM MAP ENTRIES *3 * * * REG ALLOC * X4 = SPACE FOR LOG MAP AND ESM (DEL SUBP) * SX4 X4+1+1 SX7 X5+B4 DEL SUBP COMP BUF+8 (SUBP DISC) IX7 X7+X4 BX6 X7 LX7 18 BX7 X6+X7 LX7 18 BX7 -X7 RELOCATION MASK ( WD 0 ) * * * REG ALLOC * B7 = B2 (DEL SUBP INDEX) * SB7 B2 SB2 B0 WD 0 TO RELOCATE SB5 DELSUB32 SA2 B1+P.SUBPDT LX2 3 SB3 X2 NUM SUBP * 8 LX2 3+36 SB6 B1+X2 ABS ADDR 1ST SUBP JP RELOCAT * * RELOCATE WD 3 AND WD 6 OF SUBP BEFORE DEL SUBP * DELSUB32 SB3 X2 SB3 B7-B3 NUM SUBP TO RELOCATE * 8 SB2 3 SX6 B4+X4 FORM RELOCATION MASK SX7 B4 B4 = 8 LX7 18 BX7 X6+X7 (8),(8+DEL MAP/ESM) BX7 -X7 SB5 DELSUB33 JP RELOCAT * DELSUB33 SB2 6 SX7 B4 LX7 36 BX7 -X7 SB5 DELSUB11 JP RELOCAT * * FIX STACK ENTRIES POINTING TO A SUBP WHICH WILL BE MOVED * DELSUB11 LX2 6+36 TEST FOR DEL SUBP = LAST SUBP SB2 X2-9 LAST SUBP INDEX EQ B2,B7,DELSUB21 JP IF CAN SKIP CHECK STACK,MAP CAAIN * AND MOVE SUBPR DISC * SA1 B1+P.STACK SB2 X1 STACK POINTER LX1 6+36 SB3 X1 STACK ORIGIN SX3 B4 B4=8 DELSUB12 SA1 B1+B2 SB5 X1 LT B5,B7,DELSUB15 JP IF OK IX1 X1-X3 LX1 6+36 SB5 X1+0 DELSUB13 LT B5,B7,DELSUB14 SKIP IF END OF PATH OK IX1 X1-X3 DELSUB14 LX1 18 BX6 X1 SA6 A1 JP DELSUB16 * DELSUB15 LX1 6+36 SB5 X1 GE B5,B7,DELSUB13 JP IF END OF PATH NEEDS RELOCATION DELSUB16 SB2 B2-2 GE B2,B3,DELSUB12 * * CHECK FOR RELOCATION IN MAP CHAIN * SA1 B1+P.MAPSIN HEAD OF MAP CHAIN DELSUB17 SB2 X1 LT B2,B7,DELSUB18 SKIP IF OK IX6 X1-X3 X3=8 SA6 A1 DELSUB18 SX7 B2+7 SA1 B1+X7 NE B2,B0,DELSUB17 LOOP TO END OF MAP CHAIN * * MOVE SUBP DISC IN SUBP TABLE AS NEEDED * SX7 X4+B4 RELOCATION OF LOG MAP PTRS SX3 X7 LX3 36 X3 = RELOCATION FOR WD 6 SUBP DISC SX6 X5 WDS IN COMP BUF DEL SUBP IX6 X6+X7 RELOCATION OF COMP MAP PTRS LX7 18 BX7 X7+X6 X7 = RELOCATION FOR WD 3 SUBP DISC SB6 B1+B7 SB5 1 * * * REG ALLOC * B5 = CONST 1 * SA1 B1+P.SUBPDT LX1 6+18 SB6 B6+B4 SA2 B6-B5 INITIALIZE PICK UP POINTER (A2) SB2 X1+B1 SB2 B2-2 LAST WD TO MOVE (ABS) * * DELSUB19 SA2 A2+B5 MOVE WD 0 SB3 X2 LT B3,B7,DELSUB20 SKIP IF BACKPOINTER OK SX6 B4 IX2 X2-X6 DELSUB20 BX6 X2 SA6 A2-B4 * SA2 A2+B5 WD 1 BX6 X2 SA6 A2-B4 * SA2 A2+B5 WD 2 BX6 X2 SA6 A2-B4 * SA2 A2+B5 WD 3 IX6 X2-X7 RELOCATE MAP POINTERS SA6 A2-B4 * SA2 A2+B5 WD 4 BX6 X2 SA6 A2-B4 * SA2 A2+B5 WD 5 BX6 X2 SA6 A2-B4 * SA2 A2+B5 WD 6 IX6 X2-X3 RELOCATE ESM POINTER SA6 A2-B4 * SA2 A2+B5 WD 7 BX6 X2 SA6 A2-B4 * SB3 A2 LT B3,B2,DELSUB19 LOOP TO END OF SUBP TABLE * * MOVE LOGICAL MAPS * DELSUB21 LX5 18 2) SHIFT TO MAP POINTER SB2 B1+X5 LOG MAP DEL SUBP (ABS) SA2 B1+P.MAPESM LX2 6+18 SB3 B1+X2 ORIG OF COMP MAPS (ABS) SA1 B1+P.SUBPDT LX1 6+18 SA1 B1+X1 DUMMY FETCH-GET PTR SET SA6 A1-B4 INITIALIZE PUT PTR SB5 1 * DELSUB22 SA1 A1+B5 MOVE MAPS PRECEDING DEL SUBP BX6 X1 MAP SA6 A6+B5 SB4 A1+B5 NE B4,B2,DELSUB22 LOOP UNTIL DEL SUBP MAP * SB4 X4 STEP PICK UP POINTER SA1 A1+B4 * DELSUB23 SB4 A1+B5 MOVE REST OF MAPS EQ B4,B3,DELSUB30 JP IF THRU SA1 A1+B5 BX6 X1 SA6 A6+B5 JP DELSUB23 * DELSUB30 LX5 18 3) SHIFT TO COMP BUF PTR SB2 B1+X5 ORIG DEL SUBP COMP BUF (ABS) SA2 B1+P.MAPESM LX2 6+36 LEN OF ALL COMP BUFFERS SB3 B3+X2 END OF COMP BUFFERS (ABS) * DELSUB24 SA1 A1+B5 MOVE COMP BUFFERS BEFORE BX6 X1 DEL SUBP COMP BUF SA6 A6+B5 SB4 A1+B5 NE B4,B2,DELSUB24 * LX5 6+18 4) SHIFT TO LEN OF COMP BUFFER SB2 X5 SA1 A1+B2 SKIP OVER DEL SUBP * DELSUB25 SB4 A1+B5 MOVE REST OF COMP BUFFERS EQ B4,B3,DELSUB26 SA1 A1+B5 BX6 X1 SA6 A6+B5 JP DELSUB25 * * FIX UP INCORE AND VARIABLE DISC LENGTHS * DELSUB26 SA1 B1+P.ROHEAD SA0 A1 LX1 6+36 SX0 X1 + RE 1 READ MOT RJ E.ECS SA2 A0 MX6 39 BX0 -X6*X2 ECS ADDR OF PROCESS SX6 B5 SET INTERRUPT LOCK OUT SA6 I.LOCK + RE 2 READ HEADER WDS RJ E.ECS SX6 X4+8 SX7 X5 DEL SUBP COMP MAP SPACE IX7 X6+X7 LX1 18 RECOVER POSSIBLE REDUCED POCESSS SX2 X1 CM SIZE SA1 A0 GET P.ROHEAD MX6 6+36 REPLACE PROC CM SIZE BY REDUCED SIZE BX1 X6*X1 BX1 X1+X2 IX6 X1-X7 SA6 A1 SA1 A1+B5 P.ROHEAD+1 IX6 X1-X7 SA6 A1 + WE 2 WRITE OUT HEADER RJ E.ECS BX6 X6-X6 RESET PPU LOCKOUT SA6 I.LOCK * * FIX UP P.MAPESM * SX7 X4+8 RELOCATE ORIG OF COMP MAP LX7 18 SX3 X5 BX7 X7+X3 CHANGE SIZE OF COMP BUFFERS LX7 18 BX7 X7+X4 CHANGE SIZE OF LOG MAPS AND ESM SA1 B1+P.MAPESM IX6 X1-X7 SA6 A1 * * FIX UP P.SUBPDT * SX7 8 LX7 36 SX6 B5 BX7 X6+X7 SA1 B1+P.SUBPDT IX6 X1-X7 SA6 A1 * * MOVE INCORE VERSION OF THE PROCESS DISCRIPTOR UPWARD IN CM * EXT PACKBUF * SX7 X4+8 SPACE RELEASED BY SUBP DISC, * LOG MAP, AND ESM OF DELETED SUBPROCESS SX6 X5 SPACE RELEASED BY COMP MAP OF DEL SUBP IX7 X6+X7 TOT SPACE RELEASED * SX0 PACKBUF 16 WORD BUFFER IN ECS SB6 16 * SA1 B1+P.SUBPDT FIND RA (REL THE REDUCED PROCESS * DISCRIPTOR) OF 1ST SUBPROCESS LX1 60-18 SX1 X1 SA1 B1+X1 LX1 60-18 SX1 X1 SB2 B1+X1 SB2 B2-B6 ADDR TO COPY FROM SB3 X7 NUMBER OF WORDS TO MOVE THINGS UPWARD * * DELSUB34 SA0 B2 + WE B6 RJ E.ECS SA0 A0+B3 SB2 B2-B6 + RE B6 RJ E.ECS GE B2,B1,DELSUB34 LOOP UNTILL NEAR B1 * SA0 B1 COPY LAST CHUNK SB2 B2-B1 + WE B2+16 RJ E.ECS SA0 A0+B3 + RE B2+16 RJ E.ECS * SB1 B1+B3 MOVE B1 TO REFLECT MOVED PROCESS DISC SX6 B1 SA6 S.USRB1 * * FIX UP USER MA IN HIS EXCHANGE PACKAGE * SA1 B1+P.XPACK+6 MX6 24 BX1 -X6*X1 SX6 B1+P.XPACK LX6 36 BX6 X6+X1 SA6 A1 * * REDUCE PROCESS SIZE IN ECS * * * X7= AMOUNT TO REDUCE PROCESS SIZE BX1 -X7 SX6 SYSRET SA2 B1+P.ROHEAD LX2 6+36 SX2 X2 MOT JP REALLOC SPACE 5 DELSUB31 SX7 E.NLEAF ERROR..DEL SUBP ROOT OF TREE OR NOT JP CL4 A LEAF * DELSUB27 SX7 E.INSTK ERROR..DEL SUBP IS IN STACK JP CL4 * DELSUB28 RJ DISASTR ERROR RETURN FROM ^REFER^ ENDECS DLSUB EJECT * RELOCATE A WORD IN SUBPROCESS * B2 = INDEX OF WORD TO RELOCATE * B3 = NUM SUBP *8 * B4 = CONST 8 * B5 = RETURN * B6 = ABS ADDR OF ORIG OF 1ST SUBP * X7 = RELOCATION MASK * REG USED A1/X1,A6/X6,B2 RELOCAT SA1 B6+B2 IX6 X1+X7 SA6 A1 SB2 B2+B4 GE B2,B3,RELOCAT2 JP IF DONE RELOCAT1 SA1 A1+B4 IX6 X1+X7 SA6 A1 SB2 B2+B4 GE B2,B3,RELOCAT2 JP IF DONE SA1 A1+B4 IX6 X1+X7 SA6 A1 SB2 B2+B4 LT B2,B3,RELOCAT1 * RELOCAT2 JP B5 TITLE SUBPROCESS JUMP CALL * * THIS IS THE ECS ACTION OF SUBPROCESS * JUMP CALL. ALL IS AS WITH NORMAL CALL * EXCEPT THAT WE HAVE TO MAKE IT SEEM AS * THOUGH THE CALLER WERE THE CURRENT SUBPROCESS * IN THE PREVIOUS STACK ENTRY. * ENTRY JUMPCAL JUMPCAL SA1 B1+P.STACK DECREASING THE STACK BY SX6 2 ONE ENTRY MAKES THE NORMAL IX6 X1-X6 CALL MECHANISM THINK THAT * THE CALLER WAS THE PREVIOUS * CALLER. SA6 A1 SA6 B1+P.OLDP MAKING P.OLDP NON-ZERO JP SUBPCAL KEEPS THE P-COUNTER AND * IPLIST INFO IN THE (NOW) * TOP STACK ENTRY FROM BEING * BUGGERED UP WITH DATA ABOUT * THE ACTUAL (HIDDEN) CALLER. TITLE SUBPROCESS CALL * * THIS IS THE ECS ACTION OF SUBPROCESS CALL * THE ACTUAL PARAMETER LIST FOR THE SUBPROCESS CALL * HAS BEEN FORMED * THE ONLY INPUT IS B1 = PROCESS ORIGIN * TEMPORARIES USED... P.SCR2 EXT TOUSER * ENTRY SUBPCAL * SUBPCAL SA3 B1+P.PARAMC GET NAME OF SUBPROCESS SB7 SUBPC1 JP FINDSUBP SUBPC1 SB3 A5-B1 SB4 A6-B1 EQ B3,B4,SUBPC15 ERROR..NO SUCH SUBPROCESS * SA4 B1+P.STACK SA3 A5+5 GET WD 6 OF SUBP DISC SX2 X4 STACK POINTER SX3 X3-1 MAX ALLOWED STACK PTR FOR SUBPROCESS IX3 X3-X2 NG X3,SUBPC16 ERROR..NOT ENOUGH ROOM IN THE STACK * SX6 2 IX6 X4+X6 INCREMENT STACK POINTER SA6 A4 SA3 B1+X2 OLD TOP OF STACK (WD 0 ) SX7 X3 CALLER - NEEDED IF SAME TOP OF PATH LX3 6+36 SB6 X3 OLD TOP OF PATH* SX2 X6+0 NEW STACK POINTER * * SEARCH FROM TOP OF PATH SB2 B3-1 CALLEE SA3 B1+B6 TOP OF PATH SB4 X3 EQ B4,B2,SUBPC5 JP IF SAME TOP EQ B0,B4,SUBPC4 JP IF NEW TOP SUBPC3 SA3 B1+B4 NEXT SUBP IN PATH FROM OLD TOP SB4 X3 EQ B4,B2,SUBPC5 JP IF SAME TOP EQ B0,B4,SUBPC4 JP IF NEW TOP SA3 B1+B4 NEXT SUBP SB4 X3 EQ B4,B2,SUBPC5 JP IF SAME TOP NE B4,B0,SUBPC3 LOOP IF NOT FOUND YET * * SUBPC4 SB6 B2 NEW TOP OF PATH BX7 X7-X7 REMEMBER IF NEW PATH USED SUBPC5 SA7 B1+P.SCR2 P.SCR2 =0 IF NEW TOP ELSE CALLER SB7 SUBPC6 CALL WILL 1)FORM NEW STACK ENTRY SX1 0 TYPE OF CALL (ENTRY POINT OFFSET) SA3 B1+P.OLDP JP CALL 2)SET P-COUNTER IN OLD STACK ENTRY * 3)SET P, RA, FL, IN XPACK * 4) CALL ENVIORN * PARAMS TO ^CALL^ * B1 = PROC ORIG * B2 = CALLEE * B6 = TOP OF PATH * X2 = STACK POINTER FOR NEW STACK ENTRY * X3 = STACK MANIPULATION FLAG * SUBPC6 SA2 B1+P.SCR2 GET CALLER IF NOT NEW TOP OF PATH SB6 SUBPC7 INNITIALIZE SUBP LOW CORE JP SUBPCOR * ON EXIT FORM ^SUBPCOR^ * B4 = ABS RA + FL OF CALLEE * B7 = 1 * B2 = INDEX OF CALLEE * A6 = CALLEE RA + 5 (ABS) * * * SET UP FOR PARAMETER PASSING * SUBPC7 SA1 B1+P.PARAMC-1 PARAMETER TOTALS SB3 X1 FL NEEDED IN CALLEE FOR PARAMS SB3 A6+B3 LAST WD NEEDED (ABS) GE B3,B4,SUBPC17 ERROR: NOT ROOM IN SUBP FL AX1 18 SB6 B0 CAPABILITY COUNTER SA4 B1+P.CLIST SA4 B1+X4 SB4 X4 LEN LOC C-LIST (CALLEE) SB3 X1 NUM CAPS COMMING LE B4,B3,SUBPC18 ERROR: TOO MANY CAP PARAMS AX1 18 SB3 X1 ACTUAL SIZE OF ACTUAL PARAM SB5 B1+P.LOCALC LOCAL C-LIST ORIG (ABS) SA2 B1+P.PARAM-1 ACTUAL PARAM AREA POINTER SA1 B1+P.PARAMC-2 PARAMETER TYPE BIT MASK * * REGISTERS FOR XFER OF PARAMETERS * X1 = PARAMETER TYPE BIT MASK * A2/X2 = ACTUAL PARAM PTR / DATA * A6 = PTR TO USER PARAM AREA (ABS) * B2 = INDEX OF CALLED SUBP * B3 = COUNTER FOR ACTUAL PARAM AREA * B5 = LOCAL C-LIST ORIGIN (ABS) * B6 = CAPABILITY INDEX COUNTER * B7 = CONST 1 * * TRANSFER PARAMETERS * SUBPC8 EQ B3,B0,SUBPC12 JP IF DONE NG X1,SUBPC9 JP ON BLOCK PARAM OR CAPAB PARAM * * DATUM PARAMETER * SA2 A2+B7 FETCH DATUM BX6 X2 SA6 A6+B7 STORE DATUM SB3 B3-B7 DECR ACTUAL COUNTER LX1 1 SHIFT TYPE MASK JP SUBPC8 * * * CAPABILITY PARAMETER * SUBPC9 SA2 A2+B7 1ST WD OF APPARENT CAPABILITY LX1 1 SHIFT TYPE MASK SB3 B3-2 DECR ACTUAL COUNTER MX0 59 BX0 X0-X2 ZR X0,SUBPC10 JP IF REALLY BLOCK PARAMETER * * SX6 B6 INDEX OF CAP SA6 A6+B7 STORE CAP INDEX LX6 1 BX7 X2 1ST WD OF CAPABILITY SA7 B5+X6 SA2 A2+B7 2ND WD OF CAPABILITY BX7 X2 SB6 B6+B7 INCR CAPABILITY COUNTER SA7 A7+B7 JP SUBPC8 * * * BLOCK PARAMETER * SUBPC10 SA2 A2+B7 NG X2,SUBPC11 JP IF CAPABILITY BLOCK * * MOVE DATA BLOCK SB4 X2 MAX NUM WORDS SA0 A6+2 ABS ADDR FOR BLOCK AX2 18 SX6 X2 ACTUAL NUM WORDS SA6 A6+B7 PASS SIZE OF BLOCK TO USER BX6 X6-X6 SA6 A6+B4 INCR USER PARAM POINTER SB4 X2 ACTUAL NUM WORDS AX2 18 SX0 X2 BUFFER ADDR + RE B4 GET DATA BLOCK RJ E.ECS * JP SUBPC8 * * * CAPABILITY BLOCK * SUBPC11 SX6 B6 CAPABILITY INDEX SB6 B6+X2 INCR CAPABILITY COUNTER LX2 60-18 SX7 X2 SB4 X7 ACTUAL NUM CAPS LX7 18 BX6 X6+X7 PASS ACTUAL NUM AND STARTING INDEX SA6 A6+B7 LX2 60-18 SX0 X2 BUFFER ADDR SX6 X6 STARTING INDEX IN LOCAL C-LIST LX6 1 SA0 B5+X6 SB4 B4+B4 + RE B4 READ CAPABILITIES RJ E.ECS * JP SUBPC8 * * * * * FINISHED WITH PARAMETERS * WRITE MODIFIED PORTION OF LOCAL * C-LIST TO THE ECS COPY OF SAME SUBPC12 SA4 B1+P.CLIST GET ECS ADDR OF LOC C-LIST SX4 X4+B7 SA4 B1+X4 MOT AND UNIQUE NAME SX0 X4 SA0 B1+P.SCR2+1 + RE 1 READ MOT ENTRY FOR LOCAL C-LIST RJ E.ECS SA5 A0 BX4 X4-X5 MX7 39 BX4 X4*X7 NZ X4,SUBPC19 ERROR- OBJECT GONE FORM MOT BX0 -X7*X5 SB6 B6+B6 CAPABILITY COUNT SX4 B7 SKIP PAST LENGTH WORD OF C-LIST IX0 X0+X4 SA0 B5 ABS CM ADDR ORIG LOCAL C-LIST + WE B6 WRITE CHANGES TO ECS COPY OF LOCAL C-L RJ E.ECS * * * TEST FOR POSSIBLE INTERRUPT SB7 TOUSER SX1 1 JP INTCHK GO CHECK FOR INTERRUPTS AND EXIT SPACE 5 * ERRORS * * SUBPC15 SX7 E.NOFIND EQ CL4 SUBPC16 SX7 E.FULSTK EQ CL4 SUBPC17 SX7 E.ROOM EQ CL4 SUBPC18 SX7 E.NCAP EQ CL4 SUBPC19 EQU CRESUB33 * * * TITLE SUBPROCESS INTERRUPT * * CHECK FOR INTERRUPTS * * X1 = 0 IF ^INTERRUPTED^ NOT TO * BE SET IN STACK * B7 = EXIT ADDR * * INTCHK SA2 B1+P.INTERR ZR X2,INTCHK3 JP IF NO INTERRUPTS PENDING * SA2 B1+P.STACK SB4 B0 SA3 B1+X2 SB2 X3 SB3 B2 * INTCHK1 SA3 B1+B2 PL X3,INTCHK2 SB4 B2 INTCHK2 SB2 X3 NE B2,B0,INTCHK1 * * SB2 B4 NE B2,B0,INTCHK4 JP IF INTERRUPT * INTCHK3 JP B7 EXIT * * CHECK FOR STACK FULL OR INTERUPT INHIBIT * INTCHK4 NE B2,B3,INTCHK5 JP IF INTERUPT SUBP .NE. CURRENT * SB3 B3+6 SA3 B1+B3 WD 6 OF SUBP DISC SX5 X2 SX3 X3-1 IX3 X3-X5 NG X3,INTCHK3 JP IF NOT ROOM IN STACK * SA2 B1+X2 CHECK FOR INTERRUPT INHIBIT LX2 2 NG X2,INTCHK3 JP IN INTERRUPT INHIBIT * * SET ^INTERRUPTED^ IF CALLED FOR * INTCHK5 ZR X1,INTERUPT * SA2 B1+X2 1ST WD OF STACK ENTRY MX6 1 LX6 59 BX6 X6+X2 SA6 A2 JP INTERUPT * EJECT * * THIS ROUTINE INNITIATES AN INTERRUPT THAT IS ALLOWED * TO RUN....IT MAY BE CALLED ONLY DURING A SUBPROCESS T * TRANSFER * * * ON ENTRY B2 = INDEX OF INTERRUPT SUBORCESS * * ROUTINES CALLED ^CALL^ AND ^SUBPCOR^ * * * * INTERUPT SA1 B1+B2 INTERRUPT SUBPROCESS MX0 1 CLEAR INTERRUPT FLAG BX6 -X0*X1 SA6 A1 * SB7 INT3 CALL ^CALL^ B2 = CALLEE SA1 B1+P.STACK B6 = TOP OF PATH SX7 2 B7 = RETURN IX6 X1+X7 X1 = STACK POINTER SA6 A1 SX2 X6 SA3 B1+X1 OLD STACK ENTRY FOR TOP OF PATH SX6 X3 SAVE PROVIOUS SUBP IN P.OLDP SA6 B1+P.OLDP XO )NE. 0 TO INHIBIT P-COUNTER SETTING LX3 6+36 IN OLD STACK ENTRY SB6 X3 NOTE..ALWAYS SAME (OLD) TOP OF PATH FO SX1 2 TYPE OF CALL (ENTRY POINT OFFSET) JP CALL FOR INTERRUPT CALL * * INT3 SB6 INT4 INTITIALYZE SUBPROCESS LOW CAOR SA2 B1+P.OLDP RECOVER PREVIOUS SUBP JP SUBPCOR * * INT4 SB3 B2+4 STORE INTERRUPT DATA SA1 B1+B3 LX1 6+18 SX6 X1 SA6 A6-3 * SA1 B1+P.INTERR DECREMENT INTERRUPT COUNT MX6 59 IX6 X1+X6 SA6 A1 * * SA1 B1+P.STACK .SET INTERRUPT INHIBIT IN TOP OF STAC SA1 B1+X1 MX6 1 LX6 60-2 BX6 X6+X1 SA6 A1 * JP TOUSER GO TO USER * * EJECT TITLE SUBPROCESS RETURN * THIS IS THE ROUTINE TO DO A SUBPROCESS RETURN * IT IS CALL AS AN ECS ACTION BY THE USER OR * * ENTRY RETURN * RETURN SB7 RETURN1 EQ DOSTK .. DECREMENT THE STACK TEST FOR ERRORS, * SET UP REGISTERS FOR ENVIORN, ETC. RETURN1 SB7 SETRET JP ENVIORN .. ESTABLISH ENVIORN FOR THE RETURN TITLE RETURN WITH DECREMENTED P COUNTER EJECT * * SPRET * * ^PROCEDURE^ SPRET * ^BEGIN^ * STACK=DOSTK(STACK) * ^IF^ INTERRUPTED(TOP(STACK)) ^THEN^ * ^BEGIN^ * RETURN=SETRET * ^GOTO^ ENVIORN * ^END^ * ^ELSE^ ^BEGIN^ * INTERRUPTED(TOP(STACK))=TRUE * PCOUNT(TOP(STACK))=PCOUNT(TOP(STACK))-1 * RETURN=SETRET * ^GOTO^ ENVIORN * ^END^ * ^END^ * ENTRY SPRET ECSCODE SPRET SPRET SB7 SPRET1 .. RETURN LINK EQ DOSTK .. DECREMENT STACK; SET UP REGISTERS FOR * CALL ON ENVIORN, ETC. SPRET1 LX2 18+1 .. CHECK INTERRUPTED FLAG NG X2,SPRET2 .. JUMP IF INTERRUPTED SA1 A2+1 .. READ TOP (WD 1) STACK SX3 1 IX6 X1-X3 .. DECREMENT P-COUNTER SA6 A1+0 .. XMIT NEW P-COUNTER * * SET INTERRUPTED FLAG * MX6 1 BX6 X6+X2 .. SET INTERRUPTED FLAG LX6 60-1 .. REPOSITION WORD SA6 A2+0 .. XMIT NEW (WD 0) STACK VALUE * SPRET2 SB7 SETRET .. SET RETURN EQ ENVIORN .. JUMP TO ENVIORN ENDECS SPRET TITLE RETPARM: RETURN WITH PARAMETERS EJECT * * * RETURN WITH PARAMETERS * * AP1= D: DATA CONTROL WORD * 24/0,18/WD COUNT,18/START ADDR * AP2= D: CAPABILITY CONTROL WORD * 24/0,18/CAP COUNT,18/START INDEX * * ENTRY RETPARM * RETPARM SA1 B1+P.PARAM DATA CONTROL WORD SA2 B1+P.PARAM+1 CAPABILITY CONTROL WORD SB7 RETPARM1 COPY PARAMETERS TO ECS BUFFER JP GETRETP * * FIX UP STACK RETPARM1 SB7 RETPARM2 EQ DOSTK * ESTABLISH NEW ENVIORNMENT * RETPARM2 SB7 RETPARM3 EQ ENVIORN * * COPY PARAMS TO NEW SUBPROCESS, COMPLETE RETURN AND EXIT RETPARM3 SB7 SETRET EQ PUTRETP * TITLE SETRET: SET UP THE RETURN EJECT * * THE P-COUNTER IS SET FROM THE STACK * RA AND FL ARE SET * PENDING INTERRUPTS ARE CHECKED AND EXIT IS * TO ^SYSRET^ IF ^INTERRUPTED^ IS NOT SET IN * IN THE STACK, OTHERWISE EXIT IS TO ^TOUSER^ * * SETRET SA1 B1+P.STACK SA1 B1+X1 STACK ( WD 0 ) MX6 18 CLEAR OP COUNT IN STACK LX6 60-6 BX6 -X6*X1 SA6 A1 SA2 B1+X1 CALLEE ( WD 0 ) SB2 X1 SA3 A1+1 STACK ( WD 1 ) (P-COUNTER ) LX1 6+36 SHIFT TO TOP OF PATH LX2 6+36 SHIFT TO RA SA5 B1+X1 TOP OF PATH SUBP ( WD 0 ) SB4 X2+B1 NEW RA SX2 X2 LX5 6+18 SHIFT TO RA+FL SX5 X5 IX5 X5-X2 NEW FL LX1 18+1 SX3 X3 EXTRACT P-COUNTER FROM STACK SA4 B1+P.XPACK * MX0 6+18 BX6 -X0*X4 LX3 36 BX6 X6+X3 NEW P-COUNTER FOR X-PACK SA6 A4 STORE NEW P-COUNTER SA2 B1+P.XPACK+1 BX7 -X0*X2 SX6 B4 NEW RA SA3 B1+P.XPACK+2 LX6 36 BX6 X6+X7 SA6 A2 STORE NEW RA IN XPACK BX3 -X0*X3 LX5 36 BX6 X3+X5 SA6 A3 * SB7 SYSRET B2 = SUBP INDEX PL X1,SETRET1 JP IF ^INTERRUPTED^ NOT SET SB7 TOUSER MX6 1 RESET INTERRUPTED BIT IN STACK BX6 -X6*X1 LX6 59 SA6 A1 SETRET1 BX1 X1-X1 DONT SET ^INTERRUPTED^ IN JP INTCHK CASE OF INTERRUPT * TITLE SUBPROCESS JUMP RETURN * * JUMP RETURN - RETURNS TO THE AP2-TH * OCCURANCE IN THE STACK OF SUBPROCESS AP1 * (AP2=0 - - 1-ST OCCURANCE) * (AP2=-1 -- FIND LAST SUBP) * AP1: C - CLASSCODE * AP2: D - NUMBER ECSCODE JMRET JUMPRET SB7 *+1 EQ FINDNTHS SX1 X2 IX1 X6-X1 NZ X1,JUMPRET1 .SENSE DESIRED SUBP NOT TOP-OF-STACK SA1 B1+P.XPACK AX1 36 SB4 X6+1 SA4 B1+B4 BX4 X4*X0 BX7 X4+X1 SA7 A4 .STORE MODIFIED P-COUNTER JUMPRET1 SX6 X6+2 BX7 X2*X0 BX6 X6+X7 SA6 A2 EQ RETURN ENDECS JMRET TITLE COPY RETURN PARAMETERS TO/FROM ECS BUFFER * * * COPY RETURN PARAMETERS TO ECS BUFFER * * X1= DATA CONTROL WORD * X2= CAPABILITY CONTROL WORD * B7= RETURN LINK * * ALL REGISTERS USED * ON EXIT: ^P.PARAMC^ = BUFFER CONTROL DATA * (24/0,18/CAP COUNT,18/WORD COUNT) * EXT PARMBUF * GETRETP SA3 B1+P.XPACK+2 CHECK OUT DATA CONTROL WORD AX3 36 SUBPROCESS FL SX4 X1 STARTING ADDR FOR DATA WORDS NG X4,ERR1 ERROR: NEGATIVE POINTER LX1 60-30 SB5 X1 DATA WORD COUNT LT B5,B0,ERR3 ERROR: NEGATIVE WORD COUNT SX6 X4+B5 IX6 X3-X6 NG X6,ERR10 ERROR: DATA BLOCK NOT WITHIN FL * * CHECK OUT CAPABILITY CONTROL WORD SB2 X2 STARTING CAPABILITY INDEX LX2 60-30 LT B2,B0,ERR5 ERROR: NEGATIVE C-LIST INDEX SB3 X2 COUNT OF CAPABILITIES SB4 B3+B3 LT B3,B0,ERR3 ERROR: NEGATIVE CAP COUNT SB4 B4-P.PBUFL SA2 B1+P.XPACK+1 SB4 B4+B5 AX2 36 SUBPROCESS RA GT B4,B0,ERR7 ERROR: TOO MUCH STUFF FOR BUFFER IX2 X2+X4 SA0 X2 SX0 PARMBUF * + WE B5 MOVE DATA WDS TO ECS RJ E.ECS * SX6 B5 IX0 X0+X6 INCR BUFFER POINTER SX7 B3 LX7 18 BX7 X7+X6 SA7 B1+P.PARAMC SAVE BUFFER CONTROL DATA EQ B3,B0,GETRETP9 JP IF NO CAPABILITIES TO PASS * MOVE CAPABILITIES TO BUFFER * B2 = INDEX IF 1ST CAPABILITY * B3 = CAPABILITY COUNT * X0 = BUFFER ADDRESS SA4 B1+P.CLIST SA4 B1+X4 LENGTH OF LOCAL C-LIST SB4 X4 GT B4,B2,GETRETP7 JP IF INDEX IN LOCAL C-LIST * GETRETP1 SA4 A4+2 LENGTH OF NEXT C-LIST SB2 B2-B4 DECR INDEX SB4 X4 ZR X4,ERR4 ERROR: CAPABILITY INDEX TOO LARGE GE B2,B4,GETRETP1 LOOP * * B4 = LENGTH OF CURRENT C-LIST GETRETP2 SB5 B4-B2 FIND MIN (C-LIST LENGTH - INDEX, LE B5,B3,GETRETP3 COUNT, P.SCR / 2) SB5 B3 GETRETP3 SB6 P.SCRL/2 LE B5,B6,GETRETP4 SB5 B6 * * B5 =NUM CAPS TO MOVE THIS TRIP GETRETP4 SB3 B3-B5 DECR COUNT SA5 A4+1 MOT AND U.N. OF C-LIST BX1 X0 SAVE BUFFER POINTER SX0 X5 SA0 B1+P.SCR MX6 39 + RE 1 READ MOT RJ E.ECS SA3 A0 BX5 X5-X3 BX5 X6*X5 NZ X5,ERR6 ERROR: C-LIST GONE BX0 -X6*X3 MX7 59 IX0 X0-X7 INCR PAST C-LIST LENGHT SX2 B2 INDEX IN C-LIST LX2 1 IX0 X0+X2 SB6 B5+B5 + RE B6 RJ E.ECS READ CAPABILITITES * SX6 B6 WRITE TO BUFFER BX0 X1 + WE B6 RJ E.ECS IX0 X0+X6 INCR BUFFER ADDRESS SB2 B2+B5 INCR INDEX * * STEP TO NEXT TRIP * GETRETP5 EQ B3,B0,GETRETP9 JP IF DONE (COUNT= 0) NE B2,B4,GETRETP2 JP IF NOT TIME FOR NEXT C-LIST * SA4 A4+2 LENGTH OF NEXT C-LIST SB4 X4 SB2 B0 ZR X4,ERR4 ERROR: INDEX TOO LARGE JP GETRETP2 * * * X-FER CAPABILITIES FROM LOCAL C-LIST * GETRETP7 SB5 B4-B2 FIND MIN(LENGTH-INDEX,COUNT) LE B5,B3,GETRETP8 SB5 B3 GETRETP8 SB3 B3-B5 DECR COUNT SX6 B2+P.LOCALC SX6 X6+B2 SA0 B1+X6 ABS CM STARTING ADDR SB6 B5+B5 SB2 B4 INCR INDEX + WE B6 WRITE CAPABILITIES RJ E.ECS SX6 B6 IX0 X0+X6 INCR BUFFER ADDRESS JP GETRETP5 * * DONE GETRETP9 JP B7 RETURN EJECT * * COPY RETURN PARAMETERS FROM ECS BUFFER * * B7 = RETURN LINK * ^P.PARAMC^ = BUFFER CONTROL WD * PUTRETP SA1 B1+P.STACK SA1 B1+X1 1ST WD FROM TOP OF STACK SA2 B1+X1 WD 0 OF CURRENT SUBP LX2 60-18 SB2 X2 B2 _ REL RA OF CURRENT SUBP LX1 60-18 SA2 B1+X1 WD 0 OF END OF PATH SUBP LX2 6+18 LX1 18+1 SHIFT STACK WD TO ^INTERRUPTED^ NG X1,PUTRET13 ABORT IF CURRENT SUBP WAS INTERRUPTED SA1 A1+1 2ND WD FROM TOP OF STACK SX1 X1-1 SB3 X2 SB3 B3-B2 B3 _ FL OF FULL PATH SB4 B2+X1 P-COUNTER + REL RA MX6 9 SA1 B1+B4 XJ INSTR (WE HOPE) BX6 X6*X1 LX6 9 LX1 60-19 GET RETURN AUTH FLAG BIT SX6 X6-13B CHECK FOR CEJ INSTR NZ X6,ERR9 ERROR: XJ CLOBBERED PL X1,PUTRET13 JP IF NO RETURN AUTNORIZED SA1 A1+1 GET WORD WITH POINTER SB4 X1 LT B4,B0,ERR1 ERROR: NEGATIVE POINTER GT B4,B3,ERR2 ERROR: POINTER TOO LARGE SB4 B4+B2 SA1 B1+B4 DATA CONTROL WORD SA2 A1+1 CAPABILITY CONTROL WORD SA3 B1+P.PARAMC BUFFER CONTROL WORD MX4 15 ELIMINATE POSSIBLE PREVIOUS BX1 -X4*X1 NUMBER RETURNED FIELDS BX2 -X4*X2 SX4 X1 START OF DATA BUFFER LX1 30 NG X4,ERR1 ERROR: NEG DATA POINTER SB4 X1 WORD COUNT SB5 X4+B4 GT B5,B3,ERR10 ERROR: NOT ROOM IN SUBP FL LT B4,B0,ERR3 ERROR: NEGATIVE WORD COUNT SB5 X3 NUM DATA WORDS IN BUFFER SX4 X4+B2 REL CM ADDR FOR DATA WDS LT B4,B5,PUTRETP1 FIND MIN(RETURN CONTROL, NUM SB4 B5 WDS IN BUFFER) PUTRETP1 SX6 B4 PUT THE NUMBER RETURNED IN LX6 45 THE AUTHORIZATION FOR THE LX1 30 HAPPY RECEIVER BX6 X1+X6 SA6 A1 * * B4 = NUM DATA WDS TO MOVE * B5 = NUM DATA WDS IN BUFFER * X4 = REL CM ADDR FOR DATA WDS * X2 = CAPABILITY RETURN CONTROL * X3 = BUFFER DATA * * CHECK OUT CAPABILITY RETURN AX3 18 SB2 X2 STARTING CAPABILITY INDEX LT B2,B0,ERR5 ERROR: NEGATIVE C-LIST INDEX LX2 30 SB3 X2 LT B3,B0,ERR3 ERROR: CAP COUNT NEGATIVE SB6 X3 NUM CAPS IN BUFFER LT B3,B6,PUTRETP2 FIND MIN (CAPS IN BUFFER, RETURN SB3 B6 CONTROL) PUTRETP2 SX6 B3 PUT THE NUMBER RETURNED IN LX6 45 THE AUTHORIZATION SO THE LX2 30 HAPPY REIEIVER CAN TELL BX6 X2+X6 WHATS GOING ON SA6 A2 * * B2 = STARTING CAP INDEX * B3 = NUM CAPS TO MOVE * B4 = NUM DATA WDS TO MOVE * B5 = NUM DATA WDS IN BUFFER * X4 = REL CM ADDR FOR DATA * * CHECK FOR CAPS IN RANGE SA2 B1+P.CLIST SX1 B5 X1 _ NUM DATA WDS IN BUFFER SB5 B2+B3 MAX CAP INDEX SA2 B1+X2 SB6 X2 GE B6,B5,PUTRETP4 PUTRETP3 SA2 A2+2 SB5 B5-B6 SB6 X2 ZR X2,ERR4 ERROR: TOOM MANY CAPS GE B5,B6,PUTRETP3 * CAPABILITIES OK * **** MOVE DATA WORDS **** PUTRETP4 SA0 B1+X4 ABS CM ADDR SX0 PARMBUF + RE B4 RJ E.ECS IX1 X0+X1 INCR BUFFER ADDRESS * * **** MOVE CAPABILITIES **** * EQ B3,B0,PUTRET13 SKIP IF NO CAPS TO MOVE SA4 B1+P.CLIST SA4 B1+X4 LEN LOCAL C-LIST SB4 X4 GT B4,B2,PUTRET11 JP IF IN LOCAL C-LIST PUTRETP5 SA4 A4+2 LEN LNEXT C-LIST SB2 B2-B4 LOOK FOR PROPER C-LIST SB4 X4 GE B2,B4,PUTRETP5 * * MOVE NEXT SECTION OF CAPABILITIES * PUTRETP6 SB5 B4-B2 FIND MIN(LENGTH-INDEX, COUNT, LE B5,B3,PUTRETP7 P.SCR/2) SB5 B3 PUTRETP7 SB6 P.SCRL/2 LE B5,B6,PUTRETP8 SB5 B6 * B5 = NUM OF CAPS TO MOVE * B4 = LENGTH OF CURRENT C-LIST PUTRETP8 SB6 B5+B5 SA0 B1+P.SCR BX0 X1 + RE B6 READ CAPABILITIES RJ E.ECS SX1 X0+B6 INCR BUFFER ADDR SX6 A0 SB3 B3-B5 DECR COUNT * * MOVE CABILITIES TO C-LIST * X1 = BUFFER ADDRESS * X6 = CM ADDR * B6 = COUNT*2 * B2 = INDEX PUTRETP9 SA5 A4+1 MOT AND U.N. OF C-LIST SA0 B1+P.SCR2 SX0 X5+0 MX7 39 + RE 1 READ MOT RJ E.ECS SA3 A0 BX5 X5-X3 BX5 X7*X5 BX0 -X7*X3 NZ X5,ERR6 ERROR: C-LIST GONE MX7 59 -1 IX0 X0-X7 SX2 B2 INDEX LX2 1 IX0 X0+X2 SA0 X6 + WE B6 WRITE CAPABILITIES RJ E.ECS * * STEP TO NEXT SECTION * EQ B3,B0,PUTRET13 JP IF DONE (COUNT = 0) SB2 B2+B5 INCR INDEX NE B2,B4,PUTRETP6 JP IF NOT DONE W/ C-LIST * SA4 A4+2 MOVE TO NEXT C-LIST SB4 X4 LENGTH SB2 B0 INDEX _ 0 JP PUTRETP6 * * XFER TO LOCAL C-LIST * PUTRET11 SB5 B4-B2 FIND MIN(LENGTH-INDEX,COUNT) LE B5,B3,PUTRET12 SB5 B3 PUTRET12 SB3 B3-B5 DECR COUNT SX6 B2+P.LOCALC SX6 X6+B2 SX6 X6+B1 ABS CM ADDR SB6 B5+B5 BX0 X1 SA0 X6 + RE B6 READ CAPABILITIES RJ E.ECS SX1 X0+B6 INCR BUFFER ADDR JP PUTRETP9 GO COPY TO ECS COPY OF C-LIST * * ALL DONE PUTRET13 JP B7 * * SPACE 5 * *** ERRORS *** * ERR1 SX7 E.NEGPT NEGATIVE POINTER JP ERR8 ERR2 SX7 E.BIGPT FL EXCEDED JP ERR8 ERR3 SX7 E.NEGPAR NEGATIVE COUNT JP ERR8 ERR4 SX7 E.BCPBLK CAP BLK NOT ALL IN FUL C-LIST JP ERR8 ERR5 SX7 E.NEGIX NEGATIVE C-LIST INDEX JP ERR8 ERR6 SX7 E.CLMOT C-LIST GONE FROM MOT SX6 E.MISCE JP E.ERROR ERR7 SX7 E.ROOM ECS BUFFER EXCEDED SX6 E.SUBP JP E.ERROR ERR8 SX6 E.PARMS JP E.ERROR ERR9 SX7 E.NOXJ XJ CLOBBERED SX6 E.SUBP JP E.ERROR ERR10 SX7 E.BDTBLK DATA BLK EXCEDS FL JP ERR8 * TITLE FIND SUBPROCESS ON STACK * FINDNTHS FINDS THE NTH OCCURANCE OF A SUBP ON THE STACK * IT IS CALLED FROM ACTIONS WHICH MUST FOLLOW THE SHOWN * ACTUAL PARAMETER CONVENTIONS * PARAMETERS AP1: C - CLASS CODE * AP2: D - SKIP COUNT * B7: RETURN LINK * THE AP2TH OCCURANCE OF THE SUBP IS RETRIEVED BEGINNING * AT THE TOP OF STAVK.(0=FIRST OCCURANCE,-1=LAST OCCURANCE) * THE INDEX OF THE DESIRED STACK ENTRY IS RETURNED IN X6 * REGISTERS PRESERVED: B1,A0 ,A5/X5,A6,A7/X7 * X2 CONTAINS P.STACK ON RETURN * X0 CONTAINS MX0 42 ON RETURN * B6 CONTAINS -1 ON RETURN FINDNTHS SA1 B1+P.PARAM+2 SB6 -1 SB2 X1 .SCIP COUNT LT B2,B6,ERR202 SB4 B0 SA2 B1+P.STACK SA3 B1+X2 .INITIAL FETCH FROM STACK LX2 60-18 SB3 B1+X2 .STACK ORIGIN LX2 18 SA1 A1+B6 .CLASS CODE MX0 42 FNS1 SX4 X3+1 SA4 B1+X4 BX4 X4-X1 NZ X4,FNS2 .CLASS CODES DO NOT MATCH EQ B2,FNS3 SB2 B2-1 SB4 A3 FNS2 SB5 A3 SX6 B4-B1 SA3 A3-2 NE B5,B3,FNS1 .NOT YET END OF STAVK PL B2,ERR212 ZR B4,ERR212 JP B7 FNS3 SX6 A3-B1 JP B7 ERR202 SX1 1 EQ ERR20 ERR212 SX1 1 EQ ERR21 TITLE MODIFY P-COUNTER * MODPC IS THE ACTION TO MODIFY THE P-COUNTER OF A SPECIFIED * SUBPROCESS. IF THE CALLER TRIES TO MODIFY HIS OWN * P-COUNTER HE GETS AN FRETURN. * PARAMETERS: AP1 C: CLASS CODE * AP2: D: SKIP COUNT * AP3: D: NEW P-COUNTER ECSCODE MODPC MODPC SB7 *+1 EQ FINDNTHS SB2 X6 SB3 X2 EQ B2,B3,SYSFRET .CALLER SAME AS SPEC. SUBP SA2 X6+B1 .FETCH STACK ENTRY BX1 X2 SA3 B1+P.PARAM+3 .NEW P-COUNTER LX1 6+36 SA4 A2-B6 .SECOND WORD OF STACK ENTRY SA5 B1+X2 GET WD 0 OF ROOT OF PATH LX5 6+36 RA SB2 X3 SB2 B2+X5 SA1 B1+X1 LX1 6+18 SB3 X1 GT B2,B3,ERRMODP .P-COUNTER EXCEEDS FL SX3 X3 BX7 X4*X0 NG X3,ERRMODP1 ERROR..NEGATIVE P-COUNTER BX7 X7+X3 SA7 A4 .REWRITE STACK ENTRY SX0 -B6 LX0 58 BX6 X0+X2 .SET INTERRUPTED BIT SA6 A2 EQ SYSRET ERRMODP SX1 2 EQ ERR21 ERRMODP1 SX1 2 EQ ERR20 ENDECS MODPC TITLE FIND NTH SON * * FIND NTH SON OF A GIVEN SUBPROCESS * * IP1 C: CLASSCODE OF ALLEGED FATHER * IP2 D: N (NUMBER OF SON TO FIND) * IP3 D: C-LIST INDEX TO RETURN CLASSCODE OF SON * * NOTES: * RETURNS CAP FOR SON WITH SAME OPTION BITS AS IN * ORIGINAL CAP FOR FATHER * DOES F-RETURN IF ALLEGED FATHER HAS NO NTH SON * DOES ERROR IF ALLEGED FATHER DOES NOT EXIST * * EXT PUTCAP * ECSCODE FSON FSON SA3 B1+P.PARAM+2 NUMBER OF SON SB4 X3 TOTAL SONS TO FIND IN SCAN SB3 B0 TOTAL SONS FOUND IN SCAN SO FAR SA3 B1+P.PARAM+1 CLASSCODE OF FATHER SB2 8 SIZE OF A SUBPROC DESCRIPTOR SB7 FINDSON1 JP FINDSUB FIND FATHER FINDSON1 SB5 A5-B1 PTR TO FATHER SB6 A6-B1 PTR TO 2ND DEAD CELL EQ B5,B6,CRESUB27 ERROR..FATHER DOES NOT EXIST SB6 B5-1 SA3 B1+P.SUBPDT SUBP TABLE PTR LX3 24 ADDR OF 2ND DEAD CELL SB7 X3-1 ADDR OF 1ST DEAD CELL SX6 B6 SA6 B7+B1 STORE FATHER PTR IN 1ST DEAD CELL SB7 A6 REMEMBER ADDRESS OF DEAD CELL LX3 18 SHIFT SUBP TABLE ADDR SA5 X3+B1 1ST SUBP DESCRIPTOR FINDSON2 SB5 X5 CHECK FOR DESIRED FATHER PTR NE B5,B6,FINDSON3 NOPE..CONTINUE SCAN SB5 A5 SEE IF FOUND SON OR DEAD CELL. EQ B5,B7,SYSFRET DEAD CELL..DO F-RETURN SB3 B3+1 SON..INCR NO. OF SONS FOUND EQ B3,B4,FINDSON4 JUMP IF ENOUGH SONS FOUND FINDSON3 SA5 A5+B2 KEEP LOOKING JP FINDSON2 FINDSON4 SA5 A5+1 FOUND RIGHT SON..GET CLASSCODE BX6 X5 CHANGE FATHER CLASSCODE SA6 B1+P.PARAM+1 TO SON CLASSCODE SB5 B1+P.PARAM POINT TO SON CLASSCODE SA1 B1+P.PARAM+3 C-LIST INDEX TO RETURN SON SB6 SYSRET RETURN TO USER SB3 1 JP PUTCAP WITH SON CLASSCODE ENDECS FSON TITLE DISPLAY SUBPROCESS EJECT * * DISPLAY SUBPROCESS * * C. . . . CAPABILITY FOR SUBPROCESS DISPLAYED * D. . . . BUFFER ADDRESS * D. . . . BUFFER LENGTH * * X0=MASKS,SCRATCH * X1=RA * X2=FL B2=USERS RA,SCRATCH * X3=BUFAD B3=BUFAD,POSITION IN BUFFER * X4=BUFLEN B4=BUF LWA * X5=SCRATCH B5=NUM OF SUBPS,ADDR OF TARGET * SUBPROCESS * IN BUFFER * X6=SCRATCH * X7=SCRATCH,WORD TRANSMITTED TO BUFFER * * FETCH RA,FL,BUFFADD,BUFLEN * ECSCODE DSPSP DSPSP SA1 B1+P.XPACK+1 READ RA SA2 A1+1 READ FL LX1 24 LX2 24 SA3 B1+P.PARAM+2 READ BUFAD SA4 A3+1 READ BUFLEN SX1 X1 ISOLATE RIGHTMOST 18 BITS SX2 X2 * * CHECK BUFAD,BUFLEN FOR ERRORS * SX6 E.PARMS INITIALIZE X6 FOR ERRORS NG X3,DSP2 JUMP IF BUFAD < 0 SB2 X4-1 B2=BUFLEN-1=USERS OFFSET TO BUFAD LT B2,B0,DSP3 JUMP IF BUFLEN < OR= 0 IX0 X3-X2 X0=BUFAD-FL PL X0,DSP4 JUMP IF BUFAD >OR= FL IX0 X0+X4 PL X0,DSP5 JUMP IF BUF LWA >OR=FL * * COMPUTE THE NUMBER OF WORDS TRANSFERRED * SB3 X3 B3=BUFAD SB4 B3+6 B4=BUF MAX LWA SB2 B2+B3 B2=USER S LWA GE B2,B4,BUFL.OK JUMP IF USER S LWA > OR = * SYS LWA OF BUFFER SB4 B2 OTHERWISE B4=USER S BUF LWA * * FIND SUBPROCESS TO BE DISPLAYED * BUFL.OK SB2 X1 B2=X1=USERS RA SB3 B3+B2 B3=ABS BUFR ADR SA3 B1+P.PARAM+1 X3=TARGET SUBP SB7 GOTIT JP FINDSUBP GOTIT SB7 A6-1 B7=ADR+1 OF SUBP TABLE END SB5 A5-1 B5=ADDR OF SUBP NE B7,B5,DSP.OK JUMP IF SUBP IS OK SX6 E.SUBP SX7 E.NOFIND EQ E.ERROR NO SUCH SUBPROCESS * * CONSTRUCT WORD 1 OF DISPLAY PACKAGE * DSP.OK SA1 B5 READ WORD 0 OF DESCRIPTOR MX0 1 MASK FOR INTERRUPT FLAG BX7 X0*X1 ISOLATE INTERRUPT FLAG MX0 18 MASK FOR 18 BIT DATA LX1 6 BX5 X0*X1 ISOLTE RA+FL LX1 18 BX6 X0*X1 ISOLATE RA LX5 18 POSITION X5 LX6 18 RIGHT JUSTIFY RA IX6 X5-X6 X6=FL LX6 36 POSITION FL IX7 X6+X7 ADD FL TO X7 SA1 A1+2 READ WORD 2 OF DESCRIPTOR LX1 6 MX0 36 MASK FOR ENTRY PT,MAP ORG BX6 X0*X1 ISOLATE IN X6 AX6 6+18 POSITION IX7 X6+X7 ADD TO X7 MX0 18 REFORM MASK SA7 B3 TRANSMIT TO USER EQ B3,B4,SYSRET IF BUFFER IS EXHUSTED GO TO SYSRET * * CONSTRUCT WORD 2 OF DISPLAY PACKAGE * DSP.W2 SB3 B3+1 RESET BUFFER POINTER SA1 B5 READ FATHER POINTER SB7 B1+X1 SA1 B7+1 READ FATHER S CLASS CODE BX7 X1 SA7 B3 TRANSMIT FATHER S CLASS CODE EQ B3,B4,SYSRET IF BUFFER IS EXHAUSTED, GOTO SYSRET * * CONSTRUCT WORD 3 OF DISPLAY PACKAGE (SUBP. CLASS CODE) * DSP.W3 SB3 B3+1 RESET BUFFER POINTER SA1 B5+1 READ SUBP CLASS CODE BX7 X1 SA7 B3 TRANSMIT CLSS CODE TO USER EQ B3,B4,SYSRET IF BUFFER IS EXHAUSTED GOTO SYSRET * * CONSTRUCT WORD 4 (C-LIST ORIGI, COMP MAP BUF SIZE, * INTERRUPT DATUM) * DSP.W4 SB3 B3+1 RESET BUFFER POINTER SA1 B5+2 SX7 X1 PUT C-LIST ORIGIN IN X7 LX7 36 POSITION X7 SA1 A1+1 READ COMP BUF SIZE LX1 6 LEFT JUSTIFY BX6 X1*X0 ISOLATE IN X6 LX6 36 POSITION IN X6 IX7 X6+X7 ADD COMP BUF SIZE SA1 A1+1 READ INTERRUPT DATUM LX1 24 RIGHT JUSTIFY INTERRUPT DATUM SX2 X1 ISOLATE INTERRUPT DATUM IX7 X2+X7 ADD INTERRUPT DATUM SA7 B3 EQ B3,B4,SYSRET IF BUFFER IS EXHAUSTED GOTO SYSRET * * CONSTRUCT WORD 5 (NUMBER OF LOG MAP ENTRIES, C-LIST LENGTH, * MAX STACK POINER) * DSP.W5 SB3 B3+1 RESET BUFFER POINTER MX0 36 FORM MASK BX7 X0*X1 ISOLTE # LOG MAP ENTRIES * AND C-LIST LENGTH LX7 54 POSITION X7 SA1 A1+2 READ MAX STACK POINTER SX1 X1 ISOLATE MAX STACK POINTER IX7 X1+X7 ADD MAX STACK POINTER SA7 B3 EQ B3,B4,SYSRET IF BUFFER IS EXHAUSTED GOTO SYSRET * * CONSTRUCT WORD 6 ( THE C-LIST) * DSP.W6 SB3 B3+1 RESET BUFFER POINTER SA1 A1-1 READ C-LIST UNIQUE NAME BX7 X1 SA7 B3 EQ B3,B4,SYSRET IF BUFFER IS EXHAUSTED GOTO SYSRET * * CONSTRUCT LAST WORD (ESM DATA) * DSP.W7 SB3 B3+1 RESET BUFFER POINTER SA1 A1+1 READ WORD 6 LX1 24 RIGHT JUSTIFY ESM OINTER SX2 X1 ISOLATE ESM SA3 B1+X2 A3=B1+ESM POINTER (ESM IS WITH MAPS) MX0 32 BX7 X0*X3 ISOLATE ESM AX1 18 RIGHT JUSTIFY MAX ERROR CLASS SX1 X1 ISOLATE MAX ERR CLASS IX7 X1+X7 ADD MAX ERR CLASS SA7 B3 DSPEND EQ SYSRET DO NORMAL RETURN * * ERRORS * DSP2 SX7 E.NEGPT NEGATIVE ADDRESS EQ E.ERROR DSP3 SX7 E.NEGPAR NEGATIVE PARAMETER EQ E.ERROR DSP4 SX7 E.BIGPT BUFFER ADDR > OR= FL EQ E.ERROR DSP5 SX7 E.BIGPAR LWA > OR = FL EQ E.ERROR ENDECS DSPSP TITLE SET OR CLEAR INTERRUPT-INHIBIT BIT * SETIIB AND CLRIIB ARE ECS ACTIONS TO SET OR CLEAR * THE INTERRUPT-INHIBIT BIT, RESPECTIVELY. ENTRY SETIIB,CLRIIB SETIIB SA1 B1+P.STACK MX2 1 SA1 B1+X1 .FETCH CURRENT TOP-OF-STACK LX2 58 .POSITION I-I BIT BX6 X1+X2 SA6 A1+0 .STORE ALTERED STACK ENTRY EQ SYSRET SPACE 5 CLRIIB SA1 B1+P.STACK MX2 1 SA1 B1+X1 .FETCH CURRENT SUBPROCESS LX2 58 .POSITION I-I BIT BX6 -X2*X1 SA6 A1 .REWRITE STACK ENTRY SB2 X1 INDEX OF CURRENT SUBPROCESS * SET P-COUNTER IN STACK IN CASE OF * INTERRUPT...INTERRUPT USUALLY EXPECTS * TO OCCUR DURING SUBPROCESS XFER SA2 B1+P.XPACK AX2 36 P-COUNTER BX6 X2 SA6 A6+1 STORE IN STACK * BX1 X1-X1 INDICATE NOT TO SET ^INTERUPTED^ * IN STACK IN CASE FO INTERUPT SB7 SYSRET JP INTCHK CHECK FOR INTERRUPTS AND EXIT * EJECT TITLE SUBPRCESS FRETURN * THIS ROUTINE HANDLES FRETURN ACTION * THERE ARE TWO ENTRY POINTES...ONE FOR * AND ECS SYSTEM INNITIATED FRETURN AND ONE FOR * USER INNITIATED FRETURN * * TEMPORARIES USED .. P.TEMP1, P.TEMP2, P.TEMP3, * AND P.TEMP4 * ROUTINES CALLED, ENVIORN, GETCAP, AND OPINTER * TYPES XTEXT EXT GETCAP,OPFRT,UCALL3 ENTRY SYSFRET,FRETURN * SYSTEM ENTRY POINT FOR FRETURN SYSFRET SA1 B1+P.STACK .. CONSTRUCT WD 1 FOR CURRENT STACK ENTRY SA1 B1+X1 SB2 X1 SA2 B1+P.XPACK .. GET P-COUNTER SA3 A1+1 AX2 36 SA1 B1+P.IPLIST .. GET IPLIST LX1 18 BX6 X2+X1 . .. ADD IPLIST AND P-COUNTER SA6 A3 JP FRET2 * * * USER ENTRY FOR FRETURN FRETURN SA1 B1+P.STACK SX6 2 DECREMTNT STACK POINTER IX6 X1-X6 LX1 6+36 SA2 X6+B1 FETCH WD 0 OF NEW STACK ENTRY LX2 1 TEST ^INTERRUPTED^ BIT IN NG X2,FRET20 STACK...ERROR IF SET ALREADY LX2 59 SA3 A2+1 FETCH WD 1 OF NEW STACK ENTRY SB2 X1 STACK ORIG SB3 X6 NEW STACK POINTER LT B3,B2,FRET16 ERROR - EMPTY STACK AX3 18 GET IP LIST ADDR BX7 X3 ZR X7,FRET20 ERROR: NO IPLIST SPECIFIED SA6 A1 STORE NEW STACK POINTER * SPACE 3 * * GLITCH * * WHEN OPINTER PROCESSES BLOCK DATA IT LOOKS AT * THE RA & FL STORED IN P.XPACK (+1,+2). * AN ERROR IS GENERATED IF THE POINTER IS * LESS THAN THE RA OR IF THE END OF BLOCK DATA * IS EQUAL OR GREATER THAN THE FL. * * AT THIS POINT THE XPACK REFLECTS THE SUBPROCESS * WHICH IS MAKING THE F-RETURN, NOT THE SUBPROCESS * WHICH INVOKED THE MULTI-LEVEL OPERATION. * * REFLECTS THE SUBPROCESS WHICH INVOKED THE * MULTI LEVEL OPERATION. THE P COUNTER IS PATCHED * INTO THE XPACK INCASE AN ERROR IS GENERATED * XPACK INCASE AN ERROR IS GENERATED. * P.XPACK+1 (RA) AND P.XPACK+2 (FL) ARE PATCHED TO * REFLECT THE RA AND FL OF THE SUBPROCESS WHICH * INVOKED THE OPERATION * SA4 B1+X2 .. FETCH CURRENT SUBP HEADER WORD * SB2 X2 .. CALL ENVIORN: B2=CALLEE=CURRENT SUBP * MX0 18 .. MASK FOR 18 BIT FIELDS LX2 6+36 .. END OF PATH POINTER SA5 B1+X2 .. FETCH END OF PATH HEADER WORD * SB6 X2 .. TOP OF PATH: SET FOR ENVIORN CALL * SA3 A3 .. FETCH WD 1 OF STACK LX3 6+36 BX3 X0*X3 .. ISOLATE P-COUNTER AX3 6 .. POSITION P-COUNTER SA1 B1+P.XPACK LX1 6 BX6 -X0*X1 .. ELIMINATE OLD P-COUNTER LX6 60-6 BX6 X6+X3 .. ADD P-COUNTER SA6 A1+0 .. XMIT * LX4 6+18 .. LEFT JUSTIFY RA BX6 X4*X0 .. ISOLATE LX5 6 .. LEFT JUSTIFY RA+FL BX5 X5*X0 .. ISOLATE IX5 X5-X6 .. COMPUTE RELATIVE FL SX4 B1 LX4 6+36 .. LEFT JUSTIFY B1 IX5 X5+X4 .. ABSOLUTE FL IX6 X6+X4 .. ABSOLUTE RA SA4 B1+P.XPACK+1 .. READ XPACK RA AX6 6 .. POSITION NEW RA LX0 60-6 .. POSITION MASK BX4 -X0*X4 .. CLEAR OUT OLD RA BX6 X6+X4 .. ADD NEW RA SA6 A4 .. XMIT RA SA4 A4+1 .. READ XPACK FL BX6 -X0*X4 .. CLEAR OUT OLD FL AX5 6 .. POSITION NEW FL BX6 X6+X5 .. ADD NEW FL SA6 A4+0 .. XMIT NEW FL SPACE 3 SA7 B1+P.IPLIST SB7 FRET2 JP ENVIORN * * * ENTRY FROM FRETURN WITH PARAMS * * * FRET2 SA1 B1+B2 GET RA OF SUBP LX1 6+36 SB3 B1+X1 ABSOLUTE RA SA2 B1+P.IPLIST SA1 B3+X2 FETCH IP0 * NOTE ... A1 MUST BE PROSERVED SB6 FRET3 SB3 B0 .. ERROR MODIFIER JP GETCAP FETCH CAPABILITY INDEXED BY IP0 * FRET3 SA2 A0 1ST WD OF CAPABILITY IP0 SX2 X2-T.OPER NZ X2,FRET17 ERROR - IP0 NOT AN OPERATION SA3 A0+1 2ND WD OF CAPABILITY IP0 SX0 X3 SA0 B1+P.SCR2 + RE 1 READ MOT ENTRY RJ E.ECS SA2 A0 CHECK MOT ENTRY MX6 39 BX3 X3-X2 BX3 X3*X6 NZ X3,FRET18 ERROR - OPERATION GONE FROM MOT BX0 -X6*X2 + RE 1+PS.MASKL READ HEADER WD AND TYPE MASK RJ E.ECS SA2 A0 HEADER WD LX2 6+18 SB6 X2 LENGTH OF 1ST ORDER OF OPER SA5 B1+P.STACK SA5 B1+X5 STACK ENTRY ( WD 0 ) SB7 1 AX2 6+36 NUM OF ORDERS LX5 6+18 OP COUNT SX6 X5+B7 IX3 X2-X6 ZR X3,FRET11 JP IF ALL ORDERS USED UP NG X3,FRET11 GRARD AGAINST SWITCHED OPERATION SX7 B7 IX7 X5+X7 PUT NEW OP COUNT IN STACK SA6 B1+P.TEMP2 SAVE ( NUM ORDERS -1 ) TO PROCESS LX7 36+2 CLEAR POSSIBLE INTERRUPT OR FORCED AX7 2 FRETURN FROM STACK SA7 A5 STORE NE OP COUNT LX5 18 SHICT TO TOP OF PATH SUBP BX6 X6-X6 SA6 B1+P.TEMP3 INNITIALIZE COUNTER OF ORDERS DONE SX6 PARMBUF INITIALIZE POINTER TO ECS BUFFER SA6 B1+P.TEMP6 FOR BLOCK PARAMETERS (USED BY OPINTER) SA5 X5+B1 TOP OF PATH SUBP ( WD 0 ) LX5 6+18 RA+FL OF TOP OF PATH SX7 X5+B1 ABS USER ADDRESS SPACE LIMIT SA7 B1+P.TEMP4 SAVE USER ADDR SPACE LIMIT BX6 X0 ECS ADDR OF OPER SX3 1+PS.MASKL IX0 X3+X0 SA0 B1 SA6 B1+P.TEMP1 SAVE ECS ADDR SB5 B1+P.LOCALC SA3 B1+P.CLIST SA6 B1+P.PARAM-1 SA3 B1+X3 LOCAL C-LIST LENGTH SB4 X3 * * FRET5 RE B6 READ IN ORDER OF OPERATION RJ E.ECS SA2 A0 NG X2,FRET7 JP IF NO PARAMETERS SA3 B1+P.TEMP4 USER ADDR SPACE LIMIT SB6 B6+A1 SB2 X3 SA3 A2+B7 SB6 A1 SB6 B6+X3 GE B6,B2,FRET19 ERROR - IP LIST EXTENDS TOO FAR LX2 6+18 GET PTR TO 1ST PS DATA SB2 X2 SB6 FRET7 SA2 A0+B2 PRE-FETCH PS DATA SA3 A0+3 PRE-FETCH PS BYTES JP OPFRT * * FRET7 SA5 B1+P.TEMP3 COUNT OF ORDERS PROCESSED SX7 X5+B7 SA4 B1+P.TEMP2 NUM ORDERS TO PROCESS -1 IX5 X4-X7 SA7 A5 STORE INCREMENTED ORDER COUNT NG X5,FRET9 JP IF DONE LAST ORDER SA4 B1+2 LX4 6+18 SB6 X4 LENGTH OF NEXT ORDER SA5 B1+P.TEMP1 ECS ADDR OF IST ORDER LX4 18 SX0 X4 IX0 X0+X5 SA0 B1 JP FRET5 * * END OF DOING ORDERS FRET9 SX6 1 SET ^P.OLDP^ TO INHIBIT P-COUNTER SET SA6 B1+P.OLDP (X2= CLASSCODE FROM ^OPINTER^) JP UCALL3 JUMP TO USERCALL ROUTINE TO COMPLETE * * * ALL ORDER USED ALREADY..RETURN TO TOP * OF STACK FRET11 SA1 B1+P.STACK STACK POINTER ALREADY DECREMENTED SA1 B1+X1 ST B2 = SUBPROCESS TO RETURN TO MX6 1 SET INTERRUPTED BIT TO INHIBIT LX6 59 P-COUNTER MODIFICATION BX6 X1+X6 SA6 A1 JP SETRET SET UP RETURN * * SPACE 5 * ERRORS * * FRET16 SX7 E.STK EQ CL4 FRET17 SX7 E.IP0 EQ CL7 FRET18 SX7 E.NOOP CL7 SX6 E.OPER EQ E.ERROR FRET19 SX1 B6 SX7 E.BIGPT EQ CL2 FRET20 SX7 E.IFRET ILLEGAL FRETURN (INTERRUPT) JP CL4 TITLE SCOPE CALL AND ARRITH ERROR CALL ENTRY S.CHIP,S.ARITH * * EXCHANGE PACKAGE FOR (RA+1) .NE. 0 * S.CHIP BSSZ 16 P-COUNTER ETC. SET IN ^INITL^ * * EXCHANGE PACKAGE FOR ARITH ERROR (RA) .NE. 0 * S.ARITH BSSZ 16 P-COUNTER ETC. SET IN ^INITL^ * SPACE 5 * ENTRY CHIPCAL,ARITHER EXT S.CHARG,S.OLDTM,S.USRTM EXT S.CMFL,S.ECSRA,S.ECSFL * * SCOPE SIMULATOR CALL...(RA+1) .NE. 0 * CHIPCAL SA1 S.CHIP+1 GET (RA+1) FOR ERROR NUMBER LX1 6+18 SA1 X1+1 SX6 E.CHIP SA0 S.CHIP SB3 CHIPCAL JP RAERR * * ARITH ERROR ... (RA) .NE. 0 * ARITHER SA1 S.ARITH+1 GET (RA) FOR ERROR NUMBER LX1 6+18 SA1 X1 SX6 E.ARITH ERROR CLASS SA0 S.ARITH SB3 ARITHER * * RAERR SA2 S.USRB1 GET B1 FOR THE USER SB1 X2 NO 1 TURN OFF TRACE SA2 B1+P.STACK . STACK POINTER SA2 B1+X2 . TOP OF STACK MX3 1 LX3 59 . MAKE INTERUPTED POINTER BX7 X3+X2 SA7 A2+0 . SET ^INTERUPTED^ BIT IN TOP OF STAC SA2 S.CHARG UPDATE USER TIME CLOCKS SA3 S.OLDTM SA4 B1+P.USRTIM BX7 X2 SA7 A3 IX5 X2-X3 IX7 X5+X4 SA2 S.USRTM SA7 A4 IX7 X5+X2 SA7 A2 * EXT PACKBUF * MOVE USER EXCHANGE PACKAGE * SX0 PACKBUF + WE 16 RJ E.ECS SB2 A0 SA0 B1+P.XPACK + RE 16 RJ E.ECS * * FIX UP EXCHANGE PACKAGE SX7 B3 SET P-COUNTER LX7 36 SA7 B2 BX7 X7-X7 SA7 A7+1 SET RA SB6 36 SA2 S.CMFL SET FL LX7 X2,B6 SA7 A7+1 SA2 S.ECSRA ECS RA LX7 X2,B6 SA7 A7+2 SA2 S.ECSFL ECS FL LX7 X2,B6 SA7 A7+1 * * BX7 X1 SET ERROR NUMBER JP E.ERROR TITLE USER INNITIATED ERROR ECSCODE ERCAL * * ECS ACTION...USER INNITIATED ERROR * AP1 = D: ERROR CLASS * AP2 = D: ERROR NUMBER * ENTRY ERRCALL * ERRCALL SA2 B1+P.PARAM ERROR CLASS SA3 B1+P.PARAM+1 ERROR NUMBER NG X2,ERRCALL1 NG X3,ERRCALL2 SA1 B1+P.STACK SX6 2 DECREMENT STACK IX6 X1-X6 SB4 X6 LX1 60-18 SB5 X1 GT B5,B4,RETURN11 ERROR:STACK EMPTY SA6 A1 SX6 1 INHIBIT P-COUNTER SETTING IN SA6 B1+P.OLDP OLD STACK DURING ERROR CALL BX6 X2 BX7 X3 JP ERROR0 * * ERRCALL1 SX1 0 JP ERR20 ERROR: NEGATIVE PARAM ERRCALL2 SX1 1 JP ERR20 * * ENDECS ERCAL TITLE SUBPROCESS ERROR HANDELING * * ERROR PROCESSING * THE CURRENT SUBP HAS MADE AN ERROR * WHICH WAS DETECTED BY THE ECS SYSTEM * * X6 = ERROR CLASS * X7 = ERROR NUMBER * ENTRY E.ERROR * E.ERROR BX5 X7 BX7 X7-X7 INDICATE OLD STACK ENTRY IS TO SA7 B1+P.OLDP BE UPDATED BX7 X5 * * ENTRY FROM USER INITIATED ERROR ERROR0 SA7 B1+P.PARAM SAVE ERROR NUMBER SA1 B1+P.STACK START SEARCH FOR A * SUBP TO HANDLE ERROR FROM * CURRENT SUBPROCESS SX2 X1 STACK POINTER LX1 6+18 SX3 X1 END OF STACK POINTER IX3 X3-X2 ZR X3,KILLPROC DESTROY PROC IF STACK FULL * SA1 B1+X2 LX1 6+36 GET TOP OF PATH SB6 X1 LX1 18 * MX0 55 DE-COMPOSE ERROR CLASS BX2 -X0*X6 SB3 X2 SHIFT COUNT BX2 X0*X6 AX2 5 ESM INDEX * BX7 X1 SAVE CURRENT SUBP SA7 B1+P.PARAM+2 * ERROR1 SA1 B1+X1 WD 0 OF SUBP DISC SA3 A1+6 WD 6 OF SUBP DISC SX1 X1 LX3 6+18 PTR TO ORIG OF ESM IX4 X3+X2 LX3 18 TEST FOR CLASS IN RANGE SX3 X3 FOR THIS SUBP IX3 X3-X6 NG X3,ERROR15 SA3 B1+X4 LX4 B3,X3 NG X4,ERROR2 JP IF FOUND A SUBP ERROR15 NZ X1,ERROR1 LOOP IF NOT ROOT OF TREE * SX5 X6-E.NOERR IF REPEAT OF ^NOERROR^ STOP PROCESS ZR X5,STOPROC GO DESCHEDULE PROCESS SA5 B1+P.PARAM BX7 X5 * SA6 STOPROC2 SAVE ERROR CLASS AND NUMBER SA7 STOPROC3 IN CASE OF ERROR-ERROR * MX0 36 BX6 -X0*X6 .. SAVE LOWER 24 BITS OF ERR CLASS LX6 36 MX0 24 .. MAKE SURE MODIFIER IS ONLY 18 BITS LONG BX7 -X0*X7 BX7 X6+X7 .. X7 := OLD ERROR * * X7:= VFD 24/TRUNCATED CLASS,18/MODIFIER,18/NUMBER * SX6 E.NOERR ERROR... NO SUBP TO TAKE * THE ERROR CLASS JP ERROR0 NOTE.. SHOULD BE A SPECIAL * ERROR CLASS * * FOUND A SUBP TO TAKE THE ERROR * ERROR2 SB2 A1-B1 SUBP TO CALL SA5 B1+P.STACK CHECK FOR ROOM IN STACK SX3 X5 STACK POINTER SA5 A1+6 WD 6 OF SUBP DISCRIPTOR SX5 X5-1 IX5 X5-X3 NG X5,ERROR15 JP IF SUBP CANNOT TAKE ERROR DUE * STACK TOO FULL * MX0 1 RESET ERROR CLASS BIT IN ESM SB4 60 SB3 B4-B3 BX4 -X0*X4 LX7 B3,X4 SA7 A3 * * CALL ^CALL^ * * B2 = CALLER * B6 = TOP OF PATH * B7 = RETURN * X2 = NEW STACK POINTER * X3 = 0... MEANS SETP. COUNTER AND IPLIST * IN OLD STACK ENTRY * SA6 B1+P.PARAM+1 SAVE ERROR CLASS SA1 B1+P.STACK SA3 B1+P.OLDP STACK MANIPULATION FLAG SX6 2 IX6 X1+X6 SA6 A1 SX2 X6+0 SB7 ERROR3 SX1 1 TYPE OF CALL (ENTRY POINT OFFSET) JP CALL * ERROR3 SA2 B1+P.PARAM+2 INITIALIZED SUBPROCESS CORE SB6 ERROR4 SX2 X2+0 JP SUBPCOR ERROR4 SA1 B1+P.PARAM RECOVER ERROR NUMBER SA2 B1+P.PARAM+1 RECOVER ERROR CLASS BX6 X2 BX7 X1 SA6 A6+1 STORE IN SUBP CORE SA7 A6+1 * NOTE: B2 = INDEX OF NEW CURRENT SUBP MX1 1 LX1 59 INTERRUPTED TO BE SET IN CASE OF SB7 TOUSER AN INTERRUPT JP INTCHK SPACE 5 EXT I.LOCK * * MUST DESTROY PROCESS * KILLPROC SX6 1 LOCK OUT PPU INTERRUPTS SA6 I.LOCK * SA1 B1+P.ROHEAD GET MOT OFR PROCESS LX1 6+36 SX0 X1 SA0 B1 + RE 1 RJ E.ECS * MX6 39 GET P.ROHEAD FORM PROCESS IN ECS SA1 A0 BX0 -X6*X1 + RE 1 RJ E.ECS * SA1 A0 SET DESTROY BIT AND PENDING ACTION SX6 4200B FLAG LX6 36+12 BX6 X1+X6 SA6 A1 WRITE BACK TO ECS ... PROCESS WILL B + WE 1 BE DESTROYED NEXT TIME IT SWAPS IN RJ E.ECS * BX6 X6-X6 CLEAR PPU LOCKOUT SA6 I.LOCK * EXT S.QUANT,S.SYSTM EXT CLKWAIT,SWAPOUT * DOSWAP MX6 1 MUST STOP QUANTUM CLOCK SA6 S.QUANT SB6 CLKWAIT DOSWAP1 SB6 B6-1 LOOP TO GIVE PPU TIME TO INTERFERE NE B6,B0,DOSWAP1 SA1 A6 TEST QUANTUM CLOCK LX1 1 NG X1,DOSWAP * * SA1 S.CHARG UPDATE SYSTEM CLOCKS SA2 S.OLDTM SA3 B1+P.SYSTIM BX6 X1 SA6 A2 IX5 X1-X2 IX7 X3+X5 SA4 S.SYSTM SA7 A3 IX6 X4+X5 SA6 A4 * * JP SWAPOUT CALL SWAPPER * SPACE 5 EXT DESCHED * * STOP PROCESS...MAY BE RESTARTED BY INTERRUPT * STOPROC SX6 1 STOP PPU INTERRUPTS SA6 I.LOCK SA1 B1+P.ROHEAD LX1 6+36 SX1 X1 * * RESET RUNNING FLAG * SX0 X1 SA0 B1 + RE 1 READ MOT RJ E.ECS SA2 A0 MX6 39 BX0 -X6*X2 ECS ADDR OF P.ROHEAD + RE 1 RJ E.ECS SA2 A0 MX6 1 LX6 60-2 BX6 -X6*X2 CLEAR RUNNING FLAG SA6 A2 + WE 1 RJ E.ECS * SB7 STOPROC1 JP DESCHED DESCHEDULE PROCESS * STOPROC1 BX6 X6-X6 RELEASE PPU INTERRUPT LOCKOUT SA6 I.LOCK * * SA4 STOPROC2 SAVE ORIG ERROR IN X6 AND X7 OF USER SA5 STOPROC3 BX6 X4 BX7 X5 SA6 B1+P.XPACK+14 SA7 B1+P.XPACK+15 * * * JP DOSWAP FORCE A SWAPOUT * * * STOPROC2 BSSZ 1 SAVE ERROR CLASS IN CASE OF STOPROC3 BSSZ 1 ERRNUMS XTEXT EJECT TITLE ESM MANIPULATION ROUTINES * ECS ACTION... SET ESM OF SPECIFIED SUBPROCESS * * AP1 = POINTER TO NEW ESM * AP2 = CAP FOR A CLASS CODE(SUBPROCESS NAME) * ENTRY ESMSETN * ESMSETN SA3 B1+P.PARAM+2 FIND THE PROPER SUBP SB7 ESMSETN1 JP FINDSUBP * ESMSETN1 SB4 A5-1 SB3 A6-1 SB2 B4-B1 REL SUBPROCESS INDEX NE B4,B3,ESM2 JP IF FOUND SUBP * SX6 E.SUBP ERROR-NO SUCH SUBP SX7 E.NOFIND EQ E.ERROR * SPACE 5 * * ECS ACTION...SET ESM OF CURRENT SUBPROCESS * * AP1 = POINTER TO NEW ESM * ENTRY ESMSET * ESMSET SA1 B1+P.STACK SA1 B1+X1 SB2 X1 * * * * B2 = SUBP PTR * B1+P.PARAM = PTR TO NEW ESM BLOCKED 32 * BITS PER WORD IN USER CORE * ESM2 SA3 B1+P.PARAM POINTER TO NEW ESM NG X3,ESM4 ERROR: NEGATIVE POINTER SA4 B1+P.XPACK+2 AX4 36 FL SB3 B2+6 SA2 B1+B3 WD 6 OF SUBP DISC LX2 6+36 SHIFT TO NUM ERR CLASSES SX5 X2 AX5 5 NUM WDS OF ESM IX5 X5+X3 MAX USER ADDR IX4 X5-X4 PL X4,ESM5 ERROR: ESM DATA EXCEDES FL * SA4 B1+P.XPACK+1 AX4 36 RA SB2 X2-1 NUM ERR CLASSES - 1 LX2 6+36 SHIFT TO ESM POINTER IX3 X4+X3 SA4 X3 1ST WD OF NEW ESM BX6 X4 SA6 B1+X2 SB2 B2-32 LT B2,B0,SYSRET RETURN IF DONE * ESM3 SA4 A4+1 BX6 X4 SA6 A6+1 SB2 B2-32 GE B2,B0,ESM3 JP SYSRET * * * ERRORS * ESM4 SX1 1 X1=1=PTR TO BAD VALUE IN AP LIST EQ ERR20 ESM5 SX1 1 X1=1=PTR TO BAD VALUE IN AP LIST EQ ERR21 EJECT TITLE SUBPROCESS SUBROUTINES * THIS ROUTINE INITLIZES THE SUBPROCESS LOW CORE * WITH THE TYPE OF CALL AND THE RELATIVE ORIGINS * OF THE CALLERS CORE, C-LIST, AND MAP). * * ON ENTRY B2 = REL INDEX OF CALLEE * B6 = RETURN LINK * X2 = 0 IF NEW TOP OF PATH * OTHERWISE ORIG OF CALLER * * ON EXIT B4 = ABS RA+FL OF CALLEE * B7 = 1 * A6 = ABS CALLEE RA+5 * * REGISTERS USED A2/X2,A3/X3,A4/X4,A5/X5,A6/X6, * B4, AND B7 * ENTRY SUBPCOR * SUBPCOR SB7 1 SA3 B1+B2 CALLEE LX3 6+18 SB4 X3+B1 ABS RA+FL OF CALLEE LX3 18 BX6 X6-X6 * * INNITIALIZE SUBPROCESS LOW CORE SA6 X3+B1 SET CALLEE RA = 0 SA6 A6+B7 SET CALLEE (RA+1) = 0 SA6 A6+B7 EXTRA WORD.....CAN BE USED * BY SYSTEM AT LATER DATE FOR * WHATEVER IS NEEDED * ZR X2,SUBCORE1 JP IF NEW TOP OF PATH SX3 X3 MUST TRY TO COMPUTE ORIGINS FOR HEADER SA4 X2+B1 CALLER LX4 6+36 CALLER RA SX4 X4 SA5 A3+2 MAP AND C-LIST ORIG OF CALLEE IX6 X4-X3 CALLER RA - CALLEE RA SX2 X5 CALLEE C-LIST ORIG SA4 A4+2 CALLER MAP AND C-LIST ORIGINS NG X6,SUBCORE1 JP IF INCREASING ORIGINS SX3 X4 CALLER C-LIST ORIGIN/ SA6 A6+B7 CALLEE (RA+3) = ADDR SPACE REL DIFF IX6 X3-X2 CALLER C-LIST ORIG-CALLEE C-LIST ORIG LX5 6+36 SA6 A6+B7 CALLEE(RA+4)= C-LIST REL DIF SX5 X5 CALLEE MAP ORIGIN LX4 6+36 SX4 X4 CALLER MAP ARIGIN IX6 X4-X5 SA6 A6+B7 CALLEE(RA+5)= MAP ORIGIN DIFF JP B6 * SUBCORE1 BX6 X6-X6 SET ALL ORIGINS = 0 SA6 A6+B7 SA6 A6+B7 SA6 A6+B7 JP B6 EJECT * SEARCH FOR NAMED SUBPROCESS * * ENTRY CONDITIONS X3 = NAME OF SUBP TO FIND * B7 = RETURN * EXIT A5 = ADDR+1 OF SUBP FOUND * A6 = ADDR+1 OF END OF TABLE * * REG USED A5/X5,A6/X6,B6 FINDSUBP SA5 B1+P.SUBPDT STORE NAME AT END OF * ENTRY FINDSUB FINDSUB EQU FINDSUBP * LX5 6+18 TABLE BX6 X3 SA6 B1+X5 LX5 18 SX5 X5+1 SB6 8 * START OF SEARCH SA5 B1+X5 BX5 X5-X3 ZR X5,FOUND FINDSUB1 SA5 A5+B6 BX5 X5-X3 ZR X5,FOUND SA5 A5+B6 BX5 X5-X3 ZR X5,FOUND SA5 A5+B6 BX5 X5-X3 ZR X5,FOUND SA5 A5+B6 BX5 X5-X3 NZ X5,FINDSUB1 LOOP UNTIL SUBP FOUND * FOUND JP B7 RETURN TITLE DOSTK: STACK MANIPULATION EJECT * * DOSTK * * DOSTK FINGERS THE STACK. * IT DECREMENTS THE STACK POINTER,CHECKS FOR EMPTY STACK * ERROR, AND SETS UP REGISTERS FOR A CALL ON ENVIORN. DOSTK DOES * NOT CALL ENVIORN ITSELF * * REGISTERS UPON EXIT * * X2 WD 0 STACK ENTRY. END OF PATH IS RIGHT JUSTIFIED * A2 ABS ADDR OF CURRENT STACK ENTRY * A6 ABS ADDR OF P.STACK * B2 NEW CURRENT SUBP * B6 TOP OF PATH * B7 RETURN LINK * REGISTERS USED: * A1/X1,A2/X2,A6/X6,B2,B4,B5,B6 * ENTRY DOSTK DOSTK SA1 B1+P.STACK .. FETCH STACK POINTER SX6 2 IX6 X1-X6 .. DECREMENT STACK POINTER SB4 X6 .. TEST FOR EMPTY STACK LX1 6+36 .. GET STACK ORIGIN SB5 X1 GT B5,B4,RETURN11 .. ERROR, EMPTY STACK SA2 B1+B4 .. GET STACK ENTRY SA6 A1 .. STORE NEW STACK POINTER SB2 X2 .. B2=CURRENT SUBP LX2 6+36 .. FIND END OF PATH SB6 X2 .. END OF PATH JP B7 .. RETURN RETURN11 SX7 E.ESTK .. EMPTY STACK EQ CL4 EJECT * THIS ROUTINE IS USED IN CALLING A NEW SUBPROCESS * THE FOLLOWING THINGS ARE DONE * 1) A NEW STACK ENTRY IS MADE * 2) IF X3 = 0 THEN ^P.IPLIST^ AND THE P-COUNTER * FROM THE EXCHANGE PACKAGE ARE INTERED * IN THE OLD TOP OF STACK * 3) RA, FL, AND THE P-COUNTER ARE SET IN THE * EXCHANGE PACKAGE * 4) ENVIORN IS CALLED * * ON ENTRY B1 = PROC ORIG * B2 = CALLEE * B6 = TOP OF PATH * B7 = RETURN LINK * X1 = TYPE OF CALL(ENTRY POINT OFFSTE) * X2 = STACK POINTER FOR NEW STACK ENTRY * X3 = STACK MANIPULATION FLAG * * CALL SX6 B6 TOP OF PATH LX6 18 SA5 B1+P.XPACK WORD (0) OF EXCHANGE PACKAGE SX7 B2 CALLEE BX6 X6+X7 1ST WD OF NEW STACK ENTRY MX4 6+18 SA6 B1+X2 STORE 1ST WORD OF NEW STACK ENTRY NZ X3,CALL2 JP IF NO P-CNT IN OLD SATCK ENTRY * SA3 B1+P.IPLIST INPUT PARAMETER LIST ADDRESS FOR LX3 18 FRETURN BX7 X5*X4 LX7 6+18 OLD P/COUNTER BX7 X3+X7 SA7 A6-1 SET P-COUNTER AND IPLIST IN OLD STAC * CALL2 SA3 B1+B2 CALLEE DISCRIPTOR (WD 0) LX3 6+36 SHIFT TO RA SA2 A3+2 CALLEE (WD 2) FOR ENTRY POINT BX5 -X4*X5 BX2 X4*X2 LX1 36 IX2 X2-X1 SUBTRACT ENTRY POINT OFFSET BX7 X5+X2 NEW P-COUNTER FOR EXCHANGE PACKAGE SA7 A5 SA5 A5+1 LX2 6+18 BX6 X2 SX7 X3+B1 RA OF CALLEE LX7 36 SA6 A6+1 STORE P-CNT IN NEW STACK BX5 -X4*X5 BX6 X5+X7 NEW RA FOR XPACK SA6 A5 SA2 B1+B6 TOP OF PATH ( WD 0 ) LX2 6+18 SX2 X2 SX3 X3 IX2 X2-X3 NEW FL SA5 A5+1 BX6 -X4*X5 LX2 36 BX6 X6+X2 NEW FL FOR XPACK SA6 A5 JP ENVIORN EJECT * THIS ROUTINE ESTABLISHES THE PROPER MEMORY SPACE * AND FULL C-LIST ENVIRNMENT FOR THE PROCESS * AS INPUT IT NEEDS THE TOP OF PATH AND THE CALLED * SUBPROCESS * * ON ENTRY B1 = CM PROC ORIGIN (PROC SCRATCH) * B2 = CALLED SUBPROCESS * B6 = TOP OF PATH SUBPROCESS * B7 = RETURN LINK * ON EXIT B2 IS UNCHANGED * * SCRATCH USED P.TEMP5, P.TEMP6 * * REGISTER ALLOCATION FOR ENVION * * A1 - X1 MASK (42 BITS) * A2 - X2 CURRENT SUBP IN FULL PATH * A3 - X3 CURRENT SUBP IN MAP CHAIN * B1 CM PROCESS ORIGIN * B2 CALLEE ( CALLED SUBPROCESS ) * B3 C-LIST TABLE POINTER * B4 LAST MAP IN MAP CHAIN * B5 CURRENT MAP IN MAP CHAIN * B6 CURRENT SUBP IN FULL PATH * B7 CONSTANT 7 * P.RET2 EQU P.TEMP5 EXT E.MOT * * SUBROUTINES CALLED .. SWAPIN, SWAPOUT ENVIORN SX6 B7 SAVE RETURN * SA5 B1+P.CTABLE ORIGIN OF FULL C-LIST TABLE SB3 X5+B1 ABSOLUTE ORIG OF FULL C-LIST TABLE SA6 B1+P.RET2 SB7 7 SB4 P.MAPSIN-7 HEAD OF CHAIN OF MAPS WHICH ARE IN SA5 B1+P.MAPSIN SB5 X5 CURRENT MAP OF INTEREST MX1 6+36 MASK FOR EXTRACTING 18 BIT FIELD * * FIRST HANDLE THE TOP OF PATH AS A SPECIAL CASE * SA2 B1+B6 1ST WD OF SUBP DISCRIPTOR OF TOP OFPAT LX2 1 TEST FOR MAP ALREADY IN NG X2,ENVIOR5 JP IF MAP ALREADY IN * * TEST FOR MAP ABOVE CURRENT MAP LX2 5+36 ENVIOR1 SA3 B1+B5 GET RA+FL OF CURRENT MAP OF INTEREST BX4 -X1*X2 RA OF TOP OF PATH LX3 6+18 BX5 -X1*X3 RA+FL OF CURRENT MAP OF INTEREST IX6 X4-X5 PL X6,ENVIOR8 JP IF TOP OF PATH ABOVE CURRENT SUBP * * TEST FOR TOP OF PATH BELOW CURR MAP LX2 6+36 BX4 -X1*X2 RA*FL OF TOP OF PATH LX3 18 BX5 -X1*X3 RA OF CURRENT MAP OF INTEREST IX6 X4-X5 PL X6,ENVIOR2 JP IF NOT BELOW (I.E. COLLISION) * * TOP OF PATH IS BELOW..MOVE POINTERS SB4 B5 LAST MAP BECOMES CURRMAP SA5 A3+B7 GET POINTER TO NEXT MAP AFTER CURRENT ZR X5,ENVIOR12 JUMP IF END OF MAPS IN CHAIN SB5 X5 NEW CURRENT MAP OF INTEREST LX2 18 RESET TOP OF PATH DATA JP ENVIOR1 GO TEST FOR ABOVE * * COLLISION...MEANS A SWAPOUT ENVIOR2 MX6 1 FIRST CLEAR MAP IN BIT IN SUBP LX3 18+1 GOING OUT BX6 -X6*X3 SA5 A3+B7 BEGIN TO CHAIN ARROUND SUBP LX6 59 SX4 B4+B7 REL ADDR TO STORE NEW POINTER BX7 X5 NEW POINTER TO BE SPLICED IN SA7 X4+B1 SPLICED POINTER FROM LAST MAP LX2 18 RESTORE TOP OF PATH DATE SB7 ENVIOR3 RETURN LINK SA6 A3 RESET MAP IN BIT ON SUBP GOING OUT SB5 X5 SA5 A3+3 POINTERS TO MAP SX6 B6 SAVE B6 SA6 B1+P.TEMP6 JP MAPOUT GO SWAP OUT MAP * B7 = RETURN LINK * X5 = POINTERS TO MAP TO SWAP OUT * ENVIOR3 SB7 7 EXPACT B1, B2, B3, B4, B5, X1, X2, * TO SURVIVE SWAPOUT SA5 B1+P.TEMP6 SB6 X5 EQ B5,B0,ENVIOR12 JP IF END OF MAP CHAIN JP ENVIOR1 GO TEST FOR ABOVE * * MAIN LOOP * TOP OF PATH ALREADY TAKEN CARE OF * ENVIOR4 SA2 B1+B6 GET A NEW SUBP TO WORK ON LX2 1 TEST FOR ALREADY IN PL X2,ENVIOR7 JUMP IF NOT ALREADY IN ENVIOR5 SA3 A2+B7 UPDATE WORKING MAP CHAIN POINTERS SB4 B6+0 LX2 59 RESTORE SUBP DICRIPTOR (WD 0) ZR X3,ENVIOR15 JUMP IF END OF MAP CHAIN SB5 X3+0 * ENVIOR6 SA4 A2+5 DO C-LIST STUFF FOR OLD SUBP BX6 X4 C-LIST NAME AND MOT INDEX SA6 B3-1 STORE IN FULL C-LIST TABLE SA4 A2+4 SX6 X4 C-LIST LENGTH SA6 A6-1 STORE C-LIST LENGTH IN TABLE SB3 A6 EQ B2,B6,ENVIOR14 JP IF FINISHED W/ LAST SUBP SB6 X2 NEW SUBP JP ENVIOR4 * * TEST FOR ABOVE ENVIOR7 SA3 B1+B5 GET DATA FOR CURRENT MAP OF INTEREST LX3 6+18 BX5 -X1*X3 RA+FL OF MAP ALREADY IN LX2 5+36 BX4 -X1*X2 RA OF CURRENT SUBP IX6 X4-X5 NG X6,ENVIOR10 NOT ABOVE ( MUST BE COLLISION ) * * SUBP ABOVE...SPLICE INTO MAP LIST ENVIOR8 SX6 B5 SX7 B6 ADDR TO SPLICE IN SX5 B1+B7 SA7 X5+B4 SB4 B6 SA6 X5+B6 MX5 1 SET MAP IN BIT SA2 B1+B6 LX2 1 BX6 X5+X2 LX6 59 SA6 A2 SX6 B6 SA5 A2+3 SA6 B1+P.TEMP6 SB7 ENVIOR9 JP MAPIN SWAPIN MAP B7 = RETURN LINK * X5 = POINTERS TO MAP TO SWAP ENVIOR9 SB7 7 SA5 B1+P.TEMP6 SB6 X5 SA2 B1+B6 RESTORE A2 / X2 JP ENVIOR6 * * COLLISION...MUST DO SWAPOUT * ENVIOR10 MX6 1 RESET MAP IN BIT IN SUBP DISCRIPTOR LX3 36+1 BX6 -X6*X3 SA5 A3+B7 FIDDLE MAP LIST POINTERS TO REMOVE LX6 59 SX4 B4+B7 THE OFFENDING SUBPROCESS BX7 X5 POINTER TO BE USED SA7 X4+B1 SET IT IN THE POINTER FIELD OF LASTMAP SB7 ENVIOR11 SET RETURN LINK FOR SWAPOUT SA6 A3 STORE RESET MAP IN BIT SB5 X5 SA5 A3+3 SX6 B6+0 SA6 B1+P.TEMP6 JP MAPOUT SWAP OUT MAP * ENVIOR11 SB7 7 SA5 B1+P.TEMP6 SB6 X5 SA2 B1+B6 RESTORE A2 /X2 LX2 1 FIX UP FOR ENVIOR7 NE B0,B5,ENVIOR7 JP IF NOT END MAP LIST * * END OF MAP LIST PROCESSING * ENVIOR12 SX6 B6 CHAIN IN SUBP AT END OF MAP LIST SX7 B4+B7 SA6 X7+B1 SX6 B0 MARK SUBP AS END OF MAP LIST SX7 B6+B7 SA6 X7+B1 SA2 B1+B6 SET MAP IN BIT IN SUBP MX6 1 LX2 1 BX6 X6+X2 LX6 59 SA6 A2 SB4 B6 SWAPIN A SUBPROCESS SB7 ENVIOR13 SX6 B6 SA5 A2+3 SA6 B1+P.TEMP6 JP MAPIN * ENVIOR13 SB7 7 SA5 B1+P.TEMP6 SB6 X5 SA2 B1+B6 RESTORE A2 / X2 ENVIOR15 SA4 A2+5 MAKE ENTRY IN FULL C-LIST TABLE SA5 A2+4 BX6 X4 C-LIST NAME AND MOT INDEX SX7 X5 C-LIST LENGTH SA6 B3-1 STORE IN FULL C-LIST TABLE SB3 A6-1 SA7 B3 EQ B2,B6,ENVIOR14 JP IF FINISHED (LAST SUBP) SB6 X2 STEP TO NEXT SUBP JP ENVIOR12 * * FINISHED WITH SUBP IN FULL MAP ENVIOR14 SA2 B1+B2 RESET USER RA LX2 6+36 SX6 X2+B1 SA6 S.USERA * SA3 B1+P.RET2 RECOVER RETURN LINK SX6 B3-B1 SET C-LIST TABLE ORIGIN SB7 X3 SA6 B1+P.CLIST * * READ IN LOCAL C-LIST SA4 B3 LOCAL C-LIST LENGTH LX4 1 SB5 X4+1 SA3 A4+1 LOCAL C-LIST NAME AND MOT INDEX SX0 X3 MOT ADDRESS OF LOCAL C-LIST SA0 B1 PROCESS SCRATCH AREA + RE 1 READ MOT ENTRY FOR LOCAL C-LIST RJ E.ECS SA4 A0 CHECK MOT AGAINST LOCAL NAME BX3 X3-X4 MX6 39 BX3 X3*X6 NZ X3,CRESUB33 JP IF C-LIST GONE FROM MOT BX0 -X6*X4 ECS ADDR OF LOCAL C-LIST SA0 B1+P.LOCALC-1 + RE B5 READ IN LOCAL C-LIST RJ E.ECS * * DO DIRECT ECS ACCESS MAP * B2 = CURRENT SUBPROCESS * SA1 B1+P.XPACK+4 CLEAR OUT ECSRA AND ECSFL SA2 B1+P.XPACK+5 MX7 24 BX1 -X7*X1 BX2 -X7*X2 SB5 B2+3 SA3 B1+B5 GET PTR TO MAP FOR CURRENT SUBP SX3 X3+1 SA3 B1+X3 1ST DATA WD OF COMPILED MAP LX3 1 PL X3,SWPIN44 SKIP IF NO ECS ACCESS LX3 23 GET ECS RA MX7 39 BX6 -X7*X3 LX6 36 SA4 S.ECSRA LX4 36 IX6 X4+X6 BX1 X6+X1 LX3 36 GET ECS FL LX6 36 SX6 X3+0 BX2 X6+X2 SWPIN44 BX6 X1 STORE ECS RA AND ECS FL BX7 X2 SA6 A1 SA7 A2 JP B7 RETURN END