*DECK OVERLAP 
USETEXT DNTEXT
USETEXT RPTEXT
FUNC OVERLAP(DNAT1,DNAT2);
         #THIS CODE IS A COMBINATION OF THE INTERNAL  # 
         #PROCEDURES -STORAGE- AND -STOROVERLAP- IN   # 
         #SET1 OF THE PPARSER.  IT IS USED BY THE     # 
         #REPORT WRITER TO CHECK FOR OVERLAP BETWEEN  # 
         #TWO CONTROL DATA ITEMS AND BETWEEN A SOURCE # 
         #ITEM AND A CONTROL DATA ITEM.  IT IS INAD-  # 
         #EQUATE IN THE SENSE THAT IF A SOURCE ITEM IS# 
         #SUBSCRIPTED BY A VARIABLE, SOME VALUES OF   # 
         #THE VARIABLE MIGHT CAUSE OVERLAP WITH A     # 
         #CONTROL ITEM WHILE OTHERS MIGHT NOT.  THIS  # 
         #FUNC WILL CAUSE A DIAGNOSTIC IN THESE CASES.# 
         #GIVEN TWO DATA ITEMS, THIS ROUTINE RETURNS 1 IF#
         #THEIR STORAGE AREAS IN MEMORY OVERLAP AND RETURNS#
         #0 OTHERWISE.# 
         BEGIN
         ITEM  $TEMP$        U; 
         ITEM  DNAT1         U; 
         ITEM  DNAT2         U; 
         ITEM  MSEC1         U; 
         ITEM  MSEC2         U; 
         ITEM  START1        U; 
         ITEM  START2        U; 
         ITEM  END1          U; 
         ITEM  END2          U; 
         DEF   GETQ          #GETQUICK#;
  
         CONTROL EJECT; 
*CALL AUXT1 
*CALL AUXTVALS
*CALL DNATVALS
*CALL GETSET
*CALL TABLNAMES 
         CONTROL EJECT; 
FUNC STORAGE(DP); 
         #GIVEN A DATA ITEM, THIS ROUTINE RETURNS THE TOTAL#
         #AMOUNT OF STORAGE ALLOCATED TO IT. THE CALCULATION# 
         #IS COMPLEX ONLY FOR OCCURRING ITEMS.# 
         BEGIN
         ITEM  DP            U; 
         ITEM  DEPTH         U; 
         ITEM  L             U; 
         ITEM  REG1          U; 
         ITEM  REG2          U; 
         #DO WE HAVE AN ARRAY#
         DEPTH = GETQ(DN$SDEPTH,DNAT$,DP);
         IF DEPTH EQ 0
         THEN L = GETQ(DN$ITMLEN,DNAT$,DP); 
         ELSE BEGIN 
              #INITIALIZE STORAGE REQUIRED# 
              L = 0;
              #CYCLE THROUGH EACH LEVEL OF SUBSCRIPTS#
              FOR REG1 = 1
              STEP 1
              UNTIL DEPTH 
              DO BEGIN
                 #ACCESS AUX CHAIN# 
                 REG2 = GETQ(DN$AUXREF,DNAT$,DP); 
SR1:  
                 #TEST FOR END OF CHAIN#
                 IF REG2 EQ 0 THEN GOTO SR2;
                 #TEST FOR RIGHT ENTRY AT RIGHT DEPTH#
                 IF GETQ(AX$TTYPE,AUX$,REG2) NQ MAXOCCUR
                    OR GETQ(AX$SUBSLVL,AUX$,REG2) NQ REG1 
                 THEN BEGIN 
                      REG2 = GETQ(AX$TNEXTPTR,AUX$,REG2); 
                      GOTO SR1; 
                      END 
                 #ADD ON LENGTH OF THIS DIMENSION OF ARRAY# 
                 L = L + GETQ(AX$OCCLEN,AUX$,REG2)
                        * GETQ(AX$MAXOCCNO,AUX$,REG2);
SR2:  
                 END
              END 
         STORAGE = L; 
         RETURN;
         END #OF STORAGE# 
         CONTROL EJECT; 
  
  # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *#
  # * #   EPTRACE("OVERLAP")                                       # * #
  # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *#
  
         #CHECK MEMORY AREAS FOR OVERLAP# 
         MSEC1 = GETQ(DN$MAJMSEC,DNAT$,DNAT1);
         MSEC2 = GETQ(DN$MAJMSEC,DNAT$,DNAT2);
         IF MSEC1 EQ MSEC2
         THEN BEGIN 
              #TEST FOR SPECIAL CASES#
              IF MSEC1 EQ FDMSEC OR MSEC1 EQ LINKMSEC 
              THEN BEGIN
                   #IF ONE IS FD OR LINKAGE THE OTHER IS ALSO#
                   #BECAUSE OF ABOVE TEST ON MAJOR MSEC#
                   $TEMP$ = GETQ(DN$SUBMSEC,DNAT$,DNAT1); 
                   IF $TEMP$
                      NQ
                      GETQ(DN$SUBMSEC,DNAT$,DNAT2)
                   THEN BEGIN 
                        OVERLAP = 0;
                        GOTO ENDLAP;
                        END 
                   #IF SUB$ MSECS ARE THE SAME WE CAN HAVE OVERLAP# 
                   START1 = GETQ(DN$BYTEOFFS,DNAT$,DNAT1);
                   START2 = GETQ(DN$BYTEOFFS,DNAT$,DNAT2);
                   END
              ELSE BEGIN
                   START1 = GETQ(DN$LONGOFF,DNAT$,DNAT1); 
                   START2 = GETQ(DN$LONGOFF,DNAT$,DNAT2); 
                   END
              END2 = START2 + STORAGE(DNAT2) - 1; 
              IF START1 LQ END2 
              THEN BEGIN
                   END1 = START1 + STORAGE(DNAT1) - 1;
                   IF END1 GQ START2
                   THEN BEGIN 
                        OVERLAP = 1;
                        GOTO ENDLAP;
                        END 
                   END
              END 
         OVERLAP = 0; 
ENDLAP: 
  
  # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *#
  # * #   EXTRACE("OVERLAP")                                       # * #
  # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *#
  
         RETURN;
         END   #OVERLAP#
         TERM 
