IDENT SYSENTR TITLE SYSTEM ENTRY / EXIT * ENTRY FROM USER INNITIATED CEJ IS TO THIS ROUTINE * * B1 = ORIGIN OF THE PROCESS SCRATCH AREA * * * THE CEJ IS DECODED TO FIND AND INPUT PARAMETER * LIST * THE FIRST ELEMENT OF THE INPUT PARAMETER LIST * (IP0) IS INTERPRETED AS A CAPABILITY INDEX FOR AN * OPERATION * THE OPERATION (IP0) IS THEN INTERPRETED TO FORM * AN ACTUAL PARAMETER LIST FOR THE SYSTEM CALL * PARAMETERS ARE DRAWN FROM EITHER THE OPERATION (IP0) * OR FROM THE INPUT PARAMETER LIST AS DIRECTED BY THE * OPERATION * CAPABILITY PARAMETERS SUPPLIED BY THE USER AS INDICES * IN HIS FULL C-LIST (IN THE INPUT PARAMETER LIST ) * ARE CHECKED FOR THE CORRECT TYPE AND REQUIRED OPTIONS * FINALLY, A TRANSFER IS MADE TO THE CORRECT SYSTEM * ROUTINE TO PROCESS THE USER REQUEST * * SUBROUTINES CALLED..OPINTER, GETCAP * TYPES XTEXT INTSYS XTEXT PROCSYM XTEXT ECSACT XTEXT ERRNUMS XTEXT * * EXT GETCAP,SUBPCAL,SUBPJUM,E.MOT,E.ECS,E.ERROR EXT S.QUANT,S.CHARG,S.SYSTM,S.USRTM,S.SWPTM,S.OLDTM * * UPDATE CLOCKS ENTRY USERCAL * USERCAL SA1 S.CHARG SA2 S.OLDTM SA3 B1+P.USRTIM USER TOTAL USER TIME BX6 X1 SA6 A2 UPDATE S.OLDTIM IX5 X1-X2 IX7 X5+X3 SA4 S.USRTM SYSTEM TOTAL USER TIME SA7 A3 IX6 X5+X4 SA6 A4+0 * * SA1 B1+P.XPACK FETCH USER P-COUNTER SB7 1 SA2 A1+B7 FETCH USER RA AX1 36 SB2 X1-1 AX2 36 SA4 X2+B2 FETCH THE WORD CONTAINING THE CEJ AX4 30 SB4 X4 LOWER 18 BITS OF THE CEJ INSTR * NOTE..THE USER CALL CEJ MUST BE * IN THE HIGH ORDER PART OF THE WORD SA3 A2+B7 FETCH USER FL AX3 36 GE B4,B0,UCALL1 JP IF IP LIST ADDR W/ CEJ * SX6 17B LOW ORDER CEJ SPECIFIES A REGISTER BX4 -X4*X6 WHICH CONTAINS THE IP LIST ADDR SB3 X4 SA4 A1+B3 FETCH THE REGISTER FOR XPACK SB4 X4 18 BITS OF REGISTER LT B4,B0,ERR21 ERROR- IP LIST ADDR NEGATIVE * UCALL1 SB2 X3 USER FL SX6 B4 SAVE IP LIST ADDR FOR STACK ENTRY LT B2,B4,ERR21X ERROR - IP LIST ADD .GT. FL * * FETCH THE CAPABILITY SPECIFIED BY IP0 WHICH SHOULD * BE A CAPABILITY FOR AN OPERATION * SA6 B1+P.IPLIST SB6 UCALL2 SA1 X2+B4 USER RA + IP LIST ADDR SB3 B0 .. ERROR MODIFIER FOR GETCAP JP GETCAP GET CAPABILITY * UCALL2 SA2 A0 LOAD THE CAPABILITY INTO REGISTERS SX2 X2-T.OPER MAKE SURE IP0 IS CAP FOR AN OPERATION SA3 A2+B7 NZ X2,ERR23 ERROR- IP0 NOT A CAP FOR AN OPERATION SX0 X3 MOT INDEX FOR OPERATION BX6 X6-X6 SET FLAG FOR PUTTING P-COUNTER SA6 B1+P.OLDP IN OLD TOP OF STACK IN CASE OF SUBP C SA0 B1+P.SCR2 + RE 1 READ MOT ENTRY FROM ECS RJ E.ECS MX6 39 TEST MOT ENTRY TO BE SURE IT IS SA2 A0+0 STILL THE CORRECT ENTRY FOR THE OPER BX3 X3-X2 BX3 X3*X6 NZ X3,ERR40 ERROR - ORERATION NOT IN MOT BX0 -X6*X2 + RE 1+PS.MASKL READ HEADER AND MASK BITS RJ E.ECS TO P.SCR2 SX1 1+PS.MASKL IX0 X0+X1 SA0 B1 + RE P.SCRL READ OPERATION (1ST ORDER ) RJ E.ECS * * BEGIN TO INTERPRET OPERATION * SA2 B1+B7 GET NUM VISIBLE PARAMS SB5 X2+B4 IP LIST ADDR + NUM VISIBLE PARAM LE B2,B5,ERR24 ERROR- IP LIST EXTENDS BEYOND USER FL SA2 B1 NG X2,UCALL25 JP IF PARAMETERLESS ACTION * * INNITIALIZE FOR PARAMETER PROCESSING * SA6 B1+P.PARAM-1 ACTUAL PARAMETER AREA POINTER LX2 6+18 SB6 X2 SA3 B1+3 PRE-FETCH PS BYTES SA2 B1+B6 PRE-FETCH PS DATA SB5 B1+P.LOCALC LOCAL C-LIST ORIGIN ( ABS) SA4 B1+P.CLIST SET LENGTH OF LOCAL C-LIST SA4 B1+X4 SB4 X4 * SB6 UCALL3 JP OPINTER GO INTERPRET 1ST ORDER OF OPERATION * UCALL25 SA2 B1+3 PARAMETERLESS .. GET CLASS CODE IN CA * CASE OF SUBP CALL * * * * ENTRY POINT FROM FRETURN UPON FINISHING * INTERPRETING LAST ORDER OF OPERATION * * * (X2 = CLASSCODE IF SUBP CALL ) ENTRY UCALL3 UCALL3 SA4 B1 1ST WD OF OPERATION ORDER LX4 1 TEST ACTION TYPE NG X4,UCALL16 JP IF PARAM TYPE MASKS NEEDED SA5 B1+2 2ND WD OF OPER ORDER MX7 60-ACTLIM .. ACTLIM IS DEFINED IN ECSACT BX5 -X7*X5 .. USE ACTLIM BITS OF ACTION FOR INDIRECT SB6 X5 JUMP JP B6+ACTIONL GO TO ECS ACTION CODE * * CONSTRUCT EXTRA * STUFF NEEDED FOR SUBPROCESS CALL OR * JUMP * UCALL16 BX6 X2 CLASS CODE AND INDEX (PRE-FETCHED) LX4 59 SA6 B1+P.PARAMC STORE AT END OF PARAM AREA MX0 6+18 EXTRACT AND STORE NUM OF PARAM AND BX6 -X0*X4 NUM OF CAPABILITY PARAM SA5 B1+1 AX5 18 SX5 X5 LX5 36 BX6 X6+X5 ADD ACTUAL PARAM SIZE SA6 A6-B7 * IFNE PS.MASKL,1,1 DOO ERROR IF PS.MASKL .NE. 1 ERR * SA2 B1+P.SCR2+1 FETCH PARAM TYPE BIT MASK BX6 X2 SA6 A6-B7 PASS PARAM TYPE BIT MASK * SA5 B1+2 GET ACTION CODE MX7 60-ACTLIM BX5 -X7*X5 SB6 X5 JP B6+ACTIONL GO DO ACTION * * * ENTRY ACTIONL * ACTIONL BSS TABLE * PUTACT MACRO ACT,ENTRY LOCAL T * * MAKE AN ENTRY IN THE ECS ACTION JUMP TABLE * * EXT ENTRY T EQU * ORG ACTIONL+ACT VFD 6/2,24/ENTRY,30/0 ORG T * ENDM * * * LIST G * CREATE A C-LIST * * PUTACT J.CREBLK,CREABLK PUTACT J.WRFILE,WRITFIL PUTACT J.REFILE,READFIL * * * PUTACT J.EVENT,EVNT PUTACT J.HANG,EVCHANG * * PUTACT J.SREG,SAVREG SAVE REGISTERS PUTACT J.RREG,RESTORE * * * * PUTACT J.CALSUB,SUBPCAL * PUTACT J.RETURN,RETURN * * PUTACT J.ESMGEN,ESMSETN PUTACT J.ESMLOC,ESMSET * * * PUTACT J.USRDAT,UDAT PUTACT J.FIXDAT,FDAT PUTACT J.USRCAP,UCAP PUTACT J.FIXCAP,FCAP PUTACT J.ANYCAP,ACAP PUTACT J.ADDOPT,OROPT PUTACT J.CHKBLK,CHKBLK PUTACT J.DELBLK,DELBLK PUTACT J.MAPZRO,MAPZERO PUTACT J.MPCHRO,MPCHGRO PUTACT J.MPCHRW,MPCHGRW PUTACT J.MOVBLK,MOVBLK * PUTACT J.FRETUR,FRETURN * * PUTACT J.GETEVF,GETEVF PUTACT J.CLRDAE,CLRDAE PUTACT J.SETDAE,SETDAE PUTACT J.SETIIB,SETIIB PUTACT J.CLRIIB,CLRIIB * PUTACT J.MGETH,MEVHANG PUTACT J.MGETF,MEVHNGF PUTACT J.DCLOX,DSPCLOX PUTACT J.BLKDAT,BDAT PUTACT J.BLKCAP,BCAP PUTACT J.RETPAR,RETPARM PUTACT J.TRDB,TRDB PUTACT J.CHMPRW,CHMPRW PUTACT J.CHMPRO,CHMPRO PUTACT J.DSCLX,DSPSCLX PUTACT J.JUMSUB,JUMPCAL * * EJECT * THIS ROUTINE INTERPRETS AN OPERATION TO * FORM THE ACTUAL PARAMETERS * * REGISTER ALLOCATION DURING PARAMETER PROCESSING * * A1 - X1 INPUT PARAM LIST POINTER * A2 - X2 PARAM SPECIFICATION DATA (PRE-FETCHED) * A3 - X3 PARAM SPECIFICATION BYTES(PRE-FETCHED) * A6 - X6 PARAMETER AREA POINTER AND DATA * B1 ORIG OF SCRATCH AREA (AND PROC REF) * B4 LOCAL C-LIST LENGTH * B5 LOCAL C-LIST ORIG (ABS) * B6 RETURN LINK * B7 CONST 1 * * SCRATCH = ^P.TEMP6^, ^P.SCR2+2^, ^P.SCR2+3^ * MOTE .... EACH PS ACTION MUST BE EXACTLY 2 WORDS * LONG * * ON EXIT: A2 = LAST PS DATUM + 1 * X2 = CLASS CODE IF SUBP CALL OPER * P.RET3 EQU P.TEMP5 * ENTRY OPINTER,OPFRT EXT PARMBUF * OPINTER SX7 PARMBUF INNITIALIZE FOR PLOCK PARAMS SA7 B1+P.TEMP6 OPFRT SX7 B6 SAVE RETURN LINK * OPFRT IS A SPECIAL ENTRY FOR F-RETURNS TO PREVENT SYSENTR * FROM RESETTING P.TEMP6 TO PARMBUF EVERYTIME SUCCESSIVE LAYERS * OF AN F-RETURN IS INTERPRETED (AND THEREBY SCRAMBLING PARAMETER * PASSING) * SA7 B1+P.RET3 MX7 57 3 BIT MASK OPINTER1 BX4 -X7*X3 EXTRACT PS BYTE AX3 3 SHIFT FOR NEXT PASS LX4 1 COMPUTE ACTION SB6 X4 JP B6+OPINTER3 JUMP OT PS ACTION * * PS ACTION 0 ... END OF PARAMATERS FOR THIS ORDER * OPINTER3 SA4 B1+P.RET3 SB6 X4 RETURN JP B6 * * PS ACTION 1 ... GO TO NEXT PS BYTE WORD * OPINTER4 SA3 A3+B7 FETCH NEXT WORD FULL OF PS BYTES JP OPINTER1 + BSS 1 * * PS ACTION 2 ... 'NONE' PARAM SPECIFICATION * OPINTER5 JP ERR26 + BSS 1 * * PS ACTION 3 ... USER SUPPLIED DATUM * OPINTER6 SA1 A1+B7 FETCH DATUM FROM IP LIST BX6 X1 SA6 A6+1 STORE IN ACTUAL PARAM AREA JP OPINTER1 * * PS ACTION 4 ... FIXED DATUM * OPINTER7 BX6 X2 DATUM WAS PRE-FETCHED SA2 A2+1 PREFETCH NEXT PS DATA WORD SA6 A6+B7 STORE DATUM IN ACTUAL PARAM AREA JP OPINTER1 * * PS ACTION 5 ... FIXED CAPABILITY * OPINTER8 BX6 X2 PRE-FETCHED PS DATUM SA2 A2+B7 FETCH 2ND WD OF CAPABILITY SA6 A6+B7 BX6 X2 SA2 A2+B7 PRE-FETCH NEX PS DATUM SA6 A6+B7 STORE 2ND WD OF CAPABILITY JP OPINTER1 * * PS ACTION 6 ... BLOCK PARAMETER * OPINTR13 SA1 A1+B7 BLOCK CONTROL FROM IP-LIST PL X2,OPINTR16 JP ON DATA BLOCK JP OPINTR17 PROCESS BLOCK CAPABILITIES * * PS ACTION 7 .. USER SUPPLIED CAPABILITY * OPINTER9 SA1 A1+B7 GET CAPABILITY INDEX FROM SB6 X1 IP LIST LT B6,B0,ERR22X ERROR-NEGATIVE C-LIST INDEX LE B4,B6,OPINTR11 JP IF NOT IN LOCAL C-LIST SB6 B6+B6 SA4 B5+B6 FETCH 1ST WD OF CAPABILITY NG X1,OPINTR15 JP IF INDIRECT REFERENCE * OPINTR10 BX5 -X4*X2 TEST CAP FOR TYPE AND OPTIONS BX6 X4 SA6 A6+B7 STORE 1ST WD OF CAPABILITY SA4 A4+B7 FETCH 2ND WD OF CAPABILITY NZ X5,ERR25 JP IF TYPE OR OPTION ERROR BX6 X4 SA6 A6+B7 STORE 2ND WD OF CAPABILITY SA2 A2+B7 PRE-FETCH NEXT PS DATUM JP OPINTER1 * * CAPABILITY INDEX NOT IN LOCAL C-LIST * OPINTR11 SA4 B1+P.CLIST ORIG OF C-LIST TABLE SX4 X4+2 LENGTH OF 2ND C-LIST SA4 X4+B1 SB6 B6-B4 ZR X4,ERR22 ERROR-CAP INDEX TOO LARGE SB3 X4 LT B6,B3,OPINTR14 JP IF INDEX IN 2ND C-LIST * OPINTR12 SA4 A4+2 SB6 B6-B3 LOOP TILL PROPER C-LIST SB3 X4 ZR X4,ERR22 ERROR-CAP INDEX TOO LARGE GE B6,B3,OPINTR12 JP IF NOT FOUND C-LIST YET * * GOT PROPER C-LIST * OPINTR14 SA4 A4+1 GET UNIQUE NAME AND MOT INDEX SX0 X4 OF THE C-LIST SA0 A6+B7 + RE 1 READ MOT ENTRY RJ E.ECS SA5 A0 BX4 X4-X5 TEST MOT ENTRY MX6 39 BX4 X4*X6 NZ X4,ERR41 ERROR- C-LIST GONE BX0 -X6*X5 ECS ADDR OF C-LIST SX4 B6 C-LIST INDEX LX4 1 SX4 X4+1 IX0 X4+X0 + RE 2 READ CAPABILITY RJ E.ECS * SA4 A0 FETCH 1ST WD OF CAPABILITY PL X1,OPINTR10 JP IF NOT INDIRECT REFERENCE * * INDIRECT C-LIST REFERENCE * OPINTR15 SX6 X4-T.CLIST TEST FOR CAPABILITY FOR A C-LIST NZ X6,ERR27 JP IF NOT C-LIST CAPABILITY SA4 A4+B7 SX0 X4 AX1 30 SHIFT TO INDIRECT INDEX SA0 A6+B7 + RE 1 READ MOT ENTRY RJ E.ECS SX1 X1 NG X1,ERR22X ERROR-INDIRECT INDEX NEGATIVE MX0 39 SA5 A0 BX4 X4-X5 TEST MOT ENTRY BX4 X4*X0 BX0 -X0*X5 + RE 1 READ LENGTH OF C-LIST RJ E.ECS NZ X4,ERR41 ERROR- C-LIST GONE FROM MOT SA5 A0+0 IX5 X1-X5 PL X5,ERR22 ERROR-INDEX TOO LARGE LX1 1 SX1 X1+1 IX0 X0+X1 + RE 2 READ CAPABILITY RJ E.ECS SA4 A0 FETCH 1ST WD OF CAPABILITY JP OPINTR10 * SPACE 3 * * * ***** BLOCK DATA PARAMTER ***** * * OPINTR16 SX4 X1 X4 _ PTR TO DATA BLOCK LX1 60-30 NG X4,ERR30 ERROR: NEGATIVE POINTER SB2 X1 B2 _ COUNT SB3 X2 MAX COUNT FOR OPERATION LT B2,B0,ERR32 ERROR: NEGATIVE COUNT SA5 B1+P.TEMP6 GT B2,B3,ERR33 ERROR: USER COUNT TOO LARGE BX0 X5 BUFFER ADDRESS SX7 X5+B2 INCR BUFFER ADDRESS SA7 A5 LX5 18 MX6 59 1ST WD OF ACTUAL PARAM _ -1 SA6 A6+B7 SX6 B2 BX6 X6+X5 CONSTRUCT ACT PARAM CONTROL * * THE APC * ************************************* * * 0 * ECS BUFR * ACT. NUM * MAX NUM * * * ADDR * PASSED * WDS * * ************************************* LX6 18 SX7 B3 MAX COUNT BX6 X6+X7 SA6 A6+B7 * SA5 B1+P.XPACK+2 AX5 36 FL SX7 X4+B2 IX5 X5-X7 NG X5,ERR34 ERROR: BLOCK EXTENDS PAST FL SA5 B1+P.XPACK+1 AX5 36 RA IX5 X5+X4 SA0 X5 + WE B2 WRITE BLOCK DATA TO BUFFER RJ E.ECS * SA2 A2+B7 NEXT PS DATUM MX7 57 RESTORE MASK JP OPINTER1 PROCED TO NEXT PARAM * SPACE 5 * * * ***** BLOCK CAPABILITY PARAMETER ***** * OPINTR17 SB2 X1 B2 _ STARTING INDEX LX1 60-30 SA5 B1+P.TEMP6 BUFFER ADDRESS SX1 X1 CAPABILITY COUNT LT B2,B0,ERR31 ERROR: NEGATIVE CAP INDEX BX0 X5 NG X1,ERR32 ERROR: NEGATIVE COUNT MX6 59 1ST WD ACTUAL PARAM _ -1 SA6 A6+B7 LX5 18 FORM APC ==> 2ND WD OF ACTUAL PARAM * * THE ACTUAL PARAMETER CONTROL FOR BLOCK CAPABILITY * ************************************* * * 1 * ECS BUFR * ACT. NUM * MAX NUM * * * ADDR * CAPS * CAPS * * ************************************* * BX6 X5+X1 LX6 18 BX6 X6+X2 ADD IN MAX COUNT AND CAP FLAG SA6 A6+B7 IX7 X0+X1 INCR BUFFER ADDRESS IX7 X7+X1 SA7 A5 SX2 X2 MAX CAP COUNT FROM OPER IX7 X2-X1 NG X7,ERR33 USER WANTS TO PASS TOO MUCH BX2 X0 X2 _ BUFFER ADDR * GE B2,B4,OPINTR19 JP IF NOT IN LOCAL C-LIST * * XFER CAPABILITIES FROM LOCAL C-LIST SB3 B4-B2 FIND MIN(LENGTH-INDEX, COUNT) SX7 B3 IX7 X7-X1 NG X7,OPINTR18 SB3 X1 OPINTR18 SA0 B5+B2 B3 = COUNT TO XFER SA0 A0+B2 ABS STARTING CM ADDR SX7 B3 SB3 B3+B3 + WE B3 RJ E.ECS IX1 X1-X7 DECR COUNT SB2 B4 INDEX _ LENGTH LOC C-LIST ZR X1,OPINTR23 JP IF DONE SX2 X0+B3 INCR BUFFER ADDR * * B2 = C-LIST INDEX * X1 = COUNT TO GO * X2 = BUFFER ADDR OPINTR19 SA4 B1+P.CLIST FIND STARTING C-LIST SA4 B1+X4 SB2 B2-B4 * OPINTR20 SA4 A4+2 SB3 X4 LEN OF NEXT C-LIST LT B2,B3,OPINTR21 JP IF GOT A C-LIST SB2 B2-B3 NZ X4,OPINTR20 JP ERR35 ERROR: BLOCK NOT WITHIN FULL C-LIST * * B2 = INDEX * B3 = LENGTH OF C-LIST * X1 = COUNT * X2 = BUFFER ADDR * A4 = FULL C-TABLE POINTER * X5 = ECS ADDR OF C-LIST OPINTR21 SA5 A4+1 SET UP NEXT C-LIST IFNE PS.MASKL,1,1 ERR WATCH OUT FOR OVERFLOW OF ^P.SCR2^ SA0 B1+P.SCR2+PS.MASKL+1 SX0 X5 MX7 39 BX6 X5 + RE 1 READ MOT RJ E.ECS SA5 A0 BX6 X6-X5 BX6 X7*X6 BX5 -X7*X5 ECS ADDR OF C-LIST NZ X6,ERR36 ERROR: C-LIST GONE MX7 59 IX5 X5-X7 * * MOVE CAPABILITIES * OPINTR22 SX7 B2 INDEX LX7 1 IX0 X5+X7 + RE 2 READ ONE CAPABILITY RJ E.ECS BX0 X2 BUFFER ADDR SB2 B2+B7 INCR INDEX SX1 X1-1 DECR COUNT + WE 2 WRITE ONE CAPABILITY TO BUFFER RJ E.ECS SX2 X0+2 INCR BUFFER ADDR * ZR X1,OPINTR23 JP IF DONE (COUNT EXAUSTED) NE B3,B2,OPINTR22 LOOP TO END OF C-LIST * * STEP TO NEXT C-LIST * SA4 A4+2 SB3 X4 LENGTH NEXT C-LIST SB2 B0 INDEX IN NEXT C-LIST EQ B3,B0,ERR35 ERROR:BLOCK NOT WITHIN FULL C-LIST JP OPINTR21 * * ALL DONE * OPINTR23 SA2 A2+B7 FETCH NEXT PS DATUM MX7 57 RESTORE MASK JP OPINTER1 * * EJECT * THIS IS THE STANDARD RETURN FROM ANY ECS ACTION * * IT UPDATES THE USERS P-COUNTER AS DIRECTRD BY * THE USERS CEJ INSTRUCTION AND THEN RETURNS TO THE USE * EXT SWAPOUT ENTRY SYSRET * SYSRET SA1 B1+P.XPACK GET OLD PCOUNTER LX1 6+18 SX3 X1 SA2 B1+P.XPACK+1 GET USER RA BX1 X1-X3 CLEAR OUT OLD PCOUNTER SB2 X3-1 SA4 B1+P.XPACK+2 GET USER FL AX2 36 SA5 X2+B2 GET USER CEJ INSTRUCTION MX6 9 CHECK FOR CEJ INSTR BX6 X6*X5 LX6 9 SX6 X6-13B NZ X6,ERR28 ERROR:XJ CLOBBERED SX5 X5 EXTRACT P-COUNTER OFFSET IX3 X3+X5 NEW P-COUNTER NG X3,ERR15 ERROR- P-COUNTER NEGATIVE AX4 36 IX4 X3-X4 PL X4,ERR15X ERROR - NEW P-CNT .GT. FL BX6 X1+X3 LX6 36 SA6 A1 * * THIS ENTRY POINT USED WHEN P-COUNTER IS NOT * TO BE MODIFIED * ENTRY TOUSER * * UPDATE CLOCKS * TOUSER SA1 S.CHARG SA2 S.OLDTM SA3 B1+P.SYSTIM BX6 X1 SA6 A2 IX5 X1-X2 IX7 X5+X3 SA4 S.SYSTM SA7 A3 IX6 X5+X4 SA6 A4 * SX7 0 SA7 2 SET TO RUNNING SA7 E.ECS SA1 S.QUANT PL X1,SWAPOUT * ENTRY S.RETU S.RETU XJ B1+P.XPACK CEJ TO USER * SX7 2 SA7 2 SET TO SYSTEM SX7 0 SA7 E.ECS JP USERCAL EJECT * * ERR26 SX7 E.PSANY EQ CL7 ERR23 SX7 E.IP0 SX1 0 .. IP0 MODIFIER SX6 E.OPER SX6 E.OPER EQ CL7X ERR25 SX7 E.CAPTY EQ CL7 ERR40 SX7 E.NOOP SX1 0 .. IP0 MODIFIER EQ CL7X CL7 SX6 E.OPER SX1 A1 .. FIND ERROR MODIFIER SA2 B1+P.IPLIST IX1 X1-X2 SA2 B1+P.XPACK+1 AX2 36 IX1 X1-X2 CL7X LX1 18 BX7 X1+X7 EQ E.ERROR ERR41 SX7 E.CLMOT SX6 E.MISCE EQ E.ERROR ERR24 SX7 E.BIGPT SX1 0 .. IP0 MODIFIER EQ CL2A ERR15 SX7 E.NEGPCT .. NEG P-COUNTER: 2,9 ERROR EQ ERR37 ERR15X SX7 E.BIGPCT .. P-COUNTER TOO BIG: 2,10 ERROR EQ ERR37 ERR21 SX7 E.NEGPT SX1 0 .. IP0 MOFIFIER EQ CL2A ERR21X SX7 E.BIGPT SX1 0 .. IP0 MODIFIER EQ CL2A ERR22 SX7 E.BIGIX EQ CL2 ERR27 SX7 E.NOTCL INDIRECT CAPABILITY REFERENCE JP CL2 NOT THRU A CLIST ERR22X SX7 E.NEGIX CL2 SX1 A1 CALCULATE THE INDEX OF THE SA2 B1+P.IPLIST OFFENDING PARAMETER IX1 X1-X2 SA2 B1+P.XPACK+1 AX2 36 IX1 X1-X2 CL2A LX1 18 MASK IT INTO THE ERRNUM BX7 X1+X7 SX6 E.PARMS EQ E.ERROR ERR28 SX7 E.NOXJ SX6 E.SUBP JP E.ERROR CEJ INSTR CLOBBERED * BLOCK PARAM ERRORS....SHOULD BE INTEGRATED WITH * OTHERS WHEN ERRORS FIXED UP ERR30 SX7 E.NEGPT NEGATIVE POINTER JP CL2 ERR31 SX7 E.NEGIX NEGATIVE C-LIST INDEX JP CL2 ERR32 SX7 E.NEGPAR NEGATIVE PARAMETER JP CL2 ERR33 SX7 E.BIGCNT BLOCK BIGGER THAN PS COUNT JP CL7 ERR34 SX7 E.BDTBLK .. BLOCK DATA EXTENDS PAST FL JP CL2 ERR35 SX7 E.BCPBLK CAP BLK GOES PAST FULL C-LIST JP CL2 ERR36 SX7 E.CLMOT C-LIST GONE FROM MOT SX6 E.MISCE SX1 A1 SA2 B1+P.IPLIST .. FIND ERROR MODIFIER IX1 X1-X2 SA2 B1+P.XPACK AX2 36 IX1 X1-X2 LX1 18 BX7 X7+X1 JP E.ERROR * ERR37 SX6 E.PARMS JP E.ERROR * END