*DECK     CCGTEXT 
          IDENT  CCGTEXT
          TITLE  CCGTEXT - COMMON CODE GENERATOR ASSEMBLY TEXT
          STEXT 
          SST 
          LIST   F,X
          COMMENT  COMMON CODE GENERATOR ASSEMBLY TEXT
          SPACE  3
***       CCGTEXT - COMMON CODE GENERATOR ( CCG ) ASSEMBLY TEXT 
* 
*         THIS TEXT CONTAINS SYMBOL, MACRO AND MICRO DEFINITIONS
*         NECESSARY TO ASSEMBLE CCG.
* 
*         NOTE THAT A DIFFERENT VERSION OF *CCGTEXT* EXISTS FOR EACH
*         HOST COMPILER SINCE IT CONTAINS SYMBOLS DEFINITIONS THAT
*         ARE HOST DEPENDENT. 
* 
*         THE TEXT IS DIVIDED UP INTO THE FOLLOWING SECTIONS -
*          INSTALLATION DEPENDENT INSTALLATION PARAMETERS.
*         STRUCTURED FILED DEFINITION MACROS
*          I/O CODING CONVENTIONS AND MACROS
*          GENERAL MACROS 
*          MACROS FOR DEBUGGING 
*         CCG FIELD DEFINITIONS, EQU"S AND MACROS.
*CALL     OPTIONS 
*CALL     COMADEF 
*CALL     FA=DEFS 
*CALL     CCOMGCM 
 COUNTS  TITLE     GENERAL MACROS 
**        COUNTS - COUNT NUMBER OF NAMES IN A MICRO STRING
* 
* LEN     COUNTS MICNAME
*                WHERE MICNAME IS A LIST OF NAMES SEPERATED BY COMMAS.
  
          MACRO  COUNTS,LEN,MICNAM
 .1       SET    0
          IFC    NE,/"MICNAM"//,2 
          ECHO   1,Z=("MICNAM") 
 .1       SET    .1+1 
 LEN      EQU    .1 
          ENDM
 MXX+X    SPACE  4,28 
**        MXX+X  - SELECT GREATER (MAXIMUM FUNCTION) OF TWO INTEGERS. 
* 
*         THIS OPDEF COMPARES TWO INTEGERS IN *XJ* AND *XK*, AND PLACES 
*         THE ALGEBRAICALLY GREATER VALUE IN *XI*.
* 
*         MXI    XJ+XK
* 
*         ENTRY  *XI* = RESULT X-REG, CANNOT BE *XJ* OR *XK*
*                *XJ*,*XK* = X-REGS CONTAINING INTEGERS TO BE COMPARED
* 
*         EXIT   (X.LARGER) = 0 
*                (X.SMALLER) = UNCHANGED
*         IF ON ENTRY (XJ)=(XK),
*            THEN ON EXIT (XJ)=0 AND (XK)=UNCHANGED 
*                (XI) = MAX(XJ,XK)
* 
*         USES   XI, XJ, XK 
  
          PURGDEF   MXX+X 
  
 MXX+X    OPDEF  I,J,K
  IX.I X.J-X.K
  AX.I -1 
  BX.J -X.I*X.J 
  BX.K X.I*X.K
  IX.I X.J+X.K
 MXX+X    ENDM
 MXX-X    SPACE  3
**        MXX-X - SELECT MINIMUM OF TWO INTEGERS
* 
*         MXI    XJ-XK
*         ENTRY AND EXIT CONDITIONS SAME AS FOR MAX, EXCEPT THAT
*         XI = MIN(XJ,XK) 
  
          PURGDEF   MXX-X 
  
 MXX-X    OPDEF  I,J,K
  IX.I X.J-X.K
  AX.I  -1
  BX.J X.I*X.J
  BX.K -X.I*X.K 
  IX.I X.J+X.K
 MXX-X    ENDM
 BIT      SPACE  4,8
**        BIT - SET SYMBOL TO 2**N. 
* 
*  SYM    BIT       PWR 
* 
*         ENTRY  [SYM] = SYMBOL TO BE SET 
*                [PWR] = DESIRED POWER OF 2 
* 
*         EXIT   [SYM] = 2**[PWR] 
  
          PURGMAC   BIT 
  
          MACRO  BIT,SYM,PWR
 P        DECMIC PWR
 SYM      SET    1S"P"
 BIT      ENDM
 CALL     SPACE  4,8
**        CALL - CALL A ROUTINE.
* 
*         GENERATES--    RJ  =X*ROUTINE*. 
* 
* 
*         CALL      ROUTINE 
* 
*         ENTRY  *ROUTINE* = NAME OF CALLED ROUTINE 
* 
*         USES   NONE 
  
  
          PURGMAC   CALL
  
 CALL     MACRO  R
  RJ =X_R 
  ENDM
 ENTRY.   SPACE  4,8
**        ENTRY. - DEFINE ENTRY POINT AND ITS CONTENTS. 
* 
*         REGISTER SNAPS MAY BE OBTAINED AT ENTRY POINTS DEFINED WITH 
*         THIS MACRO BY USING THE -REGSNAP- DEBUGGING MACRO.
* 
* 
* NAME    ENTRY. VALUE,C
* 
*                *NAME*  = ENTRY POINT NAME 
* 
*                *VALUE* = * OR ** OR ANY OTHER LEGAL COMPASS EXPRESSION
* 
*                *C* - ENTRY NAME SUFFIX CHARACTER
* 
*                          *     (FOR LOCAL SUBROUTINES)    EXPANDS TO--
*                                 NAME  EQ     *+1S17 
* 
*                          **    (FOR GLOBAL SUBROUTINES)   EXPANDS TO--
*                                       ENTRY  NAME 
*                                 NAME  EQ     *+1S17 
* 
*                          ELSE  (FOR GLOBAL STORAGE LOCN)  EXPANDS TO--
*                                       ENTRY  NAME 
*                                 NAME  CON    VALUE
* 
*         CALLS  NONE 
* 
*         USES   NONE 
  
  
          PURGMAC   ENTRY.
  
          MACRO  ENTRY.,NAME,VALUE,C
  IFC NE,^VALUE^*^,3
  ENTRY NAME_C
 NAME_C BSS 0 
  IFC EQ,^VALUE^**^,2 
NAME EQ *+1S17
  SKIP 1
NAME CON VALUE
*                            REGISTER SNAP FACILITY.
  IF DEF,)NAME,1
 NAME REG 
  
ENTRY. ENDM 
          SPACE  3
**        EQENT - EQUATE SYMBOL, DECLARE ENTRY POINT. 
* 
*SYM      EQENT  LAB
* 
*         ENTRY - "SYM" = SYMBOL TO BE MADE AN ENTRY POINT
*                "LAB" = VALUE OF ENTRY POINT 
* 
*         GENERATES - 
*         ENTRY  SYM
*SYM      EQU    LAB
* 
*         CALLS  NONE 
  
          PURGMAC EQENT 
  
          MACRO  EQENT,SYM,LAB
          ENTRY  SYM
 SYM      EQU    LAB
 EQENT    ENDM
 MOVE     SPACE  4,8
**        MOVE - MOVE DATA BLOCK. 
* 
* 
*         MOVE      COUNT,FROM,TO 
* 
*         ENTRY  *COUNT* = WORD COUNT OF BLOCK TO BE MOVED
*                *FROM*  = ADDRESS OF FIRST WORD OF BLOCK 
*                *TO*    = ADDRESS OF FIRST WORD OF DESTINATION 
* 
*         USES   X - 1, 2, 3
*                A - NONE 
*                B - 1
* 
*         CALLS  MVE= (COMCMVE) 
  
          PURGMAC  MOVE 
  
  
 MOVE     MACRO  C,F,T
          R=     X1,C 
          R=     X2,F 
          R=     X3,T 
          IF     -DEF,B1=1,1
          SB1    1
          RJ     =XMVE= 
 MOVE     ENDM
 PLUG     SPACE  4,40 
**        PLUG - MODIFY COMPILER CODE DURING EXECUTION. 
* 
*         SELF-MODIFYING (PLUGGING) CODE MAY SEEMINGLY FAIL ON CYBER
*         74 / 6600 AND LARGER MODELS, DUE TO THE HARDWARE INSTRUCTION
*         STACK AND 1- OR 2-WORD INSTRUCTION LOOKAHEAD.  BECAUSE OF THIS
*         PROBLEM, AND THE UNREADABILITY OF PLUGGED CODE, THE TECHNIQUE 
*         IS NOT DESIRABLE FOR WIDE USAGE.  EFFICIENCY CONSIDERATIONS 
*         ARE OCCASIONALLY MORE IMPORTANT, HOWEVER, SO WE FORMALIZE 
*         PLUGGING WITH THE FOLLOWING MACRO.  IT INCLUDES A SAFEGUARD 
*         AGAINST THE STACK/LOOKAHEAD PROBLEM, AND IS PREFERABLE TO 
*         DIRECT CODE FOR READABILITY AND DEBUGGING EASE. 
* 
*         TWO FORMS OF *PLUG* ARE AVAILABLE ... 
* 
* 
*         FORM 1 - PLUGS A CALLER-PROVIDED WORD OF CODE.
* 
*         PLUG      AT=,FROM=,FREG=,SREG=,VOID= 
* 
* 
*         FORM 2 - FABRICATES AND PLUGS AN -EQ- JUMP. 
*         RESTRICTION - THE 1-REGISTER METHOD USED FOR FORMING THE -EQ- 
*         JUMP IS NOT VALID IF *TO* IS .GT. 177777B ABSOLUTE.  THIS IS
*         NOT A PROBLEM IN PL/I, SINCE ALL ADDRESSES ARE .LT. 100000B.
* 
*         PLUG      AT=,TO=,SREG=,VOID= 
* 
* 
*         ENTRY  *AT*   = ADDRESS WHERE PLUG TO BE STORED.
*                *FREG* = (FORM 1 ONLY) (OPTIONAL)  NUMBER OF A,X REG 
*                         TO USE FOR FETCHING CODE WORD.  MUST BE 1-5.
*                         USES A1 AND X1 IF OMITTED.  IGNORED IF *FROM* 
*                         SPECIFIES AN X-REGISTER.
*                *FROM* = (FORM 1 ONLY)  SOURCE OF CODE WORD TO PLUG. 
*                         MAY BE AN X-REGISTER CONTAINING THE CODE WORD 
*                         ( E.G., FROM=X3 ), OR AN ADDRESS EXPRESSION.
*                *SREG* = (OPTIONAL)  NUMBER OF A,X REG TO USE FOR
*                         STORING PLUG.  MUST BE 6 OR 7.  USES X6 AND A6
*                         IF OMITTED. 
*                *TO*   = (FORM 2 ONLY)  -EQ- JUMP ADDRESS. 
*                *VOID* = (OPTIONAL)
*                         *NO* = DO NOT GENERATE STACK-VOIDING CODE.
*                         ELSE OR OMITTED = GENERATE VOIDING CODE IF
*                            "MODEL" IS CYBER 74 / 6600 OR LARGER.
* 
*         CALLS  NONE 
* 
*         USES   AS ABOVE 
  
  
          PURGMAC   PLUG
  
 PLUG     MACROE AT,TO,FROM,FREG,SREG,VOID
          LOCAL  FN,SN
 SN       SET    SREG  6
          IFLT   SN,6,1 
          ERR    *PLUG* STORE REG MUST BE 6 OR 7 AT ["SEQUENCE"]. 
 .F1      IFC    EQ, TO 
 .F1A     IF     REG,FROM 
*                            FORM 1A - CODE WORD IN AN X-REGISTER.
 SN       OCTMIC SN,1 
 SN       MICRO  1,, X"SN"
          IFC    NE, FROM "SN" ,1 
          BX.SN  FROM 
 .F1A     ELSE
*                            FORM 1B - FETCH CODE WORD FROM *FROM*. 
 FN       SET    FREG  1
          IFGE   FN,1,2 
          IFLE   FN,5,1 
          SKIP   1
          ERR    FETCH REG NOT 1-5 "SEQUENCE" 
          SA.FN  FROM 
          BX.SN  X.FN 
 .F1A     ENDIF 
 .F1      ELSE
*                            FORM 2 - FABRICATE -EQ- JUMP TO *TO*.
          SX.SN  TO 
          LX.SN  2+30D
*                            2000BS48+*JPADR*S32
          PX.SN  X.SN,B0
*                            0400BS48+*JPADR*S30
          LX.SN  -2 
 .F1      ENDIF 
*                            STORE THE PLUG.
          SA.SN  AT 
*                            GENERATE STACK-VOIDING CODE. 
          IFC    NE, VOID NO ,4 
          IFGE   CT.CPU,74,3  COMPILE TIME CPU
          RJ     *+1
          EQ     *+1S17 
          BSS    0
 PLUG     ENDM
 ROUTINE  SPACE  4,8
**        ROUTINE - DEFINE LOCAL SUBROUTINE ENTRY POINT.
* 
* 
* NAME    ROUTINE 
* 
*         ENTRY  *NAME* = NAME OF SUBROUTINE. 
  
  
          PURGMAC   ROUTINE 
  
          MACRO  ROUTINE,NAME 
 NAME     JP     *+1S17 
          NOREF  )NAME
          IF     DEF,)NAME,1
          PRINT  NAME,(* ENTERED*)
 ROUTINE  ENDM
 SETCORE  SPACE  4,8
**        SETCORE - SET BLOCK OF MEMORY TO A GIVEN VALUE. 
* 
*         SETCORE   FWA,LEN 
* 
*         ENTRY  *FWA* = BLOCK ADDRESS
*                *LEN* = BLOCK LENGTH 
*                (X6)  = VALUE TO SET 
* 
*         USES   X1, A6 
* 
*         CALLS  ISC=  ( CCOMISC )
  
  
          PURGMAC   SETCORE 
  
 SETCORE  MACRO  F,L
          SA6    F
 .1       IF     DEF,L
 .1       IF     ABS,L
 .1       IF     -REG,L 
 .1       IFLT   L,60 
 .2       IFNE   L,1
          MX1    L-1
          IF     -DEF,B1=1,1
          SB1    1
+         LX1    1
          SA6    A6+B1
          MI     X1,* 
 .1       ELSE
          R=     X1,L 
          RJ     =XISC= 
 .2       ENDIF 
 .1       ENDIF 
 SETCORE  ENDM
 SETCORE  ENDM
 SETZERO  SPACE  2
**        SETZERO - SET A BLOCK OF MEMORY TO ZERO 
* 
*         SETZERO  FWA,LEN
* 
*         USES   X1, X6, A6 OR CALLS ISC= 
  
 SETZERO  MACRO  F,L
          MX6    0
          SETCORE F,L 
 SETZERO  ENDM
*CALL     CCGDBGM 
*CALL     DBG=MAC 
*CALL     CCGILFD 
 BIT      EJECT 
**        BI. - DEFINE FIRST WORD OF A 2 WORD ENTRY IN *BIT*
  
          DESCRIBE BI.,60 
 RB       DEFINE 1           REACHABLE BLOCK ( SET FOR PROG BLOCKS ONLY 
 CB       DEFINE 1           CODED ( NOW IN *MCG/SII* FORMAT )
 IL       DEFINE 1           INITIAL LABEL
 FJ       DEFINE 1           FINAL *UJP*
 LJP      DEFINE 1           BLOCKS CONSISTS OF A *LAB/UJP* ONLY
 HN       DEFINE 1           =1 IF HEADER NODE OF A INTERVAL & *SCR*
 FTH      DEFINE 1           =1 IF A *HB* THAT IS FROM A *FTH* LOOP 
 OLN      DEFINE 15          FOR HB ONLY, BN OF HB CONTAINING OUTER LOOP
 PC       DEFINE 2           PARCEL COUNT 
 FLN      DEFINE 18          FIRST LINE NUMBER ( PROG BLOCKS ONLY ) 
 BVI      DEFINE 18          *BVT* INDEX TO BIT VECTORS 
  
 PII      DEQU   PC,17       INDEX TO *PSI* POST STORE INFO ( "0 )
 PBN      DEQU   FLN         PROG BLOCK INDEX OF HOLDING BLOCK
*                            *BIT* INDEX OF HEADER NODE OF LOOP THAT IT 
*                            IS THE HOLDING BLOCK OF
 MLT      SPACE  3,14 
**        ML. - MOD LIST TABLE ENTRY FORMAT 
* 
*         *MLT* IS THE *MOD* LIST INDEX TABLE.  *MOD* CONSISTS OF RLIST 
*         INSTRUCTIONS ( 4 WORDS/INSTRUCTION ), AND THE FIRST ENTRY IS
*         A DUMMY *BOS*.
*         OPERANDS OF INSTRUCTIONS IN *MOD* WHICH REFERENCE INSTRUCTIONS
*         IN *SEQ* HAVE BIT 15 OF THE R-NUMBER SET ( R+100000B ) .
* 
*         FOR FURTHER INFORMATION ONE MAY LOOK AT *MPB* IN *GPO*. 
  
          DESCRIBE ML.,60    MCW(DEL,II,NI,MTI) 
 DEL      DEFINE 1           DELETE FLAG
          DEFINE 5
 II       DEFINE 18          INSERT INDEX ( IN *SEQ* )
 NI       DEFINE 18          N. INSTRUCTIONS TO BE INSERTED 
 MTI      DEFINE 18          *MOD* TABLE INDEX
 TET      SPACE  3,14 
**        T. - TEMP EQUIVALENCE TABLE FORMAT
  
          DESCRIBE T.,60     TETW(FLAGS,ITI,BI,CA)
 INV      DEFINE 1           =1 IF *INV* TEMP 
 EQV      DEFINE 1           EQV TO ANOTHER *TET* 
 FA       DEFINE 1           FINAL ASSIGNMENT OF *CA* ( *POST* )
 CAL      DEFINE 1           CA FIELD LOCKED
 RF       DEFINE 1           =1 IF SUBSCRIPT USE IN DEFINING LOOP 
 BIP      DEFINE 1           BASE MEMBER OF *IP* CLASS
 ITI      DEFINE 18          INDEX TO INC FORMULA INFO IN *IIT* ( ^INV )
 BI       DEFINE 18          INDEX IN BLOCK WHERE *LD* GOES 
 CA       DEFINE 18          BIAS OF TST* ( SET IN SQZ * )
  
 HBN      DEQU   ITI         BN OF HB (LOOP) THAT IT. IS ASSOC WITH 
 REG      DEQU   BI          REGISTER THAT IT IS IN ( *MTA* ) 
 IPF      DEQU   ITI,19      *IP* FIELDS
 LC.      SPACE  3,12 
**        LC. - LABEL CHANGE TABLE FOR MULTI PREDECESSOR LOOPS
  
          DESCRIBE LC.
          DEFINE 6
 NEXT     DEFINE 18          LINK TO NEXT ON CHAIN, 0 IF NONE 
 GLN      DEFINE 18          H FIELD OF GL VALUE OF LABEL 
 HBN      DEFINE 18          BN OF HB THAT LABEL IS DEFINED IN
 WRITEP   SPACE  3,14 
**        WRITEP - WRITE PSEUDO OP WORD TO *SLIST* FILE 
* 
*         ENTRY  (X6) = LOW 48 BITS OF PSEUDO OP WORD 
* 
*         WRITEP OPNAME 
  
 WRITEP   MACRO  OPCD 
          R=     B3,OC.OPCD 
          RJ     =XWPW# 
          ENDM
 HC.      TITLE  HOST DEFINED SYMBOLS AND MICROS
*         GET *HCDEFS* AND *SYMDEFS* FROM THE HOST OLDPL. 
  
          QUAL   HOST 
*CALL     HCDEFS
          QUAL
  
 HC$MCIS  EQU    /HOST/HC$MCIS
  
*         HC= - MACRO TO EQUATE HC$ SYMBOLS TO HC. SYMBOLS WHICH CCG
*         REFERENCES. 
  
 HC=      MACRO  A
          IF     DEF,/HOST/HC$A,2 
 HC.A     EQU    /HOST/HC$A 
          SKIP   4
          IF     -MIC,HC$A,2
          ERR    HC$A NOT DEFINED BY THE HOST 
          SKIP   1
 HC.A     MICRO  1,,^"HC$A"^
          ENDM
  
          HC=    FLB
          HC=    NXLB 
          HC=    FPAS 
          HC=    FRTP 
          HC=    IA 
          HC=    ID 
          HC=    LNT
          HC=    MCIS 
          HC=    RJXJ 
          HC=    RJTBN
          HC=    RJ6
          HC=    ROL
          HC=    STP
          HC=    UDVB 
  
          HC=    2OC
  
          ECHO   2,Z=(MDL,MODLVL,LPNAME,LPN,VER)
          IF     MIC,Z$,1 
 Z        MICRO  1,,^"Z$"^
*         GET SYMDEFS 
  
*CALL     SYMDEFS 
 CCG.TM   EJECT 
**        MISCELLANEOUS CCG MACROS
  
**        CCG.SST - MAKE SST CALL FOR *CCG* 
  
 CCG.SST  MACRO 
          SST 
          B1=1
          ENDM
 SETB1    SPACE  3,14 
**        SETB1 - SET B1 = 1 IN A HOST CALLABLE ENTRY POINT 
  
 SETB1    MACRO 
          IFNE   HC.ID,2,1
          SB1    1
          ENDM
 ADDWRD   SPACE  3
**        ADDWRD - ADD WORD TO MANAGED TABLE. 
* 
*         ADDWRD TABLE,REG
*         ENTRY  *TABLE* = TABLE NUMBER.
*                *REG* = REGISTER NAME OR EXPRESSION FOR WORD TO ADD. 
*         USES   A0, X1.
  
          PURGMAC ADDWRD
 ADDWRD   MACRO  A,B
          R=     X1,B 
          R=     A0,=XZ$A 
          RJ     =XADW$ 
 ADDWRD   ENDM
 ALLOC    SPACE  3,14 
**        ALLOC - ALLOCATE TABLE SPACE. 
* 
*         ALLOC  TABLE,WORDS
*         ENTRY  *TABLE* = TABLE NUMBER.
*                *WORDS* = WORD COUNT OF TABLE. 
  
          PURGMAC ALLOC 
 ALLOC    MACRO  A,B
          R=     X1,B 
          R=     A0,=XZ$A 
          RJ     =XATS$ 
 ALLOC    ENDM
 PROCESS  SPACE  3,14 
**        PROCESS - DEFINE PROCESSOR ADDRESSES FOR LIST OF NAMES
* 
*         PROCESS (A,B,C,...,Z) 
  
          PURGMAC PROCESS 
 PROCESS  MACRO  P
          IRP    P
          NOREF  .P 
 .P       BSS    0
          IRP 
 PROCESS  ENDM
 EXT#     SPACE  3,14 
**        EXT# - DECLARE NAMES OF EXTERNALS WITH # SIGNS APPENDED 
* 
*         EXT#   (A,B,...,Z)
  
 EXT#     MACRO  P
          IRP    P
          EXT    P_#
 P        EQU    P_#
          IRP 
          ENDM
 TABLES   SPACE  3,14 
**        TABLES - DECLARE NAMES OF DYNAMIC TABLES REFERENCED IN A ROUTI
* 
*         TABLES (TBL1,TBL2,...,TBLN) 
  
 TABLES   MACRO  P
          IRP    P
          EXT    O$P,L$P
 O.P      EQU    O$P
 L.P      EQU    L$P
          IRP 
          EXT    F$RDT,S$IT,O$SYM 
 O.SYM    EQU    O$SYM
 F.RDT    EQU    F$RDT
 IT.      EQU    S$IT 
 TABLES   ENDM
  
 .Z       SET    1S15 
          ECHO   2,P=("HC.FRTP",SS) 
 I.P      EQU    .Z 
 .Z       SET    .Z+1S15
  
 HC.NFLB  COUNTS HC.FLB 
 WB.CXP   = WB.EXTP 
 WB.CXL   = 2 
 EQU-S    SPACE  3,14 
*         DEFINITIONS OF SYMBOLS THAT DO NOT CHANGE 
  
 WA.LCOP  EQU    0           LABEL CHANGE ORDINAL FIELD 
 WA.LCOL  EQU    12 
 WA.BINP  EQU    0           BITS IN NAME 
 WA.BINL  EQU    12 
  
 HC.TS    EQU    0
 HC.QBT   EQU    0
  
          END 
