+ creating a branch for a xpressive extension that allows nesting

of regular expressions


[SVN r38759]

cstdint_test.cpp

@@ -113,10 +113,24 @@ void integral_constant_type_check(T1, T2)
    assert(sizeof(T1) == sizeof(T2));
    assert(t1 == t2);
 #endif
+#if defined(BOOST_HAS_STDINT_H)
+   // native headers are permitted to promote small
+   // unsigned types to type int:
+   if(sizeof(T1) >= sizeof(int))
+   {
+      if(t1 > 0)
+        assert(t2 > 0);
+      else
+        assert(!(t2 > 0));
+   }
+   else if(t1 < 0)
+      assert(!(t2 > 0));
+#else
    if(t1 > 0)
      assert(t2 > 0);
    else
      assert(!(t2 > 0));
+#endif
 }
 
 

doc/integer_mask.html

@@ -202,10 +202,9 @@ href="../../../people/daryle_walker.html">Daryle Walker</a>.</p>
 
 <p>Revised September 23, 2001</p>
 
-<p>&copy; Copyright Daryle Walker 2001.  Permission to copy, use,
-modify, sell and distribute this document is granted provided this
-copyright notice appears in all copies.  This document is provided
-&quot;as is&quot; without express or implied warranty, and with no claim
-as to its suitability for any purpose.</p>
+<p>&copy; Copyright Daryle Walker 2001.  Use, modification, and distribution are
+subject to the Boost Software License, Version 1.0.  (See accompanying file <a
+href="../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or a copy at &lt;<a
+href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>&gt;.)</p>
 </body>
 </html>

doc/static_min_max.html

@@ -112,10 +112,9 @@ href="../../../people/daryle_walker.html">Daryle Walker</a>.</p>
 
 <p>Revised October 12, 2001</p>
 
-<p>&copy; Copyright Daryle Walker 2001.  Permission to copy, use,
-modify, sell and distribute this document is granted provided this
-copyright notice appears in all copies.  This document is provided
-&quot;as is&quot; without express or implied warranty, and with no claim
-as to its suitability for any purpose.</p>
+<p>&copy; Copyright Daryle Walker 2001.  Use, modification, and distribution are
+subject to the Boost Software License, Version 1.0.  (See accompanying file <a
+href="../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or a copy at &lt;<a
+href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>&gt;.)</p>
 </body>
 </html>

include/boost/cstdint.hpp

@@ -0,0 +1,446 @@
+//  boost cstdint.hpp header file  ------------------------------------------//
+
+//  (C) Copyright Beman Dawes 1999. 
+//  (C) Copyright Jens Mauer 2001  
+//  (C) Copyright John Maddock 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)
+
+//  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).
+//   22 Sep 00  Better 64-bit support (John Maddock)
+//   29 Jun 00  Reimplement to avoid including stdint.h within namespace boost
+//    8 Aug 99  Initial version (Beman Dawes)
+
+
+#ifndef BOOST_CSTDINT_HPP
+#define BOOST_CSTDINT_HPP
+
+#include <boost/config.hpp>
+
+
+#ifdef BOOST_HAS_STDINT_H
+
+// 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>
+
+// There is a bug in Cygwin two _C macros
+#   if defined(__STDC_CONSTANT_MACROS) && defined(__CYGWIN__)
+#     undef INTMAX_C
+#     undef UINTMAX_C
+#     define INTMAX_C(c) c##LL
+#     define UINTMAX_C(c) c##ULL
+#   endif
+
+# endif
+
+#ifdef __QNX__
+
+// QNX (Dinkumware stdlib) defines these as non-standard names.
+// Reflect to the standard names.
+
+typedef ::intleast8_t int_least8_t;
+typedef ::intfast8_t int_fast8_t;
+typedef ::uintleast8_t uint_least8_t;
+typedef ::uintfast8_t uint_fast8_t;
+
+typedef ::intleast16_t int_least16_t;
+typedef ::intfast16_t int_fast16_t;
+typedef ::uintleast16_t uint_least16_t;
+typedef ::uintfast16_t uint_fast16_t;
+
+typedef ::intleast32_t int_least32_t;
+typedef ::intfast32_t int_fast32_t;
+typedef ::uintleast32_t uint_least32_t;
+typedef ::uintfast32_t uint_fast32_t;
+
+# ifndef BOOST_NO_INT64_T
+
+typedef ::intleast64_t int_least64_t;
+typedef ::intfast64_t int_fast64_t;
+typedef ::uintleast64_t uint_least64_t;
+typedef ::uintfast64_t uint_fast64_t;
+
+# endif
+
+#endif
+
+namespace boost
+{
+
+  using ::int8_t;             
+  using ::int_least8_t;       
+  using ::int_fast8_t;        
+  using ::uint8_t;            
+  using ::uint_least8_t;      
+  using ::uint_fast8_t;       
+                     
+  using ::int16_t;            
+  using ::int_least16_t;      
+  using ::int_fast16_t;       
+  using ::uint16_t;           
+  using ::uint_least16_t;     
+  using ::uint_fast16_t;      
+                     
+  using ::int32_t;            
+  using ::int_least32_t;      
+  using ::int_fast32_t;       
+  using ::uint32_t;           
+  using ::uint_least32_t;     
+  using ::uint_fast32_t;      
+                     
+# ifndef BOOST_NO_INT64_T
+
+  using ::int64_t;            
+  using ::int_least64_t;      
+  using ::int_fast64_t;       
+  using ::uint64_t;           
+  using ::uint_least64_t;     
+  using ::uint_fast64_t;      
+                     
+# endif
+
+  using ::intmax_t;      
+  using ::uintmax_t;     
+
+} // namespace boost
+
+#elif defined(__FreeBSD__) && (__FreeBSD__ <= 4) || defined(__osf__)
+// FreeBSD and Tru64 have an <inttypes.h> that contains much of what we need.
+# include <inttypes.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          
+
+  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
+# include <limits.h>         // needed for limits macros
+
+
+namespace boost
+{
+
+//  These are fairly safe guesses for some 16-bit, and most 32-bit and 64-bit
+//  platforms.  For other systems, they will have to be hand tailored.
+//
+//  Because the fast types are assumed to be the same as the undecorated types,
+//  it may be possible to hand tailor a more efficient implementation.  Such
+//  an optimization may be illusionary; on the Intel x86-family 386 on, for
+//  example, byte arithmetic and load/stores are as fast as "int" sized ones.
+
+//  8-bit types  ------------------------------------------------------------//
+
+# if UCHAR_MAX == 0xff
+     typedef signed char     int8_t;
+     typedef signed char     int_least8_t;
+     typedef signed char     int_fast8_t;
+     typedef unsigned char   uint8_t;
+     typedef unsigned char   uint_least8_t;
+     typedef unsigned char   uint_fast8_t;
+# else
+#    error defaults not correct; you must hand modify boost/cstdint.hpp
+# endif
+
+//  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
+
+//  32-bit types  -----------------------------------------------------------//
+
+# if ULONG_MAX == 0xffffffff
+     typedef long            int32_t;
+     typedef long            int_least32_t;
+     typedef long            int_fast32_t;
+     typedef unsigned long   uint32_t;
+     typedef unsigned long   uint_least32_t;
+     typedef unsigned long   uint_fast32_t;
+# elif UINT_MAX == 0xffffffff
+     typedef int             int32_t;
+     typedef int             int_least32_t;
+     typedef int             int_fast32_t;
+     typedef unsigned int    uint32_t;
+     typedef unsigned int    uint_least32_t;
+     typedef unsigned int    uint_fast32_t;
+# else
+#    error defaults not correct; you must hand modify boost/cstdint.hpp
+# endif
+
+//  64-bit types + intmax_t and uintmax_t  ----------------------------------//
+
+# 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  ::boost::long_long_type            intmax_t;
+     typedef  ::boost::ulong_long_type   uintmax_t;
+     typedef  ::boost::long_long_type            int64_t;
+     typedef  ::boost::long_long_type            int_least64_t;
+     typedef  ::boost::long_long_type            int_fast64_t;
+     typedef  ::boost::ulong_long_type   uint64_t;
+     typedef  ::boost::ulong_long_type   uint_least64_t;
+     typedef  ::boost::ulong_long_type   uint_fast64_t;
+
+# elif ULONG_MAX != 0xffffffff
+
+#    if ULONG_MAX == 18446744073709551615 // 2**64 - 1
+     typedef long                 intmax_t;
+     typedef unsigned long        uintmax_t;
+     typedef long                 int64_t;
+     typedef long                 int_least64_t;
+     typedef long                 int_fast64_t;
+     typedef unsigned long        uint64_t;
+     typedef unsigned long        uint_least64_t;
+     typedef unsigned long        uint_fast64_t;
+#    else
+#       error defaults not correct; you must hand modify boost/cstdint.hpp
+#    endif
+# elif defined(__GNUC__) && defined(BOOST_HAS_LONG_LONG)
+     __extension__ typedef long long            intmax_t;
+     __extension__ typedef unsigned long long   uintmax_t;
+     __extension__ typedef long long            int64_t;
+     __extension__ typedef long long            int_least64_t;
+     __extension__ typedef long long            int_fast64_t;
+     __extension__ typedef unsigned long long   uint64_t;
+     __extension__ typedef unsigned long long   uint_least64_t;
+     __extension__ typedef unsigned long long   uint_fast64_t;
+# elif defined(BOOST_HAS_MS_INT64)
+     //
+     // we have Borland/Intel/Microsoft __int64:
+     //
+     typedef __int64             intmax_t;
+     typedef unsigned __int64    uintmax_t;
+     typedef __int64             int64_t;
+     typedef __int64             int_least64_t;
+     typedef __int64             int_fast64_t;
+     typedef unsigned __int64    uint64_t;
+     typedef unsigned __int64    uint_least64_t;
+     typedef unsigned __int64    uint_fast64_t;
+# else // assume no 64-bit integers
+#  define BOOST_NO_INT64_T
+     typedef int32_t              intmax_t;
+     typedef uint32_t             uintmax_t;
+# endif
+
+} // namespace boost
+
+
+#endif // BOOST_HAS_STDINT_H
+
+#endif // BOOST_CSTDINT_HPP
+
+
+/****************************************************
+
+Macro definition section:
+
+Define various INTXX_C macros only if
+__STDC_CONSTANT_MACROS is defined.
+
+Undefine the macros if __STDC_CONSTANT_MACROS is
+not defined and the macros are (cf <cassert>).
+
+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) && !defined(BOOST_HAS_STDINT_H)
+# define BOOST__STDC_CONSTANT_MACROS_DEFINED
+# if defined(BOOST_HAS_MS_INT64)
+//
+// Borland/Intel/Microsoft compilers have width specific suffixes:
+//
+#  define INT8_C(value)     value##i8
+#  define INT16_C(value)    value##i16
+#  define INT32_C(value)    value##i32
+#  define INT64_C(value)    value##i64
+#  ifdef __BORLANDC__
+    // Borland bug: appending ui8 makes the type a signed char
+#   define UINT8_C(value)    static_cast<unsigned char>(value##u)
+#  else
+#   define UINT8_C(value)    value##ui8
+#  endif
+#  define UINT16_C(value)   value##ui16
+#  define UINT32_C(value)   value##ui32
+#  define UINT64_C(value)   value##ui64
+#  define INTMAX_C(value)   value##i64
+#  define UINTMAX_C(value)  value##ui64
+
+# else
+//  do it the old fashioned way:
+
+//  8-bit types  ------------------------------------------------------------//
+
+#  if UCHAR_MAX == 0xff
+#   define INT8_C(value) static_cast<boost::int8_t>(value)
+#   define UINT8_C(value) static_cast<boost::uint8_t>(value##u)
+#  endif
+
+//  16-bit types  -----------------------------------------------------------//
+
+#  if USHRT_MAX == 0xffff
+#   define INT16_C(value) static_cast<boost::int16_t>(value)
+#   define UINT16_C(value) static_cast<boost::uint16_t>(value##u)
+#  endif
+
+//  32-bit types  -----------------------------------------------------------//
+
+#  if UINT_MAX == 0xffffffff
+#   define INT32_C(value) value
+#   define UINT32_C(value) value##u
+#  elif ULONG_MAX == 0xffffffff
+#   define INT32_C(value) value##L
+#   define UINT32_C(value) value##uL
+#  endif
+
+//  64-bit types + intmax_t and uintmax_t  ----------------------------------//
+
+#  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
+#       define INT64_C(value) value##L
+#       define UINT64_C(value) value##uL
+#    else
+#       error defaults not correct; you must hand modify boost/cstdint.hpp
+#    endif
+#  endif
+
+#  ifdef BOOST_NO_INT64_T
+#   define INTMAX_C(value) INT32_C(value)
+#   define UINTMAX_C(value) UINT32_C(value)
+#  else
+#   define INTMAX_C(value) INT64_C(value)
+#   define UINTMAX_C(value) UINT64_C(value)
+#  endif
+
+# endif // Borland/Microsoft specific width suffixes
+
+
+#elif defined(BOOST__STDC_CONSTANT_MACROS_DEFINED) && !defined(__STDC_CONSTANT_MACROS) && !defined(BOOST_HAS_STDINT_H)
+//
+// undef all the macros:
+//
+# undef INT8_C
+# undef INT16_C
+# undef INT32_C
+# undef INT64_C
+# undef UINT8_C
+# undef UINT16_C
+# undef UINT32_C
+# undef UINT64_C
+# undef INTMAX_C
+# undef UINTMAX_C
+
+#endif // __STDC_CONSTANT_MACROS_DEFINED etc.
+
+
+
+

include/boost/integer.hpp

@@ -0,0 +1,127 @@
+//  boost integer.hpp header file  -------------------------------------------//
+
+//  Copyright Beman Dawes and Daryle Walker 1999.  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)
+
+//  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/integer_mask.hpp

@@ -0,0 +1,93 @@
+//  Boost integer/integer_mask.hpp header file  ------------------------------//
+
+//  (C) Copyright Daryle Walker 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)
+
+//  See http://www.boost.org for updates, documentation, and revision history. 
+
+#ifndef BOOST_INTEGER_INTEGER_MASK_HPP
+#define BOOST_INTEGER_INTEGER_MASK_HPP
+
+#include <boost/integer_fwd.hpp>  // self include
+
+#include <boost/config.hpp>   // for BOOST_STATIC_CONSTANT
+#include <boost/integer.hpp>  // for boost::uint_t
+
+#include <climits>  // for UCHAR_MAX, etc.
+#include <cstddef>  // for std::size_t
+
+#include <boost/limits.hpp>  // for std::numeric_limits
+
+
+namespace boost
+{
+
+
+//  Specified single-bit mask class declaration  -----------------------------//
+//  (Lowest bit starts counting at 0.)
+
+template < std::size_t Bit >
+struct high_bit_mask_t
+{
+    typedef typename uint_t<(Bit + 1)>::least  least;
+    typedef typename uint_t<(Bit + 1)>::fast   fast;
+
+    BOOST_STATIC_CONSTANT( least, high_bit = (least( 1u ) << Bit) );
+    BOOST_STATIC_CONSTANT( fast, high_bit_fast = (fast( 1u ) << Bit) );
+
+    BOOST_STATIC_CONSTANT( std::size_t, bit_position = Bit );
+
+};  // boost::high_bit_mask_t
+
+
+//  Specified bit-block mask class declaration  ------------------------------//
+//  Makes masks for the lowest N bits
+//  (Specializations are needed when N fills up a type.)
+
+template < std::size_t Bits >
+struct low_bits_mask_t
+{
+    typedef typename uint_t<Bits>::least  least;
+    typedef typename uint_t<Bits>::fast   fast;
+
+    BOOST_STATIC_CONSTANT( least, sig_bits = (~( ~(least( 0u )) << Bits )) );
+    BOOST_STATIC_CONSTANT( fast, sig_bits_fast = fast(sig_bits) );
+
+    BOOST_STATIC_CONSTANT( std::size_t, bit_count = Bits );
+
+};  // boost::low_bits_mask_t
+
+
+#define BOOST_LOW_BITS_MASK_SPECIALIZE( Type )                                  \
+  template <  >  struct low_bits_mask_t< std::numeric_limits<Type>::digits >  { \
+      typedef std::numeric_limits<Type>           limits_type;                  \
+      typedef uint_t<limits_type::digits>::least  least;                        \
+      typedef uint_t<limits_type::digits>::fast   fast;                         \
+      BOOST_STATIC_CONSTANT( least, sig_bits = (~( least(0u) )) );              \
+      BOOST_STATIC_CONSTANT( fast, sig_bits_fast = fast(sig_bits) );            \
+      BOOST_STATIC_CONSTANT( std::size_t, bit_count = limits_type::digits );    \
+  }
+
+BOOST_LOW_BITS_MASK_SPECIALIZE( unsigned char );
+
+#if USHRT_MAX > UCHAR_MAX
+BOOST_LOW_BITS_MASK_SPECIALIZE( unsigned short );
+#endif
+
+#if UINT_MAX > USHRT_MAX
+BOOST_LOW_BITS_MASK_SPECIALIZE( unsigned int );
+#endif
+
+#if ULONG_MAX > UINT_MAX
+BOOST_LOW_BITS_MASK_SPECIALIZE( unsigned long );
+#endif
+
+#undef BOOST_LOW_BITS_MASK_SPECIALIZE
+
+
+}  // namespace boost
+
+
+#endif  // BOOST_INTEGER_INTEGER_MASK_HPP

include/boost/integer/static_log2.hpp

@@ -0,0 +1,132 @@
+// -------------- Boost static_log2.hpp header file  ----------------------- //
+//
+//                 Copyright (C) 2001 Daryle Walker.
+//                 Copyright (C) 2003 Vesa Karvonen.
+//                 Copyright (C) 2003 Gennaro Prota.
+//
+//     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)
+//
+//         ---------------------------------------------------
+//       See http://www.boost.org/libs/integer for documentation.
+// ------------------------------------------------------------------------- //
+
+
+#ifndef BOOST_INTEGER_STATIC_LOG2_HPP
+#define BOOST_INTEGER_STATIC_LOG2_HPP
+
+#include "boost/config.hpp" // for BOOST_STATIC_CONSTANT
+
+namespace boost {
+
+ namespace detail {
+
+     namespace static_log2_impl {
+
+     // choose_initial_n<>
+     //
+     // Recursively doubles its integer argument, until it
+     // becomes >= of the "width" (C99, 6.2.6.2p4) of
+     // static_log2_argument_type.
+     //
+     // Used to get the maximum power of two less then the width.
+     //
+     // Example: if on your platform argument_type has 48 value
+     //          bits it yields n=32.
+     //
+     // It's easy to prove that, starting from such a value
+     // of n, the core algorithm works correctly for any width
+     // of static_log2_argument_type and that recursion always
+     // terminates with x = 1 and n = 0 (see the algorithm's
+     // invariant).
+
+     typedef unsigned long argument_type;
+     typedef          int  result_type;
+
+
+     template <result_type n>
+     struct choose_initial_n {
+
+         enum { c = (argument_type(1) << n << n) != 0 };
+         BOOST_STATIC_CONSTANT(
+             result_type,
+             value = !c*n + choose_initial_n<2*c*n>::value
+         );
+
+     };
+
+     template <>
+     struct choose_initial_n<0> {
+         BOOST_STATIC_CONSTANT(result_type, value = 0);
+     };
+
+
+
+     // start computing from n_zero - must be a power of two
+     const result_type n_zero = 16;
+     const result_type initial_n = choose_initial_n<n_zero>::value;
+
+     // static_log2_impl<>
+     //
+     // * Invariant:
+     //                 2n
+     //  1 <= x && x < 2    at the start of each recursion
+     //                     (see also choose_initial_n<>)
+     //
+     // * Type requirements:
+     //
+     //   argument_type maybe any unsigned type with at least n_zero + 1
+     //   value bits. (Note: If larger types will be standardized -e.g.
+     //   unsigned long long- then the argument_type typedef can be
+     //   changed without affecting the rest of the code.)
+     //
+
+     template <argument_type x, result_type n = initial_n>
+     struct static_log2_impl {
+
+         enum { c = (x >> n) > 0 }; // x >= 2**n ?
+         BOOST_STATIC_CONSTANT(
+             result_type,
+             value = c*n + (static_log2_impl< (x>>c*n), n/2 >::value)
+         );
+
+     };
+
+     template <>
+     struct static_log2_impl<1, 0> {
+        BOOST_STATIC_CONSTANT(result_type, value = 0);
+     };
+
+     }
+ } // detail
+
+
+
+ // --------------------------------------
+ // static_log2<x>
+ // ----------------------------------------
+
+ typedef detail::static_log2_impl::argument_type static_log2_argument_type;
+ typedef detail::static_log2_impl::result_type   static_log2_result_type;
+
+
+ template <static_log2_argument_type x>
+ struct static_log2 {
+
+     BOOST_STATIC_CONSTANT(
+         static_log2_result_type,
+         value = detail::static_log2_impl::static_log2_impl<x>::value
+     );
+
+ };
+
+
+ template <>
+ struct static_log2<0> { };
+
+}
+
+
+
+#endif // include guard

include/boost/integer/static_min_max.hpp

@@ -0,0 +1,55 @@
+//  Boost integer/static_min_max.hpp header file  ----------------------------//
+
+//  (C) Copyright Daryle Walker 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)
+
+//  See http://www.boost.org for updates, documentation, and revision history. 
+
+#ifndef BOOST_INTEGER_STATIC_MIN_MAX_HPP
+#define BOOST_INTEGER_STATIC_MIN_MAX_HPP
+
+#include <boost/integer_fwd.hpp>  // self include
+
+#include <boost/config.hpp>  // for BOOST_STATIC_CONSTANT
+
+
+namespace boost
+{
+
+
+//  Compile-time extrema class declarations  ---------------------------------//
+//  Get the minimum or maximum of two values, signed or unsigned.
+
+template < long Value1, long Value2 >
+struct static_signed_min
+{
+    BOOST_STATIC_CONSTANT( long, value = (Value1 > Value2) ? Value2 : Value1 );
+};
+
+template < long Value1, long Value2 >
+struct static_signed_max
+{
+    BOOST_STATIC_CONSTANT( long, value = (Value1 < Value2) ? Value2 : Value1 );
+};
+
+template < unsigned long Value1, unsigned long Value2 >
+struct static_unsigned_min
+{
+    BOOST_STATIC_CONSTANT( unsigned long, value
+     = (Value1 > Value2) ? Value2 : Value1 );
+};
+
+template < unsigned long Value1, unsigned long Value2 >
+struct static_unsigned_max
+{
+    BOOST_STATIC_CONSTANT( unsigned long, value
+     = (Value1 < Value2) ? Value2 : Value1 );
+};
+
+
+}  // namespace boost
+
+
+#endif  // BOOST_INTEGER_STATIC_MIN_MAX_HPP

include/boost/integer_fwd.hpp

@@ -0,0 +1,152 @@
+//  Boost integer_fwd.hpp header file  ---------------------------------------//
+
+//  (C) Copyright Dave Abrahams and Daryle Walker 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)
+
+//  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<  ::boost::long_long_type>;
+
+template <  >
+    class integer_traits<  ::boost::ulong_long_type >;
+#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,236 @@
+/* boost integer_traits.hpp header file
+ *
+ * Copyright Jens Maurer 2000
+ * 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)
+ *
+ * $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>
+// we need wchar.h for WCHAR_MAX/MIN but not all platforms provide it,
+// and some may have <wchar.h> but not <cwchar> ...
+#if !defined(BOOST_NO_INTRINSIC_WCHAR_T) && (!defined(BOOST_NO_CWCHAR) || defined(sun) || defined(__sun) || defined(__QNX__))
+#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>,
+    // Don't trust WCHAR_MIN and WCHAR_MAX with Mac OS X's native
+    // library: they are wrong!
+#if defined(WCHAR_MIN) && defined(WCHAR_MAX) && !defined(__APPLE__)
+    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(__NetBSD__) && defined(__GNUC__))\
+    || (defined(__FreeBSD__) && defined(__GNUC__))\
+    || (defined(__DragonFly__) && 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, OpenBSD and NetBSD
+    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< ::boost::long_long_type>
+  : public std::numeric_limits< ::boost::long_long_type>,
+    public detail::integer_traits_base< ::boost::long_long_type, LLONG_MIN, LLONG_MAX>
+{ };
+
+template<>
+class integer_traits< ::boost::ulong_long_type>
+  : public std::numeric_limits< ::boost::ulong_long_type>,
+    public detail::integer_traits_base< ::boost::ulong_long_type, 0, ULLONG_MAX>
+{ };
+
+#elif defined(ULONG_LONG_MAX) && defined(BOOST_HAS_LONG_LONG)
+
+template<>
+class integer_traits< ::boost::long_long_type>  : public std::numeric_limits< ::boost::long_long_type>,    public detail::integer_traits_base< ::boost::long_long_type, LONG_LONG_MIN, LONG_LONG_MAX>{ };
+template<>
+class integer_traits< ::boost::ulong_long_type>
+  : public std::numeric_limits< ::boost::ulong_long_type>,
+    public detail::integer_traits_base< ::boost::ulong_long_type, 0, ULONG_LONG_MAX>
+{ };
+
+#elif defined(ULONGLONG_MAX) && defined(BOOST_HAS_LONG_LONG)
+
+template<>
+class integer_traits< ::boost::long_long_type>
+  : public std::numeric_limits< ::boost::long_long_type>,
+    public detail::integer_traits_base< ::boost::long_long_type, LONGLONG_MIN, LONGLONG_MAX>
+{ };
+
+template<>
+class integer_traits< ::boost::ulong_long_type>
+  : public std::numeric_limits< ::boost::ulong_long_type>,
+    public detail::integer_traits_base< ::boost::ulong_long_type, 0, ULONGLONG_MAX>
+{ };
+
+#elif defined(_LLONG_MAX) && defined(_C2) && defined(BOOST_HAS_LONG_LONG)
+
+template<>
+class integer_traits< ::boost::long_long_type>
+  : public std::numeric_limits< ::boost::long_long_type>,
+    public detail::integer_traits_base< ::boost::long_long_type, -_LLONG_MAX - _C2, _LLONG_MAX>
+{ };
+
+template<>
+class integer_traits< ::boost::ulong_long_type>
+  : public std::numeric_limits< ::boost::ulong_long_type>,
+    public detail::integer_traits_base< ::boost::ulong_long_type, 0, _ULLONG_MAX>
+{ };
+
+#elif defined(BOOST_HAS_LONG_LONG)
+//
+// we have long long but no constants, this happens for example with gcc in -ansi mode,
+// we'll just have to work out the values for ourselves (assumes 2's compliment representation):
+//
+template<>
+class integer_traits< ::boost::long_long_type>
+  : public std::numeric_limits< ::boost::long_long_type>,
+    public detail::integer_traits_base< ::boost::long_long_type, (1LL << (sizeof(::boost::long_long_type) - 1)), ~(1LL << (sizeof(::boost::long_long_type) - 1))>
+{ };
+
+template<>
+class integer_traits< ::boost::ulong_long_type>
+  : public std::numeric_limits< ::boost::ulong_long_type>,
+    public detail::integer_traits_base< ::boost::ulong_long_type, 0, ~0uLL>
+{ };
+
+#endif
+#endif
+
+} // namespace boost
+
+#endif /* BOOST_INTEGER_TRAITS_HPP */
+
+
+

