passenger 6.1.0 → 6.1.1

data/src/cxx_supportlib/vendor-modified/boost/lexical_cast/try_lexical_convert.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,14 +18,13 @@
 #ifndef BOOST_LEXICAL_CAST_TRY_LEXICAL_CONVERT_HPP
 #define BOOST_LEXICAL_CAST_TRY_LEXICAL_CONVERT_HPP
 
+#include <type_traits>
+
 #include <boost/config.hpp>
 #ifdef BOOST_HAS_PRAGMA_ONCE
 #   pragma once
 #endif
 
-#include <boost/type_traits/conditional.hpp>
-#include <boost/type_traits/is_arithmetic.hpp>
-
 #include <boost/lexical_cast/detail/buffer_view.hpp>
 #include <boost/lexical_cast/detail/is_character.hpp>
 #include <boost/lexical_cast/detail/converter_numeric.hpp>
@@ -35,12 +34,12 @@ namespace boost {
     namespace detail
     {
         template<typename Target, typename Source>
-        using is_arithmetic_and_not_xchars = boost::integral_constant<
+        using is_arithmetic_and_not_xchars = std::integral_constant<
             bool,
             !(boost::detail::is_character<Target>::value) &&
                 !(boost::detail::is_character<Source>::value) &&
-                boost::is_arithmetic<Source>::value &&
-                boost::is_arithmetic<Target>::value
+                std::is_arithmetic<Source>::value &&
+                std::is_arithmetic<Target>::value
         >;
     }
 
@@ -50,7 +49,7 @@ namespace boost {
         inline bool try_lexical_convert(const Source& arg, Target& result)
         {
             static_assert(
-                !boost::is_volatile<Source>::value,
+                !std::is_volatile<Source>::value,
                 "Boost.LexicalCast does not support volatile input");
 
             typedef typename boost::detail::array_to_pointer_decay<Source>::type src;
@@ -58,7 +57,7 @@ namespace boost {
             typedef boost::detail::is_arithmetic_and_not_xchars<Target, src >
                 shall_we_copy_with_dynamic_check_t;
 
-            typedef typename boost::conditional<
+            typedef typename std::conditional<
                  shall_we_copy_with_dynamic_check_t::value,
                  boost::detail::dynamic_num_converter_impl<Target, src >,
                  boost::detail::lexical_converter_impl<Target, src >

data/src/cxx_supportlib/vendor-modified/boost/lexical_cast.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/libs/regex/src/wide_posix_api.cpp

@@ -16,6 +16,7 @@
   *   DESCRIPTION: Implements the wide character POSIX API wrappers.
   */
 
+#define _CRT_SECURE_NO_WARNINGS // for std::wcscpy
 #define BOOST_REGEX_SOURCE
 
 #include <boost/regex/config.hpp>
@@ -169,11 +170,7 @@ BOOST_REGEX_DECL regsize_t BOOST_REGEX_CCALL regerrorW(int code, const regex_tW*
       {
          result = std::wcslen(wnames[code]) + 1;
          if(buf_size >= result)
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) && !defined(_WIN32_WCE) && !defined(UNDER_CE)
-            ::wcscpy_s(buf, buf_size, wnames[code]);
-#else
             std::wcscpy(buf, wnames[code]);
-#endif
          return result;
       }
       return result;
@@ -193,11 +190,7 @@ BOOST_REGEX_DECL regsize_t BOOST_REGEX_CCALL regerrorW(int code, const regex_tW*
             (boost::core::swprintf)(localbuf, 5, L"%d", i);
 #endif
             if(std::wcslen(localbuf) < buf_size)
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) && !defined(_WIN32_WCE) && !defined(UNDER_CE)
-               ::wcscpy_s(buf, buf_size, localbuf);
-#else
                std::wcscpy(buf, localbuf);
-#endif
             return std::wcslen(localbuf) + 1;
          }
       }
@@ -207,11 +200,7 @@ BOOST_REGEX_DECL regsize_t BOOST_REGEX_CCALL regerrorW(int code, const regex_tW*
       (boost::core::swprintf)(localbuf, 5, L"%d", 0);
 #endif
       if(std::wcslen(localbuf) < buf_size)
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) && !defined(_WIN32_WCE) && !defined(UNDER_CE)
-         ::wcscpy_s(buf, buf_size, localbuf);
-#else
          std::wcscpy(buf, localbuf);
-#endif
       return std::wcslen(localbuf) + 1;
    }
    if(code <= (int)REG_E_UNKNOWN)

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

@@ -3,7 +3,7 @@
 //  Defines enum boost::memory_order per the C++0x working draft
 //
 //  Copyright (c) 2008, 2009 Peter Dimov
-//  Copyright (c) 2018 Andrey Semashev
+//  Copyright (c) 2018, 2025 Andrey Semashev
 //
 //  Distributed under the Boost Software License, Version 1.0.
 //  See accompanying file LICENSE_1_0.txt or copy at
@@ -15,7 +15,7 @@
 #include <boost/config.hpp>
 
 #if defined(BOOST_HAS_PRAGMA_ONCE)
-# pragma once
+#pragma once
 #endif
 
 namespace boost
@@ -42,8 +42,6 @@ namespace boost
 // efficiently in compare_exchange methods.
 //
 
-#if !defined(BOOST_NO_CXX11_SCOPED_ENUMS)
-
 enum class memory_order : unsigned int
 {
     relaxed = 0,
@@ -54,28 +52,12 @@ enum class memory_order : unsigned int
     seq_cst = 14 // acq_rel | 8
 };
 
-BOOST_INLINE_VARIABLE BOOST_CONSTEXPR_OR_CONST memory_order memory_order_relaxed = memory_order::relaxed;
-BOOST_INLINE_VARIABLE BOOST_CONSTEXPR_OR_CONST memory_order memory_order_consume = memory_order::consume;
-BOOST_INLINE_VARIABLE BOOST_CONSTEXPR_OR_CONST memory_order memory_order_acquire = memory_order::acquire;
-BOOST_INLINE_VARIABLE BOOST_CONSTEXPR_OR_CONST memory_order memory_order_release = memory_order::release;
-BOOST_INLINE_VARIABLE BOOST_CONSTEXPR_OR_CONST memory_order memory_order_acq_rel = memory_order::acq_rel;
-BOOST_INLINE_VARIABLE BOOST_CONSTEXPR_OR_CONST memory_order memory_order_seq_cst = memory_order::seq_cst;
-
-#undef BOOST_MEMORY_ORDER_INLINE_VARIABLE
-
-#else // !defined(BOOST_NO_CXX11_SCOPED_ENUMS)
-
-enum memory_order
-{
-    memory_order_relaxed = 0,
-    memory_order_consume = 1,
-    memory_order_acquire = 2,
-    memory_order_release = 4,
-    memory_order_acq_rel = 6, // acquire | release
-    memory_order_seq_cst = 14 // acq_rel | 8
-};
-
-#endif // !defined(BOOST_NO_CXX11_SCOPED_ENUMS)
+BOOST_INLINE_VARIABLE constexpr memory_order memory_order_relaxed = memory_order::relaxed;
+BOOST_INLINE_VARIABLE constexpr memory_order memory_order_consume = memory_order::consume;
+BOOST_INLINE_VARIABLE constexpr memory_order memory_order_acquire = memory_order::acquire;
+BOOST_INLINE_VARIABLE constexpr memory_order memory_order_release = memory_order::release;
+BOOST_INLINE_VARIABLE constexpr memory_order memory_order_acq_rel = memory_order::acq_rel;
+BOOST_INLINE_VARIABLE constexpr memory_order memory_order_seq_cst = memory_order::seq_cst;
 
 } // namespace boost
 

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

@@ -27,7 +27,7 @@ namespace movelib {
 namespace detail {
 
 template <class T>
-inline T* iterator_to_pointer(T* i)
+BOOST_MOVE_FORCEINLINE T* iterator_to_pointer(T* i)
 {  return i; }
 
 template <class Iterator>

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

@@ -44,7 +44,7 @@ BOOST_MOVE_FORCEINLINE T* launder(T* p)
 template<class T>
 BOOST_MOVE_FORCEINLINE T launder_cast(const volatile void* p)
 {
-   return (launder)((T)p);
+   return (launder)(static_cast<T>(const_cast<void*>(p)));
 }
 
 }  //namespace move_detail {

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

@@ -9,6 +9,9 @@
 #//
 #//////////////////////////////////////////////////////////////////////////////
 #
+#ifndef BOOST_CONFIG_HPP
+#  include <boost/config.hpp>
+#endif
 #if defined(_LIBCPP_VERSION)
    #if defined(__clang__)
       #define BOOST_MOVE_STD_NS_GCC_DIAGNOSTIC_PUSH
@@ -26,6 +29,9 @@
 #elif defined(BOOST_DINKUMWARE_STDLIB)
    #define BOOST_MOVE_STD_NS_BEG _STD_BEGIN
    #define BOOST_MOVE_STD_NS_END _STD_END
+#else
+   #define BOOST_MOVE_STD_NS_BEG namespace std {
+   #define BOOST_MOVE_STD_NS_END }
 #endif
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1915)

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

@@ -497,7 +497,7 @@ struct is_unary_function_impl<R (*)(T0)>
 {  static const bool value = true;  };
 
 template <typename R, class T0>
-struct is_unary_function_impl<R (*)(T0...)>
+struct is_unary_function_impl<R (*)(T0, ...)>
 {  static const bool value = true;  };
 
 #else // BOOST_MOVE_TT_TEST_MSC_FUNC_SIGS
@@ -519,7 +519,7 @@ struct is_unary_function_impl<R (__cdecl*)(T0)>
 {  static const bool value = true;  };
 
 template <typename R, class T0>
-struct is_unary_function_impl<R (__cdecl*)(T0...)>
+struct is_unary_function_impl<R (__cdecl*)(T0, ...)>
 {  static const bool value = true;  };
 
 #endif

data/src/cxx_supportlib/vendor-modified/boost/mp11/algorithm.hpp

@@ -348,16 +348,21 @@ template<class L, class N> using mp_drop = mp_drop_c<L, std::size_t{ N::value }>
 namespace detail
 {
 
-template<class S, class F> struct mp_from_sequence_impl;
+template<class S, class F, bool Z> struct mp_from_sequence_impl;
 
-template<template<class T, T... I> class S, class U, U... J, class F> struct mp_from_sequence_impl<S<U, J...>, F>
+template<template<class T, T... I> class S, class U, U... J, class F> struct mp_from_sequence_impl<S<U, J...>, F, false>
 {
     using type = mp_list_c<U, (F::value + J)...>;
 };
 
+template<template<class T, T... I> class S, class U, U... J, class F> struct mp_from_sequence_impl<S<U, J...>, F, true>
+{
+    using type = mp_list_c<U, J...>;
+};
+
 } // namespace detail
 
-template<class S, class F = mp_int<0>> using mp_from_sequence = typename detail::mp_from_sequence_impl<S, F>::type;
+template<class S, class F = mp_int<0>> using mp_from_sequence = typename detail::mp_from_sequence_impl<S, F, (F::value == 0)>::type;
 
 // mp_iota(_c)<N, F>
 template<std::size_t N, std::size_t F = 0> using mp_iota_c = mp_from_sequence<make_index_sequence<N>, mp_size_t<F>>;
@@ -719,37 +724,7 @@ namespace detail
 
 template<class L, class V> struct mp_find_impl;
 
-#if BOOST_MP11_CLANG && defined( BOOST_MP11_HAS_FOLD_EXPRESSIONS )
-
-struct mp_index_holder
-{
-    std::size_t i_;
-    bool f_;
-};
-
-constexpr inline mp_index_holder operator+( mp_index_holder const & v, bool f )
-{
-    if( v.f_ )
-    {
-        return v;
-    }
-    else if( f )
-    {
-        return { v.i_, true };
-    }
-    else
-    {
-        return { v.i_ + 1, false };
-    }
-}
-
-template<template<class...> class L, class... T, class V> struct mp_find_impl<L<T...>, V>
-{
-    static constexpr mp_index_holder _v{ 0, false };
-    using type = mp_size_t< (_v + ... + std::is_same<T, V>::value).i_ >;
-};
-
-#elif !defined( BOOST_MP11_NO_CONSTEXPR )
+#if !defined( BOOST_MP11_NO_CONSTEXPR )
 
 template<template<class...> class L, class V> struct mp_find_impl<L<>, V>
 {
@@ -828,15 +803,7 @@ namespace detail
 
 template<class L, template<class...> class P> struct mp_find_if_impl;
 
-#if BOOST_MP11_CLANG && defined( BOOST_MP11_HAS_FOLD_EXPRESSIONS )
-
-template<template<class...> class L, class... T, template<class...> class P> struct mp_find_if_impl<L<T...>, P>
-{
-    static constexpr mp_index_holder _v{ 0, false };
-    using type = mp_size_t< (_v + ... + P<T>::value).i_ >;
-};
-
-#elif !defined( BOOST_MP11_NO_CONSTEXPR )
+#if !defined( BOOST_MP11_NO_CONSTEXPR )
 
 template<template<class...> class L, template<class...> class P> struct mp_find_if_impl<L<>, P>
 {
@@ -1003,7 +970,7 @@ template<template<class...> class L, class T1, class T2, class T3, class T4, cla
 
 } // namespace detail
 
-template<class L, class V, template<class...> class F> using mp_reverse_fold = typename detail::mp_reverse_fold_impl<L, V, F>::type;
+template<class L, class V, template<class...> class F> using mp_reverse_fold = typename detail::mp_reverse_fold_impl<mp_rename<L, mp_list>, V, F>::type;
 template<class L, class V, class Q> using mp_reverse_fold_q = mp_reverse_fold<L, V, Q::template fn>;
 
 // mp_unique<L>

data/src/cxx_supportlib/vendor-modified/boost/mp11/detail/mp_map_find.hpp

@@ -11,6 +11,14 @@
 #include <boost/mp11/utility.hpp>
 #include <boost/mp11/detail/config.hpp>
 
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_GCC, >= 140000 )
+
+#include <boost/mp11/detail/mp_list.hpp>
+#include <boost/mp11/detail/mp_append.hpp>
+#include <boost/mp11/detail/mp_front.hpp>
+
+#endif
+
 #if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1930 )
 
 // not exactly good practice, but...
@@ -26,6 +34,30 @@ namespace boost
 namespace mp11
 {
 
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_GCC, >= 140000 )
+
+// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=120161
+
+namespace detail
+{
+
+template<class M, class K> struct mp_map_find_impl;
+
+template<template<class...> class M, class... T, class K> struct mp_map_find_impl<M<T...>, K>
+{
+    template<class U> using _f = mp_if<std::is_same<mp_front<U>, K>, mp_list<U>, mp_list<>>;
+
+    using _l = mp_append<_f<T>..., mp_list<void>>;
+
+    using type = mp_front<_l>;
+};
+
+} // namespace detail
+
+template<class M, class K> using mp_map_find = typename detail::mp_map_find_impl<M, K>::type;
+
+#else
+
 // mp_map_find
 namespace detail
 {
@@ -81,6 +113,8 @@ template<template<class...> class M, class... T, class K> struct mp_map_find_imp
 
 template<class M, class K> using mp_map_find = typename detail::mp_map_find_impl<M, K>::type;
 
+#endif
+
 } // namespace mp11
 } // namespace boost
 

data/src/cxx_supportlib/vendor-modified/boost/mp11/set.hpp

@@ -1,7 +1,7 @@
 #ifndef BOOST_MP11_SET_HPP_INCLUDED
 #define BOOST_MP11_SET_HPP_INCLUDED
 
-// Copyright 2015, 2019 Peter Dimov.
+// Copyright 2015, 2019, 2024 Peter Dimov.
 //
 // Distributed under the Boost Software License, Version 1.0.
 //
@@ -10,9 +10,11 @@
 
 #include <boost/mp11/utility.hpp>
 #include <boost/mp11/function.hpp>
+#include <boost/mp11/detail/config.hpp>
 #include <boost/mp11/detail/mp_list.hpp>
 #include <boost/mp11/detail/mp_append.hpp>
 #include <boost/mp11/detail/mp_copy_if.hpp>
+#include <boost/mp11/detail/mp_fold.hpp>
 #include <boost/mp11/detail/mp_remove_if.hpp>
 #include <boost/mp11/detail/mp_is_list.hpp>
 #include <type_traits>
@@ -94,6 +96,34 @@ template<class S, class... T> using mp_set_push_front = typename detail::mp_set_
 namespace detail
 {
 
+#if !BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1900 )
+
+struct mp_is_set_helper_start
+{
+    static constexpr bool value = true;
+    template<class T> static mp_false contains( T );
+};
+
+template<class Base, class T>
+struct mp_is_set_helper: Base
+{
+    static constexpr bool value = Base::value && !decltype( Base::contains( mp_identity<T>{} ) )::value;
+    using Base::contains;
+    static mp_true contains( mp_identity<T> );
+};
+
+template<class S> struct mp_is_set_impl
+{
+    using type = mp_false;
+};
+
+template<template<class...> class L, class... T> struct mp_is_set_impl<L<T...>>
+{
+    using type = mp_bool<mp_fold<mp_list<T...>, detail::mp_is_set_helper_start, detail::mp_is_set_helper>::value>;
+};
+
+#else
+
 template<class S> struct mp_is_set_impl
 {
     using type = mp_false;
@@ -104,6 +134,8 @@ template<template<class...> class L, class... T> struct mp_is_set_impl<L<T...>>
     using type = mp_to_bool<std::is_same<mp_list<T...>, mp_set_push_back<mp_list<>, T...> > >;
 };
 
+#endif // !BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1900 )
+
 } // namespace detail
 
 template<class S> using mp_is_set = typename detail::mp_is_set_impl<S>::type;

data/src/cxx_supportlib/vendor-modified/boost/mp11/version.hpp

@@ -11,6 +11,6 @@
 // Same format as BOOST_VERSION:
 //   major * 100000 + minor * 100 + patch
 
-#define BOOST_MP11_VERSION 108700
+#define BOOST_MP11_VERSION 109000
 
 #endif // #ifndef BOOST_MP11_VERSION_HPP_INCLUDED

data/src/cxx_supportlib/vendor-modified/boost/mpl/and.hpp

@@ -28,26 +28,22 @@
 // 'or' and 'and' macros, see http://tinyurl.com/3et69; 'defined(and)'
 // has to be checked in a separate condition, otherwise GCC complains 
 // about 'and' being an alternative token
-#if defined(_MSC_VER)
-#ifndef __GCCXML__
-#if defined(and) 
+#if defined(_MSC_EXTENSIONS)
+#if defined(and)
 #   pragma push_macro("and")
 #   undef and
 #   define and(x)
 #endif
 #endif
-#endif
 
 #   define BOOST_MPL_PREPROCESSED_HEADER and.hpp
 #   include <boost/mpl/aux_/include_preprocessed.hpp>
 
-#if defined(_MSC_VER) && !defined(__clang__)
-#ifndef __GCCXML__
-#if defined(and) 
+#if defined(_MSC_EXTENSIONS)
+#if defined(and)
 #   pragma pop_macro("and")
 #endif
 #endif
-#endif
 
 #else
 

data/src/cxx_supportlib/vendor-modified/boost/mpl/aux_/na_assert.hpp

@@ -22,7 +22,7 @@
     && !BOOST_WORKAROUND(__EDG_VERSION__, <= 243)
 #   include <boost/mpl/assert.hpp>
 #   define BOOST_MPL_AUX_ASSERT_NOT_NA(x) \
-    BOOST_MPL_ASSERT_NOT((boost::mpl::is_na<type>)) \
+    BOOST_MPL_ASSERT_NOT((boost::mpl::is_na<x>)) \
 /**/
 #else
 #   include <boost/static_assert.hpp>

data/src/cxx_supportlib/vendor-modified/boost/mpl/aux_/ptr_to_ref.hpp

@@ -39,7 +39,7 @@
 
 namespace boost { namespace mpl { namespace aux {
 
-template< typename T > static T const& ptr_to_ref(T*);
+template< typename T > T const& ptr_to_ref(T*);
 
 }}}
 

data/src/cxx_supportlib/vendor-modified/boost/mpl/bitand.hpp

