libio/strops.c

   1 /* Copyright (C) 1993, 1997 Free Software Foundation, Inc.
   2    This file is part of the GNU IO Library.
   3
   4    This library is free software; you can redistribute it and/or
   5    modify it under the terms of the GNU General Public License as
   6    published by the Free Software Foundation; either version 2, or (at
   7    your option) any later version.
   8
   9    This library is distributed in the hope that it will be useful, but
  10    WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12    General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this library; see the file COPYING.  If not, write to
  16    the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
  17    MA 02111-1307, USA.
  18
  19    As a special exception, if you link this library with files
  20    compiled with a GNU compiler to produce an executable, this does
  21    not cause the resulting executable to be covered by the GNU General
  22    Public License.  This exception does not however invalidate any
  23    other reasons why the executable file might be covered by the GNU
  24    General Public License.  */
  25
  26 #include "strfile.h"
  27 #include "libioP.h"
  28 #include <string.h>
  29
  30 #if 0
  31 /* The following definitions are for exposition only.
  32    They map the terminology used in the ANSI/ISO C++ draft standard
  33    to the implementation. */
  34
  35 /* allocated:  set  when a dynamic array object has been allocated, and
  36    hence should be freed by the destructor for the strstreambuf object. */
  37 #define ALLOCATED(FP) ((FP)->_f._IO_buf_base && DYNAMIC(FP))
  38
  39 /* constant:  set when the array object has const elements,
  40    so the output sequence cannot be written. */
  41 #define CONSTANT(FP) ((FP)->_f._IO_file_flags & _IO_NO_WRITES)
  42
  43 /* alsize:  the suggested minimum size for a dynamic array object. */
  44 #define ALSIZE(FP) ??? /* not stored */
  45
  46 /* palloc: points to the function to call to allocate a dynamic array object.*/
  47 #define PALLOC(FP) \
  48   ((FP)->_s._allocate_buffer == default_alloc ? 0 : (FP)->_s._allocate_buffer)
  49
  50 /* pfree: points  to  the  function  to call to free a dynamic array object. */
  51 #define PFREE(FP) \
  52   ((FP)->_s._free_buffer == default_free ? 0 : (FP)->_s._free_buffer)
  53
  54 #endif
  55
  56 #ifdef TODO
  57 /* An "unbounded buffer" is when a buffer is supplied, but with no
  58    specified length.  An example is the buffer argument to sprintf.
  59    */
  60 #endif
  61
  62 void
  63 _IO_str_init_static (fp, ptr, size, pstart)
  64      _IO_FILE *fp;
  65      char *ptr;
  66      int size;
  67      char *pstart;
  68 {
  69   if (size == 0)
  70     size = strlen (ptr);
  71   else if (size < 0)
  72     {
  73       /* If size is negative 'the characters are assumed to
  74          continue indefinitely.'  This is kind of messy ... */
  75       int s;
  76       size = 512;
  77       /* Try increasing powers of 2, as long as we don't wrap around. */
  78       for (; s = 2*size, s > 0 && ptr + s > ptr && s < 0x4000000L; )
  79         size = s;
  80       /* Try increasing size as much as we can without wrapping around. */
  81       for (s = size >> 1; s > 0; s >>= 1)
  82         {
  83           if (ptr + size + s > ptr)
  84             size += s;
  85         }
  86     }
  87   _IO_setb (fp, ptr, ptr + size, 0);
  88
  89   fp->_IO_write_base = ptr;
  90   fp->_IO_read_base = ptr;
  91   fp->_IO_read_ptr = ptr;
  92   if (pstart)
  93     {
  94       fp->_IO_write_ptr = pstart;
  95       fp->_IO_write_end = ptr + size;
  96       fp->_IO_read_end = pstart;
  97     }
  98   else
  99     {
 100       fp->_IO_write_ptr = ptr;
 101       fp->_IO_write_end = ptr;
 102       fp->_IO_read_end = ptr+size;
 103     }
 104   /* A null _allocate_buffer function flags the strfile as being static. */
 105   (((_IO_strfile *) fp)->_s._allocate_buffer) =  (_IO_alloc_type)0;
 106 }
 107
 108 void
 109 _IO_str_init_readonly (fp, ptr, size)
 110      _IO_FILE *fp;
 111      const char *ptr;
 112      int size;
 113 {
 114   _IO_str_init_static (fp, (char *) ptr, size, NULL);
 115   fp->_IO_file_flags |= _IO_NO_WRITES;
 116 }
 117
 118 int
 119 _IO_str_overflow (fp, c)
 120      _IO_FILE *fp;
 121      int c;
 122 {
 123   int flush_only = c == EOF;
 124   _IO_size_t pos;
 125   if (fp->_flags & _IO_NO_WRITES)
 126       return flush_only ? 0 : EOF;
 127   if ((fp->_flags & _IO_TIED_PUT_GET) && !(fp->_flags & _IO_CURRENTLY_PUTTING))
 128     {
 129       fp->_flags |= _IO_CURRENTLY_PUTTING;
 130       fp->_IO_write_ptr = fp->_IO_read_ptr;
 131       fp->_IO_read_ptr = fp->_IO_read_end;
 132     }
 133   pos =  fp->_IO_write_ptr - fp->_IO_write_base;
 134   if (pos >= (_IO_size_t) (_IO_blen (fp) + flush_only))
 135     {
 136       if (fp->_flags & _IO_USER_BUF) /* not allowed to enlarge */
 137         return EOF;
 138       else
 139         {
 140           char *new_buf;
 141           char *old_buf = fp->_IO_buf_base;
 142           _IO_size_t new_size = 2 * _IO_blen (fp) + 100;
 143           new_buf
 144             = (char *) (*((_IO_strfile *) fp)->_s._allocate_buffer) (new_size);
 145           if (new_buf == NULL)
 146             {
 147               /*          __ferror(fp) = 1; */
 148               return EOF;
 149             }
 150           if (fp->_IO_buf_base)
 151             {
 152               memcpy (new_buf, old_buf, _IO_blen (fp));
 153               (*((_IO_strfile *) fp)->_s._free_buffer) (fp->_IO_buf_base);
 154               /* Make sure _IO_setb won't try to delete _IO_buf_base. */
 155               fp->_IO_buf_base = NULL;
 156             }
 157 #if 0
 158           if (lenp == &LEN(fp)) /* use '\0'-filling */
 159               memset (new_buf + pos, 0, blen() - pos);
 160 #endif
 161           _IO_setb (fp, new_buf, new_buf + new_size, 1);
 162           fp->_IO_read_base = new_buf + (fp->_IO_read_base - old_buf);
 163           fp->_IO_read_ptr = new_buf + (fp->_IO_read_ptr - old_buf);
 164           fp->_IO_read_end = new_buf + (fp->_IO_read_end - old_buf);
 165           fp->_IO_write_ptr = new_buf + (fp->_IO_write_ptr - old_buf);
 166
 167           fp->_IO_write_base = new_buf;
 168           fp->_IO_write_end = fp->_IO_buf_end;
 169         }
 170     }
 171
 172   if (!flush_only)
 173     *fp->_IO_write_ptr++ = (unsigned char) c;
 174   if (fp->_IO_write_ptr > fp->_IO_read_end)
 175     fp->_IO_read_end = fp->_IO_write_ptr;
 176   return c;
 177 }
 178
 179 int
 180 _IO_str_underflow (fp)
 181      _IO_FILE *fp;
 182 {
 183   if (fp->_IO_write_ptr > fp->_IO_read_end)
 184     fp->_IO_read_end = fp->_IO_write_ptr;
 185   if ((fp->_flags & _IO_TIED_PUT_GET) && (fp->_flags & _IO_CURRENTLY_PUTTING))
 186     {
 187       fp->_flags &= ~_IO_CURRENTLY_PUTTING;
 188       fp->_IO_read_ptr = fp->_IO_write_ptr;
 189       fp->_IO_write_ptr = fp->_IO_write_end;
 190     }
 191   if (fp->_IO_read_ptr < fp->_IO_read_end)
 192     return *fp->_IO_read_ptr;
 193   else
 194     return EOF;
 195 }
 196
 197 /* The size of the valid part of the buffer.  */
 198
 199 _IO_ssize_t
 200 _IO_str_count (fp)
 201      _IO_FILE *fp;
 202 {
 203   return ((fp->_IO_write_end > fp->_IO_read_end
 204            ? fp->_IO_write_end : fp->_IO_read_end)
 205           - fp->_IO_read_base);
 206 }
 207
 208 _IO_pos_t
 209 _IO_str_seekoff (fp, offset, dir, mode)
 210      _IO_FILE *fp;
 211      _IO_off_t offset;
 212      int dir;
 213      int mode;
 214 {
 215   _IO_ssize_t cur_size = _IO_str_count (fp);
 216   _IO_pos_t new_pos = EOF;
 217
 218   /* Move the get pointer, if requested. */
 219   if (mode & _IOS_INPUT)
 220     {
 221       switch (dir)
 222         {
 223         case _IO_seek_end:
 224           offset += cur_size;
 225           break;
 226         case _IO_seek_cur:
 227           offset += fp->_IO_read_ptr - fp->_IO_read_base;
 228           break;
 229         default: /* case _IO_seek_set: */
 230           break;
 231         }
 232       if (offset < 0 || (_IO_ssize_t) offset > cur_size)
 233         return EOF;
 234       fp->_IO_read_ptr = fp->_IO_read_base + offset;
 235       fp->_IO_read_end = fp->_IO_read_base + cur_size;
 236       new_pos = offset;
 237     }
 238
 239   /* Move the put pointer, if requested. */
 240   if (mode & _IOS_OUTPUT)
 241     {
 242       switch (dir)
 243         {
 244         case _IO_seek_end:
 245           offset += cur_size;
 246           break;
 247         case _IO_seek_cur:
 248           offset += fp->_IO_write_ptr - fp->_IO_write_base;
 249           break;
 250         default: /* case _IO_seek_set: */
 251           break;
 252         }
 253       if (offset < 0 || (_IO_ssize_t) offset > cur_size)
 254         return EOF;
 255       fp->_IO_write_ptr = fp->_IO_write_base + offset;
 256       new_pos = offset;
 257     }
 258   return new_pos;
 259 }
 260
 261 int
 262 _IO_str_pbackfail (fp, c)
 263      _IO_FILE *fp;
 264      int c;
 265 {
 266   if ((fp->_flags & _IO_NO_WRITES) && c != EOF)
 267     return EOF;
 268   return _IO_default_pbackfail (fp, c);
 269 }
 270
 271 void
 272 _IO_str_finish (fp, dummy)
 273      _IO_FILE *fp;
 274      int dummy;
 275 {
 276   if (fp->_IO_buf_base && !(fp->_flags & _IO_USER_BUF))
 277     (((_IO_strfile *) fp)->_s._free_buffer) (fp->_IO_buf_base);
 278   fp->_IO_buf_base = NULL;
 279
 280   _IO_default_finish (fp, 0);
 281 }
 282
 283 struct _IO_jump_t _IO_str_jumps =
 284 {
 285   JUMP_INIT_DUMMY,
 286   JUMP_INIT(finish, _IO_str_finish),
 287   JUMP_INIT(overflow, _IO_str_overflow),
 288   JUMP_INIT(underflow, _IO_str_underflow),
 289   JUMP_INIT(uflow, _IO_default_uflow),
 290   JUMP_INIT(pbackfail, _IO_str_pbackfail),
 291   JUMP_INIT(xsputn, _IO_default_xsputn),
 292   JUMP_INIT(xsgetn, _IO_default_xsgetn),
 293   JUMP_INIT(seekoff, _IO_str_seekoff),
 294   JUMP_INIT(seekpos, _IO_default_seekpos),
 295   JUMP_INIT(setbuf, _IO_default_setbuf),
 296   JUMP_INIT(sync, _IO_default_sync),
 297   JUMP_INIT(doallocate, _IO_default_doallocate),
 298   JUMP_INIT(read, _IO_default_read),
 299   JUMP_INIT(write, _IO_default_write),
 300   JUMP_INIT(seek, _IO_default_seek),
 301   JUMP_INIT(close, _IO_default_close),
 302   JUMP_INIT(stat, _IO_default_stat)
 303 };