*DECK DB$TFIN 
USETEXT CDCSCTX 
      PROC DB$TFIN( (PFTBLKA),(NUMTUN),(ERRBLKA) ); 
      BEGIN 
 #
* *   DB$TFIN - INTIALIZE TRANSACTION RECOV FILE PAGE  1
* *   W P CEAGLIO / P A MURRAY                   DATE  01/21/81 
* 
* DC  PURPOSE 
* 
*     ATTACH THE TRANSACTION RECOVERY FILE AND SET UP THE AUTO-RECOVERY 
*     TABLE IN CMM. 
* 
* DC  ENTRY CONDITIONS
* 
* D   PARAMETERS
# 
      ITEM PFTBLKA   I;            # ADDRESS OF ATTACH INFO IN MD      #
      ITEM NUMTUN    I;            # NUMBER OF TRANSACTION UNITS       #
      ITEM ERRBLKA   I;            # ADDRESS OF ERROR BLOCK            #
# 
* D   ASSUMPTIONS 
* 
*     THE TQT POINTER IS SET. 
*     SALX IS SET.
*     MD IS ALREADY OPEN. 
* 
* DC  EXIT CONDITIONS 
* 
*     NORMAL   - THE TRF IS ATTACHED AND THE POINTER SET IN THE SAL.
*                THE ART IS IN CORE AND ITS POINTER SET IN THE SAL. 
* 
*     ABNORMAL - POINTER IN SAL REMAINS SET TO ZERO.  INFORMATION IN THE
*                ERROR BLOCK IS COMPLETED AS FOLLOWS: 
*                    1) ERROR NUMBER = DFSRENFUN IF ATTACH OR CIO ERROR,
*                       DFSRENSCH IF SCHEMA MISMATCH, OR DFSRENALO IF 
*                       FILE NOT ALLOCATED. 
*                    2) IF ATTACH ERROR, FUNCTION = ATTACH AND
*                       PARAMETER = CONTENTS OF ATTACHSTATUS. 
*                       IF CIO ERROR, FUNCTION = CIO AND
*                       PARAMETER = CONTENTS OF FETNOSAT. 
*                    3) FILE TYPE = TRANSACTION FILE. 
* 
* DC  CALLING ROUTINES
* 
*     DB$SFIN      CONTROL ROUTINE FOR SYSTEM FILE INITIALIZATION 
* 
* DC  CALLED ROUTINES 
# 
      XREF PROC DB$ATCH;           # ATTACH SYSTEM FILE                #
      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 THE ART FROM THE TRF         #
      XREF FUNC DB$LFN;            # FOR ASSIGNING SYSTEM FILE LFN     #
      XREF PROC DB$MBA;            # ALLOCATE A MANAGED MEMORY BLOCK   #
      XREF PROC DB$MBF;            # FREE A MANAGED MEMORY BLOCK       #
      XREF PROC DB$MFA;            # ALLOCATE CMM BLOCK                #
      XREF PROC DB$MFF;            # RELEASE CMM BLOCK                 #
      XREF PROC DB$MSG;            # ISSUE DAYFILE MESSAGE             #
      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 THE STACK#
      XREF PROC DB$PSH2;           # PUSH TWO VARIABLES ONTO THE STACK #
      XREF PROC DB$PSH3;           # PUSH THREE VARIABLES TO THE STACK #
      XREF PROC DB$PUSH;           # PUSH VARIABLE ONTO STACK          #
      XREF FUNC DB$RIDI C(10);     # RESTART IDENTIFIER INITIALIZATION #
      XREF PROC DB$RTN;            # RETURN ATTACHED FILE              #
      XREF PROC DB$SCHD;           # CDCS SCHEDULER                    #
# 
* DC  NON-LOCAL VARIABLES MODIFIED
* 
*     SAL 
*       SATRFPTR   POINTER TO TRF FET 
*       SASCHST    SCHEMA STATUS
* 
*     ART 
*       ARMODFET   POINTER TO MODEL FET 
* 
* DC  DESCRIPTION 
* 
*     -  ALLOCATE BUFFER FOR FET AND RECORD POINTER IN SAL. 
* 
*     -  INITIALIZE FET FROM MODEL FET. 
* 
*     -  ASSIGN LFN USING COMBINATION OF LETTER "T" AND SCHEMA ID FROM
*        THE SAL ENTRY. 
* 
*     -  ISSUE AN INITIAL ATTACH REQUEST WITHOUT QUEUEING.  IF
*        UNSUCCESSFUL FOR ANY REASON OTHER THAN BUSY, OR IT IS SYSTEM 
*        RECOVERY TIME, OR IMMEDIATE RETURN IS SET, SET ERROR FIELDS, 
*        RELEASE THE FET, RESET THE SAL POINTER TO ZERO, AND RETURN 
*        FROM DB$TFIN.  IF UNSUCCESSFUL DUE TO A BUSY FILE, KEEP
*        REISSUING THE ATTACH.
* 
*     -  IF THE ATTACH IS SUCCESSFUL, READ THE TRF HEADER AND 
*        VALIDATE THAT IT HAS BEEN ALLOCATED. 
* 
*     -  READ THE ART (FIRST RECORD ON THE TRF).  SAVE THE POINTER TO 
*        THE MODEL TRF FET IN THE ART HEADER. 
* 
*     -  IF ANY ERRORS OCCURRED WHILE READING AND VALIDATING THE TRF, 
*        RETURN THE TRF, RELEASE THE FET, RESET THE SAL POINTER TO ZERO,
*        AND RETURN TO THE CALLER.
* 
 #
  
#     NON-LOCAL VARIABLES REFERENCED                                   #
  
      XREF ARRAY DB$LFET;          # MODEL FET FOR TRF USE             #
        BEGIN 
        ITEM TFETWD  U(00,00,60); 
        END 
  
#     LOCAL VARIABLES                                                  #
  
      ITEM ARTLENGTH I;            # FOR COMPUTING LENGTH OF ART       #
      ITEM ATCHMSG   C(61) =
        "  ATTACH ERROR 000 ON CDCS TRANSACTION RECOVERY FILE XXXXXXX:";
      ITEM INDEX     I;            # SCRATCH - FOR LOOPS               #
      ITEM P1        I;            # PARAMETER POINTER                 #
  
  
*CALL SRERRDCLS 
  
  
*CALL ARTDCLS 
  
      BASED ARRAY MDPFT;           # POINTER TO ATTACH INFO IN MD      #
        BEGIN 
        ITEM MDPFN  U(00,00,42);   # PERMANENT FILE NAME               #
        END 
  
*CALL TRFDCLS 
  
  
      BASED ARRAY TRFET;           # MODEL FET FOR TRF                 #
*CALL FETDCLS 
  
  
  
  
  
# S T A R T   O F   D B $ T F I N   E X E C U T A B L E   C O D E      #
  
  
      CONTROL IFGR DFFLOP,0;
        DB$FLOP("TFIN");
      CONTROL ENDIF;
  
#     CLEAR ERROR STATUS WORD.                                         #
  
      P<SRERRBLK> = ERRBLKA;
      SREWORD[0] = 0; 
  
#     ALLOCATE BUFFER FOR FET AND RECORD POINTER IN SAL.               #
  
      DB$MFA(DFFETLEN,P<TRFET>);
      SATRFPTR[SALX] = LOC(TRFET);
  
#     INITIALIZE THE FET FROM THE MODEL FET.                           #
  
      FOR INDEX=DFFETLEN-1 STEP -1
        UNTIL 0 
      DO
        BEGIN 
        FETLFNWD[INDEX] = TFETWD[INDEX];
        END 
  
#     ASSIGN LFN USING "T" AND SCHEMA ID FROM SAL ENTRY.               #
  
      FETLFNU[0] = DB$LFN("T",SASCHID[SALX]); 
  
#     ISSUE INITIAL ATTACH REQUEST WITHOUT QUEUEING.                   #
  
      P<MDPFT> = PFTBLKA; 
      B<36,6>MDPFN[0] = O"34";
      DB$PSH3(NUMTUN,P<SRERRBLK>,P<MDPFT>); 
      DB$ATCH(FETLFNU[0],MDPFT,FALSE);
      DB$POP2(P<MDPFT>,P<SRERRBLK>);
  
      P<TRFET> = SATRFPTR[SALX];
  
#     IF THE INITIAL ATTACH REQUEST WAS UNSUCCESSFUL FOR ANY           #
#     REASON OTHER THAN BUSY, OR IT IS SYSTEM RECOVERY TIME, OR        #
#     IMMEDIATE RETURN IS SET, SET ERROR FIELDS, RELEASE THE FET,      #
#     RESET THE SAL POINTER TO ZERO, AND RETURN FROM DB$TFIN.          #
#     IF UNSUCCESSFUL DUE TO A BUSY FILE, KEEP REISSUING THE ATTACH.  # 
  
        IF ATTACHSTATUS NQ 0           # IF FIRST ATTACH UNSUCCESSFUL  #
        THEN
          BEGIN 
          IF ATTACHSTATUS GR 0 OR      # ERROR OTHER THAN BUSY OR      #
             SYSRECOVERY OR            # SYSTEM RECOVERY TIME OR       #
             TQIMRTN[0]                # IMMEDIATE RETURN SET          #
          THEN
            BEGIN 
            C<53,7>ATCHMSG = C<0,7>MDPFN[0];
            C<15,3>ATCHMSG = DB$COCT(ABS(ATTACHSTATUS),3);
            DB$MSG(ATCHMSG);           # ISSUE ERROR TO CDCS DAYFILE   #
            SRENUMB[0] = DFSRENUNA; 
            SREFPAR[0] = ATTACHSTATUS;
            SREFTYP[0] = DFSREFTTR; 
            DB$MFF(P<TRFET>); 
            SATRFPTR[SALX] = 0; 
            DB$POP(NUMTUN); 
            P<MDPFT> = DFNPTR;
            P<TRFET> = DFNPTR;
            P<SRERRBLK> = DFNPTR; 
            RETURN; 
  
            END 
          ELSE                         # FILE BUSY AT INVOKE           #
            BEGIN 
            DB$PSH3(P<SRERRBLK>,P<MDPFT>,ATTACHSTATUS); 
  
            DB$ERR(95);                # ISSUE ERROR TO UCP            #
  
            DB$POP3(ATTACHSTATUS,P<MDPFT>,P<SRERRBLK>); 
            FOR INDEX = INDEX 
              WHILE ATTACHSTATUS LS 0  # WHILE FILE REMAINS BUSY       #
            DO
              BEGIN 
              C<53,7>ATCHMSG = C<0,7>MDPFN[0];
              C<15,3>ATCHMSG = DB$COCT(ABS(ATTACHSTATUS),3);
              DB$MSG(ATCHMSG);         # ISSUE ERROR TO CDCS DAYFILE   #
              DB$PSH2(P<SRERRBLK>,P<MDPFT>);
              P<MDPFT> = DFNPTR;
              P<TRFET> = DFNPTR;
              P<SRERRBLK> = DFNPTR; 
              DB$PUSH(DFATCHDELAY);    # DELAY COUNT IS PUT IN STACK   #
                                       # DB$SCHD WILL POP IT AND USE IT#
              DB$SCHD(LOC(STATCOMP),DFWAITCOUNT); 
  
              CONTROL IFGR DFFLOP,0;
                DB$FLOP("TFIN-S1"); 
              CONTROL ENDIF;
  
              DB$POP2(P<MDPFT>,P<SRERRBLK>);
              P<TRFET> = SATRFPTR[SALX];
              DB$PSH2(P<SRERRBLK>,P<MDPFT>);
              DB$ATCH(FETLFNU[0],MDPFT,FALSE);        # REISSUE ATTACH #
              DB$POP2(P<MDPFT>,P<SRERRBLK>);
              P<TRFET> = SATRFPTR[SALX];
              END 
            IF ATTACHSTATUS GR 0       # IF FILE BECAME UNAVAILABLE    #
                                       # FOR ANY REASON OTHER THAN BUSY#
            THEN
              BEGIN 
              C<53,7>ATCHMSG = C<0,7>MDPFN[0];
              C<15,3>ATCHMSG = DB$COCT(ABS(ATTACHSTATUS),3);
              DB$MSG(ATCHMSG);         # ISSUE ERROR TO CDCS DAYFILE   #
              SRENUMB[0] = DFSRENUNA; 
              SREFPAR[0] = ATTACHSTATUS;
              SREFTYP[0] = DFSREFTTR; 
              DB$MFF(P<TRFET>); 
              SATRFPTR[SALX] = 0; 
              DB$POP(NUMTUN); 
              P<MDPFT> = DFNPTR;
              P<TRFET> = DFNPTR;
              P<SRERRBLK> = DFNPTR; 
              RETURN; 
  
              END 
            END 
          END 
  
#     OTHERWISE,THE ATTACH WAS SUCCESSFUL.  READ THE TRF HEADER AND    #
#     VALIDATE THAT IT HAS BEEN ALLOCATED.                             #
  
        DB$MBA(DFTRFHDSIZE, P<TRHDREC>);
        FETRR[0] = 1; 
        DB$IORD(P<TRFET>, P<TRHDREC>, DFTRFHDSIZE); 
        DB$PUSH(P<SRERRBLK>); 
        P1 = LOC(TRFET);
        P<MDPFT> = DFNPTR;
        P<TRFET> = DFNPTR;
        P<SRERRBLK> = DFNPTR; 
        DB$SCHD(P1, DFWAITIO);
  
        CONTROL IFGR DFFLOP,0;
          DB$FLOP("TFIN-S2"); 
        CONTROL ENDIF;
  
        DB$POP2(P<SRERRBLK>,NUMTUN);
        P<TRFET> = SATRFPTR[SALX];
  
#       IF NO ERRORS OCCURRED WHILE READING THE TRF HEADER, VALIDATE   #
#       THAT THE TRF HAS BEEN ALLOCATED.  IF THE TRF IS EMPTY OR IF    #
#       THE SCHEMA NAME IN THE TRF HEADER DOES NOT MATCH THE SCHEMA    #
#       NAME IN THE SAL, SET THE APPROPRIATE FIELDS IN THE ERROR BLOCK.#
  
        IF FETNOSAT[0] EQ 0 
        THEN
          BEGIN 
          IF FETIN[0] EQ FETOUT[0]
          THEN                     # TRF EMPTY, MUST BE ALLOCATED      #
            BEGIN 
            SRENUMB[0] = DFSRENALO; 
            SREFTYP[0] = DFSREFTTR; 
            END 
          ELSE
            BEGIN 
            IF TRHDSCNAME[0] NQ SASCNAME[SALX]
            THEN                   # TRF NOT FOR CORRECT SCHEMA        #
              BEGIN 
              SRENUMB[0] = DFSRENSCH; 
              SREFTYP[0] = DFSREFTTR; 
              END 
            END 
  
#         OTHERWISE, ALLOCATE SPACE FOR THE ART (SIZE DETERMINED BY    #
#         READING MD SCHEMA INFO ENTRY) AND READ THE ART (FIRST RECORD #
#         ON THE TRF).                                                 #
  
          IF SRENUMB[0] EQ 0
          THEN
            BEGIN 
            ARTLENGTH = (NUMTUN * DFARTENSIZE) + DFARTHDSIZE; 
            DB$MFA(ARTLENGTH, P<ART>);
            SAARTPTR[SALX] = LOC(ART);
            FETRR[0] = 2; 
            DB$IORD(P<TRFET>,P<ART>,ARTLENGTH); 
            DB$PSH2(NUMTUN,P<SRERRBLK>);
            P1 = LOC(TRFET);
            P<MDPFT> = DFNPTR;
            P<TRFET> = DFNPTR;
            P<SRERRBLK> = DFNPTR; 
            DB$SCHD(P1, DFWAITIO);
  
            CONTROL IFGR DFFLOP,0;
              DB$FLOP("TFIN-S3"); 
            CONTROL ENDIF;
  
            DB$POP2(P<SRERRBLK>,NUMTUN);
            P<TRFET> = SATRFPTR[SALX];
            P<ART> = SAARTPTR[SALX];
            ARMODFET[0] = 0;       # INITIALIZE FET POINTER TO ZERO.   #
            ARLARID[0] = DB$RIDI;  # INITIALIZE THE RESTART IDENTIFIER #
# 
*           IF THE COMMITMENT FLAG IS ON RESET THE TRANSACTION ID 
*           TO SPACES 
# 
            FOR INDEX = NUMTUN STEP -1 UNTIL 1
            DO
              BEGIN 
              IF ARTRCS[INDEX]
              THEN
                BEGIN 
                ARBCID[INDEX] = " ";
                END 
              END 
            END 
          END 
  
#       IF AN ERROR OCCURRED WHILE READING THE TRF, SET THE            #
#       APPROPRIATE FIELDS IN THE ERROR BLOCK.                         #
  
        IF FETNOSAT[0] NQ 0 
        THEN
          BEGIN 
          SRENUMB[0] = DFSRENFUN; 
          SREFUNC[0] = DFSREFNIO; 
          SREFPAR[0] = FETNOSAT[0]; 
          SREFTYP[0] = DFSREFTTR; 
          END 
  
#       RELEASE THE SPACE FOR THE TRF HEADER.                          #
  
        DB$MBF(P<TRHDREC>); 
  
#       IF ANY ERRORS OCCURRED WHILE READING AND VALIDATING THE TRF,   #
#       RETURN THE TRF, RELEASE THE FET, AND RESET THE SAL POINTER TO  #
#       ZERO.  OTHERWISE, SAVE THE POINTER TO THE MODEL TRF FET IN THE #
#       ART HEADER.                                                    #
  
        IF SRENUMB[0] NQ 0
        THEN
          BEGIN 
          DB$RTN(FETLFNU[0]); 
          DB$MFF(P<TRFET>); 
          SATRFPTR[SALX] = 0; 
          END 
        ELSE
          BEGIN 
          ARMODFET[0] = LOC(TRFET); 
          END 
  
      P<MDPFT> = DFNPTR;
      P<TRFET> = DFNPTR;
      P<SRERRBLK> = DFNPTR; 
  
      RETURN; 
      END 
      TERM; 
