*DECK FCSUIMB 
USETEXT TEXTFCS 
      FUNC FCSUIMB (FILETYPE, FILENAME) B;
*CALL COPYRITE
# TITLE FCSUIMB - UTILITY TO INITIALIZE AN MBT ENTRY                   #
  
      BEGIN                            # FCSUIMB                       #
  
# 
**    FCSUIMB - UTILITY TO INITIALIZE AN MBT ENTRY. 
* 
*     C. J. RAMSAY                     87/11/03 
* 
*     THIS PROCEDURE INITIALIZES AN MANAGED BUFFER TABLE ENTRY FOR A
*     FILE. EACH ENTRY INCLUDES A FET, FTP CONTROL STATEMENT SPECIFIC 
*     INFORMATION, AND A CIO BUFFER.
* 
*     FUNC FCSUIMB (FILETYPE, FILENAME) 
* 
*     ENTRY   FILETYPE   = FILE TYPE. 
*             FILENAME   = LOCAL FILE NAME (ZERO FILLED). 
* 
*     EXIT    FCSUIMB    = FALSE IF ENTRY NOT INITIALIZED.
*             FCSUIMB    = TRUE IF ENTRY INITIALIZED. 
*             FTPUSERE   = TRUE IF ENTRY NOT INITIALIZED. 
*             MBTX       = INDEX OF ENTRY INITIALIZED.
* 
*     METHOD  SEARCH FOR A CORRESPONDING ENTRY AND TAKE THE 
*             FOLLOWING ACTION. 
*               SAME NAME + SAME TYPE = TRUE
*               SAME NAME + DIFF TYPE = FALSE 
*               DIFF NAME + SAME TYPE = TRUE + INITIALIZE 
*               DIFF NAME + DIFF TYPE = TRUE + CREATE + INITIALIZE
* 
# 
  
# 
****  FUNC FCSUIMB - XREF LIST
# 
      XREF
        BEGIN 
        PROC FCSMATS;                  # ALLOCATE TABLE SPACE          #
        PROC FCSOWOF;                  # WRITE TO OUTPUT FILE          #
        PROC NETUCLR;                  # CLEAR A BLOCK OF MEMORY       #
        PROC RECALL;                   # WAIT FOR OPERATION TO COMPLETE#
        PROC WRITER;                   # WRITE END OF RECORD           #
        END 
# 
****
# 
      ITEM FILETYPE      U;            # FILE TYPE                     #
      ARRAY FILENAME [00:00] S(1);     # LOCAL FILE NAME               #
        BEGIN 
        ITEM  FILE$LFN   C(00,00,07); 
        END 
  
      ITEM I             I;            # LOOP INDUCTION VARIABLE       #
      ITEM NUMENT        I;            # NUMBER OF MBT ENTRIES         #
      ITEM SAMETYPE      B;            # MATCHING TYPE FOUND           #
  
      ARRAY ULFMSG [00:00] S(6);
        BEGIN 
        ITEM  ULF$TEXT   C(00,00,51) =
       ["--ERROR--  LOCAL FILE SPECIFIED ALREADY BEING USED."]; 
        ITEM  ULF$ZBYTE  U(05,06,54) = [0]; 
        END 
      CONTROL EJECT;
# 
*     START MAIN PROCEDURE
# 
      FCSUIMB  = TRUE;                 # ENTRY INITIALIZED BY DEFAULT  #
      SAMETYPE = FALSE;                # DEFAULT TO ENTRY NOT FOUND    #
      NUMENT   = MBTL / MBTESIZ$;      # NUMBER OF MBT ENTRIES         #
# 
*     DETERMINE IF SAME FILE TYPE EXISTS. 
*     RETURN ERROR IF SAME FILE NAME BUT DIFFERENT FILE TYPE FOUND. 
*     RETURN IF SAME FILE NAME AND SAME FILE TYPE FOUND.
# 
      FOR I = 0 STEP 1                 # LOOP THRU ALL ENTRIES         #
        WHILE I LS NUMENT DO
        BEGIN 
        IF MBT$FTYPE[I] EQ FILETYPE 
        THEN
          BEGIN                        # MATCHING FILE TYPE            #
          SAMETYPE = TRUE;             # DO NOT ALLOCATE NEW ENTRY     #
          MBTX = I;                    # SAVE MBT ENTRY INDEX          #
          END 
        IF MBT$LFN[I] EQ FILE$LFN[0]
        THEN
          BEGIN                        # FOUND MATCHING FILE NAME      #
          IF MBT$FTYPE[I] NQ FILETYPE 
          THEN
            BEGIN                      # WITH NON MATCHING FILE TYPE   #
            FCSOWOF (ULFMSG,INTERNAL$);# SEND LFN IN USE ERROR MESSAGE #
            FTPUSERE = TRUE;           # UPDATE USER ERROR             #
            FCSUIMB  = FALSE;          # ENTRY NOT INITIALIZED         #
            END 
          RETURN;                      # GET OUT OF HERE QUICKLY       #
          END 
        END 
# 
*     IF CHANGING OUTPUT FILE THEN FLUSH THE EXISTING OUTPUT FILE.
*     IF NECESARY THEN CREATE A NEW ENTRY.
# 
      IF SAMETYPE 
      THEN
        BEGIN                          # ENTRY WITH SAME TYPE FOUND    #
        IF (MBT$FTYPE[MBTX] EQ FTOUTPUT) AND
           (MBT$LFNU[MBTX] NQ 0) AND
           (MBT$DT[MBTX] NQ "TT") 
        THEN
          BEGIN                        # NON TERMINAL OUTPUT FILE      #
          WRITER (MBT[MBTX]);          # FLUSH THE OUTPUT FILE         #
          RECALL (MBT[MBTX]);          # WAIT FOR OPERATION TO COMPLETE#
          END 
        END 
      ELSE
        BEGIN                          # ENTRY WITH SAME TYPE NOT FOUND#
        FCSMATS (P<MBT>, MBTL,
                 MBTESIZ$);            # ALLOCATE A MBT ENTRY          #
        MBTX = NUMENT;                 # INDEX OF NEW ENTRY            #
        END 
# 
*     INITIALIZE THE MBT ENTRY. 
# 
      NETUCLR (LOC(MBT$WORD[MBTX]), 
               MBTESIZ$);              # CLEAR THE MBT ENTRY           #
      MBT$LFN[MBTX]   = FILE$LFN[0];   # SET LOCAL FILE NAME           #
      MBT$COMPB[MBTX] = TRUE;          # SET COMPLETION BIT            #
      MBT$UP[MBTX]    = TRUE;          # SET USER PROCESSING BIT       #
      MBT$EP[MBTX]    = TRUE;          # SET ERROR PROCESSING BIT      #
      MBT$LEN[MBTX]   = FETSIZ$ - 5;   # SET FET SIZE - 5 WORDS        #
      MBT$FIRST[MBTX] = 
        LOC(MBT$BUFFER[MBTX]);         # SET FIRST ADDRESS             #
      MBT$IN[MBTX] = MBT$FIRST[MBTX];  # SET IN ADDRESS                #
      MBT$OUT[MBTX] = MBT$FIRST[MBTX]; # SET OUT ADDRESS               #
      MBT$LIMIT[MBTX] = 
        MBT$FIRST[MBTX] + FBUFSIZ$;    # SET LIMIT ADDRESS             #
      MBT$FTYPE[MBTX] = FILETYPE;      # SET FILE TYPE                 #
  
      RETURN;                          # RETURN TO CALLER              #
  
      END                              # FCSUIMB                       #
  
      TERM
