feedc0de/boost_regex
1
0
Fork 0
forked from boostorg/regex
Code Pull Requests Activity

Add module support and tests. (#174)

Browse Source
This commit is contained in:
jzmaddock
2024-12-18 19:14:23 +00:00
committed by GitHub
parent f039773693
commit 7af2aadcb8
81 changed files with 3015 additions and 318 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -24,7 +24,7 @@
#include <boost/type_traits/is_enum.hpp>
#include <boost/type_traits/is_base_and_derived.hpp>
#include <boost/static_assert.hpp>
#ifndef BOOST_TEST_TR1_REGEX
#if !defined(BOOST_TEST_TR1_REGEX) && !defined(BOOST_REGEX_TEST_MODULE)
#include <boost/regex.hpp>
#endif
#include <bitset>
@ -37,6 +37,16 @@
#define RW_NS std
#endif
//
// alter this to std::tr1, to test a std implementation:
//
#ifndef BOOST_TEST_TR1_REGEX
namespace global_regex_namespace = ::boost;
#else
namespace global_regex_namespace = ::std::tr1;
#endif
namespace boost{
//
@ -178,15 +188,6 @@ private:
regex_traits_architype& operator=(const regex_traits_architype&){ return *this; }
};
//
// alter this to std::tr1, to test a std implementation:
//
#ifndef BOOST_TEST_TR1_REGEX
namespace global_regex_namespace = ::boost;
#else
namespace global_regex_namespace = ::std::tr1;
#endif
template <class Bitmask>
struct BitmaskConcept
{
@ -273,7 +274,7 @@ template <class Regex>
struct regex_traits_computer;
template <class charT, class traits>
struct regex_traits_computer< global_regex_namespace::basic_regex<charT, traits> >
struct regex_traits_computer< ::boost::basic_regex<charT, traits> >
{
typedef traits type;
};

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

@ -29,6 +29,22 @@
#endif
#endif
#ifndef BOOST_REGEX_MODULE_EXPORT
#define BOOST_REGEX_MODULE_EXPORT
#define BOOST_REGEX_STATIC_CONST static const
#else
#define BOOST_REGEX_STATIC_CONST inline constexpr
#define BOOST_REGEX_STANDALONE
#endif
/*
* Borland C++ Fix/error check
* this has to go *before* we include any std lib headers:
*/
#if defined(__BORLANDC__) && !defined(__clang__)
# include <boost/regex/config/borland.hpp>
#endif
#ifndef BOOST_REGEX_STANDALONE
#include <boost/version.hpp>
#endif
@ -40,9 +56,13 @@
*************************************************************************/
#ifdef BOOST_REGEX_STANDALONE
#ifndef BOOST_REGEX_AS_MODULE
#include <cassert>
# define BOOST_REGEX_ASSERT(x) assert(x)
#else
# define BOOST_REGEX_ASSERT(x) do{ if(x == 0) { std::printf("%s:%d Assertion Failed", __FILE__, __LINE__); std::abort(); } }while(0)
#endif
#else
#include <boost/assert.hpp>
# define BOOST_REGEX_ASSERT(x) BOOST_ASSERT(x)
#endif
@ -284,8 +304,6 @@
* If there are no exceptions then we must report critical-errors
* the only way we know how; by terminating.
*/
#include <cassert>
# define BOOST_REGEX_NOEH_ASSERT(x) assert(x);
#else
/*

53
include/boost/regex/v5/basic_regex.hpp
View File

@ -25,10 +25,12 @@
#include <boost/regex/v5/states.hpp>
#include <boost/regex/v5/regex_raw_buffer.hpp>
#ifndef BOOST_REGEX_AS_MODULE
#include <algorithm>
#include <limits>
#include <memory>
#include <vector>
#endif
namespace boost{
#ifdef BOOST_REGEX_MSVC
@ -67,7 +69,12 @@ void bubble_down_one(I first, I last)
}
}
static const int hash_value_mask = 1 << (std::numeric_limits<int>::digits - 1);
#ifndef BOOST_REGEX_AS_MODULE
static
#else
inline
#endif
const int hash_value_mask = 1 << (std::numeric_limits<int>::digits - 1);
template <class Iterator>
inline int hash_value_from_capture_name(Iterator i, Iterator j)
@ -315,7 +322,7 @@ public:
// represents the compiled
// regular expression:
//
BOOST_REGEX_MODULE_EXPORT
#ifdef BOOST_REGEX_NO_FWD
template <class charT, class traits = regex_traits<charT> >
#else
@ -652,22 +659,38 @@ private:
// and are designed to provide the strong exception guarantee
// (in the event of a throw, the state of the object remains unchanged).
//
namespace detail
{
template <class charT, class F, class Traits>
std::shared_ptr<BOOST_REGEX_DETAIL_NS::basic_regex_implementation<charT, Traits> > create_implemenation(const charT* p1, const charT* p2, F f, std::shared_ptr<boost::regex_traits_wrapper<Traits> > ptraits)
{
std::shared_ptr<BOOST_REGEX_DETAIL_NS::basic_regex_implementation<charT, Traits> > result;
if (!ptraits.get())
{
result = std::shared_ptr<BOOST_REGEX_DETAIL_NS::basic_regex_implementation<charT, Traits> >(new BOOST_REGEX_DETAIL_NS::basic_regex_implementation<charT, Traits>());
}
else
{
result = std::shared_ptr<BOOST_REGEX_DETAIL_NS::basic_regex_implementation<charT, Traits> >(new BOOST_REGEX_DETAIL_NS::basic_regex_implementation<charT, Traits>(ptraits));
}
result->assign(p1, p2, f);
return result;
}
#ifdef BOOST_REGEX_AS_MODULE
std::shared_ptr<BOOST_REGEX_DETAIL_NS::basic_regex_implementation<char, basic_regex<char>::traits_type> >
create_implemenation(const char* p1, const char* p2, basic_regex<char>::flag_type f, std::shared_ptr<boost::regex_traits_wrapper<basic_regex<char>::traits_type> > ptraits);
std::shared_ptr<BOOST_REGEX_DETAIL_NS::basic_regex_implementation<wchar_t, basic_regex<wchar_t>::traits_type> >
create_implemenation(const wchar_t* p1, const wchar_t* p2, basic_regex<wchar_t>::flag_type f, std::shared_ptr<boost::regex_traits_wrapper<basic_regex<wchar_t>::traits_type> > ptraits);
#endif
}
template <class charT, class traits>
basic_regex<charT, traits>& basic_regex<charT, traits>::do_assign(const charT* p1,
const charT* p2,
flag_type f)
{
std::shared_ptr<BOOST_REGEX_DETAIL_NS::basic_regex_implementation<charT, traits> > temp;
if(!m_pimpl.get())
{
temp = std::shared_ptr<BOOST_REGEX_DETAIL_NS::basic_regex_implementation<charT, traits> >(new BOOST_REGEX_DETAIL_NS::basic_regex_implementation<charT, traits>());
}
else
{
temp = std::shared_ptr<BOOST_REGEX_DETAIL_NS::basic_regex_implementation<charT, traits> >(new BOOST_REGEX_DETAIL_NS::basic_regex_implementation<charT, traits>(m_pimpl->m_ptraits));
}
temp->assign(p1, p2, f);
temp.swap(m_pimpl);
m_pimpl = detail::create_implemenation(p1, p2, f, m_pimpl.get() ? m_pimpl->m_ptraits : std::shared_ptr<boost::regex_traits_wrapper<traits> >());
return *this;
}
@ -683,13 +706,13 @@ typename basic_regex<charT, traits>::locale_type basic_regex<charT, traits>::im
//
// non-members:
//
template <class charT, class traits>
BOOST_REGEX_MODULE_EXPORT template <class charT, class traits>
void swap(basic_regex<charT, traits>& e1, basic_regex<charT, traits>& e2)
{
e1.swap(e2);
}
template <class charT, class traits, class traits2>
BOOST_REGEX_MODULE_EXPORT template <class charT, class traits, class traits2>
std::basic_ostream<charT, traits>&
operator << (std::basic_ostream<charT, traits>& os,
const basic_regex<charT, traits2>& e)

8
include/boost/regex/v5/basic_regex_creator.hpp
View File

@ -30,8 +30,10 @@
#include <boost/regex/v5/basic_regex.hpp>
#ifndef BOOST_REGEX_AS_MODULE
#include <vector>
#include <set>
#endif
namespace boost{
@ -220,8 +222,10 @@ public:
m_icase = static_cast<bool>(f & regbase::icase);
}
}
re_syntax_base* append_state(syntax_element_type t, std::size_t s = sizeof(re_syntax_base));
re_syntax_base* insert_state(std::ptrdiff_t pos, syntax_element_type t, std::size_t s = sizeof(re_syntax_base));
re_syntax_base* append_state(syntax_element_type t, std::size_t s);
re_syntax_base* append_state(syntax_element_type t) { return append_state(t, sizeof(re_syntax_base)); }
re_syntax_base* insert_state(std::ptrdiff_t pos, syntax_element_type t, std::size_t s);
re_syntax_base* insert_state(std::ptrdiff_t pos, syntax_element_type t) { return insert_state(pos, t, sizeof(re_syntax_base)); }
re_literal* append_literal(charT c);
re_syntax_base* append_set(const basic_char_set<charT, traits>& char_set);
re_syntax_base* append_set(const basic_char_set<charT, traits>& char_set, std::integral_constant<bool, false>*);

2
include/boost/regex/v5/basic_regex_parser.hpp
View File

@ -21,10 +21,12 @@
#include <boost/regex/v5/basic_regex_creator.hpp>
#ifndef BOOST_REGEX_AS_MODULE
#include <climits>
#include <cstdint>
#include <limits>
#include <type_traits>
#endif
namespace boost{
namespace BOOST_REGEX_DETAIL_NS{

16
include/boost/regex/v5/c_regex_traits.hpp
View File

@ -19,15 +19,17 @@
#ifndef BOOST_C_REGEX_TRAITS_HPP_INCLUDED
#define BOOST_C_REGEX_TRAITS_HPP_INCLUDED
#ifndef BOOST_REGEX_AS_MODULE
#include <cctype>
#include <cstdint>
#include <cwctype>
#endif
#include <boost/regex/config.hpp>
#include <boost/regex/v5/regex_workaround.hpp>
#include <boost/regex/v5/primary_transform.hpp>
#include <boost/regex/v5/regex_traits_defaults.hpp>
#include <cctype>
#include <cstdint>
#include <cwctype>
namespace boost{
namespace BOOST_REGEX_DETAIL_NS {
@ -54,10 +56,10 @@ namespace boost{
}
template <class charT>
BOOST_REGEX_MODULE_EXPORT template <class charT>
struct c_regex_traits;
template<>
BOOST_REGEX_MODULE_EXPORT template<>
struct c_regex_traits<char>
{
c_regex_traits(){}
@ -102,7 +104,7 @@ private:
};
#ifndef BOOST_NO_WREGEX
template<>
BOOST_REGEX_MODULE_EXPORT template<>
struct c_regex_traits<wchar_t>
{
c_regex_traits(){}

19
include/boost/regex/v5/cpp_regex_traits.hpp
View File

@ -20,22 +20,25 @@
#define BOOST_CPP_REGEX_TRAITS_HPP_INCLUDED
#include <boost/regex/config.hpp>
#ifndef BOOST_REGEX_AS_MODULE
#include <cstdint>
#include <locale>
#include <type_traits>
#include <climits>
#include <ios>
#include <istream>
#ifdef BOOST_HAS_THREADS
#include <mutex>
#endif
#endif
#include <boost/regex/pattern_except.hpp>
#include <boost/regex/v5/regex_traits_defaults.hpp>
#ifdef BOOST_HAS_THREADS
#include <mutex>
#endif
#include <boost/regex/v5/primary_transform.hpp>
#include <boost/regex/v5/object_cache.hpp>
#include <climits>
#include <ios>
#include <istream>
#ifdef BOOST_REGEX_MSVC
#pragma warning(push)
@ -47,7 +50,7 @@ namespace boost{
//
// forward declaration is needed by some compilers:
//
template <class charT>
BOOST_REGEX_MODULE_EXPORT template <class charT>
class cpp_regex_traits;
namespace BOOST_REGEX_DETAIL_NS{
@ -731,7 +734,7 @@ inline std::shared_ptr<const cpp_regex_traits_implementation<charT> > create_cpp
} // BOOST_REGEX_DETAIL_NS
template <class charT>
BOOST_REGEX_MODULE_EXPORT template <class charT>
class cpp_regex_traits
{
private:

2
include/boost/regex/v5/cregex.hpp
View File

@ -38,11 +38,13 @@
#endif
#endif
#ifndef BOOST_REGEX_AS_MODULE
#ifdef __cplusplus
#include <cstddef>
#else
#include <stddef.h>
#endif
#endif
/* include these defs only for POSIX compatablity */
#ifdef __cplusplus

2
include/boost/regex/v5/error_type.hpp
View File

@ -26,7 +26,7 @@ namespace boost{
#ifdef __cplusplus
namespace regex_constants{
enum error_type{
BOOST_REGEX_MODULE_EXPORT enum error_type{
error_ok = 0, /* not used */
error_no_match = 1, /* not used */

78
include/boost/regex/v5/icu.hpp
View File

@ -19,11 +19,13 @@
#ifndef BOOST_REGEX_ICU_V5_HPP
#define BOOST_REGEX_ICU_V5_HPP
#ifndef BOOST_REGEX_AS_MODULE
#include <unicode/utypes.h>
#include <unicode/uchar.h>
#include <unicode/coll.h>
#include <type_traits>
#include <functional>
#endif
#include <boost/regex.hpp>
#include <boost/regex/v5/unicode_iterator.hpp>
@ -835,7 +837,7 @@ bool do_regex_match(BidiIterator first, BidiIterator last,
}
} // namespace BOOST_REGEX_DETAIL_NS
template <class BidiIterator, class Allocator>
BOOST_REGEX_MODULE_EXPORT template <class BidiIterator, class Allocator>
inline bool u32regex_match(BidiIterator first, BidiIterator last,
match_results<BidiIterator, Allocator>& m,
const u32regex& e,
@ -843,7 +845,7 @@ inline bool u32regex_match(BidiIterator first, BidiIterator last,
{
return BOOST_REGEX_DETAIL_NS::do_regex_match(first, last, m, e, flags, static_cast<std::integral_constant<int, sizeof(*first)> const*>(0));
}
inline bool u32regex_match(const UChar* p,
BOOST_REGEX_MODULE_EXPORT inline bool u32regex_match(const UChar* p,
match_results<const UChar*>& m,
const u32regex& e,
match_flag_type flags = match_default)
@ -851,7 +853,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<std::integral_constant<int, 2> const*>(0));
}
#if !BOOST_REGEX_UCHAR_IS_WCHAR_T && !defined(BOOST_NO_WREGEX)
inline bool u32regex_match(const wchar_t* p,
BOOST_REGEX_MODULE_EXPORT inline bool u32regex_match(const wchar_t* p,
match_results<const wchar_t*>& m,
const u32regex& e,
match_flag_type flags = match_default)
@ -859,21 +861,21 @@ inline bool u32regex_match(const wchar_t* p,
return BOOST_REGEX_DETAIL_NS::do_regex_match(p, p+std::wcslen(p), m, e, flags, static_cast<std::integral_constant<int, sizeof(wchar_t)> const*>(0));
}
#endif
inline bool u32regex_match(const char* p,
BOOST_REGEX_MODULE_EXPORT inline bool u32regex_match(const char* p,
match_results<const char*>& m,
const u32regex& e,
match_flag_type flags = match_default)
{
return BOOST_REGEX_DETAIL_NS::do_regex_match(p, p+std::strlen(p), m, e, flags, static_cast<std::integral_constant<int, 1> const*>(0));
}
inline bool u32regex_match(const unsigned char* p,
BOOST_REGEX_MODULE_EXPORT inline bool u32regex_match(const unsigned char* p,
match_results<const unsigned char*>& m,
const u32regex& e,
match_flag_type flags = match_default)
{
return BOOST_REGEX_DETAIL_NS::do_regex_match(p, p+std::strlen((const char*)p), m, e, flags, static_cast<std::integral_constant<int, 1> const*>(0));
}
inline bool u32regex_match(const std::string& s,
BOOST_REGEX_MODULE_EXPORT inline bool u32regex_match(const std::string& s,
match_results<std::string::const_iterator>& m,
const u32regex& e,
match_flag_type flags = match_default)
@ -881,7 +883,7 @@ inline bool u32regex_match(const std::string& s,
return BOOST_REGEX_DETAIL_NS::do_regex_match(s.begin(), s.end(), m, e, flags, static_cast<std::integral_constant<int, 1> const*>(0));
}
#ifndef BOOST_NO_STD_WSTRING
inline bool u32regex_match(const std::wstring& s,
BOOST_REGEX_MODULE_EXPORT inline bool u32regex_match(const std::wstring& s,
match_results<std::wstring::const_iterator>& m,
const u32regex& e,
match_flag_type flags = match_default)
@ -889,7 +891,7 @@ inline bool u32regex_match(const std::wstring& s,
return BOOST_REGEX_DETAIL_NS::do_regex_match(s.begin(), s.end(), m, e, flags, static_cast<std::integral_constant<int, sizeof(wchar_t)> const*>(0));
}
#endif
inline bool u32regex_match(const U_NAMESPACE_QUALIFIER UnicodeString& s,
BOOST_REGEX_MODULE_EXPORT inline bool u32regex_match(const U_NAMESPACE_QUALIFIER UnicodeString& s,
match_results<const UChar*>& m,
const u32regex& e,
match_flag_type flags = match_default)
@ -899,7 +901,7 @@ inline bool u32regex_match(const U_NAMESPACE_QUALIFIER UnicodeString& s,
//
// regex_match overloads that do not return what matched:
//
template <class BidiIterator>
BOOST_REGEX_MODULE_EXPORT template <class BidiIterator>
inline bool u32regex_match(BidiIterator first, BidiIterator last,
const u32regex& e,
match_flag_type flags = match_default)
@ -907,7 +909,7 @@ inline bool u32regex_match(BidiIterator first, BidiIterator last,
match_results<BidiIterator> m;
return BOOST_REGEX_DETAIL_NS::do_regex_match(first, last, m, e, flags, static_cast<std::integral_constant<int, sizeof(*first)> const*>(0));
}
inline bool u32regex_match(const UChar* p,
BOOST_REGEX_MODULE_EXPORT inline bool u32regex_match(const UChar* p,
const u32regex& e,
match_flag_type flags = match_default)
{
@ -915,7 +917,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<std::integral_constant<int, 2> const*>(0));
}
#if !BOOST_REGEX_UCHAR_IS_WCHAR_T && !defined(BOOST_NO_WREGEX)
inline bool u32regex_match(const wchar_t* p,
BOOST_REGEX_MODULE_EXPORT inline bool u32regex_match(const wchar_t* p,
const u32regex& e,
match_flag_type flags = match_default)
{
@ -923,21 +925,21 @@ inline bool u32regex_match(const wchar_t* p,
return BOOST_REGEX_DETAIL_NS::do_regex_match(p, p+std::wcslen(p), m, e, flags, static_cast<std::integral_constant<int, sizeof(wchar_t)> const*>(0));
}
#endif
inline bool u32regex_match(const char* p,
BOOST_REGEX_MODULE_EXPORT inline bool u32regex_match(const char* p,
const u32regex& e,
match_flag_type flags = match_default)
{
match_results<const char*> m;
return BOOST_REGEX_DETAIL_NS::do_regex_match(p, p+std::strlen(p), m, e, flags, static_cast<std::integral_constant<int, 1> const*>(0));
}
inline bool u32regex_match(const unsigned char* p,
BOOST_REGEX_MODULE_EXPORT inline bool u32regex_match(const unsigned char* p,
const u32regex& e,
match_flag_type flags = match_default)
{
match_results<const unsigned char*> m;
return BOOST_REGEX_DETAIL_NS::do_regex_match(p, p+std::strlen((const char*)p), m, e, flags, static_cast<std::integral_constant<int, 1> const*>(0));
}
inline bool u32regex_match(const std::string& s,
BOOST_REGEX_MODULE_EXPORT inline bool u32regex_match(const std::string& s,
const u32regex& e,
match_flag_type flags = match_default)
{
@ -945,7 +947,7 @@ inline bool u32regex_match(const std::string& s,
return BOOST_REGEX_DETAIL_NS::do_regex_match(s.begin(), s.end(), m, e, flags, static_cast<std::integral_constant<int, 1> const*>(0));
}
#ifndef BOOST_NO_STD_WSTRING
inline bool u32regex_match(const std::wstring& s,
BOOST_REGEX_MODULE_EXPORT inline bool u32regex_match(const std::wstring& s,
const u32regex& e,
match_flag_type flags = match_default)
{
@ -953,7 +955,7 @@ inline bool u32regex_match(const std::wstring& s,
return BOOST_REGEX_DETAIL_NS::do_regex_match(s.begin(), s.end(), m, e, flags, static_cast<std::integral_constant<int, sizeof(wchar_t)> const*>(0));
}
#endif
inline bool u32regex_match(const U_NAMESPACE_QUALIFIER UnicodeString& s,
BOOST_REGEX_MODULE_EXPORT inline bool u32regex_match(const U_NAMESPACE_QUALIFIER UnicodeString& s,
const u32regex& e,
match_flag_type flags = match_default)
{
@ -1011,7 +1013,7 @@ bool do_regex_search(BidiIterator first, BidiIterator last,
}
}
template <class BidiIterator, class Allocator>
BOOST_REGEX_MODULE_EXPORT template <class BidiIterator, class Allocator>
inline bool u32regex_search(BidiIterator first, BidiIterator last,
match_results<BidiIterator, Allocator>& m,
const u32regex& e,
@ -1019,7 +1021,7 @@ inline bool u32regex_search(BidiIterator first, BidiIterator last,
{
return BOOST_REGEX_DETAIL_NS::do_regex_search(first, last, m, e, flags, first, static_cast<std::integral_constant<int, sizeof(*first)> const*>(0));
}
template <class BidiIterator, class Allocator>
BOOST_REGEX_MODULE_EXPORT template <class BidiIterator, class Allocator>
inline bool u32regex_search(BidiIterator first, BidiIterator last,
match_results<BidiIterator, Allocator>& m,
const u32regex& e,
@ -1028,7 +1030,7 @@ inline bool u32regex_search(BidiIterator first, BidiIterator last,
{
return BOOST_REGEX_DETAIL_NS::do_regex_search(first, last, m, e, flags, base, static_cast<std::integral_constant<int, sizeof(*first)> const*>(0));
}
inline bool u32regex_search(const UChar* p,
BOOST_REGEX_MODULE_EXPORT inline bool u32regex_search(const UChar* p,
match_results<const UChar*>& m,
const u32regex& e,
match_flag_type flags = match_default)
@ -1036,7 +1038,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<std::integral_constant<int, 2> const*>(0));
}
#if !BOOST_REGEX_UCHAR_IS_WCHAR_T && !defined(BOOST_NO_WREGEX)
inline bool u32regex_search(const wchar_t* p,
BOOST_REGEX_MODULE_EXPORT inline bool u32regex_search(const wchar_t* p,
match_results<const wchar_t*>& m,
const u32regex& e,
match_flag_type flags = match_default)
@ -1044,21 +1046,21 @@ inline bool u32regex_search(const wchar_t* p,
return BOOST_REGEX_DETAIL_NS::do_regex_search(p, p+std::wcslen(p), m, e, flags, p, static_cast<std::integral_constant<int, sizeof(wchar_t)> const*>(0));
}
#endif
inline bool u32regex_search(const char* p,
BOOST_REGEX_MODULE_EXPORT inline bool u32regex_search(const char* p,
match_results<const char*>& m,
const u32regex& e,
match_flag_type flags = match_default)
{
return BOOST_REGEX_DETAIL_NS::do_regex_search(p, p+std::strlen(p), m, e, flags, p, static_cast<std::integral_constant<int, 1> const*>(0));
}
inline bool u32regex_search(const unsigned char* p,
BOOST_REGEX_MODULE_EXPORT inline bool u32regex_search(const unsigned char* p,
match_results<const unsigned char*>& m,
const u32regex& e,
match_flag_type flags = match_default)
{
return BOOST_REGEX_DETAIL_NS::do_regex_search(p, p+std::strlen((const char*)p), m, e, flags, p, static_cast<std::integral_constant<int, 1> const*>(0));
}
inline bool u32regex_search(const std::string& s,
BOOST_REGEX_MODULE_EXPORT inline bool u32regex_search(const std::string& s,
match_results<std::string::const_iterator>& m,
const u32regex& e,
match_flag_type flags = match_default)
@ -1066,7 +1068,7 @@ inline bool u32regex_search(const std::string& s,
return BOOST_REGEX_DETAIL_NS::do_regex_search(s.begin(), s.end(), m, e, flags, s.begin(), static_cast<std::integral_constant<int, 1> const*>(0));
}
#ifndef BOOST_NO_STD_WSTRING
inline bool u32regex_search(const std::wstring& s,
BOOST_REGEX_MODULE_EXPORT inline bool u32regex_search(const std::wstring& s,
match_results<std::wstring::const_iterator>& m,
const u32regex& e,
match_flag_type flags = match_default)
@ -1074,14 +1076,14 @@ inline bool u32regex_search(const std::wstring& s,
return BOOST_REGEX_DETAIL_NS::do_regex_search(s.begin(), s.end(), m, e, flags, s.begin(), static_cast<std::integral_constant<int, sizeof(wchar_t)> const*>(0));
}
#endif
inline bool u32regex_search(const U_NAMESPACE_QUALIFIER UnicodeString& s,
BOOST_REGEX_MODULE_EXPORT inline bool u32regex_search(const U_NAMESPACE_QUALIFIER UnicodeString& s,
match_results<const UChar*>& m,
const u32regex& e,
match_flag_type flags = match_default)
{
return BOOST_REGEX_DETAIL_NS::do_regex_search(s.getBuffer(), s.getBuffer() + s.length(), m, e, flags, s.getBuffer(), static_cast<std::integral_constant<int, 2> const*>(0));
}
template <class BidiIterator>
BOOST_REGEX_MODULE_EXPORT template <class BidiIterator>
inline bool u32regex_search(BidiIterator first, BidiIterator last,
const u32regex& e,
match_flag_type flags = match_default)
@ -1089,7 +1091,7 @@ inline bool u32regex_search(BidiIterator first, BidiIterator last,
match_results<BidiIterator> m;
return BOOST_REGEX_DETAIL_NS::do_regex_search(first, last, m, e, flags, first, static_cast<std::integral_constant<int, sizeof(*first)> const*>(0));
}
inline bool u32regex_search(const UChar* p,
BOOST_REGEX_MODULE_EXPORT inline bool u32regex_search(const UChar* p,
const u32regex& e,
match_flag_type flags = match_default)
{
@ -1097,7 +1099,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<std::integral_constant<int, 2> const*>(0));
}
#if !BOOST_REGEX_UCHAR_IS_WCHAR_T && !defined(BOOST_NO_WREGEX)
inline bool u32regex_search(const wchar_t* p,
BOOST_REGEX_MODULE_EXPORT inline bool u32regex_search(const wchar_t* p,
const u32regex& e,
match_flag_type flags = match_default)
{
@ -1105,21 +1107,21 @@ inline bool u32regex_search(const wchar_t* p,
return BOOST_REGEX_DETAIL_NS::do_regex_search(p, p+std::wcslen(p), m, e, flags, p, static_cast<std::integral_constant<int, sizeof(wchar_t)> const*>(0));
}
#endif
inline bool u32regex_search(const char* p,
BOOST_REGEX_MODULE_EXPORT inline bool u32regex_search(const char* p,
const u32regex& e,
match_flag_type flags = match_default)
{
match_results<const char*> m;
return BOOST_REGEX_DETAIL_NS::do_regex_search(p, p+std::strlen(p), m, e, flags, p, static_cast<std::integral_constant<int, 1> const*>(0));
}
inline bool u32regex_search(const unsigned char* p,
BOOST_REGEX_MODULE_EXPORT inline bool u32regex_search(const unsigned char* p,
const u32regex& e,
match_flag_type flags = match_default)
{
match_results<const unsigned char*> m;
return BOOST_REGEX_DETAIL_NS::do_regex_search(p, p+std::strlen((const char*)p), m, e, flags, p, static_cast<std::integral_constant<int, 1> const*>(0));
}
inline bool u32regex_search(const std::string& s,
BOOST_REGEX_MODULE_EXPORT inline bool u32regex_search(const std::string& s,
const u32regex& e,
match_flag_type flags = match_default)
{
@ -1127,7 +1129,7 @@ inline bool u32regex_search(const std::string& s,
return BOOST_REGEX_DETAIL_NS::do_regex_search(s.begin(), s.end(), m, e, flags, s.begin(), static_cast<std::integral_constant<int, 1> const*>(0));
}
#ifndef BOOST_NO_STD_WSTRING
inline bool u32regex_search(const std::wstring& s,
BOOST_REGEX_MODULE_EXPORT inline bool u32regex_search(const std::wstring& s,
const u32regex& e,
match_flag_type flags = match_default)
{
@ -1135,7 +1137,7 @@ inline bool u32regex_search(const std::wstring& s,
return BOOST_REGEX_DETAIL_NS::do_regex_search(s.begin(), s.end(), m, e, flags, s.begin(), static_cast<std::integral_constant<int, sizeof(wchar_t)> const*>(0));
}
#endif
inline bool u32regex_search(const U_NAMESPACE_QUALIFIER UnicodeString& s,
BOOST_REGEX_MODULE_EXPORT inline bool u32regex_search(const U_NAMESPACE_QUALIFIER UnicodeString& s,
const u32regex& e,
match_flag_type flags = match_default)
{
@ -1258,7 +1260,7 @@ inline BaseIterator extract_output_base(const utf16_output_iterator<BaseIterator
}
} // BOOST_REGEX_DETAIL_NS
template <class OutputIterator, class BidirectionalIterator, class charT>
BOOST_REGEX_MODULE_EXPORT template <class OutputIterator, class BidirectionalIterator, class charT>
inline OutputIterator u32regex_replace(OutputIterator out,
BidirectionalIterator first,
BidirectionalIterator last,
@ -1277,7 +1279,7 @@ inline OutputIterator u32regex_replace(OutputIterator out,
);
}
template <class OutputIterator, class Iterator, class charT>
BOOST_REGEX_MODULE_EXPORT template <class OutputIterator, class Iterator, class charT>
inline OutputIterator u32regex_replace(OutputIterator out,
Iterator first,
Iterator last,
@ -1296,7 +1298,7 @@ inline OutputIterator u32regex_replace(OutputIterator out,
);
}
template <class OutputIterator, class Iterator>
BOOST_REGEX_MODULE_EXPORT template <class OutputIterator, class Iterator>
inline OutputIterator u32regex_replace(OutputIterator out,
Iterator first,
Iterator last,
@ -1315,7 +1317,7 @@ inline OutputIterator u32regex_replace(OutputIterator out,
);
}
template <class charT>
BOOST_REGEX_MODULE_EXPORT template <class charT>
std::basic_string<charT> u32regex_replace(const std::basic_string<charT>& s,
const u32regex& e,
const charT* fmt,
@ -1327,7 +1329,7 @@ std::basic_string<charT> u32regex_replace(const std::basic_string<charT>& s,
return result;
}
template <class charT>
BOOST_REGEX_MODULE_EXPORT template <class charT>
std::basic_string<charT> u32regex_replace(const std::basic_string<charT>& s,
const u32regex& e,
const std::basic_string<charT>& fmt,

2
include/boost/regex/v5/iterator_category.hpp
View File

@ -21,8 +21,10 @@
#ifndef BOOST_REGEX_ITERATOR_CATEGORY_HPP
#define BOOST_REGEX_ITERATOR_CATEGORY_HPP
#ifndef BOOST_REGEX_AS_MODULE
#include <iterator>
#include <type_traits>
#endif
namespace boost{
namespace detail{

2
include/boost/regex/v5/iterator_traits.hpp
View File

@ -19,7 +19,9 @@
#ifndef BOOST_REGEX_V5_ITERATOR_TRAITS_HPP
#define BOOST_REGEX_V5_ITERATOR_TRAITS_HPP
#ifndef BOOST_REGEX_AS_MODULE
#include <iterator>
#endif
namespace boost{
namespace BOOST_REGEX_DETAIL_NS{

74
include/boost/regex/v5/match_flags.hpp
View File

@ -19,9 +19,11 @@
#ifndef BOOST_REGEX_V5_MATCH_FLAGS
#define BOOST_REGEX_V5_MATCH_FLAGS
#ifndef BOOST_REGEX_AS_MODULE
#ifdef __cplusplus
# include <cstdint>
#endif
#endif
#ifdef __cplusplus
namespace boost{
@ -35,7 +37,7 @@ namespace boost{
#endif
#endif
typedef enum _match_flags
BOOST_REGEX_MODULE_EXPORT typedef enum _match_flags
{
match_default = 0,
match_not_bol = 1, /* first is not start of line */
@ -89,22 +91,22 @@ typedef enum _match_flags
} match_flags;
typedef match_flags match_flag_type;
BOOST_REGEX_MODULE_EXPORT typedef match_flags match_flag_type;
#ifdef __cplusplus
inline match_flags operator&(match_flags m1, match_flags m2)
BOOST_REGEX_MODULE_EXPORT inline match_flags operator&(match_flags m1, match_flags m2)
{ return static_cast<match_flags>(static_cast<std::int32_t>(m1) & static_cast<std::int32_t>(m2)); }
inline match_flags operator|(match_flags m1, match_flags m2)
BOOST_REGEX_MODULE_EXPORT inline match_flags operator|(match_flags m1, match_flags m2)
{ return static_cast<match_flags>(static_cast<std::int32_t>(m1) | static_cast<std::int32_t>(m2)); }
inline match_flags operator^(match_flags m1, match_flags m2)
BOOST_REGEX_MODULE_EXPORT inline match_flags operator^(match_flags m1, match_flags m2)
{ return static_cast<match_flags>(static_cast<std::int32_t>(m1) ^ static_cast<std::int32_t>(m2)); }
inline match_flags operator~(match_flags m1)
BOOST_REGEX_MODULE_EXPORT inline match_flags operator~(match_flags m1)
{ return static_cast<match_flags>(~static_cast<std::int32_t>(m1)); }
inline match_flags& operator&=(match_flags& m1, match_flags m2)
BOOST_REGEX_MODULE_EXPORT inline match_flags& operator&=(match_flags& m1, match_flags m2)
{ m1 = m1&m2; return m1; }
inline match_flags& operator|=(match_flags& m1, match_flags m2)
BOOST_REGEX_MODULE_EXPORT inline match_flags& operator|=(match_flags& m1, match_flags m2)
{ m1 = m1|m2; return m1; }
inline match_flags& operator^=(match_flags& m1, match_flags m2)
BOOST_REGEX_MODULE_EXPORT inline match_flags& operator^=(match_flags& m1, match_flags m2)
{ m1 = m1^m2; return m1; }
#endif
@ -113,36 +115,36 @@ inline match_flags& operator^=(match_flags& m1, match_flags m2)
/*
* import names into boost for backwards compatibility:
*/
using regex_constants::match_flag_type;
using regex_constants::match_default;
using regex_constants::match_not_bol;
using regex_constants::match_not_eol;
using regex_constants::match_not_bob;
using regex_constants::match_not_eob;
using regex_constants::match_not_bow;
using regex_constants::match_not_eow;
using regex_constants::match_not_dot_newline;
using regex_constants::match_not_dot_null;
using regex_constants::match_prev_avail;
BOOST_REGEX_MODULE_EXPORT using regex_constants::match_flag_type;
BOOST_REGEX_MODULE_EXPORT using regex_constants::match_default;
BOOST_REGEX_MODULE_EXPORT using regex_constants::match_not_bol;
BOOST_REGEX_MODULE_EXPORT using regex_constants::match_not_eol;
BOOST_REGEX_MODULE_EXPORT using regex_constants::match_not_bob;
BOOST_REGEX_MODULE_EXPORT using regex_constants::match_not_eob;
BOOST_REGEX_MODULE_EXPORT using regex_constants::match_not_bow;
BOOST_REGEX_MODULE_EXPORT using regex_constants::match_not_eow;
BOOST_REGEX_MODULE_EXPORT using regex_constants::match_not_dot_newline;
BOOST_REGEX_MODULE_EXPORT using regex_constants::match_not_dot_null;
BOOST_REGEX_MODULE_EXPORT using regex_constants::match_prev_avail;
/* using regex_constants::match_init; */
using regex_constants::match_any;
using regex_constants::match_not_null;
using regex_constants::match_continuous;
using regex_constants::match_partial;
BOOST_REGEX_MODULE_EXPORT using regex_constants::match_any;
BOOST_REGEX_MODULE_EXPORT using regex_constants::match_not_null;
BOOST_REGEX_MODULE_EXPORT using regex_constants::match_continuous;
BOOST_REGEX_MODULE_EXPORT using regex_constants::match_partial;
/*using regex_constants::match_stop; */
using regex_constants::match_all;
using regex_constants::match_perl;
using regex_constants::match_posix;
using regex_constants::match_nosubs;
using regex_constants::match_extra;
using regex_constants::match_single_line;
BOOST_REGEX_MODULE_EXPORT using regex_constants::match_all;
BOOST_REGEX_MODULE_EXPORT using regex_constants::match_perl;
BOOST_REGEX_MODULE_EXPORT using regex_constants::match_posix;
BOOST_REGEX_MODULE_EXPORT using regex_constants::match_nosubs;
BOOST_REGEX_MODULE_EXPORT using regex_constants::match_extra;
BOOST_REGEX_MODULE_EXPORT using regex_constants::match_single_line;
/*using regex_constants::match_max; */
using regex_constants::format_all;
using regex_constants::format_sed;
using regex_constants::format_perl;
using regex_constants::format_default;
using regex_constants::format_no_copy;
using regex_constants::format_first_only;
BOOST_REGEX_MODULE_EXPORT using regex_constants::format_all;
BOOST_REGEX_MODULE_EXPORT using regex_constants::format_sed;
BOOST_REGEX_MODULE_EXPORT using regex_constants::format_perl;
BOOST_REGEX_MODULE_EXPORT using regex_constants::format_default;
BOOST_REGEX_MODULE_EXPORT using regex_constants::format_no_copy;
BOOST_REGEX_MODULE_EXPORT using regex_constants::format_first_only;
/*using regex_constants::format_is_if;*/
#ifdef BOOST_REGEX_MSVC

8
include/boost/regex/v5/match_results.hpp
View File

@ -24,8 +24,10 @@
#include <boost/regex/v5/basic_regex.hpp>
#include <boost/regex/v5/regex_format.hpp>
#ifndef BOOST_REGEX_AS_MODULE
#include <string>
#include <vector>
#endif
namespace boost{
#ifdef BOOST_REGEX_MSVC
@ -45,7 +47,7 @@ class named_subexpressions;
}
template <class BidiIterator, class Allocator>
BOOST_REGEX_MODULE_EXPORT template <class BidiIterator, class Allocator>
class match_results
{
private:
@ -674,13 +676,13 @@ void match_results<BidiIterator, Allocator>::maybe_assign(const match_results<B
*this = m;
}
template <class BidiIterator, class Allocator>
BOOST_REGEX_MODULE_EXPORT template <class BidiIterator, class Allocator>
void swap(match_results<BidiIterator, Allocator>& a, match_results<BidiIterator, Allocator>& b)
{
a.swap(b);
}
template <class charT, class traits, class BidiIterator, class Allocator>
BOOST_REGEX_MODULE_EXPORT template <class charT, class traits, class BidiIterator, class Allocator>
std::basic_ostream<charT, traits>&
operator << (std::basic_ostream<charT, traits>& os,
const match_results<BidiIterator, Allocator>& s)

3
include/boost/regex/v5/mem_block_cache.hpp
View File

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

2
include/boost/regex/v5/object_cache.hpp
View File

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

8
include/boost/regex/v5/pattern_except.hpp
View File

@ -23,8 +23,10 @@
#include <boost/regex/config.hpp>
#endif
#ifndef BOOST_REGEX_AS_MODULE
#include <cstddef>
#include <stdexcept>
#endif
#include <boost/regex/v5/error_type.hpp>
#include <boost/regex/v5/regex_traits_defaults.hpp>
@ -37,7 +39,7 @@ namespace boost{
#pragma warning(disable : 26812 4459)
#endif
#endif
class regex_error : public std::runtime_error
BOOST_REGEX_MODULE_EXPORT class regex_error : public std::runtime_error
{
public:
explicit regex_error(const std::string& s, regex_constants::error_type err = regex_constants::error_unknown, std::ptrdiff_t pos = 0)
@ -72,8 +74,8 @@ private:
std::ptrdiff_t m_position;
};
typedef regex_error bad_pattern;
typedef regex_error bad_expression;
BOOST_REGEX_MODULE_EXPORT typedef regex_error bad_pattern;
BOOST_REGEX_MODULE_EXPORT typedef regex_error bad_expression;
namespace BOOST_REGEX_DETAIL_NS{

29
include/boost/regex/v5/perl_matcher.hpp
View File

@ -19,11 +19,13 @@
#include <boost/regex/v5/states.hpp>
#include <boost/regex/v5/regex_traits.hpp>
#ifndef BOOST_REGEX_AS_MODULE
#ifndef BOOST_REGEX_STANDALONE
#include <boost/throw_exception.hpp>
#endif
#include <climits>
#endif
#ifdef BOOST_REGEX_MSVC
# pragma warning(push)
@ -578,6 +580,33 @@ private:
#endif
};
template <class Matcher>
inline bool factory_match(Matcher& m)
{
return m.match();
}
template <class Matcher>
inline bool factory_find(Matcher& m)
{
return m.find();
}
#ifdef BOOST_REGEX_AS_MODULE
bool factory_match(perl_matcher<const char*, match_results<const char*>::allocator_type, regex::traits_type>& m);
bool factory_match(perl_matcher<const wchar_t*, match_results<const wchar_t*>::allocator_type, wregex::traits_type>& m);
bool factory_match(perl_matcher<std::string::const_iterator, match_results<std::string::const_iterator>::allocator_type, regex::traits_type>& m);
bool factory_match(perl_matcher<std::wstring::const_iterator, match_results<std::wstring::const_iterator>::allocator_type, wregex::traits_type>& m);
bool factory_match(perl_matcher<std::string::iterator, match_results<std::string::iterator>::allocator_type, regex::traits_type>& m);
bool factory_match(perl_matcher<std::wstring::iterator, match_results<std::wstring::iterator>::allocator_type, wregex::traits_type>& m);
bool factory_find(perl_matcher<const char*, match_results<const char*>::allocator_type, regex::traits_type>& m);
bool factory_find(perl_matcher<const wchar_t*, match_results<const wchar_t*>::allocator_type, wregex::traits_type>& m);
bool factory_find(perl_matcher<std::string::const_iterator, match_results<std::string::const_iterator>::allocator_type, regex::traits_type>& m);
bool factory_find(perl_matcher<std::wstring::const_iterator, match_results<std::wstring::const_iterator>::allocator_type, wregex::traits_type>& m);
bool factory_find(perl_matcher<std::string::iterator, match_results<std::string::iterator>::allocator_type, regex::traits_type>& m);
bool factory_find(perl_matcher<std::wstring::iterator, match_results<std::wstring::iterator>::allocator_type, wregex::traits_type>& m);
#endif
} // namespace BOOST_REGEX_DETAIL_NS
#ifdef BOOST_REGEX_MSVC

4
include/boost/regex/v5/regbase.hpp
View File

@ -112,7 +112,7 @@ public:
//
namespace regex_constants{
enum flag_type_
BOOST_REGEX_MODULE_EXPORT enum flag_type_
{
no_except = ::boost::regbase::no_except,
@ -148,7 +148,7 @@ namespace regex_constants{
JavaScript = normal,
JScript = normal
};
typedef ::boost::regbase::flag_type syntax_option_type;
BOOST_REGEX_MODULE_EXPORT typedef ::boost::regbase::flag_type syntax_option_type;
} // namespace regex_constants

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

@ -46,17 +46,17 @@
namespace boost{
#ifdef BOOST_REGEX_NO_FWD
typedef basic_regex<char, regex_traits<char> > regex;
BOOST_REGEX_MODULE_EXPORT typedef basic_regex<char, regex_traits<char> > regex;
#ifndef BOOST_NO_WREGEX
typedef basic_regex<wchar_t, regex_traits<wchar_t> > wregex;
BOOST_REGEX_MODULE_EXPORT typedef basic_regex<wchar_t, regex_traits<wchar_t> > wregex;
#endif
#endif
typedef match_results<const char*> cmatch;
typedef match_results<std::string::const_iterator> smatch;
BOOST_REGEX_MODULE_EXPORT typedef match_results<const char*> cmatch;
BOOST_REGEX_MODULE_EXPORT typedef match_results<std::string::const_iterator> smatch;
#ifndef BOOST_NO_WREGEX
typedef match_results<const wchar_t*> wcmatch;
typedef match_results<std::wstring::const_iterator> wsmatch;
BOOST_REGEX_MODULE_EXPORT typedef match_results<const wchar_t*> wcmatch;
BOOST_REGEX_MODULE_EXPORT typedef match_results<std::wstring::const_iterator> wsmatch;
#endif
} // namespace boost

9
include/boost/regex/v5/regex_format.hpp
View File

@ -24,16 +24,17 @@
#include <boost/regex/v5/match_flags.hpp>
#include <boost/regex/v5/sub_match.hpp>
#include <boost/regex/v5/regex_traits_defaults.hpp>
#ifndef BOOST_REGEX_AS_MODULE
#include <type_traits>
#include <functional>
#endif
namespace boost{
//
// Forward declaration:
//
template <class BidiIterator, class Allocator = typename std::vector<sub_match<BidiIterator> >::allocator_type >
BOOST_REGEX_MODULE_EXPORT template <class BidiIterator, class Allocator = typename std::vector<sub_match<BidiIterator> >::allocator_type >
class match_results;
namespace BOOST_REGEX_DETAIL_NS{
@ -1099,7 +1100,7 @@ struct compute_functor_type
} // namespace BOOST_REGEX_DETAIL_NS
template <class OutputIterator, class Iterator, class Allocator, class Functor>
BOOST_REGEX_MODULE_EXPORT template <class OutputIterator, class Iterator, class Allocator, class Functor>
inline OutputIterator regex_format(OutputIterator out,
const match_results<Iterator, Allocator>& m,
Functor fmt,
@ -1109,7 +1110,7 @@ inline OutputIterator regex_format(OutputIterator out,
return m.format(out, fmt, flags);
}
template <class Iterator, class Allocator, class Functor>
BOOST_REGEX_MODULE_EXPORT template <class Iterator, class Allocator, class Functor>
inline std::basic_string<typename match_results<Iterator, Allocator>::char_type> regex_format(const match_results<Iterator, Allocator>& m,
Functor fmt,
match_flag_type flags = format_all)

18
include/boost/regex/v5/regex_fwd.hpp
View File

@ -36,30 +36,30 @@
namespace boost{
template <class charT>
BOOST_REGEX_MODULE_EXPORT template <class charT>
class cpp_regex_traits;
template <class charT>
BOOST_REGEX_MODULE_EXPORT template <class charT>
struct c_regex_traits;
template <class charT>
BOOST_REGEX_MODULE_EXPORT template <class charT>
class w32_regex_traits;
#ifdef BOOST_REGEX_USE_WIN32_LOCALE
template <class charT, class implementationT = w32_regex_traits<charT> >
BOOST_REGEX_MODULE_EXPORT template <class charT, class implementationT = w32_regex_traits<charT> >
struct regex_traits;
#elif defined(BOOST_REGEX_USE_CPP_LOCALE)
template <class charT, class implementationT = cpp_regex_traits<charT> >
BOOST_REGEX_MODULE_EXPORT template <class charT, class implementationT = cpp_regex_traits<charT> >
struct regex_traits;
#else
template <class charT, class implementationT = c_regex_traits<charT> >
BOOST_REGEX_MODULE_EXPORT template <class charT, class implementationT = c_regex_traits<charT> >
struct regex_traits;
#endif
template <class charT, class traits = regex_traits<charT> >
BOOST_REGEX_MODULE_EXPORT template <class charT, class traits = regex_traits<charT> >
class basic_regex;
typedef basic_regex<char, regex_traits<char> > regex;
BOOST_REGEX_MODULE_EXPORT typedef basic_regex<char, regex_traits<char> > regex;
#ifndef BOOST_NO_WREGEX
typedef basic_regex<wchar_t, regex_traits<wchar_t> > wregex;
BOOST_REGEX_MODULE_EXPORT typedef basic_regex<wchar_t, regex_traits<wchar_t> > wregex;
#endif
} // namespace boost

10
include/boost/regex/v5/regex_grep.hpp
View File

@ -30,7 +30,7 @@ namespace boost{
// regex_grep:
// find all non-overlapping matches within the sequence first last:
//
template <class Predicate, class BidiIterator, class charT, class traits>
BOOST_REGEX_MODULE_EXPORT template <class Predicate, class BidiIterator, class charT, class traits>
inline unsigned int regex_grep(Predicate foo,
BidiIterator first,
BidiIterator last,
@ -45,7 +45,7 @@ inline unsigned int regex_grep(Predicate foo,
match_results<BidiIterator> m;
BOOST_REGEX_DETAIL_NS::perl_matcher<BidiIterator, match_allocator_type, traits> matcher(first, last, m, e, flags, first);
unsigned int count = 0;
while(matcher.find())
while(BOOST_REGEX_DETAIL_NS::factory_find(matcher))
{
++count;
if(0 == foo(m))
@ -60,7 +60,7 @@ inline unsigned int regex_grep(Predicate foo,
// a non-NULL one at the same position:
match_results<BidiIterator, match_allocator_type> m2(m);
matcher.setf(match_not_null | match_continuous);
if(matcher.find())
if(BOOST_REGEX_DETAIL_NS::factory_find(matcher))
{
++count;
if(0 == foo(m))
@ -80,7 +80,7 @@ inline unsigned int regex_grep(Predicate foo,
//
// regex_grep convenience interfaces:
//
template <class Predicate, class charT, class traits>
BOOST_REGEX_MODULE_EXPORT template <class Predicate, class charT, class traits>
inline unsigned int regex_grep(Predicate foo, const charT* str,
const basic_regex<charT, traits>& e,
match_flag_type flags = match_default)
@ -88,7 +88,7 @@ inline unsigned int regex_grep(Predicate foo, const charT* str,
return regex_grep(foo, str, str + traits::length(str), e, flags);
}
template <class Predicate, class ST, class SA, class charT, class traits>
BOOST_REGEX_MODULE_EXPORT template <class Predicate, class ST, class SA, class charT, class traits>
inline unsigned int regex_grep(Predicate foo, const std::basic_string<charT, ST, SA>& s,
const basic_regex<charT, traits>& e,
match_flag_type flags = match_default)

17
include/boost/regex/v5/regex_iterator.hpp
View File

@ -21,8 +21,9 @@
#include <boost/regex/v5/basic_regex.hpp>
#include <boost/regex/v5/match_results.hpp>
#ifndef BOOST_REGEX_AS_MODULE
#include <memory>
#endif
namespace boost{
@ -75,7 +76,7 @@ private:
regex_iterator_implementation& operator=(const regex_iterator_implementation&);
};
template <class BidirectionalIterator,
BOOST_REGEX_MODULE_EXPORT template <class BidirectionalIterator,
class charT = typename std::iterator_traits<BidirectionalIterator>::value_type,
class traits = regex_traits<charT> >
class regex_iterator
@ -151,20 +152,20 @@ private:
}
};
typedef regex_iterator<const char*> cregex_iterator;
typedef regex_iterator<std::string::const_iterator> sregex_iterator;
BOOST_REGEX_MODULE_EXPORT typedef regex_iterator<const char*> cregex_iterator;
BOOST_REGEX_MODULE_EXPORT typedef regex_iterator<std::string::const_iterator> sregex_iterator;
#ifndef BOOST_NO_WREGEX
typedef regex_iterator<const wchar_t*> wcregex_iterator;
typedef regex_iterator<std::wstring::const_iterator> wsregex_iterator;
BOOST_REGEX_MODULE_EXPORT typedef regex_iterator<const wchar_t*> wcregex_iterator;
BOOST_REGEX_MODULE_EXPORT typedef regex_iterator<std::wstring::const_iterator> wsregex_iterator;
#endif
// make_regex_iterator:
template <class charT, class traits>
BOOST_REGEX_MODULE_EXPORT template <class charT, class traits>
inline regex_iterator<const charT*, charT, traits> make_regex_iterator(const charT* p, const basic_regex<charT, traits>& e, regex_constants::match_flag_type m = regex_constants::match_default)
{
return regex_iterator<const charT*, charT, traits>(p, p+traits::length(p), e, m);
}
template <class charT, class traits, class ST, class SA>
BOOST_REGEX_MODULE_EXPORT template <class charT, class traits, class ST, class SA>
inline regex_iterator<typename std::basic_string<charT, ST, SA>::const_iterator, charT, traits> make_regex_iterator(const std::basic_string<charT, ST, SA>& p, const basic_regex<charT, traits>& e, regex_constants::match_flag_type m = regex_constants::match_default)
{
return regex_iterator<typename std::basic_string<charT, ST, SA>::const_iterator, charT, traits>(p.begin(), p.end(), e, m);

14
include/boost/regex/v5/regex_match.hpp
View File

@ -32,16 +32,16 @@ namespace boost{
// returns true if the specified regular expression matches
// the whole of the input. Fills in what matched in m.
//
template <class BidiIterator, class Allocator, class charT, class traits>
BOOST_REGEX_MODULE_EXPORT template <class BidiIterator, class Allocator, class charT, class traits>
bool regex_match(BidiIterator first, BidiIterator last,
match_results<BidiIterator, Allocator>& m,
const basic_regex<charT, traits>& e,
match_flag_type flags = match_default)
{
BOOST_REGEX_DETAIL_NS::perl_matcher<BidiIterator, Allocator, traits> matcher(first, last, m, e, flags, first);
return matcher.match();
return BOOST_REGEX_DETAIL_NS::factory_match(matcher);
}
template <class iterator, class charT, class traits>
BOOST_REGEX_MODULE_EXPORT template <class iterator, class charT, class traits>
bool regex_match(iterator first, iterator last,
const basic_regex<charT, traits>& e,
match_flag_type flags = match_default)
@ -52,7 +52,7 @@ bool regex_match(iterator first, iterator last,
//
// query_match convenience interfaces:
//
template <class charT, class Allocator, class traits>
BOOST_REGEX_MODULE_EXPORT template <class charT, class Allocator, class traits>
inline bool regex_match(const charT* str,
match_results<const charT*, Allocator>& m,
const basic_regex<charT, traits>& e,
@ -61,7 +61,7 @@ inline bool regex_match(const charT* str,
return regex_match(str, str + traits::length(str), m, e, flags);
}
template <class ST, class SA, class Allocator, class charT, class traits>
BOOST_REGEX_MODULE_EXPORT template <class ST, class SA, class Allocator, class charT, class traits>
inline bool regex_match(const std::basic_string<charT, ST, SA>& s,
match_results<typename std::basic_string<charT, ST, SA>::const_iterator, Allocator>& m,
const basic_regex<charT, traits>& e,
@ -69,7 +69,7 @@ inline bool regex_match(const std::basic_string<charT, ST, SA>& s,
{
return regex_match(s.begin(), s.end(), m, e, flags);
}
template <class charT, class traits>
BOOST_REGEX_MODULE_EXPORT template <class charT, class traits>
inline bool regex_match(const charT* str,
const basic_regex<charT, traits>& e,
match_flag_type flags = match_default)
@ -78,7 +78,7 @@ inline bool regex_match(const charT* str,
return regex_match(str, str + traits::length(str), m, e, flags | regex_constants::match_any);
}
template <class ST, class SA, class charT, class traits>
BOOST_REGEX_MODULE_EXPORT template <class ST, class SA, class charT, class traits>
inline bool regex_match(const std::basic_string<charT, ST, SA>& s,
const basic_regex<charT, traits>& e,
match_flag_type flags = match_default)

8
include/boost/regex/v5/regex_merge.hpp
View File

@ -24,7 +24,7 @@
namespace boost{
template <class OutputIterator, class Iterator, class traits, class charT>
BOOST_REGEX_MODULE_EXPORT template <class OutputIterator, class Iterator, class traits, class charT>
inline OutputIterator regex_merge(OutputIterator out,
Iterator first,
Iterator last,
@ -35,7 +35,7 @@ inline OutputIterator regex_merge(OutputIterator out,
return regex_replace(out, first, last, e, fmt, flags);
}
template <class OutputIterator, class Iterator, class traits, class charT>
BOOST_REGEX_MODULE_EXPORT template <class OutputIterator, class Iterator, class traits, class charT>
inline OutputIterator regex_merge(OutputIterator out,
Iterator first,
Iterator last,
@ -46,7 +46,7 @@ inline OutputIterator regex_merge(OutputIterator out,
return regex_merge(out, first, last, e, fmt.c_str(), flags);
}
template <class traits, class charT>
BOOST_REGEX_MODULE_EXPORT template <class traits, class charT>
inline std::basic_string<charT> regex_merge(const std::basic_string<charT>& s,
const basic_regex<charT, traits>& e,
const charT* fmt,
@ -55,7 +55,7 @@ inline std::basic_string<charT> regex_merge(const std::basic_string<charT>& s,
return regex_replace(s, e, fmt, flags);
}
template <class traits, class charT>
BOOST_REGEX_MODULE_EXPORT template <class traits, class charT>
inline std::basic_string<charT> regex_merge(const std::basic_string<charT>& s,
const basic_regex<charT, traits>& e,
const std::basic_string<charT>& fmt,

2
include/boost/regex/v5/regex_raw_buffer.hpp
View File

@ -25,9 +25,11 @@
#include <boost/regex/config.hpp>
#endif
#ifndef BOOST_REGEX_AS_MODULE
#include <algorithm>
#include <cstddef>
#include <cstring>
#endif
namespace boost{
namespace BOOST_REGEX_DETAIL_NS{

4
include/boost/regex/v5/regex_replace.hpp
View File

@ -28,7 +28,7 @@
namespace boost{
template <class OutputIterator, class BidirectionalIterator, class traits, class charT, class Formatter>
BOOST_REGEX_MODULE_EXPORT template <class OutputIterator, class BidirectionalIterator, class traits, class charT, class Formatter>
OutputIterator regex_replace(OutputIterator out,
BidirectionalIterator first,
BidirectionalIterator last,
@ -62,7 +62,7 @@ OutputIterator regex_replace(OutputIterator out,
return out;
}
template <class traits, class charT, class Formatter>
BOOST_REGEX_MODULE_EXPORT template <class traits, class charT, class Formatter>
std::basic_string<charT> regex_replace(const std::basic_string<charT>& s,
const basic_regex<charT, traits>& e,
Formatter fmt,

18
include/boost/regex/v5/regex_search.hpp
View File

@ -25,7 +25,7 @@
namespace boost{
template <class BidiIterator, class Allocator, class charT, class traits>
BOOST_REGEX_MODULE_EXPORT template <class BidiIterator, class Allocator, class charT, class traits>
bool regex_search(BidiIterator first, BidiIterator last,
match_results<BidiIterator, Allocator>& m,
const basic_regex<charT, traits>& e,
@ -34,7 +34,7 @@ bool regex_search(BidiIterator first, BidiIterator last,
return regex_search(first, last, m, e, flags, first);
}
template <class BidiIterator, class Allocator, class charT, class traits>
BOOST_REGEX_MODULE_EXPORT template <class BidiIterator, class Allocator, class charT, class traits>
bool regex_search(BidiIterator first, BidiIterator last,
match_results<BidiIterator, Allocator>& m,
const basic_regex<charT, traits>& e,
@ -45,13 +45,13 @@ bool regex_search(BidiIterator first, BidiIterator last,
return false;
BOOST_REGEX_DETAIL_NS::perl_matcher<BidiIterator, Allocator, traits> matcher(first, last, m, e, flags, base);
return matcher.find();
return BOOST_REGEX_DETAIL_NS::factory_find(matcher);
}
//
// regex_search convenience interfaces:
//
template <class charT, class Allocator, class traits>
BOOST_REGEX_MODULE_EXPORT template <class charT, class Allocator, class traits>
inline bool regex_search(const charT* str,
match_results<const charT*, Allocator>& m,
const basic_regex<charT, traits>& e,
@ -60,7 +60,7 @@ inline bool regex_search(const charT* str,
return regex_search(str, str + traits::length(str), m, e, flags);
}
template <class ST, class SA, class Allocator, class charT, class traits>
BOOST_REGEX_MODULE_EXPORT template <class ST, class SA, class Allocator, class charT, class traits>
inline bool regex_search(const std::basic_string<charT, ST, SA>& s,
match_results<typename std::basic_string<charT, ST, SA>::const_iterator, Allocator>& m,
const basic_regex<charT, traits>& e,
@ -69,7 +69,7 @@ inline bool regex_search(const std::basic_string<charT, ST, SA>& s,
return regex_search(s.begin(), s.end(), m, e, flags);
}
template <class BidiIterator, class charT, class traits>
BOOST_REGEX_MODULE_EXPORT template <class BidiIterator, class charT, class traits>
bool regex_search(BidiIterator first, BidiIterator last,
const basic_regex<charT, traits>& e,
match_flag_type flags = match_default)
@ -80,10 +80,10 @@ bool regex_search(BidiIterator first, BidiIterator last,
match_results<BidiIterator> m;
typedef typename match_results<BidiIterator>::allocator_type match_alloc_type;
BOOST_REGEX_DETAIL_NS::perl_matcher<BidiIterator, match_alloc_type, traits> matcher(first, last, m, e, flags | regex_constants::match_any, first);
return matcher.find();
return BOOST_REGEX_DETAIL_NS::factory_find(matcher);
}
template <class charT, class traits>
BOOST_REGEX_MODULE_EXPORT template <class charT, class traits>
inline bool regex_search(const charT* str,
const basic_regex<charT, traits>& e,
match_flag_type flags = match_default)
@ -91,7 +91,7 @@ inline bool regex_search(const charT* str,
return regex_search(str, str + traits::length(str), e, flags);
}
template <class ST, class SA, class charT, class traits>
BOOST_REGEX_MODULE_EXPORT template <class ST, class SA, class charT, class traits>
inline bool regex_search(const std::basic_string<charT, ST, SA>& s,
const basic_regex<charT, traits>& e,
match_flag_type flags = match_default)

6
include/boost/regex/v5/regex_split.hpp
View File

@ -93,7 +93,7 @@ bool split_pred<OutputIterator, charT, Traits1, Alloc1>::operator()
} // namespace BOOST_REGEX_DETAIL_NS
template <class OutputIterator, class charT, class Traits1, class Alloc1, class Traits2>
BOOST_REGEX_MODULE_EXPORT template <class OutputIterator, class charT, class Traits1, class Alloc1, class Traits2>
std::size_t regex_split(OutputIterator out,
std::basic_string<charT, Traits1, Alloc1>& s,
const basic_regex<charT, Traits2>& e,
@ -128,7 +128,7 @@ std::size_t regex_split(OutputIterator out,
return init_size - max_split;
}
template <class OutputIterator, class charT, class Traits1, class Alloc1, class Traits2>
BOOST_REGEX_MODULE_EXPORT template <class OutputIterator, class charT, class Traits1, class Alloc1, class Traits2>
inline std::size_t regex_split(OutputIterator out,
std::basic_string<charT, Traits1, Alloc1>& s,
const basic_regex<charT, Traits2>& e,
@ -137,7 +137,7 @@ inline std::size_t regex_split(OutputIterator out,
return regex_split(out, s, e, flags, UINT_MAX);
}
template <class OutputIterator, class charT, class Traits1, class Alloc1>
BOOST_REGEX_MODULE_EXPORT template <class OutputIterator, class charT, class Traits1, class Alloc1>
inline std::size_t regex_split(OutputIterator out,
std::basic_string<charT, Traits1, Alloc1>& s)
{

25
include/boost/regex/v5/regex_token_iterator.hpp
View File

@ -22,8 +22,9 @@
#include <boost/regex/v5/basic_regex.hpp>
#include <boost/regex/v5/match_results.hpp>
#include <boost/regex/v5/sub_match.hpp>
#ifndef BOOST_REGEX_AS_MODULE
#include <memory>
#endif
namespace boost{
@ -124,7 +125,7 @@ private:
regex_token_iterator_implementation& operator=(const regex_token_iterator_implementation&);
};
template <class BidirectionalIterator,
BOOST_REGEX_MODULE_EXPORT template <class BidirectionalIterator,
class charT = typename std::iterator_traits<BidirectionalIterator>::value_type,
class traits = regex_traits<charT> >
class regex_token_iterator
@ -212,39 +213,39 @@ private:
}
};
typedef regex_token_iterator<const char*> cregex_token_iterator;
typedef regex_token_iterator<std::string::const_iterator> sregex_token_iterator;
BOOST_REGEX_MODULE_EXPORT typedef regex_token_iterator<const char*> cregex_token_iterator;
BOOST_REGEX_MODULE_EXPORT typedef regex_token_iterator<std::string::const_iterator> sregex_token_iterator;
#ifndef BOOST_NO_WREGEX
typedef regex_token_iterator<const wchar_t*> wcregex_token_iterator;
typedef regex_token_iterator<std::wstring::const_iterator> wsregex_token_iterator;
BOOST_REGEX_MODULE_EXPORT typedef regex_token_iterator<const wchar_t*> wcregex_token_iterator;
BOOST_REGEX_MODULE_EXPORT typedef regex_token_iterator<std::wstring::const_iterator> wsregex_token_iterator;
#endif
template <class charT, class traits>
BOOST_REGEX_MODULE_EXPORT template <class charT, class traits>
inline regex_token_iterator<const charT*, charT, traits> make_regex_token_iterator(const charT* p, const basic_regex<charT, traits>& e, int submatch = 0, regex_constants::match_flag_type m = regex_constants::match_default)
{
return regex_token_iterator<const charT*, charT, traits>(p, p+traits::length(p), e, submatch, m);
}
template <class charT, class traits, class ST, class SA>
BOOST_REGEX_MODULE_EXPORT template <class charT, class traits, class ST, class SA>
inline regex_token_iterator<typename std::basic_string<charT, ST, SA>::const_iterator, charT, traits> make_regex_token_iterator(const std::basic_string<charT, ST, SA>& p, const basic_regex<charT, traits>& e, int submatch = 0, regex_constants::match_flag_type m = regex_constants::match_default)
{
return regex_token_iterator<typename std::basic_string<charT, ST, SA>::const_iterator, charT, traits>(p.begin(), p.end(), e, submatch, m);
}
template <class charT, class traits, std::size_t N>
BOOST_REGEX_MODULE_EXPORT template <class charT, class traits, std::size_t N>
inline regex_token_iterator<const charT*, charT, traits> make_regex_token_iterator(const charT* p, const basic_regex<charT, traits>& e, const int (&submatch)[N], regex_constants::match_flag_type m = regex_constants::match_default)
{
return regex_token_iterator<const charT*, charT, traits>(p, p+traits::length(p), e, submatch, m);
}
template <class charT, class traits, class ST, class SA, std::size_t N>
BOOST_REGEX_MODULE_EXPORT template <class charT, class traits, class ST, class SA, std::size_t N>
inline regex_token_iterator<typename std::basic_string<charT, ST, SA>::const_iterator, charT, traits> make_regex_token_iterator(const std::basic_string<charT, ST, SA>& p, const basic_regex<charT, traits>& e, const int (&submatch)[N], regex_constants::match_flag_type m = regex_constants::match_default)
{
return regex_token_iterator<typename std::basic_string<charT, ST, SA>::const_iterator, charT, traits>(p.begin(), p.end(), e, submatch, m);
}
template <class charT, class traits>
BOOST_REGEX_MODULE_EXPORT template <class charT, class traits>
inline regex_token_iterator<const charT*, charT, traits> make_regex_token_iterator(const charT* p, const basic_regex<charT, traits>& e, const std::vector<int>& submatch, regex_constants::match_flag_type m = regex_constants::match_default)
{
return regex_token_iterator<const charT*, charT, traits>(p, p+traits::length(p), e, submatch, m);
}
template <class charT, class traits, class ST, class SA>
BOOST_REGEX_MODULE_EXPORT template <class charT, class traits, class ST, class SA>
inline regex_token_iterator<typename std::basic_string<charT, ST, SA>::const_iterator, charT, traits> make_regex_token_iterator(const std::basic_string<charT, ST, SA>& p, const basic_regex<charT, traits>& e, const std::vector<int>& submatch, regex_constants::match_flag_type m = regex_constants::match_default)
{
return regex_token_iterator<typename std::basic_string<charT, ST, SA>::const_iterator, charT, traits>(p.begin(), p.end(), e, submatch, m);

2
include/boost/regex/v5/regex_traits.hpp
View File

@ -33,7 +33,7 @@
namespace boost{
template <class charT, class implementationT >
BOOST_REGEX_MODULE_EXPORT template <class charT, class implementationT >
struct regex_traits : public implementationT
{
regex_traits() : implementationT() {}

2
include/boost/regex/v5/regex_traits_defaults.hpp
View File

@ -24,12 +24,14 @@
#include <boost/regex/v5/syntax_type.hpp>
#include <boost/regex/v5/error_type.hpp>
#include <boost/regex/v5/regex_workaround.hpp>
#ifndef BOOST_REGEX_AS_MODULE
#include <type_traits>
#include <cstdint>
#include <cctype>
#include <locale>
#include <cwctype>
#include <limits>
#endif
namespace boost{ namespace BOOST_REGEX_DETAIL_NS{

2
include/boost/regex/v5/regex_workaround.hpp
View File

@ -20,9 +20,11 @@
#define BOOST_REGEX_WORKAROUND_HPP
#include <boost/regex/config.hpp>
#ifndef BOOST_REGEX_AS_MODULE
#include <algorithm>
#include <stdexcept>
#include <cstring>
#endif
#ifndef BOOST_REGEX_STANDALONE
#include <boost/detail/workaround.hpp>

2
include/boost/regex/v5/states.hpp
View File

@ -21,8 +21,10 @@
#include <boost/regex/v5/regex_raw_buffer.hpp>
#ifndef BOOST_REGEX_AS_MODULE
#include <climits>
#include <cstddef>
#endif
namespace boost{
namespace BOOST_REGEX_DETAIL_NS{

100
include/boost/regex/v5/sub_match.hpp
View File

@ -19,12 +19,14 @@
#ifndef BOOST_REGEX_V5_SUB_MATCH_HPP
#define BOOST_REGEX_V5_SUB_MATCH_HPP
#ifndef BOOST_REGEX_AS_MODULE
#include <iterator>
#include <utility>
#endif
namespace boost{
template <class BidiIterator>
BOOST_REGEX_MODULE_EXPORT template <class BidiIterator>
struct sub_match : public std::pair<BidiIterator, BidiIterator>
{
typedef typename std::iterator_traits<BidiIterator>::value_type value_type;
@ -148,167 +150,167 @@ public:
BidiIterator end()const { return this->second; }
};
typedef sub_match<const char*> csub_match;
typedef sub_match<std::string::const_iterator> ssub_match;
BOOST_REGEX_MODULE_EXPORT typedef sub_match<const char*> csub_match;
BOOST_REGEX_MODULE_EXPORT typedef sub_match<std::string::const_iterator> ssub_match;
#ifndef BOOST_NO_WREGEX
typedef sub_match<const wchar_t*> wcsub_match;
typedef sub_match<std::wstring::const_iterator> wssub_match;
BOOST_REGEX_MODULE_EXPORT typedef sub_match<const wchar_t*> wcsub_match;
BOOST_REGEX_MODULE_EXPORT typedef sub_match<std::wstring::const_iterator> wssub_match;
#endif
// comparison to std::basic_string<> part 1:
template <class RandomAccessIterator, class traits, class Allocator>
BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator, class traits, class Allocator>
inline bool operator == (const std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,
const sub_match<RandomAccessIterator>& m)
{ return s.compare(m.str()) == 0; }
template <class RandomAccessIterator, class traits, class Allocator>
BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator, class traits, class Allocator>
inline bool operator != (const std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,
const sub_match<RandomAccessIterator>& m)
{ return s.compare(m.str()) != 0; }
template <class RandomAccessIterator, class traits, class Allocator>
BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator, class traits, class Allocator>
inline bool operator < (const std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,
const sub_match<RandomAccessIterator>& m)
{ return s.compare(m.str()) < 0; }
template <class RandomAccessIterator, class traits, class Allocator>
BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator, class traits, class Allocator>
inline bool operator <= (const std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,
const sub_match<RandomAccessIterator>& m)
{ return s.compare(m.str()) <= 0; }
template <class RandomAccessIterator, class traits, class Allocator>
BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator, class traits, class Allocator>
inline bool operator >= (const std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,
const sub_match<RandomAccessIterator>& m)
{ return s.compare(m.str()) >= 0; }
template <class RandomAccessIterator, class traits, class Allocator>
BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator, class traits, class Allocator>
inline bool operator > (const std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,
const sub_match<RandomAccessIterator>& m)
{ return s.compare(m.str()) > 0; }
// comparison to std::basic_string<> part 2:
template <class RandomAccessIterator, class traits, class Allocator>
BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator, class traits, class Allocator>
inline bool operator == (const sub_match<RandomAccessIterator>& m,
const std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)
{ return m.str().compare(s) == 0; }
template <class RandomAccessIterator, class traits, class Allocator>
BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator, class traits, class Allocator>
inline bool operator != (const sub_match<RandomAccessIterator>& m,
const std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)
{ return m.str().compare(s) != 0; }
template <class RandomAccessIterator, class traits, class Allocator>
BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator, class traits, class Allocator>
inline bool operator < (const sub_match<RandomAccessIterator>& m,
const std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)
{ return m.str().compare(s) < 0; }
template <class RandomAccessIterator, class traits, class Allocator>
BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator, class traits, class Allocator>
inline bool operator > (const sub_match<RandomAccessIterator>& m,
const std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)
{ return m.str().compare(s) > 0; }
template <class RandomAccessIterator, class traits, class Allocator>
BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator, class traits, class Allocator>
inline bool operator <= (const sub_match<RandomAccessIterator>& m,
const std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)
{ return m.str().compare(s) <= 0; }
template <class RandomAccessIterator, class traits, class Allocator>
BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator, class traits, class Allocator>
inline bool operator >= (const sub_match<RandomAccessIterator>& m,
const std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)
{ return m.str().compare(s) >= 0; }
// comparison to const charT* part 1:
template <class RandomAccessIterator>
BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
inline bool operator == (const sub_match<RandomAccessIterator>& m,
typename std::iterator_traits<RandomAccessIterator>::value_type const* s)
{ return m.str().compare(s) == 0; }
template <class RandomAccessIterator>
BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
inline bool operator != (const sub_match<RandomAccessIterator>& m,
typename std::iterator_traits<RandomAccessIterator>::value_type const* s)
{ return m.str().compare(s) != 0; }
template <class RandomAccessIterator>
BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
inline bool operator > (const sub_match<RandomAccessIterator>& m,
typename std::iterator_traits<RandomAccessIterator>::value_type const* s)
{ return m.str().compare(s) > 0; }
template <class RandomAccessIterator>
BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
inline bool operator < (const sub_match<RandomAccessIterator>& m,
typename std::iterator_traits<RandomAccessIterator>::value_type const* s)
{ return m.str().compare(s) < 0; }
template <class RandomAccessIterator>
BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
inline bool operator >= (const sub_match<RandomAccessIterator>& m,
typename std::iterator_traits<RandomAccessIterator>::value_type const* s)
{ return m.str().compare(s) >= 0; }
template <class RandomAccessIterator>
BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
inline bool operator <= (const sub_match<RandomAccessIterator>& m,
typename std::iterator_traits<RandomAccessIterator>::value_type const* s)
{ return m.str().compare(s) <= 0; }
// comparison to const charT* part 2:
template <class RandomAccessIterator>
BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
inline bool operator == (typename std::iterator_traits<RandomAccessIterator>::value_type const* s,
const sub_match<RandomAccessIterator>& m)
{ return m.str().compare(s) == 0; }
template <class RandomAccessIterator>
BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
inline bool operator != (typename std::iterator_traits<RandomAccessIterator>::value_type const* s,
const sub_match<RandomAccessIterator>& m)
{ return m.str().compare(s) != 0; }
template <class RandomAccessIterator>
BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
inline bool operator < (typename std::iterator_traits<RandomAccessIterator>::value_type const* s,
const sub_match<RandomAccessIterator>& m)
{ return m.str().compare(s) > 0; }
template <class RandomAccessIterator>
BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
inline bool operator > (typename std::iterator_traits<RandomAccessIterator>::value_type const* s,
const sub_match<RandomAccessIterator>& m)
{ return m.str().compare(s) < 0; }
template <class RandomAccessIterator>
BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
inline bool operator <= (typename std::iterator_traits<RandomAccessIterator>::value_type const* s,
const sub_match<RandomAccessIterator>& m)
{ return m.str().compare(s) >= 0; }
template <class RandomAccessIterator>
BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
inline bool operator >= (typename std::iterator_traits<RandomAccessIterator>::value_type const* s,
const sub_match<RandomAccessIterator>& m)
{ return m.str().compare(s) <= 0; }
// comparison to const charT& part 1:
template <class RandomAccessIterator>
BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
inline bool operator == (const sub_match<RandomAccessIterator>& m,
typename std::iterator_traits<RandomAccessIterator>::value_type const& s)
{ return m.str().compare(0, m.length(), &s, 1) == 0; }
template <class RandomAccessIterator>
BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
inline bool operator != (const sub_match<RandomAccessIterator>& m,
typename std::iterator_traits<RandomAccessIterator>::value_type const& s)
{ return m.str().compare(0, m.length(), &s, 1) != 0; }
template <class RandomAccessIterator>
BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
inline bool operator > (const sub_match<RandomAccessIterator>& m,
typename std::iterator_traits<RandomAccessIterator>::value_type const& s)
{ return m.str().compare(0, m.length(), &s, 1) > 0; }
template <class RandomAccessIterator>
BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
inline bool operator < (const sub_match<RandomAccessIterator>& m,
typename std::iterator_traits<RandomAccessIterator>::value_type const& s)
{ return m.str().compare(0, m.length(), &s, 1) < 0; }
template <class RandomAccessIterator>
BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
inline bool operator >= (const sub_match<RandomAccessIterator>& m,
typename std::iterator_traits<RandomAccessIterator>::value_type const& s)
{ return m.str().compare(0, m.length(), &s, 1) >= 0; }
template <class RandomAccessIterator>
BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
inline bool operator <= (const sub_match<RandomAccessIterator>& m,
typename std::iterator_traits<RandomAccessIterator>::value_type const& s)
{ return m.str().compare(0, m.length(), &s, 1) <= 0; }
// comparison to const charT* part 2:
template <class RandomAccessIterator>
BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
inline bool operator == (typename std::iterator_traits<RandomAccessIterator>::value_type const& s,
const sub_match<RandomAccessIterator>& m)
{ return m.str().compare(0, m.length(), &s, 1) == 0; }
template <class RandomAccessIterator>
BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
inline bool operator != (typename std::iterator_traits<RandomAccessIterator>::value_type const& s,
const sub_match<RandomAccessIterator>& m)
{ return m.str().compare(0, m.length(), &s, 1) != 0; }
template <class RandomAccessIterator>
BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
inline bool operator < (typename std::iterator_traits<RandomAccessIterator>::value_type const& s,
const sub_match<RandomAccessIterator>& m)
{ return m.str().compare(0, m.length(), &s, 1) > 0; }
template <class RandomAccessIterator>
BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
inline bool operator > (typename std::iterator_traits<RandomAccessIterator>::value_type const& s,
const sub_match<RandomAccessIterator>& m)
{ return m.str().compare(0, m.length(), &s, 1) < 0; }
template <class RandomAccessIterator>
BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
inline bool operator <= (typename std::iterator_traits<RandomAccessIterator>::value_type const& s,
const sub_match<RandomAccessIterator>& m)
{ return m.str().compare(0, m.length(), &s, 1) >= 0; }
template <class RandomAccessIterator>
BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
inline bool operator >= (typename std::iterator_traits<RandomAccessIterator>::value_type const& s,
const sub_match<RandomAccessIterator>& m)
{ return m.str().compare(0, m.length(), &s, 1) <= 0; }
// addition operators:
template <class RandomAccessIterator, class traits, class Allocator>
BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator, class traits, class Allocator>
inline std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>
operator + (const std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,
const sub_match<RandomAccessIterator>& m)
@ -317,7 +319,7 @@ operator + (const std::basic_string<typename std::iterator_traits<RandomAccessIt
result.reserve(s.size() + m.length() + 1);
return result.append(s).append(m.first, m.second);
}
template <class RandomAccessIterator, class traits, class Allocator>
BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator, class traits, class Allocator>
inline std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>
operator + (const sub_match<RandomAccessIterator>& m,
const std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)
@ -326,7 +328,7 @@ operator + (const sub_match<RandomAccessIterator>& m,
result.reserve(s.size() + m.length() + 1);
return result.append(m.first, m.second).append(s);
}
template <class RandomAccessIterator>
BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
inline std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type>
operator + (typename std::iterator_traits<RandomAccessIterator>::value_type const* s,
const sub_match<RandomAccessIterator>& m)
@ -335,7 +337,7 @@ operator + (typename std::iterator_traits<RandomAccessIterator>::value_type cons
result.reserve(std::char_traits<typename std::iterator_traits<RandomAccessIterator>::value_type>::length(s) + m.length() + 1);
return result.append(s).append(m.first, m.second);
}
template <class RandomAccessIterator>
BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
inline std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type>
operator + (const sub_match<RandomAccessIterator>& m,
typename std::iterator_traits<RandomAccessIterator>::value_type const * s)
@ -344,7 +346,7 @@ operator + (const sub_match<RandomAccessIterator>& m,
result.reserve(std::char_traits<typename std::iterator_traits<RandomAccessIterator>::value_type>::length(s) + m.length() + 1);
return result.append(m.first, m.second).append(s);
}
template <class RandomAccessIterator>
BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
inline std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type>
operator + (typename std::iterator_traits<RandomAccessIterator>::value_type const& s,
const sub_match<RandomAccessIterator>& m)
@ -353,7 +355,7 @@ operator + (typename std::iterator_traits<RandomAccessIterator>::value_type cons
result.reserve(m.length() + 2);
return result.append(1, s).append(m.first, m.second);
}
template <class RandomAccessIterator>
BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
inline std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type>
operator + (const sub_match<RandomAccessIterator>& m,
typename std::iterator_traits<RandomAccessIterator>::value_type const& s)
@ -362,7 +364,7 @@ operator + (const sub_match<RandomAccessIterator>& m,
result.reserve(m.length() + 2);
return result.append(m.first, m.second).append(1, s);
}
template <class RandomAccessIterator>
BOOST_REGEX_MODULE_EXPORT template <class RandomAccessIterator>
inline std::basic_string<typename std::iterator_traits<RandomAccessIterator>::value_type>
operator + (const sub_match<RandomAccessIterator>& m1,
const sub_match<RandomAccessIterator>& m2)
@ -371,7 +373,7 @@ operator + (const sub_match<RandomAccessIterator>& m1,
result.reserve(m1.length() + m2.length() + 1);
return result.append(m1.first, m1.second).append(m2.first, m2.second);
}
template <class charT, class traits, class RandomAccessIterator>
BOOST_REGEX_MODULE_EXPORT template <class charT, class traits, class RandomAccessIterator>
std::basic_ostream<charT, traits>&
operator << (std::basic_ostream<charT, traits>& os,
const sub_match<RandomAccessIterator>& s)

118
include/boost/regex/v5/syntax_type.hpp
View File

@ -22,81 +22,81 @@
namespace boost{
namespace regex_constants{
typedef unsigned char syntax_type;
BOOST_REGEX_MODULE_EXPORT typedef unsigned char syntax_type;
//
// values chosen are binary compatible with previous version:
//
static const syntax_type syntax_char = 0;
static const syntax_type syntax_open_mark = 1;
static const syntax_type syntax_close_mark = 2;
static const syntax_type syntax_dollar = 3;
static const syntax_type syntax_caret = 4;
static const syntax_type syntax_dot = 5;
static const syntax_type syntax_star = 6;
static const syntax_type syntax_plus = 7;
static const syntax_type syntax_question = 8;
static const syntax_type syntax_open_set = 9;
static const syntax_type syntax_close_set = 10;
static const syntax_type syntax_or = 11;
static const syntax_type syntax_escape = 12;
static const syntax_type syntax_dash = 14;
static const syntax_type syntax_open_brace = 15;
static const syntax_type syntax_close_brace = 16;
static const syntax_type syntax_digit = 17;
static const syntax_type syntax_comma = 27;
static const syntax_type syntax_equal = 37;
static const syntax_type syntax_colon = 36;
static const syntax_type syntax_not = 53;
BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST syntax_type syntax_char = 0;
BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST syntax_type syntax_open_mark = 1;
BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST syntax_type syntax_close_mark = 2;
BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST syntax_type syntax_dollar = 3;
BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST syntax_type syntax_caret = 4;
BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST syntax_type syntax_dot = 5;
BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST syntax_type syntax_star = 6;
BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST syntax_type syntax_plus = 7;
BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST syntax_type syntax_question = 8;
BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST syntax_type syntax_open_set = 9;
BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST syntax_type syntax_close_set = 10;
BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST syntax_type syntax_or = 11;
BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST syntax_type syntax_escape = 12;
BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST syntax_type syntax_dash = 14;
BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST syntax_type syntax_open_brace = 15;
BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST syntax_type syntax_close_brace = 16;
BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST syntax_type syntax_digit = 17;
BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST syntax_type syntax_comma = 27;
BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST syntax_type syntax_equal = 37;
BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST syntax_type syntax_colon = 36;
BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST syntax_type syntax_not = 53;
// extensions:
static const syntax_type syntax_hash = 13;
static const syntax_type syntax_newline = 26;
BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST syntax_type syntax_hash = 13;
BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST syntax_type syntax_newline = 26;
// escapes:
typedef syntax_type escape_syntax_type;
BOOST_REGEX_MODULE_EXPORT typedef syntax_type escape_syntax_type;
static const escape_syntax_type escape_type_word_assert = 18;
static const escape_syntax_type escape_type_not_word_assert = 19;
static const escape_syntax_type escape_type_control_f = 29;
static const escape_syntax_type escape_type_control_n = 30;
static const escape_syntax_type escape_type_control_r = 31;
static const escape_syntax_type escape_type_control_t = 32;
static const escape_syntax_type escape_type_control_v = 33;
static const escape_syntax_type escape_type_ascii_control = 35;
static const escape_syntax_type escape_type_hex = 34;
static const escape_syntax_type escape_type_unicode = 0; // not used
static const escape_syntax_type escape_type_identity = 0; // not used
static const escape_syntax_type escape_type_backref = syntax_digit;
static const escape_syntax_type escape_type_decimal = syntax_digit; // not used
static const escape_syntax_type escape_type_class = 22;
static const escape_syntax_type escape_type_not_class = 23;
BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_word_assert = 18;
BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_not_word_assert = 19;
BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_control_f = 29;
BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_control_n = 30;
BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_control_r = 31;
BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_control_t = 32;
BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_control_v = 33;
BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_ascii_control = 35;
BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_hex = 34;
BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_unicode = 0; // not used
BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_identity = 0; // not used
BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_backref = syntax_digit;
BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_decimal = syntax_digit; // not used
BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_class = 22;
BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_not_class = 23;
// extensions:
static const escape_syntax_type escape_type_left_word = 20;
static const escape_syntax_type escape_type_right_word = 21;
static const escape_syntax_type escape_type_start_buffer = 24; // for \`
static const escape_syntax_type escape_type_end_buffer = 25; // for \'
static const escape_syntax_type escape_type_control_a = 28; // for \a
static const escape_syntax_type escape_type_e = 38; // for \e
static const escape_syntax_type escape_type_E = 47; // for \Q\E
static const escape_syntax_type escape_type_Q = 48; // for \Q\E
static const escape_syntax_type escape_type_X = 49; // for \X
static const escape_syntax_type escape_type_C = 50; // for \C
static const escape_syntax_type escape_type_Z = 51; // for \Z
static const escape_syntax_type escape_type_G = 52; // for \G
BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_left_word = 20;
BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_right_word = 21;
BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_start_buffer = 24; // for \`
BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_end_buffer = 25; // for \'
BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_control_a = 28; // for \a
BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_e = 38; // for \e
BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_E = 47; // for \Q\E
BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_Q = 48; // for \Q\E
BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_X = 49; // for \X
BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_C = 50; // for \C
BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_Z = 51; // for \Z
BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_G = 52; // for \G
static const escape_syntax_type escape_type_property = 54; // for \p
static const escape_syntax_type escape_type_not_property = 55; // for \P
static const escape_syntax_type escape_type_named_char = 56; // for \N
static const escape_syntax_type escape_type_extended_backref = 57; // for \g
static const escape_syntax_type escape_type_reset_start_mark = 58; // for \K
static const escape_syntax_type escape_type_line_ending = 59; // for \R
BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_property = 54; // for \p
BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_not_property = 55; // for \P
BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_named_char = 56; // for \N
BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_extended_backref = 57; // for \g
BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_reset_start_mark = 58; // for \K
BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type escape_type_line_ending = 59; // for \R
static const escape_syntax_type syntax_max = 60;
BOOST_REGEX_MODULE_EXPORT BOOST_REGEX_STATIC_CONST escape_syntax_type syntax_max = 60;
}
}

10
include/boost/regex/v5/unicode_iterator.hpp
View File

@ -60,12 +60,14 @@ Accepts UTF-32 code points and forwards them on as UTF-16 code points.
#ifndef BOOST_REGEX_UNICODE_ITERATOR_HPP
#define BOOST_REGEX_UNICODE_ITERATOR_HPP
#include <cstdint>
#include <boost/regex/config.hpp>
#ifndef BOOST_REGEX_AS_MODULE
#include <cstdint>
#include <stdexcept>
#include <sstream>
#include <ios>
#include <limits.h> // CHAR_BIT
#endif
#ifndef BOOST_REGEX_STANDALONE
#include <boost/throw_exception.hpp>
@ -75,9 +77,9 @@ namespace boost{
namespace detail{
static const std::uint16_t high_surrogate_base = 0xD7C0u;
static const std::uint16_t low_surrogate_base = 0xDC00u;
static const std::uint32_t ten_bit_mask = 0x3FFu;
BOOST_REGEX_STATIC_CONST std::uint16_t high_surrogate_base = 0xD7C0u;
BOOST_REGEX_STATIC_CONST std::uint16_t low_surrogate_base = 0xDC00u;
BOOST_REGEX_STATIC_CONST std::uint32_t ten_bit_mask = 0x3FFu;
inline bool is_high_surrogate(std::uint16_t v)
{

4
include/boost/regex/v5/w32_regex_traits.hpp
View File

@ -23,9 +23,11 @@
#include <boost/regex/pattern_except.hpp>
#include <boost/regex/v5/regex_traits_defaults.hpp>
#ifndef BOOST_REGEX_AS_MODULE
#ifdef BOOST_HAS_THREADS
#include <mutex>
#endif
#endif
#include <boost/regex/v5/primary_transform.hpp>
#include <boost/regex/v5/object_cache.hpp>
@ -652,7 +654,7 @@ std::shared_ptr<const w32_regex_traits_implementation<charT> > create_w32_regex_
} // BOOST_REGEX_DETAIL_NS
template <class charT>
BOOST_REGEX_MODULE_EXPORT template <class charT>
class w32_regex_traits
{
public: