passenger 6.0.2 → 6.0.15

data/src/cxx_supportlib/vendor-modified/boost/type_traits/is_virtual_base_of.hpp

@@ -1,4 +1,5 @@
 //  (C) Copyright Daniel Frey and Robert Ramey 2009.
+//  (C) Copyright Balint Cserni 2017
 //  Use, modification and distribution are subject to the Boost Software License,
 //  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt).
@@ -10,9 +11,11 @@
 
 #include <boost/type_traits/is_base_of.hpp>
 #include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/make_void.hpp>
+#include <utility>
 
 namespace boost {
-namespace detail {
+   namespace detail {
 
 
 #ifdef BOOST_MSVC
@@ -22,84 +25,122 @@ namespace detail {
 #pragma GCC system_header
 #endif
 
-template<typename Base, typename Derived, typename tag>
-struct is_virtual_base_of_impl
-{
-    BOOST_STATIC_CONSTANT(bool, value = false);
-};
+#if !defined(BOOST_NO_SFINAE_EXPR) && !defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS) && !defined(BOOST_NO_CXX11_NULLPTR) && !BOOST_WORKAROUND(BOOST_GCC, < 40800)
 
-template<typename Base, typename Derived>
-struct is_virtual_base_of_impl<Base, Derived, true_type>
-{
-   union max_align
+      // Implementation based on the standard's rules of explicit type conversions.
+      // A pointer to an object of *derived* class type may be explicitly converted to a pointer to an *unambiguous* *base* class type.
+      // A pointer to an object of an *unambiguous* *non-virtual* *base* class type may be explicitly converted to a pointer of a *derived* class type.
+      // Therefore Derived has a virtual base Base if and only if
+      //   (1) a Derived* can be converted to Base* (so the base class is unambiguous, which comes necessarily from virtual inheritance)
+      //   (2) a Base* cannot be converted to Derived* (so the base class is either ambiguous or virtual)
+      // With both conditions true, Base must be a virtual base of Derived.
+      // The "is_base_of" is only needed so the compiler can (but is not required to) error out if the types are incomplete.
+      // This is in league with the the expected behaviour.
+
+      template<class T, class U>
+      constexpr bool is_virtual_base_impl(...) { return true; }
+
+      // C-style casts have the power to ignore inheritance visibility while still act as a static_cast.
+      // They can also fall back to the behaviour of reinterpret_cast, which allows is_virtual_base_of to work on non-class types too.
+      // Note that because we are casting pointers there can be no user-defined operators to interfere.
+      template<class T, class U,
+         typename boost::make_void<decltype((U*)(std::declval<T*>()))>::type* =
+         nullptr>
+         constexpr bool is_virtual_base_impl(int) { return false; }
+
+   } // namespace detail
+
+   template<class T, class U>
+   struct is_virtual_base_of : public
+      boost::integral_constant<
+      bool,
+      boost::is_base_of<T, U>::value &&
+      detail::is_virtual_base_impl<T, U>(0) &&
+      !detail::is_virtual_base_impl<U, T>(0)
+      > {};
+
+#else
+
+   template<typename Base, typename Derived, typename tag>
+   struct is_virtual_base_of_impl
+   {
+      BOOST_STATIC_CONSTANT(bool, value = false);
+   };
+
+   template<typename Base, typename Derived>
+   struct is_virtual_base_of_impl<Base, Derived, true_type>
    {
-      unsigned u;
-      unsigned long ul;
-      void* v;
-      double d;
-      long double ld;
+      union max_align
+      {
+         unsigned u;
+         unsigned long ul;
+         void* v;
+         double d;
+         long double ld;
 #ifndef BOOST_NO_LONG_LONG
-      long long ll;
+         long long ll;
 #endif
-   };
-#ifdef __BORLANDC__
-    struct boost_type_traits_internal_struct_X : public virtual Derived, public virtual Base 
-    {
-       boost_type_traits_internal_struct_X();
-       boost_type_traits_internal_struct_X(const boost_type_traits_internal_struct_X&);
-       boost_type_traits_internal_struct_X& operator=(const boost_type_traits_internal_struct_X&);
-       ~boost_type_traits_internal_struct_X()throw();
-       max_align data[4];
-    };
-    struct boost_type_traits_internal_struct_Y : public virtual Derived 
-    {
-       boost_type_traits_internal_struct_Y();
-       boost_type_traits_internal_struct_Y(const boost_type_traits_internal_struct_Y&);
-       boost_type_traits_internal_struct_Y& operator=(const boost_type_traits_internal_struct_Y&);
-       ~boost_type_traits_internal_struct_Y()throw();
-       max_align data[4];
-    };
+      };
+#ifdef BOOST_BORLANDC
+      struct boost_type_traits_internal_struct_X : public virtual Derived, public virtual Base
+      {
+         boost_type_traits_internal_struct_X();
+         boost_type_traits_internal_struct_X(const boost_type_traits_internal_struct_X&);
+         boost_type_traits_internal_struct_X& operator=(const boost_type_traits_internal_struct_X&);
+         ~boost_type_traits_internal_struct_X()throw();
+         max_align data[4];
+      };
+      struct boost_type_traits_internal_struct_Y : public virtual Derived
+      {
+         boost_type_traits_internal_struct_Y();
+         boost_type_traits_internal_struct_Y(const boost_type_traits_internal_struct_Y&);
+         boost_type_traits_internal_struct_Y& operator=(const boost_type_traits_internal_struct_Y&);
+         ~boost_type_traits_internal_struct_Y()throw();
+         max_align data[4];
+      };
 #else
-    struct boost_type_traits_internal_struct_X : public Derived, virtual Base 
-    {
-       boost_type_traits_internal_struct_X();
-       boost_type_traits_internal_struct_X(const boost_type_traits_internal_struct_X&);
-       boost_type_traits_internal_struct_X& operator=(const boost_type_traits_internal_struct_X&);
-       ~boost_type_traits_internal_struct_X()throw();
-       max_align data[16];
-    };
-    struct boost_type_traits_internal_struct_Y : public Derived 
-    {
-       boost_type_traits_internal_struct_Y();
-       boost_type_traits_internal_struct_Y(const boost_type_traits_internal_struct_Y&);
-       boost_type_traits_internal_struct_Y& operator=(const boost_type_traits_internal_struct_Y&);
-       ~boost_type_traits_internal_struct_Y()throw();
-       max_align data[16];
-    };
+      struct boost_type_traits_internal_struct_X : public Derived, virtual Base
+      {
+         boost_type_traits_internal_struct_X();
+         boost_type_traits_internal_struct_X(const boost_type_traits_internal_struct_X&);
+         boost_type_traits_internal_struct_X& operator=(const boost_type_traits_internal_struct_X&);
+         ~boost_type_traits_internal_struct_X()throw();
+         max_align data[16];
+      };
+      struct boost_type_traits_internal_struct_Y : public Derived
+      {
+         boost_type_traits_internal_struct_Y();
+         boost_type_traits_internal_struct_Y(const boost_type_traits_internal_struct_Y&);
+         boost_type_traits_internal_struct_Y& operator=(const boost_type_traits_internal_struct_Y&);
+         ~boost_type_traits_internal_struct_Y()throw();
+         max_align data[16];
+      };
 #endif
-    BOOST_STATIC_CONSTANT(bool, value = (sizeof(boost_type_traits_internal_struct_X)==sizeof(boost_type_traits_internal_struct_Y)));
-};
-
-template<typename Base, typename Derived>
-struct is_virtual_base_of_impl2
-{
-   typedef boost::integral_constant<bool, (boost::is_base_of<Base, Derived>::value && ! boost::is_same<Base, Derived>::value)> tag_type;
-   typedef is_virtual_base_of_impl<Base, Derived, tag_type> imp;
-   BOOST_STATIC_CONSTANT(bool, value = imp::value);
-};
+      BOOST_STATIC_CONSTANT(bool, value = (sizeof(boost_type_traits_internal_struct_X) == sizeof(boost_type_traits_internal_struct_Y)));
+   };
 
-#ifdef BOOST_MSVC
-#pragma warning( pop )
-#endif
+   template<typename Base, typename Derived>
+   struct is_virtual_base_of_impl2
+   {
+      typedef boost::integral_constant<bool, (boost::is_base_of<Base, Derived>::value && !boost::is_same<Base, Derived>::value)> tag_type;
+      typedef is_virtual_base_of_impl<Base, Derived, tag_type> imp;
+      BOOST_STATIC_CONSTANT(bool, value = imp::value);
+   };
 
 } // namespace detail
 
-template <class Base, class Derived> struct is_virtual_base_of : public integral_constant<bool, (::boost::detail::is_virtual_base_of_impl2<Base, Derived>::value)>{};
+template <class Base, class Derived> struct is_virtual_base_of : public integral_constant<bool, (::boost::detail::is_virtual_base_of_impl2<Base, Derived>::value)> {};
+
+#endif
 
 template <class Base, class Derived> struct is_virtual_base_of<Base&, Derived> : public false_type{};
 template <class Base, class Derived> struct is_virtual_base_of<Base, Derived&> : public false_type{};
 template <class Base, class Derived> struct is_virtual_base_of<Base&, Derived&> : public false_type{};
 
+#ifdef BOOST_MSVC
+#pragma warning( pop )
+#endif
+
 } // namespace boost
 
 #endif

data/src/cxx_supportlib/vendor-modified/boost/type_traits/is_volatile.hpp

@@ -26,7 +26,7 @@
 
 namespace boost {
 
-#if defined( __CODEGEARC__ )
+#if defined( BOOST_CODEGEARC )
 
    template <class T>
    struct is_volatile : public integral_constant<bool, __is_volatile(T)> {};

data/src/cxx_supportlib/vendor-modified/boost/type_traits/make_void.hpp

@@ -1,6 +1,6 @@
 /*
 Copyright 2017 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
+(glenjofe@gmail.com)
 
 Distributed under the Boost Software License,
 Version 1.0. (See accompanying file LICENSE_1_0.txt

data/src/cxx_supportlib/vendor-modified/boost/type_traits/negation.hpp

@@ -0,0 +1,23 @@
+/*
+Copyright 2020 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License,
+Version 1.0. (See accompanying file LICENSE_1_0.txt
+or copy at http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+#ifndef BOOST_TT_NEGATION_HPP_INCLUDED
+#define BOOST_TT_NEGATION_HPP_INCLUDED
+
+#include <boost/type_traits/integral_constant.hpp>
+
+namespace boost {
+
+template<class T>
+struct negation
+    : integral_constant<bool, !bool(T::value)> { };
+
+} /* boost */
+
+#endif

data/src/cxx_supportlib/vendor-modified/boost/type_traits/nonesuch.hpp

@@ -1,6 +1,6 @@
 /*
 Copyright 2017 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
+(glenjofe@gmail.com)
 
 Distributed under the Boost Software License,
 Version 1.0. (See accompanying file LICENSE_1_0.txt

data/src/cxx_supportlib/vendor-modified/boost/type_traits/rank.hpp

@@ -15,7 +15,7 @@
 
 namespace boost {
 
-#if !defined( __CODEGEARC__ )
+#if !defined( BOOST_CODEGEARC )
 
 namespace detail{
 
@@ -49,7 +49,7 @@ struct rank_imp<T const volatile[R], N>
    BOOST_STATIC_CONSTANT(std::size_t, value = (::boost::detail::rank_imp<T, N+1>::value));
 };
 
-#if !BOOST_WORKAROUND(__BORLANDC__, < 0x600) && !defined(__IBMCPP__) &&  !BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840))
+#if !BOOST_WORKAROUND(BOOST_BORLANDC, < 0x600) && !defined(__IBMCPP__) &&  !BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840))
 template <class T, std::size_t N>
 struct rank_imp<T[], N>
 {
@@ -74,9 +74,9 @@ struct rank_imp<T const volatile[], N>
 #endif
 }
 
-#endif // !defined( __CODEGEARC__ )
+#endif // !defined( BOOST_CODEGEARC )
 
-#if defined( __CODEGEARC__ )
+#if defined( BOOST_CODEGEARC )
 template <class T> struct rank : public integral_constant<std::size_t, __array_rank(T)>{};
 #else
 template <class T> struct rank : public integral_constant<std::size_t, (::boost::detail::rank_imp<T, 0>::value)>{};

data/src/cxx_supportlib/vendor-modified/boost/type_traits/remove_all_extents.hpp

@@ -22,7 +22,7 @@ template <class T, std::size_t N> struct remove_all_extents<T[N]> : public remov
 template <class T, std::size_t N> struct remove_all_extents<T const[N]> : public remove_all_extents<T const>{};
 template <class T, std::size_t N> struct remove_all_extents<T volatile[N]> : public remove_all_extents<T volatile>{};
 template <class T, std::size_t N> struct remove_all_extents<T const volatile[N]> : public remove_all_extents<T const volatile>{};
-#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610)) && !defined(__IBMCPP__) &&  !BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840))
+#if !BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x610)) && !defined(__IBMCPP__) &&  !BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840))
 template <class T> struct remove_all_extents<T[]> : public remove_all_extents<T>{};
 template <class T> struct remove_all_extents<T const[]> : public remove_all_extents<T const>{};
 template <class T> struct remove_all_extents<T volatile[]> : public remove_all_extents<T volatile>{};

data/src/cxx_supportlib/vendor-modified/boost/type_traits/remove_const.hpp

@@ -23,7 +23,7 @@ namespace boost {
 
 #if !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS)
    template <class T, std::size_t N> struct remove_const<T const[N]>{ typedef T type[N]; };
-#if !BOOST_WORKAROUND(__BORLANDC__, < 0x600) && !defined(__IBMCPP__) &&  !BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840))
+#if !BOOST_WORKAROUND(BOOST_BORLANDC, < 0x600) && !defined(__IBMCPP__) &&  !BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840))
    template <class T> struct remove_const<T const[]>{ typedef T type[]; };
 #endif
 #endif

data/src/cxx_supportlib/vendor-modified/boost/type_traits/remove_cv.hpp

@@ -27,7 +27,7 @@ template <class T> struct remove_cv<T const volatile>{ typedef T type; };
 template <class T, std::size_t N> struct remove_cv<T const[N]>{ typedef T type[N]; };
 template <class T, std::size_t N> struct remove_cv<T const volatile[N]>{ typedef T type[N]; };
 template <class T, std::size_t N> struct remove_cv<T volatile[N]>{ typedef T type[N]; };
-#if !BOOST_WORKAROUND(__BORLANDC__, < 0x600) && !defined(__IBMCPP__) &&  !BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840))
+#if !BOOST_WORKAROUND(BOOST_BORLANDC, < 0x600) && !defined(__IBMCPP__) &&  !BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840))
 template <class T> struct remove_cv<T const[]>{ typedef T type[]; };
 template <class T> struct remove_cv<T const volatile[]>{ typedef T type[]; };
 template <class T> struct remove_cv<T volatile[]>{ typedef T type[]; };

data/src/cxx_supportlib/vendor-modified/boost/type_traits/remove_extent.hpp

@@ -22,7 +22,7 @@ template <typename T, std::size_t N> struct remove_extent<T[N]> { typedef T type
 template <typename T, std::size_t N> struct remove_extent<T const[N]> { typedef T const type; };
 template <typename T, std::size_t N> struct remove_extent<T volatile [N]> { typedef T volatile type; };
 template <typename T, std::size_t N> struct remove_extent<T const volatile [N]> { typedef T const volatile type; };
-#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610)) && !defined(__IBMCPP__) &&  !BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840))
+#if !BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x610)) && !defined(__IBMCPP__) &&  !BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840))
 template <typename T> struct remove_extent<T[]> { typedef T type; };
 template <typename T> struct remove_extent<T const[]> { typedef T const type; };
 template <typename T> struct remove_extent<T volatile[]> { typedef T volatile type; };

data/src/cxx_supportlib/vendor-modified/boost/type_traits/remove_volatile.hpp

@@ -23,7 +23,7 @@ namespace boost {
 
 #if !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS)
    template <class T, std::size_t N> struct remove_volatile<T volatile[N]>{ typedef T type[N]; };
-#if !BOOST_WORKAROUND(__BORLANDC__, < 0x600) && !defined(__IBMCPP__) &&  !BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840))
+#if !BOOST_WORKAROUND(BOOST_BORLANDC, < 0x600) && !defined(__IBMCPP__) &&  !BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840))
    template <class T> struct remove_volatile<T volatile[]>{ typedef T type[]; };
 #endif
 #endif

data/src/cxx_supportlib/vendor-modified/boost/type_traits/type_with_alignment.hpp

@@ -25,7 +25,7 @@
 #endif
 
 namespace boost {
-#ifndef __BORLANDC__
+#ifndef BOOST_BORLANDC
    namespace detail{
 
       union max_align
@@ -120,7 +120,7 @@ template<> struct is_pod< ::boost::tt_align_ns::a128> : public true_type{};
 // registers.  Therefore we extend type_with_alignment<> to support
 // such types, however, we have to be careful to use a builtin type
 // whenever possible otherwise we break previously working code:
-// see http://article.gmane.org/gmane.comp.lib.boost.devel/173011
+// see https://lists.boost.org/Archives/boost/2014/03/212391.php
 // for an example and test case.  Thus types like a8 below will
 // be used *only* if the existing implementation can't provide a type
 // with suitable alignment.  This does mean however, that type_with_alignment<>
@@ -227,7 +227,7 @@ namespace detail {
 typedef ::boost::tt_align_ns::a16 max_align;
 
 }
-//#if ! BOOST_WORKAROUND(__CODEGEARC__, BOOST_TESTED_AT(0x610))
+//#if ! BOOST_WORKAROUND(BOOST_CODEGEARC, BOOST_TESTED_AT(0x610))
 template <> struct is_pod< ::boost::tt_align_ns::a2> : public true_type{};
 template <> struct is_pod< ::boost::tt_align_ns::a4> : public true_type{};
 template <> struct is_pod< ::boost::tt_align_ns::a8> : public true_type{};

data/src/cxx_supportlib/vendor-modified/boost/typeof/constant.hpp

@@ -0,0 +1,26 @@
+/*
+Copyright 2018 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_TYPEOF_CONSTANT_HPP
+#define BOOST_TYPEOF_CONSTANT_HPP
+
+#include <boost/config.hpp>
+
+namespace boost {
+namespace type_of {
+
+template<class T, T N>
+struct constant {
+    typedef constant<T, N> type;
+    typedef constant<T, N + 1> next;
+    BOOST_STATIC_CONSTANT(T, value=N);
+};
+
+} /* type_of */
+} /* boost */
+
+#endif

