/*

*

*

* Distributed under the Boost Software License, Version 1.0.

* (See accompanying file LICENSE_1_0.txt or copy at

namespace boost{

#ifdef BOOST_MSVC

#pragma warning(push)

#endif

namespace re_detail{

std::pair<const_iterator, const_iterator> BOOST_REGEX_CALL subexpression(std::size_t n)const

{

if(n == 0)

const std::pair<std::size_t, std::size_t>& pi = this->m_subs.at(n - 1);

std::pair<const_iterator, const_iterator> p(expression() + pi.first, expression() + pi.second);

return p;

// begin, end:

const_iterator BOOST_REGEX_CALL begin()const

{

}

const_iterator BOOST_REGEX_CALL end()const

{

}

flag_type BOOST_REGEX_CALL flags()const

{

typedef typename traits::string_type seq_type;

seq_type a(arg_first, arg_last);

if(a.size())

else

assign(static_cast<const charT*>(0), static_cast<const charT*>(0), f);

}

std::pair<const_iterator, const_iterator> BOOST_REGEX_CALL subexpression(std::size_t n)const

{

if(!m_pimpl.get())

return m_pimpl->subexpression(n);

}

const_iterator BOOST_REGEX_CALL begin()const

public:

typedef digraph<charT> digraph_type;

typedef typename traits::string_type string_type;

basic_char_set()

{

}

m_empty = false;

}

{

m_classes |= m;

m_empty = false;

}

{

m_negated_classes |= m;

m_empty = false;

{

return m_equivalents.end();

}

{

return m_classes;

}

{

return m_negated_classes;

}

std::vector<digraph_type> m_ranges; // a list of end points of our ranges

bool m_negate; // true if the set is to be negated

bool m_has_digraphs; // true if we have digraphs present

bool m_empty; // whether we've added anything yet

std::vector<digraph_type> m_equivalents; // a list of equivalence classes

};

unsigned m_backrefs; // bitmask of permitted backrefs

boost::uintmax_t m_bad_repeats; // bitmask of repeats we can't deduce a startmap for;

bool m_has_recursions; // set when we have recursive expresisons to fixup

typename traits::char_class_type m_word_mask; // mask used to determine if a character is a word character

typename traits::char_class_type m_mask_space; // mask used to determine if a character is a word character

typename traits::char_class_type m_lower_mask; // mask used to determine if a character is a lowercase character

{

typedef typename traits::string_type string_type;

typedef typename basic_char_set<charT, traits>::list_iterator item_iterator;

//

// fill in the basics:

//

//

// finally reset the address of our last state:

//

return result;

}

template<class T>

inline bool char_less(T t1, T t2)

{

return t1 < t2;

}

{

return static_cast<unsigned char>(t1) < static_cast<unsigned char>(t2);

}

{

return static_cast<unsigned char>(t1) < static_cast<unsigned char>(t2);

}

template <class charT, class traits>

re_syntax_base* basic_regex_creator<charT, traits>::append_set(

}

else

{

{

// Oops error:

return 0;

//

// and now the classes:

//

if(flags() & regbase::icase)

{

// adjust m as needed:

m_pdata->m_can_be_null = 0;

m_bad_repeats = 0;

create_startmap(m_pdata->m_first_state, m_pdata->m_startmap, &(m_pdata->m_can_be_null), mask_all);

// get the restart type:

m_pdata->m_restart_type = get_restart_type(m_pdata->m_first_state);

state = state->next.p;

}

}

// now work through our list, building all the maps as we go:

while(v.size())

{

const std::pair<bool, re_syntax_base*>& p = v.back();

m_icase = p.first;

state = p.second;

m_bad_repeats = 0;

create_startmap(state->next.p, static_cast<re_alt*>(state)->_map, &static_cast<re_alt*>(state)->can_be_null, mask_take);

m_bad_repeats = 0;

create_startmap(static_cast<re_alt*>(state)->alt.p, static_cast<re_alt*>(state)->_map, &static_cast<re_alt*>(state)->can_be_null, mask_skip);

// adjust the type of the state to allow for faster matching:

state->type = this->get_repeat_type(state);

template <class charT, class traits>

int basic_regex_creator<charT, traits>::calculate_backstep(re_syntax_base* state)

{

int result = 0;

while(state)

{

state = rep->alt.p;

continue;

}

{

BOOST_ASSERT(rep->next.p->type == syntax_element_long_set);

return -1;

if(rep->max != rep->min)

return -1;

}

return -1;

case syntax_element_long_set:

return -1;

result += 1;

break;

if(l_map)

{

l_map[0] |= mask_init;

l_map[0x85] |= mask;

}

// now figure out if we can match a NULL string at this point:

}

case syntax_element_recurse:

{

{

// Infinite recursion!!

if(0 == this->m_pdata->m_status) // update the error code if not already set

recursion_start = state;

recursion_restart = state->next.p;

state = static_cast<re_jump*>(state)->alt.p;

break;

}

// fall through, can't handle nested recursion here...

}

case syntax_element_backref:

case syntax_element_long_set:

if(l_map)

{

{

l_map[0] |= mask_init;

for(unsigned int i = 0; i < (1u << CHAR_BIT); ++i)

{

charT c = static_cast<charT>(i);

l_map[i] |= mask;

}

}

if(l_map)

{

l_map[0] |= mask_init;

}

if(pnull)

*pnull |= mask;

re_syntax_base* p = m_pdata->m_first_state;

while(p)

{

{

re_brace* p2 = static_cast<re_brace*>(static_cast<re_jump*>(p)->alt.p);

if((p2->type == syntax_element_startmark) && (p2->index == static_cast<re_brace*>(state)->index))

template <class charT, class traits>

syntax_element_type basic_regex_creator<charT, traits>::get_repeat_type(re_syntax_base* state)

{

if(state->type == syntax_element_rep)

{

// check to see if we are repeating a single state:

case re_detail::syntax_element_set:

return re_detail::syntax_element_short_set_rep;

case re_detail::syntax_element_long_set:

return re_detail::syntax_element_long_set_rep;

break;

default:

this->m_pdata->m_status = error_code;

m_position = m_end; // don't bother parsing anything else

//

// Augment error message with the regular expression text:

//

if(error_code != regex_constants::error_empty)

{

if((start_pos != 0) || (end_pos != (m_end - m_base)))

else

if(start_pos != end_pos)

{

message += std::string(m_base + start_pos, m_base + position);

}

message += "'.";

}

#ifndef BOOST_NO_EXCEPTIONS

if(0 == (this->flags() & regex_constants::no_except))

bool basic_regex_parser<charT, traits>::parse_extended_escape()

{

++m_position;

bool negate = false; // in case this is a character class escape: \w \d etc

switch(this->m_traits.escape_syntax_type(*m_position))

{

case regex_constants::escape_type_class:

{

escape_type_class_jump:

if(m != 0)

{

basic_char_set<charT, traits> char_set;

++m_position;

}

// for perl regexes only check for pocessive ++ repeats.

&& (this->m_traits.syntax_type(*m_position) == regex_constants::syntax_plus))

{

pocessive = true;

{

//

// Check for illegal following quantifier, we have to do this here, because

//

switch(this->m_traits.syntax_type(*m_position))

{

case regex_constants::syntax_star:

case regex_constants::syntax_plus:

case regex_constants::syntax_question:

fail(regex_constants::error_badrepeat, m_position - m_base);

return false;

}

++name_first;

negated = true;

}

if(m == 0)

{

if(char_set.empty() && (name_last - name_first == 1))

return false;

}

v = this->m_traits.toi(m_position, m_end, 10);

if(*m_position == charT('R'))

{

if(++m_position == m_end)

this->m_pdata->m_data.align();

re_jump* jmp = static_cast<re_jump*>(this->getaddress(jump_offset));

jmp->alt.i = this->m_pdata->m_data.size() - this->getoffset(jmp);

{

// Rewind to start of (? sequence:

--m_position;

while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position;

}

}

while(!breakout);

if(*m_position == static_cast<charT>('-'))

{

/*

*

*

* Use, modification and distribution are subject to the

* Boost Software License, Version 1.0. (See accompanying file

// however at least one std lib will always throw

// std::bad_alloc for certain arguments...

//

try{

//

// What we do here depends upon the format of the sort key returned by

// sort key returned by this->transform:

result.erase(i);

break;

}

}catch(...){}

while(result.size() && (charT(0) == *result.rbegin()))

result.erase(result.size() - 1);

if(result.empty())

// std::bad_alloc for certain arguments...

//

string_type result;

try{

result = this->m_pcollate->transform(p1, p2);

//

// Borland's STLPort version returns a NULL-terminated

result.erase(result.size() - 1);

#endif

BOOST_ASSERT(std::find(result.begin(), result.end(), charT(0)) == result.end());

}

catch(...)

{

}

return result;

}

# ifdef BOOST_MSVC

# pragma warning(push)

# endif

template class BOOST_REGEX_TEMPLATE_DECL basic_regex< BOOST_REGEX_CHAR_T BOOST_REGEX_TRAITS_T >;

namespace boost{

#ifdef BOOST_MSVC

#pragma warning(push)

#endif

namespace re_detail{

#ifdef BOOST_MSVC

#pragma warning(push)

#endif

template <class BidiIterator, class Allocator, class traits>

#ifdef __BORLANDC__

#pragma option push -w-8008 -w-8066 -w-8004

#endif

const re_repeat* rep = static_cast<const re_repeat*>(pstate);

std::size_t count = 0;

//

// start by working out how much we can skip:

template <class BidiIterator, class Allocator, class traits>

bool perl_matcher<BidiIterator, Allocator, traits>::unwind_long_set_repeat(bool r)

{

saved_single_repeat<BidiIterator>* pmp = static_cast<saved_single_repeat<BidiIterator>*>(m_backup_state);

// if we have a match, just discard this state:

const re_repeat* rep = pmp->rep;

std::size_t count = pmp->count;

pstate = rep->next.p;

position = pmp->last_position;

BOOST_ASSERT(rep->type == syntax_element_long_set_rep);

}

inline int toi(ForwardIter& i, ForwardIter j, int base)

{

typedef typename boost::is_convertible<ForwardIter, const char_type*&>::type tag_type;

return toi(i, j, base, tag_type());

}

const traits& m_traits; // the traits class for localised formatting operations

BOOST_MPL_HAS_XXX_TRAIT_DEF(const_iterator)

typedef char no_type;

typedef char (&unary_type)[2];

typedef char (&binary_type)[3];

// flags |= match_prev_avail;

BidirectionalIterator next_start = what[0].second;

match_flag_type f(flags);

f |= regex_constants::match_not_initial_null;

//if(base != next_start)

// f |= regex_constants::match_not_bob;

template <std::size_t N>

inline u32regex_token_iterator<const UChar*> make_u32regex_token_iterator(const UChar* p, const u32regex& e, const int (&submatch)[N], regex_constants::match_flag_type m = regex_constants::match_default)

{

}

#endif

template <class charT, class Traits, class Alloc, std::size_t N>

inline u32regex_token_iterator<typename std::basic_string<charT, Traits, Alloc>::const_iterator> make_u32regex_token_iterator(const std::basic_string<charT, Traits, Alloc>& p, const u32regex& e, const int (&submatch)[N], regex_constants::match_flag_type m = regex_constants::match_default)

{

typedef typename std::basic_string<charT, Traits, Alloc>::const_iterator iter_type;

}

template <std::size_t N>

inline u32regex_token_iterator<const UChar*> make_u32regex_token_iterator(const U_NAMESPACE_QUALIFIER UnicodeString& s, const u32regex& e, const int (&submatch)[N], regex_constants::match_flag_type m = regex_constants::match_default)

inline u32regex_token_iterator<typename std::basic_string<charT, Traits, Alloc>::const_iterator> make_u32regex_token_iterator(const std::basic_string<charT, Traits, Alloc>& p, const u32regex& e, const std::vector<int>& submatch, regex_constants::match_flag_type m = regex_constants::match_default)

{

typedef typename std::basic_string<charT, Traits, Alloc>::const_iterator iter_type;

}

inline u32regex_token_iterator<const UChar*> make_u32regex_token_iterator(const U_NAMESPACE_QUALIFIER UnicodeString& s, const u32regex& e, const std::vector<int>& submatch, regex_constants::match_flag_type m = regex_constants::match_default)

{