*DECK POOLDMP 
USETEXT CCTTEXT 
PROC     POOLDMP(STARTNUM,ENDNUM,HEADER); 
         BEGIN
 #
         P O O L D M P
  
         THIS PROCEDURE DUMPS THE LITERAL POOL IN FORMATTED 
         FORM FROM CHARACTER OFFSET STARTNUM TO CHARACTER 
         OFFSET ENDNUM. 
  
         IF ENDNUM IS OMITTED OR ZERO THE DUMP CONTINUES FROM 
         STARTNUM TO THE END OF THE POOL. IF BOTH PARAMETERS
         ARE OMITTED THE ENTIRE POOL IS DUMPED. 
  
         THE HEADER PARAMETER CONTROLS THE PAGE LISTING TITLE.
         IF THIS PARAMETER IS NON ZERO THE HEADING IS PRINTED.
  
         BASICALLY THE DUMPING ALGORITHM IS A LOOP OVER THE POOL
         FORMATTING 4 WORDS AT A TIME TO MAKE A PRINT LINE. 
 #
         ITEM STARTNUM            I;
         ITEM ENDNUM              I;
         ITEM HEADER              I;
          $BEGIN
 #
         DECLARATION OF NECESSARY PROGRAM VARIABLES 
 #
         ITEM STARTORD            I,
              ENDORD              I,
              POOL$OFFSET         I,
              WORD$OFFSET         I,
              IDX                 I,
              OCT$POS             I,
              BCD$POS             I,
              POOLWORD            I,
              OUTBUFF             C(132); 
 #
         DECLARATION OF EXTERNAL PROCEDURES 
 #
         XREF FUNC                DEC              C(10); 
         XREF FUNC                OCT              C(40); 
         XREF PROC                CBLIST; 
         XREF PROC                TMREOP; 
         XREF PROC                TMRECL; 
 #
         INCLUSION OF COMPILER COMMON TABLES
 #
*CALL GETSET
*CALL TABLNAMES 
*CALL LPOOL1
         CONTROL EJECT; 
  
         TMREOP(LPOOL$);                           # RE-OPEN TABLE
                                                     IF NECESSARY    #
 #
         SET UP LOOP CONTROL BOUNDARIES 
 #
         STARTORD = STARTNUM/10;                   # ROUND DOWN TO
                                                     WORD COUNT      #
         ENDORD = ENDNUM; 
         IF ENDORD LQ 0 
         OR ENDORD GR CCTLPOOLLEN                  # DEFAULT CASE    #
            THEN
            ENDORD = CCTLPOOLLEN;                  # DUMP ENTIRE
                                                     LITERAL POOL    #
         ENDORD = (ENDORD + 9)/10;                 # ROUND UP TO
                                                     WORD COUNT      #
         IF ENDORD LS STARTORD                     # BAD PARAMETERS  #
            THEN
            ENDORD = STARTORD;
 #
         OUTPUT FILE MANIPULATIONS
 #
         IF HEADER NQ 0 
         THEN 
         BEGIN
         CBLIST(8,"POOLDMP",7);                    # OPEN 
                                                     DUMP FILE       #
         OUTBUFF = "L I T E R A L   P O O L   D U M P"; 
  
         CBLIST(4,OUTBUFF,33);                     # TRANSMIT 
                                                     TITLE FIELD     #
         OUTBUFF =
        "OFFSET                               DISPLAY CODE VERSION
                                           BCD VERSION";
         CBLIST(5,OUTBUFF,117);                    # SET UP SUB 
                                                     TITLE FIELD     #
         CBLIST(3);                                # FIRST PAGE 
                                                     EJECTION        #
         END
         CONTROL EJECT; 
 #
         SET UP NORMAL OUTPUT LINE
 #
         C<5,1>OUTBUFF = " ";                      # BLANK TO DELIMIT 
                                                     OFFSET AND OCTAL#
         C<89,3>OUTBUFF = " : ";                   # MARK TO DELIMIT
                                                     OCTAL AND BCD   #
 #
         SET UP MAIN LOOP FOR AREA OF POOL TO BE DUMPED 
 #
         FOR POOL$OFFSET = STARTORD STEP 4
                           UNTIL ENDORD DO         # LINE BY LINE    #
         BEGIN
         C<0,5>OUTBUFF = DEC(POOL$OFFSET * 10);    # FORMAT 
                                                     CHAR OFFSET     #
 #
         INITIALIZE LINE POSITION COUNTERS
 #
         OCT$POS = 6;                              # OCTAL CHARS
                                                     START POSITION  #
         BCD$POS = 92;                             # BCD CHARS
                                                     START POSITION  #
         CONTROL EJECT; 
 #
         MINOR LOOP FOR EACH LINE OF DUMP 
 #
         FOR WORD$OFFSET = 0 STEP 1 UNTIL 3 DO     # WORD BY WORD    #
         BEGIN
         POOLWORD 
         = GETQUICK(LP$WORD,LPOOL$, 
                    POOL$OFFSET + WORD$OFFSET);    # ACCESS CURRENT 
                                                     POOL WORD       #
 #
         OUTPUT DISPLAY CODE VERSION OF CURRENT WORD
 #
         C<OCT$POS,20>OUTBUFF = OCT(POOLWORD,0,20);# CONVERT TO 
                                                     OCTAL FORM      #
         OCT$POS = OCT$POS + 20;                   # BUMP POSITION
                                                     COUNTER         #
         C<OCT$POS,1>OUTBUFF = " ";                # SEPARATE WORDS 
                                                     BY BLANKS       #
         OCT$POS = OCT$POS + 1;                    # BUMP POSITION
                                                     COUNTER         #
 #
         CHECK FOR 00 BYTES WHICH WILL CAUSE PROBLEMS 
         FOR EITHER PRINT OR DISPLAY OUTPUT FORMATTING
 #
         FOR IDX = 0 STEP 1 UNTIL 9 DO             # LOOP THRU
                                                     EACH POOLWORD   #
             IF C<IDX,1>POOLWORD EQ O"00"          # ZERO BYTE       #
                THEN
                C<IDX,1>POOLWORD = ".";            # CHANGE TO PERIOD 
                                                     AS RECOVERY     #
 #
         OUTPUT CHARACTER VERSION OF CURRENT WORD 
 #
         C<BCD$POS,10>OUTBUFF = C<0,10>POOLWORD;   # MOVE WORD
                                                     TO BUFFER       #
         BCD$POS = BCD$POS + 10;                   # BUMP POSITION
                                                     COUNTER         #
         END                                       # END OF SINGLE
                                                     LINE LOOP       #
 #
         PRINT THE NOW FORMATTED LINE 
 #
         CBLIST(1,OUTBUFF,132); 
         END
         CONTROL EJECT; 
 #
         FINAL TERMINATION CLEAN UP 
 #
         IF HEADER NQ 0 
         THEN 
         CBLIST(9,"POOLDMP",7); 
  
         TMRECL(LPOOL$);                           # RE-CLOSE 
                                                     THE TABLE       #
          $END
         END #POOLDMP#
TERM
