/* WBUF.C

 * 

 * Portions Copyright (c) 1990-1999 Nokia Corporation and/or its subsidiary(-ies).

 * All rights reserved.

 */

/* No user fns here.  Pesch 15apr92. */

/*

 * Copyright (c) 1990 The Regents of the University of California.

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms are permitted

 * provided that the above copyright notice and this paragraph are

 * duplicated in all such forms and that any documentation,

 * advertising materials, and other materials related to such

 * distribution and use acknowledge that the software was developed

 * by the University of California, Berkeley.  The name of the

 * University may not be used to endorse or promote products derived

 * from this software without specific prior written permission.

 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR

 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED

 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.

 */

#include <stdio.h>

#include "LOCAL.H"

#include "FVWRITE.H"

/*

 * Write the given character into the (probably full) buffer for

 * the given file.  Flush the buffer out if it is or becomes full,

 * or if c=='\n' and the file is line buffered.

 */

int

__swbuf (register int c,register FILE *fp)

{

  register int n;

  /* Ensure stdio has been initialized.  */

  CHECK_INIT (fp);

  /*

   * In case we cannot write, or longjmp takes us out early,

   * make sure _w is 0 (if fully- or un-buffered) or -_bf._size

   * (if line buffered) so that we will get called again.

   * If we did not do this, a sufficient number of putc()

   * calls might wrap _w from negative to positive.

   */

  fp->_w = fp->_lbfsize;

  if (cantwrite (fp))

    return EOF;

  c = (unsigned char) c;

  /*

   * If it is completely full, flush it out.  Then, in any case,

   * stuff c into the buffer.  If this causes the buffer to fill

   * completely, or if c is '\n' and the file is line buffered,

   * flush it (perhaps a second time).  The second flush will always

   * happen on unbuffered streams, where _bf._size==1; fflush()

   * guarantees that putc() will always call wbuf() by setting _w

   * to 0, so we need not do anything else.

   */

  n = fp->_p - fp->_bf._base;

  if (n >= fp->_bf._size)

    {

      if (fflush (fp))

	return EOF;

      n = 0;

    }

  fp->_w--;

  *fp->_p++ = (unsigned char)c;

  if (++n == fp->_bf._size || (fp->_flags & __SLBF && c == '\n'))

    if (fflush (fp))

      return EOF;

  return c;

}