This commit was manufactured by cvs2svn to create branch 'mpl_v2_2'.

[SVN r18675]

include/boost/cstdint.hpp

@@ -6,9 +6,11 @@
 //  express or implied warranty, and with no claim as to its suitability for
 //  any purpose.
 
-//  See http://www.boost.org for most recent version including documentation.
+//  See http://www.boost.org/libs/integer for documentation.
 
 //  Revision History
+//   31 Oct 01  use BOOST_HAS_LONG_LONG to check for "long long" (Jens M.)
+//   16 Apr 01  check LONGLONG_MAX when looking for "long long" (Jens Maurer)
 //   23 Jan 01  prefer "long" over "int" for int32_t and intmax_t (Jens Maurer)
 //   12 Nov 00  Merged <boost/stdint.h> (Jens Maurer)
 //   23 Sep 00  Added INTXX_C macro support (John Maddock).
@@ -23,9 +25,21 @@
 #include <boost/config.hpp>
 
 
-#ifdef BOOST_SYSTEM_HAS_STDINT_H
+#ifdef BOOST_HAS_STDINT_H
 
-# include <stdint.h> // implementation artifact; not part of interface
+// The following #include is an implementation artifact; not part of interface.
+# ifdef __hpux
+// HP-UX has a vaguely nice <stdint.h> in a non-standard location
+#   include <inttypes.h>
+#   ifdef __STDC_32_MODE__
+      // this is triggered with GCC, because it defines __cplusplus < 199707L
+#     define BOOST_NO_INT64_T
+#   endif 
+# elif defined(__FreeBSD__) || defined(__IBMCPP__)
+#   include <inttypes.h>
+# else
+#   include <stdint.h>
+# endif
 
 namespace boost
 {
@@ -67,11 +81,57 @@ namespace boost
 
 } // namespace boost
 
+#elif defined(__FreeBSD__) && (__FreeBSD__ <= 4)
+// FreeBSD has an <inttypes.h> that contains much of what we need
+# include <inttypes.h>
 
-#else  // BOOST_SYSTEM_HAS_STDINT_H
+namespace boost {
 
+  using ::int8_t;             
+  typedef int8_t int_least8_t;       
+  typedef int8_t int_fast8_t;        
+  using ::uint8_t;            
+  typedef uint8_t uint_least8_t;      
+  typedef uint8_t uint_fast8_t;       
+                     
+  using ::int16_t;            
+  typedef int16_t int_least16_t;      
+  typedef int16_t int_fast16_t;       
+  using ::uint16_t;           
+  typedef uint16_t uint_least16_t;     
+  typedef uint16_t uint_fast16_t;      
+                     
+  using ::int32_t;            
+  typedef int32_t int_least32_t;      
+  typedef int32_t int_fast32_t;       
+  using ::uint32_t;           
+  typedef uint32_t uint_least32_t;     
+  typedef uint32_t uint_fast32_t;      
+         
+# ifndef BOOST_NO_INT64_T          
 
-# include <limits.h> // implementation artifact; not part of interface
+  using ::int64_t;            
+  typedef int64_t int_least64_t;      
+  typedef int64_t int_fast64_t;       
+  using ::uint64_t;           
+  typedef uint64_t uint_least64_t;     
+  typedef uint64_t uint_fast64_t;      
+
+  typedef int64_t intmax_t;
+  typedef uint64_t uintmax_t;
+
+# else
+
+  typedef int32_t intmax_t;
+  typedef uint32_t uintmax_t;
+
+# endif
+
+} // namespace boost
+
+#else  // BOOST_HAS_STDINT_H
+
+# include <boost/limits.hpp> // implementation artifact; not part of interface
 
 
 namespace boost
@@ -101,12 +161,29 @@ namespace boost
 //  16-bit types  -----------------------------------------------------------//
 
 # if USHRT_MAX == 0xffff
+#  if defined(__crayx1)
+     // The Cray X1 has a 16-bit short, however it is not recommend
+     // for use in performance critical code.
+     typedef short           int16_t;
+     typedef short           int_least16_t;
+     typedef int             int_fast16_t;
+     typedef unsigned short  uint16_t;
+     typedef unsigned short  uint_least16_t;
+     typedef unsigned int    uint_fast16_t;
+#  else
      typedef short           int16_t;
      typedef short           int_least16_t;
      typedef short           int_fast16_t;
      typedef unsigned short  uint16_t;
      typedef unsigned short  uint_least16_t;
      typedef unsigned short  uint_fast16_t;
+#  endif
+# elif (USHRT_MAX == 0xffffffff) && defined(CRAY)
+     // no 16-bit types on Cray:
+     typedef short           int_least16_t;
+     typedef short           int_fast16_t;
+     typedef unsigned short  uint_least16_t;
+     typedef unsigned short  uint_fast16_t;
 # else
 #    error defaults not correct; you must hand modify boost/cstdint.hpp
 # endif
@@ -133,9 +210,18 @@ namespace boost
 
 //  64-bit types + intmax_t and uintmax_t  ----------------------------------//
 
-# if (defined(ULLONG_MAX) || defined(ULONG_LONG_MAX))
-#    if(defined(ULLONG_MAX) && ULLONG_MAX == 18446744073709551615U) || (defined(ULONG_LONG_MAX) && ULONG_LONG_MAX == 18446744073709551615U)
+# if defined(BOOST_HAS_LONG_LONG) && \
+   !defined(BOOST_MSVC) && !defined(__BORLANDC__) && \
+   (!defined(__GLIBCPP__) || defined(_GLIBCPP_USE_LONG_LONG)) && \
+   (defined(ULLONG_MAX) || defined(ULONG_LONG_MAX) || defined(ULONGLONG_MAX))
+#    if defined(__hpux)
+     // HP-UX's value of ULONG_LONG_MAX is unusable in preprocessor expressions
+#    elif (defined(ULLONG_MAX) && ULLONG_MAX == 18446744073709551615ULL) || (defined(ULONG_LONG_MAX) && ULONG_LONG_MAX == 18446744073709551615ULL) || (defined(ULONGLONG_MAX) && ULONGLONG_MAX == 18446744073709551615ULL)
                                                                  // 2**64 - 1
+#    else
+#       error defaults not correct; you must hand modify boost/cstdint.hpp
+#    endif
+
      typedef long long            intmax_t;
      typedef unsigned long long   uintmax_t;
      typedef long long            int64_t;
@@ -144,9 +230,7 @@ namespace boost
      typedef unsigned long long   uint64_t;
      typedef unsigned long long   uint_least64_t;
      typedef unsigned long long   uint_fast64_t;
-#    else
-#       error defaults not correct; you must hand modify boost/cstdint.hpp
-#    endif
+
 # elif ULONG_MAX != 0xffffffff
 
 #    if ULONG_MAX == 18446744073709551615 // 2**64 - 1
@@ -161,9 +245,9 @@ namespace boost
 #    else
 #       error defaults not correct; you must hand modify boost/cstdint.hpp
 #    endif
-# elif (defined(BOOST_MSVC) && (BOOST_MSVC >= 1100)) || (defined(__BORLANDC__) && (__BORLANDC__ >= 0x520))
+# elif defined(BOOST_HAS_MS_INT64)
      //
-     // we have Borland/Microsoft __int64:
+     // we have Borland/Intel/Microsoft __int64:
      //
      typedef __int64             intmax_t;
      typedef unsigned __int64    uintmax_t;
@@ -182,7 +266,7 @@ namespace boost
 } // namespace boost
 
 
-#endif // BOOST_SYSTEM_HAS_STDINT_H
+#endif // BOOST_HAS_STDINT_H
 
 #endif // BOOST_CSTDINT_HPP
 
@@ -197,15 +281,17 @@ __STDC_CONSTANT_MACROS is defined.
 Undefine the macros if __STDC_CONSTANT_MACROS is
 not defined and the macros are (cf <cassert>).
 
-Added 23rd September (John Maddock).
+Added 23rd September 2000 (John Maddock).
+Modified 11th September 2001 to be excluded when
+BOOST_HAS_STDINT_H is defined (John Maddock).
 
 ******************************************************/
 
-#if defined(__STDC_CONSTANT_MACROS) && !defined(BOOST__STDC_CONSTANT_MACROS_DEFINED)
+#if defined(__STDC_CONSTANT_MACROS) && !defined(BOOST__STDC_CONSTANT_MACROS_DEFINED) && !defined(BOOST_HAS_STDINT_H)
 # define BOOST__STDC_CONSTANT_MACROS_DEFINED
-# if (defined(BOOST_MSVC) && (BOOST_MSVC >= 1100)) || (defined(__BORLANDC__) && (__BORLANDC__ >= 0x520))
+# if defined(BOOST_HAS_MS_INT64)
 //
-// Borland/Microsoft compilers have width specific suffixes:
+// Borland/Intel/Microsoft compilers have width specific suffixes:
 //
 #  define INT8_C(value)     value##i8
 #  define INT16_C(value)    value##i16
@@ -252,14 +338,20 @@ Added 23rd September (John Maddock).
 
 //  64-bit types + intmax_t and uintmax_t  ----------------------------------//
 
-#  if (defined(ULLONG_MAX) || defined(ULONG_LONG_MAX))
-#    if(defined(ULLONG_MAX) && ULLONG_MAX == 18446744073709551615) ||  \
-        (defined(ULONG_LONG_MAX) && ULONG_LONG_MAX == 18446744073709551615)
-#       define INT64_C(value) value##LL
-#       define UINT64_C(value) value##uLL
+#  if defined(BOOST_HAS_LONG_LONG) && \
+    (defined(ULLONG_MAX) || defined(ULONG_LONG_MAX) || defined(ULONGLONG_MAX))
+
+#    if defined(__hpux)
+     // HP-UX's value of ULONG_LONG_MAX is unusable in preprocessor expressions
+#    elif (defined(ULLONG_MAX) && ULLONG_MAX == 18446744073709551615U) ||  \
+        (defined(ULONG_LONG_MAX) && ULONG_LONG_MAX == 18446744073709551615U) ||  \
+        (defined(ULONGLONG_MAX) && ULONGLONG_MAX == 18446744073709551615U)
+
 #    else
 #       error defaults not correct; you must hand modify boost/cstdint.hpp
 #    endif
+#    define INT64_C(value) value##LL
+#    define UINT64_C(value) value##uLL
 #  elif ULONG_MAX != 0xffffffff
 
 #    if ULONG_MAX == 18446744073709551615 // 2**64 - 1
@@ -281,7 +373,7 @@ Added 23rd September (John Maddock).
 # endif // Borland/Microsoft specific width suffixes
 
 
-#elif defined(BOOST__STDC_CONSTANT_MACROS_DEFINED) && !defined(__STDC_CONSTANT_MACROS)
+#elif defined(BOOST__STDC_CONSTANT_MACROS_DEFINED) && !defined(__STDC_CONSTANT_MACROS) && !defined(BOOST_HAS_STDINT_H)
 //
 // undef all the macros:
 //
@@ -298,3 +390,6 @@ Added 23rd September (John Maddock).
 
 #endif // __STDC_CONSTANT_MACROS_DEFINED etc.
 
+
+
+

include/boost/integer.hpp

@@ -0,0 +1,129 @@
+//  boost integer.hpp header file  -------------------------------------------//
+
+//  (C) Copyright Beman Dawes 1999. Permission to copy, use, modify, sell
+//  and distribute this software is granted provided this copyright
+//  notice appears in all copies. This software is provided "as is" without
+//  express or implied warranty, and with no claim as to its suitability for
+//  any purpose.
+
+//  See http://www.boost.org/libs/integer for documentation.
+
+//  Revision History
+//   22 Sep 01  Added value-based integer templates. (Daryle Walker)
+//   01 Apr 01  Modified to use new <boost/limits.hpp> header. (John Maddock)
+//   30 Jul 00  Add typename syntax fix (Jens Maurer)
+//   28 Aug 99  Initial version
+
+#ifndef BOOST_INTEGER_HPP
+#define BOOST_INTEGER_HPP
+
+#include <boost/integer_fwd.hpp>  // self include
+
+#include <boost/integer_traits.hpp>  // for boost::integer_traits
+#include <boost/limits.hpp>          // for std::numeric_limits
+
+namespace boost
+{
+
+  //  Helper templates  ------------------------------------------------------//
+
+  //  fast integers from least integers
+  //  int_fast_t<> works correctly for unsigned too, in spite of the name.
+  template< typename LeastInt >
+  struct int_fast_t { typedef LeastInt fast; }; // imps may specialize
+
+  //  convert category to type 
+  template< int Category > struct int_least_helper {}; // default is empty
+
+  //  specializatons: 1=long, 2=int, 3=short, 4=signed char,
+  //     6=unsigned long, 7=unsigned int, 8=unsigned short, 9=unsigned long
+  //  no specializations for 0 and 5: requests for a type > long are in error
+  template<> struct int_least_helper<1> { typedef long least; };
+  template<> struct int_least_helper<2> { typedef int least; };
+  template<> struct int_least_helper<3> { typedef short least; };
+  template<> struct int_least_helper<4> { typedef signed char least; };
+  template<> struct int_least_helper<6> { typedef unsigned long least; };
+  template<> struct int_least_helper<7> { typedef unsigned int least; };
+  template<> struct int_least_helper<8> { typedef unsigned short least; };
+  template<> struct int_least_helper<9> { typedef unsigned char least; };
+
+  //  integer templates specifying number of bits  ---------------------------//
+
+  //  signed
+  template< int Bits >   // bits (including sign) required
+  struct int_t 
+  {
+      typedef typename int_least_helper
+        <
+          (Bits-1 <= std::numeric_limits<long>::digits) +
+          (Bits-1 <= std::numeric_limits<int>::digits) +
+          (Bits-1 <= std::numeric_limits<short>::digits) +
+          (Bits-1 <= std::numeric_limits<signed char>::digits)
+        >::least  least;
+      typedef typename int_fast_t<least>::fast  fast;
+  };
+
+  //  unsigned
+  template< int Bits >   // bits required
+  struct uint_t 
+  {
+      typedef typename int_least_helper
+        < 
+          5 +
+          (Bits <= std::numeric_limits<unsigned long>::digits) +
+          (Bits <= std::numeric_limits<unsigned int>::digits) +
+          (Bits <= std::numeric_limits<unsigned short>::digits) +
+          (Bits <= std::numeric_limits<unsigned char>::digits)
+        >::least  least;
+      typedef typename int_fast_t<least>::fast  fast;
+      // int_fast_t<> works correctly for unsigned too, in spite of the name.
+  };
+
+  //  integer templates specifying extreme value  ----------------------------//
+
+  //  signed
+  template< long MaxValue >   // maximum value to require support
+  struct int_max_value_t 
+  {
+      typedef typename int_least_helper
+        <
+          (MaxValue <= integer_traits<long>::const_max) +
+          (MaxValue <= integer_traits<int>::const_max) +
+          (MaxValue <= integer_traits<short>::const_max) +
+          (MaxValue <= integer_traits<signed char>::const_max)
+        >::least  least;
+      typedef typename int_fast_t<least>::fast  fast;
+  };
+
+  template< long MinValue >   // minimum value to require support
+  struct int_min_value_t 
+  {
+      typedef typename int_least_helper
+        <
+          (MinValue >= integer_traits<long>::const_min) +
+          (MinValue >= integer_traits<int>::const_min) +
+          (MinValue >= integer_traits<short>::const_min) +
+          (MinValue >= integer_traits<signed char>::const_min)
+        >::least  least;
+      typedef typename int_fast_t<least>::fast  fast;
+  };
+
+  //  unsigned
+  template< unsigned long Value >   // maximum value to require support
+  struct uint_value_t 
+  {
+      typedef typename int_least_helper
+        < 
+          5 +
+          (Value <= integer_traits<unsigned long>::const_max) +
+          (Value <= integer_traits<unsigned int>::const_max) +
+          (Value <= integer_traits<unsigned short>::const_max) +
+          (Value <= integer_traits<unsigned char>::const_max)
+        >::least  least;
+      typedef typename int_fast_t<least>::fast  fast;
+  };
+
+
+} // namespace boost
+
+#endif  // BOOST_INTEGER_HPP

include/boost/integer_fwd.hpp

@@ -0,0 +1,154 @@
+//  Boost integer_fwd.hpp header file  ---------------------------------------//
+
+//  (C) Copyright boost.org 2001.  Permission to copy, use, modify, sell
+//  and distribute this software is granted provided this copyright
+//  notice appears in all copies.  This software is provided "as is" without
+//  express or implied warranty, and with no claim as to its suitability for
+//  any purpose.
+
+//  See http://www.boost.org/libs/integer for documentation.
+
+#ifndef BOOST_INTEGER_FWD_HPP
+#define BOOST_INTEGER_FWD_HPP
+
+#include <climits>  // for UCHAR_MAX, etc.
+#include <cstddef>  // for std::size_t
+
+#include <boost/config.hpp>  // for BOOST_NO_INTRINSIC_WCHAR_T
+#include <boost/limits.hpp>  // for std::numeric_limits
+
+
+namespace boost
+{
+
+
+//  From <boost/cstdint.hpp>  ------------------------------------------------//
+
+// Only has typedefs or using statements, with #conditionals
+
+
+//  From <boost/integer_traits.hpp>  -----------------------------------------//
+
+template < class T >
+    class integer_traits;
+
+template <  >
+    class integer_traits< bool >;
+
+template <  >
+    class integer_traits< char >;
+
+template <  >
+    class integer_traits< signed char >;
+
+template <  >
+    class integer_traits< unsigned char >;
+
+#ifndef BOOST_NO_INTRINSIC_WCHAR_T
+template <  >
+    class integer_traits< wchar_t >;
+#endif
+
+template <  >
+    class integer_traits< short >;
+
+template <  >
+    class integer_traits< unsigned short >;
+
+template <  >
+    class integer_traits< int >;
+
+template <  >
+    class integer_traits< unsigned int >;
+
+template <  >
+    class integer_traits< long >;
+
+template <  >
+    class integer_traits< unsigned long >;
+
+#ifdef ULLONG_MAX
+template <  >
+    class integer_traits< long long >;
+
+template <  >
+    class integer_traits< unsigned long long >;
+#endif
+
+
+//  From <boost/integer.hpp>  ------------------------------------------------//
+
+template < typename LeastInt >
+    struct int_fast_t;
+
+template< int Bits >
+    struct int_t;
+
+template< int Bits >
+    struct uint_t;
+
+template< long MaxValue >
+    struct int_max_value_t;
+
+template< long MinValue >
+    struct int_min_value_t;
+
+template< unsigned long Value >
+    struct uint_value_t;
+
+
+//  From <boost/integer/integer_mask.hpp>  -----------------------------------//
+
+template < std::size_t Bit >
+    struct high_bit_mask_t;
+
+template < std::size_t Bits >
+    struct low_bits_mask_t;
+
+template <  >
+    struct low_bits_mask_t< ::std::numeric_limits<unsigned char>::digits >;
+
+#if USHRT_MAX > UCHAR_MAX
+template <  >
+    struct low_bits_mask_t< ::std::numeric_limits<unsigned short>::digits >;
+#endif
+
+#if UINT_MAX > USHRT_MAX
+template <  >
+    struct low_bits_mask_t< ::std::numeric_limits<unsigned int>::digits >;
+#endif
+
+#if ULONG_MAX > UINT_MAX
+template <  >
+    struct low_bits_mask_t< ::std::numeric_limits<unsigned long>::digits >;
+#endif
+
+
+//  From <boost/integer/static_log2.hpp>  ------------------------------------//
+
+template < unsigned long Value >
+    struct static_log2;
+
+template <  >
+    struct static_log2< 0ul >;
+
+
+//  From <boost/integer/static_min_max.hpp>  ---------------------------------//
+
+template < long Value1, long Value2 >
+    struct static_signed_min;
+
+template < long Value1, long Value2 >
+    struct static_signed_max;
+
+template < unsigned long Value1, unsigned long Value2 >
+    struct static_unsigned_min;
+
+template < unsigned long Value1, unsigned long Value2 >
+    struct static_unsigned_max;
+
+
+}  // namespace boost
+
+
+#endif  // BOOST_INTEGER_FWD_HPP

include/boost/integer_traits.hpp

