passenger 6.0.20 → 6.0.22

data/src/cxx_supportlib/vendor-modified/boost/intrusive/detail/parent_from_member.hpp

@@ -26,8 +26,7 @@
 
 #if defined(_MSC_VER)
    #define BOOST_INTRUSIVE_MSVC_ABI_PTR_TO_MEMBER
-   #include <boost/static_assert.hpp>
-#endif
+   #endif
 
 namespace boost {
 namespace intrusive {
@@ -49,7 +48,7 @@ BOOST_INTRUSIVE_FORCEINLINE std::ptrdiff_t offset_from_pointer_to_member(const M
    //MSVC ABI can use up to 3 int32 to represent pointer to member data
    //with virtual base classes, in those cases there is no simple to
    //obtain the address of the parent. So static assert to avoid runtime errors
-   BOOST_STATIC_ASSERT( sizeof(caster) == sizeof(int) );
+   BOOST_INTRUSIVE_STATIC_ASSERT( sizeof(caster) == sizeof(int) );
 
    caster.ptr_to_member = ptr_to_member;
    return std::ptrdiff_t(caster.offset);
@@ -91,25 +90,15 @@ BOOST_INTRUSIVE_FORCEINLINE std::ptrdiff_t offset_from_pointer_to_member(const M
 template<class Parent, class Member>
 BOOST_INTRUSIVE_FORCEINLINE Parent *parent_from_member(Member *member, const Member Parent::* ptr_to_member)
 {
-   return static_cast<Parent*>
-      (
-         static_cast<void*>
-         (
-            static_cast<char*>(static_cast<void*>(member)) - offset_from_pointer_to_member(ptr_to_member)
-         )
-      );
+   return reinterpret_cast<Parent*>
+      (reinterpret_cast<std::size_t>(member) - static_cast<std::size_t>(offset_from_pointer_to_member(ptr_to_member)));
 }
 
 template<class Parent, class Member>
 BOOST_INTRUSIVE_FORCEINLINE const Parent *parent_from_member(const Member *member, const Member Parent::* ptr_to_member)
 {
-   return static_cast<const Parent*>
-      (
-         static_cast<const void*>
-         (
-            static_cast<const char*>(static_cast<const void*>(member)) - offset_from_pointer_to_member(ptr_to_member)
-         )
-      );
+   return reinterpret_cast<const Parent*>
+      ( reinterpret_cast<std::size_t>(member) - static_cast<std::size_t>(offset_from_pointer_to_member(ptr_to_member)) );
 }
 
 }  //namespace detail {

data/src/cxx_supportlib/vendor-modified/boost/intrusive/detail/simple_disposers.hpp

@@ -41,7 +41,7 @@ class init_disposer
    typedef typename NodeAlgorithms::node_ptr node_ptr;
 
    public:
-   BOOST_INTRUSIVE_FORCEINLINE void operator()(node_ptr p)
+   inline void operator()(node_ptr p)
    {  NodeAlgorithms::init(p);   }
 };
 

data/src/cxx_supportlib/vendor-modified/boost/intrusive/detail/size_holder.hpp

@@ -33,25 +33,25 @@ struct size_holder
    static const bool constant_time_size = ConstantSize;
    typedef SizeType  size_type;
 
-   BOOST_INTRUSIVE_FORCEINLINE SizeType get_size() const
+   inline SizeType get_size() const
    {  return size_;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE void set_size(SizeType size)
+   inline void set_size(SizeType size)
    {  size_ = size; }
 
-   BOOST_INTRUSIVE_FORCEINLINE void decrement()
+   inline void decrement()
    {  --size_; }
 
-   BOOST_INTRUSIVE_FORCEINLINE void increment()
+   inline void increment()
    {  ++size_; }
 
-   BOOST_INTRUSIVE_FORCEINLINE void increase(SizeType n)
+   inline void increase(SizeType n)
    {  size_ += n; }
 
-   BOOST_INTRUSIVE_FORCEINLINE void decrease(SizeType n)
+   inline void decrease(SizeType n)
    {  size_ -= n; }
 
-   BOOST_INTRUSIVE_FORCEINLINE void swap(size_holder &other)
+   inline void swap(size_holder &other)
    {  SizeType tmp(size_); size_ = other.size_; other.size_ = tmp; }
 
    SizeType size_;
@@ -63,25 +63,25 @@ struct size_holder<false, SizeType, Tag>
    static const bool constant_time_size = false;
    typedef SizeType  size_type;
 
-   BOOST_INTRUSIVE_FORCEINLINE size_type get_size() const
+   inline size_type get_size() const
    {  return 0;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE void set_size(size_type)
+   inline void set_size(size_type)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE void decrement()
+   inline void decrement()
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE void increment()
+   inline void increment()
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE void increase(SizeType)
+   inline void increase(SizeType)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE void decrease(SizeType)
+   inline void decrease(SizeType)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE void swap(size_holder){}
+   inline void swap(size_holder){}
 };
 
 }  //namespace detail{

data/src/cxx_supportlib/vendor-modified/boost/intrusive/detail/slist_iterator.hpp

@@ -27,7 +27,6 @@
 #include <boost/intrusive/detail/std_fwd.hpp>
 #include <boost/intrusive/detail/iiterator.hpp>
 #include <boost/intrusive/detail/mpl.hpp>
-#include <boost/static_assert.hpp>
 
 namespace boost {
 namespace intrusive {
@@ -63,75 +62,75 @@ class slist_iterator
    typedef typename types_t::iterator_type::reference          reference;
    typedef typename types_t::iterator_type::iterator_category  iterator_category;
 
-   BOOST_INTRUSIVE_FORCEINLINE slist_iterator()
+   inline slist_iterator()
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE slist_iterator(node_ptr nodeptr, const_value_traits_ptr traits_ptr)
+   inline slist_iterator(node_ptr nodeptr, const_value_traits_ptr traits_ptr)
       : members_(nodeptr, traits_ptr)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE explicit slist_iterator(node_ptr nodeptr)
+   inline explicit slist_iterator(node_ptr nodeptr)
       : members_(nodeptr, const_value_traits_ptr())
-   {  BOOST_STATIC_ASSERT((stateful_value_traits == false));  }
+   {  BOOST_INTRUSIVE_STATIC_ASSERT((stateful_value_traits == false));  }
 
-   BOOST_INTRUSIVE_FORCEINLINE slist_iterator(const slist_iterator &other)
+   inline slist_iterator(const slist_iterator &other)
       :  members_(other.pointed_node(), other.get_value_traits())
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE slist_iterator(const nonconst_iterator &other)
+   inline slist_iterator(const nonconst_iterator &other)
       :  members_(other.pointed_node(), other.get_value_traits())
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE slist_iterator &operator=(const slist_iterator &other)
+   inline slist_iterator &operator=(const slist_iterator &other)
    {  members_.nodeptr_ = other.members_.nodeptr_;  return *this;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE node_ptr pointed_node() const
+   inline node_ptr pointed_node() const
    { return members_.nodeptr_; }
 
-   BOOST_INTRUSIVE_FORCEINLINE slist_iterator &operator=(node_ptr n)
+   inline slist_iterator &operator=(node_ptr n)
    {  members_.nodeptr_ = n;  return static_cast<slist_iterator&>(*this);  }
 
-   BOOST_INTRUSIVE_FORCEINLINE const_value_traits_ptr get_value_traits() const
+   inline const_value_traits_ptr get_value_traits() const
    {  return members_.get_ptr(); }
 
-   BOOST_INTRUSIVE_FORCEINLINE bool operator!() const
+   inline bool operator!() const
    {  return !members_.nodeptr_; }
 
    public:
-   BOOST_INTRUSIVE_FORCEINLINE slist_iterator& operator++()
+   inline slist_iterator& operator++()
    {
       members_.nodeptr_ = node_traits::get_next(members_.nodeptr_);
       return static_cast<slist_iterator&> (*this);
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE slist_iterator operator++(int)
+   inline slist_iterator operator++(int)
    {
       slist_iterator result (*this);
       members_.nodeptr_ = node_traits::get_next(members_.nodeptr_);
       return result;
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE friend bool operator== (const slist_iterator& l, const slist_iterator& r)
+   inline friend bool operator== (const slist_iterator& l, const slist_iterator& r)
    {  return l.pointed_node() == r.pointed_node();   }
 
-   BOOST_INTRUSIVE_FORCEINLINE friend bool operator!= (const slist_iterator& l, const slist_iterator& r)
+   inline friend bool operator!= (const slist_iterator& l, const slist_iterator& r)
    {  return l.pointed_node() != r.pointed_node();   }
 
-   BOOST_INTRUSIVE_FORCEINLINE reference operator*() const
+   inline reference operator*() const
    {  return *operator->();   }
 
-   BOOST_INTRUSIVE_FORCEINLINE pointer operator->() const
+   inline pointer operator->() const
    { return this->operator_arrow(detail::bool_<stateful_value_traits>()); }
 
-   BOOST_INTRUSIVE_FORCEINLINE slist_iterator<ValueTraits, false> unconst() const
+   inline slist_iterator<ValueTraits, false> unconst() const
    {  return slist_iterator<ValueTraits, false>(this->pointed_node(), this->get_value_traits());   }
 
    private:
 
-   BOOST_INTRUSIVE_FORCEINLINE pointer operator_arrow(detail::false_) const
+   inline pointer operator_arrow(detail::false_) const
    { return ValueTraits::to_value_ptr(members_.nodeptr_); }
 
-   BOOST_INTRUSIVE_FORCEINLINE pointer operator_arrow(detail::true_) const
+   inline pointer operator_arrow(detail::true_) const
    { return this->get_value_traits()->to_value_ptr(members_.nodeptr_); }
 
    iiterator_members<node_ptr, const_value_traits_ptr, stateful_value_traits> members_;

data/src/cxx_supportlib/vendor-modified/boost/intrusive/detail/transform_iterator.hpp

@@ -33,11 +33,11 @@ namespace detail {
 template <class PseudoReference>
 struct operator_arrow_proxy
 {
-   BOOST_INTRUSIVE_FORCEINLINE operator_arrow_proxy(const PseudoReference &px)
+   inline operator_arrow_proxy(const PseudoReference &px)
       :  m_value(px)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE PseudoReference* operator->() const { return &m_value; }
+   inline PseudoReference* operator->() const { return &m_value; }
    // This function is needed for MWCW and BCC, which won't call operator->
    // again automatically per 13.3.1.2 para 8
 //   operator T*() const { return &m_value; }
@@ -47,11 +47,11 @@ struct operator_arrow_proxy
 template <class T>
 struct operator_arrow_proxy<T&>
 {
-   BOOST_INTRUSIVE_FORCEINLINE operator_arrow_proxy(T &px)
+   inline operator_arrow_proxy(T &px)
       :  m_value(px)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE T* operator->() const { return &m_value; }
+   inline T* operator->() const { return &m_value; }
    // This function is needed for MWCW and BCC, which won't call operator->
    // again automatically per 13.3.1.2 para 8
 //   operator T*() const { return &m_value; }
@@ -76,53 +76,53 @@ class transform_iterator
       :  members_()
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE Iterator get_it() const
+   inline Iterator get_it() const
    {  return members_.m_it;   }
 
    //Constructors
-   BOOST_INTRUSIVE_FORCEINLINE transform_iterator& operator++()
+   inline transform_iterator& operator++()
    { increment();   return *this;   }
 
-   BOOST_INTRUSIVE_FORCEINLINE transform_iterator operator++(int)
+   inline transform_iterator operator++(int)
    {
       transform_iterator result (*this);
       increment();
       return result;
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE friend bool operator== (const transform_iterator& i, const transform_iterator& i2)
+   inline friend bool operator== (const transform_iterator& i, const transform_iterator& i2)
    { return i.equal(i2); }
 
-   BOOST_INTRUSIVE_FORCEINLINE friend bool operator!= (const transform_iterator& i, const transform_iterator& i2)
+   inline friend bool operator!= (const transform_iterator& i, const transform_iterator& i2)
    { return !(i == i2); }
 
-   BOOST_INTRUSIVE_FORCEINLINE friend typename Iterator::difference_type operator- (const transform_iterator& i, const transform_iterator& i2)
+   inline friend typename Iterator::difference_type operator- (const transform_iterator& i, const transform_iterator& i2)
    { return i2.distance_to(i); }
 
    //Arithmetic
    transform_iterator& operator+=(typename Iterator::difference_type off)
    {  this->advance(off); return *this;   }
 
-   BOOST_INTRUSIVE_FORCEINLINE transform_iterator operator+(typename Iterator::difference_type off) const
+   inline transform_iterator operator+(typename Iterator::difference_type off) const
    {
       transform_iterator other(*this);
       other.advance(off);
       return other;
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE friend transform_iterator operator+(typename Iterator::difference_type off, const transform_iterator& right)
+   inline friend transform_iterator operator+(typename Iterator::difference_type off, const transform_iterator& right)
    {  return right + off; }
 
-   BOOST_INTRUSIVE_FORCEINLINE transform_iterator& operator-=(typename Iterator::difference_type off)
+   inline transform_iterator& operator-=(typename Iterator::difference_type off)
    {  this->advance(-off); return *this;   }
 
-   BOOST_INTRUSIVE_FORCEINLINE transform_iterator operator-(typename Iterator::difference_type off) const
+   inline transform_iterator operator-(typename Iterator::difference_type off) const
    {  return *this + (-off);  }
 
-   BOOST_INTRUSIVE_FORCEINLINE typename UnaryFunction::result_type operator*() const
+   inline typename UnaryFunction::result_type operator*() const
    { return dereference(); }
 
-   BOOST_INTRUSIVE_FORCEINLINE operator_arrow_proxy<typename UnaryFunction::result_type>
+   inline operator_arrow_proxy<typename UnaryFunction::result_type>
       operator->() const
    { return operator_arrow_proxy<typename UnaryFunction::result_type>(dereference());  }
 
@@ -130,27 +130,27 @@ class transform_iterator
    struct members
       :  UnaryFunction
    {
-      BOOST_INTRUSIVE_FORCEINLINE members(const Iterator &it, const UnaryFunction &f)
+      inline members(const Iterator &it, const UnaryFunction &f)
          :  UnaryFunction(f), m_it(it)
       {}
 
-      BOOST_INTRUSIVE_FORCEINLINE members()
+      inline members()
       {}
 
       Iterator m_it;
    } members_;
 
 
-   BOOST_INTRUSIVE_FORCEINLINE void increment()
+   inline void increment()
    { ++members_.m_it; }
 
-   BOOST_INTRUSIVE_FORCEINLINE void decrement()
+   inline void decrement()
    { --members_.m_it; }
 
-   BOOST_INTRUSIVE_FORCEINLINE bool equal(const transform_iterator &other) const
+   inline bool equal(const transform_iterator &other) const
    {  return members_.m_it == other.members_.m_it;   }
 
-   BOOST_INTRUSIVE_FORCEINLINE bool less(const transform_iterator &other) const
+   inline bool less(const transform_iterator &other) const
    {  return other.members_.m_it < members_.m_it;   }
 
    typename UnaryFunction::result_type dereference() const

data/src/cxx_supportlib/vendor-modified/boost/intrusive/detail/tree_iterator.hpp

@@ -68,32 +68,32 @@ class tree_iterator
    typedef typename types_t::iterator_type::reference          reference;
    typedef typename types_t::iterator_type::iterator_category  iterator_category;
 
-   BOOST_INTRUSIVE_FORCEINLINE tree_iterator()
+   inline tree_iterator()
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE explicit tree_iterator(node_ptr nodeptr, const_value_traits_ptr traits_ptr)
+   inline explicit tree_iterator(node_ptr nodeptr, const_value_traits_ptr traits_ptr)
       : members_(nodeptr, traits_ptr)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE tree_iterator(const tree_iterator &other)
+   inline tree_iterator(const tree_iterator &other)
       :  members_(other.pointed_node(), other.get_value_traits())
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE tree_iterator(const nonconst_iterator &other)
+   inline tree_iterator(const nonconst_iterator &other)
       :  members_(other.pointed_node(), other.get_value_traits())
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE tree_iterator &operator=(const tree_iterator &other)
+   inline tree_iterator &operator=(const tree_iterator &other)
    {  members_.nodeptr_ = other.members_.nodeptr_;  return *this;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE tree_iterator &operator=(node_ptr nodeptr)
+   inline tree_iterator &operator=(node_ptr nodeptr)
    {  members_.nodeptr_ = nodeptr;  return *this;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE node_ptr pointed_node() const
+   inline node_ptr pointed_node() const
    { return members_.nodeptr_; }
 
    public:
-   BOOST_INTRUSIVE_FORCEINLINE tree_iterator& operator++()
+   inline tree_iterator& operator++()
    {
       members_.nodeptr_ = node_algorithms::next_node(members_.nodeptr_);
       return *this;
@@ -106,7 +106,7 @@ class tree_iterator
       return result;
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE tree_iterator& operator--()
+   inline tree_iterator& operator--()
    {
       members_.nodeptr_ = node_algorithms::prev_node(members_.nodeptr_);
       return *this;
@@ -119,43 +119,43 @@ class tree_iterator
       return result;
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE tree_iterator&  go_left()
+   inline tree_iterator&  go_left()
    {
       members_.nodeptr_ = node_traits::get_left(members_.nodeptr_);
       return *this;
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE tree_iterator&  go_right()
+   inline tree_iterator&  go_right()
    {
       members_.nodeptr_ = node_traits::get_right(members_.nodeptr_);
       return *this;
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE tree_iterator&  go_parent()
+   inline tree_iterator&  go_parent()
    {
       members_.nodeptr_ = node_traits::get_parent(members_.nodeptr_);
       return *this;
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE operator unspecified_bool_type() const
+   inline operator unspecified_bool_type() const
    {  return members_.nodeptr_ ? &tree_iterator::unspecified_bool_type_func : 0;   }
 
-   BOOST_INTRUSIVE_FORCEINLINE bool operator! () const
+   inline bool operator! () const
    {  return !members_.nodeptr_;   }
 
-   BOOST_INTRUSIVE_FORCEINLINE friend bool operator== (const tree_iterator& l, const tree_iterator& r)
+   inline friend bool operator== (const tree_iterator& l, const tree_iterator& r)
    { return l.pointed_node() == r.pointed_node(); }
 
-   BOOST_INTRUSIVE_FORCEINLINE friend bool operator!= (const tree_iterator& l, const tree_iterator& r)
+   inline friend bool operator!= (const tree_iterator& l, const tree_iterator& r)
    {  return !(l == r);   }
 
-   BOOST_INTRUSIVE_FORCEINLINE reference operator*() const
+   inline reference operator*() const
    {  return *operator->();   }
 
-   BOOST_INTRUSIVE_FORCEINLINE pointer operator->() const
+   inline pointer operator->() const
    { return this->operator_arrow(detail::bool_<stateful_value_traits>()); }
 
-   BOOST_INTRUSIVE_FORCEINLINE const_value_traits_ptr get_value_traits() const
+   inline const_value_traits_ptr get_value_traits() const
    {  return members_.get_ptr();  }
 
    tree_iterator end_iterator_from_it() const
@@ -167,10 +167,10 @@ class tree_iterator
    {  return tree_iterator<value_traits, false>(this->pointed_node(), this->get_value_traits());   }
 
    private:
-   BOOST_INTRUSIVE_FORCEINLINE pointer operator_arrow(detail::false_) const
+   inline pointer operator_arrow(detail::false_) const
    { return ValueTraits::to_value_ptr(members_.nodeptr_); }
 
-   BOOST_INTRUSIVE_FORCEINLINE pointer operator_arrow(detail::true_) const
+   inline pointer operator_arrow(detail::true_) const
    { return this->get_value_traits()->to_value_ptr(members_.nodeptr_); }
 
    iiterator_members<node_ptr, const_value_traits_ptr, stateful_value_traits> members_;

data/src/cxx_supportlib/vendor-modified/boost/intrusive/detail/tree_value_compare.hpp

@@ -59,67 +59,67 @@ struct tree_value_compare
 
    typedef boost::intrusive::detail::ebo_functor_holder<KeyCompare> base_t;
 
-   BOOST_INTRUSIVE_FORCEINLINE tree_value_compare()
+   inline tree_value_compare()
       :  base_t()
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE explicit tree_value_compare(const key_compare &kcomp)
+   inline explicit tree_value_compare(const key_compare &kcomp)
       :  base_t(kcomp)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE tree_value_compare (const tree_value_compare &x)
+   inline tree_value_compare (const tree_value_compare &x)
       :  base_t(x.base_t::get())
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE tree_value_compare &operator=(const tree_value_compare &x)
+   inline tree_value_compare &operator=(const tree_value_compare &x)
    {  this->base_t::get() = x.base_t::get();   return *this;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE tree_value_compare &operator=(const key_compare &x)
+   inline tree_value_compare &operator=(const key_compare &x)
    {  this->base_t::get() = x;   return *this;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE const key_compare &key_comp() const
+   inline const key_compare &key_comp() const
    {  return static_cast<const key_compare &>(*this);  }
 
-   BOOST_INTRUSIVE_FORCEINLINE Ret operator()(const key_type &key) const
+   inline Ret operator()(const key_type &key) const
    {  return this->key_comp()(key);   }
 
-   BOOST_INTRUSIVE_FORCEINLINE Ret operator()(const value_type &value) const
+   inline Ret operator()(const value_type &value) const
    {  return this->key_comp()(KeyOfValue()(value));  }
 
    template<class U>
-   BOOST_INTRUSIVE_FORCEINLINE Ret operator()( const U &nonkey
+   inline Ret operator()( const U &nonkey
                                              , typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const
    {  return this->key_comp()(nonkey);  }
 
-   BOOST_INTRUSIVE_FORCEINLINE Ret operator()(const key_type &key1, const key_type &key2) const
+   inline Ret operator()(const key_type &key1, const key_type &key2) const
    {  return this->key_comp()(key1, key2);  }
 
-   BOOST_INTRUSIVE_FORCEINLINE Ret operator()(const value_type &value1, const value_type &value2) const
+   inline Ret operator()(const value_type &value1, const value_type &value2) const
    {  return this->key_comp()(KeyOfValue()(value1), KeyOfValue()(value2));  }
 
-   BOOST_INTRUSIVE_FORCEINLINE Ret operator()(const key_type &key1, const value_type &value2) const
+   inline Ret operator()(const key_type &key1, const value_type &value2) const
    {  return this->key_comp()(key1, KeyOfValue()(value2));  }
 
-   BOOST_INTRUSIVE_FORCEINLINE Ret operator()(const value_type &value1, const key_type &key2) const
+   inline Ret operator()(const value_type &value1, const key_type &key2) const
    {  return this->key_comp()(KeyOfValue()(value1), key2);  }
 
    template<class U>
-   BOOST_INTRUSIVE_FORCEINLINE Ret operator()( const key_type &key1, const U &nonkey2
+   inline Ret operator()( const key_type &key1, const U &nonkey2
                                               , typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const
    {  return this->key_comp()(key1, nonkey2);  }
 
    template<class U>
-   BOOST_INTRUSIVE_FORCEINLINE Ret operator()( const U &nonkey1, const key_type &key2
+   inline Ret operator()( const U &nonkey1, const key_type &key2
                                               , typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const
    {  return this->key_comp()(nonkey1, key2);  }
 
    template<class U>
-   BOOST_INTRUSIVE_FORCEINLINE Ret operator()( const value_type &value1, const U &nonvalue2
+   inline Ret operator()( const value_type &value1, const U &nonvalue2
                                               , typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const
    {  return this->key_comp()(KeyOfValue()(value1), nonvalue2);  }
 
    template<class U>
-   BOOST_INTRUSIVE_FORCEINLINE Ret operator()( const U &nonvalue1, const value_type &value2
+   inline Ret operator()( const U &nonvalue1, const value_type &value2
                                               , typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const
    {  return this->key_comp()(nonvalue1, KeyOfValue()(value2));  }
 };
@@ -137,45 +137,45 @@ struct tree_value_compare<ValuePtr, KeyCompare, KeyOfValue, Ret, true>
    typedef boost::intrusive::detail::ebo_functor_holder<KeyCompare> base_t;
 
 
-   BOOST_INTRUSIVE_FORCEINLINE tree_value_compare()
+   inline tree_value_compare()
       :  base_t()
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE explicit tree_value_compare(const key_compare &kcomp)
+   inline explicit tree_value_compare(const key_compare &kcomp)
       :  base_t(kcomp)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE tree_value_compare (const tree_value_compare &x)
+   inline tree_value_compare (const tree_value_compare &x)
       :  base_t(x.base_t::get())
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE tree_value_compare &operator=(const tree_value_compare &x)
+   inline tree_value_compare &operator=(const tree_value_compare &x)
    {  this->base_t::get() = x.base_t::get();   return *this;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE tree_value_compare &operator=(const key_compare &x)
+   inline tree_value_compare &operator=(const key_compare &x)
    {  this->base_t::get() = x;   return *this;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE const key_compare &key_comp() const
+   inline const key_compare &key_comp() const
    {  return static_cast<const key_compare &>(*this);  }
 
-   BOOST_INTRUSIVE_FORCEINLINE Ret operator()(const key_type &key) const
+   inline Ret operator()(const key_type &key) const
    {  return this->key_comp()(key);   }
 
    template<class U>
-   BOOST_INTRUSIVE_FORCEINLINE Ret operator()( const U &nonkey
+   inline Ret operator()( const U &nonkey
                                              , typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const
    {  return this->key_comp()(nonkey);  }
 
-   BOOST_INTRUSIVE_FORCEINLINE Ret operator()(const key_type &key1, const key_type &key2) const
+   inline Ret operator()(const key_type &key1, const key_type &key2) const
    {  return this->key_comp()(key1, key2);  }
 
    template<class U>
-   BOOST_INTRUSIVE_FORCEINLINE Ret operator()( const key_type &key1, const U &nonkey2
+   inline Ret operator()( const key_type &key1, const U &nonkey2
                                               , typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const
    {  return this->key_comp()(key1, nonkey2);  }
 
    template<class U>
-   BOOST_INTRUSIVE_FORCEINLINE Ret operator()(const U &nonkey1, const key_type &key2
+   inline Ret operator()(const U &nonkey1, const key_type &key2
                                               , typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const
    {  return this->key_comp()(nonkey1, key2);  }
 };

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

@@ -48,8 +48,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_INTRUSIVE_FORCEINLINE inline
-#elif defined(BOOST_GCC) && ((__GNUC__ <= 5) || defined(__MINGW32__))
+#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_INTRUSIVE_FORCEINLINE inline
 #else
    #define BOOST_INTRUSIVE_FORCEINLINE BOOST_FORCEINLINE
@@ -81,4 +84,32 @@
 #    define BOOST_INTRUSIVE_CATCH_END }
 #endif
 
+#ifndef BOOST_NO_CXX11_STATIC_ASSERT
+#  ifndef BOOST_NO_CXX11_VARIADIC_MACROS
+#     define BOOST_INTRUSIVE_STATIC_ASSERT( ... ) static_assert(__VA_ARGS__, #__VA_ARGS__)
+#  else
+#     define BOOST_INTRUSIVE_STATIC_ASSERT( B ) static_assert(B, #B)
+#  endif
+#else
+namespace boost {
+namespace intrusive {
+namespace detail {
+
+template<bool B>
+struct STATIC_ASSERTION_FAILURE;
+
+template<>
+struct STATIC_ASSERTION_FAILURE<true>{};
+
+template<unsigned> struct static_assert_test {};
+
+}}}
+
+#define BOOST_INTRUSIVE_STATIC_ASSERT(B) \
+         typedef ::boost::intrusive::detail::static_assert_test<\
+            (unsigned)sizeof(::boost::intrusive::detail::STATIC_ASSERTION_FAILURE<bool(B)>)>\
+               BOOST_JOIN(boost_intrusive_static_assert_typedef_, __LINE__) BOOST_ATTRIBUTE_UNUSED
+
+#endif
+
 #endif   //#ifndef BOOST_INTRUSIVE_DETAIL_WORKAROUND_HPP