1999-01-22 Roland McGrath <roland@baalperazim.frob.com>
[kopensolaris-gnu/glibc.git] / stdio / internals.c
index 1e2c5b4..96151c1 100644 (file)
@@ -1,37 +1,30 @@
-/* Copyright (C) 1991, 1992, 1993 Free Software Foundation, Inc.
-This file is part of the GNU C Library.
+/* Copyright (C) 1991, 92, 93, 94, 95, 96, 97 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
 
-The GNU C Library is free software; you can redistribute it and/or
-modify it under the terms of the GNU Library General Public License as
-published by the Free Software Foundation; either version 2 of the
-License, or (at your option) any later version.
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Library General Public License as
+   published by the Free Software Foundation; either version 2 of the
+   License, or (at your option) any later version.
 
-The GNU C Library is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-Library General Public License for more details.
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Library General Public License for more details.
 
-You should have received a copy of the GNU Library General Public
-License along with the GNU C Library; see the file COPYING.LIB.  If
-not, write to the Free Software Foundation, Inc., 675 Mass Ave,
-Cambridge, MA 02139, USA.  */
+   You should have received a copy of the GNU Library General Public
+   License along with the GNU C Library; see the file COPYING.LIB.  If not,
+   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
 
-#include <ansidecl.h>
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 
-/* Minimum size of a buffer we will allocate by default.
-   If this much memory is not available,
-   the stream in question will be made unbuffered instead.  */
-#define        MIN_BUFSIZE     128
-
-/* Figure out what kind of buffering (none, line, or full)
-   and what buffer size to give FP.  */
-static void
-DEFUN(init_stream, (fp), register FILE *fp)
+/* Make sure that FP has its functions set.  */
+void
+__stdio_check_funcs (register FILE *fp)
 {
   if (!fp->__seen)
     {
@@ -40,12 +33,26 @@ DEFUN(init_stream, (fp), register FILE *fp)
         If no buffer is set (and the stream is not made explicitly
         unbuffered), we allocate a buffer below, using the bufsize
         set by this function.  */
-      extern void EXFUN(__stdio_init_stream, (FILE *));
+      extern void __stdio_init_stream __P ((FILE *));
       fp->__room_funcs = __default_room_functions;
       fp->__io_funcs = __default_io_functions;
-      __stdio_init_stream(fp);
+      __stdio_init_stream (fp);
       fp->__seen = 1;
     }
+}
+
+
+/* Minimum size of a buffer we will allocate by default.
+   If this much memory is not available,
+   the stream in question will be made unbuffered instead.  */
+#define        MIN_BUFSIZE     128
+
+/* Figure out what kind of buffering (none, line, or full)
+   and what buffer size to give FP.  */
+static void
+init_stream (register FILE *fp)
+{
+  __stdio_check_funcs (fp);
 
   if (fp->__buffer == NULL && !fp->__userbuf)
     {
@@ -61,13 +68,13 @@ DEFUN(init_stream, (fp), register FILE *fp)
       save = errno;
       while (fp->__bufsize >= MIN_BUFSIZE)
        {
-         fp->__buffer = (char *) malloc(fp->__bufsize);
+         fp->__buffer = (char *) malloc (fp->__bufsize);
          if (fp->__buffer == NULL)
            fp->__bufsize /= 2;
          else
            break;
        }
-      errno = save;
+      __set_errno (save);
 
       if (fp->__buffer == NULL)
        {
@@ -88,7 +95,8 @@ DEFUN(init_stream, (fp), register FILE *fp)
 
 /* Determine the current file position of STREAM if it is unknown.  */
 int
-DEFUN(__stdio_check_offset, (stream), FILE *stream)
+__stdio_check_offset (stream)
+     FILE *stream;
 {
   init_stream (stream);
 
@@ -98,15 +106,15 @@ DEFUN(__stdio_check_offset, (stream), FILE *stream)
       if (stream->__io_funcs.__seek == NULL)
        {
          /* Unknowable.  */
-         errno = ESPIPE;
+         __set_errno (ESPIPE);
          return EOF;
        }
       else
        {
          /* Unknown.  Find it out.  */
          fpos_t pos = (fpos_t) 0;
-         if ((*stream->__io_funcs.__seek)(stream->__cookie,
-                                          &pos, SEEK_CUR) < 0)
+         if ((*stream->__io_funcs.__seek) (stream->__cookie,
+                                           &pos, SEEK_CUR) < 0)
            {
              if (errno == ESPIPE)
                /* Object is incapable of seeking.  */
@@ -131,10 +139,16 @@ DEFUN(__stdio_check_offset, (stream), FILE *stream)
    seeking as necessary and updating its `offset' field.
    Sets ferror(FP) (and possibly errno) for errors.  */
 static void
-DEFUN(seek_to_target, (fp), FILE *fp)
+seek_to_target (FILE *fp)
 {
+  int save = errno;
   if (__stdio_check_offset (fp) == EOF)
-    fp->__error = 1;
+    {
+      if (errno == ESPIPE)
+       __set_errno (save);
+      else
+       fp->__error = 1;
+    }
   else if (fp->__target != fp->__offset)
     {
       /* We are not at the target file position.
@@ -142,21 +156,32 @@ DEFUN(seek_to_target, (fp), FILE *fp)
       if (fp->__io_funcs.__seek == NULL)
        {
          /* We can't seek!  */
-         errno = ESPIPE;
+         __set_errno (ESPIPE);
          fp->__error = 1;
        }
       else
        {
          fpos_t pos = fp->__target;
-         if ((*fp->__io_funcs.__seek)(fp->__cookie, &pos, SEEK_SET) < 0)
+         if ((*fp->__io_funcs.__seek) (fp->__cookie, &pos, SEEK_SET) < 0)
            /* Seek failed!  */
            fp->__error = 1;
          else
            {
              fp->__offset = pos;
              if (pos != fp->__target)
-               /* Seek didn't go to the right place!  */
-               fp->__error = 1;
+               {
+                 /* Seek didn't go to the right place!
+                    This should never happen.  */
+#ifdef EGRATUITOUS
+                 /* It happens in the Hurd when the io server doesn't
+                    obey the protocol for io_seek.  */
+                 __set_errno (EGRATUITOUS);
+#else
+                 /* I don't think this can happen in Unix.  */
+                 __set_errno (ESPIPE); /* ??? */
+#endif
+                 fp->__error = 1;
+               }
            }
        }
     }
@@ -169,8 +194,7 @@ DEFUN(seek_to_target, (fp), FILE *fp)
    flushed to avoid a system call for a single character.
    This is the default `output room' function.  */
 static void
-DEFUN(flushbuf, (fp, c),
-      register FILE *fp AND int c)
+flushbuf (register FILE *fp, int c)
 {
   int flush_only = c == EOF;
   size_t buffer_written;
@@ -185,30 +209,36 @@ DEFUN(flushbuf, (fp, c),
 
       size_t buffer_offset = 0;
 
-      /* If the user has read some of the buffer, the target position
-        is incremented for each character he has read.  */
-      fp->__target += fp->__bufp - fp->__buffer;
+      if (fp->__target == -1)
+       /* For an unseekable object, data recently read bears no relation
+          to data we will write later.  Discard the buffer.  */
+       fp->__get_limit = fp->__buffer;
+      else
+       /* If the user has read some of the buffer, the target position
+          is incremented for each character he has read.  */
+       fp->__target += fp->__bufp - fp->__buffer;
 
       if (fp->__mode.__read && fp->__room_funcs.__input != NULL &&
          !fp->__mode.__append)
        {
          int save = errno;
-         CONST int aligned = (__stdio_check_offset(fp) == EOF ||
+         const int aligned = (fp->__buffer == NULL ||
+                              __stdio_check_offset (fp) == EOF ||
                               fp->__target % fp->__bufsize == 0);
-         errno = save;
+         __set_errno (save);
 
          if (!aligned)
            {
              /* Move to a block (buffer size) boundary and read in a block.
                 Then the output will be written as a whole block, too.  */
-             CONST size_t o = fp->__target % fp->__bufsize;
+             const size_t o = fp->__target % fp->__bufsize;
              fp->__target -= o;
-             if ((*fp->__room_funcs.__input)(fp) == EOF && ferror(fp))
+             if ((*fp->__room_funcs.__input) (fp) == EOF && ferror (fp))
                return;
              else
-               __clearerr(fp);
+               __clearerr (fp);
 
-             if (fp->__get_limit - fp->__buffer < o)
+             if ((size_t) (fp->__get_limit - fp->__buffer) < o)
                /* Oops.  We didn't read enough (probably because we got EOF).
                   Forget we even mentioned it.  */
                fp->__target += o;
@@ -216,12 +246,12 @@ DEFUN(flushbuf, (fp, c),
                /* Start bufp as far into the buffer as we were into
                   this block before we read it.  */
                buffer_offset = o;
-           }
 
-         /* The target position is now set to where the beginning of the
-            buffer maps to; and the get_limit was set by the input-room
-            function.  */
-         twiddled = 1;
+             /* The target position is now set to where the beginning of the
+                buffer maps to; and the get_limit was set by the input-room
+                function.  */
+             twiddled = 1;
+           }
        }
 
       if (fp->__buffer != NULL)
@@ -249,6 +279,14 @@ DEFUN(flushbuf, (fp, c),
                flush_only = 1;
            }
        }
+
+      if ((size_t) (fp->__bufp - fp->__buffer) <= buffer_offset && flush_only)
+       {
+         /* There is nothing new in the buffer, only data that
+            was read back aligned from the file.  */
+         buffer_written = 0;
+         goto end;
+       }
     }
 
   /* If there is read data in the buffer past what was written,
@@ -266,7 +304,8 @@ DEFUN(flushbuf, (fp, c),
         call with nothing in the buffer, so just say the buffer's
         been flushed, increment the file offset, and return.  */
       fp->__bufp = fp->__buffer;
-      fp->__offset += to_write;
+      if (fp->__offset != -1)
+       fp->__offset += to_write;
       goto end;
     }
 
@@ -282,8 +321,8 @@ DEFUN(flushbuf, (fp, c),
       if (!ferror(fp))
        {
          /* Write out the buffered data.  */
-         wrote = (*fp->__io_funcs.__write)(fp->__cookie, fp->__buffer,
-                                           to_write);
+         wrote = (*fp->__io_funcs.__write) (fp->__cookie, fp->__buffer,
+                                            to_write);
          if (wrote > 0)
            {
              if (fp->__mode.__append)
@@ -292,7 +331,7 @@ DEFUN(flushbuf, (fp, c),
                   bother to find the current position; we can get it
                   later if we need it.  */
                fp->__offset = fp->__target = -1;
-             else
+             else if (fp->__offset != -1)
                /* Record that we've moved forward in the file.  */
                fp->__offset += wrote;
            }
@@ -307,7 +346,7 @@ DEFUN(flushbuf, (fp, c),
   fp->__bufp = fp->__buffer;
 
   /* If we're not just flushing, write the last character, C.  */
-  if (!flush_only && !ferror(fp))
+  if (!flush_only && !ferror (fp))
     {
       if (fp->__buffer == NULL || (fp->__linebuf && (unsigned char) c == '\n'))
        {
@@ -316,7 +355,7 @@ DEFUN(flushbuf, (fp, c),
          char cc = (unsigned char) c;
          if ((*fp->__io_funcs.__write)(fp->__cookie, &cc, 1) < 1)
            fp->__error = 1;
-         else
+         else if (fp->__offset != -1)
            {
              /* Record that we've moved forward in the file.  */
              ++fp->__offset;
@@ -332,16 +371,17 @@ DEFUN(flushbuf, (fp, c),
 
   if (!twiddled)
     {
-      /* The new target position moves up as
-        much as the user wrote into the buffer.  */
-      fp->__target += buffer_written;
+      if (fp->__target != -1)
+       /* The new target position moves up as
+          much as the user wrote into the buffer.  */
+       fp->__target += buffer_written;
 
       /* Set the reading limit to the beginning of the buffer,
         so the next `getc' will call __fillbf.  */
       fp->__get_limit = fp->__buffer;
     }
 
-  if (feof(fp) || ferror(fp))
+  if (feof (fp) || ferror (fp))
     fp->__bufp = fp->__put_limit;
 }
 
@@ -349,13 +389,14 @@ DEFUN(flushbuf, (fp, c),
 /* Fill the buffer for FP and return the first character read (or EOF).
    This is the default `input_room' function.  */
 static int
-DEFUN(fillbuf, (fp), register FILE *fp)
+fillbuf (register FILE *fp)
 {
   /* How far into the buffer we read we want to start bufp.  */
   size_t buffer_offset = 0;
   register char *buffer;
   register size_t to_read, nread = 0;
-  char c;
+  /* This must be unsigned to avoid sign extension in return.  */
+  unsigned char c;
 
   if (fp->__io_funcs.__read == NULL)
     {
@@ -367,7 +408,7 @@ DEFUN(fillbuf, (fp), register FILE *fp)
   if (fp->__buffer == NULL)
     {
       /* We're unbuffered, so we want to read only one character.  */
-      buffer = &c;
+      buffer = (char *) &c;
       to_read = 1;
     }
   else
@@ -393,13 +434,13 @@ DEFUN(fillbuf, (fp), register FILE *fp)
          }
        seek_to_target (fp);
       }
-    errno = save;
+    __set_errno (save);
   }
 
-  while (!ferror(fp) && !feof(fp) && nread <= buffer_offset)
+  while (!ferror (fp) && !feof (fp) && nread <= buffer_offset)
     {
       /* Try to fill the buffer.  */
-      int count = (*fp->__io_funcs.__read)(fp->__cookie, buffer, to_read);
+      int count = (*fp->__io_funcs.__read) (fp->__cookie, buffer, to_read);
       if (count == 0)
        fp->__eof = 1;
       else if (count < 0)
@@ -409,15 +450,16 @@ DEFUN(fillbuf, (fp), register FILE *fp)
          buffer += count;
          nread += count;
          to_read -= count;
-         /* Record that we've moved forward in the file.  */
-         fp->__offset += count;
+         if (fp->__offset != -1)
+           /* Record that we've moved forward in the file.  */
+           fp->__offset += count;
        }
     }
 
   if (fp->__buffer == NULL)
     /* There is no buffer, so return the character we read
        without all the buffer pointer diddling.  */
-    return (feof(fp) || ferror(fp)) ? EOF : c;
+    return (feof (fp) || ferror (fp)) ? EOF : c;
 
   /* Reset the buffer pointer to the beginning of the buffer
      (plus whatever offset we may have set above).  */
@@ -425,7 +467,7 @@ DEFUN(fillbuf, (fp), register FILE *fp)
 
  end:;
 
-  if (feof(fp) || ferror(fp))
+  if (feof (fp) || ferror (fp))
     {
       /* Set both end pointers to the beginning of the buffer so
         the next i/o call will force a call to __fillbf/__flshfp.  */
@@ -440,22 +482,23 @@ DEFUN(fillbuf, (fp), register FILE *fp)
   fp->__put_limit = fp->__buffer;
 
   /* Return the first character in the buffer.  */
-  return (unsigned char) *fp->__bufp++;
+  return *((unsigned char *) (fp->__bufp++));
 }
 
 
 /* Default I/O and room functions.  */
 
-extern __io_read __stdio_read;
-extern __io_write __stdio_write;
-extern __io_seek __stdio_seek;
-extern __io_close __stdio_close;
-CONST __io_functions __default_io_functions =
+extern __io_read_fn __stdio_read;
+extern __io_write_fn __stdio_write;
+extern __io_seek_fn __stdio_seek;
+extern __io_close_fn __stdio_close;
+extern __io_fileno_fn __stdio_fileno;
+const __io_functions __default_io_functions =
   {
-    __stdio_read, __stdio_write, __stdio_seek, __stdio_close
+    __stdio_read, __stdio_write, __stdio_seek, __stdio_close, __stdio_fileno
   };
 
-CONST __room_functions __default_room_functions =
+const __room_functions __default_room_functions =
   {
     fillbuf, flushbuf
   };
@@ -464,18 +507,19 @@ CONST __room_functions __default_room_functions =
 /* Flush the buffer for FP and also write C if FLUSH_ONLY is nonzero.
    This is the function used by putc and fflush.  */
 int
-DEFUN(__flshfp, (fp, c),
-      register FILE *fp AND int c)
+__flshfp (fp, c)
+     register FILE *fp;
+     int c;
 {
   int flush_only = c == EOF;
 
-  if (!__validfp(fp) || !fp->__mode.__write)
+  if (!__validfp (fp) || !fp->__mode.__write)
     {
-      errno = EINVAL;
+      __set_errno (EINVAL);
       return EOF;
     }
 
-  if (ferror(fp))
+  if (ferror (fp))
     return EOF;
 
   if (fp->__pushed_back)
@@ -486,7 +530,7 @@ DEFUN(__flshfp, (fp, c),
     }
 
   /* Make sure the stream is initialized (has functions and buffering).  */
-  init_stream(fp);
+  init_stream (fp);
 
   /* Do this early, so a `putc' on such a stream will never return success.  */
   if (fp->__room_funcs.__output == NULL)
@@ -545,14 +589,15 @@ DEFUN(__flshfp, (fp, c),
 /* Fill the buffer for FP and return the first character read.
    This is the function used by getc.  */
 int
-DEFUN(__fillbf, (fp), register FILE *fp)
+__fillbf (fp)
+     register FILE *fp;
 {
   register int c;
   fpos_t new_target;
 
-  if (!__validfp(fp) || !fp->__mode.__read)
+  if (!__validfp (fp) || !fp->__mode.__read)
     {
-      errno = EINVAL;
+      __set_errno (EINVAL);
       return EOF;
     }
 
@@ -565,7 +610,7 @@ DEFUN(__fillbf, (fp), register FILE *fp)
     }
 
   /* Make sure the stream is initialized (has functions and buffering). */
-  init_stream(fp);
+  init_stream (fp);
 
   /* If we're trying to read the first character of a new
      line of input from an unbuffered or line buffered stream,
@@ -604,11 +649,11 @@ DEFUN(__fillbf, (fp), register FILE *fp)
 
   fp->__target = new_target;
 
-  if (ferror(fp))
+  if (ferror (fp))
     c = EOF;
   else if (fp->__room_funcs.__input != NULL)
     {
-      c = (*fp->__room_funcs.__input)(fp);
+      c = (*fp->__room_funcs.__input) (fp);
       if (fp->__buffer == NULL)
        /* This is an unbuffered stream, so the target sync above
           won't do anything the next time around.  Instead, note that
@@ -629,13 +674,14 @@ DEFUN(__fillbf, (fp), register FILE *fp)
 
 /* Nuke a stream, but don't kill its link in the chain.  */
 void
-DEFUN(__invalidate, (stream), register FILE *stream)
+__invalidate (stream)
+     register FILE *stream;
 {
   /* Save its link.  */
   register FILE *next = stream->__next;
 
-  /* Pulverize the fucker.  */
-  memset((PTR) stream, 0, sizeof(FILE));
+  /* Pulverize the deceased.  */
+  memset((void *) stream, 0, sizeof(FILE));
 
   /* Restore the deceased's link.  */
   stream->__next = next;