Restrict fix to where we really need it.

.github/workflows/ci.yml

@@ -9,15 +9,9 @@ on:
     branches:
       - 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
@@ -65,7 +59,7 @@ jobs:
         run: ../../../b2 print_config_info toolset=$TOOLSET
         working-directory: ../boost-root/libs/config/test
       - name: Test
-        run: ../../../b2 toolset=$TOOLSET variant=debug,release ${{ startsWith(matrix.compiler, 'g++-13') && 'address-sanitizer=norecover undefined-sanitizer=norecover' || '' }}
+        run: ../../../b2 toolset=$TOOLSET
         working-directory: ../boost-root/libs/regex/test
   ubuntu-jammy-standalone:
     runs-on: ubuntu-22.04
@@ -140,89 +134,6 @@ 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:
@@ -427,9 +338,6 @@ 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
@@ -456,9 +364,6 @@ 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="modules.html" title="Module Support (Experimental)">
+<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">
@@ -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="modules.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="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">
@@ -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="modules.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="intro.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="modules.html" title="Module Support (Experimental)">
+<link rel="prev" href="install.html" title="Building and Installing the Library">
 <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="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>
+<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>
 </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="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>
+<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>
 </div>
 </body>
 </html>

doc/html/boost_regex/modules.html

@@ -1,108 +0,0 @@
-<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,7 +50,6 @@
 <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

@@ -1,40 +0,0 @@
-[/ 
-  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,7 +51,6 @@ 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>
-#if !defined(BOOST_TEST_TR1_REGEX) && !defined(BOOST_REGEX_TEST_MODULE)
+#ifndef BOOST_TEST_TR1_REGEX
 #include <boost/regex.hpp>
 #endif
 #include <bitset>
@@ -37,16 +37,6 @@
 #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{
 
 //
@@ -188,6 +178,15 @@ 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
 {
@@ -274,7 +273,7 @@ template <class Regex>
 struct regex_traits_computer;
 
 template <class charT, class traits>
-struct regex_traits_computer< ::boost::basic_regex<charT, traits> >
+struct regex_traits_computer< global_regex_namespace::basic_regex<charT, traits> >
 {
    typedef traits type;
 };

include/boost/regex/config.hpp

@@ -29,22 +29,6 @@
 #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
@@ -56,13 +40,9 @@
 *************************************************************************/
 
 #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
@@ -304,6 +284,8 @@
  * 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

@@ -19,18 +19,7 @@
 #ifndef BOOST_REGEX_V5_BASIC_REGEX_HPP
 #define BOOST_REGEX_V5_BASIC_REGEX_HPP
 
-#include <boost/regex/v5/regbase.hpp>
-#include <boost/regex/v5/syntax_type.hpp>
-#include <boost/regex/v5/regex_traits.hpp>
-#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
@@ -69,12 +58,7 @@ void bubble_down_one(I first, I last)
    }
 }
 
-#ifndef BOOST_REGEX_AS_MODULE
-static
-#else
-inline
-#endif
-const int hash_value_mask = 1 << (std::numeric_limits<int>::digits - 1);
+static const int hash_value_mask = 1 << (std::numeric_limits<int>::digits - 1);
 
 template <class Iterator>
 inline int hash_value_from_capture_name(Iterator i, Iterator j)
@@ -322,7 +306,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
@@ -659,38 +643,22 @@ 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)
 {
-   m_pimpl = detail::create_implemenation(p1, p2, f, m_pimpl.get() ? m_pimpl->m_ptraits : std::shared_ptr<boost::regex_traits_wrapper<traits> >());
+   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);
    return *this;
 }
 
@@ -706,13 +674,13 @@ typename basic_regex<charT, traits>::locale_type  basic_regex<charT, traits>::im
 //
 // non-members:
 //
-BOOST_REGEX_MODULE_EXPORT template <class charT, class traits>
+template <class charT, class traits>
 void swap(basic_regex<charT, traits>& e1, basic_regex<charT, traits>& e2)
 {
    e1.swap(e2);
 }
 
-BOOST_REGEX_MODULE_EXPORT template <class charT, class traits, class traits2>
+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

@@ -28,12 +28,7 @@
 #endif
 #endif
 
-#include <boost/regex/v5/basic_regex.hpp>
-
-#ifndef BOOST_REGEX_AS_MODULE
-#include <vector>
 #include <set>
-#endif
 
 namespace boost{
 
@@ -222,10 +217,8 @@ public:
          m_icase = static_cast<bool>(f & regbase::icase);
       }
    }
