passenger 6.1.0 → 6.1.1

data/src/cxx_supportlib/vendor-modified/boost/regex/config.hpp

@@ -19,12 +19,8 @@
 #ifndef BOOST_REGEX_CONFIG_HPP
 #define BOOST_REGEX_CONFIG_HPP
 
-#if !((__cplusplus >= 201103L) || (defined(_MSC_VER) && (_MSC_VER >= 1600)) || defined(BOOST_REGEX_CXX03))
-#  define BOOST_REGEX_CXX03
-#endif
-
-#if defined(BOOST_REGEX_RECURSIVE) && !defined(BOOST_REGEX_CXX03)
-#  define BOOST_REGEX_CXX03
+#if defined(BOOST_REGEX_RECURSIVE)
+#error "All support for the C++03 recursive engine has been removed, this define has no effect anymore."
 #endif
 
 #if defined(__has_include)
@@ -33,6 +29,14 @@
 #endif
 #endif
 
+#ifndef BOOST_REGEX_MODULE_EXPORT
+#define BOOST_REGEX_MODULE_EXPORT
+#define BOOST_REGEX_STATIC_CONST static const
+#else
+#define BOOST_REGEX_STATIC_CONST inline constexpr
+#define BOOST_REGEX_STANDALONE
+#endif
+
 /*
  * Borland C++ Fix/error check
  * this has to go *before* we include any std lib headers:
@@ -40,6 +44,7 @@
 #if defined(__BORLANDC__) && !defined(__clang__)
 #  include <boost/regex/config/borland.hpp>
 #endif
+
 #ifndef BOOST_REGEX_STANDALONE
 #include <boost/version.hpp>
 #endif
@@ -51,9 +56,13 @@
 *************************************************************************/
 
 #ifdef BOOST_REGEX_STANDALONE
+#ifndef BOOST_REGEX_AS_MODULE
 #include <cassert>
 #  define BOOST_REGEX_ASSERT(x) assert(x)
 #else
+#  define BOOST_REGEX_ASSERT(x) do{ if(x == 0) { std::printf("%s:%d Assertion Failed", __FILE__, __LINE__); std::abort(); } }while(0)
+#endif
+#else
 #include <boost/assert.hpp>
 #  define BOOST_REGEX_ASSERT(x) BOOST_ASSERT(x)
 #endif
@@ -90,20 +99,7 @@
 #  endif
 #endif
 
-
-/****************************************************************************
-*
-* Legacy support:
-*
-*******************************************************************************/
-
-#if defined(BOOST_NO_STD_LOCALE) || defined(BOOST_NO_CXX11_HDR_MUTEX) || defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS) \
-   || defined(BOOST_NO_CXX11_HDR_ATOMIC) || defined(BOOST_NO_CXX11_ALLOCATOR) || defined(BOOST_NO_CXX11_SMART_PTR) \
-   || defined(BOOST_NO_CXX11_STATIC_ASSERT) || defined(BOOST_NO_NOEXCEPT)
-#ifndef BOOST_REGEX_CXX03
-#  define BOOST_REGEX_CXX03
-#endif
-#endif
+#define BOOST_REGEX_MAX_RECURSION_DEPTH 100
 
 /*****************************************************************************
  *
@@ -112,7 +108,7 @@
  ****************************************************************************/
 
 /* Obsolete macro, use BOOST_VERSION instead: */
-#define BOOST_RE_VERSION 500
+#define BOOST_RE_VERSION 600
 
 /* fix: */
 #if defined(_UNICODE) && !defined(UNICODE)
@@ -157,40 +153,6 @@
 */
 #define BOOST_REGEX_DETAIL_NS BOOST_REGEX_JOIN(re_detail_, BOOST_RE_VERSION)
 
-/*
- * Fix for gcc prior to 3.4: std::ctype<wchar_t> doesn't allow
- * masks to be combined, for example:
- * std::use_facet<std::ctype<wchar_t> >.is(std::ctype_base::lower|std::ctype_base::upper, L'a');
- * returns *false*.
- */
-#if defined(__GLIBCPP__) && defined(BOOST_REGEX_CXX03)
-#  define BOOST_REGEX_BUGGY_CTYPE_FACET
-#endif
-
-/*
- * If there isn't good enough wide character support then there will
- * be no wide character regular expressions:
- */
-#if (defined(BOOST_NO_CWCHAR) || defined(BOOST_NO_CWCTYPE) || defined(BOOST_NO_STD_WSTRING))
-#  if !defined(BOOST_NO_WREGEX)
-#     define BOOST_NO_WREGEX
-#  endif
-#else
-#  if defined(__sgi) && (defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION))
-      /* STLPort on IRIX is misconfigured: <cwctype> does not compile
-       * as a temporary fix include <wctype.h> instead and prevent inclusion
-       * of STLPort version of <cwctype> */
-#     include <wctype.h>
-#     define __STLPORT_CWCTYPE
-#     define _STLP_CWCTYPE
-#  endif
-
-#if defined(__cplusplus) && defined(BOOST_REGEX_CXX03)
-#  include <boost/regex/config/cwchar.hpp>
-#endif
-
-#endif
-
 /*
  * If Win32 support has been disabled for boost in general, then
  * it is for regex in particular:
@@ -251,19 +213,6 @@
 #  define BOOST_REGEX_DECL
 #endif
 
-#ifdef BOOST_REGEX_CXX03
-#if !defined(BOOST_REGEX_NO_LIB) && !defined(BOOST_REGEX_SOURCE) && !defined(BOOST_ALL_NO_LIB) && defined(__cplusplus)
-#  define BOOST_LIB_NAME boost_regex
-#  if defined(BOOST_REGEX_DYN_LINK) || defined(BOOST_ALL_DYN_LINK)
-#     define BOOST_DYN_LINK
-#  endif
-#  ifdef BOOST_REGEX_DIAG
-#     define BOOST_LIB_DIAGNOSTIC
-#  endif
-#  include <boost/config/auto_link.hpp>
-#endif
-#endif
-
 /*****************************************************************************
  *
  *  Set up function call type:
@@ -355,18 +304,7 @@
  * If there are no exceptions then we must report critical-errors
  * the only way we know how; by terminating.
  */
-#include <stdexcept>
-#include <string>
-#include <boost/throw_exception.hpp>
-
-#  define BOOST_REGEX_NOEH_ASSERT(x)\
-if(0 == (x))\
-{\
-   std::string s("Error: critical regex++ failure in: ");\
-   s.append(#x);\
-   std::runtime_error e(s);\
-   boost::throw_exception(e);\
-}
+#  define BOOST_REGEX_NOEH_ASSERT(x) assert(x);
 #else
 /*
  * With exceptions then error handling is taken care of and
@@ -405,26 +343,6 @@ BOOST_REGEX_DECL void BOOST_REGEX_CALL reset_stack_guard_page();
 
 #endif
 
-
-/*****************************************************************************
- *
- *  Algorithm selection and configuration.
- *  These options are now obsolete for C++11 and later (regex v5).
- *
- ****************************************************************************/
-
-#if !defined(BOOST_REGEX_RECURSIVE) && !defined(BOOST_REGEX_NON_RECURSIVE)
-#  if defined(BOOST_REGEX_HAS_MS_STACK_GUARD) && !defined(_STLP_DEBUG) && !defined(__STL_DEBUG) && !(defined(_MSC_VER) && (_MSC_VER >= 1400)) && defined(BOOST_REGEX_CXX03)
-#     define BOOST_REGEX_RECURSIVE
-#  else
-#     define BOOST_REGEX_NON_RECURSIVE
-#  endif
-#endif
-
-#ifdef BOOST_REGEX_NON_RECURSIVE
-#  ifdef BOOST_REGEX_RECURSIVE
-#     error "Can't set both BOOST_REGEX_RECURSIVE and BOOST_REGEX_NON_RECURSIVE"
-#  endif
 #  ifndef BOOST_REGEX_BLOCKSIZE
 #     define BOOST_REGEX_BLOCKSIZE 4096
 #  endif
@@ -440,7 +358,6 @@ BOOST_REGEX_DECL void BOOST_REGEX_CALL reset_stack_guard_page();
 #  ifndef BOOST_REGEX_MAX_CACHE_BLOCKS
 #     define BOOST_REGEX_MAX_CACHE_BLOCKS 16
 #  endif
-#endif
 
 
 /*****************************************************************************

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

@@ -23,10 +23,6 @@
 #include <boost/regex/config.hpp>
 #endif
 
-#ifdef BOOST_REGEX_CXX03
-#include <boost/regex/v4/pattern_except.hpp>
-#else
 #include <boost/regex/v5/pattern_except.hpp>
-#endif
 
 #endif

data/src/cxx_supportlib/vendor-modified/boost/regex/pending/object_cache.hpp

@@ -20,10 +20,6 @@
 #define BOOST_REGEX_OBJECT_CACHE_HPP
 
 #include <boost/regex/config.hpp>
-#ifdef BOOST_REGEX_CXX03
-#include <boost/regex/v4/object_cache.hpp>
-#else
 #include <boost/regex/v5/object_cache.hpp>
-#endif
 
 #endif

data/src/cxx_supportlib/vendor-modified/boost/regex/pending/unicode_iterator.hpp

@@ -20,13 +20,7 @@
 #define BOOST_REGEX_PENDING_UNICODE_ITERATOR_HPP
 
 #include <boost/regex/config.hpp>
-
-#if defined(BOOST_REGEX_CXX03)
-#include <boost/regex/v4/unicode_iterator.hpp>
-#else
 #include <boost/regex/v5/unicode_iterator.hpp>
-#endif
-
 
 #endif // BOOST_REGEX_PENDING_UNICODE_ITERATOR_HPP
 

data/src/cxx_supportlib/vendor-modified/boost/regex/regex_traits.hpp

@@ -24,11 +24,7 @@
 #endif
 
 #  ifndef BOOST_REGEX_TRAITS_HPP_INCLUDED
-#ifdef BOOST_REGEX_CXX03
-#     include <boost/regex/v4/regex_traits.hpp>
-#else
 #     include <boost/regex/v5/regex_traits.hpp>
-#endif
 #  endif
 
 #endif // include

data/src/cxx_supportlib/vendor-modified/boost/regex/user.hpp

@@ -59,16 +59,6 @@
 // exception handling.
 // #define BOOST_REGEX_HAS_MS_STACK_GUARD
 
-// define this if you want to use the recursive algorithm
-// even if BOOST_REGEX_HAS_MS_STACK_GUARD is not defined.
-// NOTE: OBSOLETE!!
-// #define BOOST_REGEX_RECURSIVE
-
-// define this if you want to use the non-recursive
-// algorithm, even if the recursive version would be the default.
-// NOTE: OBSOLETE!!
-// #define BOOST_REGEX_NON_RECURSIVE
-
 // define this if you want to set the size of the memory blocks
 // used by the non-recursive algorithm.
 // #define BOOST_REGEX_BLOCKSIZE 4096
@@ -93,3 +83,7 @@
 
 // define this if you want regex to use __cdecl calling convensions, even when __fastcall is available:
 // #define BOOST_REGEX_NO_FASTCALL
+
+// define this to control how deep non-avoidable recursive function calls can go, typical expressions 
+// and format strings should only recurse a handful of times, this is mainly to prevent DOS type attacks.
+// #define BOOST_REGEX_MAX_RECURSION_DEPTH 100

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

@@ -19,7 +19,18 @@
 #ifndef BOOST_REGEX_V5_BASIC_REGEX_HPP
 #define BOOST_REGEX_V5_BASIC_REGEX_HPP
 
+#include <boost/regex/v5/regbase.hpp>
+#include <boost/regex/v5/syntax_type.hpp>
+#include <boost/regex/v5/regex_traits.hpp>
+#include <boost/regex/v5/states.hpp>
+#include <boost/regex/v5/regex_raw_buffer.hpp>
+
+#ifndef BOOST_REGEX_AS_MODULE
+#include <algorithm>
+#include <limits>
+#include <memory>
 #include <vector>
+#endif
 
 namespace boost{
 #ifdef BOOST_REGEX_MSVC
@@ -58,7 +69,12 @@ void bubble_down_one(I first, I last)
    }
 }
 
-static const int hash_value_mask = 1 << (std::numeric_limits<int>::digits - 1);
+#ifndef BOOST_REGEX_AS_MODULE
+static
+#else
+inline
+#endif
+const int hash_value_mask = 1 << (std::numeric_limits<int>::digits - 1);
 
 template <class Iterator>
 inline int hash_value_from_capture_name(Iterator i, Iterator j)
@@ -306,7 +322,7 @@ public:
 // represents the compiled
 // regular expression:
 //
-
+BOOST_REGEX_MODULE_EXPORT
 #ifdef BOOST_REGEX_NO_FWD
 template <class charT, class traits = regex_traits<charT> >
 #else
@@ -488,7 +504,7 @@ public:
    }
    //
    // swap:
-   void  swap(basic_regex& that)throw()
+   void  swap(basic_regex& that)noexcept
    {
       m_pimpl.swap(that.m_pimpl);
    }
@@ -533,7 +549,21 @@ public:
          return status() - that.status();
       if(flags() != that.flags())
          return flags() - that.flags();
-      return str().compare(that.str());
+      
+      const char_type* i = m_pimpl->begin();
+      const char_type* j = that.m_pimpl->begin();
+      while ((i != m_pimpl->end()) && (j != that.m_pimpl->end()))
+      {
+         if (*i != *j)
+            return *i < *j ? -1 : 1;
+         ++i;
+         ++j;
+      }
+      if (i != m_pimpl->end())
+         return *i > static_cast<char_type>(0) ? 1 : -1;
+      if (j != that.m_pimpl->end())
+         return *j > static_cast<char_type>(0) ? -1 : 1;
+      return 0;
    }
    bool  operator==(const basic_regex& e)const
    { 
@@ -629,22 +659,38 @@ private:
 // and are designed to provide the strong exception guarantee
 // (in the event of a throw, the state of the object remains unchanged).
 //
+
+namespace detail
+{
+   template <class charT, class F, class Traits>
+   std::shared_ptr<BOOST_REGEX_DETAIL_NS::basic_regex_implementation<charT, Traits> > create_implemenation(const charT* p1, const charT* p2, F f, std::shared_ptr<boost::regex_traits_wrapper<Traits> > ptraits)
+   {
+      std::shared_ptr<BOOST_REGEX_DETAIL_NS::basic_regex_implementation<charT, Traits> > result;
+      if (!ptraits.get())
+      {
+         result = std::shared_ptr<BOOST_REGEX_DETAIL_NS::basic_regex_implementation<charT, Traits> >(new BOOST_REGEX_DETAIL_NS::basic_regex_implementation<charT, Traits>());
+      }
+      else
+      {
+         result = std::shared_ptr<BOOST_REGEX_DETAIL_NS::basic_regex_implementation<charT, Traits> >(new BOOST_REGEX_DETAIL_NS::basic_regex_implementation<charT, Traits>(ptraits));
+      }
+      result->assign(p1, p2, f);
+      return result;
+   }
+#ifdef BOOST_REGEX_AS_MODULE
+   std::shared_ptr<BOOST_REGEX_DETAIL_NS::basic_regex_implementation<char, basic_regex<char>::traits_type> > 
+      create_implemenation(const char* p1, const char* p2, basic_regex<char>::flag_type f, std::shared_ptr<boost::regex_traits_wrapper<basic_regex<char>::traits_type> > ptraits);
+   std::shared_ptr<BOOST_REGEX_DETAIL_NS::basic_regex_implementation<wchar_t, basic_regex<wchar_t>::traits_type> > 
+      create_implemenation(const wchar_t* p1, const wchar_t* p2, basic_regex<wchar_t>::flag_type f, std::shared_ptr<boost::regex_traits_wrapper<basic_regex<wchar_t>::traits_type> > ptraits);
+#endif
+}
+
 template <class charT, class traits>
 basic_regex<charT, traits>& basic_regex<charT, traits>::do_assign(const charT* p1,
                         const charT* p2,
                         flag_type f)
 {
-   std::shared_ptr<BOOST_REGEX_DETAIL_NS::basic_regex_implementation<charT, traits> > temp;
-   if(!m_pimpl.get())
-   {
-      temp = std::shared_ptr<BOOST_REGEX_DETAIL_NS::basic_regex_implementation<charT, traits> >(new BOOST_REGEX_DETAIL_NS::basic_regex_implementation<charT, traits>());
-   }
-   else
-   {
-      temp = std::shared_ptr<BOOST_REGEX_DETAIL_NS::basic_regex_implementation<charT, traits> >(new BOOST_REGEX_DETAIL_NS::basic_regex_implementation<charT, traits>(m_pimpl->m_ptraits));
-   }
-   temp->assign(p1, p2, f);
-   temp.swap(m_pimpl);
+   m_pimpl = detail::create_implemenation(p1, p2, f, m_pimpl.get() ? m_pimpl->m_ptraits : std::shared_ptr<boost::regex_traits_wrapper<traits> >());
    return *this;
 }
 
@@ -660,13 +706,13 @@ typename basic_regex<charT, traits>::locale_type  basic_regex<charT, traits>::im
 //
 // non-members:
 //
-template <class charT, class traits>
+BOOST_REGEX_MODULE_EXPORT template <class charT, class traits>
 void swap(basic_regex<charT, traits>& e1, basic_regex<charT, traits>& e2)
 {
    e1.swap(e2);
 }
 
-template <class charT, class traits, class traits2>
+BOOST_REGEX_MODULE_EXPORT template <class charT, class traits, class traits2>
 std::basic_ostream<charT, traits>& 
    operator << (std::basic_ostream<charT, traits>& os, 
                 const basic_regex<charT, traits2>& e)

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

@@ -28,7 +28,12 @@
 #endif
 #endif
 
+#include <boost/regex/v5/basic_regex.hpp>
+
+#ifndef BOOST_REGEX_AS_MODULE
+#include <vector>
 #include <set>
+#endif
 
 namespace boost{
 
@@ -217,8 +222,10 @@ public:
          m_icase = static_cast<bool>(f & regbase::icase);
       }
    }
-   re_syntax_base* append_state(syntax_element_type t, std::size_t s = sizeof(re_syntax_base));
-   re_syntax_base* insert_state(std::ptrdiff_t pos, syntax_element_type t, std::size_t s = sizeof(re_syntax_base));
+   re_syntax_base* append_state(syntax_element_type t, std::size_t s);
+   re_syntax_base* append_state(syntax_element_type t) { return append_state(t, sizeof(re_syntax_base)); }
+   re_syntax_base* insert_state(std::ptrdiff_t pos, syntax_element_type t, std::size_t s);
+   re_syntax_base* insert_state(std::ptrdiff_t pos, syntax_element_type t) { return insert_state(pos, t, sizeof(re_syntax_base)); }
    re_literal* append_literal(charT c);
    re_syntax_base* append_set(const basic_char_set<charT, traits>& char_set);
    re_syntax_base* append_set(const basic_char_set<charT, traits>& char_set, std::integral_constant<bool, false>*);
@@ -248,7 +255,7 @@ private:
    void fixup_recursions(re_syntax_base* state);
    void create_startmaps(re_syntax_base* state);
    int calculate_backstep(re_syntax_base* state);
-   void create_startmap(re_syntax_base* state, unsigned char* l_map, unsigned int* pnull, unsigned char mask);
+   void create_startmap(re_syntax_base* state, unsigned char* l_map, unsigned int* pnull, unsigned char mask, unsigned recursion_count = 0);
    unsigned get_restart_type(re_syntax_base* state);
    void set_all_masks(unsigned char* bits, unsigned char);
    bool is_bad_repeat(re_syntax_base* pt);
@@ -971,7 +978,12 @@ template <class charT, class traits>
 int basic_regex_creator<charT, traits>::calculate_backstep(re_syntax_base* state)
 {
    typedef typename traits::char_class_type m_type;
+
    int result = 0;
+   int last_alternative_result = -1;
+
+   std::vector<std::tuple<int, re_syntax_base*>> stack;
+
    while(state)
    {
       switch(state->type)
@@ -990,9 +1002,28 @@ int basic_regex_creator<charT, traits>::calculate_backstep(re_syntax_base* state
          }
          break;
       case syntax_element_endmark:
-         if((static_cast<re_brace*>(state)->index == -1)
+         if ((static_cast<re_brace*>(state)->index == -1)
             || (static_cast<re_brace*>(state)->index == -2))
-            return result;
+         {
+            // We've finished the calculation, check against any previous alternatives:
+            if (last_alternative_result >= 0)
+            {
+               if (last_alternative_result != result)
+                  return -1;
+            }
+            else
+               last_alternative_result = result;
+
+            if (stack.size())
+            {
+               // Skip to next alternative and calculate that as well:
+               std::tie(result, state) = stack.back();
+               stack.pop_back();
+               continue;
+            }
+            else
+               return result;
+         }
          break;
       case syntax_element_literal:
          result += static_cast<re_literal*>(state)->length;
@@ -1048,11 +1079,13 @@ int basic_regex_creator<charT, traits>::calculate_backstep(re_syntax_base* state
          continue;
       case syntax_element_alt:
          {
-            int r1 = calculate_backstep(state->next.p);
-            int r2 = calculate_backstep(static_cast<re_alt*>(state)->alt.p);
-            if((r1 < 0) || (r1 != r2))
+            // Push the alternative if we haven't pushed too many already:
+            if(stack.size() > BOOST_REGEX_MAX_BLOCKS)
                return -1;
-            return result + r1;
+            stack.push_back(std::make_tuple(result, static_cast<re_alt*>(state)->alt.p));
+            // and take the first one:
+            state = state->next.p;
+            continue;
          }
       default:
          break;
@@ -1074,7 +1107,7 @@ struct recursion_saver
 };
 
 template <class charT, class traits>
-void basic_regex_creator<charT, traits>::create_startmap(re_syntax_base* state, unsigned char* l_map, unsigned int* pnull, unsigned char mask)
+void basic_regex_creator<charT, traits>::create_startmap(re_syntax_base* state, unsigned char* l_map, unsigned int* pnull, unsigned char mask, unsigned recursion_count)
 {
    recursion_saver saved_recursions(&m_recursion_checks);
    int not_last_jump = 1;
@@ -1085,6 +1118,28 @@ void basic_regex_creator<charT, traits>::create_startmap(re_syntax_base* state,
    // track case sensitivity:
    bool l_icase = m_icase;
 
+   if (recursion_count > BOOST_REGEX_MAX_RECURSION_DEPTH)
+   {
+      // Oops error:
+      if (0 == this->m_pdata->m_status) // update the error code if not already set
+         this->m_pdata->m_status = boost::regex_constants::error_complexity;
+      //
+      // clear the expression, we should be empty:
+      //
+      this->m_pdata->m_expression = 0;
+      this->m_pdata->m_expression_len = 0;
+      //
+      // and throw if required:
+      //
+      if (0 == (this->flags() & regex_constants::no_except))
+      {
+         std::string message = "Expression complexity exceeded.";
+         boost::regex_error e(message, boost::regex_constants::error_complexity, 0);
+         e.raise();
+      }
+      return;
+   }
+
    while(state)
    {
       switch(state->type)
@@ -1122,7 +1177,7 @@ void basic_regex_creator<charT, traits>::create_startmap(re_syntax_base* state,
          }
          // now figure out if we can match a NULL string at this point:
          if(pnull)
-            create_startmap(state->next.p, 0, pnull, mask);
+            create_startmap(state->next.p, 0, pnull, mask, ++recursion_count);
          return;
       }
       case syntax_element_recurse:
@@ -1184,7 +1239,7 @@ void basic_regex_creator<charT, traits>::create_startmap(re_syntax_base* state,
       case syntax_element_word_start:
       {
          // recurse, then AND with all the word characters:
-         create_startmap(state->next.p, l_map, pnull, mask);
+         create_startmap(state->next.p, l_map, pnull, mask, ++recursion_count);
          if(l_map)
          {
             l_map[0] |= mask_init;
@@ -1199,7 +1254,7 @@ void basic_regex_creator<charT, traits>::create_startmap(re_syntax_base* state,
       case syntax_element_word_end:
       {
          // recurse, then AND with all the word characters:
-         create_startmap(state->next.p, l_map, pnull, mask);
+         create_startmap(state->next.p, l_map, pnull, mask, ++recursion_count);
          if(l_map)
          {
             l_map[0] |= mask_init;
@@ -1291,11 +1346,11 @@ void basic_regex_creator<charT, traits>::create_startmap(re_syntax_base* state,
                   return;
                }
                set_bad_repeat(state);
-               create_startmap(state->next.p, l_map, pnull, mask);
+               create_startmap(state->next.p, l_map, pnull, mask, ++recursion_count);
                if((state->type == syntax_element_alt)
                   || (static_cast<re_repeat*>(state)->min == 0)
                   || (not_last_jump == 0))
-                  create_startmap(rep->alt.p, l_map, pnull, mask);
+                  create_startmap(rep->alt.p, l_map, pnull, mask, ++recursion_count);
             }
          }
          return;
@@ -1354,7 +1409,7 @@ void basic_regex_creator<charT, traits>::create_startmap(re_syntax_base* state,
             if(ok && ((m_recursion_checks[static_cast<re_brace*>(state)->index] & 2u) == 0))
             {
                m_recursion_checks[static_cast<re_brace*>(state)->index] |= 2u;
-               create_startmap(p->next.p, l_map, pnull, mask);
+               create_startmap(p->next.p, l_map, pnull, mask, ++recursion_count);
             }
          }
          state = state->next.p;

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

@@ -19,6 +19,15 @@
 #ifndef BOOST_REGEX_V5_BASIC_REGEX_PARSER_HPP
 #define BOOST_REGEX_V5_BASIC_REGEX_PARSER_HPP
 
+#include <boost/regex/v5/basic_regex_creator.hpp>
+
+#ifndef BOOST_REGEX_AS_MODULE
+#include <climits>
+#include <cstdint>
+#include <limits>
+#include <type_traits>
+#endif
+
 namespace boost{
 namespace BOOST_REGEX_DETAIL_NS{
 
@@ -889,6 +898,11 @@ escape_type_class_jump:
          }
          const charT* pc = m_position;
          std::intmax_t i = this->m_traits.toi(pc, m_end, 10);
+         if(i < 0 && !syn_end)
+         {
+            fail(regex_constants::error_backref, m_position - m_base);
+            return false;
+         }
          if((i < 0) && syn_end)
          {
             // Check for a named capture, get the leftmost one if there is more than one:
@@ -988,7 +1002,7 @@ bool basic_regex_parser<charT, traits>::parse_repeat(std::size_t low, std::size_
       if((m_position != m_end)
          && (0 == (this->flags() & regbase::main_option_type)) 
          && (this->m_traits.syntax_type(*m_position) == regex_constants::syntax_plus))
-      {
+      { 
          possessive = true;
          ++m_position;
       }
@@ -1105,6 +1119,13 @@ bool basic_regex_parser<charT, traits>::parse_repeat(std::size_t low, std::size_
                   else
                      contin = false;
                   break;
+               case regex_constants::syntax_hash:
+                  if (this->flags() & regex_constants::mod_x) {
+                     while((m_position != m_end) && !is_separator(*m_position++)){}
+                     contin = true;
+                     break;
+                  }
+                  BOOST_REGEX_FALLTHROUGH;
                default:
                   contin = false;
                }

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

@@ -19,9 +19,16 @@
 #ifndef BOOST_C_REGEX_TRAITS_HPP_INCLUDED
 #define BOOST_C_REGEX_TRAITS_HPP_INCLUDED
 
+#ifndef BOOST_REGEX_AS_MODULE
+#include <cctype>
+#include <cstdint>
+#include <cwctype>
+#endif
+
 #include <boost/regex/config.hpp>
 #include <boost/regex/v5/regex_workaround.hpp>
-#include <cctype>
+#include <boost/regex/v5/primary_transform.hpp>
+#include <boost/regex/v5/regex_traits_defaults.hpp>
 
 namespace boost{
 
@@ -49,10 +56,10 @@ namespace boost{
 
    }
 
-template <class charT>
+BOOST_REGEX_MODULE_EXPORT template <class charT>
 struct c_regex_traits;
 
-template<>
+BOOST_REGEX_MODULE_EXPORT template<>
 struct c_regex_traits<char>
 {
    c_regex_traits(){}
@@ -97,7 +104,7 @@ private:
 };
 
 #ifndef BOOST_NO_WREGEX
-template<>
+BOOST_REGEX_MODULE_EXPORT template<>
 struct c_regex_traits<wchar_t>
 {
    c_regex_traits(){}