COMPGFP 
COMMON
          CTEXT  COMPGFP - MANAGED TABLE PROCESSOR. 
          SPACE  4,10 
 QUAL$    IF     -DEF,QUAL$ 
          QUAL   COMPGFP
 QUAL$    ENDIF 
*COMMENT  COMPGFP - MANAGED TABLE PROCESSOR.
*         COMMENT  COPYRIGHT CONTROL DATA SYSTEMS INC.  1992. 
          SPACE  4,10 
***       COMPGFP - MANAGED TABLE PROCESSOR.
*         J. L. LARSON.      81/04/03.
          SPACE  4,35 
***       *COMPGFP* DEFINES THE PROCESSORS NEEDED TO ACCESS ENTRIES IN
*         THE CLT, EJT, EST, SYSTEM FNT, JCB, ORT AND QFT TABLES. 
*         *COMPGFP* CONTAINS SUBROUTINES NEEDED TO PROCESS CALLS FROM 
*         THE *SFA* MACRO.  THE *SFA* MACRO IS INTENDED TO BE THE ONLY
*         MECHANISM TO GENERATE CALLS TO SUBROUTINES *.CLT*, *.EJT*,
*         *.EST*, *.FNT*, *.JCB*, *.ORT* AND *.QFT* IN *COMPGFP*. 
* 
*         IN ADDITION, *COMPGFP* WILL GENERATE THE *.BLI* SUBROUTINE
*         FOR USE BY THE *BLI* MACRO, WHICH BUILDS LONG (CYBER 180) 
*         INSTRUCTIONS. 
* 
*         IF *BLI$* IS DEFINED, SUBROUTINE *.BLI* WILL BE ASSEMBLED 
*         TO BUILD LONG INSTRUCTIONS.  WHEN *BLI$* IS USED, 
*         1) THE *.BLI* SYMBOL DEFINED IN *NOSTEXT* MUST BE IGNORED BY
*            INCLUDING IT ON THE *SST* PSEUDO-OP, AND 
*         2) THE CONTENTS OF *.BLI* MUST HAVE 100000B ADDED TO IT TO
*            CONVERT IT TO A *LONG* INSTRUCTION.
* 
*         IF *CLT$* IS DEFINED, SUBROUTINE *.CLT* WILL BE ASSEMBLED 
*         TO CALCULATE THE ABSOLUTE ADDRESS OF AN ENTRY IN THE
*         COMMON LIBRARIES TABLE. 
* 
*         IF *EJT$* IS DEFINED, SUBROUTINE *.EJT* WILL BE ASSEMBLED 
*         TO CALCULATE THE ABSOLUTE ADDRESS OF AN ENTRY IN THE
*         EXECUTING JOB TABLE.
* 
*         IF *EST$* IS DEFINED, SUBROUTINE *.EST* WILL BE ASSEMBLED 
*         TO CALCULATE THE ABSOLUTE ADDRESS OF AN ENTRY IN THE
*         EQUIPMENT STATUS TABLE. 
* 
*         IF *FNT$* IS DEFINED, SUBROUTINE *.FNT* WILL BE ASSEMBLED TO
*         CALCULATE THE ABSOLUTE ADDRESS OF AN ENTRY IN THE SYSTEM FILE 
*         NAME TABLE. 
* 
*         IF *JCB$* IS DEFINED, SUBROUTINE *.JCB* WILL BE ASSEMBLED TO
*         CALCULATE THE ABSOLUTE ADDRESS OF AN ENTRY IN THE JOB CONTROL 
*         BLOCK TABLE.
* 
*         IF *QFT$* IS DEFINED, SUBROUTINE *.QFT* WILL BE ASSEMBLED 
*         TO CALCULATE THE ABSOLUTE ADDRESS OF AN ENTRY IN THE
*         QUEUE FILE TABLE. 
* 
*         IF *ORT$* IS DEFINED, SUBROUTINE *.ORT* WILL BE ASSEMBLED 
*         TO CALCULATE THE ABSOLUTE ADDRESS OF AN ENTRY IN THE
*         OPTICAL DISK REQUEST TABLE. 
* 
*         IF *IFP$* IS DEFINED, REMOTE CODE FOR SUBROUTINE *IFP* WILL 
*         BE DEFINED TO INITIALIZE THE MANAGED TABLE PROCESSORS.  AN
*         *IFP* LABELED *HERE* INSTRUCTION MUST BE SPECIFIED TO CAUSE 
*         ASSEMBLY OF THE *IFP* SUBROUTINE AT THE APPROPRIATE PLACE 
*         WITHIN THE CALLING PP PROGRAM (PRESET RECOMMENDED).  THE
*         CALLING PP PROGRAM MUST RETURN JUMP TO *IFP* BEFORE 
*         PROCESSING ANY *SFA* MACRO CALLS.  IF *QUAL$* IS DEFINED IN 
*         THE CALLING PROGRAM, THE SAME QUALIFIER MUST BE IN EFFECT FOR 
*         *COMPGFP* AND FOR *IFP* REMOTE CODE.
* 
*         IF *IFP$* IS NOT DEFINED, SUBROUTINE *IFP* WILL BE ASSEMBLED
*         IN-LINE, AND THE FIRST EXECUTION OF *.CLT*, *.EJT*, *.EST*, 
*         *.FNT*, *.JCB*, *.ORT* OR *.QFT* WILL INITIALIZE THE MANAGED
*         TABLE PROCESSORS. 
* 
*         EXECUTION OF *IFP* DESTROYS DIRECT CELLS CM THROUGH CM+4, AND 
*         MODIFIES CODE TO DISABLE FURTHER CALLS TO *IFP* FROM *.CLT*,
*         *.EJT*, *.EST*, *.FNT*, *.JCB*, *.ORT* AND *.QFT*.
* 
*         NOTE - IF MULTIPLE OVERLAYS CALL *COMPGFP*, CAUTION SHOULD
*         BE OBSERVED TO ENSURE THAT ONLY THE CURRENT OVERLAY-S CODE
*         IS MODIFIED.  CODE DESTRUCTION AND MANY INTERESTING SYMPTOMS
*         CAN OCCUR IF THIS IS NOT FOLLOWED.
 .CLT     SPACE  4,10 
 CLT$     IF     DEF,CLT$ 
 .CLT     SPACE  4,10 
**        .CLT - CALCULATE CLT ENTRY ADDRESS. 
* 
*         ENTRY  (A) = ORDINAL OF ENTRY IN CLT. 
* 
*         EXIT   (A) = ABSOLUTE ADDRESS OF CLT ENTRY. 
* 
*         USES   T0.
* 
*         CALLS  IFP (FOR INITIALIZATION IF *IFP$* IS NOT DEFINED). 
* 
*         MACROS CFI. 
  
 CLT1     CFI    CLT         CALCULATE CLT ENTRY WORD INDEX 
 CLTB     ADC    **          (CLT FWA)
  
 .CLT     SUBR               ENTRY/EXIT 
 IFP$     IF     -DEF,IFP$
 CLTA     RJM    IFP         INITIALIZE MANAGED TABLE PROCESSORS
*         UJN    CLT1        (INITIALIZE COMPLETE)
 IFP$     ENDIF 
          UJN    CLT1        CALCULATE ABSOLUTE CLT ADDRESS 
  
 CLT$     ENDIF 
          SPACE  4,10 
 EJT$     IF     DEF,EJT$ 
 .EJT     SPACE  4,10 
**        .EJT - CALCULATE EJT ENTRY ADDRESS. 
* 
*         ENTRY  (A) = ORDINAL OF ENTRY IN EJT. 
* 
*         EXIT   (A) = ABSOLUTE ADDRESS OF EJT ENTRY. 
* 
*         USES   T0.
* 
*         CALLS  IFP (FOR INITIALIZATION IF *IFP$* IS NOT DEFINED). 
* 
*         MACROS CFI. 
  
  
 EJT1     CFI    EJT         CALCULATE EJT ENTRY WORD INDEX 
 EJTB     ADC    **          (EJT FWA)
  
 .EJT     SUBR               ENTRY/EXIT 
 IFP$     IF     -DEF,IFP$
 EJTA     RJM    IFP         INITIALIZE MANAGED TABLE PROCESSORS
*         UJN    EJT1        (INITIALIZATION COMPLETE)
 IFP$     ENDIF 
          UJN    EJT1        CALCULATE ABSOLUTE EJT ADDRESS 
  
 EJT$     ENDIF 
  
  
 EST$     IF     DEF,EST$ 
 .EST     SPACE  4,10 
**        .EST - CALCULATE EST ENTRY ADDRESS. 
* 
*         ENTRY  (A) = ORDINAL OF EST ENTRY.
* 
*         EXIT   (A) = ABSOLUTE ADDRESS OF EST ENTRY. 
* 
*         USES   T0.
* 
*         CALLS  IFP (FOR INITIALIZATION IF *IFP$* IS NOT DEFINED). 
* 
*         MACROS CFI. 
  
  
 EST1     CFI    EST         CALCULATE EST ENTRY WORD INDEX 
 ESTB     ADC    **          (EST FWA)
  
 .EST     SUBR               ENTRY/EXIT 
 IFP$     IF     -DEF,IFP$
 ESTA     RJM    IFP         INITIALIZE MANAGED TABLE PROCESSORS