-   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_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_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>*);
@@ -978,12 +971,7 @@ template <class charT, class traits>
 int basic_regex_creator<charT, traits>::calculate_backstep(re_syntax_base* state)
 {
    typedef typename traits::char_class_type m_type;
-
    int result = 0;
-   int last_alternative_result = -1;
-
-   std::vector<std::tuple<int, re_syntax_base*>> stack;
-
    while(state)
    {
       switch(state->type)
@@ -1002,28 +990,9 @@ int basic_regex_creator<charT, traits>::calculate_backstep(re_syntax_base* state
          }
          break;
       case syntax_element_endmark:
-         if ((static_cast<re_brace*>(state)->index == -1)
+         if((static_cast<re_brace*>(state)->index == -1)
             || (static_cast<re_brace*>(state)->index == -2))
-         {
-            // We've finished the calculation, check against any previous alternatives:
-            if (last_alternative_result >= 0)
-            {
-               if (last_alternative_result != result)
-                  return -1;
-            }
-            else
-               last_alternative_result = result;
-
-            if (stack.size())
-            {
-               // Skip to next alternative and calculate that as well:
-               std::tie(result, state) = stack.back();
-               stack.pop_back();
-               continue;
-            }
-            else
-               return result;
-         }
+            return result;
          break;
       case syntax_element_literal:
          result += static_cast<re_literal*>(state)->length;
@@ -1079,13 +1048,11 @@ int basic_regex_creator<charT, traits>::calculate_backstep(re_syntax_base* state
          continue;
       case syntax_element_alt:
          {
-            // Push the alternative if we haven't pushed too many already:
-            if(stack.size() > BOOST_REGEX_MAX_BLOCKS)
+            int r1 = calculate_backstep(state->next.p);
+            int r2 = calculate_backstep(static_cast<re_alt*>(state)->alt.p);
+            if((r1 < 0) || (r1 != r2))
                return -1;
-            stack.push_back(std::make_tuple(result, static_cast<re_alt*>(state)->alt.p));
-            // and take the first one:
-            state = state->next.p;
-            continue;
+            return result + r1;
          }
       default:
          break;

include/boost/regex/v5/basic_regex_parser.hpp

@@ -19,15 +19,6 @@
 #ifndef BOOST_REGEX_V5_BASIC_REGEX_PARSER_HPP
 #define BOOST_REGEX_V5_BASIC_REGEX_PARSER_HPP
 
-#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{
 
@@ -898,11 +889,6 @@ 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:
@@ -1002,7 +988,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;
       }
@@ -1119,13 +1105,6 @@ 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,16 +19,9 @@
 #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>
 
 namespace boost{
 
@@ -56,10 +49,10 @@ namespace boost{
 
    }
 
-BOOST_REGEX_MODULE_EXPORT template <class charT>
+template <class charT>
 struct c_regex_traits;
 
-BOOST_REGEX_MODULE_EXPORT template<>
+template<>
 struct c_regex_traits<char>
 {
    c_regex_traits(){}
@@ -104,7 +97,7 @@ private:
 };
 
 #ifndef BOOST_NO_WREGEX
-BOOST_REGEX_MODULE_EXPORT template<>
+template<>
 struct c_regex_traits<wchar_t>
 {
    c_regex_traits(){}

include/boost/regex/v5/char_regex_traits.hpp

@@ -20,8 +20,6 @@
 #ifndef BOOST_REGEX_V5_CHAR_REGEX_TRAITS_HPP
 #define BOOST_REGEX_V5_CHAR_REGEX_TRAITS_HPP
 
-#include <boost/regex/v5/regex_traits.hpp>
-
 namespace boost{
 
 namespace deprecated{

include/boost/regex/v5/cpp_regex_traits.hpp

@@ -20,25 +20,22 @@
 #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)
@@ -50,7 +47,7 @@ namespace boost{
 //
 // forward declaration is needed by some compilers:
 //
-BOOST_REGEX_MODULE_EXPORT template <class charT>
+template <class charT>
 class cpp_regex_traits;
    
 namespace BOOST_REGEX_DETAIL_NS{
@@ -734,7 +731,7 @@ inline std::shared_ptr<const cpp_regex_traits_implementation<charT> > create_cpp
 
 } // BOOST_REGEX_DETAIL_NS
 
-BOOST_REGEX_MODULE_EXPORT template <class charT>
+template <class charT>
 class cpp_regex_traits
 {
 private:

include/boost/regex/v5/cregex.hpp

@@ -38,13 +38,11 @@
 #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{
 
-BOOST_REGEX_MODULE_EXPORT enum error_type{
+enum error_type{
 
    error_ok = 0,         /* not used */
    error_no_match = 1,   /* not used */

include/boost/regex/v5/icu.hpp

@@ -19,13 +19,11 @@
 #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>
 
@@ -837,7 +835,7 @@ bool do_regex_match(BidiIterator first, BidiIterator last,
 }
 } // namespace BOOST_REGEX_DETAIL_NS
 
-BOOST_REGEX_MODULE_EXPORT template <class BidiIterator, class Allocator>
+template <class BidiIterator, class Allocator>
 inline bool u32regex_match(BidiIterator first, BidiIterator last, 
                  match_results<BidiIterator, Allocator>& m, 
                  const u32regex& e, 
@@ -845,7 +843,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));
 }
-BOOST_REGEX_MODULE_EXPORT inline bool u32regex_match(const UChar* p,
+inline bool u32regex_match(const UChar* p, 
                  match_results<const UChar*>& m, 
                  const u32regex& e, 
                  match_flag_type flags = match_default)
@@ -853,7 +851,7 @@ BOOST_REGEX_MODULE_EXPORT 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)
-BOOST_REGEX_MODULE_EXPORT inline bool u32regex_match(const wchar_t* p,
+inline bool u32regex_match(const wchar_t* p, 
                  match_results<const wchar_t*>& m, 
                  const u32regex& e, 
                  match_flag_type flags = match_default)
@@ -861,21 +859,21 @@ BOOST_REGEX_MODULE_EXPORT 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
-BOOST_REGEX_MODULE_EXPORT inline bool u32regex_match(const char* p,
+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));
 }
-BOOST_REGEX_MODULE_EXPORT inline bool u32regex_match(const unsigned char* p,
+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));
 }
-BOOST_REGEX_MODULE_EXPORT inline bool u32regex_match(const std::string& s,
+inline bool u32regex_match(const std::string& s, 
                         match_results<std::string::const_iterator>& m, 
                         const u32regex& e, 
                         match_flag_type flags = match_default)
@@ -883,7 +881,7 @@ BOOST_REGEX_MODULE_EXPORT 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
-BOOST_REGEX_MODULE_EXPORT inline bool u32regex_match(const std::wstring& s,
+inline bool u32regex_match(const std::wstring& s, 
                         match_results<std::wstring::const_iterator>& m, 
                         const u32regex& e, 
                         match_flag_type flags = match_default)
@@ -891,7 +889,7 @@ BOOST_REGEX_MODULE_EXPORT 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
-BOOST_REGEX_MODULE_EXPORT inline bool u32regex_match(const U_NAMESPACE_QUALIFIER UnicodeString& s,
+inline bool u32regex_match(const U_NAMESPACE_QUALIFIER UnicodeString& s, 
                         match_results<const UChar*>& m, 
                         const u32regex& e, 
                         match_flag_type flags = match_default)
@@ -901,7 +899,7 @@ BOOST_REGEX_MODULE_EXPORT inline bool u32regex_match(const U_NAMESPACE_QUALIFIER
 //
 // regex_match overloads that do not return what matched:
 //
-BOOST_REGEX_MODULE_EXPORT template <class BidiIterator>
+template <class BidiIterator>
 inline bool u32regex_match(BidiIterator first, BidiIterator last, 
                  const u32regex& e, 
                  match_flag_type flags = match_default)
@@ -909,7 +907,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));
 }
-BOOST_REGEX_MODULE_EXPORT inline bool u32regex_match(const UChar* p,
+inline bool u32regex_match(const UChar* p, 
                  const u32regex& e, 
                  match_flag_type flags = match_default)
 {
@@ -917,7 +915,7 @@ BOOST_REGEX_MODULE_EXPORT 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)
-BOOST_REGEX_MODULE_EXPORT inline bool u32regex_match(const wchar_t* p,
+inline bool u32regex_match(const wchar_t* p, 
                  const u32regex& e, 
                  match_flag_type flags = match_default)
 {
@@ -925,21 +923,21 @@ BOOST_REGEX_MODULE_EXPORT 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
-BOOST_REGEX_MODULE_EXPORT inline bool u32regex_match(const char* p,
+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));
 }
-BOOST_REGEX_MODULE_EXPORT inline bool u32regex_match(const unsigned char* p,
+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));
 }
-BOOST_REGEX_MODULE_EXPORT inline bool u32regex_match(const std::string& s,
+inline bool u32regex_match(const std::string& s, 
                         const u32regex& e, 
                         match_flag_type flags = match_default)
 {
@@ -947,7 +945,7 @@ BOOST_REGEX_MODULE_EXPORT 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
-BOOST_REGEX_MODULE_EXPORT inline bool u32regex_match(const std::wstring& s,
+inline bool u32regex_match(const std::wstring& s, 
                         const u32regex& e, 
                         match_flag_type flags = match_default)
 {
@@ -955,7 +953,7 @@ BOOST_REGEX_MODULE_EXPORT 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
-BOOST_REGEX_MODULE_EXPORT inline bool u32regex_match(const U_NAMESPACE_QUALIFIER UnicodeString& s,
+inline bool u32regex_match(const U_NAMESPACE_QUALIFIER UnicodeString& s, 
                         const u32regex& e, 
                         match_flag_type flags = match_default)
 {
@@ -1013,7 +1011,7 @@ bool do_regex_search(BidiIterator first, BidiIterator last,
 }
 }
 
-BOOST_REGEX_MODULE_EXPORT template <class BidiIterator, class Allocator>
+template <class BidiIterator, class Allocator>
 inline bool u32regex_search(BidiIterator first, BidiIterator last, 
                  match_results<BidiIterator, Allocator>& m, 
                  const u32regex& e, 
@@ -1021,7 +1019,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));
 }
-BOOST_REGEX_MODULE_EXPORT template <class BidiIterator, class Allocator>
+template <class BidiIterator, class Allocator>
 inline bool u32regex_search(BidiIterator first, BidiIterator last, 
                  match_results<BidiIterator, Allocator>& m, 
                  const u32regex& e, 
@@ -1030,7 +1028,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));
 }
-BOOST_REGEX_MODULE_EXPORT inline bool u32regex_search(const UChar* p,
+inline bool u32regex_search(const UChar* p, 
                  match_results<const UChar*>& m, 
                  const u32regex& e, 
                  match_flag_type flags = match_default)
@@ -1038,7 +1036,7 @@ BOOST_REGEX_MODULE_EXPORT 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)
-BOOST_REGEX_MODULE_EXPORT inline bool u32regex_search(const wchar_t* p,
+inline bool u32regex_search(const wchar_t* p, 
                  match_results<const wchar_t*>& m, 
                  const u32regex& e, 
                  match_flag_type flags = match_default)
@@ -1046,21 +1044,21 @@ BOOST_REGEX_MODULE_EXPORT 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
-BOOST_REGEX_MODULE_EXPORT inline bool u32regex_search(const char* p,
+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));
 }
-BOOST_REGEX_MODULE_EXPORT inline bool u32regex_search(const unsigned char* p,
+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));
 }
-BOOST_REGEX_MODULE_EXPORT inline bool u32regex_search(const std::string& s,
+inline bool u32regex_search(const std::string& s, 
                         match_results<std::string::const_iterator>& m, 
                         const u32regex& e, 
                         match_flag_type flags = match_default)
@@ -1068,7 +1066,7 @@ BOOST_REGEX_MODULE_EXPORT 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
-BOOST_REGEX_MODULE_EXPORT inline bool u32regex_search(const std::wstring& s,
+inline bool u32regex_search(const std::wstring& s, 
                         match_results<std::wstring::const_iterator>& m, 
                         const u32regex& e, 
                         match_flag_type flags = match_default)
@@ -1076,14 +1074,14 @@ BOOST_REGEX_MODULE_EXPORT 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
-BOOST_REGEX_MODULE_EXPORT inline bool u32regex_search(const U_NAMESPACE_QUALIFIER UnicodeString& s,
+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));
 }
-BOOST_REGEX_MODULE_EXPORT template <class BidiIterator>
+template <class BidiIterator>
 inline bool u32regex_search(BidiIterator first, BidiIterator last, 
                  const u32regex& e, 
                  match_flag_type flags = match_default)
@@ -1091,7 +1089,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));
 }
-BOOST_REGEX_MODULE_EXPORT inline bool u32regex_search(const UChar* p,
+inline bool u32regex_search(const UChar* p, 
                  const u32regex& e, 
                  match_flag_type flags = match_default)
 {
@@ -1099,7 +1097,7 @@ BOOST_REGEX_MODULE_EXPORT 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)
-BOOST_REGEX_MODULE_EXPORT inline bool u32regex_search(const wchar_t* p,
+inline bool u32regex_search(const wchar_t* p, 
                  const u32regex& e, 
                  match_flag_type flags = match_default)
 {
@@ -1107,21 +1105,21 @@ BOOST_REGEX_MODULE_EXPORT 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
-BOOST_REGEX_MODULE_EXPORT inline bool u32regex_search(const char* p,
+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));
 }
-BOOST_REGEX_MODULE_EXPORT inline bool u32regex_search(const unsigned char* p,
+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));
 }
-BOOST_REGEX_MODULE_EXPORT inline bool u32regex_search(const std::string& s,
+inline bool u32regex_search(const std::string& s, 
                         const u32regex& e, 
                         match_flag_type flags = match_default)
 {
@@ -1129,7 +1127,7 @@ BOOST_REGEX_MODULE_EXPORT 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
-BOOST_REGEX_MODULE_EXPORT inline bool u32regex_search(const std::wstring& s,
+inline bool u32regex_search(const std::wstring& s, 
                         const u32regex& e, 
                         match_flag_type flags = match_default)
 {
@@ -1137,7 +1135,7 @@ BOOST_REGEX_MODULE_EXPORT 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
-BOOST_REGEX_MODULE_EXPORT inline bool u32regex_search(const U_NAMESPACE_QUALIFIER UnicodeString& s,
+inline bool u32regex_search(const U_NAMESPACE_QUALIFIER UnicodeString& s, 
                         const u32regex& e, 
                         match_flag_type flags = match_default)
 {
@@ -1260,7 +1258,7 @@ inline BaseIterator extract_output_base(const utf16_output_iterator<BaseIterator
 }
 }  // BOOST_REGEX_DETAIL_NS
 
-BOOST_REGEX_MODULE_EXPORT template <class OutputIterator, class BidirectionalIterator, class charT>
+template <class OutputIterator, class BidirectionalIterator, class charT>
 inline OutputIterator u32regex_replace(OutputIterator out,
                          BidirectionalIterator first,
                          BidirectionalIterator last,
@@ -1279,7 +1277,7 @@ inline OutputIterator u32regex_replace(OutputIterator out,
       );
 }
 
-BOOST_REGEX_MODULE_EXPORT template <class OutputIterator, class Iterator, class charT>
+template <class OutputIterator, class Iterator, class charT>
 inline OutputIterator u32regex_replace(OutputIterator out,
                          Iterator first,
                          Iterator last,
@@ -1298,7 +1296,7 @@ inline OutputIterator u32regex_replace(OutputIterator out,
       );
 }
 
-BOOST_REGEX_MODULE_EXPORT template <class OutputIterator, class Iterator>
+template <class OutputIterator, class Iterator>
 inline OutputIterator u32regex_replace(OutputIterator out,
                          Iterator first,
                          Iterator last,
@@ -1317,7 +1315,7 @@ inline OutputIterator u32regex_replace(OutputIterator out,
       );
 }
 
-BOOST_REGEX_MODULE_EXPORT template <class charT>
+template <class charT>
 std::basic_string<charT> u32regex_replace(const std::basic_string<charT>& s,
                          const u32regex& e, 
                          const charT* fmt,
@@ -1329,7 +1327,7 @@ std::basic_string<charT> u32regex_replace(const std::basic_string<charT>& s,
    return result;
 }
 
-BOOST_REGEX_MODULE_EXPORT template <class charT>
+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,10 +21,8 @@
 #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,10 +19,6 @@
 #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,11 +19,9 @@
 #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{
@@ -37,7 +35,7 @@ namespace boost{
 #endif
 #endif
 
-BOOST_REGEX_MODULE_EXPORT typedef enum _match_flags
+typedef enum _match_flags
 {
    match_default = 0,
    match_not_bol = 1,                                /* first is not start of line */
@@ -91,22 +89,22 @@ BOOST_REGEX_MODULE_EXPORT typedef enum _match_flags
 
 } match_flags;
 
-BOOST_REGEX_MODULE_EXPORT typedef match_flags match_flag_type;
+typedef match_flags match_flag_type;
 
 #ifdef __cplusplus
-BOOST_REGEX_MODULE_EXPORT inline match_flags operator&(match_flags m1, match_flags m2)
+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)); }
-BOOST_REGEX_MODULE_EXPORT inline match_flags operator|(match_flags m1, match_flags m2)
+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)); }
-BOOST_REGEX_MODULE_EXPORT inline match_flags operator^(match_flags m1, match_flags m2)
+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)); }
-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)
+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)
 { m1 = m1&m2; return m1; }
