passenger 6.0.13 → 6.0.15

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

@@ -59,7 +59,7 @@ class BOOST_SYMBOL_VISIBLE exception
       : std_exception_t(), m_msg(msg)
    {}
 
-   virtual const char *what() const BOOST_NOEXCEPT_OR_NOTHROW
+   virtual const char *what() const BOOST_NOEXCEPT_OR_NOTHROW BOOST_OVERRIDE
    {  return m_msg ? m_msg : "unknown boost::container exception"; }
 
    private:
@@ -97,7 +97,7 @@ class BOOST_SYMBOL_VISIBLE length_error
    {}
 };
 
-typedef out_of_range length_error_t;
+typedef length_error length_error_t;
 
 class BOOST_SYMBOL_VISIBLE logic_error
    : public exception

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

@@ -82,18 +82,21 @@ class vec_iterator
 {
    public:
    typedef std::random_access_iterator_tag                                          iterator_category;
+   #ifdef BOOST_MOVE_CONTIGUOUS_ITERATOR_TAG
    typedef std::contiguous_iterator_tag                                             iterator_concept;
+   #endif
    typedef typename boost::intrusive::pointer_traits<Pointer>::element_type         value_type;
 
    //Defining element_type to make libstdc++'s std::pointer_traits well-formed leads to ambiguity
    //due to LWG3446. So we need to specialize std::pointer_traits. See 
-   //https://gcc.gnu.org/bugzilla/show_bug.cgi?id=96416 for details. /Many thanks to Jonathan Wakely
-   //for explaning the issue.
+   //https://gcc.gnu.org/bugzilla/show_bug.cgi?id=96416 for details. Many thanks to Jonathan Wakely
+   //for explaining the issue.
    #ifndef BOOST_GNU_STDLIB
    //Define element_
    typedef typename boost::intrusive::pointer_traits<Pointer>::element_type         element_type;
    #endif
    typedef typename boost::intrusive::pointer_traits<Pointer>::difference_type      difference_type;
+   typedef typename boost::intrusive::pointer_traits<Pointer>::size_type            size_type;
    typedef typename dtl::if_c
       < IsConst
       , typename boost::intrusive::pointer_traits<Pointer>::template
@@ -194,6 +197,7 @@ class vec_iterator
       friend vec_iterator operator-(vec_iterator left, difference_type off) BOOST_NOEXCEPT_OR_NOTHROW
    {  BOOST_ASSERT(left.m_ptr || !off); left.m_ptr -= off;  return left; }
 
+   //Difference
    BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
       friend difference_type operator-(const vec_iterator &left, const vec_iterator& right) BOOST_NOEXCEPT_OR_NOTHROW
    {  return left.m_ptr - right.m_ptr;   }
@@ -315,7 +319,8 @@ struct vector_alloc_holder
       (void)propagate_allocator; (void)p; (void)to_alloc; (void)from_alloc;
       const bool all_storage_propagable = !allocator_traits_type::is_partially_propagable::value ||
                                           !allocator_traits_type::storage_is_unpropagable(from_alloc, p);
-      return all_storage_propagable && (propagate_allocator || allocator_traits_type::equal(from_alloc, to_alloc));
+      return all_storage_propagable &&
+         (propagate_allocator || allocator_traits_type::is_always_equal::value || allocator_traits_type::equal(from_alloc, to_alloc));
    }
 
    BOOST_CONTAINER_FORCEINLINE
@@ -417,10 +422,10 @@ struct vector_alloc_holder
       {  this->m_size = static_cast<stored_size_type>(s);   }
 
    BOOST_CONTAINER_FORCEINLINE void dec_stored_size(size_type s) BOOST_NOEXCEPT_OR_NOTHROW
-      {  this->m_size -= static_cast<stored_size_type>(s);   }
+      {  this->m_size = static_cast<stored_size_type>(this->m_size - s);   }
 
    BOOST_CONTAINER_FORCEINLINE void inc_stored_size(size_type s) BOOST_NOEXCEPT_OR_NOTHROW
-      {  this->m_size += static_cast<stored_size_type>(s);   }
+      {  this->m_size = static_cast<stored_size_type>(this->m_size + s);   }
 
    BOOST_CONTAINER_FORCEINLINE void set_stored_capacity(size_type c) BOOST_NOEXCEPT_OR_NOTHROW
       {  this->m_capacity = static_cast<stored_size_type>(c);  }
@@ -432,7 +437,7 @@ struct vector_alloc_holder
       return this->priv_allocation_command(alloc_version(), command, limit_size, prefer_in_recvd_out_size, reuse);
    }
 
-   BOOST_CONTAINER_FORCEINLINE pointer allocate(size_type n)
+   pointer allocate(size_type n)
    {
       const size_type max_alloc = allocator_traits_type::max_size(this->alloc());
       const size_type max = max_alloc <= stored_size_type(-1) ? max_alloc : stored_size_type(-1);
@@ -450,7 +455,7 @@ struct vector_alloc_holder
    bool try_expand_fwd(size_type at_least)
    {
       //There is not enough memory, try to expand the old one
-      const size_type new_cap = this->capacity() + at_least;
+      const size_type new_cap = size_type(this->capacity() + at_least);
       size_type real_cap = new_cap;
       pointer reuse = this->start();
       bool const success = !!this->allocation_command(expand_fwd, new_cap, real_cap, reuse);
@@ -470,8 +475,8 @@ struct vector_alloc_holder
       BOOST_ASSERT(additional_objects > size_type(this->m_capacity - this->m_size));
       size_type max = allocator_traits_type::max_size(this->alloc());
       (clamp_by_stored_size_type<size_type>)(max, stored_size_type());
-      const size_type remaining_cap = max - size_type(this->m_capacity);
-      const size_type min_additional_cap = additional_objects - size_type(this->m_capacity - this->m_size);
+      const size_type remaining_cap = size_type(max - size_type(this->m_capacity));
+      const size_type min_additional_cap = size_type(additional_objects - size_type(this->m_capacity - this->m_size));
 
       if ( remaining_cap < min_additional_cap )
          boost::container::throw_length_error("get_next_capacity, allocator's max size reached");
@@ -647,10 +652,10 @@ struct vector_alloc_holder<Allocator, StoredSizeType, version_0>
       {  this->m_size = static_cast<stored_size_type>(s);   }
 
    BOOST_CONTAINER_FORCEINLINE void dec_stored_size(size_type s) BOOST_NOEXCEPT_OR_NOTHROW
-      {  this->m_size -= static_cast<stored_size_type>(s);   }
+      {  this->m_size = static_cast<stored_size_type>(this->m_size - s);   }
 
    BOOST_CONTAINER_FORCEINLINE void inc_stored_size(size_type s) BOOST_NOEXCEPT_OR_NOTHROW
-      {  this->m_size += static_cast<stored_size_type>(s);   }
+      {  this->m_size = static_cast<stored_size_type>(this->m_size + s);   }
 
    BOOST_CONTAINER_FORCEINLINE void priv_first_allocation(size_type cap)
    {
@@ -660,9 +665,7 @@ struct vector_alloc_holder<Allocator, StoredSizeType, version_0>
    }
 
    BOOST_CONTAINER_FORCEINLINE void deep_swap(vector_alloc_holder &x)
-   {
-      this->priv_deep_swap(x);
-   }
+      {  this->priv_deep_swap(x);   }
 
    template<class OtherAllocator, class OtherStoredSizeType, class OtherAllocatorVersion>
    void deep_swap(vector_alloc_holder<OtherAllocator, OtherStoredSizeType, OtherAllocatorVersion> &x)
@@ -679,7 +682,6 @@ struct vector_alloc_holder<Allocator, StoredSizeType, version_0>
       on_capacity_overflow();
    }
 
-
    BOOST_CONTAINER_FORCEINLINE void steal_resources(vector_alloc_holder &)
    {  //Containers with version 0 allocators can't be moved without moving elements one by one
       on_capacity_overflow();
@@ -813,7 +815,7 @@ private:
    private:
    BOOST_COPYABLE_AND_MOVABLE(vector)
    typedef vector_value_traits<allocator_type> value_traits;
-   typedef constant_iterator<T, difference_type>            cvalue_iterator;
+   typedef constant_iterator<T>            cvalue_iterator;
 
    protected:
 
@@ -821,12 +823,12 @@ private:
    {  return this->m_holder.steal_resources(x.m_holder);   }
 
    template<class AllocFwd>
-   BOOST_CONTAINER_FORCEINLINE vector(initial_capacity_t, pointer initial_memory, size_type capacity, BOOST_FWD_REF(AllocFwd) a)
-      : m_holder(initial_capacity_t(), initial_memory, capacity, ::boost::forward<AllocFwd>(a))
+   BOOST_CONTAINER_FORCEINLINE vector(initial_capacity_t, pointer initial_memory, size_type cap, BOOST_FWD_REF(AllocFwd) a)
+      : m_holder(initial_capacity_t(), initial_memory, cap, ::boost::forward<AllocFwd>(a))
    {}
 
-   BOOST_CONTAINER_FORCEINLINE vector(initial_capacity_t, pointer initial_memory, size_type capacity)
-      : m_holder(initial_capacity_t(), initial_memory, capacity)
+   BOOST_CONTAINER_FORCEINLINE vector(initial_capacity_t, pointer initial_memory, size_type cap)
+      : m_holder(initial_capacity_t(), initial_memory, cap)
    {}
 
    #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
@@ -1290,9 +1292,10 @@ private:
          >::type * = 0)
       )
    {
+      typedef typename iter_size<FwdIt>::type it_size_type;
       //For Fwd iterators the standard only requires EmplaceConstructible and assignable from *first
       //so we can't do any backwards allocation
-      const typename iterator_traits<FwdIt>::size_type sz = boost::container::iterator_distance(first, last);
+      const it_size_type sz = boost::container::iterator_udistance(first, last);
       if (sz > size_type(-1)){
          boost::container::throw_length_error("vector::assign, FwdIt's max length reached");
       }
@@ -1400,7 +1403,7 @@ private:
    BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE iterator end() BOOST_NOEXCEPT_OR_NOTHROW
    {
       iterator it (this->m_holder.start());
-      it += this->m_holder.m_size;
+      it += difference_type(this->m_holder.m_size);
       return it;  //Adding zero to null pointer is allowed (non-UB)
    }
 
@@ -1464,7 +1467,7 @@ private:
    BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE const_iterator cend() const BOOST_NOEXCEPT_OR_NOTHROW
    {
       const_iterator it (this->m_holder.start());
-      it += this->m_holder.m_size;
+      it += difference_type(this->m_holder.m_size);
       return it;  //Adding zero to null pointer is allowed (non-UB)
    }
 
@@ -1621,7 +1624,7 @@ private:
    BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE reference back() BOOST_NOEXCEPT_OR_NOTHROW
    {
       BOOST_ASSERT(!this->empty());
-      return this->m_holder.start()[this->m_holder.m_size - 1];
+      return this->m_holder.start()[difference_type(this->m_holder.m_size - 1u)];
    }
 
    //! <b>Requires</b>: !empty()
@@ -1649,7 +1652,7 @@ private:
    BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE reference operator[](size_type n) BOOST_NOEXCEPT_OR_NOTHROW
    {
       BOOST_ASSERT(this->m_holder.m_size > n);
-      return this->m_holder.start()[n];
+      return this->m_holder.start()[difference_type(n)];
    }
 
    //! <b>Requires</b>: size() > n.
@@ -1682,7 +1685,7 @@ private:
       iterator nth(size_type n) BOOST_NOEXCEPT_OR_NOTHROW
    {
       BOOST_ASSERT(this->m_holder.m_size >= n);
-      return iterator(this->m_holder.start()+n);
+      return iterator(this->m_holder.start()+difference_type(n));
    }
 
    //! <b>Requires</b>: size() >= n.
@@ -1700,7 +1703,7 @@ private:
       const_iterator nth(size_type n) const BOOST_NOEXCEPT_OR_NOTHROW
    {
       BOOST_ASSERT(this->m_holder.m_size >= n);
-      return const_iterator(this->m_holder.start()+n);
+      return const_iterator(this->m_holder.start()+difference_type(n));
    }
 
    //! <b>Requires</b>: begin() <= p <= end().
@@ -1748,7 +1751,7 @@ private:
    BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE reference at(size_type n)
    {
       this->priv_throw_if_out_of_range(n);
-      return this->m_holder.start()[n];
+      return this->m_holder.start()[difference_type(n)];
    }
 
    //! <b>Requires</b>: size() > n.
@@ -1990,13 +1993,13 @@ private:
       )
    {
       BOOST_ASSERT(this->priv_in_range_or_end(pos));
-      const size_type n_pos = pos - this->cbegin();
+      const size_type n_pos = size_type(pos - this->cbegin());
       iterator it(vector_iterator_get_ptr(pos));
       for(;first != last; ++first){
          it = this->emplace(it, *first);
          ++it;
       }
-      return iterator(this->m_holder.start() + n_pos);
+      return iterator(this->m_holder.start() + difference_type(n_pos));
    }
 
    #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
@@ -2009,8 +2012,9 @@ private:
          >::type * = 0
       )
    {
+      typedef typename iter_size<FwdIt>::type it_size_type;
       BOOST_ASSERT(this->priv_in_range_or_end(pos));
-      const typename iterator_traits<FwdIt>::size_type sz = boost::container::iterator_distance(first, last);
+      const it_size_type sz = boost::container::iterator_udistance(first, last);
       if (sz > size_type(-1)){
          boost::container::throw_length_error("vector::insert, FwdIt's max length reached");
       }
@@ -2041,7 +2045,7 @@ private:
    {
       BOOST_ASSERT(this->priv_in_range_or_end(pos));
       BOOST_ASSERT(dtl::is_input_iterator<InIt>::value ||
-                   num == static_cast<size_type>(boost::container::iterator_distance(first, last)));
+                   num == boost::container::iterator_udistance(first, last));
       (void)last;
       dtl::insert_range_proxy<allocator_type, InIt, T*> proxy(first);
       return this->priv_insert_forward_range(vector_iterator_get_ptr(pos), num, proxy);
@@ -2223,7 +2227,7 @@ private:
    bool stable_reserve(size_type new_cap)
    {
       const size_type cp = this->capacity();
-      return cp >= new_cap || (alloc_version::value == 2 && this->m_holder.try_expand_fwd(new_cap - cp));
+      return cp >= new_cap || (alloc_version::value == 2 && this->m_holder.try_expand_fwd(size_type(new_cap - cp)));
    }
 
    //Absolutely experimental. This function might change, disappear or simply crash!
@@ -2247,7 +2251,7 @@ private:
       size_type const free_cap = c - s;
       //If not input iterator and new elements don't fit in the remaining capacity, merge in new buffer
       if(!dtl::is_input_iterator<InputIt>::value &&
-         free_cap < (n = static_cast<size_type>(boost::container::iterator_distance(first, last)))){
+         free_cap < (n = boost::container::iterator_udistance(first, last))){
          this->priv_merge_in_new_buffer(first, n, comp, alloc_version());
       }
       else{
@@ -2433,12 +2437,12 @@ private:
    {  return this->m_holder.m_size != this->m_holder.capacity();   }
 
    BOOST_CONTAINER_FORCEINLINE pointer back_ptr() const
-   {  return this->m_holder.start() + this->m_holder.m_size;  }
+   {  return this->m_holder.start() + difference_type(this->m_holder.m_size);  }
 
    BOOST_CONTAINER_FORCEINLINE size_type priv_index_of(pointer p) const
    {
       BOOST_ASSERT(this->m_holder.start() <= p);
-      BOOST_ASSERT(p <= (this->m_holder.start()+this->size()));
+      BOOST_ASSERT(p <= (this->m_holder.start()+difference_type(this->size())));
       return static_cast<size_type>(p - this->m_holder.start());
    }
 
@@ -2545,31 +2549,40 @@ private:
    void priv_swap(Vector &x, dtl::false_type)  //version_N
    {
       const bool propagate_alloc = allocator_traits_type::propagate_on_container_swap::value;
-      if(are_swap_propagable( this->get_stored_allocator(), this->m_holder.start()
-                            , x.get_stored_allocator(), x.m_holder.start(), propagate_alloc)){
+      if (BOOST_UNLIKELY(&x == this)){
+         return;
+      }
+      else if(are_swap_propagable( this->get_stored_allocator(), this->m_holder.start()
+                                 , x.get_stored_allocator(), x.m_holder.start(), propagate_alloc)){
          //Just swap internals
          this->m_holder.swap_resources(x.m_holder);
       }
       else{
-         if (BOOST_UNLIKELY(&x == this))
-            return;
-
          //Else swap element by element...
          bool const t_smaller = this->size() < x.size();
          vector &sml = t_smaller ? *this : x;
          vector &big = t_smaller ? x : *this;
 
-         size_type const common_elements = sml.size();
-         for(size_type i = 0; i != common_elements; ++i){
-            boost::adl_move_swap(sml[i], big[i]);
+         //For empty containers, maybe storage can be moved from the other (just like in the move constructor)         
+         if(sml.empty() && is_propagable_from(big.get_stored_allocator(), big.data(), sml.get_allocator(), propagate_alloc)){
+            if(BOOST_LIKELY(0u != sml.capacity()))
+               sml.m_holder.deallocate(sml.m_holder.m_start, sml.m_holder.m_capacity);
+            sml.steal_resources(big);
+         }
+         else {
+            //Else swap element by element...
+            size_type const common_elements = sml.size();
+            for(size_type i = 0; i != common_elements; ++i){
+               boost::adl_move_swap(sml[i], big[i]);
+            }
+            //... and move-insert the remaining range
+            sml.insert( sml.cend()
+                      , boost::make_move_iterator(boost::movelib::iterator_to_raw_pointer(big.nth(common_elements)))
+                      , boost::make_move_iterator(boost::movelib::iterator_to_raw_pointer(big.end()))
+                      );
+            //Destroy remaining elements
+            big.erase(big.nth(common_elements), big.cend());
          }
-         //... and move-insert the remaining range
-         sml.insert( sml.cend()
-                   , boost::make_move_iterator(boost::movelib::iterator_to_raw_pointer(big.nth(common_elements)))
-                   , boost::make_move_iterator(boost::movelib::iterator_to_raw_pointer(big.end()))
-                   );
-         //Destroy remaining elements
-         big.erase(big.nth(common_elements), big.cend());
       }
       //And now swap the allocator
       dtl::swap_alloc(this->m_holder.alloc(), x.m_holder.alloc(), dtl::bool_<propagate_alloc>());
@@ -2622,7 +2635,7 @@ private:
             ++this->num_expand_bwd;
             #endif
             this->priv_insert_forward_range_expand_backwards
-               ( new_mem , real_cap, ins_pos, 0, this->priv_dummy_empty_proxy());
+               ( new_mem, real_cap, ins_pos, 0, this->priv_dummy_empty_proxy());
          }
          else{ //New buffer
             #ifdef BOOST_CONTAINER_VECTOR_ALLOC_STATS
@@ -2750,7 +2763,7 @@ private:
       ++this->num_alloc;
       #endif
       this->priv_insert_forward_range_new_allocation(new_buf, new_cap, raw_pos, n, insert_range_proxy);
-      return iterator(this->m_holder.start() + n_pos);
+      return iterator(this->m_holder.start() + difference_type(n_pos));
    }
 
    template <class InsertionProxy>
@@ -2758,14 +2771,14 @@ private:
       (T *const raw_pos, const size_type n, const InsertionProxy insert_range_proxy, version_2)
    {
       //Check if we have enough memory or try to expand current memory
-      const size_type n_pos = raw_pos - this->priv_raw_begin();
+      const size_type n_pos = size_type(raw_pos - this->priv_raw_begin());
 
       //There is not enough memory, allocate a new
       //buffer or expand the old one.
       size_type real_cap = this->m_holder.template next_capacity<growth_factor_type>(n);
       pointer reuse(this->m_holder.start());
       pointer const ret (this->m_holder.allocation_command
-         (allocate_new | expand_fwd | expand_bwd, this->m_holder.m_size + n, real_cap, reuse));
+         (allocate_new | expand_fwd | expand_bwd, size_type(this->m_holder.m_size + n), real_cap, reuse));
 
       //Buffer reallocated
       if(reuse){
@@ -2797,7 +2810,7 @@ private:
             ( boost::movelib::to_raw_pointer(ret), real_cap, raw_pos, n, insert_range_proxy);
       }
 
-      return iterator(this->m_holder.start() + n_pos);
+      return iterator(this->m_holder.start() + (difference_type)(n_pos));
    }
 
    template <class InsertionProxy>
@@ -2843,10 +2856,10 @@ private:
       const size_type sz = this->m_holder.m_size;
       if (new_size < sz){
          //Destroy last elements
-         this->priv_destroy_last_n(sz - new_size);
+         this->priv_destroy_last_n(size_type(sz - new_size));
       }
       else {
-         this->priv_insert_forward_range(this->back_ptr(), new_size - sz, this->priv_resize_proxy(u));
+         this->priv_insert_forward_range(this->back_ptr(), size_type(new_size - sz), this->priv_resize_proxy(u));
       }
    }
 
@@ -2922,7 +2935,9 @@ private:
          //All uninitialized_moved
          ::boost::container::uninitialized_move_alloc
             (this->m_holder.alloc(), first_ptr, last_ptr, first_ptr + shift_count);
-         hole_size = first_pos + shift_count - limit_pos;
+         //Cast in case size_type is narrower than int, promotions are applied
+         //and Wconversion is in place
+         hole_size = static_cast<size_type>(first_pos + shift_count - limit_pos);
       }
       //Case C:
       else{
@@ -3024,7 +3039,7 @@ private:
       //We can have 8 possibilities:
       const size_type elemsbefore = static_cast<size_type>(pos - old_start);
       const size_type s_before    = static_cast<size_type>(old_start - new_start);
-      const size_type before_plus_new = elemsbefore + n;
+      const size_type before_plus_new = size_type(elemsbefore + n);
 
       typedef typename value_traits::ArrayDestructor array_destructor_t;
 
@@ -3039,7 +3054,7 @@ private:
          this->m_holder.set_stored_size(elemsbefore);
          insert_range_proxy.uninitialized_copy_n_and_update(a, new_elem_pos, n);
          this->m_holder.set_stored_size(before_plus_new);
-         const size_type new_size = old_size + n;
+         const size_type new_size = size_type(old_size + n);
          //Check if s_before is so big that even copying the old data + new data
          //there is a gap between the new data and the old data
          if(s_before >= new_size){
@@ -3174,7 +3189,7 @@ private:
                   old_values_destroyer.shrink_forward(old_size - (s_before - n));
                }
             }
-            this->m_holder.set_stored_size(old_size + new_1st_range);
+            this->m_holder.set_stored_size(size_type(old_size + new_1st_range));
             //Now copy the second part of old_begin overwriting itself
             T *const next = ::boost::container::move(old_start + s_before, pos, old_start);
             //Now copy the new_beg elements
@@ -3216,11 +3231,11 @@ private:
             T * const new_pos = ::boost::container::uninitialized_move_alloc
                (a, old_start, pos, new_start);
             this->m_holder.set_stored_size(elemsbefore);
-            const size_type mid_n = s_before - elemsbefore;
+            const size_type mid_n = size_type(s_before - elemsbefore);
             insert_range_proxy.uninitialized_copy_n_and_update(a, new_pos, mid_n);
             //The buffer is all constructed until old_end,
             //release destroyer
-            this->m_holder.set_stored_size(old_size + s_before);
+            this->m_holder.set_stored_size(size_type(old_size + s_before));
             old_values_destroyer.release();
 
             if(do_after){
@@ -3229,7 +3244,7 @@ private:
             }
             else{
                //Copy all new elements
-               const size_type rest_new = n - mid_n;
+               const size_type rest_new = size_type(n - mid_n);
                insert_range_proxy.copy_n_and_update(a, old_start, rest_new);
 
                T* const move_start = old_start + rest_new;
@@ -3240,7 +3255,7 @@ private:
                                  //trivial_dctr_after_move is true
                //Destroy remaining moved elements from old_end except if they
                //have trivial destructor after being moved
-               const size_type n_destroy = s_before - n;
+               const size_type n_destroy = size_type(s_before - n);
                BOOST_IF_CONSTEXPR(!value_traits::trivial_dctr_after_move){
                   boost::container::destroy_alloc_n(a, move_end, n_destroy);
                }
@@ -3267,8 +3282,8 @@ private:
             //| old_begin      +       new            | old_end |raw |
             //|_______________________________________|_________|____|
             //
-            const size_type n_after    = n - s_before;
-            const size_type elemsafter = old_size - elemsbefore;
+            const size_type n_after    = size_type(n - s_before);
+            const size_type elemsafter = size_type(old_size - elemsbefore);
 
             //We can have two situations:
             if (elemsafter >= n_after){
@@ -3308,7 +3323,7 @@ private:
                //|__________________________|_______________|________|_________|
 
                //First initialize data in raw memory
-               const size_type mid_last_dist = n_after - elemsafter;
+               const size_type mid_last_dist = size_type(n_after - elemsafter);
 
                //Copy to the old_end part to the uninitialized zone leaving a gap.
                ::boost::container::uninitialized_move_alloc(a, pos, old_finish, old_finish + mid_last_dist);
@@ -3360,11 +3375,11 @@ private:
 
 template <typename InputIterator>
 vector(InputIterator, InputIterator) ->
-   vector<typename iterator_traits<InputIterator>::value_type>;
+   vector<typename iter_value<InputIterator>::type>;
 
 template <typename InputIterator, typename Allocator>
 vector(InputIterator, InputIterator, Allocator const&) ->
-   vector<typename iterator_traits<InputIterator>::value_type, Allocator>;
+   vector<typename iter_value<InputIterator>::type, Allocator>;
 
 #endif
 

data/src/cxx_supportlib/vendor-modified/boost/container_hash/hash.hpp

@@ -26,6 +26,7 @@
 #include <boost/type_traits/is_integral.hpp>
 #include <boost/core/enable_if.hpp>
 #include <boost/cstdint.hpp>
+#include <climits>
 
 #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
 #include <boost/type_traits/is_pointer.hpp>
@@ -307,52 +308,56 @@ namespace boost
              return seed;
         }
 
-        template <typename SizeT>
-        inline void hash_combine_impl(SizeT& seed, SizeT value)
+        template<std::size_t Bits> struct hash_combine_impl
         {
-            seed ^= value + 0x9e3779b9 + (seed<<6) + (seed>>2);
-        }
+            template <typename SizeT>
+            inline static SizeT fn(SizeT seed, SizeT value)
+            {
+                seed ^= value + 0x9e3779b9 + (seed<<6) + (seed>>2);
+                return seed;
+            }
+        };
 
-        inline void hash_combine_impl(boost::uint32_t& h1,
-                boost::uint32_t k1)
+        template<> struct hash_combine_impl<32>
         {
-            const uint32_t c1 = 0xcc9e2d51;
-            const uint32_t c2 = 0x1b873593;
-
-            k1 *= c1;
-            k1 = BOOST_FUNCTIONAL_HASH_ROTL32(k1,15);
-            k1 *= c2;
+            inline static boost::uint32_t fn(boost::uint32_t h1, boost::uint32_t k1)
+            {
+                const boost::uint32_t c1 = 0xcc9e2d51;
+                const boost::uint32_t c2 = 0x1b873593;
 
-            h1 ^= k1;
-            h1 = BOOST_FUNCTIONAL_HASH_ROTL32(h1,13);
-            h1 = h1*5+0xe6546b64;
-        }
+                k1 *= c1;
+                k1 = BOOST_FUNCTIONAL_HASH_ROTL32(k1,15);
+                k1 *= c2;
 
+                h1 ^= k1;
+                h1 = BOOST_FUNCTIONAL_HASH_ROTL32(h1,13);
+                h1 = h1*5+0xe6546b64;
 
-// Don't define 64-bit hash combine on platforms without 64 bit integers,
-// and also not for 32-bit gcc as it warns about the 64-bit constant.
-#if !defined(BOOST_NO_INT64_T) && \
-        !(defined(__GNUC__) && ULONG_MAX == 0xffffffff)
+                return h1;
+            }
+        };
 
-        inline void hash_combine_impl(boost::uint64_t& h,
-                boost::uint64_t k)
+        template<> struct hash_combine_impl<64>
         {
-            const boost::uint64_t m = UINT64_C(0xc6a4a7935bd1e995);
-            const int r = 47;
+            inline static boost::uint64_t fn(boost::uint64_t h, boost::uint64_t k)
+            {
+                const boost::uint64_t m = (boost::uint64_t(0xc6a4a793) << 32) + 0x5bd1e995;
+                const int r = 47;
 
-            k *= m;
-            k ^= k >> r;
-            k *= m;
+                k *= m;
+                k ^= k >> r;
+                k *= m;
 
-            h ^= k;
-            h *= m;
+                h ^= k;
+                h *= m;
 
-            // Completely arbitrary number, to prevent 0's
-            // from hashing to 0.
-            h += 0xe6546b64;
-        }
+                // Completely arbitrary number, to prevent 0's
+                // from hashing to 0.
+                h += 0xe6546b64;
 
-#endif // BOOST_NO_INT64_T
+                return h;
+            }
+        };
     }
 
     template <typename T>
@@ -413,7 +418,7 @@ namespace boost
     inline void hash_combine(std::size_t& seed, T const& v)
     {
         boost::hash<T> hasher;
-        return boost::hash_detail::hash_combine_impl(seed, hasher(v));
+        seed = boost::hash_detail::hash_combine_impl<sizeof(std::size_t) * CHAR_BIT>::fn(seed, hasher(v));
     }
 
 #if defined(BOOST_MSVC)