1 | /////////////////////////////////////////////////////////////////////////////// |
2 | /// \file basic_regex.hpp |
3 | /// Contains the definition of the basic_regex\<\> class template and its |
4 | /// associated helper functions. |
5 | // |
6 | // Copyright 2008 Eric Niebler. Distributed under the Boost |
7 | // Software License, Version 1.0. (See accompanying file |
8 | // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) |
9 | |
10 | #ifndef BOOST_XPRESSIVE_BASIC_REGEX_HPP_EAN_10_04_2005 |
11 | #define BOOST_XPRESSIVE_BASIC_REGEX_HPP_EAN_10_04_2005 |
12 | |
13 | // MS compatible compilers support #pragma once |
14 | #if defined(_MSC_VER) |
15 | # pragma once |
16 | #endif |
17 | |
18 | #include <boost/config.hpp> |
19 | #include <boost/mpl/bool.hpp> |
20 | #include <boost/xpressive/xpressive_fwd.hpp> |
21 | #include <boost/xpressive/regex_constants.hpp> |
22 | #include <boost/xpressive/detail/detail_fwd.hpp> |
23 | #include <boost/xpressive/detail/core/regex_impl.hpp> |
24 | #include <boost/xpressive/detail/core/regex_domain.hpp> |
25 | |
26 | // Doxygen can't handle proto :-( |
27 | #ifndef BOOST_XPRESSIVE_DOXYGEN_INVOKED |
28 | # include <boost/xpressive/detail/static/grammar.hpp> |
29 | # include <boost/proto/extends.hpp> |
30 | #endif |
31 | |
32 | #if BOOST_XPRESSIVE_HAS_MS_STACK_GUARD |
33 | # include <excpt.h> // for _exception_code() |
34 | # include <malloc.h> // for _resetstkoflw() |
35 | #endif |
36 | |
37 | namespace boost { namespace xpressive |
38 | { |
39 | |
40 | namespace detail |
41 | { |
42 | inline void throw_on_stack_error(bool stack_error) |
43 | { |
44 | BOOST_XPR_ENSURE_(!stack_error, regex_constants::error_stack, "Regex stack space exhausted" ); |
45 | } |
46 | } |
47 | |
48 | /////////////////////////////////////////////////////////////////////////////// |
49 | // basic_regex |
50 | // |
51 | /// \brief Class template basic_regex\<\> is a class for holding a compiled regular expression. |
52 | template<typename BidiIter> |
53 | struct basic_regex |
54 | : proto::extends< |
55 | proto::expr<proto::tag::terminal, proto::term<detail::tracking_ptr<detail::regex_impl<BidiIter> > >, 0> |
56 | , basic_regex<BidiIter> |
57 | , detail::regex_domain |
58 | > |
59 | { |
60 | private: |
61 | typedef proto::expr<proto::tag::terminal, proto::term<detail::tracking_ptr<detail::regex_impl<BidiIter> > >, 0> pimpl_type; |
62 | typedef proto::extends<pimpl_type, basic_regex<BidiIter>, detail::regex_domain> base_type; |
63 | |
64 | public: |
65 | typedef BidiIter iterator_type; |
66 | typedef typename iterator_value<BidiIter>::type char_type; |
67 | // For compatibility with std::basic_regex |
68 | typedef typename iterator_value<BidiIter>::type value_type; |
69 | typedef typename detail::string_type<char_type>::type string_type; |
70 | typedef regex_constants::syntax_option_type flag_type; |
71 | |
72 | BOOST_STATIC_CONSTANT(regex_constants::syntax_option_type, ECMAScript = regex_constants::ECMAScript); |
73 | BOOST_STATIC_CONSTANT(regex_constants::syntax_option_type, icase = regex_constants::icase_); |
74 | BOOST_STATIC_CONSTANT(regex_constants::syntax_option_type, nosubs = regex_constants::nosubs); |
75 | BOOST_STATIC_CONSTANT(regex_constants::syntax_option_type, optimize = regex_constants::optimize); |
76 | BOOST_STATIC_CONSTANT(regex_constants::syntax_option_type, collate = regex_constants::collate); |
77 | BOOST_STATIC_CONSTANT(regex_constants::syntax_option_type, single_line = regex_constants::single_line); |
78 | BOOST_STATIC_CONSTANT(regex_constants::syntax_option_type, not_dot_null = regex_constants::not_dot_null); |
79 | BOOST_STATIC_CONSTANT(regex_constants::syntax_option_type, not_dot_newline = regex_constants::not_dot_newline); |
80 | BOOST_STATIC_CONSTANT(regex_constants::syntax_option_type, ignore_white_space = regex_constants::ignore_white_space); |
81 | |
82 | /// \post regex_id() == 0 |
83 | /// \post mark_count() == 0 |
84 | basic_regex() |
85 | : base_type() |
86 | { |
87 | } |
88 | |
89 | /// \param that The basic_regex object to copy. |
90 | /// \post regex_id() == that.regex_id() |
91 | /// \post mark_count() == that.mark_count() |
92 | basic_regex(basic_regex<BidiIter> const &that) |
93 | : base_type(that) |
94 | { |
95 | } |
96 | |
97 | /// \param that The basic_regex object to copy. |
98 | /// \post regex_id() == that.regex_id() |
99 | /// \post mark_count() == that.mark_count() |
100 | /// \return *this |
101 | basic_regex<BidiIter> &operator =(basic_regex<BidiIter> const &that) |
102 | { |
103 | proto::value(*this) = proto::value(that); |
104 | return *this; |
105 | } |
106 | |
107 | /// Construct from a static regular expression. |
108 | /// |
109 | /// \param expr The static regular expression |
110 | /// \pre Expr is the type of a static regular expression. |
111 | /// \post regex_id() != 0 |
112 | /// \post mark_count() \>= 0 |
113 | template<typename Expr> |
114 | basic_regex(Expr const &expr) |
115 | : base_type() |
116 | { |
117 | BOOST_XPRESSIVE_CHECK_REGEX(Expr, char_type); |
118 | this->compile_(expr, is_valid_regex<Expr, char_type>()); |
119 | } |
120 | |
121 | /// Construct from a static regular expression. |
122 | /// |
123 | /// \param expr The static regular expression. |
124 | /// \pre Expr is the type of a static regular expression. |
125 | /// \post regex_id() != 0 |
126 | /// \post mark_count() \>= 0 |
127 | /// \throw std::bad_alloc on out of memory |
128 | /// \return *this |
129 | template<typename Expr> |
130 | basic_regex<BidiIter> &operator =(Expr const &expr) |
131 | { |
132 | BOOST_XPRESSIVE_CHECK_REGEX(Expr, char_type); |
133 | this->compile_(expr, is_valid_regex<Expr, char_type>()); |
134 | return *this; |
135 | } |
136 | |
137 | /// Returns the count of capturing sub-expressions in this regular expression |
138 | /// |
139 | std::size_t mark_count() const |
140 | { |
141 | return proto::value(*this) ? proto::value(*this)->mark_count_ : 0; |
142 | } |
143 | |
144 | /// Returns a token which uniquely identifies this regular expression. |
145 | /// |
146 | regex_id_type regex_id() const |
147 | { |
148 | return proto::value(*this) ? proto::value(*this)->xpr_.get() : 0; |
149 | } |
150 | |
151 | /// Swaps the contents of this basic_regex object with another. |
152 | /// |
153 | /// \param that The other basic_regex object. |
154 | /// \attention This is a shallow swap that does not do reference tracking. |
155 | /// If you embed a basic_regex object by reference in another |
156 | /// regular expression and then swap its contents with another |
157 | /// basic_regex object, the change will not be visible to the |
158 | /// enclosing regular expression. It is done this way to ensure |
159 | /// that swap() cannot throw. |
160 | /// \throw nothrow |
161 | void swap(basic_regex<BidiIter> &that) // throw() |
162 | { |
163 | proto::value(*this).swap(proto::value(that)); |
164 | } |
165 | |
166 | /// Factory method for building a regex object from a range of characters. |
167 | /// Equivalent to regex_compiler\< BidiIter \>().compile(begin, end, flags); |
168 | /// |
169 | /// \param begin The beginning of a range of characters representing the |
170 | /// regular expression to compile. |
171 | /// \param end The end of a range of characters representing the |
172 | /// regular expression to compile. |
173 | /// \param flags Optional bitmask that determines how the pat string is |
174 | /// interpreted. (See syntax_option_type.) |
175 | /// \return A basic_regex object corresponding to the regular expression |
176 | /// represented by the character range. |
177 | /// \pre [begin,end) is a valid range. |
178 | /// \pre The range of characters specified by [begin,end) contains a |
179 | /// valid string-based representation of a regular expression. |
180 | /// \throw regex_error when the range of characters has invalid regular |
181 | /// expression syntax. |
182 | template<typename InputIter> |
183 | static basic_regex<BidiIter> compile(InputIter begin, InputIter end, flag_type flags = regex_constants::ECMAScript) |
184 | { |
185 | return regex_compiler<BidiIter>().compile(begin, end, flags); |
186 | } |
187 | |
188 | /// \overload |
189 | /// |
190 | template<typename InputRange> |
191 | static basic_regex<BidiIter> compile(InputRange const &pat, flag_type flags = regex_constants::ECMAScript) |
192 | { |
193 | return regex_compiler<BidiIter>().compile(pat, flags); |
194 | } |
195 | |
196 | /// \overload |
197 | /// |
198 | static basic_regex<BidiIter> compile(char_type const *begin, flag_type flags = regex_constants::ECMAScript) |
199 | { |
200 | return regex_compiler<BidiIter>().compile(begin, flags); |
201 | } |
202 | |
203 | /// \overload |
204 | /// |
205 | static basic_regex<BidiIter> compile(char_type const *begin, std::size_t len, flag_type flags) |
206 | { |
207 | return regex_compiler<BidiIter>().compile(begin, len, flags); |
208 | } |
209 | |
210 | private: |
211 | friend struct detail::core_access<BidiIter>; |
212 | |
213 | // Avoid a common programming mistake. Construction from a string is |
214 | // ambiguous. It could mean: |
215 | // sregex rx = sregex::compile(str); // compile the string into a regex |
216 | // or |
217 | // sregex rx = as_xpr(str); // treat the string as a literal |
218 | // Since there is no easy way to disambiguate, it is disallowed. You must |
219 | // say what you mean. |
220 | |
221 | /// INTERNAL ONLY |
222 | basic_regex(char_type const *); |
223 | /// INTERNAL ONLY |
224 | basic_regex(string_type const &); |
225 | |
226 | /// INTERNAL ONLY |
227 | bool match_(detail::match_state<BidiIter> &state) const |
228 | { |
229 | #if BOOST_XPRESSIVE_HAS_MS_STACK_GUARD |
230 | bool success = false, stack_error = false; |
231 | __try |
232 | { |
233 | success = proto::value(*this)->xpr_->match(state); |
234 | } |
235 | __except(_exception_code() == 0xC00000FDUL) |
236 | { |
237 | stack_error = true; |
238 | _resetstkoflw(); |
239 | } |
240 | detail::throw_on_stack_error(stack_error); |
241 | return success; |
242 | #else |
243 | return proto::value(*this)->xpr_->match(state); |
244 | #endif |
245 | } |
246 | |
247 | // Compiles valid static regexes into a state machine. |
248 | /// INTERNAL ONLY |
249 | template<typename Expr> |
250 | void compile_(Expr const &expr, mpl::true_) |
251 | { |
252 | detail::static_compile(expr, proto::value(*this).get()); |
253 | } |
254 | |
255 | // No-op for invalid static regexes. |
256 | /// INTERNAL ONLY |
257 | template<typename Expr> |
258 | void compile_(Expr const &, mpl::false_) |
259 | { |
260 | } |
261 | }; |
262 | |
263 | #ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION |
264 | template<typename BidiIter> regex_constants::syntax_option_type const basic_regex<BidiIter>::ECMAScript; |
265 | template<typename BidiIter> regex_constants::syntax_option_type const basic_regex<BidiIter>::icase; |
266 | template<typename BidiIter> regex_constants::syntax_option_type const basic_regex<BidiIter>::nosubs; |
267 | template<typename BidiIter> regex_constants::syntax_option_type const basic_regex<BidiIter>::optimize; |
268 | template<typename BidiIter> regex_constants::syntax_option_type const basic_regex<BidiIter>::collate; |
269 | template<typename BidiIter> regex_constants::syntax_option_type const basic_regex<BidiIter>::single_line; |
270 | template<typename BidiIter> regex_constants::syntax_option_type const basic_regex<BidiIter>::not_dot_null; |
271 | template<typename BidiIter> regex_constants::syntax_option_type const basic_regex<BidiIter>::not_dot_newline; |
272 | template<typename BidiIter> regex_constants::syntax_option_type const basic_regex<BidiIter>::ignore_white_space; |
273 | #endif |
274 | |
275 | /////////////////////////////////////////////////////////////////////////////// |
276 | // swap |
277 | /// \brief Swaps the contents of two basic_regex objects. |
278 | /// \param left The first basic_regex object. |
279 | /// \param right The second basic_regex object. |
280 | /// \attention This is a shallow swap that does not do reference tracking. |
281 | /// If you embed a basic_regex object by reference in another |
282 | /// regular expression and then swap its contents with another |
283 | /// basic_regex object, the change will not be visible to the |
284 | /// enclosing regular expression. It is done this way to ensure |
285 | /// that swap() cannot throw. |
286 | /// \throw nothrow |
287 | template<typename BidiIter> |
288 | inline void swap(basic_regex<BidiIter> &left, basic_regex<BidiIter> &right) // throw() |
289 | { |
290 | left.swap(right); |
291 | } |
292 | |
293 | }} // namespace boost::xpressive |
294 | |
295 | #endif // BOOST_XPRESSIVE_BASIC_REGEX_HPP_EAN_10_04_2005 |
296 | |