passenger 6.0.20 → 6.0.21

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

@@ -43,11 +43,11 @@ class adaptive_xbuf
    typedef RandRawIt iterator;
    typedef SizeType  size_type;
 
-   BOOST_MOVE_FORCEINLINE adaptive_xbuf()
+   inline adaptive_xbuf()
       : m_ptr(), m_size(0), m_capacity(0)
    {}
 
-   BOOST_MOVE_FORCEINLINE adaptive_xbuf(RandRawIt raw_memory, size_type cap)
+   inline adaptive_xbuf(RandRawIt raw_memory, size_type cap)
       : m_ptr(raw_memory), m_size(0), m_capacity(cap)
    {}
 
@@ -102,7 +102,7 @@ class adaptive_xbuf
       }
    }
 
-   BOOST_MOVE_FORCEINLINE void set_size(size_type sz)
+   inline void set_size(size_type sz)
    {
       m_size = sz;
    }
@@ -144,12 +144,12 @@ class adaptive_xbuf
 
    private:
    template<class RIt>
-   BOOST_MOVE_FORCEINLINE static bool is_raw_ptr(RIt)
+   inline static bool is_raw_ptr(RIt)
    {
       return false;
    }
 
-   BOOST_MOVE_FORCEINLINE static bool is_raw_ptr(T*)
+   inline static bool is_raw_ptr(T*)
    {
       return true;
    }
@@ -168,43 +168,43 @@ class adaptive_xbuf
    }
 
    template<class U>
-   BOOST_MOVE_FORCEINLINE U *aligned_trailing() const
+   inline U *aligned_trailing() const
    {
       return this->aligned_trailing<U>(this->size());
    }
 
    template<class U>
-   BOOST_MOVE_FORCEINLINE U *aligned_trailing(size_type pos) const
+   inline U *aligned_trailing(size_type pos) const
    {
       uintptr_t u_addr = uintptr_t(&*(this->data()+pos));
       u_addr = ((u_addr + sizeof(U)-1)/sizeof(U))*sizeof(U);
       return (U*)u_addr;
    }
 
-   BOOST_MOVE_FORCEINLINE ~adaptive_xbuf()
+   inline ~adaptive_xbuf()
    {
       this->clear();
    }
 
-   BOOST_MOVE_FORCEINLINE size_type capacity() const
+   inline size_type capacity() const
    {  return m_capacity;   }
 
-   BOOST_MOVE_FORCEINLINE iterator data() const
+   inline iterator data() const
    {  return m_ptr;   }
 
-   BOOST_MOVE_FORCEINLINE iterator begin() const
+   inline iterator begin() const
    {  return m_ptr;   }
 
-   BOOST_MOVE_FORCEINLINE iterator end() const
+   inline iterator end() const
    {  return m_ptr+m_size;   }
 
-   BOOST_MOVE_FORCEINLINE size_type size() const
+   inline size_type size() const
    {  return m_size;   }
 
-   BOOST_MOVE_FORCEINLINE bool empty() const
+   inline bool empty() const
    {  return !m_size;   }
 
-   BOOST_MOVE_FORCEINLINE void clear()
+   inline void clear()
    {
       this->shrink_to_fit(0u);
    }

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

@@ -24,19 +24,19 @@ namespace movelib {
 template<class Comp>
 struct antistable
 {
-   BOOST_MOVE_FORCEINLINE explicit antistable(Comp &comp)
+   inline explicit antistable(Comp &comp)
       : m_comp(comp)
    {}
 
-   BOOST_MOVE_FORCEINLINE antistable(const antistable & other)
+   inline antistable(const antistable & other)
       : m_comp(other.m_comp)
    {}
 
    template<class U, class V>
-   BOOST_MOVE_FORCEINLINE bool operator()(const U &u, const V & v)
+   inline bool operator()(const U &u, const V & v)
    {  return !m_comp(v, u);  }
 
-   BOOST_MOVE_FORCEINLINE const Comp &get() const
+   inline const Comp &get() const
    {  return m_comp; }
 
    private:
@@ -56,15 +56,15 @@ template <class Comp>
 class negate
 {
    public:
-   BOOST_MOVE_FORCEINLINE negate()
+   inline negate()
    {}
 
-   BOOST_MOVE_FORCEINLINE explicit negate(Comp comp)
+   inline explicit negate(Comp comp)
       : m_comp(comp)
    {}
 
    template <class T1, class T2>
-   BOOST_MOVE_FORCEINLINE bool operator()(const T1& l, const T2& r)
+   inline bool operator()(const T1& l, const T2& r)
    {
       return !m_comp(l, r);
    }
@@ -78,15 +78,15 @@ template <class Comp>
 class inverse
 {
    public:
-   BOOST_MOVE_FORCEINLINE inverse()
+   inline inverse()
    {}
 
-   BOOST_MOVE_FORCEINLINE explicit inverse(Comp comp)
+   inline explicit inverse(Comp comp)
       : m_comp(comp)
    {}
 
    template <class T1, class T2>
-   BOOST_MOVE_FORCEINLINE bool operator()(const T1& l, const T2& r)
+   inline bool operator()(const T1& l, const T2& r)
    {
       return m_comp(r, l);
    }

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

@@ -262,12 +262,12 @@
 
    #define BOOST_COPYABLE_AND_MOVABLE(TYPE)\
       public:\
-      BOOST_MOVE_FORCEINLINE TYPE& operator=(TYPE &t)\
+      inline TYPE& operator=(TYPE &t)\
       {  this->operator=(const_cast<const TYPE&>(t)); return *this;}\
       public:\
-      BOOST_MOVE_FORCEINLINE operator ::boost::rv<TYPE>&() \
+      inline operator ::boost::rv<TYPE>&() \
       {  return *BOOST_MOVE_TO_RV_CAST(::boost::rv<TYPE>*, this);  }\
-      BOOST_MOVE_FORCEINLINE operator const ::boost::rv<TYPE>&() const \
+      inline operator const ::boost::rv<TYPE>&() const \
       {  return *BOOST_MOVE_TO_RV_CAST(const ::boost::rv<TYPE>*, this);  }\
       private:\
    //

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

@@ -27,11 +27,11 @@ namespace movelib {
 namespace detail {
 
 template <class T>
-BOOST_MOVE_FORCEINLINE T* iterator_to_pointer(T* i)
+inline T* iterator_to_pointer(T* i)
 {  return i; }
 
 template <class Iterator>
-BOOST_MOVE_FORCEINLINE typename boost::movelib::iterator_traits<Iterator>::pointer
+inline typename boost::movelib::iterator_traits<Iterator>::pointer
    iterator_to_pointer(const Iterator &i)
 {  return i.operator->();  }
 
@@ -46,7 +46,7 @@ struct iterator_to_element_ptr
 }  //namespace detail {
 
 template <class Iterator>
-BOOST_MOVE_FORCEINLINE typename boost::movelib::detail::iterator_to_element_ptr<Iterator>::type
+inline typename boost::movelib::detail::iterator_to_element_ptr<Iterator>::type
    iterator_to_raw_pointer(const Iterator &i)
 {
    return ::boost::movelib::to_raw_pointer

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

@@ -57,8 +57,8 @@ struct apply
 template< bool C_ >
 struct bool_ : integral_constant<bool, C_>
 {
-   BOOST_MOVE_FORCEINLINE operator bool() const { return C_; }
-   BOOST_MOVE_FORCEINLINE bool operator()() const { return C_; }
+   inline operator bool() const { return C_; }
+   inline bool operator()() const { return C_; }
 };
 
 typedef bool_<true>        true_;

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

@@ -69,13 +69,13 @@
    {};
 
    #define BOOST_MOVE_CONVERSION_AWARE_CATCH_COMMON(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION)\
-      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_CONST(TYPE) x)\
+      inline RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_CONST(TYPE) x)\
       {  return FWD_FUNCTION(static_cast<const TYPE&>(x)); }\
       \
-      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
+      inline RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
       {  return FWD_FUNCTION(::boost::move(x));  }\
       \
-      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(TYPE &x)\
+      inline RETURN_VALUE PUB_FUNCTION(TYPE &x)\
       {  return FWD_FUNCTION(const_cast<const TYPE &>(x)); }\
    //
    #if defined(BOOST_MOVE_HELPERS_RETURN_SFINAE_BROKEN)
@@ -83,12 +83,12 @@
          BOOST_MOVE_CONVERSION_AWARE_CATCH_COMMON(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION)\
          \
          template<class BOOST_MOVE_TEMPL_PARAM>\
-         BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(const BOOST_MOVE_TEMPL_PARAM &u,\
+         inline RETURN_VALUE PUB_FUNCTION(const BOOST_MOVE_TEMPL_PARAM &u,\
             typename boost_move_conversion_aware_catch_1< ::boost::move_detail::nat, BOOST_MOVE_TEMPL_PARAM, TYPE>::type* = 0)\
          { return FWD_FUNCTION(u); }\
          \
          template<class BOOST_MOVE_TEMPL_PARAM>\
-         BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(const BOOST_MOVE_TEMPL_PARAM &u,\
+         inline RETURN_VALUE PUB_FUNCTION(const BOOST_MOVE_TEMPL_PARAM &u,\
             typename boost_move_conversion_aware_catch_2< ::boost::move_detail::nat, BOOST_MOVE_TEMPL_PARAM, TYPE>::type* = 0)\
          {\
             TYPE t((u));\
@@ -100,12 +100,12 @@
          BOOST_MOVE_CONVERSION_AWARE_CATCH_COMMON(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION)\
          \
          template<class BOOST_MOVE_TEMPL_PARAM>\
-         BOOST_MOVE_FORCEINLINE typename boost_move_conversion_aware_catch_1<RETURN_VALUE, BOOST_MOVE_TEMPL_PARAM, TYPE>::type\
+         inline typename boost_move_conversion_aware_catch_1<RETURN_VALUE, BOOST_MOVE_TEMPL_PARAM, TYPE>::type\
             PUB_FUNCTION(const BOOST_MOVE_TEMPL_PARAM &u)\
          { return FWD_FUNCTION(u); }\
          \
          template<class BOOST_MOVE_TEMPL_PARAM>\
-         BOOST_MOVE_FORCEINLINE typename boost_move_conversion_aware_catch_2<RETURN_VALUE, BOOST_MOVE_TEMPL_PARAM, TYPE>::type\
+         inline typename boost_move_conversion_aware_catch_2<RETURN_VALUE, BOOST_MOVE_TEMPL_PARAM, TYPE>::type\
             PUB_FUNCTION(const BOOST_MOVE_TEMPL_PARAM &u)\
          {\
             TYPE t((u));\
@@ -116,14 +116,14 @@
 #elif (defined(_MSC_VER) && (_MSC_VER == 1600))
 
    #define BOOST_MOVE_CONVERSION_AWARE_CATCH(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION)\
-      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_CONST(TYPE) x)\
+      inline RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_CONST(TYPE) x)\
       {  return FWD_FUNCTION(static_cast<const TYPE&>(x)); }\
       \
-      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
+      inline RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
       {  return FWD_FUNCTION(::boost::move(x));  }\
       \
       template<class BOOST_MOVE_TEMPL_PARAM>\
-      BOOST_MOVE_FORCEINLINE typename ::boost::move_detail::enable_if_c\
+      inline typename ::boost::move_detail::enable_if_c\
                         < !::boost::move_detail::is_same<TYPE, BOOST_MOVE_TEMPL_PARAM>::value\
                         , RETURN_VALUE >::type\
       PUB_FUNCTION(const BOOST_MOVE_TEMPL_PARAM &u)\
@@ -136,10 +136,10 @@
 #else    //BOOST_NO_CXX11_RVALUE_REFERENCES
 
    #define BOOST_MOVE_CONVERSION_AWARE_CATCH(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION)\
-      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_CONST(TYPE) x)\
+      inline RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_CONST(TYPE) x)\
       {  return FWD_FUNCTION(x); }\
       \
-      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
+      inline RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
       {  return FWD_FUNCTION(::boost::move(x));  }\
    //
 
@@ -174,13 +174,13 @@
    {};
 
    #define BOOST_MOVE_CONVERSION_AWARE_CATCH_1ARG_COMMON(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION, ARG1, UNLESS_CONVERTIBLE_TO)\
-      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_CONST(TYPE) x)\
+      inline RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_CONST(TYPE) x)\
       {  return FWD_FUNCTION(arg1, static_cast<const TYPE&>(x)); }\
       \
-      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
+      inline RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
       {  return FWD_FUNCTION(arg1, ::boost::move(x));  }\
       \
-      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(ARG1 arg1, TYPE &x)\
+      inline RETURN_VALUE PUB_FUNCTION(ARG1 arg1, TYPE &x)\
       {  return FWD_FUNCTION(arg1, const_cast<const TYPE &>(x)); }\
    //
    #if defined(BOOST_MOVE_HELPERS_RETURN_SFINAE_BROKEN)
@@ -188,12 +188,12 @@
          BOOST_MOVE_CONVERSION_AWARE_CATCH_1ARG_COMMON(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION, ARG1, UNLESS_CONVERTIBLE_TO)\
          \
          template<class BOOST_MOVE_TEMPL_PARAM>\
-         BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(ARG1 arg1, const BOOST_MOVE_TEMPL_PARAM &u,\
+         inline RETURN_VALUE PUB_FUNCTION(ARG1 arg1, const BOOST_MOVE_TEMPL_PARAM &u,\
             typename boost_move_conversion_aware_catch_1arg_1<void, BOOST_MOVE_TEMPL_PARAM, UNLESS_CONVERTIBLE_TO, TYPE>::type* = 0)\
          { return FWD_FUNCTION(arg1, u); }\
          \
          template<class BOOST_MOVE_TEMPL_PARAM>\
-         BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(ARG1 arg1, const BOOST_MOVE_TEMPL_PARAM &u,\
+         inline RETURN_VALUE PUB_FUNCTION(ARG1 arg1, const BOOST_MOVE_TEMPL_PARAM &u,\
             typename boost_move_conversion_aware_catch_1arg_2<void, BOOST_MOVE_TEMPL_PARAM, UNLESS_CONVERTIBLE_TO, TYPE>::type* = 0)\
          {\
             TYPE t((u));\
@@ -205,12 +205,12 @@
          BOOST_MOVE_CONVERSION_AWARE_CATCH_1ARG_COMMON(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION, ARG1, UNLESS_CONVERTIBLE_TO)\
          \
          template<class BOOST_MOVE_TEMPL_PARAM>\
-         BOOST_MOVE_FORCEINLINE typename boost_move_conversion_aware_catch_1arg_1<RETURN_VALUE, BOOST_MOVE_TEMPL_PARAM, UNLESS_CONVERTIBLE_TO, TYPE>::type\
+         inline typename boost_move_conversion_aware_catch_1arg_1<RETURN_VALUE, BOOST_MOVE_TEMPL_PARAM, UNLESS_CONVERTIBLE_TO, TYPE>::type\
             PUB_FUNCTION(ARG1 arg1, const BOOST_MOVE_TEMPL_PARAM &u)\
          { return FWD_FUNCTION(arg1, u); }\
          \
          template<class BOOST_MOVE_TEMPL_PARAM>\
-         BOOST_MOVE_FORCEINLINE typename boost_move_conversion_aware_catch_1arg_2<RETURN_VALUE, BOOST_MOVE_TEMPL_PARAM, UNLESS_CONVERTIBLE_TO, TYPE>::type\
+         inline typename boost_move_conversion_aware_catch_1arg_2<RETURN_VALUE, BOOST_MOVE_TEMPL_PARAM, UNLESS_CONVERTIBLE_TO, TYPE>::type\
             PUB_FUNCTION(ARG1 arg1, const BOOST_MOVE_TEMPL_PARAM &u)\
          {\
             TYPE t((u));\
@@ -222,14 +222,14 @@
 #elif (defined(_MSC_VER) && (_MSC_VER == 1600))
 
    #define BOOST_MOVE_CONVERSION_AWARE_CATCH_1ARG(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION, ARG1, UNLESS_CONVERTIBLE_TO)\
-      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_CONST(TYPE) x)\
+      inline RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_CONST(TYPE) x)\
       {  return FWD_FUNCTION(arg1, static_cast<const TYPE&>(x)); }\
       \
-      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
+      inline RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
       {  return FWD_FUNCTION(arg1, ::boost::move(x));  }\
       \
       template<class BOOST_MOVE_TEMPL_PARAM>\
-      BOOST_MOVE_FORCEINLINE typename ::boost::move_detail::disable_if_or\
+      inline typename ::boost::move_detail::disable_if_or\
                         < RETURN_VALUE \
                         , ::boost::move_detail::is_same<TYPE, BOOST_MOVE_TEMPL_PARAM> \
                         , ::boost::move_detail::is_same_or_convertible<BOOST_MOVE_TEMPL_PARAM, UNLESS_CONVERTIBLE_TO> \
@@ -244,10 +244,10 @@
 #else
 
    #define BOOST_MOVE_CONVERSION_AWARE_CATCH_1ARG(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION, ARG1, UNLESS_CONVERTIBLE_TO)\
-      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_CONST(TYPE) x)\
+      inline RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_CONST(TYPE) x)\
       {  return FWD_FUNCTION(arg1, static_cast<const TYPE&>(x)); }\
       \
-      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
+      inline RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
       {  return FWD_FUNCTION(arg1, ::boost::move(x));  }\
    //
 

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

@@ -581,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
 //////////////////////////
@@ -594,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>
@@ -639,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
@@ -660,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
 //////////////////////////
@@ -732,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
 //////////////////////////////////////
@@ -802,6 +834,7 @@ struct is_arithmetic
                              is_integral<T>::value;
 };
 
+
 //////////////////////////////////////
 //    is_member_function_pointer
 //////////////////////////////////////
@@ -829,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