410 lines
12 KiB
C++
410 lines
12 KiB
C++
/*
|
|
* Copyright (c) 1999
|
|
* Silicon Graphics Computer Systems, Inc.
|
|
*
|
|
* Copyright (c) 1999
|
|
* Boris Fomitchev
|
|
*
|
|
* This material is provided "as is", with absolutely no warranty expressed
|
|
* or implied. Any use is at your own risk.
|
|
*
|
|
* Permission to use or copy this software for any purpose is hereby granted
|
|
* without fee, provided the above notices are retained on all copies.
|
|
* Permission to modify the code and to distribute modified code is granted,
|
|
* provided the above notices are retained, and a notice that the code was
|
|
* modified is included with the above copyright notice.
|
|
*
|
|
*/
|
|
#ifndef _STLP_IOS_BASE_H
|
|
#define _STLP_IOS_BASE_H
|
|
|
|
#ifndef _STLP_STDEXCEPT
|
|
#include <stdexcept>
|
|
#endif
|
|
#ifndef _STLP_UTILITY
|
|
#include <utility>
|
|
#endif
|
|
#ifndef _STLP_INTERNAL_LOCALE_H
|
|
#include <stl/_locale.h>
|
|
#endif
|
|
#ifndef _STLP_STRING_H
|
|
# include <stl/_string.h>
|
|
#endif
|
|
|
|
_STLP_BEGIN_NAMESPACE
|
|
|
|
// ----------------------------------------------------------------------
|
|
|
|
// Class ios_base. This is the base class of the ios hierarchy, which
|
|
// includes basic_istream and basic_ostream. Classes in the ios
|
|
// hierarchy are actually quite simple: they are just glorified
|
|
// wrapper classes. They delegate buffering and physical character
|
|
// manipulation to the streambuf classes, and they delegate most
|
|
// formatting tasks to a locale.
|
|
|
|
class _STLP_CLASS_DECLSPEC ios_base {
|
|
public:
|
|
|
|
class _STLP_CLASS_DECLSPEC failure : public __Named_exception {
|
|
public:
|
|
explicit failure(const string&);
|
|
virtual ~failure() _STLP_NOTHROW_INHERENTLY;
|
|
};
|
|
|
|
typedef int fmtflags;
|
|
typedef int iostate;
|
|
typedef int openmode;
|
|
typedef int seekdir;
|
|
|
|
# ifndef _STLP_NO_ANACHRONISMS
|
|
typedef fmtflags fmt_flags;
|
|
# endif
|
|
|
|
// Formatting flags.
|
|
# ifdef _STLP_STATIC_CONST_INIT_BUG
|
|
enum {
|
|
# else
|
|
// boris : type for all those constants is int
|
|
static const int
|
|
# endif
|
|
left = 0x0001,
|
|
right = 0x0002,
|
|
internal = 0x0004,
|
|
dec = 0x0008,
|
|
hex = 0x0010,
|
|
oct = 0x0020,
|
|
fixed = 0x0040,
|
|
scientific = 0x0080,
|
|
boolalpha = 0x0100,
|
|
showbase = 0x0200,
|
|
showpoint = 0x0400,
|
|
showpos = 0x0800,
|
|
skipws = 0x1000,
|
|
unitbuf = 0x2000,
|
|
uppercase = 0x4000,
|
|
adjustfield = left | right | internal,
|
|
basefield = dec | hex | oct,
|
|
floatfield = scientific | fixed,
|
|
|
|
// State flags.
|
|
goodbit = 0x00,
|
|
badbit = 0x01,
|
|
eofbit = 0x02,
|
|
failbit = 0x04,
|
|
|
|
// Openmode flags.
|
|
__default_mode = 0x0, /* implementation detail */
|
|
app = 0x01,
|
|
ate = 0x02,
|
|
binary = 0x04,
|
|
in = 0x08,
|
|
out = 0x10,
|
|
trunc = 0x20,
|
|
|
|
// Seekdir flags
|
|
|
|
beg = 0x01,
|
|
cur = 0x02,
|
|
end = 0x04
|
|
# ifdef _STLP_STATIC_CONST_INIT_BUG
|
|
}
|
|
# endif
|
|
;
|
|
|
|
public: // Flag-manipulation functions.
|
|
fmtflags flags() const { return _M_fmtflags; }
|
|
fmtflags flags(fmtflags __flags) {
|
|
fmtflags __tmp = _M_fmtflags;
|
|
_M_fmtflags = __flags;
|
|
return __tmp;
|
|
}
|
|
|
|
fmtflags setf(fmtflags __flag) {
|
|
fmtflags __tmp = _M_fmtflags;
|
|
_M_fmtflags |= __flag;
|
|
return __tmp;
|
|
}
|
|
fmtflags setf(fmtflags __flag, fmtflags __mask) {
|
|
fmtflags __tmp = _M_fmtflags;
|
|
_M_fmtflags &= ~__mask;
|
|
_M_fmtflags |= __flag & __mask;
|
|
return __tmp;
|
|
}
|
|
void unsetf(fmtflags __mask) { _M_fmtflags &= ~__mask; }
|
|
|
|
streamsize precision() const { return _M_precision; }
|
|
streamsize precision(streamsize __newprecision) {
|
|
streamsize __tmp = _M_precision;
|
|
_M_precision = __newprecision;
|
|
return __tmp;
|
|
}
|
|
|
|
streamsize width() const { return _M_width; }
|
|
streamsize width(streamsize __newwidth) {
|
|
streamsize __tmp = _M_width;
|
|
_M_width = __newwidth;
|
|
return __tmp;
|
|
}
|
|
|
|
public: // Locales
|
|
locale imbue(const locale&);
|
|
locale getloc() const { return _M_locale; }
|
|
|
|
public: // Auxiliary storage.
|
|
static int _STLP_CALL xalloc();
|
|
long& iword(int __index);
|
|
void*& pword(int __index);
|
|
|
|
public: // Destructor.
|
|
virtual ~ios_base();
|
|
|
|
public: // Callbacks.
|
|
enum event { erase_event, imbue_event, copyfmt_event };
|
|
typedef void (*event_callback)(event, ios_base&, int __index);
|
|
void register_callback(event_callback __fn, int __index);
|
|
|
|
public: // This member function affects only
|
|
// the eight predefined ios objects:
|
|
// cin, cout, etc.
|
|
static bool _STLP_CALL sync_with_stdio(bool __sync = true);
|
|
|
|
public: // The C++ standard requires only that these
|
|
// member functions be defined in basic_ios.
|
|
// We define them in the non-template
|
|
// base class to avoid code duplication.
|
|
operator void*() const { return !fail() ? (void*) __CONST_CAST(ios_base*,this) : (void*) 0; }
|
|
bool operator!() const { return fail(); }
|
|
|
|
iostate rdstate() const { return _M_iostate; }
|
|
|
|
bool good() const { return _M_iostate == 0; }
|
|
bool eof() const { return (_M_iostate & eofbit) != 0; }
|
|
bool fail() const { return (_M_iostate & (failbit | badbit)) != 0; }
|
|
bool bad() const { return (_M_iostate & badbit) != 0; }
|
|
|
|
protected: // The functional protected interface.
|
|
|
|
// Copies the state of __x to *this. This member function makes it
|
|
// possible to implement basic_ios::copyfmt without having to expose
|
|
// ios_base's private data members. Does not copy _M_exception_mask
|
|
// or _M_iostate.
|
|
void _M_copy_state(const ios_base& __x);
|
|
|
|
void _M_setstate_nothrow(iostate __state) { _M_iostate |= __state; }
|
|
void _M_clear_nothrow(iostate __state) { _M_iostate = __state; }
|
|
iostate _M_get_exception_mask() const { return _M_exception_mask; }
|
|
void _M_set_exception_mask(iostate __mask) { _M_exception_mask = __mask; }
|
|
void _M_check_exception_mask() {
|
|
if (_M_iostate & _M_exception_mask)
|
|
_M_throw_failure();
|
|
}
|
|
|
|
void _M_invoke_callbacks(event);
|
|
void _M_throw_failure();
|
|
|
|
ios_base(); // Default constructor.
|
|
|
|
protected: // Initialization of the I/O system
|
|
static void _STLP_CALL _S_initialize();
|
|
static void _STLP_CALL _S_uninitialize();
|
|
static bool _S_was_synced;
|
|
|
|
private: // Invalidate the copy constructor and
|
|
// assignment operator.
|
|
ios_base(const ios_base&);
|
|
void operator=(const ios_base&);
|
|
|
|
private: // Data members.
|
|
|
|
fmtflags _M_fmtflags; // Flags
|
|
iostate _M_iostate;
|
|
openmode _M_openmode;
|
|
seekdir _M_seekdir;
|
|
iostate _M_exception_mask;
|
|
|
|
streamsize _M_precision;
|
|
streamsize _M_width;
|
|
|
|
locale _M_locale;
|
|
|
|
pair<event_callback, int>* _M_callbacks;
|
|
size_t _M_num_callbacks; // Size of the callback array.
|
|
size_t _M_callback_index; // Index of the next available callback;
|
|
// initially zero.
|
|
|
|
long* _M_iwords; // Auxiliary storage. The count is zero
|
|
size_t _M_num_iwords; // if and only if the pointer is null.
|
|
|
|
void** _M_pwords;
|
|
size_t _M_num_pwords;
|
|
|
|
static int _S_index;
|
|
|
|
protected:
|
|
// Cached copies of the curent locale's facets. Set by init() and imbue().
|
|
locale::facet* _M_cached_ctype;
|
|
locale::facet* _M_cached_numpunct;
|
|
string _M_cached_grouping;
|
|
public:
|
|
// Equivalent to &use_facet< Facet >(getloc()), but faster.
|
|
const locale::facet* _M_ctype_facet() const { return _M_cached_ctype; }
|
|
const locale::facet* _M_numpunct_facet() const { return _M_cached_numpunct; }
|
|
const string& _M_grouping() const { return _M_cached_grouping; }
|
|
public:
|
|
|
|
// ----------------------------------------------------------------------
|
|
// Nested initializer class. This is an implementation detail, but it's
|
|
// prescribed by the standard. The static initializer object (on
|
|
// implementations where such a thing is required) is declared in
|
|
// <iostream>
|
|
|
|
class _STLP_CLASS_DECLSPEC Init {
|
|
public:
|
|
Init();
|
|
~Init();
|
|
private:
|
|
static long _S_count;
|
|
friend class ios_base;
|
|
};
|
|
|
|
// this class is needed to ensure locale initialization w/o <iostream> inclusion
|
|
class _STLP_CLASS_DECLSPEC _Loc_init {
|
|
public:
|
|
_Loc_init();
|
|
~_Loc_init();
|
|
private:
|
|
static long _S_count;
|
|
friend class locale;
|
|
friend class ios_base;
|
|
};
|
|
|
|
friend class Init;
|
|
|
|
public:
|
|
# ifndef _STLP_NO_ANACHRONISMS
|
|
// 31.6 Old iostreams members [depr.ios.members]
|
|
typedef iostate io_state;
|
|
typedef openmode open_mode;
|
|
typedef seekdir seek_dir;
|
|
typedef _STLP_STD::streamoff streamoff;
|
|
typedef _STLP_STD::streampos streampos;
|
|
# endif
|
|
};
|
|
|
|
template <class Facet>
|
|
locale::facet* _M_get_facet(ios_base& __i, Facet*)
|
|
{
|
|
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
// ios_base manipulator functions, from section 27.4.5 of the C++ standard.
|
|
// All of them are trivial one-line wrapper functions.
|
|
|
|
// fmtflag manipulators, section 27.4.5.1
|
|
inline ios_base& _STLP_CALL boolalpha(ios_base& __s)
|
|
{ __s.setf(ios_base::boolalpha); return __s;}
|
|
|
|
inline ios_base& _STLP_CALL noboolalpha(ios_base& __s)
|
|
{ __s.unsetf(ios_base::boolalpha); return __s;}
|
|
|
|
inline ios_base& _STLP_CALL showbase(ios_base& __s)
|
|
{ __s.setf(ios_base::showbase); return __s;}
|
|
|
|
inline ios_base& _STLP_CALL noshowbase(ios_base& __s)
|
|
{ __s.unsetf(ios_base::showbase); return __s;}
|
|
|
|
inline ios_base& _STLP_CALL showpoint(ios_base& __s)
|
|
{ __s.setf(ios_base::showpoint); return __s;}
|
|
|
|
inline ios_base& _STLP_CALL noshowpoint(ios_base& __s)
|
|
{ __s.unsetf(ios_base::showpoint); return __s;}
|
|
|
|
inline ios_base& _STLP_CALL showpos(ios_base& __s)
|
|
{ __s.setf(ios_base::showpos); return __s;}
|
|
|
|
inline ios_base& _STLP_CALL noshowpos(ios_base& __s)
|
|
{ __s.unsetf(ios_base::showpos); return __s;}
|
|
|
|
inline ios_base& _STLP_CALL skipws(ios_base& __s)
|
|
{ __s.setf(ios_base::skipws); return __s;}
|
|
|
|
inline ios_base& _STLP_CALL noskipws(ios_base& __s)
|
|
{ __s.unsetf(ios_base::skipws); return __s;}
|
|
|
|
inline ios_base& _STLP_CALL uppercase(ios_base& __s)
|
|
{ __s.setf(ios_base::uppercase); return __s;}
|
|
|
|
inline ios_base& _STLP_CALL nouppercase(ios_base& __s)
|
|
{ __s.unsetf(ios_base::uppercase); return __s;}
|
|
|
|
inline ios_base& _STLP_CALL unitbuf(ios_base& __s)
|
|
{ __s.setf(ios_base::unitbuf); return __s;}
|
|
|
|
inline ios_base& _STLP_CALL nounitbuf(ios_base& __s)
|
|
{ __s.unsetf(ios_base::unitbuf); return __s;}
|
|
|
|
|
|
// adjustfield manipulators, section 27.4.5.2
|
|
inline ios_base& _STLP_CALL internal(ios_base& __s)
|
|
{ __s.setf(ios_base::internal, ios_base::adjustfield); return __s; }
|
|
|
|
inline ios_base& _STLP_CALL left(ios_base& __s)
|
|
{ __s.setf(ios_base::left, ios_base::adjustfield); return __s; }
|
|
|
|
inline ios_base& _STLP_CALL right(ios_base& __s)
|
|
{ __s.setf(ios_base::right, ios_base::adjustfield); return __s; }
|
|
|
|
// basefield manipulators, section 27.4.5.3
|
|
inline ios_base& _STLP_CALL dec(ios_base& __s)
|
|
{ __s.setf(ios_base::dec, ios_base::basefield); return __s; }
|
|
|
|
inline ios_base& _STLP_CALL hex(ios_base& __s)
|
|
{ __s.setf(ios_base::hex, ios_base::basefield); return __s; }
|
|
|
|
inline ios_base& _STLP_CALL oct(ios_base& __s)
|
|
{ __s.setf(ios_base::oct, ios_base::basefield); return __s; }
|
|
|
|
|
|
// floatfield manipulators, section 27.4.5.3
|
|
inline ios_base& _STLP_CALL fixed(ios_base& __s)
|
|
{ __s.setf(ios_base::fixed, ios_base::floatfield); return __s; }
|
|
|
|
inline ios_base& _STLP_CALL scientific(ios_base& __s)
|
|
{ __s.setf(ios_base::scientific, ios_base::floatfield); return __s; }
|
|
|
|
#if defined(__BORLANDC__) && defined(_RTLDLL)
|
|
|
|
long ios_base::_Loc_init::_S_count = 0;
|
|
|
|
void _STLP_CALL _Stl_loc_init_num_put();
|
|
void _STLP_CALL _Stl_loc_init_num_get();
|
|
void _STLP_CALL _Stl_loc_init_monetary();
|
|
void _STLP_CALL _Stl_loc_init_time_facets();
|
|
|
|
inline ios_base::_Loc_init::_Loc_init() {
|
|
if (_S_count++ == 0) {
|
|
_Stl_loc_init_num_put();
|
|
_Stl_loc_init_num_get();
|
|
_Stl_loc_init_monetary();
|
|
_Stl_loc_init_time_facets();
|
|
locale::_S_initialize();
|
|
}
|
|
}
|
|
|
|
inline ios_base::_Loc_init::~_Loc_init() {
|
|
if (--_S_count == 0)
|
|
locale::_S_uninitialize();
|
|
}
|
|
|
|
#endif /* __BORLANDC__ */
|
|
|
|
_STLP_END_NAMESPACE
|
|
|
|
#endif /* _STLP_IOS_BASE */
|
|
|
|
// Local Variables:
|
|
// mode:C++
|
|
// End:
|
|
|