passenger 6.0.27 → 6.1.1

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

@@ -19,6 +19,16 @@
 #ifndef BOOST_REGEX_V5_MATCH_RESULTS_HPP
 #define BOOST_REGEX_V5_MATCH_RESULTS_HPP
 
+#include <boost/regex/v5/match_flags.hpp>
+#include <boost/regex/v5/sub_match.hpp>
+#include <boost/regex/v5/basic_regex.hpp>
+#include <boost/regex/v5/regex_format.hpp>
+
+#ifndef BOOST_REGEX_AS_MODULE
+#include <string>
+#include <vector>
+#endif
+
 namespace boost{
 #ifdef BOOST_REGEX_MSVC
 #pragma warning(push)
@@ -37,7 +47,7 @@ class named_subexpressions;
 
 }
 
-template <class BidiIterator, class Allocator>
+BOOST_REGEX_MODULE_EXPORT template <class BidiIterator, class Allocator>
 class match_results
 { 
 private:
@@ -97,15 +107,23 @@ public:
    bool empty() const
    { return m_subs.size() < 2; }
    // element access:
-   difference_type length(int sub = 0) const
+private:
+   difference_type do_get_length(int sub = 0) const
    {
-      if(m_is_singular)
+      if (m_is_singular)
          raise_logic_error();
       sub += 2;
-      if((sub < (int)m_subs.size()) && (sub > 0))
+      if ((sub < (int)m_subs.size()) && (sub > 0))
          return m_subs[sub].length();
       return 0;
    }
+public:
+   template <class Integer>
+   typename std::enable_if<std::is_integral<Integer>::value, difference_type>::type length(Integer sub) const
+   {
+      return do_get_length(static_cast<int>(sub));
+   }
+   difference_type length() const { return do_get_length(0); }
    difference_type length(const char_type* sub) const
    {
       if(m_is_singular)
@@ -161,7 +179,8 @@ public:
    {
       return position(sub.c_str());
    }
-   string_type str(int sub = 0) const
+private:
+   string_type do_get_string(int sub = 0) const
    {
       if(m_is_singular)
          raise_logic_error();
@@ -177,6 +196,13 @@ public:
       }
       return result;
    }
+public:
+   template <class Integer>
+   typename std::enable_if<std::is_integral<Integer>::value, string_type>::type str(Integer sub) const
+   {
+      return do_get_string(static_cast<int>(sub));
+   }
+   string_type str() const { return do_get_string(0); }
    string_type str(const char_type* sub) const
    {
       return (*this)[sub].str();
@@ -196,10 +222,15 @@ public:
    {
       return (*this)[sub].str();
    }
-   const_reference operator[](int sub) const
+   private:
+   const_reference get_at(int sub) const
    {
       if(m_is_singular && m_subs.empty())
          raise_logic_error();
+      
+      if (sub >= INT_MAX - 2 )
+         return m_null;
+
       sub += 2;
       if(sub < (int)m_subs.size() && (sub >= 0))
       {
@@ -207,6 +238,12 @@ public:
       }
       return m_null;
    }
+public:
+   template <class Integer>
+   typename std::enable_if<std::is_integral<Integer>::value, const_reference>::type operator[](Integer sub) const
+   {
+      return get_at(static_cast<int>(sub));
+   }
    //
    // Named sub-expressions:
    //
@@ -530,7 +567,7 @@ public:
 
    void  set_named_subs(std::shared_ptr<named_sub_type> subs)
    {
-      m_named_subs = subs;
+      m_named_subs = std::move(subs);
    }
 
 private:
@@ -643,13 +680,13 @@ void  match_results<BidiIterator, Allocator>::maybe_assign(const match_results<B
       *this = m;
 }
 
-template <class BidiIterator, class Allocator>
+BOOST_REGEX_MODULE_EXPORT template <class BidiIterator, class Allocator>
 void swap(match_results<BidiIterator, Allocator>& a, match_results<BidiIterator, Allocator>& b)
 {
    a.swap(b);
 }
 
-template <class charT, class traits, class BidiIterator, class Allocator>
+BOOST_REGEX_MODULE_EXPORT template <class charT, class traits, class BidiIterator, class Allocator>
 std::basic_ostream<charT, traits>&
    operator << (std::basic_ostream<charT, traits>& os,
                 const match_results<BidiIterator, Allocator>& s)

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

@@ -18,6 +18,8 @@
 #ifndef BOOST_REGEX_V5_MEM_BLOCK_CACHE_HPP
 #define BOOST_REGEX_V5_MEM_BLOCK_CACHE_HPP
 
+#include <boost/regex/config.hpp>
+#ifndef BOOST_REGEX_AS_MODULE
 #include <new>
 #ifdef BOOST_HAS_THREADS
 #include <mutex>
@@ -30,6 +32,8 @@
     #define BOOST_REGEX_ATOMIC_POINTER std::atomic
   #endif
 #endif
+#endif
+
 
 namespace boost{
 namespace BOOST_REGEX_DETAIL_NS{

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

@@ -20,6 +20,7 @@
 #define BOOST_REGEX_OBJECT_CACHE_HPP
 
 #include <boost/regex/config.hpp>
+#ifndef BOOST_REGEX_AS_MODULE
 #include <memory>
 #include <map>
 #include <list>
@@ -28,6 +29,7 @@
 #ifdef BOOST_HAS_THREADS
 #include <mutex>
 #endif
+#endif
 
 namespace boost{
 

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

@@ -23,8 +23,10 @@
 #include <boost/regex/config.hpp>
 #endif
 
+#ifndef BOOST_REGEX_AS_MODULE
 #include <cstddef>
 #include <stdexcept>
+#endif
 #include <boost/regex/v5/error_type.hpp>
 #include <boost/regex/v5/regex_traits_defaults.hpp>
 
@@ -37,7 +39,7 @@ namespace boost{
 #pragma warning(disable : 26812 4459)
 #endif
 #endif
-class regex_error : public std::runtime_error
+BOOST_REGEX_MODULE_EXPORT class regex_error : public std::runtime_error
 {
 public:
    explicit regex_error(const std::string& s, regex_constants::error_type err = regex_constants::error_unknown, std::ptrdiff_t pos = 0)
@@ -52,7 +54,7 @@ public:
       , m_position(0)
    {
    }
-   ~regex_error() noexcept override {}
+   ~regex_error() noexcept override = default;
    regex_constants::error_type code()const
    { return m_error_code; }
    std::ptrdiff_t position()const
@@ -72,8 +74,8 @@ private:
    std::ptrdiff_t m_position;
 };
 
-typedef regex_error bad_pattern;
-typedef regex_error bad_expression;
+BOOST_REGEX_MODULE_EXPORT typedef regex_error bad_pattern;
+BOOST_REGEX_MODULE_EXPORT typedef regex_error bad_expression;
 
 namespace BOOST_REGEX_DETAIL_NS{
 

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

@@ -12,7 +12,20 @@
 #ifndef BOOST_REGEX_MATCHER_HPP
 #define BOOST_REGEX_MATCHER_HPP
 
+#include <boost/regex/v5/match_flags.hpp>
+#include <boost/regex/v5/match_results.hpp>
+#include <boost/regex/v5/regbase.hpp>
 #include <boost/regex/v5/iterator_category.hpp>
+#include <boost/regex/v5/states.hpp>
+#include <boost/regex/v5/regex_traits.hpp>
+
+#ifndef BOOST_REGEX_AS_MODULE
+#ifndef BOOST_REGEX_STANDALONE
+#include <boost/throw_exception.hpp>
+#endif
+
+#include <climits>
+#endif
 
 #ifdef BOOST_REGEX_MSVC
 #  pragma warning(push)
@@ -28,25 +41,34 @@
 #endif
 #endif
 
+#ifndef BOOST_REGEX_STANDALONE
+#  define BOOST_REGEX_DETAIL_THROW(ex) boost::throw_exception(ex)
+#else
+#  define BOOST_REGEX_DETAIL_THROW(ex) throw ex
+#endif
+
 namespace boost{
 namespace BOOST_REGEX_DETAIL_NS{
 
 //
 // error checking API:
 //
-inline void  verify_options(boost::regex_constants::syntax_option_type, match_flag_type mf)
+inline void verify_options(boost::regex_constants::syntax_option_type, match_flag_type mf)
 {
+   auto is_perl = (mf & match_perl);
+   auto is_posix = (mf & match_posix);
+
+   if (is_perl && is_posix)
+   {
+      BOOST_REGEX_DETAIL_THROW(std::logic_error("Usage Error: Can't mix Perl and POSIX matching rules"));
+   }
+
    //
    // can't mix match_extra with POSIX matching rules:
    //
-   if ((mf & match_extra) && (mf & match_posix))
+   if ((mf & match_extra) && is_posix)
    {
-      std::logic_error msg("Usage Error: Can't mix regular expression captures with POSIX matching rules");
-#ifndef BOOST_REGEX_STANDALONE
-      throw_exception(msg);
-#else
-      throw msg;
-#endif
+      BOOST_REGEX_DETAIL_THROW(std::logic_error("Usage Error: Can't mix regular expression captures with POSIX matching rules"));
    }
 }
 //
@@ -558,6 +580,33 @@ private:
 #endif
 };
 
+template <class Matcher>
+inline bool factory_match(Matcher& m)
+{
+   return m.match();
+}
+template <class Matcher>
+inline bool factory_find(Matcher& m)
+{
+   return m.find();
+}
+
+#ifdef BOOST_REGEX_AS_MODULE
+bool factory_match(perl_matcher<const char*, match_results<const char*>::allocator_type, regex::traits_type>& m);
+bool factory_match(perl_matcher<const wchar_t*, match_results<const wchar_t*>::allocator_type, wregex::traits_type>& m);
+bool factory_match(perl_matcher<std::string::const_iterator, match_results<std::string::const_iterator>::allocator_type, regex::traits_type>& m);
+bool factory_match(perl_matcher<std::wstring::const_iterator, match_results<std::wstring::const_iterator>::allocator_type, wregex::traits_type>& m);
+bool factory_match(perl_matcher<std::string::iterator, match_results<std::string::iterator>::allocator_type, regex::traits_type>& m);
+bool factory_match(perl_matcher<std::wstring::iterator, match_results<std::wstring::iterator>::allocator_type, wregex::traits_type>& m);
+
+bool factory_find(perl_matcher<const char*, match_results<const char*>::allocator_type, regex::traits_type>& m);
+bool factory_find(perl_matcher<const wchar_t*, match_results<const wchar_t*>::allocator_type, wregex::traits_type>& m);
+bool factory_find(perl_matcher<std::string::const_iterator, match_results<std::string::const_iterator>::allocator_type, regex::traits_type>& m);
+bool factory_find(perl_matcher<std::wstring::const_iterator, match_results<std::wstring::const_iterator>::allocator_type, wregex::traits_type>& m);
+bool factory_find(perl_matcher<std::string::iterator, match_results<std::string::iterator>::allocator_type, regex::traits_type>& m);
+bool factory_find(perl_matcher<std::wstring::iterator, match_results<std::wstring::iterator>::allocator_type, wregex::traits_type>& m);
+#endif
+
 } // namespace BOOST_REGEX_DETAIL_NS
 
 #ifdef BOOST_REGEX_MSVC

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

@@ -20,6 +20,22 @@
 #ifndef BOOST_REGEX_V5_PERL_MATCHER_COMMON_HPP
 #define BOOST_REGEX_V5_PERL_MATCHER_COMMON_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/perl_matcher.hpp>
+#endif
+
+#endif
+
+#include <boost/regex/v5/basic_regex.hpp>
+#include <boost/regex/v5/match_flags.hpp>
+#include <boost/regex/v5/match_results.hpp>
+
 #ifdef BOOST_REGEX_MSVC
 #  pragma warning(push)
 #pragma warning(disable:4459)
@@ -44,12 +60,7 @@ void perl_matcher<BidiIterator, Allocator, traits>::construct_init(const basic_r
    if(e.empty())
    {
       // precondition failure: e is not a valid regex.
-      std::invalid_argument ex("Invalid regular expression object");
-#ifndef BOOST_REGEX_STANDALONE
-      boost::throw_exception(ex);
-#else
-      throw e;
-#endif
+      BOOST_REGEX_DETAIL_THROW(std::invalid_argument("Invalid regular expression object"));
    }
    pstate = 0;
    m_match_flags = f;
@@ -82,7 +93,11 @@ void perl_matcher<BidiIterator, Allocator, traits>::construct_init(const basic_r
    match_any_mask = static_cast<unsigned char>((f & match_not_dot_newline) ? BOOST_REGEX_DETAIL_NS::test_not_newline : BOOST_REGEX_DETAIL_NS::test_newline);
    // Disable match_any if requested in the state machine:
    if(e.get_data().m_disable_match_any)
+   {
+      if (m_match_flags & match_posix)
+         BOOST_REGEX_DETAIL_THROW(std::logic_error("Invalid regex for POSIX-style matching"));
       m_match_flags &= regex_constants::match_not_any;
+   }
 }
 #ifdef BOOST_REGEX_MSVC
 #  pragma warning(pop)

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

@@ -20,6 +20,18 @@
 #ifndef BOOST_REGEX_V5_PERL_MATCHER_NON_RECURSIVE_HPP
 #define BOOST_REGEX_V5_PERL_MATCHER_NON_RECURSIVE_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/perl_matcher.hpp>
+#endif
+
+#endif
+
 #include <boost/regex/v5/mem_block_cache.hpp>
 
 #ifdef BOOST_REGEX_MSVC
@@ -225,8 +237,8 @@ void perl_matcher<BidiIterator, Allocator, traits>::extend_stack()
       saved_state* backup_state;
       stack_base = static_cast<saved_state*>(get_mem_block());
       backup_state = reinterpret_cast<saved_state*>(reinterpret_cast<char*>(stack_base)+BOOST_REGEX_BLOCKSIZE);
-      saved_extra_block* block = static_cast<saved_extra_block*>(backup_state);
-      --block;
+      saved_extra_block* block = reinterpret_cast<saved_extra_block*>(
+         reinterpret_cast<std::uintptr_t>(backup_state) - sizeof(saved_extra_block));
       (void) new (block) saved_extra_block(m_stack_base, m_backup_state);
       m_stack_base = stack_base;
       m_backup_state = block;
@@ -1204,7 +1216,10 @@ bool perl_matcher<BidiIterator, Allocator, traits>::skip_until_paren(int index,
       else if(pstate->type == syntax_element_startmark)
       {
          int idx = static_cast<const re_brace*>(pstate)->index;
-         pstate = pstate->next.p;
+         if(idx > 0)
+            match_startmark();
+         else
+            pstate = pstate->next.p;
          skip_until_paren(idx, false);
          continue;
       }

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

@@ -19,6 +19,8 @@
 #ifndef BOOST_REGEX_V5_REGBASE_HPP
 #define BOOST_REGEX_V5_REGBASE_HPP
 
+#include <boost/regex/config.hpp>
+
 namespace boost{
 //
 // class regbase
@@ -112,7 +114,7 @@ public:
 //
 namespace regex_constants{
 
-   enum flag_type_
+   BOOST_REGEX_MODULE_EXPORT enum flag_type_
    {
 
       no_except = ::boost::regbase::no_except,
@@ -148,7 +150,7 @@ namespace regex_constants{
       JavaScript = normal,
       JScript = normal
    };
-   typedef ::boost::regbase::flag_type syntax_option_type;
+   BOOST_REGEX_MODULE_EXPORT typedef ::boost::regbase::flag_type syntax_option_type;
 
 } // namespace regex_constants
 

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

@@ -46,17 +46,17 @@
 
 namespace boost{
 #ifdef BOOST_REGEX_NO_FWD
-typedef basic_regex<char, regex_traits<char> > regex;
+BOOST_REGEX_MODULE_EXPORT typedef basic_regex<char, regex_traits<char> > regex;
 #ifndef BOOST_NO_WREGEX
-typedef basic_regex<wchar_t, regex_traits<wchar_t> > wregex;
+BOOST_REGEX_MODULE_EXPORT typedef basic_regex<wchar_t, regex_traits<wchar_t> > wregex;
 #endif
 #endif
 
-typedef match_results<const char*> cmatch;
-typedef match_results<std::string::const_iterator> smatch;
+BOOST_REGEX_MODULE_EXPORT typedef match_results<const char*> cmatch;
+BOOST_REGEX_MODULE_EXPORT typedef match_results<std::string::const_iterator> smatch;
 #ifndef BOOST_NO_WREGEX
-typedef match_results<const wchar_t*> wcmatch;
-typedef match_results<std::wstring::const_iterator> wsmatch;
+BOOST_REGEX_MODULE_EXPORT typedef match_results<const wchar_t*> wcmatch;
+BOOST_REGEX_MODULE_EXPORT typedef match_results<std::wstring::const_iterator> wsmatch;
 #endif
 
 } // namespace boost

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

@@ -21,15 +21,20 @@
 #ifndef BOOST_REGEX_FORMAT_HPP
 #define BOOST_REGEX_FORMAT_HPP
 
+#include <boost/regex/v5/match_flags.hpp>
+#include <boost/regex/v5/sub_match.hpp>
+#include <boost/regex/v5/regex_traits_defaults.hpp>
+#ifndef BOOST_REGEX_AS_MODULE
 #include <type_traits>
 #include <functional>
+#endif
 
 namespace boost{
 
 //
 // Forward declaration:
 //
-   template <class BidiIterator, class Allocator = typename std::vector<sub_match<BidiIterator> >::allocator_type >
+BOOST_REGEX_MODULE_EXPORT template <class BidiIterator, class Allocator = typename std::vector<sub_match<BidiIterator> >::allocator_type >
 class match_results;
 
 namespace BOOST_REGEX_DETAIL_NS{
@@ -97,11 +102,11 @@ private:
 
    void put(char_type c);
    void put(const sub_match_type& sub);
-   void format_all();
+   void format_all(unsigned recursion_count = 0);
    void format_perl();
    void format_escape();
-   void format_conditional();
-   void format_until_scope_end();
+   void format_conditional(unsigned recursion_count);
+   void format_until_scope_end(unsigned recursion_count);
    bool handle_perl_verb(bool have_brace);
 
    inline typename Results::value_type const& get_named_sub(ForwardIter i, ForwardIter j, const std::integral_constant<bool, false>&)
@@ -199,7 +204,7 @@ OutputIterator basic_regex_formatter<OutputIterator, Results, traits, ForwardIte
 }
 
 template <class OutputIterator, class Results, class traits, class ForwardIter>
-void basic_regex_formatter<OutputIterator, Results, traits, ForwardIter>::format_all()
+void basic_regex_formatter<OutputIterator, Results, traits, ForwardIter>::format_all(unsigned recursion_count)
 {
    // over and over:
    while(m_position != m_end)
@@ -219,12 +224,12 @@ void basic_regex_formatter<OutputIterator, Results, traits, ForwardIter>::format
          format_escape();
          break;
       case '(':
-         if(m_flags & boost::regex_constants::format_all)
+         if((m_flags & boost::regex_constants::format_all) && (recursion_count < BOOST_REGEX_MAX_RECURSION_DEPTH))
          {
             ++m_position;
             bool have_conditional = m_have_conditional;
             m_have_conditional = false;
-            format_until_scope_end();
+            format_until_scope_end(recursion_count);
             m_have_conditional = have_conditional;
             if(m_position == m_end)
                return;
@@ -252,10 +257,10 @@ void basic_regex_formatter<OutputIterator, Results, traits, ForwardIter>::format
          ++m_position;
          break;
       case '?':
-         if(m_flags & boost::regex_constants::format_all)
+         if((m_flags & boost::regex_constants::format_all) && (recursion_count < BOOST_REGEX_MAX_RECURSION_DEPTH))
          {
             ++m_position;
-            format_conditional();
+            format_conditional(recursion_count);
             break;
          }
          put(*m_position);
@@ -644,7 +649,7 @@ void basic_regex_formatter<OutputIterator, Results, traits, ForwardIter>::format
 }
 
 template <class OutputIterator, class Results, class traits, class ForwardIter>
-void basic_regex_formatter<OutputIterator, Results, traits, ForwardIter>::format_conditional()
+void basic_regex_formatter<OutputIterator, Results, traits, ForwardIter>::format_conditional(unsigned recursion_count)
 {
    if(m_position == m_end)
    {
@@ -692,7 +697,7 @@ void basic_regex_formatter<OutputIterator, Results, traits, ForwardIter>::format
    if(m_results[v].matched)
    {
       m_have_conditional = true;
-      format_all();
+      format_all(++recursion_count);
       m_have_conditional = false;
       if((m_position != m_end) && (*m_position == static_cast<char_type>(':')))
       {
@@ -702,7 +707,7 @@ void basic_regex_formatter<OutputIterator, Results, traits, ForwardIter>::format
          output_state saved_state = m_state;
          m_state = output_none;
          // format the rest of this scope:
-         format_until_scope_end();
+         format_until_scope_end(recursion_count);
          // restore output state:
          m_state = saved_state;
       }
@@ -714,7 +719,7 @@ void basic_regex_formatter<OutputIterator, Results, traits, ForwardIter>::format
       m_state = output_none;
       // format until ':' or ')':
       m_have_conditional = true;
-      format_all();
+      format_all(++recursion_count);
       m_have_conditional = false;
       // restore state:
       m_state = saved_state;
@@ -723,17 +728,17 @@ void basic_regex_formatter<OutputIterator, Results, traits, ForwardIter>::format
          // skip the ':':
          ++m_position;
          // format the rest of this scope:
-         format_until_scope_end();
+         format_until_scope_end(recursion_count);
       }
    }
 }
 
 template <class OutputIterator, class Results, class traits, class ForwardIter>
-void basic_regex_formatter<OutputIterator, Results, traits, ForwardIter>::format_until_scope_end()
+void basic_regex_formatter<OutputIterator, Results, traits, ForwardIter>::format_until_scope_end(unsigned recursion_count)
 {
    do
    {
-      format_all();
+      format_all(++recursion_count);
       if((m_position == m_end) || (*m_position == static_cast<char_type>(')')))
          return;
       put(*m_position++);
@@ -1095,7 +1100,7 @@ struct compute_functor_type
 
 } // namespace BOOST_REGEX_DETAIL_NS
 
-template <class OutputIterator, class Iterator, class Allocator, class Functor>
+BOOST_REGEX_MODULE_EXPORT template <class OutputIterator, class Iterator, class Allocator, class Functor>
 inline OutputIterator regex_format(OutputIterator out,
                           const match_results<Iterator, Allocator>& m,
                           Functor fmt,
@@ -1105,7 +1110,7 @@ inline OutputIterator regex_format(OutputIterator out,
    return m.format(out, fmt, flags);
 }
 
-template <class Iterator, class Allocator, class Functor>
+BOOST_REGEX_MODULE_EXPORT template <class Iterator, class Allocator, class Functor>
 inline std::basic_string<typename match_results<Iterator, Allocator>::char_type> regex_format(const match_results<Iterator, Allocator>& m, 
                                       Functor fmt, 
                                       match_flag_type flags = format_all)

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

@@ -36,30 +36,30 @@
 
 namespace boost{
 
-template <class charT>
+BOOST_REGEX_MODULE_EXPORT template <class charT>
 class cpp_regex_traits;
-template <class charT>
+BOOST_REGEX_MODULE_EXPORT template <class charT>
 struct c_regex_traits;
-template <class charT>
+BOOST_REGEX_MODULE_EXPORT template <class charT>
 class w32_regex_traits;
 
 #ifdef BOOST_REGEX_USE_WIN32_LOCALE
-template <class charT, class implementationT = w32_regex_traits<charT> >
+BOOST_REGEX_MODULE_EXPORT template <class charT, class implementationT = w32_regex_traits<charT> >
 struct regex_traits;
 #elif defined(BOOST_REGEX_USE_CPP_LOCALE)
-template <class charT, class implementationT = cpp_regex_traits<charT> >
+BOOST_REGEX_MODULE_EXPORT template <class charT, class implementationT = cpp_regex_traits<charT> >
 struct regex_traits;
 #else
-template <class charT, class implementationT = c_regex_traits<charT> >
+BOOST_REGEX_MODULE_EXPORT template <class charT, class implementationT = c_regex_traits<charT> >
 struct regex_traits;
 #endif
 
-template <class charT, class traits = regex_traits<charT> >
+BOOST_REGEX_MODULE_EXPORT template <class charT, class traits = regex_traits<charT> >
 class basic_regex;
 
-typedef basic_regex<char, regex_traits<char> > regex;
+BOOST_REGEX_MODULE_EXPORT typedef basic_regex<char, regex_traits<char> > regex;
 #ifndef BOOST_NO_WREGEX
-typedef basic_regex<wchar_t, regex_traits<wchar_t> > wregex;
+BOOST_REGEX_MODULE_EXPORT typedef basic_regex<wchar_t, regex_traits<wchar_t> > wregex;
 #endif
 
 } // namespace boost