passenger 6.0.7 → 6.0.8

data/src/cxx_supportlib/vendor-modified/boost/container/detail/advanced_insert_int.hpp

@@ -128,7 +128,7 @@ struct insert_value_initialized_n_proxy
    void copy_n_and_update(Allocator &a, Iterator p, size_type n) const
    {
       for (; 0 < n; --n, ++p){
-         typename aligned_storage<sizeof(value_type), alignment_of<value_type>::value>::type v;
+         typename dtl::aligned_storage<sizeof(value_type), dtl::alignment_of<value_type>::value>::type v;
          value_type *vp = reinterpret_cast<value_type *>(v.data);
          alloc_traits::construct(a, vp);
          value_destructor<Allocator> on_exit(a, *vp); (void)on_exit;
@@ -151,7 +151,7 @@ struct insert_default_initialized_n_proxy
    {
       if(!is_pod<value_type>::value){
          for (; 0 < n; --n, ++p){
-            typename aligned_storage<sizeof(value_type), alignment_of<value_type>::value>::type v;
+            typename dtl::aligned_storage<sizeof(value_type), dtl::alignment_of<value_type>::value>::type v;
             value_type *vp = reinterpret_cast<value_type *>(v.data);
             alloc_traits::construct(a, vp, default_init);
             value_destructor<Allocator> on_exit(a, *vp); (void)on_exit;
@@ -195,17 +195,17 @@ struct insert_move_proxy
    typedef typename alloc_traits::size_type size_type;
    typedef typename alloc_traits::value_type value_type;
 
-   explicit insert_move_proxy(value_type &v)
+   BOOST_CONTAINER_FORCEINLINE explicit insert_move_proxy(value_type &v)
       :  v_(v)
    {}
 
-   void uninitialized_copy_n_and_update(Allocator &a, Iterator p, size_type n) const
+   BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, size_type n) const
    {
       BOOST_ASSERT(n == 1);  (void)n;
       alloc_traits::construct( a, boost::movelib::iterator_to_raw_pointer(p), ::boost::move(v_) );
    }
 
-   void copy_n_and_update(Allocator &, Iterator p, size_type n) const
+   BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &, Iterator p, size_type n) const
    {
       BOOST_ASSERT(n == 1);  (void)n;
       *p = ::boost::move(v_);
@@ -288,7 +288,7 @@ struct insert_emplace_proxy
    void priv_copy_some_and_update(Allocator &a, const index_tuple<IdxPack...>&, Iterator p, size_type n)
    {
       BOOST_ASSERT(n ==1); (void)n;
-      typename aligned_storage<sizeof(value_type), alignment_of<value_type>::value>::type v;
+      typename dtl::aligned_storage<sizeof(value_type), dtl::alignment_of<value_type>::value>::type v;
       value_type *vp = reinterpret_cast<value_type *>(v.data);
       alloc_traits::construct(a, vp,
          ::boost::forward<Args>(get<IdxPack>(this->args_))...);
@@ -398,7 +398,7 @@ struct insert_emplace_proxy_arg##N\
    void copy_n_and_update(Allocator &a, Iterator p, size_type n)\
    {\
       BOOST_ASSERT(n == 1); (void)n;\
-      typename aligned_storage<sizeof(value_type), alignment_of<value_type>::value>::type v;\
+      typename dtl::aligned_storage<sizeof(value_type), dtl::alignment_of<value_type>::value>::type v;\
       BOOST_ASSERT((((size_type)(&v)) % alignment_of<value_type>::value) == 0);\
       value_type *vp = reinterpret_cast<value_type *>(v.data);\
       alloc_traits::construct(a, vp BOOST_MOVE_I##N BOOST_MOVE_MFWD##N);\

data/src/cxx_supportlib/vendor-modified/boost/container/detail/alloc_helpers.hpp

@@ -27,30 +27,30 @@ namespace container {
 namespace dtl {
 
 template<class AllocatorType>
-inline void swap_alloc(AllocatorType &, AllocatorType &, dtl::false_type)
+BOOST_CONTAINER_FORCEINLINE void swap_alloc(AllocatorType &, AllocatorType &, dtl::false_type)
    BOOST_NOEXCEPT_OR_NOTHROW
 {}
 
 template<class AllocatorType>
-inline void swap_alloc(AllocatorType &l, AllocatorType &r, dtl::true_type)
+BOOST_CONTAINER_FORCEINLINE void swap_alloc(AllocatorType &l, AllocatorType &r, dtl::true_type)
 {  boost::adl_move_swap(l, r);   }
 
 template<class AllocatorType>
-inline void assign_alloc(AllocatorType &, const AllocatorType &, dtl::false_type)
+BOOST_CONTAINER_FORCEINLINE void assign_alloc(AllocatorType &, const AllocatorType &, dtl::false_type)
    BOOST_NOEXCEPT_OR_NOTHROW
 {}
 
 template<class AllocatorType>
-inline void assign_alloc(AllocatorType &l, const AllocatorType &r, dtl::true_type)
+BOOST_CONTAINER_FORCEINLINE void assign_alloc(AllocatorType &l, const AllocatorType &r, dtl::true_type)
 {  l = r;   }
 
 template<class AllocatorType>
-inline void move_alloc(AllocatorType &, AllocatorType &, dtl::false_type)
+BOOST_CONTAINER_FORCEINLINE void move_alloc(AllocatorType &, AllocatorType &, dtl::false_type)
    BOOST_NOEXCEPT_OR_NOTHROW
 {}
 
 template<class AllocatorType>
-inline void move_alloc(AllocatorType &l, AllocatorType &r, dtl::true_type)
+BOOST_CONTAINER_FORCEINLINE void move_alloc(AllocatorType &l, AllocatorType &r, dtl::true_type)
 {  l = ::boost::move(r);   }
 
 }  //namespace dtl {

data/src/cxx_supportlib/vendor-modified/boost/container/detail/alloc_lib.h

@@ -196,11 +196,11 @@ typedef struct boost_cont_memchain_impl
 
 /*!Indicates the all elements allocated by boost_cont_multialloc_nodes or boost_cont_multialloc_arrays
    must be contiguous.*/
-#define DL_MULTIALLOC_ALL_CONTIGUOUS        ((size_t)(-1))
+#define BOOST_CONTAINER_DL_MULTIALLOC_ALL_CONTIGUOUS        ((size_t)(-1))
 
 /*!Indicates the number of contiguous elements allocated by boost_cont_multialloc_nodes or boost_cont_multialloc_arrays
    should be selected by those functions.*/
-#define DL_MULTIALLOC_DEFAULT_CONTIGUOUS    ((size_t)(0))
+#define BOOST_CONTAINER_DL_MULTIALLOC_DEFAULT_CONTIGUOUS    ((size_t)(0))
 
 typedef struct boost_cont_malloc_stats_impl
 {
@@ -225,8 +225,8 @@ enum
    BOOST_CONTAINER_EXPAND_OR_NEW         = BOOST_CONTAINER_ALLOCATE_NEW | BOOST_CONTAINER_EXPAND_BOTH
 };
 
-//#define BOOST_CONTAINERDLMALLOC__FOOTERS
-#ifndef BOOST_CONTAINERDLMALLOC__FOOTERS
+//#define BOOST_CONTAINER_DLMALLOC_FOOTERS
+#ifndef BOOST_CONTAINER_DLMALLOC_FOOTERS
 enum {   BOOST_CONTAINER_ALLOCATION_PAYLOAD = sizeof(size_t)   };
 #else
 enum {   BOOST_CONTAINER_ALLOCATION_PAYLOAD = sizeof(size_t)*2   };

data/src/cxx_supportlib/vendor-modified/boost/container/detail/block_list.hpp

@@ -27,6 +27,7 @@
 #include <boost/intrusive/circular_list_algorithms.hpp>
 #include <boost/move/detail/type_traits.hpp>
 #include <boost/assert.hpp>
+#include <boost/container/detail/placement_new.hpp>
 
 #include <cstddef>
 
@@ -100,7 +101,7 @@ class block_list_base
       if((size_t(-1) - header_size) < size)
          throw_bad_alloc();
       void *p = mr.allocate(size+header_size);
-      block_list_header &mb  = *::new((void*)p) DerivedFromBlockListHeader;
+      block_list_header &mb  = *::new((void*)p, boost_container_new_t()) DerivedFromBlockListHeader;
       mb.size = size+header_size;
       list_algo::link_after(&m_list, &mb);
       return (char *)p + header_size;

data/src/cxx_supportlib/vendor-modified/boost/container/detail/block_slist.hpp

@@ -25,6 +25,7 @@
 #include <boost/container/container_fwd.hpp>
 #include <boost/container/pmr/memory_resource.hpp>
 #include <boost/container/throw_exception.hpp>
+#include <boost/container/detail/placement_new.hpp>
 
 #include <boost/move/detail/type_traits.hpp>
 #include <boost/intrusive/linear_slist_algorithms.hpp>
@@ -94,7 +95,7 @@ class block_slist_base
       if((size_t(-1) - header_size) < size)
          throw_bad_alloc();
       void *p = mr.allocate(size+header_size);
-      block_slist_header &mb  = *::new((void*)p) DerivedFromBlockSlistHeader;
+      block_slist_header &mb  = *::new((void*)p, boost_container_new_t()) DerivedFromBlockSlistHeader;
       mb.size = size+header_size;
       slist_algo::link_after(&m_slist, &mb);
       return (char *)p + header_size;

data/src/cxx_supportlib/vendor-modified/boost/container/detail/compare_functors.hpp

@@ -24,10 +24,10 @@
 namespace boost {
 namespace container {
 
-template<class Allocator>
+template<class ValueType>
 class equal_to_value
 {
-   typedef typename Allocator::value_type value_type;
+   typedef ValueType value_type;
    const value_type &t_;
 
    public:

data/src/cxx_supportlib/vendor-modified/boost/container/detail/container_or_allocator_rebind.hpp

@@ -34,7 +34,11 @@ struct container_or_allocator_rebind_impl
 template<class AllocatorOrContainer, class ToType>
 struct container_or_allocator_rebind_impl<AllocatorOrContainer, ToType, false>
    : allocator_traits<AllocatorOrContainer>::template portable_rebind_alloc<ToType>
+{};
 
+template<class ToType>
+struct container_or_allocator_rebind_impl<void, ToType, false>
+   : real_allocator<ToType, void>
 {};
 
 template<class AllocatorOrContainer, class ToType>

data/src/cxx_supportlib/vendor-modified/boost/container/detail/container_rebind.hpp

@@ -19,6 +19,7 @@
 #endif
 
 #include <boost/container/allocator_traits.hpp>
+#include <boost/container/container_fwd.hpp>
 
 
 namespace boost {
@@ -33,14 +34,14 @@ namespace dtl {
    template <template <class, class, class...> class Cont, typename V, typename A, class... An, class U>
    struct container_rebind<Cont<V, A, An...>, U>
    {
-      typedef Cont<U, typename allocator_traits<A>::template portable_rebind_alloc<U>::type, An...> type;
+      typedef Cont<U, typename allocator_traits<typename real_allocator<V, A>::type>::template portable_rebind_alloc<U>::type, An...> type;
    };
 
    //Needed for non-conforming compilers like GCC 4.3
    template <template <class, class> class Cont, typename V, typename A, class U>
    struct container_rebind<Cont<V, A>, U>
    {
-      typedef Cont<U, typename allocator_traits<A>::template portable_rebind_alloc<U>::type> type;
+      typedef Cont<U, typename allocator_traits<typename real_allocator<V, A>::type>::template portable_rebind_alloc<U>::type> type;
    };
 
    template <template <class> class Cont, typename V, class U>
@@ -49,27 +50,6 @@ namespace dtl {
       typedef Cont<U> type;
    };
 
-   //for small_vector,static_vector
-
-   template <template <class, std::size_t, class, class...> class Cont, typename V, std::size_t N, typename A, class... An, class U>
-   struct container_rebind<Cont<V, N, A, An...>, U>
-   {
-      typedef Cont<U, N, typename allocator_traits<A>::template portable_rebind_alloc<U>::type, An...> type;
-   };
-
-   //Needed for non-conforming compilers like GCC 4.3
-   template <template <class, std::size_t, class> class Cont, typename V, std::size_t N, typename A, class U>
-   struct container_rebind<Cont<V, N, A>, U>
-   {
-      typedef Cont<U, N, typename allocator_traits<A>::template portable_rebind_alloc<U>::type> type;
-   };
-
-   template <template <class, std::size_t> class Cont, typename V, std::size_t N, class U>
-   struct container_rebind<Cont<V, N>, U>
-   {
-      typedef Cont<U, N> type;
-   };
-
 #else //C++03 compilers
 
    template <template <class> class Cont  //0arg
@@ -85,7 +65,7 @@ namespace dtl {
       , class U>
       struct container_rebind<Cont<V, A>, U>
    {
-      typedef Cont<U, typename allocator_traits<A>::template portable_rebind_alloc<U>::type> type;
+      typedef Cont<U, typename allocator_traits<typename real_allocator<V, A>::type>::template portable_rebind_alloc<U>::type> type;
    };
 
    template <template <class, class, class> class Cont  //1arg
@@ -93,7 +73,7 @@ namespace dtl {
       , class U>
       struct container_rebind<Cont<V, A, P0>, U>
    {
-      typedef Cont<U, typename allocator_traits<A>::template portable_rebind_alloc<U>::type, P0> type;
+      typedef Cont<U, typename allocator_traits<typename real_allocator<V, A>::type>::template portable_rebind_alloc<U>::type, P0> type;
    };
 
    template <template <class, class, class, class> class Cont  //2arg
@@ -101,7 +81,7 @@ namespace dtl {
       , class U>
       struct container_rebind<Cont<V, A, P0, P1>, U>
    {
-      typedef Cont<U, typename allocator_traits<A>::template portable_rebind_alloc<U>::type, P0, P1> type;
+      typedef Cont<U, typename allocator_traits<typename real_allocator<V, A>::type>::template portable_rebind_alloc<U>::type, P0, P1> type;
    };
 
    template <template <class, class, class, class, class> class Cont  //3arg
@@ -109,7 +89,7 @@ namespace dtl {
       , class U>
       struct container_rebind<Cont<V, A, P0, P1, P2>, U>
    {
-      typedef Cont<U, typename allocator_traits<A>::template portable_rebind_alloc<U>::type, P0, P1, P2> type;
+      typedef Cont<U, typename allocator_traits<typename real_allocator<V, A>::type>::template portable_rebind_alloc<U>::type, P0, P1, P2> type;
    };
 
    template <template <class, class, class, class, class, class> class Cont  //4arg
@@ -117,7 +97,7 @@ namespace dtl {
       , class U>
       struct container_rebind<Cont<V, A, P0, P1, P2, P3>, U>
    {
-      typedef Cont<U, typename allocator_traits<A>::template portable_rebind_alloc<U>::type, P0, P1, P2, P3> type;
+      typedef Cont<U, typename allocator_traits<typename real_allocator<V, A>::type>::template portable_rebind_alloc<U>::type, P0, P1, P2, P3> type;
    };
 
    template <template <class, class, class, class, class, class, class> class Cont  //5arg
@@ -125,7 +105,7 @@ namespace dtl {
       , class U>
       struct container_rebind<Cont<V, A, P0, P1, P2, P3, P4>, U>
    {
-      typedef Cont<U, typename allocator_traits<A>::template portable_rebind_alloc<U>::type, P0, P1, P2, P3, P4> type;
+      typedef Cont<U, typename allocator_traits<typename real_allocator<V, A>::type>::template portable_rebind_alloc<U>::type, P0, P1, P2, P3, P4> type;
    };
 
    template <template <class, class, class, class, class, class, class, class> class Cont  //6arg
@@ -133,7 +113,7 @@ namespace dtl {
       , class U>
       struct container_rebind<Cont<V, A, P0, P1, P2, P3, P4, P5>, U>
    {
-      typedef Cont<U, typename allocator_traits<A>::template portable_rebind_alloc<U>::type, P0, P1, P2, P3, P4, P5> type;
+      typedef Cont<U, typename allocator_traits<typename real_allocator<V, A>::type>::template portable_rebind_alloc<U>::type, P0, P1, P2, P3, P4, P5> type;
    };
 
    template <template <class, class, class, class, class, class, class, class, class> class Cont  //7arg
@@ -141,7 +121,7 @@ namespace dtl {
       , class U>
       struct container_rebind<Cont<V, A, P0, P1, P2, P3, P4, P5, P6>, U>
    {
-      typedef Cont<U, typename allocator_traits<A>::template portable_rebind_alloc<U>::type, P0, P1, P2, P3, P4, P5, P6> type;
+      typedef Cont<U, typename allocator_traits<typename real_allocator<V, A>::type>::template portable_rebind_alloc<U>::type, P0, P1, P2, P3, P4, P5, P6> type;
    };
 
    template <template <class, class, class, class, class, class, class, class, class, class> class Cont  //8arg
@@ -149,7 +129,7 @@ namespace dtl {
       , class U>
       struct container_rebind<Cont<V, A, P0, P1, P2, P3, P4, P5, P6, P7>, U>
    {
-      typedef Cont<U, typename allocator_traits<A>::template portable_rebind_alloc<U>::type, P0, P1, P2, P3, P4, P5, P6, P7> type;
+      typedef Cont<U, typename allocator_traits<typename real_allocator<V, A>::type>::template portable_rebind_alloc<U>::type, P0, P1, P2, P3, P4, P5, P6, P7> type;
    };
 
    template <template <class, class, class, class, class, class, class, class, class, class, class> class Cont  //9arg
@@ -157,100 +137,25 @@ namespace dtl {
       , class U>
       struct container_rebind<Cont<V, A, P0, P1, P2, P3, P4, P5, P6, P7, P8>, U>
    {
-      typedef Cont<U, typename allocator_traits<A>::template portable_rebind_alloc<U>::type, P0, P1, P2, P3, P4, P5, P6, P7, P8> type;
-   };
-
-   //For small_vector/static_vector
-   template <template <class, std::size_t> class Cont  //0arg
-      , typename V, std::size_t N
-      , class U>
-      struct container_rebind<Cont<V, N>, U>
-   {
-      typedef Cont<U, N> type;
-   };
-
-   template <template <class, std::size_t, class> class Cont  //0arg
-      , typename V, std::size_t N, typename A
-      , class U>
-      struct container_rebind<Cont<V, N, A>, U>
-   {
-      typedef Cont<U, N, typename allocator_traits<A>::template portable_rebind_alloc<U>::type> type;
-   };
-
-   template <template <class, std::size_t, class, class> class Cont  //1arg
-      , typename V, std::size_t N, typename A, class P0
-      , class U>
-      struct container_rebind<Cont<V, N, A, P0>, U>
-   {
-      typedef Cont<U, N, typename allocator_traits<A>::template portable_rebind_alloc<U>::type, P0> type;
-   };
-
-   template <template <class, std::size_t, class, class, class> class Cont  //2arg
-      , typename V, std::size_t N, typename A, class P0, class P1
-      , class U>
-      struct container_rebind<Cont<V, N, A, P0, P1>, U>
-   {
-      typedef Cont<U, N, typename allocator_traits<A>::template portable_rebind_alloc<U>::type, P0, P1> type;
-   };
-
-   template <template <class, std::size_t, class, class, class, class> class Cont  //3arg
-      , typename V, std::size_t N, typename A, class P0, class P1, class P2
-      , class U>
-      struct container_rebind<Cont<V, N, A, P0, P1, P2>, U>
-   {
-      typedef Cont<U, N, typename allocator_traits<A>::template portable_rebind_alloc<U>::type, P0, P1, P2> type;
-   };
-
-   template <template <class, std::size_t, class, class, class, class, class> class Cont  //4arg
-      , typename V, std::size_t N, typename A, class P0, class P1, class P2, class P3
-      , class U>
-      struct container_rebind<Cont<V, N, A, P0, P1, P2, P3>, U>
-   {
-      typedef Cont<U, N, typename allocator_traits<A>::template portable_rebind_alloc<U>::type, P0, P1, P2, P3> type;
-   };
-
-   template <template <class, std::size_t, class, class, class, class, class, class> class Cont  //5arg
-      , typename V, std::size_t N, typename A, class P0, class P1, class P2, class P3, class P4
-      , class U>
-      struct container_rebind<Cont<V, N, A, P0, P1, P2, P3, P4>, U>
-   {
-      typedef Cont<U, N, typename allocator_traits<A>::template portable_rebind_alloc<U>::type, P0, P1, P2, P3, P4> type;
+      typedef Cont<U, typename allocator_traits<typename real_allocator<V, A>::type>::template portable_rebind_alloc<U>::type, P0, P1, P2, P3, P4, P5, P6, P7, P8> type;
    };
 
-   template <template <class, std::size_t, class, class, class, class, class, class, class> class Cont  //6arg
-      , typename V, std::size_t N, typename A, class P0, class P1, class P2, class P3, class P4, class P5
-      , class U>
-      struct container_rebind<Cont<V, N, A, P0, P1, P2, P3, P4, P5>, U>
-   {
-      typedef Cont<U, N, typename allocator_traits<A>::template portable_rebind_alloc<U>::type, P0, P1, P2, P3, P4, P5> type;
-   };
+#endif   //!defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
-   template <template <class, std::size_t, class, class, class, class, class, class, class, class> class Cont  //7arg
-      , typename V, std::size_t N, typename A, class P0, class P1, class P2, class P3, class P4, class P5, class P6
-      , class U>
-      struct container_rebind<Cont<V, N, A, P0, P1, P2, P3, P4, P5, P6>, U>
-   {
-      typedef Cont<U, N, typename allocator_traits<A>::template portable_rebind_alloc<U>::type, P0, P1, P2, P3, P4, P5, P6> type;
-   };
+   //for small_vector,static_vector
 
-   template <template <class, std::size_t, class, class, class, class, class, class, class, class, class> class Cont  //8arg
-      , typename V, std::size_t N, typename A, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7
-      , class U>
-      struct container_rebind<Cont<V, N, A, P0, P1, P2, P3, P4, P5, P6, P7>, U>
+   template <typename V, std::size_t N, typename A, class U>
+   struct container_rebind<small_vector<V, N, A>, U>
    {
-      typedef Cont<U, N, typename allocator_traits<A>::template portable_rebind_alloc<U>::type, P0, P1, P2, P3, P4, P5, P6, P7> type;
+      typedef small_vector<U, N, typename allocator_traits<typename real_allocator<V, A>::type>::template portable_rebind_alloc<U>::type> type;
    };
 
-   template <template <class, std::size_t, class, class, class, class, class, class, class, class, class, class> class Cont  //9arg
-      , typename V, std::size_t N, typename A, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8
-      , class U>
-      struct container_rebind<Cont<V, N, A, P0, P1, P2, P3, P4, P5, P6, P7, P8>, U>
+   template <typename V, std::size_t N, typename O, class U>
+   struct container_rebind<static_vector<V, N, O>, U>
    {
-      typedef Cont<U, N, typename allocator_traits<A>::template portable_rebind_alloc<U>::type, P0, P1, P2, P3, P4, P5, P6, P7, P8> type;
+      typedef static_vector<U, N, O> type;
    };
 
-#endif   //!defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-
 }  //namespace dtl {
 }  //namespace container {
 }  //namespace boost {

data/src/cxx_supportlib/vendor-modified/boost/container/detail/copy_move_algo.hpp

@@ -177,8 +177,7 @@ inline F memmove(I f, I l, F r) BOOST_NOEXCEPT_OR_NOTHROW
    value_type *const dest_raw = boost::movelib::iterator_to_raw_pointer(r);
    const value_type *const beg_raw = boost::movelib::iterator_to_raw_pointer(f);
    const value_type *const end_raw = boost::movelib::iterator_to_raw_pointer(l);
-   if(BOOST_LIKELY(beg_raw != end_raw)){
-      BOOST_ASSERT(beg_raw != 0);
+   if(BOOST_LIKELY(beg_raw != end_raw && dest_raw && beg_raw)){
       const typename boost::container::iterator_traits<I>::difference_type n = end_raw - beg_raw;
       std::memmove(dest_raw, beg_raw, sizeof(value_type)*n);
       boost::container::iterator_advance(r, n);
@@ -522,9 +521,9 @@ inline typename dtl::disable_if_memtransfer_copy_constructible<I, F, I>::type
 {
    F back = r;
    BOOST_TRY{
-      while (n--) {
+      while (n) {
          boost::container::construct_in_place(a, boost::movelib::iterator_to_raw_pointer(r), f);
-         ++f; ++r;
+         ++f; ++r; --n;
       }
    }
    BOOST_CATCH(...){
@@ -588,8 +587,10 @@ inline typename dtl::enable_if_memzero_initializable<F, F>::type
    uninitialized_value_init_alloc_n(Allocator &, typename boost::container::allocator_traits<Allocator>::size_type n, F r)
 {
    typedef typename boost::container::iterator_traits<F>::value_type value_type;
-   std::memset((void*)boost::movelib::iterator_to_raw_pointer(r), 0, sizeof(value_type)*n);
-   boost::container::iterator_advance(r, n);
+   if (BOOST_LIKELY(n)){
+      std::memset((void*)boost::movelib::iterator_to_raw_pointer(r), 0, sizeof(value_type)*n);
+      boost::container::iterator_advance(r, n);
+   }
    return r;
 }
 
@@ -893,8 +894,10 @@ inline typename dtl::enable_if_memtransfer_copy_assignable<I, F, F>::type
 {
    typedef typename boost::container::iterator_traits<I>::value_type value_type;
    const typename boost::container::iterator_traits<I>::difference_type n = boost::container::iterator_distance(f, l);
-   r -= n;
-   std::memmove((boost::movelib::iterator_to_raw_pointer)(r), (boost::movelib::iterator_to_raw_pointer)(f), sizeof(value_type)*n);
+   if (BOOST_LIKELY(n)){
+      r -= n;
+      std::memmove((boost::movelib::iterator_to_raw_pointer)(r), (boost::movelib::iterator_to_raw_pointer)(f), sizeof(value_type)*n);
+   }
    return r;
 }