Daily bump.
[official-gcc.git] / libio / streambuf.cc
blob057d1e6e4ce9bca11feeff1dbd69bb33f8b06e6e
1 /* This is part of libio/iostream, providing -*- C++ -*- input/output.
2 Copyright (C) 1991, 1992, 1993, 1995 Free Software Foundation
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.
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.
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.
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. */
25 /* Written by Per Bothner (bothner@cygnus.com). */
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
39 void streambuf::_un_link() { _IO_un_link(this); }
41 void streambuf::_link_in() { _IO_link_in(this); }
43 int streambuf::switch_to_get_mode()
44 { return _IO_switch_to_get_mode(this); }
46 void streambuf::free_backup_area()
47 { _IO_free_backup_area(this); }
49 #if 0
50 int streambuf::switch_to_put_mode()
51 { return _IO_:switch_to_put_mode(this); }
52 #endif
54 int __overflow(streambuf* sb, int c)
56 return sb->overflow(c);
59 int streambuf::underflow()
60 { return EOF; }
62 int streambuf::uflow()
63 { return _IO_default_uflow (this); }
65 int streambuf::overflow(int /* = EOF */)
66 { return EOF; }
68 streamsize streambuf::xsputn(register const char* s, streamsize n)
69 { return _IO_default_xsputn(this, s, n); }
71 streamsize streambuf::xsgetn(char* s, streamsize n)
72 { return _IO_default_xsgetn(this, s, n); }
74 int streambuf::ignore(int n)
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;
85 if (more == 0 || __underflow(this) == EOF)
86 break;
88 return n - more;
91 int streambuf::sync()
93 return 0;
96 int streambuf::pbackfail(int c)
98 return _IO_default_pbackfail(this, c);
101 streambuf* streambuf::setbuf(char* p, int len)
103 if (sync() == EOF)
104 return NULL;
105 if (p == NULL || len == 0) {
106 unbuffered(1);
107 setb(_shortbuf, _shortbuf+1, 0);
109 else {
110 unbuffered(0);
111 setb(p, p+len, 0);
113 setp(0, 0);
114 setg(0, 0, 0);
115 return this;
118 streampos streambuf::seekpos(streampos pos, int mode)
120 return seekoff(pos, ios::beg, mode);
123 streampos streambuf::sseekpos(streampos pos, int mode)
125 return _IO_seekpos (this, pos, mode);
128 void streambuf::setb(char* b, char* eb, int a)
129 { _IO_setb(this, b, eb, a); }
131 int streambuf::doallocate() { return _IO_default_doallocate(this); }
133 void streambuf::doallocbuf() { _IO_doallocbuf(this); }
135 #if !_IO_UNIFIED_JUMPTABLES
136 /* The following are jump table entries that just call the virtual method */
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(); }
153 static _IO_pos_t _IO_sb_seekoff(_IO_FILE *fp, _IO_off_t pos, int dir, int mode)
155 return ((streambuf*)fp)->seekoff(pos, (ios::seek_dir)dir, mode);
158 static _IO_pos_t _IO_sb_seekpos(_IO_FILE *fp, _IO_pos_t pos, int mode)
160 return ((streambuf*)fp)->seekpos(pos, mode);
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); }
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 be used on _IO_FILE objects that are builtin
183 (or defined by C code). */
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)
206 #endif
208 streambuf::streambuf(int flags)
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
219 streambuf::~streambuf()
221 _IO_default_finish(this,0);
222 #ifdef _IO_MTSAFE_IO
223 if (this != _IO_stdin && this != _IO_stdout && this != _IO_stderr)
224 delete _lock;
225 #endif
228 streampos
229 streambuf::seekoff(streamoff, _seek_dir, int /*=ios::in|ios::out*/)
231 return EOF;
234 streampos
235 streambuf::sseekoff(streamoff o , _seek_dir d, int m /*=ios::in|ios::out*/)
237 return _IO_seekoff (this, o, d, m);
240 int streambuf::sputbackc(char c)
242 return _IO_sputbackc(this, c);
245 int streambuf::sungetc()
247 return _IO_sungetc(this);
250 #if 0 /* Work in progress */
251 void streambuf::collumn(int c)
253 if (c == -1)
254 _collumn = -1;
255 else
256 _collumn = c - (_IO_write_ptr - _IO_write_base);
258 #endif
261 int streambuf::get_column()
263 if (_cur_column)
264 return _IO_adjust_column(_cur_column - 1, pbase(), pptr() - pbase());
265 return -1;
268 int streambuf::set_column(int i)
270 _cur_column = i+1;
271 return 0;
274 int streambuf::flush_all() { return _IO_flush_all (); }
276 void streambuf::flush_all_linebuffered()
277 { _IO_flush_all_linebuffered(); }
279 int streambuf::sys_stat(void *)
281 #ifdef EIO
282 errno = EIO;
283 #endif
284 return -1;
287 streamsize streambuf::sys_read(char* /*buf*/, streamsize /*size*/)
289 return 0;
292 streamsize streambuf::sys_write(const char* /*buf*/, streamsize /*size*/)
294 return 0;
297 streampos streambuf::sys_seek(streamoff, _seek_dir)
299 return EOF;
302 int streambuf::sys_close() { return 0; /* Suceess; do nothing */ }
304 #if _G_IO_IO_FILE_VERSION == 0x20001
305 int streambuf::showmanyc()
307 return -1;
310 void streambuf::imbue(void *)
313 #endif
315 streammarker::streammarker(streambuf *sb)
317 _IO_init_marker(this, sb);
320 streammarker::~streammarker()
322 _IO_remove_marker(this);
325 #define BAD_DELTA EOF
327 int streammarker::delta(streammarker& other_mark)
329 return _IO_marker_difference(this, &other_mark);
332 int streammarker::delta()
334 return _IO_marker_delta(this);
337 int streambuf::seekmark(streammarker& mark, int delta /* = 0 */)
339 return _IO_seekmark(this, &mark, delta);
342 void streambuf::unsave_markers()
344 _IO_unsave_markers(this);
347 int ios::readable() { return !(rdbuf()->_flags & _IO_NO_READS); }
348 int ios::writable() { return !(rdbuf()->_flags & _IO_NO_WRITES); }
349 int ios::is_open() { return rdbuf()
350 && (rdbuf()->_flags & _IO_NO_READS+_IO_NO_WRITES)
351 != _IO_NO_READS+_IO_NO_WRITES; }
353 #if defined(linux)
354 #define IO_CLEANUP
355 #endif
357 #ifdef IO_CLEANUP
358 IO_CLEANUP
359 #else
360 struct __io_defs {
361 ~__io_defs() { _IO_cleanup (); }
363 __io_defs io_defs__;
364 #endif