passenger 6.0.2 → 6.0.15

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

@@ -24,7 +24,11 @@
 #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

@@ -61,10 +61,12 @@
 
 // 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

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

@@ -20,7 +20,7 @@
 #define BOOST_REGEX_V4_BASIC_REGEX_HPP
 
 #include <boost/type_traits/is_same.hpp>
-#include <boost/functional/hash.hpp>
+#include <boost/container_hash/hash.hpp>
 
 #ifdef BOOST_MSVC
 #pragma warning(push)
@@ -36,10 +36,16 @@
 namespace boost{
 #ifdef BOOST_MSVC
 #pragma warning(push)
-#pragma warning(disable : 4251 4231 4800)
+#pragma warning(disable : 4251)
+#if BOOST_MSVC < 1700
+#     pragma warning(disable : 4231)
+#endif
 #if BOOST_MSVC < 1600
 #pragma warning(disable : 4660)
 #endif
+#if BOOST_MSVC < 1910
+#pragma warning(disable:4800)
+#endif
 #endif
 
 namespace BOOST_REGEX_DETAIL_NS{
@@ -64,13 +70,14 @@ void bubble_down_one(I first, I last)
    }
 }
 
+static 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)
 {
    std::size_t r = boost::hash_range(i, j);
-   r %= ((std::numeric_limits<int>::max)() - 10001);
-   r += 10000;
-   return static_cast<int>(r);
+   r %= ((std::numeric_limits<int>::max)());
+   return static_cast<int>(r) | hash_value_mask;
 }
 
 class named_subexpressions
@@ -164,9 +171,19 @@ struct regex_data : public named_subexpressions
 
    regex_data(const ::boost::shared_ptr<
       ::boost::regex_traits_wrapper<traits> >& t) 
-      : m_ptraits(t), m_expression(0), m_expression_len(0), m_disable_match_any(false) {}
+      : m_ptraits(t), m_flags(0), m_status(0), m_expression(0), m_expression_len(0),
+         m_mark_count(0), m_first_state(0), m_restart_type(0),
+#if !defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX) && !(defined(BOOST_MSVC) && (BOOST_MSVC < 1900))
+         m_startmap{ 0 },
+#endif
+         m_can_be_null(0), m_word_mask(0), m_has_recursions(false), m_disable_match_any(false) {}
    regex_data() 
-      : m_ptraits(new ::boost::regex_traits_wrapper<traits>()), m_expression(0), m_expression_len(0), m_disable_match_any(false) {}
+      : m_ptraits(new ::boost::regex_traits_wrapper<traits>()), m_flags(0), m_status(0), m_expression(0), m_expression_len(0), 
+         m_mark_count(0), m_first_state(0), m_restart_type(0), 
+#if !defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX) && !(defined(BOOST_MSVC) && (BOOST_MSVC < 1900))
+      m_startmap{ 0 },
+#endif
+         m_can_be_null(0), m_word_mask(0), m_has_recursions(false), m_disable_match_any(false) {}
 
    ::boost::shared_ptr<
       ::boost::regex_traits_wrapper<traits>
@@ -399,7 +416,7 @@ public:
    {
       typedef typename traits::string_type seq_type;
       seq_type a(arg_first, arg_last);
-      if(a.size())
+      if(!a.empty())
          assign(static_cast<const charT*>(&*a.begin()), static_cast<const charT*>(&*a.begin() + a.size()), f);
       else
          assign(static_cast<const charT*>(0), static_cast<const charT*>(0), f);
@@ -600,32 +617,32 @@ public:
    //
    const BOOST_REGEX_DETAIL_NS::re_syntax_base* get_first_state()const
    {
-      BOOST_ASSERT(0 != m_pimpl.get());
+      BOOST_REGEX_ASSERT(0 != m_pimpl.get());
       return m_pimpl->get_first_state();
    }
    unsigned get_restart_type()const
    {
-      BOOST_ASSERT(0 != m_pimpl.get());
+      BOOST_REGEX_ASSERT(0 != m_pimpl.get());
       return m_pimpl->get_restart_type();
    }
    const unsigned char* get_map()const
    {
-      BOOST_ASSERT(0 != m_pimpl.get());
+      BOOST_REGEX_ASSERT(0 != m_pimpl.get());
       return m_pimpl->get_map();
    }
    const ::boost::regex_traits_wrapper<traits>& get_traits()const
    {
-      BOOST_ASSERT(0 != m_pimpl.get());
+      BOOST_REGEX_ASSERT(0 != m_pimpl.get());
       return m_pimpl->get_traits();
    }
    bool can_be_null()const
    {
-      BOOST_ASSERT(0 != m_pimpl.get());
+      BOOST_REGEX_ASSERT(0 != m_pimpl.get());
       return m_pimpl->can_be_null();
    }
    const BOOST_REGEX_DETAIL_NS::regex_data<charT, traits>& get_data()const
    {
-      BOOST_ASSERT(0 != m_pimpl.get());
+      BOOST_REGEX_ASSERT(0 != m_pimpl.get());
       return m_pimpl->get_data();
    }
    boost::shared_ptr<BOOST_REGEX_DETAIL_NS::named_subexpressions > get_named_subs()const
@@ -640,7 +657,7 @@ private:
 //
 // out of line members;
 // these are the only members that mutate the basic_regex object,
-// and are designed to provide the strong exception guarentee
+// and are designed to provide the strong exception guarantee
 // (in the event of a throw, the state of the object remains unchanged).
 //
 template <class charT, class traits>
@@ -778,4 +795,3 @@ public:
 #endif
 
 #endif
-

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

@@ -20,6 +20,8 @@
 #ifndef BOOST_REGEX_V4_BASIC_REGEX_CREATOR_HPP
 #define BOOST_REGEX_V4_BASIC_REGEX_CREATOR_HPP
 
+#include <boost/regex/v4/indexed_bit_flag.hpp>
+
 #ifdef BOOST_MSVC
 #pragma warning(push)
 #pragma warning(disable: 4103)
@@ -33,7 +35,9 @@
 
 #ifdef BOOST_MSVC
 #  pragma warning(push)
-#  pragma warning(disable: 4800)
+#if BOOST_MSVC < 1910
+#pragma warning(disable:4800)
+#endif
 #endif
 
 namespace boost{
@@ -48,11 +52,14 @@ struct digraph : public std::pair<charT, charT>
    digraph(charT c1, charT c2) : std::pair<charT, charT>(c1, c2)
    {}
    digraph(const digraph<charT>& d) : std::pair<charT, charT>(d.first, d.second){}
+#ifndef BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
+   digraph<charT>& operator=(const digraph<charT>&) = default;
+#endif
    template <class Seq>
    digraph(const Seq& s) : std::pair<charT, charT>()
    {
-      BOOST_ASSERT(s.size() <= 2);
-      BOOST_ASSERT(s.size());
+      BOOST_REGEX_ASSERT(s.size() <= 2);
+      BOOST_REGEX_ASSERT(s.size());
       this->first = s[0];
       this->second = (s.size() > 1) ? s[1] : 0;
    }
@@ -237,9 +244,9 @@ 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
-   unsigned                      m_backrefs;           // bitmask of permitted backrefs
+   indexed_bit_flag              m_backrefs;           // bitmask of permitted backrefs
    boost::uintmax_t              m_bad_repeats;        // bitmask of repeats we can't deduce a startmap for;
-   bool                          m_has_recursions;     // set when we have recursive expresisons to fixup
+   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
    typename traits::char_class_type m_word_mask;       // mask used to determine if a character is a word character
    typename traits::char_class_type m_mask_space;      // mask used to determine if a character is a word character
@@ -265,7 +272,8 @@ private:
 
 template <class charT, class traits>
 basic_regex_creator<charT, traits>::basic_regex_creator(regex_data<charT, traits>* data)
-   : m_pdata(data), m_traits(*(data->m_ptraits)), m_last_state(0), m_repeater_id(0), m_has_backrefs(false), m_backrefs(0), m_has_recursions(false)
+   : m_pdata(data), m_traits(*(data->m_ptraits)), m_last_state(0), m_icase(false), m_repeater_id(0), 
+   m_has_backrefs(false), m_bad_repeats(0), m_has_recursions(false), m_word_mask(0), m_mask_space(0), m_lower_mask(0), m_upper_mask(0), m_alpha_mask(0)
 {
    m_pdata->m_data.clear();
    m_pdata->m_status = ::boost::regex_constants::error_ok;
@@ -280,11 +288,11 @@ basic_regex_creator<charT, traits>::basic_regex_creator(regex_data<charT, traits
    m_upper_mask = m_traits.lookup_classname(u, u + 5);
    m_alpha_mask = m_traits.lookup_classname(a, a + 5);
    m_pdata->m_word_mask = m_word_mask;
-   BOOST_ASSERT(m_word_mask != 0); 
-   BOOST_ASSERT(m_mask_space != 0); 
-   BOOST_ASSERT(m_lower_mask != 0); 
-   BOOST_ASSERT(m_upper_mask != 0); 
-   BOOST_ASSERT(m_alpha_mask != 0); 
+   BOOST_REGEX_ASSERT(m_word_mask != 0); 
+   BOOST_REGEX_ASSERT(m_mask_space != 0); 
+   BOOST_REGEX_ASSERT(m_lower_mask != 0); 
+   BOOST_REGEX_ASSERT(m_upper_mask != 0); 
+   BOOST_REGEX_ASSERT(m_alpha_mask != 0); 
 }
 
 template <class charT, class traits>
@@ -298,7 +306,7 @@ re_syntax_base* basic_regex_creator<charT, traits>::append_state(syntax_element_
    // set the offset to the next state in our last one:
    if(m_last_state)
       m_last_state->next.i = m_pdata->m_data.size() - getoffset(m_last_state);
-   // now actually extent our data:
+   // now actually extend our data:
    m_last_state = static_cast<re_syntax_base*>(m_pdata->m_data.extend(s));
    // fill in boilerplate options in the new state:
    m_last_state->next.i = 0;
@@ -442,9 +450,9 @@ re_syntax_base* basic_regex_creator<charT, traits>::append_set(
          charT a2[3] = { c2.first, c2.second, charT(0), };
          s1 = this->m_traits.transform(a1, (a1[1] ? a1+2 : a1+1));
          s2 = this->m_traits.transform(a2, (a2[1] ? a2+2 : a2+1));
-         if(s1.size() == 0)
+         if(s1.empty())
             s1 = string_type(1, charT(0));
-         if(s2.size() == 0)
+         if(s2.empty())
             s2 = string_type(1, charT(0));
       }
       else
@@ -572,7 +580,7 @@ re_syntax_base* basic_regex_creator<charT, traits>::append_set(
             // Oops error:
             return 0;
          }
-         BOOST_ASSERT(c3[1] == charT(0));
+         BOOST_REGEX_ASSERT(c3[1] == charT(0));
          for(unsigned i = 0; i < (1u << CHAR_BIT); ++i)
          {
             c3[0] = static_cast<charT>(i);
@@ -589,7 +597,7 @@ re_syntax_base* basic_regex_creator<charT, traits>::append_set(
             return 0;
          }
          // everything in range matches:
-         std::memset(result->_map + static_cast<unsigned char>(c1), true, 1 + static_cast<unsigned char>(c2) - static_cast<unsigned char>(c1));
+         std::memset(result->_map + static_cast<unsigned char>(c1), true, static_cast<unsigned char>(1u) + static_cast<unsigned char>(static_cast<unsigned char>(c2) - static_cast<unsigned char>(c1)));
       }
    }
    //
@@ -637,7 +645,7 @@ re_syntax_base* basic_regex_creator<charT, traits>::append_set(
    while(sfirst != slast)
    {
       string_type s;
-      BOOST_ASSERT(static_cast<charT>(0) == sfirst->second);
+      BOOST_REGEX_ASSERT(static_cast<charT>(0) == sfirst->second);
       s = m_traits.transform_primary(&sfirst->first, &sfirst->first+1);
       if(s.empty())
          return 0;  // invalid or unsupported equivalence class
@@ -761,7 +769,7 @@ void basic_regex_creator<charT, traits>::fixup_recursions(re_syntax_base* state)
             if(idx < 0)
             {
                idx = -idx-1;
-               if(idx >= 10000)
+               if(idx >= hash_value_mask)
                {
                   idx = m_pdata->get_id(idx);
                   if(idx <= 0)
@@ -793,7 +801,7 @@ void basic_regex_creator<charT, traits>::fixup_recursions(re_syntax_base* state)
             bool ok = false;
             re_syntax_base* p = base;
             std::ptrdiff_t idx = static_cast<re_jump*>(state)->alt.i;
-            if(idx > 10000)
+            if(idx >= hash_value_mask)
             {
                //
                // There may be more than one capture group with this hash, just do what Perl
@@ -946,7 +954,7 @@ void basic_regex_creator<charT, traits>::create_startmaps(re_syntax_base* state)
    }
 
    // now work through our list, building all the maps as we go:
-   while(v.size())
+   while(!v.empty())
    {
       // Initialize m_recursion_checks if we need it:
       if(m_has_recursions)
@@ -1030,7 +1038,7 @@ int basic_regex_creator<charT, traits>::calculate_backstep(re_syntax_base* state
             }
             else if(state->type == syntax_element_long_set_rep)
             {
-               BOOST_ASSERT(rep->next.p->type == syntax_element_long_set);
+               BOOST_REGEX_ASSERT(rep->next.p->type == syntax_element_long_set);
                if(static_cast<re_set_long<m_type>*>(rep->next.p)->singleton == 0)
                   return -1;
                if(rep->max != rep->min)
@@ -1065,9 +1073,21 @@ int basic_regex_creator<charT, traits>::calculate_backstep(re_syntax_base* state
    return -1;
 }
 
+struct recursion_saver
+{
+   std::vector<unsigned char> saved_state;
+   std::vector<unsigned char>* state;
+   recursion_saver(std::vector<unsigned char>* p) : saved_state(*p), state(p) {}
+   ~recursion_saver()
+   {
+      state->swap(saved_state);
+   }
+};
+
 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)
 {
+   recursion_saver saved_recursions(&m_recursion_checks);
    int not_last_jump = 1;
    re_syntax_base* recursion_start = 0;
    int recursion_sub = 0;
@@ -1118,7 +1138,7 @@ void basic_regex_creator<charT, traits>::create_startmap(re_syntax_base* state,
       }
       case syntax_element_recurse:
          {
-            BOOST_ASSERT(static_cast<const re_jump*>(state)->alt.p->type == syntax_element_startmark);
+            BOOST_REGEX_ASSERT(static_cast<const re_jump*>(state)->alt.p->type == syntax_element_startmark);
             recursion_sub = static_cast<re_brace*>(static_cast<const re_jump*>(state)->alt.p)->index;
             if(m_recursion_checks[recursion_sub] & 1u)
             {
@@ -1499,7 +1519,7 @@ template <class charT, class traits>
 void basic_regex_creator<charT, traits>::probe_leading_repeat(re_syntax_base* state)
 {
    // enumerate our states, and see if we have a leading repeat 
-   // for which failed search restarts can be optimised;
+   // for which failed search restarts can be optimized;
    do
    {
       switch(state->type)
@@ -1510,6 +1530,10 @@ void basic_regex_creator<charT, traits>::probe_leading_repeat(re_syntax_base* st
             state = state->next.p;
             continue;
          }
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#pragma warning(disable:6011)
+#endif
          if((static_cast<re_brace*>(state)->index == -1)
             || (static_cast<re_brace*>(state)->index == -2))
          {
@@ -1517,6 +1541,9 @@ void basic_regex_creator<charT, traits>::probe_leading_repeat(re_syntax_base* st
             state = static_cast<const re_jump*>(state->next.p)->alt.p->next.p;
             continue;
          }
+#ifdef BOOST_MSVC
+#  pragma warning(pop)
+#endif
          if(static_cast<re_brace*>(state)->index == -3)
          {
             // Have to skip the leading jump state:
@@ -1549,7 +1576,6 @@ void basic_regex_creator<charT, traits>::probe_leading_repeat(re_syntax_base* st
    }while(state);
 }
 
-
 } // namespace BOOST_REGEX_DETAIL_NS
 
 } // namespace boost
@@ -1570,4 +1596,3 @@ void basic_regex_creator<charT, traits>::probe_leading_repeat(re_syntax_base* st
 #endif
 
 #endif
-