*DECK DB$PRST 
USETEXT CUGDFTX 
      PROC DB$PRST(FETLOC,(WORDC),WRWFLG);
      BEGIN 
 #
* *   DB$PRST - PRE-ALLOCATE AND PRESET A FILE   PAGE  1
* *   BOB MCALLESTER                             DATE  02/16/81 
* 
* DC  PURPOSE 
* 
*     PRE-ALLOCATE A FILE BY WRITING THE SPECIFIED NUMBER OF WORDS. 
*     EACH WORD IS SET TO THE VALUE -DFPRESET-, DEFINED IN CUGDFDCLS. 
* 
* DC  ENTRY CONDITIONS
* 
* D   PARAMETERS
# 
      ITEM FETLOC I;         # LOCATION OF THE FET                     #
      ITEM WORDC I;          # WORD COUNT, PRE-ALLOCATION SIZE IN WORDS#
      ITEM WRWFLG B;         # WRITE/REWRITE FLAG. IF TRUE USE THE     #
                             # REWRITE AND REWRITER MACROS. ELSE USE   #
                             # THE WRITE AND WRITER MACROS.            #
# 
* D   ASSUMPTIONS 
* 
*     THE FET POINTERS FETFIRST AND FETLIMIT DEFINE THE OUTPUT BUFFER.
*     THE FILE IS POSITIONED WHERE WRITING SHOULD BEGIN.
* 
* DC  EXIT CONDITIONS 
* 
*     NORMAL - *WORDC* WORDS CONTAINING *DFPRESET* HAVE BEEN
*             WRITTEN TO THE FILE.
* 
*     ABNORMAL - IF A CIO ERROR OCCURRED DURING THE PRESETTING
*               OF THE FILE, THEN CONTROL RETURNS TO THE CALLER.
* 
* DC  CALLING ROUTINES
* 
*     DBREC 
*       DB$BALJ              ALLOCATE JOURNAL LOG FILES 
*       DB$BALQ              ALLOCATE THE QUICK RECOVERY FILE 
*       DB$BALT              ALLOCATE TRANSACTION RECOVERY FILES
*       DB$BDLG              DUMP THE JOURNAL LOG FILE TO TAPE
* 
* DC  CALLED ROUTINES 
# 
      XREF PROC DB$RCLL;     # CPU RECALL, WAIT FOR I-O TO PROCEED.    #
      XREF PROC DB$RWRT;     # REWRITE MACRO                           #
      XREF PROC DB$RWTM;     # REWRITE RECORD MACRO                    #
      XREF PROC DB$WRRM;     # WRITE RECORD MACRO                      #
      XREF PROC DB$WRTM;     # WRITE MACRO                             #
# 
* DC  NON-LOCAL VARIABLES MODIFIED
# 
      BASED ARRAY BUFFER;    # OUTPUT BUFFER                           #
        BEGIN 
        ITEM BUFWORD I(00,00,60); 
        END 
  
      BASED ARRAY FET;
*CALL FETDCLS 
# 
* DC  DESCRIPTION 
* 
*     THE FET IN AND OUT POINTERS AND THE LOCAL VARIABLES ARE 
*     INITIALIZED.
*     THE OUTPUT BUFFER IS PRESET.
* 
*     THE MAIN LOOP DETERMINES HOW FAR THE OUT POINTER HAS BEEN MOVED 
*     BY CIO.  THE IN POINTER IS MOVED TO (OUT MINUS ONE) TO INDICATE 
*     THAT THE BUFFER IS FULL AND READY TO WRITE (OR REWRITE).
*     AS DATA IS MADE AVAILABLE TO CIO, THE WORD COUNT IS REDUCED.
*     WHEN THE WORD COUNT BECOMES NEGATIVE, THE IN POINTER IS ADJUSTED
*     TO WRITE (OR REWRITE) THE EXACT FILE SIZE.
* 
*     AFTER EXITING FROM THE MAIN LOOP, A WRITE (OR REWRITE) RECORD IS
*     ISSUED TO FLUSH THE FINAL WORDS TO THE FILE.
 #
# 
*     LOCAL VARIABLES 
# 
      ITEM FIRST I;          # ADDRESS OF FIRST BUFFER WORD            #
      ITEM IN I;             # LOCAL COPY OF IN POINTER                #
      ITEM OUT I;            # LOCAL COPY OF OUT POINTER               #
      ITEM SIZE I;           # LENGTH OF THE BUFFER                    #
      ITEM XX I;             # INDUCTION VARIABLE                      #
# 
*     A LOCAL COPY OF FETFIRST IS MADE FOR REASONS OF EFFICIENCY. 
*     A LOCAL COPY OF THE OUT POINTER IS MADE TO AVOID ITS BEING
*     MODIFIED BY CIO DURING THE CALCULATIONS.
*     A LOCAL COPY OF THE IN POINTER IS KEPT SO THAT THE FETIN IS 
*     NOT WRITTEN TO SOME PRELIMINARY VALUE THAT COULD CAUSE A
*     BUFFER ARGUMENT ERROR TO BE ISSUED BY CIO.
# 
  
  
#     B E G I N   D B $ P R S T   E X E C U T A B L E   C O D E .      #
  
# 
*     PROGRAM INITIALIZATION
# 
      P<FET> = FETLOC;
      FIRST = FETFIRST[0];
      FETOUT[0] = FIRST;
      IN = FIRST; 
      P<BUFFER> = FIRST;
      SIZE = FETLIMIT[0] - FIRST; 
                             # PRESET THE OUTPUT BUFFER                #
      FOR XX = SIZE -1 STEP -1 UNTIL 0
      DO
        BEGIN 
        BUFWORD[XX] = DFPRESET; 
        END 
# 
*     MAIN LOOP 
# 
      FOR XX = XX WHILE WORDC NQ 0
      DO
        BEGIN 
        OUT = FETOUT[0];     # SAVE THE CURRENT VALUE OF THE OUT POINTR#
        WORDC = WORDC + IN - OUT +1;  # PRELIMINARY ADJUSTMENT OF COUNT#
        IF IN GQ OUT
        THEN
          BEGIN 
          WORDC = WORDC - SIZE;  # READJUST THE WORD COUNT             #
          END 
        IN = OUT -1;         # PRELIMINARY -IN- POINTER POSITION       #
        IF IN LS FIRST
        THEN
          BEGIN 
          IN = IN + SIZE; 
          END 
        IF WORDC LS 0 
        THEN                 # THE COUNT IS NEGATIVE                   #
          BEGIN 
          IN = IN + WORDC;   # READJUST THE POTENTIAL -IN- POINTER     #
          IF IN LS FIRST
          THEN
            BEGIN 
            IN = IN + SIZE;  # MOVE -IN- BACK INTO THE BUFFER          #
            END 
          WORDC = 0;
          END 
        FETIN[0] = IN;       # SET THE POINTER IN THE FET              #
  
        IF FETCOMP[0] 
        THEN                 # THE FET IS IDLE                         #
          BEGIN 
          IF FETNOSAT[0] NQ 0      # IF A CIO ERROR OCCURRED.          #
          THEN
            BEGIN 
            RETURN;                # RETURN TO THE CALLER.             #
  
            END 
          IF WRWFLG          # IF THE WRITE/REWRITE FLAG IS TRUE       #
          THEN               # THEN ISSUE THE REWRITE FUNCTION.        #
            BEGIN 
            DB$RWRT(P<FET>);
            END 
          ELSE               # ELSE ISSUE THE WRITE FUNCTION.          #
            BEGIN 
            DB$WRTM(P<FET>);
            END 
          END 
        DB$RCLL(0);          # CPU RECALL,  GIVE CIO SOME TIME         #
        END 
# 
*     TERMINATION 
# 
      IF NOT FETCOMP[0] 
      THEN
        BEGIN 
        DB$RCLL(P<FET>);     # WAIT FOR THE LAST WRITE TO COMPLETE     #
        END 
      IF WRWFLG              # IF THE WRITE/REWRITE FLAG IS TRUE       #
      THEN                   # THEN ISSUE THE REWRITE RECORD FUNCTION. #
        BEGIN 
        DB$RWTM(P<FET>);
        END 
      ELSE                   # ELSE ISSUE THE WRITE RECORD FUNCTION.   #
        BEGIN 
        DB$WRRM(P<FET>);
        END 
      DB$RCLL(P<FET>);       # WAIT FOR IT TO COMPLETE                 #
      END 
      TERM
