*DECK DUMPS 
USETEXT CCTTEXT 
PROC DUMPS; 
$BEGIN
  # THIS SET OF ROUTINES DUMPS OUT THE MAJOR TABLES IN A
    READABLE FORMAT # 
  
  
*CALL TABLNAMES 
*CALL AWRT
*CALL CTEXT 
*CALL DNT 
*CALL NAMET 
*CALL INT1
*CALL PAT1
*CALL PNT 
*CALL PLT1
*CALL SPBT1 
  
CONTROL EJECT;
  # TEMPORARY VARIABLES # 
  ITEM I,J,K,L,TEMP,TEMP1,TEMP2,TEMP3,TEMP4;
  
  # EXTERNAL ROUTINES USED BY DUMPS # 
  XREF
    BEGIN 
      PROC CBLIST;
      PROC TMREOP;
      PROC TMRECL;
      FUNC DEC C(10); 
      FUNC OCT C(40); 
    END 
  
  # CBLIST FUNCTION CODES # 
  DEF SSP #1#;
  DEF DBSP #2#; 
  DEF EJECTPAGE #3#;
  DEF DEFTITLE #4#; 
  DEF DEFSUBTITLE #5#;
  DEF OPENF #8#;
  DEF CLOSEF #9#; 
  
  XREF FUNC VIRTUAL U; # USED TO ENSURE ENTRY IS IN MEMORY #
  
  ITEM REAL$I U; # USED TO HOLD IN-MEMORY INDEX OF TABLE #
  
  ARRAY OUT[0:11]; #USED FOR OUTPUT#
      ITEM W C(0,0,10); 
  
  
  
  BEGIN # START OF MAIN BODY #
