passenger 6.0.20 → 6.0.22

data/src/cxx_supportlib/vendor-modified/boost/asio/windows/overlapped_ptr.hpp

@@ -1,147 +0,0 @@
-//
-// windows/overlapped_ptr.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2023 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_WINDOWS_OVERLAPPED_PTR_HPP
-#define BOOST_ASIO_WINDOWS_OVERLAPPED_PTR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include <boost/asio/detail/config.hpp>
-
-#if defined(BOOST_ASIO_HAS_WINDOWS_OVERLAPPED_PTR) \
-  || defined(GENERATING_DOCUMENTATION)
-
-#include <boost/asio/detail/noncopyable.hpp>
-#include <boost/asio/detail/win_iocp_overlapped_ptr.hpp>
-#include <boost/asio/io_context.hpp>
-
-#include <boost/asio/detail/push_options.hpp>
-
-namespace boost {
-namespace asio {
-namespace windows {
-
-/// Wraps a handler to create an OVERLAPPED object for use with overlapped I/O.
-/**
- * A special-purpose smart pointer used to wrap an application handler so that
- * it can be passed as the LPOVERLAPPED argument to overlapped I/O functions.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Unsafe.
- */
-class overlapped_ptr
-  : private noncopyable
-{
-public:
-  /// Construct an empty overlapped_ptr.
-  overlapped_ptr()
-    : impl_()
-  {
-  }
-
-  /// Construct an overlapped_ptr to contain the specified handler.
-  template <typename ExecutionContext, typename Handler>
-  explicit overlapped_ptr(ExecutionContext& context,
-      BOOST_ASIO_MOVE_ARG(Handler) handler,
-      typename constraint<
-        is_convertible<ExecutionContext&, execution_context&>::value
-      >::type = 0)
-    : impl_(context.get_executor(), BOOST_ASIO_MOVE_CAST(Handler)(handler))
-  {
-  }
-
-  /// Construct an overlapped_ptr to contain the specified handler.
-  template <typename Executor, typename Handler>
-  explicit overlapped_ptr(const Executor& ex,
-      BOOST_ASIO_MOVE_ARG(Handler) handler,
-      typename constraint<
-        execution::is_executor<Executor>::value
-          || is_executor<Executor>::value
-      >::type = 0)
-    : impl_(ex, BOOST_ASIO_MOVE_CAST(Handler)(handler))
-  {
-  }
-
-  /// Destructor automatically frees the OVERLAPPED object unless released.
-  ~overlapped_ptr()
-  {
-  }
-
-  /// Reset to empty.
-  void reset()
-  {
-    impl_.reset();
-  }
-
-  /// Reset to contain the specified handler, freeing any current OVERLAPPED
-  /// object.
-  template <typename ExecutionContext, typename Handler>
-  void reset(ExecutionContext& context, BOOST_ASIO_MOVE_ARG(Handler) handler,
-      typename constraint<
-        is_convertible<ExecutionContext&, execution_context&>::value
-      >::type = 0)
-  {
-    impl_.reset(context.get_executor(), BOOST_ASIO_MOVE_CAST(Handler)(handler));
-  }
-
-  /// Reset to contain the specified handler, freeing any current OVERLAPPED
-  /// object.
-  template <typename Executor, typename Handler>
-  void reset(const Executor& ex, BOOST_ASIO_MOVE_ARG(Handler) handler,
-      typename constraint<
-        execution::is_executor<Executor>::value
-          || is_executor<Executor>::value
-      >::type = 0)
-  {
-    impl_.reset(ex, BOOST_ASIO_MOVE_CAST(Handler)(handler));
-  }
-
-  /// Get the contained OVERLAPPED object.
-  OVERLAPPED* get()
-  {
-    return impl_.get();
-  }
-
-  /// Get the contained OVERLAPPED object.
-  const OVERLAPPED* get() const
-  {
-    return impl_.get();
-  }
-
-  /// Release ownership of the OVERLAPPED object.
-  OVERLAPPED* release()
-  {
-    return impl_.release();
-  }
-
-  /// Post completion notification for overlapped operation. Releases ownership.
-  void complete(const boost::system::error_code& ec,
-      std::size_t bytes_transferred)
-  {
-    impl_.complete(ec, bytes_transferred);
-  }
-
-private:
-  detail::win_iocp_overlapped_ptr impl_;
-};
-
-} // namespace windows
-} // namespace asio
-} // namespace boost
-
-#include <boost/asio/detail/pop_options.hpp>
-
-#endif // defined(BOOST_ASIO_HAS_WINDOWS_OVERLAPPED_PTR)
-       //   || defined(GENERATING_DOCUMENTATION)
-
-#endif // BOOST_ASIO_WINDOWS_OVERLAPPED_PTR_HPP

data/src/cxx_supportlib/vendor-modified/boost/asio/windows/random_access_handle.hpp

@@ -1,39 +0,0 @@
-//
-// windows/random_access_handle.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2023 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_WINDOWS_RANDOM_ACCESS_HANDLE_HPP
-#define BOOST_ASIO_WINDOWS_RANDOM_ACCESS_HANDLE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include <boost/asio/detail/config.hpp>
-
-#if defined(BOOST_ASIO_HAS_WINDOWS_RANDOM_ACCESS_HANDLE) \
-  || defined(GENERATING_DOCUMENTATION)
-
-#include <boost/asio/windows/basic_random_access_handle.hpp>
-
-namespace boost {
-namespace asio {
-namespace windows {
-
-/// Typedef for the typical usage of a random-access handle.
-typedef basic_random_access_handle<> random_access_handle;
-
-} // namespace windows
-} // namespace asio
-} // namespace boost
-
-#endif // defined(BOOST_ASIO_HAS_WINDOWS_RANDOM_ACCESS_HANDLE)
-       //   || defined(GENERATING_DOCUMENTATION)
-
-#endif // BOOST_ASIO_WINDOWS_RANDOM_ACCESS_HANDLE_HPP

data/src/cxx_supportlib/vendor-modified/boost/asio/windows/stream_handle.hpp

@@ -1,39 +0,0 @@
-//
-// windows/stream_handle.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2023 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_WINDOWS_STREAM_HANDLE_HPP
-#define BOOST_ASIO_WINDOWS_STREAM_HANDLE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include <boost/asio/detail/config.hpp>
-
-#if defined(BOOST_ASIO_HAS_WINDOWS_STREAM_HANDLE) \
-  || defined(GENERATING_DOCUMENTATION)
-
-#include <boost/asio/windows/basic_stream_handle.hpp>
-
-namespace boost {
-namespace asio {
-namespace windows {
-
-/// Typedef for the typical usage of a stream-oriented handle.
-typedef basic_stream_handle<> stream_handle;
-
-} // namespace windows
-} // namespace asio
-} // namespace boost
-
-#endif // defined(BOOST_ASIO_HAS_WINDOWS_STREAM_HANDLE)
-       //   || defined(GENERATING_DOCUMENTATION)
-
-#endif // BOOST_ASIO_WINDOWS_STREAM_HANDLE_HPP

data/src/cxx_supportlib/vendor-modified/boost/atomic/detail/core_ops_windows.hpp

@@ -1,201 +0,0 @@
-/*
- * 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)
- *
- * Copyright (c) 2009 Helge Bahmann
- * Copyright (c) 2012 Tim Blechmann
- * Copyright (c) 2014 Andrey Semashev
- */
-/*!
- * \file   atomic/detail/core_ops_windows.hpp
- *
- * This header contains implementation of the \c core_operations template.
- *
- * This implementation is the most basic version for Windows. It should
- * work for any non-MSVC-like compilers as long as there are Interlocked WinAPI
- * functions available. This version is also used for WinCE.
- *
- * Notably, this implementation is not as efficient as other
- * versions based on compiler intrinsics.
- */
-
-#ifndef BOOST_ATOMIC_DETAIL_CORE_OPS_WINDOWS_HPP_INCLUDED_
-#define BOOST_ATOMIC_DETAIL_CORE_OPS_WINDOWS_HPP_INCLUDED_
-
-#include <cstddef>
-#include <boost/memory_order.hpp>
-#include <boost/atomic/detail/config.hpp>
-#include <boost/atomic/detail/interlocked.hpp>
-#include <boost/atomic/detail/storage_traits.hpp>
-#include <boost/atomic/detail/core_operations_fwd.hpp>
-#include <boost/atomic/detail/type_traits/make_signed.hpp>
-#include <boost/atomic/detail/ops_msvc_common.hpp>
-#include <boost/atomic/detail/extending_cas_based_arithmetic.hpp>
-#include <boost/atomic/detail/header.hpp>
-
-#ifdef BOOST_HAS_PRAGMA_ONCE
-#pragma once
-#endif
-
-namespace boost {
-namespace atomics {
-namespace detail {
-
-struct core_operations_windows_base
-{
-    static BOOST_CONSTEXPR_OR_CONST bool full_cas_based = false;
-    static BOOST_CONSTEXPR_OR_CONST bool is_always_lock_free = true;
-
-    static BOOST_FORCEINLINE void fence_before(memory_order) BOOST_NOEXCEPT
-    {
-        BOOST_ATOMIC_DETAIL_COMPILER_BARRIER();
-    }
-
-    static BOOST_FORCEINLINE void fence_after(memory_order) BOOST_NOEXCEPT
-    {
-        BOOST_ATOMIC_DETAIL_COMPILER_BARRIER();
-    }
-};
-
-template< std::size_t Size, bool Signed, bool Interprocess, typename Derived >
-struct core_operations_windows :
-    public core_operations_windows_base
-{
-    typedef typename storage_traits< Size >::type storage_type;
-
-    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_size = Size;
-    static BOOST_CONSTEXPR_OR_CONST std::size_t storage_alignment = storage_traits< Size >::alignment;
-    static BOOST_CONSTEXPR_OR_CONST bool is_signed = Signed;
-    static BOOST_CONSTEXPR_OR_CONST bool is_interprocess = Interprocess;
-
-    static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
-    {
-        Derived::exchange(storage, v, order);
-    }
-
-    static BOOST_FORCEINLINE storage_type load(storage_type const volatile& storage, memory_order order) BOOST_NOEXCEPT
-    {
-        return Derived::fetch_add(const_cast< storage_type volatile& >(storage), (storage_type)0, order);
-    }
-
-    static BOOST_FORCEINLINE storage_type fetch_sub(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
-    {
-        typedef typename boost::atomics::detail::make_signed< storage_type >::type signed_storage_type;
-        return Derived::fetch_add(storage, static_cast< storage_type >(-static_cast< signed_storage_type >(v)), order);
-    }
-
-    static BOOST_FORCEINLINE bool compare_exchange_weak(
-        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT
-    {
-        return Derived::compare_exchange_strong(storage, expected, desired, success_order, failure_order);
-    }
-
-    static BOOST_FORCEINLINE bool test_and_set(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
-    {
-        return !!Derived::exchange(storage, (storage_type)1, order);
-    }
-
-    static BOOST_FORCEINLINE void clear(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
-    {
-        store(storage, (storage_type)0, order);
-    }
-};
-
-template< bool Signed, bool Interprocess >
-struct core_operations< 4u, Signed, bool Interprocess > :
-    public core_operations_windows< 4u, Signed, Interprocess, core_operations< 4u, Signed, Interprocess > >
-{
-    typedef core_operations_windows< 4u, Signed, Interprocess, core_operations< 4u, Signed, Interprocess > > base_type;
-    typedef typename base_type::storage_type storage_type;
-
-    static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
-    {
-        base_type::fence_before(order);
-        v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD(&storage, v));
-        base_type::fence_after(order);
-        return v;
-    }
-
-    static BOOST_FORCEINLINE storage_type exchange(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
-    {
-        base_type::fence_before(order);
-        v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE(&storage, v));
-        base_type::fence_after(order);
-        return v;
-    }
-
-    static BOOST_FORCEINLINE bool compare_exchange_strong(
-        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT
-    {
-        storage_type previous = expected;
-        base_type::fence_before(success_order);
-        storage_type old_val = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE(&storage, desired, previous));
-        expected = old_val;
-        // The success and failure fences are the same anyway
-        base_type::fence_after(success_order);
-        return (previous == old_val);
-    }
-
-    static BOOST_FORCEINLINE storage_type fetch_and(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
-    {
-#if defined(BOOST_ATOMIC_INTERLOCKED_AND)
-        base_type::fence_before(order);
-        v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_AND(&storage, v));
-        base_type::fence_after(order);
-        return v;
-#else
-        storage_type res = storage;
-        while (!compare_exchange_strong(storage, res, res & v, order, memory_order_relaxed)) {}
-        return res;
-#endif
-    }
-
-    static BOOST_FORCEINLINE storage_type fetch_or(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
-    {
-#if defined(BOOST_ATOMIC_INTERLOCKED_OR)
-        base_type::fence_before(order);
-        v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_OR(&storage, v));
-        base_type::fence_after(order);
-        return v;
-#else
-        storage_type res = storage;
-        while (!compare_exchange_strong(storage, res, res | v, order, memory_order_relaxed)) {}
-        return res;
-#endif
-    }
-
-    static BOOST_FORCEINLINE storage_type fetch_xor(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
-    {
-#if defined(BOOST_ATOMIC_INTERLOCKED_XOR)
-        base_type::fence_before(order);
-        v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_XOR(&storage, v));
-        base_type::fence_after(order);
-        return v;
-#else
-        storage_type res = storage;
-        while (!compare_exchange_strong(storage, res, res ^ v, order, memory_order_relaxed)) {}
-        return res;
-#endif
-    }
-};
-
-template< bool Signed, bool Interprocess >
-struct core_operations< 1u, Signed, Interprocess > :
-    public extending_cas_based_arithmetic< core_operations< 4u, Signed, Interprocess >, 1u, Signed >
-{
-};
-
-template< bool Signed, bool Interprocess >
-struct core_operations< 2u, Signed, Interprocess > :
-    public extending_cas_based_arithmetic< core_operations< 4u, Signed, Interprocess >, 2u, Signed >
-{
-};
-
-} // namespace detail
-} // namespace atomics
-} // namespace boost
-
-#include <boost/atomic/detail/footer.hpp>
-
-#endif // BOOST_ATOMIC_DETAIL_CORE_OPS_WINDOWS_HPP_INCLUDED_

data/src/cxx_supportlib/vendor-modified/boost/atomic/detail/fence_ops_windows.hpp

@@ -1,67 +0,0 @@
-/*
- * 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)
- *
- * Copyright (c) 2020 Andrey Semashev
- */
-/*!
- * \file   atomic/detail/fence_ops_windows.hpp
- *
- * This header contains implementation of the \c fence_operations struct.
- */
-
-#ifndef BOOST_ATOMIC_DETAIL_FENCE_OPS_WINDOWS_HPP_INCLUDED_
-#define BOOST_ATOMIC_DETAIL_FENCE_OPS_WINDOWS_HPP_INCLUDED_
-
-#include <boost/cstdint.hpp>
-#include <boost/memory_order.hpp>
-#include <boost/atomic/detail/config.hpp>
-#include <boost/atomic/detail/interlocked.hpp>
-#include <boost/atomic/detail/ops_msvc_common.hpp>
-#include <boost/atomic/detail/header.hpp>
-
-#ifdef BOOST_HAS_PRAGMA_ONCE
-#pragma once
-#endif
-
-namespace boost {
-namespace atomics {
-namespace detail {
-
-//! Fence operations based on Windows-specific system calls or intrinsics
-struct fence_operations_windows
-{
-    static BOOST_FORCEINLINE void thread_fence(memory_order order) BOOST_NOEXCEPT
-    {
-        if (order != memory_order_relaxed)
-        {
-            BOOST_ATOMIC_DETAIL_COMPILER_BARRIER();
-            if (order == memory_order_seq_cst)
-                hardware_full_fence();
-            BOOST_ATOMIC_DETAIL_COMPILER_BARRIER();
-        }
-    }
-
-    static BOOST_FORCEINLINE void signal_fence(memory_order order) BOOST_NOEXCEPT
-    {
-        if (order != memory_order_relaxed)
-            BOOST_ATOMIC_DETAIL_COMPILER_BARRIER();
-    }
-
-    static BOOST_FORCEINLINE void hardware_full_fence() BOOST_NOEXCEPT
-    {
-        boost::uint32_t tmp;
-        BOOST_ATOMIC_INTERLOCKED_INCREMENT(&tmp);
-    }
-};
-
-typedef fence_operations_windows fence_operations;
-
-} // namespace detail
-} // namespace atomics
-} // namespace boost
-
-#include <boost/atomic/detail/footer.hpp>
-
-#endif // BOOST_ATOMIC_DETAIL_FENCE_OPS_WINDOWS_HPP_INCLUDED_

data/src/cxx_supportlib/vendor-modified/boost/atomic/detail/wait_caps_windows.hpp

@@ -1,57 +0,0 @@
-/*
- * 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)
- *
- * Copyright (c) 2020 Andrey Semashev
- */
-/*!
- * \file   atomic/detail/wait_caps_windows.hpp
- *
- * This header defines waiting/notifying operations capabilities macros.
- */
-
-#ifndef BOOST_ATOMIC_DETAIL_WAIT_CAPS_WINDOWS_HPP_INCLUDED_
-#define BOOST_ATOMIC_DETAIL_WAIT_CAPS_WINDOWS_HPP_INCLUDED_
-
-#include <boost/winapi/config.hpp>
-#include <boost/atomic/detail/config.hpp>
-#include <boost/atomic/detail/capabilities.hpp>
-
-#ifdef BOOST_HAS_PRAGMA_ONCE
-#pragma once
-#endif
-
-// MSDN says WaitOnAddress, WakeByAddressSingle and WakeByAddressAll only support notifications between threads of the same process, so no address-free operations.
-// https://docs.microsoft.com/en-us/windows/win32/api/synchapi/nf-synchapi-waitonaddress
-// https://docs.microsoft.com/en-us/windows/win32/api/synchapi/nf-synchapi-wakebyaddresssingle
-// https://docs.microsoft.com/en-us/windows/win32/api/synchapi/nf-synchapi-wakebyaddressall
-
-#if BOOST_USE_WINAPI_VERSION >= BOOST_WINAPI_VERSION_WIN8 && (BOOST_WINAPI_PARTITION_APP || BOOST_WINAPI_PARTITION_SYSTEM)
-
-#define BOOST_ATOMIC_DETAIL_WINDOWS_HAS_WAIT_ON_ADDRESS
-
-#define BOOST_ATOMIC_HAS_NATIVE_INT8_WAIT_NOTIFY BOOST_ATOMIC_INT8_LOCK_FREE
-#define BOOST_ATOMIC_HAS_NATIVE_INT16_WAIT_NOTIFY BOOST_ATOMIC_INT16_LOCK_FREE
-#define BOOST_ATOMIC_HAS_NATIVE_INT32_WAIT_NOTIFY BOOST_ATOMIC_INT32_LOCK_FREE
-#define BOOST_ATOMIC_HAS_NATIVE_INT64_WAIT_NOTIFY BOOST_ATOMIC_INT64_LOCK_FREE
-
-#else // BOOST_USE_WINAPI_VERSION >= BOOST_WINAPI_VERSION_WIN8 && (BOOST_WINAPI_PARTITION_APP || BOOST_WINAPI_PARTITION_SYSTEM)
-
-// Since we'll detect availability of WaitOnAddress etc. at run time, we have to define capability macros to 1 instead of 2
-#if BOOST_ATOMIC_INT8_LOCK_FREE > 0
-#define BOOST_ATOMIC_HAS_NATIVE_INT8_WAIT_NOTIFY 1
-#endif
-#if BOOST_ATOMIC_INT16_LOCK_FREE > 0
-#define BOOST_ATOMIC_HAS_NATIVE_INT16_WAIT_NOTIFY 1
-#endif
-#if BOOST_ATOMIC_INT32_LOCK_FREE > 0
-#define BOOST_ATOMIC_HAS_NATIVE_INT32_WAIT_NOTIFY 1
-#endif
-#if BOOST_ATOMIC_INT64_LOCK_FREE > 0
-#define BOOST_ATOMIC_HAS_NATIVE_INT64_WAIT_NOTIFY 1
-#endif
-
-#endif // BOOST_USE_WINAPI_VERSION >= BOOST_WINAPI_VERSION_WIN8 && (BOOST_WINAPI_PARTITION_APP || BOOST_WINAPI_PARTITION_SYSTEM)
-
-#endif // BOOST_ATOMIC_DETAIL_WAIT_CAPS_WINDOWS_HPP_INCLUDED_