passenger 6.0.2 → 6.0.15

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

@@ -49,6 +49,11 @@ namespace boost {
 namespace intrusive {
 
 using boost::movelib::iterator_traits;
+using boost::movelib::iter_difference;
+using boost::movelib::iter_value;
+using boost::movelib::iter_category;
+using boost::movelib::iter_size;
+
 
 ////////////////////
 //    iterator
@@ -63,26 +68,59 @@ struct iterator
    typedef Reference    reference;
 };
 
-////////////////////////////////////////
-//    iterator_[dis|en]able_if_boost_iterator
-////////////////////////////////////////
-template<class I>
-struct is_boost_iterator
+////////////////////////////////////////////////////////////////////////////////
+//    Conversion from boost::iterator traversals to std tags
+////////////////////////////////////////////////////////////////////////////////
+
+template<class Tag>
+struct get_std_category_from_tag
 {
-   static const bool value = false;
+   typedef Tag type;
 };
 
-template<class Category, class Traversal>
-struct is_boost_iterator< boost::iterators::detail::iterator_category_with_traversal<Category, Traversal> >
+template <class Category>
+struct get_std_category_from_tag
+   <boost::iterators::detail::iterator_category_with_traversal
+      <Category, boost::iterators::incrementable_traversal_tag> >
 {
-   static const bool value = true;
+   typedef std::input_iterator_tag type;
 };
 
-template<class I, class R = void>
-struct iterator_enable_if_boost_iterator
-   : ::boost::move_detail::enable_if_c
-      < is_boost_iterator<typename boost::intrusive::iterator_traits<I>::iterator_category >::value
-      , R>
+template <class Category>
+struct get_std_category_from_tag
+   <boost::iterators::detail::iterator_category_with_traversal
+      <Category, boost::iterators::single_pass_traversal_tag> >
+{
+   typedef std::input_iterator_tag type;
+};
+
+template <class Category>
+struct get_std_category_from_tag
+   <boost::iterators::detail::iterator_category_with_traversal
+      <Category, boost::iterators::forward_traversal_tag> >
+{
+   typedef std::input_iterator_tag type;
+};
+
+template <class Category>
+struct get_std_category_from_tag
+   <boost::iterators::detail::iterator_category_with_traversal
+      <Category, boost::iterators::bidirectional_traversal_tag> >
+{
+   typedef std::bidirectional_iterator_tag type;
+};
+
+template <class Category>
+struct get_std_category_from_tag
+   <boost::iterators::detail::iterator_category_with_traversal
+      <Category, boost::iterators::random_access_traversal_tag> >
+{
+   typedef std::random_access_iterator_tag type;
+};
+
+template<class It>
+struct get_std_category_from_it
+   : get_std_category_from_tag< typename boost::intrusive::iter_category<It>::type >
 {};
 
 ////////////////////////////////////////
@@ -92,7 +130,7 @@ template<class I, class Tag, class R = void>
 struct iterator_enable_if_tag
    : ::boost::move_detail::enable_if_c
       < ::boost::move_detail::is_same
-         < typename boost::intrusive::iterator_traits<I>::iterator_category 
+         < typename get_std_category_from_it<I>::type
          , Tag
          >::value
          , R>
@@ -102,7 +140,7 @@ template<class I, class Tag, class R = void>
 struct iterator_disable_if_tag
    : ::boost::move_detail::enable_if_c
       < !::boost::move_detail::is_same
-         < typename boost::intrusive::iterator_traits<I>::iterator_category 
+         < typename get_std_category_from_it<I>::type
          , Tag
          >::value
          , R>
@@ -115,11 +153,11 @@ template<class I, class Tag, class Tag2, class R = void>
 struct iterator_enable_if_convertible_tag
    : ::boost::move_detail::enable_if_c
       < ::boost::move_detail::is_same_or_convertible
-         < typename boost::intrusive::iterator_traits<I>::iterator_category 
+         < typename get_std_category_from_it<I>::type
          , Tag
          >::value &&
         !::boost::move_detail::is_same_or_convertible
-         < typename boost::intrusive::iterator_traits<I>::iterator_category 
+         < typename get_std_category_from_it<I>::type
          , Tag2
          >::value
          , R>
@@ -130,42 +168,42 @@ struct iterator_enable_if_convertible_tag
 ////////////////////////////////////////
 template<class I, class Tag>
 struct iterator_enable_if_tag_difference_type
-   : iterator_enable_if_tag<I, Tag, typename boost::intrusive::iterator_traits<I>::difference_type>
+   : iterator_enable_if_tag<I, Tag, typename boost::intrusive::iter_difference<I>::type>
 {};
 
 template<class I, class Tag>
 struct iterator_disable_if_tag_difference_type
-   : iterator_disable_if_tag<I, Tag, typename boost::intrusive::iterator_traits<I>::difference_type>
+   : iterator_disable_if_tag<I, Tag, typename boost::intrusive::iter_difference<I>::type>
 {};
 
 ////////////////////
 //    advance
 ////////////////////
 
-template<class InputIt, class Distance>
+template<class InputIt>
 BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag<InputIt, std::input_iterator_tag>::type
-   iterator_advance(InputIt& it, Distance n)
+   iterator_advance(InputIt& it, typename iter_difference<InputIt>::type n)
 {
    while(n--)
-	   ++it;
+      ++it;
 }
 
-template<class InputIt, class Distance>
+template<class InputIt>
 typename iterator_enable_if_tag<InputIt, std::forward_iterator_tag>::type
-   iterator_advance(InputIt& it, Distance n)
+   iterator_advance(InputIt& it, typename iter_difference<InputIt>::type n)
 {
    while(n--)
-	   ++it;
+      ++it;
 }
 
-template<class InputIt, class Distance>
+template<class InputIt>
 BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag<InputIt, std::bidirectional_iterator_tag>::type
-   iterator_advance(InputIt& it, Distance n)
+   iterator_advance(InputIt& it, typename iter_difference<InputIt>::type n)
 {
    for (; 0 < n; --n)
-	   ++it;
+      ++it;
    for (; n < 0; ++n)
-	   --it;
+      --it;
 }
 
 template<class InputIt, class Distance>
@@ -175,65 +213,24 @@ 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_convertible_tag
-   <InputIt, const boost::iterators::incrementable_traversal_tag&, const boost::iterators::single_pass_traversal_tag&>::type
-   iterator_advance(InputIt& it, Distance n)
-{
-   while(n--)
-	   ++it;
-}
-
-template<class InputIt, class Distance>
-BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_convertible_tag
-   <InputIt, const boost::iterators::single_pass_traversal_tag &, const boost::iterators::forward_traversal_tag&>::type
-   iterator_advance(InputIt& it, Distance n)
-{
-   while(n--)
-	   ++it;
-}
-
-template<class InputIt, class Distance>
-BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_convertible_tag
-   <InputIt, const boost::iterators::forward_traversal_tag&, const boost::iterators::bidirectional_traversal_tag&>::type
-   iterator_advance(InputIt& it, Distance n)
-{
-   while(n--)
-	   ++it;
-}
-
-template<class InputIt, class Distance>
-BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_convertible_tag
-   <InputIt, const boost::iterators::bidirectional_traversal_tag&, const boost::iterators::random_access_traversal_tag&>::type
-   iterator_advance(InputIt& it, Distance n)
-{
-   for (; 0 < n; --n)
-	   ++it;
-   for (; n < 0; ++n)
-	   --it;
-}
-
-class fake{};
-
-template<class InputIt, class Distance>
-BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_convertible_tag
-   <InputIt, const boost::iterators::random_access_traversal_tag&, const fake&>::type
-   iterator_advance(InputIt& it, Distance n)
+template<class It>
+BOOST_INTRUSIVE_FORCEINLINE 
+   void iterator_uadvance(It& it, typename iter_size<It>::type n)
 {
-   it += n;
+   (iterator_advance)(it, (typename iterator_traits<It>::difference_type)n);
 }
 
-////////////////////
-//    distance
-////////////////////
+////////////////////////////////////////
+//    iterator_distance
+////////////////////////////////////////
 template<class InputIt> inline
 typename iterator_disable_if_tag_difference_type
    <InputIt, std::random_access_iterator_tag>::type
       iterator_distance(InputIt first, InputIt last)
 {
-   typename iterator_traits<InputIt>::difference_type off = 0;
+   typename iter_difference<InputIt>::type off = 0;
    while(first != last){
-	   ++off;
+      ++off;
       ++first;
    }
    return off;
@@ -244,10 +241,43 @@ BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag_difference_type
    <InputIt, std::random_access_iterator_tag>::type
       iterator_distance(InputIt first, InputIt last)
 {
-   typename iterator_traits<InputIt>::difference_type off = last - first;
+   typename iter_difference<InputIt>::type off = last - first;
    return off;
 }
 
+////////////////////////////////////////
+//    iterator_udistance
+////////////////////////////////////////
+
+template<class It>
+BOOST_INTRUSIVE_FORCEINLINE typename iter_size<It>::type
+   iterator_udistance(It first, It last)
+{
+   return (typename iter_size<It>::type)(iterator_distance)(first, last);
+}
+
+////////////////////////////////////////
+//    iterator_next
+////////////////////////////////////////
+
+template<class InputIt>
+BOOST_INTRUSIVE_FORCEINLINE 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)
+{
+   (iterator_uadvance)(it, n);
+   return it;
+}
+
+////////////////////////////////////////
+// iterator_arrow_result
+////////////////////////////////////////
+
 template<class I>
 BOOST_INTRUSIVE_FORCEINLINE typename iterator_traits<I>::pointer iterator_arrow_result(const I &i)
 {  return i.operator->();  }

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

@@ -78,7 +78,7 @@ public:
       static const bool value = same_type || is_convertible<P1, const_node_ptr>::value;
    };
 
-   base_t base() const
+   BOOST_INTRUSIVE_FORCEINLINE base_t base() const
    {  return static_cast<const base_t&>(*this); }
 
    BOOST_INTRUSIVE_FORCEINLINE key_nodeptr_comp(KeyTypeKeyCompare kcomp, const ValueTraits *traits)

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

@@ -47,6 +47,11 @@ class list_iterator
    typedef typename types_t::node                           node;
    typedef typename types_t::node_ptr                       node_ptr;
    typedef typename types_t::const_value_traits_ptr         const_value_traits_ptr;
+   class nat;
+   typedef typename
+      detail::if_c< IsConst
+                  , list_iterator<value_traits, false>
+                  , nat>::type                              nonconst_iterator;
 
    public:
    typedef typename types_t::iterator_type::difference_type    difference_type;
@@ -58,19 +63,26 @@ class list_iterator
    BOOST_INTRUSIVE_FORCEINLINE list_iterator()
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE explicit list_iterator(const node_ptr & nodeptr, const const_value_traits_ptr &traits_ptr)
+   BOOST_INTRUSIVE_FORCEINLINE explicit list_iterator(node_ptr nodeptr, const_value_traits_ptr traits_ptr)
       : members_(nodeptr, traits_ptr)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE list_iterator(list_iterator<ValueTraits, false> const& other)
+   BOOST_INTRUSIVE_FORCEINLINE list_iterator(const list_iterator &other)
       :  members_(other.pointed_node(), other.get_value_traits())
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE const node_ptr &pointed_node() const
+   BOOST_INTRUSIVE_FORCEINLINE list_iterator(const nonconst_iterator &other)
+      :  members_(other.pointed_node(), other.get_value_traits())
+   {}
+
+   BOOST_INTRUSIVE_FORCEINLINE list_iterator &operator=(const list_iterator &other)
+   {  members_.nodeptr_ = other.members_.nodeptr_;  return *this;  }
+
+   BOOST_INTRUSIVE_FORCEINLINE node_ptr pointed_node() const
    { return members_.nodeptr_; }
 
-   BOOST_INTRUSIVE_FORCEINLINE list_iterator &operator=(const node_ptr &node)
-   {  members_.nodeptr_ = node;  return static_cast<list_iterator&>(*this);  }
+   BOOST_INTRUSIVE_FORCEINLINE list_iterator &operator=(node_ptr nodeptr)
+   {  members_.nodeptr_ = nodeptr;  return *this;  }
 
    BOOST_INTRUSIVE_FORCEINLINE const_value_traits_ptr get_value_traits() const
    {  return members_.get_ptr(); }
@@ -115,7 +127,7 @@ class list_iterator
    BOOST_INTRUSIVE_FORCEINLINE pointer operator->() const
    { return this->operator_arrow(detail::bool_<stateful_value_traits>()); }
 
-   list_iterator<ValueTraits, false> unconst() const
+   BOOST_INTRUSIVE_FORCEINLINE list_iterator<ValueTraits, false> unconst() const
    {  return list_iterator<ValueTraits, false>(this->pointed_node(), this->get_value_traits());   }
 
    private:

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

@@ -47,22 +47,22 @@ struct list_node_traits
    typedef typename node::node_ptr     node_ptr;
    typedef typename pointer_rebind<VoidPointer, const node>::type   const_node_ptr;
 
-   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_previous(const const_node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_previous(const_node_ptr n)
    {  return n->prev_;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_previous(const node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_previous(node_ptr n)
    {  return n->prev_;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE static void set_previous(const node_ptr & n, const node_ptr & prev)
+   BOOST_INTRUSIVE_FORCEINLINE static void set_previous(node_ptr n, node_ptr prev)
    {  n->prev_ = prev;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_next(const const_node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_next(const_node_ptr n)
    {  return n->next_;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_next(const node_ptr & n)
+   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_next(node_ptr n)
    {  return n->next_;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE static void set_next(const node_ptr & n, const node_ptr & next)
+   BOOST_INTRUSIVE_FORCEINLINE static void set_next(node_ptr n, node_ptr next)
    {  n->next_ = next;  }
 };
 

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

@@ -24,6 +24,7 @@
 #include <cstddef>
 #include <climits>
 #include <boost/intrusive/detail/mpl.hpp>
+#include <cstring>
 
 namespace boost {
 namespace intrusive {
@@ -75,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
@@ -92,7 +93,7 @@ namespace detail {
    struct builtin_clz_dispatch< ::boost::ulong_long_type >
    {
       static ::boost::ulong_long_type call(::boost::ulong_long_type n)
-      {  return __builtin_clzll(n); }
+      {  return (::boost::ulong_long_type)__builtin_clzll(n); }
    };
    #endif
 
@@ -100,14 +101,14 @@ namespace detail {
    struct builtin_clz_dispatch<unsigned long>
    {
       static unsigned long call(unsigned long n)
-      {  return __builtin_clzl(n); }
+      {  return (unsigned long)__builtin_clzl(n); }
    };
 
    template<>
    struct builtin_clz_dispatch<unsigned int>
    {
       static unsigned int call(unsigned int n)
-      {  return __builtin_clz(n); }
+      {  return (unsigned int)__builtin_clz(n); }
    };
 
    inline std::size_t floor_log2(std::size_t n)
@@ -149,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;
@@ -208,19 +162,12 @@ namespace detail {
 //http://www.flipcode.com/archives/Fast_log_Function.shtml
 inline float fast_log2 (float val)
 {
-   union caster_t
-   {
-      unsigned x;
-      float val;
-   } caster;
-
-   caster.val = val;
-   unsigned x = caster.x;
+   unsigned x;
+   std::memcpy(&x, &val, sizeof(float));
    const int log_2 = int((x >> 23) & 255) - 128;
    x &= ~(unsigned(255u) << 23u);
    x += unsigned(127) << 23u;
-   caster.x = x;
-   val = caster.val;
+   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
@@ -262,7 +209,7 @@ template<class SizeType, class Enabler = void >
 struct sqrt2_pow_max;
 
 template <class SizeType>
-struct sqrt2_pow_max<SizeType, typename enable_if< numbits_eq<SizeType, 32> >::type>
+struct sqrt2_pow_max<SizeType, typename voider<typename enable_if< numbits_eq<SizeType, 32> >::type>::type>
 {
    static const SizeType value = 0xb504f334;
    static const std::size_t pow   = 31;
@@ -271,7 +218,7 @@ struct sqrt2_pow_max<SizeType, typename enable_if< numbits_eq<SizeType, 32> >::t
 #ifndef BOOST_NO_INT64_T
 
 template <class SizeType>
-struct sqrt2_pow_max<SizeType, typename enable_if< numbits_eq<SizeType, 64> >::type>
+struct sqrt2_pow_max<SizeType, typename voider<typename enable_if< numbits_eq<SizeType, 64> >::type>::type>
 {
    static const SizeType value = 0xb504f333f9de6484ull;
    static const std::size_t pow   = 63;

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

@@ -40,6 +40,7 @@ using boost::move_detail::remove_pointer;
 using boost::move_detail::add_pointer;
 using boost::move_detail::true_type;
 using boost::move_detail::false_type;
+using boost::move_detail::voider;
 using boost::move_detail::enable_if_c;
 using boost::move_detail::enable_if;
 using boost::move_detail::disable_if_c;
@@ -154,7 +155,7 @@ template <class T>\
 struct TRAITS_PREFIX##_bool\
 {\
    template<bool Add>\
-   struct two_or_three {yes_type _[2 + Add];};\
+   struct two_or_three {yes_type _[2u + (unsigned)Add];};\
    template <class U> static yes_type test(...);\
    template <class U> static two_or_three<U::TYPEDEF_TO_FIND> test (int);\
    static const std::size_t value = sizeof(test<T>(0));\

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
-   node_ptr operator()(const node_ptr & p)
+   BOOST_INTRUSIVE_FORCEINLINE 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,13 +85,13 @@ struct node_disposer
    static const bool safemode_or_autounlink =
       is_safe_autounlink<value_traits::link_mode>::value;
 
-   node_disposer(F f, const ValueTraits *cont)
+   BOOST_INTRUSIVE_FORCEINLINE node_disposer(F f, const ValueTraits *cont)
       :  base_t(f), traits_(cont)
    {}
 
-   void operator()(const node_ptr & p)
+   BOOST_INTRUSIVE_FORCEINLINE void operator()(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/node_to_value.hpp

@@ -103,7 +103,7 @@ struct node_to_value
    typedef typename pointer_traits<npointer>::
       template rebind_pointer<const ValueTraits>::type const_value_traits_ptr;
 
-   node_to_value(const const_value_traits_ptr &ptr)
+   node_to_value(const_value_traits_ptr ptr)
       :  Base(ptr)
    {}