passenger 6.0.8 → 6.0.12

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

@@ -72,7 +72,7 @@ class circular_slist_algorithms
    //! <b>Complexity</b>: Constant
    //!
    //! <b>Throws</b>: Nothing.
-   static void init(node_ptr this_node);
+   static void init(node_ptr this_node) BOOST_NOEXCEPT;
 
    //! <b>Requires</b>: this_node must be in a circular list or be an empty circular list.
    //!
@@ -83,7 +83,7 @@ class circular_slist_algorithms
    //! <b>Complexity</b>: Constant
    //!
    //! <b>Throws</b>: Nothing.
-   static bool unique(const_node_ptr this_node);
+   static bool unique(const_node_ptr this_node) BOOST_NOEXCEPT;
 
    //! <b>Effects</b>: Returns true is "this_node" has the same state as
    //!  if it was inited using "init(node_ptr)"
@@ -91,7 +91,7 @@ class circular_slist_algorithms
    //! <b>Complexity</b>: Constant
    //!
    //! <b>Throws</b>: Nothing.
-   static bool inited(const_node_ptr this_node);
+   static bool inited(const_node_ptr this_node) BOOST_NOEXCEPT;
 
    //! <b>Requires</b>: prev_node must be in a circular list or be an empty circular list.
    //!
@@ -100,7 +100,7 @@ class circular_slist_algorithms
    //! <b>Complexity</b>: Constant
    //!
    //! <b>Throws</b>: Nothing.
-   static void unlink_after(node_ptr prev_node);
+   static void unlink_after(node_ptr prev_node) BOOST_NOEXCEPT;
 
    //! <b>Requires</b>: prev_node and last_node must be in a circular list
    //!  or be an empty circular list.
@@ -110,7 +110,7 @@ class circular_slist_algorithms
    //! <b>Complexity</b>: Constant
    //!
    //! <b>Throws</b>: Nothing.
-   static void unlink_after(node_ptr prev_node, node_ptr last_node);
+   static void unlink_after(node_ptr prev_node, node_ptr last_node) BOOST_NOEXCEPT;
 
    //! <b>Requires</b>: prev_node must be a node of a circular list.
    //!
@@ -119,7 +119,7 @@ class circular_slist_algorithms
    //! <b>Complexity</b>: Constant
    //!
    //! <b>Throws</b>: Nothing.
-   static void link_after(node_ptr prev_node, node_ptr this_node);
+   static void link_after(node_ptr prev_node, node_ptr this_node) BOOST_NOEXCEPT;
 
    //! <b>Requires</b>: b and e must be nodes of the same circular list or an empty range.
    //!   and p must be a node of a different circular list.
@@ -130,7 +130,7 @@ class circular_slist_algorithms
    //! <b>Complexity</b>: Constant
    //!
    //! <b>Throws</b>: Nothing.
-   static void transfer_after(node_ptr p, node_ptr b, node_ptr e);
+   static void transfer_after(node_ptr p, node_ptr b, node_ptr e) BOOST_NOEXCEPT;
 
    #endif   //#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
 
@@ -141,7 +141,7 @@ class circular_slist_algorithms
    //! <b>Complexity</b>: Constant
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static void init_header(node_ptr this_node)
+   BOOST_INTRUSIVE_FORCEINLINE static void init_header(node_ptr this_node) BOOST_NOEXCEPT
    {  NodeTraits::set_next(this_node, this_node);  }
 
    //! <b>Requires</b>: this_node and prev_init_node must be in the same circular list.
@@ -153,7 +153,7 @@ class circular_slist_algorithms
    //! <b>Complexity</b>: Linear to the number of elements between prev_init_node and this_node.
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_previous_node(const node_ptr &prev_init_node, const node_ptr &this_node)
+   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_previous_node(const node_ptr &prev_init_node, const node_ptr &this_node) BOOST_NOEXCEPT
    {  return base_t::get_previous_node(prev_init_node, this_node);   }
 
    //! <b>Requires</b>: this_node must be in a circular list or be an empty circular list.
@@ -163,7 +163,7 @@ class circular_slist_algorithms
    //! <b>Complexity</b>: Linear to the number of elements in the circular list.
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_previous_node(const node_ptr & this_node)
+   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_previous_node(const node_ptr & this_node) BOOST_NOEXCEPT
    {  return base_t::get_previous_node(this_node, this_node); }
 
    //! <b>Requires</b>: this_node must be in a circular list or be an empty circular list.
@@ -173,7 +173,7 @@ class circular_slist_algorithms
    //! <b>Complexity</b>: Linear to the number of elements in the circular list.
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_previous_previous_node(const node_ptr & this_node)
+   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_previous_previous_node(const node_ptr & this_node) BOOST_NOEXCEPT
    {  return get_previous_previous_node(this_node, this_node); }
 
    //! <b>Requires</b>: this_node and p must be in the same circular list.
@@ -185,7 +185,7 @@ class circular_slist_algorithms
    //! <b>Complexity</b>: Linear to the number of elements in the circular list.
    //!
    //! <b>Throws</b>: Nothing.
-   static node_ptr get_previous_previous_node(node_ptr p, const node_ptr & this_node)
+   static node_ptr get_previous_previous_node(node_ptr p, const node_ptr & this_node) BOOST_NOEXCEPT
    {
       node_ptr p_next = NodeTraits::get_next(p);
       node_ptr p_next_next = NodeTraits::get_next(p_next);
@@ -205,7 +205,7 @@ class circular_slist_algorithms
    //! <b>Complexity</b>: Linear
    //!
    //! <b>Throws</b>: Nothing.
-   static std::size_t count(const const_node_ptr & this_node)
+   static std::size_t count(const const_node_ptr & this_node) BOOST_NOEXCEPT
    {
       std::size_t result = 0;
       const_node_ptr p = this_node;
@@ -223,7 +223,7 @@ class circular_slist_algorithms
    //! <b>Complexity</b>: Linear to the number of elements in the circular list
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static void unlink(node_ptr this_node)
+   BOOST_INTRUSIVE_FORCEINLINE static void unlink(node_ptr this_node) BOOST_NOEXCEPT
    {
       if(NodeTraits::get_next(this_node))
          base_t::unlink_after(get_previous_node(this_node));
@@ -236,7 +236,7 @@ class circular_slist_algorithms
    //! <b>Complexity</b>: Linear to the number of elements in the circular list.
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static void link_before (node_ptr nxt_node, node_ptr this_node)
+   BOOST_INTRUSIVE_FORCEINLINE static void link_before (node_ptr nxt_node, node_ptr this_node) BOOST_NOEXCEPT
    {  base_t::link_after(get_previous_node(nxt_node), this_node);   }
 
    //! <b>Requires</b>: this_node and other_node must be nodes inserted
@@ -249,7 +249,7 @@ class circular_slist_algorithms
    //! <b>Complexity</b>: Linear to number of elements of both lists
    //!
    //! <b>Throws</b>: Nothing.
-   static void swap_nodes(node_ptr this_node, node_ptr other_node)
+   static void swap_nodes(node_ptr this_node, node_ptr other_node) BOOST_NOEXCEPT
    {
       if (other_node == this_node)
          return;
@@ -275,7 +275,7 @@ class circular_slist_algorithms
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: This function is linear to the contained elements.
-   static void reverse(node_ptr p)
+   static void reverse(node_ptr p) BOOST_NOEXCEPT
    {
       node_ptr i = NodeTraits::get_next(p), e(p);
       for (;;) {
@@ -294,7 +294,7 @@ class circular_slist_algorithms
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Linear to the number of elements plus the number moved positions.
-   static node_ptr move_backwards(node_ptr p, std::size_t n)
+   static node_ptr move_backwards(node_ptr p, std::size_t n) BOOST_NOEXCEPT
    {
       //Null shift, nothing to do
       if(!n) return node_ptr();
@@ -346,7 +346,7 @@ class circular_slist_algorithms
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Linear to the number of elements plus the number moved positions.
-   static node_ptr move_forward(node_ptr p, std::size_t n)
+   static node_ptr move_forward(node_ptr p, std::size_t n) BOOST_NOEXCEPT
    {
       //Null shift, nothing to do
       if(!n) return node_ptr();

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

@@ -52,18 +52,18 @@ struct derivation_value_traits
       pointer_traits<const_pointer>::reference                       const_reference;
    static const link_mode_type link_mode = LinkMode;
 
-   static node_ptr to_node_ptr(reference value)
+   BOOST_INTRUSIVE_FORCEINLINE static node_ptr to_node_ptr(reference value) BOOST_NOEXCEPT
    { return node_ptr(&value); }
 
-   static const_node_ptr to_node_ptr(const_reference value)
+   BOOST_INTRUSIVE_FORCEINLINE static const_node_ptr to_node_ptr(const_reference value) BOOST_NOEXCEPT
    { return node_ptr(&value); }
 
-   static pointer to_value_ptr(const node_ptr &n)
+   BOOST_INTRUSIVE_FORCEINLINE static pointer to_value_ptr(const node_ptr &n) BOOST_NOEXCEPT
    {
       return pointer_traits<pointer>::pointer_to(static_cast<reference>(*n));
    }
 
-   static const_pointer to_value_ptr(const const_node_ptr &n)
+   BOOST_INTRUSIVE_FORCEINLINE static const_pointer to_value_ptr(const const_node_ptr &n) BOOST_NOEXCEPT
    {
       return pointer_traits<const_pointer>::pointer_to(static_cast<const_reference>(*n));
    }

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

@@ -252,7 +252,7 @@ class any_algorithms
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Nodes</b>: If node is inserted in a tree, this function corrupts the tree.
-   BOOST_INTRUSIVE_FORCEINLINE static void init(const node_ptr & node)
+   BOOST_INTRUSIVE_FORCEINLINE static void init(const node_ptr & node) BOOST_NOEXCEPT
    {  node->node_ptr_1 = node_ptr();   };
 
    //! <b>Effects</b>: Returns true if node is in the same state as if called init(node)
@@ -263,7 +263,7 @@ class any_algorithms
    BOOST_INTRUSIVE_FORCEINLINE static bool inited(const const_node_ptr & node)
    {  return !node->node_ptr_1;  };
 
-   BOOST_INTRUSIVE_FORCEINLINE static bool unique(const const_node_ptr & node)
+   BOOST_INTRUSIVE_FORCEINLINE static bool unique(const const_node_ptr & node) BOOST_NOEXCEPT
    {  return !node->node_ptr_1; }
 
    static void unlink(const node_ptr &)

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

@@ -42,7 +42,7 @@ class bstree_algorithms_base
    //! <b>Complexity</b>: Average constant time.
    //!
    //! <b>Throws</b>: Nothing.
-   static node_ptr next_node(const node_ptr & node)
+   static node_ptr next_node(const node_ptr & node) BOOST_NOEXCEPT
    {
       node_ptr const n_right(NodeTraits::get_right(node));
       if(n_right){
@@ -66,11 +66,10 @@ class bstree_algorithms_base
    //! <b>Complexity</b>: Average constant time.
    //!
    //! <b>Throws</b>: Nothing.
-   static node_ptr prev_node(const node_ptr & node)
+   static node_ptr prev_node(const node_ptr & node) BOOST_NOEXCEPT
    {
       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));
@@ -127,7 +126,7 @@ class bstree_algorithms_base
    //! <b>Complexity</b>: Constant.
    //!
    //! <b>Throws</b>: Nothing.
-   static bool is_header(const const_node_ptr & p)
+   static bool is_header(const const_node_ptr & p) BOOST_NOEXCEPT
    {
       node_ptr p_left (NodeTraits::get_left(p));
       node_ptr p_right(NodeTraits::get_right(p));

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

@@ -52,7 +52,7 @@ class common_slist_algorithms
       return p;
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE static void init(node_ptr this_node)
+   BOOST_INTRUSIVE_FORCEINLINE static void init(node_ptr this_node) BOOST_NOEXCEPT
    {  NodeTraits::set_next(this_node, node_ptr());  }
 
    BOOST_INTRUSIVE_FORCEINLINE static bool unique(const const_node_ptr & this_node)
@@ -64,16 +64,16 @@ class common_slist_algorithms
    BOOST_INTRUSIVE_FORCEINLINE static bool inited(const const_node_ptr & this_node)
    {  return !NodeTraits::get_next(this_node); }
 
-   BOOST_INTRUSIVE_FORCEINLINE static void unlink_after(node_ptr prev_node)
+   BOOST_INTRUSIVE_FORCEINLINE static void unlink_after(node_ptr prev_node) BOOST_NOEXCEPT
    {
       const_node_ptr this_node(NodeTraits::get_next(prev_node));
       NodeTraits::set_next(prev_node, NodeTraits::get_next(this_node));
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE static void unlink_after(node_ptr prev_node, node_ptr last_node)
+   BOOST_INTRUSIVE_FORCEINLINE static void unlink_after(node_ptr prev_node, node_ptr last_node) BOOST_NOEXCEPT
    {  NodeTraits::set_next(prev_node, last_node);  }
 
-   BOOST_INTRUSIVE_FORCEINLINE static void link_after(node_ptr prev_node, node_ptr this_node)
+   BOOST_INTRUSIVE_FORCEINLINE static void link_after(node_ptr prev_node, node_ptr this_node) BOOST_NOEXCEPT
    {
       NodeTraits::set_next(this_node, NodeTraits::get_next(prev_node));
       NodeTraits::set_next(prev_node, this_node);
@@ -167,7 +167,7 @@ class common_slist_algorithms
    //! <b>Complexity</b>: Linear
    //!
    //! <b>Throws</b>: Nothing.
-   static std::size_t distance(const const_node_ptr &f, const const_node_ptr &l)
+   static std::size_t distance(const const_node_ptr &f, const const_node_ptr &l) BOOST_NOEXCEPT
    {
       const_node_ptr i(f);
       std::size_t result = 0;

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

@@ -17,6 +17,7 @@
 #ifdef BOOST_MSVC
 
    #pragma warning (push)
+   #pragma warning (disable : 4619) // there is no warning number 'XXXX'
    #pragma warning (disable : 4275) // non DLL-interface classkey "identifier" used as base for DLL-interface classkey "identifier"
    #pragma warning (disable : 4251) // "identifier" : class "type" needs to have dll-interface to be used by clients of class "type2"
    #pragma warning (disable : 4675) // "method" should be declared "static" and have exactly one parameter

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

@@ -161,30 +161,30 @@ class generic_hook
       < NodeTraits
       , Tag, LinkMode, BaseHookType>                  hooktags;
 
-   BOOST_INTRUSIVE_FORCEINLINE node_ptr this_ptr()
+   BOOST_INTRUSIVE_FORCEINLINE node_ptr this_ptr() BOOST_NOEXCEPT
    {  return pointer_traits<node_ptr>::pointer_to(static_cast<node&>(*this)); }
 
-   BOOST_INTRUSIVE_FORCEINLINE const_node_ptr this_ptr() const
+   BOOST_INTRUSIVE_FORCEINLINE const_node_ptr this_ptr() const BOOST_NOEXCEPT
    {  return pointer_traits<const_node_ptr>::pointer_to(static_cast<const node&>(*this)); }
 
    public:
    /// @endcond
 
-   BOOST_INTRUSIVE_FORCEINLINE generic_hook()
+   BOOST_INTRUSIVE_FORCEINLINE generic_hook() BOOST_NOEXCEPT
    {
       if(hooktags::safemode_or_autounlink){
          node_algorithms::init(this->this_ptr());
       }
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE generic_hook(const generic_hook& )
+   BOOST_INTRUSIVE_FORCEINLINE generic_hook(const generic_hook& ) BOOST_NOEXCEPT
    {
       if(hooktags::safemode_or_autounlink){
          node_algorithms::init(this->this_ptr());
       }
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE generic_hook& operator=(const generic_hook& )
+   BOOST_INTRUSIVE_FORCEINLINE generic_hook& operator=(const generic_hook& ) BOOST_NOEXCEPT
    {  return *this;  }
 
    BOOST_INTRUSIVE_FORCEINLINE ~generic_hook()
@@ -193,20 +193,20 @@ class generic_hook
          (*this, detail::link_dispatch<hooktags::link_mode>());
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE void swap_nodes(generic_hook &other)
+   BOOST_INTRUSIVE_FORCEINLINE void swap_nodes(generic_hook &other) BOOST_NOEXCEPT
    {
       node_algorithms::swap_nodes
          (this->this_ptr(), other.this_ptr());
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE bool is_linked() const
+   BOOST_INTRUSIVE_FORCEINLINE bool is_linked() const BOOST_NOEXCEPT
    {
       //is_linked() can be only used in safe-mode or auto-unlink
       BOOST_STATIC_ASSERT(( hooktags::safemode_or_autounlink ));
       return !node_algorithms::unique(this->this_ptr());
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE void unlink()
+   BOOST_INTRUSIVE_FORCEINLINE void unlink() BOOST_NOEXCEPT
    {
       BOOST_STATIC_ASSERT(( (int)hooktags::link_mode == (int)auto_unlink ));
       node_ptr n(this->this_ptr());

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

@@ -0,0 +1,92 @@
+// 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/hashtable_node.hpp

@@ -101,7 +101,7 @@ struct bucket_traits_impl
    BOOST_INTRUSIVE_FORCEINLINE const bucket_ptr &bucket_begin() const
    {  return buckets_;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE size_type  bucket_count() const
+   BOOST_INTRUSIVE_FORCEINLINE size_type  bucket_count() const BOOST_NOEXCEPT
    {  return buckets_len_;  }
 
    private:

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
@@ -150,53 +150,6 @@ namespace detail {
       return log2;
    }
 
-   ////////////////////////////
-   // DeBruijn method
-   ////////////////////////////
-
-   //Taken from:
-   //http://stackoverflow.com/questions/11376288/fast-computing-of-log2-for-64-bit-integers
-   //Thanks to Desmond Hume
-
-   inline std::size_t floor_log2 (std::size_t v, integral_constant<std::size_t, 32>)
-   {
-      static const int MultiplyDeBruijnBitPosition[32] =
-      {
-         0, 9, 1, 10, 13, 21, 2, 29, 11, 14, 16, 18, 22, 25, 3, 30,
-         8, 12, 20, 28, 15, 17, 24, 7, 19, 27, 23, 6, 26, 5, 4, 31
-      };
-
-      v |= v >> 1;
-      v |= v >> 2;
-      v |= v >> 4;
-      v |= v >> 8;
-      v |= v >> 16;
-
-      return MultiplyDeBruijnBitPosition[(std::size_t)(v * 0x07C4ACDDU) >> 27];
-   }
-
-   inline std::size_t floor_log2 (std::size_t v, integral_constant<std::size_t, 64>)
-   {
-      static const std::size_t MultiplyDeBruijnBitPosition[64] = {
-      63,  0, 58,  1, 59, 47, 53,  2,
-      60, 39, 48, 27, 54, 33, 42,  3,
-      61, 51, 37, 40, 49, 18, 28, 20,
-      55, 30, 34, 11, 43, 14, 22,  4,
-      62, 57, 46, 52, 38, 26, 32, 41,
-      50, 36, 17, 19, 29, 10, 13, 21,
-      56, 45, 25, 31, 35, 16,  9, 12,
-      44, 24, 15,  8, 23,  7,  6,  5};
-
-      v |= v >> 1;
-      v |= v >> 2;
-      v |= v >> 4;
-      v |= v >> 8;
-      v |= v >> 16;
-      v |= v >> 32;
-      return MultiplyDeBruijnBitPosition[((std::size_t)((v - (v >> 1))*0x07EDD5E59A4E28C2ULL)) >> 58];
-   }
-
-
    inline std::size_t floor_log2 (std::size_t x)
    {
       const std::size_t Bits = sizeof(std::size_t)*CHAR_BIT;
@@ -209,13 +162,12 @@ namespace detail {
 //http://www.flipcode.com/archives/Fast_log_Function.shtml
 inline float fast_log2 (float val)
 {
-   float f = val;
    unsigned x;
-   std::memcpy(&x, &val, sizeof(f));
+   std::memcpy(&x, &val, sizeof(float));
    const int log_2 = int((x >> 23) & 255) - 128;
    x &= ~(unsigned(255u) << 23u);
    x += unsigned(127) << 23u;
-   std::memcpy(&val, &x, sizeof(f));
+   std::memcpy(&val, &x, sizeof(float));
    //1+log2(m), m ranging from 1 to 2
    //3rd degree polynomial keeping first derivate continuity.
    //For less precision the line can be commented out

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

@@ -91,7 +91,7 @@ struct node_disposer
 
    BOOST_INTRUSIVE_FORCEINLINE void operator()(const node_ptr & p)
    {
-      if(safemode_or_autounlink)
+      BOOST_IF_CONSTEXPR(safemode_or_autounlink)
          node_algorithms::init(p);
       base_t::get()(traits_->to_value_ptr(p));
    }

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