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*
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 
64 regex_error::regex_error(regex_constants::error_type ecode)
65     : runtime_error(make_error_type_string(ecode)),
66       __code_(ecode)
67 {}
68 
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 {
221     bool operator()(const collationnames& x, const char* y)
222         {return strcmp(x.elem_, y) < 0;}
223     bool operator()(const classnames& x, const char* y)
224         {return strcmp(x.elem_, y) < 0;}
225 };
226 
227 }
228 
229 string
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
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
262 __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
289 __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