passenger 6.0.13 → 6.0.15

data/src/cxx_supportlib/vendor-modified/boost/move/algo/detail/merge_sort.hpp

@@ -34,6 +34,11 @@
 #include <boost/move/algo/detail/insertion_sort.hpp>
 #include <cassert>
 
+#if defined(BOOST_CLANG) || (defined(BOOST_GCC) && (BOOST_GCC >= 40600))
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wsign-conversion"
+#endif
+
 namespace boost {
 namespace movelib {
 
@@ -44,7 +49,7 @@ static const unsigned MergeSortInsertionSortThreshold = 16;
 template <class RandIt, class Compare>
 void inplace_stable_sort(RandIt first, RandIt last, Compare comp)
 {
-   typedef typename iterator_traits<RandIt>::size_type  size_type;
+   typedef typename iter_size<RandIt>::type  size_type;
    if (size_type(last - first) <= size_type(MergeSortInsertionSortThreshold)) {
       insertion_sort(first, last, comp);
       return;
@@ -62,14 +67,14 @@ template<class RandIt, class RandIt2, class Compare>
 void merge_sort_copy( RandIt first, RandIt last
                    , RandIt2 dest, Compare comp)
 {
-   typedef typename iterator_traits<RandIt>::size_type  size_type;
-
+   typedef typename iter_size<RandIt>::type         size_type;
+   
    size_type const count = size_type(last - first);
    if(count <= MergeSortInsertionSortThreshold){
       insertion_sort_copy(first, last, dest, comp);
    }
    else{
-      size_type const half = count/2;
+      size_type const half = size_type(count/2u);
       merge_sort_copy(first + half, last        , dest+half   , comp);
       merge_sort_copy(first       , first + half, first + half, comp);
       merge_with_right_placed
@@ -84,7 +89,7 @@ void merge_sort_uninitialized_copy( RandIt first, RandIt last
                                  , RandItRaw uninitialized
                                  , Compare comp)
 {
-   typedef typename iterator_traits<RandIt>::size_type  size_type;
+   typedef typename iter_size<RandIt>::type       size_type;
    typedef typename iterator_traits<RandIt>::value_type value_type;
 
    size_type const count = size_type(last - first);
@@ -95,7 +100,7 @@ void merge_sort_uninitialized_copy( RandIt first, RandIt last
       size_type const half = count/2;
       merge_sort_uninitialized_copy(first + half, last, uninitialized + half, comp);
       destruct_n<value_type, RandItRaw> d(uninitialized+half);
-      d.incr(count-half);
+      d.incr(size_type(count-half));
       merge_sort_copy(first, first + half, first + half, comp);
       uninitialized_merge_with_right_placed
          ( first + half, first + half + half
@@ -109,16 +114,16 @@ template<class RandIt, class RandItRaw, class Compare>
 void merge_sort( RandIt first, RandIt last, Compare comp
                , RandItRaw uninitialized)
 {
-   typedef typename iterator_traits<RandIt>::size_type  size_type;
-   typedef typename iterator_traits<RandIt>::value_type value_type;
+   typedef typename iter_size<RandIt>::type       size_type;
+   typedef typename iterator_traits<RandIt>::value_type      value_type;
 
    size_type const count = size_type(last - first);
    if(count <= MergeSortInsertionSortThreshold){
       insertion_sort(first, last, comp);
    }
    else{
-      size_type const half = count/2;
-      size_type const rest = count -  half;
+      size_type const half = size_type(count/2u);
+      size_type const rest = size_type(count -  half);
       RandIt const half_it = first + half;
       RandIt const rest_it = first + rest;
 
@@ -137,15 +142,15 @@ void merge_sort( RandIt first, RandIt last, Compare comp
 template<class RandIt, class RandItRaw, class Compare>
 void merge_sort_with_constructed_buffer( RandIt first, RandIt last, Compare comp, RandItRaw buffer)
 {
-   typedef typename iterator_traits<RandIt>::size_type  size_type;
+   typedef typename iter_size<RandIt>::type       size_type;
 
    size_type const count = size_type(last - first);
    if(count <= MergeSortInsertionSortThreshold){
       insertion_sort(first, last, comp);
    }
    else{
-      size_type const half = count/2;
-      size_type const rest = count -  half;
+      size_type const half = size_type(count/2);
+      size_type const rest = size_type(count -  half);
       RandIt const half_it = first + half;
       RandIt const rest_it = first + rest;
 
@@ -161,12 +166,12 @@ template<typename RandIt, typename Pointer,
          typename Distance, typename Compare>
 void stable_sort_ONlogN_recursive(RandIt first, RandIt last, Pointer buffer, Distance buffer_size, Compare comp)
 {
-   typedef typename iterator_traits<RandIt>::size_type  size_type;
+   typedef typename iter_size<RandIt>::type  size_type;
    if (size_type(last - first) <= size_type(MergeSortInsertionSortThreshold)) {
       insertion_sort(first, last, comp);
    }
    else {
-      const size_type len = (last - first) / 2;
+      const size_type len = size_type(last - first) / 2u;
       const RandIt middle = first + len;
       if (len > ((buffer_size+1)/2)){
          stable_sort_ONlogN_recursive(first, middle, buffer, buffer_size, comp);
@@ -202,6 +207,10 @@ void stable_sort_adaptive_ONlogN2(BidirectionalIterator first,
 
 }} //namespace boost {  namespace movelib{
 
+#if defined(BOOST_CLANG) || (defined(BOOST_GCC) && (BOOST_GCC >= 40600))
+#pragma GCC diagnostic pop
+#endif
+
 #include <boost/move/detail/config_end.hpp>
 
 #endif //#ifndef BOOST_MOVE_DETAIL_MERGE_SORT_HPP

data/src/cxx_supportlib/vendor-modified/boost/move/algo/detail/pdqsort.hpp

@@ -47,6 +47,7 @@
 #endif
 
 #include <boost/move/detail/config_begin.hpp>
+
 #include <boost/move/detail/workaround.hpp>
 #include <boost/move/utility_core.hpp>
 #include <boost/move/algo/detail/insertion_sort.hpp>
@@ -56,6 +57,11 @@
 #include <boost/move/adl_move_swap.hpp>
 #include <cstddef>
 
+#if defined(BOOST_CLANG) || (defined(BOOST_GCC) && (BOOST_GCC >= 40600))
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wsign-conversion"
+#endif
+
 namespace boost {
 namespace movelib {
 
@@ -109,7 +115,7 @@ namespace pdqsort_detail {
     template<class Iter, class Compare>
     inline bool partial_insertion_sort(Iter begin, Iter end, Compare comp) {
         typedef typename boost::movelib::iterator_traits<Iter>::value_type T;
-        typedef typename boost::movelib::iterator_traits<Iter>::size_type  size_type;
+        typedef typename boost::movelib:: iter_size<Iter>::type  size_type;
         if (begin == end) return true;
         
         size_type limit = 0;
@@ -225,10 +231,10 @@ namespace pdqsort_detail {
 
    template<class Iter, class Compare>
    void pdqsort_loop( Iter begin, Iter end, Compare comp
-                    , typename boost::movelib::iterator_traits<Iter>::size_type bad_allowed
+                    , typename boost::movelib:: iter_size<Iter>::type bad_allowed
                     , bool leftmost = true)
    {
-        typedef typename boost::movelib::iterator_traits<Iter>::size_type size_type;
+        typedef typename boost::movelib:: iter_size<Iter>::type size_type;
 
         // Use a while loop for tail recursion elimination.
         while (true) {
@@ -322,13 +328,17 @@ template<class Iter, class Compare>
 void pdqsort(Iter begin, Iter end, Compare comp)
 {
    if (begin == end) return;
-   typedef typename boost::movelib::iterator_traits<Iter>::size_type size_type;
+   typedef typename boost::movelib:: iter_size<Iter>::type size_type;
    pdqsort_detail::pdqsort_loop<Iter, Compare>(begin, end, comp, pdqsort_detail::log2(size_type(end - begin)));
 }
 
 }  //namespace movelib {
 }  //namespace boost {
 
+#if defined(BOOST_CLANG) || (defined(BOOST_GCC) && (BOOST_GCC >= 40600))
+#pragma GCC diagnostic pop
+#endif
+
 #include <boost/move/detail/config_end.hpp>
 
 #endif   //BOOST_MOVE_ALGO_PDQSORT_HPP

data/src/cxx_supportlib/vendor-modified/boost/move/algo/detail/search.hpp

@@ -0,0 +1,79 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2022-2022.
+// 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/move for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#ifndef BOOST_MOVE_DETAIL_SEARCH_HPP
+#define BOOST_MOVE_DETAIL_SEARCH_HPP
+
+#include <boost/move/detail/iterator_traits.hpp>
+
+#if defined(BOOST_CLANG) || (defined(BOOST_GCC) && (BOOST_GCC >= 40600))
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wsign-conversion"
+#endif
+
+namespace boost {
+namespace movelib {
+
+template <class RandIt, class T, class Compare>
+RandIt lower_bound
+   (RandIt first, const RandIt last, const T& key, Compare comp)
+{
+   typedef typename iter_size<RandIt>::type size_type;
+   size_type len = size_type(last - first);
+   RandIt middle;
+
+   while (len) {
+      size_type step = size_type(len >> 1);
+      middle = first;
+      middle += step;
+
+      if (comp(*middle, key)) {
+         first = ++middle;
+         len = size_type(len - (step + 1));
+      }
+      else{
+         len = step;
+      }
+   }
+   return first;
+}
+
+template <class RandIt, class T, class Compare>
+RandIt upper_bound
+   (RandIt first, const RandIt last, const T& key, Compare comp)
+{
+   typedef typename iter_size<RandIt>::type size_type;
+   size_type len = size_type(last - first);
+   RandIt middle;
+
+   while (len) {
+      size_type step = size_type(len >> 1);
+      middle = first;
+      middle += step;
+
+      if (!comp(key, *middle)) {
+         first = ++middle;
+         len = size_type(len - (step + 1));
+      }
+      else{
+         len = step;
+      }
+   }
+   return first;
+}
+
+}  //namespace movelib {
+}  //namespace boost {
+
+#if defined(BOOST_CLANG) || (defined(BOOST_GCC) && (BOOST_GCC >= 40600))
+#pragma GCC diagnostic pop
+#endif
+
+#endif   //#define BOOST_MOVE_DETAIL_SEARCH_HPP

data/src/cxx_supportlib/vendor-modified/boost/move/algo/detail/set_difference.hpp

@@ -15,8 +15,12 @@
 #include <boost/move/iterator.hpp>
 #include <boost/move/utility_core.hpp>
 
-namespace boost {
+#if defined(BOOST_CLANG) || (defined(BOOST_GCC) && (BOOST_GCC >= 40600))
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wsign-conversion"
+#endif
 
+namespace boost {
 namespace move_detail{
 
 template<class InputIt, class OutputIt>
@@ -199,7 +203,9 @@ ForwardOutputIt1 inplace_set_unique_difference
    return first1;
 }
 
-
+#if defined(BOOST_CLANG) || (defined(BOOST_GCC) && (BOOST_GCC >= 40600))
+#pragma GCC diagnostic pop
+#endif
 
 }  //namespace movelib {
 }  //namespace boost {

data/src/cxx_supportlib/vendor-modified/boost/move/algo/move.hpp

@@ -27,7 +27,11 @@
 #include <boost/move/utility_core.hpp>
 #include <boost/move/detail/iterator_traits.hpp>
 #include <boost/move/detail/iterator_to_raw_pointer.hpp>
+#include <boost/move/detail/addressof.hpp>
 #include <boost/core/no_exceptions_support.hpp>
+#if defined(BOOST_MOVE_USE_STANDARD_LIBRARY_MOVE)
+#include <algorithm>
+#endif
 
 namespace boost {
 

data/src/cxx_supportlib/vendor-modified/boost/move/algo/predicate.hpp

@@ -24,19 +24,19 @@ namespace movelib {
 template<class Comp>
 struct antistable
 {
-   explicit antistable(Comp &comp)
+   BOOST_MOVE_FORCEINLINE explicit antistable(Comp &comp)
       : m_comp(comp)
    {}
 
-   antistable(const antistable & other)
+   BOOST_MOVE_FORCEINLINE antistable(const antistable & other)
       : m_comp(other.m_comp)
    {}
 
    template<class U, class V>
-   bool operator()(const U &u, const V & v)
+   BOOST_MOVE_FORCEINLINE bool operator()(const U &u, const V & v)
    {  return !m_comp(v, u);  }
 
-   const Comp &get() const
+   BOOST_MOVE_FORCEINLINE const Comp &get() const
    {  return m_comp; }
 
    private:
@@ -56,15 +56,15 @@ template <class Comp>
 class negate
 {
    public:
-   negate()
+   BOOST_MOVE_FORCEINLINE negate()
    {}
 
-   explicit negate(Comp comp)
+   BOOST_MOVE_FORCEINLINE explicit negate(Comp comp)
       : m_comp(comp)
    {}
 
    template <class T1, class T2>
-   bool operator()(const T1& l, const T2& r)
+   BOOST_MOVE_FORCEINLINE bool operator()(const T1& l, const T2& r)
    {
       return !m_comp(l, r);
    }
@@ -78,15 +78,15 @@ template <class Comp>
 class inverse
 {
    public:
-   inverse()
+   BOOST_MOVE_FORCEINLINE inverse()
    {}
 
-   explicit inverse(Comp comp)
+   BOOST_MOVE_FORCEINLINE explicit inverse(Comp comp)
       : m_comp(comp)
    {}
 
    template <class T1, class T2>
-   bool operator()(const T1& l, const T2& r)
+   BOOST_MOVE_FORCEINLINE bool operator()(const T1& l, const T2& r)
    {
       return m_comp(r, l);
    }

data/src/cxx_supportlib/vendor-modified/boost/move/core.hpp

@@ -58,6 +58,7 @@
    #include <boost/move/detail/type_traits.hpp>
 
    #define BOOST_MOVE_TO_RV_CAST(RV_TYPE, ARG) reinterpret_cast<RV_TYPE>(ARG)
+   #define BOOST_MOVE_TO_LV_CAST(LV_TYPE, ARG) static_cast<LV_TYPE>(ARG)
 
    //Move emulation rv breaks standard aliasing rules so add workarounds for some compilers
    #if defined(BOOST_GCC) && (BOOST_GCC >= 40400) && (BOOST_GCC < 40500)
@@ -218,6 +219,10 @@
       return x;
    }
 
+   template <class T>
+   BOOST_MOVE_FORCEINLINE T& unrv(::boost::rv<T> &rv) BOOST_NOEXCEPT
+   {  return BOOST_MOVE_TO_LV_CAST(T&, rv);   }
+
    }  //namespace move_detail {
    }  //namespace boost {
 
@@ -229,6 +234,11 @@
       ::boost::move((BASE_TYPE&)(ARG))
    //
 
+   #define BOOST_MOVE_TO_LV(ARG) \
+      ::boost::move_detail::unrv(ARG)
+   //
+
+
    //////////////////////////////////////////////////////////////////////////////
    //
    //                         BOOST_MOVABLE_BUT_NOT_COPYABLE
@@ -480,6 +490,17 @@
       ::boost::move((BASE_TYPE&)(ARG))
    //
 
+   //!This macro is used to achieve portable optimal move constructors.
+   //!
+   //!In C++03 mode, when accessing a member of type through a rvalue (implemented as a `rv<T> &` type, where rv<T> derives
+   //!from T) triggers a potential UB as the program never creates objects of type rv<T>. This macro casts back `rv<T>` to
+   //!`T&` so that access to member types are done through the original type.
+   //! 
+   //!In C++11 compilers the cast from a rvalue reference of a derived type to a rvalue reference of
+   //!a base type is implicit, so it's a no-op.
+   #define BOOST_MOVE_TO_LV(ARG) ARG
+   //
+
    namespace boost {
    namespace move_detail {
 

data/src/cxx_supportlib/vendor-modified/boost/move/detail/addressof.hpp

@@ -0,0 +1,61 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2014-2015. 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/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#ifndef BOOST_MOVE_DETAIL_ADDRESSOF_HPP
+#define BOOST_MOVE_DETAIL_ADDRESSOF_HPP
+
+#ifndef BOOST_CONFIG_HPP
+#  include <boost/config.hpp>
+#endif
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#  pragma once
+#endif
+
+#include <boost/move/detail/workaround.hpp>
+
+namespace boost {
+namespace move_detail {
+
+#if defined(BOOST_MSVC_FULL_VER) && BOOST_MSVC_FULL_VER >= 190024215
+#define BOOST_MOVE_HAS_BUILTIN_ADDRESSOF
+#elif defined(BOOST_GCC) && BOOST_GCC >= 70000
+#define BOOST_MOVE_HAS_BUILTIN_ADDRESSOF
+#elif defined(__has_builtin)
+#if __has_builtin(__builtin_addressof)
+#define BOOST_MOVE_HAS_BUILTIN_ADDRESSOF
+#endif
+#endif
+
+#ifdef BOOST_MOVE_HAS_BUILTIN_ADDRESSOF
+
+template<class T>
+BOOST_MOVE_FORCEINLINE T *addressof( T & v ) BOOST_NOEXCEPT
+{
+   return __builtin_addressof(v);
+}
+
+#else //BOOST_MOVE_HAS_BUILTIN_ADDRESSOF
+
+template <typename T>
+BOOST_MOVE_FORCEINLINE T* addressof(T& obj)
+{
+   return static_cast<T*>(
+      static_cast<void*>(
+         const_cast<char*>(
+            &reinterpret_cast<const volatile char&>(obj)
+   )));
+}
+
+#endif   //BOOST_MOVE_HAS_BUILTIN_ADDRESSOF
+
+}  //namespace move_detail {
+}  //namespace boost {
+
+#endif   //#ifndef BOOST_MOVE_DETAIL_ADDRESSOF_HPP

data/src/cxx_supportlib/vendor-modified/boost/move/detail/force_ptr.hpp

@@ -0,0 +1,36 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2014-2015. 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/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#ifndef BOOST_MOVE_DETAIL_FORCE_CAST_HPP
+#define BOOST_MOVE_DETAIL_FORCE_CAST_HPP
+
+#ifndef BOOST_CONFIG_HPP
+#  include <boost/config.hpp>
+#endif
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#  pragma once
+#endif
+
+#include <boost/move/detail/workaround.hpp>
+
+namespace boost {
+namespace move_detail {
+
+
+template <typename T>
+BOOST_MOVE_FORCEINLINE T force_ptr(const volatile void *p)
+{
+   return static_cast<T>(const_cast<void*>(p));
+}
+
+}  //namespace move_detail {
+}  //namespace boost {
+
+#endif   //#ifndef BOOST_MOVE_DETAIL_FORCE_CAST_HPP

data/src/cxx_supportlib/vendor-modified/boost/move/detail/iterator_traits.hpp

@@ -22,10 +22,44 @@
 #  pragma once
 #endif
 
+#if (BOOST_CXX_VERSION > 201703L) && defined(__cpp_lib_concepts)
+
+#include <iterator>
+
+#define BOOST_MOVE_CONTIGUOUS_ITERATOR_TAG
+
+namespace boost {
+namespace movelib {
+
+   using std::iterator_traits;
+
+   template<class T>
+   struct iter_difference
+   {
+      typedef typename std::iterator_traits<T>::difference_type type;
+   };
+
+   template<class T>
+   struct iter_value
+   {
+      typedef typename std::iterator_traits<T>::value_type type;
+   };
+
+   template<class T>
+   struct iter_category
+   {
+      typedef typename std::iterator_traits<T>::iterator_category type;
+   };
+
+}} //namespace boost::movelib
+
+#else
+
 #include <cstddef>
 #include <boost/move/detail/type_traits.hpp>
 
 #include <boost/move/detail/std_ns_begin.hpp>
+
 BOOST_MOVE_STD_NS_BEG
 
 struct input_iterator_tag;
@@ -33,22 +67,74 @@ struct forward_iterator_tag;
 struct bidirectional_iterator_tag;
 struct random_access_iterator_tag;
 struct output_iterator_tag;
+
+#if (  (defined(BOOST_GNU_STDLIB) && (__cplusplus > 201703L))\
+    || (defined(_LIBCPP_VERSION) && (_LIBCPP_STD_VER > 17))\
+    || (defined(_YVALS) && defined(_CPPLIB_VER) && defined(__cpp_lib_concepts))\
+    || (__cplusplus >= 202002L)\
+    )
+#  define BOOST_MOVE_CONTIGUOUS_ITERATOR_TAG
 struct contiguous_iterator_tag;
 
+#endif
+
 BOOST_MOVE_STD_NS_END
+
 #include <boost/move/detail/std_ns_end.hpp>
 
 namespace boost{  namespace movelib{
 
+template<class T>
+struct iter_difference
+{
+   typedef typename T::difference_type type;
+};
+
+template<class T>
+struct iter_difference<T*>
+{
+   typedef std::ptrdiff_t type;
+};
+
+template<class T>
+struct iter_value
+{
+   typedef typename T::value_type type;
+};
+
+template<class T>
+struct iter_value<T*>
+{
+   typedef T type;
+};
+
+template<class T>
+struct iter_value<const T*>
+{
+   typedef T type;
+};
+
+template<class T>
+struct iter_category
+{
+   typedef typename T::iterator_category type;
+};
+
+
+template<class T>
+struct iter_category<T*>
+{
+   typedef std::random_access_iterator_tag type;
+};
+
 template<class Iterator>
 struct iterator_traits
 {
-   typedef typename Iterator::difference_type   difference_type;
-   typedef typename Iterator::value_type        value_type;
-   typedef typename Iterator::pointer           pointer;
-   typedef typename Iterator::reference         reference;
-   typedef typename Iterator::iterator_category iterator_category;
-   typedef typename boost::move_detail::make_unsigned<difference_type>::type size_type;
+   typedef typename iter_difference<Iterator>::type   difference_type;
+   typedef typename iter_value<Iterator>::type        value_type;
+   typedef typename Iterator::pointer                 pointer;
+   typedef typename Iterator::reference               reference;
+   typedef typename iter_category<Iterator>::type     iterator_category;
 };
 
 template<class T>
@@ -59,7 +145,6 @@ struct iterator_traits<T*>
    typedef T*                                pointer;
    typedef T&                                reference;
    typedef std::random_access_iterator_tag   iterator_category;
-   typedef typename boost::move_detail::make_unsigned<difference_type>::type size_type;
 };
 
 template<class T>
@@ -70,9 +155,23 @@ struct iterator_traits<const T*>
    typedef const T*                          pointer;
    typedef const T&                          reference;
    typedef std::random_access_iterator_tag   iterator_category;
-   typedef typename boost::move_detail::make_unsigned<difference_type>::type size_type;
 };
 
-}} //namespace boost {  namespace movelib{
+}} //namespace boost::movelib
+
+#endif   //
+
+#include <boost/move/detail/type_traits.hpp>
+
+namespace boost {
+namespace movelib {
+
+template<class T>
+struct iter_size
+   : boost::move_detail::
+      make_unsigned<typename iter_difference<T>::type >
+{};
+
+}}  //namespace boost move_detail {
 
 #endif //#ifndef BOOST_MOVE_DETAIL_ITERATOR_TRAITS_HPP