passenger 6.0.8 → 6.0.9

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-2020.
+// Copyright Antony Polukhin, 2011-2021.
 //
 // 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-2020.
+// Copyright Antony Polukhin, 2011-2021.
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@@ -23,7 +23,7 @@
 #   pragma once
 #endif
 
-namespace boost 
+namespace boost
 {
     namespace detail // '0', '-', '+', 'e', 'E' and '.' constants
     {

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-2020.
+// Copyright Antony Polukhin, 2011-2021.
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@@ -52,7 +52,7 @@
 #include <boost/type_traits/is_signed.hpp>
 #include <boost/noncopyable.hpp>
 
-namespace boost 
+namespace boost
 {
     namespace detail // lcast_to_unsigned
     {
@@ -60,8 +60,8 @@ namespace boost
         inline
         BOOST_DEDUCED_TYPENAME boost::make_unsigned<T>::type lcast_to_unsigned(const T value) BOOST_NOEXCEPT {
             typedef BOOST_DEDUCED_TYPENAME boost::make_unsigned<T>::type result_type;
-            return value < 0 
-                ? static_cast<result_type>(0u - static_cast<result_type>(value)) 
+            return value < 0
+                ? static_cast<result_type>(0u - static_cast<result_type>(value))
                 : static_cast<result_type>(value);
         }
     }
@@ -81,7 +81,7 @@ namespace boost
             int_type const  m_zero;
 
         public:
-            lcast_put_unsigned(const T n_param, CharT* finish) BOOST_NOEXCEPT 
+            lcast_put_unsigned(const T n_param, CharT* finish) BOOST_NOEXCEPT
                 : m_value(n_param), m_finish(finish)
                 , m_czero(lcast_char_constants<CharT>::zero), m_zero(Traits::to_int_type(m_czero))
             {
@@ -162,7 +162,7 @@ namespace boost
             T& m_value;
             const CharT* const m_begin;
             const CharT* m_end;
-    
+
         public:
             lcast_ret_unsigned(T& value, const CharT* const begin, const CharT* end) BOOST_NOEXCEPT
                 : m_multiplier_overflowed(false), m_multiplier(1), m_value(value), m_begin(begin), m_end(end)
@@ -250,7 +250,7 @@ namespace boost
             }
 
         private:
-            // Iteration that does not care about grouping/separators and assumes that all 
+            // Iteration that does not care about grouping/separators and assumes that all
             // input characters are digits
             inline bool main_convert_iteration() BOOST_NOEXCEPT {
                 CharT const czero = lcast_char_constants<CharT>::zero;
@@ -265,7 +265,7 @@ namespace boost
                 // We must correctly handle situations like `000000000000000000000000000001`.
                 // So we take care of overflow only if `dig_value` is not '0'.
                 if (*m_end < czero || *m_end >= czero + 10  // checking for correct digit
-                    || (dig_value && (                      // checking for overflow of ... 
+                    || (dig_value && (                      // checking for overflow of ...
                         m_multiplier_overflowed                             // ... multiplier
                         || static_cast<T>(maxv / dig_value) < m_multiplier  // ... subvalue
                         || static_cast<T>(maxv - new_sub_value) < m_value   // ... whole expression
@@ -273,7 +273,7 @@ namespace boost
                 ) return false;
 
                 m_value = static_cast<T>(m_value + new_sub_value);
-                
+
                 return true;
             }
 
@@ -283,7 +283,7 @@ namespace boost
                         return false;
                     }
                 }
-            
+
                 return true;
             }
         };

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-2020.
+// Copyright Antony Polukhin, 2011-2021.
 //
 // 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-2020.
+// Copyright Antony Polukhin, 2011-2021.
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@@ -81,18 +81,18 @@ namespace boost {
                     boost::is_arithmetic<Source>::value &&
                     boost::is_arithmetic<Target>::value
                 > type;
-        
+
             BOOST_STATIC_CONSTANT(bool, value = (
                 type::value
             ));
         };
 
         /*
-         * is_xchar_to_xchar<Target, Source>::value is true, 
+         * is_xchar_to_xchar<Target, Source>::value is true,
          * Target and Souce are char types of the same size 1 (char, signed char, unsigned char).
          */
         template<typename Target, typename Source>
-        struct is_xchar_to_xchar 
+        struct is_xchar_to_xchar
         {
             typedef boost::integral_constant<
                 bool,
@@ -101,7 +101,7 @@ namespace boost {
                      boost::detail::is_character<Target>::value &&
                      boost::detail::is_character<Source>::value
                 > type;
-                
+
             BOOST_STATIC_CONSTANT(bool, value = (
                 type::value
             ));

data/src/cxx_supportlib/vendor-modified/boost/libs/random/src/random_device.cpp

@@ -48,7 +48,7 @@ using namespace Windows::Security::Cryptography;
 #endif
 
 #define BOOST_AUTO_LINK_NOMANGLE
-#define BOOST_LIB_NAME "Advapi32"
+#define BOOST_LIB_NAME Advapi32
 #include <boost/config/auto_link.hpp>
 
 #ifdef __MINGW32__

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

@@ -19,9 +19,9 @@
 #define BOOST_REGEX_SOURCE
 
 #include <boost/config.hpp>
-#include <cstdio>
 #include <boost/regex.hpp>
 #include <boost/cregex.hpp>
+#include <cstdio>
 
 #if defined(BOOST_NO_STDC_NAMESPACE)
 namespace std{
@@ -269,8 +269,8 @@ BOOST_REGEX_DECL int BOOST_REGEX_CCALL regexecA(const regex_tA* expression, cons
       std::size_t i;
       for(i = 0; (i < n) && (i < expression->re_nsub + 1); ++i)
       {
-         array[i].rm_so = (m[i].matched == false) ? -1 : (m[i].first - buf);
-         array[i].rm_eo = (m[i].matched == false) ? -1 : (m[i].second - buf);
+         array[i].rm_so = m[i].matched ? (m[i].first - buf) : -1;
+         array[i].rm_eo = m[i].matched ? (m[i].second - buf) : -1;
       }
       // and set anything else to -1:
       for(i = expression->re_nsub + 1; i < n; ++i)
@@ -296,7 +296,3 @@ BOOST_REGEX_DECL void BOOST_REGEX_CCALL regfreeA(regex_tA* expression)
 }
 
 } // namespace boost
-
-
-
-

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

@@ -19,15 +19,12 @@
 
 #define BOOST_REGEX_SOURCE
 
-#include <boost/config.hpp>
-#include <new>
-#include <boost/regex.hpp>
-#include <boost/throw_exception.hpp>
+#include <boost/regex/config.hpp>
 
-#if defined(BOOST_REGEX_HAS_MS_STACK_GUARD) && defined(_MSC_VER) && (_MSC_VER >= 1300)
-#  include <malloc.h>
-#endif
 #ifdef BOOST_REGEX_HAS_MS_STACK_GUARD
+
+#include <malloc.h>
+
 #ifndef WIN32_LEAN_AND_MEAN
 #  define WIN32_LEAN_AND_MEAN
 #endif
@@ -37,78 +34,12 @@
 #define NOGDI
 #define NOUSER
 #include <windows.h>
-#endif
-
-#if defined(BOOST_REGEX_NON_RECURSIVE) && !defined(BOOST_REGEX_V3)
-#if BOOST_REGEX_MAX_CACHE_BLOCKS == 0
-#include <new>
-#else
-#include <boost/regex/v4/mem_block_cache.hpp>
-#endif
-#endif
+#include <stdexcept>
+#include <boost/regex/pattern_except.hpp>
+#include <boost/regex/v4/protected_call.hpp>
 
-#ifdef BOOST_INTEL
-#pragma warning(disable:383)
-#endif
-
-namespace boost{
-
-//
-// fix: these are declared out of line here to ensure
-// that dll builds contain the Virtual table for these
-// types - this ensures that exceptions can be thrown
-// from the dll and caught in an exe.
-regex_error::regex_error(const std::string& s, regex_constants::error_type err, std::ptrdiff_t pos) 
-   : std::runtime_error(s)
-   , m_error_code(err)
-   , m_position(pos) 
-{
-}
-
-regex_error::regex_error(regex_constants::error_type err) 
-   : std::runtime_error(::boost::BOOST_REGEX_DETAIL_NS::get_default_error_string(err))
-   , m_error_code(err)
-   , m_position(0) 
-{
-}
-
-regex_error::~regex_error() BOOST_NOEXCEPT_OR_NOTHROW
-{
-}
-
-void regex_error::raise()const
-{
-#ifndef BOOST_NO_EXCEPTIONS
-   ::boost::throw_exception(*this);
-#endif
-}
-
-
-
-namespace BOOST_REGEX_DETAIL_NS{
-
-BOOST_REGEX_DECL void BOOST_REGEX_CALL raise_runtime_error(const std::runtime_error& ex)
-{
-   ::boost::throw_exception(ex);
-}
-//
-// error checking API:
-//
-BOOST_REGEX_DECL void BOOST_REGEX_CALL verify_options(boost::regex::flag_type /*ef*/, match_flag_type mf)
-{
-#ifndef BOOST_REGEX_V3
-   //
-   // can't mix match_extra with POSIX matching rules:
-   //
-   if((mf & match_extra) && (mf & match_posix))
-   {
-      std::logic_error msg("Usage Error: Can't mix regular expression captures with POSIX matching rules");
-      throw_exception(msg);
-   }
-#endif
-}
-
-#ifdef BOOST_REGEX_HAS_MS_STACK_GUARD
+namespace boost {
+namespace BOOST_REGEX_DETAIL_NS {
 
 static void execute_eror()
 {
@@ -175,52 +106,10 @@ BOOST_REGEX_DECL void BOOST_REGEX_CALL reset_stack_guard_page()
    }
 #endif
 }
-#endif
-
-#if defined(BOOST_REGEX_NON_RECURSIVE) && !defined(BOOST_REGEX_V3)
-
-#if BOOST_REGEX_MAX_CACHE_BLOCKS == 0
-
-BOOST_REGEX_DECL void* BOOST_REGEX_CALL get_mem_block()
-{
-   return ::operator new(BOOST_REGEX_BLOCKSIZE);
-}
-
-BOOST_REGEX_DECL void BOOST_REGEX_CALL put_mem_block(void* p)
-{
-   ::operator delete(p);
-}
-
-#else
-
-#if defined(BOOST_REGEX_MEM_BLOCK_CACHE_LOCK_FREE)
-mem_block_cache block_cache = { { {nullptr} } } ;
-#elif defined(BOOST_HAS_THREADS)
-mem_block_cache block_cache = { 0, 0, BOOST_STATIC_MUTEX_INIT, };
-#else
-mem_block_cache block_cache = { 0, 0, };
-#endif
-
-BOOST_REGEX_DECL void* BOOST_REGEX_CALL get_mem_block()
-{
-   return block_cache.get();
-}
-
-BOOST_REGEX_DECL void BOOST_REGEX_CALL put_mem_block(void* p)
-{
-   block_cache.put(p);
 }
-
-#endif
-
+} // namspaces
 #endif
 
-} // namespace BOOST_REGEX_DETAIL_NS
-
-
-
-} // namespace boost
-
 #if defined(BOOST_RE_USE_VCL) && defined(BOOST_REGEX_DYN_LINK)
 
 int WINAPI DllEntryPoint(HINSTANCE , unsigned long , void*)

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

@@ -17,7 +17,10 @@
   */
 
 #define BOOST_REGEX_SOURCE
-#include <boost/config.hpp>
+#include <boost/regex/config.hpp>
+
+#if defined(BOOST_REGEX_CXX03)
+
 #include <boost/assert.hpp>
 
 #ifdef BOOST_HAS_THREADS
@@ -183,3 +186,4 @@ void scoped_static_mutex_lock::unlock()
 }
 
 #endif // BOOST_HAS_THREADS
+#endif

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

@@ -25,9 +25,9 @@
 #include <boost/regex.hpp>
 #include <boost/cregex.hpp>
 
-#include <cwchar>
-#include <cstring>
 #include <cstdio>
+#include <cstring>
+#include <cwchar>
 
 #ifdef BOOST_INTEL
 #pragma warning(disable:981)
@@ -284,8 +284,8 @@ BOOST_REGEX_DECL int BOOST_REGEX_CCALL regexecW(const regex_tW* expression, cons
       std::size_t i;
       for(i = 0; (i < n) && (i < expression->re_nsub + 1); ++i)
       {
-         array[i].rm_so = (m[i].matched == false) ? -1 : (m[i].first - buf);
-         array[i].rm_eo = (m[i].matched == false) ? -1 : (m[i].second - buf);
+         array[i].rm_so = m[i].matched ? (m[i].first - buf) : -1;
+         array[i].rm_eo = m[i].matched ? (m[i].second - buf) : -1;
       }
       // and set anything else to -1:
       for(i = expression->re_nsub + 1; i < n; ++i)
@@ -313,7 +313,3 @@ BOOST_REGEX_DECL void BOOST_REGEX_CCALL regfreeW(regex_tW* expression)
 } // namespace boost;
 
 #endif
-
-
-
-

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

@@ -98,16 +98,14 @@ inline void adaptive_merge_final_merge( RandIt first
                                       , typename iterator_traits<RandIt>::size_type len2
                                       , typename iterator_traits<RandIt>::size_type collected
                                       , typename iterator_traits<RandIt>::size_type l_intbuf
-                                      , typename iterator_traits<RandIt>::size_type l_block
-                                      , bool use_internal_buf
+                                      , typename iterator_traits<RandIt>::size_type //l_block
+                                      , bool //use_internal_buf
                                       , bool xbuf_used
                                       , Compare comp
                                       , XBuf & xbuf
                                       )
 {
    typedef typename iterator_traits<RandIt>::size_type size_type;
-   (void)l_block;
-   (void)use_internal_buf;
    size_type n_keys = collected-l_intbuf;
    size_type len = len1+len2;
    if (!xbuf_used || n_keys) {

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

@@ -14,6 +14,7 @@
 
 #include <boost/move/detail/config_begin.hpp>
 #include <boost/move/algo/detail/adaptive_sort_merge.hpp>
+#include <boost/core/ignore_unused.hpp>
 
 namespace boost {
 namespace movelib {
@@ -165,7 +166,7 @@ void adaptive_sort_combine_blocks
    , Compare comp
    , bool merge_left)
 {
-   (void)xbuf;
+   boost::ignore_unused(xbuf);
    typedef typename iterator_traits<RandIt>::size_type   size_type;
 
    size_type const l_reg_combined   = 2*l_prev_merged;
@@ -174,7 +175,7 @@ void adaptive_sort_combine_blocks
    size_type const n_reg_combined = len/l_reg_combined;
    RandIt combined_first = first;
 
-   (void)l_total_combined;
+   boost::ignore_unused(l_total_combined);
    BOOST_ASSERT(l_total_combined <= len);
 
    size_type const max_i = n_reg_combined + (l_irreg_combined != 0);

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

@@ -52,6 +52,7 @@
 #include <boost/move/algo/detail/heap_sort.hpp>
 #include <boost/move/algo/detail/merge.hpp>
 #include <boost/move/algo/detail/is_sorted.hpp>
+#include <boost/core/ignore_unused.hpp>
 #include <boost/assert.hpp>
 #include <boost/cstdint.hpp>
 
@@ -312,7 +313,8 @@ void merge_blocks_bufferless
    , Compare comp)
 {
    typedef typename iterator_traits<RandIt>::size_type size_type;
-   size_type const key_count = needed_keys_count(n_block_a, n_block_b); (void)key_count;
+   size_type const key_count = needed_keys_count(n_block_a, n_block_b);
+   ::boost::ignore_unused(key_count);
    //BOOST_ASSERT(n_block_a || n_block_b);
    BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(boost::movelib::is_sorted_and_unique(key_first, key_first + key_count, key_comp));
    BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(!n_block_b || n_block_a == count_if_with(key_first, key_first + key_count, key_comp, key_first[n_block_a]));
@@ -602,7 +604,8 @@ void unstable_sort( RandIt first, RandIt last
                     , Comp comp
                     , XBuf & xbuf)
 {
-   heap_sort(first, last, comp);(void)xbuf;
+   heap_sort(first, last, comp);
+   ::boost::ignore_unused(xbuf);
 }
 
 template<class RandIt, class Compare, class XBuf>
@@ -943,13 +946,15 @@ OutputIt op_merge_blocks_with_irreg
       max_check = min_value<size_type>(max_value<size_type>(max_check, next_key_idx+size_type(2)), n_block_left);
       RandIt const last_reg  = first_reg + l_block;
       RandIt first_min = first_reg + next_key_idx*l_block;
-      RandIt const last_min  = first_min + l_block; (void)last_min;
+      RandIt const last_min  = first_min + l_block;
+      boost::ignore_unused(last_min);
 
       BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(boost::movelib::is_sorted(first_reg, last_reg, comp));
       BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(!next_key_idx || boost::movelib::is_sorted(first_min, last_min, comp));
       BOOST_MOVE_ADAPTIVE_SORT_INVARIANT((!next_key_idx || !comp(*first_reg, *first_min )));
 
-      OutputIt orig_dest = dest; (void)orig_dest;
+      OutputIt orig_dest = dest;
+      boost::ignore_unused(orig_dest);
       dest = next_key_idx ? op_partial_merge_and_swap(first_irr, last_irr, first_reg, last_reg, first_min, dest, comp, op, is_stable)
                           : op_partial_merge         (first_irr, last_irr, first_reg, last_reg, dest, comp, op, is_stable);
       BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(boost::movelib::is_sorted(orig_dest, dest, comp));
@@ -995,7 +1000,9 @@ void op_merge_blocks_left
    , Compare comp, Op op)
 {
    typedef typename iterator_traits<RandIt>::size_type size_type;
-   size_type const key_count = needed_keys_count(n_block_a, n_block_b); (void)key_count;
+   size_type const key_count = needed_keys_count(n_block_a, n_block_b);
+   boost::ignore_unused(key_count);
+
 //   BOOST_ASSERT(n_block_a || n_block_b);
    BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(boost::movelib::is_sorted_and_unique(key_first, key_first + key_count, key_comp));
    BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(!n_block_b || n_block_a == count_if_with(key_first, key_first + key_count, key_comp, key_first[n_block_a]));
@@ -1023,7 +1030,9 @@ void op_merge_blocks_left
       size_type const next_key_idx = find_next_block(key_range2, key_comp, first2, l_block, min_check, max_check, comp);
       max_check = min_value<size_type>(max_value<size_type>(max_check, next_key_idx+size_type(2)), n_block_left);
       RandIt const first_min = first2 + next_key_idx*l_block;
-      RandIt const last_min  = first_min + l_block; (void)last_min;
+      RandIt const last_min  = first_min + l_block;
+
+      boost::ignore_unused(last_min);
       RandIt const last2  = first2 + l_block;
 
       BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(boost::movelib::is_sorted(first1, last1, comp));
@@ -1068,7 +1077,8 @@ void op_merge_blocks_left
             unmerged = op_partial_merge_and_save
                (buffer, buffer+(last1-first1), first2, last2, first_min, buf_beg, buf_end, comp, op, is_range1_A);
          }
-         (void)unmerged;
+
+         boost::ignore_unused(unmerged);
          BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(boost::movelib::is_sorted(first-l_block, unmerged, comp));
 
          swap_and_update_key( key_next, key_range2, key_mid, first2, last2
@@ -1126,7 +1136,8 @@ void op_merge_blocks_left
    buffer = op_merge_blocks_with_irreg
       ( key_range2, key_mid, key_comp, first2, first_irr2, last_irr2
       , buffer, l_block, n_block_left, min_check, max_check, comp, false, op);
-   buffer = op(forward_t(), first_irr2, last_irr2, buffer);(void)buffer;
+   buffer = op(forward_t(), first_irr2, last_irr2, buffer);
+   boost::ignore_unused(buffer);
    BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(boost::movelib::is_sorted(first-l_block, buffer, comp));
 }
 
@@ -1216,7 +1227,8 @@ void op_merge_blocks_with_buf
    , RandItBuf const buf_first)
 {
    typedef typename iterator_traits<RandIt>::size_type size_type;
-   size_type const key_count = needed_keys_count(n_block_a, n_block_b); (void)key_count;
+   size_type const key_count = needed_keys_count(n_block_a, n_block_b);
+   boost::ignore_unused(key_count);
    //BOOST_ASSERT(n_block_a || n_block_b);
    BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(boost::movelib::is_sorted_and_unique(key_first, key_first + key_count, key_comp));
    BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(!n_block_b || n_block_a == count_if_with(key_first, key_first + key_count, key_comp, key_first[n_block_a]));
@@ -1233,7 +1245,8 @@ void op_merge_blocks_with_buf
    RandIt first2 = last1;
    RandIt const first_irr2 = first2 + n_block_left*l_block;
    bool is_range1_A = true;
-   const size_type len = l_block * n_block_a + l_block * n_block_b + l_irreg1 + l_irreg2; (void)len;
+   const size_type len = l_block * n_block_a + l_block * n_block_b + l_irreg1 + l_irreg2;
+   boost::ignore_unused(len);
 
    RandItKeys key_range2(key_first);
 
@@ -1246,10 +1259,12 @@ void op_merge_blocks_with_buf
       size_type const next_key_idx = find_next_block(key_range2, key_comp, first2, l_block, min_check, max_check, comp);
       max_check = min_value<size_type>(max_value<size_type>(max_check, next_key_idx+size_type(2)), n_block_left);
       RandIt       first_min = first2 + next_key_idx*l_block;
-      RandIt const last_min  = first_min + l_block; (void)last_min;
+      RandIt const last_min  = first_min + l_block;
+      boost::ignore_unused(last_min);
       RandIt const last2  = first2 + l_block;
 
-      bool const buffer_empty = buffer == buffer_end; (void)buffer_empty;
+      bool const buffer_empty = buffer == buffer_end;
+      boost::ignore_unused(buffer_empty);
       BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(buffer_empty ? boost::movelib::is_sorted(first1, last1, comp) : boost::movelib::is_sorted(buffer, buffer_end, comp));
       BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(boost::movelib::is_sorted(first2, last2, comp));
       BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(!n_block_left || boost::movelib::is_sorted(first_min, last_min, comp));
@@ -1270,7 +1285,8 @@ void op_merge_blocks_with_buf
          RandIt res = op(forward_t(), buffer, buffer_end, first1);
          BOOST_MOVE_ADAPTIVE_SORT_PRINT_L2("   merge_blocks_w_fwd: ", len);
          buffer    = buffer_end = buf_first;
-         BOOST_ASSERT(buffer_empty || res == last1); (void)res;
+         BOOST_ASSERT(buffer_empty || res == last1);
+         boost::ignore_unused(res);
          //swap_and_update_key(key_next, key_range2, key_mid, first2, last2, first_min);
          buffer_end = buffer_and_update_key(key_next, key_range2, key_mid, first2, last2, first_min, buffer = buf_first, op);
          BOOST_MOVE_ADAPTIVE_SORT_PRINT_L2("   merge_blocks_w_swp: ", len);
@@ -1307,7 +1323,8 @@ void op_merge_blocks_with_buf
       last1 += l_block;
       first2 = last2;
    }
-   RandIt res = op(forward_t(), buffer, buffer_end, first1); (void)res;
+   RandIt res = op(forward_t(), buffer, buffer_end, first1);
+   boost::ignore_unused(res);
    BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(boost::movelib::is_sorted(first, res, comp));
    BOOST_MOVE_ADAPTIVE_SORT_PRINT_L2("   merge_blocks_w_fwd: ", len);