Boost version 1.30.0

git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@6551 a592a061-630c-0410-9148-cb99ea01b6c8

boost/ChangeLog

@@ -1,3 +1,7 @@
+2003-03-21  Lars Gullik Bjønnes  <larsbj@gullik.net>
+
+	* update boot so version 1.30.0
+
 2003-03-11  Lars Gullik Bjønnes  <larsbj@gullik.net>
 
 	* update from boost cvs branch RC_1_30_0

boost/boost/detail/limits.hpp

@@ -51,7 +51,7 @@
 // bit layout, but about floating-point NaN (etc.) bit patterns.
 #if defined(__sparc) || defined(__sparc__) || defined(__powerpc__) || defined(__ppc__) || defined(__hppa) || defined(_MIPSEB) || defined(_POWER)
 #define BOOST_BIG_ENDIAN
-#elif defined(__i386__) || defined(__alpha__)
+#elif defined(__i386__) || defined(__alpha__) || defined(__ia64) || defined(__ia64__)
 #define BOOST_LITTLE_ENDIAN
 #else
 #error The file boost/detail/limits.hpp needs to be set up for your CPU type.

boost/boost/format.hpp

@@ -40,12 +40,15 @@
 #include <boost/format/macros_stlport.hpp>  // stlport workarounds
 #include <boost/format/macros_default.hpp> 
 
-#if defined(BOOST_NO_STD_LOCALE) || ( BOOST_WORKAROUND(__BORLANDC__, <= 0x561) \
- && BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT( 0x570 ) ) )
-#define BOOST_BAD_ISDIGIT
+#if defined(BOOST_NO_STD_LOCALE) || \
+ ( BOOST_WORKAROUND(__BORLANDC__, <= 0x564) \
+   || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT( 0x570 ) )  )
+// some future __BORLANDC__ >0x564  versions might not need this
+// 0x570 is Borland's kylix branch
+#define BOOST_NO_LOCALE_ISIDIGIT
 #endif
 
-#ifdef BOOST_BAD_ISDIGIT
+#ifdef BOOST_NO_LOCALE_ISIDIGIT
 #include <cctype>  // we'll use the non-locale  <cctype>'s std::isdigit(int)
 #endif
 
@@ -85,8 +88,8 @@
 #ifdef BOOST_NO_OVERLOAD_FOR_NON_CONST
 #undef BOOST_NO_OVERLOAD_FOR_NON_CONST
 #endif
-#ifdef BOOST_BAD_ISDIGIT
-#undef BOOST_BAD_ISDIGIT
+#ifdef BOOST_NO_LOCALE_ISIDIGIT
+#undef BOOST_NO_LOCALE_ISIDIGIT
 #endif
 #ifdef BOOST_IO_STD
 #undef BOOST_IO_STD

boost/boost/format/parsing.hpp

@@ -34,7 +34,7 @@ namespace detail {
   template<class Ch, class Stream> inline
   bool wrap_isdigit(Ch c, Stream &os) 
   {
-#ifndef BOOST_BAD_ISDIGIT
+#ifndef BOOST_NO_LOCALE_ISIDIGIT
     return std::isdigit(c, os.rdbuf()->getloc() );
 # else
     using namespace std;

boost/boost/lexical_cast.hpp

@@ -1,31 +1,42 @@
-//  boost lexical_cast.hpp header  -------------------------------------------//
-
-//  See http://www.boost.org/libs/conversion for documentation.
-
 #ifndef BOOST_LEXICAL_CAST_INCLUDED
 #define BOOST_LEXICAL_CAST_INCLUDED
 
+// Boost lexical_cast.hpp header  -------------------------------------------//
+//
+// See http://www.boost.org for most recent version including documentation.
+// See end of this header for rights and permissions.
+//
 // what:  lexical_cast custom keyword cast
-// who:   contributed by Kevlin Henney, with alternative naming, behaviors
-//        and fixes contributed by Dave Abrahams, Daryle Walker and other
-//        Boosters on the list
-// when:  November 2000
-// where: tested with MSVC 6.0, BCC 5.5, and g++ 2.91
+// who:   contributed by Kevlin Henney,
+//        enhanced with contributions from Terje Slettebø,
+//        with additional fixes and suggestions from Gennaro Prota,
+//        Beman Dawes, Dave Abrahams, Daryle Walker, Peter Dimov,
+//        and other Boosters
+// when:  November 2000, March 2003
 
+#include <string>
+#include <typeinfo>
 #include <boost/config.hpp>
+#include <boost/limits.hpp>
+#include <boost/type_traits/is_pointer.hpp>
 
-// Some sstream implementations are broken for the purposes of lexical cast.
-# if defined(BOOST_NO_STRINGSTREAM)
-#  define BOOST_LEXICAL_CAST_USE_STRSTREAM
-# endif
-
-#ifdef BOOST_LEXICAL_CAST_USE_STRSTREAM
-# include <strstream>
+#ifdef BOOST_NO_STRINGSTREAM
+#include <strstream>
 #else
-# include <sstream>
+#include <sstream>
 #endif
 
-#include <typeinfo>
+#if defined(BOOST_NO_STRINGSTREAM) || \
+    defined(BOOST_NO_STD_WSTRING) || \
+    defined(BOOST_NO_STD_LOCALE) || \
+    defined(BOOST_NO_CWCHAR) || \
+    defined(BOOST_MSVC) && (BOOST_MSVC <= 1200)
+#define DISABLE_WIDE_CHAR_SUPPORT
+#endif
+
+#ifdef BOOST_NO_INTRINSIC_WCHAR_T
+#include <cwchar>
+#endif
 
 namespace boost
 {
@@ -33,35 +44,158 @@ namespace boost
     class bad_lexical_cast : public std::bad_cast
     {
     public:
-        // constructors, destructors, and assignment operator defaulted
-
-        // function inlined for brevity and consistency with rest of library
-        virtual const char * what() const throw()
+        virtual ~bad_lexical_cast() throw()
         {
-            return "bad lexical cast: "
-                   "source type value could not be interpreted as target";
         }
     };
 
+    namespace detail // actual underlying concrete exception type
+    {
+        template<typename Target, typename Source>
+        class no_lexical_conversion : public bad_lexical_cast
+        {
+        public:
+            no_lexical_conversion()
+              : description(
+                  std::string() + "bad lexical cast: " +
+                  "source type value could not be interpreted as target, Target=" +
+                  typeid(Target).name() + ", Source=" + typeid(Source).name())
+            {
+            }
+            virtual ~no_lexical_conversion() throw()
+            {
+            }
+            virtual const char *what() const throw()
+            {
+                return description.c_str();
+            }
+        private:
+            const std::string description; // static initialization fails on MSVC6
+        };
+    }
+
+    namespace detail // selectors for choosing stream character type
+    {
+        template<typename Type>
+        struct stream_char
+        {
+            typedef char type;
+        };
+
+        #ifndef DISABLE_WIDE_CHAR_SUPPORT
+        template<>
+        struct stream_char<wchar_t>
+        {
+            typedef wchar_t type;
+        };
+
+        template<>
+        struct stream_char<wchar_t *>
+        {
+            typedef wchar_t type;
+        };
+
+        template<>
+        struct stream_char<const wchar_t *>
+        {
+            typedef wchar_t type;
+        };
+
+        template<>
+        struct stream_char<std::wstring>
+        {
+            typedef wchar_t type;
+        };
+        #endif
+
+        template<typename TargetChar, typename SourceChar>
+        struct widest_char
+        {
+            typedef TargetChar type;
+        };
+
+        template<>
+        struct widest_char<char, wchar_t>
+        {
+            typedef wchar_t type;
+        };
+    }
+    
+    namespace detail // stream wrapper for handling lexical conversions
+    {
+        template<typename Target, typename Source>
+        class lexical_stream
+        {
+        public:
+            lexical_stream()
+            {
+                stream.unsetf(std::ios::skipws);
+
+                if(std::numeric_limits<Target>::is_specialized)
+                    stream.precision(std::numeric_limits<Target>::digits10 + 1);
+                else if(std::numeric_limits<Source>::is_specialized)
+                    stream.precision(std::numeric_limits<Source>::digits10 + 1);
+            }
+            ~lexical_stream()
+            {
+                #if defined(BOOST_NO_STRINGSTREAM)
+                stream.freeze(false);
+                #endif
+            }
+            bool operator<<(const Source &input)
+            {
+                return stream << input;
+            }
+            template<typename InputStreamable>
+            bool operator>>(InputStreamable &output)
+            {
+                return !is_pointer<InputStreamable>::value &&
+                       stream >> output &&
+                       (stream >> std::ws).eof();
+            }
+            bool operator>>(std::string &output)
+            {
+                #if defined(BOOST_NO_STRINGSTREAM)
+                stream << '\0';
+                #endif
+                output = stream.str();
+                return true;
+            }
+            #ifndef DISABLE_WIDE_CHAR_SUPPORT
+            bool operator>>(std::wstring &output)
+            {
+                output = stream.str();
+                return true;
+            }
+            #endif
+        private:
+            typedef typename widest_char<
+                typename stream_char<Target>::type,
+                typename stream_char<Source>::type>::type char_type;
+
+            #if defined(BOOST_NO_STRINGSTREAM)
+            std::strstream stream;
+            #elif defined(BOOST_NO_STD_LOCALE)
+            std::stringstream stream;
+            #else
+            std::basic_stringstream<char_type> stream;
+            #endif
+        };
+    }
+
     template<typename Target, typename Source>
     Target lexical_cast(Source arg)
     {
-# ifdef BOOST_LEXICAL_CAST_USE_STRSTREAM
-        std::strstream interpreter; // for out-of-the-box g++ 2.95.2
-# else
-        std::stringstream interpreter;
-# endif
+        detail::lexical_stream<Target, Source> interpreter;
         Target result;
 
-        if(!(interpreter << arg) || !(interpreter >> result) ||
-           !(interpreter >> std::ws).eof())
-            throw bad_lexical_cast();
-
+        if(!(interpreter << arg && interpreter >> result))
+            throw detail::no_lexical_conversion<Target, Source>();
         return result;
     }
 }
 
-// Copyright Kevlin Henney, 2000, 2001, 2002. All rights reserved.
+// Copyright Kevlin Henney, 2000-2003. All rights reserved.
 //
 // Permission to use, copy, modify, and distribute this software for any
 // purpose is hereby granted without fee, provided that this copyright and
@@ -69,8 +203,5 @@ namespace boost
 //
 // This software is provided "as is" without express or implied warranty.
 
-#ifdef BOOST_LEXICAL_CAST_USE_STRSTREAM
-# undef BOOST_LEXICAL_CAST_USE_STRSTREAM
-#endif
-
+#undef DISABLE_WIDE_CHAR_SUPPORT
 #endif

boost/boost/mpl/aux_/integral_wrapper.hpp

@@ -26,7 +26,13 @@
 
 #if !defined(AUX_WRAPPER_NAME)
 #   define AUX_WRAPPER_NAME BOOST_PP_CAT(AUX_WRAPPER_VALUE_TYPE,_)
+#endif
+
+#if !defined(AUX_WRAPPER_PARAMS)
 #   define AUX_WRAPPER_PARAMS(N) BOOST_MPL_AUX_NTTP_DECL(AUX_WRAPPER_VALUE_TYPE, N)
+#endif
+
+#if !defined(AUX_WRAPPER_INST)
 #   define AUX_WRAPPER_INST(value) mpl::AUX_WRAPPER_NAME< value >
 #endif
 
@@ -36,12 +42,18 @@ template< AUX_WRAPPER_PARAMS(N) >
 struct AUX_WRAPPER_NAME
 {
     BOOST_STATIC_CONSTANT(AUX_WRAPPER_VALUE_TYPE, value = N);
+// agurt, 08/mar/03: SGI MIPSpro C++ workaround, have to #ifdef because some 
+// other compilers (e.g. MSVC) are not particulary happy about it
+#if BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
     typedef struct AUX_WRAPPER_NAME type;
+#else
+    typedef AUX_WRAPPER_NAME type;
+#endif
     typedef AUX_WRAPPER_VALUE_TYPE value_type;
 
-    // have to #ifdef here: some compilers don't like the 'N + 1' form (MSVC),
-    // while some other don't like 'value + 1' (Borland), and some don't like
-    // either
+// have to #ifdef here: some compilers don't like the 'N + 1' form (MSVC),
+// while some other don't like 'value + 1' (Borland), and some don't like
+// either
 #if BOOST_WORKAROUND(__EDG_VERSION__, <= 243)
  private:
     BOOST_STATIC_CONSTANT(AUX_WRAPPER_VALUE_TYPE, next_value = BOOST_MPL_AUX_ICE_CAST(AUX_WRAPPER_VALUE_TYPE, (N + 1)));

boost/boost/mpl/aux_/void_spec.hpp

@@ -19,6 +19,7 @@
 
 #include "boost/mpl/lambda_fwd.hpp"
 #include "boost/mpl/void.hpp"
+#include "boost/mpl/int_fwd.hpp"
 #include "boost/mpl/aux_/preprocessor/params.hpp"
 #include "boost/mpl/aux_/preprocessor/enum.hpp"
 #include "boost/mpl/aux_/preprocessor/def_params_tail.hpp"
@@ -88,7 +89,7 @@ struct lambda< \
 template<> \
 struct lambda< \
       name< BOOST_MPL_AUX_VOID_SPEC_PARAMS(i) > \
-    BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(-1) \
+    BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(int_<-1>) \
     > \
 { \
     typedef name< BOOST_MPL_AUX_VOID_SPEC_PARAMS(i) > type; \

boost/boost/mpl/bool.hpp

@@ -3,7 +3,7 @@
 #define BOOST_MPL_BOOL_HPP_INCLUDED
 
 // + file: boost/mpl/bool.hpp
-// + last modified: 25/feb/03
+// + last modified: 08/mar/03
 
 // Copyright (c) 2000-03
 // Aleksey Gurtovoy
@@ -18,6 +18,7 @@
 //
 // See http://www.boost.org/libs/mpl for documentation.
 
+#include "boost/mpl/bool_fwd.hpp"
 #include "boost/mpl/aux_/config/static_constant.hpp"
 
 namespace boost { namespace mpl {
@@ -30,10 +31,6 @@ template< bool C_ > struct bool_
     operator bool() const { return this->value; }
 };
 
-// shorcuts
-typedef bool_<true> true_;
-typedef bool_<false> false_;
-
 }} // namespace boost::mpl
 
 #endif // BOOST_MPL_BOOL_HPP_INCLUDED

boost/boost/mpl/bool_fwd.hpp

@@ -0,0 +1,31 @@
+
+#ifndef BOOST_MPL_BOOL_FWD_HPP_INCLUDED
+#define BOOST_MPL_BOOL_FWD_HPP_INCLUDED
+
+// + file: boost/mpl/bool_fwd.hpp
+// + last modified: 08/mar/03
+
+// Copyright (c) 2000-03
+// Aleksey Gurtovoy
+//
+// 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 appears in all copies and 
+// that both the copyright notice and this permission notice appear in 
+// supporting documentation. No representations are made about the 
+// suitability of this software for any purpose. It is provided "as is" 
+// without express or implied warranty.
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+namespace boost { namespace mpl {
+
+template< bool C_ > struct bool_;
+
+// shorcuts
+typedef bool_<true> true_;
+typedef bool_<false> false_;
+
+}}
+
+#endif // BOOST_MPL_BOOL_FWD_HPP_INCLUDED

boost/boost/mpl/if.hpp

@@ -1,9 +1,11 @@
-//-----------------------------------------------------------------------------
-// boost/mpl/if.hpp header file
-// See http://www.boost.org for updates, documentation, and revision history.
-//-----------------------------------------------------------------------------
-//
-// Copyright (c) 2000-02 Boost.org
+
+#ifndef BOOST_MPL_IF_HPP_INCLUDED
+#define BOOST_MPL_IF_HPP_INCLUDED
+
+// + file: boost/mpl/if.hpp
+// + last modified: 10/mar/03
+
+// Copyright (c) 2000-03 Boost.org
 //
 // Permission to use, copy, modify, distribute and sell this software
 // and its documentation for any purpose is hereby granted without fee, 
@@ -12,9 +14,8 @@
 // supporting documentation. No representations are made about the 
 // suitability of this software for any purpose. It is provided "as is" 
 // without express or implied warranty.
-
-#ifndef BOOST_MPL_IF_HPP_INCLUDED
-#define BOOST_MPL_IF_HPP_INCLUDED
+//
+// See http://www.boost.org/libs/mpl for documentation.
 
 #include "boost/mpl/aux_/value_wknd.hpp"
 #include "boost/mpl/aux_/ice_cast.hpp"
@@ -85,7 +86,7 @@ struct if_c
 {
  private:
     template<bool> struct answer        { typedef T1 type; };
-    template<>     struct answer<false>	{ typedef T2 type; };
+    template<>     struct answer<false> { typedef T2 type; };
  
  public:
     typedef typename answer< C_ >::type type;
@@ -102,7 +103,7 @@ struct if_
 {
  private:
     template<bool> struct answer        { typedef T1 type; };
-    template<>     struct answer<false>	{ typedef T2 type; };
+    template<>     struct answer<false> { typedef T2 type; };
 
     // agurt, 17/sep/02: in some situations MSVC 7.0 doesn't 
     // handle 'answer<C::value>' expression very well

boost/boost/mpl/int_fwd.hpp

@@ -0,0 +1,25 @@
+
+#ifndef BOOST_MPL_INT_FWD_HPP_INCLUDED
+#define BOOST_MPL_INT_FWD_HPP_INCLUDED
+
+// + file: boost/mpl/int_fwd.hpp
+// + last modified: 08/mar/03
+
+// Copyright (c) 2000-03
+// Aleksey Gurtovoy
+//
+// 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 appears in all copies and 
+// that both the copyright notice and this permission notice appear in 
+// supporting documentation. No representations are made about the 
+// suitability of this software for any purpose. It is provided "as is" 
+// without express or implied warranty.
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+namespace boost { namespace mpl {
+template< int N > struct int_;
+}}
+
+#endif // BOOST_MPL_INT_FWD_HPP_INCLUDED

boost/boost/mpl/integral_c.hpp

@@ -3,7 +3,7 @@
 #define BOOST_MPL_INTEGRAL_C_HPP_INCLUDED
 
 // + file: boost/mpl/integral_c.hpp
-// + last modified: 25/feb/03
+// + last modified: 08/mar/03
 
 // Copyright (c) 2000-03
 // Aleksey Gurtovoy
@@ -18,6 +18,7 @@
 //
 // See http://www.boost.org/libs/mpl for documentation.
 
+#include "boost/mpl/integral_c_fwd.hpp"
 #include "boost/mpl/aux_/ice_cast.hpp"
 #include "boost/mpl/aux_/config/ctps.hpp"
 #include "boost/mpl/aux_/config/workaround.hpp"

boost/boost/mpl/lambda_fwd.hpp

@@ -24,7 +24,7 @@ namespace boost {
 namespace mpl {
 
 #if !defined(BOOST_MPL_NO_FULL_LAMBDA_SUPPORT)
-template< typename T BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(long Arity) >
+template< typename T BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(typename Arity) >
 struct lambda;
 #else
 template< typename T, bool Protect > struct lambda;

boost/boost/mpl/size_t.hpp

@@ -0,0 +1,29 @@
+
+#ifndef BOOST_MPL_SIZE_T_HPP_INCLUDED
+#define BOOST_MPL_SIZE_T_HPP_INCLUDED
+
+// + file: boost/mpl/size_t.hpp
+// + last modified: 08/mar/03
+
+// Copyright (c) 2000-03
+// Aleksey Gurtovoy
+//
+// 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 appears in all copies and 
+// that both the copyright notice and this permission notice appear in 
+// supporting documentation. No representations are made about the 
+// suitability of this software for any purpose. It is provided "as is" 
+// without express or implied warranty.
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+#include "boost/mpl/size_t_fwd.hpp"
+
+#define AUX_WRAPPER_VALUE_TYPE std::size_t
+#define AUX_WRAPPER_NAME size_t
+#define AUX_WRAPPER_PARAMS(N) std::size_t N
+
+#include "boost/mpl/aux_/integral_wrapper.hpp"
+
+#endif // BOOST_MPL_SIZE_T_HPP_INCLUDED

boost/boost/mpl/size_t_fwd.hpp

@@ -0,0 +1,28 @@
+
+#ifndef BOOST_MPL_SIZE_T_FWD_HPP_INCLUDED
+#define BOOST_MPL_SIZE_T_FWD_HPP_INCLUDED
+
+// + file: boost/mpl/size_t_fwd.hpp
+// + last modified: 08/mar/03
+
+// Copyright (c) 2000-03
+// Aleksey Gurtovoy
+//
+// 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 appears in all copies and 
+// that both the copyright notice and this permission notice appear in 
+// supporting documentation. No representations are made about the 
+// suitability of this software for any purpose. It is provided "as is" 
+// without express or implied warranty.
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+#include "boost/config.hpp" // make sure 'size_t' is placed into 'std'
+#include <cstddef>
+
+namespace boost { namespace mpl {
+template< std::size_t N > struct size_t;
+}}
+
+#endif // BOOST_MPL_SIZE_T_FWD_HPP_INCLUDED

boost/boost/regex/config.hpp

@@ -125,8 +125,10 @@
 // If there isn't good enough wide character support then there will
 // be no wide character regular expressions:
 //
-#if (defined(BOOST_NO_CWCHAR) || defined(BOOST_NO_CWCTYPE) || defined(BOOST_NO_STD_WSTRING)) && !defined(BOOST_NO_WREGEX)
-#  define BOOST_NO_WREGEX
+#if (defined(BOOST_NO_CWCHAR) || defined(BOOST_NO_CWCTYPE) || defined(BOOST_NO_STD_WSTRING))
+#  if !defined(BOOST_NO_WREGEX)
+#     define BOOST_NO_WREGEX
+#  endif
 #else
 #  if defined(__sgi) && defined(__SGI_STL_PORT)
       // STLPort on IRIX is misconfigured: <cwctype> does not compile
@@ -645,3 +647,4 @@ inline void pointer_construct(T* p, const T& t)
 
 
 
+

boost/boost/regex/v3/regex_compile.hpp

@@ -1990,6 +1990,8 @@ unsigned int BOOST_REGEX_CALL reg_expression<charT, traits, Allocator>::probe_re
    {
    case re_detail::syntax_element_startmark:
    case re_detail::syntax_element_endmark:
+      if(static_cast<const re_detail::re_brace*>(dat)->index == -2)
+         return regbase::restart_any;
       return probe_restart(dat->next.p);
    case re_detail::syntax_element_start_line:
       return regbase::restart_line;
@@ -2018,7 +2020,7 @@ unsigned int BOOST_REGEX_CALL reg_expression<charT, traits, Allocator>::fixup_le
          if((leading_lit) && (static_cast<re_detail::re_literal*>(dat)->length > 2))
          {
             // we can do a literal search for the leading literal string
-            // using Knuth-Morris-Pratt (or whatever), and only then check for 
+            // using Knuth-Morris-Pratt (or whatever), and only then check for
             // matches.  We need a decent length string though to make it
             // worth while.
             _leading_string = reinterpret_cast<charT*>(reinterpret_cast<char*>(dat) + sizeof(re_detail::re_literal));
@@ -2066,10 +2068,14 @@ unsigned int BOOST_REGEX_CALL reg_expression<charT, traits, Allocator>::fixup_le
       case re_detail::syntax_element_rep:
          if((len == 0) && (1 == fixup_leading_rep(dat->next.p, static_cast<re_detail::re_repeat*>(dat)->alt.p) ))
          {
-            static_cast<re_detail::re_repeat*>(dat)->leading = true;
+            static_cast<re_detail::re_repeat*>(dat)->leading = leading_lit;
             return len;
          }
          return len;
+      case re_detail::syntax_element_startmark:
+         if(static_cast<const re_detail::re_brace*>(dat)->index == -2)
+            return 0;
+         // fall through:
       default:
          break;
       }
@@ -2115,3 +2121,4 @@ void BOOST_REGEX_CALL reg_expression<charT, traits, Allocator>::fail(unsigned in
 
 
 
+

boost/boost/regex/v3/regex_match.hpp

@@ -56,8 +56,10 @@ inline int string_compare(const std::basic_string<C,T,A>& s, const C* p)
 { return s.compare(p); }
 inline int string_compare(const std::string& s, const char* p)
 { return std::strcmp(s.c_str(), p); }
+# ifndef BOOST_NO_WREGEX
 inline int string_compare(const std::wstring& s, const wchar_t* p)
 { return std::wcscmp(s.c_str(), p); }
+# endif
 # define STR_COMP(s,p) string_compare(s,p)
 #endif
 
@@ -753,6 +755,15 @@ bool query_match_aux(iterator first,
                   start_loop[cur_acc] = first;
                   continue;
                }
+               else if((unsigned int)accumulators[cur_acc] < static_cast<const re_repeat*>(ptr)->min)
+               {
+                  // the repeat was null, and we haven't gone round min times yet,
+                  // since all subsequent repeats will be null as well, just update
+                  // our repeat count and skip out.
+                  accumulators[cur_acc] = static_cast<const re_repeat*>(ptr)->min;
+                  ptr = static_cast<const re_repeat*>(ptr)->alt.p;
+                  continue;
+               }
                goto failure;
             }
             // see if we can skip the repeat:
@@ -809,6 +820,15 @@ bool query_match_aux(iterator first,
             start_loop[cur_acc] = first;
             continue;
          }
+         else if((first == start_loop[cur_acc]) && accumulators[cur_acc] && ((unsigned int)accumulators[cur_acc] < static_cast<const re_repeat*>(ptr)->min))
+         {
+            // the repeat was null, and we haven't gone round min times yet,
+            // since all subsequent repeats will be null as well, just update
+            // our repeat count and skip out.
+            accumulators[cur_acc] = static_cast<const re_repeat*>(ptr)->min;
+            ptr = static_cast<const re_repeat*>(ptr)->alt.p;
+            continue;
+         }
 
          // if we get here then neither option is allowed so fail:
          goto failure;
@@ -826,7 +846,7 @@ bool query_match_aux(iterator first,
             if(flags & match_not_eob)
                goto failure;
             iterator p(first);
-            while((p != last) && traits_inst.is_separator(traits_inst.translate(*first, icase)))++p;
+            while((p != last) && traits_inst.is_separator(traits_inst.translate(*p, icase)))++p;
             if(p != last)
                goto failure;
             ptr = ptr->next.p;
@@ -958,6 +978,12 @@ bool query_match_aux(iterator first,
             goto failure;
          ptr = ptr->next.p;
          continue;
+      case syntax_element_backref:
+         if(temp_match[static_cast<const re_brace*>(ptr)->index].first
+               != temp_match[static_cast<const re_brace*>(ptr)->index].second)
+               goto failure;
+         ptr = ptr->next.p;
+         continue;
       default:
          goto failure;
       }

boost/boost/type_traits/detail/is_mem_fun_pointer_impl.hpp

@@ -33,291 +33,291 @@ struct is_mem_fun_pointer_impl
 #if !defined(BOOST_TT_PREPROCESSING_MODE)
 // preprocessor-generated part, don't edit by hand!
 
-template <class R,class T>
-struct is_mem_fun_pointer_impl<R (T::*)()> { BOOST_STATIC_CONSTANT(bool,value = true); };
-#if !defined(__MWERKS__) || __MWERKS__ >= 0x3000
-template <class R,class T>
-struct is_mem_fun_pointer_impl<R (T::*)() const> { BOOST_STATIC_CONSTANT(bool,value = true); };
-template <class R,class T>
-struct is_mem_fun_pointer_impl<R (T::*)() volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
-template <class R,class T>
-struct is_mem_fun_pointer_impl<R (T::*)() const volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
-#endif // __MWERKS__ < 0x3000
+template <class R, class T  >
+struct is_mem_fun_pointer_impl<R (T::*)() > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600))
+template <class R, class T  >
+struct is_mem_fun_pointer_impl<R (T::*)() const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+template <class R, class T  >
+struct is_mem_fun_pointer_impl<R (T::*)() volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+template <class R, class T  >
+struct is_mem_fun_pointer_impl<R (T::*)() const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
 
-template <class R,class T,class T0>
-struct is_mem_fun_pointer_impl<R (T::*)(T0)> { BOOST_STATIC_CONSTANT(bool,value = true); };
-#if !defined(__MWERKS__) || __MWERKS__ >= 0x3000
-template <class R,class T,class T0>
-struct is_mem_fun_pointer_impl<R (T::*)(T0) const> { BOOST_STATIC_CONSTANT(bool,value = true); };
-template <class R,class T,class T0>
-struct is_mem_fun_pointer_impl<R (T::*)(T0) volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
-template <class R,class T,class T0>
-struct is_mem_fun_pointer_impl<R (T::*)(T0) const volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
-#endif // __MWERKS__ < 0x3000
+template <class R, class T ,  class T0>
+struct is_mem_fun_pointer_impl<R (T::*)( T0) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600))
+template <class R, class T ,  class T0>
+struct is_mem_fun_pointer_impl<R (T::*)( T0) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+template <class R, class T ,  class T0>
+struct is_mem_fun_pointer_impl<R (T::*)( T0) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+template <class R, class T ,  class T0>
+struct is_mem_fun_pointer_impl<R (T::*)( T0) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
 
-template <class R,class T,class T0,class T1>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1)> { BOOST_STATIC_CONSTANT(bool,value = true); };
-#if !defined(__MWERKS__) || __MWERKS__ >= 0x3000
-template <class R,class T,class T0,class T1>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1) const> { BOOST_STATIC_CONSTANT(bool,value = true); };
-template <class R,class T,class T0,class T1>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1) volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
-template <class R,class T,class T0,class T1>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1) const volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
-#endif // __MWERKS__ < 0x3000
+template <class R, class T ,  class T0 , class T1>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600))
+template <class R, class T ,  class T0 , class T1>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+template <class R, class T ,  class T0 , class T1>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+template <class R, class T ,  class T0 , class T1>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
 
-template <class R,class T,class T0,class T1,class T2>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2)> { BOOST_STATIC_CONSTANT(bool,value = true); };
-#if !defined(__MWERKS__) || __MWERKS__ >= 0x3000
-template <class R,class T,class T0,class T1,class T2>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2) const> { BOOST_STATIC_CONSTANT(bool,value = true); };
-template <class R,class T,class T0,class T1,class T2>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2) volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
-template <class R,class T,class T0,class T1,class T2>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2) const volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
-#endif // __MWERKS__ < 0x3000
+template <class R, class T ,  class T0 , class T1 , class T2>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600))
+template <class R, class T ,  class T0 , class T1 , class T2>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+template <class R, class T ,  class T0 , class T1 , class T2>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+template <class R, class T ,  class T0 , class T1 , class T2>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
 
-template <class R,class T,class T0,class T1,class T2,class T3>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3)> { BOOST_STATIC_CONSTANT(bool,value = true); };
-#if !defined(__MWERKS__) || __MWERKS__ >= 0x3000
-template <class R,class T,class T0,class T1,class T2,class T3>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3) const> { BOOST_STATIC_CONSTANT(bool,value = true); };
-template <class R,class T,class T0,class T1,class T2,class T3>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3) volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
-template <class R,class T,class T0,class T1,class T2,class T3>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3) const volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
-#endif // __MWERKS__ < 0x3000
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600))
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
 
-template <class R,class T,class T0,class T1,class T2,class T3,class T4>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4)> { BOOST_STATIC_CONSTANT(bool,value = true); };
-#if !defined(__MWERKS__) || __MWERKS__ >= 0x3000
-template <class R,class T,class T0,class T1,class T2,class T3,class T4>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4) const> { BOOST_STATIC_CONSTANT(bool,value = true); };
-template <class R,class T,class T0,class T1,class T2,class T3,class T4>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4) volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
-template <class R,class T,class T0,class T1,class T2,class T3,class T4>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4) const volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
-#endif // __MWERKS__ < 0x3000
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600))
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
 
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5)> { BOOST_STATIC_CONSTANT(bool,value = true); };
-#if !defined(__MWERKS__) || __MWERKS__ >= 0x3000
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5) const> { BOOST_STATIC_CONSTANT(bool,value = true); };
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5) volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5) const volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
-#endif // __MWERKS__ < 0x3000
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600))
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
 
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6)> { BOOST_STATIC_CONSTANT(bool,value = true); };
-#if !defined(__MWERKS__) || __MWERKS__ >= 0x3000
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6) const> { BOOST_STATIC_CONSTANT(bool,value = true); };
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6) volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6) const volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
-#endif // __MWERKS__ < 0x3000
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600))
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
 
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7)> { BOOST_STATIC_CONSTANT(bool,value = true); };
-#if !defined(__MWERKS__) || __MWERKS__ >= 0x3000
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7) const> { BOOST_STATIC_CONSTANT(bool,value = true); };
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7) volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7) const volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
-#endif // __MWERKS__ < 0x3000
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600))
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
 
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8)> { BOOST_STATIC_CONSTANT(bool,value = true); };
-#if !defined(__MWERKS__) || __MWERKS__ >= 0x3000
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8) const> { BOOST_STATIC_CONSTANT(bool,value = true); };
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8) volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8) const volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
-#endif // __MWERKS__ < 0x3000
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600))
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
 
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9)> { BOOST_STATIC_CONSTANT(bool,value = true); };
-#if !defined(__MWERKS__) || __MWERKS__ >= 0x3000
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9) const> { BOOST_STATIC_CONSTANT(bool,value = true); };
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9) volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9) const volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
-#endif // __MWERKS__ < 0x3000
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600))
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
 
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10)> { BOOST_STATIC_CONSTANT(bool,value = true); };
-#if !defined(__MWERKS__) || __MWERKS__ >= 0x3000
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10) const> { BOOST_STATIC_CONSTANT(bool,value = true); };
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10) volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10) const volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
-#endif // __MWERKS__ < 0x3000
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600))
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
 
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11)> { BOOST_STATIC_CONSTANT(bool,value = true); };
-#if !defined(__MWERKS__) || __MWERKS__ >= 0x3000
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11) const> { BOOST_STATIC_CONSTANT(bool,value = true); };
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11) volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11) const volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
-#endif // __MWERKS__ < 0x3000
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600))
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
 
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12)> { BOOST_STATIC_CONSTANT(bool,value = true); };
-#if !defined(__MWERKS__) || __MWERKS__ >= 0x3000
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12) const> { BOOST_STATIC_CONSTANT(bool,value = true); };
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12) volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12) const volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
-#endif // __MWERKS__ < 0x3000
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600))
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
 
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13)> { BOOST_STATIC_CONSTANT(bool,value = true); };
-#if !defined(__MWERKS__) || __MWERKS__ >= 0x3000
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13) const> { BOOST_STATIC_CONSTANT(bool,value = true); };
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13) volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13) const volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
-#endif // __MWERKS__ < 0x3000
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600))
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
 
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14)> { BOOST_STATIC_CONSTANT(bool,value = true); };
-#if !defined(__MWERKS__) || __MWERKS__ >= 0x3000
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14) const> { BOOST_STATIC_CONSTANT(bool,value = true); };
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14) volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14) const volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
-#endif // __MWERKS__ < 0x3000
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600))
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
 
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15)> { BOOST_STATIC_CONSTANT(bool,value = true); };
-#if !defined(__MWERKS__) || __MWERKS__ >= 0x3000
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15) const> { BOOST_STATIC_CONSTANT(bool,value = true); };
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15) volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15) const volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
-#endif // __MWERKS__ < 0x3000
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600))
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
 
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16)> { BOOST_STATIC_CONSTANT(bool,value = true); };
-#if !defined(__MWERKS__) || __MWERKS__ >= 0x3000
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16) const> { BOOST_STATIC_CONSTANT(bool,value = true); };
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16) volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16) const volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
-#endif // __MWERKS__ < 0x3000
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600))
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
 
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17)> { BOOST_STATIC_CONSTANT(bool,value = true); };
-#if !defined(__MWERKS__) || __MWERKS__ >= 0x3000
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17) const> { BOOST_STATIC_CONSTANT(bool,value = true); };
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17) volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17) const volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
-#endif // __MWERKS__ < 0x3000
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600))
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
 
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18)> { BOOST_STATIC_CONSTANT(bool,value = true); };
-#if !defined(__MWERKS__) || __MWERKS__ >= 0x3000
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18) const> { BOOST_STATIC_CONSTANT(bool,value = true); };
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18) volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18) const volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
-#endif // __MWERKS__ < 0x3000
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600))
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
 
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19)> { BOOST_STATIC_CONSTANT(bool,value = true); };
-#if !defined(__MWERKS__) || __MWERKS__ >= 0x3000
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19) const> { BOOST_STATIC_CONSTANT(bool,value = true); };
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19) volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19) const volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
-#endif // __MWERKS__ < 0x3000
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600))
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
 
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20)> { BOOST_STATIC_CONSTANT(bool,value = true); };
-#if !defined(__MWERKS__) || __MWERKS__ >= 0x3000
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20) const> { BOOST_STATIC_CONSTANT(bool,value = true); };
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20) volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20) const volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
-#endif // __MWERKS__ < 0x3000
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600))
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
 
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21)> { BOOST_STATIC_CONSTANT(bool,value = true); };
-#if !defined(__MWERKS__) || __MWERKS__ >= 0x3000
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21) const> { BOOST_STATIC_CONSTANT(bool,value = true); };
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21) volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21) const volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
-#endif // __MWERKS__ < 0x3000
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600))
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
 
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21,class T22>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22)> { BOOST_STATIC_CONSTANT(bool,value = true); };
-#if !defined(__MWERKS__) || __MWERKS__ >= 0x3000
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21,class T22>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22) const> { BOOST_STATIC_CONSTANT(bool,value = true); };
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21,class T22>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22) volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21,class T22>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22) const volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
-#endif // __MWERKS__ < 0x3000
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600))
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
 
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21,class T22,class T23>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23)> { BOOST_STATIC_CONSTANT(bool,value = true); };
-#if !defined(__MWERKS__) || __MWERKS__ >= 0x3000
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21,class T22,class T23>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23) const> { BOOST_STATIC_CONSTANT(bool,value = true); };
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21,class T22,class T23>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23) volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21,class T22,class T23>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23) const volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
-#endif // __MWERKS__ < 0x3000
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600))
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
 
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21,class T22,class T23,class T24>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24)> { BOOST_STATIC_CONSTANT(bool,value = true); };
-#if !defined(__MWERKS__) || __MWERKS__ >= 0x3000
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21,class T22,class T23,class T24>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24) const> { BOOST_STATIC_CONSTANT(bool,value = true); };
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21,class T22,class T23,class T24>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24) volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
-template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21,class T22,class T23,class T24>
-struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24) const volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
-#endif // __MWERKS__ < 0x3000
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600))
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+template <class R, class T ,  class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
+#endif
 
 #else
 
