You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
645 lines
16 KiB
645 lines
16 KiB
// -*- C++ -*-
|
|
/***************************************************************************
|
|
*
|
|
* _iosbase.h - Declarations for the Standard Library basic stream I/O
|
|
*
|
|
* This is an internal header file used to implement the C++ Standard
|
|
* Library. It should never be #included directly by a program.
|
|
*
|
|
* $Id: _iosbase.h 185734 2014-06-12 16:07:42Z statham $
|
|
*
|
|
***************************************************************************
|
|
*
|
|
* Copyright (c) 1994-2001 Rogue Wave Software, Inc. All Rights Reserved.
|
|
*
|
|
* This computer software is owned by Rogue Wave Software, Inc. and is
|
|
* protected by U.S. copyright laws and other laws and by international
|
|
* treaties. This computer software is furnished by Rogue Wave Software,
|
|
* Inc. pursuant to a written license agreement and may be used, copied,
|
|
* transmitted, and stored only in accordance with the terms of such
|
|
* license and with the inclusion of the above copyright notice. This
|
|
* computer software or any other copies thereof may not be provided or
|
|
* otherwise made available to any other person.
|
|
*
|
|
* U.S. Government Restricted Rights. This computer software is provided
|
|
* with Restricted Rights. Use, duplication, or disclosure by the
|
|
* Government is subject to restrictions as set forth in subparagraph (c)
|
|
* (1) (ii) of The Rights in Technical Data and Computer Software clause
|
|
* at DFARS 252.227-7013 or subparagraphs (c) (1) and (2) of the
|
|
* Commercial Computer Software--Restricted Rights at 48 CFR 52.227-19,
|
|
* as applicable. Manufacturer is Rogue Wave Software, Inc., 5500
|
|
* Flatiron Parkway, Boulder, Colorado 80301 USA.
|
|
*
|
|
**************************************************************************/
|
|
|
|
#ifndef _RWSTD_IOSBASE_H_INCLUDED
|
|
#define _RWSTD_IOSBASE_H_INCLUDED
|
|
|
|
#include <iosfwd>
|
|
|
|
#include <rw/_locale.h>
|
|
#include <rw/_mutex.h>
|
|
#include <rw/_defs.h>
|
|
#include <rw/_traits.h>
|
|
|
|
//#include <fcntl.h> Rogue Wave Bug
|
|
|
|
//#ifndef _RWSTD_NO_EXCEPTIONS Rogue Wave Bug
|
|
# include <rw/_exception.h>
|
|
//#endif // _RWSTD_NO_EXCEPTIONS Rogue Wave Bug
|
|
|
|
|
|
_RWSTD_NAMESPACE_BEGIN (std)
|
|
|
|
|
|
class _RWSTD_EXPORT ios_base: public _RW::__rw_synchronized
|
|
{
|
|
public:
|
|
|
|
// 27.4.2.1.1
|
|
class _RWSTD_EXPORT failure : public __rw_exception {
|
|
public:
|
|
_EXPLICIT failure (const string& __what):
|
|
__rw_exception (__what) { }
|
|
|
|
// extension
|
|
_EXPLICIT failure (const char *__what = 0):
|
|
__rw_exception (__what) { }
|
|
};
|
|
|
|
|
|
#ifndef _RWSTD_NO_EXT_FAILURE
|
|
|
|
// extensions
|
|
class badbit_set : public failure { public: badbit_set() {} };
|
|
|
|
class eofbit_set : public failure { public: eofbit_set() {} };
|
|
|
|
class failbit_set : public failure { public: failbit_set() {} };
|
|
|
|
#endif // _RWSTD_NO_EXT_FAILURE
|
|
|
|
// 27.4.2.1.2
|
|
typedef int fmtflags;
|
|
|
|
// insert and extract bool type in alphabetic format
|
|
_RWSTD_STATIC_CONST (fmtflags, boolalpha = _RWSTD_IOS_BOOLALPHA);
|
|
|
|
// converts integer input or generates integer output in decimal base
|
|
_RWSTD_STATIC_CONST (fmtflags, dec = _RWSTD_IOS_DEC);
|
|
|
|
// generate floating-point output in fixed-point notation
|
|
_RWSTD_STATIC_CONST (fmtflags, fixed = _RWSTD_IOS_FIXED);
|
|
|
|
// converts integer input or generates integer output in hexadecimal base
|
|
_RWSTD_STATIC_CONST (fmtflags, hex = _RWSTD_IOS_HEX);
|
|
|
|
// adds fill characters at a designated internal point in certain generated
|
|
// output, or identical to right if no such point is designated
|
|
_RWSTD_STATIC_CONST (fmtflags, internal = _RWSTD_IOS_INTERNAL);
|
|
|
|
// adds fill characters on the right of certain generated output
|
|
_RWSTD_STATIC_CONST (fmtflags, left = _RWSTD_IOS_LEFT);
|
|
|
|
// converts integer input or generates integer output in octal base
|
|
_RWSTD_STATIC_CONST (fmtflags, oct = _RWSTD_IOS_OCT);
|
|
|
|
// adds fill characters on the left of certain generated output
|
|
_RWSTD_STATIC_CONST (fmtflags, right = _RWSTD_IOS_RIGHT);
|
|
|
|
// generates floating-point output in scientific notation
|
|
_RWSTD_STATIC_CONST (fmtflags, scientific = _RWSTD_IOS_SCIENTIFIC);
|
|
|
|
// generates a prefix indicating the numeric base of generated integer
|
|
// output (bin - none, oct - "0", dec - none, hex - "0x")
|
|
_RWSTD_STATIC_CONST (fmtflags, showbase = _RWSTD_IOS_SHOWBASE);
|
|
|
|
// generates a decimal-point character unconditionally in generated
|
|
// floating-point output
|
|
_RWSTD_STATIC_CONST (fmtflags, showpoint = _RWSTD_IOS_SHOWPOINT);
|
|
|
|
// generates a + sign in non-negative generated numeric output
|
|
_RWSTD_STATIC_CONST (fmtflags, showpos = _RWSTD_IOS_SHOWPOS);
|
|
|
|
// skips leading white space before certain input operations
|
|
_RWSTD_STATIC_CONST (fmtflags, skipws = _RWSTD_IOS_SKIPWS);
|
|
|
|
// flushes output after each output operation
|
|
_RWSTD_STATIC_CONST (fmtflags, unitbuf = _RWSTD_IOS_UNITBUF);
|
|
|
|
// replaces certain lowercase letters with their uppercase equivalents
|
|
// in generated output
|
|
_RWSTD_STATIC_CONST (fmtflags, uppercase = _RWSTD_IOS_UPPERCASE);
|
|
|
|
#ifndef _RWSTD_NO_EXT_BIN_IO
|
|
|
|
// extension - converts integer input or generates integer output
|
|
// in binary base
|
|
_RWSTD_STATIC_CONST (fmtflags, bin = _RWSTD_IOS_BIN);
|
|
|
|
#endif // _RWSTD_NO_EXT_BIN_IO
|
|
|
|
_RWSTD_STATIC_CONST (fmtflags, basefield = _RWSTD_IOS_BASEFIELD);
|
|
_RWSTD_STATIC_CONST (fmtflags, adjustfield = _RWSTD_IOS_ADJUSTFIELD);
|
|
_RWSTD_STATIC_CONST (fmtflags, floatfield = _RWSTD_IOS_FLOATFIELD);
|
|
|
|
#ifndef _RWSTD_NO_EXT_REENTRANT_IO
|
|
|
|
// extension: never locks the object in MT environments
|
|
_RWSTD_STATIC_CONST (fmtflags, nolock = _RWSTD_IOS_NOLOCK);
|
|
|
|
// extension: never locks stream buffer in MT environments
|
|
_RWSTD_STATIC_CONST (fmtflags, nolockbuf = _RWSTD_IOS_NOLOCKBUF);
|
|
|
|
#endif // _RWSTD_NO_EXT_REENTRANT_IO
|
|
|
|
// 27.4.2.1.3
|
|
typedef int iostate;
|
|
|
|
_RWSTD_STATIC_CONST (iostate, goodbit = _RWSTD_IOS_GOODBIT);
|
|
|
|
// indicates a loss of integrity in an input or output sequence
|
|
// (such as an irrecoverable read error from a file);
|
|
_RWSTD_STATIC_CONST (iostate, badbit = _RWSTD_IOS_BADBIT);
|
|
|
|
// indicates that an input operation reached the end of an input sequence
|
|
_RWSTD_STATIC_CONST (iostate, eofbit = _RWSTD_IOS_EOFBIT);
|
|
|
|
// indicates that an input operation failed to read the expected
|
|
// characters, or that an output operation failed to generate the
|
|
// desired characters
|
|
_RWSTD_STATIC_CONST (iostate, failbit = _RWSTD_IOS_FAILBIT);
|
|
|
|
// 27.4.2.1.4
|
|
typedef int openmode;
|
|
|
|
// seek to end before each write
|
|
_RWSTD_STATIC_CONST (openmode, app = _RWSTD_IOS_APP);
|
|
|
|
// perform input and output in binary mode (as opposed to text mode)
|
|
_RWSTD_STATIC_CONST (openmode, binary = _RWSTD_IOS_BINARY);
|
|
|
|
// open for input
|
|
_RWSTD_STATIC_CONST (openmode, in = _RWSTD_IOS_IN);
|
|
|
|
// open for output
|
|
_RWSTD_STATIC_CONST (openmode, out = _RWSTD_IOS_OUT);
|
|
|
|
// truncate an existing stream when opening
|
|
_RWSTD_STATIC_CONST (openmode, trunc = _RWSTD_IOS_TRUNC);
|
|
|
|
// open and seek to end immediately after opening
|
|
_RWSTD_STATIC_CONST (openmode, ate = _RWSTD_IOS_ATE);
|
|
|
|
#ifndef _RWSTD_STRICT_ANSI
|
|
|
|
// do not create a (file) stream if it doesn't exist
|
|
_RWSTD_STATIC_CONST (openmode, nocreate = _RWSTD_IOS_NOCREATE);
|
|
|
|
// do not eplace an existing (file) stream
|
|
_RWSTD_STATIC_CONST (openmode, noreplace = _RWSTD_IOS_NOREPLACE);
|
|
|
|
#endif // _RWSTD_STRICT_ANSI
|
|
|
|
enum _C_seekdir {
|
|
_C_beg = SEEK_SET,
|
|
_C_cur = SEEK_CUR,
|
|
_C_end = SEEK_END
|
|
};
|
|
|
|
#ifndef _RWSTD_NO_STATIC_CONST_MEMBER_INIT
|
|
|
|
typedef _C_seekdir seekdir;
|
|
|
|
#else
|
|
|
|
typedef int seekdir;
|
|
|
|
#endif // _RWSTD_NO_STATIC_CONST_MEMBER_INIT
|
|
|
|
// 27.4.2.1.5, p1
|
|
_RWSTD_STATIC_CONST (seekdir, beg = _C_beg);
|
|
_RWSTD_STATIC_CONST (seekdir, cur = _C_cur);
|
|
_RWSTD_STATIC_CONST (seekdir, end = _C_end);
|
|
|
|
#ifndef _RWSTD_NO_DEPRECATED
|
|
|
|
// D.6, p1
|
|
typedef seekdir seek_dir;
|
|
typedef openmode open_mode;
|
|
typedef iostate io_state;
|
|
typedef _STD::streamoff streamoff;
|
|
typedef _STD::streampos streampos;
|
|
|
|
#endif // _RWSTD_NO_DEPRECATED
|
|
|
|
|
|
// 27.4.2.1.6
|
|
class _RWSTD_EXPORT Init {
|
|
static int _C_initcnt; // initialization counter
|
|
public:
|
|
Init ();
|
|
|
|
~Init ();
|
|
};
|
|
|
|
// 27.4.2.2, p1
|
|
fmtflags flags () const {
|
|
return _C_fmtfl;
|
|
}
|
|
|
|
// 27.4.2.2, p2
|
|
fmtflags flags (fmtflags __f) {
|
|
return _RWSTD_ATOMIC_IO_SWAP (_C_fmtfl, __f, _C_mutex);
|
|
}
|
|
|
|
// 27.4.2.2, p4
|
|
fmtflags setf (fmtflags __f) {
|
|
return flags (flags () | __f);
|
|
}
|
|
|
|
// 27.4.2.2, p6
|
|
fmtflags setf (fmtflags __f, fmtflags __mask) {
|
|
return flags (flags () & ~__mask | __f & __mask);
|
|
}
|
|
|
|
// 27.4.2.2, p8
|
|
void unsetf (fmtflags __f) {
|
|
flags (flags () & ~__f);
|
|
}
|
|
|
|
// 27.4.2.2, p9
|
|
streamsize precision () const {
|
|
return _C_prec;
|
|
}
|
|
|
|
// 27.4.2.2, p10
|
|
streamsize precision (streamsize __p) {
|
|
return _RWSTD_ATOMIC_IO_SWAP (_C_prec, __p, _C_mutex);
|
|
}
|
|
|
|
// 27.4.2.2, p12
|
|
streamsize width () const {
|
|
return _C_wide;
|
|
}
|
|
|
|
// 27.4.2.2, p13
|
|
streamsize width (streamsize __w) {
|
|
return _RWSTD_ATOMIC_IO_SWAP (_C_wide, __w, _C_mutex);
|
|
}
|
|
|
|
// 27.4.2.3, p1
|
|
locale imbue (const locale&);
|
|
|
|
// extension: avoids reference counting in MT builds (may result in
|
|
// a speedup of up to 50%); this is an alternative to caching a reference
|
|
// (pointer) to a facet in each stream and stream buffer object
|
|
locale& getloc () {
|
|
return _C_loc;
|
|
}
|
|
|
|
// 27.4.2.3, p4
|
|
locale getloc () const {
|
|
return _C_loc;
|
|
}
|
|
|
|
// 27.4.2.5, p1
|
|
static int xalloc () {
|
|
return _RWSTD_ATOMIC_PREINCREMENT (_C_index, false) - 1;
|
|
}
|
|
|
|
// 27.4.2.5, p2
|
|
long& iword (int);
|
|
|
|
// 27.4.2.5, p4
|
|
void*& pword (int);
|
|
|
|
enum event { erase_event, imbue_event, copyfmt_event };
|
|
|
|
typedef void (*event_callback)(event, ios_base&, int);
|
|
|
|
// 27.5.2.6, p1
|
|
void register_callback (event_callback, int);
|
|
|
|
static bool _C_is_sync () {
|
|
return _C_sync_with_stdio;
|
|
}
|
|
|
|
// 27.4.2.4, p1
|
|
static bool sync_with_stdio (bool __sync = true) {
|
|
// always atomic in MT environments since _C_sync is static
|
|
return _RWSTD_ATOMIC_SWAP (_C_sync_with_stdio, __sync, false);
|
|
}
|
|
|
|
// 27.5.2.7, p2
|
|
virtual ~ios_base ();
|
|
|
|
// returns a numeric base as per 22.2.2.1.2, p 4
|
|
int _C_base () const {
|
|
fmtflags __flags = flags () & basefield;
|
|
return oct == __flags ? 8
|
|
: dec == __flags ? 10
|
|
: hex == __flags ? 16
|
|
|
|
#ifndef _RWSTD_NO_EXT_BIN_IO
|
|
|
|
: bin == __flags ? 2 // extension
|
|
|
|
#endif // _RWSTD_NO_EXT_BIN_IO
|
|
|
|
: 0; // anything else...
|
|
}
|
|
|
|
protected:
|
|
|
|
// will be reentrant if __reentrant is true, non-reentrant otherwise
|
|
void _C_fire_event (event, bool __reentrant);
|
|
|
|
// unsafe members - not synchronized in MT environments
|
|
void _C_copyfmt (const ios_base&);
|
|
|
|
// may throw (second argument is a bitmap of exceptions considered)
|
|
// returns exceptions that would have been thrown had they not been masked
|
|
iostate _C_unsafe_clear (iostate = goodbit, iostate = ~0);
|
|
|
|
// called from basic_ios<>::imbue ()
|
|
locale _C_unsafe_imbue (const locale&);
|
|
|
|
// 27.5.2.7, p1
|
|
ios_base ();
|
|
|
|
fmtflags _C_fmtfl; // formatting flags
|
|
streamsize _C_prec; // current precision
|
|
streamsize _C_wide; // current width
|
|
iostate _C_state; // stream state
|
|
iostate _C_except; // active exceptions
|
|
|
|
private:
|
|
|
|
ios_base (const ios_base&); //not defined
|
|
ios_base& operator= (const ios_base&); //not defined
|
|
|
|
struct _C_event_cb {
|
|
int _C_index;
|
|
event_callback _C_fn;
|
|
};
|
|
|
|
locale _C_loc; // locale associated with stream
|
|
|
|
long *_C_iarray; // user long data
|
|
void* *_C_parray; // user void* data
|
|
|
|
size_t _C_isize; // size of _C_iarray in elements
|
|
size_t _C_psize; // size of _C_parray in elements
|
|
|
|
_C_event_cb *_C_cbarray; // array of user-registered callbacks
|
|
size_t _C_cbsize; // size of _C_cbarray in elems
|
|
|
|
static int _C_index; // used by xalloc to obtain a unique index
|
|
static bool _C_sync_with_stdio;
|
|
};
|
|
|
|
|
|
inline ios_base::ios_base ()
|
|
: _C_iarray (0),
|
|
_C_parray (0),
|
|
_C_isize (0),
|
|
_C_psize (0),
|
|
_C_cbarray (0),
|
|
_C_cbsize (0)
|
|
{
|
|
}
|
|
|
|
|
|
inline ios_base::~ios_base()
|
|
{
|
|
// MT guard or reentrancy not necessary in a dtor
|
|
_C_fire_event (erase_event, false /* not reentrant */);
|
|
|
|
delete [] _C_iarray;
|
|
delete [] _C_parray;
|
|
delete [] _C_cbarray;
|
|
}
|
|
|
|
|
|
inline locale ios_base::_C_unsafe_imbue (const locale& __loc)
|
|
{
|
|
locale __tmp = _C_loc;
|
|
_C_loc = __loc;
|
|
|
|
_C_fire_event (imbue_event, true /* reentrant */);
|
|
|
|
return __tmp;
|
|
}
|
|
|
|
|
|
inline locale ios_base::imbue (const locale& __loc)
|
|
{
|
|
_RWSTD_MT_GUARD (flags () & _RWSTD_IOS_NOLOCK ? 0 : &_C_mutex);
|
|
|
|
return _C_unsafe_imbue (__loc);
|
|
}
|
|
|
|
|
|
// 27.4.5.1 - fmtflags manipulators
|
|
|
|
// 27.4.5.1, p25
|
|
inline ios_base& unitbuf (ios_base& __strm)
|
|
{
|
|
__strm.setf (ios_base::unitbuf);
|
|
return __strm;
|
|
}
|
|
|
|
|
|
// 27.4.5.1, p27
|
|
inline ios_base& nounitbuf (ios_base& __strm)
|
|
{
|
|
__strm.unsetf (ios_base::unitbuf);
|
|
return __strm;
|
|
}
|
|
|
|
|
|
// 27.4.5.1, p1
|
|
inline ios_base& boolalpha (ios_base& __strm)
|
|
{
|
|
__strm.setf (ios_base::boolalpha);
|
|
return __strm;
|
|
}
|
|
|
|
|
|
// 27.4.5.1, p3
|
|
inline ios_base& noboolalpha (ios_base& __strm)
|
|
{
|
|
__strm.unsetf (ios_base::boolalpha);
|
|
return __strm;
|
|
}
|
|
|
|
|
|
// 27.4.5.1, p5
|
|
inline ios_base& showbase (ios_base& __strm)
|
|
{
|
|
__strm.setf (ios_base::showbase);
|
|
return __strm;
|
|
}
|
|
|
|
|
|
// 27.4.5.1, p7
|
|
inline ios_base& noshowbase (ios_base& __strm)
|
|
{
|
|
__strm.unsetf (ios_base::showbase);
|
|
return __strm;
|
|
}
|
|
|
|
|
|
// 27.4.5.1, p9
|
|
inline ios_base& showpoint (ios_base& __strm)
|
|
{
|
|
__strm.setf (ios_base::showpoint);
|
|
return __strm;
|
|
}
|
|
|
|
|
|
// 27.4.5.1, p11
|
|
inline ios_base& noshowpoint (ios_base& __strm)
|
|
{
|
|
__strm.unsetf (ios_base::showpoint);
|
|
return __strm;
|
|
}
|
|
|
|
|
|
// 27.4.5.1, p13
|
|
inline ios_base& showpos (ios_base& __strm)
|
|
{
|
|
__strm.setf (ios_base::showpos);
|
|
return __strm;
|
|
}
|
|
|
|
|
|
// 27.4.5.1, p15
|
|
inline ios_base& noshowpos (ios_base& __strm)
|
|
{
|
|
__strm.unsetf (ios_base::showpos);
|
|
return __strm;
|
|
}
|
|
|
|
|
|
// 27.4.5.1, p17
|
|
inline ios_base& skipws (ios_base& __strm)
|
|
{
|
|
__strm.setf (ios_base::skipws);
|
|
return __strm;
|
|
}
|
|
|
|
|
|
// 27.4.5.1, p19
|
|
inline ios_base& noskipws (ios_base& __strm)
|
|
{
|
|
__strm.unsetf (ios_base::skipws);
|
|
return __strm;
|
|
}
|
|
|
|
|
|
// 27.4.5.1, p21
|
|
inline ios_base& uppercase (ios_base& __strm)
|
|
{
|
|
__strm.setf (ios_base::uppercase);
|
|
return __strm;
|
|
}
|
|
|
|
|
|
// 27.4.5.1, p23
|
|
inline ios_base& nouppercase (ios_base& __strm)
|
|
{
|
|
__strm.unsetf (ios_base::uppercase);
|
|
return __strm;
|
|
}
|
|
|
|
|
|
// 27.4.5.2 - adjustfield manipulators
|
|
|
|
// 27.4.5.2, p1
|
|
inline ios_base& internal (ios_base& __strm)
|
|
{
|
|
__strm.setf (ios_base::internal, ios_base::adjustfield);
|
|
return __strm;
|
|
}
|
|
|
|
|
|
// 27.4.5.2, p3
|
|
inline ios_base& left (ios_base& __strm)
|
|
{
|
|
__strm.setf (ios_base::left, ios_base::adjustfield);
|
|
return __strm;
|
|
}
|
|
|
|
|
|
// 27.4.5.2, p5
|
|
inline ios_base& right (ios_base& __strm)
|
|
{
|
|
__strm.setf (ios_base::right, ios_base::adjustfield);
|
|
return __strm;
|
|
}
|
|
|
|
|
|
// 27.4.5.3 - basefield manipulators
|
|
|
|
// 27.4.5.3, p1
|
|
inline ios_base& dec (ios_base& __strm)
|
|
{
|
|
__strm.setf (ios_base::dec, ios_base::basefield);
|
|
return __strm;
|
|
}
|
|
|
|
|
|
// 27.4.5.3, p3
|
|
inline ios_base& hex (ios_base& __strm)
|
|
{
|
|
__strm.setf (ios_base::hex, ios_base::basefield);
|
|
return __strm;
|
|
}
|
|
|
|
|
|
// 27.4.5.3, p5
|
|
inline ios_base& oct (ios_base& __strm)
|
|
{
|
|
__strm.setf (ios_base::oct, ios_base::basefield);
|
|
return __strm;
|
|
}
|
|
|
|
|
|
#ifndef _RWSTD_NO_EXT_BIN_IO
|
|
|
|
// extension
|
|
inline ios_base& bin (ios_base& __strm)
|
|
{
|
|
__strm.setf (ios_base::bin, ios_base::basefield);
|
|
return __strm;
|
|
}
|
|
|
|
#endif // _RWSTD_NO_EXT_BIN_IO
|
|
|
|
|
|
// 27.4.5.4 - floatfield manipulators
|
|
|
|
// 27.4.5.4, p1
|
|
inline ios_base& fixed (ios_base& __strm)
|
|
{
|
|
__strm.setf (ios_base::fixed, ios_base::floatfield);
|
|
return __strm;
|
|
}
|
|
|
|
|
|
// 27.4.5.4, p3
|
|
inline ios_base& scientific (ios_base& __strm)
|
|
{
|
|
__strm.setf (ios_base::scientific, ios_base::floatfield);
|
|
return __strm;
|
|
}
|
|
|
|
|
|
_RWSTD_NAMESPACE_END // std
|
|
|
|
|
|
#endif // _RWSTD_IOSBASE_H_INCLUDED
|
|
|