libio/strops.c

   1 /* Copyright (C) 1993, 1997, 1998 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 *((unsigned char *) 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_ptr > fp->_IO_read_end
 204            ? fp->_IO_write_ptr : fp->_IO_read_end)
 205           - fp->_IO_read_base);
 206 }
 207
 208 _IO_fpos64_t
 209 _IO_str_seekoff (fp, offset, dir, mode)
 210      _IO_FILE *fp;
 211      _IO_off64_t offset;
 212      int dir;
 213      int mode;
 214 {
 215   _IO_fpos64_t new_pos;
 216
 217   if (mode == 0 && (fp->_flags & _IO_TIED_PUT_GET))
 218     mode = (fp->_flags & _IO_CURRENTLY_PUTTING ? _IOS_OUTPUT : _IOS_INPUT);
 219
 220   if (mode == 0)
 221     {
 222       /* Don't move any pointers. But there is no clear indication what
 223          mode FP is in. Let's guess. */
 224       if (fp->_IO_file_flags & _IO_NO_WRITES)
 225         new_pos = fp->_IO_read_ptr - fp->_IO_read_base;
 226       else
 227         new_pos = fp->_IO_write_ptr - fp->_IO_write_base;
 228     }
 229   else
 230     {
 231       _IO_ssize_t cur_size = _IO_str_count(fp);
 232       new_pos = EOF;
 233
 234       /* Move the get pointer, if requested. */
 235       if (mode & _IOS_INPUT)
 236         {
 237           switch (dir)
 238             {
 239             case _IO_seek_end:
 240               offset += cur_size;
 241               break;
 242             case _IO_seek_cur:
 243               offset += fp->_IO_read_ptr - fp->_IO_read_base;
 244               break;
 245             default: /* case _IO_seek_set: */
 246               break;
 247             }
 248           if (offset < 0 || (_IO_ssize_t) offset > cur_size)
 249             return EOF;
 250           fp->_IO_read_ptr = fp->_IO_read_base + offset;
 251           fp->_IO_read_end = fp->_IO_read_base + cur_size;
 252           new_pos = offset;
 253         }
 254
 255       /* Move the put pointer, if requested. */
 256       if (mode & _IOS_OUTPUT)
 257         {
 258           switch (dir)
 259             {
 260             case _IO_seek_end:
 261               offset += cur_size;
 262               break;
 263             case _IO_seek_cur:
 264               offset += fp->_IO_write_ptr - fp->_IO_write_base;
 265               break;
 266             default: /* case _IO_seek_set: */
 267               break;
 268             }
 269           if (offset < 0 || (_IO_ssize_t) offset > cur_size)
 270             return EOF;
 271           fp->_IO_write_ptr = fp->_IO_write_base + offset;
 272           new_pos = offset;
 273         }
 274     }
 275   return new_pos;
 276 }
 277
 278 int
 279 _IO_str_pbackfail (fp, c)
 280      _IO_FILE *fp;
 281      int c;
 282 {
 283   if ((fp->_flags & _IO_NO_WRITES) && c != EOF)
 284     return EOF;
 285   return _IO_default_pbackfail (fp, c);
 286 }
 287
 288 void
 289 _IO_str_finish (fp, dummy)
 290      _IO_FILE *fp;
 291      int dummy;
 292 {
 293   if (fp->_IO_buf_base && !(fp->_flags & _IO_USER_BUF))
 294     (((_IO_strfile *) fp)->_s._free_buffer) (fp->_IO_buf_base);
 295   fp->_IO_buf_base = NULL;
 296
 297   _IO_default_finish (fp, 0);
 298 }
 299
 300 struct _IO_jump_t _IO_str_jumps =
 301 {
 302   JUMP_INIT_DUMMY,
 303   JUMP_INIT(finish, _IO_str_finish),
 304   JUMP_INIT(overflow, _IO_str_overflow),
 305   JUMP_INIT(underflow, _IO_str_underflow),
 306   JUMP_INIT(uflow, _IO_default_uflow),
 307   JUMP_INIT(pbackfail, _IO_str_pbackfail),
 308   JUMP_INIT(xsputn, _IO_default_xsputn),
 309   JUMP_INIT(xsgetn, _IO_default_xsgetn),
 310   JUMP_INIT(seekoff, _IO_str_seekoff),
 311   JUMP_INIT(seekpos, _IO_default_seekpos),
 312   JUMP_INIT(setbuf, _IO_default_setbuf),
 313   JUMP_INIT(sync, _IO_default_sync),
 314   JUMP_INIT(doallocate, _IO_default_doallocate),
 315   JUMP_INIT(read, _IO_default_read),
 316   JUMP_INIT(write, _IO_default_write),
 317   JUMP_INIT(seek, _IO_default_seek),
 318   JUMP_INIT(close, _IO_default_close),
 319   JUMP_INIT(stat, _IO_default_stat),
 320   JUMP_INIT(showmanyc, _IO_default_showmanyc),
 321   JUMP_INIT(imbue, _IO_default_imbue)
 322 };