glibc/stdio/fwrite.c

223 lines
5.8 KiB
C

/* Copyright (C) 1991, 92, 93, 94, 96, 97, 98 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., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
#include <errno.h>
#include <stdio.h>
#include <string.h>
/* Write NMEMB chunks of SIZE bytes each from PTR onto STREAM. */
size_t
fwrite (ptr, size, nmemb, stream)
const void *ptr;
size_t size;
size_t nmemb;
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)
{
__set_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;
}
__set_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 void *) 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)
{
/* 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. */
fill_buffer:
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 ((void *) stream->__bufp, (void *) p, n);
stream->__bufp += n;
p += n;
}
if (to_write == 0)
/* Done writing. */
break;
else if (buffer_space == 0)
{
/* We have 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;
}
}
}
/* We have written all the data into the buffer. If we are
line-buffered and just put a newline in the buffer, flush now to
make sure it gets out. */
if (newlinep)
fflush (stream);
}
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;
}
weak_alias (fwrite, fwrite_unlocked)