1 ///////////////////////////////////////////////////////////////////////////////
2 /// \file regex_constants.hpp
3 /// Contains definitions for the syntax_option_type, match_flag_type and
4 /// error_type enumerations.
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_REGEX_CONSTANTS_HPP_EAN_10_04_2005
11 #define BOOST_XPRESSIVE_REGEX_CONSTANTS_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/mpl/identity.hpp>
19
20 #ifndef BOOST_XPRESSIVE_DOXYGEN_INVOKED
21 # define icase icase_
22 #endif
23
24 namespace boost { namespace xpressive { namespace regex_constants
25 {
26
27 /// Flags used to customize the regex syntax
28 ///
29 enum syntax_option_type
30 {
31 // these flags are required:
32
33 ECMAScript = 0, ///< Specifies that the grammar recognized by the regular expression
34 ///< engine uses its normal semantics: that is the same as that given
35 ///< in the ECMA-262, ECMAScript Language Specification, Chapter 15
36 ///< part 10, RegExp (Regular Expression) Objects (FWD.1).
37 ///<
38 icase = 1 << 1, ///< Specifies that matching of regular expressions against a character
39 ///< container sequence shall be performed without regard to case.
40 ///<
41 nosubs = 1 << 2, ///< Specifies that when a regular expression is matched against a
42 ///< character container sequence, then no sub-expression matches are to
43 ///< be stored in the supplied match_results structure.
44 ///<
45 optimize = 1 << 3, ///< Specifies that the regular expression engine should pay more
46 ///< attention to the speed with which regular expressions are matched,
47 ///< and less to the speed with which regular expression objects are
48 ///< constructed. Otherwise it has no detectable effect on the program
49 ///< output.
50 ///<
51 collate = 1 << 4, ///< Specifies that character ranges of the form "[a-b]" should be
52 ///< locale sensitive.
53 ///<
54
55 // These flags are optional. If the functionality is supported
56 // then the flags shall take these names.
57
58 //basic = 1 << 5, ///< Specifies that the grammar recognized by the regular expression
59 // ///< engine is the same as that used by POSIX basic regular expressions
60 // ///< in IEEE Std 1003.1-2001, Portable Operating System Interface
61 // ///< (POSIX), Base Definitions and Headers, Section 9, Regular
62 // ///< Expressions (FWD.1).
63 // ///<
64 //extended = 1 << 6, ///< Specifies that the grammar recognized by the regular expression
65 // ///< engine is the same as that used by POSIX extended regular
66 // ///< expressions in IEEE Std 1003.1-2001, Portable Operating System
67 // ///< Interface (POSIX), Base Definitions and Headers, Section 9,
68 // ///< Regular Expressions (FWD.1).
69 // ///<
70 //awk = 1 << 7, ///< Specifies that the grammar recognized by the regular expression
71 // ///< engine is the same as that used by POSIX utility awk in IEEE Std
72 // ///< 1003.1-2001, Portable Operating System Interface (POSIX), Shells
73 // ///< and Utilities, Section 4, awk (FWD.1).
74 // ///<
75 //grep = 1 << 8, ///< Specifies that the grammar recognized by the regular expression
76 // ///< engine is the same as that used by POSIX utility grep in IEEE Std
77 // ///< 1003.1-2001, Portable Operating System Interface (POSIX),
78 // ///< Shells and Utilities, Section 4, Utilities, grep (FWD.1).
79 // ///<
80 //egrep = 1 << 9, ///< Specifies that the grammar recognized by the regular expression
81 // ///< engine is the same as that used by POSIX utility grep when given
82 // ///< the -E option in IEEE Std 1003.1-2001, Portable Operating System
83 // ///< Interface (POSIX), Shells and Utilities, Section 4, Utilities,
84 // ///< grep (FWD.1).
85 // ///<
86
87 // these flags are specific to xpressive, and they help with perl compliance.
88
89 single_line = 1 << 10, ///< Specifies that the ^ and \$ metacharacters DO NOT match at
90 ///< internal line breaks. Note that this is the opposite of the
91 ///< perl default. It is the inverse of perl's /m (multi-line)
92 ///< modifier.
93 ///<
94 not_dot_null = 1 << 11, ///< Specifies that the . metacharacter does not match the null
95 ///< character \\0.
96 ///<
97 not_dot_newline = 1 << 12, ///< Specifies that the . metacharacter does not match the
98 ///< newline character \\n.
99 ///<
100 ignore_white_space = 1 << 13 ///< Specifies that non-escaped white-space is not significant.
101 ///<
102 };
103
104 /// Flags used to customize the behavior of the regex algorithms
105 ///
106 enum match_flag_type
107 {
108 match_default = 0, ///< Specifies that matching of regular expressions proceeds
109 ///< without any modification of the normal rules used in
110 ///< ECMA-262, ECMAScript Language Specification, Chapter 15
111 ///< part 10, RegExp (Regular Expression) Objects (FWD.1)
112 ///<
113 match_not_bol = 1 << 1, ///< Specifies that the expression "^" should not be matched
114 ///< against the sub-sequence [first,first).
115 ///<
116 match_not_eol = 1 << 2, ///< Specifies that the expression "\$" should not be
117 ///< matched against the sub-sequence [last,last).
118 ///<
119 match_not_bow = 1 << 3, ///< Specifies that the expression "\\b" should not be
120 ///< matched against the sub-sequence [first,first).
121 ///<
122 match_not_eow = 1 << 4, ///< Specifies that the expression "\\b" should not be
123 ///< matched against the sub-sequence [last,last).
124 ///<
125 match_any = 1 << 7, ///< Specifies that if more than one match is possible then
126 ///< any match is an acceptable result.
127 ///<
128 match_not_null = 1 << 8, ///< Specifies that the expression can not be matched
129 ///< against an empty sequence.
130 ///<
131 match_continuous = 1 << 10, ///< Specifies that the expression must match a sub-sequence
132 ///< that begins at first.
133 ///<
134 match_partial = 1 << 11, ///< Specifies that if no match can be found, then it is
135 ///< acceptable to return a match [from, last) where
136 ///< from != last, if there exists some sequence of characters
137 ///< [from,to) of which [from,last) is a prefix, and which
138 ///< would result in a full match.
139 ///<
140 match_prev_avail = 1 << 12, ///< Specifies that --first is a valid iterator position,
141 ///< when this flag is set then the flags match_not_bol
142 ///< and match_not_bow are ignored by the regular expression
143 ///< algorithms (RE.7) and iterators (RE.8).
144 ///<
145 format_default = 0, ///< Specifies that when a regular expression match is to be
146 ///< replaced by a new string, that the new string is
147 ///< constructed using the rules used by the ECMAScript
148 ///< replace function in ECMA-262, ECMAScript Language
149 ///< Specification, Chapter 15 part 5.4.11
150 ///< String.prototype.replace. (FWD.1). In addition during
151 ///< search and replace operations then all non-overlapping
152 ///< occurrences of the regular expression are located and
153 ///< replaced, and sections of the input that did not match
154 ///< the expression, are copied unchanged to the output
155 ///< string.
156 ///<
157 format_sed = 1 << 13, ///< Specifies that when a regular expression match is to be
158 ///< replaced by a new string, that the new string is
159 ///< constructed using the rules used by the Unix sed
160 ///< utility in IEEE Std 1003.1-2001, Portable Operating
161 ///< SystemInterface (POSIX), Shells and Utilities.
162 ///<
163 format_perl = 1 << 14, ///< Specifies that when a regular expression match is to be
164 ///< replaced by a new string, that the new string is
165 ///< constructed using an implementation defined superset
166 ///< of the rules used by the ECMAScript replace function in
167 ///< ECMA-262, ECMAScript Language Specification, Chapter 15
168 ///< part 5.4.11 String.prototype.replace (FWD.1).
169 ///<
170 format_no_copy = 1 << 15, ///< When specified during a search and replace operation,
171 ///< then sections of the character container sequence being
172 ///< searched that do match the regular expression, are not
173 ///< copied to the output string.
174 ///<
175 format_first_only = 1 << 16, ///< When specified during a search and replace operation,
176 ///< then only the first occurrence of the regular
177 ///< expression is replaced.
178 ///<
179 format_literal = 1 << 17, ///< Treat the format string as a literal.
180 ///<
181 format_all = 1 << 18 ///< Specifies that all syntax extensions are enabled,
182 ///< including conditional (?ddexpression1:expression2)
183 ///< replacements.
184 ///<
185 };
186
187 /// Error codes used by the regex_error type
188 ///
189 enum error_type
190 {
191 error_collate, ///< The expression contained an invalid collating element name.
192 ///<
193 error_ctype, ///< The expression contained an invalid character class name.
194 ///<
195 error_escape, ///< The expression contained an invalid escaped character,
196 ///< or a trailing escape.
197 ///<
198 error_subreg, ///< The expression contained an invalid back-reference.
199 ///<
200 error_brack, ///< The expression contained mismatched [ and ].
201 ///<
202 error_paren, ///< The expression contained mismatched ( and ).
203 ///<
204 error_brace, ///< The expression contained mismatched { and }.
205 ///<
206 error_badbrace, ///< The expression contained an invalid range in a {} expression.
207 ///<
208 error_range, ///< The expression contained an invalid character range, for
209 ///< example [b-a].
210 ///<
211 error_space, ///< There was insufficient memory to convert the expression into a
212 ///< finite state machine.
213 ///<
214 error_badrepeat, ///< One of *?+{ was not preceded by a valid regular expression.
215 ///<
216 error_complexity, ///< The complexity of an attempted match against a regular
217 ///< expression exceeded a pre-set level.
218 ///<
219 error_stack, ///< There was insufficient memory to determine whether the regular
220 ///< expression could match the specified character sequence.
221 ///<
222 error_badref, ///< An nested regex is uninitialized.
223 ///<
224 error_badmark, ///< An invalid use of a named capture.
225 ///<
226 error_badlookbehind, ///< An attempt to create a variable-width look-behind assertion
227 ///< was detected.
228 ///<
229 error_badrule, ///< An invalid use of a rule was detected.
230 ///<
231 error_badarg, ///< An argument to an action was unbound.
232 ///<
233 error_badattr, ///< Tried to read from an uninitialized attribute.
234 ///<
235 error_internal ///< An internal error has occurred.
236 ///<
237 };
238
239 /// INTERNAL ONLY
operator &(syntax_option_type b1,syntax_option_type b2)240 inline syntax_option_type operator &(syntax_option_type b1, syntax_option_type b2)
241 {
242 return static_cast<syntax_option_type>(
243 static_cast<int>(b1) & static_cast<int>(b2));
244 }
245
246 /// INTERNAL ONLY
operator |(syntax_option_type b1,syntax_option_type b2)247 inline syntax_option_type operator |(syntax_option_type b1, syntax_option_type b2)
248 {
249 return static_cast<syntax_option_type>(static_cast<int>(b1) | static_cast<int>(b2));
250 }
251
252 /// INTERNAL ONLY
operator ^(syntax_option_type b1,syntax_option_type b2)253 inline syntax_option_type operator ^(syntax_option_type b1, syntax_option_type b2)
254 {
255 return static_cast<syntax_option_type>(static_cast<int>(b1) ^ static_cast<int>(b2));
256 }
257
258 /// INTERNAL ONLY
operator ~(syntax_option_type b)259 inline syntax_option_type operator ~(syntax_option_type b)
260 {
261 return static_cast<syntax_option_type>(~static_cast<int>(b));
262 }
263
264 /// INTERNAL ONLY
operator &(match_flag_type b1,match_flag_type b2)265 inline match_flag_type operator &(match_flag_type b1, match_flag_type b2)
266 {
267 return static_cast<match_flag_type>(static_cast<int>(b1) & static_cast<int>(b2));
268 }
269
270 /// INTERNAL ONLY
operator |(match_flag_type b1,match_flag_type b2)271 inline match_flag_type operator |(match_flag_type b1, match_flag_type b2)
272 {
273 return static_cast<match_flag_type>(static_cast<int>(b1) | static_cast<int>(b2));
274 }
275
276 /// INTERNAL ONLY
operator ^(match_flag_type b1,match_flag_type b2)277 inline match_flag_type operator ^(match_flag_type b1, match_flag_type b2)
278 {
279 return static_cast<match_flag_type>(static_cast<int>(b1) ^ static_cast<int>(b2));
280 }
281
282 /// INTERNAL ONLY
operator ~(match_flag_type b)283 inline match_flag_type operator ~(match_flag_type b)
284 {
285 return static_cast<match_flag_type>(~static_cast<int>(b));
286 }
287
288 }}} // namespace boost::xpressive::regex_constants
289
290 #ifndef BOOST_XPRESSIVE_DOXYGEN_INVOKED
291 # undef icase
292 #endif
293
294 #endif
295