rom/dos/fwrite.c

   1 /*
   2     Copyright © 1995-2011, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Lang: english
   6 */
   7 #include "dos_intern.h"
   8
   9 #include <aros/debug.h>
  10
  11
  12 /*****************************************************************************
  13
  14     NAME */
  15 #include <proto/dos.h>
  16
  17         AROS_LH4(LONG, FWrite,
  18 /*      FWrite -- Writes a number of blocks to an output (buffered) */
  19
  20 /*  SYNOPSIS */
  21         AROS_LHA(BPTR , fh, D1),
  22         AROS_LHA(CONST_APTR , block, D2),
  23         AROS_LHA(ULONG, blocklen, D3),
  24         AROS_LHA(ULONG, numblocks, D4),
  25
  26 /*  LOCATION */
  27         struct DosLibrary *, DOSBase, 55, Dos)
  28
  29 /*  FUNCTION
  30         Write a number of blocks to a file.
  31
  32     INPUTS
  33         fh        - Write to this file
  34         block     - The data begins here
  35     blocklen  - number of bytes per block.  Must be > 0.
  36     numblocks - number of blocks to write.  Must be > 0.
  37
  38     RESULT
  39         The number of blocks written to the file or EOF on error. IoErr()
  40         gives additional information in case of an error.
  41
  42     SEE ALSO
  43         Open(), FRead(), FPutc(), Close()
  44
  45 *****************************************************************************/
  46 {
  47     AROS_LIBFUNC_INIT
  48
  49     ASSERT_VALID_PTR(BADDR(fh));
  50     ASSERT_VALID_PTR(block);
  51     ASSERT(blocklen > 0);
  52     ASSERT(numblocks > 0);
  53
  54     ULONG   written;
  55     const UBYTE  *ptr;
  56
  57     ptr = block;
  58
  59     SetIoErr(0);
  60
  61     for(written = 0; written < numblocks; written++)
  62     {
  63         if (FWriteChars(fh, ptr, blocklen, DOSBase) != blocklen)
  64         {
  65             return(EOF);
  66         }
  67         else
  68         {
  69             ptr += blocklen;
  70         }
  71     }
  72
  73     return written;
  74
  75     AROS_LIBFUNC_EXIT
  76 } /* FWrite */
  77
  78
  79 LONG
  80 FWriteChars(BPTR file, CONST UBYTE* buffer, ULONG length, struct DosLibrary *DOSBase)
  81 {
  82     ASSERT_VALID_PTR(BADDR(file));
  83     ASSERT_VALID_PTR(buffer);
  84
  85     /* Get pointer to filehandle. */
  86     struct FileHandle *fh = (struct FileHandle *)BADDR(file);
  87
  88     if (fh == NULL)
  89         return EOF;
  90
  91     /* Check if file is in write mode */
  92     if (!(fh->fh_Flags & FHF_WRITE))
  93     {
  94         if (fh->fh_Pos < fh->fh_End)
  95         {
  96             /* Read mode. Try to seek back to the current position. */
  97             if (Seek(file, fh->fh_Pos - fh->fh_End, OFFSET_CURRENT) < 0)
  98             {
  99                 fh->fh_Pos = fh->fh_End = 0;
 100
 101                 return EOF;
 102             }
 103         }
 104
 105         /* Is there a buffer? */
 106         if (fh->fh_Buf == BNULL)
 107         {
 108             if (vbuf_alloc(fh, NULL, IOBUFSIZE) == NULL)
 109             {
 110                 return(EOF);
 111             }
 112         }
 113
 114         /* Prepare buffer */
 115         fh->fh_Flags |= FHF_WRITE;
 116
 117         fh->fh_Pos = 0;
 118         fh->fh_End = fh->fh_BufSize;
 119     }
 120
 121         LONG
 122     written = -1;
 123
 124     if (fh->fh_Flags & FHF_NOBUF)
 125     {
 126             LONG
 127         goOn = TRUE;
 128
 129         if (fh->fh_Pos != 0)
 130         {
 131             goOn = Flush(file);
 132         }
 133
 134         if (goOn)
 135         {
 136             written = Write(file, buffer, length);
 137         }
 138     }
 139     else
 140     {
 141         for (written = 0; written < length; ++written)
 142         {
 143             /* Check if there is still some space in the buffer */
 144             if (fh->fh_Pos >= fh->fh_End)
 145             {
 146                 if (!Flush(file))
 147                 {
 148                     written = -1;
 149                     break;
 150                 }
 151             }
 152
 153             /* Write data */
 154             ((UBYTE *)BADDR(fh->fh_Buf))[fh->fh_Pos++] = buffer[written];
 155
 156             if (fh->fh_Flags & FHF_LINEBUF
 157                 && (buffer[written] == '\n' || buffer[written] == '\r'
 158                     || buffer[written] == '\0'))
 159             {
 160                 if (!Flush(file))
 161                 {
 162                     written = -1;
 163                     break;
 164                 }
 165             }
 166         }
 167     }
 168
 169     return(written);
 170 }