*DECK DB$JFIN 
USETEXT CDCSCTX 
USETEXT JLPCMTX 
      PROC DB$JFIN( (PFTBLKA),(NUMJLOG),(ERRBLKA) );
      BEGIN 
 #
* *   DB$JFIN - INITIALIZE JOURNAL LOG FILE      PAGE  1
* *   W P CEAGLIO                                DATE  01/21/81 
* *   BOB MCALLESTER                             DATE  01/21/85 
* 
* DC  PURPOSE 
* 
*     ATTACH PROPER JOURNAL LOG AND POSITION TO EOI.
* 
* DC  ENTRY CONDITIONS
* 
* D   PARAMETERS
# 
      ITEM PFTBLKA   I;            # ADDRESS OF ATTACH INFO IN MD      #
      ITEM NUMJLOG   I;            # NUMBER OF JOURNAL LOGS FOR SCHEMA #
      ITEM ERRBLKA   I;            # ADDRESS OF ERROR BLOCK            #
# 
* D   ASSUMPTIONS 
* 
*     THE TQT POINTER IS SET. 
*     SALX IS SET.
* 
* DC  EXIT CONDITIONS 
* 
*     NORMAL   - THE JOURNAL LOG IS ATTACHED AND POSITIONED TO EOI. 
* 
*     ABNORMAL - POINTER IN SAL REMAINS SET TO ZERO.  INFORMATION IN THE
*                ERROR BLOCK IS COMPLETED AS FOLLOWS: 
*                    1) ERROR NUMBER = DFSRENFUN IF ATTACH ERROR, 
*                       DFSRENUNA OTHERWISE.
*                    2) FUNCTION = ATTACH IF ERROR NUMBER = DFSRENFUN.
*                    3) PARAMETER = CONTENTS OF ATTACHSTATUS IF ERROR 
*                       NUMBER = DFSRENFUN. 
*                    4) FILE TYPE = JOURNAL LOG.
* 
* DC  CALLING ROUTINES
* 
*     DB$SFIN      CONTROL ROUTINE FOR SYSTEM FILE INITIALIZATION 
* 
* DC  CALLED ROUTINES 
# 
      XREF PROC DB$AREH;           # AUTO RECOVERY ERROR HANDLER       #
      XREF PROC DB$ATCH;           # ATTACH SYSTEM FILE                #
      XREF FUNC DB$CBIN I;         # CONVERT DISPLAY CODE TO BINARY    #
      XREF FUNC DB$COCT C(10);     # CONVERT BINARY TO OCTAL, W/ZEROES #
      XREF PROC DB$ERR;            # ERROR PROCESSOR                   #
      XREF PROC DB$FLOP;           # GENERATE A FLOW POINT ENTRY       #
      XREF PROC DB$IORD;           # READ HEADER RECORD IN JLF         #
      XREF PROC DB$IOWR;           # WRITE HEADER RECORD IN JLF        #
      XREF FUNC DB$LFN;            # FOR ASSIGNING SYSTEM FILE LFN     #
      XREF PROC DB$MFA;            # ALLOCATE CMM BLOCK                #
      XREF PROC DB$MFF;            # RELEASE CMM BLOCK                 #
      XREF PROC DB$MSG;            # ISSUE OPERATOR MESSAGE            #
      XREF PROC DB$POLE;           # POSITION JOURNAL LOG TO EOI       #
      XREF PROC DB$POP;            # POP VARIABLE FROM STACK           #
      XREF PROC DB$POP2;           # POP TWO VARIABLES FROM THE STACK  #
      XREF PROC DB$POP3;           # POP THREE VARIABLES FROM STACK    #
      XREF PROC DB$PSH2;           # PUSH TWO VARIABLES ONTO THE STACK #
      XREF PROC DB$PSH3;           # PUSH THREE VARIABLES ONTO STACK   #
      XREF PROC DB$PUSH;           # PUSH VARIABLE ON TO STACK         #
      XREF FUNC DB$ROLB B;         # REQUEST O.S. ROLL-OUT IF BTF JOB  #
      XREF PROC DB$RSDC;           # RESET DELAY COUNTS                #
      XREF PROC DB$RTN;            # RETURN JOURNAL LOG                #
      XREF PROC DB$SCHD;           # CDCS SCHEDULER                    #
# 
* DC  NON-LOCAL VARIABLES MODIFIED
* 
*     SAL 
*       SAJLFPTR   POINTER TO JOURNAL LOG QUEUE 
*       SASCHST    SCHEMA STATUS
# 
      XREF ITEM DB$ROAF I;         # ROLL-OUT ATTACH FLAG              #
# 
* DC  DESCRIPTION 
* 
*     -  ALLOCATE BUFFER FOR JOURNAL LOG QUEUE AND RECORD POINTER IN
*        THE SAL. 
* 
*     -  INITIALIZE THE JOURNAL LOG QUEUE TO EMPTY. 
* 
*     -  INITIALIZE THE FET FROM MODEL FET. 
* 
*     -  ASSIGN LFN USING COMBINATION OF LETTER "J" AND SCHEMA ID 
*        FROM THE SAL ENTRY.
* 
*     -  SET UP LOOP TO ATTACH PROPER JOURNAL LOG.  THE LIMIT IS THE
*        NUMBER OF JOURNAL LOGS DEFINED FOR THIS SCHEMA IN THE MD (THE
*        DEFAULT IS 2). 
* 
*     -  ATTACH THE PROPER JOURNAL LOG.  THE STRATEGY FOR ATTACH IS AS
*        FOLLOWS:  STARTING WITH THE FIRST LOG IN THE MD FOR THIS 
*        SCHEMA, LOOK FOR (A) THE LAST JOURNAL LOG WHICH WAS IN USE,
*        OR (B), THE FIRST AVAILABLE LOG.  IF (A) OCCURRED, ATTACH
*        PROCESSING IS COMPLETE.  IF (B) OCCURRED (BUT NOT A), THEN A 
*        SUBSEQUENT ATTACH OF THAT LOG IS (AGAIN) PERFORMED.
*        DURING THE SCAN FOR AN IMMEDIATELY AVAILABLE LOG FILE, IT IS 
*        NOTED IF ANY MIGHT BECOME AVAILABLE AFTER A DUMP HAS BEEN
*        COMPLETED. 
*        IF THERE IS ONE THAT MIGHT BECOME AVAILABLE, A DELAY IS
*        PERFORMED AND THEN THE SCAN IS REPEATED. 
*        IF NONE SEEM TO BE USABLE, AN ERROR IS DIAGNOSED.
* 
*     -  CHECK THE RESULT OF THE ATTACH PROCESSING SCAN.
*        THE SCAN MAY RESULT IN ANY OF THE FOLLOWING STATUS CONDITIONS. 
*        WHEN THERE ARE FILES OF DIFFERING STATUS, THE RESULTING SCAN 
*        STATUS WILL BE FROM THE FIRST STATUS VALUE IN THIS LIST. 
* 
*         DFJLSCUR - A PARTIALLY FILLED LOG FILE HAS BEEN ATTACHED. 
*                    USE IT FOR SYSTEM RECOVERY ROLL FORWARD
*                    OR CONTINUE LOGGING ON IT. 
*         DFJLSAVL - A NEW LOG FILE IS AVAILABLE. 
*                    ACCEPT IT AS A CURRENT LOG FILE TO INITIATE
*                    LOGGING. 
*         DFJLSBSY - AT LEAST ONE OF THE PERMANENT FILES IS BUSY. 
*                    WAIT FOR IT TO BE RELEASED.
*         DFJLSDMP - THE AVAILABLE LOG FILES ARE FULL.
*                    SYSTEM RECOVERY SKIPS THE ROLL FORWARD STAGE.
*                    IF NOT SYSTEM RECOVERY, WAIT FOR A FILE DUMP TO
*                    BE COMPLETED.
*         DFJLSERR - EITHER AN ATTACH ERROR OR AN I-O ERROR ON EACH 
*                    OF THE LOG FILES.
* 
 #
  
  
  
#     LOCAL VARIABLES                                                  #
  
      ITEM ATCHMSG   C(60) =
        "  ATTACH ERROR 000 ON CDCS JOURNAL LOG FILE XXXXXXX:"; 
      ITEM BUFLOC    I;            # JOURNAL LOG BUFFER LOCATION       #
      ITEM INDEX     I;            # SCRATCH - FOR LOOPS               #
      ITEM FULLMSG   C(40) = "  JOURNAL LOG FILE, XXXXXXX FULL:"; 
      ITEM JLFOK     I;            # JOURNAL LOG ATTACH STATUS         #
      ITEM P1        I;            # PARAMETER POINTER                 #
  
#     JLFOK STATUS VALUES                                              #
  
      DEF DFJLSCUR #00#;     # A CURRENT LOG FILE IS ATTACHED          #
      DEF DFJLSAVL #16#;     # AN EMPTY LOG FILE IS AVAILABLE          #
      DEF DFJLSBSY #32#;     # BUSY REPLY WAS RECEIVED ON AN ATTACH    #
      DEF DFJLSDMP #48#;     # FILES ARE FULL WAITING TO BE DUMPED     #
      DEF DFJLSERR #64#;     # ERROR IF NONE OF THE ABOVE              #
  
*CALL SRERRDCLS 
  
*CALL JFQUEDCLS 
  
      BASED ARRAY FET;             # FOR JOURNAL LOG FET               #
*CALL FETDCLS 
  
      XREF ARRAY DB$LFET;    # MODEL FET FOR JOURNAL LOG I/O           #
        BEGIN 
        ITEM JLFETWD U(00,00,60); 
        END 
  
      BASED ARRAY MDPFT;           # POINTER TO ATTACH INFO IN MD      #
        BEGIN 
        ITEM MDPFN   U(00,00,42);  # PERMANENT FILE NAME               #
        END 
  
  
  
  
# S T A R T   O F   D B $ J F I N   E X E C U T A B L E   C O D E      #
  
  
      CONTROL IFGR DFFLOP,0;
        DB$FLOP("JFIN");
      CONTROL ENDIF;
  
#     CLEAR ERROR STATUS WORD.                                         #
  
      P<SRERRBLK> = ERRBLKA;
      SREWORD[0] = 0; 
  
#     ALLOCATE SPACE FOR QUEUE, FET, HEADER RECORD, AND I/O BUFFER     #
#     (CONTIGUOUS IN THAT ORDER) AND RECORD POINTER IN SAL ENTRY.      #
  
      DB$MFA(DFJFET+DFFETLEN+DFLOGBUF+DFJLHDREC,P<JFQUEUE>);
      SAJLFPTR[SALX] = LOC(JFQUEUE);
  
#     INITIALIZE THE JOURNAL LOG QUEUE TO EMPTY.                       #
  
      FOR INDEX = DFJFET - 1
        STEP -1 UNTIL 0 
      DO
        BEGIN 
        JFQWORD[INDEX] = DFJFQEMPTY;
        END 
  
#     INITIALIZE FET FROM MODEL FET.                                   #
  
      P<FET> = LOC(JFQFET[0]);
      FOR INDEX=DFFETLEN-1 STEP-1 
        UNTIL 0 
      DO
        BEGIN 
        FETLFNWD[INDEX] = JLFETWD[INDEX]; 
        END 
  
#     ASSIGN LFN USING "J" AND SCHEMA ID FROM SAL ENTRY.               #
  
      FETLFNU[0] = DB$LFN("J",SASCHID[SALX]); 
  
#**********************************************************************#
#                                                                      #
#     ATTACH THE PROPER JOURNAL LOG.  THE STRATEGY FOR ATTACH IS AS    #
#     FOLLOWS:  STARTING WITH THE FIRST LOG IN THE MD FOR THIS SCHEMA, #
#     LOOK FOR (A) THE LAST JOURNAL LOG WHICH WAS IN USE, OR (B) THE   #
#     FIRST AVAILABLE LOG.  IF (A) OCCURRED, ATTACH PROCESSING IS NOW  #
#     COMPLETE.  IF (B) OCCURRED WITHOUT (A) OCCURRING, THE FIRST SUCH #
#     OCCURRENCE IS FLAGGED FOR SUBSEQUENT USE.  IF NEITHER SITUATION  #
#     OCCURRED, AN ERROR IS DIAGNOSED.                                 #
#                                                                      #
#     THE DETERMINATION OF WHETHER (A) OR (B) OCCURRED IS MADE BY      #
#     READING THE LOG HEADER (FIRST RECORD).  SITUATION (A) IS DEFINED #
#     AS A VALUE OF "3" IN THE STATUS FIELD (JLFRSTAT) WHEREAS A VALUE #
#     OF "0" DEFINES SITUATION (B).                                    #
#                                                                      #
#**********************************************************************#
  
      P<MDPFT> = PFTBLKA; 
TRYAGAIN: 
      JLFOK = DFJLSERR;      # DEFAULT JOURNAL LOG STATUS IS - ERROR   #
      FOR INDEX=1 STEP 1
        WHILE INDEX LQ NUMJLOG
        AND JLFOK NQ DFJLSCUR 
      DO
        BEGIN 
        B<36,6>MDPFN[0] = INDEX + O"33";
        DB$PSH3(P<SRERRBLK>,INDEX,NUMJLOG); 
        DB$PSH2(JLFOK,P<MDPFT>);
        P<SRERRBLK> = DFNPTR; 
        DB$ATCH(FETLFNU[0],MDPFT,FALSE);
        DB$POP2(P<MDPFT>,JLFOK);
        DB$POP3(NUMJLOG,INDEX,P<SRERRBLK>); 
        P<JFQUEUE> = SAJLFPTR[SALX];
        P<FET> = LOC(JFQFET[0]);
        IF ATTACHSTATUS EQ 0           # IF ATTACH OK, CHECK HEADER    #
        THEN
          BEGIN 
          P<JLREC> = LOC(JFQFET[0]) + DFFETLEN; 
          FETRR[0] = 1;                # SECTOR NUMBER                 #
          DB$IORD(P<FET>,P<JLREC>,DFJLHDREC); 
          DB$PSH3(P<SRERRBLK>,INDEX,NUMJLOG); 
          DB$PSH2(JLFOK,P<MDPFT>);
          P1 = LOC(FET);
          P<SRERRBLK> = DFNPTR; 
          P<MDPFT> = DFNPTR;
          P<FET> = DFNPTR;
          DB$SCHD(P1,DFWAITIO); 
  
          CONTROL IFGR DFFLOP,0;
            DB$FLOP("JFIN-S1"); 
          CONTROL ENDIF;
  
          DB$POP2(P<MDPFT>,JLFOK);
          DB$POP3(NUMJLOG,INDEX,P<SRERRBLK>); 
          P<JFQUEUE> = SAJLFPTR[SALX];
          P<FET> = LOC(JFQFET[0]);
          P<JLREC> = LOC(JFQFET[0]) + DFFETLEN; 
          IF FETNOSAT[0] NQ 0 
          THEN
            BEGIN 
            SRENUMB[0] = DFSRENFUN; 
            SREFUNC[0] = DFSREFNIO; 
            SREFPAR[0] = FETNOSAT[0]; 
            SREFTYP[0] = DFSREFTJL; 
            DB$AREH(P<SRERRBLK>); 
            SREWORD[0] = 0; 
            JLFRSTAT[0] = DFJLOGERR;
            END 
          ELSE
            BEGIN 
            IF FETIN[0] EQ FETOUT[0]
            THEN
              BEGIN 
              SRENUMB[0] = DFSRENALO;  # JLF EMPTY, MUST BE ALLOCATED  #
              SREFTYP[0] = DFSREFTJL; 
              DB$AREH(P<SRERRBLK>); 
              SREWORD[0] = 0; 
              JLFRSTAT[0] = DFJLOGERR;
              END 
            END 
  
          IF JLFRSTAT[0] EQ DFJLOGCUR  # IF CURRENT (LAST USED),...    #
          THEN
            BEGIN 
            JLFOK = DFJLSCUR; 
            END 
          ELSE
            BEGIN 
            IF JLFRSTAT[0] EQ DFJLOGAVL  # IF NEW LOG AND NOT FLAGGED, #
              AND JLFOK GR DFJLSAVL +9   # SAVE NUMBER OF LOG          #
            THEN
              BEGIN 
              JLFOK = DFJLSAVL + INDEX; 
              END 
            ELSE
              BEGIN 
              IF JLFRSTAT[0] EQ DFJLOGDMP 
              THEN
                BEGIN 
                C<20,7>FULLMSG = C<0,7>MDPFN[0];
                DB$MSG(FULLMSG);  # LOG FILE FULL MESSAGE              #
  
                IF JLFOK GR DFJLSDMP
                THEN
                  BEGIN 
                  JLFOK = DFJLSDMP; 
                  END 
                END 
              END 
            DB$RTN(FETLFNU[0]);        # RETURN LOG FOR NEXT ATTACH    #
            END 
          END 
        ELSE
          BEGIN                    # IF THE ATTACH DID NOT OCCUR       #
          IF ATTACHSTATUS LS 0
          THEN
            BEGIN                  # NOT ATTACHED BECAUSE OF BUSY STATE#
            IF JLFOK GR DFJLSBSY
            THEN
              BEGIN 
              JLFOK = DFJLSBSY;    # THE FILE IS ATTACHED ELSEWHERE    #
              END 
            END 
          SREFPAR[0] = ATTACHSTATUS;
          C<44,7>ATCHMSG = C<0,7>MDPFN[0];
          C<15,3>ATCHMSG = DB$COCT(ABS(ATTACHSTATUS),3);
          DB$MSG(ATCHMSG);
          END 
        END 
  
#**********************************************************************#
#                                                                      #
#     CHECK THE RESULT OF THE ATTACH PROCESSING LOOP.                  #
#     THE STATUS IS CONTAINED IN THE VARIABLE 'JLFOK'.                 #
#     THE JOURNAL LOG STATUS VALUES ARE DESCRIBED IN THE PROGRAM       #
#     DESCRIPTION.                                                     #
#     IF THE STATUS IS 'ERROR', RETURN THE BUFFER FOR THE JOURNAL LOG  #
#     QUEUE AND RESET THE POINTER IN THE SAL ENTRY.                    #
#                                                                      #
#**********************************************************************#
  
      INDEX = B<56,4>JLFOK;        # EXTRACT THE FILE NUMBER           #
      JLFOK = JLFOK - INDEX;       # REMOVE IT FROM THE STATUS         #
  
      IF JLFOK LQ DFJLSAVL         # IF FOUND A USABLE LOG, ...        #
      THEN
        BEGIN 
        SREFPAR[0] = 0;            # REINITIALIZE SO AS NOT TO CONTAIN #
                                   # A VALUE FROM A PREVIOUS ATTACH.   #
        IF JLFOK EQ DFJLSAVL       # IF NEW LOG, REATTACH.             #
        THEN
          BEGIN 
                                   # SET NUMBER OF NEW LOG TO ATTACH   #
          B<36,6>MDPFN[0] = INDEX + O"33";
          DB$PUSH(P<SRERRBLK>); 
          DB$ATCH(FETLFNU[0],MDPFT,TRUE); 
          DB$POP(P<SRERRBLK>);
          P<JFQUEUE> = SAJLFPTR[SALX];
          P<FET> = LOC(JFQFET[0]);
          IF ATTACHSTATUS NQ 0
          THEN
            BEGIN 
            SRENUMB[0] = DFSRENFUN; 
            SREFUNC[0] = DFSREFNAT; 
            SREFPAR[0] = ATTACHSTATUS;
            SREFTYP[0] = DFSREFTJL; 
            DB$MFF(P<JFQUEUE>); 
            SAJLFPTR[SALX] = 0; 
            P<SRERRBLK> = DFNPTR; 
            P<MDPFT> = DFNPTR;
            P<FET> = DFNPTR;
            RETURN; 
  
            END 
          P<JLREC> = LOC(FET) + DFFETLEN; 
          FETRR[0] = 1; 
          DB$IORD(P<FET>,P<JLREC>,DFJLHDREC);  # REREAD HEADER         #
          DB$PUSH(P<SRERRBLK>); 
          P1 = LOC(FET);
          P<SRERRBLK> = DFNPTR; 
          P<MDPFT> = DFNPTR;
          P<FET> = DFNPTR;
          DB$SCHD(P1,DFWAITIO); 
  
          CONTROL IFGR DFFLOP,0;
            DB$FLOP("JFIN-S2"); 
          CONTROL ENDIF;
  
          DB$POP(P<SRERRBLK>);
          P<JFQUEUE> = SAJLFPTR[SALX];
          P<FET> = LOC(JFQFET[0]);
          P<JLREC> = LOC(FET) + DFFETLEN; 
          FETRR[0] = 1; 
  
          IF FETNOSAT[0] EQ 0 
          THEN
            BEGIN 
            JLFRSTAT[0] = DFJLOGCUR;
            DB$IOWR(P<FET>,P<JLREC>,DFJLHDREC); 
            DB$PUSH(P<SRERRBLK>); 
            P1 = LOC(FET);
            P<SRERRBLK> = DFNPTR; 
            P<MDPFT> = DFNPTR;
            P<FET> = DFNPTR;
            DB$SCHD(P1,DFWAITIO); 
  
            CONTROL IFGR DFFLOP,0;
              DB$FLOP("JFIN-S3"); 
            CONTROL ENDIF;
  
            DB$POP(P<SRERRBLK>);
            P<JFQUEUE> = SAJLFPTR[SALX];
            P<FET> = LOC(JFQFET[0]);
            P<JLREC> = LOC(FET) + DFFETLEN; 
            END 
  
          IF FETNOSAT[0] NQ 0 
          THEN
            BEGIN 
            SRENUMB[0] = DFSRENFUN; 
            SREFUNC[0] = DFSREFNIO; 
            SREFPAR[0] = FETNOSAT[0]; 
            SREFTYP[0] = DFSREFTJL; 
            DB$RTN(FETLFNU[0]); 
            END 
          ELSE
            BEGIN                  # INITIALIZE THE FET                #
            BUFLOC = LOC(FET) + DFFETLEN + DFJLHDREC; 
            FETCODE[0] = DFFIRSTC;
            FETFIRST[0] = BUFLOC; 
            FETIN[0] = BUFLOC;
            FETOUT[0] = BUFLOC; 
            FETLIMIT[0] = BUFLOC + DFLOGBUF;
            FETRR[0] = 2; 
            FETCWA[0] = O"200"; 
            END 
          END 
  
        ELSE                       # OLD LOG - POSITION TO EOI         #
          BEGIN 
          IF NOT SYSRECOVERY
          THEN
            BEGIN 
            DB$POLE;
            END 
          P<JLREC> = LOC(FET) + DFFETLEN; 
          END 
  
        DB$ROAF = 0;               # CLEAR THE ROLL-OUT ATTACH FLAG.   #
        DB$RSDC;                   # ACCELERATE OTHER ATTACHES.        #
        JFQMAX[0] = DB$CBIN(JLFRFLIM[0],10,10); 
        END 
      ELSE                         # OTHERWISE, NO LOG AVAILABLE       #
        BEGIN 
  
        IF JLFOK EQ DFJLSDMP
          AND SYSRECOVERY 
        THEN
          BEGIN 
  
#         A JOURNAL LOG FILE DUMP SHOULD BE IN PROGRESS.               #
#         THE LOG IS AT A RECOVERY POINT, ROLL-FORWARD IS NOT REQUIRED.#
#         DO NOT DELAY THE SYSTEM RECOVERY.                            #
  
          P<SRERRBLK> = DFNPTR; 
          P<MDPFT> = DFNPTR;
          P<FET> = DFNPTR;
          RETURN; 
  
          END 
        IF SYSRECOVERY
        THEN
          BEGIN 
          JLFOK = DFJLSERR;        # IF SYSTEM RECOVERY, RETURN ERROR  #
          END 
  
#       THERE IS NO JOURNAL LOG FILE IMMEDIATELY AVAILABLE.            #
#       THERE IS ONE ATTACHED AT ANOTHER CONTROL POINT,                #
#         OR IF NOT IN SYSTEM RECOVERY MODE THERE MAY BE ONE WAITING   #
#         TO BE DUMPED.                                                #
#       IF IMMEDIATE RETURN IS NOT REQUIRED, WAIT.                     #
  
        IF NOT TQIMRTN[0]          # IF IMMEDIATE RETURN NOT SET       #
          AND NOT SYSRECOVERY      # AND NOT SYSTEM RECOVERY TIME      #
          AND JLFOK NQ DFJLSERR    # AND NOT AN ERROR STATUS           #
        THEN                       # WAIT AND REPEAT THE ATTACH SEQUENC#
          BEGIN 
          DB$PSH3(P<SRERRBLK>,NUMJLOG,P<MDPFT>);
          DB$ERR(95);              # ISSUE PF WAIT ERROR               #
  
          IF DB$ROLB               # IF BTF (ON NOS) ROLL-OUT          #
          THEN
            BEGIN 
            DB$POP3(P<MDPFT>,NUMJLOG,P<SRERRBLK>);
            GOTO TRYAGAIN;
  
            END 
          DB$ROAF = -1;            # SET ROLL-OUT ATTACH FLAG          #
                                   # TO PREVENT ROLL-OUT OF CDCS.      #
  
          DB$PUSH(DFATCHDELAY);    # DELAY COUNT IS PUT IN THE STACK   #
                                   # DB$SCHD WILL POP IT AND USE IT    #
          P<SRERRBLK> = DFNPTR; 
          P<MDPFT> = DFNPTR;
          P<FET> = DFNPTR;
          DB$SCHD(LOC(STATCOMP),DFWAITCOUNT); 
  
          CONTROL IFGR DFFLOP,0;
            DB$FLOP("JFIN-S4"); 
          CONTROL ENDIF;
  
          DB$POP3(P<MDPFT>,NUMJLOG,P<SRERRBLK>);
          P<JFQUEUE> = SAJLFPTR[SALX];
          P<FET> = LOC(JFQFET[0]);
  
          GOTO TRYAGAIN;
  
          END 
        SRENUMB[0] = DFSRENUNA; 
        SREFTYP[0] = DFSREFTJL; 
        END 
  
      IF SRENUMB[0] NQ 0
      THEN
        BEGIN 
        DB$MFF(P<JFQUEUE>); 
        SAJLFPTR[SALX] = 0; 
        END 
  
      P<SRERRBLK> = DFNPTR; 
      P<MDPFT> = DFNPTR;
      P<FET> = DFNPTR;
      END 
      TERM; 
