@@ -0,0 +1,645 @@
1+#include "editor.h"
2+
3+#include <stdlib.h>
4+#include <string.h>
5+
6+#include "buf.h"
7+
8+#define TAB 4
9+
10+struct cage_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+ bool masked;
18+ char *text; // cached join, valid until the next change
19+ bool text_dirty;
20+};
21+
22+static void *xmalloc(size_t n) {
23+ void *p = malloc(n);
24+ if (!p) abort();
25+ return p;
26+}
27+
28+static char *xstrdup(const char *s) {
29+ size_t n = strlen(s) + 1;
30+ char *p = xmalloc(n);
31+ memcpy(p, s, n);
32+ return p;
33+}
34+
35+static size_t cp_count(const char *s) {
36+ size_t n = 0, len = strlen(s);
37+ for (size_t i = 0; i < len;) {
38+ uint32_t cp;
39+ int b = cage_utf8_decode(s + i, len - i, &cp);
40+ if (b <= 0) break;
41+ i += (size_t)b;
42+ n++;
43+ }
44+ return n;
45+}
46+
47+// Byte offset of code point index `idx`, clamped to the end.
48+static size_t cp_off(const char *s, size_t idx) {
49+ size_t i = 0, n = 0, len = strlen(s);
50+ while (n < idx && i < len) {
51+ uint32_t cp;
52+ int b = cage_utf8_decode(s + i, len - i, &cp);
53+ if (b <= 0) break;
54+ i += (size_t)b;
55+ n++;
56+ }
57+ return i;
58+}
59+
60+// The code points [a, b) as a new string.
61+static char *cp_slice(const char *s, size_t a, size_t b) {
62+ size_t start = cp_off(s, a);
63+ size_t end = cp_off(s, b);
64+ size_t n = end > start ? end - start : 0;
65+ char *out = xmalloc(n + 1);
66+ memcpy(out, s + start, n);
67+ out[n] = '\0';
68+ return out;
69+}
70+
71+static bool cp_is_space(uint32_t cp) {
72+ return cp == ' ' || cp == '\t' || cp == '\n' || cp == '\r' || cp == '\v' || cp == '\f';
73+}
74+
75+// First code point index of the word before `col`.
76+static size_t word_start(const char *s, size_t col) {
77+ // Materialize code points for simple indexing.
78+ size_t len = strlen(s);
79+ size_t cap = 8, n = 0;
80+ uint32_t *cps = xmalloc(cap * sizeof *cps);
81+ for (size_t i = 0; i < len;) {
82+ uint32_t cp;
83+ int b = cage_utf8_decode(s + i, len - i, &cp);
84+ if (b <= 0) break;
85+ if (n == cap) {
86+ cap *= 2;
87+ cps = realloc(cps, cap * sizeof *cps);
88+ if (!cps) abort();
89+ }
90+ cps[n++] = cp;
91+ i += (size_t)b;
92+ }
93+ size_t i = col;
94+ while (i > 0 && cp_is_space(cps[i - 1])) i--;
95+ while (i > 0 && !cp_is_space(cps[i - 1])) i--;
96+ free(cps);
97+ return i;
98+}
99+
100+// One past the word at or after `col`.
101+static size_t word_end(const char *s, size_t col) {
102+ size_t len = strlen(s);
103+ size_t cap = 8, n = 0;
104+ uint32_t *cps = xmalloc(cap * sizeof *cps);
105+ for (size_t i = 0; i < len;) {
106+ uint32_t cp;
107+ int b = cage_utf8_decode(s + i, len - i, &cp);
108+ if (b <= 0) break;
109+ if (n == cap) {
110+ cap *= 2;
111+ cps = realloc(cps, cap * sizeof *cps);
112+ if (!cps) abort();
113+ }
114+ cps[n++] = cp;
115+ i += (size_t)b;
116+ }
117+ size_t i = col;
118+ while (i < n && cp_is_space(cps[i])) i++;
119+ while (i < n && !cp_is_space(cps[i])) i++;
120+ free(cps);
121+ return i;
122+}
123+
124+cage_editor *cage_editor_new(void) {
125+ cage_editor *e = calloc(1, sizeof *e);
126+ if (!e) abort();
127+ e->nlines = 1;
128+ e->lines = xmalloc(sizeof *e->lines);
129+ e->lines[0] = xstrdup("");
130+ e->width = 80;
131+ e->text_dirty = true;
132+ return e;
133+}
134+
135+void cage_editor_free(cage_editor *e) {
136+ if (!e) return;
137+ for (size_t i = 0; i < e->nlines; i++) free(e->lines[i]);
138+ free(e->lines);
139+ free(e->text);
140+ free(e);
141+}
142+
143+const char *cage_editor_text(cage_editor *e) {
144+ if (!e->text_dirty) return e->text;
145+ tui_buf b;
146+ buf_init(&b);
147+ for (size_t i = 0; i < e->nlines; i++) {
148+ if (i) buf_addc(&b, '\n');
149+ buf_adds(&b, e->lines[i]);
150+ }
151+ free(e->text);
152+ e->text = b.data ? buf_steal(&b) : xstrdup("");
153+ buf_free(&b);
154+ e->text_dirty = false;
155+ return e->text;
156+}
157+
158+void cage_editor_set_masked(cage_editor *e, bool masked) {
159+ e->masked = masked;
160+}
161+
162+void cage_editor_clear(cage_editor *e) {
163+ for (size_t i = 0; i < e->nlines; i++) free(e->lines[i]);
164+ e->nlines = 1;
165+ e->lines = realloc(e->lines, sizeof *e->lines);
166+ e->lines[0] = xstrdup("");
167+ e->row = 0;
168+ e->col = 0;
169+ e->scroll = 0;
170+ e->text_dirty = true;
171+}
172+
173+void cage_editor_set_text(cage_editor *e, const char *text) {
174+ for (size_t i = 0; i < e->nlines; i++) free(e->lines[i]);
175+ // Split on newline.
176+ size_t cap = 8, n = 0;
177+ char **lines = xmalloc(cap * sizeof *lines);
178+ const char *p = text;
179+ for (;;) {
180+ const char *nl = strchr(p, '\n');
181+ size_t len = nl ? (size_t)(nl - p) : strlen(p);
182+ char *line = xmalloc(len + 1);
183+ memcpy(line, p, len);
184+ line[len] = '\0';
185+ if (n == cap) {
186+ cap *= 2;
187+ lines = realloc(lines, cap * sizeof *lines);
188+ if (!lines) abort();
189+ }
190+ lines[n++] = line;
191+ if (!nl) break;
192+ p = nl + 1;
193+ }
194+ free(e->lines);
195+ e->lines = lines;
196+ e->nlines = n;
197+ e->row = n - 1;
198+ e->col = cp_count(e->lines[e->row]);
199+ e->scroll = 0;
200+ e->text_dirty = true;
201+}
202+
203+static char *display_line(cage_editor *e, size_t line) {
204+ if (!e->masked) return xstrdup(e->lines[line]);
205+ size_t n = cp_count(e->lines[line]);
206+ char *out = xmalloc(n + 1);
207+ memset(out, '*', n);
208+ out[n] = '\0';
209+ return out;
210+}
211+
212+// Display column of every code point boundary in `line`, tabs expanded.
213+static int *cells_of(const char *line, size_t *n_out) {
214+ size_t len = strlen(line);
215+ size_t cap = 16, n = 0;
216+ int *out = xmalloc(cap * sizeof *out);
217+ out[n++] = 0;
218+ int col = 0;
219+ for (size_t i = 0; i < len;) {
220+ uint32_t cp;
221+ int b = cage_utf8_decode(line + i, len - i, &cp);
222+ if (b <= 0) break;
223+ if (cp == '\t') col += TAB - (col % TAB);
224+ else col += cage_char_width(cp);
225+ if (n == cap) {
226+ cap *= 2;
227+ out = realloc(out, cap * sizeof *out);
228+ if (!out) abort();
229+ }
230+ out[n++] = col;
231+ i += (size_t)b;
232+ }
233+ *n_out = n;
234+ return out;
235+}
236+
237+// The caret column nearest `cell`, never past the end of the line.
238+static size_t col_at_cell(const char *line, int cell) {
239+ size_t n;
240+ int *cells = cells_of(line, &n);
241+ size_t i = n - 1;
242+ while (i > 0 && cells[i] > cell) i--;
243+ free(cells);
244+ return i;
245+}
246+
247+static void caret(cage_editor *e, int *row_out, int *col_out) {
248+ char *line = display_line(e, e->row);
249+ char *expanded = cage_expand_tabs(line, TAB);
250+ size_t nrows;
251+ char **chunks = cage_wrap_line(expanded, e->width, &nrows);
252+ size_t ncells;
253+ int *cells = cells_of(line, &ncells);
254+ int cell = cells[e->col < ncells ? e->col : ncells - 1];
255+ free(cells);
256+ int row = cell / e->width;
257+ if (row >= (int)nrows) {
258+ *row_out = (int)nrows - 1;
259+ *col_out = cage_display_width(chunks[nrows - 1]);
260+ } else {
261+ *row_out = row;
262+ *col_out = cell - row * e->width;
263+ }
264+ for (size_t i = 0; i < nrows; i++) free(chunks[i]);
265+ free(chunks);
266+ free(expanded);
267+ free(line);
268+}
269+
270+static void insert_text(cage_editor *e, const char *text) {
271+ // Split `text` on newlines.
272+ size_t nparts = 1;
273+ for (const char *p = text; *p; p++)
274+ if (*p == '\n') nparts++;
275+
276+ char *line = e->lines[e->row];
277+ char *before = cp_slice(line, 0, e->col);
278+ char *after = cp_slice(line, e->col, cp_count(line));
279+
280+ if (nparts == 1) {
281+ tui_buf b;
282+ buf_init(&b);
283+ buf_adds(&b, before);
284+ buf_adds(&b, text);
285+ buf_adds(&b, after);
286+ free(e->lines[e->row]);
287+ e->lines[e->row] = b.data ? buf_steal(&b) : xstrdup("");
288+ buf_free(&b);
289+ e->col += cp_count(text);
290+ e->text_dirty = true;
291+ free(before);
292+ free(after);
293+ return;
294+ }
295+
296+ // Build the replacement lines.
297+ size_t cap = 8, n = 0;
298+ char **parts = xmalloc(cap * sizeof *parts);
299+ const char *p = text;
300+ for (;;) {
301+ const char *nl = strchr(p, '\n');
302+ size_t len = nl ? (size_t)(nl - p) : strlen(p);
303+ char *part = xmalloc(len + 1);
304+ memcpy(part, p, len);
305+ part[len] = '\0';
306+ if (n == cap) {
307+ cap *= 2;
308+ parts = realloc(parts, cap * sizeof *parts);
309+ if (!parts) abort();
310+ }
311+ parts[n++] = part;
312+ if (!nl) break;
313+ p = nl + 1;
314+ }
315+
316+ tui_buf head;
317+ buf_init(&head);
318+ buf_adds(&head, before);
319+ buf_adds(&head, parts[0]);
320+ tui_buf tail;
321+ buf_init(&tail);
322+ buf_adds(&tail, parts[n - 1]);
323+ buf_adds(&tail, after);
324+ size_t caret_col = cp_count(parts[n - 1]);
325+ free(parts[0]);
326+ free(parts[n - 1]);
327+
328+ // New line array: [0, row) + head + middle parts + tail + (row, end).
329+ char **nl = xmalloc((e->nlines + 1) * sizeof *nl);
330+ size_t k = 0;
331+ for (size_t i = 0; i < e->row; i++) nl[k++] = e->lines[i];
332+ nl[k++] = head.data ? buf_steal(&head) : xstrdup("");
333+ buf_free(&head);
334+ for (size_t i = 1; i + 1 < n; i++) nl[k++] = parts[i];
335+ nl[k++] = tail.data ? buf_steal(&tail) : xstrdup("");
336+ buf_free(&tail);
337+ for (size_t i = e->row + 1; i < e->nlines; i++) nl[k++] = e->lines[i];
338+ free(e->lines);
339+ e->lines = nl;
340+ e->nlines = k;
341+ e->row += n - 1;
342+ e->col = caret_col;
343+ free(parts);
344+ free(before);
345+ free(after);
346+ e->text_dirty = true;
347+}
348+
349+static void backspace(cage_editor *e) {
350+ if (e->col > 0) {
351+ char *line = e->lines[e->row];
352+ char *before = cp_slice(line, 0, e->col - 1);
353+ char *after = cp_slice(line, e->col, cp_count(line));
354+ tui_buf b;
355+ buf_init(&b);
356+ buf_adds(&b, before);
357+ buf_adds(&b, after);
358+ free(line);
359+ e->lines[e->row] = b.data ? buf_steal(&b) : xstrdup("");
360+ buf_free(&b);
361+ free(before);
362+ free(after);
363+ e->col--;
364+ e->text_dirty = true;
365+ return;
366+ }
367+ if (e->row > 0) {
368+ size_t prev = cp_count(e->lines[e->row - 1]);
369+ tui_buf b;
370+ buf_init(&b);
371+ buf_adds(&b, e->lines[e->row - 1]);
372+ buf_adds(&b, e->lines[e->row]);
373+ free(e->lines[e->row - 1]);
374+ e->lines[e->row - 1] = b.data ? buf_steal(&b) : xstrdup("");
375+ buf_free(&b);
376+ free(e->lines[e->row]);
377+ for (size_t i = e->row; i + 1 < e->nlines; i++) e->lines[i] = e->lines[i + 1];
378+ e->nlines--;
379+ e->row--;
380+ e->col = prev;
381+ e->text_dirty = true;
382+ }
383+}
384+
385+static void delete_forward(cage_editor *e) {
386+ char *line = e->lines[e->row];
387+ size_t n = cp_count(line);
388+ if (e->col < n) {
389+ char *before = cp_slice(line, 0, e->col);
390+ char *after = cp_slice(line, e->col + 1, n);
391+ tui_buf b;
392+ buf_init(&b);
393+ buf_adds(&b, before);
394+ buf_adds(&b, after);
395+ free(line);
396+ e->lines[e->row] = b.data ? buf_steal(&b) : xstrdup("");
397+ buf_free(&b);
398+ free(before);
399+ free(after);
400+ e->text_dirty = true;
401+ return;
402+ }
403+ if (e->row + 1 < e->nlines) {
404+ tui_buf b;
405+ buf_init(&b);
406+ buf_adds(&b, e->lines[e->row]);
407+ buf_adds(&b, e->lines[e->row + 1]);
408+ free(e->lines[e->row]);
409+ e->lines[e->row] = b.data ? buf_steal(&b) : xstrdup("");
410+ buf_free(&b);
411+ free(e->lines[e->row + 1]);
412+ for (size_t i = e->row + 1; i + 1 < e->nlines; i++) e->lines[i] = e->lines[i + 1];
413+ e->nlines--;
414+ e->text_dirty = true;
415+ }
416+}
417+
418+cage_edit_result cage_editor_handle(cage_editor *e, const cage_key *key) {
419+ switch (key->type) {
420+ case CAGE_KEY_SUBMIT:
421+ return CAGE_EDIT_SUBMIT;
422+ case CAGE_KEY_NEWLINE:
423+ insert_text(e, "\n");
424+ return CAGE_EDIT_CHANGED;
425+ case CAGE_KEY_TEXT:
426+ insert_text(e, key->text ? key->text : "");
427+ return CAGE_EDIT_CHANGED;
428+ case CAGE_KEY_BACKSPACE:
429+ backspace(e);
430+ return CAGE_EDIT_CHANGED;
431+ case CAGE_KEY_DELETE:
432+ delete_forward(e);
433+ return CAGE_EDIT_CHANGED;
434+ case CAGE_KEY_WORD_BACK: {
435+ char *line = e->lines[e->row];
436+ size_t start = word_start(line, e->col);
437+ char *before = cp_slice(line, 0, start);
438+ char *after = cp_slice(line, e->col, cp_count(line));
439+ tui_buf b;
440+ buf_init(&b);
441+ buf_adds(&b, before);
442+ buf_adds(&b, after);
443+ free(line);
444+ e->lines[e->row] = b.data ? buf_steal(&b) : xstrdup("");
445+ buf_free(&b);
446+ free(before);
447+ free(after);
448+ e->col = start;
449+ e->text_dirty = true;
450+ return CAGE_EDIT_CHANGED;
451+ }
452+ case CAGE_KEY_LEFT:
453+ if (e->col > 0) e->col--;
454+ else if (e->row > 0) {
455+ e->row--;
456+ e->col = cp_count(e->lines[e->row]);
457+ }
458+ return CAGE_EDIT_CHANGED;
459+ case CAGE_KEY_RIGHT:
460+ if (e->col < cp_count(e->lines[e->row])) e->col++;
461+ else if (e->row + 1 < e->nlines) {
462+ e->row++;
463+ e->col = 0;
464+ }
465+ return CAGE_EDIT_CHANGED;
466+ case CAGE_KEY_WORD_LEFT: {
467+ size_t start = word_start(e->lines[e->row], e->col);
468+ if (start != e->col) {
469+ e->col = start;
470+ return CAGE_EDIT_CHANGED;
471+ }
472+ if (e->row == 0) return CAGE_EDIT_CHANGED;
473+ e->row--;
474+ size_t prev = cp_count(e->lines[e->row]);
475+ e->col = word_start(e->lines[e->row], prev);
476+ return CAGE_EDIT_CHANGED;
477+ }
478+ case CAGE_KEY_WORD_RIGHT: {
479+ size_t end = word_end(e->lines[e->row], e->col);
480+ if (end != e->col) {
481+ e->col = end;
482+ return CAGE_EDIT_CHANGED;
483+ }
484+ if (e->row + 1 >= e->nlines) return CAGE_EDIT_CHANGED;
485+ e->row++;
486+ e->col = word_end(e->lines[e->row], 0);
487+ return CAGE_EDIT_CHANGED;
488+ }
489+ case CAGE_KEY_UP: {
490+ int crow, ccol;
491+ caret(e, &crow, &ccol);
492+ if (crow > 0) {
493+ size_t n;
494+ int *cells = cells_of(e->lines[e->row], &n);
495+ int cell = cells[e->col < n ? e->col : n - 1] - e->width;
496+ free(cells);
497+ e->col = col_at_cell(e->lines[e->row], cell);
498+ return CAGE_EDIT_CHANGED;
499+ }
500+ if (e->row == 0) return CAGE_EDIT_CHANGED;
501+ e->row--;
502+ char *expanded = cage_expand_tabs(e->lines[e->row], TAB);
503+ size_t nrows;
504+ char **chunks = cage_wrap_line(expanded, e->width, &nrows);
505+ int last_row = (int)nrows - 1;
506+ for (size_t i = 0; i < nrows; i++) free(chunks[i]);
507+ free(chunks);
508+ free(expanded);
509+ e->col = col_at_cell(e->lines[e->row], last_row * e->width + ccol);
510+ return CAGE_EDIT_CHANGED;
511+ }
512+ case CAGE_KEY_DOWN: {
513+ int crow, ccol;
514+ caret(e, &crow, &ccol);
515+ char *expanded = cage_expand_tabs(e->lines[e->row], TAB);
516+ size_t nrows;
517+ char **chunks = cage_wrap_line(expanded, e->width, &nrows);
518+ for (size_t i = 0; i < nrows; i++) free(chunks[i]);
519+ free(chunks);
520+ free(expanded);
521+ if (crow < (int)nrows - 1) {
522+ size_t n;
523+ int *cells = cells_of(e->lines[e->row], &n);
524+ int cell = cells[e->col < n ? e->col : n - 1] + e->width;
525+ free(cells);
Cut short: this commit's diff is over 1000 lines.