*DECK REPORTH 
USETEXT DNTEXT
USETEXT RPTEXT
PROC REPORTH; 
          BEGIN 
  
          #REPORT HEADING ROUTINE#
          #X# 
          #THIS ROUTINE#
          #- PERFORMS THE ANALYSIS REQUIRED BY THE RULES IN#
          #  6.13.5.6 TABLE 1 RH GROUP PRESENTATION RULE TABLE. # 
          #  IF POSSIBLE-                                       # 
          #   . ADDS AN ENTRY TO REPORT-GROUPS-TABLE (RGTLINK)  # 
          #   . BUILDS                                          # 
          #      -RHRGTABLE (RHRGLINK)                          # 
          #      -RHLNTABLE (RHLNLINK)                          # 
          #      -RHPLTABLE (RHPLLINK)                          # 
  
          ITEM
          RHDIAGNO             I, 
          RHLINEREF            I, 
          INTPLTINDEX          I, 
          INTVALUE              I,
          INTINDEX              I,
          NEWPLTINDEX          I, 
          NLENGTH                I, 
          FPLPPLTPTR           I, 
          FPLPINT               I,
          S$RESULT               I, 
          SUMREL                I,
          LASTABS               I,
          LNINDEX               I,
          LASTLINENUMB       I, 
          IFIRSTDETAIL         I, 
          BASERHPLTABL        I,
          RGDNATPTR            I, 
          AUXINDEX              I,
          SAUXINDEX             I,
          NEXTENTRYAUX         I, 
          BASERHLNTABL        I,
          LSTABSPLTPTR       I, 
          LASTINT               I,
          BASERHRGTABL        I,
          RLNINDEX              I,
          USEDENTRYBIT         I, 
          INTEGERVALUE       I, 
          CHARTEMP            C(10),
          CHARVALUE          C(3);
          DEF    M70        #70#; 
          DEF    M71        #71#; 
          DEF    M72        #72#; 
          DEF    M73        #73#; 
          DEF    M74        #74#; 
  
          DEF    INT1CONVERT  #INTVALUE = PLTCNVRT(INTPLTINDEX)#; 
  
  
          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 PLT1
*CALL PLTVALS 
*CALL PNAT1 
*CALL TABLNAMES 
  
  
  
  
          CONTROL EJECT;
          #$S  ****************************#
          #INTERNAL PROCEDURE NO 1A#
  
PROC RTRHDIAG;
          BEGIN 
  
              #PARAMETERS =  RHDIAGNO,# 
              #RHLINEREF# 
  
              ANALONLYRGRP = 1; 
              CALLDDIAG(RHLINEREF,RHDIAGNO);
              END #RTRHDIAG#
          CONTROL EJECT;
  
  
PROC CONST$NEWPLT;
          BEGIN 
          #THIS RT. CONSTRUCTS A NEW PLT ENTRY FOR/CONTAINING#
          #WHATEVER INTEGER IS CONTAINED IN INTEGERVALUE# 
          #ON ENTRANCE.IT LEAVES THE PLT INDEX OF THE NEW PLT ENTRY IN# 
          #NEWPLTINDEX  ON EXIT.# 
          ITEM VALUE; 
          ITEM LENGTH;
          ITEM REMAINS; 
          ITEM OUTDEX;
          ITEM C10       C(10); 
          VALUE = INTEGERVALUE; 
          IF VALUE EQ 0 
          THEN
              BEGIN 
              LENGTH = 1; 
              C<0,1> CHARTEMP = "0";
              END 
          ELSE
              BEGIN 
              OUTDEX = 10;
              FOR LENGTH = 0 STEP 1 WHILE VALUE NQ 0 DO 
                  BEGIN 
                  OUTDEX = OUTDEX - 1;
                  REMAINS = VALUE / 10; 
                  C<OUTDEX,1> C10 = VALUE - 10 * REMAINS + O"33"; 
                  VALUE = REMAINS;
                  END 
              C<0,LENGTH> CHARTEMP = C<OUTDEX,LENGTH> C10;
              END 
          #INTEGER IS CONVERTED TO CHARACTER (LEFT JUSTIFIED)#
          SET(PL$LENGTH,PLT$,RPPLTOFFSET,LENGTH); 
          SET(PL$TYPE,PLT$,RPPLTOFFSET,PLTUNSGNILIT); 
          SET(PL$LINE,PLT$,RPPLTOFFSET,0);
          SET(PL$COLUMN,PLT$,RPPLTOFFSET,0);
          SETPLST(RPPLTOFFSET,LOC(CHARTEMP)); 
          NEWPLTINDEX = RPPLTOFFSET;
          RPPLTOFFSET = RPPLTOFFSET + 1;
          END #CONST$NEWPLT#
          CONTROL EJECT;
  
          #INTERNAL PROCEDURE NO. 2#
  
PROC RH3A;
          BEGIN 
              #FIRST PRINT LINE POSITION  RULE A.#
              FPLPPLTPTR = RWGET(RALINENUMPLT,RP$AUXPTR(INDX1STLN));
              INTPLTINDEX =  FPLPPLTPTR;
              INT1CONVERT;
              #CONVERT 1ST LINE NUMBER# 
              FPLPINT = INTVALUE; 
              END #RH3A#
          CONTROL EJECT;
  
          #INTERNAL PROCEDURE  NO. 3# 
  
PROC RH3B;
          BEGIN 
              #FIRST PRINT LINE POSITION  RULE B.#
              INTPLTINDEX = 
              #FROM RD-CODE-ENTRY.# 
              RWGET(HEADINGPLT,RP$AUXPTR(CURRDDNAT)); 
              INT1CONVERT;
              S$RESULT = INTVALUE - 1;
              INTPLTINDEX = RWGET(RALINENUMPLT,RP$AUXPTR(INDX1STLN)); 
              INT1CONVERT;
              FPLPINT  =      INTVALUE + S$RESULT;
  
              #HAVE TO BUILD A NEW PLT ENTRY FOR FPLPINT, SO CAN BE#
              #USED IN RH-LN-TABLE# 
  
              INTEGERVALUE = FPLPINT; 
              CONST$NEWPLT; 
              FPLPPLTPTR =  NEWPLTINDEX;
              END #RH3B#
          CONTROL EJECT;
  
          #INTERNAL PROCEDURE NO. 4#
  
PROC RH3D;
          BEGIN 
              #FIRST PRINT LINE POSITION RULE D.# 
              #NOTE#
              #FPLP = CONTENTS OF LINE-COUNTER (IN THIS CASE, 0) + #
              #       FIRST INTEGER(RELATIVE) OF LINE NUMBER CLAUSE.  # 
              #-THUS THIS RELATIVE INTEGER CAN BE TREATED THE SAME    # 
              # AS THE ABSOLUTE IN 3A.                                # 
              RH3A; 
              END #RH3D#
          CONTROL EJECT;
  
          #INTERNAL PROCEDURE NO. 5#
  
PROC LLNCOMPUTE;
          BEGIN 
  
              #LLN = LAST LINE NUMBER, IE.- LINE NUMBER ON WHICH FINAL# 
              #PRINT LINE OF RH REPORT GROUP IS PRESENTED (ACC. TO# 
              #USER SPECS). THIS PROC. LEAVES IT IN#
              #LASTLINENUMB.# 
              SUMREL = 0; 
              LASTABS = 0;
              FOR LNINDEX = (INDX1STLN + 1) STEP 1 UNTIL LASTRGDNAT DO
                  BEGIN 
                  IF RWGET(RALINENUMPLT,RP$AUXPTR(LNINDEX)) 
                      NQ  0 
                  THEN
                      BEGIN 
                      IF RWGET(RAKINDLINENO,RP$AUXPTR(LNINDEX)) 
                      EQ ABSOLUTE 
                      THEN
                          LASTABS = LNINDEX;
                      ELSE
                          GOTO FOUNDRELATIV;
                      END 
                  END 
              #IF FOUND ONLY ABSOLUTE LINE NUMBERS OR-# 
              #IF FOUND NO NEW LINE NUMBER SPEC"S#
              GOTO LLN2;
FOUNDRELATIV: 
              FOR RLNINDEX = LNINDEX STEP 1 UNTIL LASTRGDNAT DO 
                  BEGIN 
                  #WILL ASSUME ANY LN ENCOUNTERED TO BE RELATIVE# 
                  IF RWGET(RALINENUMPLT,RP$AUXPTR(RLNINDEX))
                      NQ 0
                  THEN
                      BEGIN 
                      INTPLTINDEX = 
                          RWGET(RALINENUMPLT,RP$AUXPTR(RLNINDEX));
                      INT1CONVERT;
                      SUMREL = SUMREL  + INTVALUE;
                      END 
                  END 
LLN2: 
              IF SEQOFLN EQ R 
              THEN
                  BEGIN 
                  LASTLINENUMB  = SUMREL  + FPLPINT;
                  GOTO ENDLLN;
                  END 
  
              #ELSE WHEN SEQOFLN = AR#
              IF LASTABS EQ 0 
              THEN
                  BEGIN 
                  LASTLINENUMB =  FPLPINT  +  SUMREL; 
                  GOTO ENDLLN;
                  END 
  
              #ELSE-# 
              INTPLTINDEX = RWGET(RALINENUMPLT,RP$AUXPTR(LASTABS)); 
              INT1CONVERT;
              LASTLINENUMB = INTVALUE  + SUMREL;
ENDLLN: 
              END #LLNCOMPUTE#
          CONTROL EJECT;
  
          #INTERNAL PROCEDURE NO 6# 
  
PROC RH2A;
          BEGIN 
              #LOWER  LIMIT RULE  2A# 
              INTPLTINDEX = 
              #FROM RD-CODE-ENTRY.# 
              RWGET(F1STDTAILPLT,RP$AUXPTR(CURRDDNAT)); 
              INT1CONVERT;
              IFIRSTDETAIL = INTVALUE;
              #WILL BE USED IN RH4A#
              IF LASTLINENUMB  GR IFIRSTDETAIL - 1
              THEN
                  BEGIN 
  
                  #DIAGNOSTIC (M70)#
                  #LINE NUMBER SPECIFICATIONS FOR THIS RH REPORT GROUP# 
                  #CAUSE FINAL PRINT LINE TO EXCEED LOWER LIMIT (FIRST-#
                  #DETAIL - 1)# 
  
                  RHDIAGNO = M70; 
                  RHLINEREF = DNATPOINTER;
                  RTRHDIAG; 
                  END 
              END #RH2A#
          CONTROL EJECT;
  
          #INTERNAL PROCEDURE NO 7# 
  
PROC RH2B;
              #LOWER LIMIT  RULE 2B#
          BEGIN 
              INTPLTINDEX = 
                  RWGET(PAGELIMITPLT,1 + RP$AUXPTR(CURRDDNAT)); 
              INT1CONVERT;
              IF LASTLINENUMB  GR  INTVALUE 
              THEN
                  BEGIN 
  
                  #DIAGNOSTIC(M71)# 
                  #LINE NUMBER SPECIFICATIONS FOR THIS RH-REPORT GROUP# 
                  #CAUSE FINAL PRINT LINE TO EXCEED PAGE LIMIT# 
  
                  RHDIAGNO = M71; 
                  RHLINEREF = DNATPOINTER;
                  RTRHDIAG; 
                  END 
              END #RH2B#
          CONTROL EJECT;
  
          #INTERNAL PROCEDURE NO.8# 
  
PROC RH4A;
              #NEXT GROUP RULE  4A# 
          BEGIN 
              IF SVNGINTEGER  GR LASTLINENUMB 
                  AND 
                  SVNGINTEGER  LS  IFIRSTDETAIL 
                  #FROM RH2A# 
              THEN
                  GOTO ENDRH4A; 
  
              #DIAGNOSTIC(M72)# 
              #NEXT GROUP INTEGER     IN THIS RH REPORT GROUP MUST BE >#
              #FINAL LINE OF RH REPORT GROUP AND < FIRST DETAIL INTEGER#
              RHDIAGNO = M72; 
              RHLINEREF = DNATPOINTER;
              RTRHDIAG; 
ENDRH4A:  
              END #RH4A#
          CONTROL EJECT;
  
          #INTERNAL PROCEDURE NO 9# 
  
PROC RH4B;
         BEGIN
              IF (SVNGINTEGER  +  LASTLINENUMB) 
                  LS IFIRSTDETAIL 
                  #FROM RH2A# 
              THEN
                  GOTO ENDRH4B; 
  
              #DIAGNOSTIC  (M73)# 
              #SUM OF NEXT GROUP INTEGER AND NUMBER OF FINAL PRINT LINE#
              #OF THIS RH REPORT GROUP MUST BE < FIRST DETAIL INTEGER.# 
              RHDIAGNO = M73; 
              RHLINEREF = DNATPOINTER;
              RTRHDIAG; 
ENDRH4B:  
              END #RH4B#
          CONTROL EJECT;
  
          #INTERNAL PROCEDURE NO 10#
  
PROC RH1; 
              #UPPER LIMIT  RULE# 
          BEGIN 
              INTPLTINDEX = 
              #FROM RD-CODE-ENTRY.# 
              RWGET(HEADINGPLT,RP$AUXPTR(CURRDDNAT)); 
              INT1CONVERT;
              #CONVERT HEADING# 
              IF INTVALUE  GR  FPLPINT
              THEN
                  BEGIN 
  
                  #DIAGNOSTIC (M74)#
                  #FIRST LINE NUMBER ON WHICH RH GROUP CAN BE PRESENTED#
                  #IS ONE SPECIFIED BY HEADING PHRASE OF PAGE CLAUSE.#
                  RHDIAGNO  = M74;
                  RHLINEREF = INDX1STLN;
                  RTRHDIAG; 
                  END 
              END #RH1# 
          CONTROL EJECT;
  
          #INTERNAL  PROCEDURE NO. 11#
  
PROC GEN$RG$PNAT; 
          #GEN A NEW PARAGRAPH NAME#
          BEGIN 
              LASTPNATINDX = LASTPNATINDX + 1;
              SET(PN$PREVSECTN,PNAT$,LASTPNATINDX,RPDUMSECTION);
              #SEE"ONCE-ONLY"SECTION# 
              #NOT A SOURCE STATEMENT ITEM# 
              END #GEN$RG$PNAT# 
          CONTROL EJECT;
  
  # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *#
  # * #   EPTRACE("REPORTH")                                       # * #
  # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *#
  
          IF RDOCURDSWTCH EQ 0
          THEN
              GOTO ENDRHRT; 
          #IS FUTILE TO ATTEMPT ANALYSIS# 
          #ON PRESENTATION RULES AS THERE IS NO VALID#
          #CURRDDNAT# 
  
          IF SEQOFLN EQ NPR 
          THEN
              #THAT FACT IS AN ALREADY DIAGNOSED ERROR  WILL SET# 
              #IT = AR TO ATTEMPT MORE POSSIBLY HELPFUL ANALYSIS# 
              SEQOFLN =     AR; 
          #BASED ON TABLE 1 REPORT HEADING GRP PRESENTATION RULE TABLE# 
  
          IF IPAGECLAUSPC EQ 0
              #NO PAGE CLAUSE#
          THEN
              BEGIN 
              IF SEQOFLN EQ R 
              THEN
                  BEGIN 
                  IF TNEXTGROUP EQ R
                      OR
                      TNEXTGROUP EQ NULLNG
                  THEN
                      BEGIN 
                      RH3D; 
                      LLNCOMPUTE; 
                      GOTO RH$BLDTABLES;
                      END 
  
                  #ELSE IS ILLEGAL COMBINATION  ALREADY DIAGNOSED SO# 
                  GOTO ENDRHRT; 
                  END 
              IF SEQOFLN EQ NULL$LN 
                  AND 
                  TNEXTGROUP   EQ NULLNG
              THEN
                  GOTO RH$BLDTABLES;
              #AS MUST KEEP THIS REPORT#
              #GROUP ALIVE IN CASE OF U-B-R  EVEN THO NOTHING#
              #PRINTABLE# 
  
              #ELSE IS ILLEGAL COMBINATION ALREADY DIAGNOSED, SO# 
              GOTO ENDRHRT; 
              END 
  
          #ELSE, WHEN PAGE CLAUSE IS SPECIFIED# 
  
          IF SEQOFLN  EQ AR 
              OR
              SEQOFLN  EQ R 
          THEN
              BEGIN 
              IF SEQOFLN EQ AR
              THEN
                  BEGIN 
                  SWITCH NXTGRPTYPE RH1CALL,TNG1CASE,TNG2CASE,TNG3CASE, 
                                    TNG4CASE; 
                  GOTO NXTGRPTYPE[TNEXTGROUP];
TNG1CASE: 
                      #NG = ABSOLUTE# 
                          BEGIN 
                          RH3A; 
                          LLNCOMPUTE; 
                          RH2A; 
                          RH4A; 
                          GOTO RH1CALL; 
                          END 
TNG2CASE: 
                      #NG = RELATIVE# 
                          BEGIN 
                          RH3A; 
                          LLNCOMPUTE; 
                          RH2A; 
                          RH4B; 
                          GOTO RH1CALL; 
                          END 
TNG3CASE: 
                      #NG = NEXT PAGE#
                          BEGIN 
                          RH3A; 
                          LLNCOMPUTE; 
                          RH2B; 
                          GOTO RH1CALL; 
                          END 
TNG4CASE: 
                      #NG =  NULL#
                          BEGIN 
                          RH3A; 
                          LLNCOMPUTE; 
                          RH2A; 
                          GOTO RH1CALL; 
                          END 
                  END 
  
              #ELSE WHEN SEQUENCE OF LN = R,  THEN# 
                  SWITCH NEXTGRPTYP RH1CALL,RNG1CASE,RNG2CASE,RNG3CASE, 
                                    RNG4CASE; 
                  GOTO NEXTGRPTYP[TNEXTGROUP];
RNG1CASE: 
                  #NG = ABSOLUTE# 
                      BEGIN 
                      RH3B; 
                      LLNCOMPUTE; 
                      RH2A; 
                      RH4A; 
                      GOTO RH1CALL; 
                      END 
RNG2CASE: 
                  #NG = RELATIVE# 
                      BEGIN 
                      RH3B; 
                      LLNCOMPUTE; 
                      RH2A; 
                      RH4B; 
                      GOTO RH1CALL; 
                      END 
RNG3CASE: 
                  #NG = NEXT PAGE#
                      BEGIN 
                      RH3B; 
                      LLNCOMPUTE; 
                      RH2B; 
                      GOTO RH1CALL; 
                      END 
RNG4CASE: 
                  #NG = NULL# 
                      BEGIN 
                      RH3B; 
                      LLNCOMPUTE; 
                      RH2A; 
                      GOTO RH1CALL; 
                      END 
RH1CALL:  
              RH1;
              GOTO RH$BLDTABLES;
              END 
          IF SEQOFLN EQ NULL$LN 
              AND 
              SEQOFLN EQ NULLNG 
          THEN
              GOTO RH$BLDTABLES;
          #MUST KEEP REPORT GROUP ALIVE#
  
          #ELSE IS ILLEGAL  ANALONLYRGRP = 1 ALREADY, SO-#
          GOTO ENDRHRT; 
RH$BLDTABLES: 
  
          #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 ENDRHRT; 
          #***********************# 
          #BUILD  RHPLLINK# 
  
          IF SEQOFLN EQ NULL$LN 
          THEN
              #WILL NOT BUILD   RHPLLINK# 
              #NOR    RHLNLINK# 
              GOTO  BRHRGTABLE; 
          BASERHPLTABL = NEXTRHPLPTR; 
          USEDENTRYBIT = 0; 
          GETNEXT(RHPLLINK);
          #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$DNATRH  #CURRRHPLPTR#,0); 
              #IN CASE NO PRINTABLE ITEMS IN THIS DNAT# 
              IF RWGET(RAPRINTABLEB,AUXINDEX) EQ 0
              THEN
                  GOTO RHPL2; 
              #ELSE PUT PRINTABLE ITEM INTO RHPLLINK# 
              USEDENTRYBIT = 1; 
              RWSET1(ALLVALUE$RH  #CURRRHPLPTR#,0); 
              RWSET1(SISOURCE$RH  #CURRRHPLPTR#,0); 
              RWSET1(PL$DNATRH  #CURRRHPLPTR#,RGDNATPTR); 
              RWSET1(PL$RH$DELIM  #CURRRHPLPTR#,0); 
              IF RWGET(RASOURCEBIT,AUXINDEX) EQ 1 
              THEN
                  BEGIN 
                  RWSET1(ITEMTYPERH  #CURRRHPLPTR#,1);
                  SAUXINDEX = 1 + AUXINDEX; 
                  IF RWGET(RASRCESIBIT,SAUXINDEX) EQ 1
                  THEN
                      BEGIN 
                      RWSET1(SISOURCE$RH  #CURRRHPLPTR#,1); 
                      RWSET1(PI$SOURCERH  #CURRRHPLPTR#,SAUXINDEX); 
                      SAUBCHANGE(SAUXINDEX);
                      GOTO RHPL2; 
                      END 
                  $TEMP$ = RWGET(RASRCEIDNAT,SAUXINDEX);
                  RWSET1(PI$SOURCERH  #CURRRHPLPTR#,$TEMP$);
                  GOTO RHPL2; 
                  END 
  
              #ELSE IF HAVE VALUE CLAUSE# 
  
              RWSET1(ITEMTYPERH  #CURRRHPLPTR#,0);
              $TEMP$ = RWGET(RAVALULITPLT,1+ AUXINDEX); 
              RWSET1(PI$SOURCERH  #CURRRHPLPTR#,$TEMP$);
              IF RWGET(RAVALUALLIND,1 + AUXINDEX) EQ 1
              THEN
                  RWSET1(ALLVALUE$RH  #CURRRHPLPTR#,1); 
RHPL2:  
              IF RGDNATPTR EQ LASTRGDNAT
              THEN
                  BEGIN 
                  RWSET1(PL$RH$DELIM  #CURRRHPLPTR#,ENDREPORTGRP);
                  GOTO ENDRHPLDO; 
                  END 
  
              #ELSE CHECK IF NEXT ENTRY HAS A LINE NUMBER#
  
              NEXTENTRYAUX =    RP$AUXPTR(RGDNATPTR + 1); 
              IF RWGET(RA1LINENOPLT,NEXTENTRYAUX) EQ 0
              THEN
                  GOTO RHPL$EL; 
              RWSET1(PL$RH$DELIM  #CURRRHPLPTR#,ENDPRINTLINE);
              USEDENTRYBIT = 1; 
RHPL$EL:    
              IF USEDENTRYBIT EQ 0
              THEN
                  GOTO ENDRHPLDO; 
              USEDENTRYBIT = 0; 
              GETNEXT(RHPLLINK);
ENDRHPLDO:  
              END 
          #******************************#
          #BUILD RHLNLINK#
  
          BASERHLNTABL = NEXTRHLNPTR; 
          GETNEXT(RHLNLINK);
          RWSET1(ABSOLUT$LNRH  #CURRRHLNPTR#,FPLPPLTPTR); 
          LSTABSPLTPTR = FPLPPLTPTR;
          LASTINT = 0;
          FOR RGDNATPTR = (INDX1STLN + 1) STEP 1 UNTIL LASTRGDNAT DO
              BEGIN 
              AUXINDEX = RP$AUXPTR(RGDNATPTR);
              IF RWGET(RA1LINENOPLT,AUXINDEX) 
                  NQ 0
              THEN
                  BEGIN 
                  GETNEXT(RHLNLINK);
                  IF RWGET(RA1KINDLINNO,AUXINDEX) EQ ABSOLUTE 
                  THEN
                      BEGIN 
                      $TEMP$ = RWGET(RALINENUMPLT,AUXINDEX);
                      RWSET1(ABSOLUT$LNRH  #CURRRHLNPTR#,$TEMP$); 
                      LSTABSPLTPTR = RWGET(RALINENUMPLT,AUXINDEX);
                      GOTO ENDRHLNDO; 
                      END 
  
                  #IF RELATIVE# 
                  IF LSTABSPLTPTR EQ 0
                  THEN
                      GOTO CONVREL; 
                  INTPLTINDEX = LSTABSPLTPTR; 
                  INT1CONVERT;
                  LASTINT = INTVALUE; 
                  LSTABSPLTPTR = 0; 
CONVREL:  
                  INTPLTINDEX = RWGET(RALINENUMPLT,AUXINDEX); 
                  INT1CONVERT;
                  LASTINT = LASTINT + INTVALUE; 
                  INTEGERVALUE = LASTINT; 
                  CONST$NEWPLT; 
                  RWSET1(ABSOLUT$LNRH  #CURRRHLNPTR#,NEWPLTINDEX);
                  END 
ENDRHLNDO:  
              END 
          #**************************#
          #BUILD RHRGLINK#
  
BRHRGTABLE: 
          BASERHRGTABL = NEXTRHRGPTR; 
          GETNEXT(RHRGLINK);
          RWSET1(RHRG$NAME  #CURRRHRGPTR#,DNATPOINTER); 
          RWSET1(RHTYPEOFRG  #CURRRHRGPTR#,RH); 
          IF SEQOFLN EQ NULL$LN 
          THEN
              BEGIN 
              RWSET1(RHLN$BASE  #CURRRHRGPTR#,0); 
              RWSET1(RHPL$BASE  #CURRRHRGPTR#,0); 
              RWSET1(RHNGFRASEIND  #CURRRHRGPTR#,0);
              RWSET1(NGINTPLTRH  #CURRRHRGPTR#,0);
              GOTO BRGSTABLE; 
              END 
          RWSET1(RHLN$BASE  #CURRRHRGPTR#,BASERHLNTABL);
          RWSET1(RHPL$BASE  #CURRRHRGPTR#,BASERHPLTABL);
          SWITCH RHNXTGRP BRGSTABLE,TNG1CASEX,TNG2CASEX,TNG3CASEX,
                          TNG4CASEX;
          GOTO RHNXTGRP[TNEXTGROUP];
          #ALSO SET RHFINALLCSET TO BE USED IN ARGROUP# 
          #TO CHECK FOR RH, PH OVERLAP.               # 
TNG1CASEX:  
                  #ABSOLUTE#
                  BEGIN 
                  RWSET1(RHNGFRASEIND  #CURRRHRGPTR#,AR); 
                  $TEMP$ = RWGET(RANGINTPLT,RP$AUXPTR(DNATPOINTER)+ 1); 
                  RWSET1(NGINTPLTRH  #CURRRHRGPTR#,$TEMP$); 
                  RHFINALLCSET = SVNGINTEGER; 
                  GOTO BRGSTABLE; 
                  END 
TNG2CASEX:  
                  #REL.#
                  BEGIN 
                  INTEGERVALUE =
                  #NEW ABSOLUTE NG INTEGER# 
                      LASTLINENUMB + SVNGINTEGER; 
          RHFINALLCSET = INTEGERVALUE;
                  CONST$NEWPLT; 
                  RWSET1(NGINTPLTRH  #CURRRHRGPTR#,NEWPLTINDEX);
                  RWSET1(RHNGFRASEIND  #CURRRHRGPTR#,AR); 
                  GOTO BRGSTABLE; 
                  END 
TNG3CASEX:  
                  BEGIN 
                  #NEXT PAGE# 
                  RWSET1(RHNGFRASEIND  #CURRRHRGPTR#,NP); 
                  GOTO BRGSTABLE; 
                  END 
TNG4CASEX:  
                  #NULL NG# 
                  BEGIN 
                  RWSET1(RHNGFRASEIND  #CURRRHRGPTR#,0);
                  GOTO BRGSTABLE; 
                  END 
          #**************************************#
          #BUILD RGTLINK ENTRY# 
  
BRGSTABLE:  
          GETNEXT(RGTLINK); 
          RWSET1(RGEOTDELIM  #CURRRPTGRPTR#,0); 
          RWSET1(RGTYPEOFRG  #CURRRPTGRPTR#,RH);
          RWSET1(RGBASERGTABL  #CURRRPTGRPTR#,BASERHRGTABL);
          #GEN NEW PARAGRAPH NAMES# 
          GEN$RG$PNAT;
          RWSET1(RGPARANAME1  #CURRRPTGRPTR#,LASTPNATINDX); 
          GEN$RG$PNAT;
          SET(PN$PERFLAST,PNAT$,LASTPNATINDX,1);
          RWSET1(RGPARANAME2  #CURRRPTGRPTR#,LASTPNATINDX); 
ENDRHRT:  
  
  # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *#
  # * #   EXTRACE("REPORTH")                                       # * #
  # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *#
  
          END  #REPORTH#
          TERM
