stdio/memstream.c

   1 /* Copyright (C) 1991, 92, 94, 95, 96 Free Software Foundation, Inc.
   2 This file is part of the GNU C Library.
   3
   4 The GNU C Library is free software; you can redistribute it and/or
   5 modify it under the terms of the GNU Library General Public License as
   6 published by the Free Software Foundation; either version 2 of the
   7 License, or (at your option) any later version.
   8
   9 The GNU C Library is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12 Library General Public License for more details.
  13
  14 You should have received a copy of the GNU Library General Public
  15 License along with the GNU C Library; see the file COPYING.LIB.  If
  16 not, write to the Free Software Foundation, Inc., 675 Mass Ave,
  17 Cambridge, MA 02139, USA.  */
  18
  19 #include <stdio.h>
  20 #include <stdlib.h>
  21 #include <string.h>
  22 #include <errno.h>
  23
  24 struct memstream_info
  25   {
  26     char **buffer;
  27     size_t *bufsize;
  28   };
  29
  30 /* Enlarge STREAM's buffer.  */
  31 static void
  32 enlarge_buffer (stream, c)
  33      register FILE *stream;
  34      int c;
  35 {
  36   struct memstream_info *info = (struct memstream_info *) stream->__cookie;
  37   size_t need;
  38
  39   if (stream->__put_limit != stream->__buffer)
  40     /* Record how much has actually been written into the buffer.  */
  41     *info->bufsize = stream->__bufp - stream->__buffer;
  42
  43   if (stream->__target != -1
  44       && stream->__target > *info->bufsize)
  45     /* Our target (where the buffer maps to) is always zero except when
  46        the user just did a SEEK_END fseek.  If he sought within the
  47        buffer, we need do nothing and will zero the target below.  If he
  48        sought past the end of the object, grow and zero-fill the buffer
  49        up to the target address.  */
  50     need = stream->__target;
  51   else
  52     need = *info->bufsize;
  53
  54   /* We always need an extra character in the buffer.  Either we are
  55      writing C, or we are flushing and need to write a NUL terminator.  */
  56   ++need;
  57
  58   if (stream->__bufsize < need)
  59     {
  60       /* Enlarge the buffer.  */
  61       char *newbuf;
  62       size_t newsize;
  63       if (stream->__bufsize * 2 < need)
  64         newsize = need;
  65       else
  66         newsize = stream->__bufsize * 2;
  67       newbuf = (char *) realloc ((void *) stream->__buffer, newsize);
  68       if (newbuf == NULL)
  69         {
  70           stream->__error = 1;
  71           return;
  72         }
  73       *info->buffer = stream->__buffer = newbuf;
  74       stream->__bufsize = newsize;
  75     }
  76
  77   stream->__target = stream->__offset = 0;
  78   stream->__get_limit = stream->__bufp = stream->__buffer + *info->bufsize;
  79   stream->__put_limit = stream->__buffer + stream->__bufsize;
  80
  81   need -= stream->__bufp - stream->__buffer + 1;
  82   if (need > 0)
  83     {
  84       /* We are extending the buffer after an fseek; zero-fill new space.  */
  85       memset (stream->__bufp, '\0', need);
  86       stream->__bufp += need;
  87     }
  88
  89   if (c != EOF)
  90     *stream->__bufp++ = (unsigned char) c;
  91   else
  92     *stream->__bufp = '\0';
  93 }
  94
  95 /* Seek function for memstreams.
  96    There is no external state to munge.  */
  97
  98 static int
  99 seek (cookie, pos, whence)
 100      void *cookie;
 101      fpos_t *pos;
 102      int whence;
 103 {
 104   switch (whence)
 105     {
 106     case SEEK_SET:
 107     case SEEK_CUR:
 108       return 0;
 109
 110     case SEEK_END:
 111       /* Return the position relative to the end of the object.
 112          fseek has just flushed us, so the info is consistent.  */
 113       *pos += *((struct memstream_info *) cookie)->bufsize;
 114       return 0;
 115
 116     default:
 117       __libc_fatal ("memstream::seek called with bogus WHENCE\n");
 118       return -1;
 119     }
 120 }
 121
 122 static int
 123 free_info (cookie)
 124      void *cookie;
 125 {
 126 #if 0
 127   struct memstream_info *info = (struct memstream_info *) cookie;
 128   char *buf;
 129
 130   buf = (char *) realloc ((PTR) *info->buffer, *info->bufsize);
 131   if (buf != NULL)
 132     *info->buffer = buf;
 133 #endif
 134
 135   free (cookie);
 136
 137   return 0;
 138 }
 139 \f
 140 /* Open a stream that writes into a malloc'd buffer that is expanded as
 141    necessary.  *BUFLOC and *SIZELOC are updated with the buffer's location
 142    and the number of characters written on fflush or fclose.  */
 143 FILE *
 144 open_memstream (bufloc, sizeloc)
 145      char **bufloc;
 146      size_t *sizeloc;
 147 {
 148   FILE *stream;
 149   struct memstream_info *info;
 150
 151   if (bufloc == NULL || sizeloc == NULL)
 152     {
 153       __set_errno (EINVAL);
 154       return NULL;
 155     }
 156
 157   stream = fmemopen ((char *) NULL, BUFSIZ, "w+");
 158   if (stream == NULL)
 159     return NULL;
 160
 161   info = (struct memstream_info *) malloc (sizeof (struct memstream_info));
 162   if (info == NULL)
 163     {
 164       int save = errno;
 165       (void) fclose (stream);
 166       __set_errno (save);
 167       return NULL;
 168     }
 169
 170   stream->__room_funcs.__output = enlarge_buffer;
 171   stream->__io_funcs.__seek = seek;
 172   stream->__io_funcs.__close = free_info;
 173   stream->__cookie = (void *) info;
 174   stream->__userbuf = 1;
 175
 176   info->buffer = bufloc;
 177   info->bufsize = sizeloc;
 178
 179   *bufloc = stream->__buffer;
 180
 181   return stream;
 182 }