passenger 6.0.16 → 6.0.18

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

@@ -218,13 +218,13 @@ class avltree_algorithms
    }
 
    //! @copydoc ::boost::intrusive::bstree_algorithms::unlink(node_ptr)
-   static void unlink(node_ptr node) BOOST_NOEXCEPT
+   static void unlink(node_ptr n) BOOST_NOEXCEPT
    {
-      node_ptr x = NodeTraits::get_parent(node);
+      node_ptr x = NodeTraits::get_parent(n);
       if(x){
          while(!is_header(x))
             x = NodeTraits::get_parent(x);
-         erase(x, node);
+         erase(x, n);
       }
    }
 
@@ -233,22 +233,22 @@ class avltree_algorithms
    static node_ptr unlink_leftmost_without_rebalance(node_ptr header) BOOST_NOEXCEPT;
 
    //! @copydoc ::boost::intrusive::bstree_algorithms::unique(const_node_ptr)
-   static bool unique(const_node_ptr node) BOOST_NOEXCEPT;
+   static bool unique(const_node_ptr n) BOOST_NOEXCEPT;
 
    //! @copydoc ::boost::intrusive::bstree_algorithms::size(const_node_ptr)
    static std::size_t size(const_node_ptr header) BOOST_NOEXCEPT;
 
    //! @copydoc ::boost::intrusive::bstree_algorithms::next_node(node_ptr)
-   static node_ptr next_node(node_ptr node) BOOST_NOEXCEPT;
+   static node_ptr next_node(node_ptr n) BOOST_NOEXCEPT;
 
    //! @copydoc ::boost::intrusive::bstree_algorithms::prev_node(node_ptr)
-   static node_ptr prev_node(node_ptr node) BOOST_NOEXCEPT;
+   static node_ptr prev_node(node_ptr n) BOOST_NOEXCEPT;
 
    //! @copydoc ::boost::intrusive::bstree_algorithms::init(node_ptr)
-   static void init(node_ptr node) BOOST_NOEXCEPT;
+   static void init(node_ptr n) BOOST_NOEXCEPT;
    #endif   //#ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
 
-   //! <b>Requires</b>: node must not be part of any tree.
+   //! <b>Requires</b>: header must not be part of any tree.
    //!
    //! <b>Effects</b>: Initializes the header to represent an empty tree.
    //!   unique(header) == true.
@@ -257,7 +257,7 @@ class avltree_algorithms
    //!
    //! <b>Throws</b>: Nothing.
    //!
-   //! <b>Nodes</b>: If node is inserted in a tree, this function corrupts the tree.
+   //! <b>Nodes</b>: If header is inserted in a tree, this function corrupts the tree.
    static void init_header(node_ptr header) BOOST_NOEXCEPT
    {
       bstree_algo::init_header(header);

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

@@ -239,7 +239,7 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits>
       return p ? p : detail::uncast(header);
    }
 
-   //! <b>Requires</b>: 'node' is a node of the tree or a node initialized
+   //! <b>Requires</b>: 'n' is a node of the tree or a node initialized
    //!   by init(...) or init_node.
    //!
    //! <b>Effects</b>: Returns true if the node is initialized by init() or init_node().
@@ -247,18 +247,18 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits>
    //! <b>Complexity</b>: Constant time.
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static bool unique(const_node_ptr node) BOOST_NOEXCEPT
-   { return !NodeTraits::get_parent(node); }
+   BOOST_INTRUSIVE_FORCEINLINE static bool unique(const_node_ptr n) BOOST_NOEXCEPT
+   { return !NodeTraits::get_parent(n); }
 
    #if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
-   //! <b>Requires</b>: 'node' is a node of the tree or a header node.
+   //! <b>Requires</b>: 'n' is a node of the tree or a header node.
    //!
    //! <b>Effects</b>: Returns the header of the tree.
    //!
    //! <b>Complexity</b>: Logarithmic.
    //!
    //! <b>Throws</b>: Nothing.
-   static node_ptr get_header(const_node_ptr node);
+   static node_ptr get_header(const_node_ptr n);
    #endif
 
    //! <b>Requires</b>: node1 and node2 can't be header nodes
@@ -518,44 +518,44 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits>
    }
 
    #if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
-   //! <b>Requires</b>: 'node' is a node from the tree except the header.
+   //! <b>Requires</b>: 'n' is a node from the tree except the header.
    //!
    //! <b>Effects</b>: Returns the next node of the tree.
    //!
    //! <b>Complexity</b>: Average constant time.
    //!
    //! <b>Throws</b>: Nothing.
