passenger 6.0.8 → 6.0.9

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

@@ -83,10 +83,8 @@ struct bstree_node_checker
                      const return_type& check_return_left, const return_type& check_return_right,
                      return_type& check_return)
    {
-      if (check_return_left.max_key_node_ptr)
-         BOOST_INTRUSIVE_INVARIANT_ASSERT(!comp_(p, check_return_left.max_key_node_ptr));
-      if (check_return_right.min_key_node_ptr)
-         BOOST_INTRUSIVE_INVARIANT_ASSERT(!comp_(check_return_right.min_key_node_ptr, p));
+      BOOST_INTRUSIVE_INVARIANT_ASSERT(!check_return_left.max_key_node_ptr || !comp_(p, check_return_left.max_key_node_ptr));
+      BOOST_INTRUSIVE_INVARIANT_ASSERT(!check_return_right.min_key_node_ptr || !comp_(check_return_right.min_key_node_ptr, p));
       check_return.min_key_node_ptr = node_traits::get_left(p)? check_return_left.min_key_node_ptr : p;
       check_return.max_key_node_ptr = node_traits::get_right(p)? check_return_right.max_key_node_ptr : p;
       check_return.node_count = check_return_left.node_count + check_return_right.node_count + 1;
@@ -1014,7 +1012,8 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits>
       while(x){
          ++depth;
          y = x;
-         x = (left_child = comp(key, x)) ?
+         left_child = comp(key, x);
+         x = left_child ?
                NodeTraits::get_left(x) : (prev = y, NodeTraits::get_right(x));
       }
 

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

@@ -23,6 +23,7 @@
 
 #include <boost/config.hpp>
 #include <boost/core/no_exceptions_support.hpp>
+#include <boost/move/detail/placement_new.hpp>
 
 namespace boost {
 namespace intrusive {
@@ -55,7 +56,7 @@ class array_initializer
       std::size_t i = 0;
       BOOST_TRY{
          for(; i != N; ++i){
-            new(init_buf)T(init);
+            ::new(init_buf, boost_move_new_t()) T(init);
             init_buf += sizeof(T);
          }
       }

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

@@ -69,8 +69,7 @@ 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);
       }
       else if(NodeTraits::get_left(node)){
          return maximum(NodeTraits::get_left(node));

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

@@ -0,0 +1,94 @@
+// Copyright 2005-2014 Daniel James.
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+//  Based on Peter Dimov's proposal
+//  http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1756.pdf
+//  issue 6.18.
+//
+//  This also contains public domain code from MurmurHash. From the
+//  MurmurHash header:
+//
+// MurmurHash3 was written by Austin Appleby, and is placed in the public
+// domain. The author hereby disclaims copyright to this source code.
+//
+// Copyright 2021 Ion Gaztanaga
+// Refactored the original boost/container_hash/hash.hpp to avoid
+// any heavy std header dependencies to just combine two hash
+// values represented in a std::size_t type.
+
+#ifndef BOOST_INTRUSIVE_DETAIL_HASH_COMBINE_HPP
+#define BOOST_INTRUSIVE_DETAIL_HASH_COMBINE_HPP
+
+#ifndef BOOST_CONFIG_HPP
+#  include <boost/config.hpp>
+#endif
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#  pragma once
+#endif
+
+#include <boost/cstdint.hpp>
+
+#if defined(_MSC_VER)
+#  include <stdlib.h>
+#  define BOOST_INTRUSIVE_HASH_ROTL32(x, r) _rotl(x,r)
+#else
+#  define BOOST_INTRUSIVE_HASH_ROTL32(x, r) (x << r) | (x >> (32 - r))
+#endif
+
+namespace boost {
+namespace intrusive {
+namespace detail {
+
+template <typename SizeT>
+inline void hash_combine_size_t(SizeT& seed, SizeT value)
+{
+   seed ^= value + 0x9e3779b9 + (seed<<6) + (seed>>2);
+}
+
+inline void hash_combine_size_t(boost::uint32_t& h1,
+         boost::uint32_t k1)
+{
+   const uint32_t c1 = 0xcc9e2d51;
+   const uint32_t c2 = 0x1b873593;
+
+   k1 *= c1;
+   k1 = BOOST_INTRUSIVE_HASH_ROTL32(k1,15);
+   k1 *= c2;
+
+   h1 ^= k1;
+   h1 = BOOST_INTRUSIVE_HASH_ROTL32(h1,13);
+   h1 = h1*5+0xe6546b64;
+}
+
+
+   // Don't define 64-bit hash combine on platforms without 64 bit integers,
+   // and also not for 32-bit gcc as it warns about the 64-bit constant.
+   #if !defined(BOOST_NO_INT64_T) && \
+       !(defined(__GNUC__) && ULONG_MAX == 0xffffffff)
+   inline void hash_combine_size_t(boost::uint64_t& h,
+            boost::uint64_t k)
+   {
+      const boost::uint64_t m = UINT64_C(0xc6a4a7935bd1e995);
+      const int r = 47;
+
+      k *= m;
+      k ^= k >> r;
+      k *= m;
+
+      h ^= k;
+      h *= m;
+
+      // Completely arbitrary number, to prevent 0's
+      // from hashing to 0.
+      h += 0xe6546b64;
+   }
+
+   #endif // BOOST_NO_INT64_T
+
+}  //namespace detail {
+}  //namespace intrusive {
+}  //namespace boost {
+
+#endif   //BOOST_INTRUSIVE_DETAIL_HASH_COMBINE_HPP

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

@@ -76,8 +76,8 @@ namespace detail {
    inline std::size_t floor_log2 (std::size_t x)
    {
       unsigned long log2;
-      BOOST_INTRUSIVE_BSR_INTRINSIC( &log2, (unsigned long)x );
-      return log2;
+      BOOST_INTRUSIVE_BSR_INTRINSIC( &log2, x );
+      return static_cast<std::size_t>(log2);
    }
 
    #undef BOOST_INTRUSIVE_BSR_INTRINSIC

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

@@ -13,6 +13,8 @@
 #ifndef BOOST_INTRUSIVE_DETAIL_SIMPLE_DISPOSERS_HPP
 #define BOOST_INTRUSIVE_DETAIL_SIMPLE_DISPOSERS_HPP
 
+#include <boost/intrusive/detail/workaround.hpp>
+
 #ifndef BOOST_CONFIG_HPP
 #  include <boost/config.hpp>
 #endif

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

@@ -0,0 +1,49 @@
+/////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga  2014-2014
+//
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/intrusive for documentation.
+//
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_INTRUSIVE_DETAIL_TWIN_HPP
+#define BOOST_INTRUSIVE_DETAIL_TWIN_HPP
+
+#ifndef BOOST_CONFIG_HPP
+#  include <boost/config.hpp>
+#endif
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#  pragma once
+#endif
+
+//A tiny utility to avoid pulling std::pair / utility for
+//very simple algorithms/types
+
+namespace boost {
+namespace intrusive {
+
+template <class T>
+struct twin
+{
+   typedef T type;
+   twin()
+      : first(), second()
+   {}
+
+   twin(const type &f, const type &s)
+      : first(f), second(s)
+   {}
+
+   T first;
+   T second;
+};
+
+}  //namespace intrusive{
+}  //namespace boost{
+
+#endif //BOOST_INTRUSIVE_DETAIL_TWIN_HPP

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

@@ -0,0 +1,42 @@
+#ifndef BOOST_INTRUSIVE_DETAIL_VALUE_FUNCTORS_HPP
+#define BOOST_INTRUSIVE_DETAIL_VALUE_FUNCTORS_HPP
+///////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2017-2021. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/intrusive for documentation.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_CONFIG_HPP
+#  include <boost/config.hpp>
+#endif
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#  pragma once
+#endif
+
+namespace boost {
+namespace intrusive {
+
+//Functors for member algorithm defaults
+template<class ValueType>
+struct value_less
+{
+   bool operator()(const ValueType &a, const ValueType &b) const
+      {  return a < b;  }
+};
+
+template<class ValueType>
+struct value_equal
+{
+   bool operator()(const ValueType &a, const ValueType &b) const
+      {  return a == b;  }
+};
+
+}  //namespace intrusive {
+}  //namespace boost {
+
+#endif   //BOOST_INTRUSIVE_DETAIL_VALUE_FUNCTORS_HPP

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

@@ -35,7 +35,7 @@
 #include <boost/intrusive/detail/mpl.hpp>
 
 //boost
-#include <boost/functional/hash.hpp>
+#include <boost/container_hash/hash.hpp>
 #include <boost/intrusive/detail/assert.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/move/utility_core.hpp>

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

@@ -19,7 +19,7 @@
 #include <boost/intrusive/detail/common_slist_algorithms.hpp>
 #include <boost/intrusive/detail/algo_type.hpp>
 #include <cstddef>
-#include <boost/intrusive/detail/minimal_pair_header.hpp>   //std::pair
+#include <boost/intrusive/detail/twin.hpp>   //for node_pair
 
 #if defined(BOOST_HAS_PRAGMA_ONCE)
 #  pragma once
@@ -62,6 +62,12 @@ class linear_slist_algorithms
    typedef typename NodeTraits::node_ptr        node_ptr;
    typedef typename NodeTraits::const_node_ptr  const_node_ptr;
    typedef NodeTraits                           node_traits;
+   //A simple struct containing:
+   //
+   // typedef node_ptr type;
+   // node_ptr first;
+   // node_ptr second;
+   typedef twin<node_ptr>                  node_pair;
 
    #if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
 
@@ -222,9 +228,9 @@ class linear_slist_algorithms
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Linear to the number of elements plus the number moved positions.
-   static std::pair<node_ptr, node_ptr> move_first_n_backwards(node_ptr p, std::size_t n)
+   static node_pair move_first_n_backwards(node_ptr p, std::size_t n)
    {
-      std::pair<node_ptr, node_ptr> ret;
+      node_pair ret;
       //Null shift, or count() == 0 or 1, nothing to do
       if(!n || !p || !NodeTraits::get_next(p)){
          return ret;
@@ -277,9 +283,9 @@ class linear_slist_algorithms
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Linear to the number of elements plus the number moved positions.
-   static std::pair<node_ptr, node_ptr> move_first_n_forward(node_ptr p, std::size_t n)
+   static node_pair move_first_n_forward(node_ptr p, std::size_t n)
    {
-      std::pair<node_ptr, node_ptr> ret;
+      node_pair ret;
       //Null shift, or count() == 0 or 1, nothing to do
       if(!n || !p || !NodeTraits::get_next(p))
          return ret;

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

@@ -39,7 +39,7 @@
 #include <boost/move/utility_core.hpp>
 #include <boost/static_assert.hpp>
 
-#include <boost/intrusive/detail/minimal_less_equal_header.hpp>//std::less
+#include <boost/intrusive/detail/value_functors.hpp>
 #include <cstddef>   //std::size_t, etc.
 
 #if defined(BOOST_HAS_PRAGMA_ONCE)
@@ -988,19 +988,19 @@ class list_impl
       }
    }
 
-   //! <b>Effects</b>: This function sorts the list *this according to std::less<value_type>.
+   //! <b>Effects</b>: This function sorts the list *this according to operator <.
    //!   The sort is stable, that is, the relative order of equivalent elements is preserved.
    //!
    //! <b>Throws</b>: If value_traits::node_traits::node
    //!   constructor throws (this does not happen with predefined Boost.Intrusive hooks)
-   //!   or std::less<value_type> throws. Basic guarantee.
+   //!   or operator < throws. Basic guarantee.
    //!
    //! <b>Notes</b>: Iterators and references are not invalidated.
    //!
    //! <b>Complexity</b>: The number of comparisons is approximately N log N, where N
    //!   is the list's size.
    void sort()
-   {  this->sort(std::less<value_type>());  }
+   {  this->sort(value_less<value_type>());  }
 
    //! <b>Requires</b>: p must be a comparison function that induces a strict weak ordering
    //!
@@ -1043,18 +1043,18 @@ class list_impl
    }
 
    //! <b>Effects</b>: This function removes all of x's elements and inserts them
-   //!   in order into *this according to std::less<value_type>. The merge is stable;
+   //!   in order into *this according to operator <. The merge is stable;
    //!   that is, if an element from *this is equivalent to one from x, then the element
    //!   from *this will precede the one from x.
    //!
-   //! <b>Throws</b>: If std::less<value_type> throws. Basic guarantee.
+   //! <b>Throws</b>: If operator < throws. Basic guarantee.
    //!
    //! <b>Complexity</b>: This function is linear time: it performs at most
    //!   size() + x.size() - 1 comparisons.
    //!
    //! <b>Note</b>: Iterators and references are not invalidated
    void merge(list_impl& x)
-   { this->merge(x, std::less<value_type>()); }
+   { this->merge(x, value_less<value_type>()); }
 
    //! <b>Requires</b>: p must be a comparison function that induces a strict weak
    //!   ordering and both *this and x must be sorted according to that ordering
@@ -1108,21 +1108,21 @@ class list_impl
    //! <b>Effects</b>: Removes all the elements that compare equal to value.
    //!   No destructors are called.
    //!
-   //! <b>Throws</b>: If std::equal_to<value_type> throws. Basic guarantee.
+   //! <b>Throws</b>: If operator == throws. Basic guarantee.
    //!
    //! <b>Complexity</b>: Linear time. It performs exactly size() comparisons for equality.
    //!
    //! <b>Note</b>: The relative order of elements that are not removed is unchanged,
    //!   and iterators to elements that are not removed remain valid.
    void remove(const_reference value)
-   {  this->remove_if(detail::equal_to_value<const_reference>(value));  }
+   {  this->remove_if(value_equal<const_reference>(value));  }
 
    //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw.
    //!
    //! <b>Effects</b>: Removes all the elements that compare equal to value.
    //!   Disposer::operator()(pointer) is called for every removed element.
    //!
-   //! <b>Throws</b>: If std::equal_to<value_type> throws. Basic guarantee.
+   //! <b>Throws</b>: If operator == throws. Basic guarantee.
    //!
    //! <b>Complexity</b>: Linear time. It performs exactly size() comparisons for equality.
    //!
@@ -1130,7 +1130,7 @@ class list_impl
    //!   and iterators to elements that are not removed remain valid.
    template<class Disposer>
    void remove_and_dispose(const_reference value, Disposer disposer)
-   {  this->remove_and_dispose_if(detail::equal_to_value<const_reference>(value), disposer);  }
+   {  this->remove_and_dispose_if(value_equal<const_reference>(value), disposer);  }
 
    //! <b>Effects</b>: Removes all the elements for which a specified
    //!   predicate is satisfied. No destructors are called.

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

@@ -39,7 +39,6 @@
 #include <cstddef>
 #include <boost/intrusive/detail/minimal_less_equal_header.hpp>
 #include <boost/intrusive/detail/minimal_pair_header.hpp>   //std::pair
-#include <cmath>
 #include <cstddef>
 
 #if defined(BOOST_HAS_PRAGMA_ONCE)
@@ -447,8 +446,7 @@ class sgtree_impl
    iterator insert_equal(reference value)
    {
       node_ptr to_insert(this->get_value_traits().to_node_ptr(value));
-      if(safemode_or_autounlink)
-         BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
+      BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(!safemode_or_autounlink || node_algorithms::unique(to_insert));
       std::size_t max_tree_size = (std::size_t)this->max_tree_size_;
       node_ptr p = node_algorithms::insert_equal_upper_bound
          (this->tree_type::header_ptr(), to_insert, this->key_node_comp(this->key_comp())
@@ -462,8 +460,7 @@ class sgtree_impl
    iterator insert_equal(const_iterator hint, reference value)
    {
       node_ptr to_insert(this->get_value_traits().to_node_ptr(value));
-      if(safemode_or_autounlink)
-         BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
+      BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(!safemode_or_autounlink || node_algorithms::unique(to_insert));
       std::size_t max_tree_size = (std::size_t)this->max_tree_size_;
       node_ptr p = node_algorithms::insert_equal
          ( this->tree_type::header_ptr(), hint.pointed_node(), to_insert, this->key_node_comp(this->key_comp())
@@ -545,8 +542,7 @@ class sgtree_impl
    iterator insert_unique_commit(reference value, const insert_commit_data &commit_data)
    {
       node_ptr to_insert(this->get_value_traits().to_node_ptr(value));
-      if(safemode_or_autounlink)
-         BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
+      BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(!safemode_or_autounlink || node_algorithms::unique(to_insert));
       std::size_t max_tree_size = (std::size_t)this->max_tree_size_;
       node_algorithms::insert_unique_commit
          ( this->tree_type::header_ptr(), to_insert, commit_data
@@ -575,8 +571,7 @@ class sgtree_impl
    iterator insert_before(const_iterator pos, reference value)
    {
       node_ptr to_insert(this->get_value_traits().to_node_ptr(value));
-      if(safemode_or_autounlink)
-         BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
+      BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(!safemode_or_autounlink || node_algorithms::unique(to_insert));
       std::size_t max_tree_size = (std::size_t)this->max_tree_size_;
       node_ptr p = node_algorithms::insert_before
          ( this->tree_type::header_ptr(), pos.pointed_node(), to_insert
@@ -590,8 +585,7 @@ class sgtree_impl
    void push_back(reference value)
    {
       node_ptr to_insert(this->get_value_traits().to_node_ptr(value));
-      if(safemode_or_autounlink)
-         BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
+      BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(!safemode_or_autounlink || node_algorithms::unique(to_insert));
       std::size_t max_tree_size = (std::size_t)this->max_tree_size_;
       node_algorithms::push_back
          ( this->tree_type::header_ptr(), to_insert
@@ -604,8 +598,7 @@ class sgtree_impl
    void push_front(reference value)
    {
       node_ptr to_insert(this->get_value_traits().to_node_ptr(value));
-      if(safemode_or_autounlink)
-         BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(to_insert));
+      BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(!safemode_or_autounlink || node_algorithms::unique(to_insert));
       std::size_t max_tree_size = (std::size_t)this->max_tree_size_;
       node_algorithms::push_front
          ( this->tree_type::header_ptr(), to_insert
@@ -621,8 +614,7 @@ class sgtree_impl
       const_iterator ret(i);
       ++ret;
       node_ptr to_erase(i.pointed_node());
-      if(safemode_or_autounlink)
-         BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(!node_algorithms::unique(to_erase));
+      BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(!safemode_or_autounlink || !node_algorithms::unique(to_erase));
       std::size_t max_tree_size = this->max_tree_size_;
       node_algorithms::erase
          ( this->tree_type::header_ptr(), to_erase, (std::size_t)this->size()