Stdio fixes from Chris Torek by way of NetBSD

diff --git a/lib/libc/stdio/local.h b/lib/libc/stdio/local.h
index c75c0fc..21966d7 100644 (file)
--- a/lib/libc/stdio/local.h
+++ b/lib/libc/stdio/local.h
@@ -33,7 +33,7 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *

- *     @(#)local.h     5.2 (Berkeley) 2/5/91
+ *     @(#)local.h     5.3 (Berkeley) 5/6/93

  */
 
 /*
  */
 
 /*


@@ -52,6 +52,7 @@ void  __sinit __P((void));
 void   _cleanup __P((void));
 void   (*__cleanup) __P((void));
 void   __smakebuf __P((FILE *));
 void   _cleanup __P((void));
 void   (*__cleanup) __P((void));
 void   __smakebuf __P((FILE *));

+int    __swhatbuf __P((FILE *, size_t *, int *));

 int    _fwalk __P((int (*)(FILE *)));
 int    __swsetup __P((FILE *));
 int    __sflags __P((const char *, int *));
 int    _fwalk __P((int (*)(FILE *)));
 int    __swsetup __P((FILE *));
 int    __sflags __P((const char *, int *));

diff --git a/lib/libc/stdio/makebuf.c b/lib/libc/stdio/makebuf.c
index 7b86aad..cb87e60 100644 (file)
--- a/lib/libc/stdio/makebuf.c
+++ b/lib/libc/stdio/makebuf.c
@@ -35,7 +35,7 @@
  */
 
 #if defined(LIBC_SCCS) && !defined(lint)
  */
 
 #if defined(LIBC_SCCS) && !defined(lint)

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

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


@@ -56,44 +56,63 @@ void
 __smakebuf(fp)
        register FILE *fp;
 {
 __smakebuf(fp)
        register FILE *fp;
 {

-       register size_t size, couldbetty;

        register void *p;
        register void *p;

-       struct stat st;
+       register int flags;
+       size_t size;
+       int couldbetty;

 
        if (fp->_flags & __SNBF) {
                fp->_bf._base = fp->_p = fp->_nbuf;
                fp->_bf._size = 1;
                return;
        }
 
        if (fp->_flags & __SNBF) {
                fp->_bf._base = fp->_p = fp->_nbuf;
                fp->_bf._size = 1;
                return;
        }

-       if (fp->_file < 0 || fstat(fp->_file, &st) < 0) {
-               couldbetty = 0;
-               size = BUFSIZ;
-               /* do not try to optimise fseek() */
-               fp->_flags |= __SNPT;
-       } else {
-               couldbetty = (st.st_mode & S_IFMT) == S_IFCHR;
-               size = st.st_blksize <= 0 ? BUFSIZ : st.st_blksize;
-               /*
-                * Optimise fseek() only if it is a regular file.
-                * (The test for __sseek is mainly paranoia.)
-                */
-               if ((st.st_mode & S_IFMT) == S_IFREG &&
-                   fp->_seek == __sseek) {
-                       fp->_flags |= __SOPT;
-                       fp->_blksize = st.st_blksize;
-               } else
-                       fp->_flags |= __SNPT;
-       }
+       flags = __swhatbuf(fp, &size, &couldbetty);

        if ((p = malloc(size)) == NULL) {
                fp->_flags |= __SNBF;
                fp->_bf._base = fp->_p = fp->_nbuf;
                fp->_bf._size = 1;
        if ((p = malloc(size)) == NULL) {
                fp->_flags |= __SNBF;
                fp->_bf._base = fp->_p = fp->_nbuf;
                fp->_bf._size = 1;

-       } else {
-               __cleanup = _cleanup;
-               fp->_flags |= __SMBF;
-               fp->_bf._base = fp->_p = p;
-               fp->_bf._size = size;
-               if (couldbetty && isatty(fp->_file))
-                       fp->_flags |= __SLBF;
+               return;

        }
        }

+       __cleanup = _cleanup;
+       flags |= __SMBF;
+       fp->_bf._base = fp->_p = p;
+       fp->_bf._size = size;
+       if (couldbetty && isatty(fp->_file))
+               flags |= __SLBF;
+       fp->_flags |= flags;
+}
+
+/*
+ * Internal routine to determine `proper' buffering for a file.
+ */
+int
+__swhatbuf(fp, bufsize, couldbetty)
+       register FILE *fp;
+       size_t *bufsize;
+       int *couldbetty;
+{
+       struct stat st;
+
+       if (fp->_file < 0 || fstat(fp->_file, &st) < 0) {
+               *couldbetty = 0;
+               *bufsize = BUFSIZ;
+               return (__SNPT);
+       }
+
+       /* could be a tty iff it is a character device */
+       *couldbetty = (st.st_mode & S_IFMT) == S_IFCHR;
+       if (st.st_blksize <= 0) {
+               *bufsize = BUFSIZ;
+               return (__SNPT);
+       }
+
+       /*
+        * Optimise fseek() only if it is a regular file.  (The test for
+        * __sseek is mainly paranoia.)  It is safe to set _blksize
+        * unconditionally; it will only be used if __SOPT is also set.
+        */
+       *bufsize = st.st_blksize;
+       fp->_blksize = st.st_blksize;
+       return ((st.st_mode & S_IFMT) == S_IFREG && fp->_seek == __sseek ?
+           __SOPT : __SNPT);

 }
 }

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);

 }
 }