Formerly ../stdio/obstream.c.~3~
authorroland <roland>
Sun, 28 Jun 1992 23:31:47 +0000 (23:31 +0000)
committerroland <roland>
Sun, 28 Jun 1992 23:31:47 +0000 (23:31 +0000)
stdio/obstream.c

index ae4e4c4..9923780 100644 (file)
@@ -21,18 +21,33 @@ Cambridge, MA 02139, USA.  */
 #include <obstack.h>
 #include <stdarg.h>
 
-FILE *obstack_stream __P ((struct obstack *));
+/* Output-room function for obstack streams.  */
 
 static void
 DEFUN(grow, (stream, c), FILE *stream AND int c)
 {
   struct obstack *const obstack = (struct obstack *) stream->__cookie;
-  const size_t bufp = stream->__bufp - stream->__buffer;
 
   /* Move the end of the object back to include only the portion
      of the buffer which the user has already written into.  */ 
   obstack_blank_fast (obstack, - (stream->__put_limit - stream->__bufp));
 
+  if (stream->__target > obstack_object_size (obstack))
+    {
+      /* Our target (where the buffer maps to) is always zero except when
+        the user just did a SEEK_END fseek.  If he sought within the
+        buffer, we need do nothing and will zero the target below.  If he
+        sought past the end of the object, grow and zero-fill the object
+        up to the target address.  */
+
+      obstack_blank (obstack,
+                    stream->__target - obstack_object_size (obstack));
+      /* fseek has just flushed us, so the put limit points
+        to the end of the written data.  */
+      bzero (stream->__put_limit,
+            stream->__target - stream->__bufsize);
+    }
+
   if (c != EOF)
     obstack_1grow (obstack, (unsigned char) c);
 
@@ -42,13 +57,52 @@ DEFUN(grow, (stream, c), FILE *stream AND int c)
      obstack is sync'd so the end of the object points just past the last
      character written to the stream.  */
 
+  stream->__target = stream->__offset = 0;
   stream->__buffer = obstack_base (obstack);
-  stream->__bufsize += obstack_room (obstack);
-  obstack_blank_fast (obstack, stream->__bufsize);
-  stream->__bufp = stream->__buffer + bufp;
+  stream->__bufsize = obstack_room (obstack);
+  stream->__bufp = obstack_next_free (obstack);
   stream->__get_limit = stream->__bufp;
-  stream->__put_limit = stream->__buffer + stream->__bufsize;
+
+  if (c == EOF)
+    /* This is fflush.  Make the stream buffer, the object,
+       and the characters actually written all match.  */
+    stream->__put_limit = stream->__get_limit;
+  else
+    {
+      /* Extend the buffer (and the object) to include
+        the rest of the obstack chunk (which is unitialized).
+        Data past bufp is undefined.  */
+      stream->__put_limit = stream->__buffer + stream->__bufsize;
+      obstack_blank_fast (obstack, stream->__put_limit - stream->__bufp);
+    }
+}
+
+/* Seek function for obstack streams.
+   There is no external state to munge.  */
+
+static int
+DEFUN(seek, (cookie, pos, whence),
+      PTR cookie AND fpos_t *pos AND int whence)
+{
+  switch (whence)
+    {
+    case SEEK_SET:
+    case SEEK_CUR:
+      return 0;
+
+    case SEEK_END:
+      /* Return the position relative to the end of the object.
+        fseek has just flushed us, so the obstack is consistent.  */
+      *pos += obstack_object_size ((struct obstack *) cookie);
+      return 0;
+
+    default:
+      __libc_fatal ("obstream::seek called with bogus WHENCE\n");
+      return -1;
+    }
 }
+\f
+/* Initialize STREAM to talk to OBSTACK.  */
 
 static void
 DEFUN(init_obstream, (stream, obstack),
@@ -60,14 +114,14 @@ DEFUN(init_obstream, (stream, obstack),
   /* Input gets EOF.  */
   stream->__room_funcs.__input = NULL;
 
-  /* When the buffer is full, grow the obstack.  */
-  stream->__room_funcs.__output = grow;
-
   /* Do nothing for close.  */
   stream->__io_funcs.__close = NULL;
 
-  /* Can't seek outside the buffer.  */
-  stream->__io_funcs.__seek = NULL;
+  /* When the buffer is full, grow the obstack.  */
+  stream->__room_funcs.__output = grow;
+
+  /* Seek within the object, and extend it.  */
+  stream->__io_funcs.__seek = seek;
   stream->__target = stream->__offset = 0;
 
   stream->__seen = 1;