*DECK IRT$RT
USETEXT CCTTEXT 
USETEXT DNTEXT
USETEXT RPTEXT
PROC IRT$RT;
          BEGIN 
  
          #IRT$RT#
          #X# 
          #THIS ROUTINE#
          #- CONSTRUCTS THE INFO-REPORT-TABLE FOR#
          #THE CURRENT RD#
  
  
  
          XREF   PROC         INTERCEPT;
          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#; 
  
          ITEM
                 $TEMP$,
                 GRUPITEMLGTH I,
                 FDRDINDEX    I,
                 CCPLTPTR     I,
                 CODEAUXINDX  I,
                 PAGEAUXINDX  I,
                 RUNMSG       C(72);
  
*CALL RPCOMM
*CALL AUXT1 
*CALL AUXTVALS
*CALL DNATVALS
*CALL FDRDT1
*CALL GETSET
*CALL PLT1
*CALL PLTVALS 
*CALL PNAT1 
*CALL TABLNAMES 
  
  
          CONTROL EJECT;
  
          #INTERNAL PROCEDURE  NO. 1# 
  
PROC GENIRT;
          BEGIN 
          LASTPNATINDX = LASTPNATINDX + 1;
  
          #WILL SET  P-PERFORM-FIRST  AND#
          #P-PERFORM-LAST#
          #OUTSIDE OF THIS PROCEDURE# 
  
          #NOT A SOURCE STATEMENT#
          #ITEM#
          SET(PN$PREVSECTN,PNAT$,LASTPNATINDX,RPDUMSECTION);
          #SEE "ONCE-ONLY" SECTION# 
          END #GENIRT#
          CONTROL EJECT;
  
          #INTERNAL PROCEDURE  NO. 2# 
  
PROC FILLINPLT; 
          BEGIN 
          SET(PL$TYPE,PLT$,RPPLTOFFSET,PLTQUOTEDLIT); 
          SET(PL$LINE,PLT$,RPPLTOFFSET,0);
          SET(PL$COLUMN,PLT$,RPPLTOFFSET,0);
          END #FILLINPLT# 
          CONTROL EJECT;
  
          #INTERNAL PROCEDURE NO. 3#
  
PROC FILLCAT3DNAT;
          BEGIN 
          LASTDNATINDX = LASTDNATINDX + 1;
          SET(DN$PICTURE,DNAT$,LASTDNATINDX,1); 
          SET(DN$LEVEL,DNAT$,LASTDNATINDX,02);
          SET(DN$MAJMSEC,DNAT$,LASTDNATINDX,RDMSEC);
          RDLBYTOFFSET = ((RDLBYTOFFSET + 9 ) / 10 ) * 10;
          SET(DN$LONGOFF,DNAT$,LASTDNATINDX,RDLBYTOFFSET);
          SET(DN$ITMLEN,DNAT$,LASTDNATINDX,10); 
          RDLBYTOFFSET = RDLBYTOFFSET + 10; 
          SET(DN$TYPE,DNAT$,LASTDNATINDX,COMP1);
          SET(DN$POINT,DNAT$,LASTDNATINDX,0); 
          SET(DN$NUMLEN,DNAT$,LASTDNATINDX,7);
          #PIC 9999999# 
          END #FILLCAT3DNAT#
          CONTROL EJECT;
  
          #INTERNAL PROCEDURE NO 4# 
  
PROC FILGROUPDNAT;
          BEGIN 
          LASTDNATINDX = LASTDNATINDX + 1;
          SET(DN$LEVEL,DNAT$,LASTDNATINDX,01);
          SET(DN$MAJMSEC,DNAT$,LASTDNATINDX,RDMSEC);
          SET(DN$LONGOFF,DNAT$,LASTDNATINDX,RDLBYTOFFSET);
          SET(DN$ITMLEN,DNAT$,LASTDNATINDX,GRUPITEMLGTH); 
          #DO NOT UPDATE OFFSET - SO THAT FIRST ELEMENTARY# 
          #ITEM WILL HAVE SAME BYTE OFFSET# 
  
          SET(DN$TYPE,DNAT$,LASTDNATINDX,GROUP);
          END #FILGROUPDNAT#
          CONTROL EJECT;
  
          #INTERNAL PROCEDURE  NO. 5# 
  
PROC FILLTYPEDNAT;
          BEGIN 
          LASTDNATINDX = LASTDNATINDX + 1;
          SET(DN$PICTURE,DNAT$,LASTDNATINDX,1); 
          SET(DN$LEVEL,DNAT$,LASTDNATINDX,02);
          SET(DN$MAJMSEC,DNAT$,LASTDNATINDX,RDMSEC);
          RDLBYTOFFSET = ((RDLBYTOFFSET + 9 ) / 10 ) * 10;
          SET(DN$LONGOFF,DNAT$,LASTDNATINDX,RDLBYTOFFSET);
          SET(DN$ITMLEN,DNAT$,LASTDNATINDX,10); 
          RDLBYTOFFSET = RDLBYTOFFSET + 10; 
          SET(DN$TYPE,DNAT$,LASTDNATINDX,COMP1);
          SET(DN$POINT,DNAT$,LASTDNATINDX,0); 
          SET(DN$NUMLEN,DNAT$,LASTDNATINDX,1);
          #1 DEC DIGIT# 
          END #FILLTYPEDNAT#
          CONTROL EJECT;
  
          #INTERNAL PROCEDURE NO.6# 
  
PROC BLDSWICHDNAT;
          BEGIN 
          LASTDNATINDX = LASTDNATINDX + 1;
          SET(DN$LEVEL,DNAT$,LASTDNATINDX,01);
          SET(DN$MAJMSEC,DNAT$,LASTDNATINDX,RDMSEC);
          RDLBYTOFFSET = ((RDLBYTOFFSET + 9) / 10 ) * 10; 
          SET(DN$LONGOFF,DNAT$,LASTDNATINDX,RDLBYTOFFSET);
          SET(DN$ITMLEN,DNAT$,LASTDNATINDX,1);
          RDLBYTOFFSET = RDLBYTOFFSET + 1;
          SET(DN$TYPE,DNAT$,LASTDNATINDX,ALPHNUM);
          END #BLDSWICHDNAT#
          CONTROL EJECT;
  
          #INFO-REPORT-TABLE# 
          #ROUTINE PROCEDURES --# 
  #* * * * * * * * * * * * * * * * * * * * * #
          EPTRACE("IRT$RT") 
  
  
          IF NOFDFLAG EQ 1
              OR
              INHIBITABLDF EQ 1 
          THEN
              GOTO ENDIRTRT;
          IRTCURRBASE  = NEXTIRTPTR;
          #FOR USE OF#
          #PROGRDLINK RT# 
          GETNEXT(IRTLINK); 
  
          #BUILD CATEGORY 1 ITEMS -#
  
          RWSET1(IRTPCINDEX #CURRIRTPTR# ,PAGECNTRDNAT);
          RWSET1(IRTLCINDEX #CURRIRTPTR# ,LINECNTRDNAT);
          #*******# 
          #*BUILD ALL CATEGORY 2 ITEMS -# 
          #********#
  
          #****#
          #* BUILD THE RECORD AREA FOR THE CURRENT RD#
          #*    .RECORD$NAME1#
          #*    .CODE-CLAUSE-REC-AREA (OPTIONAL, AND# 
          #*                           PART OF AI SECTION OF IRT)#
          #*    .CC$REC$AREA# 
          #*    .PL$REC$NAME# 
          #****#
  
          #.BUILD A DNAT FOR  01 RECORD$NAME1#
  
          LASTDNATINDX = LASTDNATINDX + 1;
          RWSET1(RECORD$NAME1 #CURRIRTPTR# ,LASTDNATINDX);
          SET(DN$LEVEL,DNAT$,LASTDNATINDX,01);
  
          #NOTE#
          #FD/ PRINT LINE REDEFINITIONS OF A RECORD AREA WILL USE#
          #DNAT-MAJOR-MSEC      BIT(04),# 
          #DNAT-SUB-MSEC        BIT(12),# 
          #DNAT-BYTE-OFFSET     BIT(16),# 
          #DNAT-MAJOR-MSEC WILL ALWAYS BE SET = 1 (THE NUMBER ASSIGNED #
          #FOR FD).                                                    #
          #DNAT-SUB-MSEC  WILL BE PICKED UP BY R-PARSER OUT OF         #
          #FDRDTABLE.                                                  #
          #DNAT-BYTE-OFFSET = USER"S COLUMN NUMBER SPECIFICATION       #
          #    + 2 FOR CODE CLAUSE LITS. (IF SPECIFIED)                #
          #    + 1 FOR CARRIAGE CONTROL                                #
  
          #***# 
          #*LOOK IN FD-RD-TABLE TO DETERMINE    SUB-MSEC FOR FILE#
          #*OF CURRENT RD#
          #* ALTHOUGH MORE THAN 1 RD MAY BE ASSOCIATED WITH AN FD#
          #* THERE IS ONLY ONE PHYSICAL RECORD AREA PER FD  SO-#
          #* ALTHOUGH R-ANALYZER BUILDS DNAT ENTRIES FOR A RECORD#
          #* AREA FOR EACH RD, IN THE CASE OF MULTIPLE RD"S TO A# 
          #* FILE, THEY GET ASSIGNED THE SAME BYTE-OFFSET SO# 
          #* THAT THE WHOLE RECORD AREA BECOMES A "REDEFINITION"# 
          #****#
  
          FOR FDRDINDEX = 1 STEP 1 UNTIL LASTFDRDNTRY DO
              BEGIN 
              IF GETQ(FR$REPTNAME,FDRDT$,FDRDINDEX) EQ DNATPOINTER
              THEN
                  BEGIN 
                  MSECCURRFILE = GETQ(FR$FILEMSEC,FDRDT$,FDRDINDEX);
                  #INITIALIZE OFFSET FOR THE RECORD AREA# 
                  CURFILOFFSET = 0; 
                  GOTO SETMSEC; 
                  END 
              END 
SETMSEC:  
          SET(DN$SUBMSEC,DNAT$,LASTDNATINDX,MSECCURRFILE);
          SET(DN$MAJMSEC,DNAT$,LASTDNATINDX,FDMSEC);
          SET(DN$BYTEOFFS,DNAT$,LASTDNATINDX,CURFILOFFSET); 
          #(NOT UPDATED SO THAT FIRST LEVEL 2 ITEM# 
          #WILL START AT SAME PLACE)# 
  
          SET(DN$TYPE,DNAT$,LASTDNATINDX,GROUP);
  
          #THE ITEM-LENGTH OF RECORD$NAME1 MUST BE FILLED IN# 
          #AFTER ALL REPORT GROUPS HAVE BEEN ANALYZED#
          #AND -# 
          #DNAT-ITEM-LENGTH(RECNAME1DNAT) =            #
          #    MAX-PRINT-LINE-LENGTH +     #
          #    ITEM-LENGTH-CARRIAGE-CONTROL-REC-AREA + #
          #    (OPTIONALLY) TWO-BYTES-FOR-CODE-CLAUSE # 
          LNGTHLONGPLE = 0;   #MAX LENGTH WILL BE MAINTAINED HERE#
                              #BY COLUMNCL AS IT CHECKS PRINT    #
                              #LINE LENGTH.                      #
  
          RECNAME1DNAT = LASTDNATINDX;
          #*************************************************# 
          #BUILD A TYPE FILE-NAME (17) AUX-TABLE ENTRY# 
          #TO BE ASSOCIATED WITH THE RECORD NAME DNAT#
  
          LASTAUXENTRY = LASTAUXENTRY + 1;
          SET(DN$AUXREF,DNAT$,RECNAME1DNAT,LASTAUXENTRY); 
          SET(AX$TTYPE,AUX$,LASTAUXENTRY,FILENAME); 
          SET(AX$TNEXTPTR,AUX$,LASTAUXENTRY,0); 
          FOR FDRDINDEX = 1 STEP 1 UNTIL LASTFDRDNTRY DO
              BEGIN 
              IF GETQ(FR$REPTNAME,FDRDT$,FDRDINDEX) EQ DNATPOINTER
              THEN
                  BEGIN 
                  $TEMP$ = GETQ(FR$FILENAME,FDRDT$,FDRDINDEX);
                  SET(AX$FDPTR,AUX$,LASTAUXENTRY,$TEMP$); 
                  $TEMP$ = GETQ(FR$FNATPTR,FDRDT$,FDRDINDEX); 
                  SET(AX$FNATPTR,AUX$,LASTAUXENTRY,$TEMP$); 
                  $TEMP$ = GETQ(FR$CODEBIT,FDRDT$,FDRDINDEX); 
                  SET(AX$CODECL,AUX$,LASTAUXENTRY,$TEMP$);
                  GOTO IRT$BCCRA; 
                  END 
              END 
          #. BUILD CODE-CLAUSE-REC-AREA  IF A VALID CODE CLAUSE#
          #EXISTS. THIS ITEM GOES INTO AI-SECTION OF IRT BUT# 
          #NEEDS TO BE BUILT HERE SO THAT THE FILE BYTE-OFFSET# 
          #CAN BE CALCUATED CORRECTLY#
  
IRT$BCCRA:  
          IF  NOCODECLAUSE EQ 1 
          THEN
              GOTO  BUILDCCRA;
          LASTDNATINDX = LASTDNATINDX + 1;
          RWSET1(CODCLRECAREA #CURRIRTPTR# ,LASTDNATINDX);
          SET(DN$LEVEL,DNAT$,LASTDNATINDX,02);
          SET(DN$SUBMSEC,DNAT$,LASTDNATINDX,MSECCURRFILE);
          SET(DN$MAJMSEC,DNAT$,LASTDNATINDX,FDMSEC);
          SET(DN$BYTEOFFS,DNAT$,LASTDNATINDX,CURFILOFFSET); 
          SET(DN$ITMLEN,DNAT$,LASTDNATINDX,2);
          CURFILOFFSET = CURFILOFFSET + 
                         GETQ(DN$ITMLEN,DNAT$,LASTDNATINDX);
          SET(DN$TYPE,DNAT$,LASTDNATINDX,ALPHNUM);
          #. BUILD DNAT FOR CC$REC$AREA#
  
BUILDCCRA:  
          LASTDNATINDX = LASTDNATINDX + 1;
          RWSET1(CC$REC$AREA #CURRIRTPTR# ,LASTDNATINDX); 
          SET(DN$LEVEL,DNAT$,LASTDNATINDX,02);
          SET(DN$MAJMSEC,DNAT$,LASTDNATINDX,FDMSEC);
          SET(DN$SUBMSEC,DNAT$,LASTDNATINDX,MSECCURRFILE);
          SET(DN$BYTEOFFS,DNAT$,LASTDNATINDX,CURFILOFFSET); 
          SET(DN$ITMLEN,DNAT$,LASTDNATINDX,1);
          CURFILOFFSET = CURFILOFFSET + 
                         GETQ(DN$ITMLEN,DNAT$,LASTDNATINDX);
          SET(DN$TYPE,DNAT$,LASTDNATINDX,ALPHNUM);
          #. BUILD DNAT FOR PL$REC$NAME#
          #EACH PRINT LINE DESCRIBED BY THE USER WILL APPEAR# 
          #AS#
          #LINE DESCRIBED BY THE USER FOR THIS REPORT WILL BE A#
          #REDEFINITION OF PL$REC$NAME)#
  
          LASTDNATINDX = LASTDNATINDX + 1;
          RWSET1(PL$REC$NAME #CURRIRTPTR# ,LASTDNATINDX); 
          SET(DN$LEVEL,DNAT$,LASTDNATINDX,02);
          SET(DN$SUBMSEC,DNAT$,LASTDNATINDX,MSECCURRFILE);
          SET(DN$MAJMSEC,DNAT$,LASTDNATINDX,FDMSEC);
          SET(DN$BYTEOFFS,DNAT$,LASTDNATINDX,CURFILOFFSET); 
          #ITEM-LENGTH WILL HAVE TO BE SET IN PL$REC$NAME#
          #DNAT AFTER ALL REPORT GROUPS HAVE BEEN ANALYZED  IT WILL#
          #THEN BE SET TO THE LENGTH OF THE LONGEST PRINT LINE# 
          #DESCRIBED. # 
          #NEITHER SHOULD BYTE-OFFSET BE UPDATED. THE FIRST"LEVEL 3" #
          #ITEM OF EACH PRINT LINE DESCRIBED SHOULD BE ASSIGNED#
          #THE SAME BYTE-OFFSET AS PL$REC$NAME# 
  
          F1OFFSETPRNT = CURFILOFFSET;
          #(TRANSFORMDTS RT. USES THIS)#
          SET(DN$TYPE,DNAT$,LASTDNATINDX,ALPHNUM);
          #****#
          #* BUILD DNAT ENTRIES FOR THE FOLLOWING CATEGORY 2 ITEMS# 
          #*    . INITIATEFLAG# 
          #*    . FIRSTGENERAT  (FLAG)# 
          #*    . GENERATEFLAG. RH$ON$PAGE. PH$PRESENTED# 
          #*    . POTP$SWITCH#
          #*    . SUMMARY-REPORT-SWITCH (INITIALIZE TO 0)#
          #****#
  
          BLDSWICHDNAT; 
          RWSET1(INITIATEFLAG #CURRIRTPTR# ,LASTDNATINDX);
  
          # INITIALIZE INITFLAG TO 0# 
          SET(DN$VALUE,DNAT$,LASTDNATINDX,1); 
          SET(DN$PLTPTR,DNAT$,LASTDNATINDX, RPPLTOFFSET); 
          SET(PL$LENGTH,PLT$,RPPLTOFFSET,1);
          FILLINPLT;
          RUNMSG = "0"; 
          SETPLST(RPPLTOFFSET,LOC(RUNMSG)); 
          RPPLTOFFSET = RPPLTOFFSET + 1;
  
          BLDSWICHDNAT; 
          RWSET1(FIRSTGENERAT #CURRIRTPTR# ,LASTDNATINDX);
          BLDSWICHDNAT; 
          RWSET1(GENERATEFLAG #CURRIRTPTR# ,LASTDNATINDX);
          BLDSWICHDNAT; 
          RWSET1(RH$ON$PAGE #CURRIRTPTR# ,LASTDNATINDX);
          BLDSWICHDNAT; 
          RWSET1(PH$PRESENTED #CURRIRTPTR# ,LASTDNATINDX);
          BLDSWICHDNAT; 
          RWSET1(POTP$SWITCH #CURRIRTPTR# ,LASTDNATINDX); 
          BLDSWICHDNAT; 
          RWSET1(SUMREPSWITCH #CURRIRTPTR# ,LASTDNATINDX);
  
          #BUILD PLT AND LAT ENTRIES TO INITIALIZE# 
          #SUMREPSWITCH TO 0(OFF) # 
  
          SET(DN$VALUE,DNAT$,LASTDNATINDX,1); 
          SET(DN$PLTPTR,DNAT$,LASTDNATINDX,RPPLTOFFSET);
          #PLT PTR# 
          #FOR ENTRY THAT IS GOING TO BE BUILT# 
  
          #PLT ENTRY FOR "0" -(DNAT TYPE IS ALPHANUMERIC)#
  
          SET(PL$LENGTH,PLT$,RPPLTOFFSET,1);
          FILLINPLT;
          RUNMSG = "0"; 
          SETPLST(RPPLTOFFSET,LOC(RUNMSG)); 
          RPPLTOFFSET = RPPLTOFFSET + 1;
  
          #BUILD THE DNAT TO HOLD THE LINE NUMBER OF THE# 
          #CURRENTLY EXECUTING REPORT WRITER VERB.      # 
  
          BLDSWICHDNAT; 
          SET(DN$ITMLEN,DNAT$,LASTDNATINDX,5);
          RDLBYTOFFSET = RDLBYTOFFSET + 4;
          CCTRWVRBLINE = LASTDNATINDX;
  
          #****#
          #*BUILD DNAT ENTRIES FOR THE FOLLOWING CATEGORY 2 ITEMS#
          #*    . SLN#
          #*    . SPACING$AREA  (SET-CODE LITS IF THEY EXIST)#
          #*    . SPACE$1  (CURRENTLY SET =     FOR CC)#
          #*    . NO-ADVANCE (CURRENTLY SET =  +  FOR CC)#
          #*    . RGTEMPORARY#
          #****#
  
          #.  BUILD DNAT FOR  SLN#
  
          LASTDNATINDX = LASTDNATINDX + 1;
          RWSET1(SLN #CURRIRTPTR# ,LASTDNATINDX); 
          SET(DN$LEVEL,DNAT$,LASTDNATINDX,01);
          SET(DN$MAJMSEC,DNAT$,LASTDNATINDX,RDMSEC);
          RDLBYTOFFSET = ((RDLBYTOFFSET + 9 ) / 10 ) * 10;
          SET(DN$LONGOFF,DNAT$,LASTDNATINDX,RDLBYTOFFSET);
          SET(DN$ITMLEN,DNAT$,LASTDNATINDX,10); 
          RDLBYTOFFSET = RDLBYTOFFSET+ 10;
          SET(DN$TYPE,DNAT$,LASTDNATINDX,COMP1);
          SET(DN$POINT,DNAT$,LASTDNATINDX,0); 
          SET(DN$NUMLEN,DNAT$,LASTDNATINDX,7);
          #PIC 9999999# 
          #. BUILD DNAT FOR SPACING$AREA  SET IT = THE CODE LITS# 
          #IF THEY EXIST BY BUILDING AN LAT ENTRY. ELSE SET IT =  # 
          #2 BLANKS BY BUILDING A PLT AND A LAT ENTRY.            # 
  
  
          #BUILD DNAT FOR SPACING$AREA# 
  
          LASTDNATINDX = LASTDNATINDX + 1;
          RWSET1(SPACING$AREA #CURRIRTPTR# ,LASTDNATINDX);
          SET(DN$LEVEL,DNAT$,LASTDNATINDX,01);
          SET(DN$MAJMSEC,DNAT$,LASTDNATINDX,RDMSEC);
          RDLBYTOFFSET = ((RDLBYTOFFSET + 9) / 10 ) * 10; 
          SET(DN$LONGOFF,DNAT$,LASTDNATINDX,RDLBYTOFFSET);
          SET(DN$ITMLEN,DNAT$,LASTDNATINDX,2);
          RDLBYTOFFSET = RDLBYTOFFSET+ 2; 
          SET(DN$TYPE,DNAT$,LASTDNATINDX,ALPHNUM);
  
          #BUILD PARTIAL LAT ENTRY AND THEN#
          #CHECK TO SEE WHAT THE VALUE OF SPACING$AREA WILL BE# 
  
          SET(DN$VALUE,DNAT$,LASTDNATINDX,1); 
          IF
              NOCODECLAUSE EQ 1 
          THEN
              GOTO SA$OF$BLANKS;
          SET(DN$PLTPTR,DNAT$,LASTDNATINDX,CODELITPLT); 
          #=PLT INDEX FOR#
          #ACTUAL VALUE OF CODE CLAUSE LITERAL# 
          IF ALL4CODELIT EQ 1 
          THEN
          SET(PL$ALL,PLT$,CODELITPLT,1);
          GOTO BLDSPACE1; 
SA$OF$BLANKS: 
          SET(DN$PLTPTR,DNAT$,LASTDNATINDX,RPPLTOFFSET);
          #PLT PTR FOR# 
          #ENTRY THAT IS GOING TO BE BUILT FOR BLANKS#
  
          #BUILD PLT ENTRY FOR  2 BLANKS# 
  
          SET(PL$LENGTH,PLT$,RPPLTOFFSET,2);
          FILLINPLT;
          RUNMSG = "  ";
          SETPLST(RPPLTOFFSET,LOC(RUNMSG)); 
          RPPLTOFFSET = RPPLTOFFSET + 1;
          #. BUILD DNAT FOR SPACE$1  AND ASSOCIATED#
          #PLT AND LAT ENTRIES# 
  
BLDSPACE1:  
          LASTDNATINDX = LASTDNATINDX + 1;
          RWSET1(SPACE$1 #CURRIRTPTR# ,LASTDNATINDX); 
          SET(DN$LEVEL,DNAT$,LASTDNATINDX,01);
          SET(DN$MAJMSEC,DNAT$,LASTDNATINDX,RDMSEC);
          RDLBYTOFFSET = ((RDLBYTOFFSET + 9) / 10 ) * 10; 
          SET(DN$LONGOFF,DNAT$,LASTDNATINDX,RDLBYTOFFSET);
          SET(DN$ITMLEN,DNAT$,LASTDNATINDX,1);
          RDLBYTOFFSET = RDLBYTOFFSET+ 1; 
          SET(DN$TYPE,DNAT$,LASTDNATINDX,ALPHNUM);
  
          #BUILD THE PLT ENTRY FOR THE CARRIAGE CONTROL#
          #CHARACTER THAT WILL EFFECT A SPACE 1#
  
          SET(PL$LENGTH,PLT$,RPPLTOFFSET,1);
          FILLINPLT;
          RUNMSG = " "; 
          SETPLST(RPPLTOFFSET,LOC(RUNMSG)); 
          CCPLTPTR = RPPLTOFFSET; 
          RPPLTOFFSET = RPPLTOFFSET + 1;
  
          #BUILD THE LAT ENTRY FOR SPACE$1 AND# 
          #CC CHARACTER#
  
          SET(DN$VALUE,DNAT$,LASTDNATINDX,1); 
          SET(DN$PLTPTR,DNAT$,LASTDNATINDX,CCPLTPTR); 
          #. BUILD DNAT FOR NO-ADVANCE  AND ASSOCIATED PLT AND LAT# 
          #ENTRIES# 
  
          LASTDNATINDX = LASTDNATINDX + 1;
          RWSET1(NOADVANCE #CURRIRTPTR# ,LASTDNATINDX); 
          SET(DN$LEVEL,DNAT$,LASTDNATINDX,01);
          SET(DN$MAJMSEC,DNAT$,LASTDNATINDX,RDMSEC);
          RDLBYTOFFSET = ((RDLBYTOFFSET + 9) / 10 ) * 10; 
          SET(DN$LONGOFF,DNAT$,LASTDNATINDX,RDLBYTOFFSET);
          SET(DN$ITMLEN,DNAT$,LASTDNATINDX,1);
          RDLBYTOFFSET = RDLBYTOFFSET+ 1; 
          SET(DN$TYPE,DNAT$,LASTDNATINDX,ALPHNUM);
          #BUILD THE PLT ENTRY FOR THE CARRIAGE CONTROL CHARACTER#
          #THAT WILL EFFECT A WRITE AFTER ADVANCING 0#
  
          SET(PL$LENGTH,PLT$,RPPLTOFFSET,1);
          FILLINPLT;
          RUNMSG = "+"; 
          SETPLST(RPPLTOFFSET,LOC(RUNMSG)); 
          CCPLTPTR = RPPLTOFFSET; 
          RPPLTOFFSET = RPPLTOFFSET + 1;
  
          #BUILD THE LAT ENTRY FOR NO-ADVANCE AND CC CHARACTER# 
  
          SET(DN$VALUE,DNAT$,LASTDNATINDX,1); 
          SET(DN$PLTPTR,DNAT$,LASTDNATINDX,CCPLTPTR); 
          #. BUILD DNAT ENTRY FOR RGTEMPORARY#
  
          FILLCAT3DNAT; 
          SET(DN$LEVEL,DNAT$,LASTDNATINDX,01);
          RWSET1(RGTEMPORARY #CURRIRTPTR# ,LASTDNATINDX); 
  
          #BUILD CATEGORY 4 ITEMS -                            #
          #(IE.- BEGINNING AND ENDING PARAGRAPH NAMES FOR THE  #
          #FOLLOWING ROUTINES THAT WILL BE GENERATED BY THE REPORT #
          #GENERATOR PHASE-                                        #
          #    * INITIATE                                          #
          #    * TERMINATE                                         #
          #    * SPACING                                           #
          #    * BODYNEXTGRUP )                                    #
          #    * BODYPAGING   ) ONLY IF IS A VALID PAGE CLAUSE     #
          #    * PAGEADVANCE  )                                    #
  
          GENIRT; 
          RWSET1(INITIATE #CURRIRTPTR# ,LASTPNATINDX);
  
          GENIRT; 
          SET(PN$PERFLAST,PNAT$,LASTPNATINDX,1);
          RWSET1(INITIATEXIT #CURRIRTPTR# ,LASTPNATINDX); 
  
          GENIRT; 
          RWSET1(TERMINATE #CURRIRTPTR# ,LASTPNATINDX); 
  
          GENIRT; 
          SET(PN$PERFLAST,PNAT$,LASTPNATINDX,1);
          RWSET1(TERMINATEXIT #CURRIRTPTR# ,LASTPNATINDX);
  
          GENIRT; 
          SET(PN$PERFLAST,PNAT$,LASTPNATINDX,1);
          RWSET1(SPACING #CURRIRTPTR# ,LASTPNATINDX); 
  
          #PAGEAUXINDX  SET UP FOR THIS RT: # 
          PAGEAUXINDX = 1 + RP$AUXPTR(DNATPOINTER); 
          IF RWGET(PAGELIMITPLT,PAGEAUXINDX) EQ 0 
          THEN
              #(IS NO VALID PAGE CLAUSE)# 
          GOTO BUILDCAT5; 
  
          RWSET1(BODYNEXTGRUP #CURRIRTPTR# ,IRTBODYNXTGP);
  
          RWSET1(BNG$EXIT #CURRIRTPTR# ,IRTBNGEXIT);
  
          RWSET1(BODYPAGING #CURRIRTPTR# ,IRTXBODYPAG); 
  
          RWSET1(BP$EXIT #CURRIRTPTR# ,IRTBPEXIT);
  
          GENIRT; 
          SET(PN$PERFLAST,PNAT$,LASTPNATINDX,1);
          RWSET1(PAGEADVANCE #CURRIRTPTR# ,LASTPNATINDX); 
  
          #BUILD CATEGORY 5 ITEMS -#
  
BUILDCAT5:  
          SET(PL$LENGTH,PLT$,RPPLTOFFSET,1);
          SET(PL$TYPE,PLT$,RPPLTOFFSET,PLTUNSGNILIT); 
          SET(PL$LINE,PLT$,RPPLTOFFSET,0);
          SET(PL$COLUMN,PLT$,RPPLTOFFSET,0);
          RUNMSG = "0"; 
          SETPLST(RPPLTOFFSET,LOC(RUNMSG)); 
          RWSET1(IRTINTZERO #CURRIRTPTR# ,RPPLTOFFSET); 
          RPPLTOFFSET = RPPLTOFFSET + 1;
  
          SET(PL$LENGTH,PLT$,RPPLTOFFSET,1);
          SET(PL$TYPE,PLT$,RPPLTOFFSET,PLTUNSGNILIT); 
          SET(PL$LINE,PLT$,RPPLTOFFSET,0);
          SET(PL$COLUMN,PLT$,RPPLTOFFSET,0);
          RUNMSG = "1"; 
          SETPLST(RPPLTOFFSET,LOC(RUNMSG)); 
          RWSET1(IRTINTONE #CURRIRTPTR# ,RPPLTOFFSET);
          RPPLTOFFSET = RPPLTOFFSET + 1;
  
          SET(PL$LENGTH,PLT$,RPPLTOFFSET,1);
          SET(PL$TYPE,PLT$,RPPLTOFFSET,PLTNEGILIT); 
          SET(PL$LINE,PLT$,RPPLTOFFSET,0);
          SET(PL$COLUMN,PLT$,RPPLTOFFSET,0);
          RUNMSG = "1"; 
          SETPLST(RPPLTOFFSET,LOC(RUNMSG)); 
          RWSET1(IRTINTNEGONE #CURRIRTPTR# ,RPPLTOFFSET); 
          RPPLTOFFSET = RPPLTOFFSET + 1;
  
          #BUILD CATEGORY 6 ITEMS -#
  
          SET(PL$LENGTH,PLT$,RPPLTOFFSET,1);
          FILLINPLT;
          SET(PL$TYPE,PLT$,RPPLTOFFSET,PLTUNSGNILIT); 
          RUNMSG = "7"; 
          SETPLST(RPPLTOFFSET,LOC(RUNMSG)); 
          RWSET1(INITERRORPLT #CURRIRTPTR# ,RPPLTOFFSET); 
          RPPLTOFFSET = RPPLTOFFSET + 1;
  
          SET(PL$LENGTH,PLT$,RPPLTOFFSET,1);
          FILLINPLT;
          SET(PL$TYPE,PLT$,RPPLTOFFSET,PLTUNSGNILIT); 
          RUNMSG = "8"; 
          SETPLST(RPPLTOFFSET,LOC(RUNMSG)); 
          RWSET1(TERMERRORPLT #CURRIRTPTR# ,RPPLTOFFSET); 
          RPPLTOFFSET = RPPLTOFFSET + 1;
  
          SET(PL$LENGTH,PLT$,RPPLTOFFSET,1);
          FILLINPLT;
          SET(PL$TYPE,PLT$,RPPLTOFFSET,PLTUNSGNILIT); 
          RUNMSG = "1"; 
          SETPLST(RPPLTOFFSET,LOC(RUNMSG)); 
          RWSET1(SPACERRORPLT #CURRIRTPTR# ,RPPLTOFFSET); 
          RPPLTOFFSET = RPPLTOFFSET + 1;
  
          SET(PL$LENGTH,PLT$,RPPLTOFFSET,1);
          FILLINPLT;
          SET(PL$TYPE,PLT$,RPPLTOFFSET,PLTUNSGNILIT); 
          RUNMSG = "4"; 
          SETPLST(RPPLTOFFSET,LOC(RUNMSG)); 
          RWSET1(DETAILERRPLT #CURRIRTPTR# ,RPPLTOFFSET); 
          RPPLTOFFSET = RPPLTOFFSET + 1;
  
  
          #BUILD CATEGORY 10  ITEM -# 
  
  
          #BUILD A PLT ENTRY TO CONTAIN THE ENTRYPOINT NAME#
          #OF THE RUNTIME ROUTINE WHICH GETS ENTERED TO LOG#
          #REPORT WRITER RUNTIME ERROR MESSAGES.           #
  
          SET(PL$LENGTH,PLT$,RPPLTOFFSET,7);
          SET(PL$TYPE,PLT$,RPPLTOFFSET,PLTQUOTEDLIT); 
          SET(PL$LINE,PLT$,RPPLTOFFSET,0);
          SET(PL$COLUMN,PLT$,RPPLTOFFSET,0);
          RUNMSG = "C.RWMSG"; 
          SETPLST(RPPLTOFFSET,LOC(RUNMSG)); 
          $TEMP$ = RPPLTOFFSET; 
          RWSET1(OSINCIDENCE #CURRIRTPTR# ,RPPLTOFFSET);
          RPPLTOFFSET = RPPLTOFFSET + 1;
  
          #BUILD CATEGORY 3 ITEMS IF VALID PAGE CLAUSE EXISTS.  # 
          #(CAT. 3 ITEMS = NEW DNAT ENTRIES)                    # 
  
          IF RWGET(PAGELIMITPLT,PAGEAUXINDX) EQ 0 
          THEN
              #(IS NO VALID PAGE CLAUSE)# 
          GOTO BUILD$AI;
  
          #BUILD  01 BP$TABLE  (GROUP NAME)           # 
          #(IE.- CONSTRUCT DNAT ENTRY FOR GROUP ITEM) # 
  
          GRUPITEMLGTH= 40; 
          FILGROUPDNAT; 
          RWSET1(BP$TABLE #CURRIRTPTR# ,LASTDNATINDX);
  
          #BUILD FIRST ELEMENTARY ITEM -# 
          #02 TYPE$LINENUM# 
  
          FILLTYPEDNAT; 
          RWSET1(TYPE$LINENUM #CURRIRTPTR# ,LASTDNATINDX);
  
          #BUILD SECOND ELEMENTARY ITEM -#
          #02 FIRSTLINENUM# 
  
          FILLCAT3DNAT; 
          RWSET1(FIRSTLINENUM #CURRIRTPTR# ,LASTDNATINDX);
          #BUILD -  02 LOWER$LIMIT# 
          FILLCAT3DNAT; 
          RWSET1(LOWER$LIMIT #CURRIRTPTR# ,LASTDNATINDX); 
          #BUILD-  02  LENGTH$RG# 
          FILLCAT3DNAT; 
          RWSET1(LENGTH$RG #CURRIRTPTR# ,LASTDNATINDX); 
  
          #BUILD   01 NG$TABLE    (GROUP NAME)# 
  
          GRUPITEMLGTH = 20;
          FILGROUPDNAT; 
          RWSET1(NG$TABLE #CURRIRTPTR# ,LASTDNATINDX);
  
          #BUILD FIRST ELEMENTARY ITEM# 
          #02 TYPENEXTGRUP# 
  
          FILLTYPEDNAT; 
          RWSET1(TYPENEXTGRUP #CURRIRTPTR# ,LASTDNATINDX);
  
          #BUILD-   02 NEXTGROUPINT#
  
          FILLCAT3DNAT; 
          RWSET1(NEXTGROUPINT #CURRIRTPTR# ,LASTDNATINDX);
  
          #END OF CATEGORY 3 PROCEDURES#
  
  
          #BUILD CATEGORY 7 ITEMS IF VALID PAGE CLAUSE EXISTS  #
          #-(CAT.7 ITEMS = PAGE CLAUSE VALUES)                 #
  
          $TEMP$ = RWGET(PAGELIMITPLT,PAGEAUXINDX); 
          RWSET1(IRTPAGELIMIT #CURRIRTPTR# ,$TEMP$);
          $TEMP$ = RWGET(FOOTINGPLT,PAGEAUXINDX); 
          RWSET1(FOOTING #CURRIRTPTR# ,$TEMP$); 
          CODEAUXINDX = RP$AUXPTR(DNATPOINTER); 
          $TEMP$ = RWGET(F1STDTAILPLT,CODEAUXINDX); 
          RWSET1(IRTFIRSTDETL #CURRIRTPTR# ,$TEMP$);
          $TEMP$ = RWGET(HEADINGPLT,CODEAUXINDX); 
          RWSET1(HEADING #CURRIRTPTR# ,$TEMP$); 
  
          #END OF PROCEDURES FOR CAT. 7#
  
  
          #BUILD ADDITIONAL INFORMATION SECTION#
  
BUILD$AI: 
          RWSET1(BASE$CNTROLS #CURRIRTPTR# ,STRTCURCONTB);
          IF RWGET(PAGELIMITPLT,PAGEAUXINDX) EQ 0 
          THEN
              BEGIN 
              RWSET1(QUEST$PAGECL #CURRIRTPTR# ,0); 
              RWSET1(BASE$IPCT #CURRIRTPTR# ,0);
              GOTO DOCODECL;
              END 
          RWSET1(QUEST$PAGECL #CURRIRTPTR# ,1); 
          #SAYS PAGE CLAUSE EXISTS# 
          RWSET1(BASE$IPCT #CURRIRTPTR# ,BASECURRIPCT); 
DOCODECL: 
          IF
              NOCODECLAUSE  EQ 1
          THEN
              RWSET1(CODE$CL$LITS #CURRIRTPTR# ,0); 
          #NULL#
          ELSE
              BEGIN 
              #1) BUILD DNAT FOR CODE$CL$LITS#
  
              LASTDNATINDX = LASTDNATINDX + 1;
              RWSET1(CODE$CL$LITS #CURRIRTPTR# ,LASTDNATINDX);
              SET(DN$LEVEL,DNAT$,LASTDNATINDX,01);
              SET(DN$MAJMSEC,DNAT$,LASTDNATINDX,RDMSEC);
              SET(DN$LONGOFF,DNAT$,LASTDNATINDX,RDLBYTOFFSET);
              SET(DN$ITMLEN,DNAT$,LASTDNATINDX,2);
              SET(DN$TYPE,DNAT$,LASTDNATINDX,ALPHNUM);
              RDLBYTOFFSET = RDLBYTOFFSET+ 2; 
  
              #2) BUILD CORRESPONDING LAT ENTRY FOR CODE-CLAUSE-# 
              #LITERALS  DNAT ENTRY - WHICH SERVES THE PURPOSE OF#
              #SETTING CODE$CL$LITS = THE CODE LITERALS#
  
              SET(DN$VALUE,DNAT$,LASTDNATINDX,1); 
              SET(DN$PLTPTR,DNAT$,LASTDNATINDX,CODELITPLT); 
              IF  ALL4CODELIT EQ 1
              THEN
                  SET(PL$ALL,PLT$,CODELITPLT,1);
  
              #NOTE-  THE DNAT ENTRY FOR CODE-CLAUSE-REC-AREA#
              #WAS BUILT WHEN THE RECORD AREA WAS BUILT UNDER#
              #THE CATEGORY 2 SECTION#
  
              END 
          RWSET1(BASE$REPORTG #CURRIRTPTR# ,NEXTRPTGRPTR);
          RWSET1(BASE$GRPIND #CURRIRTPTR# ,NEXTGRINDPTR); 
          RWSET(DEGROUPDNAT,NEXTGRINDPTR,0);
          #IN CASE NO REGULAR ENTRIES TO THIS TABLE ARE MADE# 
          #THIS FIELD BEING 0 WILL INDICATE IT TO R-GENERATOR.# 
          RWSET1(BASE$SUBTOTL #CURRIRTPTR# ,NEXTSUBTOPTR);
          #IF THERE ARE NO SUBTOTALLING CANDIDATES IN THIS REPORT,# 
          #R$MASSAGER WILL 0 OUT THE TABLE ADDRESS  WHICH WILL# 
          #TELL R-GEN THAT THERE WERE NO ENTRIES.#
          RWSET1(BASE$SUMCNTR #CURRIRTPTR# ,NEXTSUMCNPTR);
          #IF ARE NO SUM COUNTERS IN THIS REPORT, AFTER-ALL-REPORT-#
          #GROUPS-RT WILL SET THIS IRT ENTRY = 0# 
  
          RWSET1(QUESTIONTERM #CURRIRTPTR# ,0); 
          #REPORTFOOTRT WILL TURN THIS BIT ON IF PAGE CLAUSE# 
          #IS SPECIFIED AND 1ST LINE NUMBER OF RF GROUP IS RELATIVE.# 
          RWSET1(SUMRY$NODETQ #CURRIRTPTR# ,0); 
          #AFTER-ALL-REPORT-GROUPS-RT WILL SET THIS ON IF SUMMARY#
          #REPORTING IS POSSIBLE AND NO DETAIL REPORT GROUP WAS#
          #DEFINED...OR AT LEAST NO VALID ONE.# 
ENDIRTRT: 
  # * * * * * * * * * * * * * * * * * * * * * * * # 
          EXTRACE("IRT$RT") 
  
          END #IRT$RT#
          TERM