integer.htm

@@ -204,10 +204,9 @@ value-based sized templates.</p>
 
 <p>Revised May 20, 2001</p>
 
-<p>&copy; Copyright Beman Dawes 1999.  Permission to copy, use, modify,
-sell and distribute this document is granted provided this copyright
-notice appears in all copies.  This document is provided &quot;as
-is&quot; without express or implied warranty, and with no claim as to
-its suitability for any purpose.</p>
+<p>&copy; Copyright Beman Dawes 1999.  Use, modification, and distribution are
+subject to the Boost Software License, Version 1.0.  (See accompanying file <a
+href="../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or a copy at &lt;<a
+href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>&gt;.)</p>
 </body>
 </html>

integer_test.cpp

@@ -12,7 +12,7 @@
 //   10 Mar 01  Boost Test Library now used for tests (Beman Dawes)
 //   31 Aug 99  Initial version
 
-#include <boost/test/minimal.hpp>  // for main, BOOST_TEST
+#include <boost/test/minimal.hpp>  // for main, BOOST_CHECK
 
 #include <boost/config.hpp>   // for BOOST_NO_USING_TEMPLATE
 #include <boost/cstdlib.hpp>  // for boost::exit_success
@@ -128,9 +128,27 @@ namespace boost
 
 
 // Test if a constant can fit within a certain type
-#define PRIVATE_FIT_TEST(Template, Number, Type, Value)  BOOST_TEST( Template < Number > :: Type ( Value ) == Value )
+#define PRIVATE_FIT_TEST(Template, Number, Type, Value)  BOOST_CHECK( Template < Number > :: Type ( Value ) == Value )
 
-#define PRIVATE_FIT_TESTS(Template, Type, ValType, InitVal)  do { ValType v = InitVal ; PRIVATE_FIT_TEST(Template, 32, Type, v); v >>= 1; \
+#if ULONG_MAX > 0xFFFFFFFFL
+#define PRIVATE_FIT_TESTS(Template, Type, ValType, InitVal)  do { ValType v = InitVal ; \
+ PRIVATE_FIT_TEST(Template, 64, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 63, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 62, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 61, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 60, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 59, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 58, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 57, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 56, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 55, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 54, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 53, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 52, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 51, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 50, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 49, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 48, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 47, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 46, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 45, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 44, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 43, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 42, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 41, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 40, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 39, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 38, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 37, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 36, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 35, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 34, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 33, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 32, Type, v); v >>= 1; \
  PRIVATE_FIT_TEST(Template, 31, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 30, Type, v); v >>= 1; \
  PRIVATE_FIT_TEST(Template, 29, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 28, Type, v); v >>= 1; \
  PRIVATE_FIT_TEST(Template, 27, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 26, Type, v); v >>= 1; \
@@ -147,8 +165,28 @@ namespace boost
  PRIVATE_FIT_TEST(Template, 5, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 4, Type, v); v >>= 1; \
  PRIVATE_FIT_TEST(Template, 3, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 2, Type, v); v >>= 1; \
  PRIVATE_FIT_TEST(Template, 1, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 0, Type, v); } while ( false )
+#else
+#define PRIVATE_FIT_TESTS(Template, Type, ValType, InitVal)  do { ValType v = InitVal ; \
+ PRIVATE_FIT_TEST(Template, 32, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 31, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 30, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 29, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 28, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 27, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 26, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 25, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 24, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 23, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 22, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 21, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 20, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 19, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 18, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 17, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 16, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 15, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 14, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 13, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 12, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 11, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 10, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 9, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 8, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 7, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 6, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 5, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 4, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 3, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 2, Type, v); v >>= 1; \
+ PRIVATE_FIT_TEST(Template, 1, Type, v); v >>= 1; PRIVATE_FIT_TEST(Template, 0, Type, v); } while ( false )
+#endif
 
-#define PRIVATE_SHIFTED_FIT_TEST(Template, Number, Type, Value)  BOOST_TEST( Template < (ULONG_MAX >> Number) > :: Type ( Value ) == Value )
+#define PRIVATE_SHIFTED_FIT_TEST(Template, Number, Type, Value)  BOOST_CHECK( Template < (ULONG_MAX >> Number) > :: Type ( Value ) == Value )
 
 #define PRIVATE_SHIFTED_FIT_TESTS(Template, Type, ValType, InitVal)  do { ValType v = InitVal ; \
  PRIVATE_SHIFTED_FIT_TEST(Template, 0, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 1, Type, v); v >>= 1; \
@@ -168,7 +206,7 @@ namespace boost
  PRIVATE_SHIFTED_FIT_TEST(Template, 28, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 29, Type, v); v >>= 1; \
  PRIVATE_SHIFTED_FIT_TEST(Template, 30, Type, v); v >>= 1; PRIVATE_SHIFTED_FIT_TEST(Template, 31, Type, v); } while ( false )
 
-#define PRIVATE_POS_SHIFTED_FIT_TEST(Template, Number, Type, Value)  BOOST_TEST( Template < (LONG_MAX >> Number) > :: Type ( Value ) == Value )
+#define PRIVATE_POS_SHIFTED_FIT_TEST(Template, Number, Type, Value)  BOOST_CHECK( Template < (LONG_MAX >> Number) > :: Type ( Value ) == Value )
 
 #define PRIVATE_POS_FIT_TESTS(Template, Type, ValType, InitVal)  do { ValType v = InitVal ; \
  PRIVATE_POS_SHIFTED_FIT_TEST(Template, 0, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 1, Type, v); v >>= 1; \
@@ -188,7 +226,7 @@ namespace boost
  PRIVATE_POS_SHIFTED_FIT_TEST(Template, 28, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 29, Type, v); v >>= 1; \
  PRIVATE_POS_SHIFTED_FIT_TEST(Template, 30, Type, v); v >>= 1; PRIVATE_POS_SHIFTED_FIT_TEST(Template, 31, Type, v); } while ( false )
 
