*DECK DB$RDLG 
USETEXT CDGDFTX 
USETEXT CUGDFTX 
USETEXT JLPCMTX 
      FUNC DB$RDLG ((FETLOC),(WBA)) I;
      BEGIN 
 #
* *   DB$RDLG - READ A LOG RECORD                PAGE  1
* *   BOB MCALLESTER                             DATE  02/09/81 
* 
* DC  PURPOSE 
* 
*     GET A LOG RECORD FROM THE TRANSACTION FILE (TRF) OR FROM THE
*     JOURNAL LOG FILE (JLF). 
* 
* DC  ENTRY CONDITIONS
* 
* D   PARAMETERS
# 
      ITEM FETLOC I;         # LOCATION OF THE FET                     #
      ITEM WBA    I;         # WORKING BUFFER ADDRESS                  #
# 
* D   ASSUMPTIONS 
* 
*     THE FET POINTERS ARE INITIALIZED FOR THE INITIAL CALL.
*     FIRST, IN, OUT AND LIMIT ARE INITIALIZED FOR AN EMPTY BUFFER. 
*     FETRR IS SET BY THE BSAFORMULA (SEE ARTDCLS) FOR THE TRF
*     OR FOR THE FIRST LOG RECORD (2) FOR THE JLF.
* 
*     THE INITIAL CALL IS IDENTIFIED BY FETCODE EQ DFFIRSTC.
*     THIS IS NOT A VALID CODE UNDER OTHER CIRCUMSTANCES. 
* 
*     SUCCESSIVE CALLS TO DB$RDLG ARE MADE WITHOUT ANY INTERVENING
*     INTERRUPTIONS.
* 
* DC  EXIT CONDITIONS 
* 
*     THE NEXT LOG RECORD IS IN THE WORKING STORAGE AREA AT WBA.
*     THE LENGTH OF THE RECORD IS RETURNED AS A FUNCTION VALUE. 
*     IF THE NEXT CALL WOULD REQUIRE CROSSING AN END-OF-RECORD BOUNDARY 
*     BEFORE RETRIEVING THE NEXT LOG RECORD, A MINUS ONE IS RETURNED. 
* 
*     ON THE NEXT CALL AFTER THE LAST RECORD ON THE LOG FILE, A MINUS 
*     TWO IS RETURNED.
*     AS THE FUNCTION VALUE TO FLAG AN END-OF-DATA STATUS.
* 
* DC  CALLING ROUTINES
* 
*     CDCS2 
*       DB$POLE              POSITION JOURNAL LOG FILE TO END-OF-DATA 
*       DB$RFOR              ROLL FORWARD FOR SYSTEM RECOVERY 
*       DB$UNDO              BACK OUT THE TRANSACTION 
* 
*     DBREC 
*       DB$BDLG              DUMP LOG FILE TO TAPE
* 
* DC  CALLED ROUTINES 
# 
      XREF FUNC DB$CBIN I;   # CONVERT DISPLAY TO BINARY               #
      XREF FUNC DB$COCT C(10);  # CONVERT BINARY TO OCTAL DISPLAY      #
      XREF PROC DB$DUMP;     # INITIATE A MEMORY DUMP                  #
      XREF PROC DB$FLOP;     # RECORD A FLOW POINT EXECUTION           #
      XREF PROC DB$MSG;      # SEND A DAYFILE MESSAGE                  #
      XREF PROC DB$PUNT;     # PROCESS AN INTERNAL ERROR               #
      XREF PROC DB$RCLL;     # CPU RECALL INTERFACE                    #
      XREF PROC DB$RDM;      # READ MACRO                              #
      XREF FUNC DB$RDWW;     # READ WORDS TO THE WORKING BUFFER        #
      XREF PROC DB$RWTM;     # REWRITER MACRO                          #
