passenger 6.0.13 → 6.0.15

data/src/cxx_supportlib/vendor-modified/boost/optional/optional.hpp

@@ -1,5 +1,5 @@
 // Copyright (C) 2003, 2008 Fernando Luis Cacciola Carballal.
-// Copyright (C) 2014 - 2018 Andrzej Krzemienski.
+// Copyright (C) 2014 - 2021 Andrzej Krzemienski.
 //
 // Use, modification, and distribution is subject to the Boost Software
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
@@ -18,7 +18,9 @@
 #define BOOST_OPTIONAL_OPTIONAL_FLC_19NOV2002_HPP
 
 #include <new>
+#ifndef BOOST_NO_IOSTREAM
 #include <iosfwd>
+#endif // BOOST_NO_IOSTREAM
 
 #ifdef BOOST_OPTIONAL_DETAIL_USE_STD_TYPE_TRAITS
 #  include <type_traits>
@@ -35,14 +37,18 @@
 #include <boost/type.hpp>
 #include <boost/type_traits/alignment_of.hpp>
 #include <boost/type_traits/conditional.hpp>
+#include <boost/type_traits/conjunction.hpp>
+#include <boost/type_traits/disjunction.hpp>
 #include <boost/type_traits/has_nothrow_constructor.hpp>
 #include <boost/type_traits/type_with_alignment.hpp>
 #include <boost/type_traits/remove_const.hpp>
 #include <boost/type_traits/remove_reference.hpp>
 #include <boost/type_traits/decay.hpp>
+#include <boost/type_traits/is_assignable.hpp>
 #include <boost/type_traits/is_base_of.hpp>
 #include <boost/type_traits/is_const.hpp>
 #include <boost/type_traits/is_constructible.hpp>
+#include <boost/type_traits/is_convertible.hpp>
 #include <boost/type_traits/is_lvalue_reference.hpp>
 #include <boost/type_traits/is_nothrow_move_assignable.hpp>
 #include <boost/type_traits/is_nothrow_move_constructible.hpp>
@@ -59,6 +65,7 @@
 #include <boost/optional/detail/optional_config.hpp>
 #include <boost/optional/detail/optional_factory_support.hpp>
 #include <boost/optional/detail/optional_aligned_storage.hpp>
+#include <boost/optional/detail/optional_hash.hpp>
 
 namespace boost { namespace optional_detail {
 
@@ -123,6 +130,7 @@ class optional_base : public optional_tag
   protected :
 
     typedef T value_type ;
+    typedef typename boost::remove_const<T>::type unqualified_value_type;
 
   protected:
     typedef T &       reference_type ;
@@ -399,14 +407,14 @@ class optional_base : public optional_tag
 
     void construct ( argument_type val )
      {
-       ::new (m_storage.address()) value_type(val) ;
+       ::new (m_storage.address()) unqualified_value_type(val) ;
        m_initialized = true ;
      }
 
 #ifndef  BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
     void construct ( rval_reference_type val )
      {
-       ::new (m_storage.address()) value_type( boost::move(val) ) ;
+       ::new (m_storage.address()) unqualified_value_type( boost::move(val) ) ;
        m_initialized = true ;
      }
 #endif
@@ -418,7 +426,7 @@ class optional_base : public optional_tag
     template<class... Args>
     void construct ( in_place_init_t, Args&&... args )
     {
-      ::new (m_storage.address()) value_type( boost::forward<Args>(args)... ) ;
+      ::new (m_storage.address()) unqualified_value_type( boost::forward<Args>(args)... ) ;
       m_initialized = true ;
     }
 
@@ -449,13 +457,13 @@ class optional_base : public optional_tag
     template<class Arg>
     void construct ( in_place_init_t, Arg&& arg )
      {
-       ::new (m_storage.address()) value_type( boost::forward<Arg>(arg) );
+       ::new (m_storage.address()) unqualified_value_type( boost::forward<Arg>(arg) );
        m_initialized = true ;
      }
 
     void construct ( in_place_init_t )
      {
-       ::new (m_storage.address()) value_type();
+       ::new (m_storage.address()) unqualified_value_type();
        m_initialized = true ;
      }
 
@@ -509,20 +517,20 @@ class optional_base : public optional_tag
     template<class Arg>
     void construct ( in_place_init_t, const Arg& arg )
      {
-       ::new (m_storage.address()) value_type( arg );
+       ::new (m_storage.address()) unqualified_value_type( arg );
        m_initialized = true ;
      }
 
     template<class Arg>
     void construct ( in_place_init_t, Arg& arg )
      {
-       ::new (m_storage.address()) value_type( arg );
+       ::new (m_storage.address()) unqualified_value_type( arg );
        m_initialized = true ;
      }
 
     void construct ( in_place_init_t )
      {
-       ::new (m_storage.address()) value_type();
+       ::new (m_storage.address()) unqualified_value_type();
        m_initialized = true ;
      }
 
@@ -667,7 +675,7 @@ class optional_base : public optional_tag
     template<class Expr>
     void construct ( Expr&& expr, void const* )
     {
-      new (m_storage.address()) value_type(boost::forward<Expr>(expr)) ;
+      new (m_storage.address()) unqualified_value_type(boost::forward<Expr>(expr)) ;
       m_initialized = true ;
     }
 
@@ -688,7 +696,7 @@ class optional_base : public optional_tag
     template<class Expr>
     void construct ( Expr const& expr, void const* )
      {
-       new (m_storage.address()) value_type(expr) ;
+       new (m_storage.address()) unqualified_value_type(expr) ;
        m_initialized = true ;
      }
 
@@ -726,7 +734,7 @@ class optional_base : public optional_tag
        {
          // An exception can be thrown here.
          // It it happens, THIS will be left uninitialized.
-         new (m_storage.address()) value_type(boost::move(expr.get())) ;
+         new (m_storage.address()) unqualified_value_type(boost::move(expr.get())) ;
          m_initialized = true ;
        }
      }
@@ -739,7 +747,7 @@ class optional_base : public optional_tag
        {
          // An exception can be thrown here.
          // It it happens, THIS will be left uninitialized.
-         new (m_storage.address()) value_type(expr.get()) ;
+         new (m_storage.address()) unqualified_value_type(expr.get()) ;
          m_initialized = true ;
        }
      }
@@ -779,7 +787,7 @@ class optional_base : public optional_tag
 
 // definition of metafunction is_optional_val_init_candidate
 template <typename U>
-struct is_optional_related
+struct is_optional_or_tag
   : boost::conditional< boost::is_base_of<optional_detail::optional_tag, BOOST_DEDUCED_TYPENAME boost::decay<U>::type>::value
                      || boost::is_same<BOOST_DEDUCED_TYPENAME boost::decay<U>::type, none_t>::value
                      || boost::is_same<BOOST_DEDUCED_TYPENAME boost::decay<U>::type, in_place_init_t>::value
@@ -787,14 +795,22 @@ struct is_optional_related
     boost::true_type, boost::false_type>::type
 {};
 
+template <typename T, typename U>
+struct has_dedicated_constructor
+  : boost::disjunction<is_optional_or_tag<U>, boost::is_same<T, BOOST_DEDUCED_TYPENAME boost::decay<U>::type> >
+{};
+
+template <typename U>
+struct is_in_place_factory
+  : boost::disjunction< boost::is_base_of<boost::in_place_factory_base, BOOST_DEDUCED_TYPENAME boost::decay<U>::type>,
+                        boost::is_base_of<boost::typed_in_place_factory_base, BOOST_DEDUCED_TYPENAME boost::decay<U>::type> >
+{};
+
 #if !defined(BOOST_OPTIONAL_DETAIL_NO_IS_CONSTRUCTIBLE_TRAIT)
 
 template <typename T, typename U>
