home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 326.lha / MRARPFile / MRARPFile.c < prev    next >
Encoding:
C/C++ Source or Header  |  1989-12-29  |  20.6 KB  |  678 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. /*  Note: define DEBUG if you want the test program at the end. */
  39.  
  40. /*  Embedded documentation template (cut & paste): */
  41.  
  42. /*  FUNCTION
  43.  *
  44.  *  SYNOPSIS
  45.  *
  46.  *  DESCRIPTION
  47.  *
  48.  */
  49.  
  50. #include "MRARPFile.h"
  51. #include <exec/memory.h>
  52. #include <functions.h>
  53.  
  54. #ifndef min
  55. #define min(a,b) ((a) <= (b) ? (a) : (b))
  56. #define max(a,b) ((a) >= (b) ? (a) : (b))
  57. #endif
  58.  
  59. /* StoreTracker is my attempt to fix an apparent bug in ARP 1.3. I have
  60.  * found that the LastTracker kludge (via IoErr()) doesn't work reliably.
  61.  * StoreTracker simply stuffs A1 into D0 and returns . It *MUST* be
  62.  * called immediately after any ARP call which allocates a tracker to
  63.  * assure that the value is correct.
  64.  */
  65.  
  66. struct DefaultTracker *StoreTracker();  /* asm routine */
  67.  
  68. static LONG FillARPFileBuffer();
  69.  
  70. /*  FUNCTION
  71.  *      FGetsARP - get string from a buffered ARP file.
  72.  *
  73.  *  SYNOPSIS
  74.  *      char *FGetsARP(s, length, file)
  75.  *                     UBYTE         *s;
  76.  *                     LONG           length;
  77.  *                     ARPFileHandle *file;
  78.  *
  79.  *  DESCRIPTION
  80.  *      FGetsARP models the behavior of the "standard" fgets, except that
  81.  *      it is used with a buffered ARP file. The data is read from <file>
  82.  *      and transfered to string <s>. Up to length-1 characters will be
  83.  *      read. Reading is also terminated upon receipt of a newline
  84.  *      or detection of end-of-file. 
  85.  *
  86.  *      If the <file> was opened without a buffer, one of MaxInputBuf
  87.  *      bytes will be allocated.
  88.  *
  89.  *      If end of file or an error is detected, the return value will be
  90.  *      NULL. Otherwise, the return value will be <s>. <s> will be 
  91.  *      terminated with a null byte.
  92.  */
  93. char *
  94. FGetsARP(s, length, file)
  95.     char            *s;
  96.     LONG            length;
  97.     ARPFileHandle   *file;
  98. {
  99.     LONG    bytesNeeded = length - 1;
  100.     LONG    bytesRead = 0;
  101.     char    c;
  102.     char    *s1 = s;
  103.     struct DefaultTracker *tracker;
  104.  
  105.     /* Set string initially empty to protect user from failure to check
  106.      * return value.
  107.      */
  108.     *s1 = '\0';    
  109.     if (file->mode != MODE_OLDFILE)
  110.         file->lastError = ERROR_READ_PROTECTED;
  111.          
  112.     if (file->lastError) {
  113. dangit:
  114.         return NULL;
  115.     }
  116.     if (! file->buf ) {                 /* Ohmigosh! No buffer? */
  117.         file->buf = ArpAllocMem(MaxInputBuf, MEMF_CLEAR|MEMF_PUBLIC);
  118.         tracker = StoreTracker();
  119.         if (! file->buf ) {
  120.             file->lastError = ERROR_NO_FREE_STORE;
  121.             goto dangit;
  122.         }
  123.         file->bufSize = MaxInputBuf;    /* bufLength, bufPos are zero. */
  124.         file->bufTracker = tracker;
  125.     }
  126.     while (bytesNeeded) {
  127.         if (file->bufPos >= file->bufLength) {
  128.             if (FillARPFileBuffer(file) < 0) goto dangit;
  129.             if (file->bufLength == 0) break;
  130.         }
  131.         c = file->buf[file->bufPos++];
  132.         ++bytesRead;
  133.         if (c == '\n') break;
  134.         *s1++ = c;
  135.         --bytesNeeded; 
  136.     }
  137.     *s1 = '\0';
  138.     return (bytesRead ? s : NULL);
  139. }
  140.  
  141. /*  FUNCTION
  142.  *      FillARPFileBuffer - read data into ARPFile buffer.
  143.  *
  144.  *  SYNOPSIS
  145.  *      static LONG FillARPFileBuffer(file)
  146.  *                                    ARPFileHandle *file;
  147.  *
  148.  *  DESCRIPTION
  149.  *      Attempt to fill the buffer associated with <file> by reading
  150.  *      data from the associated external file. The return value will
  151.  *      be one of the following:
  152.  *          >0  => number of bytes read
  153.  *           0  => end of file
  154.  *          -1  => a Bad Thing happened (error code in file->lastError) 
  155.  *
  156.  *      Note: this is a local routine and is thus declared as "static".
  157.  *      Please inform the author if this is a hardship.
  158.  */
  159. static LONG
  160. FillARPFileBuffer(file)
  161.     ARPFileHandle *file;
  162. {
  163.     /* Remember where we were. The user might want to try error
  164.      * recovery. Of course, this probably isn't enough info, but
  165.      * it's a start.
  166.      */
  167.     file->lastPosition = Seek(file->fh, 0L, OFFSET_CURRENT);
  168.     file->bufPos = 0;
  169.     file->bufLength = Read(file->fh, file->buf, file->bufSize);
  170.     if (file->bufLength == -1) {    /* We got trubble! */
  171.         file->lastError = IoErr();
  172.     }
  173.     else if (file->bufLength == 0) {
  174.         file->endOfFile = TRUE;
  175.     }
  176.     return file->bufLength;
  177. } 
  178.  
  179. /*  FUNCTION
  180.  *      FlushARPFileBuffer - write file buffer contents to disk.
  181.  *
  182.  *  SYNOPSIS
  183.  *      static LONG FlushARPFileBuffer(file)
  184.  *                                     ARPFileHandle *file;
  185.  *  DESCRIPTION
  186.  *      FlushARPFileBuffer writes the contents of <file>'s buffer
  187.  *      (if any) to disk and resets the buffer information. The
  188.  *      return value may be any of:
  189.  *
  190.  *          >0 =>   number of bytes written
  191.  *           0 =>   nothing in buffer
  192.  *          <0 =>   negated error code
  193.  *
  194.  *      Note: it is assumed that this function will only be used locally
  195.  *      and therefore need not be public. If you disagree, please contact
  196.  *      the author.
  197.  */
  198.  
  199. static LONG
  200. FlushARPFileBuffer(file)
  201.     ARPFileHandle *file;
  202. {
  203.     LONG    bytesWritten = 0;
  204.  
  205.     /* This operation is only allowed for output files. */
  206.  
  207.     if (file->mode != MODE_NEWFILE) {
  208.         file->lastError = ERROR_WRITE_PROTECTED;
  209. badstuff:
  210.         return -file->lastError;
  211.     }
  212.  
  213.     if (file->lastError) goto badstuff; /* Residual error? */
  214.  
  215.     if (file->bufLength) {
  216.         file->lastPosition = Seek(file->fh, 0L, OFFSET_CURRENT);
  217.         bytesWritten = Write(file->fh, file->buf, file->bufLength);
  218.         if (bytesWritten != file->bufLength) {
  219.             file->lastError = IoErr();
  220.             goto badstuff;
  221.         }
  222.         else {
  223.             file->bufLength = 0;
  224.             file->bufPos = 0;
  225.         }
  226.     }
  227.     return bytesWritten;
  228. }
  229.  
  230. /*  FUNCTION
  231.  *      FPutsARP - write a string to a buffered ARP file.
  232.  *
  233.  *  SYNOPSIS
  234.  *      LONG FPutsARP(s, file)
  235.  *                    char          *s;
  236.  *                    ARPFileHandle *file;
  237.  *
  238.  *  DESCRIPTION
  239.  *      FPutsARP writes the contents of string <s> to the specified <file>.
  240.  *      If successful, it returns 0. On failure, it returns the negated
  241.  *      system error code. 
  242.  */
  243. LONG
  244. FPutsARP(s, file)
  245.     char          *s;
  246.     ARPFileHandle *file;
  247. {
  248.     LONG    bytesLeft, bytesUsed;
  249.     char    *s1 = s;
  250.  
  251.     if (file->mode != MODE_NEWFILE) 
  252.         file->lastError = ERROR_WRITE_PROTECTED;
  253.  
  254.     if (file->lastError) {
  255. shucks:
  256.         return -file->lastError;
  257.     }
  258.  
  259.     bytesLeft = strlen(s);
  260.  
  261.     /* Attempt to be smart about this transfer. Copy the string to the
  262.      * buffer in chunks. There is a possibility that the string is bigger
  263.      * than the size of the buffer.
  264.      */
  265.     while (bytesLeft) {
  266.         if (file->bufPos >= file->bufSize) {
  267.             if (FlushARPFileBuffer(file) <= 0) goto shucks;
  268.         }
  269.         bytesUsed = min(file->bufSize - file->bufPos, bytesLeft);
  270.         CopyMem(s1, &file->buf[file->bufPos], bytesUsed);
  271.         s1 += bytesUsed;
  272.         file->bufLength = (file->bufPos += bytesUsed);
  273.         bytesLeft -= bytesUsed;
  274.     }
  275.     return 0;
  276. }
  277.  
  278. /*  FUNCTION
  279.  *      ReadARPFile - read from a buffered ARP file.
  280.  *
  281.  *  SYNOPSIS
  282.  *      LONG ReadARPFile(file, buffer, length)
  283.  *                       ARPFile *file;
  284.  *                       UBYTE   *buffer;
  285.  *                       LONG    length;
  286.  *
  287.  *  DESCRIPTION
  288.  *      ReadARPFile attempts to read <length> bytes from <file>, transferring
  289.  *      the data to <buffer>. 
  290.  *
  291.  *      The return value may be any of the following:
  292.  *
  293.  *          >0      number of bytes transferred
  294.  *          0       end of file
  295.  *         <0       negated error code
  296.  *
  297.  *      Note: if the lastError field of the <file> descriptor contains a
  298.  *            non-zero value, its negated value will be returned and no
  299.  *            attempt will be made to read the file. If you attempt error
  300.  *            recovery, you must clear this field to zero.
  301.  */
  302. LONG
  303. ReadARPFile(file, buffer, length)
  304.     ARPFileHandle   *file;
  305.     UBYTE           *buffer;
  306.     LONG            length;
  307. {
  308.     LONG            bytesLeft;
  309.     LONG            bytesRead = 0;
  310.     LONG            needBytes = length;
  311.     LONG            pos = 0;
  312.     LONG            usedBytes = 0;
  313.  
  314.     /* Prevent read if this file opened for writing. */
  315.  
  316.     if (file->mode != MODE_OLDFILE)
  317.         file->lastError = ERROR_READ_PROTECTED;
  318.  
  319.     if (file->lastError) {          /* Have residual error? */
  320. boofar:
  321.         return -file->lastError;
  322.     }
  323.  
  324.     if ( ! file->buf ) {            /* No buffer? */
  325.         bytesRead = Read(file->fh, buffer, length);
  326.         if (bytesRead == -1) {
  327.             file->lastError = IoErr();
  328.             goto boofar;
  329.         }
  330.     }
  331.     else while (needBytes) {
  332.         if (file->bufLength - file->bufPos <= 0) {
  333.             if (FillARPFileBuffer(file) == -1) goto boofar;
  334.             if (file->bufLength == 0) break;
  335.         }
  336.         bytesLeft = file->bufLength - file->bufPos;
  337.         usedBytes = min(bytesLeft, length);
  338.         CopyMem(&file->buf[file->bufPos], &buffer[pos], usedBytes);
  339.         file->bufPos += usedBytes;
  340.         pos += usedBytes;
  341.         bytesRead += usedBytes;
  342.         needBytes -= usedBytes;
  343.     }
  344.     return bytesRead;   
  345. }
  346.  
  347. /*  FUNCTION
  348.  *      CloseARPFile - close buffered ARP file.
  349.  *
  350.  *  SYNOPSIS
  351.  *      LONG CloseARPFile(file)
  352.  *                        ARPFileHandle *file;
  353.  *
  354.  *  DESCRIPTION
  355.  *      CloseARPFile closes the file described by <file> which MUST have
  356.  *      been opened by OpenARPFile. It releases all tracked items
  357.  *      associated with <file>, as well.
  358.  *
  359.  *      The return value is only meaningful for output files. If, upon
  360.  *      flushing the buffer, a write error is detected, a system error
  361.  *      code (ERROR_DISK_FULL, etc.) will be returned.
  362.  */
  363.  
  364. LONG
  365. CloseARPFile(file)
  366.     ARPFileHandle *file;
  367. {
  368.     LONG        result = 0;
  369.  
  370.     if (file) {                     /* Just in case... */
  371.         if (file->fileTracker) {
  372.             /* Any left-over stuff in the buffer? If so, we must flush
  373.              * it to disk. However, if an error was detected in the
  374.              * previous operation, punt. 
  375.              */
  376.             if ( ( file->mode == MODE_NEWFILE) && 
  377.                    ! file->lastError &&
  378.                    file->bufLength) {
  379.                 if (Write(file->fh, file->buf, file->bufLength) !=
  380.                     file->bufLength)
  381.                     result = IoErr();
  382.             }
  383.             FreeTrackedItem(file->fileTracker);
  384.         }
  385.  
  386.         if (file->bufTracker)
  387.             FreeTrackedItem(file->bufTracker);
  388.  
  389.         FreeTrackedItem(file->myTracker);
  390.     }
  391.     return result;
  392. }
  393.  
  394. /*  FUNCTION
  395.  *      OpenARPFile - open a buffered ARP file
  396.  *
  397.  *  SYNOPSIS
  398.  *      struct MRARPFile *OpenARPFile(name, accessMode, bytes)
  399.  *                                    char *name;
  400.  *                                    LONG accessMode, bytes;
  401.  *
  402.  *  DESCRIPTION
  403.  *      OpenARPFile opens the file <name>, with the given <accessMode>
  404.  *      (MODE_OLDFILE, MODE_NEWFILE only!) for buffered access. The
  405.  *      size of the local buffer is specified by <bytes>.
  406.  *
  407.  *      A zero value for <bytes> is OK and is sometimes appropriate, as
  408.  *      when performing file copy operations, etc. However, if a file
  409.  *      opened with a zero length buffer is then passed to the
  410.  *      FGetsARP function, "spontaneous buffer allocation" will occur.
  411.  *      No biggy, really, just something you should know. The ARP constant,
  412.  *      MaxInputBuf will be used for the buffer size, in this case.
  413.  *
  414.  *      If successful, a pointer to the file tracking structure is 
  415.  *      returned. Otherwise, the return value will be NULL.
  416.  *
  417.  *      OpenARPFile uses full resource tracking for all information
  418.  *      associated with the file.
  419.  *
  420.  */
  421.  
  422. ARPFileHandle *
  423. OpenARPFile(name, accessMode, bytes)
  424.     char *name;
  425.     LONG accessMode, bytes;
  426. {
  427.     BPTR                  fh;
  428.     ARPFileHandle         *theFile = NULL;
  429.     struct DefaultTracker *lastTracker;
  430.  
  431.     /* This package does not support READ/WRITE access! */
  432.  
  433.     if ( (accessMode != MODE_OLDFILE) && (accessMode != MODE_NEWFILE))
  434.         return NULL;
  435.  
  436.     /* 
  437.      * Note: I'm using ArpAllocMem vs. ArpAlloc here because it appears
  438.      * that ArpAlloc gives me a bad tracker pointer (?).
  439.      */
  440.     theFile = ArpAllocMem((LONG) sizeof(ARPFileHandle), 
  441.                           MEMF_PUBLIC|MEMF_CLEAR);
  442.     lastTracker = StoreTracker();
  443.     if (theFile) {
  444.         theFile->myTracker = lastTracker;
  445.         theFile->mode = accessMode;
  446.         fh = ArpOpen(name, accessMode);
  447.         lastTracker = StoreTracker();
  448.         if (!fh) {
  449. fungu:
  450.             CloseARPFile(theFile);  /* Don't worry - it's "smart". */
  451.             theFile = NULL;
  452.         }
  453.         theFile->fileTracker = lastTracker;
  454.         theFile->fh = fh;
  455.         if ( bytes) {               /* Does user want a buffer? */
  456.             theFile->buf = ArpAllocMem(bytes, MEMF_PUBLIC|MEMF_CLEAR);
  457.             lastTracker = StoreTracker();
  458.             if (!theFile->buf) goto fungu;
  459.             theFile->bufSize = bytes;
  460.             theFile->bufTracker = lastTracker;
  461.         }
  462.     }
  463.     return theFile;  
  464. }
  465.  
  466. /*  FUNCTION
  467.  *      SeekARPFile - move to new logical position in file.
  468.  *
  469.  *  SYNOPSIS
  470.  *      LONG SeekARPFile(file, position, mode)
  471.  *                       ARPFileHandle *file;
  472.  *                       LONG           position;
  473.  *                       LONG           mode;
  474.  *
  475.  *  DESCRIPTION
  476.  *      SeekARPFile attempts to position the <file> to a new logical
  477.  *      position or report it's current position. The <position>
  478.  *      parameter represets a signed offset. The <mode> parameter may
  479.  *      be one of:
  480.  *
  481.  *          OFFSET_BEGINNING (-1) => from beginning of file
  482.  *          OFFSET_CURRENT (0)    => from current position
  483.  *          OFFSET_END (-1)       => from end of file
  484.  *
  485.  *      On output files, the current buffer contents, if any, are
  486.  *      written to disk.
  487.  *
  488.  *      The return value will either be a positive displacement >=0) or
  489.  *      a negated system error code.
  490.  */
  491. LONG
  492. SeekARPFile(file, position, mode)
  493.             ARPFileHandle *file;
  494.             LONG           position;
  495.             LONG           mode;
  496. {
  497.     LONG    newPosition;
  498.  
  499.     if (file->mode == MODE_NEWFILE && file->bufLength) {
  500.         if (FlushARPFileBuffer(file) < 0) {
  501. farboo:
  502.             return -file->lastError;
  503.         }
  504.     }
  505.     /* Remember our last position. */
  506.     file->lastPosition = Seek(file, 0L, OFFSET_CURRENT);
  507.     if ((newPosition = Seek(file->fh, position, mode)) == -1) {
  508.         file->lastError = IoErr();
  509.         goto farboo;
  510.     }
  511.     return newPosition;
  512. }  
  513.  
  514. /*  FUNCTION
  515.  *      WriteARPFile - write data to a buffered ARP file.
  516.  *
  517.  *  SYNOPSIS
  518.  *      LONG WriteARPFile(file, buffer, length)
  519.  *                        ARPFileHandle *file;
  520.  *                        UBYTE         *buffer;
  521.  *                        LONG          length;
  522.  *
  523.  *  DESCRIPTION
  524.  *      WriteARPFile attempts to write <length> bytes from <buffer> to
  525.  *      the buffered ARP file, <file>. The file MUST have been opened
  526.  *      with OpenARPFile for MODE_NEWFILE access.
  527.  *
  528.  *      WriteARPFile will not write to a file if the lastError field is
  529.  *      non-zero, or if the file was opened for input.
  530.  *
  531.  *      If successful, WriteARPFile will return the <length> parameter.
  532.  *      Otherwise, it will return a negated system error code.
  533.  */
  534. LONG
  535. WriteARPFile(file, buffer, length)
  536.     ARPFileHandle   *file;
  537.     UBYTE           *buffer;
  538.     LONG            length;
  539. {
  540.     LONG    bufferBytes;
  541.     LONG    bytesLeft = length;
  542.     LONG    pos = 0;
  543.     LONG    usedBytes = 0;
  544.  
  545.     if (file->mode != MODE_NEWFILE)
  546.         file->lastError = ERROR_WRITE_PROTECTED;
  547.  
  548.     if (file->lastError) {           /* Catches mode and residual errors. */
  549. sumbidge:
  550.         return -file->lastError;
  551.     }
  552.  
  553.     if ( ! file->buf ) {             /* No buffer? */
  554.         if (Write(file->fh, buffer, length) != length) {
  555.             file->lastError = IoErr();
  556.             goto sumbidge;
  557.         }
  558.     }
  559.     else while (bytesLeft) {
  560.         /* Need to flush the file's buffer? */
  561.         if (file->bufPos >= file->bufSize) {
  562.             if (FlushARPFileBuffer(file) < 0) {
  563.                 goto sumbidge;
  564.             }
  565.         }
  566.         bufferBytes = file->bufSize - file->bufPos;
  567.         usedBytes = min(bufferBytes, bytesLeft);
  568.         CopyMem(&buffer[pos], &file->buf[file->bufPos], usedBytes);
  569.         file->bufLength = (file->bufPos += usedBytes);
  570.         pos += usedBytes;
  571.         bytesLeft -= usedBytes;
  572.     }
  573.     return length;
  574. }
  575.  
  576. #ifdef DEBUG
  577. /*  Short test program. */
  578.  
  579. struct ArpBase          *ArpBase;
  580. struct IntuitionBase    *IntuitionBase;
  581. struct GfxBase          *GfxBase;
  582.  
  583. ARPFileHandle *
  584. GetFile(prompt, mode, bufferSize)
  585.     char    *prompt;
  586.     LONG    mode, bufferSize;
  587. {
  588.     BOOL            keepTrying;
  589.     ARPFileHandle   *theFile = NULL;
  590.     char            fileName[MaxInputBuf+1];
  591.  
  592.     for (keepTrying = TRUE; keepTrying; ) {
  593.         Puts("\nA null response aborts this test.");
  594.         Puts(prompt);
  595.         ReadLine(fileName);
  596.         if ( ! *fileName ) break;   /* Null response? */
  597.         theFile = OpenARPFile(fileName, mode, bufferSize);
  598.         if (theFile == NULL) {
  599.             Puts("That file failed to open. Try again.\n");
  600.         }
  601.         else
  602.             keepTrying = FALSE;
  603.     }
  604.     return theFile;
  605. }
  606.  
  607. main()
  608. {
  609. #define BUFFER_SIZE     16384L
  610.  
  611. static char line[81];
  612.  
  613.     UBYTE           *buffer;
  614.     LONG            count;
  615.     ARPFileHandle   *file1, *file2;
  616.     int             keepTesting;
  617.     LONG            totalBytes;
  618.  
  619.     ArpBase = (struct ArpBase *) OpenLibrary(ArpName, ArpVersion);
  620.     if (ArpBase == NULL) {
  621.         exit(1);
  622.     }
  623.     GfxBase = (struct GfxBase *) ArpBase->GfxBase;
  624.     IntuitionBase = (struct IntuitionBase *) ArpBase->IntuiBase;
  625.  
  626.     Puts("MRARPFile package test.\n\n");
  627.  
  628. FGetsARPTest:
  629.     Puts("FGetsARP test - echo file to console.");
  630.     file1 = GetFile("Enter the name of a text file:", MODE_OLDFILE, 4192L);
  631.     if ( file1) {
  632.         while (FGetsARP(line, (LONG) sizeof(line), file1))
  633.             Puts(line);
  634.         CloseARPFile(file1);
  635.     }
  636.  
  637. CopyFileTest:
  638.     buffer = ArpAllocMem(BUFFER_SIZE, MEMF_PUBLIC);
  639.     if ( ! buffer ) {
  640.         Printf("I couldn't allocate a %ld byte buffer!\n", BUFFER_SIZE);
  641.         goto die;
  642.     }
  643.     for (keepTesting = TRUE; keepTesting; ) {
  644.         Puts("ReadARPFile/WriteARPFile test.");
  645.         Puts("For this test, I will copy a file.");
  646.         file1 = GetFile("Enter input file name:", MODE_OLDFILE, 512L);
  647.         if (!file1) break;
  648.         file2 = GetFile("Enter output file name:", MODE_NEWFILE, 8192L);
  649.         if (!file2) {
  650.             CloseARPFile(file1);
  651.             break;
  652.         }
  653.         keepTesting = FALSE;        /* This is it... */
  654.         totalBytes = 0;
  655.         while (count = ReadARPFile(file1, buffer, BUFFER_SIZE)) {
  656.             totalBytes += count;
  657.             if (WriteARPFile(file2, buffer, count) != count) {
  658.                 Printf("Error on output file: %ld\n", file2->lastError);
  659.                 break;
  660.             }
  661.             if (count < BUFFER_SIZE) break;
  662.         }
  663.         if (file1->lastError)
  664.             Printf("Error on input file: %ld\n", file1->lastError);
  665.         CloseARPFile(file1);
  666.         CloseARPFile(file2);
  667.         Printf("Bytes transferred: %ld\n", totalBytes);
  668.         /* Note: leave the buffer for ARP to free up. You should check
  669.          * available memory before/after running this test to make sure
  670.          * that ARP does proper housecleaning.
  671.          */
  672.     }
  673. die:
  674.     CloseLibrary(ArpBase);
  675.     exit(0);
  676. }
  677.  
  678. #endif