*COMDECK RPROCS 
          ITEM   P1,P2,P3, C1 C(7); 
  
          $BEGIN
          ITEM   TAB          I = 0,
                 DBCTEMP      C(120); 
  
          XREF  FUNC DEC C(10); 
          XREF  PROC  CBLIST; 
          $END
          CONTROL EJECT;
  # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *  #
  # *  THIS MODULE CONTAINS THE FOLLOWING REPORT WRITER TABLE        * #
  # *  MANAGEMENT ROUTINES:                                          * #
  # *     RPAUXPTR---- A FUNCTION.  IT IS PASSED A DNAT POINTER      * #
  # *                  TO A REPORT SECTION ITEM AND RETURNS THE      * #
  # *                  RPAUXPTR THAT IS ASSOCIATED WITH THAT DNAT.   * #
  # *     SETRPAUXPTR--A PROC.  IT IS PASSED A DNAT POINTER TO A     * #
  # *                  REPORT SECTION ITEM AND A POINTER TO AN RPAUX * #
  # *                  TABLE ENTRY.  IT STORES THE RPAUX POINTER IN  * #
  # *                  THE RPAUXPTR TABLE ASSOCIATED WITH THE DNAT.  * #
  # *                                                                * #
  # *     RWGET--------A FUNCTION.  IT IS PASSED THE DESCRIPTOR  OF A* #
  # *                  FIELD IN A REPORT TABLE ENTRY AND A POINTER   * #
  # *                  TO THE ENTRY.  IT RETURNS THE CONTENTS OF THE * #
  # *                  FILED                                         * #
  # *                                                                * #
  # *     RWSET--------A PROC. IT IS PASSED THE SAME PARAMETERS AS   * #
  # *                  RWGET IN ADDITION TO A VALUE.  IT STORES THE  * #
  # *                  VALUE IN THE SPECIFIED FIELD.                 * #
  # *                                                                * #
  # *     RTINITIATE---A PROC.  IT IS PASSED THE DESCRIPTOR OF HTE   * #
  # *                  LINK FIELD OF A REPORT TABLE.  IT ALLOCATES   * #
  # *                  THE INITIAL ENTRY OF THE TABLE.               * #
  # *                                                                * #
  # *     GETNEXT------A PROC.  IT IS PASSED THE DESCRIPTOR OF THE   * #
  # *                  LINK FIELD OF A REPORT TABLE.  IT ALLOCATES   * #
  # *                  A NEW ENTRY, LINKS IT TO THE PREVIOUS ENTRY,  * #
  # *                  SETS THE CURRENT POINTER FOR THE TABLE TO     * #
  # *                  THE INDEX OF THE PREVIOUS ENTRY AND THE NEXT  * #
  # *                  POINTER TO THE INDEX OF THE NEW ENTRY.        * #
  # *     RWGET1-------LIKE RWGET EXCEPT IT IS NOT PASSED A POINTER  * #
  # *                  TO AN ENTRY.  INSTEAD IT USES THE VALUE OF THE* #
  # *                  CURRENT POINTER.                              * #
  # *                                                                * #
  # *     RWSET1-------LIKE RWSET EXCEPT IT IS NOT PASSED A POINTER  * #
  # *                  TO AN ENTRY.  INSTEAD, IT USES THE VALUE OF   * #
  # *                  THE CURRENT POINTER OF THE TABLE.             * #
  # *                                                                * #
  # *  STRUCTURE OF THE REPORT WRITER TABLES.                        * #
  # *                                                                * #
  # *      ALL OF THE REPORT WRITER TABLES ARE BUILT IN THE BLOCK RWT* #
  # *  WHOSE POINTER VARIABLE IS IN THE COMMON BLOCK RWTCOMM.  THIS  * #
  # *  BLOCK IS DIVIDED INTO THREE SECTIONS, THE RPAUXPTR TABLE, THE * #
  # *  RPAUX TABLE, AND THE REPORT TABLES.                           * #
  # *                                                                * #
  # *  1. RPAUXPTR TABLE.  THERE IS AN ENTRY IN THIS TABLE FOR EACH  * #
  # *     DNAT IN THE REORT SECTION, THUS ITS SIZE IS KNOWN AND FIXED* #
  # *     AT THE BEGINNING OF THE RPARSER.  IT IS ALLOCATED AT THE   * #
  # *     BEGINNING OF THE RWT BLOCK BY RP$SECTIONRT WHICH IS THE    * #
  # *     SUBROUTINE THAT IS CALLED WHEN THE DATA NAME DEFITION CTEXT* #
  # *     ATOM FOR THE REPORT SECTION HEADER IS RECOGNIZED BY THE    * #
  # *     SYNTAX TABLES.  EACH ENTRY CONTAINS 15 BITS AND THEY ARE   * #
  # *     PACKED 4 TO A WORD.  THE CONTENTS OF AN ENTRY IS A POINTER * #
  # *     TO THE BEGINNING OF A SERIES OF RPAUX TABLE ENTRIES THAT   * #
  # *     ARE ASSOCIATED WITH THE CORRESPONDING DNAT.  THIS TABLE IS * #
  # *     ONLY REFERENCED BY THE ROUTINES RPAUXPTR AND SETRPAUXPTR.  * #
  # *                                                                * #
  # *  2. RPAUX TABLE.  THIS TABLE IS BUILT BY THE SYNTAX TABLE      * #
  # *     SUBROUTINES IN R$SUBS.  IT IS BUILT IN RWT IMMEDIATELY     * #
  # *     FOLLOWING THE RPAUXPTR TABLE.  EACH ENTRY IS ONE WORD LONG * #
  # *     AND IS ASSOCIATED WITH A DNAT ENTRY VIA THE RPAUXPTR TABEL.* #
  # *     IF MORE THAN ONE RPAUX ENTRY IS ASSOCIATED WITH ONE DNAT   * #
  # *     ENTRY, THEN THE RPAUXPTR ENTRY FOR THE DNAT ENTRY WILL     * #
  # *     POINT TO THE FIRST RPAUX ENTRY AND THE OTHERS WILL SEQUEN- * #
  # *     TIALLY FOLLOW THE FIRST.  RPAUX ENTRIES ARE NOT EXPLICITLY * #
  # *     LINKED TOGETHER AS ARE THE ENTRIES IN THE REPORT TABLES.   * #
  # *     GETNEXT IS NOT USED TO ALLOCATE A NEW RPAUX ENTRY, THE HIGH* #
  # *     WATER MARK FOR THE RWT (RWTHWM) IS JUST INCREMENTED BY.    * #
  # *     ALL ACCESSING OF THE RPAUX TABLE IS DONE VIA RWGET AND     * #
  # *     RWSET.  RWGET1 AND RWSET1 CANNOT BE USED SINCE THE RPAUX   * #
  # *     TABLE DOES NOT HAVE IMPLICIT POINTERS.                     * #
  # *     THE SIZE OF THE RPAUX TABLE IS FIXED AT THE END OF SYNTAX  * #
  # *     ANALYSIS OF THE REPORT SECTION.  IT WILL BE REFERENCED AND * #
  # *     POSSIBLY ALTERED BY RANALYZ AND RGEN BUT IT WILL NOT GROW.* # 
  # *                                                                * #
  # *  3. REPORT TABLES.  THIS IS THE NAME OF A GROUP OF ABOUT 38    * #
  # *     TABLES WHICH ARE BUILT AND REFERENCED BY RANALYZ AND RGEN.* # 
  # *     ALTHOUGH ALL ENTRIES IN A GIVEN TABLE ARE THE SAME SIZE,   * #
  # *     THE SIZE IS DIFFERENT FOR DIFFERENT TABLES.  SINCE ALL THE * #
  # *     TABLES ARE OPENENDED AT THE SAME TIME, THEY ARE CONSTRUCTED* #
  # *     AS LINKED LISTS IN ONE BLOKC.  THE BLOCK IS RWT, STARTING  * #
  # *     JUST AFTER THE RPAUX TABLE WHOSE CONSTRUCTION IS COMPLETED * #
  # *     BEFORE ANY OF THE REPORT TABLES ARE BUILT.  ASSOCIATED     * #
  # *     WITH EACH REPORT TABLE ARE TWO IMPLICIT POINTERS, A POINTER* #
  # *     TO THE CURRENT ENTRY (CURRPTR) AND A POINTER TO THE NEXT   * #
  # *     ENTRY (NEXTPTR).  THE  NEXT ENTRY  OF A TABLE IS AN ENTRY  * #
  # *     THAT HAS BEEN ALLOCATED AND LINKED BUT WHICH WILL NOT BE   * #
  # *     WRITTEN INTO UNTIL A NEW  NEXT ENTRY IS ALLOCATED.  THE    * #
  # *     CURRENT ENTRY OF A TABLE(WHILE THE TABLE IS STILL BEING    * #
  # *     BUILT) IS THE ENTRY PRECEEDING THE NEXT ENTRY.  ITS LINK   * #
  # *     FIELD POINTS AT THE NEXT ENTRY.  NEW ENTRIES ARE ALLOCATED * #
  # *     BY THE ROUTINE GETNEXT WHICH ALLOCATES THE SPACE BY        * #
  # *     INCREMENTING RWTHWM AND MAINTAINS THE CURRENT-NEXT RELATION* #
  # *     SHIP.  THE ROUTINES THAT BUILD THESE TABLES REFERENCE THE  * #
  # *     CURRENT ENTRY.  THE ROUTINES THAT REFERECE THESE TABLES    * #
  # *     GENERALLY GO THRU THE ENTRIES SEQUENTIALLY, MOVING THE     * #
  # *     CURRPTR FROM ONE ENTRY TO THE NEXT VIA THE LINK FIELD.     * #
  # *     IN GENERAL, THESE TABLES ARE BUILT BY THE RANALYZ FROM    * # 
  # *     INFORMATION CONTAINED IN THE RPAUX TABLE, THE DNAT, AUX,   * #
  # *     FNAT, ETC. AND ARE REFERENCED BY RGEN IN ORDER TO BUILD    * #
  # *     ITS CTEXT.                                                 * #
  # *     RERORT TABLE ENTRIES ARE REFERENCED EXPLICITLY VIA RWGET   * #
  # *     AND RWSET.  THE CURRENT ENTRIES CAN BE REFERENCED          * #
  # *     IMPLICITLY WITH RWGET1 AND RWSET1.                         * #
  # *                                                                * #
  # *                                                                * #
  # *                                                                * #
  # *                                                                * #
  # *                                                                * #
          CONTROL EJECT;
          DEF    RWTHWM       #CCTRWTABLEN#;
          ITEM   INDEXTEMP; 
          ITEM   VALUETEMP; 
          ITEM   TABLENUM;
          ITEM   WORD;
          ITEM   BIT; 
          ITEM   LENGTH;
          ITEM   T1;
           ITEM   TEMP; 
  
           DEF    GETQ           #GETQUICK#;
  
