passenger 6.0.16 → 6.0.18

data/src/cxx_supportlib/vendor-modified/boost/intrusive/treap_algorithms.hpp

@@ -205,13 +205,13 @@ class treap_algorithms
 
    //! @copydoc ::boost::intrusive::bstree_algorithms::unlink(node_ptr)
    template<class NodePtrPriorityCompare>
-   static void unlink(node_ptr node, NodePtrPriorityCompare pcomp)
+   static void unlink(node_ptr n, NodePtrPriorityCompare pcomp)
    {
-      node_ptr x = NodeTraits::get_parent(node);
+      node_ptr x = NodeTraits::get_parent(n);
       if(x){
          while(!bstree_algo::is_header(x))
             x = NodeTraits::get_parent(x);
-         erase(x, node, pcomp);
+         erase(x, n, pcomp);
       }
    }
 
@@ -220,19 +220,19 @@ class treap_algorithms
    static node_ptr unlink_leftmost_without_rebalance(node_ptr header) BOOST_NOEXCEPT;
 
    //! @copydoc ::boost::intrusive::bstree_algorithms::unique(const_node_ptr)
-   static bool unique(const_node_ptr node) BOOST_NOEXCEPT;
+   static bool unique(const_node_ptr n) BOOST_NOEXCEPT;
 
    //! @copydoc ::boost::intrusive::bstree_algorithms::size(const_node_ptr)
    static std::size_t size(const_node_ptr header) BOOST_NOEXCEPT;
 
    //! @copydoc ::boost::intrusive::bstree_algorithms::next_node(node_ptr)
-   static node_ptr next_node(node_ptr node) BOOST_NOEXCEPT;
+   static node_ptr next_node(node_ptr n) BOOST_NOEXCEPT;
 
    //! @copydoc ::boost::intrusive::bstree_algorithms::prev_node(node_ptr)
-   static node_ptr prev_node(node_ptr node) BOOST_NOEXCEPT;
+   static node_ptr prev_node(node_ptr n) BOOST_NOEXCEPT;
 
    //! @copydoc ::boost::intrusive::bstree_algorithms::init(node_ptr)
-   static void init(node_ptr node) BOOST_NOEXCEPT;
+   static void init(node_ptr n) BOOST_NOEXCEPT;
 
    //! @copydoc ::boost::intrusive::bstree_algorithms::init_header(node_ptr)
    static void init_header(node_ptr header) BOOST_NOEXCEPT;

data/src/cxx_supportlib/vendor-modified/boost/iterator/iterator_facade.hpp

@@ -154,79 +154,160 @@ namespace iterators {
     class postfix_increment_proxy
     {
         typedef typename iterator_value<Iterator>::type value_type;
+
      public:
         explicit postfix_increment_proxy(Iterator const& x)
-          : stored_value(*x)
+          : stored_iterator(x)
+          , stored_value(*x)
         {}
 
         // Returning a mutable reference allows nonsense like
         // (*r++).mutate(), but it imposes fewer assumptions about the
         // behavior of the value_type.  In particular, recall that
         // (*r).mutate() is legal if operator* returns by value.
-        value_type&
-        operator*() const
+        // Provides readability of *r++
+        value_type& operator*() const
         {
-            return this->stored_value;
+            return stored_value;
+        }
+
+        // Provides X(r++)
+        operator Iterator const&() const
+        {
+            return stored_iterator;
+        }
+
+        // Provides (r++)->foo()
+        value_type* operator->() const
+        {
+            return boost::addressof(stored_value);
         }
+
      private:
+        Iterator stored_iterator;
         mutable value_type stored_value;
     };
 
+
+    template <class Iterator>
+    class writable_postfix_increment_dereference_proxy;
+
+    template <class T>
+    struct is_not_writable_postfix_increment_dereference_proxy :
+        public boost::true_type
+    {};
+
+    template <class Iterator>
+    struct is_not_writable_postfix_increment_dereference_proxy<
+        writable_postfix_increment_dereference_proxy<Iterator>
+    > :
+        public boost::false_type
+    {};
+
+    template <class Iterator>
+    class writable_postfix_increment_proxy;
+
     //
     // In general, we can't determine that such an iterator isn't
     // writable -- we also need to store a copy of the old iterator so
     // that it can be written into.
     template <class Iterator>
-    class writable_postfix_increment_proxy
+    class writable_postfix_increment_dereference_proxy
     {
+        friend class writable_postfix_increment_proxy<Iterator>;
+
         typedef typename iterator_value<Iterator>::type value_type;
+
      public:
-        explicit writable_postfix_increment_proxy(Iterator const& x)
-          : stored_value(*x)
-          , stored_iterator(x)
+        explicit writable_postfix_increment_dereference_proxy(Iterator const& x)
+          : stored_iterator(x)
+          , stored_value(*x)
         {}
 
-        // Dereferencing must return a proxy so that both *r++ = o and
-        // value_type(*r++) can work.  In this case, *r is the same as
-        // *r++, and the conversion operator below is used to ensure
-        // readability.
-        writable_postfix_increment_proxy const&
-        operator*() const
+        // Provides readability of *r++
+        operator value_type&() const
         {
-            return *this;
+            return this->stored_value;
         }
 
-        // Provides readability of *r++
-        operator value_type&() const
+        template <class OtherIterator>
+        writable_postfix_increment_dereference_proxy const&
+        operator=(writable_postfix_increment_dereference_proxy<OtherIterator> const& x) const
         {
-            return stored_value;
+            typedef typename iterator_value<OtherIterator>::type other_value_type;
+            *this->stored_iterator = static_cast<other_value_type&>(x);
+            return *this;
         }
 
         // Provides writability of *r++
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
         template <class T>
-        T const& operator=(T const& x) const
+        typename iterators::enable_if<
+            is_not_writable_postfix_increment_dereference_proxy< T >,
+            writable_postfix_increment_dereference_proxy const&
+        >::type operator=(T&& x) const
+        {
+            *this->stored_iterator = static_cast< T&& >(x);
+            return *this;
+        }
+#else
+        template <class T>
+        typename iterators::enable_if<
+            is_not_writable_postfix_increment_dereference_proxy< T >,
+            writable_postfix_increment_dereference_proxy const&
+        >::type operator=(T const& x) const
         {
             *this->stored_iterator = x;
-            return x;
+            return *this;
         }
 
         // This overload just in case only non-const objects are writable
         template <class T>
-        T& operator=(T& x) const
+        typename iterators::enable_if<
+            is_not_writable_postfix_increment_dereference_proxy< T >,
+            writable_postfix_increment_dereference_proxy const&
+        >::type operator=(T& x) const
         {
             *this->stored_iterator = x;
-            return x;
+            return *this;
+        }
+#endif
+
+     private:
+        Iterator stored_iterator;
+        mutable value_type stored_value;
+    };
+
+    template <class Iterator>
+    class writable_postfix_increment_proxy
+    {
+        typedef typename iterator_value<Iterator>::type value_type;
+
+     public:
+        explicit writable_postfix_increment_proxy(Iterator const& x)
+          : dereference_proxy(x)
+        {}
+
+        writable_postfix_increment_dereference_proxy<Iterator> const&
+        operator*() const
+        {
+            return dereference_proxy;
         }
 
         // Provides X(r++)
         operator Iterator const&() const
         {
-            return stored_iterator;
+            return dereference_proxy.stored_iterator;
+        }
+
+        // Provides (r++)->foo()
+        value_type* operator->() const
+        {
+            return boost::addressof(dereference_proxy.stored_value);
         }
 
      private:
-        mutable value_type stored_value;
-        Iterator stored_iterator;
+        writable_postfix_increment_dereference_proxy<Iterator> dereference_proxy;
     };
 
 # ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION

data/src/cxx_supportlib/vendor-modified/boost/lexical_cast/detail/converter_lexical_streams.hpp

@@ -76,7 +76,7 @@
 #include <boost/container/container_fwd.hpp>
 #include <boost/integer.hpp>
 #include <boost/detail/basic_pointerbuf.hpp>
-#include <boost/noncopyable.hpp>
+#include <boost/core/noncopyable.hpp>
 #ifndef BOOST_NO_CWCHAR
 #   include <cwchar>
 #endif

data/src/cxx_supportlib/vendor-modified/boost/lexical_cast/detail/converter_numeric.hpp

@@ -32,6 +32,7 @@
 #include <boost/type_traits/is_arithmetic.hpp>
 #include <boost/type_traits/is_base_of.hpp>
 #include <boost/type_traits/is_float.hpp>
+#include <boost/type_traits/remove_volatile.hpp>
 
 #include <boost/numeric/conversion/cast.hpp>
 
@@ -155,14 +156,16 @@ struct lexical_cast_dynamic_num_ignoring_minus
 template <typename Target, typename Source>
 struct dynamic_num_converter_impl
 {
-    static inline bool try_convert(const Source &arg, Target& result) BOOST_NOEXCEPT {
+    typedef BOOST_DEDUCED_TYPENAME boost::remove_volatile<Source>::type source_type;
+
+    static inline bool try_convert(source_type arg, Target& result) BOOST_NOEXCEPT {
         typedef BOOST_DEDUCED_TYPENAME boost::conditional<
             boost::is_unsigned<Target>::value &&
-            (boost::is_signed<Source>::value || boost::is_float<Source>::value) &&
-            !(boost::is_same<Source, bool>::value) &&
+            (boost::is_signed<source_type>::value || boost::is_float<source_type>::value) &&
+            !(boost::is_same<source_type, bool>::value) &&
             !(boost::is_same<Target, bool>::value),
-            lexical_cast_dynamic_num_ignoring_minus<Target, Source>,
-            lexical_cast_dynamic_num_not_ignoring_minus<Target, Source>
+            lexical_cast_dynamic_num_ignoring_minus<Target, source_type>,
+            lexical_cast_dynamic_num_not_ignoring_minus<Target, source_type>
         >::type caster_type;
 
         return caster_type::try_convert(arg, result);

data/src/cxx_supportlib/vendor-modified/boost/lexical_cast/detail/lcast_unsigned_converters.hpp

@@ -50,7 +50,7 @@
 #include <boost/lexical_cast/detail/lcast_char_constants.hpp>
 #include <boost/type_traits/make_unsigned.hpp>
 #include <boost/type_traits/is_signed.hpp>
-#include <boost/noncopyable.hpp>
+#include <boost/core/noncopyable.hpp>
 
 namespace boost
 {

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

@@ -175,7 +175,8 @@ void swap_and_update_key
 {
    if(begin != with){
       ::boost::adl_move_swap_ranges(begin, end, with);
-      ::boost::adl_move_swap(*key_next, *key_range2);
+      if(key_next != key_range2)  //Avoid potential self-swapping
+         ::boost::adl_move_swap(*key_next, *key_range2);
       if(key_next == key_mid){
          key_mid = key_range2;
       }
@@ -217,7 +218,8 @@ RandIt2 buffer_and_update_key
       while(begin != end) {
          op(three_way_t(), begin++, with++, buffer++);
       }
-      ::boost::adl_move_swap(*key_next, *key_range2);
+      if (key_next != key_range2)   //Avoid potential self-swapping
+         ::boost::adl_move_swap(*key_next, *key_range2);
       if (key_next == key_mid) {
          key_mid = key_range2;
       }

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

@@ -192,7 +192,8 @@ namespace pdqsort_detail {
 
         // Put the pivot in the right place.
         Iter pivot_pos = first - 1;
-        *begin = boost::move(*pivot_pos);
+        if(begin != pivot_pos)   //Avoid potential self-move
+            *begin = boost::move(*pivot_pos);
         *pivot_pos = boost::move(pivot);
 
         return pdqsort_detail::pair<Iter, bool>(pivot_pos, already_partitioned);

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

@@ -190,33 +190,37 @@
 #   endif
 
 //    BOOST_MOVE_HAS_TRIVIAL_MOVE_CONSTRUCTOR
-#   if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && BOOST_MOVE_HAS_TRAIT(is_constructible) && BOOST_MOVE_HAS_TRAIT(is_trivially_constructible)
+#   if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) 
+
+#   if BOOST_MOVE_HAS_TRAIT(is_constructible) && BOOST_MOVE_HAS_TRAIT(is_trivially_constructible)
 #     define BOOST_MOVE_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T) (__is_constructible(T, T&&) && __is_trivially_constructible(T, T&&))
 #   elif BOOST_MOVE_HAS_TRAIT(has_trivial_move_constructor)
 #     define BOOST_MOVE_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T) __has_trivial_move_constructor(T)
 #   endif
 
 //    BOOST_MOVE_HAS_TRIVIAL_MOVE_ASSIGN
-#   if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && BOOST_MOVE_HAS_TRAIT(is_assignable) && BOOST_MOVE_HAS_TRAIT(is_trivially_assignable)
+#   if BOOST_MOVE_HAS_TRAIT(is_assignable) && BOOST_MOVE_HAS_TRAIT(is_trivially_assignable)
 #     define BOOST_MOVE_HAS_TRIVIAL_MOVE_ASSIGN(T) (__is_assignable(T, T&&) && __is_trivially_assignable(T, T&&))
 #   elif BOOST_MOVE_HAS_TRAIT(has_trivial_move_assign)
 #     define BOOST_MOVE_HAS_TRIVIAL_MOVE_ASSIGN(T) __has_trivial_move_assign(T)
 #   endif
 
 //    BOOST_MOVE_HAS_NOTHROW_MOVE_CONSTRUCTOR
-#   if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && BOOST_MOVE_HAS_TRAIT(is_constructible) && BOOST_MOVE_HAS_TRAIT(is_nothrow_constructible)
+#   if BOOST_MOVE_HAS_TRAIT(is_constructible) && BOOST_MOVE_HAS_TRAIT(is_nothrow_constructible)
 #     define BOOST_MOVE_HAS_NOTHROW_MOVE_CONSTRUCTOR(T) (__is_constructible(T, T&&) && __is_nothrow_constructible(T, T&&))
 #   elif BOOST_MOVE_HAS_TRAIT(has_nothrow_move_constructor)
 #     define BOOST_MOVE_HAS_NOTHROW_MOVE_CONSTRUCTOR(T) __has_nothrow_move_constructor(T)
 #   endif
 
 //    BOOST_MOVE_HAS_NOTHROW_MOVE_ASSIGN
-#   if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && BOOST_MOVE_HAS_TRAIT(is_assignable) && BOOST_MOVE_HAS_TRAIT(is_nothrow_assignable)
+#   if BOOST_MOVE_HAS_TRAIT(is_assignable) && BOOST_MOVE_HAS_TRAIT(is_nothrow_assignable)
 #     define BOOST_MOVE_HAS_NOTHROW_MOVE_ASSIGN(T) (__is_assignable(T, T&&) && __is_nothrow_assignable(T, T&&))
 #   elif BOOST_MOVE_HAS_TRAIT(has_nothrow_move_assign)
 #     define BOOST_MOVE_HAS_NOTHROW_MOVE_ASSIGN(T) __has_nothrow_move_assign(T)
 #   endif
 
+#   endif   //BOOST_NO_CXX11_RVALUE_REFERENCES
+
 //    BOOST_MOVE_ALIGNMENT_OF
 #   define BOOST_MOVE_ALIGNMENT_OF(T) __alignof(T)
 

data/src/cxx_supportlib/vendor-modified/boost/mp11/bind.hpp

@@ -0,0 +1,111 @@
+#ifndef BOOST_MP11_BIND_HPP_INCLUDED
+#define BOOST_MP11_BIND_HPP_INCLUDED
+
+//  Copyright 2017, 2018 Peter Dimov.
+//
+//  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
+
+#include <boost/mp11/algorithm.hpp>
+#include <boost/mp11/utility.hpp>
+#include <cstddef>
+
+namespace boost
+{
+namespace mp11
+{
+
+// mp_bind_front
+template<template<class...> class F, class... T> struct mp_bind_front
+{
+    // the indirection through mp_defer works around the language inability
+    // to expand U... into a fixed parameter list of an alias template
+
+    template<class... U> using fn = typename mp_defer<F, T..., U...>::type;
+};
+
+template<class Q, class... T> using mp_bind_front_q = mp_bind_front<Q::template fn, T...>;
+
+// mp_bind_back
+template<template<class...> class F, class... T> struct mp_bind_back
+{
+    template<class... U> using fn = typename mp_defer<F, U..., T...>::type;
+};
+
+template<class Q, class... T> using mp_bind_back_q = mp_bind_back<Q::template fn, T...>;
+
+// mp_arg
+template<std::size_t I> struct mp_arg
+{
+    template<class... T> using fn = mp_at_c<mp_list<T...>, I>;
+};
+
+using _1 = mp_arg<0>;
+using _2 = mp_arg<1>;
+using _3 = mp_arg<2>;
+using _4 = mp_arg<3>;
+using _5 = mp_arg<4>;
+using _6 = mp_arg<5>;
+using _7 = mp_arg<6>;
+using _8 = mp_arg<7>;
+using _9 = mp_arg<8>;
+
+// mp_bind
+template<template<class...> class F, class... T> struct mp_bind;
+
+namespace detail
+{
+
+template<class V, class... T> struct eval_bound_arg
+{
+    using type = V;
+};
+
+template<std::size_t I, class... T> struct eval_bound_arg<mp_arg<I>, T...>
+{
+    using type = typename mp_arg<I>::template fn<T...>;
+};
+
+template<template<class...> class F, class... U, class... T> struct eval_bound_arg<mp_bind<F, U...>, T...>
+{
+    using type = typename mp_bind<F, U...>::template fn<T...>;
+};
+
+template<template<class...> class F, class... U, class... T> struct eval_bound_arg<mp_bind_front<F, U...>, T...>
+{
+    using type = typename mp_bind_front<F, U...>::template fn<T...>;
+};
+
+template<template<class...> class F, class... U, class... T> struct eval_bound_arg<mp_bind_back<F, U...>, T...>
+{
+    using type = typename mp_bind_back<F, U...>::template fn<T...>;
+};
+
+} // namespace detail
+
+template<template<class...> class F, class... T> struct mp_bind
+{
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, == 1915 )
+private:
+
+    template<class... U> struct _f { using type = F<typename detail::eval_bound_arg<T, U...>::type...>; };
+
+public:
+
+    template<class... U> using fn = typename _f<U...>::type;
+
+#else
+
+    template<class... U> using fn = F<typename detail::eval_bound_arg<T, U...>::type...>;
+
+#endif
+};
+
+template<class Q, class... T> using mp_bind_q = mp_bind<Q::template fn, T...>;
+
+} // namespace mp11
+} // namespace boost
+
+#endif // #ifndef BOOST_MP11_BIND_HPP_INCLUDED

data/src/cxx_supportlib/vendor-modified/boost/mp11/version.hpp

@@ -11,6 +11,6 @@
 // Same format as BOOST_VERSION:
 //   major * 100000 + minor * 100 + patch
 
-#define BOOST_MP11_VERSION 108000
+#define BOOST_MP11_VERSION 108100
 
 #endif // #ifndef BOOST_MP11_VERSION_HPP_INCLUDED

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

@@ -16,15 +16,15 @@
 #include "boost/numeric/conversion/int_float_mixture_enum.hpp"
 #include "boost/numeric/conversion/detail/meta.hpp"
 
-#include "boost/mpl/integral_c.hpp"
+#include "boost/type_traits/integral_constant.hpp"
 
 namespace boost { namespace numeric { namespace convdetail
 {
   // Integral Constants for 'IntFloatMixture'
-  typedef mpl::integral_c<int_float_mixture_enum, integral_to_integral> int2int_c ;
-  typedef mpl::integral_c<int_float_mixture_enum, integral_to_float>    int2float_c ;
-  typedef mpl::integral_c<int_float_mixture_enum, float_to_integral>    float2int_c ;
-  typedef mpl::integral_c<int_float_mixture_enum, float_to_float>       float2float_c ;
+  typedef boost::integral_constant<int_float_mixture_enum, integral_to_integral> int2int_c ;
+  typedef boost::integral_constant<int_float_mixture_enum, integral_to_float>    int2float_c ;
+  typedef boost::integral_constant<int_float_mixture_enum, float_to_integral>    float2int_c ;
+  typedef boost::integral_constant<int_float_mixture_enum, float_to_float>       float2float_c ;
 
   // Metafunction:
   //

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

@@ -16,15 +16,15 @@
 #include "boost/numeric/conversion/sign_mixture_enum.hpp"
 #include "boost/numeric/conversion/detail/meta.hpp"
 
-#include "boost/mpl/integral_c.hpp"
+#include "boost/type_traits/integral_constant.hpp"
 
 namespace boost { namespace numeric { namespace convdetail
 {
   // Integral Constants for 'SignMixture'
-  typedef mpl::integral_c<sign_mixture_enum, unsigned_to_unsigned> unsig2unsig_c ;
-  typedef mpl::integral_c<sign_mixture_enum, signed_to_signed>     sig2sig_c ;
-  typedef mpl::integral_c<sign_mixture_enum, signed_to_unsigned>   sig2unsig_c ;
-  typedef mpl::integral_c<sign_mixture_enum, unsigned_to_signed>   unsig2sig_c ;
+  typedef boost::integral_constant<sign_mixture_enum, unsigned_to_unsigned> unsig2unsig_c ;
+  typedef boost::integral_constant<sign_mixture_enum, signed_to_signed>     sig2sig_c ;
+  typedef boost::integral_constant<sign_mixture_enum, signed_to_unsigned>   sig2unsig_c ;
+  typedef boost::integral_constant<sign_mixture_enum, unsigned_to_signed>   unsig2sig_c ;
 
   // Metafunction:
   //

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

@@ -15,15 +15,15 @@
 #include "boost/numeric/conversion/udt_builtin_mixture_enum.hpp"
 #include "boost/numeric/conversion/detail/meta.hpp"
 
-#include "boost/mpl/integral_c.hpp"
+#include "boost/type_traits/integral_constant.hpp"
 
 namespace boost { namespace numeric { namespace convdetail
 {
   // Integral Constants for 'UdtMixture'
-  typedef mpl::integral_c<udt_builtin_mixture_enum, builtin_to_builtin> builtin2builtin_c ;
-  typedef mpl::integral_c<udt_builtin_mixture_enum, builtin_to_udt>     builtin2udt_c ;
-  typedef mpl::integral_c<udt_builtin_mixture_enum, udt_to_builtin>     udt2builtin_c ;
-  typedef mpl::integral_c<udt_builtin_mixture_enum, udt_to_udt>         udt2udt_c ;
+  typedef boost::integral_constant<udt_builtin_mixture_enum, builtin_to_builtin> builtin2builtin_c ;
+  typedef boost::integral_constant<udt_builtin_mixture_enum, builtin_to_udt>     builtin2udt_c ;
+  typedef boost::integral_constant<udt_builtin_mixture_enum, udt_to_builtin>     udt2builtin_c ;
+  typedef boost::integral_constant<udt_builtin_mixture_enum, udt_to_udt>         udt2udt_c ;
 
   // Metafunction:
   //

data/src/cxx_supportlib/vendor-modified/boost/preprocessor/variadic/has_opt.hpp

@@ -17,10 +17,14 @@
 # /* BOOST_PP_VARIADIC_HAS_OPT */
 #
 # if defined(__cplusplus) && __cplusplus > 201703L
-# include <boost/preprocessor/variadic/detail/has_opt.hpp>
-# define BOOST_PP_VARIADIC_HAS_OPT() \
+#  if defined(__GNUC__) && !defined(__clang__) && __GNUC__ >= 8 && __GNUC__ < 10
+#   define BOOST_PP_VARIADIC_HAS_OPT() 0
+#  else
+#   include <boost/preprocessor/variadic/detail/has_opt.hpp>
+#   define BOOST_PP_VARIADIC_HAS_OPT() \
   BOOST_PP_VARIADIC_HAS_OPT_ELEM2(BOOST_PP_VARIADIC_HAS_OPT_FUNCTION(?),) \
 /**/
+#  endif
 # else
 # define BOOST_PP_VARIADIC_HAS_OPT() 0
 # endif

data/src/cxx_supportlib/vendor-modified/boost/smart_ptr/detail/spinlock_gcc_atomic.hpp

@@ -30,7 +30,16 @@ class spinlock
 {
 public:
 
-    unsigned char v_;
+    // `bool` alignment is required for Apple PPC32
+    // https://github.com/boostorg/smart_ptr/issues/105
+    // https://github.com/PurpleI2P/i2pd/issues/1726
+    // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=107590
+
+    union
+    {
+        unsigned char v_;
+        bool align_;
+    };
 
 public:
 
@@ -80,6 +89,6 @@ public:
 } // namespace detail
 } // namespace boost
 
-#define BOOST_DETAIL_SPINLOCK_INIT {0}
+#define BOOST_DETAIL_SPINLOCK_INIT {{0}}
 
 #endif // #ifndef BOOST_SMART_PTR_DETAIL_SPINLOCK_GCC_ATOMIC_HPP_INCLUDED

data/src/cxx_supportlib/vendor-modified/boost/smart_ptr/intrusive_ptr.hpp

@@ -245,7 +245,7 @@ template<class T, class U> inline bool operator!=(T * a, intrusive_ptr<U> const
     return a != b.get();
 }
 
-#if __GNUC__ == 2 && __GNUC_MINOR__ <= 96
+#if defined(__GNUC__) && __GNUC__ == 2 && __GNUC_MINOR__ <= 96
 
 // Resolve the ambiguity between our op!= and the one in rel_ops
 

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

@@ -12,8 +12,14 @@
 #include <boost/config/workaround.hpp>
 
 // BOOST_SYSTEM_HAS_SYSTEM_ERROR
+//
+// The macro BOOST_SYSTEM_DISABLE_THREADS can be defined on configurations
+// that provide <system_error> and <atomic>, but not <mutex>, such as the
+// single-threaded libstdc++.
+//
+// https://github.com/boostorg/system/issues/92
 
-#if !defined(BOOST_NO_CXX11_HDR_SYSTEM_ERROR) && !defined(BOOST_NO_CXX11_HDR_ATOMIC) && !defined(BOOST_NO_CXX11_HDR_MUTEX)
+#if !defined(BOOST_NO_CXX11_HDR_SYSTEM_ERROR) && !defined(BOOST_NO_CXX11_HDR_ATOMIC) && ( !defined(BOOST_NO_CXX11_HDR_MUTEX) || defined(BOOST_SYSTEM_DISABLE_THREADS) )
 # define BOOST_SYSTEM_HAS_SYSTEM_ERROR
 #endif
 

data/src/cxx_supportlib/vendor-modified/boost/system/detail/error_category.hpp

@@ -48,7 +48,7 @@ class std_category;
 #pragma GCC diagnostic ignored "-Wnon-virtual-dtor"
 #endif
 
-#if defined(BOOST_MSVC)
+#if defined(BOOST_MSVC) && BOOST_MSVC < 1900
 #pragma warning(push)
 #pragma warning(disable: 4351) //  new behavior: elements of array will be default initialized
 #endif
@@ -183,7 +183,7 @@ public:
 #endif
 };
 
-#if defined(BOOST_MSVC)
+#if defined(BOOST_MSVC) && BOOST_MSVC < 1900
 #pragma warning(pop)
 #endif