Merge pull request #50 from boostorg/develop

Merge Fuzz-bug fixes from develop

.travis.yml

@@ -102,42 +102,6 @@ matrix:
           sources:
             - ubuntu-toolchain-r-test
 
-    - os: linux
-      env: TOOLSET=gcc COMPILER=g++-7 CXXSTD=03,11 CXXSTD_DIALECT=cxxstd-dialect=gnu
-      addons:
-        apt:
-          packages:
-            - g++-7
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      env: TOOLSET=gcc COMPILER=g++-7 CXXSTD=14,1z CXXSTD_DIALECT=cxxstd-dialect=gnu
-      addons:
-        apt:
-          packages:
-            - g++-7
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      env: TOOLSET=gcc COMPILER=g++-8 CXXSTD=03,11 CXXSTD_DIALECT=cxxstd-dialect=gnu
-      addons:
-        apt:
-          packages:
-            - g++-8
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      env: TOOLSET=gcc COMPILER=g++-8 CXXSTD=14,1z CXXSTD_DIALECT=cxxstd-dialect=gnu
-      addons:
-        apt:
-          packages:
-            - g++-8
-          sources:
-            - ubuntu-toolchain-r-test
-
     - os: linux
       env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11
 
@@ -247,11 +211,8 @@ install:
   - git clone -b $TRAVIS_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
   - cd boost-root
   - git submodule update --init tools/build
-  - git submodule update --init tools/boost_install
-  - git submodule update --init libs/headers
   - git submodule update --init libs/config
   - git submodule update --init libs/core
-  - git submodule update --init libs/container_hash
   - git submodule update --init libs/detail
   - git submodule update --init libs/smart_ptr
   - git submodule update --init libs/predef

README.md

@@ -1,36 +0,0 @@
-Boost Regex Library
-============================
-
-The Boost Regex library provides regular expression support for C++, this library is the ancestor to std::regex and still goes beyond
-and offers some advantages to, the standard version.
-
-The full documentation is available on [boost.org](http://www.boost.org/doc/libs/release/libs/regex/index.html).
-
-## Support, bugs and feature requests ##
-
-Bugs and feature requests can be reported through the [Gitub issue tracker](https://github.com/boostorg/regex/issues)
-(see [open issues](https://github.com/boostorg/regex/issues) and
-[closed issues](https://github.com/boostorg/regex/issues?utf8=%E2%9C%93&q=is%3Aissue+is%3Aclosed)).
-
-You can submit your changes through a [pull request](https://github.com/boostorg/regex/pulls).
-
-There is no mailing-list specific to Boost Regex, although you can use the general-purpose Boost [mailing-list](http://lists.boost.org/mailman/listinfo.cgi/boost-users) using the tag [regex].
-
-
-## Development ##
-
-Clone the whole boost project, which includes the individual Boost projects as submodules ([see boost+git doc](https://github.com/boostorg/boost/wiki/Getting-Started)): 
-
-    git clone https://github.com/boostorg/boost
-    cd boost
-    git submodule update --init
-
-The Boost Regex Library is located in `libs/regex/`. 
-
-### Running tests ###
-First, make sure you are in `libs/regex/test`. 
-You can either run all the tests listed in `Jamfile.v2` or run a single test:
-
-    ../../../b2                        <- run all tests
-    ../../../b2 regex_regress          <- single test
-

appveyor.yml

@@ -23,15 +23,13 @@ environment:
     - ARGS: --toolset=msvc-14.0 address-model=32
     - ARGS: --toolset=msvc-12.0 address-model=64
     - ARGS: --toolset=msvc-14.0 address-model=64
-    - ARGS: --toolset=msvc-14.0 address-model=64 cxxstd=latest
+    - ARGS: --toolset=msvc-14.0 address-model=64 cxxflags=-std:c++latest
     - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
       ARGS: --toolset=msvc-14.1 address-model=64
     - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
       ARGS: --toolset=msvc-14.1 address-model=32
     - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      ARGS: --toolset=msvc-14.1 address-model=64 cxxstd=17
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      ARGS: --toolset=msvc-14.1 address-model=64 cxxstd=latest cxxflags=-permissive-
+      ARGS: --toolset=msvc-14.1 address-model=64 cxxflags=-std:c++latest
     - ARGS: --toolset=gcc address-model=64
       PATH: C:\mingw-w64\x86_64-6.3.0-posix-seh-rt_v5-rev1\mingw64\bin;%PATH%
     - ARGS: --toolset=gcc address-model=64 cxxflags=-std=gnu++1z
@@ -40,21 +38,15 @@ environment:
       PATH: C:\mingw-w64\i686-5.3.0-posix-dwarf-rt_v4-rev0\mingw32\bin;%PATH%
     - ARGS: --toolset=gcc address-model=32 linkflags=-Wl,-allow-multiple-definition
       PATH: C:\MinGW\bin;%PATH%
-    - ARGS: --toolset=gcc address-model=32 define=_POSIX_C_SOURCE=200112L threadapi=pthread link=static
-      PATH: C:\cygwin\bin;%PATH%
-    - ARGS: --toolset=gcc address-model=64 define=_POSIX_C_SOURCE=200112L define=__USE_ISOC99 threadapi=pthread link=static
-      PATH: C:\cygwin64\bin;%PATH%
+
 
 install:
   - cd ..
   - git clone -b %APPVEYOR_REPO_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
   - cd boost-root
   - git submodule update --init tools/build
-  - git submodule update --init tools/boost_install
-  - git submodule update --init libs/headers
   - git submodule update --init libs/config
   - git submodule update --init libs/core
-  - git submodule update --init libs/container_hash
   - git submodule update --init libs/detail
   - git submodule update --init libs/smart_ptr
   - git submodule update --init libs/predef

build/Jamfile.v2

@@ -30,10 +30,6 @@ rule path_options ( properties * )
 #
 # ICU configuration:
 #
-
-local ICU_OPTS ;
-local ICU_INSTALL_OPTS ;
-
 if ! $(disable-icu)
 {
 
@@ -48,8 +44,7 @@ if ! $(disable-icu)
 
    if $(ICU_LINK)
    {
-      ICU_OPTS = <include>$(ICU_PATH)/include <linkflags>$(ICU_LINK) <define>BOOST_HAS_ICU=1 <runtime-link>shared ;
-      ICU_INSTALL_OPTS = <dll-path>$(ICU_PATH)/bin ;
+      ICU_OPTS = <include>$(ICU_PATH)/include <linkflags>$(ICU_LINK) <dll-path>$(ICU_PATH)/bin <define>BOOST_HAS_ICU=1 <runtime-link>shared ;
    }
    else
    {
@@ -127,4 +122,12 @@ lib boost_regex : ../src/$(SOURCES) icu_options
 	     <toolset>gcc-cygwin:<link>static
     ;
 
-boost-install boost_regex : $(ICU_INSTALL_OPTS) ;
+boost-install boost_regex ;
+
+
+
+
+
+
+
+

example/timer/regex_timer.cpp

@@ -67,14 +67,18 @@ ostream& operator << (ostream& os, const std::wstring& s)
 
 template <class S>
 class string_out_iterator 
+#ifndef BOOST_NO_STD_ITERATOR
+  : public std::iterator<std::output_iterator_tag, void, void, void, void>
+#endif // ndef BOOST_NO_STD_ITERATOR
 {
-public:
+#ifdef BOOST_NO_STD_ITERATOR
    typedef std::output_iterator_tag iterator_category;
    typedef void value_type;
    typedef void difference_type;
    typedef void pointer;
    typedef void reference;
-private:
+#endif // BOOST_NO_STD_ITERATOR
+
    S* out;
 public:
    string_out_iterator(S& s) : out(&s) {}

include/boost/regex/concepts.hpp

@@ -437,8 +437,7 @@ struct BaseRegexConcept
       ignore_unused_variable_warning(bi);
       sub_diff_type diff = m_sub.length();
       ignore_unused_variable_warning(diff);
-      // match_results tests - some typedefs are not used, however these
-      // guarante that they exist (some compilers may warn on non-usage)
+      // match_results tests:
       typedef typename match_results_type::value_type mr_value_type;
       typedef typename match_results_type::const_reference mr_const_reference;
       typedef typename match_results_type::reference mr_reference;
@@ -484,7 +483,7 @@ struct BaseRegexConcept
       mrci = m_cresults.end();
       ignore_unused_variable_warning(mrci);
 
-      (void) m_cresults.get_allocator();
+      mr_allocator_type at2 = m_cresults.get_allocator();
       m_results.swap(m_results);
       global_regex_namespace::swap(m_results, m_results);
 

include/boost/regex/config.hpp

@@ -113,17 +113,6 @@
 #if defined(__MINGW32__)
 #  define BOOST_REGEX_NO_EXTERNAL_TEMPLATES
 #endif
-/*
- * Clang fails to export template instances with -fvisibility=hidden, see
- * https://github.com/boostorg/regex/issues/49
- */
-#ifdef __clang__
-#  define BOOST_REGEX_NO_EXTERNAL_TEMPLATES
-#endif
-#ifdef __CYGWIN__
-/* We get multiply defined symbols without this: */
-#  define BOOST_REGEX_NO_EXTERNAL_TEMPLATES
-#endif
 
 /*
  * If there isn't good enough wide character support then there will
@@ -212,10 +201,7 @@
 #  define BOOST_REGEX_HAS_OTHER_WCHAR_T
 #  ifdef BOOST_MSVC
 #     pragma warning(push)
-#     pragma warning(disable : 4251)
-#if BOOST_MSVC < 1700
-#     pragma warning(disable : 4231)
-#endif
+#     pragma warning(disable : 4251 4231)
 #     if BOOST_MSVC < 1600
 #        pragma warning(disable : 4660)
 #     endif

include/boost/regex/icu.hpp

@@ -26,7 +26,6 @@
 #include <boost/regex.hpp>
 #include <boost/regex/pending/unicode_iterator.hpp>
 #include <boost/mpl/int_fwd.hpp>
-#include <boost/static_assert.hpp>
 #include <bitset>
 
 #ifdef BOOST_MSVC
@@ -335,34 +334,6 @@ inline u32regex do_make_u32regex(InputIterator i,
 #endif
 }
 
-// BOOST_REGEX_UCHAR_IS_WCHAR_T
-//
-// Source inspection of unicode/umachine.h in ICU version 59 indicates that:
-//
-// On version 59, UChar is always char16_t in C++ mode (and uint16_t in C mode)
-//
-// On earlier versions, the logic is
-//
-// #if U_SIZEOF_WCHAR_T==2
-//   typedef wchar_t OldUChar;
-// #elif defined(__CHAR16_TYPE__)
-//   typedef __CHAR16_TYPE__ OldUChar;
-// #else
-//   typedef uint16_t OldUChar;
-// #endif
-//
-// That is, UChar is wchar_t only on versions below 59, when U_SIZEOF_WCHAR_T==2
-//
-// Hence,
-
-#define BOOST_REGEX_UCHAR_IS_WCHAR_T (U_ICU_VERSION_MAJOR_NUM < 59 && U_SIZEOF_WCHAR_T == 2)
-
-#if BOOST_REGEX_UCHAR_IS_WCHAR_T
-  BOOST_STATIC_ASSERT((boost::is_same<UChar, wchar_t>::value));
-#else
-  BOOST_STATIC_ASSERT(!(boost::is_same<UChar, wchar_t>::value));
-#endif
-
 //
 // Construction from an iterator pair:
 //
@@ -393,7 +364,7 @@ inline u32regex make_u32regex(const wchar_t* p, boost::regex_constants::syntax_o
    return BOOST_REGEX_DETAIL_NS::do_make_u32regex(p, p + std::wcslen(p), opt, static_cast<boost::mpl::int_<sizeof(wchar_t)> const*>(0));
 }
 #endif
-#if !BOOST_REGEX_UCHAR_IS_WCHAR_T
+#if !defined(U_WCHAR_IS_UTF16) && (U_SIZEOF_WCHAR_T != 2)
 inline u32regex make_u32regex(const UChar* p, boost::regex_constants::syntax_option_type opt = boost::regex_constants::perl)
 {
    return BOOST_REGEX_DETAIL_NS::do_make_u32regex(p, p + u_strlen(p), opt, static_cast<boost::mpl::int_<2> const*>(0));
@@ -510,7 +481,7 @@ inline bool u32regex_match(const UChar* p,
 {
    return BOOST_REGEX_DETAIL_NS::do_regex_match(p, p+u_strlen(p), m, e, flags, static_cast<mpl::int_<2> const*>(0));
 }
-#if !BOOST_REGEX_UCHAR_IS_WCHAR_T && !defined(BOOST_NO_WREGEX)
+#if !defined(U_WCHAR_IS_UTF16) && (U_SIZEOF_WCHAR_T != 2) && !defined(BOOST_NO_WREGEX)
 inline bool u32regex_match(const wchar_t* p, 
                  match_results<const wchar_t*>& m, 
                  const u32regex& e, 
@@ -574,7 +545,7 @@ inline bool u32regex_match(const UChar* p,
    match_results<const UChar*> m;
    return BOOST_REGEX_DETAIL_NS::do_regex_match(p, p+u_strlen(p), m, e, flags, static_cast<mpl::int_<2> const*>(0));
 }
-#if !BOOST_REGEX_UCHAR_IS_WCHAR_T && !defined(BOOST_NO_WREGEX)
+#if !defined(U_WCHAR_IS_UTF16) && (U_SIZEOF_WCHAR_T != 2) && !defined(BOOST_NO_WREGEX)
 inline bool u32regex_match(const wchar_t* p, 
                  const u32regex& e, 
                  match_flag_type flags = match_default)
@@ -695,7 +666,7 @@ inline bool u32regex_search(const UChar* p,
 {
    return BOOST_REGEX_DETAIL_NS::do_regex_search(p, p+u_strlen(p), m, e, flags, p, static_cast<mpl::int_<2> const*>(0));
 }
-#if !BOOST_REGEX_UCHAR_IS_WCHAR_T && !defined(BOOST_NO_WREGEX)
+#if !defined(U_WCHAR_IS_UTF16) && (U_SIZEOF_WCHAR_T != 2) && !defined(BOOST_NO_WREGEX)
 inline bool u32regex_search(const wchar_t* p, 
                  match_results<const wchar_t*>& m, 
                  const u32regex& e, 
@@ -756,7 +727,7 @@ inline bool u32regex_search(const UChar* p,
    match_results<const UChar*> m;
    return BOOST_REGEX_DETAIL_NS::do_regex_search(p, p+u_strlen(p), m, e, flags, p, static_cast<mpl::int_<2> const*>(0));
 }
-#if !BOOST_REGEX_UCHAR_IS_WCHAR_T && !defined(BOOST_NO_WREGEX)
+#if !defined(U_WCHAR_IS_UTF16) && (U_SIZEOF_WCHAR_T != 2) && !defined(BOOST_NO_WREGEX)
 inline bool u32regex_search(const wchar_t* p, 
                  const u32regex& e, 
                  match_flag_type flags = match_default)

include/boost/regex/v4/basic_regex.hpp

@@ -20,7 +20,7 @@
 #define BOOST_REGEX_V4_BASIC_REGEX_HPP
 
 #include <boost/type_traits/is_same.hpp>
-#include <boost/container_hash/hash.hpp>
+#include <boost/functional/hash.hpp>
 
 #ifdef BOOST_MSVC
 #pragma warning(push)
@@ -36,16 +36,10 @@
 namespace boost{
 #ifdef BOOST_MSVC
 #pragma warning(push)
-#pragma warning(disable : 4251)
-#if BOOST_MSVC < 1700
-#     pragma warning(disable : 4231)
-#endif
+#pragma warning(disable : 4251 4231 4800)
 #if BOOST_MSVC < 1600
 #pragma warning(disable : 4660)
 #endif
-#if BOOST_MSVC < 1910
-#pragma warning(disable:4800)
-#endif
 #endif
 
 namespace BOOST_REGEX_DETAIL_NS{

include/boost/regex/v4/basic_regex_creator.hpp

@@ -33,9 +33,7 @@
 
 #ifdef BOOST_MSVC
 #  pragma warning(push)
-#if BOOST_MSVC < 1910
-#pragma warning(disable:4800)
-#endif
+#  pragma warning(disable: 4800)
 #endif
 
 namespace boost{

include/boost/regex/v4/basic_regex_parser.hpp

@@ -35,10 +35,7 @@ namespace BOOST_REGEX_DETAIL_NS{
 
 #ifdef BOOST_MSVC
 #pragma warning(push)
-#pragma warning(disable:4244)
-#if BOOST_MSVC < 1910
-#pragma warning(disable:4800)
-#endif
+#pragma warning(disable:4244 4800)
 #endif
 
 inline boost::intmax_t umax(mpl::false_ const&)
@@ -186,7 +183,7 @@ void basic_regex_parser<charT, traits>::parse(const charT* p1, const charT* p2,
    // have had an unexpected ')' :
    if(!result)
    {
-      fail(regex_constants::error_paren, ::boost::BOOST_REGEX_DETAIL_NS::distance(m_base, m_position), "Found a closing ) with no corresponding opening parenthesis.");
+      fail(regex_constants::error_paren, ::boost::BOOST_REGEX_DETAIL_NS::distance(m_base, m_position), "Found a closing ) with no corresponding openening parenthesis.");
       return;
    }
    // if an error has been set then give up now:

include/boost/regex/v4/fileiter.hpp

@@ -195,6 +195,9 @@ public:
 };
 
 class BOOST_REGEX_DECL mapfile_iterator
+#if !defined(BOOST_NO_STD_ITERATOR) || defined(BOOST_MSVC_STD_ITERATOR)
+: public std::iterator<std::random_access_iterator_tag, char>
+#endif
 {
    typedef mapfile::pointer internal_pointer;
    internal_pointer* node;

include/boost/regex/v4/instances.hpp

@@ -84,10 +84,7 @@ template class BOOST_REGEX_DECL ::boost::BOOST_REGEX_DETAIL_NS::perl_matcher<BOO
 
 #  ifdef BOOST_MSVC
 #     pragma warning(push)
-#     pragma warning(disable : 4251)
-#if BOOST_MSVC < 1700
-#     pragma warning(disable : 4231)
-#endif
+#     pragma warning(disable : 4251 4231)
 #     if BOOST_MSVC < 1600
 #     pragma warning(disable : 4660)
 #     endif
@@ -122,17 +119,9 @@ template class BOOST_REGEX_TEMPLATE_DECL ::boost::BOOST_REGEX_DETAIL_NS::perl_ma
 
 #elif (defined(__GNUC__) && (__GNUC__ >= 3)) || !defined(BOOST_NO_CXX11_EXTERN_TEMPLATE)
 
-#if defined(__clang__)
-#  pragma clang diagnostic push
-#  if defined(__APPLE_CC__)
-#    if (__clang_major__ > 6)
-#      pragma clang diagnostic ignored "-Wkeyword-macro"
-#    endif
-#  else
-#    if (__clang_major__ > 3) || ((__clang_major__ == 3) && (__clang_minor__ > 5))
-#      pragma clang diagnostic ignored "-Wkeyword-macro"
-#    endif
-#  endif
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wkeyword-macro"
 #endif
 
 #  ifndef BOOST_REGEX_INSTANTIATE

include/boost/regex/v4/match_flags.hpp

@@ -22,6 +22,7 @@
 #ifdef __cplusplus
 #  include <boost/cstdint.hpp>
 #endif
+#include <boost/detail/workaround.hpp>
 
 #ifdef __cplusplus
 namespace boost{
@@ -82,7 +83,7 @@ typedef enum _match_flags
 
 } match_flags;
 
-#if defined(__BORLANDC__) || (defined(_MSC_VER) && (_MSC_VER <= 1310))
+#if defined(__BORLANDC__) || BOOST_WORKAROUND(BOOST_MSVC, <= 1310)
 typedef unsigned long match_flag_type;
 #else
 typedef match_flags match_flag_type;

include/boost/regex/v4/match_results.hpp

@@ -33,10 +33,7 @@
 namespace boost{
 #ifdef BOOST_MSVC
 #pragma warning(push)
-#pragma warning(disable : 4251)
-#if BOOST_MSVC < 1700
-#     pragma warning(disable : 4231)
-#endif
+#pragma warning(disable : 4251 4231)
 #  if BOOST_MSVC < 1600
 #     pragma warning(disable : 4660)
 #  endif
@@ -59,9 +56,7 @@ private:
 #endif
 public: 
    typedef          sub_match<BidiIterator>                         value_type;
-#ifndef BOOST_NO_CXX11_ALLOCATOR
-   typedef typename std::allocator_traits<Allocator>::value_type const &    const_reference;
-#elif  !defined(BOOST_NO_STD_ALLOCATOR) && !(defined(BOOST_MSVC) && defined(_STLPORT_VERSION))
+#if  !defined(BOOST_NO_STD_ALLOCATOR) && !(defined(BOOST_MSVC) && defined(_STLPORT_VERSION))
    typedef typename Allocator::const_reference                              const_reference;
 #else
    typedef          const value_type&                                       const_reference;
@@ -71,11 +66,7 @@ public:
    typedef          const_iterator                                          iterator;
    typedef typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<
                                     BidiIterator>::difference_type          difference_type;
-#ifdef BOOST_NO_CXX11_ALLOCATOR
    typedef typename Allocator::size_type                                    size_type;
-#else
-   typedef typename std::allocator_traits<Allocator>::size_type             size_type;
-#endif
    typedef          Allocator                                               allocator_type;
    typedef typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<
                                     BidiIterator>::value_type               char_type;
@@ -572,7 +563,7 @@ private:
    //
    static void raise_logic_error()
    {
-      std::logic_error e("Attempt to access an uninitialized boost::match_results<> class.");
+      std::logic_error e("Attempt to access an uninitialzed boost::match_results<> class.");
       boost::throw_exception(e);
    }
 

include/boost/regex/v4/perl_matcher.hpp

@@ -27,9 +27,7 @@
 
 #ifdef BOOST_MSVC
 #  pragma warning(push)
-#if BOOST_MSVC < 1910
-#pragma warning(disable:4800)
-#endif
+#  pragma warning(disable: 4800)
 #endif
 
 namespace boost{
@@ -355,10 +353,7 @@ struct recursion_info
 
 #ifdef BOOST_MSVC
 #pragma warning(push)
-#pragma warning(disable : 4251)
-#if BOOST_MSVC < 1700
-#     pragma warning(disable : 4231)
-#endif
+#pragma warning(disable : 4251 4231)
 #  if BOOST_MSVC < 1600
 #     pragma warning(disable : 4660)
 #  endif

include/boost/regex/v4/perl_matcher_common.hpp

@@ -36,9 +36,7 @@
 #endif
 #ifdef BOOST_MSVC
 #  pragma warning(push)
-#if BOOST_MSVC < 1910
-#pragma warning(disable:4800)
-#endif
+#  pragma warning(disable: 4800)
 #endif
 
 namespace boost{
@@ -478,14 +476,12 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_word_boundary()
    }
    else
    {
-      if (m_match_flags & match_not_eow)
-         return false;
-      b = false;
+      b = (m_match_flags & match_not_eow) ? true : false;
    }
    if((position == backstop) && ((m_match_flags & match_prev_avail) == 0))
    {
       if(m_match_flags & match_not_bow)
-         return false;
+         b ^= true;
       else
          b ^= false;
    }

include/boost/regex/v4/perl_matcher_non_recursive.hpp

@@ -34,10 +34,7 @@
 #endif
 #ifdef BOOST_MSVC
 #  pragma warning(push)
-#  pragma warning(disable: 4706)
-#if BOOST_MSVC < 1910
-#pragma warning(disable:4800)
-#endif
+#  pragma warning(disable: 4800 4706)
 #endif
 
 namespace boost{
@@ -67,7 +64,7 @@ struct saved_matched_paren : public saved_state
 {
    int index;
    sub_match<BidiIterator> sub;
-   saved_matched_paren(int i, const sub_match<BidiIterator>& s) : saved_state(1), index(i), sub(s){}
+   saved_matched_paren(int i, const sub_match<BidiIterator>& s) : saved_state(1), index(i), sub(s){};
 };
 
 template <class BidiIterator>
@@ -75,7 +72,7 @@ struct saved_position : public saved_state
 {
    const re_syntax_base* pstate;
    BidiIterator position;
-   saved_position(const re_syntax_base* ps, BidiIterator pos, int i) : saved_state(i), pstate(ps), position(pos){}
+   saved_position(const re_syntax_base* ps, BidiIterator pos, int i) : saved_state(i), pstate(ps), position(pos){};
 };
 
 template <class BidiIterator>
@@ -83,7 +80,7 @@ struct saved_assertion : public saved_position<BidiIterator>
 {
    bool positive;
    saved_assertion(bool p, const re_syntax_base* ps, BidiIterator pos) 
-      : saved_position<BidiIterator>(ps, pos, saved_type_assertion), positive(p){}
+      : saved_position<BidiIterator>(ps, pos, saved_type_assertion), positive(p){};
 };
 
 template <class BidiIterator>
@@ -1800,7 +1797,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::unwind_recursion_pop(bool r)
    // Backtracking out of a recursion, we must pop state off the recursion
    // stack unconditionally to ensure matched pushes and pops:
    saved_state* pmp = static_cast<saved_state*>(m_backup_state);
-   if (!r && !recursion_stack.empty())
+   if (!r)
    {
       *m_presult = recursion_stack.back().results;
       position = recursion_stack.back().location_of_start;
@@ -1837,7 +1834,6 @@ bool perl_matcher<BidiIterator, Allocator, traits>::unwind_commit(bool b)
       // If we stop because we just unwound an assertion, put the
       // commit state back on the stack again:
       //
-      m_unwound_lookahead = false;
       saved_state* pmp = m_backup_state;
       --pmp;
       if(pmp < m_stack_base)

include/boost/regex/v4/regex_format.hpp

@@ -800,6 +800,9 @@ void basic_regex_formatter<OutputIterator, Results, traits, ForwardIter>::put(co
 
 template <class S>
 class string_out_iterator
+#ifndef BOOST_NO_STD_ITERATOR
+   : public std::iterator<std::output_iterator_tag, typename S::value_type>
+#endif
 {
    S* out;
 public:
@@ -813,11 +816,13 @@ public:
       return *this; 
    }
 
+#ifdef BOOST_NO_STD_ITERATOR
    typedef std::ptrdiff_t difference_type;
    typedef typename S::value_type value_type;
    typedef value_type* pointer;
    typedef value_type& reference;
    typedef std::output_iterator_tag iterator_category;
+#endif
 };
 
 template <class OutputIterator, class Iterator, class Alloc, class ForwardIter, class traits>

include/boost/regex/v4/regex_iterator.hpp

@@ -85,6 +85,14 @@ template <class BidirectionalIterator,
           class charT = BOOST_DEDUCED_TYPENAME BOOST_REGEX_DETAIL_NS::regex_iterator_traits<BidirectionalIterator>::value_type,
           class traits = regex_traits<charT> >
 class regex_iterator 
+#ifndef BOOST_NO_STD_ITERATOR
+   : public std::iterator<
+         std::forward_iterator_tag, 
+         match_results<BidirectionalIterator>,
+         typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<BidirectionalIterator>::difference_type,
+         const match_results<BidirectionalIterator>*,
+         const match_results<BidirectionalIterator>& >         
+#endif
 {
 private:
    typedef regex_iterator_implementation<BidirectionalIterator, charT, traits> impl;

include/boost/regex/v4/regex_raw_buffer.hpp

@@ -138,12 +138,12 @@ public:
 
    size_type BOOST_REGEX_CALL size()
    {
-      return size_type(end - start);
+      return end - start;
    }
 
    size_type BOOST_REGEX_CALL capacity()
    {
-      return size_type(last - start);
+      return last - start;
    }
 
    void* BOOST_REGEX_CALL data()const
@@ -153,7 +153,7 @@ public:
 
    size_type BOOST_REGEX_CALL index(void* ptr)
    {
-      return size_type(static_cast<pointer>(ptr) - static_cast<pointer>(data()));
+      return static_cast<pointer>(ptr) - static_cast<pointer>(data());
    }
 
    void BOOST_REGEX_CALL clear()

include/boost/regex/v4/regex_split.hpp

@@ -36,9 +36,7 @@ namespace boost{
 
 #ifdef BOOST_MSVC
 #  pragma warning(push)
-#if BOOST_MSVC < 1910
-#pragma warning(disable:4800)
-#endif
+#  pragma warning(disable: 4800)
 #endif
 
 namespace BOOST_REGEX_DETAIL_NS{

include/boost/regex/v4/regex_token_iterator.hpp

@@ -167,6 +167,14 @@ template <class BidirectionalIterator,
           class charT = BOOST_DEDUCED_TYPENAME BOOST_REGEX_DETAIL_NS::regex_iterator_traits<BidirectionalIterator>::value_type,
           class traits = regex_traits<charT> >
 class regex_token_iterator 
+#ifndef BOOST_NO_STD_ITERATOR
+   : public std::iterator<
+         std::forward_iterator_tag, 
+         sub_match<BidirectionalIterator>,
+         typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<BidirectionalIterator>::difference_type,
+         const sub_match<BidirectionalIterator>*,
+         const sub_match<BidirectionalIterator>& >         
+#endif
 {
 private:
    typedef regex_token_iterator_implementation<BidirectionalIterator, charT, traits> impl;

include/boost/regex/v4/regex_traits_defaults.hpp

@@ -39,7 +39,6 @@
 #include <boost/regex/v4/error_type.hpp>
 #endif
 #include <boost/type_traits/make_unsigned.hpp>
-#include <boost/utility/enable_if.hpp>
 
 #ifdef BOOST_NO_STDC_NAMESPACE
 namespace std{
@@ -241,7 +240,7 @@ inline std::ptrdiff_t global_length<char>(const char* p)
 template<>
 inline std::ptrdiff_t global_length<wchar_t>(const wchar_t* p)
 {
-   return (std::ptrdiff_t)(std::wcslen)(p);
+   return (std::wcslen)(p);
 }
 #endif
 template <class charT>
@@ -328,17 +327,17 @@ boost::intmax_t global_toi(const charT*& p1, const charT* p2, int radix, const t
 }
 
 template <class charT>
-inline typename boost::enable_if_c<(sizeof(charT) > 1), const charT*>::type get_escape_R_string()
+inline const charT* get_escape_R_string()
 {
 #ifdef BOOST_MSVC
 #  pragma warning(push)
 #  pragma warning(disable:4309 4245)
 #endif
-   static const charT e1[] = { '(', '?', '-', 'x', ':', '(', '?', '>', '\x0D', '\x0A', '?',
-      '|', '[', '\x0A', '\x0B', '\x0C', static_cast<charT>(0x85), static_cast<charT>(0x2028),
-      static_cast<charT>(0x2029), ']', ')', ')', '\0' };
-   static const charT e2[] = { '(', '?', '-', 'x', ':', '(', '?', '>', '\x0D', '\x0A', '?',
-      '|', '[', '\x0A', '\x0B', '\x0C', static_cast<charT>(0x85), ']', ')', ')', '\0' };
+   static const charT e1[] = { '(', '?', '>', '\\', 'x', '0', 'D', '\\', 'x', '0', 'A', '?',
+      '|', '[', '\\', 'x', '0', 'A', '\\', 'x', '0', 'B', '\\', 'x', '0', 'C', static_cast<unsigned char>('\x85'), '\\', 'x', '{', '2', '0', '2', '8', '}',
+                '\\', 'x', '{', '2', '0', '2', '9', '}', ']', ')', '\0' };
+   static const charT e2[] = { '(', '?', '>', '\\', 'x', '0', 'D', '\\', 'x', '0', 'A', '?',
+      '|', '[', '\\', 'x', '0', 'A', '\\', 'x', '0', 'B', '\\', 'x', '0', 'C', static_cast<unsigned char>('\x85'), ']', ')', '\0' };
 
    charT c = static_cast<charT>(0x2029u);
    bool b = (static_cast<unsigned>(c) == 0x2029u);
@@ -349,15 +348,15 @@ inline typename boost::enable_if_c<(sizeof(charT) > 1), const charT*>::type get_
 #endif
 }
 
-template <class charT>
-inline typename boost::disable_if_c<(sizeof(charT) > 1), const charT*>::type get_escape_R_string()
+template <>
+inline const char* get_escape_R_string<char>()
 {
 #ifdef BOOST_MSVC
 #  pragma warning(push)
 #  pragma warning(disable:4309)
 #endif
-   static const charT e2[] = { '(', '?', '-', 'x', ':', '(', '?', '>', '\x0D', '\x0A', '?',
-      '|', '[', '\x0A', '\x0B', '\x0C', '\x85', ']', ')', ')', '\0' };
+   static const char e2[] = { '(', '?', '>', '\\', 'x', '0', 'D', '\\', 'x', '0', 'A', '?',
+      '|', '[', '\\', 'x', '0', 'A', '\\', 'x', '0', 'B', '\\', 'x', '0', 'C', '\\', 'x', '8', '5', ']', ')', '\0' };
    return e2;
 #ifdef BOOST_MSVC
 #  pragma warning(pop)

include/boost/regex/v4/regex_workaround.hpp

@@ -198,10 +198,9 @@ namespace boost{ namespace BOOST_REGEX_DETAIL_NS{
       const char *strSource 
    )
    {
-	  std::size_t lenSourceWithNull = std::strlen(strSource) + 1;
-	  if (lenSourceWithNull > sizeInBytes)
+      if(std::strlen(strSource)+1 > sizeInBytes)
          return 1;
-	  std::memcpy(strDestination, strSource, lenSourceWithNull);
+      std::strcpy(strDestination, strSource);
       return 0;
    }
    inline std::size_t strcat_s(
@@ -210,11 +209,9 @@ namespace boost{ namespace BOOST_REGEX_DETAIL_NS{
       const char *strSource 
    )
    {
-	  std::size_t lenSourceWithNull = std::strlen(strSource) + 1;
-	  std::size_t lenDestination = std::strlen(strDestination);
-	  if (lenSourceWithNull + lenDestination > sizeInBytes)
+      if(std::strlen(strSource) + std::strlen(strDestination) + 1 > sizeInBytes)
          return 1;
-	  std::memcpy(strDestination + lenDestination, strSource, lenSourceWithNull);
+      std::strcat(strDestination, strSource);
       return 0;
    }
 

include/boost/regex/v4/u32regex_iterator.hpp

@@ -72,6 +72,14 @@ private:
 
 template <class BidirectionalIterator>
 class u32regex_iterator 
+#ifndef BOOST_NO_STD_ITERATOR
+   : public std::iterator<
+         std::forward_iterator_tag, 
+         match_results<BidirectionalIterator>,
+         typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<BidirectionalIterator>::difference_type,
+         const match_results<BidirectionalIterator>*,
+         const match_results<BidirectionalIterator>& >         
+#endif
 {
 private:
    typedef u32regex_iterator_implementation<BidirectionalIterator> impl;
@@ -158,7 +166,7 @@ inline u32regex_iterator<const wchar_t*> make_u32regex_iterator(const wchar_t* p
    return u32regex_iterator<const wchar_t*>(p, p+std::wcslen(p), e, m);
 }
 #endif
-#if !defined(BOOST_REGEX_UCHAR_IS_WCHAR_T)
+#if !defined(U_WCHAR_IS_UTF16) && (U_SIZEOF_WCHAR_T != 2)
 inline u32regex_iterator<const UChar*> make_u32regex_iterator(const UChar* p, const u32regex& e, regex_constants::match_flag_type m = regex_constants::match_default)
 {
    return u32regex_iterator<const UChar*>(p, p+u_strlen(p), e, m);

include/boost/regex/v4/u32regex_token_iterator.hpp

@@ -155,6 +155,14 @@ private:
 
 template <class BidirectionalIterator>
 class u32regex_token_iterator 
+#ifndef BOOST_NO_STD_ITERATOR
+   : public std::iterator<
+         std::forward_iterator_tag, 
+         sub_match<BidirectionalIterator>,
+         typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<BidirectionalIterator>::difference_type,
+         const sub_match<BidirectionalIterator>*,
+         const sub_match<BidirectionalIterator>& >         
+#endif
 {
 private:
    typedef u32regex_token_iterator_implementation<BidirectionalIterator> impl;
@@ -267,7 +275,7 @@ inline u32regex_token_iterator<const wchar_t*> make_u32regex_token_iterator(cons
    return u32regex_token_iterator<const wchar_t*>(p, p+std::wcslen(p), e, submatch, m);
 }
 #endif
-#if !defined(BOOST_REGEX_UCHAR_IS_WCHAR_T)
+#if !defined(U_WCHAR_IS_UTF16) && (U_SIZEOF_WCHAR_T != 2)
 inline u32regex_token_iterator<const UChar*> make_u32regex_token_iterator(const UChar* p, const u32regex& e, int submatch = 0, regex_constants::match_flag_type m = regex_constants::match_default)
 {
    return u32regex_token_iterator<const UChar*>(p, p+u_strlen(p), e, submatch, m);
@@ -297,7 +305,7 @@ inline u32regex_token_iterator<const wchar_t*> make_u32regex_token_iterator(cons
    return u32regex_token_iterator<const wchar_t*>(p, p+std::wcslen(p), e, submatch, m);
 }
 #endif
-#if !defined(BOOST_REGEX_UCHAR_IS_WCHAR_T)
+#if !defined(U_WCHAR_IS_UTF16) && (U_SIZEOF_WCHAR_T != 2)
 template <std::size_t N>
 inline u32regex_token_iterator<const UChar*> make_u32regex_token_iterator(const UChar* p, const u32regex& e, const int (&submatch)[N], regex_constants::match_flag_type m = regex_constants::match_default)
 {

include/boost/regex/v4/w32_regex_traits.hpp

@@ -51,10 +51,8 @@
 #ifdef BOOST_MSVC
 #pragma warning(push)
 #pragma warning(disable:4786)
-#if BOOST_MSVC < 1910
 #pragma warning(disable:4800)
 #endif
-#endif
 
 namespace boost{ 
 

performance/table_helper.cpp

@@ -11,7 +11,7 @@
 #include <boost/lexical_cast.hpp>
 #include <boost/filesystem.hpp>
 #include <boost/filesystem/fstream.hpp>
-#include <boost/container_hash/hash.hpp>
+#include <boost/functional/hash.hpp>
 #include <vector>
 #include <set>
 #include <iostream>

src/cregex.cpp

@@ -491,8 +491,8 @@ std::size_t RegEx::Position(int i)const
    {
    case BOOST_REGEX_DETAIL_NS::RegExData::type_pc:
       return pdata->m[i].matched ? pdata->m[i].first - pdata->pbase : RegEx::npos;
-   case BOOST_REGEX_DETAIL_NS::RegExData::type_pf:
 #ifndef BOOST_REGEX_NO_FILEITER
+   case BOOST_REGEX_DETAIL_NS::RegExData::type_pf:
       return pdata->fm[i].matched ? pdata->fm[i].first - pdata->fbase : RegEx::npos;
 #endif
    case BOOST_REGEX_DETAIL_NS::RegExData::type_copy:
@@ -518,8 +518,8 @@ std::size_t RegEx::Length(int i)const
    {
    case BOOST_REGEX_DETAIL_NS::RegExData::type_pc:
       return pdata->m[i].matched ? pdata->m[i].second - pdata->m[i].first : RegEx::npos;
-   case BOOST_REGEX_DETAIL_NS::RegExData::type_pf:
 #ifndef BOOST_REGEX_NO_FILEITER
+   case BOOST_REGEX_DETAIL_NS::RegExData::type_pf:
       return pdata->fm[i].matched ? pdata->fm[i].second - pdata->fm[i].first : RegEx::npos;
 #endif
    case BOOST_REGEX_DETAIL_NS::RegExData::type_copy:
@@ -539,10 +539,10 @@ bool RegEx::Matched(int i)const
    {
    case BOOST_REGEX_DETAIL_NS::RegExData::type_pc:
       return pdata->m[i].matched;
-   case BOOST_REGEX_DETAIL_NS::RegExData::type_pf:
 #ifndef BOOST_REGEX_NO_FILEITER
+   case BOOST_REGEX_DETAIL_NS::RegExData::type_pf:
       return pdata->fm[i].matched;
-#endif
+#endif      
    case BOOST_REGEX_DETAIL_NS::RegExData::type_copy:
       {
       std::map<int, std::string, std::less<int> >::iterator pos = pdata->strings.find(i);

src/fileiter.cpp

@@ -832,7 +832,7 @@ bool iswild(const char* mask, const char* name)
             ++mask;
             continue;
          }
-         // fall through
+         // fall through:
       default:
          if(BOOST_REGEX_FI_TRANSLATE(*mask) != BOOST_REGEX_FI_TRANSLATE(*name))
             return false;

src/icu.cpp

@@ -481,7 +481,7 @@ icu_regex_traits::string_type icu_regex_traits::lookup_collatename(const char_ty
 bool icu_regex_traits::isctype(char_type c, char_class_type f) const
 {
    // check for standard catagories first:
-   char_class_type m = char_class_type(static_cast<char_class_type>(1) << u_charType(c));
+   char_class_type m = char_class_type(1u << u_charType(c));
    if((m & f) != 0) 
       return true;
    // now check for special cases:

src/regex.cpp

@@ -28,9 +28,7 @@
 #  include <malloc.h>
 #endif
 #ifdef BOOST_REGEX_HAS_MS_STACK_GUARD
-#ifndef WIN32_LEAN_AND_MEAN
-#  define WIN32_LEAN_AND_MEAN
-#endif
+#define WIN32_LEAN_AND_MEAN
 #ifndef NOMINMAX
 #  define NOMINMAX
 #endif

src/static_mutex.cpp

@@ -28,9 +28,7 @@
 #ifndef NOMINMAX
 #  define NOMINMAX
 #endif
-#ifndef WIN32_LEAN_AND_MEAN
-#  define WIN32_LEAN_AND_MEAN
-#endif
+#define WIN32_LEAN_AND_MEAN
 #include <windows.h>
 #include <boost/static_assert.hpp>
 #endif

src/w32_regex_traits.cpp

@@ -23,9 +23,7 @@
 #include <boost/regex/regex_traits.hpp>
 #include <boost/regex/pattern_except.hpp>
 
-#ifndef WIN32_LEAN_AND_MEAN
-#  define WIN32_LEAN_AND_MEAN
-#endif
+#define WIN32_LEAN_AND_MEAN
 #ifndef NOMINMAX
 #  define NOMINMAX
 #endif

test/Jamfile.v2

@@ -19,7 +19,7 @@ project
       <define>U_USING_ICU_NAMESPACE=0
       #<toolset>gcc-mw:<link>static
       #<toolset>gcc-mingw:<link>static
-      #<toolset>gcc-cygwin:<link>static
+      <toolset>gcc-cygwin:<link>static
       <toolset>sun:<link>static
     ;
 
@@ -194,10 +194,4 @@ compile test_consolidated.cpp ;
 
 build-project ../example ;
 
-# `quick` target (for CI)
-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
-         <toolset>clang:<warnings>all <toolset>clang:<warnings-as-errors>on ;

test/c_compiler_checks/posix_api_check.c

@@ -39,7 +39,7 @@ int main()
    {
       char buf[256];
       regerrorA(result, &re, buf, sizeof(buf));
-      puts(buf);
+      printf(buf);
       return result;
    }
    assert(re.re_nsub == 0);
@@ -50,7 +50,7 @@ int main()
    {
       char buf[256];
       regerrorA(result, &re, buf, sizeof(buf));
-      puts(buf);
+      printf(buf);
       regfreeA(&re);
       return result;
    }

test/c_compiler_checks/wide_posix_api_check.c

@@ -50,7 +50,7 @@ int main()
       regerror(result, &re, buf, sizeof(buf));
       for(i = 0; i < 256; ++i)
          nbuf[i] = (char)(buf[i]);
-      puts(nbuf);
+      printf(nbuf);
       return result;
    }
    if(re.re_nsub != 0)
@@ -66,7 +66,7 @@ int main()
       regerror(result, &re, buf, sizeof(buf));
       for(i = 0; i < 256; ++i)
          nbuf[i] = (char)(buf[i]);
-      puts(nbuf);
+      printf(nbuf);
       regfree(&re);
       return result;
    }

test/captures/captures_test.cpp

@@ -29,9 +29,9 @@
 #define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))
 
 template <int N>
-size_t array_size(const char* (&p)[N])
+int array_size(const char* (&p)[N])
 {
-   for(size_t i = 0; i < N; ++i)
+   for(int i = 0; i < N; ++i)
       if(p[i] == 0)
          return i;
    return N;

test/concepts/icu_concept_check.cpp

@@ -33,34 +33,7 @@
 #include <boost/regex/concepts.hpp>
 #endif
 
-template <class I>
-void check_token_iterator(I i)
-{
-   typedef typename I::value_type value_type;
-   typedef typename value_type::value_type char_type;
-   typedef std::basic_string<char_type> string_type;
 
-   I j;
-
-   std::vector<string_type> v;
-
-   while (i != j)
-   {
-      v.push_back(i->str());
-      ++i;
-   }
-
-}
-
-template <class I>
-void check_iterator(I i)
-{
-   typedef typename I::value_type value_type;
-
-   std::vector <value_type> v(i, I());
-   (void)v;
-
-}
 int main()
 {
    // VC6 and VC7 can't cope with the iterator architypes, 
@@ -177,64 +150,6 @@ int main()
    s1 = boost::u32regex_replace(s1, e1, s1);
    s2 = boost::u32regex_replace(s2, e1, s2);
 
-   std::vector<int> subs1;
-   int subs2[2] = { 1, 2 };
-
-   check_token_iterator(boost::make_u32regex_token_iterator((const char*)(pb), e1, 0, boost::regex_constants::match_default));
-   check_token_iterator(boost::make_u32regex_token_iterator((const char*)(pb), e1, 0));
-   check_token_iterator(boost::make_u32regex_token_iterator((const char*)(pb), e1));
-   check_token_iterator(boost::make_u32regex_token_iterator((const UChar*)(pb), e1, 0, boost::regex_constants::match_default));
-   check_token_iterator(boost::make_u32regex_token_iterator((const UChar*)(pb), e1, 0));
-   check_token_iterator(boost::make_u32regex_token_iterator((const UChar*)(pb), e1));
-   check_token_iterator(boost::make_u32regex_token_iterator((const wchar_t*)(pb), e1, 0, boost::regex_constants::match_default));
-   check_token_iterator(boost::make_u32regex_token_iterator((const wchar_t*)(pb), e1, 0));
-   check_token_iterator(boost::make_u32regex_token_iterator((const wchar_t*)(pb), e1));
-   check_token_iterator(boost::make_u32regex_token_iterator(s1, e1, 0, boost::regex_constants::match_default));
-   check_token_iterator(boost::make_u32regex_token_iterator(s1, e1, 0));
-   check_token_iterator(boost::make_u32regex_token_iterator(s1, e1));
-   check_token_iterator(boost::make_u32regex_token_iterator(s2, e1, 0, boost::regex_constants::match_default));
-   check_token_iterator(boost::make_u32regex_token_iterator(s2, e1, 0));
-   check_token_iterator(boost::make_u32regex_token_iterator(s2, e1));
-   check_token_iterator(boost::make_u32regex_token_iterator(us, e1, 0, boost::regex_constants::match_default));
-   check_token_iterator(boost::make_u32regex_token_iterator(us, e1, 0));
-   check_token_iterator(boost::make_u32regex_token_iterator(us, e1));
-
-   check_token_iterator(boost::make_u32regex_token_iterator((const char*)(pb), e1, subs2, boost::regex_constants::match_default));
-   check_token_iterator(boost::make_u32regex_token_iterator((const char*)(pb), e1, subs2));
-   check_token_iterator(boost::make_u32regex_token_iterator((const UChar*)(pb), e1, subs2, boost::regex_constants::match_default));
-   check_token_iterator(boost::make_u32regex_token_iterator((const UChar*)(pb), e1, subs2));
-   check_token_iterator(boost::make_u32regex_token_iterator((const wchar_t*)(pb), e1, subs2, boost::regex_constants::match_default));
-   check_token_iterator(boost::make_u32regex_token_iterator((const wchar_t*)(pb), e1, subs2));
-   check_token_iterator(boost::make_u32regex_token_iterator(s1, e1, subs2, boost::regex_constants::match_default));
-   check_token_iterator(boost::make_u32regex_token_iterator(s1, e1, subs2));
-   check_token_iterator(boost::make_u32regex_token_iterator(s2, e1, subs2, boost::regex_constants::match_default));
-   check_token_iterator(boost::make_u32regex_token_iterator(s2, e1, subs2));
-   check_token_iterator(boost::make_u32regex_token_iterator(us, e1, subs2, boost::regex_constants::match_default));
-   check_token_iterator(boost::make_u32regex_token_iterator(us, e1, subs2));
-
-   check_token_iterator(boost::make_u32regex_token_iterator((const char*)(pb), e1, subs1, boost::regex_constants::match_default));
-   check_token_iterator(boost::make_u32regex_token_iterator((const char*)(pb), e1, subs1));
-   check_token_iterator(boost::make_u32regex_token_iterator((const UChar*)(pb), e1, subs1, boost::regex_constants::match_default));
-   check_token_iterator(boost::make_u32regex_token_iterator((const UChar*)(pb), e1, subs1));
-   check_token_iterator(boost::make_u32regex_token_iterator((const wchar_t*)(pb), e1, subs1, boost::regex_constants::match_default));
-   check_token_iterator(boost::make_u32regex_token_iterator((const wchar_t*)(pb), e1, subs1));
-   check_token_iterator(boost::make_u32regex_token_iterator(s1, e1, subs1, boost::regex_constants::match_default));
-   check_token_iterator(boost::make_u32regex_token_iterator(s1, e1, subs1));
-   check_token_iterator(boost::make_u32regex_token_iterator(s2, e1, subs1, boost::regex_constants::match_default));
-   check_token_iterator(boost::make_u32regex_token_iterator(s2, e1, subs1));
-   check_token_iterator(boost::make_u32regex_token_iterator(us, e1, subs1, boost::regex_constants::match_default));
-   check_token_iterator(boost::make_u32regex_token_iterator(us, e1, subs1));
-
-   check_iterator(boost::make_u32regex_iterator((const char*)(pb), e1, boost::regex_constants::match_default));
-   check_iterator(boost::make_u32regex_iterator((const char*)(pb), e1));
-   check_iterator(boost::make_u32regex_iterator((const UChar*)(pb), e1, boost::regex_constants::match_default));
-   check_iterator(boost::make_u32regex_iterator((const UChar*)(pb), e1));
-   check_iterator(boost::make_u32regex_iterator((const wchar_t*)(pb), e1, boost::regex_constants::match_default));
-   check_iterator(boost::make_u32regex_iterator((const wchar_t*)(pb), e1));
-   check_iterator(boost::make_u32regex_iterator(s1, e1, boost::regex_constants::match_default));
-   check_iterator(boost::make_u32regex_iterator(s2, e1));
-   check_iterator(boost::make_u32regex_iterator(us, e1));
-
 #endif   
    return 0;
 }

test/de_fuzz/corpus/0334845542326f79e3fafbe94969c6b369f004bc

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

test/de_fuzz/corpus/07284125555baeddc03d1a3637df0ccbcab9d5fb

@@ -1 +0,0 @@
-
Z(((((((a+)+)+)+)+<2B><><EFBFBD><EFBFBD>)+|Y(((((((a+)+)+)+)+)++)+)|X(((((((a+)+)+)+)+)+)+)+|W((<28><>(((a+)+)+)+)+)+)+)+;|V((()++)+)+|CW(((((((a+)+)+)+((((a+)+)+)+)+)+)+)+|CZ(((((((a+)+)+)+)+)+)+)+|CY(((((((a+)+)+)+)+)+)+)+|CX(((((((a+)+)+)+)+)+)+)+|CW(((((((a+)+)+)+)+)+)+)+|CV,((((((a+)+)+)+)+)+)+)+|(a+)+bc