X-Git-Url: http://git.buserror.net/cgi-bin/gitweb.cgi?p=polintos%2Fscott%2Fpriv.git;a=blobdiff_plain;f=include%2Fc%2B%2B%2Fstl%2Fstl%2F_ios_base.h;fp=include%2Fc%2B%2B%2Fstl%2Fstl%2F_ios_base.h;h=b90606a4bd0b3b648e59fdc86eb9514f553661f2;hp=0000000000000000000000000000000000000000;hb=173d8903eb9d51a4ea7d7fa3e52dc86c9bb6d4f1;hpb=b024710fe2b60cd4a42a8993b61333d6cdb56ca3 diff --git a/include/c++/stl/stl/_ios_base.h b/include/c++/stl/stl/_ios_base.h new file mode 100644 index 0000000..b90606a --- /dev/null +++ b/include/c++/stl/stl/_ios_base.h @@ -0,0 +1,368 @@ +/* + * 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_INTERNAL_STDEXCEPT_BASE +# include +#endif + +#ifndef _STLP_UTILITY +# include +#endif + +#ifndef _STLP_INTERNAL_LOCALE_H +# include +#endif + +#ifndef _STLP_INTERNAL_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. + +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. +#if defined (_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 _STLP_FUNCTION_THROWS _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* _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; + +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: + Init(); + ~Init(); + private: + static long _S_count; + 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 +}; + +// ---------------------------------------------------------------------- +// 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; } + +_STLP_END_NAMESPACE + +#endif /* _STLP_IOS_BASE */ + +// Local Variables: +// mode:C++ +// End: +