1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/ossrv/ossrv_pub/boost_apis/boost/xpressive/regex_primitives.hpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,655 @@
1.4 +///////////////////////////////////////////////////////////////////////////////
1.5 +/// \file regex_primitives.hpp
1.6 +/// Contains the syntax elements for writing static regular expressions.
1.7 +//
1.8 +// Copyright 2004 Eric Niebler. Distributed under the Boost
1.9 +// Software License, Version 1.0. (See accompanying file
1.10 +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
1.11 +
1.12 +#ifndef BOOST_XPRESSIVE_REGEX_PRIMITIVES_HPP_EAN_10_04_2005
1.13 +#define BOOST_XPRESSIVE_REGEX_PRIMITIVES_HPP_EAN_10_04_2005
1.14 +
1.15 +#include <climits>
1.16 +#include <boost/mpl/assert.hpp>
1.17 +#include <boost/preprocessor/cat.hpp>
1.18 +#include <boost/xpressive/proto/proto.hpp>
1.19 +#include <boost/xpressive/detail/detail_fwd.hpp>
1.20 +#include <boost/xpressive/detail/core/icase.hpp>
1.21 +#include <boost/xpressive/detail/core/action.hpp>
1.22 +#include <boost/xpressive/detail/core/matchers.hpp>
1.23 +#include <boost/xpressive/detail/static/as_xpr.hpp>
1.24 +#include <boost/xpressive/detail/static/compile.hpp>
1.25 +#include <boost/xpressive/detail/static/modifier.hpp>
1.26 +#include <boost/xpressive/detail/static/regex_operators.hpp>
1.27 +#include <boost/xpressive/detail/static/productions/productions.hpp>
1.28 +
1.29 +namespace boost { namespace xpressive { namespace detail
1.30 +{
1.31 +
1.32 +typedef assert_word_placeholder<word_boundary<true> > assert_word_boundary;
1.33 +typedef assert_word_placeholder<word_begin> assert_word_begin;
1.34 +typedef assert_word_placeholder<word_end> assert_word_end;
1.35 +
1.36 +/*
1.37 +///////////////////////////////////////////////////////////////////////////////
1.38 +/// INTERNAL ONLY
1.39 +// BOOST_XPRESSIVE_GLOBAL
1.40 +// for defining globals that neither violate the One Definition Rule nor
1.41 +// lead to undefined behavior due to global object initialization order.
1.42 +//#define BOOST_XPRESSIVE_GLOBAL(type, name, init) \
1.43 +// namespace detail \
1.44 +// { \
1.45 +// template<int Dummy> \
1.46 +// struct BOOST_PP_CAT(global_pod_, name) \
1.47 +// { \
1.48 +// static type const value; \
1.49 +// private: \
1.50 +// union type_must_be_pod \
1.51 +// { \
1.52 +// type t; \
1.53 +// char ch; \
1.54 +// } u; \
1.55 +// }; \
1.56 +// template<int Dummy> \
1.57 +// type const BOOST_PP_CAT(global_pod_, name)<Dummy>::value = init; \
1.58 +// } \
1.59 +// type const &name = detail::BOOST_PP_CAT(global_pod_, name)<0>::value
1.60 +*/
1.61 +
1.62 +} // namespace detail
1.63 +
1.64 +/// INTERNAL ONLY (for backwards compatibility)
1.65 +unsigned int const repeat_max = UINT_MAX-1;
1.66 +
1.67 +///////////////////////////////////////////////////////////////////////////////
1.68 +/// \brief For infinite repetition of a sub-expression.
1.69 +///
1.70 +/// Magic value used with the repeat\<\>() function template
1.71 +/// to specify an unbounded repeat. Use as: repeat<17, inf>('a').
1.72 +/// The equivalent in perl is /a{17,}/.
1.73 +unsigned int const inf = UINT_MAX-1;
1.74 +
1.75 +/// INTERNAL ONLY (for backwards compatibility)
1.76 +proto::op_proxy<
1.77 + proto::unary_op<detail::epsilon_matcher, proto::noop_tag>
1.78 +> const epsilon = {};
1.79 +
1.80 +///////////////////////////////////////////////////////////////////////////////
1.81 +/// \brief Successfully matches nothing.
1.82 +///
1.83 +/// Successfully matches a zero-width sequence. nil always succeeds and
1.84 +/// never consumes any characters.
1.85 +proto::op_proxy<
1.86 + proto::unary_op<detail::epsilon_matcher, proto::noop_tag>
1.87 +> const nil = {};
1.88 +
1.89 +///////////////////////////////////////////////////////////////////////////////
1.90 +/// \brief Matches an alpha-numeric character.
1.91 +///
1.92 +/// The regex traits are used to determine which characters are alpha-numeric.
1.93 +/// To match any character that is not alpha-numeric, use ~alnum.
1.94 +///
1.95 +/// \attention alnum is equivalent to /[[:alnum:]]/ in perl. ~alnum is equivalent
1.96 +/// to /[[:^alnum:]]/ in perl.
1.97 +proto::op_proxy<
1.98 + proto::unary_op<detail::posix_charset_placeholder, proto::noop_tag>
1.99 + , char const *
1.100 +> const alnum = {"alnum"};
1.101 +
1.102 +///////////////////////////////////////////////////////////////////////////////
1.103 +/// \brief Matches an alphabetic character.
1.104 +///
1.105 +/// The regex traits are used to determine which characters are alphabetic.
1.106 +/// To match any character that is not alphabetic, use ~alpha.
1.107 +///
1.108 +/// \attention alpha is equivalent to /[[:alpha:]]/ in perl. ~alpha is equivalent
1.109 +/// to /[[:^alpha:]]/ in perl.
1.110 +proto::op_proxy<
1.111 + proto::unary_op<detail::posix_charset_placeholder, proto::noop_tag>
1.112 + , char const *
1.113 +> const alpha = {"alpha"};
1.114 +
1.115 +///////////////////////////////////////////////////////////////////////////////
1.116 +/// \brief Matches a blank (horizonal white-space) character.
1.117 +///
1.118 +/// The regex traits are used to determine which characters are blank characters.
1.119 +/// To match any character that is not blank, use ~blank.
1.120 +///
1.121 +/// \attention blank is equivalent to /[[:blank:]]/ in perl. ~blank is equivalent
1.122 +/// to /[[:^blank:]]/ in perl.
1.123 +proto::op_proxy<
1.124 + proto::unary_op<detail::posix_charset_placeholder, proto::noop_tag>
1.125 + , char const *
1.126 +> const blank = {"blank"};
1.127 +
1.128 +///////////////////////////////////////////////////////////////////////////////
1.129 +/// \brief Matches a control character.
1.130 +///
1.131 +/// The regex traits are used to determine which characters are control characters.
1.132 +/// To match any character that is not a control character, use ~cntrl.
1.133 +///
1.134 +/// \attention cntrl is equivalent to /[[:cntrl:]]/ in perl. ~cntrl is equivalent
1.135 +/// to /[[:^cntrl:]]/ in perl.
1.136 +proto::op_proxy<
1.137 + proto::unary_op<detail::posix_charset_placeholder, proto::noop_tag>
1.138 + , char const *
1.139 +> const cntrl = {"cntrl"};
1.140 +
1.141 +///////////////////////////////////////////////////////////////////////////////
1.142 +/// \brief Matches a digit character.
1.143 +///
1.144 +/// The regex traits are used to determine which characters are digits.
1.145 +/// To match any character that is not a digit, use ~digit.
1.146 +///
1.147 +/// \attention digit is equivalent to /[[:digit:]]/ in perl. ~digit is equivalent
1.148 +/// to /[[:^digit:]]/ in perl.
1.149 +proto::op_proxy<
1.150 + proto::unary_op<detail::posix_charset_placeholder, proto::noop_tag>
1.151 + , char const *
1.152 +> const digit = {"digit"};
1.153 +
1.154 +///////////////////////////////////////////////////////////////////////////////
1.155 +/// \brief Matches a graph character.
1.156 +///
1.157 +/// The regex traits are used to determine which characters are graphable.
1.158 +/// To match any character that is not graphable, use ~graph.
1.159 +///
1.160 +/// \attention graph is equivalent to /[[:graph:]]/ in perl. ~graph is equivalent
1.161 +/// to /[[:^graph:]]/ in perl.
1.162 +proto::op_proxy<
1.163 + proto::unary_op<detail::posix_charset_placeholder, proto::noop_tag>
1.164 + , char const *
1.165 +> const graph = {"graph"};
1.166 +
1.167 +///////////////////////////////////////////////////////////////////////////////
1.168 +/// \brief Matches a lower-case character.
1.169 +///
1.170 +/// The regex traits are used to determine which characters are lower-case.
1.171 +/// To match any character that is not a lower-case character, use ~lower.
1.172 +///
1.173 +/// \attention lower is equivalent to /[[:lower:]]/ in perl. ~lower is equivalent
1.174 +/// to /[[:^lower:]]/ in perl.
1.175 +proto::op_proxy<
1.176 + proto::unary_op<detail::posix_charset_placeholder, proto::noop_tag>
1.177 + , char const *
1.178 +> const lower = {"lower"};
1.179 +
1.180 +///////////////////////////////////////////////////////////////////////////////
1.181 +/// \brief Matches a printable character.
1.182 +///
1.183 +/// The regex traits are used to determine which characters are printable.
1.184 +/// To match any character that is not printable, use ~print.
1.185 +///
1.186 +/// \attention print is equivalent to /[[:print:]]/ in perl. ~print is equivalent
1.187 +/// to /[[:^print:]]/ in perl.
1.188 +proto::op_proxy<
1.189 + proto::unary_op<detail::posix_charset_placeholder, proto::noop_tag>
1.190 + , char const *
1.191 +> const print = {"print"};
1.192 +
1.193 +///////////////////////////////////////////////////////////////////////////////
1.194 +/// \brief Matches a punctuation character.
1.195 +///
1.196 +/// The regex traits are used to determine which characters are punctuation.
1.197 +/// To match any character that is not punctuation, use ~punct.
1.198 +///
1.199 +/// \attention punct is equivalent to /[[:punct:]]/ in perl. ~punct is equivalent
1.200 +/// to /[[:^punct:]]/ in perl.
1.201 +proto::op_proxy<
1.202 + proto::unary_op<detail::posix_charset_placeholder, proto::noop_tag>
1.203 + , char const *
1.204 +> const punct = {"punct"};
1.205 +
1.206 +///////////////////////////////////////////////////////////////////////////////
1.207 +/// \brief Matches a space character.
1.208 +///
1.209 +/// The regex traits are used to determine which characters are space characters.
1.210 +/// To match any character that is not white-space, use ~space.
1.211 +///
1.212 +/// \attention space is equivalent to /[[:space:]]/ in perl. ~space is equivalent
1.213 +/// to /[[:^space:]]/ in perl.
1.214 +proto::op_proxy<
1.215 + proto::unary_op<detail::posix_charset_placeholder, proto::noop_tag>
1.216 + , char const *
1.217 +> const space = {"space"};
1.218 +
1.219 +///////////////////////////////////////////////////////////////////////////////
1.220 +/// \brief Matches an upper-case character.
1.221 +///
1.222 +/// The regex traits are used to determine which characters are upper-case.
1.223 +/// To match any character that is not upper-case, use ~upper.
1.224 +///
1.225 +/// \attention upper is equivalent to /[[:upper:]]/ in perl. ~upper is equivalent
1.226 +/// to /[[:^upper:]]/ in perl.
1.227 +proto::op_proxy<
1.228 + proto::unary_op<detail::posix_charset_placeholder, proto::noop_tag>
1.229 + , char const *
1.230 +> const upper = {"upper"};
1.231 +
1.232 +///////////////////////////////////////////////////////////////////////////////
1.233 +/// \brief Matches a hexadecimal digit character.
1.234 +///
1.235 +/// The regex traits are used to determine which characters are hex digits.
1.236 +/// To match any character that is not a hex digit, use ~xdigit.
1.237 +///
1.238 +/// \attention xdigit is equivalent to /[[:xdigit:]]/ in perl. ~xdigit is equivalent
1.239 +/// to /[[:^xdigit:]]/ in perl.
1.240 +proto::op_proxy<
1.241 + proto::unary_op<detail::posix_charset_placeholder, proto::noop_tag>
1.242 + , char const *
1.243 +> const xdigit = {"xdigit"};
1.244 +
1.245 +///////////////////////////////////////////////////////////////////////////////
1.246 +/// \brief Beginning of sequence assertion.
1.247 +///
1.248 +/// For the character sequence [begin, end), 'bos' matches the
1.249 +/// zero-width sub-sequence [begin, begin).
1.250 +proto::op_proxy<
1.251 + proto::unary_op<detail::assert_bos_matcher, proto::noop_tag>
1.252 +> const bos = {};
1.253 +
1.254 +///////////////////////////////////////////////////////////////////////////////
1.255 +/// \brief End of sequence assertion.
1.256 +///
1.257 +/// For the character sequence [begin, end),
1.258 +/// 'eos' matches the zero-width sub-sequence [end, end).
1.259 +///
1.260 +/// \attention Unlike the perl end of sequence assertion \$, 'eos' will
1.261 +/// not match at the position [end-1, end-1) if *(end-1) is '\\n'. To
1.262 +/// get that behavior, use (!_n >> eos).
1.263 +proto::op_proxy<
1.264 + proto::unary_op<detail::assert_eos_matcher, proto::noop_tag>
1.265 +> const eos = {};
1.266 +
1.267 +///////////////////////////////////////////////////////////////////////////////
1.268 +/// \brief Beginning of line assertion.
1.269 +///
1.270 +/// 'bol' matches the zero-width sub-sequence
1.271 +/// immediately following a logical newline sequence. The regex traits
1.272 +/// is used to determine what constitutes a logical newline sequence.
1.273 +proto::op_proxy<
1.274 + proto::unary_op<detail::assert_bol_placeholder, proto::noop_tag>
1.275 +> const bol = {};
1.276 +
1.277 +///////////////////////////////////////////////////////////////////////////////
1.278 +/// \brief End of line assertion.
1.279 +///
1.280 +/// 'eol' matches the zero-width sub-sequence
1.281 +/// immediately preceeding a logical newline sequence. The regex traits
1.282 +/// is used to determine what constitutes a logical newline sequence.
1.283 +proto::op_proxy<
1.284 + proto::unary_op<detail::assert_eol_placeholder, proto::noop_tag>
1.285 +> const eol = {};
1.286 +
1.287 +///////////////////////////////////////////////////////////////////////////////
1.288 +/// \brief Beginning of word assertion.
1.289 +///
1.290 +/// 'bow' matches the zero-width sub-sequence
1.291 +/// immediately following a non-word character and preceeding a word character.
1.292 +/// The regex traits are used to determine what constitutes a word character.
1.293 +proto::op_proxy<
1.294 + proto::unary_op<detail::assert_word_begin, proto::noop_tag>
1.295 +> const bow = {};
1.296 +
1.297 +///////////////////////////////////////////////////////////////////////////////
1.298 +/// \brief End of word assertion.
1.299 +///
1.300 +/// 'eow' matches the zero-width sub-sequence
1.301 +/// immediately following a word character and preceeding a non-word character.
1.302 +/// The regex traits are used to determine what constitutes a word character.
1.303 +proto::op_proxy<
1.304 + proto::unary_op<detail::assert_word_end, proto::noop_tag>
1.305 +> const eow = {};
1.306 +
1.307 +///////////////////////////////////////////////////////////////////////////////
1.308 +/// \brief Word boundary assertion.
1.309 +///
1.310 +/// '_b' matches the zero-width sub-sequence at the beginning or the end of a word.
1.311 +/// It is equivalent to (bow | eow). The regex traits are used to determine what
1.312 +/// constitutes a word character. To match a non-word boundary, use ~_b.
1.313 +///
1.314 +/// \attention _b is like \\b in perl. ~_b is like \\B in perl.
1.315 +proto::op_proxy<
1.316 + proto::unary_op<detail::assert_word_boundary, proto::noop_tag>
1.317 +> const _b = {};
1.318 +
1.319 +///////////////////////////////////////////////////////////////////////////////
1.320 +/// \brief Matches a word character.
1.321 +///
1.322 +/// '_w' matches a single word character. The regex traits are used to determine which
1.323 +/// characters are word characters. Use ~_w to match a character that is not a word
1.324 +/// character.
1.325 +///
1.326 +/// \attention _w is like \\w in perl. ~_w is like \\W in perl.
1.327 +proto::op_proxy<
1.328 + proto::unary_op<detail::posix_charset_placeholder, proto::noop_tag>
1.329 + , char const *
1.330 +> const _w = {"w"};
1.331 +
1.332 +///////////////////////////////////////////////////////////////////////////////
1.333 +/// \brief Matches a digit character.
1.334 +///
1.335 +/// '_d' matches a single digit character. The regex traits are used to determine which
1.336 +/// characters are digits. Use ~_d to match a character that is not a digit
1.337 +/// character.
1.338 +///
1.339 +/// \attention _d is like \\d in perl. ~_d is like \\D in perl.
1.340 +proto::op_proxy<
1.341 + proto::unary_op<detail::posix_charset_placeholder, proto::noop_tag>
1.342 + , char const *
1.343 +> const _d = {"d"};
1.344 +
1.345 +///////////////////////////////////////////////////////////////////////////////
1.346 +/// \brief Matches a space character.
1.347 +///
1.348 +/// '_s' matches a single space character. The regex traits are used to determine which
1.349 +/// characters are space characters. Use ~_s to match a character that is not a space
1.350 +/// character.
1.351 +///
1.352 +/// \attention _s is like \\s in perl. ~_s is like \\S in perl.
1.353 +proto::op_proxy<
1.354 + proto::unary_op<detail::posix_charset_placeholder, proto::noop_tag>
1.355 + , char const *
1.356 +> const _s = {"s"};
1.357 +
1.358 +///////////////////////////////////////////////////////////////////////////////
1.359 +/// \brief Matches a literal newline character, '\\n'.
1.360 +///
1.361 +/// '_n' matches a single newline character, '\\n'. Use ~_n to match a character
1.362 +/// that is not a newline.
1.363 +///
1.364 +/// \attention ~_n is like '.' in perl without the /s modifier.
1.365 +proto::op_proxy<
1.366 + proto::unary_op<detail::literal_placeholder<char>, proto::noop_tag>
1.367 + , char
1.368 +> const _n = {'\n'};
1.369 +
1.370 +///////////////////////////////////////////////////////////////////////////////
1.371 +/// \brief Matches a logical newline sequence.
1.372 +///
1.373 +/// '_ln' matches a logical newline sequence. This can be any character in the
1.374 +/// line separator class, as determined by the regex traits, or the '\\r\\n' sequence.
1.375 +/// For the purpose of back-tracking, '\\r\\n' is treated as a unit.
1.376 +/// To match any one character that is not a logical newline, use ~_ln.
1.377 +proto::op_proxy<
1.378 + detail::logical_newline_xpression
1.379 +> const _ln = {};
1.380 +
1.381 +///////////////////////////////////////////////////////////////////////////////
1.382 +/// \brief Matches any one character.
1.383 +///
1.384 +/// Match any character, similar to '.' in perl syntax with the /s modifier.
1.385 +/// '_' matches any one character, including the newline.
1.386 +///
1.387 +/// \attention To match any character except the newline, use ~_n
1.388 +proto::op_proxy<
1.389 + proto::unary_op<detail::any_matcher, proto::noop_tag>
1.390 +> const _ = {};
1.391 +
1.392 +///////////////////////////////////////////////////////////////////////////////
1.393 +/// \brief Reference to the current regex object
1.394 +///
1.395 +/// Useful when constructing recursive regular expression objects. The 'self'
1.396 +/// identifier is a short-hand for the current regex object. For instance,
1.397 +/// sregex rx = '(' >> (self | nil) >> ')'; will create a regex object that
1.398 +/// matches balanced parens such as "((()))".
1.399 +proto::op_proxy<
1.400 + proto::unary_op<detail::self_placeholder, proto::noop_tag>
1.401 +> const self = {};
1.402 +
1.403 +///////////////////////////////////////////////////////////////////////////////
1.404 +/// \brief Used to create character sets.
1.405 +///
1.406 +/// There are two ways to create character sets with the 'set' identifier. The
1.407 +/// easiest is to create a comma-separated list of the characters in the set,
1.408 +/// as in (set= 'a','b','c'). This set will match 'a', 'b', or 'c'. The other
1.409 +/// way is to define the set as an argument to the set subscript operator.
1.410 +/// For instance, set[ 'a' | range('b','c') | digit ] will match an 'a', 'b',
1.411 +/// 'c' or a digit character.
1.412 +///
1.413 +/// To complement a set, apply the '~' operator. For instance, ~(set= 'a','b','c')
1.414 +/// will match any character that is not an 'a', 'b', or 'c'.
1.415 +///
1.416 +/// Sets can be composed of other, possibly complemented, sets. For instance,
1.417 +/// set[ ~digit | ~(set= 'a','b','c') ].
1.418 +proto::op_proxy<
1.419 + detail::set_initializer_type
1.420 +> const set = {};
1.421 +
1.422 +///////////////////////////////////////////////////////////////////////////////
1.423 +/// \brief Sub-match placeholder, like $& in Perl
1.424 +proto::op_proxy<detail::mark_tag, int> const s0 = {0};
1.425 +
1.426 +///////////////////////////////////////////////////////////////////////////////
1.427 +/// \brief Sub-match placeholder, like $1 in perl.
1.428 +///
1.429 +/// To create a sub-match, assign a sub-expression to the sub-match placeholder.
1.430 +/// For instance, (s1= _) will match any one character and remember which
1.431 +/// character was matched in the 1st sub-match. Later in the pattern, you can
1.432 +/// refer back to the sub-match. For instance, (s1= _) >> s1 will match any
1.433 +/// character, and then match the same character again.
1.434 +///
1.435 +/// After a successful regex_match() or regex_search(), the sub-match placeholders
1.436 +/// can be used to index into the match_results\<\> object to retrieve the Nth
1.437 +/// sub-match.
1.438 +proto::op_proxy<detail::mark_tag, int> const s1 = {1};
1.439 +proto::op_proxy<detail::mark_tag, int> const s2 = {2};
1.440 +proto::op_proxy<detail::mark_tag, int> const s3 = {3};
1.441 +proto::op_proxy<detail::mark_tag, int> const s4 = {4};
1.442 +proto::op_proxy<detail::mark_tag, int> const s5 = {5};
1.443 +proto::op_proxy<detail::mark_tag, int> const s6 = {6};
1.444 +proto::op_proxy<detail::mark_tag, int> const s7 = {7};
1.445 +proto::op_proxy<detail::mark_tag, int> const s8 = {8};
1.446 +proto::op_proxy<detail::mark_tag, int> const s9 = {9};
1.447 +
1.448 +// NOTE: For the purpose of xpressive's documentation, make icase() look like an
1.449 +// ordinary function. In reality, it is a function object defined in detail/icase.hpp
1.450 +// so that it can serve double-duty as regex_constants::icase, the syntax_option_type.
1.451 +// Do the same for as_xpr(), which is actually defined in detail/static/as_xpr.hpp
1.452 +#ifdef BOOST_XPRESSIVE_DOXYGEN_INVOKED
1.453 +///////////////////////////////////////////////////////////////////////////////
1.454 +/// \brief Makes a literal into a regular expression.
1.455 +///
1.456 +/// Use as_xpr() to turn a literal into a regular expression. For instance,
1.457 +/// "foo" >> "bar" will not compile because both operands to the right-shift
1.458 +/// operator are const char*, and no such operator exists. Use as_xpr("foo") >> "bar"
1.459 +/// instead.
1.460 +///
1.461 +/// You can use as_xpr() with character literals in addition to string literals.
1.462 +/// For instance, as_xpr('a') will match an 'a'. You can also complement a
1.463 +/// character literal, as with ~as_xpr('a'). This will match any one character
1.464 +/// that is not an 'a'.
1.465 +template<typename Literal>
1.466 +inline typename detail::as_xpr_type<Literal>::const_reference
1.467 +as_xpr(Literal const &literal)
1.468 +{
1.469 + return detail::as_xpr_type<Literal>::call(xpr);
1.470 +}
1.471 +
1.472 +///////////////////////////////////////////////////////////////////////////////
1.473 +/// \brief Makes a sub-expression case-insensitive.
1.474 +///
1.475 +/// Use icase() to make a sub-expression case-insensitive. For instance,
1.476 +/// "foo" >> icase(set['b'] >> "ar") will match "foo" exactly followed by
1.477 +/// "bar" irrespective of case.
1.478 +template<typename Xpr>
1.479 +inline proto::binary_op<detail::icase_modifier, typename detail::as_xpr_type<Xpr>::type, modifier_tag> const
1.480 +icase(Xpr const &xpr)
1.481 +{
1.482 + detail::icase_modifier mod;
1.483 + return proto::make_op<modifier_tag>(mod, as_xpr(xpr));
1.484 +}
1.485 +#endif
1.486 +
1.487 +///////////////////////////////////////////////////////////////////////////////
1.488 +/// \brief Embed a regex object by reference.
1.489 +///
1.490 +/// \param rex The basic_regex object to embed by reference.
1.491 +template<typename BidiIter>
1.492 +inline proto::unary_op<detail::regex_placeholder<BidiIter, true>, proto::noop_tag> const
1.493 +by_ref(basic_regex<BidiIter> const &rex)
1.494 +{
1.495 + typedef detail::core_access<BidiIter> access;
1.496 + shared_ptr<detail::regex_impl<BidiIter> > impl = access::get_regex_impl(rex);
1.497 + return proto::noop(detail::regex_placeholder<BidiIter, true>(impl));
1.498 +}
1.499 +
1.500 +///////////////////////////////////////////////////////////////////////////////
1.501 +/// \brief Match a range of characters.
1.502 +///
1.503 +/// Match any character in the range [ch_min, ch_max].
1.504 +///
1.505 +/// \param ch_min The lower end of the range to match.
1.506 +/// \param ch_max The upper end of the range to match.
1.507 +template<typename Char>
1.508 +inline proto::unary_op<detail::range_placeholder<Char>, proto::noop_tag> const
1.509 +range(Char ch_min, Char ch_max)
1.510 +{
1.511 + return proto::noop(detail::range_placeholder<Char>(ch_min, ch_max));
1.512 +}
1.513 +
1.514 +///////////////////////////////////////////////////////////////////////////////
1.515 +/// \brief Make a sub-expression optional. Equivalent to !as_xpr(xpr).
1.516 +///
1.517 +/// \param xpr The sub-expression to make optional.
1.518 +template<typename Xpr>
1.519 +inline proto::unary_op
1.520 +<
1.521 + typename detail::as_xpr_type<Xpr>::type
1.522 + , proto::logical_not_tag
1.523 +> const
1.524 +optional(Xpr const &xpr)
1.525 +{
1.526 + return !as_xpr(xpr);
1.527 +}
1.528 +
1.529 +///////////////////////////////////////////////////////////////////////////////
1.530 +/// \brief Repeat a sub-expression multiple times.
1.531 +///
1.532 +/// There are two forms of the repeat\<\>() function template. To match a
1.533 +/// sub-expression N times, use repeat\<N\>(xpr). To match a sub-expression
1.534 +/// from M to N times, use repeat\<M,N\>(xpr).
1.535 +///
1.536 +/// The repeat\<\>() function creates a greedy quantifier. To make the quantifier
1.537 +/// non-greedy, apply the unary minus operator, as in -repeat\<M,N\>(xpr).
1.538 +///
1.539 +/// \param xpr The sub-expression to repeat.
1.540 +template<unsigned int Min, unsigned int Max, typename Xpr>
1.541 +inline proto::unary_op
1.542 +<
1.543 + typename detail::as_xpr_type<Xpr>::type
1.544 + , detail::generic_quant_tag<Min, Max>
1.545 +> const
1.546 +repeat(Xpr const &xpr)
1.547 +{
1.548 + return proto::make_op<detail::generic_quant_tag<Min, Max> >(as_xpr(xpr));
1.549 +}
1.550 +
1.551 +/// \overload
1.552 +template<unsigned int Count, typename Xpr2>
1.553 +inline proto::unary_op
1.554 +<
1.555 + typename detail::as_xpr_type<Xpr2>::type
1.556 + , detail::generic_quant_tag<Count, Count>
1.557 +> const
1.558 +repeat(Xpr2 const &xpr)
1.559 +{
1.560 + return proto::make_op<detail::generic_quant_tag<Count, Count> >(as_xpr(xpr));
1.561 +}
1.562 +
1.563 +///////////////////////////////////////////////////////////////////////////////
1.564 +/// \brief Create an independent sub-expression.
1.565 +///
1.566 +/// Turn off back-tracking for a sub-expression. Any branches or repeats within
1.567 +/// the sub-expression will match only one way, and no other alternatives are
1.568 +/// tried.
1.569 +///
1.570 +/// \attention keep(xpr) is equivalent to the perl (?>...) extension.
1.571 +///
1.572 +/// \param xpr The sub-expression to modify.
1.573 +template<typename Xpr>
1.574 +inline proto::unary_op
1.575 +<
1.576 + typename detail::as_xpr_type<Xpr>::type
1.577 + , detail::keeper_tag
1.578 +> const
1.579 +keep(Xpr const &xpr)
1.580 +{
1.581 + return proto::make_op<detail::keeper_tag>(as_xpr(xpr));
1.582 +}
1.583 +
1.584 +///////////////////////////////////////////////////////////////////////////////
1.585 +/// \brief Look-ahead assertion.
1.586 +///
1.587 +/// before(xpr) succeeds if the xpr sub-expression would match at the current
1.588 +/// position in the sequence, but xpr is not included in the match. For instance,
1.589 +/// before("foo") succeeds if we are before a "foo". Look-ahead assertions can be
1.590 +/// negated with the bit-compliment operator.
1.591 +///
1.592 +/// \attention before(xpr) is equivalent to the perl (?=...) extension.
1.593 +/// ~before(xpr) is a negative look-ahead assertion, equivalent to the
1.594 +/// perl (?!...) extension.
1.595 +///
1.596 +/// \param xpr The sub-expression to put in the look-ahead assertion.
1.597 +template<typename Xpr>
1.598 +inline proto::unary_op
1.599 +<
1.600 + typename detail::as_xpr_type<Xpr>::type
1.601 + , detail::lookahead_tag<true>
1.602 +> const
1.603 +before(Xpr const &xpr)
1.604 +{
1.605 + return proto::make_op<detail::lookahead_tag<true> >(as_xpr(xpr));
1.606 +}
1.607 +
1.608 +///////////////////////////////////////////////////////////////////////////////
1.609 +/// \brief Look-behind assertion.
1.610 +///
1.611 +/// after(xpr) succeeds if the xpr sub-expression would match at the current
1.612 +/// position minus N in the sequence, where N is the width of xpr. xpr is not included in
1.613 +/// the match. For instance, after("foo") succeeds if we are after a "foo". Look-behind
1.614 +/// assertions can be negated with the bit-complement operator.
1.615 +///
1.616 +/// \attention after(xpr) is equivalent to the perl (?<=...) extension.
1.617 +/// ~after(xpr) is a negative look-behind assertion, equivalent to the
1.618 +/// perl (?<!...) extension.
1.619 +///
1.620 +/// \param xpr The sub-expression to put in the look-ahead assertion.
1.621 +///
1.622 +/// \pre xpr cannot match a variable number of characters.
1.623 +template<typename Xpr>
1.624 +inline proto::unary_op
1.625 +<
1.626 + typename detail::as_xpr_type<Xpr>::type
1.627 + , detail::lookbehind_tag<true>
1.628 +> const
1.629 +after(Xpr const &xpr)
1.630 +{
1.631 + return proto::make_op<detail::lookbehind_tag<true> >(as_xpr(xpr));
1.632 +}
1.633 +
1.634 +///////////////////////////////////////////////////////////////////////////////
1.635 +/// \brief Specify a regex traits or a std::locale.
1.636 +///
1.637 +/// imbue() instructs the regex engine to use the specified traits or locale
1.638 +/// when matching the regex. The entire expression must use the same traits/locale.
1.639 +/// For instance, the following specifies a locale for use with a regex:
1.640 +/// std::locale loc;
1.641 +/// sregex rx = imbue(loc)(+digit);
1.642 +///
1.643 +/// \param loc The std::locale or regex traits object.
1.644 +template<typename Locale>
1.645 +inline detail::modifier_op<detail::locale_modifier<Locale> > const
1.646 +imbue(Locale const &loc)
1.647 +{
1.648 + detail::modifier_op<detail::locale_modifier<Locale> > mod =
1.649 + {
1.650 + detail::locale_modifier<Locale>(loc)
1.651 + , regex_constants::ECMAScript
1.652 + };
1.653 + return mod;
1.654 +}
1.655 +
1.656 +}} // namespace boost::xpressive
1.657 +
1.658 +#endif