-#define PRIVATE_NEG_SHIFTED_FIT_TEST(Template, Number, Type, Value)  BOOST_TEST( Template < (LONG_MIN >> Number) > :: Type ( Value ) == Value )
+#define PRIVATE_NEG_SHIFTED_FIT_TEST(Template, Number, Type, Value)  BOOST_CHECK( Template < (LONG_MIN >> Number) > :: Type ( Value ) == Value )
 
 #define PRIVATE_NEG_FIT_TESTS(Template, Type, ValType, InitVal)  do { ValType v = InitVal ; \
  PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 0, Type, v); v >>= 1; PRIVATE_NEG_SHIFTED_FIT_TEST(Template, 1, Type, v); v >>= 1; \

integer_traits_test.cpp

@@ -53,11 +53,19 @@ void runtest(const char * type, T)
             << "; min is " << make_char_numeric_for_streaming((traits::min)())
             << ", max is " << make_char_numeric_for_streaming((traits::max)())
             << std::endl;
-  BOOST_TEST(traits::is_specialized);
-  BOOST_TEST(traits::is_integer);
-  BOOST_TEST(traits::is_integral);
-  BOOST_TEST(traits::const_min == (traits::min)());
-  BOOST_TEST(traits::const_max == (traits::max)());
+  BOOST_CHECK(traits::is_specialized);
+#if defined(BOOST_MSVC) && (BOOST_MSVC <= 1200)
+  // MSVC++ 6.0 issues a LNK1179 error (duplicate comdat) when the compiler
+  // generates different symbol names with a very long common prefix:
+  // the dummy "&& true" disambiguates between the symbols generated by this
+  // BOOST_CHECK instantiation and the preceding one.
+  BOOST_CHECK(traits::is_integer && true);
+#else
+  BOOST_CHECK(traits::is_integer);
+#endif
+  BOOST_CHECK(traits::is_integral == true);
+  BOOST_CHECK(traits::const_min == (traits::min)());
+  BOOST_CHECK(traits::const_max == (traits::max)());
 }
 
 int test_main(int, char*[])

test/integer_mask_test.cpp

@@ -19,16 +19,16 @@
 #include <iostream>  // for std::cout (std::endl indirectly)
 
 
-#define PRIVATE_HIGH_BIT_SLOW_TEST(v)  BOOST_TEST( ::boost::high_bit_mask_t< \
+#define PRIVATE_HIGH_BIT_SLOW_TEST(v)  BOOST_CHECK( ::boost::high_bit_mask_t< \
  (v) >::high_bit == (1ul << (v)) );
-#define PRIVATE_HIGH_BIT_FAST_TEST(v)  BOOST_TEST( ::boost::high_bit_mask_t< \
+#define PRIVATE_HIGH_BIT_FAST_TEST(v)  BOOST_CHECK( ::boost::high_bit_mask_t< \
  (v) >::high_bit_fast == (1ul << (v)) );
 #define PRIVATE_HIGH_BIT_TEST(v)  do { PRIVATE_HIGH_BIT_SLOW_TEST(v); \
  PRIVATE_HIGH_BIT_FAST_TEST(v); } while (false)
 
-#define PRIVATE_LOW_BITS_SLOW_TEST(v)  BOOST_TEST( ::boost::low_bits_mask_t< \
+#define PRIVATE_LOW_BITS_SLOW_TEST(v)  BOOST_CHECK( ::boost::low_bits_mask_t< \
  (v) >::sig_bits == ((1ul << (v)) - 1) );
-#define PRIVATE_LOW_BITS_FAST_TEST(v)  BOOST_TEST( ::boost::low_bits_mask_t< \
+#define PRIVATE_LOW_BITS_FAST_TEST(v)  BOOST_CHECK( ::boost::low_bits_mask_t< \
  (v) >::sig_bits_fast == ((1ul << (v)) - 1) );
 #define PRIVATE_LOW_BITS_TEST(v)  do { PRIVATE_LOW_BITS_SLOW_TEST(v); \
  PRIVATE_LOW_BITS_FAST_TEST(v); } while (false)

test/static_log2_test.cpp

@@ -20,7 +20,7 @@
 
 
 // Macros to compact code
-#define PRIVATE_LB_TEST( v, e )  BOOST_TEST( ::boost::static_log2<v>::value == e )
+#define PRIVATE_LB_TEST( v, e )  BOOST_CHECK( ::boost::static_log2<v>::value == e )
 
 #define PRIVATE_PRINT_LB( v )    ::std::cout << "boost::static_log2<" << (v) \
  << "> = " << ::boost::static_log2< (v) >::value << '.' << ::std::endl

test/static_min_max_test.cpp

@@ -11,7 +11,7 @@
 //  23 Sep 2001  Initial version (Daryle Walker)
 
 #define  BOOST_INCLUDE_MAIN
-#include <boost/test/test_tools.hpp>  // for main, BOOST_TEST
+#include <boost/test/test_tools.hpp>  // for main, BOOST_CHECK
 
 #include <boost/cstdlib.hpp>                 // for boost::exit_success
 #include <boost/integer/static_min_max.hpp>  // for boost::static_signed_min, etc.
@@ -37,57 +37,57 @@ test_main
     // Two positives
     cout << "Doing tests with two positive values." << endl;
 
-    BOOST_TEST( (static_signed_min< 9, 14>::value) ==  9 );
-    BOOST_TEST( (static_signed_max< 9, 14>::value) == 14 );
-    BOOST_TEST( (static_signed_min<14,  9>::value) ==  9 );
-    BOOST_TEST( (static_signed_max<14,  9>::value) == 14 );
+    BOOST_CHECK( (static_signed_min< 9, 14>::value) ==  9 );
+    BOOST_CHECK( (static_signed_max< 9, 14>::value) == 14 );
+    BOOST_CHECK( (static_signed_min<14,  9>::value) ==  9 );
+    BOOST_CHECK( (static_signed_max<14,  9>::value) == 14 );
 
-    BOOST_TEST( (static_unsigned_min< 9, 14>::value) ==  9 );
-    BOOST_TEST( (static_unsigned_max< 9, 14>::value) == 14 );
-    BOOST_TEST( (static_unsigned_min<14,  9>::value) ==  9 );
-    BOOST_TEST( (static_unsigned_max<14,  9>::value) == 14 );
+    BOOST_CHECK( (static_unsigned_min< 9, 14>::value) ==  9 );
+    BOOST_CHECK( (static_unsigned_max< 9, 14>::value) == 14 );
+    BOOST_CHECK( (static_unsigned_min<14,  9>::value) ==  9 );
+    BOOST_CHECK( (static_unsigned_max<14,  9>::value) == 14 );
 
     // Two negatives
     cout << "Doing tests with two negative values." << endl;
 
-    BOOST_TEST( (static_signed_min<  -8, -101>::value) == -101 );
-    BOOST_TEST( (static_signed_max<  -8, -101>::value) ==   -8 );
-    BOOST_TEST( (static_signed_min<-101,   -8>::value) == -101 );
-    BOOST_TEST( (static_signed_max<-101,   -8>::value) ==   -8 );
+    BOOST_CHECK( (static_signed_min<  -8, -101>::value) == -101 );
+    BOOST_CHECK( (static_signed_max<  -8, -101>::value) ==   -8 );
+    BOOST_CHECK( (static_signed_min<-101,   -8>::value) == -101 );
+    BOOST_CHECK( (static_signed_max<-101,   -8>::value) ==   -8 );
 
     // With zero
     cout << "Doing tests with zero and a positive or negative value." << endl;
 
-    BOOST_TEST( (static_signed_min< 0, 14>::value) ==  0 );
-    BOOST_TEST( (static_signed_max< 0, 14>::value) == 14 );
-    BOOST_TEST( (static_signed_min<14,  0>::value) ==  0 );
-    BOOST_TEST( (static_signed_max<14,  0>::value) == 14 );
+    BOOST_CHECK( (static_signed_min< 0, 14>::value) ==  0 );
+    BOOST_CHECK( (static_signed_max< 0, 14>::value) == 14 );
+    BOOST_CHECK( (static_signed_min<14,  0>::value) ==  0 );
+    BOOST_CHECK( (static_signed_max<14,  0>::value) == 14 );
 
-    BOOST_TEST( (static_unsigned_min< 0, 14>::value) ==  0 );
-    BOOST_TEST( (static_unsigned_max< 0, 14>::value) == 14 );
-    BOOST_TEST( (static_unsigned_min<14,  0>::value) ==  0 );
-    BOOST_TEST( (static_unsigned_max<14,  0>::value) == 14 );
+    BOOST_CHECK( (static_unsigned_min< 0, 14>::value) ==  0 );
+    BOOST_CHECK( (static_unsigned_max< 0, 14>::value) == 14 );
+    BOOST_CHECK( (static_unsigned_min<14,  0>::value) ==  0 );
+    BOOST_CHECK( (static_unsigned_max<14,  0>::value) == 14 );
 
-    BOOST_TEST( (static_signed_min<   0, -101>::value) == -101 );
-    BOOST_TEST( (static_signed_max<   0, -101>::value) ==    0 );
-    BOOST_TEST( (static_signed_min<-101,    0>::value) == -101 );
-    BOOST_TEST( (static_signed_max<-101,    0>::value) ==    0 );
+    BOOST_CHECK( (static_signed_min<   0, -101>::value) == -101 );
+    BOOST_CHECK( (static_signed_max<   0, -101>::value) ==    0 );
+    BOOST_CHECK( (static_signed_min<-101,    0>::value) == -101 );
+    BOOST_CHECK( (static_signed_max<-101,    0>::value) ==    0 );
 
     // With identical
     cout << "Doing tests with two identical values." << endl;
 
-    BOOST_TEST( (static_signed_min<0, 0>::value) == 0 );
-    BOOST_TEST( (static_signed_max<0, 0>::value) == 0 );
-    BOOST_TEST( (static_unsigned_min<0, 0>::value) == 0 );
-    BOOST_TEST( (static_unsigned_max<0, 0>::value) == 0 );
+    BOOST_CHECK( (static_signed_min<0, 0>::value) == 0 );
+    BOOST_CHECK( (static_signed_max<0, 0>::value) == 0 );
+    BOOST_CHECK( (static_unsigned_min<0, 0>::value) == 0 );
+    BOOST_CHECK( (static_unsigned_max<0, 0>::value) == 0 );
 
-    BOOST_TEST( (static_signed_min<14, 14>::value) == 14 );
-    BOOST_TEST( (static_signed_max<14, 14>::value) == 14 );
-    BOOST_TEST( (static_unsigned_min<14, 14>::value) == 14 );
-    BOOST_TEST( (static_unsigned_max<14, 14>::value) == 14 );
+    BOOST_CHECK( (static_signed_min<14, 14>::value) == 14 );
+    BOOST_CHECK( (static_signed_max<14, 14>::value) == 14 );
+    BOOST_CHECK( (static_unsigned_min<14, 14>::value) == 14 );
+    BOOST_CHECK( (static_unsigned_max<14, 14>::value) == 14 );
 
-    BOOST_TEST( (static_signed_min< -101, -101>::value) == -101 );
-    BOOST_TEST( (static_signed_max< -101, -101>::value) == -101 );
+    BOOST_CHECK( (static_signed_min< -101, -101>::value) == -101 );
+    BOOST_CHECK( (static_signed_max< -101, -101>::value) == -101 );
 
     return boost::exit_success;
 }