forked from KolibriOS/kolibrios
570 lines
14 KiB
C++
570 lines
14 KiB
C++
// Iostreams base classes -*- C++ -*-
|
|
|
|
// Copyright (C) 1997, 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
|
|
//
|
|
// This file is part of the GNU ISO C++ 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, you may use this file as part of a free software
|
|
// library without restriction. Specifically, if other files instantiate
|
|
// templates or use macros or inline functions from this file, or you compile
|
|
// this file and link it with other files to produce an executable, this
|
|
// file does not by itself 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.
|
|
|
|
//
|
|
// ISO C++ 14882: 27.8 File-based streams
|
|
//
|
|
|
|
#ifndef _CPP_BITS_IOSBASE_H
|
|
#define _CPP_BITS_IOSBASE_H 1
|
|
|
|
#pragma GCC system_header
|
|
|
|
namespace std
|
|
{
|
|
// The following definitions of bitmask types are enums, not ints,
|
|
// as permitted (but not required) in the standard, in order to provide
|
|
// better type safety in iostream calls. A side effect is that
|
|
// expressions involving them are no longer compile-time constants.
|
|
enum _Ios_Fmtflags { _M_ios_fmtflags_end = 1L << 16 };
|
|
|
|
inline _Ios_Fmtflags
|
|
operator&(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
|
|
{ return _Ios_Fmtflags(static_cast<int>(__a) & static_cast<int>(__b)); }
|
|
|
|
inline _Ios_Fmtflags
|
|
operator|(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
|
|
{ return _Ios_Fmtflags(static_cast<int>(__a) | static_cast<int>(__b)); }
|
|
|
|
inline _Ios_Fmtflags
|
|
operator^(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
|
|
{ return _Ios_Fmtflags(static_cast<int>(__a) ^ static_cast<int>(__b)); }
|
|
|
|
inline _Ios_Fmtflags
|
|
operator|=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
|
|
{ return __a = __a | __b; }
|
|
|
|
inline _Ios_Fmtflags
|
|
operator&=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
|
|
{ return __a = __a & __b; }
|
|
|
|
inline _Ios_Fmtflags
|
|
operator^=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
|
|
{ return __a = __a ^ __b; }
|
|
|
|
inline _Ios_Fmtflags
|
|
operator~(_Ios_Fmtflags __a)
|
|
{ return _Ios_Fmtflags(~static_cast<int>(__a)); }
|
|
|
|
|
|
enum _Ios_Openmode { _M_ios_openmode_end = 1L << 16 };
|
|
|
|
inline _Ios_Openmode
|
|
operator&(_Ios_Openmode __a, _Ios_Openmode __b)
|
|
{ return _Ios_Openmode(static_cast<int>(__a) & static_cast<int>(__b)); }
|
|
|
|
inline _Ios_Openmode
|
|
operator|(_Ios_Openmode __a, _Ios_Openmode __b)
|
|
{ return _Ios_Openmode(static_cast<int>(__a) | static_cast<int>(__b)); }
|
|
|
|
inline _Ios_Openmode
|
|
operator^(_Ios_Openmode __a, _Ios_Openmode __b)
|
|
{ return _Ios_Openmode(static_cast<int>(__a) ^ static_cast<int>(__b)); }
|
|
|
|
inline _Ios_Openmode
|
|
operator|=(_Ios_Openmode& __a, _Ios_Openmode __b)
|
|
{ return __a = __a | __b; }
|
|
|
|
inline _Ios_Openmode
|
|
operator&=(_Ios_Openmode& __a, _Ios_Openmode __b)
|
|
{ return __a = __a & __b; }
|
|
|
|
inline _Ios_Openmode
|
|
operator^=(_Ios_Openmode& __a, _Ios_Openmode __b)
|
|
{ return __a = __a ^ __b; }
|
|
|
|
inline _Ios_Openmode
|
|
operator~(_Ios_Openmode __a)
|
|
{ return _Ios_Openmode(~static_cast<int>(__a)); }
|
|
|
|
|
|
enum _Ios_Iostate { _M_ios_iostate_end = 1L << 16 };
|
|
|
|
inline _Ios_Iostate
|
|
operator&(_Ios_Iostate __a, _Ios_Iostate __b)
|
|
{ return _Ios_Iostate(static_cast<int>(__a) & static_cast<int>(__b)); }
|
|
|
|
inline _Ios_Iostate
|
|
operator|(_Ios_Iostate __a, _Ios_Iostate __b)
|
|
{ return _Ios_Iostate(static_cast<int>(__a) | static_cast<int>(__b)); }
|
|
|
|
inline _Ios_Iostate
|
|
operator^(_Ios_Iostate __a, _Ios_Iostate __b)
|
|
{ return _Ios_Iostate(static_cast<int>(__a) ^ static_cast<int>(__b)); }
|
|
|
|
inline _Ios_Iostate
|
|
operator|=(_Ios_Iostate& __a, _Ios_Iostate __b)
|
|
{ return __a = __a | __b; }
|
|
|
|
inline _Ios_Iostate
|
|
operator&=(_Ios_Iostate& __a, _Ios_Iostate __b)
|
|
{ return __a = __a & __b; }
|
|
|
|
inline _Ios_Iostate
|
|
operator^=(_Ios_Iostate& __a, _Ios_Iostate __b)
|
|
{ return __a = __a ^ __b; }
|
|
|
|
inline _Ios_Iostate
|
|
operator~(_Ios_Iostate __a)
|
|
{ return _Ios_Iostate(~static_cast<int>(__a)); }
|
|
|
|
enum _Ios_Seekdir { _M_ios_seekdir_end = 1L << 16 };
|
|
|
|
// 27.4.2 Class ios_base
|
|
class ios_base
|
|
{
|
|
public:
|
|
|
|
// 27.4.2.1.1 Class ios_base::failure
|
|
class failure : public exception
|
|
{
|
|
public:
|
|
#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
|
|
// Can't do exception(_msg) as defined in 27.4.2.1.1
|
|
explicit
|
|
failure(const string& __str) throw();
|
|
|
|
virtual
|
|
~failure() throw();
|
|
|
|
virtual const char*
|
|
what() const throw();
|
|
|
|
private:
|
|
enum { _M_bufsize = 256 };
|
|
char _M_name[_M_bufsize];
|
|
#endif
|
|
};
|
|
|
|
// 27.4.2.1.2 Type ios_base::fmtflags
|
|
typedef _Ios_Fmtflags fmtflags;
|
|
// 27.4.2.1.2 Type fmtflags
|
|
static const fmtflags boolalpha = fmtflags(__ios_flags::_S_boolalpha);
|
|
static const fmtflags dec = fmtflags(__ios_flags::_S_dec);
|
|
static const fmtflags fixed = fmtflags(__ios_flags::_S_fixed);
|
|
static const fmtflags hex = fmtflags(__ios_flags::_S_hex);
|
|
static const fmtflags internal = fmtflags(__ios_flags::_S_internal);
|
|
static const fmtflags left = fmtflags(__ios_flags::_S_left);
|
|
static const fmtflags oct = fmtflags(__ios_flags::_S_oct);
|
|
static const fmtflags right = fmtflags(__ios_flags::_S_right);
|
|
static const fmtflags scientific = fmtflags(__ios_flags::_S_scientific);
|
|
static const fmtflags showbase = fmtflags(__ios_flags::_S_showbase);
|
|
static const fmtflags showpoint = fmtflags(__ios_flags::_S_showpoint);
|
|
static const fmtflags showpos = fmtflags(__ios_flags::_S_showpos);
|
|
static const fmtflags skipws = fmtflags(__ios_flags::_S_skipws);
|
|
static const fmtflags unitbuf = fmtflags(__ios_flags::_S_unitbuf);
|
|
static const fmtflags uppercase = fmtflags(__ios_flags::_S_uppercase);
|
|
static const fmtflags adjustfield = fmtflags(__ios_flags::_S_adjustfield);
|
|
static const fmtflags basefield = fmtflags(__ios_flags::_S_basefield);
|
|
static const fmtflags floatfield = fmtflags(__ios_flags::_S_floatfield);
|
|
|
|
// 27.4.2.1.3 Type ios_base::iostate
|
|
typedef _Ios_Iostate iostate;
|
|
static const iostate badbit = iostate(__ios_flags::_S_badbit);
|
|
static const iostate eofbit = iostate(__ios_flags::_S_eofbit);
|
|
static const iostate failbit = iostate(__ios_flags::_S_failbit);
|
|
static const iostate goodbit = iostate(0);
|
|
|
|
// 27.4.2.1.4 Type openmode
|
|
typedef _Ios_Openmode openmode;
|
|
static const openmode app = openmode(__ios_flags::_S_app);
|
|
static const openmode ate = openmode(__ios_flags::_S_ate);
|
|
static const openmode binary = openmode(__ios_flags::_S_bin);
|
|
static const openmode in = openmode(__ios_flags::_S_in);
|
|
static const openmode out = openmode(__ios_flags::_S_out);
|
|
static const openmode trunc = openmode(__ios_flags::_S_trunc);
|
|
|
|
// 27.4.2.1.5 Type seekdir
|
|
typedef _Ios_Seekdir seekdir;
|
|
static const seekdir beg = seekdir(0);
|
|
static const seekdir cur = seekdir(SEEK_CUR);
|
|
static const seekdir end = seekdir(SEEK_END);
|
|
|
|
#ifdef _GLIBCPP_DEPRECATED
|
|
typedef int io_state;
|
|
typedef int open_mode;
|
|
typedef int seek_dir;
|
|
#endif
|
|
|
|
// Callbacks;
|
|
enum event
|
|
{
|
|
erase_event,
|
|
imbue_event,
|
|
copyfmt_event
|
|
};
|
|
|
|
typedef void (*event_callback) (event, ios_base&, int);
|
|
|
|
void
|
|
register_callback(event_callback __fn, int __index);
|
|
|
|
protected:
|
|
// Data Members
|
|
streamsize _M_precision;
|
|
streamsize _M_width;
|
|
fmtflags _M_flags;
|
|
|
|
// 27.4.2.6 Members for callbacks
|
|
// 27.4.2.6 ios_base callbacks
|
|
struct _Callback_list
|
|
{
|
|
// Data Members
|
|
_Callback_list* _M_next;
|
|
ios_base::event_callback _M_fn;
|
|
int _M_index;
|
|
int _M_refcount; // 0 means one reference.
|
|
|
|
_Callback_list(ios_base::event_callback __fn, int __index,
|
|
_Callback_list* __cb)
|
|
: _M_next(__cb), _M_fn(__fn), _M_index(__index), _M_refcount(0) { }
|
|
|
|
void
|
|
_M_add_reference() { ++_M_refcount; } // XXX MT
|
|
|
|
int
|
|
_M_remove_reference() { return _M_refcount--; } // 0 => OK to delete
|
|
};
|
|
|
|
_Callback_list* _M_callbacks;
|
|
|
|
void
|
|
_M_call_callbacks(event __ev) throw();
|
|
|
|
void
|
|
_M_dispose_callbacks(void);
|
|
|
|
// 27.4.2.5 Members for iword/pword storage
|
|
struct _Words
|
|
{
|
|
void* _M_pword;
|
|
long _M_iword;
|
|
};
|
|
|
|
static const int _S_local_words = 8;
|
|
_Words _M_word_array[_S_local_words]; // Guaranteed storage
|
|
_Words _M_dummy; // Only for failed iword/pword calls.
|
|
_Words* _M_words;
|
|
int _M_word_limit;
|
|
|
|
_Words&
|
|
_M_grow_words(int __index);
|
|
|
|
// Members for locale and locale caching.
|
|
locale _M_ios_locale;
|
|
|
|
void
|
|
_M_init();
|
|
|
|
public:
|
|
|
|
// 27.4.2.1.6 Class ios_base::Init
|
|
// Used to initialize standard streams. In theory, g++ could use
|
|
// -finit-priority to order this stuff correctly without going
|
|
// through these machinations.
|
|
class Init
|
|
{
|
|
friend class ios_base;
|
|
public:
|
|
Init();
|
|
~Init();
|
|
|
|
static void
|
|
_S_ios_create(bool __sync);
|
|
|
|
static void
|
|
_S_ios_destroy();
|
|
|
|
private:
|
|
static int _S_ios_base_init;
|
|
static bool _S_synced_with_stdio;
|
|
};
|
|
|
|
// Fmtflags state:
|
|
inline fmtflags
|
|
flags() const { return _M_flags; }
|
|
|
|
inline fmtflags
|
|
flags(fmtflags __fmtfl)
|
|
{
|
|
fmtflags __old = _M_flags;
|
|
_M_flags = __fmtfl;
|
|
return __old;
|
|
}
|
|
|
|
inline fmtflags
|
|
setf(fmtflags __fmtfl)
|
|
{
|
|
fmtflags __old = _M_flags;
|
|
_M_flags |= __fmtfl;
|
|
return __old;
|
|
}
|
|
|
|
inline fmtflags
|
|
setf(fmtflags __fmtfl, fmtflags __mask)
|
|
{
|
|
fmtflags __old = _M_flags;
|
|
_M_flags &= ~__mask;
|
|
_M_flags |= (__fmtfl & __mask);
|
|
return __old;
|
|
}
|
|
|
|
inline void
|
|
unsetf(fmtflags __mask) { _M_flags &= ~__mask; }
|
|
|
|
inline streamsize
|
|
precision() const { return _M_precision; }
|
|
|
|
inline streamsize
|
|
precision(streamsize __prec)
|
|
{
|
|
streamsize __old = _M_precision;
|
|
_M_precision = __prec;
|
|
return __old;
|
|
}
|
|
|
|
inline streamsize
|
|
width() const { return _M_width; }
|
|
|
|
inline streamsize
|
|
width(streamsize __wide)
|
|
{
|
|
streamsize __old = _M_width;
|
|
_M_width = __wide;
|
|
return __old;
|
|
}
|
|
|
|
static bool
|
|
sync_with_stdio(bool __sync = true);
|
|
|
|
// Locales:
|
|
locale
|
|
imbue(const locale& __loc);
|
|
|
|
inline locale
|
|
getloc() const { return _M_ios_locale; }
|
|
|
|
// Storage:
|
|
static int
|
|
xalloc() throw();
|
|
|
|
inline long&
|
|
iword(int __ix)
|
|
{
|
|
_Words& __word = (__ix < _M_word_limit)
|
|
? _M_words[__ix] : _M_grow_words(__ix);
|
|
return __word._M_iword;
|
|
}
|
|
|
|
inline void*&
|
|
pword(int __ix)
|
|
{
|
|
_Words& __word = (__ix < _M_word_limit)
|
|
? _M_words[__ix] : _M_grow_words(__ix);
|
|
return __word._M_pword;
|
|
}
|
|
|
|
// Destructor
|
|
~ios_base();
|
|
|
|
protected:
|
|
ios_base();
|
|
|
|
#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
|
|
private:
|
|
ios_base(const ios_base&);
|
|
|
|
ios_base&
|
|
operator=(const ios_base&);
|
|
#endif
|
|
};
|
|
|
|
// 27.4.5.1 fmtflags manipulators:
|
|
inline ios_base&
|
|
boolalpha(ios_base& __base)
|
|
{
|
|
__base.setf(ios_base::boolalpha);
|
|
return __base;
|
|
}
|
|
|
|
inline ios_base&
|
|
noboolalpha(ios_base& __base)
|
|
{
|
|
__base.unsetf(ios_base::boolalpha);
|
|
return __base;
|
|
}
|
|
|
|
inline ios_base&
|
|
showbase(ios_base& __base)
|
|
{
|
|
__base.setf(ios_base::showbase);
|
|
return __base;
|
|
}
|
|
|
|
inline ios_base&
|
|
noshowbase(ios_base& __base)
|
|
{
|
|
__base.unsetf(ios_base::showbase);
|
|
return __base;
|
|
}
|
|
|
|
inline ios_base&
|
|
showpoint(ios_base& __base)
|
|
{
|
|
__base.setf(ios_base::showpoint);
|
|
return __base;
|
|
}
|
|
|
|
inline ios_base&
|
|
noshowpoint(ios_base& __base)
|
|
{
|
|
__base.unsetf(ios_base::showpoint);
|
|
return __base;
|
|
}
|
|
|
|
inline ios_base&
|
|
showpos(ios_base& __base)
|
|
{
|
|
__base.setf(ios_base::showpos);
|
|
return __base;
|
|
}
|
|
|
|
inline ios_base&
|
|
noshowpos(ios_base& __base)
|
|
{
|
|
__base.unsetf(ios_base::showpos);
|
|
return __base;
|
|
}
|
|
|
|
inline ios_base&
|
|
skipws(ios_base& __base)
|
|
{
|
|
__base.setf(ios_base::skipws);
|
|
return __base;
|
|
}
|
|
|
|
inline ios_base&
|
|
noskipws(ios_base& __base)
|
|
{
|
|
__base.unsetf(ios_base::skipws);
|
|
return __base;
|
|
}
|
|
|
|
inline ios_base&
|
|
uppercase(ios_base& __base)
|
|
{
|
|
__base.setf(ios_base::uppercase);
|
|
return __base;
|
|
}
|
|
|
|
inline ios_base&
|
|
nouppercase(ios_base& __base)
|
|
{
|
|
__base.unsetf(ios_base::uppercase);
|
|
return __base;
|
|
}
|
|
|
|
inline ios_base&
|
|
unitbuf(ios_base& __base)
|
|
{
|
|
__base.setf(ios_base::unitbuf);
|
|
return __base;
|
|
}
|
|
|
|
inline ios_base&
|
|
nounitbuf(ios_base& __base)
|
|
{
|
|
__base.unsetf(ios_base::unitbuf);
|
|
return __base;
|
|
}
|
|
|
|
// 27.4.5.2 adjustfield anipulators:
|
|
inline ios_base&
|
|
internal(ios_base& __base)
|
|
{
|
|
__base.setf(ios_base::internal, ios_base::adjustfield);
|
|
return __base;
|
|
}
|
|
|
|
inline ios_base&
|
|
left(ios_base& __base)
|
|
{
|
|
__base.setf(ios_base::left, ios_base::adjustfield);
|
|
return __base;
|
|
}
|
|
|
|
inline ios_base&
|
|
right(ios_base& __base)
|
|
{
|
|
__base.setf(ios_base::right, ios_base::adjustfield);
|
|
return __base;
|
|
}
|
|
|
|
// 27.4.5.3 basefield anipulators:
|
|
inline ios_base&
|
|
dec(ios_base& __base)
|
|
{
|
|
__base.setf(ios_base::dec, ios_base::basefield);
|
|
return __base;
|
|
}
|
|
|
|
inline ios_base&
|
|
hex(ios_base& __base)
|
|
{
|
|
__base.setf(ios_base::hex, ios_base::basefield);
|
|
return __base;
|
|
}
|
|
|
|
inline ios_base&
|
|
oct(ios_base& __base)
|
|
{
|
|
__base.setf(ios_base::oct, ios_base::basefield);
|
|
return __base;
|
|
}
|
|
|
|
// 27.4.5.4 floatfield anipulators:
|
|
inline ios_base&
|
|
fixed(ios_base& __base)
|
|
{
|
|
__base.setf(ios_base::fixed, ios_base::floatfield);
|
|
return __base;
|
|
}
|
|
|
|
inline ios_base&
|
|
scientific(ios_base& __base)
|
|
{
|
|
__base.setf(ios_base::scientific, ios_base::floatfield);
|
|
return __base;
|
|
}
|
|
|
|
} // namespace std
|
|
|
|
#endif /* _CPP_BITS_IOSBASE_H */
|
|
|