passenger 6.0.19 → 6.0.21

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

@@ -26,6 +26,7 @@
 
 #include <boost/config.hpp>
 #include <boost/cstdint.hpp>
+#include <boost/move/detail/workaround.hpp>
 #include <cstdlib>
 
 
@@ -39,26 +40,73 @@
 
 #if defined(BOOST_MOVE_DETAIL_WINDOWS_API)
 
-#include <boost/winapi/time.hpp>
-#include <boost/winapi/timers.hpp>
-#include <boost/winapi/get_last_error.hpp>
-#include <boost/winapi/error_codes.hpp>
-#include <boost/assert.hpp>
-#include <boost/core/ignore_unused.hpp>
+#include <cassert>
+
+#if defined( BOOST_USE_WINDOWS_H )
+#include <Windows.h>
+#else
+
+#if defined (WIN32_PLATFORM_PSPC)
+#define BOOST_MOVE_WINAPI_IMPORT BOOST_SYMBOL_IMPORT
+#define BOOST_MOVE_WINAPI_IMPORT_EXCEPT_WM
+#elif defined (_WIN32_WCE)
+#define BOOST_MOVE_WINAPI_IMPORT
+#define BOOST_MOVE_WINAPI_IMPORT_EXCEPT_WM
+#else
+#define BOOST_MOVE_WINAPI_IMPORT BOOST_SYMBOL_IMPORT
+#define BOOST_MOVE_WINAPI_IMPORT_EXCEPT_WM BOOST_SYMBOL_IMPORT
+#endif
+
+#if defined(WINAPI)
+#define BOOST_MOVE_WINAPI_CC WINAPI
+#else
+   #if defined(_M_IX86) || defined(__i386__)
+   #define BOOST_MOVE_WINAPI_CC __stdcall
+   #else
+   // On architectures other than 32-bit x86 __stdcall is ignored. Clang also issues a warning.
+   #define BOOST_MOVE_WINAPI_CC
+   #endif
+#endif
+
+
+extern "C" {
+
+union _LARGE_INTEGER;
+typedef long long QuadPart;
+
+BOOST_MOVE_WINAPI_IMPORT_EXCEPT_WM int BOOST_MOVE_WINAPI_CC
+QueryPerformanceCounter(::_LARGE_INTEGER* lpPerformanceCount);
+
+BOOST_MOVE_WINAPI_IMPORT_EXCEPT_WM int BOOST_MOVE_WINAPI_CC
+QueryPerformanceFrequency(::_LARGE_INTEGER* lpFrequency);
+
+} // extern "C"
+#endif
+
 
 namespace boost { namespace move_detail {
 
+BOOST_FORCEINLINE int QueryPerformanceCounter(long long* lpPerformanceCount)
+{
+    return ::QueryPerformanceCounter(reinterpret_cast< ::_LARGE_INTEGER* >(lpPerformanceCount));
+}
+
+BOOST_FORCEINLINE int QueryPerformanceFrequency(long long* lpFrequency)
+{
+    return ::QueryPerformanceFrequency(reinterpret_cast< ::_LARGE_INTEGER* >(lpFrequency));
+}
+
+
 template<int Dummy>
 struct QPFHolder
 {
    static inline double get_nsec_per_tic()
    {
-      boost::winapi::LARGE_INTEGER_ freq;
-      boost::winapi::BOOL_ r = boost::winapi::QueryPerformanceFrequency( &freq );
-      boost::ignore_unused(r);
-      BOOST_ASSERT(r != 0 && "Boost::Move - get_nanosecs_per_tic Internal Error");
-
-      return double(1000000000.0L / freq.QuadPart);
+      long long freq;
+      //According to MS documentation:
+      //"On systems that run Windows XP or later, the function will always succeed and will thus never return zero"
+      (void)boost::move_detail::QueryPerformanceFrequency(&freq);
+      return double(1000000000.0L / double(freq));
    }
 
    static const double nanosecs_per_tic;
@@ -71,18 +119,11 @@ inline boost::uint64_t nsec_clock() BOOST_NOEXCEPT
 {
    double nanosecs_per_tic = QPFHolder<0>::nanosecs_per_tic;
    
-   boost::winapi::LARGE_INTEGER_ pcount;
-   unsigned times=0;
-   while ( !boost::winapi::QueryPerformanceCounter( &pcount ) )
-   {
-      if ( ++times > 3 )
-      {
-         BOOST_ASSERT("Boost::Move - QueryPerformanceCounter Internal Error");
-         return 0u;
-      }
-   }
-
-   return static_cast<boost::uint64_t>(nanosecs_per_tic * double(pcount.QuadPart));
+   long long pcount;
+   //According to MS documentation:
+   //"On systems that run Windows XP or later, the function will always succeed and will thus never return zero"
+   (void)boost::move_detail::QueryPerformanceCounter( &pcount );
+   return static_cast<boost::uint64_t>(nanosecs_per_tic * double(pcount));
 }
 
 }}  //namespace boost { namespace move_detail {

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

@@ -29,7 +29,7 @@ namespace boost {
 namespace movelib {
 
 template<class I>
-BOOST_MOVE_FORCEINLINE typename iterator_traits<I>::pointer iterator_arrow_result(const I &i)
+inline typename iterator_traits<I>::pointer iterator_arrow_result(const I &i)
 {  return i.operator->();  }
 
 template<class T>
@@ -49,38 +49,38 @@ class reverse_iterator
 
    typedef It iterator_type;
 
-   BOOST_MOVE_FORCEINLINE reverse_iterator()
+   inline reverse_iterator()
       : m_current()  //Value initialization to achieve "null iterators" (N3644)
    {}
 
-   BOOST_MOVE_FORCEINLINE explicit reverse_iterator(It r)
+   inline explicit reverse_iterator(It r)
       : m_current(r)
    {}
 
-   BOOST_MOVE_FORCEINLINE reverse_iterator(const reverse_iterator& r)
+   inline reverse_iterator(const reverse_iterator& r)
       : m_current(r.base())
    {}
 
    template<class OtherIt>
-   BOOST_MOVE_FORCEINLINE
+   inline
       reverse_iterator( const reverse_iterator<OtherIt>& r
                       , typename boost::move_detail::enable_if_convertible<OtherIt, It>::type* =0
                    )
       : m_current(r.base())
    {}
 
-   BOOST_MOVE_FORCEINLINE reverse_iterator & operator=( const reverse_iterator& r)
+   inline reverse_iterator & operator=( const reverse_iterator& r)
    {  m_current = r.base();   return *this;  }
 
    template<class OtherIt>
-   BOOST_MOVE_FORCEINLINE typename boost::move_detail::enable_if_convertible<OtherIt, It, reverse_iterator &>::type
+   inline typename boost::move_detail::enable_if_convertible<OtherIt, It, reverse_iterator &>::type
          operator=( const reverse_iterator<OtherIt>& r)
    {  m_current = r.base();   return *this;  }
 
-   BOOST_MOVE_FORCEINLINE It base() const
+   inline It base() const
    {  return m_current;  }
 
-   BOOST_MOVE_FORCEINLINE reference operator*() const
+   inline reference operator*() const
    {
       It temp(m_current);
       --temp;
@@ -88,78 +88,78 @@ class reverse_iterator
       return r;
    }
 
-   BOOST_MOVE_FORCEINLINE pointer operator->() const
+   inline pointer operator->() const
    {
       It temp(m_current);
       --temp;
       return (iterator_arrow_result)(temp);
    }
 
-   BOOST_MOVE_FORCEINLINE reference operator[](difference_type off) const
+   inline reference operator[](difference_type off) const
    {
       return this->m_current[difference_type(-off - 1)];
    }
 
-   BOOST_MOVE_FORCEINLINE reverse_iterator& operator++()
+   inline reverse_iterator& operator++()
    {
       --m_current;
       return *this;
    }
 
-   BOOST_MOVE_FORCEINLINE reverse_iterator operator++(int)
+   inline reverse_iterator operator++(int)
    {
       reverse_iterator temp((*this));
       --m_current;
       return temp;
    }
 
-   BOOST_MOVE_FORCEINLINE reverse_iterator& operator--()
+   inline reverse_iterator& operator--()
    {
       ++m_current;
       return *this;
    }
 
-   BOOST_MOVE_FORCEINLINE reverse_iterator operator--(int)
+   inline reverse_iterator operator--(int)
    {
       reverse_iterator temp((*this));
       ++m_current;
       return temp;
    }
 
-   BOOST_MOVE_FORCEINLINE friend bool operator==(const reverse_iterator& l, const reverse_iterator& r)
+   inline friend bool operator==(const reverse_iterator& l, const reverse_iterator& r)
    {  return l.m_current == r.m_current;  }
 
-   BOOST_MOVE_FORCEINLINE friend bool operator!=(const reverse_iterator& l, const reverse_iterator& r)
+   inline friend bool operator!=(const reverse_iterator& l, const reverse_iterator& r)
    {  return l.m_current != r.m_current;  }
 
-   BOOST_MOVE_FORCEINLINE friend bool operator<(const reverse_iterator& l, const reverse_iterator& r)
+   inline friend bool operator<(const reverse_iterator& l, const reverse_iterator& r)
    {  return l.m_current > r.m_current;  }
 
-   BOOST_MOVE_FORCEINLINE friend bool operator<=(const reverse_iterator& l, const reverse_iterator& r)
+   inline friend bool operator<=(const reverse_iterator& l, const reverse_iterator& r)
    {  return l.m_current >= r.m_current;  }
 
-   BOOST_MOVE_FORCEINLINE friend bool operator>(const reverse_iterator& l, const reverse_iterator& r)
+   inline friend bool operator>(const reverse_iterator& l, const reverse_iterator& r)
    {  return l.m_current < r.m_current;  }
 
-   BOOST_MOVE_FORCEINLINE friend bool operator>=(const reverse_iterator& l, const reverse_iterator& r)
+   inline friend bool operator>=(const reverse_iterator& l, const reverse_iterator& r)
    {  return l.m_current <= r.m_current;  }
 
-   BOOST_MOVE_FORCEINLINE reverse_iterator& operator+=(difference_type off)
+   inline reverse_iterator& operator+=(difference_type off)
    {  m_current -= off; return *this;  }
 
-   BOOST_MOVE_FORCEINLINE reverse_iterator& operator-=(difference_type off)
+   inline reverse_iterator& operator-=(difference_type off)
    {  m_current += off; return *this;  }
 
-   BOOST_MOVE_FORCEINLINE friend reverse_iterator operator+(reverse_iterator l, difference_type off)
+   inline friend reverse_iterator operator+(reverse_iterator l, difference_type off)
    {  return (l += off);  }
 
-   BOOST_MOVE_FORCEINLINE friend reverse_iterator operator+(difference_type off, reverse_iterator r)
+   inline friend reverse_iterator operator+(difference_type off, reverse_iterator r)
    {  return (r += off);   }
 
-   BOOST_MOVE_FORCEINLINE friend reverse_iterator operator-(reverse_iterator l, difference_type off)
+   inline friend reverse_iterator operator-(reverse_iterator l, difference_type off)
    {  return (l-= off);  }
 
-   BOOST_MOVE_FORCEINLINE friend difference_type operator-(const reverse_iterator& l, const reverse_iterator& r)
+   inline friend difference_type operator-(const reverse_iterator& l, const reverse_iterator& r)
    {  return r.m_current - l.m_current;  }
 
    private:
@@ -167,7 +167,7 @@ class reverse_iterator
 };
 
 template< class Iterator >
-BOOST_MOVE_FORCEINLINE reverse_iterator<Iterator> make_reverse_iterator( Iterator i )
+inline reverse_iterator<Iterator> make_reverse_iterator( Iterator i )
 {  return reverse_iterator<Iterator>(i);  }
 
 } //namespace movelib {

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

@@ -33,7 +33,7 @@ BOOST_MOVE_FORCEINLINE T* to_raw_pointer(T* p)
 {  return p; }
 
 template <class Pointer>
-BOOST_MOVE_FORCEINLINE typename boost::movelib::pointer_element<Pointer>::type*
+inline typename boost::movelib::pointer_element<Pointer>::type*
 to_raw_pointer(const Pointer &p)
 {  return ::boost::movelib::to_raw_pointer(p.operator->());  }
 

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

@@ -30,8 +30,7 @@
 // move/detail
 #include <boost/move/detail/meta_utils.hpp>
 // other
-#include <boost/assert.hpp>
-#include <boost/static_assert.hpp>
+#include <cassert>
 // std
 #include <cstddef>
 
@@ -582,6 +581,28 @@ struct remove_cvref
 {
 };
 
+//////////////////////////
+//    is_unsigned
+//////////////////////////
+template<class T> struct is_unsigned_cv               { static const bool value = true; };
+template <>       struct is_unsigned_cv<signed char>  { static const bool value = false; };
+template <>       struct is_unsigned_cv<signed short> { static const bool value = false; };
+template <>       struct is_unsigned_cv<signed int>   { static const bool value = false; };
+template <>       struct is_unsigned_cv<signed long>  { static const bool value = false; };
+#ifdef BOOST_HAS_LONG_LONG
+template <>       struct is_unsigned_cv< ::boost::long_long_type > { static const bool value = false; };
+#endif
+
+#ifdef BOOST_HAS_INT128
+template <>       struct is_unsigned_cv< ::boost::int128_type >    { static const bool value = false; };
+#endif
+
+template <class T>
+struct is_unsigned
+   : is_unsigned_cv<typename remove_cv<T>::type>
+{};
+
+
 //////////////////////////
 //    make_unsigned
 //////////////////////////
@@ -595,6 +616,11 @@ template <> struct make_unsigned_impl<signed long>                {  typedef uns
 template <> struct make_unsigned_impl< ::boost::long_long_type >  {  typedef ::boost::ulong_long_type type; };
 #endif
 
+#ifdef BOOST_HAS_INT128
+template <> struct make_unsigned_impl< ::boost::int128_type > { typedef ::boost::uint128_type type; };
+#endif
+
+
 template <class T>
 struct make_unsigned
    : make_unsigned_impl<typename remove_cv<T>::type>
@@ -640,6 +666,13 @@ template<> struct is_integral_cv<            unsigned long>{  static const bool
 template<> struct is_integral_cv< ::boost:: long_long_type>{  static const bool value = true; };
 template<> struct is_integral_cv< ::boost::ulong_long_type>{  static const bool value = true; };
 #endif
+#ifdef BOOST_HAS_INT128
+template <> struct is_integral_cv< ::boost::int128_type >  {  static const bool value = true; };
+template <> struct is_integral_cv< ::boost::uint128_type > {  static const bool value = true; };
+#endif
+#if defined(__cpp_char8_t) && __cpp_char8_t >= 201811L
+template<> struct is_integral_cv<char8_t>  { static const bool value = true; };
+#endif
 
 template<class T>
 struct is_integral
@@ -661,13 +694,6 @@ template <class T, std::size_t N>
 struct remove_all_extents<T[N]>
 {  typedef typename remove_all_extents<T>::type type;};
 
-//////////////////////////
-//    is_scalar
-//////////////////////////
-template<class T>
-struct is_scalar
-{  static const bool value = is_integral<T>::value || is_floating_point<T>::value; };
-
 //////////////////////////
 //       is_void
 //////////////////////////
@@ -733,6 +759,11 @@ struct is_nullptr_t
    : is_nullptr_t_cv<typename remove_cv<T>::type>
 {};
 
+template <class T>
+struct is_null_pointer
+   : is_nullptr_t_cv<typename remove_cv<T>::type>
+{};
+
 //////////////////////////////////////
 //          is_function
 //////////////////////////////////////
@@ -803,6 +834,7 @@ struct is_arithmetic
                              is_integral<T>::value;
 };
 
+
 //////////////////////////////////////
 //    is_member_function_pointer
 //////////////////////////////////////
@@ -830,21 +862,38 @@ struct is_member_function_pointer
 template <class T>
 struct is_enum_nonintrinsic
 {
-   static const bool value =  !is_arithmetic<T>::value     &&
-                              !is_reference<T>::value      &&
-                              !is_class_or_union<T>::value &&
-                              !is_array<T>::value          &&
-                              !is_void<T>::value           &&
-                              !is_nullptr_t<T>::value      &&
-                              !is_member_pointer<T>::value &&
-                              !is_pointer<T>::value        &&
-                              !is_function<T>::value;
+   static const bool value = !is_arithmetic<T>::value &&
+      !is_reference<T>::value &&
+      !is_class_or_union<T>::value &&
+      !is_array<T>::value &&
+      !is_void<T>::value &&
+      !is_nullptr_t<T>::value &&
+      !is_member_pointer<T>::value &&
+      !is_pointer<T>::value &&
+      !is_function<T>::value;
 };
 #endif
 
 template <class T>
 struct is_enum
-{  static const bool value = BOOST_MOVE_IS_ENUM_IMPL(T);  };
+{
+   static const bool value = BOOST_MOVE_IS_ENUM_IMPL(T);
+};
+
+
+//////////////////////////
+//    is_scalar
+//////////////////////////
+template<class T>
+struct is_scalar
+{
+   static const bool value = is_arithmetic<T>::value ||
+      is_enum<T>::value ||
+      is_pointer<T>::value ||
+      is_member_pointer<T>::value ||
+      is_null_pointer<T>::value;
+};
+
 
 //////////////////////////////////////
 //       is_pod
@@ -1238,7 +1287,7 @@ struct aligned_next;
 template<std::size_t Len, std::size_t Align, class T>
 struct aligned_next<Len, Align, T, true>
 {
-   BOOST_STATIC_ASSERT((alignment_of<T>::value == Align));
+   BOOST_MOVE_STATIC_ASSERT((alignment_of<T>::value == Align));
    typedef aligned_union<T, Len> type;
 };
 
@@ -1278,13 +1327,13 @@ template<std::size_t Len, std::size_t Align = alignment_of<max_align_t>::value>
 struct aligned_storage
 {
    //Sanity checks for input parameters
-   BOOST_STATIC_ASSERT(Align > 0);
+   BOOST_MOVE_STATIC_ASSERT(Align > 0);
 
    //Sanity checks for output type
    typedef typename aligned_storage_impl<Len ? Len : 1, Align>::type type;
    static const std::size_t value = alignment_of<type>::value;
-   BOOST_STATIC_ASSERT(value >= Align);
-   BOOST_STATIC_ASSERT((value % Align) == 0);
+   BOOST_MOVE_STATIC_ASSERT(value >= Align);
+   BOOST_MOVE_STATIC_ASSERT((value % Align) == 0);
 
    //Just in case someone instantiates aligned_storage
    //instead of aligned_storage::type (typical error).

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

@@ -61,11 +61,91 @@
 #elif defined(BOOST_MSVC) && (_MSC_VER < 1900 || defined(_DEBUG))
    //"__forceinline" and MSVC seems to have some bugs in old versions and in debug mode
    #define BOOST_MOVE_FORCEINLINE inline
-#elif defined(BOOST_GCC) && (__GNUC__ <= 5)
+#elif defined(BOOST_CLANG) || (defined(BOOST_GCC) && ((__GNUC__ <= 5) || defined(__MINGW32__)))
    //Older GCCs have problems with forceinline
+   //Clang can have code bloat issues with forceinline, see
+   //https://lists.boost.org/boost-users/2023/04/91445.php and
+   //https://github.com/llvm/llvm-project/issues/62202
    #define BOOST_MOVE_FORCEINLINE inline
 #else
    #define BOOST_MOVE_FORCEINLINE BOOST_FORCEINLINE
 #endif
 
+namespace boost {
+namespace movelib {
+
+template <typename T1>
+BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void ignore(T1 const&)
+{}
+
+}} //namespace boost::movelib {
+
+#if !(defined BOOST_NO_EXCEPTIONS)
+#    define BOOST_MOVE_TRY { try
+#    define BOOST_MOVE_CATCH(x) catch(x)
+#    define BOOST_MOVE_RETHROW throw;
+#    define BOOST_MOVE_CATCH_END }
+#else
+#    if !defined(BOOST_MSVC) || BOOST_MSVC >= 1900
+#        define BOOST_MOVE_TRY { if (true)
+#        define BOOST_MOVE_CATCH(x) else if (false)
+#    else
+// warning C4127: conditional expression is constant
+#        define BOOST_MOVE_TRY { \
+             __pragma(warning(push)) \
+             __pragma(warning(disable: 4127)) \
+             if (true) \
+             __pragma(warning(pop))
+#        define BOOST_MOVE_CATCH(x) else \
+             __pragma(warning(push)) \
+             __pragma(warning(disable: 4127)) \
+             if (false) \
+             __pragma(warning(pop))
+#    endif
+#    define BOOST_MOVE_RETHROW
+#    define BOOST_MOVE_CATCH_END }
+#endif
+
+#ifndef BOOST_NO_CXX11_STATIC_ASSERT
+#  ifndef BOOST_NO_CXX11_VARIADIC_MACROS
+#     define BOOST_MOVE_STATIC_ASSERT( ... ) static_assert(__VA_ARGS__, #__VA_ARGS__)
+#  else
+#     define BOOST_MOVE_STATIC_ASSERT( B ) static_assert(B, #B)
+#  endif
+#else
+namespace boost {
+namespace move_detail {
+
+template<bool B>
+struct STATIC_ASSERTION_FAILURE;
+
+template<>
+struct STATIC_ASSERTION_FAILURE<true>{};
+
+template<unsigned> struct static_assert_test {};
+
+}}
+
+#define BOOST_MOVE_STATIC_ASSERT(B) \
+         typedef ::boost::move_detail::static_assert_test<\
+            (unsigned)sizeof(::boost::move_detail::STATIC_ASSERTION_FAILURE<bool(B)>)>\
+               BOOST_JOIN(boost_move_static_assert_typedef_, __LINE__) BOOST_ATTRIBUTE_UNUSED
+
+#endif
+
+#if !defined(__has_cpp_attribute) || defined(__CUDACC__)
+#define BOOST_MOVE_HAS_MSVC_ATTRIBUTE(ATTR) 0
+#else
+#define BOOST_MOVE_HAS_MSVC_ATTRIBUTE(ATTR) __has_cpp_attribute(msvc::ATTR)
+#endif
+
+// See https://devblogs.microsoft.com/cppblog/improving-the-state-of-debug-performance-in-c/
+// for details on how MSVC has improved debug experience, specifically for move/forward-like utilities
+#if BOOST_MOVE_HAS_MSVC_ATTRIBUTE(intrinsic)
+#define BOOST_MOVE_INTRINSIC_CAST [[msvc::intrinsic]]
+#else
+#define BOOST_MOVE_INTRINSIC_CAST BOOST_MOVE_FORCEINLINE
+#endif
+
 #endif   //#ifndef BOOST_MOVE_DETAIL_WORKAROUND_HPP
+

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

@@ -58,20 +58,20 @@ class move_iterator
    typedef typename boost::movelib::iterator_traits<iterator_type>::difference_type   difference_type;
    typedef typename boost::movelib::iterator_traits<iterator_type>::iterator_category iterator_category;
 
-   BOOST_MOVE_FORCEINLINE move_iterator()
+   inline move_iterator()
       : m_it()
    {}
 
-   BOOST_MOVE_FORCEINLINE explicit move_iterator(const It &i)
+   inline explicit move_iterator(const It &i)
       :  m_it(i)
    {}
 
    template <class U>
-   BOOST_MOVE_FORCEINLINE move_iterator(const move_iterator<U>& u)
+   inline move_iterator(const move_iterator<U>& u)
       :  m_it(u.m_it)
    {}
 
-   BOOST_MOVE_FORCEINLINE reference operator*() const
+   inline reference operator*() const
    {
       #if defined(BOOST_NO_CXX11_RVALUE_REFERENCES) || defined(BOOST_MOVE_OLD_RVALUE_REF_BINDING_RULES)
       return *m_it;
@@ -80,34 +80,34 @@ class move_iterator
       #endif
    }
 
-   BOOST_MOVE_FORCEINLINE pointer   operator->() const
+   inline pointer   operator->() const
    {  return m_it;   }
 
-   BOOST_MOVE_FORCEINLINE move_iterator& operator++()
+   inline move_iterator& operator++()
    {  ++m_it; return *this;   }
 
-   BOOST_MOVE_FORCEINLINE move_iterator<iterator_type>  operator++(int)
+   inline move_iterator<iterator_type>  operator++(int)
    {  move_iterator<iterator_type> tmp(*this); ++(*this); return tmp;   }
 
-   BOOST_MOVE_FORCEINLINE move_iterator& operator--()
+   inline move_iterator& operator--()
    {  --m_it; return *this;   }
 
-   BOOST_MOVE_FORCEINLINE move_iterator<iterator_type>  operator--(int)
+   inline move_iterator<iterator_type>  operator--(int)
    {  move_iterator<iterator_type> tmp(*this); --(*this); return tmp;   }
 
    move_iterator<iterator_type>  operator+ (difference_type n) const
    {  return move_iterator<iterator_type>(m_it + n);  }
 
-   BOOST_MOVE_FORCEINLINE move_iterator& operator+=(difference_type n)
+   inline move_iterator& operator+=(difference_type n)
    {  m_it += n; return *this;   }
 
-   BOOST_MOVE_FORCEINLINE move_iterator<iterator_type>  operator- (difference_type n) const
+   inline move_iterator<iterator_type>  operator- (difference_type n) const
    {  return move_iterator<iterator_type>(m_it - n);  }
 
-   BOOST_MOVE_FORCEINLINE move_iterator& operator-=(difference_type n)
+   inline move_iterator& operator-=(difference_type n)
    {  m_it -= n; return *this;   }
 
-   BOOST_MOVE_FORCEINLINE reference operator[](difference_type n) const
+   inline reference operator[](difference_type n) const
    {
       #if defined(BOOST_NO_CXX11_RVALUE_REFERENCES) || defined(BOOST_MOVE_OLD_RVALUE_REF_BINDING_RULES)
       return m_it[n];
@@ -116,28 +116,28 @@ class move_iterator
       #endif
    }
 
-   BOOST_MOVE_FORCEINLINE friend bool operator==(const move_iterator& x, const move_iterator& y)
+   inline friend bool operator==(const move_iterator& x, const move_iterator& y)
    {  return x.m_it == y.m_it;  }
 
-   BOOST_MOVE_FORCEINLINE friend bool operator!=(const move_iterator& x, const move_iterator& y)
+   inline friend bool operator!=(const move_iterator& x, const move_iterator& y)
    {  return x.m_it != y.m_it;  }
 
-   BOOST_MOVE_FORCEINLINE friend bool operator< (const move_iterator& x, const move_iterator& y)
+   inline friend bool operator< (const move_iterator& x, const move_iterator& y)
    {  return x.m_it < y.m_it;   }
 
-   BOOST_MOVE_FORCEINLINE friend bool operator<=(const move_iterator& x, const move_iterator& y)
+   inline friend bool operator<=(const move_iterator& x, const move_iterator& y)
    {  return x.m_it <= y.m_it;  }
 
-   BOOST_MOVE_FORCEINLINE friend bool operator> (const move_iterator& x, const move_iterator& y)
+   inline friend bool operator> (const move_iterator& x, const move_iterator& y)
    {  return x.m_it > y.m_it;  }
 
-   BOOST_MOVE_FORCEINLINE friend bool operator>=(const move_iterator& x, const move_iterator& y)
+   inline friend bool operator>=(const move_iterator& x, const move_iterator& y)
    {  return x.m_it >= y.m_it;  }
 
-   BOOST_MOVE_FORCEINLINE friend difference_type operator-(const move_iterator& x, const move_iterator& y)
+   inline friend difference_type operator-(const move_iterator& x, const move_iterator& y)
    {  return x.m_it - y.m_it;   }
 
-   BOOST_MOVE_FORCEINLINE friend move_iterator operator+(difference_type n, const move_iterator& x)
+   inline friend move_iterator operator+(difference_type n, const move_iterator& x)
    {  return move_iterator(x.m_it + n);   }
 
    private:
@@ -170,7 +170,7 @@ struct is_move_iterator< ::boost::move_iterator<I> >
 //!
 //! <b>Returns</b>: move_iterator<It>(i).
 template<class It>
-BOOST_MOVE_FORCEINLINE move_iterator<It> make_move_iterator(const It &it)
+inline move_iterator<It> make_move_iterator(const It &it)
 {  return move_iterator<It>(it); }
 
 //////////////////////////////////////////////////////////////////////////////