*DECK     UDT 
          IDENT  UDT
 UDT      TITLE  UDT - USE/DEF TABLE PROCESSING 
*CALL     SSTCALL 
 B=UDT    RPVDEF
 UDT      SPACE  2
**        UDT - USE/DEF TABLE INITIALIZATION
* 
*         MISCELLANEOUS ROUTINES FOR THE PREPROCESSING PHASE OF OPT=2 . 
 UDT      SPACE  2
          LIST   -R 
  
          TABLES (BST,IOL,LBT,RND,RXI,TXT,UDI)
  
          ECHO   4,A=(BIT,BVT),B=(BST,RXI)
          EXT    Z$B
 Z$A      EQU    Z$B
 O.A      EQU    O.B
 L.A      EQU    L.B
          SPACE  2
          EXT    F.MEM
 O.UDB    EQU    F.MEM
  
          USE    /BVINFO/ 
 VL       BSS    1           BIT VECTOR LENGTH
 N.VAR    BSS    1           N.VARIABLES IN *UDT* 
 BVL      BSS    1           VL - 1 
 RCV      BSS    1           =1 IF REFERENCED COMMON VARIABLES
          USE    0
  
*         BLOCK HEADER TRAILER WORD DEFINTIONS
  
 BH.LENP  EQU    0
 BH.BIP   EQU    36 
 BT.LENP  EQU    0
  
*CALL     CFTBLD
  
          LIST   X
  
*CALL     UDTBLD
          LIST   R
 CG$INIT  TITLE  CG$INIT - INITIALIZE *CCG* 
**        CG$INIT - INITIALIZE *CCG* PROCESSING 
* 
*         ENTRY  HOST COMPILER STATIC TABLES INITIALIZED IN HIGH CORE 
*                (X1) = *LBT* ORDINAL OF BLOCK THAT *SLIST* IS IN.
  
 CG$INIT  ENTRY. ** 
 .T       IFNE   TEST,0 
          SX7    =XCG$PTC 
          SA7    =XHO$RDR    HO$RDR = LOCF(CG$PTC)
 .T       ENDIF 
 .LCM     IFNE   .DAL,0 
          SA2    =XHO$LCM 
          PL     X2,INIT0    IF NOT LCM=G 
          SX6    B1 
          LX6    D.L2P+59-D.STP                                         001190
          SA6    =XLCM#G           */  SET FLAG FOR *SQZ* 
 INIT0    BSS    0
 .LCM     ENDIF 
  
*         INITIALIZE TABLE MANAGER, ALLOCATE SPACE FOR *TXT*
  
          SA2    =XHO$OPT 
          MI     X2,INIT0A   IF OPT = 2 
          SX6    7
          SA6    =XATSNAT#   NUMBER OF OPT1 *ACTIVE* TABLES 
          SX6    0
          SA6    =XATSTOG#   DONT TOGGLE
          SX6    1000B
          SA6    =XTHRESH#   TABLE MANAGER SLOP 
  
 INIT0A   BSS    0
          IFNE   HC.2OC,0,2 
          SX6    O.UDB
          SA6    =XLM#       LM = O.UDB 
          BX0    X1 
          CALL   CWS# 
          AX6    2
          ALLOC  TXT,X6      ALLOC( TXT , CWS/4 ) 
          SX6    4
          SA6    A3          L.TXT = 4
          SA1    =XHO$OPT 
  
*         INITIALIZE FLAGS FOR BLOCK PROCESSING 
  
          BX6    X0 
          SA4    =XF$LBT+X0  GET INITIAL LENGTH OF BLOCK
          SX7    X4 
          SA6    =XCC$LBO    CC$LBO = PARAM 
          SA7    =XCC$BLEN
          AX4    18 
          SX6    X4 
          SA6    =XCC$PC
  
          PL     X1,INIT2    IF HO$OPT " 2
  
*         INITIALIZE TABLES FOR OPT=2 
*         ALLOCATE AND CLEAR A BASE TABLE FOR *UDI* 
  
          SA1    =XCC$FT
          NZ     X1,INIT1    IF CC$FT " 0  */ NOT FIRST TIME
          SX6    B1 
          SA6    A1          CC$FT = 1
          CLOSE  =XF.OPT,UNLOAD,RCL  ENSURE NO FILE FROM PREV. STEP     001210
  
*         REQUEST ECS FL FOR OPT=2. 
  
 #ECS     IFNE   CT.ECS,0 
  
 #OS      IFEQ   .OS,2       IF SCOPE 2 
          MEMORY LCM,INITA,R
          SA1    INITA
          BX6    X1 
          AX1    30 
          LX6    59-1        1S59 IF LCM REDUCE MODE
          PL     X6,INIT05   IF FIXED ECS FL MODE 
          SX7    30000B 
 #OS      ELSE
          MEMORY LCM,INITB,R
          SA1    INITB
          SA2    =XMAX.LCM
          AX1    30          MAX OBTAINABLE LCM 
          BX0    X1 
          MX6    X0-X2
 .FTN     IFEQ   HC.ID,2     IF FTN HOST                                        F1037CC 11
          SA1    =XCO.EC                                                        F1037CC 12
          AX1    59                                                             F1037CC 13
          BX6    X1*X6       ALLOW ECS USE IFF EC ON                            F1037CC 14
 .FTN     ENDIF                                                                 F1037CC 15
          SA6    A2          MAX.LCM = MIN(MAX OBT.,200000B)
          MEMORY LCM,INITA,R
          SA1    INITA
          AX1    30          CURRENT LCM
          SA2    MAX.LCM
          SX6    30000B 
          MX7    X2-X6       REQUEST MIN(MAX.LCM,30000B)
  
 #OS      ENDIF 
          IX3    X1-X7
          LX7    30 
          PL     X3,INIT05   IF WE ALREADY HAVE 30K ECS 
          SA7    INITA
          MEMORY LCM,INITA,R,,NOABT      REQUEST 30K
          SA1    INITA
          AX1    30 
  
 INIT05   BX7    X1 
          SA7    =XCP.AFLL
 #ECS     ENDIF 
  
 INIT1    CALL   IMPA#       INITIALIZE MASS I/O PROCESSING 
          SA5    =XLM#
          SX1    =XHO$OBL+101B     S = 101B + HO$OBL
          ALLOC  TXT,X1      ALLOC( TXT , S ) 
          IX6    X1+X5
          SA6    A5          LM = LM + S
          SX7    4
          SA6    A2          O.TXT = LM 
          SA7    A3          L.TXT = 4
          SETZERO X5,100B    SETZERO( UDB , 100B )
          ALLOC UDI,2        ALLOC( UDI , 2 ) 
  
          ALLOC  BST,4       ALLOC( BST , 4 ) 
          SX1    B1 
          SX2    B1+B1
          LX1    CF.FROMP 
          LX2    CF.TOP 
          BX1    X1+X2
          ADDWRD CFT,X1      ADDWRD CFT , (1,2) ) 
          MX6    0
          SA6    =XCC$OPF    CC$OPF = 0 
  
*         SETUP *BOS*"S AT THE BEGINNING OF *TXT* AND *MOD* 
  
 SBOS     MACRO 
          SA4    F.RDT+OC.BOS 
          R=     B2,OC.BOS
          MX7    0
          PX6    B2,X7
          SA6    X2 
          SA7    X2+B1
          BX6    X4 
          SA6    A7+B1
          SA7    A6+B1
          ENDM
  
 INIT2    SA2    =XO.TXT
          SBOS
          ALLOC  MOD,4       ALLOC( MOD , 4 ) 
          SBOS
          EQ     CG$INIT
  
 INITA    BSSZ   1
 INITB    VFD    30/-1,30/0 
 AUT      TITLE  AUT - ADJUST USE/DEF INDEX TABLE 
**        AUT - ADJUST USE/DEF INEX TABLE TO BRING TO WORKING FORM
*         SORT TABLE BY [IH,CR] TO CHAIN CLASS"S AND EXPAND TO 2 WDS/ENTRY
  
*         I. - TEMP SORT TABLE FORMAT 
  
          DESCRIBE I.,60
          DEFINE 12 
 IH       DEFINE 18 
          DEFINE 11 
 CR       DEFINE 1
 UI       DEFINE 18 
  
 AUT      ENTRY. **,# 
          SA5    L.UDI
          SX7    X5-2 
          NZ     X7,AUT0     IF L.UDI " 2  */ TABLE NON-EMPTY 
          ADDWRD UDI,1       ADDWRD( UDI , 1 )  */ DUMMY ENTRY
 AUT0     BSS    0
 .T       IFNE   TEST,0 
          SA1    =XHO$SNAP
          LX1    1R2
          PL     X1,AUTT     IF SNAP=2 NOT SELECTED 
          DCALL  DMPUDI,([O.UDI],L.UDI)    PRINT SYMBOL DICTIONARY
 AUTT     BSS    0
 .T       ENDIF 
          SA5    L.UDI
          BX6    X5 
          LX5    1
          SA6    N.VAR       N.VAR = L.UDI
          ALLOC  UDI,X5+3    ALLOC( UDI , 2*N.VAR + 3 ) 
          SB2    B6-2        N = OLD(L.UDI-2) 
          BX6    X5 
          SA6    A3          L.UDI = 2*N.VAR  */ EXTRA SPACE FOR SORT ONLY
          SB3    X2+B1
          SB7    B3+X5       T0 = O.UDI+1 + 2*N.VAR 
          SX0    B1 
          MX7    0
          SA5    X2+2        UI = O.UDI + 2 
          LX0    UA.CRP 
          SB4    B1+B1
          SA7    B7-B1       TI = T0 - 1;  [TI] = 0 
          SX4    B4+B4       I = 4
          SX1    B2+
  
*         FORM SORT TABLE SO AS TO GROUP BY *IH"S*
  
 AUT1     BX3    X0*X5
          LX5    -UA.IHP
          LX3    I.CRP-UA.CRP 
          SX2    X5 
          IX6    X3+X4       SW = ITF(IH,CR,I)
          LX2    I.IHP
          SA5    A5+B1       UI = UI + 1
          BX7    X2+X6
          SB2    B2-B1       N = N - 1
          SX4    X4+B4       I = I + 2
          SA7    A7+B1       TI = TI + 1;  [TI] = SW
          NZ     B2,AUT1     IF N " 0 
  
          SA0    A7          TL = TI
          CALL   SHL#        SORT( UDI , [IH,CR,I] )
 AUT      SPACE  3,14 
*         NOW SETUP FINAL FORM OF USE/DEF INDEX TABLE WHERE ALL 
*         CLASS MEMBERS POINT TO THEIR BASE MEMBER AND THE MEMBERS OF 
*         THE CLASS ARE CHAINED FROM THE BASE MEMBER TO THE CLASS.
  
          SA2    O.UDI
          SA3    O.SYM
          SX0    B1 
          SA1    AUTA 
          LX0    I.CRP
          SA5    A0          TI = TL
          SB2    X2 
          SB4    X3+1 
          SB6    I.IHP-1
          SX3    B1 
          LX3    WB.LOCFP 
  
 AUT2     ZR     X5,AUT4     IF [TI] = 0   */ END OF TABLE
          BX7    X0*X5       C = CR[TI] 
          SX6    X5          I = UI[TI] 
          AX5    B6,X5
          SB3    B4+X5       IHB = IH[TI] 
          LX7    UD.CRP-I.CRP 
          AX5    1
          SA2    B3+X5       WORDB = SYM(3*IHB+1) 
          BX5    X3*X2
          LX5    WB.COMP-WB.LOCFP 
          BX4    X1*X2
          BX4    X4+X5       COM = COM ! LOCF 
          LX4    UD.COMP-WB.COMP
          SA5    A5-B1       TI = TI - 1
          LX2    X7 
          BX7    X4+X7
          SA7    B2+X6       UDI(I) = UDIT(COM,C,0,0,0);  UL = UDI(I) 
          ZR     X2,AUT2     IF C = 0      */ NOT A CLASS REP 
  
*         CHAIN CLASS MEMBERS FROM BASE, AND POINT THEM TO THE BASE MEMBER
  
          LX2    UD.CMP-UD.CRP
          BX4    X2+X4
          LX6    UD.BMIP
          IX6    X4+X6
  
 AUT3     AX4    B6,X5
          SB7    X4+B4
          NE     B7,B3,AUT2  IF IH[TI] " IHB
          SX2    X5          J = UI[TI] 
          SA5    A5-B1       TI = TI - 1
          LX2    UD.ECLP
          BX7    X2+X7       ECL[UL] = J   */ LINK LAST TO THIS 
          SA7    A7 
          LX2    -UD.ECLP 
          BX7    X6 
          SA7    B2+X2       UDI(J) = UDIT(COM,0,I,0);  UL = UDI(J) 
          EQ     AUT3 
  
 AUTA     BFMW   WB,(FP,COM)
 AUT      SPACE  3,14 
*         FORM "SPOIL" BIT VECTOR FOR COMMON VARIABLES
  
 AUT4     SA5    N.VAR
          SX2    60 
          SX1    X5+57
          IX7    X1/X2       L = (N.VAR+57) / 60
          LX2    B1,X7
          SA7    VL          VL = L 
          SX6    X7-1 
          SA6    BVL         BVL = L - 1
          LX7    2
          IX1    X2+X7
          ALLOC  BVT,X1      ALLOC( BVT , 6*L ) 
  
          SA4    O.UDI
          SB2    X5-2        N = N.VAR - 2
          SB4    -B1
          SB6    B0          BITN = 0 
          SB7    60 
          MX7    0           WI = 0 
          PX7    B4,X7
          MX6    -UD.ISTP 
          SA6    X4          UDI(0) = (DEFR,DEF,^RD,IST)
          SA7    X4+B1       UDI(1) = PACK(-1,0) */ NO REP IN BIT VECT
          SA7    X4+3        UDI(3) = PACK(-1,0) */ FOR FIRST 2 ENTRIES 
          MX6    0           SV = 0 
          SA6    A7-B1       UDI(2) = 0 
          SX0    1
          SA5    A7+B1       UI = UDI(4)
          MX1    0           SVS = 0       */ SPOIL VECTOR SUM
          LX0    UD.COMP
          SB3    UD.COMP     J = 0
  
 AUT5     PX7    B6,X7
          BX4    X0*X5
          SA7    A5+B1       US = UI + 1;  [US] = PACK(BITN,WI) 
          SB2    B2-B1       N = N - 1
          AX3    B3,X4       SV = SV ! SHIFT(1,COM[UI]) 
          SB3    B3-B1       J = J - 1
          BX6    X3+X6
          SA5    A7+B1       UI = US + 1
          SB6    B6+B1       BITN = BITN + 1
          ZR     B2,AUT6     IF N = 0 
          LT     B6,B7,AUT5  IF BITN < 60 
          SB3    UD.COMP
  
 AUT6     SA6    X2          [BI] = SV
          BX1    X1+X6       SVS = SVS ! SV 
          SX2    X2+B1       BI = BI + 1
          SB6    B0          BITN = 0 
          MX6    0           SV = 0 
          SX7    X7+B1       WI = WI + 1
          NZ     B2,AUT5     IF N " 0 
  
          CX7    X1 
          SA7    RCV         RCV = COUNT(SVS)  */ REFED COMMON VARS FLAG
 AUT      SPACE  1,10 
*         FORM DEAD DEFINITION CANIDATE COMPLEMENT VECTOR 
*         ^DDC = CR ! CM .
  
          SA5    BVL
          SA1    AUTB 
          SB6    X5+B1       INDX = BVL + 1 
          SA0    X5+B1       L = BVL + 1
          RJ     FSV         FORM *DDC* VECTOR
  
*         FORM THE PROGRAM ENTRY/EXIT NODE BITS VECTORS FOR USE IN THE
*         LIVE EXIT BIT VECTOR COMPUTATION.  LET S = THE SET OF COMMON
*         VARIABLES ( LOCF VARS INCLUDED ) AND F.P.S .   I.E. THE SET 
*         OF VARIABLES WHICH ARE LIVE ON EXIT FROM THE SUBPROGRAM.
*         THEN DEF(0) = 0, AND UBD(0) = USE(0) = LX(0) = S .
  
          SA2    O.BIT
          SX6    B6 
          LX6    BI.BVIP
          SA6    X2          BVI[BIT(0)] = 2*L
          SA6    X2+2        BVI[BIT(2)] = 2*L
          MX7    0
          SB7    B7+A0
+         SA7    B5+B6       FOR I = 0 TO BVL; DEF(0) = 0 
          SB6    B6+B1
          LT     B6,B7,*
          SA1    AUTC 
          RJ     FSV         FORM EXIT BLOCK *USE* VECTOR 
  
*         SET LX = USE AND UBD = USE
  
          SB2    A0 
          SB6    B6-B2       I = 4*L;  UL = 5*L 
 AUT10    SA5    B5+B6       UVA = O.BVI + I;  VW = [UVA] 
          SB6    B6+B1       I = I + 1
          LX7    X5 
          SA7    A5+B2       UFA = UVA + L       [UFA] = VW 
          SA7    A7+B2       LXA = UFA + L       [LXA] = VW 
          LT     B6,B7,AUT10 IF I < UL
  
          SA2    =XN$FPS
          ZR     X2,AUT      IF N$FPS = 0   */ NO F.P. S
          SA1    AUTC 
          SX7    B1 
          SB6    B0          INDX = 0 
          SA7    RCV         RCV = 1
          RJ     FSV         INCLUDE F.P.S IN COMMON VAR SPOIL VECTOR 
  
          EQ     AUT
  
 AUTB     BFMW   UD,(CR,CM) 
 AUTC     BFMW   UD,(FP,COM)
 FSV      SPACE  3,24        FSV
**        FSV - FORM SPECIAL BIT VECTOR FROM *UDI*
* 
*         ENTRY  (X1) = FM , MASK FOR BITS IN SET.
*                (A0) = L = BVL+1 
*                (B6) = *BVT* STORE INDEX 
* 
*         EXIT   (B5) = [O.BVT] 
*                (B6) = INDX + L
  
 FSV      ROUTINE 
          SA2    N.VAR
          SA3    O.BVT
          SA4    O.UDI
          SB4    X2-2        N = N.VAR - 2
          SB5    X3 
          SB7    B6+A0       UL = INDX + L
          SA5    X4+4        UI = [O.UDI] + 4 
          SB2    B0          BITN = 0 
          SB3    60 
          SX0    B1 
          SX6    0           VW = 0 
  
 FSV1     BX7    X1*X5       B = FM[UI] 
          SA5    A5+2        UI = UI + 2
          SB4    B4-B1       N = N - 1
          ZR     X7,FSV2     IF B = 0      */ VAR NOT IN SET
          LX4    B2,X0
          BX6    X4+X6       VW = VW ! SHIFT( 1 , BITN )
 FSV2     SB2    B2+1        BITN = BITN + 1
          ZR     B4,FSV3     IF N = 0 
          LT     B2,B3,FSV1  IF BITN < 60 
          SB2    0           BITN = 0 
 FSV3     SA6    B5+B6       BVT(INDX) = VW 
          SB6    B6+1        INDX = INDX + 1
          MX6    0           VW = 0 
          LT     B6,B7,FSV1  IF INDX < UL 
  
          EQ     FSV
 CMR      TITLE  CMR - CHAIN MEMORY REFERENCES TO *UDI* 
**        CMR - CHAIN MEMORY REFS IN *TXT* TO *UDI* BY THE *IN* FIELD 
*         SETUP LINKS FROM INSTRUCTIONS TO *UDI* FOR LATER USE/DEF PROCESSING 
* 
*         AP AND IO LIST LD/ST"S ARE IGNORED
*         F.P. ADDRESS LOADS ARE CHAINED TO ENTRY 1 
  
 CMR0     SX6    B6+         L.UDI  = UI
          SA6    L.UDI
  
 CMR      ENTRY. **,# 
          SA1    L.TXT
          AX1    2
          ALLOC  UDI,X1      ALLOC( UDI , L.TXT/4 );  UI = OLD( L.UDI ) 
          SA5    O.TXT
          SB7    X2          UDI = O.UDI
          MX0    -D.LDSTL 
          SB2    B1+B1
          LX0    D.LDSTP
          SA4    X5+B2       DI = O.TXT + 2 
          MX1    -IH.CAIHL
          LX1    IH.CAIHP 
          SA2    O.SYM
          SB4    X2+1                      (B4) = SYM + 1 
  
*         SCAN *TXT* FOR MEMORY REFS AND CHAIN THEM TO *UDI*
  
 CMR1     SA5    A4+B2       R1 = DI + 2
          SA4    A5+B2       DI = R1 + 2
          UX7    B3,X5
          BX6    -X0*X4 
          ZR     B3,CMR0     IF OC[R1] = 0 */ END OF BLOCK
          ZR     X6,CMR1     IF LDST[DI] = 0  */ NOT A MEM REF
  
          SA3    A5+B1       R2 = R1 + 1
          BX7    -X1*X3      IHF = CAIH[R2] 
          MX2    -6 
          LX3    -IH.RFP
          LX7    -IH.IHP
          BX4    -X2*X7      HI = IHF & 77B  */ HASH INDEX
          SB3    X3          C0 = RF[R2]
          SX6    X7 
          AX6    IH.IP
          NZ     X6,CMR1     IF I[IH] " 0  */ REF TO GL/AP LIST 
  
          NZ     B3,CMR6     IF C0 " 0     */ INDEXED REF 
          SB5    B4+X7
          LX6    B1,X7
          SA2    B5+X6       WORDB = SYM(3*IH[R2W]+1) 
          SB5    B1          CL = 1 
          LX2    59-WB.LDOP 
          MI     X2,CMR5     IF LDO[WORDB] */ VAR IS LOAD ONLY
          LX2    WB.LDOP-WB.FPP 
          PL     X2,CMR2     IF ^FP[DI] 
          SA2    A2+B1       WORDC = WORDB + 1
          SX3    B1 
          IX6    X2+X3       RA[WORDC] = RA[WORDC] + 1  */ COUNT REFS 
          SA6    A2 
  
 CMR2     SA2    O.UDB+X4    CI = UDB(HI) 
          ZR     X2,CMR4     IF CI = 0     */ BASE TABLE ENTRY IS EMPTY 
  
*         SEARCH HASH CHAIN 
  
          SA7    B7          [UDI] = IHF   */ SEARCH TERMINATOR 
          SB3    X2          C0 = CI       */ INDEX TO LAST ON CHAIN
  
 CMR3     SA3    B7+X2       UDW = UDI(CI)
          SB5    X2          CL = CI
          BX6    X3-X7
          LX3    -UA.HLP
          SX2    X3          CI = HL[UDW] 
          BX4    -X1*X6 
          NZ     X4,CMR3     IF CAIH[UDW] " IHF 
  
          NZ     B5,CMR5     IF CL " 0     */ ENTRY IN TABLE
  
*         ADD  *CAIH* TO *UDI*
  
 CMR4     SX4    B3 
          SX6    B6          UL = UI
          LX4    UA.HLP 
          BX7    X4+X7
          SA7    B7+B6       UDI(UI) = UDIW(0,C0,IHF) 
          SB6    B6+B1       UI = UI + 1
          SB5    X6          CL = UL
          SA6    A2          UDB(HI) = UL  */ UPDATE BASE TABLE 
  
*         CHAIN ENTRY TO *UDI*
  
 CMR5     SX4    B5 
          LX4    R1.INP+1 
          BX6    X4+X5       IN[R1] = 2*CL
          SA6    A5 
          EQ     CMR1 
  
*         INDEXED MEMORY REF
  
 CMR6     SB5    B1          CL = 1 
          EQ     B3,B5,CMR5  IF RF[R2] = 1
          SA3    CMRA 
          SB3    B0          C0 = 0 
          BX7    X3+X7       CR[IHF] = 1;  CA[IHF] = -0 
          EQ     CMR2 
  
 CMRA     BFMW   UA,(CR,CA) 
 CG$CPL   TITLE  CG$CPL - CHAIN PARAMETER LIST ENTRIES TO *UDI* 
**        CG$CPL - CHAIN PARAMETER LIST ENTRIES TO *UDI*
* 
*         ENTRY  (X5) = INDEX , TABLE INDEX OF PARAMETER LIST 
*                (X6) = TBL , ADDRESS OF TABLE POINTER
*                (B2) = LEN , NUMBER OF ENTRIES IN TABLE
* 
*         EXIT   (X1) = INDX , TO LIST IN *IOL* 
*                (X0) = LEN , OF LIST IN *IOL*
*                (X7) = L.IOL 
*                (B5) = *UDI* INDEX OF LAST ENTRY IN ARG LIST 
  
 CG$CPL   ENTRY.
          LX5    18 
          PX4    B2,X5
          SX1    B2+B2
          BX5    X4+X6
          ALLOC  IOL,X1      ALLOC( IOL , 2*LEN ) 
          SX0    B6 
          ALLOC  UDI,X1      ALLOC( UDI , 2*LEN );  UI = OLD(L.UDI) 
          SB4    X2          UDI = O.UDI
          UX7    B2,X5       N = LEN
          SA2    O.IOL
          IX1    X2+X0       S0 = O.IOL + OLD(L.IOL)
          SA0    X1          SI = S0       */ STORE INDEX 
          SA4    X5 
          AX7    18 
          IX6    X4+X7
          MX0    -IH.CAIHL
          SA3    O.SYM
          SA5    X6+         TI = O.TBL + INDEX 
          SB7    X3+1                      (B7) = SYM + 1 
  
 CPL1     BX7    -X0*X5      IHF = CAIH[TI] 
          LX5    59-AP.CRP
          PL     X5,CPL2     IF ^CR[TI] 
          SA3    CMRA 
          LX5    1+AP.CRP 
          BX7    X3+X7       CR[IHF] = 1;  CA[IHF] = -0 
          EQ     CPL3 
  
 CPL2     LX5    AP.CRP-AP.P1P
          MI     X5,CPL4     IF P1[TI]     */ DOUBLE / COMPLEX
          LX5    1+AP.P1P 
  
 CPL3     RJ     SUI
          BX2    X2*X5
          SB2    B2-B1       N = N - 1
          BX6    X2+X6
          SA5    A5+B1       TI = TI + 1
          SA6    A0          [SI] = (IO,USE)[TI] ! SUI( IHF ) 
          SA0    A0+B1       SI = SI + 1
          NZ     B2,CPL1     IF N " 0 
  
*         SET EXIT CONDITIONS 
  
          SA2    O.IOL
          SB5    X6 
          SX3    A0 
          SX6    B6 
          SA6    L.UDI       L.UDI = UI 
          IX7    X3-X2       L.IOL = SI - O.IOL 
          IX0    X3-X1       LEN = SI - S0 */ LIST LENGTH 
          SA7    L.IOL
          IX1    X1-X2       INDX = S0 - O.IOL
          EQ     CG$CPL 
  
*         DOUBLE/COMPLEX ENTRY
  
 CPL4     LX5    1+AP.P1P 
          RJ     SUI
          BX2    X2*X5
          SX4    B1 
          BX6    X2+X6
          LX4    IH.CAP 
          SA6    A0          [SI] = (IO,USE)[TI] ! SUI( IHF ) 
          SA0    A0+B1       SI = SI + 1
          IX7    X4+X7       CA[IHF] = CA[IHF] + 1 */ CA ALWAYS POSITIVE
          EQ     CPL3 
 SUI      TITLE  SUI - SET *UDI* INDEX
**        SUI - SET *UDI* INDEX 
* 
*         ENTRY  (X0) = MASK(-UA.CAIHL) 
*                (X7) = IHF , CA,IH OF LOCATION 
*                (B4) = O.UDI 
*                (B6) = UI , NEXT AVAIL LOC IN *UDI*
*                (B7) = O.SYM - 1 
* 
*         EXIT   (X6) = U0 = INDEX TO IHF IN *UDI*
*                (X2) = MASK(60-AP.USEP)  ( 3S58 )
* 
*         USES   B - 3, 5 
*                A - 2, 3, 6
*                X - 2, 3, 4, 6 
  
 SUI0     SX6    B5+B5       U0 = 2*CL
          MX2    -AP.USEP 
  
 SUI      ROUTINE 
          LX6    B1,X7
          SB3    B7+X6
          SA2    B3+X7       WORDB = SYM(3*IH+1)
          SB5    B1          CL = 1 
          LX2    59-WB.LDOP 
          MI     X2,SUI0     IF LDO[WORDB] */ VAR IS LD ONLY
          MX4    -6 
          BX6    -X4*X7      HI = IHF & 77B 
          SA7    B4          [UDI] = IHF   */ SET SEARCH TERMINATOR 
          SA2    O.UDB+X6    CI = UDB(HI) 
          SX4    B0          C0 = 0 
          ZR     X2,SUI2     IF CI = 0     */ BASE TABLE ENTRY IS EMPTY 
          SB3    X2          C0 = CI
  
*         SEARCH HASH CHAIN 
  
 SUI1     SA3    B4+X2       UDW = UDI(CI)
          SB5    X2          CL = CI
          BX6    X3-X7
          LX3    -UA.HLP
          SX2    X3          CI = HL[UDW] 
          BX4    -X0*X6 
          NZ     X4,SUI1     IF CAIH[UDW] " IHF 
  
          NZ     B5,SUI0     IF CL " 0     */ ENTRY IN TABLE
  
*         ADD ENTRY TO *UDI*
  
          SX4    B3 
          LX4    UA.HLP 
 SUI2     BX6    X4+X7       UDI(UI) = UDIW(0,C0,IHF) 
          SA6    B4+B6
          SX6    B6          U0 = UI
          MX2    -AP.USEP 
          SB6    B6+B1       UI = UI + 1
          SA6    A2          UDB(HI) = U0 
          LX6    1           U0 = 2*U0
          EQ     SUI
 PBB      TITLE  PBB - PROCESS BASIC BLOCK FOR OPT = 2
**        PBB - PROCESS BASIC BLOCK FOR OPT = 2 
* 
*         SETUP *BIT* ENTRY FOR *TXT* IN BLOCK AND DUMP BLOCK TO MASS 
*         STORAGE.
* 
*         ENTRY  *TXT* - SQUEEZED BASIC BLOCK 
*                *IOL* - PARAMETER LIST INFO
* 
*         EXIT   BLOCK WRITTEN TO MASS STORAGE
*                RI[*BOS*] = *BIT* INDEX OF BLOCK 
*                R2[*BOS*] = 42/0,18/L.TXT, INSTRUCTION LENGTH
  
 PBB      ENTRY. **,# 
          CALL   CMR         CHAIN MEMORY REFS TO *UDI* 
  
*         SET INFO IN R1, R2 WORDS OF *BOS* 
  
          SA3    O.TXT
          SA2    L.TXT
          SA1    L.IOL
          SA5    X3          R1 = [O.TXT] 
          MX0    -IH.IHL
          SA4    L.BIT
          BX5    X0*X5
          IX7    X4+X5       IH[R1] = L.BIT  */ SAVE BLOCK NUMBER 
          SA7    A5 
          BX6    X2 
          LX6    R2.TXTLP 
          SA6    A7+B1       R2 = R1 + 1;  TXTL[R2] = L.TXT 
  
          IX7    X1+X2
          SA3    =XM.BBL# 
          IX0    X3-X7
          PL     X0,PBB0     M.BBL = MAX( M.BBL , L.TXT + L.IOL ) 
          SA7    A3+
  
 PBB0     ZR     X1,PBB1     IF L.IOL = 0  */ NO PARAMETER LISTS
          ALLOC  TXT,X1 
          SX3    X2+B6
          SA2    O.IOL
          MOVE   X1,X2,X3    MOVE( L.IOL , O.IOL , O.TXT + OLD(L.TXT) ) 
          MX6    0
          SA6    L.IOL       L.IOL = 0
  
*         SETUP *BIT* ENTRY, AND DUMP BLOCK TO MASS STORAGE 
  
 PBB1     ALLOC  BIT,1       ALLOC( BIT , 1 ) 
          SA4    O.TXT       FSCM = [O.TXT]  */ FWA OF BLOCK
          SB5    X2+B6       BI = O.BIT + OLD(L.BIT)
          SA3    X4          R1 = [O.TXT] 
          LX3    -R1.INP
          SX6    X3 
          LX6    BI.FLNP     FLN[BI] = IN[R1] 
          SA1    X4+4        R1 = R1 + 4   */ LOOKAT FIRST INSTRUCTION
          UX7    B2,X1
          SB3    B2-OC.LAB
          NZ     B3,PBB2     IF OC[R1] " OC.LAB 
          SX0    B1 
          SB4    X1          LIH = IH[R1] 
          LX0    BI.ILP      IL[BI] = 1 
          BX6    X0+X6
  
 PBB2     SA2    X4+B1       LTXT = [O.TXT+1] 
          SB7    X2-8 
          SA5    X4+B7       R1L = O.TXT + LTXT-8 
          UX7    B2,X5
          SX0    B2-OC.UJP
          ZR     X0,PBB2A    IF OC[RI] = OC.UJP 
          SX0    B2-OC.JIN
          NZ     X0,PBB3      IF OC[R1L] " OC.JIN 
 PBB2A    SX0    B1 
          LX0    BI.FJP 
          BX6    X0+X6       FJ[BI] = 1    */ INDICATE FINAL *UJP*
          SX7    X2-12
          NZ     X7,PBB3     IF LTXT " 12  */ NOT 2 INSTRUCTION BLOCK 
          NZ     B3,PBB3     IF OC[R1] " OC.LAB 
          LX0    BI.LJPP-BI.FJP 
          BX6    X0+X6       LJP[BI] = 1   */ INDICATE LAB/JP ONLY
  
 PBB3     SA5    L.TXT
          SA3    =XL.PTXT#
          IX7    X3+X5       L.PTXT = L.PTXT + L.TXT
          SA7    A3 
  
*         INHIBIT COMBINATION OF LARGE BLOCKS WITH EXTERNAL REFS IN CBB 
  
          SX7    X5-2004B 
          SA3    =XCC$XR
          MI     X7,PBB4     IF L.TXT < 2000B 
          LX3    1+BI.FJP 
          BX6    X3+X6       FJ[BI] = XR
  
 PBB4     SX7    X5+2        L = L.TXT + 2
          IX0    X4+X5       LTXT = O.TXT + L.TXT 
          SA6    B5 
          LX7    BT.LENP
          SA7    X0          [LTXT] = BTW(0,0,0,L)  */ TRAILER WORD 
          SX3    B6 
          LX3    BH.BIP 
          LX7    BH.LENP-BT.LENP
          BX7    X3+X7
          SA7    X4-1        [O.TXT-1] = BHW(0,OLD(L.BIT),0,L)
          SB2    0           FLCM = 0 
          CALL   SMB#        SMB( O.TXT , L. TXT )
          ADDWRD BIT,X1      ADDWRD( BIT , RIW )
          EQ     PBB
  
          ENTRY  F$UDT
  
 F$UDT    END 
