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