//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//
//=============================================================================//
/*
*
* Copyright (c) 1998-9
* Dr John Maddock
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Dr John Maddock makes no representations
* about the suitability of this software for any purpose.
* It is provided "as is" without express or implied warranty.
*
*/
/*
* FILE regmatch.h
* VERSION 2.12
* regular expression matching algorithms
*/
#ifndef __REGMATCH_H
#define __REGMATCH_H
JM_NAMESPACE(__JM)
template <class iterator, class charT, class traits_type, class Allocator>
iterator RE_CALL re_is_set_member(iterator next,
iterator last,
re_set_long* set,
const reg_expression<charT, traits_type, Allocator>& e)
{
const charT* p = (const charT*)(set+1);
iterator ptr;
unsigned int i;
bool icase = e.flags() & regbase::icase;
// try and match a single character, could be a multi-character
// collating element...
for(i = 0; i < set->csingles; ++i)
{
ptr = next;
while(*p && (ptr != last))
{
if(traits_type::translate(*ptr, icase MAYBE_PASS_LOCALE(e.locale())) != *p)
break;
++p;
++ptr;
}
if(*p == 0) // if null we've matched
return set->isnot ? next : (ptr == next) ? ++next : ptr;
while(*p)++p;
++p; // skip null
}
charT col = traits_type::translate(*next, icase MAYBE_PASS_LOCALE(e.locale()));
if(set->cranges || set->cequivalents)
{
re_str<charT> s2(col);
re_str<charT> s1;
//
// try and match a range, NB only a single character can match
if(set->cranges)
{
if(e.flags() & regbase::nocollate)
s1 = s2;
else
traits_type::transform(s1, s2 MAYBE_PASS_LOCALE(e.locale()));
for(i = 0; i < set->cranges; ++i)
{
if(s1 <= p)
{
while(*p)++p;
++p;
if(s1 >= p)
return set->isnot ? next : ++next;
}
else
{
// skip first string
while(*p)++p;
++p;
}
// skip second string
while(*p)++p;
++p;
}
}
//
// try and match an equivalence class, NB only a single character can match
if(set->cequivalents)
{
traits_type::transform_primary(s1, s2 MAYBE_PASS_LOCALE(e.locale()));
for(i = 0; i < set->cequivalents; ++i)
{
if(s1 == p)
return set->isnot ? next : ++next;
// skip string
while(*p)++p;
++p;
}
}
}
if(traits_type::is_class(col, set->cclasses MAYBE_PASS_LOCALE(e.locale())) == true)
return set->isnot ? next : ++next;
return set->isnot ? ++next : next;
}
template <class iterator, class Allocator>
class __priv_match_data
{
public:
typedef JM_MAYBE_TYPENAME REBIND_TYPE(int, Allocator) i_alloc;
typedef JM_MAYBE_TYPENAME REBIND_TYPE(iterator, Allocator) it_alloc;
reg_match_base<iterator, Allocator> temp_match;
// failure stacks:
jstack<reg_match_base<iterator, Allocator>, Allocator> matches;
jstack<iterator, Allocator> prev_pos;
jstack<const re_syntax_base*, Allocator> prev_record;
jstack<int, Allocator> prev_acc;
int* accumulators;
unsigned int caccumulators;
iterator* loop_starts;
__priv_match_data(const reg_match_base<iterator, Allocator>&);
~__priv_match_data()
{
free();
}
void free();
void set_accumulator_size(unsigned int size);
int* get_accumulators()
{
return accumulators;
}
iterator* get_loop_starts()
{
return loop_starts;
}
};
template <class iterator, class Allocator>
__priv_match_data<iterator, Allocator>::__priv_match_data(const reg_match_base<iterator, Allocator>& m)
: temp_match(m), matches(64, m.allocator()), prev_pos(64, m.allocator()), prev_record(64, m.allocator())
{
accumulators = 0;
caccumulators = 0;
loop_starts = 0;
}
template <class iterator, class Allocator>
void __priv_match_data<iterator, Allocator>::set_accumulator_size(unsigned int size)
{
if(size > caccumulators)
{
free();
caccumulators = size;
accumulators = i_alloc(temp_match.allocator()).allocate(caccumulators);
loop_starts = it_alloc(temp_match.allocator()).allocate(caccumulators);
for(unsigned i = 0; i < caccumulators; ++i)
new (loop_starts + i) iterator();
}
}
template <class iterator, class Allocator>
void __priv_match_data<iterator, Allocator>::free()
{
if(caccumulators)
{
//REBIND_INSTANCE(int, Allocator, temp_match.allocator()).deallocate(accumulators, caccumulators);
i_alloc temp1(temp_match.allocator());
temp1.deallocate(accumulators, caccumulators);
for(unsigned i = 0; i < caccumulators; ++i)
jm_destroy(loop_starts + i);
//REBIND_INSTANCE(iterator, Allocator, temp_match.allocator()).deallocate(loop_starts, caccumulators);
it_alloc temp2(temp_match.allocator());
temp2.deallocate(loop_starts, caccumulators);
}
}
//
// proc query_match
// returns true if the specified regular expression matches
// at position first. Fills in what matched in m.
//
template <class iterator, class Allocator, class charT, class traits, class Allocator2>
bool query_match(iterator first, iterator last, reg_match<iterator, Allocator>& m, const reg_expression<charT, traits, Allocator2>& e, unsigned flags = match_default)
{
// prepare m for failure:
if((flags & match_init) == 0)
{
m.set_size(e.mark_count(), first, last);
}
__priv_match_data<iterator, Allocator> pd(m);
iterator restart;
return query_match_aux(first, last, m, e, flags, pd, &restart);
}
//
// query_match convenience interfaces:
#ifndef JM_NO_PARTIAL_FUNC_SPEC
//
// this isn't really a partial specialisation, but template function
// overloading - if the compiler doesn't support partial specialisation
// then it really won't support this either:
template <class charT, class Allocator, class traits, class Allocator2>
inline bool query_match(const charT* str,
reg_match<const charT*, Allocator>& m,
const reg_expression<charT, traits, Allocator2>& e,
unsigned flags = match_default)
{
return query_match(str, str + traits::length(str), m, e, flags);
}
#ifndef JM_NO_STRING_H
template <class ST, class SA, class Allocator, class charT, class traits, class Allocator2>
inline bool query_match(const __JM_STD::basic_string<charT, ST, SA>& s,
reg_match<typename __JM_STD::basic_string<charT, ST, SA>::const_iterator, Allocator>& m,
const reg_expression<charT, traits, Allocator2>& e,
unsigned flags = match_default)
{
return query_match(s.begin(), s.end(), m, e, flags);
}
#endif
#else // partial specialisation
inline bool query_match(const char* str,
cmatch& m,
const regex& e,
unsigned flags = match_default)
{
return query_match(str, str + regex::traits_type::length(str), m, e, flags);
}
#ifndef JM_NO_WCSTRING
inline bool query_match(const wchar_t* str,
wcmatch& m,
const wregex& e,
unsigned flags = match_default)
{
return query_match(str, str + wregex::traits_type::length(str), m, e, flags);
}
#endif
#ifndef JM_NO_STRING_H
inline bool query_match(const __JM_STD::string& s,
reg_match<__JM_STD::string::const_iterator, regex::alloc_type>& m,
const regex& e,
unsigned flags = match_default)
{
return query_match(s.begin(), s.end(), m, e, flags);
}
#if !defined(JM_NO_STRING_DEF_ARGS) && !defined(JM_NO_WCSTRING)
inline bool query_match(const __JM_STD::basic_string<wchar_t>& s,
reg_match<__JM_STD::basic_string<wchar_t>::const_iterator, wregex::alloc_type>& m,
const wregex& e,
unsigned flags = match_default)
{
return query_match(s.begin(), s.end(), m, e, flags);
}
#endif
#endif
#endif
#if defined(JM_NO_TEMPLATE_SWITCH_MERGE) && !defined(JM_NO_NAMESPACES)
//
// Ugly ugly hack,
// template don't merge if they contain switch statements so declare these
// templates in unnamed namespace (ie with internal linkage), each translation
// unit then gets its own local copy, it works seemlessly but bloats the app.
namespace{
#endif
template <class iterator, class Allocator, class charT, class traits, class Allocator2>
bool query_match_aux(iterator first,
iterator last,
reg_match<iterator, Allocator>& m,
const reg_expression<charT, traits, Allocator2>& e,
unsigned flags,
__priv_match_data<iterator, Allocator>& pd,
iterator* restart)
{
if(e.flags() & regbase::failbit)
return false;
typedef typename traits::size_type traits_size_type;
typedef typename traits::uchar_type traits_uchar_type;
typedef typename is_byte<charT>::width_type width_type;
#ifdef RE_LOCALE_CPP
const __JM_STD::locale& locale_inst = e.locale();
#endif
// declare some local aliases to reduce pointer loads
// good optimising compilers should make this unnecessary!!
jstack<reg_match_base<iterator, Allocator>, Allocator>& matches = pd.matches;
jstack<iterator, Allocator>& prev_pos = pd.prev_pos;
jstack<const re_syntax_base*, Allocator>& prev_record = pd.prev_record;
jstack<int, Allocator>& prev_acc = pd.prev_acc;
reg_match_base<iterator, Allocator>& temp_match = pd.temp_match;
temp_match.set_first(first);
//temp_match.set_size(e.mark_count(), first, last);
register const re_syntax_base* ptr = e.first();
bool match_found = false;
bool need_push_match = (e.mark_count() > 1);
int cur_acc = -1; // no active accumulator
pd.set_accumulator_size(e.repeat_count());
int* accumulators = pd.get_accumulators();
iterator* start_loop = pd.get_loop_starts();
int k; // for loops
bool icase = e.flags() & regbase::icase;
*restart = first;
iterator base = first;
// prepare m for failure:
/*
if((flags & match_init) == 0)
{
m.init_fail(first, last);
} */
retry:
while(first != last)
{
jm_assert(ptr);
switch(ptr->type)
{
case syntax_element_match:
match_jump:
{
// match found, save then fallback in case we missed a
// longer one.
if((flags & match_not_null) && (first == temp_match[0].first))
goto failure;
temp_match.set_second(first);
m.maybe_assign(temp_match);
match_found = true;
if((flags & match_any) || ((first == last) && (need_push_match == false)))
{
// either we don't care what we match or we've matched
// the whole string and can't match anything longer.
while(matches.empty() == false)
matches.pop();
while(prev_pos.empty() == false)
prev_pos.pop();
while(prev_record.empty() == false)
prev_record.pop();
while(prev_acc.empty() == false)
prev_acc.pop();
return true;
}
}
goto failure;
case syntax_element_startmark:
temp_match.set_first(first, ((re_brace*)ptr)->index);
ptr = ptr->next.p;
break;
case syntax_element_endmark:
temp_match.set_second(first, ((re_brace*)ptr)->index);
ptr = ptr->next.p;
break;
case syntax_element_literal:
{
unsigned int len = ((re_literal*)ptr)->length;
charT* what = (charT*)(((re_literal*)ptr) + 1);
//
// compare string with what we stored in
// our records:
for(unsigned int i = 0; i < len; ++i, ++first)
{
if((first == last) || (traits::translate(*first, icase MAYBE_PASS_LOCALE(locale_inst)) != what[i]))
goto failure;
}
ptr = ptr->next.p;
break;
}
case syntax_element_start_line:
outer_line_check:
if(first == temp_match[0].first)
{
// we're at the start of the buffer
if(flags & match_prev_avail)
{
inner_line_check:
// check the previous value even though its before
// the start of our "buffer".
iterator t(first);
--t;
if(traits::is_separator(*t) && !((*t == '\r') && (*first == '\n')) )
{
ptr = ptr->next.p;
continue;
}
goto failure;
}
if((flags & match_not_bol) == 0)
{
ptr = ptr->next.p;
continue;
}
goto failure;
}
// we're in the middle of the string
goto inner_line_check;
case syntax_element_end_line:
// we're not yet at the end so *first is always valid:
if(traits::is_separator(*first))
{
if((first != base) || (flags & match_prev_avail))
{
// check that we're not in the middle of \r\n sequence
iterator t(first);
--t;
if((*t == '\r') && (*first == '\n'))
{
goto failure;
}
}
ptr = ptr->next.p;
continue;
}
goto failure;
case syntax_element_wild:
// anything except possibly NULL or \n:
if(traits::is_separator(*first))
{
if(flags & match_not_dot_newline)
goto failure;
ptr = ptr->next.p;
++first;
continue;
}
if(*first == charT(0))
{
if(flags & match_not_dot_null)
goto failure;
ptr = ptr->next.p;
++first;
continue;
}
ptr = ptr->next.p;
++first;
break;
case syntax_element_word_boundary:
{
// prev and this character must be opposites:
bool b = traits::is_class(*first, char_class_word MAYBE_PASS_LOCALE(locale_inst));
if((first == temp_match[0].first) && ((flags & match_prev_avail) == 0))
{
if(flags & match_not_bow)
b ^= true;
else
b ^= false;
}
else
{
--first;
b ^= traits::is_class(*first, char_class_word MAYBE_PASS_LOCALE(locale_inst));
++first;
}
if(b)
{
ptr = ptr->next.p;
continue;
}
goto failure;
}
case syntax_element_within_word:
// both prev and this character must be char_class_word:
if(traits::is_class(*first, char_class_word MAYBE_PASS_LOCALE(locale_inst)))
{
bool b;
if((first == temp_match[0].first) && ((flags & match_prev_avail) == 0))
b = false;
else
{
--first;
b = traits::is_class(*first, char_class_word MAYBE_PASS_LOCALE(locale_inst));
++first;
}
if(b)
{
ptr = ptr->next.p;
continue;
}
}
goto failure;
case syntax_element_word_start:
if((first == temp_match[0].first) && ((flags & match_prev_avail) == 0))
{
// start of buffer:
if(flags & match_not_bow)
goto failure;
if(traits::is_class(*first, char_class_word MAYBE_PASS_LOCALE(locale_inst)))
{
ptr = ptr->next.p;
continue;
}
goto failure;
}
// otherwise inside buffer:
if(traits::is_class(*first, char_class_word MAYBE_PASS_LOCALE(locale_inst)))
{
iterator t(first);
--t;
if(traits::is_class(*t, char_class_word MAYBE_PASS_LOCALE(locale_inst)) == false)
{
ptr = ptr->next.p;
continue;
}
}
goto failure; // if we fall through to here then we've failed
case syntax_element_word_end:
if((first == temp_match[0].first) && ((flags & match_prev_avail) == 0))
goto failure; // start of buffer can't be end of word
// otherwise inside buffer:
if(traits::is_class(*first, char_class_word MAYBE_PASS_LOCALE(locale_inst)) == false)
{
iterator t(first);
--t;
if(traits::is_class(*t, char_class_word MAYBE_PASS_LOCALE(locale_inst)))
{
ptr = ptr->next.p;
continue;
}
}
goto failure; // if we fall through to here then we've failed
case syntax_element_buffer_start:
if((first != temp_match[0].first) || (flags & match_not_bob))
goto failure;
// OK match:
ptr = ptr->next.p;
break;
case syntax_element_buffer_end:
if((first != last) || (flags & match_not_eob))
goto failure;
// OK match:
ptr = ptr->next.p;
break;
case syntax_element_backref:
{
// compare with what we previously matched:
iterator i = temp_match[((re_brace*)ptr)->index].first;
iterator j = temp_match[((re_brace*)ptr)->index].second;
while(i != j)
{
if((first == last) || (traits::translate(*first, icase MAYBE_PASS_LOCALE(locale_inst)) != traits::translate(*i, icase MAYBE_PASS_LOCALE(locale_inst))))
goto failure;
++i;
++first;
}
ptr = ptr->next.p;
break;
}
case syntax_element_long_set:
{
// let the traits class do the work:
iterator t = re_is_set_member(first, last, (re_set_long*)ptr, e);
if(t != first)
{
ptr = ptr->next.p;
first = t;
continue;
}
goto failure;
}
case syntax_element_set:
// lookup character in table:
if(((re_set*)ptr)->__map[(traits_uchar_type)traits::translate(*first, icase MAYBE_PASS_LOCALE(locale_inst))])
{
ptr = ptr->next.p;
++first;
continue;
}
goto failure;
case syntax_element_jump:
ptr = ((re_jump*)ptr)->alt.p;
continue;
case syntax_element_alt:
{
// alt_jump:
if(reg_expression<charT, traits, Allocator2>::can_start(*first, ((re_jump*)ptr)->__map, (unsigned char)mask_take, width_type()))
{
// we can take the first alternative,
// see if we need to push next alternative:
if(reg_expression<charT, traits, Allocator2>::can_start(*first, ((re_jump*)ptr)->__map, mask_skip, width_type()))
{
if(need_push_match)
matches.push(temp_match);
for(k = 0; k <= cur_acc; ++k)
prev_pos.push(start_loop[k]);
prev_pos.push(first);
prev_record.push(ptr);
for(k = 0; k <= cur_acc; ++k)
prev_acc.push(accumulators[k]);
prev_acc.push(cur_acc);
}
ptr = ptr->next.p;
continue;
}
if(reg_expression<charT, traits, Allocator2>::can_start(*first, ((re_jump*)ptr)->__map, mask_skip, width_type()))
{
ptr = ((re_jump*)ptr)->alt.p;
continue;
}
goto failure; // neither option is possible
}
case syntax_element_rep:
{
// repeater_jump:
// if we're moving to a higher id (nested repeats etc)
// zero out our accumualtors:
if(cur_acc < ((re_repeat*)ptr)->id)
{
cur_acc = ((re_repeat*)ptr)->id;
accumulators[cur_acc] = 0;
start_loop[cur_acc] = iterator();
}
cur_acc = ((re_repeat*)ptr)->id;
if(((re_repeat*)ptr)->leading)
*restart = first;
//charT c = traits::translate(*first MAYBE_PASS_LOCALE(locale_inst));
// first of all test for special case where this is last element,
// if that is the case then repeat as many times as possible:
if(((re_repeat*)ptr)->alt.p->type == syntax_element_match)
{
// see if we can take the repeat:
if(((unsigned int)accumulators[cur_acc] < ((re_repeat*)ptr)->max)
&& reg_expression<charT, traits, Allocator2>::can_start(*first, ((re_repeat*)ptr)->__map, mask_take, width_type()))
{
// push terminating match as fallback:
if((unsigned int)accumulators[cur_acc] >= ((re_repeat*)ptr)->min)
{
if((prev_record.empty() == false) && (prev_record.peek() == ((re_repeat*)ptr)->alt.p))
{
// we already have the required fallback
// don't add any more, just update this one:
if(need_push_match)
matches.peek() = temp_match;
prev_pos.peek() = first;
}
else
{
if(need_push_match)
matches.push(temp_match);
prev_pos.push(first);
prev_record.push(((re_repeat*)ptr)->alt.p);
}
}
// move to next item in list:
if(first != start_loop[cur_acc])
{
++accumulators[cur_acc];
ptr = ptr->next.p;
start_loop[cur_acc] = first;
continue;
}
goto failure;
}
// see if we can skip the repeat:
if(((unsigned int)accumulators[cur_acc] >= ((re_repeat*)ptr)->min)
&& reg_expression<charT, traits, Allocator2>::can_start(*first, ((re_repeat*)ptr)->__map, mask_skip, width_type()))
{
ptr = ((re_repeat*)ptr)->alt.p;
continue;
}
// otherwise fail:
goto failure;
}
// see if we can skip the repeat:
if(((unsigned int)accumulators[cur_acc] >= ((re_repeat*)ptr)->min)
&& reg_expression<charT, traits, Allocator2>::can_start(*first, ((re_repeat*)ptr)->__map, mask_skip, width_type()))
{
// see if we can push failure info:
if(((unsigned int)accumulators[cur_acc] < ((re_repeat*)ptr)->max)
&& reg_expression<charT, traits, Allocator2>::can_start(*first, ((re_repeat*)ptr)->__map, mask_take, width_type()))
{
// check to see if the last loop matched a NULL string
// if so then we really don't want to loop again:
if(((unsigned int)accumulators[cur_acc] == ((re_repeat*)ptr)->min)
|| (first != start_loop[cur_acc]))
{
if(need_push_match)
matches.push(temp_match);
prev_pos.push(first);
prev_record.push(ptr);
for(k = 0; k <= cur_acc; ++k)
prev_acc.push(accumulators[k]);
//prev_acc.push(cur_acc);
}
}
ptr = ((re_repeat*)ptr)->alt.p;
continue;
}
// otherwise see if we can take the repeat:
if(((unsigned int)accumulators[cur_acc] < ((re_repeat*)ptr)->max)
&& reg_expression<charT, traits, Allocator2>::can_start(*first, ((re_repeat*)ptr)->__map, mask_take, width_type()) &&
(first != start_loop[cur_acc]))
{
// move to next item in list:
++accumulators[cur_acc];
ptr = ptr->next.p;
start_loop[cur_acc] = first;
continue;
}
// if we get here then neither option is allowed so fail:
goto failure;
}
case syntax_element_combining:
if(traits::is_combining(traits::translate(*first, icase MAYBE_PASS_LOCALE(locale_inst))))
goto failure;
++first;
while((first != last) && traits::is_combining(traits::translate(*first, icase MAYBE_PASS_LOCALE(locale_inst))))++first;
ptr = ptr->next.p;
continue;
case syntax_element_soft_buffer_end:
{
if(flags & match_not_eob)
goto failure;
iterator p(first);
while((p != last) && traits::is_separator(traits::translate(*first, icase MAYBE_PASS_LOCALE(locale_inst))))++p;
if(p != last)
goto failure;
ptr = ptr->next.p;
continue;
}
case syntax_element_restart_continue:
if(first != temp_match[-1].first)
goto failure;
ptr = ptr->next.p;
continue;
default:
jm_assert(0); // should never get to here!!
return false;
}
}
//
// if we get to here then we've run out of characters to match against,
// we could however still have non-character regex items left
if(ptr->can_be_null == 0)
goto failure;
while(true)
{
jm_assert(ptr);
switch(ptr->type)
{
case syntax_element_match:
goto match_jump;
case syntax_element_startmark:
temp_match.set_first(first, ((re_brace*)ptr)->index);
ptr = ptr->next.p;
break;
case syntax_element_endmark:
temp_match.set_second(first, ((re_brace*)ptr)->index);
ptr = ptr->next.p;
break;
case syntax_element_start_line:
goto outer_line_check;
case syntax_element_end_line:
// we're at the end so *first is never valid:
if((flags & match_not_eol) == 0)
{
ptr = ptr->next.p;
continue;
}
goto failure;
case syntax_element_word_boundary:
case syntax_element_word_end:
if(((flags & match_not_eow) == 0) && (first != temp_match[0].first))
{
iterator t(first);
--t;
if(traits::is_class(*t, char_class_word MAYBE_PASS_LOCALE(locale_inst)))
{
ptr = ptr->next.p;
continue;
}
}
goto failure;
case syntax_element_buffer_end:
case syntax_element_soft_buffer_end:
if(flags & match_not_eob)
goto failure;
// OK match:
ptr = ptr->next.p;
break;
case syntax_element_jump:
ptr = ((re_jump*)ptr)->alt.p;
continue;
case syntax_element_alt:
if(ptr->can_be_null & mask_take)
{
// we can test the first alternative,
// see if we need to push next alternative:
if(ptr->can_be_null & mask_skip)
{
if(need_push_match)
matches.push(temp_match);
for(k = 0; k <= cur_acc; ++k)
prev_pos.push(start_loop[k]);
prev_pos.push(first);
prev_record.push(ptr);
for(k = 0; k <= cur_acc; ++k)
prev_acc.push(accumulators[k]);
prev_acc.push(cur_acc);
}
ptr = ptr->next.p;
continue;
}
if(ptr->can_be_null & mask_skip)
{
ptr = ((re_jump*)ptr)->alt.p;
continue;
}
goto failure; // neither option is possible
case syntax_element_rep:
// if we're moving to a higher id (nested repeats etc)
// zero out our accumualtors:
if(cur_acc < ((re_repeat*)ptr)->id)
{
cur_acc = ((re_repeat*)ptr)->id;
accumulators[cur_acc] = 0;
start_loop[cur_acc] = first;
}
cur_acc = ((re_repeat*)ptr)->id;
// see if we can skip the repeat:
if(((unsigned int)accumulators[cur_acc] >= ((re_repeat*)ptr)->min)
&& (ptr->can_be_null & mask_skip))
{
// don't push failure info, there's no point:
ptr = ((re_repeat*)ptr)->alt.p;
continue;
}
// otherwise see if we can take the repeat:
if(((unsigned int)accumulators[cur_acc] < ((re_repeat*)ptr)->max)
&& ((ptr->can_be_null & (mask_take | mask_skip)) == (mask_take | mask_skip)))
{
// move to next item in list:
++accumulators[cur_acc];
ptr = ptr->next.p;
start_loop[cur_acc] = first;
continue;
}
// if we get here then neither option is allowed so fail:
goto failure;
case syntax_element_restart_continue:
if(first != temp_match[-1].first)
goto failure;
ptr = ptr->next.p;
continue;
default:
goto failure;
}
}
failure:
if(prev_record.empty() == false)
{
ptr = prev_record.peek();
switch(ptr->type)
{
case syntax_element_alt:
// get next alternative:
ptr = ((re_jump*)ptr)->alt.p;
if(need_push_match)
matches.pop(temp_match);
prev_acc.pop(cur_acc);
for(k = cur_acc; k >= 0; --k)
prev_acc.pop(accumulators[k]);
prev_pos.pop(first);
for(k = cur_acc; k >= 0; --k)
prev_pos.pop(start_loop[k]);
prev_record.pop();
goto retry;
case syntax_element_rep:
// we're doing least number of repeats first,
// increment count and repeat again:
if(need_push_match)
matches.pop(temp_match);
prev_pos.pop(first);
cur_acc = ((re_repeat*)ptr)->id;
for(k = cur_acc; k >= 0; --k)
prev_acc.pop(accumulators[k]);
prev_record.pop();
if((unsigned int)++accumulators[cur_acc] > ((re_repeat*)ptr)->max)
goto failure; // repetions exhausted.
ptr = ptr->next.p;
start_loop[cur_acc] = first;
goto retry;
case syntax_element_match:
if(need_push_match)
matches.pop(temp_match);
prev_pos.pop(first);
prev_record.pop();
goto retry;
default:
jm_assert(0);
// mustn't get here!!
}
}
if(match_found)
return true;
// if we get to here then everything has failed
// and no match was found:
return false;
}
#if defined(JM_NO_TEMPLATE_SWITCH_MERGE) && !defined(JM_NO_NAMESPACES)
} // namespace
#endif
template <class iterator>
void __skip_and_inc(unsigned int& clines, iterator& last_line, iterator& first, const iterator last)
{
while(first != last)
{
if(*first == '\n')
{
last_line = ++first;
++clines;
}
else
++first;
}
}
template <class iterator>
void __skip_and_dec(unsigned int& clines, iterator& last_line, iterator& first, iterator base, unsigned int len)
{
bool need_line = false;
for(unsigned int i = 0; i < len; ++i)
{
--first;
if(*first == '\n')
{
need_line = true;
--clines;
}
}
if(need_line)
{
last_line = first;
if(last_line != base)
--last_line;
else
return;
while((last_line != base) && (*last_line != '\n'))
--last_line;
if(*last_line == '\n')
++last_line;
}
}
template <class iterator>
inline void __inc_one(unsigned int& clines, iterator& last_line, iterator& first)
{
if(*first == '\n')
{
last_line = ++first;
++clines;
}
else
++first;
}
template <class iterator, class Allocator>
struct grep_search_predicate
{
reg_match<iterator, Allocator>* pm;
grep_search_predicate(reg_match<iterator, Allocator>* p) : pm(p) {}
bool operator()(const reg_match<iterator, Allocator>& m)
{
*pm = static_cast<const reg_match_base<iterator, Allocator>&>(m);
return false;
}
};
#if !defined(JM_NO_TEMPLATE_RETURNS) && !defined(JM_NO_PARTIAL_FUNC_SPEC)
template <class iterator, class Allocator>
inline const reg_match_base<iterator, Allocator>& grep_out_type(const grep_search_predicate<iterator, Allocator>& o, const Allocator&)
{
return *(o.pm);
}
#endif
template <class T, class Allocator>
inline const Allocator& grep_out_type(const T&, const Allocator& a)
{
return a;
}
#if defined(JM_NO_TEMPLATE_SWITCH_MERGE) && !defined(JM_NO_NAMESPACES)
//
// Ugly ugly hack,
// template don't merge if they contain switch statements so declare these
// templates in unnamed namespace (ie with internal linkage), each translation
// unit then gets its own local copy, it works seemlessly but bloats the app.
namespace{
#endif
//
// reg_grep2:
// find all non-overlapping matches within the sequence first last:
//
template <class Predicate, class I, class charT, class traits, class A, class A2>
unsigned int reg_grep2(Predicate foo, I first, I last, const reg_expression<charT, traits, A>& e, unsigned flags, A2 a)
{
if(e.flags() & regbase::failbit)
return 0;
typedef typename traits::size_type traits_size_type;
typedef typename traits::uchar_type traits_uchar_type;
typedef typename is_byte<charT>::width_type width_type;
reg_match<I, A2> m(grep_out_type(foo, a));
I restart;
m.set_size(e.mark_count(), first, last);
m.set_line(1, first);
#ifdef RE_LOCALE_CPP
const __JM_STD::locale& locale_inst = e.locale();
#endif
unsigned int clines = 1;
unsigned int cmatches = 0;
I last_line = first;
I next_base;
I base = first;
bool need_init;
flags |= match_init;
__priv_match_data<I, A2> pd(m);
const unsigned char* __map = e.get_map();
unsigned int type;
if(first == last)
{
// special case, only test if can_be_null,
// don't dereference any pointers!!
if(e.first()->can_be_null)
if(query_match_aux(first, last, m, e, flags, pd, &restart))
{
foo(m);
++cmatches;
}
return cmatches;
}
// try one time whatever:
if( reg_expression<charT, traits, A>::can_start(*first, __map, (unsigned char)mask_any, width_type() ) )
{
if(query_match_aux(first, last, m, e, flags, pd, &restart))
{
++cmatches;
if(foo(m) == false)
return cmatches;
// update to end of what matched
// trying to match again with match_not_null set if this
// is a null match...
need_init = true;
if(first == m[0].second)
{
next_base = m[0].second;
pd.temp_match.init_fail(next_base, last);
m.init_fail(next_base, last);
if(query_match_aux(first, last, m, e, flags | match_not_null, pd, &restart))
{
++cmatches;
if(foo(m) == false)
return cmatches;
}
else
{
need_init = false;
for(unsigned int i = 0; (restart != first) && (i < e.leading_length()); ++i, --restart);
if(restart != last)
++restart;
__skip_and_inc(clines, last_line, first, restart);
}
}
if(need_init)
{
__skip_and_inc(clines, last_line, first, m[0].second);
next_base = m[0].second;
pd.temp_match.init_fail(next_base, last);
m.init_fail(next_base, last);
}
}
else
{
for(unsigned int i = 0; (restart != first) && (i < e.leading_length()); ++i, --restart);
if(restart != last)
++restart;
__skip_and_inc(clines, last_line, first, restart);
}
}
else
__inc_one(clines, last_line, first);
flags |= match_prev_avail | match_not_bob;
// depending on what the first record is we may be able to
// optimise the search:
type = (flags & match_continuous) ? regbase::restart_continue : e.restart_type();
if(type == regbase::restart_buf)
return cmatches;
switch(type)
{
case regbase::restart_lit:
case regbase::restart_fixed_lit:
{
const kmp_info<charT>* info = e.get_kmp();
int len = info->len;
const charT* x = info->pstr;
int j = 0;
bool icase = e.flags() & regbase::icase;
while (first != last)
{
while((j > -1) && (x[j] != traits::translate(*first, icase MAYBE_PASS_LOCALE(locale_inst))))
j = info->kmp_next[j];
__inc_one(clines, last_line, first);
++j;
if(j >= len)
{
if(type == regbase::restart_fixed_lit)
{
__skip_and_dec(clines, last_line, first, base, j);
restart = first;
restart += len;
m.set_first(first);
m.set_second(restart);
m.set_line(clines, last_line);
++cmatches;
if(foo(m) == false)
return cmatches;
__skip_and_inc(clines, last_line, first, restart);
next_base = m[0].second;
pd.temp_match.init_fail(next_base, last);
m.init_fail(next_base, last);
j = 0;
}
else
{
restart = first;
__skip_and_dec(clines, last_line, first, base, j);
if(query_match_aux(first, last, m, e, flags, pd, &restart))
{
m.set_line(clines, last_line);
++cmatches;
if(foo(m) == false)
return cmatches;
// update to end of what matched
__skip_and_inc(clines, last_line, first, m[0].second);
next_base = m[0].second;
pd.temp_match.init_fail(next_base, last);
m.init_fail(next_base, last);
j = 0;
}
else
{
for(int k = 0; (restart != first) && (k < j); ++k, --restart);
if(restart != last)
++restart;
__skip_and_inc(clines, last_line, first, restart);
j = 0; //we could do better than this...
}
}
}
}
break;
}
case regbase::restart_any:
{
while(first != last)
{
if( reg_expression<charT, traits, A>::can_start(*first, __map, (unsigned char)mask_any, width_type()) )
{
if(query_match_aux(first, last, m, e, flags, pd, &restart))
{
m.set_line(clines, last_line);
++cmatches;
if(foo(m) == false)
return cmatches;
// update to end of what matched
// trying to match again with match_not_null set if this
// is a null match...
need_init = true;
if(first == m[0].second)
{
next_base = m[0].second;
pd.temp_match.init_fail(next_base, last);
m.init_fail(next_base, last);
if(query_match_aux(first, last, m, e, flags | match_not_null, pd, &restart))
{
m.set_line(clines, last_line);
++cmatches;
if(foo(m) == false)
return cmatches;
}
else
{
need_init = false;
for(unsigned int i = 0; (restart != first) && (i < e.leading_length()); ++i, --restart);
if(restart != last)
++restart;
__skip_and_inc(clines, last_line, first, restart);
}
}
if(need_init)
{
__skip_and_inc(clines, last_line, first, m[0].second);
next_base = m[0].second;
pd.temp_match.init_fail(next_base, last);
m.init_fail(next_base, last);
}
continue;
}
else
{
for(unsigned int i = 0; (restart != first) && (i < e.leading_length()); ++i, --restart);
if(restart != last)
++restart;
__skip_and_inc(clines, last_line, first, restart);
}
}
else
__inc_one(clines, last_line, first);
}
}
break;
case regbase::restart_word:
{
// do search optimised for word starts:
while(first != last)
{
--first;
if(*first == '\n')
--clines;
// skip the word characters:
while((first != last) && traits::is_class(*first, char_class_word MAYBE_PASS_LOCALE(locale_inst)))
++first;
// now skip the white space:
while((first != last) && (traits::is_class(*first, char_class_word MAYBE_PASS_LOCALE(locale_inst)) == false))
__inc_one(clines, last_line, first);
if(first == last)
break;
if( reg_expression<charT, traits, A>::can_start(*first, __map, (unsigned char)mask_any, width_type()) )
{
if(query_match_aux(first, last, m, e, flags, pd, &restart))
{
m.set_line(clines, last_line);
++cmatches;
if(foo(m) == false)
return cmatches;
// update to end of what matched
// trying to match again with match_not_null set if this
// is a null match...
need_init = true;
if(first == m[0].second)
{
next_base = m[0].second;
pd.temp_match.init_fail(next_base, last);
m.init_fail(next_base, last);
if(query_match_aux(first, last, m, e, flags | match_not_null, pd, &restart))
{
m.set_line(clines, last_line);
++cmatches;
if(foo(m) == false)
return cmatches;
}
else
{
need_init = false;
for(unsigned int i = 0; (restart != first) && (i < e.leading_length()); ++i, --restart);
if(restart != last)
++restart;
__skip_and_inc(clines, last_line, first, restart);
}
}
if(need_init)
{
__skip_and_inc(clines, last_line, first, m[0].second);
next_base = m[0].second;
pd.temp_match.init_fail(next_base, last);
m.init_fail(next_base, last);
}
}
else
{
for(unsigned int i = 0; (restart != first) && (i < e.leading_length()); ++i, --restart);
if(restart != last)
++restart;
__skip_and_inc(clines, last_line, first, restart);
}
}
else
__inc_one(clines, last_line, first);
}
}
break;
case regbase::restart_line:
{
// do search optimised for line starts:
while(first != last)
{
// find first charcter after a line break:
--first;
if(*first == '\n')
--clines;
while((first != last) && (*first != '\n'))
++first;
if(first == last)
break;
++first;
if(first == last)
break;
++clines;
last_line = first;
if( reg_expression<charT, traits, A>::can_start(*first, __map, (unsigned char)mask_any, width_type()) )
{
if(query_match_aux(first, last, m, e, flags, pd, &restart))
{
m.set_line(clines, last_line);
++cmatches;
if(foo(m) == false)
return cmatches;
// update to end of what matched
// trying to match again with match_not_null set if this
// is a null match...
need_init = true;
if(first == m[0].second)
{
next_base = m[0].second;
pd.temp_match.init_fail(next_base, last);
m.init_fail(next_base, last);
if(query_match_aux(first, last, m, e, flags | match_not_null, pd, &restart))
{
m.set_line(clines, last_line);
++cmatches;
if(foo(m) == false)
return cmatches;
}
else
{
need_init = false;
for(unsigned int i = 0; (restart != first) && (i < e.leading_length()); ++i, --restart);
if(restart != last)
++restart;
__skip_and_inc(clines, last_line, first, restart);
}
}
if(need_init)
{
__skip_and_inc(clines, last_line, first, m[0].second);
next_base = m[0].second;
pd.temp_match.init_fail(next_base, last);
m.init_fail(next_base, last);
}
}
else
{
for(unsigned int i = 0; (restart != first) && (i < e.leading_length()); ++i, --restart);
if(restart != last)
++restart;
__skip_and_inc(clines, last_line, first, restart);
}
}
else
__inc_one(clines, last_line, first);
}
}
break;
case regbase::restart_continue:
{
while(first != last)
{
if( reg_expression<charT, traits, A>::can_start(*first, __map, (unsigned char)mask_any, width_type()) )
{
if(query_match_aux(first, last, m, e, flags, pd, &restart))
{
m.set_line(clines, last_line);
++cmatches;
if(foo(m) == false)
return cmatches;
// update to end of what matched
// trying to match again with match_not_null set if this
// is a null match...
if(first == m[0].second)
{
next_base = m[0].second;
pd.temp_match.init_fail(next_base, last);
m.init_fail(next_base, last);
if(query_match_aux(first, last, m, e, flags | match_not_null, pd, &restart))
{
m.set_line(clines, last_line);
++cmatches;
if(foo(m) == false)
return cmatches;
}
else
return cmatches; // can't continue from null match
}
__skip_and_inc(clines, last_line, first, m[0].second);
next_base = m[0].second;
pd.temp_match.init_fail(next_base, last);
m.init_fail(next_base, last);
continue;
}
}
return cmatches;
}
}
break;
}
// finally check trailing null string:
if(e.first()->can_be_null)
{
if(query_match_aux(first, last, m, e, flags, pd, &restart))
{
m.set_line(clines, last_line);
++cmatches;
if(foo(m) == false)
return cmatches;
}
}
return cmatches;
}
#if defined(JM_NO_TEMPLATE_SWITCH_MERGE) && !defined(JM_NO_NAMESPACES)
} // namespace
#endif
template <class iterator, class Allocator, class charT, class traits, class Allocator2>
bool reg_search(iterator first, iterator last, reg_match<iterator, Allocator>& m, const reg_expression<charT, traits, Allocator2>& e, unsigned flags = match_default)
{
if(e.flags() & regbase::failbit)
return false;
typedef typename traits::size_type traits_size_type;
typedef typename traits::uchar_type traits_uchar_type;
// prepare m for failure:
if((flags & match_init) == 0)
{
m.set_size(e.mark_count(), first, last);
}
flags |= match_init;
return reg_grep2(grep_search_predicate<iterator, Allocator>(&m), first, last, e, flags, m.allocator());
}
//
// reg_search convenience interfaces:
#ifndef JM_NO_PARTIAL_FUNC_SPEC
//
// this isn't really a partial specialisation, but template function
// overloading - if the compiler doesn't support partial specialisation
// then it really won't support this either:
template <class charT, class Allocator, class traits, class Allocator2>
inline bool reg_search(const charT* str,
reg_match<const charT*, Allocator>& m,
const reg_expression<charT, traits, Allocator2>& e,
unsigned flags = match_default)
{
return reg_search(str, str + traits::length(str), m, e, flags);
}
#ifndef JM_NO_STRING_H
template <class ST, class SA, class Allocator, class charT, class traits, class Allocator2>
inline bool reg_search(const __JM_STD::basic_string<charT, ST, SA>& s,
reg_match<typename __JM_STD::basic_string<charT, ST, SA>::const_iterator, Allocator>& m,
const reg_expression<charT, traits, Allocator2>& e,
unsigned flags = match_default)
{
return reg_search(s.begin(), s.end(), m, e, flags);
}
#endif
#else // partial specialisation
inline bool reg_search(const char* str,
cmatch& m,
const regex& e,
unsigned flags = match_default)
{
return reg_search(str, str + regex::traits_type::length(str), m, e, flags);
}
#ifndef JM_NO_WCSTRING
inline bool reg_search(const wchar_t* str,
wcmatch& m,
const wregex& e,
unsigned flags = match_default)
{
return reg_search(str, str + wregex::traits_type::length(str), m, e, flags);
}
#endif
#ifndef JM_NO_STRING_H
inline bool reg_search(const __JM_STD::string& s,
reg_match<__JM_STD::string::const_iterator, regex::alloc_type>& m,
const regex& e,
unsigned flags = match_default)
{
return reg_search(s.begin(), s.end(), m, e, flags);
}
#if !defined(JM_NO_STRING_DEF_ARGS) && !defined(JM_NO_WCSTRING)
inline bool reg_search(const __JM_STD::basic_string<wchar_t>& s,
reg_match<__JM_STD::basic_string<wchar_t>::const_iterator, wregex::alloc_type>& m,
const wregex& e,
unsigned flags = match_default)
{
return reg_search(s.begin(), s.end(), m, e, flags);
}
#endif
#endif
#endif
//
// reg_grep:
// find all non-overlapping matches within the sequence first last:
//
template <class Predicate, class iterator, class charT, class traits, class Allocator>
inline unsigned int reg_grep(Predicate foo, iterator first, iterator last, const reg_expression<charT, traits, Allocator>& e, unsigned flags = match_default)
{
return reg_grep2(foo, first, last, e, flags, e.allocator());
}
//
// reg_grep convenience interfaces:
#ifndef JM_NO_PARTIAL_FUNC_SPEC
//
// this isn't really a partial specialisation, but template function
// overloading - if the compiler doesn't support partial specialisation
// then it really won't support this either:
template <class Predicate, class charT, class Allocator, class traits>
inline bool reg_grep(Predicate foo, const charT* str,
const reg_expression<charT, traits, Allocator>& e,
unsigned flags = match_default)
{
return reg_grep(foo, str, str + traits::length(str), e, flags);
}
#ifndef JM_NO_STRING_H
template <class Predicate, class ST, class SA, class Allocator, class charT, class traits>
inline bool reg_grep(Predicate foo, const __JM_STD::basic_string<charT, ST, SA>& s,
const reg_expression<charT, traits, Allocator>& e,
unsigned flags = match_default)
{
return reg_grep(foo, s.begin(), s.end(), e, flags);
}
#endif
#else // partial specialisation
inline bool reg_grep(bool (*foo)(const cmatch&), const char* str,
const regex& e,
unsigned flags = match_default)
{
return reg_grep(foo, str, str + regex::traits_type::length(str), e, flags);
}
#ifndef JM_NO_WCSTRING
inline bool reg_grep(bool (*foo)(const wcmatch&), const wchar_t* str,
const wregex& e,
unsigned flags = match_default)
{
return reg_grep(foo, str, str + wregex::traits_type::length(str), e, flags);
}
#endif
#ifndef JM_NO_STRING_H
inline bool reg_grep(bool (*foo)(const reg_match<__JM_STD::string::const_iterator, regex::alloc_type>&), const __JM_STD::string& s,
const regex& e,
unsigned flags = match_default)
{
return reg_grep(foo, s.begin(), s.end(), e, flags);
}
#if !defined(JM_NO_STRING_DEF_ARGS) && !defined(JM_NO_WCSTRING)
inline bool reg_grep(bool (*foo)(const reg_match<__JM_STD::basic_string<wchar_t>::const_iterator, wregex::alloc_type>&),
const __JM_STD::basic_string<wchar_t>& s,
const wregex& e,
unsigned flags = match_default)
{
return reg_grep(foo, s.begin(), s.end(), e, flags);
}
#endif
#endif
#endif
//
// finally for compatablity with version 1.x of the library
// we need a form of reg_grep that takes an output iterator
// as its first argument:
//
//
// struct grep_match:
// stores what matched during a reg_grep,
// the output iterator type passed to reg_grep must have an
// operator*() that returns a type with an
// operator=(const grep_match<iterator, Allocator>&);
//
template <class iterator, class Allocator>
struct grep_match
{
unsigned int line;
iterator line_start;
reg_match<iterator, Allocator> what;
grep_match(Allocator a = Allocator()) : what(a) {}
grep_match(unsigned int l, iterator p1, const reg_match<iterator, Allocator>& m)
: what(m) { line = l; line_start = p1; }
bool operator == (const grep_match& )
{ return false; }
bool operator < (const grep_match&)
{ return false; }
};
template <class O, class I, class A>
struct grep_adaptor
{
O oi;
reg_match<I, A> m;
grep_adaptor(O i, A a) : m(a), oi(i) {}
bool operator()(const reg_match_base<I, A>& w)
{
m.what = w;
m.line = w.line();
m.line_start = w.line_start();
*oi = m;
++oi;
return true;
}
};
template <class Out, class iterator, class charT, class traits, class Allocator>
inline unsigned int reg_grep_old(Out oi, iterator first, iterator last, const reg_expression<charT, traits, Allocator>& e, unsigned flags = match_default)
{
return reg_grep2(grep_adaptor<Out, iterator, Allocator>(oi, e.allocator()), first, last, e, flags, e.allocator());
}
JM_END_NAMESPACE // namespace regex
#endif // __REGMATCH_H