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

#if defined(_DEBUG) || defined(__MSVC_RUNTIME_CHECKS) || defined(_MANAGED) || defined(BOOST_REGEX_NO_FASTCALL)

# define BOOST_REGEX_CALL __cdecl

typedef u16_to_u32_iterator<BidiIterator, UChar32> conv_type;

typedef match_results<conv_type> match_type;

match_type what;

bool result = ::boost::regex_match(conv_type(first, first, last), conv_type(last, first, last), what, e, flags);

typedef u8_to_u32_iterator<BidiIterator, UChar32> conv_type;

typedef match_results<conv_type> match_type;

match_type what;

bool result = ::boost::regex_match(conv_type(first, first, last), conv_type(last, first, last), what, e, flags);

typedef u16_to_u32_iterator<BidiIterator, UChar32> conv_type;

typedef match_results<conv_type> match_type;

match_type what;

bool result = ::boost::regex_search(conv_type(first, first, last), conv_type(last, first, last), what, e, flags, conv_type(base));

typedef u8_to_u32_iterator<BidiIterator, UChar32> conv_type;

typedef match_results<conv_type> match_type;

match_type what;

bool result = ::boost::regex_search(conv_type(first, first, last), conv_type(last, first, last), what, e, flags, conv_type(base));

{

return re_detail::extract_output_base

(

re_detail::do_regex_replace(

{

return re_detail::extract_output_base

(

re_detail::do_regex_replace(

{

return re_detail::extract_output_base

(

re_detail::do_regex_replace(

namespace boost{

#define BOOST_STATIC_MUTEX_INIT { PTHREAD_MUTEX_INITIALIZER, }

};

} // namespace boost

// dependencies so that build tools don't find them.

//

namespace boost{

void unlock();

private:

bool m_have_lock;

};

typedef boost::iterator_facade<u32_to_u16_iterator<BaseIterator, U16Type>, U16Type, std::bidirectional_iterator_tag, const U16Type> base_type;

typedef typename std::iterator_traits<BaseIterator>::value_type base_value_type;

BOOST_STATIC_CONSTANT(U32Type, pending_read = 0xffffffffu);

typedef typename std::iterator_traits<BaseIterator>::value_type base_value_type;

typedef boost::iterator_facade<u32_to_u8_iterator<BaseIterator, U8Type>, U8Type, std::bidirectional_iterator_tag, const U8Type> base_type;

typedef typename std::iterator_traits<BaseIterator>::value_type base_value_type;

BOOST_STATIC_CONSTANT(U32Type, pending_read = 0xffffffffu);

typedef typename std::iterator_traits<BaseIterator>::value_type base_value_type;

void increment()

{

// skip high surrogate first if there is one:

unsigned c = detail::utf8_byte_count(*m_position);

m_value = pending_read;

}

if((m_value & 0xC0u) == 0x80u)

invalid_sequence();

unsigned extra = detail::utf8_trailing_byte_count(*m_position);

// extract the extra bits, 6 from each extra byte:

++next;

m_value <<= 6;

m_value += static_cast<boost::uint8_t>(*next) & 0x3Fu;

}

};

m_value &= masks[extra];

if(m_value > static_cast<U32Type>(0x10FFFFu))

invalid_sequence();

}

BaseIterator m_position;

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

{

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

return p;

size_type BOOST_REGEX_CALL mark_count()const

{

}

const re_detail::re_syntax_base* get_first_state()const

digraph(charT c1, charT c2) : std::pair<charT, charT>(c1, c2)

{}

digraph(const digraph<charT>& d) : std::pair<charT, charT>(d.first, d.second){}

template <class Seq>

digraph(const Seq& s) : std::pair<charT, charT>()

charT* characters = static_cast<charT*>(static_cast<void*>(result+1));

characters[result->length] = m_traits.translate(c, m_icase);

}

return result;

{

// we need to transform our range into sort keys:

charT a1[3] = { c1.first, c1.second, charT(0), };

charT a2[3] = { c2.first, c2.second, charT(0), };

s1 = this->m_traits.transform(a1, (a1[1] ? a1+2 : a1+1));

s2 = this->m_traits.transform(a2, (a2[1] ? a2+2 : a2+1));

if(s1.size() == 0)

s1 = string_type(1, charT(0));

if(first->second)

{

charT cs[3] = { first->first, first->second, charT(0), };

s = m_traits.transform_primary(cs, cs+2);

}

else

// set the state_id of this repeat:

static_cast<re_repeat*>(state)->state_id = m_repeater_id++;

case syntax_element_alt:

std::memset(static_cast<re_alt*>(state)->_map, 0, sizeof(static_cast<re_alt*>(state)->_map));

static_cast<re_alt*>(state)->can_be_null = 0;

case syntax_element_jump:

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

default:

if(state->next.i)

}

}

default:

break;

}

}

default:

state = state->next.p;

}

m_recursion_checks[recursion_sub] = true;

}

case syntax_element_backref:

if(pnull)

*pnull |= mask;

case syntax_element_wild:

{

break;

}

default:

state = state->next.p;

m_bad_repeats |= (one << state_id);

}

default:

break;

if(this->m_has_backrefs == 0)

static_cast<re_repeat*>(state)->leading = true;

default:

return;

return true;

}

default:

result = parse_literal();

case 'w':

negate = false;

case 'W':

{

case 's':

negate = false;

case 'S':

return add_emacs_code(negate);

case regex_constants::escape_type_not_class:

negate = true;

case regex_constants::escape_type_class:

{

case regex_constants::escape_type_not_property:

negate = true;

case regex_constants::escape_type_property:

{

if(0 == (this->flags() & (regbase::main_option_type | regbase::no_perl_ex)))

goto escape_type_class_jump;

default:

this->append_literal(unescape_character());

re_literal* lit = static_cast<re_literal*>(this->m_last_state);

charT c = (static_cast<charT*>(static_cast<void*>(lit+1)))[lit->length - 1];

// now append new state:

lit = static_cast<re_literal*>(this->append_state(syntax_element_literal, sizeof(re_literal) + sizeof(charT)));

while((m_position != m_end) && this->m_traits.isctype(*m_position, this->m_mask_space))

++m_position;

if(this->m_position == this->m_end)

{

}

// get min:

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

// skip whitespace:

if(v < 0)

{

}

{

}

min = v;

if(this->m_position == this->m_end)

{

}

// get the value if any:

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

}

else

if(this->m_position == this->m_end)

{

}

if(isbasic)

else

{

}

//

case regex_constants::syntax_or:

m_mark_reset = m_mark_count;

case regex_constants::syntax_colon:

//

#include <boost/config.hpp>

#ifndef BOOST_NO_STD_LOCALE

parser_buf<charT, traits>::seekoff(off_type off, ::std::ios_base::seekdir way, ::std::ios_base::openmode which)

{

if(which & ::std::ios_base::out)

return pos_type(off_type(-1));

std::ptrdiff_t pos = this->gptr() - this->eback();

charT* g = this->eback();

{

case ::std::ios_base::beg:

//

BOOST_ASSERT(*p2 == 0);

string_type result;

//

// swallowing all exceptions here is a bad idea

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

//

#ifndef BOOST_NO_EXCEPTIONS

try{

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

#endif

#ifndef BOOST_NO_EXCEPTIONS

}

}

#endif

}

}

#if !defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS)\

&& !BOOST_WORKAROUND(__BORLANDC__, <= 0x0551)

std::string name(p1, p2);

name = lookup_default_collate_name(name);

#if !defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS)\

&& !BOOST_WORKAROUND(__BORLANDC__, <= 0x0551)

if(name.size())

template <class charT>

{

cpp_regex_traits_base<charT> key(l);

template class BOOST_REGEX_TEMPLATE_DECL basic_regex< BOOST_REGEX_CHAR_T BOOST_REGEX_TRAITS_T >;

template class BOOST_REGEX_TEMPLATE_DECL match_results< const BOOST_REGEX_CHAR_T* >;

#ifndef BOOST_NO_STD_ALLOCATOR

template class BOOST_REGEX_TEMPLATE_DECL ::boost::re_detail::perl_matcher<BOOST_REGEX_CHAR_T const *, match_results< const BOOST_REGEX_CHAR_T* >::allocator_type BOOST_REGEX_TRAITS_T >;

&& !(defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION))\

&& !defined(BOOST_REGEX_ICU_INSTANCES)

template class BOOST_REGEX_TEMPLATE_DECL match_results< std::basic_string<BOOST_REGEX_CHAR_T>::const_iterator >;

#ifndef BOOST_NO_STD_ALLOCATOR

template class BOOST_REGEX_TEMPLATE_DECL ::boost::re_detail::perl_matcher< std::basic_string<BOOST_REGEX_CHAR_T>::const_iterator, match_results< std::basic_string<BOOST_REGEX_CHAR_T>::const_iterator >::allocator_type, boost::regex_traits<BOOST_REGEX_CHAR_T > >;

#undef BOOST_REGEX_TEMPLATE_DECL

# ifndef BOOST_REGEX_INSTANTIATE

namespace re_detail{

template <class T>

} match_flags;

typedef unsigned long match_flag_type;

#else

//

#ifndef _RWSTD_VER

template <class C, class T, class A>

inline int string_compare(const std::basic_string<C,T,A>& s, const C* p)

return s.compare(p);

}

