passenger 6.0.20 → 6.0.21

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

@@ -61,8 +61,11 @@
 #elif defined(BOOST_MSVC) && (_MSC_VER < 1900 || defined(_DEBUG))
    //"__forceinline" and MSVC seems to have some bugs in old versions and in debug mode
    #define BOOST_MOVE_FORCEINLINE inline
-#elif defined(BOOST_GCC) && (__GNUC__ <= 5)
+#elif defined(BOOST_CLANG) || (defined(BOOST_GCC) && ((__GNUC__ <= 5) || defined(__MINGW32__)))
    //Older GCCs have problems with forceinline
+   //Clang can have code bloat issues with forceinline, see
+   //https://lists.boost.org/boost-users/2023/04/91445.php and
+   //https://github.com/llvm/llvm-project/issues/62202
    #define BOOST_MOVE_FORCEINLINE inline
 #else
    #define BOOST_MOVE_FORCEINLINE BOOST_FORCEINLINE
@@ -126,7 +129,7 @@ template<unsigned> struct static_assert_test {};
 #define BOOST_MOVE_STATIC_ASSERT(B) \
          typedef ::boost::move_detail::static_assert_test<\
             (unsigned)sizeof(::boost::move_detail::STATIC_ASSERTION_FAILURE<bool(B)>)>\
-               BOOST_JOIN(boost_static_assert_typedef_, __LINE__) BOOST_ATTRIBUTE_UNUSED
+               BOOST_JOIN(boost_move_static_assert_typedef_, __LINE__) BOOST_ATTRIBUTE_UNUSED
 
 #endif
 

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

@@ -58,20 +58,20 @@ class move_iterator
    typedef typename boost::movelib::iterator_traits<iterator_type>::difference_type   difference_type;
    typedef typename boost::movelib::iterator_traits<iterator_type>::iterator_category iterator_category;
 
-   BOOST_MOVE_FORCEINLINE move_iterator()
+   inline move_iterator()
       : m_it()
    {}
 
-   BOOST_MOVE_FORCEINLINE explicit move_iterator(const It &i)
+   inline explicit move_iterator(const It &i)
       :  m_it(i)
    {}
 
    template <class U>
-   BOOST_MOVE_FORCEINLINE move_iterator(const move_iterator<U>& u)
+   inline move_iterator(const move_iterator<U>& u)
       :  m_it(u.m_it)
    {}
 
-   BOOST_MOVE_FORCEINLINE reference operator*() const
+   inline reference operator*() const
    {
       #if defined(BOOST_NO_CXX11_RVALUE_REFERENCES) || defined(BOOST_MOVE_OLD_RVALUE_REF_BINDING_RULES)
       return *m_it;
@@ -80,34 +80,34 @@ class move_iterator
       #endif
    }
 
-   BOOST_MOVE_FORCEINLINE pointer   operator->() const
+   inline pointer   operator->() const
    {  return m_it;   }
 
-   BOOST_MOVE_FORCEINLINE move_iterator& operator++()
+   inline move_iterator& operator++()
    {  ++m_it; return *this;   }
 
-   BOOST_MOVE_FORCEINLINE move_iterator<iterator_type>  operator++(int)
+   inline move_iterator<iterator_type>  operator++(int)
    {  move_iterator<iterator_type> tmp(*this); ++(*this); return tmp;   }
 
-   BOOST_MOVE_FORCEINLINE move_iterator& operator--()
+   inline move_iterator& operator--()
    {  --m_it; return *this;   }
 
-   BOOST_MOVE_FORCEINLINE move_iterator<iterator_type>  operator--(int)
+   inline move_iterator<iterator_type>  operator--(int)
    {  move_iterator<iterator_type> tmp(*this); --(*this); return tmp;   }
 
    move_iterator<iterator_type>  operator+ (difference_type n) const
    {  return move_iterator<iterator_type>(m_it + n);  }
 
-   BOOST_MOVE_FORCEINLINE move_iterator& operator+=(difference_type n)
+   inline move_iterator& operator+=(difference_type n)
    {  m_it += n; return *this;   }
 
-   BOOST_MOVE_FORCEINLINE move_iterator<iterator_type>  operator- (difference_type n) const
+   inline move_iterator<iterator_type>  operator- (difference_type n) const
    {  return move_iterator<iterator_type>(m_it - n);  }
 
-   BOOST_MOVE_FORCEINLINE move_iterator& operator-=(difference_type n)
+   inline move_iterator& operator-=(difference_type n)
    {  m_it -= n; return *this;   }
 
-   BOOST_MOVE_FORCEINLINE reference operator[](difference_type n) const
+   inline reference operator[](difference_type n) const
    {
       #if defined(BOOST_NO_CXX11_RVALUE_REFERENCES) || defined(BOOST_MOVE_OLD_RVALUE_REF_BINDING_RULES)
       return m_it[n];
@@ -116,28 +116,28 @@ class move_iterator
       #endif
    }
 
-   BOOST_MOVE_FORCEINLINE friend bool operator==(const move_iterator& x, const move_iterator& y)
+   inline friend bool operator==(const move_iterator& x, const move_iterator& y)
    {  return x.m_it == y.m_it;  }
 
-   BOOST_MOVE_FORCEINLINE friend bool operator!=(const move_iterator& x, const move_iterator& y)
+   inline friend bool operator!=(const move_iterator& x, const move_iterator& y)
    {  return x.m_it != y.m_it;  }
 
-   BOOST_MOVE_FORCEINLINE friend bool operator< (const move_iterator& x, const move_iterator& y)
+   inline friend bool operator< (const move_iterator& x, const move_iterator& y)
    {  return x.m_it < y.m_it;   }
 
-   BOOST_MOVE_FORCEINLINE friend bool operator<=(const move_iterator& x, const move_iterator& y)
+   inline friend bool operator<=(const move_iterator& x, const move_iterator& y)
    {  return x.m_it <= y.m_it;  }
 
-   BOOST_MOVE_FORCEINLINE friend bool operator> (const move_iterator& x, const move_iterator& y)
+   inline friend bool operator> (const move_iterator& x, const move_iterator& y)
    {  return x.m_it > y.m_it;  }
 
-   BOOST_MOVE_FORCEINLINE friend bool operator>=(const move_iterator& x, const move_iterator& y)
+   inline friend bool operator>=(const move_iterator& x, const move_iterator& y)
    {  return x.m_it >= y.m_it;  }
 
-   BOOST_MOVE_FORCEINLINE friend difference_type operator-(const move_iterator& x, const move_iterator& y)
+   inline friend difference_type operator-(const move_iterator& x, const move_iterator& y)
    {  return x.m_it - y.m_it;   }
 
-   BOOST_MOVE_FORCEINLINE friend move_iterator operator+(difference_type n, const move_iterator& x)
+   inline friend move_iterator operator+(difference_type n, const move_iterator& x)
    {  return move_iterator(x.m_it + n);   }
 
    private:
@@ -170,7 +170,7 @@ struct is_move_iterator< ::boost::move_iterator<I> >
 //!
 //! <b>Returns</b>: move_iterator<It>(i).
 template<class It>
-BOOST_MOVE_FORCEINLINE move_iterator<It> make_move_iterator(const It &it)
+inline move_iterator<It> make_move_iterator(const It &it)
 {  return move_iterator<It>(it); }
 
 //////////////////////////////////////////////////////////////////////////////

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

@@ -92,25 +92,25 @@ struct unique_ptr_data
    typedef typename deleter_types<D>::del_ref            del_ref;
    typedef typename deleter_types<D>::del_cref           del_cref;
 
-   BOOST_MOVE_FORCEINLINE unique_ptr_data() BOOST_NOEXCEPT
+   inline unique_ptr_data() BOOST_NOEXCEPT
       : m_p(), d()
    {}
 
-   BOOST_MOVE_FORCEINLINE explicit unique_ptr_data(P p) BOOST_NOEXCEPT
+   inline explicit unique_ptr_data(P p) BOOST_NOEXCEPT
       : m_p(p), d()
    {}
 
-   BOOST_MOVE_FORCEINLINE unique_ptr_data(P p, deleter_arg_type1 d1) BOOST_NOEXCEPT
+   inline unique_ptr_data(P p, deleter_arg_type1 d1) BOOST_NOEXCEPT
       : m_p(p), d(d1)
    {}
 
    template <class U>
-   BOOST_MOVE_FORCEINLINE unique_ptr_data(P p, BOOST_FWD_REF(U) d1) BOOST_NOEXCEPT
+   inline unique_ptr_data(P p, BOOST_FWD_REF(U) d1) BOOST_NOEXCEPT
       : m_p(p), d(::boost::forward<U>(d1))
    {}
 
-   BOOST_MOVE_FORCEINLINE del_ref deleter()       { return d; }
-   BOOST_MOVE_FORCEINLINE del_cref deleter() const{ return d; }
+   inline del_ref deleter()       { return d; }
+   inline del_cref deleter() const{ return d; }
 
    P m_p;
    D d;
@@ -128,25 +128,25 @@ struct unique_ptr_data<P, D, false>
    typedef typename deleter_types<D>::del_ref            del_ref;
    typedef typename deleter_types<D>::del_cref           del_cref;
 
-   BOOST_MOVE_FORCEINLINE unique_ptr_data() BOOST_NOEXCEPT
+   inline unique_ptr_data() BOOST_NOEXCEPT
       : D(), m_p()
    {}
 
-   BOOST_MOVE_FORCEINLINE explicit unique_ptr_data(P p) BOOST_NOEXCEPT
+   inline explicit unique_ptr_data(P p) BOOST_NOEXCEPT
       : D(), m_p(p)
    {}
 
