ios.cpp

Go to the documentation of this file.

 
#define _RWSTD_LIB_SRC
 
#include <stdlib.h>
#include <string.h>
 
#include <iosfwd>
 
#include <rw/_error.h>
 
#include "iosdata.h"
 
#include <rw/_defs.h>
 
 
_RWSTD_NAMESPACE (__rw) {
 
// array of pointers to the 8 standard iostream objects
_RWSTD_EXPORT const void* __rw_std_streams [8];
 
}   // namespace __rw
 
 
_RWSTD_NAMESPACE (std) { 
 
 
ios_base::ios_base ()
    : _C_usr (0)
{
    // outlined to hide implementation details
    // no-op
}
 
 
// std::cin and std::wcin _C_usr_data structures
ios_base::_C_usr_data ios_base::_C_usr_data::_C_std_usr_data [2];
 
 
ios_base::~ios_base()
{
    // verify that _C_usr_data is a POD (i.e., has no user-defined ctor)
    // necessary in order for the C_std_usr_data array defined above to
    // not be overwritten during dynamic initialization
    union U {
        ios_base::_C_usr_data dummy;
    };
 
    // MT guard or reentrancy not necessary in a dtor
 
    if (_C_usr) {
        // invoke through a member pointer to avoid a link-time dependency
        // of this translation unit on the one that defines the member
        // function ios_base::_C_fire_event()
        if (_C_usr->_C_fire)
            (this->*_C_usr->_C_fire)(erase_event, false /* not reentrant */);
 
        _C_usr_data::_C_dealloc (_C_usr);
    }
}
 
 
streamsize ios_base::precision (streamsize prec)
{
    // outlined to hide implementation details
    return _RWSTD_ATOMIC_IO_SWAP (_C_prec, prec, _C_mutex);
}
 
 
ios_base::fmtflags ios_base::flags (fmtflags fl)
{
    const unsigned mask =
        ~(unsigned (_RWSTD_IOS_BASEMASK) << _RWSTD_IOS_BASEOFF);
 
    unsigned ifl = unsigned (fl);
 
    switch (fl & basefield) {
        // if basefield is set, clear the base mask and set
        // the numeric base bits according to the basefield
    case oct:
        ifl = ifl &  mask | 8U << _RWSTD_IOS_BASEOFF;
        break;
 
    case dec:
        ifl = ifl & mask | 10U << _RWSTD_IOS_BASEOFF;
        break;
 
    case hex:
        ifl = ifl & mask | 16U << _RWSTD_IOS_BASEOFF;
        break;
 
    case _RWSTD_IOS_BIN:
        ifl = ifl & mask | 2U << _RWSTD_IOS_BASEOFF;
        break;
 
    case 0:
        // if basefield is clear and the numeric base bits are set,
        // set the basefield accordingly, making sure that when
        // numeric base bits are set to 10, dec is left alone
        // (necessary for autodected parsing to work correctly)
        switch (ifl >> _RWSTD_IOS_BASEOFF) {
        case  0: ifl |= 10U << _RWSTD_IOS_BASEOFF; break;
        case  2: ifl |= _RWSTD_IOS_BIN; break;
        case  8: ifl |= oct; break;
        case 10: /* no-op */ break;
        case 16: ifl |= hex; break;
        }
        break;
 
    default:
        ifl |= 10U << _RWSTD_IOS_BASEOFF;
    }
 
    return fmtflags (_RWSTD_ATOMIC_IO_SWAP (_C_fmtfl, ifl, _C_mutex));
}
 
 
locale ios_base::imbue (const locale &loc)
{
    // outlined to hide implementation details
 
    _RWSTD_MT_GUARD (flags () & _RW::__rw_nolock ? 0 : &_C_mutex);
 
    return _C_unsafe_imbue (loc);
}
 
 
/* static */ bool ios_base::_C_sync_with_stdio = true;
 
/* static */ bool ios_base::sync_with_stdio (bool syncflag /* = true */)
{
    // outlined to hide implementation details
 
    // always atomic in MT environments since _C_sync is static
    return _RWSTD_ATOMIC_SWAP (_C_sync_with_stdio, syncflag, false);
}
 
 
void ios_base::_C_init (void *sb)
{
    // not guarded, assumed to be called only from ctors
    // all members are assumed to be uninitialized
 
    // NOTE: `sb' may point to a yet uninitialized object
    //       it is unsafe to reference any of its members
 
    const unsigned fmtfl = (10U << _RWSTD_IOS_BASEOFF) | skipws | dec;
 
    _C_state  = (_C_rdbuf = sb) ? goodbit : badbit;
    _C_fmtfl  = fmtfl;
    _C_wide   = 0;
    _C_prec   = 6;
    _C_except = 0;
 
#if     defined (_RWSTD_REENTRANT)             \
    && !defined (_RWSTD_NO_EXT_REENTRANT_IO)   \
    && !defined (_RWSTD_NO_REENTRANT_IO_DEFAULT)
 
    // disable locking of iostream objects and their associated buffers
    // standard iostream objects will override in ios_base::Init::Init()
    _C_fmtfl  |= _RW::__rw_nolock | _RW::__rw_nolockbuf;
 
#endif   // _RWSTD_REENTRANT && !_RWSTD_NO_REENTRANT_IO && ...
}
 
 
locale ios_base::_C_unsafe_imbue (const locale &loc)
{
    // outlined to hide implementation details
 
    const locale tmp (_C_loc);
 
    _C_loc = loc;
 
    if (_C_usr) {
        // invoke through a member pointer to avoid a link-time dependency
        // of this translation unit on the one that defines the member
        // function ios_base::_C_fire_event()
        if (_C_usr->_C_fire)
            (this->*_C_usr->_C_fire)(imbue_event, true /* reentrant */);
    }
 
    return tmp;  
}
 
 
void* ios_base::
_C_set (unsigned state, unsigned except, void *rdbuf)
{
    _RWSTD_MT_GUARD ((_C_fmtfl | except) & _RW::__rw_nolock ? 0 : &_C_mutex);
 
    except &= ~_RW::__rw_nolock;
 
    if (!rdbuf)
        state |= badbit;
 
    void* const rdbuf_save = _C_rdbuf;
 
    _C_rdbuf  = rdbuf;
    _C_state  = iostate (state & ~(_RW::__rw_nothrow | _RW::__rw_rethrow));
    _C_except = except;
 
#ifndef _RWSTD_NO_EXCEPTIONS
 
    if (!(state & _RW::__rw_nothrow) && (state & except)) {
 
        if (state & _RW::__rw_rethrow)
            throw;
 
        const char *bit =
            "std::ios::badbit, std::ios::failbit, std::ios::eofbit";
 
        static const char streams[][11] = {
            "std::cin", "std::cout", "std::cerr", "std::clog",
            "std::wcin", "std::wcout", "std::wcerr", "std::wclog"
        };
 
        // is `this' one of the standard iostreams or is it user-defined?
        const char *strm = "user-defined";
        for (const void * const *ps = _RW::__rw_std_streams; *ps; ++ps) {
            if (this == *ps)
                strm = streams [ps - _RW::__rw_std_streams];
        }
 
        switch (state & except) {
 
#ifndef _RWSTD_NO_EXT_FAILURE
 
        // casts below are necessary to preserve the static type
        // of the exception being thrown (upcast by _C_format ())
 
        case _RWSTD_IOS_BADBIT:
            _RW::__rw_throw (_RWSTD_ERROR_BADBIT_SET, strm);
 
        case _RWSTD_IOS_FAILBIT:
            _RW::__rw_throw (_RWSTD_ERROR_FAILBIT_SET, strm);
            
        case _RWSTD_IOS_EOFBIT:
            _RW::__rw_throw (_RWSTD_ERROR_EOFBIT_SET, strm);
 
#else   // if defined (_RWSTD_NO_EXT_FAILURE)
 
        case _RWSTD_IOS_BADBIT:
            bit = "badbit";
            break;
 
        case _RWSTD_IOS_FAILBIT:
            bit = "failbit";
            break;
 
        case _RWSTD_IOS_EOFBIT:
            bit = "eofbit";
            break;
 
#endif   // _RWSTD_NO_EXT_FAILURE
 
        case _RWSTD_IOS_BADBIT | _RWSTD_IOS_FAILBIT:
            bit = "badbit, failbit";
            break;
 
        case _RWSTD_IOS_BADBIT | _RWSTD_IOS_EOFBIT:
            bit = "badbit, eofbit";
            break;
 
        case _RWSTD_IOS_FAILBIT | _RWSTD_IOS_EOFBIT:
            bit = "failbit, eofbit";
            break;
        }
 
        _RW::__rw_throw (_RWSTD_ERROR_IOSTATE_BIT_SET, strm, bit);
    }
 
#endif   // !defined (_RWSTD_NO_EXCEPTIONS)
 
    return rdbuf_save;
}
 
 
void* ios_base::_C_tie () const
{
    // outlined to hide implementation details
 
    return _C_usr ? _C_usr->_C_tie : 0;
}
 
 
void* ios_base::_C_tie (void *pstrm)
{
    _RWSTD_MT_GUARD (flags () & _RW::__rw_nolock ? 0 : &_C_mutex);
 
    void *save = 0;
 
    if (_C_usr) {
        save = _C_usr->_C_tie;
 
        if (   !pstrm
            && !_C_usr->_C_iarray
            && !_C_usr->_C_parray
            && !_C_usr->_C_cbarray) {
            _C_usr_data::_C_dealloc (_C_usr);
            _C_usr = 0;
        }
    }
    else if (pstrm)
        _C_usr = _C_usr_data::_C_alloc (0);
 
    if (_C_usr)
        _C_usr->_C_tie = pstrm;
 
    return save;
}
 
 
}  // namespace std