libio/streambuf.cc

   1 /* This is part of libio/iostream, providing -*- C++ -*- input/output.
   2 Copyright (C) 1991, 1992, 1993, 1995 Free Software Foundation
   3
   4 This file is part of the GNU IO Library.  This library is free
   5 software; you can redistribute it and/or modify it under the
   6 terms of the GNU General Public License as published by the
   7 Free Software Foundation; either version 2, or (at your option)
   8 any later version.
   9
  10 This library is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with this library; see the file COPYING.  If not, write to the Free
  17 Software Foundation, 59 Temple Place - Suite 330, Boston, 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 not cause
  21 the resulting executable to be covered by the GNU General Public License.
  22 This exception does not however invalidate any other reasons why
  23 the executable file might be covered by the GNU General Public License. */
  24
  25 /* Written by Per Bothner (bothner@cygnus.com). */
  26
  27 #define _STREAM_COMPAT
  28 #ifdef __GNUG__
  29 #pragma implementation
  30 #endif
  31 #include "iostreamP.h"
  32 #include <string.h>
  33 #include <stdarg.h>
  34 #include <errno.h>
  35 #ifndef errno
  36 extern int errno;
  37 #endif
  38
  39 void streambuf::_un_link() { _IO_un_link(this); }
  40
  41 void streambuf::_link_in() { _IO_link_in(this); }
  42
  43 int streambuf::switch_to_get_mode()
  44 { return _IO_switch_to_get_mode(this); }
  45
  46 void streambuf::free_backup_area()
  47 { _IO_free_backup_area(this); }
  48
  49 #if 0
  50 int streambuf::switch_to_put_mode()
  51 { return _IO_:switch_to_put_mode(this); }
  52 #endif
  53
  54 int __overflow(streambuf* sb, int c)
  55 {
  56     return sb->overflow(c);
  57 }
  58
  59 int streambuf::underflow()
  60 { return EOF; }
  61
  62 int streambuf::uflow()
  63 { return _IO_default_uflow (this); }
  64
  65 int streambuf::overflow(int /* = EOF */)
  66 { return EOF; }
  67
  68 streamsize streambuf::xsputn(register const char* s, streamsize n)
  69 { return _IO_default_xsputn(this, s, n); }
  70
  71 streamsize streambuf::xsgetn(char* s, streamsize n)
  72 { return _IO_default_xsgetn(this, s, n); }
  73
  74 int streambuf::ignore(int n)
  75 {
  76     register int more = n;
  77     for (;;) {
  78         int count = _IO_read_end - _IO_read_ptr; // Data available.
  79         if (count > 0) {
  80             if (count > more)
  81                 count = more;
  82             _IO_read_ptr += count;
  83             more -= count;
  84         }
  85         if (more == 0 || __underflow(this) == EOF)
  86             break;
  87     }
  88     return n - more;
  89 }
  90
  91 int streambuf::sync()
  92 {
  93   return 0;
  94 }
  95
  96 int streambuf::pbackfail(int c)
  97 {
  98   return _IO_default_pbackfail(this, c);
  99 }
 100
 101 streambuf* streambuf::setbuf(char* p, int len)
 102 {
 103     if (sync() == EOF)
 104         return NULL;
 105     if (p == NULL || len == 0) {
 106         unbuffered(1);
 107         setb(_shortbuf, _shortbuf+1, 0);
 108     }
 109     else {
 110         unbuffered(0);
 111         setb(p, p+len, 0);
 112     }
 113     setp(0, 0);
 114     setg(0, 0, 0);
 115     return this;
 116 }
 117
 118 streampos streambuf::seekpos(streampos pos, int mode)
 119 {
 120     return seekoff(pos, ios::beg, mode);
 121 }
 122
 123 streampos streambuf::sseekpos(streampos pos, int mode)
 124 {
 125   return _IO_seekpos (this, pos, mode);
 126 }
 127
 128 void streambuf::setb(char* b, char* eb, int a)
 129 { _IO_setb(this, b, eb, a); }
 130
 131 int streambuf::doallocate() { return _IO_default_doallocate(this); }
 132
 133 void streambuf::doallocbuf() { _IO_doallocbuf(this); }
 134
 135 #if !_IO_UNIFIED_JUMPTABLES
 136 /* The following are jump table entries that just call the virtual method */
 137
 138 static int _IO_sb_overflow(_IO_FILE *fp, int c)
 139 { return ((streambuf*)fp)->overflow(c); }
 140 static int _IO_sb_underflow(_IO_FILE *fp)
 141 { return ((streambuf*)fp)->underflow(); }
 142 static _IO_size_t _IO_sb_xsputn(_IO_FILE *fp, const void *s, _IO_size_t n)
 143 { return ((streambuf*)fp)->xsputn((const char*)s, n); }
 144 static _IO_size_t _IO_sb_xsgetn(_IO_FILE *fp, void *s, _IO_size_t n)
 145 { return ((streambuf*)fp)->xsgetn((char*)s, n); }
 146 static int _IO_sb_close(_IO_FILE *fp)
 147 { return ((streambuf*)fp)->sys_close(); }
 148 static int _IO_sb_stat(_IO_FILE *fp, void *b)
 149 { return ((streambuf*)fp)->sys_stat(b); }
 150 static int _IO_sb_doallocate(_IO_FILE *fp)
 151 { return ((streambuf*)fp)->doallocate(); }
 152
 153 static _IO_pos_t _IO_sb_seekoff(_IO_FILE *fp, _IO_off_t pos, int dir, int mode)
 154 {
 155   return ((streambuf*)fp)->seekoff(pos, (ios::seek_dir)dir, mode);
 156 }
 157
 158 static _IO_pos_t _IO_sb_seekpos(_IO_FILE *fp, _IO_pos_t pos, int mode)
 159 {
 160   return ((streambuf*)fp)->seekpos(pos, mode);
 161 }
 162
 163 static int _IO_sb_pbackfail(_IO_FILE *fp, int ch)
 164 { return ((streambuf*)fp)->pbackfail(ch); }
 165 static void _IO_sb_finish(_IO_FILE *fp, int)
 166 { ((streambuf*)fp)->~streambuf(); }
 167 static _IO_ssize_t _IO_sb_read(_IO_FILE *fp, void *buf, _IO_ssize_t n)
 168 { return ((streambuf*)fp)->sys_read((char*)buf, n); }
 169 static _IO_ssize_t _IO_sb_write(_IO_FILE *fp, const void *buf, _IO_ssize_t n)
 170 { return ((streambuf*)fp)->sys_write((const char*)buf, n); }
 171 static int _IO_sb_sync(_IO_FILE *fp)
 172 { return ((streambuf*)fp)->sync(); }
 173 static _IO_pos_t _IO_sb_seek(_IO_FILE *fp, _IO_off_t off, int dir)
 174 { return ((streambuf*)fp)->sys_seek(off, (_seek_dir)dir); }
 175 static _IO_FILE* _IO_sb_setbuf(_IO_FILE *fp, char *buf, _IO_ssize_t n)
 176 { return ((streambuf*)fp)->setbuf(buf, n); }
 177
 178 /* This callbacks in this jumptable just call the corresponding
 179    virtual function, so that C functions can access (potentially user-defined)
 180    streambuf-derived objects.
 181    Contrast the builtinbuf class, which does the converse:  Allow
 182    C++ virtual calls to to be used on _IO_FILE objects that are builtin
 183    (or defined by C code). */
 184
 185
 186 struct _IO_jump_t _IO_streambuf_jumps = {
 187   JUMP_INIT_DUMMY,
 188   JUMP_INIT(finish, _IO_sb_finish),
 189   JUMP_INIT(overflow, _IO_sb_overflow),
 190   JUMP_INIT(underflow, _IO_sb_underflow),
 191   JUMP_INIT(uflow, _IO_default_uflow),
 192   JUMP_INIT(pbackfail, _IO_sb_pbackfail),
 193   JUMP_INIT(xsputn, _IO_sb_xsputn),
 194   JUMP_INIT(xsgetn, _IO_sb_xsgetn),
 195   JUMP_INIT(seekoff, _IO_sb_seekoff),
 196   JUMP_INIT(seekpos, _IO_sb_seekpos),
 197   JUMP_INIT(setbuf, _IO_sb_setbuf),
 198   JUMP_INIT(sync, _IO_sb_sync),
 199   JUMP_INIT(doallocate, _IO_sb_doallocate),
 200   JUMP_INIT(read, _IO_sb_read),
 201   JUMP_INIT(write, _IO_sb_write),
 202   JUMP_INIT(seek, _IO_sb_seek),
 203   JUMP_INIT(close, _IO_sb_close),
 204   JUMP_INIT(stat, _IO_sb_stat)
 205 };
 206 #endif
 207
 208 streambuf::streambuf(int flags)
 209 {
 210 #ifdef _IO_MTSAFE_IO
 211   _lock = new _IO_lock_t;
 212 #endif
 213   _IO_init(this, flags);
 214 #if !_IO_UNIFIED_JUMPTABLES
 215   _jumps = &_IO_streambuf_jumps;
 216 #endif
 217 }
 218
 219 streambuf::~streambuf()
 220 {
 221   _IO_default_finish(this,0);
 222 #ifdef _IO_MTSAFE_IO
 223   delete _lock;
 224 #endif
 225 }
 226
 227 streampos
 228 streambuf::seekoff(streamoff, _seek_dir, int /*=ios::in|ios::out*/)
 229 {
 230     return EOF;
 231 }
 232
 233 streampos
 234 streambuf::sseekoff(streamoff o , _seek_dir d, int m /*=ios::in|ios::out*/)
 235 {
 236   return _IO_seekoff (this, o, d, m);
 237 }
 238
 239 int streambuf::sputbackc(char c)
 240 {
 241   return _IO_sputbackc(this, c);
 242 }
 243
 244 int streambuf::sungetc()
 245 {
 246   return _IO_sungetc(this);
 247 }
 248
 249 #if 0 /* Work in progress */
 250 void streambuf::collumn(int c)
 251 {
 252     if (c == -1)
 253         _collumn = -1;
 254     else
 255         _collumn = c - (_IO_write_ptr - _IO_write_base);
 256 }
 257 #endif
 258
 259
 260 int streambuf::get_column()
 261 {
 262     if (_cur_column)
 263         return _IO_adjust_column(_cur_column - 1, pbase(), pptr() - pbase());
 264     return -1;
 265 }
 266
 267 int streambuf::set_column(int i)
 268 {
 269     _cur_column = i+1;
 270     return 0;
 271 }
 272
 273 int streambuf::flush_all() { return _IO_flush_all (); }
 274
 275 void streambuf::flush_all_linebuffered()
 276 { _IO_flush_all_linebuffered(); }
 277
 278 int streambuf::sys_stat(void *)
 279 {
 280 #ifdef EIO
 281   errno = EIO;
 282 #endif
 283   return -1;
 284 }
 285
 286 streamsize streambuf::sys_read(char* /*buf*/, streamsize /*size*/)
 287 {
 288   return 0;
 289 }
 290
 291 streamsize streambuf::sys_write(const char* /*buf*/, streamsize /*size*/)
 292 {
 293   return 0;
 294 }
 295
 296 streampos streambuf::sys_seek(streamoff, _seek_dir)
 297 {
 298   return EOF;
 299 }
 300
 301 int streambuf::sys_close() { return 0; /* Suceess; do nothing */ }
 302
 303 streammarker::streammarker(streambuf *sb)
 304 {
 305   _IO_init_marker(this, sb);
 306 }
 307
 308 streammarker::~streammarker()
 309 {
 310   _IO_remove_marker(this);
 311 }
 312
 313 #define BAD_DELTA EOF
 314
 315 int streammarker::delta(streammarker& other_mark)
 316 {
 317   return _IO_marker_difference(this, &other_mark);
 318 }
 319
 320 int streammarker::delta()
 321 {
 322   return _IO_marker_delta(this);
 323 }
 324
 325 int streambuf::seekmark(streammarker& mark, int delta /* = 0 */)
 326 {
 327   return _IO_seekmark(this, &mark, delta);
 328 }
 329
 330 void streambuf::unsave_markers()
 331 {
 332   _IO_unsave_markers(this);
 333 }
 334
 335 int ios::readable() { return !(rdbuf()->_flags & _IO_NO_READS); }
 336 int ios::writable() { return !(rdbuf()->_flags & _IO_NO_WRITES); }
 337 int ios::is_open() { return rdbuf()
 338                          && (rdbuf()->_flags & _IO_NO_READS+_IO_NO_WRITES)
 339                              != _IO_NO_READS+_IO_NO_WRITES; }
 340
 341 #if defined(linux)
 342 #define IO_CLEANUP
 343 #endif
 344
 345 #ifdef IO_CLEANUP
 346   IO_CLEANUP
 347 #else
 348 struct __io_defs {
 349     ~__io_defs() { _IO_cleanup (); }
 350 };
 351 __io_defs io_defs__;
 352 #endif