/* FVWRITE.C

  * 

  * Portions Copyright (c) 1990-2004 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_r.h>

 #include <string.h>

 #include "LOCAL.H"

 #include "FVWRITE.H"

 #define	MIN(a, b) ((a) < (b) ? (a) : (b))

 #define	COPY(n)	  (void) memmove((void *) fp->_p, (void *) p, (size_t) (n))

 #define GETIOV(extra_work) \

   while (len == 0) \

     { \

       extra_work; \

       p = (const char*)iov->iov_base; \

       len = iov->iov_len; \

       iov++; \

     }

 /*

  * Write some memory regions.  Return zero on success, EOF on error.

  *

  * This routine is large and unsightly, but most of the ugliness due

  * to the three different kinds of output buffering is handled here.

  */

 int

 __sfvwrite (register FILE *fp,register struct __suio *uio)

 {

   register size_t len;

   register const char *p;

   register struct __siov *iov;

   register int w, s;

   char *nl;

   int nlknown, nldist = -1;

   if ((len = uio->uio_resid) == 0)

     return 0;

   /* make sure we can write */

   if (cantwrite (fp))

     return EOF;

   iov = uio->uio_iov;

   len = 0;

   if (fp->_flags & __SNBF)

     {

       /*

        * Unbuffered: write up to BUFSIZ bytes at a time.

        */

       do

 	{

 	  GETIOV (;);

 	  w = (*fp->_write) (fp->_cookie, p, MIN (len, BUFSIZ));

 	  if (w <= 0)

 	    goto err;

 	  p += w;

 	  len -= w;

 	}

       while ((uio->uio_resid -= w) != 0);

     }

   else if ((fp->_flags & __SLBF) == 0)

     {

       /*

        * Fully buffered: fill partially full buffer, if any,

        * and then flush.  If there is no partial buffer, write

        * one _bf._size byte chunk directly (without copying).

        *

        * String output is a special case: write as many bytes

        * as fit, but pretend we wrote everything.  This makes

        * snprintf() return the number of bytes needed, rather

        * than the number used, and avoids its write function

        * (so that the write function can be invalid).

        */

       do

 	{

 	  GETIOV (;);

 	  w = fp->_w;

 	  if (fp->_flags & __SSTR)

 	    {

 	      if ((int)len < w)

 		w = len;

 	      COPY (w);		/* copy MIN(fp->_w,len), */

 	      fp->_w -= w;

 	      fp->_p += w;

 	      w = len;		/* but pretend copied all */

 	    }

 	  else if (fp->_p > fp->_bf._base && (int)len > w)

 	    {

 	      /* fill and flush */

 	      COPY (w);

 	      /* fp->_w -= w; *//* unneeded */

 	      fp->_p += w;

 	      if (fflush (fp))

 		goto err;

 	    }

 	  else if ((int)len >= (w = fp->_bf._size))

 	    {

 	      /* write directly */

 	      w = (*fp->_write) (fp->_cookie, p, w);

 	      if (w <= 0)

 		goto err;

 	    }

 	  else

 	    {

 	      /* fill and done */

 	      w = len;

 	      COPY (w);

 	      fp->_w -= w;

 	      fp->_p += w;

 	    }

 	  p += w;

 	  len -= w;

 	}

       while ((uio->uio_resid -= w) != 0);

     }

   else

     {

       /*

        * Line buffered: like fully buffered, but we

        * must check for newlines.  Compute the distance

        * to the first newline (including the newline),

        * or `infinity' if there is none, then pretend

        * that the amount to write is MIN(len,nldist).

        */

       nlknown = 0;

       do

 	{

 	  GETIOV (nlknown = 0);

 	  if (!nlknown)

 	    {

 	      nl = (char *)memchr ((void *) p, '\n', len);

 	      nldist = nl ? nl + 1 - p : len + 1;

 	      nlknown = 1;

 	    }

 	  s = MIN ((int)len, nldist);

 	  w = fp->_w + fp->_bf._size;

 	  if (fp->_p > fp->_bf._base && s > w)

 	    {

 	      COPY (w);

 	      /* fp->_w -= w; */

 	      fp->_p += w;

 	      if (fflush (fp))

 		goto err;

 	    }

 	  else if (s >= (w = fp->_bf._size))

 	    {

 	      w = (*fp->_write) (fp->_cookie, p, w);

 	      if (w <= 0)

 		goto err;

 	    }

 	  else

 	    {

 	      w = s;

 	      COPY (w);

 	      fp->_w -= w;

 	      fp->_p += w;

 	    }

 	  if ((nldist -= w) == 0)

 	    {

 	      /* copied the newline: flush and forget */

 	      if (fflush (fp))

 		goto err;

 	      nlknown = 0;

 	    }

 	  p += w;

 	  len -= w;

 	}

       while ((uio->uio_resid -= w) != 0);

     }

   return 0;

 err:

   fp->_flags |= __SERR;

   return EOF;

 }