-   static node_ptr next_node(node_ptr node) BOOST_NOEXCEPT;
+   static node_ptr next_node(node_ptr n) BOOST_NOEXCEPT;
 
-   //! <b>Requires</b>: 'node' is a node from the tree except the leftmost node.
+   //! <b>Requires</b>: 'n' is a node from the tree except the leftmost node.
    //!
    //! <b>Effects</b>: Returns the previous node of the tree.
    //!
    //! <b>Complexity</b>: Average constant time.
    //!
    //! <b>Throws</b>: Nothing.
-   static node_ptr prev_node(node_ptr node) BOOST_NOEXCEPT;
+   static node_ptr prev_node(node_ptr n) BOOST_NOEXCEPT;
 
-   //! <b>Requires</b>: 'node' is a node of a tree but not the header.
+   //! <b>Requires</b>: 'n' is a node of a tree but not the header.
    //!
    //! <b>Effects</b>: Returns the minimum node of the subtree starting at p.
    //!
    //! <b>Complexity</b>: Logarithmic to the size of the subtree.
    //!
    //! <b>Throws</b>: Nothing.
-   static node_ptr minimum(node_ptr node);
+   static node_ptr minimum(node_ptr n);
 
-   //! <b>Requires</b>: 'node' is a node of a tree but not the header.
+   //! <b>Requires</b>: 'n' is a node of a tree but not the header.
    //!
    //! <b>Effects</b>: Returns the maximum node of the subtree starting at p.
    //!
    //! <b>Complexity</b>: Logarithmic to the size of the subtree.
    //!
    //! <b>Throws</b>: Nothing.
-   static node_ptr maximum(node_ptr node);
+   static node_ptr maximum(node_ptr n);
    #endif
 
-   //! <b>Requires</b>: 'node' must not be part of any tree.
+   //! <b>Requires</b>: 'n' must not be part of any tree.
    //!
    //! <b>Effects</b>: After the function unique(node) == true.
    //!
@@ -564,11 +564,11 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits>
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Nodes</b>: If node is inserted in a tree, this function corrupts the tree.
-   static void init(node_ptr node) BOOST_NOEXCEPT
+   static void init(node_ptr n) BOOST_NOEXCEPT
    {
-      NodeTraits::set_parent(node, node_ptr());
-      NodeTraits::set_left(node, node_ptr());
-      NodeTraits::set_right(node, node_ptr());
+      NodeTraits::set_parent(n, node_ptr());
+      NodeTraits::set_left(n, node_ptr());
+      NodeTraits::set_right(n, node_ptr());
    }
 
    //! <b>Effects</b>: Returns true if node is in the same state as if called init(node)
@@ -576,14 +576,14 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits>
    //! <b>Complexity</b>: Constant.
    //!
    //! <b>Throws</b>: Nothing.
-   static bool inited(const_node_ptr node)
+   static bool inited(const_node_ptr n)
    {
-      return !NodeTraits::get_parent(node) &&
-             !NodeTraits::get_left(node)   &&
-             !NodeTraits::get_right(node)  ;
+      return !NodeTraits::get_parent(n) &&
+             !NodeTraits::get_left(n)   &&
+             !NodeTraits::get_right(n)  ;
    }
 
-   //! <b>Requires</b>: node must not be part of any tree.
+   //! <b>Requires</b>: header must not be part of any tree.
    //!
    //! <b>Effects</b>: Initializes the header to represent an empty tree.
    //!   unique(header) == true.
@@ -592,7 +592,7 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits>
    //!
    //! <b>Throws</b>: Nothing.
    //!
-   //! <b>Nodes</b>: If node is inserted in a tree, this function corrupts the tree.
+   //! <b>Nodes</b>: If header is inserted in a tree, this function corrupts the tree.
    static void init_header(node_ptr header) BOOST_NOEXCEPT
    {
       NodeTraits::set_parent(header, node_ptr());
@@ -664,9 +664,9 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits>
       return leftmost;
    }
 
-   //! <b>Requires</b>: node is a node of the tree but it's not the header.
+   //! <b>Requires</b>: 'header' the header of the tree.
    //!
-   //! <b>Effects</b>: Returns the number of nodes of the subtree.
+   //! <b>Effects</b>: Returns the number of nodes of the tree.
    //!
    //! <b>Complexity</b>: Linear time.
    //!
@@ -1259,7 +1259,7 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits>
       insert_commit(header, new_node, commit_data);
    }
 
-   //! <b>Requires</b>: 'node' can't be a header node.
+   //! <b>Requires</b>: 'n' can't be a header node.
    //!
    //! <b>Effects</b>: Calculates the depth of a node: the depth of a
    //! node is the length (number of edges) of the path from the root
@@ -1268,13 +1268,13 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits>
    //! <b>Complexity</b>: Logarithmic to the number of nodes in the tree.
    //!
    //! <b>Throws</b>: Nothing.
-   static std::size_t depth(const_node_ptr node) BOOST_NOEXCEPT
+   static std::size_t depth(const_node_ptr n) BOOST_NOEXCEPT
    {
       std::size_t depth = 0;
       node_ptr p_parent;
-      while(node != NodeTraits::get_parent(p_parent = NodeTraits::get_parent(node))){
+      while(n != NodeTraits::get_parent(p_parent = NodeTraits::get_parent(n))){
          ++depth;
-         node = p_parent;
+         n = p_parent;
       }
       return depth;
    }
@@ -1365,20 +1365,20 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits>
       transfer_equal(header1, comp, header2, z, ignored);
    }
 
-   //! <b>Requires</b>: node is a tree node but not the header.
+   //! <b>Requires</b>: 'n' is a tree node but not the header.
    //!
    //! <b>Effects</b>: Unlinks the node and rebalances the tree.
    //!
    //! <b>Complexity</b>: Average complexity is constant time.
    //!
    //! <b>Throws</b>: Nothing.
-   static void unlink(node_ptr node) BOOST_NOEXCEPT
+   static void unlink(node_ptr n) BOOST_NOEXCEPT
    {
-      node_ptr x = NodeTraits::get_parent(node);
+      node_ptr x = NodeTraits::get_parent(n);
       if(x){
          while(!base_type::is_header(x))
             x = NodeTraits::get_parent(x);
-         erase(x, node);
+         erase(x, n);
       }
    }
 
@@ -1585,7 +1585,7 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits>
       info.x_parent = x_parent;
    }
 
-   //! <b>Requires</b>: node is a node of the tree but it's not the header.
+   //! <b>Requires</b>: 'subtree' is a node of the tree but it's not the header.
    //!
    //! <b>Effects</b>: Returns the number of nodes of the subtree.
    //!
@@ -1916,10 +1916,10 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits>
    //! <b>Complexity</b>: Logarithmic.
    //!
    //! <b>Throws</b>: Nothing.
-   static node_ptr get_root(node_ptr node) BOOST_NOEXCEPT
+   static node_ptr get_root(node_ptr n) BOOST_NOEXCEPT
    {
-      BOOST_INTRUSIVE_INVARIANT_ASSERT((!inited(node)));
-      node_ptr x = NodeTraits::get_parent(node);
+      BOOST_INTRUSIVE_INVARIANT_ASSERT((!inited(n)));
+      node_ptr x = NodeTraits::get_parent(n);
       if(x){
          while(!base_type::is_header(x)){
             x = NodeTraits::get_parent(x);
@@ -1927,7 +1927,7 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits>
          return x;
       }
       else{
-         return node;
+         return n;
       }
    }
 
@@ -2059,23 +2059,23 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits>
    }
 
    template<class Checker>
-   static void check_subtree(const_node_ptr node, Checker checker, typename Checker::return_type& check_return)
+   static void check_subtree(const_node_ptr n, Checker checker, typename Checker::return_type& check_return)
    {
-      const_node_ptr left = NodeTraits::get_left(node);
-      const_node_ptr right = NodeTraits::get_right(node);
+      const_node_ptr left = NodeTraits::get_left(n);
+      const_node_ptr right = NodeTraits::get_right(n);
       typename Checker::return_type check_return_left;
       typename Checker::return_type check_return_right;
       if (left)
       {
-         BOOST_INTRUSIVE_INVARIANT_ASSERT(NodeTraits::get_parent(left) == node);
+         BOOST_INTRUSIVE_INVARIANT_ASSERT(NodeTraits::get_parent(left) == n);
          check_subtree(left, checker, check_return_left);
       }
       if (right)
       {
-         BOOST_INTRUSIVE_INVARIANT_ASSERT(NodeTraits::get_parent(right) == node);
+         BOOST_INTRUSIVE_INVARIANT_ASSERT(NodeTraits::get_parent(right) == n);
          check_subtree(right, checker, check_return_right);
       }
-      checker(node, check_return_left, check_return_right, check_return);
+      checker(n, check_return_left, check_return_right, check_return);
    }
 };
 

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

@@ -243,7 +243,7 @@ class any_algorithms
    typedef typename node::const_node_ptr  const_node_ptr;
    typedef any_node_traits<VoidPointer>   node_traits;
 
-   //! <b>Requires</b>: node must not be part of any tree.
+   //! <b>Requires</b>: 'n' must not be part of any tree.
    //!
    //! <b>Effects</b>: After the function unique(node) == true.
    //!
@@ -252,19 +252,19 @@ 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(node_ptr node) BOOST_NOEXCEPT
-   {  node->node_ptr_1 = node_ptr();   };
+   BOOST_INTRUSIVE_FORCEINLINE static void init(node_ptr n) BOOST_NOEXCEPT
+   {  n->node_ptr_1 = node_ptr();   };
 
-   //! <b>Effects</b>: Returns true if node is in the same state as if called init(node)
+   //! <b>Effects</b>: Returns true if 'n' is in the same state as if called init(node)
    //!
    //! <b>Complexity</b>: Constant.
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static bool inited(const_node_ptr node)
-   {  return !node->node_ptr_1;  };
+   BOOST_INTRUSIVE_FORCEINLINE static bool inited(const_node_ptr n)
+   {  return !n->node_ptr_1;  };
 
-   BOOST_INTRUSIVE_FORCEINLINE static bool unique(const_node_ptr node) BOOST_NOEXCEPT
-   {  return !node->node_ptr_1; }
+   BOOST_INTRUSIVE_FORCEINLINE static bool unique(const_node_ptr n) BOOST_NOEXCEPT
+   {  return !n->node_ptr_1; }
 
    static void unlink(node_ptr)
    {

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

@@ -35,21 +35,20 @@ class bstree_algorithms_base
    typedef typename NodeTraits::node_ptr        node_ptr;
    typedef typename NodeTraits::const_node_ptr  const_node_ptr;
 
-   //! <b>Requires</b>: 'node' is a node from the tree except the header.
+   //! <b>Requires</b>: 'n' is a node from the tree except the header.
    //!
    //! <b>Effects</b>: Returns the next node of the tree.
    //!
    //! <b>Complexity</b>: Average constant time.
    //!
    //! <b>Throws</b>: Nothing.
-   static node_ptr next_node(node_ptr node) BOOST_NOEXCEPT
+   static node_ptr next_node(node_ptr n) BOOST_NOEXCEPT
    {
-      node_ptr const n_right(NodeTraits::get_right(node));
+      node_ptr const n_right(NodeTraits::get_right(n));
       if(n_right){
          return minimum(n_right);
       }
       else {
-         node_ptr n(node);
          node_ptr p(NodeTraits::get_parent(n));
          while(n == NodeTraits::get_right(p)){
             n = p;
@@ -59,23 +58,23 @@ class bstree_algorithms_base
       }
    }
 
-   //! <b>Requires</b>: 'node' is a node from the tree except the leftmost node.
+   //! <b>Requires</b>: 'n' is a node from the tree except the leftmost node.
    //!
    //! <b>Effects</b>: Returns the previous node of the tree.
    //!
    //! <b>Complexity</b>: Average constant time.
    //!
    //! <b>Throws</b>: Nothing.
-   static node_ptr prev_node(node_ptr node) BOOST_NOEXCEPT
+   static node_ptr prev_node(node_ptr n) BOOST_NOEXCEPT
    {
-      if(is_header(node)){
-         return NodeTraits::get_right(node);
+      if(is_header(n)){
+         return NodeTraits::get_right(n);
       }
-      else if(NodeTraits::get_left(node)){
-         return maximum(NodeTraits::get_left(node));
+      else if(NodeTraits::get_left(n)){
+         return maximum(NodeTraits::get_left(n));
       }
       else {
-         node_ptr p(node);
+         node_ptr p(n);
          node_ptr x = NodeTraits::get_parent(p);
          while(p == NodeTraits::get_left(x)){
             p = x;
@@ -85,38 +84,38 @@ class bstree_algorithms_base
       }
    }
 
-   //! <b>Requires</b>: 'node' is a node of a tree but not the header.
+   //! <b>Requires</b>: 'n' is a node of a tree but not the header.
    //!
    //! <b>Effects</b>: Returns the minimum node of the subtree starting at p.
    //!
    //! <b>Complexity</b>: Logarithmic to the size of the subtree.
    //!
    //! <b>Throws</b>: Nothing.
-   static node_ptr minimum(node_ptr node)
+   static node_ptr minimum(node_ptr n)
    {
-      for(node_ptr p_left = NodeTraits::get_left(node)
+      for(node_ptr p_left = NodeTraits::get_left(n)
          ;p_left
-         ;p_left = NodeTraits::get_left(node)){
-         node = p_left;
+         ;p_left = NodeTraits::get_left(n)){
+         n = p_left;
       }
-      return node;
+      return n;
    }
 
-   //! <b>Requires</b>: 'node' is a node of a tree but not the header.
+   //! <b>Requires</b>: 'n' is a node of a tree but not the header.
    //!
    //! <b>Effects</b>: Returns the maximum node of the subtree starting at p.
    //!
    //! <b>Complexity</b>: Logarithmic to the size of the subtree.
    //!
    //! <b>Throws</b>: Nothing.
-   static node_ptr maximum(node_ptr node)
+   static node_ptr maximum(node_ptr n)
    {
-      for(node_ptr p_right = NodeTraits::get_right(node)
+      for(node_ptr p_right = NodeTraits::get_right(n)
          ;p_right
-         ;p_right = NodeTraits::get_right(node)){
-         node = p_right;
+         ;p_right = NodeTraits::get_right(n)){
+         n = p_right;
       }
-      return node;
+      return n;
    }
 
    //! <b>Requires</b>: p is a node of a tree.
@@ -143,37 +142,37 @@ class bstree_algorithms_base
       return false;
    }
 
-   //! <b>Requires</b>: 'node' is a node of the tree or a header node.
+   //! <b>Requires</b>: 'n' is a node of the tree or a header node.
    //!
    //! <b>Effects</b>: Returns the header of the tree.
    //!
    //! <b>Complexity</b>: Logarithmic.
    //!
    //! <b>Throws</b>: Nothing.
-   static node_ptr get_header(const_node_ptr node)
+   static node_ptr get_header(const_node_ptr n)
    {
-      node_ptr n(detail::uncast(node));
-      node_ptr p(NodeTraits::get_parent(node));
-      //If p is null, then n is the header of an empty tree
+      node_ptr nn(detail::uncast(n));
+      node_ptr p(NodeTraits::get_parent(n));
+      //If p is null, then nn is the header of an empty tree
       if(p){
-         //Non-empty tree, check if n is neither root nor header
+         //Non-empty tree, check if nn is neither root nor header
          node_ptr pp(NodeTraits::get_parent(p));
-         //If granparent is not equal to n, then n is neither root nor header,
+         //If granparent is not equal to nn, then nn is neither root nor header,
          //the try the fast path
-         if(n != pp){
+         if(nn != pp){
             do{
-               n = p;
+               nn = p;
                p = pp;
                pp = NodeTraits::get_parent(pp);
-            }while(n != pp);
-            n = p;
+            }while(nn != pp);
+            nn = p;
          }
-         //Check if n is root or header when size() > 0
-         else if(!bstree_algorithms_base::is_header(n)){
-            n = p;
+         //Check if nn is root or header when size() > 0
+         else if(!bstree_algorithms_base::is_header(nn)){
+            nn = p;
          }
       }
-      return n;
+      return nn;
    }
 };
 

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

@@ -213,6 +213,14 @@ BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag<InputIt, std::random
    it += n;
 }
 
+template<class InputIt, class Distance>
+BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag<InputIt, std::random_access_iterator_tag, InputIt>::type
+   make_iterator_advance(InputIt it, Distance n)
+{
+   (iterator_advance)(it, n);
+   return it;
+}
+
 template<class It>
 BOOST_INTRUSIVE_FORCEINLINE 
    void iterator_uadvance(It& it, typename iter_size<It>::type n)
@@ -220,6 +228,14 @@ BOOST_INTRUSIVE_FORCEINLINE
    (iterator_advance)(it, (typename iterator_traits<It>::difference_type)n);
 }
 
+template<class It>
+BOOST_INTRUSIVE_FORCEINLINE
+It make_iterator_uadvance(It it, typename iter_size<It>::type n)
+{
+   (iterator_uadvance)(it, n);
+   return it;
+}
+
 ////////////////////////////////////////
 //    iterator_distance
 ////////////////////////////////////////

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

@@ -48,7 +48,7 @@
 #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)
+#elif defined(BOOST_GCC) && ((__GNUC__ <= 5) || defined(__MINGW32__))
    //Older GCCs have problems with forceinline
    #define BOOST_INTRUSIVE_FORCEINLINE inline
 #else