passenger 6.0.19 → 6.0.21

data/src/cxx_supportlib/vendor-modified/boost/container/detail/adaptive_node_pool_impl.hpp

@@ -42,7 +42,6 @@
 #include <boost/intrusive/slist.hpp>
 // other
 #include <boost/assert.hpp>
-#include <boost/core/no_exceptions_support.hpp>
 #include <cstddef>
 
 namespace boost {
@@ -760,7 +759,7 @@ class private_adaptive_node_pool_impl_common
                            , const size_type real_num_node, const size_type num_subblocks)
    {
       size_type i = 0;
-      BOOST_TRY{
+      BOOST_CONTAINER_TRY{
          this->priv_invariants(real_num_node, num_subblocks, real_block_alignment);
          while(i != n){
             //If there are no free nodes we allocate all needed blocks
@@ -800,12 +799,12 @@ class private_adaptive_node_pool_impl_common
             i += num_elems;
          }
       }
-      BOOST_CATCH(...){
+      BOOST_CONTAINER_CATCH(...){
          this->priv_deallocate_nodes(chain, max_free_blocks, real_num_node, num_subblocks, real_block_alignment);
          this->priv_invariants(real_num_node, num_subblocks, real_block_alignment);
-         BOOST_RETHROW
+         BOOST_CONTAINER_RETHROW
       }
-      BOOST_CATCH_END
+      BOOST_CONTAINER_CATCH_END
       this->priv_invariants(real_num_node, num_subblocks, real_block_alignment);
    }
 

data/src/cxx_supportlib/vendor-modified/boost/container/detail/advanced_insert_int.hpp

@@ -41,7 +41,6 @@
 #include <boost/move/detail/force_ptr.hpp>
 // other
 #include <boost/assert.hpp>
-#include <boost/core/no_exceptions_support.hpp>
 
 namespace boost { namespace container { namespace dtl {
 
@@ -50,19 +49,19 @@ struct move_insert_range_proxy
 {
    typedef typename allocator_traits<Allocator>::value_type value_type;
 
-   BOOST_CONTAINER_FORCEINLINE explicit move_insert_range_proxy(FwdIt first)
+   inline explicit move_insert_range_proxy(FwdIt first)
       :  first_(first)
    {}
 
    template<class Iterator>
-   BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n)
+   inline void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n)
    {
       this->first_ = ::boost::container::uninitialized_move_alloc_n_source
          (a, this->first_, n, p);
    }
 
    template<class Iterator>
-   BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &, Iterator p, std::size_t n)
+   inline void copy_n_and_update(Allocator &, Iterator p, std::size_t n)
    {
       this->first_ = ::boost::container::move_n_source(this->first_, n, p);
    }
@@ -76,18 +75,18 @@ struct insert_range_proxy
 {
    typedef typename allocator_traits<Allocator>::value_type value_type;
 
-   BOOST_CONTAINER_FORCEINLINE explicit insert_range_proxy(FwdIt first)
+   inline explicit insert_range_proxy(FwdIt first)
       :  first_(first)
    {}
 
    template<class Iterator>
-   BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n)
+   inline void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n)
    {
       this->first_ = ::boost::container::uninitialized_copy_alloc_n_source(a, this->first_, n, p);
    }
 
    template<class Iterator>
-   BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &, Iterator p, std::size_t n)
+   inline void copy_n_and_update(Allocator &, Iterator p, std::size_t n)
    {
       this->first_ = ::boost::container::copy_n_source(this->first_, n, p);
    }
@@ -101,16 +100,16 @@ struct insert_n_copies_proxy
 {
    typedef typename allocator_traits<Allocator>::value_type value_type;
 
-   BOOST_CONTAINER_FORCEINLINE explicit insert_n_copies_proxy(const value_type &v)
+   inline explicit insert_n_copies_proxy(const value_type &v)
       :  v_(v)
    {}
 
    template<class Iterator>
-   BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const
+   inline void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const
    {  boost::container::uninitialized_fill_alloc_n(a, v_, n, p);  }
 
    template<class Iterator>
-   BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &, Iterator p, std::size_t n) const
+   inline void copy_n_and_update(Allocator &, Iterator p, std::size_t n) const
    {
       while (n){
          --n;
@@ -130,7 +129,7 @@ struct insert_value_initialized_n_proxy
    typedef typename dtl::aligned_storage<sizeof(value_type), dtl::alignment_of<value_type>::value>::type storage_t;
 
    template<class Iterator>
-   BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const
+   inline void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const
    {  boost::container::uninitialized_value_init_alloc_n(a, n, p);  }
 
    template<class Iterator>
@@ -156,7 +155,7 @@ struct insert_default_initialized_n_proxy
    typedef typename dtl::aligned_storage<sizeof(value_type), dtl::alignment_of<value_type>::value>::type storage_t;
 
    template<class Iterator>
-   BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const
+   inline void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const
    {  boost::container::uninitialized_default_init_alloc_n(a, n, p);  }
 
    template<class Iterator>
@@ -184,19 +183,19 @@ struct insert_copy_proxy
 
    static const bool single_value = true;
 
-   BOOST_CONTAINER_FORCEINLINE explicit insert_copy_proxy(const value_type &v)
+   inline explicit insert_copy_proxy(const value_type &v)
       :  v_(v)
    {}
 
    template<class Iterator>
-   BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const
+   inline void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const
    {
       BOOST_ASSERT(n == 1);  (void)n;
       alloc_traits::construct( a, boost::movelib::iterator_to_raw_pointer(p), v_);
    }
 
    template<class Iterator>
-   BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &, Iterator p, std::size_t n) const
+   inline void copy_n_and_update(Allocator &, Iterator p, std::size_t n) const
    {
       BOOST_ASSERT(n == 1);  (void)n;
       *p = v_;
@@ -214,19 +213,19 @@ struct insert_move_proxy
 
    static const bool single_value = true;
 
-   BOOST_CONTAINER_FORCEINLINE explicit insert_move_proxy(value_type &v)
+   inline explicit insert_move_proxy(value_type &v)
       :  v_(v)
    {}
 
    template<class Iterator>
-   BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const
+   inline void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const
    {
       BOOST_ASSERT(n == 1);  (void)n;
       alloc_traits::construct( a, boost::movelib::iterator_to_raw_pointer(p), ::boost::move(v_) );
    }
 
    template<class Iterator>
-   BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &, Iterator p, std::size_t n) const
+   inline void copy_n_and_update(Allocator &, Iterator p, std::size_t n) const
    {
       BOOST_ASSERT(n == 1);  (void)n;
       *p = ::boost::move(v_);
@@ -236,13 +235,13 @@ struct insert_move_proxy
 };
 
 template<class It, class Allocator>
-BOOST_CONTAINER_FORCEINLINE insert_move_proxy<Allocator> get_insert_value_proxy(BOOST_RV_REF(typename boost::container::iterator_traits<It>::value_type) v)
+inline insert_move_proxy<Allocator> get_insert_value_proxy(BOOST_RV_REF(typename boost::container::iterator_traits<It>::value_type) v)
 {
    return insert_move_proxy<Allocator>(v);
 }
 
 template<class It, class Allocator>
-BOOST_CONTAINER_FORCEINLINE insert_copy_proxy<Allocator> get_insert_value_proxy(const typename boost::container::iterator_traits<It>::value_type &v)
+inline insert_copy_proxy<Allocator> get_insert_value_proxy(const typename boost::container::iterator_traits<It>::value_type &v)
 {
    return insert_copy_proxy<Allocator>(v);
 }
@@ -267,17 +266,17 @@ struct insert_nonmovable_emplace_proxy
 
    static const bool single_value = true;
 
-   BOOST_CONTAINER_FORCEINLINE explicit insert_nonmovable_emplace_proxy(BOOST_FWD_REF(Args)... args)
+   inline explicit insert_nonmovable_emplace_proxy(BOOST_FWD_REF(Args)... args)
       : args_(args...)
    {}
 
    template<class Iterator>
-   BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n)
+   inline void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n)
    {  this->priv_uninitialized_copy_some_and_update(a, index_tuple_t(), p, n);  }
 
    private:
    template<std::size_t ...IdxPack, class Iterator>