#else

template <class C, class T, class A>

inline int string_compare(const std::basic_string<C,T,A>& s, const C* p)

return s.compare(p);

}

inline int string_compare(const std::string& s, const char* p)

{ return std::strcmp(s.c_str(), p); }

else if((re_f & (regbase::main_option_type|regbase::emacs_ex)) == (regbase::basic_syntax_group|regbase::emacs_ex))

m_match_flags |= match_perl;

else

m_match_flags |= match_posix;

state_count = 0;

m_match_flags |= regex_constants::match_all;

m_presult->set_base(base);

m_presult->set_named_subs(this->re.get_named_subs());

search_base = position = base;

pstate = re.get_first_state();

m_presult->set_base(base);

m_presult->set_named_subs(this->re.get_named_subs());

}

// reset $` start:

//if((base != search_base) && (base == backstop))

// m_match_flags |= match_prev_avail;

if(m_match_flags & match_posix)

{

m_result.set_base(base);

}

m_presult->set_second(last, 0, false);

position = last;

}

#ifdef BOOST_REGEX_MATCH_EXTRA

{

// prev and this character must be opposites:

b = traits_inst.isctype(*position, m_word_mask);

}

else

{

BidiIterator end = position;

BidiIterator origin(position);

while((position != end) && (traits_inst.translate(*position, icase) == what))

{

BidiIterator end = position;

BidiIterator origin(position);

while((position != end) && map[static_cast<unsigned char>(traits_inst.translate(*position, icase))])

{

BidiIterator end = position;

BidiIterator origin(position);

while((position != end) && (position != re_is_set_member(position, last, set, re.get_data(), icase)))

}

if(position == last)

{

{

BidiIterator end = position;

BidiIterator origin(position);

while((position != end) && map[static_cast<unsigned char>(traits_inst.translate(*position, icase))])

{

BidiIterator end = position;

BidiIterator origin(position);

while((position != end) && (position != re_is_set_member(position, last, set, re.get_data(), icase)))

break;

}

default:

put(*m_position);

have_brace = true;

++m_position;

default:

// see if we have a number:

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

{

const charT* end = func;

while(*end) ++end;

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

{

return re_detail::regex_format_imp(i, m, func.begin(), func.end(), f, t);

}

if(size_type(last - end) < n)

resize(n + (end - start));

end += n;

return result;

{

typedef typename std::basic_string<charT, Traits1, Alloc1>::const_iterator ci_t;

ci_t last = s.begin();

std::size_t init_size = max_split;

// is not exhausted, and we're not splitting sub-expressions rather

// than whitespace:

{

*out = std::basic_string<charT, Traits1, Alloc1>((ci_t)last, (ci_t)s.end());

#include <boost/detail/workaround.hpp>

#if (BOOST_WORKAROUND(__BORLANDC__, >= 0x560) && BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x570)))\

|| BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003))

//

#ifdef BOOST_MSVC

#pragma warning(pop)

#endif

#if !BOOST_WORKAROUND(__HP_aCC, < 60700)

#if (BOOST_WORKAROUND(__BORLANDC__, >= 0x560) && BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x570)))\

|| BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003)) \

|| BOOST_WORKAROUND(__HP_aCC, < 60700)

#if !BOOST_WORKAROUND(__HP_aCC, < 60700)

#if (BOOST_WORKAROUND(__BORLANDC__, >= 0x560) && BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x570)))\

|| BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003)) \

|| BOOST_WORKAROUND(__HP_aCC, < 60700)

return regex_token_iterator<typename std::basic_string<charT, ST, SA>::const_iterator, charT, traits>(p.begin(), p.end(), e, submatch, m);

}

template <class charT, class traits, std::size_t N>

inline regex_token_iterator<const charT*, charT, traits> make_regex_token_iterator(const charT* p, const basic_regex<charT, traits>& e, const int (&submatch)[N], regex_constants::match_flag_type m = regex_constants::match_default)

return regex_token_iterator<typename std::basic_string<charT, ST, SA>::const_iterator, charT, traits>(p.begin(), p.end(), e, submatch, m);

}

template <class charT, class traits>

inline regex_token_iterator<const charT*, charT, traits> make_regex_token_iterator(const charT* p, const basic_regex<charT, traits>& e, const std::vector<int>& submatch, regex_constants::match_flag_type m = regex_constants::match_default)

}

#ifdef BOOST_MSVC

#pragma warning(push)

#pragma warning(disable: 4103)

//

namespace re_detail{

BOOST_MPL_HAS_XXX_TRAIT_DEF(boost_extensions_tag)

#else

typedef BaseT type;

};

template <class BaseT>

struct compute_wrapper_base<BaseT, false>

* John Maddock

*

* LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

*

*/

/*

* LOCATION: see http://www.boost.org for most recent version.

}

#if !defined(__hpux) && !defined(__WINSCW__) // can't use WCHAR_MAX/MIN in pp-directives

template<>

inline bool is_combining<wchar_t>(wchar_t c)

{

return BOOST_REGEX_MAKE_BOOL(

|| (static_cast<boost::uint16_t>(c) == 0x85u));

}

};

{

{data+0, data+5,}, // alnum

static const character_pointer_range<charT>* ranges_begin = ranges;

static const character_pointer_range<charT>* ranges_end = ranges + (sizeof(ranges)/sizeof(ranges[0]));

character_pointer_range<charT> t = { p1, p2, };

const character_pointer_range<charT>* p = std::lower_bound(ranges_begin, ranges_end, t);

# pragma warning(disable:4309 4245)

#endif

'\\', 'x', '{', '2', '0', '2', '9', '}', ']', ')', '\0' };

charT c = static_cast<charT>(0x2029u);

bool b = (static_cast<unsigned>(c) == 0x2029u);

return (b ? e1 : e2);

#ifdef BOOST_MSVC

# pragma warning(disable:4309)

#endif

'|', '[', '\x0A', '\x0B', '\x0C', '\x85', ']', ')', '\0' };

return e2;

{

typedef typename re_detail::regex_iterator_traits<BidiIterator>::value_type value_type;

typedef std::ptrdiff_t difference_type;

#else

sub_match(BidiIterator i) : std::pair<BidiIterator, BidiIterator>(i, i), matched(false) {}

#if !defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS)\

&& !BOOST_WORKAROUND(__BORLANDC__, <= 0x0551)\

&& !BOOST_WORKAROUND(__DECCXX_VER, BOOST_TESTED_AT(60590042))

#if (BOOST_WORKAROUND(__BORLANDC__, >= 0x560) && BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x570)))\

|| BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003))

//

# include BOOST_ABI_PREFIX

#endif

# pragma warning(push)

# pragma warning(disable:4700)

u32regex_token_iterator_implementation(const regex_type* p, BidirectionalIterator last, const std::vector<int>& v, match_flag_type f)

: end(last), re(*p), flags(f), subs(v){}

|| BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003)) \

|| BOOST_WORKAROUND(__HP_aCC, < 60700)

pdata.reset();

}

|| BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003)) \

|| BOOST_WORKAROUND(__HP_aCC, < 60700)

}

// construction from a reference to an array:

template <std::size_t N>

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

}

// construction from a vector of sub_match state_id's:

}

# pragma warning(pop)

#endif

}

#if !defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS)\

&& !BOOST_WORKAROUND(__BORLANDC__, <= 0x0551)

std::string name(p1, p2);

name = lookup_default_collate_name(name);

#if !defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS)\

&& !BOOST_WORKAROUND(__BORLANDC__, <= 0x0551)

if(name.size())

template <class charT>

{

// TODO: create a cache for previously constructed objects.