passenger 6.2.1 → 6.2.2

data/src/cxx_supportlib/vendor-modified/boost/container/detail/placement_new.hpp

@@ -11,14 +11,27 @@
 ///////////////////////////////////////////////////////////////////////////////
 
 #include <cstddef>
+#include <boost/container/detail/workaround.hpp>   //BOOST_CONTAINER_RETURNS_NONNULL
 
 struct boost_container_new_t{};
 
-//avoid including <new>
-inline void *operator new(std::size_t, void *p, boost_container_new_t)
+//returns_nonnull lets the compiler drop the null check the new-expression
+//otherwise performs on the result of this custom placement operator new;
+//nonnull(2) tells it the passed pointer 'p' is never null either.
+BOOST_CONTAINER_RETURNS_NONNULL BOOST_CONTAINER_NONNULL(2)
+BOOST_CONTAINER_FORCEINLINE void *operator new(std::size_t, void *p, boost_container_new_t)
 {  return p;  }
 
-inline void operator delete(void *, void *, boost_container_new_t)
+BOOST_CONTAINER_FORCEINLINE  void operator delete(void *, void *, boost_container_new_t)
+{}
+
+struct boost_container_init_life_t{};
+
+//p can be null
+BOOST_CONTAINER_FORCEINLINE  void *operator new(std::size_t, void *p, boost_container_init_life_t)
+{  return p;  }
+
+BOOST_CONTAINER_FORCEINLINE  void operator delete(void *, void *, boost_container_init_life_t)
 {}
 
 #endif   //BOOST_CONTAINER_DETAIL_PLACEMENT_NEW_HPP

data/src/cxx_supportlib/vendor-modified/boost/container/detail/pool_common_alloc.hpp

@@ -24,6 +24,7 @@
 #include <boost/container/throw_exception.hpp>
 
 #include <boost/intrusive/slist.hpp>
+#include <boost/container/detail/multiallocation_chain.hpp>
 #include <boost/container/detail/pool_common.hpp>
 #include <boost/container/detail/dlmalloc.hpp>
 #include <cstddef>
@@ -66,13 +67,6 @@ struct fake_segment_manager
       return ret;
    }
 
-   static void *allocate(std::size_t nbytes)
-   {
-      void *ret = dlmalloc_malloc(nbytes);
-      if(!ret)
-         boost::container::throw_bad_alloc();
-      return ret;
-   }
 };
 
 }  //namespace boost{

data/src/cxx_supportlib/vendor-modified/boost/container/detail/range_utils.hpp

@@ -0,0 +1,196 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2024-2024. 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)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_CONTAINER_DETAIL_RANGE_UTILS_HPP
+#define BOOST_CONTAINER_DETAIL_RANGE_UTILS_HPP
+
+#ifndef BOOST_CONFIG_HPP
+#  include <boost/config.hpp>
+#endif
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#  pragma once
+#endif
+
+#include <boost/container/detail/workaround.hpp>
+#include <boost/container/detail/std_fwd.hpp>   //forward declares ::std::from_range_t
+
+//! \file
+//!   Defines boost::container::from_range_t and the boost::container::from_range
+//!   tag, used to disambiguate the range-based members of the containers.
+//!
+//!   When the standard library provides ::std::from_range_t (see
+//!   BOOST_CONTAINER_DETAIL_STD_FROM_RANGE_SUPPORT in std_fwd.hpp), from_range_t
+//!   is a reference to it -following the same technique as
+//!   boost::container::piecewise_construct_t and boost::container::allocator_arg_t-
+//!   so the tag is the very same type as the standard one and interoperates with
+//!   ::std::from_range, yet the heavyweight <ranges> header is not required.
+//!   Otherwise, there is no standard type to refer to and from_range_t is defined
+//!   as a standalone type.
+
+namespace boost {
+namespace container {
+
+#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
+
+#if defined(BOOST_CONTAINER_DETAIL_STD_FROM_RANGE_SUPPORT)
+
+   template <int Dummy = 0>
+   struct std_from_range_holder
+   {
+      static ::std::from_range_t *dummy;
+   };
+
+   template <int Dummy>                                            //Silence null-reference compiler warnings
+   ::std::from_range_t *std_from_range_holder<Dummy>::dummy = reinterpret_cast< ::std::from_range_t * >(0x1234);
+
+typedef const ::std::from_range_t & from_range_t;
+
+//! A instance of type from_range_t
+static from_range_t from_range = *std_from_range_holder<>::dummy;
+
+#else //!defined(BOOST_CONTAINER_DETAIL_STD_FROM_RANGE_SUPPORT)
+
+//The standard library does not provide ::std::from_range_t, so there is nothing
+//to interoperate with: from_range_t is a standalone type.
+struct from_range_t {};
+
+//! A instance of type from_range_t
+static const from_range_t from_range = from_range_t();
+
+#endif   //defined(BOOST_CONTAINER_DETAIL_STD_FROM_RANGE_SUPPORT)
+
+#else    //BOOST_CONTAINER_DOXYGEN_INVOKED
+
+//! The from_range_t struct is an empty structure type used as a unique type to
+//! disambiguate the constructors and member functions that build or replace the
+//! contents of a container from a container-compatible range.
+typedef unspecified from_range_t;
+
+//! A instance of type from_range_t
+static from_range_t from_range;
+
+#endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
+
+///@cond
+
+namespace dtl {
+
+//Range begin()/end() access that depends on neither <ranges> nor <iterator>.
+namespace adl_range {
+
+//When decltype/trailing-return-types are available (C++11), adl_range below also
+//resolves ranges whose begin()/end() are free functions found only through ADL,
+//matching std::ranges::begin/std::ranges::end reachability. This needs neither
+//<ranges> nor <iterator> nor a (UB and fragile) forward declaration of
+//std::begin/std::end: member begin()/end() is detected directly and the ADL
+//fallback already reaches std::begin/std::end for types in namespace std (e.g.
+//std::valarray). In C++03 adl_range supports member begin()/end() and C arrays.
+#if !defined(BOOST_NO_CXX11_DECLTYPE) && !defined(BOOST_NO_CXX11_TRAILING_RESULT_TYPES)
+#  define BOOST_CONTAINER_RANGE_UTILS_ADL_FREE_FUNCTIONS
+#endif
+
+#if defined(BOOST_CONTAINER_RANGE_UTILS_ADL_FREE_FUNCTIONS)
+
+//Member begin()/end() is preferred; when there is no member, an unqualified
+//begin()/end() call is used, so free begin()/end() reachable through ADL are
+//picked up (this also reaches std::begin/std::end for types in namespace std,
+//such as std::valarray). C arrays have a dedicated overload. This mirrors
+//std::ranges::begin/std::ranges::end reachability, without including <iterator>
+//or forward declaring std::begin/std::end.
+//
+//Priority tags (int beats long in overload resolution) ensure the member form
+//wins when present and the ADL free-function form is only the fallback. The C&
+//parameter deduces const/non-const, selecting the right iterator type.
+template<class C>
+inline auto adl_begin_impl(C &c, int) -> decltype(c.begin())
+{  return c.begin();  }
+
+template<class C>
+inline auto adl_begin_impl(C &c, long) -> decltype(begin(c))
+{  return begin(c);  }
+
+template<class C>
+inline auto adl_end_impl(C &c, int) -> decltype(c.end())
+{  return c.end();  }
+
+template<class C>
+inline auto adl_end_impl(C &c, long) -> decltype(end(c))
+{  return end(c);  }
+
+template<class C>
+inline auto adl_begin(C &c) -> decltype(adl_begin_impl(c, 0))
+{  return adl_begin_impl(c, 0);  }
+
+template<class C>
+inline auto adl_end(C &c) -> decltype(adl_end_impl(c, 0))
+{  return adl_end_impl(c, 0);  }
+
+//C arrays (more specialized than the generic adl_begin/adl_end templates above).
+template<class T, std::size_t N>
+inline T* adl_begin(T (&array)[N])
+{  return array;  }
+
+template<class T, std::size_t N>
+inline T* adl_end(T (&array)[N])
+{  return array + N;  }
+
+#else //C++03: decltype/trailing return types are unavailable.
+
+//Member begin()/end() (every standard and Boost container, std::initializer_list,
+//std::span, std::string_view, ...) plus a dedicated overload for C arrays.
+//Free begin()/end() found only through ADL are not supported in this mode.
+//Written in a C++03-compatible way (no decltype/auto/trailing return type); the
+//const-reference overload is picked for const ranges via partial ordering.
+template<class C>
+inline typename C::iterator adl_begin(C &c)
+{  return c.begin();  }
+
+template<class C>
+inline typename C::const_iterator adl_begin(const C &c)
+{  return c.begin();  }
+
+template<class C>
+inline typename C::iterator adl_end(C &c)
+{  return c.end();  }
+
+template<class C>
+inline typename C::const_iterator adl_end(const C &c)
+{  return c.end();  }
+
+template<class T, std::size_t N>
+inline T* adl_begin(T (&array)[N])
+{  return array;  }
+
+template<class T, std::size_t N>
+inline T* adl_end(T (&array)[N])
+{  return array + N;  }
+
+#endif   //BOOST_CONTAINER_RANGE_UTILS_ADL_FREE_FUNCTIONS
+
+#undef BOOST_CONTAINER_RANGE_UTILS_ADL_FREE_FUNCTIONS
+
+}  //namespace adl_range
+
+struct from_range_construct_use
+{
+   //Avoid warnings of unused "from_range"
+   from_range_construct_use()
+   {  (void)&::boost::container::from_range;   }
+};
+
+}  //namespace dtl {
+
+///@endcond
+
+}  //namespace container {
+}  //namespace boost {
+
+#endif   //BOOST_CONTAINER_DETAIL_RANGE_UTILS_HPP

data/src/cxx_supportlib/vendor-modified/boost/container/detail/std_fwd.hpp

@@ -25,6 +25,32 @@
 
 #include <cstddef>
 
+//<version> is needed to reliably query the C++23 library feature-test macros
+//for ::std::from_range_t / P1206R7. It is one of the lightest standard headers.
+#if defined(__has_include)
+#  if __has_include(<version>)
+#     include <version>
+#  endif
+#elif BOOST_CXX_VERSION >= 202002L
+#  include <version>
+#endif
+
+// Whether ::std::from_range_t tag is provided by the standard library.
+//
+// The official feature-test macro for std::from_range_t is
+// __cpp_lib_containers_ranges. However, std::from_range_t lives in <ranges>
+// next to std::ranges::to, whose specification uses the tag, so any library
+// that provides std::ranges::to necessarily provides std::from_range_t too.
+//
+// Some standard libraries (e.g. libc++ 17/18) ship std::ranges::to and
+// std::from_range_t -- defining __cpp_lib_ranges_to_container -- before they
+// complete the container support and define __cpp_lib_containers_ranges.
+// In that window only __cpp_lib_ranges_to_container is defined even though the
+// tag is already present.
+#if defined(__cpp_lib_ranges_to_container) || defined(__cpp_lib_containers_ranges)
+#  define BOOST_CONTAINER_DETAIL_STD_FROM_RANGE_SUPPORT
+#endif
+
 #include <boost/move/detail/std_ns_begin.hpp>
 BOOST_MOVE_STD_NS_BEG
 
@@ -58,6 +84,12 @@ struct piecewise_construct_t;
 template <class Ptr>
 struct pointer_traits;
 
+//Only forward declare ::std::from_range_t when the standard library actually
+//provides it; see BOOST_CONTAINER_DETAIL_STD_FROM_RANGE_SUPPORT above.
+#if defined(BOOST_CONTAINER_DETAIL_STD_FROM_RANGE_SUPPORT)
+struct from_range_t;
+#endif
+
 BOOST_MOVE_STD_NS_END
 #include <boost/move/detail/std_ns_end.hpp>
 
@@ -70,6 +102,6 @@ enum class align_val_t : std::size_t;
 
 }  //namespace std
 
-#endif
+#endif   //defined(__cpp_aligned_new)
 
 #endif //#ifndef BOOST_CONTAINER_DETAIL_STD_FWD_HPP