@@ -0,0 +1,217 @@
+/* boost integer_traits.hpp header file
+ *
+ * Copyright Jens Maurer 2000
+ * Permission to use, copy, modify, sell, and distribute this software
+ * is hereby granted without fee provided that the above copyright notice
+ * appears in all copies and that both that copyright notice and this
+ * permission notice appear in supporting documentation,
+ *
+ * Jens Maurer makes no representations about the suitability of this
+ * software for any purpose. It is provided "as is" without express or
+ * implied warranty.
+ *
+ * $Id$
+ *
+ * Idea by Beman Dawes, Ed Brey, Steve Cleary, and Nathan Myers
+ */
+
+//  See http://www.boost.org/libs/integer for documentation.
+
+
+#ifndef BOOST_INTEGER_TRAITS_HPP
+#define BOOST_INTEGER_TRAITS_HPP
+
+#include <boost/config.hpp>
+#include <boost/limits.hpp>
+
+// These are an implementation detail and not part of the interface
+#include <limits.h>
+#if !defined(BOOST_NO_INTRINSIC_WCHAR_T) && !defined(BOOST_NO_CWCHAR)
+#include <wchar.h>
+#endif
+
+
+namespace boost {
+template<class T>
+class integer_traits : public std::numeric_limits<T>
+{
+public:
+  BOOST_STATIC_CONSTANT(bool, is_integral = false);
+};
+
+namespace detail {
+template<class T, T min_val, T max_val>
+class integer_traits_base
+{
+public:
+  BOOST_STATIC_CONSTANT(bool, is_integral = true);
+  BOOST_STATIC_CONSTANT(T, const_min = min_val);
+  BOOST_STATIC_CONSTANT(T, const_max = max_val);
+};
+
+#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
+//  A definition is required even for integral static constants
+template<class T, T min_val, T max_val>
+const bool integer_traits_base<T, min_val, max_val>::is_integral;
+
+template<class T, T min_val, T max_val>
+const T integer_traits_base<T, min_val, max_val>::const_min;
+
+template<class T, T min_val, T max_val>
+const T integer_traits_base<T, min_val, max_val>::const_max;
+#endif
+
+} // namespace detail
+
+template<>
+class integer_traits<bool>
+  : public std::numeric_limits<bool>,
+    public detail::integer_traits_base<bool, false, true>
+{ };
+
+template<>
+class integer_traits<char>
+  : public std::numeric_limits<char>,
+    public detail::integer_traits_base<char, CHAR_MIN, CHAR_MAX>
+{ };
+
+template<>
+class integer_traits<signed char>
+  : public std::numeric_limits<signed char>,
+    public detail::integer_traits_base<signed char, SCHAR_MIN, SCHAR_MAX>
+{ };
+
+template<>
+class integer_traits<unsigned char>
+  : public std::numeric_limits<unsigned char>,
+    public detail::integer_traits_base<unsigned char, 0, UCHAR_MAX>
+{ };
+
+#ifndef BOOST_NO_INTRINSIC_WCHAR_T
+template<>
+class integer_traits<wchar_t>
+  : public std::numeric_limits<wchar_t>,
+#if defined(WCHAR_MIN) && defined(WCHAR_MAX)
+    public detail::integer_traits_base<wchar_t, WCHAR_MIN, WCHAR_MAX>
+#elif defined(__BORLANDC__) || defined(__CYGWIN__) || defined(__MINGW32__) || (defined(__BEOS__) && defined(__GNUC__))
+    // No WCHAR_MIN and WCHAR_MAX, whar_t is short and unsigned:
+    public detail::integer_traits_base<wchar_t, 0, 0xffff>
+#elif (defined(__sgi) && (!defined(__SGI_STL_PORT) || __SGI_STL_PORT < 0x400))\
+    || (defined __APPLE__)\
+    || (defined(__OpenBSD__) && defined(__GNUC__))\
+    || (defined(__FreeBSD__) && defined(__GNUC__))\
+    || (defined(__hpux) && defined(__GNUC__) && (__GNUC__ == 3) && !defined(__SGI_STL_PORT))
+    // No WCHAR_MIN and WCHAR_MAX, wchar_t has the same range as int.
+    //  - SGI MIPSpro with native library
+    //  - gcc 3.x on HP-UX
+    //  - Mac OS X with native library
+    //  - gcc on FreeBSD
+    public detail::integer_traits_base<wchar_t, INT_MIN, INT_MAX>
+#elif defined(__hpux) && defined(__GNUC__) && (__GNUC__ == 2) && !defined(__SGI_STL_PORT)
+    // No WCHAR_MIN and WCHAR_MAX, wchar_t has the same range as unsigned int.
+    //  - gcc 2.95.x on HP-UX
+    // (also, std::numeric_limits<wchar_t> appears to return the wrong values).
+    public detail::integer_traits_base<wchar_t, 0, UINT_MAX>
+#else
+#error No WCHAR_MIN and WCHAR_MAX present, please adjust integer_traits<> for your compiler.
+#endif
+{ };
+#endif // BOOST_NO_INTRINSIC_WCHAR_T
+
+template<>
+class integer_traits<short>
+  : public std::numeric_limits<short>,
+    public detail::integer_traits_base<short, SHRT_MIN, SHRT_MAX>
+{ };
+
+template<>
+class integer_traits<unsigned short>
+  : public std::numeric_limits<unsigned short>,
+    public detail::integer_traits_base<unsigned short, 0, USHRT_MAX>
+{ };
+
+template<>
+class integer_traits<int>
+  : public std::numeric_limits<int>,
+    public detail::integer_traits_base<int, INT_MIN, INT_MAX>
+{ };
+
+template<>
+class integer_traits<unsigned int>
+  : public std::numeric_limits<unsigned int>,
+    public detail::integer_traits_base<unsigned int, 0, UINT_MAX>
+{ };
+
+template<>
+class integer_traits<long>
+  : public std::numeric_limits<long>,
+    public detail::integer_traits_base<long, LONG_MIN, LONG_MAX>
+{ };
+
+template<>
+class integer_traits<unsigned long>
+  : public std::numeric_limits<unsigned long>,
+    public detail::integer_traits_base<unsigned long, 0, ULONG_MAX>
+{ };
+
+#if !defined(BOOST_NO_INTEGRAL_INT64_T) && !defined(BOOST_NO_INT64_T)
+#if defined(ULLONG_MAX) && defined(BOOST_HAS_LONG_LONG)
+
+template<>
+class integer_traits<long long>
+  : public std::numeric_limits<long long>,
+    public detail::integer_traits_base<long long, LLONG_MIN, LLONG_MAX>
+{ };
+
+template<>
+class integer_traits<unsigned long long>
+  : public std::numeric_limits<unsigned long long>,
+    public detail::integer_traits_base<unsigned long long, 0, ULLONG_MAX>
+{ };
+
+#elif defined(ULONG_LONG_MAX) && defined(BOOST_HAS_LONG_LONG)
+
+template<>
+class integer_traits<long long>  : public std::numeric_limits<long long>,    public detail::integer_traits_base<long long, LONG_LONG_MIN, LONG_LONG_MAX>{ };
+template<>
+class integer_traits<unsigned long long>
+  : public std::numeric_limits<unsigned long long>,
+    public detail::integer_traits_base<unsigned long long, 0, ULONG_LONG_MAX>
+{ };
+
+#elif defined(ULONGLONG_MAX) && defined(BOOST_HAS_LONG_LONG)
+
+template<>
+class integer_traits<long long>
+  : public std::numeric_limits<long long>,
+    public detail::integer_traits_base<long long, LONGLONG_MIN, LONGLONG_MAX>
+{ };
+
+template<>
+class integer_traits<unsigned long long>
+  : public std::numeric_limits<unsigned long long>,
+    public detail::integer_traits_base<unsigned long long, 0, ULONGLONG_MAX>
+{ };
+
+#elif defined(_LLONG_MAX) && defined(_C2) && defined(BOOST_HAS_LONG_LONG)
+
+template<>
+class integer_traits<long long>
+  : public std::numeric_limits<long long>,
+    public detail::integer_traits_base<long long, -_LLONG_MAX - _C2, _LLONG_MAX>
+{ };
+
+template<>
+class integer_traits<unsigned long long>
+  : public std::numeric_limits<unsigned long long>,
+    public detail::integer_traits_base<unsigned long long, 0, _ULLONG_MAX>
+{ };
+
+#endif
+#endif
+
+} // namespace boost
+
+#endif /* BOOST_INTEGER_TRAITS_HPP */
+
+