passenger 6.0.23 → 6.0.24

data/src/cxx_supportlib/vendor-modified/boost/function/function_template.hpp

@@ -15,11 +15,10 @@
 #include <boost/core/no_exceptions_support.hpp>
 #include <boost/mem_fn.hpp>
 #include <boost/throw_exception.hpp>
-#include <boost/type_traits/is_integral.hpp>
-#include <boost/type_traits/is_void.hpp>
 #include <boost/config.hpp>
 #include <algorithm>
 #include <cassert>
+#include <type_traits>
 
 #if defined(BOOST_MSVC)
 #   pragma warning( push )
@@ -180,7 +179,7 @@ namespace boost {
       >
       struct get_function_invoker
       {
-        typedef typename conditional<(is_void<R>::value),
+        typedef typename std::conditional<std::is_void<R>::value,
                             void_function_invoker<
                             FunctionPtr,
                             R,
@@ -201,7 +200,7 @@ namespace boost {
        >
       struct get_function_obj_invoker
       {
-        typedef typename conditional<(is_void<R>::value),
+        typedef typename std::conditional<std::is_void<R>::value,
                             void_function_obj_invoker<
                             FunctionObj,
                             R,
@@ -222,7 +221,7 @@ namespace boost {
        >
       struct get_function_ref_invoker
       {
-        typedef typename conditional<(is_void<R>::value),
+        typedef typename std::conditional<std::is_void<R>::value,
                             void_function_ref_invoker<
                             FunctionObj,
                             R,
@@ -244,7 +243,7 @@ namespace boost {
        >
       struct get_member_invoker
       {
-        typedef typename conditional<(is_void<R>::value),
+        typedef typename std::conditional<std::is_void<R>::value,
                             void_member_invoker<
                             MemberPtr,
                             R,
@@ -499,27 +498,27 @@ namespace boost {
         // Assign to a function object using the small object optimization
         template<typename FunctionObj>
         void
-        assign_functor(FunctionObj f, function_buffer& functor, true_type) const
+        assign_functor(FunctionObj f, function_buffer& functor, std::true_type) const
         {
           new (reinterpret_cast<void*>(functor.data)) FunctionObj(std::move(f));
         }
         template<typename FunctionObj,typename Allocator>
         void
-        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, true_type) const
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, std::true_type) const
         {
-          assign_functor(std::move(f),functor,true_type());
+          assign_functor(std::move(f),functor,std::true_type());
         }
 
         // Assign to a function object allocated on the heap.
         template<typename FunctionObj>
         void
-        assign_functor(FunctionObj f, function_buffer& functor, false_type) const
+        assign_functor(FunctionObj f, function_buffer& functor, std::false_type) const
         {
           functor.members.obj_ptr = new FunctionObj(std::move(f));
         }
         template<typename FunctionObj,typename Allocator>
         void
-        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, false_type) const
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, std::false_type) const
         {
           typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;
 
@@ -540,7 +539,7 @@ namespace boost {
         {
           if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
             assign_functor(std::move(f), functor,
-                           integral_constant<bool, (function_allows_small_object_optimization<FunctionObj>::value)>());
+                           std::integral_constant<bool, (function_allows_small_object_optimization<FunctionObj>::value)>());
             return true;
           } else {
             return false;
@@ -552,7 +551,7 @@ namespace boost {
         {
           if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
             assign_functor_a(std::move(f), functor, a,
-                           integral_constant<bool, (function_allows_small_object_optimization<FunctionObj>::value)>());
+                           std::integral_constant<bool, (function_allows_small_object_optimization<FunctionObj>::value)>());
             return true;
           } else {
             return false;
@@ -566,8 +565,8 @@ namespace boost {
                   function_buffer& functor, function_obj_ref_tag) const
         {
           functor.members.obj_ref.obj_ptr = (void *)(f.get_pointer());
-          functor.members.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
-          functor.members.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
+          functor.members.obj_ref.is_const_qualified = std::is_const<FunctionObj>::value;
+          functor.members.obj_ref.is_volatile_qualified = std::is_volatile<FunctionObj>::value;
           return true;
         }
         template<typename FunctionObj,typename Allocator>
@@ -587,19 +586,125 @@ namespace boost {
       struct variadic_function_base
       {};
 
-      template <typename T>
-      struct variadic_function_base<T>
+      template <typename T1>
+      struct variadic_function_base<T1>
       {
-        typedef T argument_type;
+        typedef T1 argument_type;
+        typedef T1 arg1_type;
       };
 
-      template <typename T0, typename T1>
-      struct variadic_function_base<T0, T1>
+      template <typename T1, typename T2>
+      struct variadic_function_base<T1, T2>
       {
-        typedef T0 first_argument_type;
-        typedef T1 second_argument_type;
+        typedef T1 first_argument_type;
+        typedef T2 second_argument_type;
+        typedef T1 arg1_type;
+        typedef T2 arg2_type;
       };
 
+      template <typename T1, typename T2, typename T3>
+      struct variadic_function_base<T1, T2, T3>
+      {
+        typedef T1 arg1_type;
+        typedef T2 arg2_type;
+        typedef T3 arg3_type;
+      };
+
+      template <typename T1, typename T2, typename T3, typename T4>
+      struct variadic_function_base<T1, T2, T3, T4>
+      {
+        typedef T1 arg1_type;
+        typedef T2 arg2_type;
+        typedef T3 arg3_type;
+        typedef T4 arg4_type;
+      };
+
+      template <typename T1, typename T2, typename T3, typename T4, typename T5>
+      struct variadic_function_base<T1, T2, T3, T4, T5>
+      {
+        typedef T1 arg1_type;
+        typedef T2 arg2_type;
+        typedef T3 arg3_type;
+        typedef T4 arg4_type;
+        typedef T5 arg5_type;
+      };
+
+      template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
+      struct variadic_function_base<T1, T2, T3, T4, T5, T6>
+      {
+        typedef T1 arg1_type;
+        typedef T2 arg2_type;
+        typedef T3 arg3_type;
+        typedef T4 arg4_type;
+        typedef T5 arg5_type;
+        typedef T6 arg6_type;
+      };
+
+      template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
+      struct variadic_function_base<T1, T2, T3, T4, T5, T6, T7>
+      {
+        typedef T1 arg1_type;
+        typedef T2 arg2_type;
+        typedef T3 arg3_type;
+        typedef T4 arg4_type;
+        typedef T5 arg5_type;
+        typedef T6 arg6_type;
+        typedef T7 arg7_type;
+      };
+
+      template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
+      struct variadic_function_base<T1, T2, T3, T4, T5, T6, T7, T8>
+      {
+        typedef T1 arg1_type;
+        typedef T2 arg2_type;
+        typedef T3 arg3_type;
+        typedef T4 arg4_type;
+        typedef T5 arg5_type;
+        typedef T6 arg6_type;
+        typedef T7 arg7_type;
+        typedef T8 arg8_type;
+      };
+
+      template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
+      struct variadic_function_base<T1, T2, T3, T4, T5, T6, T7, T8, T9>
+      {
+        typedef T1 arg1_type;
+        typedef T2 arg2_type;
+        typedef T3 arg3_type;
+        typedef T4 arg4_type;
+        typedef T5 arg5_type;
+        typedef T6 arg6_type;
+        typedef T7 arg7_type;
+        typedef T8 arg8_type;
+        typedef T9 arg9_type;
+      };
+
+      template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10>
+      struct variadic_function_base<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
+      {
+        typedef T1 arg1_type;
+        typedef T2 arg2_type;
+        typedef T3 arg3_type;
+        typedef T4 arg4_type;
+        typedef T5 arg5_type;
+        typedef T6 arg6_type;
+        typedef T7 arg7_type;
+        typedef T8 arg8_type;
+        typedef T9 arg9_type;
+        typedef T10 arg10_type;
+      };
+
+#if defined( BOOST_LIBSTDCXX_VERSION ) && BOOST_LIBSTDCXX_VERSION < 50000
+
+      template<class T> struct is_trivially_copyable: std::integral_constant<bool,
+        __has_trivial_copy(T) && __has_trivial_assign(T) && __has_trivial_destructor(T)> {};
+
+#else
+
+      using std::is_trivially_copyable;
+
+#endif
+
     } // end namespace function
   } // end namespace detail
 
@@ -643,8 +748,8 @@ namespace boost {
     // one with a default parameter.
     template<typename Functor>
     function_n(Functor f
-                            ,typename boost::enable_if_<
-                             !(is_integral<Functor>::value),
+                            ,typename std::enable_if<
+                             !std::is_integral<Functor>::value,
                                         int>::type = 0
                             ) :
       function_base()
@@ -653,8 +758,8 @@ namespace boost {
     }
     template<typename Functor,typename Allocator>
     function_n(Functor f, Allocator a
-                            ,typename boost::enable_if_<
-                              !(is_integral<Functor>::value),
+                            ,typename std::enable_if<
+                              !std::is_integral<Functor>::value,
                                         int>::type = 0
                             ) :
       function_base()
@@ -691,8 +796,8 @@ namespace boost {
     // handle function_n as the type of the temporary to
     // construct.
     template<typename Functor>
-    typename boost::enable_if_<
-                  !(is_integral<Functor>::value),
+    typename std::enable_if<
+                  !std::is_integral<Functor>::value,
                function_n&>::type
     operator=(Functor f)
     {
@@ -835,8 +940,7 @@ namespace boost {
       if (stored_vtable.assign_to(std::move(f), functor)) {
         std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
         // coverity[pointless_expression]: suppress coverity warnings on apparant if(const).
-        if (boost::has_trivial_copy_constructor<Functor>::value &&
-            boost::has_trivial_destructor<Functor>::value &&
+        if (boost::detail::function::is_trivially_copyable<Functor>::value &&
             boost::detail::function::function_allows_small_object_optimization<Functor>::value)
           value |= static_cast<std::size_t>(0x01);
         vtable = reinterpret_cast<boost::detail::function::vtable_base *>(value);
@@ -869,8 +973,7 @@ namespace boost {
       if (stored_vtable.assign_to_a(std::move(f), functor, a)) {
         std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
         // coverity[pointless_expression]: suppress coverity warnings on apparant if(const).
-        if (boost::has_trivial_copy_constructor<Functor>::value &&
-            boost::has_trivial_destructor<Functor>::value &&
+        if (boost::detail::function::is_trivially_copyable<Functor>::value &&
             boost::detail::function::function_allows_small_object_optimization<Functor>::value)
           value |= static_cast<std::size_t>(0x01);
         vtable = reinterpret_cast<boost::detail::function::vtable_base *>(value);
@@ -974,8 +1077,8 @@ public:
 
   template<typename Functor>
   function(Functor f
-           ,typename boost::enable_if_<
-                          !(is_integral<Functor>::value),
+           ,typename std::enable_if<
+                          !std::is_integral<Functor>::value,
                        int>::type = 0
            ) :
     base_type(std::move(f))
@@ -983,8 +1086,8 @@ public:
   }
   template<typename Functor,typename Allocator>
   function(Functor f, Allocator a
-           ,typename boost::enable_if_<
-                           !(is_integral<Functor>::value),
+           ,typename std::enable_if<
+                           !std::is_integral<Functor>::value,
                        int>::type = 0
            ) :
     base_type(std::move(f),a)
@@ -1014,8 +1117,8 @@ public:
   }
 
   template<typename Functor>
-  typename boost::enable_if_<
-                         !(is_integral<Functor>::value),
+  typename std::enable_if<
+                         !std::is_integral<Functor>::value,
                       self_type&>::type
   operator=(Functor f)
   {

data/src/cxx_supportlib/vendor-modified/boost/intrusive/detail/algorithm.hpp

@@ -26,15 +26,15 @@ namespace intrusive {
 
 struct algo_pred_equal
 {
-   template<class T>
-   bool operator()(const T &x, const T &y) const
+   template<class T, class T2>
+   bool operator()(const T &x, const T2 &y) const
    {  return x == y;  }
 };
 
 struct algo_pred_less
 {
-   template<class T>
-   bool operator()(const T &x, const T &y) const
+   template<class T, class T2>
+   bool operator()(const T &x, const T2 &y) const
    {  return x < y;  }
 };
 
@@ -49,10 +49,6 @@ bool algo_equal(InputIt1 first1, InputIt1 last1, InputIt2 first2, BinaryPredicat
     return true;
 }
 
-template<class InputIt1, class InputIt2>
-bool algo_equal(InputIt1 first1, InputIt1 last1, InputIt2 first2)
-{  return (algo_equal)(first1, last1, first2, algo_pred_equal());  }
-
 template<class InputIt1, class InputIt2, class BinaryPredicate>
 bool algo_equal(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, BinaryPredicate pred)
 {
@@ -62,6 +58,10 @@ bool algo_equal(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2
     return first1 == last1 && first2 == last2;
 }
 
+template<class InputIt1, class InputIt2>
+bool algo_equal(InputIt1 first1, InputIt1 last1, InputIt2 first2)
+{  return (algo_equal)(first1, last1, first2, algo_pred_equal());  }
+
 template<class InputIt1, class InputIt2>
 bool algo_equal(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2)
 {  return (algo_equal)(first1, last1, first2, last2, algo_pred_equal());  }

data/src/cxx_supportlib/vendor-modified/boost/intrusive/detail/hash.hpp

@@ -2,7 +2,7 @@
 //
 // Copyright 2005-2014 Daniel James.
 // Copyright 2021, 2022 Peter Dimov.
-// Copyright 2024 Ion Gazta�aga.
+// Copyright 2024 Ion Gaztanaga.
 // Distributed under the Boost Software License, Version 1.0.
 // https://www.boost.org/LICENSE_1_0.txt
 //

data/src/cxx_supportlib/vendor-modified/boost/intrusive/detail/hook_traits.hpp

@@ -46,6 +46,10 @@ struct bhtraits_base
       template rebind_pointer<T>::type                               pointer;
    typedef typename pointer_traits<node_ptr>::
       template rebind_pointer<const T>::type                         const_pointer;
+   typedef typename pointer_traits<node_ptr>::
+      template rebind_pointer<node_holder_type>::type                node_holder_ptr;
+   typedef typename pointer_traits<node_ptr>::
+      template rebind_pointer<const node_holder_type>::type          const_node_holder_ptr;
    typedef T &                                                       reference;
    typedef const T &                                                 const_reference;
    typedef node_holder_type &                                        node_holder_reference;
@@ -55,16 +59,14 @@ struct bhtraits_base
 
    inline static pointer to_value_ptr(node_ptr n)
    {
-      pointer p = pointer_traits<pointer>::pointer_to
-         (static_cast<reference>(static_cast<node_holder_reference>(*n)));
-      return p;
+      return pointer_traits<pointer>::
+         static_cast_from(pointer_traits<node_holder_ptr>::static_cast_from(n));
    }
 
    inline static const_pointer to_value_ptr(const_node_ptr n)
    {
-      const_pointer p = pointer_traits<const_pointer>::pointer_to
-         (static_cast<const_reference>(static_cast<const_node_holder_reference>(*n)));
-      return p;
+      return pointer_traits<const_pointer>::
+         static_cast_from(pointer_traits<const_node_holder_ptr>::static_cast_from(n));
    }
 
    inline static node_ptr to_node_ptr(reference value)

data/src/cxx_supportlib/vendor-modified/boost/intrusive/pointer_traits.hpp

@@ -130,7 +130,7 @@ struct pointer_traits
    //!
    //! <b>Note</b>: For non-conforming compilers only the existence of a member function called
    //!   <code>pointer_to</code> is checked.
-   inline static pointer pointer_to(reference r) BOOST_NOEXCEPT
+   BOOST_INTRUSIVE_FORCEINLINE static pointer pointer_to(reference r) BOOST_NOEXCEPT
    {
       //Non-standard extension, it does not require Ptr::pointer_to. If not present
       //tries to converts &r to pointer.
@@ -150,7 +150,7 @@ struct pointer_traits
    //! <b>Note</b>: For non-conforming compilers only the existence of a member function called
    //!   <code>static_cast_from</code> is checked.
    template<class UPtr>
-   inline static pointer static_cast_from(const UPtr &uptr) BOOST_NOEXCEPT
+   BOOST_INTRUSIVE_FORCEINLINE static pointer static_cast_from(const UPtr &uptr) BOOST_NOEXCEPT
    {
       typedef const UPtr &RefArg;
       const bool value = boost::intrusive::detail::
@@ -171,7 +171,7 @@ struct pointer_traits
    //! <b>Note</b>: For non-conforming compilers only the existence of a member function called
    //!   <code>const_cast_from</code> is checked.
    template<class UPtr>
-   inline static pointer const_cast_from(const UPtr &uptr) BOOST_NOEXCEPT
+   BOOST_INTRUSIVE_FORCEINLINE static pointer const_cast_from(const UPtr &uptr) BOOST_NOEXCEPT
    {
       typedef const UPtr &RefArg;
       const bool value = boost::intrusive::detail::
@@ -192,7 +192,7 @@ struct pointer_traits
    //! <b>Note</b>: For non-conforming compilers only the existence of a member function called
    //!   <code>dynamic_cast_from</code> is checked.
    template<class UPtr>
-   inline static pointer dynamic_cast_from(const UPtr &uptr) BOOST_NOEXCEPT
+   BOOST_INTRUSIVE_FORCEINLINE static pointer dynamic_cast_from(const UPtr &uptr) BOOST_NOEXCEPT
    {
       typedef const UPtr &RefArg;
       const bool value = boost::intrusive::detail::
@@ -208,46 +208,46 @@ struct pointer_traits
    private:
    //priv_to_raw_pointer
    template <class T>
-   inline static T* to_raw_pointer(T* p) BOOST_NOEXCEPT
+   BOOST_INTRUSIVE_FORCEINLINE static T* to_raw_pointer(T* p) BOOST_NOEXCEPT
    {  return p; }
 
    template <class Pointer>
-   inline static typename pointer_traits<Pointer>::element_type*
+   BOOST_INTRUSIVE_FORCEINLINE static typename pointer_traits<Pointer>::element_type*
       to_raw_pointer(const Pointer &p) BOOST_NOEXCEPT
    {  return pointer_traits::to_raw_pointer(p.operator->());  }
 
    //priv_pointer_to
-   inline static pointer priv_pointer_to(boost::intrusive::detail::true_, reference r) BOOST_NOEXCEPT
+   BOOST_INTRUSIVE_FORCEINLINE static pointer priv_pointer_to(boost::intrusive::detail::true_, reference r) BOOST_NOEXCEPT
    { return Ptr::pointer_to(r); }
 
-   inline static pointer priv_pointer_to(boost::intrusive::detail::false_, reference r) BOOST_NOEXCEPT
+   BOOST_INTRUSIVE_FORCEINLINE static pointer priv_pointer_to(boost::intrusive::detail::false_, reference r) BOOST_NOEXCEPT
    { return pointer(boost::intrusive::detail::addressof(r)); }
 
    //priv_static_cast_from
    template<class UPtr>
-   inline static pointer priv_static_cast_from(boost::intrusive::detail::true_, const UPtr &uptr) BOOST_NOEXCEPT
+   BOOST_INTRUSIVE_FORCEINLINE static pointer priv_static_cast_from(boost::intrusive::detail::true_, const UPtr &uptr) BOOST_NOEXCEPT
    { return Ptr::static_cast_from(uptr); }
 
    template<class UPtr>
-   inline static pointer priv_static_cast_from(boost::intrusive::detail::false_, const UPtr &uptr) BOOST_NOEXCEPT
+   BOOST_INTRUSIVE_FORCEINLINE static pointer priv_static_cast_from(boost::intrusive::detail::false_, const UPtr &uptr) BOOST_NOEXCEPT
    {  return uptr ? pointer_to(*static_cast<element_type*>(to_raw_pointer(uptr))) : pointer();  }
 
    //priv_const_cast_from
    template<class UPtr>
-   inline static pointer priv_const_cast_from(boost::intrusive::detail::true_, const UPtr &uptr) BOOST_NOEXCEPT
+   BOOST_INTRUSIVE_FORCEINLINE static pointer priv_const_cast_from(boost::intrusive::detail::true_, const UPtr &uptr) BOOST_NOEXCEPT
    { return Ptr::const_cast_from(uptr); }
 
    template<class UPtr>
-   inline static pointer priv_const_cast_from(boost::intrusive::detail::false_, const UPtr &uptr) BOOST_NOEXCEPT
+   BOOST_INTRUSIVE_FORCEINLINE static pointer priv_const_cast_from(boost::intrusive::detail::false_, const UPtr &uptr) BOOST_NOEXCEPT
    {  return uptr ? pointer_to(const_cast<element_type&>(*uptr)) : pointer();  }
 
    //priv_dynamic_cast_from
    template<class UPtr>
-   inline static pointer priv_dynamic_cast_from(boost::intrusive::detail::true_, const UPtr &uptr) BOOST_NOEXCEPT
+   BOOST_INTRUSIVE_FORCEINLINE static pointer priv_dynamic_cast_from(boost::intrusive::detail::true_, const UPtr &uptr) BOOST_NOEXCEPT
    { return Ptr::dynamic_cast_from(uptr); }
 
    template<class UPtr>
-   inline static pointer priv_dynamic_cast_from(boost::intrusive::detail::false_, const UPtr &uptr) BOOST_NOEXCEPT
+   BOOST_INTRUSIVE_FORCEINLINE static pointer priv_dynamic_cast_from(boost::intrusive::detail::false_, const UPtr &uptr) BOOST_NOEXCEPT
    {  return uptr ? pointer_to(dynamic_cast<element_type&>(*uptr)) : pointer();  }
    ///@endcond
 };
@@ -296,25 +296,25 @@ struct pointer_traits<T*>
 
    //! <b>Returns</b>: addressof(r)
    //!
-   inline static pointer pointer_to(reference r) BOOST_NOEXCEPT
+   BOOST_INTRUSIVE_FORCEINLINE static pointer pointer_to(reference r) BOOST_NOEXCEPT
    { return boost::intrusive::detail::addressof(r); }
 
    //! <b>Returns</b>: static_cast<pointer>(uptr)
    //!
    template<class U>
-   inline static pointer static_cast_from(U *uptr) BOOST_NOEXCEPT
+   BOOST_INTRUSIVE_FORCEINLINE static pointer static_cast_from(U *uptr) BOOST_NOEXCEPT
    {  return static_cast<pointer>(uptr);  }
 
    //! <b>Returns</b>: const_cast<pointer>(uptr)
    //!
    template<class U>
-   inline static pointer const_cast_from(U *uptr) BOOST_NOEXCEPT
+   BOOST_INTRUSIVE_FORCEINLINE static pointer const_cast_from(U *uptr) BOOST_NOEXCEPT
    {  return const_cast<pointer>(uptr);  }
 
    //! <b>Returns</b>: dynamic_cast<pointer>(uptr)
    //!
    template<class U>
-   inline static pointer dynamic_cast_from(U *uptr) BOOST_NOEXCEPT
+   BOOST_INTRUSIVE_FORCEINLINE static pointer dynamic_cast_from(U *uptr) BOOST_NOEXCEPT
    {  return dynamic_cast<pointer>(uptr);  }
 };
 

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

@@ -198,7 +198,6 @@ namespace boost { namespace detail { namespace lcast {
         }
 
         bool shl_real_type(float val, char* begin) {
-            using namespace std;
             const double val_as_double = val;
             finish = start +
                 boost::core::snprintf(begin, CharacterBufferSize,
@@ -207,7 +206,6 @@ namespace boost { namespace detail { namespace lcast {
         }
 
         bool shl_real_type(double val, char* begin) {
-            using namespace std;
             finish = start +
                 boost::core::snprintf(begin, CharacterBufferSize,
                 "%.*g", static_cast<int>(boost::detail::lcast_get_precision<double>()), val);
@@ -216,7 +214,6 @@ namespace boost { namespace detail { namespace lcast {
 
 #ifndef __MINGW32__
         bool shl_real_type(long double val, char* begin) {
-            using namespace std;
             finish = start +
                 boost::core::snprintf(begin, CharacterBufferSize,
                 "%.*Lg", static_cast<int>(boost::detail::lcast_get_precision<long double>()), val );
@@ -228,28 +225,32 @@ namespace boost { namespace detail { namespace lcast {
         }
 #endif
 
-#if !defined(BOOST_LCAST_NO_WCHAR_T) && !defined(BOOST_NO_SWPRINTF) && !defined(__MINGW32__)
+#if !defined(BOOST_LCAST_NO_WCHAR_T)
         bool shl_real_type(float val, wchar_t* begin) {
-            using namespace std;
             const double val_as_double = val;
-            finish = start + swprintf(begin, CharacterBufferSize,
-                                   L"%.*g",
-                                   static_cast<int>(boost::detail::lcast_get_precision<float >()),
-                                   val_as_double );
+            finish = start + boost::core::swprintf(
+                begin, CharacterBufferSize, L"%.*g",
+                static_cast<int>(boost::detail::lcast_get_precision<float >()),
+                val_as_double
+            );
             return finish > start;
         }
 
         bool shl_real_type(double val, wchar_t* begin) {
-            using namespace std;
-            finish = start + swprintf(begin, CharacterBufferSize,
-                                      L"%.*g", static_cast<int>(boost::detail::lcast_get_precision<double >()), val );
+            finish = start + boost::core::swprintf(
+              begin, CharacterBufferSize, L"%.*g",
+              static_cast<int>(boost::detail::lcast_get_precision<double>()),
+              val
+            );
             return finish > start;
         }
 
         bool shl_real_type(long double val, wchar_t* begin) {
-            using namespace std;
-            finish = start + swprintf(begin, CharacterBufferSize,
-                                      L"%.*Lg", static_cast<int>(boost::detail::lcast_get_precision<long double >()), val );
+            finish = start + boost::core::swprintf(
+                begin, CharacterBufferSize, L"%.*Lg",
+                static_cast<int>(boost::detail::lcast_get_precision<long double>()),
+                val
+            );
             return finish > start;
         }
 #endif
@@ -345,13 +346,17 @@ namespace boost { namespace detail { namespace lcast {
         template <class C, class CharTraits>
         enable_if_compatible_char_t<C>
         stream_in(lcast::exact<std::basic_string_view<C, CharTraits>> x) noexcept {
-            return shl_char_array_limited(reinterpret_cast<const CharT*>(x.payload.data()), x.payload.size());
+            start = reinterpret_cast<const CharT*>(x.payload.data());
+            finish = start + x.payload.size();
+            return true;
         }
 #endif
         template <class C, class CharTraits>
         enable_if_compatible_char_t<C>
         stream_in(lcast::exact<boost::basic_string_view<C, CharTraits>> x) noexcept {
-            return shl_char_array_limited(reinterpret_cast<const CharT*>(x.payload.data()), x.payload.size());
+            start = reinterpret_cast<const CharT*>(x.payload.data());
+            finish = start + x.payload.size();
+            return true;
         }
     };
 

data/src/cxx_supportlib/vendor-modified/boost/libs/random/src/random_device.cpp

@@ -10,7 +10,9 @@
  *
  */
 
-#define BOOST_RANDOM_SOURCE
+#ifndef BOOST_RANDOM_SOURCE
+#  define BOOST_RANDOM_SOURCE
+#endif
 
 #include <boost/random/random_device.hpp>
 #include <boost/config.hpp>

data/src/cxx_supportlib/vendor-modified/boost/move/detail/config_begin.hpp

@@ -16,7 +16,6 @@
 #  pragma warning (disable : 4619) // there is no warning number 'XXXX'
 #  pragma warning (disable : 4324) // structure was padded due to __declspec(align())
 #  pragma warning (disable : 4675) // "function":  resolved overload was found by argument-dependent lookup
-#  pragma warning (disable : 4996) // "function": was declared deprecated (_CRT_SECURE_NO_DEPRECATE/_SCL_SECURE_NO_WARNINGS)
 #  pragma warning (disable : 4714) // "function": marked as __forceinline not inlined
 #  pragma warning (disable : 4127) // conditional expression is constant
 #endif