passenger 6.0.19 → 6.0.20

data/src/cxx_supportlib/vendor-modified/boost/config/stdlib/libstdcpp3.hpp

@@ -139,6 +139,13 @@
 //
 #ifdef __clang__
 
+#ifdef _GLIBCXX_RELEASE
+#  define BOOST_LIBSTDCXX_VERSION (_GLIBCXX_RELEASE * 10000 + 100)
+#else
+//
+// We figure out which gcc version issued this std lib
+// by checking which headers are available:
+//
 #if __has_include(<expected>)
 #  define BOOST_LIBSTDCXX_VERSION 120100
 #elif __has_include(<source_location>)
@@ -170,6 +177,7 @@
 #elif __has_include(<array>)
 #  define BOOST_LIBSTDCXX_VERSION 40300
 #endif
+#endif
 //
 // If BOOST_HAS_FLOAT128 is set, now that we know the std lib is libstdc++3, check to see if the std lib is
 // configured to support this type.  If not disable it:
@@ -259,7 +267,7 @@ extern "C" char *gets (char *__s);
 #     if !_GLIBCXX_DEPRECATED
 #        define BOOST_NO_AUTO_PTR
 #     endif
-#  elif !_GLIBCXX_USE_DEPRECATED
+#  elif !defined(_GLIBCXX_USE_DEPRECATED) || !_GLIBCXX_USE_DEPRECATED
 #     define BOOST_NO_AUTO_PTR
 #     define BOOST_NO_CXX98_BINDERS
 #  endif
@@ -431,6 +439,13 @@ extern "C" char *gets (char *__s);
 #endif
 #endif
 
+#if defined(__clang__) && (BOOST_LIBSTDCXX_VERSION < 40300) && !defined(BOOST_NO_CXX11_NULLPTR)
+#  define BOOST_NO_CXX11_NULLPTR
+#endif
+#if defined(__clang__) && (BOOST_LIBSTDCXX_VERSION < 40300) && defined(BOOST_HAS_INT128) && defined(__APPLE_CC__)
+#undef BOOST_HAS_INT128
+#endif
+
 //
 // Headers not present on Solaris with the Oracle compiler:
 #if defined(__SUNPRO_CC) && (__SUNPRO_CC < 0x5140)

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

@@ -186,35 +186,6 @@ template <class Key
          ,class Allocator = void >
 class flat_multimap;
 
-//Experimental forward declarations, not implemented yet!
-template <class Key
-         ,class Hash //= hash<Key>,
-         ,class Pred = std::equal_to<Key>
-         ,class Compare  = std::less<Key>
-         ,class Allocator = void
-         ,class Options = void>
-class hash_set;
-
-template <class Key
-         ,class Compare  = std::less<Key>
-         ,class Allocator = void
-         ,class Options = void >
-class hash_multiset;
-
-template <class Key
-         ,class T
-         ,class Compare  = std::less<Key>
-         ,class Allocator = void
-         ,class Options = void >
-class hash_map;
-
-template <class Key
-         ,class T
-         ,class Compare  = std::less<Key>
-         ,class Allocator = void
-         ,class Options = void >
-class hash_multimap;
-
 #ifndef BOOST_NO_CXX11_TEMPLATE_ALIASES
 
 //! Alias templates for small_flat_[multi]{set|map} using small_vector as container

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

@@ -50,7 +50,6 @@
 #include <boost/move/detail/move_helpers.hpp>
 // other
 #include <boost/assert.hpp>
-#include <boost/core/no_exceptions_support.hpp>
 // std
 #include <cstddef>
 
@@ -434,16 +433,16 @@ class deque_base
          ptr_alloc_ptr nstart = this->members_.m_map + difference_type(this->members_.m_map_size - num_nodes) / 2;
          ptr_alloc_ptr nfinish = nstart + difference_type(num_nodes);
 
-         BOOST_TRY {
+         BOOST_CONTAINER_TRY {
             this->priv_create_nodes(nstart, nfinish);
          }
-         BOOST_CATCH(...){
+         BOOST_CONTAINER_CATCH(...){
             this->priv_deallocate_map(this->members_.m_map, this->members_.m_map_size);
             this->members_.m_map = 0;
             this->members_.m_map_size = 0;
-            BOOST_RETHROW
+            BOOST_CONTAINER_RETHROW
          }
-         BOOST_CATCH_END
+         BOOST_CONTAINER_CATCH_END
 
          this->members_.m_start.priv_set_node(nstart, get_block_size());
          this->members_.m_finish.priv_set_node(nfinish - 1, get_block_size());
@@ -455,15 +454,15 @@ class deque_base
    void priv_create_nodes(ptr_alloc_ptr nstart, ptr_alloc_ptr nfinish)
    {
       ptr_alloc_ptr cur = nstart;
-      BOOST_TRY {
+      BOOST_CONTAINER_TRY {
          for (; cur < nfinish; ++cur)
             *cur = this->priv_allocate_node();
       }
-      BOOST_CATCH(...){
+      BOOST_CONTAINER_CATCH(...){
          this->priv_destroy_nodes(nstart, cur);
-         BOOST_RETHROW
+         BOOST_CONTAINER_RETHROW
       }
-      BOOST_CATCH_END
+      BOOST_CONTAINER_CATCH_END
    }
 
    void priv_destroy_nodes(ptr_alloc_ptr nstart, ptr_alloc_ptr nfinish) BOOST_NOEXCEPT_OR_NOTHROW
@@ -2123,15 +2122,15 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
                const size_type raw_gap = n - elemsafter;
                ::boost::container::uninitialized_move_alloc
                   (this->alloc(), pos, old_finish, old_finish + difference_type(raw_gap));
-               BOOST_TRY{
+               BOOST_CONTAINER_TRY{
                   proxy.copy_n_and_update(this->alloc(), pos, elemsafter);
                   proxy.uninitialized_copy_n_and_update(this->alloc(), old_finish, raw_gap);
                }
-               BOOST_CATCH(...){
+               BOOST_CONTAINER_CATCH(...){
                   this->priv_destroy_range(old_finish, old_finish + difference_type(elemsafter));
-                  BOOST_RETHROW
+                  BOOST_CONTAINER_RETHROW
                }
-               BOOST_CATCH_END
+               BOOST_CONTAINER_CATCH_END
                this->members_.m_finish = new_finish;
             }
          }
@@ -2176,7 +2175,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    void priv_fill_initialize(const value_type& value)
    {
       index_pointer cur = this->members_.m_start.m_node;
-      BOOST_TRY {
+      BOOST_CONTAINER_TRY {
          for ( ; cur < this->members_.m_finish.m_node; ++cur){
             boost::container::uninitialized_fill_alloc
                (this->alloc(), *cur, *cur + get_block_ssize(), value);
@@ -2184,26 +2183,26 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
          boost::container::uninitialized_fill_alloc
             (this->alloc(), this->members_.m_finish.m_first, this->members_.m_finish.m_cur, value);
       }
-      BOOST_CATCH(...){
+      BOOST_CONTAINER_CATCH(...){
          this->priv_destroy_range(this->members_.m_start, iterator(*cur, cur, get_block_size()));
-         BOOST_RETHROW
+         BOOST_CONTAINER_RETHROW
       }
-      BOOST_CATCH_END
+      BOOST_CONTAINER_CATCH_END
    }
 
    template <class InIt>
    void priv_range_initialize(InIt first, InIt last, typename iterator_enable_if_tag<InIt, std::input_iterator_tag>::type* =0)
    {
       this->priv_initialize_map(0);
-      BOOST_TRY {
+      BOOST_CONTAINER_TRY {
          for ( ; first != last; ++first)
             this->emplace_back(*first);
       }
-      BOOST_CATCH(...){
+      BOOST_CONTAINER_CATCH(...){
          this->clear();
-         BOOST_RETHROW
+         BOOST_CONTAINER_RETHROW
       }
-      BOOST_CATCH_END
+      BOOST_CONTAINER_CATCH_END
    }
 
    template <class FwdIt>
@@ -2214,7 +2213,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
       this->priv_initialize_map(n);
 
       index_pointer cur_node = this->members_.m_start.m_node;
-      BOOST_TRY {
+      BOOST_CONTAINER_TRY {
          for (; cur_node < this->members_.m_finish.m_node; ++cur_node) {
             FwdIt mid = first;
             boost::container::iterator_uadvance(mid, get_block_size());
@@ -2223,11 +2222,11 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
          }
          ::boost::container::uninitialized_copy_alloc(this->alloc(), first, last, this->members_.m_finish.m_first);
       }
-      BOOST_CATCH(...){
+      BOOST_CONTAINER_CATCH(...){
          this->priv_destroy_range(this->members_.m_start, iterator(*cur_node, cur_node, get_block_size()));
-         BOOST_RETHROW
+         BOOST_CONTAINER_RETHROW
       }
-      BOOST_CATCH_END
+      BOOST_CONTAINER_CATCH_END
    }
 
    // Called only if this->members_.m_finish.m_cur == this->members_.m_finish.m_first.
@@ -2268,16 +2267,16 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
             this->priv_reallocate_map(new_nodes, true);
          }
          size_type i = 1;
-         BOOST_TRY {
+         BOOST_CONTAINER_TRY {
             for (; i <= new_nodes; ++i)
                *(this->members_.m_start.m_node - difference_type(i)) = this->priv_allocate_node();
          }
-         BOOST_CATCH(...) {
+         BOOST_CONTAINER_CATCH(...) {
             for (size_type j = 1; j < i; ++j)
                this->priv_deallocate_node(*(this->members_.m_start.m_node - difference_type(j)));
-            BOOST_RETHROW
+            BOOST_CONTAINER_RETHROW
          }
-         BOOST_CATCH_END
+         BOOST_CONTAINER_CATCH_END
       }
       return this->members_.m_start - difference_type(n);
    }
@@ -2293,16 +2292,16 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
             this->priv_reallocate_map(new_nodes, false);
          }
          size_type i = 1;
-         BOOST_TRY {
+         BOOST_CONTAINER_TRY {
             for (; i <= new_nodes; ++i)
                *(this->members_.m_finish.m_node + difference_type(i)) = this->priv_allocate_node();
          }
-         BOOST_CATCH(...) {
+         BOOST_CONTAINER_CATCH(...) {
             for (size_type j = 1; j < i; ++j)
                this->priv_deallocate_node(*(this->members_.m_finish.m_node + difference_type(j)));
-            BOOST_RETHROW
+            BOOST_CONTAINER_RETHROW
          }
-         BOOST_CATCH_END
+         BOOST_CONTAINER_CATCH_END
       }
       return this->members_.m_finish + difference_type(n);
    }

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

@@ -42,7 +42,6 @@
 #include <boost/intrusive/slist.hpp>
 // other
 #include <boost/assert.hpp>
-#include <boost/core/no_exceptions_support.hpp>
 #include <cstddef>
 
 namespace boost {
@@ -760,7 +759,7 @@ class private_adaptive_node_pool_impl_common
                            , const size_type real_num_node, const size_type num_subblocks)
    {
       size_type i = 0;
-      BOOST_TRY{
+      BOOST_CONTAINER_TRY{
          this->priv_invariants(real_num_node, num_subblocks, real_block_alignment);
          while(i != n){
             //If there are no free nodes we allocate all needed blocks
@@ -800,12 +799,12 @@ class private_adaptive_node_pool_impl_common
             i += num_elems;
          }
       }
-      BOOST_CATCH(...){
+      BOOST_CONTAINER_CATCH(...){
          this->priv_deallocate_nodes(chain, max_free_blocks, real_num_node, num_subblocks, real_block_alignment);
          this->priv_invariants(real_num_node, num_subblocks, real_block_alignment);
-         BOOST_RETHROW
+         BOOST_CONTAINER_RETHROW
       }
-      BOOST_CATCH_END
+      BOOST_CONTAINER_CATCH_END
       this->priv_invariants(real_num_node, num_subblocks, real_block_alignment);
    }
 

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

@@ -41,7 +41,6 @@
 #include <boost/move/detail/force_ptr.hpp>
 // other
 #include <boost/assert.hpp>
-#include <boost/core/no_exceptions_support.hpp>
 
 namespace boost { namespace container { namespace dtl {
 
@@ -315,14 +314,14 @@ struct insert_emplace_proxy
       typename dtl::aligned_storage<sizeof(value_type), dtl::alignment_of<value_type>::value>::type v;
       alloc_traits::construct(a, move_detail::force_ptr<value_type *>(&v), ::boost::forward<Args>(get<IdxPack>(this->args_))...);
       value_type *vp = move_detail::force_ptr<value_type *>(&v);
-      BOOST_TRY{
+      BOOST_CONTAINER_TRY{
          *p = ::boost::move(*vp);
       }
-      BOOST_CATCH(...){
+      BOOST_CONTAINER_CATCH(...){
          alloc_traits::destroy(a, vp);
-         BOOST_RETHROW
+         BOOST_CONTAINER_RETHROW
       }
-      BOOST_CATCH_END
+      BOOST_CONTAINER_CATCH_END
       alloc_traits::destroy(a, vp);
    }
 };
@@ -438,14 +437,14 @@ struct insert_emplace_proxy_arg##N\
       typename dtl::aligned_storage<sizeof(value_type), dtl::alignment_of<value_type>::value>::type v;\
       alloc_traits::construct(a, move_detail::force_ptr<value_type *>(&v) BOOST_MOVE_I##N BOOST_MOVE_MFWD##N);\
       value_type *vp = move_detail::force_ptr<value_type *>(&v);\
-      BOOST_TRY{\
+      BOOST_CONTAINER_TRY{\
          *p = ::boost::move(*vp);\
       }\
-      BOOST_CATCH(...){\
+      BOOST_CONTAINER_CATCH(...){\
          alloc_traits::destroy(a, vp);\
-         BOOST_RETHROW\
+         BOOST_CONTAINER_RETHROW\
       }\
-      BOOST_CATCH_END\
+      BOOST_CONTAINER_CATCH_END\
       alloc_traits::destroy(a, vp);\
    }\
 };\

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

@@ -29,7 +29,6 @@
 #include <boost/container/detail/allocation_type.hpp>       //allocation_type
 #include <boost/container/detail/mpl.hpp>                   //integral_constant
 #include <boost/intrusive/pointer_traits.hpp>               //pointer_traits
-#include <boost/core/no_exceptions_support.hpp>             //BOOST_TRY
 
 namespace boost {
 namespace container {
@@ -47,19 +46,19 @@ struct allocator_version_traits
    typedef typename boost::container::allocator_traits<Allocator>::size_type  size_type;
 
    //Node allocation interface
-   static pointer allocate_one(Allocator &a)
+   BOOST_CONTAINER_FORCEINLINE static pointer allocate_one(Allocator &a)
    {  return a.allocate_one();   }
 
-   static void deallocate_one(Allocator &a, const pointer &p)
+   BOOST_CONTAINER_FORCEINLINE static void deallocate_one(Allocator &a, const pointer &p)
    {  a.deallocate_one(p);   }
 
-   static void allocate_individual(Allocator &a, size_type n, multiallocation_chain &m)
+   BOOST_CONTAINER_FORCEINLINE static void allocate_individual(Allocator &a, size_type n, multiallocation_chain &m)
    {  return a.allocate_individual(n, m);   }
 
-   static void deallocate_individual(Allocator &a, multiallocation_chain &holder)
+   BOOST_CONTAINER_FORCEINLINE static void deallocate_individual(Allocator &a, multiallocation_chain &holder)
    {  a.deallocate_individual(holder);   }
 
-   static pointer allocation_command(Allocator &a, allocation_type command,
+   BOOST_CONTAINER_FORCEINLINE static pointer allocation_command(Allocator &a, allocation_type command,
                          size_type limit_size, size_type &prefer_in_recvd_out_size, pointer &reuse)
    {  return a.allocation_command(command, limit_size, prefer_in_recvd_out_size, reuse);  }
 };
@@ -83,10 +82,10 @@ struct allocator_version_traits<Allocator, 1>
          < multialloc_cached_counted, value_type>           multiallocation_chain;
 
    //Node allocation interface
-   static pointer allocate_one(Allocator &a)
+   BOOST_CONTAINER_FORCEINLINE static pointer allocate_one(Allocator &a)
    {  return a.allocate(1);   }
 
-   static void deallocate_one(Allocator &a, const pointer &p)
+   BOOST_CONTAINER_FORCEINLINE static void deallocate_one(Allocator &a, const pointer &p)
    {  a.deallocate(p, 1);   }
 
    static void deallocate_individual(Allocator &a, multiallocation_chain &holder)
@@ -103,17 +102,17 @@ struct allocator_version_traits<Allocator, 1>
 
    struct allocate_individual_rollback
    {
-      allocate_individual_rollback(Allocator &a, multiallocation_chain &chain)
+      BOOST_CONTAINER_FORCEINLINE allocate_individual_rollback(Allocator &a, multiallocation_chain &chain)
          : mr_a(a), mp_chain(&chain)
       {}
 
-      ~allocate_individual_rollback()
+      BOOST_CONTAINER_FORCEINLINE ~allocate_individual_rollback()
       {
          if(mp_chain)
             allocator_version_traits::deallocate_individual(mr_a, *mp_chain);
       }
 
-      void release()
+      BOOST_CONTAINER_FORCEINLINE void release()
       {
          mp_chain = 0;
       }
@@ -139,15 +138,15 @@ struct allocator_version_traits<Allocator, 1>
          throw_logic_error("version 1 allocator without allocate_new flag");
       }
       else{
-         BOOST_TRY{
+         BOOST_CONTAINER_TRY{
             ret = a.allocate(prefer_in_recvd_out_size);
          }
-         BOOST_CATCH(...){
+         BOOST_CONTAINER_CATCH(...){
             if(!(command & nothrow_allocation)){
-               BOOST_RETHROW
+               BOOST_CONTAINER_RETHROW
             }
          }
-         BOOST_CATCH_END
+         BOOST_CONTAINER_CATCH_END
          reuse = pointer();
       }
       return ret;

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

@@ -17,6 +17,7 @@
 
 #ifdef BOOST_MSVC
    #pragma warning (push)
+   #pragma warning (disable : 4619) // there is no warning number 'XXXX'
    #pragma warning (disable : 4127) // conditional expression is constant
    #pragma warning (disable : 4146) // unary minus operator applied to unsigned type, result still unsigned
    #pragma warning (disable : 4197) // top-level volatile in cast is ignored