+/*

+ * Shared regex lib will crash without this, frankly it looks a lot like a gcc bug:

+ */

+#if defined(__MINGW32__)

+# define BOOST_REGEX_NO_EXTERNAL_TEMPLATES

+#endif

+# if defined(_DLL) && defined(BOOST_MSVC) && (BOOST_MSVC < 1600)

+ offset_ascii = U_CHAR_CATEGORY_COUNT+6,

+ offset_horizontal = U_CHAR_CATEGORY_COUNT+7,

+ offset_vertical = U_CHAR_CATEGORY_COUNT+8

+ static const char_class_type mask_horizontal;

+ static const char_class_type mask_vertical;

+ typedef std::vector<UChar32> vector_type;

+ v.push_back((UChar32)(*i));

+ ++i;

+inline u32regex make_u32regex(const U_NAMESPACE_QUALIFIER UnicodeString& s, boost::regex_constants::syntax_option_type opt = boost::regex_constants::perl)

+inline bool u32regex_match(const U_NAMESPACE_QUALIFIER UnicodeString& s,

+inline bool u32regex_match(const U_NAMESPACE_QUALIFIER UnicodeString& s,

+inline bool u32regex_search(const U_NAMESPACE_QUALIFIER UnicodeString& s,

+inline bool u32regex_search(const U_NAMESPACE_QUALIFIER UnicodeString& s,

+ const U_NAMESPACE_QUALIFIER UnicodeString& fmt,

+ U_NAMESPACE_QUALIFIER UnicodeString* out;

+ unicode_string_out_iterator(U_NAMESPACE_QUALIFIER UnicodeString& s) : out(&s) {}

+inline U_NAMESPACE_QUALIFIER UnicodeString u32regex_replace(const U_NAMESPACE_QUALIFIER UnicodeString& s,

+ U_NAMESPACE_QUALIFIER UnicodeString result;

+inline U_NAMESPACE_QUALIFIER UnicodeString u32regex_replace(const U_NAMESPACE_QUALIFIER UnicodeString& s,

+ const U_NAMESPACE_QUALIFIER UnicodeString& fmt,

+ U_NAMESPACE_QUALIFIER UnicodeString result;

+#ifdef BOOST_NO_UNREACHABLE_RETURN_DETECTION

+#endif

+extern "C" BOOST_REGEX_DECL void boost_regex_free_static_mutex();

+#include <boost/type_traits/is_same.hpp>

+#include <boost/functional/hash.hpp>

+

+template <class I>

+void bubble_down_one(I first, I last)

+{

+ if(first != last)

+ {

+ I next = last - 1;

+ while((next != first) && !(*(next-1) < *next))

+ {

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

+ --next;

+ }

+ }

+}

+

+//

+// Class named_subexpressions

+// Contains information about named subexpressions within the regex.

+//

+template <class charT>

+class named_subexpressions_base

+{

+public:

+ virtual int get_id(const charT* i, const charT* j)const = 0;

+ virtual int get_id(std::size_t hash)const = 0;

+#ifdef __GNUC__

+ // warning supression:

+ virtual ~named_subexpressions_base(){}

+#endif

+};

+

+template <class Iterator>

+inline std::size_t hash_value_from_capture_name(Iterator i, Iterator j)

+{

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

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

+ r += 10000;

+ return r;

+}

+

+template <class charT>

+class named_subexpressions : public named_subexpressions_base<charT>

+{

+ struct name

+ {

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

+ : /*n(i, j), */ index(idx)

+ {

+ hash = hash_value_from_capture_name(i, j);

+ }

+ name(std::size_t h, int idx)

+ : index(idx), hash(h)

+ {

+ }

+ //std::vector<charT> n;

+ int index;

+ std::size_t hash;

+ bool operator < (const name& other)const

+ {

+ return hash < other.hash; //std::lexicographical_compare(n.begin(), n.end(), other.n.begin(), other.n.end());

+ }

+ bool operator == (const name& other)const

+ {

+ return hash == other.hash; //n == other.n;

+ }

+ void swap(name& other)

+ {

+ //n.swap(other.n);

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

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

+ }

+ };

+public:

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

+ typename std::vector<name>::const_iterator pos = std::lower_bound(m_sub_names.begin(), m_sub_names.end(), t);

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

+ {

+ return pos->index;

+ }

+ return -1;

+ }

+ int get_id(std::size_t h)const

+ {

+ name t(h, 0);

+ typename std::vector<name>::const_iterator pos = std::lower_bound(m_sub_names.begin(), m_sub_names.end(), t);

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

+ {

+ return pos->index;

+ }

+ return -1;

+ }

+private:

+ std::vector<name> m_sub_names;

+};

+

+template <class charT, class Other>

+class named_subexpressions_converter : public named_subexpressions_base<charT>

+{

+ boost::shared_ptr<named_subexpressions<Other> > m_converter;

+public:

+ named_subexpressions_converter(boost::shared_ptr<named_subexpressions<Other> > s)

+ : m_converter(s) {}

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

+ {

+ if(i == j)

+ return -1;

+ std::vector<Other> v;

+ while(i != j)

+ {

+ v.push_back(*i);

+ ++i;

+ }

+ return m_converter->get_id(&v[0], &v[0] + v.size());

+ }

+ int get_id(std::size_t h)const

+ {

+ return m_converter->get_id(h);

+ }

+};

+

+template <class To>

+inline boost::shared_ptr<named_subexpressions_base<To> > convert_to_named_subs_imp(

+ boost::shared_ptr<named_subexpressions<To> > s,

+ boost::integral_constant<bool,true> const&)

+{

+ return s;

+}

+template <class To, class From>

+inline boost::shared_ptr<named_subexpressions_base<To> > convert_to_named_subs_imp(

+ boost::shared_ptr<named_subexpressions<From> > s,

+ boost::integral_constant<bool,false> const&)

+{

+ return boost::shared_ptr<named_subexpressions_converter<To, From> >(new named_subexpressions_converter<To, From>(s));

+}

+template <class To, class From>

+inline boost::shared_ptr<named_subexpressions_base<To> > convert_to_named_subs(

+ boost::shared_ptr<named_subexpressions<From> > s)

+{

+ typedef typename boost::is_same<To, From>::type tag_type;

+ return convert_to_named_subs_imp<To>(s, tag_type());

+}

+struct regex_data : public named_subexpressions<charT>

+ bool m_has_recursions; // whether we have recursive expressions;

+ boost::shared_ptr<re_detail::named_subexpressions<charT> > get_named_subs()const

+ {

+ return m_pimpl;

+ }

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

+ void fixup_recursions(re_syntax_base* state);

+ : m_pdata(data), m_traits(*(data->m_ptraits)), m_last_state(0), m_repeater_id(0), m_has_backrefs(false), m_backrefs(0), m_has_recursions(false)

+ if(this->m_pdata->m_status)

+ return;

+ if(m_has_recursions)

+ {

+ m_pdata->m_has_recursions = true;

+ fixup_recursions(m_pdata->m_first_state);

+ if(this->m_pdata->m_status)

+ return;

+ }

+ else

+ m_pdata->m_has_recursions = false;

+ case syntax_element_recurse:

+ m_has_recursions = true;

+ if(state->next.i)

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

+ else

+ state->next.p = 0;

+ break;

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

+{

+ re_syntax_base* base = state;

+ while(state)

+ {

+ switch(state->type)

+ {

+ case syntax_element_assert_backref:

+ {

+ // just check that the index is valid:

+ int id = static_cast<const re_brace*>(state)->index;

+ if(id < 0)

+ {

+ id = -id-1;

+ if(id >= 10000)

+ {

+ id = m_pdata->get_id(id);

+ if(id <= 0)

+ {

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

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

+ this->m_pdata->m_status = boost::regex_constants::error_bad_pattern;

+ //

+ // clear the expression, we should be empty:

+ //

+ this->m_pdata->m_expression = 0;

+ this->m_pdata->m_expression_len = 0;

+ //

+ // and throw if required:

+ //

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

+ {

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

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

+ e.raise();

+ }

+ }

+ }

+ }

+ }

+ break;

+ case syntax_element_recurse:

+ {

+ bool ok = false;

+ re_syntax_base* p = base;

+ int id = static_cast<re_jump*>(state)->alt.i;

+ if(id > 10000)

+ id = m_pdata->get_id(id);

+ while(p)

+ {

+ if((p->type == syntax_element_startmark) && (static_cast<re_brace*>(p)->index == id))

+ {

+ //

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

+ //

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

+ ok = true;

+ //

+ // Now scan the target for nested repeats:

+ //

+ p = p->next.p;

+ int next_rep_id = 0;

+ while(p)

+ {

+ switch(p->type)

+ {

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

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

+ break;

+ case syntax_element_endmark:

+ if(static_cast<const re_brace*>(p)->index == id)

+ next_rep_id = -1;

+ break;

+ default:

+ break;

+ }

+ if(next_rep_id)

+ break;

+ p = p->next.p;

+ }

+ if(next_rep_id > 0)

+ {

+ static_cast<re_recurse*>(state)->state_id = next_rep_id - 1;

+ }

+

+ break;

+ }

+ p = p->next.p;

+ }

+ if(!ok)

+ {

+ // recursion to sub-expression that doesn't exist:

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

+ this->m_pdata->m_status = boost::regex_constants::error_bad_pattern;

+ //

+ // clear the expression, we should be empty:

+ //

+ this->m_pdata->m_expression = 0;

+ this->m_pdata->m_expression_len = 0;

+ //

+ // and throw if required:

+ //

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

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

+ re_syntax_base* recursion_start = 0;

+ int recursion_sub = 0;

+ re_syntax_base* recursion_restart = 0;

+ case syntax_element_recurse:

+ {

+ if(recursion_start == state)

+ {

+ // Infinite recursion!!

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

+ this->m_pdata->m_status = boost::regex_constants::error_bad_pattern;

+ //

+ // clear the expression, we should be empty:

+ //

+ this->m_pdata->m_expression = 0;

+ this->m_pdata->m_expression_len = 0;

+ //

+ // and throw if required:

+ //

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

+ {

+ std::string message = "Encountered an infinite recursion.";

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

+ e.raise();

+ }

+ }

+ else if(recursion_start == 0)

+ {

+ recursion_start = state;

+ recursion_restart = state->next.p;

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

+ if(state->type == syntax_element_startmark)

+ recursion_sub = static_cast<re_brace*>(state)->index;

+ else

+ recursion_sub = 0;

+ break;

+ }

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

+ }

+ else if(recursion_start && (recursion_sub != 0) && (recursion_sub == static_cast<re_brace*>(state)->index))

+ // recursion termination:

+ recursion_start = 0;

+ state = recursion_restart;

+ //

+ // Normally we just go to the next state... but if this sub-expression is

+ // the target of a recursion, then we might be ending a recursion, in which

+ // case we should check whatever follows that recursion, as well as whatever

+ // follows this state:

+ //

+ if(m_pdata->m_has_recursions && static_cast<re_brace*>(state)->index)

+ {

+ bool ok = false;

+ re_syntax_base* p = m_pdata->m_first_state;

+ while(p)

+ {

+ if((p->type == syntax_element_recurse))

+ {

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

+ {

+ ok = true;

+ break;

+ }

+ }

+ p = p->next.p;

+ }

+ if(ok)

+ {

+ create_startmap(p->next.p, l_map, pnull, mask);

+ }

+ }

+ state = state->next.p;

+ break;

+

+ void fail(regex_constants::error_type error_code, std::ptrdiff_t position, std::string message, std::ptrdiff_t start_pos);

+ void fail(regex_constants::error_type error_code, std::ptrdiff_t position, const std::string& message)

+ {

+ fail(error_code, position, message, position);

+ }

+ int m_mark_reset; // used to indicate that we're inside a (?|...) block.

+ unsigned m_max_mark; // largest mark count seen inside a (?|...) block.

+ : basic_regex_creator<charT, traits>(data), m_mark_count(0), m_mark_reset(-1), m_max_mark(0), m_paren_start(0), m_alt_insert_point(0), m_has_case_change(false)

+ {

+ m_parser_proc = &basic_regex_parser<charT, traits>::parse_extended;

+ //

+ // Add a leading paren with index zero to give recursions a target:

+ //

+ re_brace* br = static_cast<re_brace*>(this->append_state(syntax_element_startmark, sizeof(re_brace)));

+ br->index = 0;

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

+ break;

+ }

+ default:

+ // Ooops, someone has managed to set more than one of the main option flags,

+ // so this must be an error:

+ fail(regex_constants::error_unknown, 0, "An invalid combination of regular expression syntax flags was used.");

+ return;

+ fail(regex_constants::error_paren, ::boost::re_detail::distance(m_base, m_position), "Found a closing ) with no corresponding openening parenthesis.");

+ // get the error message:

+ std::string message = this->m_pdata->m_ptraits->error_string(error_code);

+ fail(error_code, position, message);

+}

+

+template <class charT, class traits>

+void basic_regex_parser<charT, traits>::fail(regex_constants::error_type error_code, std::ptrdiff_t position, std::string message, std::ptrdiff_t start_pos)

+{

+

+ //

+ // Augment error message with the regular expression text:

+ //

+ if(start_pos == position)

+ start_pos = (std::max)(static_cast<std::ptrdiff_t>(0), position - static_cast<std::ptrdiff_t>(10));

+ std::ptrdiff_t end_pos = (std::min)(position + static_cast<std::ptrdiff_t>(10), static_cast<std::ptrdiff_t>(m_end - m_base));

+ if(error_code != regex_constants::error_empty)

+ {

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

+ message += " The error occured while parsing the regular expression fragment: '";

+ else

+ message += " The error occured while parsing the regular expression: '";

+ if(start_pos != end_pos)

+ {

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

+ message += ">>>HERE>>>";

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

+ }

+ message += "'.";

+ }

+

+ fail(regex_constants::error_badrepeat, 0, "The repeat operator \"*\" cannot start a regular expression.");

+ fail(regex_constants::error_badrepeat, 0, "The repeat operator \"?\" cannot start a regular expression.");

+ fail(regex_constants::error_badrepeat, 0, "The repeat operator \"+\" cannot start a regular expression.");

+ fail(regex_constants::error_brace, this->m_position - this->m_base, "Found a closing repetition operator } with no corresponding {.");

+#ifndef BOOST_NO_STD_DISTANCE

+#else

+ if(this->flags() & regbase::save_subexpression_location)

+ this->m_pdata->m_subs.push_back(std::pair<std::size_t, std::size_t>((m_position - m_base) - 1, 0));

+#endif

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

+ // Back up branch reset data in case we have a nested (?|...)

+ //

+ int mark_reset = m_mark_reset;

+ m_mark_reset = -1;

+ //

+ // restore branch reset:

+ //

+ m_mark_reset = mark_reset;

+ //

+#ifndef BOOST_NO_STD_DISTANCE

+#else

+ if(markid && (this->flags() & regbase::save_subexpression_location))

+ this->m_pdata->m_subs.at(markid - 1).second = (m_position - m_base);

+#endif

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

+ fail(regex_constants::error_brace, this->m_position - this->m_base, "Found a closing repetition operator } with no corresponding {.");

+ 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.");

+escape_type_class_jump:

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

+ fail(regex_constants::error_escape, m_position - m_base, "Closing } missing from property escape sequence.");

+ fail(regex_constants::error_ctype, m_position - m_base, "Escape sequence was neither a valid property nor a valid character class name.");

+ return false;

+ }

+ case regex_constants::escape_type_reset_start_mark:

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

+ {

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

+ pb->index = -5;

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

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

+ ++m_position;

+ return true;

+ }

+ goto escape_type_class_jump;

+ case regex_constants::escape_type_line_ending:

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

+ {

+ const charT* e = get_escape_R_string<charT>();

+ const charT* old_position = m_position;

+ const charT* old_end = m_end;

+ const charT* old_base = m_base;

+ m_position = e;

+ m_base = e;

+ m_end = e + traits::length(e);

+ bool r = parse_all();

+ m_position = ++old_position;

+ m_end = old_end;

+ m_base = old_base;

+ return r;

+ }

+ goto escape_type_class_jump;

+ case regex_constants::escape_type_extended_backref:

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

+ {

+ bool have_brace = false;

+ bool negative = false;

+ static const char* incomplete_message = "Incomplete \\g escape found.";

+ if(++m_position == m_end)

+ {

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

+ return false;

+ }

+ // maybe have \g{ddd}

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

+ {

+ if(++m_position == m_end)

+ {

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

+ return false;

+ }

+ have_brace = true;

+ }

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

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

+ {

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

+ return false;

+ }

+ const charT* pc = m_position;

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

+ if(i < 0)

+ {

+ // Check for a named capture:

+ const charT* base = m_position;

+ while((m_position != m_end) && (this->m_traits.syntax_type(*m_position) != regex_constants::syntax_close_brace))

+ ++m_position;

+ i = this->m_pdata->get_id(base, m_position);

+ pc = m_position;

+ }

+ if(negative)

+ i = 1 + m_mark_count - i;

+ if((i > 0) && (this->m_backrefs & (1u << (i-1))))

+ {

+ m_position = pc;

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

+ pb->index = i;

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

+ }

+ else

+ {

+ fail(regex_constants::error_backref, m_position - m_base);

+ return false;

+ }

+ m_position = pc;

+ if(have_brace)

+ {

+ if((m_position == m_end) || (this->m_traits.syntax_type(*m_position) != regex_constants::syntax_close_brace))

+ {

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

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

+ // fallthrough:

+ bool pocessive = false;

+ // OK we have a perl or emacs regex, check for a '?':

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

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

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

+ {

+ pocessive = true;

+ ++m_position;

+ }

+ fail(regex_constants::error_badrepeat, ::boost::re_detail::distance(m_base, m_position), "Nothing to repeat.");

+ //

+ // If the repeat is pocessive then bracket the repeat with a (?>...)

+ // independent sub-expression construct:

+ //

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

+ jmp = static_cast<re_jump*>(this->insert_state(insert_point + sizeof(re_brace), syntax_element_jump, sizeof(re_jump)));

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

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

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

+ pb->index = -3;

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

+ }

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

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

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

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

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

+ // Backtrack to error location:

+ m_position -= 2;

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

+ ++m_position;

+ fail(regex_constants::error_badbrace, m_position - m_base);

+ fail(regex_constants::error_empty, this->m_position - this->m_base, "A regular expression can start with the alternation operator |.");

+ //

+ // Reset mark count if required:

+ //

+ if(m_max_mark < m_mark_count)

+ m_max_mark = m_mark_count;

+ if(m_mark_reset >= 0)

+ m_mark_count = m_mark_reset;

+

+ static const char* incomplete_message = "Character set declaration starting with [ terminated prematurely - either no ] was found or the set had no content.";

+ fail(regex_constants::error_brack, m_position - m_base, incomplete_message);

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

+ static const char* incomplete_message = "Character class declaration starting with [ terminated prematurely - either no ] was found or the set had no content.";

+ fail(regex_constants::error_brack, m_position - m_base, incomplete_message);

+ fail(regex_constants::error_brack, m_position - m_base, incomplete_message);

+ fail(regex_constants::error_brack, m_position - m_base, incomplete_message);

+ fail(regex_constants::error_brack, m_position - m_base, incomplete_message);

+ fail(regex_constants::error_brack, m_position - m_base, incomplete_message);

+ fail(regex_constants::error_brack, m_position - m_base, incomplete_message);

+ fail(regex_constants::error_brack, m_position - m_base, incomplete_message);

+ fail(regex_constants::error_brack, m_position - m_base, incomplete_message);

+ fail(regex_constants::error_brack, m_position - m_base, incomplete_message);

+ fail(regex_constants::error_escape, m_position - m_base, "Escape sequence terminated prematurely.");

+ // Rewind to start of escape:

+ --m_position;

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

+ fail(regex_constants::error_escape, m_position - m_base, "ASCII escape sequence terminated prematurely.");

+ // Rewind to start of escape:

+ --m_position;

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

+ fail(regex_constants::error_escape, m_position - m_base, "Hexadecimal escape sequence terminated prematurely.");

+ // Rewind to start of escape:

+ --m_position;

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

+ fail(regex_constants::error_escape, m_position - m_base, "Missing } in hexadecimal escape sequence.");

+ || ((std::numeric_limits<charT>::is_specialized) && (i > (int)(std::numeric_limits<charT>::max)()))

+ // Rewind to start of escape:

+ --m_position;

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

+ fail(regex_constants::error_badbrace, m_position - m_base, "Hexadecimal escape sequence was invalid.");

+ std::ptrdiff_t len = (std::min)(static_cast<std::ptrdiff_t>(2), static_cast<std::ptrdiff_t>(m_end - m_position));

+ // Rewind to start of escape:

+ --m_position;

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

+ fail(regex_constants::error_escape, m_position - m_base, "Escape sequence did not encode a valid character.");

+ // Rewind to start of escape:

+ --m_position;

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

+ fail(regex_constants::error_escape, m_position - m_base, "Invalid octal escape sequence.");

+ // Rewind to start of escape:

+ --m_position;

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

+ fail(regex_constants::error_escape, m_position - m_base, "Octal escape sequence is invalid.");

+ // Rewind to start of escape:

+ --m_position;

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

+ // Rewind to start of escape:

+ --m_position;

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

+ // Rewind to start of escape:

+ --m_position;

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

+ // Rewind to start of escape:

+ --m_position;

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

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

+ // Rewind to start of escape:

+ --m_position;

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

+ fail(regex_constants::error_backref, m_position - m_base);

+ fail(regex_constants::error_escape, m_position - m_base, "Unterminated \\Q...\\E sequence.");

+ // Rewind to start of (? sequence:

+ --m_position;

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

+ fail(regex_constants::error_perl_extension, m_position - m_base);

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

+ charT name_delim;

+ int mark_reset = m_mark_reset;

+ m_mark_reset = -1;

+ int v;

+ case regex_constants::syntax_or:

+ m_mark_reset = m_mark_count;

+ // fall through:

+ case regex_constants::syntax_digit:

+ {

+ //

+ // a recursive subexpression:

+ //

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

+ if((v < 0) || (this->m_traits.syntax_type(*m_position) != regex_constants::syntax_close_mark))

+ {

+ // Rewind to start of (? sequence:

+ --m_position;

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

+ fail(regex_constants::error_perl_extension, m_position - m_base, "The recursive sub-expression refers to an invalid marking group, or is unterminated.");

+ return false;

+ }

+insert_recursion:

+ pb->index = markid = 0;

+ re_recurse* pr = static_cast<re_recurse*>(this->append_state(syntax_element_recurse, sizeof(re_recurse)));

+ pr->alt.i = v;

+ pr->state_id = 0;

+ static_cast<re_case*>(

+ this->append_state(syntax_element_toggle_case, sizeof(re_case))

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

+ break;

+ }

+ case regex_constants::syntax_plus:

+ //

+ // A forward-relative recursive subexpression:

+ //

+ ++m_position;

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

+ if((v <= 0) || (this->m_traits.syntax_type(*m_position) != regex_constants::syntax_close_mark))

+ {

+ // Rewind to start of (? sequence:

+ --m_position;

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

+ fail(regex_constants::error_perl_extension, m_position - m_base, "An invalid or unterminated recursive sub-expression.");

+ return false;

+ }

+ v += m_mark_count;

+ goto insert_recursion;

+ case regex_constants::syntax_dash:

+ //

+ // Possibly a backward-relative recursive subexpression:

+ //

+ ++m_position;

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

+ if(v <= 0)

+ {

+ --m_position;

+ // Oops not a relative recursion at all, but a (?-imsx) group:

+ goto option_group_jump;

+ }

+ v = m_mark_count + 1 - v;

+ if(v <= 0)

+ {

+ // Rewind to start of (? sequence:

+ --m_position;

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

+ fail(regex_constants::error_perl_extension, m_position - m_base, "An invalid or unterminated recursive sub-expression.");

+ return false;

+ }

+ goto insert_recursion;

+ // Rewind to start of (? sequence:

+ --m_position;

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

+ fail(regex_constants::error_perl_extension, m_position - m_base);

+ // Probably a named capture which also starts (?< :

+ name_delim = '>';

+ --m_position;

+ goto named_capture_jump;

+ // Rewind to start of (? sequence:

+ --m_position;

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

+ fail(regex_constants::error_perl_extension, m_position - m_base);

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

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

+ {

+ if(++m_position == m_end)

+ {

+ // Rewind to start of (? sequence:

+ --m_position;

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

+ fail(regex_constants::error_perl_extension, m_position - m_base);

+ return false;

+ }

+ if(*m_position == charT('&'))

+ {

+ const charT* base = ++m_position;

+ while((m_position != m_end) && (this->m_traits.syntax_type(*m_position) != regex_constants::syntax_close_mark))

+ ++m_position;

+ if(m_position == m_end)

+ {

+ // Rewind to start of (? sequence:

+ --m_position;

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

+ fail(regex_constants::error_perl_extension, m_position - m_base);

+ return false;

+ }

+ v = -static_cast<int>(hash_value_from_capture_name(base, m_position));

+ }

+ else

+ {

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

+ }

+ re_brace* br = static_cast<re_brace*>(this->append_state(syntax_element_assert_backref, sizeof(re_brace)));

+ br->index = v < 0 ? (v - 1) : 0;

+ if(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_close_mark)

+ {

+ // Rewind to start of (? sequence:

+ --m_position;

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

+ fail(regex_constants::error_perl_extension, m_position - m_base);

+ return false;

+ }

+ if(++m_position == m_end)

+ {

+ // Rewind to start of (? sequence:

+ --m_position;

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

+ fail(regex_constants::error_perl_extension, m_position - m_base);

+ return false;

+ }

+ }

+ else if((*m_position == charT('\'')) || (*m_position == charT('<')))

+ {

+ const charT* base = ++m_position;

+ while((m_position != m_end) && (*m_position != charT('>')) && (*m_position != charT('\'')))

+ ++m_position;

+ if(m_position == m_end)

+ {

+ // Rewind to start of (? sequence:

+ --m_position;

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

+ fail(regex_constants::error_perl_extension, m_position - m_base);

+ return false;

+ }

+ v = static_cast<int>(hash_value_from_capture_name(base, m_position));

+ re_brace* br = static_cast<re_brace*>(this->append_state(syntax_element_assert_backref, sizeof(re_brace)));

+ br->index = v;

+ if(((*m_position != charT('>')) && (*m_position != charT('\''))) || (++m_position == m_end))

+ {

+ // Rewind to start of (? sequence:

+ --m_position;

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

+ fail(regex_constants::error_perl_extension, m_position - m_base, "Unterminated named capture.");

+ return false;

+ }

+ if(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_close_mark)

+ {

+ // Rewind to start of (? sequence:

+ --m_position;

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

+ fail(regex_constants::error_perl_extension, m_position - m_base);

+ return false;

+ }

+ if(++m_position == m_end)

+ {

+ // Rewind to start of (? sequence:

+ --m_position;

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

+ fail(regex_constants::error_perl_extension, m_position - m_base);

+ return false;

+ }

+ }

+ else if(*m_position == charT('D'))

+ {

+ const char* def = "DEFINE";

+ while(*def && (m_position != m_end) && (*m_position == charT(*def)))

+ ++m_position, ++def;

+ if((m_position == m_end) || *def)

+ {

+ // Rewind to start of (? sequence:

+ --m_position;

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

+ fail(regex_constants::error_perl_extension, m_position - m_base);

+ return false;

+ }

+ re_brace* br = static_cast<re_brace*>(this->append_state(syntax_element_assert_backref, sizeof(re_brace)));

+ br->index = 9999; // special magic value!

+ if(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_close_mark)

+ {

+ // Rewind to start of (? sequence:

+ --m_position;

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

+ fail(regex_constants::error_perl_extension, m_position - m_base);

+ return false;

+ }

+ if(++m_position == m_end)

+ {

+ // Rewind to start of (? sequence:

+ --m_position;

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

+ fail(regex_constants::error_perl_extension, m_position - m_base);

+ return false;

+ }

+ }

+ else if(v > 0)

+ // Rewind to start of (? sequence:

+ --m_position;

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

+ fail(regex_constants::error_perl_extension, m_position - m_base);

+ // Rewind to start of (? sequence:

+ --m_position;

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

+ fail(regex_constants::error_perl_extension, m_position - m_base);

+ // Rewind to start of (? sequence:

+ --m_position;

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

+ fail(regex_constants::error_perl_extension, m_position - m_base);

+ // Rewind to start of (? sequence:

+ --m_position;

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

+ fail(regex_constants::error_perl_extension, m_position - m_base);

+ // Rewind to start of (? sequence:

+ --m_position;

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

+ fail(regex_constants::error_perl_extension, m_position - m_base);

+ // Rewind to start of (? sequence:

+ --m_position;

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

+ fail(regex_constants::error_perl_extension, m_position - m_base);

+ // Rewind to start of (? sequence:

+ --m_position;

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

+ fail(regex_constants::error_perl_extension, m_position - m_base);

+ // Rewind to start of (? sequence:

+ --m_position;

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

+ fail(regex_constants::error_perl_extension, m_position - m_base);

+ case regex_constants::escape_type_end_buffer:

+ {

+ name_delim = *m_position;

+named_capture_jump:

+ markid = 0;

+ if(0 == (this->flags() & regbase::nosubs))

+ {

+ markid = ++m_mark_count;

+ #ifndef BOOST_NO_STD_DISTANCE

+ if(this->flags() & regbase::save_subexpression_location)

+ this->m_pdata->m_subs.push_back(std::pair<std::size_t, std::size_t>(std::distance(m_base, m_position) - 2, 0));

+ #else

+ if(this->flags() & regbase::save_subexpression_location)

+ this->m_pdata->m_subs.push_back(std::pair<std::size_t, std::size_t>((m_position - m_base) - 2, 0));

+ #endif

+ }

+ pb->index = markid;

+ const charT* base = ++m_position;

+ if(m_position == m_end)

+ {

+ // Rewind to start of (? sequence:

+ --m_position;

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

+ fail(regex_constants::error_perl_extension, m_position - m_base);

+ return false;

+ }

+ while((m_position != m_end) && (*m_position != name_delim))

+ ++m_position;

+ if(m_position == m_end)

+ {

+ // Rewind to start of (? sequence:

+ --m_position;

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

+ fail(regex_constants::error_perl_extension, m_position - m_base);

+ return false;

+ }

+ this->m_pdata->set_name(base, m_position, markid);

+ ++m_position;

+ break;

+ }

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

+ {

+ ++m_position;

+ v = 0;

+ if(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_close_mark)

+ {

+ // Rewind to start of (? sequence:

+ --m_position;

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

+ fail(regex_constants::error_perl_extension, m_position - m_base);

+ return false;

+ }

+ goto insert_recursion;

+ }

+ if(*m_position == charT('&'))

+ {

+ ++m_position;

+ const charT* base = m_position;

+ while((m_position != m_end) && (this->m_traits.syntax_type(*m_position) != regex_constants::syntax_close_mark))

+ ++m_position;

+ if(m_position == m_end)

+ {

+ // Rewind to start of (? sequence:

+ --m_position;

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

+ fail(regex_constants::error_perl_extension, m_position - m_base);

+ return false;

+ }

+ v = static_cast<int>(hash_value_from_capture_name(base, m_position));

+ goto insert_recursion;

+ }

+ if(*m_position == charT('P'))

+ {

+ ++m_position;

+ if(m_position == m_end)

+ {

+ // Rewind to start of (? sequence:

+ --m_position;

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

+ fail(regex_constants::error_perl_extension, m_position - m_base);

+ return false;

+ }

+ if(*m_position == charT('>'))

+ {

+ ++m_position;

+ const charT* base = m_position;

+ while((m_position != m_end) && (this->m_traits.syntax_type(*m_position) != regex_constants::syntax_close_mark))

+ ++m_position;

+ if(m_position == m_end)

+ {

+ // Rewind to start of (? sequence:

+ --m_position;

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

+ fail(regex_constants::error_perl_extension, m_position - m_base);

+ return false;

+ }

+ v = static_cast<int>(hash_value_from_capture_name(base, m_position));

+ goto insert_recursion;

+ }

+ }

+option_group_jump:

+ {

+ // Rewind to start of (? sequence:

+ --m_position;

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

+ fail(regex_constants::error_perl_extension, m_position - m_base);

+ }

+ // Rewind to start of (? sequence:

+ --m_position;

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

+ fail(regex_constants::error_perl_extension, m_position - m_base);

+ {

+ // Rewind to start of (? sequence:

+ --m_position;

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

+ fail(regex_constants::error_perl_extension, m_position - m_base, "Invalid alternation operators within (?...) block.");

+ }

+ // Rewind to start of (? sequence:

+ --m_position;

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

+ // Rewind to start of (? sequence:

+ --m_position;

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

+ fail(regex_constants::error_perl_extension, m_position - m_base, "Invalid or empty zero width assertion.");

+ // Can't have seen more than one alternative:

+ // Rewind to start of (? sequence:

+ --m_position;

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

+ fail(regex_constants::error_bad_pattern, m_position - m_base, "More than one alternation operator | was encountered inside a conditional expression.");

+ else

+ {

+ // We must *not* have seen an alternative inside a (DEFINE) block:

+ b = this->getaddress(b->next.i, b);

+ if((b->type == syntax_element_assert_backref) && (static_cast<re_brace*>(b)->index == 9999))

+ {

+ // Rewind to start of (? sequence:

+ --m_position;

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

+ fail(regex_constants::error_bad_pattern, m_position - m_base, "Alternation operators are not allowed inside a DEFINE block.");

+ return false;

+ }

+ }

+ // Rewind to start of (? sequence:

+ --m_position;

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

+ fail(regex_constants::error_badrepeat, m_position - m_base, "A repetition operator cannot be applied to a zero-width assertion.");

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

+ //

+ // And the mark_reset data:

+ //

+ if(m_max_mark > m_mark_count)

+ {

+ m_mark_count = m_max_mark;

+ }

+ m_mark_reset = mark_reset;

+

+

+ if(markid > 0)

+ {

+#ifndef BOOST_NO_STD_DISTANCE

+ if(this->flags() & regbase::save_subexpression_location)

+ this->m_pdata->m_subs.at(markid - 1).second = std::distance(m_base, m_position) - 1;

+#else

+ if(this->flags() & regbase::save_subexpression_location)

+ this->m_pdata->m_subs.at(markid - 1).second = (m_position - m_base) - 1;

+#endif

+ //

+ // allow backrefs to this mark:

+ //

+ if((markid > 0) && (markid < (int)(sizeof(unsigned) * CHAR_BIT)))

+ this->m_backrefs |= 1u << (markid - 1);

+ }

+ // Rewind to start of sequence:

+ --m_position;

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

+ // Rewind to start of (? sequence:

+ --m_position;

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

+ // Rewind to start of (? sequence:

+ --m_position;

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

+ // Rewind to start of (? sequence:

+ --m_position;

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

+ fail(regex_constants::error_empty, this->m_position - this->m_base, "Can't terminate a sub-expression with an alternation operator |.");

+ return m_pcollate < b.m_pcollate;

+ m_pmessages = BOOST_HAS_FACET(std::messages<charT>, l) ? &BOOST_USE_FACET(std::messages<charT>, l) : 0;

+ if(cat_name.size() && (this->m_pmessages != 0))

+ if(this->m_pmessages)

+ this->m_pmessages->close(cat);

+ char_class_unicode=1<<11,

+ char_class_horizontal_space=1<<12,

+ char_class_vertical_space=1<<13

+ BOOST_STATIC_CONSTANT(char_class_type, mask_horizontal = 1u << 27);

+ BOOST_STATIC_CONSTANT(char_class_type, mask_vertical = 1u << 28);

+template <class charT>

+typename cpp_regex_traits_implementation<charT>::char_class_type const cpp_regex_traits_implementation<charT>::mask_vertical;

+template <class charT>

+typename cpp_regex_traits_implementation<charT>::char_class_type const cpp_regex_traits_implementation<charT>::mask_horizontal;

+ if(cat_name.size() && (this->m_pmessages != 0))

+ static const char_class_type masks[16] =

+ cpp_regex_traits_implementation<charT>::mask_horizontal,

+ cpp_regex_traits_implementation<charT>::mask_vertical,

+ static const char_class_type masks[16] =

+ ::boost::re_detail::char_class_horizontal_space,

+ ::boost::re_detail::char_class_vertical_space,

+ static const char_class_type masks[22] =

+ cpp_regex_traits_implementation<charT>::mask_horizontal,

+ cpp_regex_traits_implementation<charT>::mask_vertical,

+ static const char_class_type masks[22] =

+ ::boost::re_detail::char_class_horizontal_space,

+ ::boost::re_detail::char_class_vertical_space,

+ || ((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) && m_pctype->is(std::ctype<charT>::space, c) && !(is_separator(c) || (c == '\v')));

+ else if((f & re_detail::cpp_regex_traits_implementation<charT>::mask_vertical)

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

+ return true;

+ else if((f & re_detail::cpp_regex_traits_implementation<charT>::mask_horizontal)

+ && this->isctype(c, std::ctype<charT>::space) && !this->isctype(c, re_detail::cpp_regex_traits_implementation<charT>::mask_vertical))

+ return true;

+/*

+ * POSIX error codes:

+ */

+typedef reg_error_t reg_errcode_t; /* backwards compatibility */

+static const reg_error_t REG_E_PERL = 20; /* Perl (?...) error */

+static const reg_error_t REG_E_UNKNOWN = 21; /* unknown error */

+static const reg_error_t REG_ENOSYS = 21; /* = REG_E_UNKNOWN : Reserved. */

+} /* extern "C" */

+} /* namespace */

+/*

+ * C++ high level wrapper goes here:

+ */

+} /* namespace re_detail */

+ /*

+ * now matching operators:

+ */

+ /*

+ * now operators for returning what matched in more detail:

+ */

+} /* namespace boost */

+#endif /* __cplusplus */

+#endif /* include guard */

+ error_ok = 0, /* not used */

+ error_no_match = 1, /* not used */

+ error_end = 14, /* not used */

+ error_right_paren = 16, /* not used */

+ error_perl_extension = 20,

+ error_unknown = 21

+#endif /* __cplusplus */

+#ifndef BOOST_NO_STD_ITERATOR_TRAITS

+#else

+ BOOST_STATIC_CONSTANT(bool, value = false);

+#endif

+ match_not_bol = 1, /* first is not start of line */

+ match_not_eol = match_not_bol << 1, /* last is not end of line */

+ match_not_bob = match_not_eol << 1, /* first is not start of buffer */

+ match_not_eob = match_not_bob << 1, /* last is not end of buffer */

+ match_not_bow = match_not_eob << 1, /* first is not start of word */

+ match_not_eow = match_not_bow << 1, /* last is not end of word */

+ match_not_dot_newline = match_not_eow << 1, /* \n is not matched by '.' */

+ match_not_dot_null = match_not_dot_newline << 1, /* '\0' is not matched by '.' */

+ match_prev_avail = match_not_dot_null << 1, /* *--first is a valid expression */

+ match_init = match_prev_avail << 1, /* internal use */

+ match_any = match_init << 1, /* don't care what we match */

+ match_not_null = match_any << 1, /* string can't be null */

+ match_continuous = match_not_null << 1, /* each grep match must continue from */

+ /* uninterupted from the previous one */

+ match_partial = match_continuous << 1, /* find partial matches */

+ match_stop = match_partial << 1, /* stop after first match (grep) V3 only */

+ match_not_initial_null = match_stop, /* don't match initial null, V4 only */

+ match_all = match_stop << 1, /* must find the whole of input even if match_any is set */

+ match_perl = match_all << 1, /* Use perl matching rules */

+ match_posix = match_perl << 1, /* Use POSIX matching rules */

+ match_nosubs = match_posix << 1, /* don't trap marked subs */

+ match_extra = match_nosubs << 1, /* include full capture information for repeated captures */

+ match_single_line = match_extra << 1, /* treat text as single line and ignor any \n's when matching ^ and $. */

+ match_unused1 = match_single_line << 1, /* unused */

+ match_unused2 = match_unused1 << 1, /* unused */

+ match_unused3 = match_unused2 << 1, /* unused */

+ format_perl = 0, /* perl style replacement */

+ format_default = 0, /* ditto. */

+ 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 */

+} /* namespace regex_constants */

+/*

+ * import names into boost for backwards compatiblity:

+ */

+/* using regex_constants::match_init; */

+/*using regex_constants::match_stop; */

+/*using regex_constants::match_max; */

+/*using regex_constants::format_is_if;*/

+} /* namespace boost */

+#endif /* __cplusplus */

+#endif /* include guard */

+ * Copyright (c) 1998-2009

+namespace re_detail{

+

+template <class charT>

+class named_subexpressions;

+

+}

+

+ typedef re_detail::named_subexpressions_base<char_type> named_sub_type;

+ : m_subs(a), m_base(), m_last_closed_paren(0), m_is_singular(true) {}

+ : m_subs(), m_base(), m_last_closed_paren(0), m_is_singular(true) { (void)a; }

+ : m_subs(m.m_subs), m_named_subs(m.m_named_subs), m_last_closed_paren(m.m_last_closed_paren), m_is_singular(m.m_is_singular)

+ {

+ if(!m_is_singular)

+ {

+ m_base = m.m_base;

+ m_null = m.m_null;

+ }

+ }

+ m_named_subs = m.m_named_subs;

+ m_last_closed_paren = m.m_last_closed_paren;

+ m_is_singular = m.m_is_singular;

+ if(!m_is_singular)

+ {

+ m_base = m.m_base;

+ m_null = m.m_null;

+ }

+ if(m_is_singular)

+ raise_logic_error();

+ difference_type length(const char_type* sub) const

+ {

+ if(m_is_singular)

+ raise_logic_error();

+ const char_type* sub_end = sub;

+ while(*sub_end) ++sub_end;

+ return length(named_subexpression_index(sub, sub_end));

+ }

+ template <class charT>

+ difference_type length(const charT* sub) const

+ {

+ if(m_is_singular)

+ raise_logic_error();

+ const charT* sub_end = sub;

+ while(*sub_end) ++sub_end;

+ return length(named_subexpression_index(sub, sub_end));

+ }

+ template <class charT, class Traits, class A>

+ difference_type length(const std::basic_string<charT, Traits, A>& sub) const

+ {

+ return length(sub.c_str());

+ }

+ if(m_is_singular)

+ raise_logic_error();

+ difference_type position(const char_type* sub) const

+ {

+ const char_type* sub_end = sub;

+ while(*sub_end) ++sub_end;

+ return position(named_subexpression_index(sub, sub_end));

+ }

+ template <class charT>

+ difference_type position(const charT* sub) const

+ {

+ const charT* sub_end = sub;

+ while(*sub_end) ++sub_end;

+ return position(named_subexpression_index(sub, sub_end));

+ }

+ template <class charT, class Traits, class A>

+ difference_type position(const std::basic_string<charT, Traits, A>& sub) const

+ {

+ return position(sub.c_str());

+ }

+ if(m_is_singular)

+ raise_logic_error();

+ string_type str(const char_type* sub) const

+ {

+ return (*this)[sub].str();

+ }

+ template <class Traits, class A>

+ string_type str(const std::basic_string<char_type, Traits, A>& sub) const

+ {

+ return (*this)[sub].str();

+ }

+ template <class charT>

+ string_type str(const charT* sub) const

+ {

+ return (*this)[sub].str();

+ }

+ template <class charT, class Traits, class A>

+ string_type str(const std::basic_string<charT, Traits, A>& sub) const

+ {

+ return (*this)[sub].str();

+ }

+ if(m_is_singular && m_subs.empty())

+ raise_logic_error();

+ //

+ // Named sub-expressions:

+ //

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

+ {

+ if(m_is_singular)

+ raise_logic_error();

+ int index = m_named_subs->get_id(i, j);

+ return index > 0 ? (*this)[index] : m_null;

+ }

+ template <class charT>

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

+ {

+ BOOST_STATIC_ASSERT(sizeof(charT) <= sizeof(char_type));

+ if(i == j)

+ return m_null;

+ std::vector<char_type> s;

+ while(i != j)

+ s.insert(s.end(), *i++);

+ return named_subexpression(&*s.begin(), &*s.begin() + s.size());

+ }

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

+ {

+ if(m_is_singular)

+ raise_logic_error();

+ int index = m_named_subs->get_id(i, j);

+ return index > 0 ? index : -20;

+ }

+ template <class charT>

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

+ {

+ BOOST_STATIC_ASSERT(sizeof(charT) <= sizeof(char_type));

+ if(i == j)

+ return -20;

+ std::vector<char_type> s;

+ while(i != j)

+ s.insert(s.end(), *i++);

+ return named_subexpression_index(&*s.begin(), &*s.begin() + s.size());

+ }

+ template <class Traits, class A>

+ const_reference operator[](const std::basic_string<char_type, Traits, A>& s) const

+ {

+ return named_subexpression(s.c_str(), s.c_str() + s.size());

+ }

+ const_reference operator[](const char_type* p) const

+ {

+ const char_type* e = p;

+ while(*e) ++e;

+ return named_subexpression(p, e);

+ }

+

+ template <class charT>

+ const_reference operator[](const charT* p) const

+ {

+ BOOST_STATIC_ASSERT(sizeof(charT) <= sizeof(char_type));

+ if(*p == 0)

+ return m_null;

+ std::vector<char_type> s;

+ while(*p)

+ s.insert(s.end(), *p++);

+ return named_subexpression(&*s.begin(), &*s.begin() + s.size());

+ }

+ template <class charT, class Traits, class A>

+ const_reference operator[](const std::basic_string<charT, Traits, A>& ns) const

+ {

+ BOOST_STATIC_ASSERT(sizeof(charT) <= sizeof(char_type));

+ if(ns.empty())

+ return m_null;

+ std::vector<char_type> s;

+ for(unsigned i = 0; i < ns.size(); ++i)

+ s.insert(s.end(), ns[i]);

+ return named_subexpression(&*s.begin(), &*s.begin() + s.size());

+ }

+ if(m_is_singular)

+ raise_logic_error();

+ if(m_is_singular)

+ raise_logic_error();

+ template <class OutputIterator, class Functor>

+ Functor fmt,

+ if(m_is_singular)

+ raise_logic_error();

+ typedef typename re_detail::compute_functor_type<Functor, match_results<BidiIterator, Allocator>, OutputIterator>::type F;

+ F func(fmt);

+ return func(*this, out, flags);

+ template <class Functor>

+ string_type format(Functor fmt, match_flag_type flags = format_default) const

+ if(m_is_singular)

+ raise_logic_error();

+ std::basic_string<char_type> result;

+ re_detail::string_out_iterator<std::basic_string<char_type> > i(result);

+

+ typedef typename re_detail::compute_functor_type<Functor, match_results<BidiIterator, Allocator>, re_detail::string_out_iterator<std::basic_string<char_type> > >::type F;

+ F func(fmt);

+

+ func(*this, i, flags);

+ template <class OutputIterator, class Functor, class RegexT>

+ Functor fmt,

+ if(m_is_singular)

+ raise_logic_error();

+ typedef ::boost::regex_traits_wrapper<typename RegexT::traits_type> traits_type;

+ typedef typename re_detail::compute_functor_type<Functor, match_results<BidiIterator, Allocator>, OutputIterator, traits_type>::type F;

+ F func(fmt);

+ return func(*this, out, flags, re.get_traits());

+ template <class RegexT, class Functor>

+ string_type format(Functor fmt,

+ if(m_is_singular)

+ raise_logic_error();

+ typedef ::boost::regex_traits_wrapper<typename RegexT::traits_type> traits_type;

+ std::basic_string<char_type> result;

+ re_detail::string_out_iterator<std::basic_string<char_type> > i(result);

+

+ typedef typename re_detail::compute_functor_type<Functor, match_results<BidiIterator, Allocator>, re_detail::string_out_iterator<std::basic_string<char_type> >, traits_type >::type F;

+ F func(fmt);

+

+ func(*this, i, flags, re.get_traits());

+ const_reference get_last_closed_paren()const

+ {

+ if(m_is_singular)

+ raise_logic_error();

+ return m_last_closed_paren == 0 ? m_null : (*this)[m_last_closed_paren];

+ }

+

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

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

+ std::swap(m_is_singular, that.m_is_singular);

+ if(m_is_singular)

+ {

+ if(!that.m_is_singular)

+ {

+ m_base = that.m_base;

+ m_null = that.m_null;

+ }

+ }

+ else if(that.m_is_singular)

+ {

+ that.m_base = m_base;

+ that.m_null = m_null;

+ }

+ else

+ {

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

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

+ }

+ if(m_is_singular)

+ {

+ return that.m_is_singular;

+ }

+ else if(that.m_is_singular)

+ {

+ return false;

+ }

+ return (m_subs == that.m_subs) && (m_base == that.m_base) && (m_last_closed_paren == that.m_last_closed_paren);

+ if(m_is_singular)

+ raise_logic_error();

+ m_is_singular = false;

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

+ if(pos)

+ m_last_closed_paren = pos;

+ if((pos == 2) && !escape_k)

+ m_is_singular = false;

+ m_last_closed_paren = 0;

+ BOOST_ASSERT(m_subs.size() > 2);

+ void BOOST_REGEX_CALL set_first(BidiIterator i, size_type pos, bool escape_k = false)

+ if(pos || escape_k)

+ {

+ if(escape_k)

+ {

+ m_subs[1].second = i;

+ m_subs[1].matched = (m_subs[1].first != m_subs[1].second);

+ }

+ }

+ void BOOST_REGEX_CALL set_named_subs(boost::shared_ptr<named_sub_type> subs)

+ {

+ m_named_subs = subs;

+ }

+ //

+ // Error handler called when an uninitialized match_results is accessed:

+ //

+ static void raise_logic_error()

+ {

+ std::logic_error e("Attempt to access an uninitialzed boost::match_results<> class.");

+ boost::throw_exception(e);

+ }

+

+

+ vector_type m_subs; // subexpressions

+ BidiIterator m_base; // where the search started from

+ sub_match<BidiIterator> m_null; // a null match

+ boost::shared_ptr<named_sub_type> m_named_subs; // Shared copy of named subs in the regex object

+ int m_last_closed_paren; // Last ) to be seen - used for formatting

+ bool m_is_singular; // True if our stored iterators are singular

+ if(m_is_singular)

+ {

+ *this = m;

+ return;

+ }

+#if !defined(__hpux) && !defined(__WINSCW__)// WCHAR_MIN not usable in pp-directives.

+ while(p && (p->state_id != state_id))

+ if(p)

+ {

+ count = p->count;

+ start_pos = p->start_pos;

+ }

+ else

+ count = 0;

+ if(next)

+ *stack = next;

+template <class Results>

+struct recursion_info

+{

+ typedef typename Results::value_type value_type;

+ typedef typename value_type::iterator iterator;

+ int id;

+ const re_syntax_base* preturn_address;

+ Results results;

+ repeater_count<iterator>* repeater_stack;

+};

+

+ typedef match_results<BidiIterator, Allocator> results_type;

+ m_independent(false), next_count(&rep_obj), rep_obj(&next_count), recursion_stack_position(0)

+ bool match_dot_repeat_dispatch()

+ {

+ return ::boost::is_random_access_iterator<BidiIterator>::value ? match_dot_repeat_fast() : match_dot_repeat_slow();

+ }

+ bool match_recursion();

+ // recursion information:

+ recursion_info<results_type> recursion_stack[50];

+ unsigned recursion_stack_position;

+ bool unwind_recursion(bool);

+ bool unwind_recursion_pop(bool);

+ void push_recursion(int id, const re_syntax_base* p, results_type* presults);

+ void push_recursion_pop();

+ m_presult->set_named_subs(re_detail::convert_to_named_subs<typename match_results<BidiIterator>::char_type>(this->re.get_named_subs()));

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

+ m_presult->set_named_subs(re_detail::convert_to_named_subs<typename match_results<BidiIterator>::char_type>(this->re.get_named_subs()));

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

+ bool result;

+ if(index == 9999)

+ {

+ // Magic value for a (DEFINE) block:

+ return false;

+ }

+ else if(index > 0)

+ {

+ // Check if index is a hash value:

+ if(index >= 10000)

+ index = re.get_data().get_id(index);

+ // Have we matched subexpression "index"?

+ result = (*m_presult)[index].matched;

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

+ int id = -index-1;

+ if(id >= 10000)

+ id = re.get_data().get_id(id);

+ result = recursion_stack_position && ((recursion_stack[recursion_stack_position-1].id == id) || (index == 0));

+ pstate = pstate->next.p;

+ }

+template <class Results>

+struct saved_recursion : public saved_state

+{

+ saved_recursion(int id, const re_syntax_base* p, Results* pr)

+ : saved_state(14), recursion_id(id), preturn_address(p), results(*pr)

+ {}

+ int recursion_id;

+ const re_syntax_base* preturn_address;

+ Results results;

+};

+

+ static matcher_proc_type const s_match_vtable[30] =

+ // Although this next line *should* be evaluated at compile time, in practice

+ // some compilers (VC++) emit run-time initialisation which breaks thread

+ // safety, so use a dispatch function instead:

+ //(::boost::is_random_access_iterator<BidiIterator>::value ? &perl_matcher<BidiIterator, Allocator, traits>::match_dot_repeat_fast : &perl_matcher<BidiIterator, Allocator, traits>::match_dot_repeat_slow),

+ &perl_matcher<BidiIterator, Allocator, traits>::match_dot_repeat_dispatch,

+ &perl_matcher<BidiIterator, Allocator, traits>::match_recursion,

+ raise_error(traits_inst, regex_constants::error_complexity);

+ raise_error(traits_inst, regex_constants::error_stack);

+ //BOOST_ASSERT(index);

+inline void perl_matcher<BidiIterator, Allocator, traits>::push_recursion(int id, const re_syntax_base* p, results_type* presults)

+{

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

+ --pmp;

+ if(pmp < m_stack_base)

+ {

+ extend_stack();

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

+ --pmp;

+ }

+ (void) new (pmp)saved_recursion<results_type>(id, p, presults);

+ m_backup_state = pmp;

+}

+

+template <class BidiIterator, class Allocator, class traits>

+ icase = static_cast<const re_brace*>(pstate)->icase;

+ case -5:

+ {

+ push_matched_paren(0, (*m_presult)[0]);

+ m_presult->set_first(position, 0, true);

+ pstate = pstate->next.p;

+ break;

+ }

+template <class BidiIterator, class Allocator, class traits>

+bool perl_matcher<BidiIterator, Allocator, traits>::match_recursion()

+{

+ BOOST_ASSERT(pstate->type == syntax_element_recurse);

+ //

+ // Backup call stack:

+ //

+ push_recursion_pop();

+ //

+ // Set new call stack:

+ //

+ if(recursion_stack_position >= static_cast<int>(sizeof(recursion_stack)/sizeof(recursion_stack[0])))

+ {

+ return false;

+ }

+ recursion_stack[recursion_stack_position].preturn_address = pstate->next.p;

+ recursion_stack[recursion_stack_position].results = *m_presult;

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

+ recursion_stack[recursion_stack_position].id = static_cast<const re_brace*>(pstate)->index;

+ ++recursion_stack_position;

+ //BOOST_ASSERT(recursion_stack[recursion_stack_position-1].id);

+

+ return true;

+}

+

+template <class BidiIterator, class Allocator, class traits>

+bool perl_matcher<BidiIterator, Allocator, traits>::match_endmark()

+{

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

+ icase = static_cast<const re_brace*>(pstate)->icase;

+ if(index > 0)

+ {

+ if((m_match_flags & match_nosubs) == 0)

+ {

+ m_presult->set_second(position, index);

+ }

+ if(recursion_stack_position)

+ {

+ if(index == recursion_stack[recursion_stack_position-1].id)

+ {

+ --recursion_stack_position;

+ pstate = recursion_stack[recursion_stack_position].preturn_address;

+ *m_presult = recursion_stack[recursion_stack_position].results;

+ push_recursion(recursion_stack[recursion_stack_position].id, recursion_stack[recursion_stack_position].preturn_address, &recursion_stack[recursion_stack_position].results);

+ }

+ }

+ }

+ else if((index < 0) && (index != -4))

+ {

+ // matched forward lookahead:

+ pstate = 0;

+ return true;

+ }

+ pstate = pstate->next.p;

+ return true;

+}

+

+template <class BidiIterator, class Allocator, class traits>

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

+{

+ if(recursion_stack_position)

+ {

+ BOOST_ASSERT(0 == recursion_stack[recursion_stack_position-1].id);

+ --recursion_stack_position;

+ pstate = recursion_stack[recursion_stack_position].preturn_address;

+ *m_presult = recursion_stack[recursion_stack_position].results;

+ push_recursion(recursion_stack[recursion_stack_position].id, recursion_stack[recursion_stack_position].preturn_address, &recursion_stack[recursion_stack_position].results);

+ return true;

+ }

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

+ return false;

+ if((m_match_flags & match_all) && (position != last))

+ return false;

+ if((m_match_flags & regex_constants::match_not_initial_null) && (position == search_base))

+ return false;

+ m_presult->set_second(position);

+ pstate = 0;

+ m_has_found_match = true;

+ if((m_match_flags & match_posix) == match_posix)

+ {

+ m_result.maybe_assign(*m_presult);

+ if((m_match_flags & match_any) == 0)

+ return false;

+ }

+#ifdef BOOST_REGEX_MATCH_EXTRA

+ if(match_extra & m_match_flags)

+ {

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

+ if((*m_presult)[i].matched)

+ ((*m_presult)[i]).get_captures().push_back((*m_presult)[i]);

+ }

+#endif

+ return true;

+}

+

+ static unwind_proc_type const s_unwind_table[18] =

+ &perl_matcher<BidiIterator, Allocator, traits>::unwind_recursion,

+ &perl_matcher<BidiIterator, Allocator, traits>::unwind_recursion_pop,

+ m_presult->set_first(pmp->sub.first, pmp->index, pmp->index == 0);

+ m_presult->set_second(pmp->sub.second, pmp->index, pmp->sub.matched, pmp->index == 0);

+template <class BidiIterator, class Allocator, class traits>

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

+{

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

+ if(!r)

+ {

+ recursion_stack[recursion_stack_position].id = pmp->recursion_id;

+ recursion_stack[recursion_stack_position].preturn_address = pmp->preturn_address;

+ recursion_stack[recursion_stack_position].results = pmp->results;

+ ++recursion_stack_position;

+ }

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

+ m_backup_state = pmp;

+ return true;

+}

+

+template <class BidiIterator, class Allocator, class traits>

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

+{

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

+ if(!r)

+ {

+ --recursion_stack_position;

+ }

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

+ m_backup_state = pmp;

+ return true;

+}

+

+template <class BidiIterator, class Allocator, class traits>

+void perl_matcher<BidiIterator, Allocator, traits>::push_recursion_pop()

+{

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

+ --pmp;

+ if(pmp < m_stack_base)

+ {

+ extend_stack();

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

+ --pmp;

+ }

+ (void) new (pmp)saved_state(15);

+ m_backup_state = pmp;

+}

+/*

+template <class BidiIterator, class Allocator, class traits>

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

+{

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

+ if(!r)

+ {

+ --parenthesis_stack_position;

+ }

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

+ m_backup_state = pmp;

+ return true;

+}

+

+template <class BidiIterator, class Allocator, class traits>

+void perl_matcher<BidiIterator, Allocator, traits>::push_parenthesis_pop()

+{

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

+ --pmp;

+ if(pmp < m_stack_base)

+ {

+ extend_stack();

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

+ --pmp;

+ }

+ (void) new (pmp)saved_state(16);

+ m_backup_state = pmp;

+}

+

+template <class BidiIterator, class Allocator, class traits>

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

+{

+ saved_position<BidiIterator>* pmp = static_cast<saved_position<BidiIterator>*>(m_backup_state);

+ if(!r)

+ {

+ parenthesis_stack[parenthesis_stack_position++] = pmp->position;

+ }

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

+ m_backup_state = pmp;

+ return true;

+}

+

+template <class BidiIterator, class Allocator, class traits>

+inline void perl_matcher<BidiIterator, Allocator, traits>::push_parenthesis_push(BidiIterator p)

+{

+ saved_position<BidiIterator>* pmp = static_cast<saved_position<BidiIterator>*>(m_backup_state);

+ --pmp;

+ if(pmp < m_stack_base)

+ {

+ extend_stack();

+ pmp = static_cast<saved_position<BidiIterator>*>(m_backup_state);

+ --pmp;

+ }

+ (void) new (pmp)saved_position<BidiIterator>(0, p, 17);

+ m_backup_state = pmp;

+}

+*/

+ w.set_first(sub.first, index, index == 0);

+ w.set_second(sub.second, index, sub.matched, index == 0);

+ static matcher_proc_type const s_match_vtable[30] =

+ // Although this next line *should* be evaluated at compile time, in practice

+ // some compilers (VC++) emit run-time initialisation which breaks thread

+ // safety, so use a dispatch function instead:

+ //(::boost::is_random_access_iterator<BidiIterator>::value ? &perl_matcher<BidiIterator, Allocator, traits>::match_dot_repeat_fast : &perl_matcher<BidiIterator, Allocator, traits>::match_dot_repeat_slow),

+ &perl_matcher<BidiIterator, Allocator, traits>::match_dot_repeat_dispatch,

+ &perl_matcher<BidiIterator, Allocator, traits>::match_recursion,

+ raise_error(traits_inst, regex_constants::error_complexity);

+ icase = static_cast<const re_brace*>(pstate)->icase;

+ case -5:

+ {

+ // Reset start of $0, since we have a \K escape

+ backup_subex<BidiIterator> sub(*m_presult, 0);

+ m_presult->set_first(position, 0, true);

+ pstate = pstate->next.p;

+ r = match_all_states();

+ if(r == false)

+ sub.restore(*m_presult);

+ break;

+ }

+template <class BidiIterator, class Allocator, class traits>

+bool perl_matcher<BidiIterator, Allocator, traits>::match_recursion()

+{

+ BOOST_ASSERT(pstate->type == syntax_element_recurse);

+ //

+ // Set new call stack:

+ //

+ if(recursion_stack_position >= static_cast<int>(sizeof(recursion_stack)/sizeof(recursion_stack[0])))

+ {

+ return false;

+ }

+ recursion_stack[recursion_stack_position].preturn_address = pstate->next.p;

+ recursion_stack[recursion_stack_position].results = *m_presult;

+ recursion_stack[recursion_stack_position].repeater_stack = next_count;

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

+ recursion_stack[recursion_stack_position].id = static_cast<const re_brace*>(pstate)->index;

+ ++recursion_stack_position;

+

+ 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

+ next_count = &r;

+ bool result = match_all_states();

+ next_count = saved;

+

+ if(!result)

+ {

+ --recursion_stack_position;

+ next_count = recursion_stack[recursion_stack_position].repeater_stack;

+ *m_presult = recursion_stack[recursion_stack_position].results;

+ return false;

+ }

+ return true;

+}

+

+template <class BidiIterator, class Allocator, class traits>

+bool perl_matcher<BidiIterator, Allocator, traits>::match_endmark()

+{

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

+ icase = static_cast<const re_brace*>(pstate)->icase;

+ if(index > 0)

+ {

+ if((m_match_flags & match_nosubs) == 0)

+ {

+ m_presult->set_second(position, index);

+ }

+ if(recursion_stack_position)

+ {

+ if(index == recursion_stack[recursion_stack_position-1].id)

+ {

+ --recursion_stack_position;

+ recursion_info<results_type> saved = recursion_stack[recursion_stack_position];

+ const re_syntax_base* saved_state = pstate = saved.preturn_address;

+ repeater_count<BidiIterator>* saved_count = next_count;

+ next_count = saved.repeater_stack;

+ *m_presult = saved.results;

+ if(!match_all_states())

+ {

+ recursion_stack[recursion_stack_position] = saved;

+ ++recursion_stack_position;

+ next_count = saved_count;

+ return false;

+ }

+ }

+ }

+ }

+ else if((index < 0) && (index != -4))

+ {

+ // matched forward lookahead:

+ pstate = 0;

+ return true;

+ }

+ pstate = pstate ? pstate->next.p : 0;

+ return true;

+}

+

+template <class BidiIterator, class Allocator, class traits>

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

+{

+ if(recursion_stack_position)

+ {

+ BOOST_ASSERT(0 == recursion_stack[recursion_stack_position-1].id);

+ --recursion_stack_position;

+ const re_syntax_base* saved_state = pstate = recursion_stack[recursion_stack_position].preturn_address;

+ *m_presult = recursion_stack[recursion_stack_position].results;

+ if(!match_all_states())

+ {

+ recursion_stack[recursion_stack_position].preturn_address = saved_state;

+ recursion_stack[recursion_stack_position].results = *m_presult;

+ ++recursion_stack_position;

+ return false;

+ }

+ return true;

+ }

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

+ return false;

+ if((m_match_flags & match_all) && (position != last))

+ return false;

+ if((m_match_flags & regex_constants::match_not_initial_null) && (position == search_base))

+ return false;

+ m_presult->set_second(position);

+ pstate = 0;

+ m_has_found_match = true;

+ if((m_match_flags & match_posix) == match_posix)

+ {

+ m_result.maybe_assign(*m_presult);

+ if((m_match_flags & match_any) == 0)

+ return false;

+ }

+#ifdef BOOST_REGEX_MATCH_EXTRA

+ if(match_extra & m_match_flags)

+ {

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

+ if((*m_presult)[i].matched)

+ ((*m_presult)[i]).get_captures().push_back((*m_presult)[i]);

+ }

+#endif

+ return true;

+}

+

+

+

+ * Copyright (c) 1998-2009 John Maddock

+ * Copyright 2008 Eric Niebler.

+#include <boost/type_traits/is_pointer.hpp>

+#include <boost/type_traits/is_function.hpp>

+#include <boost/type_traits/is_class.hpp>

+#include <boost/type_traits/is_same.hpp>

+#include <boost/type_traits/is_convertible.hpp>

+#include <boost/type_traits/remove_pointer.hpp>

+#include <boost/type_traits/remove_cv.hpp>

+#include <boost/mpl/if.hpp>

+#include <boost/mpl/and.hpp>

+#include <boost/mpl/not.hpp>

+#ifndef BOOST_NO_SFINAE

+#include <boost/mpl/has_xxx.hpp>

+#endif

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

+ OutputIterator format(ForwardIter p1, ForwardIter p2, match_flag_type f);

+ OutputIterator format(ForwardIter p1, match_flag_type f)

+ bool handle_perl_verb(bool have_brace);

+ inline typename Results::value_type const& get_named_sub(ForwardIter i, ForwardIter j, const mpl::false_&)

+ {

+ std::vector<char_type> v(i, j);

+ return (i != j) ? this->m_results.named_subexpression(&v[0], &v[0] + v.size())

+ : this->m_results.named_subexpression(static_cast<const char_type*>(0), static_cast<const char_type*>(0));

+ }

+ inline typename Results::value_type const& get_named_sub(ForwardIter i, ForwardIter j, const mpl::true_&)

+ {

+ return this->m_results.named_subexpression(i, j);

+ }

+ inline typename Results::value_type const& get_named_sub(ForwardIter i, ForwardIter j)

+ {

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

+ return get_named_sub(i, j, tag_type());

+ }

+ inline int get_named_sub_index(ForwardIter i, ForwardIter j, const mpl::false_&)

+ {

+ std::vector<char_type> v(i, j);

+ return (i != j) ? this->m_results.named_subexpression_index(&v[0], &v[0] + v.size())

+ : this->m_results.named_subexpression_index(static_cast<const char_type*>(0), static_cast<const char_type*>(0));

+ }

+ inline int get_named_sub_index(ForwardIter i, ForwardIter j, const mpl::true_&)

+ {

+ return this->m_results.named_subexpression_index(i, j);

+ }

+ inline int get_named_sub_index(ForwardIter i, ForwardIter j)

+ {

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

+ {

+ std::vector<char_type> v(i, j);

+ const char_type* start = &v[0];

+ const char_type* pos = start;

+ int r = m_traits.toi(pos, &v[0] + v.size(), base);

+ std::advance(i, pos - start);

+ return r;

+ }

+ return -1;

+ }

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

+ {

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

+ }

+ 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

+ const Results& m_results; // the match_results being used.

+ OutputIterator m_out; // where to send output.

+ ForwardIter m_position; // format string, current position

+ ForwardIter m_end; // format string end

+ match_flag_type m_flags; // format flags to use

+ output_state m_state; // what to do with the next character

+ output_state m_restore_state; // what state to restore to.

+ bool m_have_conditional; // we are parsing a conditional

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

+OutputIterator basic_regex_formatter<OutputIterator, Results, traits, ForwardIter>::format(ForwardIter p1, ForwardIter p2, match_flag_type f)

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

+void basic_regex_formatter<OutputIterator, Results, traits, ForwardIter>::format_all()

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

+void basic_regex_formatter<OutputIterator, Results, traits, ForwardIter>::format_perl()

+ ForwardIter save_position = m_position;

+ case '+':

+ if((++m_position != m_end) && (*m_position == '{'))

+ {

+ ForwardIter base = ++m_position;

+ while((m_position != m_end) && (*m_position != '}')) ++m_position;

+ if(m_position != m_end)

+ {

+ // Named sub-expression:

+ put(get_named_sub(base, m_position));

+ ++m_position;

+ break;

+ }

+ else

+ {

+ m_position = --base;

+ }

+ }

+ put((this->m_results)[this->m_results.size() > 1 ? this->m_results.size() - 1 : 1]);

+ break;

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

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

+ // Look for a Perl-5.10 verb:

+ if(!handle_perl_verb(have_brace))

+ {

+ // leave the $ as is, and carry on:

+ m_position = --save_position;

+ put(*m_position);

+ ++m_position;

+ }

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

+bool basic_regex_formatter<OutputIterator, Results, traits, ForwardIter>::handle_perl_verb(bool have_brace)

+{

+ //

+ // We may have a capitalised string containing a Perl action:

+ //

+ static const char_type MATCH[] = { 'M', 'A', 'T', 'C', 'H' };

+ static const char_type PREMATCH[] = { 'P', 'R', 'E', 'M', 'A', 'T', 'C', 'H' };

+ static const char_type POSTMATCH[] = { 'P', 'O', 'S', 'T', 'M', 'A', 'T', 'C', 'H' };

+ static const char_type LAST_PAREN_MATCH[] = { 'L', 'A', 'S', 'T', '_', 'P', 'A', 'R', 'E', 'N', '_', 'M', 'A', 'T', 'C', 'H' };

+ static const char_type LAST_SUBMATCH_RESULT[] = { 'L', 'A', 'S', 'T', '_', 'S', 'U', 'B', 'M', 'A', 'T', 'C', 'H', '_', 'R', 'E', 'S', 'U', 'L', 'T' };

+ static const char_type LAST_SUBMATCH_RESULT_ALT[] = { '^', 'N' };

+

+ if(m_position == m_end)

+ return false;

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

+ ++m_position;

+

+ int max_len = m_end - m_position;

+

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

+ {

+ m_position += 5;

+ if(have_brace)

+ {

+ if((m_position != m_end) && (*m_position == '}'))

+ ++m_position;

+ else

+ {

+ m_position -= 5;

+ return false;

+ }

+ }

+ put(this->m_results[0]);

+ return true;

+ }

+ if((max_len >= 8) && std::equal(m_position, m_position + 8, PREMATCH))

+ {

+ m_position += 8;

+ if(have_brace)

+ {

+ if((m_position != m_end) && (*m_position == '}'))

+ ++m_position;

+ else

+ {

+ m_position -= 8;

+ return false;

+ }

+ }

+ put(this->m_results.prefix());

+ return true;

+ }

+ if((max_len >= 9) && std::equal(m_position, m_position + 9, POSTMATCH))

+ {

+ m_position += 9;

+ if(have_brace)

+ {

+ if((m_position != m_end) && (*m_position == '}'))

+ ++m_position;

+ else

+ {

+ m_position -= 9;

+ return false;

+ }

+ }

+ put(this->m_results.suffix());

+ return true;

+ }

+ if((max_len >= 16) && std::equal(m_position, m_position + 16, LAST_PAREN_MATCH))

+ {

+ m_position += 16;

+ if(have_brace)

+ {

+ if((m_position != m_end) && (*m_position == '}'))

+ ++m_position;

+ else

+ {

+ m_position -= 16;

+ return false;

+ }

+ }

+ put((this->m_results)[this->m_results.size() > 1 ? this->m_results.size() - 1 : 1]);

+ return true;

+ }

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

+ {

+ m_position += 20;

+ if(have_brace)

+ {

+ if((m_position != m_end) && (*m_position == '}'))

+ ++m_position;

+ else

+ {

+ m_position -= 20;

+ return false;

+ }

+ }

+ put(this->m_results.get_last_closed_paren());

+ return true;

+ }

+ if((max_len >= 2) && std::equal(m_position, m_position + 2, LAST_SUBMATCH_RESULT_ALT))

+ {

+ m_position += 2;

+ if(have_brace)

+ {

+ if((m_position != m_end) && (*m_position == '}'))

+ ++m_position;

+ else

+ {

+ m_position -= 2;

+ return false;

+ }

+ }

+ put(this->m_results.get_last_closed_paren());

+ return true;

+ }

+ return false;

+}

+

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

+void basic_regex_formatter<OutputIterator, Results, traits, ForwardIter>::format_escape()

+ int val = this->toi(m_position, m_end, 16);

+ if((m_position == m_end) || (*m_position != static_cast<char_type>('}')))

+ --m_position;

+ int val = this->toi(m_position, m_position + len, 16);

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

+ len = (std::min)(static_cast<std::ptrdiff_t>(1), len);

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

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

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

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

+void basic_regex_formatter<OutputIterator, Results, traits, ForwardIter>::format_conditional()

+ int v;

+ if(*m_position == '{')

+ {

+ ForwardIter base = m_position;

+ ++m_position;

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

+ if(v < 0)

+ {

+ // Try a named subexpression:

+ while((m_position != m_end) && (*m_position != '}'))

+ ++m_position;

+ v = this->get_named_sub_index(base + 1, m_position);

+ }

+ if((v < 0) || (*m_position != '}'))

+ {

+ m_position = base;

+ // oops trailing '?':

+ put(static_cast<char_type>('?'));

+ return;

+ }

+ // Skip trailing '}':

+ ++m_position;

+ }

+ else

+ {

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

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

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

+ }

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

+void basic_regex_formatter<OutputIterator, Results, traits, ForwardIter>::format_until_scope_end()

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

+void basic_regex_formatter<OutputIterator, Results, traits, ForwardIter>::put(char_type c)

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

+void basic_regex_formatter<OutputIterator, Results, traits, ForwardIter>::put(const sub_match_type& sub)

+template <class OutputIterator, class Iterator, class Alloc, class ForwardIter, class traits>

+ ForwardIter p1, ForwardIter p2,

+ traits, ForwardIter> f(out, m, t);

+#ifndef BOOST_NO_SFINAE

+BOOST_MPL_HAS_XXX_TRAIT_DEF(const_iterator)

+struct any_type { any_type(...); };

+typedef char no_type;

+typedef char (&unary_type)[2];

+typedef char (&binary_type)[3];

+typedef char (&ternary_type)[4];

+

+no_type check_is_formatter(unary_type, binary_type, ternary_type);

+template<typename T>

+unary_type check_is_formatter(T const &, binary_type, ternary_type);

+template<typename T>

+binary_type check_is_formatter(unary_type, T const &, ternary_type);

+template<typename T, typename U>

+binary_type check_is_formatter(T const &, U const &, ternary_type);

+template<typename T>

+ternary_type check_is_formatter(unary_type, binary_type, T const &);

+template<typename T, typename U>

+ternary_type check_is_formatter(T const &, binary_type, U const &);

+template<typename T, typename U>

+ternary_type check_is_formatter(unary_type, T const &, U const &);

+template<typename T, typename U, typename V>

+ternary_type check_is_formatter(T const &, U const &, V const &);

+

+struct unary_binary_ternary

+ typedef unary_type (*unary_fun)(any_type);

+ typedef binary_type (*binary_fun)(any_type, any_type);

+ typedef ternary_type (*ternary_fun)(any_type, any_type, any_type);

+ operator unary_fun();

+ operator binary_fun();

+ operator ternary_fun();

+};

+template<typename Formatter, bool IsFunction = boost::is_function<Formatter>::value>

+struct formatter_wrapper

+ : Formatter

+ , unary_binary_ternary

+ formatter_wrapper(){}

+};

+template<typename Formatter>

+struct formatter_wrapper<Formatter, true>

+ : unary_binary_ternary

+{

+ operator Formatter *();

+};

+

+template<typename Formatter>

+struct formatter_wrapper<Formatter *, false>

+ : unary_binary_ternary

+{

+ operator Formatter *();

+};

+

+template <class F, class M, class O>

+struct format_traits_imp

+{

+private:

+ //

+ // 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 formatter_wrapper<F> f;

+ static M m;

+ static O out;

+ static boost::regex_constants::match_flag_type flags;

+public:

+ BOOST_STATIC_CONSTANT(int, value = sizeof(check_is_formatter(f(m), f(m, out), f(m, out, flags))));

+};

+

+template <class F, class M, class O>

+struct format_traits

+{

+public:

+ //

+ // Type is mpl::int_<N> where N is one of:

+ //

+ // 0 : F is a pointer to a presumably null-terminated string.

+ // 1 : F is a character-container such as a std::string.

+ // 2 : F is a Unary Functor.

+ // 3 : F is a Binary Functor.

+ // 4 : F is a Ternary Functor.

+ //

+ typedef typename boost::mpl::if_<

+ boost::mpl::and_<boost::is_pointer<F>, boost::mpl::not_<boost::is_function<typename boost::remove_pointer<F>::type> > >,

+ boost::mpl::int_<0>,

+ typename boost::mpl::if_<

+ has_const_iterator<F>,

+ boost::mpl::int_<1>,

+ boost::mpl::int_<format_traits_imp<F, M, O>::value>

+ >::type

+ >::type type;

+ //

+ // This static assertion will fail if the functor passed does not accept

+ // the same type of arguments passed.

+ //

+ BOOST_STATIC_ASSERT( boost::is_class<F>::value && !has_const_iterator<F>::value ? (type::value > 1) : true);

+};

+

+#else // BOOST_NO_SFINAE

+

+template <class F, class M, class O>

+struct format_traits

+{

+public:

+ //

+ // Type is mpl::int_<N> where N is one of:

+ //

+ // 0 : F is a pointer to a presumably null-terminated string.

+ // 1 : F is a character-container such as a std::string.

+ //

+ // Other options such as F being a Functor are not supported without

+ // SFINAE support.

+ //

+ typedef typename boost::mpl::if_<

+ boost::is_pointer<F>,

+ boost::mpl::int_<0>,

+ boost::mpl::int_<1>

+ >::type type;

+};

+

+#endif // BOOST_NO_SFINAE

+

+template <class Base, class Match>

+struct format_functor3

+{

+ format_functor3(Base b) : func(b) {}

+ template <class OutputIter>

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

+ {

+ return func(m, i, f);

+ }

+ template <class OutputIter, class Traits>

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

+ {

+ return (*this)(m, i, f);

+ }

+private:

+ Base func;

+ format_functor3(const format_functor3&);

+ format_functor3& operator=(const format_functor3&);

+};

+

+template <class Base, class Match>

+struct format_functor2

+{

+ format_functor2(Base b) : func(b) {}

+ template <class OutputIter>

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

+ {

+ return func(m, i);

+ }

+ template <class OutputIter, class Traits>

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

+ {

+ return (*this)(m, i, f);

+ }

+private:

+ Base func;

+ format_functor2(const format_functor2&);

+ format_functor2& operator=(const format_functor2&);

+};

+

+template <class Base, class Match>

+struct format_functor1

+{

+ format_functor1(Base b) : func(b) {}

+

+ template <class S, class OutputIter>

+ OutputIter do_format_string(const S& s, OutputIter i)

+ {

+ return re_detail::copy(s.begin(), s.end(), i);

+ }

+ template <class S, class OutputIter>

+ inline OutputIter do_format_string(const S* s, OutputIter i)

+ {

+ while(s && *s)

+ {

+ *i = *s;

+ ++i;

+ ++s;

+ }

+ return i;

+ }

+ template <class OutputIter>

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

+ {

+ return do_format_string(func(m), i);

+ }

+ template <class OutputIter, class Traits>

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

+ {

+ return (*this)(m, i, f);

+ }

+private:

+ Base func;

+ format_functor1(const format_functor1&);

+ format_functor1& operator=(const format_functor1&);

+};

+

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

+ {

+ typedef typename Match::char_type char_type;

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

+ {

+ typedef typename Match::char_type char_type;

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

+struct compute_functor_type

+{

+ typedef typename format_traits<Func, Match, OutputIterator>::type tag;

+ typedef typename boost::remove_cv< typename boost::remove_pointer<Func>::type>::type maybe_char_type;

+

+ typedef typename mpl::if_<

+ ::boost::is_same<tag, mpl::int_<0> >, format_functor_c_string<maybe_char_type, Match, Traits>,

+ typename mpl::if_<

+ ::boost::is_same<tag, mpl::int_<1> >, format_functor_container<Func, Match, Traits>,

+ typename mpl::if_<

+ ::boost::is_same<tag, mpl::int_<2> >, format_functor1<Func, Match>,

+ typename mpl::if_<

+ ::boost::is_same<tag, mpl::int_<3> >, format_functor2<Func, Match>,

+ format_functor3<Func, Match>

+ >::type

+ >::type

+ >::type

+ >::type type;

+};

+

+} // namespace re_detail

+

+template <class OutputIterator, class Iterator, class Allocator, class Functor>

+inline OutputIterator regex_format(OutputIterator out,

+ const match_results<Iterator, Allocator>& m,

+ Functor fmt,

+ match_flag_type flags = format_all

+ )

+ return m.format(out, fmt, flags);

+template <class Iterator, class Allocator, class Functor>

+inline std::basic_string<typename match_results<Iterator, Allocator>::char_type> regex_format(const match_results<Iterator, Allocator>& m,

+ Functor fmt,

+ return m.format(fmt, flags);

+ * Copyright (c) 1998-2009

+template <class OutputIterator, class BidirectionalIterator, class traits, class charT, class Formatter>

+ Formatter fmt,

+template <class traits, class charT, class Formatter>

+ Formatter fmt,

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

+ static const charT data[73] = {

+ 'v',

+ static const character_pointer_range<charT> ranges[21] =

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

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

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

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

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

+template <class charT>

+inline const charT* get_escape_R_string()

+{

+#ifdef BOOST_MSVC

+# pragma warning(push)

+# pragma warning(disable:4309 4245)

+#endif

+ static const charT e1[] = { '(', '?', '>', '\x0D', '\x0A', '?',

+ '|', '[', '\x0A', '\x0B', '\x0C', '\x85', '\\', 'x', '{', '2', '0', '2', '8', '}',

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

+ static const charT e2[] = { '(', '?', '>', '\x0D', '\x0A', '?',

+ '|', '[', '\x0A', '\x0B', '\x0C', '\x85', ']', ')', '\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

+ static const char e2[] = { '(', '?', '>', '\x0D', '\x0A', '?',

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

+ return e2;

+#ifdef BOOST_MSVC

+# pragma warning(pop)

+#endif

+}

+

+#if BOOST_WORKAROUND(BOOST_MSVC,>=1400) && BOOST_WORKAROUND(BOOST_MSVC, <1600) && defined(_CPPLIB_VER) && defined(BOOST_DINKUMWARE_STDLIB) && !(defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION))

+ syntax_element_toggle_case = syntax_element_assert_backref + 1,

+ // a recursive expression:

+ syntax_element_recurse = syntax_element_toggle_case + 1

+ bool icase;

+/*** struct re_recurse ************************************************

+Recurse to a particular subexpression.

+**********************************************************************/

+struct re_recurse : public re_jump

+{

+ int state_id; // identifier of first nested repeat within the recursion.

+};

+

+static const escape_syntax_type escape_type_extended_backref = 57; // for \g

+static const escape_syntax_type escape_type_reset_start_mark = 58; // for \K

+static const escape_syntax_type escape_type_line_ending = 59; // for \R

+static const escape_syntax_type syntax_max = 60;

+inline u32regex_iterator<const UChar*> make_u32regex_iterator(const U_NAMESPACE_QUALIFIER UnicodeString& s, const u32regex& e, regex_constants::match_flag_type m = regex_constants::match_default)

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

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

+ BOOST_STATIC_CONSTANT(char_class_type, mask_horizontal = 0x1000); // must be C1_DEFINED << 3

+ BOOST_STATIC_CONSTANT(char_class_type, mask_vertical = 0x2000); // must be C1_DEFINED << 4

+ static const char_class_type masks[22] =

+ w32_regex_traits_implementation<charT>::mask_horizontal,

+ w32_regex_traits_implementation<charT>::mask_vertical,

+ else if((f & re_detail::w32_regex_traits_implementation<charT>::mask_vertical)

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

+ return true;

+ else if((f & re_detail::w32_regex_traits_implementation<charT>::mask_horizontal)

+ && this->isctype(c, 0x0008u) && !this->isctype(c, re_detail::w32_regex_traits_implementation<charT>::mask_vertical))

+ return true;