-struct is_convertible_to_T_or_factory
-  : boost::conditional< boost::is_base_of<boost::in_place_factory_base, BOOST_DEDUCED_TYPENAME boost::decay<U>::type>::value
-                     || boost::is_base_of<boost::typed_in_place_factory_base, BOOST_DEDUCED_TYPENAME boost::decay<U>::type>::value
-                     || (boost::is_constructible<T, U&&>::value && !boost::is_same<T, BOOST_DEDUCED_TYPENAME boost::decay<U>::type>::value)
-                      , boost::true_type, boost::false_type>::type
+struct is_factory_or_constructible_to_T
+  : boost::disjunction< is_in_place_factory<U>, boost::is_constructible<T, U&&> >
 {};
 
 template <typename T, typename U>
@@ -804,7 +820,7 @@ struct is_optional_constructible : boost::is_constructible<T, U>
 #else
 
 template <typename, typename>
-struct is_convertible_to_T_or_factory : boost::true_type
+struct is_factory_or_constructible_to_T : boost::true_type
 {};
 
 template <typename T, typename U>
@@ -813,15 +829,58 @@ struct is_optional_constructible : boost::true_type
 
 #endif // is_convertible condition
 
-template <typename T, typename U, bool = is_optional_related<U>::value>
+#if !defined(BOOST_NO_CXX11_DECLTYPE) && !BOOST_WORKAROUND(BOOST_MSVC, < 1800)
+// for is_assignable
+
+#if (!defined BOOST_NO_CXX11_RVALUE_REFERENCES)
+// On some initial rvalue reference implementations GCC does it in a strange way,
+// preferring perfect-forwarding constructor to implicit copy constructor.
+
+template <typename T, typename U>
+struct is_opt_assignable
+  : boost::conjunction<boost::is_convertible<U&&, T>, boost::is_assignable<T&, U&&> >
+{};
+
+#else
+
+template <typename T, typename U>
+struct is_opt_assignable
+  : boost::conjunction<boost::is_convertible<U, T>, boost::is_assignable<T&, U> >
+{};
+
+#endif
+
+#else
+
+template <typename T, typename U>
+struct is_opt_assignable : boost::is_convertible<U, T>
+{};
+
+#endif
+
+template <typename T, typename U>
+struct is_factory_or_opt_assignable_to_T
+  : boost::disjunction< is_in_place_factory<U>, is_opt_assignable<T, U> >
+{};
+
+template <typename T, typename U, bool = has_dedicated_constructor<T, U>::value>
 struct is_optional_val_init_candidate
   : boost::false_type
 {};
 
 template <typename T, typename U>
 struct is_optional_val_init_candidate<T, U, false>
-  : boost::conditional< is_convertible_to_T_or_factory<T, U>::value
-                      , boost::true_type, boost::false_type>::type
+  : is_factory_or_constructible_to_T<T, U>
+{};
+
+template <typename T, typename U, bool = has_dedicated_constructor<T, U>::value>
+struct is_optional_val_assign_candidate
+  : boost::false_type
+{};
+
+template <typename T, typename U>
+struct is_optional_val_assign_candidate<T, U, false>
+  : is_factory_or_opt_assignable_to_T<T, U>
 {};
 
 } // namespace optional_detail
@@ -994,7 +1053,7 @@ class optional
 #ifndef  BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
 
     template<class Expr>
-    BOOST_DEDUCED_TYPENAME boost::enable_if<optional_detail::is_optional_val_init_candidate<T, Expr>, optional&>::type
+    BOOST_DEDUCED_TYPENAME boost::enable_if<optional_detail::is_optional_val_assign_candidate<T, Expr>, optional&>::type
     operator= ( Expr&& expr )
       {
         this->assign_expr(boost::forward<Expr>(expr),boost::addressof(expr));
@@ -1586,6 +1645,7 @@ get_pointer ( optional<T>& opt )
 
 } // namespace boost
 
+#ifndef BOOST_NO_IOSTREAM
 namespace boost {
 
 // The following declaration prevents a bug where operator safe-bool is used upon streaming optional object if you forget the IO header.
@@ -1598,6 +1658,7 @@ operator<<(std::basic_ostream<CharType, CharTrait>& os, optional_detail::optiona
 }
 
 } // namespace boost
+#endif // BOOST_NO_IOSTREAM
 
 #include <boost/optional/detail/optional_relops.hpp>
 #include <boost/optional/detail/optional_swap.hpp>

data/src/cxx_supportlib/vendor-modified/boost/optional/optional_io.hpp

@@ -12,6 +12,7 @@
 #ifndef BOOST_OPTIONAL_OPTIONAL_IO_FLC_19NOV2002_HPP
 #define BOOST_OPTIONAL_OPTIONAL_IO_FLC_19NOV2002_HPP
 
+#ifndef BOOST_NO_IOSTREAM
 #include <istream>
 #include <ostream>
 
@@ -31,7 +32,7 @@ operator<<(std::basic_ostream<CharType, CharTrait>& out, none_t)
   {
     out << "--";
   }
-   
+
   return out;
 }
 
@@ -90,5 +91,5 @@ operator>>(std::basic_istream<CharType, CharTrait>& in, optional<T>& v)
 
 } // namespace boost
 
+#endif // BOOST_NO_IOSTREAM
 #endif
-

data/src/cxx_supportlib/vendor-modified/boost/pool/pool.hpp

@@ -26,6 +26,8 @@
 
 #include <boost/pool/poolfwd.hpp>
 
+// std::numeric_limits
+#include <boost/limits.hpp>
 // boost::integer::static_lcm
 #include <boost/integer/common_factor_ct.hpp>
 // boost::simple_segregated_storage
@@ -355,6 +357,12 @@ class pool: protected simple_segregated_storage < typename UserAllocator::size_t
       return s;
     }
 
+    size_type max_chunks() const
+    { //! Calculated maximum number of memory chunks that can be allocated in a single call by this Pool.
+      size_type POD_size = integer::static_lcm<sizeof(size_type), sizeof(void *)>::value + sizeof(size_type);
+      return (std::numeric_limits<size_type>::max() - POD_size) / alloc_size();
+    }
+
     static void * & nextof(void * const ptr)
     { //! \returns Pointer dereferenced.
       //! (Provided and used for the sake of code readability :)
@@ -375,6 +383,8 @@ class pool: protected simple_segregated_storage < typename UserAllocator::size_t
       //!   the first time that object needs to allocate system memory.
       //!   The default is 32. This parameter may not be 0.
       //! \param nmax_size is the maximum number of chunks to allocate in one block.
+      set_next_size(nnext_size);
+      set_max_size(nmax_size);
     }
 
     ~pool()
@@ -398,8 +408,8 @@ class pool: protected simple_segregated_storage < typename UserAllocator::size_t
     }
     void set_next_size(const size_type nnext_size)
     { //! Set number of chunks to request from the system the next time that object needs to allocate system memory. This value should never be set to 0.
-      //! \returns nnext_size.
-      next_size = start_size = nnext_size;
+      BOOST_USING_STD_MIN();
+      next_size = start_size = min BOOST_PREVENT_MACRO_SUBSTITUTION(nnext_size, max_chunks());
     }
     size_type get_max_size() const
     { //! \returns max_size.
@@ -407,7 +417,8 @@ class pool: protected simple_segregated_storage < typename UserAllocator::size_t
     }
     void set_max_size(const size_type nmax_size)
     { //! Set max_size.
-      max_size = nmax_size;
+      BOOST_USING_STD_MIN();
+      max_size = min BOOST_PREVENT_MACRO_SUBSTITUTION(nmax_size, max_chunks());
     }
     size_type get_requested_size() const
     { //!   \returns the requested size passed into the constructor.
@@ -708,9 +719,9 @@ void * pool<UserAllocator>::malloc_need_resize()
 
   BOOST_USING_STD_MIN();
   if(!max_size)
-    next_size <<= 1;
+    set_next_size(next_size << 1);
   else if( next_size*partition_size/requested_size < max_size)
-    next_size = min BOOST_PREVENT_MACRO_SUBSTITUTION(next_size << 1, max_size*requested_size/ partition_size);
+    set_next_size(min BOOST_PREVENT_MACRO_SUBSTITUTION(next_size << 1, max_size * requested_size / partition_size));
 
   //  initialize it,
   store().add_block(node.begin(), node.element_size(), partition_size);
@@ -748,9 +759,9 @@ void * pool<UserAllocator>::ordered_malloc_need_resize()
 
   BOOST_USING_STD_MIN();
   if(!max_size)
-    next_size <<= 1;
+    set_next_size(next_size << 1);
   else if( next_size*partition_size/requested_size < max_size)
-    next_size = min BOOST_PREVENT_MACRO_SUBSTITUTION(next_size << 1, max_size*requested_size/ partition_size);
+    set_next_size(min BOOST_PREVENT_MACRO_SUBSTITUTION(next_size << 1, max_size * requested_size / partition_size));
 
   //  initialize it,
   //  (we can use "add_block" here because we know that
@@ -792,6 +803,8 @@ void * pool<UserAllocator>::ordered_malloc(const size_type n)
 { //! Gets address of a chunk n, allocating new memory if not already available.
   //! \returns Address of chunk n if allocated ok.
   //! \returns 0 if not enough memory for n chunks.
+  if (n > max_chunks())
+    return 0;
 
   const size_type partition_size = alloc_size();
   const size_type total_req_size = n * requested_size;
@@ -840,9 +853,9 @@ void * pool<UserAllocator>::ordered_malloc(const size_type n)
 
   BOOST_USING_STD_MIN();
   if(!max_size)
-    next_size <<= 1;
+    set_next_size(next_size << 1);
   else if( next_size*partition_size/requested_size < max_size)
-    next_size = min BOOST_PREVENT_MACRO_SUBSTITUTION(next_size << 1, max_size*requested_size/ partition_size);
+    set_next_size(min BOOST_PREVENT_MACRO_SUBSTITUTION(next_size << 1, max_size * requested_size / partition_size));
 
   //  insert it into the list,
   //   handle border case.

data/src/cxx_supportlib/vendor-modified/boost/predef/architecture/loongarch.h

@@ -0,0 +1,41 @@
+/*
+Copyright Zhang Na 2022
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
+http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+#ifndef BOOST_PREDEF_ARCHITECTURE_LOONGARCH_H
+#define BOOST_PREDEF_ARCHITECTURE_LOONGARCH_H
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+/* tag::reference[]
+= `BOOST_ARCH_LOONGARCH`
+
+[options="header"]
+|===
+| {predef_symbol} | {predef_version}
+
+| `+__loongarch__+` | {predef_detection}
+|===
+*/ // end::reference[]
+
+#define BOOST_ARCH_LOONGARCH BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if defined(__loongarch__)
+#   undef BOOST_ARCH_LOONGARCH
+#   define BOOST_ARCH_LOONGARCH BOOST_VERSION_NUMBER_AVAILABLE
+#endif
+
+#if BOOST_ARCH_LOONGARCH
+#   define BOOST_ARCH_LOONGARCH_AVAILABLE
+#endif
+
+#define BOOST_ARCH_LOONGARCH_NAME "LoongArch"
+
+#endif
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_ARCH_LOONGARCH,BOOST_ARCH_LOONGARCH_NAME)

data/src/cxx_supportlib/vendor-modified/boost/predef/architecture/sparc.h

@@ -34,10 +34,10 @@ http://en.wikipedia.org/wiki/SPARC[SPARC] architecture.
 
 #if defined(__sparc__) || defined(__sparc)
 #   undef BOOST_ARCH_SPARC
-#   if !defined(BOOST_ARCH_SPARC) && (defined(__sparcv9) || defined(__sparc_v9__)
+#   if !defined(BOOST_ARCH_SPARC) && (defined(__sparcv9) || defined(__sparc_v9__))
 #       define BOOST_ARCH_SPARC BOOST_VERSION_NUMBER(9,0,0)
 #   endif
-#   if !defined(BOOST_ARCH_SPARC) && (defined(__sparcv8) || defined(__sparc_v8__)
+#   if !defined(BOOST_ARCH_SPARC) && (defined(__sparcv8) || defined(__sparc_v8__))
 #       define BOOST_ARCH_SPARC BOOST_VERSION_NUMBER(8,0,0)
 #   endif
 #   if !defined(BOOST_ARCH_SPARC)

data/src/cxx_supportlib/vendor-modified/boost/predef/architecture.h

@@ -16,6 +16,7 @@ http://www.boost.org/LICENSE_1_0.txt)
 #include <boost/predef/architecture/convex.h>
 #include <boost/predef/architecture/e2k.h>
 #include <boost/predef/architecture/ia64.h>
+#include <boost/predef/architecture/loongarch.h>
 #include <boost/predef/architecture/m68k.h>
 #include <boost/predef/architecture/mips.h>
 #include <boost/predef/architecture/parisc.h>

data/src/cxx_supportlib/vendor-modified/boost/predef/language/stdc.h

@@ -15,7 +15,7 @@ http://www.boost.org/LICENSE_1_0.txt)
 = `BOOST_LANG_STDC`
 
 http://en.wikipedia.org/wiki/C_(programming_language)[Standard C] language.
-If available, the year of the standard is detected as YYYY.MM.1 from the Epoc date.
+If available, the year of the standard is detected as YYYY.MM.1 from the Epoch date.
 
 [options="header"]
 |===

data/src/cxx_supportlib/vendor-modified/boost/predef/language/stdcpp.h

@@ -15,7 +15,7 @@ http://www.boost.org/LICENSE_1_0.txt)
 = `BOOST_LANG_STDCPP`
 
 http://en.wikipedia.org/wiki/C%2B%2B[Standard {CPP}] language.
-If available, the year of the standard is detected as YYYY.MM.1 from the Epoc date.
+If available, the year of the standard is detected as YYYY.MM.1 from the Epoch date.
 Because of the way the {CPP} standardization process works the
 defined version year will not be the commonly known year of the standard.
 Specifically the defined versions are:
@@ -61,7 +61,7 @@ Specifically the defined versions are:
 = `BOOST_LANG_STDCPPCLI`
 
 http://en.wikipedia.org/wiki/C%2B%2B/CLI[Standard {CPP}/CLI] language.
-If available, the year of the standard is detected as YYYY.MM.1 from the Epoc date.
+If available, the year of the standard is detected as YYYY.MM.1 from the Epoch date.
 
 [options="header"]
 |===

data/src/cxx_supportlib/vendor-modified/boost/predef/other/endian.h

@@ -121,6 +121,7 @@ information and acquired knowledge:
         defined(__ARMEL__) || \
         defined(__THUMBEL__) || \
         defined(__AARCH64EL__) || \
+        defined(__loongarch__) || \
         defined(_MIPSEL) || \
         defined(__MIPSEL) || \
         defined(__MIPSEL__) || \

data/src/cxx_supportlib/vendor-modified/boost/predef/version.h

@@ -10,6 +10,6 @@ http://www.boost.org/LICENSE_1_0.txt)
 
 #include <boost/predef/version_number.h>
 
-#define BOOST_PREDEF_VERSION BOOST_VERSION_NUMBER(1,13,0)
+#define BOOST_PREDEF_VERSION BOOST_VERSION_NUMBER(1,14,0)
 
 #endif

data/src/cxx_supportlib/vendor-modified/boost/regex/v4/basic_regex_parser.hpp

@@ -1055,6 +1055,7 @@ bool basic_regex_parser<charT, traits>::parse_repeat(std::size_t low, std::size_
       case syntax_element_jump:
       case syntax_element_startmark:
       case syntax_element_backstep:
+      case syntax_element_toggle_case:
          // can't legally repeat any of the above:
          fail(regex_constants::error_badrepeat, m_position - m_base);
          return false;
@@ -3140,7 +3141,13 @@ bool basic_regex_parser<charT, traits>::unwind_alts(std::ptrdiff_t last_paren_st
       m_alt_jumps.pop_back();
       this->m_pdata->m_data.align();
       re_jump* jmp = static_cast<re_jump*>(this->getaddress(jump_offset));
-      BOOST_REGEX_ASSERT(jmp->type == syntax_element_jump);
+      if (jmp->type != syntax_element_jump)
+      {
+         // Something really bad happened, this used to be an assert, 
+         // but we'll make it an error just in case we should ever get here.
+         fail(regex_constants::error_unknown, this->m_position - this->m_base, "Internal logic failed while compiling the expression, probably you added a repeat to something non-repeatable!");
+         return false;
+      }
       jmp->alt.i = this->m_pdata->m_data.size() - jump_offset;
    }
    return true;

data/src/cxx_supportlib/vendor-modified/boost/regex/v4/icu.hpp

@@ -187,7 +187,7 @@ namespace boost {
       }
       char_type translate_nocase(char_type c) const
       {
-         return ::u_tolower(c);
+         return ::u_foldCase(c, U_FOLD_CASE_DEFAULT);
       }
       char_type translate(char_type c, bool icase) const
       {

data/src/cxx_supportlib/vendor-modified/boost/regex/v4/pattern_except.hpp

@@ -88,7 +88,8 @@ typedef regex_error bad_expression;
 
 namespace BOOST_REGEX_DETAIL_NS{
 
-inline void BOOST_REGEX_CALL raise_runtime_error(const std::runtime_error& ex)
+template <class E>
+inline void raise_runtime_error(const E& ex)
 {
 #ifndef BOOST_REGEX_STANDALONE
    ::boost::throw_exception(ex);
@@ -101,7 +102,7 @@ template <class traits>
 void raise_error(const traits& t, regex_constants::error_type code)
 {
    (void)t;  // warning suppression
-   std::runtime_error e(t.error_string(code));
+   regex_error e(t.error_string(code), code, 0);
    ::boost::BOOST_REGEX_DETAIL_NS::raise_runtime_error(e);
 }
 

data/src/cxx_supportlib/vendor-modified/boost/regex/v4/perl_matcher_non_recursive.hpp

@@ -1354,6 +1354,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::unwind_alt(bool r)
 template <class BidiIterator, class Allocator, class traits>
 bool perl_matcher<BidiIterator, Allocator, traits>::unwind_repeater_counter(bool)
 {
+   ++used_block_count;
    saved_repeater<BidiIterator>* pmp = static_cast<saved_repeater<BidiIterator>*>(m_backup_state);
    boost::BOOST_REGEX_DETAIL_NS::inplace_destroy(pmp++);
    m_backup_state = pmp;

data/src/cxx_supportlib/vendor-modified/boost/regex/v5/basic_regex_creator.hpp

@@ -20,8 +20,6 @@
 #ifndef BOOST_REGEX_V5_BASIC_REGEX_CREATOR_HPP
 #define BOOST_REGEX_V5_BASIC_REGEX_CREATOR_HPP
 
-#include <boost/regex/v5/indexed_bit_flag.hpp>
-
 #ifdef BOOST_REGEX_MSVC
 #  pragma warning(push)
 #pragma warning(disable:4459)
@@ -30,6 +28,8 @@
 #endif
 #endif
 
+#include <set>
+
 namespace boost{
 
 namespace BOOST_REGEX_DETAIL_NS{
@@ -232,7 +232,6 @@ protected:
    bool                          m_icase;              // true for case insensitive matches
    unsigned                      m_repeater_id;        // the state_id of the next repeater
    bool                          m_has_backrefs;       // true if there are actually any backrefs
-   indexed_bit_flag              m_backrefs;           // bitmask of permitted backrefs
    std::uintmax_t                m_bad_repeats;        // bitmask of repeats we can't deduce a startmap for;
    bool                          m_has_recursions;     // set when we have recursive expressions to fixup
    std::vector<unsigned char>    m_recursion_checks;   // notes which recursions we've followed while analysing this expression
@@ -1020,6 +1019,8 @@ int basic_regex_creator<charT, traits>::calculate_backstep(re_syntax_base* state
             {
                if(rep->max != rep->min)
                   return -1;
+               if (static_cast<std::size_t>((std::numeric_limits<int>::max)() - result) < rep->min)
+                  return -1; // protection against overflow, we can't calculate a backstep in this case and the expression is probably ill-formed.
                result += static_cast<int>(rep->min);
                state = rep->alt.p;
                continue;