Merge pull request #246 from cmazakas/cve-42512790

fix integer overflow when parsing Perl-extended named backrefs

.github/workflows/ci.yml

@@ -10,9 +10,14 @@ on:
       - master
       - develop
       - feature/**
+      - cve-*
   pull_request:
   release:
     types: [published, created, edited]
+
+env:
+  UBSAN_OPTIONS: print_stacktrace=1
+
 jobs:
   ubuntu-jammy:
     runs-on: ubuntu-22.04
@@ -60,7 +65,7 @@ jobs:
         run: ../../../b2 print_config_info toolset=$TOOLSET
         working-directory: ../boost-root/libs/config/test
       - name: Test
-        run: ../../../b2 toolset=$TOOLSET
+        run: ../../../b2 toolset=$TOOLSET variant=debug,release ${{ startsWith(matrix.compiler, 'g++-13') && 'address-sanitizer=norecover undefined-sanitizer=norecover' || '' }}
         working-directory: ../boost-root/libs/regex/test
   ubuntu-jammy-standalone:
     runs-on: ubuntu-22.04
@@ -135,6 +140,89 @@ jobs:
       - name: Test
         run: ../../../b2 toolset=$TOOLSET define=CI_SUPPRESS_KNOWN_ISSUES define=SLOW_COMPILER
         working-directory: ../boost-root/libs/regex/test
+  ubuntu-jammy-clang-18-modules:
+    runs-on: ubuntu-22.04
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          fetch-depth: '0'
+      - uses: mstachniuk/ci-skip@v1
+        with:
+          commit-filter: '[skip ci];[ci skip];[CI SKIP];[SKIP CI];***CI SKIP***;***SKIP CI***;[windows];[Windows];[WINDOWS];[apple];[Apple];[APPLE]'
+          commit-filter-separator: ';'
+          fail-fast: true
+      - name: Grab install script
+        run: wget https://apt.llvm.org/llvm.sh && chmod u+x llvm.sh
+      - name: Install clang 18 packages
+        run: sudo ./llvm.sh 18 && clang++-18 --version
+      - name: Checkout main boost
+        run: git clone -b develop --depth 1 https://github.com/boostorg/boost.git ../boost-root
+      - name: Update tools/boostdep
+        run: git submodule update --init tools/boostdep
+        working-directory: ../boost-root
+      - name: Copy files
+        run: cp -r $GITHUB_WORKSPACE/* libs/regex
+        working-directory: ../boost-root
+      - name: Install deps
+        run: python tools/boostdep/depinst/depinst.py -I example -g "--jobs 3" regex
+        working-directory: ../boost-root
+      - name: Bootstrap
+        run: ./bootstrap.sh
+        working-directory: ../boost-root
+      - name: Generate headers
+        run: ./b2 headers
+        working-directory: ../boost-root
+      - name: Test
+        run: CXX=clang++-18 LIBRARIES="-licuuc -licudata -licui18n" ./test_clang.sh
+        working-directory: ../boost-root/libs/regex/test/module
+  ubuntu-noble-clang:
+    runs-on: ubuntu-24.04
+    strategy:
+      fail-fast: false
+      matrix:
+        compiler: [ clang++-16, clang++-17, clang++-18 ]
+        standard: [ c++11, c++14, c++17, c++20 ]
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          fetch-depth: '0'
+      - uses: mstachniuk/ci-skip@v1
+        with:
+          commit-filter: '[skip ci];[ci skip];[CI SKIP];[SKIP CI];***CI SKIP***;***SKIP CI***;[windows];[Windows];[WINDOWS];[apple];[Apple];[APPLE]'
+          commit-filter-separator: ';'
+          fail-fast: true
+      - name: Set TOOLSET
+        run: echo ${{ matrix.compiler }} | awk '/^g/ { print "TOOLSET=gcc" } /^clang/ { print "TOOLSET=clang" }' >> $GITHUB_ENV
+      - name: Add repository
+        run: sudo apt-add-repository -y "ppa:ubuntu-toolchain-r/test"
+      - name: Install packages
+        run: sudo apt install clang-16 clang-17 clang-18
+      - name: Checkout main boost
+        run: git clone -b develop --depth 1 https://github.com/boostorg/boost.git ../boost-root
+      - name: Update tools/boostdep
+        run: git submodule update --init tools/boostdep
+        working-directory: ../boost-root
+      - name: Copy files
+        run: cp -r $GITHUB_WORKSPACE/* libs/regex
+        working-directory: ../boost-root
+      - name: Install deps
+        run: python tools/boostdep/depinst/depinst.py -I example -g "--jobs 3" regex
+        working-directory: ../boost-root
+      - name: Bootstrap
+        run: ./bootstrap.sh
+        working-directory: ../boost-root
+      - name: Generate headers
+        run: ./b2 headers
+        working-directory: ../boost-root
+      - name: Generate user config
+        run: 'echo "using $TOOLSET : : ${{ matrix.compiler }} : <cxxflags>-std=${{ matrix.standard }} ;" > ~/user-config.jam'
+        working-directory: ../boost-root
+      - name: Config info
+        run: ../../../b2 print_config_info toolset=$TOOLSET
+        working-directory: ../boost-root/libs/config/test
+      - name: Test
+        run: ../../../b2 toolset=$TOOLSET define=CI_SUPPRESS_KNOWN_ISSUES define=SLOW_COMPILER variant=debug,release ${{ startsWith(matrix.compiler, 'clang++-18') && 'address-sanitizer=norecover undefined-sanitizer=norecover' || '' }}
+        working-directory: ../boost-root/libs/regex/test
   macos:
     runs-on: macos-latest
     strategy:
@@ -339,6 +427,9 @@ jobs:
           commit-filter: '[skip ci];[ci skip];[CI SKIP];[SKIP CI];***CI SKIP***;***SKIP CI***;[apple];[Apple];[APPLE];[linux];[Linux];[LINUX]'
           commit-filter-separator: ';'
           fail-fast: true
+      - uses: TheMrMilchmann/setup-msvc-dev@v3
+        with:
+          arch: x64
       - name: Checkout main boost
         run: git clone -b develop --depth 1 https://github.com/boostorg/boost.git ../boost-root
       - name: Update tools/boostdep
@@ -365,6 +456,9 @@ jobs:
       - name: Test
         run: ..\..\..\b2 --hash %ARGS%
         working-directory: ../boost-root/libs/regex/test
+      - name: Module Test
+        run: msvc_test.bat
+        working-directory: ../boost-root/libs/regex/test/module
   ubuntu-cmake-install:
     runs-on: ubuntu-20.04
     strategy:

doc/html/boost_regex/install.html

@@ -7,7 +7,7 @@
 <link rel="home" href="../index.html" title="Boost.Regex 7.0.1">
 <link rel="up" href="../index.html" title="Boost.Regex 7.0.1">
 <link rel="prev" href="configuration/tuning.html" title="Algorithm Tuning">
-<link rel="next" href="intro.html" title="Introduction and Overview">
+<link rel="next" href="modules.html" title="Module Support (Experimental)">
 <meta name="viewport" content="width=device-width, initial-scale=1">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
@@ -21,7 +21,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="configuration/tuning.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="intro.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
+<a accesskey="p" href="configuration/tuning.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="modules.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
@@ -109,7 +109,7 @@
 </div>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="configuration/tuning.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="intro.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
+<a accesskey="p" href="configuration/tuning.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="modules.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 </body>
 </html>

doc/html/boost_regex/intro.html

@@ -6,7 +6,7 @@
 <meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
 <link rel="home" href="../index.html" title="Boost.Regex 7.0.1">
 <link rel="up" href="../index.html" title="Boost.Regex 7.0.1">
-<link rel="prev" href="install.html" title="Building and Installing the Library">
+<link rel="prev" href="modules.html" title="Module Support (Experimental)">
 <link rel="next" href="unicode.html" title="Unicode and Boost.Regex">
 <meta name="viewport" content="width=device-width, initial-scale=1">
 </head>
@@ -21,7 +21,7 @@
 </tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="install.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="unicode.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
+<a accesskey="p" href="modules.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="unicode.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
@@ -206,7 +206,7 @@
 </div>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="install.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="unicode.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
+<a accesskey="p" href="modules.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="unicode.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
 </div>
 </body>
 </html>

doc/html/boost_regex/modules.html

@@ -0,0 +1,108 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+<title>Module Support (Experimental)</title>
+<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
+<link rel="home" href="../index.html" title="Boost.Regex 7.0.1">
+<link rel="up" href="../index.html" title="Boost.Regex 7.0.1">
+<link rel="prev" href="install.html" title="Building and Installing the Library">
+<link rel="next" href="intro.html" title="Introduction and Overview">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
+<td align="center"><a href="../../../../../more/index.htm">More</a></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="install.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="intro.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="boost_regex.modules"></a><a class="link" href="modules.html" title="Module Support (Experimental)">Module Support (Experimental)</a>
+</h2></div></div></div>
+<p>
+      This library has experimental support for C++ modules (C++20 or later), currently
+      the support is experimental not least because at the time of writing (2025)
+      build tools have yet to catch up with module support.
+    </p>
+<p>
+      In order to use this library as a module you simply add a:
+    </p>
+<pre class="programlisting"><span class="identifier">import</span> <span class="identifier">boost</span><span class="special">.</span><span class="identifier">regex</span><span class="special">;</span>
+</pre>
+<p>
+      to your code.
+    </p>
+<p>
+      Before that you must first build the module, which consists of these steps:
+    </p>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
+<li class="listitem">
+          Depending on your compiler, you may need to build the standard library
+          module, and place the standard module somewhere that your compiler can
+          find it.
+        </li>
+<li class="listitem">
+          Build <code class="computeroutput"><span class="identifier">libs</span><span class="special">/</span><span class="identifier">regex</span><span class="special">/</span><span class="identifier">module</span><span class="special">/</span><span class="identifier">regex</span><span class="special">.</span><span class="identifier">cxx</span></code> into the boost.regex module, and
+          place the module definition file somewhere that your compiler can find
+          it.
+        </li>
+<li class="listitem">
+          Build all the source files in <code class="computeroutput"><span class="identifier">libs</span><span class="special">/</span><span class="identifier">regex</span><span class="special">/</span><span class="identifier">module</span></code>
+          (including regex.cxx) into a library, and place the result somewhere your
+          linker can find it.
+        </li>
+</ul></div>
+<p>
+      Visual studio users can simplify all of the above into one step, by placing
+      everything in <code class="computeroutput"><span class="identifier">libs</span><span class="special">/</span><span class="identifier">regex</span><span class="special">/</span><span class="identifier">module</span></code>
+      into a static library project, and then adding the <code class="computeroutput"><span class="special">/</span><span class="identifier">interface</span></code> command line option to the regex.cxx
+      source file.
+    </p>
+<p>
+      Known limitations:
+    </p>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
+<li class="listitem">
+          As of the start of 2025, only very recent versions of clang and msvc are
+          supported. GCC is definitely not supported.
+        </li>
+<li class="listitem">
+          The regex library must always be consumed via <code class="computeroutput"><span class="identifier">import</span>
+          <span class="identifier">boost</span><span class="special">.</span><span class="identifier">regex</span><span class="special">;</span></code>
+          and you can never mix this with <code class="computeroutput"><span class="preprocessor">#includes</span>
+          <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">regex</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>.
+        </li>
+<li class="listitem">
+          Ideally the standard library should always be used via <code class="computeroutput"><span class="identifier">import</span>
+          <span class="identifier">std</span></code> and not via #includes: more
+          recent compilers are mostly making this work, but are still very fragile.
+        </li>
+<li class="listitem">
+          The regex version imported, is always the "standalone" version
+          which includes no other Boost headers.
+        </li>
+</ul></div>
+<p>
+      Finally... there are some build and test scripts in <code class="computeroutput"><span class="identifier">libs</span><span class="special">/</span><span class="identifier">regex</span><span class="special">/</span><span class="identifier">test</span><span class="special">/</span><span class="identifier">module</span></code>
+      for msvc and clang.
+    </p>
+</div>
+<div class="copyright-footer">Copyright © 1998-2013 John Maddock<p>
+        Distributed under the Boost Software License, Version 1.0. (See accompanying
+        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
+      </p>
+</div>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="install.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="intro.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

doc/html/index.html

@@ -50,6 +50,7 @@
 <dt><span class="section"><a href="boost_regex/configuration/tuning.html">Algorithm Tuning</a></span></dt>
 </dl></dd>
 <dt><span class="section"><a href="boost_regex/install.html">Building and Installing the Library</a></span></dt>
+<dt><span class="section"><a href="boost_regex/modules.html">Module Support (Experimental)</a></span></dt>
 <dt><span class="section"><a href="boost_regex/intro.html">Introduction and Overview</a></span></dt>
 <dt><span class="section"><a href="boost_regex/unicode.html">Unicode and Boost.Regex</a></span></dt>
 <dt><span class="section"><a href="boost_regex/captures.html">Understanding Marked Sub-Expressions

doc/modules.qbk

@@ -0,0 +1,40 @@
+[/ 
+  Copyright 2024 John Maddock.
+  Distributed under the Boost Software License, Version 1.0.
+  (See accompanying file LICENSE_1_0.txt or copy at
+  http://www.boost.org/LICENSE_1_0.txt).
+]
+
+[section:modules Module Support (Experimental)]
+
+This library has experimental support for C++ modules (C++20 or later), currently the support is experimental
+not least because at the time of writing (2025) build tools have yet to catch up with module support.
+
+In order to use this library as a module you simply add a:
+
+```
+import boost.regex;
+```
+
+to your code.
+
+Before that you must first build the module, which consists of these steps:
+
+* Depending on your compiler, you may need to build the standard library module, and place the standard module somewhere that your compiler can find it.
+* Build `libs/regex/module/regex.cxx` into the boost.regex module, and place the module definition file somewhere that your compiler can find it.
+* Build all the source files in `libs/regex/module` (including regex.cxx) into a library, and place the result somewhere your linker can find it.
+
+Visual studio users can simplify all of the above into one step, by placing everything in `libs/regex/module` into a static library project, and then adding the `/interface`
+command line option to the regex.cxx source file.
+
+Known limitations:
+
+* As of the start of 2025, only very recent versions of clang and msvc are supported.  GCC is definitely not supported.
+* The regex library must always be consumed via `import boost.regex;` and you can never mix this with `#includes <boost/regex.hpp>`.
+* Ideally the standard library should always be used via `import std` and not via #includes: more recent compilers are mostly making this work, but are still very fragile.
+* The regex version imported, is always the "standalone" version which includes no other Boost headers.
+
+Finally... there are some build and test scripts in `libs/regex/test/module` for msvc and clang.
+
+[endsect]
+

doc/regex.qbk

@@ -51,6 +51,7 @@ PDF version of this manual is also available].
 
 [include configuration.qbk]
 [include install.qbk]
+[include modules.qbk]
 [include introduction.qbk]
 [include unicode.qbk]
 [include captures.qbk]

include/boost/regex/concepts.hpp

@@ -24,7 +24,7 @@
 #include <boost/type_traits/is_enum.hpp>
 #include <boost/type_traits/is_base_and_derived.hpp>
 #include <boost/static_assert.hpp>
-#ifndef BOOST_TEST_TR1_REGEX
+#if !defined(BOOST_TEST_TR1_REGEX) && !defined(BOOST_REGEX_TEST_MODULE)
 #include <boost/regex.hpp>
 #endif
 #include <bitset>
@@ -37,6 +37,16 @@
 #define RW_NS std
 #endif
 
+
+  //
+  // alter this to std::tr1, to test a std implementation:
+  //
+#ifndef BOOST_TEST_TR1_REGEX
+namespace global_regex_namespace = ::boost;
+#else
+namespace global_regex_namespace = ::std::tr1;
+#endif
+
 namespace boost{
 
 //
@@ -178,15 +188,6 @@ private:
    regex_traits_architype& operator=(const regex_traits_architype&){ return *this; }
 };
 
-//
-// alter this to std::tr1, to test a std implementation:
-//
-#ifndef BOOST_TEST_TR1_REGEX
-namespace global_regex_namespace = ::boost;
-#else
-namespace global_regex_namespace = ::std::tr1;
-#endif
-
 template <class Bitmask>
 struct BitmaskConcept
 {
@@ -273,7 +274,7 @@ template <class Regex>
 struct regex_traits_computer;
 
 template <class charT, class traits>
-struct regex_traits_computer< global_regex_namespace::basic_regex<charT, traits> >
+struct regex_traits_computer< ::boost::basic_regex<charT, traits> >
 {
    typedef traits type;
 };

include/boost/regex/config.hpp

@@ -29,6 +29,22 @@
 #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:
+ */
+#if defined(__BORLANDC__) && !defined(__clang__)
+#  include <boost/regex/config/borland.hpp>
+#endif
+
 #ifndef BOOST_REGEX_STANDALONE
 #include <boost/version.hpp>
 #endif
@@ -40,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
@@ -284,8 +304,6 @@
  * If there are no exceptions then we must report critical-errors
  * the only way we know how; by terminating.
  */
-#include <cassert>
-
 #  define BOOST_REGEX_NOEH_ASSERT(x) assert(x);
 #else
 /*

include/boost/regex/v5/basic_regex.hpp

@@ -25,10 +25,12 @@
 #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
@@ -67,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)
@@ -315,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
@@ -652,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;
 }
 
@@ -683,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)

include/boost/regex/v5/basic_regex_creator.hpp

@@ -30,8 +30,10 @@
 
 #include <boost/regex/v5/basic_regex.hpp>
 
+#ifndef BOOST_REGEX_AS_MODULE
 #include <vector>
 #include <set>
+#endif
 
 namespace boost{
 
@@ -220,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>*);

include/boost/regex/v5/basic_regex_parser.hpp

@@ -21,10 +21,12 @@
 
 #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{
@@ -896,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:
@@ -995,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;
       }
@@ -1112,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;
                }

include/boost/regex/v5/c_regex_traits.hpp

@@ -19,15 +19,17 @@
 #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 <boost/regex/v5/primary_transform.hpp>
 #include <boost/regex/v5/regex_traits_defaults.hpp>
 
-#include <cctype>
-#include <cstdint>
-#include <cwctype>
-
 namespace boost{
 
    namespace BOOST_REGEX_DETAIL_NS {
@@ -54,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(){}
@@ -102,7 +104,7 @@ private:
 };
 
 #ifndef BOOST_NO_WREGEX
-template<>
+BOOST_REGEX_MODULE_EXPORT template<>
 struct c_regex_traits<wchar_t>
 {
    c_regex_traits(){}

include/boost/regex/v5/cpp_regex_traits.hpp

@@ -20,22 +20,25 @@
 #define BOOST_CPP_REGEX_TRAITS_HPP_INCLUDED
 
 #include <boost/regex/config.hpp>
+
+#ifndef BOOST_REGEX_AS_MODULE
 #include <cstdint>
 #include <locale>
 #include <type_traits>
+#include <climits>
+#include <ios>
+#include <istream>
+#ifdef BOOST_HAS_THREADS
+#include <mutex>
+#endif
+#endif
 
 #include <boost/regex/pattern_except.hpp>
 #include <boost/regex/v5/regex_traits_defaults.hpp>
 
-#ifdef BOOST_HAS_THREADS
-#include <mutex>
-#endif
 #include <boost/regex/v5/primary_transform.hpp>
 #include <boost/regex/v5/object_cache.hpp>
 
-#include <climits>
-#include <ios>
-#include <istream>
 
 #ifdef BOOST_REGEX_MSVC
 #pragma warning(push)
@@ -47,7 +50,7 @@ namespace boost{
 //
 // forward declaration is needed by some compilers:
 //
-template <class charT>
+BOOST_REGEX_MODULE_EXPORT template <class charT>
 class cpp_regex_traits;
    
 namespace BOOST_REGEX_DETAIL_NS{
@@ -731,7 +734,7 @@ inline std::shared_ptr<const cpp_regex_traits_implementation<charT> > create_cpp
 
 } // BOOST_REGEX_DETAIL_NS
 
-template <class charT>
+BOOST_REGEX_MODULE_EXPORT template <class charT>
 class cpp_regex_traits
 {
 private:

include/boost/regex/v5/cregex.hpp

@@ -38,11 +38,13 @@
 #endif
 #endif
 
+#ifndef BOOST_REGEX_AS_MODULE
 #ifdef __cplusplus
 #include <cstddef>
 #else
 #include <stddef.h>
 #endif
+#endif
 
 /* include these defs only for POSIX compatablity */
 #ifdef __cplusplus

include/boost/regex/v5/error_type.hpp

