src/regexp.c
| Line | Branch | Exec | Source |
|---|---|---|---|
| 1 | #include <errno.h> | ||
| 2 | #include <stdlib.h> | ||
| 3 | #include "regexp.h" | ||
| 4 | #include "util/arith.h" | ||
| 5 | #include "util/ascii.h" | ||
| 6 | #include "util/debug.h" | ||
| 7 | #include "util/hashmap.h" | ||
| 8 | #include "util/intern.h" | ||
| 9 | #include "util/xmalloc.h" | ||
| 10 | #include "util/xstring.h" | ||
| 11 | |||
| 12 | // NOLINTNEXTLINE(*-avoid-non-const-global-variables) | ||
| 13 | static HashMap interned_regexps = {.flags = HMAP_BORROWED_KEYS}; | ||
| 14 | |||
| 15 | ✗ | bool regexp_error_msg(ErrorBuffer *ebuf, const regex_t *re, const char *pattern, int err) | |
| 16 | { | ||
| 17 | ✗ | if (!ebuf) { | |
| 18 | return false; | ||
| 19 | } | ||
| 20 | ✗ | char msg[1024]; | |
| 21 | ✗ | regerror(err, re, msg, sizeof(msg)); | |
| 22 | ✗ | return error_msg(ebuf, "%s: %s", msg, pattern); | |
| 23 | } | ||
| 24 | |||
| 25 | 3 | const regex_t *regexp_compile_or_fatal_error(const char *pattern) | |
| 26 | { | ||
| 27 | 3 | const InternedRegexp *ir = regexp_intern(NULL, pattern); | |
| 28 |
1/2✗ Branch 3 → 4 not taken.
✓ Branch 3 → 5 taken 3 times.
|
3 | FATAL_ERROR_ON(!ir, EINVAL); |
| 29 | 3 | return &ir->re; | |
| 30 | } | ||
| 31 | |||
| 32 | 147 | bool regexp_exec ( | |
| 33 | const regex_t *re, | ||
| 34 | const char *text, | ||
| 35 | size_t text_len, | ||
| 36 | size_t nmatch, | ||
| 37 | regmatch_t *pmatch, | ||
| 38 | int flags | ||
| 39 | ) { | ||
| 40 | 147 | BUG_ON(nmatch && !pmatch); | |
| 41 | |||
| 42 | 147 | if (HAVE_REG_STARTEND) { | |
| 43 | // "If REG_STARTEND is specified, pmatch must point to at least | ||
| 44 | // one regmatch_t (even if nmatch is 0 or REG_NOSUB was specified), | ||
| 45 | // to hold the input offsets for REG_STARTEND." | ||
| 46 | // -- https://man.openbsd.org/regexec#:~:text=If-,REG_STARTEND,-is%20specified | ||
| 47 | 147 | regmatch_t tmp_startend; | |
| 48 |
2/2✓ Branch 4 → 5 taken 92 times.
✓ Branch 4 → 6 taken 55 times.
|
147 | pmatch = nmatch ? pmatch : &tmp_startend; |
| 49 | 147 | pmatch[0].rm_so = 0; | |
| 50 | 147 | pmatch[0].rm_eo = text_len; | |
| 51 | 147 | return !regexec(re, text, nmatch, pmatch, flags | REGEXP_STARTEND_FLAG); | |
| 52 | } | ||
| 53 | |||
| 54 | // Buffer must be null-terminated if REG_STARTEND isn't supported | ||
| 55 | char *cstr = xstrcut(text, text_len); | ||
| 56 | int ret = !regexec(re, cstr, nmatch, pmatch, flags); | ||
| 57 | free(cstr); | ||
| 58 | return ret; | ||
| 59 | } | ||
| 60 | |||
| 61 | // Check which word boundary tokens are supported by regcomp(3) | ||
| 62 | // (if any) and initialize `rwbt` with them for later use | ||
| 63 | 11 | RegexpWordBoundaryTokens regexp_get_word_boundary_tokens(void) | |
| 64 | { | ||
| 65 | 11 | static const char text[] = "SSfooEE SSfoo fooEE foo SSfooEE"; | |
| 66 | 11 | const regoff_t match_start = 20, match_end = 23; | |
| 67 | 11 | static const RegexpWordBoundaryTokens pairs[] = { | |
| 68 | {"\\<", "\\>", 2}, | ||
| 69 | {"[[:<:]]", "[[:>:]]", 7}, | ||
| 70 | {"\\b", "\\b", 2}, | ||
| 71 | }; | ||
| 72 | |||
| 73 | 11 | BUG_ON(ARRAYLEN(text) <= match_end); | |
| 74 | 11 | BUG_ON(!mem_equal(text + match_start - 1, " foo ", 5)); | |
| 75 | |||
| 76 | UNROLL_LOOP(ARRAYLEN(pairs)) | ||
| 77 |
1/2✓ Branch 17 → 5 taken 11 times.
✗ Branch 17 → 18 not taken.
|
11 | for (size_t i = 0; i < ARRAYLEN(pairs); i++) { |
| 78 | 11 | const RegexpWordBoundaryTokens *p = &pairs[i]; | |
| 79 | 11 | char patt[32]; | |
| 80 | 11 | xmempcpy4(patt, p->start, p->len, STRN("(foo)"), p->end, p->len, "", 1); | |
| 81 | 11 | regex_t re; | |
| 82 |
1/2✗ Branch 7 → 8 not taken.
✓ Branch 7 → 9 taken 11 times.
|
11 | if (regcomp(&re, patt, DEFAULT_REGEX_FLAGS) != 0) { |
| 83 | ✗ | continue; | |
| 84 | } | ||
| 85 | 11 | regmatch_t m[2]; | |
| 86 | 11 | bool match = !regexec(&re, text, ARRAYLEN(m), m, 0); | |
| 87 | 11 | regfree(&re); | |
| 88 |
3/6✓ Branch 11 → 12 taken 11 times.
✗ Branch 11 → 15 not taken.
✓ Branch 12 → 13 taken 11 times.
✗ Branch 12 → 15 not taken.
✓ Branch 13 → 14 taken 11 times.
✗ Branch 13 → 15 not taken.
|
11 | if (match && m[0].rm_so == match_start && m[0].rm_eo == match_end) { |
| 89 | 11 | return pairs[i]; | |
| 90 | } | ||
| 91 | } | ||
| 92 | |||
| 93 | ✗ | return (RegexpWordBoundaryTokens){.len = 0}; | |
| 94 | } | ||
| 95 | |||
| 96 | NONNULL_ARG(1) NONNULL_ARG_IF_NONZERO_LENGTH(3, 4) | ||
| 97 | 67 | static size_t regexp_escapeb(char *buf, size_t buflen, const char *pat, size_t plen) | |
| 98 | { | ||
| 99 | 67 | BUG_ON(buflen < (2 * plen) + 1); | |
| 100 | size_t o = 0; | ||
| 101 |
2/2✓ Branch 7 → 4 taken 539 times.
✓ Branch 7 → 8 taken 67 times.
|
606 | for (size_t i = 0; i < plen; i++) { |
| 102 | 539 | char ch = pat[i]; | |
| 103 |
2/2✓ Branch 4 → 5 taken 15 times.
✓ Branch 4 → 6 taken 524 times.
|
539 | if (is_regex_special_char(ch)) { |
| 104 | 15 | buf[o++] = '\\'; | |
| 105 | } | ||
| 106 | 539 | buf[o++] = ch; | |
| 107 | } | ||
| 108 | 67 | buf[o] = '\0'; | |
| 109 | 67 | return o; | |
| 110 | } | ||
| 111 | |||
| 112 | 1 | char *regexp_escape(const char *pattern, size_t len) | |
| 113 | { | ||
| 114 | 1 | size_t buflen = xmul(2, len) + 1; | |
| 115 | 1 | char *buf = xmalloc(buflen); | |
| 116 | 1 | regexp_escapeb(buf, buflen, pattern, len); | |
| 117 | 1 | return buf; | |
| 118 | } | ||
| 119 | |||
| 120 | 66 | size_t string_append_escaped_regex(String *s, StringView pattern) | |
| 121 | { | ||
| 122 | 66 | size_t bufsize = xmul(2, pattern.length) + 1; | |
| 123 | 66 | char *buf = string_reserve_space(s, bufsize); | |
| 124 | 66 | size_t esc_len = regexp_escapeb(buf, bufsize, pattern.data, pattern.length); | |
| 125 | 66 | BUG_ON(esc_len < pattern.length); | |
| 126 | 66 | s->len += esc_len; | |
| 127 | 66 | return esc_len; | |
| 128 | } | ||
| 129 | |||
| 130 | 38 | const InternedRegexp *regexp_intern(ErrorBuffer *ebuf, const char *pattern) | |
| 131 | { | ||
| 132 |
1/2✓ Branch 2 → 3 taken 38 times.
✗ Branch 2 → 14 not taken.
|
38 | if (pattern[0] == '\0') { |
| 133 | return NULL; | ||
| 134 | } | ||
| 135 | |||
| 136 | 38 | InternedRegexp *ir = hashmap_get(&interned_regexps, pattern); | |
| 137 |
2/2✓ Branch 4 → 5 taken 35 times.
✓ Branch 4 → 14 taken 3 times.
|
38 | if (ir) { |
| 138 | return ir; | ||
| 139 | } | ||
| 140 | |||
| 141 | 35 | ir = xmalloc(sizeof(*ir)); | |
| 142 | 35 | int err = regcomp(&ir->re, pattern, DEFAULT_REGEX_FLAGS | REG_NEWLINE | REG_NOSUB); | |
| 143 |
1/2✗ Branch 7 → 8 not taken.
✓ Branch 7 → 10 taken 35 times.
|
35 | if (unlikely(err)) { |
| 144 | ✗ | regexp_error_msg(ebuf, &ir->re, pattern, err); | |
| 145 | ✗ | free(ir); | |
| 146 | ✗ | return NULL; | |
| 147 | } | ||
| 148 | |||
| 149 | 35 | BUG_ON(!(interned_regexps.flags & HMAP_BORROWED_KEYS)); | |
| 150 | 35 | const char *str = str_intern(pattern); | |
| 151 | 35 | ir->str = str; | |
| 152 | 35 | return hashmap_insert(&interned_regexps, (char*)str, ir); | |
| 153 | } | ||
| 154 | |||
| 155 | 56 | bool regexp_is_interned(const char *pattern) | |
| 156 | { | ||
| 157 | // Note that this only checks that an entry matching `pattern` | ||
| 158 | // exists and NOT for pointer equality between `pattern` and | ||
| 159 | // the corresponding `InternedRegexp::str` | ||
| 160 | 56 | return !!hashmap_find(&interned_regexps, pattern); | |
| 161 | } | ||
| 162 | |||
| 163 | 35 | static void free_interned_regexp(InternedRegexp *ir) | |
| 164 | { | ||
| 165 | 35 | regfree(&ir->re); | |
| 166 | 35 | free(ir); | |
| 167 | 35 | } | |
| 168 | |||
| 169 | 11 | void free_interned_regexps(void) | |
| 170 | { | ||
| 171 | 11 | BUG_ON(!(interned_regexps.flags & HMAP_BORROWED_KEYS)); | |
| 172 | 11 | hashmap_free(&interned_regexps, FREE_FUNC(free_interned_regexp)); | |
| 173 | 11 | } | |
| 174 |