passenger 6.0.14 → 6.0.16

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

@@ -2,7 +2,7 @@
 // impl/awaitable.hpp
 // ~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 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)
@@ -19,7 +19,6 @@
 #include <exception>
 #include <new>
 #include <tuple>
-#include <utility>
 #include <boost/asio/cancellation_signal.hpp>
 #include <boost/asio/cancellation_state.hpp>
 #include <boost/asio/detail/thread_context.hpp>
@@ -38,6 +37,8 @@ namespace asio {
 namespace detail {
 
 struct awaitable_thread_has_context_switched {};
+template <typename, typename> class awaitable_async_op_handler;
+template <typename, typename, typename> class awaitable_async_op;
 
 // An awaitable_thread represents a thread-of-execution that is composed of one
 // or more "stack frames", with each frame represented by an awaitable_frame.
@@ -163,10 +164,23 @@ public:
   {
     if (attached_thread_->entry_point()->throw_if_cancelled_)
       if (!!attached_thread_->get_cancellation_state().cancelled())
-        do_throw_error(boost::asio::error::operation_aborted, "co_await");
+        throw_error(boost::asio::error::operation_aborted, "co_await");
     return a;
   }
 
+  template <typename Op>
+  auto await_transform(Op&& op,
+      typename constraint<is_async_operation<Op>::value>::type = 0)
+  {
+    if (attached_thread_->entry_point()->throw_if_cancelled_)
+      if (!!attached_thread_->get_cancellation_state().cancelled())
+        throw_error(boost::asio::error::operation_aborted, "co_await");
+
+    return awaitable_async_op<typename completion_signature_of<Op>::type,
+      typename decay<Op>::type, Executor>{
+        std::forward<Op>(op), this};
+  }
+
   // This await transformation obtains the associated executor of the thread of
   // execution.
   auto await_transform(this_coro::executor_t) noexcept
@@ -373,7 +387,7 @@ public:
           typename result_of<Function(awaitable_frame_base*)>::type,
           awaitable_thread<Executor>*
         >::value
-      >::type* = 0)
+      >::type* = nullptr)
   {
     struct result
     {
@@ -387,7 +401,12 @@ public:
 
       void await_suspend(coroutine_handle<void>) noexcept
       {
-        function_(this_);
+        this_->after_suspend(
+            [](void* arg)
+            {
+              result* r = static_cast<result*>(arg);
+              r->function_(r->this_);
+            }, this);
       }
 
       void await_resume() const noexcept
@@ -451,9 +470,25 @@ public:
     caller_ = nullptr;
   }
 
+  struct resume_context
+  {
+    void (*after_suspend_fn_)(void*) = nullptr;
+    void *after_suspend_arg_ = nullptr;
+  };
+
   void resume()
   {
+    resume_context context;
+    resume_context_ = &context;
     coro_.resume();
+    if (context.after_suspend_fn_)
+      context.after_suspend_fn_(context.after_suspend_arg_);
+  }
+
+  void after_suspend(void (*fn)(void*), void* arg)
+  {
+    resume_context_->after_suspend_fn_ = fn;
+    resume_context_->after_suspend_arg_ = arg;
   }
 
   void destroy()
@@ -466,6 +501,7 @@ protected:
   awaitable_thread<Executor>* attached_thread_ = nullptr;
   awaitable_frame_base<Executor>* caller_ = nullptr;
   std::exception_ptr pending_exception_ = nullptr;
+  resume_context* resume_context_ = nullptr;
 };
 
 template <typename T, typename Executor>
@@ -580,6 +616,7 @@ public:
 
 private:
   template <typename> friend class awaitable_frame_base;
+  template <typename, typename> friend class awaitable_async_op_handler;
   template <typename, typename> friend class awaitable_handler_base;
   template <typename> friend class awaitable_thread;
 
@@ -725,6 +762,364 @@ protected:
   awaitable<awaitable_thread_entry_point, Executor> bottom_of_stack_;
 };
 
+template <typename Signature, typename Executor>
+class awaitable_async_op_handler;
+
+template <typename R, typename Executor>
+class awaitable_async_op_handler<R(), Executor>
+  : public awaitable_thread<Executor>
+{
+public:
+  struct result_type {};
+
+  awaitable_async_op_handler(
+      awaitable_thread<Executor>* h, result_type&)
+    : awaitable_thread<Executor>(std::move(*h))
+  {
+  }
+
+  void operator()()
+  {
+    this->entry_point()->top_of_stack_->attach_thread(this);
+    this->entry_point()->top_of_stack_->clear_cancellation_slot();
+    this->pump();
+  }
+
+  static void resume(result_type&)
+  {
+  }
+};
+
+template <typename R, typename Executor>
+class awaitable_async_op_handler<R(boost::system::error_code), Executor>
+  : public awaitable_thread<Executor>
+{
+public:
+  typedef boost::system::error_code* result_type;
+
+  awaitable_async_op_handler(
+      awaitable_thread<Executor>* h, result_type& result)
+    : awaitable_thread<Executor>(std::move(*h)),
+      result_(result)
+  {
+  }
+
+  void operator()(boost::system::error_code ec)
+  {
+    result_ = &ec;
+    this->entry_point()->top_of_stack_->attach_thread(this);
+    this->entry_point()->top_of_stack_->clear_cancellation_slot();
+    this->pump();
+  }
+
+  static void resume(result_type& result)
+  {
+    throw_error(*result);
+  }
+
+private:
+  result_type& result_;
+};
+
+template <typename R, typename Executor>
+class awaitable_async_op_handler<R(std::exception_ptr), Executor>
+  : public awaitable_thread<Executor>
+{
+public:
+  typedef std::exception_ptr* result_type;
+
+  awaitable_async_op_handler(
+      awaitable_thread<Executor>* h, result_type& result)
+    : awaitable_thread<Executor>(std::move(*h)),
+      result_(result)
+  {
+  }
+
+  void operator()(std::exception_ptr ex)
+  {
+    result_ = &ex;
+    this->entry_point()->top_of_stack_->attach_thread(this);
+    this->entry_point()->top_of_stack_->clear_cancellation_slot();
+    this->pump();
+  }
+
+  static void resume(result_type& result)
+  {
+    if (*result)
+    {
+      std::exception_ptr ex = std::exchange(*result, nullptr);
+      std::rethrow_exception(ex);
+    }
+  }
+
+private:
+  result_type& result_;
+};
+
+template <typename R, typename T, typename Executor>
+class awaitable_async_op_handler<R(T), Executor>
+  : public awaitable_thread<Executor>
+{
+public:
+  typedef T* result_type;
+
+  awaitable_async_op_handler(
+      awaitable_thread<Executor>* h, result_type& result)
+    : awaitable_thread<Executor>(std::move(*h)),
+      result_(result)
+  {
+  }
+
+  void operator()(T result)
+  {
+    result_ = &result;
+    this->entry_point()->top_of_stack_->attach_thread(this);
+    this->entry_point()->top_of_stack_->clear_cancellation_slot();
+    this->pump();
+  }
+
+  static T resume(result_type& result)
+  {
+    return std::move(*result);
+  }
+
+private:
+  result_type& result_;
+};
+
+template <typename R, typename T, typename Executor>
+class awaitable_async_op_handler<R(boost::system::error_code, T), Executor>
+  : public awaitable_thread<Executor>
+{
+public:
+  struct result_type
+  {
+    boost::system::error_code* ec_;
+    T* value_;
+  };
+
+  awaitable_async_op_handler(
+      awaitable_thread<Executor>* h, result_type& result)
+    : awaitable_thread<Executor>(std::move(*h)),
+      result_(result)
+  {
+  }
+
+  void operator()(boost::system::error_code ec, T value)
+  {
+    result_.ec_ = &ec;
+    result_.value_ = &value;
+    this->entry_point()->top_of_stack_->attach_thread(this);
+    this->entry_point()->top_of_stack_->clear_cancellation_slot();
+    this->pump();
+  }
+
+  static T resume(result_type& result)
+  {
+    throw_error(*result.ec_);
+    return std::move(*result.value_);
+  }
+
+private:
+  result_type& result_;
+};
+
+template <typename R, typename T, typename Executor>
+class awaitable_async_op_handler<R(std::exception_ptr, T), Executor>
+  : public awaitable_thread<Executor>
+{
+public:
+  struct result_type
+  {
+    std::exception_ptr* ex_;
+    T* value_;
+  };
+
+  awaitable_async_op_handler(
+      awaitable_thread<Executor>* h, result_type& result)
+    : awaitable_thread<Executor>(std::move(*h)),
+      result_(result)
+  {
+  }
+
+  void operator()(std::exception_ptr ex, T value)
+  {
+    result_.ex_ = &ex;
+    result_.value_ = &value;
+    this->entry_point()->top_of_stack_->attach_thread(this);
+    this->entry_point()->top_of_stack_->clear_cancellation_slot();
+    this->pump();
+  }
+
+  static T resume(result_type& result)
+  {
+    if (*result)
+    {
+      std::exception_ptr ex = std::exchange(*result.ex_, nullptr);
+      std::rethrow_exception(ex);
+    }
+    return std::move(*result.value_);
+  }
+
+private:
+  result_type& result_;
+};
+
+template <typename R, typename... Ts, typename Executor>
+class awaitable_async_op_handler<R(Ts...), Executor>
+  : public awaitable_thread<Executor>
+{
+public:
+  typedef std::tuple<Ts...>* result_type;
+
+  awaitable_async_op_handler(
+      awaitable_thread<Executor>* h, result_type& result)
+    : awaitable_thread<Executor>(std::move(*h)),
+      result_(result)
+  {
+  }
+
+  template <typename... Args>
+  void operator()(Args&&... args)
+  {
+    std::tuple<Ts...> result(std::forward<Args>(args)...);
+    result_ = &result;
+    this->entry_point()->top_of_stack_->attach_thread(this);
+    this->entry_point()->top_of_stack_->clear_cancellation_slot();
+    this->pump();
+  }
+
+  static std::tuple<Ts...> resume(result_type& result)
+  {
+    return std::move(*result);
+  }
+
+private:
+  result_type& result_;
+};
+
+template <typename R, typename... Ts, typename Executor>
+class awaitable_async_op_handler<R(boost::system::error_code, Ts...), Executor>
+  : public awaitable_thread<Executor>
+{
+public:
+  struct result_type
+  {
+    boost::system::error_code* ec_;
+    std::tuple<Ts...>* value_;
+  };
+
+  awaitable_async_op_handler(
+      awaitable_thread<Executor>* h, result_type& result)
+    : awaitable_thread<Executor>(std::move(*h)),
+      result_(result)
+  {
+  }
+
+  template <typename... Args>
+  void operator()(boost::system::error_code ec, Args&&... args)
+  {
+    result_.ec_ = &ec;
+    std::tuple<Ts...> value(std::forward<Args>(args)...);
+    result_.value_ = &value;
+    this->entry_point()->top_of_stack_->attach_thread(this);
+    this->entry_point()->top_of_stack_->clear_cancellation_slot();
+    this->pump();
+  }
+
+  static std::tuple<Ts...> resume(result_type& result)
+  {
+    throw_error(*result.ec_);
+    return std::move(*result.value_);
+  }
+
+private:
+  result_type& result_;
+};
+
+template <typename R, typename... Ts, typename Executor>
+class awaitable_async_op_handler<R(std::exception_ptr, Ts...), Executor>
+  : public awaitable_thread<Executor>
+{
+public:
+  struct result_type
+  {
+    std::exception_ptr* ex_;
+    std::tuple<Ts...>* value_;
+  };
+
+  awaitable_async_op_handler(
+      awaitable_thread<Executor>* h, result_type& result)
+    : awaitable_thread<Executor>(std::move(*h)),
+      result_(result)
+  {
+  }
+
+  template <typename... Args>
+  void operator()(std::exception_ptr ex, Args&&... args)
+  {
+    result_.ex_ = &ex;
+    std::tuple<Ts...> value(std::forward<Args>(args)...);
+    result_.value_ = &value;
+    this->entry_point()->top_of_stack_->attach_thread(this);
+    this->entry_point()->top_of_stack_->clear_cancellation_slot();
+    this->pump();
+  }
+
+  static std::tuple<Ts...> resume(result_type& result)
+  {
+    if (*result)
+    {
+      std::exception_ptr ex = std::exchange(*result.ex_, nullptr);
+      std::rethrow_exception(ex);
+    }
+    return std::move(*result.value_);
+  }
+
+private:
+  result_type& result_;
+};
+
+template <typename Signature, typename Op, typename Executor>
+class awaitable_async_op
+{
+public:
+  typedef awaitable_async_op_handler<Signature, Executor> handler_type;
+
+  awaitable_async_op(Op&& o, awaitable_frame_base<Executor>* frame)
+    : op_(std::forward<Op>(o)),
+      frame_(frame),
+      result_()
+  {
+  }
+
+  bool await_ready() const noexcept
+  {
+    return false;
+  }
+
+  void await_suspend(coroutine_handle<void>)
+  {
+    frame_->after_suspend(
+        [](void* arg)
+        {
+          awaitable_async_op* self = static_cast<awaitable_async_op*>(arg);
+          std::forward<Op&&>(self->op_)(
+              handler_type(self->frame_->detach_thread(), self->result_));
+        }, this);
+  }
+
+  auto await_resume()
+  {
+    return handler_type::resume(result_);
+  }
+
+private:
+  Op&& op_;
+  awaitable_frame_base<Executor>* frame_;
+  typename handler_type::result_type result_;
+};
+
 } // namespace detail
 } // namespace asio
 } // namespace boost

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

@@ -2,7 +2,7 @@
 // impl/buffered_read_stream.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 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)
@@ -223,10 +223,15 @@ template <typename Stream>
 template <
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
       std::size_t)) ReadHandler>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(ReadHandler,
     void (boost::system::error_code, std::size_t))
 buffered_read_stream<Stream>::async_fill(
     BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+    async_initiate<ReadHandler,
+      void (boost::system::error_code, std::size_t)>(
+        declval<detail::initiate_async_buffered_fill<Stream> >(),
+        handler, declval<detail::buffered_stream_storage*>())))
 {
   return async_initiate<ReadHandler,
     void (boost::system::error_code, std::size_t)>(
@@ -459,11 +464,16 @@ template <typename Stream>
 template <typename MutableBufferSequence,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
       std::size_t)) ReadHandler>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(ReadHandler,
     void (boost::system::error_code, std::size_t))
 buffered_read_stream<Stream>::async_read_some(
     const MutableBufferSequence& buffers,
     BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+    async_initiate<ReadHandler,
+      void (boost::system::error_code, std::size_t)>(
+        declval<detail::initiate_async_buffered_read_some<Stream> >(),
+        handler, declval<detail::buffered_stream_storage*>(), buffers)))
 {
   return async_initiate<ReadHandler,
     void (boost::system::error_code, std::size_t)>(

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

@@ -2,7 +2,7 @@
 // impl/buffered_write_stream.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 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)
@@ -203,10 +203,15 @@ template <typename Stream>
 template <
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
       std::size_t)) WriteHandler>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteHandler,
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(WriteHandler,
     void (boost::system::error_code, std::size_t))
 buffered_write_stream<Stream>::async_flush(
     BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+    async_initiate<WriteHandler,
+      void (boost::system::error_code, std::size_t)>(
+        declval<detail::initiate_async_buffered_flush<Stream> >(),
+        handler, declval<detail::buffered_stream_storage*>())))
 {
   return async_initiate<WriteHandler,
     void (boost::system::error_code, std::size_t)>(
@@ -445,11 +450,16 @@ template <typename Stream>
 template <typename ConstBufferSequence,
     BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
       std::size_t)) WriteHandler>
-BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteHandler,
+BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(WriteHandler,
     void (boost::system::error_code, std::size_t))
 buffered_write_stream<Stream>::async_write_some(
     const ConstBufferSequence& buffers,
     BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+    async_initiate<WriteHandler,
+      void (boost::system::error_code, std::size_t)>(
+        declval<detail::initiate_async_buffered_write_some<Stream> >(),
+        handler, declval<detail::buffered_stream_storage*>(), buffers)))
 {
   return async_initiate<WriteHandler,
     void (boost::system::error_code, std::size_t)>(

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

@@ -0,0 +1,98 @@
+//
+// impl/cancellation_signal.ipp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 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)
+//
+
+#ifndef BOOST_ASIO_IMPL_CANCELLATION_SIGNAL_IPP
+#define BOOST_ASIO_IMPL_CANCELLATION_SIGNAL_IPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <boost/asio/cancellation_signal.hpp>
+#include <boost/asio/detail/thread_context.hpp>
+#include <boost/asio/detail/thread_info_base.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+
+cancellation_signal::~cancellation_signal()
+{
+  if (handler_)
+  {
+    std::pair<void*, std::size_t> mem = handler_->destroy();
+    detail::thread_info_base::deallocate(
+        detail::thread_info_base::cancellation_signal_tag(),
+        detail::thread_context::top_of_thread_call_stack(),
+        mem.first, mem.second);
+  }
+}
+
+void cancellation_slot::clear()
+{
+  if (handler_ != 0 && *handler_ != 0)
+  {
+    std::pair<void*, std::size_t> mem = (*handler_)->destroy();
+    detail::thread_info_base::deallocate(
+        detail::thread_info_base::cancellation_signal_tag(),
+        detail::thread_context::top_of_thread_call_stack(),
+        mem.first, mem.second);
+    *handler_ = 0;
+  }
+}
+
+std::pair<void*, std::size_t> cancellation_slot::prepare_memory(
+    std::size_t size, std::size_t align)
+{
+  assert(handler_);
+  std::pair<void*, std::size_t> mem;
+  if (*handler_)
+  {
+    mem = (*handler_)->destroy();
+    *handler_ = 0;
+  }
+  if (size > mem.second
+      || reinterpret_cast<std::size_t>(mem.first) % align != 0)
+  {
+    if (mem.first)
+    {
+      detail::thread_info_base::deallocate(
+          detail::thread_info_base::cancellation_signal_tag(),
+          detail::thread_context::top_of_thread_call_stack(),
+          mem.first, mem.second);
+    }
+    mem.first = detail::thread_info_base::allocate(
+        detail::thread_info_base::cancellation_signal_tag(),
+        detail::thread_context::top_of_thread_call_stack(),
+        size, align);
+    mem.second = size;
+  }
+  return mem;
+}
+
+cancellation_slot::auto_delete_helper::~auto_delete_helper()
+{
+  if (mem.first)
+  {
+    detail::thread_info_base::deallocate(
+        detail::thread_info_base::cancellation_signal_tag(),
+        detail::thread_context::top_of_thread_call_stack(),
+        mem.first, mem.second);
+  }
+}
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_IMPL_CANCELLATION_SIGNAL_IPP