passenger 6.0.20 → 6.0.22

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-2023.
+// Copyright Antony Polukhin, 2011-2024.
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@@ -28,14 +28,12 @@
 
 namespace boost { namespace detail {
 
-    template <typename TargetChar, typename SourceChar>
-    struct widest_char {
-        typedef BOOST_DEDUCED_TYPENAME boost::conditional<
-            (sizeof(TargetChar) > sizeof(SourceChar))
-            , TargetChar
-            , SourceChar
-        >::type type;
-    };
+template <typename TargetChar, typename SourceChar>
+using widest_char = boost::conditional<
+    (sizeof(TargetChar) > sizeof(SourceChar))
+    , TargetChar
+    , SourceChar
+>;
 
 }} // namespace boost::detail
 

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-2023.
+// Copyright Antony Polukhin, 2011-2024.
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@@ -23,140 +23,25 @@
 #   pragma once
 #endif
 
-#if defined(__clang__) || (defined(__GNUC__) && \
-    !(defined(__INTEL_COMPILER) || defined(__ICL) || defined(__ICC) || defined(__ECC)) && \
-    (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)))
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wuninitialized"
-#pragma GCC diagnostic ignored "-Wsign-conversion"
-#endif
-
-
-#include <string>
-#include <boost/type_traits/is_integral.hpp>
-#include <boost/type_traits/type_identity.hpp>
 #include <boost/type_traits/conditional.hpp>
-#include <boost/type_traits/is_same.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>
 #include <boost/lexical_cast/detail/converter_lexical.hpp>
 
-#include <boost/range/iterator_range_core.hpp>
-#include <boost/container/container_fwd.hpp>
-
 namespace boost {
     namespace detail
     {
-        template<typename T>
-        struct is_stdstring
-            : boost::false_type
-        {};
-
-        template<typename CharT, typename Traits, typename Alloc>
-        struct is_stdstring< std::basic_string<CharT, Traits, Alloc> >
-            : boost::true_type
-        {};
-
-        // Sun Studio has problem with partial specialization of templates differing only in namespace.
-        // We workaround that by making `is_booststring` trait, instead of specializing `is_stdstring` for `boost::container::basic_string`.
-        template<typename T>
-        struct is_booststring
-            : boost::false_type
-        {};
-
-        template<typename CharT, typename Traits, typename Alloc>
-        struct is_booststring< boost::container::basic_string<CharT, Traits, Alloc> >
-            : boost::true_type
-        {};
-
-        template<typename Target, typename Source>
-        struct is_arithmetic_and_not_xchars
-        {
-            typedef boost::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
-                > type;
-
-            BOOST_STATIC_CONSTANT(bool, value = (
-                type::value
-            ));
-        };
-
-        /*
-         * is_xchar_to_xchar<Target, Source>::value is true,
-         * Target and Souce are char types of the same size 1 (char, signed char, unsigned char).
-         */
-        template<typename Target, typename Source>
-        struct is_xchar_to_xchar
-        {
-            typedef boost::integral_constant<
-                bool,
-                sizeof(Source) == sizeof(Target) &&
-                     sizeof(Source) == sizeof(char) &&
-                     boost::detail::is_character<Target>::value &&
-                     boost::detail::is_character<Source>::value
-                > type;
-
-            BOOST_STATIC_CONSTANT(bool, value = (
-                type::value
-            ));
-        };
-
-        template<typename Target, typename Source>
-        struct is_char_array_to_stdstring
-            : boost::false_type
-        {};
-
-        template<typename CharT, typename Traits, typename Alloc>
-        struct is_char_array_to_stdstring< std::basic_string<CharT, Traits, Alloc>, CharT* >
-            : boost::true_type
-        {};
-
-        template<typename CharT, typename Traits, typename Alloc>
-        struct is_char_array_to_stdstring< std::basic_string<CharT, Traits, Alloc>, const CharT* >
-            : boost::true_type
-        {};
-
-        // Sun Studio has problem with partial specialization of templates differing only in namespace.
-        // We workaround that by making `is_char_array_to_booststring` trait, instead of specializing `is_char_array_to_stdstring` for `boost::container::basic_string`.
         template<typename Target, typename Source>
-        struct is_char_array_to_booststring
-            : boost::false_type
-        {};
-
-        template<typename CharT, typename Traits, typename Alloc>
-        struct is_char_array_to_booststring< boost::container::basic_string<CharT, Traits, Alloc>, CharT* >
-            : boost::true_type
-        {};
-
-        template<typename CharT, typename Traits, typename Alloc>
-        struct is_char_array_to_booststring< boost::container::basic_string<CharT, Traits, Alloc>, const CharT* >
-            : boost::true_type
-        {};
-
-        template <typename Target, typename Source>
-        struct copy_converter_impl
-        {
-// MSVC fail to forward an array (DevDiv#555157 "SILENT BAD CODEGEN triggered by perfect forwarding",
-// fixed in 2013 RTM).
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && (!defined(BOOST_MSVC) || BOOST_MSVC >= 1800)
-            template <class T>
-            static inline bool try_convert(T&& arg, Target& result) {
-                result = static_cast<T&&>(arg); // eqaul to `result = std::forward<T>(arg);`
-                return true;
-            }
-#else
-            static inline bool try_convert(const Source& arg, Target& result) {
-                result = arg;
-                return true;
-            }
-#endif
-        };
+        using is_arithmetic_and_not_xchars = boost::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
+        >;
     }
 
     namespace conversion { namespace detail {
@@ -164,39 +49,20 @@ namespace boost {
         template <typename Target, typename Source>
         inline bool try_lexical_convert(const Source& arg, Target& result)
         {
-            typedef BOOST_DEDUCED_TYPENAME boost::detail::array_to_pointer_decay<Source>::type src;
-
-            typedef boost::integral_constant<
-                bool,
-                boost::detail::is_xchar_to_xchar<Target, src >::value ||
-                boost::detail::is_char_array_to_stdstring<Target, src >::value ||
-                boost::detail::is_char_array_to_booststring<Target, src >::value ||
-                (
-                     boost::is_same<Target, src >::value &&
-                     (boost::detail::is_stdstring<Target >::value || boost::detail::is_booststring<Target >::value)
-                ) ||
-                (
-                     boost::is_same<Target, src >::value &&
-                     boost::detail::is_character<Target >::value
-                )
-            > shall_we_copy_t;
+            static_assert(
+                !boost::is_volatile<Source>::value,
+                "Boost.LexicalCast does not support volatile input");
+
+            typedef typename boost::detail::array_to_pointer_decay<Source>::type src;
 
             typedef boost::detail::is_arithmetic_and_not_xchars<Target, src >
                 shall_we_copy_with_dynamic_check_t;
 
-            // We do evaluate second `if_` lazily to avoid unnecessary instantiations
-            // of `shall_we_copy_with_dynamic_check_t` and improve compilation times.
-            typedef BOOST_DEDUCED_TYPENAME boost::conditional<
-                shall_we_copy_t::value,
-                boost::type_identity<boost::detail::copy_converter_impl<Target, src > >,
-                boost::conditional<
-                     shall_we_copy_with_dynamic_check_t::value,
-                     boost::detail::dynamic_num_converter_impl<Target, src >,
-                     boost::detail::lexical_converter_impl<Target, src >
-                >
-            >::type caster_type_lazy;
-
-            typedef BOOST_DEDUCED_TYPENAME caster_type_lazy::type caster_type;
+            typedef typename boost::conditional<
+                 shall_we_copy_with_dynamic_check_t::value,
+                 boost::detail::dynamic_num_converter_impl<Target, src >,
+                 boost::detail::lexical_converter_impl<Target, src >
+            >::type caster_type;
 
             return caster_type::try_convert(arg, result);
         }
@@ -204,12 +70,13 @@ namespace boost {
         template <typename Target, typename CharacterT>
         inline bool try_lexical_convert(const CharacterT* chars, std::size_t count, Target& result)
         {
-            BOOST_STATIC_ASSERT_MSG(
+            static_assert(
                 boost::detail::is_character<CharacterT>::value,
                 "This overload of try_lexical_convert is meant to be used only with arrays of characters."
             );
             return ::boost::conversion::detail::try_lexical_convert(
-                ::boost::iterator_range<const CharacterT*>(chars, chars + count), result
+                ::boost::conversion::detail::make_buffer_view(chars, chars + count),
+                result
             );
         }
 
@@ -222,11 +89,5 @@ namespace boost {
 
 } // namespace boost
 
-#if defined(__clang__) || (defined(__GNUC__) && \
-    !(defined(__INTEL_COMPILER) || defined(__ICL) || defined(__ICC) || defined(__ECC)) && \
-    (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)))
-#pragma GCC diagnostic pop
-#endif
-
 #endif // BOOST_LEXICAL_CAST_TRY_LEXICAL_CONVERT_HPP
 

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-2023.
+// Copyright Antony Polukhin, 2011-2024.
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@@ -23,29 +23,12 @@
 #   pragma once
 #endif
 
-#include <boost/config/pragma_message.hpp>
-#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES) || \
-    defined(BOOST_NO_CXX11_AUTO_DECLARATIONS) || \
-    defined(BOOST_NO_CXX11_CONSTEXPR) || \
-    defined(BOOST_NO_CXX11_NULLPTR) || \
-    defined(BOOST_NO_CXX11_NOEXCEPT) || \
-    defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) || \
-    defined(BOOST_NO_CXX11_FINAL) || \
-    defined(BOOST_NO_CXX11_ALIGNOF) || \
-    defined(BOOST_NO_CXX11_STATIC_ASSERT) || \
-    defined(BOOST_NO_CXX11_SMART_PTR) || \
-    defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) || \
-    defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)
-
-BOOST_PRAGMA_MESSAGE("C++03 support is deprecated in Boost.LexicalCast 1.82 and will be removed in Boost.LexicalCast 1.84.")
-
-#endif
-
 #if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_WSTRING)
 #define BOOST_LCAST_NO_WCHAR_T
 #endif
 
-#include <boost/range/iterator_range_core.hpp>
+#include <boost/lexical_cast/detail/buffer_view.hpp>
+
 #include <boost/lexical_cast/bad_lexical_cast.hpp>
 #include <boost/lexical_cast/try_lexical_convert.hpp>
 
@@ -67,7 +50,7 @@ namespace boost
     inline Target lexical_cast(const char* chars, std::size_t count)
     {
         return ::boost::lexical_cast<Target>(
-            ::boost::iterator_range<const char*>(chars, chars + count)
+            ::boost::conversion::detail::make_buffer_view(chars, chars + count)
         );
     }
 
@@ -75,7 +58,7 @@ namespace boost
     inline Target lexical_cast(const unsigned char* chars, std::size_t count)
     {
         return ::boost::lexical_cast<Target>(
-            ::boost::iterator_range<const unsigned char*>(chars, chars + count)
+            ::boost::conversion::detail::make_buffer_view(chars, chars + count)
         );
     }
 
@@ -83,7 +66,7 @@ namespace boost
     inline Target lexical_cast(const signed char* chars, std::size_t count)
     {
         return ::boost::lexical_cast<Target>(
-            ::boost::iterator_range<const signed char*>(chars, chars + count)
+            ::boost::conversion::detail::make_buffer_view(chars, chars + count)
         );
     }
 
@@ -92,28 +75,24 @@ namespace boost
     inline Target lexical_cast(const wchar_t* chars, std::size_t count)
     {
         return ::boost::lexical_cast<Target>(
-            ::boost::iterator_range<const wchar_t*>(chars, chars + count)
+            ::boost::conversion::detail::make_buffer_view(chars, chars + count)
         );
     }
 #endif
-#ifndef BOOST_NO_CXX11_CHAR16_T
     template <typename Target>
     inline Target lexical_cast(const char16_t* chars, std::size_t count)
     {
         return ::boost::lexical_cast<Target>(
-            ::boost::iterator_range<const char16_t*>(chars, chars + count)
+            ::boost::conversion::detail::make_buffer_view(chars, chars + count)
         );
     }
-#endif
-#ifndef BOOST_NO_CXX11_CHAR32_T
     template <typename Target>
     inline Target lexical_cast(const char32_t* chars, std::size_t count)
     {
         return ::boost::lexical_cast<Target>(
-            ::boost::iterator_range<const char32_t*>(chars, chars + count)
+            ::boost::conversion::detail::make_buffer_view(chars, chars + count)
         );
     }
-#endif
 
 } // namespace boost
 

data/src/cxx_supportlib/vendor-modified/boost/libs/chrono/src/chrono.cpp

@@ -6,10 +6,12 @@
 //  Distributed under the Boost Software License, Version 1.0.
 //  See http://www.boost.org/LICENSE_1_0.txt
 
-// define BOOST_CHRONO_SOURCE so that <boost/filesystem/config.hpp> knows
+// define BOOST_CHRONO_SOURCE so that <boost/chrono/config.hpp> knows
 // the library is being built (possibly exporting rather than importing code)
 
-#define BOOST_CHRONO_SOURCE
+#ifndef BOOST_CHRONO_SOURCE
+# define BOOST_CHRONO_SOURCE
+#endif
 
 #include <boost/chrono/detail/inlined/chrono.hpp>
 

data/src/cxx_supportlib/vendor-modified/boost/libs/chrono/src/process_cpu_clocks.cpp

@@ -12,7 +12,9 @@
 // define BOOST_CHRONO_SOURCE so that <boost/chrono/config.hpp> knows
 // the library is being built (possibly exporting rather than importing code)
 
-#define BOOST_CHRONO_SOURCE
+#ifndef BOOST_CHRONO_SOURCE
+# define BOOST_CHRONO_SOURCE
+#endif
 
 #include <boost/chrono/detail/inlined/process_cpu_clocks.hpp>
 

data/src/cxx_supportlib/vendor-modified/boost/libs/chrono/src/thread_clock.cpp

@@ -13,7 +13,9 @@
 // define BOOST_CHRONO_SOURCE so that <boost/chrono/config.hpp> knows
 // the library is being built (possibly exporting rather than importing code)
 
-#define BOOST_CHRONO_SOURCE
+#ifndef BOOST_CHRONO_SOURCE
+# define BOOST_CHRONO_SOURCE
+#endif
 
 #include <boost/chrono/detail/inlined/thread_clock.hpp>
 

data/src/cxx_supportlib/vendor-modified/boost/libs/thread/src/pthread/thread.cpp

@@ -19,6 +19,8 @@
 #include <boost/thread/future.hpp>
 #include <boost/thread/pthread/pthread_helpers.hpp>
 #include <boost/thread/pthread/pthread_mutex_scoped_lock.hpp>
+#include <boost/thread/detail/string_trim.hpp>
+#include <boost/thread/detail/string_to_unsigned.hpp>
 
 #ifdef __GLIBC__
 #include <sys/sysinfo.h>
@@ -33,10 +35,6 @@
 #include <vxCpuLib.h>
 #endif
 
-#include <boost/algorithm/string/split.hpp>
-#include <boost/algorithm/string/trim.hpp>
-#include <boost/lexical_cast.hpp>
-
 #include <fstream>
 #include <string>
 #include <set>
@@ -535,24 +533,36 @@ namespace boost
                 if (line.empty())
                     continue;
 
