*DECK REPORTF 
USETEXT DNTEXT
USETEXT RPTEXT
PROC REPORTF; 
          BEGIN 
  
          #REPORT FOOTING ROUTINE#
          #X# 
          #THIS ROUTINE#
          #- PERFORMS THE ANALYSIS REQUIRED BY THE RULES IN#
          #6.13.5.10 TABLE 5 RF PRESENTATION RULE TABLE#
          #- IF POSSIBLE. ADDS AN ENTRY TO RGTLINK. BUILDS# 
          #-RFRGLINK# 
          #-RFLNLINK# 
          #-RFPLLINK# 
          #- SETS FLAGS. RFPFANALAARG. RFPFLOWLIMAN. BUILTRFTABLS#
          #FOR AFTER-ALL-REPORT-GROUPS-RT#
  
          ITEM
                 RFDIAGNO     I,
                 RFLINEREF    I,
                 INTPLTINDEX  I,
                 INTVALUE     I,
                 LASTABS      I,
                 RELINT       I,
                 RGDNATPTR    I,
                 AUXINDEX     I,
                 LLN          I,
                 BASERFLNTABL I,
                 INTINDEX     I,
                 BASERFPLTABL I,
                 BASERFRGTABL I,
                 SAUXINDEX    I,
                 NEXTENTRYAUX I,
                 USEDENTRYBIT I;
  
          DEF    M81          #81#; 
          DEF    M82          #82#; 
          DEF    M83          #83#; 
  
  
          ITEM   $TEMP$,
                $DUMMY$;
  
          XREF    PROC          SAUBCHANGE; 
          XREF   PROC         INTERCEPT;
          XREF   FUNC         PLTCNVRT I; 
          XREF   PROC         RWSET    ;
          XREF   PROC         RWSET1   ;
          XREF   PROC         GETNEXT  ;
          XREF   FUNC         RP$AUXPTR;
          XREF   FUNC         RWGET    ;
          XREF   FUNC         RWGET1   ;
  
          DEF    GET          #GETFIELD#; 
          DEF    SET          #SETFIELD#; 
          DEF    GETQ         #GETQUICK#; 
  
*CALL RPCOMM
*CALL GETSET
*CALL PNAT1 
*CALL TABLNAMES 
  
  
  
  
          CONTROL EJECT;
  
          #INTERNAL PROCEDURE NO 1  $S# 
  
PROC GENRGPNAT; 
          BEGIN 
          LASTPNATINDX = LASTPNATINDX + 1;
          SET(PN$PREVSECTN,PNAT$,LASTPNATINDX,RPDUMSECTION);
          #SEE"ONCE-ONLY"SECTION# 
          #NOT A SOURCE STATEMENT ITEM# 
          END #GENRGPNAT# 
  
          #INTERNAL PROCEDURE NO 3# 
  
PROC RTRFDIAG;
          BEGIN 
  
          #PARAMETERS = RFDIAGNO# 
          #RFLINEREF# 
  
          ANALONLYRGRP = 1; 
          CALLDDIAG(RFLINEREF,RFDIAGNO);
          END #RTRFDIAG#
          CONTROL EJECT;
  
  # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *#
  # * #   EPTRACE("REPORTF")                                       # * #
  # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *#
  
          BUILTRFTABLS = 0; 
          IF RDOCURDSWTCH EQ 0
          THEN
              GOTO ENDRFRT; 
          #FUTILE TO ATTEMPT ANALYSIS AS THERE# 
          #IS NO VALID CURRDDNAT# 
          IF RWGET1(QUEST$PAGECL  #CURRIRTPTR#) EQ 1
              #PAGE CL SPECIFIED# 
              AND 
              SEQOFLN EQ R
          THEN
              #* SET BIT IN IRT-TABLE#
              RWSET1(QUESTIONTERM  #CURRIRTPTR#,1); 
          IF IPAGECLAUSPC EQ 0
          THEN
              BEGIN 
              IF SEQOFLN EQ AR
                  OR
                  SEQOFLN EQ NPR
              THEN
                  GOTO ENDRFRT; 
              #DIAGNOSED ILLEGAL COMBINATION# 
              IF SEQOFLN EQ R 
                  OR
                  SEQOFLN EQ NULL$LN
              THEN
                  GOTO RFBLDTABLES; 
              END 
          IF IPAGECLAUSPC  EQ 1 
          THEN
              BEGIN 
              #* * * * * * * * * * * * * * * * * * * *# 
              IF SEQOFLN  EQ AR 
              THEN
                  BEGIN 
  
                  #FPLP =  RULE  3A#
  
                  INTPLTINDEX = RWGET(RALINENUMPLT, 
                                RP$AUXPTR(INDX1STLN));
                  INTVALUE = PLTCNVRT(INTPLTINDEX); 
                  RFFPLP = INTVALUE;
  
                  #PART 2 OF RULE 1A (UPPER LIMIT) WILL BE CHECKED 1ST# 
                  #KNOW THAT IF RFFPLP FAILS THIS TEST, IT WOULD# 
                  #LIKEWISE BE IN ERROR IF PF WERE PRESENTED,AS 1ST#
                  #PRINT LINE FOR PF IS FOOTING + 1  HOWEVER, IF RFFPLP#
                  #PASSES THIS TEST THEN PART 1 OF RULE 1A WILL HAVE TO#
                  #BE CHECKED IN AFTER-ALL-REPORT-GROUPS.#
  
                  INTPLTINDEX = RWGET(FOOTINGPLT, 
                                RP$AUXPTR(CURRDDNAT) + 1);
                  INTVALUE = PLTCNVRT(INTPLTINDEX); 
                  IF RFFPLP LS (INTVALUE + 1) 
                      #FOOTING + 1# 
                  THEN
                      BEGIN 
                      RFDIAGNO = M81; 
                      RFLINEREF = INDX1STLN;
                      RTRFDIAG; 
  
                      #DIAGNOSTIC (M81)#
                      #FIRST PRINT LINE POSITION OF REPORT FOOTING #
                      # VIOLATES UPPER #
                      #LIMIT RULE OF TABLE 5 - RF PRESENTATION RULES.#
                      GOTO
                      RFCOMPUTELLN; 
                      END 
  
                  #ELSE WHEN IS OK, MUST SET UP FOR A CHECK OF PART 1#
                  #OF RULE 1A#
  
                  RFPFANALAARG = 1; 
                  RFDIAGLINREF = DNATPOINTER; 
  
                  #COMPUTE LLN# 
  
RFCOMPUTELLN: 
                  LASTABS = 0;
                  #PLT-PTR# 
                  RELINT = 0; 
                  #INTEGER VALUE# 
                  FOR RGDNATPTR = (INDX1STLN + 1) STEP 1 UNTIL
                      LASTRGDNAT DO 
                      BEGIN 
                      AUXINDEX = RP$AUXPTR(RGDNATPTR);
                      IF RWGET(RALINENUMPLT,AUXINDEX) NQ  0 
                      THEN
                          BEGIN 
                          IF RWGET(RAKINDLINENO,AUXINDEX) EQ ABSOLUTE 
                          THEN
                              LASTABS = RWGET(RALINENUMPLT,AUXINDEX); 
                          #IF RELATIVE# 
                          ELSE
                              BEGIN 
  
                              INTPLTINDEX =RWGET(RALINENUMPLT,AUXINDEX);
                              INTVALUE = PLTCNVRT(INTPLTINDEX); 
                              RELINT = RELINT + INTVALUE; 
                              END 
                          END 
                      END 
                  IF LASTABS EQ 0 
                  THEN
                      LLN = RFFPLP + RELINT;
                  ELSE
                      BEGIN 
                      INTVALUE = PLTCNVRT(LASTABS); 
                      LLN = INTVALUE + RELINT;
                      END 
  
                  #COMPUTE LOWER LIMIT# 
  
                  INTPLTINDEX = RWGET(PAGELIMITPLT, 
                                RP$AUXPTR(CURRDDNAT) + 1);
                  INTVALUE = PLTCNVRT(INTPLTINDEX); 
  
                  #RULE 2 (LOWER LIMIT)#
  
                  IF LLN GR  INTVALUE 
                      #PAGE LIMIT#
                  THEN
                      BEGIN 
ERM82:  
                      RFDIAGNO  = M82;
                      RFLINEREF = DNATPOINTER;
                      RTRFDIAG; 
  
                      #DIAGNOSTIC (M82)#
                      #LINE INDICATED BY PAGE LIMIT INTEGER IS LAST # 
                      #LINE ON WHICH #
                      #REPORT FOOTING PRINT LINE CAN BE PRESENTED#
  
                      GOTO ENDRFRT; 
                      END 
                  GOTO RFBLDTABLES; 
                  END 
              #* * * * * * * * * * * * * * * * * * * *# 
              IF SEQOFLN EQ R 
              THEN
                  BEGIN 
  
                  #FPLP = RULE 3B#
                  #NOTE-                 BY VIRTUE OF ITS DEFINITION,#
                  #NEITHER FPLP AS DESCRIBED BY RULE 3B CAN POSSIBLY# 
                  #VIOLATE UPPER LIMIT RULE 1A... THUS NO NEED TO#
                  #VALIDATE RULE 3B FPLP"S AGAINST  RULE 1A UPPER#
                  #LIMITS.# 
  
                  #RULE 2 -LOWER LIMIT RULE#
                  #WILL FIRST COMPUTE THE FPLP AND LASTLINENUMB#
                  #FOR THE CASE IN WHICH A PAGE FOOTING WOULD NOT BE# 
                  #PRESENTED ON THE SAME PAGE. IF THIS CASE VIOLATES# 
                  #THE LOWER LIMIT RULE  THEN THE OTHER CASE (IN# 
                  #WHICH PAGE FOOTING WOULD BE PRESENTED ON THE SAME# 
                  #PAGE) WILL LIKEWISE VIOLATE THE LOWER LIMIT RULE.# 
                  #HOWEVER, IF THE FIRST ABOVE-MENTIONED CASE DOES  # 
                  #NOT VIOLATE LOWER LIMIT, THEN THE POSSIBILITY OF#
                  #THE OTHER CASE VIOLATING IT WILL HAVE TO BE# 
                  #CHECKED FOR IN AFTER-ALL-REPORT-GROUPS-RT(AARG).#
  
                  #COMPUTE SUMRELINENOS  ALSO SAVE IT FOR#
                  #POSSIBLE USE IN AARG.# 
                  SUMRELINENOS = 0; 
                  FOR RGDNATPTR =  INDX1STLN  STEP 1 UNTIL LASTRGDNAT DO
                      BEGIN 
                      AUXINDEX = RP$AUXPTR(RGDNATPTR);
                      IF RWGET(RALINENUMPLT,AUXINDEX) NQ 0
                      THEN
                          BEGIN 
                      INTPLTINDEX = RWGET(RALINENUMPLT,AUXINDEX); 
                      INTVALUE = PLTCNVRT(INTPLTINDEX); 
                          SUMRELINENOS = SUMRELINENOS + INTVALUE; 
                          END 
                      END 
                  INTPLTINDEX = RWGET(FOOTINGPLT,RP$AUXPTR(CURRDDNAT) 
                                + 1); 
                  #COMPUTE LASTLINENUMB#
  
                  LLN = SUMRELINENOS + INTVALUE;
                  #FOOTING# 
                  #COMPUTE LOWER LIMIT# 
                  INTPLTINDEX = RWGET(PAGELIMITPLT, 
                                RP$AUXPTR(CURRDDNAT) + 1);
                  INTVALUE = PLTCNVRT(INTPLTINDEX); 
                  IF LLN GR INTVALUE
                  THEN
                      GOTO ERM82; 
                  #DIAG. AND EXIT#
  
                  #ELSE HAVE TO SET UP FOR A LOWER LIMIT CHECK IN AARG# 
  
  
                  #SAVE LOWER LIMIT FOR AARG# 
  
                  RFLOWLIMIT = INTVALUE;
                  RFDIAGLINREF = DNATPOINTER; 
                  RFPFLOWLIMAN = 1; 
                  GOTO RFBLDTABLES; 
                  #* * * * * * * * * * * * * * * * * * * *# 
                  IF SEQOFLN EQ NPR 
                  THEN
                      BEGIN 
  
                      #FPLP = RULE 3C#
  
                      INTPLTINDEX = RWGET(RALINENUMPLT, 
                                    RP$AUXPTR(INDX1STLN));
                      INTVALUE = PLTCNVRT(INTPLTINDEX); 
                      RFFPLP = INTVALUE;
  
                      #UPPER LIMIT = RULE 1B# 
  
                      INTPLTINDEX = RWGET(HEADINGPLT, 
                                    RP$AUXPTR(CURRDDNAT));
                      INTVALUE = PLTCNVRT(INTPLTINDEX); 
                      IF RFFPLP LS INTVALUE 
                          #HEADING# 
                      THEN
                          BEGIN 
                          RFDIAGNO = M83; 
                          RFLINEREF = INDX1STLN;
                          RTRFDIAG; 
  
                          #DIAGNOSTIC (M83)#
                      #FIRST LINE ON WHICH THIS REPORT GROUP #
                      #CAN BE PRESENTED IS LINE NUMBER       #
                      #SPECIFIED BY HEADING PHRASE (UPPER LIMIT#
                      #RULE) #
                          #VIOLATION.#
                          END 
  
                      #COMPUTE LLN AND TEST AGAINST LOWER LIMIT#
  
                      GOTO RFCOMPUTELLN;
                      END 
                  END 
              END 
          #* * * * * * * * * * * * * * * * * * * * * * #
RFBLDTABLES:  
  
          #DETERMINE IF IT IS POSSIBLE OR WORTHWHILE TO BUILD ANY#
          #TABLES FOR THIS REPORT GROUP OR REPORT#
  
          IF ANALONLYREPT EQ 1
              OR
              ANALONLYRGRP EQ 1 
          THEN
              GOTO ENDRFRT; 
          BUILTRFTABLS = 1; 
          #* * * * * * * * * * * * * * * * * * * * * #
          #BUILD RFPLLINK#
  
          IF SEQOFLN EQ NULL$LN 
          THEN
              #WILL NOT BUILD RFPLLINK# 
              #NOR  RFLNLINK# 
              GOTO BRFRGTABLE;
          BASERFPLTABL = NEXTRFPLPTR; 
          USEDENTRYBIT = 0; 
          GETNEXT(RFPLLINK);
          #WILL HAVE TO HAVE ENTRY(S) FOR DELIMITERS EVEN IF ARE# 
          #NO PRINTABLE ITEMS - SO THAT CAN PRINT A LINE OF BLANKS.#
          IF INDX1STLN LS FIRSTF3OR4DE
          THEN
              $TEMP$ = FIRSTF3OR4DE;
          ELSE
              $TEMP$ = INDX1STLN; 
          FOR RGDNATPTR = $TEMP$ STEP 1 UNTIL LASTRGDNAT DO 
              BEGIN 
              AUXINDEX = RP$AUXPTR(RGDNATPTR);
              RWSET1(PL$DNATRF  #CURRRFPLPTR#,0); 
              IF RWGET(RAPRINTABLEB,AUXINDEX)EQ 0 
              THEN
                  GOTO RFPL2; 
              #ELSE PUT PRINTABLE INTO  RFPLLINK# 
              RWSET1(ALLVALUE$RF  #CURRRFPLPTR#,0); 
              RWSET1(SISOURCE$RF  #CURRRFPLPTR#,0); 
              RWSET1(PL$DNATRF  #CURRRFPLPTR#,RGDNATPTR); 
              RWSET1(PL$RF$DELIM  #CURRRFPLPTR#,0); 
              USEDENTRYBIT = 1; 
              IF RWGET(RASOURCEBIT,AUXINDEX) EQ 1 
              THEN
                  BEGIN 
                  RWSET1(ITEMTYPERF  #CURRRFPLPTR#,1);
                  SAUXINDEX = 1 + AUXINDEX; 
                  IF RWGET(RASRCESIBIT,SAUXINDEX) EQ 1
                  THEN
                      BEGIN 
                      RWSET1(SISOURCE$RF  #CURRRFPLPTR#,1); 
                      RWSET1(PI$SOURCERF  #CURRRFPLPTR#,SAUXINDEX); 
                      SAUBCHANGE(SAUXINDEX);
                      GOTO RFPL2; 
                      END 
  
                  #MUST CHECK IF SOUCE-ID WAS A CONTROL DATA ITEM#
                  #AND USE PREVIOUS VALUE DNAT IF IT WAS.#
                  IF CIDTPTRCURRD NQ 0
                  THEN
                      BEGIN 
                      CURRCIDTPTR = CIDTPTRCURRD; 
                          FOR $DUMMY$ = 0 WHILE RWGET1(CIDTLINK 
                              #CURRCIDTPTR#) NQ 0 DO
                          BEGIN 
                          IF RWGET1(CIDTCONTRLID  #CURRCIDTPTR#) EQ 
                             RWGET(RASRCEIDNAT,SAUXINDEX) 
                          THEN
                              BEGIN 
                                 $TEMP$ = RWGET1(CIDTPREVALUE 
                                          #CURRCIDTPTR#); 
                              RWSET1(PI$SOURCERF  #CURRRFPLPTR#,$TEMP$);
                              GOTO RFPL2; 
                              END 
                          CURRCIDTPTR =  RWGET1(CIDTLINK #CURRCIDTPTR#);
                          END 
                      END 
                  #IF NOT, THEN#
  
                  $TEMP$ = RWGET(RASRCEIDNAT,SAUXINDEX);
                  RWSET1(PI$SOURCERF  #CURRRFPLPTR#,$TEMP$);
                  GOTO RFPL2; 
                  END 
  
              #ELSE IF HAVE VALUE CLAUSE# 
  
              RWSET1(ITEMTYPERF  #CURRRFPLPTR#,0);
              $TEMP$ = RWGET(RAVALULITPLT,1 + AUXINDEX);
              RWSET1(PI$SOURCERF  #CURRRFPLPTR#,$TEMP$);
              IF RWGET(RAVALUALLIND,1 + AUXINDEX) EQ 1
              THEN
                  RWSET1(ALLVALUE$RF  #CURRRFPLPTR#,1); 
RFPL2:  
              IF RGDNATPTR EQ LASTRGDNAT
              THEN
                  BEGIN 
                  RWSET1(PL$RF$DELIM  #CURRRFPLPTR#,ENDREPORTGRP);
                  GOTO ENDRFPLDO; 
                  END 
  
              #ELSE CHECK IF NEXT ENTRY HAS A LINE NUMBER#
  
              NEXTENTRYAUX = RP$AUXPTR(RGDNATPTR + 1);
              IF RWGET(RA1LINENOPLT,NEXTENTRYAUX)EQ 0 
              THEN
                  GOTO RFPLEL;
              RWSET1(PL$RF$DELIM  #CURRRFPLPTR#,ENDPRINTLINE);
              USEDENTRYBIT = 1; 
RFPLEL: 
              IF USEDENTRYBIT EQ 0
              THEN
                  GOTO ENDRFPLDO; 
              USEDENTRYBIT = 0; 
              GETNEXT(RFPLLINK);
ENDRFPLDO:  
              END 
          #* * * * * * * * * * * * * * * * * * * * * #
          #BUILD RFLNLINK#
  
          BASERFLNTABL = NEXTRFLNPTR; 
          FOR RGDNATPTR = INDX1STLN  STEP 1 UNTIL LASTRGDNAT DO 
              BEGIN 
              AUXINDEX = RP$AUXPTR(RGDNATPTR);
              IF RWGET(RALINENUMPLT,AUXINDEX) NQ  0 
              THEN
                  BEGIN 
                  GETNEXT(RFLNLINK);
                  $TEMP$ = RWGET(RALINENUMPLT,AUXINDEX);
                  RWSET1(LNINT$PLTRF  #CURRRFLNPTR#,$TEMP$);
                  IF RWGET(RAKINDLINENO,AUXINDEX) EQ ABSOLUTE 
                  THEN
                      RWSET1(KIND$LNINTRF  #CURRRFLNPTR#,ABSOLUTE); 
                  IF RWGET(RAKINDLINENO,AUXINDEX) EQ RELATEVE 
                  THEN
                      RWSET1(KIND$LNINTRF  #CURRRFLNPTR#,RELATEVE); 
                  IF RWGET(RAKINDLINENO,AUXINDEX) EQ NEXTPAGEABSL 
                  THEN
                      RWSET1(KIND$LNINTRF  #CURRRFLNPTR#,NEXTPAGEABSL); 
                  END 
              END 
          #* * * * * * * * * * * * * * * * * * * * * * * *# 
          #BUILD RFRGLINK#
  
BRFRGTABLE: 
          BASERFRGTABL = NEXTRFRGPTR; 
          GETNEXT(RFRGLINK);
          RWSET1(RG$NAMERF  #CURRRFRGPTR#,DNATPOINTER); 
          RWSET1(TYPEOFRGRF  #CURRRFRGPTR#,RF); 
          RWSET1(RF$ERRORMES  #CURRRFRGPTR#,0); 
          RWSET1(RFPF$OVERLAP  #CURRRFRGPTR#,0);
          RWSET1(PFRFOVERLIMT  #CURRRFRGPTR#,0);
          #NOTE -#
          #THESE LAST 3 ENTRIES THAT HAVE BEEN SET = 0,#
          #WILL BE FILLED IN BY AFTER-ALL-REPORT-GROUPS-RT# 
          #IF FURTHER ANALYSIS INDICATES THAT IT IS NECESSARY.# 
          IF SEQOFLN EQ NULL$LN 
          THEN
              BEGIN 
              RWSET1(RFLN$BASE  #CURRRFRGPTR#,0); 
              RWSET1(RFPL$BASE  #CURRRFRGPTR#,0); 
              GOTO RFBLDRGSENTY;
              END 
          RWSET1(RFLN$BASE  #CURRRFRGPTR#,BASERFLNTABL);
          RWSET1(RFPL$BASE  #CURRRFRGPTR#,BASERFPLTABL);
          #* * * * * * * * * * * * * * * * * * * * * #
          #BUILD RGTLINK ENTRY# 
  
RFBLDRGSENTY: 
          GETNEXT(RGTLINK); 
          RWSET1(RGEOTDELIM  #CURRRPTGRPTR#,0); 
          RWSET1(RGTYPEOFRG  #CURRRPTGRPTR#,RF);
          RWSET1(RGBASERGTABL  #CURRRPTGRPTR#,BASERFRGTABL);
  
          #GEN NEW PARAGRAPH NAMES# 
          GENRGPNAT;
          RWSET1(RGPARANAME1  #CURRRPTGRPTR#,LASTPNATINDX); 
          GENRGPNAT;
          SET(PN$PERFLAST,PNAT$,LASTPNATINDX,1);
          RWSET1(RGPARANAME2  #CURRRPTGRPTR#,LASTPNATINDX); 
ENDRFRT:  
  
  # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *#
  # * #   EXTRACE("REPORTF")                                       # * #
  # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *#
  
          END #REPORTF# 
          TERM
