xonecas.io
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}