mirror of
https://github.com/jart/cosmopolitan.git
synced 2025-01-31 11:37:35 +00:00
399 lines
10 KiB
C++
399 lines
10 KiB
C++
//===----------------------------------------------------------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include <algorithm>
|
|
#include <iterator>
|
|
#include <regex>
|
|
|
|
_LIBCPP_BEGIN_NAMESPACE_STD
|
|
|
|
static const char* make_error_type_string(regex_constants::error_type ecode) {
|
|
switch (ecode) {
|
|
case regex_constants::error_collate:
|
|
return "The expression contained an invalid collating element name.";
|
|
case regex_constants::error_ctype:
|
|
return "The expression contained an invalid character class name.";
|
|
case regex_constants::error_escape:
|
|
return "The expression contained an invalid escaped character, or a "
|
|
"trailing escape.";
|
|
case regex_constants::error_backref:
|
|
return "The expression contained an invalid back reference.";
|
|
case regex_constants::error_brack:
|
|
return "The expression contained mismatched [ and ].";
|
|
case regex_constants::error_paren:
|
|
return "The expression contained mismatched ( and ).";
|
|
case regex_constants::error_brace:
|
|
return "The expression contained mismatched { and }.";
|
|
case regex_constants::error_badbrace:
|
|
return "The expression contained an invalid range in a {} expression.";
|
|
case regex_constants::error_range:
|
|
return "The expression contained an invalid character range, "
|
|
"such as [b-a] in most encodings.";
|
|
case regex_constants::error_space:
|
|
return "There was insufficient memory to convert the expression into "
|
|
"a finite state machine.";
|
|
case regex_constants::error_badrepeat:
|
|
return "One of *?+{ was not preceded by a valid regular expression.";
|
|
case regex_constants::error_complexity:
|
|
return "The complexity of an attempted match against a regular "
|
|
"expression exceeded a pre-set level.";
|
|
case regex_constants::error_stack:
|
|
return "There was insufficient memory to determine whether the regular "
|
|
"expression could match the specified character sequence.";
|
|
case regex_constants::__re_err_grammar:
|
|
return "An invalid regex grammar has been requested.";
|
|
case regex_constants::__re_err_empty:
|
|
return "An empty regex is not allowed in the POSIX grammar.";
|
|
case regex_constants::__re_err_parse:
|
|
return "The parser did not consume the entire regular expression.";
|
|
default:
|
|
break;
|
|
}
|
|
return "Unknown error type";
|
|
}
|
|
|
|
regex_error::regex_error(regex_constants::error_type ecode)
|
|
: runtime_error(make_error_type_string(ecode)), __code_(ecode) {}
|
|
|
|
regex_error::~regex_error() throw() {}
|
|
|
|
namespace {
|
|
|
|
struct collationnames {
|
|
const char* elem_;
|
|
char char_;
|
|
};
|
|
|
|
#if defined(__MVS__) && !defined(__NATIVE_ASCII_F)
|
|
// EBCDIC IBM-1047
|
|
// Sorted via the EBCDIC collating sequence
|
|
const collationnames collatenames[] = {
|
|
{"a", 0x81},
|
|
{"alert", 0x2f},
|
|
{"ampersand", 0x50},
|
|
{"apostrophe", 0x7d},
|
|
{"asterisk", 0x5c},
|
|
{"b", 0x82},
|
|
{"backslash", 0xe0},
|
|
{"backspace", 0x16},
|
|
{"c", 0x83},
|
|
{"carriage-return", 0xd},
|
|
{"circumflex", 0x5f},
|
|
{"circumflex-accent", 0x5f},
|
|
{"colon", 0x7a},
|
|
{"comma", 0x6b},
|
|
{"commercial-at", 0x7c},
|
|
{"d", 0x84},
|
|
{"dollar-sign", 0x5b},
|
|
{"e", 0x85},
|
|
{"eight", 0xf8},
|
|
{"equals-sign", 0x7e},
|
|
{"exclamation-mark", 0x5a},
|
|
{"f", 0x86},
|
|
{"five", 0xf5},
|
|
{"form-feed", 0xc},
|
|
{"four", 0xf4},
|
|
{"full-stop", 0x4b},
|
|
{"g", 0x87},
|
|
{"grave-accent", 0x79},
|
|
{"greater-than-sign", 0x6e},
|
|
{"h", 0x88},
|
|
{"hyphen", 0x60},
|
|
{"hyphen-minus", 0x60},
|
|
{"i", 0x89},
|
|
{"j", 0x91},
|
|
{"k", 0x92},
|
|
{"l", 0x93},
|
|
{"left-brace", 0xc0},
|
|
{"left-curly-bracket", 0xc0},
|
|
{"left-parenthesis", 0x4d},
|
|
{"left-square-bracket", 0xad},
|
|
{"less-than-sign", 0x4c},
|
|
{"low-line", 0x6d},
|
|
{"m", 0x94},
|
|
{"n", 0x95},
|
|
{"newline", 0x15},
|
|
{"nine", 0xf9},
|
|
{"number-sign", 0x7b},
|
|
{"o", 0x96},
|
|
{"one", 0xf1},
|
|
{"p", 0x97},
|
|
{"percent-sign", 0x6c},
|
|
{"period", 0x4b},
|
|
{"plus-sign", 0x4e},
|
|
{"q", 0x98},
|
|
{"question-mark", 0x6f},
|
|
{"quotation-mark", 0x7f},
|
|
{"r", 0x99},
|
|
{"reverse-solidus", 0xe0},
|
|
{"right-brace", 0xd0},
|
|
{"right-curly-bracket", 0xd0},
|
|
{"right-parenthesis", 0x5d},
|
|
{"right-square-bracket", 0xbd},
|
|
{"s", 0xa2},
|
|
{"semicolon", 0x5e},
|
|
{"seven", 0xf7},
|
|
{"six", 0xf6},
|
|
{"slash", 0x61},
|
|
{"solidus", 0x61},
|
|
{"space", 0x40},
|
|
{"t", 0xa3},
|
|
{"tab", 0x5},
|
|
{"three", 0xf3},
|
|
{"tilde", 0xa1},
|
|
{"two", 0xf2},
|
|
{"u", 0xa4},
|
|
{"underscore", 0x6d},
|
|
{"v", 0xa5},
|
|
{"vertical-line", 0x4f},
|
|
{"vertical-tab", 0xb},
|
|
{"w", 0xa6},
|
|
{"x", 0xa7},
|
|
{"y", 0xa8},
|
|
{"z", 0xa9},
|
|
{"zero", 0xf0},
|
|
{"A", 0xc1},
|
|
{"B", 0xc2},
|
|
{"C", 0xc3},
|
|
{"D", 0xc4},
|
|
{"E", 0xc5},
|
|
{"F", 0xc6},
|
|
{"G", 0xc7},
|
|
{"H", 0xc8},
|
|
{"I", 0xc9},
|
|
{"J", 0xd1},
|
|
{"K", 0xd2},
|
|
{"L", 0xd3},
|
|
{"M", 0xd4},
|
|
{"N", 0xd5},
|
|
{"NUL", 0},
|
|
{"O", 0xd6},
|
|
{"P", 0xd7},
|
|
{"Q", 0xd8},
|
|
{"R", 0xd9},
|
|
{"S", 0xe2},
|
|
{"T", 0xe3},
|
|
{"U", 0xe4},
|
|
{"V", 0xe5},
|
|
{"W", 0xe6},
|
|
{"X", 0xe7},
|
|
{"Y", 0xe8},
|
|
{"Z", 0xe9}};
|
|
#else
|
|
// ASCII
|
|
const collationnames collatenames[] = {
|
|
{"A", 0x41},
|
|
{"B", 0x42},
|
|
{"C", 0x43},
|
|
{"D", 0x44},
|
|
{"E", 0x45},
|
|
{"F", 0x46},
|
|
{"G", 0x47},
|
|
{"H", 0x48},
|
|
{"I", 0x49},
|
|
{"J", 0x4a},
|
|
{"K", 0x4b},
|
|
{"L", 0x4c},
|
|
{"M", 0x4d},
|
|
{"N", 0x4e},
|
|
{"NUL", 0x00},
|
|
{"O", 0x4f},
|
|
{"P", 0x50},
|
|
{"Q", 0x51},
|
|
{"R", 0x52},
|
|
{"S", 0x53},
|
|
{"T", 0x54},
|
|
{"U", 0x55},
|
|
{"V", 0x56},
|
|
{"W", 0x57},
|
|
{"X", 0x58},
|
|
{"Y", 0x59},
|
|
{"Z", 0x5a},
|
|
{"a", 0x61},
|
|
{"alert", 0x07},
|
|
{"ampersand", 0x26},
|
|
{"apostrophe", 0x27},
|
|
{"asterisk", 0x2a},
|
|
{"b", 0x62},
|
|
{"backslash", 0x5c},
|
|
{"backspace", 0x08},
|
|
{"c", 0x63},
|
|
{"carriage-return", 0x0d},
|
|
{"circumflex", 0x5e},
|
|
{"circumflex-accent", 0x5e},
|
|
{"colon", 0x3a},
|
|
{"comma", 0x2c},
|
|
{"commercial-at", 0x40},
|
|
{"d", 0x64},
|
|
{"dollar-sign", 0x24},
|
|
{"e", 0x65},
|
|
{"eight", 0x38},
|
|
{"equals-sign", 0x3d},
|
|
{"exclamation-mark", 0x21},
|
|
{"f", 0x66},
|
|
{"five", 0x35},
|
|
{"form-feed", 0x0c},
|
|
{"four", 0x34},
|
|
{"full-stop", 0x2e},
|
|
{"g", 0x67},
|
|
{"grave-accent", 0x60},
|
|
{"greater-than-sign", 0x3e},
|
|
{"h", 0x68},
|
|
{"hyphen", 0x2d},
|
|
{"hyphen-minus", 0x2d},
|
|
{"i", 0x69},
|
|
{"j", 0x6a},
|
|
{"k", 0x6b},
|
|
{"l", 0x6c},
|
|
{"left-brace", 0x7b},
|
|
{"left-curly-bracket", 0x7b},
|
|
{"left-parenthesis", 0x28},
|
|
{"left-square-bracket", 0x5b},
|
|
{"less-than-sign", 0x3c},
|
|
{"low-line", 0x5f},
|
|
{"m", 0x6d},
|
|
{"n", 0x6e},
|
|
{"newline", 0x0a},
|
|
{"nine", 0x39},
|
|
{"number-sign", 0x23},
|
|
{"o", 0x6f},
|
|
{"one", 0x31},
|
|
{"p", 0x70},
|
|
{"percent-sign", 0x25},
|
|
{"period", 0x2e},
|
|
{"plus-sign", 0x2b},
|
|
{"q", 0x71},
|
|
{"question-mark", 0x3f},
|
|
{"quotation-mark", 0x22},
|
|
{"r", 0x72},
|
|
{"reverse-solidus", 0x5c},
|
|
{"right-brace", 0x7d},
|
|
{"right-curly-bracket", 0x7d},
|
|
{"right-parenthesis", 0x29},
|
|
{"right-square-bracket", 0x5d},
|
|
{"s", 0x73},
|
|
{"semicolon", 0x3b},
|
|
{"seven", 0x37},
|
|
{"six", 0x36},
|
|
{"slash", 0x2f},
|
|
{"solidus", 0x2f},
|
|
{"space", 0x20},
|
|
{"t", 0x74},
|
|
{"tab", 0x09},
|
|
{"three", 0x33},
|
|
{"tilde", 0x7e},
|
|
{"two", 0x32},
|
|
{"u", 0x75},
|
|
{"underscore", 0x5f},
|
|
{"v", 0x76},
|
|
{"vertical-line", 0x7c},
|
|
{"vertical-tab", 0x0b},
|
|
{"w", 0x77},
|
|
{"x", 0x78},
|
|
{"y", 0x79},
|
|
{"z", 0x7a},
|
|
{"zero", 0x30}};
|
|
#endif
|
|
|
|
struct classnames {
|
|
const char* elem_;
|
|
regex_traits<char>::char_class_type mask_;
|
|
};
|
|
|
|
const classnames ClassNames[] = {
|
|
{"alnum", ctype_base::alnum},
|
|
{"alpha", ctype_base::alpha},
|
|
{"blank", ctype_base::blank},
|
|
{"cntrl", ctype_base::cntrl},
|
|
{"d", ctype_base::digit},
|
|
{"digit", ctype_base::digit},
|
|
{"graph", ctype_base::graph},
|
|
{"lower", ctype_base::lower},
|
|
{"print", ctype_base::print},
|
|
{"punct", ctype_base::punct},
|
|
{"s", ctype_base::space},
|
|
{"space", ctype_base::space},
|
|
{"upper", ctype_base::upper},
|
|
{"w", regex_traits<char>::__regex_word},
|
|
{"xdigit", ctype_base::xdigit}};
|
|
|
|
struct use_strcmp {
|
|
bool operator()(const collationnames& x, const char* y) { return strcmp(x.elem_, y) < 0; }
|
|
bool operator()(const classnames& x, const char* y) { return strcmp(x.elem_, y) < 0; }
|
|
};
|
|
|
|
} // namespace
|
|
|
|
string __get_collation_name(const char* s) {
|
|
const collationnames* i = std::lower_bound(begin(collatenames), end(collatenames), s, use_strcmp());
|
|
string r;
|
|
if (i != end(collatenames) && strcmp(s, i->elem_) == 0)
|
|
r = char(i->char_);
|
|
return r;
|
|
}
|
|
|
|
regex_traits<char>::char_class_type __get_classname(const char* s, bool __icase) {
|
|
const classnames* i = std::lower_bound(begin(ClassNames), end(ClassNames), s, use_strcmp());
|
|
regex_traits<char>::char_class_type r = 0;
|
|
if (i != end(ClassNames) && strcmp(s, i->elem_) == 0) {
|
|
r = i->mask_;
|
|
if (r == regex_traits<char>::__regex_word)
|
|
r |= ctype_base::alnum | ctype_base::upper | ctype_base::lower;
|
|
else if (__icase) {
|
|
if (r & (ctype_base::lower | ctype_base::upper))
|
|
r |= ctype_base::alpha;
|
|
}
|
|
}
|
|
return r;
|
|
}
|
|
|
|
template <>
|
|
void __match_any_but_newline<char>::__exec(__state& __s) const {
|
|
if (__s.__current_ != __s.__last_) {
|
|
switch (*__s.__current_) {
|
|
case '\r':
|
|
case '\n':
|
|
__s.__do_ = __state::__reject;
|
|
__s.__node_ = nullptr;
|
|
break;
|
|
default:
|
|
__s.__do_ = __state::__accept_and_consume;
|
|
++__s.__current_;
|
|
__s.__node_ = this->first();
|
|
break;
|
|
}
|
|
} else {
|
|
__s.__do_ = __state::__reject;
|
|
__s.__node_ = nullptr;
|
|
}
|
|
}
|
|
|
|
template <>
|
|
void __match_any_but_newline<wchar_t>::__exec(__state& __s) const {
|
|
if (__s.__current_ != __s.__last_) {
|
|
switch (*__s.__current_) {
|
|
case '\r':
|
|
case '\n':
|
|
case 0x2028:
|
|
case 0x2029:
|
|
__s.__do_ = __state::__reject;
|
|
__s.__node_ = nullptr;
|
|
break;
|
|
default:
|
|
__s.__do_ = __state::__accept_and_consume;
|
|
++__s.__current_;
|
|
__s.__node_ = this->first();
|
|
break;
|
|
}
|
|
} else {
|
|
__s.__do_ = __state::__reject;
|
|
__s.__node_ = nullptr;
|
|
}
|
|
}
|
|
|
|
_LIBCPP_END_NAMESPACE_STD
|