passenger 6.0.14 → 6.0.27

data/src/cxx_supportlib/vendor-modified/boost/config/stdlib/libcpp.hpp

@@ -104,7 +104,7 @@
 #  define BOOST_NO_CXX98_BINDERS
 #endif
 
-#ifdef __has_include
+#if defined(__cplusplus) && defined(__has_include)
 #if __has_include(<version>)
 #include <version>
 
@@ -115,50 +115,7 @@
 #define BOOST_NO_CXX17_STD_INVOKE
 #endif
 
-#if !defined(__cpp_lib_bit_cast) || (__cpp_lib_bit_cast < 201806L) || !defined(__cpp_lib_bitops) || (__cpp_lib_bitops < 201907L) || !defined(__cpp_lib_endian) || (__cpp_lib_endian < 201907L)
-#  define BOOST_NO_CXX20_HDR_BIT
-#endif
-#if !defined(__cpp_lib_three_way_comparison) || (__cpp_lib_three_way_comparison < 201907L)
-#  define BOOST_NO_CXX20_HDR_COMPARE
-#endif
-#if !defined(__cpp_lib_ranges) || (__cpp_lib_ranges < 201911L)
-#  define BOOST_NO_CXX20_HDR_RANGES
-#endif
-#if !defined(__cpp_lib_barrier) || (__cpp_lib_barrier < 201907L)
-#  define BOOST_NO_CXX20_HDR_BARRIER
-#endif
-#if !defined(__cpp_lib_format) || (__cpp_lib_format < 201907L)
-#  define BOOST_NO_CXX20_HDR_FORMAT
-#endif
-#if !defined(__cpp_lib_source_location) || (__cpp_lib_source_location < 201907L)
-#  define BOOST_NO_CXX20_HDR_SOURCE_LOCATION
-#endif
-#if !defined(__cpp_lib_latch) || (__cpp_lib_latch < 201907L)
-#  define BOOST_NO_CXX20_HDR_SOURCE_LATCH
-#endif
-#if !defined(__cpp_lib_span) || (__cpp_lib_span < 202002L)
-#  define BOOST_NO_CXX20_HDR_SOURCE_SPAN
-#endif
-#if !defined(__cpp_lib_math_constants) || (__cpp_lib_math_constants < 201907L)
-#  define BOOST_NO_CXX20_HDR_SOURCE_NUMBERS
-#endif
-#if !defined(__cpp_lib_jthread) || (__cpp_lib_jthread < 201911L)
-#  define BOOST_NO_CXX20_HDR_SOURCE_STOP_TOKEN
-#endif
-#if !defined(__cpp_lib_concepts) || (__cpp_lib_concepts < 202002L)
-#  define BOOST_NO_CXX20_HDR_SOURCE_STOP_CONCEPTS
-#endif
-#if !defined(__cpp_lib_syncbuf) || (__cpp_lib_syncbuf < 201803L)
-#  define BOOST_NO_CXX20_HDR_SYNCSTREAM
-#endif
-#if !defined(__cpp_lib_coroutine) || (__cpp_lib_coroutine < 201902L)
-#  define BOOST_NO_CXX20_HDR_COROUTINE
-#endif
-#if !defined(__cpp_lib_semaphore) || (__cpp_lib_semaphore < 201907L)
-#  define BOOST_NO_CXX20_HDR_SEMAPHORE
-#endif
-
-#if(_LIBCPP_VERSION < 9000) && !defined(BOOST_NO_CXX20_HDR_SPAN)
+#if(_LIBCPP_VERSION < 9000)
 // as_writable_bytes is missing.
 #  define BOOST_NO_CXX20_HDR_SPAN
 #endif
@@ -211,4 +168,13 @@
 #  define BOOST_NO_CXX14_HDR_SHARED_MUTEX
 #endif
 
+#if _LIBCPP_VERSION >= 15000
+//
+// Unary function is now deprecated in C++11 and later:
+//
+#if __cplusplus >= 201103L
+#define BOOST_NO_CXX98_FUNCTION_BASE
+#endif
+#endif
+
 //  --- end ---

data/src/cxx_supportlib/vendor-modified/boost/config/stdlib/libstdcpp3.hpp

@@ -139,7 +139,18 @@
 //
 #ifdef __clang__
 
-#if __has_include(<compare>)
+#ifdef _GLIBCXX_RELEASE
+#  define BOOST_LIBSTDCXX_VERSION (_GLIBCXX_RELEASE * 10000 + 100)
+#else
+//
+// We figure out which gcc version issued this std lib
+// by checking which headers are available:
+//
+#if __has_include(<expected>)
+#  define BOOST_LIBSTDCXX_VERSION 120100
+#elif __has_include(<source_location>)
+#  define BOOST_LIBSTDCXX_VERSION 110100
+#elif __has_include(<compare>)
 #  define BOOST_LIBSTDCXX_VERSION 100100
 #elif __has_include(<memory_resource>)
 #  define BOOST_LIBSTDCXX_VERSION 90100
@@ -166,6 +177,7 @@
 #elif __has_include(<array>)
 #  define BOOST_LIBSTDCXX_VERSION 40300
 #endif
+#endif
 //
 // If BOOST_HAS_FLOAT128 is set, now that we know the std lib is libstdc++3, check to see if the std lib is
 // configured to support this type.  If not disable it:
@@ -255,7 +267,7 @@ extern "C" char *gets (char *__s);
 #     if !_GLIBCXX_DEPRECATED
 #        define BOOST_NO_AUTO_PTR
 #     endif
-#  elif !_GLIBCXX_USE_DEPRECATED
+#  elif !defined(_GLIBCXX_USE_DEPRECATED) || !_GLIBCXX_USE_DEPRECATED
 #     define BOOST_NO_AUTO_PTR
 #     define BOOST_NO_CXX98_BINDERS
 #  endif
@@ -385,6 +397,15 @@ extern "C" char *gets (char *__s);
 #define BOOST_NO_CXX20_HDR_BIT
 #endif
 
+#if BOOST_LIBSTDCXX_VERSION >= 120000
+//
+// Unary function is now deprecated in C++11 and later:
+//
+#if __cplusplus >= 201103L
+#define BOOST_NO_CXX98_FUNCTION_BASE
+#endif
+#endif
+
 #ifndef __cpp_impl_coroutine
 #  define BOOST_NO_CXX20_HDR_COROUTINE
 #endif
@@ -407,6 +428,24 @@ extern "C" char *gets (char *__s);
 #endif
 #endif
 
+#if defined(__clang__)
+#if (__clang_major__ < 11) && !defined(BOOST_NO_CXX20_HDR_RANGES)
+#  define BOOST_NO_CXX20_HDR_RANGES
+#endif
+#if (__clang_major__ < 10) && (BOOST_LIBSTDCXX_VERSION >= 110000) && !defined(BOOST_NO_CXX11_HDR_CHRONO)
+// Old clang can't parse <chrono>:
+#  define BOOST_NO_CXX11_HDR_CHRONO
+#  define BOOST_NO_CXX11_HDR_CONDITION_VARIABLE
+#endif
+#endif
+
+#if defined(__clang__) && (BOOST_LIBSTDCXX_VERSION < 40300) && !defined(BOOST_NO_CXX11_NULLPTR)
+#  define BOOST_NO_CXX11_NULLPTR
+#endif
+#if defined(__clang__) && (BOOST_LIBSTDCXX_VERSION < 40300) && defined(BOOST_HAS_INT128) && defined(__APPLE_CC__)
+#undef BOOST_HAS_INT128
+#endif
+
 //
 // Headers not present on Solaris with the Oracle compiler:
 #if defined(__SUNPRO_CC) && (__SUNPRO_CC < 0x5140)
@@ -435,7 +474,7 @@ extern "C" char *gets (char *__s);
 #  endif
 #endif
 
-#if (!defined(_GTHREAD_USE_MUTEX_TIMEDLOCK) || (_GTHREAD_USE_MUTEX_TIMEDLOCK == 0)) && !defined(BOOST_NO_CXX11_HDR_MUTEX)
+#if (!defined(_GTHREAD_USE_MUTEX_TIMEDLOCK) || (_GTHREAD_USE_MUTEX_TIMEDLOCK == 0)) && !defined(BOOST_NO_CXX11_HDR_MUTEX) && (__GNUC__ < 6)
 // Timed mutexes are not always available:
 #  define BOOST_NO_CXX11_HDR_MUTEX
 #endif

data/src/cxx_supportlib/vendor-modified/boost/config/workaround.hpp

@@ -192,6 +192,11 @@
 #else
 #define _COMPILER_VERSION_WORKAROUND_GUARD 0
 #endif
+#ifndef __clang_major__
+#define __clang_major___WORKAROUND_GUARD 1
+#else
+#define __clang_major___WORKAROUND_GUARD 0
+#endif
 
 #ifndef _RWSTD_VER
 #define _RWSTD_VER_WORKAROUND_GUARD 1
@@ -254,6 +259,12 @@
 #else
 #define BOOST_INTEL_WORKAROUND_GUARD 0
 #endif
+#ifndef BOOST_CLANG_VERSION
+#define BOOST_CLANG_VERSION_WORKAROUND_GUARD 1
+#else
+#define BOOST_CLANG_VERSION_WORKAROUND_GUARD 0
+#endif
+
 // Always define to zero, if it's used it'll be defined my MPL:
 #define BOOST_MPL_CFG_GCC_WORKAROUND_GUARD 0
 

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

