Use STLPort instead of our stripped version.

This fixes the simulator build and allows us to get closer to sharing code with
chromium.

STLPort was copied with minor edits from the Android port of gears.

1 files changed, 679 insertions, 0 deletions

diff --git a/WebKit/android/stlport/stl/_num_get.c b/WebKit/android/stlport/stl/_num_get.c
new file mode 100644
index 0000000..da12993
--- /dev/null
+++ b/WebKit/android/stlport/stl/_num_get.c
@@ -0,0 +1,679 @@
+/*
+ * 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 <stl/_num_get.h>
+#endif
+
+#ifndef _STLP_INTERNAL_LIMITS
+#  include <stl/_limits.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+_STLP_DECLSPEC unsigned char _STLP_CALL __digit_val_table(unsigned);
+_STLP_DECLSPEC const char* _STLP_CALL __narrow_atoms();
+
+template < class _InputIter, class _Integer, class _CharT>
+_InputIter _STLP_CALL
+__do_get_integer(_InputIter&, _InputIter&, ios_base&, ios_base::iostate&, _Integer&, _CharT*);
+
+// __do_get_integer and its helper functions.
+
+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 *__digits) {
+  if (__c == __sep) {
+    __c = ',' ;
+    return true ;
+  }
+  else
+    return  __get_fdigit(__c, __digits);
+}
+
+inline int _STLP_CALL
+__get_digit_from_table(unsigned __index)
+{ return (__index > 127 ? 0xFF : __digit_val_table(__index)); }
+
+template <class _InputIter, class _CharT>
+int
+__get_base_or_zero(_InputIter& __in_ite, _InputIter& __end, ios_base& __str, _CharT*) {
+  _CharT __atoms[5];
+  const ctype<_CharT>& __c_type = *__STATIC_CAST(const ctype<_CharT>*, __str._M_ctype_facet());
+
+  __c_type.widen(__narrow_atoms(), __narrow_atoms() + 5, __atoms);
+
+  bool __negative = false;
+  _CharT __c = *__in_ite;
+
+  if (__c == __atoms[1] /* __xminus_char */ ) {
+    __negative = true;
+    ++__in_ite;
+  }
+  else if (__c == __atoms[0] /* __xplus_char */ )
+    ++__in_ite;
+
+  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 (__in_ite != __end && *__in_ite == __atoms[2] /* __zero_char */ ) {
+      ++__in_ite;
+      if (__in_ite != __end &&
+          (*__in_ite == __atoms[3] /* __x_char */ || *__in_ite == __atoms[4] /* __X_char */ ))
+        ++__in_ite;
+      else
+        __valid_zero = 1; // That zero is valid by itself.
+    }
+    break;
+  default:
+    if (__in_ite != __end && *__in_ite == __atoms[2] /* __zero_char */ ) {
+      ++__in_ite;
+      if (__in_ite != __end &&
+          (*__in_ite == __atoms[3] /* __x_char */ || *__in_ite == __atoms[4] /* __X_char */ )) {
+        ++__in_ite;
+        __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 <class _InputIter, class _Integer, class _CharT>
+bool _STLP_CALL
+__get_integer(_InputIter& __first, _InputIter& __last,
+              int __base, _Integer& __val,
+              int __got, bool __is_negative, _CharT __separator, const string& __grouping, const __true_type& /*_IsSigned*/) {
+  bool __ovflow = false;
+  _Integer __result = 0;
+  bool __is_group = !__grouping.empty();
+  char __group_sizes[64];
+  char __current_group_size = 0;
+  char* __group_sizes_end = __group_sizes;
+
+  _Integer __over_base = (numeric_limits<_Integer>::min)() / __STATIC_CAST(_Integer, __base);
+
+   for ( ; __first != __last ; ++__first) {
+
+     const _CharT __c = *__first;
+
+     if (__is_group && __c == __separator) {
+       *__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 ? __is_negative ? (numeric_limits<_Integer>::min)()
+                                        : (numeric_limits<_Integer>::max)()
+                        : __is_negative ? __result
+                                        : __STATIC_CAST(_Integer, -__result);
+   }
+  // overflow is being treated as failure
+  return ((__got > 0) && !__ovflow) &&
+          (__is_group == 0 ||
+           __valid_grouping(__group_sizes, __group_sizes_end,
+                            __grouping.data(), __grouping.data()+ __grouping.size()));
+}
+
+template <class _InputIter, class _Integer, class _CharT>
+bool _STLP_CALL
+__get_integer(_InputIter& __first, _InputIter& __last,
+              int __base, _Integer& __val,
+              int __got, bool __is_negative, _CharT __separator, const string& __grouping, const __false_type& /*_IsSigned*/) {
+  bool __ovflow = false;
+  _Integer __result = 0;
+  bool __is_group = !__grouping.empty();
+  char __group_sizes[64];
+  char __current_group_size = 0;
+  char* __group_sizes_end = __group_sizes;
+
+  _Integer  __over_base = (numeric_limits<_Integer>::max)() / __STATIC_CAST(_Integer, __base);
+
+  for ( ; __first != __last ; ++__first) {
+
+    const _CharT __c = *__first;
+
+    if (__is_group && __c == __separator) {
+      *__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);
+  }
+
+  // overflow is being treated as failure
+  return ((__got > 0) && !__ovflow) &&
+          (__is_group == 0 ||
+           __valid_grouping(__group_sizes, __group_sizes_end,
+                            __grouping.data(), __grouping.data()+ __grouping.size()));
+}
+
+
+template <class _InputIter, class _Integer, class _CharT>
+bool _STLP_CALL
+__get_decimal_integer(_InputIter& __first, _InputIter& __last, _Integer& __val, _CharT* /*dummy*/) {
+  string __grp;
+  //Here there is no grouping so separator is not important, we just pass the default charater.
+  return __get_integer(__first, __last, 10, __val, 0, false, _CharT() /*separator*/, __grp, __false_type());
+}
+
+template <class _InputIter, class _Integer, class _CharT>
+_InputIter _STLP_CALL
+__do_get_integer(_InputIter& __in_ite, _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<numeric_limits<_Integer>::is_signed>::_Ret _IsSigned;
+#endif
+
+  const numpunct<_CharT>& __numpunct = *__STATIC_CAST(const numpunct<_CharT>*, __str._M_numpunct_facet());
+  const string& __grouping = __str._M_grouping(); // cached copy
+
+  const int __base_or_zero = __get_base_or_zero(__in_ite, __end, __str, __pc);
+  int  __got = __base_or_zero & 1;
+
+  bool __result;
+
+  if (__in_ite == __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) != 0;
+    const int __base = __base_or_zero >> 2;
+
+#if defined (__HP_aCC) && (__HP_aCC == 1)
+    if (_IsSigned)
+      __result = __get_integer(__in_ite, __end, __base,  __val, __got, __negative, __numpunct.thousands_sep(), __grouping, __true_type() );
+    else
+      __result = __get_integer(__in_ite, __end, __base,  __val, __got, __negative, __numpunct.thousands_sep(), __grouping, __false_type() );
+#else
+    __result = __get_integer(__in_ite, __end, __base,  __val, __got, __negative, __numpunct.thousands_sep(), __grouping, _IsSigned());
+# endif
+  }
+
+  __err = __STATIC_CAST(ios_base::iostate, __result ? ios_base::goodbit : ios_base::failbit);
+
+  if (__in_ite == __end)
+    __err |= ios_base::eofbit;
+  return __in_ite;
+}
+
+// __read_float and its helper functions.
+template <class _InputIter, class _CharT>
+_InputIter  _STLP_CALL
+__copy_sign(_InputIter __first, _InputIter __last, __iostring& __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 <class _InputIter, class _CharT>
+bool _STLP_CALL
+__copy_digits(_InputIter& __first, _InputIter __last,
+              __iostring& __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 <class _InputIter, class _CharT>
+bool _STLP_CALL
+__copy_grouped_digits(_InputIter& __first, _InputIter __last,
+                      __iostring& __v, const _CharT * __digits,
+                      _CharT __sep, const string& __grouping,
+                      bool& __grouping_ok) {
+  bool __ok = false;
+  char __group_sizes[64];
+  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 == ',') {
+        *__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());
+  return __ok;
+}
+
+
+template <class _InputIter, class _CharT>
+bool _STLP_CALL
+__read_float(__iostring& __buf, _InputIter& __in_ite, _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 = *__STATIC_CAST(const ctype<_CharT>*, __s._M_ctype_facet());
+  const numpunct<_CharT>& __numpunct = *__STATIC_CAST(const numpunct<_CharT>*, __s._M_numpunct_facet());
+  const string& __grouping = __s._M_grouping(); // cached copy
+
+  _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
+  __in_ite = __copy_sign(__in_ite, __end, __buf, __xplus, __xminus);
+
+  // Get an optional string of digits.
+  if (!__grouping.empty())
+    __digits_before_dot = __copy_grouped_digits(__in_ite, __end, __buf, __digits,
+                                                __sep, __grouping, __grouping_ok);
+  else
+    __digits_before_dot = __copy_digits(__in_ite, __end, __buf, __digits);
+
+  // Get an optional decimal point, and an optional string of digits.
+  if (__in_ite != __end && *__in_ite == __dot) {
+    __buf.push_back('.');
+    ++__in_ite;
+    __digits_after_dot = __copy_digits(__in_ite, __end, __buf, __digits);
+  }
+
+  // There have to be some digits, somewhere.
+  __ok = __digits_before_dot || __digits_after_dot;
+
+  // Get an optional exponent.
+  if (__ok && __in_ite != __end && (*__in_ite == __pow_e || *__in_ite == __pow_E)) {
+    __buf.push_back('e');
+    ++__in_ite;
+    __in_ite = __copy_sign(__in_ite, __end, __buf, __xplus, __xminus);
+    __ok = __copy_digits(__in_ite, __end, __buf, __digits);
+    // If we have an exponent then the sign
+    // is optional but the digits aren't.
+  }
+
+  return __ok;
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+//
+// num_get<>, num_put<>
+//
+
+#if ( _STLP_STATIC_TEMPLATE_DATA > 0 )
+#  if !defined (__BORLANDC__)
+template <class _CharT, class _InputIterator>
+locale::id num_get<_CharT, _InputIterator>::id;
+#  endif
+
+#  if (defined (__CYGWIN__) || defined (__MINGW32__)) && \
+       defined (_STLP_USE_DYNAMIC_LIB) && !defined (__BUILDING_STLPORT)
+/*
+ * Under cygwin, when STLport is used as a shared library, the id needs
+ * to be specified as imported otherwise they will be duplicated in the
+ * calling executable.
+ */
+template <>
+_STLP_DECLSPEC locale::id num_get<char, istreambuf_iterator<char, char_traits<char> > >::id;
+/*
+template <>
+_STLP_DECLSPEC locale::id num_get<char, const char*>::id;
+*/
+
+#    if !defined (STLP_NO_WCHAR_T)
+template <>
+_STLP_DECLSPEC locale::id num_get<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t> > >::id;
+/*
+template <>
+_STLP_DECLSPEC locale::id num_get<wchar_t, const wchar_t*>::id;
+*/
+#    endif
+
+#  endif /* __CYGWIN__ && _STLP_USE_DYNAMIC_LIB */
+
+#else /* ( _STLP_STATIC_TEMPLATE_DATA > 0 ) */
+
+//typedef num_get<char, const char*> num_get_char;
+typedef num_get<char, istreambuf_iterator<char, char_traits<char> > > num_get_char_2;
+
+//__DECLARE_INSTANCE(locale::id, num_get_char::id, );
+__DECLARE_INSTANCE(locale::id, num_get_char_2::id, );
+
+#  if !defined (_STLP_NO_WCHAR_T)
+
+//typedef num_get<wchar_t, const wchar_t*> num_get_wchar_t;
+typedef num_get<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t> > > num_get_wchar_t_2;
+
+//__DECLARE_INSTANCE(locale::id, num_get_wchar_t::id, );
+__DECLARE_INSTANCE(locale::id, num_get_wchar_t_2::id, );
+
+#  endif
+
+#endif /* ( _STLP_STATIC_TEMPLATE_DATA > 0 ) */
+
+#if !defined (_STLP_NO_BOOL)
+template <class _CharT, class _InputIter>
+_InputIter
+num_get<_CharT, _InputIter>::do_get(_InputIter __in_ite, _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 = *__STATIC_CAST(const _Numpunct*, __s._M_numpunct_facet());
+    //    const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc) ;
+//    const ctype<_CharT>& __ct =    use_facet<ctype<_CharT> >(__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 ( ; __in_ite != __end; ++__in_ite) {
+      _CharT __c = *__in_ite;
+      __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())) {
+        ++__in_ite;
+        break;
+      }
+    }
+    if (__true_ok  && __n < __truename.size())  __true_ok  = false;
+    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 (__in_ite == __end)
+      __err |= ios_base::eofbit;
+
+    return __in_ite;
+  }
+
+  else {
+    long __lx;
+    _InputIter __tmp = this->do_get(__in_ite, __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 */
+
+#if defined (_STLP_FIX_LIBRARY_ISSUES)
+template <class _CharT, class _InputIter>
+_InputIter
+num_get<_CharT, _InputIter>::do_get(_InputIter __in_ite, _InputIter __end, ios_base& __str,
+                                    ios_base::iostate& __err, short& __val) const
+{ return _STLP_PRIV __do_get_integer(__in_ite, __end, __str, __err, __val, (_CharT*)0 ); }
+
+template <class _CharT, class _InputIter>
+_InputIter
+num_get<_CharT, _InputIter>::do_get(_InputIter __in_ite, _InputIter __end, ios_base& __str,
+                                    ios_base::iostate& __err, int& __val) const
+{ return _STLP_PRIV __do_get_integer(__in_ite, __end, __str, __err, __val, (_CharT*)0 ); }
+
+#endif
+
+template <class _CharT, class _InputIter>
+_InputIter
+num_get<_CharT, _InputIter>::do_get(_InputIter __in_ite, _InputIter __end, ios_base& __str,
+                                    ios_base::iostate& __err, long& __val) const
+{ return _STLP_PRIV __do_get_integer(__in_ite, __end, __str, __err, __val, (_CharT*)0 ); }
+
+template <class _CharT, class _InputIter>
+_InputIter
+num_get<_CharT, _InputIter>::do_get(_InputIter __in_ite, _InputIter __end, ios_base& __str,
+                                    ios_base::iostate& __err,
+                                    unsigned short& __val) const
+{ return _STLP_PRIV __do_get_integer(__in_ite, __end, __str, __err, __val, (_CharT*)0 ); }
+
+template <class _CharT, class _InputIter>
+_InputIter
+num_get<_CharT, _InputIter>::do_get(_InputIter __in_ite, _InputIter __end, ios_base& __str,
+                                    ios_base::iostate& __err,
+                                    unsigned int& __val) const
+{ return _STLP_PRIV __do_get_integer(__in_ite, __end, __str, __err, __val, (_CharT*)0 ); }
+
+template <class _CharT, class _InputIter>
+_InputIter
+num_get<_CharT, _InputIter>::do_get(_InputIter __in_ite, _InputIter __end, ios_base& __str,
+                                    ios_base::iostate& __err,
+                                    unsigned long& __val) const
+{ return _STLP_PRIV __do_get_integer(__in_ite, __end, __str, __err, __val, (_CharT*)0 ); }
+
+
+template <class _CharT, class _InputIter>
+_InputIter
+num_get<_CharT, _InputIter>::do_get(_InputIter __in_ite, _InputIter __end, ios_base& __str,
+                                    ios_base::iostate& __err,
+                                    float& __val) const {
+  _STLP_PRIV __iostring __buf ;
+  bool __ok = _STLP_PRIV __read_float(__buf, __in_ite, __end, __str, (_CharT*)0 );
+  _STLP_PRIV __string_to_float(__buf, __val);
+  __err = __STATIC_CAST(ios_base::iostate, __ok ? ios_base::goodbit : ios_base::failbit);
+  if (__in_ite == __end)
+    __err |= ios_base::eofbit;
+  return __in_ite;
+}
+
+template <class _CharT, class _InputIter>
+_InputIter
+num_get<_CharT, _InputIter>::do_get(_InputIter __in_ite, _InputIter __end, ios_base& __str,
+                                    ios_base::iostate& __err,
+                                    double& __val) const {
+  _STLP_PRIV __iostring __buf ;
+  bool __ok = _STLP_PRIV __read_float(__buf, __in_ite, __end, __str, (_CharT*)0 );
+  _STLP_PRIV __string_to_float(__buf, __val);
+  __err = __STATIC_CAST(ios_base::iostate, __ok ? ios_base::goodbit : ios_base::failbit);
+  if (__in_ite == __end)
+    __err |= ios_base::eofbit;
+  return __in_ite;
+}
+
+#if !defined (_STLP_NO_LONG_DOUBLE)
+template <class _CharT, class _InputIter>
+_InputIter
+num_get<_CharT, _InputIter>::do_get(_InputIter __in_ite, _InputIter __end, ios_base& __str,
+                                    ios_base::iostate& __err,
+                                    long double& __val) const {
+  _STLP_PRIV __iostring __buf ;
+  bool __ok = _STLP_PRIV __read_float(__buf, __in_ite, __end, __str, (_CharT*)0 );
+  _STLP_PRIV __string_to_float(__buf, __val);
+  __err = __STATIC_CAST(ios_base::iostate, __ok ? ios_base::goodbit : ios_base::failbit);
+  if (__in_ite == __end)
+    __err |= ios_base::eofbit;
+  return __in_ite;
+}
+#endif /* _STLP_NO_LONG_DOUBLE */
+
+template <class _CharT, class _InputIter>
+_InputIter
+num_get<_CharT, _InputIter>::do_get(_InputIter __in_ite, _InputIter __end, ios_base& __str,
+                           ios_base::iostate& __err,
+                           void*& __p) const {
+#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
+    iter_type __tmp = _STLP_PRIV __do_get_integer(__in_ite, __end, __str, __err, __val, (_CharT*)0 );
+    if (!(__err & ios_base::failbit))
+      __p = __REINTERPRET_CAST(void*,__val);
+    return __tmp;
+  }
+
+#if defined (_STLP_LONG_LONG)
+template <class _CharT, class _InputIter>
+_InputIter
+num_get<_CharT, _InputIter>::do_get(_InputIter __in_ite, _InputIter __end, ios_base& __str,
+                                    ios_base::iostate& __err,
+                                    _STLP_LONG_LONG& __val) const {
+  return _STLP_PRIV __do_get_integer(__in_ite, __end, __str, __err, __val, (_CharT*)0 );
+}
+
+template <class _CharT, class _InputIter>
+_InputIter
+num_get<_CharT, _InputIter>::do_get(_InputIter __in_ite, _InputIter __end, ios_base& __str,
+                                    ios_base::iostate& __err,
+                                    unsigned _STLP_LONG_LONG& __val) const {
+  return _STLP_PRIV __do_get_integer(__in_ite, __end, __str, __err, __val, (_CharT*)0 );
+}
+#endif /* _STLP_LONG_LONG */
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_NUMERIC_FACETS_C */
+
+// Local Variables:
+// mode:C++
+// End: