rom/dos/fwrite.c

   1 /*
   2     Copyright © 1995-2007, 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(fh);
  50     ASSERT_VALID_PTR(block);
  51     ASSERT(blocklen > 0);
  52     ASSERT(numblocks > 0);
  53
  54     ULONG   len;
  55     UBYTE  *ptr;
  56
  57     ptr = block;
  58     len = 0;
  59
  60     SetIoErr(0);
  61
  62         ULONG
  63     written;
  64
  65     for(written = 0; written < numblocks; written++)
  66     {
  67         if (FWriteChars(fh, ptr, blocklen, DOSBase) != blocklen)
  68         {
  69             return(EOF);
  70         }
  71         else
  72         {
  73             ptr += blocklen;
  74         }
  75     }
  76
  77     return written;
  78
  79     AROS_LIBFUNC_EXIT
  80 } /* FWrite */
  81
  82
  83 LONG
  84 FWriteChars(BPTR file, CONST UBYTE* buffer, ULONG length, struct DosLibrary *DOSBase)
  85 {
  86     ASSERT_VALID_PTR(BADDR(file));
  87     ASSERT_VALID_PTR(buffer);
  88
  89     /* Get pointer to filehandle. */
  90     struct FileHandle *fh = (struct FileHandle *)BADDR(file);
  91
  92     /* Check if file is in write mode */
  93     if (!(fh->fh_Flags & FHF_WRITE))
  94     {
  95         if (fh->fh_Pos < fh->fh_End)
  96         {
  97             /* Read mode. Try to seek back to the current position. */
  98             if (Seek(file, fh->fh_Pos - fh->fh_End, OFFSET_CURRENT) < 0)
  99             {
 100                 fh->fh_Pos = fh->fh_End = fh->fh_Buf;
 101
 102                 return EOF;
 103             }
 104         }
 105
 106         /* Is there a buffer? */
 107         if (fh->fh_Buf == NULL)
 108         {
 109             if (NULL == vbuf_alloc(fh, IOBUFSIZE, DOSBase))
 110             {
 111                 return(EOF);
 112             }
 113         }
 114
 115         /* Prepare buffer */
 116         fh->fh_Flags |= FHF_WRITE;
 117
 118         fh->fh_Pos = fh->fh_Buf;
 119         fh->fh_End = fh->fh_Buf + fh->fh_Size;
 120     }
 121
 122         LONG
 123     written = -1;
 124
 125     if (fh->fh_Flags & FHF_NOBUF)
 126     {
 127             LONG
 128         goOn = TRUE;
 129
 130         if (fh->fh_Pos != fh->fh_Buf)
 131         {
 132             goOn = Flush(file);
 133         }
 134
 135         if (FALSE != goOn)
 136         {
 137             written = Write(file, buffer, length);
 138         }
 139     }
 140     else
 141     {
 142         for (written = 0; written < length; ++written)
 143         {
 144 /* Check if there is still some space in the buffer */
 145             if (fh->fh_Pos >= fh->fh_End)
 146             {
 147                 if (NULL == Flush(file))
 148                 {
 149                     written = -1;
 150                     break;
 151                 }
 152             }
 153
 154 /* Write data */
 155             *fh->fh_Pos++ = buffer[written];
 156
 157             if (fh->fh_Flags & FHF_LINEBUF
 158                 && (buffer[written] == '\n' || buffer[written] == '\r'
 159                     || buffer[written] == '\0'))
 160             {
 161                 if (NULL == Flush(file))
 162                 {
 163                     written = -1;
 164                     break;
 165                 }
 166             }
 167         }
 168     }
 169
 170     return(written);
 171 }