passenger 6.1.0 → 6.1.1

data/src/cxx_supportlib/vendor-modified/boost/lexical_cast/detail/converter_lexical_streams.hpp

@@ -1,6 +1,6 @@
 // Copyright Kevlin Henney, 2000-2005.
 // Copyright Alexander Nasonov, 2006-2010.
-// Copyright Antony Polukhin, 2011-2024.
+// Copyright Antony Polukhin, 2011-2025.
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@@ -32,13 +32,10 @@
 #include <string>
 #include <cstring>
 #include <cstdio>
+#include <type_traits>
 #include <boost/limits.hpp>
-#include <boost/type_traits/conditional.hpp>
-#include <boost/type_traits/is_enum.hpp>
-#include <boost/type_traits/is_signed.hpp>
-#include <boost/type_traits/is_unsigned.hpp>
-#include <boost/type_traits/is_pointer.hpp>
 #include <boost/detail/lcast_precision.hpp>
+#include <boost/lexical_cast/detail/type_traits.hpp>
 #include <boost/config/workaround.hpp>
 #include <boost/core/snprintf.hpp>
 
@@ -71,13 +68,7 @@
 
 #include <array>
 
-#include <boost/type_traits/make_unsigned.hpp>
-#include <boost/type_traits/is_integral.hpp>
-#include <boost/type_traits/is_float.hpp>
-#include <boost/type_traits/is_const.hpp>
-#include <boost/type_traits/is_reference.hpp>
 #include <boost/container/container_fwd.hpp>
-#include <boost/core/enable_if.hpp>
 #ifndef BOOST_NO_CWCHAR
 #   include <cwchar>
 #endif
@@ -97,8 +88,8 @@ namespace boost { namespace detail { namespace lcast {
 
     template <typename T>
     struct exact {
-        static_assert(!boost::is_const<T>::value, "");
-        static_assert(!boost::is_reference<T>::value, "");
+        static_assert(!std::is_const<T>::value, "");
+        static_assert(!std::is_reference<T>::value, "");
 
         const T& payload;
     };
@@ -185,7 +176,7 @@ namespace boost { namespace detail { namespace lcast {
         template <class T>
         inline bool shl_signed(const T n) {
             CharT* tmp_finish = buffer + CharacterBufferSize;
-            typedef typename boost::make_unsigned<T>::type utype;
+            typedef typename boost::detail::lcast::make_unsigned<T>::type utype;
             CharT* tmp_start = lcast_put_unsigned<Traits, utype, CharT>(lcast_to_unsigned(n), tmp_finish).convert();
             if (n < 0) {
                 --tmp_start;
@@ -197,37 +188,37 @@ namespace boost { namespace detail { namespace lcast {
             return true;
         }
 
-        bool shl_real_type(float val, char* begin) {
-            const double val_as_double = val;
+        bool shl_real_type(lcast::exact<float> val, char* begin) {
+            const double val_as_double = static_cast<double>(val.payload);
             finish = start +
                 boost::core::snprintf(begin, CharacterBufferSize,
                 "%.*g", static_cast<int>(boost::detail::lcast_precision<float>::value), val_as_double);
             return finish > start;
         }
 
-        bool shl_real_type(double val, char* begin) {
+        bool shl_real_type(lcast::exact<double> val, char* begin) {
             finish = start +
                 boost::core::snprintf(begin, CharacterBufferSize,
-                "%.*g", static_cast<int>(boost::detail::lcast_precision<double>::value), val);
+                "%.*g", static_cast<int>(boost::detail::lcast_precision<double>::value), val.payload);
             return finish > start;
         }
 
 #ifndef __MINGW32__
-        bool shl_real_type(long double val, char* begin) {
+        bool shl_real_type(lcast::exact<long double> val, char* begin) {
             finish = start +
                 boost::core::snprintf(begin, CharacterBufferSize,
-                "%.*Lg", static_cast<int>(boost::detail::lcast_precision<long double>::value), val );
+                "%.*Lg", static_cast<int>(boost::detail::lcast_precision<long double>::value), val.payload );
             return finish > start;
         }
 #else
-        bool shl_real_type(long double val, char* begin) {
-            return shl_real_type(static_cast<double>(val), begin);
+        bool shl_real_type(lcast::exact<long double> val, char* begin) {
+            return shl_real_type(lcast::exact<double>{static_cast<double>(val.payload)}, begin);
         }
 #endif
 
 #if !defined(BOOST_LCAST_NO_WCHAR_T)
-        bool shl_real_type(float val, wchar_t* begin) {
-            const double val_as_double = val;
+        bool shl_real_type(lcast::exact<float> val, wchar_t* begin) {
+            const double val_as_double = static_cast<double>(val.payload);
             finish = start + boost::core::swprintf(
                 begin, CharacterBufferSize, L"%.*g",
                 static_cast<int>(boost::detail::lcast_precision<float>::value),
@@ -236,31 +227,31 @@ namespace boost { namespace detail { namespace lcast {
             return finish > start;
         }
 
-        bool shl_real_type(double val, wchar_t* begin) {
+        bool shl_real_type(lcast::exact<double> val, wchar_t* begin) {
             finish = start + boost::core::swprintf(
               begin, CharacterBufferSize, L"%.*g",
               static_cast<int>(boost::detail::lcast_precision<double>::value),
-              val
+              val.payload
             );
             return finish > start;
         }
 
-        bool shl_real_type(long double val, wchar_t* begin) {
+        bool shl_real_type(lcast::exact<long double> val, wchar_t* begin) {
             finish = start + boost::core::swprintf(
                 begin, CharacterBufferSize, L"%.*Lg",
                 static_cast<int>(boost::detail::lcast_precision<long double>::value),
-                val
+                val.payload
             );
             return finish > start;
         }
 #endif
     public:
         template <class C>
-        using enable_if_compatible_char_t = typename boost::enable_if_c<
-            boost::is_same<const C, const CharT>::value || (
-                boost::is_same<const char, const CharT>::value && (
-                    boost::is_same<const C, const unsigned char>::value ||
-                    boost::is_same<const C, const signed char>::value
+        using enable_if_compatible_char_t = typename std::enable_if<
+            std::is_same<const C, const CharT>::value || (
+                std::is_same<const char, const CharT>::value && (
+                    std::is_same<const C, const unsigned char>::value ||
+                    std::is_same<const C, const signed char>::value
                 )
             ), bool
         >::type;
@@ -302,32 +293,34 @@ namespace boost { namespace detail { namespace lcast {
         bool stream_in(lcast::exact<char> x)                    { return shl_char(x.payload); }
         bool stream_in(lcast::exact<unsigned char> x)           { return shl_char(static_cast<char>(x.payload)); }
         bool stream_in(lcast::exact<signed char> x)             { return shl_char(static_cast<char>(x.payload)); }
-        
+
+#if !defined(BOOST_NO_INTRINSIC_WCHAR_T)
         template <class C>
-        typename boost::enable_if_c<boost::detail::is_character<C>::value, bool>::type
+        typename std::enable_if<boost::detail::is_character<C>::value, bool>::type
                 stream_in(lcast::exact<C> x)                    { return shl_char(x.payload); }
+#endif
 
         template <class Type>
         enable_if_compatible_char_t<Type>
                 stream_in(lcast::exact<Type*> x)                { return shl_char_array(reinterpret_cast<CharT const*>(x.payload)); }
 
         template <class Type>
-        typename boost::enable_if_c<boost::is_signed<Type>::value && !boost::is_enum<Type>::value, bool>::type
+        typename std::enable_if<!std::is_floating_point<Type>::value && boost::detail::lcast::is_signed<Type>::value && !std::is_enum<Type>::value, bool>::type
                 stream_in(lcast::exact<Type> x)                  { return shl_signed(x.payload); }
 
         template <class Type>
-        typename boost::enable_if_c<boost::is_unsigned<Type>::value && !boost::is_enum<Type>::value, bool>::type
+        typename std::enable_if<boost::detail::lcast::is_unsigned<Type>::value && !std::is_enum<Type>::value, bool>::type
                 stream_in(lcast::exact<Type> x)                  { return shl_unsigned(x.payload); }
 
         template <class Type>
-        auto stream_in(lcast::exact<Type> x) -> decltype(shl_real_type(x.payload, buffer)) {
+        auto stream_in(lcast::exact<Type> x) -> decltype(shl_real_type(x, buffer)) {
             const CharT* inf_nan  = detail::get_inf_nan(x.payload, CharT());
             if (inf_nan) {
                 start = inf_nan;
                 finish = start + Traits::length(inf_nan);
                 return true;
             }
-            return shl_real_type(x.payload, buffer);
+            return shl_real_type(x, buffer);
         }
 
         template <class C, std::size_t N>
@@ -398,7 +391,7 @@ namespace boost { namespace detail { namespace lcast {
 #if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_LOCALE)
             // If you have compilation error at this point, than your STL library
             // does not support such conversions. Try updating it.
-            static_assert(boost::is_same<char, CharT>::value, "");
+            static_assert(std::is_same<char, CharT>::value, "");
 #endif
 
 #ifndef BOOST_NO_EXCEPTIONS
@@ -434,17 +427,17 @@ namespace boost { namespace detail { namespace lcast {
                 return true;
             }
 
-            lcast_set_precision(out_stream, &val);
+            boost::detail::lcast_set_precision(out_stream, &val);
             return shl_input_streamable(val);
         }
 
     public:
         template <class Type>
-        typename boost::enable_if_c<boost::detail::is_character<Type>::value && sizeof(char) == sizeof(Type), bool>::type
+        typename std::enable_if<boost::detail::is_character<Type>::value && sizeof(char) == sizeof(Type), bool>::type
                 stream_in(lcast::exact<const Type*> x)         { return shl_char_array(reinterpret_cast<char const*>(x.payload)); }
 
         template <class Type>
-        typename boost::enable_if_c<boost::detail::is_character<Type>::value && sizeof(char) != sizeof(Type), bool>::type
+        typename std::enable_if<boost::detail::is_character<Type>::value && sizeof(char) != sizeof(Type), bool>::type
                 stream_in(lcast::exact<const Type*> x)         { return shl_char_array(x.payload); }
 
         bool stream_in(lcast::exact<float> x)                  { return shl_real(x.payload); }
@@ -458,14 +451,14 @@ namespace boost { namespace detail { namespace lcast {
         }
 
         template <class C>
-        typename boost::enable_if_c<boost::detail::is_character<C>::value, bool>::type
+        typename std::enable_if<boost::detail::is_character<C>::value, bool>::type
         stream_in(lcast::exact<iterator_range<C*>> x) noexcept {
             auto buf = boost::conversion::detail::make_buffer_view(x.payload.begin(), x.payload.end());
             return stream_in(lcast::exact<decltype(buf)>{buf});
         }
 
         template <class C>
-        typename boost::enable_if_c<boost::detail::is_character<C>::value, bool>::type
+        typename std::enable_if<boost::detail::is_character<C>::value, bool>::type
         stream_in(lcast::exact<iterator_range<const C*>> x) noexcept {
             auto buf = boost::conversion::detail::make_buffer_view(x.payload.begin(), x.payload.end());
             return stream_in(lcast::exact<decltype(buf)>{buf});
@@ -526,7 +519,7 @@ namespace boost { namespace detail { namespace lcast {
             if (start == finish) return false;
             CharT const minus = lcast_char_constants<CharT>::minus;
             CharT const plus = lcast_char_constants<CharT>::plus;
-            typedef typename make_unsigned<Type>::type utype;
+            typedef typename boost::detail::lcast::make_unsigned<Type>::type utype;
             utype out_tmp = 0;
             bool const has_minus = Traits::eq(minus, *start);
 
@@ -552,12 +545,12 @@ namespace boost { namespace detail { namespace lcast {
         bool shr_using_base_class(InputStreamable& output)
         {
             static_assert(
-                !boost::is_pointer<InputStreamable>::value,
+                !std::is_pointer<InputStreamable>::value,
                 "boost::lexical_cast can not convert to pointers"
             );
 
 #if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_LOCALE)
-            static_assert(boost::is_same<char, CharT>::value,
+            static_assert(std::is_same<char, CharT>::value,
                 "boost::lexical_cast can not convert, because your STL library does not "
                 "support such conversions. Try updating it."
             );
@@ -583,7 +576,7 @@ namespace boost { namespace detail { namespace lcast {
             try {
 #endif
             stream.unsetf(std::ios::skipws);
-            lcast_set_precision(stream, static_cast<InputStreamable*>(0));
+            boost::detail::lcast_set_precision(stream, static_cast<InputStreamable*>(0));
 
             return (stream >> output)
                 && (stream.get() == Traits::eof());

data/src/cxx_supportlib/vendor-modified/boost/lexical_cast/detail/converter_numeric.hpp

@@ -1,6 +1,6 @@
 // Copyright Kevlin Henney, 2000-2005.
 // Copyright Alexander Nasonov, 2006-2010.
-// Copyright Antony Polukhin, 2011-2024.
+// Copyright Antony Polukhin, 2011-2025.
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@@ -23,15 +23,10 @@
 #   pragma once
 #endif
 
+#include <type_traits>
 #include <boost/core/cmath.hpp>
-#include <boost/core/enable_if.hpp>
 #include <boost/limits.hpp>
-#include <boost/type_traits/type_identity.hpp>
-#include <boost/type_traits/conditional.hpp>
-#include <boost/type_traits/make_unsigned.hpp>
-#include <boost/type_traits/is_signed.hpp>
-#include <boost/type_traits/is_arithmetic.hpp>
-#include <boost/type_traits/is_float.hpp>
+#include <boost/lexical_cast/detail/type_traits.hpp>
 
 namespace boost { namespace detail {
 
@@ -46,14 +41,15 @@ bool ios_numeric_comparer_float(Source x, Source y) noexcept {
 template <class RangeType, class T>
 constexpr bool is_out_of_range_for(T value) noexcept {
     return value > static_cast<T>((std::numeric_limits<RangeType>::max)())
-        || value < static_cast<T>((std::numeric_limits<RangeType>::min)());
+        || value < static_cast<T>((std::numeric_limits<RangeType>::min)())
+        || boost::core::isnan(value);
 }
 
 
 // integral -> integral
 template <typename Target, typename Source>
-typename boost::enable_if_c<
-    !boost::is_floating_point<Source>::value && !boost::is_floating_point<Target>::value, bool
+typename std::enable_if<
+    !std::is_floating_point<Source>::value && !std::is_floating_point<Target>::value, bool
 >::type noexcept_numeric_convert(Source arg, Target& result) noexcept {
     const Target target_tmp = static_cast<Target>(arg);
     const Source arg_restored = static_cast<Source>(target_tmp);
@@ -66,8 +62,8 @@ typename boost::enable_if_c<
 
 // integral -> floating point
 template <typename Target, typename Source>
-typename boost::enable_if_c<
-    !boost::is_floating_point<Source>::value && boost::is_floating_point<Target>::value, bool
+typename std::enable_if<
+    !std::is_floating_point<Source>::value && std::is_floating_point<Target>::value, bool
 >::type noexcept_numeric_convert(Source arg, Target& result) noexcept {
     const Target target_tmp = static_cast<Target>(arg);
     result = target_tmp;
@@ -77,8 +73,8 @@ typename boost::enable_if_c<
 
 // floating point -> floating point
 template <typename Target, typename Source>
-typename boost::enable_if_c<
-    boost::is_floating_point<Source>::value && boost::is_floating_point<Target>::value, bool
+typename std::enable_if<
+    std::is_floating_point<Source>::value && std::is_floating_point<Target>::value, bool
 >::type noexcept_numeric_convert(Source arg, Target& result) noexcept {
     const Target target_tmp = static_cast<Target>(arg);
     const Source arg_restored = static_cast<Source>(target_tmp);
@@ -92,8 +88,8 @@ typename boost::enable_if_c<
 
 // floating point -> integral
 template <typename Target, typename Source>
-typename boost::enable_if_c<
-    boost::is_floating_point<Source>::value && !boost::is_floating_point<Target>::value, bool
+typename std::enable_if<
+    std::is_floating_point<Source>::value && !std::is_floating_point<Target>::value, bool
 >::type noexcept_numeric_convert(Source arg, Target& result) noexcept {
     if (detail::is_out_of_range_for<Target>(arg)) {
         return false;
@@ -101,7 +97,7 @@ typename boost::enable_if_c<
 
     const Target target_tmp = static_cast<Target>(arg);
     const Source arg_restored = static_cast<Source>(target_tmp);
-    if (detail::ios_numeric_comparer_float<Source, Target>(arg, arg_restored)) {
+    if (arg == arg_restored /* special values are handled in detail::is_out_of_range_for */) {
         result = target_tmp;
         return true;
     }
@@ -124,10 +120,10 @@ struct lexical_cast_dynamic_num_ignoring_minus
     __attribute__((no_sanitize("unsigned-integer-overflow")))
 #endif
     static inline bool try_convert(Source arg, Target& result) noexcept {
-        typedef typename boost::conditional<
-                boost::is_float<Source>::value,
-                boost::type_identity<Source>,
-                boost::make_unsigned<Source>
+        typedef typename std::conditional<
+                std::is_floating_point<Source>::value,
+                std::conditional<true, Source, Source>,  // std::type_identity emulation
+                boost::detail::lcast::make_unsigned<Source>
         >::type usource_lazy_t;
         typedef typename usource_lazy_t::type usource_t;
 
@@ -165,11 +161,11 @@ template <typename Target, typename Source>
 struct dynamic_num_converter_impl
 {
     static inline bool try_convert(Source arg, Target& result) noexcept {
-        typedef typename boost::conditional<
-            boost::is_unsigned<Target>::value &&
-            (boost::is_signed<Source>::value || boost::is_float<Source>::value) &&
-            !(boost::is_same<Source, bool>::value) &&
-            !(boost::is_same<Target, bool>::value),
+        typedef typename std::conditional<
+            boost::detail::lcast::is_unsigned<Target>::value &&
+            (boost::detail::lcast::is_signed<Source>::value || std::is_floating_point<Source>::value) &&
+            !(std::is_same<Source, bool>::value) &&
+            !(std::is_same<Target, bool>::value),
             lexical_cast_dynamic_num_ignoring_minus,
             lexical_cast_dynamic_num_not_ignoring_minus
         >::type caster_type;

data/src/cxx_supportlib/vendor-modified/boost/lexical_cast/detail/inf_nan.hpp

@@ -1,6 +1,6 @@
 // Copyright Kevlin Henney, 2000-2005.
 // Copyright Alexander Nasonov, 2006-2010.
-// Copyright Antony Polukhin, 2011-2024.
+// Copyright Antony Polukhin, 2011-2025.
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at

data/src/cxx_supportlib/vendor-modified/boost/lexical_cast/detail/is_character.hpp

@@ -1,6 +1,6 @@
 // Copyright Kevlin Henney, 2000-2005.
 // Copyright Alexander Nasonov, 2006-2010.
-// Copyright Antony Polukhin, 2011-2024.
+// Copyright Antony Polukhin, 2011-2025.
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@@ -18,32 +18,31 @@
 #ifndef BOOST_LEXICAL_CAST_DETAIL_IS_CHARACTER_HPP
 #define BOOST_LEXICAL_CAST_DETAIL_IS_CHARACTER_HPP
 
+#include <type_traits>
+
 #include <boost/config.hpp>
 #ifdef BOOST_HAS_PRAGMA_ONCE
 #   pragma once
 #endif
 
-#include <boost/type_traits/integral_constant.hpp>
-#include <boost/type_traits/is_same.hpp>
-
 namespace boost { namespace detail {
 
 // returns true, if T is one of the character types
 template < typename T >
-using is_character = boost::integral_constant<
+using is_character = std::integral_constant<
     bool,
-    boost::is_same< T, char >::value ||
+    std::is_same< T, char >::value ||
 #if !defined(BOOST_NO_STRINGSTREAM) && !defined(BOOST_NO_STD_WSTRING)
-    boost::is_same< T, wchar_t >::value ||
+    std::is_same< T, wchar_t >::value ||
 #endif
 #ifndef BOOST_NO_CXX11_CHAR16_T
-    boost::is_same< T, char16_t >::value ||
+    std::is_same< T, char16_t >::value ||
 #endif
 #ifndef BOOST_NO_CXX11_CHAR32_T
-    boost::is_same< T, char32_t >::value ||
+    std::is_same< T, char32_t >::value ||
 #endif
-    boost::is_same< T, unsigned char >::value ||
-    boost::is_same< T, signed char >::value
+    std::is_same< T, unsigned char >::value ||
+    std::is_same< T, signed char >::value
 >;
 
 }}

data/src/cxx_supportlib/vendor-modified/boost/lexical_cast/detail/lcast_basic_unlockedbuf.hpp

@@ -1,6 +1,6 @@
 // Copyright Kevlin Henney, 2000-2005.
 // Copyright Alexander Nasonov, 2006-2010.
-// Copyright Antony Polukhin, 2011-2024.
+// Copyright Antony Polukhin, 2011-2025.
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at

data/src/cxx_supportlib/vendor-modified/boost/lexical_cast/detail/lcast_char_constants.hpp

@@ -1,6 +1,6 @@
 // Copyright Kevlin Henney, 2000-2005.
 // Copyright Alexander Nasonov, 2006-2010.
-// Copyright Antony Polukhin, 2011-2024.
+// Copyright Antony Polukhin, 2011-2025.
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at

data/src/cxx_supportlib/vendor-modified/boost/lexical_cast/detail/lcast_unsigned_converters.hpp

@@ -1,6 +1,6 @@
 // Copyright Kevlin Henney, 2000-2005.
 // Copyright Alexander Nasonov, 2006-2010.
-// Copyright Antony Polukhin, 2011-2024.
+// Copyright Antony Polukhin, 2011-2025.
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@@ -28,9 +28,10 @@
 #include <string>
 #include <cstring>
 #include <cstdio>
+#include <type_traits>
 #include <boost/limits.hpp>
-#include <boost/type_traits/conditional.hpp>
 #include <boost/config/workaround.hpp>
+#include <boost/lexical_cast/detail/type_traits.hpp>
 
 
 #ifndef BOOST_NO_STD_LOCALE
@@ -47,8 +48,6 @@
 #endif
 
 #include <boost/lexical_cast/detail/lcast_char_constants.hpp>
-#include <boost/type_traits/make_unsigned.hpp>
-#include <boost/type_traits/is_signed.hpp>
 #include <boost/core/noncopyable.hpp>
 
 namespace boost
@@ -60,8 +59,8 @@ namespace boost
        __attribute__((no_sanitize("unsigned-integer-overflow")))
 #endif
         inline
-        typename boost::make_unsigned<T>::type lcast_to_unsigned(const T value) noexcept {
-            typedef typename boost::make_unsigned<T>::type result_type;
+        typename boost::detail::lcast::make_unsigned<T>::type lcast_to_unsigned(const T value) noexcept {
+            typedef typename boost::detail::lcast::make_unsigned<T>::type result_type;
             return value < 0
                 ? static_cast<result_type>(0u - static_cast<result_type>(value))
                 : static_cast<result_type>(value);
@@ -73,7 +72,7 @@ namespace boost
         template <class Traits, class T, class CharT>
         class lcast_put_unsigned: boost::noncopyable {
             typedef typename Traits::int_type int_type;
-            typename boost::conditional<
+            typename std::conditional<
                     (sizeof(unsigned) > sizeof(T))
                     , unsigned
                     , T

data/src/cxx_supportlib/vendor-modified/boost/lexical_cast/detail/type_traits.hpp

@@ -0,0 +1,81 @@
+// Copyright Peter Dimov, 2025.
+// Copyright Romain Geissler, 2025.
+//
+// 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_LEXICAL_CAST_DETAIL_TYPE_TRAITS_HPP
+#define BOOST_LEXICAL_CAST_DETAIL_TYPE_TRAITS_HPP
+
+#include <boost/config.hpp>
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#   pragma once
+#endif
+
+#include <type_traits>
+
+namespace boost { namespace detail { namespace lcast {
+
+// libstdc++ from gcc <= 15 doesn't provide support for __int128 in the standard traits,
+// so define them explicitly.
+// This was fixed with gcc >= 16, so we may eventually remove this workaround and use
+// directly the standard type_traits.
+
+template<class T> struct is_integral: public std::is_integral<T>
+{
+};
+
+template<class T> struct is_signed: public std::is_signed<T>
+{
+};
+
+template<class T> struct is_unsigned: public std::is_unsigned<T>
+{
+};
+
+template<class T> struct make_unsigned: public std::make_unsigned<T>
+{
+};
+
+#if defined(__SIZEOF_INT128__)
+
+template<> struct is_integral<__int128_t>: public std::true_type
+{
+};
+
+template<> struct is_integral<__uint128_t>: public std::true_type
+{
+};
+
+template<> struct is_signed<__int128_t>: public std::true_type
+{
+};
+
+template<> struct is_signed<__uint128_t>: public std::false_type
+{
+};
+
+template<> struct is_unsigned<__int128_t>: public std::false_type
+{
+};
+
+template<> struct is_unsigned<__uint128_t>: public std::true_type
+{
+};
+
+template<> struct make_unsigned<__int128_t>
+{
+    typedef __uint128_t type;
+};
+
+template<> struct make_unsigned<__uint128_t>
+{
+    typedef __uint128_t type;
+};
+
+#endif
+
+}}}  // namespace boost::detail::lcast
+
+#endif // BOOST_LEXICAL_CAST_DETAIL_TYPE_TRAITS_HPP

data/src/cxx_supportlib/vendor-modified/boost/lexical_cast/detail/widest_char.hpp

@@ -1,6 +1,6 @@
 // Copyright Kevlin Henney, 2000-2005.
 // Copyright Alexander Nasonov, 2006-2010.
-// Copyright Antony Polukhin, 2011-2024.
+// Copyright Antony Polukhin, 2011-2025.
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@@ -18,18 +18,18 @@
 #ifndef BOOST_LEXICAL_CAST_DETAIL_WIDEST_CHAR_HPP
 #define BOOST_LEXICAL_CAST_DETAIL_WIDEST_CHAR_HPP
 
+#include <type_traits>
+
 #include <boost/config.hpp>
 #ifdef BOOST_HAS_PRAGMA_ONCE
 #   pragma once
 #endif
 
 
-#include <boost/type_traits/conditional.hpp>
-
 namespace boost { namespace detail {
 
 template <typename TargetChar, typename SourceChar>
-using widest_char = boost::conditional<
+using widest_char = std::conditional<
     (sizeof(TargetChar) > sizeof(SourceChar))
     , TargetChar
     , SourceChar