Sync from upstream.

.github/workflows/ci.yml

@@ -13,12 +13,12 @@ on:
   release:
     types: [published, created, edited]
 jobs:
-  ubuntu-focal:
+  ubuntu-jammy:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
     strategy:
       fail-fast: false
       matrix:
-        compiler: [ g++-9, g++-10, clang++-9, clang++-10 ]
+        compiler: [ g++-11, g++-12, g++-13 ]
         standard: [ c++11, c++14, c++17, c++2a ]
     steps:
       - uses: actions/checkout@v2
@@ -34,7 +34,7 @@ jobs:
       - name: Add repository
         run: sudo apt-add-repository -y "ppa:ubuntu-toolchain-r/test"
       - name: Install packages
-        run: sudo apt install g++-9 g++-10 clang-9 clang-10  libicu-dev
+        run: sudo apt install g++-11 g++-12 g++-13
       - name: Checkout main boost
         run: git clone -b develop --depth 1 https://github.com/boostorg/boost.git ../boost-root
       - name: Update tools/boostdep
@@ -55,11 +55,8 @@ jobs:
       - name: Generate user config
         run: 'echo "using $TOOLSET : : ${{ matrix.compiler }} : <cxxflags>-std=${{ matrix.standard }} ;" > ~/user-config.jam'
         working-directory: ../boost-root
-      - name: Config info install
-        run: ../../../b2 config_info_travis_install toolset=$TOOLSET
-        working-directory: ../boost-root/libs/config/test
       - name: Config info
-        run: ./config_info_travis
+        run: ../../../b2 print_config_info toolset=$TOOLSET
         working-directory: ../boost-root/libs/config/test
       - name: Test
         run: ../../../b2 toolset=$TOOLSET
@@ -89,12 +86,12 @@ jobs:
       - name: Test
         run: ${{ matrix.compiler }} -std=${{ matrix.standard }}  -I../../include *.cpp ../../src/*.cpp -o regress && ./regress
         working-directory: ./test/regress
-  ubuntu-bionic:
+  ubuntu-jammy-clang:
-    runs-on: ubuntu-18.04
+    runs-on: ubuntu-22.04
     strategy:
       fail-fast: false
       matrix:
-        compiler: [ g++-7, g++-8, clang++-7, clang++-8 ]
+        compiler: [ clang++-15 ]
         standard: [ c++11, c++14, c++17 ]
     steps:
       - uses: actions/checkout@v2
@@ -110,7 +107,7 @@ jobs:
       - name: Add repository
         run: sudo apt-add-repository -y "ppa:ubuntu-toolchain-r/test"
       - name: Install packages
-        run: sudo apt install g++-7 g++-8 clang-7 clang-8 libicu-dev
+        run: sudo apt install clang-15
       - name: Checkout main boost
         run: git clone -b develop --depth 1 https://github.com/boostorg/boost.git ../boost-root
       - name: Update tools/boostdep
@@ -131,11 +128,8 @@ jobs:
       - name: Generate user config
         run: 'echo "using $TOOLSET : : ${{ matrix.compiler }} : <cxxflags>-std=${{ matrix.standard }} ;" > ~/user-config.jam'
         working-directory: ../boost-root
-      - name: Config info install
-        run: ../../../b2 config_info_travis_install toolset=$TOOLSET
-        working-directory: ../boost-root/libs/config/test
       - name: Config info
-        run: ./config_info_travis
+        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

example/timer/regex_timer.cpp

@@ -13,6 +13,8 @@
 #pragma warning(disable: 4996 4127)
 #endif
 
+#define BOOST_TIMER_ENABLE_DEPRECATED
+
 #include <boost/config.hpp>
 #include <boost/regex.hpp>
 #include <boost/cregex.hpp>

include/boost/regex/concepts.hpp

@@ -127,6 +127,9 @@ bool operator == (const allocator_architype<T>&, const allocator_architype<T>&)
 template <class T>
 bool operator != (const allocator_architype<T>&, const allocator_architype<T>&) { return false; }
 
+template <class T>
+void consume_type() {}
+
 namespace boost{
 //
 // regex_traits_architype:
@@ -371,6 +374,8 @@ struct BaseRegexConcept
       e1 = except.code();
 
       typedef typename Regex::value_type regex_value_type;
+      regex_value_type val{};
+      ignore_unused_variable_warning(val);
       function_requires< RegexTraitsConcept<global_regex_namespace::regex_traits<char> > >();
       function_requires< BaseRegexConcept<global_regex_namespace::basic_regex<char> > >();
    }
@@ -446,15 +451,25 @@ struct BaseRegexConcept
       // match_results tests - some typedefs are not used, however these
       // guarante that they exist (some compilers may warn on non-usage)
       typedef typename match_results_type::value_type mr_value_type;
+      consume_type<mr_value_type>();
       typedef typename match_results_type::const_reference mr_const_reference;
+      consume_type<mr_const_reference>();
       typedef typename match_results_type::reference mr_reference;
+      consume_type<mr_reference>();
       typedef typename match_results_type::const_iterator mr_const_iterator;
+      consume_type<mr_const_iterator>();
       typedef typename match_results_type::iterator mr_iterator;
+      consume_type<mr_iterator>();
       typedef typename match_results_type::difference_type mr_difference_type;
+      consume_type<mr_difference_type>();
       typedef typename match_results_type::size_type mr_size_type;
+      consume_type<mr_size_type>();
       typedef typename match_results_type::allocator_type mr_allocator_type;
+      consume_type<mr_allocator_type>();
       typedef typename match_results_type::char_type mr_char_type;
+      consume_type<mr_char_type>();
       typedef typename match_results_type::string_type mr_string_type;
+      consume_type<mr_string_type>();
 
       match_results_type m1;
       mr_allocator_type at;

include/boost/regex/config.hpp

@@ -90,6 +90,8 @@
 #  endif
 #endif
 
+#define BOOST_REGEX_MAX_RECURSION_DEPTH 100
+
 
 /****************************************************************************
 *

include/boost/regex/user.hpp

@@ -93,3 +93,7 @@
 
 // define this if you want regex to use __cdecl calling convensions, even when __fastcall is available:
 // #define BOOST_REGEX_NO_FASTCALL
+
+// define this to control how deep non-avoidable recursive function calls can go, typical expressions 
+// and format strings should only recurse a handful of times, this is mainly to prevent DOS type attacks.
+// #define BOOST_REGEX_MAX_RECURSION_DEPTH 100

include/boost/regex/v5/basic_regex_creator.hpp

@@ -248,7 +248,7 @@ private:
    void fixup_recursions(re_syntax_base* state);
    void create_startmaps(re_syntax_base* state);
    int calculate_backstep(re_syntax_base* state);
-   void create_startmap(re_syntax_base* state, unsigned char* l_map, unsigned int* pnull, unsigned char mask);
+   void create_startmap(re_syntax_base* state, unsigned char* l_map, unsigned int* pnull, unsigned char mask, unsigned recursion_count = 0);
    unsigned get_restart_type(re_syntax_base* state);
    void set_all_masks(unsigned char* bits, unsigned char);
    bool is_bad_repeat(re_syntax_base* pt);
@@ -1074,7 +1074,7 @@ struct recursion_saver
 };
 
 template <class charT, class traits>
-void basic_regex_creator<charT, traits>::create_startmap(re_syntax_base* state, unsigned char* l_map, unsigned int* pnull, unsigned char mask)
+void basic_regex_creator<charT, traits>::create_startmap(re_syntax_base* state, unsigned char* l_map, unsigned int* pnull, unsigned char mask, unsigned recursion_count)
 {
    recursion_saver saved_recursions(&m_recursion_checks);
    int not_last_jump = 1;
@@ -1085,6 +1085,28 @@ void basic_regex_creator<charT, traits>::create_startmap(re_syntax_base* state,
    // track case sensitivity:
    bool l_icase = m_icase;
 
+   if (recursion_count > BOOST_REGEX_MAX_RECURSION_DEPTH)
+   {
+      // Oops error:
+      if (0 == this->m_pdata->m_status) // update the error code if not already set
+         this->m_pdata->m_status = boost::regex_constants::error_complexity;
+      //
+      // clear the expression, we should be empty:
+      //
+      this->m_pdata->m_expression = 0;
+      this->m_pdata->m_expression_len = 0;
+      //
+      // and throw if required:
+      //
+      if (0 == (this->flags() & regex_constants::no_except))
+      {
+         std::string message = "Expression complexity exceeded.";
+         boost::regex_error e(message, boost::regex_constants::error_complexity, 0);
+         e.raise();
+      }
+      return;
+   }
+
    while(state)
    {
       switch(state->type)
@@ -1122,7 +1144,7 @@ void basic_regex_creator<charT, traits>::create_startmap(re_syntax_base* state,
          }
          // now figure out if we can match a NULL string at this point:
          if(pnull)
-            create_startmap(state->next.p, 0, pnull, mask);
+            create_startmap(state->next.p, 0, pnull, mask, ++recursion_count);
          return;
       }
       case syntax_element_recurse:
@@ -1184,7 +1206,7 @@ void basic_regex_creator<charT, traits>::create_startmap(re_syntax_base* state,
       case syntax_element_word_start:
       {
          // recurse, then AND with all the word characters:
-         create_startmap(state->next.p, l_map, pnull, mask);
+         create_startmap(state->next.p, l_map, pnull, mask, ++recursion_count);
          if(l_map)
          {
             l_map[0] |= mask_init;
@@ -1199,7 +1221,7 @@ void basic_regex_creator<charT, traits>::create_startmap(re_syntax_base* state,
       case syntax_element_word_end:
       {
          // recurse, then AND with all the word characters:
-         create_startmap(state->next.p, l_map, pnull, mask);
+         create_startmap(state->next.p, l_map, pnull, mask, ++recursion_count);
          if(l_map)
          {
             l_map[0] |= mask_init;
@@ -1291,11 +1313,11 @@ void basic_regex_creator<charT, traits>::create_startmap(re_syntax_base* state,
                   return;
                }
                set_bad_repeat(state);
-               create_startmap(state->next.p, l_map, pnull, mask);
+               create_startmap(state->next.p, l_map, pnull, mask, ++recursion_count);
                if((state->type == syntax_element_alt)
                   || (static_cast<re_repeat*>(state)->min == 0)
                   || (not_last_jump == 0))
-                  create_startmap(rep->alt.p, l_map, pnull, mask);
+                  create_startmap(rep->alt.p, l_map, pnull, mask, ++recursion_count);
             }
          }
          return;
@@ -1354,7 +1376,7 @@ void basic_regex_creator<charT, traits>::create_startmap(re_syntax_base* state,
             if(ok && ((m_recursion_checks[static_cast<re_brace*>(state)->index] & 2u) == 0))
             {
                m_recursion_checks[static_cast<re_brace*>(state)->index] |= 2u;
-               create_startmap(p->next.p, l_map, pnull, mask);
+               create_startmap(p->next.p, l_map, pnull, mask, ++recursion_count);
             }
          }
          state = state->next.p;

include/boost/regex/v5/regex_format.hpp

@@ -97,11 +97,11 @@ private:
 
    void put(char_type c);
    void put(const sub_match_type& sub);
-   void format_all();
+   void format_all(unsigned recursion_count = 0);
    void format_perl();
    void format_escape();
-   void format_conditional();
+   void format_conditional(unsigned recursion_count);
-   void format_until_scope_end();
+   void format_until_scope_end(unsigned recursion_count);
    bool handle_perl_verb(bool have_brace);
 
    inline typename Results::value_type const& get_named_sub(ForwardIter i, ForwardIter j, const std::integral_constant<bool, false>&)
@@ -199,7 +199,7 @@ OutputIterator basic_regex_formatter<OutputIterator, Results, traits, ForwardIte
 }
 
 template <class OutputIterator, class Results, class traits, class ForwardIter>
-void basic_regex_formatter<OutputIterator, Results, traits, ForwardIter>::format_all()
+void basic_regex_formatter<OutputIterator, Results, traits, ForwardIter>::format_all(unsigned recursion_count)
 {
    // over and over:
    while(m_position != m_end)
@@ -219,12 +219,12 @@ void basic_regex_formatter<OutputIterator, Results, traits, ForwardIter>::format
          format_escape();
          break;
       case '(':
-         if(m_flags & boost::regex_constants::format_all)
+         if((m_flags & boost::regex_constants::format_all) && (recursion_count < BOOST_REGEX_MAX_RECURSION_DEPTH))
          {
             ++m_position;
             bool have_conditional = m_have_conditional;
             m_have_conditional = false;
-            format_until_scope_end();
+            format_until_scope_end(recursion_count);
             m_have_conditional = have_conditional;
             if(m_position == m_end)
                return;
@@ -252,10 +252,10 @@ void basic_regex_formatter<OutputIterator, Results, traits, ForwardIter>::format
          ++m_position;
          break;
       case '?':
-         if(m_flags & boost::regex_constants::format_all)
+         if((m_flags & boost::regex_constants::format_all) && (recursion_count < BOOST_REGEX_MAX_RECURSION_DEPTH))
          {
             ++m_position;
-            format_conditional();
+            format_conditional(recursion_count);
             break;
          }
          put(*m_position);
@@ -644,7 +644,7 @@ void basic_regex_formatter<OutputIterator, Results, traits, ForwardIter>::format
 }
 
 template <class OutputIterator, class Results, class traits, class ForwardIter>
-void basic_regex_formatter<OutputIterator, Results, traits, ForwardIter>::format_conditional()
+void basic_regex_formatter<OutputIterator, Results, traits, ForwardIter>::format_conditional(unsigned recursion_count)
 {
    if(m_position == m_end)
    {
@@ -692,7 +692,7 @@ void basic_regex_formatter<OutputIterator, Results, traits, ForwardIter>::format
    if(m_results[v].matched)
    {
       m_have_conditional = true;
-      format_all();
+      format_all(++recursion_count);
       m_have_conditional = false;
       if((m_position != m_end) && (*m_position == static_cast<char_type>(':')))
       {
@@ -702,7 +702,7 @@ void basic_regex_formatter<OutputIterator, Results, traits, ForwardIter>::format
          output_state saved_state = m_state;
          m_state = output_none;
          // format the rest of this scope:
-         format_until_scope_end();
+         format_until_scope_end(recursion_count);
          // restore output state:
          m_state = saved_state;
       }
@@ -714,7 +714,7 @@ void basic_regex_formatter<OutputIterator, Results, traits, ForwardIter>::format
       m_state = output_none;
       // format until ':' or ')':
       m_have_conditional = true;
-      format_all();
+      format_all(++recursion_count);
       m_have_conditional = false;
       // restore state:
       m_state = saved_state;
@@ -723,17 +723,17 @@ void basic_regex_formatter<OutputIterator, Results, traits, ForwardIter>::format
          // skip the ':':
          ++m_position;
          // format the rest of this scope:
-         format_until_scope_end();
+         format_until_scope_end(recursion_count);
       }
    }
 }
 
 template <class OutputIterator, class Results, class traits, class ForwardIter>
-void basic_regex_formatter<OutputIterator, Results, traits, ForwardIter>::format_until_scope_end()
+void basic_regex_formatter<OutputIterator, Results, traits, ForwardIter>::format_until_scope_end(unsigned recursion_count)
 {
    do
    {
-      format_all();
+      format_all(++recursion_count);
       if((m_position == m_end) || (*m_position == static_cast<char_type>(')')))
          return;
       put(*m_position++);

include/boost/regex/v5/u32regex_iterator.hpp

@@ -35,6 +35,7 @@ class u32regex_iterator_implementation
 public:
    u32regex_iterator_implementation(const regex_type* p, BidirectionalIterator last, match_flag_type f)
       : base(), end(last), re(*p), flags(f){}
+   u32regex_iterator_implementation(const u32regex_iterator_implementation&) = default;
    bool init(BidirectionalIterator first)
    {
       base = first;

test/Jamfile.v2

@@ -80,155 +80,60 @@ lib boost_regex_recursive :
 
 local regress-sources = regress/$(R_SOURCE) ;
 
-test-suite regex
+run regress/$(R_SOURCE) ../build//boost_regex ../build//icu_options
-      : 
+   : # command line
-      [ run regress/$(R_SOURCE) /boost/regex//boost_regex ../build//icu_options
+   : # input files
-        : # command line
+   : # requirements
-        : # input files
+   : regex_regress ;
-        : # requirements
-        : regex_regress ]
 
-      [ run regress/$(R_SOURCE) /boost/regex//boost_regex
+run regress/$(R_SOURCE) ../build//boost_regex
-                                /boost/thread//boost_thread ../build//icu_options
+                           /boost/thread//boost_thread ../build//icu_options
-        : # command line
+   : # command line
-        : # input files
+   : # input files
-        : # requirements
+   : # requirements
-        <define>TEST_THREADS
+   <define>TEST_THREADS
-        : regex_regress_threaded ]
+   : regex_regress_threaded ;
 
-      [ run regress/$(R_SOURCE) /boost/regex//boost_regex
+run regress/$(R_SOURCE) ../build//boost_regex
-                                /boost/thread//boost_thread ../build//icu_options
+                           /boost/thread//boost_thread ../build//icu_options
-        : # command line
+   : # command line
-        : # input files
+   : # input files
-        : # requirements
+   : # requirements
-        <define>TEST_THREADS
+   <define>TEST_THREADS
-        <define>BOOST_REGEX_MAX_CACHE_BLOCKS=0
+   <define>BOOST_REGEX_MAX_CACHE_BLOCKS=0
-        : regex_regress_threaded_no_cache ]
+   : regex_regress_threaded_no_cache ;
-
-      [ regex-test posix_api_check : c_compiler_checks/posix_api_check.c ]
-
-      [ compile c_compiler_checks/wide_posix_api_check.c 
-        : : wide_posix_api_check_c ]
-
-      [ regex-test posix_api_check_cpp : c_compiler_checks/posix_api_check.cpp ]
-
-      [ regex-test wide_posix_api_check_cpp 
-          : c_compiler_checks/wide_posix_api_check.cpp ]
-
-      [ run pathology/bad_expression_test.cpp : : :
-            [ check-target-builds ../build//is_legacy_03 : : <source>/boost/regex//boost_regex ]
-      ]
-
-      [ run pathology/recursion_test.cpp : : :
-            [ check-target-builds ../build//is_legacy_03 : : <source>/boost/regex//boost_regex ]
-      ]
-      
-      [ run named_subexpressions/named_subexpressions_test.cpp : : :
-            [ check-target-builds ../build//is_legacy_03 : : <source>/boost/regex//boost_regex ]
-      ]
-      
-      [ run unicode/unicode_iterator_test.cpp : : : 
-            [ check-target-builds ../build//is_legacy_03 : : <source>/boost/regex//boost_regex ]
-            release <define>TEST_UTF8 : unicode_iterator_test_utf8 ]
-      [ run unicode/unicode_iterator_test.cpp : : : 
-            [ check-target-builds ../build//is_legacy_03 : : <source>/boost/regex//boost_regex ]
-            release <define>TEST_UTF16 : unicode_iterator_test_utf16 ]
-      [ run unicode/unicode_casefold_test.cpp 
-            /boost/regex//boost_regex ../build//icu_options
-      ]
-      [ run static_mutex/static_mutex_test.cpp
-            /boost/thread//boost_thread /boost/regex//boost_regex
-            /boost/timer//boost_timer
-            : : : <define>BOOST_TIMER_ENABLE_DEPRECATED
-      ]
-      [ run object_cache/object_cache_test.cpp : : :
-            [ check-target-builds ../build//is_legacy_03 : : <source>/boost/regex//boost_regex ]
-      ]
-      
-      [ run config_info/regex_config_info.cpp 
-         /boost/regex//boost_regex/<link>static 
-         : # command line
-         : # input files
-         : <test-info>always_show_run_output
-           <use>/boost/config//testing
-      ]
-      [ run config_info/regex_config_info.cpp /boost/regex//boost_regex 
-        : # command line
-        : # input files
-        : <test-info>always_show_run_output
-          <use>/boost/config//testing
-        : regex_dll_config_info
-      ]
-
-      [ run collate_info/collate_info.cpp /boost/regex//boost_regex
-      : : : <test-info>always_show_run_output : test_collate_info ]
-
-
-      [ link concepts/concept_check.cpp :
-            [ check-target-builds ../build//is_legacy_03 : : <source>/boost/regex//boost_regex ]
-      ]
-      [ link concepts/concept_check.cpp :
-            <define>BOOST_REGEX_STANDALONE [ check-target-builds ../build//is_legacy_03 : : <build>no ] : standalone_concept_check
-      ]
-      [ link concepts/icu_concept_check.cpp :
-            <define>BOOST_REGEX_STANDALONE [ check-target-builds ../build//is_legacy_03 : : <source>/boost/regex//boost_regex ]
-      ]
-      [ link concepts/icu_concept_check.cpp :
-            [ check-target-builds ../build//is_legacy_03 : : <build>no ] : standalone_icu_concept_check
-      ]
-      [ link concepts/range_concept_check.cpp :
-            [ check-target-builds ../build//is_legacy_03 : : <source>/boost/regex//boost_regex ]
-             <source>/boost/range//boost_range
-      ]
-      [ run concepts/test_bug_11988.cpp : : :
-            [ check-target-builds ../build//is_legacy_03 : : <source>/boost/regex//boost_regex ]
-      ]
-      
-     [ run
-    # sources
-    captures/captures_test.cpp
-    ../build//icu_options
- :  # additional args
- :  # test-files
- :  # requirements
-    <source>/boost/array//boost_array
-    <threading>multi
-    <define>BOOST_REGEX_MATCH_EXTRA=1
-    <define>BOOST_REGEX_NO_LIB=1
-    [ check-target-builds ../build//is_legacy_03 : : <source>/boost/regex//boost_regex ]
- :  # test name
-    captures_test
- ]
-
- [ run regress/$(R_SOURCE) .//boost_regex_recursive
-                          ../build//icu_options
-  : # command line
-  : # input files
-  : # requirements
-    <define>BOOST_REGEX_RECURSIVE=1
-    <define>BOOST_REGEX_CXX03=1
-  : regex_regress_recursive ]
-
-[ run regress/$(R_SOURCE) ./noeh_test//boost_regex_noeh
-                          ../build//icu_options
-  : # command line
-  : # input files
-  : # requirements
-    <define>BOOST_NO_EXCEPTIONS=1
-    <exception-handling>off
-    <link>static
-    <runtime-link>shared
-  : regex_regress_noeh ]
-
-;
 
+regex-test posix_api_check : c_compiler_checks/posix_api_check.c ;
+compile c_compiler_checks/wide_posix_api_check.c  : : wide_posix_api_check_c ;
+regex-test posix_api_check_cpp : c_compiler_checks/posix_api_check.cpp ;
+regex-test wide_posix_api_check_cpp  : c_compiler_checks/wide_posix_api_check.cpp ;
+run pathology/bad_expression_test.cpp : : : [ check-target-builds ../build//is_legacy_03 : : <source>../build//boost_regex ] ;
+run pathology/recursion_test.cpp : : : [ check-target-builds ../build//is_legacy_03 : : <source>../build//boost_regex ] ;
+run named_subexpressions/named_subexpressions_test.cpp : : : [ check-target-builds ../build//is_legacy_03 : : <source>../build//boost_regex ] ;
+run unicode/unicode_iterator_test.cpp : : : [ check-target-builds ../build//is_legacy_03 : : <source>../build//boost_regex ] release <define>TEST_UTF8 : unicode_iterator_test_utf8 ;
+run unicode/unicode_iterator_test.cpp : : : [ check-target-builds ../build//is_legacy_03 : : <source>../build//boost_regex ] release <define>TEST_UTF16 : unicode_iterator_test_utf16 ;
+run unicode/unicode_casefold_test.cpp  ../build//boost_regex ../build//icu_options ;
+run static_mutex/static_mutex_test.cpp /boost/thread//boost_thread ../build//boost_regex ;
+run object_cache/object_cache_test.cpp : : : [ check-target-builds ../build//is_legacy_03 : : <source>../build//boost_regex ] ;
+run config_info/regex_config_info.cpp  ../build//boost_regex/<link>static : : : <test-info>always_show_run_output ;
+run config_info/regex_config_info.cpp ../build//boost_regex : : : <test-info>always_show_run_output : regex_dll_config_info ;    
+run collate_info/collate_info.cpp ../build//boost_regex : : : <test-info>always_show_run_output : test_collate_info ;
+link concepts/concept_check.cpp : [ check-target-builds ../build//is_legacy_03 : : <source>../build//boost_regex ] <toolset>gcc:<cxxflags>-Wno-deprecated-copy ;
+link concepts/concept_check.cpp : <define>BOOST_REGEX_STANDALONE [ check-target-builds ../build//is_legacy_03 : : <build>no ] <toolset>gcc:<cxxflags>-Wno-deprecated-copy : standalone_concept_check ;
+link concepts/icu_concept_check.cpp : <define>BOOST_REGEX_STANDALONE [ check-target-builds ../build//is_legacy_03 : : <source>../build//boost_regex ] <toolset>gcc:<cxxflags>-Wno-deprecated-copy ;
+link concepts/icu_concept_check.cpp : [ check-target-builds ../build//is_legacy_03 : : <build>no ] <toolset>gcc:<cxxflags>-Wno-deprecated-copy : standalone_icu_concept_check ;
+link concepts/range_concept_check.cpp : [ check-target-builds ../build//is_legacy_03 : : <source>../build//boost_regex ] <toolset>gcc:<cxxflags>-Wno-deprecated-copy ;
+run concepts/test_bug_11988.cpp : : : [ check-target-builds ../build//is_legacy_03 : : <source>../build//boost_regex ] ;      
+run captures/captures_test.cpp ../build//icu_options : : : <threading>multi <define>BOOST_REGEX_MATCH_EXTRA=1 <define>BOOST_REGEX_NO_LIB=1 
+      [ check-target-builds ../build//is_legacy_03 : : <source>../build//boost_regex ] : captures_test ;
+run regress/$(R_SOURCE) .//boost_regex_recursive ../build//icu_options : : : <define>BOOST_REGEX_RECURSIVE=1 <define>BOOST_REGEX_CXX03=1 : regex_regress_recursive ;
+run regress/$(R_SOURCE) ./noeh_test//boost_regex_noeh ../build//icu_options : : : <define>BOOST_NO_EXCEPTIONS=1 <exception-handling>off <link>static <runtime-link>shared : regex_regress_noeh ;
 compile test_consolidated.cpp ;
 
 build-project ../example ;
 
 # `quick` target (for CI)
-run quick.cpp /boost/regex//boost_regex ;
+run quick.cpp ../build//boost_regex ;
-
 compile test_warnings.cpp 
    :     <toolset>msvc:<warnings>all <toolset>msvc:<warnings-as-errors>on
          <toolset>gcc:<warnings>all <toolset>gcc:<warnings-as-errors>on

test/regress/test_alt.cpp

@@ -51,5 +51,9 @@ void test_alt()
    TEST_REGEX_SEARCH("a\nb", grep, "a", match_default, make_array(0, 1, -2, -2));
    TEST_REGEX_SEARCH("a\nb", egrep, "b", match_default, make_array(0, 1, -2, -2));
    TEST_REGEX_SEARCH("a\nb", egrep, "a", match_default, make_array(0, 1, -2, -2));
+   // DOS protection:
+#ifndef BOOST_REGEX_RECURSIVE
+   TEST_INVALID_REGEX("(|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||(?0))", perl);
+#endif
 }
 

test/regress/test_anchors.cpp

@@ -62,6 +62,10 @@ void test_anchors()
 #if !BOOST_WORKAROUND(BOOST_BORLANDC, < 0x560)
    TEST_REGEX_SEARCH_W(L"^.", boost::regex::extended, L"\x2028 \x2028", match_default, make_array(0, 1, -2, 1, 2, -2, -2));
    TEST_REGEX_SEARCH_W(L".$", boost::regex::extended, L" \x2028 \x2028", match_default, make_array(0, 1, -2, 2, 3, -2, 3, 4, -2, -2));
+#endif
+   // DOS attack prevention:
+#ifndef BOOST_REGEX_RECURSIVE
+   TEST_INVALID_REGEX("$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$", perl);
 #endif
 }
 

test/regress/test_replace.cpp

@@ -194,5 +194,9 @@ void test_replace()
    TEST_REGEX_REPLACE("(a*)", perl, "aabb", match_default, "{$1}", "{aa}{}b{}b{}");
    TEST_REGEX_REPLACE("(a*)", boost::regex::extended, "aabb", match_default, "{$1}", "{aa}{}b{}b{}");
    TEST_REGEX_REPLACE("(a*)", boost::regex::extended, "aabb", match_default|match_posix, "{$1}", "{aa}b{}b{}");
+#ifndef BOOST_REGEX_RECURSIVE
+   // DOS protection:
+   TEST_REGEX_REPLACE("foo", boost::regex::perl, "foobar", match_default|format_all, "(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((", "(((((((((((((((((((((bar");
+#endif
 }
 

test/static_mutex/static_mutex_test.cpp

@@ -16,6 +16,8 @@
   *   DESCRIPTION: test program for boost::static_mutex.
   */
 
+#define BOOST_TIMER_ENABLE_DEPRECATED
+
 #include <boost/regex/pending/static_mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/timer.hpp>