Initial revision
authorroland <roland>
Mon, 17 Feb 1992 08:49:37 +0000 (08:49 +0000)
committerroland <roland>
Mon, 17 Feb 1992 08:49:37 +0000 (08:49 +0000)
stdio/internals.c [new file with mode: 0644]

diff --git a/stdio/internals.c b/stdio/internals.c
new file mode 100644 (file)
index 0000000..ade9c96
--- /dev/null
@@ -0,0 +1,596 @@
+/* Copyright (C) 1991 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 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.  */
+
+#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)
+{
+  if (!fp->__seen)
+    {
+      /* Initialize the stream's info, including buffering info.
+        This may give a buffer, change I/O functions, etc.
+        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 *));
+      fp->__room_funcs = __default_room_functions;
+      fp->__io_funcs = __default_io_functions;
+      __stdio_init_stream(fp);
+      fp->__seen = 1;
+    }
+
+  if (fp->__buffer == NULL && !fp->__userbuf)
+    {
+      int save;
+
+      if (fp->__bufsize == 0)
+       fp->__bufsize = BUFSIZ;
+
+      /* Try to get however many bytes of buffering __stdio_pickbuf
+        specified, but if that much memory isn't available,
+        try half as much each time until it succeeds or the buffer
+        size becomes too small to be useful.  */
+      save = errno;
+      while (fp->__bufsize >= MIN_BUFSIZE)
+       {
+         fp->__buffer = (char *) malloc(fp->__bufsize);
+         if (fp->__buffer == NULL)
+           fp->__bufsize /= 2;
+         else
+           break;
+       }
+      errno = save;
+
+      if (fp->__buffer == NULL)
+       {
+         /* We can't get space for the buffer, so make it unbuffered.  */
+         fp->__userbuf = 1;
+         fp->__bufsize = 0;
+       }
+    }
+
+  if (fp->__bufp == NULL)
+    {
+      /* Set the buffer pointer to the beginning of the buffer.  */
+      fp->__bufp = fp->__buffer;
+      fp->__put_limit = fp->__get_limit = fp->__buffer;
+    }
+}
+
+
+/* Determine the current file position of STREAM if it is unknown.  */
+int
+DEFUN(__stdio_check_offset, (stream), FILE *stream)
+{
+  if (stream->__offset == (fpos_t) -1)
+    {
+      /* This stream's offset is unknown or unknowable.  */
+      if (stream->__io_funcs.__seek == NULL)
+       {
+         /* Unknowable.  */
+         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 (errno == ESPIPE)
+               /* Object is incapable of seeking.  */
+               stream->__io_funcs.__seek = NULL;
+             return EOF;
+           }
+         stream->__offset = pos;
+       }
+    }
+
+  if (stream->__target == (fpos_t) -1)
+    /* This stream was opened on an existing object with
+       an unknown file position.  The position is now known.
+       Make this the target position.  */
+    stream->__target = stream->__offset;
+
+  return 0;
+}
+
+
+/* Move FP's file position to its target file position,
+   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)
+{
+  if (fp->__target != fp->__offset)
+    {
+      /* We are not at the target file position.
+        Seek to that position.  */
+      if (fp->__io_funcs.__seek == NULL)
+       {
+         /* We can't seek!  */
+         errno = ESPIPE;
+         fp->__error = 1;
+       }
+      else
+       {
+         fpos_t pos = fp->__target;
+         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;
+           }
+       }
+    }
+}
+
+/* Flush the buffer for FP.
+   If C is not EOF, it is also to be written.
+   If the stream is line buffered and C is a newline, it is written
+   to the output, otherwise it is put in the buffer after it has been
+   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)
+{
+  int flush_only = c == EOF;
+  size_t to_write;
+  int target_set = 0;
+
+  if (fp->__put_limit == fp->__buffer)
+    {
+      /* The stream needs to be primed for writing.  */
+
+      size_t buffer_offset = 0;
+
+      if (fp->__mode.__read && fp->__room_funcs.__input != NULL)
+       {
+         int save = errno;
+         CONST int aligned = (__stdio_check_offset(fp) == EOF ||
+                              fp->__target % fp->__bufsize == 0);
+         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;
+             fp->__target -= o;
+             if ((*fp->__room_funcs.__input)(fp) == EOF && ferror(fp))
+               return;
+             else
+               __clearerr(fp);
+
+             if (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;
+             else
+               /* 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.  */
+         target_set = 1;
+       }
+
+      if (fp->__buffer != NULL)
+       {
+         /* Set up to write output into the buffer.  */
+         fp->__put_limit = fp->__buffer + fp->__bufsize;
+         fp->__bufp = fp->__buffer + buffer_offset;
+         if (!flush_only)
+           {
+             *fp->__bufp++ = (unsigned char) c;
+             if (!fp->__linebuf || (unsigned char) c != '\n')
+               return;
+             flush_only = 1;
+           }
+       }
+    }
+
+  /* If there is read data in the buffer past what was written,
+     write all of that as well.  Otherwise, just write what has been
+     written into the buffer.  */
+  to_write = (fp->__get_limit > fp->__bufp ?
+             fp->__get_limit - fp->__buffer :
+             fp->__bufp - fp->__buffer);
+
+  if (fp->__io_funcs.__write == NULL || (to_write == 0 && flush_only))
+    {
+      /* There is no writing function or we're coming from an fflush
+        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;
+      goto end;
+    }
+
+  if (to_write > 0)
+    {
+      int wrote;
+
+      /* Go to the target file position.  */
+      seek_to_target(fp);
+
+      if (!ferror(fp))
+       {
+         /* Write out the buffered data.  */
+         wrote = (*fp->__io_funcs.__write)(fp->__cookie, fp->__buffer,
+                                           to_write);
+         if (wrote > 0)
+           /* Record that we've moved forward in the file.  */
+           fp->__offset += wrote;
+         if (wrote < (int) to_write)
+           /* The writing function should always write
+              the whole buffer unless there is an error.  */
+           fp->__error = 1;
+       }
+    }
+
+  /* Reset the buffer pointer to the beginning of the buffer.  */
+  fp->__bufp = fp->__buffer;
+
+  /* If we're not just flushing, write the last character, C.  */
+  if (!flush_only && !ferror(fp))
+    {
+      if (fp->__buffer == NULL || (fp->__linebuf && (unsigned char) c == '\n'))
+       {
+         /* Either we're unbuffered, or we're line-buffered and
+            C is a newline, so really write it out immediately.  */
+         char cc = (unsigned char) c;
+         if ((*fp->__io_funcs.__write)(fp->__cookie, &cc, 1) < 1)
+           fp->__error = 1;
+         else
+           /* Record that we've moved forward in the file.  */
+           ++fp->__offset;
+       }
+      else
+       /* Just put C in the buffer.  */
+       *fp->__bufp++ = (unsigned char) c;
+    }
+
+ end:;
+
+  if (!target_set)
+    /* The beginning of the buffer now maps to
+       just past the data we have just written.  */
+    fp->__target = fp->__offset;
+
+  if (!fp->__mode.__write)
+    /* 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))
+    fp->__bufp = fp->__put_limit;
+}
+
+
+/* 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)
+{
+  /* 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;
+
+  if (fp->__io_funcs.__read == NULL)
+    {
+      /* There is no read function, so always return EOF.  */
+      fp->__eof = 1;
+      goto end;
+    }
+
+  if (fp->__buffer == NULL)
+    {
+      /* We're unbuffered, so we want to read only one character.  */
+      buffer = &c;
+      to_read = 1;
+    }
+  else
+    {
+      /* We're buffered, so try to fill the buffer.  */
+      buffer = fp->__buffer;
+      to_read = fp->__bufsize;
+    }
+
+  /* We're reading, so we're not at the end-of-file.  */
+  fp->__eof = 0;
+
+  /* Go to the target file position.  */
+  {
+    int save = errno;
+    if (__stdio_check_offset (fp) == 0 && fp->__target != fp->__offset)
+      {
+       /* Move to a block (buffer size) boundary.  */
+       if (fp->__bufsize != 0)
+         {
+           buffer_offset = fp->__target % fp->__bufsize;
+           fp->__target -= buffer_offset;
+         }
+       seek_to_target (fp);
+      }
+    errno = save;
+  }
+
+  while (!ferror(fp) && !feof(fp) && nread <= buffer_offset)
+    {
+      /* Try to fill the buffer.  */
+      int count = (*fp->__io_funcs.__read)(fp->__cookie, buffer, to_read);
+      if (count == 0)
+       fp->__eof = 1;
+      else if (count < 0)
+       fp->__error = 1;
+      else
+       {
+         buffer += count;
+         nread += count;
+         to_read -= count;
+         /* 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;
+
+  /* Reset the buffer pointer to the beginning of the buffer
+     (plus whatever offset we may have set above).  */
+  fp->__bufp = fp->__buffer + buffer_offset;
+
+ end:;
+
+  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.  */
+      fp->__put_limit = fp->__get_limit = fp->__buffer;
+      return EOF;
+    }
+
+  /* Set the end pointer to one past the last character we read.  */
+  fp->__get_limit = fp->__buffer + nread;
+
+  if (fp->__mode.__write)
+    /* Allow writing into the buffer.  */
+    fp->__put_limit = fp->__buffer + fp->__bufsize;
+  else
+    /* Make it so the next `putc' will call __flshfp.  */
+    fp->__put_limit = fp->__buffer;
+
+  /* Return the first character in the buffer.  */
+  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 =
+  {
+    __stdio_read, __stdio_write, __stdio_seek, __stdio_close
+  };
+
+CONST __room_functions __default_room_functions =
+  {
+    fillbuf, flushbuf
+  };
+
+
+/* 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)
+{
+  int flush_only = c == EOF;
+
+  if (!__validfp(fp) || !fp->__mode.__write)
+    {
+      errno = EINVAL;
+      return EOF;
+    }
+
+  if (ferror(fp))
+    return EOF;
+
+  /* Make sure the stream is initialized (has functions and buffering).  */
+  init_stream(fp);
+
+  if (!flush_only && fp->__get_limit == fp->__buffer &&
+      fp->__bufp > fp->__buffer && fp->__bufp < fp->__buffer + fp->__bufsize)
+    {
+      /* The character will fit in the buffer, so put it there.  */
+      *fp->__bufp++ = (unsigned char) c;
+      if (fp->__linebuf && (unsigned char) c == '\n')
+       flush_only = 1;
+      else
+       return (unsigned char) c;
+    }
+
+  if (fp->__room_funcs.__output == NULL)
+    {
+      /* A NULL `output room' function means
+        to always return an output error.  */
+      fp->__error = 1;
+      return EOF;
+    }
+
+  if (!flush_only || fp->__bufp > fp->__buffer)
+    {
+      if (fp->__linebuf && fp->__bufp > fp->__buffer)
+       /* This is a line-buffered stream, so its put-limit is
+          set to the beginning of the buffer in order to force
+          a __flshfp call on each putc.  We undo this hack here
+          (by setting the limit to the end of the buffer) to simplify
+          the interface with the output-room function.
+          However, we must make sure we don't do this if there isn't
+          actually anything in the buffer, because in that case we
+          want to give the output-room function a chance to prime
+          the stream for writing in whatever fashion turns it on.  */
+       fp->__put_limit = fp->__buffer + fp->__bufsize;
+
+      /* Make room in the buffer.  */
+      (*fp->__room_funcs.__output)(fp, flush_only ? EOF : (unsigned char) c);
+
+      if (fp->__linebuf)
+       /* Set the end pointer to the beginning of the buffer,
+          so the next `putc' call will force a call to this function
+          (see comment above about line-buffered streams).  */
+       fp->__put_limit = fp->__buffer;
+    }
+
+  if (ferror (fp))
+    return EOF;
+  if (flush_only)
+    return 0;
+  return (unsigned char) 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)
+{
+  register int c;
+
+  if (!__validfp(fp) || !fp->__mode.__read)
+    {
+      errno = EINVAL;
+      return EOF;
+    }
+
+  if (fp->__pushed_back)
+    {
+      /* Return the char pushed back by ungetc.  */
+      fp->__bufp = fp->__pushback_bufp;
+      fp->__pushed_back = 0;
+      return fp->__pushback;
+    }
+
+  /* Make sure the stream is initialized (has functions and buffering). */
+  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,
+     we must flush all line-buffered output streams. */
+  if (fp->__buffer == NULL || fp->__linebuf)
+    {
+      register FILE *f;
+      for (f = __stdio_head; f != NULL; f = f->__next)
+       if (__validfp(f) && f->__linebuf && f->__mode.__write &&
+           f->__put_limit > f->__buffer)
+         (void) __flshfp(f, EOF);
+    }
+
+  if (fp->__put_limit > fp->__buffer)
+    {
+      /* There is written data in the buffer.
+        Flush it out.  */
+      if (fp->__room_funcs.__output == NULL)
+       fp->__error = 1;
+      else
+       {
+         fpos_t target = fp->__target;
+         (*fp->__room_funcs.__output)(fp, EOF);
+         fp->__target = target;
+       }
+    }
+
+  /* We want the beginning of the buffer to now
+     map to just past the last data we read.  */
+  fp->__target += fp->__get_limit - fp->__buffer;
+
+  if (ferror(fp))
+    c = EOF;
+  else if (fp->__room_funcs.__input != NULL)
+    {
+      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
+          we have read one character.  The (nonexistent) buffer now
+          maps to the position just past that character.  */
+       ++fp->__target;
+    }
+  else
+    {
+      /* A NULL `input_room' function means always return EOF.  */
+      fp->__eof = 1;
+      c = EOF;
+    }
+
+  return c;
+}
+
+
+/* Nuke a stream, but don't kill its link in the chain.  */
+void
+DEFUN(__invalidate, (stream), register FILE *stream)
+{
+  /* Save its link.  */
+  register FILE *next = stream->__next;
+
+  /* Pulverize the fucker.  */
+  memset((PTR) stream, 0, sizeof(FILE));
+
+  /* Restore the deceased's link.  */
+  stream->__next = next;
+}
+
+
+/* Abort with an error message.  */
+__NORETURN
+void
+DEFUN(__libc_fatal, (message), CONST char *message)
+{
+  __stdio_errmsg(message, strlen(message));
+  abort();
+}