# 
* DC  NON-LOCAL VARIABLES MODIFIED
* 
*     NONE
* 
* DC  DESCRIPTION 
* 
*     IF IT IS AN INITIAL CALL FOR THE JLF OR THE SEGMENT OF THE TRF, 
*     AN INITIAL READ MACRO IS ISSUED, FOLLOWED BY A DB$RDWW CALL TO
*     GET ONE WORD.  THIS IS THE FIRST WORD OF THE FIRST RECORD.
* 
*     AS EACH LOG RECORD IS READ, THE FIRST WORD OF THE NEXT RECORD 
*     IS ALSO READ AND SAVED IN THE LOCAL ITEM HDWDA.  IT IS AVAILABLE
*     FOR INSPECTION BEFORE READING THE REST OF THE RECORD. 
*     IF IT IS EQUAL TO THE PRESET VALUE OF THE FILE, IT INDICATES THAT 
*     THERE IS NO NEXT RECORD, END-OF-DATA HAS BEEN REACHED.
* 
*     WHEN IT IS NOT END-OF-DATA, THE FIRST WORD CONTAINS A DISPLAY 
*     CODED DECIMAL NUMBER WHICH IS THE NUMBER OF CHARACTERS IN THE 
*     TRAILER.  THIS NUMBER IS USED TO DETERMINE THE LENGTH OF THE
*     REMAINING PORTION OF THE LOG RECORD.
* 
*     AFTER READING THE LOG RECORD AND THE FIRST WORD OF THE NEXT 
*     RECORD, A TEST IS MADE IF THE LOG RECORD IS COMPLETE. 
*     IF THE LAST WORD OF THE RECORD AND THE FIRST WORD OF THE NEXT 
*     RECORD ARE BOTH EQUAL TO THE FILE PRESET VALUE, THE RECORD IS 
*     INCOMPLETE. 
*     THIS RECORD FRAGMENT IS REMOVED FROM THE LOG FILE SO THAT IT
*     WILL NOT INTERFERE WITH FUTURE USE OF THE FILE. 
*     AN END-OF-RECORD STATUS IS THEN RETURNED. 
* 
*     THE ATTEMPT TO READ THE FIRST WORD OF THE NEXT LOG RECORD MAY 
*     RESULT IN AN END-OF-RECORD STATUS BEING RETURNED BY DB$RDWW.
*     THE END-OF-RECORD STATUS IS A NON-ZERO POSITIVE NUMBER. 
*     IT IS SAVED IN EODF AND CAUSES A MINUS ONE TO BE RETURNED ON THE
*     NEXT DB$RDLG CALL.
*     IF THE CALLING ROUTINE REQUIRES TO READ BEYOND AN END-OF-RECORD 
*     BOUNDARY, FETCODE MUST BE SET TO DFFIRSTC BEFORE RESUMING THE 
*     DB$RDLG CALLS.
 #
# 
*     LOCAL DATA ITEMS
# 
      BASED ARRAY FET;
*CALL FETDCLS 
  
      BASED ARRAY BUF S(1); 
        BEGIN 
        ITEM BUFWORD (00,00,60);   # BUFFER WORD DEFINITION            #
        END 
  
      ITEM EODF I;           # END-OF-DATA FLAG                        #
      ITEM DCOUNT I = 0;     # COUNT OF BAD RECORDS DUMPED             #
      ITEM FOUND B;          # FOUND THE OBJECT OF THE SEARCH          #
      ITEM HDWDA C(10);      # FIRST WORD OF THE NEXT RECORD           #
      ITEM LENGTH I;         # LENGTH (WORDS) OF THE RECORD LESS 1ST WD#
      ITEM NEWLENGTH I;      # LENGTH OF A NEW RECORD                  #
      ITEM READLOC I;        # LOCATION FOR READING RECORD             #
      ITEM SAVHDWDA C(10);   # SAVE HEAD WORD                          #
      ITEM SCRATCH I;        # SCRATCH WORD                            #
      ITEM STUBL    I;       # RECORD STUB LENGTH                      #
      ITEM TRLS I;           # TRAILER SIZE (CHARACTERS)               #
      ITEM XX I;             # INDUCTION VARIABLE                      #
      ITEM XY I;             # INDUCTION VARIABLE                      #
      ITEM XZ I;             # INDUCTION VARIABLE                      #
  
  
  
  
#     B E G I N   D B $ R D L G   E X E C U T A B L E   C O D E        #
  
      P<JLREC> = WBA; 
      P<FET> = FETLOC;
# 
*     IF THIS IS AN INITIAL READ FOR THE FILE OR TRF SEGMENT, 
*     GET THE FIRST WORD OF THE LOG RECORD. 
*     THE FIRST WORD IS PLACED IN THE LOCAL ITEM -HDWDA- WHERE IT 
*     WOULD BE IF THERE HAD BEEN A PRIOR LOG RECORD.
# 
      IF FETCODE[0] EQ DFFIRSTC 
      THEN                   # THIS IS THE FIRST READ                  #
        BEGIN 
  
        CONTROL IFGR DFFLOP,0;
          DB$FLOP("RDLG-B");
        CONTROL ENDIF;
  
        DB$RDM(P<FET>);      # AN INITIAL READ MACRO                   #
        EODF = DB$RDWW(P<FET>,LOC(HDWDA),1);  # 1ST WORD TO HDWDA      #
        END 
# 
*     IDENTIFY AN END-OF-DATA STATUS LEFT AFTER READING THE LAST RECORD.
# 
      IF EODF LS 0
        OR HDWDA EQ DFPRESET
      THEN                   # END-OF-DATA                             #
        BEGIN 
        IF NOT FETCOMP[0] 
        THEN                 # CIO STILL READING THE PRESET PRU"S      #
          BEGIN 
          DB$RCLL(P<FET>);   # WAIT FOR COMPLETION                     #
          END 
  
        CONTROL IFGR DFFLOP,0;
          DB$FLOP("RDLG-ED"); 
        CONTROL ENDIF;
  
        FETIN[0] = FETFIRST[0];  # EMPTY THE BUFFER                    #
        FETOUT[0] = FETFIRST[0];
        FETRR[0] = FETSA[0];  # SET FILE POSITION                      #
        DB$RDLG = DFRDLGEOD; # RETURN AN END-OF-DATA STATUS            #
        RETURN; 
  
        END 
# 
*     IDENTIFY AN END-OF-RECORD STATUS. 
# 
      IF EODF GR 0
      THEN
        BEGIN 
        FETSA[0] = FETSA[0] +1;  # ADJUST CURRENT WORD ADDRESS         #
        FETSR[0] = 0; 
  
        CONTROL IFGR DFFLOP,0;
          DB$FLOP("RDLG-ER"); 
        CONTROL ENDIF;
  
        DB$RDLG = DFRDLGEOR; # RETURN AN END-OF-RECORD STATUS          #
        RETURN; 
  
        END 
# 
*     TRANSFER THE FIRST WORD FROM -HDWDA- TO THE FIRST WORD OF THE 
*     WORKING STORAGE AREA. 
*     COMPUTE THE LENGTH OF THE REST OF THE LOG RECORD. 
*     READ THE REMAINING PORTION OF THE LOG RECORD. 
# 
      JLHDWDA[0] = HDWDA; 
      TRLS = DB$CBIN(JLHDTRLS[0],6,10);  # TRAILER SIZE (CHARACTERS)   #
      LENGTH = (TRLS + DFHDRSZ -1) /10;  # RECORD LENGTH -1 (WORDS)    #
      READLOC = LOC(JLHDWDB[0]);         # WHERE TO READ IT TO         #
      EODF = DB$RDWW(P<FET>,READLOC,LENGTH);
# 
*     IT IS POSSIBLE FOR A PARTIAL RECORD TO BE FOLLOWED BY THE PRESET
*     VALUES. 
*     TO IDENTIFY THIS SITUATION, THE FIRST WORD OF THE NEXT RECORD IS
*     READ. 
*     THE FIRST WORD OF A RECORD CAN NOT BE A PRESET VALUE. 
*     IF IT IS, THE NEXT RECORD IS NOT PRESENT. 
*     IF THE LAST WORD OF THE PRESENT RECORD IS ALSO A PRESET VALUE,
*     IT IS ASSUMED THAT THE WHOLE RECORD WAS NOT RECORDED ON DISK. 
*     THE RECORD FRAGMENT IS REMOVED FROM THE FILE. 
*     AN END-OF-RECORD STATUS IS RETURNED.
# 
      EODF = DB$RDWW(P<FET>,LOC(HDWDA),1);  # READ FIRST WORD OF NEXT  #
      IF EODF EQ 0
        AND HDWDA EQ DFPRESET 
        AND JLHDWDA[LENGTH] EQ DFPRESET 
      THEN
        BEGIN 
  
        CONTROL IFGR DFFLOP,0;
          DB$FLOP("RDLG-FR"); 
        CONTROL ENDIF;
  
        DB$RCLL(P<FET>);
        FETIN[0] = FETFIRST[0]; 
        FETOUT[0] = FETFIRST[0];
        FETRR[0]  = FETSA[0]; 
        DB$RDM(P<FET>);      # REREAD THE LAST PARTIALLY GOOD PRU      #
        DB$RCLL(P<FET>);
  
        FETIN[0] = FETFIRST[0] + FETSR[0];  # RETAIN ONLY THE GOOD PART#
        FETRR[0] = FETSA[0];
        DB$RWTM(P<FET>);     # REWRITE THE SHORT PRU WITH GOOD DATA    #
        DB$RCLL(P<FET>);
  
        FETSA[0] = FETSA[0] +1;  # SET ADDRESS TO NEXT PRU             #
        FETRR[0]  = FETSA[0]; 
        FETSR[0] = 0; 
  
#       FILL THE BUFFER WITH PRESET VALUES AND REWRITE THE PRUS JUST   #
#       BEYOND THE GOOD DATA.                                          #
#       THIS WILL ERASE ANY REMAINING PORTION OF THE FRAGMENT.         #
  
        P<BUF> = FETFIRST[0]; 
        FOR XX = LENGTH STEP -1 UNTIL 0 
        DO
          BEGIN 
          BUFWORD[XX] = DFPRESET; 
          END 
  
        FETOUT[0] = FETFIRST[0];
        FETIN[0] = FETFIRST[0] + LENGTH;
        DB$RWTM(P<FET>);
        DB$RCLL(P<FET>);
  
        FETIN[0] = FETFIRST[0];  # EMPTY THE BUFFER                    #
        FETOUT[0] = FETFIRST[0];
        FETRR[0] = FETSA[0];  # SET FILE POSITION                      #
        DB$RDLG = DFRDLGEOD;  # RETURN AN END-OF-DATA STATUS           #
        RETURN; 
  
        END 
# 
*     IF THE WORD FOLLOWING THE LOG RECORD IS NOT A VALID HEADER WORD 
*     FOR THE NEXT LOG RECORD, IT IS ASSUMED THAT THIS LOG RECORD IS
*     NOT A VALID RECORD. 
*     SKIP THIS RECORD. 
# 
      TRLS = DB$CBIN(C<4,6>HDWDA,6,10); 
      FOR XZ=XZ WHILE ( C<0,1>HDWDA NQ "*"
                     OR C<2,1>HDWDA NQ "*"
                     OR TRLS LS 0 ) 
                 AND ( EODF EQ 0
                     AND HDWDA NQ DFPRESET) 
      DO                     # THE LOG RECORD HEADER IS BAD.           #
        BEGIN 
        SEARCH;              # SEARCH FOR A GOOD RECORD HEADER         #
        IF LENGTH EQ 2
        THEN
          BEGIN 
          IF EODF LS 0
            OR HDWDA EQ DFPRESET
          THEN                   # END-OF-DATA                         #
            BEGIN 
            IF NOT FETCOMP[0] 
            THEN                 # CIO STILL READING THE PRESET PRU"S  #
              BEGIN 
              DB$RCLL(P<FET>);   # WAIT FOR COMPLETION                 #
              END 
  
            CONTROL IFGR DFFLOP,0;
              DB$FLOP("RDLG-GD"); 
            CONTROL ENDIF;
  
            FETIN[0] = FETFIRST[0];  # EMPTY THE BUFFER                #
            FETOUT[0] = FETFIRST[0];
            FETRR[0] = FETSA[0];  # SET FILE POSITION                  #
            DB$RDLG = DFRDLGEOD; # RETURN AN END-OF-DATA STATUS        #
            RETURN; 
  
            END 
# 
*         IDENTIFY AN END-OF-RECORD STATUS. 
# 
          IF EODF GR 0
          THEN
            BEGIN 
            FETSA[0] = FETSA[0] +1;  # ADJUST CURRENT WORD ADDRESS     #
            FETSR[0] = 0; 
  
            CONTROL IFGR DFFLOP,0;
              DB$FLOP("RDLG-GR"); 
            CONTROL ENDIF;
  
            DB$RDLG = DFRDLGEOR; # RETURN AN END-OF-RECORD STATUS      #
            RETURN; 
  
            END 
          END 
        END 
# 
*     MAINTAIN THE CURRENT WORD ADDRESS FOR THOSE WHO DEPEND ON IT. 
# 
      FETCWA[0] = FETCWA[0] + LENGTH +1;
# 
*     THE READ OF THE LOG RECORD IS COMPLETE. 
*     THE FIRST WORD OF THE NEXT RECORD AND END-OF-DATA STATUS ARE
*     LEFT IN LOCAL VARIABLES WHERE THEY CAN BE ACCESSED ON THE NEXT
*     DB$RDLG CALL. 
*     THEY CAN BE LEFT THERE BECAUSE NONE OF THE PROCEDURES THAT CALL 
*     DB$RDLG ARE INTERRUPTIBLE.
# 
      DB$RDLG = LENGTH + 1;  # RETURN THE RECORD LENGTH                #
  
      RETURN; 
  
  
#**********************************************************************#
#                                                                      #
#     I N T E R N A L   P R O C E D U R E   -   S E A R C H .          #
#                                                                      #
#**********************************************************************#
  
      PROC SEARCH;
        BEGIN 
# 
*       MAKE SURE WE ARE NOT IN A LOOP TAKING DUMPS.
# 
        DCOUNT = DCOUNT +1; 
        IF DCOUNT GR 10 
        THEN
          BEGIN 
          DB$PUNT("DB$RDLG 3"); 
          END 
# 
*       SEARCH FOR A GOOD LOG RECORD FOLLOWING THE ONE THAT HAS BEEN
*       IDENTIFIED AS BEING BAD.
* 
*       FIRST ISSUE DIAGNOSTIC MESSAGES AND DUMPS TO TRY TO IDENTIFY
*       THE BAD RECORD. 
# 
        DB$MSG("  THERE ARE FOUR DUMPS ON THE OUTPUT FILE:"); 
        DB$MSG("      1. A BAD LOG RECORD, BEING SKIPPED.:"); 
        DB$MSG("      2. THE LOG FILE FET.:");
        DB$MSG("      3. THE INPUT BUFFER.:");
        DB$MSG("      4. THE NEXT LOG RECORD FOUND.:"); 
        DB$DUMP(WBA, WBA+LENGTH); 
        DB$DUMP(P<FET>, LOC(FET)+DFFETLEN); 
        DB$DUMP(FETFIRST[0], FETLIMIT[0]);
  
        SAVHDWDA = HDWDA; 
        FOUND = FALSE;
# 
*       SCAN INSIDE THE BAD RECORD TO SEE IF IT HAS BEEN OVERLAPPED 
*       BY ANOTHER LOG RECORD.
# 
        FOR XX = LENGTH STEP -1 UNTIL 1 
        DO
          BEGIN 
          HDWDA = JLHDWDA[XX];
          TESTHDR;
          IF NOT FOUND
          THEN
            BEGIN 
            TEST XX;               # CONTINUE THE SEARCH               #
  
            END 
          STUBL = LENGTH - XX +1;  # COMPUTE THE LENGTH OF THE STUB.   #
                             # THE STUB IS A PIECE OF A RECORD THAT    #
                             # HAS BEEN FOUND EMBEDDED IN THE BAD      #
                             # RECORD THAT HAS BEEN REJECTED.          #
          FOR XY = 0 STEP 1 UNTIL STUBL -1
          DO
            BEGIN 
            JLHDWDA[XY] = JLHDWDA[XX + XY]; 
            END 
                                   # THIS WORD IS APPENDED TO THE STUB.#
          JLHDWDA[STUBL] = SAVHDWDA;
                                   # COMPUTE (LENGTH -1) OF THE NEW REC#
          NEWLENGTH = (TRLS + DFHDRSZ -1) /10;
                                   # COMPUTE THE LENGTH OF THE         #
                                   # REMAINDER OF THE NEW RECORD THAT  #
                                   # IS STILL TO BE READ IN.           #
          SCRATCH = NEWLENGTH - STUBL;
          IF SCRATCH LS 0 
          THEN
            BEGIN 
            FOUND = FALSE;
            TEST XX;
  
            END 
          IF SCRATCH NQ 0 
          THEN
            BEGIN 
            LENGTH = SCRATCH; 
            READLOC = LOC(JLHDWDB[0]) + STUBL;
            EODF = DB$RDWW(P<FET>,READLOC,LENGTH);
            END 
          LENGTH = NEWLENGTH;      # LENGTH OF THE NEW RECORD (-1)     #
  
                                   # UPDATE CURRENT WORD ADDRESS       #
                                   # BY THE NUMBER OF WORDS SKIPPED.   #
          FETCWA[0] = FETCWA[0] + XX; 
          XX = 1; 
          END 
  
                             # IF NO STUB WAS FOUND IN THE BAD RECORD  #
                             # THEN SEARCH ONCE AROUND THE BUFFER FOR  #
                             # A GOOD RECORD HEADER.                   #
        IF NOT FOUND
        THEN
          BEGIN 
          FETCWA[0] = FETCWA[0] + LENGTH +1;
          XX = FETOUT[0] -1;
          IF FETOUT[0] EQ FETFIRST[0] 
          THEN
            BEGIN 
            XX = FETLIMIT[0] -1;
            END 
          FOR XX = XX WHILE FETOUT[0] NQ XX 
          DO
            BEGIN 
            FETCWA[0] = FETCWA[0] +1; 
            EODF = DB$RDWW(P<FET>,LOC(HDWDA),1);  # READ NEXT WORD     #
            IF EODF NQ 0
            THEN
              BEGIN 
              FOUND = TRUE; 
              JLHDWDA[0] = "       END";
              JLHDWDA[1] = "-OF-DATA  ";
              JLHDWDA[2] = "          ";
              LENGTH = 2; 
              XX = FETOUT[0];          # EXIT FROM THE LOOP            #
              TEST XX;
  
              END 
            TESTHDR;
            IF FOUND
            THEN                       # READ IN THE RECORD            #
              BEGIN 
              JLHDWDA[0] = HDWDA; 
              LENGTH = (TRLS + DFHDRSZ -1) /10; 
              READLOC = LOC(JLHDWDB[0]);
              EODF = DB$RDWW(P<FET>,READLOC,LENGTH);
              XX = FETOUT[0];          # TERMINATE THE LOOP            #
              END 
            END 
          IF NOT FOUND
          THEN
            BEGIN 
            DB$PUNT("DB$RDLG 4"); 
            END 
          END 
        DB$DUMP(WBA, WBA+LENGTH); 
        IF EODF EQ 0
        THEN                 # GET THE 1ST WORD OF THE NEXT RECORD     #
          BEGIN 
          EODF = DB$RDWW(P<FET>,LOC(HDWDA),1);
          END 
        END 
  
  
