Ticket #2269: regex.patch

basic_regex.hpp

@@ -148 +148 @@
    {
       return this->m_mark_count;
    }
+   std::pair<const_iterator, const_iterator> BOOST_REGEX_CALL get_mark(size_type index)const
+   {
+                std::pair<const_iterator, const_iterator> mark(0,0) ;
+                ptrdiff_t position = this->m_expression_len ;
+
+                if(!mark_count() && index < mark_count())
+                        return mark ;
+
+                mark.first = mark.second = this->m_expression ;
+
+                if(index == 0)
+                {
+                        while(position--) mark.second++ ; // We seek after the last
+                        return mark ;
+                }
+
+                ::boost::re_detail::re_syntax_base const *      state = get_first_state() ;
+                ::boost::re_detail::re_brace const *            state_brace = 0 ;
+
+                do
+                {
+                        if(state->type != ::boost::re_detail::syntax_element_startmark
+                                        && state->type != ::boost::re_detail::syntax_element_endmark)
+                                continue ;
+
+                        state_brace = static_cast<re_brace const *>(state) ;
+                        if(state_brace->index != (int) index)
+                                continue ;
+
+                        ptrdiff_t position = state_brace->position ;
+                        if(state_brace->type == ::boost::re_detail::syntax_element_startmark)
+                                while(--position) mark.first++ ; // We seek on '('
+                        else if(state_brace->type == ::boost::re_detail::syntax_element_endmark)
+                        {
+                                while(position--) mark.second++ ; // We seek after ')'
+                                state = 0 ;
+                                break ;
+                        }
+
+                } while((state = state->next.p)) ;
+
+           return mark ;
+   }
+
    const re_detail::re_syntax_base* get_first_state()const
    {
       return this->m_first_state;
@@ -405 +449 @@
       return (m_pimpl.get() ? m_pimpl->mark_count() : 0); 
    }
 
+   std::pair<const_iterator, const_iterator> BOOST_REGEX_CALL get_mark(size_type index)const
+   {
+      return (m_pimpl.get() ? m_pimpl->get_mark(index) : std::pair<const_iterator, const_iterator>(0,0)); 
+   }
+
    int status()const
    {
       return (m_pimpl.get() ? m_pimpl->status() : regex_constants::error_empty);

basic_regex_parser.hpp

@@ -371 +371 @@
       markid = ++m_mark_count;
    re_brace* pb = static_cast<re_brace*>(this->append_state(syntax_element_startmark, sizeof(re_brace)));
    pb->index = markid;
+   pb->position = ::boost::re_detail::distance(m_base, m_position) ;
    std::ptrdiff_t last_paren_start = this->getoffset(pb);
    // back up insertion point for alternations, and set new point:
    std::ptrdiff_t last_alt_point = m_alt_insert_point;
@@ -421 +422 @@
    //
    pb = static_cast<re_brace*>(this->append_state(syntax_element_endmark, sizeof(re_brace)));
    pb->index = markid;
+   pb->position = ::boost::re_detail::distance(m_base, m_position) ;
    this->m_paren_start = last_paren_start;
    //
    // restore the alternate insertion point:
@@ -1549 +1551 @@
       m_position = pc;
       re_brace* pb = static_cast<re_brace*>(this->append_state(syntax_element_backref, sizeof(re_brace)));
       pb->index = i;
+      pb->position = ::boost::re_detail::distance(m_base, m_position) ;
    }
    else
    {
@@ -1786 +1789 @@
       // make a note of whether we have a case change:
       m_has_case_change = ((opts & regbase::icase) != (this->flags() & regbase::icase));
       pb->index = markid = 0;
+      pb->position = ::boost::re_detail::distance(m_base, m_position) ;
       if(this->m_traits.syntax_type(*m_position) == regex_constants::syntax_close_mark)
       {
          // update flags and carry on as normal:
@@ -1896 +1900 @@
    //
    pb = static_cast<re_brace*>(this->append_state(syntax_element_endmark, sizeof(re_brace)));
    pb->index = markid;
+   pb->position = ::boost::re_detail::distance(m_base, m_position) ;
    this->m_paren_start = last_paren_start;
    //
    // restore the alternate insertion point:

states.hpp

@@ -156 +156 @@
    // The index to match, can be zero (don't mark the sub-expression)
    // or negative (for perl style (?...) extentions):
    int index;
+   std::ptrdiff_t position ;
 };
 
 /*** struct re_dot **************************************************