rom/dos/fwrite.c

   1 /*
   2     Copyright © 1995-2013, 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         Buffered write of a number of blocks to a stream.
  31         May write fewer blocks than requested.
  32
  33     INPUTS
  34         fh        - Write to this file
  35         block     - The data begins here
  36         blocklen  - number of bytes per block.  Must be > 0.
  37         numblocks - number of blocks to write.  Must be > 0.
  38
  39     RESULT
  40         The number of blocks written to the file or EOF on error. IoErr()
  41         gives additional information in case of an error.
  42
  43     NOTES
  44         Some releases of AmigaOS may not clear IoErr(), while AROS
  45         does. For full backwards compatibility, you may want to call
  46         SetIoErr(0L) before FWrite() if you need to be able to check
  47         the error code.
  48
  49     EXAMPLE
  50
  51     BUGS
  52
  53     SEE ALSO
  54         Open(), FRead(), FPutc(), Close()
  55
  56 *****************************************************************************/
  57 {
  58     AROS_LIBFUNC_INIT
  59
  60     ASSERT_VALID_PTR(BADDR(fh));
  61     ASSERT_VALID_PTR(block);
  62     ASSERT(blocklen > 0);
  63     ASSERT(numblocks > 0);
  64
  65     ULONG   written;
  66     const UBYTE  *ptr;
  67
  68     ptr = block;
  69
  70     SetIoErr(0);
  71
  72     for(written = 0; written < numblocks; written++)
  73     {
  74         if (FWriteChars(fh, ptr, blocklen, DOSBase) != blocklen)
  75         {
  76             return(EOF);
  77         }
  78         else
  79         {
  80             ptr += blocklen;
  81         }
  82     }
  83
  84     return written;
  85
  86     AROS_LIBFUNC_EXIT
  87 } /* FWrite */
  88
  89
  90 LONG
  91 FWriteChars(BPTR file, CONST UBYTE* buffer, ULONG length, struct DosLibrary *DOSBase)
  92 {
  93     ASSERT_VALID_PTR(BADDR(file));
  94     ASSERT_VALID_PTR(buffer);
  95
  96     /* Get pointer to filehandle. */
  97     struct FileHandle *fh = (struct FileHandle *)BADDR(file);
  98
  99     if (fh == NULL)
 100         return EOF;
 101
 102     /* Check if file is in write mode */
 103     if (!(fh->fh_Flags & FHF_WRITE))
 104     {
 105         if (fh->fh_Pos < fh->fh_End)
 106         {
 107             /* Read mode. Try to seek back to the current position. */
 108             if (Seek(file, fh->fh_Pos - fh->fh_End, OFFSET_CURRENT) < 0)
 109             {
 110                 fh->fh_Pos = fh->fh_End = 0;
 111
 112                 return EOF;
 113             }
 114         }
 115
 116         /* Is there a buffer? */
 117         if (fh->fh_Buf == BNULL)
 118         {
 119             if (vbuf_alloc(fh, NULL, IOBUFSIZE) == NULL)
 120             {
 121                 return(EOF);
 122             }
 123         }
 124
 125         /* Prepare buffer */
 126         fh->fh_Flags |= FHF_WRITE;
 127
 128         fh->fh_Pos = 0;
 129         fh->fh_End = fh->fh_BufSize;
 130     }
 131
 132         LONG
 133     written = -1;
 134
 135     if (fh->fh_Flags & FHF_NOBUF)
 136     {
 137             LONG
 138         goOn = TRUE;
 139
 140         if (fh->fh_Pos != 0)
 141         {
 142             goOn = Flush(file);
 143         }
 144
 145         if (goOn)
 146         {
 147             written = Write(file, buffer, length);
 148         }
 149     }
 150     else
 151     {
 152         for (written = 0; written < length; ++written)
 153         {
 154             /* Check if there is still some space in the buffer */
 155             if (fh->fh_Pos >= fh->fh_End)
 156             {
 157                 if (!Flush(file))
 158                 {
 159                     written = -1;
 160                     break;
 161                 }
 162             }
 163
 164             /* Write data */
 165             ((UBYTE *)BADDR(fh->fh_Buf))[fh->fh_Pos++] = buffer[written];
 166
 167             if (fh->fh_Flags & FHF_LINEBUF
 168                 && (buffer[written] == '\n' || buffer[written] == '\r'
 169                     || buffer[written] == '\0'))
 170             {
 171                 if (!Flush(file))
 172                 {
 173                     written = -1;
 174                     break;
 175                 }
 176             }
 177         }
 178     }
 179
 180     return(written);
 181 }