regex.cpp revision 360784 
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
15static
16const char*
17make_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
64regex_error::regex_error(regex_constants::error_type ecode)
65    : runtime_error(make_error_type_string(ecode)),
66      __code_(ecode)
67{}
68
69regex_error::~regex_error() throw() {}
70
71namespace {
72
73struct collationnames
74{
75    const char* elem_;
76    char char_;
77};
78
79const 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
194struct classnames
195{
196    const char* elem_;
197    regex_traits<char>::char_class_type mask_;
198};
199
200const 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
219struct 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
229string
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
240regex_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
260template <>
261void
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
287template <>
288void
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