1 /* This is part of libio/iostream, providing -*- C++ -*- input/output.
2 Copyright (C) 1993 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)
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. */
31 /* #define _G_IO_THROW */ /* Not implemented: ios::failure */
33 #define _IO_NEW_STREAMS // new optimizated stream representation
38 //#include <_G_config.h>
39 #ifdef _G_NEED_STDARG_H
43 #define _IO_va_list char *
58 #define _IO_wchar_t short
62 class istream
; /* Work-around for a g++ name mangling bug. Fixed in 2.6. */
63 class ostream
; class streambuf
;
65 // In case some header files defines these as macros.
69 typedef _IO_off_t streamoff
;
70 typedef _IO_fpos_t streampos
;
71 typedef _IO_ssize_t streamsize
;
73 typedef unsigned long __fmtflags
;
74 typedef unsigned char __iostate
;
77 { // The data members of an ios.
84 __iostate _exceptions
;
87 void *_arrays
; /* Support for ios::iword and ios::pword. */
100 #define _IO_NOCREATE 32
101 #define _IO_NOREPLACE 64
104 #ifdef _STREAM_COMPAT
114 append
= _IO_APPEND
};
117 class ios
: public _ios_fields
{
118 ios
& operator=(ios
&); /* Not allowed! */
119 ios (const ios
&); /* Not allowed! */
121 typedef __fmtflags fmtflags
;
123 typedef int openmode
;
124 typedef int streamsize
;
136 nocreate
= _IO_NOCREATE
,
137 noreplace
= _IO_NOREPLACE
,
138 bin
= _IOS_BIN
, // Deprecated - ANSI uses ios::binary.
140 enum seek_dir
{ beg
, cur
, end
};
141 typedef enum seek_dir seekdir
;
142 // NOTE: If adding flags here, before to update ios::bitalloc().
143 enum { skipws
=_IO_SKIPWS
,
144 left
=_IO_LEFT
, right
=_IO_RIGHT
, internal
=_IO_INTERNAL
,
145 dec
=_IO_DEC
, oct
=_IO_OCT
, hex
=_IO_HEX
,
146 showbase
=_IO_SHOWBASE
, showpoint
=_IO_SHOWPOINT
,
147 uppercase
=_IO_UPPERCASE
, showpos
=_IO_SHOWPOS
,
148 scientific
=_IO_SCIENTIFIC
, fixed
=_IO_FIXED
,
149 unitbuf
=_IO_UNITBUF
, stdio
=_IO_STDIO
150 #ifndef _IO_NEW_STREAMS
151 , dont_close
=_IO_DONT_CLOSE
// Don't delete streambuf on stream destruction
155 basefield
=dec
+oct
+hex
,
156 floatfield
= scientific
+fixed
,
157 adjustfield
= left
+right
+internal
161 class failure
: public xmsg
{
164 failure(ios
* stream
) { _stream
= stream
; }
165 failure(string cause
, ios
* stream
) { _stream
= stream
; }
166 ios
* rdios() const { return _stream
; }
170 ostream
* tie() const { return _tie
; }
171 ostream
* tie(ostream
* val
) { ostream
* save
=_tie
; _tie
=val
; return save
; }
173 // Methods to change the format state.
174 _IO_wchar_t
fill() const { return (_IO_wchar_t
)_fill
; }
175 _IO_wchar_t
fill(_IO_wchar_t newf
)
176 {_IO_wchar_t oldf
= (_IO_wchar_t
)_fill
; _fill
= (char)newf
; return oldf
;}
177 fmtflags
flags() const { return _flags
; }
178 fmtflags
flags(fmtflags new_val
) {
179 fmtflags old_val
= _flags
; _flags
= new_val
; return old_val
; }
180 int precision() const { return _precision
; }
181 int precision(int newp
) {
182 unsigned short oldp
= _precision
; _precision
= (unsigned short)newp
;
184 fmtflags
setf(fmtflags val
) {
185 fmtflags oldbits
= _flags
;
186 _flags
|= val
; return oldbits
; }
187 fmtflags
setf(fmtflags val
, fmtflags mask
) {
188 fmtflags oldbits
= _flags
;
189 _flags
= (_flags
& ~mask
) | (val
& mask
); return oldbits
; }
190 fmtflags
unsetf(fmtflags mask
) {
191 fmtflags oldbits
= _flags
;
192 _flags
&= ~mask
; return oldbits
; }
193 int width() const { return _width
; }
194 int width(int val
) { int save
= _width
; _width
= val
; return save
; }
197 void _throw_failure() const { throw new ios::failure(this); }
199 void _throw_failure() const { }
201 void clear(iostate state
= 0) {
202 _state
= _strbuf
? state
: state
|badbit
;
203 if (_state
& _exceptions
) _throw_failure(); }
204 void set(iostate flag
) { _state
|= flag
;
205 if (_state
& _exceptions
) _throw_failure(); }
206 void setstate(iostate flag
) { _state
|= flag
; // ANSI
207 if (_state
& _exceptions
) _throw_failure(); }
208 int good() const { return _state
== 0; }
209 int eof() const { return _state
& ios::eofbit
; }
210 int fail() const { return _state
& (ios::badbit
|ios::failbit
); }
211 int bad() const { return _state
& ios::badbit
; }
212 iostate
rdstate() const { return _state
; }
213 operator void*() const { return fail() ? (void*)0 : (void*)(-1); }
214 int operator!() const { return fail(); }
215 iostate
exceptions() const { return _exceptions
; }
216 void exceptions(iostate enable
) {
217 _exceptions
= enable
;
218 if (_state
& _exceptions
) _throw_failure(); }
220 streambuf
* rdbuf() const { return _strbuf
; }
221 streambuf
* rdbuf(streambuf
*_s
) {
222 streambuf
*_old
= _strbuf
; _strbuf
= _s
; clear (); return _old
; }
224 static int sync_with_stdio(int on
);
225 static void sync_with_stdio() { sync_with_stdio(1); }
226 static fmtflags
bitalloc();
229 void* pword(int) const;
231 long iword(int) const;
233 #ifdef _STREAM_COMPAT
234 void unset(state_value flag
) { _state
&= ~flag
; }
241 // Used to initialize standard streams. Not needed in this implementation.
248 inline ios(streambuf
* sb
= 0, ostream
* tie_to
= 0);
249 inline virtual ~ios();
250 inline void init(streambuf
* sb
, ostream
* tie
= 0);
254 typedef int _seek_dir
;
256 typedef ios::seek_dir _seek_dir
;
259 // Magic numbers and bits for the _flags field.
260 // The magic numbers use the high-order bits of _flags;
261 // the remaining bits are abailable for variable flags.
262 // Note: The magic numbers must all be negative if stdio
263 // emulation is desired.
265 // A streammarker remembers a position in a buffer.
266 // You are guaranteed to be able to seek back to it if it is saving().
267 class streammarker
: private _IO_marker
{
268 friend class streambuf
;
269 void set_offset(int offset
) { _pos
= offset
; }
271 streammarker(streambuf
*sb
);
273 int saving() { return 1; }
274 int delta(streammarker
&);
278 struct streambuf
: public _IO_FILE
{ // protected??
280 friend class istream
;
281 friend class ostream
;
282 friend class streammarker
;
283 const void *&_vtable() { return *(const void**)((_IO_FILE
*)this + 1); }
285 static streambuf
* _list_all
; /* List of open streambufs. */
286 _IO_FILE
*& xchain() { return _chain
; }
290 { return _IO_file_flags
& _IO_IN_BACKUP
? _IO_save_base
: _IO_read_ptr
; }
291 char* pptr() const { return _IO_write_ptr
; }
293 { return _IO_file_flags
& _IO_IN_BACKUP
? _IO_save_end
: _IO_read_end
; }
294 char* epptr() const { return _IO_write_end
; }
295 char* pbase() const { return _IO_write_base
; }
297 { return _IO_file_flags
& _IO_IN_BACKUP
? _IO_save_base
: _IO_read_base
;}
298 char* base() const { return _IO_buf_base
; }
299 char* ebuf() const { return _IO_buf_end
; }
300 int blen() const { return _IO_buf_end
- _IO_buf_base
; }
301 void xput_char(char c
) { *_IO_write_ptr
++ = c
; }
302 int xflags() { return _IO_file_flags
; }
303 int xflags(int f
) {int fl
= _IO_file_flags
; _IO_file_flags
= f
; return fl
;}
304 void xsetflags(int f
) { _IO_file_flags
|= f
; }
305 void xsetflags(int f
, int mask
)
306 { _IO_file_flags
= (_IO_file_flags
& ~mask
) | (f
& mask
); }
308 { _IO_file_flags
& _IO_IN_BACKUP
? (_IO_save_base
+=n
):(_IO_read_ptr
+=n
);}
309 void pbump(int n
) { _IO_write_ptr
+= n
; }
310 void setb(char* b
, char* eb
, int a
=0);
311 void setp(char* p
, char* ep
)
312 { _IO_write_base
=_IO_write_ptr
=p
; _IO_write_end
=ep
; }
313 void setg(char* eb
, char* g
, char *eg
) {
314 if (_IO_file_flags
& _IO_IN_BACKUP
) _IO_free_backup_area(this);
315 _IO_read_base
= eb
; _IO_read_ptr
= g
; _IO_read_end
= eg
; }
316 char *shortbuf() { return _shortbuf
; }
318 int in_backup() { return _flags
& _IO_IN_BACKUP
; }
319 // The start of the main get area: FIXME: wrong for write-mode filebuf?
320 char *Gbase() { return in_backup() ? _IO_save_base
: _IO_read_base
; }
321 // The end of the main get area:
322 char *eGptr() { return in_backup() ? _IO_save_end
: _IO_read_end
; }
323 // The start of the backup area:
324 char *Bbase() { return in_backup() ? _IO_read_base
: _IO_save_base
; }
325 char *Bptr() { return _IO_backup_base
; }
326 // The end of the backup area:
327 char *eBptr() { return in_backup() ? _IO_read_end
: _IO_save_end
; }
328 char *Nbase() { return _IO_save_base
; }
329 char *eNptr() { return _IO_save_end
; }
330 int have_backup() { return _IO_save_base
!= NULL
; }
331 int have_markers() { return _markers
!= NULL
; }
332 void free_backup_area();
333 void unsave_markers(); // Make all streammarkers !saving().
334 int put_mode() { return _flags
& _IO_CURRENTLY_PUTTING
; }
335 int switch_to_get_mode();
337 streambuf(int flags
=0);
339 static int flush_all();
340 static void flush_all_linebuffered(); // Flush all line buffered files.
341 virtual ~streambuf();
342 virtual int overflow(int c
= EOF
); // Leave public for now
343 virtual int underflow(); // Leave public for now
344 virtual int uflow(); // Leave public for now
345 virtual int pbackfail(int c
);
346 // virtual int showmany ();
347 virtual streamsize
xsputn(const char* s
, streamsize n
);
348 virtual streamsize
xsgetn(char* s
, streamsize n
);
349 virtual streampos
seekoff(streamoff
, _seek_dir
, int mode
=ios::in
|ios::out
);
350 virtual streampos
seekpos(streampos pos
, int mode
= ios::in
|ios::out
);
352 streampos
pubseekoff(streamoff o
, _seek_dir d
, int mode
=ios::in
|ios::out
)
353 { return _IO_seekoff (this, o
, d
, mode
); }
354 streampos
pubseekpos(streampos pos
, int mode
= ios::in
|ios::out
)
355 { return _IO_seekpos (this, pos
, mode
); }
356 streampos
sseekoff(streamoff
, _seek_dir
, int mode
=ios::in
|ios::out
);
357 streampos
sseekpos(streampos pos
, int mode
= ios::in
|ios::out
);
358 virtual streambuf
* setbuf(char* p
, int len
);
360 virtual int doallocate();
362 int seekmark(streammarker
& mark
, int delta
= 0);
363 int sputbackc(char c
);
365 int unbuffered() { return _flags
& _IO_UNBUFFERED
? 1 : 0; }
366 int linebuffered() { return _flags
& _IO_LINE_BUF
? 1 : 0; }
367 void unbuffered(int i
)
368 { if (i
) _flags
|= _IO_UNBUFFERED
; else _flags
&= ~_IO_UNBUFFERED
; }
369 void linebuffered(int i
)
370 { if (i
) _flags
|= _IO_LINE_BUF
; else _flags
&= ~_IO_LINE_BUF
; }
371 int allocate() { // For AT&T compatibility
372 if (base() || unbuffered()) return 0;
373 else return doallocate(); }
374 // Allocate a buffer if needed; use _shortbuf if appropriate.
375 void allocbuf() { if (base() == NULL
) doallocbuf(); }
377 int in_avail() { return _IO_read_end
- _IO_read_ptr
; }
378 int out_waiting() { return _IO_write_ptr
- _IO_write_base
; }
379 streamsize
sputn(const char* s
, streamsize n
) { return xsputn(s
, n
); }
380 streamsize
padn(char pad
, streamsize n
) { return _IO_padn(this, pad
, n
); }
381 streamsize
sgetn(char* s
, streamsize n
) { return _IO_sgetn(this, s
, n
); }
385 long sgetline(char* buf
, _IO_size_t n
, char delim
, int putback_delim
);
386 int sputc(int c
) { return _IO_putc(c
, this); }
387 int sbumpc() { return _IO_getc(this); }
388 int sgetc() { return _IO_peekc(this); }
390 if (_IO_read_ptr
>= _IO_read_end
&& __underflow(this) == EOF
)
392 else return _IO_read_ptr
++, sgetc(); }
393 void stossc() { if (_IO_read_ptr
< _IO_read_end
) _IO_read_ptr
++; }
394 int vscan(char const *fmt0
, _IO_va_list ap
, ios
* stream
= NULL
);
395 int scan(char const *fmt0
...);
396 int vform(char const *fmt0
, _IO_va_list ap
);
397 int form(char const *fmt0
...);
398 #if 0 /* Work in progress */
399 int column(); // Current column number (of put pointer). -1 is unknown.
400 void column(int c
); // Set column number of put pointer to c.
402 virtual streamsize
sys_read(char* buf
, streamsize size
);
403 virtual streamsize
sys_write(const char*, streamsize
);
404 virtual streampos
sys_seek(streamoff
, _seek_dir
);
405 virtual int sys_close();
406 virtual int sys_stat(void*); // Actually, a (struct stat*)
409 // A backupbuf is a streambuf with full backup and savepoints on reading.
410 // All standard streambufs in the GNU iostream library are backupbufs.
412 class filebuf
: public streambuf
{
416 static const int openprot
; // Non-ANSI AT&T-ism: Default open protection.
419 filebuf(int fd
, char* p
, int len
);
420 #if !_IO_UNIFIED_JUMPTABLES
421 static filebuf
*__new();
424 filebuf
* attach(int fd
);
425 filebuf
* open(const char *filename
, const char *mode
);
426 filebuf
* open(const char *filename
, ios::openmode mode
, int prot
= 0664);
427 virtual int underflow();
428 virtual int overflow(int c
= EOF
);
429 int is_open() const { return _fileno
>= 0; }
430 int fd() const { return is_open() ? _fileno
: EOF
; }
432 virtual int doallocate();
433 virtual streampos
seekoff(streamoff
, _seek_dir
, int mode
=ios::in
|ios::out
);
434 virtual streambuf
* setbuf(char* p
, int len
);
435 streamsize
xsputn(const char* s
, streamsize n
);
436 streamsize
xsgetn(char* s
, streamsize n
);
438 protected: // See documentation in filebuf.C.
439 // virtual int pbackfail(int c);
440 int is_reading() { return eback() != egptr(); }
441 char* cur_ptr() { return is_reading() ? gptr() : pptr(); }
442 /* System's idea of pointer */
443 char* file_ptr() { return eGptr(); }
444 // Low-level operations (Usually invoke system calls.)
445 virtual streamsize
sys_read(char* buf
, streamsize size
);
446 virtual streampos
sys_seek(streamoff
, _seek_dir
);
447 virtual streamsize
sys_write(const char*, streamsize
);
448 virtual int sys_stat(void*); // Actually, a (struct stat*)
449 virtual int sys_close();
456 inline void ios::init(streambuf
* sb
, ostream
* tie_to
) {
457 _state
= sb
? ios::goodbit
: ios::badbit
; _exceptions
=0;
458 _strbuf
=sb
; _tie
= tie_to
; _width
=0; _fill
=' ';
459 #ifdef _IO_NEW_STREAMS
460 _flags
=ios::skipws
|ios::dec
;
462 _flags
=ios::skipws
|ios::dec
|ios::dont_close
;
464 _precision
=6; _arrays
= 0; }
466 inline ios::ios(streambuf
* sb
, ostream
* tie_to
) { init(sb
, tie_to
); }
469 #ifndef _IO_NEW_STREAMS
470 if (!(_flags
& (unsigned int)ios::dont_close
)) delete rdbuf();
472 if (_arrays
) delete [] _arrays
;
475 #endif /* _STREAMBUF_H */