Move ICU <dll-path> from usage requirements to install requirements

Update hash.hpp include path

.travis.yml

@@ -102,6 +102,42 @@ 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
 
@@ -211,8 +247,11 @@ 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

@@ -0,0 +1,36 @@
+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,13 +23,15 @@ 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 cxxflags=-std:c++latest
+    - ARGS: --toolset=msvc-14.0 address-model=64 cxxstd=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 cxxflags=-std:c++latest
+      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=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
@@ -38,15 +40,21 @@ 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,6 +30,10 @@ rule path_options ( properties * )
 #
 # ICU configuration:
 #
+
+local ICU_OPTS ;
+local ICU_INSTALL_OPTS ;
+
 if ! $(disable-icu)
 {
 
@@ -44,7 +48,8 @@ if ! $(disable-icu)
 
    if $(ICU_LINK)
    {
-      ICU_OPTS = <include>$(ICU_PATH)/include <linkflags>$(ICU_LINK) <dll-path>$(ICU_PATH)/bin <define>BOOST_HAS_ICU=1 <runtime-link>shared ;
+      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 ;
    }
    else
    {
@@ -122,12 +127,4 @@ lib boost_regex : ../src/$(SOURCES) icu_options
 	     <toolset>gcc-cygwin:<link>static
     ;
 
-boost-install boost_regex ;
-
-
-
-
-
-
-
-
+boost-install boost_regex : $(ICU_INSTALL_OPTS) ;

example/timer/regex_timer.cpp

@@ -67,18 +67,14 @@ 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
 {
-#ifdef BOOST_NO_STD_ITERATOR
+public:
    typedef std::output_iterator_tag iterator_category;
    typedef void value_type;
    typedef void difference_type;
    typedef void pointer;
    typedef void reference;
-#endif // BOOST_NO_STD_ITERATOR
-
+private:
    S* out;
 public:
    string_out_iterator(S& s) : out(&s) {}

include/boost/regex/concepts.hpp

@@ -437,7 +437,8 @@ struct BaseRegexConcept
       ignore_unused_variable_warning(bi);
       sub_diff_type diff = m_sub.length();
       ignore_unused_variable_warning(diff);
-      // match_results tests:
+      // 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;
       typedef typename match_results_type::const_reference mr_const_reference;
       typedef typename match_results_type::reference mr_reference;
@@ -483,7 +484,7 @@ struct BaseRegexConcept
       mrci = m_cresults.end();
       ignore_unused_variable_warning(mrci);
 
-      mr_allocator_type at2 = m_cresults.get_allocator();
+      (void) m_cresults.get_allocator();
       m_results.swap(m_results);
       global_regex_namespace::swap(m_results, m_results);
 

include/boost/regex/config.hpp

@@ -113,6 +113,17 @@
 #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
@@ -201,7 +212,10 @@
 #  define BOOST_REGEX_HAS_OTHER_WCHAR_T
 #  ifdef BOOST_MSVC
 #     pragma warning(push)
-#     pragma warning(disable : 4251 4231)
+#     pragma warning(disable : 4251)
+#if BOOST_MSVC < 1700
+#     pragma warning(disable : 4231)
+#endif
 #     if BOOST_MSVC < 1600
 #        pragma warning(disable : 4660)
 #     endif

include/boost/regex/icu.hpp

@@ -26,6 +26,7 @@
 #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
@@ -334,6 +335,34 @@ 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:
 //
@@ -364,7 +393,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 !defined(U_WCHAR_IS_UTF16) && (U_SIZEOF_WCHAR_T != 2)
+#if !BOOST_REGEX_UCHAR_IS_WCHAR_T
 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));
@@ -481,7 +510,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 !defined(U_WCHAR_IS_UTF16) && (U_SIZEOF_WCHAR_T != 2) && !defined(BOOST_NO_WREGEX)
+#if !BOOST_REGEX_UCHAR_IS_WCHAR_T && !defined(BOOST_NO_WREGEX)
 inline bool u32regex_match(const wchar_t* p, 
                  match_results<const wchar_t*>& m, 
                  const u32regex& e, 
@@ -545,7 +574,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 !defined(U_WCHAR_IS_UTF16) && (U_SIZEOF_WCHAR_T != 2) && !defined(BOOST_NO_WREGEX)
+#if !BOOST_REGEX_UCHAR_IS_WCHAR_T && !defined(BOOST_NO_WREGEX)
 inline bool u32regex_match(const wchar_t* p, 
                  const u32regex& e, 
                  match_flag_type flags = match_default)
@@ -666,7 +695,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 !defined(U_WCHAR_IS_UTF16) && (U_SIZEOF_WCHAR_T != 2) && !defined(BOOST_NO_WREGEX)
+#if !BOOST_REGEX_UCHAR_IS_WCHAR_T && !defined(BOOST_NO_WREGEX)
 inline bool u32regex_search(const wchar_t* p, 
                  match_results<const wchar_t*>& m, 
                  const u32regex& e, 
@@ -727,7 +756,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 !defined(U_WCHAR_IS_UTF16) && (U_SIZEOF_WCHAR_T != 2) && !defined(BOOST_NO_WREGEX)
+#if !BOOST_REGEX_UCHAR_IS_WCHAR_T && !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/functional/hash.hpp>
+#include <boost/container_hash/hash.hpp>
 
 #ifdef BOOST_MSVC
 #pragma warning(push)
@@ -36,10 +36,16 @@
 namespace boost{
 #ifdef BOOST_MSVC
 #pragma warning(push)
-#pragma warning(disable : 4251 4231 4800)
+#pragma warning(disable : 4251)
+#if BOOST_MSVC < 1700
+#     pragma warning(disable : 4231)
+#endif
 #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,7 +33,9 @@
 
 #ifdef BOOST_MSVC
 #  pragma warning(push)
-#  pragma warning(disable: 4800)
+#if BOOST_MSVC < 1910
+#pragma warning(disable:4800)
+#endif
 #endif
 
 namespace boost{

include/boost/regex/v4/basic_regex_parser.hpp

@@ -35,7 +35,10 @@ namespace BOOST_REGEX_DETAIL_NS{
 
 #ifdef BOOST_MSVC
 #pragma warning(push)
-#pragma warning(disable:4244 4800)
+#pragma warning(disable:4244)
+#if BOOST_MSVC < 1910
+#pragma warning(disable:4800)
+#endif
 #endif
 
 inline boost::intmax_t umax(mpl::false_ const&)
@@ -183,7 +186,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 openening parenthesis.");
+      fail(regex_constants::error_paren, ::boost::BOOST_REGEX_DETAIL_NS::distance(m_base, m_position), "Found a closing ) with no corresponding opening parenthesis.");
       return;
    }
    // if an error has been set then give up now:

include/boost/regex/v4/fileiter.hpp

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

include/boost/regex/v4/match_flags.hpp

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

include/boost/regex/v4/match_results.hpp

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

include/boost/regex/v4/perl_matcher.hpp

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

include/boost/regex/v4/perl_matcher_common.hpp

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

include/boost/regex/v4/perl_matcher_non_recursive.hpp

@@ -34,7 +34,10 @@
 #endif
 #ifdef BOOST_MSVC
 #  pragma warning(push)
-#  pragma warning(disable: 4800 4706)
+#  pragma warning(disable: 4706)
+#if BOOST_MSVC < 1910
+#pragma warning(disable:4800)
+#endif
 #endif
 
 namespace boost{
@@ -64,7 +67,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>
@@ -72,7 +75,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>
@@ -80,7 +83,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>
@@ -1797,7 +1800,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)
+   if (!r && !recursion_stack.empty())
    {
       *m_presult = recursion_stack.back().results;
       position = recursion_stack.back().location_of_start;
@@ -1834,6 +1837,7 @@ 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,9 +800,6 @@ 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:
@@ -816,13 +813,11 @@ 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,14 +85,6 @@ 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 end - start;
+      return size_type(end - start);
    }
 
    size_type BOOST_REGEX_CALL capacity()
    {
-      return last - start;
+      return size_type(last - start);
    }
 
    void* BOOST_REGEX_CALL data()const
@@ -153,7 +153,7 @@ public:
 
    size_type BOOST_REGEX_CALL index(void* ptr)
    {
-      return static_cast<pointer>(ptr) - static_cast<pointer>(data());
+      return size_type(static_cast<pointer>(ptr) - static_cast<pointer>(data()));
    }
 
    void BOOST_REGEX_CALL clear()

include/boost/regex/v4/regex_split.hpp

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

include/boost/regex/v4/regex_token_iterator.hpp

@@ -167,14 +167,6 @@ 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,6 +39,7 @@
 #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{
@@ -240,7 +241,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::wcslen)(p);
+   return (std::ptrdiff_t)(std::wcslen)(p);
 }
 #endif
 template <class charT>
@@ -327,17 +328,17 @@ boost::intmax_t global_toi(const charT*& p1, const charT* p2, int radix, const t
 }
 
 template <class charT>
-inline const charT* get_escape_R_string()
+inline typename boost::enable_if_c<(sizeof(charT) > 1), const charT*>::type get_escape_R_string()
 {
 #ifdef BOOST_MSVC
 #  pragma warning(push)
 #  pragma warning(disable:4309 4245)
 #endif
-   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' };
+   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' };
 
    charT c = static_cast<charT>(0x2029u);
    bool b = (static_cast<unsigned>(c) == 0x2029u);
@@ -348,15 +349,15 @@ inline const charT* get_escape_R_string()
 #endif
 }
 
-template <>
-inline const char* get_escape_R_string<char>()
+template <class charT>
+inline typename boost::disable_if_c<(sizeof(charT) > 1), const charT*>::type get_escape_R_string()
 {
 #ifdef BOOST_MSVC
 #  pragma warning(push)
 #  pragma warning(disable:4309)
 #endif
-   static const char e2[] = { '(', '?', '>', '\\', 'x', '0', 'D', '\\', 'x', '0', 'A', '?',
-      '|', '[', '\\', 'x', '0', 'A', '\\', 'x', '0', 'B', '\\', 'x', '0', 'C', '\\', 'x', '8', '5', ']', ')', '\0' };
+   static const charT e2[] = { '(', '?', '-', 'x', ':', '(', '?', '>', '\x0D', '\x0A', '?',
+      '|', '[', '\x0A', '\x0B', '\x0C', '\x85', ']', ')', ')', '\0' };
    return e2;
 #ifdef BOOST_MSVC
 #  pragma warning(pop)

include/boost/regex/v4/regex_workaround.hpp

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

include/boost/regex/v4/u32regex_iterator.hpp

@@ -72,14 +72,6 @@ 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;
@@ -166,7 +158,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(U_WCHAR_IS_UTF16) && (U_SIZEOF_WCHAR_T != 2)
+#if !defined(BOOST_REGEX_UCHAR_IS_WCHAR_T)
 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,14 +155,6 @@ 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;
@@ -275,7 +267,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(U_WCHAR_IS_UTF16) && (U_SIZEOF_WCHAR_T != 2)
+#if !defined(BOOST_REGEX_UCHAR_IS_WCHAR_T)
 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);
@@ -305,7 +297,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(U_WCHAR_IS_UTF16) && (U_SIZEOF_WCHAR_T != 2)
+#if !defined(BOOST_REGEX_UCHAR_IS_WCHAR_T)
 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,8 +51,10 @@
 #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/functional/hash.hpp>
+#include <boost/container_hash/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;
-#ifndef BOOST_REGEX_NO_FILEITER
    case BOOST_REGEX_DETAIL_NS::RegExData::type_pf:
+#ifndef BOOST_REGEX_NO_FILEITER
       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;
-#ifndef BOOST_REGEX_NO_FILEITER
    case BOOST_REGEX_DETAIL_NS::RegExData::type_pf:
+#ifndef BOOST_REGEX_NO_FILEITER
       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;
-#ifndef BOOST_REGEX_NO_FILEITER
    case BOOST_REGEX_DETAIL_NS::RegExData::type_pf:
+#ifndef BOOST_REGEX_NO_FILEITER
       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(1u << u_charType(c));
+   char_class_type m = char_class_type(static_cast<char_class_type>(1) << u_charType(c));
    if((m & f) != 0) 
       return true;
    // now check for special cases:

src/regex.cpp

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

src/static_mutex.cpp

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

src/w32_regex_traits.cpp

@@ -23,7 +23,9 @@
 #include <boost/regex/regex_traits.hpp>
 #include <boost/regex/pattern_except.hpp>
 
-#define WIN32_LEAN_AND_MEAN
+#ifndef WIN32_LEAN_AND_MEAN
+#  define WIN32_LEAN_AND_MEAN
+#endif
 #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,4 +194,10 @@ 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));
-      printf(buf);
+      puts(buf);
       return result;
    }
    assert(re.re_nsub == 0);
@@ -50,7 +50,7 @@ int main()
    {
       char buf[256];
       regerrorA(result, &re, buf, sizeof(buf));
-      printf(buf);
+      puts(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]);
-      printf(nbuf);
+      puts(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]);
-      printf(nbuf);
+      puts(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>
-int array_size(const char* (&p)[N])
+size_t array_size(const char* (&p)[N])
 {
-   for(int i = 0; i < N; ++i)
+   for(size_t i = 0; i < N; ++i)
       if(p[i] == 0)
          return i;
    return N;

test/concepts/icu_concept_check.cpp

@@ -33,7 +33,34 @@
 #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, 
@@ -150,6 +177,64 @@ 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

@@ -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)

test/de_fuzz/corpus/07284125555baeddc03d1a3637df0ccbcab9d5fb

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