passenger 6.0.14 → 6.0.15

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

@@ -21,6 +21,7 @@
 #include <boost/move/detail/workaround.hpp>  //forceinline
 #include <boost/move/detail/meta_utils_core.hpp>
 #include <cstddef>   //for std::size_t
+#include <boost/move/detail/addressof.hpp>
 
 //Small meta-typetraits to support move
 
@@ -56,8 +57,8 @@ struct apply
 template< bool C_ >
 struct bool_ : integral_constant<bool, C_>
 {
-     operator bool() const { return C_; }
-   bool operator()() const { return C_; }
+   BOOST_MOVE_FORCEINLINE operator bool() const { return C_; }
+   BOOST_MOVE_FORCEINLINE bool operator()() const { return C_; }
 };
 
 typedef bool_<true>        true_;
@@ -70,6 +71,10 @@ struct nat{};
 struct nat2{};
 struct nat3{};
 
+template <unsigned N>
+struct natN
+{};
+
 //////////////////////////////////////
 //          yes_type/no_type
 //////////////////////////////////////
@@ -220,7 +225,7 @@ struct identity
 {
    typedef T type;
    typedef typename add_const_lvalue_reference<T>::type reference;
-   reference operator()(reference t)
+   BOOST_MOVE_FORCEINLINE reference operator()(reference t) const
    {  return t;   }
 };
 
@@ -241,36 +246,7 @@ struct is_class_or_union
 //////////////////////////////////////
 //             addressof
 //////////////////////////////////////
-template<class T>
-struct addr_impl_ref
-{
-   T & v_;
-   BOOST_MOVE_FORCEINLINE addr_impl_ref( T & v ): v_( v ) {}
-   BOOST_MOVE_FORCEINLINE operator T& () const { return v_; }
-
-   private:
-   addr_impl_ref & operator=(const addr_impl_ref &);
-};
 
-template<class T>
-struct addressof_impl
-{
-   BOOST_MOVE_FORCEINLINE static T * f( T & v, long )
-   {
-      return reinterpret_cast<T*>(
-         &const_cast<char&>(reinterpret_cast<const volatile char &>(v)));
-   }
-
-   BOOST_MOVE_FORCEINLINE static T * f( T * v, int )
-   {  return v;  }
-};
-
-template<class T>
-BOOST_MOVE_FORCEINLINE T * addressof( T & v )
-{
-   return ::boost::move_detail::addressof_impl<T>::f
-      ( ::boost::move_detail::addr_impl_ref<T>( v ), 0 );
-}
 
 //////////////////////////////////////
 //          has_pointer_type

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

@@ -82,7 +82,7 @@ inline boost::uint64_t nsec_clock() BOOST_NOEXCEPT
       }
    }
 
-   return static_cast<boost::uint64_t>((nanosecs_per_tic) * pcount.QuadPart);
+   return static_cast<boost::uint64_t>(nanosecs_per_tic * double(pcount.QuadPart));
 }
 
 }}  //namespace boost { namespace move_detail {
@@ -121,9 +121,9 @@ inline boost::uint64_t nsec_clock() BOOST_NOEXCEPT
 {
    struct timespec count;
    ::clock_gettime(BOOST_MOVE_DETAIL_CLOCK_MONOTONIC, &count);
-   boost::uint64_t r = count.tv_sec;
+   boost::uint64_t r = static_cast<boost::uint64_t>(count.tv_sec);
    r *= 1000000000U;
-   r += count.tv_nsec;
+   r += static_cast<boost::uint64_t>(count.tv_nsec);
    return r;
 }
 
@@ -140,6 +140,9 @@ struct cpu_times
    nanosecond_type system;
 
    void clear() { wall = user = system = 0; }
+
+   cpu_times()
+   {  this->clear(); }
 };
 
 

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

@@ -28,6 +28,14 @@
 namespace boost {
 namespace movelib {
 
+template<class I>
+BOOST_MOVE_FORCEINLINE typename iterator_traits<I>::pointer iterator_arrow_result(const I &i)
+{  return i.operator->();  }
+
+template<class T>
+BOOST_MOVE_FORCEINLINE T * iterator_arrow_result(T *p)
+{  return p;   }
+
 template<class It>
 class reverse_iterator
 {
@@ -41,37 +49,38 @@ class reverse_iterator
 
    typedef It iterator_type;
 
-   reverse_iterator()
+   BOOST_MOVE_FORCEINLINE reverse_iterator()
       : m_current()  //Value initialization to achieve "null iterators" (N3644)
    {}
 
-   explicit reverse_iterator(It r)
+   BOOST_MOVE_FORCEINLINE explicit reverse_iterator(It r)
       : m_current(r)
    {}
 
-   reverse_iterator(const reverse_iterator& r)
+   BOOST_MOVE_FORCEINLINE reverse_iterator(const reverse_iterator& r)
       : m_current(r.base())
    {}
 
    template<class OtherIt>
-   reverse_iterator( const reverse_iterator<OtherIt>& r
-                   , typename boost::move_detail::enable_if_convertible<OtherIt, It>::type* =0
+   BOOST_MOVE_FORCEINLINE
+      reverse_iterator( const reverse_iterator<OtherIt>& r
+                      , typename boost::move_detail::enable_if_convertible<OtherIt, It>::type* =0
                    )
       : m_current(r.base())
    {}
 
-   reverse_iterator & operator=( const reverse_iterator& r)
+   BOOST_MOVE_FORCEINLINE reverse_iterator & operator=( const reverse_iterator& r)
    {  m_current = r.base();   return *this;  }
 
    template<class OtherIt>
-   typename boost::move_detail::enable_if_convertible<OtherIt, It, reverse_iterator &>::type
+   BOOST_MOVE_FORCEINLINE typename boost::move_detail::enable_if_convertible<OtherIt, It, reverse_iterator &>::type
          operator=( const reverse_iterator<OtherIt>& r)
    {  m_current = r.base();   return *this;  }
 
-   It base() const
+   BOOST_MOVE_FORCEINLINE It base() const
    {  return m_current;  }
 
-   reference operator*() const
+   BOOST_MOVE_FORCEINLINE reference operator*() const
    {
       It temp(m_current);
       --temp;
@@ -79,78 +88,78 @@ class reverse_iterator
       return r;
    }
 
-   pointer operator->() const
+   BOOST_MOVE_FORCEINLINE pointer operator->() const
    {
       It temp(m_current);
       --temp;
-      return iterator_arrow_result(temp);
+      return (iterator_arrow_result)(temp);
    }
 
-   reference operator[](difference_type off) const
+   BOOST_MOVE_FORCEINLINE reference operator[](difference_type off) const
    {
-      return this->m_current[-off - 1];
+      return this->m_current[difference_type(-off - 1)];
    }
 
-   reverse_iterator& operator++()
+   BOOST_MOVE_FORCEINLINE reverse_iterator& operator++()
    {
       --m_current;
       return *this;
    }
 
-   reverse_iterator operator++(int)
+   BOOST_MOVE_FORCEINLINE reverse_iterator operator++(int)
    {
       reverse_iterator temp((*this));
       --m_current;
       return temp;
    }
 
-   reverse_iterator& operator--()
+   BOOST_MOVE_FORCEINLINE reverse_iterator& operator--()
    {
       ++m_current;
       return *this;
    }
 
-   reverse_iterator operator--(int)
+   BOOST_MOVE_FORCEINLINE reverse_iterator operator--(int)
    {
       reverse_iterator temp((*this));
       ++m_current;
       return temp;
    }
 
-   friend bool operator==(const reverse_iterator& l, const reverse_iterator& r)
+   BOOST_MOVE_FORCEINLINE friend bool operator==(const reverse_iterator& l, const reverse_iterator& r)
    {  return l.m_current == r.m_current;  }
 
-   friend bool operator!=(const reverse_iterator& l, const reverse_iterator& r)
+   BOOST_MOVE_FORCEINLINE friend bool operator!=(const reverse_iterator& l, const reverse_iterator& r)
    {  return l.m_current != r.m_current;  }
 
-   friend bool operator<(const reverse_iterator& l, const reverse_iterator& r)
+   BOOST_MOVE_FORCEINLINE friend bool operator<(const reverse_iterator& l, const reverse_iterator& r)
    {  return l.m_current > r.m_current;  }
 
-   friend bool operator<=(const reverse_iterator& l, const reverse_iterator& r)
+   BOOST_MOVE_FORCEINLINE friend bool operator<=(const reverse_iterator& l, const reverse_iterator& r)
    {  return l.m_current >= r.m_current;  }
 
-   friend bool operator>(const reverse_iterator& l, const reverse_iterator& r)
+   BOOST_MOVE_FORCEINLINE friend bool operator>(const reverse_iterator& l, const reverse_iterator& r)
    {  return l.m_current < r.m_current;  }
 
-   friend bool operator>=(const reverse_iterator& l, const reverse_iterator& r)
+   BOOST_MOVE_FORCEINLINE friend bool operator>=(const reverse_iterator& l, const reverse_iterator& r)
    {  return l.m_current <= r.m_current;  }
 
-   reverse_iterator& operator+=(difference_type off)
+   BOOST_MOVE_FORCEINLINE reverse_iterator& operator+=(difference_type off)
    {  m_current -= off; return *this;  }
 
-   reverse_iterator& operator-=(difference_type off)
+   BOOST_MOVE_FORCEINLINE reverse_iterator& operator-=(difference_type off)
    {  m_current += off; return *this;  }
 
-   friend reverse_iterator operator+(reverse_iterator l, difference_type off)
+   BOOST_MOVE_FORCEINLINE friend reverse_iterator operator+(reverse_iterator l, difference_type off)
    {  return (l += off);  }
 
-   friend reverse_iterator operator+(difference_type off, reverse_iterator r)
+   BOOST_MOVE_FORCEINLINE friend reverse_iterator operator+(difference_type off, reverse_iterator r)
    {  return (r += off);   }
 
-   friend reverse_iterator operator-(reverse_iterator l, difference_type off)
+   BOOST_MOVE_FORCEINLINE friend reverse_iterator operator-(reverse_iterator l, difference_type off)
    {  return (l-= off);  }
 
-   friend difference_type operator-(const reverse_iterator& l, const reverse_iterator& r)
+   BOOST_MOVE_FORCEINLINE friend difference_type operator-(const reverse_iterator& l, const reverse_iterator& r)
    {  return r.m_current - l.m_current;  }
 
    private:
@@ -158,10 +167,8 @@ class reverse_iterator
 };
 
 template< class Iterator >
-reverse_iterator<Iterator> make_reverse_iterator( Iterator i )
-{
-    return reverse_iterator<Iterator>(i);
-}
+BOOST_MOVE_FORCEINLINE reverse_iterator<Iterator> make_reverse_iterator( Iterator i )
+{  return reverse_iterator<Iterator>(i);  }
 
 } //namespace movelib {
 } //namespace boost {

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

@@ -24,7 +24,11 @@
    #define BOOST_MOVE_STD_NS_BEG _GLIBCXX_BEGIN_NAMESPACE(std)
    #define BOOST_MOVE_STD_NS_END _GLIBCXX_END_NAMESPACE
 #else
+   #if defined(_MSC_VER) && (_MSC_VER >= 1915)
+      #pragma warning (push)
+      #pragma warning (disable : 4643) // Forward declaring 'X' in namespace std is not permitted by the C++ Standard
+   #endif
+
    #define BOOST_MOVE_STD_NS_BEG namespace std{
    #define BOOST_MOVE_STD_NS_END }
 #endif
-

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

@@ -11,4 +11,6 @@
 #ifdef BOOST_MOVE_STD_NS_GCC_DIAGNOSTIC_PUSH
    #pragma GCC diagnostic pop
    #undef BOOST_MOVE_STD_NS_GCC_DIAGNOSTIC_PUSH
+#elif defined(_MSC_VER) && (_MSC_VER >= 1915)
+   #pragma warning (pop)
 #endif   //BOOST_MOVE_STD_NS_GCC_DIAGNOSTIC_PUSH

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

@@ -1102,7 +1102,7 @@ struct alignment_of
 class alignment_dummy;
 typedef void (*function_ptr)();
 typedef int (alignment_dummy::*member_ptr);
-typedef int (alignment_dummy::*member_function_ptr)();
+
 struct alignment_struct
 {  long double dummy[4];  };
 
@@ -1125,7 +1125,6 @@ union max_align
    long double long_double_[4];
    alignment_dummy *unknown_class_ptr_;
    function_ptr function_ptr_;
-   member_function_ptr member_function_ptr_;
    alignment_struct alignment_struct_;
 };
 

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

@@ -52,14 +52,16 @@
    #define BOOST_MOVE_MSVC_AUTO_MOVE_RETURN_BUG
 #endif
 
+//#define BOOST_MOVE_DISABLE_FORCEINLINE
+
 #if defined(BOOST_MOVE_DISABLE_FORCEINLINE)
    #define BOOST_MOVE_FORCEINLINE inline
 #elif defined(BOOST_MOVE_FORCEINLINE_IS_BOOST_FORCELINE)
    #define BOOST_MOVE_FORCEINLINE BOOST_FORCEINLINE
-#elif defined(BOOST_MSVC) && defined(_DEBUG)
-   //"__forceinline" and MSVC seems to have some bugs in debug mode
+#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_MOVE_FORCEINLINE inline
-#elif defined(__GNUC__) && ((__GNUC__ < 4) || (__GNUC__ == 4 && (__GNUC_MINOR__ < 5)))
+#elif defined(BOOST_GCC) && (__GNUC__ <= 5)
    //Older GCCs have problems with forceinline
    #define BOOST_MOVE_FORCEINLINE inline
 #else

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

@@ -38,12 +38,22 @@
  
 #if !defined(BOOST_MOVE_DOXYGEN_INVOKED)
 
+#if defined(_MSC_VER) && (_MSC_VER >= 1915)
+   #pragma warning (push)
+   #pragma warning (disable : 4643) // Forward declaring 'X' in namespace std is not permitted by the C++ Standard
+#endif
+
 namespace std {   //no namespace versioning in clang+libc++
 
 struct nothrow_t;
 
 }  //namespace std {
 
+#if defined(_MSC_VER) && (_MSC_VER >= 1915)
+   #pragma warning (pop)
+#endif
+
+
 namespace boost{
 namespace move_upmu {
 

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

@@ -258,44 +258,47 @@
 
       #endif   //BOOST_MOVE_DOXYGEN_INVOKED
 
-      //////////////////////////////////////////////////////////////////////////////
-      //
-      //                         move_if_not_lvalue_reference
-      //
-      //////////////////////////////////////////////////////////////////////////////
+      }  //namespace boost {
 
+   #endif   //BOOST_MOVE_USE_STANDARD_LIBRARY_MOVE
 
-      #if defined(BOOST_MOVE_DOXYGEN_INVOKED)
-         //! <b>Effects</b>: Calls `boost::move` if `input_reference` is not a lvalue reference.
-         //!   Otherwise returns the reference
-         template <class T> output_reference move_if_not_lvalue_reference(input_reference) noexcept;
-      #elif defined(BOOST_MOVE_OLD_RVALUE_REF_BINDING_RULES)
+   //////////////////////////////////////////////////////////////////////////////
+   //
+   //                         move_if_not_lvalue_reference
+   //
+   //////////////////////////////////////////////////////////////////////////////
 
-         //Old move approach, lvalues could bind to rvalue references
+   namespace boost {
 
-         template <class T>
-         BOOST_MOVE_FORCEINLINE T&& move_if_not_lvalue_reference(typename ::boost::move_detail::identity<T>::type&& t) BOOST_NOEXCEPT
-         {  return t;   }
+   #if defined(BOOST_MOVE_DOXYGEN_INVOKED)
+      //! <b>Effects</b>: Calls `boost::move` if `input_reference` is not a lvalue reference.
+      //!   Otherwise returns the reference
+      template <class T> output_reference move_if_not_lvalue_reference(input_reference) noexcept;
+   #elif defined(BOOST_MOVE_OLD_RVALUE_REF_BINDING_RULES)
 
-      #else //Old move
+      //Old move approach, lvalues could bind to rvalue references
 
-         template <class T>
-         BOOST_MOVE_FORCEINLINE T&& move_if_not_lvalue_reference(typename ::boost::move_detail::remove_reference<T>::type& t) BOOST_NOEXCEPT
-         {  return static_cast<T&&>(t);   }
+      template <class T>
+      BOOST_MOVE_FORCEINLINE T&& move_if_not_lvalue_reference(typename ::boost::move_detail::identity<T>::type&& t) BOOST_NOEXCEPT
+      {  return t;   }
 
-         template <class T>
-         BOOST_MOVE_FORCEINLINE T&& move_if_not_lvalue_reference(typename ::boost::move_detail::remove_reference<T>::type&& t) BOOST_NOEXCEPT
-         {
-            //"boost::forward<T> error: 'T' is a lvalue reference, can't forward as rvalue.";
-            BOOST_STATIC_ASSERT(!boost::move_detail::is_lvalue_reference<T>::value);
-            return static_cast<T&&>(t);
-         }
+   #else //Old move
 
-      #endif   //BOOST_MOVE_DOXYGEN_INVOKED
+      template <class T>
+      BOOST_MOVE_FORCEINLINE T&& move_if_not_lvalue_reference(typename ::boost::move_detail::remove_reference<T>::type& t) BOOST_NOEXCEPT
+      {  return static_cast<T&&>(t);   }
 
-      }  //namespace boost {
+      template <class T>
+      BOOST_MOVE_FORCEINLINE T&& move_if_not_lvalue_reference(typename ::boost::move_detail::remove_reference<T>::type&& t) BOOST_NOEXCEPT
+      {
+         //"boost::forward<T> error: 'T' is a lvalue reference, can't forward as rvalue.";
+         BOOST_STATIC_ASSERT(!boost::move_detail::is_lvalue_reference<T>::value);
+         return static_cast<T&&>(t);
+      }
+
+   #endif   //BOOST_MOVE_DOXYGEN_INVOKED
 
-   #endif   //#if defined(BOOST_MOVE_USE_STANDARD_LIBRARY_MOVE)
+   }  //namespace boost {
 
 #endif   //BOOST_NO_CXX11_RVALUE_REFERENCES