1999-01-22 Roland McGrath <roland@baalperazim.frob.com>
[kopensolaris-gnu/glibc.git] / stdio / internals.c
index c238bf3..96151c1 100644 (file)
@@ -1,22 +1,21 @@
-/* Copyright (C) 1991, 1992, 1993, 1994, 1995 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>
@@ -25,7 +24,7 @@ Cambridge, MA 02139, USA.  */
 
 /* Make sure that FP has its functions set.  */
 void
-DEFUN(__stdio_check_funcs, (fp), register FILE *fp)
+__stdio_check_funcs (register FILE *fp)
 {
   if (!fp->__seen)
     {
@@ -34,7 +33,7 @@ DEFUN(__stdio_check_funcs, (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);
@@ -51,7 +50,7 @@ DEFUN(__stdio_check_funcs, (fp), register FILE *fp)
 /* 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)
+init_stream (register FILE *fp)
 {
   __stdio_check_funcs (fp);
 
@@ -69,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)
        {
@@ -96,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);
 
@@ -106,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.  */
@@ -139,13 +139,13 @@ 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)
     {
       if (errno == ESPIPE)
-       errno = save;
+       __set_errno (save);
       else
        fp->__error = 1;
     }
@@ -156,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;
+               }
            }
        }
     }
@@ -183,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;
@@ -199,31 +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 = (fp->__buffer == NULL ||
-                              __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;
@@ -231,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)
@@ -265,7 +280,7 @@ DEFUN(flushbuf, (fp, c),
            }
        }
 
-      if (fp->__bufp - fp->__buffer <= buffer_offset && flush_only)
+      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.  */
@@ -289,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;
     }
 
@@ -305,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)
@@ -315,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;
            }
@@ -330,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'))
        {
@@ -339,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;
@@ -355,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;
 }
 
@@ -372,7 +389,7 @@ 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;
@@ -417,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)
@@ -433,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).  */
@@ -449,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.  */
@@ -475,12 +493,12 @@ 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 =
+const __io_functions __default_io_functions =
   {
     __stdio_read, __stdio_write, __stdio_seek, __stdio_close, __stdio_fileno
   };
 
-CONST __room_functions __default_room_functions =
+const __room_functions __default_room_functions =
   {
     fillbuf, flushbuf
   };
@@ -489,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)
@@ -511,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)
@@ -570,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;
     }
 
@@ -590,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,
@@ -629,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
@@ -654,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;