-                vector<string> key_val(2);
-                boost::split(key_val, line, boost::is_any_of(":"));
+                std::size_t i = line.find( ':' );
+
+                if( i == std::string::npos )
+                {
+                    return hardware_concurrency();
+                }
 
-                if (key_val.size() != 2)
-                  return hardware_concurrency();
+                std::string key = line.substr( 0, i );
+                std::string value = line.substr( i+1 );
 
-                string key   = key_val[0];
-                string value = key_val[1];
-                boost::trim(key);
-                boost::trim(value);
+                key = thread_detail::string_trim( key );
+                value = thread_detail::string_trim( value );
 
                 if (key == physical_id) {
-                    current_core_entry.first = boost::lexical_cast<unsigned>(value);
+
+                    if( !thread_detail::string_to_unsigned( value, current_core_entry.first ) )
+                    {
+                        return hardware_concurrency();
+                    }
+
                     continue;
                 }
 
                 if (key == core_id) {
-                    current_core_entry.second = boost::lexical_cast<unsigned>(value);
+
+                    if( !thread_detail::string_to_unsigned( value, current_core_entry.second ) )
+                    {
+                        return hardware_concurrency();
+                    }
+
                     cores.insert(current_core_entry);
                     continue;
                 }

data/src/cxx_supportlib/vendor-modified/boost/move/adl_move_swap.hpp

@@ -155,7 +155,7 @@ struct and_op_not
 {};
 
 template<class T>
-BOOST_MOVE_FORCEINLINE void swap_proxy(T& x, T& y, typename boost::move_detail::enable_if_c<!boost::move_detail::has_move_emulation_enabled_impl<T>::value>::type* = 0)
+inline void swap_proxy(T& x, T& y, typename boost::move_detail::enable_if_c<!boost::move_detail::has_move_emulation_enabled_impl<T>::value>::type* = 0)
 {
    //use std::swap if argument dependent lookup fails
    //Use using directive ("using namespace xxx;") instead as some older compilers
@@ -165,14 +165,14 @@ BOOST_MOVE_FORCEINLINE void swap_proxy(T& x, T& y, typename boost::move_detail::
 }
 
 template<class T>
-BOOST_MOVE_FORCEINLINE void swap_proxy(T& x, T& y
+void swap_proxy(T& x, T& y
                , typename boost::move_detail::enable_if< and_op_not_impl<boost::move_detail::has_move_emulation_enabled_impl<T>
                                                                         , boost_move_member_swap::has_member_swap<T> >
                                                        >::type* = 0)
 {  T t(::boost::move(x)); x = ::boost::move(y); y = ::boost::move(t);  }
 
 template<class T>
-BOOST_MOVE_FORCEINLINE void swap_proxy(T& x, T& y
+inline void swap_proxy(T& x, T& y
                , typename boost::move_detail::enable_if< and_op_impl< boost::move_detail::has_move_emulation_enabled_impl<T>
                                                                     , boost_move_member_swap::has_member_swap<T> >
                                                        >::type* = 0)
@@ -185,7 +185,7 @@ BOOST_MOVE_FORCEINLINE void swap_proxy(T& x, T& y
 namespace boost_move_adl_swap{
 
 template<class T>
-BOOST_MOVE_FORCEINLINE void swap_proxy(T& x, T& y)
+inline void swap_proxy(T& x, T& y)
 {
    using std::swap;
    swap(x, y);
@@ -222,7 +222,7 @@ namespace boost{
 //!   -  Otherwise a move-based swap is called, equivalent to: 
 //!      <code>T t(::boost::move(x)); x = ::boost::move(y); y = ::boost::move(t);</code>.
 template<class T>
-BOOST_MOVE_FORCEINLINE void adl_move_swap(T& x, T& y)
+inline void adl_move_swap(T& x, T& y)
 {
    ::boost_move_adl_swap::swap_proxy(x, y);
 }

data/src/cxx_supportlib/vendor-modified/boost/move/algo/adaptive_merge.hpp

@@ -19,6 +19,7 @@
 #if defined(BOOST_CLANG) || (defined(BOOST_GCC) && (BOOST_GCC >= 40600))
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wsign-conversion"
+#pragma GCC diagnostic ignored "-Wconversion"
 #endif
 
 namespace boost {

data/src/cxx_supportlib/vendor-modified/boost/move/algo/adaptive_sort.hpp

@@ -20,6 +20,7 @@
 #if defined(BOOST_CLANG) || (defined(BOOST_GCC) && (BOOST_GCC >= 40600))
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wsign-conversion"
+#pragma GCC diagnostic ignored "-Wconversion"
 #endif
 
 namespace boost {

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

@@ -60,6 +60,7 @@
 #if defined(BOOST_CLANG) || (defined(BOOST_GCC) && (BOOST_GCC >= 40600))
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wsign-conversion"
+#pragma GCC diagnostic ignored "-Wconversion"
 #endif
 
 #ifndef BOOST_MOVE_ADAPTIVE_SORT_STATS_LEVEL
@@ -93,26 +94,12 @@
    #define BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(L)
 #endif
 
-namespace boost {
-namespace movelib {
-
 #if defined(BOOST_MOVE_ADAPTIVE_SORT_INVARIANTS)
+#include <boost/move/algo/detail/is_sorted.hpp>
+#endif
 
-bool is_sorted(::order_perf_type *first, ::order_perf_type *last, ::order_type_less)
-{
-   if (first != last) {
-      const order_perf_type *next = first, *cur(first);
-      while (++next != last) {
-         if (!(cur->key < next->key || (cur->key == next->key && cur->val < next->val)))
-            return false;
-         cur = next;
-      }
-   }
-   return true;
-}
-
-#endif   //BOOST_MOVE_ADAPTIVE_SORT_INVARIANTS
-
+namespace boost {
+namespace movelib {
 namespace detail_adaptive {
 
 static const std::size_t AdaptiveSortInsertionSortThreshold = 16;
@@ -1320,7 +1307,6 @@ void op_merge_blocks_with_buf
          //swap_and_update_key(key_next, key_range2, key_mid, first2, last2, first_min);
          buffer_end = buffer_and_update_key(key_next, key_range2, key_mid, first2, last2, first_min, buffer = buf_first, op);
          BOOST_MOVE_ADAPTIVE_SORT_PRINT_L2("   merge_blocks_w_swp: ", len);
-         BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(boost::movelib::is_sorted(first2, last2, comp));
          BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(boost::movelib::is_sorted(first_min, last_min, comp));
          first1 = first2;
          BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(boost::movelib::is_sorted(first, first1, comp));

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

@@ -36,19 +36,19 @@ struct four_way_t{};
 struct move_op
 {
    template <class SourceIt, class DestinationIt>
-   BOOST_MOVE_FORCEINLINE void operator()(SourceIt source, DestinationIt dest)
+   inline void operator()(SourceIt source, DestinationIt dest)
    {  *dest = ::boost::move(*source);  }
 
    template <class SourceIt, class DestinationIt>
-   BOOST_MOVE_FORCEINLINE DestinationIt operator()(forward_t, SourceIt first, SourceIt last, DestinationIt dest_begin)
+   inline DestinationIt operator()(forward_t, SourceIt first, SourceIt last, DestinationIt dest_begin)
    {  return ::boost::move(first, last, dest_begin);  }
 
    template <class SourceIt, class DestinationIt>
-   BOOST_MOVE_FORCEINLINE DestinationIt operator()(backward_t, SourceIt first, SourceIt last, DestinationIt dest_last)
+   inline DestinationIt operator()(backward_t, SourceIt first, SourceIt last, DestinationIt dest_last)
    {  return ::boost::move_backward(first, last, dest_last);  }
 
    template <class SourceIt, class DestinationIt1, class DestinationIt2>
-   BOOST_MOVE_FORCEINLINE void operator()(three_way_t, SourceIt srcit, DestinationIt1 dest1it, DestinationIt2 dest2it)
+   inline void operator()(three_way_t, SourceIt srcit, DestinationIt1 dest1it, DestinationIt2 dest2it)
    {
       *dest2it = boost::move(*dest1it);
       *dest1it = boost::move(*srcit);
@@ -65,7 +65,7 @@ struct move_op
    }
 
    template <class SourceIt, class DestinationIt1, class DestinationIt2, class DestinationIt3>
-   BOOST_MOVE_FORCEINLINE void operator()(four_way_t, SourceIt srcit, DestinationIt1 dest1it, DestinationIt2 dest2it, DestinationIt3 dest3it)
+   inline void operator()(four_way_t, SourceIt srcit, DestinationIt1 dest1it, DestinationIt2 dest2it, DestinationIt3 dest3it)
    {
       *dest3it = boost::move(*dest2it);
       *dest2it = boost::move(*dest1it);
@@ -76,19 +76,19 @@ struct move_op
 struct swap_op
 {
    template <class SourceIt, class DestinationIt>
-   BOOST_MOVE_FORCEINLINE void operator()(SourceIt source, DestinationIt dest)
+   inline void operator()(SourceIt source, DestinationIt dest)
    {  boost::adl_move_swap(*dest, *source);  }
 
    template <class SourceIt, class DestinationIt>
-   BOOST_MOVE_FORCEINLINE DestinationIt operator()(forward_t, SourceIt first, SourceIt last, DestinationIt dest_begin)
+   inline DestinationIt operator()(forward_t, SourceIt first, SourceIt last, DestinationIt dest_begin)
    {  return boost::adl_move_swap_ranges(first, last, dest_begin);  }
 
    template <class SourceIt, class DestinationIt>
-   BOOST_MOVE_FORCEINLINE DestinationIt operator()(backward_t, SourceIt first, SourceIt last, DestinationIt dest_begin)
+   inline DestinationIt operator()(backward_t, SourceIt first, SourceIt last, DestinationIt dest_begin)
    {  return boost::adl_move_swap_ranges_backward(first, last, dest_begin);  }
 
    template <class SourceIt, class DestinationIt1, class DestinationIt2>
-   BOOST_MOVE_FORCEINLINE void operator()(three_way_t, SourceIt srcit, DestinationIt1 dest1it, DestinationIt2 dest2it)
+   inline void operator()(three_way_t, SourceIt srcit, DestinationIt1 dest1it, DestinationIt2 dest2it)
    {
       typename ::boost::movelib::iterator_traits<SourceIt>::value_type tmp(boost::move(*dest2it));
       *dest2it = boost::move(*dest1it);
@@ -106,7 +106,7 @@ struct swap_op
    }
 
    template <class SourceIt, class DestinationIt1, class DestinationIt2, class DestinationIt3>
-   BOOST_MOVE_FORCEINLINE void operator()(four_way_t, SourceIt srcit, DestinationIt1 dest1it, DestinationIt2 dest2it, DestinationIt3 dest3it)
+   inline void operator()(four_way_t, SourceIt srcit, DestinationIt1 dest1it, DestinationIt2 dest2it, DestinationIt3 dest3it)
    {
       typename ::boost::movelib::iterator_traits<SourceIt>::value_type tmp(boost::move(*dest3it));
       *dest3it = boost::move(*dest2it);

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

@@ -106,7 +106,7 @@ class heap_sort_helper
 };
 
 template <class RandomAccessIterator, class Compare>
-BOOST_MOVE_FORCEINLINE void heap_sort(RandomAccessIterator first, RandomAccessIterator last, Compare comp)
+inline void heap_sort(RandomAccessIterator first, RandomAccessIterator last, Compare comp)
 {
    heap_sort_helper<RandomAccessIterator, Compare>::sort(first, last, comp);
 }