passenger 5.1.4 → 5.1.5

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

@@ -22,6 +22,7 @@
 #endif
 
 #include <boost/intrusive/detail/config_begin.hpp>
+#include <boost/intrusive/detail/workaround.hpp>
 #include <boost/intrusive/pointer_rebind.hpp>
 #include <boost/intrusive/avltree_algorithms.hpp>
 #include <boost/intrusive/pointer_plus_bits.hpp>
@@ -68,49 +69,49 @@ struct default_avltree_node_traits_impl
 
    typedef typename node::balance balance;
 
-   static node_ptr get_parent(const const_node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_parent(const const_node_ptr & n)
    {  return n->parent_;  }
 
-   static node_ptr get_parent(const node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_parent(const node_ptr & n)
    {  return n->parent_;  }
 
-   static void set_parent(const node_ptr & n, const node_ptr & p)
+   BOOST_INTRUSIVE_FORCEINLINE static void set_parent(const node_ptr & n, const node_ptr & p)
    {  n->parent_ = p;  }
 
-   static node_ptr get_left(const const_node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_left(const const_node_ptr & n)
    {  return n->left_;  }
 
-   static node_ptr get_left(const node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_left(const node_ptr & n)
    {  return n->left_;  }
 
-   static void set_left(const node_ptr & n, const node_ptr & l)
+   BOOST_INTRUSIVE_FORCEINLINE static void set_left(const node_ptr & n, const node_ptr & l)
    {  n->left_ = l;  }
 
-   static node_ptr get_right(const const_node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_right(const const_node_ptr & n)
    {  return n->right_;  }
 
-   static node_ptr get_right(const node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_right(const node_ptr & n)
    {  return n->right_;  }
 
-   static void set_right(const node_ptr & n, const node_ptr & r)
+   BOOST_INTRUSIVE_FORCEINLINE static void set_right(const node_ptr & n, const node_ptr & r)
    {  n->right_ = r;  }
 
-   static balance get_balance(const const_node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static balance get_balance(const const_node_ptr & n)
    {  return n->balance_;  }
 
-   static balance get_balance(const node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static balance get_balance(const node_ptr & n)
    {  return n->balance_;  }
 
-   static void set_balance(const node_ptr & n, balance b)
+   BOOST_INTRUSIVE_FORCEINLINE static void set_balance(const node_ptr & n, balance b)
    {  n->balance_ = b;  }
 
-   static balance negative()
+   BOOST_INTRUSIVE_FORCEINLINE static balance negative()
    {  return node::negative_t;  }
 
-   static balance zero()
+   BOOST_INTRUSIVE_FORCEINLINE static balance zero()
    {  return node::zero_t;  }
 
-   static balance positive()
+   BOOST_INTRUSIVE_FORCEINLINE static balance positive()
    {  return node::positive_t;  }
 };
 
@@ -126,37 +127,37 @@ struct compact_avltree_node_traits_impl
 
    typedef pointer_plus_bits<node_ptr, 2> ptr_bit;
 
-   static node_ptr get_parent(const const_node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_parent(const const_node_ptr & n)
    {  return ptr_bit::get_pointer(n->parent_);  }
 
-   static void set_parent(const node_ptr & n, const node_ptr & p)
+   BOOST_INTRUSIVE_FORCEINLINE static void set_parent(const node_ptr & n, const node_ptr & p)
    {  ptr_bit::set_pointer(n->parent_, p);  }
 
-   static node_ptr get_left(const const_node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_left(const const_node_ptr & n)
    {  return n->left_;  }
 
-   static void set_left(const node_ptr & n, const node_ptr & l)
+   BOOST_INTRUSIVE_FORCEINLINE static void set_left(const node_ptr & n, const node_ptr & l)
    {  n->left_ = l;  }
 
-   static node_ptr get_right(const const_node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_right(const const_node_ptr & n)
    {  return n->right_;  }
 
-   static void set_right(const node_ptr & n, const node_ptr & r)
+   BOOST_INTRUSIVE_FORCEINLINE static void set_right(const node_ptr & n, const node_ptr & r)
    {  n->right_ = r;  }
 
-   static balance get_balance(const const_node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static balance get_balance(const const_node_ptr & n)
    {  return (balance)ptr_bit::get_bits(n->parent_);  }
 
-   static void set_balance(const node_ptr & n, balance b)
+   BOOST_INTRUSIVE_FORCEINLINE static void set_balance(const node_ptr & n, balance b)
    {  ptr_bit::set_bits(n->parent_, (std::size_t)b);  }
 
-   static balance negative()
+   BOOST_INTRUSIVE_FORCEINLINE static balance negative()
    {  return node::negative_t;  }
 
-   static balance zero()
+   BOOST_INTRUSIVE_FORCEINLINE static balance zero()
    {  return node::zero_t;  }
 
-   static balance positive()
+   BOOST_INTRUSIVE_FORCEINLINE static balance positive()
    {  return node::positive_t;  }
 };
 

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

@@ -69,8 +69,8 @@ class bstree_algorithms_base
    static node_ptr prev_node(const node_ptr & node)
    {
       if(is_header(node)){
-         return NodeTraits::get_right(node);
-         //return maximum(NodeTraits::get_parent(node));
+         //return NodeTraits::get_right(node);
+         return maximum(NodeTraits::get_parent(node));
       }
       else if(NodeTraits::get_left(node)){
          return maximum(NodeTraits::get_left(node));

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

@@ -52,34 +52,34 @@ class common_slist_algorithms
       return p;
    }
 
-   static void init(const node_ptr & this_node)
+   BOOST_INTRUSIVE_FORCEINLINE static void init(const node_ptr & this_node)
    {  NodeTraits::set_next(this_node, node_ptr());  }
 
-   static bool unique(const const_node_ptr & this_node)
+   BOOST_INTRUSIVE_FORCEINLINE static bool unique(const const_node_ptr & this_node)
    {
       node_ptr next = NodeTraits::get_next(this_node);
       return !next || next == this_node;
    }
 
-   static bool inited(const const_node_ptr & this_node)
+   BOOST_INTRUSIVE_FORCEINLINE static bool inited(const const_node_ptr & this_node)
    {  return !NodeTraits::get_next(this_node); }
 
-   static void unlink_after(const node_ptr & prev_node)
+   BOOST_INTRUSIVE_FORCEINLINE static void unlink_after(const node_ptr & prev_node)
    {
       const_node_ptr this_node(NodeTraits::get_next(prev_node));
       NodeTraits::set_next(prev_node, NodeTraits::get_next(this_node));
    }
 
-   static void unlink_after(const node_ptr & prev_node, const node_ptr & last_node)
+   BOOST_INTRUSIVE_FORCEINLINE static void unlink_after(const node_ptr & prev_node, const node_ptr & last_node)
    {  NodeTraits::set_next(prev_node, last_node);  }
 
-   static void link_after(const node_ptr & prev_node, const node_ptr & this_node)
+   BOOST_INTRUSIVE_FORCEINLINE static void link_after(const node_ptr & prev_node, const node_ptr & this_node)
    {
       NodeTraits::set_next(this_node, NodeTraits::get_next(prev_node));
       NodeTraits::set_next(prev_node, this_node);
    }
 
-   static void incorporate_after(const node_ptr & bp, const node_ptr & b, const node_ptr & be)
+   BOOST_INTRUSIVE_FORCEINLINE static void incorporate_after(const node_ptr & bp, const node_ptr & b, const node_ptr & be)
    {
       node_ptr p(NodeTraits::get_next(bp));
       NodeTraits::set_next(bp, b);

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

@@ -38,13 +38,18 @@
    #pragma warning (disable : 4284) // odd return type for operator->
    #pragma warning (disable : 4244) // possible loss of data
    #pragma warning (disable : 4521) ////Disable "multiple copy constructors specified"
-   #pragma warning (disable : 4522)
+   #pragma warning (disable : 4127) //conditional expression is constant
    #pragma warning (disable : 4146)
    #pragma warning (disable : 4267) //conversion from 'X' to 'Y', possible loss of data
-   #pragma warning (disable : 4127) //conditional expression is constant
-   #pragma warning (disable : 4706) //assignment within conditional expression
    #pragma warning (disable : 4541) //'typeid' used on polymorphic type 'boost::exception' with /GR-
    #pragma warning (disable : 4512) //'typeid' used on polymorphic type 'boost::exception' with /GR-
+   #pragma warning (disable : 4522)
+   #pragma warning (disable : 4706) //assignment within conditional expression
+   #pragma warning (disable : 4710) // function not inlined
+   #pragma warning (disable : 4714) // "function": marked as __forceinline not inlined
+   #pragma warning (disable : 4711) // function selected for automatic inline expansion
+   #pragma warning (disable : 4786) // identifier truncated in debug info
+   #pragma warning (disable : 4996) // "function": was declared deprecated
 #endif
 
 //#define BOOST_INTRUSIVE_USE_ITERATOR_FACADE

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

@@ -21,6 +21,7 @@
 #  pragma once
 #endif
 
+#include <boost/intrusive/detail/workaround.hpp>
 #include <boost/intrusive/pointer_traits.hpp>
 #include <boost/intrusive/detail/to_raw_pointer.hpp>
 
@@ -39,14 +40,14 @@ struct default_header_holder : public NodeTraits::node
 
    default_header_holder() : node() {}
 
-   const_node_ptr get_node() const
+   BOOST_INTRUSIVE_FORCEINLINE const_node_ptr get_node() const
    { return pointer_traits< const_node_ptr >::pointer_to(*static_cast< const node* >(this)); }
 
-   node_ptr get_node()
+   BOOST_INTRUSIVE_FORCEINLINE node_ptr get_node()
    { return pointer_traits< node_ptr >::pointer_to(*static_cast< node* >(this)); }
 
    // (unsafe) downcast used to implement container-from-iterator
-   static default_header_holder* get_holder(const node_ptr &p)
+   BOOST_INTRUSIVE_FORCEINLINE static default_header_holder* get_holder(const node_ptr &p)
    { return static_cast< default_header_holder* >(boost::intrusive::detail::to_raw_pointer(p)); }
 };
 

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

@@ -22,6 +22,7 @@
 #  pragma once
 #endif
 
+#include <boost/intrusive/detail/workaround.hpp>
 #include <boost/move/utility_core.hpp>
 
 namespace boost {
@@ -165,57 +166,57 @@ class ebo_functor_holder
    public:
    typedef T functor_type;
 
-   ebo_functor_holder()
+   BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder()
       : t_()
    {}
 
-   explicit ebo_functor_holder(const T &t)
+   BOOST_INTRUSIVE_FORCEINLINE explicit ebo_functor_holder(const T &t)
       : t_(t)
    {}
 
-   explicit ebo_functor_holder(BOOST_RV_REF(T) t)
+   BOOST_INTRUSIVE_FORCEINLINE explicit ebo_functor_holder(BOOST_RV_REF(T) t)
       : t_(::boost::move(t))
    {}
 
    template<class Arg1, class Arg2>
-   ebo_functor_holder(BOOST_FWD_REF(Arg1) arg1, BOOST_FWD_REF(Arg2) arg2)
+   BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder(BOOST_FWD_REF(Arg1) arg1, BOOST_FWD_REF(Arg2) arg2)
       : t_(::boost::forward<Arg1>(arg1), ::boost::forward<Arg2>(arg2))
    {}
 
-   ebo_functor_holder(const ebo_functor_holder &x)
-      : t_(x)
+   BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder(const ebo_functor_holder &x)
+      : t_(x.t_)
    {}
 
-   ebo_functor_holder(BOOST_RV_REF(ebo_functor_holder) x)
+   BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder(BOOST_RV_REF(ebo_functor_holder) x)
       : t_(x.t_)
    {}
 
-   ebo_functor_holder& operator=(BOOST_COPY_ASSIGN_REF(ebo_functor_holder) x)
+   BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder& operator=(BOOST_COPY_ASSIGN_REF(ebo_functor_holder) x)
    {
       this->get() = x.get();
       return *this;
    }
 
-   ebo_functor_holder& operator=(BOOST_RV_REF(ebo_functor_holder) x)
+   BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder& operator=(BOOST_RV_REF(ebo_functor_holder) x)
    {
       this->get() = ::boost::move(x.get());
       return *this;
    }
 
-   ebo_functor_holder& operator=(const T &x)
+   BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder& operator=(const T &x)
    {
       this->get() = x;
       return *this;
    }
 
-   ebo_functor_holder& operator=(BOOST_RV_REF(T) x)
+   BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder& operator=(BOOST_RV_REF(T) x)
    {
       this->get() = ::boost::move(x);
       return *this;
    }
 
-   T&       get(){return t_;}
-   const T& get()const{return t_;}
+   BOOST_INTRUSIVE_FORCEINLINE T&       get(){return t_;}
+   BOOST_INTRUSIVE_FORCEINLINE const T& get()const{return t_;}
 
    private:
    T t_;
@@ -230,58 +231,58 @@ class ebo_functor_holder<T, false>
    public:
    typedef T functor_type;
 
-   ebo_functor_holder()
+   BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder()
       : T()
    {}
 
-   explicit ebo_functor_holder(const T &t)
+   BOOST_INTRUSIVE_FORCEINLINE explicit ebo_functor_holder(const T &t)
       : T(t)
    {}
 
-   explicit ebo_functor_holder(BOOST_RV_REF(T) t)
+   BOOST_INTRUSIVE_FORCEINLINE explicit ebo_functor_holder(BOOST_RV_REF(T) t)
       : T(::boost::move(t))
    {}
 
    template<class Arg1, class Arg2>
-   ebo_functor_holder(BOOST_FWD_REF(Arg1) arg1, BOOST_FWD_REF(Arg2) arg2)
+   BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder(BOOST_FWD_REF(Arg1) arg1, BOOST_FWD_REF(Arg2) arg2)
       : T(::boost::forward<Arg1>(arg1), ::boost::forward<Arg2>(arg2))
    {}
 
-   ebo_functor_holder(const ebo_functor_holder &x)
+   BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder(const ebo_functor_holder &x)
       : T(static_cast<const T&>(x))
    {}
 
-   ebo_functor_holder(BOOST_RV_REF(ebo_functor_holder) x)
+   BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder(BOOST_RV_REF(ebo_functor_holder) x)
       : T(BOOST_MOVE_BASE(T, x))
    {}
 
-   ebo_functor_holder& operator=(BOOST_COPY_ASSIGN_REF(ebo_functor_holder) x)
+   BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder& operator=(BOOST_COPY_ASSIGN_REF(ebo_functor_holder) x)
    {
       const ebo_functor_holder&r = x;
-      this->get() = x.get();
+      this->get() = r;
       return *this;
    }
 
-   ebo_functor_holder& operator=(BOOST_RV_REF(ebo_functor_holder) x)
+   BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder& operator=(BOOST_RV_REF(ebo_functor_holder) x)
    {
       this->get() = ::boost::move(x.get());
       return *this;
    }
 
-   ebo_functor_holder& operator=(const T &x)
+   BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder& operator=(const T &x)
    {
       this->get() = x;
       return *this;
    }
 
-   ebo_functor_holder& operator=(BOOST_RV_REF(T) x)
+   BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder& operator=(BOOST_RV_REF(T) x)
    {
       this->get() = ::boost::move(x);
       return *this;
    }
 
-   T&       get(){return *this;}
-   const T& get()const{return *this;}
+   BOOST_INTRUSIVE_FORCEINLINE T&       get(){return *this;}
+   BOOST_INTRUSIVE_FORCEINLINE const T& get()const{return *this;}
 };
 
 }  //namespace detail {

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

@@ -21,6 +21,8 @@
 #  pragma once
 #endif
 
+#include <boost/intrusive/detail/workaround.hpp>
+
 namespace boost {
 namespace intrusive {
 namespace detail {
@@ -37,7 +39,7 @@ class equal_to_value
       :  t_(t)
    {}
 
-   bool operator()(ConstReference t)const
+   BOOST_INTRUSIVE_FORCEINLINE bool operator()(ConstReference t)const
    {  return t_ == t;   }
 };
 

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

@@ -21,6 +21,8 @@
 #  pragma once
 #endif
 
+#include <boost/intrusive/detail/workaround.hpp>
+
 namespace boost {
 namespace intrusive {
 namespace detail {
@@ -39,7 +41,7 @@ class exception_disposer
       :  cont_(&cont), disp_(disp)
    {}
 
-   void release()
+   BOOST_INTRUSIVE_FORCEINLINE void release()
    {  cont_ = 0;  }
 
    ~exception_disposer()
@@ -67,7 +69,7 @@ class exception_array_disposer
       :  cont_(&cont), disp_(disp), constructed_(constructed)
    {}
 
-   void release()
+   BOOST_INTRUSIVE_FORCEINLINE void release()
    {  cont_ = 0;  }
 
    ~exception_array_disposer()

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

@@ -26,6 +26,7 @@
 #include <boost/intrusive/detail/mpl.hpp>
 #include <boost/intrusive/detail/assert.hpp>
 #include <boost/intrusive/detail/node_holder.hpp>
+#include <boost/intrusive/detail/algo_type.hpp>
 #include <boost/static_assert.hpp>
 
 namespace boost {
@@ -120,7 +121,8 @@ struct hooktags_impl
 /// @endcond
 
 template
-   < class NodeAlgorithms
+   < boost::intrusive::algo_types Algo
+   , class NodeTraits
    , class Tag
    , link_mode_type LinkMode
    , base_hook_type BaseHookType
@@ -135,20 +137,20 @@ class generic_hook
    //from the hook.
    : public detail::if_c
       < detail::is_same<Tag, member_tag>::value
-      , typename NodeAlgorithms::node
-      , node_holder<typename NodeAlgorithms::node, Tag, BaseHookType>
+      , typename NodeTraits::node
+      , node_holder<typename NodeTraits::node, Tag, BaseHookType>
       >::type
    //If this is the a default-tagged base hook derive from a class that
    //will define an special internal typedef. Containers will be able to detect this
    //special typedef and obtain generic_hook's internal types in order to deduce
    //value_traits for this hook.
    , public hook_tags_definer
-      < generic_hook<NodeAlgorithms, Tag, LinkMode, BaseHookType>
-      , detail::is_same<Tag, dft_tag>::value*BaseHookType>
+      < generic_hook<Algo, NodeTraits, Tag, LinkMode, BaseHookType>
+      , detail::is_same<Tag, dft_tag>::value ? BaseHookType : NoBaseHookId>
    /// @endcond
 {
    /// @cond
-   typedef          NodeAlgorithms                    node_algorithms;
+   typedef typename get_algo<Algo, NodeTraits>::type  node_algorithms;
    typedef typename node_algorithms::node             node;
    typedef typename node_algorithms::node_ptr         node_ptr;
    typedef typename node_algorithms::const_node_ptr   const_node_ptr;
@@ -156,7 +158,7 @@ class generic_hook
    public:
 
    typedef hooktags_impl
-      < typename NodeAlgorithms::node_traits
+      < NodeTraits
       , Tag, LinkMode, BaseHookType>                  hooktags;
 
    node_ptr this_ptr()