*DECK FLUSHPL 
USETEXT CCTTEXT 
USETEXT DNTEXT
          PROC  FLUSHPL;
  
#**       FLUSHPL -  FLUSH POOLED LITERALS
* 
*         FLUSHPL                  (FROM CGEN)
* 
*         FLUSHES OTEXT BUFFER, 
*         GENERATES OTEXT:  
*           USE    LITERAL
*           DATA   WORD_1 
*           ... 
*           DATA   WORD_N 
*         FLUSHES OTEXT BUFFER. 
# 
  
  
          BEGIN 
  
  
          XREF  FUNC  VIRTUAL      I;  # INDEX TO A MANAGED TABLE      #
          XREF  PROC  CGABORT;         # INTERNAL COMPILER ERROR       #
          XREF  PROC  FLUSHOT;         # FLUSH OTEXT BUFFER            #
          $BEGIN
          XREF  PROC  CBLIST;          # COBOL LIST PROGRAM            #
          XREF  FUNC  OCT          C(20);        # DISPLAY OCTAL VALUE #
          $END
  
  
*CALL M$
  
          $BEGIN
*CALL BUG202C 
          $END
  
  
  
*CALL INSTDEFS
  
*CALL LISTCTL 
  
*CALL OPNAMES 
  
*CALL OTXT$ 
  
*CALL TABLETYP
  
  
*CALL WORKTABS
  
  
          ITEM  DUMMY        I; 
          ITEM  EXCHANGED    B;        # FLAG TO SIGNAL COMPLETE SORT  #
          ITEM  I            I; 
          ITEM  IMAX         I; 
          ITEM  IMIN         I; 
          ITEM  L            I; 
          ITEM  LEN          I; 
          ITEM  RELNUM       I;        # LITOFFSET[VRX]                #
          ITEM  RX           I;        # UNMODIFIED INDEX TO RELOCS$   #
          ITEM  RXLIM        I;        # LIMIT FOR RX                  #
          ITEM  TEMP         I;        # SCRATCH                       #
          ITEM  TEMP1        I;        # SCRATCH                       #
          ITEM  VDX          I;        # VIRTUALIZED INDEX TO DNAT$    #
          ITEM  VI           I;        # VIRTUALIZED INDEX TO WORK2$   #
          ITEM  VRX          I;        # VIRTUALIZED INDEX TO WORK3$   #
          ITEM  WORD         I;        # SCRATCH                       #
  
          DEF  LIT           #WORK2LITPOOL#;
          DEF  AVAILABLE     #WORK1LITPOOL#;
          DEF  LOOP  #DUMMY=DUMMY#; 
  
          XREF
              BEGIN 
              ITEM  LITBLK     I;      # NUMERIC LITERALS USETAB INDEX #
                                       #   FOR MAIN PROGRAM (ORIG.)    #
              ITEM  NUMLBLK    I;      # NUMERIC LITERALS USETAB INDEX #
                                       #   FOR SEGMENTED PROGRAMS      #
              ITEM  NUMLITOFFSET I;    # LITERAL OFFSET SKIPPING ALPHAS#
          ITEM  MAXLITLENGTH I;        # MAX. LENGTH OF LITERAL BLOCK  #
              END 
  
          FUNC  MIN(A,B)  I;
          BEGIN 
          ITEM  A            I; 
          ITEM  B            I; 
  
          IF A LQ B  THEN 
              MIN = A;
          ELSE
              MIN = B;
          END 
  
          DEF  OTEXTWORD     #OTXT$WORD#; 
CONTROL EJECT;
  
          $BEGIN
          PROC  DUMP; 
              BEGIN 
              ITEM  I;
                     IF BUG202C$NUML[1]  THEN 
                  BEGIN 
                  FOR I = 0 STEP 1 UNTIL WSLENGT-1  DO
                      BEGIN 
                      CBLIST(LISTCTL"LINE", OCT(OTEXTWORD[I],0,20), 20);
                      END 
                  END 
              END 
          $END
CONTROL EJECT;
  
#      SORT THE RELOCATION TABLE ACCORDING TO WORD OFFSETS             #
  
          EXCHANGED = TRUE; 
          VRX = VIRTUAL(TABLETYPE"WORK3$", 0);
          RXLIM = WORK3$NRELS[VRX] - 1; 
  
          FOR LOOP WHILE EXCHANGED  DO
              BEGIN 
              EXCHANGED = FALSE;
              FOR RX = 1 STEP 1 UNTIL RXLIM  DO 
                  BEGIN 
                  VRX = VIRTUAL(TABLETYPE"WORK3$", RX);    # OLD LOWER #
                  TEMP = WORK3$OFFSET[VRX]; 
                  WORD = WORK3$WORD[VRX]; 
                  VRX = VIRTUAL(TABLETYPE"WORK3$", RX+1);  # OLD UPPER #
                  IF WORK3$OFFSET[VRX] LS TEMP  THEN # IF OUT OF ORDER #
                      BEGIN 
                      TEMP1 = WORK3$WORD[VRX];       # SAVE OLD UPPER  #
                      WORK3$WORD[VRX] = WORD;        # SET NEW UPPER   #
                      VRX = VIRTUAL(TABLETYPE"WORK3$", RX); 
                      WORK3$WORD[VRX] = TEMP1;       # SET NEW LOWER   #
                      EXCHANGED = TRUE;              # NOTE EXCHANGE   #
                      END 
                  END  #I#
              END  #LOOP# 
  
          VRX = VIRTUAL(TABLETYPE"WORK3$", RXLIM+2);
          WORK3$OFFSET[VRX] = 99999;             # APPEND DUMMY ENTRY  #
          RX = 1;                                # SET COUNT           #
          VRX = VIRTUAL(TABLETYPE"WORK3$", RX);  # SAVE INDEX          #
          RELNUM = WORK3$OFFSET[VRX];            # FIRST VFD WORD      #
  
          $BEGIN
          DUMP; 
          $END
          FLUSHOT;
          OTEXTWORD[0] = LITBLK;
          B<0,12>OTEXTWORD[0] = OPNAMES"USE$";
          WSLENGT = 1;
          $BEGIN
          DUMP; 
          $END
          FLUSHOT;
  
  
          IMIN = 1; 
          VI = VIRTUAL(TABLETYPE"WORK2$", 0);              # LIT       #
          LEN = B<0,60>LIT[VI]; 
  
          FOR LOOP WHILE LEN NQ 0 DO
              BEGIN 
              L = MIN(LEN, RELNUM - IMIN);
              L = MIN(L, WSLIMIT-1);
            IF L GR 0  THEN 
              BEGIN 
              OTEXTWORD[0] = L * 2**18; 
              B<0,12>OTEXTWORD[0] = OPNAMES"DATA$"; 
              IMAX = IMIN + L - 1;
              L = 0;
  
              FOR I = IMIN STEP 1 UNTIL IMAX  DO
                  BEGIN 
                  L = L + 1;
                  VI = VIRTUAL(TABLETYPE"WORK2$", I);      # LIT       #
                  B<0,60>OTEXTWORD[L] = B<0,60>LIT[VI]; 
                  END 
  
              WSLENGT = L + 1;
              $BEGIN
              DUMP; 
              $END
              FLUSHOT;
              IMIN = IMAX + 1;
              END 
            ELSE
              BEGIN                    # RELNUM MUST EQUAL IMIN        #
              VI = VIRTUAL(TABLETYPE"WORK2$", RELNUM);     # LIT       #
              OTEXTWORD[0] = 6 * 2**18; 
              B<0,12>OTEXTWORD[0] = OPNAMES"VFD$";
OTEXTWORD[1] = 0; 
B<0,12>OTEXTWORD[1] = 12; 
              OTEXTWORD[2] = B<0,12>LIT[VI];
OTEXTWORD[3] = 0; 
B<0,12>OTEXTWORD[3] = 18; 
              B<34,8>OTEXTWORD[3] = TABLETYPE"DNAT$"; 
              B<42,18>OTEXTWORD[3] = WORK3$DNAT[VRX];      # DNAT INDEX#
              CCTLPOOLLEN = CCTLPOOLLEN + 1;     # NOTE NEW DNAT ENTRY #
              OTEXTWORD[4] = B<12,18>LIT[VI]; 
OTEXTWORD[5] = 0; 
B<0,12>OTEXTWORD[5] = 30; 
              OTEXTWORD[6] = B<30,30>LIT[VI]; 
              WSLENGT = 7;
              $BEGIN
              DUMP; 
              $END
              FLUSHOT;                           # WRITE OUT THE VFD   #
              RX = RX + 1;                       # GO TO NEXT REL.     #
              VRX = VIRTUAL(TABLETYPE"WORK3$", RX); 
              RELNUM = WORK3$OFFSET[VRX]; 
              IMIN = IMIN + 1;                   # DONE WITH 1 LIT WORD#
              L = 1;                             # DONE WITH 1 LIT WORD#
              END 
  
              LEN = LEN - L;
              END  #LOOP# 
  
  
#   CLEAR COMPILER TABLES IN CASE OF SEGMENTED PROGRAM                 #
  
          VI = VIRTUAL(TABLETYPE"WORK1$", 0); 
          B<0,60>WORK1LITPOOL[VI] = 0;
  
          VI = VIRTUAL(TABLETYPE"WORK2$", 0); 
          B<0,60>WORK2LITPOOL[VI] = 0;
  
          VI = VIRTUAL(TABLETYPE"WORK3$", 0); 
          WORK3$NRELS[VI] = 0;
  
          NUMLITOFFSET = -1;           # NOTE NO ALPHA LITS IN BLOCK   #
          MAXLITLENGTH = 0;            # TRIGGER RE-INIT. OF LITPOOL   #
  
  
          WSLENGT = 0;                 # IN CASE FLUSHOT CALLED AGAIN  #
  
  
#   SWITCH TO LOCAL BLOCK FOR SUBSEQUENT SEGMENTS                      #
  
          LITBLK = NUMLBLK; 
  
          END 
          TERM
