Use STLPort instead of our stripped version. DO NOT MERGE.

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, 538 insertions, 0 deletions

diff --git a/WebKit/android/stlport/stl/_limits.h b/WebKit/android/stlport/stl/_limits.h
new file mode 100644
index 0000000..0d4202d
--- /dev/null
+++ b/WebKit/android/stlport/stl/_limits.h
@@ -0,0 +1,538 @@
+/*
+ * Copyright (c) 1997
+ * 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.
+ *
+ */
+
+/* NOTE: This may be not portable code. Parts of numeric_limits<> are
+ * inherently machine-dependent.  At present this file is suitable
+ * for the MIPS, SPARC, Alpha and ia32 architectures.
+ */
+
+#ifndef _STLP_INTERNAL_LIMITS
+#define _STLP_INTERNAL_LIMITS
+
+#ifndef _STLP_CLIMITS
+#  include <climits>
+#endif
+
+#ifndef _STLP_CFLOAT
+#  include <cfloat>
+#endif
+
+#if defined (_STLP_HAS_WCHAR_T) && !defined (_STLP_INTERNAL_CWCHAR)
+#  include <stl/_cwchar.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+enum float_round_style {
+  round_indeterminate       = -1,
+  round_toward_zero         =  0,
+  round_to_nearest          =  1,
+  round_toward_infinity     =  2,
+  round_toward_neg_infinity =  3
+};
+
+enum float_denorm_style {
+  denorm_indeterminate = -1,
+  denorm_absent        =  0,
+  denorm_present       =  1
+};
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+// Base class for all specializations of numeric_limits.
+template <class __number>
+class _Numeric_limits_base {
+public:
+
+  static __number (_STLP_CALL min)() _STLP_NOTHROW { return __number(); }
+  static __number (_STLP_CALL max)() _STLP_NOTHROW { return __number(); }
+
+#if defined ( _STLP_STATIC_CONST_INIT_BUG)
+  enum {
+#else
+  static const int
+#endif
+
+  digits = 0,
+  digits10 = 0,
+  radix = 0,
+  min_exponent = 0,
+  min_exponent10 = 0,
+  max_exponent = 0,
+  max_exponent10 = 0
+
+#if defined ( _STLP_STATIC_CONST_INIT_BUG)
+  ,
+  has_denorm = denorm_absent,
+  round_style = round_toward_zero,
+#else
+  ;
+  static const float_denorm_style has_denorm =  denorm_absent;
+  static const float_round_style round_style = round_toward_zero;
+  static const bool
+#endif
+
+    is_specialized = false,
+    is_signed  = false,
+    is_integer = false,
+    is_exact = false,
+    has_infinity = false,
+    has_quiet_NaN = false,
+    has_signaling_NaN = false,
+    has_denorm_loss = false,
+    is_iec559 = false,
+    is_bounded = false,
+    is_modulo = false,
+    traps = false,
+    tinyness_before = false
+#if defined ( _STLP_STATIC_CONST_INIT_BUG)
+  }
+#endif
+  ;
+
+  static __number _STLP_CALL epsilon() _STLP_NOTHROW     { return __number(); }
+  static __number _STLP_CALL round_error() _STLP_NOTHROW { return __number(); }
+
+  static __number _STLP_CALL infinity() _STLP_NOTHROW      { return __number(); }
+  static __number _STLP_CALL quiet_NaN() _STLP_NOTHROW     { return __number(); }
+  static __number _STLP_CALL signaling_NaN() _STLP_NOTHROW { return __number(); }
+  static __number _STLP_CALL denorm_min() _STLP_NOTHROW    { return __number(); }
+};
+
+// Base class for integers.
+
+#ifdef _STLP_LIMITED_DEFAULT_TEMPLATES
+#  ifdef _STLP_LONG_LONG
+#    define _STLP_LIMITS_MIN_TYPE _STLP_LONG_LONG
+#    define _STLP_LIMITS_MAX_TYPE unsigned _STLP_LONG_LONG
+#  else
+#    define _STLP_LIMITS_MIN_TYPE long
+#    define _STLP_LIMITS_MAX_TYPE unsigned long
+#  endif
+#else
+#  define _STLP_LIMITS_MIN_TYPE _Int
+#  define _STLP_LIMITS_MAX_TYPE _Int
+#endif /* _STLP_LIMITED_DEFAULT_TEMPLATES */
+
+template <class _Int,
+          _STLP_LIMITS_MIN_TYPE __imin,
+          _STLP_LIMITS_MAX_TYPE __imax,
+          int __idigits, bool __ismod>
+class _Integer_limits : public _Numeric_limits_base<_Int> {
+public:
+
+  static _Int (_STLP_CALL min) () _STLP_NOTHROW { return (_Int)__imin; }
+  static _Int (_STLP_CALL max) () _STLP_NOTHROW { return (_Int)__imax; }
+
+#if defined (_STLP_STATIC_CONST_INIT_BUG)
+  enum {
+#else
+  static const int
+#endif
+  digits = (__idigits < 0) ?
+  ((int)((sizeof(_Int) * (CHAR_BIT))) - ((__imin == 0) ? 0 : 1))
+  : (__idigits),
+  digits10 = (digits * 301UL) / 1000,
+  radix = 2
+#if !defined (_STLP_STATIC_CONST_INIT_BUG)
+  ;
+  static const bool
+#else
+  ,
+#endif
+  is_specialized = true,
+  is_signed = (__imin != 0),
+  is_integer = true,
+  is_exact = true,
+  is_bounded = true,
+  is_modulo = __ismod
+#if defined ( _STLP_STATIC_CONST_INIT_BUG)
+  }
+#endif
+  ;
+};
+
+// Base class for floating-point numbers.
+template <class __number,
+         int __Digits, int __Digits10,
+         int __MinExp, int __MaxExp,
+         int __MinExp10, int __MaxExp10,
+         bool __IsIEC559,
+         float_round_style __RoundStyle>
+class _Floating_limits : public _Numeric_limits_base<__number> {
+public:
+
+#if defined (_STLP_STATIC_CONST_INIT_BUG)
+  enum {
+#else
+  static const int
+#endif
+
+  digits = __Digits,
+  digits10 = __Digits10,
+
+  radix = (  FLT_RADIX /* 2 */ ),
+  min_exponent = __MinExp,
+  max_exponent = __MaxExp,
+  min_exponent10 = __MinExp10,
+  max_exponent10 = __MaxExp10
+
+#if defined (_STLP_STATIC_CONST_INIT_BUG)
+  ,
+  has_denorm = denorm_indeterminate,
+  round_style = __RoundStyle,
+#else
+  ;
+  static const float_denorm_style has_denorm = denorm_indeterminate;
+  static const float_round_style round_style = __RoundStyle;
+  static const bool
+#endif
+
+  is_specialized = true,
+  is_signed = true,
+
+  //IEC 559 specify the floating point representation of
+  //infinity, quiet and signaling Not a Number. Not supporting
+  //it is consider as not being able to grant those values.
+#if (defined (_STLP_MSVC) && (_STLP_MSVC < 1300))
+  //MSVC 6 do not fully support IEC 599 but grant a good infinity value.
+  has_infinity      = true,
+#else
+  has_infinity      = __IsIEC559,
+#endif
+  has_quiet_NaN     = __IsIEC559,
+  has_signaling_NaN = __IsIEC559,
+
+  has_denorm_loss   =  false,
+  is_iec559      =  __IsIEC559,
+  is_bounded     =  true,
+  traps          =  true,
+  tinyness_before=  false
+
+#if defined (_STLP_STATIC_CONST_INIT_BUG)
+  }
+#endif
+  ;
+};
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+// Class numeric_limits
+
+// The unspecialized class.
+
+template<class _Tp>
+class numeric_limits : public _STLP_PRIV _Numeric_limits_base<_Tp> {};
+
+// Specializations for all built-in integral types.
+
+#if !defined (_STLP_NO_BOOL)
+_STLP_TEMPLATE_NULL
+class numeric_limits<bool>
+  : public _STLP_PRIV _Integer_limits<bool, false, true, 1, false>
+{};
+#endif /* _STLP_NO_BOOL */
+
+_STLP_TEMPLATE_NULL
+class numeric_limits<char>
+  : public _STLP_PRIV _Integer_limits<char, CHAR_MIN, CHAR_MAX, -1, true>
+{};
+
+#if !defined (_STLP_NO_SIGNED_BUILTINS)
+_STLP_TEMPLATE_NULL
+class numeric_limits<signed char>
+  : public _STLP_PRIV _Integer_limits<signed char, SCHAR_MIN, SCHAR_MAX, -1, true>
+{};
+#endif
+
+_STLP_TEMPLATE_NULL
+class numeric_limits<unsigned char>
+  : public _STLP_PRIV _Integer_limits<unsigned char, 0, UCHAR_MAX, -1, true>
+{};
+
+#if !(defined (_STLP_NO_WCHAR_T) || defined (_STLP_WCHAR_T_IS_USHORT))
+
+_STLP_TEMPLATE_NULL
+class numeric_limits<wchar_t>
+  : public _STLP_PRIV _Integer_limits<wchar_t, WCHAR_MIN, WCHAR_MAX, -1, true>
+{};
+
+#endif
+
+_STLP_TEMPLATE_NULL
+class numeric_limits<short>
+  : public _STLP_PRIV _Integer_limits<short, SHRT_MIN, SHRT_MAX, -1, true>
+{};
+
+_STLP_TEMPLATE_NULL
+class numeric_limits<unsigned short>
+  : public _STLP_PRIV _Integer_limits<unsigned short, 0, USHRT_MAX, -1, true>
+{};
+
+#if defined (__xlC__) && (__xlC__ == 0x500)
+#  undef INT_MIN
+#  define INT_MIN -2147483648
+#endif
+
+_STLP_TEMPLATE_NULL
+class numeric_limits<int>
+  : public _STLP_PRIV _Integer_limits<int, INT_MIN, INT_MAX, -1, true>
+{};
+
+_STLP_TEMPLATE_NULL
+class numeric_limits<unsigned int>
+  : public _STLP_PRIV _Integer_limits<unsigned int, 0, UINT_MAX, -1, true>
+{};
+
+_STLP_TEMPLATE_NULL
+class numeric_limits<long>
+  : public _STLP_PRIV _Integer_limits<long, LONG_MIN, LONG_MAX, -1, true>
+{};
+
+_STLP_TEMPLATE_NULL
+class numeric_limits<unsigned long>
+  : public _STLP_PRIV _Integer_limits<unsigned long, 0, ULONG_MAX, -1, true>
+{};
+
+#if defined (_STLP_LONG_LONG)
+
+#  if defined (_STLP_MSVC) || defined (__BORLANDC__)
+#    define LONGLONG_MAX     0x7fffffffffffffffi64
+#    define LONGLONG_MIN     (-LONGLONG_MAX-1i64)
+#    define ULONGLONG_MAX    0xffffffffffffffffUi64
+#  else
+#    ifndef LONGLONG_MAX
+#      define LONGLONG_MAX   0x7fffffffffffffffLL
+#    endif
+#    ifndef LONGLONG_MIN
+#      define LONGLONG_MIN   (-LONGLONG_MAX-1LL)
+#    endif
+#    ifndef ULONGLONG_MAX
+#      define ULONGLONG_MAX  0xffffffffffffffffULL
+#    endif
+#  endif
+
+#  if !defined(__GNUC__) || (__GNUC__ == 2 && __GNUC_MINOR__ <= 96)
+
+_STLP_TEMPLATE_NULL
+class numeric_limits<_STLP_LONG_LONG>
+  : public _STLP_PRIV _Integer_limits<_STLP_LONG_LONG, LONGLONG_MIN, LONGLONG_MAX, -1, true>
+{};
+
+_STLP_TEMPLATE_NULL
+class numeric_limits<unsigned _STLP_LONG_LONG>
+  : public _STLP_PRIV _Integer_limits<unsigned _STLP_LONG_LONG, 0, ULONGLONG_MAX, -1, true>
+{};
+#  else /* gcc 2.97 (after 2000-11-01), 2.98, 3.0 */
+/*
+ newest gcc has new mangling scheme, that has problem
+ with generating name [instantiated] of template specialization like
+ _Integer_limits<_STLP_LONG_LONG, LONGLONG_MIN, LONGLONG_MAX, -1, true>
+                                  ~~~~~~~~~~~~  ~~~~~~~~~~~~
+ Below is code that solve this problem.
+   - ptr
+ */
+_STLP_TEMPLATE_NULL
+class numeric_limits<_STLP_LONG_LONG>
+  : public _STLP_PRIV _Numeric_limits_base<_STLP_LONG_LONG> {
+public:
+
+  static _STLP_LONG_LONG (_STLP_CALL min) () _STLP_NOTHROW { return LONGLONG_MIN; }
+  static _STLP_LONG_LONG (_STLP_CALL max) () _STLP_NOTHROW { return LONGLONG_MAX; }
+
+#    if defined ( _STLP_STATIC_CONST_INIT_BUG)
+  enum {
+#    else
+  static const int
+#    endif
+  digits = ((int)((sizeof(_STLP_LONG_LONG) * (CHAR_BIT))) - 1),
+  digits10 = (digits * 301UL) / 1000,
+  radix = 2
+#    if ! defined (_STLP_STATIC_CONST_INIT_BUG)
+  ;
+  static const bool
+#    else
+  ,
+#    endif
+  is_specialized = true,
+  is_signed = true,
+  is_integer = true,
+  is_exact = true,
+  is_bounded = true,
+  is_modulo = true
+#    if defined (_STLP_STATIC_CONST_INIT_BUG)
+  }
+#    endif
+  ;
+};
+
+_STLP_TEMPLATE_NULL
+class numeric_limits<unsigned _STLP_LONG_LONG>
+  : public _STLP_PRIV _Numeric_limits_base<unsigned _STLP_LONG_LONG> {
+public:
+
+  static unsigned _STLP_LONG_LONG (_STLP_CALL min) () _STLP_NOTHROW { return 0ULL; }
+  static unsigned _STLP_LONG_LONG (_STLP_CALL max) () _STLP_NOTHROW { return ULONGLONG_MAX; }
+
+#    if defined (_STLP_STATIC_CONST_INIT_BUG)
+  enum {
+#    else
+  static const int
+#    endif
+  digits = ((int)((sizeof(unsigned _STLP_LONG_LONG) * (CHAR_BIT)))),
+  digits10 = (digits * 301UL) / 1000,
+  radix = 2
+#    if ! defined (_STLP_STATIC_CONST_INIT_BUG)
+  ;
+  static const bool
+#    else
+  ,
+#    endif
+  is_specialized = true,
+  is_signed = false,
+  is_integer = true,
+  is_exact = true,
+  is_bounded = true,
+  is_modulo = true
+#    if defined ( _STLP_STATIC_CONST_INIT_BUG)
+  }
+#    endif
+  ;
+};
+
+#  endif /* __GNUC__ > 2000-11-01 */
+
+#endif /* _STLP_LONG_LONG */
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+// Specializations for all built-in floating-point types.
+template <class __dummy>
+class _LimG {
+public:
+  static float _STLP_CALL get_F_inf();
+  static float _STLP_CALL get_F_qNaN();
+  static float _STLP_CALL get_F_sNaN();
+  static double _STLP_CALL get_D_inf();
+  static double _STLP_CALL get_D_qNaN();
+  static double _STLP_CALL get_D_sNaN();
+
+#if !defined (_STLP_NO_LONG_DOUBLE)
+  static long double _STLP_CALL get_LD_inf();
+  static long double _STLP_CALL get_LD_qNaN();
+  static long double _STLP_CALL get_LD_sNaN();
+#endif
+};
+
+#if defined (_STLP_USE_TEMPLATE_EXPORT)
+_STLP_EXPORT_TEMPLATE_CLASS _LimG<bool>;
+#endif
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+_STLP_TEMPLATE_NULL
+class numeric_limits<float>
+  : public _STLP_PRIV _Floating_limits<float,
+                                        FLT_MANT_DIG,   // Binary digits of precision
+                                        FLT_DIG,        // Decimal digits of precision
+                                        FLT_MIN_EXP,    // Minimum exponent
+                                        FLT_MAX_EXP,    // Maximum exponent
+                                        FLT_MIN_10_EXP, // Minimum base 10 exponent
+                                        FLT_MAX_10_EXP, // Maximum base 10 exponent
+#if defined (_STLP_NO_IEC559_SUPPORT)
+                                        false,          // do not conform to iec559
+#else
+                                        true,           // conforms to iec559
+#endif
+                                        round_to_nearest> {
+public:
+  static float (_STLP_CALL min) () _STLP_NOTHROW { return FLT_MIN; }
+  static float _STLP_CALL denorm_min() _STLP_NOTHROW { return FLT_MIN; }
+  static float (_STLP_CALL max) () _STLP_NOTHROW { _STLP_USING_VENDOR_CSTD return FLT_MAX; }
+  static float _STLP_CALL epsilon() _STLP_NOTHROW { return FLT_EPSILON; }
+  static float _STLP_CALL round_error() _STLP_NOTHROW { return 0.5f; } // Units: ulps.
+  static  float _STLP_CALL infinity() _STLP_NOTHROW { return _STLP_PRIV _LimG<bool>::get_F_inf(); }
+  static  float _STLP_CALL quiet_NaN() _STLP_NOTHROW { return _STLP_PRIV _LimG<bool>::get_F_qNaN(); }
+  static  float _STLP_CALL signaling_NaN() _STLP_NOTHROW { return _STLP_PRIV _LimG<bool>::get_F_sNaN(); }
+};
+
+_STLP_TEMPLATE_NULL
+class numeric_limits<double>
+  : public _STLP_PRIV _Floating_limits<double,
+                                        DBL_MANT_DIG,   // Binary digits of precision
+                                        DBL_DIG,        // Decimal digits of precision
+                                        DBL_MIN_EXP,    // Minimum exponent
+                                        DBL_MAX_EXP,    // Maximum exponent
+                                        DBL_MIN_10_EXP, // Minimum base 10 exponent
+                                        DBL_MAX_10_EXP, // Maximum base 10 exponent
+#if defined (_STLP_NO_IEC559_SUPPORT)
+                                        false,          // do not conform to iec559
+#else
+                                        true,           // conforms to iec559
+#endif
+                                        round_to_nearest> {
+public:
+  static double (_STLP_CALL min)() _STLP_NOTHROW { return DBL_MIN; }
+  static double _STLP_CALL denorm_min() _STLP_NOTHROW { return DBL_MIN; }
+  static double (_STLP_CALL max)() _STLP_NOTHROW { _STLP_USING_VENDOR_CSTD return DBL_MAX; }
+  static double _STLP_CALL epsilon() _STLP_NOTHROW { return DBL_EPSILON; }
+  static double _STLP_CALL round_error() _STLP_NOTHROW { return 0.5; } // Units: ulps.
+  static  double _STLP_CALL infinity() _STLP_NOTHROW { return _STLP_PRIV _LimG<bool>::get_D_inf(); }
+  static  double _STLP_CALL quiet_NaN() _STLP_NOTHROW { return _STLP_PRIV _LimG<bool>::get_D_qNaN(); }
+  static  double _STLP_CALL signaling_NaN() _STLP_NOTHROW { return _STLP_PRIV _LimG<bool>::get_D_sNaN(); }
+};
+
+#if !defined (_STLP_NO_LONG_DOUBLE)
+
+_STLP_TEMPLATE_NULL
+class numeric_limits<long double>
+  : public _STLP_PRIV _Floating_limits<long double,
+                                        LDBL_MANT_DIG,  // Binary digits of precision
+                                        LDBL_DIG,       // Decimal digits of precision
+                                        LDBL_MIN_EXP,   // Minimum exponent
+                                        LDBL_MAX_EXP,   // Maximum exponent
+                                        LDBL_MIN_10_EXP,// Minimum base 10 exponent
+                                        LDBL_MAX_10_EXP,// Maximum base 10 exponent
+                                        false,          // do not conform to iec559
+                                        round_to_nearest> {
+public:
+  static long double (_STLP_CALL min) () _STLP_NOTHROW { _STLP_USING_VENDOR_CSTD return LDBL_MIN; }
+  static long double _STLP_CALL denorm_min() _STLP_NOTHROW { _STLP_USING_VENDOR_CSTD return LDBL_MIN; }
+  static long double (_STLP_CALL max) () _STLP_NOTHROW { _STLP_USING_VENDOR_CSTD return LDBL_MAX; }
+  static long double _STLP_CALL epsilon() _STLP_NOTHROW { return LDBL_EPSILON; }
+  static long double _STLP_CALL round_error() _STLP_NOTHROW { return 4; } // Units: ulps.
+  static long double _STLP_CALL infinity() _STLP_NOTHROW { return _STLP_PRIV _LimG<bool>::get_LD_inf(); }
+  static long double _STLP_CALL quiet_NaN() _STLP_NOTHROW { return _STLP_PRIV _LimG<bool>::get_LD_qNaN(); }
+  static long double _STLP_CALL signaling_NaN() _STLP_NOTHROW { return _STLP_PRIV _LimG<bool>::get_LD_sNaN(); }
+};
+
+#endif
+
+// We write special values (Inf and NaN) as bit patterns and
+// cast the the appropriate floating-point types.
+_STLP_END_NAMESPACE
+
+#if !defined (_STLP_LINK_TIME_INSTANTIATION)
+#  include <stl/_limits.c>
+#endif
+
+#endif
+
+// Local Variables:
+// mode:C++
+// End: