home *** CD-ROM | disk | FTP | other *** search
/ Fish 'n' More 2 / fishmore-publicdomainlibraryvol.ii1991xetec.iso / fish / keyboard / keymacro_398 / mrarpfile.c < prev    next >
C/C++ Source or Header  |  1990-11-01  |  17KB  |  691 lines
  1. /*  File support routines to complement ARP.
  2.  *  Author: Mark R. Rinfret
  3.  *          Usenet:     mrr@amanpt1.Newport.RI.US
  4.  *          BIX:        markr
  5.  *          CIS:        72017, 136 (good luck!)
  6.  *
  7.  *          348 Indian Avenue
  8.  *          Portsmouth, RI 02871
  9.  *          401-846-7639 (home)
  10.  *          401-849-9390 (work)       
  11.  *
  12.  *  This package was written primarily because of _one_ missing element
  13.  *  in ARP: FGets. ARGH! ARPFFFT! It extends ARP by adding buffering to
  14.  *  the basic file type (FileHandle) and defining a new type, named
  15.  *  ARPFileHandle (hope this is OK with the ARP guys). Also, I've used the
  16.  *  convention of embedding ARP (vs. Arp in MicroSmith's stuff) in all type
  17.  *  and function names to (hopefully) avoid naming collisions.
  18.  *
  19.  *  This package (as far as I am concerned) is public domain. Use it any
  20.  *  way you like. Some comments on the "MR" prefix: it isn't short for
  21.  *  "Mister", it comprises the initials of my first and last names;
  22.  *  I use it primarily to avoid name collisions with stuff by other
  23.  *  authors. If any other authors whose initials are "MR" start doing
  24.  *  this, we'll probably have to appeal to Electronic Arts to dole out
  25.  *  "author codes" along the lines of those issued for IFF :-). I hereby
  26.  *  stake a claim to 'MRR_'.
  27.  *
  28.  *  A word of warning:
  29.  *
  30.  *  DO NOT INTERMIX STANDARD AMIGADOS FILE SUPPORT CALLS WITH CALLS TO
  31.  *  THIS PACKAGE ON FILES USING THIS FILE METHOD!
  32.  *
  33.  *  Obviously, the system doesn't know about the buffering added here
  34.  *  and will cause unpredictable results (unless, of course, you
  35.  *  take care to maintain the ARPFileHandle information).
  36.  */
  37.  
  38. /*  Olsen: In order to adapt the code to ANSI some declarations and
  39.  *         function calls were rearranged. I also fixed two parts of
  40.  *         code which appeared not to work correctly.
  41.  */
  42.  
  43.     /* Skip prototypes. */
  44.  
  45. #define _MRARPFILE_PRIVATE 1
  46.  
  47. #include "MRARPFile.h"
  48.  
  49.     /* System includes. */
  50.  
  51. #include <exec/memory.h>
  52. #include <clib/macros.h>
  53. #include <functions.h>
  54.  
  55. /* StoreTracker is my attempt to fix an apparent bug in ARP 1.3. I have
  56.  * found that the LastTracker kludge (via IoErr()) doesn't work reliably.
  57.  * StoreTracker simply stuffs A1 into D0 and returns . It *MUST* be
  58.  * called immediately after any ARP call which allocates a tracker to
  59.  * assure that the value is correct.
  60.  */
  61.  
  62. #asm
  63.     public    _StoreTracker
  64.  
  65. _StoreTracker:
  66.     move.l    a1,d0
  67.     rts
  68. #endasm
  69.  
  70. struct DefaultTracker *    StoreTracker(VOID);
  71.  
  72. char *            FGetsARP(char *s,LONG length,ARPFileHandle *file);
  73. static LONG        FillARPFileBuffer(ARPFileHandle *file);
  74. static LONG        FlushARPFileBuffer(ARPFileHandle *file);
  75. LONG            FPutsARP(char *s,ARPFileHandle *file);
  76. LONG            ReadARPFile(ARPFileHandle *file,UBYTE *buffer,LONG length);
  77. LONG            CloseARPFile(ARPFileHandle *file);
  78. ARPFileHandle *        OpenARPFile(char *name,LONG accessMode,LONG bytes);
  79. LONG            SeekARPFile(ARPFileHandle *file,LONG position,LONG mode);
  80. LONG            WriteARPFile(ARPFileHandle *file,UBYTE *buffer,LONG length);
  81.  
  82. /*  FUNCTION
  83.  *      FGetsARP - get string from a buffered ARP file.
  84.  *
  85.  *  SYNOPSIS
  86.  *      char *FGetsARP(s, length, file)
  87.  *                     UBYTE         *s;
  88.  *                     LONG           length;
  89.  *                     ARPFileHandle *file;
  90.  *
  91.  *  DESCRIPTION
  92.  *      FGetsARP models the behavior of the "standard" fgets, except that
  93.  *      it is used with a buffered ARP file. The data is read from <file>
  94.  *      and transfered to string <s>. Up to length-1 characters will be
  95.  *      read. Reading is also terminated upon receipt of a newline
  96.  *      or detection of end-of-file. 
  97.  *
  98.  *      If the <file> was opened without a buffer, one of MaxInputBuf
  99.  *      bytes will be allocated.
  100.  *
  101.  *      If end of file or an error is detected, the return value will be
  102.  *      NULL. Otherwise, the return value will be <s>. <s> will be 
  103.  *      terminated with a null byte.
  104.  */
  105.  
  106. char *
  107. FGetsARP(char *s,LONG length,ARPFileHandle *file)
  108. {
  109.     struct DefaultTracker    *tracker;
  110.     LONG             bytesNeeded = length - 1;
  111.     LONG             bytesRead = 0;
  112.     char             c;
  113.     char            *s1 = s;
  114.  
  115.     /* Set string initially empty to protect user from failure to check
  116.      * return value.
  117.      */
  118.  
  119.     *s1 = '\0';    
  120.  
  121.     if(file -> mode != MODE_OLDFILE)
  122.         file -> lastError = ERROR_READ_PROTECTED;
  123.          
  124.     if(file -> lastError)
  125.     {
  126. dangit:        return(NULL);
  127.     }
  128.  
  129.         /* Ohmigosh! No buffer? */
  130.  
  131.     if(!file -> buf)
  132.     {
  133.         file -> buf = ArpAllocMem(MaxInputBuf, MEMF_CLEAR | MEMF_PUBLIC);
  134.  
  135.         tracker = StoreTracker();
  136.  
  137.         if(!file -> buf)
  138.         {
  139.             file -> lastError = ERROR_NO_FREE_STORE;
  140.             goto dangit;
  141.         }
  142.  
  143.         file -> bufSize        = MaxInputBuf;    /* bufLength, bufPos are zero. */
  144.         file -> bufTracker    = tracker;
  145.     }
  146.  
  147.     while(bytesNeeded)
  148.     {
  149.         if(file -> bufPos >= file -> bufLength)
  150.         {
  151.             if(FillARPFileBuffer(file) < 0)
  152.                 goto dangit;
  153.  
  154.             if(!file -> bufLength)
  155.                 break;
  156.         }
  157.  
  158.         c = file -> buf[file -> bufPos++];
  159.  
  160.         ++bytesRead;
  161.  
  162.         if(c == '\n')
  163.             break;
  164.  
  165.         *s1++ = c;
  166.  
  167.         --bytesNeeded; 
  168.     }
  169.  
  170.     *s1 = '\0';
  171.  
  172.     return(bytesRead ? s : NULL);
  173. }
  174.  
  175. /*  FUNCTION
  176.  *      FillARPFileBuffer - read data into ARPFile buffer.
  177.  *
  178.  *  SYNOPSIS
  179.  *      static LONG FillARPFileBuffer(file)
  180.  *                                    ARPFileHandle *file;
  181.  *
  182.  *  DESCRIPTION
  183.  *      Attempt to fill the buffer associated with <file> by reading
  184.  *      data from the associated external file. The return value will
  185.  *      be one of the following:
  186.  *          >0  => number of bytes read
  187.  *           0  => end of file
  188.  *          -1  => a Bad Thing happened (error code in file -> lastError) 
  189.  *
  190.  *      Note: this is a local routine and is thus declared as "static".
  191.  *      Please inform the author if this is a hardship.
  192.  */
  193.  
  194. static LONG
  195. FillARPFileBuffer(ARPFileHandle *file)
  196. {
  197.     /* Remember where we were. The user might want to try error
  198.      * recovery. Of course, this probably isn't enough info, but
  199.      * it's a start.
  200.      */
  201.  
  202.     file -> lastPosition    = Seek(file -> fh, 0L, OFFSET_CURRENT);
  203.     file -> bufPos        = 0;
  204.     file -> bufLength    = Read(file -> fh, file -> buf, file -> bufSize);
  205.  
  206.         /* We got trubble! */
  207.  
  208.     if(file -> bufLength == -1)
  209.         file -> lastError = IoErr();
  210.     else
  211.     {
  212.         if(!file -> bufLength)
  213.             file -> endOfFile = TRUE;
  214.     }
  215.  
  216.     return(file -> bufLength);
  217. } 
  218.  
  219. /*  FUNCTION
  220.  *      FlushARPFileBuffer - write file buffer contents to disk.
  221.  *
  222.  *  SYNOPSIS
  223.  *      static LONG FlushARPFileBuffer(file)
  224.  *                                     ARPFileHandle *file;
  225.  *  DESCRIPTION
  226.  *      FlushARPFileBuffer writes the contents of <file>'s buffer
  227.  *      (if any) to disk and resets the buffer information. The
  228.  *      return value may be any of:
  229.  *
  230.  *          >0 =>   number of bytes written
  231.  *           0 =>   nothing in buffer
  232.  *          <0 =>   negated error code
  233.  *
  234.  *      Note: it is assumed that this function will only be used locally
  235.  *      and therefore need not be public. If you disagree, please contact
  236.  *      the author.
  237.  */
  238.  
  239. static LONG
  240. FlushARPFileBuffer(ARPFileHandle *file)
  241. {
  242.     LONG bytesWritten = 0;
  243.  
  244.     /* This operation is only allowed for output files. */
  245.  
  246.     if(file -> mode != MODE_NEWFILE)
  247.     {
  248.         file -> lastError = ERROR_WRITE_PROTECTED;
  249.  
  250. badstuff:    return(-file -> lastError);
  251.     }
  252.  
  253.     if(file -> lastError)
  254.         goto badstuff; /* Residual error? */
  255.  
  256.     if(file -> bufLength)
  257.     {
  258.         file -> lastPosition = Seek(file -> fh, 0L, OFFSET_CURRENT);
  259.  
  260.         bytesWritten = Write(file -> fh, file -> buf, file -> bufLength);
  261.  
  262.         if(bytesWritten != file -> bufLength)
  263.         {
  264.             file -> lastError = IoErr();
  265.             goto badstuff;
  266.         }
  267.         else
  268.         {
  269.             file -> bufLength    = 0;
  270.             file -> bufPos        = 0;
  271.         }
  272.     }
  273.  
  274.     return(bytesWritten);
  275. }
  276.  
  277. /*  FUNCTION
  278.  *      FPutsARP - write a string to a buffered ARP file.
  279.  *
  280.  *  SYNOPSIS
  281.  *      LONG FPutsARP(s, file)
  282.  *                    char          *s;
  283.  *                    ARPFileHandle *file;
  284.  *
  285.  *  DESCRIPTION
  286.  *      FPutsARP writes the contents of string <s> to the specified <file>.
  287.  *      If successful, it returns 0. On failure, it returns the negated
  288.  *      system error code. 
  289.  */
  290.  
  291. LONG
  292. FPutsARP(char *s,ARPFileHandle *file)
  293. {
  294.     LONG     bytesLeft, bytesUsed;
  295.     char    *s1 = s;
  296.  
  297.     if(file -> mode != MODE_NEWFILE) 
  298.         file -> lastError = ERROR_WRITE_PROTECTED;
  299.  
  300.     if(file -> lastError)
  301.     {
  302. shucks:        return(-file -> lastError);
  303.     }
  304.  
  305.     bytesLeft = strlen(s);
  306.  
  307.     /* Attempt to be smart about this transfer. Copy the string to the
  308.      * buffer in chunks. There is a possibility that the string is bigger
  309.      * than the size of the buffer.
  310.      */
  311.  
  312.     while(bytesLeft)
  313.     {
  314.         if(file -> bufPos >= file -> bufSize)
  315.         {
  316.             if(FlushARPFileBuffer(file) <= 0)
  317.                 goto shucks;
  318.         }
  319.  
  320.         bytesUsed = MIN(file -> bufSize - file -> bufPos, bytesLeft);
  321.  
  322.         CopyMem(s1, &file -> buf[file -> bufPos], bytesUsed);
  323.  
  324.         s1 += bytesUsed;
  325.  
  326.         file -> bufLength = (file -> bufPos += bytesUsed);
  327.  
  328.         bytesLeft -= bytesUsed;
  329.     }
  330.  
  331.     return(0);
  332. }
  333.  
  334. /*  FUNCTION
  335.  *      ReadARPFile - read from a buffered ARP file.
  336.  *
  337.  *  SYNOPSIS
  338.  *      LONG ReadARPFile(file, buffer, length)
  339.  *                       ARPFile *file;
  340.  *                       UBYTE   *buffer;
  341.  *                       LONG    length;
  342.  *
  343.  *  DESCRIPTION
  344.  *      ReadARPFile attempts to read <length> bytes from <file>, transferring
  345.  *      the data to <buffer>. 
  346.  *
  347.  *      The return value may be any of the following:
  348.  *
  349.  *          >0      number of bytes transferred
  350.  *          0       end of file
  351.  *         <0       negated error code
  352.  *
  353.  *      Note: if the lastError field of the <file> descriptor contains a
  354.  *            non-zero value, its negated value will be returned and no
  355.  *            attempt will be made to read the file. If you attempt error
  356.  *            recovery, you must clear this field to zero.
  357.  */
  358.  
  359. LONG
  360. ReadARPFile(ARPFileHandle *file,UBYTE *buffer,LONG length)
  361. {
  362.     LONG    bytesLeft;
  363.     LONG    bytesRead = 0;
  364.     LONG    needBytes = length;
  365.     LONG    pos = 0;
  366.     LONG    usedBytes = 0;
  367.  
  368.         /* Prevent read if this file opened for writing. */
  369.  
  370.     if(file -> mode != MODE_OLDFILE)
  371.         file -> lastError = ERROR_READ_PROTECTED;
  372.  
  373.         /* Have residual error? */
  374.  
  375.     if(file -> lastError)
  376.     {
  377. boofar:        return(-file -> lastError);
  378.     }
  379.  
  380.         /* No buffer? */
  381.  
  382.     if(!file -> buf )
  383.     {
  384.         bytesRead = Read(file -> fh, buffer, length);
  385.  
  386.         if(bytesRead == -1)
  387.         {
  388.             file -> lastError = IoErr();
  389.             goto boofar;
  390.         }
  391.     }
  392.     else
  393.     {
  394.         while(needBytes)
  395.         {
  396.             if(file -> bufLength - file -> bufPos <= 0)
  397.             {
  398.                 if(FillARPFileBuffer(file) == -1)
  399.                     goto boofar;
  400.  
  401.                 if(!file -> bufLength)
  402.                     break;
  403.             }
  404.  
  405.             bytesLeft = file -> bufLength - file -> bufPos;
  406.  
  407.             usedBytes = MIN(bytesLeft, length);
  408.  
  409.             CopyMem(&file -> buf[file -> bufPos], &buffer[pos], usedBytes);
  410.  
  411.             file -> bufPos += usedBytes;
  412.  
  413.             pos += usedBytes;
  414.  
  415.             bytesRead += usedBytes;
  416.             needBytes -= usedBytes;
  417.         }
  418.     }
  419.  
  420.     return(bytesRead);
  421. }
  422.  
  423. /*  FUNCTION
  424.  *      CloseARPFile - close buffered ARP file.
  425.  *
  426.  *  SYNOPSIS
  427.  *      LONG CloseARPFile(file)
  428.  *                        ARPFileHandle *file;
  429.  *
  430.  *  DESCRIPTION
  431.  *      CloseARPFile closes the file described by <file> which MUST have
  432.  *      been opened by OpenARPFile. It releases all tracked items
  433.  *      associated with <file>, as well.
  434.  *
  435.  *      The return value is only meaningful for output files. If, upon
  436.  *      flushing the buffer, a write error is detected, a system error
  437.  *      code (ERROR_DISK_FULL, etc.) will be returned.
  438.  */
  439.  
  440. LONG
  441. CloseARPFile(ARPFileHandle *file)
  442. {
  443.     LONG result = 0;
  444.  
  445.         /* Just in case... */
  446.  
  447.     if(file)
  448.     {
  449.         if(file -> fileTracker)
  450.         {
  451.             /* Any left-over stuff in the buffer? If so, we must flush
  452.              * it to disk. However, if an error was detected in the
  453.              * previous operation, punt. 
  454.              */
  455.  
  456.             if((file -> mode == MODE_NEWFILE) && ! file -> lastError && file -> bufLength)
  457.             {
  458.                 if(Write(file -> fh, file -> buf, file -> bufLength) != file -> bufLength)
  459.                     result = IoErr();
  460.             }
  461.  
  462.             FreeTrackedItem(file -> fileTracker);
  463.         }
  464.  
  465.         if(file -> bufTracker)
  466.             FreeTrackedItem(file -> bufTracker);
  467.  
  468.         FreeTrackedItem(file -> myTracker);
  469.     }
  470.  
  471.     return(result);
  472. }
  473.  
  474. /*  FUNCTION
  475.  *      OpenARPFile - open a buffered ARP file
  476.  *
  477.  *  SYNOPSIS
  478.  *      struct MRARPFile *OpenARPFile(name, accessMode, bytes)
  479.  *                                    char *name;
  480.  *                                    LONG accessMode, bytes;
  481.  *
  482.  *  DESCRIPTION
  483.  *      OpenARPFile opens the file <name>, with the given <accessMode>
  484.  *      (MODE_OLDFILE, MODE_NEWFILE only!) for buffered access. The
  485.  *      size of the local buffer is specified by <bytes>.
  486.  *
  487.  *      A zero value for <bytes> is OK and is sometimes appropriate, as
  488.  *      when performing file copy operations, etc. However, if a file
  489.  *      opened with a zero length buffer is then passed to the
  490.  *      FGetsARP function, "spontaneous buffer allocation" will occur.
  491.  *      No biggy, really, just something you should know. The ARP constant,
  492.  *      MaxInputBuf will be used for the buffer size, in this case.
  493.  *
  494.  *      If successful, a pointer to the file tracking structure is 
  495.  *      returned. Otherwise, the return value will be NULL.
  496.  *
  497.  *      OpenARPFile uses full resource tracking for all information
  498.  *      associated with the file.
  499.  *
  500.  */
  501.  
  502. ARPFileHandle *
  503. OpenARPFile(char *name,LONG accessMode,LONG bytes)
  504. {
  505.     struct DefaultTracker    *lastTracker;
  506.     ARPFileHandle        *theFile = NULL;
  507.     BPTR             fh;
  508.  
  509.         /* This package does not support READ/WRITE access! */
  510.  
  511.     if((accessMode != MODE_OLDFILE) && (accessMode != MODE_NEWFILE))
  512.         return(NULL);
  513.  
  514.     /* 
  515.      * Note: I'm using ArpAllocMem vs. ArpAlloc here because it appears
  516.      * that ArpAlloc gives me a bad tracker pointer (?).
  517.      */
  518.  
  519.     theFile = ArpAllocMem((LONG) sizeof(ARPFileHandle), MEMF_PUBLIC | MEMF_CLEAR);
  520.  
  521.     lastTracker = StoreTracker();
  522.  
  523.     if(theFile)
  524.     {
  525.         theFile -> myTracker = lastTracker;
  526.         theFile -> mode = accessMode;
  527.  
  528.         fh = ArpOpen(name, accessMode);
  529.  
  530.         lastTracker = StoreTracker();
  531.  
  532.         if(!fh)
  533.         {
  534. fungu:            CloseARPFile(theFile);    /* Don't worry - it's "smart". */
  535.             theFile = NULL;
  536.  
  537.             return(NULL);        /* This one was missing -Olsen */
  538.         }
  539.  
  540.         theFile -> fileTracker    = lastTracker;
  541.         theFile -> fh        = fh;
  542.  
  543.             /* Does user want a buffer? */
  544.  
  545.         if(bytes)
  546.         {
  547.             theFile -> buf = ArpAllocMem(bytes, MEMF_PUBLIC | MEMF_CLEAR);
  548.  
  549.             lastTracker = StoreTracker();
  550.  
  551.             if(!theFile -> buf)
  552.                 goto fungu;
  553.  
  554.             theFile -> bufSize    = bytes;
  555.             theFile -> bufTracker    = lastTracker;
  556.         }
  557.     }
  558.  
  559.     return(theFile);
  560. }
  561.  
  562. /*  FUNCTION
  563.  *      SeekARPFile - move to new logical position in file.
  564.  *
  565.  *  SYNOPSIS
  566.  *      LONG SeekARPFile(file, position, mode)
  567.  *                       ARPFileHandle *file;
  568.  *                       LONG           position;
  569.  *                       LONG           mode;
  570.  *
  571.  *  DESCRIPTION
  572.  *      SeekARPFile attempts to position the <file> to a new logical
  573.  *      position or report it's current position. The <position>
  574.  *      parameter represets a signed offset. The <mode> parameter may
  575.  *      be one of:
  576.  *
  577.  *          OFFSET_BEGINNING (-1) => from beginning of file
  578.  *          OFFSET_CURRENT (0)    => from current position
  579.  *          OFFSET_END (-1)       => from end of file
  580.  *
  581.  *      On output files, the current buffer contents, if any, are
  582.  *      written to disk.
  583.  *
  584.  *      The return value will either be a positive displacement >=0) or
  585.  *      a negated system error code.
  586.  */
  587.  
  588. LONG
  589. SeekARPFile(ARPFileHandle *file,LONG position,LONG mode)
  590. {
  591.     LONG newPosition;
  592.  
  593.     if(file -> mode == MODE_NEWFILE && file -> bufLength)
  594.     {
  595.         if(FlushARPFileBuffer(file) < 0)
  596.         {
  597. farboo:            return(-file -> lastError);
  598.         }
  599.     }
  600.  
  601.         /* Remember our last position. Seek(file,...) fixed
  602.          * to use Seek(file -> fh,...) -Olsen.
  603.          */
  604.  
  605.     file -> lastPosition = Seek(file -> fh, 0L, OFFSET_CURRENT);
  606.  
  607.     if((newPosition = Seek(file -> fh, position, mode)) == -1)
  608.     {
  609.         file -> lastError = IoErr();
  610.         goto farboo;
  611.     }
  612.  
  613.     return(newPosition);
  614. }  
  615.  
  616. /*  FUNCTION
  617.  *      WriteARPFile - write data to a buffered ARP file.
  618.  *
  619.  *  SYNOPSIS
  620.  *      LONG WriteARPFile(file, buffer, length)
  621.  *                        ARPFileHandle *file;
  622.  *                        UBYTE         *buffer;
  623.  *                        LONG          length;
  624.  *
  625.  *  DESCRIPTION
  626.  *      WriteARPFile attempts to write <length> bytes from <buffer> to
  627.  *      the buffered ARP file, <file>. The file MUST have been opened
  628.  *      with OpenARPFile for MODE_NEWFILE access.
  629.  *
  630.  *      WriteARPFile will not write to a file if the lastError field is
  631.  *      non-zero, or if the file was opened for input.
  632.  *
  633.  *      If successful, WriteARPFile will return the <length> parameter.
  634.  *      Otherwise, it will return a negated system error code.
  635.  */
  636.  
  637. LONG
  638. WriteARPFile(ARPFileHandle *file,UBYTE *buffer,LONG length)
  639. {
  640.     LONG    bufferBytes;
  641.     LONG    bytesLeft = length;
  642.     LONG    pos = 0;
  643.     LONG    usedBytes = 0;
  644.  
  645.     if(file -> mode != MODE_NEWFILE)
  646.         file -> lastError = ERROR_WRITE_PROTECTED;
  647.  
  648.         /* Catches mode and residual errors. */
  649.  
  650.     if(file -> lastError)
  651.     {
  652. sumbidge:    return(-file -> lastError);
  653.     }
  654.  
  655.         /* No buffer? */
  656.  
  657.     if(!file -> buf)
  658.     {
  659.         if(Write(file -> fh, buffer, length) != length)
  660.         {
  661.             file -> lastError = IoErr();
  662.             goto sumbidge;
  663.         }
  664.     }
  665.     else
  666.     {
  667.         while(bytesLeft)
  668.         {
  669.                 /* Need to flush the file's buffer? */
  670.  
  671.             if(file -> bufPos >= file -> bufSize)
  672.                 if(FlushARPFileBuffer(file) < 0)
  673.                     goto sumbidge;
  674.  
  675.             bufferBytes = file -> bufSize - file -> bufPos;
  676.  
  677.             usedBytes = MIN(bufferBytes, bytesLeft);
  678.  
  679.             CopyMem(&buffer[pos], &file -> buf[file -> bufPos], usedBytes);
  680.  
  681.             file -> bufLength = (file -> bufPos += usedBytes);
  682.  
  683.             pos += usedBytes;
  684.  
  685.             bytesLeft -= usedBytes;
  686.         }
  687.     }
  688.  
  689.     return(length);
  690. }
  691.