@@ -31,8 +31,9 @@
 #include <boost/container/detail/singleton.hpp>
 #include <boost/container/detail/placement_new.hpp>
 
+#include <boost/move/detail/force_ptr.hpp>
+
 #include <boost/assert.hpp>
-#include <boost/static_assert.hpp>
 #include <boost/move/utility_core.hpp>
 #include <cstddef>
 
@@ -70,12 +71,12 @@ class adaptive_pool
          BOOST_CONTAINER_DOCIGN(BOOST_MOVE_I Version)
          >   self_t;
 
-   static const std::size_t nodes_per_block        = NodesPerBlock;
-   static const std::size_t max_free_blocks        = MaxFreeBlocks;
-   static const std::size_t overhead_percent       = OverheadPercent;
-   static const std::size_t real_nodes_per_block   = NodesPerBlock;
+   BOOST_STATIC_CONSTEXPR std::size_t nodes_per_block        = NodesPerBlock;
+   BOOST_STATIC_CONSTEXPR std::size_t max_free_blocks        = MaxFreeBlocks;
+   BOOST_STATIC_CONSTEXPR std::size_t overhead_percent       = OverheadPercent;
+   BOOST_STATIC_CONSTEXPR 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:
    //-------
@@ -252,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))){
@@ -263,7 +264,8 @@ class adaptive_pool
                              ,(T*)BOOST_CONTAINER_MEMCHAIN_LASTMEM(&ch)
                              ,BOOST_CONTAINER_MEMCHAIN_SIZE(&ch) );*/
       if(BOOST_UNLIKELY(!dlmalloc_multialloc_nodes
-            (n_elements, elem_size*sizeof(T), BOOST_CONTAINER_DL_MULTIALLOC_DEFAULT_CONTIGUOUS, reinterpret_cast<dlmalloc_memchain *>(&chain)))){
+            ( n_elements, elem_size*sizeof(T), BOOST_CONTAINER_DL_MULTIALLOC_DEFAULT_CONTIGUOUS
+            , move_detail::force_ptr<dlmalloc_memchain *>(&chain)))){
          boost::container::throw_bad_alloc();
       }
    }
@@ -272,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))){
@@ -283,7 +285,8 @@ class adaptive_pool
                              ,(T*)BOOST_CONTAINER_MEMCHAIN_LASTMEM(&ch)
                              ,BOOST_CONTAINER_MEMCHAIN_SIZE(&ch) );*/
       if(BOOST_UNLIKELY(!dlmalloc_multialloc_arrays
-         (n_elements, elem_sizes, sizeof(T), BOOST_CONTAINER_DL_MULTIALLOC_DEFAULT_CONTIGUOUS, reinterpret_cast<dlmalloc_memchain *>(&chain)))){
+         ( n_elements, elem_sizes, sizeof(T), BOOST_CONTAINER_DL_MULTIALLOC_DEFAULT_CONTIGUOUS
+         , move_detail::force_ptr<dlmalloc_memchain *>(&chain)))){
          boost::container::throw_bad_alloc();
       }
    }
@@ -295,7 +298,7 @@ class adaptive_pool
       size_t size(chain.size());
       BOOST_CONTAINER_MEMCHAIN_INIT_FROM(&ch, beg, last, size);
       dlmalloc_multidealloc(&ch);*/
-      dlmalloc_multidealloc(reinterpret_cast<dlmalloc_memchain *>(&chain));
+      dlmalloc_multidealloc(move_detail::force_ptr<dlmalloc_memchain *>(&chain));
    }
 
    //!Deallocates all free blocks of the pool
@@ -381,12 +384,12 @@ class private_adaptive_pool
          BOOST_CONTAINER_DOCIGN(BOOST_MOVE_I Version)
          >   self_t;
 
-   static const std::size_t nodes_per_block        = NodesPerBlock;
-   static const std::size_t max_free_blocks        = MaxFreeBlocks;
-   static const std::size_t overhead_percent       = OverheadPercent;
-   static const std::size_t real_nodes_per_block   = NodesPerBlock;
+   BOOST_STATIC_CONSTEXPR std::size_t nodes_per_block        = NodesPerBlock;
+   BOOST_STATIC_CONSTEXPR std::size_t max_free_blocks        = MaxFreeBlocks;
+   BOOST_STATIC_CONSTEXPR std::size_t overhead_percent       = OverheadPercent;
+   BOOST_STATIC_CONSTEXPR 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;
@@ -542,9 +545,10 @@ 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, reinterpret_cast<dlmalloc_memchain *>(&chain)))){
+            ( n_elements, elem_size*sizeof(T), BOOST_CONTAINER_DL_MULTIALLOC_DEFAULT_CONTIGUOUS
+            , move_detail::force_ptr<dlmalloc_memchain *>(&chain)))){
          boost::container::throw_bad_alloc();
       }
    }
@@ -553,16 +557,17 @@ 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, reinterpret_cast<dlmalloc_memchain *>(&chain)))){
+         (n_elements, elem_sizes, sizeof(T), BOOST_CONTAINER_DL_MULTIALLOC_DEFAULT_CONTIGUOUS
+         , move_detail::force_ptr<dlmalloc_memchain *>(&chain)))){
          boost::container::throw_bad_alloc();
       }
    }
 
    void deallocate_many(multiallocation_chain &chain) BOOST_NOEXCEPT_OR_NOTHROW
    {
-      dlmalloc_multidealloc(reinterpret_cast<dlmalloc_memchain *>(&chain));
+      dlmalloc_multidealloc(move_detail::force_ptr<dlmalloc_memchain *>(&chain));
    }
 
    //!Deallocates all free blocks of the pool

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

@@ -26,7 +26,9 @@
 #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>
+
 #include <cstddef>
 #include <cassert>
 
@@ -113,14 +115,14 @@ class allocator
    template<class T2, unsigned int Version2, unsigned int AllocationDisableMask2>
    allocator& operator=(const allocator<T2, Version2, AllocationDisableMask2>&);
 
-   static const unsigned int ForbiddenMask =
+   BOOST_STATIC_CONSTEXPR unsigned int ForbiddenMask =
       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
 
@@ -190,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
@@ -211,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;   }
 
@@ -224,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);
@@ -240,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);
    }
 
@@ -248,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);
    }
 
@@ -269,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);
    }
 
@@ -287,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)){
@@ -298,7 +300,8 @@ class allocator
                              ,(T*)BOOST_CONTAINER_MEMCHAIN_LASTMEM(&ch)
                              ,BOOST_CONTAINER_MEMCHAIN_SIZE(&ch) );
 /*
-      if(!dlmalloc_multialloc_nodes(n_elements, elem_size*sizeof(T), BOOST_CONTAINER_DL_MULTIALLOC_DEFAULT_CONTIGUOUS, reinterpret_cast<dlmalloc_memchain *>(&chain))){
+      if(!dlmalloc_multialloc_nodes( n_elements, elem_size*sizeof(T), BOOST_CONTAINER_DL_MULTIALLOC_DEFAULT_CONTIGUOUS
+                                   , move_detail::force_ptr<dlmalloc_memchain *>(&chain))){
          boost::container::throw_bad_alloc();
       }*/
    }
@@ -308,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)){
@@ -319,7 +322,8 @@ class allocator
                              ,(T*)BOOST_CONTAINER_MEMCHAIN_LASTMEM(&ch)
                              ,BOOST_CONTAINER_MEMCHAIN_SIZE(&ch) );
       /*
-      if(!dlmalloc_multialloc_arrays(n_elements, elem_sizes, sizeof(T), BOOST_CONTAINER_DL_MULTIALLOC_DEFAULT_CONTIGUOUS, reinterpret_cast<dlmalloc_memchain *>(&chain))){
+      if(!dlmalloc_multialloc_arrays( n_elements, elem_sizes, sizeof(T), BOOST_CONTAINER_DL_MULTIALLOC_DEFAULT_CONTIGUOUS
+                                    , move_detail::force_ptr<dlmalloc_memchain *>(&chain))){
          boost::container::throw_bad_alloc();
       }*/
    }
@@ -329,13 +333,13 @@ 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());
-      BOOST_CONTAINER_MEMCHAIN_INIT_FROM(&ch, beg, last, size);
+      size_t sz(chain.size());
+      BOOST_CONTAINER_MEMCHAIN_INIT_FROM(&ch, beg, last, sz);
       dlmalloc_multidealloc(&ch);
-      //dlmalloc_multidealloc(reinterpret_cast<dlmalloc_memchain *>(&chain));
+      //dlmalloc_multidealloc(move_detail::force_ptr<dlmalloc_memchain *>(&chain));
    }
 
    private:
@@ -347,7 +351,7 @@ class allocator
    {
       std::size_t const preferred_size = prefer_in_recvd_out_size;
       dlmalloc_command_ret_t ret = {0 , 0};
-      if((limit_size > this->max_size()) | (preferred_size > this->max_size())){
+      if((limit_size > this->max_size()) || (preferred_size > this->max_size())){
          return pointer();
       }
       std::size_t l_size = limit_size*sizeof(T);