| Line | Branch | Exec | Source |
|---|---|---|---|
| 1 | #include <stdbool.h> | ||
| 2 | #include <stdlib.h> | ||
| 3 | #include <string.h> | ||
| 4 | #include "parse.h" | ||
| 5 | #include "trace.h" | ||
| 6 | #include "util/ascii.h" | ||
| 7 | #include "util/debug.h" | ||
| 8 | #include "util/string.h" | ||
| 9 | #include "util/strtonum.h" | ||
| 10 | #include "util/unicode.h" | ||
| 11 | #include "util/xmalloc.h" | ||
| 12 | #include "util/xstring.h" | ||
| 13 | |||
| 14 | 1645 | static size_t parse_sq(const char *cmd, size_t len, String *buf) | |
| 15 | { | ||
| 16 | 1645 | const char *end = memchr(cmd, '\'', len); | |
| 17 |
2/2✓ Branch 2 → 3 taken 1644 times.
✓ Branch 2 → 4 taken 1 time.
|
1645 | size_t pos = end ? (size_t)(end - cmd) : len; |
| 18 | 1645 | string_append_buf(buf, cmd, pos); | |
| 19 |
2/2✓ Branch 5 → 6 taken 1 time.
✓ Branch 5 → 7 taken 1644 times.
|
1645 | return pos + (end ? 1 : 0); |
| 20 | } | ||
| 21 | |||
| 22 | 6 | static size_t unicode_escape(const char *str, size_t count, String *buf) | |
| 23 | { | ||
| 24 | // Note: `u` doesn't need to be initialized here, but `gcc -Og` | ||
| 25 | // gives a spurious -Wmaybe-uninitialized warning if it's not | ||
| 26 | 6 | unsigned int u = 0; | |
| 27 | 6 | static_assert(sizeof(u) >= 4); | |
| 28 | 6 | size_t n = buf_parse_hex_uint(str, count, &u); | |
| 29 |
3/4✓ Branch 3 → 4 taken 4 times.
✓ Branch 3 → 6 taken 2 times.
✓ Branch 4 → 5 taken 4 times.
✗ Branch 4 → 6 not taken.
|
6 | if (likely(n > 0 && u_is_unicode(u))) { |
| 30 | 4 | string_append_codepoint(buf, u); | |
| 31 | } | ||
| 32 | 6 | return n; | |
| 33 | } | ||
| 34 | |||
| 35 | 44 | static size_t hex_escape(const char *str, size_t count, String *buf) | |
| 36 | { | ||
| 37 | 44 | unsigned int x = 0; | |
| 38 | 44 | size_t n = buf_parse_hex_uint(str, count, &x); | |
| 39 |
2/2✓ Branch 3 → 4 taken 39 times.
✓ Branch 3 → 5 taken 5 times.
|
44 | if (likely(n == 2)) { |
| 40 | 39 | string_append_byte(buf, x); | |
| 41 | } | ||
| 42 | 44 | return n; | |
| 43 | } | ||
| 44 | |||
| 45 | 677 | static size_t parse_dq(const char *cmd, size_t len, String *buf) | |
| 46 | { | ||
| 47 | 677 | size_t pos = 0; | |
| 48 |
2/2✓ Branch 24 → 3 taken 3332 times.
✓ Branch 24 → 25 taken 2 times.
|
3334 | while (pos < len) { |
| 49 | 3332 | unsigned char ch = cmd[pos++]; | |
| 50 |
2/2✓ Branch 3 → 4 taken 2657 times.
✓ Branch 3 → 25 taken 675 times.
|
3332 | if (ch == '"') { |
| 51 | break; | ||
| 52 | } | ||
| 53 |
2/2✓ Branch 4 → 5 taken 683 times.
✓ Branch 4 → 22 taken 1974 times.
|
2657 | if (ch == '\\' && pos < len) { |
| 54 | 683 | ch = cmd[pos++]; | |
| 55 |
13/13✓ Branch 5 → 6 taken 1 time.
✓ Branch 5 → 7 taken 1 time.
✓ Branch 5 → 8 taken 1 time.
✓ Branch 5 → 9 taken 3 times.
✓ Branch 5 → 10 taken 382 times.
✓ Branch 5 → 11 taken 9 times.
✓ Branch 5 → 12 taken 121 times.
✓ Branch 5 → 13 taken 1 time.
✓ Branch 5 → 14 taken 44 times.
✓ Branch 5 → 16 taken 4 times.
✓ Branch 5 → 18 taken 2 times.
✓ Branch 5 → 20 taken 5 times.
✓ Branch 5 → 22 taken 109 times.
|
683 | switch (ch) { |
| 56 | 1 | case 'a': ch = '\a'; break; | |
| 57 | 1 | case 'b': ch = '\b'; break; | |
| 58 | 1 | case 'e': ch = '\033'; break; | |
| 59 | 3 | case 'f': ch = '\f'; break; | |
| 60 | 382 | case 'n': ch = '\n'; break; | |
| 61 | 9 | case 'r': ch = '\r'; break; | |
| 62 | 121 | case 't': ch = '\t'; break; | |
| 63 | 1 | case 'v': ch = '\v'; break; | |
| 64 | case '\\': | ||
| 65 | case '"': | ||
| 66 | break; | ||
| 67 | 44 | case 'x': | |
| 68 | 44 | pos += hex_escape(cmd + pos, MIN(2, len - pos), buf); | |
| 69 | 44 | continue; | |
| 70 | 4 | case 'u': | |
| 71 | 4 | pos += unicode_escape(cmd + pos, MIN(4, len - pos), buf); | |
| 72 | 4 | continue; | |
| 73 | 2 | case 'U': | |
| 74 | 2 | pos += unicode_escape(cmd + pos, MIN(8, len - pos), buf); | |
| 75 | 2 | continue; | |
| 76 | 5 | default: | |
| 77 | 5 | string_append_byte(buf, '\\'); | |
| 78 | 5 | break; | |
| 79 | } | ||
| 80 | } | ||
| 81 | 2607 | string_append_byte(buf, ch); | |
| 82 | } | ||
| 83 | |||
| 84 | 677 | return pos; | |
| 85 | } | ||
| 86 | |||
| 87 | 27 | static size_t expand_var ( | |
| 88 | const CommandRunner *runner, | ||
| 89 | const char *cmd, | ||
| 90 | size_t len, | ||
| 91 | String *buf | ||
| 92 | ) { | ||
| 93 |
4/4✓ Branch 2 → 3 taken 26 times.
✓ Branch 2 → 9 taken 1 time.
✓ Branch 3 → 4 taken 25 times.
✓ Branch 3 → 9 taken 1 time.
|
27 | if (!runner->expand_variable || len == 0) { |
| 94 | return len; | ||
| 95 | } | ||
| 96 | |||
| 97 | 25 | char *name = xstrcut(cmd, len); | |
| 98 | 25 | char *value = runner->expand_variable(runner->e, name); | |
| 99 | 25 | free(name); | |
| 100 |
2/2✓ Branch 6 → 7 taken 16 times.
✓ Branch 6 → 9 taken 9 times.
|
25 | if (value) { |
| 101 | 16 | string_append_cstring(buf, value); | |
| 102 | 16 | free(value); | |
| 103 | } | ||
| 104 | |||
| 105 | return len; | ||
| 106 | } | ||
| 107 | |||
| 108 | // Handles bracketed variables, e.g. ${varname} | ||
| 109 | 3 | static size_t parse_bracketed_var ( | |
| 110 | const CommandRunner *runner, | ||
| 111 | const char *cmd, | ||
| 112 | size_t len, | ||
| 113 | String *buf | ||
| 114 | ) { | ||
| 115 | 3 | const char *end = memchr(cmd + 1, '}', len - 1); | |
| 116 |
2/2✓ Branch 2 → 3 taken 1 time.
✓ Branch 2 → 5 taken 2 times.
|
3 | if (!end) { |
| 117 | 1 | LOG_WARNING("no end delimiter for bracketed variable: $%.*s", (int)len, cmd); | |
| 118 | 1 | return len; // Consume without appending | |
| 119 | } | ||
| 120 | |||
| 121 | 2 | size_t var_len = (size_t)(end - cmd) - 1; | |
| 122 | 2 | TRACE_CMD("expanding variable: ${%.*s}", (int)var_len, cmd + 1); | |
| 123 | 2 | return expand_var(runner, cmd + 1, var_len, buf) + STRLEN("{}"); | |
| 124 | } | ||
| 125 | |||
| 126 | 31 | static size_t parse_var ( | |
| 127 | const CommandRunner *runner, | ||
| 128 | const char *cmd, | ||
| 129 | size_t len, | ||
| 130 | String *buf | ||
| 131 | ) { | ||
| 132 |
1/2✓ Branch 2 → 3 taken 31 times.
✗ Branch 2 → 4 not taken.
|
31 | char ch = len ? cmd[0] : 0; |
| 133 |
2/2✓ Branch 4 → 5 taken 6 times.
✓ Branch 4 → 8 taken 25 times.
|
31 | if (!is_alpha_or_underscore(ch)) { |
| 134 | 6 | bool bracketed = (ch == '{'); | |
| 135 |
2/2✓ Branch 5 → 6 taken 3 times.
✓ Branch 5 → 7 taken 3 times.
|
6 | return bracketed ? parse_bracketed_var(runner, cmd, len, buf) : 0; |
| 136 | } | ||
| 137 | |||
| 138 | 25 | AsciiCharType type_mask = ASCII_ALNUM | ASCII_UNDERSCORE; | |
| 139 | 25 | size_t var_len = ascii_type_prefix_length(cmd, len, type_mask); | |
| 140 | 25 | TRACE_CMD("expanding variable: $%.*s", (int)var_len, cmd); | |
| 141 | 25 | return expand_var(runner, cmd, var_len, buf); | |
| 142 | } | ||
| 143 | |||
| 144 | // Parse a single dterc(5) argument from `cmd`, stopping when an unquoted | ||
| 145 | // whitespace or semicolon character is found or when all `len` bytes have | ||
| 146 | // been processed without encountering such a character. Escape sequences | ||
| 147 | // and $variables are expanded during processing and the fully expanded | ||
| 148 | // result is returned as a malloc'd string. | ||
| 149 | 33215 | char *parse_command_arg(const CommandRunner *runner, const char *cmd, size_t len) | |
| 150 | { | ||
| 151 | 33215 | const StringView *home = runner->home_dir; | |
| 152 | 33215 | bool expand_ts = (runner->flags & CMDRUNNER_EXPAND_TILDE_SLASH); | |
| 153 |
4/4✓ Branch 2 → 3 taken 32307 times.
✓ Branch 2 → 6 taken 908 times.
✓ Branch 4 → 5 taken 3 times.
✓ Branch 4 → 6 taken 32304 times.
|
33215 | bool tilde_slash = expand_ts && len >= 2 && mem_equal(cmd, "~/", 2); |
| 154 | 33215 | String buf = string_new(len + 1 + (tilde_slash ? home->length : 0)); | |
| 155 | 33215 | size_t pos = 0; | |
| 156 | |||
| 157 |
2/2✓ Branch 7 → 8 taken 3 times.
✓ Branch 7 → 21 taken 33212 times.
|
33215 | if (tilde_slash) { |
| 158 | 3 | string_append_strview(&buf, *home); | |
| 159 | 3 | pos += 1; // Skip past '~' and leave '/' to be handled below | |
| 160 | } | ||
| 161 | |||
| 162 |
2/2✓ Branch 24 → 9 taken 182647 times.
✓ Branch 24 → 25 taken 33209 times.
|
215856 | while (pos < len) { |
| 163 | 182647 | char ch = cmd[pos++]; | |
| 164 |
6/6✓ Branch 9 → 10 taken 5 times.
✓ Branch 9 → 11 taken 1645 times.
✓ Branch 9 → 13 taken 677 times.
✓ Branch 9 → 15 taken 31 times.
✓ Branch 9 → 17 taken 239 times.
✓ Branch 9 → 20 taken 180050 times.
|
182647 | switch (ch) { |
| 165 | 5 | case '\t': | |
| 166 | case '\n': | ||
| 167 | case '\r': | ||
| 168 | case ' ': | ||
| 169 | case ';': | ||
| 170 | 5 | goto end; | |
| 171 | 1645 | case '\'': | |
| 172 | 1645 | pos += parse_sq(cmd + pos, len - pos, &buf); | |
| 173 | 1645 | break; | |
| 174 | 677 | case '"': | |
| 175 | 677 | pos += parse_dq(cmd + pos, len - pos, &buf); | |
| 176 | 677 | break; | |
| 177 | 31 | case '$': | |
| 178 | 31 | pos += parse_var(runner, cmd + pos, len - pos, &buf); | |
| 179 | 31 | break; | |
| 180 | 239 | case '\\': | |
| 181 |
2/2✓ Branch 17 → 18 taken 1 time.
✓ Branch 17 → 19 taken 238 times.
|
239 | if (unlikely(pos == len)) { |
| 182 | 1 | goto end; | |
| 183 | } | ||
| 184 | 238 | ch = cmd[pos++]; | |
| 185 | // Fallthrough | ||
| 186 | 180288 | default: | |
| 187 | 180288 | string_append_byte(&buf, ch); | |
| 188 | 180288 | break; | |
| 189 | } | ||
| 190 | } | ||
| 191 | |||
| 192 | 33209 | end: | |
| 193 | 33215 | return string_steal_cstring(&buf); | |
| 194 | } | ||
| 195 | |||
| 196 | 33165 | size_t find_end(const char *cmd, size_t pos, CommandParseError *err) | |
| 197 | { | ||
| 198 | 215820 | while (1) { | |
| 199 |
5/5✓ Branch 5 → 5 taken 180132 times.
✓ Branch 5 → 6 taken 1635 times.
✓ Branch 5 → 11 taken 666 times.
✓ Branch 5 → 20 taken 236 times.
✓ Branch 5 → 23 taken 33151 times.
|
215820 | switch (cmd[pos++]) { |
| 200 | 28383 | case '\'': | |
| 201 | 55131 | while (1) { | |
| 202 |
2/2✓ Branch 6 → 7 taken 1630 times.
✓ Branch 6 → 8 taken 26753 times.
|
28383 | if (cmd[pos] == '\'') { |
| 203 | 1630 | pos++; | |
| 204 | 1630 | break; | |
| 205 | } | ||
| 206 |
2/2✓ Branch 8 → 9 taken 5 times.
✓ Branch 8 → 10 taken 26748 times.
|
26753 | if (unlikely(cmd[pos] == '\0')) { |
| 207 | 5 | *err = CMDERR_UNCLOSED_SQUOTE; | |
| 208 | 5 | return 0; | |
| 209 | } | ||
| 210 | 26748 | pos++; | |
| 211 | } | ||
| 212 | 1630 | break; | |
| 213 | 1323 | case '"': | |
| 214 | 3348 | while (1) { | |
| 215 |
2/2✓ Branch 12 → 13 taken 659 times.
✓ Branch 12 → 14 taken 2689 times.
|
3348 | if (cmd[pos] == '"') { |
| 216 | 659 | pos++; | |
| 217 | 659 | break; | |
| 218 | } | ||
| 219 |
2/2✓ Branch 14 → 15 taken 5 times.
✓ Branch 14 → 16 taken 2684 times.
|
2689 | if (unlikely(cmd[pos] == '\0')) { |
| 220 | 5 | *err = CMDERR_UNCLOSED_DQUOTE; | |
| 221 | 5 | return 0; | |
| 222 | } | ||
| 223 |
2/2✓ Branch 16 → 12 taken 2025 times.
✓ Branch 16 → 17 taken 659 times.
|
2684 | if (cmd[pos++] == '\\') { |
| 224 |
2/2✓ Branch 17 → 18 taken 2 times.
✓ Branch 17 → 19 taken 657 times.
|
659 | if (unlikely(cmd[pos] == '\0')) { |
| 225 | 2 | *err = CMDERR_UNEXPECTED_EOF; | |
| 226 | 2 | return 0; | |
| 227 | } | ||
| 228 | 657 | pos++; | |
| 229 | } | ||
| 230 | } | ||
| 231 | 659 | break; | |
| 232 | 236 | case '\\': | |
| 233 |
2/2✓ Branch 20 → 21 taken 2 times.
✓ Branch 20 → 22 taken 234 times.
|
236 | if (unlikely(cmd[pos] == '\0')) { |
| 234 | 2 | *err = CMDERR_UNEXPECTED_EOF; | |
| 235 | 2 | return 0; | |
| 236 | } | ||
| 237 | 234 | pos++; | |
| 238 | 234 | break; | |
| 239 | 33151 | case '\0': | |
| 240 | case '\t': | ||
| 241 | case '\n': | ||
| 242 | case '\r': | ||
| 243 | case ' ': | ||
| 244 | case ';': | ||
| 245 | 33151 | *err = CMDERR_NONE; | |
| 246 | 33151 | return pos - 1; | |
| 247 | } | ||
| 248 | } | ||
| 249 | |||
| 250 | BUG("Unexpected break of outer loop"); | ||
| 251 | } | ||
| 252 | |||
| 253 | // Note: `array` must be freed, regardless of the return value | ||
| 254 | 12025 | CommandParseError parse_commands ( | |
| 255 | const CommandRunner *runner, | ||
| 256 | PointerArray *array, | ||
| 257 | const char *cmd | ||
| 258 | ) { | ||
| 259 | 12025 | for (size_t pos = 0; true; ) { | |
| 260 |
2/2✓ Branch 5 → 3 taken 22419 times.
✓ Branch 5 → 6 taken 45058 times.
|
67477 | while (ascii_isspace(cmd[pos])) { |
| 261 | 22419 | pos++; | |
| 262 | } | ||
| 263 | |||
| 264 |
2/2✓ Branch 6 → 7 taken 33047 times.
✓ Branch 6 → 16 taken 12011 times.
|
45058 | if (cmd[pos] == '\0') { |
| 265 | break; | ||
| 266 | } | ||
| 267 | |||
| 268 |
2/2✓ Branch 7 → 8 taken 105 times.
✓ Branch 7 → 10 taken 32942 times.
|
33047 | if (cmd[pos] == ';') { |
| 269 | 105 | ptr_array_append(array, NULL); | |
| 270 | 105 | pos++; | |
| 271 | 105 | continue; | |
| 272 | } | ||
| 273 | |||
| 274 | 32942 | CommandParseError err; | |
| 275 | 32942 | size_t end = find_end(cmd, pos, &err); | |
| 276 |
2/2✓ Branch 11 → 12 taken 14 times.
✓ Branch 11 → 13 taken 32928 times.
|
32942 | if (err != CMDERR_NONE) { |
| 277 | 14 | return err; | |
| 278 | } | ||
| 279 | |||
| 280 | 32928 | ptr_array_append(array, parse_command_arg(runner, cmd + pos, end - pos)); | |
| 281 | 32928 | pos = end; | |
| 282 | } | ||
| 283 | |||
| 284 | 12011 | ptr_array_append(array, NULL); | |
| 285 | 12011 | return CMDERR_NONE; | |
| 286 | } | ||
| 287 | |||
| 288 | 6 | const char *command_parse_error_to_string(CommandParseError err) | |
| 289 | { | ||
| 290 | 6 | static const char error_strings[][16] = { | |
| 291 | [CMDERR_UNCLOSED_SQUOTE] = "unclosed '", | ||
| 292 | [CMDERR_UNCLOSED_DQUOTE] = "unclosed \"", | ||
| 293 | [CMDERR_UNEXPECTED_EOF] = "unexpected EOF", | ||
| 294 | }; | ||
| 295 | |||
| 296 | 6 | BUG_ON(err <= CMDERR_NONE); | |
| 297 | 6 | BUG_ON(err >= ARRAYLEN(error_strings)); | |
| 298 | 6 | return error_strings[err]; | |
| 299 | } | ||
| 300 |