*

****************************************************************************/

# if defined(BOOST_REGEX_SOURCE)

# define BOOST_REGEX_BUILD_DLL

# else

# endif

# define BOOST_REGEX_DECL

#endif

# define BOOST_REGEX_USE_CPP_LOCALE

#endif

/* Win32 defaults to native Win32 locale: */

#if defined(_WIN32) && !defined(BOOST_REGEX_USE_WIN32_LOCALE) && !defined(BOOST_REGEX_USE_C_LOCALE) && !defined(BOOST_REGEX_USE_CPP_LOCALE) && !defined(BOOST_REGEX_NO_W32)

# define BOOST_REGEX_USE_WIN32_LOCALE

#include <boost/mpl/int_fwd.hpp>

#include <bitset>

namespace boost{

} // namespace boost.

#include <boost/regex/v4/u32regex_iterator.hpp>

#include <boost/regex/v4/u32regex_token_iterator.hpp>

typedef std::map<Key, list_iterator> map_type;

typedef typename map_type::iterator map_iterator;

typedef typename list_type::size_type size_type;

private:

struct data

{

};

template <class Key, class Object>

{

#ifdef BOOST_HAS_THREADS

static boost::static_mutex mut = BOOST_STATIC_MUTEX_INIT;

boost::static_mutex::scoped_lock l(mut);

if(l)

{

}

//

// what do we do if the lock fails?

return boost::shared_ptr<Object>();

#endif

#else

#endif

}

template <class Key, class Object>

{

typedef typename object_cache<Key, Object>::data object_data;

typedef typename map_type::size_type map_size_type;

BOOST_ASSERT(s_data.index[k]->first.get() == result.get());

BOOST_ASSERT(&(s_data.index.find(k)->first) == s_data.cont.back().second);

BOOST_ASSERT(s_data.index.find(k)->first == k);

{

//

// We have too many items in the list, so we need to start

//

list_iterator pos = s_data.cont.begin();

list_iterator last = s_data.cont.end();

{

if(pos->first.unique())

{

public:

scoped_static_mutex_lock(static_mutex& mut, bool lk = true);

~scoped_static_mutex_lock();

void lock();

void unlock();

private:

scoped_static_mutex_lock& operator=(const scoped_static_mutex_lock&);

};

} // namespace

#else

if(first != last)

{

I next = last - 1;

{

(next-1)->swap(*next);

--next;

}

}

template <class Iterator>

{

std::size_t r = boost::hash_range(i, j);

r %= ((std::numeric_limits<int>::max)() - 10001);

r += 10000;

}

{

struct name

{

name(const charT* i, const charT* j, int idx)

{

hash = hash_value_from_capture_name(i, j);

}

: index(idx), hash(h)

{

}

int index;

bool operator < (const name& other)const

{

}

bool operator == (const name& other)const

{

}

void swap(name& other)

{

std::swap(index, other.index);

std::swap(hash, other.hash);

}

};

named_subexpressions(){}

void set_name(const charT* i, const charT* j, int index)

{

m_sub_names.push_back(name(i, j, index));

bubble_down_one(m_sub_names.begin(), m_sub_names.end());

}

int get_id(const charT* i, const charT* j)const

{

name t(i, j, 0);

}

return -1;

}

{

name t(h, 0);

if((pos != m_sub_names.end()) && (*pos == t))

{

return pos->index;

}

return -1;

}

{

}

};

//

// class regex_data:

// represents the data we wish to expose to the matching algorithms.

//

template <class charT, class traits>

{

typedef regex_constants::syntax_option_type flag_type;

typedef std::size_t size_type;

BOOST_ASSERT(0 != m_pimpl.get());

return m_pimpl->get_data();

}

{

return m_pimpl;

}

case syntax_element_assert_backref:

{

// just check that the index is valid:

{

{

{

// check of sub-expression that doesn't exist:

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

{

bool ok = false;

re_syntax_base* p = base;

while(p)

{

{

//

// We've found the target of the recursion, set the jump target:

next_rep_id = static_cast<re_repeat*>(p)->state_id;

break;

case syntax_element_endmark:

next_rep_id = -1;

break;

default:

case syntax_element_jump:

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

continue;

default:

break;

}

#endif

#endif

return false;

}

// maybe have \g{ddd}

{

if(++m_position == m_end)

{

return false;

}

have_brace = true;

}

negative = (*m_position == static_cast<charT>('-'));

if((negative) && (++m_position == m_end))

}

const charT* pc = m_position;

int i = this->m_traits.toi(pc, m_end, 10);

{

const charT* base = m_position;

++m_position;

pc = m_position;

}

if(negative)

i = 1 + m_mark_count - i;

{

m_position = pc;

re_brace* pb = static_cast<re_brace*>(this->append_state(syntax_element_backref, sizeof(re_brace)));

m_position = pc;

if(have_brace)

{

{

fail(regex_constants::error_escape, m_position - m_base, incomplete_message);

return false;

//

if(pocessive)

{

re_brace* pb = static_cast<re_brace*>(this->insert_state(insert_point, syntax_element_startmark, sizeof(re_brace)));

pb->index = -3;

pb->icase = this->flags() & regbase::icase;

m_has_case_change = false;

charT name_delim;

int mark_reset = m_mark_reset;

m_mark_reset = -1;

int v;

//

// select the actual extension used:

m_mark_count = m_max_mark;

}

m_mark_reset = mark_reset;

if(markid > 0)

#ifdef BOOST_MSVC

#pragma warning(push)

#endif

namespace boost{

bool cpp_regex_traits_implementation<charT>::isctype(const charT c, char_class_type mask) const

{

return

|| ((mask & ::boost::re_detail::char_class_word) && (c == '_'))

|| ((mask & ::boost::re_detail::char_class_unicode) && ::boost::re_detail::is_extended(c))

|| ((mask & ::boost::re_detail::char_class_vertical_space) && (is_separator(c) || (c == '\v')))

}

#endif

#undef BOOST_REGEX_TEMPLATE_DECL

# ifndef BOOST_REGEX_INSTANTIATE

# endif

#if !defined(BOOST_NO_STD_LOCALE) && !defined(BOOST_REGEX_ICU_INSTANCES)

namespace re_detail{

class named_subexpressions;

}

typedef typename re_detail::regex_iterator_traits<

BidiIterator>::value_type char_type;

typedef std::basic_string<char_type> string_type;

// construct/copy/destroy:

explicit match_results(const Allocator& a = Allocator())

//

const_reference named_subexpression(const char_type* i, const char_type* j) const

{

if(m_is_singular)

raise_logic_error();

}

template <class charT>

const_reference named_subexpression(const charT* i, const charT* j) const

}

int named_subexpression_index(const char_type* i, const char_type* j) const

{

if(m_is_singular)

raise_logic_error();

}

template <class charT>

int named_subexpression_index(const charT* i, const charT* j) const

std::swap(m_subs, that.m_subs);

std::swap(m_named_subs, that.m_named_subs);

std::swap(m_last_closed_paren, that.m_last_closed_paren);

if(m_is_singular)

{

if(!that.m_is_singular)

std::swap(m_base, that.m_base);

std::swap(m_null, that.m_null);

}

}

bool operator==(const match_results& that)const

{

void BOOST_REGEX_CALL set_second(BidiIterator i, size_type pos, bool m = true, bool escape_k = false)

{

if(pos)

pos += 2;

BOOST_ASSERT(m_subs.size() > pos);

m_subs[pos].second = i;

{

typedef typename Results::value_type value_type;

typedef typename value_type::iterator iterator;

const re_syntax_base* preturn_address;

Results results;

repeater_count<iterator>* repeater_stack;

BidiIterator l_base)

: m_result(what), base(first), last(end),

position(first), backstop(l_base), re(e), traits_inst(e.get_traits()),

{

construct_init(e, f);

}

// matching flags in use:

match_flag_type m_match_flags;

// how many states we have examined so far:

// max number of states to examine before giving up:

// whether we should ignore case or not:

bool icase;

// set to true when (position == last), indicates that we may have a partial match:

// the bitmask to use when determining whether a match_any matches a newline or not:

unsigned char match_any_mask;

// recursion information:

#ifdef BOOST_REGEX_NON_RECURSIVE

//

void push_repeater_count(int i, repeater_count<BidiIterator>** s);

void push_single_repeat(std::size_t c, const re_repeat* r, BidiIterator last_position, int state_id);

void push_non_greedy_repeat(const re_syntax_base* ps);

void push_recursion_pop();

// pointer to base of stack:

//

// Calculate NS^2 first:

//

if(dist == 0)

dist = 1;

if(states == 0)

states = 1;

states *= states;

{

return;

}

states *= dist;

{

return;

}

states += k;

// Now calculate N^2:

//

states = dist;

{

return;

}

states *= dist;

{

return;

}

states += k;

m_match_flags |= regex_constants::match_all;

m_presult->set_size((m_match_flags & match_nosubs) ? 1 : re.mark_count(), search_base, last);

m_presult->set_base(base);

if(m_match_flags & match_posix)

m_result = *m_presult;

verify_options(re.flags(), m_match_flags);

pstate = re.get_first_state();

m_presult->set_size((m_match_flags & match_nosubs) ? 1 : re.mark_count(), base, last);

m_presult->set_base(base);

m_match_flags |= regex_constants::match_init;

}

else

// in the match, this is in line with ECMAScript, but not Perl

// or PCRE.

//

while(i != j)

{

if((position == last) || (traits_inst.translate(*position, icase) != traits_inst.translate(*i, icase)))

{

// return true if marked sub-expression N has been matched:

int index = static_cast<const re_brace*>(pstate)->index;

if(index == 9999)

{

// Magic value for a (DEFINE) block:

}

else if(index > 0)

{

// Check if index is a hash value:

if(index >= 10000)

pstate = pstate->next.p;

}

else

{

// Have we recursed into subexpression "index"?

// If index == 0 then check for any recursion at all, otherwise for recursion to -index-1.

pstate = pstate->next.p;

}

return result;

template <class Results>

struct saved_recursion : public saved_state

{

{}

int recursion_id;

const re_syntax_base* preturn_address;

}

template <class BidiIterator, class Allocator, class traits>

{

saved_recursion<results_type>* pmp = static_cast<saved_recursion<results_type>*>(m_backup_state);

--pmp;

pmp = static_cast<saved_recursion<results_type>*>(m_backup_state);

--pmp;

}

m_backup_state = pmp;

}

//

// Set new call stack:

//

{

}

if(static_cast<const re_recurse*>(pstate)->state_id > 0)

{

push_repeater_count(static_cast<const re_recurse*>(pstate)->state_id, &next_count);

}

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

return true;

}

{

m_presult->set_second(position, index);

}

{

{

}

}

}

template <class BidiIterator, class Allocator, class traits>

bool perl_matcher<BidiIterator, Allocator, traits>::match_match()

{

{

return true;

}

if((m_match_flags & match_not_null) && (position == (*m_presult)[0].first))

saved_recursion<results_type>* pmp = static_cast<saved_recursion<results_type>*>(m_backup_state);

if(!r)

{

}

boost::re_detail::inplace_destroy(pmp++);

m_backup_state = pmp;

saved_state* pmp = static_cast<saved_state*>(m_backup_state);

if(!r)

{

}

boost::re_detail::inplace_destroy(pmp++);

m_backup_state = pmp;

BidiIterator saved_position = position;

const re_syntax_base* next_pstate = static_cast<const re_jump*>(pstate->next.p)->alt.p->next.p;

pstate = pstate->next.p->next.p;

position = saved_position;

if(negated)

pstate = next_pstate;

else

pstate = alt->alt.p;

//

// Set new call stack:

//

{

}

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

repeater_count<BidiIterator>* saved = next_count;

repeater_count<BidiIterator> r(&next_count); // resets all repeat counts since we're recursing and starting fresh on those

if(!result)

{

return false;

}

return true;

{

m_presult->set_second(position, index);

}

{

{

repeater_count<BidiIterator>* saved_count = next_count;

next_count = saved.repeater_stack;

*m_presult = saved.results;

if(!match_all_states())

{

next_count = saved_count;

return false;

}

template <class BidiIterator, class Allocator, class traits>

bool perl_matcher<BidiIterator, Allocator, traits>::match_match()

{

{

if(!match_all_states())

{

return false;

}

return true;

#ifndef BOOST_NO_SFINAE

#include <boost/mpl/has_xxx.hpp>

#endif

namespace boost{

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

return get_named_sub_index(i, j, tag_type());

}

inline int toi(ForwardIter& i, ForwardIter j, int base, const boost::mpl::false_&)

{

if(i != j)

}

return -1;

}

inline int toi(ForwardIter& i, ForwardIter j, int base, const boost::mpl::true_&)

{

return m_traits.toi(i, j, base);

m_position = --base;

}

}

break;

case '{':

have_brace = true;

if(have_brace && (*m_position == '^'))

++m_position;

if((max_len >= 5) && std::equal(m_position, m_position + 5, MATCH))

{

return false;

}

}

return true;

}

if((max_len >= 20) && std::equal(m_position, m_position + 20, LAST_SUBMATCH_RESULT))

// F must be a pointer, a function, or a class with a function call operator:

//

BOOST_STATIC_ASSERT((::boost::is_pointer<F>::value || ::boost::is_function<F>::value || ::boost::is_class<F>::value));

static M m;

static O out;

static boost::regex_constants::match_flag_type flags;

template <class OutputIter>

OutputIter operator()(const Match& m, OutputIter i, boost::regex_constants::match_flag_type f)

{

}

template <class OutputIter, class Traits>

OutputIter operator()(const Match& m, OutputIter i, boost::regex_constants::match_flag_type f, const Traits&)

template <class OutputIter>

OutputIter operator()(const Match& m, OutputIter i, boost::regex_constants::match_flag_type /*f*/)

{

}

template <class OutputIter, class Traits>

OutputIter operator()(const Match& m, OutputIter i, boost::regex_constants::match_flag_type f, const Traits&)

template <class OutputIter>

OutputIter operator()(const Match& m, OutputIter i, boost::regex_constants::match_flag_type /*f*/)

{

}

template <class OutputIter, class Traits>

OutputIter operator()(const Match& m, OutputIter i, boost::regex_constants::match_flag_type f, const Traits&)

{

return stdext::unchecked_equal(first, last, with);

}

#else

using std::copy;

using std::equal;

template <class T, class A>

operator std::basic_string<value_type, T, A> ()const

{

}

#else

operator std::basic_string<value_type> ()const

#endif

difference_type BOOST_REGEX_CALL length()const

{

return n;

}

std::basic_string<value_type> str()const

{

std::basic_string<value_type> result;

{

}

return result;

}

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, int submatch = 0, 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, int submatch = 0, regex_constants::match_flag_type m = regex_constants::match_default)

{

return u32regex_token_iterator<const UChar*>(s.getBuffer(), s.getBuffer() + s.length(), e, submatch, m);

}

# pragma warning(pop)

#endif

#ifdef BOOST_HAS_ABI_HEADERS