*COMDECK DACOMDK
#DEF DECLARATIONS#
DEF NEWPAGE #CONTROL EJECT#;
  
DEF WORDLIMITX10 #655360#; #USED TO DETECT ERRORS 144, 145, 146#
  
# 
MESSAGE SEVERITY DECLARATIONS 
# 
DEF D$ERROR #1#; #DATA DECLARATION ERROR# 
DEF A$ERROR #4#;
DEF T$ERROR #5#; #TRIVIAL ERROR#
DEF J$ERROR #6#;
# 
THE FOLLOWING DEF DECLARATIONS RELATE THE ERROR MESSAGE NUMBER SYMBOLS
USED IN THE CALL TO "ERROR" TO THEIR APPROPRIATE VALUES.THE 
REASON FOR HAVING MESSAGE NUMBER SYMBOLS IS THAT, GIVEN A CROSS 
REFERENCE LISTING SOMEONE CAN FIND OUT WHERE A GIVEN MESSAGE
IS OUTPUT.
# 
DEF MSG1 #1#; 
DEF MSG2 #2#; 
DEF MSG3 #3#; 
DEF MSG4 #4#; 
DEF MSG5 #5#; 
DEF MSG6 #6#; 
DEF MSG7 #7#; 
DEF MSG8 #8#; 
DEF MSG9 #9#; 
DEF MSG10 #10#; 
DEF MSG11 #11#; 
DEF MSG12 #12#; 
DEF MSG13 #13#; 
DEF MSG14 #14#; 
DEF MSG15 #15#; 
DEF MSG16 #16#; 
DEF MSG17 #17#; 
DEF MSG18 #18#; 
DEF MSG19 #19#; 
DEF MSG20 #20#; 
DEF MSG21 #21#; 
DEF MSG22 #22#; 
DEF MSG23 #23#; 
DEF MSG24 #24#; 
DEF MSG25 #25#; 
DEF MSG26 #26#; 
DEF MSG27 #27#; 
DEF MSG28 #28#; 
DEF MSG29 #29#; 
DEF MSG30 #30#; 
DEF MSG31 #31#; 
DEF MSG32 #32#; 
DEF MSG33 #33#; 
DEF MSG34 #34#; 
DEF MSG35 #35#; 
DEF MSG36 #36#; 
DEF MSG37 #37#; 
DEF MSG38 #38#; 
DEF MSG39 #39#; 
DEF MSG40 #40#; 
DEF MSG41 #41#; 
DEF MSG42 #42#; 
DEF MSG43 #43#; 
DEF MSG44 #44#; 
DEF MSG45 #45#; 
DEF MSG46 #46#; 
DEF MSG47 #47#; 
DEF MSG48 #48#; 
DEF MSG49 #49#; 
DEF MSG50 #50#; 
DEF MSG51 #51#; 
DEF MSG52 #52#; 
DEF MSG53 #53#; 
DEF MSG54 #54#; 
DEF MSG55 #55#; 
DEF MSG56 #56#; 
DEF MSG57 #57#; 
DEF MSG58 #58#; 
DEF MSG59 #59#; 
DEF MSG60 #60#; 
DEF MSG61 #61#; 
DEF MSG62 #62#; 
DEF MSG63 #63#; 
DEF MSG64 #64#; 
DEF MSG65 #65#; 
DEF MSG66 #66#; 
DEF MSG67 #67#; 
DEF MSG68 #68#; 
DEF MSG69 #69#; 
DEF MSG70 #70#; 
DEF MSG71 #71#; 
DEF MSG72 #72#; 
DEF MSG73 #73#; 
DEF MSG74 #74#; 
DEF MSG75 #75#; 
DEF MSG76 #76#; 
DEF MSG77 #77#; 
DEF MSG78 #78#; 
DEF MSG79 #79#; 
DEF MSG80 #80#; 
DEF MSG81 #81#; 
DEF MSG82 #82#; 
DEF MSG83 #83#; 
DEF MSG84 #84#; 
DEF MSG85 #85#; 
DEF MSG86 #86#; 
DEF MSG87 #87#; 
DEF MSG88 #88#; 
DEF MSG89 #89#; 
DEF MSG90 #90#; 
DEF MSG91 #91#; 
DEF MSG92 #92#; 
DEF MSG93 #93#; 
DEF MSG94 #94#; 
DEF MSG95 #95#; 
DEF MSG96 #96#; 
DEF MSG97 #97#; 
DEF MSG98 #98#; 
DEF MSG99 #99#; 
DEF MSG100 #100#; 
DEF MSG101 #101#; 
DEF MSG102 #102#; 
DEF MSG103 #103#; 
DEF MSG104 #104#; 
DEF MSG105 #105#; 
DEF MSG106 #106#; 
DEF MSG107 #107#; 
DEF MSG108 #108#; 
DEF MSG109 #109#; 
DEF MSG110 #110#; 
DEF MSG111 #111#; 
DEF MSG112 #112#; 
DEF MSG113 #113#; 
DEF MSG114 #114#; 
DEF MSG115 #115#; 
DEF MSG116 #116#; 
DEF MSG117 #117#; 
DEF MSG118 #118#; 
DEF MSG119 #119#; 
DEF MSG120 #120#; 
DEF MSG121 #121#; 
DEF MSG122 #122#; 
DEF MSG123 #123#; 
DEF MSG124 #124#; 
DEF MSG125 #125#; 
DEF MSG126 #126#; 
DEF MSG127 #127#; 
DEF MSG128 #128#; 
DEF MSG129 #129#; 
DEF MSG130 #130#; 
DEF MSG131 #131#; 
DEF MSG132 #132#; 
DEF MSG133 #133#; 
DEF MSG134 #134#; 
DEF MSG135 #135#; 
DEF MSG136 #136#; 
DEF MSG137 #137#; 
DEF MSG138 #138#; 
DEF MSG139 #139#; 
DEF MSG140 #140#; 
   DEF MSG141 #141#;
  DEF MSG142 #142#; 
DEF MSG144 #144#; 
DEF MSG145 #145#; 
DEF MSG146 #146#; 
DEF MSG147 #147#; 
DEF MSG275 #275#; 
DEF MSG143 #143#; 
DEF MSG200 #200#; 
DEF MSG201 #201#; 
DEF MSG202 #202#; 
DEF MSG203 #203#; 
#THE ABOVE LINE IS THE LAST MESSAGE DEF"D#
##
NEWPAGE;
#XREFS# 
XREF BEGIN
PROC INTERCEPTOR; 
#XREF# END
NEWPAGE;
#FLAGS# 
DEF BYTES$PER$WD #10#;
COMMON DAVAR1;
BEGIN 
 ITEM  ELEMENTARY  I=0; #=1 IF CURRENT ITEM ELEMENTARY, =0 IF GROUP#
 ITEM  NO$SIGND$PIC I=0; #=1 IF GROUP HAS SIGN CLAUSE,
                    SET 0 WHEN SIGNED PIC FOUND#
# 
THE FOLLOWING FLAGS ARE SET WHEN A SUPERIOR GROUP ITEM HAS
THE CORRESPONDING CLAUSES IN IT#
 ITEM  SYNC$FLAG  I=0; #SYNCHRONIZED# 
 ITEM  SYNCR$FLAG  I=0; #SYNCHRONIZED RIGHT#
 ITEM  USAGE$FLAG  I=0; #USAGE# 
 ITEM  SIGN$FLAG  I=0; #SIGN# 
 ITEM  DEPEND$FLAG  I=0; #DEPENDING UPON# 
 ITEM  VALUE$FLAG  I=0; #VALUE# 
##
#MISCELLANEOUS VARIABLES# 
 ITEM  CURR$ITM$LVL  I=0; #LEVEL NUMBER OF THE CURRENT DNAT ITEM# 
 ITEM  NXT$ITM$LVL  I=0; #LEVEL NUMBER OF THE NEXT NON-INDEX, 77 OR 88 #
 ITEM  SECTION  I=0; #CURRENT SECTION CODE# 
 ITEM  MAX$REC$LEN  I=0; #MAXIMUM RECORD LENGTH FOR A GIVEN FILE# 
 ITEM  MIN$REC$LEN  I=0; #MINIMUM RECORD LENGTH FOR A GIVEN FILE# 
 ITEM GROUP$LEVEL I=0; #LEVEL OF GROUP ITEM#
 ITEM  GROUP$USAGE I=0; #USAGE TYPE OF GROUP ITEM#
 ITEM TOTAL$LEN I=0; #TOTAL LENGTH OF OCCURRING GROUP#
 ITEM OCCUR$MAX I=0; #MAX NO OF OCCURRENCES OF GROUP# 
 ITEM  GROUP$LEN  I=0; #LENGTH OF GROUP ITEM# 
 ITEM  O$ADDR  I=0;  #OBJECT ADDRESS ....SHOULD BE LOCAL VARIABLE#
 ITEM  MIN$OCCURS  I=0; #MINIMUM NUMBER OF OCCURS#
 ITEM  MAJ$MEM$SEC  I=0; #MAJOR MEMORY SECTION (USED WITH BYTE OFFSET)# 
 ITEM  MIN$MEM$SEC  I=0; #MINOR MEMORY SECTION
              (USED IN FDSECTION WITH BYTE OFF)#
 ITEM  SVD$MIN$MSEC  I=0; #TEMP STORAGE FOR 
              MINOR MSEC DURING SAME AREA PROCESING#
 ITEM  NAB  I=0; #NEXT AVAILABLE BYTE 
        ..ADDED TO MEMORY SECTION TO GET FINAL ADDR#
ITEM  SAVE$NAB I=-1;
 ITEM  NAB$INDEX  I=0; #SAME AS NAB BUT FOR INDEX ITEMS#
 ITEM  CD$OFFSET  I=0; #ADDEND TO BYTE OFFSET FOR CD ITEMS# 
 ITEM ZERO  I=0; #DUMMY VALUE USED IN FOR LOOPS#
ITEM FNAT$LINE; #SOURCE LINE NBR OF SELECT CLAUSE FROM FNAT#
 ITEM LINE$NO I=0; #LINE NUMBER OF CURRENT DNAT ITEM# 
ITEM DEPEND$NAME I=0; #DNAT PTR TO DEPENDED UPON ITM# 
ITEM SYNC$BYTES I=0; #BYTES TO ADD TO NAB FOR SYNC ITMS#
ITEM NANSILVLNOFG B = FALSE; # NON ANSI LEVEL NO. FLAG                 #
ITEM ERF I = 0; 
#THE FOLLOWING VARIABLE AS ADDED TO ACT AS A TEMPORARY
STORAGE SO THAT GETQUICK(P1,P2,GETQUICK...) AND 
SETFIELD(P1,P2,P3,GETQUICK(... STRUCTURES WOULD BE AVOIDED# 
ITEM TGET U;
#THE FOLLOWING VARIABLES ARE USED TO SET THE FN$VARTYPE FIELD.
THEY ARE INITIALISED IN LEVEL$FDSD, SET IN SUM$RECORD AND USED IN 
SUM$FILE# 
ITEM FIXPARTSIZE; #BYTE OFFSET OF SUB OCC DEP ITEM# 
ITEM TRAILSIZE; #ITMLEN OF SUB OCC DEP ITEM#
ITEM DEPONDNAT; #DNAT OF DEP ON VARIABLE# 
ITEM DEPONCOUNT; #COUNT OF NUMBER OF OCC DEP ON#
ITEM NUMRECS;   #NUMBER OF RECORDS IN A GIVEN FILE# 
ITEM CD01COUNT I=0;  #USED IN VALUE CLAUSE PROCESSING#
NEWPAGE;
#INTERNAL ARRAYS# 
ARRAY $GRP$S [49];
  BEGIN 
   ITEM  GRP$ST; #CONTAINS DNAT PTR OF GROUP ITEM#
  END 
ARRAY $RDEF$NAB$S [49]; 
  BEGIN 
   ITEM  RDEF$NAB$ST; #CONTAINS NAB OF REDEFINITION ITEMS#
  END 
ARRAY $RDEF$DNAT$S [49];
  BEGIN 
   ITEM  RDEF$DNAT$ST; #CONTAINS DNAT PTRS OF REDEFINITION ITEMS# 
  END 
ARRAY $KEY$PTR [3]; 
  BEGIN 
 ITEM  KEY$PTR; #CONTAINS DNAT PTR OF KEYED GROUP ITEMS#
  END 
ARRAY $SYNC$GROUP [3];
  BEGIN 
   ITEM  SYNC$GROUP; #CONTAINS FLAG WHICH IS SET IF GROUP IS SYNC#
  END 
ARRAY $OCCUR$NAME [3];
  BEGIN 
   ITEM  OCCUR$NAME; #CONTAINS DNAT PTR OF OCCURING ITEMS#
  END 
END #DAVAR1#
NEWPAGE;
#COMMON TABLES# 
CONTROL NOLIST; 
CONTROL NOLIST; 
*CALL AUXT1 
*CALL FDRDT1
*CALL GETSET
*CALL PLT1
*CALL DNATVALS
*CALL AUXTVALS
*CALL PLTVALS 
*CALL FNATVALS
*CALL FNAT1 
*CALL TABLNAMES 
NEWPAGE;
#TABLE AND ARRAY POINTERS#
COMMON DAVAR2;  BEGIN 
 ITEM  DNAT$PTR  I=1; #PTR TO THE CURRENT ITEM IN THE DNAT# 
 ITEM  FNAT$PTR  I=0;    #PTR TO THE FNAT#
 ITEM  GRP$ST$PTR  I=0; #PTR TO THE GRP$ST# 
 ITEM  RDEF$ST$PTR  I=0; #PTR TO BOTH RDEF$NAB$ST AND RDEF$DNAT$ST# 
 ITEM  SUB$DEPTH  I=0; #PTR TO KEY$PTR, SYNC$GROUP AND OCCUR$NAME ARRAYS..
           ALSO CONTAINS THE CURRENT SUBSCRIPT DEPTH# 
 ITEM  GROUP$PTR  I=0; #PTR TO THE CURRENT GROUP ITEM DNAT# 
 ITEM  FIRST$R$PTR  I=0; #PTR TO THE FIRST 01 ITEM OF A RECORD# 
 ITEM  LAST$ITEM  I=0; #DNAT PTR TO THE LAST ENTRY IN THE DNAT# 
 ITEM  CD$PTR  I=0; #DNAT PTR TO THE CD ITEM# 
 ITEM  FD$PTR  I=0; #DNAT PTR TO THE FD ITEM# 
# 
THE FOLLOWING POINTERS ARE DNAT POINTERS TO THE SUPERIOR GROUP
ITEMS HAVING THE APPROPRIATE ATTRIBUTES... SEE THE FLAG DECLARATIONS
WHICH ARE USED IN CONJUNCTION WITH THESE POINTERS 
# 
 ITEM  SYNC$PTR  I=0; 
 ITEM  USAGE$PTR  I=0;
 ITEM  SIGN$PTR  I=0; 
 ITEM  DEPEND$PTR  I=0; 
 ITEM  VALUE$PTR  I=0;
END #DAVAR2#
NEWPAGE;
#THE DEBUG SYSTEM IS DESIGNED WITH THE FOLLOWING OBJECTIVES:  
    1.WHEN DEBUGGING IS COMPLETE ALL DEBUG CODING SHOULD BE REMOVED 
        FROM THE OBJECT CODING .. BUT LEFT IN THE SOURCE CODING SO THAT 
        FOR SUBSEQUENT BUG FIXING IT CAN BE TURNED BACK ON. 
        THE OVERALL " MASTER SWITCH FOR DEBUGGING IS THE FOLLOWING
        DEF DECLARATION. IF IT IS GIVEN A VALUE OF ZERO NO OBJECT 
        CODING WILL BE GENERATED FOR DEBUG CALLS. 
# 
     #TO BRING THE D-ANALYZER INTO LINE WITH COMPILER STANDARDS 
     DEBUG CODE GENERATION IS CONDITIONAL UPON THE "E" PARAMETER
     ON THE SYMPL CONTROL CARD - THIS PARAMETER DICTATES WHETHER
     OR NOT THE DEBUG$SWITCH WILL BE DEF"D TO ZERO OR 1.# 
$BEGIN
DEF DEBUG$SWITCH #1#; 
CONTROL IFEQ 1,2; 
$END
CONTROL IFEQ 1,1; 
DEF DEBUG$SWITCH #0#; 
CONTROL FI; 
$BEGIN
CONTROL FI; 
$END
##
#THE ABOVE MASTER DEBUG SWITCH IS USED IN CONJUNCTION WITH OTHER
SWITCHES. THESE OTHER SWITCHES CONTROL THE OTHER DEBUG FUNCTIONS: 
* 
    1.PRINTOUT OF ROUTINE NAME ON ENTRY AND EXIT TO AND FROM
        THAT ROUTINE. 
        CALLS ARE ENTRY$("NAME")  [PRINTS "ENTRY TO NAME"]
                  EXIT$("NAME")   [PRINTS "EXIT FROM NAME"] 
            WHERE NAME IS UP TO 10 CHARACTERS LONG. 
            THE CONTROL FLAG (WHICH DETERMINES WHETHER OR NOT 
            THIS FUNCTION IS EXECUTED IS "ENTRY$EXIT$" AND IS 
            DEFINED BELOW.
* 
        2. PRINTOUT OF TRACK POINT NAME (USED TO RECORD PASSING 
            THRU A PARTICULAR PART OF THE CODING).
            CALL IS TRACK$(MODULEFLAG,"NAME")  [PRINTS TRACK NAME]
            ***MODULE FLAGS ARE NOT THE SAME AS CONTROL FLAGS : A 
            FURTHER EXPLANATION OF MODULE FLAGS IS GIVEN BELOW. 
            THE CONTROL FLAG IS "TRACKING$" AND IS DEFINED BELOW. 
* 
        3.   PRINTOUT OF CHARACTERS STRINGS AND ITEM VALUES 
            CALL IS VALUE$(MODULEFLAG,ARG1,ARG2)
            WHERE MODULEFLAG IS EXPLAINED BELOW 
                  ARG1 AND ARG2 MAY BE :  
                    * A CHARACTER STRING (MAX 10) "EXAMPLE" 
                    * A CHARACTER ITEM NAME 
                    * A DEC OR OCT FUNCTION CALL
                        *THE DEC CALL IS DEC(ITEM)
                        THE RESULT IS THE ITEM VALUE CONVERTED
                        TO AN UP TO 10 CHARACTER DEC VALUE
                        LEFTJUSTIFIED WITH LEADING MINUS
                        IF NEGATIVE 
                        *THE OCT CALL IS OCT(ITEM,TRIAD,LENGTH) 
                        THE RESULT IS A "LENGTH" LONG FIELD 
                        OF LENGTH/3 BITS STARTING AT BIT
                        TRIAD*3 OF ITEM CONVERTED TO OCTAL
                        CHARACTERS. LENGTH MUST BE LESS THAN
                        ELEVEN CHARACTERS.
                        TO CONVERT AN ENTIRE 60 BIT WORD
                        REQUIRE TWO SUCCESSIVE CALLS TO OCT:  
                        E.G. OCT(ITEM,0,10),OCT(ITEM,10,10).
            A TYPICAL CALL WOULD BE:  
            VALUE$(MODFLAG,"PARAM1=",DEC(PARAM1)) 
           OR 
           VALUE$(MODFLAG,"PARAM2=",OCT(PARAM2,10,10))
            * 
            THE CONTROL FLAG IS DEBUG$VALUES (DEFINED BELOW). 
# 
##
#CONTROL FLAGS# 
    DEF ENTRY$EXIT$ 
    #1#;
    DEF TRACKING$ 
    #1#;
    DEF DEBUG$VALUES
    #1#;
##
# 
MODULE FLAGS
============
    THE USER OF THESE DEBUG ROUTINES CAN DYNAMICALLY CONTROL THE
    DEBUG INFORMATION GATHERED ON A PARTICULAR TEST SHOT BY 
    SELECTIVELY SETTING FLAGS ASSOCIATED WITH SPECIFIC DEBUG
    CALLS.
    THESE FLAGS ARE SPECIFIED IN EACH TRACK$ AND VALUE$ CALL. 
    THE DEBUG CODING GENERATED BY THESE CALLS CHECKS THE VALUE OF 
    THE ASSOCIATED MODULE FLAG. 
    THE VALUE OF THE MODULE FLAG HAS THE FOLLOWING SIGNIFICANCE:  
            = 0 NO TRACK$ OR VALUE$ OUTPUT
            = 1 TRACK$ OUTPUT 
            = 2 VALUE$ OUTPUT 
            = 3 TRACK$ AND VALUE$ OUTPUT
* 
    THE LOGIC BEHIND THESE FLAGS IS HAVE "AREA" DEBUGGING OR "LEVEL"
    DEBUGGING.  FOR EXAMPLE IF THE USER WISHES TO USE AREA DEBUGGING, 
    THEN AS THE NAME SUGGESTS, ONE FLAG WILL BE USED FOR ALL DEBUG
    CALLS WITHIN A GIVEN ROUTINE. THIS ONE FLAG THEN CONTROLS THAT
    AREA OF CODING. IT CAN BE SET TO A PARTICULAR VALUE EITHER AT 
    COMPILE TIME, OR AT THE BEGINNING OF A GIVEN TEST SHOT (USING COBS) 
    OR EVEN DYNAMICALLY FROM WITHIN THE PROGRAM (BY SOME SPECIALLY
    ADDED CODING THAT DETECTS AN N"TH ITERATION OR COMPLEX CONDITION
    SUCH THAT DEBUGGING SHOULD COMMENCE. IN THIS WAY UNNECESSARY
    DEBUG OUTPUT CAN BE SUPPRESED.
    ALTERNATIVELY, THE USER MAY THINK OF EACH FLAG AS REPRESENTING A
    LEVEL OF DEBUGGING: LEVEL 1 REPRESENTS ONLY HIGH LEVEL DEBUG
    INFORMATION (VALUE OF PARAMETERS ON ENTRY/EXIT ), LEVEL N 
    REPRESENTS MORE DETAILED INFORMATION, INTERMEDIATE VALUES ETC.
    NATURALLY, THE CHOICE IS THE USERS AND WILL NORMALLY BE A FUNCTION
    OF THE TYPE OF CODING BEING DEBUGGED. 
# 
NEWPAGE;
#THE FOLLOWING DEFS TURN ON/OFF THE DEBUG CODING ACCORING TO
THE SETTING OF THE CONTROL FLAGS. 
THE ACTUAL ON/OFF MECHANISM IS THE USE OF THE "CONTROL IFEQ"
FOLLOWED BY EITHER 0,0 (ALWAYS TRUE), OR 0,1 (ALWAYS FALSE).
NOTE THAT AN EARLIER DEF PERMITS $ TO BE USED INSTEAD OF THE
WORD CONTROL. 
# 
CONTROL IFEQ DEBUG$SWITCH,1;    #CHECK MASTER SWITCH ON#
    CONTROL IFEQ ENTRY$EXIT$,1;    #AND ENTRY/EXIT SWITCH ON# 
        DEF S$ENT$EXIT #CONTROL IFEQ 0,0#; #YES TURN ON ENTRY EXIT# 
    CONTROL FI; 
    CONTROL IFEQ ENTRY$EXIT$,0;    #ENTRY EXIT SWITCH OFF#
        DEF S$ENT$EXIT #CONTROL IFEQ 0,1#; #TURN OF ENTRY EXIT# 
    CONTROL FI; 
    CONTROL IFEQ TRACKING$,1;    #CHECK TRACKING SWITCH ON# 
        DEF S$TRACK #CONTROL IFEQ 0,0#; #YES TURN ON TRACKING#
    CONTROL FI; 
    CONTROL IFEQ TRACKING$,0;     #CHECK TRACKING SWITCH OFF# 
        DEF S$TRACK #CONTROL IFEQ 0,1#; #YES TURN OFF TRACKING# 
    CONTROL FI; 
    CONTROL IFEQ DEBUG$VALUES,1;    #CHECK DEBUG VALUE SWITCH#
        DEF S$VALUE #CONTROL IFEQ 0,0#; #YES TURN ON DEBUG VALUE# 
    CONTROL FI; 
    CONTROL IFEQ DEBUG$VALUES,0; #CHECK DEBUG VALUE SWITCH O# 
        DEF S$VALUE #CONTROL IFEQ 0,1#;  #YES TURN OFF DEBUG VALUES#
    CONTROL FI; 
CONTROL FI; 
CONTROL IFEQ DEBUG$SWITCH,0;  #CHECK MASTER SWITCH OFF# 
    DEF S$ENT$EXIT #CONTROL IFEQ 0,1#; #YES TURN OFF ALL DEBUG CODE#
    DEF S$TRACK #CONTROL IFEQ 0,1#; 
    DEF S$VALUE #CONTROL IFEQ 0,1#; 
CONTROL FI; 
NEWPAGE;
#THE FOLLOWING CODE IS THE ACTUAL CODING GENERATED INLINE AS
A RESULT OF DEBUG CALLS.
# 
DEF ENTRY$(FLAG,NAME) 
    #S$ENT$EXIT;
    E$PROC(FLAG,NAME);
    CONTROL FI
    #;
DEF EXIT$(FLAG,NAME)
    #S$ENT$EXIT;
    X$PROC(FLAG,NAME);
    CONTROL FI
    #;
DEF TRACK$(FLAG,NAME) 
    #S$TRACK; 
    T$PROC(FLAG,NAME);
    CONTROL FI
    #;
DEF VALUE$(FLAG,P1,P2)
    #S$VALUE; 
    V$PROC(FLAG,P1,P2); 
    CONTROL FI
    #;
# 
    FINALLY THERE IS A ONE=TIME ROUTINE THAT SHOULD BE CALLED 
    AS SOON AS THE PROGRAM UNDER TEST HAS BEEN ENTERED. 
    THE CALL IS DEBUG$(MODULEFLAGS,NUMBEROFFL)
        WHERE MODULEFLAGS IS EITHER THE NAME OF THE ARRAY 
            CONTAINING THE MODULE FLAGS.
        NUMBEROFFL IS THE NUMBER OF FLAGS DECLARED. 
* 
(NOTE: EACH FLAG IS ASSUMED TO BE A 60 BIT INTEGER (I OR U))
* 
    THE ROUTINE DEBUG$ ONLY GENERATES CODE IF THE DEBUG MASTER
    SWITCH IS ON.[=1] 
* 
    THE ROUTINE, WHEN CALLED USES THE COBOL COBS PROC "DISPLAY" TO
    INTERACT WITH THE TERMINAL USER (OR BATCH INPUT FILE) 
    ALLOWING THE USER TO SET THE APPROPRIATE MODULE FLAGS.
* 
    THE DIALOGUE IS : 
        "STARTING DEBUG 
        ENTER RELATIVE FLAG NUMBER (0 IS FIRST) 
        \[USER ENTERS "N" OR "END" (WHERE "N" IS THE FLAG NUMBER) 
        SET TO VALUE= 
        \[USER ENTERS 0 OR 1 OR 2 OR 3] 
        .....AND SO ON UNTIL USER ENTERS "END". 
# 
NEWPAGE;
    XREF
    BEGIN 
        PROC DISPLAY; 
        PROC OUTPUT;
        FUNC OCT; 
        FUNC DEC; 
        FUNC TOBIN; 
        PROC GENIE; 
         PROC COPYD4; 
    END 
COMMON DBUGVAR; BEGIN 
    ARRAY FLAGS$ARRAY [49]; 
        BEGIN 
        ITEM MFLAG I(0,0,60)  = [50(3)];
        END 
ITEM RESPONSE C(10);
ITEM FILLERX C(70); 
ITEM BREAKPOINT I=0;
ITEM TRIGGER I=0; 
ITEM DISPEEX I=0; 
ITEM SPACES C(10) = "          "; 
ITEM PHDEBUG I=0;  #RUN TIME FLAG#
END #DBUGVAR# 
COMMON PARAMS;
  BEGIN 
  ARRAY PARAMT[0:7];
  ITEM PARAMC C(0,0,10);
  END 
