summaryrefslogtreecommitdiff
path: root/stdio/fwrite.c
diff options
context:
space:
mode:
Diffstat (limited to 'stdio/fwrite.c')
-rw-r--r--stdio/fwrite.c208
1 files changed, 208 insertions, 0 deletions
diff --git a/stdio/fwrite.c b/stdio/fwrite.c
new file mode 100644
index 0000000000..4d012f1779
--- /dev/null
+++ b/stdio/fwrite.c
@@ -0,0 +1,208 @@
+/* Copyright (C) 1991, 1992, 1993, 1994 Free Software Foundation, Inc.
+This file is part of the GNU C Library.
+
+The GNU C Library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Library General Public License as
+published by the Free Software Foundation; either version 2 of the
+License, or (at your option) any later version.
+
+The GNU C Library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+Library General Public License for more details.
+
+You should have received a copy of the GNU Library General Public
+License along with the GNU C Library; see the file COPYING.LIB. If
+not, write to the Free Software Foundation, Inc., 675 Mass Ave,
+Cambridge, MA 02139, USA. */
+
+#include <ansidecl.h>
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+
+
+/* Write NMEMB chunks of SIZE bytes each from PTR onto STREAM. */
+size_t
+DEFUN(fwrite, (ptr, size, nmemb, stream),
+ CONST PTR ptr AND size_t size AND
+ size_t nmemb AND register FILE *stream)
+{
+ register CONST unsigned char *p = (CONST unsigned char *) ptr;
+ register size_t to_write = size * nmemb;
+ register size_t written = 0;
+ int newlinep;
+ size_t buffer_space;
+ int default_func;
+
+ if (!__validfp (stream) || !stream->__mode.__write)
+ {
+ errno = EINVAL;
+ return 0;
+ }
+
+ if (ferror (stream))
+ return 0;
+ if (p == NULL || to_write == 0)
+ return 0;
+
+ if (!stream->__seen || stream->__put_limit == stream->__buffer)
+ {
+ /* This stream has never been seen before.
+ Calling __flshfp will give it a buffer
+ and I/O functions if it needs them. */
+ if (__flshfp (stream, *p++) == EOF)
+ return 0;
+ if (--to_write == 0)
+ return 1;
+ else
+ ++written;
+ }
+
+ default_func
+ = stream->__room_funcs.__output == __default_room_functions.__output;
+
+ {
+ int save = errno;
+
+ if (__stdio_check_offset (stream) == EOF && errno != ESPIPE)
+ {
+ stream->__error = 1;
+ goto done;
+ }
+
+ errno = save;
+ }
+
+ if (stream->__buffer == NULL && default_func &&
+ stream->__offset == stream->__target)
+ write_through:
+ /* This is an unbuffered stream using the standard output
+ buffer-flushing function, so we just do a straight write. */
+ {
+ int count = (stream->__io_funcs.__write == NULL ? to_write :
+ (*stream->__io_funcs.__write) (stream->__cookie,
+ (CONST char *) p,
+ to_write));
+ if (count > 0)
+ {
+ written += count;
+ if (stream->__offset != -1)
+ {
+ stream->__offset += count;
+ stream->__target = stream->__offset;
+ }
+ to_write -= count;
+ p += count;
+ }
+ else
+ stream->__error = 1;
+ goto done;
+ }
+
+ /* We ignore the end pointer here since we want to find out how much space
+ is really in the buffer, even for a line-buffered stream. */
+ buffer_space = stream->__bufsize - (stream->__bufp - stream->__buffer);
+
+ newlinep = (stream->__linebuf &&
+ memchr ((CONST PTR) p, '\n', to_write) != NULL);
+
+ if (newlinep && stream->__bufp == stream->__buffer &&
+ stream->__offset == stream->__target)
+ /* The buffer's empty, and we want to write our data
+ out soon anyway, so just write it straight out. */
+ goto write_through;
+
+ if (stream->__bufsize == 0 && !default_func)
+ {
+ /* No buffer, and a special function.
+ We can't do much better than putc. */
+ while (to_write-- > 0)
+ {
+ if (__flshfp (stream, *p++) == EOF)
+ break;
+ else
+ ++written;
+ }
+ }
+ else if (!default_func || buffer_space >= to_write)
+ fill_buffer:
+ /* There is enough room in the buffer for everything we
+ want to write or the user has specified his own output
+ buffer-flushing/expanding function. */
+ while (to_write > 0)
+ {
+ register size_t n = to_write;
+
+ if (n > buffer_space)
+ n = buffer_space;
+
+ buffer_space -= n;
+
+ written += n;
+ to_write -= n;
+
+ if (n < 20)
+ while (n-- > 0)
+ *stream->__bufp++ = *p++;
+ else
+ {
+ memcpy ((PTR) stream->__bufp, (PTR) p, n);
+ stream->__bufp += n;
+ p += n;
+ }
+
+ if (buffer_space == 0 || (to_write == 0 && newlinep))
+ {
+ /* We've filled the buffer, so flush it. */
+ if (fflush (stream) == EOF)
+ break;
+
+ /* Reset our record of the space available in the buffer,
+ since we have just flushed it. */
+ check_space:
+ buffer_space = (stream->__bufsize -
+ (stream->__bufp - stream->__buffer));
+ if (buffer_space == 0)
+ {
+ /* With a custom output-room function, flushing might
+ not create any buffer space. Try writing a single
+ character to create the space. */
+ if (__flshfp (stream, *p++) == EOF)
+ goto done;
+ ++written;
+ --to_write;
+ goto check_space;
+ }
+ }
+ }
+ else
+ {
+ /* It won't all fit in the buffer. */
+
+ if (stream->__bufp != stream->__buffer)
+ {
+ /* There are characters in the buffer. Flush them. */
+ if (__flshfp (stream, EOF) == EOF)
+ goto done;
+ }
+
+ /* The buffer has been flushed.
+ Now either fill it or write directly. */
+
+ buffer_space = stream->__bufsize - (stream->__bufp - stream->__buffer);
+
+ if (stream->__offset == stream->__target &&
+ (buffer_space < to_write || newlinep))
+ /* What we have to write is bigger than the buffer,
+ or it contains a newline and we're line-buffered,
+ so write it out. */
+ goto write_through;
+ else
+ /* It will fit in the buffer. */
+ goto fill_buffer;
+ }
+
+ done:;
+ return (size_t) written / size;
+}