/* f4file.c (c)Copyright Sequiter Software Inc., 1988-1996.  All rights reserved. */

#include "d4all.h"
#ifdef __TURBOC__
   #pragma hdrstop
#endif

#ifdef S4TEMP
   #include "t4test.h"
#endif

#ifdef _MSC_VER
   #ifdef S4WINDOWS
      #include <dos.h>
   #endif
#endif

#ifdef S4WINTEL
   #ifndef S4IBMOS2
      #ifndef __TURBOC__
         #include <sys\locking.h>
         #define S4LOCKING
      #endif
      #ifdef __ZTC__
      #endif
      #ifdef _MSC_VER
         #include <sys\types.h>
         #include <sys\locking.h>
      #endif
   #endif

/*   #include <sys\stat.h>*/
/*   #include <share.h>*/
#endif

/*#include <fcntl.h>*/

#ifdef __SC__
   #include <dos.h>
#endif

#ifdef S4NO_FILELENGTH
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
      #ifdef S4WIN32
         long u4filelength( int hand )
         {
            long rc ;

            rc = (long)GetFileSize( (HANDLE)hand, NULL ) ;

            #ifdef E4PARM_LOW
               if ( rc == -1L )
                  error4( 0, e4result, E90603 ) ;
            #endif

            return rc ;
         }
      #else
         #include  <sys/types.h>
         #include  <sys/stat.h>

         long u4filelength( int hand )
         {
            struct stat strStat ;

            if (fstat( hand, &strStat ) )
               return error4( 0, e4result, E90603 ) ;

            return( (long) strStat.st_size ) ;
         }
      #endif
/* */
#endif

/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */

#ifdef S4LSEEK
   /* if extend is set, file is extended, else lseek to EOF */
   long f4lseek(FILE4 *f4, long offset, int fromWhere, int extend )
   {
      long fileLen ;

      if ( offset != 0 )
      {
         fileLen = u4filelength( f4->hand ) ;

         if (extend)
         {
            if ( fileLen < offset )
               file4changeSize( f4, offset ) ;
         }
         else
            if ( fileLen < offset )
            {
               if ( lseek( f4->hand, fileLen, 0 ) )
                  return offset ;
               else
                  return -1L ;
            }
      }
      return lseek( f4->hand, offset, fromWhere ) ;
   }
#endif

#ifdef S4NO_CHSIZE

#define E4MAXLINE 129   /* maximum file path length */

/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
   #ifdef _MSC_VER
      #ifdef S4WINDOWS
         int S4FUNCTION file4changeSize( FILE4 *f4, long size )
         {
            unsigned int rc, num ;
            char a ;

            a = (char)0x00 ;
            _llseek( f4->hand, size, SEEK_SET ) ;

            rc = _dos_write( f4->hand, &a, 0, &num ) ;
            if ( num != 0 || rc != 0 )
               return error4( f4->codeBase, e4lenSet, E90604 ) ;

            return 0 ;
         }
      #endif
   #else
      int S4FUNCTION file4changeSize( FILE4 *f4, long size )
      {
         char *buffer ;
         char tempName[E4MAXLINE], fileName[E4MAXLINE] ;
         long bufferSize, fileLen, amountRead = 0, t ;
         CODE4 *c4 ;
         FILE4 temp ;
         FILE4SEQ_WRITE seqWrite ;
         FILE4SEQ_READ seqRead ;
         int len, shortLen, pos, i, rc ;
         int oldTemp, oldc4Temp, oldAccessMode, oldReadOnly, newAccessMode, newReadOnly;

         #ifdef E4PARM_LOW
            if ( f4 == 0 || size < 0L )
               return error4( 0, e4parm_null, E90604 ) ;
         #endif

         #ifdef E4ANALYZE
            if ( f4->isReadOnly )
               return error4( f4->codeBase, e4parm, E90604 ) ;
         #endif

         c4 = f4->codeBase ;

         fileLen = u4filelength( f4->hand ) ;
         if ( size == fileLen )
            return 0 ;

         bufferSize = c4->memSizeBuffer ;
         buffer = (char *)u4allocFree( c4, bufferSize ) ;
         while ( !buffer )
         {
            bufferSize -= 0x400 ;

            if ( bufferSize <= 0 )
               return error4( c4, e4memory, E90604 ) ;

            buffer = (char *)u4allocFree( c4, bufferSize ) ;
         }

         if ( size > fileLen )    /* pad file to increase size */
         {
            file4seqWriteInit( &seqWrite, f4, fileLen, buffer, bufferSize ) ;
            file4seqWriteRepeat( &seqWrite, size - fileLen, '\0' ) ;
            file4seqWriteFlush( &seqWrite ) ;
            u4free( buffer ) ;
            return 0 ;
         }

         c4 = f4->codeBase ;

         len = strlen( f4->name ) ;
         if ( len >= E4MAXLINE )
            len = E4MAXLINE - 1 ;
         memcpy( fileName, f4->name, len ) ;
         fileName[len] = 0 ;
         oldTemp = f4->isTemp;
         newAccessMode = f4->lowAccessMode;
         newReadOnly = f4->isReadOnly;
         oldc4Temp =  c4->createTemp;
         oldAccessMode = c4->accessMode;
         oldReadOnly = c4->readOnly;
         c4->createTemp = 0;
         c4->accessMode = newAccessMode;
         c4->readOnly = newReadOnly;

         u4namePiece(tempName, E4MAXLINE, f4->name, 0,0);
         shortLen = strlen(tempName);
         u4namePiece( tempName, E4MAXLINE, f4->name, 1, 0 ) ;
         pos = strlen(tempName) - shortLen;
         memcpy(tempName+pos, "TEMP",4);
         tempName[pos+9] = 0;

         for ( i = 0 ;; )
         {
            if ( i >= 100 )
            {
               rc = error4( c4, e4create, E80605 ) ;
               break ;
            }
            i++ ;

            u4delayHundredth( 50 ) ;
            time( &t ) ;
            t %= 10000L ;

            c4ltoa45( t, tempName + pos + 4, -4 ) ;
            u4nameExt( tempName, E4MAXLINE, "TMP", 1 ) ;

            rc = file4create( &temp, c4, tempName, 0 ) ;
            if ( rc <= 0 )
               break;
         }

         c4->createTemp = oldc4Temp;
         c4->accessMode = oldAccessMode;
         c4->readOnly = oldReadOnly;

         if (rc < 0)
         {
            u4free( buffer ) ;
            return error4describe( c4, e4create, E90604, tempName, 0, 0 ) ;
         }

         /* use file4seq to avoid tracking position manually */
         file4seqWriteInit( &seqWrite, &temp, 0, 0, 0 ) ;
         file4seqReadInit( &seqRead, f4, 0, 0, 0 ) ;

         /* copy the old file contents to the temp file */
         while ( size > 0 )
         {
            if ( size < bufferSize )
               amountRead = file4seqRead( &seqRead, buffer, size ) ;
            else
               amountRead = file4seqRead( &seqRead, buffer, bufferSize ) ;

            file4seqWrite( &seqWrite, buffer, amountRead ) ;
            size -= amountRead ;
         }

         file4seqWriteFlush( &seqWrite ) ;

         u4free( buffer ) ;

         file4close( &temp ) ;

         f4->isTemp = 1;
         if ( file4close( f4 ) != 0)
            return error4describe( c4, e4info, E90604, fileName, 0, 0 ) ;

         if ( u4rename( tempName, fileName ) )
            return error4describe( c4, e4rename, E90604, fileName, 0, 0 ) ;

         if ( file4open( f4, c4, fileName, 1 ) < 0 )
            return error4describe( c4, e4open, E90604, fileName, 0, 0 ) ;

         f4->isTemp = oldTemp;

         #ifndef S4OFF_MULTI
            if ( file4lock( f4, L4LOCK_POS, L4LOCK_POS ) < 0 )
               return error4describe( c4, e4lock, E90604, fileName, 0, 0 ) ;
         #endif

         return 0 ;
      }
   #endif /* MSC_VER */
/* */
#endif   /* ifdef S4NO_CHSIZE */

long S4FUNCTION file4len( FILE4 *f4 )
{
   long lrc ;

   #ifdef E4PARM_HIGH
      if ( f4 == 0 )
         return error4( 0, e4parm_null, E90605 ) ;
   #endif
   #ifdef E4ANALYZE
      if ( f4->hand < 0 )
         return error4( f4->codeBase, e4parm, E90605 ) ;
   #endif

   #ifndef S4OFF_OPTIMIZE
      if ( f4->isTemp == 1 && f4->fileCreated == 0 )
      {
         /* 04/24/96 AS fix for c/s t4commit.c */
         if ( f4->len == -1 )
            return 0 ;
         else
            return f4->len ;
      }
      if ( f4->doBuffer && f4->len >= 0 )
         lrc = f4->len ;
      else
   #endif
   lrc = u4filelength( f4->hand ) ;
   if ( lrc < 0L )
      error4describe( f4->codeBase, e4len, E90605, f4->name, 0, 0 ) ;
   return lrc ;
}

int S4FUNCTION file4lenSet( FILE4 *f4, const long newLen )
{
   int rc ;
   CODE4 *c4 ;
   #ifdef S4WRITE_DELAY
      FILE4WRITE_DELAY *writeDelay ;
      LINK4 *delayLink ;
   #endif
   #ifdef __SC__
      union REGS dosFlush ;
   #endif

   #ifdef E4PARM_HIGH
      if ( f4 == 0 || newLen < 0 )
         return error4( 0, e4parm_null, E90606 ) ;
   #endif

   c4 = f4->codeBase ;

   #ifdef E4ANALYZE
      if ( f4->hand < 0 || f4->codeBase == 0 )
         return error4( c4, e4struct, E90606 ) ;
      if ( f4->isReadOnly )
         return error4( c4, e4struct, E80601 ) ;
   #else
      if ( c4 == 0 )
         return -1 ;
   #endif

   if ( error4code( c4 ) > 0 && error4code( c4 ) < 200 )  /* file error */
      return -1 ;

   if ( f4->isReadOnly )
      return error4( c4, e4parm, E80607 ) ;

   #ifndef S4OFF_OPTIMIZE
      if ( f4->doBuffer )
      {
         /* if len is -1 but bufferWrites true, may still have buffered data
            which must be removed, so get disk file length for reference */
         if ( f4->bufferWrites == 1 && f4->fileCreated != 0 )
            f4->len = file4len( f4 ) ;
         if ( f4->len > newLen )   /* must do a partial delete of memory */
            opt4fileDelete( f4, newLen, f4->len ) ;
         if ( f4->bufferWrites )
            f4->len = newLen ;
         #ifdef E4ANALYZE
            else
               if ( f4->len != -1L )
                  error4( 0, e4result, E90606 ) ;
         #endif
      }

      #ifdef E4ANALYZE_ALL
         if ( f4->hasDup == 1 )
            if ( f4->doBuffer == 1 || f4->link.n == 0 )
               if ( file4PartLenSet( f4, newLen ) < 0 )
                  return error4( c4, e4opt, E80602 ) ;
      #endif

      #ifdef S4SAFE
         if ( f4->fileCreated != 0 )   /* don't need to safeguard temporary files */
      #else
         /* E4ANALYZE must explicitly set file length for later verifications */
         #ifndef E4ANALYZE
            if ( f4->doBuffer == 0 || f4->bufferWrites == 0 )
         #endif
      #endif
   #endif

   {      /* needed !!! */
      #ifndef S4OFF_OPTIMIZE
         if ( f4->fileCreated == 1 )
      #endif
      {
/* */
/* */
/* */
            #ifdef S4WIN32
               #ifdef S4MULTI_THREAD
                  EnterCriticalSection( &f4->critical4file ) ;
               #endif
               #ifdef S4WRITE_DELAY
                  if ( l4numNodes( &f4->delayWriteFileList ) != 0 )
                  {
                     for ( delayLink = (LINK4 *)l4first( &f4->delayWriteFileList ) ;; )
                     {
                        if ( delayLink == 0 )
                           break ;
                        writeDelay = (FILE4WRITE_DELAY *)(delayLink - 1 ) ;
                        delayLink = (LINK4 *)l4next( &f4->delayWriteFileList, delayLink ) ;
                        /* now, if the delay-write is without the boundaries of
                           the len-set, then remove that part */
                        if ( ( writeDelay->pos + (long)writeDelay->len ) > newLen )
                        {
                           /* maybe is being written to disk now, in which case
                              must wait */
                           while ( writeDelay->usageFlag == r4inUse )  /* is being written to disk, just wait until it is done... */
                              Sleep( 0 ) ;
                           if ( writeDelay->usageFlag == r4finished ) /* is written to disk, so can just ignore */
                              continue ;
                           if ( writeDelay->pos > newLen )   /* just remove */
                           {
                              writeDelay->status = 0 ;
                              writeDelay->usageFlag = r4finished ;  /* outside of critical section, to allow a wait for completion while keeping the critical section */
                              l4remove( &f4->codeBase->delayWriteList, writeDelay ) ;
                              l4remove( &f4->delayWriteFileList, &writeDelay->fileLink ) ;
                              writeDelay->completionRoutine( writeDelay ) ;
                              mem4free( c4->delayWriteMemory, writeDelay ) ;
                           }
                           else  /* just reduce the length */
                              writeDelay->len = newLen - writeDelay->pos ;
                        }
                     }
                  }
               #endif
               if ( SetFilePointer( (HANDLE)f4->hand, newLen, NULL, FILE_BEGIN ) == (DWORD)-1 )
                  return error4describe( c4, e4lenSet, E90606, f4->name, 0, 0 ) ;
               if ( SetEndOfFile( (HANDLE)f4->hand ) )
                  rc = 0 ;
               else
                  rc = -1 ;
               #ifdef S4MULTI_THREAD
                  LeaveCriticalSection( &f4->critical4file ) ;
               #endif
            #else
               #ifdef __SC__
                  rc = 0 ;
                  dosFlush.x.ax = 0x4200;
                  dosFlush.x.bx = f4->hand ;
                  memcpy((void *)&dosFlush.x.dx,(void *)&newLen,2);
                  memcpy((void *)&dosFlush.x.cx,((char *)&newLen)+2,2);
                  intdos( &dosFlush, &dosFlush ) ;
                  if ( dosFlush.x.cflag != 0 )
                    return error4( c4, e4lenSet, E90606 ) ;
                  dosFlush.h.ah = 0x40;
                  dosFlush.x.bx = f4->hand ;
                  dosFlush.x.cx = 0x00;
                  intdos( &dosFlush, &dosFlush ) ;
                  if ( dosFlush.x.cflag != 0 )
                    return error4( c4, e4lenSet, E90606 ) ;
                  rc = 0
               #else
                  #ifdef S4NO_CHSIZE
                     rc = ftruncate( f4->hand, newLen ) ;
                  #else
                     rc = chsize( f4->hand, newLen ) ;
                  #endif
               #endif
            #endif
/* */

         if ( rc < 0 )
            return error4describe( c4, e4lenSet, E90606, f4->name, (char *)0, (char *)0 ) ;
      }
   }  /* needed ! ! ! */

   return 0 ;
}

static unsigned file4readLowDo( FILE4 *f4, const long pos, void *ptr, const unsigned len )
{
   long rc ;
   unsigned urc ;
   #ifndef S4OFF_OPTIMIZE
      #ifdef S4OPTIMIZE_STATS
         DATA4 *stat ;
         CODE4 *c4 ;
      #endif
   #endif

   #ifdef S4MULTI_THREAD
      EnterCriticalSection( &f4->critical4file ) ;
   #endif

   #ifndef S4OFF_OPTIMIZE
      #ifdef S4OPTIMIZE_STATS
         c4 = f4->codeBase ;
         stat = c4->statusDbf ;
         if ( stat != 0 )  /* track stats */
         {
            if ( f4 != &stat->dataFile->file )  /* don't do for the stat file! */
            {
               if ( d4appendStart( stat, 0 ) == 0 )
               {
                  f4assignChar( c4->typeFld, 'L' ) ;  /* low-level */
                  f4assign( c4->fileNameFld, f4->name ) ;
                  f4assignLong( c4->offsetFld, pos ) ;
                  f4assignLong( c4->lengthFld, len ) ;
                  d4append( stat ) ;
               }
            }
         }
      #endif
   #endif

   #ifdef S4WIN32
      rc = SetFilePointer( (HANDLE)f4->hand, pos, NULL, FILE_BEGIN ) ;
      if ( rc != (DWORD)-1 )
         rc = pos ;
   #else
/* */
/* */
/* */
         #ifdef S4WINDOWS
            rc = _llseek( f4->hand, pos, 0 ) ;
         #else
            #ifdef S4LSEEK
               rc = f4lseek( f4, pos, 0, 0 ) ;
            #else
               rc = lseek( f4->hand, pos, 0 ) ;
            #endif
         #endif
/* */
   #endif

   if ( rc != pos )
   {
      #ifdef S4MULTI_THREAD
         LeaveCriticalSection( &f4->critical4file ) ;
      #endif
      file4readError( f4, pos, len, "file4readLow" ) ;
      return 0 ;
   }

   #ifdef S4WIN32
      ReadFile( (HANDLE)f4->hand, ptr, len, (unsigned long *)&urc, NULL ) ;
   #else
/* */
/* */
/* */
/* */
/* */
/* */
/* */
/* */
         #ifdef S4WINDOWS
            urc = (unsigned)_lread( f4->hand, (char *)ptr, len ) ;
         #else
            #ifdef S4LSEEK
               /* if reading past EOF */
               if ( pos+len > u4filelength( f4->hand ) )
                  urc = (unsigned)read( f4->hand, ptr, u4filelength(f4->hand) - pos ) ;
               else
                  urc = (unsigned)read( f4->hand, ptr, len ) ;
            #else
               urc = (unsigned)read( f4->hand, ptr, len ) ;
            #endif
         #endif
/* */
   #endif

   if ( urc > len )
   {
      #ifdef S4MULTI_THREAD
         LeaveCriticalSection( &f4->critical4file ) ;
      #endif

      file4readError( f4, pos, len, "file4readLow" ) ;
      return 0 ;
   }

   #ifndef S4OFF_OPTIMIZE
      #ifdef E4ANALYZE_ALL
         if ( f4->hasDup == 1 )
            if ( f4->doBuffer == 1 || f4->link.n == 0 )
               if ( file4cmpPart( f4->codeBase, ptr, f4, pos, urc ) != 0 )
               {
                  #ifdef S4MULTI_THREAD
                     LeaveCriticalSection( &f4->critical4file ) ;
                  #endif
                  error4( f4->codeBase, e4opt, E80602 ) ;
                  return 0 ;
               }
      #endif
   #endif

   #ifdef S4MULTI_THREAD
      LeaveCriticalSection( &f4->critical4file ) ;
   #endif

   return urc ;
}

/* this function also includes advance-read/delay-write checking */
unsigned file4readLow( FILE4 *f4, const long pos, void *ptr, const unsigned len )
{
   unsigned urc ;
   #ifndef S4OFF_OPTIMIZE
      #ifdef S4OPTIMIZE_STATS
         DATA4 *stat ;
         CODE4 *c4 ;
      #endif
   #endif
   #ifdef S4WRITE_DELAY
      FILE4WRITE_DELAY *writeDelay ;
      LINK4 *delayLink ;
      long beforeLen, afterPos, afterLen ;
      unsigned copyLen, copyPos ;
   #endif
   #ifdef S4ADVANCE_READ
      long offset ;
   #endif

   #ifdef S4ADVANCE_READ
      /* check the special advance-read-buffer for the file first, if it fits
         in entirely, then copy from there instead of performing read */
      if ( f4->advanceReadBufStatus != AR4EMPTY )  /* if it is set put still in area, then wait for the advance-read to finish */
      {
         offset = pos - f4->advanceReadBufPos ;
         if ( ( offset >= 0 ) && ( ( pos + len ) <= ( f4->advanceReadBufPos + f4->advanceReadBufLen ) ) )
         {
            while( f4->advanceReadBufStatus == AR4SET )
               Sleep( 0 ) ;
            if ( f4->advanceReadBufStatus == AR4FULL ) /* successful read */
            {
               memcpy( (char *)ptr, f4->advanceReadBuf + offset, len ) ;
               return len ;
            }
         }
      }
   #endif

   #ifdef S4MULTI_THREAD
      EnterCriticalSection( &f4->critical4file ) ;
   #endif

   #ifdef S4WRITE_DELAY
      /* make sure that the data to read isn't in memory */
      urc = 0 ;
      if ( l4numNodes( &f4->delayWriteFileList ) != 0 )  /* check for pieces already in memory */
      {
         for ( delayLink = 0 ;; )
         {
            delayLink = (LINK4 *)l4next( &f4->delayWriteFileList, delayLink ) ;
            if ( delayLink == 0 )
               break ;
            writeDelay = (FILE4WRITE_DELAY *)(delayLink - 1 ) ;
            /* now, if the delay piece belongs in the buffer, then read all
               the info before the delay piece, copy the delay piece over,
               and read all the info after the delay piece */
            if ( pos >= ( writeDelay->pos + (long)writeDelay->len ) )  /* outside of block */
               continue ;
            if ( ( pos + (long)len ) <= writeDelay->pos )  /* outside of block */
               continue ;
            beforeLen = writeDelay->pos - pos ;
            if ( beforeLen < 0 )
                beforeLen = 0 ;
            if ( beforeLen == 0 )
            {
               copyPos = pos - writeDelay->pos ;
               copyLen = len ;
            }
            else
            {
               copyPos = 0 ;
               copyLen = len - beforeLen ;
            }
            if ( copyLen > ( writeDelay->len - copyPos ) )
               copyLen = writeDelay->len - copyPos ;
            afterPos = beforeLen + pos + copyLen ;
            afterLen = pos + len - writeDelay->pos - writeDelay->len ;
            if ( beforeLen != 0 )
               urc = file4readLow( f4, pos, ptr, beforeLen ) ;
            if ( urc == (unsigned int)beforeLen )
            {
               memcpy( (char *)ptr + beforeLen, writeDelay->data + copyPos, copyLen ) ;
               urc += copyLen ;
               if ( afterLen > 0 )  /* is negative if read ends within block */
                  urc += file4readLow( f4, afterPos, (char *)ptr + beforeLen + copyLen, afterLen ) ;
            }
            LeaveCriticalSection( &f4->critical4file ) ;
            return urc ;
         }
      }
   #endif

   urc = file4readLowDo( f4, pos, ptr, len ) ;

   #ifdef S4MULTI_THREAD
      LeaveCriticalSection( &f4->critical4file ) ;
   #endif

   #ifdef S4ADVANCE_READ
      file4advanceReadWriteOver( f4, pos, len, ptr, 0 ) ;
   #endif

   return urc ;
}

unsigned S4FUNCTION file4read( FILE4 *f4, const long pos, void *ptr, const unsigned len )
{
   #ifndef S4OFF_OPTIMIZE
      unsigned urc ;
      #ifdef S4OPTIMIZE_STATS
         DATA4 *stat ;
         CODE4 *c4 ;
      #endif
   #endif

   #ifdef E4PARM_HIGH
      if ( f4 == 0 || pos < 0 || ptr == 0  )
      {
         error4( 0, e4parm_null, E90607 ) ;
         return 0 ;
      }
   #endif
   #ifdef E4ANALYZE
      if ( f4->hand < 0 )
      {
         error4( f4->codeBase, e4parm, E90607 ) ;
         return 0 ;
      }
   #endif

   if ( error4code( f4->codeBase ) < 0 )
      return 0 ;

   if ( len == 0 )
      return 0 ;

   #ifndef S4OFF_OPTIMIZE
      if ( f4->doBuffer )
      {
         #ifdef S4OPTIMIZE_STATS
            c4 = f4->codeBase ;
            stat = c4->statusDbf ;
            if ( stat != 0 )  /* track stats */
            {
               if ( f4 != &stat->dataFile->file )  /* don't do for the stat file! */
               {
                  if ( d4appendStart( stat, 0 ) == 0 )
                  {
                     f4assignChar( c4->typeFld, 'H' ) ;  /* high-level */
                     f4assign( c4->fileNameFld, f4->name ) ;
                     f4assignLong( c4->offsetFld, pos ) ;
                     f4assignLong( c4->lengthFld, len ) ;
                     d4append( stat ) ;
                  }
               }
            }
         #endif

         urc = (unsigned)opt4fileRead( f4, pos, ptr, len )  ;
         if ( urc > len )
         {
            file4readError( f4, pos, len, "file4read" ) ;
            return 0 ;
         }
         return urc ;
      }
      else
      {
         if ( f4->fileCreated == 0 )   /* cannot read from non-existant file */
            return 0 ;
   #endif
      return file4readLow( f4, pos, ptr, len ) ;

   #ifndef S4OFF_OPTIMIZE
      }
   #endif
}

int S4FUNCTION file4readAll( FILE4 *f4, const long pos, void *ptr, const unsigned len )
{
   unsigned urc ;

   #ifdef E4PARM_HIGH
      if ( f4 == 0 || pos < 0 || ptr == 0  )
         return error4( 0, e4parm_null, E90608 ) ;
   #endif
   #ifdef E4ANALYZE
      if ( f4->hand < 0 )
         return error4( f4->codeBase, e4parm, E90608 ) ;
   #endif

   if ( error4code( f4->codeBase ) < 0 )
      return -1 ;

   if ( len == 0 )
      return 0 ;

   #ifndef S4OFF_OPTIMIZE
      if ( f4->doBuffer )
      {
         urc = opt4fileRead( f4, pos, ptr, len )  ;
         if ( urc != len )
            return file4readError( f4, pos, len, "file4readAll" ) ;
         return 0 ;
      }
      else
      {
         if ( f4->fileCreated == 0 )   /* cannot read from non-existant file */
            return error4( f4->codeBase, e4opt, E90607 ) ;
   #endif
      urc = file4readLow( f4, pos, ptr, len ) ;
      if ( urc != len )
         return file4readError( f4, pos, len, "file4readAllLow" ) ;
   #ifndef S4OFF_OPTIMIZE
      }
   #endif

   return 0 ;
}

int S4FUNCTION file4readError( FILE4 *f4, const long pos, const unsigned int len, const char *location )
{
   char posBuf[40] ;

   memset( posBuf, 0, sizeof( posBuf ) ) ;
   memset( posBuf, ' ', sizeof( posBuf ) - 1 ) ;

   c4ltoa45( pos, posBuf, 19 ) ;
   c4ltoa45( (long)len, posBuf + 20, 19 ) ;

   return error4describe( f4->codeBase, e4read, E90621, f4->name, posBuf, location ) ;
}

int S4FUNCTION file4replace( FILE4 *keep, FILE4 *from )
{
   FILE4 tmp ;
   int rc ;
   char fromName[LEN4PATH] ;
   #ifndef S4SINGLE
      char *buf ;
      unsigned bufSize ;
      #ifdef S4LOW_MEMORY
         #ifndef S4OFF_OPTIMIZE
            int hasOpt ;
         #endif
      #endif
      long pos, fLen ;
   #endif

   #ifdef E4PARM_LOW
      if ( keep == 0 || from == 0  )
         return error4( 0, e4parm_null, E90609 ) ;
   #endif

   rc = 0 ;
   #ifdef E4ANALYZE
      if ( from->isReadOnly || keep->isReadOnly )
         return error4( from->codeBase, e4parm, E90601 ) ;
   #endif

   #ifndef S4SINGLE
      if ( keep->lowAccessMode == OPEN4DENY_RW )
      {
   #endif
      memcpy( (void *)&tmp, (void *)keep, sizeof ( FILE4 ) ) ;  /* remember settings */

   /* 05/09/96 AS first, must flush the files to disk to avoid delay-writes
      which are based on the FILE4 pointer which is maintained, instead of
      the physical handle, which is not --> or at least unoptimize it */

      file4optimize( from, OPT4OFF, OPT4OTHER ) ;
      file4optimize( keep, OPT4OFF, OPT4OTHER ) ;
      file4flush( from ) ;
      file4flush( keep ) ;

      keep->hand = from->hand ;
      from->hand = tmp.hand ;
      keep->doAllocFree = 0 ;
      strncpy( fromName, from->name, sizeof( fromName ) ) ;
      from->name = keep->name ;
      from->isTemp = 1 ;
      if ( file4close ( from ) )
         return -1 ;
      if ( file4close ( keep ) )
         return -1 ;

      if ( u4rename( fromName, tmp.name ) < 0 )
         return -1 ;

      if ( file4open ( keep, tmp.codeBase, tmp.name, 0 ) )
         return -1 ;
      keep->isTemp = tmp.isTemp ;
      keep->doAllocFree = tmp.doAllocFree ;
      #ifndef S4OFF_OPTIMIZE
         if ( tmp.link.n != 0 )   /* file was optimized... */
            file4optimizeLow( keep, tmp.codeBase->optimize, tmp.type, tmp.expectedReadSize, tmp.ownerPtr ) ;
      #endif
   #ifndef S4SINGLE
      }
      else  /* can't lose the file handle if other user's have the file open, so just do a copy */
      {
         file4lenSet( keep, 0L ) ;

         bufSize = from->codeBase->memSizeBuffer ;

         #ifdef S4LOW_MEMORY
            #ifndef S4OFF_OPTIMIZE
               hasOpt = from->codeBase->hasOpt && from->codeBase->opt.numBuffers ;
               code4optSuspend( from->codeBase ) ;
            #endif
         #endif

         for ( ;; bufSize -= 0x800 )
         {
            if ( bufSize < 0x800 )  /* make one last try */
            {
               bufSize = 100 ;
               buf = (char *)u4allocEr( from->codeBase, (long)bufSize ) ;
               if ( buf == 0 )
                  return -1 ;
            }
            buf = (char *)u4alloc( (long)bufSize ) ;
            if ( buf )
               break ;
         }

         pos = 0 ;
         for( fLen = file4len( from ) ; fLen > 0 ; fLen -= bufSize )
         {
            bufSize = ((long)bufSize > fLen) ?  (unsigned)fLen : bufSize ;
            if ( file4readAll( from, pos, buf, (unsigned)bufSize ) < 0 )
            {
               rc = -1 ;
               break ;
            }
            if ( file4write( keep, pos, buf, (unsigned)bufSize ) < 0 )
            {
               rc = -1 ;
               break ;
            }
            pos += bufSize ;
         }
         from->isTemp = 1 ;
         file4close( from ) ;
         u4free( buf ) ;
         #ifdef S4LOW_MEMORY
            #ifndef S4OFF_OPTIMIZE
               if ( hasOpt )
                  code4optRestart( keep->codeBase ) ;
            #endif
         #endif
      }
   #endif
   return rc ;
}

#ifdef S4NO_ECVT
   #define S4NO_FCVT
#endif

#ifdef S4NO_FCVT

#define MAXIMUM 30
#define PRECISION 17

static char valueStr[32] ;

static double minus[] =
{1e-256,1e-128,1e-64,
 1e-32,1e-16,1e-8,
 1e-4,1e-2,1e-1,1.0} ;

static double plus[] =
{1e+256,1e+128,1e+64,
 1e+32,1e+16,1e+8,
 1e+4,1e+2,1e+1} ;

#ifdef S4NO_ECVT
char *f4ecvt( double value, int numdigits, int *decPtr, int *signPtr )
{
   int dptr, count, j, k ;
   char *vPtr ;

   if ( numdigits < 0 )
      numdigits = 0 ;
   else
      if ( numdigits > MAXIMUM ) numdigits = MAXIMUM ;

   if ( value < 0.0 )
   {
      value = -value ;
      *signPtr = 1 ;
   }
   else
      *signPtr = 0 ;

   if ( value == 0.0 )
   {
      memset( valueStr, '0', numdigits ) ;
      dptr = 0 ;
   }
   else
   {
      dptr = 1 ;
      k = 256 ;
      count = 0 ;
      while ( value < 1.0 )
      {
        while ( value < minus[count+1] )
        {
           value *= plus[count] ;
           dptr -= k ;
        }
        k /= 2 ;
        count++ ;
      }
      k = 256 ;
      count = 0 ;
      while ( value >= 10.0 )
      {
        while ( value >= plus[count] )
        {
           value *= minus[count] ;
           dptr += k ;
        }
        k /= 2 ;
        count++ ;
      }

      for ( vPtr = &valueStr[0]; vPtr <= &valueStr[numdigits]; vPtr++ )
      {
         if ( vPtr >= &valueStr[PRECISION] )  *vPtr = '0' ;
         else
         {
            j = value ;
            *vPtr = j + '0' ;
            value = ( value - j + 1.0e-15 ) * 10.0 ;
         }
      }
      --vPtr ;
      if ( *vPtr >= '5' )
      {
        while (1)
        {
           if ( vPtr == &valueStr[0] )
           {
              dptr++ ;
              valueStr[0] = '1' ;
              break ;
           }
           *vPtr = 0 ;
           --vPtr ;
           if ( *vPtr != '9' )
           {
              (*vPtr)++ ;
              break ;
           }
        }
      }
   }
   *decPtr = dptr ;
   valueStr[numdigits] = 0 ;
   return valueStr ;
}
#endif

char *f4fcvt( double value, int numdigits, int *decPtr, int *signPtr )
{
   int dptr, count, j, k ;
   char *vPtr ;

   if ( numdigits < 0 )
      numdigits = 0 ;
   else
      if ( numdigits > MAXIMUM ) numdigits = MAXIMUM ;

   if ( value < 0.0 )
   {
      value = -value ;
      *signPtr = 1 ;
   }
   else
      *signPtr = 0 ;

   if ( value == 0.0 )
   {
      memset( valueStr, '0', numdigits ) ;
      dptr = 0 ;
   }
   else
   {
      dptr = 1 ;
      k = 256 ;
      count = 0 ;
      while ( value < 1.0 )
      {
        while ( value < minus[count+1] )
        {
           value *= plus[count] ;
           dptr -= k ;
        }
        k /= 2 ;
        count++ ;
      }
      k = 256 ;
      count = 0 ;
      while ( value >= 10.0 )
      {
        while ( value >= plus[count] )
        {
           value *= minus[count] ;
           dptr += k ;
        }
        k /= 2 ;
        count++ ;
      }

      if ( ( numdigits += dptr ) < 0 )
        numdigits = 0 ;
      else
        if ( numdigits > MAXIMUM )  numdigits = MAXIMUM ;

      for ( vPtr = &valueStr[0]; vPtr <= &valueStr[numdigits]; vPtr++ )
      {
         if ( vPtr >= &valueStr[PRECISION] )  *vPtr = '0' ;
         else
         {
            j = value ;
            *vPtr = j + '0' ;
            value = ( value - j + 1.0e-15 ) * 10.0 ;
         }
      }
      --vPtr ;
      if ( *vPtr >= '5' )
      {
        while (1)
        {
           if ( vPtr == &valueStr[0] )
           {
              numdigits++ ;
              dptr++ ;
              valueStr[0] = '1' ;
              break ;
           }
           *vPtr = 0 ;
           --vPtr ;
           if ( *vPtr != '9' )
           {
              (*vPtr)++ ;
              break ;
           }
        }
      }
   }
   *decPtr = dptr ;
   valueStr[numdigits] = 0 ;
   return valueStr ;
}
#endif

/* f4aread.c (c)Copyright Sequiter Software Inc., 1988-1996.  All rights reserved. */

#include "d4all.h"
#ifdef __TURBOC__
   #pragma hdrstop
#endif

#ifdef S4READ_ADVANCE

#define MEM4ADVANCE_START 10
#define MEM4ADVANCE_EXPAND 10

int S4FUNCTION file4advanceRead( FILE4 *f4, const long pos, void *data, const unsigned int len, S4ADVANCE_FUNCTION *completionRoutine, void *completionData )
{
   FILE4ADVANCE_READ *advanceRead ;
   CODE4 *c4 ;

   c4 = f4->codeBase ;

   if ( c4->advanceReadsEnabled == 0 )  /* not enabled */
      return 0 ;

   if ( c4->advanceReadMemory == 0 )
      advanceRead = (FILE4ADVANCE_READ *)mem4createAlloc( c4, &c4->advanceReadMemory, MEM4ADVANCE_START, sizeof( FILE4ADVANCE_READ ), MEM4ADVANCE_EXPAND, 0 ) ;
   else
      advanceRead = (FILE4ADVANCE_READ *)mem4alloc( c4->advanceReadMemory ) ;

   if ( advanceRead == 0 )
      return error4( c4, e4memory, E90624 ) ;

   advanceRead->file = f4 ;
   advanceRead->data = (char *)data ;
   advanceRead->len = len ;
   advanceRead->pos = pos ;
   advanceRead->usageFlag = r4queued ;
   advanceRead->completionRoutine = completionRoutine ;
   advanceRead->completionData = completionData ;

   EnterCriticalSection( &c4->critical4advanceReadList ) ;

   l4add( &c4->advanceReadList, advanceRead ) ;
   l4add( &f4->advanceReadFileList, &advanceRead->fileLink ) ;

   LeaveCriticalSection( &c4->critical4advanceReadList ) ;

   SetEvent( c4->pendingReadEvent ) ;  /* notify the write thread */
   Sleep( 0 ) ;

   return 0 ;
}

/* cancels all advance-reads for the given file */
int file4advanceCancel( FILE4 *f4 )
{
   FILE4ADVANCE_READ *advanceRead ;
   LINK4 *advanceReadLink, *saved ;
   CODE4 *c4 ;

   c4 = f4->codeBase ;

   EnterCriticalSection( &c4->critical4advanceReadList ) ;

   for ( advanceReadLink = (LINK4 *)l4first( &f4->advanceReadFileList ) ;; )
   {
      if ( advanceReadLink == 0 )
         break ;
      advanceRead = (FILE4ADVANCE_READ *)(advanceReadLink - 1) ;
      saved = (LINK4 *)l4next( &f4->advanceReadFileList, advanceReadLink ) ;
      if ( advanceRead->usageFlag == r4queued )  /* do ourselves */
      {
         l4remove( &f4->advanceReadFileList, advanceReadLink ) ;
         l4remove( &c4->advanceReadList, advanceRead ) ;
         advanceRead->status = 0 ;
         advanceRead->usageFlag = r4finished ;
         mem4free( c4->advanceReadMemory, advanceRead ) ;
      }
      advanceReadLink = saved ;
   }

   LeaveCriticalSection( &c4->critical4advanceReadList ) ;

   for ( ;; )
   {
      /* now verify that the checkInUse read gets completed */
      if ( l4numNodes( &f4->advanceReadFileList ) == 0 )
         break ;
      #ifdef E4ANALYZE
         if ( l4numNodes( &f4->advanceReadFileList ) > 1 )   /* in theory impossible, it means delay-write has 2 files writing at same time */
            return error4( c4, e4struct, E90624 ) ;
      #endif
      SetEvent( c4->pendingReadEvent ) ;  /* notify the write thread */
      Sleep( 0 ) ;   /* give up our time slice to get the delay-write going */
   }

   #ifndef S4OFF_OPTIMIZE
      if ( c4->opt.advanceReadFile == f4 )
      {
         c4->opt.advanceLargeBufferAvail = AR4EMPTY ;
         c4->opt.advanceReadFile = 0 ;
      }
   #endif

   return 0 ;
}

#ifdef S4USE_INT_DELAY
   int file4advanceReadMain( void *data )
#else
   void file4advanceReadMain( void *data )
#endif
{
   CODE4 *c4 ;
   FILE4ADVANCE_READ *advanceRead ;

   c4 = (CODE4 *)data ;
   c4->advanceReadsEnabled = 1 ;

   for ( ;; )
   {
      if ( l4numNodes( &c4->advanceReadList ) == 0 )
      {
         if ( c4->uninitializeAdvanceRead == 1 )   /* shutdown */
         {
            SetEvent( c4->initUndoAdvanceRead ) ;
            #ifdef S4USE_INT_DELAY
               return 0 ;
            #else
               return ;
            #endif
         }
         else
         {
            WaitForSingleObject( c4->pendingReadEvent, INFINITE ) ;
            ResetEvent( c4->pendingReadEvent ) ;
         }
      }
      else  /* perform a read on the first available block */
      {
         EnterCriticalSection( &c4->critical4advanceReadList ) ;

         advanceRead = (FILE4ADVANCE_READ *)l4first( &c4->advanceReadList ) ;
         if ( advanceRead == 0 )   /* maybe got removed by main thread, so none to read... */
         {
            LeaveCriticalSection( &c4->critical4advanceReadList ) ;
            Sleep( 0 ) ;
            continue ;
         }
         advanceRead->usageFlag = r4inUse ;
         LeaveCriticalSection( &c4->critical4advanceReadList ) ;

         advanceRead->status = file4readLowDo( advanceRead->file, advanceRead->pos, advanceRead->data, advanceRead->len ) ;
         advanceRead->usageFlag = r4finished ;  /* outside of critical section, to allow a wait for completion while keeping the critical section */
         EnterCriticalSection( &c4->critical4advanceReadList ) ;
         l4remove( &c4->advanceReadList, advanceRead ) ;
         l4remove( &advanceRead->file->advanceReadFileList, &advanceRead->fileLink ) ;

         /* the completion routine may get reset by another routine which
            needed to call it */
         if ( advanceRead->completionRoutine != 0 )
            advanceRead->completionRoutine( advanceRead ) ;

         /* for reading, the critical section includes the completion routine
            because it checks the status flag before modifying it */
         LeaveCriticalSection( &c4->critical4advanceReadList ) ;
         mem4free( c4->advanceReadMemory, advanceRead ) ;
      }
   }
}

/* this function takes a write request, and ensures that any advance-read
   information which overlaps the write request is updated to reflect the
   changes */
/* if doCancel is true, it means that advance-reads which overlap the positions
   partially will be canceled since they are out of date (i.e. based on a write
   overlap request, not a re-request which is also serviced here) */
void file4advanceReadWriteOver( FILE4 *f4, const long pos, const unsigned len, const void *data, const int doCancel )
{
   FILE4ADVANCE_READ *advanceRead ;
   LINK4 *advanceLink ;
   CODE4 *c4 ;
   #ifndef S4OFF_OPTIMIZE
      OPT4 *opt ;
   #endif

   c4 = f4->codeBase ;

   #ifndef S4OFF_OPTIMIZE
      if ( f4->fileCreated == 0 )  /* ensure file created, else no critical section, can't be advance-reads */
         return ;
   #endif

   /* first lock out operations on the advance-read list */
   EnterCriticalSection( &c4->critical4advanceReadList ) ;

   /* first take care of the outstanding advance-reads */
   if ( l4numNodes( &f4->advanceReadFileList ) != 0 )
   {
      for ( advanceLink = (LINK4 *)l4first( &f4->advanceReadFileList ) ;; )
      {
         if ( advanceLink == 0 )
            break ;
         advanceRead = (FILE4ADVANCE_READ *)(advanceLink - 1 ) ;
         advanceLink = (LINK4 *)l4next( &f4->advanceReadFileList, advanceLink ) ;

         if ( pos >= ( advanceRead->pos + (long)advanceRead->len ) )  /* outside of block */
            continue ;
         if ( ( pos + (long)len ) <= advanceRead->pos )  /* outside of block */
            continue ;

         /* if the status is in-use, then just wait for it to finish */
         while ( advanceRead->usageFlag == r4inUse )
            Sleep( 0 ) ;

         /* in this case, the piece is finished, so take care of the completion
            routine ourselves */
         /* once that is finished, it is assumed that the completion routine
            will make it noticed in the handling code below for after-read
            advance-read data */
         if ( advanceRead->usageFlag == r4finished )
         {
            if ( advanceRead->completionRoutine != 0 )
               advanceRead->completionRoutine( advanceRead ) ;
            advanceRead->completionRoutine = 0 ;
            continue ;
         }

         /* now, if the advance piece belongs in the buffer, then read all
            the info before the delay piece, copy the delay piece over,
            and read all the info after the delay piece */

         /* if the entire block is within the range, then can just copy to
            it, otherwise cancel it */
         if ( ( advanceRead->pos >= pos ) && ( pos + len >= advanceRead->pos + advanceRead->len ) ) /* copy it */
         {
            advanceRead->status = 0 ;
            memcpy( advanceRead->data, (const char *)data + (advanceRead->pos - pos ), advanceRead->len ) ;
            advanceRead->usageFlag = r4finished ;  /* outside of critical section, to allow a wait for completion while keeping the critical section */
         }
         else
         {
            if ( doCancel )
               advanceRead->usageFlag = r4canceled ;  /* outside of critical section, to allow a wait for completion while keeping the critical section */
            else
               continue ;
         }

         l4remove( &f4->codeBase->advanceReadList, advanceRead ) ;
         l4remove( &f4->advanceReadFileList, &advanceRead->fileLink ) ;
         if ( advanceRead->completionRoutine != 0 )
            advanceRead->completionRoutine( advanceRead ) ;
         mem4free( f4->codeBase->advanceReadMemory, advanceRead ) ;
      }
   }

   /* now take care of the special-advance-read buffer */
   /* if it is not full, then either it is empty or else we serviced it
      already in the advance-read list */
   if ( f4->advanceReadBufStatus == AR4FULL )
   {
      if ( pos < ( f4->advanceReadBufPos + (long)f4->advanceReadBufLen ) )  /* outside of block */
         if ( ( pos + (long)len ) > f4->advanceReadBufPos )  /* outside of block */
         {
            if ( ( f4->advanceReadBufPos >= pos ) && ( pos + len >= f4->advanceReadBufPos + f4->advanceReadBufLen ) ) /* copy it */
               memcpy( f4->advanceReadBuf, (const char *)data + (f4->advanceReadBufPos - pos ), f4->advanceReadBufLen ) ;
            else
               if ( doCancel )
                  f4->advanceReadBufStatus = AR4EMPTY ;
         }
   }

   /* now take care of the optimized advance-read buffer */
   #ifndef S4OFF_OPTIMIZE
      opt = &c4->opt ;

      /* if it is not full, then either it is empty or else we serviced it
         already in the advance-read list */
      if ( opt->advanceLargeBufferAvail == AR4FULL )
      {
         if ( pos < ( opt->advanceLargePos + (long)opt->advanceLargeLen ) )  /* outside of block */
            if ( ( pos + (long)len ) > opt->advanceLargePos )  /* outside of block */
            {
               if ( ( opt->advanceLargePos >= pos ) && ( pos + len >= opt->advanceLargePos + opt->advanceLargeLen ) ) /* copy it */
                  memcpy( opt->advanceLargeBuffer, (const char *)data + (opt->advanceLargePos - pos ), opt->advanceLargeLen ) ;
               else
                  if ( doCancel )
                     opt->advanceLargeBufferAvail = AR4EMPTY ;
            }
      }
   #endif

   LeaveCriticalSection( &c4->critical4advanceReadList ) ;
}

void S4CALL file4advanceReadBufCompletionRoutine( void *advance )
{
   FILE4ADVANCE_READ *advanceRead ;
   int *arFlag ;

   /* to verify safety, use critical section on the arFlag (from CODE4) */

   advanceRead = (FILE4ADVANCE_READ *)advance ;
   arFlag = (int *)(advanceRead->completionData) ;

   if ( advanceRead->usageFlag == r4canceled )
      *arFlag = AR4EMPTY ;
   else
      if ( *arFlag == AR4SET )  /* if reset to empty it means the read was cancelled by the main thread, so leave as empty */
      {
         /* verify that all was read */
         if ( advanceRead->file->advanceReadBufLen == advanceRead->status )
            *arFlag = AR4FULL ;
         else
            *arFlag = AR4EMPTY ;
      }
}

void opt4advanceReadBuf( FILE4 *f4, long pos, unsigned len )
{
   CODE4 *c4 ;
   LINK4 *advanceLink ;
   FILE4ADVANCE_READ *advanceRead ;
   #ifndef S4OFF_OPTIMIZE
      long hashVal, adjustedPos ;
      unsigned int extraRead ;
      OPT4 *opt ;
   #endif

   c4 = f4->codeBase ;

   /* if optimization is enabled, then first ensure that the block is not
      already in memory */
   #ifndef S4OFF_OPTIMIZE
      opt = &f4->codeBase->opt ;
      if ( len > opt->blockSize )  /* don't do multi-block reads */
         return ;

      extraRead = (unsigned) ((unsigned long)((unsigned long)pos << opt->numShift ) >> opt->numShift ) ;
      adjustedPos = pos - extraRead ;
      hashVal = opt4fileHash( opt, f4, (unsigned long)adjustedPos ) ;
      if ( opt4fileReturnBlock( f4, pos, hashVal ) != 0 )
         return ;
   #endif

   if ( f4->advanceReadBuf == 0 )
   {
      f4->advanceReadBuf = (char *)u4alloc( len ) ;
      if ( f4->advanceReadBuf == 0 )
         return ;
      f4->advanceReadBufStatus = AR4EMPTY ;
      f4->advanceReadBufLen = len ;
   }
   else
   {
      if ( len > f4->advanceReadBufLen )   /* too large, don't bother */
         return ;
      if ( f4->advanceReadBufStatus == AR4SET || f4->advanceReadBufStatus == AR4FULL )
         if ( f4->advanceReadBufPos == pos )  /* already advanced on this read */
            return ;
   }

   #ifndef S4OFF_OPTIMIZE
      if ( f4->advanceReadBufStatus == AR4FULL )  /* finished read, so place into optimization */
      {
         /* first ensure that it is not already bufferred */
         extraRead = (unsigned) ((unsigned long)((unsigned long)f4->advanceReadBufPos << opt->numShift ) >> opt->numShift ) ;
         adjustedPos = f4->advanceReadBufPos - extraRead ;
         hashVal = opt4fileHash( opt, f4, (unsigned long)adjustedPos ) ;
         if ( opt4fileReturnBlock( f4, adjustedPos, hashVal ) == 0 )
         {
            /* the opt4fileWrite function can be used to place data into memory
               without marking as changed based on last paramater... */
            opt4fileWrite( f4, f4->advanceReadBufPos, f4->advanceReadBufLen, f4->advanceReadBuf, 0 ) ;
         }
         f4->advanceReadBufStatus = AR4EMPTY ;
      }
   #endif

   EnterCriticalSection( &c4->critical4advanceReadList ) ;
   if ( f4->advanceReadBufStatus == AR4SET )  /* must remove from list */
   {
      for ( advanceLink = (LINK4 *)l4first( &f4->advanceReadFileList ) ;; )
      {
         if ( advanceLink == 0 )
            break ;
         advanceRead = (FILE4ADVANCE_READ *)(advanceLink - 1 ) ;
         advanceLink = (LINK4 *)l4next( &f4->advanceReadFileList, advanceLink ) ;

         if ( advanceRead->completionRoutine == file4advanceReadBufCompletionRoutine )  /* spec buf */
         {
            if ( advanceRead->usageFlag != r4queued )  /* must just wait */
            {
               LeaveCriticalSection( &c4->critical4advanceReadList ) ;
               while ( f4->advanceReadBufStatus == AR4SET )
                  Sleep( 0 ) ;
               EnterCriticalSection( &c4->critical4advanceReadList ) ;
               break ;
            }

            /* is queued, so can just remove */
            advanceRead->status = 0 ;
            advanceRead->usageFlag = r4finished ;
            l4remove( &f4->codeBase->advanceReadList, advanceRead ) ;
            l4remove( &f4->advanceReadFileList, &advanceRead->fileLink ) ;
            mem4free( f4->codeBase->advanceReadMemory, advanceRead ) ;
         }
      }
   }

   #ifndef S4OFF_OPTIMIZE
      /* in optimized case, make sure the read is done on a block boundary */
      extraRead = (unsigned) ((unsigned long)((unsigned long)pos << opt->numShift ) >> opt->numShift ) ;
      adjustedPos = pos - extraRead ;
      len = f4->advanceReadBufLen ;
      f4->advanceReadBufStatus = AR4SET ;
      f4->advanceReadBufPos = adjustedPos ;

      LeaveCriticalSection( &c4->critical4advanceReadList ) ;

      file4advanceRead( f4, pos, f4->advanceReadBuf, len, file4advanceReadBufCompletionRoutine, &f4->advanceReadBufStatus ) ;
   #else
      f4->advanceReadBufStatus = AR4SET ;
      f4->advanceReadBufPos = pos ;

      LeaveCriticalSection( &c4->critical4advanceReadList ) ;

      file4advanceRead( f4, pos, f4->advanceReadBuf, len, file4advanceReadBufCompletionRoutine, &f4->advanceReadBufStatus ) ;
   #endif
}

#endif /* S4READ_ADVANCE */