@@ -19,27 +19,23 @@
 // macros, see http://tinyurl.com/ycwdxco; 'defined(bitand)'
 // has to be checked in a separate condition, otherwise GCC complains 
 // about 'bitand' being an alternative token
-#if defined(_MSC_VER)
-#ifndef __GCCXML__
+#if defined(_MSC_EXTENSIONS)
 #if defined(bitand)
 #   pragma push_macro("bitand")
 #   undef bitand
 #   define bitand(x)
 #endif
 #endif
-#endif
 
 #define AUX778076_OP_NAME   bitand_
 #define AUX778076_OP_PREFIX bitand
 #define AUX778076_OP_TOKEN  &
 #include <boost/mpl/aux_/arithmetic_op.hpp>
 
-#if defined(_MSC_VER) && !defined(__clang__)
-#ifndef __GCCXML__
+#if defined(_MSC_EXTENSIONS)
 #if defined(bitand)
 #   pragma pop_macro("bitand")
 #endif
 #endif
-#endif
 
 #endif // BOOST_MPL_BITAND_HPP_INCLUDED

data/src/cxx_supportlib/vendor-modified/boost/mpl/bitor.hpp

@@ -19,27 +19,23 @@
 // macros, see http://tinyurl.com/ycwdxco; 'defined(bitor)'
 // has to be checked in a separate condition, otherwise GCC complains 
 // about 'bitor' being an alternative token
-#if defined(_MSC_VER)
-#ifndef __GCCXML__
+#if defined(_MSC_EXTENSIONS)
 #if defined(bitor)
 #   pragma push_macro("bitor")
 #   undef bitor
 #   define bitor(x)
 #endif
 #endif
-#endif
 
 #define AUX778076_OP_NAME   bitor_
 #define AUX778076_OP_PREFIX bitor
 #define AUX778076_OP_TOKEN  |
 #include <boost/mpl/aux_/arithmetic_op.hpp>
 
-#if defined(_MSC_VER) && !defined(__clang__)
-#ifndef __GCCXML__
+#if defined(_MSC_EXTENSIONS)
 #if defined(bitor)
 #   pragma pop_macro("bitor")
 #endif
 #endif
-#endif
 
 #endif // BOOST_MPL_BITOR_HPP_INCLUDED

data/src/cxx_supportlib/vendor-modified/boost/mpl/or.hpp

@@ -29,26 +29,22 @@
 // 'or' and 'and' macros, see http://tinyurl.com/3et69; 'defined(or)'
 // has to be checked in a separate condition, otherwise GCC complains 
 // about 'or' being an alternative token
-#if defined(_MSC_VER)
-#ifndef __GCCXML__
+#if defined(_MSC_EXTENSIONS)
 #if defined(or)
 #   pragma push_macro("or")
 #   undef or
 #   define or(x)
 #endif
 #endif
-#endif
 
 #   define BOOST_MPL_PREPROCESSED_HEADER or.hpp
 #   include <boost/mpl/aux_/include_preprocessed.hpp>
 
-#if defined(_MSC_VER) && !defined(__clang__)
-#ifndef __GCCXML__
+#if defined(_MSC_EXTENSIONS)
 #if defined(or)
 #   pragma pop_macro("or")
 #endif
 #endif
-#endif
 
 #else
 

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

@@ -39,7 +39,7 @@
 
 #ifdef BOOST_POOL_INSTRUMENT
 #include <iostream>
-#include<iomanip>
+#include <iomanip>
 #endif
 #ifdef BOOST_POOL_VALGRIND
 #include <set>

data/src/cxx_supportlib/vendor-modified/boost/pool/simple_segregated_storage.hpp

@@ -328,19 +328,6 @@ void * simple_segregated_storage<SizeType>::try_malloc_n(
     void * & start, size_type n, const size_type partition_size)
 {
   void * iter = nextof(start);
-  if (n == 1)
-  {
-    void * next = nextof(iter);
-    if (next != static_cast<char *>(iter) + partition_size)
-    {
-      start = iter;
-      return 0;
-    }
-    else
-    {
-      return iter;
-    }
-  }
   while (--n != 0)
   {
     void * next = nextof(iter);