passenger 6.0.8 → 6.0.20

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;
@@ -186,7 +192,8 @@ namespace pdqsort_detail {
 
         // Put the pivot in the right place.
         Iter pivot_pos = first - 1;
-        *begin = boost::move(*pivot_pos);
+        if(begin != pivot_pos)   //Avoid potential self-move
+            *begin = boost::move(*pivot_pos);
         *pivot_pos = boost::move(pivot);
 
         return pdqsort_detail::pair<Iter, bool>(pivot_pos, already_partitioned);
@@ -225,10 +232,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 +329,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,10 @@
 #include <boost/move/utility_core.hpp>
 #include <boost/move/detail/iterator_traits.hpp>
 #include <boost/move/detail/iterator_to_raw_pointer.hpp>
-#include <boost/core/no_exceptions_support.hpp>
+#include <boost/move/detail/addressof.hpp>
+#if defined(BOOST_MOVE_USE_STANDARD_LIBRARY_MOVE)
+#include <algorithm>
+#endif
 
 namespace boost {
 
@@ -118,20 +121,20 @@ F uninitialized_move(I f, I l, F r
    typedef typename boost::movelib::iterator_traits<I>::value_type input_value_type;
 
    F back = r;
-   BOOST_TRY{
+   BOOST_MOVE_TRY{
       while (f != l) {
          void * const addr = static_cast<void*>(::boost::move_detail::addressof(*r));
          ::new(addr) input_value_type(::boost::move(*f));
          ++f; ++r;
       }
    }
-   BOOST_CATCH(...){
+   BOOST_MOVE_CATCH(...){
       for (; back != r; ++back){
          boost::movelib::iterator_to_raw_pointer(back)->~input_value_type();
       }
-      BOOST_RETHROW;
+      BOOST_MOVE_RETHROW;
    }
-   BOOST_CATCH_END
+   BOOST_MOVE_CATCH_END
    return r;
 }
 

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

@@ -16,7 +16,7 @@
 #include <boost/move/algo/detail/basic_op.hpp>
 #include <boost/move/detail/iterator_traits.hpp>
 #include <boost/move/detail/destruct_n.hpp>
-#include <boost/assert.hpp>
+#include <cassert>
 
 namespace boost {
 namespace movelib {
@@ -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/algorithm.hpp

@@ -27,7 +27,6 @@
 #include <boost/move/utility_core.hpp>
 #include <boost/move/iterator.hpp>
 #include <boost/move/algo/move.hpp>
-#include <boost/core/no_exceptions_support.hpp>
 
 #include <algorithm> //copy, copy_backward
 #include <memory>    //uninitialized_copy

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/default_delete.hpp

@@ -23,7 +23,6 @@
 #include <boost/move/detail/workaround.hpp>
 #include <boost/move/detail/unique_ptr_meta_utils.hpp>
 #include <boost/move/utility_core.hpp>
-#include <boost/static_assert.hpp>
 
 #include <cstddef>   //For std::size_t,std::nullptr_t
 
@@ -112,6 +111,33 @@ void call_delete(T *p, is_array_del<false>)
    delete p;
 }
 
+template< class T, class U
+        , bool enable =  def_del_compatible_cond< U, T>::value &&
+                        !move_upmu::is_array<T>::value &&
+                        !move_upmu::is_same<typename move_upmu::remove_cv<T>::type, void>::value &&
+                        !move_upmu::is_same<typename move_upmu::remove_cv<U>::type, typename move_upmu::remove_cv<T>::type>::value
+        >
+struct missing_virtual_destructor_default_delete
+{  static const bool value = !move_upmu::has_virtual_destructor<T>::value;  };
+
+template<class T, class U>
+struct missing_virtual_destructor_default_delete<T, U, false>
+{  static const bool value = false;  };
+
+//////////////////////////////////////
+//       missing_virtual_destructor
+//////////////////////////////////////
+
+template<class Deleter, class U>
+struct missing_virtual_destructor
+{  static const bool value = false;  };
+
+template<class T, class U>
+struct missing_virtual_destructor< ::boost::movelib::default_delete<T>, U >
+   : missing_virtual_destructor_default_delete<T, U>
+{};
+
+
 }  //namespace move_upd {
 // @endcond
 
@@ -163,7 +189,7 @@ struct default_delete
    {
       //If T is not an array type, U derives from T
       //and T has no virtual destructor, then you have a problem
-      BOOST_STATIC_ASSERT(( !::boost::move_upmu::missing_virtual_destructor<default_delete, U>::value ));
+      BOOST_MOVE_STATIC_ASSERT(( !bmupd::missing_virtual_destructor<default_delete, U>::value ));
    }
 
    //! <b>Effects</b>: Constructs a default_delete object from another <tt>default_delete<U></tt> object.
@@ -178,7 +204,7 @@ struct default_delete
    {
       //If T is not an array type, U derives from T
       //and T has no virtual destructor, then you have a problem
-      BOOST_STATIC_ASSERT(( !::boost::move_upmu::missing_virtual_destructor<default_delete, U>::value ));
+      BOOST_MOVE_STATIC_ASSERT(( !bmupd::missing_virtual_destructor<default_delete, U>::value ));
       return *this;
    }
 
@@ -195,10 +221,10 @@ struct default_delete
       operator()(U* ptr) const BOOST_NOEXCEPT
    {
       //U must be a complete type
-      BOOST_STATIC_ASSERT(sizeof(U) > 0);
+      BOOST_MOVE_STATIC_ASSERT(sizeof(U) > 0);
       //If T is not an array type, U derives from T
       //and T has no virtual destructor, then you have a problem
-      BOOST_STATIC_ASSERT(( !::boost::move_upmu::missing_virtual_destructor<default_delete, U>::value ));
+      BOOST_MOVE_STATIC_ASSERT(( !bmupd::missing_virtual_destructor<default_delete, U>::value ));
       element_type * const p = static_cast<element_type*>(ptr);
       move_upd::call_delete(p, move_upd::is_array_del<bmupmu::is_array<T>::value>());
    }
@@ -206,7 +232,7 @@ struct default_delete
    //! <b>Effects</b>: Same as <tt>(*this)(static_cast<element_type*>(nullptr))</tt>.
    //!
    void operator()(BOOST_MOVE_DOC0PTR(bmupd::nullptr_type)) const BOOST_NOEXCEPT
-   {  BOOST_STATIC_ASSERT(sizeof(element_type) > 0);  }
+   {  BOOST_MOVE_STATIC_ASSERT(sizeof(element_type) > 0);  }
 };
 
 }  //namespace movelib {

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/config_begin.hpp

@@ -13,6 +13,7 @@
 
 #ifdef BOOST_MSVC
 #  pragma warning (push)
+#  pragma warning (disable : 4619) // there is no warning number 'XXXX'
 #  pragma warning (disable : 4324) // structure was padded due to __declspec(align())
 #  pragma warning (disable : 4675) // "function":  resolved overload was found by argument-dependent lookup
 #  pragma warning (disable : 4996) // "function": was declared deprecated (_CRT_SECURE_NO_DEPRECATE/_SCL_SECURE_NO_WARNINGS)

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/fwd_macros.hpp

@@ -336,6 +336,18 @@ namespace move_detail {
 #define BOOST_MOVE_VAL_INITQ8 BOOST_MOVE_VAL_INITQ7, m_q7(q7)
 #define BOOST_MOVE_VAL_INITQ9 BOOST_MOVE_VAL_INITQ8, m_q8(q8)
 
+//BOOST_MOVE_UREFANONN
+#define BOOST_MOVE_UREFANON0
+#define BOOST_MOVE_UREFANON1                       BOOST_FWD_REF(P0)
+#define BOOST_MOVE_UREFANON2 BOOST_MOVE_UREFANON1, BOOST_FWD_REF(P1)
+#define BOOST_MOVE_UREFANON3 BOOST_MOVE_UREFANON2, BOOST_FWD_REF(P2)
+#define BOOST_MOVE_UREFANON4 BOOST_MOVE_UREFANON3, BOOST_FWD_REF(P3)
+#define BOOST_MOVE_UREFANON5 BOOST_MOVE_UREFANON4, BOOST_FWD_REF(P4)
+#define BOOST_MOVE_UREFANON6 BOOST_MOVE_UREFANON5, BOOST_FWD_REF(P5)
+#define BOOST_MOVE_UREFANON7 BOOST_MOVE_UREFANON6, BOOST_FWD_REF(P6)
+#define BOOST_MOVE_UREFANON8 BOOST_MOVE_UREFANON7, BOOST_FWD_REF(P7)
+#define BOOST_MOVE_UREFANON9 BOOST_MOVE_UREFANON8, BOOST_FWD_REF(P8)
+
 //BOOST_MOVE_UREFN
 #define BOOST_MOVE_UREF0
 #define BOOST_MOVE_UREF1                   BOOST_FWD_REF(P0) p0