/*

 * © Portions copyright (c) 2006-2007 Nokia Corporation.  All rights reserved.

 *

 * 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.

 *

 */ 

# include "stlport_prefix.h"

# include <algorithm>

# include <stl/_ios.h>

#if defined(__LIBSTD_CPP_SYMBIAN32_WSD__) || defined(_STLP_LIBSTD_CPP_NO_STATIC_VAR_)

#include "libstdcppwsd.h"

# endif

_STLP_BEGIN_NAMESPACE

char* _STLP_CALL

__write_integer(char* buf, ios_base::fmtflags flags, long x);

//----------------------------------------------------------------------

// ios_base members

// class ios_base::failure, a subclass of exception.  It's used solely

// for reporting errors.

_STLP_EXP_DECLSPEC ios_base::failure::failure(const string& s) 

  : __Named_exception(s)

{}

_STLP_EXP_DECLSPEC ios_base::failure::~failure() _STLP_NOTHROW_INHERENTLY {}

#if !defined (_STLP_STATIC_CONST_INIT_BUG)

// Definitions of ios_base's formatting flags.

const ios_base::fmtflags ios_base::left;

const ios_base::fmtflags ios_base::right;

const ios_base::fmtflags ios_base::internal;

const ios_base::fmtflags ios_base::dec;

const ios_base::fmtflags ios_base::hex;

const ios_base::fmtflags ios_base::oct;

const ios_base::fmtflags ios_base::fixed;

const ios_base::fmtflags ios_base::scientific;

const ios_base::fmtflags ios_base::boolalpha;

const ios_base::fmtflags ios_base::showbase;

const ios_base::fmtflags ios_base::showpoint;

const ios_base::fmtflags ios_base::showpos;

const ios_base::fmtflags ios_base::skipws;

const ios_base::fmtflags ios_base::unitbuf;

const ios_base::fmtflags ios_base::uppercase;

const ios_base::fmtflags ios_base::adjustfield;

const ios_base::fmtflags ios_base::basefield;

const ios_base::fmtflags ios_base::floatfield;

// Definitions of ios_base's state flags.

const ios_base::iostate ios_base::goodbit;

const ios_base::iostate ios_base::badbit;

const ios_base::iostate ios_base::eofbit;

const ios_base::iostate ios_base::failbit;

// Definitions of ios_base's openmode flags.

const ios_base::openmode ios_base::app;

const ios_base::openmode ios_base::ate;

const ios_base::openmode ios_base::binary;

const ios_base::openmode ios_base::in;

const ios_base::openmode ios_base::out;

const ios_base::openmode ios_base::trunc;

// Definitions of ios_base's seekdir flags.

const ios_base::seekdir ios_base::beg;

const ios_base::seekdir ios_base::cur;

const ios_base::seekdir ios_base::end;

# endif /*  _STLP_STATIC_CONST_INIT_BUG */

// Internal functions used for managing exponentially-growing arrays of

// POD types.

// array is a pointer to N elements of type PODType.  Expands the array,

// if necessary, so that array[index] is meaningful.  All new elements are

// initialized to zero.  Returns a pointer to the new array, and the new

// size.

template <class PODType>

pair<PODType*, size_t> 

_Stl_expand_array(PODType* array, size_t N, int index)

{

  if (N < (size_t)(index + 1)) {

    size_t new_N = (max)(2 * N, size_t(index + 1));

    size_t total_alloc = new_N * sizeof(PODType);

    PODType* new_array = (PODType*)0;

    // fixed the maximum range problem

    if(total_alloc)

        new_array  = __STATIC_CAST(PODType*,realloc(array, total_alloc));

    if (new_array) {

      fill(new_array + N, new_array + new_N, PODType());

      return pair<PODType*, size_t>(new_array, new_N);

    }

    else 

      return pair<PODType*, size_t>(__STATIC_CAST(PODType*,0), 0);

  }

  else

    return pair<PODType*, size_t>(array, N);

}

// array is a pointer to N elements of type PODType.  Allocate a new

// array of N elements, copying the values from the old array to the new.

// Return a pointer to the new array.  It is assumed that array is non-null

// and N is nonzero.

template <class PODType>

PODType* _Stl_copy_array(const PODType* array, size_t N) {

  PODType* result = __STATIC_CAST(PODType*,malloc(N * sizeof(PODType)));

  if (result)

    copy(array, array + N, result);

  return result;

}

_STLP_EXP_DECLSPEC locale ios_base::imbue(const locale& loc) {

    locale previous = _M_locale;

    _M_locale = loc;

    _M_invoke_callbacks(imbue_event);

    return previous;

}

#if defined(__LIBSTD_CPP_SYMBIAN32_WSD__) || defined(_STLP_LIBSTD_CPP_NO_STATIC_VAR_)

void ios_base_S_index_init()

{

	get_ios_base_S_index() = 0;	

}	

# else

int ios_base::_S_index = 0;

# endif

_STLP_EXP_DECLSPEC int _STLP_CALL ios_base::xalloc()

{

#if defined(__LIBSTD_CPP_SYMBIAN32_WSD__) || defined(_STLP_LIBSTD_CPP_NO_STATIC_VAR_)

   get_ios_xalloc_L()._M_lock.iState = _ENeedsNormalInit;

   get_ios_xalloc_L()._M_lock.iPtr = 0;

   get_ios_xalloc_L()._M_lock.iReentry = 0;   

   _STLP_auto_lock sentry(get_ios_xalloc_L());    

   return get_ios_base_S_index()++;

# else

  static _STLP_STATIC_MUTEX L _STLP_MUTEX_INITIALIZER;

  _STLP_auto_lock sentry(L);

  return _S_index++;

# endif  

}

_STLP_EXP_DECLSPEC long& ios_base::iword(int index) {

#if defined(__LIBSTD_CPP_SYMBIAN32_WSD__) || defined(_STLP_LIBSTD_CPP_NO_STATIC_VAR_)

	get_ios_iword_dummy() = 0;

# else

	static long dummy = 0;

# endif  

  pair<long*, size_t> tmp = _Stl_expand_array(_M_iwords, _M_num_iwords, index);

  if (tmp.first) {              // The allocation, if any, succeeded.

    _M_iwords = tmp.first;

    _M_num_iwords = tmp.second;

    return _M_iwords[index];

  }

  else {

    _M_setstate_nothrow(badbit);

    _M_check_exception_mask();

#if defined(__LIBSTD_CPP_SYMBIAN32_WSD__) || defined(_STLP_LIBSTD_CPP_NO_STATIC_VAR_)

	return (get_ios_iword_dummy());

# else

	return dummy;

# endif    

  }

}

_STLP_EXP_DECLSPEC void*& ios_base::pword(int index) {

# if !defined(__LIBSTD_CPP_SYMBIAN32_WSD__) && !defined(_STLP_LIBSTD_CPP_NO_STATIC_VAR_)

	static void* dummy = 0;

# endif  

  pair<void**, size_t> tmp = _Stl_expand_array(_M_pwords, _M_num_pwords, index);

  if (tmp.first) {              // The allocation, if any, succeeded.

    _M_pwords = tmp.first;

    _M_num_pwords = tmp.second;

    return _M_pwords[index];

  }

  else {

    _M_setstate_nothrow(badbit);

    _M_check_exception_mask();

#if defined(__LIBSTD_CPP_SYMBIAN32_WSD__) || defined(_STLP_LIBSTD_CPP_NO_STATIC_VAR_)

	return (get_ios_pword_dummy());

# else

	return dummy;

# endif    

  }

}

_STLP_EXP_DECLSPEC void ios_base::register_callback(event_callback __fn, int index) {

  pair<pair<event_callback, int>*, size_t> tmp

    = _Stl_expand_array(_M_callbacks, _M_num_callbacks, (int)_M_callback_index /* fbp: index ??? */ );

  if (tmp.first) {

    _M_callbacks = tmp.first;

    _M_num_callbacks = tmp.second;

    _M_callbacks[_M_callback_index++] = make_pair(__fn, index);

  }

  else {

    _M_setstate_nothrow(badbit);

    _M_check_exception_mask();

  }

}

// Invokes all currently registered callbacks for a particular event.

// Behaves correctly even if one of the callbacks adds a new callback.

_STLP_EXP_DECLSPEC void ios_base::_M_invoke_callbacks(event E) {

  for (size_t i = _M_callback_index; i > 0; --i) {

    event_callback f = _M_callbacks[i-1].first;

    int n = _M_callbacks[i-1].second;

    f(E, *this, n);

  }

}

// This function is called if the state, rdstate(), has a bit set

// that is also set in the exception mask exceptions().

_STLP_EXP_DECLSPEC void ios_base::_M_throw_failure() {

  const char* arg ;

# if 0

  char buffer[256];

  char* ptr;

  strcpy(buffer, "ios failure: rdstate = 0x");

  ptr = __write_integer(buffer+strlen(buffer), ios_base::hex, __STATIC_CAST(unsigned long,_M_iostate)); 

  strcpy(ptr, " mask = 0x");

  ptr = __write_integer(buffer+strlen(buffer), ios_base::hex, __STATIC_CAST(unsigned long,_M_exception_mask)); 

  *ptr = 0;

  arg = buffer;

# else

  arg = "ios failure";

# endif

# ifndef _STLP_USE_EXCEPTIONS

  fputs(arg, stderr);

# else

  throw failure(arg);

# endif

}

// Copy x's state to *this.  This member function is used in the 

// implementation of basic_ios::copyfmt.  Does not copy _M_exception_mask

// or _M_iostate.  

_STLP_EXP_DECLSPEC void ios_base::_M_copy_state(const ios_base& x) {

  _M_fmtflags  = x._M_fmtflags; // Copy the flags, except for _M_iostate

  _M_openmode  = x._M_openmode; // and _M_exception_mask.

  _M_seekdir   = x._M_seekdir;

  _M_precision = x._M_precision;

  _M_width     = x._M_width;

  if (_M_locale != x._M_locale) {

    _M_locale = x._M_locale;

    _M_cached_ctype = x._M_cached_ctype;

    _M_cached_numpunct = x._M_cached_numpunct;

  }

  if (x._M_callbacks) {

    pair<event_callback, int>* tmp = _Stl_copy_array(x._M_callbacks, x._M_callback_index);

    if (tmp) {

      free(_M_callbacks);

      _M_callbacks = tmp;

      _M_num_callbacks = _M_callback_index = x._M_callback_index;

    }

    else {

      _M_setstate_nothrow(badbit);

      _M_check_exception_mask();

    }

  }

  if (x._M_iwords) {

    long* tmp = _Stl_copy_array(x._M_iwords, x._M_num_iwords);

    if (tmp) {

      free(_M_iwords);

      _M_iwords = tmp;

      _M_num_iwords = x._M_num_iwords;

    }

    else {

      _M_setstate_nothrow(badbit);

      _M_check_exception_mask();

    }

  }

  if (x._M_pwords) {

    void** tmp = _Stl_copy_array(x._M_pwords, x._M_num_pwords);

    if (tmp) {

      free(_M_pwords);

      _M_pwords = tmp;

      _M_num_pwords = x._M_num_pwords;

    }

    else {

      _M_setstate_nothrow(badbit);

      _M_check_exception_mask();

    }

  }

}

// ios's (protected) default constructor.  The standard says that all 

// fields have indeterminate values; we initialize them to zero for

// simplicity.  The only thing that really matters is that the arrays

// are all initially null pointers, and the array element counts are all

// initially zero.

_STLP_EXP_DECLSPEC ios_base::ios_base()

  : _M_fmtflags(0), _M_iostate(0), _M_openmode(0), _M_seekdir(0),

    _M_exception_mask(0),

    _M_precision(0), _M_width(0),

    _M_locale(),

    _M_callbacks(0), _M_num_callbacks(0), _M_callback_index(0),

    _M_iwords(0), _M_num_iwords(0),

    _M_pwords(0),

    _M_num_pwords(0) , _M_cached_ctype(0), _M_cached_numpunct(0)

{ }

// ios's destructor.

_STLP_EXP_DECLSPEC ios_base::~ios_base() {

  _M_invoke_callbacks(erase_event);

  free(_M_callbacks);

  free(_M_iwords);

  free(_M_pwords);

}

#ifndef __SYMBIAN32__ 

template <class _CharT, class _Traits>

_STLP_EXP_DECLSPEC locale basic_ios<_CharT, _Traits>::imbue(const locale& __loc)

{

  locale __tmp = ios_base::imbue(__loc);

  if (_M_streambuf)

    _M_streambuf->pubimbue(__loc);

  // no throwing here

#if defined(__LIBSTD_CPP_SYMBIAN32_WSD__) || defined(_STLP_LIBSTD_CPP_NO_STATIC_VAR_)

  this->_M_cached_ctype = __loc._M_get_facet(ctype<char_type>::GetFacetLocaleId()) ;

  this->_M_cached_numpunct = __loc._M_get_facet(numpunct<char_type>::GetFacetLocaleId()) ;

#else

  this->_M_cached_ctype = __loc._M_get_facet(ctype<char_type>::id) ;

  this->_M_cached_numpunct = __loc._M_get_facet(numpunct<char_type>::id) ;

#endif //__LIBSTD_CPP_SYMBIAN32_WSD__

  this->_M_cached_grouping = ((numpunct<char_type>*)_M_cached_numpunct)->grouping() ;

  return __tmp;

}

#endif //#ifndef __SYMBIAN32__ 

//----------------------------------------------------------------------

// Force instantiation of basic_ios

// For DLL exports, they are already instantiated.

#  if !defined(_STLP_NO_FORCE_INSTANTIATE)

template class _STLP_CLASS_DECLSPEC basic_ios<char, char_traits<char> >;

#   ifndef _STLP_NO_WCHAR_T

template class _STLP_CLASS_DECLSPEC basic_ios<wchar_t, char_traits<wchar_t> >;

#   endif /* _STLP_NO_WCHAR_T */

#  endif

_STLP_END_NAMESPACE

// Local Variables:

// mode:C++

// End: