xonecas.io
7814
Ta

tiny-c-agent / files

tiny-c-agent / src / tui / editor.c

14.9 KB
1#include "editor.h"
2
3#include <stdlib.h>
4#include <string.h>
5
6#include "util.h"
7
8#define TAB 4
9
10struct tiny_editor {
11    char **lines;
12    size_t nlines;
13    size_t row;
14    size_t col;     // code point index within the row
15    int scroll;
16    int width;
17    char *text;     // cached join, valid until the next change
18    bool text_dirty;
19};
20
21static size_t cp_count(const char *s) {
22    size_t n = 0, len = strlen(s);
23    for (size_t i = 0; i < len;) {
24        uint32_t cp;
25        int b = tiny_utf8_decode(s + i, len - i, &cp);
26        if (b <= 0) break;
27        i += (size_t)b;
28        n++;
29    }
30    return n;
31}
32
33// Byte offset of code point index `idx`, clamped to the end.
34static size_t cp_off(const char *s, size_t idx) {
35    size_t i = 0, n = 0, len = strlen(s);
36    while (n < idx && i < len) {
37        uint32_t cp;
38        int b = tiny_utf8_decode(s + i, len - i, &cp);
39        if (b <= 0) break;
40        i += (size_t)b;
41        n++;
42    }
43    return i;
44}
45
46// The code points [a, b) as a new string.
47static char *cp_slice(const char *s, size_t a, size_t b) {
48    size_t start = cp_off(s, a);
49    size_t end = cp_off(s, b);
50    size_t n = end > start ? end - start : 0;
51    char *out = xmalloc(n + 1);
52    memcpy(out, s + start, n);
53    out[n] = '\0';
54    return out;
55}
56
57static bool cp_is_space(uint32_t cp) {
58    return cp == ' ' || cp == '\t' || cp == '\n' || cp == '\r' || cp == '\v' || cp == '\f';
59}
60
61// Decodes `s` into a malloc'd array of code points; *n receives the count.
62static uint32_t *cps_of(const char *s, size_t *n_out) {
63    size_t len = strlen(s), cap = 8, n = 0;
64    uint32_t *cps = xmalloc(cap * sizeof *cps);
65    for (size_t i = 0; i < len;) {
66        uint32_t cp;
67        int b = tiny_utf8_decode(s + i, len - i, &cp);
68        if (b <= 0) break;
69        if (n == cap) {
70            cap *= 2;
71            cps = xrealloc(cps, cap * sizeof *cps);
72        }
73        cps[n++] = cp;
74        i += (size_t)b;
75    }
76    *n_out = n;
77    return cps;
78}
79
80// First code point index of the word before `col`.
81static size_t word_start(const char *s, size_t col) {
82    size_t n;
83    uint32_t *cps = cps_of(s, &n);
84    size_t i = col;
85    while (i > 0 && cp_is_space(cps[i - 1])) i--;
86    while (i > 0 && !cp_is_space(cps[i - 1])) i--;
87    free(cps);
88    return i;
89}
90
91// One past the word at or after `col`.
92static size_t word_end(const char *s, size_t col) {
93    size_t n;
94    uint32_t *cps = cps_of(s, &n);
95    size_t i = col;
96    while (i < n && cp_is_space(cps[i])) i++;
97    while (i < n && !cp_is_space(cps[i])) i++;
98    free(cps);
99    return i;
100}
101
102tiny_editor *tiny_editor_new(void) {
103    tiny_editor *e = calloc(1, sizeof *e);
104    if (!e) abort();
105    e->nlines = 1;
106    e->lines = xmalloc(sizeof *e->lines);
107    e->lines[0] = xstrdup("");
108    e->width = 80;
109    e->text_dirty = true;
110    return e;
111}
112
113void tiny_editor_free(tiny_editor *e) {
114    if (!e) return;
115    for (size_t i = 0; i < e->nlines; i++) free(e->lines[i]);
116    free(e->lines);
117    free(e->text);
118    free(e);
119}
120
121const char *tiny_editor_text(tiny_editor *e) {
122    if (!e->text_dirty) return e->text;
123    tui_buf b;
124    buf_init(&b);
125    for (size_t i = 0; i < e->nlines; i++) {
126        if (i) buf_addc(&b, '\n');
127        buf_adds(&b, e->lines[i]);
128    }
129    free(e->text);
130    e->text = buf_steal(&b);
131    e->text_dirty = false;
132    return e->text;
133}
134
135void tiny_editor_clear(tiny_editor *e) {
136    for (size_t i = 0; i < e->nlines; i++) free(e->lines[i]);
137    e->nlines = 1;
138    e->lines = realloc(e->lines, sizeof *e->lines);
139    e->lines[0] = xstrdup("");
140    e->row = 0;
141    e->col = 0;
142    e->scroll = 0;
143    e->text_dirty = true;
144}
145
146void tiny_editor_set_text(tiny_editor *e, const char *text) {
147    for (size_t i = 0; i < e->nlines; i++) free(e->lines[i]);
148    tiny_strv lines = tiny_split_lines(text);
149    free(e->lines);
150    e->lines = lines.v;
151    e->nlines = lines.n;
152    e->row = lines.n - 1;
153    e->col = cp_count(e->lines[e->row]);
154    e->scroll = 0;
155    e->text_dirty = true;
156}
157
158// Display column of every code point boundary in `line`, tabs expanded.
159static int *cells_of(const char *line, size_t *n_out) {
160    size_t len = strlen(line);
161    size_t cap = 16, n = 0;
162    int *out = xmalloc(cap * sizeof *out);
163    out[n++] = 0;
164    int col = 0;
165    for (size_t i = 0; i < len;) {
166        uint32_t cp;
167        int b = tiny_utf8_decode(line + i, len - i, &cp);
168        if (b <= 0) break;
169        if (cp == '\t') col += TAB - (col % TAB);
170        else col += tiny_char_width(cp);
171        if (n == cap) {
172            cap *= 2;
173            out = realloc(out, cap * sizeof *out);
174            if (!out) abort();
175        }
176        out[n++] = col;
177        i += (size_t)b;
178    }
179    *n_out = n;
180    return out;
181}
182
183// The caret column nearest `cell`, never past the end of the line.
184static size_t col_at_cell(const char *line, int cell) {
185    size_t n;
186    int *cells = cells_of(line, &n);
187    size_t i = n - 1;
188    while (i > 0 && cells[i] > cell) i--;
189    free(cells);
190    return i;
191}
192
193static void caret(tiny_editor *e, int *row_out, int *col_out) {
194    char *line = xstrdup(e->lines[e->row]);
195    char *expanded = tiny_expand_tabs(line, TAB);
196    tiny_strv chunks = tiny_wrap_line(expanded, e->width);
197    size_t ncells;
198    int *cells = cells_of(line, &ncells);
199    int cell = cells[e->col < ncells ? e->col : ncells - 1];
200    free(cells);
201    int row = cell / e->width;
202    if (row >= (int)chunks.n) {
203        *row_out = (int)chunks.n - 1;
204        *col_out = tiny_display_width(chunks.v[chunks.n - 1]);
205    } else {
206        *row_out = row;
207        *col_out = cell - row * e->width;
208    }
209    strv_free(&chunks);
210    free(expanded);
211    free(line);
212}
213
214// Replaces the code points [start, end) of a line with `insert`. A copy of
215// `line` is passed because the caller may hold it.
216static void line_splice(tiny_editor *e, const char *line, size_t start, size_t end, const char *insert) {
217    char *before = cp_slice(line, 0, start);
218    char *after = cp_slice(line, end, cp_count(line));
219    tui_buf b;
220    buf_init(&b);
221    buf_adds(&b, before);
222    buf_adds(&b, insert);
223    buf_adds(&b, after);
224    free(before);
225    free(after);
226    free(e->lines[e->row]);
227    e->lines[e->row] = buf_steal(&b);
228    e->text_dirty = true;
229}
230
231static void insert_text(tiny_editor *e, const char *text) {
232    if (!strchr(text, '\n')) {
233        line_splice(e, e->lines[e->row], e->col, e->col, text);
234        e->col += cp_count(text);
235        return;
236    }
237
238    char *line = e->lines[e->row];
239    char *before = cp_slice(line, 0, e->col);
240    char *after = cp_slice(line, e->col, cp_count(line));
241
242    // Build the replacement lines.
243    tiny_strv parts = tiny_split_lines(text);
244    size_t n = parts.n;
245
246    tui_buf head;
247    buf_init(&head);
248    buf_adds(&head, before);
249    buf_adds(&head, parts.v[0]);
250    tui_buf tail;
251    buf_init(&tail);
252    buf_adds(&tail, parts.v[n - 1]);
253    buf_adds(&tail, after);
254    size_t caret_col = cp_count(parts.v[n - 1]);
255    free(parts.v[0]);
256    free(parts.v[n - 1]);
257
258    // New line array: [0, row) + head + middle parts + tail + (row, end).
259    char **nl = xmalloc((e->nlines + 1) * sizeof *nl);
260    size_t k = 0;
261    for (size_t i = 0; i < e->row; i++) nl[k++] = e->lines[i];
262    nl[k++] = buf_steal(&head);
263    for (size_t i = 1; i + 1 < n; i++) nl[k++] = parts.v[i];
264    nl[k++] = buf_steal(&tail);
265    for (size_t i = e->row + 1; i < e->nlines; i++) nl[k++] = e->lines[i];
266    free(line);
267    free(e->lines);
268    e->lines = nl;
269    e->nlines = k;
270    e->row += n - 1;
271    e->col = caret_col;
272    free(parts.v);
273    free(before);
274    free(after);
275    e->text_dirty = true;
276}
277
278static void backspace(tiny_editor *e) {
279    if (e->col > 0) {
280        line_splice(e, e->lines[e->row], e->col - 1, e->col, "");
281        e->col--;
282        return;
283    }
284    if (e->row > 0) {
285        size_t prev = cp_count(e->lines[e->row - 1]);
286        tui_buf b;
287        buf_init(&b);
288        buf_adds(&b, e->lines[e->row - 1]);
289        buf_adds(&b, e->lines[e->row]);
290        free(e->lines[e->row - 1]);
291        e->lines[e->row - 1] = buf_steal(&b);
292        free(e->lines[e->row]);
293        for (size_t i = e->row; i + 1 < e->nlines; i++) e->lines[i] = e->lines[i + 1];
294        e->nlines--;
295        e->row--;
296        e->col = prev;
297        e->text_dirty = true;
298    }
299}
300
301static void delete_forward(tiny_editor *e) {
302    size_t n = cp_count(e->lines[e->row]);
303    if (e->col < n) {
304        line_splice(e, e->lines[e->row], e->col, e->col + 1, "");
305        return;
306    }
307    if (e->row + 1 < e->nlines) {
308        tui_buf b;
309        buf_init(&b);
310        buf_adds(&b, e->lines[e->row]);
311        buf_adds(&b, e->lines[e->row + 1]);
312        free(e->lines[e->row]);
313        e->lines[e->row] = buf_steal(&b);
314        free(e->lines[e->row + 1]);
315        for (size_t i = e->row + 1; i + 1 < e->nlines; i++) e->lines[i] = e->lines[i + 1];
316        e->nlines--;
317        e->text_dirty = true;
318    }
319}
320
321tiny_edit_result tiny_editor_handle(tiny_editor *e, const tiny_key *key) {
322    switch (key->type) {
323    case TINY_KEY_SUBMIT:
324        return TINY_EDIT_SUBMIT;
325    case TINY_KEY_NEWLINE:
326        insert_text(e, "\n");
327        return TINY_EDIT_CHANGED;
328    case TINY_KEY_TEXT:
329        insert_text(e, key->text ? key->text : "");
330        return TINY_EDIT_CHANGED;
331    case TINY_KEY_BACKSPACE:
332        backspace(e);
333        return TINY_EDIT_CHANGED;
334    case TINY_KEY_DELETE:
335        delete_forward(e);
336        return TINY_EDIT_CHANGED;
337    case TINY_KEY_WORD_BACK: {
338        size_t start = word_start(e->lines[e->row], e->col);
339        line_splice(e, e->lines[e->row], start, e->col, "");
340        e->col = start;
341        return TINY_EDIT_CHANGED;
342    }
343    case TINY_KEY_LEFT:
344        if (e->col > 0) e->col--;
345        else if (e->row > 0) {
346            e->row--;
347            e->col = cp_count(e->lines[e->row]);
348        }
349        return TINY_EDIT_CHANGED;
350    case TINY_KEY_RIGHT:
351        if (e->col < cp_count(e->lines[e->row])) e->col++;
352        else if (e->row + 1 < e->nlines) {
353            e->row++;
354            e->col = 0;
355        }
356        return TINY_EDIT_CHANGED;
357    case TINY_KEY_WORD_LEFT: {
358        size_t start = word_start(e->lines[e->row], e->col);
359        if (start != e->col) {
360            e->col = start;
361            return TINY_EDIT_CHANGED;
362        }
363        if (e->row == 0) return TINY_EDIT_CHANGED;
364        e->row--;
365        size_t prev = cp_count(e->lines[e->row]);
366        e->col = word_start(e->lines[e->row], prev);
367        return TINY_EDIT_CHANGED;
368    }
369    case TINY_KEY_WORD_RIGHT: {
370        size_t end = word_end(e->lines[e->row], e->col);
371        if (end != e->col) {
372            e->col = end;
373            return TINY_EDIT_CHANGED;
374        }
375        if (e->row + 1 >= e->nlines) return TINY_EDIT_CHANGED;
376        e->row++;
377        e->col = word_end(e->lines[e->row], 0);
378        return TINY_EDIT_CHANGED;
379    }
380    case TINY_KEY_UP: {
381        int crow, ccol;
382        caret(e, &crow, &ccol);
383        if (crow > 0) {
384            size_t n;
385            int *cells = cells_of(e->lines[e->row], &n);
386            int cell = cells[e->col < n ? e->col : n - 1] - e->width;
387            free(cells);
388            e->col = col_at_cell(e->lines[e->row], cell);
389            return TINY_EDIT_CHANGED;
390        }
391        if (e->row == 0) return TINY_EDIT_CHANGED;
392        e->row--;
393        char *expanded = tiny_expand_tabs(e->lines[e->row], TAB);
394        tiny_strv chunks = tiny_wrap_line(expanded, e->width);
395        free(expanded);
396        e->col = col_at_cell(e->lines[e->row], ((int)chunks.n - 1) * e->width + ccol);
397        strv_free(&chunks);
398        return TINY_EDIT_CHANGED;
399    }
400    case TINY_KEY_DOWN: {
401        int crow, ccol;
402        caret(e, &crow, &ccol);
403        char *expanded = tiny_expand_tabs(e->lines[e->row], TAB);
404        tiny_strv chunks = tiny_wrap_line(expanded, e->width);
405        free(expanded);
406        if (crow < (int)chunks.n - 1) {
407            size_t n;
408            int *cells = cells_of(e->lines[e->row], &n);
409            int cell = cells[e->col < n ? e->col : n - 1] + e->width;
410            free(cells);
411            e->col = col_at_cell(e->lines[e->row], cell);
412            strv_free(&chunks);
413            return TINY_EDIT_CHANGED;
414        }
415        strv_free(&chunks);
416        if (e->row + 1 >= e->nlines) return TINY_EDIT_CHANGED;
417        e->row++;
418        e->col = col_at_cell(e->lines[e->row], ccol);
419        return TINY_EDIT_CHANGED;
420    }
421    case TINY_KEY_HOME:
422        e->col = 0;
423        return TINY_EDIT_CHANGED;
424    case TINY_KEY_END:
425        e->col = cp_count(e->lines[e->row]);
426        return TINY_EDIT_CHANGED;
427    case TINY_KEY_DOC_START:
428        e->row = 0;
429        e->col = 0;
430        return TINY_EDIT_CHANGED;
431    case TINY_KEY_DOC_END:
432        e->row = e->nlines - 1;
433        e->col = cp_count(e->lines[e->row]);
434        return TINY_EDIT_CHANGED;
435    default:
436        return TINY_EDIT_NONE;
437    }
438}
439
440bool tiny_editor_complete_word(tiny_editor *e, char *(*step)(const char *word, void *user), void *user) {
441    char *line = e->lines[e->row];
442    size_t start = word_start(line, e->col);
443    if (start == e->col) return false;
444    // The character before the caret must not be whitespace.
445    size_t off = cp_off(line, e->col - 1);
446    uint32_t cp;
447    tiny_utf8_decode(line + off, strlen(line) - off, &cp);
448    if (cp_is_space(cp)) return false;
449    char *word = cp_slice(line, start, e->col);
450    char *completed = step(word, user);
451    free(word);
452    if (!completed) return false;
453    line_splice(e, line, start, e->col, completed);
454    e->col = start + cp_count(completed);
455    free(completed);
456    return true;
457}
458
459tiny_editor_view tiny_editor_render(tiny_editor *e, int width, int max_rows) {
460    e->width = width > 0 ? width : 1;
461    tiny_strv rows = {0};
462    int cursor_row = 0, cursor_col = 0;
463    for (size_t line = 0; line < e->nlines; line++) {
464        char *disp = xstrdup(e->lines[line]);
465        char *expanded = tiny_expand_tabs(disp, TAB);
466        tiny_strv chunks = tiny_wrap_line(expanded, e->width);
467        free(expanded);
468        free(disp);
469        if (line == e->row) {
470            int cr, cc;
471            caret(e, &cr, &cc);
472            cursor_row = (int)rows.n + cr;
473            cursor_col = cc;
474        }
475        for (size_t i = 0; i < chunks.n; i++) strv_push(&rows, chunks.v[i]);
476        free(chunks.v);
477    }
478
479    int view = max_rows > 0 ? max_rows : 1;
480    if (cursor_row < e->scroll) e->scroll = cursor_row;
481    else if (cursor_row >= e->scroll + view) e->scroll = cursor_row - view + 1;
482    int max_scroll = (int)rows.n - view;
483    if (max_scroll < 0) max_scroll = 0;
484    if (e->scroll > max_scroll) e->scroll = max_scroll;
485    if (e->scroll < 0) e->scroll = 0;
486
487    size_t shown = rows.n > (size_t)e->scroll ? rows.n - (size_t)e->scroll : 0;
488    if (shown > (size_t)view) shown = (size_t)view;
489    char **out = xmalloc((shown ? shown : 1) * sizeof *out);
490    // Free rows scrolled off and after the window.
491    for (size_t i = 0; i < rows.n; i++) {
492        if (i < (size_t)e->scroll || i >= (size_t)e->scroll + shown) free(rows.v[i]);
493        else out[i - (size_t)e->scroll] = rows.v[i];
494    }
495    free(rows.v);
496
497    tiny_editor_view v = {
498        .rows = out,
499        .nrows = shown,
500        .cursor_row = cursor_row - e->scroll,
501        .cursor_col = cursor_col,
502    };
503    return v;
504}
505