-   BOOST_MOVE_FORCEINLINE unique_ptr_data(P p, deleter_arg_type1 d1) BOOST_NOEXCEPT
+   inline unique_ptr_data(P p, deleter_arg_type1 d1) BOOST_NOEXCEPT
       : D(d1), m_p(p)
    {}
 
    template <class U>
-   BOOST_MOVE_FORCEINLINE unique_ptr_data(P p, BOOST_FWD_REF(U) d) BOOST_NOEXCEPT
+   inline unique_ptr_data(P p, BOOST_FWD_REF(U) d) BOOST_NOEXCEPT
       : D(::boost::forward<U>(d)), m_p(p)
    {}
 
-   BOOST_MOVE_FORCEINLINE del_ref deleter()        BOOST_NOEXCEPT   {  return static_cast<del_ref>(*this);   }
-   BOOST_MOVE_FORCEINLINE del_cref deleter() const BOOST_NOEXCEPT   {  return static_cast<del_cref>(*this);  }
+   inline del_ref deleter()        BOOST_NOEXCEPT   {  return static_cast<del_ref>(*this);   }
+   inline del_cref deleter() const BOOST_NOEXCEPT   {  return static_cast<del_cref>(*this);  }
 
    P m_p;
 
@@ -388,7 +388,7 @@ class unique_ptr
    //!
    //! <b>Remarks</b>: If this constructor is instantiated with a pointer type or reference type
    //!   for the template argument D, the program is ill-formed.   