*         UJN    EST1        (INITIALIZATION COMPLETE)
 IFP$     ENDIF 
          UJN    EST1        CALCULATE ABSOLUTE EST ADDRESS 
  
 EST$     ENDIF 
  
  
 BLI$     IF     DEF,BLI$ 
 .BLI     SPACE  4,15 
**        .BLI - BUILD LONG INSTRUCTION (CYBER 180-S ONLY). 
* 
*         ENTRY  (A) = THE LONG INSTRUCTION.
*                (T3) = THE ADDRESS AT WHICH TO STORE THE INSTRUCTION.
*                (.EST) = RETURN ADDRESS. 
* 
*         NOTE - *.BLI* IS ONLY TO BE USED BY THE *BLI* MACRO.  *.BLI*
*         EXITS TO THE RETURN ADDRESS OF THE LAST CALL TO *.EST*.  THIS 
*         IS A VERY UNUSUAL EXIT PATH, BUT IT ALLOWS THE BUILDING OF
*         LONG INSTRUCTIONS TO BE ACCOMPLISHED IN A MINIMAL NUMBER OF 
*         BYTES OF RESIDENT CODE. 
  
  
 .BLI     STI    T3 
*         STIL   T3          (SET BY CALLER-S CODE) 
          UJP    .ESTX       RETURN 
  
 BLI$     ENDIF 
  
  
 FNT$     IF     DEF,FNT$ 
 .FNT     SPACE  4,10 
**        .FNT - CALCULATE SYSTEM FNT ENTRY ADDRESS.
* 
*         ENTRY  (A) = ORDINAL OF ENTRY IN SYSTEM FNT.
* 
*         EXIT   (A) = ABSOLUTE ADDRESS OF SYSTEM FNT ENTRY.
* 
*         USES   T0.
* 
*         CALLS  IFP (FOR INITIALIZATION IF *IFP$* IS NOT DEFINED). 
* 
*         MACROS CFI. 
  
  
 FNT1     CFI    FNT         CALCULATE SYSTEM FNT ENTRY WORD INDEX
 FNTB     ADC    **          (FNT FWA)
  
 .FNT     SUBR               ENTRY/EXIT 
 IFP$     IF     -DEF,IFP$
 FNTA     RJM    IFP         INITIALIZE MANAGED TABLE PROCESSORS
*         UJN    FNT1        (INITIALIZATION COMPLETE)
 IFP$     ENDIF 
          UJN    FNT1        CALCULATE ABSOLUTE FNT ADDRESS 
  
 FNT$     ENDIF 
  
  
 JCB$     IF     DEF,JCB$ 
 .JCB     SPACE  4,10 
**        .JCB - CALCULATE JCB ENTRY ADDRESS. 
* 
*         ENTRY  (A) = ORDINAL OF ENTRY IN JCB. 
* 
*         EXIT   (A) = ABSOLUTE ADDRESS OF JCB ENTRY. 
* 
*         USES   T0.
* 
*         CALLS  IFP (FOR INITIALIZATION IF *IFP$* IS NOT DEFINED). 
* 
*         MACROS CFI. 
  
 JCB1     CFI    JCB         CALCULATE JCB ENTRY WORD INDEX 
 JCBB     ADC    **          (JCB FWA)
  
 .JCB     SUBR               ENTRY/EXIT 
 IFP$     IF     -DEF,IFP$
 JCBA     RJM    IFP         INITIALIZE MANAGED TABLE PROCESSORS
*         UJN    JCB1        (INITIALIZE COMPLETE)
 IFP$     ENDIF 
          UJN    JCB1        CALCULATE ABSOLUTE JCB ADDRESS 
  
 JCB$     ENDIF 
  
  
 QFT$     IF     DEF,QFT$ 
 .QFT     SPACE  4,10 
**        .QFT - CALCULATE QFT ENTRY ADDRESS. 
* 
*         ENTRY  (A) = ORDINAL OF ENTRY IN QFT. 
* 
*         EXIT   (A) = ABSOLUTE ADDRESS OF QFT ENTRY. 
* 
*         USES   T0.
* 
*         CALLS  IFP (FOR INITIALIZATION IF *IFP$* IS NOT DEFINED). 
* 
*         MACROS CFI. 
  
  
 QFT1     CFI    QFT         CALCULATE QFT ENTRY WORD INDEX 
 QFTB     ADC    **          (QFT FWA)
  
 .QFT     SUBR               ENTRY/EXIT 
 IFP$     IF     -DEF,IFP$
 QFTA     RJM    IFP         INITIALIZE MANAGED TABLE PROCESSORS
*         UJN    QFT1        (INITIALIZATION COMPLETE)
 IFP$     ENDIF 
          UJN    QFT1        CALCULATE ABSOLUTE QFT ADDRESS 
  
 QFT$     ENDIF 
 .ORT     SPACE  4,10 
 ORT$     IF     DEF,ORT$ 
 .ORT     SPACE  4,10 
**        .ORT - CALCULATE ORT ENTRY ADDRESS. 
* 
*         ENTRY  (A) = ORDINAL OF ENTRY ON ORT. 
* 
*         EXIT   (A) = ABSOLUTE ADDRESS OF ORT ENTRY. 
* 
*         USES   T0.
* 
*         CALLS  IFP (FOR INITIALIZATION IF *IFP$* IS NOT DEFINED). 
* 
*         MACROS CFI. 
  
 ORT1     CFI    ORT         CALCULATE ORT ENTRY WORD INDEX 
 ORTB     ADC    **          (ORT FWA)
  
 .ORT     SUBR               ENTRY/EXIT 
 IFP$     IF     -DEF,IFP$
 ORTA     RJM    IFP         INITIALIZE MANAGED TABLE PROCESSORS
*         UJN    ORT1        (INITIALIZE COMPLETE)
 IFP$     ENDIF 
          UJN    ORT1        CALCULATE ABSOLUTE ORT ADDRESS 
  
 ORT$     ENDIF 
  
  
 IFP$     IF     DEF,IFP$ 
 IFP      RMT 
 QUAL$    IF     -DEF,QUAL$ 
          QUAL   COMPGFP
 QUAL$    ENDIF 
 IFP$     ENDIF 
 IFP      SPACE  4,10 
