iostore.cpp

Go to the documentation of this file.

 
#define _RWSTD_LIB_SRC
 
#include <string.h>        // memcpy(), memset()
#include <rw/_rawiter.h>   // get_temporary_buffer()
 
#include "iosdata.h"
 
#include <rw/_defs.h>
 
 
_RWSTD_NAMESPACE (__rw) {
 
 
// will grow an array of POD elements, never shrinks
static void*
__rw_realloc (void *array, _RWSTD_SIZE_T size, _RWSTD_SIZE_T &n, int inx)
{
    if (inx < 0)
        return 0;   // bad index
 
    if (_RWSTD_STATIC_CAST (_RWSTD_SIZE_T, inx) < n)
        return array;   // no need to reallocate
 
    void *tmp;
 
    _TRY {
        // make sure index is dereferencable (cast prevents HP aCC warnings)
        tmp = operator new (_RWSTD_STATIC_CAST (_RWSTD_SIZE_T, ++inx) * size);
    }
    _CATCH (...) {
        return 0;
    }
 
    _RWSTD_ASSERT (0 != tmp);
 
    // copy elements from array to tmp
    if (array)
        memcpy (tmp, array, n * size);
 
    // zero out newly allocated storage
    memset (_RWSTD_STATIC_CAST (char*, tmp) + n * size, 0, (inx - n) * size);
 
    // modify passed-in size
    n = _RWSTD_STATIC_CAST (_RWSTD_SIZE_T, inx);
 
    operator delete (array);
 
    return tmp;
}
 
 
}   // namespace __rw
 
 
_RWSTD_NAMESPACE (std) {
 
 
/* static */ int ios_base::xalloc ()
{
    // outlined to hide implementation details
 
    static int inx /* = 0 */;
 
    return _RWSTD_ATOMIC_PREINCREMENT (inx, false) - 1;
}
 
 
void ios_base::_C_fire_event (event ev, bool reentrant)
{
    if (!_C_usr)
        return;
 
    _C_usr_data::_C_event_cb *cba    = _C_usr->_C_cbarray;
    _RWSTD_SIZE_T             cbsize = _C_usr->_C_cbsize;
 
    // verify consistency (either both are 0 or neither is)
    _RWSTD_ASSERT (!!cba == !!cbsize);
 
    if (!cba)
        return;
 
    // caller expected to lock if necessary
 
    _TRY {
        // protect `cba' from an exception (copy only necessary
        // when `reentrant' is non-zero in which case we unlock
        // the mutex and allow registered callbacks to call the
        // stream member functions recursively)
        if (reentrant) {
            // never throws
            cba = _GET_TEMP_BUFFER (_C_usr_data::_C_event_cb, cbsize).first;
 
            if (!cba) {
                // clear may throw...
                _C_set (_C_state | badbit, _C_except | _RW::__rw_nolock,
                        _C_rdbuf);
                return;
            }
 
            // verify consistency (neither must be 0 at this point)
            _RWSTD_ASSERT (_C_usr->_C_cbarray && _C_usr->_C_cbsize);
 
            // copy into temporary buffer
            memcpy (cba, _C_usr->_C_cbarray, cbsize * sizeof *cba);
 
            // unlock only if stream state allows it
            if (!(flags () & _RW::__rw_nolock))
                _C_unlock ();
        }
 
        // 27.4.2.6, p1 - call callbacks in opposite order of registration
        for (_RWSTD_SIZE_T i = cbsize; i-- > 0; ) {
 
            _RWSTD_ASSERT (cba && cba [i]._C_fn);
 
            // ok if callback calls locking functions, we're unlocked
            // and working with a local copy of callack array
            cba [i]._C_fn (ev, *this, cba [i]._C_index);
        }
 
        if (reentrant) {
            return_temporary_buffer (cba);
 
            // lock only if stream state allows it (stream state
            // may have been modified by one of the callbacks)
            if (!(flags () & _RW::__rw_nolock))
                _C_lock ();
        }
    }
    _CATCH (...) {
        if (reentrant) {
            return_temporary_buffer (cba);
 
            // lock only if `cba' was successfully allocated (or copied)
            // and the stream state allows it (stream state may have been
            // modified by one of the callbacks)
            if (cba && !(flags () & _RW::__rw_nolock))
                _C_lock ();
        }
        _RETHROW;
    }
}
 
 
// succeeds irrespective of rdstate()
void ios_base::
_C_copyfmt (const ios_base &rhs,
            void *dst, const void *src, _RWSTD_SIZE_T size)
{
    if (this == &rhs)
        return;
 
    typedef _C_usr_data::_C_event_cb EventCB;
 
    // allocate sufficient storage
    long    *ia  = 0;
    void*   *pa  = 0;
    EventCB *cba = 0;
 
    _RWSTD_SIZE_T a_size [3];    // sizes of arrays above
 
    unsigned   fmtfl;    // formatting flags
    streamsize prec;     // new precision
    streamsize wide;     // new width
    unsigned   except;   // new exceptions
    void*      ptie;     // tied ostream
    locale     loc;      // new locale
 
    char srcbuf [16];    // buffer to copy `src' to
 
    // flags to copy from `rhs'
    const fmtflags flagmask = ~(_RW::__rw_nolock | _RW::__rw_nolockbuf);
 
    _TRY {
        // lock `rhs', *this not locked yet
        _RWSTD_MT_GUARD (rhs.flags () & _RW::__rw_nolock
                         ? 0 : &_RWSTD_CONST_CAST (ios_base&, rhs)._C_mutex);
 
        if (rhs._C_usr) {
 
            // copy pointer to the tied ostream, if any
            ptie = rhs._C_usr->_C_tie;
 
            // for convenience
            const _C_usr_data* const rusr = rhs._C_usr;
 
            // verify that either both are 0 or neither is
            _RWSTD_ASSERT (!!rusr->_C_iarray == !!rusr->_C_isize);
            _RWSTD_ASSERT (!!rusr->_C_parray == !!rusr->_C_psize);
            _RWSTD_ASSERT (!!rusr->_C_cbarray == !!rusr->_C_cbsize);
 
            a_size [0] = rusr->_C_isize;
            a_size [1] = rusr->_C_psize;
            a_size [2] = rusr->_C_cbsize;
                
            ia = _RWSTD_STATIC_CAST (long*,
                     a_size [0] ? operator new (a_size [0] * sizeof *ia) : 0);
 
            pa = _RWSTD_STATIC_CAST (void**,
                     a_size [1] ? operator new (a_size [1] * sizeof *pa) : 0);
 
            cba = _RWSTD_STATIC_CAST (EventCB*,
                     a_size [2] ? operator new (a_size [2] * sizeof *cba) : 0);
 
            // copy rhs into allocated storage and assign (27.4.4.2, p15)
            memcpy (ia,  rusr->_C_iarray,  a_size [0] * sizeof *ia);
            memcpy (pa,  rusr->_C_parray,  a_size [1] * sizeof *pa);
            memcpy (cba, rusr->_C_cbarray, a_size [2] * sizeof *cba);
        }
        else {
            // zero out array to prevent (bogus) gcc warnings
            // about the variable being used uninitialized
            memset (a_size, 0, sizeof a_size);
 
            ptie = 0;
        }
 
        // copy the rest of rhs state (save for exceptions)
        // while it's locked to guarantee atomicity
        fmtfl  = rhs._C_fmtfl;
        prec   = rhs._C_prec;
        wide   = rhs._C_wide;
        except = rhs._C_except;
        loc    = rhs._C_loc;
 
        // copy additional data (rhs's fill char) to the small
        // temporary buffer only if it fits
        if (size <= sizeof srcbuf)
            src = memcpy (srcbuf, src, size);
    }
    _CATCH (...) {
        // *this is unmodified
        operator delete (ia);
        operator delete (pa);
        operator delete (cba);
 
        _RETHROW;
    }
 
    // `rhs' unlocked, lock *this
    _RWSTD_MT_GUARD (flags () & _RW::__rw_nolock ? 0 : &_C_mutex);
 
    _TRY {
        if (_C_usr) {
            // fire erase events (27.4.4.2, p17) - may throw
            if (_C_usr->_C_fire)
                (this->*_C_usr->_C_fire)(erase_event, true /* reentrant */);
 
            // delete existing arrays, if any; _C_usr will only be deleted
            // if `rhs' contains no user data (see below)
            operator delete (_C_usr->_C_iarray);
            _C_usr->_C_iarray = 0;
            _C_usr->_C_isize = 0;
            operator delete (_C_usr->_C_parray);
            _C_usr->_C_parray = 0;
            _C_usr->_C_psize = 0;
            operator delete (_C_usr->_C_cbarray);
            _C_usr->_C_cbarray = 0;
            _C_usr->_C_cbsize = 0;
        }
        else if (ia || pa || cba || ptie) {
            // allocation may throw
            _C_usr = new _C_usr_data ();
 
#ifdef _RWSTD_NO_POD_ZERO_INIT
 
#  ifdef _RWSTD_NO_NEW_THROWS
 
            if (!_C_usr)
                _RW::__rw_throw (_RWSTD_ERROR_FIRST + 3 /* BAD_ALLOC */);
 
#  endif   // _RWSTD_NO_NEW_THROWS
 
            _RWSTD_ASSERT (0 != _C_usr);
            memset (_C_usr, 0, sizeof *_C_usr);
 
#endif   // _RWSTD_NO_POD_ZERO_INIT
 
        }
    }
    _CATCH (...) {
        // *this is unmodified
        operator delete (ia);
        operator delete (pa);
        operator delete (cba);
 
        _RETHROW;
    }
 
    if (ia || pa || cba || ptie) {
 
        // assing allocated and copied arrays and their sizes
        _C_usr->_C_iarray  = ia;
        _C_usr->_C_parray  = pa;
        _C_usr->_C_cbarray = cba;
 
        _C_usr->_C_isize   = a_size [0];
        _C_usr->_C_psize   = a_size [1];
        _C_usr->_C_cbsize  = a_size [2];
 
        _C_usr->_C_tie     = ptie;
 
        _C_usr->_C_fire    = &ios_base::_C_fire_event;
    }
    else {
        // `rhs' contains no user data, delete _C_usr
        _C_usr_data::_C_dealloc (_C_usr);
        _C_usr = 0;
    }
 
    // copy all but masked flags(), leave masked flags alone
    _C_fmtfl = fmtfl & flagmask | _C_fmtfl & ~flagmask;
    _C_prec  = prec;
    _C_wide  = wide;
    _C_loc   = loc;
 
    // copy additional data (fill character) -- will be atomic
    // only if size is sufficiently small; since this is used
    // for the fill character represented in derived classes
    // as int_type this will be true for all standard iostreams
    memcpy (dst, src, size);
 
    if (_C_usr && _C_usr->_C_fire) {
        _TRY {
            // fire copy events (27.4.4.2, p17), may temporarily unlock
            // or throw
            (this->*_C_usr->_C_fire)(copyfmt_event, true /* reentrant */);
        }
        _CATCH (...) {
            // must still assign exceptions
            _C_except = except;
 
            // just rethrow caught exception (don't call clear())
            _RETHROW;
        }
    }
 
    // assign exceptions last (27.4.4.2, p15, bullet 2)
    _C_except = except;
 
    // leave state alone but throw an exception if necessary
    _C_set (_C_state, _C_except | _RW::__rw_nolock, _C_rdbuf);
}
 
 
long& ios_base::iword (int inx)
{
    _RWSTD_MT_GUARD (flags () & _RW::__rw_nolock ? 0 : &_C_mutex);
 
    if (!_C_usr)
        _C_usr = _C_usr_data::_C_alloc (&ios_base::_C_fire_event);
 
    long* const ia = _C_usr
        ? _RWSTD_STATIC_CAST (long*, _RW::__rw_realloc (_C_usr->_C_iarray,
                                                        sizeof (long),
                                                        _C_usr->_C_isize,
                                                        inx))
        : 0;
 
    if (ia) {
        _RWSTD_ASSERT (  _C_usr->_C_isize
                       > _RWSTD_STATIC_CAST (_RWSTD_SIZE_T, inx));
 
        return (_C_usr->_C_iarray = ia)[inx];
    }
 
    _C_set (_C_state | badbit, _C_except | _RW::__rw_nolock, _C_rdbuf);
 
    // returns a reference to a dummy object on failure (27.4.2.5, p3)
    static long dummy_iword;
 
    return dummy_iword = 0;
}
 
 
void*& ios_base::pword (int inx)
{ 
    _RWSTD_MT_GUARD (flags () & _RW::__rw_nolock ? 0 : &_C_mutex);
 
    if (!_C_usr)
        _C_usr = _C_usr_data::_C_alloc (&ios_base::_C_fire_event);
 
    void** const pa = _C_usr
        ? _RWSTD_STATIC_CAST (void**, _RW::__rw_realloc (_C_usr->_C_parray,
                                                         sizeof (void*),
                                                         _C_usr->_C_psize,
                                                         inx))
        : 0;
 
    if (pa) {
        _RWSTD_ASSERT (  _C_usr->_C_psize
                       > _RWSTD_STATIC_CAST (_RWSTD_SIZE_T, inx));
 
        return (_C_usr->_C_parray = pa)[inx];
    }
 
    _C_set (_C_state | badbit, _C_except | _RW::__rw_nolock, _C_rdbuf);
 
    // returns a reference to a dummy object on failure (27.4.2.5, p3)
    static void *dummy_pword;
 
    return dummy_pword = 0;
}
 
 
void ios_base::
register_callback (event_callback fun, int inx)
{
    _RWSTD_ASSERT (0 != fun);
 
    _RWSTD_MT_GUARD (flags () & _RW::__rw_nolock ? 0 : &_C_mutex);
 
    if (!_C_usr)
        _C_usr = _C_usr_data::_C_alloc (&ios_base::_C_fire_event);
 
    typedef _C_usr_data::_C_event_cb EventCB;
 
    _RWSTD_SIZE_T  sz  = 0;
    EventCB       *cba = 0;
 
    if (_C_usr) {
        sz  = _C_usr->_C_cbsize;
        cba = _RWSTD_STATIC_CAST (EventCB*,
                                  _RW::__rw_realloc (_C_usr->_C_cbarray,
                                                     sizeof (EventCB),
                                                     _C_usr->_C_cbsize,
                                                     int (sz)));
    }
 
    if (cba) {
        // array must have grown by at least one element
        _RWSTD_ASSERT (sz < _C_usr->_C_cbsize);
 
        _C_usr->_C_cbarray = cba;
 
        _C_usr->_C_cbarray [sz]._C_index = inx;
        _C_usr->_C_cbarray [sz]._C_fn    = fun;
    }
    else {
        // not required by 27.4.2.6
        _C_set (_C_state | badbit, _C_except | _RW::__rw_nolock, _C_rdbuf);
    }
}
 
 
}   // namespace std