passenger 6.0.20 → 6.0.22

data/src/cxx_supportlib/vendor-modified/boost/config/compiler/visualc.hpp

@@ -263,6 +263,9 @@
 #define BOOST_NO_CXX17_INLINE_VARIABLES
 #define BOOST_NO_CXX17_FOLD_EXPRESSIONS
 #endif
+#if (_MSC_VER < 1914) || (_MSVC_LANG < 201703)
+#define BOOST_NO_CXX17_AUTO_NONTYPE_TEMPLATE_PARAMS
+#endif
 
 //
 // Things that don't work in clr mode:
@@ -305,6 +308,10 @@
 #  define BOOST_CXX_VERSION 201402L
 #endif
 
+#if BOOST_CXX_VERSION >= 201703L
+#  define BOOST_ATTRIBUTE_UNUSED [[maybe_unused]]
+#endif
+
 #ifndef BOOST_COMPILER
 // TODO:
 // these things are mostly bogus. 1200 means version 12.0 of the compiler. The

data/src/cxx_supportlib/vendor-modified/boost/config/compiler/xlcpp.hpp

@@ -265,6 +265,10 @@
 #  define BOOST_NO_CXX17_FOLD_EXPRESSIONS
 #endif
 
+#if !defined(__cpp_nontype_template_parameter_auto) || (__cpp_nontype_template_parameter_auto < 201606)
+#  define BOOST_NO_CXX17_AUTO_NONTYPE_TEMPLATE_PARAMS
+#endif
+
 #if !__has_feature(cxx_thread_local)
 #  define BOOST_NO_CXX11_THREAD_LOCAL
 #endif

data/src/cxx_supportlib/vendor-modified/boost/config/compiler/xlcpp_zos.hpp

@@ -157,6 +157,7 @@
 #define BOOST_NO_CXX17_INLINE_VARIABLES
 #define BOOST_NO_CXX17_FOLD_EXPRESSIONS
 #define BOOST_NO_CXX17_IF_CONSTEXPR
+#define BOOST_NO_CXX17_AUTO_NONTYPE_TEMPLATE_PARAMS
 
 // -------------------------------------
 

data/src/cxx_supportlib/vendor-modified/boost/config/detail/cxx_composite.hpp

@@ -1,4 +1,4 @@
-//  This file was automatically generated on Sun Jun  5 16:50:18 2022
+//  This file was automatically generated on Fri Oct 13 19:09:38 2023
 //  by libs/config/tools/generate.cpp
 //  Copyright John Maddock 2002-21.
 //  Use, modification and distribution are subject to the 
@@ -81,6 +81,7 @@
 #if defined(BOOST_NO_CXX03)\
    || defined(BOOST_NO_CXX11_ADDRESSOF)\
    || defined(BOOST_NO_CXX11_ALIGNAS)\
+   || defined(BOOST_NO_CXX11_ALIGNOF)\
    || defined(BOOST_NO_CXX11_ALLOCATOR)\
    || defined(BOOST_NO_CXX11_AUTO_DECLARATIONS)\
    || defined(BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS)\
@@ -163,6 +164,7 @@
 #endif
 
 #if defined(BOOST_NO_CXX14)\
+   || defined(BOOST_NO_CXX17_AUTO_NONTYPE_TEMPLATE_PARAMS)\
    || defined(BOOST_NO_CXX17_DEDUCTION_GUIDES)\
    || defined(BOOST_NO_CXX17_FOLD_EXPRESSIONS)\
    || defined(BOOST_NO_CXX17_HDR_ANY)\
@@ -201,3 +203,16 @@
 #    define BOOST_NO_CXX20
 #endif
 
+#if defined(BOOST_NO_CXX20)\
+   || defined(BOOST_NO_CXX23_HDR_EXPECTED)\
+   || defined(BOOST_NO_CXX23_HDR_FLAT_MAP)\
+   || defined(BOOST_NO_CXX23_HDR_FLAT_SET)\
+   || defined(BOOST_NO_CXX23_HDR_GENERATOR)\
+   || defined(BOOST_NO_CXX23_HDR_MDSPAN)\
+   || defined(BOOST_NO_CXX23_HDR_PRINT)\
+   || defined(BOOST_NO_CXX23_HDR_SPANSTREAM)\
+   || defined(BOOST_NO_CXX23_HDR_STACKTRACE)\
+   || defined(BOOST_NO_CXX23_HDR_STDFLOAT)
+#    define BOOST_NO_CXX23
+#endif
+

data/src/cxx_supportlib/vendor-modified/boost/config/detail/suffix.hpp

@@ -1257,6 +1257,46 @@ namespace std{ using ::type_info; }
 #endif
 #endif
 
+#if (!defined(__has_include) || (BOOST_CXX_VERSION < 202003L))
+#  define BOOST_NO_CXX23_HDR_EXPECTED
+#  define BOOST_NO_CXX23_HDR_FLAT_MAP
+#  define BOOST_NO_CXX23_HDR_FLAT_SET
+#  define BOOST_NO_CXX23_HDR_GENERATOR
+#  define BOOST_NO_CXX23_HDR_MDSPAN
+#  define BOOST_NO_CXX23_HDR_PRINT
+#  define BOOST_NO_CXX23_HDR_SPANSTREAM
+#  define BOOST_NO_CXX23_HDR_STACKTRACE
+#  define BOOST_NO_CXX23_HDR_STDFLOAT
+#else
+#if (!__has_include(<expected>) || !defined(__cpp_lib_expected) || (__cpp_lib_expected < 202211L)) && !defined(BOOST_NO_CXX23_HDR_EXPECTED)
+#  define BOOST_NO_CXX23_HDR_EXPECTED
+#endif
+#if (!__has_include(<flat_map>) || !defined(__cpp_lib_flat_map) || (__cpp_lib_flat_map < 202207L)) && !defined(BOOST_NO_CXX23_HDR_FLAT_MAP)
+#  define BOOST_NO_CXX23_HDR_FLAT_MAP
+#endif
+#if (!__has_include(<flat_set>) || !defined(__cpp_lib_flat_set) || (__cpp_lib_flat_set < 202207L)) && !defined(BOOST_NO_CXX23_HDR_FLAT_SET)
+#  define BOOST_NO_CXX23_HDR_FLAT_SET
+#endif
+#if (!__has_include(<generator>) || !defined(__cpp_lib_generator) || (__cpp_lib_generator < 202207L)) && !defined(BOOST_NO_CXX23_HDR_GENERATOR)
+#  define BOOST_NO_CXX23_HDR_GENERATOR
+#endif
+#if (!__has_include(<mdspan>) || !defined(__cpp_lib_mdspan) || (__cpp_lib_mdspan < 202207L)) && !defined(BOOST_NO_CXX23_HDR_MDSPAN)
+#  define BOOST_NO_CXX23_HDR_MDSPAN
+#endif
+#if (!__has_include(<print>) || !defined(__cpp_lib_print) || (__cpp_lib_print < 202207L)) && !defined(BOOST_NO_CXX23_HDR_PRINT)
+#  define BOOST_NO_CXX23_HDR_PRINT
+#endif
+#if (!__has_include(<spanstream>) || !defined(__cpp_lib_spanstream) || (__cpp_lib_spanstream < 202106L)) && !defined(BOOST_NO_CXX23_HDR_SPANSTREAM)
+#  define BOOST_NO_CXX23_HDR_SPANSTREAM
+#endif
+#if (!__has_include(<stacktrace>) || !defined(__cpp_lib_stacktrace) || (__cpp_lib_stacktrace < 202011L)) && !defined(BOOST_NO_CXX23_HDR_STACKTRACE)
+#  define BOOST_NO_CXX23_HDR_STACKTRACE
+#endif
+#if !__has_include(<stdfloat>) && !defined(BOOST_NO_CXX23_HDR_STDFLOAT)
+#  define BOOST_NO_CXX23_HDR_STDFLOAT
+#endif
+#endif
+
 #if defined(__cplusplus) && defined(__has_include)
 #if !__has_include(<version>)
 #  define BOOST_NO_CXX20_HDR_VERSION

data/src/cxx_supportlib/vendor-modified/boost/container/adaptive_pool.hpp

@@ -34,7 +34,6 @@
 #include <boost/move/detail/force_ptr.hpp>
 
 #include <boost/assert.hpp>
-#include <boost/static_assert.hpp>
 #include <boost/move/utility_core.hpp>
 #include <cstddef>
 
@@ -77,7 +76,7 @@ class adaptive_pool
    static const std::size_t overhead_percent       = OverheadPercent;
    static const std::size_t real_nodes_per_block   = NodesPerBlock;
 
-   BOOST_CONTAINER_DOCIGN(BOOST_STATIC_ASSERT((Version <=2)));
+   BOOST_CONTAINER_DOCIGN(BOOST_CONTAINER_STATIC_ASSERT((Version <=2)));
 
    public:
    //-------
@@ -254,7 +253,7 @@ class adaptive_pool
    //!Elements must be individually deallocated with deallocate()
    void allocate_many(size_type elem_size, std::size_t n_elements, multiallocation_chain &chain)
    {
-      BOOST_STATIC_ASSERT(( Version > 1 ));/*
+      BOOST_CONTAINER_STATIC_ASSERT(( Version > 1 ));/*
       dlmalloc_memchain ch;
       BOOST_CONTAINER_MEMCHAIN_INIT(&ch);
       if(BOOST_UNLIKELY(!dlmalloc_multialloc_nodes(n_elements, elem_size*sizeof(T), BOOST_CONTAINER_DL_MULTIALLOC_DEFAULT_CONTIGUOUS, &ch))){
@@ -275,7 +274,7 @@ class adaptive_pool
    //!Elements must be individually deallocated with deallocate()
    void allocate_many(const size_type *elem_sizes, size_type n_elements, multiallocation_chain &chain)
    {
-      BOOST_STATIC_ASSERT(( Version > 1 ));/*
+      BOOST_CONTAINER_STATIC_ASSERT(( Version > 1 ));/*
       dlmalloc_memchain ch;
       BOOST_CONTAINER_MEMCHAIN_INIT(&ch);
       if(BOOST_UNLIKELY(!dlmalloc_multialloc_arrays(n_elements, elem_sizes, sizeof(T), BOOST_CONTAINER_DL_MULTIALLOC_DEFAULT_CONTIGUOUS, &ch))){
@@ -390,7 +389,7 @@ class private_adaptive_pool
    static const std::size_t overhead_percent       = OverheadPercent;
    static const std::size_t real_nodes_per_block   = NodesPerBlock;
 
-   BOOST_CONTAINER_DOCIGN(BOOST_STATIC_ASSERT((Version <=2)));
+   BOOST_CONTAINER_DOCIGN(BOOST_CONTAINER_STATIC_ASSERT((Version <=2)));
 
    typedef dtl::private_adaptive_node_pool
       <sizeof(T), NodesPerBlock, MaxFreeBlocks, OverheadPercent> pool_t;
@@ -546,7 +545,7 @@ class private_adaptive_pool
    //!Elements must be individually deallocated with deallocate()
    void allocate_many(size_type elem_size, std::size_t n_elements, multiallocation_chain &chain)
    {
-      BOOST_STATIC_ASSERT(( Version > 1 ));
+      BOOST_CONTAINER_STATIC_ASSERT(( Version > 1 ));
       if(BOOST_UNLIKELY(!dlmalloc_multialloc_nodes
             ( n_elements, elem_size*sizeof(T), BOOST_CONTAINER_DL_MULTIALLOC_DEFAULT_CONTIGUOUS
             , move_detail::force_ptr<dlmalloc_memchain *>(&chain)))){
@@ -558,7 +557,7 @@ class private_adaptive_pool
    //!Elements must be individually deallocated with deallocate()
    void allocate_many(const size_type *elem_sizes, size_type n_elements, multiallocation_chain &chain)
    {
-      BOOST_STATIC_ASSERT(( Version > 1 ));
+      BOOST_CONTAINER_STATIC_ASSERT(( Version > 1 ));
       if(BOOST_UNLIKELY(!dlmalloc_multialloc_arrays
          (n_elements, elem_sizes, sizeof(T), BOOST_CONTAINER_DL_MULTIALLOC_DEFAULT_CONTIGUOUS
          , move_detail::force_ptr<dlmalloc_memchain *>(&chain)))){

data/src/cxx_supportlib/vendor-modified/boost/container/allocator.hpp

@@ -26,7 +26,6 @@
 #include <boost/container/throw_exception.hpp>
 #include <boost/container/detail/dlmalloc.hpp>
 #include <boost/container/detail/multiallocation_chain.hpp>
-#include <boost/static_assert.hpp>
 
 #include <boost/move/detail/force_ptr.hpp>
 
@@ -120,10 +119,10 @@ class allocator
       BOOST_CONTAINER_ALLOCATE_NEW | BOOST_CONTAINER_EXPAND_BWD | BOOST_CONTAINER_EXPAND_FWD ;
 
    //The mask can't disable all the allocation types
-   BOOST_STATIC_ASSERT((  (AllocationDisableMask & ForbiddenMask) != ForbiddenMask  ));
+   BOOST_CONTAINER_STATIC_ASSERT((  (AllocationDisableMask & ForbiddenMask) != ForbiddenMask  ));
 
    //The mask is only valid for version 2 allocators
-   BOOST_STATIC_ASSERT((  Version != 1 || (AllocationDisableMask == 0)  ));
+   BOOST_CONTAINER_STATIC_ASSERT((  Version != 1 || (AllocationDisableMask == 0)  ));
 
    #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
@@ -193,17 +192,17 @@ class allocator
 
    //!Deallocates previously allocated memory.
    //!Never throws
-   BOOST_CONTAINER_FORCEINLINE void deallocate(pointer ptr, size_type) BOOST_NOEXCEPT_OR_NOTHROW
+   inline void deallocate(pointer ptr, size_type) BOOST_NOEXCEPT_OR_NOTHROW
    {  dlmalloc_free(ptr);  }
 
    //!Returns the maximum number of elements that could be allocated.
    //!Never throws
-   BOOST_CONTAINER_FORCEINLINE size_type max_size() const BOOST_NOEXCEPT_OR_NOTHROW
+   inline size_type max_size() const BOOST_NOEXCEPT_OR_NOTHROW
    {  return size_type(-1)/(2u*sizeof(T));   }
 
    //!Swaps two allocators, does nothing
    //!because this allocator is stateless
-   BOOST_CONTAINER_FORCEINLINE friend void swap(self_t &, self_t &) BOOST_NOEXCEPT_OR_NOTHROW
+   inline friend void swap(self_t &, self_t &) BOOST_NOEXCEPT_OR_NOTHROW
    {}
 
    //!An allocator always compares to true, as memory allocated with one
@@ -214,7 +213,7 @@ class allocator
 
    //!An allocator always compares to false, as memory allocated with one
    //!instance can be deallocated by another instance
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       friend bool operator!=(const allocator &, const allocator &) BOOST_NOEXCEPT_OR_NOTHROW
    {  return false;   }
 
@@ -227,7 +226,7 @@ class allocator
                          size_type &prefer_in_recvd_out_size,
                          pointer &reuse)
    {
-      BOOST_STATIC_ASSERT(( Version > 1 ));
+      BOOST_CONTAINER_STATIC_ASSERT(( Version > 1 ));
       const allocation_type mask(AllocationDisableMask);
       command &= ~mask;
       pointer ret = this->priv_allocation_command(command, limit_size, prefer_in_recvd_out_size, reuse);
@@ -243,7 +242,7 @@ class allocator
    //!This function is available only with Version == 2
    BOOST_CONTAINER_ATTRIBUTE_NODISCARD size_type size(pointer p) const BOOST_NOEXCEPT_OR_NOTHROW
    {
-      BOOST_STATIC_ASSERT(( Version > 1 ));
+      BOOST_CONTAINER_STATIC_ASSERT(( Version > 1 ));
       return dlmalloc_size(p);
    }
 
@@ -251,18 +250,18 @@ class allocator
    //!must be deallocated only with deallocate_one().
    //!Throws bad_alloc if there is no enough memory
    //!This function is available only with Version == 2
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE pointer allocate_one()
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline pointer allocate_one()
    {
-      BOOST_STATIC_ASSERT(( Version > 1 ));
+      BOOST_CONTAINER_STATIC_ASSERT(( Version > 1 ));
       return this->allocate(1);
    }
 
    //!Allocates many elements of size == 1.
    //!Elements must be individually deallocated with deallocate_one()
    //!This function is available only with Version == 2
-   BOOST_CONTAINER_FORCEINLINE void allocate_individual(std::size_t num_elements, multiallocation_chain &chain)
+   inline void allocate_individual(std::size_t num_elements, multiallocation_chain &chain)
    {
-      BOOST_STATIC_ASSERT(( Version > 1 ));
+      BOOST_CONTAINER_STATIC_ASSERT(( Version > 1 ));
       this->allocate_many(1, num_elements, chain);
    }
 
@@ -272,16 +271,16 @@ class allocator
    //Never throws
    void deallocate_one(pointer p) BOOST_NOEXCEPT_OR_NOTHROW
    {
-      BOOST_STATIC_ASSERT(( Version > 1 ));
+      BOOST_CONTAINER_STATIC_ASSERT(( Version > 1 ));
       return this->deallocate(p, 1);
    }
 
    //!Deallocates memory allocated with allocate_one() or allocate_individual().
    //!This function is available only with Version == 2
-   BOOST_CONTAINER_FORCEINLINE
+   inline
       void deallocate_individual(multiallocation_chain &chain) BOOST_NOEXCEPT_OR_NOTHROW
    {
-      BOOST_STATIC_ASSERT(( Version > 1 ));
+      BOOST_CONTAINER_STATIC_ASSERT(( Version > 1 ));
       return this->deallocate_many(chain);
    }
 
@@ -290,7 +289,7 @@ class allocator
    //!This function is available only with Version == 2
    void allocate_many(size_type elem_size, std::size_t n_elements, multiallocation_chain &chain)
    {
-      BOOST_STATIC_ASSERT(( Version > 1 ));
+      BOOST_CONTAINER_STATIC_ASSERT(( Version > 1 ));
       dlmalloc_memchain ch;
       BOOST_CONTAINER_MEMCHAIN_INIT(&ch);
       if(!dlmalloc_multialloc_nodes(n_elements, elem_size*sizeof(T), BOOST_CONTAINER_DL_MULTIALLOC_DEFAULT_CONTIGUOUS, &ch)){
@@ -312,7 +311,7 @@ class allocator
    //!This function is available only with Version == 2
    void allocate_many(const size_type *elem_sizes, size_type n_elements, multiallocation_chain &chain)
    {
-      BOOST_STATIC_ASSERT(( Version > 1 ));
+      BOOST_CONTAINER_STATIC_ASSERT(( Version > 1 ));
       dlmalloc_memchain ch;
       BOOST_CONTAINER_MEMCHAIN_INIT(&ch);
       if(!dlmalloc_multialloc_arrays(n_elements, elem_sizes, sizeof(T), BOOST_CONTAINER_DL_MULTIALLOC_DEFAULT_CONTIGUOUS, &ch)){
@@ -334,7 +333,7 @@ class allocator
    //!This function is available only with Version == 2
    void deallocate_many(multiallocation_chain &chain) BOOST_NOEXCEPT_OR_NOTHROW
    {
-      BOOST_STATIC_ASSERT(( Version > 1 ));
+      BOOST_CONTAINER_STATIC_ASSERT(( Version > 1 ));
       dlmalloc_memchain ch;
       void *beg(&*chain.begin()), *last(&*chain.last());
       size_t size(chain.size());

data/src/cxx_supportlib/vendor-modified/boost/container/allocator_traits.hpp

@@ -44,8 +44,6 @@
 #if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 #include <boost/move/detail/fwd_macros.hpp>
 #endif
-// other boost
-#include <boost/static_assert.hpp>
 
 #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
@@ -298,18 +296,18 @@ struct allocator_traits
 
    //! <b>Returns</b>: <code>a.allocate(n)</code>
    //!
-   BOOST_CONTAINER_FORCEINLINE static pointer allocate(Allocator &a, size_type n)
+   inline static pointer allocate(Allocator &a, size_type n)
    {  return a.allocate(n);  }
 
    //! <b>Returns</b>: <code>a.deallocate(p, n)</code>
    //!
    //! <b>Throws</b>: Nothing
-   BOOST_CONTAINER_FORCEINLINE static void deallocate(Allocator &a, pointer p, size_type n)
+   inline static void deallocate(Allocator &a, pointer p, size_type n)
    {  a.deallocate(p, n);  }
 
    //! <b>Effects</b>: calls <code>a.allocate(n, p)</code> if that call is well-formed;
    //! otherwise, invokes <code>a.allocate(n)</code>
-   BOOST_CONTAINER_FORCEINLINE static pointer allocate(Allocator &a, size_type n, const_void_pointer p)
+   inline static pointer allocate(Allocator &a, size_type n, const_void_pointer p)
    {
       const bool value = boost::container::dtl::
          has_member_function_callable_with_allocate
@@ -321,7 +319,7 @@ struct allocator_traits
    //! <b>Effects</b>: calls <code>a.destroy(p)</code> if that call is well-formed;
    //! otherwise, invokes <code>p->~T()</code>.
    template<class T>
-   BOOST_CONTAINER_FORCEINLINE static void destroy(Allocator &a, T*p) BOOST_NOEXCEPT_OR_NOTHROW
+   inline static void destroy(Allocator &a, T*p) BOOST_NOEXCEPT_OR_NOTHROW
    {
       typedef T* destroy_pointer;
       const bool value = boost::container::dtl::
@@ -333,7 +331,7 @@ struct allocator_traits
 
    //! <b>Returns</b>: <code>a.max_size()</code> if that expression is well-formed; otherwise,
    //! <code>numeric_limits<size_type>::max()</code>.
-   BOOST_CONTAINER_FORCEINLINE static size_type max_size(const Allocator &a) BOOST_NOEXCEPT_OR_NOTHROW
+   inline static size_type max_size(const Allocator &a) BOOST_NOEXCEPT_OR_NOTHROW
    {
       const bool value = allocator_traits_detail::has_max_size<Allocator, size_type (Allocator::*)() const>::value;
       dtl::bool_<value> flag;
@@ -342,7 +340,7 @@ struct allocator_traits
 
    //! <b>Returns</b>: <code>a.select_on_container_copy_construction()</code> if that expression is well-formed;
    //! otherwise, a.
-   BOOST_CONTAINER_FORCEINLINE static BOOST_CONTAINER_DOC1ST(Allocator,
+   inline static BOOST_CONTAINER_DOC1ST(Allocator,
       typename dtl::if_c
          < allocator_traits_detail::has_select_on_container_copy_construction<Allocator BOOST_MOVE_I Allocator (Allocator::*)() const>::value
          BOOST_MOVE_I Allocator BOOST_MOVE_I const Allocator & >::type)
@@ -358,7 +356,7 @@ struct allocator_traits
       //! <b>Effects</b>: calls <code>a.construct(p, std::forward<Args>(args)...)</code> if that call is well-formed;
       //! otherwise, invokes <code>`placement new` (static_cast<void*>(p)) T(std::forward<Args>(args)...)</code>
       template <class T, class ...Args>
-      BOOST_CONTAINER_FORCEINLINE static void construct(Allocator & a, T* p, BOOST_FWD_REF(Args)... args)
+      inline static void construct(Allocator & a, T* p, BOOST_FWD_REF(Args)... args)
       {
          static const bool value = ::boost::move_detail::and_
             < dtl::is_not_std_allocator<Allocator>
@@ -372,7 +370,7 @@ struct allocator_traits
 
    //! <b>Returns</b>: <code>a.storage_is_unpropagable(p)</code> if is_partially_propagable::value is true; otherwise,
    //! <code>false</code>.
-   BOOST_CONTAINER_FORCEINLINE static bool storage_is_unpropagable(const Allocator &a, pointer p) BOOST_NOEXCEPT_OR_NOTHROW
+   inline static bool storage_is_unpropagable(const Allocator &a, pointer p) BOOST_NOEXCEPT_OR_NOTHROW
    {
       dtl::bool_<is_partially_propagable::value> flag;
       return allocator_traits::priv_storage_is_unpropagable(flag, a, p);
@@ -380,7 +378,7 @@ struct allocator_traits
 
    //! <b>Returns</b>: <code>true</code> if <code>is_always_equal::value == true</code>, otherwise,
    //! <code>a == b</code>.
-   BOOST_CONTAINER_FORCEINLINE static bool equal(const Allocator &a, const Allocator &b) BOOST_NOEXCEPT_OR_NOTHROW
+   inline static bool equal(const Allocator &a, const Allocator &b) BOOST_NOEXCEPT_OR_NOTHROW
    {
       dtl::bool_<is_always_equal::value> flag;
       return allocator_traits::priv_equal(flag, a, b);
@@ -388,46 +386,46 @@ struct allocator_traits
 
    #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
    private:
-   BOOST_CONTAINER_FORCEINLINE static pointer priv_allocate(dtl::true_type, Allocator &a, size_type n, const_void_pointer p)
+   inline static pointer priv_allocate(dtl::true_type, Allocator &a, size_type n, const_void_pointer p)
    {  return a.allocate(n, p);  }
 
-   BOOST_CONTAINER_FORCEINLINE static pointer priv_allocate(dtl::false_type, Allocator &a, size_type n, const_void_pointer)
+   inline static pointer priv_allocate(dtl::false_type, Allocator &a, size_type n, const_void_pointer)
    {  return a.allocate(n);  }
 
    template<class T>
-   BOOST_CONTAINER_FORCEINLINE static void priv_destroy(dtl::true_type, Allocator &a, T* p) BOOST_NOEXCEPT_OR_NOTHROW
+   inline static void priv_destroy(dtl::true_type, Allocator &a, T* p) BOOST_NOEXCEPT_OR_NOTHROW
    {  a.destroy(p);  }
 
    template<class T>
-   BOOST_CONTAINER_FORCEINLINE static void priv_destroy(dtl::false_type, Allocator &, T* p) BOOST_NOEXCEPT_OR_NOTHROW
+   inline static void priv_destroy(dtl::false_type, Allocator &, T* p) BOOST_NOEXCEPT_OR_NOTHROW
    {  p->~T(); (void)p;  }
 
-   BOOST_CONTAINER_FORCEINLINE static size_type priv_max_size(dtl::true_type, const Allocator &a) BOOST_NOEXCEPT_OR_NOTHROW
+   inline static size_type priv_max_size(dtl::true_type, const Allocator &a) BOOST_NOEXCEPT_OR_NOTHROW
    {  return a.max_size();  }
 
-   BOOST_CONTAINER_FORCEINLINE static size_type priv_max_size(dtl::false_type, const Allocator &) BOOST_NOEXCEPT_OR_NOTHROW
+   inline static size_type priv_max_size(dtl::false_type, const Allocator &) BOOST_NOEXCEPT_OR_NOTHROW
    {  return size_type(-1)/sizeof(value_type);  }
 
-   BOOST_CONTAINER_FORCEINLINE static Allocator priv_select_on_container_copy_construction(dtl::true_type, const Allocator &a)
+   inline static Allocator priv_select_on_container_copy_construction(dtl::true_type, const Allocator &a)
    {  return a.select_on_container_copy_construction();  }
 
-   BOOST_CONTAINER_FORCEINLINE static const Allocator &priv_select_on_container_copy_construction(dtl::false_type, const Allocator &a) BOOST_NOEXCEPT_OR_NOTHROW
+   inline static const Allocator &priv_select_on_container_copy_construction(dtl::false_type, const Allocator &a) BOOST_NOEXCEPT_OR_NOTHROW
    {  return a;  }
 
    #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
       template<class T, class ...Args>
-      BOOST_CONTAINER_FORCEINLINE static void priv_construct(dtl::true_type, Allocator &a, T *p, BOOST_FWD_REF(Args) ...args)
+      inline static void priv_construct(dtl::true_type, Allocator &a, T *p, BOOST_FWD_REF(Args) ...args)
       {  a.construct( p, ::boost::forward<Args>(args)...);  }
 
       template<class T, class ...Args>
-      BOOST_CONTAINER_FORCEINLINE static void priv_construct(dtl::false_type, Allocator &, T *p, BOOST_FWD_REF(Args) ...args)
+      inline static void priv_construct(dtl::false_type, Allocator &, T *p, BOOST_FWD_REF(Args) ...args)
       {  ::new((void*)p, boost_container_new_t()) T(::boost::forward<Args>(args)...); }
    #else // #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
       public:
 
       #define BOOST_CONTAINER_ALLOCATOR_TRAITS_CONSTRUCT_IMPL(N) \
       template<class T BOOST_MOVE_I##N BOOST_MOVE_CLASS##N >\
-      BOOST_CONTAINER_FORCEINLINE static void construct(Allocator &a, T *p BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
+      inline static void construct(Allocator &a, T *p BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
       {\
          static const bool value = ::boost::move_detail::and_ \
             < dtl::is_not_std_allocator<Allocator> \
@@ -447,11 +445,11 @@ struct allocator_traits
       /////////////////////////////////
       #define BOOST_CONTAINER_ALLOCATOR_TRAITS_PRIV_CONSTRUCT_IMPL(N) \
       template<class T BOOST_MOVE_I##N BOOST_MOVE_CLASS##N >\
-      BOOST_CONTAINER_FORCEINLINE static void priv_construct(dtl::true_type, Allocator &a, T *p BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
+      inline static void priv_construct(dtl::true_type, Allocator &a, T *p BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
       {  a.construct( p BOOST_MOVE_I##N BOOST_MOVE_FWD##N );  }\
       \
       template<class T BOOST_MOVE_I##N BOOST_MOVE_CLASS##N >\
-      BOOST_CONTAINER_FORCEINLINE static void priv_construct(dtl::false_type, Allocator &, T *p BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
+      inline static void priv_construct(dtl::false_type, Allocator &, T *p BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
       {  ::new((void*)p, boost_container_new_t()) T(BOOST_MOVE_FWD##N); }\
       //
       BOOST_MOVE_ITERATE_0TO8(BOOST_CONTAINER_ALLOCATOR_TRAITS_PRIV_CONSTRUCT_IMPL)
@@ -460,19 +458,19 @@ struct allocator_traits
    #endif   // #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
    template<class T>
-   BOOST_CONTAINER_FORCEINLINE static void priv_construct(dtl::false_type, Allocator &, T *p, const ::boost::container::default_init_t&)
+   inline static void priv_construct(dtl::false_type, Allocator &, T *p, const ::boost::container::default_init_t&)
    {  ::new((void*)p, boost_container_new_t()) T; }
 
-   BOOST_CONTAINER_FORCEINLINE static bool priv_storage_is_unpropagable(dtl::true_type, const Allocator &a, pointer p)
+   inline static bool priv_storage_is_unpropagable(dtl::true_type, const Allocator &a, pointer p)
    {  return a.storage_is_unpropagable(p);  }
 
-   BOOST_CONTAINER_FORCEINLINE static bool priv_storage_is_unpropagable(dtl::false_type, const Allocator &, pointer)
+   inline static bool priv_storage_is_unpropagable(dtl::false_type, const Allocator &, pointer)
    {  return false;  }
 
-   BOOST_CONTAINER_FORCEINLINE static bool priv_equal(dtl::true_type,  const Allocator &, const Allocator &)
+   inline static bool priv_equal(dtl::true_type,  const Allocator &, const Allocator &)
    {  return true;  }
 
-   BOOST_CONTAINER_FORCEINLINE static bool priv_equal(dtl::false_type, const Allocator &a, const Allocator &b)
+   inline static bool priv_equal(dtl::false_type, const Allocator &a, const Allocator &b)
    {  return a == b;  }
 
    #endif   //#if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)