passenger 6.0.14 → 6.0.15

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

@@ -98,6 +98,7 @@ private:
    std::ptrdiff_t             m_alt_insert_point; // where to insert the next alternative
    bool                       m_has_case_change; // true if somewhere in the current block the case has changed
    unsigned                   m_recursion_count; // How many times we've called parse_all.
+   unsigned                   m_max_backref;     // Largest index of any backref.
 #if defined(BOOST_REGEX_MSVC) && defined(_M_IX86)
    // This is an ugly warning suppression workaround (for warnings *inside* std::vector
    // that can not otherwise be suppressed)...
@@ -114,7 +115,7 @@ private:
 template <class charT, class traits>
 basic_regex_parser<charT, traits>::basic_regex_parser(regex_data<charT, traits>* data)
    : basic_regex_creator<charT, traits>(data), m_parser_proc(), m_base(0), m_end(0), m_position(0), 
-   m_mark_count(0), m_mark_reset(-1), m_max_mark(0), m_paren_start(0), m_alt_insert_point(0), m_has_case_change(false), m_recursion_count(0)
+   m_mark_count(0), m_mark_reset(-1), m_max_mark(0), m_paren_start(0), m_alt_insert_point(0), m_has_case_change(false), m_recursion_count(0), m_max_backref(0)
 {
 }
 
@@ -184,6 +185,13 @@ void basic_regex_parser<charT, traits>::parse(const charT* p1, const charT* p2,
       return;
    // fill in our sub-expression count:
    this->m_pdata->m_mark_count = 1u + (std::size_t)m_mark_count;
+   //
+   // Check we don't have backreferences to sub-expressions which don't exist:
+   //
+   if (m_max_backref > m_mark_count)
+   {
+      fail(regex_constants::error_backref, std::distance(m_base, m_position), "Found a backreference to a non-existant sub-expression.");
+   }
    this->finalize(p1, p2);
 }
 
@@ -529,11 +537,6 @@ bool basic_regex_parser<charT, traits>::parse_open_paren()
    // restore the alternate insertion point:
    //
    this->m_alt_insert_point = last_alt_point;
-   //
-   // allow backrefs to this mark:
-   //
-   if(markid > 0)
-      this->m_backrefs.set(markid);
 
    return true;
 }
@@ -899,12 +902,14 @@ escape_type_class_jump:
          }
          if(negative)
             i = 1 + (static_cast<std::intmax_t>(m_mark_count) - i);
-         if(((i < hash_value_mask) && (i > 0) && (this->m_backrefs.test((std::size_t)i))) || ((i >= hash_value_mask) && (this->m_pdata->get_id((int)i) > 0) && (this->m_backrefs.test(this->m_pdata->get_id((int)i)))))
+         if(((i < hash_value_mask) && (i > 0)) || ((i >= hash_value_mask) && (this->m_pdata->get_id((int)i) > 0)))
          {
             m_position = pc;
             re_brace* pb = static_cast<re_brace*>(this->append_state(syntax_element_backref, sizeof(re_brace)));
             pb->index = (int)i;
             pb->icase = this->flags() & regbase::icase;
+            if ((i > m_max_backref) && (i < hash_value_mask))
+               m_max_backref = i;
          }
          else
          {
@@ -1029,6 +1034,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;
@@ -1934,12 +1940,14 @@ bool basic_regex_parser<charT, traits>::parse_backref()
       charT c = unescape_character();
       this->append_literal(c);
    }
-   else if((i > 0) && (this->m_backrefs.test((std::size_t)i)))
+   else if((i > 0))
    {
       m_position = pc;
       re_brace* pb = static_cast<re_brace*>(this->append_state(syntax_element_backref, sizeof(re_brace)));
       pb->index = (int)i;
       pb->icase = this->flags() & regbase::icase;
+      if(i > m_max_backref)
+         m_max_backref = i;
    }
    else
    {
@@ -2695,10 +2703,6 @@ option_group_jump:
    {
       if(this->flags() & regbase::save_subexpression_location)
          this->m_pdata->m_subs.at((std::size_t)markid - 1).second = std::distance(m_base, m_position) - 1;
-      //
-      // allow backrefs to this mark:
-      //
-      this->m_backrefs.set(markid);
    }
    return true;
 }
@@ -3104,7 +3108,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/v5/icu.hpp

@@ -161,7 +161,7 @@ public:
    }
    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/v5/mem_block_cache.hpp

@@ -34,6 +34,7 @@
 namespace boost{
 namespace BOOST_REGEX_DETAIL_NS{
 
+#if BOOST_REGEX_MAX_CACHE_BLOCKS != 0
 #ifdef BOOST_REGEX_MEM_BLOCK_CACHE_LOCK_FREE /* lock free implementation */
 struct mem_block_cache
 {
@@ -138,6 +139,7 @@ struct mem_block_cache
    }
 };
 #endif
+#endif
 
 #if BOOST_REGEX_MAX_CACHE_BLOCKS == 0
 

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

@@ -77,7 +77,8 @@ typedef regex_error bad_expression;
 
 namespace BOOST_REGEX_DETAIL_NS{
 
-inline void 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);
@@ -90,7 +91,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/v5/perl_matcher_common.hpp

@@ -471,6 +471,11 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_word_boundary()
 template <class BidiIterator, class Allocator, class traits>
 bool perl_matcher<BidiIterator, Allocator, traits>::match_within_word()
 {
+   bool b = !match_word_boundary();
+   if(b)
+      pstate = pstate->next.p;
+   return b;
+   /*
    if(position == last)
       return false;
    // both prev and this character must be m_word_mask:
@@ -492,6 +497,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_within_word()
       }
    }
    return false;
+   */
 }
 
 template <class BidiIterator, class Allocator, class traits>

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

@@ -417,7 +417,8 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_startmark()
          {
             // Must be unwinding from a COMMIT/SKIP/PRUNE and the independent 
             // sub failed, need to unwind everything else:
-            while(unwind(false));
+            while (m_backup_state->state_id)
+               unwind(false);
             return false;
          }
 #if !defined(BOOST_NO_EXCEPTIONS)
@@ -1353,6 +1354,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::unwind_repeater_counter(bool
 template <class BidiIterator, class Allocator, class traits>
 bool perl_matcher<BidiIterator, Allocator, traits>::unwind_extra_block(bool)
 {
+   ++used_block_count;
    saved_extra_block* pmp = static_cast<saved_extra_block*>(m_backup_state);
    void* condemmed = m_stack_base;
    m_stack_base = pmp->base;