@@ -26,7 +26,7 @@ namespace boost{
 #ifdef __cplusplus
 namespace regex_constants{
 
-enum error_type{
+BOOST_REGEX_MODULE_EXPORT enum error_type{
 
    error_ok = 0,         /* not used */
    error_no_match = 1,   /* not used */

include/boost/regex/v5/icu.hpp

@@ -19,11 +19,13 @@
 #ifndef BOOST_REGEX_ICU_V5_HPP
 #define BOOST_REGEX_ICU_V5_HPP
 
+#ifndef BOOST_REGEX_AS_MODULE
 #include <unicode/utypes.h>
 #include <unicode/uchar.h>
 #include <unicode/coll.h>
 #include <type_traits>
 #include <functional>
+#endif
 #include <boost/regex.hpp>
 #include <boost/regex/v5/unicode_iterator.hpp>
 
@@ -835,7 +837,7 @@ bool do_regex_match(BidiIterator first, BidiIterator last,
 }
 } // namespace BOOST_REGEX_DETAIL_NS
 
-template <class BidiIterator, class Allocator>
+BOOST_REGEX_MODULE_EXPORT template <class BidiIterator, class Allocator>
 inline bool u32regex_match(BidiIterator first, BidiIterator last, 
                  match_results<BidiIterator, Allocator>& m, 
                  const u32regex& e, 
@@ -843,7 +845,7 @@ inline bool u32regex_match(BidiIterator first, BidiIterator last,
 {
    return BOOST_REGEX_DETAIL_NS::do_regex_match(first, last, m, e, flags, static_cast<std::integral_constant<int, sizeof(*first)> const*>(0));
 }
-inline bool u32regex_match(const UChar* p, 
+BOOST_REGEX_MODULE_EXPORT inline bool u32regex_match(const UChar* p,
                  match_results<const UChar*>& m, 
                  const u32regex& e, 
                  match_flag_type flags = match_default)
@@ -851,7 +853,7 @@ inline bool u32regex_match(const UChar* p,
    return BOOST_REGEX_DETAIL_NS::do_regex_match(p, p+u_strlen(p), m, e, flags, static_cast<std::integral_constant<int, 2> const*>(0));
 }
 #if !BOOST_REGEX_UCHAR_IS_WCHAR_T && !defined(BOOST_NO_WREGEX)
-inline bool u32regex_match(const wchar_t* p, 
+BOOST_REGEX_MODULE_EXPORT inline bool u32regex_match(const wchar_t* p,
                  match_results<const wchar_t*>& m, 
                  const u32regex& e, 
                  match_flag_type flags = match_default)
@@ -859,21 +861,21 @@ inline bool u32regex_match(const wchar_t* p,
    return BOOST_REGEX_DETAIL_NS::do_regex_match(p, p+std::wcslen(p), m, e, flags, static_cast<std::integral_constant<int, sizeof(wchar_t)> const*>(0));
 }
 #endif
-inline bool u32regex_match(const char* p, 
+BOOST_REGEX_MODULE_EXPORT inline bool u32regex_match(const char* p,
                  match_results<const char*>& m, 
                  const u32regex& e, 
                  match_flag_type flags = match_default)
 {
    return BOOST_REGEX_DETAIL_NS::do_regex_match(p, p+std::strlen(p), m, e, flags, static_cast<std::integral_constant<int, 1> const*>(0));
 }
-inline bool u32regex_match(const unsigned char* p, 
+BOOST_REGEX_MODULE_EXPORT inline bool u32regex_match(const unsigned char* p,
                  match_results<const unsigned char*>& m, 
                  const u32regex& e, 
                  match_flag_type flags = match_default)
 {
    return BOOST_REGEX_DETAIL_NS::do_regex_match(p, p+std::strlen((const char*)p), m, e, flags, static_cast<std::integral_constant<int, 1> const*>(0));
 }
-inline bool u32regex_match(const std::string& s, 
+BOOST_REGEX_MODULE_EXPORT inline bool u32regex_match(const std::string& s,
                         match_results<std::string::const_iterator>& m, 
                         const u32regex& e, 
                         match_flag_type flags = match_default)
@@ -881,7 +883,7 @@ inline bool u32regex_match(const std::string& s,
    return BOOST_REGEX_DETAIL_NS::do_regex_match(s.begin(), s.end(), m, e, flags, static_cast<std::integral_constant<int, 1> const*>(0));
 }
 #ifndef BOOST_NO_STD_WSTRING
-inline bool u32regex_match(const std::wstring& s, 
+BOOST_REGEX_MODULE_EXPORT inline bool u32regex_match(const std::wstring& s,
                         match_results<std::wstring::const_iterator>& m, 
                         const u32regex& e, 
                         match_flag_type flags = match_default)
@@ -889,7 +891,7 @@ inline bool u32regex_match(const std::wstring& s,
    return BOOST_REGEX_DETAIL_NS::do_regex_match(s.begin(), s.end(), m, e, flags, static_cast<std::integral_constant<int, sizeof(wchar_t)> const*>(0));
 }
 #endif
-inline bool u32regex_match(const U_NAMESPACE_QUALIFIER UnicodeString& s, 
+BOOST_REGEX_MODULE_EXPORT inline bool u32regex_match(const U_NAMESPACE_QUALIFIER UnicodeString& s,
                         match_results<const UChar*>& m, 
                         const u32regex& e, 
                         match_flag_type flags = match_default)
@@ -899,7 +901,7 @@ inline bool u32regex_match(const U_NAMESPACE_QUALIFIER UnicodeString& s,
 //
 // regex_match overloads that do not return what matched:
 //
-template <class BidiIterator>
+BOOST_REGEX_MODULE_EXPORT template <class BidiIterator>
 inline bool u32regex_match(BidiIterator first, BidiIterator last, 
                  const u32regex& e, 
                  match_flag_type flags = match_default)
@@ -907,7 +909,7 @@ inline bool u32regex_match(BidiIterator first, BidiIterator last,
    match_results<BidiIterator> m;
    return BOOST_REGEX_DETAIL_NS::do_regex_match(first, last, m, e, flags, static_cast<std::integral_constant<int, sizeof(*first)> const*>(0));
 }
-inline bool u32regex_match(const UChar* p, 
+BOOST_REGEX_MODULE_EXPORT inline bool u32regex_match(const UChar* p,
                  const u32regex& e, 
                  match_flag_type flags = match_default)
 {
@@ -915,7 +917,7 @@ inline bool u32regex_match(const UChar* p,
    return BOOST_REGEX_DETAIL_NS::do_regex_match(p, p+u_strlen(p), m, e, flags, static_cast<std::integral_constant<int, 2> const*>(0));
 }
 #if !BOOST_REGEX_UCHAR_IS_WCHAR_T && !defined(BOOST_NO_WREGEX)
-inline bool u32regex_match(const wchar_t* p, 
+BOOST_REGEX_MODULE_EXPORT inline bool u32regex_match(const wchar_t* p,
                  const u32regex& e, 
                  match_flag_type flags = match_default)
 {
@@ -923,21 +925,21 @@ inline bool u32regex_match(const wchar_t* p,
    return BOOST_REGEX_DETAIL_NS::do_regex_match(p, p+std::wcslen(p), m, e, flags, static_cast<std::integral_constant<int, sizeof(wchar_t)> const*>(0));
 }
 #endif
-inline bool u32regex_match(const char* p, 
+BOOST_REGEX_MODULE_EXPORT inline bool u32regex_match(const char* p,
                  const u32regex& e, 
                  match_flag_type flags = match_default)
 {
    match_results<const char*> m;
    return BOOST_REGEX_DETAIL_NS::do_regex_match(p, p+std::strlen(p), m, e, flags, static_cast<std::integral_constant<int, 1> const*>(0));
 }
-inline bool u32regex_match(const unsigned char* p, 
+BOOST_REGEX_MODULE_EXPORT inline bool u32regex_match(const unsigned char* p,
                  const u32regex& e, 
                  match_flag_type flags = match_default)
 {
    match_results<const unsigned char*> m;
    return BOOST_REGEX_DETAIL_NS::do_regex_match(p, p+std::strlen((const char*)p), m, e, flags, static_cast<std::integral_constant<int, 1> const*>(0));
 }
-inline bool u32regex_match(const std::string& s, 
+BOOST_REGEX_MODULE_EXPORT inline bool u32regex_match(const std::string& s,
                         const u32regex& e, 
                         match_flag_type flags = match_default)
 {
@@ -945,7 +947,7 @@ inline bool u32regex_match(const std::string& s,
    return BOOST_REGEX_DETAIL_NS::do_regex_match(s.begin(), s.end(), m, e, flags, static_cast<std::integral_constant<int, 1> const*>(0));
 }
 #ifndef BOOST_NO_STD_WSTRING
-inline bool u32regex_match(const std::wstring& s, 
+BOOST_REGEX_MODULE_EXPORT inline bool u32regex_match(const std::wstring& s,
                         const u32regex& e, 
                         match_flag_type flags = match_default)
 {
@@ -953,7 +955,7 @@ inline bool u32regex_match(const std::wstring& s,
    return BOOST_REGEX_DETAIL_NS::do_regex_match(s.begin(), s.end(), m, e, flags, static_cast<std::integral_constant<int, sizeof(wchar_t)> const*>(0));
 }
 #endif
-inline bool u32regex_match(const U_NAMESPACE_QUALIFIER UnicodeString& s, 
+BOOST_REGEX_MODULE_EXPORT inline bool u32regex_match(const U_NAMESPACE_QUALIFIER UnicodeString& s,
                         const u32regex& e, 
                         match_flag_type flags = match_default)
 {
@@ -1011,7 +1013,7 @@ bool do_regex_search(BidiIterator first, BidiIterator last,
 }
 }
 
-template <class BidiIterator, class Allocator>
+BOOST_REGEX_MODULE_EXPORT template <class BidiIterator, class Allocator>
 inline bool u32regex_search(BidiIterator first, BidiIterator last, 
                  match_results<BidiIterator, Allocator>& m, 
                  const u32regex& e, 
@@ -1019,7 +1021,7 @@ inline bool u32regex_search(BidiIterator first, BidiIterator last,
 {
    return BOOST_REGEX_DETAIL_NS::do_regex_search(first, last, m, e, flags, first, static_cast<std::integral_constant<int, sizeof(*first)> const*>(0));
 }
-template <class BidiIterator, class Allocator>
+BOOST_REGEX_MODULE_EXPORT template <class BidiIterator, class Allocator>
 inline bool u32regex_search(BidiIterator first, BidiIterator last, 
                  match_results<BidiIterator, Allocator>& m, 
                  const u32regex& e, 
@@ -1028,7 +1030,7 @@ inline bool u32regex_search(BidiIterator first, BidiIterator last,
 {
    return BOOST_REGEX_DETAIL_NS::do_regex_search(first, last, m, e, flags, base, static_cast<std::integral_constant<int, sizeof(*first)> const*>(0));
 }
-inline bool u32regex_search(const UChar* p, 
+BOOST_REGEX_MODULE_EXPORT inline bool u32regex_search(const UChar* p,
                  match_results<const UChar*>& m, 
                  const u32regex& e, 
                  match_flag_type flags = match_default)
@@ -1036,7 +1038,7 @@ inline bool u32regex_search(const UChar* p,
    return BOOST_REGEX_DETAIL_NS::do_regex_search(p, p+u_strlen(p), m, e, flags, p, static_cast<std::integral_constant<int, 2> const*>(0));
 }
 #if !BOOST_REGEX_UCHAR_IS_WCHAR_T && !defined(BOOST_NO_WREGEX)
-inline bool u32regex_search(const wchar_t* p, 
+BOOST_REGEX_MODULE_EXPORT inline bool u32regex_search(const wchar_t* p,
                  match_results<const wchar_t*>& m, 
                  const u32regex& e, 
                  match_flag_type flags = match_default)
@@ -1044,21 +1046,21 @@ inline bool u32regex_search(const wchar_t* p,
    return BOOST_REGEX_DETAIL_NS::do_regex_search(p, p+std::wcslen(p), m, e, flags, p, static_cast<std::integral_constant<int, sizeof(wchar_t)> const*>(0));
 }
 #endif
-inline bool u32regex_search(const char* p, 
+BOOST_REGEX_MODULE_EXPORT inline bool u32regex_search(const char* p,
                  match_results<const char*>& m, 
                  const u32regex& e, 
                  match_flag_type flags = match_default)
 {
    return BOOST_REGEX_DETAIL_NS::do_regex_search(p, p+std::strlen(p), m, e, flags, p, static_cast<std::integral_constant<int, 1> const*>(0));
 }
-inline bool u32regex_search(const unsigned char* p, 
+BOOST_REGEX_MODULE_EXPORT inline bool u32regex_search(const unsigned char* p,
                  match_results<const unsigned char*>& m, 
                  const u32regex& e, 
                  match_flag_type flags = match_default)
 {
    return BOOST_REGEX_DETAIL_NS::do_regex_search(p, p+std::strlen((const char*)p), m, e, flags, p, static_cast<std::integral_constant<int, 1> const*>(0));
 }
-inline bool u32regex_search(const std::string& s, 
+BOOST_REGEX_MODULE_EXPORT inline bool u32regex_search(const std::string& s,
                         match_results<std::string::const_iterator>& m, 
                         const u32regex& e, 
                         match_flag_type flags = match_default)
@@ -1066,7 +1068,7 @@ inline bool u32regex_search(const std::string& s,
    return BOOST_REGEX_DETAIL_NS::do_regex_search(s.begin(), s.end(), m, e, flags, s.begin(), static_cast<std::integral_constant<int, 1> const*>(0));
 }
 #ifndef BOOST_NO_STD_WSTRING
-inline bool u32regex_search(const std::wstring& s, 
+BOOST_REGEX_MODULE_EXPORT inline bool u32regex_search(const std::wstring& s,
                         match_results<std::wstring::const_iterator>& m, 
                         const u32regex& e, 
                         match_flag_type flags = match_default)
@@ -1074,14 +1076,14 @@ inline bool u32regex_search(const std::wstring& s,
    return BOOST_REGEX_DETAIL_NS::do_regex_search(s.begin(), s.end(), m, e, flags, s.begin(), static_cast<std::integral_constant<int, sizeof(wchar_t)> const*>(0));
 }
 #endif
-inline bool u32regex_search(const U_NAMESPACE_QUALIFIER UnicodeString& s, 
+BOOST_REGEX_MODULE_EXPORT inline bool u32regex_search(const U_NAMESPACE_QUALIFIER UnicodeString& s,
                         match_results<const UChar*>& m, 
                         const u32regex& e, 
                         match_flag_type flags = match_default)
 {
    return BOOST_REGEX_DETAIL_NS::do_regex_search(s.getBuffer(), s.getBuffer() + s.length(), m, e, flags, s.getBuffer(), static_cast<std::integral_constant<int, 2> const*>(0));
 }
-template <class BidiIterator>
+BOOST_REGEX_MODULE_EXPORT template <class BidiIterator>
 inline bool u32regex_search(BidiIterator first, BidiIterator last, 
                  const u32regex& e, 
                  match_flag_type flags = match_default)
@@ -1089,7 +1091,7 @@ inline bool u32regex_search(BidiIterator first, BidiIterator last,
    match_results<BidiIterator> m;
    return BOOST_REGEX_DETAIL_NS::do_regex_search(first, last, m, e, flags, first, static_cast<std::integral_constant<int, sizeof(*first)> const*>(0));
 }
-inline bool u32regex_search(const UChar* p, 
+BOOST_REGEX_MODULE_EXPORT inline bool u32regex_search(const UChar* p,
                  const u32regex& e, 
                  match_flag_type flags = match_default)
 {
@@ -1097,7 +1099,7 @@ inline bool u32regex_search(const UChar* p,
    return BOOST_REGEX_DETAIL_NS::do_regex_search(p, p+u_strlen(p), m, e, flags, p, static_cast<std::integral_constant<int, 2> const*>(0));
 }
 #if !BOOST_REGEX_UCHAR_IS_WCHAR_T && !defined(BOOST_NO_WREGEX)
-inline bool u32regex_search(const wchar_t* p, 
+BOOST_REGEX_MODULE_EXPORT inline bool u32regex_search(const wchar_t* p,
                  const u32regex& e, 
                  match_flag_type flags = match_default)
 {
@@ -1105,21 +1107,21 @@ inline bool u32regex_search(const wchar_t* p,
    return BOOST_REGEX_DETAIL_NS::do_regex_search(p, p+std::wcslen(p), m, e, flags, p, static_cast<std::integral_constant<int, sizeof(wchar_t)> const*>(0));
 }
 #endif
-inline bool u32regex_search(const char* p, 
+BOOST_REGEX_MODULE_EXPORT inline bool u32regex_search(const char* p,
                  const u32regex& e, 
                  match_flag_type flags = match_default)
 {
    match_results<const char*> m;
    return BOOST_REGEX_DETAIL_NS::do_regex_search(p, p+std::strlen(p), m, e, flags, p, static_cast<std::integral_constant<int, 1> const*>(0));
 }
-inline bool u32regex_search(const unsigned char* p, 
+BOOST_REGEX_MODULE_EXPORT inline bool u32regex_search(const unsigned char* p,
                  const u32regex& e, 
                  match_flag_type flags = match_default)
 {
    match_results<const unsigned char*> m;
    return BOOST_REGEX_DETAIL_NS::do_regex_search(p, p+std::strlen((const char*)p), m, e, flags, p, static_cast<std::integral_constant<int, 1> const*>(0));
 }
-inline bool u32regex_search(const std::string& s, 
+BOOST_REGEX_MODULE_EXPORT inline bool u32regex_search(const std::string& s,
                         const u32regex& e, 
                         match_flag_type flags = match_default)
 {
@@ -1127,7 +1129,7 @@ inline bool u32regex_search(const std::string& s,
    return BOOST_REGEX_DETAIL_NS::do_regex_search(s.begin(), s.end(), m, e, flags, s.begin(), static_cast<std::integral_constant<int, 1> const*>(0));
 }
 #ifndef BOOST_NO_STD_WSTRING
-inline bool u32regex_search(const std::wstring& s, 
+BOOST_REGEX_MODULE_EXPORT inline bool u32regex_search(const std::wstring& s,
                         const u32regex& e, 
                         match_flag_type flags = match_default)
 {
@@ -1135,7 +1137,7 @@ inline bool u32regex_search(const std::wstring& s,
    return BOOST_REGEX_DETAIL_NS::do_regex_search(s.begin(), s.end(), m, e, flags, s.begin(), static_cast<std::integral_constant<int, sizeof(wchar_t)> const*>(0));
 }
 #endif
-inline bool u32regex_search(const U_NAMESPACE_QUALIFIER UnicodeString& s, 
+BOOST_REGEX_MODULE_EXPORT inline bool u32regex_search(const U_NAMESPACE_QUALIFIER UnicodeString& s,
                         const u32regex& e, 
                         match_flag_type flags = match_default)
 {
@@ -1258,7 +1260,7 @@ inline BaseIterator extract_output_base(const utf16_output_iterator<BaseIterator
 }
 }  // BOOST_REGEX_DETAIL_NS
 
-template <class OutputIterator, class BidirectionalIterator, class charT>
+BOOST_REGEX_MODULE_EXPORT template <class OutputIterator, class BidirectionalIterator, class charT>
 inline OutputIterator u32regex_replace(OutputIterator out,
                          BidirectionalIterator first,
                          BidirectionalIterator last,
@@ -1277,7 +1279,7 @@ inline OutputIterator u32regex_replace(OutputIterator out,
       );
 }
 
-template <class OutputIterator, class Iterator, class charT>
+BOOST_REGEX_MODULE_EXPORT template <class OutputIterator, class Iterator, class charT>
 inline OutputIterator u32regex_replace(OutputIterator out,
                          Iterator first,
                          Iterator last,
@@ -1296,7 +1298,7 @@ inline OutputIterator u32regex_replace(OutputIterator out,
       );
 }
 
-template <class OutputIterator, class Iterator>
+BOOST_REGEX_MODULE_EXPORT template <class OutputIterator, class Iterator>
 inline OutputIterator u32regex_replace(OutputIterator out,
                          Iterator first,
                          Iterator last,
@@ -1315,7 +1317,7 @@ inline OutputIterator u32regex_replace(OutputIterator out,
       );
 }
 
-template <class charT>
+BOOST_REGEX_MODULE_EXPORT template <class charT>
 std::basic_string<charT> u32regex_replace(const std::basic_string<charT>& s,
                          const u32regex& e, 
                          const charT* fmt,
@@ -1327,7 +1329,7 @@ std::basic_string<charT> u32regex_replace(const std::basic_string<charT>& s,
    return result;
 }
 
-template <class charT>
+BOOST_REGEX_MODULE_EXPORT template <class charT>
 std::basic_string<charT> u32regex_replace(const std::basic_string<charT>& s,
                          const u32regex& e, 
                          const std::basic_string<charT>& fmt,

include/boost/regex/v5/iterator_category.hpp

@@ -21,8 +21,10 @@
 #ifndef BOOST_REGEX_ITERATOR_CATEGORY_HPP
 #define BOOST_REGEX_ITERATOR_CATEGORY_HPP
 
+#ifndef BOOST_REGEX_AS_MODULE
 #include <iterator>
 #include <type_traits>
+#endif
 
 namespace boost{
 namespace detail{

include/boost/regex/v5/iterator_traits.hpp

@@ -19,7 +19,9 @@
 #ifndef BOOST_REGEX_V5_ITERATOR_TRAITS_HPP
 #define BOOST_REGEX_V5_ITERATOR_TRAITS_HPP
 
+#ifndef BOOST_REGEX_AS_MODULE
 #include <iterator>
+#endif
 
 namespace boost{
 namespace BOOST_REGEX_DETAIL_NS{

include/boost/regex/v5/match_flags.hpp

@@ -19,9 +19,11 @@
 #ifndef BOOST_REGEX_V5_MATCH_FLAGS
 #define BOOST_REGEX_V5_MATCH_FLAGS
 
+#ifndef BOOST_REGEX_AS_MODULE
 #ifdef __cplusplus
 #  include <cstdint>
 #endif
+#endif
 
 #ifdef __cplusplus
 namespace boost{
@@ -35,7 +37,7 @@ namespace boost{
 #endif
 #endif
 
-typedef enum _match_flags
+BOOST_REGEX_MODULE_EXPORT typedef enum _match_flags
 {
    match_default = 0,
    match_not_bol = 1,                                /* first is not start of line */
@@ -89,22 +91,22 @@ typedef enum _match_flags
 
 } match_flags;
 
-typedef match_flags match_flag_type;
+BOOST_REGEX_MODULE_EXPORT typedef match_flags match_flag_type;
 
 #ifdef __cplusplus
-inline match_flags operator&(match_flags m1, match_flags m2)
+BOOST_REGEX_MODULE_EXPORT inline match_flags operator&(match_flags m1, match_flags m2)
 { return static_cast<match_flags>(static_cast<std::int32_t>(m1) & static_cast<std::int32_t>(m2)); }
-inline match_flags operator|(match_flags m1, match_flags m2)
+BOOST_REGEX_MODULE_EXPORT inline match_flags operator|(match_flags m1, match_flags m2)
 { return static_cast<match_flags>(static_cast<std::int32_t>(m1) | static_cast<std::int32_t>(m2)); }
-inline match_flags operator^(match_flags m1, match_flags m2)
+BOOST_REGEX_MODULE_EXPORT inline match_flags operator^(match_flags m1, match_flags m2)
 { return static_cast<match_flags>(static_cast<std::int32_t>(m1) ^ static_cast<std::int32_t>(m2)); }
-inline match_flags operator~(match_flags m1)
-{ return static_cast<match_flags>(~static_cast<std::int32_t>(m1)); }
-inline match_flags& operator&=(match_flags& m1, match_flags m2)
+BOOST_REGEX_MODULE_EXPORT inline match_flags operator~(match_flags m1)
+{ return static_cast<match_flags>(~static_cast<std::int32_t>(m1) & static_cast<std::int32_t>(match_not_any)); }
+BOOST_REGEX_MODULE_EXPORT inline match_flags& operator&=(match_flags& m1, match_flags m2)
 { m1 = m1&m2; return m1; }
-inline match_flags& operator|=(match_flags& m1, match_flags m2)
+BOOST_REGEX_MODULE_EXPORT inline match_flags& operator|=(match_flags& m1, match_flags m2)
 { m1 = m1|m2; return m1; }
-inline match_flags& operator^=(match_flags& m1, match_flags m2)
+BOOST_REGEX_MODULE_EXPORT inline match_flags& operator^=(match_flags& m1, match_flags m2)
 { m1 = m1^m2; return m1; }
 #endif
 
@@ -113,36 +115,36 @@ inline match_flags& operator^=(match_flags& m1, match_flags m2)
 /*
  * import names into boost for backwards compatibility:
  */
-using regex_constants::match_flag_type;
-using regex_constants::match_default;
-using regex_constants::match_not_bol;
-using regex_constants::match_not_eol;
-using regex_constants::match_not_bob;
-using regex_constants::match_not_eob;
-using regex_constants::match_not_bow;
-using regex_constants::match_not_eow;
-using regex_constants::match_not_dot_newline;
-using regex_constants::match_not_dot_null;
-using regex_constants::match_prev_avail;
+BOOST_REGEX_MODULE_EXPORT using regex_constants::match_flag_type;
+BOOST_REGEX_MODULE_EXPORT using regex_constants::match_default;
+BOOST_REGEX_MODULE_EXPORT using regex_constants::match_not_bol;
+BOOST_REGEX_MODULE_EXPORT using regex_constants::match_not_eol;
+BOOST_REGEX_MODULE_EXPORT using regex_constants::match_not_bob;
+BOOST_REGEX_MODULE_EXPORT using regex_constants::match_not_eob;
+BOOST_REGEX_MODULE_EXPORT using regex_constants::match_not_bow;
+BOOST_REGEX_MODULE_EXPORT using regex_constants::match_not_eow;
+BOOST_REGEX_MODULE_EXPORT using regex_constants::match_not_dot_newline;
+BOOST_REGEX_MODULE_EXPORT using regex_constants::match_not_dot_null;
+BOOST_REGEX_MODULE_EXPORT using regex_constants::match_prev_avail;
 /* using regex_constants::match_init; */
-using regex_constants::match_any;
-using regex_constants::match_not_null;
-using regex_constants::match_continuous;
-using regex_constants::match_partial;
+BOOST_REGEX_MODULE_EXPORT using regex_constants::match_any;
+BOOST_REGEX_MODULE_EXPORT using regex_constants::match_not_null;
+BOOST_REGEX_MODULE_EXPORT using regex_constants::match_continuous;
+BOOST_REGEX_MODULE_EXPORT using regex_constants::match_partial;
 /*using regex_constants::match_stop; */
-using regex_constants::match_all;
-using regex_constants::match_perl;
-using regex_constants::match_posix;
-using regex_constants::match_nosubs;
-using regex_constants::match_extra;
-using regex_constants::match_single_line;
+BOOST_REGEX_MODULE_EXPORT using regex_constants::match_all;
+BOOST_REGEX_MODULE_EXPORT using regex_constants::match_perl;
+BOOST_REGEX_MODULE_EXPORT using regex_constants::match_posix;
+BOOST_REGEX_MODULE_EXPORT using regex_constants::match_nosubs;
+BOOST_REGEX_MODULE_EXPORT using regex_constants::match_extra;
+BOOST_REGEX_MODULE_EXPORT using regex_constants::match_single_line;
 /*using regex_constants::match_max; */
-using regex_constants::format_all;
-using regex_constants::format_sed;
-using regex_constants::format_perl;
-using regex_constants::format_default;
-using regex_constants::format_no_copy;
-using regex_constants::format_first_only;
+BOOST_REGEX_MODULE_EXPORT using regex_constants::format_all;
+BOOST_REGEX_MODULE_EXPORT using regex_constants::format_sed;
+BOOST_REGEX_MODULE_EXPORT using regex_constants::format_perl;
+BOOST_REGEX_MODULE_EXPORT using regex_constants::format_default;
+BOOST_REGEX_MODULE_EXPORT using regex_constants::format_no_copy;
+BOOST_REGEX_MODULE_EXPORT using regex_constants::format_first_only;
 /*using regex_constants::format_is_if;*/
 
 #ifdef BOOST_REGEX_MSVC

include/boost/regex/v5/match_results.hpp

@@ -24,8 +24,10 @@
 #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
@@ -45,7 +47,7 @@ class named_subexpressions;
 
 }
 
-template <class BidiIterator, class Allocator>
+BOOST_REGEX_MODULE_EXPORT template <class BidiIterator, class Allocator>
 class match_results
 { 
 private:
@@ -225,6 +227,10 @@ public:
    {
       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))
       {
@@ -674,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)

include/boost/regex/v5/mem_block_cache.hpp

@@ -19,7 +19,7 @@
 #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>
@@ -32,6 +32,7 @@
     #define BOOST_REGEX_ATOMIC_POINTER std::atomic
   #endif
 #endif
+#endif
 
 
 namespace boost{

include/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{
 

include/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)
@@ -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{
 

include/boost/regex/v5/perl_matcher.hpp

@@ -19,11 +19,13 @@
 #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)
@@ -578,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

include/boost/regex/v5/perl_matcher_non_recursive.hpp

@@ -237,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;

include/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
 

include/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

include/boost/regex/v5/regex_format.hpp

@@ -24,16 +24,17 @@
 #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{
@@ -1099,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,
@@ -1109,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)

include/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

include/boost/regex/v5/regex_grep.hpp

@@ -30,7 +30,7 @@ namespace boost{
 // regex_grep:
 // find all non-overlapping matches within the sequence first last:
 //
-template <class Predicate, class BidiIterator, class charT, class traits>
+BOOST_REGEX_MODULE_EXPORT template <class Predicate, class BidiIterator, class charT, class traits>
 inline unsigned int regex_grep(Predicate foo, 
                                BidiIterator first, 
                                BidiIterator last, 
@@ -45,7 +45,7 @@ inline unsigned int regex_grep(Predicate foo,
    match_results<BidiIterator> m;
    BOOST_REGEX_DETAIL_NS::perl_matcher<BidiIterator, match_allocator_type, traits> matcher(first, last, m, e, flags, first);
    unsigned int count = 0;
-   while(matcher.find())
+   while(BOOST_REGEX_DETAIL_NS::factory_find(matcher))
    {
       ++count;
       if(0 == foo(m))
@@ -60,7 +60,7 @@ inline unsigned int regex_grep(Predicate foo,
          // a non-NULL one at the same position:
          match_results<BidiIterator, match_allocator_type> m2(m);
          matcher.setf(match_not_null | match_continuous);
-         if(matcher.find())
+         if(BOOST_REGEX_DETAIL_NS::factory_find(matcher))
          {
             ++count;
             if(0 == foo(m))
@@ -80,7 +80,7 @@ inline unsigned int regex_grep(Predicate foo,
 //
 // regex_grep convenience interfaces:
 //
-template <class Predicate, class charT, class traits>
+BOOST_REGEX_MODULE_EXPORT template <class Predicate, class charT, class traits>
 inline unsigned int regex_grep(Predicate foo, const charT* str, 
                         const basic_regex<charT, traits>& e, 
                         match_flag_type flags = match_default)
@@ -88,7 +88,7 @@ inline unsigned int regex_grep(Predicate foo, const charT* str,
    return regex_grep(foo, str, str + traits::length(str), e, flags);
 }
 
-template <class Predicate, class ST, class SA, class charT, class traits>
+BOOST_REGEX_MODULE_EXPORT template <class Predicate, class ST, class SA, class charT, class traits>
 inline unsigned int regex_grep(Predicate foo, const std::basic_string<charT, ST, SA>& s, 
                  const basic_regex<charT, traits>& e, 
                  match_flag_type flags = match_default)

include/boost/regex/v5/regex_iterator.hpp

@@ -21,8 +21,9 @@
 
 #include <boost/regex/v5/basic_regex.hpp>
 #include <boost/regex/v5/match_results.hpp>
-
+#ifndef BOOST_REGEX_AS_MODULE
 #include <memory>
+#endif
 
 namespace boost{
 
@@ -75,7 +76,7 @@ private:
    regex_iterator_implementation& operator=(const regex_iterator_implementation&);
 };
 
-template <class BidirectionalIterator, 
+BOOST_REGEX_MODULE_EXPORT template <class BidirectionalIterator,
           class charT = typename std::iterator_traits<BidirectionalIterator>::value_type,
           class traits = regex_traits<charT> >
 class regex_iterator 
@@ -151,20 +152,20 @@ private:
    }
 };
 
-typedef regex_iterator<const char*> cregex_iterator;
-typedef regex_iterator<std::string::const_iterator> sregex_iterator;
+BOOST_REGEX_MODULE_EXPORT typedef regex_iterator<const char*> cregex_iterator;
+BOOST_REGEX_MODULE_EXPORT typedef regex_iterator<std::string::const_iterator> sregex_iterator;
 #ifndef BOOST_NO_WREGEX
-typedef regex_iterator<const wchar_t*> wcregex_iterator;
-typedef regex_iterator<std::wstring::const_iterator> wsregex_iterator;
+BOOST_REGEX_MODULE_EXPORT typedef regex_iterator<const wchar_t*> wcregex_iterator;
+BOOST_REGEX_MODULE_EXPORT typedef regex_iterator<std::wstring::const_iterator> wsregex_iterator;
 #endif
 
 // make_regex_iterator:
-template <class charT, class traits>
+BOOST_REGEX_MODULE_EXPORT template <class charT, class traits>
 inline regex_iterator<const charT*, charT, traits> make_regex_iterator(const charT* p, const basic_regex<charT, traits>& e, regex_constants::match_flag_type m = regex_constants::match_default)
 {
    return regex_iterator<const charT*, charT, traits>(p, p+traits::length(p), e, m);
 }
-template <class charT, class traits, class ST, class SA>
+BOOST_REGEX_MODULE_EXPORT template <class charT, class traits, class ST, class SA>
 inline regex_iterator<typename std::basic_string<charT, ST, SA>::const_iterator, charT, traits> make_regex_iterator(const std::basic_string<charT, ST, SA>& p, const basic_regex<charT, traits>& e, regex_constants::match_flag_type m = regex_constants::match_default)
 {
    return regex_iterator<typename std::basic_string<charT, ST, SA>::const_iterator, charT, traits>(p.begin(), p.end(), e, m);

include/boost/regex/v5/regex_match.hpp

@@ -32,16 +32,16 @@ namespace boost{
 // returns true if the specified regular expression matches
 // the whole of the input.  Fills in what matched in m.
 //
-template <class BidiIterator, class Allocator, class charT, class traits>
+BOOST_REGEX_MODULE_EXPORT template <class BidiIterator, class Allocator, class charT, class traits>
 bool regex_match(BidiIterator first, BidiIterator last, 
                  match_results<BidiIterator, Allocator>& m, 
                  const basic_regex<charT, traits>& e, 
                  match_flag_type flags = match_default)
 {
    BOOST_REGEX_DETAIL_NS::perl_matcher<BidiIterator, Allocator, traits> matcher(first, last, m, e, flags, first);
-   return matcher.match();
+   return BOOST_REGEX_DETAIL_NS::factory_match(matcher);
 }
-template <class iterator, class charT, class traits>
+BOOST_REGEX_MODULE_EXPORT template <class iterator, class charT, class traits>
 bool regex_match(iterator first, iterator last, 
                  const basic_regex<charT, traits>& e, 
                  match_flag_type flags = match_default)
@@ -52,7 +52,7 @@ bool regex_match(iterator first, iterator last,
 //
 // query_match convenience interfaces:
 //
-template <class charT, class Allocator, class traits>
+BOOST_REGEX_MODULE_EXPORT template <class charT, class Allocator, class traits>
 inline bool regex_match(const charT* str, 
                         match_results<const charT*, Allocator>& m, 
                         const basic_regex<charT, traits>& e, 
@@ -61,7 +61,7 @@ inline bool regex_match(const charT* str,
    return regex_match(str, str + traits::length(str), m, e, flags);
 }
 
-template <class ST, class SA, class Allocator, class charT, class traits>
+BOOST_REGEX_MODULE_EXPORT template <class ST, class SA, class Allocator, class charT, class traits>
 inline bool regex_match(const std::basic_string<charT, ST, SA>& s, 
                  match_results<typename std::basic_string<charT, ST, SA>::const_iterator, Allocator>& m, 
                  const basic_regex<charT, traits>& e, 
@@ -69,7 +69,7 @@ inline bool regex_match(const std::basic_string<charT, ST, SA>& s,
 {
    return regex_match(s.begin(), s.end(), m, e, flags);
 }
-template <class charT, class traits>
+BOOST_REGEX_MODULE_EXPORT template <class charT, class traits>
 inline bool regex_match(const charT* str, 
                         const basic_regex<charT, traits>& e, 
                         match_flag_type flags = match_default)
@@ -78,7 +78,7 @@ inline bool regex_match(const charT* str,
    return regex_match(str, str + traits::length(str), m, e, flags | regex_constants::match_any);
 }
 
-template <class ST, class SA, class charT, class traits>
+BOOST_REGEX_MODULE_EXPORT template <class ST, class SA, class charT, class traits>
 inline bool regex_match(const std::basic_string<charT, ST, SA>& s, 
                  const basic_regex<charT, traits>& e, 
                  match_flag_type flags = match_default)

include/boost/regex/v5/regex_merge.hpp

@@ -24,7 +24,7 @@
 
 namespace boost{
 
-template <class OutputIterator, class Iterator, class traits, class charT>
+BOOST_REGEX_MODULE_EXPORT template <class OutputIterator, class Iterator, class traits, class charT>
 inline OutputIterator regex_merge(OutputIterator out,
                          Iterator first,
                          Iterator last,
@@ -35,7 +35,7 @@ inline OutputIterator regex_merge(OutputIterator out,
    return regex_replace(out, first, last, e, fmt, flags);
 }
 
-template <class OutputIterator, class Iterator, class traits, class charT>
+BOOST_REGEX_MODULE_EXPORT template <class OutputIterator, class Iterator, class traits, class charT>
 inline OutputIterator regex_merge(OutputIterator out,
                          Iterator first,
                          Iterator last,
@@ -46,7 +46,7 @@ inline OutputIterator regex_merge(OutputIterator out,
    return regex_merge(out, first, last, e, fmt.c_str(), flags);
 }
 
-template <class traits, class charT>
+BOOST_REGEX_MODULE_EXPORT template <class traits, class charT>
 inline std::basic_string<charT> regex_merge(const std::basic_string<charT>& s,
                          const basic_regex<charT, traits>& e, 
                          const charT* fmt,
@@ -55,7 +55,7 @@ inline std::basic_string<charT> regex_merge(const std::basic_string<charT>& s,
    return regex_replace(s, e, fmt, flags);
 }
 
-template <class traits, class charT>
+BOOST_REGEX_MODULE_EXPORT template <class traits, class charT>
 inline std::basic_string<charT> regex_merge(const std::basic_string<charT>& s,
                          const basic_regex<charT, traits>& e, 
                          const std::basic_string<charT>& fmt,

include/boost/regex/v5/regex_raw_buffer.hpp

@@ -25,9 +25,11 @@
 #include <boost/regex/config.hpp>
 #endif
 
+#ifndef BOOST_REGEX_AS_MODULE
 #include <algorithm>
 #include <cstddef>
 #include <cstring>
+#endif
 
 namespace boost{
    namespace BOOST_REGEX_DETAIL_NS{

include/boost/regex/v5/regex_replace.hpp

@@ -28,7 +28,7 @@
 
 namespace boost{
 
-template <class OutputIterator, class BidirectionalIterator, class traits, class charT, class Formatter>
+BOOST_REGEX_MODULE_EXPORT template <class OutputIterator, class BidirectionalIterator, class traits, class charT, class Formatter>
 OutputIterator regex_replace(OutputIterator out,
                          BidirectionalIterator first,
                          BidirectionalIterator last,
@@ -62,7 +62,7 @@ OutputIterator regex_replace(OutputIterator out,
    return out;
 }
 
-template <class traits, class charT, class Formatter>
+BOOST_REGEX_MODULE_EXPORT template <class traits, class charT, class Formatter>
 std::basic_string<charT> regex_replace(const std::basic_string<charT>& s,
                          const basic_regex<charT, traits>& e, 
                          Formatter fmt,

include/boost/regex/v5/regex_search.hpp

@@ -25,7 +25,7 @@
 
 namespace boost{
 
-template <class BidiIterator, class Allocator, class charT, class traits>
+BOOST_REGEX_MODULE_EXPORT template <class BidiIterator, class Allocator, class charT, class traits>
 bool regex_search(BidiIterator first, BidiIterator last, 
                   match_results<BidiIterator, Allocator>& m, 
                   const basic_regex<charT, traits>& e, 
@@ -34,7 +34,7 @@ bool regex_search(BidiIterator first, BidiIterator last,
    return regex_search(first, last, m, e, flags, first);
 }
 
-template <class BidiIterator, class Allocator, class charT, class traits>
+BOOST_REGEX_MODULE_EXPORT template <class BidiIterator, class Allocator, class charT, class traits>
 bool regex_search(BidiIterator first, BidiIterator last, 
                   match_results<BidiIterator, Allocator>& m, 
                   const basic_regex<charT, traits>& e, 
@@ -45,13 +45,13 @@ bool regex_search(BidiIterator first, BidiIterator last,
       return false;
 
    BOOST_REGEX_DETAIL_NS::perl_matcher<BidiIterator, Allocator, traits> matcher(first, last, m, e, flags, base);
-   return matcher.find();
+   return BOOST_REGEX_DETAIL_NS::factory_find(matcher);
 }
 
 //
 // regex_search convenience interfaces:
 //
-template <class charT, class Allocator, class traits>
+BOOST_REGEX_MODULE_EXPORT template <class charT, class Allocator, class traits>
 inline bool regex_search(const charT* str, 
                         match_results<const charT*, Allocator>& m, 
                         const basic_regex<charT, traits>& e, 
@@ -60,7 +60,7 @@ inline bool regex_search(const charT* str,
    return regex_search(str, str + traits::length(str), m, e, flags);
 }
 
-template <class ST, class SA, class Allocator, class charT, class traits>
+BOOST_REGEX_MODULE_EXPORT template <class ST, class SA, class Allocator, class charT, class traits>
 inline bool regex_search(const std::basic_string<charT, ST, SA>& s, 
                  match_results<typename std::basic_string<charT, ST, SA>::const_iterator, Allocator>& m, 
                  const basic_regex<charT, traits>& e, 
@@ -69,7 +69,7 @@ inline bool regex_search(const std::basic_string<charT, ST, SA>& s,
    return regex_search(s.begin(), s.end(), m, e, flags);
 }
 
-template <class BidiIterator, class charT, class traits>
+BOOST_REGEX_MODULE_EXPORT template <class BidiIterator, class charT, class traits>
 bool regex_search(BidiIterator first, BidiIterator last, 
                   const basic_regex<charT, traits>& e, 
                   match_flag_type flags = match_default)
@@ -80,10 +80,10 @@ bool regex_search(BidiIterator first, BidiIterator last,
    match_results<BidiIterator> m;
    typedef typename match_results<BidiIterator>::allocator_type match_alloc_type;
    BOOST_REGEX_DETAIL_NS::perl_matcher<BidiIterator, match_alloc_type, traits> matcher(first, last, m, e, flags | regex_constants::match_any, first);
-   return matcher.find();
+   return BOOST_REGEX_DETAIL_NS::factory_find(matcher);
 }
 
-template <class charT, class traits>
+BOOST_REGEX_MODULE_EXPORT template <class charT, class traits>
 inline bool regex_search(const charT* str, 
                         const basic_regex<charT, traits>& e, 
                         match_flag_type flags = match_default)
@@ -91,7 +91,7 @@ inline bool regex_search(const charT* str,
    return regex_search(str, str + traits::length(str), e, flags);
 }
 
-template <class ST, class SA, class charT, class traits>
+BOOST_REGEX_MODULE_EXPORT template <class ST, class SA, class charT, class traits>
 inline bool regex_search(const std::basic_string<charT, ST, SA>& s, 
                  const basic_regex<charT, traits>& e, 
                  match_flag_type flags = match_default)

include/boost/regex/v5/regex_split.hpp

@@ -93,7 +93,7 @@ bool split_pred<OutputIterator, charT, Traits1, Alloc1>::operator()
 
 } // namespace BOOST_REGEX_DETAIL_NS
 
-template <class OutputIterator, class charT, class Traits1, class Alloc1, class Traits2>
+BOOST_REGEX_MODULE_EXPORT template <class OutputIterator, class charT, class Traits1, class Alloc1, class Traits2>
 std::size_t regex_split(OutputIterator out,
                    std::basic_string<charT, Traits1, Alloc1>& s, 
                    const basic_regex<charT, Traits2>& e,
@@ -128,7 +128,7 @@ std::size_t regex_split(OutputIterator out,
    return init_size - max_split;
 }
 
-template <class OutputIterator, class charT, class Traits1, class Alloc1, class Traits2>
+BOOST_REGEX_MODULE_EXPORT template <class OutputIterator, class charT, class Traits1, class Alloc1, class Traits2>
 inline std::size_t regex_split(OutputIterator out,
                    std::basic_string<charT, Traits1, Alloc1>& s, 
                    const basic_regex<charT, Traits2>& e,
@@ -137,7 +137,7 @@ inline std::size_t regex_split(OutputIterator out,
    return regex_split(out, s, e, flags, UINT_MAX);
 }
 
-template <class OutputIterator, class charT, class Traits1, class Alloc1>
+BOOST_REGEX_MODULE_EXPORT template <class OutputIterator, class charT, class Traits1, class Alloc1>
 inline std::size_t regex_split(OutputIterator out,
                    std::basic_string<charT, Traits1, Alloc1>& s)
 {

include/boost/regex/v5/regex_token_iterator.hpp

@@ -22,8 +22,9 @@
 #include <boost/regex/v5/basic_regex.hpp>
 #include <boost/regex/v5/match_results.hpp>
 #include <boost/regex/v5/sub_match.hpp>
-
+#ifndef BOOST_REGEX_AS_MODULE
 #include <memory>
+#endif
 
 namespace boost{
 
@@ -124,7 +125,7 @@ private:
    regex_token_iterator_implementation& operator=(const regex_token_iterator_implementation&);
 };
 
-template <class BidirectionalIterator, 
+BOOST_REGEX_MODULE_EXPORT template <class BidirectionalIterator,
           class charT = typename std::iterator_traits<BidirectionalIterator>::value_type,
           class traits = regex_traits<charT> >
 class regex_token_iterator 
@@ -212,39 +213,39 @@ private:
    }
 };
 
-typedef regex_token_iterator<const char*> cregex_token_iterator;
-typedef regex_token_iterator<std::string::const_iterator> sregex_token_iterator;
+BOOST_REGEX_MODULE_EXPORT typedef regex_token_iterator<const char*> cregex_token_iterator;
+BOOST_REGEX_MODULE_EXPORT typedef regex_token_iterator<std::string::const_iterator> sregex_token_iterator;
 #ifndef BOOST_NO_WREGEX
-typedef regex_token_iterator<const wchar_t*> wcregex_token_iterator;
-typedef regex_token_iterator<std::wstring::const_iterator> wsregex_token_iterator;
+BOOST_REGEX_MODULE_EXPORT typedef regex_token_iterator<const wchar_t*> wcregex_token_iterator;
+BOOST_REGEX_MODULE_EXPORT typedef regex_token_iterator<std::wstring::const_iterator> wsregex_token_iterator;
 #endif
 
-template <class charT, class traits>
+BOOST_REGEX_MODULE_EXPORT template <class charT, class traits>
 inline regex_token_iterator<const charT*, charT, traits> make_regex_token_iterator(const charT* p, const basic_regex<charT, traits>& e, int submatch = 0, regex_constants::match_flag_type m = regex_constants::match_default)
 {
    return regex_token_iterator<const charT*, charT, traits>(p, p+traits::length(p), e, submatch, m);
 }
-template <class charT, class traits, class ST, class SA>
+BOOST_REGEX_MODULE_EXPORT template <class charT, class traits, class ST, class SA>
 inline regex_token_iterator<typename std::basic_string<charT, ST, SA>::const_iterator, charT, traits> make_regex_token_iterator(const std::basic_string<charT, ST, SA>& p, const basic_regex<charT, traits>& e, int submatch = 0, regex_constants::match_flag_type m = regex_constants::match_default)
 {
    return regex_token_iterator<typename std::basic_string<charT, ST, SA>::const_iterator, charT, traits>(p.begin(), p.end(), e, submatch, m);
 }
-template <class charT, class traits, std::size_t N>
+BOOST_REGEX_MODULE_EXPORT template <class charT, class traits, std::size_t N>
 inline regex_token_iterator<const charT*, charT, traits> make_regex_token_iterator(const charT* p, const basic_regex<charT, traits>& e, const int (&submatch)[N], regex_constants::match_flag_type m = regex_constants::match_default)
 {
    return regex_token_iterator<const charT*, charT, traits>(p, p+traits::length(p), e, submatch, m);
 }
-template <class charT, class traits, class ST, class SA, std::size_t N>
+BOOST_REGEX_MODULE_EXPORT template <class charT, class traits, class ST, class SA, std::size_t N>
 inline regex_token_iterator<typename std::basic_string<charT, ST, SA>::const_iterator, charT, traits> make_regex_token_iterator(const std::basic_string<charT, ST, SA>& p, const basic_regex<charT, traits>& e, const int (&submatch)[N], regex_constants::match_flag_type m = regex_constants::match_default)
 {
    return regex_token_iterator<typename std::basic_string<charT, ST, SA>::const_iterator, charT, traits>(p.begin(), p.end(), e, submatch, m);
 }
-template <class charT, class traits>
+BOOST_REGEX_MODULE_EXPORT template <class charT, class traits>
 inline regex_token_iterator<const charT*, charT, traits> make_regex_token_iterator(const charT* p, const basic_regex<charT, traits>& e, const std::vector<int>& submatch, regex_constants::match_flag_type m = regex_constants::match_default)
 {
    return regex_token_iterator<const charT*, charT, traits>(p, p+traits::length(p), e, submatch, m);
 }
-template <class charT, class traits, class ST, class SA>
+BOOST_REGEX_MODULE_EXPORT template <class charT, class traits, class ST, class SA>
 inline regex_token_iterator<typename std::basic_string<charT, ST, SA>::const_iterator, charT, traits> make_regex_token_iterator(const std::basic_string<charT, ST, SA>& p, const basic_regex<charT, traits>& e, const std::vector<int>& submatch, regex_constants::match_flag_type m = regex_constants::match_default)
 {
    return regex_token_iterator<typename std::basic_string<charT, ST, SA>::const_iterator, charT, traits>(p.begin(), p.end(), e, submatch, m);

include/boost/regex/v5/regex_traits.hpp

@@ -33,7 +33,7 @@
 
 namespace boost{
 
-template <class charT, class implementationT >
+BOOST_REGEX_MODULE_EXPORT template <class charT, class implementationT >
 struct regex_traits : public implementationT
 {
    regex_traits() : implementationT() {}

include/boost/regex/v5/regex_traits_defaults.hpp

@@ -24,12 +24,14 @@
 #include <boost/regex/v5/syntax_type.hpp>
 #include <boost/regex/v5/error_type.hpp>
 #include <boost/regex/v5/regex_workaround.hpp>
+#ifndef BOOST_REGEX_AS_MODULE
 #include <type_traits>
 #include <cstdint>
 #include <cctype>
 #include <locale>
 #include <cwctype>
 #include <limits>
+#endif
 
 namespace boost{ namespace BOOST_REGEX_DETAIL_NS{
 

include/boost/regex/v5/regex_workaround.hpp

@@ -20,9 +20,11 @@
 #define BOOST_REGEX_WORKAROUND_HPP
 
 #include <boost/regex/config.hpp>
+#ifndef BOOST_REGEX_AS_MODULE
 #include <algorithm>
 #include <stdexcept>
 #include <cstring>
+#endif
 
 #ifndef BOOST_REGEX_STANDALONE
 #include <boost/detail/workaround.hpp>

include/boost/regex/v5/states.hpp

@@ -21,8 +21,10 @@
 
 #include <boost/regex/v5/regex_raw_buffer.hpp>
 
+#ifndef BOOST_REGEX_AS_MODULE
 #include <climits>
 #include <cstddef>
+#endif
 
 namespace boost{
 namespace BOOST_REGEX_DETAIL_NS{

include/boost/regex/v5/sub_match.hpp

@@ -19,12 +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;
@@ -148,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)
@@ -317,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)
@@ -326,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)
@@ -335,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)
@@ -344,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)
@@ -353,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)
@@ -362,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)
@@ -371,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)

include/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;
+BOOST_REGEX_MODULE_EXPORT 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 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
+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
 
-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
+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
 
-static const escape_syntax_type syntax_max = 60;
+BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type syntax_max = 60;
 
 }
 }

include/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)
 {

include/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:

module/regex.cxx

@@ -0,0 +1,103 @@
+
+module;
+
+#if defined(__cpp_lib_modules) || (defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 193833135))
+#define BOOST_REGEX_USE_STD_MODULE
+#endif
+
+#if __has_include(<unicode/utypes.h>)
+
+#if !defined(BOOST_REGEX_WITH_ICU)
+
+#if defined(_MSC_FULL_VER)
+#pragma message "ICU headers are available but building the Regex module with ICU support is turned OFF.  Build with BOOST_REGEX_WITH_ICU=1 to turn it on, or BOOST_REGEX_WITH_ICU=0 to disable this message"
+#else
+# warning "ICU headers are available but building the Regex module with ICU support is turned OFF.  Build with BOOST_REGEX_WITH_ICU=1 to turn it on, or BOOST_REGEX_WITH_ICU=0 to disable this message"
+#endif
+
+#elif BOOST_REGEX_WITH_ICU
+#  define BOOST_REGEX_HAS_ICU_HEADERS
+#endif
+
+
+#endif
+
+#if defined(_WIN32) && __has_include(<windows.h>)
+#include <windows.h>
+#endif
+
+#if !defined(BOOST_REGEX_USE_STD_MODULE) && !defined(MSVC_EXPERIMENTAL_STD_MODULE)
+#include <cassert>
+#include <cstdint>
+#include <climits>
+#include <cctype>
+#include <cstddef>
+#include <cwctype>
+#include <climits>
+#include <cstring>
+
+#include <vector>
+#include <set>
+#include <locale>
+#include <type_traits>
+#include <ios>
+#include <istream>
+#include <functional>
+#include <iterator>
+#include <new>
+#include <atomic>
+#include <memory>
+#include <map>
+#include <list>
+#include <stdexcept>
+#include <string>
+#include <functional>
+#include <algorithm>
+#include <locale>
+#include <limits>
+#include <cstdint>
+#include <sstream>
+#include <ios>
+#ifdef BOOST_HAS_THREADS
+#include <mutex>
+#endif
+#include <cwctype>
+#include <assert.h>
+#endif
+
+#if !defined(BOOST_REGEX_USE_STD_MODULE) && defined(MSVC_EXPERIMENTAL_STD_MODULE)
+#include <cwchar>
+#include <cwctype>
+#endif
+
+#ifdef BOOST_REGEX_HAS_ICU_HEADERS
+#include <unicode/utypes.h>
+#include <unicode/uchar.h>
+#include <unicode/coll.h>
+#endif
+
+#define BOOST_REGEX_AS_MODULE
+#define BOOST_REGEX_STANDALONE
+#define BOOST_REGEX_MODULE_EXPORT export
+
+export module boost.regex;
+
+#if defined(BOOST_REGEX_USE_STD_MODULE)
+import std;
+#elif defined(MSVC_EXPERIMENTAL_STD_MODULE)
+import std.core;
+#endif
+
+#ifdef _MSC_FULL_VER
+#pragma warning(disable:5244)
+#endif
+
+#ifdef __clang__
+#pragma clang diagnostic ignored "-Winclude-angled-in-module-purview"
+#endif
+
+#include <boost/regex.hpp>
+
+#ifdef BOOST_REGEX_HAS_ICU_HEADERS
+#include <boost/regex/icu.hpp>
+#endif

module/regex_cfind.cpp

@@ -0,0 +1,11 @@
+
+module boost.regex;
+
+namespace boost::re_detail_600 {
+
+   bool factory_find(perl_matcher<const char*, match_results<const char*>::allocator_type, regex::traits_type>& m)
+   {
+      return m.find();
+   }
+
+}

module/regex_cmatch.cpp

@@ -0,0 +1,11 @@
+
+module boost.regex;
+
+namespace boost::re_detail_600 {
+
+   bool factory_match(perl_matcher<const char*, match_results<const char*>::allocator_type, regex::traits_type>& m)
+   {
+      return m.match();
+   }
+
+}

module/regex_create_char.cpp

@@ -0,0 +1,30 @@
+
+module;
+
+#if defined(__cpp_lib_modules) || (defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 193833135))
+#define BOOST_REGEX_USE_STD_MODULE
+#endif
+
+#ifndef BOOST_REGEX_DETAIL_NS
+#define BOOST_REGEX_DETAIL_NS re_detail_600
+#endif
+
+#if !defined(BOOST_REGEX_USE_STD_MODULE) && !defined(MSVC_EXPERIMENTAL_STD_MODULE)
+#include <memory>
+#endif
+
+module boost.regex;
+
+#if !defined(BOOST_REGEX_USE_STD_MODULE) && defined(MSVC_EXPERIMENTAL_STD_MODULE)
+import std.core;
+#endif
+
+namespace boost::detail {
+
+   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)
+   {
+      return create_implemenation<char, basic_regex<char>::flag_type, basic_regex<char>::traits_type>(p1, p2, f, ptraits);
+   }
+
+}

module/regex_create_wchar_t.cpp

@@ -0,0 +1,30 @@
+
+module;
+
+#if defined(__cpp_lib_modules) || (defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 193833135))
+#define BOOST_REGEX_USE_STD_MODULE
+#endif
+
+#ifndef BOOST_REGEX_DETAIL_NS
+#define BOOST_REGEX_DETAIL_NS re_detail_600
+#endif
+
+#if !defined(BOOST_REGEX_USE_STD_MODULE) && !defined(MSVC_EXPERIMENTAL_STD_MODULE)
+#include <memory>
+#endif
+
+module boost.regex;
+
+#if !defined(BOOST_REGEX_USE_STD_MODULE) && defined(MSVC_EXPERIMENTAL_STD_MODULE)
+import std.core;
+#endif
+
+namespace boost::detail {
+
+   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)
+   {
+      return create_implemenation<wchar_t, basic_regex<wchar_t>::flag_type, basic_regex<wchar_t>::traits_type>(p1, p2, f, ptraits);
+   }
+
+}

module/regex_nc_sfind.cpp

@@ -0,0 +1,25 @@
+
+module;
+
+#if defined(__cpp_lib_modules) || (defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 193833135))
+#define BOOST_REGEX_USE_STD_MODULE
+#endif
+
+#if !defined(BOOST_REGEX_USE_STD_MODULE) && !defined(MSVC_EXPERIMENTAL_STD_MODULE)
+#include <string>
+#endif
+
+module boost.regex;
+
+#if !defined(BOOST_REGEX_USE_STD_MODULE) && defined(MSVC_EXPERIMENTAL_STD_MODULE)
+import std.core;
+#endif
+
+namespace boost::re_detail_600 {
+
+   bool factory_find(perl_matcher<std::string::iterator, match_results<std::string::iterator>::allocator_type, regex::traits_type>& m)
+   {
+      return m.find();
+   }
+
+}

module/regex_nc_smatch.cpp

@@ -0,0 +1,25 @@
+
+module;
+
+#if defined(__cpp_lib_modules) || (defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 193833135))
+#define BOOST_REGEX_USE_STD_MODULE
+#endif
+
+#if !defined(BOOST_REGEX_USE_STD_MODULE) && !defined(MSVC_EXPERIMENTAL_STD_MODULE)
+#include <string>
+#endif
+
+module boost.regex;
+
+#if !defined(BOOST_REGEX_USE_STD_MODULE) && defined(MSVC_EXPERIMENTAL_STD_MODULE)
+import std.core;
+#endif
+
+namespace boost::re_detail_600 {
+
+   bool factory_match(perl_matcher<std::string::iterator, match_results<std::string::iterator>::allocator_type, regex::traits_type>& m)
+   {
+      return m.match();
+   }
+
+}

module/regex_nc_wsfind.cpp

@@ -0,0 +1,25 @@
+
+module;
+
+#if defined(__cpp_lib_modules) || (defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 193833135))
+#define BOOST_REGEX_USE_STD_MODULE
+#endif
+
+#if !defined(BOOST_REGEX_USE_STD_MODULE) && !defined(MSVC_EXPERIMENTAL_STD_MODULE)
+#include <string>
+#endif
+
+module boost.regex;
+
+#if !defined(BOOST_REGEX_USE_STD_MODULE) && defined(MSVC_EXPERIMENTAL_STD_MODULE)
+import std.core;
+#endif
+
+namespace boost::re_detail_600 {
+
+   bool factory_find(perl_matcher<std::wstring::iterator, match_results<std::wstring::iterator>::allocator_type, wregex::traits_type>& m)
+   {
+      return m.find();
+   }
+
+}

module/regex_nc_wsmatch.cpp

@@ -0,0 +1,25 @@
+
+module;
+
+#if defined(__cpp_lib_modules) || (defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 193833135))
+#define BOOST_REGEX_USE_STD_MODULE
+#endif
+
+#if !defined(BOOST_REGEX_USE_STD_MODULE) && !defined(MSVC_EXPERIMENTAL_STD_MODULE)
+#include <string>
+#endif
+
+module boost.regex;
+
+#if !defined(BOOST_REGEX_USE_STD_MODULE) && defined(MSVC_EXPERIMENTAL_STD_MODULE)
+import std.core;
+#endif
+
+namespace boost::re_detail_600 {
+
+   bool factory_match(perl_matcher<std::wstring::iterator, match_results<std::wstring::iterator>::allocator_type, wregex::traits_type>& m)
+   {
+      return m.match();
+   }
+
+}

module/regex_sfind.cpp

@@ -0,0 +1,25 @@
+
+module;
+
+#if defined(__cpp_lib_modules) || (defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 193833135))
+#define BOOST_REGEX_USE_STD_MODULE
+#endif
+
+#if !defined(BOOST_REGEX_USE_STD_MODULE) && !defined(MSVC_EXPERIMENTAL_STD_MODULE)
+#include <string>
+#endif
+
+module boost.regex;
+
+#if !defined(BOOST_REGEX_USE_STD_MODULE) && defined(MSVC_EXPERIMENTAL_STD_MODULE)
+import std.core;
+#endif
+
+namespace boost::re_detail_600 {
+
+   bool factory_find(perl_matcher<std::string::const_iterator, match_results<std::string::const_iterator>::allocator_type, regex::traits_type>& m)
+   {
+      return m.find();
+   }
+
+}

module/regex_smatch.cpp

@@ -0,0 +1,25 @@
+
+module;
+
+#if defined(__cpp_lib_modules) || (defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 193833135))
+#define BOOST_REGEX_USE_STD_MODULE
+#endif
+
+#if !defined(BOOST_REGEX_USE_STD_MODULE) && !defined(MSVC_EXPERIMENTAL_STD_MODULE)
+#include <string>
+#endif
+
+module boost.regex;
+
+#if !defined(BOOST_REGEX_USE_STD_MODULE) && defined(MSVC_EXPERIMENTAL_STD_MODULE)
+import std.core;
+#endif
+
+namespace boost::re_detail_600 {
+
+   bool factory_match(perl_matcher<std::string::const_iterator, match_results<std::string::const_iterator>::allocator_type, regex::traits_type>& m)
+   {
+      return m.match();
+   }
+
+}

module/regex_wcfind.cpp

@@ -0,0 +1,11 @@
+
+module boost.regex;
+
+namespace boost::re_detail_600 {
+
+   bool factory_find(perl_matcher<const wchar_t*, match_results<const wchar_t*>::allocator_type, wregex::traits_type>& m)
+   {
+      return m.find();
+   }
+
+}

module/regex_wcmatch.cpp

@@ -0,0 +1,11 @@
+
+module boost.regex;
+
+namespace boost::re_detail_600 {
+
+   bool factory_match(perl_matcher<const wchar_t*, match_results<const wchar_t*>::allocator_type, wregex::traits_type>& m)
+   {
+      return m.match();
+   }
+
+}

module/regex_wsfind.cpp

@@ -0,0 +1,25 @@
+
+module;
+
+#if defined(__cpp_lib_modules) || (defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 193833135))
+#define BOOST_REGEX_USE_STD_MODULE
+#endif
+
+#if !defined(BOOST_REGEX_USE_STD_MODULE) && !defined(MSVC_EXPERIMENTAL_STD_MODULE)
+#include <string>
+#endif
+
+module boost.regex;
+
+#if !defined(BOOST_REGEX_USE_STD_MODULE) && defined(MSVC_EXPERIMENTAL_STD_MODULE)
+import std.core;
+#endif
+
+namespace boost::re_detail_600 {
+
+   bool factory_find(perl_matcher<std::wstring::const_iterator, match_results<std::wstring::const_iterator>::allocator_type, wregex::traits_type>& m)
+   {
+      return m.find();
+   }
+
+}

module/regex_wsmatch.cpp

@@ -0,0 +1,25 @@
+
+module;
+
+#if defined(__cpp_lib_modules) || (defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 193833135))
+#define BOOST_REGEX_USE_STD_MODULE
+#endif
+
+#if !defined(BOOST_REGEX_USE_STD_MODULE) && !defined(MSVC_EXPERIMENTAL_STD_MODULE)
+#include <string>
+#endif
+
+module boost.regex;
+
+#if !defined(BOOST_REGEX_USE_STD_MODULE) && defined(MSVC_EXPERIMENTAL_STD_MODULE)
+import std.core;
+#endif
+
+namespace boost::re_detail_600 {
+
+   bool factory_match(perl_matcher<std::wstring::const_iterator, match_results<std::wstring::const_iterator>::allocator_type, wregex::traits_type>& m)
+   {
+      return m.match();
+   }
+
+}

test/Jamfile.v2

@@ -137,5 +137,8 @@ compile test_windows_defs_4.cpp ;
 run issue153.cpp : : : "<toolset>msvc:<linkflags>-STACK:2097152" ;
 run issue227.cpp ;
 run issue232.cpp ;
+run issue244.cpp ;
+run issue245.cpp ;
 run lookbehind_recursion_stress_test.cpp ;
+run regex_replace_overflow.cpp ;
 

test/concepts/module_concept_check.cpp

@@ -0,0 +1,99 @@
+/*
+ *
+ * Copyright (c) 2022
+ * John Maddock
+ *
+ * Use, modification and distribution are subject to the 
+ * Boost Software License, Version 1.0. (See accompanying file 
+ * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ *
+ */
+
+#ifdef __GNUC__
+//
+// For some reason, GCC chokes unless all std lib includes appear
+// before module imports:
+//
+#include <boost/concept_archetype.hpp>
+#include <boost/concept_check.hpp>
+#include <boost/type_traits/is_enum.hpp>
+#include <boost/type_traits/is_base_and_derived.hpp>
+#include <boost/static_assert.hpp>
+#include <bitset>
+#include <vector>
+#include <ostream>
+#endif
+
+import boost.regex;
+
+#define BOOST_REGEX_TEST_MODULE
+
+#include <boost/regex/concepts.hpp>
+
+
+int main()
+{
+   boost::function_requires<
+      boost::RegexTraitsConcept<
+         boost::regex_traits<char>
+      >
+   >();
+#ifndef BOOST_NO_STD_LOCALE
+   boost::function_requires<
+      boost::BoostRegexConcept<
+         boost::basic_regex<char, boost::cpp_regex_traits<char> >
+      >
+   >();
+#ifndef BOOST_NO_WREGEX
+   boost::function_requires<
+      boost::BoostRegexConcept<
+         boost::basic_regex<wchar_t, boost::cpp_regex_traits<wchar_t> >
+      >
+   >();
+#endif
+#endif
+   boost::function_requires<
+      boost::BoostRegexConcept<
+         boost::basic_regex<char, boost::c_regex_traits<char> >
+      >
+   >();
+#ifndef BOOST_NO_WREGEX
+   boost::function_requires<
+      boost::BoostRegexConcept<
+         boost::basic_regex<wchar_t, boost::c_regex_traits<wchar_t> >
+      >
+   >();
+#endif
+#if defined(_WIN32) && !defined(BOOST_REGEX_NO_W32)
+   boost::function_requires<
+      boost::BoostRegexConcept<
+         boost::basic_regex<char, boost::w32_regex_traits<char> >
+      >
+   >();
+#ifndef BOOST_NO_WREGEX
+   boost::function_requires<
+      boost::BoostRegexConcept<
+         boost::basic_regex<wchar_t, boost::w32_regex_traits<wchar_t> >
+      >
+   >();
+#endif
+#endif
+   //
+   // now test the regex_traits concepts:
+   //
+   typedef boost::basic_regex<char, boost::regex_traits_architype<char> > regex_traits_tester_type1;
+   boost::function_requires<
+      boost::BoostRegexConcept<
+         regex_traits_tester_type1
+      >
+   >();
+   typedef boost::basic_regex<boost::char_architype, boost::regex_traits_architype<boost::char_architype> > regex_traits_tester_type2;
+   boost::function_requires<
+      boost::BaseRegexConcept<
+         regex_traits_tester_type2
+      >
+   >();
+   return 0;
+}
+
+

test/de_fuzz/corpus/0334845542326f79e3fafbe94969c6b369f004bc

@@ -1 +0,0 @@
-
Z(((((((a+)+)+)+)+)+)+)+|Y(((((((a+)+)+)+)+)+)+)+|X(((((((a+)+)+)+)+)+)+)+|W(((((((a+)+)+)+)+)+)+)+|V(((((((a+)+)+)+)+)+)+)+|CZ(((((((a+)+)+)+)+)+)+)+|CY(((((((a+)+)+)+)+)+)+;+|CX(((((((a+)+)+)+)+)+)+)+|CW(((((((a+)+)+)+)+)+)+)+|CV(((((((a+)+)+)+)+)+)+)+|(a+)+b)