*DECK LITPOOL 
USETEXT CCTTEXT 
USETEXT DNTEXT
          PROC  LITPOOL;
  
          BEGIN 
  
 # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * #
 #                                                                     #
 #        LITPOOL -  POOL A LITERAL                                    #
 #                                                                     #
 #        REGT = DNAT POINTER                                          #
 #          *** THIS MEANS   MOVEZ  N,(BCPOF,REGT)   WILL WORK ***     #
 #        (BYTLENOF,REGT) = NUMBER OF CHARACTERS IN LITERAL.           #
 #          BYTE LENGTH MUST BE A MULTIPLE OF 10.                      #
 #        P1 = 0 MEANS P2 IS VALUE OF LITERAL.                         #
 #                 (ASSUMES P3... FOLLOWS P2 IN CORE FOR LEN > 10)     #
 #           " 0 MEANS P2 IS ADDRESS OF VALUE OF LITERAL.              #
 #               AND RELOCATION OF ONE ADDRESS FIELD MAY BE SPECIFIED  #
 #               BY P1 \ 2:                                            #
 #                  P1 = (DNAT INDEX OF DESTINATION) + 1               #
 #        P2 INDICATES VALUE OF LITERAL, AS ABOVE.                     #
 #                                                                     #
 #        EXECUTE LITPOOL                                              #
 #                                                                     #
 #        SETS (FWA$OF,REGT) = ADDRESS OF LITERAL                      #
 #                                                                     #
 #        NOTE-                                                        #
 #        AT THE END OF CODE GENERATION, *FLUSHPL* MUST BE CALLED      #
 #        TO FLUSH OUT THE POOLED LITERALS FROM THE COMPILER TABLES.   #
 #                                                                     #
 # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * #
  
  
          XREF  FUNC  VIRTUAL      I;  # INDEX TO MANAGED TABLE        #
  
  
*CALL M$
  
  
  
*CALL FIXCOM
  
*CALL FIXED 
  
*CALL REGTABL 
  
  
*CALL GTEXT 
  
 #                                                                     #
 #     STATUS LIST FOR REFERENCING DNAT FIELDS                         #
 #                                                                     #
          CONTROL NOLIST;    # STATUS FIELDS <FIELDNAM> <SEMI-COLON>   #
          STATUS FIELDS 
          ; 
          CONTROL LIST;      # STATUS FIELDS <FIELDNAM> <SEMI-COLON>   #
  
*CALL TABLETYP
  
  
*CALL WORKTABS
  
  
          BASED ARRAY PARAM[1:24] S(1); 
              BEGIN 
              ITEM  PARM         C(0, 0,10);
              END 
  
  
          ITEM  I            I;        # SCRATCH                       #
          ITEM  IMAX         I;        # MAXIMUM VALUE FOR I           #
          ITEM  LEN          I;        # NO. OF WORDS IN GIVEN LITERAL #
          ITEM  N            I;        # INDEX TO LITPOOL/ALITPOOL     #
          ITEM  NMAX         I;        # MAX. INDEX IN SEARCH          #
          ITEM  NRELS0       I;        # LOCAL VALUE OF NRELS[0]       #
          ITEM  OFFSET       I;        # REL WORD OFFSET IN WHOLE TABLE#
          ITEM  REG          I;        # REGTABL INDEX FOR REGB        #
          ITEM  REL          I;        # USE BLOCK NUMBER FOR ADDRESS  #
          ITEM  VI           I;        # VIRTUALIZED I                 #
  
          XREF  ITEM  LITBLK       I;  # INDEX TO USETAB FOR LITERALS  #
          XDEF  ITEM  MAXLITLENGTH I;  # MAX. LENGTH OF LITERAL BLOCK  #
          XDEF  ITEM  NUMLITOFFSET I;  # LITERAL OFFSET SKIPPING ALPHAS#
  
          DEF  LIT           #WORK2LITPOOL#;
  
  
          $BEGIN
          XREF
              BEGIN 
              PROC  CBLIST;            # PROCESS COBOL LIST FILE       #
              PROC  CGABORT;           # INTERNAL COMPILER ABORT       #
              FUNC  DEC          C(10);# DECIMAL DISPLAY VALUE         #
              END 
  
*CALL BUG202C 
  
*CALL LISTCTL 
  
          ITEM  BUGLINE1     C(130) =                                  "
                                        POOLED LITERAL = (";
          ITEM  BUGLINE2     C(130) =                                  "
                                        REGTABL = ****DNAT = ******SUBMS
EC = ***WORDOFF = ******";
          DEF   BUGLINE2A    #C<50,4>BUGLINE2#;            # REGTABL   #
          DEF   BUGLINE2B    #C<61,6>BUGLINE2#;            # DNAT      #
          DEF   BUGLINE2C    #C<77,3>BUGLINE2#;            # SUBMSEC   #
          DEF   BUGLINE2D    #C<90,6>BUGLINE2#;            # WORDOFF   #
          $END
          CONTROL EJECT;
  
 #     INITIALIZE LITERAL POOL TABLES IF NECESSARY                     #
  
          IF MAXLITLENGTH LS 0  THEN
              BEGIN 
              VI = VIRTUAL(TABLETYPE"WORK2$", 0);          # LIT       #
              B<0,60>LIT[VI] = 0;                # LENGTH OF POOL = 0  #
              MAXLITLENGTH = 0; 
              VI = VIRTUAL(TABLETYPE"WORK3$", 0); 
              WORK3$NRELS[VI] = 0;
              NRELS0 = 0; 
              END 
          ELSE
              BEGIN 
              VI = VIRTUAL(TABLETYPE"WORK3$", 0); 
              NRELS0 = WORK3$NRELS[VI]; 
              END 
  
 #     PICK UP PARAMETERS                                              #
  
          REG = B<42,18>REGDNATADDR[FIXEDCELL[FIXED"REGT"]];
  
          LEN = (DN$ITMLEN[VIRTUAL(TABLETYPE"DNAT$", REG)] + 9) / 10; 
  
          IF FIXEDCELL[FIXED"P1"] EQ 0  THEN
              BEGIN 
              P<PARAM> = LOC(FIXEDCELL[FIXED"P2"]); 
              REL = 0;
              END 
          ELSE
              BEGIN 
              P<PARAM> = FIXEDCELL[FIXED"P2"];
              REL = FIXEDCELL[FIXED"P1"] - 1; 
              $BEGIN
              IF LEN GR 24  THEN
                  CGABORT("LITPOOL2");
              $END
              END 
  
  
          N = MAXLITLENGTH + 1;                  # INDEX TO NEW ENTRY  #
          MAXLITLENGTH = MAXLITLENGTH + LEN;
          B<0,60>LIT[VIRTUAL(TABLETYPE"WORK2$",0)] = MAXLITLENGTH;
          FOR I = 1 STEP 1 UNTIL LEN  DO
              BEGIN 
              B<0,60>LIT[VIRTUAL(TABLETYPE"WORK2$", N+I-1)] = PARM[I];
              END 
          IF REL NQ 0  THEN 
              BEGIN 
              VI = VIRTUAL(TABLETYPE"WORK3$", NRELS0+1);
              WORK3$DNAT[VI] = REL; 
              WORK3$OFFSET[VI] = N; 
              WORK3$NRELS[VIRTUAL(TABLETYPE"WORK3$",0)] = NRELS0 + 1; 
              END 
  
#      A MATCH HAS BEEN ENSURED AT INDEX N                             #
  
MATCH:  
          REGGCODE[FIXEDCELL[FIXED"REGT"]] = GDATAREF;
  
          I = VIRTUAL (TABLETYPE "DNAT$", REG); 
          DN$SUBMSEC [I] = LITBLK;
          DN$BYTEOFFS [I] = NUMLITOFFSET + N; 
  
          $BEGIN
          IF BUG202C$ANYF[0]  THEN
              BEGIN 
              C<58,62>BUGLINE1 = " "; 
              FOR I = 1 STEP 1 UNTIL 20  DO 
                  C<57+I,1>BUGLINE1 = B<3*I-3,3>PARM[1] + O"33";
              C<78,1>BUGLINE1 = ")";
              IF LEN NQ 1  THEN 
                  BEGIN 
                  FOR I = 1 STEP 1 UNTIL 20  DO 
                      C<77+I,1>BUGLINE1 = B<3*I-3,3>PARM[2] + O"33";
                  IF LEN EQ 2  THEN 
                  C<98,1>BUGLINE1 = ")";
                  ELSE
                  C<98,4>BUGLINE1 = " ..."; 
                  END 
              CBLIST(LISTCTL"LINE", BUGLINE1, 130); 
  
              BUGLINE2A = DEC(FIXEDCELL[FIXED"REGT"]);
              BUGLINE2B = DEC(REG); 
              BUGLINE2C = DEC(LITBLK);
              BUGLINE2D = DEC(NUMLITOFFSET + N);
              CBLIST(LISTCTL"LINE", BUGLINE2, 130); 
              END 
          $END
          END 
          TERM