*CALL GETSET
*CALL RWT1
*CALL PLT1
*CALL PLTVALS 
*CALL TABLNAMES 
          CONTROL EJECT;
          $BEGIN
PROC FIELD$TRACE ( FTP0, FTP1 ) ; 
          BEGIN 
          ITEM   FTP0         I;
          ITEM   FTP1         C(4); 
          ITEM   FTVAR        I;
  
  # FTP0 IS EITHER DB$ALL OR DB$SET, DEPENDING ON WHO THE CALLER# 
  # WAS.  IF FTP0 = 0, THEN NO TRACE IS TO BE DONE, SO RETURN.  # 
  # FTP1 IS A 4 CHAR STRING WHICH IDENTIFIES A FUNCTION OR PROC # 
  # THAT WAS CALLED.  DISPLAY A TRACE LINE CONTAINING FTP1, P1  # 
  # WHICH IS A FIELD DESCRIPTOR, INDEXTEMP- THE INDEX OF THE    # 
  # FIRST WORD OF THE ENTRY CONTAINING THE REFERENCED FIELD,    # 
  # AND VALUETEMP- THE VALUE THAT IS BEING PLACED INTO OR GOTTEN# 
  # FROM THE FIELD.                                             # 
  
          #MOVE FTP0 TO LOCAL VAR SO OUT OF RANGE TEST CAN #
          #SET IT IF NECESSARY.                            #
          FTVAR = FTP0; 
          # CHECK FOR REFERENCE OUT OF RANGE. # 
          IF INDEXTEMP + WORD GR RWTHWM 
          THEN
              BEGIN 
              CBLIST ( 1, "RWT INDEX OUT OF RANGE", 22 ); 
              #TURN ON ALL DEBUGGING SO BAD REF CAN BE FOUND# 
              DB$ALL = 1; 
              DB$SET = 1; 
              DEBUG$$ = TRUE; 
              FTVAR = 1;
              END 
  
          IF FTVAR EQ 0 
          THEN
              RETURN; 
  
          DBCTEMP = " ";
          C< TAB     ,  6 > DBCTEMP = FTP1; 
          C< TAB + 6 ,  8 > DBCTEMP = DEC ( P1 ); 
          C< TAB + 14, 10 > DBCTEMP = ", INDEX = "; 
          C< TAB + 24,  7 > DBCTEMP = DEC ( INDEXTEMP );
          C< TAB + 31, 10 > DBCTEMP = ", VALUE = "; 
          C< TAB + 41,  7 > DBCTEMP = DEC ( VALUETEMP );
  
          CBLIST ( 1, DBCTEMP, TAB + 48 );
  
          RETURN; 
          END 
          $END
          CONTROL EJECT;
PROC DECODE;
          BEGIN 
          # P1 IS A REPORT TABLE FIELD DESCRIPTOR.  IT IS THE BINARY   #
          # REPRESENTATION OF THE DECIMAL NUMBER  TTWWBBLL             #
          # WHERE TT IS THE TABLE NUMBER, WW IS THE WORD INDEX INTO    #
          # THE ENTRY(0 ORIGIN) OF THE WORD THAT CONTAINS THE FIELD,   #
          # BB IS THE BIT INDEX INTO THE WORD(0 ORIGIN) OF THE FIELD,  #
          # AND LL IS THE BIT LENGTH OF THE FIELD.  BB + LL IS ALWAYS  #
          # LESS THAN 61, IE. NO FIELDS CROSS WORD BOUNDARIES.         #
          #                                                            #
          # THIS PROCEDURE CRACKS THE DESCRIPTOR AND PUTS THE RESULTS  #
          # INTO THE VARIABLES TABLENUM, WORD, BIT, AND LENGTH.        #
          ITEM   REMAINS; 
          TABLENUM = P1 / 1000000;
          REMAINS  = P1 - TABLENUM * 1000000; 
          WORD     = REMAINS / 10000; 
          REMAINS  = REMAINS - WORD * 10000;
          BIT      = REMAINS / 100; 
          LENGTH   = REMAINS - BIT * 100; 
          RETURN; 
          END   # DECODE #
          CONTROL EJECT;
ENTRY FUNC RP$AUXPTR(P1)  I;
          BEGIN 
          # P1 IS A DNAT POINTER IN THE REPORT SECTION.          #
          #                                                      #
          # RETURN THE RPAUXPTR THAT IS ASSOCIATED WITH THE DNAT.#
          # ENTRY.                                               #
          T1 = P1 - CCTRSDNATPTR; #DNAT PTR RELATIVE TO 1ST IN REP SEC# 
          WORD =  T1 / 4;        #WORD INDEX OF RPAUXPTR IN RWT        #
          BIT  =  (T1 - WORD * 4) * 15;   #BIT POSITION WITHIN THE WORD#
          RP$AUXPTR = B<BIT,15>GETQ(RWT$ENTRY,RWT$,WORD + 1); 
  
          $BEGIN
          IF P1 GR CCTDNTLEN OR P1 LS CCTRSDNATPTR
          THEN
              BEGIN 
              #OUT OF RANGE REFERENCE#
              CBLIST ( 1, "RP$AUXPTR REF FOR NON RS DNAT", 29 );
              CBLIST ( 1, DEC ( P1 ), 10 ); 
              #TURN ON ALL DEBUG STUFF #
              DB$ALL = 1; 
              DB$SET = 1; 
              DEBUG$$ = TRUE; 
              END 
          $END
  
          RETURN; 
          END   #RP$AUXPTR# 
          CONTROL EJECT;
ENTRY PROC SETRPAUXPTR(P1,P2);
          BEGIN 
          # P1 IS A DNAT PTR TO A REPORT SECTION ITEM.                 #
          # P2 IS AN RPAUXPTR WHICH IS TO BE STORED INTO THE RPAUX     #
          # ENTRY ASSOCIATED WITH THAT DNAT.                           #
          T1 = P1 - CCTRSDNATPTR; #ENTRY INDEX INTO RPAUX TABLE       # 
          WORD = T1 / 4;         #WORD INDEX OF THE ENTRY              #
          BIT = (T1 - WORD * 4) * 15;   #BIT POSITION WITHIN THE WORD  #
          B<BIT,15>GETQ(RWT$ENTRY,RWT$,WORD + 1) = P2;
          RETURN; 
          END   #SETRPAUXPTR# 
          CONTROL EJECT;
ENTRY PROC GETNEXT(P1); 
          BEGIN 
          # P1 IS THE DESCRIPTOR OF THE LINK FIELD OF A REPORT TABLE.  #
          #                                                            #
          #-MAKE THE NEXT ENTRY THE CURRENT ENTRY.                     #
          #-ALLOCATE A NEW NEXT ENTRY.                                 #
          #-SET LINK OF NEXT ENTRY TO 0.                               #
          #-SET LINK OF CURRENT ENTRY TO NEXT.                         #
          DECODE(P1); 
          CURRPTR[TABLENUM] = NEXTPTR[TABLENUM];
          RWTHWM = RWTHWM + 1;   #POINT TO NEW ENTRY# 
          NEXTPTR [ TABLENUM ] = RWTHWM;
          TEMP = CURRPTR[TABLENUM];     #CURRPTR# 
          B<BIT,LENGTH>GETQ(RWT$ENTRY,RWT$,TEMP + WORD ) = RWTHWM;
                                                    #SET LINK TO NEXT#
          RWTHWM = RWTHWM + WORD; 
          B<BIT,LENGTH>GETQ(RWT$ENTRY,RWT$,RWTHWM) = 0; 
          RETURN; 
          END   # GETNEXT#
          CONTROL EJECT;
ENTRY PROC RTINITIATE(P1);
          BEGIN 
          # P1 IS THE DESCRIPTOR OF THE LINK FIELD OF A REPORT TABLE.  #
          # ACTION:                                                    #
          #        1. ALLOCATE INITIAL TABLE ENTRY.                    #
          #        2. SET THE CURRPTR AND THE NEXTPTR TO POINT TO THIS #
          #           ENTRY.                                           #
          #        3. SET THE LINK OF THIS ENTRY TO 0.                 #
          DECODE(P1);   # CRACK THE DESCRIPTOR INTO TABLENUM, WORD, BIT#
                        # LENGTH.  THE WORDS OF AN ENTRY ARE NUMBERED  #
                        # STARTING AT 0.  THE LINK FIELD IS IN THE LAST#
                        # WORD, THUS WORD + 1 IS THE WORD LENGTH OF    #
                        # THE ENTRY.                                   #
          RWTHWM = RWTHWM + 1;   #NEXT AVAILABLE WORD                  #
          CURRPTR[TABLENUM]   = RWTHWM;   # SET CURRPTR OF THE TABLE   #
          NEXTPTR[TABLENUM]       = RWTHWM;   # SET NEXTPTR            #
          RWTHWM = RWTHWM + WORD;       #ALLOCATE THE ENTRY            #
                                        #SET LINK TO 0                 #
          B<BIT,LENGTH>GETQ(RWT$ENTRY,RWT$,RWTHWM) = 0; 
          RETURN; 
          END 
          CONTROL EJECT;
ENTRY FUNC RWGET1(P1);
          BEGIN 
          # P1 IS THE DESCRIPTOR OF A FIELD IN A REPORT TABLE.         #
          #                                                            #
          # RETURN THE CONTENTS OF THAT FIELD IN THE CURRENT ENTRY.    #
          DECODE(P1); 
          INDEXTEMP = CURRPTR[TABLENUM];     #CURRPTR FOR THE TABLE    #
          VALUETEMP = 
                  B<BIT,LENGTH>GETQ(RWT$ENTRY,RWT$,INDEXTEMP + WORD); 
  
          RWGET1 = VALUETEMP; 
          $BEGIN
  
              FIELD$TRACE( DB$ALL, "GET1"); 
          $END
  
          RETURN; 
          END 
          CONTROL EJECT;
ENTRY FUNC RWGET(P1,P2);
          BEGIN 
          # P1 IS THE DESCRIPTOR OF A FIELD IN A REPORT TABLE ENTRY.   #
          # P2 IS THE INDEX OF AN ENTRY IN THAT TABLE.                 #
          #                                                            #
          # RETURN THE CONTENTS OF THE FIELD.                          #
          INDEXTEMP = P2; 
          DECODE(P1); 
          VALUETEMP = 
                  B<BIT,LENGTH>GETQ(RWT$ENTRY,RWT$,INDEXTEMP + WORD); 
  
          RWGET = VALUETEMP;
          $BEGIN
  
              FIELD$TRACE( DB$ALL, "GET "); 
          $END
  
          RETURN; 
          END 
          CONTROL EJECT;
ENTRY PROC RWSET1(P1,P2); 
          BEGIN 
          # P1 IS THE DESCRIPTOR OF A FIELD IN A REPORT TABLE          #
          # P2 IS A VALUE.                                             #
          #                                                            #
          # PUT THE VALUE INTO THE FIELD IN THE CURRENT ENTRY.         #
          DECODE(P1); 
          INDEXTEMP =  CURRPTR [TABLENUM];   #CURRENT PTR OF THE TABLE #
          VALUETEMP = P2; 
          B<BIT,LENGTH>GETQ(RWT$ENTRY,RWT$,INDEXTEMP + WORD)
              = VALUETEMP;
          $BEGIN
  
              FIELD$TRACE( DB$SET, "SET1"); 
          $END
          RETURN; 
          END 
          CONTROL EJECT;
ENTRY PROC RWSET(P1,P2,P3); 
          BEGIN 
          # P1 IS THE DESCRIPTOR OF A FIELD IN A REPORT TABLE.         #
          # P2 IS THE INDEX OF AN ENTRY IN THAT TABLE.                 #
          # P3 IS A VALUE.                                             #
          #                                                            #
          # PUT THE VALUE IN THE FIELD                                 #
          INDEXTEMP = P2; 
          VALUETEMP = P3; 
          DECODE(P1); 
          B<BIT,LENGTH>GETQ(RWT$ENTRY,RWT$,INDEXTEMP + WORD)
              = VALUETEMP;
          $BEGIN
  
              FIELD$TRACE( DB$SET, "SET "); 
          $END
          RETURN; 
          END 
          CONTROL EJECT;
ENTRY FUNC PLTCNVRT(P1);
          BEGIN 
          # P1 IS A POINTER TO A POSITIVE INTEGER LITERAL IN THE PLT  # 
  
          # RETURN ITS VALUE IN BINARY.                               # 
  
          ITEM   BINVALUE,
                 TEMP1   ,
                 TEMP2   ,
                 CTEMP   C(20); 
  
          BINVALUE = 0; 
          TEMP1 = P1;     #CLUDGE- P1 WONT WORK IN GETQUICK#
          TEMP1 = GETQUICK(PL$LENGTH,PLT$,TEMP1); 
          GETPLST(P1,LOC(CTEMP)); 
          FOR TEMP2 = 0 STEP 1 UNTIL TEMP1 - 1 DO 
              BINVALUE = BINVALUE * 10 + C<TEMP2,1> CTEMP - "0";
  
          PLTCNVRT = BINVALUE;
          RETURN; 
          END   #PLTCNVRT#
          $BEGIN
          CONTROL EJECT;
ENTRY PROC EP$TRACE(C1);
          BEGIN 
          DBCTEMP = " ";
          C< TAB     ,  7 > DBCTEMP = C1; 
          C< TAB + 7 ,  6 > DBCTEMP = " ENTER"; 
          CBLIST ( 1, DBCTEMP, TAB + 13 );
          TAB = TAB + 13; 
  
          # LOOKUP MOD NAME IN NAMES FROM CONTROL CARD #
  
          FOR TEMP = 0 STEP 1 WHILE DEBUG$WORD [ TEMP ] NQ C1 DO
              IF DEBUG$WORD [ TEMP ] EQ " " 
                 OR 
                 TEMP GQ 7
              THEN
                  # NOT FOUND # 
                   RETURN;
  
          # FOUND IT, TURN ON TRACE. #
  
          DB$ALL = 1; 
          DB$SET = 1; 
  
          RETURN; 
          END   #EP$TRACE#
ENTRY PROC EX$TRACE(C1);
          BEGIN 
          DBCTEMP = " ";
          TAB = TAB - 13; 
          IF TAB LS 0 
          THEN
              TAB = 0;
          C< TAB     ,  7 > DBCTEMP = C1; 
          C< TAB + 7 ,  6 > DBCTEMP = " EXIT "; 
          CBLIST ( 1, DBCTEMP, TAB + 13 );
  
          # LOOKUP MOD NAME IN CONTROL CARD PARAMS #
  
          FOR TEMP = 0 STEP 1 WHILE DEBUG$WORD [ TEMP ] NQ C1 DO
              IF DEBUG$WORD [ TEMP ] EQ " " 
                 OR 
                 TEMP GQ 7
              THEN
                  # NOT FOUND # 
                   RETURN;
  
          # FOUND IT, TURN OFF  TRACE. #
  
          DB$ALL = 0; 
          DB$SET = 0; 
          RETURN; 
          END 
          $END
