From cd98c4a2570604f35fdab1ed438309bbc1006f02 Mon Sep 17 00:00:00 2001 From: Steven Watanabe Date: Thu, 10 Jun 2010 19:49:34 +0000 Subject: [PATCH] Add a 64 bit specialization of low_bits_mask_t. Fixes #4332 [SVN r62756] --- include/boost/integer/integer_mask.hpp | 24 +++++++ include/boost/integer_fwd.hpp | 16 ----- test/integer_mask_test.cpp | 92 ++++++++++++++++++++++++-- 3 files changed, 110 insertions(+), 22 deletions(-) diff --git a/include/boost/integer/integer_mask.hpp b/include/boost/integer/integer_mask.hpp index 8c4e1bb..2acf7f7 100644 --- a/include/boost/integer/integer_mask.hpp +++ b/include/boost/integer/integer_mask.hpp @@ -20,6 +20,17 @@ #include // 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 { @@ -89,6 +100,19 @@ 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 diff --git a/include/boost/integer_fwd.hpp b/include/boost/integer_fwd.hpp index e6045ca..20eff2b 100644 --- a/include/boost/integer_fwd.hpp +++ b/include/boost/integer_fwd.hpp @@ -136,22 +136,6 @@ template < std::size_t Bits > template < > struct low_bits_mask_t< ::std::numeric_limits::digits >; -#if USHRT_MAX > UCHAR_MAX -template < > - struct low_bits_mask_t< ::std::numeric_limits::digits >; -#endif - -#if UINT_MAX > USHRT_MAX -template < > - struct low_bits_mask_t< ::std::numeric_limits::digits >; -#endif - -#if ULONG_MAX > UINT_MAX -template < > - struct low_bits_mask_t< ::std::numeric_limits::digits >; -#endif - - // From ------------------------------------// template diff --git a/test/integer_mask_test.cpp b/test/integer_mask_test.cpp index 4c1bb4b..a66ab8d 100644 --- a/test/integer_mask_test.cpp +++ b/test/integer_mask_test.cpp @@ -21,25 +21,35 @@ #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(1)) + #define PRIVATE_HIGH_BIT_SLOW_TEST(v) BOOST_TEST( ::boost::high_bit_mask_t< \ - (v) >::high_bit == (1ul << (v)) ); + (v) >::high_bit == (ONE << (v)) ); #define PRIVATE_HIGH_BIT_FAST_TEST(v) BOOST_TEST( ::boost::high_bit_mask_t< \ - (v) >::high_bit_fast == (1ul << (v)) ); + (v) >::high_bit_fast == (ONE << (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{ \ - unsigned long mask = 0;\ + MASK_TYPE mask = 0;\ if(v > 0)\ - { mask = ((1ul << (v-1)) - 1); mask <<= 1; mask |= 1; }\ + { mask = ((ONE << (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{ \ - unsigned long mask = 0;\ + MASK_TYPE mask = 0;\ if(v > 0)\ - { mask = ((1ul << (v-1)) - 1); mask <<= 1; mask |= 1; }\ + { mask = ((ONE << (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); \ @@ -52,6 +62,41 @@ 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 ); @@ -86,6 +131,41 @@ 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 );