This commit was manufactured by cvs2svn to create tag 'FreeBSD-release/1.0'.

[unix-history] / lib / libc / stdio / setvbuf.c

diff --git a/lib/libc/stdio/setvbuf.c b/lib/libc/stdio/setvbuf.c
index 2e53cd2..1928ae1 100644 (file)
--- a/lib/libc/stdio/setvbuf.c
+++ b/lib/libc/stdio/setvbuf.c
@@ -35,7 +35,7 @@
  */
 
 #if defined(LIBC_SCCS) && !defined(lint)
  */
 
 #if defined(LIBC_SCCS) && !defined(lint)

-static char sccsid[] = "@(#)setvbuf.c  5.2 (Berkeley) 2/1/91";
+static char sccsid[] = "@(#)setvbuf.c  5.5 (Berkeley) 5/6/93";

 #endif /* LIBC_SCCS and not lint */
 
 #include <stdio.h>
 #endif /* LIBC_SCCS and not lint */
 
 #include <stdio.h>


@@ -52,59 +52,97 @@ setvbuf(fp, buf, mode, size)
        register int mode;
        register size_t size;
 {
        register int mode;
        register size_t size;
 {

+       register int ret, flags;
+       size_t iosize;
+       int ttyflag;

 
        /*
         * Verify arguments.  The `int' limit on `size' is due to this
 
        /*
         * Verify arguments.  The `int' limit on `size' is due to this

-        * particular implementation.
+        * particular implementation.  Note, buf and size are ignored
+        * when setting _IONBF.

         */
         */

-       if ((mode != _IOFBF && mode != _IOLBF && mode != _IONBF) ||
-           (int)size < 0)
-               return (EOF);
+       if (mode != _IONBF)
+               if ((mode != _IOFBF && mode != _IOLBF) || (int)size < 0)
+                       return (EOF);

 
        /*
 
        /*

-        * Write current buffer, if any; drop read count, if any.
-        * Make sure putc() will not think fp is line buffered.
-        * Free old buffer if it was from malloc().  Clear line and
-        * non buffer flags, and clear malloc flag.
+        * Write current buffer, if any.  Discard unread input, cancel
+        * line buffering, and free old buffer if malloc()ed.

         */
         */

-       (void) __sflush(fp);
-       fp->_r = 0;
-       fp->_lbfsize = 0;
-       if (fp->_flags & __SMBF)
+       ret = 0;
+       (void)__sflush(fp);
+       fp->_r = fp->_lbfsize = 0;
+       flags = fp->_flags;
+       if (flags & __SMBF)

                free((void *)fp->_bf._base);
                free((void *)fp->_bf._base);

-       fp->_flags &= ~(__SLBF|__SNBF|__SMBF);
+       flags &= ~(__SLBF | __SNBF | __SMBF | __SOPT | __SNPT);
+
+       /* If setting unbuffered mode, skip all the hard work. */
+       if (mode == _IONBF)
+               goto nbf;

 
        /*
 
        /*

-        * Now put back whichever flag is needed, and fix _lbfsize
-        * if line buffered.  Ensure output flush on exit if the
-        * stream will be buffered at all.
+        * Find optimal I/O size for seek optimization.  This also returns
+        * a `tty flag' to suggest that we check isatty(fd), but we do not
+        * care since our caller told us how to buffer.

         */
         */

-       switch (mode) {
-
-       case _IONBF:
-               fp->_flags |= __SNBF;
-               fp->_bf._base = fp->_p = fp->_nbuf;
-               fp->_bf._size = 1;
-               break;
-
-       case _IOLBF:
-               fp->_flags |= __SLBF;
-               fp->_lbfsize = -size;
-               /* FALLTHROUGH */
+       flags |= __swhatbuf(fp, &iosize, &ttyflag);
+       if (size == 0) {
+               buf = NULL;     /* force local allocation */
+               size = iosize;
+       }

 
 

-       case _IOFBF:
-               /* no flag */
-               __cleanup = _cleanup;
-               fp->_bf._base = fp->_p = (unsigned char *)buf;
-               fp->_bf._size = size;
-               break;
+       /* Allocate buffer if needed. */
+       if (buf == NULL) {
+               if ((buf = malloc(size)) == NULL) {
+                       /*
+                        * Unable to honor user's request.  We will return
+                        * failure, but try again with file system size.
+                        */
+                       ret = EOF;
+                       if (size != iosize) {
+                               size = iosize;
+                               buf = malloc(size);
+                       }
+               }
+               if (buf == NULL) {
+                       /* No luck; switch to unbuffered I/O. */
+nbf:
+                       fp->_flags = flags | __SNBF;
+                       fp->_w = 0;
+                       fp->_bf._base = fp->_p = fp->_nbuf;
+                       fp->_bf._size = 1;
+                       return (ret);
+               }
+               flags |= __SMBF;

        }
 
        /*
        }
 
        /*

-        * Patch up write count if necessary.
+        * Kill any seek optimization if the buffer is not the
+        * right size.
+        *
+        * SHOULD WE ALLOW MULTIPLES HERE (i.e., ok iff (size % iosize) == 0)?

         */
         */

-       if (fp->_flags & __SWR)
-               fp->_w = fp->_flags & (__SLBF|__SNBF) ? 0 : size;
+       if (size != iosize)
+               flags |= __SNPT;
+
+       /*
+        * Fix up the FILE fields, and set __cleanup for output flush on
+        * exit (since we are buffered in some way).  If in r/w mode, go
+        * to the intermediate state, so that everyone has to call
+        * __srefill or __swsetup on the first operation -- it is more
+        * trouble than it is worth to set things up correctly here.
+        */
+       if (mode == _IOLBF)
+               flags |= __SLBF;
+       if (flags & __SRW)
+               flags &= ~(__SRD | __SWR);
+       fp->_w = 0;
+       fp->_flags = flags;
+       fp->_bf._base = fp->_p = (unsigned char *)buf;
+       fp->_bf._size = size;
+       fp->_lbfsize = 0;
+       __cleanup = _cleanup;

 
 

-       return (0);
+       return (ret);

 }
 }