passenger 6.0.27 → 6.1.1

data/src/cxx_supportlib/vendor-modified/boost/core/bit.hpp

@@ -15,8 +15,8 @@
 // Distributed under the Boost Software License, Version 1.0.
 // https://www.boost.org/LICENSE_1_0.txt
 
+#include <boost/core/detail/static_assert.hpp>
 #include <boost/config.hpp>
-#include <boost/static_assert.hpp>
 #include <boost/cstdint.hpp>
 #include <limits>
 #include <cstring>
@@ -28,7 +28,7 @@
 # pragma intrinsic(_BitScanForward)
 # pragma intrinsic(_BitScanReverse)
 
-# if defined(_M_X64)
+# if defined(_M_X64) || defined(_M_ARM64)
 #  pragma intrinsic(_BitScanForward64)
 #  pragma intrinsic(_BitScanReverse64)
 # endif
@@ -80,7 +80,7 @@ BOOST_CONSTEXPR To bit_cast( From const & from ) BOOST_NOEXCEPT
 template<class To, class From>
 To bit_cast( From const & from ) BOOST_NOEXCEPT
 {
-    BOOST_STATIC_ASSERT( sizeof(To) == sizeof(From) );
+    BOOST_CORE_STATIC_ASSERT( sizeof(To) == sizeof(From) );
 
     To to;
     std::memcpy( &to, &from, sizeof(To) );
@@ -126,7 +126,7 @@ BOOST_CONSTEXPR inline int countl_impl( boost::ulong_long_type x ) BOOST_NOEXCEP
 template<class T>
 BOOST_CONSTEXPR int countl_zero( T x ) BOOST_NOEXCEPT
 {
-    BOOST_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );
+    BOOST_CORE_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );
 
     return boost::core::detail::countl_impl( x );
 }
@@ -230,7 +230,7 @@ inline int countl_impl( boost::uint16_t x ) BOOST_NOEXCEPT
 
 #endif
 
-#if defined(_MSC_VER) && defined(_M_X64) && defined(BOOST_CORE_HAS_BUILTIN_ISCONSTEVAL)
+#if defined(_MSC_VER) && (defined(_M_X64) || defined(_M_ARM64)) && defined(BOOST_CORE_HAS_BUILTIN_ISCONSTEVAL)
 
 BOOST_CXX14_CONSTEXPR inline int countl_impl( boost::uint64_t x ) BOOST_NOEXCEPT
 {
@@ -255,7 +255,7 @@ BOOST_CXX14_CONSTEXPR inline int countl_impl( boost::uint64_t x ) BOOST_NOEXCEPT
     }
 }
 
-#elif defined(_MSC_VER) && defined(_M_X64)
+#elif defined(_MSC_VER) && (defined(_M_X64) || defined(_M_ARM64))
 
 inline int countl_impl( boost::uint64_t x ) BOOST_NOEXCEPT
 {
@@ -296,9 +296,9 @@ inline int countl_impl( boost::uint64_t x ) BOOST_NOEXCEPT
 template<class T>
 BOOST_CXX14_CONSTEXPR int countl_zero( T x ) BOOST_NOEXCEPT
 {
-    BOOST_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );
+    BOOST_CORE_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );
 
-    BOOST_STATIC_ASSERT( sizeof(T) == sizeof(boost::uint8_t) || sizeof(T) == sizeof(boost::uint16_t) || sizeof(T) == sizeof(boost::uint32_t) || sizeof(T) == sizeof(boost::uint64_t) );
+    BOOST_CORE_STATIC_ASSERT( sizeof(T) == sizeof(boost::uint8_t) || sizeof(T) == sizeof(boost::uint16_t) || sizeof(T) == sizeof(boost::uint32_t) || sizeof(T) == sizeof(boost::uint64_t) );
 
     BOOST_IF_CONSTEXPR ( sizeof(T) == sizeof(boost::uint8_t) )
     {
@@ -323,7 +323,7 @@ BOOST_CXX14_CONSTEXPR int countl_zero( T x ) BOOST_NOEXCEPT
 template<class T>
 BOOST_CONSTEXPR int countl_one( T x ) BOOST_NOEXCEPT
 {
-    BOOST_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );
+    BOOST_CORE_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );
 
     return boost::core::countl_zero( static_cast<T>( ~x ) );
 }
@@ -365,7 +365,7 @@ BOOST_CONSTEXPR inline int countr_impl( boost::ulong_long_type x ) BOOST_NOEXCEP
 template<class T>
 BOOST_CONSTEXPR int countr_zero( T x ) BOOST_NOEXCEPT
 {
-    BOOST_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );
+    BOOST_CORE_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );
 
     return boost::core::detail::countr_impl( x );
 }
@@ -455,7 +455,7 @@ inline int countr_impl( boost::uint16_t x ) BOOST_NOEXCEPT
 
 #endif
 
-#if defined(_MSC_VER) && defined(_M_X64) && defined(BOOST_CORE_HAS_BUILTIN_ISCONSTEVAL)
+#if defined(_MSC_VER) && (defined(_M_X64) || defined(_M_ARM64)) && defined(BOOST_CORE_HAS_BUILTIN_ISCONSTEVAL)
 
 BOOST_CXX14_CONSTEXPR inline int countr_impl( boost::uint64_t x ) BOOST_NOEXCEPT
 {
@@ -480,7 +480,7 @@ BOOST_CXX14_CONSTEXPR inline int countr_impl( boost::uint64_t x ) BOOST_NOEXCEPT
     }
 }
 
-#elif defined(_MSC_VER) && defined(_M_X64)
+#elif defined(_MSC_VER) && (defined(_M_X64) || defined(_M_ARM64))
 
 inline int countr_impl( boost::uint64_t x ) BOOST_NOEXCEPT
 {
@@ -521,9 +521,9 @@ inline int countr_impl( boost::uint64_t x ) BOOST_NOEXCEPT
 template<class T>
 BOOST_CXX14_CONSTEXPR int countr_zero( T x ) BOOST_NOEXCEPT
 {
-    BOOST_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );
+    BOOST_CORE_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );
 
-    BOOST_STATIC_ASSERT( sizeof(T) == sizeof(boost::uint8_t) || sizeof(T) == sizeof(boost::uint16_t) || sizeof(T) == sizeof(boost::uint32_t) || sizeof(T) == sizeof(boost::uint64_t) );
+    BOOST_CORE_STATIC_ASSERT( sizeof(T) == sizeof(boost::uint8_t) || sizeof(T) == sizeof(boost::uint16_t) || sizeof(T) == sizeof(boost::uint32_t) || sizeof(T) == sizeof(boost::uint64_t) );
 
     BOOST_IF_CONSTEXPR ( sizeof(T) == sizeof(boost::uint8_t) )
     {
@@ -548,7 +548,7 @@ BOOST_CXX14_CONSTEXPR int countr_zero( T x ) BOOST_NOEXCEPT
 template<class T>
 BOOST_CONSTEXPR int countr_one( T x ) BOOST_NOEXCEPT
 {
-    BOOST_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );
+    BOOST_CORE_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );
 
     return boost::core::countr_zero( static_cast<T>( ~x ) );
 }
@@ -598,7 +598,7 @@ BOOST_CORE_POPCOUNT_CONSTEXPR inline int popcount_impl( boost::ulong_long_type x
 template<class T>
 BOOST_CONSTEXPR int popcount( T x ) BOOST_NOEXCEPT
 {
-    BOOST_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );
+    BOOST_CORE_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );
 
     return boost::core::detail::popcount_impl( x );
 }
@@ -631,9 +631,9 @@ BOOST_CXX14_CONSTEXPR inline int popcount_impl( boost::uint64_t x ) BOOST_NOEXCE
 template<class T>
 BOOST_CXX14_CONSTEXPR int popcount( T x ) BOOST_NOEXCEPT
 {
-    BOOST_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );
+    BOOST_CORE_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );
 
-    BOOST_STATIC_ASSERT( sizeof(T) <= sizeof(boost::uint64_t) );
+    BOOST_CORE_STATIC_ASSERT( sizeof(T) <= sizeof(boost::uint64_t) );
 
     BOOST_IF_CONSTEXPR ( sizeof(T) <= sizeof(boost::uint32_t) )
     {
@@ -652,7 +652,7 @@ BOOST_CXX14_CONSTEXPR int popcount( T x ) BOOST_NOEXCEPT
 template<class T>
 BOOST_CXX14_CONSTEXPR T rotl( T x, int s ) BOOST_NOEXCEPT
 {
-    BOOST_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );
+    BOOST_CORE_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );
 
     unsigned const mask = std::numeric_limits<T>::digits - 1;
     return static_cast<T>( x << (static_cast<unsigned>( s ) & mask) | x >> (static_cast<unsigned>( -s ) & mask) );
@@ -661,7 +661,7 @@ BOOST_CXX14_CONSTEXPR T rotl( T x, int s ) BOOST_NOEXCEPT
 template<class T>
 BOOST_CXX14_CONSTEXPR T rotr( T x, int s ) BOOST_NOEXCEPT
 {
-    BOOST_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );
+    BOOST_CORE_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );
 
     unsigned const mask = std::numeric_limits<T>::digits - 1;
     return static_cast<T>( x >> (static_cast<unsigned>( s ) & mask) | x << (static_cast<unsigned>( -s ) & mask) );
@@ -672,7 +672,7 @@ BOOST_CXX14_CONSTEXPR T rotr( T x, int s ) BOOST_NOEXCEPT
 template<class T>
 BOOST_CONSTEXPR bool has_single_bit( T x ) BOOST_NOEXCEPT
 {
-    BOOST_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );
+    BOOST_CORE_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );
 
     return x != 0 && ( x & ( x - 1 ) ) == 0;
 }
@@ -683,7 +683,7 @@ BOOST_CONSTEXPR bool has_single_bit( T x ) BOOST_NOEXCEPT
 template<class T>
 BOOST_CONSTEXPR int bit_width( T x ) BOOST_NOEXCEPT
 {
-    BOOST_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );
+    BOOST_CORE_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );
 
     return std::numeric_limits<T>::digits - boost::core::countl_zero( x );
 }
@@ -691,7 +691,7 @@ BOOST_CONSTEXPR int bit_width( T x ) BOOST_NOEXCEPT
 template<class T>
 BOOST_CONSTEXPR T bit_floor( T x ) BOOST_NOEXCEPT
 {
-    BOOST_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );
+    BOOST_CORE_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );
 
     return x == 0? T(0): static_cast<T>( T(1) << ( boost::core::bit_width( x ) - 1 ) );
 }
@@ -703,7 +703,7 @@ BOOST_CXX14_CONSTEXPR inline boost::uint32_t bit_ceil_impl( boost::uint32_t x )
 {
     if( x == 0 )
     {
-        return 0;
+        return 1;
     }
 
     --x;
@@ -723,7 +723,7 @@ BOOST_CXX14_CONSTEXPR inline boost::uint64_t bit_ceil_impl( boost::uint64_t x )
 {
     if( x == 0 )
     {
-        return 0;
+        return 1;
     }
 
     --x;
@@ -745,9 +745,9 @@ BOOST_CXX14_CONSTEXPR inline boost::uint64_t bit_ceil_impl( boost::uint64_t x )
 template<class T>
 BOOST_CXX14_CONSTEXPR T bit_ceil( T x ) BOOST_NOEXCEPT
 {
-    BOOST_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );
+    BOOST_CORE_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );
 
-    BOOST_STATIC_ASSERT( sizeof(T) <= sizeof(boost::uint64_t) );
+    BOOST_CORE_STATIC_ASSERT( sizeof(T) <= sizeof(boost::uint64_t) );
 
     BOOST_IF_CONSTEXPR ( sizeof(T) <= sizeof(boost::uint32_t) )
     {
@@ -922,9 +922,9 @@ BOOST_CXX14_CONSTEXPR inline boost::uint64_t byteswap_impl( boost::uint64_t x )
 
 template<class T> BOOST_CXX14_CONSTEXPR T byteswap( T x ) BOOST_NOEXCEPT
 {
-    BOOST_STATIC_ASSERT( std::numeric_limits<T>::is_integer );
+    BOOST_CORE_STATIC_ASSERT( std::numeric_limits<T>::is_integer );
 
-    BOOST_STATIC_ASSERT( sizeof(T) == sizeof(boost::uint8_t) || sizeof(T) == sizeof(boost::uint16_t) || sizeof(T) == sizeof(boost::uint32_t) || sizeof(T) == sizeof(boost::uint64_t) );
+    BOOST_CORE_STATIC_ASSERT( sizeof(T) == sizeof(boost::uint8_t) || sizeof(T) == sizeof(boost::uint16_t) || sizeof(T) == sizeof(boost::uint32_t) || sizeof(T) == sizeof(boost::uint64_t) );
 
     BOOST_IF_CONSTEXPR ( sizeof(T) == sizeof(boost::uint8_t) )
     {

data/src/cxx_supportlib/vendor-modified/boost/core/cmath.hpp

@@ -20,8 +20,8 @@
 
 #if defined(BOOST_CORE_USE_GENERIC_CMATH) || (!defined(_MSC_VER) && !defined(FP_SUBNORMAL))
 
+#include <boost/core/detail/static_assert.hpp>
 #include <boost/cstdint.hpp>
-#include <boost/static_assert.hpp>
 #include <limits>
 #include <cstring>
 
@@ -81,7 +81,7 @@ inline bool signbit( float x )
 {
     boost::int32_t y;
 
-    BOOST_STATIC_ASSERT( sizeof( x ) == sizeof( y ) );
+    BOOST_CORE_STATIC_ASSERT( sizeof( x ) == sizeof( y ) );
 
     std::memcpy( &y, &x, sizeof( y ) );
 
@@ -92,7 +92,7 @@ inline bool signbit( double x )
 {
     boost::int64_t y;
 
-    BOOST_STATIC_ASSERT( sizeof( x ) == sizeof( y ) );
+    BOOST_CORE_STATIC_ASSERT( sizeof( x ) == sizeof( y ) );
 
     std::memcpy( &y, &x, sizeof( y ) );
 

data/src/cxx_supportlib/vendor-modified/boost/core/data.hpp

@@ -8,8 +8,20 @@ Distributed under the Boost Software License, Version 1.0.
 #ifndef BOOST_CORE_DATA_HPP
 #define BOOST_CORE_DATA_HPP
 
-#include <initializer_list>
+#include <iterator>
+
+// Note: MSVC doesn't define __cpp_lib_nonmember_container_access but supports the feature even in C++14 mode
+#if (defined(__cpp_lib_nonmember_container_access) && (__cpp_lib_nonmember_container_access >= 201411l)) || \
+    (defined(_MSC_VER) && (_MSC_VER >= 1900))
+
+namespace boost {
+using std::data;
+} /* boost */
+
+#else // (defined(__cpp_lib_nonmember_container_access) ...
+
 #include <cstddef>
+#include <initializer_list>
 
 namespace boost {
 
@@ -43,4 +55,6 @@ data(std::initializer_list<T> l) noexcept
 
 } /* boost */
 
+#endif // (defined(__cpp_lib_nonmember_container_access) ...
+
 #endif

data/src/cxx_supportlib/vendor-modified/boost/core/default_allocator.hpp

@@ -10,6 +10,7 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/config.hpp>
 #include <new>
+#include <cstddef>
 
 namespace boost {
 

data/src/cxx_supportlib/vendor-modified/boost/core/demangle.hpp

@@ -30,7 +30,7 @@
 
 #if defined( BOOST_CORE_HAS_CXXABI_H )
 # include <cxxabi.h>
-// For some archtectures (mips, mips64, x86, x86_64) cxxabi.h in Android NDK is implemented by gabi++ library
+// For some architectures (mips, mips64, x86, x86_64) cxxabi.h in Android NDK is implemented by gabi++ library
 // (https://android.googlesource.com/platform/ndk/+/master/sources/cxx-stl/gabi++/), which does not implement
 // abi::__cxa_demangle(). We detect this implementation by checking the include guard here.
 # if defined( __GABIXX_CXXABI_H__ )

data/src/cxx_supportlib/vendor-modified/boost/core/detail/assert.hpp

@@ -0,0 +1,18 @@
+/*
+Copyright 2025 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#undef BOOST_CORE_DETAIL_ASSERT
+
+#if !defined(__clang__) && \
+    !defined(__INTEL_COMPILER) && \
+    defined(__GNUC__) && \
+    (__GNUC__ < 5)
+#define BOOST_CORE_DETAIL_ASSERT(expr) void(0)
+#else
+#include <boost/assert.hpp>
+#define BOOST_CORE_DETAIL_ASSERT(expr) BOOST_ASSERT(expr)
+#endif

data/src/cxx_supportlib/vendor-modified/boost/core/detail/sp_thread_sleep.hpp

@@ -67,7 +67,7 @@ namespace core
 
 inline void sp_thread_sleep() BOOST_NOEXCEPT
 {
-#if defined(BOOST_HAS_PTHREADS) && !defined(__ANDROID__)
+#if defined(BOOST_HAS_PTHREADS) && !defined(__ANDROID__) && !defined(__OHOS__)
 
     int oldst;
     pthread_setcancelstate( PTHREAD_CANCEL_DISABLE, &oldst );
@@ -85,7 +85,7 @@ inline void sp_thread_sleep() BOOST_NOEXCEPT
 
     nanosleep( &rqtp, 0 );
 
-#if defined(BOOST_HAS_PTHREADS) && !defined(__ANDROID__)
+#if defined(BOOST_HAS_PTHREADS) && !defined(__ANDROID__) && !defined(__OHOS__)
 
     pthread_setcancelstate( oldst, &oldst );
 

data/src/cxx_supportlib/vendor-modified/boost/core/detail/static_assert.hpp

@@ -0,0 +1,42 @@
+#ifndef BOOST_CORE_DETAIL_STATIC_ASSERT_HPP_INCLUDED
+#define BOOST_CORE_DETAIL_STATIC_ASSERT_HPP_INCLUDED
+
+// Copyright 2025 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#if defined(__cpp_static_assert) && __cpp_static_assert >= 200410L
+
+#define BOOST_CORE_STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
+
+#else
+
+#include <boost/config.hpp>
+#include <cstddef>
+
+namespace boost
+{
+namespace core
+{
+
+template<bool> struct STATIC_ASSERTION_FAILURE;
+
+template<> struct STATIC_ASSERTION_FAILURE<true>
+{
+};
+
+template<std::size_t> struct static_assert_test
+{
+};
+
+} // namespace core
+} // namespace boost
+
+#define BOOST_CORE_STATIC_ASSERT(expr) \
+    typedef ::boost::core::static_assert_test< \
+        sizeof( ::boost::core::STATIC_ASSERTION_FAILURE<(expr)? true: false> ) \
+    > BOOST_JOIN(boost_static_assert_typedef_,__LINE__) BOOST_ATTRIBUTE_UNUSED
+
+#endif
+
+#endif  // #ifndef BOOST_CORE_DETAIL_STATIC_ASSERT_HPP_INCLUDED

data/src/cxx_supportlib/vendor-modified/boost/core/detail/string_view.hpp

@@ -34,6 +34,9 @@
 #if !defined(BOOST_NO_CXX20_HDR_CONCEPTS) // std::common_reference_with
 # include <type_traits>
 #endif
+#if !defined(BOOST_NO_CXX20_HDR_FORMAT)
+# include <format> // std::formatter
+#endif
 
 namespace boost
 {
@@ -41,9 +44,6 @@ namespace boost
 // forward declaration of boost::basic_string_view from Utility
 template<class Ch, class Tr> class basic_string_view;
 
-// forward declaration of boost::hash_range from ContainerHash
-template<class It> std::size_t hash_range( It, It );
-
 namespace core
 {
 namespace detail
@@ -381,7 +381,7 @@ public:
     }
 
     template<class End> BOOST_CXX14_CONSTEXPR basic_string_view( Ch const* first, End last,
-        typename boost::enable_if<boost::core::detail::is_same<End, Ch const*> >::type* = 0 ) BOOST_NOEXCEPT: p_( first ), n_( static_cast<size_type>( last - first ) )
+        typename boost::enable_if<boost::core::detail::is_same<End, Ch const*>, int >::type = 0 ) BOOST_NOEXCEPT: p_( first ), n_( static_cast<size_type>( last - first ) )
     {
         BOOST_ASSERT( last - first >= 0 );
     }
@@ -399,7 +399,7 @@ public:
 #endif
 
     template<class Ch2> basic_string_view( boost::basic_string_view<Ch2, std::char_traits<Ch2> > const& str,
-        typename boost::enable_if<boost::core::detail::is_same<Ch, Ch2> >::type* = 0 ) BOOST_NOEXCEPT: p_( str.data() ), n_( str.size() )
+        typename boost::enable_if<boost::core::detail::is_same<Ch, Ch2>, int >::type = 0 ) BOOST_NOEXCEPT: p_( str.data() ), n_( str.size() )
     {
     }
 
@@ -1181,11 +1181,6 @@ public:
     }
 
 #endif
-
-    inline friend std::size_t hash_value( basic_string_view const& sv )
-    {
-        return boost::hash_range( sv.begin(), sv.end() );
-    }
 };
 
 // stream inserter
@@ -1269,4 +1264,15 @@ struct std::basic_common_reference<
 
 #endif
 
+// std::format support
+
+#if !defined(BOOST_NO_CXX20_HDR_FORMAT)
+
+template<class Ch, class Ch2>
+struct std::formatter<boost::core::basic_string_view<Ch>, Ch2>: std::formatter<std::basic_string_view<Ch>, Ch2>
+{
+};
+
+#endif
+
 #endif  // #ifndef BOOST_CORE_STRING_VIEW_HPP_INCLUDED

data/src/cxx_supportlib/vendor-modified/boost/core/lightweight_test.hpp

@@ -551,39 +551,47 @@ inline void lwt_init()
 #define BOOST_TEST_ALL_EQ(begin1, end1, begin2, end2) ( ::boost::detail::test_all_eq_impl(BOOST_LIGHTWEIGHT_TEST_OSTREAM, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, begin1, end1, begin2, end2) )
 #define BOOST_TEST_ALL_WITH(begin1, end1, begin2, end2, predicate) ( ::boost::detail::test_all_with_impl(BOOST_LIGHTWEIGHT_TEST_OSTREAM, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, begin1, end1, begin2, end2, predicate) )
 
+#if defined(BOOST_MSVC) && BOOST_MSVC < 1900
+# define BOOST_LWT_DETAIL_WHILE_FALSE __pragma(warning(push)) __pragma(warning(disable:4127)) while(false) __pragma(warning(pop))
+#else
+# define BOOST_LWT_DETAIL_WHILE_FALSE while(false)
+#endif
+
 #ifndef BOOST_NO_EXCEPTIONS
-   #define BOOST_TEST_THROWS( EXPR, EXCEP )                           \
-      try {                                                           \
-         EXPR;                                                        \
-         ::boost::detail::throw_failed_impl                           \
-         (#EXPR, #EXCEP, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION); \
-      }                                                               \
-      catch(EXCEP const&) {                                           \
-         ::boost::detail::test_results();                             \
-      }                                                               \
-      catch(...) {                                                    \
-         ::boost::detail::throw_failed_impl                           \
-         (#EXPR, #EXCEP, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION); \
-      }                                                               \
-   //
+   #define BOOST_TEST_THROWS( EXPR, EXCEP )                              \
+      do {                                                               \
+         try {                                                           \
+            EXPR;                                                        \
+            ::boost::detail::throw_failed_impl                           \
+            (#EXPR, #EXCEP, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION); \
+         }                                                               \
+         catch(EXCEP const&) {                                           \
+            ::boost::detail::test_results();                             \
+         }                                                               \
+         catch(...) {                                                    \
+            ::boost::detail::throw_failed_impl                           \
+            (#EXPR, #EXCEP, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION); \
+         }                                                               \
+      } BOOST_LWT_DETAIL_WHILE_FALSE
 #else
-   #define BOOST_TEST_THROWS( EXPR, EXCEP )
+   #define BOOST_TEST_THROWS( EXPR, EXCEP ) do {} BOOST_LWT_DETAIL_WHILE_FALSE
 #endif
 
 #ifndef BOOST_NO_EXCEPTIONS
-#  define BOOST_TEST_NO_THROW(EXPR)                                    \
-    try {                                                              \
-        EXPR;                                                          \
-    } catch (const std::exception& e) {                                \
-        ::boost::detail::no_throw_failed_impl                          \
-        (#EXPR, e.what(), __FILE__, __LINE__, BOOST_CURRENT_FUNCTION); \
-    } catch (...) {                                                    \
-        ::boost::detail::no_throw_failed_impl                          \
-        (#EXPR, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION);           \
-    }
-    //
+#  define BOOST_TEST_NO_THROW(EXPR)                                        \
+    do {                                                                   \
+        try {                                                              \
+            EXPR;                                                          \
+        } catch (const std::exception& e) {                                \
+            ::boost::detail::no_throw_failed_impl                          \
+            (#EXPR, e.what(), __FILE__, __LINE__, BOOST_CURRENT_FUNCTION); \
+        } catch (...) {                                                    \
+            ::boost::detail::no_throw_failed_impl                          \
+            (#EXPR, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION);           \
+        }                                                                  \
+    } BOOST_LWT_DETAIL_WHILE_FALSE
 #else
-#  define BOOST_TEST_NO_THROW(EXPR) { EXPR; }
+#  define BOOST_TEST_NO_THROW(EXPR) do { EXPR; } BOOST_LWT_DETAIL_WHILE_FALSE
 #endif
 
 #endif // #ifndef BOOST_CORE_LIGHTWEIGHT_TEST_HPP

data/src/cxx_supportlib/vendor-modified/boost/core/scoped_enum.hpp

@@ -37,7 +37,7 @@ namespace boost
   /**
    * Casts a scoped enum to its underlying type.
    *
-   * This function is useful when working with scoped enum classes, which doens't implicitly convert to the underlying type.
+   * This function is useful when working with scoped enum classes, which doesn't implicitly convert to the underlying type.
    * @param v A scoped enum.
    * @returns The underlying type.
    * @throws No-throws.

data/src/cxx_supportlib/vendor-modified/boost/core/size.hpp

@@ -8,6 +8,18 @@ Distributed under the Boost Software License, Version 1.0.
 #ifndef BOOST_CORE_SIZE_HPP
 #define BOOST_CORE_SIZE_HPP
 
+#include <iterator>
+
+// Note: MSVC doesn't define __cpp_lib_nonmember_container_access but supports the feature even in C++14 mode
+#if (defined(__cpp_lib_nonmember_container_access) && (__cpp_lib_nonmember_container_access >= 201411l)) || \
+    (defined(_MSC_VER) && (_MSC_VER >= 1900))
+
+namespace boost {
+using std::size;
+} /* boost */
+
+#else // (defined(__cpp_lib_nonmember_container_access) ...
+
 #include <cstddef>
 
 namespace boost {
@@ -28,4 +40,6 @@ size(T(&)[N]) noexcept
 
 } /* boost */
 
+#endif // (defined(__cpp_lib_nonmember_container_access) ...
+
 #endif

data/src/cxx_supportlib/vendor-modified/boost/core/span.hpp

@@ -8,6 +8,7 @@ Distributed under the Boost Software License, Version 1.0.
 #ifndef BOOST_CORE_SPAN_HPP
 #define BOOST_CORE_SPAN_HPP
 
+#include <boost/core/detail/assert.hpp>
 #include <boost/core/data.hpp>
 #include <array>
 #include <iterator>
@@ -22,9 +23,15 @@ class span;
 
 namespace detail {
 
-template<class U, class T>
+template<class U, class T, class = void>
 struct span_convertible {
-    static constexpr bool value = std::is_convertible<U(*)[], T(*)[]>::value;
+    static constexpr bool value = false;
+};
+
+template<class U, class T>
+struct span_convertible<U, T, typename
+    std::enable_if<std::is_convertible<U(*)[], T(*)[]>::value>::type> {
+    static constexpr bool value = true;
 };
 
 template<std::size_t E, std::size_t N>
@@ -274,17 +281,21 @@ public:
     }
 
     constexpr span<T, dynamic_extent> first(size_type c) const {
-        return span<T, dynamic_extent>(s_.p, c);
+        return BOOST_CORE_DETAIL_ASSERT(c <= size()),
+            span<T, dynamic_extent>(s_.p, c);
     }
 
     constexpr span<T, dynamic_extent> last(size_type c) const {
-        return span<T, dynamic_extent>(s_.p + (s_.n - c), c);
+        return BOOST_CORE_DETAIL_ASSERT(c <= size()),
+            span<T, dynamic_extent>(s_.p + (s_.n - c), c);
     }
 
     constexpr span<T, dynamic_extent> subspan(size_type o,
         size_type c = dynamic_extent) const {
-        return span<T, dynamic_extent>(s_.p + o,
-            c == dynamic_extent ? s_.n - o : c);
+        return BOOST_CORE_DETAIL_ASSERT(o <= size() &&
+                (c == dynamic_extent || c + o <= size())),
+            span<T, dynamic_extent>(s_.p + o,
+                c == dynamic_extent ? s_.n - o : c);
     }
 
     constexpr size_type size() const noexcept {
@@ -300,15 +311,15 @@ public:
     }
 
     constexpr reference operator[](size_type i) const {
-        return s_.p[i];
+        return BOOST_CORE_DETAIL_ASSERT(i < size()), s_.p[i];
     }
 
     constexpr reference front() const {
-        return *s_.p;
+        return BOOST_CORE_DETAIL_ASSERT(!empty()), *s_.p;
     }
 
     constexpr reference back() const {
-        return s_.p[s_.n - 1];
+        return BOOST_CORE_DETAIL_ASSERT(!empty()), s_.p[s_.n - 1];
     }
 
     constexpr pointer data() const noexcept {

data/src/cxx_supportlib/vendor-modified/boost/cregex.hpp

@@ -14,7 +14,6 @@
   *   FILE         cregex.cpp
   *   VERSION      see <boost/version.hpp>
   *   DESCRIPTION: Declares POSIX API functions
-  *                + boost::RegEx high level wrapper.
   */
 
 #ifndef BOOST_RE_CREGEX_HPP
@@ -24,11 +23,7 @@
 #include <boost/regex/config.hpp>
 #endif
 
-#ifdef BOOST_REGEX_CXX03
-#include <boost/regex/v4/cregex.hpp>
-#else
 #include <boost/regex/v5/cregex.hpp>
-#endif
 
 #endif /* include guard */
 

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

@@ -37,4 +37,12 @@
 # define BOOST_DESCRIBE_MAYBE_UNUSED
 #endif
 
+#if defined(__cpp_inline_variables) && __cpp_inline_variables >= 201606L
+# define BOOST_DESCRIBE_INLINE_VARIABLE inline
+#else
+# define BOOST_DESCRIBE_INLINE_VARIABLE
+#endif
+
+#define BOOST_DESCRIBE_INLINE_CONSTEXPR BOOST_DESCRIBE_INLINE_VARIABLE BOOST_DESCRIBE_CONSTEXPR_OR_CONST
+
 #endif // #ifndef BOOST_DESCRIBE_DETAIL_CONFIG_HPP_INCLUDED