/**************************************************************************
 *
 * ios.cpp - Source for the Standard Library ios classes
 *
 * $Id$
 *
 ***************************************************************************
 *
 * Licensed to the Apache Software  Foundation (ASF) under one or more
 * contributor  license agreements.  See  the NOTICE  file distributed
 * with  this  work  for  additional information  regarding  copyright
 * ownership.   The ASF  licenses this  file to  you under  the Apache
 * License, Version  2.0 (the  License); you may  not use  this file
 * except in  compliance with the License.   You may obtain  a copy of
 * the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the  License is distributed on an  "AS IS" BASIS,
 * WITHOUT  WARRANTIES OR CONDITIONS  OF ANY  KIND, either  express or
 * implied.   See  the License  for  the  specific language  governing
 * permissions and limitations under the License.
 *
 * Copyright 1994-2008 Rogue Wave Software, Inc.
 * 
 **************************************************************************/

#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