| #ifndef __REGEXP_PCRE_HPP |
| #define __REGEXP_PCRE_HPP |
| |
| #include <pcre.h> |
| #include <array> |
| #include <stdexcept> |
| #include <string> |
| #include <vector> |
| |
| namespace rgx { |
| /* partially implement the std::regex interface using PCRE for performance |
| * (=> pass "match" as non-const reference) |
| */ |
| |
| namespace regex_constants { |
| enum error_type { |
| _enum_error_collate, |
| _enum_error_ctype, |
| _enum_error_escape, |
| _enum_error_backref, |
| _enum_error_brack, |
| _enum_error_paren, |
| _enum_error_brace, |
| _enum_error_badbrace, |
| _enum_error_range, |
| _enum_error_space, |
| _enum_error_badrepeat, |
| _enum_error_complexity, |
| _enum_error_stack, |
| _enum_error_last |
| }; |
| static const error_type error_collate(_enum_error_collate); |
| static const error_type error_ctype(_enum_error_ctype); |
| static const error_type error_escape(_enum_error_escape); |
| static const error_type error_backref(_enum_error_backref); |
| static const error_type error_brack(_enum_error_brack); |
| static const error_type error_paren(_enum_error_paren); |
| static const error_type error_brace(_enum_error_brace); |
| static const error_type error_badbrace(_enum_error_badbrace); |
| static const error_type error_range(_enum_error_range); |
| static const error_type error_space(_enum_error_space); |
| static const error_type error_badrepeat(_enum_error_badrepeat); |
| static const error_type error_complexity(_enum_error_complexity); |
| static const error_type error_stack(_enum_error_stack); |
| } // namespace regex_constants |
| |
| class regex_error : public std::runtime_error { |
| private: |
| regex_constants::error_type errcode; |
| |
| public: |
| explicit regex_error(regex_constants::error_type code, const char* what = "regex error") |
| : runtime_error(what), errcode(code) |
| {} |
| |
| [[nodiscard]] auto virtual code() const -> regex_constants::error_type; |
| }; |
| |
| [[nodiscard]] auto regex_error::code() const -> regex_constants::error_type |
| { |
| return errcode; |
| } |
| |
| class regex { |
| private: |
| int errcode = 0; |
| |
| const char* errptr = nullptr; |
| |
| int erroffset = 0; |
| |
| pcre* const re = nullptr; |
| |
| static const std::array<regex_constants::error_type, 86> errcode_pcre2regex; |
| |
| static const auto BASE = 10; |
| |
| public: |
| inline regex() = default; |
| |
| inline regex(const regex&) = delete; |
| |
| inline regex(regex&&) = default; |
| |
| inline auto operator=(const regex&) -> regex& = delete; |
| |
| inline auto operator=(regex &&) -> regex& = delete; |
| |
| explicit regex(const std::string& str) : regex(str.c_str()) {} |
| |
| explicit regex(const char* const str) |
| : re{pcre_compile2(str, 0, &errcode, &errptr, &erroffset, nullptr)} |
| { |
| if (re == nullptr) { |
| std::string what = std::string("regex error: ") + errptr + '\n'; |
| what += " '" + std::string{str} + "'\n"; |
| what += " " + std::string(erroffset, ' ') + '^'; |
| |
| throw regex_error(errcode_pcre2regex.at(errcode), what.c_str()); |
| } |
| } |
| |
| ~regex() |
| { |
| if (re != nullptr) { |
| pcre_free(re); |
| } |
| } |
| |
| inline auto operator()() const -> const pcre* |
| { |
| return re; |
| } |
| }; |
| |
| class smatch { |
| friend auto regex_search(std::string::const_iterator begin, |
| std::string::const_iterator end, |
| smatch& match, // NOLINT(google-runtime-references) |
| const regex& rgx); // match std::regex interface. |
| |
| private: |
| std::string::const_iterator begin; |
| |
| std::string::const_iterator end; |
| |
| std::vector<int> vec{}; |
| |
| int n = 0; |
| |
| public: |
| [[nodiscard]] inline auto position(int i = 0) const |
| { |
| return (i < 0 || i >= n) ? std::string::npos : vec[2 * i]; |
| } |
| |
| [[nodiscard]] inline auto length(int i = 0) const |
| { |
| return (i < 0 || i >= n) ? 0 : vec[2 * i + 1] - vec[2 * i]; |
| } |
| |
| [[nodiscard]] auto str(int i = 0) const -> std::string |
| { // should we throw? |
| if (i < 0 || i >= n) { |
| return ""; |
| } |
| int x = vec[2 * i]; |
| if (x < 0) { |
| return ""; |
| } |
| int y = vec[2 * i + 1]; |
| return std::string{begin + x, begin + y}; |
| } |
| |
| [[nodiscard]] auto format(const std::string& fmt) const; |
| |
| [[nodiscard]] auto size() const -> int |
| { |
| return n; |
| } |
| |
| [[nodiscard]] inline auto empty() const |
| { |
| return n < 0; |
| } |
| |
| [[nodiscard]] inline auto ready() const |
| { |
| return !vec.empty(); |
| } |
| }; |
| |
| inline auto regex_search(const std::string& subj, const regex& rgx); |
| |
| auto regex_replace(const std::string& subj, const regex& rgx, const std::string& insert); |
| |
| inline auto regex_search(const std::string& subj, |
| smatch& match, // NOLINT(google-runtime-references) |
| const regex& rgx); // match std::regex interface. |
| |
| auto regex_search(std::string::const_iterator begin, |
| std::string::const_iterator end, |
| smatch& match, // NOLINT(google-runtime-references) |
| const regex& rgx); // match std::regex interface. |
| |
| // ------------------------- implementation: ---------------------------------- |
| |
| inline auto regex_search(const std::string& subj, const regex& rgx) |
| { |
| if (rgx() == nullptr) { |
| throw std::runtime_error("regex_search error: no regex given"); |
| } |
| int n = |
| pcre_exec(rgx(), nullptr, subj.c_str(), static_cast<int>(subj.length()), 0, 0, nullptr, 0); |
| return n >= 0; |
| } |
| |
| auto regex_search(const std::string::const_iterator begin, |
| const std::string::const_iterator end, |
| smatch& match, |
| const regex& rgx) |
| { |
| if (rgx() == nullptr) { |
| throw std::runtime_error("regex_search error: no regex given"); |
| } |
| |
| int sz = 0; |
| pcre_fullinfo(rgx(), nullptr, PCRE_INFO_CAPTURECOUNT, &sz); |
| sz = 3 * (sz + 1); |
| |
| match.vec.reserve(sz); |
| |
| const char* subj = &*begin; |
| int len = static_cast<int>(&*end - subj); |
| |
| match.begin = begin; |
| match.end = end; |
| |
| match.n = pcre_exec(rgx(), nullptr, subj, len, 0, 0, &match.vec[0], sz); |
| |
| if (match.n < 0) { |
| return false; |
| } |
| if (match.n == 0) { |
| match.n = sz / 3; |
| } |
| |
| return true; |
| } |
| |
| inline auto regex_search(const std::string& subj, smatch& match, const regex& rgx) |
| { |
| return regex_search(subj.begin(), subj.end(), match, rgx); |
| } |
| |
| auto smatch::format(const std::string& fmt) const |
| { |
| std::string ret{}; |
| size_t index = 0; |
| |
| size_t pos = 0; |
| while ((pos = fmt.find('$', index)) != std::string::npos) { |
| ret.append(fmt, index, pos - index); |
| index = pos + 1; |
| |
| char chr = fmt[index++]; |
| switch (chr) { |
| case '&': // match |
| ret += str(0); |
| break; |
| |
| case '`': // prefix |
| ret.append(begin, begin + vec[0]); |
| break; |
| |
| case '\'': // suffix |
| ret.append(begin + vec[1], end); |
| break; |
| |
| default: |
| if (isdigit(chr) != 0) { // one or two digits => submatch: |
| int num = chr - '0'; |
| chr = fmt[index]; |
| if (isdigit(chr) != 0) { // second digit: |
| ++index; |
| static const auto base = 10; |
| num = num * base + chr - '0'; |
| } |
| ret += str(num); |
| break; |
| } // else: |
| |
| ret += '$'; |
| [[fallthrough]]; |
| |
| case '$': // escaped |
| ret += chr; |
| } |
| } |
| ret.append(fmt, index); |
| return ret; |
| } |
| |
| auto regex_replace(const std::string& subj, const regex& rgx, const std::string& insert) |
| { |
| if (rgx() == nullptr) { |
| throw std::runtime_error("regex_replace error: no regex given"); |
| } |
| |
| std::string ret{}; |
| auto pos = subj.begin(); |
| |
| for (smatch match; regex_search(pos, subj.end(), match, rgx); |
| pos += match.position(0) + match.length(0)) |
| { |
| ret.append(pos, pos + match.position(0)); |
| ret.append(match.format(insert)); |
| } |
| |
| ret.append(pos, subj.end()); |
| return ret; |
| } |
| |
| // ------------ There is only the translation table below : ------------------- |
| |
| const std::array<regex_constants::error_type, 86> regex::errcode_pcre2regex = { |
| // 0 no error |
| regex_constants::error_type::_enum_error_last, |
| // 1 \ at end of pattern |
| regex_constants::error_escape, |
| // 2 \c at end of pattern |
| regex_constants::error_escape, |
| // 3 unrecognized character follows \ . |
| regex_constants::error_escape, |
| // 4 numbers out of order in {} quantifier |
| regex_constants::error_badbrace, |
| // 5 number too big in {} quantifier |
| regex_constants::error_badbrace, |
| // 6 missing terminating for character class |
| regex_constants::error_brack, |
| // 7 invalid escape sequence in character class |
| regex_constants::error_escape, |
| // 8 range out of order in character class |
| regex_constants::error_range, |
| // 9 nothing to repeat |
| regex_constants::error_badrepeat, |
| // 10 [this code is not in use |
| regex_constants::error_type::_enum_error_last, |
| // 11 internal error: unexpected repeat |
| regex_constants::error_badrepeat, |
| // 12 unrecognized character after (? or (?- |
| regex_constants::error_backref, |
| // 13 POSIX named classes are supported only within a class |
| regex_constants::error_range, |
| // 14 missing ) |
| regex_constants::error_paren, |
| // 15 reference to non-existent subpattern |
| regex_constants::error_backref, |
| // 16 erroffset passed as NULL |
| regex_constants::error_type::_enum_error_last, |
| // 17 unknown option bit(s) set |
| regex_constants::error_type::_enum_error_last, |
| // 18 missing ) after comment |
| regex_constants::error_paren, |
| // 19 [this code is not in use |
| regex_constants::error_type::_enum_error_last, |
| // 20 regular expression is too large |
| regex_constants::error_space, |
| // 21 failed to get memory |
| regex_constants::error_stack, |
| // 22 unmatched parentheses |
| regex_constants::error_paren, |
| // 23 internal error: code overflow |
| regex_constants::error_stack, |
| // 24 unrecognized character after (?< |
| regex_constants::error_backref, |
| // 25 lookbehind assertion is not fixed length |
| regex_constants::error_backref, |
| // 26 malformed number or name after (?( |
| regex_constants::error_backref, |
| // 27 conditional group contains more than two branches |
| regex_constants::error_backref, |
| // 28 assertion expected after (?( |
| regex_constants::error_backref, |
| // 29 (?R or (?[+-digits must be followed by ) |
| regex_constants::error_backref, |
| // 30 unknown POSIX class name |
| regex_constants::error_ctype, |
| // 31 POSIX collating elements are not supported |
| regex_constants::error_collate, |
| // 32 this version of PCRE is compiled without UTF support |
| regex_constants::error_collate, |
| // 33 [this code is not in use |
| regex_constants::error_type::_enum_error_last, |
| // 34 character value in \x{} or \o{} is too large |
| regex_constants::error_escape, |
| // 35 invalid condition (?(0) |
| regex_constants::error_backref, |
| // 36 \C not allowed in lookbehind assertion |
| regex_constants::error_escape, |
| // 37 PCRE does not support \L, \l, \N{name}, \U, or \u |
| regex_constants::error_escape, |
| // 38 number after (?C is > 255 |
| regex_constants::error_backref, |
| // 39 closing ) for (?C expected |
| regex_constants::error_paren, |
| // 40 recursive call could loop indefinitely |
| regex_constants::error_complexity, |
| // 41 unrecognized character after (?P |
| regex_constants::error_backref, |
| // 42 syntax error in subpattern name (missing terminator) |
| regex_constants::error_paren, |
| // 43 two named subpatterns have the same name |
| regex_constants::error_backref, |
| // 44 invalid UTF-8 string (specifically UTF-8) |
| regex_constants::error_collate, |
| // 45 support for \P, \p, and \X has not been compiled |
| regex_constants::error_escape, |
| // 46 malformed \P or \p sequence |
| regex_constants::error_escape, |
| // 47 unknown property name after \P or \p |
| regex_constants::error_escape, |
| // 48 subpattern name is too long (maximum 32 characters) |
| regex_constants::error_backref, |
| // 49 too many named subpatterns (maximum 10000) |
| regex_constants::error_complexity, |
| // 50 [this code is not in use |
| regex_constants::error_type::_enum_error_last, |
| // 51 octal value is greater than \377 in 8-bit non-UTF-8 mode |
| regex_constants::error_escape, |
| // 52 internal error: overran compiling workspace |
| regex_constants::error_type::_enum_error_last, |
| // 53 internal error: previously-checked referenced subpattern not found |
| regex_constants::error_type::_enum_error_last, |
| // 54 DEFINE group contains more than one branch |
| regex_constants::error_backref, |
| // 55 repeating a DEFINE group is not allowed |
| regex_constants::error_backref, |
| // 56 inconsistent NEWLINE options |
| regex_constants::error_escape, |
| // 57 \g is not followed by a braced, angle-bracketed, or quoted name/number or by a plain |
| // number |
| regex_constants::error_backref, |
| // 58 a numbered reference must not be zero |
| regex_constants::error_backref, |
| // 59 an argument is not allowed for (*ACCEPT), (*FAIL), or (*COMMIT) |
| regex_constants::error_complexity, |
| // 60 (*VERB) not recognized or malformed |
| regex_constants::error_complexity, |
| // 61 number is too big |
| regex_constants::error_complexity, |
| // 62 subpattern name expected |
| regex_constants::error_backref, |
| // 63 digit expected after (?+ |
| regex_constants::error_backref, |
| // 64 is an invalid data character in JavaScript compatibility mode |
| regex_constants::error_escape, |
| // 65 different names for subpatterns of the same number are not allowed |
| regex_constants::error_backref, |
| // 66 (*MARK) must have an argument |
| regex_constants::error_complexity, |
| // 67 this version of PCRE is not compiled with Unicode property support |
| regex_constants::error_collate, |
| // 68 \c must be followed by an ASCII character |
| regex_constants::error_escape, |
| // 69 \k is not followed by a braced, angle-bracketed, or quoted name |
| regex_constants::error_backref, |
| // 70 internal error: unknown opcode in find_fixedlength() |
| regex_constants::error_type::_enum_error_last, |
| // 71 \N is not supported in a class |
| regex_constants::error_ctype, |
| // 72 too many forward references |
| regex_constants::error_backref, |
| // 73 disallowed Unicode code point (>= 0xd800 && <= 0xdfff) |
| regex_constants::error_escape, |
| // 74 invalid UTF-16 string (specifically UTF-16) |
| regex_constants::error_collate, |
| // 75 name is too long in (*MARK), (*PRUNE), (*SKIP), or (*THEN) |
| regex_constants::error_complexity, |
| // 76 character value in \u.... sequence is too large |
| regex_constants::error_escape, |
| // 77 invalid UTF-32 string (specifically UTF-32) |
| regex_constants::error_collate, |
| // 78 setting UTF is disabled by the application |
| regex_constants::error_collate, |
| // 79 non-hex character in \x{} (closing brace missing?) |
| regex_constants::error_escape, |
| // 80 non-octal character in \o{} (closing brace missing?) |
| regex_constants::error_escape, |
| // 81 missing opening brace after \o |
| regex_constants::error_brace, |
| // 82 parentheses are too deeply nested |
| regex_constants::error_complexity, |
| // 83 invalid range in character class |
| regex_constants::error_range, |
| // 84 group name must start with a non-digit |
| regex_constants::error_backref, |
| // 85 parentheses are too deeply nested (stack check) |
| regex_constants::error_stack}; |
| |
| } // namespace rgx |
| |
| #endif |