passenger 6.0.19 → 6.0.20

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

@@ -53,8 +53,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 <cassert>
 #include <boost/cstdint.hpp>
 #include <limits.h>
 
@@ -89,7 +88,7 @@
 #endif
 
 #ifdef BOOST_MOVE_ADAPTIVE_SORT_INVARIANTS
-   #define BOOST_MOVE_ADAPTIVE_SORT_INVARIANT  BOOST_ASSERT
+   #define BOOST_MOVE_ADAPTIVE_SORT_INVARIANT  assert
 #else
    #define BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(L)
 #endif
@@ -118,7 +117,7 @@ namespace detail_adaptive {
 
 static const std::size_t AdaptiveSortInsertionSortThreshold = 16;
 //static const std::size_t AdaptiveSortInsertionSortThreshold = 4;
-BOOST_STATIC_ASSERT((AdaptiveSortInsertionSortThreshold&(AdaptiveSortInsertionSortThreshold-1)) == 0);
+BOOST_MOVE_STATIC_ASSERT((AdaptiveSortInsertionSortThreshold&(AdaptiveSortInsertionSortThreshold-1)) == 0);
 
 #if defined BOOST_HAS_INTPTR_T
    typedef ::boost::uintptr_t uintptr_t;
@@ -291,7 +290,7 @@ typename iter_size<RandIt>::type
    typedef typename iter_size<RandIt>::type      size_type;
    typedef typename iterator_traits<RandIt>::value_type     value_type;
    typedef typename iterator_traits<RandItKeys>::value_type key_type;
-   BOOST_ASSERT(ix_first_block <= ix_last_block);
+   assert(ix_first_block <= ix_last_block);
    size_type ix_min_block = 0u;
    for (size_type szt_i = ix_first_block; szt_i < ix_last_block; ++szt_i) {
       const value_type &min_val = first[size_type(ix_min_block*l_block)];
@@ -323,8 +322,8 @@ void merge_blocks_bufferless
 {
    typedef typename iter_size<RandIt>::type size_type;
    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::movelib::ignore(key_count);
+   //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]));
 
@@ -576,7 +575,7 @@ template<class Unsigned>
 Unsigned lblock_for_combine
    (Unsigned const l_block, Unsigned const n_keys, Unsigned const l_data, bool &use_buf)
 {
-   BOOST_ASSERT(l_data > 1);
+   assert(l_data > 1);
 
    //We need to guarantee lblock >= l_merged/(n_keys/2) keys for the combination.
    //We have at least 4 keys guaranteed (which are the minimum to merge 2 ranges)
@@ -587,8 +586,8 @@ Unsigned lblock_for_combine
    if(!l_block){
       //If l_block == 0 then n_keys is power of two
       //(guaranteed by build_params(...))
-      BOOST_ASSERT(n_keys >= 4);
-      //BOOST_ASSERT(0 == (n_keys &(n_keys-1)));
+      assert(n_keys >= 4);
+      //assert(0 == (n_keys &(n_keys-1)));
 
       //See if half keys are at least 4 and if half keys fulfill
       Unsigned const new_buf  = n_keys/2;
@@ -627,7 +626,7 @@ void unstable_sort( RandIt first, RandIt last
                     , XBuf & xbuf)
 {
    heap_sort(first, last, comp);
-   ::boost::ignore_unused(xbuf);
+   ::boost::movelib::ignore(xbuf);
 }
 
 template<class RandIt, class Compare, class XBuf>
@@ -636,7 +635,7 @@ void stable_merge
       , Compare comp
       , XBuf &xbuf)
 {
-   BOOST_ASSERT(xbuf.empty());
+   assert(xbuf.empty());
    typedef typename iter_size<RandIt>::type   size_type;
    size_type const len1  = size_type(middle-first);
    size_type const len2  = size_type(last-middle);
@@ -658,7 +657,7 @@ void initialize_keys( RandIt first, RandIt last
                     , XBuf & xbuf)
 {
    unstable_sort(first, last, comp, xbuf);
-   BOOST_ASSERT(boost::movelib::is_sorted_and_unique(first, last, comp));
+   assert(boost::movelib::is_sorted_and_unique(first, last, comp));
 }
 
 template<class RandIt, class U>
@@ -712,11 +711,11 @@ void combine_params
    //Initial parameters for selection sort blocks
    l_irreg1 = size_type(l_prev_merged%l_block);
    l_irreg2 = size_type((l_combined-l_irreg1)%l_block);
-   BOOST_ASSERT(((l_combined-l_irreg1-l_irreg2)%l_block) == 0);
+   assert(((l_combined-l_irreg1-l_irreg2)%l_block) == 0);
    size_type const n_reg_block = size_type((l_combined-l_irreg1-l_irreg2)/l_block);
    n_block_a = l_prev_merged/l_block;
    n_block_b = size_type(n_reg_block - n_block_a);
-   BOOST_ASSERT(n_reg_block>=n_block_a);
+   assert(n_reg_block>=n_block_a);
 
    //Key initialization
    if (do_initialize_keys) {
@@ -907,7 +906,7 @@ RandIt op_partial_merge_and_save_impl
       first1 = last1;
    }
    else{
-      BOOST_ASSERT((last1-first1) == (buf_last1 - buf_first1));
+      assert((last1-first1) == (buf_last1 - buf_first1));
    }
 
    //Now merge from buffer
@@ -969,14 +968,14 @@ OutputIt op_merge_blocks_with_irreg
       RandIt const last_reg  = first_reg + l_block;
       RandIt first_min = first_reg + size_type(next_key_idx*l_block);
       RandIt const last_min  = first_min + l_block;
-      boost::ignore_unused(last_min);
+      boost::movelib::ignore(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;
-      boost::ignore_unused(orig_dest);
+      boost::movelib::ignore(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));
@@ -1027,9 +1026,9 @@ void op_merge_blocks_left
    typedef typename iter_size<RandIt>::type       size_type;
 
    size_type const key_count = needed_keys_count(n_block_a, n_block_b);
-   boost::ignore_unused(key_count);
+   boost::movelib::ignore(key_count);
 
-//   BOOST_ASSERT(n_block_a || n_block_b);
+//   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]));
 
@@ -1058,7 +1057,7 @@ void op_merge_blocks_left
       RandIt const first_min = first2 + size_type(next_key_idx*l_block);
       RandIt const last_min  = first_min + l_block;
 
-      boost::ignore_unused(last_min);
+      boost::movelib::ignore(last_min);
       RandIt const last2  = first2 + l_block;
 
       BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(boost::movelib::is_sorted(first1, last1, comp));
@@ -1080,7 +1079,7 @@ void op_merge_blocks_left
                                           (!is_buffer_middle && size_type(first1-buffer) == l_block && first2 == last1));
 
       if(is_range1_A == is_range2_A){
-         BOOST_ASSERT((first1 == last1) || !comp(*first_min, last1[typename iterator_traits<RandIt>::difference_type(-1)]));
+         assert((first1 == last1) || !comp(*first_min, last1[typename iterator_traits<RandIt>::difference_type(-1)]));
          if(!is_buffer_middle){
             buffer = op(forward_t(), first1, last1, buffer);
          }
@@ -1104,7 +1103,7 @@ void op_merge_blocks_left
                (buffer, buffer+(last1-first1), first2, last2, first_min, buf_beg, buf_end, comp, op, is_range1_A);
          }
 
-         boost::ignore_unused(unmerged);
+         boost::movelib::ignore(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
@@ -1133,7 +1132,7 @@ void op_merge_blocks_left
    }
 
    BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(!n_block_b || n_block_a == count_if_with(key_first, key_range2 + n_block_left, key_comp, *key_mid));
-   BOOST_ASSERT(!n_block_b_left);
+   assert(!n_block_b_left);
 
    ////////////////////////////////////////////////////////////////////////////
    //Process remaining range 1 left before the irregular B block
@@ -1167,7 +1166,7 @@ void op_merge_blocks_left
       ( 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);
-   boost::ignore_unused(buffer);
+   boost::movelib::ignore(buffer);
    BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(boost::movelib::is_sorted(first-l_block, buffer, comp));
 }
 
@@ -1259,8 +1258,8 @@ void op_merge_blocks_with_buf
 {
    typedef typename iter_size<RandIt>::type size_type;
    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::movelib::ignore(key_count);
+   //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]));
 
@@ -1277,7 +1276,7 @@ void op_merge_blocks_with_buf
    RandIt const first_irr2 = first2 + size_type(n_block_left*l_block);
    bool is_range1_A = true;
    const size_type len = size_type(l_block * n_block_a + l_block * n_block_b + l_irreg1 + l_irreg2);
-   boost::ignore_unused(len);
+   boost::movelib::ignore(len);
 
    RandItKeys key_range2(key_first);
 
@@ -1291,11 +1290,11 @@ void op_merge_blocks_with_buf
       max_check = min_value(max_value(max_check, size_type(next_key_idx+2)), n_block_left);
       RandIt       first_min = first2 + size_type(next_key_idx*l_block);
       RandIt const last_min  = first_min + l_block;
-      boost::ignore_unused(last_min);
+      boost::movelib::ignore(last_min);
       RandIt const last2  = first2 + l_block;
 
       bool const buffer_empty = buffer == buffer_end;
-      boost::ignore_unused(buffer_empty);
+      boost::movelib::ignore(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));
@@ -1316,8 +1315,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);
-         boost::ignore_unused(res);
+         assert(buffer_empty || res == last1);
+         boost::movelib::ignore(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);
@@ -1330,7 +1329,7 @@ void op_merge_blocks_with_buf
          RandIt const unmerged = op_partial_merge_and_save(first1, last1, first2, last2, first_min, buffer, buffer_end, comp, op, is_range1_A);
          BOOST_MOVE_ADAPTIVE_SORT_PRINT_L2("   merge_blocks_w_mrs: ", len);
          bool const is_range_1_empty = buffer == buffer_end;
-         BOOST_ASSERT(is_range_1_empty || (buffer_end-buffer) == (last1+l_block-unmerged));
+         assert(is_range_1_empty || (buffer_end-buffer) == (last1+l_block-unmerged));
          if(is_range_1_empty){
             buffer    = buffer_end = buf_first;
             first_min = last_min - (last2 - first2);
@@ -1349,7 +1348,7 @@ void op_merge_blocks_with_buf
          first1 = unmerged;
          BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(boost::movelib::is_sorted(first, unmerged, comp));
       }
-      BOOST_ASSERT( (is_range2_A && n_block_a_left) || (!is_range2_A && n_block_b_left));
+      assert( (is_range2_A && n_block_a_left) || (!is_range2_A && n_block_b_left));
       is_range2_A ? --n_block_a_left : --n_block_b_left;
       last1 += l_block;
       first2 = last2;
@@ -1359,7 +1358,7 @@ void op_merge_blocks_with_buf
       max_check = size_type(max_check - (max_check != 0));
    }
    RandIt res = op(forward_t(), buffer, buffer_end, first1);
-   boost::ignore_unused(res);
+   boost::movelib::ignore(res);
    BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(boost::movelib::is_sorted(first, res, comp));
    BOOST_MOVE_ADAPTIVE_SORT_PRINT_L2("   merge_blocks_w_fwd: ", len);
 
@@ -1382,7 +1381,7 @@ void op_merge_blocks_with_buf
    BOOST_MOVE_ADAPTIVE_SORT_PRINT_L2("   merge_blocks_w_irg: ", len);
 
    buffer_end = rbuf_beg.base();
-   BOOST_ASSERT((dest-last1) == (buffer_end-buffer));
+   assert((dest-last1) == (buffer_end-buffer));
    op_merge_with_left_placed(is_range1_A ? first1 : last1, last1, dest, buffer, buffer_end, comp, op);
    BOOST_MOVE_ADAPTIVE_SORT_PRINT_L2("   merge_with_left_plc:", len);
    BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(boost::movelib::is_sorted(first, last_irr2, comp));
@@ -1430,7 +1429,7 @@ void op_merge_right_step_once
    typedef typename iter_size<RandIt>::type size_type;
    size_type restk = size_type(elements_in_blocks%(2*l_build_buf));
    size_type p = size_type(elements_in_blocks - restk);
-   BOOST_ASSERT(0 == (p%(2*l_build_buf)));
+   assert(0 == (p%(2*l_build_buf)));
 
    if(restk <= l_build_buf){
       op(backward_t(),first_block+p, first_block+p+restk, first_block+p+restk+l_build_buf);

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

@@ -22,6 +22,7 @@
 #include <boost/move/utility_core.hpp>
 #include <boost/move/adl_move_swap.hpp>
 #include <boost/move/detail/iterator_traits.hpp>
+#include <boost/move/algo/move.hpp>
 
 namespace boost {
 namespace movelib {

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

@@ -28,6 +28,7 @@
 #include <boost/move/detail/iterator_traits.hpp>
 #include <boost/move/algo/detail/is_sorted.hpp>
 #include <boost/move/utility_core.hpp>
+#include <cassert>
 
 #if defined(BOOST_CLANG) || (defined(BOOST_GCC) && (BOOST_GCC >= 40600))
 #pragma GCC diagnostic push
@@ -100,7 +101,7 @@ class heap_sort_helper
    {
       make_heap(first, last, comp);
       sort_heap(first, last, comp);
-      BOOST_ASSERT(boost::movelib::is_sorted(first, last, comp));
+      assert(boost::movelib::is_sorted(first, last, comp));
    }
 };
 

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

@@ -11,8 +11,6 @@
 #ifndef BOOST_MOVE_MERGE_HPP
 #define BOOST_MOVE_MERGE_HPP
 
-#include <boost/core/ignore_unused.hpp>
-#include <boost/move/algo/move.hpp>
 #include <boost/move/adl_move_swap.hpp>
 #include <boost/move/algo/detail/basic_op.hpp>
 #include <boost/move/detail/iterator_traits.hpp>
@@ -20,7 +18,7 @@
 #include <boost/move/algo/predicate.hpp>
 #include <boost/move/algo/detail/search.hpp>
 #include <boost/move/detail/iterator_to_raw_pointer.hpp>
-#include <boost/assert.hpp>
+#include <cassert>
 #include <cstddef>
 
 #if defined(BOOST_CLANG) || (defined(BOOST_GCC) && (BOOST_GCC >= 40600))
@@ -75,7 +73,7 @@ class adaptive_xbuf
    template<class RandIt>
    void push_back(RandIt first, size_type n)
    {
-      BOOST_ASSERT(m_capacity - m_size >= n);
+      assert(m_capacity - m_size >= n);
       boost::uninitialized_move(first, first+n, m_ptr+m_size);
       m_size += n;
    }
@@ -83,7 +81,7 @@ class adaptive_xbuf
    template<class RandIt>
    iterator add(RandIt it)
    {
-      BOOST_ASSERT(m_size < m_capacity);
+      assert(m_size < m_capacity);
       RandRawIt p_ret = m_ptr + m_size;
       ::new(&*p_ret) T(::boost::move(*it));
       ++m_size;
@@ -121,9 +119,9 @@ class adaptive_xbuf
 
    void initialize_until(size_type const sz, T &t)
    {
-      BOOST_ASSERT(m_size < m_capacity);
+      assert(m_size < m_capacity);
       if(m_size < sz){
-         BOOST_TRY
+         BOOST_MOVE_TRY
          {
             ::new((void*)&m_ptr[m_size]) T(::boost::move(t));
             ++m_size;
@@ -132,7 +130,7 @@ class adaptive_xbuf
             }
             t = ::boost::move(m_ptr[m_size-1]);
          }
-         BOOST_CATCH(...)
+         BOOST_MOVE_CATCH(...)
          {
             while(m_size)
             {
@@ -140,7 +138,7 @@ class adaptive_xbuf
                m_ptr[m_size].~T();
             }
          }
-         BOOST_CATCH_END
+         BOOST_MOVE_CATCH_END
       }
    }
 
@@ -234,7 +232,7 @@ class range_xbuf
    template<class RandIt>
    void move_assign(RandIt first, size_type n)
    {
-      BOOST_ASSERT(size_type(n) <= size_type(m_cap-m_first));
+      assert(size_type(n) <= size_type(m_cap-m_first));
       typedef typename iter_difference<RandIt>::type d_type;
       m_last = Op()(forward_t(), first, first+d_type(n), m_first);
    }
@@ -636,12 +634,12 @@ void op_merge_with_right_placed
    , InputOutIterator dest_first, InputOutIterator r_first, InputOutIterator r_last
    , Compare comp, Op op)
 {
-   BOOST_ASSERT((last - first) == (r_first - dest_first));
+   assert((last - first) == (r_first - dest_first));
    while ( first != last ) {
       if (r_first == r_last) {
          InputOutIterator end = op(forward_t(), first, last, dest_first);
-         BOOST_ASSERT(end == r_last);
-         boost::ignore_unused(end);
+         assert(end == r_last);
+         boost::movelib::ignore(end);
          return;
       }
       else if (comp(*r_first, *first)) {
@@ -673,12 +671,12 @@ void op_merge_with_left_placed
    , BidirIterator const r_first, BidirIterator r_last
    , Compare comp, Op op)
 {
-   BOOST_ASSERT((dest_last - last) == (r_last - r_first));
+   assert((dest_last - last) == (r_last - r_first));
    while( r_first != r_last ) {
       if(first == last) {
          BidirOutIterator res = op(backward_t(), r_first, r_last, dest_last);
-         BOOST_ASSERT(last == res);
-         boost::ignore_unused(res);
+         assert(last == res);
+         boost::movelib::ignore(res);
          return;
       }
       --r_last;
@@ -727,7 +725,7 @@ void uninitialized_merge_with_right_placed
    , InputOutIterator dest_first, InputOutIterator r_first, InputOutIterator r_last
    , Compare comp)
 {
-   BOOST_ASSERT((last - first) == (r_first - dest_first));
+   assert((last - first) == (r_first - dest_first));
    typedef typename iterator_traits<InputOutIterator>::value_type value_type;
    InputOutIterator const original_r_first = r_first;
 
@@ -741,8 +739,8 @@ void uninitialized_merge_with_right_placed
          }
          d.release();
          InputOutIterator end = ::boost::move(first, last, original_r_first);
-         BOOST_ASSERT(end == r_last);
-         boost::ignore_unused(end);
+         assert(end == r_last);
+         boost::movelib::ignore(end);
          return;
       }
       else if (comp(*r_first, *first)) {

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

@@ -28,7 +28,6 @@
 #include <boost/move/detail/iterator_traits.hpp>
 #include <boost/move/detail/iterator_to_raw_pointer.hpp>
 #include <boost/move/detail/addressof.hpp>
-#include <boost/core/no_exceptions_support.hpp>
 #if defined(BOOST_MOVE_USE_STANDARD_LIBRARY_MOVE)
 #include <algorithm>
 #endif
@@ -122,20 +121,20 @@ F uninitialized_move(I f, I l, F r
    typedef typename boost::movelib::iterator_traits<I>::value_type input_value_type;
 
    F back = r;
-   BOOST_TRY{
+   BOOST_MOVE_TRY{
       while (f != l) {
          void * const addr = static_cast<void*>(::boost::move_detail::addressof(*r));
          ::new(addr) input_value_type(::boost::move(*f));
          ++f; ++r;
       }
    }
-   BOOST_CATCH(...){
+   BOOST_MOVE_CATCH(...){
       for (; back != r; ++back){
          boost::movelib::iterator_to_raw_pointer(back)->~input_value_type();
       }
-      BOOST_RETHROW;
+      BOOST_MOVE_RETHROW;
    }
-   BOOST_CATCH_END
+   BOOST_MOVE_CATCH_END
    return r;
 }
 

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

@@ -16,7 +16,7 @@
 #include <boost/move/algo/detail/basic_op.hpp>
 #include <boost/move/detail/iterator_traits.hpp>
 #include <boost/move/detail/destruct_n.hpp>
-#include <boost/assert.hpp>
+#include <cassert>
 
 namespace boost {
 namespace movelib {

data/src/cxx_supportlib/vendor-modified/boost/move/algorithm.hpp

@@ -27,7 +27,6 @@
 #include <boost/move/utility_core.hpp>
 #include <boost/move/iterator.hpp>
 #include <boost/move/algo/move.hpp>
-#include <boost/core/no_exceptions_support.hpp>
 
 #include <algorithm> //copy, copy_backward
 #include <memory>    //uninitialized_copy

data/src/cxx_supportlib/vendor-modified/boost/move/default_delete.hpp

@@ -23,7 +23,6 @@
 #include <boost/move/detail/workaround.hpp>
 #include <boost/move/detail/unique_ptr_meta_utils.hpp>
 #include <boost/move/utility_core.hpp>
-#include <boost/static_assert.hpp>
 
 #include <cstddef>   //For std::size_t,std::nullptr_t
 
@@ -190,7 +189,7 @@ struct default_delete
    {
       //If T is not an array type, U derives from T
       //and T has no virtual destructor, then you have a problem
-      BOOST_STATIC_ASSERT(( !bmupd::missing_virtual_destructor<default_delete, U>::value ));
+      BOOST_MOVE_STATIC_ASSERT(( !bmupd::missing_virtual_destructor<default_delete, U>::value ));
    }
 
    //! <b>Effects</b>: Constructs a default_delete object from another <tt>default_delete<U></tt> object.
@@ -205,7 +204,7 @@ struct default_delete
    {
       //If T is not an array type, U derives from T
       //and T has no virtual destructor, then you have a problem
-      BOOST_STATIC_ASSERT(( !bmupd::missing_virtual_destructor<default_delete, U>::value ));
+      BOOST_MOVE_STATIC_ASSERT(( !bmupd::missing_virtual_destructor<default_delete, U>::value ));
       return *this;
    }
 
@@ -222,10 +221,10 @@ struct default_delete
       operator()(U* ptr) const BOOST_NOEXCEPT
    {
       //U must be a complete type
-      BOOST_STATIC_ASSERT(sizeof(U) > 0);
+      BOOST_MOVE_STATIC_ASSERT(sizeof(U) > 0);
       //If T is not an array type, U derives from T
       //and T has no virtual destructor, then you have a problem
-      BOOST_STATIC_ASSERT(( !bmupd::missing_virtual_destructor<default_delete, U>::value ));
+      BOOST_MOVE_STATIC_ASSERT(( !bmupd::missing_virtual_destructor<default_delete, U>::value ));
       element_type * const p = static_cast<element_type*>(ptr);
       move_upd::call_delete(p, move_upd::is_array_del<bmupmu::is_array<T>::value>());
    }
@@ -233,7 +232,7 @@ struct default_delete
    //! <b>Effects</b>: Same as <tt>(*this)(static_cast<element_type*>(nullptr))</tt>.
    //!
    void operator()(BOOST_MOVE_DOC0PTR(bmupd::nullptr_type)) const BOOST_NOEXCEPT
-   {  BOOST_STATIC_ASSERT(sizeof(element_type) > 0);  }
+   {  BOOST_MOVE_STATIC_ASSERT(sizeof(element_type) > 0);  }
 };
 
 }  //namespace movelib {

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

@@ -26,6 +26,7 @@
 
 #include <boost/config.hpp>
 #include <boost/cstdint.hpp>
+#include <boost/move/detail/workaround.hpp>
 #include <cstdlib>
 
 
@@ -39,26 +40,73 @@
 
 #if defined(BOOST_MOVE_DETAIL_WINDOWS_API)
 
-#include <boost/winapi/time.hpp>
-#include <boost/winapi/timers.hpp>
-#include <boost/winapi/get_last_error.hpp>
-#include <boost/winapi/error_codes.hpp>
-#include <boost/assert.hpp>
-#include <boost/core/ignore_unused.hpp>
+#include <cassert>
+
+#if defined( BOOST_USE_WINDOWS_H )
+#include <Windows.h>
+#else
+
+#if defined (WIN32_PLATFORM_PSPC)
+#define BOOST_MOVE_WINAPI_IMPORT BOOST_SYMBOL_IMPORT
+#define BOOST_MOVE_WINAPI_IMPORT_EXCEPT_WM
+#elif defined (_WIN32_WCE)
+#define BOOST_MOVE_WINAPI_IMPORT
+#define BOOST_MOVE_WINAPI_IMPORT_EXCEPT_WM
+#else
+#define BOOST_MOVE_WINAPI_IMPORT BOOST_SYMBOL_IMPORT
+#define BOOST_MOVE_WINAPI_IMPORT_EXCEPT_WM BOOST_SYMBOL_IMPORT
+#endif
+
+#if defined(WINAPI)
+#define BOOST_MOVE_WINAPI_CC WINAPI
+#else
+   #if defined(_M_IX86) || defined(__i386__)
+   #define BOOST_MOVE_WINAPI_CC __stdcall
+   #else
+   // On architectures other than 32-bit x86 __stdcall is ignored. Clang also issues a warning.
+   #define BOOST_MOVE_WINAPI_CC
+   #endif
+#endif
+
+
+extern "C" {
+
+union _LARGE_INTEGER;
+typedef long long QuadPart;
+
+BOOST_MOVE_WINAPI_IMPORT_EXCEPT_WM int BOOST_MOVE_WINAPI_CC
+QueryPerformanceCounter(::_LARGE_INTEGER* lpPerformanceCount);
+
+BOOST_MOVE_WINAPI_IMPORT_EXCEPT_WM int BOOST_MOVE_WINAPI_CC
+QueryPerformanceFrequency(::_LARGE_INTEGER* lpFrequency);
+
+} // extern "C"
+#endif
+
 
 namespace boost { namespace move_detail {
 
+BOOST_FORCEINLINE int QueryPerformanceCounter(long long* lpPerformanceCount)
+{
+    return ::QueryPerformanceCounter(reinterpret_cast< ::_LARGE_INTEGER* >(lpPerformanceCount));
+}
+
+BOOST_FORCEINLINE int QueryPerformanceFrequency(long long* lpFrequency)
+{
+    return ::QueryPerformanceFrequency(reinterpret_cast< ::_LARGE_INTEGER* >(lpFrequency));
+}
+
+
 template<int Dummy>
 struct QPFHolder
 {
    static inline double get_nsec_per_tic()
    {
-      boost::winapi::LARGE_INTEGER_ freq;
-      boost::winapi::BOOL_ r = boost::winapi::QueryPerformanceFrequency( &freq );
-      boost::ignore_unused(r);
-      BOOST_ASSERT(r != 0 && "Boost::Move - get_nanosecs_per_tic Internal Error");
-
-      return double(1000000000.0L / freq.QuadPart);
+      long long freq;
+      //According to MS documentation:
+      //"On systems that run Windows XP or later, the function will always succeed and will thus never return zero"
+      (void)boost::move_detail::QueryPerformanceFrequency(&freq);
+      return double(1000000000.0L / double(freq));
    }
 
    static const double nanosecs_per_tic;
@@ -71,18 +119,11 @@ inline boost::uint64_t nsec_clock() BOOST_NOEXCEPT
 {
    double nanosecs_per_tic = QPFHolder<0>::nanosecs_per_tic;
    
-   boost::winapi::LARGE_INTEGER_ pcount;
-   unsigned times=0;
-   while ( !boost::winapi::QueryPerformanceCounter( &pcount ) )
-   {
-      if ( ++times > 3 )
-      {
-         BOOST_ASSERT("Boost::Move - QueryPerformanceCounter Internal Error");
-         return 0u;
-      }
-   }
-
-   return static_cast<boost::uint64_t>(nanosecs_per_tic * double(pcount.QuadPart));
+   long long pcount;
+   //According to MS documentation:
+   //"On systems that run Windows XP or later, the function will always succeed and will thus never return zero"
+   (void)boost::move_detail::QueryPerformanceCounter( &pcount );
+   return static_cast<boost::uint64_t>(nanosecs_per_tic * double(pcount));
 }
 
 }}  //namespace boost { namespace move_detail {