passenger 6.0.15 → 6.0.17

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

@@ -371,6 +371,17 @@
 #  endif // defined(BOOST_ASIO_MSVC)
 # endif // !defined(BOOST_ASIO_DISABLE_DECLTYPE)
 #endif // !defined(BOOST_ASIO_HAS_DECLTYPE)
+#if defined(BOOST_ASIO_HAS_DECLTYPE)
+# define BOOST_ASIO_AUTO_RETURN_TYPE_PREFIX(t) auto
+# define BOOST_ASIO_AUTO_RETURN_TYPE_PREFIX2(t0, t1) auto
+# define BOOST_ASIO_AUTO_RETURN_TYPE_PREFIX3(t0, t1, t2) auto
+# define BOOST_ASIO_AUTO_RETURN_TYPE_SUFFIX(expr) -> decltype expr
+#else // defined(BOOST_ASIO_HAS_DECLTYPE)
+# define BOOST_ASIO_AUTO_RETURN_TYPE_PREFIX(t) t
+# define BOOST_ASIO_AUTO_RETURN_TYPE_PREFIX2(t0, t1) t0, t1
+# define BOOST_ASIO_AUTO_RETURN_TYPE_PREFIX3(t0, t1, t2) t0, t1, t2
+# define BOOST_ASIO_AUTO_RETURN_TYPE_SUFFIX(expr)
+#endif // defined(BOOST_ASIO_HAS_DECLTYPE)
 
 // Support alias templates on compilers known to allow it.
 #if !defined(BOOST_ASIO_HAS_ALIAS_TEMPLATES)
@@ -407,7 +418,11 @@
 #   if (__cpp_return_type_deduction >= 201304)
 #    define BOOST_ASIO_HAS_RETURN_TYPE_DEDUCTION 1
 #   endif // (__cpp_return_type_deduction >= 201304)
-#  endif // defined(__cpp_return_type_deduction)
+#  elif defined(BOOST_ASIO_MSVC)
+#   if (_MSC_VER >= 1900 && _MSVC_LANG >= 201402)
+#    define BOOST_ASIO_HAS_RETURN_TYPE_DEDUCTION 1
+#   endif // (_MSC_VER >= 1900 && _MSVC_LANG >= 201402)
+#  endif // defined(BOOST_ASIO_MSVC)
 # endif // !defined(BOOST_ASIO_DISABLE_RETURN_TYPE_DEDUCTION)
 #endif // !defined(BOOST_ASIO_HAS_RETURN_TYPE_DEDUCTION)
 
@@ -675,6 +690,30 @@
 # endif // !defined(BOOST_ASIO_DISABLE_STD_ALIGNED_ALLOC)
 #endif // !defined(BOOST_ASIO_HAS_STD_ALIGNED_ALLOC)
 
+// Standard library support for std::align.
+#if !defined(BOOST_ASIO_HAS_STD_ALIGN)
+# if !defined(BOOST_ASIO_DISABLE_STD_ALIGN)
+#  if defined(__clang__)
+#   if defined(BOOST_ASIO_HAS_CLANG_LIBCXX)
+#    define BOOST_ASIO_HAS_STD_ALIGN 1
+#   elif (__cplusplus >= 201103)
+#    define BOOST_ASIO_HAS_STD_ALIGN 1
+#   endif // (__cplusplus >= 201103)
+#  elif defined(__GNUC__)
+#   if (__GNUC__ >= 6)
+#    if (__cplusplus >= 201103) || defined(__GXX_EXPERIMENTAL_CXX0X__)
+#     define BOOST_ASIO_HAS_STD_ALIGN 1
+#    endif // (__cplusplus >= 201103) || defined(__GXX_EXPERIMENTAL_CXX0X__)
+#   endif // (__GNUC__ >= 6)
+#  endif // defined(__GNUC__)
+#  if defined(BOOST_ASIO_MSVC)
+#   if (_MSC_VER >= 1700)
+#    define BOOST_ASIO_HAS_STD_ALIGN 1
+#   endif // (_MSC_VER >= 1700)
+#  endif // defined(BOOST_ASIO_MSVC)
+# endif // !defined(BOOST_ASIO_DISABLE_STD_ALIGN)
+#endif // !defined(BOOST_ASIO_HAS_STD_ALIGN)
+
 // Standard library support for system errors.
 # if !defined(BOOST_ASIO_DISABLE_STD_SYSTEM_ERROR)
 #  if defined(__clang__)
@@ -1311,14 +1350,11 @@
 #   if (_MSC_VER >= 1911 && _MSVC_LANG >= 201703)
 #    define BOOST_ASIO_HAS_STD_INVOKE_RESULT 1
 #   endif // (_MSC_VER >= 1911 && _MSVC_LANG >= 201703)
+#  else // defined(BOOST_ASIO_MSVC)
+#   if (__cplusplus >= 201703)
+#    define BOOST_ASIO_HAS_STD_INVOKE_RESULT 1
+#   endif // (__cplusplus >= 201703)
 #  endif // defined(BOOST_ASIO_MSVC)
-#  if defined(BOOST_ASIO_HAS_CLANG_LIBCXX)
-#   if (_LIBCPP_VERSION >= 13000)
-#    if (__cplusplus >= 201703)
-#     define BOOST_ASIO_HAS_STD_INVOKE_RESULT 1
-#    endif // (__cplusplus >= 201703)
-#   endif // (_LIBCPP_VERSION >= 13000)
-#  endif // defined(BOOST_ASIO_HAS_CLANG_LIBCXX)
 # endif // !defined(BOOST_ASIO_DISABLE_STD_INVOKE_RESULT)
 #endif // !defined(BOOST_ASIO_HAS_STD_INVOKE_RESULT)
 
@@ -2054,11 +2090,23 @@
 #    endif // defined(_RESUMABLE_FUNCTIONS_SUPPORTED)
 #   endif // (_MSC_FULL_VER >= 190023506)
 #  elif defined(__clang__)
-#   if (__cplusplus >= 201703) && (__cpp_coroutines >= 201703)
-#    if __has_include(<experimental/coroutine>)
-#     define BOOST_ASIO_HAS_CO_AWAIT 1
-#    endif // __has_include(<experimental/coroutine>)
-#   endif // (__cplusplus >= 201703) && (__cpp_coroutines >= 201703)
+#   if (__clang_major__ >= 14)
+#    if (__cplusplus >= 202002) && (__cpp_impl_coroutine >= 201902)
+#     if __has_include(<coroutine>)
+#      define BOOST_ASIO_HAS_CO_AWAIT 1
+#     endif // __has_include(<coroutine>)
+#    elif (__cplusplus >= 201703) && (__cpp_coroutines >= 201703)
+#     if __has_include(<experimental/coroutine>)
+#      define BOOST_ASIO_HAS_CO_AWAIT 1
+#     endif // __has_include(<experimental/coroutine>)
+#    endif // (__cplusplus >= 201703) && (__cpp_coroutines >= 201703)
+#   else // (__clang_major__ >= 14)
+#    if (__cplusplus >= 201703) && (__cpp_coroutines >= 201703)
+#     if __has_include(<experimental/coroutine>)
+#      define BOOST_ASIO_HAS_CO_AWAIT 1
+#     endif // __has_include(<experimental/coroutine>)
+#    endif // (__cplusplus >= 201703) && (__cpp_coroutines >= 201703)
+#   endif // (__clang_major__ >= 14)
 #  elif defined(__GNUC__)
 #   if (__cplusplus >= 201709) && (__cpp_impl_coroutine >= 201902)
 #    if __has_include(<coroutine>)
@@ -2076,8 +2124,15 @@
 #   if (_MSC_VER >= 1928) && (_MSVC_LANG >= 201705)
 #    define BOOST_ASIO_HAS_STD_COROUTINE 1
 #   endif // (_MSC_VER >= 1928) && (_MSVC_LANG >= 201705)
-#  endif // defined(BOOST_ASIO_MSVC)
-#  if defined(__GNUC__)
+#  elif defined(__clang__)
+#   if (__clang_major__ >= 14)
+#    if (__cplusplus >= 202002) && (__cpp_impl_coroutine >= 201902)
+#     if __has_include(<coroutine>)
+#      define BOOST_ASIO_HAS_STD_COROUTINE 1
+#     endif // __has_include(<coroutine>)
+#    endif // (__cplusplus >= 202002) && (__cpp_impl_coroutine >= 201902)
+#   endif // (__clang_major__ >= 14)
+#  elif defined(__GNUC__)
 #   if (__cplusplus >= 201709) && (__cpp_impl_coroutine >= 201902)
 #    if __has_include(<coroutine>)
 #     define BOOST_ASIO_HAS_STD_COROUTINE 1
@@ -2158,4 +2213,15 @@
 # endif // !defined(BOOST_ASIO_DISABLE_STD_TO_ADDRESS)
 #endif // !defined(BOOST_ASIO_HAS_STD_TO_ADDRESS)
 
+// Standard library support for snprintf.
+#if !defined(BOOST_ASIO_HAS_SNPRINTF)
+# if !defined(BOOST_ASIO_DISABLE_SNPRINTF)
+#  if defined(__apple_build_version__)
+#    if (__clang_major__ >= 14)
+#     define BOOST_ASIO_HAS_SNPRINTF 1
+#    endif // (__clang_major__ >= 14)
+#  endif // defined(__apple_build_version__)
+# endif // !defined(BOOST_ASIO_DISABLE_SNPRINTF)
+#endif // !defined(BOOST_ASIO_HAS_SNPRINTF)
+
 #endif // BOOST_ASIO_DETAIL_CONFIG_HPP

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

@@ -55,7 +55,7 @@ inline void* allocate(std::size_t s, Handler& h,
     std::size_t align = BOOST_ASIO_DEFAULT_ALIGN)
 {
 #if !defined(BOOST_ASIO_HAS_HANDLER_HOOKS)
-  return aligned_new(align, s);
+  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>;
@@ -65,7 +65,7 @@ inline void* allocate(std::size_t s, Handler& h,
       boost::asio::detail::thread_context::top_of_thread_call_stack(),
       s, align);
 # else // !defined(BOOST_ASIO_DISABLE_SMALL_BLOCK_RECYCLING)
-  return aligned_new(align, s);
+  return boost::asio::aligned_new(align, s);
 # endif // !defined(BOOST_ASIO_DISABLE_SMALL_BLOCK_RECYCLING)
 #else
   (void)align;
@@ -78,7 +78,7 @@ template <typename Handler>
 inline void deallocate(void* p, std::size_t s, Handler& h)
 {
 #if !defined(BOOST_ASIO_HAS_HANDLER_HOOKS)
-  aligned_delete(p);
+  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>;
@@ -88,7 +88,7 @@ inline void deallocate(void* p, std::size_t s, Handler& h)
       boost::asio::detail::thread_context::top_of_thread_call_stack(), p, s);
 #else // !defined(BOOST_ASIO_DISABLE_SMALL_BLOCK_RECYCLING)
   (void)s;
-  aligned_delete(p);
+  boost::asio::aligned_delete(p);
 #endif // !defined(BOOST_ASIO_DISABLE_SMALL_BLOCK_RECYCLING)
 #else
   using boost::asio::asio_handler_deallocate;

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

@@ -37,6 +37,7 @@ class io_context;
 
 #if !defined(BOOST_ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
 
+class any_completion_executor;
 class any_io_executor;
 
 #endif // !defined(BOOST_ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
@@ -95,11 +96,16 @@ public:
   template <typename Function, typename Handler>
   void dispatch(Function& function, Handler& handler)
   {
+#if defined(BOOST_ASIO_NO_DEPRECATED)
+    boost::asio::prefer(executor_,
+        execution::allocator((get_associated_allocator)(handler))
+      ).execute(BOOST_ASIO_MOVE_CAST(Function)(function));
+#else // defined(BOOST_ASIO_NO_DEPRECATED)
     execution::execute(
         boost::asio::prefer(executor_,
-          execution::blocking.possibly,
           execution::allocator((get_associated_allocator)(handler))),
         BOOST_ASIO_MOVE_CAST(Function)(function));
+#endif // defined(BOOST_ASIO_NO_DEPRECATED)
   }
 
 private:
@@ -361,9 +367,11 @@ public:
   template <typename Function, typename Handler>
   void dispatch(Function& function, Handler&)
   {
-    execution::execute(
-        boost::asio::prefer(executor_, execution::blocking.possibly),
-        BOOST_ASIO_MOVE_CAST(Function)(function));
+#if defined(BOOST_ASIO_NO_DEPRECATED)
+    executor_.execute(BOOST_ASIO_MOVE_CAST(Function)(function));
+#else // defined(BOOST_ASIO_NO_DEPRECATED)
+    execution::execute(executor_, BOOST_ASIO_MOVE_CAST(Function)(function));
+#endif // defined(BOOST_ASIO_NO_DEPRECATED)
   }
 
 private:
@@ -378,10 +386,8 @@ class handler_work_base<
     Executor, CandidateExecutor,
     IoContext, PolymorphicExecutor,
     typename enable_if<
-      is_same<
-        Executor,
-        any_io_executor
-      >::value
+      is_same<Executor, any_completion_executor>::value
+        || is_same<Executor, any_io_executor>::value
     >::type>
 {
 public:
@@ -436,9 +442,11 @@ public:
   template <typename Function, typename Handler>
   void dispatch(Function& function, Handler&)
   {
-    execution::execute(
-        boost::asio::prefer(executor_, execution::blocking.possibly),
-        BOOST_ASIO_MOVE_CAST(Function)(function));
+#if defined(BOOST_ASIO_NO_DEPRECATED)
+    executor_.execute(BOOST_ASIO_MOVE_CAST(Function)(function));
+#else // defined(BOOST_ASIO_NO_DEPRECATED)
+    execution::execute(executor_, BOOST_ASIO_MOVE_CAST(Function)(function));
+#endif // defined(BOOST_ASIO_NO_DEPRECATED)
   }
 
 private:

data/src/cxx_supportlib/vendor-modified/boost/asio/detail/impl/descriptor_ops.ipp

@@ -70,7 +70,18 @@ int close(int d, state_type& state, boost::system::error_code& ec)
         ::fcntl(d, F_SETFL, flags & ~O_NONBLOCK);
 #else // defined(__SYMBIAN32__) || defined(__EMSCRIPTEN__)
       ioctl_arg_type arg = 0;
+# if defined(ENOTTY)
+      result = ::ioctl(d, FIONBIO, &arg);
+      get_last_error(ec, result < 0);
+      if (ec.value() == ENOTTY)
+      {
+        int flags = ::fcntl(d, F_GETFL, 0);
+        if (flags >= 0)
+          ::fcntl(d, F_SETFL, flags & ~O_NONBLOCK);
+      }
+# else // defined(ENOTTY)
       ::ioctl(d, FIONBIO, &arg);
+# endif // defined(ENOTTY)
 #endif // defined(__SYMBIAN32__) || defined(__EMSCRIPTEN__)
       state &= ~non_blocking;
 
@@ -104,6 +115,19 @@ bool set_user_non_blocking(int d, state_type& state,
   ioctl_arg_type arg = (value ? 1 : 0);
   int result = ::ioctl(d, FIONBIO, &arg);
   get_last_error(ec, result < 0);
+# if defined(ENOTTY)
+  if (ec.value() == ENOTTY)
+  {
+    int result = ::fcntl(d, F_GETFL, 0);
+    get_last_error(ec, result < 0);
+    if (result >= 0)
+    {
+      int flag = (value ? (result | O_NONBLOCK) : (result & ~O_NONBLOCK));
+      result = ::fcntl(d, F_SETFL, flag);
+      get_last_error(ec, result < 0);
+    }
+  }
+# endif // defined(ENOTTY)
 #endif // defined(__SYMBIAN32__) || defined(__EMSCRIPTEN__)
 
   if (result >= 0)
@@ -154,6 +178,19 @@ bool set_internal_non_blocking(int d, state_type& state,
   ioctl_arg_type arg = (value ? 1 : 0);
   int result = ::ioctl(d, FIONBIO, &arg);
   get_last_error(ec, result < 0);
+# if defined(ENOTTY)
+  if (ec.value() == ENOTTY)
+  {
+    int result = ::fcntl(d, F_GETFL, 0);
+    get_last_error(ec, result < 0);
+    if (result >= 0)
+    {
+      int flag = (value ? (result | O_NONBLOCK) : (result & ~O_NONBLOCK));
+      result = ::fcntl(d, F_SETFL, flag);
+      get_last_error(ec, result < 0);
+    }
+  }
+# endif // defined(ENOTTY)
 #endif // defined(__SYMBIAN32__) || defined(__EMSCRIPTEN__)
 
   if (result >= 0)

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

@@ -366,7 +366,9 @@ void handler_tracking::write_line(const char* format, ...)
   va_start(args, format);
 
   char line[256] = "";
-#if defined(BOOST_ASIO_HAS_SECURE_RTL)
+#if defined(BOOST_ASIO_HAS_SNPRINTF)
+  int length = vsnprintf(line, sizeof(line), format, args);
+#elif defined(BOOST_ASIO_HAS_SECURE_RTL)
   int length = vsprintf_s(line, sizeof(line), format, args);
 #else // defined(BOOST_ASIO_HAS_SECURE_RTL)
   int length = vsprintf(line, format, args);

data/src/cxx_supportlib/vendor-modified/boost/asio/detail/impl/select_reactor.ipp

@@ -310,7 +310,7 @@ void select_reactor::run_thread()
   {
     lock.unlock();
     op_queue<operation> ops;
-    run(true, ops);
+    run(-1, ops);
     scheduler_.post_deferred_completions(ops);
     lock.lock();
   }

data/src/cxx_supportlib/vendor-modified/boost/asio/detail/impl/socket_ops.ipp

@@ -2520,7 +2520,11 @@ const char* inet_ntop(int af, const void* src, char* dest, size_t length,
         && ((ipv6_address->s6_addr[1] & 0x0f) == 0x02));
     if ((!is_link_local && !is_multicast_link_local)
         || if_indextoname(static_cast<unsigned>(scope_id), if_name + 1) == 0)
+#if defined(BOOST_ASIO_HAS_SNPRINTF)
+      snprintf(if_name + 1, sizeof(if_name) - 1, "%lu", scope_id);
+#else // defined(BOOST_ASIO_HAS_SNPRINTF)
       sprintf(if_name + 1, "%lu", scope_id);
+#endif // defined(BOOST_ASIO_HAS_SNPRINTF)
     strcat(dest, if_name);
   }
   return result;
@@ -3628,7 +3632,9 @@ inline boost::system::error_code getnameinfo_emulation(
       {
         return ec = boost::asio::error::no_buffer_space;
       }
-#if defined(BOOST_ASIO_HAS_SECURE_RTL)
+#if defined(BOOST_ASIO_HAS_SNPRINTF)
+      snprintf(serv, servlen, "%u", ntohs(port));
+#elif defined(BOOST_ASIO_HAS_SECURE_RTL)
       sprintf_s(serv, servlen, "%u", ntohs(port));
 #else // defined(BOOST_ASIO_HAS_SECURE_RTL)
       sprintf(serv, "%u", ntohs(port));
@@ -3651,7 +3657,9 @@ inline boost::system::error_code getnameinfo_emulation(
         {
           return ec = boost::asio::error::no_buffer_space;
         }
-#if defined(BOOST_ASIO_HAS_SECURE_RTL)
+#if defined(BOOST_ASIO_HAS_SNPRINTF)
+        snprintf(serv, servlen, "%u", ntohs(port));
+#elif defined(BOOST_ASIO_HAS_SECURE_RTL)
         sprintf_s(serv, servlen, "%u", ntohs(port));
 #else // defined(BOOST_ASIO_HAS_SECURE_RTL)
         sprintf(serv, "%u", ntohs(port));

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

@@ -107,13 +107,22 @@ public:
       {
         recycling_allocator<void> allocator;
         executor_type ex = this_->executor_;
+#if defined(BOOST_ASIO_NO_DEPRECATED)
+        boost::asio::prefer(
+            boost::asio::require(
+              BOOST_ASIO_MOVE_CAST(executor_type)(ex),
+              execution::blocking.never),
+            execution::allocator(allocator)
+          ).execute(BOOST_ASIO_MOVE_CAST(invoker)(*this_));
+#else // defined(BOOST_ASIO_NO_DEPRECATED)
         execution::execute(
             boost::asio::prefer(
               boost::asio::require(
                 BOOST_ASIO_MOVE_CAST(executor_type)(ex),
                 execution::blocking.never),
-            execution::allocator(allocator)),
+              execution::allocator(allocator)),
             BOOST_ASIO_MOVE_CAST(invoker)(*this_));
+#endif // defined(BOOST_ASIO_NO_DEPRECATED)
       }
     }
   };
@@ -255,7 +264,11 @@ void strand_executor_service::do_execute(const implementation_type& impl,
   p.v = p.p = 0;
   if (first)
   {
+#if defined(BOOST_ASIO_NO_DEPRECATED)
+    ex.execute(invoker<Executor>(impl, ex));
+#else // defined(BOOST_ASIO_NO_DEPRECATED)
     execution::execute(ex, invoker<Executor>(impl, ex));
+#endif // defined(BOOST_ASIO_NO_DEPRECATED)
   }
 }
 

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

@@ -20,6 +20,7 @@
 #include <cstdlib>
 #include <memory>
 #include <new>
+#include <boost/asio/detail/cstdint.hpp>
 #include <boost/asio/detail/throw_exception.hpp>
 
 #if !defined(BOOST_ASIO_HAS_STD_SHARED_PTR)
@@ -73,6 +74,23 @@ template <typename T>
 inline const volatile T* to_address(const volatile T* p) { return p; }
 #endif // defined(BOOST_ASIO_HAS_STD_TO_ADDRESS)
 
+inline void* align(std::size_t alignment,
+    std::size_t size, void*& ptr, std::size_t& space)
+{
+#if defined(BOOST_ASIO_HAS_STD_ALIGN)
+  return std::align(alignment, size, ptr, space);
+#else // defined(BOOST_ASIO_HAS_STD_ALIGN)
+	const uintptr_t intptr = reinterpret_cast<uintptr_t>(ptr);
+	const uintptr_t aligned = (intptr - 1u + alignment) & -alignment;
+	const std::size_t padding = aligned - intptr;
+	if (size + padding > space)
+    return 0;
+	space -= padding;
+	ptr = reinterpret_cast<void*>(aligned);
+  return ptr;
+#endif // defined(BOOST_ASIO_HAS_STD_ALIGN)
+}
+
 } // namespace detail
 
 #if defined(BOOST_ASIO_HAS_CXX11_ALLOCATORS)

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

@@ -16,8 +16,7 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
-
-# include <utility>
+#include <utility>
 
 namespace boost {
 namespace asio {

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

@@ -81,12 +81,16 @@ public:
   {
     typename associated_allocator<Handler>::type alloc(
         (get_associated_allocator)(handler_));
+#if defined(BOOST_ASIO_NO_DEPRECATED)
+    boost::asio::prefer(executor_, execution::allocator(alloc)).execute(
+        boost::asio::detail::bind_handler(
+          BOOST_ASIO_MOVE_CAST(Handler)(handler_)));
+#else // defined(BOOST_ASIO_NO_DEPRECATED)
     execution::execute(
-        boost::asio::prefer(executor_,
-          execution::blocking.possibly,
-          execution::allocator(alloc)),
+        boost::asio::prefer(executor_, execution::allocator(alloc)),
         boost::asio::detail::bind_handler(
           BOOST_ASIO_MOVE_CAST(Handler)(handler_)));
+#endif // defined(BOOST_ASIO_NO_DEPRECATED)
   }
 
 private:

data/src/cxx_supportlib/vendor-modified/boost/asio/dispatch.hpp

@@ -63,10 +63,7 @@ template <typename> class initiate_dispatch_with_executor;
  * @code auto alloc = get_associated_allocator(handler); @endcode
  *
  * @li If <tt>execution::is_executor<Ex>::value</tt> is true, performs
- * @code execution::execute(
- *     prefer(ex,
- *       execution::blocking.possibly,
- *       execution::allocator(alloc)),
+ * @code prefer(ex, execution::allocator(alloc)).execute(
  *     std::forward<CompletionHandler>(completion_handler)); @endcode
  *
  * @li If <tt>execution::is_executor<Ex>::value</tt> is false, performs
@@ -126,11 +123,8 @@ BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(NullaryToken, void()) dispatch(
  * handler_ that is a decay-copy of @c completion_handler, and a function call
  * operator that performs:
  * @code auto a = get_associated_allocator(handler_);
- * execution::execute(
- *     prefer(executor_,
- *       execution::blocking.possibly,
- *       execution::allocator(a)),
- *     std::move(handler_)); @endcode
+ * prefer(executor_, execution::allocator(a)).execute(std::move(handler_));
+ * @endcode
  *
  * @li If <tt>execution::is_executor<Ex1>::value</tt> is false, constructs a
  * function object @c f with a member @c work_ that is initialised with
@@ -141,11 +135,7 @@ BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(NullaryToken, void()) dispatch(
  * work_.reset(); @endcode
  *
  * @li If <tt>execution::is_executor<Ex>::value</tt> is true, performs
- * @code execution::execute(
- *     prefer(ex,
- *       execution::blocking.possibly,
- *       execution::allocator(alloc)),
- *     std::move(f)); @endcode
+ * @code prefer(ex, execution::allocator(alloc)).execute(std::move(f)); @endcode
  *
  * @li If <tt>execution::is_executor<Ex>::value</tt> is false, performs
  * @code ex.dispatch(std::move(f), alloc); @endcode

data/src/cxx_supportlib/vendor-modified/boost/asio/execution/allocator.hpp

@@ -79,6 +79,12 @@ template <typename ProtoAllocator>
 struct allocator_t
 {
 #if defined(BOOST_ASIO_HAS_VARIABLE_TEMPLATES)
+# if defined(BOOST_ASIO_NO_DEPRECATED)
+  template <typename T>
+  BOOST_ASIO_STATIC_CONSTEXPR(bool,
+    is_applicable_property_v = (
+      is_executor<T>::value));
+# else // defined(BOOST_ASIO_NO_DEPRECATED)
   template <typename T>
   BOOST_ASIO_STATIC_CONSTEXPR(bool,
     is_applicable_property_v = (
@@ -92,7 +98,9 @@ struct allocator_t
             is_executor<T>::value,
             false_type,
             is_scheduler<T>
-          >::type::value));
+          >::type::value
+      ));
+# endif // defined(BOOST_ASIO_NO_DEPRECATED)
 #endif // defined(BOOST_ASIO_HAS_VARIABLE_TEMPLATES)
 
   BOOST_ASIO_STATIC_CONSTEXPR(bool, is_requirable = true);
@@ -173,6 +181,12 @@ template <>
 struct allocator_t<void>
 {
 #if defined(BOOST_ASIO_HAS_VARIABLE_TEMPLATES)
+# if defined(BOOST_ASIO_NO_DEPRECATED)
+  template <typename T>
+  BOOST_ASIO_STATIC_CONSTEXPR(bool,
+    is_applicable_property_v = (
+      is_executor<T>::value));
+# else // defined(BOOST_ASIO_NO_DEPRECATED)
   template <typename T>
   BOOST_ASIO_STATIC_CONSTEXPR(bool,
     is_applicable_property_v = (
@@ -186,7 +200,9 @@ struct allocator_t<void>
             is_executor<T>::value,
             false_type,
             is_scheduler<T>
-          >::type::value));
+          >::type::value
+      ));
+# endif // defined(BOOST_ASIO_NO_DEPRECATED)
 #endif // defined(BOOST_ASIO_HAS_VARIABLE_TEMPLATES)
 
   BOOST_ASIO_STATIC_CONSTEXPR(bool, is_requirable = true);
@@ -284,6 +300,7 @@ template <typename T, typename ProtoAllocator>
 struct is_applicable_property<T, execution::allocator_t<ProtoAllocator> >
   : integral_constant<bool,
       execution::is_executor<T>::value
+#if !defined(BOOST_ASIO_NO_DEPRECATED)
         || conditional<
             execution::is_executor<T>::value,
             false_type,
@@ -293,7 +310,9 @@ struct is_applicable_property<T, execution::allocator_t<ProtoAllocator> >
             execution::is_executor<T>::value,
             false_type,
             execution::is_scheduler<T>
-          >::type::value>
+          >::type::value
+#endif // !defined(BOOST_ASIO_NO_DEPRECATED)
+    >
 {
 };