passenger 6.0.20 → 6.0.21

data/src/cxx_supportlib/vendor-modified/boost/asio/detail/future.hpp

@@ -2,7 +2,7 @@
 // detail/future.hpp
 // ~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // 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)
@@ -16,18 +16,17 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
-#if defined(BOOST_ASIO_HAS_STD_FUTURE)
-# include <future>
+#include <future>
+
 // Even though the future header is available, libstdc++ may not implement the
 // std::future class itself. However, we need to have already included the
 // future header to reliably test for _GLIBCXX_HAS_GTHREADS.
-# if defined(__GNUC__) && !defined(BOOST_ASIO_HAS_CLANG_LIBCXX)
-#  if defined(_GLIBCXX_HAS_GTHREADS)
-#   define BOOST_ASIO_HAS_STD_FUTURE_CLASS 1
-#  endif // defined(_GLIBCXX_HAS_GTHREADS)
-# else // defined(__GNUC__) && !defined(BOOST_ASIO_HAS_CLANG_LIBCXX)
+#if defined(__GNUC__) && !defined(BOOST_ASIO_HAS_CLANG_LIBCXX)
+# if defined(_GLIBCXX_HAS_GTHREADS)
 #  define BOOST_ASIO_HAS_STD_FUTURE_CLASS 1
-# endif // defined(__GNUC__) && !defined(BOOST_ASIO_HAS_CLANG_LIBCXX)
-#endif // defined(BOOST_ASIO_HAS_STD_FUTURE)
+# endif // defined(_GLIBCXX_HAS_GTHREADS)
+#else // defined(__GNUC__) && !defined(BOOST_ASIO_HAS_CLANG_LIBCXX)
+# define BOOST_ASIO_HAS_STD_FUTURE_CLASS 1
+#endif // defined(__GNUC__) && !defined(BOOST_ASIO_HAS_CLANG_LIBCXX)
 
 #endif // BOOST_ASIO_DETAIL_FUTURE_HPP

data/src/cxx_supportlib/vendor-modified/boost/asio/detail/global.hpp

@@ -2,7 +2,7 @@
 // detail/global.hpp
 // ~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // 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)
@@ -23,10 +23,8 @@
 # include <boost/asio/detail/win_global.hpp>
 #elif defined(BOOST_ASIO_HAS_PTHREADS)
 # include <boost/asio/detail/posix_global.hpp>
-#elif defined(BOOST_ASIO_HAS_STD_CALL_ONCE)
-# include <boost/asio/detail/std_global.hpp>
 #else
-# error Only Windows, POSIX and std::call_once are supported!
+# include <boost/asio/detail/std_global.hpp>
 #endif
 
 namespace boost {
@@ -42,7 +40,7 @@ inline T& global()
   return win_global<T>();
 #elif defined(BOOST_ASIO_HAS_PTHREADS)
   return posix_global<T>();
-#elif defined(BOOST_ASIO_HAS_STD_CALL_ONCE)
+#else
   return std_global<T>();
 #endif
 }

data/src/cxx_supportlib/vendor-modified/boost/asio/detail/handler_alloc_helpers.hpp

@@ -2,7 +2,7 @@
 // detail/handler_alloc_helpers.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // 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)
@@ -21,68 +21,27 @@
 #include <boost/asio/detail/recycling_allocator.hpp>
 #include <boost/asio/detail/thread_info_base.hpp>
 #include <boost/asio/associated_allocator.hpp>
-#include <boost/asio/handler_alloc_hook.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
-// Calls to asio_handler_allocate and asio_handler_deallocate must be made from
-// a namespace that does not contain any overloads of these functions. The
-// boost_asio_handler_alloc_helpers namespace is defined here for that purpose.
-namespace boost_asio_handler_alloc_helpers {
-
-#if defined(BOOST_ASIO_NO_DEPRECATED)
-template <typename Handler>
-inline void error_if_hooks_are_defined(Handler& h)
-{
-  using boost::asio::asio_handler_allocate;
-  // If you get an error here it is because some of your handlers still
-  // overload asio_handler_allocate, but this hook is no longer used.
-  (void)static_cast<boost::asio::asio_handler_allocate_is_no_longer_used>(
-    asio_handler_allocate(static_cast<std::size_t>(0),
-      boost::asio::detail::addressof(h)));
-
-  using boost::asio::asio_handler_deallocate;
-  // If you get an error here it is because some of your handlers still
-  // overload asio_handler_deallocate, but this hook is no longer used.
-  (void)static_cast<boost::asio::asio_handler_deallocate_is_no_longer_used>(
-    asio_handler_deallocate(static_cast<void*>(0),
-      static_cast<std::size_t>(0), boost::asio::detail::addressof(h)));
-}
-#endif // defined(BOOST_ASIO_NO_DEPRECATED)
+namespace boost {
+namespace asio {
+namespace detail {
 
-template <typename Handler>
-inline void* allocate(std::size_t s, Handler& h,
+inline void* default_allocate(std::size_t s,
     std::size_t align = BOOST_ASIO_DEFAULT_ALIGN)
 {
-#if !defined(BOOST_ASIO_HAS_HANDLER_HOOKS)
-  return boost::asio::aligned_new(align, s);
-#elif defined(BOOST_ASIO_NO_DEPRECATED)
-  // The asio_handler_allocate hook is no longer used to obtain memory.
-  (void)&error_if_hooks_are_defined<Handler>;
-  (void)h;
-# if !defined(BOOST_ASIO_DISABLE_SMALL_BLOCK_RECYCLING)
+#if !defined(BOOST_ASIO_DISABLE_SMALL_BLOCK_RECYCLING)
   return boost::asio::detail::thread_info_base::allocate(
       boost::asio::detail::thread_context::top_of_thread_call_stack(),
       s, align);
-# else // !defined(BOOST_ASIO_DISABLE_SMALL_BLOCK_RECYCLING)
+#else // !defined(BOOST_ASIO_DISABLE_SMALL_BLOCK_RECYCLING)
   return boost::asio::aligned_new(align, s);
-# endif // !defined(BOOST_ASIO_DISABLE_SMALL_BLOCK_RECYCLING)
-#else
-  (void)align;
-  using boost::asio::asio_handler_allocate;
-  return asio_handler_allocate(s, boost::asio::detail::addressof(h));
-#endif
+#endif // !defined(BOOST_ASIO_DISABLE_SMALL_BLOCK_RECYCLING)
 }
 
-template <typename Handler>
-inline void deallocate(void* p, std::size_t s, Handler& h)
+inline void default_deallocate(void* p, std::size_t s)
 {
-#if !defined(BOOST_ASIO_HAS_HANDLER_HOOKS)
-  boost::asio::aligned_delete(p);
-#elif defined(BOOST_ASIO_NO_DEPRECATED)
-  // The asio_handler_allocate hook is no longer used to obtain memory.
-  (void)&error_if_hooks_are_defined<Handler>;
-  (void)h;
 #if !defined(BOOST_ASIO_DISABLE_SMALL_BLOCK_RECYCLING)
   boost::asio::detail::thread_info_base::deallocate(
       boost::asio::detail::thread_context::top_of_thread_call_stack(), p, s);
@@ -90,20 +49,10 @@ inline void deallocate(void* p, std::size_t s, Handler& h)
   (void)s;
   boost::asio::aligned_delete(p);
 #endif // !defined(BOOST_ASIO_DISABLE_SMALL_BLOCK_RECYCLING)
-#else
-  using boost::asio::asio_handler_deallocate;
-  asio_handler_deallocate(p, s, boost::asio::detail::addressof(h));
-#endif
 }
 
-} // namespace boost_asio_handler_alloc_helpers
-
-namespace boost {
-namespace asio {
-namespace detail {
-
-template <typename Handler, typename T>
-class hook_allocator
+template <typename T>
+class default_allocator
 {
 public:
   typedef T value_type;
@@ -111,38 +60,31 @@ public:
   template <typename U>
   struct rebind
   {
-    typedef hook_allocator<Handler, U> other;
+    typedef default_allocator<U> other;
   };
 
-  explicit hook_allocator(Handler& h)
-    : handler_(h)
+  default_allocator() noexcept
   {
   }
 
   template <typename U>
-  hook_allocator(const hook_allocator<Handler, U>& a)
-    : handler_(a.handler_)
+  default_allocator(const default_allocator<U>&) noexcept
   {
   }
 
   T* allocate(std::size_t n)
   {
-    return static_cast<T*>(
-        boost_asio_handler_alloc_helpers::allocate(
-          sizeof(T) * n, handler_, BOOST_ASIO_ALIGNOF(T)));
+    return static_cast<T*>(default_allocate(sizeof(T) * n, alignof(T)));
   }
 
   void deallocate(T* p, std::size_t n)
   {
-    boost_asio_handler_alloc_helpers::deallocate(p, sizeof(T) * n, handler_);
+    default_deallocate(p, sizeof(T) * n);
   }
-
-//private:
-  Handler& handler_;
 };
 
-template <typename Handler>
-class hook_allocator<Handler, void>
+template <>
+class default_allocator<void>
 {
 public:
   typedef void value_type;
@@ -150,43 +92,38 @@ public:
   template <typename U>
   struct rebind
   {
-    typedef hook_allocator<Handler, U> other;
+    typedef default_allocator<U> other;
   };
 
-  explicit hook_allocator(Handler& h)
-    : handler_(h)
+  default_allocator() noexcept
   {
   }
 
   template <typename U>
-  hook_allocator(const hook_allocator<Handler, U>& a)
-    : handler_(a.handler_)
+  default_allocator(const default_allocator<U>&) noexcept
   {
   }
-
-//private:
-  Handler& handler_;
 };
 
-template <typename Handler, typename Allocator>
-struct get_hook_allocator
+template <typename Allocator>
+struct get_default_allocator
 {
   typedef Allocator type;
 
-  static type get(Handler&, const Allocator& a)
+  static type get(const Allocator& a)
   {
     return a;
   }
 };
 
-template <typename Handler, typename T>
-struct get_hook_allocator<Handler, std::allocator<T> >
+template <typename T>
+struct get_default_allocator<std::allocator<T>>
 {
-  typedef hook_allocator<Handler, T> type;
+  typedef default_allocator<T> type;
 
-  static type get(Handler& handler, const std::allocator<T>&)
+  static type get(const std::allocator<T>&)
   {
-    return type(handler);
+    return type();
   }
 };
 
@@ -208,12 +145,12 @@ struct get_hook_allocator<Handler, std::allocator<T> >
     { \
       typedef typename ::boost::asio::associated_allocator< \
         Handler>::type associated_allocator_type; \
-      typedef typename ::boost::asio::detail::get_hook_allocator< \
-        Handler, associated_allocator_type>::type hook_allocator_type; \
-      BOOST_ASIO_REBIND_ALLOC(hook_allocator_type, op) a( \
-            ::boost::asio::detail::get_hook_allocator< \
-              Handler, associated_allocator_type>::get( \
-                handler, ::boost::asio::get_associated_allocator(handler))); \
+      typedef typename ::boost::asio::detail::get_default_allocator< \
+        associated_allocator_type>::type default_allocator_type; \
+      BOOST_ASIO_REBIND_ALLOC(default_allocator_type, op) a( \
+            ::boost::asio::detail::get_default_allocator< \
+              associated_allocator_type>::get( \
+                ::boost::asio::get_associated_allocator(handler))); \
       return a.allocate(1); \
     } \
     void reset() \
@@ -227,12 +164,12 @@ struct get_hook_allocator<Handler, std::allocator<T> >
       { \
         typedef typename ::boost::asio::associated_allocator< \
           Handler>::type associated_allocator_type; \
-        typedef typename ::boost::asio::detail::get_hook_allocator< \
-          Handler, associated_allocator_type>::type hook_allocator_type; \
-        BOOST_ASIO_REBIND_ALLOC(hook_allocator_type, op) a( \
-              ::boost::asio::detail::get_hook_allocator< \
-                Handler, associated_allocator_type>::get( \
-                  *h, ::boost::asio::get_associated_allocator(*h))); \
+        typedef typename ::boost::asio::detail::get_default_allocator< \
+          associated_allocator_type>::type default_allocator_type; \
+        BOOST_ASIO_REBIND_ALLOC(default_allocator_type, op) a( \
+              ::boost::asio::detail::get_default_allocator< \
+                associated_allocator_type>::get( \
+                  ::boost::asio::get_associated_allocator(*h))); \
         a.deallocate(static_cast<op*>(v), 1); \
         v = 0; \
       } \

data/src/cxx_supportlib/vendor-modified/boost/asio/detail/handler_cont_helpers.hpp

@@ -2,7 +2,7 @@
 // detail/handler_cont_helpers.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // 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)

data/src/cxx_supportlib/vendor-modified/boost/asio/detail/handler_tracking.hpp

@@ -2,7 +2,7 @@
 // detail/handler_tracking.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // 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)
@@ -102,8 +102,8 @@ public:
 
   private:
     // Disallow copying and assignment.
-    location(const location&) BOOST_ASIO_DELETED;
-    location& operator=(const location&) BOOST_ASIO_DELETED;
+    location(const location&) = delete;
+    location& operator=(const location&) = delete;
 
     friend class handler_tracking;
     const char* file_;

data/src/cxx_supportlib/vendor-modified/boost/asio/detail/handler_type_requirements.hpp

@@ -2,7 +2,7 @@
 // detail/handler_type_requirements.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
 // 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)
@@ -65,7 +65,7 @@ template <typename Handler>
 auto zero_arg_copyable_handler_test(Handler h, void*)
   -> decltype(
     sizeof(Handler(static_cast<const Handler&>(h))),
-    (BOOST_ASIO_MOVE_OR_LVALUE(Handler)(h)()),
+    (static_cast<Handler&&>(h)()),
     char(0));
 
 template <typename Handler>
@@ -74,8 +74,8 @@ char (&zero_arg_copyable_handler_test(Handler, ...))[2];
 template <typename Handler, typename Arg1>
 auto one_arg_handler_test(Handler h, Arg1* a1)
   -> decltype(
-    sizeof(Handler(BOOST_ASIO_MOVE_CAST(Handler)(h))),
-    (BOOST_ASIO_MOVE_OR_LVALUE(Handler)(h)(*a1)),
+    sizeof(Handler(static_cast<Handler&&>(h))),
+    (static_cast<Handler&&>(h)(*a1)),
     char(0));
 
 template <typename Handler>
@@ -84,8 +84,8 @@ char (&one_arg_handler_test(Handler h, ...))[2];
 template <typename Handler, typename Arg1, typename Arg2>
 auto two_arg_handler_test(Handler h, Arg1* a1, Arg2* a2)
   -> decltype(
-    sizeof(Handler(BOOST_ASIO_MOVE_CAST(Handler)(h))),
-    (BOOST_ASIO_MOVE_OR_LVALUE(Handler)(h)(*a1, *a2)),
+    sizeof(Handler(static_cast<Handler&&>(h))),
+    (static_cast<Handler&&>(h)(*a1, *a2)),
     char(0));
 
 template <typename Handler>
@@ -94,9 +94,9 @@ char (&two_arg_handler_test(Handler, ...))[2];
 template <typename Handler, typename Arg1, typename Arg2>
 auto two_arg_move_handler_test(Handler h, Arg1* a1, Arg2* a2)
   -> decltype(
-    sizeof(Handler(BOOST_ASIO_MOVE_CAST(Handler)(h))),
-    (BOOST_ASIO_MOVE_OR_LVALUE(Handler)(h)(
-      *a1, BOOST_ASIO_MOVE_CAST(Arg2)(*a2))),
+    sizeof(Handler(static_cast<Handler&&>(h))),
+    (static_cast<Handler&&>(h)(
+      *a1, static_cast<Arg2&&>(*a2))),
     char(0));
 
 template <typename Handler>
@@ -115,15 +115,9 @@ template <typename T> T& lvref();
 template <typename T> T& lvref(T);
 template <typename T> const T& clvref();
 template <typename T> const T& clvref(T);
-#if defined(BOOST_ASIO_HAS_MOVE)
 template <typename T> T rvref();
 template <typename T> T rvref(T);
 template <typename T> T rorlvref();
-#else // defined(BOOST_ASIO_HAS_MOVE)
-template <typename T> const T& rvref();
-template <typename T> const T& rvref(T);
-template <typename T> T& rorlvref();
-#endif // defined(BOOST_ASIO_HAS_MOVE)
 template <typename T> char argbyv(T);
 
 template <int>