boost library updated to 1.45

include/boost/boost_version.txt

-boost version: 1_44_0
+boost version: 1_45_0

include/boost/concept_check.hpp

 //
 // (C) Copyright Jeremy Siek 2000.
+// Copyright 2002 The Trustees of Indiana University.
+//
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
@@ -999,6 +1001,42 @@ namespace boost
 
   // HashedAssociativeContainer
 
+  BOOST_concept(Collection,(C))
+  {
+      BOOST_CONCEPT_USAGE(Collection)
+      {
+        boost::function_requires<boost::InputIteratorConcept<iterator> >();
+        boost::function_requires<boost::InputIteratorConcept<const_iterator> >();
+        boost::function_requires<boost::CopyConstructibleConcept<value_type> >();
+        const_constraints(c);
+        i = c.begin();
+        i = c.end();
+        c.swap(c);
+      }
+
+      void const_constraints(const C& c) {
+        ci = c.begin();
+        ci = c.end();
+        n = c.size();
+        b = c.empty();
+      }
+
+    private:
+      typedef typename C::value_type value_type;
+      typedef typename C::iterator iterator;
+      typedef typename C::const_iterator const_iterator;
+      typedef typename C::reference reference;
+      typedef typename C::const_reference const_reference;
+      // typedef typename C::pointer pointer;
+      typedef typename C::difference_type difference_type;
+      typedef typename C::size_type size_type;
+
+      C c;
+      bool b;
+      iterator i;
+      const_iterator ci;
+      size_type n;
+  };
 } // namespace boost
 
 # include <boost/concept/detail/concept_undef.hpp>

include/boost/config/auto_link.hpp

@@ -362,7 +362,7 @@ BOOST_LIB_VERSION:    The Boost version, in the form x_y, for Boost version x.y.
       && defined(BOOST_LIB_VERSION)
 
 #ifdef BOOST_AUTO_LINK_TAGGED
-#  pragma commentcomment(lib, BOOST_LIB_PREFIX BOOST_STRINGIZE(BOOST_LIB_NAME) BOOST_LIB_THREAD_OPT BOOST_LIB_RT_OPT ".lib")
+#  pragma comment(lib, BOOST_LIB_PREFIX BOOST_STRINGIZE(BOOST_LIB_NAME) BOOST_LIB_THREAD_OPT BOOST_LIB_RT_OPT ".lib")
 #  ifdef BOOST_LIB_DIAGNOSTIC
 #     pragma message ("Linking to lib file: " BOOST_LIB_PREFIX BOOST_STRINGIZE(BOOST_LIB_NAME) "-" BOOST_LIB_TOOLSET BOOST_LIB_THREAD_OPT BOOST_LIB_RT_OPT "-" BOOST_LIB_VERSION ".lib")
 #  endif

include/boost/config/compiler/borland.hpp

@@ -46,6 +46,8 @@
 // Borland C++Builder 5, command-line compiler 5.5:
 #       define BOOST_NO_OPERATORS_IN_NAMESPACE
 #     endif
+// Variadic macros do not exist for C++ Builder versions 5 and below
+#define BOOST_NO_VARIADIC_MACROS
 #   endif
 
 // Version 5.51 and below:

include/boost/config/compiler/clang.hpp

@@ -48,6 +48,7 @@
 #define BOOST_NO_TEMPLATE_ALIASES
 #define BOOST_NO_UNICODE_LITERALS
 #define BOOST_NO_VARIADIC_TEMPLATES
+#define BOOST_NO_VARIADIC_MACROS
 
 // HACK: Clang does support extern templates, but Boost's test for
 // them is wrong.

include/boost/config/compiler/common_edg.hpp

@@ -88,12 +88,10 @@
 #define BOOST_NO_TEMPLATE_ALIASES
 #define BOOST_NO_UNICODE_LITERALS
 #define BOOST_NO_VARIADIC_TEMPLATES
+#define BOOST_NO_VARIADIC_MACROS
 
 #ifdef c_plusplus
 // EDG has "long long" in non-strict mode
 // However, some libraries have insufficient "long long" support
 // #define BOOST_HAS_LONG_LONG
 #endif
-
-
-

include/boost/config/compiler/digitalmars.hpp

@@ -80,6 +80,9 @@
 #define BOOST_NO_TEMPLATE_ALIASES
 #define BOOST_NO_UNICODE_LITERALS
 #define BOOST_NO_VARIADIC_TEMPLATES
+#if (__DMC__ < 0x812)
+#define BOOST_NO_VARIADIC_MACROS
+#endif
 
 #if __DMC__ < 0x800
 #error "Compiler not supported or configured - please reconfigure"

include/boost/config/compiler/gcc.hpp

@@ -43,6 +43,8 @@
 #   define BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL
 #   define BOOST_NO_IS_ABSTRACT
 #   define BOOST_NO_EXTERN_TEMPLATE
+// Variadic macros do not exist for gcc versions before 3.0
+#   define BOOST_NO_VARIADIC_MACROS
 #elif __GNUC__ == 3
 #  if defined (__PATHSCALE__)
 #     define BOOST_NO_TWO_PHASE_NAME_LOOKUP
@@ -113,7 +115,7 @@
 // Dynamic shared object (DSO) and dynamic-link library (DLL) support
 //
 #if __GNUC__ >= 4
-#  if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
+#  if (defined(_WIN32) || defined(__WIN32__) || defined(WIN32)) && !defined(__CYGWIN__)
      // All Win32 development environments, including 64-bit Windows and MinGW, define 
      // _WIN32 or one of its variant spellings. Note that Cygwin is a POSIX environment,
      // so does not define _WIN32 or its variants.

include/boost/config/compiler/gcc_xml.hpp

@@ -35,6 +35,7 @@
 #  define BOOST_NO_RVALUE_REFERENCES
 #  define BOOST_NO_STATIC_ASSERT
 #  define BOOST_NO_VARIADIC_TEMPLATES
+#  define BOOST_NO_VARIADIC_MACROS
 #  define BOOST_NO_AUTO_DECLARATIONS
 #  define BOOST_NO_AUTO_MULTIDECLARATIONS
 #  define BOOST_NO_CHAR16_T

include/boost/config/compiler/hp_acc.hpp

@@ -115,6 +115,16 @@
 #define BOOST_NO_TEMPLATE_ALIASES
 #define BOOST_NO_UNICODE_LITERALS
 #define BOOST_NO_VARIADIC_TEMPLATES
