This commit was manufactured by cvs2svn to create tag

'Version_1_26_0'.

[SVN r11842]

cstdint.htm

@@ -69,7 +69,7 @@ representing any value of any signed integer type.</p>
 capable of representing any value of any unsigned integer type.</p>
 <p>These types are required.</p>
 <hr>
-<p>Revised <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %b %Y" startspan -->14 Nov 2000<!--webbot bot="Timestamp" endspan i-checksum="15241" -->
+<p>Revised <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %b %Y" startspan -->19 Aug 2001<!--webbot bot="Timestamp" endspan i-checksum="14767" -->
 </p>
 <p>&nbsp;</p>
 

cstdint_test.cpp

@@ -9,21 +9,12 @@
 //  See http://www.boost.org for most recent version including documentation.
 
 //  Revision History
+//   11 Sep 01  Adapted to work with macros defined in native stdint.h (John Maddock)
 //   12 Nov 00  Adapted to merged <boost/cstdint.hpp>
 //   23 Sep 00  Added INTXX_C constant macro support + int64_t support (John Maddock).
 //   28 Jun 00  Initial version
 #include <cassert>
 #include <iostream>
-#include <boost/cstdint.hpp>
-//
-// macros should not be defined by default:
-//
-#ifdef INT8_C
-#error header incorrectly implemented
-#endif
-//
-// now define the macros:
-//
 #define __STDC_CONSTANT_MACROS
 #include <boost/cstdint.hpp>
 
@@ -108,10 +99,17 @@ void integral_constant_type_check(T1, T2)
    // numeric_limits implementations currently
    // vary too much, or are incomplete or missing.
    //
-   assert(sizeof(T1) == sizeof(T2));
    T1 t1 = -1;
    T2 t2 = -1;
+#if defined(BOOST_HAS_STDINT_H)
+   // if we have a native stdint.h
+   // then the INTXX_C macros may define
+   // a type that's wider than required:
+   assert(sizeof(T1) <= sizeof(T2));
+#else
+   assert(sizeof(T1) == sizeof(T2));
    assert(t1 == t2);
+#endif
    if(t1 >= 0)
      assert(t2 >= 0);
    else
@@ -216,12 +214,4 @@ int main()
   return 0;
 }
 
-//
-// now verify that constant macros get undef'ed correctly:
-//
-#undef __STDC_CONSTANT_MACROS
-#include <boost/cstdint.hpp>
 
-#ifdef INT8_C
-#error boost/cstdint.hpp not correctly defined
-#endif

include/boost/cstdint.hpp

@@ -9,6 +9,9 @@
 //  See http://www.boost.org for most recent version including 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)
@@ -22,9 +25,19 @@
 #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 
+# else
+#   include <stdint.h>
+# endif
 
 namespace boost
 {
@@ -67,7 +80,7 @@ namespace boost
 } // namespace boost
 
 
-#else  // BOOST_SYSTEM_HAS_STDINT_H
+#else  // BOOST_HAS_STDINT_H
 
 
 # include <limits.h> // implementation artifact; not part of interface
@@ -112,30 +125,38 @@ 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 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;
 # else
 #    error defaults not correct; you must hand modify boost/cstdint.hpp
 # endif
 
 //  64-bit types + intmax_t and uintmax_t  ----------------------------------//
 
-# if (defined(ULLONG_MAX) || defined(ULONG_LONG_MAX)) && !(defined(_WIN32) && defined(__GNUC__))
-#    if(defined(ULLONG_MAX) && ULLONG_MAX == 18446744073709551615) ||  \
-        (defined(ULONG_LONG_MAX) && ULONG_LONG_MAX == 18446744073709551615)
+# 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 +165,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
@@ -182,7 +201,7 @@ namespace boost
 } // namespace boost
 
 
-#endif // BOOST_SYSTEM_HAS_STDINT_H
+#endif // BOOST_HAS_STDINT_H
 
 #endif // BOOST_CSTDINT_HPP
 
@@ -197,11 +216,13 @@ __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))
 //
@@ -252,14 +273,20 @@ Added 23rd September (John Maddock).
 
 //  64-bit types + intmax_t and uintmax_t  ----------------------------------//
 
-#  if (defined(ULLONG_MAX) || defined(ULONG_LONG_MAX)) && !(defined(_WIN32) && defined(__GNUC__))
-#    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 +308,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:
 //
@@ -297,3 +324,5 @@ Added 23rd September (John Maddock).
 # undef UINTMAX_C
 
 #endif // __STDC_CONSTANT_MACROS_DEFINED etc.
+
+

include/boost/integer.hpp

@@ -9,13 +9,14 @@
 //  See http://www.boost.org for most recent version including documentation.
 
 //  Revision History
-//   30 Jul 00  Add typename syntax fix (Jens Maurer) 
+//   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 <limits>
+#include <boost/limits.hpp>
 
 namespace boost
 {
@@ -23,6 +24,7 @@ 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
 
@@ -31,6 +33,7 @@ namespace boost
 
   //  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; };
@@ -53,7 +56,7 @@ namespace boost
           (Bits-1 <= std::numeric_limits<short>::digits) +
           (Bits-1 <= std::numeric_limits<signed char>::digits)
         >::least  least;
-      typedef int_fast_t<least>::fast  fast;
+      typedef typename int_fast_t<least>::fast  fast;
   };
 
   //  unsigned
@@ -68,7 +71,8 @@ namespace boost
           (Bits <= std::numeric_limits<unsigned short>::digits) +
           (Bits <= std::numeric_limits<unsigned char>::digits)
         >::least  least;
-      typedef int_fast_t<least>::fast  fast;
+      typedef typename int_fast_t<least>::fast  fast;
+      // int_fast_t<> works correctly for unsigned too, in spite of the name.
   };
 
 //  The same dispatching technique can be used to select types based on

include/boost/integer_traits.hpp

@@ -2,7 +2,7 @@
  *
  * Copyright Jens Maurer 2000
  * Permission to use, copy, modify, sell, and distribute this software
- * is hereby granted without free provided that the above copyright notice
+ * 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,
  *
@@ -18,11 +18,14 @@
 #ifndef BOOST_INTEGER_TRAITS_HPP
 #define BOOST_INTEGER_TRAITS_HPP
 
-#include <limits>
 #include <boost/config.hpp>
+#include <boost/limits.hpp>
 
-// This is an implementation detail and not part of the interface
+// 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 {
@@ -30,11 +33,7 @@ template<class T>
 class integer_traits : public std::numeric_limits<T>
 {
 public:
-#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
-  static const bool is_integral = false;
-#else
-  enum { is_integral = false };
-#endif
+  BOOST_STATIC_CONSTANT(bool, is_integral = false);
 };
 
 namespace detail {
@@ -42,18 +41,23 @@ template<class T, T min_val, T max_val>
 class integer_traits_base
 {
 public:
-#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
-  static const bool is_integral = true;
-  static const T const_min = min_val;
-  static const T const_max = max_val;
-#else
-  enum {
-    is_integral = true,
-    const_min = min_val,
-    const_max = max_val
-  };
-#endif
+  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<>
@@ -80,7 +84,31 @@ class integer_traits<unsigned char>
     public detail::integer_traits_base<unsigned char, 0, UCHAR_MAX>
 { };
 
-// What about wchar_t ?
+#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(__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
+    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>
@@ -118,7 +146,7 @@ class integer_traits<unsigned long>
     public detail::integer_traits_base<unsigned long, 0, ULONG_MAX>
 { };
 
-#ifdef ULLONG_MAX
+#if defined(ULLONG_MAX) && !defined(__SUNPRO_CC)
 template<>
 class integer_traits<long long>
   : public std::numeric_limits<long long>,
@@ -140,8 +168,20 @@ 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_MSVC) && !defined(__BORLANDC__)
+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>
+{ };
 #endif
 
 } // namespace boost
 
 #endif /* BOOST_INTEGER_TRAITS_HPP */
+

include/boost/stdint.h

@@ -1,272 +0,0 @@
-//  boost stdint.h header file  ---------------------------------------------//
-
-//  (C) Copyright boost.org 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 for most recent version including documentation.
-
-//  NOTE WELL: This is an implementation of the ISO C Standard (1999) stdint.h
-//  header.  C++ programs are advised to use <boost/cstdint.hpp> rather than
-//  this header.
-
-//  NOTE OF OBSOLESCENCE: In general, this header file cannot detect
-//  whether the current translation unit somewhere includes ISO C99
-//  <stdint.h> or not.  For example, in case BOOST_SYSTEM_HAS_STDINT_H
-//  is not defined and ISO C99 <stdint.h> has been included before,
-//  this file will re-define ISO C99 reserved file-scope identifiers
-//  such as int8_t (see ISO C99 7.1.3 and 7.18).  Defining the macro
-//  BOOST_SYSTEM_HAS_STDINT_H is not sufficient in general, in
-//  particular if a partly conformant <stdint.h> header is available
-//  on the platform, e.g. Comeau C++ with GNU glibc 2.1.2.
-//
-//  In order to avoid incompatibilities with ISO C99, this header
-//  should not be used at all, and it may be deleted in the future.
-//  C++ programs which require ISO C99 <stdint.h> functionality are
-//  strongly advised to use <boost/cstdint.hpp> instead, which
-//  provides <stdint.h> names in namespace boost, e.g. boost::int8_t.
-
-
-//  Revision History
-//   12 Nov 00  obsoleted (Jens Maurer)
-//   23 Sep 00  INTXX_C support added (John Maddock)
-//   22 Sep 00  64-bit support for Borland & Microsoft compilers (John Maddock)
-//    8 Aug 99  Initial version (Beman Dawes)
-
-#ifndef BOOST_STDINT_H
-#define BOOST_STDINT_H
-
-#include <boost/config.hpp>
-
-#ifdef BOOST_SYSTEM_HAS_STDINT_H
-#include <stdint.h>
-
-#else
-
-#include <limits.h> // implementation artifact; not part of interface
-
-//  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/stdint.h
-# endif
-
-//  16-bit types  ------------------------------------------------------------//
-
-# if USHRT_MAX == 0xffff
-     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;
-# else
-#    error defaults not correct; you must hand modify boost/stdint.h
-# endif
-
-//  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 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;
-# else
-#    error defaults not correct; you must hand modify boost/stdint.h
-# endif
-
-//  64-bit types + intmax_t and uintmax_t  -----------------------------------//
-
-# if (defined(ULLONG_MAX) || defined(ULONG_LONG_MAX)) && !(defined(_WIN32) && defined(__GNUC__))
-#    if(defined(ULLONG_MAX) && ULLONG_MAX == 18446744073709551615) ||  \
-        (defined(ULONG_LONG_MAX) && ULONG_LONG_MAX == 18446744073709551615)
-                                                                 // 2**64 - 1
-     typedef long long            intmax_t;
-     typedef unsigned long long   uintmax_t;
-     typedef long long            int64_t;
-     typedef long long            int_least64_t;
-     typedef long long            int_fast64_t;
-     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/stdint.h
-#    endif
-# 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/stdint.h
-#    endif
-# elif (defined(BOOST_MSVC) && (BOOST_MSVC >= 1100)) || (defined(__BORLANDC__) && (__BORLANDC__ >= 0x520))
-     //
-     // we have Borland/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
-
-#endif  // BOOST_SYSTEM_HAS_STDINT_H not defined
-#endif  // BOOST_STDINT_H
-
-/****************************************************
-
-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 (John Maddock).
-
-******************************************************/
-
-#if defined(__STDC_CONSTANT_MACROS) && !defined(BOOST__STDC_CONSTANT_MACROS_DEFINED)
-#define BOOST__STDC_CONSTANT_MACROS_DEFINED
-#if (defined(BOOST_MSVC) && (BOOST_MSVC >= 1100)) || (defined(__BORLANDC__) && (__BORLANDC__ >= 0x520))
-//
-// Borland/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<int8_t>(value)
-#define UINT8_C(value) static_cast<uint8_t>(value##u)
-# endif
-
-//  16-bit types  ------------------------------------------------------------//
-
-# if USHRT_MAX == 0xffff
-#define INT16_C(value) static_cast<int16_t>(value)
-#define UINT16_C(value) static_cast<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(ULLONG_MAX) || defined(ULONG_LONG_MAX)) && !(defined(_WIN32) && defined(__GNUC__))
-#    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
-#    else
-#       error defaults not correct; you must hand modify boost/stdint.h
-#    endif
-# 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/stdint.h
-#    endif
-# elif (defined(BOOST_MSVC) && (BOOST_MSVC >= 1100)) || (defined(__BORLANDC__) && (__BORLANDC__ >= 0x520))
-     //
-     // we have Borland/Microsoft __int64:
-     //
-#define INT64_C(value) value##i64
-#define UINT64_C(value) value##ui64
-# 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/MS specific
-
-#elif defined(BOOST__STDC_CONSTANT_MACROS_DEFINED) && !defined(__STDC_CONSTANT_MACROS)
-//
-// 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 // constant macros
-
-

index.htm

@@ -90,7 +90,7 @@ instead.
 
 <hr>
 
-<p>Revised: <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %b %Y" startspan -->14 Nov 2000<!--webbot bot="Timestamp" endspan i-checksum="15241" -->
+<p>Revised: <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %b %Y" startspan -->19 Aug 2001<!--webbot bot="Timestamp" endspan i-checksum="14767" -->
 </p>
 
 </body>

integer.htm

@@ -34,6 +34,7 @@ appropriate to use the types supplied in <code><a href="../../boost/cstdint.hpp"
 <pre>namespace boost
 {
   //  fast integers from least integers
+  // int_fast_t&lt;&gt; works correctly for unsigned too, in spite of the name.
   template&lt; typename LeastInt &gt;  // Required: LeastInt is integral type, not bool
   struct int_fast_t { typedef LeastInt fast; }; // implementations may specialize
 
@@ -51,6 +52,7 @@ appropriate to use the types supplied in <code><a href="../../boost/cstdint.hpp"
   {
       typedef <i>implementation-supplied</i>  least;
       typedef int_fast_t&lt;least&gt;::fast  fast;
+      // int_fast_t&lt;&gt; works correctly for unsigned too, in spite of the name.
   };
 } // namespace boost
 </pre>

integer_test.cpp

@@ -9,15 +9,14 @@
 //  See http://www.boost.org for most recent version including documentation.
 
 //  Revision History
+//   10 Mar 01  Boost Test Library now used for tests (Beman Dawes)
 //   31 Aug 99  Initial version
 
-//  This program is misnamed in that it is really a demonstration rather than
-//  a test.  It doesn't detect failure, so isn't worthy of the name "test".
-
 #include <iostream>
 #include <boost/integer.hpp>
 
-using namespace boost;  // not the best practice, but useful for testing
+#define BOOST_INCLUDE_MAIN
+#include <boost/test/test_tools.hpp>
 
 namespace
 {
@@ -37,8 +36,16 @@ namespace boost
     template<> struct int_fast_t<short> { typedef long fast; };
 }
 
-int main()
+int test_main(int,char**)
 {
+#ifndef BOOST_NO_USING_TEMPLATE
+     using boost::int_t;
+     using boost::uint_t;
+#else
+     using namespace boost;
+#endif
+
+#ifdef BOOST_SHOW_TYPES
      std::cout << 32 << ' '; test( int_t<32>::least() ); 
      std::cout << 31 << ' '; test( int_t<31>::least() ); 
      std::cout << 30 << ' '; test( int_t<30>::least() ); 
@@ -170,7 +177,145 @@ int main()
      std::cout << 3 << ' '; test( uint_t<3>::fast() ); 
      std::cout << 2 << ' '; test( uint_t<2>::fast() ); 
      std::cout << 1 << ' '; test( uint_t<1>::fast() ); 
-     std::cout << 0 << ' '; test( uint_t<0>::fast() ); 
-
+     std::cout << 0 << ' '; test( uint_t<0>::fast() );
+#endif
+     
+    long v = 0x7FFFFFFF;
+    BOOST_TEST( int_t<32>::least(v) == v );    v >>= 1;
+    BOOST_TEST( int_t<31>::least(v) == v );    v >>= 1;
+    BOOST_TEST( int_t<30>::least(v) == v );    v >>= 1;
+    BOOST_TEST( int_t<29>::least(v) == v );    v >>= 1;
+    BOOST_TEST( int_t<28>::least(v) == v );    v >>= 1;
+    BOOST_TEST( int_t<27>::least(v) == v );    v >>= 1;
+    BOOST_TEST( int_t<26>::least(v) == v );    v >>= 1;
+    BOOST_TEST( int_t<25>::least(v) == v );    v >>= 1;
+    BOOST_TEST( int_t<24>::least(v) == v );    v >>= 1;
+    BOOST_TEST( int_t<23>::least(v) == v );    v >>= 1;
+    BOOST_TEST( int_t<22>::least(v) == v );    v >>= 1;
+    BOOST_TEST( int_t<21>::least(v) == v );    v >>= 1;
+    BOOST_TEST( int_t<20>::least(v) == v );    v >>= 1;
+    BOOST_TEST( int_t<19>::least(v) == v );    v >>= 1;
+    BOOST_TEST( int_t<18>::least(v) == v );    v >>= 1;
+    BOOST_TEST( int_t<17>::least(v) == v );    v >>= 1;
+    BOOST_TEST( int_t<16>::least(v) == v );    v >>= 1;
+    BOOST_TEST( int_t<15>::least(v) == v );    v >>= 1;
+    BOOST_TEST( int_t<14>::least(v) == v );    v >>= 1;
+    BOOST_TEST( int_t<13>::least(v) == v );    v >>= 1;
+    BOOST_TEST( int_t<12>::least(v) == v );    v >>= 1;
+    BOOST_TEST( int_t<11>::least(v) == v );    v >>= 1;
+    BOOST_TEST( int_t<10>::least(v) == v );    v >>= 1;
+    BOOST_TEST( int_t<9>::least(v) == v );     v >>= 1;
+    BOOST_TEST( int_t<8>::least(v) == v );     v >>= 1;
+    BOOST_TEST( int_t<7>::least(v) == v );     v >>= 1;
+    BOOST_TEST( int_t<6>::least(v) == v );     v >>= 1;
+    BOOST_TEST( int_t<5>::least(v) == v );     v >>= 1;
+    BOOST_TEST( int_t<4>::least(v) == v );     v >>= 1;
+    BOOST_TEST( int_t<3>::least(v) == v );     v >>= 1;
+    BOOST_TEST( int_t<2>::least(v) == v );     v >>= 1;
+    BOOST_TEST( int_t<1>::least(v) == v );     v >>= 1;
+    BOOST_TEST( int_t<0>::least(v) == v );
+    v = 0x7FFFFFFF;
+    BOOST_TEST( int_t<32>::fast(v) == v );    v >>= 1;
+    BOOST_TEST( int_t<31>::fast(v) == v );    v >>= 1;
+    BOOST_TEST( int_t<30>::fast(v) == v );    v >>= 1;
+    BOOST_TEST( int_t<29>::fast(v) == v );    v >>= 1;
+    BOOST_TEST( int_t<28>::fast(v) == v );    v >>= 1;
+    BOOST_TEST( int_t<27>::fast(v) == v );    v >>= 1;
+    BOOST_TEST( int_t<26>::fast(v) == v );    v >>= 1;
+    BOOST_TEST( int_t<25>::fast(v) == v );    v >>= 1;
+    BOOST_TEST( int_t<24>::fast(v) == v );    v >>= 1;
+    BOOST_TEST( int_t<23>::fast(v) == v );    v >>= 1;
+    BOOST_TEST( int_t<22>::fast(v) == v );    v >>= 1;
+    BOOST_TEST( int_t<21>::fast(v) == v );    v >>= 1;
+    BOOST_TEST( int_t<20>::fast(v) == v );    v >>= 1;
+    BOOST_TEST( int_t<19>::fast(v) == v );    v >>= 1;
+    BOOST_TEST( int_t<18>::fast(v) == v );    v >>= 1;
+    BOOST_TEST( int_t<17>::fast(v) == v );    v >>= 1;
+    BOOST_TEST( int_t<16>::fast(v) == v );    v >>= 1;
+    BOOST_TEST( int_t<15>::fast(v) == v );    v >>= 1;
+    BOOST_TEST( int_t<14>::fast(v) == v );    v >>= 1;
+    BOOST_TEST( int_t<13>::fast(v) == v );    v >>= 1;
+    BOOST_TEST( int_t<12>::fast(v) == v );    v >>= 1;
+    BOOST_TEST( int_t<11>::fast(v) == v );    v >>= 1;
+    BOOST_TEST( int_t<10>::fast(v) == v );    v >>= 1;
+    BOOST_TEST( int_t<9>::fast(v) == v );     v >>= 1;
+    BOOST_TEST( int_t<8>::fast(v) == v );     v >>= 1;
+    BOOST_TEST( int_t<7>::fast(v) == v );     v >>= 1;
+    BOOST_TEST( int_t<6>::fast(v) == v );     v >>= 1;
+    BOOST_TEST( int_t<5>::fast(v) == v );     v >>= 1;
+    BOOST_TEST( int_t<4>::fast(v) == v );     v >>= 1;
+    BOOST_TEST( int_t<3>::fast(v) == v );     v >>= 1;
+    BOOST_TEST( int_t<2>::fast(v) == v );     v >>= 1;
+    BOOST_TEST( int_t<1>::fast(v) == v );     v >>= 1;
+    BOOST_TEST( int_t<0>::fast(v) == v );
+    unsigned long u = 0xFFFFFFFF;
+    BOOST_TEST( uint_t<32>::least(u) == u );    u >>= 1;
+    BOOST_TEST( uint_t<31>::least(u) == u );    u >>= 1;
+    BOOST_TEST( uint_t<30>::least(u) == u );    u >>= 1;
+    BOOST_TEST( uint_t<29>::least(u) == u );    u >>= 1;
+    BOOST_TEST( uint_t<28>::least(u) == u );    u >>= 1;
+    BOOST_TEST( uint_t<27>::least(u) == u );    u >>= 1;
+    BOOST_TEST( uint_t<26>::least(u) == u );    u >>= 1;
+    BOOST_TEST( uint_t<25>::least(u) == u );    u >>= 1;
+    BOOST_TEST( uint_t<24>::least(u) == u );    u >>= 1;
+    BOOST_TEST( uint_t<23>::least(u) == u );    u >>= 1;
+    BOOST_TEST( uint_t<22>::least(u) == u );    u >>= 1;
+    BOOST_TEST( uint_t<21>::least(u) == u );    u >>= 1;
+    BOOST_TEST( uint_t<20>::least(u) == u );    u >>= 1;
+    BOOST_TEST( uint_t<19>::least(u) == u );    u >>= 1;
+    BOOST_TEST( uint_t<18>::least(u) == u );    u >>= 1;
+    BOOST_TEST( uint_t<17>::least(u) == u );    u >>= 1;
+    BOOST_TEST( uint_t<16>::least(u) == u );    u >>= 1;
+    BOOST_TEST( uint_t<15>::least(u) == u );    u >>= 1;
+    BOOST_TEST( uint_t<14>::least(u) == u );    u >>= 1;
+    BOOST_TEST( uint_t<13>::least(u) == u );    u >>= 1;
+    BOOST_TEST( uint_t<11>::least(u) == u );    u >>= 1;
+    BOOST_TEST( uint_t<12>::least(u) == u );    u >>= 1;
+    BOOST_TEST( uint_t<10>::least(u) == u );    u >>= 1;
+    BOOST_TEST( uint_t<9>::least(u) == u );     u >>= 1;
+    BOOST_TEST( uint_t<8>::least(u) == u );     u >>= 1;
+    BOOST_TEST( uint_t<7>::least(u) == u );     u >>= 1;
+    BOOST_TEST( uint_t<6>::least(u) == u );     u >>= 1;
+    BOOST_TEST( uint_t<5>::least(u) == u );     u >>= 1;
+    BOOST_TEST( uint_t<4>::least(u) == u );     u >>= 1;
+    BOOST_TEST( uint_t<3>::least(u) == u );     u >>= 1;
+    BOOST_TEST( uint_t<2>::least(u) == u );     u >>= 1;
+    BOOST_TEST( uint_t<1>::least(u) == u );     u >>= 1;
+    BOOST_TEST( uint_t<0>::least(u) == u );
+    u = 0xFFFFFFFF;
+    BOOST_TEST( uint_t<32>::fast(u) == u );    u >>= 1;
+    BOOST_TEST( uint_t<31>::fast(u) == u );    u >>= 1;
+    BOOST_TEST( uint_t<30>::fast(u) == u );    u >>= 1;
+    BOOST_TEST( uint_t<29>::fast(u) == u );    u >>= 1;
+    BOOST_TEST( uint_t<28>::fast(u) == u );    u >>= 1;
+    BOOST_TEST( uint_t<27>::fast(u) == u );    u >>= 1;
+    BOOST_TEST( uint_t<26>::fast(u) == u );    u >>= 1;
+    BOOST_TEST( uint_t<25>::fast(u) == u );    u >>= 1;
+    BOOST_TEST( uint_t<24>::fast(u) == u );    u >>= 1;
+    BOOST_TEST( uint_t<23>::fast(u) == u );    u >>= 1;
+    BOOST_TEST( uint_t<22>::fast(u) == u );    u >>= 1;
+    BOOST_TEST( uint_t<21>::fast(u) == u );    u >>= 1;
+    BOOST_TEST( uint_t<20>::fast(u) == u );    u >>= 1;
+    BOOST_TEST( uint_t<19>::fast(u) == u );    u >>= 1;
+    BOOST_TEST( uint_t<18>::fast(u) == u );    u >>= 1;
+    BOOST_TEST( uint_t<17>::fast(u) == u );    u >>= 1;
+    BOOST_TEST( uint_t<16>::fast(u) == u );    u >>= 1;
+    BOOST_TEST( uint_t<15>::fast(u) == u );    u >>= 1;
+    BOOST_TEST( uint_t<14>::fast(u) == u );    u >>= 1;
+    BOOST_TEST( uint_t<13>::fast(u) == u );    u >>= 1;
+    BOOST_TEST( uint_t<12>::fast(u) == u );    u >>= 1;
+    BOOST_TEST( uint_t<11>::fast(u) == u );    u >>= 1;
+    BOOST_TEST( uint_t<10>::fast(u) == u );    u >>= 1;
+    BOOST_TEST( uint_t<9>::fast(u) == u );     u >>= 1;
+    BOOST_TEST( uint_t<8>::fast(u) == u );     u >>= 1;
+    BOOST_TEST( uint_t<7>::fast(u) == u );     u >>= 1;
+    BOOST_TEST( uint_t<6>::fast(u) == u );     u >>= 1;
+    BOOST_TEST( uint_t<5>::fast(u) == u );     u >>= 1;
+    BOOST_TEST( uint_t<4>::fast(u) == u );     u >>= 1;
+    BOOST_TEST( uint_t<3>::fast(u) == u );     u >>= 1;
+    BOOST_TEST( uint_t<2>::fast(u) == u );     u >>= 1;
+    BOOST_TEST( uint_t<1>::fast(u) == u );     u >>= 1;
+    BOOST_TEST( uint_t<0>::fast(u) == u );
+        
     return 0;
 }

integer_traits_test.cpp

@@ -2,7 +2,7 @@
  *
  * Copyright Jens Maurer 2000
  * Permission to use, copy, modify, sell, and distribute this software
- * is hereby granted without free provided that the above copyright notice
+ * 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,
  *
@@ -18,15 +18,12 @@
  */
 
 #include <iostream>
-#include <cassert>
 #include <boost/integer_traits.hpp>
 // use int64_t instead of long long for better portability
 #include <boost/cstdint.hpp>
 
-#ifdef NDEBUG
-#error This test relies on assert() and thus makes no sense with NDEBUG defined
-#endif
-
+#define BOOST_INCLUDE_MAIN
+#include <boost/test/test_tools.hpp>
 
 /*
  * General portability note:
@@ -38,22 +35,27 @@
  * Therefore, avoid explicit function template instantiations.
  */
 
+template<typename T> inline T make_char_numeric_for_streaming(T x) { return x; }
+inline int make_char_numeric_for_streaming(char c) { return c; }
+inline int make_char_numeric_for_streaming(signed char c) { return c; }
+inline int make_char_numeric_for_streaming(unsigned char c) { return c; }
+
 template<class T>
 void runtest(const char * type, T)
 {
   typedef boost::integer_traits<T> traits;
   std::cout << "Checking " << type
-	    << "; min is " << traits::min()
-            << ", max is " << traits::max()
-	    << std::endl;
-  assert(traits::is_specialized);
-  assert(traits::is_integer);
-  assert(traits::is_integral);
-  assert(traits::const_min == traits::min());
-  assert(traits::const_max == traits::max());
+            << "; 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());
 }
 
-int main()
+int test_main(int, char*[])
 {
   runtest("bool", bool());
   runtest("char", char());
@@ -61,6 +63,7 @@ int main()
   runtest("signed char", signed_char());
   typedef unsigned char unsigned_char;
   runtest("unsigned char", unsigned_char());
+  runtest("wchar_t", wchar_t());
   runtest("short", short());
   typedef unsigned short unsigned_short;
   runtest("unsigned short", unsigned_short());
@@ -70,13 +73,17 @@ int main()
   runtest("long", long());
   typedef unsigned long unsigned_long;
   runtest("unsigned long", unsigned_long());
-#if !defined(BOOST_NO_INT64_T) && !defined(BOOST_MSVC) && !defined(__BORLANDC__)
+#if !defined(BOOST_NO_INT64_T) && !defined(BOOST_MSVC) && !defined(__BORLANDC__) && !defined(__BEOS__)
   //
   // MS/Borland compilers can't support 64-bit member constants
+  // BeOS doesn't have specialisations for long long in SGI's <limits> header.
   runtest("int64_t (possibly long long)", boost::int64_t());
   runtest("uint64_t (possibly unsigned long long)", boost::uint64_t());
+#else
+  std::cout << "Skipped int64_t and uint64_t" << std::endl;
 #endif
   // Some compilers don't pay attention to std:3.6.1/5 and issue a
   // warning here if "return 0;" is omitted.
   return 0;
 }
+