diff options
Diffstat (limited to 'stdio/fwrite.c')
| -rw-r--r-- | stdio/fwrite.c | 208 |
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; +} |