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

Merge changes from Trunk ready for 1.37.

Browse Source 
[SVN r48796]
This commit is contained in:
John Maddock
2008-09-16 11:54:24 +00:00
parent 756a875620
commit 5471176846
18 changed files with 148 additions and 112 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
build/Jamfile.v2
View File

@ -169,7 +169,8 @@ rule check-icu-config ( )
if [ check-icu-config ] if [ check-icu-config ]
{ {
BOOST_REGEX_ICU_OPTS = "<define>BOOST_HAS_ICU=1" ; BOOST_REGEX_ICU_OPTS = "<target-os>freebsd:<include>/usr/local/include" ;
BOOST_REGEX_ICU_OPTS += "<define>BOOST_HAS_ICU=1" ;
if $(ICU_PATH) if $(ICU_PATH)
{ {
@ -259,3 +260,4 @@ boost-install boost_regex ;

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

@ -87,12 +87,12 @@ struct regex_traits_architype
public: public:
regex_traits_architype(); regex_traits_architype();
typedef charT char_type; typedef charT char_type;
typedef std::size_t size_type; // typedef std::size_t size_type;
typedef std::vector<char_type> string_type; typedef std::vector<char_type> string_type;
typedef copy_constructible_archetype<assignable_archetype<> > locale_type; typedef copy_constructible_archetype<assignable_archetype<> > locale_type;
typedef bitmask_archetype char_class_type; typedef bitmask_archetype char_class_type;
static size_type length(const char_type* ) { return 0; } static std::size_t length(const char_type* ) { return 0; }
charT translate(charT ) const { return charT(); } charT translate(charT ) const { return charT(); }
charT translate_nocase(charT ) const { return static_object<charT>::get(); } charT translate_nocase(charT ) const { return static_object<charT>::get(); }
@ -163,21 +163,21 @@ struct RegexTraitsConcept
RegexTraitsConcept(); RegexTraitsConcept();
// required typedefs: // required typedefs:
typedef typename traits::char_type char_type; typedef typename traits::char_type char_type;
typedef typename traits::size_type size_type; // typedef typename traits::size_type size_type;
typedef typename traits::string_type string_type; typedef typename traits::string_type string_type;
typedef typename traits::locale_type locale_type; typedef typename traits::locale_type locale_type;
typedef typename traits::char_class_type char_class_type; typedef typename traits::char_class_type char_class_type;
void constraints() void constraints()
{ {
function_requires<UnsignedIntegerConcept<size_type> >(); //function_requires<UnsignedIntegerConcept<size_type> >();
function_requires<RandomAccessContainerConcept<string_type> >(); function_requires<RandomAccessContainerConcept<string_type> >();
function_requires<DefaultConstructibleConcept<locale_type> >(); function_requires<DefaultConstructibleConcept<locale_type> >();
function_requires<CopyConstructibleConcept<locale_type> >(); function_requires<CopyConstructibleConcept<locale_type> >();
function_requires<AssignableConcept<locale_type> >(); function_requires<AssignableConcept<locale_type> >();
function_requires<BitmaskConcept<char_class_type> >(); function_requires<BitmaskConcept<char_class_type> >();
size_type n = traits::length(m_pointer); std::size_t n = traits::length(m_pointer);
ignore_unused_variable_warning(n); ignore_unused_variable_warning(n);
char_type c = m_ctraits.translate(m_char); char_type c = m_ctraits.translate(m_char);

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

@ -355,7 +355,7 @@ inline u32regex make_u32regex(const wchar_t* p, boost::regex_constants::syntax_o
return re_detail::do_make_u32regex(p, p + std::wcslen(p), opt, static_cast<boost::mpl::int_<sizeof(wchar_t)> const*>(0)); return re_detail::do_make_u32regex(p, p + std::wcslen(p), opt, static_cast<boost::mpl::int_<sizeof(wchar_t)> const*>(0));
} }
#endif #endif
#ifndef U_WCHAR_IS_UTF16 #if !defined(U_WCHAR_IS_UTF16) && (U_SIZEOF_WCHAR_T != 2)
inline u32regex make_u32regex(const UChar* p, boost::regex_constants::syntax_option_type opt = boost::regex_constants::perl) inline u32regex make_u32regex(const UChar* p, boost::regex_constants::syntax_option_type opt = boost::regex_constants::perl)
{ {
return re_detail::do_make_u32regex(p, p + u_strlen(p), opt, static_cast<boost::mpl::int_<2> const*>(0)); return re_detail::do_make_u32regex(p, p + u_strlen(p), opt, static_cast<boost::mpl::int_<2> const*>(0));
@ -455,7 +455,7 @@ inline bool u32regex_match(const UChar* p,
{ {
return re_detail::do_regex_match(p, p+u_strlen(p), m, e, flags, static_cast<mpl::int_<2> const*>(0)); return re_detail::do_regex_match(p, p+u_strlen(p), m, e, flags, static_cast<mpl::int_<2> const*>(0));
} }
#if !defined(U_WCHAR_IS_UTF16) && !defined(BOOST_NO_WREGEX) #if !defined(U_WCHAR_IS_UTF16) && (U_SIZEOF_WCHAR_T != 2) && !defined(BOOST_NO_WREGEX)
inline bool u32regex_match(const wchar_t* p, 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,
@ -519,7 +519,7 @@ inline bool u32regex_match(const UChar* p,
match_results<const UChar*> m; match_results<const UChar*> m;
return re_detail::do_regex_match(p, p+u_strlen(p), m, e, flags, static_cast<mpl::int_<2> const*>(0)); return re_detail::do_regex_match(p, p+u_strlen(p), m, e, flags, static_cast<mpl::int_<2> const*>(0));
} }
#if !defined(U_WCHAR_IS_UTF16) && !defined(BOOST_NO_WREGEX) #if !defined(U_WCHAR_IS_UTF16) && (U_SIZEOF_WCHAR_T != 2) && !defined(BOOST_NO_WREGEX)
inline bool u32regex_match(const wchar_t* p, 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)
@ -640,7 +640,7 @@ inline bool u32regex_search(const UChar* p,
{ {
return re_detail::do_regex_search(p, p+u_strlen(p), m, e, flags, p, static_cast<mpl::int_<2> const*>(0)); return re_detail::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) && !defined(BOOST_NO_WREGEX) #if !defined(U_WCHAR_IS_UTF16) && (U_SIZEOF_WCHAR_T != 2) && !defined(BOOST_NO_WREGEX)
inline bool u32regex_search(const wchar_t* p, 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,
@ -701,7 +701,7 @@ inline bool u32regex_search(const UChar* p,
match_results<const UChar*> m; match_results<const UChar*> m;
return re_detail::do_regex_search(p, p+u_strlen(p), m, e, flags, p, static_cast<mpl::int_<2> const*>(0)); return re_detail::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) && !defined(BOOST_NO_WREGEX) #if !defined(U_WCHAR_IS_UTF16) && (U_SIZEOF_WCHAR_T != 2) && !defined(BOOST_NO_WREGEX)
inline bool u32regex_search(const wchar_t* p, 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)

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

@ -191,7 +191,7 @@ class basic_regex : public regbase
{ {
public: public:
// typedefs: // typedefs:
typedef typename traits::size_type traits_size_type; typedef std::size_t traits_size_type;
typedef typename traits::string_type traits_string_type; typedef typename traits::string_type traits_string_type;
typedef charT char_type; typedef charT char_type;
typedef traits traits_type; typedef traits traits_type;

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

@ -236,7 +236,7 @@ protected:
m_traits; // convenience reference to traits class m_traits; // convenience reference to traits class
re_syntax_base* m_last_state; // the last state we added re_syntax_base* m_last_state; // the last state we added
bool m_icase; // true for case insensitive matches bool m_icase; // true for case insensitive matches
unsigned m_repeater_id; // the id of the next repeater unsigned m_repeater_id; // the state_id of the next repeater
bool m_has_backrefs; // true if there are actually any backrefs bool m_has_backrefs; // true if there are actually any backrefs
unsigned m_backrefs; // bitmask of permitted backrefs unsigned m_backrefs; // bitmask of permitted backrefs
boost::uintmax_t m_bad_repeats; // bitmask of repeats we can't deduce a startmap for; boost::uintmax_t m_bad_repeats; // bitmask of repeats we can't deduce a startmap for;
@ -718,8 +718,8 @@ void basic_regex_creator<charT, traits>::fixup_pointers(re_syntax_base* state)
case syntax_element_char_rep: case syntax_element_char_rep:
case syntax_element_short_set_rep: case syntax_element_short_set_rep:
case syntax_element_long_set_rep: case syntax_element_long_set_rep:
// set the id of this repeat: // set the state_id of this repeat:
static_cast<re_repeat*>(state)->id = m_repeater_id++; static_cast<re_repeat*>(state)->state_id = m_repeater_id++;
// fall through: // fall through:
case syntax_element_alt: case syntax_element_alt:
std::memset(static_cast<re_alt*>(state)->_map, 0, sizeof(static_cast<re_alt*>(state)->_map)); std::memset(static_cast<re_alt*>(state)->_map, 0, sizeof(static_cast<re_alt*>(state)->_map));
@ -1194,11 +1194,11 @@ bool basic_regex_creator<charT, traits>::is_bad_repeat(re_syntax_base* pt)
case syntax_element_short_set_rep: case syntax_element_short_set_rep:
case syntax_element_long_set_rep: case syntax_element_long_set_rep:
{ {
unsigned id = static_cast<re_repeat*>(pt)->id; unsigned state_id = static_cast<re_repeat*>(pt)->state_id;
if(id > sizeof(m_bad_repeats) * CHAR_BIT) if(state_id > sizeof(m_bad_repeats) * CHAR_BIT)
return true; // run out of bits, assume we can't traverse this one. return true; // run out of bits, assume we can't traverse this one.
static const boost::uintmax_t one = 1uL; static const boost::uintmax_t one = 1uL;
return m_bad_repeats & (one << id); return m_bad_repeats & (one << state_id);
} }
default: default:
return false; return false;
@ -1216,10 +1216,10 @@ void basic_regex_creator<charT, traits>::set_bad_repeat(re_syntax_base* pt)
case syntax_element_short_set_rep: case syntax_element_short_set_rep:
case syntax_element_long_set_rep: case syntax_element_long_set_rep:
{ {
unsigned id = static_cast<re_repeat*>(pt)->id; unsigned state_id = static_cast<re_repeat*>(pt)->state_id;
static const boost::uintmax_t one = 1uL; static const boost::uintmax_t one = 1uL;
if(id <= sizeof(m_bad_repeats) * CHAR_BIT) if(state_id <= sizeof(m_bad_repeats) * CHAR_BIT)
m_bad_repeats |= (one << id); m_bad_repeats |= (one << state_id);
} }
default: default:
break; break;

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

@ -799,9 +799,9 @@ typename cpp_regex_traits_implementation<charT>::char_class_type
if(pos != m_custom_class_names.end()) if(pos != m_custom_class_names.end())
return pos->second; return pos->second;
} }
std::size_t id = 1 + re_detail::get_default_class_id(p1, p2); std::size_t state_id = 1 + re_detail::get_default_class_id(p1, p2);
BOOST_ASSERT(id < sizeof(masks) / sizeof(masks[0])); BOOST_ASSERT(state_id < sizeof(masks) / sizeof(masks[0]));
return masks[id]; return masks[state_id];
} }
#ifdef BOOST_REGEX_BUGGY_CTYPE_FACET #ifdef BOOST_REGEX_BUGGY_CTYPE_FACET

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

@ -248,7 +248,7 @@ class repeater_count
{ {
repeater_count** stack; repeater_count** stack;
repeater_count* next; repeater_count* next;
int id; int state_id;
std::size_t count; // the number of iterations so far std::size_t count; // the number of iterations so far
BidiIterator start_pos; // where the last repeat started BidiIterator start_pos; // where the last repeat started
public: public:
@ -256,22 +256,22 @@ public:
{ {
stack = s; stack = s;
next = 0; next = 0;
id = -1; state_id = -1;
count = 0; count = 0;
} }
repeater_count(int i, repeater_count** s, BidiIterator start) repeater_count(int i, repeater_count** s, BidiIterator start)
: start_pos(start) : start_pos(start)
{ {
id = i; state_id = i;
stack = s; stack = s;
next = *stack; next = *stack;
*stack = this; *stack = this;
if(id > next->id) if(state_id > next->state_id)
count = 0; count = 0;
else else
{ {
repeater_count* p = next; repeater_count* p = next;
while(p->id != id) while(p->state_id != state_id)
p = p->next; p = p->next;
count = p->count; count = p->count;
start_pos = p->start_pos; start_pos = p->start_pos;
@ -282,7 +282,7 @@ public:
*stack = next; *stack = next;
} }
std::size_t get_count() { return count; } std::size_t get_count() { return count; }
int get_id() { return id; } int get_id() { return state_id; }
std::size_t operator++() { return ++count; } std::size_t operator++() { return ++count; }
bool check_null_repeat(const BidiIterator& pos, std::size_t max) bool check_null_repeat(const BidiIterator& pos, std::size_t max)
{ {
@ -331,7 +331,7 @@ public:
typedef typename traits::char_type char_type; typedef typename traits::char_type char_type;
typedef perl_matcher<BidiIterator, Allocator, traits> self_type; typedef perl_matcher<BidiIterator, Allocator, traits> self_type;
typedef bool (self_type::*matcher_proc_type)(void); typedef bool (self_type::*matcher_proc_type)(void);
typedef typename traits::size_type traits_size_type; typedef std::size_t traits_size_type;
typedef typename is_byte<char_type>::width_type width_type; typedef typename is_byte<char_type>::width_type width_type;
typedef typename regex_iterator_traits<BidiIterator>::difference_type difference_type; typedef typename regex_iterator_traits<BidiIterator>::difference_type difference_type;
@ -487,7 +487,7 @@ private:
void push_assertion(const re_syntax_base* ps, bool positive); void push_assertion(const re_syntax_base* ps, bool positive);
void push_alt(const re_syntax_base* ps); void push_alt(const re_syntax_base* ps);
void push_repeater_count(int i, repeater_count<BidiIterator>** s); void push_repeater_count(int i, repeater_count<BidiIterator>** s);
void push_single_repeat(std::size_t c, const re_repeat* r, BidiIterator last_position, int id); void push_single_repeat(std::size_t c, const re_repeat* r, BidiIterator last_position, int state_id);
void push_non_greedy_repeat(const re_syntax_base* ps); void push_non_greedy_repeat(const re_syntax_base* ps);

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

@ -50,13 +50,13 @@ inline void inplace_destroy(T* p)
struct saved_state struct saved_state
{ {
union{ union{
unsigned int id; unsigned int state_id;
// this padding ensures correct alignment on 64-bit platforms: // this padding ensures correct alignment on 64-bit platforms:
std::size_t padding1; std::size_t padding1;
std::ptrdiff_t padding2; std::ptrdiff_t padding2;
void* padding3; void* padding3;
}; };
saved_state(unsigned i) : id(i) {} saved_state(unsigned i) : state_id(i) {}
}; };
template <class BidiIterator> template <class BidiIterator>
@ -298,7 +298,7 @@ inline void perl_matcher<BidiIterator, Allocator, traits>::push_repeater_count(i
} }
template <class BidiIterator, class Allocator, class traits> template <class BidiIterator, class Allocator, class traits>
inline void perl_matcher<BidiIterator, Allocator, traits>::push_single_repeat(std::size_t c, const re_repeat* r, BidiIterator last_position, int id) inline void perl_matcher<BidiIterator, Allocator, traits>::push_single_repeat(std::size_t c, const re_repeat* r, BidiIterator last_position, int state_id)
{ {
saved_single_repeat<BidiIterator>* pmp = static_cast<saved_single_repeat<BidiIterator>*>(m_backup_state); saved_single_repeat<BidiIterator>* pmp = static_cast<saved_single_repeat<BidiIterator>*>(m_backup_state);
--pmp; --pmp;
@ -308,7 +308,7 @@ inline void perl_matcher<BidiIterator, Allocator, traits>::push_single_repeat(st
pmp = static_cast<saved_single_repeat<BidiIterator>*>(m_backup_state); pmp = static_cast<saved_single_repeat<BidiIterator>*>(m_backup_state);
--pmp; --pmp;
} }
(void) new (pmp)saved_single_repeat<BidiIterator>(c, r, last_position, id); (void) new (pmp)saved_single_repeat<BidiIterator>(c, r, last_position, state_id);
m_backup_state = pmp; m_backup_state = pmp;
} }
@ -477,11 +477,13 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_rep()
take_second = can_start(*position, rep->_map, (unsigned char)mask_skip); take_second = can_start(*position, rep->_map, (unsigned char)mask_skip);
} }
if(take_first || (next_count->get_id() != rep->id)) if((m_backup_state->state_id != saved_state_repeater_count)
|| (static_cast<saved_repeater<BidiIterator>*>(m_backup_state)->count.get_id() != rep->state_id)
|| (next_count->get_id() != rep->state_id))
{ {
// we're moving to a different repeat from the last // we're moving to a different repeat from the last
// one, so set up a counter object: // one, so set up a counter object:
push_repeater_count(rep->id, &next_count); push_repeater_count(rep->state_id, &next_count);
} }
// //
// If we've had at least one repeat already, and the last one // If we've had at least one repeat already, and the last one
@ -882,7 +884,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::unwind(bool have_match)
// //
do do
{ {
unwinder = s_unwind_table[m_backup_state->id]; unwinder = s_unwind_table[m_backup_state->state_id];
cont = (this->*unwinder)(m_recursive_result); cont = (this->*unwinder)(m_recursive_result);
}while(cont); }while(cont);
// //

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

@ -291,7 +291,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_rep()
// Always copy the repeat count, so that the state is restored // Always copy the repeat count, so that the state is restored
// when we exit this scope: // when we exit this scope:
// //
repeater_count<BidiIterator> r(rep->id, &next_count, position); repeater_count<BidiIterator> r(rep->state_id, &next_count, position);
// //
// If we've had at least one repeat already, and the last one // If we've had at least one repeat already, and the last one
// matched the NULL string then set the repeat count to // matched the NULL string then set the repeat count to

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

@ -134,8 +134,8 @@ inline bool is_separator<char>(char c)
BOOST_REGEX_DECL std::string BOOST_REGEX_CALL lookup_default_collate_name(const std::string& name); BOOST_REGEX_DECL std::string BOOST_REGEX_CALL lookup_default_collate_name(const std::string& name);
// //
// get the id of a character clasification, the individual // get the state_id of a character clasification, the individual
// traits classes then transform that id into a bitmask: // traits classes then transform that state_id into a bitmask:
// //
template <class charT> template <class charT>
struct character_pointer_range struct character_pointer_range

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

@ -240,7 +240,7 @@ Repeat a section of the machine
struct re_repeat : public re_alt struct re_repeat : public re_alt
{ {
std::size_t min, max; // min and max allowable repeats std::size_t min, max; // min and max allowable repeats
int id; // Unique identifier for this repeat int state_id; // Unique identifier for this repeat
bool leading; // True if this repeat is at the start of the machine (lets us optimize some searches) bool leading; // True if this repeat is at the start of the machine (lets us optimize some searches)
bool greedy; // True if this is a greedy repeat bool greedy; // True if this is a greedy repeat
}; };

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

@ -166,7 +166,7 @@ inline u32regex_iterator<const wchar_t*> make_u32regex_iterator(const wchar_t* p
return u32regex_iterator<const wchar_t*>(p, p+std::wcslen(p), e, m); return u32regex_iterator<const wchar_t*>(p, p+std::wcslen(p), e, m);
} }
#endif #endif
#ifndef U_WCHAR_IS_UTF16 #if !defined(U_WCHAR_IS_UTF16) && (U_SIZEOF_WCHAR_T != 2)
inline u32regex_iterator<const UChar*> make_u32regex_iterator(const UChar* p, const u32regex& e, regex_constants::match_flag_type m = regex_constants::match_default) 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);

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

@ -271,7 +271,7 @@ typedef u32regex_token_iterator<const char*> utf8regex_token_iterator;
typedef u32regex_token_iterator<const UChar*> utf16regex_token_iterator; typedef u32regex_token_iterator<const UChar*> utf16regex_token_iterator;
typedef u32regex_token_iterator<const UChar32*> utf32regex_token_iterator; typedef u32regex_token_iterator<const UChar32*> utf32regex_token_iterator;
// construction from an integral sub_match id: // construction from an integral sub_match state_id:
inline u32regex_token_iterator<const char*> make_u32regex_token_iterator(const char* p, const u32regex& e, int submatch = 0, regex_constants::match_flag_type m = regex_constants::match_default) inline u32regex_token_iterator<const char*> make_u32regex_token_iterator(const char* p, const u32regex& e, int submatch = 0, regex_constants::match_flag_type m = regex_constants::match_default)
{ {
return u32regex_token_iterator<const char*>(p, p+std::strlen(p), e, submatch, m); return u32regex_token_iterator<const char*>(p, p+std::strlen(p), e, submatch, m);
@ -282,7 +282,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
#ifndef U_WCHAR_IS_UTF16 #if !defined(U_WCHAR_IS_UTF16) && (U_SIZEOF_WCHAR_T != 2)
inline u32regex_token_iterator<const UChar*> make_u32regex_token_iterator(const UChar* p, const u32regex& e, int submatch = 0, regex_constants::match_flag_type m = regex_constants::match_default) 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, m); return u32regex_token_iterator<const UChar*>(p, p+u_strlen(p), e, m);
@ -313,7 +313,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
#ifndef U_WCHAR_IS_UTF16 #if !defined(U_WCHAR_IS_UTF16) && (U_SIZEOF_WCHAR_T != 2)
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)
{ {
@ -333,7 +333,7 @@ inline u32regex_token_iterator<const UChar*> make_u32regex_token_iterator(const
} }
#endif // BOOST_MSVC < 1300 #endif // BOOST_MSVC < 1300
// construction from a vector of sub_match id's: // construction from a vector of sub_match state_id's:
inline u32regex_token_iterator<const char*> make_u32regex_token_iterator(const char* p, const u32regex& e, const std::vector<int>& submatch, regex_constants::match_flag_type m = regex_constants::match_default) inline u32regex_token_iterator<const char*> make_u32regex_token_iterator(const char* p, const u32regex& e, const std::vector<int>& submatch, regex_constants::match_flag_type m = regex_constants::match_default)
{ {
return u32regex_token_iterator<const char*>(p, p+std::strlen(p), e, submatch, m); return u32regex_token_iterator<const char*>(p, p+std::strlen(p), e, submatch, m);
@ -344,7 +344,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
#ifndef U_WCHAR_IS_UTF16 #if !defined(U_WCHAR_IS_UTF16) && (U_SIZEOF_WCHAR_T != 2)
inline u32regex_token_iterator<const UChar*> make_u32regex_token_iterator(const UChar* p, const u32regex& e, const std::vector<int>& submatch, 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 std::vector<int>& submatch, regex_constants::match_flag_type m = regex_constants::match_default)
{ {
return u32regex_token_iterator<const UChar*>(p, p+u_strlen(p), e, m); return u32regex_token_iterator<const UChar*>(p, p+u_strlen(p), e, m);

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

@ -76,36 +76,36 @@ BOOST_REGEX_DECL bool BOOST_REGEX_CALL w32_is_lower(char, lcid_type);
#ifndef BOOST_NO_WREGEX #ifndef BOOST_NO_WREGEX
BOOST_REGEX_DECL bool BOOST_REGEX_CALL w32_is_lower(wchar_t, lcid_type); BOOST_REGEX_DECL bool BOOST_REGEX_CALL w32_is_lower(wchar_t, lcid_type);
#ifdef BOOST_REGEX_HAS_OTHER_WCHAR_T #ifdef BOOST_REGEX_HAS_OTHER_WCHAR_T
BOOST_REGEX_DECL bool BOOST_REGEX_CALL w32_is_lower(unsigned short ca, lcid_type id); BOOST_REGEX_DECL bool BOOST_REGEX_CALL w32_is_lower(unsigned short ca, lcid_type state_id);
#endif #endif
#endif #endif
BOOST_REGEX_DECL bool BOOST_REGEX_CALL w32_is_upper(char, lcid_type); BOOST_REGEX_DECL bool BOOST_REGEX_CALL w32_is_upper(char, lcid_type);
#ifndef BOOST_NO_WREGEX #ifndef BOOST_NO_WREGEX
BOOST_REGEX_DECL bool BOOST_REGEX_CALL w32_is_upper(wchar_t, lcid_type); BOOST_REGEX_DECL bool BOOST_REGEX_CALL w32_is_upper(wchar_t, lcid_type);
#ifdef BOOST_REGEX_HAS_OTHER_WCHAR_T #ifdef BOOST_REGEX_HAS_OTHER_WCHAR_T
BOOST_REGEX_DECL bool BOOST_REGEX_CALL w32_is_upper(unsigned short ca, lcid_type id); BOOST_REGEX_DECL bool BOOST_REGEX_CALL w32_is_upper(unsigned short ca, lcid_type state_id);
#endif #endif
#endif #endif
BOOST_REGEX_DECL cat_type BOOST_REGEX_CALL w32_cat_open(const std::string& name); BOOST_REGEX_DECL cat_type BOOST_REGEX_CALL w32_cat_open(const std::string& name);
BOOST_REGEX_DECL std::string BOOST_REGEX_CALL w32_cat_get(const cat_type& cat, lcid_type id, int i, const std::string& def); BOOST_REGEX_DECL std::string BOOST_REGEX_CALL w32_cat_get(const cat_type& cat, lcid_type state_id, int i, const std::string& def);
#ifndef BOOST_NO_WREGEX #ifndef BOOST_NO_WREGEX
BOOST_REGEX_DECL std::wstring BOOST_REGEX_CALL w32_cat_get(const cat_type& cat, lcid_type id, int i, const std::wstring& def); BOOST_REGEX_DECL std::wstring BOOST_REGEX_CALL w32_cat_get(const cat_type& cat, lcid_type state_id, int i, const std::wstring& def);
#ifdef BOOST_REGEX_HAS_OTHER_WCHAR_T #ifdef BOOST_REGEX_HAS_OTHER_WCHAR_T
BOOST_REGEX_DECL std::basic_string<unsigned short> BOOST_REGEX_CALL w32_cat_get(const cat_type& cat, lcid_type, int i, const std::basic_string<unsigned short>& def); BOOST_REGEX_DECL std::basic_string<unsigned short> BOOST_REGEX_CALL w32_cat_get(const cat_type& cat, lcid_type, int i, const std::basic_string<unsigned short>& def);
#endif #endif
#endif #endif
BOOST_REGEX_DECL std::string BOOST_REGEX_CALL w32_transform(lcid_type id, const char* p1, const char* p2); BOOST_REGEX_DECL std::string BOOST_REGEX_CALL w32_transform(lcid_type state_id, const char* p1, const char* p2);
#ifndef BOOST_NO_WREGEX #ifndef BOOST_NO_WREGEX
BOOST_REGEX_DECL std::wstring BOOST_REGEX_CALL w32_transform(lcid_type id, const wchar_t* p1, const wchar_t* p2); BOOST_REGEX_DECL std::wstring BOOST_REGEX_CALL w32_transform(lcid_type state_id, const wchar_t* p1, const wchar_t* p2);
#ifdef BOOST_REGEX_HAS_OTHER_WCHAR_T #ifdef BOOST_REGEX_HAS_OTHER_WCHAR_T
BOOST_REGEX_DECL std::basic_string<unsigned short> BOOST_REGEX_CALL w32_transform(lcid_type id, const unsigned short* p1, const unsigned short* p2); BOOST_REGEX_DECL std::basic_string<unsigned short> BOOST_REGEX_CALL w32_transform(lcid_type state_id, const unsigned short* p1, const unsigned short* p2);
#endif #endif
#endif #endif
BOOST_REGEX_DECL char BOOST_REGEX_CALL w32_tolower(char c, lcid_type); BOOST_REGEX_DECL char BOOST_REGEX_CALL w32_tolower(char c, lcid_type);
#ifndef BOOST_NO_WREGEX #ifndef BOOST_NO_WREGEX
BOOST_REGEX_DECL wchar_t BOOST_REGEX_CALL w32_tolower(wchar_t c, lcid_type); BOOST_REGEX_DECL wchar_t BOOST_REGEX_CALL w32_tolower(wchar_t c, lcid_type);
#ifdef BOOST_REGEX_HAS_OTHER_WCHAR_T #ifdef BOOST_REGEX_HAS_OTHER_WCHAR_T
BOOST_REGEX_DECL unsigned short BOOST_REGEX_CALL w32_tolower(unsigned short c, lcid_type id); BOOST_REGEX_DECL unsigned short BOOST_REGEX_CALL w32_tolower(unsigned short c, lcid_type state_id);
#endif #endif
#endif #endif
BOOST_REGEX_DECL char BOOST_REGEX_CALL w32_toupper(char c, lcid_type); BOOST_REGEX_DECL char BOOST_REGEX_CALL w32_toupper(char c, lcid_type);
@ -116,7 +116,7 @@ BOOST_REGEX_DECL bool BOOST_REGEX_CALL w32_is(lcid_type, boost::uint32_t mask, c
#ifndef BOOST_NO_WREGEX #ifndef BOOST_NO_WREGEX
BOOST_REGEX_DECL bool BOOST_REGEX_CALL w32_is(lcid_type, boost::uint32_t mask, wchar_t c); BOOST_REGEX_DECL bool BOOST_REGEX_CALL w32_is(lcid_type, boost::uint32_t mask, wchar_t c);
#ifdef BOOST_REGEX_HAS_OTHER_WCHAR_T #ifdef BOOST_REGEX_HAS_OTHER_WCHAR_T
BOOST_REGEX_DECL bool BOOST_REGEX_CALL w32_is(lcid_type id, boost::uint32_t m, unsigned short c); BOOST_REGEX_DECL bool BOOST_REGEX_CALL w32_is(lcid_type state_id, boost::uint32_t m, unsigned short c);
#endif #endif
#endif #endif
// //
@ -540,9 +540,9 @@ typename w32_regex_traits_implementation<charT>::char_class_type
if(pos != m_custom_class_names.end()) if(pos != m_custom_class_names.end())
return pos->second; return pos->second;
} }
std::size_t id = 1 + re_detail::get_default_class_id(p1, p2); std::size_t state_id = 1 + re_detail::get_default_class_id(p1, p2);
if(id < sizeof(masks) / sizeof(masks[0])) if(state_id < sizeof(masks) / sizeof(masks[0]))
return masks[id]; return masks[state_id];
return masks[0]; return masks[0];
} }

83
src/usinstances.cpp
View File

@ -18,46 +18,59 @@
#define BOOST_REGEX_SOURCE #define BOOST_REGEX_SOURCE
#include <boost/detail/workaround.hpp>
#include <memory>
#include <string>
#if defined(_DLL_CPPLIB) && !defined(_M_CEE_PURE) \
&& !(defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION) || defined(__STD_RWCOMPILER_H__) || defined(_RWSTD_VER))
//
// This is a horrible workaround, but without declaring these symbols extern we get
// duplicate symbol errors when linking if the application is built without
// /Zc:wchar_t
//
#ifdef _CRTIMP2_PURE
# define BOOST_REGEX_STDLIB_DECL _CRTIMP2_PURE
#else
# define BOOST_REGEX_STDLIB_DECL _CRTIMP2
#endif
namespace std{
#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
template class BOOST_REGEX_STDLIB_DECL allocator<unsigned short>;
template class BOOST_REGEX_STDLIB_DECL _String_val<unsigned short, allocator<unsigned short> >;
template class BOOST_REGEX_STDLIB_DECL basic_string<unsigned short, char_traits<unsigned short>,
allocator<unsigned short> >;
#endif
#if BOOST_WORKAROUND(BOOST_MSVC, > 1300) && BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1400))
template<> BOOST_REGEX_STDLIB_DECL std::size_t __cdecl char_traits<unsigned short>::length(unsigned short const*);
#endif
template BOOST_REGEX_STDLIB_DECL bool __cdecl operator==(
const basic_string<unsigned short, char_traits<unsigned short>, allocator<unsigned short> >&,
const basic_string<unsigned short, char_traits<unsigned short>, allocator<unsigned short> >&);
template BOOST_REGEX_STDLIB_DECL bool __cdecl operator==(
const unsigned short *,
const basic_string<unsigned short, char_traits<unsigned short>, allocator<unsigned short> >&);
template BOOST_REGEX_STDLIB_DECL bool __cdecl operator==(
const basic_string<unsigned short, char_traits<unsigned short>, allocator<unsigned short> >&,
const unsigned short *);
template BOOST_REGEX_STDLIB_DECL bool __cdecl operator<(
const basic_string<unsigned short, char_traits<unsigned short>, allocator<unsigned short> >&,
const basic_string<unsigned short, char_traits<unsigned short>, allocator<unsigned short> >&);
template BOOST_REGEX_STDLIB_DECL bool __cdecl operator>(
const basic_string<unsigned short, char_traits<unsigned short>, allocator<unsigned short> >&,
const basic_string<unsigned short, char_traits<unsigned short>, allocator<unsigned short> >&);
}
#endif
#include <boost/regex/config.hpp> #include <boost/regex/config.hpp>
#if !defined(BOOST_NO_WREGEX) && defined(BOOST_REGEX_HAS_OTHER_WCHAR_T) && !defined(BOOST_REGEX_NO_EXTERNAL_TEMPLATES) #if !defined(BOOST_NO_WREGEX) && defined(BOOST_REGEX_HAS_OTHER_WCHAR_T) && !defined(BOOST_REGEX_NO_EXTERNAL_TEMPLATES)
#define BOOST_REGEX_US_INSTANTIATE #define BOOST_REGEX_US_INSTANTIATE
#ifdef _DLL_CPPLIB
#include <boost/detail/workaround.hpp>
#include <memory>
#include <string>
//
// This is a horrible workaround, without declaring these symbols extern we get
// duplicate symbol errors when linking if the application is built without
// /Zc:wchar_t
//
namespace std{
template _CRTIMP2 bool __cdecl operator==(
const basic_string<unsigned short, char_traits<unsigned short>, allocator<unsigned short> >&,
const basic_string<unsigned short, char_traits<unsigned short>, allocator<unsigned short> >&);
template _CRTIMP2 bool __cdecl operator==(
const unsigned short *,
const basic_string<unsigned short, char_traits<unsigned short>, allocator<unsigned short> >&);
template _CRTIMP2 bool __cdecl operator==(
const basic_string<unsigned short, char_traits<unsigned short>, allocator<unsigned short> >&,
const unsigned short *);
template _CRTIMP2 bool __cdecl operator<(
const basic_string<unsigned short, char_traits<unsigned short>, allocator<unsigned short> >&,
const basic_string<unsigned short, char_traits<unsigned short>, allocator<unsigned short> >&);
template _CRTIMP2 bool __cdecl operator>(
const basic_string<unsigned short, char_traits<unsigned short>, allocator<unsigned short> >&,
const basic_string<unsigned short, char_traits<unsigned short>, allocator<unsigned short> >&);
#if BOOST_WORKAROUND(BOOST_MSVC, > 1300) && BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1400))
template<> _CRTIMP2 std::size_t __cdecl char_traits<unsigned short>::length(unsigned short const*);
#endif
#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
template _CRTIMP2 allocator<unsigned short>::allocator();
#endif
}
#endif
#include <boost/regex.hpp> #include <boost/regex.hpp>
#endif #endif

45
src/wc_regex_traits.cpp
View File

@ -19,42 +19,57 @@
#define BOOST_REGEX_SOURCE #define BOOST_REGEX_SOURCE
#include <boost/regex/config.hpp>
#include <boost/detail/workaround.hpp> #include <boost/detail/workaround.hpp>
#ifdef _DLL_CPPLIB
#include <memory> #include <memory>
#include <string> #include <string>
#if defined(_DLL_CPPLIB) && !defined(_M_CEE_PURE) \
&& !(defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION) || defined(__STD_RWCOMPILER_H__) || defined(_RWSTD_VER))
// //
// This is a horrible workaround, without declaring these symbols extern we get // This is a horrible workaround, but without declaring these symbols extern we get
// duplicate symbol errors when linking if the application is built without // duplicate symbol errors when linking if the application is built without
// /Zc:wchar_t // /Zc:wchar_t
// //
#ifdef _CRTIMP2_PURE
# define BOOST_REGEX_STDLIB_DECL _CRTIMP2_PURE
#else
# define BOOST_REGEX_STDLIB_DECL _CRTIMP2
#endif
namespace std{ namespace std{
template _CRTIMP2 bool __cdecl operator==(
#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
template class BOOST_REGEX_STDLIB_DECL allocator<unsigned short>;
template class BOOST_REGEX_STDLIB_DECL _String_val<unsigned short, allocator<unsigned short> >;
template class BOOST_REGEX_STDLIB_DECL basic_string<unsigned short, char_traits<unsigned short>,
allocator<unsigned short> >;
#endif
#if BOOST_WORKAROUND(BOOST_MSVC, > 1300) && BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1400))
template<> BOOST_REGEX_STDLIB_DECL std::size_t __cdecl char_traits<unsigned short>::length(unsigned short const*);
#endif
template BOOST_REGEX_STDLIB_DECL bool __cdecl operator==(
const basic_string<unsigned short, char_traits<unsigned short>, allocator<unsigned short> >&, const basic_string<unsigned short, char_traits<unsigned short>, allocator<unsigned short> >&,
const basic_string<unsigned short, char_traits<unsigned short>, allocator<unsigned short> >&); const basic_string<unsigned short, char_traits<unsigned short>, allocator<unsigned short> >&);
template _CRTIMP2 bool __cdecl operator==( template BOOST_REGEX_STDLIB_DECL bool __cdecl operator==(
const unsigned short *, const unsigned short *,
const basic_string<unsigned short, char_traits<unsigned short>, allocator<unsigned short> >&); const basic_string<unsigned short, char_traits<unsigned short>, allocator<unsigned short> >&);
template _CRTIMP2 bool __cdecl operator==( template BOOST_REGEX_STDLIB_DECL bool __cdecl operator==(
const basic_string<unsigned short, char_traits<unsigned short>, allocator<unsigned short> >&, const basic_string<unsigned short, char_traits<unsigned short>, allocator<unsigned short> >&,
const unsigned short *); const unsigned short *);
template _CRTIMP2 bool __cdecl operator<( template BOOST_REGEX_STDLIB_DECL bool __cdecl operator<(
const basic_string<unsigned short, char_traits<unsigned short>, allocator<unsigned short> >&, const basic_string<unsigned short, char_traits<unsigned short>, allocator<unsigned short> >&,
const basic_string<unsigned short, char_traits<unsigned short>, allocator<unsigned short> >&); const basic_string<unsigned short, char_traits<unsigned short>, allocator<unsigned short> >&);
template _CRTIMP2 bool __cdecl operator>( template BOOST_REGEX_STDLIB_DECL bool __cdecl operator>(
const basic_string<unsigned short, char_traits<unsigned short>, allocator<unsigned short> >&, const basic_string<unsigned short, char_traits<unsigned short>, allocator<unsigned short> >&,
const basic_string<unsigned short, char_traits<unsigned short>, allocator<unsigned short> >&); const basic_string<unsigned short, char_traits<unsigned short>, allocator<unsigned short> >&);
#if BOOST_WORKAROUND(BOOST_MSVC, > 1300) && BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1400))
template<> _CRTIMP2 std::size_t __cdecl char_traits<unsigned short>::length(unsigned short const*);
#endif
#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
template _CRTIMP2 allocator<unsigned short>::allocator();
#endif
} }
#endif #endif
#include <boost/regex/config.hpp>
#include <boost/detail/workaround.hpp>
#if !BOOST_WORKAROUND(__BORLANDC__, < 0x560) #if !BOOST_WORKAROUND(__BORLANDC__, < 0x560)
#include <boost/regex/v4/c_regex_traits.hpp> #include <boost/regex/v4/c_regex_traits.hpp>

3
test/pathology/bad_expression_test.cpp
View File

@ -46,7 +46,7 @@ int test_main( int , char* [] )
bad_text.assign((std::string::size_type)500000, 'a'); bad_text.assign((std::string::size_type)500000, 'a');
e2.assign("aaa*@"); e2.assign("aaa*@");
BOOST_CHECK_THROW(0 == boost::regex_search(bad_text, what, e2), std::runtime_error); BOOST_CHECK_THROW(boost::regex_search(bad_text, what, e2), std::runtime_error);
good_text.assign((std::string::size_type)5000, 'a'); good_text.assign((std::string::size_type)5000, 'a');
BOOST_CHECK(0 == boost::regex_search(good_text, what, e2)); BOOST_CHECK(0 == boost::regex_search(good_text, what, e2));
@ -54,3 +54,4 @@ int test_main( int , char* [] )
} }
#include <boost/test/included/test_exec_monitor.hpp> #include <boost/test/included/test_exec_monitor.hpp>

3
test/regress/test_tricky_cases.cpp
View File

@ -377,6 +377,9 @@ void test_tricky_cases3()
TEST_REGEX_SEARCH("(?:\\d{9}.*){2}", perl, "123456789dfsdfsdfsfsdfds123456789b", match_default, make_array(0, 34, -2, -2)); TEST_REGEX_SEARCH("(?:\\d{9}.*){2}", perl, "123456789dfsdfsdfsfsdfds123456789b", match_default, make_array(0, 34, -2, -2));
TEST_REGEX_SEARCH("(?:\\d{9}.*){2}", perl, "123456789dfsdfsdfsfsdfds12345678", match_default, make_array(-2, -2)); TEST_REGEX_SEARCH("(?:\\d{9}.*){2}", perl, "123456789dfsdfsdfsfsdfds12345678", match_default, make_array(-2, -2));
TEST_REGEX_SEARCH("(?:\\d{9}.*){2}", perl, "123456789dfsdfsdfsfsdfds", match_default, make_array(-2, -2)); TEST_REGEX_SEARCH("(?:\\d{9}.*){2}", perl, "123456789dfsdfsdfsfsdfds", match_default, make_array(-2, -2));
TEST_REGEX_SEARCH("^(25[0-5]|2[0-4][0-9]|[0-1]?[0-9]?[0-9])(\\.(25[0-5]|2[0-4][0-9]|[0-1]?[0-9]?[0-9])){3}$", perl, "1.2.03", match_default, make_array(-2, -2));
TEST_REGEX_SEARCH("^(25[0-5]|2[0-4][0-9]|[0-1]?[0-9]?[0-9])(\\.(25[0-5]|2[0-4][0-9]|[0-1]?[0-9]?[0-9])){3,4}$", perl, "1.2.03", match_default, make_array(-2, -2));
TEST_REGEX_SEARCH("^(25[0-5]|2[0-4][0-9]|[0-1]?[0-9]?[0-9])(\\.(25[0-5]|2[0-4][0-9]|[0-1]?[0-9]?[0-9])){3,4}?$", perl, "1.2.03", match_default, make_array(-2, -2));
// //