This commit was manufactured by cvs2svn to create tag

'Version_1_21_2'.

[SVN r9983]

include/boost/config.hpp

@@ -11,6 +11,19 @@
 //  http://www.boost.org/libs/config
 
 //  Revision History (excluding minor changes for specific compilers)
+//   16 Mar 01  Added BOOST_VERSION (Jens Maurer)
+//   06 Mar 01  Refactored EDG checks for Intel C++ (Dave Abrahams)
+//   04 Mar 01  Factored EDG checks, added BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
+//              for Intel C++ 5.0 (Dave Abrahams)
+//   17 Feb 01  BOOST_NO_CV_SPECIALIZATIONS
+//              BOOST_NO_CV_VOID_SPECIALIZATIONS (John Maddock)
+//   11 Feb 01  Added BOOST_STATIC_CONSTANT (Dave Abrahams)
+//   20 Jan 01  BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS moved here from
+//              cast.hpp. Added missing BOOST_NO_STRINGSTREAM which some
+//              boost code seemed to depend on. (Dave Abrahams)
+//   13 Jan 01  SGI MIPSpro and Compaq Tru64 Unix compiler support added
+//              (Jens Maurer)
+//   13 Jan 01  BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP (Jens Maurer)
 //   17 Nov 00  BOOST_NO_AUTO_PTR (John Maddock)
 //    4 Oct 00  BOOST_NO_STD_MIN_MAX (Jeremy Siek)
 //   29 Sep 00  BOOST_NO_INTEGRAL_INT64_T (Jens Maurer)
@@ -45,6 +58,13 @@
 #ifndef BOOST_CONFIG_HPP
 #define BOOST_CONFIG_HPP
 
+#define BOOST_VERSION 102102
+
+//  BOOST_VERSION % 100 is the sub-minor version
+//  BOOST_VERSION / 100 % 1000 is the minor version
+//  BOOST_VERSION / 100000 is the major version
+
+
 //  Conformance Flag Macros  -------------------------------------------------//
 //
 //  Conformance flag macros should identify the absence of C++ Standard 
@@ -53,6 +73,16 @@
 //  burden where it should be, on non-conforming compilers.  In the future,
 //  hopefully, less rather than more conformance flags will have to be defined.
 
+//  BOOST_NO_CV_SPECIALIZATIONS: if template specialisations for cv-qualified types
+//  conflict with a specialistaion for unqualififed type.
+
+//  BOOST_NO_CV_VOID_SPECIALIZATIONS: if template specialisations for cv-void types
+//  conflict with a specialistaion for void.
+
+//  BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP: Compiler does not implement
+//  argument-dependent lookup (also named Koenig lookup); see std::3.4.2
+//  [basic.koenig.lookup]
+
 //  BOOST_NO_DEPENDENT_TYPES_IN_TEMPLATE_VALUE_PARAMETERS: Template value
 //  parameters cannot have a dependent type, for example
 //  "template<class T, typename T::type value> class X { ... };"
@@ -65,6 +95,9 @@
 //  BOOST_NO_INTEGRAL_INT64_T: int64_t as defined by <boost/cstdint.hpp> is
 //  not an integral type.
 
+//  BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS: constants such as
+//  numeric_limits<T>::is_signed are not available for use at compile-time.
+
 //  BOOST_NO_MEMBER_TEMPLATES: Member template functions not fully supported.
 //  Also see BOOST_MSVC6_MEMBER_TEMPLATES in the Compiler Control section below.
 
@@ -119,12 +152,19 @@
 
 //  BOOST_DECL:  Certain compilers for Microsoft operating systems require
 //  non-standard class and function decoration if dynamic load library linking
-//  is desired.  BOOST_DECL supplies that decoration, defaulting to a nul string
-//  so that it is harmless when not required.  Boost does not encourage the use
-//  of BOOST_DECL - it is non-standard and to be avoided if practical to do so.
-
-//  BOOST_DECL_EXPORTS:  User defined, BOOST_DECL_EXPORTS causes BOOST_DECL to
-//  be defined as __declspec(dllexport) rather than __declspec(dllimport).
+//  is desired.  BOOST_DECL supplies that decoration.  Boost does not require
+//  use of BOOST_DECL - it is non-standard and to be avoided if practical to do
+//  so. Even compilers requiring it for DLL's only require it in certain cases.
+//
+//    BOOST_DECL_EXPORTS:  User defined, usually via command line or IDE,
+//    it causes BOOST_DECL to be defined as __declspec(dllexport).
+//
+//    BOOST_DECL_IMPORTS:  User defined, usually via command line or IDE,
+//    it causes BOOST_DECL to be defined as __declspec(dllimport).
+//
+//    If neither BOOST_DECL_EXPORTS nor BOOST_DECL_IMPORTS is defined, or if
+//    the compiler does not require __declspec() decoration, BOOST_DECL is
+//    defined as a null string.
 
 //  BOOST_MSVC6_MEMBER_TEMPLATES:  Microsoft Visual C++ 6.0 has enough member
 //  template idiosyncrasies (being polite) that BOOST_NO_MEMBER_TEMPLATES is
@@ -150,6 +190,8 @@
 
 //  BOOST_NO_SLIST: The C++ implementation does not provide the slist class.
 
+//  BOOST_NO_STRINGSTREAM: The C++ implementation does not provide the <sstream> header.
+
 //  BOOST_NO_HASH: The C++ implementation does not provide the hash_set
 //  or hash_map classes.
 
@@ -172,6 +214,18 @@
 //  BOOST_NO_STD_MIN_MAX: The C++ standard library does not provide
 //  the min() and max() template functions that should be in <algorithm>.
 
+//  Common compiler front-ends precede all compiler checks  ------------------//
+
+//  Edison Design Group front-ends
+# if defined(__EDG_VERSION__)
+
+#   if __EDG_VERSION__ <= 241
+#     define BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
+#   endif
+
+# endif
+
+//  Compiler-specific checks -------------------------------------------------//
 //  Compilers are listed in alphabetic order (except VC++ last - see below)---//
 
 //  GNU CC (also known as GCC and G++)  --------------------------------------//
@@ -181,18 +235,33 @@
        // egcs 1.1 won't parse smart_ptr.hpp without this:
 #      define BOOST_NO_AUTO_PTR
 #   endif
-#   if __GNUC__ == 2 && __GNUC_MINOR__ <= 95
-#     include <iterator>  // not sure this is the right way to do this -JGS
-#     if !defined(_CXXRT_STD) && !defined(__SGI_STL) // need to ask Dietmar about this -JGS
+#   if __GNUC__ == 2 && __GNUC_MINOR__ <= 97
+#     include <string>  // not sure this is the right way to do this -JGS
+#     if defined(__BASTRING__) && !defined(__GLIBCPP__) && !defined(_CXXRT_STD) && !defined(__SGI_STL) // need to ask Dietmar about this -JGS
+        // this should only detect the stdlibc++ that ships with gcc, and
+        // not any replacements that may be installed...
 #       define BOOST_NO_STD_ITERATOR
 #       define BOOST_NO_LIMITS
 #     endif
+#     if !defined(_CXXRT_STD) && !defined(__SGI_STL_OWN_IOSTREAMS)
+#       define BOOST_NO_STRINGSTREAM
+#     endif
 #     define BOOST_NO_MEMBER_TEMPLATE_FRIENDS
 #     define BOOST_NO_OPERATORS_IN_NAMESPACE
 #   endif
 #   if __GNUC__ == 2 && __GNUC_MINOR__ <= 8
 #     define BOOST_NO_MEMBER_TEMPLATES
 #   endif
+#   if (__GNUC__ == 2 && __GNUC_MINOR__ > 97) || __GNUC__ > 2
+      // upcoming gcc 3.0
+#     include <iterator>
+#     if defined(__GLIBCPP__)
+        // The new GNU C++ library has slist, hash_map, hash_set headers
+        // in <ext/*>, but client code assumes they're in <*> --- Jens M. 
+#       define BOOST_NO_SLIST
+#       define BOOST_NO_HASH
+#     endif
+#   endif
 
 //  Kai C++ ------------------------------------------------------------------//
 
@@ -200,6 +269,21 @@
 #   define BOOST_NO_SLIST
 #   define BOOST_NO_HASH
 
+#   if __KCC_VERSION <= 4001
+      // at least on Sun, the contents of <cwchar> is not in namespace std
+#     define BOOST_NO_STDC_NAMESPACE
+#   endif
+
+//  SGI MIPSpro C++ --------------------------------------------------------
+
+#elif defined __sgi
+
+//  Compaq Tru64 Unix cxx ---------------------------------------------------
+
+#elif defined __DECCXX
+#   define BOOST_NO_SLIST
+#   define BOOST_NO_HASH
+
 //  Greenhills C++ -----------------------------------------------------------//
 
 #elif defined __ghs
@@ -211,6 +295,8 @@
 #elif defined __BORLANDC__
 #   define BOOST_NO_SLIST
 #   define BOOST_NO_HASH
+// pull in standard library version:
+#   include <memory>
 #   if __BORLANDC__ <= 0x0551
 #     define BOOST_NO_INTEGRAL_INT64_T
 #     define BOOST_NO_PRIVATE_IN_AGGREGATE
@@ -225,10 +311,23 @@
 #     endif
 #   endif
 #   if defined BOOST_DECL_EXPORTS
+#     if defined BOOST_DECL_IMPORTS
+#       error Not valid to define both BOOST_DECL_EXPORTS and BOOST_DECL_IMPORTS
+#     endif
 #     define BOOST_DECL __declspec(dllexport)
-#   else
+#   elif defined BOOST_DECL_IMPORTS
 #     define BOOST_DECL __declspec(dllimport)
+#   else
+#     define BOOST_DECL
 #   endif
+#if (__BORLANDC__ == 0x550) || (__BORLANDC__ == 0x551)
+// <climits> is partly broken, some macos define symbols that are really in
+// namespace std, so you end up having to use illegal constructs like
+// std::DBL_MAX, as a fix we'll just include float.h and have done with:
+#include <float.h>
+#endif
+#   define BOOST_NO_CV_SPECIALIZATIONS
+#   define BOOST_NO_CV_VOID_SPECIALIZATIONS
 
 //  Intel  -------------------------------------------------------------------//
 
@@ -248,24 +347,30 @@
 #     define BOOST_NO_STD_ALLOCATOR
 #     define BOOST_NO_STD_MIN_MAX
 #   endif
-
+#   define BOOST_NO_INTRINSIC_WCHAR_T // tentative addition - required for VC6 compatibility? (added by JM 19 Feb 2001)
 
 //  Metrowerks CodeWarrior  --------------------------------------------------//
 
 # elif defined  __MWERKS__
-#   if __MWERKS__ <= 0x4000
+#   if __MWERKS__ <= 0x2400  // 6.0
 #     define BOOST_NO_MEMBER_TEMPLATE_FRIENDS
 #   endif
-#   if __MWERKS__ <= 0x2301
+#   if __MWERKS__ <= 0x2301  // 5.3?
 #     define BOOST_NO_POINTER_TO_MEMBER_CONST
+#     define BOOST_NO_DEPENDENT_TYPES_IN_TEMPLATE_VALUE_PARAMETERS
 #   endif
 #   if __MWERKS__ >= 0x2300
 #     define BOOST_SYSTEM_HAS_STDINT_H
 #   endif
 #   if defined BOOST_DECL_EXPORTS
+#     if defined BOOST_DECL_IMPORTS
+#       error Not valid to define both BOOST_DECL_EXPORTS and BOOST_DECL_IMPORTS
+#     endif
 #     define BOOST_DECL __declspec(dllexport)
-#   else
+#   elif defined BOOST_DECL_IMPORTS
 #     define BOOST_DECL __declspec(dllimport)
+#   else
+#     define BOOST_DECL
 #   endif
 
 #   define BOOST_STD_EXTENSION_NAMESPACE Metrowerks
@@ -273,6 +378,11 @@
 //  Sun Workshop Compiler C++ ------------------------------------------------//
 
 # elif defined  __SUNPRO_CC
+#    if __SUNPRO_CC <= 0x520
+#      define BOOST_NO_SLIST
+#      define BOOST_NO_HASH
+#      define BOOST_NO_STD_ITERATOR_TRAITS
+#    endif
 #    if __SUNPRO_CC <= 0x500
 #      define BOOST_NO_MEMBER_TEMPLATES
 #      define BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
@@ -293,6 +403,7 @@
 #   if _MSC_VER <= 1200  // 1200 == VC++ 6.0
 #     define BOOST_NO_INCLASS_MEMBER_INITIALIZATION
 #     define BOOST_NO_PRIVATE_IN_AGGREGATE
+#     define BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
 
 #     define BOOST_NO_INTEGRAL_INT64_T
 #     define BOOST_NO_INTRINSIC_WCHAR_T
@@ -331,6 +442,7 @@
 #       endif
 #     endif
 #     define BOOST_NO_STD_ITERATOR_TRAITS
+#     define BOOST_NO_CV_VOID_SPECIALIZATIONS
 
 
 // Make sure at least one standard library header is included so that library
@@ -340,16 +452,21 @@
 
 // Determine if the standard library implementation is already pulling names
 // into std.  STLport defines the following if so. (Ed Brey 5 Jun 00)
-#     ifndef __STL_IMPORT_VENDOR_CSTD
+#     if !defined( __STL_IMPORT_VENDOR_CSTD ) || defined( __STL_NO_CSTD_FUNCTION_IMPORTS )
 #       define BOOST_NO_STDC_NAMESPACE
 #     endif
 
 #   endif
 
 #   if defined BOOST_DECL_EXPORTS
+#     if defined BOOST_DECL_IMPORTS
+#       error Not valid to define both BOOST_DECL_EXPORTS and BOOST_DECL_IMPORTS
+#     endif
 #     define BOOST_DECL __declspec(dllexport)
-#   else
+#   elif defined BOOST_DECL_IMPORTS
 #     define BOOST_DECL __declspec(dllimport)
+#   else
+#     define BOOST_DECL
 #   endif
 
 # endif // Microsoft (excluding Intel/EDG frontend) 
@@ -360,6 +477,17 @@
 
 //  end of compiler specific portion  ----------------------------------------//
 
+#if defined(BOOST_NO_LIMITS) || (defined(_RWSTD_VER) && defined(__BORLANDC__) && _RWSTD_VER < 0x020300) || (defined(__SGI_STL_PORT) && __SGI_STL_PORT <= 0x410 && __STL_STATIC_CONST_INIT_BUG)
+// STLPort 4.0 doesn't define the static constants in numeric_limits<> so that they
+// can be used at compile time if the compiler bug indicated by
+// __STL_STATIC_CONST_INIT_BUG is present.
+
+// Rogue wave STL (C++ Builder) also has broken numeric_limits
+// with default template defining members out of line.
+// However, Compaq C++ also uses RogueWave (version 0x0203) and it's ok.
+#   define BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
+#endif
+
 #ifndef BOOST_STD_EXTENSION_NAMESPACE
 # define BOOST_STD_EXTENSION_NAMESPACE std
 #endif
@@ -407,8 +535,18 @@ namespace std {
 }
 #endif
 
+// BOOST_STATIC_CONSTANT workaround --------------------------------------- //
+// On compilers which don't allow in-class initialization of static integral
+// constant members, we must use enums as a workaround if we want the constants
+// to be available at compile-time. This macro gives us a convenient way to
+// declare such constants.
+#ifdef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
+# define BOOST_STATIC_CONSTANT(type, assignment) enum { assignment }
+#else
+# define BOOST_STATIC_CONSTANT(type, assignment) static const type assignment
+#endif
+
 #endif  // BOOST_CONFIG_HPP
 
 
 
-

include/boost/detail/limits.hpp

@@ -0,0 +1,433 @@
+/*
+ * Copyright (c) 1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied warranty.
+ */
+
+/* NOTE: This is not portable code.  Parts of numeric_limits<> are
+ * inherently machine-dependent, and this file is written for the MIPS
+ * architecture and the SGI MIPSpro C++ compiler.  Parts of it (in
+ * particular, some of the characteristics of floating-point types)
+ * are almost certainly incorrect for any other platform.
+ */
+
+/*
+ * Revision history:
+ * 13 Apr 2001:
+ *    Added powerpc to the big endian family. (Jeremy Siek)
+ * 5 Apr 2001:
+ *    Added sparc (big endian) processor support (John Maddock).
+ * Initial sub:
+ * 	Modified by Jens Maurer for gcc 2.95 on x86.
+ */
+
+#ifndef BOOST_SGI_CPP_LIMITS
+#define BOOST_SGI_CPP_LIMITS
+
+#include <climits>
+#include <cfloat>
+#include <boost/config.hpp>
+
+#if defined(__sparc) || defined(__sparc__) || defined(__powerpc__)
+#define BOOST_BIG_ENDIAN
+#elif !defined(__i386__)
+#error This file is not correctly set up for your cpu type.
+#endif
+
+namespace std {
+
+enum float_round_style {
+  round_indeterminate       = -1,
+  round_toward_zero         =  0,
+  round_to_nearest          =  1,
+  round_toward_infinity     =  2,
+  round_toward_neg_infinity =  3
+};
+
+enum float_denorm_style {
+  denorm_indeterminate = -1,
+  denorm_absent        =  0,
+  denorm_present       =  1
+};
+
+// The C++ standard (section 18.2.1) requires that some of the members of
+// numeric_limits be static const data members that are given constant-
+// initializers within the class declaration.  On compilers where the
+// BOOST_NO_INCLASS_MEMBER_INITIALIZATION macro is defined, it is impossible to write
+// a standard-conforming numeric_limits class.
+//
+// There are two possible workarounds: either initialize the data
+// members outside the class, or change them from data members to
+// enums.  Neither workaround is satisfactory: the former makes it
+// impossible to use the data members in constant-expressions, and the
+// latter means they have the wrong type and that it is impossible to
+// take their addresses.  We choose the former workaround.
+
+#ifdef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
+# define BOOST_STL_DECLARE_LIMITS_MEMBER(__mem_type, __mem_name, __mem_value) \
+  enum { __mem_name = __mem_value }
+#else /* BOOST_NO_INCLASS_MEMBER_INITIALIZATION */
+# define BOOST_STL_DECLARE_LIMITS_MEMBER(__mem_type, __mem_name, __mem_value) \
+  static const __mem_type __mem_name = __mem_value
+#endif /* BOOST_NO_INCLASS_MEMBER_INITIALIZATION */
+
+// Base class for all specializations of numeric_limits.
+
+template <class __number>
+class _Numeric_limits_base {
+public:
+  BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_specialized, false);
+
+  static __number min() throw() { return __number(); }
+  static __number max() throw() { return __number(); }
+
+  BOOST_STL_DECLARE_LIMITS_MEMBER(int, digits,   0);
+  BOOST_STL_DECLARE_LIMITS_MEMBER(int, digits10, 0);
+
+  BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_signed,  false);
+  BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_integer, false);
+  BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_exact,   false);
+
+  BOOST_STL_DECLARE_LIMITS_MEMBER(int, radix, 0);
+
+  static __number epsilon() throw()     { return __number(); }
+  static __number round_error() throw() { return __number(); }
+
+  BOOST_STL_DECLARE_LIMITS_MEMBER(int, min_exponent,   0);
+  BOOST_STL_DECLARE_LIMITS_MEMBER(int, min_exponent10, 0);
+  BOOST_STL_DECLARE_LIMITS_MEMBER(int, max_exponent,   0);
+  BOOST_STL_DECLARE_LIMITS_MEMBER(int, max_exponent10, 0);
+
+  BOOST_STL_DECLARE_LIMITS_MEMBER(bool, has_infinity,      false);
+  BOOST_STL_DECLARE_LIMITS_MEMBER(bool, has_quiet_NaN,     false);
+  BOOST_STL_DECLARE_LIMITS_MEMBER(bool, has_signaling_NaN, false);
+  BOOST_STL_DECLARE_LIMITS_MEMBER(float_denorm_style,
+                              has_denorm,
+                              denorm_absent);
+  BOOST_STL_DECLARE_LIMITS_MEMBER(bool, has_denorm_loss,   false);
+
+  static __number infinity() throw()      { return __number(); }
+  static __number quiet_NaN() throw()     { return __number(); }
+  static __number signaling_NaN() throw() { return __number(); }
+  static __number denorm_min() throw()    { return __number(); }
+
+  BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_iec559,  false);
+  BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_bounded, false);
+  BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_modulo,  false);
+
+  BOOST_STL_DECLARE_LIMITS_MEMBER(bool, traps,            false);
+  BOOST_STL_DECLARE_LIMITS_MEMBER(bool, tinyness_before,  false);
+  BOOST_STL_DECLARE_LIMITS_MEMBER(float_round_style,
+                              round_style,
+                              round_toward_zero);
+};
+
+// Base class for integers.
+
+template <class _Int,
+          _Int __imin,
+          _Int __imax,
+          int __idigits = -1>
+class _Integer_limits : public _Numeric_limits_base<_Int> 
+{
+public:
+  BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_specialized, true);
+
+  static _Int min() throw() { return __imin; }
+  static _Int max() throw() { return __imax; }
+
+  BOOST_STL_DECLARE_LIMITS_MEMBER(int,
+                              digits,
+                              (__idigits < 0) ? (int)(sizeof(_Int) * CHAR_BIT)
+                                                   - (__imin == 0 ? 0 : 1) 
+                                              : __idigits);
+  BOOST_STL_DECLARE_LIMITS_MEMBER(int, digits10, (digits * 301) / 1000); 
+                                // log 2 = 0.301029995664...
+
+  BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_signed,  __imin != 0);
+  BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_integer, true);
+  BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_exact,   true);
+  BOOST_STL_DECLARE_LIMITS_MEMBER(int,  radix,      2);
+
+  BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_bounded, true);
+  BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_modulo, true);
+};
+
+#if defined(BOOST_BIG_ENDIAN)
+
+ template<class Number, unsigned int Word>
+ struct float_helper{
+  static Number get_word() throw() {
+    // sizeof(long double) == 16
+    const unsigned int _S_word[4] = { Word, 0, 0, 0 };
+    return *reinterpret_cast<const Number*>(&_S_word);
+  } 
+};
+
+#else
+
+ template<class Number, unsigned int Word>
+ struct float_helper{
+  static Number get_word() throw() {
+    // sizeof(long double) == 12, but only 10 bytes significant
+    const unsigned int _S_word[4] = { 0, 0, 0, Word };
+    return *reinterpret_cast<const Number*>(
+        reinterpret_cast<const char *>(&_S_word)+16-
+		(sizeof(Number) == 12 ? 10 : sizeof(Number)));
+  } 
+};
+
+#endif
+
+// Base class for floating-point numbers.
+template <class __number,
+         int __Digits, int __Digits10,
+         int __MinExp, int __MaxExp,
+         int __MinExp10, int __MaxExp10,
+         unsigned int __InfinityWord,
+         unsigned int __QNaNWord, unsigned int __SNaNWord,
+         bool __IsIEC559,
+         float_round_style __RoundStyle>
+class _Floating_limits : public _Numeric_limits_base<__number>
+{
+public:
+  BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_specialized, true);
+
+  BOOST_STL_DECLARE_LIMITS_MEMBER(int, digits,   __Digits);
+  BOOST_STL_DECLARE_LIMITS_MEMBER(int, digits10, __Digits10);
+
+  BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_signed, true);
+
+  BOOST_STL_DECLARE_LIMITS_MEMBER(int, radix, 2);
+
+  BOOST_STL_DECLARE_LIMITS_MEMBER(int, min_exponent,   __MinExp);
+  BOOST_STL_DECLARE_LIMITS_MEMBER(int, max_exponent,   __MaxExp);
+  BOOST_STL_DECLARE_LIMITS_MEMBER(int, min_exponent10, __MinExp10);
+  BOOST_STL_DECLARE_LIMITS_MEMBER(int, max_exponent10, __MaxExp10);
+
+  BOOST_STL_DECLARE_LIMITS_MEMBER(bool, has_infinity,      true);
+  BOOST_STL_DECLARE_LIMITS_MEMBER(bool, has_quiet_NaN,     true);
+  BOOST_STL_DECLARE_LIMITS_MEMBER(bool, has_signaling_NaN, true);
+  BOOST_STL_DECLARE_LIMITS_MEMBER(float_denorm_style,
+                              has_denorm,
+                              denorm_indeterminate);
+  BOOST_STL_DECLARE_LIMITS_MEMBER(bool, has_denorm_loss,   false);
+
+ 
+  static __number infinity() throw() {
+    return float_helper<__number, __InfinityWord>::get_word();
+  }
+  static __number quiet_NaN() throw() {
+    return float_helper<__number,__QNaNWord>::get_word();
+  }
+  static __number signaling_NaN() throw() {
+    return float_helper<__number,__SNaNWord>::get_word();
+  }
+
+  BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_iec559,       __IsIEC559);
+  BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_bounded,      true);
+  BOOST_STL_DECLARE_LIMITS_MEMBER(bool, traps,           false /* was: true */ );
+  BOOST_STL_DECLARE_LIMITS_MEMBER(bool, tinyness_before, false);
+
+  BOOST_STL_DECLARE_LIMITS_MEMBER(float_round_style, round_style, __RoundStyle);
+};
+
+// Class numeric_limits
+
+// The unspecialized class.
+
+template<class T> 
+class numeric_limits : public _Numeric_limits_base<T> {};
+
+// Specializations for all built-in integral types.
+
+template<>
+class numeric_limits<bool>
+  : public _Integer_limits<bool, false, true, 0>
+{};
+
+template<>
+class numeric_limits<char>
+  : public _Integer_limits<char, CHAR_MIN, CHAR_MAX>
+{};
+
+template<>
+class numeric_limits<signed char>
+  : public _Integer_limits<signed char, SCHAR_MIN, SCHAR_MAX>
+{};
+
+template<>
+class numeric_limits<unsigned char>
+  : public _Integer_limits<unsigned char, 0, UCHAR_MAX>
+{};
+
+#ifndef _WIN32
+template<>
+class numeric_limits<wchar_t>
+  : public _Integer_limits<wchar_t, INT_MIN, INT_MAX>
+{};
+#else
+class numeric_limits<wchar_t>
+  : public _Integer_limits<wchar_t, 0, USHRT_MAX>
+{};
+#endif
+
+template<>
+class numeric_limits<short>
+  : public _Integer_limits<short, SHRT_MIN, SHRT_MAX>
+{};
+
+template<>
+class numeric_limits<unsigned short>
+  : public _Integer_limits<unsigned short, 0, USHRT_MAX>
+{};
+
+template<>
+class numeric_limits<int>
+  : public _Integer_limits<int, INT_MIN, INT_MAX>
+{};
+
+template<>
+class numeric_limits<unsigned int>
+  : public _Integer_limits<unsigned int, 0, UINT_MAX>
+{};
+
+template<>
+class numeric_limits<long>
+  : public _Integer_limits<long, LONG_MIN, LONG_MAX>
+{};
+
+template<>
+class numeric_limits<unsigned long>
+  : public _Integer_limits<unsigned long, 0, ULONG_MAX>
+{};
+
+#ifdef __GNUC__
+
+// Some compilers have long long, but don't define the
+// LONGLONG_MIN and LONGLONG_MAX macros in limits.h.  This
+// assumes that long long is 64 bits.
+#if !defined(LONGLONG_MIN) && !defined(LONGLONG_MAX) \
+                           && !defined(ULONGLONG_MAX)
+
+#define ULONGLONG_MAX 0xffffffffffffffffLLU
+#define LONGLONG_MAX 0x7fffffffffffffffLL
+#define LONGLONG_MIN (-LONGLONG_MAX - 1)
+
+#endif
+
+template<>
+class numeric_limits<long long>
+  : public _Integer_limits<long long, LONGLONG_MIN, LONGLONG_MAX>
+{};
+
+template<>
+class numeric_limits<unsigned long long>
+  : public _Integer_limits<unsigned long long, 0, ULONGLONG_MAX>
+{};
+
+#endif /* __GNUC__ */
+
+// Specializations for all built-in floating-point type.
+
+template<> class numeric_limits<float>
+  : public _Floating_limits<float, 
+                            FLT_MANT_DIG,   // Binary digits of precision
+                            FLT_DIG,        // Decimal digits of precision
+                            FLT_MIN_EXP,    // Minimum exponent
+                            FLT_MAX_EXP,    // Maximum exponent
+                            FLT_MIN_10_EXP, // Minimum base 10 exponent
+                            FLT_MAX_10_EXP, // Maximum base 10 exponent
+#if defined(BOOST_BIG_ENDIAN)
+                            0x7f80 << (sizeof(int)*CHAR_BIT-16),    // Last word of +infinity
+                            0x7f81 << (sizeof(int)*CHAR_BIT-16),    // Last word of quiet NaN
+                            0x7fc1 << (sizeof(int)*CHAR_BIT-16),    // Last word of signaling NaN
+#else
+                            0x7f800000u,    // Last word of +infinity
+                            0x7f810000u,    // Last word of quiet NaN
+                            0x7fc10000u,    // Last word of signaling NaN
+#endif
+                            true,           // conforms to iec559
+                            round_to_nearest>
+{
+public:
+  static float min() throw() { return FLT_MIN; }
+  static float denorm_min() throw() { return FLT_MIN; }
+  static float max() throw() { return FLT_MAX; }
+  static float epsilon() throw() { return FLT_EPSILON; }
+  static float round_error() throw() { return 0.5f; } // Units: ulps.
+};
+
+template<> class numeric_limits<double>
+  : public _Floating_limits<double, 
+                            DBL_MANT_DIG,   // Binary digits of precision
+                            DBL_DIG,        // Decimal digits of precision
+                            DBL_MIN_EXP,    // Minimum exponent
+                            DBL_MAX_EXP,    // Maximum exponent
+                            DBL_MIN_10_EXP, // Minimum base 10 exponent
+                            DBL_MAX_10_EXP, // Maximum base 10 exponent
+#if defined(BOOST_BIG_ENDIAN)
+                            0x7ff0 << (sizeof(int)*CHAR_BIT-16),    // Last word of +infinity
+                            0x7ff1 << (sizeof(int)*CHAR_BIT-16),    // Last word of quiet NaN
+                            0x7ff9 << (sizeof(int)*CHAR_BIT-16),    // Last word of signaling NaN
+#else
+                            0x7ff00000u,    // Last word of +infinity
+                            0x7ff10000u,    // Last word of quiet NaN
+                            0x7ff90000u,    // Last word of signaling NaN
+#endif
+                            true,           // conforms to iec559
+                            round_to_nearest>
+{
+public:
+  static double min() throw() { return DBL_MIN; }
+  static double denorm_min() throw() { return DBL_MIN; }
+  static double max() throw() { return DBL_MAX; }
+  static double epsilon() throw() { return DBL_EPSILON; }
+  static double round_error() throw() { return 0.5; } // Units: ulps.
+};
+
+template<> class numeric_limits<long double>
+  : public _Floating_limits<long double, 
+                            LDBL_MANT_DIG,  // Binary digits of precision
+                            LDBL_DIG,       // Decimal digits of precision
+                            LDBL_MIN_EXP,   // Minimum exponent
+                            LDBL_MAX_EXP,   // Maximum exponent
+                            LDBL_MIN_10_EXP,// Minimum base 10 exponent
+                            LDBL_MAX_10_EXP,// Maximum base 10 exponent
+#if defined(BOOST_BIG_ENDIAN)
+                            0x7ff0 << (sizeof(int)*CHAR_BIT-16),    // Last word of +infinity
+                            0x7ff1 << (sizeof(int)*CHAR_BIT-16),    // Last word of quiet NaN
+                            0x7ff9 << (sizeof(int)*CHAR_BIT-16),    // Last word of signaling NaN
+#else
+                            0x7fff8000u,    // Last word of +infinity
+                            0x7fffc000u,    // Last word of quiet NaN
+                            0x7fff9000u,    // Last word of signaling NaN
+#endif
+                            false,          // Doesn't conform to iec559
+                            round_to_nearest>
+{
+public:
+  static long double min() throw() { return LDBL_MIN; }
+  static long double denorm_min() throw() { return LDBL_MIN; }
+  static long double max() throw() { return LDBL_MAX; }
+  static long double epsilon() throw() { return LDBL_EPSILON; }
+  static long double round_error() throw() { return 4; } // Units: ulps.
+};
+
+} // namespace std
+
+#endif /* BOOST_SGI_CPP_LIMITS */
+
+// Local Variables:
+// mode:C++
+// End:
+
+
+

include/boost/limits.hpp

@@ -0,0 +1,20 @@
+
+//  (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.
+//
+// use this header as a workaround for missing <limits>
+
+#ifndef BOOST_LIMITS
+#define BOOST_LIMITS
+
+#include <boost/config.hpp>
+
+#ifdef BOOST_NO_LIMITS
+#include <boost/detail/limits.hpp>
+#else
+#include <limits>
+#endif
+
+#endif

include/boost/pending/limits.hpp

@@ -1,407 +0,0 @@
-/** -*- C++ -*-
- **  KAI C++ Compiler
- **
- **  Copyright (C) 1996-1997, Kuck & Associates, Inc. All rights reserved.
- **  This is an almost complete rewrite of Modena version.
- **/
-/**
- ** Lib++     : The Modena C++ Standard Library,
- **             Version 2.4, August 27th 1997
- **
- ** Copyright (c) 1994-1997 Modena Software Inc.
- **/
-#ifndef BOOST_GRAPH_DETAIL_LIMITS_HPP
-#define BOOST_GRAPH_DETAIL_LIMITS_HPP
-
-#include <boost/config.hpp>
-
-#ifdef BOOST_NO_LIMITS
-
-#define MSIPL_THROW
-
-#include <float.h>
-#include <limits.h>
-
-namespace std {
-
-enum float_round_style {
-     round_indeterminate       = -1,
-     round_toward_zero         =  0,
-     round_to_nearest          =  1,
-     round_toward_infinity     =  2,
-     round_toward_neg_infinity =  3
-};
-
-template <class T>
-class numeric_limits {
-public:
-    static const bool is_specialized = false;
-    static T min() throw() {return T();}
-    static T max() throw() {return T();}
-    static const int  digits = 0;
-    static const int  digits10 = 0;
-    static const bool is_signed = false;
-    static const bool is_integer = false;
-    static const bool is_exact = false;
-    static const int  radix = 0;
-    static T epsilon() throw() {return T();}
-    static T round_error() throw() {return T();}
-
-    static const int  min_exponent = 0;
-    static const int  min_exponent10 = 0;
-    static const int  max_exponent = 0;
-    static const int  max_exponent10 = 0;
-
-    static const bool has_infinity = false;
-    static const bool has_quiet_NaN = false;
-    static const bool has_signaling_NaN = false;
-    static const bool has_denorm = false;
-    static const bool has_denorm_loss = false;
-
-    // Sept. 1996 draft is vague on how these can be guaranteed to return
-    // value without throwing an exception.  
-    static T infinity() throw() {return T();};
-    static T quiet_NaN() throw() {return T();}
-    static T signaling_NaN() throw() {return T();}
-    static T denorm_min() throw() {return T();}
-
-    static const bool is_iec559 = false;
-    static const bool is_bounded = false;
-    static const bool is_modulo = false;
-
-    static const bool traps = false;
-    static const bool tinyness_before = false;
-    static const float_round_style round_style = round_toward_zero;
-};
-template<class T> const bool numeric_limits<T>::is_specialized;
-template<class T> const int  numeric_limits<T>::digits;
-template<class T> const int  numeric_limits<T>::digits10;
-template<class T> const bool numeric_limits<T>::is_signed;
-template<class T> const bool numeric_limits<T>::is_integer;
-template<class T> const bool numeric_limits<T>::is_exact;
-template<class T> const int  numeric_limits<T>::radix;
-template<class T> const int  numeric_limits<T>::min_exponent;
-template<class T> const int  numeric_limits<T>::min_exponent10;
-template<class T> const int  numeric_limits<T>::max_exponent;
-template<class T> const int  numeric_limits<T>::max_exponent10;
-template<class T> const bool numeric_limits<T>::has_infinity;
-template<class T> const bool numeric_limits<T>::has_quiet_NaN;
-template<class T> const bool numeric_limits<T>::has_signaling_NaN;
-template<class T> const bool numeric_limits<T>::has_denorm;
-template<class T> const bool numeric_limits<T>::has_denorm_loss;
-template<class T> const bool numeric_limits<T>::is_iec559;
-template<class T> const bool numeric_limits<T>::is_bounded;
-template<class T> const bool numeric_limits<T>::is_modulo;
-template<class T> const bool numeric_limits<T>::traps;
-template<class T> const bool numeric_limits<T>::tinyness_before;
-template<class T> const float_round_style numeric_limits<T>::round_style;
-
-// The specializations for floating-point types use the following macro 
-// to factor out commonality.  They presume IEEE arithmetic.
-#define __KAI_NUMERIC_LIMITS_FLOAT(T)    \
-    static const bool is_specialized = true;  \
-    static const int  radix = 2;    \
-                                    \
-    static const bool is_signed = true;    \
-    static const bool is_integer = false;  \
-    static const bool is_exact = false;    \
-                                    \
-    static const bool has_infinity = true;  \
-    static const bool has_quiet_NaN = true;  \
-    static const bool has_signaling_NaN = true;  \
-    static const bool has_denorm = false;  \
-    static const bool has_denorm_loss = false;  \
-                                    \
-    static const bool is_iec559 = sizeof(T)<=8;  \
-    static const bool is_bounded = true;  \
-    static const bool is_modulo = false;  \
-    static const bool traps = true;    \
-    static const bool tinyness_before = true;  \
-                                     \
-    static T round_error ()   MSIPL_THROW    { return (T)0.5F; }      \
-    static const float_round_style round_style = round_to_nearest;  \
-    static T infinity ()      MSIPL_THROW {return *(T*)(void*)data.value[0];}\
-    static T quiet_NaN ()     MSIPL_THROW {return *(T*)(void*)data.value[1];}\
-    static T signaling_NaN () MSIPL_THROW {return *(T*)(void*)data.value[2];}\
-private:                            \
-    static const struct data_t {    \
-  T align;                          \
-  int value[3][sizeof(T)/sizeof(int)];  \
-    } data;                            \
-public:                                    \
-
-template<>
-class numeric_limits <float> {
-public:
-    static const int  digits = FLT_MANT_DIG;
-    static const int  digits10 = FLT_DIG;
-    static const int  min_exponent = FLT_MIN_EXP;
-    static const int  max_exponent = FLT_MAX_EXP;
-    static const int  min_exponent10 = FLT_MIN_10_EXP;
-    static const int  max_exponent10 = FLT_MAX_10_EXP;
-
-    __KAI_NUMERIC_LIMITS_FLOAT(float)
-
-    static float min ()          MSIPL_THROW    { return FLT_MIN; }
-    static float max ()          MSIPL_THROW    { return FLT_MAX; }
-    static float epsilon ()      MSIPL_THROW    { return FLT_EPSILON; }
-    static float denorm_min ()   MSIPL_THROW    { return FLT_MIN; }
-};
-
-template<>
-class numeric_limits <double> {
-public:
-    static const int  digits = DBL_MANT_DIG;
-    static const int  digits10 = DBL_DIG;
-    static const int  min_exponent = DBL_MIN_EXP;
-    static const int  max_exponent = DBL_MAX_EXP;
-    static const int  min_exponent10 = DBL_MIN_10_EXP;
-    static const int  max_exponent10 = DBL_MAX_10_EXP;
-
-    __KAI_NUMERIC_LIMITS_FLOAT(double)
-
-    static double min ()          MSIPL_THROW    { return DBL_MIN; }
-    static double max ()          MSIPL_THROW    { return DBL_MAX; }
-    static double epsilon ()      MSIPL_THROW    { return DBL_EPSILON; }
-    static double denorm_min ()   MSIPL_THROW    { return min (); }
-};
-
-template<>
-class numeric_limits <long double> {
-public:
-    static const int  digits = LDBL_MANT_DIG;
-    static const int  digits10 = LDBL_DIG;
-    static const int  min_exponent = LDBL_MIN_EXP;
-    static const int  max_exponent = LDBL_MAX_EXP;
-    static const int  min_exponent10 = LDBL_MIN_10_EXP;
-    static const int  max_exponent10 = LDBL_MAX_10_EXP;
-
-    __KAI_NUMERIC_LIMITS_FLOAT(long double)
-
-    static long double min ()          MSIPL_THROW    { return LDBL_MIN; }
-    static long double max ()          MSIPL_THROW    { return LDBL_MAX; }
-    static long double epsilon ()      MSIPL_THROW    { return LDBL_EPSILON; }
-    static long double denorm_min ()   MSIPL_THROW    { return min (); }
-};
-
-// The specializations for integral types use three macros to factor out
-// commonality.
-//
-//   __KAI_NUMERIC_LIMITS_INTEGRAL declares members of numeric_limits<T>
-//   whose value does not depend on the signdness of T. 
-//
-//  __KAI_NUMERIC_LIMITS_SIGNED(T) declares members dependent on
-//  knowing that T is signed.
-//
-//  __KAI_NUMERIC_LIMITS_UNSIGNED(T) declares members dependent on
-//  knowing that T is unsigned.
-//
-// We could have been real cutesy and come up with definitions that would
-// work for both signed and unsigned types, but doing so does not seem
-// to be worth the additional obfuscation and overhead for constant folding.
-//
-// The definitions are not intended to be universally portable.
-// They are designed with KAI C++ targets in mind. -ADR
-
-#define __KAI_NUMERIC_LIMITS_INTEGRAL(T)            \
-    static const bool is_specialized = true;            \
-                                                    \
-    static const int radix = 2;                            \
-    static const int min_exponent = 0;                    \
-    static const int max_exponent = 0;                    \
-    static const int min_exponent10 = 0;            \
-    static const int max_exponent10 = 0;            \
-                                                    \
-    static const bool is_integer = true;            \
-    static const bool is_exact = true;                    \
-                                                    \
-    static const bool has_infinity = false;            \
-    static const bool has_quiet_NaN = false;            \
-    static const bool has_signaling_NaN = false;    \
-    static const bool has_denorm = false;            \
-    static const bool has_denorm_loss = false;            \
-                                                    \
-    static const bool is_iec559 = false;            \
-    static const bool is_bounded = true;            \
-    static const bool is_modulo = true;                    \
-    static const bool traps = false;                    \
-    static const bool tinyness_before = false;            \
-                                                    \
-    static T infinity ()       MSIPL_THROW { return 0; }  \
-    static T quiet_NaN ()      MSIPL_THROW { return 0; }  \
-    static T signaling_NaN () MSIPL_THROW { return 0; }    \
-    static T epsilon ()     MSIPL_THROW { return 1; }    \
-    static T denorm_min ()  MSIPL_THROW { return min (); }  \
-    static T round_error () MSIPL_THROW { return 0; }    \
-                                                    \
-    static const float_round_style round_style = round_toward_zero;
-
-#define __KAI_NUMERIC_LIMITS_SIGNED(T)                     \
-    static const int digits = 8*sizeof(T)-1;            \
-    /* Following presumes 8, 16, 32, or 64-bit T. */    \
-    static const int digits10 = 7*sizeof(T)/3;             \
-    static const bool is_signed = true;                    
-
-#define __KAI_NUMERIC_LIMITS_UNSIGNED(T)             \
-    static const int digits = 8*sizeof(T);            \
-    /* Following presumes 8, 16, 32, or 64-bit T. */    \
-    static const int digits10 = 12*sizeof(T)/5;      \
-    static const bool is_signed = false;                    
-
-template<>
-class numeric_limits <int> {
-public:
-    __KAI_NUMERIC_LIMITS_INTEGRAL(int)
-    __KAI_NUMERIC_LIMITS_SIGNED(int)
-    static int min() MSIPL_THROW { return INT_MIN; }
-    static int max() MSIPL_THROW { return INT_MAX; }
-};
-
-template<>
-class numeric_limits <unsigned int> {
-public:
-    __KAI_NUMERIC_LIMITS_INTEGRAL(unsigned int)
-    __KAI_NUMERIC_LIMITS_UNSIGNED(unsigned int)
-    static unsigned int min() MSIPL_THROW { return 0; }
-    static unsigned int max() MSIPL_THROW { return UINT_MAX; }
-};
-
-template<>
-class numeric_limits <long> {
-public:
-    __KAI_NUMERIC_LIMITS_INTEGRAL(long)
-    __KAI_NUMERIC_LIMITS_SIGNED(long)
-    static long min() MSIPL_THROW { return LONG_MIN; }
-    static long max() MSIPL_THROW { return LONG_MAX; }
-};
-
-template<>
-class numeric_limits <unsigned long> {
-public:
-    __KAI_NUMERIC_LIMITS_INTEGRAL(unsigned long)
-    __KAI_NUMERIC_LIMITS_UNSIGNED(unsigned long)
-    static unsigned long min() MSIPL_THROW { return 0; }
-    static unsigned long max() MSIPL_THROW { return ULONG_MAX; }
-};
-
-template<>
-class numeric_limits <short> {
-public:
-    __KAI_NUMERIC_LIMITS_INTEGRAL(short)
-    __KAI_NUMERIC_LIMITS_SIGNED(short)
-    static short min () MSIPL_THROW { return SHRT_MIN; }
-    static short max () MSIPL_THROW { return SHRT_MAX; }
-};
-
-template<>
-class numeric_limits <unsigned short> {
-public:
-    __KAI_NUMERIC_LIMITS_INTEGRAL(unsigned short)
-    __KAI_NUMERIC_LIMITS_UNSIGNED(unsigned short)
-    static unsigned short min () MSIPL_THROW { return 0; }
-    static unsigned short max () MSIPL_THROW { return USHRT_MAX; }
-};
-
-template<>
-class numeric_limits <char> {
-public:
-    __KAI_NUMERIC_LIMITS_INTEGRAL(char)
-    static const int digits = CHAR_MIN<0 ? 7 : 8;
-    static const int digits10 = 2;
-    static const bool is_signed = CHAR_MIN<0;                    
-    static char min () MSIPL_THROW { return CHAR_MIN; }
-    static char max () MSIPL_THROW { return CHAR_MAX; }
-};
-
-template<>
-class numeric_limits <signed char> {
-public:
-    __KAI_NUMERIC_LIMITS_INTEGRAL(signed char)
-    __KAI_NUMERIC_LIMITS_SIGNED(signed char)
-    static signed char min ()         MSIPL_THROW { return SCHAR_MIN; }
-    static signed char max ()         MSIPL_THROW { return SCHAR_MAX; }
-};
-
-template<>
-class numeric_limits <unsigned char> {
-public:
-    __KAI_NUMERIC_LIMITS_INTEGRAL(unsigned char)
-    __KAI_NUMERIC_LIMITS_UNSIGNED(unsigned char)
-    static unsigned char min ()         MSIPL_THROW { return 0; }
-    static unsigned char max ()         MSIPL_THROW { return UCHAR_MAX; }
-};
-
-#if 0
-#ifdef MSIPL_WCHART
-
-template<>
-class numeric_limits <wchar_t> {
-public:
-    __KAI_NUMERIC_LIMITS_INTEGRAL(wchar_t)
-    static const bool is_signed = (wchar_t)-1<0;
-    static const int digits = 8*sizeof(wchar_t) - is_signed;
-    // Following assumes that wchar_t is 8, 16, or 32-bit, 
-    // either signed or unsigned.
-    static const int digits10 = 7*sizeof(T)/3;
-    static char min () MSIPL_THROW { return CHAR_MIN; }
-    static char max () MSIPL_THROW { return CHAR_MAX; }
-};
-
-#endif /* MSIPL_WCHART */
-
-#ifdef _BOOL
-template<>
-class numeric_limits <bool> {
-public:
-    static const bool is_specialized = true;
-
-    static const int radix = 2;
-    static const int min_exponent = 0;
-    static const int max_exponent = 0;
-    static const int min_exponent10 = 0;
-    static const int max_exponent10 = 0;
-
-    static const bool is_integer = false;
-    static const bool is_exact = true;
-
-    static const bool has_infinity = false;
-    static const bool has_quiet_NaN = false;
-    static const bool has_signaling_NaN = false;
-    static const bool has_denorm = false;
-    static const bool has_denorm_loss = false;
-
-    static const bool is_iec559 = false;
-    static const bool is_bounded = true;
-    static const bool is_modulo = false;
-    static const bool traps = false;
-    static const bool tinyness_before = false;
-
-    static bool infinity ()       MSIPL_THROW { return false; }
-    static bool quiet_NaN ()      MSIPL_THROW { return false; }
-    static bool signaling_NaN () MSIPL_THROW { return false; }
-    static bool epsilon ()     MSIPL_THROW { return false; }
-    static bool denorm_min ()  MSIPL_THROW { return min (); }
-    static bool round_error () MSIPL_THROW { return false; }
-                                                    
-    static const float_round_style round_style = round_toward_zero;
-
-    static const int digits = 1;
-    static const int digits10 = 0;
-    static const bool is_signed = false;
-
-    static bool min ()         MSIPL_THROW { return false; }
-    static bool max ()         MSIPL_THROW { return true; }
-};
-#endif  /* _BOOL */
-#endif
-
-} /* namespace std */
-
-
-#else
-
-#include <limits>
-
-#endif /* BOOST_GRAPH_DETAIL_HAVE_LIMITS */
-
-#endif /* BOOST_GRAPH_DETAIL_LIMIT_H */

limits_test.cpp

@@ -0,0 +1,147 @@
+/* boost limits_test.cpp   test your <limits> file for important
+ *
+ * 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
+ * appears in all copies and that both that copyright notice and this
+ * permission notice appear in supporting documentation,
+ *
+ * Jens Maurer makes no representations about the suitability of this
+ * software for any purpose. It is provided "as is" without express or
+ * implied warranty.
+ *
+ * $Id$
+ */
+
+#include <boost/limits.hpp>
+#define BOOST_INCLUDE_MAIN
+#include <boost/test/test_tools.hpp>
+#include <iostream>
+
+/*
+ * General portability note:
+ * MSVC mis-compiles explicit function template instantiations.
+ * For example, f<A>() and f<B>() are both compiled to call f<A>().
+ * BCC is unable to implicitly convert a "const char *" to a std::string
+ * when using explicit function template instantiations.
+ *
+ * Therefore, avoid explicit function template instantiations.
+ */
+
+template<class T>
+void test_integral_limits(const T &, const char * msg)
+{
+  typedef std::numeric_limits<T> lim;
+  std::cout << "Testing " << msg
+            << " (size " << sizeof(T) << ")" 
+            << " min: " << lim::min() << ", max: " << lim::max()
+            << std::endl;
+
+  BOOST_TEST(lim::is_specialized);
+  BOOST_TEST(lim::is_integer);
+  // BOOST_TEST(lim::is_modulo);
+}
+
+template <class T>
+void print_hex_val(T t, const char* name)
+{
+  const unsigned char* p = (const unsigned char*)&t;
+  std::cout << "hex value of " << name << " is: ";
+  for (unsigned int i = 0; i < sizeof(T); ++i) {
+    if(p[i] <= 0xF)
+      std::cout << "0";
+    std::cout << std::hex << (int)p[i];
+  }
+  std::cout << std::dec << std::endl;
+}
+
+template<class T>
+void test_float_limits(const T &, const char * msg)
+{
+  std::cout << "\nTesting " << msg << std::endl;
+  typedef std::numeric_limits<T> lim;
+
+  BOOST_TEST(lim::is_specialized);
+  BOOST_TEST(!lim::is_modulo);
+  BOOST_TEST(!lim::is_integer);
+  BOOST_TEST(lim::is_signed);
+  
+  BOOST_TEST(lim::epsilon() > 0);
+
+  BOOST_TEST(lim::has_infinity);
+  BOOST_TEST(lim::has_quiet_NaN);
+  BOOST_TEST(lim::has_signaling_NaN);
+  
+  const T infinity = lim::infinity();
+  const T qnan = lim::quiet_NaN();
+  const T snan = lim::signaling_NaN();
+
+  // make sure those values are not 0 or similar nonsense
+
+  std::cout << "IEEE-compatible: " << lim::is_iec559
+	    << ", traps: " << lim::traps
+	    << ", bounded: " << lim::is_bounded
+	    << ", exact: " << lim::is_exact << '\n'
+	    << "min: " << lim::min() << ", max: " << lim::max() << '\n'
+	    << "infinity: " << infinity << ", QNaN: " << qnan << '\n';
+  print_hex_val(lim::max(), "max");
+  print_hex_val(infinity, "infinity");
+  print_hex_val(qnan, "qnan");
+  print_hex_val(snan, "snan");
+
+  // infinity is beyond the representable range
+  BOOST_TEST(lim::max() > 1000);
+  BOOST_TEST(lim::infinity() > lim::max());
+  BOOST_TEST(-lim::infinity() < -lim::max());
+  BOOST_TEST(lim::min() < 0.001);
+  BOOST_TEST(lim::min() > 0);
+
+  // NaNs shall always compare "false" when compared for equality
+  // If one of these fail, your compiler may be optimizing incorrectly
+  BOOST_TEST(! (qnan == 42));
+  BOOST_TEST(! (qnan == qnan));
+  BOOST_TEST(qnan != 42);
+  BOOST_TEST(qnan != qnan);
+
+  // The following tests may cause arithmetic traps etc. Avoid for now.
+  // BOOST_TEST(! (qnan < 42));
+  // BOOST_TEST(! (qnan > 42));
+  // BOOST_TEST(! (qnan <= 42));
+  // BOOST_TEST(! (qnan >= 42));
+}
+
+
+int test_main(int, char*[])
+{
+  test_integral_limits(bool(), "bool");
+  test_integral_limits(char(), "char");
+  typedef signed char signed_char;
+  test_integral_limits(signed_char(), "signed char");
+  typedef unsigned char unsigned_char;
+  test_integral_limits(unsigned_char(), "unsigned char");
+  test_integral_limits(wchar_t(), "wchar_t");
+  test_integral_limits(short(), "short");
+  typedef unsigned short unsigned_short;
+  test_integral_limits(unsigned_short(), "unsigned short");
+  test_integral_limits(int(), "int");
+  typedef unsigned int unsigned_int;
+  test_integral_limits(unsigned_int(), "unsigned int");
+  test_integral_limits(long(), "long");
+  typedef unsigned long unsigned_long;
+  test_integral_limits(unsigned_long(), "unsigned long");
+#ifdef __GNUC__
+  typedef long long long_long;
+  test_integral_limits(long_long(), "long long");
+  typedef unsigned long long unsigned_long_long;
+  test_integral_limits(unsigned_long_long(), "unsigned long long");
+#endif
+
+  test_float_limits(float(), "float");
+  test_float_limits(double(), "double");
+  typedef long double long_double;
+  test_float_limits(long_double(), "long double");
+  // Some compilers don't pay attention to std:3.6.1/5 and issue a
+  // warning here if "return 0;" is omitted.
+  return 0;
+}
+