BSD 4_4 release

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

diff --git a/usr/src/lib/libc/stdio/setvbuf.c b/usr/src/lib/libc/stdio/setvbuf.c
index bd66017..07d639d 100644 (file)
--- a/usr/src/lib/libc/stdio/setvbuf.c
+++ b/usr/src/lib/libc/stdio/setvbuf.c
@@ -1,15 +1,41 @@
 /*-
 /*-

- * Copyright (c) 1990 The Regents of the University of California.
- * All rights reserved.
+ * Copyright (c) 1990, 1993
+ *     The Regents of the University of California.  All rights reserved.

  *
  * This code is derived from software contributed to Berkeley by
  * Chris Torek.
  *
  *
  * This code is derived from software contributed to Berkeley by
  * Chris Torek.
  *

- * %sccs.include.redist.c%
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *     This product includes software developed by the University of
+ *     California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.

  */
 
 #if defined(LIBC_SCCS) && !defined(lint)
  */
 
 #if defined(LIBC_SCCS) && !defined(lint)

-static char sccsid[] = "@(#)setvbuf.c  5.1 (Berkeley) %G%";
+static char sccsid[] = "@(#)setvbuf.c  8.1 (Berkeley) 6/4/93";

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


@@ -26,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) fflush(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);

 }
 }