passenger 6.1.0 → 6.1.1

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

@@ -19,9 +19,14 @@
 #ifndef BOOST_REGEX_V5_SUB_MATCH_HPP
 #define BOOST_REGEX_V5_SUB_MATCH_HPP
 
+#ifndef BOOST_REGEX_AS_MODULE
+#include <iterator>
+#include <utility>
+#endif
+
 namespace boost{
 
-template <class BidiIterator>
+BOOST_REGEX_MODULE_EXPORT template <class BidiIterator>
 struct sub_match : public std::pair<BidiIterator, BidiIterator>
 {
    typedef typename std::iterator_traits<BidiIterator>::value_type       value_type;
@@ -145,167 +150,167 @@ public:
    BidiIterator end()const { return this->second; }
 };
 
-typedef sub_match<const char*> csub_match;
-typedef sub_match<std::string::const_iterator> ssub_match;
+BOOST_REGEX_MODULE_EXPORT typedef sub_match<const char*> csub_match;
+BOOST_REGEX_MODULE_EXPORT typedef sub_match<std::string::const_iterator> ssub_match;
 #ifndef BOOST_NO_WREGEX
-typedef sub_match<const wchar_t*> wcsub_match;
-typedef sub_match<std::wstring::const_iterator> wssub_match;
+BOOST_REGEX_MODULE_EXPORT typedef sub_match<const wchar_t*> wcsub_match;
+BOOST_REGEX_MODULE_EXPORT typedef sub_match<std::wstring::const_iterator> wssub_match;
 #endif
 
 // comparison to std::basic_string<> part 1:
-template <class RandomAccessIterator, class traits, class Allocator>
+BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator, class traits, class Allocator>
 inline bool operator == (const std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,
                   const sub_match<RandomAccessIterator>& m)
 { return s.compare(m.str()) == 0; }
-template <class RandomAccessIterator, class traits, class Allocator>
+BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator, class traits, class Allocator>
 inline bool operator != (const std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,
                   const sub_match<RandomAccessIterator>& m)
 { return s.compare(m.str()) != 0; }
-template <class RandomAccessIterator, class traits, class Allocator>
+BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator, class traits, class Allocator>
 inline bool operator < (const std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,
                  const sub_match<RandomAccessIterator>& m)
 { return s.compare(m.str()) < 0; }
-template <class RandomAccessIterator, class traits, class Allocator>
+BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator, class traits, class Allocator>
 inline bool operator <= (const std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,
                   const sub_match<RandomAccessIterator>& m)
 { return s.compare(m.str()) <= 0; }
-template <class RandomAccessIterator, class traits, class Allocator>
+BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator, class traits, class Allocator>
 inline bool operator >= (const std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,
                   const sub_match<RandomAccessIterator>& m)
 { return s.compare(m.str()) >= 0; }
-template <class RandomAccessIterator, class traits, class Allocator>
+BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator, class traits, class Allocator>
 inline bool operator > (const std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,
                  const sub_match<RandomAccessIterator>& m)
 { return s.compare(m.str()) > 0; }
 // comparison to std::basic_string<> part 2:
-template <class RandomAccessIterator, class traits, class Allocator>
+BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator, class traits, class Allocator>
 inline bool operator == (const sub_match<RandomAccessIterator>& m,
                   const std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)
 { return m.str().compare(s) == 0; }
-template <class RandomAccessIterator, class traits, class Allocator>
+BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator, class traits, class Allocator>
 inline bool operator != (const sub_match<RandomAccessIterator>& m,
                   const std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)
 { return m.str().compare(s) != 0; }
-template <class RandomAccessIterator, class traits, class Allocator>
+BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator, class traits, class Allocator>
 inline bool operator < (const sub_match<RandomAccessIterator>& m,
                   const std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)
 { return m.str().compare(s) < 0; }
-template <class RandomAccessIterator, class traits, class Allocator>
+BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator, class traits, class Allocator>
 inline bool operator > (const sub_match<RandomAccessIterator>& m,
                   const std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)
 { return m.str().compare(s) > 0; }
-template <class RandomAccessIterator, class traits, class Allocator>
+BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator, class traits, class Allocator>
 inline bool operator <= (const sub_match<RandomAccessIterator>& m,
                   const std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)
 { return m.str().compare(s) <= 0; }
-template <class RandomAccessIterator, class traits, class Allocator>
+BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator, class traits, class Allocator>
 inline bool operator >= (const sub_match<RandomAccessIterator>& m,
                   const std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)
 { return m.str().compare(s) >= 0; }
 // comparison to const charT* part 1:
-template <class RandomAccessIterator>
+BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
 inline bool operator == (const sub_match<RandomAccessIterator>& m,
                   typename std::iterator_traits<RandomAccessIterator>::value_type const* s)
 { return m.str().compare(s) == 0; }
-template <class RandomAccessIterator>
+BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
 inline bool operator != (const sub_match<RandomAccessIterator>& m,
                   typename std::iterator_traits<RandomAccessIterator>::value_type const* s)
 { return m.str().compare(s) != 0; }
-template <class RandomAccessIterator>
+BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
 inline bool operator > (const sub_match<RandomAccessIterator>& m,
                   typename std::iterator_traits<RandomAccessIterator>::value_type const* s)
 { return m.str().compare(s) > 0; }
-template <class RandomAccessIterator>
+BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
 inline bool operator < (const sub_match<RandomAccessIterator>& m,
                   typename std::iterator_traits<RandomAccessIterator>::value_type const* s)
 { return m.str().compare(s) < 0; }
-template <class RandomAccessIterator>
+BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
 inline bool operator >= (const sub_match<RandomAccessIterator>& m,
                   typename std::iterator_traits<RandomAccessIterator>::value_type const* s)
 { return m.str().compare(s) >= 0; }
-template <class RandomAccessIterator>
+BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
 inline bool operator <= (const sub_match<RandomAccessIterator>& m,
                   typename std::iterator_traits<RandomAccessIterator>::value_type const* s)
 { return m.str().compare(s) <= 0; }
 // comparison to const charT* part 2:
-template <class RandomAccessIterator>
+BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
 inline bool operator == (typename std::iterator_traits<RandomAccessIterator>::value_type const* s,
                   const sub_match<RandomAccessIterator>& m)
 { return m.str().compare(s) == 0; }
-template <class RandomAccessIterator>
+BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
 inline bool operator != (typename std::iterator_traits<RandomAccessIterator>::value_type const* s,
                   const sub_match<RandomAccessIterator>& m)
 { return m.str().compare(s) != 0; }
-template <class RandomAccessIterator>
+BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
 inline bool operator < (typename std::iterator_traits<RandomAccessIterator>::value_type const* s,
                   const sub_match<RandomAccessIterator>& m)
 { return m.str().compare(s) > 0; }
-template <class RandomAccessIterator>
+BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
 inline bool operator > (typename std::iterator_traits<RandomAccessIterator>::value_type const* s,
                   const sub_match<RandomAccessIterator>& m)
 { return m.str().compare(s) < 0; }
-template <class RandomAccessIterator>
+BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
 inline bool operator <= (typename std::iterator_traits<RandomAccessIterator>::value_type const* s,
                   const sub_match<RandomAccessIterator>& m)
 { return m.str().compare(s) >= 0; }
-template <class RandomAccessIterator>
+BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
 inline bool operator >= (typename std::iterator_traits<RandomAccessIterator>::value_type const* s,
                   const sub_match<RandomAccessIterator>& m)
 { return m.str().compare(s) <= 0; }
 
 // comparison to const charT& part 1:
-template <class RandomAccessIterator>
+BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
 inline bool operator == (const sub_match<RandomAccessIterator>& m,
                   typename std::iterator_traits<RandomAccessIterator>::value_type const& s)
 { return m.str().compare(0, m.length(), &s, 1) == 0; }
-template <class RandomAccessIterator>
+BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
 inline bool operator != (const sub_match<RandomAccessIterator>& m,
                   typename std::iterator_traits<RandomAccessIterator>::value_type const& s)
 { return m.str().compare(0, m.length(), &s, 1) != 0; }
-template <class RandomAccessIterator>
+BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
 inline bool operator > (const sub_match<RandomAccessIterator>& m,
                   typename std::iterator_traits<RandomAccessIterator>::value_type const& s)
 { return m.str().compare(0, m.length(), &s, 1) > 0; }
-template <class RandomAccessIterator>
+BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
 inline bool operator < (const sub_match<RandomAccessIterator>& m,
                   typename std::iterator_traits<RandomAccessIterator>::value_type const& s)
 { return m.str().compare(0, m.length(), &s, 1) < 0; }
-template <class RandomAccessIterator>
+BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
 inline bool operator >= (const sub_match<RandomAccessIterator>& m,
                   typename std::iterator_traits<RandomAccessIterator>::value_type const& s)
 { return m.str().compare(0, m.length(), &s, 1) >= 0; }
-template <class RandomAccessIterator>
+BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
 inline bool operator <= (const sub_match<RandomAccessIterator>& m,
                   typename std::iterator_traits<RandomAccessIterator>::value_type const& s)
 { return m.str().compare(0, m.length(), &s, 1) <= 0; }
 // comparison to const charT* part 2:
-template <class RandomAccessIterator>
+BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
 inline bool operator == (typename std::iterator_traits<RandomAccessIterator>::value_type const& s,
                   const sub_match<RandomAccessIterator>& m)
 { return m.str().compare(0, m.length(), &s, 1) == 0; }
-template <class RandomAccessIterator>
+BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
 inline bool operator != (typename std::iterator_traits<RandomAccessIterator>::value_type const& s,
                   const sub_match<RandomAccessIterator>& m)
 { return m.str().compare(0, m.length(), &s, 1) != 0; }
-template <class RandomAccessIterator>
+BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
 inline bool operator < (typename std::iterator_traits<RandomAccessIterator>::value_type const& s,
                   const sub_match<RandomAccessIterator>& m)
 { return m.str().compare(0, m.length(), &s, 1) > 0; }
-template <class RandomAccessIterator>
+BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
 inline bool operator > (typename std::iterator_traits<RandomAccessIterator>::value_type const& s,
                   const sub_match<RandomAccessIterator>& m)
 { return m.str().compare(0, m.length(), &s, 1) < 0; }
-template <class RandomAccessIterator>
+BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
 inline bool operator <= (typename std::iterator_traits<RandomAccessIterator>::value_type const& s,
                   const sub_match<RandomAccessIterator>& m)
 { return m.str().compare(0, m.length(), &s, 1) >= 0; }
-template <class RandomAccessIterator>
+BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
 inline bool operator >= (typename std::iterator_traits<RandomAccessIterator>::value_type const& s,
                   const sub_match<RandomAccessIterator>& m)
 { return m.str().compare(0, m.length(), &s, 1) <= 0; }
 
 // addition operators:
-template <class RandomAccessIterator, class traits, class Allocator>
+BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator, class traits, class Allocator>
 inline std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type, traits, Allocator> 
 operator + (const std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,
                   const sub_match<RandomAccessIterator>& m)
@@ -314,7 +319,7 @@ operator + (const std::basic_string<typename std::iterator_traits<RandomAccessIt
    result.reserve(s.size() + m.length() + 1);
    return result.append(s).append(m.first, m.second);
 }
-template <class RandomAccessIterator, class traits, class Allocator>
+BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator, class traits, class Allocator>
 inline std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type, traits, Allocator> 
 operator + (const sub_match<RandomAccessIterator>& m,
             const std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)
@@ -323,7 +328,7 @@ operator + (const sub_match<RandomAccessIterator>& m,
    result.reserve(s.size() + m.length() + 1);
    return result.append(m.first, m.second).append(s);
 }
-template <class RandomAccessIterator>
+BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
 inline std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type> 
 operator + (typename std::iterator_traits<RandomAccessIterator>::value_type const* s,
                   const sub_match<RandomAccessIterator>& m)
@@ -332,7 +337,7 @@ operator + (typename std::iterator_traits<RandomAccessIterator>::value_type cons
    result.reserve(std::char_traits<typename std::iterator_traits<RandomAccessIterator>::value_type>::length(s) + m.length() + 1);
    return result.append(s).append(m.first, m.second);
 }
-template <class RandomAccessIterator>
+BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
 inline std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type> 
 operator + (const sub_match<RandomAccessIterator>& m,
             typename std::iterator_traits<RandomAccessIterator>::value_type const * s)
@@ -341,7 +346,7 @@ operator + (const sub_match<RandomAccessIterator>& m,
    result.reserve(std::char_traits<typename std::iterator_traits<RandomAccessIterator>::value_type>::length(s) + m.length() + 1);
    return result.append(m.first, m.second).append(s);
 }
-template <class RandomAccessIterator>
+BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
 inline std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type> 
 operator + (typename std::iterator_traits<RandomAccessIterator>::value_type const& s,
                   const sub_match<RandomAccessIterator>& m)
@@ -350,7 +355,7 @@ operator + (typename std::iterator_traits<RandomAccessIterator>::value_type cons
    result.reserve(m.length() + 2);
    return result.append(1, s).append(m.first, m.second);
 }
-template <class RandomAccessIterator>
+BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
 inline std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type> 
 operator + (const sub_match<RandomAccessIterator>& m,
             typename std::iterator_traits<RandomAccessIterator>::value_type const& s)
@@ -359,7 +364,7 @@ operator + (const sub_match<RandomAccessIterator>& m,
    result.reserve(m.length() + 2);
    return result.append(m.first, m.second).append(1, s);
 }
-template <class RandomAccessIterator>
+BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
 inline std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type> 
 operator + (const sub_match<RandomAccessIterator>& m1,
             const sub_match<RandomAccessIterator>& m2)
@@ -368,7 +373,7 @@ operator + (const sub_match<RandomAccessIterator>& m1,
    result.reserve(m1.length() + m2.length() + 1);
    return result.append(m1.first, m1.second).append(m2.first, m2.second);
 }
-template <class charT, class traits, class RandomAccessIterator>
+BOOST_REGEX_MODULE_EXPORT template <class charT, class traits, class RandomAccessIterator>
 std::basic_ostream<charT, traits>&
    operator << (std::basic_ostream<charT, traits>& os,
                 const sub_match<RandomAccessIterator>& s)

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

@@ -19,84 +19,86 @@
 #ifndef BOOST_REGEX_SYNTAX_TYPE_HPP
 #define BOOST_REGEX_SYNTAX_TYPE_HPP
 
+#include <boost/regex/config.hpp>
+
 namespace boost{
 namespace regex_constants{
 
-typedef unsigned char syntax_type;
+BOOST_REGEX_MODULE_EXPORT typedef unsigned char syntax_type;
 
 //
 // values chosen are binary compatible with previous version:
 //
-static const syntax_type syntax_char = 0;
-static const syntax_type syntax_open_mark = 1;
-static const syntax_type syntax_close_mark = 2;
-static const syntax_type syntax_dollar = 3;
-static const syntax_type syntax_caret = 4;
-static const syntax_type syntax_dot = 5;
-static const syntax_type syntax_star = 6;
-static const syntax_type syntax_plus = 7;
-static const syntax_type syntax_question = 8;
-static const syntax_type syntax_open_set = 9;
-static const syntax_type syntax_close_set = 10;
-static const syntax_type syntax_or = 11;
-static const syntax_type syntax_escape = 12;
-static const syntax_type syntax_dash = 14;
-static const syntax_type syntax_open_brace = 15;
-static const syntax_type syntax_close_brace = 16;
-static const syntax_type syntax_digit = 17;
-static const syntax_type syntax_comma = 27;
-static const syntax_type syntax_equal = 37;
-static const syntax_type syntax_colon = 36;
-static const syntax_type syntax_not = 53;
+BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST syntax_type syntax_char = 0;
+BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST syntax_type syntax_open_mark = 1;
+BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST syntax_type syntax_close_mark = 2;
+BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST syntax_type syntax_dollar = 3;
+BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST syntax_type syntax_caret = 4;
+BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST syntax_type syntax_dot = 5;
+BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST syntax_type syntax_star = 6;
+BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST syntax_type syntax_plus = 7;
+BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST syntax_type syntax_question = 8;
+BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST syntax_type syntax_open_set = 9;
+BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST syntax_type syntax_close_set = 10;
+BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST syntax_type syntax_or = 11;
+BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST syntax_type syntax_escape = 12;
+BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST syntax_type syntax_dash = 14;
+BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST syntax_type syntax_open_brace = 15;
+BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST syntax_type syntax_close_brace = 16;
+BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST syntax_type syntax_digit = 17;
+BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST syntax_type syntax_comma = 27;
+BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST syntax_type syntax_equal = 37;
+BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST syntax_type syntax_colon = 36;
+BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST syntax_type syntax_not = 53;
 
 // extensions:
 
-static const syntax_type syntax_hash = 13;
-static const syntax_type syntax_newline = 26;
+BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST syntax_type syntax_hash = 13;
+BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST syntax_type syntax_newline = 26;
 
 // escapes:
 
-typedef syntax_type escape_syntax_type;
-
-static const escape_syntax_type escape_type_word_assert = 18;
-static const escape_syntax_type escape_type_not_word_assert = 19;
-static const escape_syntax_type escape_type_control_f = 29;
-static const escape_syntax_type escape_type_control_n = 30;
-static const escape_syntax_type escape_type_control_r = 31;
-static const escape_syntax_type escape_type_control_t = 32;
-static const escape_syntax_type escape_type_control_v = 33;
-static const escape_syntax_type escape_type_ascii_control = 35;
-static const escape_syntax_type escape_type_hex = 34;
-static const escape_syntax_type escape_type_unicode = 0; // not used
-static const escape_syntax_type escape_type_identity = 0; // not used
-static const escape_syntax_type escape_type_backref = syntax_digit;
-static const escape_syntax_type escape_type_decimal = syntax_digit; // not used
-static const escape_syntax_type escape_type_class = 22; 
-static const escape_syntax_type escape_type_not_class = 23; 
+BOOST_REGEX_MODULE_EXPORT typedef syntax_type escape_syntax_type;
+
+BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_word_assert = 18;
+BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_not_word_assert = 19;
+BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_control_f = 29;
+BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_control_n = 30;
+BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_control_r = 31;
+BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_control_t = 32;
+BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_control_v = 33;
+BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_ascii_control = 35;
+BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_hex = 34;
+BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_unicode = 0; // not used
+BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_identity = 0; // not used
+BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_backref = syntax_digit;
+BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_decimal = syntax_digit; // not used
+BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_class = 22; 
+BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_not_class = 23; 
 
 // extensions:
 
-static const escape_syntax_type escape_type_left_word = 20;
-static const escape_syntax_type escape_type_right_word = 21;
-static const escape_syntax_type escape_type_start_buffer = 24;                 // for \`
-static const escape_syntax_type escape_type_end_buffer = 25;                   // for \'
-static const escape_syntax_type escape_type_control_a = 28;                    // for \a
-static const escape_syntax_type escape_type_e = 38;                            // for \e
-static const escape_syntax_type escape_type_E = 47;                            // for \Q\E
-static const escape_syntax_type escape_type_Q = 48;                            // for \Q\E
-static const escape_syntax_type escape_type_X = 49;                            // for \X
-static const escape_syntax_type escape_type_C = 50;                            // for \C
-static const escape_syntax_type escape_type_Z = 51;                            // for \Z
-static const escape_syntax_type escape_type_G = 52;                            // for \G
-
-static const escape_syntax_type escape_type_property = 54;                     // for \p
-static const escape_syntax_type escape_type_not_property = 55;                 // for \P
-static const escape_syntax_type escape_type_named_char = 56;                   // for \N
-static const escape_syntax_type escape_type_extended_backref = 57;             // for \g
-static const escape_syntax_type escape_type_reset_start_mark = 58;             // for \K
-static const escape_syntax_type escape_type_line_ending = 59;                  // for \R
-
-static const escape_syntax_type syntax_max = 60;
+BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_left_word = 20;
+BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_right_word = 21;
+BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_start_buffer = 24;                 // for \`
+BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_end_buffer = 25;                   // for \'
+BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_control_a = 28;                    // for \a
+BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_e = 38;                            // for \e
+BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_E = 47;                            // for \Q\E
+BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_Q = 48;                            // for \Q\E
+BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_X = 49;                            // for \X
+BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_C = 50;                            // for \C
+BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_Z = 51;                            // for \Z
+BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_G = 52;                            // for \G
+
+BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_property = 54;                     // for \p
+BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_not_property = 55;                 // for \P
+BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_named_char = 56;                   // for \N
+BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_extended_backref = 57;             // for \g
+BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_reset_start_mark = 58;             // for \K
+BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_line_ending = 59;                  // for \R
+
+BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type syntax_max = 60;
 
 }
 }

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

@@ -19,6 +19,21 @@
 #ifndef BOOST_REGEX_V5_U32REGEX_ITERATOR_HPP
 #define BOOST_REGEX_V5_U32REGEX_ITERATOR_HPP
 
+#include <boost/regex/config.hpp>
+
+#ifndef BOOST_REGEX_STANDALONE
+
+#include <boost/config.hpp>
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#pragma once
+#include <boost/regex/v5/icu.hpp>
+#endif
+
+#endif
+
+#include <boost/regex/v5/match_flags.hpp>
+#include <boost/regex/v5/match_results.hpp>
+
 namespace boost{
 
 template <class BidirectionalIterator>
@@ -35,6 +50,7 @@ class u32regex_iterator_implementation
 public:
    u32regex_iterator_implementation(const regex_type* p, BidirectionalIterator last, match_flag_type f)
       : base(), end(last), re(*p), flags(f){}
+   u32regex_iterator_implementation(const u32regex_iterator_implementation&) = default;
    bool init(BidirectionalIterator first)
    {
       base = first;

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

@@ -19,6 +19,18 @@
 #ifndef BOOST_REGEX_V5_U32REGEX_TOKEN_ITERATOR_HPP
 #define BOOST_REGEX_V5_U32REGEX_TOKEN_ITERATOR_HPP
 
+#include <boost/regex/config.hpp>
+
+#ifndef BOOST_REGEX_STANDALONE
+
+#include <boost/config.hpp>
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#pragma once
+#include <boost/regex/v5/icu.hpp>
+#endif
+
+#endif
+
 namespace boost{
 
 #ifdef BOOST_REGEX_MSVC

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

@@ -60,12 +60,14 @@ Accepts UTF-32 code points and forwards them on as UTF-16 code points.
 
 #ifndef BOOST_REGEX_UNICODE_ITERATOR_HPP
 #define BOOST_REGEX_UNICODE_ITERATOR_HPP
-#include <cstdint>
 #include <boost/regex/config.hpp>
+#ifndef BOOST_REGEX_AS_MODULE
+#include <cstdint>
 #include <stdexcept>
 #include <sstream>
 #include <ios>
 #include <limits.h> // CHAR_BIT
+#endif
 
 #ifndef BOOST_REGEX_STANDALONE
 #include <boost/throw_exception.hpp>
@@ -75,9 +77,9 @@ namespace boost{
 
 namespace detail{
 
-static const std::uint16_t high_surrogate_base = 0xD7C0u;
-static const std::uint16_t low_surrogate_base = 0xDC00u;
-static const std::uint32_t ten_bit_mask = 0x3FFu;
+BOOST_REGEX_STATIC_CONST std::uint16_t high_surrogate_base = 0xD7C0u;
+BOOST_REGEX_STATIC_CONST std::uint16_t low_surrogate_base = 0xDC00u;
+BOOST_REGEX_STATIC_CONST std::uint32_t ten_bit_mask = 0x3FFu;
 
 inline bool is_high_surrogate(std::uint16_t v)
 {

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

@@ -23,9 +23,11 @@
 
 #include <boost/regex/pattern_except.hpp>
 #include <boost/regex/v5/regex_traits_defaults.hpp>
+#ifndef BOOST_REGEX_AS_MODULE
 #ifdef BOOST_HAS_THREADS
 #include <mutex>
 #endif
+#endif
 #include <boost/regex/v5/primary_transform.hpp>
 #include <boost/regex/v5/object_cache.hpp>
 
@@ -652,7 +654,7 @@ std::shared_ptr<const w32_regex_traits_implementation<charT> > create_w32_regex_
 
 } // BOOST_REGEX_DETAIL_NS
 
-template <class charT>
+BOOST_REGEX_MODULE_EXPORT template <class charT>
 class w32_regex_traits
 {
 public:

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

@@ -28,11 +28,7 @@
 #include <boost/regex/config.hpp>
 #endif
 
-#ifdef BOOST_REGEX_CXX03
-#include <boost/regex/v4/regex.hpp>
-#else
 #include <boost/regex/v5/regex.hpp>
-#endif
 
 #endif  // include
 

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

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

data/src/cxx_supportlib/vendor-modified/boost/smart_ptr/detail/atomic_count.hpp

@@ -43,10 +43,7 @@
 //    Memory Ordering: acquire/release
 //
 
-#include <boost/smart_ptr/detail/sp_has_gcc_intrinsics.hpp>
-#include <boost/smart_ptr/detail/sp_has_sync_intrinsics.hpp>
 #include <boost/smart_ptr/detail/deprecated_macros.hpp>
-#include <boost/config.hpp>
 
 #if defined( BOOST_AC_DISABLE_THREADS )
 # include <boost/smart_ptr/detail/atomic_count_nt.hpp>
@@ -54,50 +51,11 @@
 #elif defined( BOOST_AC_USE_STD_ATOMIC )
 # include <boost/smart_ptr/detail/atomic_count_std_atomic.hpp>
 
-#elif defined( BOOST_AC_USE_SPINLOCK )
-# include <boost/smart_ptr/detail/atomic_count_spin.hpp>
-
-#elif defined( BOOST_AC_USE_PTHREADS )
-# include <boost/smart_ptr/detail/atomic_count_pt.hpp>
-
 #elif defined( BOOST_SP_DISABLE_THREADS )
 # include <boost/smart_ptr/detail/atomic_count_nt.hpp>
 
-#elif defined( BOOST_SP_USE_STD_ATOMIC )
-# include <boost/smart_ptr/detail/atomic_count_std_atomic.hpp>
-
-#elif defined( BOOST_SP_USE_SPINLOCK )
-# include <boost/smart_ptr/detail/atomic_count_spin.hpp>
-
-#elif defined( BOOST_SP_USE_PTHREADS )
-# include <boost/smart_ptr/detail/atomic_count_pt.hpp>
-
-#elif defined( BOOST_DISABLE_THREADS ) && !defined( BOOST_SP_ENABLE_THREADS ) && !defined( BOOST_DISABLE_WIN32 )
-# include <boost/smart_ptr/detail/atomic_count_nt.hpp>
-
-#elif defined( BOOST_SP_HAS_GCC_INTRINSICS )
-# include <boost/smart_ptr/detail/atomic_count_gcc_atomic.hpp>
-
-#elif !defined( BOOST_NO_CXX11_HDR_ATOMIC )
-# include <boost/smart_ptr/detail/atomic_count_std_atomic.hpp>
-
-#elif defined( BOOST_SP_HAS_SYNC_INTRINSICS )
-# include <boost/smart_ptr/detail/atomic_count_sync.hpp>
-
-#elif defined( __GNUC__ ) && ( defined( __i386__ ) || defined( __x86_64__ ) ) && !defined( __PATHSCALE__ )
-# include <boost/smart_ptr/detail/atomic_count_gcc_x86.hpp>
-
-#elif defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
-# include <boost/smart_ptr/detail/atomic_count_win32.hpp>
-
-#elif defined(__GLIBCPP__) || defined(__GLIBCXX__)
-# include <boost/smart_ptr/detail/atomic_count_gcc.hpp>
-
-#elif !defined( BOOST_HAS_THREADS )
-# include <boost/smart_ptr/detail/atomic_count_nt.hpp>
-
 #else
-# include <boost/smart_ptr/detail/atomic_count_spin.hpp>
+# include <boost/smart_ptr/detail/atomic_count_std_atomic.hpp>
 
 #endif