data/src/cxx_supportlib/vendor-modified/boost/typeof/dmc/typeof_impl.hpp

@@ -7,8 +7,8 @@
 # define BOOST_TYPEOF_MSVC_TYPEOF_IMPL_HPP_INCLUDED
 
 # include <boost/config.hpp>
-# include <boost/detail/workaround.hpp>
-# include <boost/mpl/int.hpp>
+# include <boost/config/workaround.hpp>
+# include <boost/typeof/constant.hpp>
 
 namespace boost
 {
@@ -45,7 +45,7 @@ namespace boost
 
         template<int ID>
         struct msvc_typeid_wrapper {
-            typedef typename msvc_extract_type<mpl::int_<ID> >::id2type id2type;
+            typedef typename msvc_extract_type<constant<int,ID> >::id2type id2type;
             typedef typename id2type::type type;
         };
 
@@ -56,7 +56,7 @@ namespace boost
             //Get the next available compile time constants index
             BOOST_STATIC_CONSTANT(unsigned,value=BOOST_TYPEOF_INDEX(T));
             //Instantiate the template
-            typedef typename msvc_register_type<T,mpl::int_<value> >::id2type type;
+            typedef typename msvc_register_type<T,constant<int,value> >::id2type type;
             //Set the next compile time constants index
             BOOST_STATIC_CONSTANT(unsigned,next=value+1);
             //Increment the compile time constant (only needed when extensions are not active

data/src/cxx_supportlib/vendor-modified/boost/typeof/encode_decode.hpp

@@ -8,9 +8,6 @@
 #ifndef BOOST_TYPEOF_ENCODE_DECODE_HPP_INCLUDED
 #define BOOST_TYPEOF_ENCODE_DECODE_HPP_INCLUDED
 
-#include <boost/mpl/deref.hpp>
-#include <boost/mpl/next.hpp>
-
 #ifndef BOOST_TYPEOF_SUPPRESS_UNNAMED_NAMESPACE
 
 #   define BOOST_TYPEOF_BEGIN_ENCODE_NS namespace { namespace boost_typeof {

data/src/cxx_supportlib/vendor-modified/boost/typeof/encode_decode_params.hpp

@@ -28,7 +28,7 @@
 
 #define BOOST_TYPEOF_ENCODE_PARAMS(n, ID)                   \
     BOOST_PP_REPEAT(n, BOOST_TYPEOF_ENCODE_PARAMS_BEGIN, ~) \
-    typename boost::type_of::push_back<V, boost::mpl::size_t<ID> >::type      \
+    typename boost::type_of::push_back<V, boost::type_of::constant<std::size_t,ID> >::type      \
     BOOST_PP_REPEAT(n, BOOST_TYPEOF_ENCODE_PARAMS_END, ~)
 
 #endif//BOOST_TYPEOF_ENCODE_DECODE_PARAMS_HPP_INCLUDED

data/src/cxx_supportlib/vendor-modified/boost/typeof/int_encoding.hpp

@@ -5,9 +5,9 @@
 #ifndef BOOST_TYPEOF_INT_ENCODING_HPP_INCLUDED
 #define BOOST_TYPEOF_INT_ENCODING_HPP_INCLUDED
 
-#include <boost/mpl/if.hpp>
-#include <boost/mpl/size_t.hpp>
 #include <boost/config.hpp>
+#include <boost/typeof/constant.hpp>
+#include <cstddef> // for std::size_t
 
 namespace boost { namespace type_of {
 
@@ -56,15 +56,15 @@ namespace boost { namespace type_of {
     template<class V, std::size_t n, bool overflow = (n >= 0x3fffffff)>
     struct encode_size_t : push_back<
         V,
-        boost::mpl::size_t<pack<n, false>::value>
+        boost::type_of::constant<std::size_t,pack<n, false>::value>
     >
     {};
 
     template<class V, std::size_t n>
     struct encode_size_t<V, n, true> : push_back<typename push_back<
         V,
-        boost::mpl::size_t<pack<n % 0x3ffffffe, true>::value> >::type,
-        boost::mpl::size_t<n / 0x3ffffffe>
+        boost::type_of::constant<std::size_t,pack<n % 0x3ffffffe, true>::value> >::type,
+        boost::type_of::constant<std::size_t,n / 0x3ffffffe>
     >
     {};
 

data/src/cxx_supportlib/vendor-modified/boost/typeof/modifiers.hpp

@@ -19,11 +19,11 @@
             typename boost::type_of::encode_type<\
             typename boost::type_of::push_back<\
             V\
-            , boost::mpl::size_t<ID> >::type\
+            , boost::type_of::constant<std::size_t,ID> >::type\
             , T>::type\
             type;\
     };\
-    template<class Iter> struct decode_type_impl<boost::mpl::size_t<ID>, Iter>\
+    template<class Iter> struct decode_type_impl<boost::type_of::constant<std::size_t,ID>, Iter>\
     {\
         typedef boost::type_of::decode_type<Iter> d1;\
         typedef Fun(typename d1::type) type;\
@@ -37,7 +37,7 @@
 #define BOOST_TYPEOF_pointer_fun(T) T*
 #define BOOST_TYPEOF_reference_fun(T) T&
 
-#if defined(__BORLANDC__) && (__BORLANDC__ < 0x600)
+#if defined(__BORLANDC__) && !defined(__clang__) && (__BORLANDC__ < 0x600)
 //Borland incorrectly handles T const, T const volatile and T volatile.
 //It drops the decoration no matter what, so we need to try to handle T* const etc. without loosing the top modifier.
 #define BOOST_TYPEOF_const_pointer_fun(T) T const *
@@ -56,7 +56,7 @@ BOOST_TYPEOF_modifier_support(BOOST_TYPEOF_UNIQUE_ID(), BOOST_TYPEOF_volatile_co
 BOOST_TYPEOF_modifier_support(BOOST_TYPEOF_UNIQUE_ID(), BOOST_TYPEOF_pointer_fun);
 BOOST_TYPEOF_modifier_support(BOOST_TYPEOF_UNIQUE_ID(), BOOST_TYPEOF_reference_fun);
 
-#if defined(__BORLANDC__) && (__BORLANDC__ < 0x600)
+#if defined(__BORLANDC__) && !defined(__clang__) && (__BORLANDC__ < 0x600)
 BOOST_TYPEOF_modifier_support(BOOST_TYPEOF_UNIQUE_ID(), BOOST_TYPEOF_const_pointer_fun);
 BOOST_TYPEOF_modifier_support(BOOST_TYPEOF_UNIQUE_ID(), BOOST_TYPEOF_const_reference_fun);
 BOOST_TYPEOF_modifier_support(BOOST_TYPEOF_UNIQUE_ID(), BOOST_TYPEOF_volatile_pointer_fun);
@@ -74,7 +74,7 @@ BOOST_TYPEOF_END_ENCODE_NS
 #undef BOOST_TYPEOF_pointer_fun
 #undef BOOST_TYPEOF_reference_fun
 
-#if defined(__BORLANDC__) && (__BORLANDC__ < 0x600)
+#if defined(__BORLANDC__) && !defined(__clang__) && (__BORLANDC__ < 0x600)
 #undef BOOST_TYPEOF_const_pointer_fun
 #undef BOOST_TYPEOF_const_reference_fun
 #undef BOOST_TYPEOF_volatile_pointer_fun
@@ -94,13 +94,13 @@ BOOST_TYPEOF_END_ENCODE_NS
             typename boost::type_of::push_back<\
             typename boost::type_of::push_back<\
             V\
-            , boost::mpl::size_t<ID> >::type\
-            , boost::mpl::size_t<N> >::type\
+            , boost::type_of::constant<std::size_t,ID> >::type\
+            , boost::type_of::constant<std::size_t,N> >::type\
             , T>::type\
         type;\
     };\
     template<class Iter>\
-    struct decode_type_impl<boost::mpl::size_t<ID>, Iter>\
+    struct decode_type_impl<boost::type_of::constant<std::size_t,ID>, Iter>\
     {\
         enum{n = Iter::type::value};\
         typedef boost::type_of::decode_type<typename Iter::next> d;\

data/src/cxx_supportlib/vendor-modified/boost/typeof/msvc/typeof_impl.hpp

@@ -10,10 +10,10 @@
 # define BOOST_TYPEOF_MSVC_TYPEOF_IMPL_HPP_INCLUDED
 
 # include <boost/config.hpp>
-# include <boost/detail/workaround.hpp>
-# include <boost/mpl/int.hpp>
+# include <boost/config/workaround.hpp>
+# include <boost/typeof/constant.hpp>
+# include <boost/type_traits/enable_if.hpp>
 # include <boost/type_traits/is_function.hpp>
-# include <boost/utility/enable_if.hpp>
 
 # include <typeinfo>
 
@@ -135,7 +135,7 @@ namespace boost
 
         template<int ID>
         struct msvc_typeid_wrapper {
-            typedef typename msvc_extract_type<mpl::int_<ID> >::id2type id2type;
+            typedef typename msvc_extract_type<constant<int,ID> >::id2type id2type;
             typedef typename id2type::type type;
         };
         //Workaround for ETI-bug for VC6 and VC7
@@ -156,7 +156,7 @@ namespace boost
             //Get the next available compile time constants index
             BOOST_STATIC_CONSTANT(unsigned,value=BOOST_TYPEOF_INDEX(T));
             //Instantiate the template
-            typedef typename msvc_register_type<T,mpl::int_<value> >::id2type type;
+            typedef typename msvc_register_type<T,constant<int,value> >::id2type type;
             //Set the next compile time constants index
             BOOST_STATIC_CONSTANT(unsigned,next=value+1);
             //Increment the compile time constant (only needed when extensions are not active
@@ -168,12 +168,12 @@ namespace boost
         {
             typedef char(*type)[encode_type<T>::value];
         };
-        template<typename T> typename disable_if<
-            typename is_function<T>::type,
+        template<typename T> typename enable_if_<
+            !is_function<T>::value,
             typename sizer<T>::type>::type encode_start(T const&);
 
-        template<typename T> typename enable_if<
-            typename is_function<T>::type,
+        template<typename T> typename enable_if_<
+            is_function<T>::value,
             typename sizer<T>::type>::type encode_start(T&);
         template<typename Organizer, typename T>
         msvc_register_type<T,Organizer> typeof_register_type(const T&,Organizer* =0);

data/src/cxx_supportlib/vendor-modified/boost/typeof/native.hpp

@@ -18,8 +18,8 @@ namespace boost { namespace type_of {
 
 #else
 
+#include <boost/type_traits/enable_if.hpp>
 #include <boost/type_traits/is_function.hpp> 
-#include <boost/utility/enable_if.hpp>
 
 namespace boost { namespace type_of {
 # ifdef BOOST_NO_SFINAE
@@ -27,11 +27,11 @@ namespace boost { namespace type_of {
     T& ensure_obj(const T&);
 # else
     template<typename T>
-        typename enable_if<is_function<T>, T&>::type
+        typename enable_if_<is_function<T>::value, T&>::type
         ensure_obj(T&);
 
     template<typename T>
-        typename disable_if<is_function<T>, T&>::type
+        typename enable_if_<!is_function<T>::value, T&>::type
         ensure_obj(const T&);
 # endif
 }}

data/src/cxx_supportlib/vendor-modified/boost/typeof/pointers_data_members.hpp

@@ -21,7 +21,7 @@ struct encode_type_impl<V, P0 P1::*>
 };
 
 template<class Iter>
-struct decode_type_impl<boost::mpl::size_t<PTR_DATA_MEM_ID>, Iter>
+struct decode_type_impl<boost::type_of::constant<std::size_t,PTR_DATA_MEM_ID>, Iter>
 {
     typedef Iter iter0;
     BOOST_TYPEOF_DECODE_PARAMS(2)
@@ -29,7 +29,7 @@ struct decode_type_impl<boost::mpl::size_t<PTR_DATA_MEM_ID>, Iter>
     template<class T> struct workaround{
         typedef p0 T::* type;
     };
-    typedef typename decode_type_impl<boost::mpl::size_t<PTR_DATA_MEM_ID>, Iter>::template workaround<p1>::type type;
+    typedef typename decode_type_impl<boost::type_of::constant<std::size_t,PTR_DATA_MEM_ID>, Iter>::template workaround<p1>::type type;
     typedef iter2 iter;
 };