diff -r 666f914201fb -r 2fe1408b6811 epoc32/include/stdapis/boost/detail/numeric_traits.hpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/epoc32/include/stdapis/boost/detail/numeric_traits.hpp	Tue Mar 16 16:12:26 2010 +0000
@@ -0,0 +1,191 @@
+// (C) Copyright David Abrahams 2001, Howard Hinnant 2001.
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// Template class numeric_traits<Number> --
+//
+//    Supplies:
+//
+//      typedef difference_type -- a type used to represent the difference
+//      between any two values of Number.
+//
+//    Support:
+//      1. Not all specializations are supplied
+//
+//      2. Use of specializations that are not supplied will cause a
+//      compile-time error
+//
+//      3. Users are free to specialize numeric_traits for any type.
+//
+//      4. Right now, specializations are only supplied for integer types.
+//
+//      5. On implementations which do not supply compile-time constants in
+//      std::numeric_limits<>, only specializations for built-in integer types
+//      are supplied.
+//
+//      6. Handling of numbers whose range of representation is at least as
+//      great as boost::intmax_t can cause some differences to be
+//      unrepresentable in difference_type:
+//
+//        Number    difference_type
+//        ------    ---------------
+//        signed    Number
+//        unsigned  intmax_t
+//
+// template <class Number> typename numeric_traits<Number>::difference_type
+// numeric_distance(Number x, Number y)
+//    computes (y - x), attempting to avoid overflows.
+//
+
+// See http://www.boost.org for most recent version including documentation.
+
+// Revision History
+// 11 Feb 2001 - Use BOOST_STATIC_CONSTANT (David Abrahams)
+// 11 Feb 2001 - Rolled back ineffective Borland-specific code
+//               (David Abrahams)
+// 10 Feb 2001 - Rolled in supposed Borland fixes from John Maddock, but
+//               not seeing any improvement yet (David Abrahams)
+// 06 Feb 2001 - Factored if_true out into boost/detail/select_type.hpp
+//               (David Abrahams)
+// 23 Jan 2001 - Fixed logic of difference_type selection, which was
+//               completely wack. In the process, added digit_traits<>
+//               to compute the number of digits in intmax_t even when
+//               not supplied by numeric_limits<>. (David Abrahams)
+// 21 Jan 2001 - Created (David Abrahams)
+
+#ifndef BOOST_NUMERIC_TRAITS_HPP_DWA20001901
+# define BOOST_NUMERIC_TRAITS_HPP_DWA20001901
+
+# include <boost/config.hpp>
+# include <boost/cstdint.hpp>
+# include <boost/static_assert.hpp>
+# include <boost/type_traits.hpp>
+# include <boost/detail/select_type.hpp>
+# include <boost/limits.hpp>
+
+namespace boost { namespace detail {
+
+  // Template class is_signed -- determine whether a numeric type is signed
+  // Requires that T is constructable from the literals -1 and 0.  Compile-time
+  // error results if that requirement is not met (and thus signedness is not
+  // likely to have meaning for that type).
+  template <class Number>
+  struct is_signed
+  {
+#if defined(BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS) || defined(BOOST_MSVC) && BOOST_MSVC <= 1300
+    BOOST_STATIC_CONSTANT(bool, value = (Number(-1) < Number(0)));
+#else
+    BOOST_STATIC_CONSTANT(bool, value = std::numeric_limits<Number>::is_signed);
+#endif
+  };
+
+# ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
+  // digit_traits - compute the number of digits in a built-in integer
+  // type. Needed for implementations on which numeric_limits is not specialized
+  // for intmax_t (e.g. VC6).
+  template <bool is_specialized> struct digit_traits_select;
+
+  // numeric_limits is specialized; just select that version of digits
+  template <> struct digit_traits_select<true>
+  {
+      template <class T> struct traits
+      {
+          BOOST_STATIC_CONSTANT(int, digits = std::numeric_limits<T>::digits);
+      };
+  };
+
+  // numeric_limits is not specialized; compute digits from sizeof(T)
+  template <> struct digit_traits_select<false>
+  {
+      template <class T> struct traits
+      {
+          BOOST_STATIC_CONSTANT(int, digits = (
+              sizeof(T) * std::numeric_limits<unsigned char>::digits
+              - (is_signed<T>::value ? 1 : 0))
+              );
+      };
+  };
+
+  // here's the "usable" template
+  template <class T> struct digit_traits
+  {
+      typedef digit_traits_select<
+                ::std::numeric_limits<T>::is_specialized> selector;
+      typedef typename selector::template traits<T> traits;
+      BOOST_STATIC_CONSTANT(int, digits = traits::digits);
+  };
+#endif
+
+  // Template class integer_traits<Integer> -- traits of various integer types
+  // This should probably be rolled into boost::integer_traits one day, but I
+  // need it to work without <limits>
+  template <class Integer>
+  struct integer_traits
+  {
+# ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
+   private:
+      typedef Integer integer_type;
+      typedef std::numeric_limits<integer_type> x;
+#   if defined(BOOST_MSVC) && BOOST_MSVC <= 1300
+      // for some reason, MSVC asserts when it shouldn't unless we make these
+      // local definitions
+      BOOST_STATIC_CONSTANT(bool, is_integer = x::is_integer);
+      BOOST_STATIC_CONSTANT(bool, is_specialized = x::is_specialized);
+      
+      BOOST_STATIC_ASSERT(is_integer);
+      BOOST_STATIC_ASSERT(is_specialized);
+#   endif
+   public:
+      typedef typename
+      if_true<(int(x::is_signed)
+              && (!int(x::is_bounded)
+                 // digits is the number of no-sign bits
+                  || (int(x::digits) + 1 >= digit_traits<boost::intmax_t>::digits)))>::template then<
+        Integer,
+          
+      typename if_true<(int(x::digits) + 1 < digit_traits<signed int>::digits)>::template then<
+        signed int,
+
+      typename if_true<(int(x::digits) + 1 < digit_traits<signed long>::digits)>::template then<
+        signed long,
+
+   // else
+        intmax_t
+      >::type>::type>::type difference_type;
+#else
+      BOOST_STATIC_ASSERT(boost::is_integral<Integer>::value);
+
+      typedef typename
+      if_true<(sizeof(Integer) >= sizeof(intmax_t))>::template then<
+               
+        typename if_true<(is_signed<Integer>::value)>::template then<
+          Integer,
+          intmax_t
+        >::type,
+
+        typename if_true<(sizeof(Integer) < sizeof(std::ptrdiff_t))>::template then<
+          std::ptrdiff_t,
+          intmax_t
+        >::type
+      >::type difference_type;
+# endif
+  };
+
+  // Right now, only supports integers, but should be expanded.
+  template <class Number>
+  struct numeric_traits
+  {
+      typedef typename integer_traits<Number>::difference_type difference_type;
+  };
+
+  template <class Number>
+  typename numeric_traits<Number>::difference_type numeric_distance(Number x, Number y)
+  {
+      typedef typename numeric_traits<Number>::difference_type difference_type;
+      return difference_type(y) - difference_type(x);
+  }
+}}
+
+#endif // BOOST_NUMERIC_TRAITS_HPP_DWA20001901