--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/stdcpp/src/ios.cpp Tue Feb 02 02:01:42 2010 +0200
@@ -0,0 +1,376 @@
+/*
+ * © 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: