# include <boost/config/auto_link.hpp>

#endif

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

*

* Set up function call type:

*

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

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

# define BOOST_REGEX_CALL __cdecl

#else

# define BOOST_REGEX_CALL __fastcall

#endif

# define BOOST_REGEX_CCALL __cdecl

#endif

#if defined(__BORLANDC__) && !defined(BOOST_DISABLE_WIN32)

template <class BidiIterator, class Allocator>

bool do_regex_match(BidiIterator first, BidiIterator last,

match_results<BidiIterator, Allocator>& m,

const u32regex& e,

match_flag_type flags,

boost::mpl::int_<2> const*)

{

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);

// copy results across to m:

if(result) copy_results(m, what);

return result;

}

template <class BidiIterator, class Allocator>

bool do_regex_match(BidiIterator first, BidiIterator last,

match_results<BidiIterator, Allocator>& m,

const u32regex& e,

match_flag_type flags,

boost::mpl::int_<1> const*)

{

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);

// copy results across to m:

if(result) copy_results(m, what);

return result;

}

} // namespace re_detail

template <class BidiIterator, class Allocator>

bool do_regex_search(BidiIterator first, BidiIterator last,

match_results<BidiIterator, Allocator>& m,

const u32regex& e,

match_flag_type flags,

BidiIterator base,

boost::mpl::int_<2> const*)

{

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));

// copy results across to m:

if(result) copy_results(m, what);

return result;

}

template <class BidiIterator, class Allocator>

bool do_regex_search(BidiIterator first, BidiIterator last,

match_results<BidiIterator, Allocator>& m,

const u32regex& e,

match_flag_type flags,

BidiIterator base,

boost::mpl::int_<1> const*)

{

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));

// copy results across to m:

if(result) copy_results(m, what);

return result;

}

}

template <class BidiIterator, class Allocator>

template <class OutputIterator, class BidirectionalIterator, class charT>

inline OutputIterator u32regex_replace(OutputIterator out,

BidirectionalIterator first,

BidirectionalIterator last,

const u32regex& e,

const charT* fmt,

match_flag_type flags = match_default)

{

return re_detail::extract_output_base

(

re_detail::do_regex_replace(

re_detail::make_utf32_out(out, static_cast<mpl::int_<sizeof(*first)> const*>(0)),

re_detail::make_utf32_seq(first, last, static_cast<mpl::int_<sizeof(*first)> const*>(0)),

e,

re_detail::make_utf32_seq(fmt, static_cast<mpl::int_<sizeof(*fmt)> const*>(0)),

flags)

);

}

template <class OutputIterator, class Iterator, class charT>

inline OutputIterator u32regex_replace(OutputIterator out,

Iterator first,

Iterator last,

const u32regex& e,

const std::basic_string<charT>& fmt,

match_flag_type flags = match_default)

{

return re_detail::extract_output_base

(

re_detail::do_regex_replace(

re_detail::make_utf32_out(out, static_cast<mpl::int_<sizeof(*first)> const*>(0)),

re_detail::make_utf32_seq(first, last, static_cast<mpl::int_<sizeof(*first)> const*>(0)),

e,

re_detail::make_utf32_seq(fmt.begin(), fmt.end(), static_cast<mpl::int_<sizeof(charT)> const*>(0)),

flags)

);

}

template <class OutputIterator, class Iterator>

inline OutputIterator u32regex_replace(OutputIterator out,

Iterator first,

Iterator last,

const u32regex& e,

const U_NAMESPACE_QUALIFIER UnicodeString& fmt,

match_flag_type flags = match_default)

{

return re_detail::extract_output_base

(

re_detail::do_regex_replace(

re_detail::make_utf32_out(out, static_cast<mpl::int_<sizeof(*first)> const*>(0)),

re_detail::make_utf32_seq(first, last, static_cast<mpl::int_<sizeof(*first)> const*>(0)),

e,

re_detail::make_utf32_seq(fmt.getBuffer(), fmt.getBuffer() + fmt.length(), static_cast<mpl::int_<2> const*>(0)),

flags)

);

}

#if defined(BOOST_HAS_PTHREADS) && defined(PTHREAD_MUTEX_INITIALIZER)

//

// pthreads version:

// simple wrap around a pthread_mutex_t initialized with

// PTHREAD_MUTEX_INITIALIZER.

//

namespace boost{

#define BOOST_STATIC_MUTEX_INIT { PTHREAD_MUTEX_INITIALIZER, }

class BOOST_REGEX_DECL scoped_static_mutex_lock

{

public:

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

~scoped_static_mutex_lock();

inline bool locked()const

return locked() ? this : 0;

}

void lock();

void unlock();

private:

static_mutex& m_mutex;

bool m_have_lock;

};

} // namespace boost

#elif defined(BOOST_HAS_WINTHREADS)

//

// Win32 version:

// Use a 32-bit int as a lock, along with a test-and-set

// implementation using InterlockedCompareExchange.

//

// Portable version of a static mutex based on Boost.Thread library:

// This has to use a single mutex shared by all instances of static_mutex

// because boost::call_once doesn't alow us to pass instance information

// down to the initialisation proceedure. In fact the initialisation routine

// may need to be called more than once - but only once per instance.

//

// Since this preprocessor path is almost never taken, we hide these header

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

//

namespace boost{

class BOOST_REGEX_DECL scoped_static_mutex_lock;

extern "C" BOOST_REGEX_DECL void boost_regex_free_static_mutex();

class BOOST_REGEX_DECL static_mutex

{

public:

{

public:

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

~scoped_static_mutex_lock();

operator void const*()const;

bool locked()const;

void lock();

void unlock();

private:

bool m_have_lock;

};

inline scoped_static_mutex_lock::operator void const*()const

{

return locked() ? this : 0;

}

inline bool scoped_static_mutex_lock::locked()const

} // namespace detail

template <class BaseIterator, class U16Type = ::boost::uint16_t>

class u32_to_u16_iterator

: public boost::iterator_facade<u32_to_u16_iterator<BaseIterator, U16Type>, U16Type, std::bidirectional_iterator_tag, const U16Type>

{

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_ASSERT(sizeof(base_value_type)*CHAR_BIT == 32);

BOOST_STATIC_ASSERT(sizeof(U16Type)*CHAR_BIT == 16);

#endif

public:

typename base_type::reference

dereference()const

template <class BaseIterator, class U32Type = ::boost::uint32_t>

class u16_to_u32_iterator

: public boost::iterator_facade<u16_to_u32_iterator<BaseIterator, U32Type>, U32Type, std::bidirectional_iterator_tag, const U32Type>

{

typedef boost::iterator_facade<u16_to_u32_iterator<BaseIterator, U32Type>, U32Type, std::bidirectional_iterator_tag, const U32Type> base_type;

// special values for pending iterator reads:

BOOST_STATIC_CONSTANT(U32Type, pending_read = 0xffffffffu);

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

BOOST_STATIC_ASSERT(sizeof(base_value_type)*CHAR_BIT == 16);

BOOST_STATIC_ASSERT(sizeof(U32Type)*CHAR_BIT == 32);

#endif

public:

typename base_type::reference

dereference()const

mutable U32Type m_value;

};

template <class BaseIterator, class U8Type = ::boost::uint8_t>

class u32_to_u8_iterator

: public boost::iterator_facade<u32_to_u8_iterator<BaseIterator, U8Type>, U8Type, std::bidirectional_iterator_tag, const U8Type>

{

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_ASSERT(sizeof(base_value_type)*CHAR_BIT == 32);

BOOST_STATIC_ASSERT(sizeof(U8Type)*CHAR_BIT == 8);

#endif

public:

typename base_type::reference

dereference()const

template <class BaseIterator, class U32Type = ::boost::uint32_t>

class u8_to_u32_iterator

: public boost::iterator_facade<u8_to_u32_iterator<BaseIterator, U32Type>, U32Type, std::bidirectional_iterator_tag, const U32Type>

{

typedef boost::iterator_facade<u8_to_u32_iterator<BaseIterator, U32Type>, U32Type, std::bidirectional_iterator_tag, const U32Type> base_type;

// special values for pending iterator reads:

BOOST_STATIC_CONSTANT(U32Type, pending_read = 0xffffffffu);

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

BOOST_STATIC_ASSERT(sizeof(base_value_type)*CHAR_BIT == 8);

BOOST_STATIC_ASSERT(sizeof(U32Type)*CHAR_BIT == 32);

#endif

public:

typename base_type::reference

dereference()const

extract_current();

return m_value;

}

bool equal(const u8_to_u32_iterator& that)const

{

return m_position == that.m_position;

}

void increment()

{

// skip high surrogate first if there is one:

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

m_value = pending_read;

}

void decrement()

{

// Keep backtracking until we don't have a trailing character:

unsigned count = 0;

while((*--m_position & 0xC0u) == 0x80u) ++count;

// now check that the sequence was valid:

if(count != detail::utf8_trailing_byte_count(*m_position))

std::out_of_range e("Invalid UTF-8 sequence encountered while trying to encode UTF-32 character");

boost::throw_exception(e);

}

void extract_current()const

{

m_value = static_cast<U32Type>(static_cast< ::boost::uint8_t>(*m_position));

// we must not have a continuation character:

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:

BaseIterator next(m_position);

for(unsigned c = 0; c < extra; ++c)

{

++next;

m_value <<= 6;

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

}

// we now need to remove a few of the leftmost bits, but how many depends

// upon how many extra bytes we've extracted:

static const boost::uint32_t masks[4] =

{

0x7Fu,

0x7FFu,

0xFFFFu,

0x1FFFFFu,

};

m_value &= masks[extra];

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

invalid_sequence();

}

BaseIterator m_position;

mutable U32Type m_value;

};

template <class BaseIterator>

class utf16_output_iterator

{

public:

result = std::basic_string<charT>(this->m_expression, this->m_expression_len);

return result;

}

const_iterator BOOST_REGEX_CALL expression()const

{

return this->m_expression;

}

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;

}

//

// begin, end:

const_iterator BOOST_REGEX_CALL begin()const

{

return (this->m_status ? 0 : this->m_expression);

}

{

return this->m_expression_len;

}

int BOOST_REGEX_CALL status()const

{

return this->m_status;

}

size_type BOOST_REGEX_CALL mark_count()const

{

}

const re_detail::re_syntax_base* get_first_state()const

{

return this->m_first_state;

}

unsigned get_restart_type()const

{

return this->m_restart_type;

}

namespace re_detail{

template <class charT>

struct digraph : public std::pair<charT, charT>

{

digraph() : std::pair<charT, charT>(0, 0){}

digraph(charT c1) : std::pair<charT, charT>(c1, 0){}

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>()

{

BOOST_ASSERT(s.size() <= 2);

BOOST_ASSERT(s.size());

this->first = s[0];

this->second = (s.size() > 1) ? s[1] : 0;

}

};

}

else

{

// we have an existing re_literal, extend it:

std::ptrdiff_t off = getoffset(m_last_state);

m_pdata->m_data.extend(sizeof(charT));

m_last_state = result = static_cast<re_literal*>(getaddress(off));

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

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

}

return result;

}

template <class charT, class traits>

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

const basic_char_set<charT, traits>& char_set)

{

typedef mpl::bool_< (sizeof(charT) == 1) > truth_type;

digraph<charT> c2 = *first;

c2.first = this->m_traits.translate(c2.first, this->m_icase);

c2.second = this->m_traits.translate(c2.second, this->m_icase);

++first;

string_type s1, s2;

// different actions now depending upon whether collation is turned on:

if(flags() & regex_constants::collate)

{

// 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(s2.size() == 0)

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

}

else

{

if(c1.second)

{

// now process the equivalence classes:

//

first = char_set.equivalents_begin();

last = char_set.equivalents_end();

while(first != last)

{

string_type s;

if(first->second)

{

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

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

}

else

s = m_traits.transform_primary(&first->first, &first->first+1);

if(s.empty())

return 0; // invalid or unsupported equivalence class

charT* p = static_cast<charT*>(this->m_pdata->m_data.extend(sizeof(charT) * (s.size()+1) ) );

re_detail::copy(s.begin(), s.end(), p);

p[s.size()] = charT(0);

++first;

state->next.p = 0;

break;

case syntax_element_rep:

case syntax_element_dot_rep:

case syntax_element_char_rep:

case syntax_element_short_set_rep:

case syntax_element_long_set_rep:

// 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)

state->next.p = getaddress(state->next.i, state);

else

state->next.p = 0;

}

state = state->next.p;

}

}

//

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

{

std::string message = "Encountered a forward reference to a recursive sub-expression that does not exist.";

boost::regex_error e(message, boost::regex_constants::error_bad_pattern, 0);

e.raise();

}

}

}

default:

break;

}

state = state->next.p;

}

}

template <class charT, class traits>

void basic_regex_creator<charT, traits>::create_startmaps(re_syntax_base* state)

// and throw if required:

//

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

{

std::string message = "Invalid lookbehind assertion encountered in the regular expression.";

boost::regex_error e(message, boost::regex_constants::error_bad_pattern, 0);

e.raise();

}

}

default:

state = state->next.p;

}

}

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

while(v.size())

{

// Initialize m_recursion_checks if we need it:

else if(recursion_start == 0)

{

recursion_start = state;

recursion_restart = state->next.p;

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

m_recursion_checks[recursion_sub] = true;

break;

}

m_recursion_checks[recursion_sub] = true;

}

case syntax_element_backref:

// can be null, and any character can match:

if(pnull)

*pnull |= mask;

case syntax_element_wild:

{

// can't be null, any character can match:

set_all_masks(l_map, mask);

return;

}

case syntax_element_match:

{

// must be null, any character can match:

break;

case syntax_element_startmark:

// need to handle independent subs as a special case:

if(static_cast<re_brace*>(state)->index == -3)

{

state = state->next.p->next.p;

break;

}

default:

state = state->next.p;

}

++not_last_jump;

}

}

template <class charT, class traits>

unsigned basic_regex_creator<charT, traits>::get_restart_type(re_syntax_base* state)

case syntax_element_char_rep:

case syntax_element_short_set_rep:

case syntax_element_long_set_rep:

{

unsigned state_id = static_cast<re_repeat*>(pt)->state_id;

static const boost::uintmax_t one = 1uL;

if(state_id <= sizeof(m_bad_repeats) * CHAR_BIT)

m_bad_repeats |= (one << state_id);

}

default:

break;

}

}

template <class charT, class traits>

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

{

typedef typename traits::char_class_type m_type;

case syntax_element_restart_continue:

state = state->next.p;

break;

case syntax_element_dot_rep:

case syntax_element_char_rep:

case syntax_element_short_set_rep:

case syntax_element_long_set_rep:

if(this->m_has_backrefs == 0)

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

default:

return;

}

}while(state);

}

} // namespace re_detail

// we get to a newline character:

//

if((this->flags()

& (regbase::no_perl_ex|regbase::mod_x))

== regbase::mod_x)

{

while((m_position != m_end) && !is_separator(*m_position++)){}

return true;

}

default:

result = parse_literal();

break;

}

return result;

}

#ifdef BOOST_MSVC

#pragma warning(pop)

#endif

break;

default:

if(this->flags() & regbase::emacs_ex)

{

bool negate = true;

switch(*m_position)

{

case 'w':

negate = false;

case 'W':

{

basic_char_set<charT, traits> char_set;

if(negate)

char_set.negate();

char_set.add_class(this->m_word_mask);

if(0 == this->append_set(char_set))

{

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

return false;

}

++m_position;

return true;

}

case 's':

negate = false;

case 'S':

return add_emacs_code(negate);

case 'c':

case 'C':

// not supported yet:

fail(regex_constants::error_escape, m_position - m_base, "The \\c and \\C escape sequences are not supported by POSIX basic regular expressions: try the Perl syntax instead.");

return false;

default:

break;

{

fail(regex_constants::error_escape, m_position - m_base, "Incomplete escape sequence found.");

return false;

}

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_not_class:

negate = true;

case regex_constants::escape_type_class:

{

escape_type_class_jump:

typedef typename traits::char_class_type m_type;

m_type m = this->m_traits.lookup_classname(m_position, m_position+1);

if(m != 0)

{

basic_char_set<charT, traits> char_set;

if(negate)

++m_position;

this->append_state(syntax_element_combining);

break;

case regex_constants::escape_type_G:

++m_position;

this->append_state(syntax_element_restart_continue);

break;

case regex_constants::escape_type_not_property:

negate = true;

case regex_constants::escape_type_property:

{

++m_position;

char_class_type m;

if(m_position == m_end)

{

fail(regex_constants::error_escape, m_position - m_base, "Incomplete property escape found.");

return false;

}

}

++m_position;

}

return true;

}

goto escape_type_class_jump;

case regex_constants::escape_type_control_v:

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

goto escape_type_class_jump;

default:

this->append_literal(unescape_character());

break;

}

return true;

}

template <class charT, class traits>

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

{

// insert a repeat before the '(' matching the last ')':

insert_point = this->m_paren_start;

}

else if((this->m_last_state->type == syntax_element_literal) && (static_cast<re_literal*>(this->m_last_state)->length > 1))

{

// the last state was a literal with more than one character, split it in two:

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)));

lit->length = 1;

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

insert_point = this->getoffset(this->m_last_state);

}

else

{

// repeat the last state whatever it was, need to add some error checking here:

static const char* incomplete_message = "Missing } in quantified repetition.";

//

// parse a repeat-range:

//

std::size_t min, max;

int v;

// skip whitespace:

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;

// see if we have a comma:

if(this->m_traits.syntax_type(*m_position) == regex_constants::syntax_comma)

{

// move on and error check:

++m_position;

// skip whitespace:

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 the value if any:

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

}

else

{

// no comma, max = min:

max = min;

}

// skip whitespace:

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

++m_position;

// OK now check trailing }:

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

{

}

if(isbasic)

{

if(this->m_traits.syntax_type(*m_position) == regex_constants::syntax_escape)

{

++m_position;

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

{

fail(regex_constants::error_brace, this->m_position - this->m_base, incomplete_message);

{

fail(regex_constants::error_brace, this->m_position - this->m_base, incomplete_message);

return false;

}

}

if(this->m_traits.syntax_type(*m_position) == regex_constants::syntax_close_brace)

++m_position;

else

{

}

//

// finally go and add the repeat, unless error:

//

if(min > max)

{

// Backtrack to error location:

m_position -= 2;

while(this->m_traits.isctype(*m_position, this->m_word_mask)) --m_position;

m_max_mark = m_mark_count;

int v;

//

// select the actual extension used:

//

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

{

case regex_constants::syntax_or:

m_mark_reset = m_mark_count;

case regex_constants::syntax_colon:

//

// a non-capturing mark:

//

pb->index = markid = 0;

++m_position;

break;

case regex_constants::syntax_digit:

{

* FILE cpp_regex_traits.hpp

* VERSION see <boost/version.hpp>

* DESCRIPTION: Declares regular expression traits class cpp_regex_traits.

*/

#ifndef BOOST_CPP_REGEX_TRAITS_HPP_INCLUDED

#define BOOST_CPP_REGEX_TRAITS_HPP_INCLUDED

#include <boost/config.hpp>

#ifndef BOOST_NO_STD_LOCALE

#ifndef BOOST_RE_PAT_EXCEPT_HPP

#include <boost/regex/pattern_except.hpp>

#endif

#ifndef BOOST_REGEX_TRAITS_DEFAULTS_HPP_INCLUDED

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

#endif

{

this->setg(s, s, s + n);

return this;

}

template<class charT, class traits>

typename parser_buf<charT, traits>::pos_type

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 size = this->egptr() - this->eback();

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

charT* g = this->eback();

{

case ::std::ios_base::beg:

if((off < 0) || (off > size))

return pos_type(off_type(-1));

else

this->setg(g, g + off, g + size);

break;

case ::std::ios_base::end:

if((off < 0) || (off > size))

//

// PRECONDITIONS:

//

// A bug in gcc 3.2 (and maybe other versions as well) treats

// p1 as a null terminated string, for efficiency reasons

// we work around this elsewhere, but just assert here that

// we adhere to gcc's (buggy) preconditions...

//

BOOST_ASSERT(*p2 == 0);

string_type result;

//

// swallowing all exceptions here is a bad idea

// however at least one std lib will always throw

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

//

#ifndef BOOST_NO_EXCEPTIONS

try{

#endif

//

// we work around this elsewhere, but just assert here that

// we adhere to gcc's (buggy) preconditions...

//

BOOST_ASSERT(*p2 == 0);

//

// swallowing all exceptions here is a bad idea

// however at least one std lib will always throw

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

//

#ifndef BOOST_NO_EXCEPTIONS

try{

#endif

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

//

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

// string that has garbage at the end - each call to

// std::collate<wchar_t>::transform returns a different string!

// So as a workaround, we'll truncate the string at the first NULL

// which _seems_ to work....

#if BOOST_WORKAROUND(__BORLANDC__, < 0x580)

result.erase(result.find(charT(0)));

#else

//

// some implementations (Dinkumware) append unnecessary trailing \0's:

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

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

#endif

#ifndef BOOST_NO_EXCEPTIONS

}

catch(...)

{

}

#endif

}

template <class charT>

typename cpp_regex_traits_implementation<charT>::string_type

cpp_regex_traits_implementation<charT>::lookup_collatename(const charT* p1, const charT* p2) const

{

typedef typename std::map<string_type, string_type>::const_iterator iter_type;

if(m_custom_collate_names.size())

{

iter_type pos = m_custom_collate_names.find(string_type(p1, p2));

if(pos != m_custom_collate_names.end())

return pos->second;

}

#if !defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS)\

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

std::string name(p1, p2);

#else

std::string name;

const charT* p0 = p1;

while(p0 != p2)

name.append(1, char(*p0++));

#endif

name = lookup_default_collate_name(name);

#if !defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS)\

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

if(name.size())

return string_type(name.begin(), name.end());

#else

if(name.size())

{

string_type result;

typedef std::string::const_iterator iter;

iter b = name.begin();

|| ((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')))

|| ((mask & ::boost::re_detail::char_class_horizontal_space) && this->m_pctype->is(std::ctype<charT>::space, c) && !(is_separator(c) || (c == '\v')));

}

#endif

template <class charT>

{

cpp_regex_traits_base<charT> key(l);

return ::boost::object_cache<cpp_regex_traits_base<charT>, cpp_regex_traits_implementation<charT> >::get(key, 5);

}

} // re_detail

template <class charT>

class cpp_regex_traits

# pragma warning(push)

# pragma warning(disable : 4251 4231)

# if BOOST_MSVC < 1600

# pragma warning(disable : 4660)

# endif

# endif

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 >;

#endif

#if !(defined(BOOST_DINKUMWARE_STDLIB) && (BOOST_DINKUMWARE_STDLIB <= 1))\

&& !(defined(BOOST_INTEL_CXX_VERSION) && (BOOST_INTEL_CXX_VERSION <= 800))\

&& !(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 > >;

#endif

#endif

# ifdef BOOST_MSVC

# pragma warning(pop)

# endif

# ifdef template

# undef template

# endif

#undef BOOST_REGEX_TEMPLATE_DECL

# ifndef BOOST_REGEX_INSTANTIATE

# ifdef __GNUC__

# define template __extension__ extern template

# else

# define template extern template

# endif

# endif

# include BOOST_ABI_PREFIX

#endif

#ifdef BOOST_MSVC

#pragma warning(pop)

#endif

namespace boost{

namespace re_detail{

template <class T>

struct regex_iterator_traits

{

typedef typename T::iterator_category iterator_category;

typedef typename T::value_type value_type;

#if !defined(BOOST_NO_STD_ITERATOR)

typedef typename T::difference_type difference_type;

typedef typename T::pointer pointer;

format_sed = match_max << 1, /* sed style replacement. */

format_all = format_sed << 1, /* enable all extentions to sytax. */

format_no_copy = format_all << 1, /* don't copy non-matching segments. */

format_first_only = format_no_copy << 1, /* Only replace first occurance. */

format_is_if = format_first_only << 1, /* internal use only. */

format_literal = format_is_if << 1 /* treat string as a literal */

} match_flags;

typedef unsigned long match_flag_type;

#else

typedef match_flags match_flag_type;

#ifdef __cplusplus

inline match_flags operator&(match_flags m1, match_flags m2)

{ return static_cast<match_flags>(static_cast<boost::int32_t>(m1) & static_cast<boost::int32_t>(m2)); }

inline match_flags operator|(match_flags m1, match_flags m2)

//

// Unfortunately Rogue Waves standard library appears to have a bug

// in std::basic_string::compare that results in eroneous answers

// in some cases (tested with Borland C++ 5.1, Rogue Wave lib version

// 0x020101) the test case was:

// {39135,0} < {0xff,0}

// which succeeds when it should not.

//

#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)

{

if(0 == *p)

{

if(s.empty() || ((s.size() == 1) && (s[0] == 0)))

return 0;

}

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)

{

if(0 == *p)

{

if(s.empty() || ((s.size() == 1) && (s[0] == 0)))

return 0;

}

return s.compare(p);

}

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

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

# ifndef BOOST_NO_WREGEX

inline int string_compare(const std::wstring& s, const wchar_t* p)

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

#endif

#endif

template <class Seq, class C>

inline int string_compare(const Seq& s, const C* p)

estimate_max_state_count(static_cast<category*>(0));

expression_flag_type re_f = re.flags();

icase = re_f & regex_constants::icase;

if(!(m_match_flags & (match_perl|match_posix)))

{

if((re_f & (regbase::main_option_type|regbase::no_perl_ex)) == 0)

m_match_flags |= match_perl;

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;

}

if(m_match_flags & match_posix)

{

m_temp_match.reset(new match_results<BidiIterator, Allocator>());

m_presult = m_temp_match.get();

}

else

try{

#endif

#endif

// reset our state machine:

position = base;

search_base = base;

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());

if(m_match_flags & match_posix)

m_result = *m_presult;

verify_options(re.flags(), m_match_flags);

if(0 == match_prefix())

return false;

return (m_result[0].second == last) && (m_result[0].first == base);

#endif

#endif

state_count = 0;

if((m_match_flags & regex_constants::match_init) == 0)

{

// reset our state machine:

search_base = position = base;

pstate = re.get_first_state();

m_presult->set_base(base);

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

m_match_flags |= regex_constants::match_init;

}

else

{

// start again:

search_base = position = m_result[0].second;

// If last match was null and match_not_null was not set then increment

// our start position, otherwise we go into an infinite loop:

if(((m_match_flags & match_not_null) == 0) && (m_result.length() == 0))

{

if(position == last)

return false;

else

++position;

}

// 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);

}

verify_options(re.flags(), m_match_flags);

// find out what kind of expression we have:

unsigned type = (m_match_flags & match_continuous) ?

static_cast<unsigned int>(regbase::restart_continue)

: static_cast<unsigned int>(re.get_restart_type());

pstate = re.get_first_state();

m_presult->set_first(position);

restart = position;

match_all_states();

if(!m_has_found_match && m_has_partial_match && (m_match_flags & match_partial))

{

m_has_found_match = true;

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

position = last;

}

#ifdef BOOST_REGEX_MATCH_EXTRA

if(m_has_found_match && (match_extra & m_match_flags))

{

//

// we have a match, reverse the capture information:

//

for(unsigned i = 0; i < m_presult->size(); ++i)

{

}

template <class BidiIterator, class Allocator, class traits>

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

{

bool b; // indcates whether next character is a word character

if(position != last)

{

// prev and this character must be opposites:

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

}

else

{

b = (m_match_flags & match_not_eow) ? true : false;

}

if((position == backstop) && ((m_match_flags & match_prev_avail) == 0))

{

if(m_match_flags & match_not_bow)

b ^= true;

std::size_t count = 0;

//

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

//

bool greedy = (rep->greedy) && (!(m_match_flags & regex_constants::match_any) || m_independent);

std::size_t desired = greedy ? rep->max : rep->min;

if(::boost::is_random_access_iterator<BidiIterator>::value)

{

BidiIterator end = position;

BidiIterator origin(position);

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

{

++position;

}

count = (unsigned)::boost::re_detail::distance(origin, position);

}

else

{

std::size_t count = 0;

//

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

//

bool greedy = (rep->greedy) && (!(m_match_flags & regex_constants::match_any) || m_independent);

std::size_t desired = greedy ? rep->max : rep->min;

if(::boost::is_random_access_iterator<BidiIterator>::value)

{

BidiIterator end = position;

BidiIterator origin(position);

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

{

++position;

}

count = (unsigned)::boost::re_detail::distance(origin, position);

}

else

{

std::size_t count = 0;

//

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

//

bool greedy = (rep->greedy) && (!(m_match_flags & regex_constants::match_any) || m_independent);

std::size_t desired = greedy ? rep->max : rep->min;

if(::boost::is_random_access_iterator<BidiIterator>::value)

{

BidiIterator end = position;

BidiIterator origin(position);

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

{

++position;

}

count = (unsigned)::boost::re_detail::distance(origin, position);

}

else

{

// wind forward until we can skip out of the repeat:

do

{

++position;

++count;

++state_count;

}while((count < rep->max) && (position != last) && !can_start(*position, rep->_map, mask_skip));

}

if(position == last)

{

// can't repeat any more, remove the pushed state:

destroy_single_repeat();

if((m_match_flags & match_partial) && (position == last) && (position != search_base))

m_has_partial_match = true;

if(0 == (rep->can_be_null & mask_skip))

return true;

}

unsigned count = 0;

//

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

//

bool greedy = (rep->greedy) && (!(m_match_flags & regex_constants::match_any) || m_independent);

std::size_t desired = greedy ? rep->max : rep->min;

if(::boost::is_random_access_iterator<BidiIterator>::value)

{

BidiIterator end = position;

BidiIterator origin(position);

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

{

++position;

}

count = (unsigned)::boost::re_detail::distance(origin, position);

}

else

{

unsigned count = 0;

//

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

//

bool greedy = (rep->greedy) && (!(m_match_flags & regex_constants::match_any) || m_independent);

std::size_t desired = greedy ? rep->max : rep->min;

if(::boost::is_random_access_iterator<BidiIterator>::value)

{

BidiIterator end = position;

BidiIterator origin(position);

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

{

++position;

}

count = (unsigned)::boost::re_detail::distance(origin, position);

}

else

{

put(*m_position);

++m_position;

break;

case '$':

if((m_flags & format_sed) == 0)

{

format_perl();

break;

}

default:

put(*m_position);

++m_position;

break;

}

}

}

template <class OutputIterator, class Results, class traits, class ForwardIter>

{

m_position = --base;

}

}

put((this->m_results)[this->m_results.size() > 1 ? static_cast<int>(this->m_results.size() - 1) : 1]);

break;

case '{':

have_brace = true;

++m_position;

default:

// see if we have a number:

{

std::ptrdiff_t len = ::boost::re_detail::distance(m_position, m_end);

//len = (std::min)(static_cast<std::ptrdiff_t>(2), len);

int v = this->toi(m_position, m_position + len, 10);

if((v < 0) || (have_brace && ((m_position == m_end) || (*m_position != '}'))))

{

// Look for a Perl-5.10 verb:

template <class charT, class Match, class Traits>

struct format_functor_c_string

{

format_functor_c_string(const charT* ps) : func(ps) {}

template <class OutputIter>

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;

return regex_format_imp(i, m, func, end, f, t);

}

private:

const charT* func;

format_functor_c_string(const format_functor_c_string&);

format_functor_c_string& operator=(const format_functor_c_string&);

};

template <class Container, class Match, class Traits>

struct format_functor_container

{

format_functor_container(const Container& c) : func(c) {}

template <class OutputIter>

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);

}

private:

const Container& func;

format_functor_container(const format_functor_container&);

format_functor_container& operator=(const format_functor_container&);

};

template <class Func, class Match, class OutputIterator, class Traits = re_detail::trivial_format_traits<typename Match::char_type> >

::operator delete(start);

}

void BOOST_REGEX_CALL resize(size_type n);

void* BOOST_REGEX_CALL extend(size_type n)

{

if(size_type(last - end) < n)

resize(n + (end - start));

end += n;

return result;

}

void* BOOST_REGEX_CALL insert(size_type pos, size_type n);

size_type BOOST_REGEX_CALL size()

{

return end - start;

template <class OutputIterator, class charT, class Traits1, class Alloc1, class Traits2>

std::size_t regex_split(OutputIterator out,

std::basic_string<charT, Traits1, Alloc1>& s,

const basic_regex<charT, Traits2>& e,

match_flag_type flags,

std::size_t max_split)

{

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

ci_t last = s.begin();

std::size_t init_size = max_split;

re_detail::split_pred<OutputIterator, charT, Traits1, Alloc1> pred(&last, &out, &max_split);

ci_t i, j;

i = s.begin();

j = s.end();

regex_grep(pred, i, j, e, flags);

//

// if there is still input left, do a final push as long as 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());

++out;

last = s.end();

--max_split;

}

//

// delete from the string everything that has been processed so far:

s.erase(0, last - s.begin());

* DESCRIPTION: Provides regex_token_iterator implementation.

*/

#ifndef BOOST_REGEX_V4_REGEX_TOKEN_ITERATOR_HPP

#define BOOST_REGEX_V4_REGEX_TOKEN_ITERATOR_HPP

#include <boost/shared_ptr.hpp>

#include <boost/detail/workaround.hpp>

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

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

//

// Borland C++ Builder 6, and Visual C++ 6,

// can't cope with the array template constructor

// so we have a template member that will accept any type as

// argument, and then assert that is really is an array:

//

#include <boost/static_assert.hpp>

#include <boost/type_traits/is_array.hpp>

#ifdef BOOST_MSVC

#pragma warning(push)

#pragma warning(disable: 4103)

#endif

#ifdef BOOST_HAS_ABI_HEADERS

# include BOOST_ABI_PREFIX

#endif

#ifdef BOOST_MSVC

#pragma warning(pop)

#endif

template <class BidirectionalIterator,

class charT,

class traits>

class regex_token_iterator_implementation

{

typedef basic_regex<charT, traits> regex_type;

typedef sub_match<BidirectionalIterator> value_type;

std::vector<int> subs; // the sub-expressions to enumerate

public:

regex_token_iterator_implementation(const regex_type* p, BidirectionalIterator last, int sub, match_flag_type f)

: end(last), re(*p), flags(f){ subs.push_back(sub); }

regex_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){}

#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)

template <class T>

regex_token_iterator_implementation(const regex_type* p, BidirectionalIterator last, const T& submatches, match_flag_type f)

: end(last), re(*p), flags(f)

{

// assert that T really is an array:

BOOST_STATIC_ASSERT(::boost::is_array<T>::value);

const std::size_t array_size = sizeof(T) / sizeof(submatches[0]);

regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b, const regex_type& re,

const std::vector<int>& submatches, match_flag_type m = match_default)

: pdata(new impl(&re, b, submatches, m))

{

if(!pdata->init(a))

pdata.reset();

}

#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)

template <class T>

regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b, const regex_type& re,

const T& submatches, match_flag_type m = match_default)

: pdata(new impl(&re, b, submatches, m))

{

if(!pdata->init(a))

pdata.reset();

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

{

return regex_token_iterator<const charT*, charT, traits>(p, p+traits::length(p), e, submatch, m);

}

template <class charT, class traits, class ST, class SA>

inline regex_token_iterator<typename std::basic_string<charT, ST, SA>::const_iterator, charT, traits> make_regex_token_iterator(const std::basic_string<charT, ST, SA>& p, const basic_regex<charT, traits>& e, int submatch = 0, 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, 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<const charT*, charT, traits>(p, p+traits::length(p), e, submatch, m);

}

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

inline regex_token_iterator<typename std::basic_string<charT, ST, SA>::const_iterator, charT, traits> make_regex_token_iterator(const std::basic_string<charT, ST, SA>& 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)

{

return regex_token_iterator<const charT*, charT, traits>(p, p+traits::length(p), e, submatch, m);

}

template <class charT, class traits, class ST, class SA>

inline regex_token_iterator<typename std::basic_string<charT, ST, SA>::const_iterator, charT, traits> make_regex_token_iterator(const std::basic_string<charT, ST, SA>& p, const basic_regex<charT, traits>& e, const std::vector<int>& submatch, 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);

}

#ifdef BOOST_MSVC

#pragma warning(push)

#pragma warning(disable: 4103)

#endif

#ifdef BOOST_HAS_ABI_HEADERS

# include BOOST_ABI_SUFFIX

#endif

#ifdef BOOST_MSVC

#pragma warning(pop)

#endif

//

// class regex_traits_wrapper.

// this is what our implementation will actually store;

// it provides default implementations of the "optional"

// interfaces that we support, in addition to the

// required "standard" ones:

//

namespace re_detail{

BOOST_MPL_HAS_XXX_TRAIT_DEF(boost_extensions_tag)

#else

template<class T>

struct has_boost_extensions_tag

{

BOOST_STATIC_CONSTANT(bool, value = false);

};

#endif

return ::boost::re_detail::global_upper(c);

}

};

template <class BaseT, bool has_extensions>

struct compute_wrapper_base

{

typedef BaseT type;

};

template <class BaseT>

struct compute_wrapper_base<BaseT, false>

{

typedef default_wrapper<BaseT> type;

};

#else

template <>

struct compute_wrapper_base<c_regex_traits<char>, false>

{

/*

*

* Copyright (c) 2004

* 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.

* FILE regex_traits_defaults.hpp

* VERSION see <boost/version.hpp>

* DESCRIPTION: Declares API's for access to regex_traits default properties.

*/

#ifndef BOOST_REGEX_TRAITS_DEFAULTS_HPP_INCLUDED

#define BOOST_REGEX_TRAITS_DEFAULTS_HPP_INCLUDED

{

return false;

}

template <>

inline bool is_combining<unsigned char>(unsigned char)

{

return false;

}

#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 is_combining_implementation(static_cast<unsigned short>(c));

}

#elif !defined(__DECCXX) && !defined(__osf__) && !defined(__OSF__) && defined(WCHAR_MIN) && (WCHAR_MIN == 0) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)

#if defined(WCHAR_MAX) && (WCHAR_MAX <= USHRT_MAX)

template<>

inline bool is_combining<wchar_t>(wchar_t c)

#endif

//

// is a charT c a line separator?

//

template <class charT>

inline bool is_separator(charT c)

{

return BOOST_REGEX_MAKE_BOOL(

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

}

template <>

inline bool is_separator<char>(char c)

{

return BOOST_REGEX_MAKE_BOOL((c == '\n') || (c == '\r') || (c == '\f'));

}

//

'p', 'u', 'n', 'c', 't',

's', 'p', 'a', 'c', 'e',

'u', 'n', 'i', 'c', 'o', 'd', 'e',

'u', 'p', 'p', 'e', 'r',

'v',

'w', 'o', 'r', 'd',

'x', 'd', 'i', 'g', 'i', 't',

};

{

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

{data+5, data+10,}, // alpha

{data+10, data+15,}, // blank

{data+15, data+20,}, // cntrl

{data+20, data+21,}, // d

{data+20, data+25,}, // digit

{data+25, data+30,}, // graph

{data+29, data+30,}, // h

{data+50, data+57,}, // unicode

{data+57, data+62,}, // upper

{data+62, data+63,}, // v

{data+63, data+64,}, // w

{data+63, data+67,}, // word

{data+67, data+73,}, // xdigit

};

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);

if((p != ranges_end) && (t == *p))

return static_cast<int>(p - ranges);

return -1;

}

//

// helper functions:

}

template <class charT>

inline const charT* get_escape_R_string()

{

#ifdef BOOST_MSVC

# pragma warning(push)

# 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(pop)

#endif

}

template <>

inline const char* get_escape_R_string<char>()

{

#ifdef BOOST_MSVC

# pragma warning(push)

# pragma warning(disable:4309)

#endif

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

return e2;

#ifdef BOOST_MSVC

# pragma warning(pop)

#endif

}

} // re_detail

} // boost

#pragma warning(pop)

#endif

namespace boost{

template <class BidiIterator>

struct sub_match : public std::pair<BidiIterator, BidiIterator>

{

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

typedef std::ptrdiff_t difference_type;

#else

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

#endif

typedef BidiIterator iterator_type;

typedef BidiIterator iterator;

typedef BidiIterator const_iterator;

bool matched;

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

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))

template <class T, class A>

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

{

return matched ? std::basic_string<value_type, T, A>(this->first, this->second) : std::basic_string<value_type, T, A>();

}

#else

operator std::basic_string<value_type> ()const

* FILE u32regex_token_iterator.hpp

* VERSION see <boost/version.hpp>

* DESCRIPTION: Provides u32regex_token_iterator implementation.

*/

#ifndef BOOST_REGEX_V4_U32REGEX_TOKEN_ITERATOR_HPP

#define BOOST_REGEX_V4_U32REGEX_TOKEN_ITERATOR_HPP

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

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

//

// Borland C++ Builder 6, and Visual C++ 6,

// can't cope with the array template constructor

// so we have a template member that will accept any type as

// argument, and then assert that is really is an array:

//

#include <boost/static_assert.hpp>

#include <boost/type_traits/is_array.hpp>

#endif

namespace boost{

#ifdef BOOST_HAS_ABI_HEADERS

# include BOOST_ABI_PREFIX

#endif

# pragma warning(push)

# pragma warning(disable:4700)

#endif

template <class BidirectionalIterator>

class u32regex_token_iterator_implementation

{

typedef u32regex regex_type;

typedef sub_match<BidirectionalIterator> value_type;

value_type result; // the current string result

int N; // the current sub-expression being enumerated

std::vector<int> subs; // the sub-expressions to enumerate

public:

u32regex_token_iterator_implementation(const regex_type* p, BidirectionalIterator last, int sub, match_flag_type f)

: end(last), re(*p), flags(f){ subs.push_back(sub); }

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)

template <class T>

u32regex_token_iterator_implementation(const regex_type* p, BidirectionalIterator last, const T& submatches, match_flag_type f)

: end(last), re(*p), flags(f)

{

// assert that T really is an array:

BOOST_STATIC_ASSERT(::boost::is_array<T>::value);

const std::size_t array_size = sizeof(T) / sizeof(submatches[0]);

pdata.reset();

}

u32regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b, const regex_type& re,

const std::vector<int>& submatches, match_flag_type m = match_default)

: pdata(new impl(&re, b, submatches, m))

{

if(!pdata->init(a))

pdata.reset();

}

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

|| BOOST_WORKAROUND(__HP_aCC, < 60700)

template <class T>

u32regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b, const regex_type& re,

const T& submatches, match_flag_type m = match_default)

: pdata(new impl(&re, b, submatches, m))

{

if(!pdata->init(a))

pdata.reset();

{

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

return u32regex_token_iterator<iter_type>(p.begin(), p.end(), e, submatch, m);

}

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);

}

// construction from a reference to an array:

template <std::size_t N>

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

{

return u32regex_token_iterator<const char*>(p, p+std::strlen(p), e, submatch, m);

}

#ifndef BOOST_NO_WREGEX

template <std::size_t N>

inline u32regex_token_iterator<const wchar_t*> make_u32regex_token_iterator(const wchar_t* 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;

return u32regex_token_iterator<iter_type>(p.begin(), p.end(), e, submatch, m);

}

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)

{

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:

inline u32regex_token_iterator<const char*> make_u32regex_token_iterator(const char* p, const u32regex& e, const std::vector<int>& submatch, regex_constants::match_flag_type m = regex_constants::match_default)

{

return u32regex_token_iterator<const char*>(p, p+std::strlen(p), e, submatch, m);

}

#ifndef BOOST_NO_WREGEX

inline u32regex_token_iterator<const wchar_t*> make_u32regex_token_iterator(const wchar_t* 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;

return u32regex_token_iterator<iter_type>(p.begin(), p.end(), e, submatch, m);

}

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)

{

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

}

# pragma warning(pop)

#endif

#ifdef BOOST_HAS_ABI_HEADERS

# include BOOST_ABI_SUFFIX

#endif

} // namespace boost

#endif // BOOST_REGEX_V4_REGEX_TOKEN_ITERATOR_HPP

{

typedef typename std::map<string_type, string_type>::const_iterator iter_type;

if(m_custom_collate_names.size())

{

iter_type pos = m_custom_collate_names.find(string_type(p1, p2));

if(pos != m_custom_collate_names.end())

return pos->second;

}

#if !defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS)\

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

std::string name(p1, p2);

#else

std::string name;

const charT* p0 = p1;

while(p0 != p2)

name.append(1, char(*p0++));

#endif

name = lookup_default_collate_name(name);

#if !defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS)\

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

if(name.size())

return string_type(name.begin(), name.end());

#else

if(name.size())

{

string_type result;

typedef std::string::const_iterator iter;

iter b = name.begin();

}

std::size_t state_id = 1 + re_detail::get_default_class_id(p1, p2);

if(state_id < sizeof(masks) / sizeof(masks[0]))

return masks[state_id];

return masks[0];

}

template <class charT>

{

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

return boost::object_cache< ::boost::re_detail::lcid_type, w32_regex_traits_implementation<charT> >::get(l, 5);

}

} // re_detail

template <class charT>

class w32_regex_traits