@@ -341,8 +341,8 @@ struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T1
 template <class R, class T BOOST_PP_COMMA_IF(i) BOOST_PP_ENUM_PARAMS(i,class T)>
 struct is_mem_fun_pointer_impl<R (T::*)(BOOST_PP_ENUM_PARAMS(i,T)) > { BOOST_STATIC_CONSTANT(bool, value = true); };
 
-// Metrowerks thinks this creates ambiguities
-//: #if !defined(__MWERKS__) || __MWERKS__ >= 0x3000
+// Metrowerks and Visual Age think this creates ambiguities
+//: #if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600))
 template <class R, class T BOOST_PP_COMMA_IF(i) BOOST_PP_ENUM_PARAMS(i,class T)>
 struct is_mem_fun_pointer_impl<R (T::*)(BOOST_PP_ENUM_PARAMS(i,T)) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
 
@@ -351,7 +351,7 @@ struct is_mem_fun_pointer_impl<R (T::*)(BOOST_PP_ENUM_PARAMS(i,T)) volatile > {
 
 template <class R, class T BOOST_PP_COMMA_IF(i) BOOST_PP_ENUM_PARAMS(i,class T)>
 struct is_mem_fun_pointer_impl<R (T::*)(BOOST_PP_ENUM_PARAMS(i,T)) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
-//: #endif // __MWERKS__ < 0x3000
+//: #endif
 
 
 #undef i

boost/boost/type_traits/detail/size_t_trait_def.hpp

@@ -17,7 +17,7 @@
 // no include guards, the header is intended for multiple inclusion!
 
 #include "boost/type_traits/detail/template_arity_spec.hpp"
-#include "boost/mpl/size_t_c.hpp"
+#include "boost/mpl/size_t.hpp"
 #include "boost/mpl/aux_/lambda_support.hpp"
 
 #include <cstddef>
@@ -26,7 +26,7 @@
 #   define BOOST_TT_AUX_SIZE_T_TRAIT_VALUE_DECL(C) /**/
 #else
 #   define BOOST_TT_AUX_SIZE_T_TRAIT_VALUE_DECL(C) \
-    typedef mpl::size_t_c< C > base_; \
+    typedef mpl::size_t< C > base_; \
     using base_::value; \
     /**/
 #endif
@@ -34,7 +34,7 @@
 
 #define BOOST_TT_AUX_SIZE_T_TRAIT_DEF1(trait,T,C) \
 template< typename T > struct trait \
-    : mpl::size_t_c< C > \
+    : mpl::size_t< C > \
 { \
     BOOST_TT_AUX_SIZE_T_TRAIT_VALUE_DECL(C) \
     BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) \
@@ -45,7 +45,7 @@ BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait) \
 
 #define BOOST_TT_AUX_SIZE_T_TRAIT_SPEC1(trait,spec,C) \
 template<> struct trait<spec> \
-    : mpl::size_t_c< C > \
+    : mpl::size_t< C > \
 { \
     BOOST_TT_AUX_SIZE_T_TRAIT_VALUE_DECL(C) \
     BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(spec)) \
@@ -54,7 +54,7 @@ template<> struct trait<spec> \
 
 #define BOOST_TT_AUX_SIZE_T_TRAIT_PARTIAL_SPEC1_1(param,trait,spec,C) \
 template< param > struct trait<spec> \
-    : mpl::size_t_c< C > \
+    : mpl::size_t< C > \
 { \
 }; \
 /**/

boost/boost/type_traits/is_base_and_derived.hpp

@@ -1,5 +1,5 @@
 
-// (C) Copyright Rani Sharoni 2002.
+// (C) Copyright Rani Sharoni 2003.
 // 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 
@@ -25,6 +25,7 @@ namespace boost {
 namespace detail {
 
 #if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x570)) \
+ && !BOOST_WORKAROUND(__SUNPRO_CC , BOOST_TESTED_AT(0x540)) \
  && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
                              // The EDG version number is a lower estimate.
                              // It is not currently known which EDG version
@@ -35,58 +36,73 @@ namespace detail {
 This version detects ambiguous base classes and private base classes
 correctly, and was devised by Rani Sharoni.
 
-The following explanation is by Terje Slettebo:
+Explanation by Terje Slettebø and Rani Sharoni.
 
-Let's take the multiple base class below as an example, and the
-following will also show why there's not a problem with ambiguous base
+Let's take the multiple base class below as an example, and the following
+will also show why there's not a problem with private or ambiguous base
 class:
 
 struct B {};
 struct B1 : B {};
 struct B2 : B {};
-struct D : B1, private B2 {};
+struct D : private B1, private B2 {};
 
-typedef char Test[is_base_and_derived<B, D>::result]; // improvement 1 -
-multiple base
+is_base_and_derived<B, D>::value;
 
+First, some terminology:
 
-We have several possible conversion sequences:
+SC  - Standard conversion
+UDC - User-defined conversion
 
-For "static no check(B const volatile *, int)" we have the conversion
+A user-defined conversion sequence consists of an SC, followed by an UDC,
+followed by another SC. Either SC may be the identity conversion.
+
+When passing the default-constructed Host object to the overloaded check()
+functions (initialization 8.5/14/4/3), we have several viable implicit
+conversion sequences:
+
+For "static no_type check(B const volatile *, int)" we have the conversion
 sequences:
-   C -> C const -> B*
-and
-   C -> D* -> B1*|B2* -> B*
 
-For "static yes check(D const volatile *, T)" we have the conversion
+C -> C const (SC - Qualification Adjustment) -> B const volatile* (UDC)
+C -> D const volatile* (UDC) -> B1 const volatile* / B2 const volatile* ->
+     B const volatile* (SC - Conversion)
+
+For "static yes_type check(D const volatile *, T)" we have the conversion
 sequence:
-   C -> D*
 
-Since, for the purpose of selecting the appropriate user-defined conversion
-for a given function, it only considers up to the user-defined conversion,
-for the first function this means choosing between C -> C const and C -> C,
-and it chooses the latter. Therefore, we have:
+C -> D const volatile* (UDC)
 
-C -> D* -> B1*|B2* -> B*
-C -> D*
+According to 13.3.3.1/4, in context of user-defined conversion only the
+standard conversion sequence is considered when selecting the best viable
+function, so it only considers up to the user-defined conversion. For the
+first function this means choosing between C -> C const and C -> C, and it
+chooses the latter, because it's a proper subset (13.3.3.2/3/2) of the
+former. Therefore, we have:
 
-Here, the principle of the "shortest subsequence" applies, and it chooses
-C -> D*. This shows that it doesn't even need to consider the multiple paths
-to B, as that possibility is eliminated before it could possibly cause
-ambiguity. Nifty. :)
+C -> D const volatile* (UDC) -> B1 const volatile* / B2 const volatile* ->
+     B const volatile* (SC - Conversion)
+C -> D const volatile* (UDC)
 
-As Daveed notes in the posting Rani gives a link to in the clc++m posting,
-if D is not derived from B, it has to choose between C -> C const -> B* for
-the first function, and C -> D* for the second function, which are just as
-good, _had it not been for the fact that "static no check(B const volatile
-&, int)" is not templated (as Rani points out in the posting)_, which makes
-C -> C const -> B* the best choice, resulting in "no".
+Here, the principle of the "shortest subsequence" applies again, and it
+chooses C -> D const volatile*. This shows that it doesn't even need to
+consider the multiple paths to B, or accessibility, as that possibility is
+eliminated before it could possibly cause ambiguity or access violation.
 
-Also, if C::operator B* hadn't been const, the two conversion sequences for
-"static no check(B const volatile *, int)" would have been ambiguous.
+If D is not derived from B, it has to choose between C -> C const -> B const
+volatile* for the first function, and C -> D const volatile* for the second
+function, which are just as good (both requires a UDC, 13.3.3.2), had it not
+been for the fact that "static no_type check(B const volatile *, int)" is
+not templated, which makes C -> C const -> B const volatile* the best choice
+(13.3.3/1/4), resulting in "no".
 
-See also http://groups.google.com/groups?selm=df893da6.0301280859.522081f7%40posting.google.com
-and links therein.
+Also, if Host::operator B const volatile* hadn't been const, the two
+conversion sequences for "static no_type check(B const volatile *, int)", in
+the case where D is derived from B, would have been ambiguous.
+
+See also
+http://groups.google.com/groups?selm=df893da6.0301280859.522081f7%40posting.
+google.com and links therein.
 
 *************************************************************************/
 
@@ -189,5 +205,3 @@ BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(typename Base,typename Derived,is_base_a
 #include "boost/type_traits/detail/bool_trait_undef.hpp"
 
 #endif // BOOST_TT_IS_BASE_AND_DERIVED_HPP_INCLUDED
-
-