boostorg/regex
1
0
Fork 1
mirror of https://github.com/boostorg/regex.git synced 2025-07-17 06:12:10 +02:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'develop'

Browse Source
This commit is contained in:
jzmaddock
2018-09-15 08:59:28 +01:00
parent a9fc8fb5de 8a31a996b8
commit c653a0bf05
41 changed files with 428 additions and 115 deletions
Download Patch File Download Diff File Expand all files Collapse all files

37
.travis.yml
View File

@ -102,6 +102,42 @@ matrix:
sources: sources:
- ubuntu-toolchain-r-test - 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 - os: linux
env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11 env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11
@ -213,6 +249,7 @@ install:
- git submodule update --init tools/build - git submodule update --init tools/build
- git submodule update --init libs/config - git submodule update --init libs/config
- git submodule update --init libs/core - git submodule update --init libs/core
- git submodule update --init libs/container_hash
- git submodule update --init libs/detail - git submodule update --init libs/detail
- git submodule update --init libs/smart_ptr - git submodule update --init libs/smart_ptr
- git submodule update --init libs/predef - git submodule update --init libs/predef

1
appveyor.yml
View File

@ -47,6 +47,7 @@ install:
- git submodule update --init tools/build - git submodule update --init tools/build
- git submodule update --init libs/config - git submodule update --init libs/config
- git submodule update --init libs/core - git submodule update --init libs/core
- git submodule update --init libs/container_hash
- git submodule update --init libs/detail - git submodule update --init libs/detail
- git submodule update --init libs/smart_ptr - git submodule update --init libs/smart_ptr
- git submodule update --init libs/predef - git submodule update --init libs/predef

8
example/timer/regex_timer.cpp
View File

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

5
include/boost/regex/concepts.hpp
View File

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

12
include/boost/regex/config.hpp
View File

@ -113,6 +113,13 @@
#if defined(__MINGW32__) #if defined(__MINGW32__)
# define BOOST_REGEX_NO_EXTERNAL_TEMPLATES # define BOOST_REGEX_NO_EXTERNAL_TEMPLATES
#endif #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
/* /*
* If there isn't good enough wide character support then there will * If there isn't good enough wide character support then there will
@ -201,7 +208,10 @@
# define BOOST_REGEX_HAS_OTHER_WCHAR_T # define BOOST_REGEX_HAS_OTHER_WCHAR_T
# ifdef BOOST_MSVC # ifdef BOOST_MSVC
# pragma warning(push) # 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 # if BOOST_MSVC < 1600
# pragma warning(disable : 4660) # pragma warning(disable : 4660)
# endif # endif

39
include/boost/regex/icu.hpp
View File

@ -26,6 +26,7 @@
#include <boost/regex.hpp> #include <boost/regex.hpp>
#include <boost/regex/pending/unicode_iterator.hpp> #include <boost/regex/pending/unicode_iterator.hpp>
#include <boost/mpl/int_fwd.hpp> #include <boost/mpl/int_fwd.hpp>
#include <boost/static_assert.hpp>
#include <bitset> #include <bitset>
#ifdef BOOST_MSVC #ifdef BOOST_MSVC
@ -334,6 +335,34 @@ inline u32regex do_make_u32regex(InputIterator i,
#endif #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: // 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)); 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 #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) 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)); 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)); 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, inline bool u32regex_match(const wchar_t* p,
match_results<const wchar_t*>& m, match_results<const wchar_t*>& m,
const u32regex& e, const u32regex& e,
@ -545,7 +574,7 @@ inline bool u32regex_match(const UChar* p,
match_results<const UChar*> m; 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)); 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, inline bool u32regex_match(const wchar_t* p,
const u32regex& e, const u32regex& e,
match_flag_type flags = match_default) 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)); 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, inline bool u32regex_search(const wchar_t* p,
match_results<const wchar_t*>& m, match_results<const wchar_t*>& m,
const u32regex& e, const u32regex& e,
@ -727,7 +756,7 @@ inline bool u32regex_search(const UChar* p,
match_results<const UChar*> m; 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)); 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, inline bool u32regex_search(const wchar_t* p,
const u32regex& e, const u32regex& e,
match_flag_type flags = match_default) match_flag_type flags = match_default)

8
include/boost/regex/v4/basic_regex.hpp
View File

@ -36,10 +36,16 @@
namespace boost{ namespace boost{
#ifdef BOOST_MSVC #ifdef BOOST_MSVC
#pragma warning(push) #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 #if BOOST_MSVC < 1600
#pragma warning(disable : 4660) #pragma warning(disable : 4660)
#endif #endif
#if BOOST_MSVC < 1910
#pragma warning(disable:4800)
#endif
#endif #endif
namespace BOOST_REGEX_DETAIL_NS{ namespace BOOST_REGEX_DETAIL_NS{

4
include/boost/regex/v4/basic_regex_creator.hpp
View File

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

7
include/boost/regex/v4/basic_regex_parser.hpp
View File

@ -35,7 +35,10 @@ namespace BOOST_REGEX_DETAIL_NS{
#ifdef BOOST_MSVC #ifdef BOOST_MSVC
#pragma warning(push) #pragma warning(push)
#pragma warning(disable:4244 4800) #pragma warning(disable:4244)
#if BOOST_MSVC < 1910
#pragma warning(disable:4800)
#endif
#endif #endif
inline boost::intmax_t umax(mpl::false_ const&) 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 ')' : // have had an unexpected ')' :
if(!result) 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; return;
} }
// if an error has been set then give up now: // if an error has been set then give up now:

3
include/boost/regex/v4/fileiter.hpp
View File

@ -195,9 +195,6 @@ public:
}; };
class BOOST_REGEX_DECL mapfile_iterator 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; typedef mapfile::pointer internal_pointer;
internal_pointer* node; internal_pointer* node;

19
include/boost/regex/v4/instances.hpp
View File

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

3
include/boost/regex/v4/match_flags.hpp
View File

@ -22,7 +22,6 @@
#ifdef __cplusplus #ifdef __cplusplus
# include <boost/cstdint.hpp> # include <boost/cstdint.hpp>
#endif #endif
#include <boost/detail/workaround.hpp>
#ifdef __cplusplus #ifdef __cplusplus
namespace boost{ namespace boost{
@ -83,7 +82,7 @@ typedef enum _match_flags
} 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; typedef unsigned long match_flag_type;
#else #else
typedef match_flags match_flag_type; typedef match_flags match_flag_type;

15
include/boost/regex/v4/match_results.hpp
View File

@ -33,7 +33,10 @@
namespace boost{ namespace boost{
#ifdef BOOST_MSVC #ifdef BOOST_MSVC
#pragma warning(push) #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 # if BOOST_MSVC < 1600
# pragma warning(disable : 4660) # pragma warning(disable : 4660)
# endif # endif
@ -56,7 +59,9 @@ private:
#endif #endif
public: public:
typedef sub_match<BidiIterator> value_type; 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; typedef typename Allocator::const_reference const_reference;
#else #else
typedef const value_type& const_reference; typedef const value_type& const_reference;
@ -66,7 +71,11 @@ public:
typedef const_iterator iterator; typedef const_iterator iterator;
typedef typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits< typedef typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<
BidiIterator>::difference_type difference_type; BidiIterator>::difference_type difference_type;
#ifdef BOOST_NO_CXX11_ALLOCATOR
typedef typename Allocator::size_type size_type; typedef typename Allocator::size_type size_type;
#else
typedef typename std::allocator_traits<Allocator>::size_type size_type;
#endif
typedef Allocator allocator_type; typedef Allocator allocator_type;
typedef typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits< typedef typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<
BidiIterator>::value_type char_type; BidiIterator>::value_type char_type;
@ -563,7 +572,7 @@ private:
// //
static void raise_logic_error() 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); boost::throw_exception(e);
} }

9
include/boost/regex/v4/perl_matcher.hpp
View File

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

10
include/boost/regex/v4/perl_matcher_common.hpp
View File

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

8
include/boost/regex/v4/perl_matcher_non_recursive.hpp
View File

@ -34,7 +34,10 @@
#endif #endif
#ifdef BOOST_MSVC #ifdef BOOST_MSVC
# pragma warning(push) # pragma warning(push)
# pragma warning(disable: 4800 4706) # pragma warning(disable: 4706)
#if BOOST_MSVC < 1910
#pragma warning(disable:4800)
#endif
#endif #endif
namespace boost{ namespace boost{
@ -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 // Backtracking out of a recursion, we must pop state off the recursion
// stack unconditionally to ensure matched pushes and pops: // stack unconditionally to ensure matched pushes and pops:
saved_state* pmp = static_cast<saved_state*>(m_backup_state); saved_state* pmp = static_cast<saved_state*>(m_backup_state);
if (!r) if (!r && !recursion_stack.empty())
{ {
*m_presult = recursion_stack.back().results; *m_presult = recursion_stack.back().results;
position = recursion_stack.back().location_of_start; 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 // If we stop because we just unwound an assertion, put the
// commit state back on the stack again: // commit state back on the stack again:
// //
m_unwound_lookahead = false;
saved_state* pmp = m_backup_state; saved_state* pmp = m_backup_state;
--pmp; --pmp;
if(pmp < m_stack_base) if(pmp < m_stack_base)

5
include/boost/regex/v4/regex_format.hpp
View File

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

8
include/boost/regex/v4/regex_iterator.hpp
View File

@ -85,14 +85,6 @@ template <class BidirectionalIterator,
class charT = BOOST_DEDUCED_TYPENAME BOOST_REGEX_DETAIL_NS::regex_iterator_traits<BidirectionalIterator>::value_type, class charT = BOOST_DEDUCED_TYPENAME BOOST_REGEX_DETAIL_NS::regex_iterator_traits<BidirectionalIterator>::value_type,
class traits = regex_traits<charT> > class traits = regex_traits<charT> >
class regex_iterator 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: private:
typedef regex_iterator_implementation<BidirectionalIterator, charT, traits> impl; typedef regex_iterator_implementation<BidirectionalIterator, charT, traits> impl;

6
include/boost/regex/v4/regex_raw_buffer.hpp
View File

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

4
include/boost/regex/v4/regex_split.hpp
View File

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

8
include/boost/regex/v4/regex_token_iterator.hpp
View File

@ -167,14 +167,6 @@ template <class BidirectionalIterator,
class charT = BOOST_DEDUCED_TYPENAME BOOST_REGEX_DETAIL_NS::regex_iterator_traits<BidirectionalIterator>::value_type, class charT = BOOST_DEDUCED_TYPENAME BOOST_REGEX_DETAIL_NS::regex_iterator_traits<BidirectionalIterator>::value_type,
class traits = regex_traits<charT> > class traits = regex_traits<charT> >
class regex_token_iterator 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: private:
typedef regex_token_iterator_implementation<BidirectionalIterator, charT, traits> impl; typedef regex_token_iterator_implementation<BidirectionalIterator, charT, traits> impl;

23
include/boost/regex/v4/regex_traits_defaults.hpp
View File

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

11
include/boost/regex/v4/regex_workaround.hpp
View File

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

10
include/boost/regex/v4/u32regex_iterator.hpp
View File

@ -72,14 +72,6 @@ private:
template <class BidirectionalIterator> template <class BidirectionalIterator>
class u32regex_iterator 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: private:
typedef u32regex_iterator_implementation<BidirectionalIterator> impl; 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); return u32regex_iterator<const wchar_t*>(p, p+std::wcslen(p), e, m);
} }
#endif #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) 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); return u32regex_iterator<const UChar*>(p, p+u_strlen(p), e, m);

12
include/boost/regex/v4/u32regex_token_iterator.hpp
View File

@ -155,14 +155,6 @@ private:
template <class BidirectionalIterator> template <class BidirectionalIterator>
class u32regex_token_iterator 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: private:
typedef u32regex_token_iterator_implementation<BidirectionalIterator> impl; 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); return u32regex_token_iterator<const wchar_t*>(p, p+std::wcslen(p), e, submatch, m);
} }
#endif #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) 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); 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); return u32regex_token_iterator<const wchar_t*>(p, p+std::wcslen(p), e, submatch, m);
} }
#endif #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> 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) 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)
{ {

2
include/boost/regex/v4/w32_regex_traits.hpp
View File

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

6
src/cregex.cpp
View File

@ -491,8 +491,8 @@ std::size_t RegEx::Position(int i)const
{ {
case BOOST_REGEX_DETAIL_NS::RegExData::type_pc: case BOOST_REGEX_DETAIL_NS::RegExData::type_pc:
return pdata->m[i].matched ? pdata->m[i].first - pdata->pbase : RegEx::npos; 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: 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; return pdata->fm[i].matched ? pdata->fm[i].first - pdata->fbase : RegEx::npos;
#endif #endif
case BOOST_REGEX_DETAIL_NS::RegExData::type_copy: 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: case BOOST_REGEX_DETAIL_NS::RegExData::type_pc:
return pdata->m[i].matched ? pdata->m[i].second - pdata->m[i].first : RegEx::npos; 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: 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; return pdata->fm[i].matched ? pdata->fm[i].second - pdata->fm[i].first : RegEx::npos;
#endif #endif
case BOOST_REGEX_DETAIL_NS::RegExData::type_copy: case BOOST_REGEX_DETAIL_NS::RegExData::type_copy:
@ -539,8 +539,8 @@ bool RegEx::Matched(int i)const
{ {
case BOOST_REGEX_DETAIL_NS::RegExData::type_pc: case BOOST_REGEX_DETAIL_NS::RegExData::type_pc:
return pdata->m[i].matched; return pdata->m[i].matched;
#ifndef BOOST_REGEX_NO_FILEITER
case BOOST_REGEX_DETAIL_NS::RegExData::type_pf: case BOOST_REGEX_DETAIL_NS::RegExData::type_pf:
#ifndef BOOST_REGEX_NO_FILEITER
return pdata->fm[i].matched; return pdata->fm[i].matched;
#endif #endif
case BOOST_REGEX_DETAIL_NS::RegExData::type_copy: case BOOST_REGEX_DETAIL_NS::RegExData::type_copy:

2
src/fileiter.cpp
View File

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

2
src/icu.cpp
View File

@ -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 bool icu_regex_traits::isctype(char_type c, char_class_type f) const
{ {
// check for standard catagories first: // 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) if((m & f) != 0)
return true; return true;
// now check for special cases: // now check for special cases:

6
test/Jamfile.v2
View File

@ -194,4 +194,10 @@ compile test_consolidated.cpp ;
build-project ../example ; 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 ;

4
test/c_compiler_checks/posix_api_check.c
View File

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

4
test/c_compiler_checks/wide_posix_api_check.c
View File

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

4
test/captures/captures_test.cpp
View File

@ -29,9 +29,9 @@
#define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0])) #define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))
template <int N> 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) if(p[i] == 0)
return i; return i;
return N; return N;

85
test/concepts/icu_concept_check.cpp
View File

@ -33,7 +33,34 @@
#include <boost/regex/concepts.hpp> #include <boost/regex/concepts.hpp>
#endif #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() int main()
{ {
// VC6 and VC7 can't cope with the iterator architypes, // VC6 and VC7 can't cope with the iterator architypes,
@ -150,6 +177,64 @@ int main()
s1 = boost::u32regex_replace(s1, e1, s1); s1 = boost::u32regex_replace(s1, e1, s1);
s2 = boost::u32regex_replace(s2, e1, s2); 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 #endif
return 0; return 0;
} }

55
test/quick.cpp Normal file
View File

@ -0,0 +1,55 @@
// Copyright 1998-2002 John Maddock
// Copyright 2017 Peter Dimov
//
// Distributed under the Boost Software License, Version 1.0.
//
// See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt
// See library home page at http://www.boost.org/libs/regex
#include <boost/regex.hpp>
#include <boost/core/lightweight_test.hpp>
#include <string>
bool validate_card_format(const std::string& s)
{
static const boost::regex e("(\\d{4}[- ]){3}\\d{4}");
return boost::regex_match(s, e);
}
const boost::regex card_rx("\\A(\\d{3,4})[- ]?(\\d{4})[- ]?(\\d{4})[- ]?(\\d{4})\\z");
const std::string machine_format("\\1\\2\\3\\4");
const std::string human_format("\\1-\\2-\\3-\\4");
std::string machine_readable_card_number(const std::string& s)
{
return boost::regex_replace(s, card_rx, machine_format, boost::match_default | boost::format_sed);
}
std::string human_readable_card_number(const std::string& s)
{
return boost::regex_replace(s, card_rx, human_format, boost::match_default | boost::format_sed);
}
int main()
{
std::string s[ 4 ] = { "0000111122223333", "0000 1111 2222 3333", "0000-1111-2222-3333", "000-1111-2222-3333" };
BOOST_TEST( !validate_card_format( s[0] ) );
BOOST_TEST_EQ( machine_readable_card_number( s[0] ), s[0] );
BOOST_TEST_EQ( human_readable_card_number( s[0] ), s[2] );
BOOST_TEST( validate_card_format( s[1] ) );
BOOST_TEST_EQ( machine_readable_card_number( s[1] ), s[0] );
BOOST_TEST_EQ( human_readable_card_number( s[1] ), s[2] );
BOOST_TEST( validate_card_format( s[2] ) );
BOOST_TEST_EQ( machine_readable_card_number( s[2] ), s[0] );
BOOST_TEST_EQ( human_readable_card_number( s[2] ), s[2] );
BOOST_TEST( !validate_card_format( s[3] ) );
return boost::report_errors();
}

43
test/regress/test_escapes.cpp
View File

@ -169,5 +169,48 @@ void test_assertion_escapes()
TEST_REGEX_SEARCH_W(L"(?x) abc \\R", perl, L"abc\u2028bar", match_default, make_array(0, 4, -2, -2)); TEST_REGEX_SEARCH_W(L"(?x) abc \\R", perl, L"abc\u2028bar", match_default, make_array(0, 4, -2, -2));
TEST_REGEX_SEARCH_W(L"(?x) abc \\R", perl, L"abc\u2029bar", match_default, make_array(0, 4, -2, -2)); TEST_REGEX_SEARCH_W(L"(?x) abc \\R", perl, L"abc\u2029bar", match_default, make_array(0, 4, -2, -2));
} }
// Bug report: https://github.com/boostorg/regex/issues/40
TEST_REGEX_SEARCH("\\b", perl, "", match_default, make_array(-2, -2));
TEST_REGEX_SEARCH("\\b", perl, "", match_not_bow, make_array(-2, -2));
TEST_REGEX_SEARCH("\\b", perl, "", match_not_eow, make_array(-2, -2));
TEST_REGEX_SEARCH("\\b", perl, "", match_not_bow | match_not_eow, make_array(-2, -2));
TEST_REGEX_SEARCH("\\b", perl, "-", match_default, make_array(-2, -2));
TEST_REGEX_SEARCH("\\b", perl, "-", match_not_bow, make_array(-2, -2));
TEST_REGEX_SEARCH("\\b", perl, "-", match_not_eow, make_array(-2, -2));
TEST_REGEX_SEARCH("\\b", perl, "-", match_not_bow | match_not_eow, make_array(-2, -2));
TEST_REGEX_SEARCH("\\<", perl, "", match_default, make_array(-2, -2));
TEST_REGEX_SEARCH("\\<", perl, "", match_not_bow, make_array(-2, -2));
TEST_REGEX_SEARCH("\\<", perl, "", match_not_eow, make_array(-2, -2));
TEST_REGEX_SEARCH("\\<", perl, "", match_not_bow | match_not_eow, make_array(-2, -2));
TEST_REGEX_SEARCH("\\<", perl, "-", match_default, make_array(-2, -2));
TEST_REGEX_SEARCH("\\<", perl, "-", match_not_bow, make_array(-2, -2));
TEST_REGEX_SEARCH("\\<", perl, "-", match_not_eow, make_array(-2, -2));
TEST_REGEX_SEARCH("\\<", perl, "-", match_not_bow | match_not_eow, make_array(-2, -2));
TEST_REGEX_SEARCH("\\>", perl, "", match_default, make_array(-2, -2));
TEST_REGEX_SEARCH("\\>", perl, "", match_not_bow, make_array(-2, -2));
TEST_REGEX_SEARCH("\\>", perl, "", match_not_eow, make_array(-2, -2));
TEST_REGEX_SEARCH("\\>", perl, "", match_not_bow | match_not_eow, make_array(-2, -2));
TEST_REGEX_SEARCH("\\>", perl, "-", match_default, make_array(-2, -2));
TEST_REGEX_SEARCH("\\>", perl, "-", match_not_bow, make_array(-2, -2));
TEST_REGEX_SEARCH("\\>", perl, "-", match_not_eow, make_array(-2, -2));
TEST_REGEX_SEARCH("\\>", perl, "-", match_not_bow | match_not_eow, make_array(-2, -2));
// Bug report https://github.com/boostorg/regex/issues/57
// Line ending \R:
TEST_REGEX_SEARCH("\\R", perl | no_escape_in_lists, "foo\nbar", match_default, make_array(3, 4, -2, -2));
TEST_REGEX_SEARCH("\\R", perl | no_escape_in_lists, "foo\rbar", match_default, make_array(3, 4, -2, -2));
TEST_REGEX_SEARCH("\\R", perl | no_escape_in_lists, "foo\r\nbar", match_default, make_array(3, 5, -2, -2));
TEST_REGEX_SEARCH("(?x) abc \\R", perl | no_escape_in_lists, "abc\r\nbar", match_default, make_array(0, 5, -2, -2));
TEST_REGEX_SEARCH("(?x) abc \\R", perl | no_escape_in_lists, "abc\012bar", match_default, make_array(0, 4, -2, -2));
TEST_REGEX_SEARCH("(?x) abc \\R", perl | no_escape_in_lists, "abc\013bar", match_default, make_array(0, 4, -2, -2));
TEST_REGEX_SEARCH("(?x) abc \\R", perl | no_escape_in_lists, "abc\013bar", match_default, make_array(0, 4, -2, -2));
TEST_REGEX_SEARCH("(?x) abc \\R", perl | no_escape_in_lists, "abc\205bar", match_default, make_array(0, 4, -2, -2));
// see if \u works:
if(*w == 0x2028u)
{
TEST_REGEX_SEARCH_W(L"\\R", perl | no_escape_in_lists, L"foo\u2028bar", match_default, make_array(3, 4, -2, -2));
TEST_REGEX_SEARCH_W(L"\\R", perl | no_escape_in_lists, L"foo\u2029bar", match_default, make_array(3, 4, -2, -2));
TEST_REGEX_SEARCH_W(L"(?x) abc \\R", perl | no_escape_in_lists, L"abc\u2028bar", match_default, make_array(0, 4, -2, -2));
TEST_REGEX_SEARCH_W(L"(?x) abc \\R", perl | no_escape_in_lists, L"abc\u2029bar", match_default, make_array(0, 4, -2, -2));
}
} }

8
test/regress/test_icu.cpp
View File

@ -33,16 +33,16 @@ namespace unnecessary_fix{
// //
template <class Seq> template <class Seq>
class back_insert_iterator class back_insert_iterator
#ifndef BOOST_NO_STD_ITERATOR
: public std::iterator<std::output_iterator_tag,void,void,void,void>
#endif
{ {
private: private:
Seq* container; Seq* container;
public: public:
typedef const typename Seq::value_type value_type; typedef const typename Seq::value_type value_type;
typedef Seq container_type; typedef Seq container_type;
typedef std::output_iterator_tag iterator_category; typedef void difference_type;
typedef void pointer;
typedef void reference;
typedef std::output_iterator_tag iterator_category;
explicit back_insert_iterator(Seq& x) : container(&x) {} explicit back_insert_iterator(Seq& x) : container(&x) {}
back_insert_iterator& operator=(const value_type& val) back_insert_iterator& operator=(const value_type& val)

4
test/regress/test_locale.cpp
View File

@ -49,7 +49,9 @@ test_locale::test_locale(const char* c_name, boost::uint32_t lcid)
#else #else
s_c_locale = no_test; s_c_locale = no_test;
#endif #endif
#if !defined(BOOST_NO_STD_LOCALE) && !defined(BOOST_NO_EXCEPTIONS) // Disabled for VC15.7 (and later?) as the C runtime asserts if you pass an invalid
// locale name to std::locale, rather than throwing the expected exception.
#if !defined(BOOST_NO_STD_LOCALE) && !defined(BOOST_NO_EXCEPTIONS) && !BOOST_WORKAROUND(BOOST_MSVC, > 1913)
// back up the C++ locale and create the new one: // back up the C++ locale and create the new one:
m_old_cpp_locale = s_cpp_locale_inst; m_old_cpp_locale = s_cpp_locale_inst;
m_old_cpp_state = s_cpp_locale; m_old_cpp_state = s_cpp_locale;

4
test/test_macros.hpp
View File

@ -65,8 +65,8 @@ void report_unexpected_exception(const E& e, int severity, const char* file, int
} }
#define BOOST_MP_UNEXPECTED_EXCEPTION_CHECK(severity) \ #define BOOST_MP_UNEXPECTED_EXCEPTION_CHECK(severity) \
catch(const std::exception& e) \ catch(const std::exception& __e) \
{ report_unexpected_exception(e, severity, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION); }\ { report_unexpected_exception(__e, severity, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION); }\
catch(...)\ catch(...)\
{ BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Exception of unknown type was thrown" << std::endl; report_severity(severity); } { BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Exception of unknown type was thrown" << std::endl; report_severity(severity); }

29
test/test_warnings.cpp Normal file
View File

@ -0,0 +1,29 @@
/*
*
* Copyright (c) 2018
* John Maddock
*
* Use, modification and distribution are subject to the
* Boost Software License, Version 1.0. (See accompanying file
* LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
*
*/
#ifdef _MSC_VER
#pragma warning(disable:4820 4668)
#endif
#ifdef __APPLE_CC__
#pragma clang diagnostic ignored "-Wc++11-long-long"
#endif
#include <boost/regex.hpp>
void test_proc()
{
std::string text, re;
boost::regex exp(re);
regex_match(text, exp);
}

8
test/unicode/unicode_iterator_test.cpp
View File

@ -157,22 +157,30 @@ void spot_checks()
void test(const std::vector< ::boost::uint32_t>& v) void test(const std::vector< ::boost::uint32_t>& v)
{ {
typedef std::vector< ::boost::uint32_t> vector32_type; typedef std::vector< ::boost::uint32_t> vector32_type;
#ifdef TEST_UTF16
typedef std::vector< ::boost::uint16_t> vector16_type; typedef std::vector< ::boost::uint16_t> vector16_type;
#endif
typedef std::vector< ::boost::uint8_t> vector8_type; typedef std::vector< ::boost::uint8_t> vector8_type;
#ifdef TEST_UTF16
typedef boost::u32_to_u16_iterator<vector32_type::const_iterator, ::boost::uint16_t> u32to16type; typedef boost::u32_to_u16_iterator<vector32_type::const_iterator, ::boost::uint16_t> u32to16type;
typedef boost::u16_to_u32_iterator<vector16_type::const_iterator, ::boost::uint32_t> u16to32type; typedef boost::u16_to_u32_iterator<vector16_type::const_iterator, ::boost::uint32_t> u16to32type;
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_NO_STD_ITERATOR) && !defined(_RWSTD_NO_CLASS_PARTIAL_SPEC) #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_NO_STD_ITERATOR) && !defined(_RWSTD_NO_CLASS_PARTIAL_SPEC)
typedef std::reverse_iterator<u32to16type> ru32to16type; typedef std::reverse_iterator<u32to16type> ru32to16type;
typedef std::reverse_iterator<u16to32type> ru16to32type; typedef std::reverse_iterator<u16to32type> ru16to32type;
#endif #endif
#endif // TEST_UTF16
#ifdef TEST_UTF8
typedef boost::u32_to_u8_iterator<vector32_type::const_iterator, ::boost::uint8_t> u32to8type; typedef boost::u32_to_u8_iterator<vector32_type::const_iterator, ::boost::uint8_t> u32to8type;
typedef boost::u8_to_u32_iterator<vector8_type::const_iterator, ::boost::uint32_t> u8to32type; typedef boost::u8_to_u32_iterator<vector8_type::const_iterator, ::boost::uint32_t> u8to32type;
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_NO_STD_ITERATOR) && !defined(_RWSTD_NO_CLASS_PARTIAL_SPEC) #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_NO_STD_ITERATOR) && !defined(_RWSTD_NO_CLASS_PARTIAL_SPEC)
typedef std::reverse_iterator<u32to8type> ru32to8type; typedef std::reverse_iterator<u32to8type> ru32to8type;
typedef std::reverse_iterator<u8to32type> ru8to32type; typedef std::reverse_iterator<u8to32type> ru8to32type;
#endif #endif
#endif // TEST_UTF8
vector8_type v8; vector8_type v8;
#ifdef TEST_UTF16
vector16_type v16; vector16_type v16;
#endif
vector32_type v32; vector32_type v32;
vector32_type::const_iterator i, j, k; vector32_type::const_iterator i, j, k;