/* Copyright (C) 2004       Manuel Novoa III    <mjn3@codepoet.org>
 *
 * GNU Library General Public License (LGPL) version 2 or later.
 *
 * Dedicated to Toni.  See uClibc/DEDICATION.mjn3 for details.
 */

#include "_stdio.h"


/* Given a writing stream with no buffered output, write the
 * data in 'buf' (which may be the stream's bufstart) of size
 * 'bufsize' to the stream.  If a write error occurs, set the
 * stream's error indicator and (if buffering) buffer as much
 * data as possible (FBF) or only up to '\n' (LBF) to implement
 * "as if fputc()" clause in the standard.
 *
 * Returns the number of bytes written and/or buffered.
 *
 * Notes:
 *   Calling with bufsize == 0 is permitted, and buf is ignored in
 *     that case.
 *   We implement fflush() by setting bufpos to bufstart and passing
 *     bufstart as the buf arg.  If there is a write error, the
 *     unwritten buffered data will simply be moved to the beginning
 *     of the buffer.  Since the data obviously fits in the buffer
 *     and since there will be no '\n' chars in the buffer in the LBF
 *     case, no data will be lost.
 *   NOT THREADSAFE!  Assumes stream already locked if necessary.
 */

size_t attribute_hidden __stdio_WRITE(register FILE *stream,
					 register const unsigned char *buf, size_t bufsize)
{
	size_t todo;
	ssize_t rv, stodo;

	__STDIO_STREAM_VALIDATE(stream);
	assert(stream->__filedes >= -1);
	assert(__STDIO_STREAM_IS_WRITING(stream));
	assert(!__STDIO_STREAM_BUFFER_WUSED(stream)); /* Buffer must be empty. */

	todo = bufsize;

	while (todo != 0) {
		stodo = (todo <= SSIZE_MAX) ? todo : SSIZE_MAX;
		rv = __WRITE(stream, (char *) buf, stodo);
		if (rv >= 0) {
#ifdef __UCLIBC_MJN3_ONLY__
#warning TODO: Make custom stream write return check optional.
#endif
#ifdef __UCLIBC_HAS_GLIBC_CUSTOM_STREAMS__
			assert(rv <= stodo);
			if (rv > stodo) {	/* Wrote more than stodo! */
/* 				abort(); */
			}
#endif
			todo -= rv;
			buf += rv;
		} else {

			__STDIO_STREAM_SET_ERROR(stream);

			/* We buffer data on "transient" errors, but discard it
			 * on "hard" ones. Example of a hard error:
			 *
			 * close(fileno(stdout));
			 * printf("Hi there 1\n"); // EBADF
			 * dup2(good_fd, fileno(stdout));
			 * printf("Hi there 2\n"); // buffers new data
			 *
			 * This program should not print "Hi there 1" to good_fd.
			 * The rationale is that the caller of writing operation
			 * should check for error and act on it.
			 * If he didn't, then future users of the stream
			 * have no idea what to do.
			 * It's least confusing to at least not burden them with
			 * some hidden buffered crap in the buffer.
			 */
			if (errno != EINTR && errno != EAGAIN) {
				/* do we have other "soft" errors? */
				break;
			}
#ifdef __STDIO_BUFFERS
			stodo = __STDIO_STREAM_BUFFER_SIZE(stream);
			if (stodo != 0) {
				unsigned char *s;

				if (stodo > todo) {
					stodo = todo;
				}

				s = stream->__bufstart;

				do {
					*s = *buf;
					if ((*s == '\n')
						&& __STDIO_STREAM_IS_LBF(stream)
						) {
						break;
					}
					++s;
					++buf;
				} while (--stodo);

				stream->__bufpos = s;

				todo -= (s - stream->__bufstart);
			}
#endif /* __STDIO_BUFFERS */

			bufsize -= todo;
			break;
		}
	}

	__STDIO_STREAM_VALIDATE(stream);
	return bufsize;
}