**        IFP - INITIALIZE MANAGED TABLE PROCESSORS.
* 
*         ENTRY  (A) = ORDINAL IF CALLED FROM *.CLT*, *.EJT*, *.EST*, 
*                *.FNT*, *.ORT* OR *.QFT* (*IFP$* NOT DEFINED). 
* 
*         EXIT   (A) = ORDINAL, IF *IFP$* NOT DEFINED.
*                TABLE ADDRESS(ES) INSERTED AS APPROPRIATE. 
*                *UJN* INSTRUCTION(S) INSERTED AS APPROPRIATE.
* 
*         USES   T0, CM - CM+4. 
  
  
 IFP      SUBR               ENTRY/EXIT 
 IFP$     IF     -DEF,IFP$
          STD    T0          SAVE (A) = ORDINAL 
 IFP$     ENDIF 
 CLT$     IF     DEF,CLT$ 
          LDK    CLTP        GET CLT POINTER
          CRD    CM 
          LDD    CM          SET CLT FWA OF *.CLT* SUBROUTINE 
          RAM    CLTB 
          LDD    CM+1 
          STM    CLTB+1 
 IFP$     IF     -DEF,IFP$
          LDC    **          REPLACE *IFP* CALL WITH *UJN CLT1* 
          ORG    *-1
          LOC    CLTA 
          UJN    CLT1        CALCULATE CLT ENTRY ADDRESS
          LOC    *O 
          STM    CLTA 
 IFP$     ENDIF 
 CLT$     ENDIF 
 EJT$     IF     DEF,EJT$ 
          LDK    EJTP        GET EJT POINTER
          CRD    CM 
          LDD    CM          SET EJT FWA OF *.EJT* SUBROUTINE 
          RAM    EJTB 
          LDD    CM+1 
          STM    EJTB+1 
 IFP$     IF     -DEF,IFP$
          LDC    **          REPLACE *IFP* CALL WITH *UJN EJT1* 
          ORG    *-1
          LOC    EJTA 
          UJN    EJT1        CALCULATE EJT ENTRY ADDRESS
          LOC    *O 
          STM    EJTA 
 IFP$     ENDIF 
 EJT$     ENDIF 
 EST$     IF     DEF,EST$ 
          LDK    ESTP        READ EST POINTER 
          CRD    CM 
          LDD    CM          SET EST FWA IN *.EST* SUBROUTINE 
          RAM    ESTB 
          LDD    CM+1 
          STM    ESTB+1 
 IFP$     IF     -DEF,IFP$
          LDC    **          REPLACE *IFP* CALL WITH *UJN EST1* 
          ORG    *-1
          LOC    ESTA 
          UJN    EST1        CALCULATE EST ENTRY ADDRESS
          LOC    *O 
          STM    ESTA 
 IFP$     ENDIF 
 EST$     ENDIF 
 FNT$     IF     DEF,FNT$ 
          LDK    FNTP        GET SYSTEM FNT POINTER 
          CRD    CM 
          LDD    CM          SET SYSTEM FNT FWA IN *.FNT* SUBROUTINE
          RAM    FNTB 
          LDD    CM+1 
          STM    FNTB+1 
 IFP$     IF     -DEF,IFP$
          LDC    **          REPLACE *IFP* CALL WITH *UJN FNT1* 
          ORG    *-1
          LOC    FNTA 
          UJN    FNT1        CALCULATE FNT ENTRY ADDRESS
          LOC    *O 
          STM    FNTA 
 IFP$     ENDIF 
 FNT$     ENDIF 
 JCB$     IF     DEF,JCB$ 
          LDK    JBCP        GET JCB POINTER
          CRD    CM 
          LDD    CM          SET JCB FWA OF *.JCB* SUBROUTINE 
          RAM    JCBB 
          LDD    CM+1 
          STM    JCBB+1 
 IFP$     IF     -DEF,IFP$
          LDC    **          REPLACE *IFP* CALL WITH *UJN JCB1* 
          ORG    *-1
          LOC    JCBA 
          UJN    JCB1        CALCULATE JCB ENTRY ADDRESS
          LOC    *O 
          STM    JCBA 
 IFP$     ENDIF 
 JCB$     ENDIF 
 QFT$     IF     DEF,QFT$ 
          LDK    QFTP        GET QFT POINTER
          CRD    CM 
          LDD    CM          SET QFT FWA IN *.QFT* SUBROUTINE 
          RAM    QFTB 
          LDD    CM+1 
          STM    QFTB+1 
 IFP$     IF     -DEF,IFP$
          LDC    **          REPLACE *IFP* CALL WITH *UJN QFT1* 
          ORG    *-1
          LOC    QFTA 
          UJN    QFT1        CALCULATE QFT ENTRY ADDRESS
          LOC    *O 
          STM    QFTA 
 IFP$     ENDIF 
 QFT$     ENDIF 
 ORT$     IF     DEF,ORT$ 
          LDK    ORTP        GET ORT POINTER
          CRD    CM 
          LDD    CM          SET ORT FWA OF *.ORT* SUBROUTINE 
          RAM    ORTB 
          LDD    CM+1 
          STM    ORTB+1 
 IFP$     IF     -DEF,IFP$
          LDC    **          REPLACE *IFP* CALL WITH *UJN ORT1* 
          ORG    *-1
          LOC    ORTA 
          UJN    ORT1        CALCULATE ORT ENTRY ADDRESS
          LOC    *O 
          STM    ORTA 
 IFP$     ENDIF 
 ORT$     ENDIF 
 IFP$     IF     -DEF,IFP$
          LDD    T0          RESTORE (A) = ORDINAL
 IFP$     ENDIF 
          UJP    IFPX        RETURN 
  
 IFP$     IF     DEF,IFP$ 
 QUAL$    IF     -DEF,QUAL$ 
          QUAL   *
 IFP      EQU    /COMPGFP/IFP 
 QUAL$    ENDIF 
 IFP      RMT 
 IFP$     ENDIF 
          SPACE  4,10 
 QUAL$    IF     -DEF,QUAL$ 
          QUAL   *
 BLI$     IF     DEF,BLI$ 
 .BLI     EQU    /COMPGFP/.BLI
 BLI$     ENDIF 
 CLT$     IF     DEF,CLT$ 
 .CLT     EQU    /COMPGFP/.CLT
 CLT$     ENDIF 
 EJT$     IF     DEF,EJT$ 
 .EJT     EQU    /COMPGFP/.EJT
 EJT$     ENDIF 
 EST$     IF     DEF,EST$ 
 .EST     EQU    /COMPGFP/.EST
 EST$     ENDIF 
 FNT$     IF     DEF,FNT$ 
 .FNT     EQU    /COMPGFP/.FNT
 FNT$     ENDIF 
 JCB$     IF     DEF,JCB$ 
 .JCB     EQU    /COMPGFP/.JCB
 JCB$     ENDIF 
 QFT$     IF     DEF,QFT$ 
 .QFT     EQU    /COMPGFP/.QFT
 QFT$     ENDIF 
 ORT$     IF     DEF,ORT$ 
 .ORT     EQU    /COMPGFP/.ORT
 ORT$     ENDIF 
 QUAL$    ENDIF 
          ENDX
