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

Fixes #2306.

Browse Source 
Change "id" to "state_id".

[SVN r48751]
This commit is contained in:
John Maddock
2008-09-12 12:40:23 +00:00
parent 18623d00af
commit d70f98e658
9 changed files with 46 additions and 46 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -236,7 +236,7 @@ protected:
m_traits; // convenience reference to traits class
re_syntax_base* m_last_state; // the last state we added
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
unsigned m_backrefs; // bitmask of permitted backrefs
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_short_set_rep:
case syntax_element_long_set_rep:
// set the id of this repeat:
static_cast<re_repeat*>(state)->id = m_repeater_id++;
// set the state_id of this repeat:
static_cast<re_repeat*>(state)->state_id = m_repeater_id++;
// fall through:
case syntax_element_alt:
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_long_set_rep:
{
unsigned id = static_cast<re_repeat*>(pt)->id;
if(id > sizeof(m_bad_repeats) * CHAR_BIT)
unsigned state_id = static_cast<re_repeat*>(pt)->state_id;
if(state_id > sizeof(m_bad_repeats) * CHAR_BIT)
return true; // run out of bits, assume we can't traverse this one.
static const boost::uintmax_t one = 1uL;
return m_bad_repeats & (one << id);
return m_bad_repeats & (one << state_id);
}
default:
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_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;
if(id <= sizeof(m_bad_repeats) * CHAR_BIT)
m_bad_repeats |= (one << id);
if(state_id <= sizeof(m_bad_repeats) * CHAR_BIT)
m_bad_repeats |= (one << state_id);
}
default:
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())
return pos->second;
}
std::size_t id = 1 + re_detail::get_default_class_id(p1, p2);
BOOST_ASSERT(id < sizeof(masks) / sizeof(masks[0]));
return masks[id];
std::size_t state_id = 1 + re_detail::get_default_class_id(p1, p2);
BOOST_ASSERT(state_id < sizeof(masks) / sizeof(masks[0]));
return masks[state_id];
}
#ifdef BOOST_REGEX_BUGGY_CTYPE_FACET

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

@ -248,7 +248,7 @@ class repeater_count
{
repeater_count** stack;
repeater_count* next;
int id;
int state_id;
std::size_t count; // the number of iterations so far
BidiIterator start_pos; // where the last repeat started
public:
@ -256,22 +256,22 @@ public:
{
stack = s;
next = 0;
id = -1;
state_id = -1;
count = 0;
}
repeater_count(int i, repeater_count** s, BidiIterator start)
: start_pos(start)
{
id = i;
state_id = i;
stack = s;
next = *stack;
*stack = this;
if(id > next->id)
if(state_id > next->state_id)
count = 0;
else
{
repeater_count* p = next;
while(p->id != id)
while(p->state_id != state_id)
p = p->next;
count = p->count;
start_pos = p->start_pos;
@ -282,7 +282,7 @@ public:
*stack = next;
}
std::size_t get_count() { return count; }
int get_id() { return id; }
int get_id() { return state_id; }
std::size_t operator++() { return ++count; }
bool check_null_repeat(const BidiIterator& pos, std::size_t max)
{
@ -487,7 +487,7 @@ private:
void push_assertion(const re_syntax_base* ps, bool positive);
void push_alt(const re_syntax_base* ps);
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);

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

@ -50,13 +50,13 @@ inline void inplace_destroy(T* p)
struct saved_state
{
union{
unsigned int id;
unsigned int state_id;
// this padding ensures correct alignment on 64-bit platforms:
std::size_t padding1;
std::ptrdiff_t padding2;
void* padding3;
};
saved_state(unsigned i) : id(i) {}
saved_state(unsigned i) : state_id(i) {}
};
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>
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);
--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;
}
(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;
}
@ -477,13 +477,13 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_rep()
take_second = can_start(*position, rep->_map, (unsigned char)mask_skip);
}
if((m_backup_state->id != saved_state_repeater_count)
|| (static_cast<saved_repeater<BidiIterator>*>(m_backup_state)->count.get_id() != rep->id)
|| (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
// 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
@ -884,7 +884,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::unwind(bool have_match)
//
do
{
unwinder = s_unwind_table[m_backup_state->id];
unwinder = s_unwind_table[m_backup_state->state_id];
cont = (this->*unwinder)(m_recursive_result);
}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
// 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
// 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);
//
// get the id of a character clasification, the individual
// traits classes then transform that id into a bitmask:
// get the state_id of a character clasification, the individual
// traits classes then transform that state_id into a bitmask:
//
template <class charT>
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
{
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 greedy; // True if this is a greedy repeat
};

4
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 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)
{
return u32regex_token_iterator<const char*>(p, p+std::strlen(p), e, submatch, m);
@ -333,7 +333,7 @@ inline u32regex_token_iterator<const UChar*> make_u32regex_token_iterator(const
}
#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)
{
return u32regex_token_iterator<const char*>(p, p+std::strlen(p), e, submatch, 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
BOOST_REGEX_DECL bool BOOST_REGEX_CALL w32_is_lower(wchar_t, lcid_type);
#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
BOOST_REGEX_DECL bool BOOST_REGEX_CALL w32_is_upper(char, lcid_type);
#ifndef BOOST_NO_WREGEX
BOOST_REGEX_DECL bool BOOST_REGEX_CALL w32_is_upper(wchar_t, lcid_type);
#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
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
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
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
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
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
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
BOOST_REGEX_DECL char BOOST_REGEX_CALL w32_tolower(char c, lcid_type);
#ifndef BOOST_NO_WREGEX
BOOST_REGEX_DECL wchar_t BOOST_REGEX_CALL w32_tolower(wchar_t c, lcid_type);
#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
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
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
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
//
@ -540,9 +540,9 @@ typename w32_regex_traits_implementation<charT>::char_class_type
if(pos != m_custom_class_names.end())
return pos->second;
}
std::size_t id = 1 + re_detail::get_default_class_id(p1, p2);
if(id < sizeof(masks) / sizeof(masks[0]))
return masks[id];
std::size_t state_id = 1 + re_detail::get_default_class_id(p1, p2);
if(state_id < sizeof(masks) / sizeof(masks[0]))
return masks[state_id];
return masks[0];
}