Release 1.44.0

[SVN r64846]

doc/Jamfile.v2

@@ -50,7 +50,6 @@ boostbook standalone
         <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/libs/regex/doc/html
     ;
 
-install pdfinstall : standalone/<format>pdf : <location>. <install-type>PDF ;
-explicit pdfinstall ;
+install pdf-install : standalone : <location>. <install-type>PDF ;
 
 

include/boost/cstdint.hpp

@@ -137,7 +137,7 @@ namespace boost
 
 } // namespace boost
 
-#elif defined(__FreeBSD__) && (__FreeBSD__ <= 4) || defined(__osf__) || defined(__VMS)
+#elif defined(__FreeBSD__) && (__FreeBSD__ <= 4) || defined(__osf__)
 // FreeBSD and Tru64 have an <inttypes.h> that contains much of what we need.
 # include <inttypes.h>
 
@@ -256,27 +256,20 @@ namespace boost
 
 //  32-bit types  -----------------------------------------------------------//
 
-# if 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;
-# elif (USHRT_MAX == 0xffffffff)
-     typedef short             int32_t;
-     typedef short             int_least32_t;
-     typedef short             int_fast32_t;
-     typedef unsigned short    uint32_t;
-     typedef unsigned short    uint_least32_t;
-     typedef unsigned short    uint_fast32_t;
-# elif ULONG_MAX == 0xffffffff
+# 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;
 # elif (UINT_MAX == 0xffffffffffffffff) && defined(__MTA__) 
       // Integers are 64 bits on the MTA / XMT 
       typedef __int32           int32_t; 

include/boost/integer.hpp

@@ -20,7 +20,6 @@
 #include <boost/integer_traits.hpp>  // for boost::::boost::integer_traits
 #include <boost/limits.hpp>          // for ::std::numeric_limits
 #include <boost/cstdint.hpp>         // for boost::int64_t and BOOST_NO_INTEGRAL_INT64_T
-#include <boost/static_assert.hpp>
 
 //
 // We simply cannot include this header on gcc without getting copious warnings of the kind:
@@ -52,7 +51,6 @@ namespace boost
 
   //  convert category to type 
   template< int Category > struct int_least_helper {}; // default is empty
-  template< int Category > struct uint_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 char
@@ -67,14 +65,14 @@ namespace boost
   template<> struct int_least_helper<4> { typedef short least; };
   template<> struct int_least_helper<5> { typedef signed char least; };
 #ifdef BOOST_HAS_LONG_LONG
-  template<> struct uint_least_helper<1> { typedef boost::ulong_long_type least; };
+  template<> struct int_least_helper<6> { typedef boost::ulong_long_type least; };
 #elif defined(BOOST_HAS_MS_INT64)
-  template<> struct uint_least_helper<1> { typedef unsigned __int64 least; };
+  template<> struct int_least_helper<6> { typedef unsigned __int64 least; };
 #endif
-  template<> struct uint_least_helper<2> { typedef unsigned long least; };
-  template<> struct uint_least_helper<3> { typedef unsigned int least; };
-  template<> struct uint_least_helper<4> { typedef unsigned short least; };
-  template<> struct uint_least_helper<5> { typedef unsigned char least; };
+  template<> struct int_least_helper<7> { typedef unsigned long least; };
+  template<> struct int_least_helper<8> { typedef unsigned int least; };
+  template<> struct int_least_helper<9> { typedef unsigned short least; };
+  template<> struct int_least_helper<10> { typedef unsigned char least; };
 
   template <int Bits>
   struct exact_signed_base_helper{};
@@ -113,12 +111,10 @@ namespace boost
   template< int Bits >   // bits (including sign) required
   struct int_t : public detail::exact_signed_base_helper<Bits>
   {
-      BOOST_STATIC_ASSERT_MSG(Bits <= (int)(sizeof(boost::intmax_t) * CHAR_BIT),
-         "No suitable signed integer type with the requested number of bits is available.");
       typedef typename detail::int_least_helper
         <
 #ifdef BOOST_HAS_LONG_LONG
-          (Bits <= (int)(sizeof(boost::long_long_type) * CHAR_BIT)) +
+          (Bits-1 <= (int)(sizeof(boost::long_long_type) * CHAR_BIT)) +
 #else
            1 +
 #endif
@@ -134,8 +130,6 @@ namespace boost
   template< int Bits >   // bits required
   struct uint_t : public detail::exact_unsigned_base_helper<Bits>
   {
-     BOOST_STATIC_ASSERT_MSG(Bits <= (int)(sizeof(boost::uintmax_t) * CHAR_BIT),
-         "No suitable unsigned integer type with the requested number of bits is available.");
 #if (defined(__BORLANDC__) || defined(__CODEGEAR__)) && defined(BOOST_NO_INTEGRAL_INT64_T)
      // It's really not clear why this workaround should be needed... shrug I guess!  JM
      BOOST_STATIC_CONSTANT(int, s = 
@@ -146,10 +140,11 @@ namespace boost
           (Bits <= ::std::numeric_limits<unsigned char>::digits));
      typedef typename detail::int_least_helper< ::boost::uint_t<Bits>::s>::least least;
 #else
-      typedef typename detail::uint_least_helper
+      typedef typename detail::int_least_helper
         < 
+          5 +
 #ifdef BOOST_HAS_LONG_LONG
-          (Bits <= (int)(sizeof(boost::long_long_type) * CHAR_BIT)) +
+          (Bits-1 <= (int)(sizeof(boost::long_long_type) * CHAR_BIT)) +
 #else
            1 +
 #endif
@@ -222,7 +217,7 @@ namespace boost
      // It's really not clear why this workaround should be needed... shrug I guess!  JM
 #if defined(BOOST_NO_INTEGRAL_INT64_T)
       BOOST_STATIC_CONSTANT(unsigned, which = 
-           1 +
+           6 +
           (MaxValue <= ::boost::integer_traits<unsigned long>::const_max) +
           (MaxValue <= ::boost::integer_traits<unsigned int>::const_max) +
           (MaxValue <= ::boost::integer_traits<unsigned short>::const_max) +
@@ -230,17 +225,18 @@ namespace boost
       typedef typename detail::int_least_helper< ::boost::uint_value_t<MaxValue>::which>::least least;
 #else // BOOST_NO_INTEGRAL_INT64_T
       BOOST_STATIC_CONSTANT(unsigned, which = 
-           1 +
+           5 +
           (MaxValue <= ::boost::integer_traits<boost::ulong_long_type>::const_max) +
           (MaxValue <= ::boost::integer_traits<unsigned long>::const_max) +
           (MaxValue <= ::boost::integer_traits<unsigned int>::const_max) +
           (MaxValue <= ::boost::integer_traits<unsigned short>::const_max) +
           (MaxValue <= ::boost::integer_traits<unsigned char>::const_max));
-      typedef typename detail::uint_least_helper< ::boost::uint_value_t<MaxValue>::which>::least least;
+      typedef typename detail::int_least_helper< ::boost::uint_value_t<MaxValue>::which>::least least;
 #endif // BOOST_NO_INTEGRAL_INT64_T
 #else
-      typedef typename detail::uint_least_helper
+      typedef typename detail::int_least_helper
         < 
+          5 +
 #if !defined(BOOST_NO_INTEGRAL_INT64_T) && defined(BOOST_HAS_LONG_LONG)
           (MaxValue <= ::boost::integer_traits<boost::ulong_long_type>::const_max) +
 #else

include/boost/integer/integer_mask.hpp

@@ -20,17 +20,6 @@
 
 #include <boost/limits.hpp>  // for std::numeric_limits
 
-//
-// We simply cannot include this header on gcc without getting copious warnings of the kind:
-//
-// boost/integer/integer_mask.hpp:93:35: warning: use of C99 long long integer constant
-//
-// And yet there is no other reasonable implementation, so we declare this a system header
-// to suppress these warnings.
-//
-#if defined(__GNUC__) && (__GNUC__ >= 4)
-#pragma GCC system_header
-#endif
 
 namespace boost
 {
@@ -100,19 +89,6 @@ BOOST_LOW_BITS_MASK_SPECIALIZE( unsigned int );
 BOOST_LOW_BITS_MASK_SPECIALIZE( unsigned long );
 #endif
 
-#if defined(BOOST_HAS_LONG_LONG)
-    #if ((defined(ULLONG_MAX) && (ULLONG_MAX > ULONG_MAX)) ||\
-        (defined(ULONG_LONG_MAX) && (ULONG_LONG_MAX > ULONG_MAX)) ||\
-        (defined(ULONGLONG_MAX) && (ULONGLONG_MAX > ULONG_MAX)) ||\
-        (defined(_ULLONG_MAX) && (_ULLONG_MAX > ULONG_MAX)))
-    BOOST_LOW_BITS_MASK_SPECIALIZE( boost::ulong_long_type );
-    #endif
-#elif defined(BOOST_HAS_MS_INT64)
-    #if 18446744073709551615ui64 > ULONG_MAX
-    BOOST_LOW_BITS_MASK_SPECIALIZE( unsigned __int64 );
-    #endif
-#endif
-
 #ifdef BOOST_MSVC
 #pragma warning(pop)
 #endif

include/boost/integer_fwd.hpp

@@ -136,6 +136,22 @@ template < std::size_t Bits >
 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 <static_log2_argument_type Value >

include/boost/integer_traits.hpp

@@ -227,7 +227,7 @@ class integer_traits< ::boost::ulong_long_type>
 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) * CHAR_BIT - 1)), ~(1LL << (sizeof(::boost::long_long_type) * CHAR_BIT - 1))>
+    public detail::integer_traits_base< ::boost::long_long_type, (1LL << (sizeof(::boost::long_long_type) - 1)), ~(1LL << (sizeof(::boost::long_long_type) - 1))>
 { };
 
 template<>

test/Jamfile.v2

@@ -22,10 +22,4 @@ test-suite integer
         [ compile static_log2_include_test.cpp ]
         [ compile static_min_max_include_test.cpp ]
         [ compile integer_fwd_include_test.cpp ]
-        [ compile-fail fail_int_exact.cpp ]
-        [ compile-fail fail_int_fast.cpp ]
-        [ compile-fail fail_int_least.cpp ]
-        [ compile-fail fail_uint_exact.cpp ]
-        [ compile-fail fail_uint_fast.cpp ]
-        [ compile-fail fail_uint_least.cpp ]
     ;

test/fail_int_exact.cpp

@@ -1,8 +0,0 @@
-//  Copyright John Maddock 2012.  
-//  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)
-
-#include <boost/integer.hpp>
-
-typedef boost::int_t<sizeof(boost::intmax_t)*CHAR_BIT + 1>::exact fail_int_exact;

test/fail_int_fast.cpp

@@ -1,8 +0,0 @@
-//  Copyright John Maddock 2012.  
-//  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)
-
-#include <boost/integer.hpp>
-
-typedef boost::int_t<sizeof(boost::intmax_t)*CHAR_BIT + 1>::fast fail_int_fast;

test/fail_int_least.cpp

@@ -1,8 +0,0 @@
-//  Copyright John Maddock 2012.  
-//  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)
-
-#include <boost/integer.hpp>
-
-typedef boost::int_t<sizeof(boost::intmax_t)*CHAR_BIT + 1>::least fail_int_least;

test/fail_uint_exact.cpp

@@ -1,8 +0,0 @@
-//  Copyright John Maddock 2012.  
-//  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)
-
-#include <boost/integer.hpp>
-
-typedef boost::uint_t<sizeof(boost::intmax_t)*CHAR_BIT + 1>::exact fail_uint_exact;

test/fail_uint_fast.cpp

@@ -1,8 +0,0 @@
-//  Copyright John Maddock 2012.  
-//  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)
-
-#include <boost/integer.hpp>
-
-typedef boost::uint_t<sizeof(boost::intmax_t)*CHAR_BIT + 1>::fast fail_uint_fast;

test/fail_uint_least.cpp

@@ -1,8 +0,0 @@
-//  Copyright John Maddock 2012.  
-//  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)
-
-#include <boost/integer.hpp>
-
-typedef boost::uint_t<sizeof(boost::intmax_t)*CHAR_BIT + 1>::least fail_uint_least;

test/integer_mask_test.cpp

@@ -21,35 +21,25 @@
 #pragma warning(disable:4127) // conditional expression is constant
 #endif
 
-#if defined(BOOST_HAS_LONG_LONG)
-#define MASK_TYPE ::boost::ulong_long_type
-#elif defined(BOOST_HAS_MS_INT64)
-#define MASK_TYPE unsigned __int64
-#else
-#define MASK_TYPE unsigned long
-#endif
-
-#define ONE (static_cast<MASK_TYPE>(1))
-
 #define PRIVATE_HIGH_BIT_SLOW_TEST(v)  BOOST_TEST( ::boost::high_bit_mask_t< \
- (v) >::high_bit == (ONE << (v)) );
+ (v) >::high_bit == (1ul << (v)) );
 #define PRIVATE_HIGH_BIT_FAST_TEST(v)  BOOST_TEST( ::boost::high_bit_mask_t< \
- (v) >::high_bit_fast == (ONE << (v)) );
+ (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)  \
    do{ \
-      MASK_TYPE mask = 0;\
+      unsigned long mask = 0;\
       if(v > 0)\
-         { mask = ((ONE << (v-1)) - 1); mask <<= 1; mask |= 1; }\
+         { mask = ((1ul << (v-1)) - 1); mask <<= 1; mask |= 1; }\
       BOOST_TEST( ::boost::low_bits_mask_t< (v) >::sig_bits ==  mask); \
    }while(false);
 #define PRIVATE_LOW_BITS_FAST_TEST(v)  \
    do{ \
-      MASK_TYPE mask = 0;\
+      unsigned long mask = 0;\
       if(v > 0)\
-         { mask = ((ONE << (v-1)) - 1); mask <<= 1; mask |= 1; }\
+         { mask = ((1ul << (v-1)) - 1); mask <<= 1; mask |= 1; }\
       BOOST_TEST( ::boost::low_bits_mask_t< (v) >::sig_bits_fast == mask);\
    }while(false);
 #define PRIVATE_LOW_BITS_TEST(v)  do { PRIVATE_LOW_BITS_SLOW_TEST(v); \
@@ -62,41 +52,6 @@ int main( int, char*[] )
     using std::endl;
 
     cout << "Doing high_bit_mask_t tests." << endl;
-
-#if defined(BOOST_HAS_LONG_LONG) || defined(BOOST_HAS_MS_INT64)
-    PRIVATE_HIGH_BIT_TEST( 63 );
-    PRIVATE_HIGH_BIT_TEST( 62 );
-    PRIVATE_HIGH_BIT_TEST( 61 );
-    PRIVATE_HIGH_BIT_TEST( 60 );
-    PRIVATE_HIGH_BIT_TEST( 59 );
-    PRIVATE_HIGH_BIT_TEST( 58 );
-    PRIVATE_HIGH_BIT_TEST( 57 );
-    PRIVATE_HIGH_BIT_TEST( 56 );
-    PRIVATE_HIGH_BIT_TEST( 55 );
-    PRIVATE_HIGH_BIT_TEST( 54 );
-    PRIVATE_HIGH_BIT_TEST( 53 );
-    PRIVATE_HIGH_BIT_TEST( 52 );
-    PRIVATE_HIGH_BIT_TEST( 51 );
-    PRIVATE_HIGH_BIT_TEST( 50 );
-    PRIVATE_HIGH_BIT_TEST( 49 );
-    PRIVATE_HIGH_BIT_TEST( 48 );
-    PRIVATE_HIGH_BIT_TEST( 47 );
-    PRIVATE_HIGH_BIT_TEST( 46 );
-    PRIVATE_HIGH_BIT_TEST( 45 );
-    PRIVATE_HIGH_BIT_TEST( 44 );
-    PRIVATE_HIGH_BIT_TEST( 43 );
-    PRIVATE_HIGH_BIT_TEST( 42 );
-    PRIVATE_HIGH_BIT_TEST( 41 );
-    PRIVATE_HIGH_BIT_TEST( 40 );
-    PRIVATE_HIGH_BIT_TEST( 39 );
-    PRIVATE_HIGH_BIT_TEST( 38 );
-    PRIVATE_HIGH_BIT_TEST( 37 );
-    PRIVATE_HIGH_BIT_TEST( 36 );
-    PRIVATE_HIGH_BIT_TEST( 35 );
-    PRIVATE_HIGH_BIT_TEST( 34 );
-    PRIVATE_HIGH_BIT_TEST( 33 );
-    PRIVATE_HIGH_BIT_TEST( 32 );
-#endif
     PRIVATE_HIGH_BIT_TEST( 31 );
     PRIVATE_HIGH_BIT_TEST( 30 );
     PRIVATE_HIGH_BIT_TEST( 29 );
@@ -131,41 +86,6 @@ int main( int, char*[] )
     PRIVATE_HIGH_BIT_TEST(  0 );
 
     cout << "Doing low_bits_mask_t tests." << endl;
-
-#if defined(BOOST_HAS_LONG_LONG) || defined(BOOST_HAS_MS_INT64)
-    PRIVATE_LOW_BITS_TEST( 64 );
-    PRIVATE_LOW_BITS_TEST( 63 );
-    PRIVATE_LOW_BITS_TEST( 62 );
-    PRIVATE_LOW_BITS_TEST( 61 );
-    PRIVATE_LOW_BITS_TEST( 60 );
-    PRIVATE_LOW_BITS_TEST( 59 );
-    PRIVATE_LOW_BITS_TEST( 58 );
-    PRIVATE_LOW_BITS_TEST( 57 );
-    PRIVATE_LOW_BITS_TEST( 56 );
-    PRIVATE_LOW_BITS_TEST( 55 );
-    PRIVATE_LOW_BITS_TEST( 54 );
-    PRIVATE_LOW_BITS_TEST( 53 );
-    PRIVATE_LOW_BITS_TEST( 52 );
-    PRIVATE_LOW_BITS_TEST( 51 );
-    PRIVATE_LOW_BITS_TEST( 50 );
-    PRIVATE_LOW_BITS_TEST( 49 );
-    PRIVATE_LOW_BITS_TEST( 48 );
-    PRIVATE_LOW_BITS_TEST( 47 );
-    PRIVATE_LOW_BITS_TEST( 46 );
-    PRIVATE_LOW_BITS_TEST( 45 );
-    PRIVATE_LOW_BITS_TEST( 44 );
-    PRIVATE_LOW_BITS_TEST( 43 );
-    PRIVATE_LOW_BITS_TEST( 42 );
-    PRIVATE_LOW_BITS_TEST( 41 );
-    PRIVATE_LOW_BITS_TEST( 40 );
-    PRIVATE_LOW_BITS_TEST( 39 );
-    PRIVATE_LOW_BITS_TEST( 38 );
-    PRIVATE_LOW_BITS_TEST( 37 );
-    PRIVATE_LOW_BITS_TEST( 36 );
-    PRIVATE_LOW_BITS_TEST( 35 );
-    PRIVATE_LOW_BITS_TEST( 34 );
-    PRIVATE_LOW_BITS_TEST( 33 );
-#endif
     PRIVATE_LOW_BITS_TEST( 32 );
     PRIVATE_LOW_BITS_TEST( 31 );
     PRIVATE_LOW_BITS_TEST( 30 );

test/integer_test.cpp

@@ -152,7 +152,7 @@ void do_test_bits()
    if(boost::detail::test_errors() != last_error_count)
    {
       last_error_count = boost::detail::test_errors();
-      std::cout << "Errors occurred while testing with bit count = " << Bits << std::endl;
+      std::cout << "Errors occured while testing with bit count = " << Bits << std::endl;
       std::cout << "Type int_t<" << Bits << ">::least was " << get_name_of_type(least_int(0)) << std::endl;
       std::cout << "Type int_t<" << Bits << ">::fast was " << get_name_of_type(fast_int(0)) << std::endl;
       std::cout << "Type uint_t<" << Bits << ">::least was " << get_name_of_type(least_uint(0)) << std::endl;