home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 375.lha / MRARPFile_v1.1 / MRARPFile.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-05-02  |  17.1 KB  |  572 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 if you mix calls to this package
  35.  *  with calls to Read/Write/Seek, etc. (unless, of course, you take care 
  36.  * to maintain the ARPFileHandle information).
  37.  */
  38.  
  39.  
  40. #if __STDC__
  41. #include <stdlib.h>
  42. #endif
  43.  
  44. #include "MRARPFile.h"
  45. #include <exec/memory.h>
  46. #include <string.h>
  47. #include <functions.h>
  48.  
  49. #ifndef min
  50. #define min(a,b) ((a) <= (b) ? (a) : (b))
  51. #define max(a,b) ((a) >= (b) ? (a) : (b))
  52. #endif
  53.  
  54. /* struct DefaultTracker *StoreTracker __PARMS( (void) ); */
  55.  
  56. static LONG FillARPFileBuffer __PARMS( (ARPFileHandle *file) );
  57. static LONG FlushARPFileBuffer __PARMS( (ARPFileHandle *file) );
  58.  
  59. /*  FUNCTION
  60.  *      FGetsARP - get string from a buffered ARP file.
  61.  *
  62.  *  SYNOPSIS
  63.  *      #include <MRARPFile.h>
  64.  *
  65.  *      char *FGetsARP(s, length, file)
  66.  *                     UBYTE         *s;
  67.  *                     LONG           length;
  68.  *                     ARPFileHandle *file;
  69.  *
  70.  *  DESCRIPTION
  71.  *      FGetsARP models the behavior of the "standard" fgets, except that
  72.  *      it is used with a buffered ARP file. The data is read from <file>
  73.  *      and transfered to string <s>. Up to length-1 characters will be
  74.  *      read. Reading is also terminated upon receipt of a newline
  75.  *      or detection of end-of-file. 
  76.  *
  77.  *      If the <file> was opened without a buffer, one of MaxInputBuf
  78.  *      bytes will be allocated.
  79.  *
  80.  *      If end of file or an error is detected, the return value will be
  81.  *      NULL. Otherwise, the return value will be <s>. <s> will be 
  82.  *      terminated with a null byte.
  83.  */
  84. char *
  85. FGetsARP(s, length, file)
  86.     char            *s;
  87.     LONG            length;
  88.     ARPFileHandle   *file;
  89. {
  90.     LONG    bytesNeeded = length - 1;
  91.     LONG    bytesRead = 0;
  92.     char    c;
  93.     char    *s1 = s;
  94.  
  95.     /* Set string initially empty to protect user from failure to check
  96.      * return value.
  97.      */
  98.     *s1 = '\0';    
  99.     if (file->mode != MODE_OLDFILE)
  100.         file->lastError = ERROR_READ_PROTECTED;
  101.          
  102.     if (file->lastError) {
  103. dangit:
  104.         return NULL;
  105.     }
  106.     if (! file->buf ) {                 /* Ohmigosh! No buffer? */
  107.         file->buf = ArpAlloc(MaxInputBuf);
  108.         if (! file->buf ) {
  109.             file->lastError = ERROR_NO_FREE_STORE;
  110.             goto dangit;
  111.         }
  112.         file->bufSize = MaxInputBuf;    /* bufLength, bufPos are zero. */
  113.     }
  114.     while (bytesNeeded) {
  115.         if (file->bufPos >= file->bufLength) {
  116.             if (FillARPFileBuffer(file) < 0) goto dangit;
  117.             if (file->bufLength == 0) break;
  118.         }
  119.         c = file->buf[file->bufPos++];
  120.         ++bytesRead;
  121.         if (c == '\n') break;
  122.         *s1++ = c;
  123.         --bytesNeeded; 
  124.     }
  125.     *s1 = '\0';
  126.     return (bytesRead ? s : NULL);
  127. }
  128.  
  129. /*  FUNCTION
  130.  *      FillARPFileBuffer - read data into ARPFile buffer.
  131.  *
  132.  *  SYNOPSIS
  133.  *      #include <MRARPFile.h>
  134.  *
  135.  *      static LONG FillARPFileBuffer(file)
  136.  *                                    ARPFileHandle *file;
  137.  *
  138.  *  DESCRIPTION
  139.  *      Attempt to fill the buffer associated with <file> by reading
  140.  *      data from the associated external file. The return value will
  141.  *      be one of the following:
  142.  *          >0  => number of bytes read
  143.  *           0  => end of file
  144.  *          -1  => a Bad Thing happened (error code in file->lastError) 
  145.  *
  146.  *      Note: this is a local routine and is thus declared as "static".
  147.  *      Please inform the author if this is a hardship.
  148.  */
  149. static LONG
  150. FillARPFileBuffer(file)
  151.     ARPFileHandle *file;
  152. {
  153.     /* Remember where we were. The user might want to try error
  154.      * recovery. Of course, this probably isn't enough info, but
  155.      * it's a start.
  156.      */
  157.     file->lastPosition = Seek(file->fh, 0L, OFFSET_CURRENT);
  158.     file->bufPos = 0;
  159.     file->bufLength = Read(file->fh, file->buf, file->bufSize);
  160.     if (file->bufLength == -1) {    /* We got trubble! */
  161.         file->lastError = IoErr();
  162.     }
  163.     else if (file->bufLength == 0) {
  164.         file->endOfFile = TRUE;
  165.     }
  166.     return file->bufLength;
  167. } 
  168.  
  169. /*  FUNCTION
  170.  *      FlushARPFileBuffer - write file buffer contents to disk.
  171.  *
  172.  *  SYNOPSIS
  173.  *      #include <MRARPFile.h>
  174.  *
  175.  *      static LONG FlushARPFileBuffer(ARPFileHandle *file);
  176.  *
  177.  *  DESCRIPTION
  178.  *      FlushARPFileBuffer writes the contents of <file>'s buffer
  179.  *      (if any) to disk and resets the buffer information. The
  180.  *      return value may be any of:
  181.  *
  182.  *          >0 =>   number of bytes written
  183.  *           0 =>   nothing in buffer
  184.  *          <0 =>   negated error code
  185.  *
  186.  *      Note: it is assumed that this function will only be used locally
  187.  *      and therefore need not be public. If you disagree, please contact
  188.  *      the author.
  189.  */
  190.  
  191. static LONG
  192. FlushARPFileBuffer(file)
  193.     ARPFileHandle *file;
  194. {
  195.     LONG    bytesWritten = 0;
  196.  
  197.     /* This operation is only allowed for output files. */
  198.  
  199.     if (file->mode != MODE_NEWFILE) {
  200.         file->lastError = ERROR_WRITE_PROTECTED;
  201. badstuff:
  202.         return -file->lastError;
  203.     }
  204.  
  205.     if (file->lastError) goto badstuff; /* Residual error? */
  206.  
  207.     if (file->bufLength) {
  208.         file->lastPosition = Seek(file->fh, 0L, OFFSET_CURRENT);
  209.         bytesWritten = Write(file->fh, (const char *) file->buf, file->bufLength);
  210.         if (bytesWritten != file->bufLength) {
  211.             file->lastError = IoErr();
  212.             goto badstuff;
  213.         }
  214.         else {
  215.             file->bufLength = 0;
  216.             file->bufPos = 0;
  217.         }
  218.     }
  219.     return bytesWritten;
  220. }
  221.  
  222. /*  FUNCTION
  223.  *      FPutsARP - write a string to a buffered ARP file.
  224.  *
  225.  *  SYNOPSIS
  226.  *      #include <MRARPFile.h>
  227.  *
  228.  *      LONG FPutsARP(s, file)
  229.  *                    char          *s;
  230.  *                    ARPFileHandle *file;
  231.  *
  232.  *  DESCRIPTION
  233.  *      FPutsARP writes the contents of string <s> to the specified <file>.
  234.  *      If successful, it returns 0. On failure, it returns the negated
  235.  *      system error code. 
  236.  */
  237. LONG
  238. FPutsARP(s, file)
  239.     char          *s;
  240.     ARPFileHandle *file;
  241. {
  242.     LONG    bytesLeft, bytesUsed;
  243.     char    *s1 = s;
  244.  
  245.     if (file->mode != MODE_NEWFILE) 
  246.         file->lastError = ERROR_WRITE_PROTECTED;
  247.  
  248.     if (file->lastError) {
  249. shucks:
  250.         return -file->lastError;
  251.     }
  252.  
  253.     bytesLeft = strlen(s);
  254.  
  255.     /* Attempt to be smart about this transfer. Copy the string to the
  256.      * buffer in chunks. There is a possibility that the string is bigger
  257.      * than the size of the buffer.
  258.      */
  259.     while (bytesLeft) {
  260.         if (file->bufPos >= file->bufSize) {
  261.             if (FlushARPFileBuffer(file) <= 0) goto shucks;
  262.         }
  263.         bytesUsed = min(file->bufSize - file->bufPos, bytesLeft);
  264.         CopyMem(s1, &file->buf[file->bufPos], bytesUsed);
  265.         s1 += bytesUsed;
  266.         file->bufLength = (file->bufPos += bytesUsed);
  267.         bytesLeft -= bytesUsed;
  268.     }
  269.     return 0;
  270. }
  271.  
  272. /*  FUNCTION
  273.  *      ReadARPFile - read from a buffered ARP file.
  274.  *
  275.  *  SYNOPSIS
  276.  *      #include <MRARPFile.h>
  277.  *
  278.  *      LONG ReadARPFile(ARPFileHandle *file, char *buffer, LONG length);
  279.  *
  280.  *  DESCRIPTION
  281.  *      ReadARPFile attempts to read <length> bytes from <file>, transferring
  282.  *      the data to <buffer>. 
  283.  *
  284.  *      The return value may be any of the following:
  285.  *
  286.  *          >0      number of bytes transferred
  287.  *          0       end of file
  288.  *         <0       negated error code
  289.  *
  290.  *      Note: if the lastError field of the <file> descriptor contains a
  291.  *            non-zero value, its negated value will be returned and no
  292.  *            attempt will be made to read the file. If you attempt error
  293.  *            recovery, you must clear this field to zero.
  294.  */
  295. LONG
  296. ReadARPFile(file, buffer, length)
  297.     ARPFileHandle   *file;
  298.     char            *buffer;
  299.     LONG            length;
  300. {
  301.     LONG            bytesLeft;
  302.     LONG            bytesRead = 0;
  303.     LONG            needBytes = length;
  304.     LONG            pos = 0;
  305.     LONG            usedBytes = 0;
  306.  
  307.     /* Prevent read if this file opened for writing. */
  308.  
  309.     if (file->mode != MODE_OLDFILE)
  310.         file->lastError = ERROR_READ_PROTECTED;
  311.  
  312.     if (file->lastError) {          /* Have residual error? */
  313. boofar:
  314.         return -file->lastError;
  315.     }
  316.  
  317.     if ( ! file->buf ) {            /* No buffer? */
  318.         bytesRead = Read(file->fh, buffer, length);
  319.         if (bytesRead == -1) {
  320.             file->lastError = IoErr();
  321.             goto boofar;
  322.         }
  323.     }
  324.     else while (needBytes) {
  325.         if (file->bufLength - file->bufPos <= 0) {
  326.             if (FillARPFileBuffer(file) == -1) goto boofar;
  327.             if (file->bufLength == 0) break;
  328.         }
  329.         bytesLeft = file->bufLength - file->bufPos;
  330.         usedBytes = min(bytesLeft, length);
  331.         CopyMem(&file->buf[file->bufPos], &buffer[pos], usedBytes);
  332.         file->bufPos += usedBytes;
  333.         pos += usedBytes;
  334.         bytesRead += usedBytes;
  335.         needBytes -= usedBytes;
  336.     }
  337.     return bytesRead;   
  338. }
  339.  
  340. /*  FUNCTION
  341.  *      CloseARPFile - close buffered ARP file.
  342.  *
  343.  *  SYNOPSIS
  344.  *      #include <MRARPFile.h>
  345.  *
  346.  *      LONG CloseARPFile(file)
  347.  *                        ARPFileHandle *file;
  348.  *
  349.  *  DESCRIPTION
  350.  *      CloseARPFile closes the file described by <file> which MUST have
  351.  *      been opened by OpenARPFile. It releases all tracked items
  352.  *      associated with <file>, as well.
  353.  *
  354.  *      The return value is only meaningful for output files. If, upon
  355.  *      flushing the buffer, a write error is detected, a system error
  356.  *      code (ERROR_DISK_FULL, etc.) will be returned.
  357.  */
  358.  
  359. LONG
  360. CloseARPFile(file)
  361.     ARPFileHandle *file;
  362. {
  363.     LONG        result = 0;
  364.  
  365.     if (file) {                     /* Just in case... */
  366.         if (file->fileTracker) {
  367.             /* Any left-over stuff in the buffer? If so, we must flush
  368.              * it to disk. However, if an error was detected in the
  369.              * previous operation, punt. 
  370.              */
  371.             if ( ( file->mode == MODE_NEWFILE) && 
  372.                    ! file->lastError &&
  373.                    file->bufLength) {
  374.                 if (Write(file->fh, (const char *) file->buf, file->bufLength) !=
  375.                     file->bufLength)
  376.                     result = IoErr();
  377.             }
  378.             FreeTrackedItem(file->fileTracker);
  379.         }
  380.  
  381.         FreeTrackedItem((struct DefaultTracker *) file->buf);
  382.         FreeTrackedItem((struct DefaultTracker *) file);
  383.     }
  384.     return result;
  385. }
  386.  
  387. /*  FUNCTION
  388.  *      OpenARPFile - open a buffered ARP file
  389.  *
  390.  *  SYNOPSIS
  391.  *      #include <MRARPFile.h>
  392.  *
  393.  *      struct MRARPFile *OpenARPFile(name, accessMode, bytes)
  394.  *                                    char *name;
  395.  *                                    LONG accessMode, bytes;
  396.  *
  397.  *  DESCRIPTION
  398.  *      OpenARPFile opens the file <name>, with the given <accessMode>
  399.  *      (MODE_OLDFILE, MODE_NEWFILE only!) for buffered access. The
  400.  *      size of the local buffer is specified by <bytes>.
  401.  *
  402.  *      A zero value for <bytes> is OK and is sometimes appropriate, as
  403.  *      when performing file copy operations, etc. However, if a file
  404.  *      opened with a zero length buffer is then passed to the
  405.  *      FGetsARP function, "spontaneous buffer allocation" will occur.
  406.  *      No biggy, really, just something you should know. The ARP constant,
  407.  *      MaxInputBuf will be used for the buffer size, in this case.
  408.  *
  409.  *      If successful, a pointer to the file tracking structure is 
  410.  *      returned. Otherwise, the return value will be NULL.
  411.  *
  412.  *      OpenARPFile uses full resource tracking for all information
  413.  *      associated with the file.
  414.  *
  415.  */
  416.  
  417. ARPFileHandle *
  418. OpenARPFile(name, accessMode, bytes)
  419.     char *name;
  420.     LONG accessMode, bytes;
  421. {
  422.     BPTR                  fh;
  423.     ARPFileHandle         *theFile = NULL;
  424.     struct DefaultTracker *lastTracker;
  425.  
  426.     /* This package does not support READ/WRITE access! */
  427.  
  428.     if ( (accessMode != MODE_OLDFILE) && (accessMode != MODE_NEWFILE))
  429.         return NULL;
  430.  
  431.     theFile = ArpAlloc((LONG) sizeof(ARPFileHandle));
  432.     if (theFile) {
  433.         theFile->mode = accessMode;
  434.         fh = ArpOpen(name, accessMode);
  435.         lastTracker = LastTracker;
  436.         if (!fh) {
  437. fungu:
  438.             CloseARPFile(theFile);  /* Don't worry - it's "smart". */
  439.             theFile = NULL;
  440.         }
  441.         theFile->fileTracker = lastTracker;
  442.         theFile->fh = fh;
  443.         if ( bytes) {               /* Does user want a buffer? */
  444.             theFile->buf = ArpAlloc(bytes);
  445.             if (!theFile->buf) goto fungu;
  446.             theFile->bufSize = bytes;
  447.         }
  448.     }
  449.     return theFile;  
  450. }
  451.  
  452. /*  FUNCTION
  453.  *      SeekARPFile - move to new logical position in file.
  454.  *
  455.  *  SYNOPSIS
  456.  *      #include <MRARPFile.h>
  457.  *
  458.  *      LONG SeekARPFile(file, position, mode)
  459.  *                       ARPFileHandle *file;
  460.  *                       LONG           position;
  461.  *                       LONG           mode;
  462.  *
  463.  *  DESCRIPTION
  464.  *      SeekARPFile attempts to position the <file> to a new logical
  465.  *      position or report it's current position. The <position>
  466.  *      parameter represets a signed offset. The <mode> parameter may
  467.  *      be one of:
  468.  *
  469.  *          OFFSET_BEGINNING (-1) => from beginning of file
  470.  *          OFFSET_CURRENT (0)    => from current position
  471.  *          OFFSET_END (-1)       => from end of file
  472.  *
  473.  *      On output files, the current buffer contents, if any, are
  474.  *      written to disk.
  475.  *
  476.  *      The return value will either be a positive displacement >=0) or
  477.  *      a negated system error code.
  478.  */
  479. LONG
  480. SeekARPFile(file, position, mode)
  481.             ARPFileHandle *file;
  482.             LONG           position;
  483.             LONG           mode;
  484. {
  485.     LONG    newPosition;
  486.  
  487.     if (file->mode == MODE_NEWFILE && file->bufLength) {
  488.         if (FlushARPFileBuffer(file) < 0) {
  489. farboo:
  490.             return -file->lastError;
  491.         }
  492.     }
  493.     /* Remember our last position. */
  494.     file->lastPosition = Seek(file->fh, 0L, OFFSET_CURRENT);
  495.     if ((newPosition = Seek(file->fh, position, mode)) == -1) {
  496.         file->lastError = IoErr();
  497.         goto farboo;
  498.     }
  499.     return newPosition;
  500. }  
  501.  
  502. /*  FUNCTION
  503.  *      WriteARPFile - write data to a buffered ARP file.
  504.  *
  505.  *  SYNOPSIS
  506.  *      #include <MRARPFile.h>
  507.  *
  508.  *      LONG WriteARPFile(ARPFileHandle *file, const char *buffer, LONG length);
  509.  *
  510.  *  DESCRIPTION
  511.  *      WriteARPFile attempts to write <length> bytes from <buffer> to
  512.  *      the buffered ARP file, <file>. The file MUST have been opened
  513.  *      with OpenARPFile for MODE_NEWFILE access.
  514.  *
  515.  *      WriteARPFile will not write to a file if the lastError field is
  516.  *      non-zero, or if the file was opened for input.
  517.  *
  518.  *      If successful, WriteARPFile will return the <length> parameter.
  519.  *      Otherwise, it will return a negated system error code.
  520.  */
  521. LONG
  522. WriteARPFile(file, buffer, length)
  523.     ARPFileHandle   *file;
  524.     const char      *buffer;
  525.     LONG            length;
  526. {
  527.     LONG    bufferBytes;
  528.     LONG    bytesLeft = length;
  529.     LONG    pos = 0;
  530.     LONG    usedBytes = 0;
  531.  
  532.     if (file->mode != MODE_NEWFILE)
  533.         file->lastError = ERROR_WRITE_PROTECTED;
  534.  
  535.     if (file->lastError) {           /* Catches mode and residual errors. */
  536. sumbidge:
  537.         return -(file->lastError);
  538.     }
  539.  
  540.     if ( ! file->buf ) {             /* No buffer? */
  541.         if (Write(file->fh, buffer, length) != length) {
  542.             file->lastError = IoErr();
  543.             goto sumbidge;
  544.         }
  545.     }
  546.     else while (bytesLeft) {
  547.         /* Need to flush the file's buffer? */
  548.         if (file->bufPos >= file->bufSize) {
  549.             if (FlushARPFileBuffer(file) < 0) {
  550.                 goto sumbidge;
  551.             }
  552.         }
  553.         bufferBytes = file->bufSize - file->bufPos;
  554.         usedBytes = min(bufferBytes, bytesLeft);
  555.         CopyMem(&buffer[pos], &file->buf[file->bufPos], usedBytes);
  556.         file->bufLength = (file->bufPos += usedBytes);
  557.         pos += usedBytes;
  558.         bytesLeft -= usedBytes;
  559.     }
  560.     return length;
  561. }
  562.  
  563. /*  Embedded documentation template (cut & paste): */
  564.  
  565. /*  FUNCTION
  566.  *
  567.  *  SYNOPSIS
  568.  *
  569.  *  DESCRIPTION
  570.  *
  571.  */
  572.