diff -r e1b950c65cb4 -r 837f303aceeb epoc32/include/stdapis/stlport/stl/_num_get.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/epoc32/include/stdapis/stlport/stl/_num_get.c Wed Mar 31 12:33:34 2010 +0100 @@ -0,0 +1,882 @@ +/* + * © 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. + * + */ +#ifndef _STLP_NUM_GET_C +#define _STLP_NUM_GET_C + +#ifndef _STLP_INTERNAL_NUM_GET_H +# include +#endif + +# if defined (_STLP_EXPOSE_STREAM_IMPLEMENTATION) + +#ifndef _STLP_LIMITS_H +# include +#endif + +_STLP_DECLSPEC unsigned char* __get_digit_val_table(void); +_STLP_DECLSPEC char* __get_narrow_atoms(void); +_STLP_BEGIN_NAMESPACE + +extern const unsigned char __digit_val_table[]; + +template < class _InputIter, class _Integer, class _CharT> +_InputIter _STLP_CALL +_M_do_get_integer(_InputIter&, _InputIter&, ios_base&, ios_base::iostate&, _Integer&, _CharT*); + +// _M_do_get_integer and its helper functions. + +#ifdef __SYMBIAN32__ +template +inline bool _STLP_CALL __get_fdigit(_CharT& c, const _CharT* digits) + { + + const _CharT* p = find(digits, digits + 10, c); + if (p != digits + 10) { + c = (_CharT)( (_CharT)'0' + (p - digits)); + return true; + } + else + return false; +} + +#endif +inline bool _STLP_CALL __get_fdigit(char& __c, const char*) + { return __c >= '0' && __c <= '9'; } + +inline bool _STLP_CALL __get_fdigit_or_sep(char& __c, char __sep, const char *) +{ + if (__c == __sep) { + __c = ',' ; + return true ; + } else + return ( __c >= '0' && __c <= '9'); +} + +# ifndef _STLP_NO_WCHAR_T + +// Similar, except return the character itself instead of the numeric +// value. Used for floating-point input. +inline bool _STLP_CALL __get_fdigit(wchar_t& c, const wchar_t* digits) +{ + const wchar_t* p = find(digits, digits + 10, c); + if (p != digits + 10) { + c = (char)('0' + (p - digits)); + return true; + } + else + return false; +} + +inline bool _STLP_CALL __get_fdigit_or_sep(wchar_t& c, wchar_t sep, + const wchar_t * digits) +{ + if (c == sep) { + c = (char)','; + return true; + } + else + return __get_fdigit(c, digits); +} +#ifdef __SYMBIAN32__ +template +inline bool _STLP_CALL __get_fdigit_or_sep(_CharT& c, _CharT sep, + const _CharT * digits) +{ + if (c == sep) { + c = (_CharT)','; + return true; + } + else + return __get_fdigit(c, digits); +} + + + +#endif +#endif +inline int _STLP_CALL +__get_digit_from_table(unsigned __index) +{ + return (__index > 127 ? 0xFF : __get_digit_val_table()[__index]); +} + +extern const char __narrow_atoms[]; + +template +int +_M_get_base_or_zero(_InputIter& __stl_in, _InputIter& __end, ios_base& __str, _CharT*) +{ + _CharT __atoms[5]; + const ctype<_CharT>& __c_type = use_facet< ctype<_CharT> >(__str.getloc()); + // const ctype<_CharT>& __c_type = *(const ctype<_CharT>*)__str._M_ctype_facet(); + + __c_type.widen(__get_narrow_atoms(), __get_narrow_atoms() + 5, __atoms); + + bool __negative = false; + _CharT __c = *__stl_in; + + if (__c == __atoms[1] /* __xminus_char */ ) { + __negative = true; + ++__stl_in; + } + else if (__c == __atoms[0] /* __xplus_char */ ) + ++__stl_in; + + + int __base; + int __valid_zero = 0; + + ios_base::fmtflags __basefield = __str.flags() & ios_base::basefield; + + switch (__basefield) { + case ios_base::oct: + __base = 8; + break; + case ios_base::dec: + __base = 10; + break; + case ios_base::hex: + __base = 16; + if (__stl_in != __end && *__stl_in == __atoms[2] /* __zero_char */ ) { + ++__stl_in; + if (__stl_in != __end && + (*__stl_in == __atoms[3] /* __x_char */ || *__stl_in == __atoms[4] /* __X_char */ )) + ++__stl_in; + else + __valid_zero = 1; // That zero is valid by itself. + } + break; + default: + if (__stl_in != __end && *__stl_in == __atoms[2] /* __zero_char */ ) { + ++__stl_in; + if (__stl_in != __end && + (*__stl_in == __atoms[3] /* __x_char */ || *__stl_in == __atoms[4] /* __X_char */ )) { + ++__stl_in; + __base = 16; + } + else + { + __base = 8; + __valid_zero = 1; // That zero is still valid by itself. + } + } + else + __base = 10; + break; + } + return (__base << 2) | ((int)__negative << 1) | __valid_zero; +} + + +template +bool _STLP_CALL +__get_integer(_InputIter& __first, _InputIter& __last, + int __base, _Integer& __val, + int __got, bool __is_negative, char __separator, const string& __grouping, const __true_type&) +{ + bool __ovflow = false; + bool __valid_group = true; + + _Integer __result = 0; + bool __is_group = !__grouping.empty(); +// char __group_sizes[64]; + char __group_sizes[256] = {0}; //group sizes can be more +#ifdef __SYMBIAN32__ +int __current_group_size = __got; +#else + int __current_group_size = 0; +#endif + char* __group_sizes_end = __group_sizes; + int prv_got = 0; + + + _Integer __over_base = (numeric_limits<_Integer>::min)() / __STATIC_CAST(_Integer, __base); + + for ( ; __first != __last ; ++__first) { + + const char __c = *__first; + + if (__is_group && __c == __separator) { + if (prv_got == __got) //no successive seperators + return false; + prv_got = __got; + *__group_sizes_end++ = __current_group_size; + __current_group_size = 0; + continue; + } + + int __n = __get_digit_from_table(__c); + + if (__n >= __base) + break; + + ++__got; + ++__current_group_size; + + if (__result < __over_base) + __ovflow = true; // don't need to keep accumulating + else { + _Integer __next = __STATIC_CAST(_Integer, __base * __result - __n); + if (__result != 0) +#ifdef __SYMBIAN32__ + if (__is_negative) + __ovflow = __ovflow || __next >= __result; + else + __ovflow = __ovflow || (__next-1) >= __result; //For signed char, the ranges are -128 to 127, +#else + __ovflow = __ovflow || __next >= __result; +#endif + __result = __next; + } + } + + if (__is_group && __group_sizes_end != __group_sizes) { + *__group_sizes_end++ = __current_group_size; + + } + + // fbp : added to not modify value if nothing was read + if (__got > 0) { + __val = __ovflow + ? __is_negative ? (numeric_limits<_Integer>::min)() + : (numeric_limits<_Integer>::max)() + : (__is_negative ? __result : __STATIC_CAST(_Integer, -__result)); + } + __valid_group = __valid_grouping(__group_sizes, __group_sizes_end, + __grouping.data(), __grouping.data()+ __grouping.size()); + + if (__valid_group == false) + __val = 0; + + // overflow is being treated as failure + return ((__got > 0) && !__ovflow) && (__is_group == 0 || __valid_group) ; +} + +template +bool _STLP_CALL +__get_integer(_InputIter& __first, _InputIter& __last, + int __base, _Integer& __val, + int __got, bool __is_negative, char __separator, const string& __grouping, const __false_type&) +{ + bool __ovflow = false; + bool __valid_group = true; + _Integer __result = 0; + bool __is_group = !__grouping.empty(); +// char __group_sizes[64]; + char __group_sizes[256] = {0};//group sizes can be more + int __current_group_size = 0; + char* __group_sizes_end = __group_sizes; + int prv_got = 0; + + + _Integer __over_base = (numeric_limits<_Integer>::max)() / __STATIC_CAST(_Integer, __base); + + for ( ; __first != __last ; ++__first) { + + const char __c = *__first; +/* + //if (__is_group && __c == __separator) { //no seperator at the start of number. + if (__is_group && __c == __separator && __got) { + // seperator should come after extracting some digits + if (!__current_group_size) + break; + *__group_sizes_end++ = __current_group_size; + __current_group_size = 0; + continue; + } +*/ + if (__is_group && __c == __separator) { + if (prv_got == __got) //no successive seperators + return false; + prv_got = __got; + *__group_sizes_end++ = __current_group_size; + __current_group_size = 0; + continue; + } + int __n = __get_digit_from_table(__c); + + if (__n >= __base) + break; + + ++__got; + ++__current_group_size; + + if (__result > __over_base) + __ovflow = true; //don't need to keep accumulating + else { + _Integer __next = __STATIC_CAST(_Integer, __base * __result + __n); + if (__result != 0) + __ovflow = __ovflow || __next <= __result; + __result = __next; + } + } + + if (__is_group && __group_sizes_end != __group_sizes) { + *__group_sizes_end++ = __current_group_size; + } + + // fbp : added to not modify value if nothing was read + if (__got > 0) { + __val = __ovflow + ? (numeric_limits<_Integer>::max)() + : (__is_negative ? __STATIC_CAST(_Integer, -__result) : __result); + } + __valid_group = __valid_grouping(__group_sizes, __group_sizes_end, + __grouping.data(), __grouping.data()+ __grouping.size()); + + if (__valid_group == false) + __val = 0; + + // overflow is being treated as failure + return ((__got > 0) && !__ovflow) && + (__is_group == 0 ||__valid_group) ; +} + + +template +bool _STLP_CALL +__get_decimal_integer(_InputIter& __first, _InputIter& __last, _Integer& __val) +{ + string __grp; + return __get_integer(__first, __last, 10, __val, 0, false, ' ', __grp, __false_type()); +} + +template +_InputIter _STLP_CALL +_M_do_get_integer(_InputIter& __stl_in, _InputIter& __end, ios_base& __str, + ios_base::iostate& __err, _Integer& __val, _CharT* __pc) +{ + +#if defined(__HP_aCC) && (__HP_aCC == 1) + bool _IsSigned = !((_Integer)(-1) > 0); +#else + typedef typename __bool2type::is_signed>::_Ret _IsSigned; +#endif + + //const numpunct<_CharT>& __numpunct = *(const numpunct<_CharT>*)__str._M_numpunct_facet(); + const numpunct<_CharT>& __numpunct = use_facet< numpunct<_CharT> >(__str.getloc()); +// const string& __grouping = __str._M_grouping(); // cached copy //stdcxx fix - 11/1/06 + const string& __grouping = __numpunct.grouping(); + + + const int __base_or_zero = _M_get_base_or_zero(__stl_in, __end, __str, __pc); + int __got = __base_or_zero & 1; + + bool __result; + + if (__stl_in == __end) { // We may have already read a 0. If so, + + if (__got > 0) { // the result is 0 even if we're at eof. + __val = 0; + __result = true; + } + else + __result = false; + } else { + + const bool __negative = __base_or_zero & 2; + const int __base = __base_or_zero >> 2; + +#if defined(__HP_aCC) && (__HP_aCC == 1) + if (_IsSigned) + __result = __get_integer(__stl_in, __end, __base, __val, __got, __negative, __numpunct.thousands_sep(), __grouping, __true_type() ); + else + __result = __get_integer(__stl_in, __end, __base, __val, __got, __negative, __numpunct.thousands_sep(), __grouping, __false_type() ); +#else +#ifdef __SYMBIAN32__ + _Integer __tval; + __result = __get_integer(__stl_in, __end, __base, __tval, __got, __negative, __numpunct.thousands_sep(), __grouping, _IsSigned()); + if(__result) + __val = __tval; +#else + __result = __get_integer(__stl_in, __end, __base, __val, __got, __negative, __numpunct.thousands_sep(), __grouping, _IsSigned()); +#endif +# endif + } + + __err = __STATIC_CAST(ios_base::iostate, __result ? ios_base::goodbit : ios_base::failbit); + + if (__stl_in == __end) + __err |= ios_base::eofbit; + return __stl_in; +} + +// _M_read_float and its helper functions. +template +_InputIter _STLP_CALL +__copy_sign(_InputIter __first, _InputIter __last, string& __v, + _CharT __xplus, _CharT __xminus) { + if (__first != __last) { + _CharT __c = *__first; + if (__c == __xplus) + ++__first; + else if (__c == __xminus) { + __v.push_back('-'); + ++__first; + } + } + return __first; +} + + +template +bool _STLP_CALL +__copy_digits(_InputIter& __first, _InputIter& __last, + string& __v, const _CharT* __digits) +{ + bool __ok = false; + + for ( ; __first != __last; ++__first) { + _CharT __c = *__first; + if (__get_fdigit(__c, __digits)) { + __v.push_back((char)__c); + __ok = true; + } + else + break; + } + return __ok; +} + +template +bool _STLP_CALL +__copy_grouped_digits(_InputIter& __first, _InputIter& __last, + string& __v, const _CharT * __digits, + _CharT __sep, const string& __grouping, + bool& __grouping_ok) +{ + bool __ok = false; +// char __group_sizes[64]; + char __group_sizes[256] = {0};//group sizes can be more + char*__group_sizes_end = __group_sizes; + char __current_group_size = 0; + + for ( ; __first != __last; ++__first) { + _CharT __c = *__first; + bool __tmp = __get_fdigit_or_sep(__c, __sep, __digits); + if (__tmp) { + if (__c == ',') { + // seperator should come after extracting some digits + if (!__current_group_size) + break; + + *__group_sizes_end++ = __current_group_size; + __current_group_size = 0; + } + else { + __ok = true; + __v.push_back((char)__c); + ++__current_group_size; + } + } + else + break; + } + + if (__group_sizes_end != __group_sizes) + *__group_sizes_end++ = __current_group_size; + __grouping_ok = __valid_grouping(__group_sizes, __group_sizes_end, __grouping.data(), __grouping.data() + __grouping.size()); + __ok = __ok & __grouping_ok; //Added, to check for valid grouping. If not valid grouping should return false. + return __ok; +} + + +template +bool _STLP_CALL +_M_read_float(string& __buf, _InputIter& __stl_in, _InputIter& __end, ios_base& __s, _CharT*) +{ + // Create a string, copying characters of the form + // [+-]? [0-9]* .? [0-9]* ([eE] [+-]? [0-9]+)? + + bool __digits_before_dot /* = false */; + bool __digits_after_dot = false; + bool __ok; + + bool __grouping_ok = true; + + const ctype<_CharT>& __ct = use_facet< ctype<_CharT> >(__s.getloc()); + // const ctype<_CharT>& __ct = *(const ctype<_CharT>*)__s._M_ctype_facet(); + //const numpunct<_CharT>& __numpunct = *(const numpunct<_CharT>*)__s._M_numpunct_facet(); + const numpunct<_CharT>& __numpunct = use_facet< numpunct<_CharT> >(__s.getloc()); +// const string& __grouping = __s._M_grouping(); // cached copy //stdcxx fix - 11/1/06 + const string& __grouping = __numpunct.grouping(); + + _CharT __dot = __numpunct.decimal_point(); + _CharT __sep = __numpunct.thousands_sep(); + + _CharT __digits[10]; + _CharT __xplus; + _CharT __xminus; + + _CharT __pow_e; + _CharT __pow_E; + + _Initialize_get_float(__ct, __xplus, __xminus, __pow_e, __pow_E, __digits); + + // Get an optional sign + __stl_in = __copy_sign(__stl_in, __end, __buf, __xplus, __xminus); + + // Get an optional string of digits. + if (__grouping.size() != 0) + __digits_before_dot = __copy_grouped_digits(__stl_in, __end, __buf, __digits, + __sep, __grouping, __grouping_ok); + else + __digits_before_dot = __copy_digits(__stl_in, __end, __buf, __digits); + + // Get an optional decimal point, and an optional string of digits. + if (__stl_in != __end && *__stl_in == __dot) { + __buf.push_back('.'); + ++__stl_in; + __digits_after_dot = __copy_digits(__stl_in, __end, __buf, __digits); + } + + // There have to be some digits, somewhere. + __ok = __digits_before_dot || __digits_after_dot; + + // Get an optional exponent. + if (__ok && __stl_in != __end && (*__stl_in == __pow_e || *__stl_in == __pow_E)) { + __buf.push_back('e'); + ++__stl_in; + __stl_in = __copy_sign(__stl_in, __end, __buf, __xplus, __xminus); + __ok = __copy_digits(__stl_in, __end, __buf, __digits); + // If we have an exponent then the sign + // is optional but the digits aren't. + } + + return __ok; +} + +// +// num_get<>, num_put<> +// + +# if ( _STLP_STATIC_TEMPLATE_DATA > 0 ) +# if !defined(__LIBSTD_CPP_SYMBIAN32_WSD__) && !defined(_STLP_LIBSTD_CPP_NO_STATIC_VAR_) +template +locale::id num_get<_CharT, _InputIterator>::id; +#endif +# else + +typedef num_get num_get_char; +typedef num_get > > num_get_char_2; + +#ifndef __SYMBIAN32__ +__DECLARE_INSTANCE(locale::id, num_get_char::id, ); +__DECLARE_INSTANCE(locale::id, num_get_char_2::id, ); +#endif + +# ifndef _STLP_NO_WCHAR_T + +typedef num_get num_get_wchar_t; +typedef num_get > > num_get_wchar_t_2; + +#ifndef __SYMBIAN32__ +__DECLARE_INSTANCE(locale::id, num_get_wchar_t::id, ); +__DECLARE_INSTANCE(locale::id, num_get_wchar_t_2::id, ); +#endif + +# endif + +# endif /* ( _STLP_STATIC_TEMPLATE_DATA > 0 ) */ + +# ifndef _STLP_NO_BOOL +template +_InputIter +num_get<_CharT, _InputIter>::do_get(_InputIter __stl_in, _InputIter __end, + ios_base& __s, + ios_base::iostate& __err, bool& __x) const +{ + if (__s.flags() & ios_base::boolalpha) { + locale __loc = __s.getloc(); + //const _Numpunct& __np = *(const _Numpunct*)__s._M_numpunct_facet(); + const numpunct<_CharT>& __np = use_facet >(__loc) ; +// const ctype<_CharT>& __ct = use_facet >(__loc) ; + + const basic_string<_CharT> __truename = __np.truename(); + const basic_string<_CharT> __falsename = __np.falsename(); + bool __true_ok = true; + bool __false_ok = true; + + size_t __n = 0; + for ( ; __stl_in != __end; ++__stl_in) { + _CharT __c = *__stl_in; + __true_ok = __true_ok && (__c == __truename[__n]); + __false_ok = __false_ok && (__c == __falsename[__n]); + ++__n; + + if ((!__true_ok && !__false_ok) || + (__true_ok && __n >= __truename.size()) || + (__false_ok && __n >= __falsename.size())) { + + if (__true_ok || __false_ok) //if anything OK then increment, else, break + ++__stl_in; + break; + } + } + // stdcxx fix, Changed to check for complete true,false string + if (__true_ok && __n < __truename.size()) + { + for ( ; __stl_in != __end; ++__stl_in) { + _CharT __c = *__stl_in; + __true_ok = __true_ok && (__c == __truename[__n]); + ++__n; + if ((!__true_ok) ||(__true_ok && __n >= __truename.size()) ) + { + if(__true_ok) + ++__stl_in; + break; + } + + } + if (__true_ok && __n < __truename.size()) + __true_ok = false; + } + if (__false_ok && __n < __falsename.size()) + { + + for ( ; __stl_in != __end; ++__stl_in) { + _CharT __c = *__stl_in; + __false_ok = __false_ok && (__c == __falsename[__n]); + ++__n; + if ((!__false_ok) ||(__false_ok && __n >= __falsename.size()) ) + { + if(__false_ok) + ++__stl_in; + break; + } + + } + if (__false_ok && __n < __falsename.size()) + __false_ok = false; + } + + if (__true_ok || __false_ok) { + __err = ios_base::goodbit; + __x = __true_ok; + } + else + __err = ios_base::failbit; + + if (__stl_in == __end) + __err |= ios_base::eofbit; + + return __stl_in; + } + + else { + long __lx; + _InputIter __tmp = this->do_get(__stl_in, __end, __s, __err, __lx); + if (!(__err & ios_base::failbit)) { + if (__lx == 0) + __x = false; + else if (__lx == 1) + __x = true; + else + __err |= ios_base::failbit; + } + return __tmp; + } +} + +# endif /* _STLP_NO_BOOL */ + +//# ifdef _STLP_FIX_LIBRARY_ISSUES +template +_InputIter +num_get<_CharT, _InputIter>::do_get(_InputIter __stl_in, _InputIter __end, ios_base& __str, + ios_base::iostate& __err, short& __val) const { + return _M_do_get_integer(__stl_in, __end, __str, __err, __val, (_CharT*)0 ); +} + +template +_InputIter +num_get<_CharT, _InputIter>::do_get(_InputIter __stl_in, _InputIter __end, ios_base& __str, + ios_base::iostate& __err, int& __val) const { + return _M_do_get_integer(__stl_in, __end, __str, __err, __val, (_CharT*)0 ); +} + +//# endif + +template +_InputIter +num_get<_CharT, _InputIter>::do_get(_InputIter __stl_in, _InputIter __end, ios_base& __str, + ios_base::iostate& __err, long& __val) const { + return _M_do_get_integer(__stl_in, __end, __str, __err, __val, (_CharT*)0 ); +} + +template +_InputIter +num_get<_CharT, _InputIter>::do_get(_InputIter __stl_in, _InputIter __end, ios_base& __str, + ios_base::iostate& __err, + unsigned short& __val) const { + return _M_do_get_integer(__stl_in, __end, __str, __err, __val, (_CharT*)0 ); +} + +template +_InputIter +num_get<_CharT, _InputIter>::do_get(_InputIter __stl_in, _InputIter __end, ios_base& __str, + ios_base::iostate& __err, + unsigned int& __val) const { + return _M_do_get_integer(__stl_in, __end, __str, __err, __val, (_CharT*)0 ); +} + +template +_InputIter +num_get<_CharT, _InputIter>::do_get(_InputIter __stl_in, _InputIter __end, ios_base& __str, + ios_base::iostate& __err, + unsigned long& __val) const { + return _M_do_get_integer(__stl_in, __end, __str, __err, __val, (_CharT*)0 ); +} + + +template +_InputIter +num_get<_CharT, _InputIter>::do_get(_InputIter __stl_in, _InputIter __end, ios_base& __str, + ios_base::iostate& __err, + float& __val) const { + string __buf ; + bool __ok = _M_read_float(__buf, __stl_in, __end, __str, (_CharT*)0 ); + if(__ok) //If success reading float then convert it. + { +#ifdef __SYMBIAN32__ + float __tval; + __ok = __string_to_float(__buf, __tval); + if(__ok) + __val = __tval; +#else + __string_to_float(__buf, __val); +#endif + } + __err = __STATIC_CAST(ios_base::iostate, __ok ? ios_base::goodbit : ios_base::failbit); + if (__stl_in == __end) + __err |= ios_base::eofbit; + return __stl_in; +} + +template +_InputIter +num_get<_CharT, _InputIter>::do_get(_InputIter __stl_in, _InputIter __end, ios_base& __str, + ios_base::iostate& __err, + double& __val) const { + string __buf ; + bool __ok = _M_read_float(__buf, __stl_in, __end, __str, (_CharT*)0 ); + if(__ok) //If success reading float then convert it. + { +#ifdef __SYMBIAN32__ + double __tval; + __ok = __string_to_float(__buf, __tval); + if(__ok) + __val = __tval; +#else + __string_to_float(__buf, __val); +#endif + } + __err = __STATIC_CAST(ios_base::iostate, __ok ? ios_base::goodbit : ios_base::failbit); + if (__stl_in == __end) + __err |= ios_base::eofbit; + return __stl_in; +} + +#ifndef _STLP_NO_LONG_DOUBLE +template +_InputIter +num_get<_CharT, _InputIter>::do_get(_InputIter __stl_in, _InputIter __end, ios_base& __str, + ios_base::iostate& __err, + long double& __val) const { + string __buf ; + bool __ok = _M_read_float(__buf, __stl_in, __end, __str, (_CharT*)0 ); + if(__ok) //If success reading float then convert it. + { +#ifdef __SYMBIAN32__ + long double __tval; + __ok = __string_to_float(__buf, __tval); + if(__ok) + __val = __tval; +#else + __string_to_float(__buf, __val); +#endif + } + __err = __STATIC_CAST(ios_base::iostate, __ok ? ios_base::goodbit : ios_base::failbit); + if (__stl_in == __end) + __err |= ios_base::eofbit; + return __stl_in; +} +#endif /* _STLP_NO_LONG_DOUBLE */ + +template +_InputIter +num_get<_CharT, _InputIter>::do_get(_InputIter __stl_in, _InputIter __end, ios_base& __str, + ios_base::iostate& __err, + void*& __p) const { +#ifdef __SYMBIAN32__ + unsigned long __val; //using only long +#else +# if defined(_STLP_LONG_LONG)&&!defined(__MRC__) //*ty 12/07/2001 - MrCpp can not cast from long long to void* + unsigned _STLP_LONG_LONG __val; +# else + unsigned long __val; +# endif +#endif //__SYMBIAN32__ +#ifdef __SYMBIAN32__ + ios_base::fmtflags __save_flags = __str.flags(); + + __str.setf(ios_base::hex, ios_base::basefield); + __str.setf(ios_base::showbase); + __str.setf(ios_base::internal, ios_base::adjustfield); + __str.width((sizeof(void*) * 2) + 2); +#endif // __SYMBIAN32__ + iter_type __tmp = _M_do_get_integer(__stl_in, __end, __str, __err, __val, (_CharT*)0 ); + if (!(__err & ios_base::failbit)) + __p = __REINTERPRET_CAST(void*,(long)__val); +#ifdef __SYMBIAN32__ + __str.flags(__save_flags); +#endif //__SYMBIAN32__ + return __tmp; + } + + +#ifdef _STLP_LONG_LONG + +template +_InputIter +num_get<_CharT, _InputIter>::do_get(_InputIter __stl_in, _InputIter __end, ios_base& __str, + ios_base::iostate& __err, + _STLP_LONG_LONG& __val) const { + return _M_do_get_integer(__stl_in, __end, __str, __err, __val, (_CharT*)0 ); +} + +template +_InputIter +num_get<_CharT, _InputIter>::do_get(_InputIter __stl_in, _InputIter __end, ios_base& __str, + ios_base::iostate& __err, + unsigned _STLP_LONG_LONG& __val) const { + return _M_do_get_integer(__stl_in, __end, __str, __err, __val, (_CharT*)0 ); +} + +#endif /* _STLP_LONG_LONG */ + +_STLP_END_NAMESPACE + +# endif /* _STLP_EXPOSE_STREAM_IMPLEMENTATION */ + +#endif /* _STLP_NUMERIC_FACETS_C */ + +// Local Variables: +// mode:C++ +// End: