IDENT INITL ERR VV HAS IT * TITLE I N I T L * * INNITIALIZE ECS AND CREATE INNITIAL OBJECTS * * EXT I.LOCK TYPES XTEXT * * * ************************************* * INTSYS XTEXT * * ******************************* * PROCSYM XTEXT * * * **************************************R * ECSACT XTEXT * * ************************************* * OBBITS XTEXT * ********************************************** ENTRY ENDSYS ENDSYS BSS 0 * EXT LIMIT,S.SYSAB EXT INTINIA,INTINIB EXT ECSINIT EXT S.FSWAP,FORSWAP EXT S.CHIP,CHIPCAL,S.ARITH,ARITHER EXT S.CMFL,S.ECSRA,S.ECSFL EXT I.BOX EXT INTINIC EXT MC.INT,MC.IPRC ENTRY INITYZ * INITYZ BSSZ 1 * RJ ECSINIT INITIALIZE ECS AND ALLOCATION * MECHANISM AND * RJ BEGINIT PATCH SYSTEM FOR OBJECT CREATION * SX6 FORSWAP SET P-COUNTER IN FORCED SWAP X-PACK LX6 36 SA6 S.FSWAP SX6 CHIPCAL SET UP CHIP AND ARITH P-COUNTERS LX6 36 SA6 S.CHIP SX6 ARITHER LX6 36 SA6 S.ARITH * * SET UP ECS AND CM LIMITL IN EXCHANGE PACKAGES * SB5 36 SA1 S.CMFL FL LX6 X1,B5 SA6 S.CHIP+2 SA6 S.ARITH+2 SA6 S.FSWAP+2 SA6 I.BOX+2 * SA1 A1+1 EXIT MODE LX6 X1,B5 SA6 S.CHIP+3 SA6 S.ARITH+3 SA6 S.FSWAP+3 SA6 I.BOX+3 * SA1 S.ECSRA ECS RA LX6 X1,B5 SA6 S.CHIP+4 SA6 S.ARITH+4 SA6 S.FSWAP+4 SA6 I.BOX+4 * SA1 S.ECSFL ECS FL LX6 X1,B5 SA6 S.CHIP+5 SA6 S.ARITH+5 SA6 S.FSWAP+5 SA6 I.BOX+5 * SB1 LIMIT BX6 X6-X6 SET UP RA AND FL IN DUMMY EXCHANGE SA6 B1+P.XPACK+1 PACKAGE SA2 S.CMFL LX6 X2,B5 SA6 B1+P.XPACK+2 * SA2 S.SYSAB FETCH ALLOC BK CAPABILITY SA3 A2+1 BX6 X2 AND MOVE IT TO (DUMMY) ACTUAL PARAM BX7 X3 AREA SA6 B1+P.PARAM SA7 B1+P.PARAM+1 * BX6 X6-X6 INNITIALIZE C-LIST INDEX SA6 B1+P.PARAM+2 * SX6 INITYZ1 DUMMY UP LOCAL C-LIST SX7 B1 IX6 X6-X7 SA6 B1+P.CLIST * RJ INICLIST CREATE INNITIAL C-LIST * * PUT CAPABILITY FOR SYSTEM ALLOC BK * IN SYSTEM C-LIST SA5 SYSCAP+1 SX1 1 BX6 X1 SA6 B1+P.PARAM+2 INCREMENT C-LIST INDEX SB4 X1 SB5 B1+P.PARAM SB6 INITYZ2 JP ARBCAP * INITYZ2 RJ INTINIA INTERRUPT FILE CREATION * RJ INIOPS CREATA OPERATIONS * + SB3 *+1 . NOW GET RID OF ANY SPACE BEFORE EQ =XCOMPACT . INITIALIZING THE INTERRUPT OBJECTS * RJ INTINIB INTERRUPT INNITIALIZATION * RJ GETCLCD * SA2 B1+P.PARAM+2 BX6 X2 SA6 =XS.IPROC * RJ INIFILE CREATE FILES * * RJ INIPROC CREATE A PROCESS RJ ENDINIT UN-PATCH SYSTEM * JP INITYZ RETURN * INITYZ1 VFD 60/2000 DUMMY LENGTH FOR LOCAL C-LIST EJECT * * THIS ROUTINE PATCHES THE SYSTEM TO ALLOW * INNITIAL CREATION OPERATIONS TO BE USED * TO USE THE SYSTEM, ONE SETS UP THE PARAMETERS * IN AN ACTUAL PARAMETER AREA (AT B1+P.PARAM) AND THE * STORE A RETURN LINK IN ^RETLINK^ AND THEN * JUMP THRU THE ECS ACTION TABLE (^ACTIONL^) * * EXT SYSRET,E.ERROR,PUTCAP,GETCAP * BEGINIT BSSZ 1 SA1 SYSRET PATCH SYSTEM STANDARD RETURN BX6 X1 SAVE OLD STUFF SA6 BEGIN1 SA2 SYSPAT BX6 X2 SA6 A1 * SA1 E.ERROR PATCH SYSTEM ERROR MECHANISM BX6 X1 SA6 BEGIN2 SA2 ERRPAT BX6 X2 SA6 A1 * SA1 PUTCAP PATCH STANDARD CAPABILITY PUTTER BX6 X1 SA6 BEGIN3 SA2 CAPPAT BX6 X2 SA6 A1 * SA1 GETCAP PATCH STANDARD CAPABILITY GETTER BX6 X1 SA6 BEGIN4 SA2 CAPGET BX6 X2 SA6 A1+0 * JP BEGINIT * * SYSPAT JP INIRET ERRPAT JP INIERR CAPPAT JP INICAP CAPGET JP INIGET * BEGIN1 BSS 1 BEGIN2 BSS 1 BEGIN3 BSS 1 BEGIN4 BSS 1 EJECT * * * THIS ROUTINE UN-PATCHES THE SYSTEM * ENDINIT BSSZ 1 SA1 BEGIN1 BX6 X1 SA6 SYSRET * SA1 BEGIN2 BX6 X1 SA6 E.ERROR * SA1 BEGIN3 BX6 X1 SA6 PUTCAP * SA1 BEGIN4 BX6 X1 SA6 GETCAP * JP ENDINIT EJECT * * THIS ROUTINE IS TO HANDLE THE RETURN FROM THE PATCHED * SYSTEM * BEFORE CALLING THE SYSTEM..ONE SHOULD SET * ^RETLINK^ FOR THIS ROUTINE TO USE TO GET BACK * INIRET SA2 RETLINK SB6 X2 JP B6 * RETLINK BSSZ 1 EJECT * * * ROUTINE CALLED FROM SYSTEM PATCH * TO PUT A CAPABILITY IN THE SYSTEM C-LIST * CAPABLLITY FOR THE C-LIST IS AT ^SYSCAP^ * IF (^SYSCAP^) = 0 THEN WE WILL SUBSITIUTE THE * CAPABILITY TO BE WRITTEN IN THE C-LIST AT ^SYSCAP^ * ( I.E. ON FIRST CALL, THE C-LIST ITSELF IS THE * CAPABILITY TO BE WRITTEN ) * * EXT ARBCAP * INICAP SA4 SYSCAP+1 CHECK FOR 1ST CALL NZ X4,INICAP1 SA4 B5 STORE CAPAB AT SYSCAP BX6 X4 SA6 SYSCAP SA4 B5+1 BX6 X4 SA6 SYSCAP+1 * INICAP1 BX5 X4 SX6 B4 SAVE B4 AND B6 SA6 INICAP3 SX6 B6 SA6 INICAP4 SB4 1 SB6 INICAP2 JP ARBCAP * * INICAP2 SA4 INICAP3 RECOVER B4 AND B6 SB4 X4 SA4 INICAP4 SB6 X4 JP B6 RETURN TO SYSTEM * INICAP3 BSSZ 1 INICAP4 BSSZ 1 SYSCAP BSSZ 2 EJECT * * INIGET * THIS ROUTINE IS CALLED FROM A SYSTEM PATCH TO GET A CAPABILITY * FROM THE SYSTEM CLIST * ENTRY INIGET * INIGET SA5 SYSCAP+1 .. MOT/UN FOR ARBCAP SB4 0 .. READ CAPABILITY SX6 B6 SA6 INIGET3 .. SAVE B6(=RETURN) SB6 INIGET1 .. RETURN LINK SB5 INIGET2 .. CM ADDR TO PUT CAPAB JP ARBCAP INIGET1 SA0 INIGET2 SA4 INIGET3 SB6 X4 JP B6 .. RETURN INIGET2 BSS 2 .. ARBCAP PUTS CAPABILITIES HERE WHEN GETCAP * PATCH IS IN EFFECT INIGET3 BSS 1 .. B6 IS SAVED HERE SPACE 5 * * THIS ROUTINE ABORTS WHEN AN ERROR OCCURS WITHIN * THE SYSTEM DURING INNITIALIZATION * IT IS CALLED THRU THE SYSTEM PATCH AT ^E.ERROR^ * EXT DISASTR * INIERR SA6 SAVEX6 SA7 SAVEX7 RJ DISASTR * SAVEX6 BSSZ 1 SAVEX7 BSSZ 1 * SPACE 5 * * MAKE A ECS SYSTEM CALL DURING INNITIALIZATION * PARAMETER LIST FOR ECS ACTION ALREADY AT B1+P.PARAM * B5 = ECS ACTION NUMBER * B6 = RETURN LINK * ENTRY CALLSYS EXT ACTIONL * CALLSYS SX6 B6 SA6 RETLINK SET RETURN FOR SYSTEM PATCH JP ACTIONL+B5 * EJECT * * THIS ROUTINE CREATES THE SYSTEM MASTER C-LIST * IT MUST BE CALLED BEFORE ANY OTHER OPERATIONS * WHICH CREATE OBLECTS WHICH WILL BE PUT INTO THE * MASTER C-LIST (WITH THE EXCEPTION OF THE * SYSTEM ALLOCATION BLOCK ) * * * * INICLIST BSSZ 1 RJ INTINIC GET INTINIT TO COMPUTE ITS NEEDS SA1 MC.INT SPACE USED BY INTERRUPT OBJECTS BX6 X1 SA1 MC.IPRC SPACE USED IN M CLIST BY IPROC IX6 X1+X6 SX1 NUMOPS+3 IX6 X1+X6 SA6 B1+P.PARAM+3 SB6 INICLIST SB5 J.CRECL JP CALLSYS TITLE * * CREATE ECS ACTION OPERATIONS * SPACE 5 * * PROTEK * * PROTEK TURNS OFF SPECIFIED OPTION BITS ON NEWLY CREATED * OBJECTS BY IMITATING THE ECS SYSTEM ACTION TO ^MOVE A * CAPABILITY AND DECREASE THE OPTION BITS^. * * ON INPUT * B6=ABS CM POINTER TO OPTION BIT MASK * * THE OBJECT WHOSE OPTION BITS ARE TO BE TURNED OFF SHOULD * JUST HAVE BEEN CREATED SO THAT THE PROPER AP LIST WILL * BE AT B1+P.PARAM. PART OF THAT AP LIST IS USED BY ^PROTEK^ * THE AP LIST IS SAVED AND RESTORED BY PROTEK. THE CAPABILITY * CREATED BY MAKEOBJ IS ASSUMED TO STILL RESIDE IN FULL CLIST * AT THE INDEX STORED AT P.PARAM+2 * ENTRY PROTEK EXT GETCAP * PROTEK BSS 1 .. ENTRY POINT * SB2 1 SA1 B1+P.PARAM .. FETCH AP LIST AND SAVE IT SA2 A1+B2 .. +1 SA3 A2+B2 .. +2 SA4 A3+B2 .. +3 * BX6 X1 BX7 X2 SA6 PROTEK3 SA7 A6+B2 BX6 X3 BX7 X4 SA6 A7+B2 SA7 A6+B2 * * FETCH THE MASK * SA1 B6 .. MASK POINTER BX6 X1 SA6 A4 .. XMIT TO B1+P.PARAM+3 * * GET CAPABILITY FOR OBJECT * SA1 B1+P.PARAM+2 .. GETCAP EXPECTS INDEX IN X1 SB6 PROTEK1 .. RETURN LINK JP GETCAP * * DO ACTION * PROTEK1 SA1 A0 .. GETCAP LEFT ADDR OF CAPABILITY IN A0 SA2 A1+B2 .. GETCAP PRESERVED B2(:=1) BX6 X1 BX7 X2 SA6 B1+P.PARAM .. SET UP AP LIST FOR MOVEC SA7 A6+1 .. MASK HAS ALREADY BEEN PUT AT P.PARAM+3, * P.PARAAM+2 (INDEX = IP2) HAS NOT BEEN CHANGED SB5 J.MOVEC SB6 PROTEK2 .. RETURN LINK JP CALLSYS * * RESTORE AP LIST * PROTEK2 SA1 PROTEK3 SB2 1 .. B2 := 1 := CONSTANT SA2 A1+B2 .. +1 SA3 A2+B2 .. +2 SA4 A3+B2 .. +3 * BX6 X1 BX7 X2 SA6 B1+P.PARAM SA7 A6+B2 .. +1 * BX6 X3 BX7 X4 SA6 A7+B2 .. +2 SA7 A6+1 .. +3 JP PROTEK .. RETURN * PROTEK3 BSS 4 .. SAVE AP LIST HERE SPACE 5 INIOPS DATA 0 * * WHILE CREATING THE OPERATIONS, THE MASTER ALLOCATION BLOCK CAPABILITY * AND THE MASTER C-LIST INDEX WILL BE SAVED, SINCE THEIR POSITIONS IN * THE ACTUAL PARAMETER AREA WILL BE NEEDED. * EXT CAPAB * * SA1 B1+P.PARAM SA2 A1+1 SA3 A2+1 BX6 X1 BX7 X2 SA6 =SSAVEAP1 SA7 =SABMOT BX6 X3 SA6 =SSAVEAP2 * NUMOP SET 0 . NUMBER OF OPERATIONS * EXT MKOPRN * OPER MACRO ACTION,NO:PS,PS1,PS2,PS3,PS4,PS5,PS6,PS7,PS8,PS9,PS10 ,,PS11,PS12,PS13,PS14,PS15,PS16,PS17,PS18,PS19,PS20 IFGT NO:PS,20,1 ERR ********** TOO MANY PARAMETERS ********** 01 MICRO 1,,$PS1$ 02 MICRO 1,,$PS2$ 03 MICRO 1,,$PS3$ 04 MICRO 1,,$PS4$ 05 MICRO 1,,$PS5$ 06 MICRO 1,,$PS6$ 07 MICRO 1,,$PS7$ 08 MICRO 1,,$PS8$ 09 MICRO 1,,$PS9$ 10 MICRO 1,,$PS10$ 11 MICRO 1,,$PS11$ 12 MICRO 1,,$PS12$ 13 MICRO 1,,$PS13$ 14 MICRO 1,,$PS14$ 15 MICRO 1,,$PS15$ 16 MICRO 1,,$PS16$ 17 MICRO 1,,$PS17$ 18 MICRO 1,,$PS18$ 19 MICRO 1,,$PS19$ 20 MICRO 1,,$PS20$ * SA5 ABMOT . SYSTEM ALLOCATION BLOCK SX4 NO:PS . NUMBER OF PARAMETER SPECIFICATIONS SA2 SAVEAP2 . CURRENT INDEX IN MASTER C-LIST SX6 X2+1 SA6 A2 SA6 B1+P.PARAM+2 . SET CURRENT INDEX IN AP LIST * FOR USE BY PROTEK BX2 X6 * * SX3 ACTION + SX7 *+1 RETURN EQ MKOPRN * SB6 OPMASK RJ PROTEK + BSS 0 * ZZ IFNE NO:PS,0 SA1 CAPAB+1 BX6 X1 SA6 B1+P.PARAM+1 INDEX SET 0 DUP NO:PS TEMP MICRO 2*INDEX+1,2,$0102030405060708091011121314151617181920 ,$ INDIRECT 'TEMP',TEMP SX6 INDEX . PS INDEX SA6 B1+P.PARAM+2 PARM 'TEMP' INDEX SET INDEX+1 ENDD ZZ ENDIF NUMOP SET NUMOP+1 ENDM INDIRECT MACRO X,Y Y MICRO 1,,$'X'$ ENDM * UDAT MACRO SB5 J.USRDAT ENDM UCAP MACRO P1,P2 LOCAL PAR SB5 J.USRCAP SX6 P2 . TYPE NUMBER SA6 B1+P.PARAM+3 SA1 PAR BX6 X1 SA6 A6+1 . OPTIONS MASK USE DATA PAR VFD 60/P1 USE * ENDM ACAP MACRO P1 LOCAL PAR SB5 J.ANYCAP SA1 PAR .. OPTION BITS BX6 X1 SA6 B1+P.PARAM+3 USE DATA PAR VFD 60/P1 USE * ENDM FDAT MACRO P1 LOCAL PAR PARM UDAT SA1 PAR BX6 X1 SA6 B1+P.PARAM+3 USE DATA PAR VFD 60/P3 USE * SB5 J.FIXDAT ENDM PARM MACRO TYPE,P1,P2,P3 TYPE P1,P2,P3 + SB6 *+1 EQ CALLSYS ENDM * READ A FILE LIST G OPER J.REFILE,4,(UCAP,OB.RDFIL,T.FILE),UDAT,UDAT,UDAT LIST -G * WRITE A FILE OPER J.WRFILE,4,(UCAP,OB.WFILE,T.FILE),UDAT,UDAT,UDAT * SEND AN EVENT OPER J.EVENT,2,(UCAP,OB.SNDEV,T.EVCH),UDAT * GET AN EVENT OPER J.HANG,1,(UCAP,OB.GETEV,T.EVCH) * CREATE A C-LIST OPER J.CRECL,3,(UCAP,OB.CRECL,T.ALLOC),UDAT,UDAT * CREATE A FILE OPER J.CREFIL,4,(UCAP,OB.CRFIL,T.ALLOC),UDAT,UDAT,UDAT * CREATE A FILE BLOCK OPER J.CREBLK,2,(UCAP,OB.CREBL,T.FILE),UDAT * CREATE A PROCESS OPER J.CPROC,18,(UCAP,OB.CREPR,T.ALLOC),UDAT,UDAT,UDAT,( ,UCAP,OB.SONSP,T.CLSCD),UDAT,UDAT,UDAT,UDAT,(UCAP,OB.LOCCL,T.CLIST),(UCA ,P,OB.WFILE+OB.RDFIL+OB.PLMAP,T.FILE),UDAT,UDAT,UDAT,(UCAP,OB.RDFIL+OB.P ,LMAP,T.FILE),UDAT,UDAT,UDAT * CREATE AN EVENT CHANNEL OPER J.MKEC,3,(UCAP,OB.CREEC,T.ALLOC),UDAT,UDAT * CREATE A SUBPROCESS OPER J.MKSUBP,7,(UCAP,OB.SONSP,T.CLSCD),(UCAP,OB.FATHR,T. ,CLSCD),UDAT,UDAT,UDAT,UDAT,(UCAP,OB.LOCCL,T.CLIST) * CREATE A CLASS CODE WITH A NEW PERMANENT PART OPER J.CRECC,1,UDAT * SAVE THE REGISTERS OPER J.SREG,1,UDAT * RESTORE THE REGISTERS OPER J.RREG,1,UDAT * DISPLAY A CAPABILITY FROM THE FULL C-LIST OPER J.DSCAP,1,(ACAP,0,0) * FIND THE NTH SON OF A GIVEN SUBPROCESS OPER J.FSON,3,(UCAP,0,T.CLSCD),UDAT,UDAT * COPY A CAPABILITY AND DECREASE THE OPTIONS OPER J.MOVEC,3,(ACAP,0,0),UDAT,UDAT * COPY A CAPABILITH INTO THE FULL C-LIST OPER J.CAPIN,3,(UCAP,OB.CPYOT,T.CLIST),UDAT,UDAT * COPY A CAPABILITY OUT OF THE FULL C-LIST OPER J.CAPOU,3,(UCAP,OB.CPYIN,T.CLIST),UDAT,UDAT * SET ERROR SELECTION MASK OF GENERAL SUBPROCESS OPER J.ESMGEN,2,UDAT,(UCAP,OB.STESM,T.CLSCD) * SET ERROR SELECTION MASK OF LOCAL SUBPROCESS OPER J.ESMLOC,1,UDAT * MAKE NEW, ORDER 1, OPERATION OPER J.MKOPER,5,(UCAP,OB.ALORD,T.ALLOC),UDAT,UDAT,(UCAP,O ,B.CALOP,T.CLSCD),UDAT * SUBPROCESS RETURN OPER J.RETURN,0 * SUBPROCESS FRETURN OPER J.FRETUR,0 * FIX A CAPABILITY PARAMETER SPECIFICATION OPER J.FIXCAP,3,(UCAP,OB.CHOPT,T.OPER),UDAT,(ACAP,0) * FIX A DATUM PARAMETER SPECIFICATION OPER J.FIXDAT,3,(UCAP,OB.CHTYP,T.OPER),UDAT,UDAT * CHANGE AN ANY PS TO UDAT OPER J.USRDAT,2,(UCAP,OB.CHTYP,T.OPER),UDAT * CHANGE AN ANY PS TO UCAP OPER J.USRCAP,4,(UCAP,OB.CHTYP,T.OPER),UDAT,UDAT,UDAT * CHANGE AN ANY PS TO ACAP OPER J.ANYCAP,3,(UCAP,OB.CHTYP,T.OPER),UDAT,UDAT * ADD OPTION BITS TO UCAP PARAMETER OPER J.ADDOPT,3,(UCAP,OB.CHOPT,T.OPER),UDAT,UDAT * MAKE A COPY OF AN OPERATION OPER J.COPYOP,3,(UCAP,OB.ALORD,T.ALLOC),UDAT,UDAT,(UCAP, ,OB,ADDOR,T.OPER) * CHECK FOR MISSING FILE BLOCKS OPER J.CHKBLK,2,(UCAP,0,T.FILE),UDAT * DELETE A FILE BLOCK OPER J.DELBLK,2,(UCAP,OB.DELBL,T.FILE),UDAT * DELETE A FILE OPER J.DELFIL,1,(UCAP,OB.DSTRY,T.FILE) * READ THE SHAPE NUMBERS OF A FILE OPER J.REDSHP,3,(UCAP,0,T.FILE),UDAT,UDAT * SET A MAP ENTRY TO EMPTY OPER J.MAPZRO,3,(UCAP,OB.CHMAP,T.CLSCD),UDAT,(UCAP,OB.PLMA ,P,T.FILE) * SET A ZERO MAP ENTRY TO A READ-ONLY MAP ENTRY OPER J.MPCHRO,6,(UCAP,OB.CHMAP,T.CLSCD),UDAT,(UCAP,OB.PLM ,AP+OB.RDFIL,T.FILE),UDAT,UDAT,UDAT * SET A ZERO MAP ENTRY TO A READ-WRITE MAP ENTRY OPER J.MPCHRW,6,(UCAP,OB.CHMAP,T.CLSCD),UDAT,(UCAP,OB.PLM ,AP+OB.RDFIL+OB.WFILE,T.FILE),UDAT,UDAT,UDAT * MOVE A FILE BLOCK OPER J.MOVBLK,4,(UCAP,OB.RDFIL+OB.DELBL,T.FILE),UDAT,(UCA ,P,OB.WFILE+OB.CREBL,T.FILE),UDAT * DISPLAY A MAP ENTRY OPER J.DISMAP,3,(UCAP,0,T.CLSCD),UDAT,UDAT * JUMP RETURN OPER J.JPRET,2,(UCAP,OB.SPRET,T.CLSCD),UDAT * * CHANGE A UNIQUE NAME OPER J.NEWUN,3,(ACAP,OB.CHNAM,0),UDAT,UDAT * DISPLAY THE ENTIRE STACK OPER J.DISPST,2,UDAT,UDAT * DISPLAY A SPECIFIC STACK ENTRY OPER J.DISSEN,2,UDAT,UDAT * DSFMAP DISPLAYS AN ENTRY FROM THE FULL MAP OPER J.DSFMAP,2,UDAT,UDAT * DELETE A C-LIST OPER J.DELCL,1,(UCAP,OB.DSTRY,T.CLIST) * * SEND PROCESS INTERRUPT * OPER J.PINT,3,(UCAP,OB.SDINT,T.PROC),(UCAP,OB.INTSP,T.CLSC ,D),UDAT * * ADD AN ORDER TO AN OPERATION OPER J.ADDORD,5,(UCAP,OB.ALORD,T.ALLOC),UDAT,(UCAP,OB.ADDO ,R,T.OPER),(UCAP,OB.CALOP,T.CLSCD),UDAT * CREATE COMPLETE CAPABILITY FOR FIRST OBJECT OF ALLOC BK OPER J.CCCLOA,3,(UCAP,OB.GOD,T.ALLOC),UDAT,UDAT * TRANSFER FUNDS OR SPACE FROM ONE ALLOCATION BK TO ANOTHER OPER J.DONATE,3,(UCAP,OB.GIVE,T.ALLOC),(UCAP,OB.GET,T.ALLO ,C),UDAT * CREATE ALLOCATION BLOCK OPER J.CRALBK,2,(UCAP,OB.CREAB,T.ALLOC),UDAT * MODIFY P-COUNTER OF SPECIFIED SUBPROCESS OPER J.MODPC,3,(UCAP,OB.PCNT,T.CLSCD),UDAT,UDAT * DESTROY A PROCESS OPER J.DLPRO,1,(UCAP,OB.DSTRY,T.PROC) * DISPLAY A PROCESS DESCRIPTOR OPER J.DPROD,3,(UCAP,0,T.PROC),UDAT,UDAT * CLEAR THE DIRECT ACCESS ECS MAP ENTRY OPER J.CLRDAE,1,(UCAP,OB.CHMAP,T.CLSCD) * SET THE DIRECT ACCESS ECS MAP ENTRY OPER J.SETDAE,4,(UCAP,OB.DAE,T.CLSCD),(UCAP,OB.FDAE,T.FILE ,),UDAT,UDAT * DESTROY SUBPROCESS OPER J.DELSUB,1,(UCAP,OB.DSTRY,T.CLSCD) * SET INTERRUPT-INHIBIT BIT OPER J.SETIIB,0 * CLEAR INTERRUPT-INHIBIT BIT OPER J.CLRIIB,0 * GET AN EVENT OR FRETURN OPER J.GETEVF,1,(UCAP,OB.GTEVF,T.EVCH) * DESTROY AN ALLOCATION BLOCK OPER J.DELAB,1,(UCAP,OB.DSTRY,T.ALLOC) * * GET EVENT FROM MULTIPLE CHANNELS OR HANG OPER J.MGETH,2,UDAT,UDAT * GET EVENT FROM MULTIPLE CHANNELS OR F-RETURN OPER J.MGETF,2,UDAT,UDAT * DESTROY AN EVENT CHANNEL OPER J.DELEC,1,(UCAP,OB.DSTRY,T.EVCH) * DISPLAY CLOCK TIMES IN USER CORE OPER J.DCLOX,1,UDAT * SET TEMPORARY PART OF CLASS CODE OPER J.NWTMP,3,(UCAP,OB.TEMP,T.CLSCD),UDAT,UDAT * DISPLAY ALLOCATION BLOCK OPER J.DSPAB,3,(UCAP,0,T.ALLOC),UDAT,UDAT * CHANGE A NONE PS TO BLOCK DATA OPER J.BLKDAT,3,(UCAP,0,T.OPER),UDAT,UDAT * CHANGE A NONE PS TO BLOCK CAPABILITY OPER J.BLKCAP,3,(UCAP,0,T.OPER),UDAT,UDAT * DISPLAY AN OPERATION OPER J.DISPOP,3,(UCAP,0,T.OPER),UDAT,UDAT * USER INITIATED ERROR OPER J.USRER,2,UDAT,UDAT * RETURN WITH PAARAMETERSS OPER J.RETPAR,2,UDAT,UDAT * RETURN DATE AND TIME OPER J.TIMDT,0 * CREATE A CAPABILITY CREATING AUTHORIZATION OPER J.CAGEN,1,UDAT * CREATE A CAPABILITY OPER J.CGEN,3,UDAT,(UCAP,0,T.CAUTH),UDAT * DISPLAY SUBPROCESS DESCRIPTOR OPER J.DSPSP,3,(UCAP,0,T.CLSCD),UDAT,UDAT * TEST AND RESET DIRTY BIT OPER J.TRDB,2,(UCAP,OB.TRDB,T.FILE),UDAT * INCREMENT CHARGE RATE IN ALLOCATION BLOCK OPER J.INCHR,2,(UCAP,OB.INCHR,T.ALLOC),UDAT * DISPLAY ARBITRARY OBJECT IN BIZARRE FASHION OPER J.DSPOB,3,(ACAP,0,0),UDAT,UDAT * DISPLAY ALLOCATOR CONSTANTS OPER J.DSPALC,2,UDAT,UDAT * CHANGE A MAP ENTRY, NEW ENTRY IS READ-WRITE OPER J.CHMPRW,7,(UCAP,OB.CHMAP,T.CLSCD),UDAT,(UCAP,OB.PLM ,AP+OB.RDFIL+OB.WFILE,T.FILE),UDAT,UDAT,UDAT,(UCAP,OB.PLMAP,T.FILE) * CHANGE A MAP ENTRY, NEW ENTRY IS READ ONLY OPER J.CHMPRO,7,(UCAP,OB.CHMAP,T.CLSCD),UDAT,(UCAP,OB.PLM ,AP+OB.RDFIL,T.FILE),UDAT,UDAT,UDAT,(UCAP,OB.PLMAP,T.FILE) * DISPLAY SYSTEM CLOCKS IN USER CORE OPER J.DSCLX,1,UDAT * * SPECIAL RETURN: DECREMENT P COUNTER OPER J.SPRET,0 * * ZERO A CAPABILITY OPER J.CPZRO,1,UDAT * MOVE CP TIME TWIXT FATHER AND SON AB OPER J.MOVCP,3,(UCAP,OB.GIVCP,T.ALLOC),(UCAP,OB.GETCP,T.A ,LLOC),UDAT * MOVE MOT SLOTS TWIXT FATHER AND SON AB OPER J.MOVMT,3,(UCAP,OB.GIVMT,T.ALLOC),(UCAP,OB.GETMT,T.A ,LLOC),UDAT * INCREMENT CHARGE METER ON AB OPER J.INMTR,2,(UCAP,OB.INMTR,T.ALLOC),UDAT * * DESTROY AN OPERATION OPER J.DLOPR,1,(UCAP,OB.DSTRY,T.OPER) * STEAL ECS SPACE OPER J.GRAB,4,(UCAP,0,T.ALLOC),(UCAP,0,T.ALLOC),(UCAP,0,T ,.ALLOC),UDAT * * SA1 SAVEAP1 SA2 ABMOT SA3 SAVEAP2 BX6 X1 BX7 X2 SA6 B1+P.PARAM SA7 A6+1 BX6 X3 SA6 A7+1 * * * ENTRY NUMOPS NUMOPS EQU NUMOP * * JP INIOPS * EJECT SPACE 5 EJECT EJECT BLKSIZ VFD 60/=XIPROCSZ+40 EXT IPROCO1,IPROCO2,IPSTART,IPWDS1,IPWDS2 * FSAVE1 BSS 1 FSAVE2 BSS 1 FSAVE3 BSS 1 * * INIFILE BSSZ 1 SA1 B1+P.PARAM+2 INCREMENT C-LIST INDEX SX6 X1+1 SA6 A1 * * SET UP TO CREATE A FILE SX6 1 NUMBER OF LEVELS IN THE FILE SA6 A6+1 * SX6 BLKSIZ SA6 A6+1 * SB5 J.CREFIL SB6 INIFILE1 JP CALLSYS * INIFILE1 SA1 CAPAB MOVE CAPABILITY FOR USE BY INNITIAL BX6 X1 PROCESS CREATION SA6 FILE1 SA6 FILE2 SA1 CAPAB+1 BX6 X1 SA6 FILE1+1 SA6 FILE2+1 * SAVE P.PARAM THRU P.PARAM+2 SA1 B1+P.PARAM SA2 B1+P.PARAM+1 SA3 B1+P.PARAM+2 BX6 X1 BX7 X2 SA6 FSAVE1 SA7 FSAVE2 SX6 X3 SA6 FSAVE3 * CREATE BLOCK ON FILE SA1 CAPAB SA2 CAPAB+1 BX6 X1 BX7 X2 SA6 B1+P.PARAM SA7 B1+P.PARAM+1 BX6 X6-X6 SA6 B1+P.PARAM+2 * SB5 J.CREBLK CALL CREABLK SB6 INIFILE2 JP CALLSYS * INIFILE2 BX6 X6-X6 SET UP FOR 1ST FILE WRITE SA6 B1+P.PARAM+2 FILE ADDRESS SA6 FILADR1 SX6 IPROCO1 CM ADDRESS SA6 B1+P.PARAM+3 SX6 IPWDS1 WORD COUNT SA6 B1+P.PARAM+4 SB5 J.WRFILE WRITE SB6 INIFILE3 JP CALLSYS * 2ND FILE WRITE INIFILE3 SX6 IPWDS1 WORDS WRITTEN ALREADY SX6 X6+5 SA6 B1+P.PARAM+2 FILE ADDRESS SA6 FILADR2 SX6 IPROCO2 CM ADDRESS SA6 B1+P.PARAM+3 SX6 IPWDS2 WORD COUNT SA6 B1+P.PARAM+4 * SB5 J.WRFILE WRITE SB6 INIFILE4 JP CALLSYS * INIFILE4 SA1 FSAVE1 RESTORE P.PARAM THEU P.PARAM+3 SA2 FSAVE2 SA3 FSAVE3 BX6 X1 BX7 X2 SA6 B1+P.PARAM SA7 B1+P.PARAM+1 BX6 X3 SA6 B1+P.PARAM+2 JP INIFILE EJECT * * CREATE THE INNITIAL PROCESS * EXT RUNORG1,RUNORG2 * INIPROC BSSZ 1 * INCREMENT C-LIST INDEX SA1 B1+P.PARAM+2 SX6 X1+1 SA6 A1 * SET NUMBER OF CHAINING WORDS SX6 NUMCHWD SA6 A6+1 * SET STACK SIZE SX6 STACKSZ SA6 A6+1 * CLASS CODE SA4 PROCLCD BX6 X4 SA6 A6+1 SA4 PROCLCD+1 BX6 X4 SA6 A6+1 * NUMBER OF MAP ENTRIES SX6 NUMAP SA6 A6+1 * COMPILED MAP BUFFER SX6 COMPBUF SA6 A6+1 * FIELD LENGTH OF SUBP SX6 FIELDL SA6 A6+1 * ENTRY POINT FOR SUBP SX6 IPSTART SA6 A6+1 * C-LIST = MASTER C-LIST SA4 SYSCAP BX6 X4 SA6 A6+1 SA4 SYSCAP+1 BX6 X4 SA6 A6+1 * FIRST FILE SA4 FILE1 BX6 X4 SA6 A6+1 SA4 FILE1+1 BX6 X4 SA6 A6+1 * FILE ADDRESS SA4 FILADR1 BX6 X4 SA6 A6+1 * CORE ADDRESS BX6 X6-X6 KLUDGE TO GET ARROUNG LOADER REFULSAL * TO LINK TO ^RUNORG1 WITH VALUE = 0 SA6 A6+1 * WORD COUNT SX6 IPWDS1 SA6 A6+1 * SECOND FILE SA4 FILE2 BX6 X4 SA6 A6+1 SA4 FILE2+1 BX6 X4 SA6 A6+1 * FILE ADDRESS SA4 FILADR2 BX6 X4 SA6 A6+1 * CORE ADDRESS SX6 RUNORG2 SA6 A6+1 * CORD COUNT SX6 IPWDS2 SA6 A6+1 * CALL THE SYSTEM * SB6 INIPROC RETURN LINK SB5 J.CPROC JP CALLSYS * EJECT * GET INNITIAL CLASS CODE FOR INITIAL PROCESS * STORE CALSS CODE AT ^PROCLCD^ FOR ^INIPROC^ * GETCLCD BSS 1 SA1 B1+P.PARAM SAVE ALLOCATION BLOCK CAPABILITY SA2 A1+1 BX6 X1 BX7 X2 SA6 SAVEALL SA7 SAVEALL+1 * SA1 B1+P.PARAM+2 INCREMENT C-LIST INDEX AND SX6 X1+1 AT ACTUAL PARAM 1 SA6 B1+P.PARAM * SB5 J.CRECC CREATE CLASS CODE SB6 GETCC1 JP CALLSYS * GETCC1 SA5 SYSCAP+1 RECOVER CLASSCODE BY SA1 B1+P.PARAM CALLING^ARBCAP^ SB4 B0 SB5 PROCLCD SB6 GETCC2 JP ARBCAP * GETCC2 SA1 B1+P.PARAM RESTORE ACTUAL PARAM AREA SA2 SAVEALL SA3 SAVEALL+1 BX6 X2 BX7 X3 SA6 A1 SA7 A6+1 BX6 X1 SA6 A7+1 JP GETCLCD ALL DONE * SAVEALL BSSZ 2 SPACE 5 * NUMCHWD EQU 1 STACKSZ EQU 10 PROCLCD BSSZ 2 NUMAP EQU 4 COMPBUF EQU 40 EXT IPROCSZ FIELDL EQU IPROCSZ+40 FILE1 BSSZ 2 FILADR1 BSSZ 1 RWFLG1 EQU 0 FILE2 BSSZ 2 FILADR2 BSSZ 1 OPMASK VFD 60/4B . OPTION BIT MASK FOR ECS ACTIONS: USED * IN PROTEK RWFLG2 EQU 0 EJECT * * EXT PRODUCE,S.SAVE1,S.SAVE2,SWAPIN ENTRY S.START * S.START SB7 START1 SX6 1 SET INTERRUPT LOCKOUT FOR SCHEDULER SA6 I.LOCK JP PRODUCE CALL SCHEDULER * START1 BX6 X6-X6 CLEAR PPU LOCK OUT SA6 I.LOCK BX7 X1 SA7 S.SAVE1 SAVE ECS ADDR OF PROC * BX6 X2 SA6 S.SAVE2 * JP SWAPIN * END