passenger 5.3.3 → 5.3.4

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

@@ -446,7 +446,7 @@ class is_convertible
 #define BOOST_MOVE_TT_DECL
 #endif
 
-#if defined(_MSC_EXTENSIONS) && !defined(__BORLAND__) && !defined(_WIN64) && !defined(_M_ARM) && !defined(UNDER_CE)
+#if defined(_MSC_EXTENSIONS) && !defined(__BORLAND__) && !defined(_WIN64) && !defined(_M_ARM) && !defined(_M_ARM64) && !defined(UNDER_CE)
 #define BOOST_MOVE_TT_TEST_MSC_FUNC_SIGS
 #endif
 

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

@@ -56,7 +56,7 @@
 // and GCC (which issues "unused variable" warnings when static constants are used 
 // at a function scope)
 #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610)) \
-    || (BOOST_MPL_CFG_GCC != 0) || (BOOST_MPL_CFG_GPU != 0)
+    || (BOOST_MPL_CFG_GCC != 0) || (BOOST_MPL_CFG_GPU != 0) || defined(__PGI)
 #   define BOOST_MPL_AUX_ASSERT_CONSTANT(T, expr) enum { expr }
 #else
 #   define BOOST_MPL_AUX_ASSERT_CONSTANT(T, expr) BOOST_STATIC_CONSTANT(T, expr)

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

@@ -0,0 +1,26 @@
+
+#ifndef BOOST_MPL_GET_TAG_HPP_INCLUDED
+#define BOOST_MPL_GET_TAG_HPP_INCLUDED
+
+// Copyright Sergey Krivonos 2017
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id$
+// $Date$
+// $Revision$
+
+
+#define BOOST_MPL_GET_TAG_DEF(TAG) \
+    namespace boost { namespace mpl { \
+        template<typename T> \
+        struct get_##TAG { \
+            typedef typename T::TAG type; \
+        }; \
+    }}
+
+#endif

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

@@ -1,8 +1,11 @@
 //  Boost next_prior.hpp header file  ---------------------------------------//
 
-//  (C) Copyright Dave Abrahams and Daniel Walker 1999-2003. 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)
+//  (C) Copyright Dave Abrahams and Daniel Walker 1999-2003.
+//  Copyright (c) Andrey Semashev 2017
+//
+//  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)
 
 //  See http://www.boost.org/libs/utility for documentation.
 
@@ -13,17 +16,14 @@
 #define BOOST_NEXT_PRIOR_HPP_INCLUDED
 
 #include <iterator>
-#if defined(_MSC_VER) && _MSC_VER <= 1310
-#include <boost/mpl/and.hpp>
-#include <boost/type_traits/is_integral.hpp>
-#endif
-#include <boost/type_traits/is_unsigned.hpp>
-#include <boost/type_traits/integral_promotion.hpp>
-#include <boost/type_traits/make_signed.hpp>
+#include <boost/config.hpp>
+#include <boost/core/enable_if.hpp>
 #include <boost/type_traits/has_plus.hpp>
 #include <boost/type_traits/has_plus_assign.hpp>
 #include <boost/type_traits/has_minus.hpp>
 #include <boost/type_traits/has_minus_assign.hpp>
+#include <boost/iterator/advance.hpp>
+#include <boost/iterator/reverse_iterator.hpp>
 
 namespace boost {
 
@@ -39,18 +39,51 @@ namespace boost {
 
 namespace next_prior_detail {
 
-template< typename T, typename Distance, bool HasPlus = has_plus< T, Distance >::value >
-struct next_impl2
+// The trait attempts to detect if the T type is an iterator. Class-type iterators are assumed
+// to have the nested type iterator_category. Strictly speaking, this is not required to be the
+// case (e.g. a user can specialize iterator_traits for T without defining T::iterator_category).
+// Still, this is a good heuristic in practice, and we can't do anything better anyway.
+// Since C++17 we can test for iterator_traits<T>::iterator_category presence instead as it is
+// required to be only present for iterators.
+template< typename T, typename Void = void >
+struct is_iterator_class
 {
-    static T call(T x, Distance n)
-    {
-        std::advance(x, n);
-        return x;
-    }
+    static BOOST_CONSTEXPR_OR_CONST bool value = false;
 };
 
+template< typename T >
+struct is_iterator_class<
+    T,
+    typename enable_if_has_type<
+#if !defined(BOOST_NO_CXX17_ITERATOR_TRAITS)
+        typename std::iterator_traits< T >::iterator_category
+#else
+        typename T::iterator_category
+#endif
+    >::type
+>
+{
+    static BOOST_CONSTEXPR_OR_CONST bool value = true;
+};
+
+template< typename T >
+struct is_iterator :
+    public is_iterator_class< T >
+{
+};
+
+template< typename T >
+struct is_iterator< T* >
+{
+    static BOOST_CONSTEXPR_OR_CONST bool value = true;
+};
+
+
+template< typename T, typename Distance, bool HasPlus = has_plus< T, Distance >::value >
+struct next_plus_impl;
+
 template< typename T, typename Distance >
-struct next_impl2< T, Distance, true >
+struct next_plus_impl< T, Distance, true >
 {
     static T call(T x, Distance n)
     {
@@ -58,15 +91,14 @@ struct next_impl2< T, Distance, true >
     }
 };
 
-
 template< typename T, typename Distance, bool HasPlusAssign = has_plus_assign< T, Distance >::value >
-struct next_impl1 :
-    public next_impl2< T, Distance >
+struct next_plus_assign_impl :
+    public next_plus_impl< T, Distance >
 {
 };
 
 template< typename T, typename Distance >
-struct next_impl1< T, Distance, true >
+struct next_plus_assign_impl< T, Distance, true >
 {
     static T call(T x, Distance n)
     {
@@ -75,47 +107,28 @@ struct next_impl1< T, Distance, true >
     }
 };
 
-
-template<
-    typename T,
-    typename Distance,
-    typename PromotedDistance = typename integral_promotion< Distance >::type,
-#if !defined(_MSC_VER) || _MSC_VER > 1310
-    bool IsUInt = is_unsigned< PromotedDistance >::value
-#else
-    // MSVC 7.1 has problems with applying is_unsigned to non-integral types
-    bool IsUInt = mpl::and_< is_integral< PromotedDistance >, is_unsigned< PromotedDistance > >::value
-#endif
->
-struct prior_impl3
+template< typename T, typename Distance, bool IsIterator = is_iterator< T >::value >
+struct next_advance_impl :
+    public next_plus_assign_impl< T, Distance >
 {
-    static T call(T x, Distance n)
-    {
-        std::advance(x, -n);
-        return x;
-    }
 };
 
-template< typename T, typename Distance, typename PromotedDistance >
-struct prior_impl3< T, Distance, PromotedDistance, true >
+template< typename T, typename Distance >
+struct next_advance_impl< T, Distance, true >
 {
     static T call(T x, Distance n)
     {
-        typedef typename make_signed< PromotedDistance >::type signed_distance;
-        std::advance(x, -static_cast< signed_distance >(static_cast< PromotedDistance >(n)));
+        boost::iterators::advance(x, n);
         return x;
     }
 };
 
 
 template< typename T, typename Distance, bool HasMinus = has_minus< T, Distance >::value >
-struct prior_impl2 :
-    public prior_impl3< T, Distance >
-{
-};
+struct prior_minus_impl;
 
 template< typename T, typename Distance >
-struct prior_impl2< T, Distance, true >
+struct prior_minus_impl< T, Distance, true >
 {
     static T call(T x, Distance n)
     {
@@ -123,15 +136,14 @@ struct prior_impl2< T, Distance, true >
     }
 };
 
-
 template< typename T, typename Distance, bool HasMinusAssign = has_minus_assign< T, Distance >::value >
-struct prior_impl1 :
-    public prior_impl2< T, Distance >
+struct prior_minus_assign_impl :
+    public prior_minus_impl< T, Distance >
 {
 };
 
 template< typename T, typename Distance >
-struct prior_impl1< T, Distance, true >
+struct prior_minus_assign_impl< T, Distance, true >
 {
     static T call(T x, Distance n)
     {
@@ -140,6 +152,24 @@ struct prior_impl1< T, Distance, true >
     }
 };
 
+template< typename T, typename Distance, bool IsIterator = is_iterator< T >::value >
+struct prior_advance_impl :
+    public prior_minus_assign_impl< T, Distance >
+{
+};
+
+template< typename T, typename Distance >
+struct prior_advance_impl< T, Distance, true >
+{
+    static T call(T x, Distance n)
+    {
+        // Avoid negating n to sidestep possible integer overflow
+        boost::iterators::reverse_iterator< T > rx(x);
+        boost::iterators::advance(rx, n);
+        return rx.base();
+    }
+};
+
 } // namespace next_prior_detail
 
 template <class T>
@@ -148,7 +178,7 @@ inline T next(T x) { return ++x; }
 template <class T, class Distance>
 inline T next(T x, Distance n)
 {
-    return next_prior_detail::next_impl1< T, Distance >::call(x, n);
+    return next_prior_detail::next_advance_impl< T, Distance >::call(x, n);
 }
 
 template <class T>
@@ -157,7 +187,7 @@ inline T prior(T x) { return --x; }
 template <class T, class Distance>
 inline T prior(T x, Distance n)
 {
-    return next_prior_detail::prior_impl1< T, Distance >::call(x, n);
+    return next_prior_detail::prior_advance_impl< T, Distance >::call(x, n);
 }
 
 } // namespace boost

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

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

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

@@ -21,13 +21,6 @@ template<class T, class S>
 struct conversion_traits 
     : convdetail::get_conversion_traits<T,S>::type 
 {
-#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
-    typedef typename convdetail::get_conversion_traits<T,S>::type base_;
-    typedef typename base_::target_type     target_type;
-    typedef typename base_::source_type     source_type;
-    typedef typename base_::result_type     result_type;
-    typedef typename base_::argument_type   argument_type;
-#endif
 } ;
 
 } } // namespace boost::numeric

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

@@ -450,13 +450,10 @@ namespace boost { namespace numeric { namespace convdetail
   // Trivial Converter : used when (cv-unqualified) T == (cv-unqualified)  S
   //
   template<class Traits>
-  struct trivial_converter_impl : public std::unary_function<  BOOST_DEDUCED_TYPENAME Traits::argument_type
-                                                              ,BOOST_DEDUCED_TYPENAME Traits::result_type
-                                                            >
-                                 ,public dummy_range_checker<Traits>
+  struct trivial_converter_impl : public dummy_range_checker<Traits>
   {
     typedef Traits traits ;
-
+    
     typedef typename Traits::source_type   source_type   ;
     typedef typename Traits::argument_type argument_type ;
     typedef typename Traits::result_type   result_type   ;
@@ -471,10 +468,7 @@ namespace boost { namespace numeric { namespace convdetail
   // Rounding Converter : used for float to integral conversions.
   //
   template<class Traits,class RangeChecker,class RawConverter,class Float2IntRounder>
-  struct rounding_converter : public std::unary_function<  BOOST_DEDUCED_TYPENAME Traits::argument_type
-                                                          ,BOOST_DEDUCED_TYPENAME Traits::result_type
-                                                        >
-                             ,public RangeChecker
+  struct rounding_converter : public RangeChecker
                              ,public Float2IntRounder
                              ,public RawConverter
   {
@@ -501,10 +495,7 @@ namespace boost { namespace numeric { namespace convdetail
   // Non-Rounding Converter : used for all other conversions.
   //
   template<class Traits,class RangeChecker,class RawConverter>
-  struct non_rounding_converter : public std::unary_function< BOOST_DEDUCED_TYPENAME Traits::argument_type
-                                                             ,BOOST_DEDUCED_TYPENAME Traits::result_type
-                                                           >
-                                 ,public RangeChecker
+  struct non_rounding_converter : public RangeChecker
                                  ,public RawConverter
   {
     typedef RangeChecker RangeCheckerBase ;

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

@@ -1,7 +1,7 @@
 //  Boost operators.hpp header file  ----------------------------------------//
 
 //  (C) Copyright David Abrahams, Jeremy Siek, Daryle Walker 1999-2001.
-//  (C) Copyright Daniel Frey 2002-2016.
+//  (C) Copyright Daniel Frey 2002-2017.
 //  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)
@@ -9,6 +9,9 @@
 //  See http://www.boost.org/libs/utility/operators.htm for documentation.
 
 //  Revision History
+//  23 Nov 17 Protect dereferenceable<> from overloaded operator&.
+//  15 Oct 17 Adapted to C++17, replace std::iterator<> with manual
+//            implementation.
 //  22 Feb 16 Added ADL protection, preserve old work-arounds in
 //            operators_v1.hpp and clean up this file. (Daniel Frey)
 //  16 Dec 10 Limit warning suppression for 4284 to older versions of VC++
@@ -96,6 +99,7 @@
 
 #include <boost/config.hpp>
 #include <boost/detail/workaround.hpp>
+#include <boost/core/addressof.hpp>
 
 #if defined(__sgi) && !defined(__GNUC__)
 #   pragma set woff 1234
@@ -300,7 +304,7 @@ struct dereferenceable : B
 {
   P operator->() const
   {
-    return &*static_cast<const T&>(*this);
+    return ::boost::addressof(*static_cast<const T&>(*this));
   }
 };
 
@@ -824,6 +828,21 @@ template <class T> struct operators<T, T>
 //  Iterator helper classes (contributed by Jeremy Siek) -------------------//
 //  (Input and output iterator helpers contributed by Daryle Walker) -------//
 //  (Changed to use combined operator classes by Daryle Walker) ------------//
+//  (Adapted to C++17 by Daniel Frey) --------------------------------------//
+template <class Category,
+          class T,
+          class Distance = std::ptrdiff_t,
+          class Pointer = T*,
+          class Reference = T&>
+struct iterator_helper
+{
+  typedef Category iterator_category;
+  typedef T value_type;
+  typedef Distance difference_type;
+  typedef Pointer pointer;
+  typedef Reference reference;
+};
+
 template <class T,
           class V,
           class D = std::ptrdiff_t,
@@ -831,13 +850,13 @@ template <class T,
           class R = V const &>
 struct input_iterator_helper
   : input_iteratable<T, P
-  , std::iterator<std::input_iterator_tag, V, D, P, R
+  , iterator_helper<std::input_iterator_tag, V, D, P, R
     > > {};
 
 template<class T>
 struct output_iterator_helper
   : output_iteratable<T
-  , std::iterator<std::output_iterator_tag, void, void, void, void
+  , iterator_helper<std::output_iterator_tag, void, void, void, void
   > >
 {
   T& operator*()  { return static_cast<T&>(*this); }
@@ -851,7 +870,7 @@ template <class T,
           class R = V&>
 struct forward_iterator_helper
   : forward_iteratable<T, P
-  , std::iterator<std::forward_iterator_tag, V, D, P, R
+  , iterator_helper<std::forward_iterator_tag, V, D, P, R
     > > {};
 
 template <class T,
@@ -861,7 +880,7 @@ template <class T,
           class R = V&>
 struct bidirectional_iterator_helper
   : bidirectional_iteratable<T, P
-  , std::iterator<std::bidirectional_iterator_tag, V, D, P, R
+  , iterator_helper<std::bidirectional_iterator_tag, V, D, P, R
     > > {};
 
 template <class T,
@@ -871,7 +890,7 @@ template <class T,
           class R = V&>
 struct random_access_iterator_helper
   : random_access_iteratable<T, P, D, R
-  , std::iterator<std::random_access_iterator_tag, V, D, P, R
+  , iterator_helper<std::random_access_iterator_tag, V, D, P, R
     > >
 {
   friend D requires_difference_operator(const T& x, const T& y) {

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

@@ -0,0 +1,98 @@
+// Copyright (C) 2017 Andrzej Krzemienski.
+//
+// Use, modification, and distribution is 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)
+//
+// See http://www.boost.org/libs/optional for documentation.
+//
+// You are welcome to contact the author at:
+//  akrzemi1@gmail.com
+
+#ifndef BOOST_OPTIONAL_DETAIL_EXPERIMENTAL_TRAITS_04NOV2017_HPP
+#define BOOST_OPTIONAL_DETAIL_EXPERIMENTAL_TRAITS_04NOV2017_HPP
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+#include <boost/type_traits.hpp>
+
+namespace boost { namespace optional_detail {
+  
+// The condition to use POD implementation
+
+#ifdef BOOST_OPTIONAL_CONFIG_NO_POD_SPEC
+# define BOOST_OPTIONAL_DETAIL_NO_SPEC_FOR_TRIVIAL_TYPES
+#elif defined BOOST_OPTIONAL_CONFIG_NO_SPEC_FOR_TRIVIAL_TYPES
+# define BOOST_OPTIONAL_DETAIL_NO_SPEC_FOR_TRIVIAL_TYPES
+#elif !defined BOOST_HAS_TRIVIAL_CONSTRUCTOR
+# define BOOST_OPTIONAL_DETAIL_NO_SPEC_FOR_TRIVIAL_TYPES
+#elif !defined BOOST_HAS_TRIVIAL_MOVE_ASSIGN
+# define BOOST_OPTIONAL_DETAIL_NO_SPEC_FOR_TRIVIAL_TYPES
+#elif !defined BOOST_HAS_TRIVIAL_MOVE_CONSTRUCTOR
+# define BOOST_OPTIONAL_DETAIL_NO_SPEC_FOR_TRIVIAL_TYPES
+#elif !defined BOOST_HAS_TRIVIAL_COPY
+# define BOOST_OPTIONAL_DETAIL_NO_SPEC_FOR_TRIVIAL_TYPES
+#elif !defined BOOST_HAS_TRIVIAL_ASSIGN
+# define BOOST_OPTIONAL_DETAIL_NO_SPEC_FOR_TRIVIAL_TYPES
+#elif !defined BOOST_HAS_TRIVIAL_DESTRUCTOR
+# define BOOST_OPTIONAL_DETAIL_NO_SPEC_FOR_TRIVIAL_TYPES
+#elif BOOST_WORKAROUND(BOOST_GCC, < 50000)
+# define BOOST_OPTIONAL_DETAIL_NO_SPEC_FOR_TRIVIAL_TYPES
+#endif
+
+#if __cplusplus >= 201103L
+#  if BOOST_WORKAROUND(BOOST_GCC, >= 50000)
+#    define BOOST_OPTIONAL_DETAIL_USE_STD_TYPE_TRAITS
+#  elif (defined BOOST_CLANG)
+#    define BOOST_OPTIONAL_DETAIL_USE_STD_TYPE_TRAITS
+#  endif
+#endif  
+
+
+#ifndef BOOST_OPTIONAL_DETAIL_USE_STD_TYPE_TRAITS
+#  define BOOST_OPTIONAL_DETAIL_HAS_TRIVIAL_CTOR(T) BOOST_HAS_TRIVIAL_CONSTRUCTOR(T)
+#else
+#  define BOOST_OPTIONAL_DETAIL_HAS_TRIVIAL_CTOR(T) std::is_trivially_default_constructible<T>::value
+#endif
+  
+  
+  
+#ifndef BOOST_OPTIONAL_DETAIL_NO_SPEC_FOR_TRIVIAL_TYPES
+template <typename T>
+struct is_type_trivially_copyable
+  : boost::conditional<(boost::has_trivial_copy_constructor<T>::value &&
+                        boost::has_trivial_move_constructor<T>::value &&
+                        boost::has_trivial_destructor<T>::value &&
+                        boost::has_trivial_move_assign<T>::value &&
+                        boost::has_trivial_assign<T>::value),
+                        boost::true_type, boost::false_type>::type
+{};
+#else
+template <typename T>
+struct is_type_trivially_copyable
+: boost::conditional<(boost::is_scalar<T>::value && !boost::is_const<T>::value && !boost::is_volatile<T>::value),
+                     boost::true_type, boost::false_type>::type
+{};
+#endif
+
+
+
+#ifndef BOOST_OPTIONAL_DETAIL_NO_SPEC_FOR_TRIVIAL_TYPES  
+template <typename T>
+struct optional_uses_direct_storage_for_
+  : boost::conditional< (is_type_trivially_copyable<T>::value && BOOST_OPTIONAL_DETAIL_HAS_TRIVIAL_CTOR(T)) ||
+                        (boost::is_scalar<T>::value && !boost::is_const<T>::value && !boost::is_volatile<T>::value)
+                      , boost::true_type, boost::false_type>::type
+{};
+#else
+template <typename T>
+struct optional_uses_direct_storage_for_
+  : boost::conditional<(boost::is_scalar<T>::value && !boost::is_const<T>::value && !boost::is_volatile<T>::value)
+                      , boost::true_type, boost::false_type>::type
+{};
+#endif
+
+
+}} // boost::optional_detail
+
+#endif