passenger 6.0.18 → 6.0.20

data/src/cxx_supportlib/vendor-modified/boost/lexical_cast/detail/converter_lexical_streams.hpp

@@ -1,6 +1,6 @@
 // Copyright Kevlin Henney, 2000-2005.
 // Copyright Alexander Nasonov, 2006-2010.
-// Copyright Antony Polukhin, 2011-2022.
+// Copyright Antony Polukhin, 2011-2023.
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@@ -38,6 +38,7 @@
 #include <boost/static_assert.hpp>
 #include <boost/detail/lcast_precision.hpp>
 #include <boost/detail/workaround.hpp>
+#include <boost/core/snprintf.hpp>
 
 #ifndef BOOST_NO_STD_LOCALE
 #   include <locale>
@@ -279,11 +280,7 @@ namespace boost {
                 using namespace std;
                 const double val_as_double = val;
                 finish = start +
-#if defined(_MSC_VER) && (_MSC_VER >= 1400) && !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)
-                    sprintf_s(begin, CharacterBufferSize,
-#else
-                    sprintf(begin,
-#endif
+                    boost::core::snprintf(begin, CharacterBufferSize,
                     "%.*g", static_cast<int>(boost::detail::lcast_get_precision<float>()), val_as_double);
                 return finish > start;
             }
@@ -291,11 +288,7 @@ namespace boost {
             bool shl_real_type(double val, char* begin) {
                 using namespace std;
                 finish = start +
-#if defined(_MSC_VER) && (_MSC_VER >= 1400) && !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)
-                    sprintf_s(begin, CharacterBufferSize,
-#else
-                    sprintf(begin,
-#endif
+                    boost::core::snprintf(begin, CharacterBufferSize,
                     "%.*g", static_cast<int>(boost::detail::lcast_get_precision<double>()), val);
                 return finish > start;
             }
@@ -304,11 +297,7 @@ namespace boost {
             bool shl_real_type(long double val, char* begin) {
                 using namespace std;
                 finish = start +
-#if defined(_MSC_VER) && (_MSC_VER >= 1400) && !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)
-                    sprintf_s(begin, CharacterBufferSize,
-#else
-                    sprintf(begin,
-#endif
+                    boost::core::snprintf(begin, CharacterBufferSize,
                     "%.*Lg", static_cast<int>(boost::detail::lcast_get_precision<long double>()), val );
                 return finish > start;
             }

data/src/cxx_supportlib/vendor-modified/boost/lexical_cast/detail/converter_numeric.hpp

@@ -1,6 +1,6 @@
 // Copyright Kevlin Henney, 2000-2005.
 // Copyright Alexander Nasonov, 2006-2010.
-// Copyright Antony Polukhin, 2011-2022.
+// Copyright Antony Polukhin, 2011-2023.
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at

data/src/cxx_supportlib/vendor-modified/boost/lexical_cast/detail/inf_nan.hpp

@@ -1,6 +1,6 @@
 // Copyright Kevlin Henney, 2000-2005.
 // Copyright Alexander Nasonov, 2006-2010.
-// Copyright Antony Polukhin, 2011-2022.
+// Copyright Antony Polukhin, 2011-2023.
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at

data/src/cxx_supportlib/vendor-modified/boost/lexical_cast/detail/is_character.hpp

@@ -1,6 +1,6 @@
 // Copyright Kevlin Henney, 2000-2005.
 // Copyright Alexander Nasonov, 2006-2010.
-// Copyright Antony Polukhin, 2011-2022.
+// Copyright Antony Polukhin, 2011-2023.
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at

data/src/cxx_supportlib/vendor-modified/boost/lexical_cast/detail/lcast_char_constants.hpp

@@ -1,6 +1,6 @@
 // Copyright Kevlin Henney, 2000-2005.
 // Copyright Alexander Nasonov, 2006-2010.
-// Copyright Antony Polukhin, 2011-2022.
+// Copyright Antony Polukhin, 2011-2023.
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at

data/src/cxx_supportlib/vendor-modified/boost/lexical_cast/detail/lcast_unsigned_converters.hpp

@@ -1,6 +1,6 @@
 // Copyright Kevlin Henney, 2000-2005.
 // Copyright Alexander Nasonov, 2006-2010.
-// Copyright Antony Polukhin, 2011-2022.
+// Copyright Antony Polukhin, 2011-2023.
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at

data/src/cxx_supportlib/vendor-modified/boost/lexical_cast/detail/widest_char.hpp

@@ -1,6 +1,6 @@
 // Copyright Kevlin Henney, 2000-2005.
 // Copyright Alexander Nasonov, 2006-2010.
-// Copyright Antony Polukhin, 2011-2022.
+// Copyright Antony Polukhin, 2011-2023.
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at

data/src/cxx_supportlib/vendor-modified/boost/lexical_cast/try_lexical_convert.hpp

@@ -1,6 +1,6 @@
 // Copyright Kevlin Henney, 2000-2005.
 // Copyright Alexander Nasonov, 2006-2010.
-// Copyright Antony Polukhin, 2011-2022.
+// Copyright Antony Polukhin, 2011-2023.
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at

data/src/cxx_supportlib/vendor-modified/boost/lexical_cast.hpp

@@ -1,6 +1,6 @@
 // Copyright Kevlin Henney, 2000-2005.
 // Copyright Alexander Nasonov, 2006-2010.
-// Copyright Antony Polukhin, 2011-2022.
+// Copyright Antony Polukhin, 2011-2023.
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@@ -23,6 +23,24 @@
 #   pragma once
 #endif
 
+#include <boost/config/pragma_message.hpp>
+#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES) || \
+    defined(BOOST_NO_CXX11_AUTO_DECLARATIONS) || \
+    defined(BOOST_NO_CXX11_CONSTEXPR) || \
+    defined(BOOST_NO_CXX11_NULLPTR) || \
+    defined(BOOST_NO_CXX11_NOEXCEPT) || \
+    defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) || \
+    defined(BOOST_NO_CXX11_FINAL) || \
+    defined(BOOST_NO_CXX11_ALIGNOF) || \
+    defined(BOOST_NO_CXX11_STATIC_ASSERT) || \
+    defined(BOOST_NO_CXX11_SMART_PTR) || \
+    defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) || \
+    defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)
+
+BOOST_PRAGMA_MESSAGE("C++03 support is deprecated in Boost.LexicalCast 1.82 and will be removed in Boost.LexicalCast 1.84.")
+
+#endif
+
 #if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_WSTRING)
 #define BOOST_LCAST_NO_WCHAR_T
 #endif

data/src/cxx_supportlib/vendor-modified/boost/libs/regex/src/posix_api.cpp

@@ -18,19 +18,19 @@
 
 #define BOOST_REGEX_SOURCE
 
-#include <boost/config.hpp>
 #include <boost/regex.hpp>
 #include <boost/cregex.hpp>
 #include <cstdio>
 
-#if defined(BOOST_NO_STDC_NAMESPACE)
-namespace std{
-   using ::sprintf;
-   using ::strcpy;
-   using ::strcmp;
-}
+#ifndef BOOST_WORKAROUND
+#define BOOST_WORKAROUND(x, y) false
 #endif
 
+#ifndef BOOST_REGEX_STANDALONE
+#include <boost/core/snprintf.hpp>
+#else
+namespace boost { namespace core { using std::snprintf; } }
+#endif
 
 namespace boost{
 
@@ -87,7 +87,7 @@ BOOST_REGEX_DECL int BOOST_REGEX_CCALL regcompA(regex_tA* expression, const char
       return REG_E_MEMORY;
 #endif
    // set default flags:
-   boost::uint_fast32_t flags = (f & REG_PERLEX) ? 0 : ((f & REG_EXTENDED) ? regex::extended : regex::basic);
+   unsigned flags = (f & REG_PERLEX) ? 0 : ((f & REG_EXTENDED) ? regex::extended : regex::basic);
    expression->eflags = (f & REG_NEWLINE) ? match_not_dot_newline : match_default;
    // and translate those that are actually set:
 
@@ -176,11 +176,7 @@ BOOST_REGEX_DECL regsize_t BOOST_REGEX_CCALL regerrorA(int code, const regex_tA*
             // We're converting an integer i to a string, and since i <= REG_E_UNKNOWN
             // a five character string is *always* large enough:
             //
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) && !defined(_WIN32_WCE) && !defined(UNDER_CE)
-            int r = (::sprintf_s)(localbuf, 5, "%d", i);
-#else
-            int r = (std::sprintf)(localbuf, "%d", i);
-#endif
+            int r = (boost::core::snprintf)(localbuf, 5, "%d", i);
             if(r < 0)
                return 0; // sprintf failed
             if(std::strlen(localbuf) < buf_size)
@@ -188,11 +184,7 @@ BOOST_REGEX_DECL regsize_t BOOST_REGEX_CCALL regerrorA(int code, const regex_tA*
             return std::strlen(localbuf) + 1;
          }
       }
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) && !defined(_WIN32_WCE) && !defined(UNDER_CE)
-      int r = (::sprintf_s)(localbuf, 5, "%d", 0);
-#else
-      int r = (std::sprintf)(localbuf, "%d", 0);
-#endif
+      int r = (boost::core::snprintf)(localbuf, 5, "%d", 0);
       if(r < 0)
          return 0; // sprintf failed
       if(std::strlen(localbuf) < buf_size)

data/src/cxx_supportlib/vendor-modified/boost/libs/regex/src/wide_posix_api.cpp

@@ -25,6 +25,16 @@
 #include <boost/regex.hpp>
 #include <boost/cregex.hpp>
 
+#ifndef BOOST_REGEX_STANDALONE
+#include <boost/core/snprintf.hpp>
+#else
+namespace boost { namespace core { using std::swprintf; } }
+#endif
+
+#ifndef BOOST_WORKAROUND
+#define BOOST_WORKAROUND(x, y) false
+#endif
+
 #include <cstdio>
 #include <cstring>
 #include <cwchar>
@@ -33,15 +43,6 @@
 #pragma warning(disable:981)
 #endif
 
-#if defined(BOOST_NO_STDC_NAMESPACE) || defined(__NetBSD__)
-namespace std{
-#  ifndef BOOST_NO_SWPRINTF
-      using ::swprintf;
-#  endif
-}
-#endif
-
-
 namespace boost{
 
 namespace {
@@ -97,7 +98,7 @@ BOOST_REGEX_DECL int BOOST_REGEX_CCALL regcompW(regex_tW* expression, const wcha
       return REG_E_MEMORY;
 #endif
    // set default flags:
-   boost::uint_fast32_t flags = (f & REG_PERLEX) ? 0 : ((f & REG_EXTENDED) ? wregex::extended : wregex::basic);
+   unsigned flags = (f & REG_PERLEX) ? 0 : ((f & REG_EXTENDED) ? wregex::extended : wregex::basic);
    expression->eflags = (f & REG_NEWLINE) ? match_not_dot_newline : match_default;
 
    // and translate those that are actually set:
@@ -177,7 +178,6 @@ BOOST_REGEX_DECL regsize_t BOOST_REGEX_CCALL regerrorW(int code, const regex_tW*
       }
       return result;
    }
-#if !defined(BOOST_NO_SWPRINTF)
    if(code == REG_ATOI)
    {
       wchar_t localbuf[5];
@@ -190,7 +190,7 @@ BOOST_REGEX_DECL regsize_t BOOST_REGEX_CCALL regerrorW(int code, const regex_tW*
 #if defined(_WIN32_WCE) && !defined(UNDER_CE)
             (std::swprintf)(localbuf, L"%d", i);
 #else
-            (std::swprintf)(localbuf, 5, L"%d", i);
+            (boost::core::swprintf)(localbuf, 5, L"%d", i);
 #endif
             if(std::wcslen(localbuf) < buf_size)
 #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) && !defined(_WIN32_WCE) && !defined(UNDER_CE)
@@ -204,7 +204,7 @@ BOOST_REGEX_DECL regsize_t BOOST_REGEX_CCALL regerrorW(int code, const regex_tW*
 #if defined(_WIN32_WCE) && !defined(UNDER_CE)
       (std::swprintf)(localbuf, L"%d", 0);
 #else
-      (std::swprintf)(localbuf, 5, L"%d", 0);
+      (boost::core::swprintf)(localbuf, 5, L"%d", 0);
 #endif
       if(std::wcslen(localbuf) < buf_size)
 #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) && !defined(_WIN32_WCE) && !defined(UNDER_CE)
@@ -214,7 +214,6 @@ BOOST_REGEX_DECL regsize_t BOOST_REGEX_CCALL regerrorW(int code, const regex_tW*
 #endif
       return std::wcslen(localbuf) + 1;
    }
-#endif
    if(code <= (int)REG_E_UNKNOWN)
    {
       std::string p;

data/src/cxx_supportlib/vendor-modified/boost/limits.hpp

@@ -59,8 +59,8 @@ namespace std
       BOOST_STATIC_CONSTANT(bool, is_integer = true);
       BOOST_STATIC_CONSTANT(bool, is_exact = true);
       BOOST_STATIC_CONSTANT(int, radix = 2);
-      static BOOST_LLT epsilon() throw() { return 0; };
-      static BOOST_LLT round_error() throw() { return 0; };
+      static BOOST_LLT epsilon() BOOST_NOEXCEPT_OR_NOTHROW { return 0; };
+      static BOOST_LLT round_error() BOOST_NOEXCEPT_OR_NOTHROW { return 0; };
 
       BOOST_STATIC_CONSTANT(int, min_exponent = 0);
       BOOST_STATIC_CONSTANT(int, min_exponent10 = 0);
@@ -72,10 +72,10 @@ namespace std
       BOOST_STATIC_CONSTANT(bool, has_signaling_NaN = false);
       BOOST_STATIC_CONSTANT(bool, has_denorm = false);
       BOOST_STATIC_CONSTANT(bool, has_denorm_loss = false);
-      static BOOST_LLT infinity() throw() { return 0; };
-      static BOOST_LLT quiet_NaN() throw() { return 0; };
-      static BOOST_LLT signaling_NaN() throw() { return 0; };
-      static BOOST_LLT denorm_min() throw() { return 0; };
+      static BOOST_LLT infinity() BOOST_NOEXCEPT_OR_NOTHROW { return 0; };
+      static BOOST_LLT quiet_NaN() BOOST_NOEXCEPT_OR_NOTHROW { return 0; };
+      static BOOST_LLT signaling_NaN() BOOST_NOEXCEPT_OR_NOTHROW { return 0; };
+      static BOOST_LLT denorm_min() BOOST_NOEXCEPT_OR_NOTHROW { return 0; };
 
       BOOST_STATIC_CONSTANT(bool, is_iec559 = false);
       BOOST_STATIC_CONSTANT(bool, is_bounded = true);
@@ -112,8 +112,8 @@ namespace std
       BOOST_STATIC_CONSTANT(bool, is_integer = true);
       BOOST_STATIC_CONSTANT(bool, is_exact = true);
       BOOST_STATIC_CONSTANT(int, radix = 2);
-      static BOOST_ULLT epsilon() throw() { return 0; };
-      static BOOST_ULLT round_error() throw() { return 0; };
+      static BOOST_ULLT epsilon() BOOST_NOEXCEPT_OR_NOTHROW { return 0; };
+      static BOOST_ULLT round_error() BOOST_NOEXCEPT_OR_NOTHROW { return 0; };
 
       BOOST_STATIC_CONSTANT(int, min_exponent = 0);
       BOOST_STATIC_CONSTANT(int, min_exponent10 = 0);
@@ -125,10 +125,10 @@ namespace std
       BOOST_STATIC_CONSTANT(bool, has_signaling_NaN = false);
       BOOST_STATIC_CONSTANT(bool, has_denorm = false);
       BOOST_STATIC_CONSTANT(bool, has_denorm_loss = false);
-      static BOOST_ULLT infinity() throw() { return 0; };
-      static BOOST_ULLT quiet_NaN() throw() { return 0; };
-      static BOOST_ULLT signaling_NaN() throw() { return 0; };
-      static BOOST_ULLT denorm_min() throw() { return 0; };
+      static BOOST_ULLT infinity() BOOST_NOEXCEPT_OR_NOTHROW { return 0; };
+      static BOOST_ULLT quiet_NaN() BOOST_NOEXCEPT_OR_NOTHROW { return 0; };
+      static BOOST_ULLT signaling_NaN() BOOST_NOEXCEPT_OR_NOTHROW { return 0; };
+      static BOOST_ULLT denorm_min() BOOST_NOEXCEPT_OR_NOTHROW { return 0; };
 
       BOOST_STATIC_CONSTANT(bool, is_iec559 = false);
       BOOST_STATIC_CONSTANT(bool, is_bounded = true);

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

@@ -14,6 +14,7 @@
 
 #include <boost/move/detail/config_begin.hpp>
 #include <boost/move/algo/detail/adaptive_sort_merge.hpp>
+#include <cassert>
 
 #if defined(BOOST_CLANG) || (defined(BOOST_GCC) && (BOOST_GCC >= 40600))
 #pragma GCC diagnostic push
@@ -53,7 +54,7 @@ inline void adaptive_merge_combine_blocks( RandIt first
          if(xbuf.size() < l_block){
             xbuf.initialize_until(l_block, *first);
          }
-         BOOST_ASSERT(xbuf.size() >= l_block);
+         assert(xbuf.size() >= l_block);
          size_type n_block_a, n_block_b, l_irreg1, l_irreg2;
          combine_params( keys, comp, l_combine
                            , l_combine1, l_block, xbuf
@@ -91,7 +92,7 @@ inline void adaptive_merge_combine_blocks( RandIt first
                      , l_combine1, l_block, xbuf
                      , n_block_a, n_block_b, l_irreg1, l_irreg2, true);   //Outputs
       BOOST_MOVE_ADAPTIVE_SORT_PRINT_L2("   A combine: ", len);
-      BOOST_ASSERT(xbuf.size() >= l_block);
+      assert(xbuf.size() >= l_block);
       op_merge_blocks_with_buf
          (uint_keys, less(), first, l_block, l_irreg1, n_block_a, n_block_b, l_irreg2, comp, move_op(), xbuf.data());
       xbuf.clear();
@@ -163,7 +164,7 @@ inline SizeType adaptive_merge_n_keys_intbuf(SizeType &rl_block, SizeType len1,
 
    //This is the minimum number of keys to implement the ideal algorithm
    size_type n_keys = adaptive_merge_n_keys_without_external_keys(l_block, len1, len2, l_intbuf);
-   BOOST_ASSERT(n_keys >= ((len1-l_intbuf-n_keys)/l_block + len2/l_block));
+   assert(n_keys >= ((len1-l_intbuf-n_keys)/l_block + len2/l_block));
 
    if(xbuf.template supports_aligned_trailing<size_type>
       ( l_block

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

@@ -15,7 +15,7 @@
 #include <boost/move/detail/config_begin.hpp>
 
 #include <boost/move/algo/detail/adaptive_sort_merge.hpp>
-#include <boost/core/ignore_unused.hpp>
+#include <cassert>
 
 #if defined(BOOST_CLANG) || (defined(BOOST_GCC) && (BOOST_GCC >= 40600))
 #pragma GCC diagnostic push
@@ -93,8 +93,8 @@ typename iter_size<RandIt>::type
       , Compare comp)
 {
    typedef typename iter_size<RandIt>::type       size_type;
-   BOOST_ASSERT(l_build_buf <= len);
-   BOOST_ASSERT(0 == ((l_build_buf / l_base)&(l_build_buf/l_base-1)));
+   assert(l_build_buf <= len);
+   assert(0 == ((l_build_buf / l_base)&(l_build_buf/l_base-1)));
 
    //Place the start pointer after the buffer
    RandIt first_block = first + l_build_buf;
@@ -105,7 +105,7 @@ typename iter_size<RandIt>::type
    //////////////////////////////////
    size_type l_merged = 0u;
 
-   BOOST_ASSERT(l_build_buf);
+   assert(l_build_buf);
    //If there is no enough buffer for the insertion sort step, just avoid the external buffer
    size_type kbuf = min_value<size_type>(l_build_buf, size_type(xbuf.capacity()));
    kbuf = kbuf < l_base ? 0 : kbuf;
@@ -136,7 +136,7 @@ typename iter_size<RandIt>::type
    l_merged = op_merge_left_step_multiple
       (first_block-l_merged, elements_in_blocks, l_merged, l_build_buf, size_type(l_build_buf - l_merged), comp, swap_op());
 
-   BOOST_ASSERT(l_merged == l_build_buf);
+   assert(l_merged == l_build_buf);
 
    //////////////////////////////////
    // Start of merge to right step
@@ -172,7 +172,7 @@ void adaptive_sort_combine_blocks
    , Compare comp
    , bool merge_left)
 {
-   boost::ignore_unused(xbuf);
+   boost::movelib::ignore(xbuf);
    typedef typename iter_size<RandIt>::type         size_type;
 
    size_type const l_reg_combined   = size_type(2u*l_prev_merged);
@@ -181,8 +181,8 @@ void adaptive_sort_combine_blocks
    size_type const n_reg_combined = len/l_reg_combined;
    RandIt combined_first = first;
 
-   boost::ignore_unused(l_total_combined);
-   BOOST_ASSERT(l_total_combined <= len);
+   boost::movelib::ignore(l_total_combined);
+   assert(l_total_combined <= len);
 
    size_type const max_i = size_type(n_reg_combined + (l_irreg_combined != 0));
 
@@ -278,9 +278,9 @@ bool adaptive_sort_combine_all_blocks
       //Otherwise, just give up and and use all keys to merge using rotations (use_internal_buf = false)
       bool use_internal_buf = false;
       size_type const l_block = lblock_for_combine(l_intbuf, n_keys, size_type(2*l_merged), use_internal_buf);
-      BOOST_ASSERT(!l_intbuf || (l_block == l_intbuf));
-      BOOST_ASSERT(n == 0 || (!use_internal_buf || prev_use_internal_buf) );
-      BOOST_ASSERT(n == 0 || (!use_internal_buf || l_prev_block == l_block) );
+      assert(!l_intbuf || (l_block == l_intbuf));
+      assert(n == 0 || (!use_internal_buf || prev_use_internal_buf) );
+      assert(n == 0 || (!use_internal_buf || l_prev_block == l_block) );
       
       bool const is_merge_left = (n&1) == 0;
       size_type const l_total_combined = calculate_total_combined(l_data, l_merged);
@@ -332,7 +332,7 @@ bool adaptive_sort_combine_all_blocks
       l_prev_block = l_block;
       prev_use_internal_buf = use_internal_buf;
    }
-   BOOST_ASSERT(l_prev_total_combined == l_data);
+   assert(l_prev_total_combined == l_data);
    bool const buffer_right = prev_use_internal_buf && prev_merge_left;
 
    l_intbuf = prev_use_internal_buf ? l_prev_block : 0u;
@@ -359,7 +359,7 @@ void adaptive_sort_final_merge( bool buffer_right
                               , XBuf & xbuf
                               , Compare comp)
 {
-   //BOOST_ASSERT(n_keys || xbuf.size() == l_intbuf);
+   //assert(n_keys || xbuf.size() == l_intbuf);
    xbuf.clear();
 
    typedef typename iter_size<RandIt>::type         size_type;
@@ -423,7 +423,7 @@ bool adaptive_sort_build_params
       --n_min_ideal_keys;
    }
    ++n_min_ideal_keys;
-   BOOST_ASSERT(n_min_ideal_keys <= l_intbuf);
+   assert(n_min_ideal_keys <= l_intbuf);
 
    if(xbuf.template supports_aligned_trailing<size_type>
          (l_intbuf, size_type((size_type(len-l_intbuf)-1u)/l_intbuf+1u))){
@@ -460,7 +460,7 @@ bool adaptive_sort_build_params
       //If collected keys are not enough, try to fix n_keys and l_intbuf. If no fix
       //is possible (due to very low unique keys), then go to a slow sort based on rotations.
       else{
-         BOOST_ASSERT(collected < (n_min_ideal_keys+l_intbuf));
+         assert(collected < (n_min_ideal_keys+l_intbuf));
          if(collected < 4){  //No combination possible with less that 4 keys
             return false;
          }
@@ -476,7 +476,7 @@ bool adaptive_sort_build_params
          l_intbuf = 0;
          l_build_buf = n_keys;
       }
-      BOOST_ASSERT((n_keys+l_intbuf) >= l_build_buf);
+      assert((n_keys+l_intbuf) >= l_build_buf);
    }
 
    return true;
@@ -557,7 +557,7 @@ void adaptive_sort_impl
    }
    else{
       //Make sure it is at least four
-      BOOST_STATIC_ASSERT(AdaptiveSortInsertionSortThreshold >= 4);
+      BOOST_MOVE_STATIC_ASSERT(AdaptiveSortInsertionSortThreshold >= 4);
 
       size_type l_base = 0;
       size_type l_intbuf = 0;
@@ -570,12 +570,12 @@ void adaptive_sort_impl
          stable_sort(first, first+len, comp, xbuf);
       }
       else{
-         BOOST_ASSERT(l_build_buf);
+         assert(l_build_buf);
          //Otherwise, continue the adaptive_sort
          BOOST_MOVE_ADAPTIVE_SORT_PRINT_L1("\n   After collect_unique: ", len);
          size_type const n_key_plus_buf = size_type(l_intbuf+n_keys);
          //l_build_buf is always power of two if l_intbuf is zero
-         BOOST_ASSERT(l_intbuf || (0 == (l_build_buf & (l_build_buf-1))));
+         assert(l_intbuf || (0 == (l_build_buf & (l_build_buf-1))));
 
          //Classic merge sort until internal buffer and xbuf are exhausted
          size_type const l_merged = adaptive_sort_build_blocks