/////////////////////////////////////////////////////////////////////////////// | |
/// \file regex_primitives.hpp | |
/// Contains the syntax elements for writing static regular expressions. | |
// | |
// Copyright 2008 Eric Niebler. Distributed under the Boost | |
// Software License, Version 1.0. (See accompanying file | |
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) | |
#ifndef BOOST_XPRESSIVE_REGEX_PRIMITIVES_HPP_EAN_10_04_2005 | |
#define BOOST_XPRESSIVE_REGEX_PRIMITIVES_HPP_EAN_10_04_2005 | |
#include <vector> | |
#include <climits> | |
#include <boost/config.hpp> | |
#include <boost/assert.hpp> | |
#include <boost/mpl/if.hpp> | |
#include <boost/mpl/and.hpp> | |
#include <boost/mpl/assert.hpp> | |
#include <boost/detail/workaround.hpp> | |
#include <boost/preprocessor/cat.hpp> | |
#include <boost/xpressive/detail/detail_fwd.hpp> | |
#include <boost/xpressive/detail/core/matchers.hpp> | |
#include <boost/xpressive/detail/core/regex_domain.hpp> | |
#include <boost/xpressive/detail/utility/ignore_unused.hpp> | |
// Doxygen can't handle proto :-( | |
#ifndef BOOST_XPRESSIVE_DOXYGEN_INVOKED | |
# include <boost/proto/core.hpp> | |
# include <boost/proto/transform/arg.hpp> | |
# include <boost/proto/transform/when.hpp> | |
# include <boost/xpressive/detail/core/icase.hpp> | |
# include <boost/xpressive/detail/static/compile.hpp> | |
# include <boost/xpressive/detail/static/modifier.hpp> | |
#endif | |
namespace boost { namespace xpressive { namespace detail | |
{ | |
typedef assert_word_placeholder<word_boundary<mpl::true_> > assert_word_boundary; | |
typedef assert_word_placeholder<word_begin> assert_word_begin; | |
typedef assert_word_placeholder<word_end> assert_word_end; | |
// workaround msvc-7.1 bug with function pointer types | |
// within function types: | |
#if BOOST_WORKAROUND(BOOST_MSVC, == 1310) | |
#define mark_number(x) proto::call<mark_number(x)> | |
#define minus_one() proto::make<minus_one()> | |
#endif | |
struct push_back : proto::callable | |
{ | |
typedef int result_type; | |
template<typename Subs> | |
int operator ()(Subs &subs, int i) const | |
{ | |
subs.push_back(i); | |
return i; | |
} | |
}; | |
struct mark_number : proto::callable | |
{ | |
typedef int result_type; | |
template<typename Expr> | |
int operator ()(Expr const &expr) const | |
{ | |
return expr.mark_number_; | |
} | |
}; | |
typedef mpl::int_<-1> minus_one; | |
// s1 or -s1 | |
struct SubMatch | |
: proto::or_< | |
proto::when<basic_mark_tag, push_back(proto::_data, mark_number(proto::_value)) > | |
, proto::when<proto::negate<basic_mark_tag>, push_back(proto::_data, minus_one()) > | |
> | |
{}; | |
struct SubMatchList | |
: proto::or_<SubMatch, proto::comma<SubMatchList, SubMatch> > | |
{}; | |
template<typename Subs> | |
typename enable_if< | |
mpl::and_<proto::is_expr<Subs>, proto::matches<Subs, SubMatchList> > | |
, std::vector<int> | |
>::type | |
to_vector(Subs const &subs) | |
{ | |
std::vector<int> subs_; | |
SubMatchList()(subs, 0, subs_); | |
return subs_; | |
} | |
#if BOOST_WORKAROUND(BOOST_MSVC, == 1310) | |
#undef mark_number | |
#undef minus_one | |
#endif | |
// replace "Expr" with "keep(*State) >> Expr" | |
struct skip_primitives : proto::transform<skip_primitives> | |
{ | |
template<typename Expr, typename State, typename Data> | |
struct impl : proto::transform_impl<Expr, State, Data> | |
{ | |
typedef | |
typename proto::shift_right< | |
typename proto::unary_expr< | |
keeper_tag | |
, typename proto::dereference<State>::type | |
>::type | |
, Expr | |
>::type | |
result_type; | |
result_type operator ()( | |
typename impl::expr_param expr | |
, typename impl::state_param state | |
, typename impl::data_param | |
) const | |
{ | |
result_type that = {{{state}}, expr}; | |
return that; | |
} | |
}; | |
}; | |
struct Primitives | |
: proto::or_< | |
proto::terminal<proto::_> | |
, proto::comma<proto::_, proto::_> | |
, proto::subscript<proto::terminal<set_initializer>, proto::_> | |
, proto::assign<proto::terminal<set_initializer>, proto::_> | |
, proto::assign<proto::terminal<attribute_placeholder<proto::_> >, proto::_> | |
, proto::complement<Primitives> | |
> | |
{}; | |
struct SkipGrammar | |
: proto::or_< | |
proto::when<Primitives, skip_primitives> | |
, proto::assign<proto::terminal<mark_placeholder>, SkipGrammar> // don't "skip" mark tags | |
, proto::subscript<SkipGrammar, proto::_> // don't put skips in actions | |
, proto::binary_expr<modifier_tag, proto::_, SkipGrammar> // don't skip modifiers | |
, proto::unary_expr<lookbehind_tag, proto::_> // don't skip lookbehinds | |
, proto::nary_expr<proto::_, proto::vararg<SkipGrammar> > // everything else is fair game! | |
> | |
{}; | |
template<typename Skip> | |
struct skip_directive | |
{ | |
typedef typename proto::result_of::as_expr<Skip>::type skip_type; | |
skip_directive(Skip const &skip) | |
: skip_(proto::as_expr(skip)) | |
{} | |
template<typename Sig> | |
struct result; | |
template<typename This, typename Expr> | |
struct result<This(Expr)> | |
{ | |
typedef | |
SkipGrammar::impl< | |
typename proto::result_of::as_expr<Expr>::type | |
, skip_type const & | |
, mpl::void_ & | |
> | |
skip_transform; | |
typedef | |
typename proto::shift_right< | |
typename skip_transform::result_type | |
, typename proto::dereference<skip_type>::type | |
>::type | |
type; | |
}; | |
template<typename Expr> | |
typename result<skip_directive(Expr)>::type | |
operator ()(Expr const &expr) const | |
{ | |
mpl::void_ ignore; | |
typedef result<skip_directive(Expr)> result_fun; | |
typename result_fun::type that = { | |
typename result_fun::skip_transform()(proto::as_expr(expr), this->skip_, ignore) | |
, {skip_} | |
}; | |
return that; | |
} | |
private: | |
skip_type skip_; | |
}; | |
/* | |
/////////////////////////////////////////////////////////////////////////////// | |
/// INTERNAL ONLY | |
// BOOST_XPRESSIVE_GLOBAL | |
// for defining globals that neither violate the One Definition Rule nor | |
// lead to undefined behavior due to global object initialization order. | |
//#define BOOST_XPRESSIVE_GLOBAL(type, name, init) \ | |
// namespace detail \ | |
// { \ | |
// template<int Dummy> \ | |
// struct BOOST_PP_CAT(global_pod_, name) \ | |
// { \ | |
// static type const value; \ | |
// private: \ | |
// union type_must_be_pod \ | |
// { \ | |
// type t; \ | |
// char ch; \ | |
// } u; \ | |
// }; \ | |
// template<int Dummy> \ | |
// type const BOOST_PP_CAT(global_pod_, name)<Dummy>::value = init; \ | |
// } \ | |
// type const &name = detail::BOOST_PP_CAT(global_pod_, name)<0>::value | |
*/ | |
} // namespace detail | |
/// INTERNAL ONLY (for backwards compatibility) | |
unsigned int const repeat_max = UINT_MAX-1; | |
/////////////////////////////////////////////////////////////////////////////// | |
/// \brief For infinite repetition of a sub-expression. | |
/// | |
/// Magic value used with the repeat\<\>() function template | |
/// to specify an unbounded repeat. Use as: repeat<17, inf>('a'). | |
/// The equivalent in perl is /a{17,}/. | |
unsigned int const inf = UINT_MAX-1; | |
/// INTERNAL ONLY (for backwards compatibility) | |
proto::terminal<detail::epsilon_matcher>::type const epsilon = {{}}; | |
/////////////////////////////////////////////////////////////////////////////// | |
/// \brief Successfully matches nothing. | |
/// | |
/// Successfully matches a zero-width sequence. nil always succeeds and | |
/// never consumes any characters. | |
proto::terminal<detail::epsilon_matcher>::type const nil = {{}}; | |
/////////////////////////////////////////////////////////////////////////////// | |
/// \brief Matches an alpha-numeric character. | |
/// | |
/// The regex traits are used to determine which characters are alpha-numeric. | |
/// To match any character that is not alpha-numeric, use ~alnum. | |
/// | |
/// \attention alnum is equivalent to /[[:alnum:]]/ in perl. ~alnum is equivalent | |
/// to /[[:^alnum:]]/ in perl. | |
proto::terminal<detail::posix_charset_placeholder>::type const alnum = {{"alnum", false}}; | |
/////////////////////////////////////////////////////////////////////////////// | |
/// \brief Matches an alphabetic character. | |
/// | |
/// The regex traits are used to determine which characters are alphabetic. | |
/// To match any character that is not alphabetic, use ~alpha. | |
/// | |
/// \attention alpha is equivalent to /[[:alpha:]]/ in perl. ~alpha is equivalent | |
/// to /[[:^alpha:]]/ in perl. | |
proto::terminal<detail::posix_charset_placeholder>::type const alpha = {{"alpha", false}}; | |
/////////////////////////////////////////////////////////////////////////////// | |
/// \brief Matches a blank (horizonal white-space) character. | |
/// | |
/// The regex traits are used to determine which characters are blank characters. | |
/// To match any character that is not blank, use ~blank. | |
/// | |
/// \attention blank is equivalent to /[[:blank:]]/ in perl. ~blank is equivalent | |
/// to /[[:^blank:]]/ in perl. | |
proto::terminal<detail::posix_charset_placeholder>::type const blank = {{"blank", false}}; | |
/////////////////////////////////////////////////////////////////////////////// | |
/// \brief Matches a control character. | |
/// | |
/// The regex traits are used to determine which characters are control characters. | |
/// To match any character that is not a control character, use ~cntrl. | |
/// | |
/// \attention cntrl is equivalent to /[[:cntrl:]]/ in perl. ~cntrl is equivalent | |
/// to /[[:^cntrl:]]/ in perl. | |
proto::terminal<detail::posix_charset_placeholder>::type const cntrl = {{"cntrl", false}}; | |
/////////////////////////////////////////////////////////////////////////////// | |
/// \brief Matches a digit character. | |
/// | |
/// The regex traits are used to determine which characters are digits. | |
/// To match any character that is not a digit, use ~digit. | |
/// | |
/// \attention digit is equivalent to /[[:digit:]]/ in perl. ~digit is equivalent | |
/// to /[[:^digit:]]/ in perl. | |
proto::terminal<detail::posix_charset_placeholder>::type const digit = {{"digit", false}}; | |
/////////////////////////////////////////////////////////////////////////////// | |
/// \brief Matches a graph character. | |
/// | |
/// The regex traits are used to determine which characters are graphable. | |
/// To match any character that is not graphable, use ~graph. | |
/// | |
/// \attention graph is equivalent to /[[:graph:]]/ in perl. ~graph is equivalent | |
/// to /[[:^graph:]]/ in perl. | |
proto::terminal<detail::posix_charset_placeholder>::type const graph = {{"graph", false}}; | |
/////////////////////////////////////////////////////////////////////////////// | |
/// \brief Matches a lower-case character. | |
/// | |
/// The regex traits are used to determine which characters are lower-case. | |
/// To match any character that is not a lower-case character, use ~lower. | |
/// | |
/// \attention lower is equivalent to /[[:lower:]]/ in perl. ~lower is equivalent | |
/// to /[[:^lower:]]/ in perl. | |
proto::terminal<detail::posix_charset_placeholder>::type const lower = {{"lower", false}}; | |
/////////////////////////////////////////////////////////////////////////////// | |
/// \brief Matches a printable character. | |
/// | |
/// The regex traits are used to determine which characters are printable. | |
/// To match any character that is not printable, use ~print. | |
/// | |
/// \attention print is equivalent to /[[:print:]]/ in perl. ~print is equivalent | |
/// to /[[:^print:]]/ in perl. | |
proto::terminal<detail::posix_charset_placeholder>::type const print = {{"print", false}}; | |
/////////////////////////////////////////////////////////////////////////////// | |
/// \brief Matches a punctuation character. | |
/// | |
/// The regex traits are used to determine which characters are punctuation. | |
/// To match any character that is not punctuation, use ~punct. | |
/// | |
/// \attention punct is equivalent to /[[:punct:]]/ in perl. ~punct is equivalent | |
/// to /[[:^punct:]]/ in perl. | |
proto::terminal<detail::posix_charset_placeholder>::type const punct = {{"punct", false}}; | |
/////////////////////////////////////////////////////////////////////////////// | |
/// \brief Matches a space character. | |
/// | |
/// The regex traits are used to determine which characters are space characters. | |
/// To match any character that is not white-space, use ~space. | |
/// | |
/// \attention space is equivalent to /[[:space:]]/ in perl. ~space is equivalent | |
/// to /[[:^space:]]/ in perl. | |
proto::terminal<detail::posix_charset_placeholder>::type const space = {{"space", false}}; | |
/////////////////////////////////////////////////////////////////////////////// | |
/// \brief Matches an upper-case character. | |
/// | |
/// The regex traits are used to determine which characters are upper-case. | |
/// To match any character that is not upper-case, use ~upper. | |
/// | |
/// \attention upper is equivalent to /[[:upper:]]/ in perl. ~upper is equivalent | |
/// to /[[:^upper:]]/ in perl. | |
proto::terminal<detail::posix_charset_placeholder>::type const upper = {{"upper", false}}; | |
/////////////////////////////////////////////////////////////////////////////// | |
/// \brief Matches a hexadecimal digit character. | |
/// | |
/// The regex traits are used to determine which characters are hex digits. | |
/// To match any character that is not a hex digit, use ~xdigit. | |
/// | |
/// \attention xdigit is equivalent to /[[:xdigit:]]/ in perl. ~xdigit is equivalent | |
/// to /[[:^xdigit:]]/ in perl. | |
proto::terminal<detail::posix_charset_placeholder>::type const xdigit = {{"xdigit", false}}; | |
/////////////////////////////////////////////////////////////////////////////// | |
/// \brief Beginning of sequence assertion. | |
/// | |
/// For the character sequence [begin, end), 'bos' matches the | |
/// zero-width sub-sequence [begin, begin). | |
proto::terminal<detail::assert_bos_matcher>::type const bos = {{}}; | |
/////////////////////////////////////////////////////////////////////////////// | |
/// \brief End of sequence assertion. | |
/// | |
/// For the character sequence [begin, end), | |
/// 'eos' matches the zero-width sub-sequence [end, end). | |
/// | |
/// \attention Unlike the perl end of sequence assertion \$, 'eos' will | |
/// not match at the position [end-1, end-1) if *(end-1) is '\\n'. To | |
/// get that behavior, use (!_n >> eos). | |
proto::terminal<detail::assert_eos_matcher>::type const eos = {{}}; | |
/////////////////////////////////////////////////////////////////////////////// | |
/// \brief Beginning of line assertion. | |
/// | |
/// 'bol' matches the zero-width sub-sequence | |
/// immediately following a logical newline sequence. The regex traits | |
/// is used to determine what constitutes a logical newline sequence. | |
proto::terminal<detail::assert_bol_placeholder>::type const bol = {{}}; | |
/////////////////////////////////////////////////////////////////////////////// | |
/// \brief End of line assertion. | |
/// | |
/// 'eol' matches the zero-width sub-sequence | |
/// immediately preceeding a logical newline sequence. The regex traits | |
/// is used to determine what constitutes a logical newline sequence. | |
proto::terminal<detail::assert_eol_placeholder>::type const eol = {{}}; | |
/////////////////////////////////////////////////////////////////////////////// | |
/// \brief Beginning of word assertion. | |
/// | |
/// 'bow' matches the zero-width sub-sequence | |
/// immediately following a non-word character and preceeding a word character. | |
/// The regex traits are used to determine what constitutes a word character. | |
proto::terminal<detail::assert_word_begin>::type const bow = {{}}; | |
/////////////////////////////////////////////////////////////////////////////// | |
/// \brief End of word assertion. | |
/// | |
/// 'eow' matches the zero-width sub-sequence | |
/// immediately following a word character and preceeding a non-word character. | |
/// The regex traits are used to determine what constitutes a word character. | |
proto::terminal<detail::assert_word_end>::type const eow = {{}}; | |
/////////////////////////////////////////////////////////////////////////////// | |
/// \brief Word boundary assertion. | |
/// | |
/// '_b' matches the zero-width sub-sequence at the beginning or the end of a word. | |
/// It is equivalent to (bow | eow). The regex traits are used to determine what | |
/// constitutes a word character. To match a non-word boundary, use ~_b. | |
/// | |
/// \attention _b is like \\b in perl. ~_b is like \\B in perl. | |
proto::terminal<detail::assert_word_boundary>::type const _b = {{}}; | |
/////////////////////////////////////////////////////////////////////////////// | |
/// \brief Matches a word character. | |
/// | |
/// '_w' matches a single word character. The regex traits are used to determine which | |
/// characters are word characters. Use ~_w to match a character that is not a word | |
/// character. | |
/// | |
/// \attention _w is like \\w in perl. ~_w is like \\W in perl. | |
proto::terminal<detail::posix_charset_placeholder>::type const _w = {{"w", false}}; | |
/////////////////////////////////////////////////////////////////////////////// | |
/// \brief Matches a digit character. | |
/// | |
/// '_d' matches a single digit character. The regex traits are used to determine which | |
/// characters are digits. Use ~_d to match a character that is not a digit | |
/// character. | |
/// | |
/// \attention _d is like \\d in perl. ~_d is like \\D in perl. | |
proto::terminal<detail::posix_charset_placeholder>::type const _d = {{"d", false}}; | |
/////////////////////////////////////////////////////////////////////////////// | |
/// \brief Matches a space character. | |
/// | |
/// '_s' matches a single space character. The regex traits are used to determine which | |
/// characters are space characters. Use ~_s to match a character that is not a space | |
/// character. | |
/// | |
/// \attention _s is like \\s in perl. ~_s is like \\S in perl. | |
proto::terminal<detail::posix_charset_placeholder>::type const _s = {{"s", false}}; | |
/////////////////////////////////////////////////////////////////////////////// | |
/// \brief Matches a literal newline character, '\\n'. | |
/// | |
/// '_n' matches a single newline character, '\\n'. Use ~_n to match a character | |
/// that is not a newline. | |
/// | |
/// \attention ~_n is like '.' in perl without the /s modifier. | |
proto::terminal<char>::type const _n = {'\n'}; | |
/////////////////////////////////////////////////////////////////////////////// | |
/// \brief Matches a logical newline sequence. | |
/// | |
/// '_ln' matches a logical newline sequence. This can be any character in the | |
/// line separator class, as determined by the regex traits, or the '\\r\\n' sequence. | |
/// For the purpose of back-tracking, '\\r\\n' is treated as a unit. | |
/// To match any one character that is not a logical newline, use ~_ln. | |
detail::logical_newline_xpression const _ln = {{}}; | |
/////////////////////////////////////////////////////////////////////////////// | |
/// \brief Matches any one character. | |
/// | |
/// Match any character, similar to '.' in perl syntax with the /s modifier. | |
/// '_' matches any one character, including the newline. | |
/// | |
/// \attention To match any character except the newline, use ~_n | |
proto::terminal<detail::any_matcher>::type const _ = {{}}; | |
/////////////////////////////////////////////////////////////////////////////// | |
/// \brief Reference to the current regex object | |
/// | |
/// Useful when constructing recursive regular expression objects. The 'self' | |
/// identifier is a short-hand for the current regex object. For instance, | |
/// sregex rx = '(' >> (self | nil) >> ')'; will create a regex object that | |
/// matches balanced parens such as "((()))". | |
proto::terminal<detail::self_placeholder>::type const self = {{}}; | |
/////////////////////////////////////////////////////////////////////////////// | |
/// \brief Used to create character sets. | |
/// | |
/// There are two ways to create character sets with the 'set' identifier. The | |
/// easiest is to create a comma-separated list of the characters in the set, | |
/// as in (set= 'a','b','c'). This set will match 'a', 'b', or 'c'. The other | |
/// way is to define the set as an argument to the set subscript operator. | |
/// For instance, set[ 'a' | range('b','c') | digit ] will match an 'a', 'b', | |
/// 'c' or a digit character. | |
/// | |
/// To complement a set, apply the '~' operator. For instance, ~(set= 'a','b','c') | |
/// will match any character that is not an 'a', 'b', or 'c'. | |
/// | |
/// Sets can be composed of other, possibly complemented, sets. For instance, | |
/// set[ ~digit | ~(set= 'a','b','c') ]. | |
detail::set_initializer_type const set = {{}}; | |
/////////////////////////////////////////////////////////////////////////////// | |
/// \brief Sub-match placeholder type, used to create named captures in | |
/// static regexes. | |
/// | |
/// \c mark_tag is the type of the global sub-match placeholders \c s0, \c s1, etc.. You | |
/// can use the \c mark_tag type to create your own sub-match placeholders with | |
/// more meaningful names. This is roughly equivalent to the "named capture" | |
/// feature of dynamic regular expressions. | |
/// | |
/// To create a named sub-match placeholder, initialize it with a unique integer. | |
/// The integer must only be unique within the regex in which the placeholder | |
/// is used. Then you can use it within static regexes to created sub-matches | |
/// by assigning a sub-expression to it, or to refer back to already created | |
/// sub-matches. | |
/// | |
/// \code | |
/// mark_tag number(1); // "number" is now equivalent to "s1" | |
/// // Match a number, followed by a space and the same number again | |
/// sregex rx = (number = +_d) >> ' ' >> number; | |
/// \endcode | |
/// | |
/// After a successful \c regex_match() or \c regex_search(), the sub-match placeholder | |
/// can be used to index into the <tt>match_results\<\></tt> object to retrieve the | |
/// corresponding sub-match. | |
struct mark_tag | |
: proto::extends<detail::basic_mark_tag, mark_tag, detail::regex_domain> | |
{ | |
private: | |
typedef proto::extends<detail::basic_mark_tag, mark_tag, detail::regex_domain> base_type; | |
static detail::basic_mark_tag make_tag(int mark_nbr) | |
{ | |
detail::basic_mark_tag mark = {{mark_nbr}}; | |
return mark; | |
} | |
public: | |
/// \brief Initialize a mark_tag placeholder | |
/// \param mark_nbr An integer that uniquely identifies this \c mark_tag | |
/// within the static regexes in which this \c mark_tag will be used. | |
/// \pre <tt>mark_nbr \> 0</tt> | |
mark_tag(int mark_nbr) | |
: base_type(mark_tag::make_tag(mark_nbr)) | |
{ | |
// Marks numbers must be integers greater than 0. | |
BOOST_ASSERT(mark_nbr > 0); | |
} | |
/// INTERNAL ONLY | |
operator detail::basic_mark_tag const &() const | |
{ | |
return this->proto_base(); | |
} | |
BOOST_PROTO_EXTENDS_USING_ASSIGN_NON_DEPENDENT(mark_tag) | |
}; | |
// This macro is used when declaring mark_tags that are global because | |
// it guarantees that they are statically initialized. That avoids | |
// order-of-initialization bugs. In user code, the simpler: mark_tag s0(0); | |
// would be preferable. | |
/// INTERNAL ONLY | |
#define BOOST_XPRESSIVE_GLOBAL_MARK_TAG(NAME, VALUE) \ | |
boost::xpressive::mark_tag::proto_base_expr const NAME = {{VALUE}} \ | |
/**/ | |
/////////////////////////////////////////////////////////////////////////////// | |
/// \brief Sub-match placeholder, like $& in Perl | |
BOOST_XPRESSIVE_GLOBAL_MARK_TAG(s0, 0); | |
/////////////////////////////////////////////////////////////////////////////// | |
/// \brief Sub-match placeholder, like $1 in perl. | |
/// | |
/// To create a sub-match, assign a sub-expression to the sub-match placeholder. | |
/// For instance, (s1= _) will match any one character and remember which | |
/// character was matched in the 1st sub-match. Later in the pattern, you can | |
/// refer back to the sub-match. For instance, (s1= _) >> s1 will match any | |
/// character, and then match the same character again. | |
/// | |
/// After a successful regex_match() or regex_search(), the sub-match placeholders | |
/// can be used to index into the match_results\<\> object to retrieve the Nth | |
/// sub-match. | |
BOOST_XPRESSIVE_GLOBAL_MARK_TAG(s1, 1); | |
BOOST_XPRESSIVE_GLOBAL_MARK_TAG(s2, 2); | |
BOOST_XPRESSIVE_GLOBAL_MARK_TAG(s3, 3); | |
BOOST_XPRESSIVE_GLOBAL_MARK_TAG(s4, 4); | |
BOOST_XPRESSIVE_GLOBAL_MARK_TAG(s5, 5); | |
BOOST_XPRESSIVE_GLOBAL_MARK_TAG(s6, 6); | |
BOOST_XPRESSIVE_GLOBAL_MARK_TAG(s7, 7); | |
BOOST_XPRESSIVE_GLOBAL_MARK_TAG(s8, 8); | |
BOOST_XPRESSIVE_GLOBAL_MARK_TAG(s9, 9); | |
// NOTE: For the purpose of xpressive's documentation, make icase() look like an | |
// ordinary function. In reality, it is a function object defined in detail/icase.hpp | |
// so that it can serve double-duty as regex_constants::icase, the syntax_option_type. | |
#ifdef BOOST_XPRESSIVE_DOXYGEN_INVOKED | |
/////////////////////////////////////////////////////////////////////////////// | |
/// \brief Makes a sub-expression case-insensitive. | |
/// | |
/// Use icase() to make a sub-expression case-insensitive. For instance, | |
/// "foo" >> icase(set['b'] >> "ar") will match "foo" exactly followed by | |
/// "bar" irrespective of case. | |
template<typename Expr> detail::unspecified icase(Expr const &expr) { return 0; } | |
#endif | |
/////////////////////////////////////////////////////////////////////////////// | |
/// \brief Makes a literal into a regular expression. | |
/// | |
/// Use as_xpr() to turn a literal into a regular expression. For instance, | |
/// "foo" >> "bar" will not compile because both operands to the right-shift | |
/// operator are const char*, and no such operator exists. Use as_xpr("foo") >> "bar" | |
/// instead. | |
/// | |
/// You can use as_xpr() with character literals in addition to string literals. | |
/// For instance, as_xpr('a') will match an 'a'. You can also complement a | |
/// character literal, as with ~as_xpr('a'). This will match any one character | |
/// that is not an 'a'. | |
#ifdef BOOST_XPRESSIVE_DOXYGEN_INVOKED | |
template<typename Literal> detail::unspecified as_xpr(Literal const &literal) { return 0; } | |
#else | |
proto::functional::as_expr<> const as_xpr = {}; | |
#endif | |
/////////////////////////////////////////////////////////////////////////////// | |
/// \brief Embed a regex object by reference. | |
/// | |
/// \param rex The basic_regex object to embed by reference. | |
template<typename BidiIter> | |
inline typename proto::terminal<reference_wrapper<basic_regex<BidiIter> const> >::type const | |
by_ref(basic_regex<BidiIter> const &rex) | |
{ | |
reference_wrapper<basic_regex<BidiIter> const> ref(rex); | |
return proto::terminal<reference_wrapper<basic_regex<BidiIter> const> >::type::make(ref); | |
} | |
/////////////////////////////////////////////////////////////////////////////// | |
/// \brief Match a range of characters. | |
/// | |
/// Match any character in the range [ch_min, ch_max]. | |
/// | |
/// \param ch_min The lower end of the range to match. | |
/// \param ch_max The upper end of the range to match. | |
template<typename Char> | |
inline typename proto::terminal<detail::range_placeholder<Char> >::type const | |
range(Char ch_min, Char ch_max) | |
{ | |
detail::range_placeholder<Char> that = {ch_min, ch_max, false}; | |
return proto::terminal<detail::range_placeholder<Char> >::type::make(that); | |
} | |
/////////////////////////////////////////////////////////////////////////////// | |
/// \brief Make a sub-expression optional. Equivalent to !as_xpr(expr). | |
/// | |
/// \param expr The sub-expression to make optional. | |
template<typename Expr> | |
typename proto::result_of::make_expr< | |
proto::tag::logical_not | |
, proto::default_domain | |
, Expr const & | |
>::type const | |
optional(Expr const &expr) | |
{ | |
return proto::make_expr< | |
proto::tag::logical_not | |
, proto::default_domain | |
>(boost::ref(expr)); | |
} | |
/////////////////////////////////////////////////////////////////////////////// | |
/// \brief Repeat a sub-expression multiple times. | |
/// | |
/// There are two forms of the repeat\<\>() function template. To match a | |
/// sub-expression N times, use repeat\<N\>(expr). To match a sub-expression | |
/// from M to N times, use repeat\<M,N\>(expr). | |
/// | |
/// The repeat\<\>() function creates a greedy quantifier. To make the quantifier | |
/// non-greedy, apply the unary minus operator, as in -repeat\<M,N\>(expr). | |
/// | |
/// \param expr The sub-expression to repeat. | |
template<unsigned int Min, unsigned int Max, typename Expr> | |
typename proto::result_of::make_expr< | |
detail::generic_quant_tag<Min, Max> | |
, proto::default_domain | |
, Expr const & | |
>::type const | |
repeat(Expr const &expr) | |
{ | |
return proto::make_expr< | |
detail::generic_quant_tag<Min, Max> | |
, proto::default_domain | |
>(boost::ref(expr)); | |
} | |
/// \overload | |
/// | |
template<unsigned int Count, typename Expr2> | |
typename proto::result_of::make_expr< | |
detail::generic_quant_tag<Count, Count> | |
, proto::default_domain | |
, Expr2 const & | |
>::type const | |
repeat(Expr2 const &expr2) | |
{ | |
return proto::make_expr< | |
detail::generic_quant_tag<Count, Count> | |
, proto::default_domain | |
>(boost::ref(expr2)); | |
} | |
/////////////////////////////////////////////////////////////////////////////// | |
/// \brief Create an independent sub-expression. | |
/// | |
/// Turn off back-tracking for a sub-expression. Any branches or repeats within | |
/// the sub-expression will match only one way, and no other alternatives are | |
/// tried. | |
/// | |
/// \attention keep(expr) is equivalent to the perl (?>...) extension. | |
/// | |
/// \param expr The sub-expression to modify. | |
template<typename Expr> | |
typename proto::result_of::make_expr< | |
detail::keeper_tag | |
, proto::default_domain | |
, Expr const & | |
>::type const | |
keep(Expr const &expr) | |
{ | |
return proto::make_expr< | |
detail::keeper_tag | |
, proto::default_domain | |
>(boost::ref(expr)); | |
} | |
/////////////////////////////////////////////////////////////////////////////// | |
/// \brief Look-ahead assertion. | |
/// | |
/// before(expr) succeeds if the expr sub-expression would match at the current | |
/// position in the sequence, but expr is not included in the match. For instance, | |
/// before("foo") succeeds if we are before a "foo". Look-ahead assertions can be | |
/// negated with the bit-compliment operator. | |
/// | |
/// \attention before(expr) is equivalent to the perl (?=...) extension. | |
/// ~before(expr) is a negative look-ahead assertion, equivalent to the | |
/// perl (?!...) extension. | |
/// | |
/// \param expr The sub-expression to put in the look-ahead assertion. | |
template<typename Expr> | |
typename proto::result_of::make_expr< | |
detail::lookahead_tag | |
, proto::default_domain | |
, Expr const & | |
>::type const | |
before(Expr const &expr) | |
{ | |
return proto::make_expr< | |
detail::lookahead_tag | |
, proto::default_domain | |
>(boost::ref(expr)); | |
} | |
/////////////////////////////////////////////////////////////////////////////// | |
/// \brief Look-behind assertion. | |
/// | |
/// after(expr) succeeds if the expr sub-expression would match at the current | |
/// position minus N in the sequence, where N is the width of expr. expr is not included in | |
/// the match. For instance, after("foo") succeeds if we are after a "foo". Look-behind | |
/// assertions can be negated with the bit-complement operator. | |
/// | |
/// \attention after(expr) is equivalent to the perl (?<=...) extension. | |
/// ~after(expr) is a negative look-behind assertion, equivalent to the | |
/// perl (?<!...) extension. | |
/// | |
/// \param expr The sub-expression to put in the look-ahead assertion. | |
/// | |
/// \pre expr cannot match a variable number of characters. | |
template<typename Expr> | |
typename proto::result_of::make_expr< | |
detail::lookbehind_tag | |
, proto::default_domain | |
, Expr const & | |
>::type const | |
after(Expr const &expr) | |
{ | |
return proto::make_expr< | |
detail::lookbehind_tag | |
, proto::default_domain | |
>(boost::ref(expr)); | |
} | |
/////////////////////////////////////////////////////////////////////////////// | |
/// \brief Specify a regex traits or a std::locale. | |
/// | |
/// imbue() instructs the regex engine to use the specified traits or locale | |
/// when matching the regex. The entire expression must use the same traits/locale. | |
/// For instance, the following specifies a locale for use with a regex: | |
/// std::locale loc; | |
/// sregex rx = imbue(loc)(+digit); | |
/// | |
/// \param loc The std::locale or regex traits object. | |
template<typename Locale> | |
inline detail::modifier_op<detail::locale_modifier<Locale> > const | |
imbue(Locale const &loc) | |
{ | |
detail::modifier_op<detail::locale_modifier<Locale> > mod = | |
{ | |
detail::locale_modifier<Locale>(loc) | |
, regex_constants::ECMAScript | |
}; | |
return mod; | |
} | |
proto::terminal<detail::attribute_placeholder<mpl::int_<1> > >::type const a1 = {{}}; | |
proto::terminal<detail::attribute_placeholder<mpl::int_<2> > >::type const a2 = {{}}; | |
proto::terminal<detail::attribute_placeholder<mpl::int_<3> > >::type const a3 = {{}}; | |
proto::terminal<detail::attribute_placeholder<mpl::int_<4> > >::type const a4 = {{}}; | |
proto::terminal<detail::attribute_placeholder<mpl::int_<5> > >::type const a5 = {{}}; | |
proto::terminal<detail::attribute_placeholder<mpl::int_<6> > >::type const a6 = {{}}; | |
proto::terminal<detail::attribute_placeholder<mpl::int_<7> > >::type const a7 = {{}}; | |
proto::terminal<detail::attribute_placeholder<mpl::int_<8> > >::type const a8 = {{}}; | |
proto::terminal<detail::attribute_placeholder<mpl::int_<9> > >::type const a9 = {{}}; | |
/////////////////////////////////////////////////////////////////////////////// | |
/// \brief Specify which characters to skip when matching a regex. | |
/// | |
/// <tt>skip()</tt> instructs the regex engine to skip certain characters when matching | |
/// a regex. It is most useful for writing regexes that ignore whitespace. | |
/// For instance, the following specifies a regex that skips whitespace and | |
/// punctuation: | |
/// | |
/// \code | |
/// // A sentence is one or more words separated by whitespace | |
/// // and punctuation. | |
/// sregex word = +alpha; | |
/// sregex sentence = skip(set[_s | punct])( +word ); | |
/// \endcode | |
/// | |
/// The way it works in the above example is to insert | |
/// <tt>keep(*set[_s | punct])</tt> before each primitive within the regex. | |
/// A "primitive" includes terminals like strings, character sets and nested | |
/// regexes. A final <tt>*set[_s | punct]</tt> is added to the end of the | |
/// regex. The regex <tt>sentence</tt> specified above is equivalent to | |
/// the following: | |
/// | |
/// \code | |
/// sregex sentence = +( keep(*set[_s | punct]) >> word ) | |
/// >> *set[_s | punct]; | |
/// \endcode | |
/// | |
/// \attention Skipping does not affect how nested regexes are handled because | |
/// they are treated atomically. String literals are also treated | |
/// atomically; that is, no skipping is done within a string literal. So | |
/// <tt>skip(_s)("this that")</tt> is not the same as | |
/// <tt>skip(_s)("this" >> as_xpr("that"))</tt>. The first will only match | |
/// when there is only one space between "this" and "that". The second will | |
/// skip any and all whitespace between "this" and "that". | |
/// | |
/// \param skip A regex that specifies which characters to skip. | |
template<typename Skip> | |
detail::skip_directive<Skip> skip(Skip const &skip) | |
{ | |
return detail::skip_directive<Skip>(skip); | |
} | |
namespace detail | |
{ | |
inline void ignore_unused_regex_primitives() | |
{ | |
detail::ignore_unused(repeat_max); | |
detail::ignore_unused(inf); | |
detail::ignore_unused(epsilon); | |
detail::ignore_unused(nil); | |
detail::ignore_unused(alnum); | |
detail::ignore_unused(bos); | |
detail::ignore_unused(eos); | |
detail::ignore_unused(bol); | |
detail::ignore_unused(eol); | |
detail::ignore_unused(bow); | |
detail::ignore_unused(eow); | |
detail::ignore_unused(_b); | |
detail::ignore_unused(_w); | |
detail::ignore_unused(_d); | |
detail::ignore_unused(_s); | |
detail::ignore_unused(_n); | |
detail::ignore_unused(_ln); | |
detail::ignore_unused(_); | |
detail::ignore_unused(self); | |
detail::ignore_unused(set); | |
detail::ignore_unused(s0); | |
detail::ignore_unused(s1); | |
detail::ignore_unused(s2); | |
detail::ignore_unused(s3); | |
detail::ignore_unused(s4); | |
detail::ignore_unused(s5); | |
detail::ignore_unused(s6); | |
detail::ignore_unused(s7); | |
detail::ignore_unused(s8); | |
detail::ignore_unused(s9); | |
detail::ignore_unused(a1); | |
detail::ignore_unused(a2); | |
detail::ignore_unused(a3); | |
detail::ignore_unused(a4); | |
detail::ignore_unused(a5); | |
detail::ignore_unused(a6); | |
detail::ignore_unused(a7); | |
detail::ignore_unused(a8); | |
detail::ignore_unused(a9); | |
detail::ignore_unused(as_xpr); | |
} | |
} | |
}} // namespace boost::xpressive | |
#endif |