RomkaZVO/FC1
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

123

Browse Source
This commit is contained in:
romkazvo
2023-08-07 19:29:24 +08:00
commit 34d6c5d489
4832 changed files with 1389451 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

409
STLPORT/stlport/stl/_ios_base.h Normal file
View File

@@ -0,0 +1,409 @@
/*
* 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: