This commit was manufactured by cvs2svn to create tag

'Version_1_20_2'.

[SVN r9073]

config_test.cpp

@@ -1,4 +1,4 @@
-//  Boost config.hpp configuration test program file  -----------------------//
+//  Boost config.hpp configuration test program file  ------------------------------//
 
 //  (C) Copyright Boost.org 2000. Permission to copy, use, modify, sell and
 //  distribute this software is granted provided this copyright notice appears
@@ -11,14 +11,10 @@
 #include <iostream>
 
 using std::cout;
-using std::hex;
-using std::dec;
 
 int main()
 {
 
-  // boost compiler workaround defines
-
 #   ifdef BOOST_NO_DEPENDENT_TYPES_IN_TEMPLATE_VALUE_PARAMETERS
         cout << "BOOST_NO_DEPENDENT_TYPES_IN_TEMPLATE_VALUE_PARAMETERS defined\n";
 #   endif
@@ -67,37 +63,10 @@ int main()
         cout << "BOOST_SYSTEM_HAS_STDINT_H defined\n";
 #   endif
 
-
-  // compilers
-
 #   ifdef __GNUC__
         cout << "__GNUC__ defined as " << __GNUC__ << "\n";
 #   endif
 
-#   ifdef __GNUC_MINOR__
-        cout << "__GNUC_MINOR__ defined as " << __GNUC_MINOR__ << "\n";
-#   endif
-
-#   ifdef __EDG_VERSION__
-        cout << "__EDG_VERSION__ defined as " << __EDG_VERSION__ << "\n";
-#   endif
-
-#   ifdef __ICC
-        cout << "__ICC defined as " << __ICC << "\n";
-#   endif
-
-#   ifdef __ICL
-        cout << "__ICL defined as " << __ICL << "\n";
-#   endif
-
-#   ifdef __INTEL_COMPILER
-        cout << "__INTEL_COMPILER defined as " << __INTEL_COMPILER << "\n";
-#   endif
-
-#   ifdef __USLC__
-        cout << "__USLC__ defined\n";
-#   endif
-
 #   ifdef __BORLANDC__
         cout << "__BORLANDC__ defined as " << __BORLANDC__ << "\n";
 #   endif
@@ -110,20 +79,6 @@ int main()
         cout << "__SUNPRO_CC defined as " << __SUNPRO_CC << "\n";
 #   endif
 
-#   ifdef __sgi
-        cout << "__sgi is defined\n";
-#     ifdef _COMPILER_VERSION
-        cout << "_COMPILER_VERSION defined as " << _COMPILER_VERSION << "\n";
-#     endif
-#   endif
-
-#   ifdef __DECCXX
-        cout << "__DECCXX defined\n";
-#     ifdef __DECCXX_VER
-        cout << "__DECCXX_VER defined as " << __DECCXX_VER << "\n";
-#     endif
-#   endif
-
 #   ifdef _MSC_VER
         cout << "_MSC_VER defined as " << _MSC_VER << "\n";
 #   endif
@@ -140,28 +95,8 @@ int main()
         cout << "BOOST_MSVC_STD_ITERATOR defined\n";
 #   endif
 
-
-  // libraries
-
 #   ifdef __SGI_STL_PORT
-        cout << "__SGI_STL_PORT defined as 0x"
-             << hex << __SGI_STL_PORT << dec << "\n";
-#   endif
-
-#   ifdef __GLIBCPP__
-        cout << "__GLIBCPP__ defined\n";
-#   endif
-
-#   ifdef _GLIBCPP_VERSION
-        cout << "_GLIBCPP_VERSION defined as " << _GLIBCPP_VERSION << "\n";
-#   endif
-
-#   ifdef _GLIBCPP_USE_LONG_LONG
-        cout << "_GLIBCPP_USE_LONG_LONG defined\n";
-#   endif
-
-#   ifdef _GLIBCPP_USE_WCHAR_T
-        cout << "_GLIBCPP_USE_WCHAR_T defined\n";
+        cout << "__SGI_STL_PORT defined\n";
 #   endif
 
 #   ifdef __STL_NO_NAMESPACES
@@ -176,9 +111,5 @@ int main()
         cout << "__STL_IMPORT_VENDOR_CSTD defined\n";
 #   endif
 
-#   ifdef _RWSTD_VER
-        cout << "_RWSTD_VER defined as " << _RWSTD_VER << "\n";
-#   endif
-
     return 0;
 }

include/boost/config.hpp

@@ -11,14 +11,6 @@
 //  http://www.boost.org/libs/config
 
 //  Revision History (excluding minor changes for specific compilers)
-//   29 Mar 01  BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS (Daryle Walker)
-//   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)
@@ -59,13 +51,6 @@
 #ifndef BOOST_CONFIG_HPP
 #define BOOST_CONFIG_HPP
 
-#define BOOST_VERSION 102300
-
-//  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 
@@ -74,12 +59,6 @@
 //  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]
@@ -88,9 +67,6 @@
 //  parameters cannot have a dependent type, for example
 //  "template<class T, typename T::type value> class X { ... };"
 
-//  BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS: Can only use deduced
-//  template arguments when calling function template instantiations.
-
 //  BOOST_NO_INCLASS_MEMBER_INITIALIZATION: Compiler violates std::9.4.2/4. 
 
 //  BOOST_NO_INT64_T: <boost/cstdint.hpp> does not support 64-bit integer
@@ -148,23 +124,6 @@
 //  BOOST_NO_AUTO_PTR: If the compiler / library supplies non-standard or broken
 //  std::auto_ptr.
 
-//  BOOST_WEAK_FUNCTION_TEMPLATE_ORDERING: The compiler does not perform 
-//  function template ordering or its function template ordering is incorrect.
-//  
-//  template<typename T> void f(T); // #1
-//  template<typename T, typename U> void f(T (*)(U)); // #2
-//  void bar(int);
-//  f(&bar); // should choose #2. 
-
-//  BOOST_NO_DEPENDENT_NESTED_DERIVATIONS: The compiler fails to compile
-//  a nested class that has a dependent base class:
-//  template<typename T>
-//  struct foo : public T {  
-//    template<typename U>
-//    struct bar : public T, public U {};
-//  };
-
-//  
 //  Compiler Control or Information Macros  ----------------------------------//
 //
 //  Compilers often supply features outside of the C++ Standard which need to be
@@ -235,29 +194,82 @@
 //  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  ------------------//
+//  Compilers are listed in alphabetic order (except VC++ last - see below)---//
 
-//  Edison Design Group front-ends
-# if defined(__EDG_VERSION__)
-#   if __EDG_VERSION__ <= 241
+//  GNU CC (also known as GCC and G++)  --------------------------------------//
+
+# if defined __GNUC__
+#   if __GNUC__ == 2 && __GNUC_MINOR__ == 91
+       // 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
+#       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__ > 95) || __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++ ------------------------------------------------------------------//
+
+#elif defined __KCC
+#   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
+
+#   if defined(__EDG_VERSION__) && __EDG_VERSION__ <= 240
 #     define BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
 #   endif
 
-# endif
+//  Compaq Tru64 Unix cxx ---------------------------------------------------
 
-//  Compiler-specific checks -------------------------------------------------//
-//  Compilers are listed in alphabetic order by vendor name
-//  (except VC++ must be last - see below)
+#elif defined __DECCXX
+
+#   if defined(__EDG_VERSION__) && __EDG_VERSION__ <= 240
+#     define BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
+#   endif
+
+//  Greenhills C++ -----------------------------------------------------------//
+
+#elif defined __ghs
+#   define BOOST_NO_SLIST
+#   define BOOST_NO_HASH
 
 //  Borland ------------------------------------------------------------------//
 
-#if defined __BORLANDC__
+#elif defined __BORLANDC__
 #   define BOOST_NO_SLIST
 #   define BOOST_NO_HASH
 // pull in standard library version:
 #   include <memory>
 #   if __BORLANDC__ <= 0x0551
-#     define BOOST_NO_DEPENDENT_NESTED_DERIVATIONS
 #     define BOOST_NO_INTEGRAL_INT64_T
 #     define BOOST_NO_PRIVATE_IN_AGGREGATE
 #   endif
@@ -286,105 +298,15 @@
 // 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
 
-// Comeau C++ ----------------------------------------------------------------//
-
-# elif defined __COMO__
-#   if __COMO_VERSION__ <= 4245
-#     define BOOST_FUNCTION_USE_VIRTUAL_FUNCTIONS
-#   endif
-
-//  Compaq Tru64 Unix cxx ---------------------------------------------------
-
-# elif defined __DECCXX
-#   define BOOST_NO_SLIST
-#   define BOOST_NO_HASH
-
-//  GNU CC (also known as GCC and G++)  --------------------------------------//
-
-# elif defined __GNUC__
-#   if __GNUC__ == 2 && __GNUC_MINOR__ == 91
-       // egcs 1.1 won't parse smart_ptr.hpp without this:
-#      define BOOST_NO_AUTO_PTR
-#   endif
-#   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
-#     define BOOST_WEAK_FUNCTION_TEMPLATE_ORDERING
-#   endif
-#   if __GNUC__ == 2 && __GNUC_MINOR__ <= 8
-#     define BOOST_NO_MEMBER_TEMPLATES
-#   endif
-#   if __GNUC__ >= 3
-#     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
-
-//  Greenhills C++ -----------------------------------------------------------//
-
-#elif defined __ghs
-#   define BOOST_NO_SLIST
-#   define BOOST_NO_HASH
-
-//  HP aCC -------------------------------------------------------------------
-
-# elif defined __HP_aCC
-#    define BOOST_NO_SLIST
-#    define BOOST_NO_HASH
-#    define BOOST_NO_DEPENDENT_TYPES_IN_TEMPLATE_VALUE_PARAMETERS
-#    define BOOST_NO_OPERATORS_IN_NAMESPACE
-     // (support for HP aCC is not complete, see the regression test results)
-
-//  Intel on Linux -----------------------------------------------------------//
-
-#elif defined __ICC
-#   include <iterator>
-#   ifdef _CPPLIB_VER 
-      // shipped with Dinkumware 3.10, which has a different hash_map
-#     define BOOST_NO_HASH
-#   endif
-
-//  Intel on Windows --------------------------------------------------------//
+//  Intel  -------------------------------------------------------------------//
 
 # elif defined __ICL
-#   if __ICL <= 500
-      // Intel C++ 5.0.1 uses EDG 2.45, but fails to activate Koenig lookup
-      // in the frontend even in "strict" mode.  (reported by Kirk Klobe)
-#     ifndef BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
-#       define BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
-#     endif
-#     define BOOST_WEAK_FUNCTION_TEMPLATE_ORDERING
-#     define BOOST_NO_INTRINSIC_WCHAR_T // tentative addition - required for VC6 compatibility? (added by JM 19 Feb 2001)
-#   endif
 #   include <iterator>  // not sure this is the right way to do this -JGS
 #   if __SGI_STL_PORT >= 0x400 || __SGI_STL_PORT >= 0x321 && defined(__STL_USE_NAMESPACES)
         // a perfectly good implementation of std::iterator is supplied
 #   elif defined(__SGI_STL_ITERATOR)
 #     define BOOST_NO_STD_ITERATOR // No std::iterator in this case
-#   elif defined(_CPPLIB_VER) && (_CPPLIB_VER >= 306)
-#     // full dinkumware 3.06 and above
-#     define BOOST_NO_HASH
-#     define BOOST_NO_STD_ITERATOR_TRAITS
-#     if !_GLOBAL_USING   // can be defined in yvals.h
-#       define BOOST_NO_STDC_NAMESPACE
-#     endif
 #   else // assume using dinkumware's STL that comes with VC++ 6.0
 #     define BOOST_MSVC_STD_ITERATOR
 #     define BOOST_NO_STD_ITERATOR_TRAITS
@@ -396,31 +318,15 @@
 #     define BOOST_NO_STD_MIN_MAX
 #   endif
 
-//  Kai C++ ----------------------------------------------------------------
 
-#elif defined __KCC
-#   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
- 
-//  Metrowerks CodeWarrior  -------------------------------------------------//
+//  Metrowerks CodeWarrior  --------------------------------------------------//
 
 # elif defined  __MWERKS__
-#   if __MWERKS__ <= 0x2401  // 6.2
+#   if __MWERKS__ <= 0x4000
 #     define BOOST_NO_MEMBER_TEMPLATE_FRIENDS
-#     define BOOST_WEAK_FUNCTION_TEMPLATE_ORDERING
 #   endif
-#   if __MWERKS__ <= 0x2301  // 5.3
+#   if __MWERKS__ <= 0x2301
 #     define BOOST_NO_POINTER_TO_MEMBER_CONST
-#     define BOOST_NO_DEPENDENT_TYPES_IN_TEMPLATE_VALUE_PARAMETERS
-#     define BOOST_NO_HASH
-#   endif
-#   if __MWERKS__ >= 0x2400
-#     define BOOST_STD_EXTENSION_NAMESPACE Metrowerks
 #   endif
 #   if __MWERKS__ >= 0x2300
 #     define BOOST_SYSTEM_HAS_STDINT_H
@@ -436,43 +342,22 @@
 #     define BOOST_DECL
 #   endif
 
-//  SGI MIPSpro C++ ---------------------------------------------------------//
+#   define BOOST_STD_EXTENSION_NAMESPACE Metrowerks
 
-# elif defined __sgi
-    // This is a generic STLport condition and could be moved elsewhere.
-#   include <iterator>
-#   if defined(__SGI_STL_PORT) && !defined(__STL_MEMBER_TEMPLATE_CLASSES) && !defined(_STLP_MEMBER_TEMPLATE_CLASSES)
-#     define BOOST_NO_STD_ALLOCATOR
-#   endif
-
-//  Sun Workshop Compiler C++ -----------------------------------------------//
+//  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
-#      define BOOST_NO_STD_ALLOCATOR
-
-       // although sunpro 5.1 supports the syntax for
-       // inline initialization it often gets the value
-       // wrong, especially where the value is computed
-       // from other constants (J Maddock 6th May 2001)
-#      define BOOST_NO_INCLASS_MEMBER_INITIALIZATION
-
-       // although sunpro 5.1 supports the syntax for
-       // partial specialization, it often seems to
-       // bind to the wrong specialization.  Better
-       // to disable it until suppport becomes more stable
-       // (J Maddock 6th May 2001).
-#      define BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 #    endif
 #    if __SUNPRO_CC <= 0x500
 #      define BOOST_NO_MEMBER_TEMPLATES
 #      define BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 #    endif
 
-//  Microsoft Visual C++ (excluding Intel/EDG front end)  --------------------
+//  Microsoft Visual C++ (excluding Intel/EDG front end)  --------------------//
 //
 //  Must remain the last #elif since some other vendors (Metrowerks, for
 //  example) also #define _MSC_VER
@@ -488,7 +373,6 @@
 #     define BOOST_NO_INCLASS_MEMBER_INITIALIZATION
 #     define BOOST_NO_PRIVATE_IN_AGGREGATE
 #     define BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
-#     define BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS
 
 #     define BOOST_NO_INTEGRAL_INT64_T
 #     define BOOST_NO_INTRINSIC_WCHAR_T
@@ -502,25 +386,14 @@
 #     define BOOST_NO_MEMBER_TEMPLATE_FRIENDS
 #     define BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 #     define BOOST_NO_DEPENDENT_TYPES_IN_TEMPLATE_VALUE_PARAMETERS
-#     define BOOST_WEAK_FUNCTION_TEMPLATE_ORDERING
+
 #     include <iterator>  // not sure this is the right way to do this -JGS
 #     if __SGI_STL_PORT >= 0x400 || __SGI_STL_PORT >= 0x321 && defined(__STL_USE_NAMESPACES)
         // a perfectly good implementation of std::iterator is supplied
-        // A conforming allocator is supplied, but the compiler cannot cope
-        // when using "rebind".  (Douglas Gregor)
-#       define BOOST_NO_STD_ALLOCATOR
 #     elif defined(__SGI_STL_ITERATOR)
 #       define BOOST_NO_STD_ITERATOR // No std::iterator in this case
-#     elif defined(_CPPLIB_VER) && (_CPPLIB_VER >= 306)
-        // full dinkumware 3.06 and above
-#       define BOOST_NO_HASH
-#       define BOOST_NO_STD_ITERATOR_TRAITS
-#       ifndef _GLOBAL_USING    // can be defined in yvals.h
-#         define BOOST_NO_STDC_NAMESPACE
-#       endif
-#       define BOOST_MSVC_STD_ITERATOR
 #     else
-#       define BOOST_MSVC_STD_ITERATOR
+#       define BOOST_MSVC_STD_ITERATOR 1
 #       define BOOST_NO_SLIST
 #       define BOOST_NO_HASH
 #       define BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS
@@ -538,7 +411,6 @@
 #       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
@@ -573,7 +445,9 @@
 
 //  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 && defined(__STL_STATIC_CONST_INIT_BUG))
+#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.
@@ -584,11 +458,6 @@
 #   define BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
 #endif
 
-#if defined(__hpux)
-// HP-UX has a nice stdint.h in a different location, see boost/cstdint.hpp
-# define BOOST_SYSTEM_HAS_STDINT_H
-#endif
-
 #ifndef BOOST_STD_EXTENSION_NAMESPACE
 # define BOOST_STD_EXTENSION_NAMESPACE std
 #endif
@@ -636,22 +505,6 @@ 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

@@ -1,443 +0,0 @@
-/*
- * 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__) || defined(__hppa)
-#define BOOST_BIG_ENDIAN
-#elif !defined(__i386__)
-#error The file boost/detail/limits.hpp needs to be 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 BOOST_NO_INTRINSIC_WCHAR_T
-#if !defined(WCHAR_MAX) || !defined(WCHAR_MIN)
-#if !defined(_WIN32) && !defined(__CYGWIN__)
-template<>
-class numeric_limits<wchar_t>
-  : public _Integer_limits<wchar_t, INT_MIN, INT_MAX>
-{};
-#else
-template<>
-class numeric_limits<wchar_t>
-  : public _Integer_limits<wchar_t, 0, USHRT_MAX>
-{};
-#endif
-#else
-template<>
-class numeric_limits<wchar_t>
-  : public _Integer_limits<wchar_t, WCHAR_MIN, WCHAR_MAX>
-{};
-#endif
-#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

@@ -1,20 +0,0 @@
-
-//  (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

@@ -0,0 +1,407 @@
+/** -*- 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 */

index.htm

@@ -79,10 +79,8 @@ be self documenting.</p>
 <h2>Test program</h2>
 <p>The <a href="config_test.cpp">config_test.cpp</a> program can be used to
 verify which #defines are in effect for your compiler.</p>
-<p>The <a href="limits_test.cpp">limits_test.cpp</a> program can also be helpful
-in diagnosing configuration problems.</p>
 <hr>
-<p>Revised <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %b %Y" startspan -->22 May 2001<!--webbot bot="Timestamp" endspan i-checksum="15106" --></p>
+<p>Revised <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %b %Y" startspan -->10 Nov 2000<!--webbot bot="Timestamp" endspan i-checksum="15233" --></p>
 
 </body>
 

limits_test.cpp

@@ -1,158 +0,0 @@
-/* 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 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,
- *
- * 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);
-  
-  const T infinity = lim::infinity();
-  const T qnan = lim::quiet_NaN();
-  const T snan = lim::signaling_NaN();
-
-  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");
-
-  BOOST_TEST(lim::max() > 1000);
-  BOOST_TEST(lim::min() > 0);
-  BOOST_TEST(lim::min() < 0.001);
-  BOOST_TEST(lim::epsilon() > 0);
-
-  if(lim::is_iec559) {
-    BOOST_TEST(lim::has_infinity);
-    BOOST_TEST(lim::has_quiet_NaN);
-    BOOST_TEST(lim::has_signaling_NaN);
-  } else {
-    std::cout << "Does not claim IEEE conformance" << std::endl;
-  }
-
-  if(lim::has_infinity) {
-    // make sure those values are not 0 or similar nonsense
-    // infinity is beyond the representable range
-    BOOST_TEST(infinity > lim::max());
-    BOOST_TEST(-infinity < -lim::max());
-  } else {
-    std::cout << "Does not have infinity" << std::endl;
-  }
- 
-  if(lim::has_quiet_NaN) { 
-    // 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));
-  } else {
-    std::cout << "Does not have QNaN" << std::endl;
-  }
-}
-
-
-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");
-#if defined(__GNUC__) && !(__GNUC__ == 3 && __GNUC_MINOR__ == 0 && defined(__GLIBCPP__))
-  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;
-}
-