passenger 6.0.18 → 6.0.20

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

@@ -45,8 +45,6 @@
 #if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 #include <boost/move/detail/fwd_macros.hpp>
 #endif
-// other
-#include <boost/core/no_exceptions_support.hpp>
 
 
 namespace boost {
@@ -417,26 +415,26 @@ struct node_alloc_holder
    NodePtr create_node_from_key(BOOST_FWD_REF(KeyConvertible) key)
    {
       NodePtr p = this->allocate_one();
-      BOOST_TRY{
+      BOOST_CONTAINER_TRY{
          ::new(boost::movelib::iterator_to_raw_pointer(p), boost_container_new_t()) Node;
          NodeAlloc &na = this->node_alloc();
          node_allocator_traits_type::construct
             (na, dtl::addressof(p->get_real_data().first), boost::forward<KeyConvertible>(key));
-         BOOST_TRY{
+         BOOST_CONTAINER_TRY{
             node_allocator_traits_type::construct(na, dtl::addressof(p->get_real_data().second));
          }
-         BOOST_CATCH(...){
+         BOOST_CONTAINER_CATCH(...){
             node_allocator_traits_type::destroy(na, dtl::addressof(p->get_real_data().first));
-            BOOST_RETHROW;
+            BOOST_CONTAINER_RETHROW;
          }
-         BOOST_CATCH_END
+         BOOST_CONTAINER_CATCH_END
       }
-      BOOST_CATCH(...) {
+      BOOST_CONTAINER_CATCH(...) {
          p->destroy_header();
          this->node_alloc().deallocate(p, 1);
-         BOOST_RETHROW
+         BOOST_CONTAINER_RETHROW
       }
-      BOOST_CATCH_END
+      BOOST_CONTAINER_CATCH_END
       return (p);
    }
 
@@ -470,7 +468,7 @@ struct node_alloc_holder
          chain.clear();
 
          Node *p = 0;
-            BOOST_TRY{
+            BOOST_CONTAINER_TRY{
             Deallocator node_deallocator(NodePtr(), nalloc);
             dtl::scoped_node_destructor<NodeAlloc> sdestructor(nalloc, 0);
             while(n){
@@ -490,12 +488,12 @@ struct node_alloc_holder
             sdestructor.release();
             node_deallocator.release();
          }
-         BOOST_CATCH(...){
+         BOOST_CONTAINER_CATCH(...){
             chain.incorporate_after(chain.last(), &*itbeg, &*itlast, n);
             node_allocator_version_traits_type::deallocate_individual(this->node_alloc(), chain);
-            BOOST_RETHROW
+            BOOST_CONTAINER_RETHROW
          }
-         BOOST_CATCH_END
+         BOOST_CONTAINER_CATCH_END
       }
    }
 

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

@@ -33,7 +33,6 @@
 #include <boost/intrusive/set.hpp>
 #include <boost/intrusive/slist.hpp>
 
-#include <boost/core/no_exceptions_support.hpp>
 #include <boost/assert.hpp>
 #include <cstddef>
 
@@ -85,21 +84,21 @@ class private_node_pool_impl
    {}
 
    //!Destructor. Deallocates all allocated blocks. Never throws
-   ~private_node_pool_impl()
+   BOOST_CONTAINER_FORCEINLINE ~private_node_pool_impl()
    {  this->purge_blocks();  }
 
-   size_type get_real_num_node() const
+   BOOST_CONTAINER_FORCEINLINE size_type get_real_num_node() const
    {  return m_nodes_per_block; }
 
    //!Returns the segment manager. Never throws
-   segment_manager_base_type* get_segment_manager_base()const
+   BOOST_CONTAINER_FORCEINLINE segment_manager_base_type* get_segment_manager_base()const
    {  return boost::movelib::to_raw_pointer(mp_segment_mngr_base);  }
 
-   void *allocate_node()
+   BOOST_CONTAINER_FORCEINLINE void *allocate_node()
    {  return this->priv_alloc_node();  }
 
    //!Deallocates an array pointed by ptr. Never throws
-   void deallocate_node(void *ptr)
+   BOOST_CONTAINER_FORCEINLINE void deallocate_node(void *ptr)
    {  this->priv_dealloc_node(ptr); }
 
    //!Allocates a singly linked list of n nodes ending in null pointer.
@@ -206,7 +205,7 @@ class private_node_pool_impl
          , backup_list.size());
    }
 
-   size_type num_free_nodes()
+   BOOST_CONTAINER_FORCEINLINE size_type num_free_nodes()
    {  return m_freelist.size();  }
 
    //!Deallocates all used memory. Precondition: all nodes allocated from this pool should
@@ -310,7 +309,7 @@ class private_node_pool_impl
       size_type blocksize =
          (get_rounded_size)(m_real_node_size*m_nodes_per_block, (size_type)alignment_of<node_t>::value);
 
-      BOOST_TRY{
+      BOOST_CONTAINER_TRY{
          for(size_type i = 0; i != num_blocks; ++i){
             //We allocate a new NodeBlock and put it as first
             //element in the free Node list
@@ -326,11 +325,11 @@ class private_node_pool_impl
             }
          }
       }
-      BOOST_CATCH(...){
+      BOOST_CONTAINER_CATCH(...){
          //to-do: if possible, an efficient way to deallocate allocated blocks
-         BOOST_RETHROW
+         BOOST_CONTAINER_RETHROW
       }
-      BOOST_CATCH_END
+      BOOST_CONTAINER_CATCH_END
    }
 
    //!Deprecated, use deallocate_free_blocks

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

@@ -10,14 +10,6 @@
 //
 ///////////////////////////////////////////////////////////////////////////////
 
-#ifndef BOOST_CONFIG_HPP
-#  include <boost/config.hpp>
-#endif
-
-#if defined(BOOST_HAS_PRAGMA_ONCE)
-#  pragma once
-#endif
-
 #include <cstddef>
 
 struct boost_container_new_t{};

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

@@ -53,8 +53,6 @@
 #endif
 #include <boost/move/detail/move_helpers.hpp>
 #include <boost/move/detail/force_ptr.hpp>
-// other
-#include <boost/core/no_exceptions_support.hpp>
 
 
 
@@ -311,20 +309,20 @@ class RecyclingCloner
    {
       if(node_ptr_type p = m_icont.unlink_leftmost_without_rebalance()){
          //First recycle a node (this can't throw)
-         BOOST_TRY{
+         BOOST_CONTAINER_TRY{
             //This can throw
             this->do_assign(p, other, bool_<DoMove>());
             return p;
          }
-         BOOST_CATCH(...){
+         BOOST_CONTAINER_CATCH(...){
             //If there is an exception destroy the whole source
             m_holder.destroy_node(p);
             while((p = m_icont.unlink_leftmost_without_rebalance())){
                m_holder.destroy_node(p);
             }
-            BOOST_RETHROW
+            BOOST_CONTAINER_RETHROW
          }
-         BOOST_CATCH_END
+         BOOST_CONTAINER_CATCH_END
       }
       else{
          return m_holder.create_node(boost::move(other.get_real_data()));
@@ -425,7 +423,8 @@ class tree
 
    public:
 
-   typedef typename key_of_value_t::type                    key_type;
+   typedef typename dtl::remove_const
+      <typename key_of_value_t::type>::type                 key_type;
    typedef T                                                value_type;
    typedef Compare                                          key_compare;
    typedef ValComp                                          value_compare;

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

@@ -152,6 +152,39 @@
 //#define BOOST_CONTAINER_USE_STD_EXCEPTIONS
 
 
+namespace boost {
+namespace container {
 
+template <typename T1>
+BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void ignore(T1 const&)
+{}
+
+}} //namespace boost::container {
+
+#if !(defined BOOST_NO_EXCEPTIONS)
+#    define BOOST_CONTAINER_TRY { try
+#    define BOOST_CONTAINER_CATCH(x) catch(x)
+#    define BOOST_CONTAINER_RETHROW throw;
+#    define BOOST_CONTAINER_CATCH_END }
+#else
+#    if !defined(BOOST_MSVC) || BOOST_MSVC >= 1900
+#        define BOOST_CONTAINER_TRY { if (true)
+#        define BOOST_CONTAINER_CATCH(x) else if (false)
+#    else
+// warning C4127: conditional expression is constant
+#        define BOOST_CONTAINER_TRY { \
+             __pragma(warning(push)) \
+             __pragma(warning(disable: 4127)) \
+             if (true) \
+             __pragma(warning(pop))
+#        define BOOST_CONTAINER_CATCH(x) else \
+             __pragma(warning(push)) \
+             __pragma(warning(disable: 4127)) \
+             if (false) \
+             __pragma(warning(pop))
+#    endif
+#    define BOOST_CONTAINER_RETHROW
+#    define BOOST_CONTAINER_CATCH_END }
+#endif
 
 #endif   //#ifndef BOOST_CONTAINER_DETAIL_WORKAROUND_HPP

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

@@ -15,11 +15,9 @@
 #include <boost/container/detail/config_begin.hpp>
 #include <boost/container/detail/workaround.hpp>
 
-//#include <algorithm>
 #include <cstring> // memcpy
 
 #include <boost/assert.hpp>
-#include <boost/type_traits/aligned_storage.hpp>
 
 #include <boost/container/detail/copy_move_algo.hpp>
 #include <boost/container/new_allocator.hpp> //new_allocator
@@ -50,8 +48,6 @@
 #include <boost/move/algo/detail/merge.hpp>
 #include <boost/move/detail/force_ptr.hpp>
 
-#include <boost/type_traits/is_nothrow_move_constructible.hpp>
-
 //std
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
 #include <initializer_list>    //for std::initializer_list
@@ -350,17 +346,17 @@ class devector
       )
       : m_(allocator)
    {
-      BOOST_TRY{
+      BOOST_CONTAINER_TRY{
          while (first != last) {
             this->emplace_back(*first++);
          }
          BOOST_ASSERT(invariants_ok());
       }
-      BOOST_CATCH(...){
+      BOOST_CONTAINER_CATCH(...){
          this->destroy_elements(m_.buffer + m_.front_idx, m_.buffer + m_.back_idx);
          this->deallocate_buffer();
       }
-      BOOST_CATCH_END
+      BOOST_CONTAINER_CATCH_END
    }
 
    #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED

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

@@ -43,8 +43,6 @@
 // intrusive
 #include <boost/intrusive/detail/minimal_pair_header.hpp>      //pair
 #include <boost/intrusive/detail/minimal_less_equal_header.hpp>//less, equal
-//others
-#include <boost/core/no_exceptions_support.hpp>
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
 #include <initializer_list>

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

@@ -1097,7 +1097,7 @@ class flat_set
    //!
    //! <b>Postcondition</b>: this->empty()
    //!
-   //! <b>Throws</b>: If secuence_type's move constructor throws 
+   //! <b>Throws</b>: If sequence_type's move constructor throws 
    sequence_type extract_sequence();
 
    #endif   //#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED

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

@@ -46,7 +46,6 @@
 #include <boost/intrusive/detail/minimal_less_equal_header.hpp>//less, equal
 // other
 #include <boost/static_assert.hpp>
-#include <boost/core/no_exceptions_support.hpp>
 // std
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
 #include <initializer_list>

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

@@ -30,7 +30,8 @@
 #include <boost/move/utility_core.hpp>
 #include <boost/move/adl_move_swap.hpp>
 
-#include <boost/type_traits/aligned_storage.hpp>
+#include <boost/container/detail/mpl.hpp>
+#include <boost/assert.hpp>
 
 
 //!\file
@@ -111,15 +112,16 @@ class node_handle
    BOOST_MOVABLE_BUT_NOT_COPYABLE(node_handle)
 
    typedef typename nator_traits::pointer                         node_pointer;
-   typedef ::boost::aligned_storage
+   typedef typename dtl::aligned_storage
       < sizeof(nallocator_type)
-      , boost::alignment_of<nallocator_type>::value>              nalloc_storage_t;
+      , dtl::alignment_of<nallocator_type>::value
+      >::type                                                     nalloc_storage_t;
 
    node_pointer      m_ptr;
    nalloc_storage_t  m_nalloc_storage;
 
    void move_construct_alloc(nallocator_type &al)
-   {  ::new(m_nalloc_storage.address(), boost_container_new_t()) nallocator_type(::boost::move(al));   }
+   {  ::new((void*)m_nalloc_storage.data, boost_container_new_t()) nallocator_type(::boost::move(al));   }
 
    void destroy_deallocate_node()
    {
@@ -131,7 +133,7 @@ class node_handle
    void move_construct_end(OtherNodeHandle &nh)
    {
       if(m_ptr){
-         ::new (m_nalloc_storage.address(), boost_container_new_t()) nallocator_type(::boost::move(nh.node_alloc()));
+         ::new ((void*)m_nalloc_storage.data, boost_container_new_t()) nallocator_type(::boost::move(nh.node_alloc()));
          node_handle_friend::destroy_alloc(nh);
          node_handle_friend::get_node_pointer(nh) = node_pointer();
       }
@@ -139,7 +141,7 @@ class node_handle
    }
 
    void destroy_alloc() BOOST_NOEXCEPT
-   {  static_cast<nallocator_type*>(m_nalloc_storage.address())->~nallocator_type();  }
+   {  static_cast<nallocator_type*>((void*)m_nalloc_storage.data)->~nallocator_type();  }
 
    node_pointer &get_node_pointer() BOOST_NOEXCEPT
    {  return m_ptr;  }
@@ -160,7 +162,7 @@ class node_handle
       :  m_ptr(p)
    {
       if(m_ptr){
-         ::new (m_nalloc_storage.address(), boost_container_new_t()) nallocator_type(al);
+         ::new ((void*)m_nalloc_storage.data, boost_container_new_t()) nallocator_type(al);
       }
    }
 
@@ -373,7 +375,7 @@ class node_handle
    nallocator_type &node_alloc() BOOST_NOEXCEPT
    {
       BOOST_ASSERT(!empty());
-      return *static_cast<nallocator_type*>(m_nalloc_storage.address());
+      return *static_cast<nallocator_type*>((void*)m_nalloc_storage.data);
    }
 
 
@@ -383,7 +385,7 @@ class node_handle
    const nallocator_type &node_alloc() const BOOST_NOEXCEPT
    {
       BOOST_ASSERT(!empty());
-      return *static_cast<const nallocator_type*>(m_nalloc_storage.address());
+      return *static_cast<const nallocator_type*>((const void*)m_nalloc_storage.data);
    }
 
    //! <b>Effects</b>: x.swap(y).

data/src/cxx_supportlib/vendor-modified/boost/container/pmr/memory_resource.hpp

@@ -54,7 +54,7 @@ class memory_resource
    {  return this->do_deallocate(p, bytes, alignment);  }
 
    //! <b>Effects</b>: Equivalent to
-   //! `return return do_is_equal(other);`
+   //! `return do_is_equal(other);`
    bool is_equal(const memory_resource& other) const BOOST_NOEXCEPT
    {  return this->do_is_equal(other);  }
    

data/src/cxx_supportlib/vendor-modified/boost/container/pmr/polymorphic_allocator.hpp

@@ -22,6 +22,7 @@
 #include <boost/container/new_allocator.hpp>
 #include <boost/container/pmr/memory_resource.hpp>
 #include <boost/container/pmr/global_resource.hpp>
+#include <boost/assert.hpp>
 
 #include <cstddef>
 

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

@@ -38,8 +38,6 @@
 #endif
 #include <boost/move/utility_core.hpp>
 
-#include <boost/core/no_exceptions_support.hpp>
-
 namespace boost { namespace container {
 
 #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED

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

@@ -48,8 +48,6 @@
 #endif
 #include <boost/move/detail/move_helpers.hpp>
 #include <boost/move/detail/force_ptr.hpp>
-// other
-#include <boost/core/no_exceptions_support.hpp>
 // std
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
 #include <initializer_list>

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

@@ -345,7 +345,7 @@ class small_vector_base
    public:
    //Make it public as it will be inherited by small_vector and container
    //must have this public member
-   typedef typename real_allocator<T, SecAlloc>::type                  secondary_allocator_t;
+   typedef typename real_allocator<T, SecAlloc>::type                            secondary_allocator_t;
    typedef typename allocator_traits<secondary_allocator_t>::
       template portable_rebind_alloc<void>::type                                 void_allocator_t;
    typedef typename dtl::get_small_vector_opt<Options>::type                     options_t;
@@ -387,6 +387,24 @@ class small_vector_base
       : base_type(initial_capacity_t(), this->internal_storage(), capacity, ::boost::forward<AllocFwd>(a))
    {}
 
+   BOOST_CONTAINER_FORCEINLINE explicit small_vector_base(maybe_initial_capacity_t, std::size_t initial_capacity, std::size_t initial_size)
+      : base_type( maybe_initial_capacity_t()
+                 , (initial_capacity >= initial_size) ? this->internal_storage() : pointer()
+                 , (initial_capacity >= initial_size) ? initial_capacity : initial_size
+                 )
+   {}
+
+   template<class AllocFwd>
+   BOOST_CONTAINER_FORCEINLINE explicit small_vector_base(maybe_initial_capacity_t, std::size_t initial_capacity, std::size_t initial_size, BOOST_FWD_REF(AllocFwd) a)
+      : base_type(maybe_initial_capacity_t()
+                 , (initial_capacity >= initial_size) ? this->internal_storage() : pointer()
+                 , (initial_capacity >= initial_size) ? initial_capacity : initial_size
+                 , ::boost::forward<AllocFwd>(a)
+      )
+   {}
+
+   using base_type::protected_set_size;
+
    //~small_vector_base(){}
    #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
@@ -408,9 +426,10 @@ class small_vector_base
          this->steal_resources(x);
       }
       else{
-         this->assign( boost::make_move_iterator(boost::movelib::iterator_to_raw_pointer(x.begin()))
-                     , boost::make_move_iterator(boost::movelib::iterator_to_raw_pointer(x.end  ()))
-                     );
+         const typename base_type::size_type sz = x.size();
+         ::boost::container::uninitialized_move_alloc_n_source
+            (this->base_type::get_stored_allocator(), x.begin(), sz, this->begin());
+         this->protected_set_size(sz);
          x.clear();
       }
    }
@@ -546,28 +565,28 @@ class small_vector
    {}
 
    BOOST_CONTAINER_FORCEINLINE explicit small_vector(size_type n)
-      : base_type(initial_capacity_t(), internal_capacity())
-   {  this->resize(n); }
+      : base_type(maybe_initial_capacity_t(), internal_capacity(), n)
+   {  this->protected_init_n(n, value_init); }
 
    BOOST_CONTAINER_FORCEINLINE small_vector(size_type n, const allocator_type &a)
-      : base_type(initial_capacity_t(), internal_capacity(), a)
-   {  this->resize(n); }
+      : base_type(maybe_initial_capacity_t(), internal_capacity(), n, a)
+   {  this->protected_init_n(n, value_init); }
 
    BOOST_CONTAINER_FORCEINLINE small_vector(size_type n, default_init_t)
-      : base_type(initial_capacity_t(), internal_capacity())
-   {  this->resize(n, default_init_t()); }
+      : base_type(maybe_initial_capacity_t(), internal_capacity(), n)
+   {  this->protected_init_n(n, default_init_t()); }
 
    BOOST_CONTAINER_FORCEINLINE small_vector(size_type n, default_init_t, const allocator_type &a)
-      : base_type(initial_capacity_t(), internal_capacity(), a)
-   {  this->resize(n, default_init_t()); }
+      : base_type(maybe_initial_capacity_t(), internal_capacity(), n, a)
+   {  this->protected_init_n(n, default_init_t()); }
 
    BOOST_CONTAINER_FORCEINLINE small_vector(size_type n, const value_type &v)
-      : base_type(initial_capacity_t(), internal_capacity())
-   {  this->resize(n, v); }
+      : base_type(maybe_initial_capacity_t(), internal_capacity(), n)
+   {  this->protected_init_n(n, v); }
 
    BOOST_CONTAINER_FORCEINLINE small_vector(size_type n, const value_type &v, const allocator_type &a)
-      : base_type(initial_capacity_t(), internal_capacity(), a)
-   {  this->resize(n, v); }
+      : base_type(maybe_initial_capacity_t(), internal_capacity(), n, a)
+   {  this->protected_init_n(n, v); }
 
    template <class InIt>
    BOOST_CONTAINER_FORCEINLINE small_vector(InIt first, InIt last

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

@@ -60,7 +60,6 @@
 #include <boost/move/detail/iterator_to_raw_pointer.hpp>
 // other
 #include <boost/assert.hpp>
-#include <boost/core/no_exceptions_support.hpp>
 // std
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
 #include <initializer_list>
@@ -2091,38 +2090,38 @@ class stable_vector
    {
       node_type *praw = ::new(boost::movelib::iterator_to_raw_pointer(p), boost_container_new_t())
          node_type(index_traits_type::ptr_to_node_base_ptr(*up_index));
-      BOOST_TRY{
+      BOOST_CONTAINER_TRY{
          //This can throw
          boost::container::construct_in_place
             ( this->priv_node_alloc()
             , praw->get_data_ptr()
             , it);
       }
-      BOOST_CATCH(...) {
+      BOOST_CONTAINER_CATCH(...) {
          praw->destroy_header();
          this->priv_node_alloc().deallocate(p, 1);
-         BOOST_RETHROW
+         BOOST_CONTAINER_RETHROW
       }
-      BOOST_CATCH_END
+      BOOST_CONTAINER_CATCH_END
    }
 
    template<class ValueConvertible>
    void priv_build_node_from_convertible(const node_ptr &p, BOOST_FWD_REF(ValueConvertible) value_convertible)
    {
       node_type *praw = ::new(boost::movelib::iterator_to_raw_pointer(p), boost_container_new_t()) node_type;
-      BOOST_TRY{
+      BOOST_CONTAINER_TRY{
          //This can throw
          boost::container::allocator_traits<node_allocator_type>::construct
             ( this->priv_node_alloc()
             , p->get_data_ptr()
             , ::boost::forward<ValueConvertible>(value_convertible));
       }
-      BOOST_CATCH(...) {
+      BOOST_CONTAINER_CATCH(...) {
          praw->destroy_header();
          this->priv_node_alloc().deallocate(p, 1);
-         BOOST_RETHROW
+         BOOST_CONTAINER_RETHROW
       }
-      BOOST_CATCH_END
+      BOOST_CONTAINER_CATCH_END
    }
 
    void priv_swap_members(stable_vector &x)

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

@@ -50,7 +50,6 @@
 #include <boost/move/traits.hpp>
 
 #include <boost/static_assert.hpp>
-#include <boost/core/no_exceptions_support.hpp>
 
 #include <iosfwd> 
 #include <istream>   //
@@ -65,6 +64,13 @@
 #include <initializer_list>   //for std::initializer_list
 #endif
 
+//GCC 12 has a regression for array-bounds warnings
+#if defined(BOOST_GCC) && (BOOST_GCC >= 120000) && (BOOST_GCC < 130000)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Warray-bounds"
+#endif
+
+
 namespace boost {
 namespace container {
 
@@ -2962,7 +2968,7 @@ class basic_string
       const size_type long_size    = this->priv_long_size();
       const size_type long_storage = this->priv_long_storage();
       //We can make this nothrow as chars are always NoThrowCopyables
-      BOOST_TRY{
+      BOOST_CONTAINER_TRY{
          pointer reuse = 0;
          real_cap = long_size+1;
          const pointer ret = this->allocation_command(allocate_new, long_size+1, real_cap, reuse);
@@ -2975,10 +2981,10 @@ class basic_string
          //And release old buffer
          this->alloc().deallocate(long_addr, long_storage);
       }
-      BOOST_CATCH(...){
+      BOOST_CONTAINER_CATCH(...){
          return;
       }
-      BOOST_CATCH_END
+      BOOST_CONTAINER_CATCH_END
    }
 
    template<class AllocVersion>
@@ -3008,20 +3014,20 @@ class basic_string
       //Save initial position
       FwdIt init = first;
 
-      BOOST_TRY{
+      BOOST_CONTAINER_TRY{
          //Construct objects
          for (; count--; ++first){
             this->construct(first, val);
          }
       }
-      BOOST_CATCH(...){
+      BOOST_CONTAINER_CATCH(...){
          //Call destructors
          for (; init != first; ++init){
             this->destroy(init);
          }
-         BOOST_RETHROW
+         BOOST_CONTAINER_RETHROW
       }
-      BOOST_CATCH_END
+      BOOST_CONTAINER_CATCH_END
    }
 
    template<class InpIt, class FwdIt> inline
@@ -3031,20 +3037,20 @@ class basic_string
       FwdIt dest_init = dest;
       size_type constructed = 0;
 
-      BOOST_TRY{
+      BOOST_CONTAINER_TRY{
          //Try to build objects
          for (; first != last; ++dest, ++first, ++constructed){
             this->construct(dest, *first);
          }
       }
-      BOOST_CATCH(...){
+      BOOST_CONTAINER_CATCH(...){
          //Call destructors
          for (; constructed--; ++dest_init){
             this->destroy(dest_init);
          }
-         BOOST_RETHROW
+         BOOST_CONTAINER_RETHROW
       }
-      BOOST_CATCH_END
+      BOOST_CONTAINER_CATCH_END
       return (constructed);
    }
 
@@ -3589,6 +3595,11 @@ inline std::size_t hash_value(basic_string<Ch, std::char_traits<Ch>, Allocator>
 
 }}
 
+//GCC 12 has a regression for array-bounds warnings
+#if defined(BOOST_GCC) && (BOOST_GCC >= 120000) && (BOOST_GCC < 130000)
+#pragma GCC diagnostic pop
+#endif
+
 
 #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED