passenger 5.3.3 → 5.3.4

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

@@ -450,7 +450,8 @@ namespace boost{
     char_separator()
       : m_use_ispunct(true),
         m_use_isspace(true),
-        m_empty_tokens(drop_empty_tokens) { }
+        m_empty_tokens(drop_empty_tokens),
+        m_output_done(false) { }
 
     void reset() { }
 

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

@@ -39,8 +39,11 @@ namespace boost
         >
   {
 
-      friend class iterator_core_access;
-
+#ifdef __DCC__ 
+      friend class boost::iterator_core_access; 
+#else 
+      friend class iterator_core_access; 
+#endif  
       TokenizerFunc f_;
       Iterator begin_;
       Iterator end_;

data/src/cxx_supportlib/vendor-modified/boost/tuple/detail/tuple_basic.hpp

@@ -35,13 +35,13 @@
 
 #include <utility> // needed for the assignment from pair to tuple
 
-#include "boost/type_traits/cv_traits.hpp"
-#include "boost/type_traits/function_traits.hpp"
-#include "boost/utility/swap.hpp"
+#include <boost/type_traits/cv_traits.hpp>
+#include <boost/type_traits/function_traits.hpp>
+#include <boost/utility/swap.hpp>
 
-#include "boost/detail/workaround.hpp" // needed for BOOST_WORKAROUND
+#include <boost/detail/workaround.hpp> // needed for BOOST_WORKAROUND
 
-#if BOOST_GCC >= 40700
+#if defined(BOOST_GCC) && (BOOST_GCC >= 40700)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wunused-local-typedefs"
 #endif
@@ -484,7 +484,7 @@ public:
 // access_traits<T>::parameter_type takes non-reference types as const T&
   tuple() {}
 
-  tuple(typename access_traits<T0>::parameter_type t0)
+  explicit tuple(typename access_traits<T0>::parameter_type t0)
     : inherited(t0, detail::cnull(), detail::cnull(), detail::cnull(),
                 detail::cnull(), detail::cnull(), detail::cnull(),
                 detail::cnull(), detail::cnull(), detail::cnull()) {}
@@ -979,11 +979,9 @@ inline void swap(tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>& lhs,
 } // end of namespace boost
 
 
-#if BOOST_GCC >= 40700
+#if defined(BOOST_GCC) && (BOOST_GCC >= 40700)
 #pragma GCC diagnostic pop
 #endif
 
 
 #endif // BOOST_TUPLE_BASIC_HPP
-
-

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

@@ -8,7 +8,7 @@
 
 // For more information, see http://www.boost.org
 
-// ----------------------------------------------------------------- 
+// -----------------------------------------------------------------
 
 #ifndef BOOST_TUPLE_HPP
 #define BOOST_TUPLE_HPP
@@ -20,15 +20,15 @@
 namespace boost { namespace python { class tuple; }}
 #endif
 
-#include "boost/config.hpp"
-#include "boost/static_assert.hpp"
+#include <boost/config.hpp>
+#include <boost/static_assert.hpp>
 
 // other compilers
-#include "boost/ref.hpp"
-#include "boost/tuple/detail/tuple_basic.hpp"
+#include <boost/ref.hpp>
+#include <boost/tuple/detail/tuple_basic.hpp>
 
 
-namespace boost {    
+namespace boost {
 
 using tuples::tuple;
 using tuples::make_tuple;
@@ -47,7 +47,7 @@ inline typename tuples::access_traits<
                 >::non_const_type
 get(tuples::cons<HT, TT>& c) {
   return tuples::get<N,HT,TT>(c);
-} 
+}
 // get function for const cons-lists, returns a const reference to
 // the element. If the element is a reference, returns the reference
 // as such (that is, can return a non-const reference)
@@ -60,7 +60,7 @@ get(const tuples::cons<HT, TT>& c) {
 }
 
 #endif // BOOST_NO_USING_TEMPLATE
-   
+
 } // end namespace boost
 
 

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

@@ -1,5 +1,5 @@
 //
-// Copyright (c) Antony Polukhin, 2012-2014.
+// Copyright (c) Antony Polukhin, 2012-2018.
 //
 // 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)

data/src/cxx_supportlib/vendor-modified/boost/type_index/stl_type_index.hpp

@@ -1,5 +1,5 @@
 //
-// Copyright (c) Antony Polukhin, 2013-2017.
+// Copyright (c) Antony Polukhin, 2013-2018.
 //
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -40,6 +40,8 @@
 #include <boost/mpl/if.hpp>
 #include <boost/mpl/or.hpp>
 
+#include <boost/container_hash/hash.hpp>
+
 #if (defined(__EDG_VERSION__) && __EDG_VERSION__ < 245) \
         || (defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 744)
 #   include <boost/type_traits/is_signed.hpp>
@@ -174,7 +176,9 @@ inline std::string stl_type_index::pretty_name() const {
 
 
 inline std::size_t stl_type_index::hash_code() const BOOST_NOEXCEPT {
-#if (defined(_MSC_VER) && _MSC_VER > 1600) || (__GNUC__ == 4 && __GNUC_MINOR__ > 5 && defined(__GXX_EXPERIMENTAL_CXX0X__))
+#if (defined(_MSC_VER) && _MSC_VER > 1600) \
+    || (defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ > 5 && defined(__GXX_EXPERIMENTAL_CXX0X__)) \
+    || (defined(__GNUC__) && __GNUC__ > 4 && __cplusplus >= 201103)
     return data_->hash_code();
 #else
     return boost::hash_range(raw_name(), raw_name() + std::strlen(raw_name()));

data/src/cxx_supportlib/vendor-modified/boost/type_index/type_index_facade.hpp

@@ -1,5 +1,5 @@
 //
-// Copyright (c) Antony Polukhin, 2013-2015.
+// Copyright (c) Antony Polukhin, 2013-2018.
 //
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -10,6 +10,7 @@
 #define BOOST_TYPE_INDEX_TYPE_INDEX_FACADE_HPP
 
 #include <boost/config.hpp>
+#include <boost/container_hash/hash_fwd.hpp>
 #include <string>
 #include <cstring>
 
@@ -25,11 +26,6 @@
 # pragma once
 #endif
 
-// Forward declaration from #include <boost/functional/hash_fwd.hpp>
-namespace boost {
-    template <class It> std::size_t hash_range(It, It);
-}
-
 namespace boost { namespace typeindex {
 
 /// \class type_index_facade
@@ -103,7 +99,8 @@ public:
 
     /// \b Override: This function \b may be redefined in Derived class. Overrides \b must not throw.
     /// \return Hash code of a type. By default hashes types by raw_name().
-    /// \note <boost/functional/hash.hpp> has to be included if this function is used.
+    /// \note Derived class header \b must include <boost/container_hash/hash.hpp>, \b unless this function is redefined in
+    /// Derived class to not use boost::hash_range().
     inline std::size_t hash_code() const BOOST_NOEXCEPT {
         const char* const name_raw = derived().raw_name();
         return boost::hash_range(name_raw, name_raw + std::strlen(name_raw));
@@ -288,7 +285,7 @@ inline std::basic_ostream<CharT, TriatT>& operator<<(
 #endif // BOOST_NO_IOSTREAM
 
 /// This free function is used by Boost's unordered containers.
-/// \note <boost/functional/hash.hpp> has to be included if this function is used.
+/// \note <boost/container_hash/hash.hpp> has to be included if this function is used.
 template <class Derived, class TypeInfo>
 inline std::size_t hash_value(const type_index_facade<Derived, TypeInfo>& lhs) BOOST_NOEXCEPT {
     return static_cast<Derived const&>(lhs).hash_code();

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

@@ -41,6 +41,12 @@ namespace boost {
       typedef T& type;
    };
 
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+   template <class T> using add_const_t = typename add_const<T>::type;
+
+#endif
+
 } // namespace boost
 
 #endif // BOOST_TT_ADD_CONST_HPP_INCLUDED

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

@@ -36,6 +36,12 @@ template <class T> struct add_cv{ typedef T const volatile type; };
 
 template <class T> struct add_cv<T&>{ typedef T& type; };
 
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+   template <class T> using add_cv_t = typename add_cv<T>::type;
+
+#endif
+
 } // namespace boost
 
 #endif // BOOST_TT_ADD_CV_HPP_INCLUDED

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

@@ -22,6 +22,12 @@ template <class T> struct add_lvalue_reference<T&&>
 };
 #endif
 
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+   template <class T> using add_lvalue_reference_t = typename add_lvalue_reference<T>::type;
+
+#endif
+
 }
 
 #endif  // BOOST_TYPE_TRAITS_EXT_ADD_LVALUE_REFERENCE__HPP

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

@@ -56,6 +56,12 @@ struct add_pointer
 
 #endif
 
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+   template <class T> using add_pointer_t = typename add_pointer<T>::type;
+
+#endif
+
 } // namespace boost
 
 #endif // BOOST_TT_ADD_POINTER_HPP_INCLUDED

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

@@ -54,6 +54,13 @@ template <> struct add_reference<const volatile void> { typedef const volatile v
 template <> struct add_reference<volatile void> { typedef volatile void type; };
 #endif
 
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+template <class T> using add_reference_t = typename add_reference<T>::type;
+
+#endif
+
+
 } // namespace boost
 
 #endif // BOOST_TT_ADD_REFERENCE_HPP_INCLUDED

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

@@ -58,6 +58,12 @@ template <class T> struct add_rvalue_reference
    typedef typename boost::type_traits_detail::add_rvalue_reference_imp<T>::type type;
 };
 
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+   template <class T> using add_rvalue_reference_t = typename add_rvalue_reference<T>::type;
+
+#endif
+
 }  // namespace boost
 
 #endif  // BOOST_TYPE_TRAITS_EXT_ADD_RVALUE_REFERENCE__HPP

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

@@ -35,6 +35,12 @@ template <class T> struct add_volatile{ typedef T volatile type; };
 
 template <class T> struct add_volatile<T&>{ typedef T& type; };
 
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+   template <class T> using add_volatile_t = typename add_volatile<T>::type;
+
+#endif
+
 } // namespace boost
 
 #endif // BOOST_TT_ADD_VOLATILE_HPP_INCLUDED

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

@@ -13,6 +13,10 @@
 #include <boost/type_traits/decay.hpp>
 #include <boost/type_traits/declval.hpp>
 #include <boost/detail/workaround.hpp>
+#include <boost/type_traits/is_complete.hpp>
+#include <boost/type_traits/is_void.hpp>
+#include <boost/type_traits/is_array.hpp>
+#include <boost/static_assert.hpp>
 
 #if defined(BOOST_NO_CXX11_DECLTYPE)
 #include <boost/type_traits/detail/common_type_impl.hpp>
@@ -75,6 +79,7 @@ struct common_type: common_type<typename common_type<T1, T2>::type, T3, T4, T5,
 
 template<class T> struct common_type<T>: boost::decay<T>
 {
+   BOOST_STATIC_ASSERT_MSG(::boost::is_complete<T>::value || ::boost::is_void<T>::value || ::boost::is_array<T>::value, "Arguments to common_type must both be complete types");
 };
 
 // two arguments
@@ -138,6 +143,8 @@ template<class T1, class T2> struct common_type_decay_helper<T1, T2, T1, T2>: co
 
 template<class T1, class T2> struct common_type<T1, T2>: type_traits_detail::common_type_decay_helper<T1, T2>
 {
+   BOOST_STATIC_ASSERT_MSG(::boost::is_complete<T1>::value || ::boost::is_void<T1>::value || ::boost::is_array<T1>::value, "Arguments to common_type must both be complete types");
+   BOOST_STATIC_ASSERT_MSG(::boost::is_complete<T2>::value || ::boost::is_void<T2>::value || ::boost::is_array<T2>::value, "Arguments to common_type must both be complete types");
 };
 
 } // namespace boost

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

@@ -9,11 +9,19 @@
 #ifndef BOOST_TT_CONDITIONAL_HPP_INCLUDED
 #define BOOST_TT_CONDITIONAL_HPP_INCLUDED
 
+#include <boost/config.hpp>
+
 namespace boost {
 
 template <bool b, class T, class U> struct conditional { typedef T type; };
 template <class T, class U> struct conditional<false, T, U> { typedef U type; };
 
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+   template <bool b, class T, class U> using conditional_t = typename conditional<b, T, U>::type;
+
+#endif
+
 } // namespace boost
 
 

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

@@ -29,6 +29,12 @@ public:
     typedef typename boost::conditional<boost::is_volatile<U>::value, typename boost::add_volatile<CT>::type, CT>::type type;
 };
 
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+   template <class T, class U> using copy_cv_t = typename copy_cv<T, U>::type;
+
+#endif
+
 } // namespace boost
 
 #endif // #ifndef BOOST_TYPE_TRAITS_COPY_CV_HPP_INCLUDED

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

@@ -37,6 +37,12 @@ namespace boost
        typedef typename boost::detail::decay_imp<Ty, boost::is_array<Ty>::value, boost::is_function<Ty>::value>::type type;
     };
     
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+   template <class T> using decay_t = typename decay<T>::type;
+
+#endif
+
 } // namespace boost
 
 

data/src/cxx_supportlib/vendor-modified/boost/type_traits/detail/config.hpp

@@ -13,7 +13,7 @@
 #include <boost/config.hpp>
 #endif
 #include <boost/version.hpp>
-#include <boost/detail/workaround.hpp>
+#include <boost/config/workaround.hpp>
 
 //
 // whenever we have a conversion function with ellipses
@@ -67,6 +67,17 @@
 #define BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(x)
 #define BOOST_TT_BROKEN_COMPILER_SPEC(x)
 
+//
+// Can we implement "accurate" binary operator detection:
+//
+#if !defined(BOOST_NO_SFINAE_EXPR) && !defined(BOOST_NO_CXX11_DECLTYPE) && !BOOST_WORKAROUND(BOOST_MSVC, < 1900) && !BOOST_WORKAROUND(BOOST_GCC, < 40900)
+#  define BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION
+#endif
+
+#if defined(__clang__) && (__clang_major__ == 3) && (__clang_minor__ < 2) && defined(BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION)
+#undef BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION
+#endif
+
 #endif // BOOST_TT_CONFIG_HPP_INCLUDED
 
 

data/src/cxx_supportlib/vendor-modified/boost/type_traits/detail/detector.hpp

@@ -0,0 +1,37 @@
+/*
+Copyright 2017-2018 Glen Joseph Fernandes
+<glenjofe -at- 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_DETAIL_DETECTOR_HPP_INCLUDED
+#define BOOST_TT_DETAIL_DETECTOR_HPP_INCLUDED
+
+#include <boost/type_traits/integral_constant.hpp>
+#include <boost/type_traits/make_void.hpp>
+
+namespace boost {
+namespace detail {
+
+template<class T>
+using detector_t = typename boost::make_void<T>::type;
+
+template<class Default, class, template<class...> class, class...>
+struct detector {
+    using value_t = boost::false_type;
+    using type = Default;
+};
+
+template<class Default, template<class...> class Op, class... Args>
+struct detector<Default, detector_t<Op<Args...> >, Op, Args...> {
+    using value_t = boost::true_type;
+    using type = Op<Args...>;
+};
+
+} /* detail */
+} /* boost */
+
+#endif

data/src/cxx_supportlib/vendor-modified/boost/type_traits/detail/has_binary_operator.hpp

@@ -7,19 +7,7 @@
 //  See http://www.boost.org/libs/type_traits for most recent version including documentation.
 
 #include <boost/config.hpp>
-#include <boost/type_traits/detail/yes_no_type.hpp>
-#include <boost/type_traits/integral_constant.hpp>
-#include <boost/type_traits/is_base_of.hpp>
-#include <boost/type_traits/is_const.hpp>
-#include <boost/type_traits/is_convertible.hpp>
-#include <boost/type_traits/is_fundamental.hpp>
-#include <boost/type_traits/is_integral.hpp>
-#include <boost/type_traits/is_pointer.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/type_traits/is_void.hpp>
-#include <boost/type_traits/remove_cv.hpp>
-#include <boost/type_traits/remove_pointer.hpp>
-#include <boost/type_traits/remove_reference.hpp>
+#include <boost/type_traits/detail/config.hpp>
 
 // cannot include this header without getting warnings of the kind:
 // gcc:
@@ -37,12 +25,78 @@
 #   pragma GCC system_header
 #elif defined(BOOST_MSVC)
 #   pragma warning ( push )
-#   pragma warning ( disable : 4018 4244 4547 4800 4804 4805 4913)
+#   pragma warning ( disable : 4018 4244 4547 4800 4804 4805 4913 4133)
 #   if BOOST_WORKAROUND(BOOST_MSVC_FULL_VER, >= 140050000)
 #       pragma warning ( disable : 6334)
 #   endif
 #endif
 
+#if defined(BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION)
+
+#include <boost/type_traits/integral_constant.hpp>
+#include <boost/type_traits/make_void.hpp>
+#include <boost/type_traits/is_convertible.hpp>
+#include <boost/type_traits/is_void.hpp>
+#include <boost/type_traits/add_reference.hpp>
+#include <utility>
+
+namespace boost
+{
+
+   namespace binary_op_detail {
+
+      struct dont_care;
+
+      template <class T, class U, class Ret, class = boost::void_t<>>
+      struct BOOST_JOIN(BOOST_TT_TRAIT_NAME, _ret_imp) : public boost::false_type {};
+
+      template <class T, class U, class Ret>
+      struct BOOST_JOIN(BOOST_TT_TRAIT_NAME, _ret_imp)<T, U, Ret, boost::void_t<decltype(std::declval<typename add_reference<T>::type>() BOOST_TT_TRAIT_OP std::declval<typename add_reference<U>::type>())> >
+         : public boost::integral_constant<bool, ::boost::is_convertible<decltype(std::declval<typename add_reference<T>::type>() BOOST_TT_TRAIT_OP std::declval<typename add_reference<U>::type>()), Ret>::value> {};
+
+      template <class T, class U, class = boost::void_t<> >
+      struct BOOST_JOIN(BOOST_TT_TRAIT_NAME, _void_imp) : public boost::false_type {};
+
+      template <class T, class U>
+      struct BOOST_JOIN(BOOST_TT_TRAIT_NAME, _void_imp)<T, U, boost::void_t<decltype(std::declval<typename add_reference<T>::type>() BOOST_TT_TRAIT_OP std::declval<typename add_reference<U>::type>())> >
+         : public boost::integral_constant<bool, ::boost::is_void<decltype(std::declval<typename add_reference<T>::type>() BOOST_TT_TRAIT_OP std::declval<typename add_reference<U>::type>())>::value> {};
+
+      template <class T, class U, class = boost::void_t<>>
+      struct BOOST_JOIN(BOOST_TT_TRAIT_NAME, _dc_imp) : public boost::false_type {};
+
+      template <class T, class U>
+      struct BOOST_JOIN(BOOST_TT_TRAIT_NAME, _dc_imp)<T, U, boost::void_t<decltype(std::declval<typename add_reference<T>::type>() BOOST_TT_TRAIT_OP std::declval<typename add_reference<U>::type>())> >
+         : public boost::true_type {};
+
+   }
+
+   template <class T, class U = T, class Ret = boost::binary_op_detail::dont_care>
+   struct BOOST_TT_TRAIT_NAME : public boost::binary_op_detail:: BOOST_JOIN(BOOST_TT_TRAIT_NAME, _ret_imp) <T, U, Ret> {};
+   template <class T, class U>
+   struct BOOST_TT_TRAIT_NAME<T, U, void> : public boost::binary_op_detail:: BOOST_JOIN(BOOST_TT_TRAIT_NAME, _void_imp) <T, U> {};
+   template <class T, class U>
+   struct BOOST_TT_TRAIT_NAME<T, U, boost::binary_op_detail::dont_care> : public boost::binary_op_detail:: BOOST_JOIN(BOOST_TT_TRAIT_NAME, _dc_imp) <T, U> {};
+
+
+}
+
+#else
+
+#include <boost/type_traits/detail/yes_no_type.hpp>
+#include <boost/type_traits/integral_constant.hpp>
+#include <boost/type_traits/is_base_of.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/is_convertible.hpp>
+#include <boost/type_traits/is_fundamental.hpp>
+#include <boost/type_traits/is_integral.hpp>
+#include <boost/type_traits/is_pointer.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/is_void.hpp>
+#include <boost/type_traits/remove_cv.hpp>
+#include <boost/type_traits/remove_pointer.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+#include <boost/type_traits/detail/is_likely_lambda.hpp>
+
 namespace boost {
 namespace detail {
 
@@ -217,6 +271,9 @@ struct BOOST_TT_TRAIT_NAME : public integral_constant<bool, (::boost::detail::BO
 
 } // namespace boost
 
+#endif
+
 #if defined(BOOST_MSVC)
 #   pragma warning ( pop )
 #endif
+