1 //===-------------------------- regex.cpp ---------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8
9 #include "regex"
10 #include "algorithm"
11 #include "iterator"
12
13 _LIBCPP_BEGIN_NAMESPACE_STD
14
15 static
16 const char*
make_error_type_string(regex_constants::error_type ecode)17 make_error_type_string(regex_constants::error_type ecode)
18 {
19 switch (ecode)
20 {
21 case regex_constants::error_collate:
22 return "The expression contained an invalid collating element name.";
23 case regex_constants::error_ctype:
24 return "The expression contained an invalid character class name.";
25 case regex_constants::error_escape:
26 return "The expression contained an invalid escaped character, or a "
27 "trailing escape.";
28 case regex_constants::error_backref:
29 return "The expression contained an invalid back reference.";
30 case regex_constants::error_brack:
31 return "The expression contained mismatched [ and ].";
32 case regex_constants::error_paren:
33 return "The expression contained mismatched ( and ).";
34 case regex_constants::error_brace:
35 return "The expression contained mismatched { and }.";
36 case regex_constants::error_badbrace:
37 return "The expression contained an invalid range in a {} expression.";
38 case regex_constants::error_range:
39 return "The expression contained an invalid character range, "
40 "such as [b-a] in most encodings.";
41 case regex_constants::error_space:
42 return "There was insufficient memory to convert the expression into "
43 "a finite state machine.";
44 case regex_constants::error_badrepeat:
45 return "One of *?+{ was not preceded by a valid regular expression.";
46 case regex_constants::error_complexity:
47 return "The complexity of an attempted match against a regular "
48 "expression exceeded a pre-set level.";
49 case regex_constants::error_stack:
50 return "There was insufficient memory to determine whether the regular "
51 "expression could match the specified character sequence.";
52 case regex_constants::__re_err_grammar:
53 return "An invalid regex grammar has been requested.";
54 case regex_constants::__re_err_empty:
55 return "An empty regex is not allowed in the POSIX grammar.";
56 case regex_constants::__re_err_parse:
57 return "The parser did not consume the entire regular expression.";
58 default:
59 break;
60 }
61 return "Unknown error type";
62 }
63
regex_error(regex_constants::error_type ecode)64 regex_error::regex_error(regex_constants::error_type ecode)
65 : runtime_error(make_error_type_string(ecode)),
66 __code_(ecode)
67 {}
68
~regex_error()69 regex_error::~regex_error() throw() {}
70
71 namespace {
72
73 struct collationnames
74 {
75 const char* elem_;
76 char char_;
77 };
78
79 const collationnames collatenames[] =
80 {
81 {"A", 0x41},
82 {"B", 0x42},
83 {"C", 0x43},
84 {"D", 0x44},
85 {"E", 0x45},
86 {"F", 0x46},
87 {"G", 0x47},
88 {"H", 0x48},
89 {"I", 0x49},
90 {"J", 0x4a},
91 {"K", 0x4b},
92 {"L", 0x4c},
93 {"M", 0x4d},
94 {"N", 0x4e},
95 {"NUL", 0x00},
96 {"O", 0x4f},
97 {"P", 0x50},
98 {"Q", 0x51},
99 {"R", 0x52},
100 {"S", 0x53},
101 {"T", 0x54},
102 {"U", 0x55},
103 {"V", 0x56},
104 {"W", 0x57},
105 {"X", 0x58},
106 {"Y", 0x59},
107 {"Z", 0x5a},
108 {"a", 0x61},
109 {"alert", 0x07},
110 {"ampersand", 0x26},
111 {"apostrophe", 0x27},
112 {"asterisk", 0x2a},
113 {"b", 0x62},
114 {"backslash", 0x5c},
115 {"backspace", 0x08},
116 {"c", 0x63},
117 {"carriage-return", 0x0d},
118 {"circumflex", 0x5e},
119 {"circumflex-accent", 0x5e},
120 {"colon", 0x3a},
121 {"comma", 0x2c},
122 {"commercial-at", 0x40},
123 {"d", 0x64},
124 {"dollar-sign", 0x24},
125 {"e", 0x65},
126 {"eight", 0x38},
127 {"equals-sign", 0x3d},
128 {"exclamation-mark", 0x21},
129 {"f", 0x66},
130 {"five", 0x35},
131 {"form-feed", 0x0c},
132 {"four", 0x34},
133 {"full-stop", 0x2e},
134 {"g", 0x67},
135 {"grave-accent", 0x60},
136 {"greater-than-sign", 0x3e},
137 {"h", 0x68},
138 {"hyphen", 0x2d},
139 {"hyphen-minus", 0x2d},
140 {"i", 0x69},
141 {"j", 0x6a},
142 {"k", 0x6b},
143 {"l", 0x6c},
144 {"left-brace", 0x7b},
145 {"left-curly-bracket", 0x7b},
146 {"left-parenthesis", 0x28},
147 {"left-square-bracket", 0x5b},
148 {"less-than-sign", 0x3c},
149 {"low-line", 0x5f},
150 {"m", 0x6d},
151 {"n", 0x6e},
152 {"newline", 0x0a},
153 {"nine", 0x39},
154 {"number-sign", 0x23},
155 {"o", 0x6f},
156 {"one", 0x31},
157 {"p", 0x70},
158 {"percent-sign", 0x25},
159 {"period", 0x2e},
160 {"plus-sign", 0x2b},
161 {"q", 0x71},
162 {"question-mark", 0x3f},
163 {"quotation-mark", 0x22},
164 {"r", 0x72},
165 {"reverse-solidus", 0x5c},
166 {"right-brace", 0x7d},
167 {"right-curly-bracket", 0x7d},
168 {"right-parenthesis", 0x29},
169 {"right-square-bracket", 0x5d},
170 {"s", 0x73},
171 {"semicolon", 0x3b},
172 {"seven", 0x37},
173 {"six", 0x36},
174 {"slash", 0x2f},
175 {"solidus", 0x2f},
176 {"space", 0x20},
177 {"t", 0x74},
178 {"tab", 0x09},
179 {"three", 0x33},
180 {"tilde", 0x7e},
181 {"two", 0x32},
182 {"u", 0x75},
183 {"underscore", 0x5f},
184 {"v", 0x76},
185 {"vertical-line", 0x7c},
186 {"vertical-tab", 0x0b},
187 {"w", 0x77},
188 {"x", 0x78},
189 {"y", 0x79},
190 {"z", 0x7a},
191 {"zero", 0x30}
192 };
193
194 struct classnames
195 {
196 const char* elem_;
197 regex_traits<char>::char_class_type mask_;
198 };
199
200 const classnames ClassNames[] =
201 {
202 {"alnum", ctype_base::alnum},
203 {"alpha", ctype_base::alpha},
204 {"blank", ctype_base::blank},
205 {"cntrl", ctype_base::cntrl},
206 {"d", ctype_base::digit},
207 {"digit", ctype_base::digit},
208 {"graph", ctype_base::graph},
209 {"lower", ctype_base::lower},
210 {"print", ctype_base::print},
211 {"punct", ctype_base::punct},
212 {"s", ctype_base::space},
213 {"space", ctype_base::space},
214 {"upper", ctype_base::upper},
215 {"w", regex_traits<char>::__regex_word},
216 {"xdigit", ctype_base::xdigit}
217 };
218
219 struct use_strcmp
220 {
operator ()__anonf5395a5b0111::use_strcmp221 bool operator()(const collationnames& x, const char* y)
222 {return strcmp(x.elem_, y) < 0;}
operator ()__anonf5395a5b0111::use_strcmp223 bool operator()(const classnames& x, const char* y)
224 {return strcmp(x.elem_, y) < 0;}
225 };
226
227 }
228
229 string
__get_collation_name(const char * s)230 __get_collation_name(const char* s)
231 {
232 const collationnames* i =
233 _VSTD::lower_bound(begin(collatenames), end(collatenames), s, use_strcmp());
234 string r;
235 if (i != end(collatenames) && strcmp(s, i->elem_) == 0)
236 r = char(i->char_);
237 return r;
238 }
239
240 regex_traits<char>::char_class_type
__get_classname(const char * s,bool __icase)241 __get_classname(const char* s, bool __icase)
242 {
243 const classnames* i =
244 _VSTD::lower_bound(begin(ClassNames), end(ClassNames), s, use_strcmp());
245 regex_traits<char>::char_class_type r = 0;
246 if (i != end(ClassNames) && strcmp(s, i->elem_) == 0)
247 {
248 r = i->mask_;
249 if (r == regex_traits<char>::__regex_word)
250 r |= ctype_base::alnum | ctype_base::upper | ctype_base::lower;
251 else if (__icase)
252 {
253 if (r & (ctype_base::lower | ctype_base::upper))
254 r |= ctype_base::alpha;
255 }
256 }
257 return r;
258 }
259
260 template <>
261 void
__exec(__state & __s) const262 __match_any_but_newline<char>::__exec(__state& __s) const
263 {
264 if (__s.__current_ != __s.__last_)
265 {
266 switch (*__s.__current_)
267 {
268 case '\r':
269 case '\n':
270 __s.__do_ = __state::__reject;
271 __s.__node_ = nullptr;
272 break;
273 default:
274 __s.__do_ = __state::__accept_and_consume;
275 ++__s.__current_;
276 __s.__node_ = this->first();
277 break;
278 }
279 }
280 else
281 {
282 __s.__do_ = __state::__reject;
283 __s.__node_ = nullptr;
284 }
285 }
286
287 template <>
288 void
__exec(__state & __s) const289 __match_any_but_newline<wchar_t>::__exec(__state& __s) const
290 {
291 if (__s.__current_ != __s.__last_)
292 {
293 switch (*__s.__current_)
294 {
295 case '\r':
296 case '\n':
297 case 0x2028:
298 case 0x2029:
299 __s.__do_ = __state::__reject;
300 __s.__node_ = nullptr;
301 break;
302 default:
303 __s.__do_ = __state::__accept_and_consume;
304 ++__s.__current_;
305 __s.__node_ = this->first();
306 break;
307 }
308 }
309 else
310 {
311 __s.__do_ = __state::__reject;
312 __s.__node_ = nullptr;
313 }
314 }
315
316 _LIBCPP_END_NAMESPACE_STD
317