7814
Ta
tiny-c-agent / files
tiny-c-agent / src / tui / term.c
17.8 KB
1#include "term.h" 2 3#include <stdlib.h> 4#include <string.h> 5 6#include "util.h" 7 8// ---- UTF-8 ----------------------------------------------------------------- 9 10int tiny_utf8_decode(const char *s, size_t len, uint32_t *cp) { 11 if (len == 0) { 12 *cp = 0; 13 return 0; 14 } 15 unsigned char c = (unsigned char)s[0]; 16 if (c < 0x80) { 17 *cp = c; 18 return 1; 19 } 20 int n; 21 uint32_t v; 22 if ((c & 0xe0) == 0xc0) { 23 n = 2; 24 v = c & 0x1f; 25 } else if ((c & 0xf0) == 0xe0) { 26 n = 3; 27 v = c & 0x0f; 28 } else if ((c & 0xf8) == 0xf0) { 29 n = 4; 30 v = c & 0x07; 31 } else { 32 *cp = c; 33 return 1; 34 } 35 if ((size_t)n > len) { 36 *cp = c; 37 return 1; 38 } 39 for (int i = 1; i < n; i++) { 40 unsigned char cc = (unsigned char)s[i]; 41 if ((cc & 0xc0) != 0x80) { 42 *cp = c; 43 return 1; 44 } 45 v = (v << 6) | (cc & 0x3f); 46 } 47 *cp = v; 48 return n; 49} 50 51int tiny_utf8_encode(uint32_t cp, char out[4]) { 52 if (cp < 0x80) { 53 out[0] = (char)cp; 54 return 1; 55 } 56 if (cp < 0x800) { 57 out[0] = (char)(0xc0 | (cp >> 6)); 58 out[1] = (char)(0x80 | (cp & 0x3f)); 59 return 2; 60 } 61 if (cp < 0x10000) { 62 out[0] = (char)(0xe0 | (cp >> 12)); 63 out[1] = (char)(0x80 | ((cp >> 6) & 0x3f)); 64 out[2] = (char)(0x80 | (cp & 0x3f)); 65 return 3; 66 } 67 out[0] = (char)(0xf0 | (cp >> 18)); 68 out[1] = (char)(0x80 | ((cp >> 12) & 0x3f)); 69 out[2] = (char)(0x80 | ((cp >> 6) & 0x3f)); 70 out[3] = (char)(0x80 | (cp & 0x3f)); 71 return 4; 72} 73 74static bool is_combining(uint32_t cp) { 75 return (cp >= 0x0300 && cp <= 0x036f) || (cp >= 0x1ab0 && cp <= 0x1aff) || 76 (cp >= 0x1dc0 && cp <= 0x1dff) || (cp >= 0x20d0 && cp <= 0x20ff) || 77 (cp >= 0xfe20 && cp <= 0xfe2f); 78} 79 80int tiny_char_width(uint32_t cp) { 81 if (cp < 32 || (cp >= 0x7f && cp < 0xa0)) return 0; 82 if (cp == 0x200b || cp == 0x200c || cp == 0x200d || cp == 0xfeff) return 0; 83 if (cp >= 0xfe00 && cp <= 0xfe0f) return 0; 84 if (cp >= 0xe0100 && cp <= 0xe01ef) return 0; 85 if (is_combining(cp)) return 0; 86 if ((cp >= 0x1100 && cp <= 0x115f) || (cp >= 0x2e80 && cp <= 0x303e) || 87 (cp >= 0x3041 && cp <= 0x33ff) || (cp >= 0x3400 && cp <= 0x4dbf) || 88 (cp >= 0x4e00 && cp <= 0x9fff) || (cp >= 0xa000 && cp <= 0xa4cf) || 89 (cp >= 0xac00 && cp <= 0xd7a3) || (cp >= 0xf900 && cp <= 0xfaff) || 90 (cp >= 0xfe10 && cp <= 0xfe19) || (cp >= 0xfe30 && cp <= 0xfe6f) || 91 (cp >= 0xff00 && cp <= 0xff60) || (cp >= 0xffe0 && cp <= 0xffe6) || 92 (cp >= 0x1f300 && cp <= 0x1faff) || (cp >= 0x20000 && cp <= 0x3fffd)) { 93 return 2; 94 } 95 return 1; 96} 97 98int tiny_display_width(const char *text) { 99 int width = 0; 100 size_t len = strlen(text); 101 for (size_t i = 0; i < len;) { 102 uint32_t cp; 103 int n = tiny_utf8_decode(text + i, len - i, &cp); 104 if (n <= 0) break; 105 width += tiny_char_width(cp); 106 i += (size_t)n; 107 } 108 return width; 109} 110 111// ---- sanitize and tab expansion ------------------------------------------- 112 113// SGR: `ESC [ [0-9;]* m`, zero cells wide. 114static bool is_sgr(const char *s, size_t len, size_t *seq_len) { 115 if (len < 3 || s[0] != '\x1b' || s[1] != '[') return false; 116 size_t i = 2; 117 while (i < len && ((s[i] >= '0' && s[i] <= '9') || s[i] == ';')) i++; 118 if (i < len && s[i] == 'm') { 119 *seq_len = i + 1; 120 return true; 121 } 122 return false; 123} 124 125char *tiny_sanitize(const char *text) { 126 tui_buf out; 127 buf_init(&out); 128 size_t len = strlen(text); 129 for (size_t i = 0; i < len;) { 130 unsigned char c = (unsigned char)text[i]; 131 if (c == 0x1b) { 132 size_t sgr; 133 if (is_sgr(text + i, len - i, &sgr)) { 134 buf_add(&out, text + i, sgr); 135 i += sgr; 136 continue; 137 } 138 // A non-SGR escape: drop the whole sequence. CSI runs to its final 139 // byte; every other escape consumes one following byte. 140 if (i + 1 < len && text[i + 1] == '[') { 141 size_t j = i + 2; 142 while (j < len && !(text[j] >= 0x40 && text[j] <= 0x7e)) j++; 143 i = j < len ? j + 1 : len; 144 } else { 145 i += (i + 1 < len) ? 2 : 1; 146 } 147 continue; 148 } 149 if (c < 0x20 || c == 0x7f || (c >= 0x80 && c < 0xa0)) { 150 i++; 151 continue; 152 } 153 uint32_t cp; 154 int n = tiny_utf8_decode(text + i, len - i, &cp); 155 if (n <= 0) break; 156 buf_add(&out, text + i, (size_t)n); 157 i += (size_t)n; 158 } 159 if (!out.data) return strdup(""); 160 return buf_steal(&out); 161} 162 163char *tiny_expand_tabs(const char *text, int size) { 164 if (!strchr(text, '\t')) return strdup(text); 165 tui_buf out; 166 buf_init(&out); 167 size_t len = strlen(text); 168 int column = 0; 169 for (size_t i = 0; i < len;) { 170 size_t sgr; 171 if (is_sgr(text + i, len - i, &sgr)) { 172 buf_add(&out, text + i, sgr); 173 i += sgr; 174 continue; 175 } 176 uint32_t cp; 177 int n = tiny_utf8_decode(text + i, len - i, &cp); 178 if (n <= 0) break; 179 if (cp == '\t') { 180 int spaces = size - (column % size); 181 for (int k = 0; k < spaces; k++) buf_addc(&out, ' '); 182 column += spaces; 183 } else { 184 buf_add(&out, text + i, (size_t)n); 185 column += tiny_char_width(cp); 186 } 187 i += (size_t)n; 188 } 189 if (!out.data) return strdup(""); 190 return buf_steal(&out); 191} 192 193tiny_strv tiny_wrap_line(const char *text, int width) { 194 tiny_strv rows = {0}; 195 tui_buf cur; 196 buf_init(&cur); 197 int used = 0; 198 if (width <= 0 || text[0] == '\0') { 199 strv_push(&rows, strdup("")); 200 return rows; 201 } 202 size_t len = strlen(text); 203 for (size_t i = 0; i < len;) { 204 if (text[i] == '\x1b') { 205 size_t sgr; 206 if (is_sgr(text + i, len - i, &sgr)) { 207 buf_add(&cur, text + i, sgr); 208 i += sgr; 209 continue; 210 } 211 } 212 uint32_t cp; 213 int nb = tiny_utf8_decode(text + i, len - i, &cp); 214 if (nb <= 0) break; 215 int w = tiny_char_width(cp); 216 if (used + w > width && cur.len > 0) { 217 strv_push(&rows, buf_steal(&cur)); 218 buf_init(&cur); 219 used = 0; 220 } 221 buf_add(&cur, text + i, (size_t)nb); 222 used += w; 223 i += (size_t)nb; 224 } 225 strv_push(&rows, buf_steal(&cur)); 226 return rows; 227} 228 229// ---- key decoding ---------------------------------------------------------- 230 231#define PASTE_START "\x1b[200~" 232#define PASTE_END "\x1b[201~" 233 234#define SHIFT 1 235#define ALT 2 236#define CTRL 4 237#define MODS (SHIFT | ALT | CTRL) 238 239enum { 240 K_ENTER = 13, 241 K_ESCAPE = 27, 242 K_TAB = 9, 243 K_BACKSPACE = 127, 244 K_DELETE = 57349, 245 K_LEFT = 57350, 246 K_RIGHT = 57351, 247 K_UP = 57352, 248 K_DOWN = 57353, 249 K_HOME = 57356, 250 K_END = 57357, 251}; 252 253// Returns the key type for a code/modifier pair, or -1 when unmapped. 254static int key_for(long code, int mods) { 255 if (code == K_ENTER) return (mods == ALT || mods == SHIFT) ? TINY_KEY_NEWLINE : (mods == 0 ? TINY_KEY_SUBMIT : -1); 256 if (code == K_ESCAPE) return mods == 0 ? TINY_KEY_ESCAPE : -1; 257 if (code == K_TAB) return mods == 0 ? TINY_KEY_TAB : -1; 258 if (code == K_BACKSPACE) return mods == CTRL ? TINY_KEY_WORD_BACK : (mods == 0 ? TINY_KEY_BACKSPACE : -1); 259 if (code == K_DELETE) return mods == 0 ? TINY_KEY_DELETE : -1; 260 if (code == K_LEFT) return mods == CTRL ? TINY_KEY_WORD_LEFT : (mods == 0 ? TINY_KEY_LEFT : -1); 261 if (code == K_RIGHT) return mods == CTRL ? TINY_KEY_WORD_RIGHT : (mods == 0 ? TINY_KEY_RIGHT : -1); 262 if (code == K_UP) return mods == 0 ? TINY_KEY_UP : -1; 263 if (code == K_DOWN) return mods == 0 ? TINY_KEY_DOWN : -1; 264 if (code == K_HOME) return mods == CTRL ? TINY_KEY_DOC_START : (mods == 0 ? TINY_KEY_HOME : -1); 265 if (code == K_END) return mods == CTRL ? TINY_KEY_DOC_END : (mods == 0 ? TINY_KEY_END : -1); 266 if (code == 97 && mods == CTRL) return TINY_KEY_HOME; // Ctrl+A 267 if (code == 98 && mods == ALT) return TINY_KEY_WORD_BACK; // Alt+B 268 if (code == 99 && mods == CTRL) return TINY_KEY_INTERRUPT; // Ctrl+C 269 if (code == 100 && mods == CTRL) return TINY_KEY_EOF; // Ctrl+D 270 if (code == 101 && mods == CTRL) return TINY_KEY_END; // Ctrl+E 271 if (code == 106 && mods == CTRL) return TINY_KEY_NEWLINE; // Ctrl+J 272 if (code == 119 && mods == CTRL) return TINY_KEY_WORD_BACK; // Ctrl+W 273 return -1; 274} 275 276struct tiny_key_parser { 277 char *buf; 278 size_t len; 279 size_t cap; 280 bool pasting; 281}; 282 283tiny_key_parser *tiny_key_parser_new(void) { 284 tiny_key_parser *p = calloc(1, sizeof *p); 285 if (!p) abort(); 286 return p; 287} 288 289void tiny_key_parser_free(tiny_key_parser *p) { 290 if (!p) return; 291 free(p->buf); 292 free(p); 293} 294 295static void pb_append(tiny_key_parser *p, const char *bytes, size_t n) { 296 if (p->len + n + 1 > p->cap) { 297 size_t cap = p->cap ? p->cap : 64; 298 while (cap < p->len + n + 1) cap *= 2; 299 p->buf = realloc(p->buf, cap); 300 if (!p->buf) abort(); 301 p->cap = cap; 302 } 303 memcpy(p->buf + p->len, bytes, n); 304 p->len += n; 305 p->buf[p->len] = '\0'; 306} 307 308static void pb_drop(tiny_key_parser *p, size_t n) { 309 if (n >= p->len) { 310 p->len = 0; 311 if (p->buf) p->buf[0] = '\0'; 312 return; 313 } 314 memmove(p->buf, p->buf + n, p->len - n); 315 p->len -= n; 316 p->buf[p->len] = '\0'; 317} 318 319static void emit_type(tiny_key_fn emit, void *user, tiny_key_type t) { 320 tiny_key k = {.type = t, .text = NULL}; 321 emit(&k, user); 322} 323 324static void emit_text(tiny_key_fn emit, void *user, const char *text) { 325 tiny_key k = {.type = TINY_KEY_TEXT, .text = (char *)text}; 326 emit(&k, user); 327} 328 329// Normalizes CRLF and CR to LF, returning a malloc'd copy. 330static char *normalize_paste(const char *text, size_t n) { 331 tui_buf out; 332 buf_init(&out); 333 for (size_t i = 0; i < n; i++) { 334 if (text[i] == '\r') { 335 buf_addc(&out, '\n'); 336 if (i + 1 < n && text[i + 1] == '\n') i++; 337 } else { 338 buf_addc(&out, text[i]); 339 } 340 } 341 if (!out.data) return strdup(""); 342 return buf_steal(&out); 343} 344 345static int mods_of(const char *field, size_t n) { 346 if (n == 0) return 0; 347 long raw = strtol(field, NULL, 10); 348 return raw > 0 ? (int)((raw - 1) & MODS) : 0; 349} 350 351static void parse_escape(tiny_key_parser *p, tiny_key_fn emit, void *user, bool *progress); 352 353// `params final`: the legacy `CSI 1;5D` form and SS3's bare `A`. 354static int legacy_chord(char final, const char *params, size_t plen, long *code, int *mods) { 355 // Split params on ';': first field selects the key for `~`, second is mods. 356 char first[16] = {0}; 357 char second[16] = {0}; 358 size_t fi = 0, si = 0; 359 size_t i = 0; 360 for (; i < plen && params[i] != ';'; i++) 361 if (fi < sizeof first - 1) first[fi++] = params[i]; 362 if (i < plen) { 363 i++; 364 for (; i < plen; i++) 365 if (si < sizeof second - 1) second[si++] = params[i]; 366 } 367 if (final == '~') { 368 long n = strtol(first, NULL, 10); 369 long c = -1; 370 if (n == 1 || n == 7) c = K_HOME; 371 else if (n == 3) c = K_DELETE; 372 else if (n == 4 || n == 8) c = K_END; 373 if (c < 0) return -1; 374 *code = c; 375 } else { 376 switch (final) { 377 case 'A': *code = K_UP; break; 378 case 'B': *code = K_DOWN; break; 379 case 'C': *code = K_RIGHT; break; 380 case 'D': *code = K_LEFT; break; 381 case 'H': *code = K_HOME; break; 382 case 'F': *code = K_END; break; 383 default: return -1; 384 } 385 } 386 *mods = mods_of(second, strlen(second)); 387 return 0; 388} 389 390// `code[:shifted[:base]];mods[:event];text` 391static int csi_u_chord(const char *params, size_t plen, long *code, int *mods) { 392 char first[24] = {0}; 393 char second[24] = {0}; 394 size_t fi = 0, si = 0, i = 0; 395 for (; i < plen; i++) { 396 if (params[i] == ':' || params[i] == ';') break; 397 if (fi < sizeof first - 1) first[fi++] = params[i]; 398 } 399 while (i < plen && params[i] != ';') i++; 400 if (i < plen) { 401 i++; 402 for (; i < plen; i++) { 403 if (params[i] == ':' || params[i] == ';') break; 404 if (si < sizeof second - 1) second[si++] = params[i]; 405 } 406 } 407 if (fi == 0) return -1; 408 long c = strtol(first, NULL, 10); 409 if (c >= 57344) return -1; // functional keys never arrive as CSI-u 410 *code = c; 411 *mods = mods_of(second, strlen(second)); 412 return 0; 413} 414 415// OSC ends at BEL or ST; DCS/APC/PM/SOS end at ST. Skipped whole. 416static bool skip_string(tiny_key_parser *p, bool bel) { 417 size_t st = SIZE_MAX, bell = SIZE_MAX; 418 for (size_t i = 2; i + 1 < p->len; i++) 419 if (p->buf[i] == '\x1b' && p->buf[i + 1] == '\\') { 420 st = i; 421 break; 422 } 423 if (bel) { 424 for (size_t i = 2; i < p->len; i++) 425 if (p->buf[i] == '\x07') { 426 bell = i; 427 break; 428 } 429 } 430 size_t end; 431 if (bell != SIZE_MAX && (st == SIZE_MAX || bell < st)) end = bell + 1; 432 else if (st != SIZE_MAX) end = st + 2; 433 else return false; 434 pb_drop(p, end); 435 return true; 436} 437 438static bool parse_csi(tiny_key_parser *p, tiny_key_fn emit, void *user) { 439 size_t i = 2; 440 while (i < p->len) { 441 unsigned char c = (unsigned char)p->buf[i]; 442 if (c >= 0x40 && c <= 0x7e) break; 443 i++; 444 } 445 if (i >= p->len) return false; 446 char final = p->buf[i]; 447 char params[256]; 448 size_t plen = i - 2; 449 if (plen >= sizeof params) plen = sizeof params - 1; 450 memcpy(params, p->buf + 2, plen); 451 params[plen] = '\0'; 452 pb_drop(p, i + 1); 453 long code = -1; 454 int mods = 0; 455 int rc = final == 'u' ? csi_u_chord(params, plen, &code, &mods) 456 : legacy_chord(final, params, plen, &code, &mods); 457 if (rc == 0) { 458 int type = key_for(code, mods); 459 if (type >= 0) emit_type(emit, user, (tiny_key_type)type); 460 } 461 return true; 462} 463 464static void parse_escape(tiny_key_parser *p, tiny_key_fn emit, void *user, bool *progress) { 465 *progress = false; 466 if (p->len < 2) return; 467 char next = p->buf[1]; 468 if (next == '[' || next == 'O') { 469 *progress = parse_csi(p, emit, user); 470 return; 471 } 472 if (next == ']') { 473 *progress = skip_string(p, true); 474 return; 475 } 476 if (next == 'P' || next == 'X' || next == '^' || next == '_') { 477 *progress = skip_string(p, false); 478 return; 479 } 480 pb_drop(p, 2); 481 uint32_t cp; 482 tiny_utf8_decode(&next, 1, &cp); 483 int type = key_for(cp, ALT); 484 if (type >= 0) emit_type(emit, user, (tiny_key_type)type); 485 *progress = true; 486} 487 488static void map_point(uint32_t cp, tiny_key_fn emit, void *user) { 489 if (cp == 0x7f) { 490 int t = key_for(K_BACKSPACE, 0); 491 if (t >= 0) emit_type(emit, user, (tiny_key_type)t); 492 return; 493 } 494 if (cp < 0x20) { 495 if (cp == 0x08) { 496 int t = key_for(K_BACKSPACE, 0); 497 if (t >= 0) emit_type(emit, user, (tiny_key_type)t); 498 } else if (cp == 0x09) { 499 int t = key_for(K_TAB, 0); 500 if (t >= 0) emit_type(emit, user, (tiny_key_type)t); 501 } else if (cp == 0x0d) { 502 int t = key_for(K_ENTER, 0); 503 if (t >= 0) emit_type(emit, user, (tiny_key_type)t); 504 } else { 505 int t = key_for((long)cp + 0x60, CTRL); 506 if (t >= 0) emit_type(emit, user, (tiny_key_type)t); 507 } 508 return; 509 } 510 char out[4]; 511 int n = tiny_utf8_encode(cp, out); 512 char *text = malloc((size_t)n + 1); 513 if (!text) abort(); 514 memcpy(text, out, (size_t)n); 515 text[n] = '\0'; 516 emit_text(emit, user, text); 517 free(text); 518} 519 520void tiny_key_parser_feed(tiny_key_parser *p, const char *bytes, size_t n, 521 tiny_key_fn emit, void *user) { 522 pb_append(p, bytes, n); 523 for (;;) { 524 if (p->pasting) { 525 // Search for the paste end marker. 526 size_t end = SIZE_MAX; 527 size_t elen = strlen(PASTE_END); 528 for (size_t i = 0; i + elen <= p->len; i++) 529 if (memcmp(p->buf + i, PASTE_END, elen) == 0) { 530 end = i; 531 break; 532 } 533 if (end != SIZE_MAX) { 534 if (end > 0) { 535 char *text = normalize_paste(p->buf, end); 536 emit_text(emit, user, text); 537 free(text); 538 } 539 pb_drop(p, end + elen); 540 p->pasting = false; 541 continue; 542 } 543 if (p->len > elen) { 544 size_t keep = elen - 1; 545 size_t take = p->len - keep; 546 char *text = normalize_paste(p->buf, take); 547 if (text[0]) emit_text(emit, user, text); 548 free(text); 549 pb_drop(p, take); 550 } 551 break; 552 } 553 554 if (p->len == 0) break; 555 size_t slen = strlen(PASTE_START); 556 if (p->len >= slen && memcmp(p->buf, PASTE_START, slen) == 0) { 557 pb_drop(p, slen); 558 p->pasting = true; 559 continue; 560 } 561 if (p->buf[0] == '\x1b') { 562 bool progress; 563 parse_escape(p, emit, user, &progress); 564 if (!progress) break; 565 continue; 566 } 567 uint32_t cp; 568 int nb = tiny_utf8_decode(p->buf, p->len, &cp); 569 if (nb <= 0) break; 570 pb_drop(p, (size_t)nb); 571 map_point(cp, emit, user); 572 } 573} 574 575int tiny_key_parser_pending(tiny_key_parser *p) { 576 if (p->pasting) return 0; 577 if (p->len == 1 && p->buf[0] == '\x1b') return 1; 578 return p->len > 1 ? 2 : 0; 579} 580 581void tiny_key_parser_flush_escape(tiny_key_parser *p, tiny_key_fn emit, void *user) { 582 if (!(p->len == 1 && p->buf[0] == '\x1b')) return; 583 pb_drop(p, 1); 584 emit_type(emit, user, TINY_KEY_ESCAPE); 585} 586 587void tiny_key_parser_flush_sequence(tiny_key_parser *p) { 588 pb_drop(p, p->len); 589}