-   BOOST_MOVE_FORCEINLINE BOOST_CONSTEXPR unique_ptr() BOOST_NOEXCEPT
+   inline BOOST_CONSTEXPR unique_ptr() BOOST_NOEXCEPT
       : m_data()
    {
       //If this constructor is instantiated with a pointer type or reference type
@@ -399,7 +399,7 @@ class unique_ptr
 
    //! <b>Effects</b>: Same as <tt>unique_ptr()</tt> (default constructor).
    //! 
-   BOOST_MOVE_FORCEINLINE BOOST_CONSTEXPR unique_ptr(BOOST_MOVE_DOC0PTR(bmupd::nullptr_type)) BOOST_NOEXCEPT
+   inline BOOST_CONSTEXPR unique_ptr(BOOST_MOVE_DOC0PTR(bmupd::nullptr_type)) BOOST_NOEXCEPT
       : m_data()
    {
       //If this constructor is instantiated with a pointer type or reference type
@@ -422,7 +422,7 @@ class unique_ptr
    //!      - If T is not an array type and Pointer is implicitly convertible to pointer.
    //!      - If T is an array type and Pointer is a more CV qualified pointer to element_type.
    template<class Pointer>
-   BOOST_MOVE_FORCEINLINE explicit unique_ptr(Pointer p
+   inline explicit unique_ptr(Pointer p
       BOOST_MOVE_DOCIGN(BOOST_MOVE_I typename bmupd::enable_up_ptr<T BOOST_MOVE_I Pointer BOOST_MOVE_I pointer>::type* =0)
                  ) BOOST_NOEXCEPT
       : m_data(p)
@@ -460,7 +460,7 @@ class unique_ptr
    //!      - If T is not an array type and Pointer is implicitly convertible to pointer.
    //!      - If T is an array type and Pointer is a more CV qualified pointer to element_type.
    template<class Pointer>
-   BOOST_MOVE_FORCEINLINE unique_ptr(Pointer p, BOOST_MOVE_SEEDOC(deleter_arg_type1) d1
+   inline unique_ptr(Pointer p, BOOST_MOVE_SEEDOC(deleter_arg_type1) d1
       BOOST_MOVE_DOCIGN(BOOST_MOVE_I typename bmupd::enable_up_ptr<T BOOST_MOVE_I Pointer BOOST_MOVE_I pointer>::type* =0)
               ) BOOST_NOEXCEPT
       : m_data(p, d1)
@@ -473,7 +473,7 @@ class unique_ptr
 
    //! <b>Effects</b>: Same effects as <tt>template<class Pointer> unique_ptr(Pointer p, deleter_arg_type1 d1)</tt>
    //!   and additionally <tt>get() == nullptr</tt>
-   BOOST_MOVE_FORCEINLINE unique_ptr(BOOST_MOVE_DOC0PTR(bmupd::nullptr_type), BOOST_MOVE_SEEDOC(deleter_arg_type1) d1) BOOST_NOEXCEPT
+   inline unique_ptr(BOOST_MOVE_DOC0PTR(bmupd::nullptr_type), BOOST_MOVE_SEEDOC(deleter_arg_type1) d1) BOOST_NOEXCEPT
       : m_data(pointer(), d1)
    {}
 
@@ -498,7 +498,7 @@ class unique_ptr
    //!      - If T is not an array type and Pointer is implicitly convertible to pointer.
    //!      - If T is an array type and Pointer is a more CV qualified pointer to element_type.
    template<class Pointer>
-   BOOST_MOVE_FORCEINLINE unique_ptr(Pointer p, BOOST_MOVE_SEEDOC(deleter_arg_type2) d2
+   inline unique_ptr(Pointer p, BOOST_MOVE_SEEDOC(deleter_arg_type2) d2
       BOOST_MOVE_DOCIGN(BOOST_MOVE_I typename bmupd::enable_up_ptr<T BOOST_MOVE_I Pointer BOOST_MOVE_I pointer>::type* =0)
              ) BOOST_NOEXCEPT
       : m_data(p, ::boost::move(d2))
@@ -511,7 +511,7 @@ class unique_ptr
 
    //! <b>Effects</b>: Same effects as <tt>template<class Pointer> unique_ptr(Pointer p, deleter_arg_type2 d2)</tt>
    //!   and additionally <tt>get() == nullptr</tt>
-   BOOST_MOVE_FORCEINLINE unique_ptr(BOOST_MOVE_DOC0PTR(bmupd::nullptr_type), BOOST_MOVE_SEEDOC(deleter_arg_type2) d2) BOOST_NOEXCEPT
+   inline unique_ptr(BOOST_MOVE_DOC0PTR(bmupd::nullptr_type), BOOST_MOVE_SEEDOC(deleter_arg_type2) d2) BOOST_NOEXCEPT
       : m_data(pointer(), ::boost::move(d2))
    {}
 
@@ -525,7 +525,7 @@ class unique_ptr
    //! <b>Postconditions</b>: <tt>get()</tt> yields the value u.get() yielded before the construction. <tt>get_deleter()</tt>
    //! returns a reference to the stored deleter that was constructed from u.get_deleter(). If D is a
    //! reference type then <tt>get_deleter()</tt> and <tt>u.get_deleter()</tt> both reference the same lvalue deleter.
-   BOOST_MOVE_FORCEINLINE unique_ptr(BOOST_RV_REF(unique_ptr) u) BOOST_NOEXCEPT
+   inline unique_ptr(BOOST_RV_REF(unique_ptr) u) BOOST_NOEXCEPT
       : m_data(u.release(), ::boost::move_if_not_lvalue_reference<D>(u.get_deleter()))
    {}
 
@@ -545,7 +545,7 @@ class unique_ptr
    //! <b>Postconditions</b>: <tt>get()</tt> yields the value <tt>u.get()</tt> yielded before the construction. <tt>get_deleter()</tt>
    //!   returns a reference to the stored deleter that was constructed from <tt>u.get_deleter()</tt>.
    template <class U, class E>
-   BOOST_MOVE_FORCEINLINE unique_ptr( BOOST_RV_REF_BEG_IF_CXX11 unique_ptr<U, E> BOOST_RV_REF_END_IF_CXX11 u
+   inline unique_ptr( BOOST_RV_REF_BEG_IF_CXX11 unique_ptr<U, E> BOOST_RV_REF_END_IF_CXX11 u
       BOOST_MOVE_DOCIGN(BOOST_MOVE_I typename bmupd::enable_up_moveconv_constr<T BOOST_MOVE_I D BOOST_MOVE_I U BOOST_MOVE_I E>::type* =0)
       ) BOOST_NOEXCEPT
       : m_data(u.release(), ::boost::move_if_not_lvalue_reference<E>(u.get_deleter()))
@@ -628,7 +628,7 @@ class unique_ptr
    //! <b>Returns</b>: <tt>get()[i]</tt>.
    //!
    //! <b>Remarks</b: If T is not an array type, the program is ill-formed.
-   BOOST_MOVE_FORCEINLINE BOOST_MOVE_DOC1ST(element_type&, typename bmupmu::add_lvalue_reference<element_type>::type)
+   inline BOOST_MOVE_DOC1ST(element_type&, typename bmupmu::add_lvalue_reference<element_type>::type)
       operator[](std::size_t i) const BOOST_NOEXCEPT
    {
       assert( bmupmu::extent<T>::value == 0 || i < bmupmu::extent<T>::value );
@@ -643,7 +643,7 @@ class unique_ptr
    //! <b>Note</b>: use typically requires that T be a complete type.
    //!
    //! <b>Remarks</b: If T is an array type, the program is ill-formed.
-   BOOST_MOVE_FORCEINLINE pointer operator->() const BOOST_NOEXCEPT
+   inline pointer operator->() const BOOST_NOEXCEPT
    {
       BOOST_MOVE_STATIC_ASSERT((!bmupmu::is_array<T>::value));
       assert(m_data.m_p);
@@ -652,27 +652,27 @@ class unique_ptr
 
    //! <b>Returns</b>: The stored pointer.
    //!
-   BOOST_MOVE_FORCEINLINE pointer get() const BOOST_NOEXCEPT
+   inline pointer get() const BOOST_NOEXCEPT
    {  return m_data.m_p;  }
 
    //! <b>Returns</b>: A reference to the stored deleter.
    //!
-   BOOST_MOVE_FORCEINLINE BOOST_MOVE_DOC1ST(D&, typename bmupmu::add_lvalue_reference<D>::type)
+   inline BOOST_MOVE_DOC1ST(D&, typename bmupmu::add_lvalue_reference<D>::type)
       get_deleter() BOOST_NOEXCEPT
    {  return m_data.deleter();  }   
 
    //! <b>Returns</b>: A reference to the stored deleter.
    //!
-   BOOST_MOVE_FORCEINLINE BOOST_MOVE_DOC1ST(const D&, typename bmupmu::add_const_lvalue_reference<D>::type)
+   inline BOOST_MOVE_DOC1ST(const D&, typename bmupmu::add_const_lvalue_reference<D>::type)
       get_deleter() const BOOST_NOEXCEPT
    {  return m_data.deleter();  }
 
    #ifdef BOOST_MOVE_DOXYGEN_INVOKED
    //! <b>Returns</b>: Returns: get() != nullptr.
    //!
-   BOOST_MOVE_FORCEINLINE explicit operator bool
+   inline explicit operator bool
    #else
-   BOOST_MOVE_FORCEINLINE operator bmupd::explicit_bool_arg
+   inline operator bmupd::explicit_bool_arg
    #endif
       ()const BOOST_NOEXCEPT
    {
@@ -684,7 +684,7 @@ class unique_ptr
    //! <b>Postcondition</b>: <tt>get() == nullptr</tt>.
    //!
    //! <b>Returns</b>: The value <tt>get()</tt> had at the start of the call to release.   
-   BOOST_MOVE_FORCEINLINE pointer release() BOOST_NOEXCEPT
+   inline pointer release() BOOST_NOEXCEPT
    {
       const pointer tmp = m_data.m_p;
       m_data.m_p = pointer();
@@ -747,19 +747,19 @@ class unique_ptr
 //! <b>Effects</b>: Calls <tt>x.swap(y)</tt>.
 //!
 template <class T, class D>
-BOOST_MOVE_FORCEINLINE void swap(unique_ptr<T, D> &x, unique_ptr<T, D> &y) BOOST_NOEXCEPT
+inline void swap(unique_ptr<T, D> &x, unique_ptr<T, D> &y) BOOST_NOEXCEPT
 {  x.swap(y); }
 
 //! <b>Returns</b>: <tt>x.get() == y.get()</tt>.
 //!
 template <class T1, class D1, class T2, class D2>
-BOOST_MOVE_FORCEINLINE bool operator==(const unique_ptr<T1, D1> &x, const unique_ptr<T2, D2> &y)
+inline bool operator==(const unique_ptr<T1, D1> &x, const unique_ptr<T2, D2> &y)
 {  return x.get() == y.get(); }
 
 //! <b>Returns</b>: <tt>x.get() != y.get()</tt>.
 //!
 template <class T1, class D1, class T2, class D2>
-BOOST_MOVE_FORCEINLINE bool operator!=(const unique_ptr<T1, D1> &x, const unique_ptr<T2, D2> &y)
+inline bool operator!=(const unique_ptr<T1, D1> &x, const unique_ptr<T2, D2> &y)
 {  return x.get() != y.get(); }
 
 //! <b>Returns</b>: x.get() < y.get().
@@ -767,99 +767,99 @@ BOOST_MOVE_FORCEINLINE bool operator!=(const unique_ptr<T1, D1> &x, const unique
 //! <b>Remarks</b>: This comparison shall induce a
 //!   strict weak ordering betwen pointers.
 template <class T1, class D1, class T2, class D2>
-BOOST_MOVE_FORCEINLINE bool operator<(const unique_ptr<T1, D1> &x, const unique_ptr<T2, D2> &y)
+inline bool operator<(const unique_ptr<T1, D1> &x, const unique_ptr<T2, D2> &y)
 {  return x.get() < y.get();  }
 
 //! <b>Returns</b>: !(y < x).
 //!
 template <class T1, class D1, class T2, class D2>
-BOOST_MOVE_FORCEINLINE bool operator<=(const unique_ptr<T1, D1> &x, const unique_ptr<T2, D2> &y)
+inline bool operator<=(const unique_ptr<T1, D1> &x, const unique_ptr<T2, D2> &y)
 {  return !(y < x);  }
 
 //! <b>Returns</b>: y < x.
 //!
 template <class T1, class D1, class T2, class D2>
-BOOST_MOVE_FORCEINLINE bool operator>(const unique_ptr<T1, D1> &x, const unique_ptr<T2, D2> &y)
+inline bool operator>(const unique_ptr<T1, D1> &x, const unique_ptr<T2, D2> &y)
 {  return y < x;  }
 
 //! <b>Returns</b>:!(x < y).
 //!
 template <class T1, class D1, class T2, class D2>
-BOOST_MOVE_FORCEINLINE bool operator>=(const unique_ptr<T1, D1> &x, const unique_ptr<T2, D2> &y)
+inline bool operator>=(const unique_ptr<T1, D1> &x, const unique_ptr<T2, D2> &y)
 {  return !(x < y);  }
 
 //! <b>Returns</b>:!x.
 //!
 template <class T, class D>
-BOOST_MOVE_FORCEINLINE bool operator==(const unique_ptr<T, D> &x, BOOST_MOVE_DOC0PTR(bmupd::nullptr_type)) BOOST_NOEXCEPT
+inline bool operator==(const unique_ptr<T, D> &x, BOOST_MOVE_DOC0PTR(bmupd::nullptr_type)) BOOST_NOEXCEPT
 {  return !x;  }
 
 //! <b>Returns</b>:!x.
 //!
 template <class T, class D>
-BOOST_MOVE_FORCEINLINE bool operator==(BOOST_MOVE_DOC0PTR(bmupd::nullptr_type), const unique_ptr<T, D> &x) BOOST_NOEXCEPT
+inline bool operator==(BOOST_MOVE_DOC0PTR(bmupd::nullptr_type), const unique_ptr<T, D> &x) BOOST_NOEXCEPT
 {  return !x;  }
 
 //! <b>Returns</b>: (bool)x.
 //!
 template <class T, class D>
-BOOST_MOVE_FORCEINLINE bool operator!=(const unique_ptr<T, D> &x, BOOST_MOVE_DOC0PTR(bmupd::nullptr_type)) BOOST_NOEXCEPT
+inline bool operator!=(const unique_ptr<T, D> &x, BOOST_MOVE_DOC0PTR(bmupd::nullptr_type)) BOOST_NOEXCEPT
 {  return !!x;  }
 
 //! <b>Returns</b>: (bool)x.
 //!
 template <class T, class D>
-BOOST_MOVE_FORCEINLINE bool operator!=(BOOST_MOVE_DOC0PTR(bmupd::nullptr_type), const unique_ptr<T, D> &x) BOOST_NOEXCEPT
+inline bool operator!=(BOOST_MOVE_DOC0PTR(bmupd::nullptr_type), const unique_ptr<T, D> &x) BOOST_NOEXCEPT
 {  return !!x;  }
 
 //! <b>Requires</b>: <tt>operator </tt> shall induce a strict weak ordering on unique_ptr<T, D>::pointer values.
 //!
 //! <b>Returns</b>: Returns <tt>x.get() < pointer()</tt>.
 template <class T, class D>
-BOOST_MOVE_FORCEINLINE bool operator<(const unique_ptr<T, D> &x, BOOST_MOVE_DOC0PTR(bmupd::nullptr_type))
+inline bool operator<(const unique_ptr<T, D> &x, BOOST_MOVE_DOC0PTR(bmupd::nullptr_type))
 {  return x.get() < typename unique_ptr<T, D>::pointer();  }
 
 //! <b>Requires</b>: <tt>operator </tt> shall induce a strict weak ordering on unique_ptr<T, D>::pointer values.
 //!
 //! <b>Returns</b>: Returns <tt>pointer() < x.get()</tt>.
 template <class T, class D>
-BOOST_MOVE_FORCEINLINE bool operator<(BOOST_MOVE_DOC0PTR(bmupd::nullptr_type), const unique_ptr<T, D> &x)
+inline bool operator<(BOOST_MOVE_DOC0PTR(bmupd::nullptr_type), const unique_ptr<T, D> &x)
 {  return typename unique_ptr<T, D>::pointer() < x.get();  }
 
 //! <b>Returns</b>: <tt>nullptr < x</tt>.
 //!
 template <class T, class D>
-BOOST_MOVE_FORCEINLINE bool operator>(const unique_ptr<T, D> &x, BOOST_MOVE_DOC0PTR(bmupd::nullptr_type))
+inline bool operator>(const unique_ptr<T, D> &x, BOOST_MOVE_DOC0PTR(bmupd::nullptr_type))
 {  return x.get() > typename unique_ptr<T, D>::pointer();  }
 
 //! <b>Returns</b>: <tt>x < nullptr</tt>.
 //!
 template <class T, class D>
-BOOST_MOVE_FORCEINLINE bool operator>(BOOST_MOVE_DOC0PTR(bmupd::nullptr_type), const unique_ptr<T, D> &x)
+inline bool operator>(BOOST_MOVE_DOC0PTR(bmupd::nullptr_type), const unique_ptr<T, D> &x)
 {  return typename unique_ptr<T, D>::pointer() > x.get();  }
 
 //! <b>Returns</b>: <tt>!(nullptr < x)</tt>.
 //!
 template <class T, class D>
-BOOST_MOVE_FORCEINLINE bool operator<=(const unique_ptr<T, D> &x, BOOST_MOVE_DOC0PTR(bmupd::nullptr_type))
+inline bool operator<=(const unique_ptr<T, D> &x, BOOST_MOVE_DOC0PTR(bmupd::nullptr_type))
 {  return !(bmupd::nullptr_type() < x);  }
 
 //! <b>Returns</b>: <tt>!(x < nullptr)</tt>.
 //!
 template <class T, class D>
-BOOST_MOVE_FORCEINLINE bool operator<=(BOOST_MOVE_DOC0PTR(bmupd::nullptr_type), const unique_ptr<T, D> &x)
+inline bool operator<=(BOOST_MOVE_DOC0PTR(bmupd::nullptr_type), const unique_ptr<T, D> &x)
 {  return !(x < bmupd::nullptr_type());  }
 
 //! <b>Returns</b>: <tt>!(x < nullptr)</tt>.
 //!
 template <class T, class D>
-BOOST_MOVE_FORCEINLINE bool operator>=(const unique_ptr<T, D> &x, BOOST_MOVE_DOC0PTR(bmupd::nullptr_type))
+inline bool operator>=(const unique_ptr<T, D> &x, BOOST_MOVE_DOC0PTR(bmupd::nullptr_type))
 {  return !(x < bmupd::nullptr_type());  }
 
 //! <b>Returns</b>: <tt>!(nullptr < x)</tt>.
 //!
 template <class T, class D>
-BOOST_MOVE_FORCEINLINE bool operator>=(BOOST_MOVE_DOC0PTR(bmupd::nullptr_type), const unique_ptr<T, D> &x)
+inline bool operator>=(BOOST_MOVE_DOC0PTR(bmupd::nullptr_type), const unique_ptr<T, D> &x)
 {  return !(bmupd::nullptr_type() < x);  }
 
 }  //namespace movelib {

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

@@ -26,6 +26,11 @@
 #include <type_traits>
 #include <utility>
 
+#if defined(_MSC_VER) || defined(__GNUC__)
+# pragma push_macro( "I" )
+# undef I
+#endif
+
 namespace boost
 {
 namespace mp11
@@ -84,6 +89,25 @@ template<template<class...> class F, template<class...> class L1, class... T1, t
 #endif
 };
 
+#if defined(BOOST_MP11_HAS_TEMPLATE_AUTO)
+
+template<template<class...> class F, template<auto...> class L, auto... A> struct mp_transform_impl<F, L<A...>>
+{
+    using type = L< F< mp_value<A> >::value... >;
+};
+
+template<template<class...> class F, template<auto...> class L1, auto... A1, template<auto...> class L2, auto... A2> struct mp_transform_impl<F, L1<A1...>, L2<A2...>>
+{
+    using type = L1< F< mp_value<A1>, mp_value<A2> >::value... >;
+};
+
+template<template<class...> class F, template<auto...> class L1, auto... A1, template<auto...> class L2, auto... A2, template<auto...> class L3, auto... A3> struct mp_transform_impl<F, L1<A1...>, L2<A2...>, L3<A3...>>
+{
+    using type = L1< F< mp_value<A1>, mp_value<A2>, mp_value<A3> >::value... >;
+};
+
+#endif
+
 #if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, == 1900 ) || BOOST_MP11_WORKAROUND( BOOST_MP11_GCC, < 40800 )
 
 template<class... L> using mp_same_size_1 = mp_same<mp_size<L>...>;
@@ -473,6 +497,10 @@ struct mp_take_c_impl<N, L<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T...>, typen
 template<class L, std::size_t N> using mp_take_c = mp_assign<L, typename detail::mp_take_c_impl<N, mp_rename<L, mp_list>>::type>;
 template<class L, class N> using mp_take = mp_take_c<L, std::size_t{ N::value }>;
 
+// mp_slice(_c)<L, I, J>
+template<class L, std::size_t I, std::size_t J> using mp_slice_c = mp_drop_c< mp_take_c<L, J>, I >;
+template<class L, class I, class J> using mp_slice = mp_drop< mp_take<L, J>, I >;
+
 // mp_back<L>
 template<class L> using mp_back = mp_at_c<L, mp_size<L>::value - 1>;
 
@@ -1261,6 +1289,33 @@ template<class L, class Q> using mp_pairwise_fold_impl = mp_transform_q<Q, mp_po
 template<class L, class Q> using mp_pairwise_fold_q = mp_eval_if<mp_empty<L>, mp_clear<L>, detail::mp_pairwise_fold_impl, L, Q>;
 template<class L, template<class...> class F> using mp_pairwise_fold = mp_pairwise_fold_q<L, mp_quote<F>>;
 
+// mp_sliding_fold<L, N, F>
+namespace detail
+{
+
+template<class C, class L, class Q, class S> struct mp_sliding_fold_impl;
+
+template<class L, class N, class Q> struct mp_sliding_fold_impl<mp_true, L, N, Q>
+{
+    static const std::size_t M = mp_size<L>::value - N::value + 1;
+
+    template<class I> using F = mp_slice_c<L, I::value, I::value + M>;
+
+    using J = mp_transform<F, mp_iota<N>>;
+
+    using type = mp_apply<mp_transform_q, mp_push_front<J, Q>>;
+};
+
+template<class L, class N, class Q> struct mp_sliding_fold_impl<mp_false, L, N, Q>
+{
+    using type = mp_clear<L>;
+};
+
+} // namespace detail
+
+template<class L, class N, class Q> using mp_sliding_fold_q = typename detail::mp_sliding_fold_impl<mp_bool<(mp_size<L>::value >= N::value)>, L, N, Q>::type;
+template<class L, class N, template<class...> class F> using mp_sliding_fold = mp_sliding_fold_q<L, N, mp_quote<F>>;
+
 // mp_intersperse<L, S>
 namespace detail
 {
@@ -1324,4 +1379,8 @@ template<class L, class S> using mp_join = mp_apply<mp_append, mp_intersperse<L,
 } // namespace mp11
 } // namespace boost
 
+#if defined(_MSC_VER) || defined(__GNUC__)
+# pragma pop_macro( "I" )
+#endif
+
 #endif // #ifndef BOOST_MP11_ALGORITHM_HPP_INCLUDED

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

@@ -12,6 +12,11 @@
 #include <boost/mp11/utility.hpp>
 #include <cstddef>
 
+#if defined(_MSC_VER) || defined(__GNUC__)
+# pragma push_macro( "I" )
+# undef I
+#endif
+
 namespace boost
 {
 namespace mp11
@@ -108,4 +113,8 @@ template<class Q, class... T> using mp_bind_q = mp_bind<Q::template fn, T...>;
 } // namespace mp11
 } // namespace boost
 
+#if defined(_MSC_VER) || defined(__GNUC__)
+# pragma pop_macro( "I" )
+#endif
+
 #endif // #ifndef BOOST_MP11_BIND_HPP_INCLUDED

data/src/cxx_supportlib/vendor-modified/boost/mp11/detail/mp_fold.hpp

@@ -10,6 +10,8 @@
 
 #include <boost/mp11/detail/config.hpp>
 #include <boost/mp11/detail/mp_defer.hpp>
+#include <boost/mp11/detail/mp_rename.hpp>
+#include <boost/mp11/detail/mp_list.hpp>
 
 namespace boost
 {
@@ -155,7 +157,7 @@ struct mp_fold_impl<L<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T...>, V, F>
 
 } // namespace detail
 
-template<class L, class V, template<class...> class F> using mp_fold = typename detail::mp_fold_impl<L, V, F>::type;
+template<class L, class V, template<class...> class F> using mp_fold = typename detail::mp_fold_impl<mp_rename<L, mp_list>, V, F>::type;
 template<class L, class V, class Q> using mp_fold_q = mp_fold<L, V, Q::template fn>;
 
 } // namespace mp11

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

@@ -11,6 +11,11 @@
 #include <boost/mp11/version.hpp>
 #include <cstddef>
 
+#if defined(_MSC_VER) || defined(__GNUC__)
+# pragma push_macro( "I" )
+# undef I
+#endif
+
 #if defined(__has_builtin)
 # if __has_builtin(__make_integer_seq)
 #  define BOOST_MP11_HAS_MAKE_INTEGER_SEQ
@@ -109,4 +114,8 @@ template<class... T> using index_sequence_for = make_integer_sequence<std::size_
 } // namespace mp11
 } // namespace boost
 
+#if defined(_MSC_VER) || defined(__GNUC__)
+# pragma pop_macro( "I" )
+#endif
+
 #endif // #ifndef BOOST_MP11_INTEGER_SEQUENCE_HPP_INCLUDED

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

@@ -13,6 +13,11 @@
 #include <type_traits>
 #include <cstddef>
 
+#if defined(_MSC_VER) || defined(__GNUC__)
+# pragma push_macro( "I" )
+# undef I
+#endif
+
 namespace boost
 {
 namespace mp11
@@ -39,4 +44,8 @@ template<std::size_t N> using mp_size_t = std::integral_constant<std::size_t, N>
 } // namespace mp11
 } // namespace boost
 
+#if defined(_MSC_VER) || defined(__GNUC__)
+# pragma pop_macro( "I" )
+#endif
+
 #endif // #ifndef BOOST_MP11_INTEGRAL_HPP_INCLUDED