passenger 6.0.8 → 6.0.9

data/src/cxx_supportlib/vendor-modified/boost/move/detail/unique_ptr_meta_utils.hpp

@@ -559,32 +559,6 @@ struct is_unary_function
    struct has_virtual_destructor{   static const bool value = true;  };
 #endif
 
-//////////////////////////////////////
-//       missing_virtual_destructor
-//////////////////////////////////////
-
-template< class T, class U
-        , bool enable =  is_convertible< U*, T*>::value &&
-                        !is_array<T>::value &&
-                        !is_same<typename remove_cv<T>::type, void>::value &&
-                        !is_same<typename remove_cv<U>::type, typename remove_cv<T>::type>::value
-        >
-struct missing_virtual_destructor_default_delete
-{  static const bool value = !has_virtual_destructor<T>::value;  };
-
-template<class T, class U>
-struct missing_virtual_destructor_default_delete<T, U, false>
-{  static const bool value = false;  };
-
-template<class Deleter, class U>
-struct missing_virtual_destructor
-{  static const bool value = false;  };
-
-template<class T, class U>
-struct missing_virtual_destructor< ::boost::movelib::default_delete<T>, U >
-   : missing_virtual_destructor_default_delete<T, U>
-{};
-
 }  //namespace move_upmu {
 }  //namespace boost {
 

data/src/cxx_supportlib/vendor-modified/boost/move/unique_ptr.hpp

@@ -430,7 +430,7 @@ class unique_ptr
    {
       //If T is not an array type, element_type_t<Pointer> derives from T
       //it uses the default deleter and T has no virtual destructor, then you have a problem
-      BOOST_STATIC_ASSERT(( !::boost::move_upmu::missing_virtual_destructor
+      BOOST_STATIC_ASSERT(( !bmupd::missing_virtual_destructor
                             <D, typename bmupd::get_element_type<Pointer>::type>::value ));
       //If this constructor is instantiated with a pointer type or reference type
       //for the template argument D, the program is ill-formed.
@@ -468,7 +468,7 @@ class unique_ptr
    {
       //If T is not an array type, element_type_t<Pointer> derives from T
       //it uses the default deleter and T has no virtual destructor, then you have a problem
-      BOOST_STATIC_ASSERT(( !::boost::move_upmu::missing_virtual_destructor
+      BOOST_STATIC_ASSERT(( !bmupd::missing_virtual_destructor
                             <D, typename bmupd::get_element_type<Pointer>::type>::value ));
    }
 
@@ -506,7 +506,7 @@ class unique_ptr
    {
       //If T is not an array type, element_type_t<Pointer> derives from T
       //it uses the default deleter and T has no virtual destructor, then you have a problem
-      BOOST_STATIC_ASSERT(( !::boost::move_upmu::missing_virtual_destructor
+      BOOST_STATIC_ASSERT(( !bmupd::missing_virtual_destructor
                             <D, typename bmupd::get_element_type<Pointer>::type>::value ));
    }
 
@@ -553,7 +553,7 @@ class unique_ptr
    {
       //If T is not an array type, U derives from T
       //it uses the default deleter and T has no virtual destructor, then you have a problem
-      BOOST_STATIC_ASSERT(( !::boost::move_upmu::missing_virtual_destructor
+      BOOST_STATIC_ASSERT(( !bmupd::missing_virtual_destructor
                             <D, typename unique_ptr<U, E>::pointer>::value ));
    }
 
@@ -711,7 +711,7 @@ class unique_ptr
    {
       //If T is not an array type, element_type_t<Pointer> derives from T
       //it uses the default deleter and T has no virtual destructor, then you have a problem
-      BOOST_STATIC_ASSERT(( !::boost::move_upmu::missing_virtual_destructor
+      BOOST_STATIC_ASSERT(( !bmupd::missing_virtual_destructor
                             <D, typename bmupd::get_element_type<Pointer>::type>::value ));
       pointer tmp = m_data.m_p;
       m_data.m_p = p;

data/src/cxx_supportlib/vendor-modified/boost/mpl/aux_/preprocessor/enum.hpp

@@ -29,6 +29,10 @@
     BOOST_PP_CAT(BOOST_MPL_PP_ENUM_,n)(param) \
     /**/
     
+#   define BOOST_MPL_PP_ENUM_Z(z_ignored, n, param) \
+    BOOST_PP_CAT(BOOST_MPL_PP_ENUM_,n)(param) \
+    /**/
+    
 #   define BOOST_MPL_PP_ENUM_0(p)
 #   define BOOST_MPL_PP_ENUM_1(p) p
 #   define BOOST_MPL_PP_ENUM_2(p) p,p
@@ -57,6 +61,14 @@
         ) \
     /**/
 
+#   define BOOST_MPL_PP_ENUM_Z(z, n, param) \
+    BOOST_PP_REPEAT_ ## z( \
+          n \
+        , BOOST_MPL_PP_AUX_ENUM_FUNC \
+        , param \
+        ) \
+    /**/
+
 #endif
 
 #endif // BOOST_MPL_AUX_PREPROCESSOR_ENUM_HPP_INCLUDED

data/src/cxx_supportlib/vendor-modified/boost/mpl/aux_/preprocessor/params.hpp

@@ -29,6 +29,10 @@
     BOOST_PP_CAT(BOOST_MPL_PP_PARAMS_,n)(p) \
     /**/
 
+#   define BOOST_MPL_PP_PARAMS_Z(z_ignored,n,p) \
+    BOOST_PP_CAT(BOOST_MPL_PP_PARAMS_,n)(p) \
+    /**/
+
 #   define BOOST_MPL_PP_PARAMS_0(p)
 #   define BOOST_MPL_PP_PARAMS_1(p) p##1
 #   define BOOST_MPL_PP_PARAMS_2(p) p##1,p##2
@@ -60,6 +64,14 @@
         ) \
     /**/
 
+#   define BOOST_MPL_PP_PARAMS_Z(z, n, param) \
+    BOOST_PP_REPEAT_ ## z( \
+          n \
+        , BOOST_MPL_PP_AUX_PARAM_FUNC \
+        , param \
+        ) \
+    /**/
+
 #endif 
 
 #endif // BOOST_MPL_AUX_PREPROCESSOR_PARAMS_HPP_INCLUDED

data/src/cxx_supportlib/vendor-modified/boost/mpl/has_xxx.hpp

@@ -334,7 +334,7 @@ struct trait \
 // correct name but different number of arguments.
 #   define BOOST_MPL_HAS_MEMBER_MULTI_SUBSTITUTE(z, n, args) \
       template< \
-          template< BOOST_PP_ENUM_PARAMS(BOOST_PP_INC(n), typename V) > class V \
+          template< BOOST_PP_ENUM_PARAMS_Z(z, BOOST_PP_INC(n), typename V) > class V \
        > \
       struct BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_NAME(args, n) { \
       }; \
@@ -503,7 +503,7 @@ struct trait \
                  z, n, args \
              ) \
         template< \
-             template< BOOST_PP_ENUM_PARAMS(BOOST_PP_INC(n), typename U) > class U \
+             template< BOOST_PP_ENUM_PARAMS_Z(z, BOOST_PP_INC(n), typename U) > class U \
         > \
         struct BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_NAME_WITH_TEMPLATE_SFINAE( \
                 args, n \

data/src/cxx_supportlib/vendor-modified/boost/mpl/string.hpp

@@ -500,11 +500,11 @@ namespace boost { namespace mpl
     };
 
     #define M0(z, n, data)                                                                            \
-    template<BOOST_PP_ENUM_PARAMS(BOOST_MPL_STRING_MAX_PARAMS, int C), int J>                         \
-    struct string_iterator<mpl::string<BOOST_PP_ENUM_PARAMS(BOOST_MPL_STRING_MAX_PARAMS, C)>, n, J>   \
+    template<BOOST_PP_ENUM_PARAMS_Z(z, BOOST_MPL_STRING_MAX_PARAMS, int C), int J>                    \
+    struct string_iterator<mpl::string<BOOST_PP_ENUM_PARAMS_Z(z, BOOST_MPL_STRING_MAX_PARAMS, C)>, n, J> \
     {                                                                                                 \
         enum { eomc_ = (BOOST_MPL_MULTICHAR_LENGTH(BOOST_PP_CAT(C, n)) == J + 1) };                   \
-        typedef mpl::string<BOOST_PP_ENUM_PARAMS(BOOST_MPL_STRING_MAX_PARAMS, C)> string;             \
+        typedef mpl::string<BOOST_PP_ENUM_PARAMS_Z(z, BOOST_MPL_STRING_MAX_PARAMS, C)> string;        \
         typedef std::bidirectional_iterator_tag category;                                             \
         typedef                                                                                       \
             mpl::string_iterator<string, n + eomc_, eomc_ ? 0 : J + 1>                                \
@@ -514,11 +514,11 @@ namespace boost { namespace mpl
         prior;                                                                                        \
         typedef mpl::char_<BOOST_MPL_MULTICHAR_AT(BOOST_PP_CAT(C, n), J)> type;                       \
     };                                                                                                \
-    template<BOOST_PP_ENUM_PARAMS(BOOST_MPL_STRING_MAX_PARAMS, int C)>                                \
-    struct string_iterator<mpl::string<BOOST_PP_ENUM_PARAMS(BOOST_MPL_STRING_MAX_PARAMS, C)>, n, 0>   \
+    template<BOOST_PP_ENUM_PARAMS_Z(z, BOOST_MPL_STRING_MAX_PARAMS, int C)>                           \
+    struct string_iterator<mpl::string<BOOST_PP_ENUM_PARAMS_Z(z, BOOST_MPL_STRING_MAX_PARAMS, C)>, n, 0> \
     {                                                                                                 \
         enum { eomc_ = (BOOST_MPL_MULTICHAR_LENGTH(BOOST_PP_CAT(C, n)) == 1) };                       \
-        typedef mpl::string<BOOST_PP_ENUM_PARAMS(BOOST_MPL_STRING_MAX_PARAMS, C)> string;             \
+        typedef mpl::string<BOOST_PP_ENUM_PARAMS_Z(z, BOOST_MPL_STRING_MAX_PARAMS, C)> string;        \
         typedef std::bidirectional_iterator_tag category;                                             \
         typedef                                                                                       \
             mpl::string_iterator<string, n + eomc_, !eomc_>                                           \

data/src/cxx_supportlib/vendor-modified/boost/none.hpp

@@ -24,7 +24,7 @@ namespace boost {
 
 #ifdef BOOST_OPTIONAL_USE_OLD_DEFINITION_OF_NONE
 
-BOOST_INLINE_VARIABLE none_t const none = (static_cast<none_t>(0)) ;
+BOOST_INLINE_VARIABLE none_t BOOST_CONSTEXPR_OR_CONST none = (static_cast<none_t>(0)) ;
 
 #elif defined BOOST_OPTIONAL_USE_SINGLETON_DEFINITION_OF_NONE
 
@@ -45,16 +45,15 @@ namespace detail { namespace optional_detail {
 
 namespace {
   // TU-local
-  const none_t& none = detail::optional_detail::none_instance<none_t>::instance; 
+  const none_t& none = detail::optional_detail::none_instance<none_t>::instance;
 }
 
 #else
 
-BOOST_INLINE_VARIABLE const none_t none ((none_t::init_tag()));
+BOOST_INLINE_VARIABLE BOOST_CONSTEXPR_OR_CONST none_t none ((none_t::init_tag()));
 
 #endif // older definitions
 
 } // namespace boost
 
 #endif // header guard
-

data/src/cxx_supportlib/vendor-modified/boost/none_t.hpp

@@ -13,6 +13,8 @@
 #ifndef BOOST_NONE_T_17SEP2003_HPP
 #define BOOST_NONE_T_17SEP2003_HPP
 
+#include <boost/config.hpp>
+
 namespace boost {
 
 #ifdef BOOST_OPTIONAL_USE_OLD_DEFINITION_OF_NONE
@@ -29,7 +31,7 @@ class none_t {};
 struct none_t
 {
   struct init_tag{};
-  explicit none_t(init_tag){} // to disable default constructor
+  explicit BOOST_CONSTEXPR none_t(init_tag){} // to disable default constructor
 };
 
 #endif // old implementation workarounds

data/src/cxx_supportlib/vendor-modified/boost/numeric/conversion/cast.hpp

@@ -23,7 +23,7 @@
 
 #include <boost/detail/workaround.hpp>
 
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x582))
+#if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x582))
 
 #  include<boost/numeric/conversion/detail/old_numeric_cast.hpp>
 

data/src/cxx_supportlib/vendor-modified/boost/numeric/conversion/converter_policies.hpp

@@ -10,14 +10,13 @@
 #ifndef BOOST_NUMERIC_CONVERSION_CONVERTER_POLICIES_FLC_12NOV2002_HPP
 #define BOOST_NUMERIC_CONVERSION_CONVERTER_POLICIES_FLC_12NOV2002_HPP
 
+#include <functional>
 #include <typeinfo> // for std::bad_cast
 
 #include <boost/config.hpp>
 #include <boost/config/no_tr1/cmath.hpp> // for std::floor and std::ceil
 #include <boost/throw_exception.hpp>
 
-#include <functional>
-
 #include "boost/type_traits/is_arithmetic.hpp"
 
 #include "boost/mpl/if.hpp"
@@ -137,7 +136,7 @@ class bad_numeric_cast : public std::bad_cast
 {
   public:
 
-    virtual const char * what() const BOOST_NOEXCEPT_OR_NOTHROW
+    const char * what() const BOOST_NOEXCEPT_OR_NOTHROW BOOST_OVERRIDE
       {  return "bad numeric conversion: overflow"; }
 };
 
@@ -145,14 +144,14 @@ class negative_overflow : public bad_numeric_cast
 {
   public:
 
-    virtual const char * what() const BOOST_NOEXCEPT_OR_NOTHROW
+    const char * what() const BOOST_NOEXCEPT_OR_NOTHROW BOOST_OVERRIDE
       {  return "bad numeric conversion: negative overflow"; }
 };
 class positive_overflow : public bad_numeric_cast
 {
   public:
 
-    virtual const char * what() const BOOST_NOEXCEPT_OR_NOTHROW
+    const char * what() const BOOST_NOEXCEPT_OR_NOTHROW BOOST_OVERRIDE
       { return "bad numeric conversion: positive overflow"; }
 };
 

data/src/cxx_supportlib/vendor-modified/boost/numeric/conversion/detail/converter.hpp

@@ -561,7 +561,7 @@ namespace boost { namespace numeric { namespace convdetail
           >
   struct get_converter_impl
   {
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT( 0x0561 ) )
+#if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT( 0x0561 ) )
     // bcc55 prefers sometimes template parameters to be explicit local types.
     // (notice that is is illegal to reuse the names like this)
     typedef Traits           Traits ;

data/src/cxx_supportlib/vendor-modified/boost/numeric/conversion/detail/meta.hpp

@@ -25,7 +25,7 @@ namespace boost { namespace numeric { namespace convdetail
    template< class T1, class T2>
    struct equal_to
    {
-   #if !defined(__BORLANDC__)
+   #if !defined(BOOST_BORLANDC)
    
        enum { x = ( BOOST_MPL_AUX_VALUE_WKND(T1)::value == BOOST_MPL_AUX_VALUE_WKND(T2)::value ) };
            

data/src/cxx_supportlib/vendor-modified/boost/optional/detail/old_optional_implementation.hpp

@@ -79,7 +79,7 @@ class optional_base : public optional_tag
   private :
 
     typedef
-#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+#if !BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x564))
     BOOST_DEDUCED_TYPENAME
 #endif
     ::boost::detail::make_reference_content<T>::type internal_type ;
@@ -619,7 +619,7 @@ class optional_base : public optional_tag
     reference_const_type dereference( internal_type const* p, is_reference_tag     ) const { return p->get() ; }
     reference_type       dereference( internal_type*       p, is_reference_tag     )       { return p->get() ; }
 
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x581))
+#if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x581))
     void destroy_impl ( is_not_reference_tag ) { get_ptr_impl()->internal_type::~internal_type() ; m_initialized = false ; }
 #else
     void destroy_impl ( is_not_reference_tag ) { get_ptr_impl()->~T() ; m_initialized = false ; }

data/src/cxx_supportlib/vendor-modified/boost/optional/detail/optional_config.hpp

@@ -28,7 +28,7 @@
 # define BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT
 #endif
 
-#if BOOST_WORKAROUND(__BORLANDC__, <= 0x551)
+#if BOOST_WORKAROUND(BOOST_BORLANDC, <= 0x551)
 // BCB (5.5.1) cannot parse the nested template struct in an inplace factory.
 # define BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT
 #endif

data/src/cxx_supportlib/vendor-modified/boost/optional/detail/optional_reference_spec.hpp

@@ -151,7 +151,14 @@ public:
     T* get_ptr() const BOOST_NOEXCEPT { return ptr_; }
     T* operator->() const { BOOST_ASSERT(ptr_); return ptr_; }
     T& operator*() const { BOOST_ASSERT(ptr_); return *ptr_; }
-    T& value() const { return ptr_ ? *ptr_ : (throw_exception(bad_optional_access()), *ptr_); }
+    
+    T& value() const
+    {
+      if (this->is_initialized())
+        return this->get();
+      else
+        throw_exception(bad_optional_access());
+    }
     
     bool operator!() const BOOST_NOEXCEPT { return ptr_ == 0; }  
     BOOST_EXPLICIT_OPERATOR_BOOL_NOEXCEPT()

data/src/cxx_supportlib/vendor-modified/boost/parameter/aux_/arg_list.hpp

@@ -599,7 +599,7 @@ namespace boost { namespace parameter { namespace aux {
         template <typename KW>
         static ::boost::parameter::aux::no_tag has_key(KW*);
 
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+#if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x564))
         // The overload set technique doesn't work with these older compilers,
         // so they need some explicit handholding.
 
@@ -670,7 +670,7 @@ namespace boost { namespace parameter { namespace aux {
 #include <boost/core/enable_if.hpp>
 #endif
 
-#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+#if !BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x564))
 #include <boost/parameter/aux_/preprocessor/nullptr.hpp>
 #endif
 
@@ -767,7 +767,7 @@ namespace boost { namespace parameter { namespace aux {
             };
         };
 
-#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+#if !BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x564))
         // Overload for key_type, so the assert below will fire
         // if the same keyword is used again.
         static ::boost::parameter::aux::yes_tag has_key(key_type*);
@@ -827,7 +827,7 @@ namespace boost { namespace parameter { namespace aux {
         }
 
      public:
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+#if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x564))
         // These older compilers don't support the overload set creation
         // idiom well, so we need to do all the return type calculation
         // for the compiler and dispatch through an outer function template.
@@ -927,7 +927,7 @@ namespace boost { namespace parameter { namespace aux {
         {
             return this->arg.get_value();
         }
-#else   // !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+#else   // !BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x564))
         inline BOOST_CONSTEXPR reference
             operator[](::boost::parameter::keyword<key_type> const&) const
         {

data/src/cxx_supportlib/vendor-modified/boost/parameter/aux_/default.hpp

@@ -91,6 +91,17 @@ namespace boost { namespace parameter { namespace aux {
         {
         }
 
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1910)
+        // MSVC 2015 miscompiles moves for classes containing rvalue ref members
+        // using the default generated move constructor
+        // when moving into a function
+        // https://github.com/boostorg/parameter/pull/109
+        inline BOOST_CONSTEXPR default_r_(default_r_&& x)
+          : value(::std::forward<Value>(x.value))
+        {
+        }
+#endif
+
         Value&& value;
     };
 }}} // namespace boost::parameter::aux

data/src/cxx_supportlib/vendor-modified/boost/parameter/aux_/maybe.hpp

@@ -49,7 +49,7 @@ namespace boost { namespace parameter { namespace aux {
 #else   // !defined(BOOST_PARAMETER_CAN_USE_MP11)
 #include <boost/type_traits/add_lvalue_reference.hpp>
 #include <boost/type_traits/remove_cv.hpp>
-#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+#if !BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x564))
 #include <boost/type_traits/add_const.hpp>
 #endif
 #endif  // BOOST_PARAMETER_CAN_USE_MP11
@@ -64,7 +64,7 @@ namespace boost { namespace parameter { namespace aux {
             typename ::std::add_const<T>::type
 #else   // !defined(BOOST_PARAMETER_CAN_USE_MP11)
         typedef typename ::boost::add_lvalue_reference<
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+#if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x564))
             T const
 #else
             typename ::boost::add_const<T>::type

data/src/cxx_supportlib/vendor-modified/boost/parameter/aux_/name.hpp

@@ -34,7 +34,7 @@ namespace boost { namespace parameter { namespace aux {
 #include <boost/config/workaround.hpp>
 
 #if !defined(BOOST_NO_SFINAE) && \
-    !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592))
+    !BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x592))
 #include <boost/parameter/aux_/lambda_tag.hpp>
 #include <boost/mpl/lambda.hpp>
 #include <boost/mpl/bind.hpp>

data/src/cxx_supportlib/vendor-modified/boost/parameter/aux_/pack/item.hpp

@@ -10,7 +10,7 @@
 #include <boost/config.hpp>
 #include <boost/config/workaround.hpp>
 
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+#if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x564))
 #include <boost/type_traits/is_const.hpp>
 #include <boost/type_traits/remove_reference.hpp>
 #endif
@@ -26,7 +26,7 @@ namespace boost { namespace parameter { namespace aux {
     struct item
     {
         typedef Spec spec;
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+#if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x564))
         typedef ::boost::is_const<
             typename ::boost::remove_reference<Arg>::type
         > is_arg_const;