[gcc.git] / libio / streambuf.cc

/* This is part of libio/iostream, providing -*- C++ -*- input/output.
Copyright (C) 1991, 1992, 1993, 1995 Free Software Foundation

This file is part of the GNU IO Library.  This library is free
software; you can redistribute it and/or modify it under the
terms of the GNU General Public License as published by the
Free Software Foundation; either version 2, or (at your option)
any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this library; see the file COPYING.  If not, write to the Free
Software Foundation, 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

As a special exception, if you link this library with files
compiled with a GNU compiler to produce an executable, this does not cause
the resulting executable to be covered by the GNU General Public License.
This exception does not however invalidate any other reasons why
the executable file might be covered by the GNU General Public License. */

/* Written by Per Bothner (bothner@cygnus.com). */

#define _STREAM_COMPAT
#ifdef __GNUG__
#pragma implementation
#endif
#include "iostreamP.h"
#include <string.h>
#include <stdarg.h>
#include <errno.h>
#ifndef errno
extern int errno;
#endif

void streambuf::_un_link() { _IO_un_link(this); }

void streambuf::_link_in() { _IO_link_in(this); }

int streambuf::switch_to_get_mode()
{ return _IO_switch_to_get_mode(this); }

void streambuf::free_backup_area()
{ _IO_free_backup_area(this); }

#if 0
int streambuf::switch_to_put_mode()
{ return _IO_:switch_to_put_mode(this); }
#endif

int __overflow(streambuf* sb, int c)
{
    return sb->overflow(c);
}

int streambuf::underflow()
{ return EOF; }

int streambuf::uflow()
{ return _IO_default_uflow (this); }

int streambuf::overflow(int /* = EOF */)
{ return EOF; }

streamsize streambuf::xsputn(register const char* s, streamsize n)
{ return _IO_default_xsputn(this, s, n); }

streamsize streambuf::xsgetn(char* s, streamsize n)
{ return _IO_default_xsgetn(this, s, n); }

int streambuf::ignore(int n)
{
    register int more = n;
    for (;;) {
	int count = _IO_read_end - _IO_read_ptr; // Data available.
	if (count > 0) {
	    if (count > more)
		count = more;
	    _IO_read_ptr += count;
	    more -= count;
	}
	if (more == 0 || __underflow(this) == EOF)
	    break;
    }
    return n - more;
}

int streambuf::sync()
{
  return 0;
}

int streambuf::pbackfail(int c)
{
  return _IO_default_pbackfail(this, c);
}

streambuf* streambuf::setbuf(char* p, int len)
{
    if (sync() == EOF)
	return NULL;
    if (p == NULL || len == 0) {
	unbuffered(1);
	setb(_shortbuf, _shortbuf+1, 0);
    }
    else {
	unbuffered(0);
	setb(p, p+len, 0);
    }
    setp(0, 0);
    setg(0, 0, 0);
    return this;
}

streampos streambuf::seekpos(streampos pos, int mode)
{
    return seekoff(pos, ios::beg, mode);
}

streampos streambuf::sseekpos(streampos pos, int mode)
{
  return _IO_seekpos (this, pos, mode);
}

void streambuf::setb(char* b, char* eb, int a)
{ _IO_setb(this, b, eb, a); }

int streambuf::doallocate() { return _IO_default_doallocate(this); }

void streambuf::doallocbuf() { _IO_doallocbuf(this); }

#if !_IO_UNIFIED_JUMPTABLES
/* The following are jump table entries that just call the virtual method */

static int _IO_sb_overflow(_IO_FILE *fp, int c)
{ return ((streambuf*)fp)->overflow(c); }
static int _IO_sb_underflow(_IO_FILE *fp)
{ return ((streambuf*)fp)->underflow(); }
static _IO_size_t _IO_sb_xsputn(_IO_FILE *fp, const void *s, _IO_size_t n)
{ return ((streambuf*)fp)->xsputn((const char*)s, n); }
static _IO_size_t _IO_sb_xsgetn(_IO_FILE *fp, void *s, _IO_size_t n)
{ return ((streambuf*)fp)->xsgetn((char*)s, n); }
static int _IO_sb_close(_IO_FILE *fp)
{ return ((streambuf*)fp)->sys_close(); }
static int _IO_sb_stat(_IO_FILE *fp, void *b)
{ return ((streambuf*)fp)->sys_stat(b); }
static int _IO_sb_doallocate(_IO_FILE *fp)
{ return ((streambuf*)fp)->doallocate(); }

static _IO_pos_t _IO_sb_seekoff(_IO_FILE *fp, _IO_off_t pos, int dir, int mode)
{
  return ((streambuf*)fp)->seekoff(pos, (ios::seek_dir)dir, mode);
}

static _IO_pos_t _IO_sb_seekpos(_IO_FILE *fp, _IO_pos_t pos, int mode)
{
  return ((streambuf*)fp)->seekpos(pos, mode);
}

static int _IO_sb_pbackfail(_IO_FILE *fp, int ch)
{ return ((streambuf*)fp)->pbackfail(ch); }
static void _IO_sb_finish(_IO_FILE *fp, int)
{ ((streambuf*)fp)->~streambuf(); }
static _IO_ssize_t _IO_sb_read(_IO_FILE *fp, void *buf, _IO_ssize_t n)
{ return ((streambuf*)fp)->sys_read((char*)buf, n); }
static _IO_ssize_t _IO_sb_write(_IO_FILE *fp, const void *buf, _IO_ssize_t n)
{ return ((streambuf*)fp)->sys_write((const char*)buf, n); }
static int _IO_sb_sync(_IO_FILE *fp)
{ return ((streambuf*)fp)->sync(); }
static _IO_pos_t _IO_sb_seek(_IO_FILE *fp, _IO_off_t off, int dir)
{ return ((streambuf*)fp)->sys_seek(off, (_seek_dir)dir); }
static _IO_FILE* _IO_sb_setbuf(_IO_FILE *fp, char *buf, _IO_ssize_t n)
{ return ((streambuf*)fp)->setbuf(buf, n); }

/* This callbacks in this jumptable just call the corresponding
   virtual function, so that C functions can access (potentially user-defined)
   streambuf-derived objects.
   Contrast the builtinbuf class, which does the converse:  Allow
   C++ virtual calls to to be used on _IO_FILE objects that are builtin
   (or defined by C code). */


struct _IO_jump_t _IO_streambuf_jumps = {
  JUMP_INIT_DUMMY,
  JUMP_INIT(finish, _IO_sb_finish),
  JUMP_INIT(overflow, _IO_sb_overflow),
  JUMP_INIT(underflow, _IO_sb_underflow),
  JUMP_INIT(uflow, _IO_default_uflow),
  JUMP_INIT(pbackfail, _IO_sb_pbackfail),
  JUMP_INIT(xsputn, _IO_sb_xsputn),
  JUMP_INIT(xsgetn, _IO_sb_xsgetn),
  JUMP_INIT(seekoff, _IO_sb_seekoff),
  JUMP_INIT(seekpos, _IO_sb_seekpos),
  JUMP_INIT(setbuf, _IO_sb_setbuf),
  JUMP_INIT(sync, _IO_sb_sync),
  JUMP_INIT(doallocate, _IO_sb_doallocate),
  JUMP_INIT(read, _IO_sb_read),
  JUMP_INIT(write, _IO_sb_write),
  JUMP_INIT(seek, _IO_sb_seek),
  JUMP_INIT(close, _IO_sb_close),
  JUMP_INIT(stat, _IO_sb_stat)
};
#endif

streambuf::streambuf(int flags)
{
#ifdef _IO_MTSAFE_IO
  _lock = new _IO_lock_t;
#endif
  _IO_init(this, flags);
#if !_IO_UNIFIED_JUMPTABLES
  _jumps = &_IO_streambuf_jumps;
#endif
}

streambuf::~streambuf()
{
  _IO_default_finish(this,0);
#ifdef _IO_MTSAFE_IO
  delete _lock;
#endif
}

streampos
streambuf::seekoff(streamoff, _seek_dir, int /*=ios::in|ios::out*/)
{
    return EOF;
}

streampos
streambuf::sseekoff(streamoff o , _seek_dir d, int m /*=ios::in|ios::out*/)
{
  return _IO_seekoff (this, o, d, m);
}

int streambuf::sputbackc(char c)
{
  return _IO_sputbackc(this, c);
}

int streambuf::sungetc()
{
  return _IO_sungetc(this);
}

#if 0 /* Work in progress */
void streambuf::collumn(int c)
{
    if (c == -1)
	_collumn = -1;
    else
	_collumn = c - (_IO_write_ptr - _IO_write_base);
}
#endif


int streambuf::get_column()
{
    if (_cur_column) 
	return _IO_adjust_column(_cur_column - 1, pbase(), pptr() - pbase());
    return -1;
}

int streambuf::set_column(int i)
{
    _cur_column = i+1;
    return 0;
}

int streambuf::flush_all() { return _IO_flush_all (); }

void streambuf::flush_all_linebuffered()
{ _IO_flush_all_linebuffered(); }

int streambuf::sys_stat(void *)
{
#ifdef EIO
  errno = EIO;
#endif
  return -1;
}

streamsize streambuf::sys_read(char* /*buf*/, streamsize /*size*/)
{
  return 0;
}

streamsize streambuf::sys_write(const char* /*buf*/, streamsize /*size*/)
{
  return 0;
}

streampos streambuf::sys_seek(streamoff, _seek_dir)
{
  return EOF;
}

int streambuf::sys_close() { return 0; /* Suceess; do nothing */ }

streammarker::streammarker(streambuf *sb)
{
  _IO_init_marker(this, sb);
}

streammarker::~streammarker()
{
  _IO_remove_marker(this);
}

#define BAD_DELTA EOF

int streammarker::delta(streammarker& other_mark)
{
  return _IO_marker_difference(this, &other_mark);
}

int streammarker::delta()
{
  return _IO_marker_delta(this);
}

int streambuf::seekmark(streammarker& mark, int delta /* = 0 */)
{
  return _IO_seekmark(this, &mark, delta);
}

void streambuf::unsave_markers()
{
  _IO_unsave_markers(this);
}

int ios::readable() { return !(rdbuf()->_flags & _IO_NO_READS); }
int ios::writable() { return !(rdbuf()->_flags & _IO_NO_WRITES); }
int ios::is_open() { return rdbuf()
			 && (rdbuf()->_flags & _IO_NO_READS+_IO_NO_WRITES)
			     != _IO_NO_READS+_IO_NO_WRITES; }

#if defined(linux)
#define IO_CLEANUP
#endif

#ifdef IO_CLEANUP
  IO_CLEANUP
#else
struct __io_defs {
    ~__io_defs() { _IO_cleanup (); }
};   
__io_defs io_defs__;
#endif
Commit	Line	Data
6599da04 JM	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); }
e693cc28	165	static void _IO_sb_finish(_IO_FILE *fp, int)
6599da04 JM	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	{
e693cc28 UD	210	#ifdef _IO_MTSAFE_IO
	211	_lock = new _IO_lock_t;
	212	#endif
6599da04 JM	213	_IO_init(this, flags);
	214	#if !_IO_UNIFIED_JUMPTABLES
	215	_jumps = &_IO_streambuf_jumps;
	216	#endif
	217	}
	218
e693cc28 UD	219	streambuf::~streambuf()
	220	{
	221	_IO_default_finish(this,0);
	222	#ifdef _IO_MTSAFE_IO
	223	delete _lock;
	224	#endif
	225	}
6599da04 JM	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