Boost logo

Boost-Commit :

Subject: [Boost-commit] svn:boost r48751 - trunk/boost/regex/v4
From: john_at_[hidden]
Date: 2008-09-12 08:40:24


Author: johnmaddock
Date: 2008-09-12 08:40:23 EDT (Fri, 12 Sep 2008)
New Revision: 48751
URL: http://svn.boost.org/trac/boost/changeset/48751

Log:
Fixes #2306.
Change "id" to "state_id".
Text files modified:
   trunk/boost/regex/v4/basic_regex_creator.hpp | 18 +++++++++---------
   trunk/boost/regex/v4/cpp_regex_traits.hpp | 6 +++---
   trunk/boost/regex/v4/perl_matcher.hpp | 14 +++++++-------
   trunk/boost/regex/v4/perl_matcher_non_recursive.hpp | 18 +++++++++---------
   trunk/boost/regex/v4/perl_matcher_recursive.hpp | 2 +-
   trunk/boost/regex/v4/regex_traits_defaults.hpp | 4 ++--
   trunk/boost/regex/v4/states.hpp | 2 +-
   trunk/boost/regex/v4/u32regex_token_iterator.hpp | 4 ++--
   trunk/boost/regex/v4/w32_regex_traits.hpp | 24 ++++++++++++------------
   9 files changed, 46 insertions(+), 46 deletions(-)

Modified: trunk/boost/regex/v4/basic_regex_creator.hpp
==============================================================================
--- trunk/boost/regex/v4/basic_regex_creator.hpp (original)
+++ trunk/boost/regex/v4/basic_regex_creator.hpp 2008-09-12 08:40:23 EDT (Fri, 12 Sep 2008)
@@ -236,7 +236,7 @@
                                  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 @@
       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 @@
    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 @@
    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;

Modified: trunk/boost/regex/v4/cpp_regex_traits.hpp
==============================================================================
--- trunk/boost/regex/v4/cpp_regex_traits.hpp (original)
+++ trunk/boost/regex/v4/cpp_regex_traits.hpp 2008-09-12 08:40:23 EDT (Fri, 12 Sep 2008)
@@ -799,9 +799,9 @@
       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

Modified: trunk/boost/regex/v4/perl_matcher.hpp
==============================================================================
--- trunk/boost/regex/v4/perl_matcher.hpp (original)
+++ trunk/boost/regex/v4/perl_matcher.hpp 2008-09-12 08:40:23 EDT (Fri, 12 Sep 2008)
@@ -248,7 +248,7 @@
 {
    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 @@
    {
       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 @@
       *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 @@
    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);
 
 

Modified: trunk/boost/regex/v4/perl_matcher_non_recursive.hpp
==============================================================================
--- trunk/boost/regex/v4/perl_matcher_non_recursive.hpp (original)
+++ trunk/boost/regex/v4/perl_matcher_non_recursive.hpp 2008-09-12 08:40:23 EDT (Fri, 12 Sep 2008)
@@ -50,13 +50,13 @@
 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 @@
 }
 
 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 @@
       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 @@
       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 @@
    //
    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);
    //

Modified: trunk/boost/regex/v4/perl_matcher_recursive.hpp
==============================================================================
--- trunk/boost/regex/v4/perl_matcher_recursive.hpp (original)
+++ trunk/boost/regex/v4/perl_matcher_recursive.hpp 2008-09-12 08:40:23 EDT (Fri, 12 Sep 2008)
@@ -291,7 +291,7 @@
    // 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

Modified: trunk/boost/regex/v4/regex_traits_defaults.hpp
==============================================================================
--- trunk/boost/regex/v4/regex_traits_defaults.hpp (original)
+++ trunk/boost/regex/v4/regex_traits_defaults.hpp 2008-09-12 08:40:23 EDT (Fri, 12 Sep 2008)
@@ -134,8 +134,8 @@
 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

Modified: trunk/boost/regex/v4/states.hpp
==============================================================================
--- trunk/boost/regex/v4/states.hpp (original)
+++ trunk/boost/regex/v4/states.hpp 2008-09-12 08:40:23 EDT (Fri, 12 Sep 2008)
@@ -240,7 +240,7 @@
 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
 };

Modified: trunk/boost/regex/v4/u32regex_token_iterator.hpp
==============================================================================
--- trunk/boost/regex/v4/u32regex_token_iterator.hpp (original)
+++ trunk/boost/regex/v4/u32regex_token_iterator.hpp 2008-09-12 08:40:23 EDT (Fri, 12 Sep 2008)
@@ -271,7 +271,7 @@
 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 @@
 }
 #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);

Modified: trunk/boost/regex/v4/w32_regex_traits.hpp
==============================================================================
--- trunk/boost/regex/v4/w32_regex_traits.hpp (original)
+++ trunk/boost/regex/v4/w32_regex_traits.hpp 2008-09-12 08:40:23 EDT (Fri, 12 Sep 2008)
@@ -76,36 +76,36 @@
 #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 @@
 #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 @@
       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];
 }
 


Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk