*DECK HALFSYN 
USETEXT TCLFN 
USETEXT TENVIRN 
USETEXT TLFNINF 
USETEXT TREPORT 
USETEXT TOPTION 
USETEXT TXSTD 
      PROC HALFSYN; 
  
#----------------------------------------------------------------------#
#                                                                      #
#  THE FOLLOWING PROCS ARE XDEF"D WITHIN THIS DECK:                    #
#                                                                      #
#     GETREADY                                                         #
#     MOREHAF                                                          #
#                                                                      #
#----------------------------------------------------------------------#
  
      BEGIN 
  
      XDEF ITEM A            C(10);  # TEMP ILFN HOLDER                #
      XDEF ITEM B            C(10);  # TEMP ILFNLG HOLDER              #
      XREF ITEM CURRENTLFPTR I;    # LOCATION OF CURRENT LFNINFO ENTRY #
      XREF BASED ARRAY DESPTR;
        BEGIN 
        ITEM DESCOUNT I(00,00,12); # NUMBER OF LOCAL FILES REFERENCING #
                                   # THIS LIST OF DESCRIBE ITEMS.      #
        ITEM DESSIZE U(0,24,18);   # SIZE OF DESCRIBED LIST IN CHAR    #
        ITEM DESADDR U(0,42,18);   # DESLIST FOR THIS FILE             #
        END 
      ITEM COMPFG    B;            # TRUE MEANS GOOD READ              #
      ITEM I            I;         # SCRATCH TEMPORARY                 #
      XDEF ITEM ROOT         I; 
       DEF DFTRPWD #O"40000000000001000000"#;  #DEFAULT VALUE FOR 
                                                REPORTLIST WORD 1,
                                                BEYOND IS ON, 
                                                LINE NB IS 1# 
         DEF DFTRPWD2 #O"04010000000000000000"#;
  
  
      XREF PROC DIAG;              # WRITE ERROR MESSAGE               #
      XREF PROC SETBIT; 
      XREF PROC SYNIO;
      XREF PROC WRDIRT;            # CLEAN UP AND LEAVE PROC           #
  
  
  
  
#----------------------------------------------------------------------#
#             P R O C   C H K C O M P                                  #
#                                                                      #
#     PROCEDURE TO TEST WHETHER THERE WAS A SUCCEFUL READ              #
#     FROM THE CATALOG AND FROM THIS DETERMINE THE TYPE                #
#     OF RETURN.   COMPFG IS SET IN PROC MOREHAF TO TRUE               #
#     IF CATFITES = 0 OTHERWISE IT IS SET TO FALSE.                    #
#----------------------------------------------------------------------#
  
      XDEF PROC CHKCOMP;
      PROC CHKCOMP; 
      BEGIN 
        IF COMPFG                  # IF CATFITES = 0 (GOOD READ)       #
        THEN
          BEGIN 
          STDYES;                  # RETURN VIA YES                    #
          END 
        ELSE
          BEGIN                    # CATFITES NQ 0 (ERROR OR EOF)      #
          STDNO;
          END 
  
      END                          # END PROC CHKCOMP                  #
#----------------------------------------------------------------------#
  
  
  
  
           XDEF PROC GETREADY;
          PROC GETREADY;
          BEGIN 
              PRESUMFG = FALSE;                                         000130
                 READFROM = S"GET1ST";
                 CURREPT = RPTNAME[RPTCTR]; 
                 ILFN[IFRO] = FROMLFN[RPTCTR];
                 ILFNLG[IFRO] = FROMLEN[RPTCTR];
                 IF TEXTFG[RPTCTR] THEN BEGIN PSFLG=1; SETBIT; RETURN;
                                   END
                 PSFLG = 0; 
                 MAJORKEYLEN = 7; 
                 KEYAREA[0] = RPTNAME[RPTCTR];                           FEAT157
                 HIGHKEY = KEYAREA[0];                                   FEAT157
                 B<42,18>HIGHKEY = O"777777"; 
         IF NOT FLAGA THEN
                 SYNIO; 
                 SETBIT;
                 CURRENTLFPTR = FLFNINFO[RPTCTR]; 
                 P<LFNINFO> = CURRENTLFPTR; 
                 P<DESPTR> = L$DESPTR;                                   FORMALT
                 DESLIST = DESADDR;  # DESCRIBE LIST FOR THIS FILE     #
                 FSIZE = DESSIZE;    # SIZE OF DESCRIBED LIST IN CHAR  #
                 RETURN;
          END 
  
  
  
  
#----------------------------------------------------------------------#
  
  
  
  
          XDEF PROC MOREHAF;
          PROC MOREHAF; 
          BEGIN 
          IF RPTCTR GR RPTMAX      # IS RPTLFNS FULL                   #
          THEN
            BEGIN 
            DIAG(620);             # TABLE OVERFLOW MESSAGE            #
            WRDIRT;                # STOP PROCESSING RETURN STDNO      #
            END 
  
          IF TEXTFG[RPTCTR] THEN BEGIN I = RPTCTR;
               SUMMARYED[I] = TRUE; 
               GOTO REPEAT; END 
                 KEYAREA[0] = RPTNAME[RPTCTR];                           FEAT157
                 B<42,18>KEYAREA[0] = O"27777";                          FEAT157
          MAJORKEYLEN = 8;
          READFROM = S"GET1ST"; 
          SYNIO;
          IF CATAFITES EQ 0                                              FORMALT
          THEN                                                           FORMALT
                 BEGIN PSFLG = 4; LVL = LVL + 1;
                       ROOT = RPTCTR; GOTO SETNEXT; 
                 END
                 I = RPTCTR;
                 SUMMARYED[I] = TRUE; 
            NEXTSUM:  
                 B<42,6>KEYAREA[0] = "1";                                FEAT157
          READFROM = S"GET1ST"; 
          SYNIO;
          IF CATAFITES NQ 0                                              FORMALT
          THEN                                                           FORMALT
                 BEGIN
                   REPEAT:  
                       I = ROOTPTR[I];
                       IF I LS 0 THEN GOTO PREPARE; 
                       IF NOT SUMMARYED[I] THEN 
                       BEGIN                                             FEAT157
                       KEYAREA[0] = RPTNAME[I];                          FEAT157
                             LVL = LEVELPTR[I]; 
                             SUMMARYED[I] = TRUE; 
                             GOTO NEXTSUM;
                       END
                       GOTO REPEAT; 
                 END
                 ELSE 
                 BEGIN LVL = LVL + 1; ROOT = I; PSFLG = 1;
                 END
            SETNEXT:  
                 RPTCTR = RPTCTR + 1; 
                 PRESUM[RPTCTR] = PSFLG;
                 ROOTPTR[RPTCTR] = ROOT;
                 LEVELPTR[RPTCTR] = LVL;
                 TEXTFG[RPTCTR] = FALSE;
                 SUMMARYED[RPTCTR] = FALSE; 
                 COMPFG = FALSE;
                 STDYES;
            PREPARE:  
                 PREP;
                 LVL = RPTCTR;
                 RPTCTR =0; 
           IF DIRLEXID EQ O"142" THEN  # IF COMPILE                    #
               BEGIN                                                     XXXX 
               FOR RPTCTR=0 STEP 1 UNTIL LVL DO                          XXXX 
                   BEGIN                                                 XXXX 
                   IF RPTNAME[RPTCTR] EQ A THEN GOTO COMPOUT;            XXXX 
                   END                                                   XXXX 
               END                                                       XXXX 
       COMPOUT:   #  #                                                   XXXX 
                 GETREADY;
            IF DIRLEXID EQ O"142" THEN  # IF COMPILE                   #
              BEGIN 
              RPTCTR = LVL; 
              FLAGA = TRUE; 
              END 
                 ILFN[IPRE] = A;
                 ILFNLG[IPRE] = B;
                 COMPFG = TRUE; 
                 STDYES;
          END 
  
  
  
  
#----------------------------------------------------------------------#
  
  
  
  
  PROC PREP;
  BEGIN 
          ITEM I,J,K,L,M; 
          FOR I = 0 STEP 1 UNTIL 9 DO 
              PRIORITY[I] = O"2222222222";
          FOR I = 1 STEP 1 UNTIL RPTCTR DO
          BEGIN K = I;
            CHKLFN: 
                 J = ROOTPTR[K];
                 IF J LS 0 THEN GOTO OK;
                 IF RPTNAME[I] EQ RPTNAME[J] THEN GOTO ERR; 
                 K = ROOTPTR[J];
          IF K LS 0 THEN GOTO OK; 
                 GOTO CHKLFN; 
            OK: 
                 J = LEVELPTR[I]; 
                 L = (J - 1) * 3; 
                 K = WORD2[ROOTPTR[I]]; 
                 IF L NQ 0 THEN B<30,L>WORD2[I] = B<30,L>K; 
                 B<30+L,3>WORD2[I] = PRESUM[I]; 
          END 
          I = 0;
          J = 1;
          K = I;
       SORT:  
          IF PRIORITY[I] LS PRIORITY[I+J] THEN
          BEGIN 
          WORD1A[I] ==WORD1A[I+J];
          WORD3A[I] ==WORD3A[I+J];
                 WORD2[I] == WORD2[I+J];
                 IF I EQ 0 THEN GOTO GOON;
                 I = I - 1; 
                 GOTO SORT; 
          END 
       GOON:  
          I = K + 1;
          K = I;
          IF K EQ RPTCTR THEN RETURN; 
          GOTO SORT;
       ERR: 
          RETURN; 
          END 
  
  
  
  
#----------------------------------------------------------------------#
  
  
      END 
      TERM