#**********************************************************************#
#                                                                      #
#     I N T E R N A L   P R O C E D U R E   -   T E S T H D R .        #
#                                                                      #
#**********************************************************************#
  
      PROC TESTHDR; 
        BEGIN 
# 
*       IF THE WORD AT HDWDA CONFORMS TO THE RULES OF A LOG RECORD
*       HEADER FIRST WORD, SET "FOUND" EQUAL TO TRUE. 
# 
        IF C<0,1>HDWDA NQ "*" 
          OR C<2,1>HDWDA NQ "*" 
        THEN
          BEGIN 
          RETURN;                  # IS NOT A LOG RECORD HEADER        #
  
          END 
        IF   C<1,1>HDWDA EQ DFJLRQPV
          OR C<1,1>HDWDA EQ DFJLRQCL
          OR C<1,1>HDWDA EQ DFJLRQIN
          OR C<1,1>HDWDA EQ DFJLRQTM
          OR C<1,1>HDWDA EQ DFJLRQRP
          OR C<1,1>HDWDA EQ DFJLRQCP
          OR C<1,1>HDWDA EQ DFJLRQBG
          OR C<1,1>HDWDA EQ DFJLRQCM
          OR C<1,1>HDWDA EQ DFJLRQDR
          OR C<1,1>HDWDA EQ DFJLRQVR
        THEN
          BEGIN 
          IF C<3,1>HDWDA NQ DFJLDCZ 
          THEN
            BEGIN 
            RETURN;                # IS NOT A LOG RECORD HEADER        #
  
            END 
          END 
        ELSE
          BEGIN 
          IF   C<1,1>HDWDA EQ DFJLRQTR
            OR C<1,1>HDWDA EQ DFJLRQOP
            OR C<1,1>HDWDA EQ DFJLRQBI
            OR C<1,1>HDWDA EQ DFJLRQAI
          THEN
            BEGIN 
            IF C<3,1>HDWDA GR DFJLDCF 
            THEN
              BEGIN 
              RETURN;              # IS NOT A LOG RECORD HEADER        #
  
              END 
            END 
          ELSE
            BEGIN 
            RETURN;                # IS NOT A LOG RECORD HEADER        #
  
            END 
          END 
        TRLS = DB$CBIN(C<4,6>HDWDA,6,10); 
        IF TRLS LS 0
        THEN
          BEGIN 
          RETURN; 
  
          END 
        FOUND = TRUE; 
        END 
      END 
      TERM
