passenger 6.0.20 → 6.0.22

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

@@ -52,25 +52,25 @@ struct bucket_impl
    typedef detail::common_slist_algorithms<NodeTraits> algo_t;
 
    public:
-   BOOST_INTRUSIVE_FORCEINLINE bucket_impl()
+   inline bucket_impl()
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE bucket_impl(const bucket_impl &)
+   inline bucket_impl(const bucket_impl &)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE ~bucket_impl()
+   inline ~bucket_impl()
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE bucket_impl &operator=(const bucket_impl&)
+   inline bucket_impl &operator=(const bucket_impl&)
    {  return *this;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE node_ptr get_node_ptr()
+   inline node_ptr get_node_ptr()
    {  return pointer_traits<node_ptr>::pointer_to(*this);  }
 
-   BOOST_INTRUSIVE_FORCEINLINE const_node_ptr get_node_ptr() const
+   inline const_node_ptr get_node_ptr() const
    {  return pointer_traits<const_node_ptr>::pointer_to(*this);  }
 
-   BOOST_INTRUSIVE_FORCEINLINE node_ptr begin_ptr()
+   inline node_ptr begin_ptr()
    {  return node_traits::get_next(get_node_ptr());  }
 };
 
@@ -136,7 +136,7 @@ class hashtable_iterator
                   , hashtable_iterator<BucketValueTraits, LinearBuckets, false>
                   , nat>::type                                 nonconst_iterator;
 
-   BOOST_INTRUSIVE_FORCEINLINE static node_ptr downcast_bucket(typename bucket_type::node_traits::node_ptr p)
+   inline static node_ptr downcast_bucket(typename bucket_type::node_traits::node_ptr p)
    {
       return pointer_traits<node_ptr>::
          pointer_to(static_cast<typename node_traits::node&>(*p));
@@ -144,61 +144,61 @@ class hashtable_iterator
 
    public:
 
-   BOOST_INTRUSIVE_FORCEINLINE hashtable_iterator ()
+   inline hashtable_iterator ()
       : slist_it_()  //Value initialization to achieve "null iterators" (N3644)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE explicit hashtable_iterator(siterator ptr, const BucketValueTraits *cont)
+   inline explicit hashtable_iterator(siterator ptr, const BucketValueTraits *cont)
       : slist_it_ (ptr)
       , traitsptr_ (cont ? pointer_traits<const_bucketvaltraits_ptr>::pointer_to(*cont) : const_bucketvaltraits_ptr() )
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE hashtable_iterator(const hashtable_iterator &other)
+   inline hashtable_iterator(const hashtable_iterator &other)
       :  slist_it_(other.slist_it()), traitsptr_(other.get_bucket_value_traits())
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE hashtable_iterator(const nonconst_iterator &other)
+   inline hashtable_iterator(const nonconst_iterator &other)
       :  slist_it_(other.slist_it()), traitsptr_(other.get_bucket_value_traits())
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE const siterator &slist_it() const
+   inline const siterator &slist_it() const
    { return slist_it_; }
 
-   BOOST_INTRUSIVE_FORCEINLINE hashtable_iterator<BucketValueTraits, LinearBuckets, false> unconst() const
+   inline hashtable_iterator<BucketValueTraits, LinearBuckets, false> unconst() const
    {  return hashtable_iterator<BucketValueTraits, LinearBuckets, false>(this->slist_it(), this->get_bucket_value_traits());   }
 
-   BOOST_INTRUSIVE_FORCEINLINE hashtable_iterator& operator++()
+   inline hashtable_iterator& operator++()
    {  this->increment();   return *this;   }
 
-   BOOST_INTRUSIVE_FORCEINLINE hashtable_iterator &operator=(const hashtable_iterator &other)
+   inline hashtable_iterator &operator=(const hashtable_iterator &other)
    {  slist_it_ = other.slist_it(); traitsptr_ = other.get_bucket_value_traits();   return *this;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE hashtable_iterator operator++(int)
+   inline hashtable_iterator operator++(int)
    {
       hashtable_iterator result (*this);
       this->increment();
       return result;
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE friend bool operator== (const hashtable_iterator& i, const hashtable_iterator& i2)
+   inline friend bool operator== (const hashtable_iterator& i, const hashtable_iterator& i2)
    { return i.slist_it_ == i2.slist_it_; }
 
-   BOOST_INTRUSIVE_FORCEINLINE friend bool operator!= (const hashtable_iterator& i, const hashtable_iterator& i2)
+   inline friend bool operator!= (const hashtable_iterator& i, const hashtable_iterator& i2)
    { return !(i == i2); }
 
-   BOOST_INTRUSIVE_FORCEINLINE reference operator*() const
+   inline reference operator*() const
    { return *this->operator ->(); }
 
-   BOOST_INTRUSIVE_FORCEINLINE pointer operator->() const
+   inline pointer operator->() const
    {
       return this->priv_value_traits().to_value_ptr
          (downcast_bucket(slist_it_.pointed_node()));
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE const_bucketvaltraits_ptr get_bucket_value_traits() const
+   inline const_bucketvaltraits_ptr get_bucket_value_traits() const
    {  return traitsptr_;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE const value_traits &priv_value_traits() const
+   inline const value_traits &priv_value_traits() const
    {  return traitsptr_->priv_value_traits();  }
 
    private:
@@ -281,7 +281,7 @@ class hashtable_iterator<BucketValueTraits, true, IsConst>
                   , hashtable_iterator<BucketValueTraits, true, false>
                   , nat>::type                                 nonconst_iterator;
 
-   BOOST_INTRUSIVE_FORCEINLINE static node_ptr downcast_bucket(slist_node_ptr p)
+   inline static node_ptr downcast_bucket(slist_node_ptr p)
    {
       return pointer_traits<node_ptr>::
          pointer_to(static_cast<typename node_traits::node&>(*p));
@@ -289,67 +289,67 @@ class hashtable_iterator<BucketValueTraits, true, IsConst>
 
    public:
 
-   BOOST_INTRUSIVE_FORCEINLINE hashtable_iterator ()
+   inline hashtable_iterator ()
       : slist_it_()  //Value initialization to achieve "null iterators" (N3644)
       , members_()
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE explicit hashtable_iterator(siterator ptr, bucket_ptr bp, const_value_traits_ptr traits_ptr)
+   inline explicit hashtable_iterator(siterator ptr, bucket_ptr bp, const_value_traits_ptr traits_ptr)
       : slist_it_ (ptr)
       , members_ (bp, traits_ptr)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE hashtable_iterator(const hashtable_iterator &other)
+   inline hashtable_iterator(const hashtable_iterator &other)
       :  slist_it_(other.slist_it()), members_(other.get_bucket_ptr(), other.get_value_traits())
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE hashtable_iterator(const nonconst_iterator &other)
+   inline hashtable_iterator(const nonconst_iterator &other)
       :  slist_it_(other.slist_it()), members_(other.get_bucket_ptr(), other.get_value_traits())
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE const siterator &slist_it() const
+   inline const siterator &slist_it() const
    { return slist_it_; }
 
-   BOOST_INTRUSIVE_FORCEINLINE hashtable_iterator<BucketValueTraits, true, false> unconst() const
+   inline hashtable_iterator<BucketValueTraits, true, false> unconst() const
    {  return hashtable_iterator<BucketValueTraits, true, false>(this->slist_it(), members_.nodeptr_, members_.get_ptr());   }
 
-   BOOST_INTRUSIVE_FORCEINLINE hashtable_iterator& operator++()
+   inline hashtable_iterator& operator++()
    {  this->increment();   return *this;   }
 
-   BOOST_INTRUSIVE_FORCEINLINE hashtable_iterator &operator=(const hashtable_iterator &other)
+   inline hashtable_iterator &operator=(const hashtable_iterator &other)
    {  slist_it_ = other.slist_it(); members_ = other.members_;  return *this;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE hashtable_iterator operator++(int)
+   inline hashtable_iterator operator++(int)
    {
       hashtable_iterator result (*this);
       this->increment();
       return result;
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE friend bool operator== (const hashtable_iterator& i, const hashtable_iterator& i2)
+   inline friend bool operator== (const hashtable_iterator& i, const hashtable_iterator& i2)
    { return i.slist_it_ == i2.slist_it_; }
 
-   BOOST_INTRUSIVE_FORCEINLINE friend bool operator!= (const hashtable_iterator& i, const hashtable_iterator& i2)
+   inline friend bool operator!= (const hashtable_iterator& i, const hashtable_iterator& i2)
    { return i.slist_it_ != i2.slist_it_; }
 
-   BOOST_INTRUSIVE_FORCEINLINE reference operator*() const
+   inline reference operator*() const
    { return *this->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(); }
 
-   BOOST_INTRUSIVE_FORCEINLINE bucket_ptr get_bucket_ptr() const
+   inline bucket_ptr get_bucket_ptr() const
    {  return members_.nodeptr_; }
 
    private:
 
-   BOOST_INTRUSIVE_FORCEINLINE pointer operator_arrow(detail::false_) const
+   inline pointer operator_arrow(detail::false_) const
    { return value_traits::to_value_ptr(downcast_bucket(slist_it_.pointed_node())); }
 
-   BOOST_INTRUSIVE_FORCEINLINE pointer operator_arrow(detail::true_) const
+   inline pointer operator_arrow(detail::true_) const
    { return this->get_value_traits()->to_value_ptr(downcast_bucket(slist_it_.pointed_node())); }
 
    void increment()

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

@@ -28,7 +28,6 @@
 #include <boost/intrusive/detail/mpl.hpp>
 #include <boost/move/detail/to_raw_pointer.hpp>
 #include <boost/intrusive/detail/node_holder.hpp>
-#include <boost/assert.hpp>
 
 namespace boost {
 namespace intrusive {
@@ -47,8 +46,6 @@ struct bhtraits_base
       template rebind_pointer<T>::type                               pointer;
    typedef typename pointer_traits<node_ptr>::
       template rebind_pointer<const T>::type                         const_pointer;
-   //typedef typename pointer_traits<pointer>::reference               reference;
-   //typedef typename pointer_traits<const_pointer>::reference         const_reference;
    typedef T &                                                       reference;
    typedef const T &                                                 const_reference;
    typedef node_holder_type &                                        node_holder_reference;
@@ -56,35 +53,31 @@ struct bhtraits_base
    typedef node&                                                     node_reference;
    typedef const node &                                              const_node_reference;
 
-   BOOST_INTRUSIVE_FORCEINLINE static pointer to_value_ptr(node_ptr n)
+   inline static pointer to_value_ptr(node_ptr n)
    {
       pointer p = pointer_traits<pointer>::pointer_to
          (static_cast<reference>(static_cast<node_holder_reference>(*n)));
-      BOOST_ASSERT(!!p);
       return p;
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE static const_pointer to_value_ptr(const_node_ptr n)
+   inline static const_pointer to_value_ptr(const_node_ptr n)
    {
       const_pointer p = pointer_traits<const_pointer>::pointer_to
          (static_cast<const_reference>(static_cast<const_node_holder_reference>(*n)));
-      BOOST_ASSERT(!!p);
       return p;
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE static node_ptr to_node_ptr(reference value)
+   inline static node_ptr to_node_ptr(reference value)
    {
       node_ptr p = pointer_traits<node_ptr>::pointer_to
          (static_cast<node_reference>(static_cast<node_holder_reference>(value)));
-      BOOST_ASSERT(!!p);
       return p;
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE static const_node_ptr to_node_ptr(const_reference value)
+   inline static const_node_ptr to_node_ptr(const_reference value)
    {
       const_node_ptr p = pointer_traits<const_node_ptr>::pointer_to
          (static_cast<const_node_reference>(static_cast<const_node_holder_reference>(value)));
-      BOOST_ASSERT(!!p);
       return p;
    }
 };
@@ -121,26 +114,26 @@ struct mhtraits
 
    static const link_mode_type link_mode = Hook::hooktags::link_mode;
 
-   BOOST_INTRUSIVE_FORCEINLINE static node_ptr to_node_ptr(reference value)
+   inline static node_ptr to_node_ptr(reference value)
    {
       return pointer_traits<node_ptr>::pointer_to
          (static_cast<node_reference>(static_cast<hook_reference>(value.*P)));
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE static const_node_ptr to_node_ptr(const_reference value)
+   inline static const_node_ptr to_node_ptr(const_reference value)
    {
       return pointer_traits<const_node_ptr>::pointer_to
          (static_cast<const_node_reference>(static_cast<const_hook_reference>(value.*P)));
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE static pointer to_value_ptr(node_ptr n)
+   inline static pointer to_value_ptr(node_ptr n)
    {
       return pointer_traits<pointer>::pointer_to
          (*detail::parent_from_member<T, Hook>
             (static_cast<Hook*>(boost::movelib::to_raw_pointer(n)), P));
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE static const_pointer to_value_ptr(const_node_ptr n)
+   inline static const_pointer to_value_ptr(const_node_ptr n)
    {
       return pointer_traits<const_pointer>::pointer_to
          (*detail::parent_from_member<T, Hook>
@@ -169,23 +162,23 @@ struct fhtraits
    typedef const value_type &                                        const_reference;
    static const link_mode_type link_mode = hook_type::hooktags::link_mode;
 
-   static node_ptr to_node_ptr(reference value)
+   inline static node_ptr to_node_ptr(reference value)
    {  return static_cast<node*>(boost::movelib::to_raw_pointer(Functor::to_hook_ptr(value)));  }
 
-   static const_node_ptr to_node_ptr(const_reference value)
+   inline static const_node_ptr to_node_ptr(const_reference value)
    {  return static_cast<const node*>(boost::movelib::to_raw_pointer(Functor::to_hook_ptr(value)));  }
 
-   static pointer to_value_ptr(node_ptr n)
+   inline static pointer to_value_ptr(node_ptr n)
    {  return Functor::to_value_ptr(to_hook_ptr(n));  }
 
-   static const_pointer to_value_ptr(const_node_ptr n)
+   inline static const_pointer to_value_ptr(const_node_ptr n)
    {  return Functor::to_value_ptr(to_hook_ptr(n));  }
 
    private:
-   static hook_ptr to_hook_ptr(node_ptr n)
+   inline static hook_ptr to_hook_ptr(node_ptr n)
    {  return hook_ptr(&*static_cast<hook_type*>(&*n));  }
 
-   static const_hook_ptr to_hook_ptr(const_node_ptr n)
+   inline static const_hook_ptr to_hook_ptr(const_node_ptr n)
    {  return const_hook_ptr(&*static_cast<const hook_type*>(&*n));  }
 };
 

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

@@ -84,15 +84,15 @@ template<class NodePtr, class StoredPointer, bool StatefulValueTraits = true>
 struct iiterator_members
 {
 
-   BOOST_INTRUSIVE_FORCEINLINE iiterator_members()
+   inline iiterator_members()
       : nodeptr_()//Value initialization to achieve "null iterators" (N3644)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE iiterator_members(const NodePtr &n_ptr, const StoredPointer &data)
+   inline iiterator_members(const NodePtr &n_ptr, const StoredPointer &data)
       :  nodeptr_(n_ptr), ptr_(data)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE StoredPointer get_ptr() const
+   inline StoredPointer get_ptr() const
    {  return ptr_;  }
 
    NodePtr nodeptr_;
@@ -102,15 +102,15 @@ struct iiterator_members
 template<class NodePtr, class StoredPointer>
 struct iiterator_members<NodePtr, StoredPointer, false>
 {
-   BOOST_INTRUSIVE_FORCEINLINE iiterator_members()
+   inline iiterator_members()
       : nodeptr_()//Value initialization to achieve "null iterators" (N3644)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE iiterator_members(const NodePtr &n_ptr, const StoredPointer &)
+   inline iiterator_members(const NodePtr &n_ptr, const StoredPointer &)
       : nodeptr_(n_ptr)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE StoredPointer get_ptr() const
+   inline StoredPointer get_ptr() const
    {  return StoredPointer();  }
 
    NodePtr nodeptr_;

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

@@ -181,7 +181,7 @@ struct iterator_disable_if_tag_difference_type
 ////////////////////
 
 template<class InputIt>
-BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag<InputIt, std::input_iterator_tag>::type
+inline typename iterator_enable_if_tag<InputIt, std::input_iterator_tag>::type
    iterator_advance(InputIt& it, typename iter_difference<InputIt>::type n)
 {
    while(n--)
@@ -197,7 +197,7 @@ typename iterator_enable_if_tag<InputIt, std::forward_iterator_tag>::type
 }
 
 template<class InputIt>
-BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag<InputIt, std::bidirectional_iterator_tag>::type
+inline typename iterator_enable_if_tag<InputIt, std::bidirectional_iterator_tag>::type
    iterator_advance(InputIt& it, typename iter_difference<InputIt>::type n)
 {
    for (; 0 < n; --n)
@@ -207,14 +207,14 @@ BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag<InputIt, std::bidire
 }
 
 template<class InputIt, class Distance>
-BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag<InputIt, std::random_access_iterator_tag>::type
+inline typename iterator_enable_if_tag<InputIt, std::random_access_iterator_tag>::type
    iterator_advance(InputIt& it, Distance n)
 {
    it += n;
 }
 
 template<class InputIt, class Distance>
-BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag<InputIt, std::random_access_iterator_tag, InputIt>::type
+inline typename iterator_enable_if_tag<InputIt, std::random_access_iterator_tag, InputIt>::type
    make_iterator_advance(InputIt it, Distance n)
 {
    (iterator_advance)(it, n);
@@ -222,14 +222,14 @@ BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag<InputIt, std::random
 }
 
 template<class It>
-BOOST_INTRUSIVE_FORCEINLINE 
+inline 
    void iterator_uadvance(It& it, typename iter_size<It>::type n)
 {
    (iterator_advance)(it, (typename iterator_traits<It>::difference_type)n);
 }
 
 template<class It>
-BOOST_INTRUSIVE_FORCEINLINE
+inline
 It make_iterator_uadvance(It it, typename iter_size<It>::type n)
 {
    (iterator_uadvance)(it, n);
@@ -253,7 +253,7 @@ typename iterator_disable_if_tag_difference_type
 }
 
 template<class InputIt>
-BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag_difference_type
+inline typename iterator_enable_if_tag_difference_type
    <InputIt, std::random_access_iterator_tag>::type
       iterator_distance(InputIt first, InputIt last)
 {
@@ -266,7 +266,7 @@ BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag_difference_type
 ////////////////////////////////////////
 
 template<class It>
-BOOST_INTRUSIVE_FORCEINLINE typename iter_size<It>::type
+inline typename iter_size<It>::type
    iterator_udistance(It first, It last)
 {
    return (typename iter_size<It>::type)(iterator_distance)(first, last);
@@ -277,14 +277,14 @@ BOOST_INTRUSIVE_FORCEINLINE typename iter_size<It>::type
 ////////////////////////////////////////
 
 template<class InputIt>
-BOOST_INTRUSIVE_FORCEINLINE InputIt iterator_next(InputIt it, typename iter_difference<InputIt>::type n)
+inline InputIt iterator_next(InputIt it, typename iter_difference<InputIt>::type n)
 {
    (iterator_advance)(it, n);
    return it;
 }
 
 template<class InputIt>
-BOOST_INTRUSIVE_FORCEINLINE InputIt iterator_unext(InputIt it, typename iterator_traits<InputIt>::size_type n)
+inline InputIt iterator_unext(InputIt it, typename iterator_traits<InputIt>::size_type n)
 {
    (iterator_uadvance)(it, n);
    return it;
@@ -295,11 +295,11 @@ BOOST_INTRUSIVE_FORCEINLINE InputIt iterator_unext(InputIt it, typename iterator
 ////////////////////////////////////////
 
 template<class I>
-BOOST_INTRUSIVE_FORCEINLINE typename iterator_traits<I>::pointer iterator_arrow_result(const I &i)
+inline typename iterator_traits<I>::pointer iterator_arrow_result(const I &i)
 {  return i.operator->();  }
 
 template<class T>
-BOOST_INTRUSIVE_FORCEINLINE T * iterator_arrow_result(T *p)
+inline T * iterator_arrow_result(T *p)
 {  return p;   }
 
 } //namespace intrusive

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

@@ -78,40 +78,40 @@ public:
       static const bool value = same_type || is_convertible<P1, const_node_ptr>::value;
    };
 
-   BOOST_INTRUSIVE_FORCEINLINE base_t base() const
+   inline base_t base() const
    {  return static_cast<const base_t&>(*this); }
 
-   BOOST_INTRUSIVE_FORCEINLINE key_nodeptr_comp(KeyTypeKeyCompare kcomp, const ValueTraits *traits)
+   inline key_nodeptr_comp(KeyTypeKeyCompare kcomp, const ValueTraits *traits)
       :  base_t(kcomp), traits_(traits)
    {}
 
    //pred(pnode)
    template<class T1>
-   BOOST_INTRUSIVE_FORCEINLINE bool operator()(const T1 &t1, typename enable_if_c< is_same_or_nodeptr_convertible<T1>::value, sfinae_type* >::type = 0) const
+   inline bool operator()(const T1 &t1, typename enable_if_c< is_same_or_nodeptr_convertible<T1>::value, sfinae_type* >::type = 0) const
    {  return base().get()(key_of_value()(*traits_->to_value_ptr(t1)));  }
 
    //operator() 2 arg
    //pred(pnode, pnode)
    template<class T1, class T2>
-   BOOST_INTRUSIVE_FORCEINLINE bool operator()
+   inline bool operator()
       (const T1 &t1, const T2 &t2, typename enable_if_c< is_same_or_nodeptr_convertible<T1>::value && is_same_or_nodeptr_convertible<T2>::value, sfinae_type* >::type = 0) const
    {  return base()(*traits_->to_value_ptr(t1), *traits_->to_value_ptr(t2));  }
 
    //pred(pnode, key)
    template<class T1, class T2>
-   BOOST_INTRUSIVE_FORCEINLINE bool operator()
+   inline bool operator()
       (const T1 &t1, const T2 &t2, typename enable_if_c< is_same_or_nodeptr_convertible<T1>::value && !is_same_or_nodeptr_convertible<T2>::value, sfinae_type* >::type = 0) const
    {  return base()(*traits_->to_value_ptr(t1), t2);  }
 
    //pred(key, pnode)
    template<class T1, class T2>
-   BOOST_INTRUSIVE_FORCEINLINE bool operator()
+   inline bool operator()
       (const T1 &t1, const T2 &t2, typename enable_if_c< !is_same_or_nodeptr_convertible<T1>::value && is_same_or_nodeptr_convertible<T2>::value, sfinae_type* >::type = 0) const
    {  return base()(t1, *traits_->to_value_ptr(t2));  }
 
    //pred(key, key)
    template<class T1, class T2>
-   BOOST_INTRUSIVE_FORCEINLINE bool operator()
+   inline bool operator()
       (const T1 &t1, const T2 &t2, typename enable_if_c< !is_same_or_nodeptr_convertible<T1>::value && !is_same_or_nodeptr_convertible<T2>::value, sfinae_type* >::type = 0) const
    {  return base()(t1, t2);  }
 

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

@@ -60,81 +60,81 @@ class list_iterator
    typedef typename types_t::iterator_type::reference          reference;
    typedef typename types_t::iterator_type::iterator_category  iterator_category;
 
-   BOOST_INTRUSIVE_FORCEINLINE list_iterator()
+   inline list_iterator()
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE explicit list_iterator(node_ptr nodeptr, const_value_traits_ptr traits_ptr)
+   inline explicit list_iterator(node_ptr nodeptr, const_value_traits_ptr traits_ptr)
       : members_(nodeptr, traits_ptr)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE list_iterator(const list_iterator &other)
+   inline list_iterator(const list_iterator &other)
       :  members_(other.pointed_node(), other.get_value_traits())
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE list_iterator(const nonconst_iterator &other)
+   inline list_iterator(const nonconst_iterator &other)
       :  members_(other.pointed_node(), other.get_value_traits())
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE list_iterator &operator=(const list_iterator &other)
+   inline list_iterator &operator=(const list_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 list_iterator &operator=(node_ptr nodeptr)
+   inline list_iterator &operator=(node_ptr nodeptr)
    {  members_.nodeptr_ = nodeptr;  return *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(); }
 
    public:
-   BOOST_INTRUSIVE_FORCEINLINE list_iterator& operator++()
+   inline list_iterator& operator++()
    {
       node_ptr p = node_traits::get_next(members_.nodeptr_);
       members_.nodeptr_ = p;
       return static_cast<list_iterator&> (*this);
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE list_iterator operator++(int)
+   inline list_iterator operator++(int)
    {
       list_iterator result (*this);
       members_.nodeptr_ = node_traits::get_next(members_.nodeptr_);
       return result;
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE list_iterator& operator--()
+   inline list_iterator& operator--()
    {
       members_.nodeptr_ = node_traits::get_previous(members_.nodeptr_);
       return static_cast<list_iterator&> (*this);
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE list_iterator operator--(int)
+   inline list_iterator operator--(int)
    {
       list_iterator result (*this);
       members_.nodeptr_ = node_traits::get_previous(members_.nodeptr_);
       return result;
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE friend bool operator== (const list_iterator& l, const list_iterator& r)
+   inline friend bool operator== (const list_iterator& l, const list_iterator& r)
    {  return l.pointed_node() == r.pointed_node();   }
 
-   BOOST_INTRUSIVE_FORCEINLINE friend bool operator!= (const list_iterator& l, const list_iterator& r)
+   inline friend bool operator!= (const list_iterator& l, const list_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 list_iterator<ValueTraits, false> unconst() const
+   inline list_iterator<ValueTraits, false> unconst() const
    {  return list_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/mpl.hpp

@@ -66,6 +66,12 @@ using boost::move_detail::eval_if_c;
 using boost::move_detail::eval_if;
 using boost::move_detail::unvoid_ref;
 using boost::move_detail::add_const_if_c;
+using boost::move_detail::is_integral;
+using boost::move_detail::make_unsigned;
+using boost::move_detail::is_enum;
+using boost::move_detail::is_floating_point;
+using boost::move_detail::is_scalar;
+using boost::move_detail::is_unsigned;
 
 template<std::size_t S>
 struct ls_zeros

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

@@ -59,7 +59,7 @@ struct node_cloner
    {}
 
    // tree-based containers use this method, which is proxy-reference friendly
-   BOOST_INTRUSIVE_FORCEINLINE node_ptr operator()(node_ptr p)
+   inline node_ptr operator()(node_ptr p)
    {
       reference_type v = *traits_->to_value_ptr(p);
       node_ptr n = traits_->to_node_ptr(*base_t::get()(v));
@@ -85,11 +85,11 @@ struct node_disposer
    static const bool safemode_or_autounlink =
       is_safe_autounlink<value_traits::link_mode>::value;
 
-   BOOST_INTRUSIVE_FORCEINLINE node_disposer(F f, const ValueTraits *cont)
+   inline node_disposer(F f, const ValueTraits *cont)
       :  base_t(f), traits_(cont)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE void operator()(node_ptr p)
+   inline void operator()(node_ptr p)
    {
       BOOST_IF_CONSTEXPR(safemode_or_autounlink)
          node_algorithms::init(p);