+
+/* 
+  See https://forums13.itrc.hp.com/service/forums/questionanswer.do?threadId=1443331 and
+      https://forums13.itrc.hp.com/service/forums/questionanswer.do?threadId=1443436
+*/
+
+#if (__HP_aCC < 62500) || !defined(HP_CXX0x_SOURCE)
+  #define BOOST_NO_VARIADIC_MACROS
+#endif
+
 #endif
 
 //

include/boost/config/compiler/metrowerks.hpp

@@ -114,6 +114,7 @@
 #define BOOST_NO_TEMPLATE_ALIASES
 #define BOOST_NO_UNICODE_LITERALS
 #define BOOST_NO_VARIADIC_TEMPLATES
+#define BOOST_NO_VARIADIC_MACROS
 
 #define BOOST_COMPILER "Metrowerks CodeWarrior C++ version " BOOST_STRINGIZE(BOOST_COMPILER_VERSION)
 

include/boost/config/compiler/mpw.hpp

@@ -63,6 +63,7 @@
 #define BOOST_NO_TEMPLATE_ALIASES
 #define BOOST_NO_UNICODE_LITERALS
 #define BOOST_NO_VARIADIC_TEMPLATES
+#define BOOST_NO_VARIADIC_MACROS
 
 //
 // versions check:

include/boost/config/compiler/nvcc.hpp

@@ -37,6 +37,7 @@
 #define BOOST_HAS_DIRENT_H
 #define BOOST_HAS_CLOCK_GETTIME
 #define BOOST_NO_VARIADIC_TEMPLATES
+#define BOOST_NO_VARIADIC_MACROS
 #define BOOST_NO_UNICODE_LITERALS
 #define BOOST_NO_TEMPLATE_ALIASES
 #define BOOST_NO_STD_UNORDERED

include/boost/config/compiler/pgi.hpp

@@ -70,6 +70,7 @@
 #define BOOST_NO_TEMPLATE_ALIASES
 #define BOOST_NO_UNICODE_LITERALS
 #define BOOST_NO_VARIADIC_TEMPLATES
+#define BOOST_NO_VARIADIC_MACROS
 
 //
 // version check:

include/boost/config/compiler/sunpro_cc.hpp

@@ -122,6 +122,7 @@
 #define BOOST_NO_TEMPLATE_ALIASES
 #define BOOST_NO_UNICODE_LITERALS
 #define BOOST_NO_VARIADIC_TEMPLATES
+#define BOOST_NO_VARIADIC_MACROS
 
 //
 // Version

include/boost/config/compiler/vacpp.hpp

@@ -91,6 +91,7 @@
 #define BOOST_NO_TEMPLATE_ALIASES
 #define BOOST_NO_UNICODE_LITERALS
 #define BOOST_NO_VARIADIC_TEMPLATES
+#define BOOST_NO_VARIADIC_MACROS
 
 
 

include/boost/config/compiler/visualc.hpp

@@ -81,6 +81,8 @@
 #  define BOOST_NO_SWPRINTF
 // Our extern template tests also fail for this compiler:
 #  define BOOST_NO_EXTERN_TEMPLATE
+// Variadic macros do not exist for VC7.1 and lower
+#  define BOOST_NO_VARIADIC_MACROS
 #endif
 
 #if defined(UNDER_CE)

include/boost/config/platform/bsd.hpp

@@ -56,7 +56,7 @@
 #endif
 
 #if !((defined(__FreeBSD__) && (__FreeBSD__ >= 5)) \
-      || (__NetBSD_GCC__ >= 2095003) || defined(__DragonFly__))
+      || (defined(__NetBSD_GCC__) && (__NetBSD_GCC__ >= 2095003)) || defined(__DragonFly__))
 #  define BOOST_NO_CWCHAR
 #endif
 //

include/boost/config/platform/cygwin.hpp

@@ -41,6 +41,13 @@
 
 // boilerplate code:
 #include <boost/config/posix_features.hpp>
+
+//
+// Cygwin lies about XSI conformance, there is no nl_types.h:
+//
+#ifdef BOOST_HAS_NL_TYPES_H
+#  undef BOOST_HAS_NL_TYPES_H
+#endif
  
 
 

include/boost/config/select_platform_config.hpp

@@ -69,6 +69,9 @@
 // Symbian: 
 #  define BOOST_PLATFORM_CONFIG "boost/config/platform/symbian.hpp" 
 
+#elif defined(__VMS) 
+// VMS:
+#  define BOOST_PLATFORM_CONFIG "boost/config/platform/vms.hpp" 
 #else
 
 #  if defined(unix) \

include/boost/config/stdlib/dinkumware.hpp

@@ -125,6 +125,7 @@
 #  define BOOST_NO_0X_HDR_MUTEX
 #  define BOOST_NO_0X_HDR_RATIO
 #  define BOOST_NO_0X_HDR_THREAD
+#  define BOOST_NO_NUMERIC_LIMITS_LOWEST
 
 #ifdef _CPPLIB_VER
 #  define BOOST_DINKUMWARE_STDLIB _CPPLIB_VER

include/boost/config/stdlib/libcomo.hpp

@@ -58,6 +58,7 @@
 #  define BOOST_NO_STD_UNORDERED        // deprecated; see following
 #  define BOOST_NO_0X_HDR_UNORDERED_MAP
 #  define BOOST_NO_0X_HDR_UNORDERED_SET
+#  define BOOST_NO_NUMERIC_LIMITS_LOWEST
 
 //
 // Intrinsic type_traits support.

include/boost/config/stdlib/libstdcpp3.hpp

@@ -115,6 +115,12 @@
 #  define BOOST_NO_0X_HDR_THREAD
 #endif
 
+//  C++0x features in GCC 4.5.0 and later
+//
+#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 5) || !defined(__GXX_EXPERIMENTAL_CXX0X__)
+#  define BOOST_NO_NUMERIC_LIMITS_LOWEST
+#endif
+
 //  C++0x headers not yet implemented
 //
 #  define BOOST_NO_0X_HDR_CODECVT

include/boost/config/stdlib/modena.hpp

@@ -47,6 +47,7 @@
 #  define BOOST_NO_STD_UNORDERED        // deprecated; see following
 #  define BOOST_NO_0X_HDR_UNORDERED_MAP
 #  define BOOST_NO_0X_HDR_UNORDERED_SET
+#  define BOOST_NO_NUMERIC_LIMITS_LOWEST
 
 #define BOOST_STDLIB "Modena C++ standard library"
 

include/boost/config/stdlib/msl.hpp

@@ -71,6 +71,7 @@
 #  define BOOST_NO_STD_UNORDERED        // deprecated; see following
 #  define BOOST_NO_0X_HDR_UNORDERED_MAP
 #  define BOOST_NO_0X_HDR_UNORDERED_SET
+#  define BOOST_NO_NUMERIC_LIMITS_LOWEST
 
 #define BOOST_STDLIB "Metrowerks Standard Library version " BOOST_STRINGIZE(__MSL_CPP__)
 

include/boost/config/stdlib/roguewave.hpp

@@ -177,4 +177,5 @@
 #  define BOOST_NO_STD_UNORDERED        // deprecated; see following
 #  define BOOST_NO_0X_HDR_UNORDERED_MAP
 #  define BOOST_NO_0X_HDR_UNORDERED_SET
+#  define BOOST_NO_NUMERIC_LIMITS_LOWEST
 

include/boost/config/stdlib/sgi.hpp

@@ -130,6 +130,7 @@
 #  define BOOST_NO_STD_UNORDERED        // deprecated; see following
 #  define BOOST_NO_0X_HDR_UNORDERED_MAP
 #  define BOOST_NO_0X_HDR_UNORDERED_SET
+#  define BOOST_NO_NUMERIC_LIMITS_LOWEST
 
 #define BOOST_STDLIB "SGI standard library"
 

include/boost/config/stdlib/stlport.hpp

@@ -225,6 +225,7 @@ namespace boost { using std::min; using std::max; }
 #  define BOOST_NO_STD_UNORDERED        // deprecated; see following
 #  define BOOST_NO_0X_HDR_UNORDERED_MAP
 #  define BOOST_NO_0X_HDR_UNORDERED_SET
+#  define BOOST_NO_NUMERIC_LIMITS_LOWEST
 
 #define BOOST_STDLIB "STLPort standard library version " BOOST_STRINGIZE(__SGI_STL_PORT)
 

include/boost/config/stdlib/vacpp.hpp

@@ -37,6 +37,7 @@
 #  define BOOST_NO_STD_UNORDERED        // deprecated; see following
 #  define BOOST_NO_0X_HDR_UNORDERED_MAP
 #  define BOOST_NO_0X_HDR_UNORDERED_SET
+#  define BOOST_NO_NUMERIC_LIMITS_LOWEST
 
 #define BOOST_STDLIB "Visual Age default standard library"
 

include/boost/config/suffix.hpp

@@ -25,6 +25,14 @@
 #ifndef BOOST_CONFIG_SUFFIX_HPP
 #define BOOST_CONFIG_SUFFIX_HPP
 
+#if defined(__GNUC__) && (__GNUC__ >= 4)
+//
+// Some GCC-4.x versions issue warnings even when __extension__ is used,
+// so use this as a workaround:
+//
+#pragma GCC system_header
+#endif
+
 //
 // ensure that visibility macros are always defined, thus symplifying use
 //

include/boost/detail/is_incrementable.hpp

@@ -70,10 +70,10 @@ namespace is_incrementable_
 # endif 
 
   // two check overloads help us identify which operator++ was picked
-  char (& check(tag) )[2];
+  char (& check_(tag) )[2];
   
   template <class T>
-  char check(T const&);
+  char check_(T const&);
   
 
   template <class T>
@@ -83,7 +83,7 @@ namespace is_incrementable_
 
       BOOST_STATIC_CONSTANT(
           bool
-        , value = sizeof(is_incrementable_::check(BOOST_comma(++x,0))) == 1
+        , value = sizeof(is_incrementable_::check_(BOOST_comma(++x,0))) == 1
       );
   };
 
@@ -94,7 +94,7 @@ namespace is_incrementable_
 
       BOOST_STATIC_CONSTANT(
           bool
-        , value = sizeof(is_incrementable_::check(BOOST_comma(x++,0))) == 1
+        , value = sizeof(is_incrementable_::check_(BOOST_comma(x++,0))) == 1
       );
   };
 

include/boost/detail/sp_typeinfo.hpp

@@ -74,7 +74,13 @@ template<class T> struct sp_typeid_
     }
 };
 
+#if defined(__SUNPRO_CC)
+// see #4199, the Sun Studio compiler gets confused about static initialization 
+// constructor arguments. But an assignment works just fine. 
 template<class T> sp_typeinfo sp_typeid_< T >::ti_ = sp_typeid_< T >::name();
+#else
+template<class T> sp_typeinfo sp_typeid_< T >::ti_(sp_typeid_< T >::name());
+#endif
 
 template<class T> struct sp_typeid_< T & >: sp_typeid_< T >
 {

include/boost/foreach.hpp

@@ -246,7 +246,7 @@ struct auto_any_base
 template<typename T>
 struct auto_any : auto_any_base
 {
-    auto_any(T const &t)
+    explicit auto_any(T const &t)
       : item(t)
     {
     }
@@ -606,7 +606,7 @@ should_copy_impl(boost::mpl::false_ *, boost::mpl::false_ *, bool *is_rvalue)
 template<typename T>
 inline auto_any<T> contain(T const &t, boost::mpl::true_ *) // rvalue
 {
-    return t;
+    return auto_any<T>(t);
 }
 
 template<typename T>
@@ -614,18 +614,18 @@ inline auto_any<T *> contain(T &t, boost::mpl::false_ *) // lvalue
 {
     // Cannot seem to get sunpro to handle addressof() with array types.
     #if BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x570))
-    return &t;
+    return auto_any<T *>(&t);
     #else
-    return boost::addressof(t);
+    return auto_any<T *>(boost::addressof(t));
     #endif
 }
 
 #ifdef BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION
 template<typename T>
-auto_any<simple_variant<T> >
+inline auto_any<simple_variant<T> >
 contain(T const &t, bool *rvalue)
 {
-    return *rvalue ? simple_variant<T>(t) : simple_variant<T>(&t);
+    return auto_any<simple_variant<T> >(*rvalue ? simple_variant<T>(t) : simple_variant<T>(&t));
 }
 #endif
 
@@ -636,7 +636,8 @@ template<typename T, typename C>
 inline auto_any<BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type>
 begin(auto_any_t col, type2type<T, C> *, boost::mpl::true_ *) // rvalue
 {
-    return boost::begin(auto_any_cast<T, C>(col));
+    return auto_any<BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type>(
+        boost::begin(auto_any_cast<T, C>(col)));
 }
 
 template<typename T, typename C>
@@ -645,15 +646,17 @@ begin(auto_any_t col, type2type<T, C> *, boost::mpl::false_ *) // lvalue
 {
     typedef BOOST_DEDUCED_TYPENAME type2type<T, C>::type type;
     typedef BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type iterator;
-    return iterator(boost::begin(derefof(auto_any_cast<type *, boost::mpl::false_>(col))));
+    return auto_any<BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type>(
+        iterator(boost::begin(derefof(auto_any_cast<type *, boost::mpl::false_>(col)))));
 }
 
 #ifdef BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION
 template<typename T>
-auto_any<BOOST_DEDUCED_TYPENAME foreach_iterator<T, const_>::type>
+inline auto_any<BOOST_DEDUCED_TYPENAME foreach_iterator<T, const_>::type>
 begin(auto_any_t col, type2type<T, const_> *, bool *)
 {
-    return boost::begin(*auto_any_cast<simple_variant<T>, boost::mpl::false_>(col).get());
+    return auto_any<BOOST_DEDUCED_TYPENAME foreach_iterator<T, const_>::type>(
+        boost::begin(*auto_any_cast<simple_variant<T>, boost::mpl::false_>(col).get()));
 }
 #endif
 
@@ -662,7 +665,7 @@ template<typename T, typename C>
 inline auto_any<T *>
 begin(auto_any_t col, type2type<T *, C> *, boost::mpl::true_ *) // null-terminated C-style strings
 {
-    return auto_any_cast<T *, boost::mpl::false_>(col);
+    return auto_any<T *>(auto_any_cast<T *, boost::mpl::false_>(col));
 }
 #endif
 
@@ -673,7 +676,8 @@ template<typename T, typename C>
 inline auto_any<BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type>
 end(auto_any_t col, type2type<T, C> *, boost::mpl::true_ *) // rvalue
 {
-    return boost::end(auto_any_cast<T, C>(col));
+    return auto_any<BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type>(
+        boost::end(auto_any_cast<T, C>(col)));
 }
 
 template<typename T, typename C>
@@ -682,15 +686,17 @@ end(auto_any_t col, type2type<T, C> *, boost::mpl::false_ *) // lvalue
 {
     typedef BOOST_DEDUCED_TYPENAME type2type<T, C>::type type;
     typedef BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type iterator;
-    return iterator(boost::end(derefof(auto_any_cast<type *, boost::mpl::false_>(col))));
+    return auto_any<BOOST_DEDUCED_TYPENAME foreach_iterator<T, C>::type>(
+        iterator(boost::end(derefof(auto_any_cast<type *, boost::mpl::false_>(col)))));
 }
 
 #ifdef BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION
 template<typename T>
-auto_any<BOOST_DEDUCED_TYPENAME foreach_iterator<T, const_>::type>
+inline auto_any<BOOST_DEDUCED_TYPENAME foreach_iterator<T, const_>::type>
 end(auto_any_t col, type2type<T, const_> *, bool *)
 {
-    return boost::end(*auto_any_cast<simple_variant<T>, boost::mpl::false_>(col).get());
+    return auto_any<BOOST_DEDUCED_TYPENAME foreach_iterator<T, const_>::type>(
+        boost::end(*auto_any_cast<simple_variant<T>, boost::mpl::false_>(col).get()));
 }
 #endif
 
@@ -699,7 +705,7 @@ template<typename T, typename C>
 inline auto_any<int>
 end(auto_any_t, type2type<T *, C> *, boost::mpl::true_ *) // null-terminated C-style strings
 {
-    return 0; // not used
+    return auto_any<int>(0); // not used
 }
 #endif
 
@@ -749,7 +755,8 @@ template<typename T, typename C>
 inline auto_any<BOOST_DEDUCED_TYPENAME foreach_reverse_iterator<T, C>::type>
 rbegin(auto_any_t col, type2type<T, C> *, boost::mpl::true_ *) // rvalue
 {
-    return boost::rbegin(auto_any_cast<T, C>(col));
+    return auto_any<BOOST_DEDUCED_TYPENAME foreach_reverse_iterator<T, C>::type>(
+        boost::rbegin(auto_any_cast<T, C>(col)));
 }
 
 template<typename T, typename C>
@@ -758,15 +765,17 @@ rbegin(auto_any_t col, type2type<T, C> *, boost::mpl::false_ *) // lvalue
 {
     typedef BOOST_DEDUCED_TYPENAME type2type<T, C>::type type;
     typedef BOOST_DEDUCED_TYPENAME foreach_reverse_iterator<T, C>::type iterator;
-    return iterator(boost::rbegin(derefof(auto_any_cast<type *, boost::mpl::false_>(col))));
+    return auto_any<BOOST_DEDUCED_TYPENAME foreach_reverse_iterator<T, C>::type>(
+        iterator(boost::rbegin(derefof(auto_any_cast<type *, boost::mpl::false_>(col)))));
 }
 
 #ifdef BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION
 template<typename T>
-auto_any<BOOST_DEDUCED_TYPENAME foreach_reverse_iterator<T, const_>::type>
+inline auto_any<BOOST_DEDUCED_TYPENAME foreach_reverse_iterator<T, const_>::type>
 rbegin(auto_any_t col, type2type<T, const_> *, bool *)
 {
-    return boost::rbegin(*auto_any_cast<simple_variant<T>, boost::mpl::false_>(col).get());
+    return auto_any<BOOST_DEDUCED_TYPENAME foreach_reverse_iterator<T, const_>::type>(
+        boost::rbegin(*auto_any_cast<simple_variant<T>, boost::mpl::false_>(col).get()));
 }
 #endif
 
@@ -778,7 +787,7 @@ rbegin(auto_any_t col, type2type<T *, C> *, boost::mpl::true_ *) // null-termina
     T *p = auto_any_cast<T *, boost::mpl::false_>(col);
     while(0 != *p)
         ++p;
-    return reverse_iterator<T *>(p);
+    return auto_any<reverse_iterator<T *> >(reverse_iterator<T *>(p));
 }
 #endif
 
@@ -789,7 +798,8 @@ template<typename T, typename C>
 inline auto_any<BOOST_DEDUCED_TYPENAME foreach_reverse_iterator<T, C>::type>
 rend(auto_any_t col, type2type<T, C> *, boost::mpl::true_ *) // rvalue
 {
-    return boost::rend(auto_any_cast<T, C>(col));
+    return auto_any<BOOST_DEDUCED_TYPENAME foreach_reverse_iterator<T, C>::type>(
+        boost::rend(auto_any_cast<T, C>(col)));
 }
 
 template<typename T, typename C>
@@ -798,15 +808,17 @@ rend(auto_any_t col, type2type<T, C> *, boost::mpl::false_ *) // lvalue
 {
     typedef BOOST_DEDUCED_TYPENAME type2type<T, C>::type type;
     typedef BOOST_DEDUCED_TYPENAME foreach_reverse_iterator<T, C>::type iterator;
-    return iterator(boost::rend(derefof(auto_any_cast<type *, boost::mpl::false_>(col))));
+    return auto_any<BOOST_DEDUCED_TYPENAME foreach_reverse_iterator<T, C>::type>(
+        iterator(boost::rend(derefof(auto_any_cast<type *, boost::mpl::false_>(col)))));
 }
 
 #ifdef BOOST_FOREACH_RUN_TIME_CONST_RVALUE_DETECTION
 template<typename T>
-auto_any<BOOST_DEDUCED_TYPENAME foreach_reverse_iterator<T, const_>::type>
+inline auto_any<BOOST_DEDUCED_TYPENAME foreach_reverse_iterator<T, const_>::type>
 rend(auto_any_t col, type2type<T, const_> *, bool *)
 {
-    return boost::rend(*auto_any_cast<simple_variant<T>, boost::mpl::false_>(col).get());
+    return auto_any<BOOST_DEDUCED_TYPENAME foreach_reverse_iterator<T, const_>::type>(
+        boost::rend(*auto_any_cast<simple_variant<T>, boost::mpl::false_>(col).get()));
 }
 #endif
 
@@ -815,7 +827,8 @@ template<typename T, typename C>
 inline auto_any<reverse_iterator<T *> >
 rend(auto_any_t col, type2type<T *, C> *, boost::mpl::true_ *) // null-terminated C-style strings
 {
-    return reverse_iterator<T *>(auto_any_cast<T *, boost::mpl::false_>(col));
+    return auto_any<reverse_iterator<T *> >(
+        reverse_iterator<T *>(auto_any_cast<T *, boost::mpl::false_>(col)));
 }
 #endif
 

include/boost/polygon/detail/scan_arbitrary.hpp

@@ -192,6 +192,8 @@ namespace boost { namespace polygon{
             if(pack_.compute_intersection(intersection, he1, he2)) {
               //their intersection point
               pts.push_back(intersection);
+              intersection_points[(*inner).second].insert(intersection);
+              intersection_points[(*outer).second].insert(intersection);
             } 
           }
         }

include/boost/ptr_container/detail/serialize_ptr_map_adapter.hpp

@@ -9,6 +9,7 @@
 #include <boost/ptr_container/ptr_map_adapter.hpp>
 #include <boost/ptr_container/detail/serialize_xml_names.hpp>
 #include <boost/serialization/split_free.hpp>
+#include <boost/serialization/nvp.hpp> 
 
 namespace boost 
 {

include/boost/ptr_container/detail/serialize_reversible_cont.hpp

@@ -9,6 +9,7 @@
 #include <boost/ptr_container/detail/reversible_ptr_container.hpp>
 #include <boost/ptr_container/detail/serialize_xml_names.hpp>
 #include <boost/serialization/split_free.hpp>
+#include <boost/serialization/nvp.hpp>
 
 namespace boost 
 {

include/boost/smart_ptr/detail/sp_convertible.hpp

@@ -45,7 +45,7 @@ template< class Y, class T > struct sp_convertible
     static yes f( T* );
     static no  f( ... );
 
-    enum _vt { value = sizeof( f( static_cast<Y*>(0) ) ) == sizeof(yes) };
+    enum _vt { value = sizeof( (f)( static_cast<Y*>(0) ) ) == sizeof(yes) };
 };
 
 struct sp_empty

include/boost/smart_ptr/detail/yield_k.hpp

@@ -55,7 +55,7 @@ namespace detail
 {
 
 #if !defined( BOOST_USE_WINDOWS_H )
-  extern "C" void __stdcall Sleep( unsigned ms );
+  extern "C" void __stdcall Sleep( unsigned long ms );
 #endif
 
 inline void yield( unsigned k )

include/boost/type_traits/intrinsics.hpp

@@ -159,6 +159,33 @@
 #   define BOOST_HAS_TYPE_TRAITS_INTRINSICS
 #endif
 
+#if defined(__ghs__) && (__GHS_VERSION_NUMBER >= 600)
+#   include <boost/type_traits/is_same.hpp>
+#   include <boost/type_traits/is_reference.hpp>
+#   include <boost/type_traits/is_volatile.hpp>
+
+#   define BOOST_IS_UNION(T) __is_union(T)
+#   define BOOST_IS_POD(T) __is_pod(T)
+#   define BOOST_IS_EMPTY(T) __is_empty(T)
+#   define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) __has_trivial_constructor(T)
+#   define BOOST_HAS_TRIVIAL_COPY(T) (__has_trivial_copy(T) && !is_reference<T>::value)
+#   define BOOST_HAS_TRIVIAL_ASSIGN(T) __has_trivial_assign(T)
+#   define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) __has_trivial_destructor(T)
+#   define BOOST_HAS_NOTHROW_CONSTRUCTOR(T) __has_nothrow_constructor(T)
+#   define BOOST_HAS_NOTHROW_COPY(T) (__has_nothrow_copy(T) && !is_volatile<T>::value && !is_reference<T>::value)
+#   define BOOST_HAS_NOTHROW_ASSIGN(T) (__has_nothrow_assign(T) && !is_volatile<T>::value)
+#   define BOOST_HAS_VIRTUAL_DESTRUCTOR(T) __has_virtual_destructor(T)
+
+#   define BOOST_IS_ABSTRACT(T) __is_abstract(T)
+#   define BOOST_IS_BASE_OF(T,U) (__is_base_of(T,U) && !is_same<T,U>::value)
+#   define BOOST_IS_CLASS(T) __is_class(T)
+#   define BOOST_IS_ENUM(T) __is_enum(T)
+#   define BOOST_IS_POLYMORPHIC(T) __is_polymorphic(T)
+#   define BOOST_ALIGNMENT_OF(T) __alignof__(T)
+
+#   define BOOST_HAS_TYPE_TRAITS_INTRINSICS
+#endif
+
 # if defined(__CODEGEARC__)
 #   include <boost/type_traits/is_same.hpp>
 #   include <boost/type_traits/is_reference.hpp>

include/boost/type_traits/is_signed.hpp

@@ -24,14 +24,19 @@ namespace boost {
 
 namespace detail{
 
-#if !(defined(__EDG_VERSION__) && __EDG_VERSION__ <= 238)
+#if !(defined(__EDG_VERSION__) && __EDG_VERSION__ <= 238) && !defined(BOOST_NO_INCLASS_MEMBER_INITIALIZATION)
 
 template <class T>
 struct is_signed_values
 {
+   //
+   // Note that we cannot use BOOST_STATIC_CONSTANT here, using enum's
+   // rather than "real" static constants simply doesn't work or give
+   // the correct answer.
+   //
    typedef typename remove_cv<T>::type no_cv_t;
-   BOOST_STATIC_CONSTANT(no_cv_t, minus_one = (static_cast<no_cv_t>(-1)));
-   BOOST_STATIC_CONSTANT(no_cv_t, zero = (static_cast<no_cv_t>(0)));
+   static const no_cv_t minus_one = (static_cast<no_cv_t>(-1));
+   static const no_cv_t zero = (static_cast<no_cv_t>(0));
 };
 
 template <class T>

include/boost/type_traits/is_unsigned.hpp

@@ -24,14 +24,19 @@ namespace boost {
 
 namespace detail{
 
-#if !(defined(__EDG_VERSION__) && __EDG_VERSION__ <= 238)
+#if !(defined(__EDG_VERSION__) && __EDG_VERSION__ <= 238) && !defined(BOOST_NO_INCLASS_MEMBER_INITIALIZATION)
 
 template <class T>
 struct is_unsigned_values
 {
+   //
+   // Note that we cannot use BOOST_STATIC_CONSTANT here, using enum's
+   // rather than "real" static constants simply doesn't work or give
+   // the correct answer.
+   //
    typedef typename remove_cv<T>::type no_cv_t;
-   BOOST_STATIC_CONSTANT(no_cv_t, minus_one = (static_cast<no_cv_t>(-1)));
-   BOOST_STATIC_CONSTANT(no_cv_t, zero = (static_cast<no_cv_t>(0)));
+   static const no_cv_t minus_one = (static_cast<no_cv_t>(-1));
+   static const no_cv_t zero = (static_cast<no_cv_t>(0));
 };
 
 template <class T>

include/boost/type_traits/is_virtual_base_of.hpp

@@ -37,37 +37,37 @@ template<typename Base, typename Derived>
 struct is_virtual_base_of_impl<Base, Derived, mpl::true_>
 {
 #ifdef __BORLANDC__
-    struct X : public virtual Derived, public virtual Base 
+    struct boost_type_traits_internal_struct_X : public virtual Derived, public virtual Base 
     {
-       X();
-       X(const X&);
-       X& operator=(const X&);
-       ~X()throw();
+       boost_type_traits_internal_struct_X();
+       boost_type_traits_internal_struct_X(const boost_type_traits_internal_struct_X&);
+       boost_type_traits_internal_struct_X& operator=(const boost_type_traits_internal_struct_X&);
+       ~boost_type_traits_internal_struct_X()throw();
     };
-    struct Y : public virtual Derived 
+    struct boost_type_traits_internal_struct_Y : public virtual Derived 
     {
-       Y();
-       Y(const Y&);
-       Y& operator=(const Y&);
-       ~Y()throw();
+       boost_type_traits_internal_struct_Y();
+       boost_type_traits_internal_struct_Y(const boost_type_traits_internal_struct_Y&);
+       boost_type_traits_internal_struct_Y& operator=(const boost_type_traits_internal_struct_Y&);
+       ~boost_type_traits_internal_struct_Y()throw();
     };
 #else
-    struct X : Derived, virtual Base 
+    struct boost_type_traits_internal_struct_X : Derived, virtual Base 
     {
-       X();
-       X(const X&);
-       X& operator=(const X&);
-       ~X()throw();
+       boost_type_traits_internal_struct_X();
+       boost_type_traits_internal_struct_X(const boost_type_traits_internal_struct_X&);
+       boost_type_traits_internal_struct_X& operator=(const boost_type_traits_internal_struct_X&);
+       ~boost_type_traits_internal_struct_X()throw();
     };
-    struct Y : Derived 
+    struct boost_type_traits_internal_struct_Y : Derived 
     {
-       Y();
-       Y(const Y&);
-       Y& operator=(const Y&);
-       ~Y()throw();
+       boost_type_traits_internal_struct_Y();
+       boost_type_traits_internal_struct_Y(const boost_type_traits_internal_struct_Y&);
+       boost_type_traits_internal_struct_Y& operator=(const boost_type_traits_internal_struct_Y&);
+       ~boost_type_traits_internal_struct_Y()throw();
     };
 #endif
-    BOOST_STATIC_CONSTANT(bool, value = (sizeof(X)==sizeof(Y)));
+    BOOST_STATIC_CONSTANT(bool, value = (sizeof(boost_type_traits_internal_struct_X)==sizeof(boost_type_traits_internal_struct_Y)));
 };
 
 template<typename Base, typename Derived>

include/boost/typeof/message.hpp

@@ -2,7 +2,7 @@
 // Use, modification and distribution is subject to the Boost Software
 // License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
 
-#if defined(_MSC_VER) && !defined BOOST_TYPEOF_SILENT 
+#if defined(_MSC_VER) && defined BOOST_TYPEOF_MESSAGES
 #    pragma message(BOOST_TYPEOF_TEXT)
 #endif
 #undef BOOST_TYPEOF_TEXT

include/boost/typeof/register_functions.hpp

@@ -24,12 +24,19 @@
 enum 
 {
     FUN_ID                          = BOOST_TYPEOF_UNIQUE_ID(),
-    FUN_PTR_ID                      = FUN_ID + 1 * BOOST_PP_INC(BOOST_TYPEOF_LIMIT_FUNCTION_ARITY),
-    FUN_REF_ID                      = FUN_ID + 2 * BOOST_PP_INC(BOOST_TYPEOF_LIMIT_FUNCTION_ARITY),
-    MEM_FUN_ID                      = FUN_ID + 3 * BOOST_PP_INC(BOOST_TYPEOF_LIMIT_FUNCTION_ARITY),
-    CONST_MEM_FUN_ID                = FUN_ID + 4 * BOOST_PP_INC(BOOST_TYPEOF_LIMIT_FUNCTION_ARITY),
-    VOLATILE_MEM_FUN_ID             = FUN_ID + 5 * BOOST_PP_INC(BOOST_TYPEOF_LIMIT_FUNCTION_ARITY),
-    VOLATILE_CONST_MEM_FUN_ID       = FUN_ID + 6 * BOOST_PP_INC(BOOST_TYPEOF_LIMIT_FUNCTION_ARITY)
+    FUN_PTR_ID                      = FUN_ID +  1 * BOOST_PP_INC(BOOST_TYPEOF_LIMIT_FUNCTION_ARITY),
+    FUN_REF_ID                      = FUN_ID +  2 * BOOST_PP_INC(BOOST_TYPEOF_LIMIT_FUNCTION_ARITY),
+    MEM_FUN_ID                      = FUN_ID +  3 * BOOST_PP_INC(BOOST_TYPEOF_LIMIT_FUNCTION_ARITY),
+    CONST_MEM_FUN_ID                = FUN_ID +  4 * BOOST_PP_INC(BOOST_TYPEOF_LIMIT_FUNCTION_ARITY),
+    VOLATILE_MEM_FUN_ID             = FUN_ID +  5 * BOOST_PP_INC(BOOST_TYPEOF_LIMIT_FUNCTION_ARITY),
+    VOLATILE_CONST_MEM_FUN_ID       = FUN_ID +  6 * BOOST_PP_INC(BOOST_TYPEOF_LIMIT_FUNCTION_ARITY),
+    FUN_VAR_ID                      = FUN_ID +  7 * BOOST_PP_INC(BOOST_TYPEOF_LIMIT_FUNCTION_ARITY),
+    FUN_VAR_PTR_ID                  = FUN_ID +  8 * BOOST_PP_INC(BOOST_TYPEOF_LIMIT_FUNCTION_ARITY),
+    FUN_VAR_REF_ID                  = FUN_ID +  9 * BOOST_PP_INC(BOOST_TYPEOF_LIMIT_FUNCTION_ARITY),
+    MEM_FUN_VAR_ID                  = FUN_ID + 10 * BOOST_PP_INC(BOOST_TYPEOF_LIMIT_FUNCTION_ARITY),
+    CONST_MEM_FUN_VAR_ID            = FUN_ID + 11 * BOOST_PP_INC(BOOST_TYPEOF_LIMIT_FUNCTION_ARITY),
+    VOLATILE_MEM_FUN_VAR_ID         = FUN_ID + 12 * BOOST_PP_INC(BOOST_TYPEOF_LIMIT_FUNCTION_ARITY),
+    VOLATILE_CONST_MEM_FUN_VAR_ID   = FUN_ID + 13 * BOOST_PP_INC(BOOST_TYPEOF_LIMIT_FUNCTION_ARITY)
 };
 
 BOOST_TYPEOF_BEGIN_ENCODE_NS

include/boost/typeof/register_functions_iterate.hpp

@@ -15,6 +15,13 @@ struct encode_type_impl<V, R(*)(BOOST_PP_ENUM_PARAMS(n, P))>
     typedef BOOST_TYPEOF_ENCODE_PARAMS(BOOST_PP_INC(n), FUN_PTR_ID + n) type;
 };
 
+template<class V, class R BOOST_PP_ENUM_TRAILING_PARAMS(n, class P)>
+struct encode_type_impl<V, R(*)(BOOST_PP_ENUM_PARAMS(n, P) ...)>
+{
+    typedef R BOOST_PP_CAT(P, n);
+    typedef BOOST_TYPEOF_ENCODE_PARAMS(BOOST_PP_INC(n), FUN_VAR_PTR_ID + n) type;
+};
+
 template<class Iter>
 struct decode_type_impl<boost::mpl::size_t<FUN_PTR_ID + n>, Iter>
 {
@@ -24,6 +31,15 @@ struct decode_type_impl<boost::mpl::size_t<FUN_PTR_ID + n>, Iter>
     typedef BOOST_PP_CAT(iter, BOOST_PP_INC(n)) iter;
 };
 
+template<class Iter>
+struct decode_type_impl<boost::mpl::size_t<FUN_VAR_PTR_ID + n>, Iter>
+{
+    typedef Iter iter0;
+    BOOST_TYPEOF_DECODE_PARAMS(BOOST_PP_INC(n))
+    typedef BOOST_PP_CAT(p, n)(*type)(BOOST_PP_ENUM_PARAMS(n, p) ...);
+    typedef BOOST_PP_CAT(iter, BOOST_PP_INC(n)) iter;
+};
+
 #ifndef BOOST_TYPEOF_NO_FUNCTION_TYPES
 
     // function references
@@ -35,6 +51,13 @@ struct decode_type_impl<boost::mpl::size_t<FUN_PTR_ID + n>, Iter>
         typedef BOOST_TYPEOF_ENCODE_PARAMS(BOOST_PP_INC(n), FUN_REF_ID + n) type;
     };
 
+    template<class V, class R BOOST_PP_ENUM_TRAILING_PARAMS(n, class P)>
+    struct encode_type_impl<V, R(&)(BOOST_PP_ENUM_PARAMS(n, P) ...)>
+    {
+        typedef R BOOST_PP_CAT(P, n);
+        typedef BOOST_TYPEOF_ENCODE_PARAMS(BOOST_PP_INC(n), FUN_VAR_REF_ID + n) type;
+    };
+
     template<class Iter>
     struct decode_type_impl<boost::mpl::size_t<FUN_REF_ID + n>, Iter>
     {
@@ -44,6 +67,15 @@ struct decode_type_impl<boost::mpl::size_t<FUN_PTR_ID + n>, Iter>
         typedef BOOST_PP_CAT(iter, BOOST_PP_INC(n)) iter;
     };
 
+    template<class Iter>
+    struct decode_type_impl<boost::mpl::size_t<FUN_VAR_REF_ID + n>, Iter>
+    {
+        typedef Iter iter0;
+        BOOST_TYPEOF_DECODE_PARAMS(BOOST_PP_INC(n))
+        typedef BOOST_PP_CAT(p, n)(&type)(BOOST_PP_ENUM_PARAMS(n, p) ...);
+        typedef BOOST_PP_CAT(iter, BOOST_PP_INC(n)) iter;
+    };
+
     // functions
 
     template<class V, class R BOOST_PP_ENUM_TRAILING_PARAMS(n, class P)>
@@ -53,6 +85,13 @@ struct decode_type_impl<boost::mpl::size_t<FUN_PTR_ID + n>, Iter>
         typedef BOOST_TYPEOF_ENCODE_PARAMS(BOOST_PP_INC(n), FUN_ID + n) type;
     };
 
+    template<class V, class R BOOST_PP_ENUM_TRAILING_PARAMS(n, class P)>
+    struct encode_type_impl<V, R(BOOST_PP_ENUM_PARAMS(n, P) ...)>
+    {
+        typedef R BOOST_PP_CAT(P, n);
+        typedef BOOST_TYPEOF_ENCODE_PARAMS(BOOST_PP_INC(n), FUN_VAR_ID + n) type;
+    };
+
     template<class Iter>
     struct decode_type_impl<boost::mpl::size_t<FUN_ID + n>, Iter>
     {
@@ -62,6 +101,15 @@ struct decode_type_impl<boost::mpl::size_t<FUN_PTR_ID + n>, Iter>
         typedef BOOST_PP_CAT(iter, BOOST_PP_INC(n)) iter;
     };
 
+    template<class Iter>
+    struct decode_type_impl<boost::mpl::size_t<FUN_VAR_ID + n>, Iter>
+    {
+        typedef Iter iter0;
+        BOOST_TYPEOF_DECODE_PARAMS(BOOST_PP_INC(n))
+        typedef BOOST_PP_CAT(p, n)(type)(BOOST_PP_ENUM_PARAMS(n, p) ...);
+        typedef BOOST_PP_CAT(iter, BOOST_PP_INC(n)) iter;
+    };
+
 #endif//BOOST_TYPEOF_NO_FUNCTION_TYPES
 
 #ifndef BOOST_TYPEOF_NO_MEMBER_FUNCTION_TYPES

include/boost/typeof/typeof.hpp

@@ -15,7 +15,7 @@
 
 #if defined(__COMO__)
 #   ifdef __GNUG__
-#       ifndef(BOOST_TYPEOF_EMULATION)
+#       ifndef BOOST_TYPEOF_EMULATION
 #           ifndef BOOST_TYPEOF_NATIVE
 #               define BOOST_TYPEOF_NATIVE
 #           endif
@@ -65,7 +65,7 @@
 #           endif
 #           define BOOST_TYPEOF_KEYWORD __typeof__
 #       else
-#           error typeof emulation is not supported
+#           define BOOST_TYPEOF_EMULATION_UNSUPPORTED
 #       endif
 #   else // 9.x
 #       ifndef BOOST_TYPEOF_EMULATION
@@ -75,7 +75,22 @@
 #           define BOOST_TYPEOF_KEYWORD __typeof__
 #       endif
 #   endif
-
+#elif defined __CODEGEARC__
+#   ifndef BOOST_TYPEOF_EMULATION
+#       ifndef BOOST_TYPEOF_NATIVE
+#           define BOOST_TYPEOF_EMULATION_UNSUPPORTED
+#       endif
+#   else
+#       define BOOST_TYPEOF_EMULATION_UNSUPPORTED
+#   endif
+#elif defined __BORLANDC__
+#   ifndef BOOST_TYPEOF_EMULATION
+#       ifndef BOOST_TYPEOF_NATIVE
+#           define BOOST_TYPEOF_EMULATION_UNSUPPORTED
+#       endif
+#   else
+#       define BOOST_TYPEOF_EMULATION_UNSUPPORTED
+#   endif
 #elif defined __DMC__
 #   ifndef BOOST_TYPEOF_EMULATION
 #       ifndef BOOST_TYPEOF_NATIVE
@@ -95,24 +110,21 @@
 #       else
 #           error typeof emulation is not supported
 #       endif
-#   elif (_MSC_VER >= 1310)  // 7.1, 8.0
+#   elif (_MSC_VER >= 1310)  // 7.1 ->
 #       ifndef BOOST_TYPEOF_EMULATION
 #           ifndef BOOST_TYPEOF_NATIVE
-#               define BOOST_TYPEOF_NATIVE
+#               ifndef _MSC_EXTENSIONS
+#                   define BOOST_TYPEOF_EMULATION
+#               else
+#                   define BOOST_TYPEOF_NATIVE
+#               endif
 #           endif
+#       endif
+#       ifdef BOOST_TYPEOF_NATIVE
 #           include <boost/typeof/msvc/typeof_impl.hpp>
 #           define MSVC_TYPEOF_HACK
 #       endif
-/*#   else // 8.0
-#       ifndef BOOST_TYPEOF_NATIVE
-#           ifndef BOOST_TYPEOF_EMULATION
-#               define BOOST_TYPEOF_EMULATION
-#           endif
-#       else
-#           error native typeof is not supported
-#       endif*/
 #   endif
-
 #elif defined(__HP_aCC)
 #   ifndef BOOST_TYPEOF_NATIVE
 #       ifndef BOOST_TYPEOF_EMULATION
@@ -163,7 +175,9 @@
 #define BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()\
      <boost/typeof/incr_registration_group.hpp>
 
-#ifdef BOOST_TYPEOF_EMULATION
+#ifdef BOOST_TYPEOF_EMULATION_UNSUPPORTED
+#   include <boost/typeof/unsupported.hpp>
+#elif defined BOOST_TYPEOF_EMULATION
 #   define BOOST_TYPEOF_TEXT "using typeof emulation"
 #   include <boost/typeof/message.hpp>
 #   include <boost/typeof/typeof_impl.hpp>