CONTROL EJECT;
  ENTRY PROC DNTDMP;
    # THIS ROUTINE DUMPS THE DNT #
  
    BEGIN 
      CBLIST(DEFSUBTITLE, 
      "NAME                          INT NU COL LEV LINE LINK GRP SCOPE 
SR ST UNQ        BIGHASH  NW NAMEP  INFO",110); 
      CBLIST(EJECTPAGE);
      TMREOP (DNT$);
      TMREOP(NAMET$); 
      FOR I = 1 STEP 1 UNTIL CCTDNTLEN DO 
        BEGIN 
          FOR K = 0 STEP 1 UNTIL 11 DO
            W[K] = "          ";
  
            REAL$I = VIRTUAL(DNT$,I); 
          C<0,4> W[3] = DEC(I); # PUT IN INT. NAME #
            BEGIN # FILL OUT NAME # 
              IF DNTFILLER[REAL$I]
              THEN
                W[0] = "FILLER";
              ELSE
                IF DNTNAMETPTR[REAL$I] NQ 0 
                THEN
                  GETNAME(DNTNAMETPTR[REAL$I], DNTNBRWORDS[REAL$I]);
            END 
              C<5,1>W[3] = DEC(DNTNOTUNIQUE [REAL$I]);
              C<7,3>W[3] = DEC(DNTCOLUMN    [REAL$I]);
              C<1,2>W[4] = DEC(DNTLEVEL     [REAL$I]);
              C<6,4>W[4] = DEC(DNTLINE      [REAL$I]);
              C<1,4>W[5] = DEC(DNTLINK      [REAL$I]);
              C<6,1>W[5] = DEC(DNTGROUP     [REAL$I]);
              C<0,3>W[6] = DEC(DNTSCOPE     [REAL$I]);
              C<5,1>W[6] = DEC(DNTSREG      [REAL$I]);
              C<7,2>W[6] = DEC(DNTSREGVAL   [REAL$I]);
              C<1,2>W[7] = DEC(DNTIDUNQ     [REAL$I]);
              C<0,10>W[8] = OCT(DNTBIGHASH[REAL$I],10,10);
              C<2,1>W[9] = DEC(DNTNBRWORDS  [REAL$I]);
              C<5,4>W[9] = DEC(DNTNAMETPTR  [REAL$I]);
              C<0,10>W[10] = OCT(DNTINFO[REAL$I],0,10); 
              C<0,10>W[11] = OCT(DNTINFO[REAL$I],10,10);
  
        CBLIST(SSP,OUT,120);
  
        END 
      CBLIST(SSP,"  ** END OF DNTDUMP **  ",24);
      CBLIST(DEFSUBTITLE," ",1); #RESET SUBTITLE TO BLANK#
      TMRECL (DNT$);
      TMRECL (NAMET$);
      RETURN; 
    END 
  
  
CONTROL EJECT;
  ENTRY PROC PNTDMP;
    # THIS ROUTINE DUMPS OUT THE PNT #
    BEGIN 
      CBLIST(DEFSUBTITLE, 
                 " NAME                         INT COL NU AM S DBG LINE
 LINK G  D SEGORSECT  OCTAL          NW NAMEP BIGHASH    IDUNQ",116); 
      CBLIST(EJECTPAGE);
      TMREOP (PNT$);
      TMREOP (NAMET$);
      FOR I = 1 STEP 1 UNTIL CCTPNTLEN DO 
        BEGIN 
          FOR K = 0 STEP 1 UNTIL 11 DO
            W[K] = "          ";
          REAL$I = VIRTUAL(PNT$,I); 
         IF PNTNAMETPTR[REAL$I] NQ 0
         THEN 
           GETNAME(PNTNAMETPTR[REAL$I], PNTNBRWORDS[REAL$I]); 
         C<0,4> W[3] = DEC(I);
         C<4,3> W[3] = DEC(PNTCOLUMN[REAL$I]);
         C<8,1> W[3] = DEC(PNTNOTUNIQUE[REAL$I]); 
         C<1,1> W[4] = DEC(PNTAMBIGUOUS[REAL$I]); 
         C<4,1> W[4] = DEC(PNTSECTION[REAL$I]); 
         C<7,1> W[4] = DEC(PNTDEBUG[REAL$I]); 
         C<0,4> W[5] = DEC(PNTLINE[REAL$I]);
         C<5,4> W[5] = DEC(PNTLINK[REAL$I]);
         C<0,1> W[6] = DEC(PNTGROUP[REAL$I]); 
         C<3,1> W[6] = DEC(PNTDECLARATV[REAL$I]); 
         C<5,5> W[6] = DEC(PNTSEGORSECT[REAL$I]); 
         W[7] = OCT(PNTINFO[REAL$I],0,10);
         W[8] = OCT(PNTINFO[REAL$I],10,10); 
         C<2,1> W[9] = DEC(PNTNBRWORDS[REAL$I]);
         C<4,5> W[9] = DEC(PNTNAMETPTR[REAL$I]);
         W[10] = OCT(PNTBIGHASH[REAL$I],10,10); 
          C<2,2> W[11]= DEC(PNTIDUNQ[REAL$I]);
  
         CBLIST(SSP,OUT,120); 
        END 
  
      CBLIST(SSP,"  ** END OF PNTDUMP **  ",24);
      CBLIST(DEFSUBTITLE," ",1); #RESET SUBTITLE TO BLANK#
      TMRECL (PNT$);
      TMRECL (NAMET$);
      RETURN; 
    END 
  
CONTROL EJECT;
  PROC GETNAME(INDEX, WORDS); 
 #  GETS NAME FROM NAME TABLE - IS PASSED NAEM TABLE INDEX + NBR WORDS #
    BEGIN 
      ITEM INDEX I; 
      ITEM WORDS I; 
  
      W[0] = NAMET$CHARS[VIRTUAL(NAMET$,INDEX)];
      IF WORDS GR 1 
      THEN
          BEGIN 
          W[1] = NAMET$CHARS[VIRTUAL(NAMET$,INDEX + 1)];
          IF WORDS GR 2 
          THEN
            W[2] = NAMET$CHARS[VIRTUAL(NAMET$,INDEX +2)]; 
          ELSE
            W[2] = "          " ; 
          END 
      ELSE
          W[2] = "          ";
      RETURN; 
    END 
CONTROL EJECT;
  ENTRY PROC AWRTDMP; 
    # DUMP OUT THE AWRT # 
    BEGIN 
      CBLIST(DEFSUBTITLE, 
                 " NAME                         INT Q CODE IMME SREG LIN
E OCTAL  ** AWRT **",74); 
      CBLIST(EJECTPAGE);
      TMREOP (AWRT$); 
      L = 0;
      FOR I = 1 STEP 1 UNTIL CCTAWRTLEN DO
        BEGIN 
          FOR K = 0 STEP 1 UNTIL 10 DO
            W[K] = "          ";
          REAL$I = VIRTUAL(AWRT$,I);
          IF AWRTQUALIF[REAL$I] EQ 0 THEN L = L+1; # INT. PTR # 
          W[0] = AWR1ST10CHAR[REAL$I];
          W[1] = AWR2ND10CHAR[REAL$I];
          W[2] = AWR3RD10CHAR[REAL$I];
          C<0,4> W[3] = DEC(L); 
          C<4,1> W[3] = DEC(AWRTQUALIF[REAL$I]);
          C<7,1> W[3] = DEC(AWRTCODE[REAL$I]);
          C<1,4> W[4] = DEC(AWRTIMMED[REAL$I]); 
          C<6,4> W[4] = DEC(AWRTSREG[REAL$I]);
        C<1,4> W[5] = DEC(AWRTLINE[REAL$I]);
          W[6] = OCT(AWRTINFO[REAL$I],0,10);
          W[7] = OCT(AWRTINFO[REAL$I],10,10); 
          CBLIST(SSP,OUT,80); 
        END 
      CBLIST(SSP,"  ** END OF AWRTDUMP **  ",25); 
      CBLIST(DEFSUBTITLE," ",1); #RESET SUBTITLE TO BLANK#
      TMRECL (AWRT$); 
      RETURN; 
    END 
  
  
CONTROL EJECT;
  ENTRY PROC INTDMP;
    # DUMP OUT THE INT #
    BEGIN 
      CBLIST(DEFSUBTITLE, 
                 " INDEX PROCNAME CODE INT-NAME OCTAL  ** INT **",46);
      CBLIST(EJECTPAGE);
      TMREOP (INT$);
      FOR I = 1 STEP 1 UNTIL CCTINTLEN DO 
        BEGIN 
          FOR K = 0 STEP 1 UNTIL 10 DO
            W[K] = "          ";
          REAL$I = VIRTUAL(INT$,I); 
          C<2,4> W[0] = DEC(I); 
          C<0,1> W[1] = DEC(IN$PROCNAME[REAL$I]); 
          C<8,2> W[1] = DEC(IN$CODE[REAL$I]); 
          C<4,4> W[2] = DEC(IN$NAME[REAL$I]); 
          W[3] = OCT(IN$INFO[REAL$I],0,10); 
          W[4] = OCT(IN$INFO[REAL$I],10,10);
          CBLIST(SSP,OUT,50); 
        END 
      CBLIST(SSP,"  ** END OF INTDUMP **  ",24);
      CBLIST(DEFSUBTITLE," ",1); #RESET SUBTITLE TO BLANK#
      TMRECL (INT$);
      RETURN; 
    END 
  
  
CONTROL EJECT;
  ENTRY PROC PLTDMP;
    # DUMP THE PLTATTRIBUTE AND PLTSTRING TABLES #
    BEGIN 
      CBLIST(DEFSUBTITLE, 
                 " INDEX SD SGN ZSQLH CODE LINE COL LENGTH PTR      OCTA
L  **PLTDUMP**            STRING",86);
      CBLIST(EJECTPAGE);
      TMREOP (PLT$);
      # PUT OUT THE ATTRIBUTE TABLE # 
  
      FOR K = 0 STEP 1 UNTIL 10 DO W[K] = " ";
      FOR I = 1 STEP 1 UNTIL CCTPLTLEN DO 
        BEGIN 
          REAL$I = VIRTUAL(PLT$,I); 
          C<2,4>W[0] = DEC(I);
          C<8,1>W[0] = DEC(PL$SIGNEDFLG[REAL$I]); 
          C<1,1>W[1] = DEC(PL$SIGNFLAG[REAL$I]);
          C<4,1>W[1] = DEC(PL$FIGZERO[REAL$I]); 
          C<5,1>W[1] = DEC(PL$FIGSPACE[REAL$I]);
          C<6,1>W[1] = DEC(PL$FIGQUOTE[REAL$I]);
          C<7,1>W[1] = DEC(PL$FIGLOWV[REAL$I]); 
          C<8,1>W[1] = DEC(PL$FIGHIGHV[REAL$I]);
          C<1,3>W[2] = DEC(PL$CODE[REAL$I]);
          C<6,4>W[2] = DEC(PL$LINE[REAL$I]);
          C<1,3>W[3]=  DEC(PL$COLUMN[REAL$I]);
          C<5,4>W[3] = DEC(PL$LENGTH[REAL$I]);
          W[5] = OCT(PL$INFO[REAL$I],0,10); 
          W[6] = OCT(PL$INFO[REAL$I],10,10);
          #DUMP STRING PART#
           TEMP = PL$STRINGPTR[REAL$I]; 
           TEMP2 =PL$LENGTH[REAL$I];
           FOR TEMP3 = TEMP STEP 1 UNTIL
                       TEMP + (TEMP2 - 1) / 10 DO 
               BEGIN
               C<1,4>W[4] = DEC(TEMP3);   # STRING POINTER# 
               REAL$I = VIRTUAL(PLTSTR$,TEMP3); 
               W[8] = PLT$CHAR[REAL$I]; 
               CBLIST(SSP,OUT,90);
               FOR K = 0 STEP 1 UNTIL 8 DO W[K] = " ";
               END
        END 
      CBLIST(SSP,"  ** END OF PLTDUMP **  ",24);
      CBLIST(DEFSUBTITLE," ",1); #RESET SUBTITLE TO BLANK#
      TMRECL (PLT$);
      RETURN; 
    END 
  
CONTROL EJECT;
  ENTRY PROC CTXTDMP; 
    # DUMP OUT THE CTEXT #
    BEGIN 
      # DEFINE NAMES FOR CTEXT TYPE FIELD # 
      ARRAY[0:32];
      ITEM NAME$CTEXT C(0,0,10) =["**ERROR** ","CONDNAME  ",
                                  "*         ","DN-DEF    ",
                                  "DN-REF    ","=         ",
                                  "**        ",">         ",
                                  "(         ","<         ",
                                  "-         ",".         ",
                                  "+         ",")         ",
                                  "/         ","RESWORD   ",
                                  "PN-DEF    ","PN-REF    ",
                                  "SN-DEF    ","LITERAL   ",
                                  "DELIMITER ","LEVEL     ",
                                  "PICTURE   ","ERROR     ",
                                  "IMPLNAME  ","FILLER    ",
                                  "ENDDECL   ","LINECOUNT ",
                                  "LINAGECT  ","PAGECOUNT ",
                                   "DEBUGITEM ",":         ", 
                                  "HASHVALUE " ]; 
      CBLIST(DEFSUBTITLE, 
      "INDEX     KEY       COLUMN    TYPE      VALUE      FIELDS
     CTEXT",75);
      CBLIST(EJECTPAGE," ",1); # PAGE EJECT # 
      TMREOP (CTEXT$);
      CBLIST(SSP," ",1);
CONTROL EJECT;
      FOR I = 1 STEP 1 UNTIL CCTCTEXTLEN DO 
        BEGIN 
          FOR K = 0 STEP 1 UNTIL 10 DO
            W[K] = "          ";
          #ACCESS FIELDS FROM APPROPRIATE ATOM# 
          J = I/2;     #WHICH WORD# 
          IF I - J*2 EQ 1 THEN #1ST HALFWORD# 
            BEGIN 
            REAL$I = VIRTUAL(CTEXT$,J+1); 
            TEMP = CTEXTKEY1[REAL$I]; 
            TEMP1 = CTEXTCOLUMN1[REAL$I]; 
            TEMP2 = CTEXTTYPE1[REAL$I]; 
            TEMP3 = CTEXTVALUE1[REAL$I];
            TEMP4 = CTEXTATOM1[REAL$I]; 
            END 
          ELSE #2ND HALFWORD# 
            BEGIN 
            REAL$I = VIRTUAL(CTEXT$,J); 
            TEMP = CTEXTKEY2[REAL$I]; 
            TEMP1 = CTEXTCOLUMN2[REAL$I]; 
            TEMP2 = CTEXTTYPE2[REAL$I]; 
            TEMP3 = CTEXTVALUE2[REAL$I];
            TEMP4 = CTEXTATOM2[REAL$I]; 
            END 
          C<0,5>W[0] = DEC(I); #INDEX#
          IF TEMP EQ 1 THEN #KEY ELEMENT# 
            C<0,1>W[1] = "1"; 
          C<0,3>W[2] = DEC(TEMP1); #COLUMN# 
          # FORMAT TYPE FIELD # 
          IF TEMP2 LQ 32 THEN 
            C<0,10>W[3] = NAME$CTEXT[TEMP2];
          ELSE
            W[3] = "**ERROR** ";
          # SHOULD SPECIAL CASE RESERVED WORDS #
          C<0,5>W[4] = DEC(TEMP3); #VALUE#
          # FORMAT ATOM FIELDWISE IN DECIMAL #
          C<1,1>W[5] = DEC(TEMP); 
          C<2,1>W[5] = " "; 
          C<3,3>W[5] = DEC(TEMP1);
          C<6,1>W[5] = " "; 
          C<7,2>W[5] = DEC(TEMP2);
          C<9,1>W[5] = " "; 
          C<0,5>W[6] = DEC(TEMP3);
          #OUTPUT ATOM IN OCTAL#
          C<0,10>W[7] = OCT(TEMP4,10,10); 
          #OUTPUT ENTIRE ENTRY LINE#
          CBLIST(SSP,OUT,80); 
        END 
      CBLIST(SSP,"  ** END OF CTEXTDUMP **  ",26);
      CBLIST(DEFSUBTITLE," ",1); #RESET SUBTITLE TO BLANK#
      TMRECL (CTEXT$);
      RETURN; 
    END 
CONTROL EJECT;
ENTRY PROC PATDMP;
BEGIN 
ARRAY FIELDNAMES[27] S(1);
      ITEM FIELDNAME C(0,0,10) =
 ["ZERO      ","LENGTH    ","PTLOC     ","NUMLEN    ","REPLCNT   ", 
  "TYPE      ","NEBITS    ","COEFFSGN  ","EXPSIGN   ","DECPT     ", 
  "FLAGS     ","FLAG0     ","SGNPIC    ","FLAG1     ","FLAG2     ", 
  "FLAG3     ","FLAG4     ","FLAG5     ","FLAG6     ","FLAG7     ", 
  "FXDSGNLFT ","BWZ       ","FXDINSRT  ","FLTINSRT  ","ASTRSKFIL ", 
  "PATTOFF   ","EXPLEN    ","CKPROTECT "];
  
BASED ARRAY A$PRINTLINE[4] S(2);
BEGIN 
    ITEM NAME    C(0,0,10); 
    ITEM EQUALS  C(1,0,2);
    ITEM VALUE   C(1,12,8); 
END 
  
ITEM PRINTLINE C(100);
  
ARRAY A$ENTRYHEAD[0] S(2);
BEGIN 
    ITEM ENTRYHEAD     C(0,0,20); 
    ITEM EH1           C(0,0,12) = ["PAT ENTRY   "];
    ITEM EH2           C(1,12,8); 
END 
  
ARRAY TRUNCATE[0];
BEGIN 
    ITEM C8   C(0,0,8); 
    ITEM FILL C(0,48,2);
END 
  
DEF FIELD$       #J*5+K#; 
DEF NUMPATITEMS #28#;   #THIS MUST EQUAL THE LENGTH OF THE SWITCH 
                        LIST "PAT$FIELD".#
  
FUNC GETVALUE(FIELD,LOCINDEX) C(10);
BEGIN 
ITEM FIELD, LOCINDEX; 
  
SWITCH PAT$FIELD
F0,F1,F2,F3,F4,F5,F6,F7,F8,F9,F10,F11,F12,F13,F14,
F15,F16,F17,F18,F19,F20,F21,F22,F23,F24,F25,F26,F27;
  
REAL$I = VIRTUAL(PAT$,LOCINDEX);
  
GOTO PAT$FIELD[FIELD];
F0: GETVALUE = DEC(P$ZERO[REAL$I]); GOTO GVEND; 
F1: GETVALUE = DEC(P$LENGTH[REAL$I]); GOTO GVEND; 
F2: GETVALUE = DEC(P$PTLOC[REAL$I]); GOTO GVEND;
F3: GETVALUE = DEC(P$NUMLEN[REAL$I]); GOTO GVEND; 
F4: GETVALUE = DEC(P$REPLCNT[REAL$I]); GOTO GVEND;
F5: GETVALUE = DEC(P$TYPE[REAL$I]); GOTO GVEND; 
F6: GETVALUE = DEC(P$NEBITS[REAL$I]); GOTO GVEND; 
F7: GETVALUE = DEC(P$COEFFSGN[REAL$I]); GOTO GVEND; 
F8: GETVALUE = DEC(P$EXPSIGN[REAL$I]); GOTO GVEND;
F9: GETVALUE = DEC(P$DECPT[REAL$I]); GOTO GVEND;
F10: GETVALUE = DEC(P$FLAGS[REAL$I]); GOTO GVEND; 
F11: GETVALUE = DEC(P$FLAG0[REAL$I]); GOTO GVEND; 
F12: GETVALUE = DEC(P$SGNPIC[REAL$I]); GOTO GVEND;
F13: GETVALUE = DEC(P$FLAG1[REAL$I]); GOTO GVEND; 
F14: GETVALUE = DEC(P$FLAG2[REAL$I]); GOTO GVEND; 
F15: GETVALUE = DEC(P$FLAG3[REAL$I]); GOTO GVEND; 
F16: GETVALUE = DEC(P$FLAG4[REAL$I]); GOTO GVEND; 
F17: GETVALUE = DEC(P$FLAG5[REAL$I]); GOTO GVEND; 
F18: GETVALUE = DEC(P$FLAG6[REAL$I]); GOTO GVEND; 
F19: GETVALUE = DEC(P$FLAG7[REAL$I]); GOTO GVEND; 
F20: GETVALUE = DEC(P$FXDSGNLFT[REAL$I]); GOTO GVEND; 
F21: GETVALUE = DEC(P$BWZ[REAL$I]); GOTO GVEND; 
F22: GETVALUE = DEC(P$FXDINSRT[REAL$I]); GOTO GVEND;
F23: GETVALUE = DEC(P$FLTINSRT[REAL$I]); GOTO GVEND;
F24: GETVALUE = DEC(P$ASTRSKFIL[REAL$I]); GOTO GVEND; 
F25: GETVALUE = DEC(P$PATTOFF[REAL$I]); GOTO GVEND; 
F26: GETVALUE = DEC(P$EXPLEN[REAL$I]); GOTO GVEND;
F27: GETVALUE = DEC(P$CKPROTECT[REAL$I]); GOTO GVEND; 
GVEND: RETURN;
END 
# MAINLINE #
P<A$PRINTLINE> = LOC(PRINTLINE);
CBLIST(DEFSUBTITLE,"  ** PATDUMP **  ",17); 
CBLIST(EJECTPAGE);
CBLIST(SSP," ",1);
# MAIN LOOP # 
FOR I = 1 STEP 1 UNTIL CCTPATLEN DO 
BEGIN 
  C8[0] = DEC(I); 
  EH2[0] = C8[0]; 
  CBLIST(DBSP,ENTRYHEAD[0],20); 
  CBLIST(SSP," ",1);
  FOR J = 0 STEP 1 UNTIL 5 DO 
  BEGIN 
    PRINTLINE = " ";   #TO REMOVE PREVIOUS ENTRIES# 
    FOR K = 0 STEP 1 WHILE (FIELD$ LS NUMPATITEMS AND K LQ 4) DO
    BEGIN 
      # K IS INDEX INTO PRINTLINE,
        J*5+K (DEF"D AS "FIELD$") IS FIELD ARG FOR GETVALUE FUNC# 
      NAME[K] = FIELDNAME[FIELD$];
      EQUALS[K] = "= "; 
      C8[0] = GETVALUE(FIELD$,I); 
      VALUE[K] = C8[0]; 
    END 
    CBLIST(SSP,PRINTLINE,100);
  END 
CBLIST(SSP," ",1);
END 
CBLIST(SSP,"  ** END OF PATDUMP **  ",24);
CBLIST(DEFSUBTITLE," ",1);   #ERASE SUBTITLE# 
RETURN; 
END # END OF PATDUMP #
  
  
CONTROL EJECT;
ENTRY PROC CCTDMP;
BEGIN 
   DEF CCTENTLITLEN #12#; 
   DEF CCTENTMAXLEN #60#; 
   DEF OCTWORDLEN #20#; 
  
   DEF CHAR01 #1#;
   DEF CHAR10 #10#; 
   DEF CHAR30 #30#; 
   DEF CHAR60 #60#; 
  
   DEF ZERO #0#;
   DEF LINELENGTH #132#;
   DEF SPACES #"
  
    "#; 
  
# 
THE DEFS FOLLOWING ARE TAB POSITIONS FOR
THE DIFFERENT TYPES OF DATA IN THE CCT
# 
  
   DEF CHARTAB1 #25#; 
   DEF CHARTAB2 #50#; 
   DEF C$OCTTAB1 #6#; 
   DEF C$OCTTAB2 #27#;
   DEF C$OCTTAB3 #48#;
   DEF C$OCTTAB4 #69#;
   DEF C$OCTTAB5 #90#;
   DEF C$OCTTAB6 #111#; 
   DEF DECTAB1 #25#;
   DEF DECTAB2 #35#;
   DEF OCTTAB1 #50#;
   DEF OCTTAB2 #60#;
   DEF OCTTAB3 #66#;
   DEF OCTTAB4 #72#;
   DEF OCTTAB5 #78#;
   DEF BITTAB1 #25#;
   DEF BITTAB2 #35#;
  
   ITEM LINE C(LINELENGTH); 
   ITEM TEMPCCTCHAR C(CCTENTMAXLEN);
  
PROC CHARDUMP(CCTENTVAL,CCTENTVALLEN,CCTENTLIT);
BEGIN 
   ITEM CCTENTVAL C(CCTENTMAXLEN),
        CCTENTLIT C(CCTENTLITLEN),
        CCTENTVALLEN I; 
CBLIST(SSP,"     ",5);
LINE = SPACES;
#PUT CCTNAME ONTO OUTPUT LINE#
C<ZERO,CCTENTLITLEN> LINE = CCTENTLIT;
C<CHARTAB1,6> LINE = "CHAR =";
#PUT ASSOCIATED VALUE ONTO OUTPUT LINE# 
C<CHARTAB2,CCTENTVALLEN> LINE = CCTENTVAL;
CBLIST(SSP,LINE,LINELENGTH);
LINE = SPACES;
C<ZERO,5> LINE = "OCT ="; 
IF CCTENTVALLEN EQ CHAR01 
THEN C<C$OCTTAB1,2> LINE = OCT(CCTENTVAL,0,2);
ELSE
  BEGIN 
  IF CCTENTVALLEN GQ CHAR10 
  THEN
    BEGIN 
    C<C$OCTTAB1,OCTWORDLEN> LINE = OCT(CCTENTVAL,0,OCTWORDLEN); 
    IF CCTENTVALLEN GQ CHAR30 
    THEN
      BEGIN 
      C<C$OCTTAB2,OCTWORDLEN> LINE = OCT(CCTENTVAL,20,OCTWORDLEN);
      C<C$OCTTAB3,OCTWORDLEN> LINE = OCT(CCTENTVAL,40,OCTWORDLEN);
      IF CCTENTVALLEN EQ 60 
      THEN
        BEGIN 
        C<C$OCTTAB4,OCTWORDLEN> LINE = OCT(CCTENTVAL,60,OCTWORDLEN);
        C<C$OCTTAB5,OCTWORDLEN> LINE = OCT(CCTENTVAL,80,OCTWORDLEN);
        C<C$OCTTAB6,OCTWORDLEN> LINE = OCT(CCTENTVAL,100,OCTWORDLEN); 
        END 
      END 
    END 
  END 
CBLIST(SSP,LINE,LINELENGTH);
END  #OF CHARACTER DUMPING PROCEDURE# 
  
PROC INTEGERDUMP (CCTENTVAL,CCTENTLIT); 
BEGIN 
   ITEM CCTENTVAL I,
        CCTENTLIT C(CCTENTLITLEN);
LINE = SPACES;
#PUT CCTNAME ONTO OUTPUT LINE#
C<ZERO,CCTENTLITLEN> LINE = CCTENTLIT;
#PUT ASSOCIATED VALUES ONTO OUTPUT LINE#
C<DECTAB1,5> LINE = "DEC =";
C<DECTAB2,10> LINE = DEC(CCTENTVAL);
C<OCTTAB1,5> LINE = "OCT =";
C<OCTTAB2,5> LINE = OCT(CCTENTVAL,0,5); 
C<OCTTAB3,5> LINE = OCT(CCTENTVAL,5,5); 
C<OCTTAB4,5> LINE = OCT(CCTENTVAL,10,5);
C<OCTTAB5,5> LINE = OCT(CCTENTVAL,15,5);
CBLIST(SSP,LINE,LINELENGTH);
END  #OF INTEGER DUMPING PROCEDURE# 
  
PROC BITDUMP (CCTENTVAL,CCTENTLIT); 
BEGIN 
   ITEM CCTENTVAL B,
        CCTENTLIT C(CCTENTLITLEN);
LINE = SPACES;
#PUT CCTNAME ONTO OUTPUT LINE#
C<ZERO,CCTENTLITLEN> LINE = CCTENTLIT;
#PUT ASSOCIATED VALUE ONTO OUTPUT LINE# 
C<BITTAB1,5> LINE = "BIT =";
IF CCTENTVAL
THEN C<BITTAB2,4> LINE = "TRUE";
ELSE C<BITTAB2,5> LINE = "FALSE"; 
CBLIST(SSP,LINE,LINELENGTH);
END  #OF BIT DUMPING PROCEDURE# 
  
CBLIST(DEFSUBTITLE,"  ** CCT DUMP **  ",18);
CBLIST(EJECTPAGE,"     ",5);  #SET TO NEW PAGE# 
CBLIST(SSP,"  ** CHARACTER DATA ITEMS **  ",30);
  
# 
THE FOLLOWING ARE CHARACTER  1  DATA ITEMS
# 
  
TEMPCCTCHAR  =      C<ZERO,CHAR01> CCTDECPOINT[0];
CHARDUMP    ((TEMPCCTCHAR),CHAR01,"CCTDECPOINT ");
  
TEMPCCTCHAR  =      C<ZERO,CHAR01> CCTCURRSIGN [0]; 
CHARDUMP    ((TEMPCCTCHAR),CHAR01,"CCTCURRSIGN ");
  
TEMPCCTCHAR  =      C<ZERO,CHAR01> CCTLOVALUE[0]; 
CHARDUMP    ((TEMPCCTCHAR), CHAR01, "CCTLOVALUE");
  
TEMPCCTCHAR  =      C<ZERO,CHAR01> CCTHIVALUE[0]; 
CHARDUMP    ((TEMPCCTCHAR), CHAR01, "CCTHIVALUE");
  
# 
THE FOLLOWING ARE CHARACTER  10  DATA ITEMS 
# 
  
TEMPCCTCHAR  =      C<ZERO,CHAR10> CCTSOURCEFIL[0]; 
CHARDUMP    ((TEMPCCTCHAR),CHAR10,"CCTSOURCEFIL");
  
TEMPCCTCHAR  =      C<ZERO,CHAR10> CCTLIBFILE  [0]; 
CHARDUMP    ((TEMPCCTCHAR),CHAR10,"CCTLIBFILE  ");
  
TEMPCCTCHAR  =      C<ZERO,CHAR10> CCTSCLISTFIL[0]; 
CHARDUMP    ((TEMPCCTCHAR),CHAR10,"CCTSCLISTFIL");
  
TEMPCCTCHAR  =      C<ZERO,CHAR10> CCTASLISTFIL[0]; 
CHARDUMP    ((TEMPCCTCHAR),CHAR10,"CCTASLISTFIL");
  
TEMPCCTCHAR  =      C<ZERO,CHAR10> CCTXRLISTFIL[0]; 
CHARDUMP    ((TEMPCCTCHAR),CHAR10,"CCTXRLISTFIL");
  
TEMPCCTCHAR  =      C<ZERO,CHAR10> CCTDGLISTFIL[0]; 
CHARDUMP    ((TEMPCCTCHAR),CHAR10,"CCTDGLISTFIL");
  
TEMPCCTCHAR  =      C<ZERO,CHAR10> CCTCHKOUT   [0]; 
CHARDUMP    ((TEMPCCTCHAR),CHAR10,"CCTCHKOUT   ");
  
TEMPCCTCHAR  =      C<ZERO,CHAR10> CCTOBJFILE  [0]; 
CHARDUMP    ((TEMPCCTCHAR),CHAR10,"CCTOBJFILE  ");
  
TEMPCCTCHAR  =      C<ZERO,CHAR10> CCTCOMPASS  [0]; 
CHARDUMP    ((TEMPCCTCHAR),CHAR10,"CCTCOMPASS  ");
  
TEMPCCTCHAR  =      C<ZERO,CHAR10> CCTSSLIB [0];
CHARDUMP    ((TEMPCCTCHAR), CHAR10, "CCTSSLIB");
TEMPCCTCHAR  =      C<ZERO,CHAR10>CCTUARFILE[0];
CHARDUMP    ((TEMPCCTCHAR),CHAR10,"CCTUARFILE  ");
  
CHARDUMP    (CCTPROGRAMID[0],CHAR10,"CCTPROGRAMID");
CHARDUMP    (CCTPROGRI0,CHAR10,"CCTPROGRI0  "); 
CHARDUMP    (CCTPROGRI1,CHAR10,"CCTPROGRI1  "); 
CHARDUMP    (CCTPROGRI2,CHAR10,"CCTPROGRI2  "); 
CHARDUMP    (CCTDATE,CHAR10,"CCTDATE     ");
  
# 
THE FOLLOWING ARE CHARACTER  30  DATA ITEMS 
# 
  
CHARDUMP    (CCTSSNAME[0],CHAR30,"CCTSSNAME   "); 
CHARDUMP    (CCTSCHNAME[0],CHAR30,"CCTSCHNAME  ");
  
  
# 
THE FOLLOWING ARE INTEGER DATA ITEMS
# 
  
CBLIST(EJECTPAGE,"     ",5);    #SET TO NEW PAGE# 
CBLIST(SSP,"  ** INTEGER DATA ITEMS **  ",28);
CBLIST(SSP,"     ",5);      #SPACE UNDER HEADER#
INTEGERDUMP ((CCTCTEXTLEN ),"CCTCTEXTLEN ");
INTEGERDUMP ((CCTEDCTXLEN ),"CCTEDCTXLEN ");
INTEGERDUMP ((CCTEDCTXADDR),"CCTEDCTXADDR");
INTEGERDUMP ((CCTDBFSCTXT ),"CCTDBFSCTXT ");
INTEGERDUMP ((CCTDDCTXLEN ),"CCTDDCTXLEN ");
INTEGERDUMP ((CCTDDCTXADDR),"CCTDDCTXADDR");
INTEGERDUMP ((CCTRSCTXLEN ),"CCTRSCTXLEN ");
INTEGERDUMP ((CCTRSCTXADDR),"CCTRSCTXADDR");
INTEGERDUMP ((CCTPDCTXLEN ),"CCTPDCTXLEN ");
INTEGERDUMP ((CCTPDCTXADDR),"CCTPDCTXADDR");
INTEGERDUMP ((CCTETEXTLEN ),"CCTETEXTLEN ");
INTEGERDUMP ((CCTGTEXTLEN ),"CCTGTEXTLEN ");
INTEGERDUMP ((CCTOTEXTLEN ),"CCTOTEXTLEN ");
INTEGERDUMP ((CCTAWRTLEN  ),"CCTAWRTLEN  ");
INTEGERDUMP ((CCTDNTLEN   ),"CCTDNTLEN   ");
INTEGERDUMP ((CCTPNTLEN   ),"CCTPNTLEN   ");
INTEGERDUMP ((CCTPLTLEN   ),"CCTPLTLEN   ");
INTEGERDUMP ((CCTINTLEN   ),"CCTINTLEN   ");
INTEGERDUMP ((CCTPLSTLEN  ),"CCTPLSTLEN  ");
INTEGERDUMP ((CCTSPBTLEN  ),"CCTSPBTLEN  ");
INTEGERDUMP ((CCTDNATLEN  ),"CCTDNATLEN  ");
INTEGERDUMP ((CCTFNATLEN  ),"CCTFNATLEN  ");
INTEGERDUMP ((CCTPNATLEN  ),"CCTPNATLEN  ");
INTEGERDUMP ((CCTAUXTLEN  ),"CCTAUXTLEN  ");
INTEGERDUMP ((CCTPATLEN   ),"CCTPATLEN   ");
INTEGERDUMP ((CCTLATLEN   ),"CCTLATLEN   ");
INTEGERDUMP ((CCTPDLITLEN ),"CCTPDLITLEN ");
INTEGERDUMP ((CCTPDLITADDR),"CCTPDLITADDR");
INTEGERDUMP ((CCTEDITPLEN ),"CCTEDITPLEN ");
INTEGERDUMP ((CCTEDITPADDR),"CCTEDITPADDR");
INTEGERDUMP ((CCTLPOOLLEN ),"CCTLPOOLLEN ");
INTEGERDUMP ((CCTFDRDLEN  ),"CCTFDRDLEN  ");
INTEGERDUMP ((CCTCIDTLEN  ),"CCTCIDTLEN  ");
INTEGERDUMP ((CCTRDCDILEN ),"CCTRDCDILEN ");
INTEGERDUMP ((CCTRDCDIADDR),"CCTRDCDIADDR");
INTEGERDUMP ((CCTRPAUXLEN ),"CCTRPAUXLEN ");
INTEGERDUMP ((CCTRWTABLEN ),"CCTRWTABLEN ");
INTEGERDUMP ((CCTPDXRV    ),"CCTPDXRV    ");
INTEGERDUMP ((CCTRFTLEN   ),"CCTRFTLEN   ");
INTEGERDUMP ((CCTDLTLEN   ),"CCTDLTLEN   ");
INTEGERDUMP ((CCTCIDTADDR),"CCTCIDTADDR");
INTEGERDUMP ((CCTRWTABADDR),"CCTRWTABADDR");
INTEGERDUMP ((CCTLDSETLEN ),"CCTLDSETLEN"); 
INTEGERDUMP ((CCTANSIDIAG ),"CCTANSIDIAG ");
INTEGERDUMP ((CCTRWVRBLINE),"CCTRWVRBLINE");
  INTEGERDUMP((CCTFDLTLEN),"CCTFDLTLEN"); 
  
CBLIST(SSP,"     ",5);
  
INTEGERDUMP ((CCTMSECLEN  [ 1]),"CCTMSECLEN 1");
INTEGERDUMP ((CCTMSECLEN  [ 2]),"CCTMSECLEN 2");
INTEGERDUMP ((CCTMSECLEN  [ 3]),"CCTMSECLEN 3");
INTEGERDUMP ((CCTMSECLEN  [ 4]),"CCTMSECLEN 4");
INTEGERDUMP ((CCTMSECLEN  [ 5]),"CCTMSECLEN 5");
INTEGERDUMP ((CCTMSECLEN  [ 6]),"CCTMSECLEN 6");
INTEGERDUMP ((CCTMSECLEN  [ 7]),"CCTMSECLEN 7");
INTEGERDUMP ((CCTMSECLEN  [ 8]),"CCTMSECLEN 8");
INTEGERDUMP ((CCTMSECLEN  [ 9]),"CCTMSECLEN 9");
INTEGERDUMP ((CCTMSECLEN  [10]),"CCTMSECLEN10");
INTEGERDUMP ((CCTMSECLEN  [11]),"CCTMSECLEN11");
INTEGERDUMP ((CCTMSECLEN  [12]),"CCTMSECLEN12");
INTEGERDUMP ((CCTMSECLEN  [13]),"CCTMSECLEN13");
INTEGERDUMP ((CCTMSECLEN  [14]),"CCTMSECLEN14");
INTEGERDUMP ((CCTMSECLEN  [15]),"CCTMSECLEN15");
INTEGERDUMP ((CCTMSECLEN  [16]),"CCTMSECLEN16");
INTEGERDUMP ((CCTMSECLEN  [17]),"CCTMSECLEN17");
INTEGERDUMP ((CCTMSECLEN  [18]),"CCTMSECLEN18");
INTEGERDUMP ((CCTMSECLEN  [19]),"CCTMSECLEN19");
  
CBLIST(SSP,"     ",5);
  
INTEGERDUMP ((CCTPHASEID  ),"CCTPHASEID  ");
INTEGERDUMP ((CCTLASTREPOR),"CCTLASTREPOR");
INTEGERDUMP ((CCTREPORTCUT),"CCTREPORTCUT");
INTEGERDUMP ((CCTDCLUPPBND),"CCTDCLUPPBND");
INTEGERDUMP ((CCTDCLLOWBND),"CCTDCLLOWBND");
INTEGERDUMP ((CCTEDLINENUM),"CCTEDLINENUM");
INTEGERDUMP ((CCTDDLINENUM),"CCTDDLINENUM");
INTEGERDUMP ((CCTRSLINENUM),"CCTRSLINENUM");
INTEGERDUMP ((CCTPDLINENUM),"CCTPDLINENUM");
INTEGERDUMP ((CCTLATDDLNGT),"CCTLATDDLNGT");
INTEGERDUMP ((CCTLATPDLNGT),"CCTLATPDLNGT");
INTEGERDUMP ((CCTCLOCKUNIT),"CCTCLOCKUNIT");
INTEGERDUMP ((CCTRERUNCOND),"CCTRERUNCOND");
INTEGERDUMP ((CCTRPSECTNAM),"CCTRPSECTNAM");
INTEGERDUMP ((CCTLSTWSDNAT),"CCTLSTWSDNAT");
INTEGERDUMP ((CCTLASTLINE ),"CCTLASTLINE ");
INTEGERDUMP ((CCTDIAGLEVEL),"CCTDIAGLEVEL");
INTEGERDUMP ((CCTSEGLIMIT ),"CCTSEGLIMIT ");
INTEGERDUMP ((CCTMODENUMB ),"CCTMODENUMB ");
INTEGERDUMP ((CCTCOREOPTN ),"CCTCOREOPTN ");
INTEGERDUMP ((CCTBRTABBASE),"CCTBRTABBASE");
INTEGERDUMP ((CCTLSTGLPN  ),"CCLSTGLPN  "); 
INTEGERDUMP ((CCTCAPCOUNT ),"CCTCAPCOUNT ");
INTEGERDUMP ((CCTINITTABBS),"CCTINITTABBS");
INTEGERDUMP ((CCTINITTABLN),"CCTINITTABLN");
  
CBLIST(SSP,"     ",5);
  
INTEGERDUMP ((CCTMAXMNEM  ),"CCTMAXMNEM  ");
INTEGERDUMP ((CCTLINAGE   ),"CCTLINAGE   ");
INTEGERDUMP ((CCTPNCOUNT  ),"CCTPNCOUNT  ");
INTEGERDUMP ((CCTPNINDEX  ),"CCTPNINDEX  ");
INTEGERDUMP ((CCTFDDNATPTR),"CCTFDDNATPTR");
INTEGERDUMP ((CCTWSDNATPTR),"CCTWSDNATPTR");
INTEGERDUMP ((CCTLKDNATPTR),"CCTLKDNATPTR");
INTEGERDUMP ((CCTCDDNATPTR),"CCTCDDNATPTR");
INTEGERDUMP ((CCTRSDNATPTR),"CCTRSDNATPTR");
INTEGERDUMP ((CCTCSDNATPTR),"CCTCSDNATPTR");
INTEGERDUMP ((CCTSSDNATPTR),"CCTSSDNATPTR");
INTEGERDUMP ((CCTFIRSTAN  ),"CCTFIRSTAN  ");
INTEGERDUMP ((CCTLASTAN   ),"CCTLASTAN   ");
INTEGERDUMP ((CCTCOLLSEQ  ),"CCTCOLLSEQ  ");
INTEGERDUMP ((CCTIPCSET   ),"CCTIPCSET   ");
INTEGERDUMP ((CCTPERFTIMES),"CCTPERFTIMES");
INTEGERDUMP ((CCTINTRDBUG ),"CCTINTRDBUG ");
INTEGERDUMP  ((CCTFIPSLEVEL),"CCTFIPSLEVEL"); 
INTEGERDUMP ((CCTSSDATE   ),"CCTSSDATE   ");
INTEGERDUMP ((CCTSSTIME   ),"CCTSSTIME   ");
INTEGERDUMP((CCTMAXMNUM  ), "CCTMAXMNUM  ");
  
CBLIST(SSP,"     ",5);
  
INTEGERDUMP ((CCTPLTLOPTR ),"CCTPLTLOPTR ");
INTEGERDUMP ((CCTOVLNAME),"CCTOVLNAME");
INTEGERDUMP ((CCTOVCOUNT  ),"CCTOVCOUNT  ");
INTEGERDUMP ((CCTOBJLSTLEN),"CCTOBJLSTLEN");
INTEGERDUMP ((CCTINITCD   ),"CCTINITCD   ");
INTEGERDUMP ((CCTMAXMNUM  ),"CCTMAXMNUM  ");
INTEGERDUMP ((CCTNAMETLEN ),"CCTNAMETLEN ");
INTEGERDUMP ((CCTDATFORMAT),"CCTDATFORMAT");
  
# 
THE FOLLOWING ARE BIT DATA ITEMS
# 
  
CBLIST(EJECTPAGE,"     ",5); #SET TO NEW PAGE#
CBLIST(SSP,"  ** BIT DATA ITEMS **  ",24);
  
INTEGERDUMP ((CCTFLAGINFO [0]),"CCTFLAGINFO "); #ALL FLAGS# 
BITDUMP     ((CCTDECPTCOMM[0]),"CCTDECPTCOMM"); 
BITDUMP     ((CCTREPORTSEC[0]),"CCTREPORTSEC"); 
BITDUMP     ((CCTDEBUGMODE[0]),"CCTDEBUGMODE"); 
BITDUMP     ((CCTSUBPROGR [0]),"CCTSUBPROGR "); 
BITDUMP     ((CCTSIGNLEAD [0]),"CCTSIGNLEAD "); 
BITDUMP     ((CCTSIGNSEPAR[0]),"CCTSIGNSEPAR"); 
BITDUMP     ((CCTHILO     [0]),"CCTHILO     "); 
BITDUMP     ((CCTQUOTEAPOS[0]),"CCTQUOTEAPOS"); 
BITDUMP     ((CCTSUBSCHECK[0]),"CCTSUBSCHECK"); 
BITDUMP     ((CCTSUBSOPTIM[0]),"CCTSUBSOPTIM"); 
BITDUMP     ((CCTOSISNOS  [0]),"CCTOSISNOS  "); 
BITDUMP     ((CCTSYNTXONLY[0]),"CCTSYNTXONLY"); 
BITDUMP     ((CCTFORCEDOBJ[0]),"CCTFORCEDOBJ"); 
BITDUMP     ((CCTSUPPREXEC[0]),"CCTSUPPREXEC"); 
BITDUMP     ((CCTSOURCLIST[0]),"CCTSOURCLIST"); 
BITDUMP     ((CCTASSEMLIST[0]),"CCTASSEMLIST"); 
BITDUMP     ((CCTXREFLIST [0]),"CCTXREFLIST "); 
BITDUMP     ((CCTOBJCTDECK[0]),"CCTOBJCTDECK"); 
BITDUMP     ((CCTMEMORYMAP[0]),"CCTMEMORYMAP"); 
BITDUMP     ((CCTSECTION  [0]),"CCTSECTION  "); 
BITDUMP     ((CCTALTER    [0]),"CCTALTER    "); 
BITDUMP     ((CCTGOTO     [0]),"CCTGOTO     "); 
BITDUMP     ((CCTGOTODEPND[0]),"CCTGOTODEPND"); 
BITDUMP     ((CCTALTINDSEG[0]),"CCTALTINDSEG"); 
BITDUMP     ((CCTANALSO   [0]),"CCTANALSO   "); 
BITDUMP     ((CCTSEGMENTS [0]),"CCTSEGMENTS "); 
BITDUMP     ((CCTCOMPC1[0]),   "CCTCOMPC1   "); 
BITDUMP     ((CCTUNPACKC1[0]), "CCTUNPACKC1 "); 
BITDUMP     ((CCTMAINSUB[0]),  "CCTMAINSUB  "); 
BITDUMP     ((CCTLBZ[0]),      "CCTLBZ      "); 
BITDUMP     ((CCTTRACE[0]),    "CCTTRACE    "); 
BITDUMP     ((CCTDEBUGLINE),   "CCTDEBUGLINE"); 
BITDUMP     ((CCTDIAGTT[0]),   "CCTDIAGTT   "); 
BITDUMP     ((CCTICHKOUT[0]),  "CCTICHKOUT  "); 
BITDUMP     ((CCT1STCOMPIL[0]),"CCT1STCOMPIL"); 
BITDUMP    ((CCTDBTBSTATS   ), "CCTDBTBSTATS"); 
BITDUMP     ((CCTCMU[0]),      "CCTCMU      "); 
BITDUMP     ((CCTABORT[0]),    "CCTABORT    "); 
BITDUMP     ((CCTRFCHECK     ),"CCTRFCHECK  "); 
BITDUMP    ((CCTCHKCOMP1    ), "CCTCHKCOMP1 "); 
BITDUMP    ((CCTTIMRPT      ), "CCTTIMRPT   "); 
BITDUMP     ((CCTMIPOO),       "CCTMIPOO    "); 
BITDUMP     ((CCTSMVERB)      ,"CCTSMVERB   "); 
BITDUMP     ((CCTFDLCDCS)     ,"CCTFDLCDCS  "); 
BITDUMP     ((CCTFDL),         "CCTFDL      "); 
BITDUMP     ((CCTPSQ),         "CCTPSQ      "); 
BITDUMP     ((CCTNOSTERM),     "CCTNOSTERM  "); 
BITDUMP     ((CCTDPARAM),      "CCTDPARAM   "); 
BITDUMP     ((CCTSUBONLY),     "CCTSUBONLY  "); 
BITDUMP     ((CCTTAF),         "CCTTAF      "); 
BITDUMP     ((CCTNOEDIT),      "CCTNOEDIT   "); 
BITDUMP     ((CCTLEFT77),      "CCTLEFT77   "); 
BITDUMP     ((CCTUARWANTED),   "CCTUARWANTED"); 
BITDUMP     ((CCTIDBUG),       "CCTCIDBUG   "); 
BITDUMP     ((CCTTDF),         "CCTTDF      "); 
  
CBLIST(SSP,"     ",5);
CBLIST(SSP,"  ** END OF CCT DUMP **  ",25); 
CBLIST(DEFSUBTITLE,"     ",5);      #ERASE SUB-TITLE# 
  
RETURN; 
END  #OF CCT DUMPING PROCEDURE# 
  
ENTRY PROC ETEXTDMP;
BEGIN 
   RETURN;
END 
  
  
  
ENTRY PROC RFTDMP;
BEGIN 
   RETURN;
END 
  
  
ENTRY PROC RPADMP;
BEGIN 
   RETURN;
END 
CONTROL EJECT;
  ENTRY PROC SPBTDMP; 
    #DUMP THE SORT PROCEDURE BOUNDARY TABLE#
    BEGIN 
      CBLIST(DEFSUBTITLE," INDEX    LOBOUND   HIBOUND   LINE  COL   PROC
    STATUS    TYPE  VERB  DNAT    OCTAL               ** SPBT **",110); 
      CBLIST(EJECTPAGE);
      TMREOP (SPBT$); 
      FOR I = 1 STEP 1 UNTIL CCTSPBTLEN DO
        BEGIN 
          FOR K = 0 STEP 1 UNTIL 11 DO
            W[K] = "          ";
          REAL$I = VIRTUAL(SPBT$,I);
          C<1,5>W[0] = DEC(I);
          C<0,5>W[1] = DEC(SPBT$LOBOUND[REAL$I]); 
          C<0,5>W[2] = DEC(SPBT$HIBOUND[REAL$I]); 
          C<0,5>W[3] = DEC(SPBT$LINE[REAL$I]);
          C<6,3>W[3] = DEC(SPBT$COLUMN[REAL$I]);
          C<2,5>W[4] = DEC(SPBT$PROC[REAL$I]);
          C<0,5>W[5] = DEC(SPBT$STATUS[REAL$I]);
          C<0,5>W[6] = DEC(SPBT$TYPE[REAL$I]);
          C<7,1>W[6] = DEC(SPBT$VERB[REAL$I]);
          C<2,5>W[7] = DEC(SPBT$DNAT[REAL$I]);
          W[8] = OCT(SPBT$WORD1[REAL$I],0,10);
          W[9] = OCT(SPBT$WORD1[REAL$I],10,10); 
          W[10] = OCT(SPBT$WORD2[REAL$I],0,10); 
          W[11] = OCT(SPBT$WORD2[REAL$I],10,10);
          CBLIST(SSP,OUT,120);
        END 
      CBLIST(SSP,"  ** END OF SPBTDUMP **  ",25); 
      CBLIST(DEFSUBTITLE," ",1);
      TMRECL (SPBT$); 
      RETURN; 
    END 
CONTROL EJECT;
ENTRY PROC RPDMP; 
BEGIN 
   RETURN;
END 
  
  
END 
$END
TERM
