///////////////////////////////////////////////////////////////////////////////

/// \file regex_primitives.hpp

/// Contains the syntax elements for writing static regular expressions.

//

//  Copyright 2004 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 <climits>

#include <boost/mpl/assert.hpp>

#include <boost/preprocessor/cat.hpp>

#include <boost/xpressive/proto/proto.hpp>

#include <boost/xpressive/detail/detail_fwd.hpp>

#include <boost/xpressive/detail/core/icase.hpp>

#include <boost/xpressive/detail/core/action.hpp>

#include <boost/xpressive/detail/core/matchers.hpp>

#include <boost/xpressive/detail/static/as_xpr.hpp>

#include <boost/xpressive/detail/static/compile.hpp>

#include <boost/xpressive/detail/static/modifier.hpp>

#include <boost/xpressive/detail/static/regex_operators.hpp>

#include <boost/xpressive/detail/static/productions/productions.hpp>

namespace boost { namespace xpressive { namespace detail

{

typedef assert_word_placeholder<word_boundary<true> > assert_word_boundary;

typedef assert_word_placeholder<word_begin> assert_word_begin;

typedef assert_word_placeholder<word_end> assert_word_end;

/*

///////////////////////////////////////////////////////////////////////////////

/// 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::op_proxy<

    proto::unary_op<detail::epsilon_matcher, proto::noop_tag>

> const epsilon = {};

///////////////////////////////////////////////////////////////////////////////

/// \brief Successfully matches nothing.

///

/// Successfully matches a zero-width sequence. nil always succeeds and

/// never consumes any characters.

proto::op_proxy<

    proto::unary_op<detail::epsilon_matcher, proto::noop_tag>

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

    proto::unary_op<detail::posix_charset_placeholder, proto::noop_tag>

  , char const *

> const alnum = {"alnum"};

///////////////////////////////////////////////////////////////////////////////

/// \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::op_proxy<

    proto::unary_op<detail::posix_charset_placeholder, proto::noop_tag>

  , char const *

> const alpha = {"alpha"};

///////////////////////////////////////////////////////////////////////////////

/// \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::op_proxy<

    proto::unary_op<detail::posix_charset_placeholder, proto::noop_tag>

  , char const *

> const blank = {"blank"};

///////////////////////////////////////////////////////////////////////////////

/// \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::op_proxy<

    proto::unary_op<detail::posix_charset_placeholder, proto::noop_tag>

  , char const *

> const cntrl = {"cntrl"};

///////////////////////////////////////////////////////////////////////////////

/// \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::op_proxy<

    proto::unary_op<detail::posix_charset_placeholder, proto::noop_tag>

  , char const *

> const digit = {"digit"};

///////////////////////////////////////////////////////////////////////////////

/// \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::op_proxy<

    proto::unary_op<detail::posix_charset_placeholder, proto::noop_tag>

  , char const *

> const graph = {"graph"};

///////////////////////////////////////////////////////////////////////////////

/// \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::op_proxy<

    proto::unary_op<detail::posix_charset_placeholder, proto::noop_tag>

  , char const *

> const lower = {"lower"};

///////////////////////////////////////////////////////////////////////////////

/// \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::op_proxy<

    proto::unary_op<detail::posix_charset_placeholder, proto::noop_tag>

  , char const *

> const print = {"print"};

///////////////////////////////////////////////////////////////////////////////

/// \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::op_proxy<

    proto::unary_op<detail::posix_charset_placeholder, proto::noop_tag>

  , char const *

> const punct = {"punct"};

///////////////////////////////////////////////////////////////////////////////

/// \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::op_proxy<

    proto::unary_op<detail::posix_charset_placeholder, proto::noop_tag>

  , char const *

> const space = {"space"};

///////////////////////////////////////////////////////////////////////////////

/// \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::op_proxy<

    proto::unary_op<detail::posix_charset_placeholder, proto::noop_tag>

  , char const *

> const upper = {"upper"};

///////////////////////////////////////////////////////////////////////////////

/// \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::op_proxy<

    proto::unary_op<detail::posix_charset_placeholder, proto::noop_tag>

  , char const *

> const xdigit = {"xdigit"};

///////////////////////////////////////////////////////////////////////////////

/// \brief Beginning of sequence assertion.

///

/// For the character sequence [begin, end), 'bos' matches the

/// zero-width sub-sequence [begin, begin).

proto::op_proxy<

    proto::unary_op<detail::assert_bos_matcher, proto::noop_tag>

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

    proto::unary_op<detail::assert_eos_matcher, proto::noop_tag>

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

    proto::unary_op<detail::assert_bol_placeholder, proto::noop_tag>

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

    proto::unary_op<detail::assert_eol_placeholder, proto::noop_tag>

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

    proto::unary_op<detail::assert_word_begin, proto::noop_tag>

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

    proto::unary_op<detail::assert_word_end, proto::noop_tag>

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

    proto::unary_op<detail::assert_word_boundary, proto::noop_tag>

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

    proto::unary_op<detail::posix_charset_placeholder, proto::noop_tag>

  , char const *

> const _w = {"w"};

///////////////////////////////////////////////////////////////////////////////

/// \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::op_proxy<

    proto::unary_op<detail::posix_charset_placeholder, proto::noop_tag>

  , char const *

> const _d = {"d"};

///////////////////////////////////////////////////////////////////////////////

/// \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::op_proxy<

    proto::unary_op<detail::posix_charset_placeholder, proto::noop_tag>

  , char const *

> const _s = {"s"};

///////////////////////////////////////////////////////////////////////////////

/// \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::op_proxy<

    proto::unary_op<detail::literal_placeholder<char>, proto::noop_tag>

  , char

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

proto::op_proxy<

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

    proto::unary_op<detail::any_matcher, proto::noop_tag>

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

    proto::unary_op<detail::self_placeholder, proto::noop_tag>

> 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') ].

proto::op_proxy<

    detail::set_initializer_type

> const set = {};

///////////////////////////////////////////////////////////////////////////////

/// \brief Sub-match placeholder, like $& in Perl

proto::op_proxy<detail::mark_tag, int> const 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.

proto::op_proxy<detail::mark_tag, int> const s1 = {1};

proto::op_proxy<detail::mark_tag, int> const s2 = {2};

proto::op_proxy<detail::mark_tag, int> const s3 = {3};

proto::op_proxy<detail::mark_tag, int> const s4 = {4};

proto::op_proxy<detail::mark_tag, int> const s5 = {5};

proto::op_proxy<detail::mark_tag, int> const s6 = {6};

proto::op_proxy<detail::mark_tag, int> const s7 = {7};

proto::op_proxy<detail::mark_tag, int> const s8 = {8};

proto::op_proxy<detail::mark_tag, int> const 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.

// Do the same for as_xpr(), which is actually defined in detail/static/as_xpr.hpp

#ifdef BOOST_XPRESSIVE_DOXYGEN_INVOKED

///////////////////////////////////////////////////////////////////////////////

/// \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'.

template<typename Literal>

inline typename detail::as_xpr_type<Literal>::const_reference

as_xpr(Literal const &literal)

{

    return detail::as_xpr_type<Literal>::call(xpr);

}

///////////////////////////////////////////////////////////////////////////////

/// \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 Xpr>

inline proto::binary_op<detail::icase_modifier, typename detail::as_xpr_type<Xpr>::type, modifier_tag> const

icase(Xpr const &xpr)

{

    detail::icase_modifier mod;

    return proto::make_op<modifier_tag>(mod, as_xpr(xpr));

}

#endif

///////////////////////////////////////////////////////////////////////////////

/// \brief Embed a regex object by reference.

///

/// \param rex The basic_regex object to embed by reference.

template<typename BidiIter>

inline proto::unary_op<detail::regex_placeholder<BidiIter, true>, proto::noop_tag> const

by_ref(basic_regex<BidiIter> const &rex)

{

    typedef detail::core_access<BidiIter> access;

    shared_ptr<detail::regex_impl<BidiIter> > impl = access::get_regex_impl(rex);

    return proto::noop(detail::regex_placeholder<BidiIter, true>(impl));

}

///////////////////////////////////////////////////////////////////////////////

/// \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 proto::unary_op<detail::range_placeholder<Char>, proto::noop_tag> const

range(Char ch_min, Char ch_max)

{

    return proto::noop(detail::range_placeholder<Char>(ch_min, ch_max));

}

///////////////////////////////////////////////////////////////////////////////

/// \brief Make a sub-expression optional. Equivalent to !as_xpr(xpr).

///

/// \param xpr The sub-expression to make optional.

template<typename Xpr>

inline proto::unary_op

<

    typename detail::as_xpr_type<Xpr>::type

  , proto::logical_not_tag

> const

optional(Xpr const &xpr)

{

    return !as_xpr(xpr);

}

///////////////////////////////////////////////////////////////////////////////

/// \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\>(xpr). To match a sub-expression

/// from M to N times, use repeat\<M,N\>(xpr).

///

/// The repeat\<\>() function creates a greedy quantifier. To make the quantifier

/// non-greedy, apply the unary minus operator, as in -repeat\<M,N\>(xpr).

///

/// \param xpr The sub-expression to repeat.

template<unsigned int Min, unsigned int Max, typename Xpr>

inline proto::unary_op

<

    typename detail::as_xpr_type<Xpr>::type

  , detail::generic_quant_tag<Min, Max>

> const

repeat(Xpr const &xpr)

{

    return proto::make_op<detail::generic_quant_tag<Min, Max> >(as_xpr(xpr));

}

/// \overload

template<unsigned int Count, typename Xpr2>

inline proto::unary_op

<

    typename detail::as_xpr_type<Xpr2>::type

  , detail::generic_quant_tag<Count, Count>

> const

repeat(Xpr2 const &xpr)

{

    return proto::make_op<detail::generic_quant_tag<Count, Count> >(as_xpr(xpr));

}

///////////////////////////////////////////////////////////////////////////////

/// \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(xpr) is equivalent to the perl (?>...) extension.

///

/// \param xpr The sub-expression to modify.

template<typename Xpr>

inline proto::unary_op

<

    typename detail::as_xpr_type<Xpr>::type

  , detail::keeper_tag

> const

keep(Xpr const &xpr)

{

    return proto::make_op<detail::keeper_tag>(as_xpr(xpr));

}

///////////////////////////////////////////////////////////////////////////////

/// \brief Look-ahead assertion.

///

/// before(xpr) succeeds if the xpr sub-expression would match at the current

/// position in the sequence, but xpr 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(xpr) is equivalent to the perl (?=...) extension.

/// ~before(xpr) is a negative look-ahead assertion, equivalent to the

/// perl (?!...) extension.

///

/// \param xpr The sub-expression to put in the look-ahead assertion.

template<typename Xpr>

inline proto::unary_op

<

    typename detail::as_xpr_type<Xpr>::type

  , detail::lookahead_tag<true>

> const

before(Xpr const &xpr)

{

    return proto::make_op<detail::lookahead_tag<true> >(as_xpr(xpr));

}

///////////////////////////////////////////////////////////////////////////////

/// \brief Look-behind assertion.

///

/// after(xpr) succeeds if the xpr sub-expression would match at the current

/// position minus N in the sequence, where N is the width of xpr. xpr 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(xpr) is equivalent to the perl (?<=...) extension.

/// ~after(xpr) is a negative look-behind assertion, equivalent to the

/// perl (?<!...) extension.

///

/// \param xpr The sub-expression to put in the look-ahead assertion.

///

/// \pre xpr cannot match a variable number of characters.

template<typename Xpr>

inline proto::unary_op

<

    typename detail::as_xpr_type<Xpr>::type

  , detail::lookbehind_tag<true>

> const

after(Xpr const &xpr)

{

    return proto::make_op<detail::lookbehind_tag<true> >(as_xpr(xpr));

}

///////////////////////////////////////////////////////////////////////////////

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

}

}} // namespace boost::xpressive

#endif