diff -r 2fe1408b6811 -r e1b950c65cb4 epoc32/include/stdapis/stlportv5/stl/_ios_base.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/epoc32/include/stdapis/stlportv5/stl/_ios_base.h Wed Mar 31 12:27:01 2010 +0100 @@ -0,0 +1,439 @@ +/* + * © Portions copyright (c) 2006-2007 Nokia Corporation. All rights reserved. + * 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 +#endif +#ifndef _STLP_UTILITY +#include +#endif +#ifndef _STLP_INTERNAL_LOCALE_H +#include +#endif +#ifndef _STLP_STRING_H +# include +#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. + +#ifdef __SYMBIAN32__ +class ios_base { +#else +class _STLP_CLASS_DECLSPEC ios_base { +#endif +public: + + class _STLP_CLASS_DECLSPEC failure : public __Named_exception { + public: + _STLP_DECLSPEC explicit failure(const string&); + _STLP_DECLSPEC 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 + _STLP_DECLSPEC locale imbue(const locale&); + _STLP_DECLSPEC locale getloc() const;// { return _M_locale; } + +public: // Auxiliary storage. + _STLP_DECLSPEC static int _STLP_CALL xalloc(); + _STLP_DECLSPEC long& iword(int __index); + _STLP_DECLSPEC void*& pword(int __index); + +public: // Destructor. + _STLP_DECLSPEC virtual ~ios_base(); + +public: // Callbacks. + enum event { erase_event, imbue_event, copyfmt_event }; + typedef void (*event_callback)(event, ios_base&, int __index); + _STLP_DECLSPEC void register_callback(event_callback __fn, int __index); + +public: // This member function affects only + // the eight predefined ios objects: + // cin, cout, etc. + _STLP_DECLSPEC 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. + _STLP_DECLSPEC 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(); + } + + _STLP_DECLSPEC void _M_invoke_callbacks(event); + _STLP_DECLSPEC void _M_throw_failure(); + + _STLP_DECLSPEC ios_base(); // Default constructor. + +protected: // Initialization of the I/O system + static void _STLP_CALL _S_initialize(); + static void _STLP_CALL _S_uninitialize(); +# if !defined(__LIBSTD_CPP_SYMBIAN32_WSD__) && !defined(_STLP_LIBSTD_CPP_NO_STATIC_VAR_) + static bool _S_was_synced; +# endif //__LIBSTD_CPP_SYMBIAN32_WSD__ + friend void CallIosInit(); +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* _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; + +# if !defined(__LIBSTD_CPP_SYMBIAN32_WSD__) && !defined(_STLP_LIBSTD_CPP_NO_STATIC_VAR_) + static int _S_index; +# endif //__LIBSTD_CPP_SYMBIAN32_WSD__ + + +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 + // + + class _STLP_CLASS_DECLSPEC Init { + public: + _STLP_DECLSPEC Init(); + _STLP_DECLSPEC ~Init(); + private: +# if !defined(__LIBSTD_CPP_SYMBIAN32_WSD__) && !defined(_STLP_LIBSTD_CPP_NO_STATIC_VAR_) + static long _S_count; +# endif //__LIBSTD_CPP_SYMBIAN32_WSD__ + friend class ios_base; + }; + + // this class is needed to ensure locale initialization w/o inclusion + class _STLP_CLASS_DECLSPEC _Loc_init { + public: + _STLP_DECLSPEC _Loc_init(); + _STLP_DECLSPEC ~_Loc_init(); + private: +# if !defined(__LIBSTD_CPP_SYMBIAN32_WSD__) && !defined(_STLP_LIBSTD_CPP_NO_STATIC_VAR_) + static long _S_count; +# endif //__LIBSTD_CPP_SYMBIAN32_WSD__ + 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 +}; + +inline _STLP_EXP_DECLSPEC locale ios_base::getloc() const + { + return _M_locale; + } + +// ---------------------------------------------------------------------- +// 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__ */ + +#if 0 +#ifdef __SYMBIAN32__ +#pragma message("Symbian I/O stream support on progress.") +inline ios_base::_Loc_init::_Loc_init() { +} + +inline ios_base::_Loc_init::~_Loc_init() { +} +#endif + +inline ios_base::Init::Init() { +} + +inline ios_base::Init::~Init() { +} +#endif + +_STLP_END_NAMESPACE + +#endif /* _STLP_IOS_BASE */ + +// Local Variables: +// mode:C++ +// End: +