-   BOOST_CONTAINER_FORCEINLINE void priv_uninitialized_copy_some_and_update(Allocator &a, const index_tuple<IdxPack...>&, Iterator p, std::size_t n)
+   inline void priv_uninitialized_copy_some_and_update(Allocator &a, const index_tuple<IdxPack...>&, Iterator p, std::size_t n)
    {
       BOOST_ASSERT(n == 1); (void)n;
       alloc_traits::construct( a, boost::movelib::iterator_to_raw_pointer(p), ::boost::forward<Args>(get<IdxPack>(this->args_))... );
@@ -298,31 +297,31 @@ struct insert_emplace_proxy
 
    static const bool single_value = true;
 
-   BOOST_CONTAINER_FORCEINLINE explicit insert_emplace_proxy(BOOST_FWD_REF(Args)... args)
+   inline explicit insert_emplace_proxy(BOOST_FWD_REF(Args)... args)
       : base_t(::boost::forward<Args>(args)...)
    {}
 
    template<class Iterator>
-   BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &a, Iterator p, std::size_t n)
+   inline void copy_n_and_update(Allocator &a, Iterator p, std::size_t n)
    {  this->priv_copy_some_and_update(a, index_tuple_t(), p, n);  }
 
    private:
 
    template<std::size_t ...IdxPack, class Iterator>
-   BOOST_CONTAINER_FORCEINLINE void priv_copy_some_and_update(Allocator &a, const index_tuple<IdxPack...>&, Iterator p, std::size_t n)
+   inline void priv_copy_some_and_update(Allocator &a, const index_tuple<IdxPack...>&, Iterator p, std::size_t n)
    {
       BOOST_ASSERT(n ==1); (void)n;
       typename dtl::aligned_storage<sizeof(value_type), dtl::alignment_of<value_type>::value>::type v;
       alloc_traits::construct(a, move_detail::force_ptr<value_type *>(&v), ::boost::forward<Args>(get<IdxPack>(this->args_))...);
       value_type *vp = move_detail::force_ptr<value_type *>(&v);
-      BOOST_TRY{
+      BOOST_CONTAINER_TRY{
          *p = ::boost::move(*vp);
       }
-      BOOST_CATCH(...){
+      BOOST_CONTAINER_CATCH(...){
          alloc_traits::destroy(a, vp);
-         BOOST_RETHROW
+         BOOST_CONTAINER_RETHROW
       }
-      BOOST_CATCH_END
+      BOOST_CONTAINER_CATCH_END
       alloc_traits::destroy(a, vp);
    }
 };
@@ -334,7 +333,7 @@ struct insert_emplace_proxy<Allocator, typename boost::container::allocator_trai
 {
    static const bool single_value = true;
 
-   BOOST_CONTAINER_FORCEINLINE explicit insert_emplace_proxy(typename boost::container::allocator_traits<Allocator>::value_type &&v)
+   inline explicit insert_emplace_proxy(typename boost::container::allocator_traits<Allocator>::value_type &&v)
    : insert_move_proxy<Allocator>(v)
    {}
 };
@@ -351,7 +350,7 @@ struct insert_emplace_proxy<Allocator
 
    static const bool single_value = true;
 
-   BOOST_CONTAINER_FORCEINLINE explicit insert_emplace_proxy(const typename boost::container::allocator_traits<Allocator>::value_type &v)
+   inline explicit insert_emplace_proxy(const typename boost::container::allocator_traits<Allocator>::value_type &v)
    : insert_copy_proxy<Allocator>(v)
    {}
 };
@@ -362,7 +361,7 @@ struct insert_emplace_proxy<Allocator, typename boost::container::allocator_trai
 {
    static const bool single_value = true;
 
-   BOOST_CONTAINER_FORCEINLINE explicit insert_emplace_proxy(const typename boost::container::allocator_traits<Allocator>::value_type &v)
+   inline explicit insert_emplace_proxy(const typename boost::container::allocator_traits<Allocator>::value_type &v)
    : insert_copy_proxy<Allocator>(v)
    {}
 };
@@ -375,7 +374,7 @@ struct insert_emplace_proxy<Allocator
 {
    static const bool single_value = true;
 
-   BOOST_CONTAINER_FORCEINLINE explicit insert_emplace_proxy(const typename boost::container::allocator_traits<Allocator>::value_type &v)
+   inline explicit insert_emplace_proxy(const typename boost::container::allocator_traits<Allocator>::value_type &v)
    : insert_copy_proxy<Allocator>(v)
    {}
 };
@@ -399,18 +398,18 @@ struct insert_nonmovable_emplace_proxy##N\
    \
    static const bool single_value = true;\
    \
-   BOOST_CONTAINER_FORCEINLINE explicit insert_nonmovable_emplace_proxy##N(BOOST_MOVE_UREF##N)\
+   inline explicit insert_nonmovable_emplace_proxy##N(BOOST_MOVE_UREF##N)\
       BOOST_MOVE_COLON##N BOOST_MOVE_FWD_INIT##N {}\
    \
    template<class Iterator>\
-   BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n)\
+   inline void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n)\
    {\
       BOOST_ASSERT(n == 1); (void)n;\
       alloc_traits::construct(a, boost::movelib::iterator_to_raw_pointer(p) BOOST_MOVE_I##N BOOST_MOVE_MFWD##N);\
    }\
    \
    template<class Iterator>\
-   BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &, Iterator, std::size_t)\
+   inline void copy_n_and_update(Allocator &, Iterator, std::size_t)\
    {  BOOST_ASSERT(false);   }\
    \
    protected:\
@@ -428,24 +427,24 @@ struct insert_emplace_proxy_arg##N\
    \
    static const bool single_value = true;\
    \
-   BOOST_CONTAINER_FORCEINLINE explicit insert_emplace_proxy_arg##N(BOOST_MOVE_UREF##N)\
+   inline explicit insert_emplace_proxy_arg##N(BOOST_MOVE_UREF##N)\
       : base_t(BOOST_MOVE_FWD##N){}\
    \
    template<class Iterator>\
-   BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &a, Iterator p, std::size_t n)\
+   inline void copy_n_and_update(Allocator &a, Iterator p, std::size_t n)\
    {\
       BOOST_ASSERT(n == 1); (void)n;\
       typename dtl::aligned_storage<sizeof(value_type), dtl::alignment_of<value_type>::value>::type v;\
       alloc_traits::construct(a, move_detail::force_ptr<value_type *>(&v) BOOST_MOVE_I##N BOOST_MOVE_MFWD##N);\
       value_type *vp = move_detail::force_ptr<value_type *>(&v);\
-      BOOST_TRY{\
+      BOOST_CONTAINER_TRY{\
          *p = ::boost::move(*vp);\
       }\
-      BOOST_CATCH(...){\
+      BOOST_CONTAINER_CATCH(...){\
          alloc_traits::destroy(a, vp);\
-         BOOST_RETHROW\
+         BOOST_CONTAINER_RETHROW\
       }\
-      BOOST_CATCH_END\
+      BOOST_CONTAINER_CATCH_END\
       alloc_traits::destroy(a, vp);\
    }\
 };\
@@ -462,7 +461,7 @@ struct insert_emplace_proxy_arg1<Allocator, ::boost::rv<typename boost::containe
 {
    static const bool single_value = true;
 
-   BOOST_CONTAINER_FORCEINLINE explicit insert_emplace_proxy_arg1(typename boost::container::allocator_traits<Allocator>::value_type &v)
+   inline explicit insert_emplace_proxy_arg1(typename boost::container::allocator_traits<Allocator>::value_type &v)
    : insert_move_proxy<Allocator>(v)
    {}
 };
@@ -473,7 +472,7 @@ struct insert_emplace_proxy_arg1<Allocator, typename boost::container::allocator
 {
    static const bool single_value = true;
 
-   BOOST_CONTAINER_FORCEINLINE explicit insert_emplace_proxy_arg1(const typename boost::container::allocator_traits<Allocator>::value_type &v)
+   inline explicit insert_emplace_proxy_arg1(const typename boost::container::allocator_traits<Allocator>::value_type &v)
    : insert_copy_proxy<Allocator>(v)
    {}
 };
@@ -487,7 +486,7 @@ struct insert_emplace_proxy_arg1<Allocator, typename boost::container::allocator
 {
    static const bool single_value = true;
 
-   BOOST_CONTAINER_FORCEINLINE explicit insert_emplace_proxy_arg1(typename boost::container::allocator_traits<Allocator>::value_type &&v)
+   inline explicit insert_emplace_proxy_arg1(typename boost::container::allocator_traits<Allocator>::value_type &&v)
    : insert_move_proxy<Allocator>(v)
    {}
 };
@@ -503,7 +502,7 @@ struct insert_emplace_proxy_arg1<Allocator
 {
    static const bool single_value = true;
 
-   BOOST_CONTAINER_FORCEINLINE explicit insert_emplace_proxy_arg1(const typename boost::container::allocator_traits<Allocator>::value_type &v)
+   inline explicit insert_emplace_proxy_arg1(const typename boost::container::allocator_traits<Allocator>::value_type &v)
    : insert_copy_proxy<Allocator>(v)
    {}
 };
@@ -514,7 +513,7 @@ struct insert_emplace_proxy_arg1<Allocator, typename boost::container::allocator
 {
    static const bool single_value = true;
 
-   BOOST_CONTAINER_FORCEINLINE explicit insert_emplace_proxy_arg1(const typename boost::container::allocator_traits<Allocator>::value_type &v)
+   inline explicit insert_emplace_proxy_arg1(const typename boost::container::allocator_traits<Allocator>::value_type &v)
    : insert_copy_proxy<Allocator>(v)
    {}
 };
@@ -527,7 +526,7 @@ struct insert_emplace_proxy_arg1<Allocator
 {
    static const bool single_value = true;
 
-   BOOST_CONTAINER_FORCEINLINE explicit insert_emplace_proxy_arg1(const typename boost::container::allocator_traits<Allocator>::value_type &v)
+   inline explicit insert_emplace_proxy_arg1(const typename boost::container::allocator_traits<Allocator>::value_type &v)
    : insert_copy_proxy<Allocator>(v)
    {}
 };

data/src/cxx_supportlib/vendor-modified/boost/container/detail/alloc_helpers.hpp

@@ -27,30 +27,30 @@ namespace container {
 namespace dtl {
 
 template<class AllocatorType>
-BOOST_CONTAINER_FORCEINLINE void swap_alloc(AllocatorType &, AllocatorType &, dtl::false_type)
+inline void swap_alloc(AllocatorType &, AllocatorType &, dtl::false_type)
    BOOST_NOEXCEPT_OR_NOTHROW
 {}
 
 template<class AllocatorType>
-BOOST_CONTAINER_FORCEINLINE void swap_alloc(AllocatorType &l, AllocatorType &r, dtl::true_type)
+inline void swap_alloc(AllocatorType &l, AllocatorType &r, dtl::true_type)
 {  boost::adl_move_swap(l, r);   }
 
 template<class AllocatorType>
-BOOST_CONTAINER_FORCEINLINE void assign_alloc(AllocatorType &, const AllocatorType &, dtl::false_type)
+inline void assign_alloc(AllocatorType &, const AllocatorType &, dtl::false_type)
    BOOST_NOEXCEPT_OR_NOTHROW
 {}
 
 template<class AllocatorType>
-BOOST_CONTAINER_FORCEINLINE void assign_alloc(AllocatorType &l, const AllocatorType &r, dtl::true_type)
+inline void assign_alloc(AllocatorType &l, const AllocatorType &r, dtl::true_type)
 {  l = r;   }
 
 template<class AllocatorType>
-BOOST_CONTAINER_FORCEINLINE void move_alloc(AllocatorType &, AllocatorType &, dtl::false_type)
+inline void move_alloc(AllocatorType &, AllocatorType &, dtl::false_type)
    BOOST_NOEXCEPT_OR_NOTHROW
 {}
 
 template<class AllocatorType>
-BOOST_CONTAINER_FORCEINLINE void move_alloc(AllocatorType &l, AllocatorType &r, dtl::true_type)
+inline void move_alloc(AllocatorType &l, AllocatorType &r, dtl::true_type)
 {  l = ::boost::move(r);   }
 
 }  //namespace dtl {

data/src/cxx_supportlib/vendor-modified/boost/container/detail/allocator_version_traits.hpp

@@ -29,7 +29,6 @@
 #include <boost/container/detail/allocation_type.hpp>       //allocation_type
 #include <boost/container/detail/mpl.hpp>                   //integral_constant
 #include <boost/intrusive/pointer_traits.hpp>               //pointer_traits
-#include <boost/core/no_exceptions_support.hpp>             //BOOST_TRY
 
 namespace boost {
 namespace container {
@@ -47,19 +46,19 @@ struct allocator_version_traits
    typedef typename boost::container::allocator_traits<Allocator>::size_type  size_type;
 
    //Node allocation interface
-   static pointer allocate_one(Allocator &a)
+   inline static pointer allocate_one(Allocator &a)
    {  return a.allocate_one();   }
 
-   static void deallocate_one(Allocator &a, const pointer &p)
+   inline static void deallocate_one(Allocator &a, const pointer &p)
    {  a.deallocate_one(p);   }
 
-   static void allocate_individual(Allocator &a, size_type n, multiallocation_chain &m)
+   inline static void allocate_individual(Allocator &a, size_type n, multiallocation_chain &m)
    {  return a.allocate_individual(n, m);   }
 
-   static void deallocate_individual(Allocator &a, multiallocation_chain &holder)
+   inline static void deallocate_individual(Allocator &a, multiallocation_chain &holder)
    {  a.deallocate_individual(holder);   }
 
-   static pointer allocation_command(Allocator &a, allocation_type command,
+   inline static pointer allocation_command(Allocator &a, allocation_type command,
                          size_type limit_size, size_type &prefer_in_recvd_out_size, pointer &reuse)
    {  return a.allocation_command(command, limit_size, prefer_in_recvd_out_size, reuse);  }
 };
@@ -83,10 +82,10 @@ struct allocator_version_traits<Allocator, 1>
          < multialloc_cached_counted, value_type>           multiallocation_chain;
 
    //Node allocation interface
-   static pointer allocate_one(Allocator &a)
+   inline static pointer allocate_one(Allocator &a)
    {  return a.allocate(1);   }
 
-   static void deallocate_one(Allocator &a, const pointer &p)
+   inline static void deallocate_one(Allocator &a, const pointer &p)
    {  a.deallocate(p, 1);   }
 
    static void deallocate_individual(Allocator &a, multiallocation_chain &holder)
@@ -103,17 +102,17 @@ struct allocator_version_traits<Allocator, 1>
 
    struct allocate_individual_rollback
    {
-      allocate_individual_rollback(Allocator &a, multiallocation_chain &chain)
+      inline allocate_individual_rollback(Allocator &a, multiallocation_chain &chain)
          : mr_a(a), mp_chain(&chain)
       {}
 
-      ~allocate_individual_rollback()
+      inline ~allocate_individual_rollback()
       {
          if(mp_chain)
             allocator_version_traits::deallocate_individual(mr_a, *mp_chain);
       }
 
-      void release()
+      inline void release()
       {
          mp_chain = 0;
       }
@@ -139,15 +138,15 @@ struct allocator_version_traits<Allocator, 1>
          throw_logic_error("version 1 allocator without allocate_new flag");
       }
       else{
-         BOOST_TRY{
+         BOOST_CONTAINER_TRY{
             ret = a.allocate(prefer_in_recvd_out_size);
          }
-         BOOST_CATCH(...){
+         BOOST_CONTAINER_CATCH(...){
             if(!(command & nothrow_allocation)){
-               BOOST_RETHROW
+               BOOST_CONTAINER_RETHROW
             }
          }
-         BOOST_CATCH_END
+         BOOST_CONTAINER_CATCH_END
          reuse = pointer();
       }
       return ret;

data/src/cxx_supportlib/vendor-modified/boost/container/detail/compare_functors.hpp

@@ -32,11 +32,11 @@ class equal_to_value
    const value_type &t_;
 
    public:
-   BOOST_CONTAINER_FORCEINLINE explicit equal_to_value(const value_type &t)
+   inline explicit equal_to_value(const value_type &t)
       :  t_(t)
    {}
 
-   BOOST_CONTAINER_FORCEINLINE bool operator()(const value_type &t)const
+   inline bool operator()(const value_type &t)const
    {  return t_ == t;   }
 };
 
@@ -47,39 +47,39 @@ struct value_to_node_compare
    typedef Pred predicate_type;
    typedef Node node_type;
 
-   BOOST_CONTAINER_FORCEINLINE value_to_node_compare()
+   inline value_to_node_compare()
       : Pred()
    {}
 
-   BOOST_CONTAINER_FORCEINLINE explicit value_to_node_compare(Pred pred)
+   inline explicit value_to_node_compare(Pred pred)
       :  Pred(pred)
    {}
 
-   BOOST_CONTAINER_FORCEINLINE Ret operator()(const Node &a, const Node &b) const
+   inline Ret operator()(const Node &a, const Node &b) const
    {  return static_cast<const Pred&>(*this)(a.get_data(), b.get_data());  }
 
-   BOOST_CONTAINER_FORCEINLINE Ret operator()(const Node &a) const
+   inline Ret operator()(const Node &a) const
    {  return static_cast<const Pred&>(*this)(a.get_data());  }
 
-   BOOST_CONTAINER_FORCEINLINE Ret operator()(const Node &a, const Node &b)
+   inline Ret operator()(const Node &a, const Node &b)
    {  return static_cast<Pred&>(*this)(a.get_data(), b.get_data());  }
 
-   BOOST_CONTAINER_FORCEINLINE Ret operator()(const Node &a)
+   inline Ret operator()(const Node &a)
    {  return static_cast<Pred&>(*this)(a.get_data());  }
 
-   BOOST_CONTAINER_FORCEINLINE predicate_type &       predicate()        { return static_cast<predicate_type&>(*this); }
-   BOOST_CONTAINER_FORCEINLINE const predicate_type & predicate()  const { return static_cast<predicate_type&>(*this); }
+   inline predicate_type &       predicate()        { return static_cast<predicate_type&>(*this); }
+   inline const predicate_type & predicate()  const { return static_cast<predicate_type&>(*this); }
 };
 
 template<class KeyPred, class KeyOfValue, class Node, class Ret = bool>
 struct key_node_pred
    :  public boost::intrusive::detail::ebo_functor_holder<KeyPred>
 {
-   BOOST_CONTAINER_FORCEINLINE explicit key_node_pred(const KeyPred &comp)
+   inline explicit key_node_pred(const KeyPred &comp)
       :  base_t(comp)
    {}
 
-   BOOST_CONTAINER_FORCEINLINE explicit key_node_pred()
+   inline explicit key_node_pred()
    {}
 
    typedef boost::intrusive::detail::ebo_functor_holder<KeyPred> base_t;
@@ -88,42 +88,42 @@ struct key_node_pred
    typedef typename KeyOfValue::type   key_type;
 
 
-   BOOST_CONTAINER_FORCEINLINE static const key_type &key_from(const Node &n)
+   inline static const key_type &key_from(const Node &n)
    {
       return key_of_value()(n.get_data());
    }
 
    template <class T>
-   BOOST_CONTAINER_FORCEINLINE static const T &
+   inline static const T &
       key_from(const T &t)
    {  return t;  }
 
-   BOOST_CONTAINER_FORCEINLINE const key_predicate &key_pred() const
+   inline const key_predicate &key_pred() const
    {  return static_cast<const key_predicate &>(*this);  }
 
-   BOOST_CONTAINER_FORCEINLINE key_predicate &key_pred()
+   inline key_predicate &key_pred()
    {  return static_cast<key_predicate &>(*this);  }
 
-   BOOST_CONTAINER_FORCEINLINE Ret operator()(const key_type &key) const
+   inline Ret operator()(const key_type &key) const
    {  return this->key_pred()(key);  }
 
    template<class U>
-   BOOST_CONTAINER_FORCEINLINE Ret operator()(const U &nonkey) const
+   inline Ret operator()(const U &nonkey) const
    {  return this->key_pred()(this->key_from(nonkey));  }
 
-   BOOST_CONTAINER_FORCEINLINE bool operator()(const key_type &key1, const key_type &key2) const
+   inline bool operator()(const key_type &key1, const key_type &key2) const
    {  return this->key_pred()(key1, key2);  }
 
    template<class U>
-   BOOST_CONTAINER_FORCEINLINE bool operator()(const key_type &key1, const U &nonkey2) const
+   inline bool operator()(const key_type &key1, const U &nonkey2) const
    {  return this->key_pred()(key1, this->key_from(nonkey2));  }
 
    template<class U>
-   BOOST_CONTAINER_FORCEINLINE bool operator()(const U &nonkey1, const key_type &key2) const
+   inline bool operator()(const U &nonkey1, const key_type &key2) const
    {  return this->key_pred()(this->key_from(nonkey1), key2);  }
 
    template<class U, class V>
-   BOOST_CONTAINER_FORCEINLINE bool operator()(const U &nonkey1, const V &nonkey2) const
+   inline bool operator()(const U &nonkey1, const V &nonkey2) const
    {  return this->key_pred()(this->key_from(nonkey1), this->key_from(nonkey2));  }
 };
 

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

@@ -17,6 +17,7 @@
 
 #ifdef BOOST_MSVC
    #pragma warning (push)
+   #pragma warning (disable : 4619) // there is no warning number 'XXXX'
    #pragma warning (disable : 4127) // conditional expression is constant
    #pragma warning (disable : 4146) // unary minus operator applied to unsigned type, result still unsigned
    #pragma warning (disable : 4197) // top-level volatile in cast is ignored