Chris@16: /*
Chris@16:  *
Chris@16:  * Copyright (c) 2002
Chris@16:  * John Maddock
Chris@16:  *
Chris@16:  * Use, modification and distribution are subject to the 
Chris@16:  * Boost Software License, Version 1.0. (See accompanying file 
Chris@16:  * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
Chris@16:  *
Chris@16:  */
Chris@16: 
Chris@16:  /*
Chris@16:   *   LOCATION:    see http://www.boost.org for most recent version.
Chris@16:   *   FILE         perl_matcher_common.cpp
Chris@16:   *   VERSION      see <boost/version.hpp>
Chris@16:   *   DESCRIPTION: Definitions of perl_matcher member functions that are 
Chris@16:   *                specific to the non-recursive implementation.
Chris@16:   */
Chris@16: 
Chris@16: #ifndef BOOST_REGEX_V4_PERL_MATCHER_NON_RECURSIVE_HPP
Chris@16: #define BOOST_REGEX_V4_PERL_MATCHER_NON_RECURSIVE_HPP
Chris@16: 
Chris@16: #include <new>
Chris@16: 
Chris@16: #ifdef BOOST_MSVC
Chris@16: #pragma warning(push)
Chris@16: #pragma warning(disable: 4103)
Chris@16: #endif
Chris@16: #ifdef BOOST_HAS_ABI_HEADERS
Chris@16: #  include BOOST_ABI_PREFIX
Chris@16: #endif
Chris@16: #ifdef BOOST_MSVC
Chris@16: #pragma warning(pop)
Chris@16: #endif
Chris@16: #ifdef BOOST_MSVC
Chris@16: #  pragma warning(push)
Chris@16: #  pragma warning(disable: 4800)
Chris@16: #endif
Chris@16: 
Chris@16: namespace boost{
Chris@16: namespace re_detail{
Chris@16: 
Chris@16: template <class T>
Chris@16: inline void inplace_destroy(T* p)
Chris@16: {
Chris@16:    (void)p;  // warning suppression
Chris@16:    p->~T();
Chris@16: }
Chris@16: 
Chris@16: struct saved_state
Chris@16: {
Chris@16:    union{
Chris@16:       unsigned int state_id;
Chris@16:       // this padding ensures correct alignment on 64-bit platforms:
Chris@16:       std::size_t padding1;
Chris@16:       std::ptrdiff_t padding2;
Chris@16:       void* padding3;
Chris@16:    };
Chris@16:    saved_state(unsigned i) : state_id(i) {}
Chris@16: };
Chris@16: 
Chris@16: template <class BidiIterator>
Chris@16: struct saved_matched_paren : public saved_state
Chris@16: {
Chris@16:    int index;
Chris@16:    sub_match<BidiIterator> sub;
Chris@16:    saved_matched_paren(int i, const sub_match<BidiIterator>& s) : saved_state(1), index(i), sub(s){};
Chris@16: };
Chris@16: 
Chris@16: template <class BidiIterator>
Chris@16: struct saved_position : public saved_state
Chris@16: {
Chris@16:    const re_syntax_base* pstate;
Chris@16:    BidiIterator position;
Chris@16:    saved_position(const re_syntax_base* ps, BidiIterator pos, int i) : saved_state(i), pstate(ps), position(pos){};
Chris@16: };
Chris@16: 
Chris@16: template <class BidiIterator>
Chris@16: struct saved_assertion : public saved_position<BidiIterator>
Chris@16: {
Chris@16:    bool positive;
Chris@16:    saved_assertion(bool p, const re_syntax_base* ps, BidiIterator pos) 
Chris@16:       : saved_position<BidiIterator>(ps, pos, saved_type_assertion), positive(p){};
Chris@16: };
Chris@16: 
Chris@16: template <class BidiIterator>
Chris@16: struct saved_repeater : public saved_state
Chris@16: {
Chris@16:    repeater_count<BidiIterator> count;
Chris@16:    saved_repeater(int i, repeater_count<BidiIterator>** s, BidiIterator start) 
Chris@16:       : saved_state(saved_state_repeater_count), count(i,s,start){}
Chris@16: };
Chris@16: 
Chris@16: struct saved_extra_block : public saved_state
Chris@16: {
Chris@16:    saved_state *base, *end;
Chris@16:    saved_extra_block(saved_state* b, saved_state* e) 
Chris@16:       : saved_state(saved_state_extra_block), base(b), end(e) {}
Chris@16: };
Chris@16: 
Chris@16: struct save_state_init
Chris@16: {
Chris@16:    saved_state** stack;
Chris@16:    save_state_init(saved_state** base, saved_state** end)
Chris@16:       : stack(base)
Chris@16:    {
Chris@16:       *base = static_cast<saved_state*>(get_mem_block());
Chris@16:       *end = reinterpret_cast<saved_state*>(reinterpret_cast<char*>(*base)+BOOST_REGEX_BLOCKSIZE);
Chris@16:       --(*end);
Chris@16:       (void) new (*end)saved_state(0);
Chris@16:       BOOST_ASSERT(*end > *base);
Chris@16:    }
Chris@16:    ~save_state_init()
Chris@16:    {
Chris@16:       put_mem_block(*stack);
Chris@16:       *stack = 0;
Chris@16:    }
Chris@16: };
Chris@16: 
Chris@16: template <class BidiIterator>
Chris@16: struct saved_single_repeat : public saved_state
Chris@16: {
Chris@16:    std::size_t count;
Chris@16:    const re_repeat* rep;
Chris@16:    BidiIterator last_position;
Chris@16:    saved_single_repeat(std::size_t c, const re_repeat* r, BidiIterator lp, int arg_id) 
Chris@16:       : saved_state(arg_id), count(c), rep(r), last_position(lp){}
Chris@16: };
Chris@16: 
Chris@16: template <class Results>
Chris@16: struct saved_recursion : public saved_state
Chris@16: {
Chris@16:    saved_recursion(int idx, const re_syntax_base* p, Results* pr) 
Chris@16:       : saved_state(14), recursion_id(idx), preturn_address(p), results(*pr)
Chris@16:    {}
Chris@16:    int recursion_id;
Chris@16:    const re_syntax_base* preturn_address;
Chris@16:    Results results;
Chris@16: };
Chris@16: 
Chris@16: template <class BidiIterator, class Allocator, class traits>
Chris@16: bool perl_matcher<BidiIterator, Allocator, traits>::match_all_states()
Chris@16: {
Chris@16:    static matcher_proc_type const s_match_vtable[30] = 
Chris@16:    {
Chris@16:       (&perl_matcher<BidiIterator, Allocator, traits>::match_startmark),
Chris@16:       &perl_matcher<BidiIterator, Allocator, traits>::match_endmark,
Chris@16:       &perl_matcher<BidiIterator, Allocator, traits>::match_literal,
Chris@16:       &perl_matcher<BidiIterator, Allocator, traits>::match_start_line,
Chris@16:       &perl_matcher<BidiIterator, Allocator, traits>::match_end_line,
Chris@16:       &perl_matcher<BidiIterator, Allocator, traits>::match_wild,
Chris@16:       &perl_matcher<BidiIterator, Allocator, traits>::match_match,
Chris@16:       &perl_matcher<BidiIterator, Allocator, traits>::match_word_boundary,
Chris@16:       &perl_matcher<BidiIterator, Allocator, traits>::match_within_word,
Chris@16:       &perl_matcher<BidiIterator, Allocator, traits>::match_word_start,
Chris@16:       &perl_matcher<BidiIterator, Allocator, traits>::match_word_end,
Chris@16:       &perl_matcher<BidiIterator, Allocator, traits>::match_buffer_start,
Chris@16:       &perl_matcher<BidiIterator, Allocator, traits>::match_buffer_end,
Chris@16:       &perl_matcher<BidiIterator, Allocator, traits>::match_backref,
Chris@16:       &perl_matcher<BidiIterator, Allocator, traits>::match_long_set,
Chris@16:       &perl_matcher<BidiIterator, Allocator, traits>::match_set,
Chris@16:       &perl_matcher<BidiIterator, Allocator, traits>::match_jump,
Chris@16:       &perl_matcher<BidiIterator, Allocator, traits>::match_alt,
Chris@16:       &perl_matcher<BidiIterator, Allocator, traits>::match_rep,
Chris@16:       &perl_matcher<BidiIterator, Allocator, traits>::match_combining,
Chris@16:       &perl_matcher<BidiIterator, Allocator, traits>::match_soft_buffer_end,
Chris@16:       &perl_matcher<BidiIterator, Allocator, traits>::match_restart_continue,
Chris@16:       // Although this next line *should* be evaluated at compile time, in practice
Chris@16:       // some compilers (VC++) emit run-time initialisation which breaks thread
Chris@16:       // safety, so use a dispatch function instead:
Chris@16:       //(::boost::is_random_access_iterator<BidiIterator>::value ? &perl_matcher<BidiIterator, Allocator, traits>::match_dot_repeat_fast : &perl_matcher<BidiIterator, Allocator, traits>::match_dot_repeat_slow),
Chris@16:       &perl_matcher<BidiIterator, Allocator, traits>::match_dot_repeat_dispatch,
Chris@16:       &perl_matcher<BidiIterator, Allocator, traits>::match_char_repeat,
Chris@16:       &perl_matcher<BidiIterator, Allocator, traits>::match_set_repeat,
Chris@16:       &perl_matcher<BidiIterator, Allocator, traits>::match_long_set_repeat,
Chris@16:       &perl_matcher<BidiIterator, Allocator, traits>::match_backstep,
Chris@16:       &perl_matcher<BidiIterator, Allocator, traits>::match_assert_backref,
Chris@16:       &perl_matcher<BidiIterator, Allocator, traits>::match_toggle_case,
Chris@16:       &perl_matcher<BidiIterator, Allocator, traits>::match_recursion,
Chris@16:    };
Chris@16: 
Chris@16:    push_recursion_stopper();
Chris@16:    do{
Chris@16:       while(pstate)
Chris@16:       {
Chris@16:          matcher_proc_type proc = s_match_vtable[pstate->type];
Chris@16:          ++state_count;
Chris@16:          if(!(this->*proc)())
Chris@16:          {
Chris@16:             if(state_count > max_state_count)
Chris@16:                raise_error(traits_inst, regex_constants::error_complexity);
Chris@16:             if((m_match_flags & match_partial) && (position == last) && (position != search_base))
Chris@16:                m_has_partial_match = true;
Chris@16:             bool successful_unwind = unwind(false);
Chris@16:             if((m_match_flags & match_partial) && (position == last) && (position != search_base))
Chris@16:                m_has_partial_match = true;
Chris@16:             if(false == successful_unwind)
Chris@16:                return m_recursive_result;
Chris@16:          }
Chris@16:       }
Chris@16:    }while(unwind(true));
Chris@16:    return m_recursive_result;
Chris@16: }
Chris@16: 
Chris@16: template <class BidiIterator, class Allocator, class traits>
Chris@16: void perl_matcher<BidiIterator, Allocator, traits>::extend_stack()
Chris@16: {
Chris@16:    if(used_block_count)
Chris@16:    {
Chris@16:       --used_block_count;
Chris@16:       saved_state* stack_base;
Chris@16:       saved_state* backup_state;
Chris@16:       stack_base = static_cast<saved_state*>(get_mem_block());
Chris@16:       backup_state = reinterpret_cast<saved_state*>(reinterpret_cast<char*>(stack_base)+BOOST_REGEX_BLOCKSIZE);
Chris@16:       saved_extra_block* block = static_cast<saved_extra_block*>(backup_state);
Chris@16:       --block;
Chris@16:       (void) new (block) saved_extra_block(m_stack_base, m_backup_state);
Chris@16:       m_stack_base = stack_base;
Chris@16:       m_backup_state = block;
Chris@16:    }
Chris@16:    else
Chris@16:       raise_error(traits_inst, regex_constants::error_stack);
Chris@16: }
Chris@16: 
Chris@16: template <class BidiIterator, class Allocator, class traits>
Chris@16: inline void perl_matcher<BidiIterator, Allocator, traits>::push_matched_paren(int index, const sub_match<BidiIterator>& sub)
Chris@16: {
Chris@16:    //BOOST_ASSERT(index);
Chris@16:    saved_matched_paren<BidiIterator>* pmp = static_cast<saved_matched_paren<BidiIterator>*>(m_backup_state);
Chris@16:    --pmp;
Chris@16:    if(pmp < m_stack_base)
Chris@16:    {
Chris@16:       extend_stack();
Chris@16:       pmp = static_cast<saved_matched_paren<BidiIterator>*>(m_backup_state);
Chris@16:       --pmp;
Chris@16:    }
Chris@16:    (void) new (pmp)saved_matched_paren<BidiIterator>(index, sub);
Chris@16:    m_backup_state = pmp;
Chris@16: }
Chris@16: 
Chris@16: template <class BidiIterator, class Allocator, class traits>
Chris@16: inline void perl_matcher<BidiIterator, Allocator, traits>::push_recursion_stopper()
Chris@16: {
Chris@16:    saved_state* pmp = m_backup_state;
Chris@16:    --pmp;
Chris@16:    if(pmp < m_stack_base)
Chris@16:    {
Chris@16:       extend_stack();
Chris@16:       pmp = m_backup_state;
Chris@16:       --pmp;
Chris@16:    }
Chris@16:    (void) new (pmp)saved_state(saved_type_recurse);
Chris@16:    m_backup_state = pmp;
Chris@16: }
Chris@16: 
Chris@16: template <class BidiIterator, class Allocator, class traits>
Chris@16: inline void perl_matcher<BidiIterator, Allocator, traits>::push_assertion(const re_syntax_base* ps, bool positive)
Chris@16: {
Chris@16:    saved_assertion<BidiIterator>* pmp = static_cast<saved_assertion<BidiIterator>*>(m_backup_state);
Chris@16:    --pmp;
Chris@16:    if(pmp < m_stack_base)
Chris@16:    {
Chris@16:       extend_stack();
Chris@16:       pmp = static_cast<saved_assertion<BidiIterator>*>(m_backup_state);
Chris@16:       --pmp;
Chris@16:    }
Chris@16:    (void) new (pmp)saved_assertion<BidiIterator>(positive, ps, position);
Chris@16:    m_backup_state = pmp;
Chris@16: }
Chris@16: 
Chris@16: template <class BidiIterator, class Allocator, class traits>
Chris@16: inline void perl_matcher<BidiIterator, Allocator, traits>::push_alt(const re_syntax_base* ps)
Chris@16: {
Chris@16:    saved_position<BidiIterator>* pmp = static_cast<saved_position<BidiIterator>*>(m_backup_state);
Chris@16:    --pmp;
Chris@16:    if(pmp < m_stack_base)
Chris@16:    {
Chris@16:       extend_stack();
Chris@16:       pmp = static_cast<saved_position<BidiIterator>*>(m_backup_state);
Chris@16:       --pmp;
Chris@16:    }
Chris@16:    (void) new (pmp)saved_position<BidiIterator>(ps, position, saved_state_alt);
Chris@16:    m_backup_state = pmp;
Chris@16: }
Chris@16: 
Chris@16: template <class BidiIterator, class Allocator, class traits>
Chris@16: inline void perl_matcher<BidiIterator, Allocator, traits>::push_non_greedy_repeat(const re_syntax_base* ps)
Chris@16: {
Chris@16:    saved_position<BidiIterator>* pmp = static_cast<saved_position<BidiIterator>*>(m_backup_state);
Chris@16:    --pmp;
Chris@16:    if(pmp < m_stack_base)
Chris@16:    {
Chris@16:       extend_stack();
Chris@16:       pmp = static_cast<saved_position<BidiIterator>*>(m_backup_state);
Chris@16:       --pmp;
Chris@16:    }
Chris@16:    (void) new (pmp)saved_position<BidiIterator>(ps, position, saved_state_non_greedy_long_repeat);
Chris@16:    m_backup_state = pmp;
Chris@16: }
Chris@16: 
Chris@16: template <class BidiIterator, class Allocator, class traits>
Chris@16: inline void perl_matcher<BidiIterator, Allocator, traits>::push_repeater_count(int i, repeater_count<BidiIterator>** s)
Chris@16: {
Chris@16:    saved_repeater<BidiIterator>* pmp = static_cast<saved_repeater<BidiIterator>*>(m_backup_state);
Chris@16:    --pmp;
Chris@16:    if(pmp < m_stack_base)
Chris@16:    {
Chris@16:       extend_stack();
Chris@16:       pmp = static_cast<saved_repeater<BidiIterator>*>(m_backup_state);
Chris@16:       --pmp;
Chris@16:    }
Chris@16:    (void) new (pmp)saved_repeater<BidiIterator>(i, s, position);
Chris@16:    m_backup_state = pmp;
Chris@16: }
Chris@16: 
Chris@16: template <class BidiIterator, class Allocator, class traits>
Chris@16: inline void perl_matcher<BidiIterator, Allocator, traits>::push_single_repeat(std::size_t c, const re_repeat* r, BidiIterator last_position, int state_id)
Chris@16: {
Chris@16:    saved_single_repeat<BidiIterator>* pmp = static_cast<saved_single_repeat<BidiIterator>*>(m_backup_state);
Chris@16:    --pmp;
Chris@16:    if(pmp < m_stack_base)
Chris@16:    {
Chris@16:       extend_stack();
Chris@16:       pmp = static_cast<saved_single_repeat<BidiIterator>*>(m_backup_state);
Chris@16:       --pmp;
Chris@16:    }
Chris@16:    (void) new (pmp)saved_single_repeat<BidiIterator>(c, r, last_position, state_id);
Chris@16:    m_backup_state = pmp;
Chris@16: }
Chris@16: 
Chris@16: template <class BidiIterator, class Allocator, class traits>
Chris@16: inline void perl_matcher<BidiIterator, Allocator, traits>::push_recursion(int idx, const re_syntax_base* p, results_type* presults)
Chris@16: {
Chris@16:    saved_recursion<results_type>* pmp = static_cast<saved_recursion<results_type>*>(m_backup_state);
Chris@16:    --pmp;
Chris@16:    if(pmp < m_stack_base)
Chris@16:    {
Chris@16:       extend_stack();
Chris@16:       pmp = static_cast<saved_recursion<results_type>*>(m_backup_state);
Chris@16:       --pmp;
Chris@16:    }
Chris@16:    (void) new (pmp)saved_recursion<results_type>(idx, p, presults);
Chris@16:    m_backup_state = pmp;
Chris@16: }
Chris@16: 
Chris@16: template <class BidiIterator, class Allocator, class traits>
Chris@16: bool perl_matcher<BidiIterator, Allocator, traits>::match_startmark()
Chris@16: {
Chris@16:    int index = static_cast<const re_brace*>(pstate)->index;
Chris@16:    icase = static_cast<const re_brace*>(pstate)->icase;
Chris@16:    switch(index)
Chris@16:    {
Chris@16:    case 0:
Chris@16:       pstate = pstate->next.p;
Chris@16:       break;
Chris@16:    case -1:
Chris@16:    case -2:
Chris@16:       {
Chris@16:          // forward lookahead assert:
Chris@16:          const re_syntax_base* next_pstate = static_cast<const re_jump*>(pstate->next.p)->alt.p->next.p;
Chris@16:          pstate = pstate->next.p->next.p;
Chris@16:          push_assertion(next_pstate, index == -1);
Chris@16:          break;
Chris@16:       }
Chris@16:    case -3:
Chris@16:       {
Chris@16:          // independent sub-expression, currently this is always recursive:
Chris@16:          bool old_independent = m_independent;
Chris@16:          m_independent = true;
Chris@16:          const re_syntax_base* next_pstate = static_cast<const re_jump*>(pstate->next.p)->alt.p->next.p;
Chris@16:          pstate = pstate->next.p->next.p;
Chris@16:          bool r = match_all_states();
Chris@16:          pstate = next_pstate;
Chris@16:          m_independent = old_independent;
Chris@16: #ifdef BOOST_REGEX_MATCH_EXTRA
Chris@16:          if(r && (m_match_flags & match_extra))
Chris@16:          {
Chris@16:             //
Chris@16:             // our captures have been stored in *m_presult
Chris@16:             // we need to unpack them, and insert them
Chris@16:             // back in the right order when we unwind the stack:
Chris@16:             //
Chris@16:             match_results<BidiIterator, Allocator> temp_match(*m_presult);
Chris@16:             unsigned i;
Chris@16:             for(i = 0; i < temp_match.size(); ++i)
Chris@16:                (*m_presult)[i].get_captures().clear();
Chris@16:             // match everything else:
Chris@16:             r = match_all_states();
Chris@16:             // now place the stored captures back:
Chris@16:             for(i = 0; i < temp_match.size(); ++i)
Chris@16:             {
Chris@16:                typedef typename sub_match<BidiIterator>::capture_sequence_type seq;
Chris@16:                seq& s1 = (*m_presult)[i].get_captures();
Chris@16:                const seq& s2 = temp_match[i].captures();
Chris@16:                s1.insert(
Chris@16:                   s1.end(), 
Chris@16:                   s2.begin(), 
Chris@16:                   s2.end());
Chris@16:             }
Chris@16:          }
Chris@16: #endif
Chris@16:          return r;
Chris@16:       }
Chris@16:    case -4:
Chris@16:       {
Chris@16:       // conditional expression:
Chris@16:       const re_alt* alt = static_cast<const re_alt*>(pstate->next.p);
Chris@16:       BOOST_ASSERT(alt->type == syntax_element_alt);
Chris@16:       pstate = alt->next.p;
Chris@16:       if(pstate->type == syntax_element_assert_backref)
Chris@16:       {
Chris@16:          if(!match_assert_backref())
Chris@16:             pstate = alt->alt.p;
Chris@16:          break;
Chris@16:       }
Chris@16:       else
Chris@16:       {
Chris@16:          // zero width assertion, have to match this recursively:
Chris@16:          BOOST_ASSERT(pstate->type == syntax_element_startmark);
Chris@16:          bool negated = static_cast<const re_brace*>(pstate)->index == -2;
Chris@16:          BidiIterator saved_position = position;
Chris@16:          const re_syntax_base* next_pstate = static_cast<const re_jump*>(pstate->next.p)->alt.p->next.p;
Chris@16:          pstate = pstate->next.p->next.p;
Chris@16:          bool r = match_all_states();
Chris@16:          position = saved_position;
Chris@16:          if(negated)
Chris@16:             r = !r;
Chris@16:          if(r)
Chris@16:             pstate = next_pstate;
Chris@16:          else
Chris@16:             pstate = alt->alt.p;
Chris@16:          break;
Chris@16:       }
Chris@16:       }
Chris@16:    case -5:
Chris@16:       {
Chris@16:          push_matched_paren(0, (*m_presult)[0]);
Chris@16:          m_presult->set_first(position, 0, true);
Chris@16:          pstate = pstate->next.p;
Chris@16:          break;
Chris@16:       }
Chris@16:    default:
Chris@16:    {
Chris@16:       BOOST_ASSERT(index > 0);
Chris@16:       if((m_match_flags & match_nosubs) == 0)
Chris@16:       {
Chris@16:          push_matched_paren(index, (*m_presult)[index]);
Chris@16:          m_presult->set_first(position, index);
Chris@16:       }
Chris@16:       pstate = pstate->next.p;
Chris@16:       break;
Chris@16:    }
Chris@16:    }
Chris@16:    return true;
Chris@16: }
Chris@16: 
Chris@16: template <class BidiIterator, class Allocator, class traits>
Chris@16: bool perl_matcher<BidiIterator, Allocator, traits>::match_alt()
Chris@16: {
Chris@16:    bool take_first, take_second;
Chris@16:    const re_alt* jmp = static_cast<const re_alt*>(pstate);
Chris@16: 
Chris@16:    // find out which of these two alternatives we need to take:
Chris@16:    if(position == last)
Chris@16:    {
Chris@16:       take_first = jmp->can_be_null & mask_take;
Chris@16:       take_second = jmp->can_be_null & mask_skip;
Chris@16:    }
Chris@16:    else
Chris@16:    {
Chris@16:       take_first = can_start(*position, jmp->_map, (unsigned char)mask_take);
Chris@16:       take_second = can_start(*position, jmp->_map, (unsigned char)mask_skip);
Chris@16:   }
Chris@16: 
Chris@16:    if(take_first)
Chris@16:    {
Chris@16:       // we can take the first alternative,
Chris@16:       // see if we need to push next alternative:
Chris@16:       if(take_second)
Chris@16:       {
Chris@16:          push_alt(jmp->alt.p);
Chris@16:       }
Chris@16:       pstate = pstate->next.p;
Chris@16:       return true;
Chris@16:    }
Chris@16:    if(take_second)
Chris@16:    {
Chris@16:       pstate = jmp->alt.p;
Chris@16:       return true;
Chris@16:    }
Chris@16:    return false;  // neither option is possible
Chris@16: }
Chris@16: 
Chris@16: template <class BidiIterator, class Allocator, class traits>
Chris@16: bool perl_matcher<BidiIterator, Allocator, traits>::match_rep()
Chris@16: {
Chris@16: #ifdef BOOST_MSVC
Chris@16: #pragma warning(push)
Chris@16: #pragma warning(disable:4127 4244)
Chris@16: #endif
Chris@16: #ifdef __BORLANDC__
Chris@16: #pragma option push -w-8008 -w-8066 -w-8004
Chris@16: #endif
Chris@16:    const re_repeat* rep = static_cast<const re_repeat*>(pstate);
Chris@16: 
Chris@16:    // find out which of these two alternatives we need to take:
Chris@16:    bool take_first, take_second;
Chris@16:    if(position == last)
Chris@16:    {
Chris@16:       take_first = rep->can_be_null & mask_take;
Chris@16:       take_second = rep->can_be_null & mask_skip;
Chris@16:    }
Chris@16:    else
Chris@16:    {
Chris@16:       take_first = can_start(*position, rep->_map, (unsigned char)mask_take);
Chris@16:       take_second = can_start(*position, rep->_map, (unsigned char)mask_skip);
Chris@16:    }
Chris@16: 
Chris@16:    if((m_backup_state->state_id != saved_state_repeater_count) 
Chris@16:       || (static_cast<saved_repeater<BidiIterator>*>(m_backup_state)->count.get_id() != rep->state_id)
Chris@16:       || (next_count->get_id() != rep->state_id))
Chris@16:    {
Chris@16:       // we're moving to a different repeat from the last
Chris@16:       // one, so set up a counter object:
Chris@16:       push_repeater_count(rep->state_id, &next_count);
Chris@16:    }
Chris@16:    //
Chris@16:    // If we've had at least one repeat already, and the last one 
Chris@16:    // matched the NULL string then set the repeat count to
Chris@16:    // maximum:
Chris@16:    //
Chris@16:    next_count->check_null_repeat(position, rep->max);
Chris@16: 
Chris@16:    if(next_count->get_count() < rep->min)
Chris@16:    {
Chris@16:       // we must take the repeat:
Chris@16:       if(take_first)
Chris@16:       {
Chris@16:          // increase the counter:
Chris@16:          ++(*next_count);
Chris@16:          pstate = rep->next.p;
Chris@16:          return true;
Chris@16:       }
Chris@16:       return false;
Chris@16:    }
Chris@16: 
Chris@16:    bool greedy = (rep->greedy) && (!(m_match_flags & regex_constants::match_any) || m_independent);   
Chris@16:    if(greedy)
Chris@16:    {
Chris@16:       // try and take the repeat if we can:
Chris@16:       if((next_count->get_count() < rep->max) && take_first)
Chris@16:       {
Chris@16:          if(take_second)
Chris@16:          {
Chris@16:             // store position in case we fail:
Chris@16:             push_alt(rep->alt.p);
Chris@16:          }
Chris@16:          // increase the counter:
Chris@16:          ++(*next_count);
Chris@16:          pstate = rep->next.p;
Chris@16:          return true;
Chris@16:       }
Chris@16:       else if(take_second)
Chris@16:       {
Chris@16:          pstate = rep->alt.p;
Chris@16:          return true;
Chris@16:       }
Chris@16:       return false; // can't take anything, fail...
Chris@16:    }
Chris@16:    else // non-greedy
Chris@16:    {
Chris@16:       // try and skip the repeat if we can:
Chris@16:       if(take_second)
Chris@16:       {
Chris@16:          if((next_count->get_count() < rep->max) && take_first)
Chris@16:          {
Chris@16:             // store position in case we fail:
Chris@16:             push_non_greedy_repeat(rep->next.p);
Chris@16:          }
Chris@16:          pstate = rep->alt.p;
Chris@16:          return true;
Chris@16:       }
Chris@16:       if((next_count->get_count() < rep->max) && take_first)
Chris@16:       {
Chris@16:          // increase the counter:
Chris@16:          ++(*next_count);
Chris@16:          pstate = rep->next.p;
Chris@16:          return true;
Chris@16:       }
Chris@16:    }
Chris@16:    return false;
Chris@16: #ifdef __BORLANDC__
Chris@16: #pragma option pop
Chris@16: #endif
Chris@16: #ifdef BOOST_MSVC
Chris@16: #pragma warning(pop)
Chris@16: #endif
Chris@16: }
Chris@16: 
Chris@16: template <class BidiIterator, class Allocator, class traits>
Chris@16: bool perl_matcher<BidiIterator, Allocator, traits>::match_dot_repeat_slow()
Chris@16: {
Chris@16:    unsigned count = 0;
Chris@16:    const re_repeat* rep = static_cast<const re_repeat*>(pstate);
Chris@16:    re_syntax_base* psingle = rep->next.p;
Chris@16:    // match compulsary repeats first:
Chris@16:    while(count < rep->min)
Chris@16:    {
Chris@16:       pstate = psingle;
Chris@16:       if(!match_wild())
Chris@16:          return false;
Chris@16:       ++count;
Chris@16:    }
Chris@16:    bool greedy = (rep->greedy) && (!(m_match_flags & regex_constants::match_any) || m_independent);   
Chris@16:    if(greedy)
Chris@16:    {
Chris@16:       // repeat for as long as we can:
Chris@16:       while(count < rep->max)
Chris@16:       {
Chris@16:          pstate = psingle;
Chris@16:          if(!match_wild())
Chris@16:             break;
Chris@16:          ++count;
Chris@16:       }
Chris@16:       // remember where we got to if this is a leading repeat:
Chris@16:       if((rep->leading) && (count < rep->max))
Chris@16:          restart = position;
Chris@16:       // push backtrack info if available:
Chris@16:       if(count - rep->min)
Chris@16:          push_single_repeat(count, rep, position, saved_state_greedy_single_repeat);
Chris@16:       // jump to next state:
Chris@16:       pstate = rep->alt.p;
Chris@16:       return true;
Chris@16:    }
Chris@16:    else
Chris@16:    {
Chris@16:       // non-greedy, push state and return true if we can skip:
Chris@16:       if(count < rep->max)
Chris@16:          push_single_repeat(count, rep, position, saved_state_rep_slow_dot);
Chris@16:       pstate = rep->alt.p;
Chris@16:       return (position == last) ? (rep->can_be_null & mask_skip) : can_start(*position, rep->_map, mask_skip);
Chris@16:    }
Chris@16: }
Chris@16: 
Chris@16: template <class BidiIterator, class Allocator, class traits>
Chris@16: bool perl_matcher<BidiIterator, Allocator, traits>::match_dot_repeat_fast()
Chris@16: {
Chris@16:    if(m_match_flags & match_not_dot_null)
Chris@16:       return match_dot_repeat_slow();
Chris@16:    if((static_cast<const re_dot*>(pstate->next.p)->mask & match_any_mask) == 0)
Chris@16:       return match_dot_repeat_slow();
Chris@16: 
Chris@16:    const re_repeat* rep = static_cast<const re_repeat*>(pstate);
Chris@16:    bool greedy = (rep->greedy) && (!(m_match_flags & regex_constants::match_any) || m_independent);   
Chris@16:    unsigned count = static_cast<unsigned>((std::min)(static_cast<unsigned>(::boost::re_detail::distance(position, last)), static_cast<unsigned>(greedy ? rep->max : rep->min)));
Chris@16:    if(rep->min > count)
Chris@16:    {
Chris@16:       position = last;
Chris@16:       return false;  // not enough text left to match
Chris@16:    }
Chris@16:    std::advance(position, count);
Chris@16: 
Chris@16:    if(greedy)
Chris@16:    {
Chris@16:       if((rep->leading) && (count < rep->max))
Chris@16:          restart = position;
Chris@16:       // push backtrack info if available:
Chris@16:       if(count - rep->min)
Chris@16:          push_single_repeat(count, rep, position, saved_state_greedy_single_repeat);
Chris@16:       // jump to next state:
Chris@16:       pstate = rep->alt.p;
Chris@16:       return true;
Chris@16:    }
Chris@16:    else
Chris@16:    {
Chris@16:       // non-greedy, push state and return true if we can skip:
Chris@16:       if(count < rep->max)
Chris@16:          push_single_repeat(count, rep, position, saved_state_rep_fast_dot);
Chris@16:       pstate = rep->alt.p;
Chris@16:       return (position == last) ? (rep->can_be_null & mask_skip) : can_start(*position, rep->_map, mask_skip);
Chris@16:    }
Chris@16: }
Chris@16: 
Chris@16: template <class BidiIterator, class Allocator, class traits>
Chris@16: bool perl_matcher<BidiIterator, Allocator, traits>::match_char_repeat()
Chris@16: {
Chris@16: #ifdef BOOST_MSVC
Chris@16: #pragma warning(push)
Chris@16: #pragma warning(disable:4127)
Chris@16: #endif
Chris@16: #ifdef __BORLANDC__
Chris@16: #pragma option push -w-8008 -w-8066 -w-8004
Chris@16: #endif
Chris@16:    const re_repeat* rep = static_cast<const re_repeat*>(pstate);
Chris@16:    BOOST_ASSERT(1 == static_cast<const re_literal*>(rep->next.p)->length);
Chris@16:    const char_type what = *reinterpret_cast<const char_type*>(static_cast<const re_literal*>(rep->next.p) + 1);
Chris@16:    std::size_t count = 0;
Chris@16:    //
Chris@16:    // start by working out how much we can skip:
Chris@16:    //
Chris@16:    bool greedy = (rep->greedy) && (!(m_match_flags & regex_constants::match_any) || m_independent);   
Chris@16:    std::size_t desired = greedy ? rep->max : rep->min;
Chris@16:    if(::boost::is_random_access_iterator<BidiIterator>::value)
Chris@16:    {
Chris@16:       BidiIterator end = position;
Chris@16:       // Move end forward by "desired", preferably without using distance or advance if we can
Chris@16:       // as these can be slow for some iterator types.
Chris@16:       std::size_t len = (desired == (std::numeric_limits<std::size_t>::max)()) ? 0u : ::boost::re_detail::distance(position, last);
Chris@16:       if(desired >= len)
Chris@16:          end = last;
Chris@16:       else
Chris@16:          std::advance(end, desired);
Chris@16:       BidiIterator origin(position);
Chris@16:       while((position != end) && (traits_inst.translate(*position, icase) == what))
Chris@16:       {
Chris@16:          ++position;
Chris@16:       }
Chris@16:       count = (unsigned)::boost::re_detail::distance(origin, position);
Chris@16:    }
Chris@16:    else
Chris@16:    {
Chris@16:       while((count < desired) && (position != last) && (traits_inst.translate(*position, icase) == what))
Chris@16:       {
Chris@16:          ++position;
Chris@16:          ++count;
Chris@16:       }
Chris@16:    }
Chris@16: 
Chris@16:    if(count < rep->min)
Chris@16:       return false;
Chris@16: 
Chris@16:    if(greedy)
Chris@16:    {
Chris@16:       if((rep->leading) && (count < rep->max))
Chris@16:          restart = position;
Chris@16:       // push backtrack info if available:
Chris@16:       if(count - rep->min)
Chris@16:          push_single_repeat(count, rep, position, saved_state_greedy_single_repeat);
Chris@16:       // jump to next state:
Chris@16:       pstate = rep->alt.p;
Chris@16:       return true;
Chris@16:    }
Chris@16:    else
Chris@16:    {
Chris@16:       // non-greedy, push state and return true if we can skip:
Chris@16:       if(count < rep->max)
Chris@16:          push_single_repeat(count, rep, position, saved_state_rep_char);
Chris@16:       pstate = rep->alt.p;
Chris@16:       return (position == last) ? (rep->can_be_null & mask_skip) : can_start(*position, rep->_map, mask_skip);
Chris@16:    }
Chris@16: #ifdef __BORLANDC__
Chris@16: #pragma option pop
Chris@16: #endif
Chris@16: #ifdef BOOST_MSVC
Chris@16: #pragma warning(pop)
Chris@16: #endif
Chris@16: }
Chris@16: 
Chris@16: template <class BidiIterator, class Allocator, class traits>
Chris@16: bool perl_matcher<BidiIterator, Allocator, traits>::match_set_repeat()
Chris@16: {
Chris@16: #ifdef BOOST_MSVC
Chris@16: #pragma warning(push)
Chris@16: #pragma warning(disable:4127)
Chris@16: #endif
Chris@16: #ifdef __BORLANDC__
Chris@16: #pragma option push -w-8008 -w-8066 -w-8004
Chris@16: #endif
Chris@16:    const re_repeat* rep = static_cast<const re_repeat*>(pstate);
Chris@16:    const unsigned char* map = static_cast<const re_set*>(rep->next.p)->_map;
Chris@16:    std::size_t count = 0;
Chris@16:    //
Chris@16:    // start by working out how much we can skip:
Chris@16:    //
Chris@16:    bool greedy = (rep->greedy) && (!(m_match_flags & regex_constants::match_any) || m_independent);   
Chris@16:    std::size_t desired = greedy ? rep->max : rep->min;
Chris@16:    if(::boost::is_random_access_iterator<BidiIterator>::value)
Chris@16:    {
Chris@16:       BidiIterator end = position;
Chris@16:       // Move end forward by "desired", preferably without using distance or advance if we can
Chris@16:       // as these can be slow for some iterator types.
Chris@16:       std::size_t len = (desired == (std::numeric_limits<std::size_t>::max)()) ? 0u : ::boost::re_detail::distance(position, last);
Chris@16:       if(desired >= len)
Chris@16:          end = last;
Chris@16:       else
Chris@16:          std::advance(end, desired);
Chris@16:       BidiIterator origin(position);
Chris@16:       while((position != end) && map[static_cast<unsigned char>(traits_inst.translate(*position, icase))])
Chris@16:       {
Chris@16:          ++position;
Chris@16:       }
Chris@16:       count = (unsigned)::boost::re_detail::distance(origin, position);
Chris@16:    }
Chris@16:    else
Chris@16:    {
Chris@16:       while((count < desired) && (position != last) && map[static_cast<unsigned char>(traits_inst.translate(*position, icase))])
Chris@16:       {
Chris@16:          ++position;
Chris@16:          ++count;
Chris@16:       }
Chris@16:    }
Chris@16: 
Chris@16:    if(count < rep->min)
Chris@16:       return false;
Chris@16: 
Chris@16:    if(greedy)
Chris@16:    {
Chris@16:       if((rep->leading) && (count < rep->max))
Chris@16:          restart = position;
Chris@16:       // push backtrack info if available:
Chris@16:       if(count - rep->min)
Chris@16:          push_single_repeat(count, rep, position, saved_state_greedy_single_repeat);
Chris@16:       // jump to next state:
Chris@16:       pstate = rep->alt.p;
Chris@16:       return true;
Chris@16:    }
Chris@16:    else
Chris@16:    {
Chris@16:       // non-greedy, push state and return true if we can skip:
Chris@16:       if(count < rep->max)
Chris@16:          push_single_repeat(count, rep, position, saved_state_rep_short_set);
Chris@16:       pstate = rep->alt.p;
Chris@16:       return (position == last) ? (rep->can_be_null & mask_skip) : can_start(*position, rep->_map, mask_skip);
Chris@16:    }
Chris@16: #ifdef __BORLANDC__
Chris@16: #pragma option pop
Chris@16: #endif
Chris@16: #ifdef BOOST_MSVC
Chris@16: #pragma warning(pop)
Chris@16: #endif
Chris@16: }
Chris@16: 
Chris@16: template <class BidiIterator, class Allocator, class traits>
Chris@16: bool perl_matcher<BidiIterator, Allocator, traits>::match_long_set_repeat()
Chris@16: {
Chris@16: #ifdef BOOST_MSVC
Chris@16: #pragma warning(push)
Chris@16: #pragma warning(disable:4127)
Chris@16: #endif
Chris@16: #ifdef __BORLANDC__
Chris@16: #pragma option push -w-8008 -w-8066 -w-8004
Chris@16: #endif
Chris@16:    typedef typename traits::char_class_type m_type;
Chris@16:    const re_repeat* rep = static_cast<const re_repeat*>(pstate);
Chris@16:    const re_set_long<m_type>* set = static_cast<const re_set_long<m_type>*>(pstate->next.p);
Chris@16:    std::size_t count = 0;
Chris@16:    //
Chris@16:    // start by working out how much we can skip:
Chris@16:    //
Chris@16:    bool greedy = (rep->greedy) && (!(m_match_flags & regex_constants::match_any) || m_independent);   
Chris@16:    std::size_t desired = greedy ? rep->max : rep->min;
Chris@16:    if(::boost::is_random_access_iterator<BidiIterator>::value)
Chris@16:    {
Chris@16:       BidiIterator end = position;
Chris@16:       // Move end forward by "desired", preferably without using distance or advance if we can
Chris@16:       // as these can be slow for some iterator types.
Chris@16:       std::size_t len = (desired == (std::numeric_limits<std::size_t>::max)()) ? 0u : ::boost::re_detail::distance(position, last);
Chris@16:       if(desired >= len)
Chris@16:          end = last;
Chris@16:       else
Chris@16:          std::advance(end, desired);
Chris@16:       BidiIterator origin(position);
Chris@16:       while((position != end) && (position != re_is_set_member(position, last, set, re.get_data(), icase)))
Chris@16:       {
Chris@16:          ++position;
Chris@16:       }
Chris@16:       count = (unsigned)::boost::re_detail::distance(origin, position);
Chris@16:    }
Chris@16:    else
Chris@16:    {
Chris@16:       while((count < desired) && (position != last) && (position != re_is_set_member(position, last, set, re.get_data(), icase)))
Chris@16:       {
Chris@16:          ++position;
Chris@16:          ++count;
Chris@16:       }
Chris@16:    }
Chris@16: 
Chris@16:    if(count < rep->min)
Chris@16:       return false;
Chris@16: 
Chris@16:    if(greedy)
Chris@16:    {
Chris@16:       if((rep->leading) && (count < rep->max))
Chris@16:          restart = position;
Chris@16:       // push backtrack info if available:
Chris@16:       if(count - rep->min)
Chris@16:          push_single_repeat(count, rep, position, saved_state_greedy_single_repeat);
Chris@16:       // jump to next state:
Chris@16:       pstate = rep->alt.p;
Chris@16:       return true;
Chris@16:    }
Chris@16:    else
Chris@16:    {
Chris@16:       // non-greedy, push state and return true if we can skip:
Chris@16:       if(count < rep->max)
Chris@16:          push_single_repeat(count, rep, position, saved_state_rep_long_set);
Chris@16:       pstate = rep->alt.p;
Chris@16:       return (position == last) ? (rep->can_be_null & mask_skip) : can_start(*position, rep->_map, mask_skip);
Chris@16:    }
Chris@16: #ifdef __BORLANDC__
Chris@16: #pragma option pop
Chris@16: #endif
Chris@16: #ifdef BOOST_MSVC
Chris@16: #pragma warning(pop)
Chris@16: #endif
Chris@16: }
Chris@16: 
Chris@16: template <class BidiIterator, class Allocator, class traits>
Chris@16: bool perl_matcher<BidiIterator, Allocator, traits>::match_recursion()
Chris@16: {
Chris@16:    BOOST_ASSERT(pstate->type == syntax_element_recurse);
Chris@16:    //
Chris@16:    // Backup call stack:
Chris@16:    //
Chris@16:    push_recursion_pop();
Chris@16:    //
Chris@16:    // Set new call stack:
Chris@16:    //
Chris@16:    if(recursion_stack.capacity() == 0)
Chris@16:    {
Chris@16:       recursion_stack.reserve(50);
Chris@16:    }
Chris@16:    recursion_stack.push_back(recursion_info<results_type>());
Chris@16:    recursion_stack.back().preturn_address = pstate->next.p;
Chris@16:    recursion_stack.back().results = *m_presult;
Chris@16:    if(static_cast<const re_recurse*>(pstate)->state_id > 0)
Chris@16:    {
Chris@16:       push_repeater_count(static_cast<const re_recurse*>(pstate)->state_id, &next_count);
Chris@16:    }
Chris@16:    pstate = static_cast<const re_jump*>(pstate)->alt.p;
Chris@16:    recursion_stack.back().idx = static_cast<const re_brace*>(pstate)->index;
Chris@16: 
Chris@16:    return true;
Chris@16: }
Chris@16: 
Chris@16: template <class BidiIterator, class Allocator, class traits>
Chris@16: bool perl_matcher<BidiIterator, Allocator, traits>::match_endmark()
Chris@16: {
Chris@16:    int index = static_cast<const re_brace*>(pstate)->index;
Chris@16:    icase = static_cast<const re_brace*>(pstate)->icase;
Chris@16:    if(index > 0)
Chris@16:    {
Chris@16:       if((m_match_flags & match_nosubs) == 0)
Chris@16:       {
Chris@16:          m_presult->set_second(position, index);
Chris@16:       }
Chris@16:       if(!recursion_stack.empty())
Chris@16:       {
Chris@16:          if(index == recursion_stack.back().idx)
Chris@16:          {
Chris@16:             pstate = recursion_stack.back().preturn_address;
Chris@16:             *m_presult = recursion_stack.back().results;
Chris@16:             push_recursion(recursion_stack.back().idx, recursion_stack.back().preturn_address, &recursion_stack.back().results);
Chris@16:             recursion_stack.pop_back();
Chris@16:          }
Chris@16:       }
Chris@16:    }
Chris@16:    else if((index < 0) && (index != -4))
Chris@16:    {
Chris@16:       // matched forward lookahead:
Chris@16:       pstate = 0;
Chris@16:       return true;
Chris@16:    }
Chris@16:    pstate = pstate->next.p;
Chris@16:    return true;
Chris@16: }
Chris@16: 
Chris@16: template <class BidiIterator, class Allocator, class traits>
Chris@16: bool perl_matcher<BidiIterator, Allocator, traits>::match_match()
Chris@16: {
Chris@16:    if(!recursion_stack.empty())
Chris@16:    {
Chris@16:       BOOST_ASSERT(0 == recursion_stack.back().idx);
Chris@16:       pstate = recursion_stack.back().preturn_address;
Chris@16:       *m_presult = recursion_stack.back().results;
Chris@16:       push_recursion(recursion_stack.back().idx, recursion_stack.back().preturn_address, &recursion_stack.back().results);
Chris@16:       recursion_stack.pop_back();
Chris@16:       return true;
Chris@16:    }
Chris@16:    if((m_match_flags & match_not_null) && (position == (*m_presult)[0].first))
Chris@16:       return false;
Chris@16:    if((m_match_flags & match_all) && (position != last))
Chris@16:       return false;
Chris@16:    if((m_match_flags & regex_constants::match_not_initial_null) && (position == search_base))
Chris@16:       return false;
Chris@16:    m_presult->set_second(position);
Chris@16:    pstate = 0;
Chris@16:    m_has_found_match = true;
Chris@16:    if((m_match_flags & match_posix) == match_posix)
Chris@16:    {
Chris@16:       m_result.maybe_assign(*m_presult);
Chris@16:       if((m_match_flags & match_any) == 0)
Chris@16:          return false;
Chris@16:    }
Chris@16: #ifdef BOOST_REGEX_MATCH_EXTRA
Chris@16:    if(match_extra & m_match_flags)
Chris@16:    {
Chris@16:       for(unsigned i = 0; i < m_presult->size(); ++i)
Chris@16:          if((*m_presult)[i].matched)
Chris@16:             ((*m_presult)[i]).get_captures().push_back((*m_presult)[i]);
Chris@16:    }
Chris@16: #endif
Chris@16:    return true;
Chris@16: }
Chris@16: 
Chris@16: /****************************************************************************
Chris@16: 
Chris@16: Unwind and associated proceedures follow, these perform what normal stack
Chris@16: unwinding does in the recursive implementation.
Chris@16: 
Chris@16: ****************************************************************************/
Chris@16: 
Chris@16: template <class BidiIterator, class Allocator, class traits>
Chris@16: bool perl_matcher<BidiIterator, Allocator, traits>::unwind(bool have_match)
Chris@16: {
Chris@16:    static unwind_proc_type const s_unwind_table[18] = 
Chris@16:    {
Chris@16:       &perl_matcher<BidiIterator, Allocator, traits>::unwind_end,
Chris@16:       &perl_matcher<BidiIterator, Allocator, traits>::unwind_paren,
Chris@16:       &perl_matcher<BidiIterator, Allocator, traits>::unwind_recursion_stopper,
Chris@16:       &perl_matcher<BidiIterator, Allocator, traits>::unwind_assertion,
Chris@16:       &perl_matcher<BidiIterator, Allocator, traits>::unwind_alt,
Chris@16:       &perl_matcher<BidiIterator, Allocator, traits>::unwind_repeater_counter,
Chris@16:       &perl_matcher<BidiIterator, Allocator, traits>::unwind_extra_block,
Chris@16:       &perl_matcher<BidiIterator, Allocator, traits>::unwind_greedy_single_repeat,
Chris@16:       &perl_matcher<BidiIterator, Allocator, traits>::unwind_slow_dot_repeat,
Chris@16:       &perl_matcher<BidiIterator, Allocator, traits>::unwind_fast_dot_repeat,
Chris@16:       &perl_matcher<BidiIterator, Allocator, traits>::unwind_char_repeat,
Chris@16:       &perl_matcher<BidiIterator, Allocator, traits>::unwind_short_set_repeat,
Chris@16:       &perl_matcher<BidiIterator, Allocator, traits>::unwind_long_set_repeat,
Chris@16:       &perl_matcher<BidiIterator, Allocator, traits>::unwind_non_greedy_repeat,
Chris@16:       &perl_matcher<BidiIterator, Allocator, traits>::unwind_recursion,
Chris@16:       &perl_matcher<BidiIterator, Allocator, traits>::unwind_recursion_pop,
Chris@16:    };
Chris@16: 
Chris@16:    m_recursive_result = have_match;
Chris@16:    unwind_proc_type unwinder;
Chris@16:    bool cont;
Chris@16:    //
Chris@16:    // keep unwinding our stack until we have something to do:
Chris@16:    //
Chris@16:    do
Chris@16:    {
Chris@16:       unwinder = s_unwind_table[m_backup_state->state_id];
Chris@16:       cont = (this->*unwinder)(m_recursive_result);
Chris@16:    }while(cont);
Chris@16:    //
Chris@16:    // return true if we have more states to try:
Chris@16:    //
Chris@16:    return pstate ? true : false;
Chris@16: }
Chris@16: 
Chris@16: template <class BidiIterator, class Allocator, class traits>
Chris@16: bool perl_matcher<BidiIterator, Allocator, traits>::unwind_end(bool)
Chris@16: {
Chris@16:    pstate = 0;   // nothing left to search
Chris@16:    return false; // end of stack nothing more to search
Chris@16: }
Chris@16: 
Chris@16: template <class BidiIterator, class Allocator, class traits>
Chris@16: bool perl_matcher<BidiIterator, Allocator, traits>::unwind_paren(bool have_match)
Chris@16: {
Chris@16:    saved_matched_paren<BidiIterator>* pmp = static_cast<saved_matched_paren<BidiIterator>*>(m_backup_state);
Chris@16:    // restore previous values if no match was found:
Chris@16:    if(have_match == false)
Chris@16:    {
Chris@16:       m_presult->set_first(pmp->sub.first, pmp->index, pmp->index == 0);
Chris@16:       m_presult->set_second(pmp->sub.second, pmp->index, pmp->sub.matched, pmp->index == 0);
Chris@16:    }
Chris@16: #ifdef BOOST_REGEX_MATCH_EXTRA
Chris@16:    //
Chris@16:    // we have a match, push the capture information onto the stack:
Chris@16:    //
Chris@16:    else if(pmp->sub.matched && (match_extra & m_match_flags))
Chris@16:       ((*m_presult)[pmp->index]).get_captures().push_back(pmp->sub);
Chris@16: #endif
Chris@16:    // unwind stack:
Chris@16:    m_backup_state = pmp+1;
Chris@16:    boost::re_detail::inplace_destroy(pmp);
Chris@16:    return true; // keep looking
Chris@16: }
Chris@16: 
Chris@16: template <class BidiIterator, class Allocator, class traits>
Chris@16: bool perl_matcher<BidiIterator, Allocator, traits>::unwind_recursion_stopper(bool)
Chris@16: {
Chris@16:    boost::re_detail::inplace_destroy(m_backup_state++);
Chris@16:    pstate = 0;   // nothing left to search
Chris@16:    return false; // end of stack nothing more to search
Chris@16: }
Chris@16: 
Chris@16: template <class BidiIterator, class Allocator, class traits>
Chris@16: bool perl_matcher<BidiIterator, Allocator, traits>::unwind_assertion(bool r)
Chris@16: {
Chris@16:    saved_assertion<BidiIterator>* pmp = static_cast<saved_assertion<BidiIterator>*>(m_backup_state);
Chris@16:    pstate = pmp->pstate;
Chris@16:    position = pmp->position;
Chris@16:    bool result = (r == pmp->positive);
Chris@16:    m_recursive_result = pmp->positive ? r : !r;
Chris@16:    boost::re_detail::inplace_destroy(pmp++);
Chris@16:    m_backup_state = pmp;
Chris@16:    return !result; // return false if the assertion was matched to stop search.
Chris@16: }
Chris@16: 
Chris@16: template <class BidiIterator, class Allocator, class traits>
Chris@16: bool perl_matcher<BidiIterator, Allocator, traits>::unwind_alt(bool r)
Chris@16: {
Chris@16:    saved_position<BidiIterator>* pmp = static_cast<saved_position<BidiIterator>*>(m_backup_state);
Chris@16:    if(!r)
Chris@16:    {
Chris@16:       pstate = pmp->pstate;
Chris@16:       position = pmp->position;
Chris@16:    }
Chris@16:    boost::re_detail::inplace_destroy(pmp++);
Chris@16:    m_backup_state = pmp;
Chris@16:    return r; 
Chris@16: }
Chris@16: 
Chris@16: template <class BidiIterator, class Allocator, class traits>
Chris@16: bool perl_matcher<BidiIterator, Allocator, traits>::unwind_repeater_counter(bool)
Chris@16: {
Chris@16:    saved_repeater<BidiIterator>* pmp = static_cast<saved_repeater<BidiIterator>*>(m_backup_state);
Chris@16:    boost::re_detail::inplace_destroy(pmp++);
Chris@16:    m_backup_state = pmp;
Chris@16:    return true; // keep looking
Chris@16: }
Chris@16: 
Chris@16: template <class BidiIterator, class Allocator, class traits>
Chris@16: bool perl_matcher<BidiIterator, Allocator, traits>::unwind_extra_block(bool)
Chris@16: {
Chris@16:    saved_extra_block* pmp = static_cast<saved_extra_block*>(m_backup_state);
Chris@16:    void* condemmed = m_stack_base;
Chris@16:    m_stack_base = pmp->base;
Chris@16:    m_backup_state = pmp->end;
Chris@16:    boost::re_detail::inplace_destroy(pmp);
Chris@16:    put_mem_block(condemmed);
Chris@16:    return true; // keep looking
Chris@16: }
Chris@16: 
Chris@16: template <class BidiIterator, class Allocator, class traits>
Chris@16: inline void perl_matcher<BidiIterator, Allocator, traits>::destroy_single_repeat()
Chris@16: {
Chris@16:    saved_single_repeat<BidiIterator>* p = static_cast<saved_single_repeat<BidiIterator>*>(m_backup_state);
Chris@16:    boost::re_detail::inplace_destroy(p++);
Chris@16:    m_backup_state = p;
Chris@16: }
Chris@16: 
Chris@16: template <class BidiIterator, class Allocator, class traits>
Chris@16: bool perl_matcher<BidiIterator, Allocator, traits>::unwind_greedy_single_repeat(bool r)
Chris@16: {
Chris@16:    saved_single_repeat<BidiIterator>* pmp = static_cast<saved_single_repeat<BidiIterator>*>(m_backup_state);
Chris@16: 
Chris@16:    // if we have a match, just discard this state:
Chris@16:    if(r) 
Chris@16:    {
Chris@16:       destroy_single_repeat();
Chris@16:       return true;
Chris@16:    }
Chris@16: 
Chris@16:    const re_repeat* rep = pmp->rep;
Chris@16:    std::size_t count = pmp->count;
Chris@16:    BOOST_ASSERT(rep->next.p != 0);
Chris@16:    BOOST_ASSERT(rep->alt.p != 0);
Chris@16: 
Chris@16:    count -= rep->min;
Chris@16:    
Chris@16:    if((m_match_flags & match_partial) && (position == last))
Chris@16:       m_has_partial_match = true;
Chris@16: 
Chris@16:    BOOST_ASSERT(count);
Chris@16:    position = pmp->last_position;
Chris@16: 
Chris@16:    // backtrack till we can skip out:
Chris@16:    do
Chris@16:    {
Chris@16:       --position;
Chris@16:       --count;
Chris@16:       ++state_count;
Chris@16:    }while(count && !can_start(*position, rep->_map, mask_skip));
Chris@16: 
Chris@16:    // if we've hit base, destroy this state:
Chris@16:    if(count == 0)
Chris@16:    {
Chris@16:          destroy_single_repeat();
Chris@16:          if(!can_start(*position, rep->_map, mask_skip))
Chris@16:             return true;
Chris@16:    }
Chris@16:    else
Chris@16:    {
Chris@16:       pmp->count = count + rep->min;
Chris@16:       pmp->last_position = position;
Chris@16:    }
Chris@16:    pstate = rep->alt.p;
Chris@16:    return false;
Chris@16: }
Chris@16: 
Chris@16: template <class BidiIterator, class Allocator, class traits>
Chris@16: bool perl_matcher<BidiIterator, Allocator, traits>::unwind_slow_dot_repeat(bool r)
Chris@16: {
Chris@16:    saved_single_repeat<BidiIterator>* pmp = static_cast<saved_single_repeat<BidiIterator>*>(m_backup_state);
Chris@16: 
Chris@16:    // if we have a match, just discard this state:
Chris@16:    if(r) 
Chris@16:    {
Chris@16:       destroy_single_repeat();
Chris@16:       return true;
Chris@16:    }
Chris@16: 
Chris@16:    const re_repeat* rep = pmp->rep;
Chris@16:    std::size_t count = pmp->count;
Chris@16:    BOOST_ASSERT(rep->type == syntax_element_dot_rep);
Chris@16:    BOOST_ASSERT(rep->next.p != 0);
Chris@16:    BOOST_ASSERT(rep->alt.p != 0);
Chris@16:    BOOST_ASSERT(rep->next.p->type == syntax_element_wild);
Chris@16: 
Chris@16:    BOOST_ASSERT(count < rep->max);
Chris@16:    pstate = rep->next.p;
Chris@16:    position = pmp->last_position;
Chris@16: 
Chris@16:    if(position != last)
Chris@16:    {
Chris@16:       // wind forward until we can skip out of the repeat:
Chris@16:       do
Chris@16:       {
Chris@16:          if(!match_wild())
Chris@16:          {
Chris@16:             // failed repeat match, discard this state and look for another:
Chris@16:             destroy_single_repeat();
Chris@16:             return true;
Chris@16:          }
Chris@16:          ++count;
Chris@16:          ++state_count;
Chris@16:          pstate = rep->next.p;
Chris@16:       }while((count < rep->max) && (position != last) && !can_start(*position, rep->_map, mask_skip));
Chris@16:    }   
Chris@16:    if(position == last)
Chris@16:    {
Chris@16:       // can't repeat any more, remove the pushed state: 
Chris@16:       destroy_single_repeat();
Chris@16:       if((m_match_flags & match_partial) && (position == last) && (position != search_base))
Chris@16:          m_has_partial_match = true;
Chris@16:       if(0 == (rep->can_be_null & mask_skip))
Chris@16:          return true;
Chris@16:    }
Chris@16:    else if(count == rep->max)
Chris@16:    {
Chris@16:       // can't repeat any more, remove the pushed state: 
Chris@16:       destroy_single_repeat();
Chris@16:       if(!can_start(*position, rep->_map, mask_skip))
Chris@16:          return true;
Chris@16:    }
Chris@16:    else
Chris@16:    {
Chris@16:       pmp->count = count;
Chris@16:       pmp->last_position = position;
Chris@16:    }
Chris@16:    pstate = rep->alt.p;
Chris@16:    return false;
Chris@16: }
Chris@16: 
Chris@16: template <class BidiIterator, class Allocator, class traits>
Chris@16: bool perl_matcher<BidiIterator, Allocator, traits>::unwind_fast_dot_repeat(bool r)
Chris@16: {
Chris@16:    saved_single_repeat<BidiIterator>* pmp = static_cast<saved_single_repeat<BidiIterator>*>(m_backup_state);
Chris@16: 
Chris@16:    // if we have a match, just discard this state:
Chris@16:    if(r) 
Chris@16:    {
Chris@16:       destroy_single_repeat();
Chris@16:       return true;
Chris@16:    }
Chris@16: 
Chris@16:    const re_repeat* rep = pmp->rep;
Chris@16:    std::size_t count = pmp->count;
Chris@16: 
Chris@16:    BOOST_ASSERT(count < rep->max);
Chris@16:    position = pmp->last_position;
Chris@16:    if(position != last)
Chris@16:    {
Chris@16: 
Chris@16:       // wind forward until we can skip out of the repeat:
Chris@16:       do
Chris@16:       {
Chris@16:          ++position;
Chris@16:          ++count;
Chris@16:          ++state_count;
Chris@16:       }while((count < rep->max) && (position != last) && !can_start(*position, rep->_map, mask_skip));
Chris@16:    }
Chris@16: 
Chris@16:    // remember where we got to if this is a leading repeat:
Chris@16:    if((rep->leading) && (count < rep->max))
Chris@16:       restart = position;
Chris@16:    if(position == last)
Chris@16:    {
Chris@16:       // can't repeat any more, remove the pushed state: 
Chris@16:       destroy_single_repeat();
Chris@16:       if((m_match_flags & match_partial) && (position == last) && (position != search_base))
Chris@16:          m_has_partial_match = true;
Chris@16:       if(0 == (rep->can_be_null & mask_skip))
Chris@16:          return true;
Chris@16:    }
Chris@16:    else if(count == rep->max)
Chris@16:    {
Chris@16:       // can't repeat any more, remove the pushed state: 
Chris@16:       destroy_single_repeat();
Chris@16:       if(!can_start(*position, rep->_map, mask_skip))
Chris@16:          return true;
Chris@16:    }
Chris@16:    else
Chris@16:    {
Chris@16:       pmp->count = count;
Chris@16:       pmp->last_position = position;
Chris@16:    }
Chris@16:    pstate = rep->alt.p;
Chris@16:    return false;
Chris@16: }
Chris@16: 
Chris@16: template <class BidiIterator, class Allocator, class traits>
Chris@16: bool perl_matcher<BidiIterator, Allocator, traits>::unwind_char_repeat(bool r)
Chris@16: {
Chris@16:    saved_single_repeat<BidiIterator>* pmp = static_cast<saved_single_repeat<BidiIterator>*>(m_backup_state);
Chris@16: 
Chris@16:    // if we have a match, just discard this state:
Chris@16:    if(r) 
Chris@16:    {
Chris@16:       destroy_single_repeat();
Chris@16:       return true;
Chris@16:    }
Chris@16: 
Chris@16:    const re_repeat* rep = pmp->rep;
Chris@16:    std::size_t count = pmp->count;
Chris@16:    pstate = rep->next.p;
Chris@16:    const char_type what = *reinterpret_cast<const char_type*>(static_cast<const re_literal*>(pstate) + 1);
Chris@16:    position = pmp->last_position;
Chris@16: 
Chris@16:    BOOST_ASSERT(rep->type == syntax_element_char_rep);
Chris@16:    BOOST_ASSERT(rep->next.p != 0);
Chris@16:    BOOST_ASSERT(rep->alt.p != 0);
Chris@16:    BOOST_ASSERT(rep->next.p->type == syntax_element_literal);
Chris@16:    BOOST_ASSERT(count < rep->max);
Chris@16: 
Chris@16:    if(position != last)
Chris@16:    {
Chris@16:       // wind forward until we can skip out of the repeat:
Chris@16:       do
Chris@16:       {
Chris@16:          if(traits_inst.translate(*position, icase) != what)
Chris@16:          {
Chris@16:             // failed repeat match, discard this state and look for another:
Chris@16:             destroy_single_repeat();
Chris@16:             return true;
Chris@16:          }
Chris@16:          ++count;
Chris@16:          ++ position;
Chris@16:          ++state_count;
Chris@16:          pstate = rep->next.p;
Chris@16:       }while((count < rep->max) && (position != last) && !can_start(*position, rep->_map, mask_skip));
Chris@16:    }   
Chris@16:    // remember where we got to if this is a leading repeat:
Chris@16:    if((rep->leading) && (count < rep->max))
Chris@16:       restart = position;
Chris@16:    if(position == last)
Chris@16:    {
Chris@16:       // can't repeat any more, remove the pushed state: 
Chris@16:       destroy_single_repeat();
Chris@16:       if((m_match_flags & match_partial) && (position == last) && (position != search_base))
Chris@16:          m_has_partial_match = true;
Chris@16:       if(0 == (rep->can_be_null & mask_skip))
Chris@16:          return true;
Chris@16:    }
Chris@16:    else if(count == rep->max)
Chris@16:    {
Chris@16:       // can't repeat any more, remove the pushed state: 
Chris@16:       destroy_single_repeat();
Chris@16:       if(!can_start(*position, rep->_map, mask_skip))
Chris@16:          return true;
Chris@16:    }
Chris@16:    else
Chris@16:    {
Chris@16:       pmp->count = count;
Chris@16:       pmp->last_position = position;
Chris@16:    }
Chris@16:    pstate = rep->alt.p;
Chris@16:    return false;
Chris@16: }
Chris@16: 
Chris@16: template <class BidiIterator, class Allocator, class traits>
Chris@16: bool perl_matcher<BidiIterator, Allocator, traits>::unwind_short_set_repeat(bool r)
Chris@16: {
Chris@16:    saved_single_repeat<BidiIterator>* pmp = static_cast<saved_single_repeat<BidiIterator>*>(m_backup_state);
Chris@16: 
Chris@16:    // if we have a match, just discard this state:
Chris@16:    if(r) 
Chris@16:    {
Chris@16:       destroy_single_repeat();
Chris@16:       return true;
Chris@16:    }
Chris@16: 
Chris@16:    const re_repeat* rep = pmp->rep;
Chris@16:    std::size_t count = pmp->count;
Chris@16:    pstate = rep->next.p;
Chris@16:    const unsigned char* map = static_cast<const re_set*>(rep->next.p)->_map;
Chris@16:    position = pmp->last_position;
Chris@16: 
Chris@16:    BOOST_ASSERT(rep->type == syntax_element_short_set_rep);
Chris@16:    BOOST_ASSERT(rep->next.p != 0);
Chris@16:    BOOST_ASSERT(rep->alt.p != 0);
Chris@16:    BOOST_ASSERT(rep->next.p->type == syntax_element_set);
Chris@16:    BOOST_ASSERT(count < rep->max);
Chris@16:    
Chris@16:    if(position != last)
Chris@16:    {
Chris@16:       // wind forward until we can skip out of the repeat:
Chris@16:       do
Chris@16:       {
Chris@16:          if(!map[static_cast<unsigned char>(traits_inst.translate(*position, icase))])
Chris@16:          {
Chris@16:             // failed repeat match, discard this state and look for another:
Chris@16:             destroy_single_repeat();
Chris@16:             return true;
Chris@16:          }
Chris@16:          ++count;
Chris@16:          ++ position;
Chris@16:          ++state_count;
Chris@16:          pstate = rep->next.p;
Chris@16:       }while((count < rep->max) && (position != last) && !can_start(*position, rep->_map, mask_skip));
Chris@16:    }   
Chris@16:    // remember where we got to if this is a leading repeat:
Chris@16:    if((rep->leading) && (count < rep->max))
Chris@16:       restart = position;
Chris@16:    if(position == last)
Chris@16:    {
Chris@16:       // can't repeat any more, remove the pushed state: 
Chris@16:       destroy_single_repeat();
Chris@16:       if((m_match_flags & match_partial) && (position == last) && (position != search_base))
Chris@16:          m_has_partial_match = true;
Chris@16:       if(0 == (rep->can_be_null & mask_skip))
Chris@16:          return true;
Chris@16:    }
Chris@16:    else if(count == rep->max)
Chris@16:    {
Chris@16:       // can't repeat any more, remove the pushed state: 
Chris@16:       destroy_single_repeat();
Chris@16:       if(!can_start(*position, rep->_map, mask_skip))
Chris@16:          return true;
Chris@16:    }
Chris@16:    else
Chris@16:    {
Chris@16:       pmp->count = count;
Chris@16:       pmp->last_position = position;
Chris@16:    }
Chris@16:    pstate = rep->alt.p;
Chris@16:    return false;
Chris@16: }
Chris@16: 
Chris@16: template <class BidiIterator, class Allocator, class traits>
Chris@16: bool perl_matcher<BidiIterator, Allocator, traits>::unwind_long_set_repeat(bool r)
Chris@16: {
Chris@16:    typedef typename traits::char_class_type m_type;
Chris@16:    saved_single_repeat<BidiIterator>* pmp = static_cast<saved_single_repeat<BidiIterator>*>(m_backup_state);
Chris@16: 
Chris@16:    // if we have a match, just discard this state:
Chris@16:    if(r)
Chris@16:    {
Chris@16:       destroy_single_repeat();
Chris@16:       return true;
Chris@16:    }
Chris@16: 
Chris@16:    const re_repeat* rep = pmp->rep;
Chris@16:    std::size_t count = pmp->count;
Chris@16:    pstate = rep->next.p;
Chris@16:    const re_set_long<m_type>* set = static_cast<const re_set_long<m_type>*>(pstate);
Chris@16:    position = pmp->last_position;
Chris@16: 
Chris@16:    BOOST_ASSERT(rep->type == syntax_element_long_set_rep);
Chris@16:    BOOST_ASSERT(rep->next.p != 0);
Chris@16:    BOOST_ASSERT(rep->alt.p != 0);
Chris@16:    BOOST_ASSERT(rep->next.p->type == syntax_element_long_set);
Chris@16:    BOOST_ASSERT(count < rep->max);
Chris@16: 
Chris@16:    if(position != last)
Chris@16:    {
Chris@16:       // wind forward until we can skip out of the repeat:
Chris@16:       do
Chris@16:       {
Chris@16:          if(position == re_is_set_member(position, last, set, re.get_data(), icase))
Chris@16:          {
Chris@16:             // failed repeat match, discard this state and look for another:
Chris@16:             destroy_single_repeat();
Chris@16:             return true;
Chris@16:          }
Chris@16:          ++position;
Chris@16:          ++count;
Chris@16:          ++state_count;
Chris@16:          pstate = rep->next.p;
Chris@16:       }while((count < rep->max) && (position != last) && !can_start(*position, rep->_map, mask_skip));
Chris@16:    }   
Chris@16:    // remember where we got to if this is a leading repeat:
Chris@16:    if((rep->leading) && (count < rep->max))
Chris@16:       restart = position;
Chris@16:    if(position == last)
Chris@16:    {
Chris@16:       // can't repeat any more, remove the pushed state:
Chris@16:       destroy_single_repeat();
Chris@16:       if((m_match_flags & match_partial) && (position == last) && (position != search_base))
Chris@16:          m_has_partial_match = true;
Chris@16:       if(0 == (rep->can_be_null & mask_skip))
Chris@16:          return true;
Chris@16:    }
Chris@16:    else if(count == rep->max)
Chris@16:    {
Chris@16:       // can't repeat any more, remove the pushed state: 
Chris@16:       destroy_single_repeat();
Chris@16:       if(!can_start(*position, rep->_map, mask_skip))
Chris@16:          return true;
Chris@16:    }
Chris@16:    else
Chris@16:    {
Chris@16:       pmp->count = count;
Chris@16:       pmp->last_position = position;
Chris@16:    }
Chris@16:    pstate = rep->alt.p;
Chris@16:    return false;
Chris@16: }
Chris@16: 
Chris@16: template <class BidiIterator, class Allocator, class traits>
Chris@16: bool perl_matcher<BidiIterator, Allocator, traits>::unwind_non_greedy_repeat(bool r)
Chris@16: {
Chris@16:    saved_position<BidiIterator>* pmp = static_cast<saved_position<BidiIterator>*>(m_backup_state);
Chris@16:    if(!r)
Chris@16:    {
Chris@16:       position = pmp->position;
Chris@16:       pstate = pmp->pstate;
Chris@16:       ++(*next_count);
Chris@16:    }
Chris@16:    boost::re_detail::inplace_destroy(pmp++);
Chris@16:    m_backup_state = pmp;
Chris@16:    return r;
Chris@16: }
Chris@16: 
Chris@16: template <class BidiIterator, class Allocator, class traits>
Chris@16: bool perl_matcher<BidiIterator, Allocator, traits>::unwind_recursion(bool r)
Chris@16: {
Chris@16:    saved_recursion<results_type>* pmp = static_cast<saved_recursion<results_type>*>(m_backup_state);
Chris@16:    if(!r)
Chris@16:    {
Chris@16:       recursion_stack.push_back(recursion_info<results_type>());
Chris@16:       recursion_stack.back().idx = pmp->recursion_id;
Chris@16:       recursion_stack.back().preturn_address = pmp->preturn_address;
Chris@16:       recursion_stack.back().results = pmp->results;
Chris@16:    }
Chris@16:    boost::re_detail::inplace_destroy(pmp++);
Chris@16:    m_backup_state = pmp;
Chris@16:    return true;
Chris@16: }
Chris@16: 
Chris@16: template <class BidiIterator, class Allocator, class traits>
Chris@16: bool perl_matcher<BidiIterator, Allocator, traits>::unwind_recursion_pop(bool r)
Chris@16: {
Chris@16:    saved_state* pmp = static_cast<saved_state*>(m_backup_state);
Chris@16:    if(!r)
Chris@16:    {
Chris@16:       recursion_stack.pop_back();
Chris@16:    }
Chris@16:    boost::re_detail::inplace_destroy(pmp++);
Chris@16:    m_backup_state = pmp;
Chris@16:    return true;
Chris@16: }
Chris@16: 
Chris@16: template <class BidiIterator, class Allocator, class traits>
Chris@16: void perl_matcher<BidiIterator, Allocator, traits>::push_recursion_pop()
Chris@16: {
Chris@16:    saved_state* pmp = static_cast<saved_state*>(m_backup_state);
Chris@16:    --pmp;
Chris@16:    if(pmp < m_stack_base)
Chris@16:    {
Chris@16:       extend_stack();
Chris@16:       pmp = static_cast<saved_state*>(m_backup_state);
Chris@16:       --pmp;
Chris@16:    }
Chris@16:    (void) new (pmp)saved_state(15);
Chris@16:    m_backup_state = pmp;
Chris@16: }
Chris@16: /*
Chris@16: template <class BidiIterator, class Allocator, class traits>
Chris@16: bool perl_matcher<BidiIterator, Allocator, traits>::unwind_parenthesis_pop(bool r)
Chris@16: {
Chris@16:    saved_state* pmp = static_cast<saved_state*>(m_backup_state);
Chris@16:    if(!r)
Chris@16:    {
Chris@16:       --parenthesis_stack_position;
Chris@16:    }
Chris@16:    boost::re_detail::inplace_destroy(pmp++);
Chris@16:    m_backup_state = pmp;
Chris@16:    return true;
Chris@16: }
Chris@16: 
Chris@16: template <class BidiIterator, class Allocator, class traits>
Chris@16: void perl_matcher<BidiIterator, Allocator, traits>::push_parenthesis_pop()
Chris@16: {
Chris@16:    saved_state* pmp = static_cast<saved_state*>(m_backup_state);
Chris@16:    --pmp;
Chris@16:    if(pmp < m_stack_base)
Chris@16:    {
Chris@16:       extend_stack();
Chris@16:       pmp = static_cast<saved_state*>(m_backup_state);
Chris@16:       --pmp;
Chris@16:    }
Chris@16:    (void) new (pmp)saved_state(16);
Chris@16:    m_backup_state = pmp;
Chris@16: }
Chris@16: 
Chris@16: template <class BidiIterator, class Allocator, class traits>
Chris@16: bool perl_matcher<BidiIterator, Allocator, traits>::unwind_parenthesis_push(bool r)
Chris@16: {
Chris@16:    saved_position<BidiIterator>* pmp = static_cast<saved_position<BidiIterator>*>(m_backup_state);
Chris@16:    if(!r)
Chris@16:    {
Chris@16:       parenthesis_stack[parenthesis_stack_position++] = pmp->position;
Chris@16:    }
Chris@16:    boost::re_detail::inplace_destroy(pmp++);
Chris@16:    m_backup_state = pmp;
Chris@16:    return true;
Chris@16: }
Chris@16: 
Chris@16: template <class BidiIterator, class Allocator, class traits>
Chris@16: inline void perl_matcher<BidiIterator, Allocator, traits>::push_parenthesis_push(BidiIterator p)
Chris@16: {
Chris@16:    saved_position<BidiIterator>* pmp = static_cast<saved_position<BidiIterator>*>(m_backup_state);
Chris@16:    --pmp;
Chris@16:    if(pmp < m_stack_base)
Chris@16:    {
Chris@16:       extend_stack();
Chris@16:       pmp = static_cast<saved_position<BidiIterator>*>(m_backup_state);
Chris@16:       --pmp;
Chris@16:    }
Chris@16:    (void) new (pmp)saved_position<BidiIterator>(0, p, 17);
Chris@16:    m_backup_state = pmp;
Chris@16: }
Chris@16: */
Chris@16: } // namespace re_detail
Chris@16: } // namespace boost
Chris@16: 
Chris@16: #ifdef BOOST_MSVC
Chris@16: #  pragma warning(pop)
Chris@16: #endif
Chris@16: 
Chris@16: #ifdef BOOST_MSVC
Chris@16: #pragma warning(push)
Chris@16: #pragma warning(disable: 4103)
Chris@16: #endif
Chris@16: #ifdef BOOST_HAS_ABI_HEADERS
Chris@16: #  include BOOST_ABI_SUFFIX
Chris@16: #endif
Chris@16: #ifdef BOOST_MSVC
Chris@16: #pragma warning(pop)
Chris@16: #endif
Chris@16: 
Chris@16: #endif
Chris@16: 
Chris@16: