/*

#define BOOST_REGEX_SOURCE

#include <boost/regex/regex_traits.hpp>

#include <cctype>

#ifndef BOOST_NO_WREGEX

#include <cwctype>

#endif

#if defined(BOOST_NO_STDC_NAMESPACE)

namespace std{

using ::tolower;

using ::toupper;

#ifndef BOOST_NO_WREGEX

using ::towlower;

using ::towupper;

#endif

}

#endif

namespace boost{ namespace BOOST_REGEX_DETAIL_NS{

BOOST_REGEX_DECL const char* BOOST_REGEX_CALL get_default_syntax(regex_constants::syntax_type n)

{

// if the user hasn't supplied a message catalog, then this supplies

// default "messages" for us to load in the range 1-100.

const char* messages[] = {

"",

"(",

")",

"$",

"^",

".",

"*",

"+",

"?",

"[",

"]",

"|",

"\\",

"#",

"-",

"{",

"}",

"0123456789",

"b",

"B",

"<",

">",

"",

"",

"A`",

"z'",

"\n",

",",

"a",

"f",

"n",

"r",

"t",

"v",

"x",

"c",

":",

"=",

"e",

"",

"",

"",

"",

"",

"",

"",

"",

"E",

"Q",

"X",

"C",

"Z",

"G",

"!",

"p",

"P",

"N",

"gk",

"K",

"R",

};

return ((n >= (sizeof(messages) / sizeof(messages[1]))) ? "" : messages[n]);

}

BOOST_REGEX_DECL const char* BOOST_REGEX_CALL get_default_error_string(regex_constants::error_type n)

{

static const char* const s_default_error_messages[] = {

"Success", /* REG_NOERROR 0 error_ok */

"No match", /* REG_NOMATCH 1 error_no_match */

"Invalid regular expression.", /* REG_BADPAT 2 error_bad_pattern */

"Invalid collation character.", /* REG_ECOLLATE 3 error_collate */

"Invalid character class name, collating name, or character range.", /* REG_ECTYPE 4 error_ctype */

"Invalid or unterminated escape sequence.", /* REG_EESCAPE 5 error_escape */

"Invalid back reference: specified capturing group does not exist.", /* REG_ESUBREG 6 error_backref */

"Unmatched [ or [^ in character class declaration.", /* REG_EBRACK 7 error_brack */

"Unmatched marking parenthesis ( or \\(.", /* REG_EPAREN 8 error_paren */

"Unmatched quantified repeat operator { or \\{.", /* REG_EBRACE 9 error_brace */

"Invalid content of repeat range.", /* REG_BADBR 10 error_badbrace */

"Invalid range end in character class", /* REG_ERANGE 11 error_range */

"Out of memory.", /* REG_ESPACE 12 error_space NOT USED */

"Invalid preceding regular expression prior to repetition operator.", /* REG_BADRPT 13 error_badrepeat */

"Premature end of regular expression", /* REG_EEND 14 error_end NOT USED */

"Regular expression is too large.", /* REG_ESIZE 15 error_size NOT USED */

"Unmatched ) or \\)", /* REG_ERPAREN 16 error_right_paren NOT USED */

"Empty regular expression.", /* REG_EMPTY 17 error_empty */

"The complexity of matching the regular expression exceeded predefined bounds. "

"Try refactoring the regular expression to make each choice made by the state machine unambiguous. "

"This exception is thrown to prevent \"eternal\" matches that take an "

"indefinite period time to locate.", /* REG_ECOMPLEXITY 18 error_complexity */

"Ran out of stack space trying to match the regular expression.", /* REG_ESTACK 19 error_stack */

"Invalid or unterminated Perl (?...) sequence.", /* REG_E_PERL 20 error_perl */

"Unknown error.", /* REG_E_UNKNOWN 21 error_unknown */

};

return (n > ::boost::regex_constants::error_unknown) ? s_default_error_messages[ ::boost::regex_constants::error_unknown] : s_default_error_messages[n];

}

BOOST_REGEX_DECL bool BOOST_REGEX_CALL is_combining_implementation(boost::uint_least16_t c)

}

BOOST_REGEX_DECL const char* def_coll_names[] = {

"NUL", "SOH", "STX", "ETX", "EOT", "ENQ", "ACK", "alert", "backspace", "tab", "newline",

"vertical-tab", "form-feed", "carriage-return", "SO", "SI", "DLE", "DC1", "DC2", "DC3", "DC4", "NAK",

"SYN", "ETB", "CAN", "EM", "SUB", "ESC", "IS4", "IS3", "IS2", "IS1", "space", "exclamation-mark",

"quotation-mark", "number-sign", "dollar-sign", "percent-sign", "ampersand", "apostrophe",

"left-parenthesis", "right-parenthesis", "asterisk", "plus-sign", "comma", "hyphen",

"period", "slash", "zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine",

"colon", "semicolon", "less-than-sign", "equals-sign", "greater-than-sign",

"question-mark", "commercial-at", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P",

"Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "left-square-bracket", "backslash",

"right-square-bracket", "circumflex", "underscore", "grave-accent", "a", "b", "c", "d", "e", "f",

"g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "left-curly-bracket",

"vertical-line", "right-curly-bracket", "tilde", "DEL", "",

};

BOOST_REGEX_DECL const char* def_multi_coll[] = {

"ae",

"Ae",

"AE",

"ch",

"Ch",

"CH",

"ll",

"Ll",

"LL",

"ss",

"Ss",

"SS",

"nj",

"Nj",

"NJ",

"dz",

"Dz",

"DZ",

"lj",

"Lj",

"LJ",

"",

};

BOOST_REGEX_DECL std::string BOOST_REGEX_CALL lookup_default_collate_name(const std::string& name)

}

BOOST_REGEX_DECL char BOOST_REGEX_CALL do_global_lower(char c)

{

return static_cast<char>((std::tolower)((unsigned char)c));

}

BOOST_REGEX_DECL char BOOST_REGEX_CALL do_global_upper(char c)

{

return static_cast<char>((std::toupper)((unsigned char)c));

}

#ifndef BOOST_NO_WREGEX

BOOST_REGEX_DECL wchar_t BOOST_REGEX_CALL do_global_lower(wchar_t c)

{

return (std::towlower)(c);

}

BOOST_REGEX_DECL wchar_t BOOST_REGEX_CALL do_global_upper(wchar_t c)

{

return (std::towupper)(c);

}

#ifdef BOOST_REGEX_HAS_OTHER_WCHAR_T

BOOST_REGEX_DECL unsigned short BOOST_REGEX_CALL do_global_lower(unsigned short c)

{

return (std::towlower)(c);

}

BOOST_REGEX_DECL unsigned short BOOST_REGEX_CALL do_global_upper(unsigned short c)

{

return (std::towupper)(c);

}

#endif

#endif

BOOST_REGEX_DECL regex_constants::escape_syntax_type BOOST_REGEX_CALL get_default_escape_syntax_type(char c)

}

BOOST_REGEX_DECL regex_constants::syntax_type BOOST_REGEX_CALL get_default_syntax_type(char c)

}

} // BOOST_REGEX_DETAIL_NS

} // boost