-BOOST_REGEX_MODULE_EXPORT inline match_flags& operator|=(match_flags& m1, match_flags m2)
+inline match_flags& operator|=(match_flags& m1, match_flags m2)
 { m1 = m1|m2; return m1; }
-BOOST_REGEX_MODULE_EXPORT inline match_flags& operator^=(match_flags& m1, match_flags m2)
+inline match_flags& operator^=(match_flags& m1, match_flags m2)
 { m1 = m1^m2; return m1; }
 #endif
 
@@ -115,36 +113,36 @@ BOOST_REGEX_MODULE_EXPORT inline match_flags& operator^=(match_flags& m1, match_
 /*
  * import names into boost for backwards compatibility:
  */
-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_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;
 /* using regex_constants::match_init; */
-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_any;
+using regex_constants::match_not_null;
+using regex_constants::match_continuous;
+using regex_constants::match_partial;
 /*using regex_constants::match_stop; */
-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_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;
 /*using regex_constants::match_max; */
-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_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;
 /*using regex_constants::format_is_if;*/
 
 #ifdef BOOST_REGEX_MSVC

include/boost/regex/v5/match_results.hpp

@@ -19,16 +19,6 @@
 #ifndef BOOST_REGEX_V5_MATCH_RESULTS_HPP
 #define BOOST_REGEX_V5_MATCH_RESULTS_HPP
 
-#include <boost/regex/v5/match_flags.hpp>
-#include <boost/regex/v5/sub_match.hpp>
-#include <boost/regex/v5/basic_regex.hpp>
-#include <boost/regex/v5/regex_format.hpp>
-
-#ifndef BOOST_REGEX_AS_MODULE
-#include <string>
-#include <vector>
-#endif
-
 namespace boost{
 #ifdef BOOST_REGEX_MSVC
 #pragma warning(push)
@@ -47,7 +37,7 @@ class named_subexpressions;
 
 }
 
-BOOST_REGEX_MODULE_EXPORT template <class BidiIterator, class Allocator>
+template <class BidiIterator, class Allocator>
 class match_results
 { 
 private:
@@ -227,10 +217,6 @@ 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))
       {
@@ -680,13 +666,13 @@ void  match_results<BidiIterator, Allocator>::maybe_assign(const match_results<B
       *this = m;
 }
 
-BOOST_REGEX_MODULE_EXPORT template <class BidiIterator, class Allocator>
+template <class BidiIterator, class Allocator>
 void swap(match_results<BidiIterator, Allocator>& a, match_results<BidiIterator, Allocator>& b)
 {
    a.swap(b);
 }
 
-BOOST_REGEX_MODULE_EXPORT template <class charT, class traits, class BidiIterator, class Allocator>
+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

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

include/boost/regex/v5/object_cache.hpp

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

include/boost/regex/v5/pattern_except.hpp

@@ -23,10 +23,8 @@
 #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>
 
@@ -39,7 +37,7 @@ namespace boost{
 #pragma warning(disable : 26812 4459)
 #endif
 #endif
-BOOST_REGEX_MODULE_EXPORT class regex_error : public std::runtime_error
+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)
@@ -74,8 +72,8 @@ private:
    std::ptrdiff_t m_position;
 };
 
-BOOST_REGEX_MODULE_EXPORT typedef regex_error bad_pattern;
-BOOST_REGEX_MODULE_EXPORT typedef regex_error bad_expression;
+typedef regex_error bad_pattern;
+typedef regex_error bad_expression;
 
 namespace BOOST_REGEX_DETAIL_NS{
 

include/boost/regex/v5/perl_matcher.hpp

@@ -12,20 +12,7 @@
 #ifndef BOOST_REGEX_MATCHER_HPP
 #define BOOST_REGEX_MATCHER_HPP
 
-#include <boost/regex/v5/match_flags.hpp>
-#include <boost/regex/v5/match_results.hpp>
-#include <boost/regex/v5/regbase.hpp>
 #include <boost/regex/v5/iterator_category.hpp>
-#include <boost/regex/v5/states.hpp>
-#include <boost/regex/v5/regex_traits.hpp>
-
-#ifndef BOOST_REGEX_AS_MODULE
-#ifndef BOOST_REGEX_STANDALONE
-#include <boost/throw_exception.hpp>
-#endif
-
-#include <climits>
-#endif
 
 #ifdef BOOST_REGEX_MSVC
 #  pragma warning(push)
@@ -41,34 +28,25 @@
 #endif
 #endif
 
-#ifndef BOOST_REGEX_STANDALONE
-#  define BOOST_REGEX_DETAIL_THROW(ex) boost::throw_exception(ex)
-#else
-#  define BOOST_REGEX_DETAIL_THROW(ex) throw ex
-#endif
-
 namespace boost{
 namespace BOOST_REGEX_DETAIL_NS{
 
 //
 // error checking API:
 //
-inline void verify_options(boost::regex_constants::syntax_option_type, match_flag_type mf)
+inline void  verify_options(boost::regex_constants::syntax_option_type, match_flag_type mf)
 {
-   auto is_perl = (mf & match_perl);
-   auto is_posix = (mf & match_posix);
-
-   if (is_perl && is_posix)
-   {
-      BOOST_REGEX_DETAIL_THROW(std::logic_error("Usage Error: Can't mix Perl and POSIX matching rules"));
-   }
-
    //
    // can't mix match_extra with POSIX matching rules:
    //
-   if ((mf & match_extra) && is_posix)
+   if ((mf & match_extra) && (mf & match_posix))
    {
-      BOOST_REGEX_DETAIL_THROW(std::logic_error("Usage Error: Can't mix regular expression captures with POSIX matching rules"));
+      std::logic_error msg("Usage Error: Can't mix regular expression captures with POSIX matching rules");
+#ifndef BOOST_REGEX_STANDALONE
+      throw_exception(msg);
+#else
+      throw msg;
+#endif
    }
 }
 //
@@ -580,33 +558,6 @@ 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_common.hpp

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

include/boost/regex/v5/perl_matcher_non_recursive.hpp

@@ -20,18 +20,6 @@
 #ifndef BOOST_REGEX_V5_PERL_MATCHER_NON_RECURSIVE_HPP
 #define BOOST_REGEX_V5_PERL_MATCHER_NON_RECURSIVE_HPP
 
-#include <boost/regex/config.hpp>
-
-#ifndef BOOST_REGEX_STANDALONE
-
-#include <boost/config.hpp>
-#if defined(BOOST_HAS_PRAGMA_ONCE)
-#pragma once
-#include <boost/regex/v5/perl_matcher.hpp>
-#endif
-
-#endif
-
 #include <boost/regex/v5/mem_block_cache.hpp>
 
 #ifdef BOOST_REGEX_MSVC
@@ -237,8 +225,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 = reinterpret_cast<saved_extra_block*>(
-         reinterpret_cast<std::uintptr_t>(backup_state) - sizeof(saved_extra_block));
+      saved_extra_block* block = static_cast<saved_extra_block*>(backup_state);
+      --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,8 +19,6 @@
 #ifndef BOOST_REGEX_V5_REGBASE_HPP
 #define BOOST_REGEX_V5_REGBASE_HPP
 
-#include <boost/regex/config.hpp>
-
 namespace boost{
 //
 // class regbase
@@ -114,7 +112,7 @@ public:
 //
 namespace regex_constants{
 
-   BOOST_REGEX_MODULE_EXPORT enum flag_type_
+   enum flag_type_
    {
 
       no_except = ::boost::regbase::no_except,
@@ -150,7 +148,7 @@ namespace regex_constants{
       JavaScript = normal,
       JScript = normal
    };
-   BOOST_REGEX_MODULE_EXPORT typedef ::boost::regbase::flag_type syntax_option_type;
+   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
-BOOST_REGEX_MODULE_EXPORT typedef basic_regex<char, regex_traits<char> > regex;
+typedef basic_regex<char, regex_traits<char> > regex;
 #ifndef BOOST_NO_WREGEX
-BOOST_REGEX_MODULE_EXPORT typedef basic_regex<wchar_t, regex_traits<wchar_t> > wregex;
+typedef basic_regex<wchar_t, regex_traits<wchar_t> > wregex;
 #endif
 #endif
 
-BOOST_REGEX_MODULE_EXPORT typedef match_results<const char*> cmatch;
-BOOST_REGEX_MODULE_EXPORT typedef match_results<std::string::const_iterator> smatch;
+typedef match_results<const char*> cmatch;
+typedef match_results<std::string::const_iterator> smatch;
 #ifndef BOOST_NO_WREGEX
-BOOST_REGEX_MODULE_EXPORT typedef match_results<const wchar_t*> wcmatch;
-BOOST_REGEX_MODULE_EXPORT typedef match_results<std::wstring::const_iterator> wsmatch;
+typedef match_results<const wchar_t*> wcmatch;
+typedef match_results<std::wstring::const_iterator> wsmatch;
 #endif
 
 } // namespace boost

include/boost/regex/v5/regex_format.hpp

@@ -21,20 +21,15 @@
 #ifndef BOOST_REGEX_FORMAT_HPP
 #define BOOST_REGEX_FORMAT_HPP
 
-#include <boost/regex/v5/match_flags.hpp>
-#include <boost/regex/v5/sub_match.hpp>
-#include <boost/regex/v5/regex_traits_defaults.hpp>
-#ifndef BOOST_REGEX_AS_MODULE
 #include <type_traits>
 #include <functional>
-#endif
 
 namespace boost{
 
 //
 // Forward declaration:
 //
-BOOST_REGEX_MODULE_EXPORT template <class BidiIterator, class Allocator = typename std::vector<sub_match<BidiIterator> >::allocator_type >
+   template <class BidiIterator, class Allocator = typename std::vector<sub_match<BidiIterator> >::allocator_type >
 class match_results;
 
 namespace BOOST_REGEX_DETAIL_NS{
@@ -1100,7 +1095,7 @@ struct compute_functor_type
 
 } // namespace BOOST_REGEX_DETAIL_NS
 
-BOOST_REGEX_MODULE_EXPORT template <class OutputIterator, class Iterator, class Allocator, class Functor>
+template <class OutputIterator, class Iterator, class Allocator, class Functor>
 inline OutputIterator regex_format(OutputIterator out,
                           const match_results<Iterator, Allocator>& m,
                           Functor fmt,
@@ -1110,7 +1105,7 @@ inline OutputIterator regex_format(OutputIterator out,
    return m.format(out, fmt, flags);
 }
 
-BOOST_REGEX_MODULE_EXPORT template <class Iterator, class Allocator, class Functor>
+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{
 
-BOOST_REGEX_MODULE_EXPORT template <class charT>
+template <class charT>
 class cpp_regex_traits;
-BOOST_REGEX_MODULE_EXPORT template <class charT>
+template <class charT>
 struct c_regex_traits;
-BOOST_REGEX_MODULE_EXPORT template <class charT>
+template <class charT>
 class w32_regex_traits;
 
 #ifdef BOOST_REGEX_USE_WIN32_LOCALE
-BOOST_REGEX_MODULE_EXPORT template <class charT, class implementationT = w32_regex_traits<charT> >
+template <class charT, class implementationT = w32_regex_traits<charT> >
 struct regex_traits;
 #elif defined(BOOST_REGEX_USE_CPP_LOCALE)
-BOOST_REGEX_MODULE_EXPORT template <class charT, class implementationT = cpp_regex_traits<charT> >
+template <class charT, class implementationT = cpp_regex_traits<charT> >
 struct regex_traits;
 #else
-BOOST_REGEX_MODULE_EXPORT template <class charT, class implementationT = c_regex_traits<charT> >
+template <class charT, class implementationT = c_regex_traits<charT> >
 struct regex_traits;
 #endif
 
-BOOST_REGEX_MODULE_EXPORT template <class charT, class traits = regex_traits<charT> >
+template <class charT, class traits = regex_traits<charT> >
 class basic_regex;
 
-BOOST_REGEX_MODULE_EXPORT typedef basic_regex<char, regex_traits<char> > regex;
+typedef basic_regex<char, regex_traits<char> > regex;
 #ifndef BOOST_NO_WREGEX
-BOOST_REGEX_MODULE_EXPORT typedef basic_regex<wchar_t, regex_traits<wchar_t> > wregex;
+typedef basic_regex<wchar_t, regex_traits<wchar_t> > wregex;
 #endif
 
 } // namespace boost

include/boost/regex/v5/regex_grep.hpp

@@ -19,10 +19,6 @@
 #ifndef BOOST_REGEX_V5_REGEX_GREP_HPP
 #define BOOST_REGEX_V5_REGEX_GREP_HPP
 
-#include <boost/regex/v5/basic_regex.hpp>
-#include <boost/regex/v5/match_flags.hpp>
-#include <boost/regex/v5/match_results.hpp>
-#include <boost/regex/v5/perl_matcher.hpp>
 
 namespace boost{
 
@@ -30,7 +26,7 @@ namespace boost{
 // regex_grep:
 // find all non-overlapping matches within the sequence first last:
 //
-BOOST_REGEX_MODULE_EXPORT template <class Predicate, class BidiIterator, class charT, class traits>
+template <class Predicate, class BidiIterator, class charT, class traits>
 inline unsigned int regex_grep(Predicate foo, 
                                BidiIterator first, 
                                BidiIterator last, 
@@ -45,7 +41,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(BOOST_REGEX_DETAIL_NS::factory_find(matcher))
+   while(matcher.find())
    {
       ++count;
       if(0 == foo(m))
@@ -60,7 +56,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(BOOST_REGEX_DETAIL_NS::factory_find(matcher))
+         if(matcher.find())
          {
             ++count;
             if(0 == foo(m))
@@ -80,7 +76,7 @@ inline unsigned int regex_grep(Predicate foo,
 //
 // regex_grep convenience interfaces:
 //
-BOOST_REGEX_MODULE_EXPORT template <class Predicate, class charT, class traits>
+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 +84,7 @@ inline unsigned int regex_grep(Predicate foo, const charT* str,
    return regex_grep(foo, str, str + traits::length(str), e, flags);
 }
 
-BOOST_REGEX_MODULE_EXPORT template <class Predicate, class ST, class SA, class charT, class traits>
+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

@@ -19,11 +19,7 @@
 #ifndef BOOST_REGEX_V5_REGEX_ITERATOR_HPP
 #define BOOST_REGEX_V5_REGEX_ITERATOR_HPP
 
-#include <boost/regex/v5/basic_regex.hpp>
-#include <boost/regex/v5/match_results.hpp>
-#ifndef BOOST_REGEX_AS_MODULE
 #include <memory>
-#endif
 
 namespace boost{
 
@@ -76,7 +72,7 @@ private:
    regex_iterator_implementation& operator=(const regex_iterator_implementation&);
 };
 
-BOOST_REGEX_MODULE_EXPORT template <class BidirectionalIterator,
+template <class BidirectionalIterator, 
           class charT = typename std::iterator_traits<BidirectionalIterator>::value_type,
           class traits = regex_traits<charT> >
 class regex_iterator 
@@ -152,20 +148,20 @@ private:
    }
 };
 
-BOOST_REGEX_MODULE_EXPORT typedef regex_iterator<const char*> cregex_iterator;
-BOOST_REGEX_MODULE_EXPORT typedef regex_iterator<std::string::const_iterator> sregex_iterator;
+typedef regex_iterator<const char*> cregex_iterator;
+typedef regex_iterator<std::string::const_iterator> sregex_iterator;
 #ifndef BOOST_NO_WREGEX
-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;
+typedef regex_iterator<const wchar_t*> wcregex_iterator;
+typedef regex_iterator<std::wstring::const_iterator> wsregex_iterator;
 #endif
 
 // make_regex_iterator:
-BOOST_REGEX_MODULE_EXPORT template <class charT, class traits>
+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);
 }
-BOOST_REGEX_MODULE_EXPORT template <class charT, class traits, class ST, class SA>
+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

@@ -22,9 +22,6 @@
 #ifndef BOOST_REGEX_MATCH_HPP
 #define BOOST_REGEX_MATCH_HPP
 
-#include <boost/regex/v5/match_results.hpp>
-#include <boost/regex/v5/perl_matcher.hpp>
-
 namespace boost{
 
 //
@@ -32,16 +29,16 @@ namespace boost{
 // returns true if the specified regular expression matches
 // the whole of the input.  Fills in what matched in m.
 //
-BOOST_REGEX_MODULE_EXPORT template <class BidiIterator, class Allocator, class charT, class traits>
+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 BOOST_REGEX_DETAIL_NS::factory_match(matcher);
+   return matcher.match();
 }
-BOOST_REGEX_MODULE_EXPORT template <class iterator, class charT, class traits>
+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 +49,7 @@ bool regex_match(iterator first, iterator last,
 //
 // query_match convenience interfaces:
 //
-BOOST_REGEX_MODULE_EXPORT template <class charT, class Allocator, class traits>
+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 +58,7 @@ inline bool regex_match(const charT* str,
    return regex_match(str, str + traits::length(str), m, e, flags);
 }
 
-BOOST_REGEX_MODULE_EXPORT template <class ST, class SA, class Allocator, class charT, class traits>
+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 +66,7 @@ inline bool regex_match(const std::basic_string<charT, ST, SA>& s,
 {
    return regex_match(s.begin(), s.end(), m, e, flags);
 }
-BOOST_REGEX_MODULE_EXPORT template <class charT, class traits>
+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 +75,7 @@ inline bool regex_match(const charT* str,
    return regex_match(str, str + traits::length(str), m, e, flags | regex_constants::match_any);
 }
 
-BOOST_REGEX_MODULE_EXPORT template <class ST, class SA, class charT, class traits>
+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{
 
-BOOST_REGEX_MODULE_EXPORT template <class OutputIterator, class Iterator, class traits, class charT>
+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);
 }
 
-BOOST_REGEX_MODULE_EXPORT template <class OutputIterator, class Iterator, class traits, class charT>
+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);
 }
 
-BOOST_REGEX_MODULE_EXPORT template <class traits, class charT>
+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);
 }
 
-BOOST_REGEX_MODULE_EXPORT template <class traits, class charT>
+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,11 +25,8 @@
 #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

@@ -22,13 +22,9 @@
 #define BOOST_REGEX_V5_REGEX_REPLACE_HPP
 
 
-#include <boost/regex/v5/basic_regex.hpp>
-#include <boost/regex/v5/match_flags.hpp>
-#include <boost/regex/v5/regex_iterator.hpp>
-
 namespace boost{
 
-BOOST_REGEX_MODULE_EXPORT template <class OutputIterator, class BidirectionalIterator, class traits, class charT, class Formatter>
+template <class OutputIterator, class BidirectionalIterator, class traits, class charT, class Formatter>
 OutputIterator regex_replace(OutputIterator out,
                          BidirectionalIterator first,
                          BidirectionalIterator last,
@@ -62,7 +58,7 @@ OutputIterator regex_replace(OutputIterator out,
    return out;
 }
 
-BOOST_REGEX_MODULE_EXPORT template <class traits, class charT, class Formatter>
+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

@@ -20,12 +20,9 @@
 #define BOOST_REGEX_V5_REGEX_SEARCH_HPP
 
 
-#include <boost/regex/v5/match_results.hpp>
-#include <boost/regex/v5/perl_matcher.hpp>
-
 namespace boost{
 
-BOOST_REGEX_MODULE_EXPORT template <class BidiIterator, class Allocator, class charT, class traits>
+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 +31,7 @@ bool regex_search(BidiIterator first, BidiIterator last,
    return regex_search(first, last, m, e, flags, first);
 }
 
-BOOST_REGEX_MODULE_EXPORT template <class BidiIterator, class Allocator, class charT, class traits>
+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 +42,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 BOOST_REGEX_DETAIL_NS::factory_find(matcher);
+   return matcher.find();
 }
 
 //
 // regex_search convenience interfaces:
 //
-BOOST_REGEX_MODULE_EXPORT template <class charT, class Allocator, class traits>
+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 +57,7 @@ inline bool regex_search(const charT* str,
    return regex_search(str, str + traits::length(str), m, e, flags);
 }
 
-BOOST_REGEX_MODULE_EXPORT template <class ST, class SA, class Allocator, class charT, class traits>
+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 +66,7 @@ inline bool regex_search(const std::basic_string<charT, ST, SA>& s,
    return regex_search(s.begin(), s.end(), m, e, flags);
 }
 
-BOOST_REGEX_MODULE_EXPORT template <class BidiIterator, class charT, class traits>
+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 +77,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 BOOST_REGEX_DETAIL_NS::factory_find(matcher);
+   return matcher.find();
 }
 
-BOOST_REGEX_MODULE_EXPORT template <class charT, class traits>
+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 +88,7 @@ inline bool regex_search(const charT* str,
    return regex_search(str, str + traits::length(str), e, flags);
 }
 
-BOOST_REGEX_MODULE_EXPORT template <class ST, class SA, class charT, class traits>
+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

@@ -21,9 +21,6 @@
 #ifndef BOOST_REGEX_SPLIT_HPP
 #define BOOST_REGEX_SPLIT_HPP
 
-#include <boost/regex/v5/basic_regex.hpp>
-#include <boost/regex/v5/match_results.hpp>
-
 namespace boost{
 
 #ifdef BOOST_REGEX_MSVC
@@ -93,7 +90,7 @@ bool split_pred<OutputIterator, charT, Traits1, Alloc1>::operator()
 
 } // namespace BOOST_REGEX_DETAIL_NS
 
-BOOST_REGEX_MODULE_EXPORT template <class OutputIterator, class charT, class Traits1, class Alloc1, class Traits2>
+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 +125,7 @@ std::size_t regex_split(OutputIterator out,
    return init_size - max_split;
 }
 
-BOOST_REGEX_MODULE_EXPORT template <class OutputIterator, class charT, class Traits1, class Alloc1, class Traits2>
+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 +134,7 @@ inline std::size_t regex_split(OutputIterator out,
    return regex_split(out, s, e, flags, UINT_MAX);
 }
 
-BOOST_REGEX_MODULE_EXPORT template <class OutputIterator, class charT, class Traits1, class Alloc1>
+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

@@ -19,12 +19,7 @@
 #ifndef BOOST_REGEX_V5_REGEX_TOKEN_ITERATOR_HPP
 #define BOOST_REGEX_V5_REGEX_TOKEN_ITERATOR_HPP
 
-#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{
 
@@ -125,7 +120,7 @@ private:
    regex_token_iterator_implementation& operator=(const regex_token_iterator_implementation&);
 };
 
-BOOST_REGEX_MODULE_EXPORT template <class BidirectionalIterator,
+template <class BidirectionalIterator, 
           class charT = typename std::iterator_traits<BidirectionalIterator>::value_type,
           class traits = regex_traits<charT> >
 class regex_token_iterator 
@@ -213,39 +208,39 @@ private:
    }
 };
 
-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;
+typedef regex_token_iterator<const char*> cregex_token_iterator;
+typedef regex_token_iterator<std::string::const_iterator> sregex_token_iterator;
 #ifndef BOOST_NO_WREGEX
-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;
+typedef regex_token_iterator<const wchar_t*> wcregex_token_iterator;
+typedef regex_token_iterator<std::wstring::const_iterator> wsregex_token_iterator;
 #endif
 
-BOOST_REGEX_MODULE_EXPORT template <class charT, class traits>
+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);
 }
-BOOST_REGEX_MODULE_EXPORT template <class charT, class traits, class ST, class SA>
+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);
 }
-BOOST_REGEX_MODULE_EXPORT template <class charT, class traits, std::size_t N>
+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);
 }
-BOOST_REGEX_MODULE_EXPORT template <class charT, class traits, class ST, class SA, std::size_t N>
+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);
 }
-BOOST_REGEX_MODULE_EXPORT template <class charT, class traits>
+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);
 }
-BOOST_REGEX_MODULE_EXPORT template <class charT, class traits, class ST, class SA>
+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{
 
-BOOST_REGEX_MODULE_EXPORT template <class charT, class implementationT >
+template <class charT, class implementationT >
 struct regex_traits : public implementationT
 {
    regex_traits() : implementationT() {}

include/boost/regex/v5/regex_traits_defaults.hpp

@@ -24,14 +24,12 @@
 #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,11 +20,9 @@
 #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

@@ -19,13 +19,6 @@
 #ifndef BOOST_REGEX_V5_STATES_HPP
 #define BOOST_REGEX_V5_STATES_HPP
 
-#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,14 +19,9 @@
 #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{
 
-BOOST_REGEX_MODULE_EXPORT template <class BidiIterator>
+template <class BidiIterator>
 struct sub_match : public std::pair<BidiIterator, BidiIterator>
 {
    typedef typename std::iterator_traits<BidiIterator>::value_type       value_type;
@@ -150,167 +145,167 @@ public:
    BidiIterator end()const { return this->second; }
 };
 
-BOOST_REGEX_MODULE_EXPORT typedef sub_match<const char*> csub_match;
-BOOST_REGEX_MODULE_EXPORT typedef sub_match<std::string::const_iterator> ssub_match;
+typedef sub_match<const char*> csub_match;
+typedef sub_match<std::string::const_iterator> ssub_match;
 #ifndef BOOST_NO_WREGEX
-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;
+typedef sub_match<const wchar_t*> wcsub_match;
+typedef sub_match<std::wstring::const_iterator> wssub_match;
 #endif
 
 // comparison to std::basic_string<> part 1:
-BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator, class traits, class Allocator>
+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; }
-BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator, class traits, class Allocator>
+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; }
-BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator, class traits, class Allocator>
+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; }
-BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator, class traits, class Allocator>
+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; }
-BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator, class traits, class Allocator>
+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; }
-BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator, class traits, class Allocator>
+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:
-BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator, class traits, class Allocator>
+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; }
-BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator, class traits, class Allocator>
+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; }
-BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator, class traits, class Allocator>
+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; }
-BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator, class traits, class Allocator>
+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; }
-BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator, class traits, class Allocator>
+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; }
-BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator, class traits, class Allocator>
+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:
-BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
+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; }
-BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
+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; }
-BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
+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; }
-BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
+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; }
-BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
+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; }
-BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
+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:
-BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
+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; }
-BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
+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; }
-BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
+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; }
-BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
+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; }
-BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
+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; }
-BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
+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:
-BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
+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; }
-BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
+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; }
-BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
+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; }
-BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
+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; }
-BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
+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; }
-BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
+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:
-BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
+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; }
-BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
+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; }
-BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
+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; }
-BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
+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; }
-BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
+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; }
-BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
+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:
-BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator, class traits, class Allocator>
+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)
@@ -319,7 +314,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);
 }
-BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator, class traits, class Allocator>
+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)
@@ -328,7 +323,7 @@ operator + (const sub_match<RandomAccessIterator>& m,
    result.reserve(s.size() + m.length() + 1);
    return result.append(m.first, m.second).append(s);
 }
-BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
+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)
@@ -337,7 +332,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);
 }
-BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
+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)
@@ -346,7 +341,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);
 }
-BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
+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)
@@ -355,7 +350,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);
 }
-BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
+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)
@@ -364,7 +359,7 @@ operator + (const sub_match<RandomAccessIterator>& m,
    result.reserve(m.length() + 2);
    return result.append(m.first, m.second).append(1, s);
 }
-BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
+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)
@@ -373,7 +368,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);
 }
-BOOST_REGEX_MODULE_EXPORT template <class charT, class traits, class RandomAccessIterator>
+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,86 +19,84 @@
 #ifndef BOOST_REGEX_SYNTAX_TYPE_HPP
 #define BOOST_REGEX_SYNTAX_TYPE_HPP
 
-#include <boost/regex/config.hpp>
-
 namespace boost{
 namespace regex_constants{
 
-BOOST_REGEX_MODULE_EXPORT typedef unsigned char syntax_type;
+typedef unsigned char syntax_type;
 
 //
 // values chosen are binary compatible with previous version:
 //
-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;
+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;
 
 // extensions:
 
-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;
+static const syntax_type syntax_hash = 13;
+static const syntax_type syntax_newline = 26;
 
 // escapes:
 
-BOOST_REGEX_MODULE_EXPORT typedef syntax_type escape_syntax_type;
+typedef syntax_type escape_syntax_type;
 
-BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_word_assert = 18;
-BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_not_word_assert = 19;
-BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_control_f = 29;
-BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_control_n = 30;
-BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_control_r = 31;
-BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_control_t = 32;
-BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_control_v = 33;
-BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_ascii_control = 35;
-BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_hex = 34;
-BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_unicode = 0; // not used
-BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_identity = 0; // not used
-BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_backref = syntax_digit;
-BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_decimal = syntax_digit; // not used
-BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_class = 22; 
-BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_not_class = 23; 
+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; 
 
 // extensions:
 
-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_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_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 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 syntax_max = 60;
+static const escape_syntax_type syntax_max = 60;
 
 }
 }

include/boost/regex/v5/u32regex_iterator.hpp

@@ -19,21 +19,6 @@
 #ifndef BOOST_REGEX_V5_U32REGEX_ITERATOR_HPP
 #define BOOST_REGEX_V5_U32REGEX_ITERATOR_HPP
 
-#include <boost/regex/config.hpp>
-
-#ifndef BOOST_REGEX_STANDALONE
-
-#include <boost/config.hpp>
-#if defined(BOOST_HAS_PRAGMA_ONCE)
-#pragma once
-#include <boost/regex/v5/icu.hpp>
-#endif
-
-#endif
-
-#include <boost/regex/v5/match_flags.hpp>
-#include <boost/regex/v5/match_results.hpp>
-
 namespace boost{
 
 template <class BidirectionalIterator>

include/boost/regex/v5/u32regex_token_iterator.hpp

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

include/boost/regex/v5/unicode_iterator.hpp

@@ -60,14 +60,12 @@ 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 <boost/regex/config.hpp>
-#ifndef BOOST_REGEX_AS_MODULE
 #include <cstdint>
+#include <boost/regex/config.hpp>
 #include <stdexcept>
 #include <sstream>
 #include <ios>
 #include <limits.h> // CHAR_BIT
-#endif
 
 #ifndef BOOST_REGEX_STANDALONE
 #include <boost/throw_exception.hpp>
@@ -77,9 +75,9 @@ namespace boost{
 
 namespace detail{
 
-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;
+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;
 
 inline bool is_high_surrogate(std::uint16_t v)
 {

include/boost/regex/v5/w32_regex_traits.hpp

@@ -23,11 +23,9 @@
 
 #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>
 
@@ -654,7 +652,7 @@ std::shared_ptr<const w32_regex_traits_implementation<charT> > create_w32_regex_
 
 } // BOOST_REGEX_DETAIL_NS
 
-BOOST_REGEX_MODULE_EXPORT template <class charT>
+template <class charT>
 class w32_regex_traits
 {
 public:

module/regex.cxx

@@ -1,103 +0,0 @@
-
-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

@@ -1,11 +0,0 @@
-
-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

@@ -1,11 +0,0 @@
-
-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

@@ -1,30 +0,0 @@
-
-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

@@ -1,30 +0,0 @@
-
-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

@@ -1,25 +0,0 @@
-
-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

@@ -1,25 +0,0 @@
-
-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

@@ -1,25 +0,0 @@
-
-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

@@ -1,25 +0,0 @@
-
-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

@@ -1,25 +0,0 @@
-
-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

@@ -1,25 +0,0 @@
-
-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

@@ -1,11 +0,0 @@
-
-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

@@ -1,11 +0,0 @@
-
-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

@@ -1,25 +0,0 @@
-
-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

@@ -1,25 +0,0 @@
-
-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

@@ -136,9 +136,3 @@ 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

@@ -1,99 +0,0 @@
-/*
- *
- * 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

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