diff options
Diffstat (limited to 'src/dged')
34 files changed, 5339 insertions, 0 deletions
diff --git a/src/dged/allocator.c b/src/dged/allocator.c new file mode 100644 index 0000000..308b97c --- /dev/null +++ b/src/dged/allocator.c @@ -0,0 +1,24 @@ +#include "allocator.h" + +struct frame_allocator frame_allocator_create(size_t capacity) { + return (struct frame_allocator){ + .capacity = capacity, .offset = 0, .buf = (uint8_t *)malloc(capacity)}; +} + +void frame_allocator_destroy(struct frame_allocator *alloc) { + free(alloc->buf); + alloc->buf = NULL; +} + +void *frame_allocator_alloc(struct frame_allocator *alloc, size_t sz) { + if (alloc->offset + sz > alloc->capacity) { + return NULL; + } + + void *mem = alloc->buf + alloc->offset; + alloc->offset += sz; + + return mem; +} + +void frame_allocator_clear(struct frame_allocator *alloc) { alloc->offset = 0; } diff --git a/src/dged/allocator.h b/src/dged/allocator.h new file mode 100644 index 0000000..49e3aec --- /dev/null +++ b/src/dged/allocator.h @@ -0,0 +1,46 @@ +#include <stddef.h> +#include <stdint.h> +#include <stdlib.h> + +/** + * Simple bump allocator that can be used for + * allocations with a frame lifetime. + */ +struct frame_allocator { + uint8_t *buf; + size_t offset; + size_t capacity; +}; + +/** + * Create a new frame allocator + * + * @param capacity The capacity in bytes of the frame allocator + * @returns The frame allocator + */ +struct frame_allocator frame_allocator_create(size_t capacity); + +/** + * Destroy a frame allocator. + * + * @param alloc The @ref frame_allocator "frame allocator" to destroy. + */ +void frame_allocator_destroy(struct frame_allocator *alloc); + +/** + * Allocate memory in this @ref frame_allocator "frame allocator" + * + * @param alloc The allocator to allocate in + * @param sz The size in bytes to allocate. + * @returns void* representing the start of the allocated region on success, + * NULL on failure. + */ +void *frame_allocator_alloc(struct frame_allocator *alloc, size_t sz); + +/** + * Clear this @ref frame_allocator "frame allocator". + * + * This does not free any memory, but simply resets the offset to 0. + * @param alloc The frame allocator to clear + */ +void frame_allocator_clear(struct frame_allocator *alloc); diff --git a/src/dged/binding.c b/src/dged/binding.c new file mode 100644 index 0000000..5111548 --- /dev/null +++ b/src/dged/binding.c @@ -0,0 +1,75 @@ +#include "binding.h" +#include "command.h" + +#include <stdlib.h> +#include <string.h> + +struct keymap keymap_create(const char *name, uint32_t capacity) { + return (struct keymap){ + .name = name, + .bindings = calloc(capacity, sizeof(struct binding)), + .nbindings = 0, + .capacity = capacity, + }; +} + +void keymap_bind_keys(struct keymap *keymap, struct binding *bindings, + uint32_t nbindings) { + if (keymap->nbindings + nbindings >= keymap->capacity) { + keymap->capacity = + nbindings > keymap->capacity * 2 ? nbindings * 2 : keymap->capacity * 2; + keymap->bindings = + realloc(keymap->bindings, sizeof(struct binding) * keymap->capacity); + } + memcpy(keymap->bindings + keymap->nbindings, bindings, + sizeof(struct binding) * nbindings); + + keymap->nbindings += nbindings; +} + +void keymap_destroy(struct keymap *keymap) { + free(keymap->bindings); + keymap->bindings = 0; + keymap->capacity = 0; + keymap->nbindings = 0; +} + +struct lookup_result lookup_key(struct keymap *keymaps, uint32_t nkeymaps, + struct key *key, struct commands *commands) { + // lookup in reverse order in the keymaps + uint32_t kmi = nkeymaps; + while (kmi > 0) { + --kmi; + struct keymap *keymap = &keymaps[kmi]; + + for (uint32_t bi = keymap->nbindings; bi > 0; --bi) { + struct binding *binding = &keymap->bindings[bi - 1]; + if (key_equal(key, &binding->key)) { + switch (binding->type) { + case BindingType_Command: { + return (struct lookup_result){ + .found = true, + .type = BindingType_Command, + .command = lookup_command_by_hash(commands, binding->command), + }; + } + case BindingType_Keymap: { + return (struct lookup_result){ + .found = true, + .type = BindingType_Keymap, + .keymap = binding->keymap, + }; + } + case BindingType_DirectCommand: + return (struct lookup_result){ + .found = true, + .type = BindingType_Command, + .command = binding->direct_command, + }; + } + } + } + } + + return (struct lookup_result){.found = false}; +} diff --git a/src/dged/binding.h b/src/dged/binding.h new file mode 100644 index 0000000..f2a531d --- /dev/null +++ b/src/dged/binding.h @@ -0,0 +1,136 @@ +#include "hash.h" +#include "keyboard.h" + +/** + * Directory of keyboard mappings. + */ +struct keymap { + /** Keymap name */ + const char *name; + + /** The bindings in this keymap */ + struct binding *bindings; + + /** The number of bindings in this keymap */ + uint32_t nbindings; + + /** The number of bindings this keymap can currently hold */ + uint32_t capacity; +}; + +/** + * Type of a keyboard binding + */ +enum binding_type { + /** This binding is to a command */ + BindingType_Command, + + /** This binding is to another keymap */ + BindingType_Keymap, + + /** This binding is to an already resolved command, + * a.k.a. anonymous binding. + */ + BindingType_DirectCommand +}; + +#define BINDING_INNER(mod_, c_, command_) \ + (struct binding) { \ + .key = {.mod = mod_, .key = c_}, .type = BindingType_Command, \ + .command = hash_name(command_) \ + } + +#define ANONYMOUS_BINDING_INNER(mod_, c_, command_) \ + (struct binding) { \ + .key = {.mod = mod_, .key = c_}, .type = BindingType_DirectCommand, \ + .direct_command = command_ \ + } + +#define PREFIX_INNER(mod_, c_, keymap_) \ + (struct binding) { \ + .key = {.mod = mod_, .key = c_}, .type = BindingType_Keymap, \ + .keymap = keymap_ \ + } + +#define BINDING(...) BINDING_INNER(__VA_ARGS__) +#define PREFIX(...) PREFIX_INNER(__VA_ARGS__) +#define ANONYMOUS_BINDING(...) ANONYMOUS_BINDING_INNER(__VA_ARGS__) + +/** + * A keyboard key bound to an action + */ +struct binding { + /** The keyboard key that triggers the action in this binding */ + struct key key; + + /** Type of this binding, see @ref binding_type */ + uint8_t type; + + union { + /** A hash of a command name */ + uint32_t command; + /** A command */ + struct command *direct_command; + /** A keymap */ + struct keymap *keymap; + }; +}; + +/** + * Result of a binding lookup + */ +struct lookup_result { + /** True if a binding was found */ + bool found; + + /** Type of binding in the result */ + uint8_t type; + + union { + /** A command */ + struct command *command; + /** A keymap */ + struct keymap *keymap; + }; +}; + +struct commands; + +/** + * Create a new keymap + * + * @param name Name of the keymap + * @param capacity Initial capacity of the keymap. + * @returns The created keymap + */ +struct keymap keymap_create(const char *name, uint32_t capacity); + +/** + * Bind keys in a keymap. + * + * @param keymap The keymap to bind keys in. + * @param bindings Bindings to add. + * @param nbindings Number of bindings in @ref bindings. + */ +void keymap_bind_keys(struct keymap *keymap, struct binding *bindings, + uint32_t nbindings); + +/** + * Destroy a keymap. + * + * This clears all keybindings associated with the keymap. + * @param keymap Keymap to destroy. + */ +void keymap_destroy(struct keymap *keymap); + +/** + * Lookup the binding for a key in a set of keymaps. + * + * @param keymaps The keymaps to look in. + * @param nkeymaps The number of keymaps in @ref keymaps. + * @param key The keystroke to look up bindings for. + * @param commands Available commands for lookup. + * @returns A @ref lookup_result with the result of the lookup. + */ +struct lookup_result lookup_key(struct keymap *keymaps, uint32_t nkeymaps, + struct key *key, struct commands *commands); diff --git a/src/dged/btree.h b/src/dged/btree.h new file mode 100644 index 0000000..8743b32 --- /dev/null +++ b/src/dged/btree.h @@ -0,0 +1,113 @@ +#ifndef _BTREE_H +#define _BTREE_H + +#include "vec.h" + +#include <stdlib.h> + +#define BINTREE_ENTRY_TYPE(name, entry) \ + struct name { \ + struct name *parent; \ + struct name *left; \ + struct name *right; \ + entry value; \ + } + +#define BINTREE(entry) \ + struct { \ + struct entry *root; \ + } + +#define BINTREE_INIT(tree) ((tree)->root = NULL) +#define BINTREE_DESTROY(tree, entry_type) BINTREE_INIT(tree) + +#define BINTREE_ROOT(tree) (tree)->root + +#define BINTREE_LEFT(node) (node)->left +#define BINTREE_RIGHT(node) (node)->right +#define BINTREE_PARENT(node) (node)->parent +#define BINTREE_VALUE(node) (node)->value +#define BINTREE_HAS_PARENT(node) ((node)->parent != NULL) +#define BINTREE_HAS_LEFT(node) ((node)->left != NULL) +#define BINTREE_HAS_RIGHT(node) ((node)->right != NULL) + +#define BINTREE_FREE_NODE(node) free(node) +#define BINTREE_FREE_NODES(root, entry_type) \ + { \ + BINTREE_FIRST(root); \ + VEC(struct entry_type *) to_delete; \ + VEC_INIT(&to_delete, 10); \ + while (root != NULL) { \ + VEC_PUSH(&to_delete, root); \ + BINTREE_NEXT(root); \ + } \ + VEC_FOR_EACH(&to_delete, struct entry_type **e) { BINTREE_FREE_NODE(*e); } \ + VEC_DESTROY(&to_delete); \ + } + +#define BINTREE_FIRST(res) \ + if (res == NULL) { \ + res = NULL; \ + } else { \ + while (BINTREE_HAS_LEFT(res)) { \ + res = BINTREE_LEFT(res); \ + } \ + } + +#define BINTREE_NEXT(res) \ + if (res == NULL) { \ + res = NULL; \ + } else { \ + if (BINTREE_HAS_RIGHT(res)) { \ + res = BINTREE_RIGHT(res); \ + BINTREE_FIRST(res) \ + } else { \ + while (BINTREE_HAS_PARENT(res) && \ + res == BINTREE_RIGHT(BINTREE_PARENT(res))) \ + res = BINTREE_PARENT(res); \ + res = BINTREE_PARENT(res); \ + } \ + } + +#define BINTREE_INSERT(parent, entry) \ + if (parent != NULL) { \ + if (!BINTREE_HAS_LEFT(parent)) { \ + BINTREE_LEFT(parent) = calloc(1, sizeof(*(parent))); \ + BINTREE_PARENT(BINTREE_LEFT(parent)) = parent; \ + BINTREE_VALUE(BINTREE_LEFT(parent)) = entry; \ + } else { \ + BINTREE_RIGHT(parent) = calloc(1, sizeof(*(parent))); \ + BINTREE_PARENT(BINTREE_RIGHT(parent)) = parent; \ + BINTREE_VALUE(BINTREE_RIGHT(parent)) = entry; \ + } \ + } + +#define BINTREE_REMOVE(node) \ + if (BINTREE_HAS_PARENT(node)) { \ + if (BINTREE_LEFT(BINTREE_PARENT(node)) == node) { \ + BINTREE_LEFT(BINTREE_PARENT(node)) = NULL; \ + } else { \ + BINTREE_RIGHT(BINTREE_PARENT(node)) = NULL; \ + } \ + BINTREE_PARENT(node) = NULL; \ + } + +#define BINTREE_SET_ROOT(tree, value) \ + (tree)->root = calloc(1, sizeof(*(tree)->root)); \ + BINTREE_VALUE((tree)->root) = value; + +#define BINTREE_FIND(tree, needle, res) \ + { \ + res = BINTREE_ROOT(tree); \ + BINTREE_FIRST(res); \ + bool found = false; \ + while (res != NULL) { \ + if (BINTREE_VALUE(res) == needle) { \ + found = true; \ + break; \ + } \ + BINTREE_NEXT(res); \ + } \ + res = found ? res : NULL; \ + } +#endif diff --git a/src/dged/buffer.c b/src/dged/buffer.c new file mode 100644 index 0000000..25a8a4a --- /dev/null +++ b/src/dged/buffer.c @@ -0,0 +1,1110 @@ +#include "buffer.h" +#include "binding.h" +#include "bits/stdint-uintn.h" +#include "dged/vec.h" +#include "display.h" +#include "errno.h" +#include "lang.h" +#include "minibuffer.h" +#include "reactor.h" +#include "settings.h" +#include "utf8.h" + +#include <fcntl.h> +#include <libgen.h> +#include <stdbool.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <time.h> +#include <unistd.h> +#include <wchar.h> + +struct modeline { + uint8_t *buffer; + uint32_t sz; +}; + +#define KILL_RING_SZ 64 +static struct kill_ring { + struct text_chunk buffer[KILL_RING_SZ]; + struct buffer_location last_paste; + bool paste_up_to_date; + uint32_t curr_idx; + uint32_t paste_idx; +} g_kill_ring = {.curr_idx = 0, + .buffer = {0}, + .last_paste = {0}, + .paste_idx = 0, + .paste_up_to_date = false}; + +#define MAX_CREATE_HOOKS 32 +static struct create_hook { + create_hook_cb callback; + void *userdata; +} g_create_hooks[MAX_CREATE_HOOKS]; +static uint32_t g_num_create_hooks = 0; + +struct update_hook_result buffer_linenum_hook(struct buffer_view *view, + struct command_list *commands, + uint32_t width, uint32_t height, + uint64_t frame_time, + void *userdata); + +struct update_hook_result buffer_modeline_hook(struct buffer_view *view, + struct command_list *commands, + uint32_t width, uint32_t height, + uint64_t frame_time, + void *userdata); + +struct buffer_view buffer_view_create(struct buffer *buffer, bool modeline, + bool line_numbers) { + struct buffer_view view = { + .dot = {0}, + .mark = {0}, + .mark_set = false, + .scroll = {0}, + .buffer = buffer, + .modeline = NULL, + .line_numbers = line_numbers, + }; + + if (modeline) { + view.modeline = calloc(1, sizeof(struct modeline)); + view.modeline->buffer = malloc(1024); + view.modeline->sz = 1024; + view.modeline->buffer[0] = '\0'; + } + + return view; +} + +struct buffer_view buffer_view_clone(struct buffer_view *view) { + struct buffer_view c = { + .dot = view->dot, + .mark = view->mark, + .mark_set = view->mark_set, + .scroll = view->scroll, + .buffer = view->buffer, + .modeline = NULL, + .line_numbers = view->line_numbers, + }; + + if (view->modeline) { + c.modeline = calloc(1, sizeof(struct modeline)); + c.modeline->buffer = malloc(view->modeline->sz); + memcpy(c.modeline->buffer, view->modeline->buffer, view->modeline->sz); + } + + return c; +} + +void buffer_view_destroy(struct buffer_view *view) { + if (view->modeline != NULL) { + free(view->modeline->buffer); + free(view->modeline); + } +} + +uint32_t buffer_add_create_hook(create_hook_cb hook, void *userdata) { + if (g_num_create_hooks < MAX_CREATE_HOOKS) { + g_create_hooks[g_num_create_hooks] = (struct create_hook){ + .callback = hook, + .userdata = userdata, + }; + ++g_num_create_hooks; + } + + return g_num_create_hooks - 1; +} + +struct buffer buffer_create(char *name) { + struct buffer b = (struct buffer){ + .filename = NULL, + .name = strdup(name), + .text = text_create(10), + .modified = false, + .readonly = false, + .lang = lang_from_id("fnd"), + }; + + undo_init(&b.undo, 100); + + for (uint32_t hooki = 0; hooki < g_num_create_hooks; ++hooki) { + g_create_hooks[hooki].callback(&b, g_create_hooks[hooki].userdata); + } + + return b; +} + +void buffer_destroy(struct buffer *buffer) { + text_destroy(buffer->text); + buffer->text = NULL; + + free(buffer->name); + buffer->name = NULL; + + free(buffer->filename); + buffer->filename = NULL; + + undo_destroy(&buffer->undo); +} + +void buffer_clear(struct buffer_view *view) { + text_clear(view->buffer->text); + view->dot.col = view->dot.line = 0; +} + +void buffer_static_init() { + settings_register_setting( + "editor.tab-width", + (struct setting_value){.type = Setting_Number, .number_value = 4}); + + settings_register_setting( + "editor.show-whitespace", + (struct setting_value){.type = Setting_Bool, .bool_value = true}); +} + +void buffer_static_teardown() { + for (uint32_t i = 0; i < KILL_RING_SZ; ++i) { + if (g_kill_ring.buffer[i].allocated) { + free(g_kill_ring.buffer[i].text); + } + } +} + +bool buffer_is_empty(struct buffer *buffer) { + return text_num_lines(buffer->text) == 0; +} + +bool buffer_is_modified(struct buffer *buffer) { return buffer->modified; } + +bool buffer_is_readonly(struct buffer *buffer) { return buffer->readonly; } +void buffer_set_readonly(struct buffer *buffer, bool readonly) { + buffer->readonly = readonly; +} + +void delete_with_undo(struct buffer *buffer, struct buffer_location start, + struct buffer_location end) { + if (buffer->readonly) { + minibuffer_echo_timeout(4, "buffer is read-only"); + return; + } + + struct text_chunk txt = + text_get_region(buffer->text, start.line, start.col, end.line, end.col); + + undo_push_delete( + &buffer->undo, + (struct undo_delete){.data = txt.text, + .nbytes = txt.nbytes, + .pos = {.row = start.line, .col = start.col}}); + undo_push_boundary(&buffer->undo, + (struct undo_boundary){.save_point = false}); + + text_delete(buffer->text, start.line, start.col, end.line, end.col); + buffer->modified = true; +} + +void buffer_goto_beginning(struct buffer_view *view) { + view->dot.col = 0; + view->dot.line = 0; +} + +void buffer_goto_end(struct buffer_view *view) { + view->dot.line = text_num_lines(view->buffer->text); + view->dot.col = 0; +} + +bool movev(struct buffer_view *view, int rowdelta) { + int64_t new_line = (int64_t)view->dot.line + rowdelta; + + if (new_line < 0) { + view->dot.line = 0; + return false; + } else if (new_line > text_num_lines(view->buffer->text)) { + view->dot.line = text_num_lines(view->buffer->text); + return false; + } else { + view->dot.line = (uint32_t)new_line; + + // make sure column stays on the line + uint32_t linelen = text_line_length(view->buffer->text, view->dot.line); + view->dot.col = view->dot.col > linelen ? linelen : view->dot.col; + return true; + } +} + +// move dot `coldelta` chars +bool moveh(struct buffer_view *view, int coldelta) { + int64_t new_col = (int64_t)view->dot.col + coldelta; + + if (new_col > (int64_t)text_line_length(view->buffer->text, view->dot.line)) { + if (movev(view, 1)) { + view->dot.col = 0; + } + } else if (new_col < 0) { + if (movev(view, -1)) { + view->dot.col = text_line_length(view->buffer->text, view->dot.line); + } else { + return false; + } + } else { + view->dot.col = new_col; + } + + return true; +} + +void buffer_goto(struct buffer_view *view, uint32_t line, uint32_t col) { + int64_t linedelta = (int64_t)line - (int64_t)view->dot.line; + movev(view, linedelta); + + int64_t coldelta = (int64_t)col - (int64_t)view->dot.col; + moveh(view, coldelta); +} + +struct region { + struct buffer_location begin; + struct buffer_location end; +}; + +struct region to_region(struct buffer_location dot, + struct buffer_location mark) { + struct region reg = {.begin = mark, .end = dot}; + + if (dot.line < mark.line || (dot.line == mark.line && dot.col < mark.col)) { + reg.begin = dot; + reg.end = mark; + } + + return reg; +} + +struct region buffer_get_region(struct buffer_view *view) { + return to_region(view->dot, view->mark); +} + +bool buffer_region_has_size(struct buffer_view *view) { + return view->mark_set && + (labs((int64_t)view->mark.line - (int64_t)view->dot.line) + + labs((int64_t)view->mark.col - (int64_t)view->dot.col)) > 0; +} + +struct text_chunk *copy_region(struct buffer *buffer, struct region region) { + struct text_chunk *curr = &g_kill_ring.buffer[g_kill_ring.curr_idx]; + g_kill_ring.curr_idx = g_kill_ring.curr_idx + 1 % KILL_RING_SZ; + + if (curr->allocated) { + free(curr->text); + } + + struct text_chunk txt = + text_get_region(buffer->text, region.begin.line, region.begin.col, + region.end.line, region.end.col); + *curr = txt; + return curr; +} + +void buffer_copy(struct buffer_view *view) { + if (buffer_region_has_size(view)) { + struct region reg = buffer_get_region(view); + struct text_chunk *curr = copy_region(view->buffer, reg); + buffer_clear_mark(view); + } +} + +void paste(struct buffer_view *view, uint32_t ring_idx) { + if (ring_idx > 0) { + struct text_chunk *curr = &g_kill_ring.buffer[ring_idx - 1]; + if (curr->text != NULL) { + g_kill_ring.last_paste = view->mark_set ? view->mark : view->dot; + buffer_add_text(view, curr->text, curr->nbytes); + g_kill_ring.paste_up_to_date = true; + } + } +} + +void buffer_paste(struct buffer_view *view) { + g_kill_ring.paste_idx = g_kill_ring.curr_idx; + paste(view, g_kill_ring.curr_idx); +} + +void buffer_paste_older(struct buffer_view *view) { + if (g_kill_ring.paste_up_to_date) { + + // remove previous paste + struct text_chunk *curr = &g_kill_ring.buffer[g_kill_ring.curr_idx]; + delete_with_undo(view->buffer, g_kill_ring.last_paste, view->dot); + + // place ourselves right + view->dot = g_kill_ring.last_paste; + + // paste older + if (g_kill_ring.paste_idx - 1 > 0) { + --g_kill_ring.paste_idx; + } else { + g_kill_ring.paste_idx = g_kill_ring.curr_idx; + } + + paste(view, g_kill_ring.paste_idx); + + } else { + buffer_paste(view); + } +} + +void buffer_cut(struct buffer_view *view) { + if (buffer_region_has_size(view)) { + struct region reg = buffer_get_region(view); + copy_region(view->buffer, reg); + delete_with_undo(view->buffer, reg.begin, reg.end); + buffer_clear_mark(view); + view->dot = reg.begin; + } +} + +bool maybe_delete_region(struct buffer_view *view) { + if (buffer_region_has_size(view)) { + struct region reg = buffer_get_region(view); + delete_with_undo(view->buffer, reg.begin, reg.end); + buffer_clear_mark(view); + view->dot = reg.begin; + return true; + } + + return false; +} + +void buffer_kill_line(struct buffer_view *view) { + uint32_t nchars = + text_line_length(view->buffer->text, view->dot.line) - view->dot.col; + if (nchars == 0) { + nchars = 1; + } + + struct region reg = { + .begin = view->dot, + .end = + { + .line = view->dot.line, + .col = view->dot.col + nchars, + }, + }; + copy_region(view->buffer, reg); + delete_with_undo(view->buffer, view->dot, + (struct buffer_location){ + .line = view->dot.line, + .col = view->dot.col + nchars, + }); +} + +void buffer_forward_delete_char(struct buffer_view *view) { + if (maybe_delete_region(view)) { + return; + } + + delete_with_undo(view->buffer, view->dot, + (struct buffer_location){ + .line = view->dot.line, + .col = view->dot.col + 1, + }); +} + +void buffer_backward_delete_char(struct buffer_view *view) { + if (maybe_delete_region(view)) { + return; + } + + if (moveh(view, -1)) { + buffer_forward_delete_char(view); + } +} + +void buffer_backward_char(struct buffer_view *view) { moveh(view, -1); } +void buffer_forward_char(struct buffer_view *view) { moveh(view, 1); } + +struct buffer_location find_next(struct buffer_view *view, uint8_t chars[], + uint32_t nchars, int direction) { + struct text_chunk line = text_get_line(view->buffer->text, view->dot.line); + int64_t bytei = + text_col_to_byteindex(view->buffer->text, view->dot.line, view->dot.col); + while (bytei < line.nbytes && bytei > 0 && + (line.text[bytei] == ' ' || line.text[bytei] == '.')) { + bytei += direction; + } + + for (; bytei < line.nbytes && bytei > 0; bytei += direction) { + uint8_t b = line.text[bytei]; + if (b == ' ' || b == '.') { + break; + } + } + + uint32_t target_col = + text_byteindex_to_col(view->buffer->text, view->dot.line, bytei); + return (struct buffer_location){.line = view->dot.line, .col = target_col}; +} + +void buffer_forward_word(struct buffer_view *view) { + moveh(view, 1); + uint8_t chars[] = {' ', '.'}; + view->dot = find_next(view, chars, 2, 1); +} + +void buffer_backward_word(struct buffer_view *view) { + moveh(view, -1); + uint8_t chars[] = {' ', '.'}; + view->dot = find_next(view, chars, 2, -1); +} + +void buffer_backward_line(struct buffer_view *view) { movev(view, -1); } +void buffer_forward_line(struct buffer_view *view) { movev(view, 1); } + +void buffer_end_of_line(struct buffer_view *view) { + view->dot.col = text_line_length(view->buffer->text, view->dot.line); +} + +void buffer_beginning_of_line(struct buffer_view *view) { view->dot.col = 0; } + +struct buffer buffer_from_file(char *filename) { + struct buffer b = buffer_create(basename((char *)filename)); + b.filename = strdup(filename); + if (access(b.filename, F_OK) == 0) { + FILE *file = fopen(filename, "r"); + + if (file == NULL) { + minibuffer_echo("Error opening %s: %s", filename, strerror(errno)); + return b; + } + + while (true) { + uint8_t buff[4096]; + int bytes = fread(buff, 1, 4096, file); + if (bytes > 0) { + uint32_t ignore; + text_append(b.text, buff, bytes, &ignore, &ignore); + } else if (bytes == 0) { + break; // EOF + } else { + minibuffer_echo("error reading from %s: %s", filename, strerror(errno)); + fclose(file); + return b; + } + } + + fclose(file); + } + + const char *ext = strrchr(b.filename, '.'); + if (ext != NULL) { + b.lang = lang_from_extension(ext + 1); + } + undo_push_boundary(&b.undo, (struct undo_boundary){.save_point = true}); + return b; +} + +void write_line(struct text_chunk *chunk, void *userdata) { + FILE *file = (FILE *)userdata; + fwrite(chunk->text, 1, chunk->nbytes, file); + + // final newline is not optional! + fputc('\n', file); +} + +void buffer_to_file(struct buffer *buffer) { + if (!buffer->filename) { + minibuffer_echo("buffer \"%s\" is not associated with a file", + buffer->name); + return; + } + + if (!buffer->modified) { + minibuffer_echo_timeout(4, "buffer already saved"); + return; + } + + FILE *file = fopen(buffer->filename, "w"); + if (file == NULL) { + minibuffer_echo("failed to open file %s for writing: %s", buffer->filename, + strerror(errno)); + return; + } + + uint32_t nlines = text_num_lines(buffer->text); + struct text_chunk lastline = text_get_line(buffer->text, nlines - 1); + uint32_t nlines_to_write = lastline.nbytes == 0 ? nlines - 1 : nlines; + + text_for_each_line(buffer->text, 0, nlines_to_write, write_line, file); + minibuffer_echo_timeout(4, "wrote %d lines to %s", nlines_to_write, + buffer->filename); + fclose(file); + + buffer->modified = false; + undo_push_boundary(&buffer->undo, (struct undo_boundary){.save_point = true}); +} + +void buffer_write_to(struct buffer *buffer, const char *filename) { + buffer->filename = strdup(filename); + buffer_to_file(buffer); +} + +struct search_data { + VEC(struct match) matches; + const char *pattern; +}; + +// TODO: maybe should live in text +void search_line(struct text_chunk *chunk, void *userdata) { + struct search_data *data = (struct search_data *)userdata; + size_t pattern_len = strlen(data->pattern); + uint32_t pattern_nchars = utf8_nchars((uint8_t *)data->pattern, pattern_len); + + char *line = malloc(chunk->nbytes + 1); + memcpy(line, chunk->text, chunk->nbytes); + line[chunk->nbytes] = '\0'; + char *hit = NULL; + uint32_t byteidx = 0; + while ((hit = strstr(line + byteidx, data->pattern)) != NULL) { + byteidx = hit - line; + uint32_t begin = utf8_nchars(chunk->text, byteidx); + struct match match = (struct match){ + .begin = {.col = begin, .line = chunk->line}, + .end = {.col = begin + pattern_nchars, .line = chunk->line}, + }; + + VEC_PUSH(&data->matches, match); + + // proceed to after match + byteidx += pattern_len; + } +} + +void buffer_find(struct buffer *buffer, const char *pattern, + struct match **matches, uint32_t *nmatches) { + + struct search_data data = (struct search_data){.pattern = pattern}; + VEC_INIT(&data.matches, 16); + text_for_each_line(buffer->text, 0, text_num_lines(buffer->text), search_line, + &data); + + *matches = VEC_ENTRIES(&data.matches); + *nmatches = VEC_SIZE(&data.matches); +} + +void buffer_set_text(struct buffer *buffer, uint8_t *text, uint32_t nbytes) { + text_clear(buffer->text); + uint32_t lines, cols; + text_append(buffer->text, text, nbytes, &lines, &cols); +} + +int buffer_add_text(struct buffer_view *view, uint8_t *text, uint32_t nbytes) { + if (view->buffer->readonly) { + minibuffer_echo_timeout(4, "buffer is read-only"); + return 0; + } + + // invalidate last paste + g_kill_ring.paste_up_to_date = false; + + /* If we currently have a selection active, + * replace it with the text to insert. */ + maybe_delete_region(view); + + struct buffer_location initial = view->dot; + + uint32_t lines_added, cols_added; + text_insert_at(view->buffer->text, initial.line, initial.col, text, nbytes, + &lines_added, &cols_added); + + // move to after inserted text + movev(view, lines_added); + if (lines_added > 0) { + // does not make sense to use position from another line + view->dot.col = 0; + } + moveh(view, cols_added); + + struct buffer_location final = view->dot; + undo_push_add( + &view->buffer->undo, + (struct undo_add){.begin = {.row = initial.line, .col = initial.col}, + .end = {.row = final.line, .col = final.col}}); + + if (lines_added > 0) { + undo_push_boundary(&view->buffer->undo, + (struct undo_boundary){.save_point = false}); + } + + view->buffer->modified = true; + return lines_added; +} + +void buffer_newline(struct buffer_view *view) { + buffer_add_text(view, (uint8_t *)"\n", 1); +} + +void buffer_indent(struct buffer_view *view) { + uint32_t tab_width = view->buffer->lang.tab_width; + buffer_add_text(view, (uint8_t *)" ", + tab_width > 16 ? 16 : tab_width); +} + +uint32_t buffer_add_update_hook(struct buffer *buffer, update_hook_cb hook, + void *userdata) { + struct update_hook *h = + &buffer->update_hooks.hooks[buffer->update_hooks.nhooks]; + h->callback = hook; + h->userdata = userdata; + + ++buffer->update_hooks.nhooks; + + // TODO: cant really have this if we actually want to remove a hook + return buffer->update_hooks.nhooks - 1; +} + +void buffer_set_mark(struct buffer_view *view) { + view->mark_set ? buffer_clear_mark(view) + : buffer_set_mark_at(view, view->dot.line, view->dot.col); +} + +void buffer_clear_mark(struct buffer_view *view) { + view->mark_set = false; + minibuffer_echo_timeout(2, "mark cleared"); +} + +void buffer_set_mark_at(struct buffer_view *view, uint32_t line, uint32_t col) { + view->mark_set = true; + view->mark.line = line; + view->mark.col = col; + minibuffer_echo_timeout(2, "mark set"); +} + +void buffer_undo(struct buffer_view *view) { + struct undo_stack *undo = &view->buffer->undo; + undo_begin(undo); + + // fetch and handle records + struct undo_record *records = NULL; + uint32_t nrecords = 0; + + if (undo_current_position(undo) == INVALID_TOP) { + minibuffer_echo_timeout(4, + "no more undo information, starting from top..."); + } + + undo_next(undo, &records, &nrecords); + + undo_push_boundary(undo, (struct undo_boundary){.save_point = false}); + for (uint32_t reci = 0; reci < nrecords; ++reci) { + struct undo_record *rec = &records[reci]; + switch (rec->type) { + case Undo_Boundary: { + struct undo_boundary *b = &rec->boundary; + if (b->save_point) { + view->buffer->modified = false; + } + break; + } + case Undo_Add: { + struct undo_add *add = &rec->add; + + delete_with_undo(view->buffer, + (struct buffer_location){ + .line = add->begin.row, + .col = add->begin.col, + }, + (struct buffer_location){ + .line = add->end.row, + .col = add->end.col, + }); + + buffer_goto(view, add->begin.row, add->begin.col); + break; + } + case Undo_Delete: { + struct undo_delete *del = &rec->delete; + buffer_goto(view, del->pos.row, del->pos.col); + buffer_add_text(view, del->data, del->nbytes); + break; + } + } + } + undo_push_boundary(undo, (struct undo_boundary){.save_point = false}); + + free(records); + undo_end(undo); +} + +struct cmdbuf { + struct command_list *cmds; + struct buffer_location scroll; + uint32_t line_offset; + uint32_t left_margin; + uint32_t width; + + struct region region; + bool mark_set; + + bool show_ws; + + struct line_render_hook *line_render_hooks; + uint32_t nlinerender_hooks; +}; + +void render_line(struct text_chunk *line, void *userdata) { + struct cmdbuf *cmdbuf = (struct cmdbuf *)userdata; + uint32_t visual_line = line->line - cmdbuf->scroll.line + cmdbuf->line_offset; + + for (uint32_t hooki = 0; hooki < cmdbuf->nlinerender_hooks; ++hooki) { + struct line_render_hook *hook = &cmdbuf->line_render_hooks[hooki]; + hook->callback(line, visual_line, cmdbuf->cmds, hook->userdata); + } + + uint32_t scroll_bytes = + utf8_nbytes(line->text, line->nbytes, cmdbuf->scroll.col); + uint32_t text_nbytes_scroll = + scroll_bytes > line->nbytes ? 0 : line->nbytes - scroll_bytes; + uint8_t *text = line->text + scroll_bytes; + + // calculate how many chars we can fit in 'width' + uint32_t linewidth = cmdbuf->left_margin; + uint32_t text_nbytes = 0; + for (uint32_t bytei = 0; + bytei < text_nbytes_scroll && linewidth < cmdbuf->width; ++bytei) { + uint8_t *txt = &text[bytei]; + if (*txt == '\t') { + linewidth += 3; + } else if (utf8_byte_is_unicode_start(*txt)) { + wchar_t wc; + if (mbrtowc(&wc, (char *)txt, 6, NULL) >= 0) { + linewidth += wcwidth(wc) - 1; + } + } + + ++linewidth; + ++text_nbytes; + } + + command_list_set_show_whitespace(cmdbuf->cmds, cmdbuf->show_ws); + struct buffer_location *begin = &cmdbuf->region.begin, + *end = &cmdbuf->region.end; + + // should we draw region? + if (cmdbuf->mark_set && line->line >= begin->line && + line->line <= end->line) { + uint32_t byte_offset = 0; + uint32_t col_offset = 0; + + // draw any text on the line that should not be part of region + if (begin->line == line->line) { + if (begin->col > cmdbuf->scroll.col) { + uint32_t nbytes = + utf8_nbytes(text, text_nbytes, begin->col - cmdbuf->scroll.col); + command_list_draw_text(cmdbuf->cmds, cmdbuf->left_margin, visual_line, + text, nbytes); + + byte_offset += nbytes; + } + + col_offset = begin->col - cmdbuf->scroll.col; + } + + // activate region color + command_list_set_index_color_bg(cmdbuf->cmds, 5); + + // draw any text on line that should be part of region + if (end->line == line->line) { + if (end->col > cmdbuf->scroll.col) { + uint32_t nbytes = + utf8_nbytes(text + byte_offset, text_nbytes - byte_offset, + end->col - col_offset - cmdbuf->scroll.col); + command_list_draw_text(cmdbuf->cmds, cmdbuf->left_margin + col_offset, + visual_line, text + byte_offset, nbytes); + byte_offset += nbytes; + } + + col_offset = end->col - cmdbuf->scroll.col; + command_list_reset_color(cmdbuf->cmds); + } + + // draw rest of line + if (text_nbytes - byte_offset > 0) { + command_list_draw_text(cmdbuf->cmds, cmdbuf->left_margin + col_offset, + visual_line, text + byte_offset, + text_nbytes - byte_offset); + } + + // done rendering region + command_list_reset_color(cmdbuf->cmds); + + } else { + command_list_draw_text(cmdbuf->cmds, cmdbuf->left_margin, visual_line, text, + text_nbytes); + } + + command_list_set_show_whitespace(cmdbuf->cmds, false); + + if (linewidth < cmdbuf->width) { + command_list_draw_repeated(cmdbuf->cmds, linewidth, visual_line, ' ', + cmdbuf->width - linewidth); + } +} + +void scroll(struct buffer_view *view, int line_delta, int col_delta) { + uint32_t nlines = text_num_lines(view->buffer->text); + int64_t new_line = (int64_t)view->scroll.line + line_delta; + if (new_line >= 0 && new_line < nlines) { + view->scroll.line = (uint32_t)new_line; + } else if (new_line < 0) { + view->scroll.line = 0; + } + + int64_t new_col = (int64_t)view->scroll.col + col_delta; + if (new_col >= 0 && + new_col < text_line_length(view->buffer->text, view->dot.line)) { + view->scroll.col = (uint32_t)new_col; + } else if (new_col < 0) { + view->scroll.col = 0; + } +} + +void to_relative(struct buffer_view *view, uint32_t line, uint32_t col, + int64_t *rel_line, int64_t *rel_col) { + *rel_col = (int64_t)col - (int64_t)view->scroll.col; + *rel_line = (int64_t)line - (int64_t)view->scroll.line; +} + +uint32_t visual_dot_col(struct buffer_view *view, uint32_t dot_col) { + uint32_t visual_dot_col = dot_col; + struct text_chunk line = text_get_line(view->buffer->text, view->dot.line); + for (uint32_t bytei = 0; + bytei < + text_col_to_byteindex(view->buffer->text, view->dot.line, view->dot.col); + ++bytei) { + if (line.text[bytei] == '\t') { + visual_dot_col += 3; + } else if (utf8_byte_is_unicode_start(line.text[bytei])) { + wchar_t wc; + if (mbrtowc(&wc, (char *)line.text + bytei, 6, NULL) >= 0) { + visual_dot_col += wcwidth(wc) - 1; + } + } + } + + return visual_dot_col; +} + +void render_modeline(struct modeline *modeline, struct buffer_view *view, + struct command_list *commands, uint32_t width, + uint32_t height, uint64_t frame_time) { + char buf[width * 4]; + + static uint64_t samples[10] = {0}; + static uint32_t samplei = 0; + static uint64_t avg = 0; + + // calc a moving average with a window of the last 10 frames + ++samplei; + samplei %= 10; + avg += 0.1 * (frame_time - samples[samplei]); + samples[samplei] = frame_time; + + time_t now = time(NULL); + struct tm *lt = localtime(&now); + char left[128], right[128]; + + snprintf(left, 128, " %c%c %-16s (%d, %d) (%s)", + view->buffer->modified ? '*' : '-', + view->buffer->readonly ? '%' : '-', view->buffer->name, + view->dot.line + 1, visual_dot_col(view, view->dot.col), + view->buffer->lang.name); + snprintf(right, 128, "(%.2f ms) %02d:%02d", frame_time / 1e6, lt->tm_hour, + lt->tm_min); + + snprintf(buf, width * 4, "%s%*s%s", left, + (int)(width - (strlen(left) + strlen(right))), "", right); + + if (strcmp(buf, (char *)modeline->buffer) != 0) { + modeline->buffer = realloc(modeline->buffer, width * 4); + modeline->sz = width * 4; + strcpy((char *)modeline->buffer, buf); + } + + command_list_set_index_color_bg(commands, 8); + command_list_draw_text(commands, 0, height - 1, modeline->buffer, + strlen((char *)modeline->buffer)); + command_list_reset_color(commands); +} + +struct linenumdata { + uint32_t longest_nchars; + uint32_t dot_line; +} linenum_data; + +void linenum_render_hook(struct text_chunk *line_data, uint32_t line, + struct command_list *commands, void *userdata) { + struct linenumdata *data = (struct linenumdata *)userdata; + static char buf[16]; + command_list_set_index_color_bg(commands, 236); + command_list_set_index_color_fg( + commands, line_data->line == data->dot_line ? 253 : 244); + uint32_t chars = + snprintf(buf, 16, "%*d", data->longest_nchars + 1, line_data->line + 1); + command_list_draw_text_copy(commands, 0, line, (uint8_t *)buf, chars); + command_list_reset_color(commands); + command_list_draw_text(commands, data->longest_nchars + 1, line, + (uint8_t *)" ", 1); +} + +void clear_empty_linenum_lines(uint32_t line, struct command_list *commands, + void *userdata) { + struct linenumdata *data = (struct linenumdata *)userdata; + uint32_t longest_nchars = data->longest_nchars; + command_list_draw_repeated(commands, 0, line, ' ', longest_nchars + 2); +} + +uint32_t longest_linenum(struct buffer *buffer) { + uint32_t total_lines = text_num_lines(buffer->text); + uint32_t longest_nchars = 10; + if (total_lines < 10) { + longest_nchars = 1; + } else if (total_lines < 100) { + longest_nchars = 2; + } else if (total_lines < 1000) { + longest_nchars = 3; + } else if (total_lines < 10000) { + longest_nchars = 4; + } else if (total_lines < 100000) { + longest_nchars = 5; + } else if (total_lines < 1000000) { + longest_nchars = 6; + } else if (total_lines < 10000000) { + longest_nchars = 7; + } else if (total_lines < 100000000) { + longest_nchars = 8; + } else if (total_lines < 1000000000) { + longest_nchars = 9; + } + + return longest_nchars; +} + +void buffer_update(struct buffer_view *view, uint32_t width, uint32_t height, + struct command_list *commands, uint64_t frame_time, + uint32_t *relline, uint32_t *relcol) { + if (width == 0 || height == 0) { + return; + } + + uint32_t total_width = width, total_height = height; + struct margin total_margins = {0}; + struct line_render_hook line_hooks[16 + 1]; + uint32_t nlinehooks = 0; + for (uint32_t hooki = 0; hooki < view->buffer->update_hooks.nhooks; ++hooki) { + struct update_hook *h = &view->buffer->update_hooks.hooks[hooki]; + struct update_hook_result res = + h->callback(view, commands, width, height, frame_time, h->userdata); + + if (res.line_render_hook.callback != NULL) { + line_hooks[nlinehooks] = res.line_render_hook; + ++nlinehooks; + } + + total_margins.left += res.margins.left; + total_margins.right += res.margins.right; + total_margins.bottom += res.margins.bottom; + total_margins.top += res.margins.top; + + height -= total_margins.top + total_margins.bottom; + width -= total_margins.left + total_margins.right; + } + + if (view->line_numbers) { + linenum_data.longest_nchars = longest_linenum(view->buffer); + linenum_data.dot_line = view->dot.line; + line_hooks[nlinehooks].callback = linenum_render_hook; + line_hooks[nlinehooks].empty_callback = clear_empty_linenum_lines; + line_hooks[nlinehooks].userdata = &linenum_data; + ++nlinehooks; + + total_margins.left += linenum_data.longest_nchars + 2; + } + + if (view->modeline != NULL) { + render_modeline(view->modeline, view, commands, width, height, frame_time); + total_margins.bottom += 1; + } + + height -= total_margins.top + total_margins.bottom; + width -= total_margins.left + total_margins.right; + + int64_t rel_line, rel_col; + to_relative(view, view->dot.line, view->dot.col, &rel_line, &rel_col); + int line_delta = 0, col_delta = 0; + if (rel_line < 0) { + line_delta = rel_line - ((int)height / 2); + } else if (rel_line >= height) { + line_delta = (rel_line - height) + height / 2; + } + + if (rel_col < 0) { + col_delta = rel_col - ((int)width / 2); + } else if (rel_col >= width) { + col_delta = (rel_col - width) + width / 2; + } + + scroll(view, line_delta, col_delta); + + struct setting *show_ws = settings_get("editor.show-whitespace"); + + struct cmdbuf cmdbuf = (struct cmdbuf){ + .cmds = commands, + .scroll = view->scroll, + .left_margin = total_margins.left, + .width = total_width, + .line_offset = total_margins.top, + .line_render_hooks = line_hooks, + .nlinerender_hooks = nlinehooks, + .mark_set = view->mark_set, + .region = to_region(view->dot, view->mark), + .show_ws = show_ws != NULL ? show_ws->value.bool_value : true, + }; + text_for_each_line(view->buffer->text, view->scroll.line, height, render_line, + &cmdbuf); + + // draw empty lines + uint32_t nlines = text_num_lines(view->buffer->text); + for (uint32_t linei = nlines - view->scroll.line + total_margins.top; + linei < height; ++linei) { + + for (uint32_t hooki = 0; hooki < nlinehooks; ++hooki) { + struct line_render_hook *hook = &line_hooks[hooki]; + hook->empty_callback(linei, commands, hook->userdata); + } + + command_list_draw_repeated(commands, total_margins.left, linei, ' ', + total_width - total_margins.left); + } + + // update the visual cursor position + to_relative(view, view->dot.line, view->dot.col, &rel_line, &rel_col); + uint32_t visual_col = visual_dot_col(view, view->dot.col); + to_relative(view, view->dot.line, visual_col, &rel_line, &rel_col); + + *relline = rel_line < 0 ? 0 : (uint32_t)rel_line + total_margins.top; + *relcol = rel_col < 0 ? 0 : (uint32_t)rel_col + total_margins.left; +} + +struct text_chunk buffer_get_line(struct buffer *buffer, uint32_t line) { + return text_get_line(buffer->text, line); +} + +void buffer_view_scroll_down(struct buffer_view *view, uint32_t height) { + buffer_goto(view, view->dot.line + height, view->dot.col); + scroll(view, height, 0); +} +void buffer_view_scroll_up(struct buffer_view *view, uint32_t height) { + buffer_goto(view, view->dot.line - height, view->dot.col); + scroll(view, -height, 0); +} diff --git a/src/dged/buffer.h b/src/dged/buffer.h new file mode 100644 index 0000000..539c427 --- /dev/null +++ b/src/dged/buffer.h @@ -0,0 +1,219 @@ +#include <stddef.h> +#include <stdint.h> +#include <stdio.h> + +#include "bits/stdint-uintn.h" +#include "command.h" +#include "lang.h" +#include "text.h" +#include "undo.h" +#include "window.h" + +struct keymap; +struct command_list; + +/** + * Margins where buffer text should not be + */ +struct margin { + uint32_t left; + uint32_t right; + uint32_t top; + uint32_t bottom; +}; + +/** Callback for line rendering hooks */ +typedef void (*line_render_cb)(struct text_chunk *line_data, uint32_t line, + struct command_list *commands, void *userdata); + +typedef void (*line_render_empty_cb)(uint32_t line, + struct command_list *commands, + void *userdata); + +/** + * A line render hook + * + * A callback paired with userdata + */ +struct line_render_hook { + line_render_cb callback; + line_render_empty_cb empty_callback; + void *userdata; +}; + +/** + * Result of updating a buffer hook + */ +struct update_hook_result { + /** Desired margins for this hook */ + struct margin margins; + + /** Hook to be added to rendering of buffer lines */ + struct line_render_hook line_render_hook; +}; + +/** Buffer update hook callback function */ +typedef struct update_hook_result (*update_hook_cb)( + struct buffer_view *view, struct command_list *commands, uint32_t width, + uint32_t height, uint64_t frame_time, void *userdata); + +/** + * A buffer update hook. + * + * Can be used to implement custom behavior on top of a buffer. Used for + * minibuffer, line numbers, modeline etc. + */ +struct update_hook { + /** Callback function */ + update_hook_cb callback; + + /** Optional userdata to pass to the callback function unmodified */ + void *userdata; +}; + +typedef void (*create_hook_cb)(struct buffer *buffer, void *userdata); + +/** + * A set of update hooks + */ +struct update_hooks { + /** The update hooks */ + struct update_hook hooks[32]; + + /** The number of update hooks */ + uint32_t nhooks; +}; + +struct buffer_location { + uint32_t line; + uint32_t col; +}; + +struct match { + struct buffer_location begin; + struct buffer_location end; +}; + +struct buffer_view { + /** Location of dot (cursor) */ + struct buffer_location dot; + + /** Location of mark (where a selection starts) */ + struct buffer_location mark; + + /** Current buffer scroll position */ + struct buffer_location scroll; + + /** True if the start of a selection has been set */ + bool mark_set; + + /** Modeline buffer (may be NULL) */ + struct modeline *modeline; + + bool line_numbers; + + struct buffer *buffer; +}; + +struct buffer_view buffer_view_create(struct buffer *buffer, bool modeline, + bool line_numbers); +struct buffer_view buffer_view_clone(struct buffer_view *view); + +void buffer_view_scroll_down(struct buffer_view *view, uint32_t height); +void buffer_view_scroll_up(struct buffer_view *view, uint32_t height); + +void buffer_view_destroy(struct buffer_view *view); + +/** + * A buffer of text that can be modified, read from and written to disk. + * + * This is the central data structure of dged and most other behavior is + * implemented on top of it. + */ +struct buffer { + + /** Buffer name */ + char *name; + + /** Associated filename, this is where the buffer will be saved to */ + char *filename; + + /** Text data structure */ + struct text *text; + + /** Buffer update hooks */ + struct update_hooks update_hooks; + + /** Buffer undo stack */ + struct undo_stack undo; + + /** Has this buffer been modified from when it was last saved */ + bool modified; + + /** Can this buffer be changed */ + bool readonly; + + /** Buffer programming language */ + struct language lang; +}; + +struct buffer buffer_create(char *name); +void buffer_destroy(struct buffer *buffer); + +void buffer_static_init(); +void buffer_static_teardown(); + +int buffer_add_text(struct buffer_view *view, uint8_t *text, uint32_t nbytes); +void buffer_set_text(struct buffer *buffer, uint8_t *text, uint32_t nbytes); +void buffer_clear(struct buffer_view *view); +bool buffer_is_empty(struct buffer *buffer); +bool buffer_is_modified(struct buffer *buffer); +bool buffer_is_readonly(struct buffer *buffer); +void buffer_set_readonly(struct buffer *buffer, bool readonly); + +void buffer_kill_line(struct buffer_view *view); +void buffer_forward_delete_char(struct buffer_view *view); +void buffer_backward_delete_char(struct buffer_view *view); +void buffer_backward_char(struct buffer_view *view); +void buffer_backward_word(struct buffer_view *view); +void buffer_forward_char(struct buffer_view *view); +void buffer_forward_word(struct buffer_view *view); +void buffer_backward_line(struct buffer_view *view); +void buffer_forward_line(struct buffer_view *view); +void buffer_end_of_line(struct buffer_view *view); +void buffer_beginning_of_line(struct buffer_view *view); +void buffer_newline(struct buffer_view *view); +void buffer_indent(struct buffer_view *view); + +void buffer_undo(struct buffer_view *view); + +void buffer_goto_beginning(struct buffer_view *view); +void buffer_goto_end(struct buffer_view *view); +void buffer_goto(struct buffer_view *view, uint32_t line, uint32_t col); + +void buffer_find(struct buffer *buffer, const char *pattern, + struct match **matches, uint32_t *nmatches); + +void buffer_set_mark(struct buffer_view *view); +void buffer_clear_mark(struct buffer_view *view); +void buffer_set_mark_at(struct buffer_view *view, uint32_t line, uint32_t col); + +void buffer_copy(struct buffer_view *view); +void buffer_paste(struct buffer_view *view); +void buffer_paste_older(struct buffer_view *view); +void buffer_cut(struct buffer_view *view); + +struct text_chunk buffer_get_line(struct buffer *buffer, uint32_t line); + +uint32_t buffer_add_update_hook(struct buffer *buffer, update_hook_cb hook, + void *userdata); + +uint32_t buffer_add_create_hook(create_hook_cb hook, void *userdata); + +struct buffer buffer_from_file(char *filename); +void buffer_to_file(struct buffer *buffer); +void buffer_write_to(struct buffer *buffer, const char *filename); + +void buffer_update(struct buffer_view *view, uint32_t width, uint32_t height, + struct command_list *commands, uint64_t frame_time, + uint32_t *relline, uint32_t *relcol); diff --git a/src/dged/buffers.c b/src/dged/buffers.c new file mode 100644 index 0000000..38b51b7 --- /dev/null +++ b/src/dged/buffers.c @@ -0,0 +1,43 @@ +#include "buffers.h" +#include "buffer.h" + +#include <stdlib.h> +#include <string.h> + +void buffers_init(struct buffers *buffers, uint32_t initial_capacity) { + buffers->buffers = calloc(initial_capacity, sizeof(struct buffer)); + buffers->nbuffers = 0; + buffers->capacity = initial_capacity; +} + +struct buffer *buffers_add(struct buffers *buffers, struct buffer buffer) { + if (buffers->nbuffers == buffers->capacity) { + buffers->capacity *= 2; + buffers->buffers = + realloc(buffers->buffers, sizeof(struct buffer) * buffers->capacity); + } + + buffers->buffers[buffers->nbuffers] = buffer; + ++buffers->nbuffers; + + return &buffers->buffers[buffers->nbuffers - 1]; +} + +struct buffer *buffers_find(struct buffers *buffers, const char *name) { + for (uint32_t bufi = 0; bufi < buffers->nbuffers; ++bufi) { + if (strcmp(name, buffers->buffers[bufi].name) == 0) { + return &buffers->buffers[bufi]; + } + } + + return NULL; +} + +void buffers_destroy(struct buffers *buffers) { + for (uint32_t bufi = 0; bufi < buffers->nbuffers; ++bufi) { + buffer_destroy(&buffers->buffers[bufi]); + } + + buffers->nbuffers = 0; + free(buffers->buffers); +} diff --git a/src/dged/buffers.h b/src/dged/buffers.h new file mode 100644 index 0000000..edf772c --- /dev/null +++ b/src/dged/buffers.h @@ -0,0 +1,17 @@ +#include <stdint.h> + +struct buffer; + +struct buffers { + // TODO: more buffers + struct buffer *buffers; + uint32_t nbuffers; + uint32_t capacity; +}; + +void buffers_init(struct buffers *buffers, uint32_t initial_capacity); + +struct buffer *buffers_add(struct buffers *buffers, struct buffer buffer); +struct buffer *buffers_find(struct buffers *buffers, const char *name); + +void buffers_destroy(struct buffers *buffers); diff --git a/src/dged/command.c b/src/dged/command.c new file mode 100644 index 0000000..9144058 --- /dev/null +++ b/src/dged/command.c @@ -0,0 +1,79 @@ +#include "command.h" +#include "buffer.h" +#include "buffers.h" +#include "hash.h" +#include "hashmap.h" +#include "minibuffer.h" + +#include <string.h> + +struct commands command_registry_create(uint32_t capacity) { + + struct commands cmds = {0}; + HASHMAP_INIT(&cmds.commands, capacity, hash_name); + return cmds; +} + +void command_registry_destroy(struct commands *commands) { + HASHMAP_DESTROY(&commands->commands); +} + +uint32_t register_command(struct commands *commands, struct command command) { + uint32_t hash = 0; + HASHMAP_INSERT(&commands->commands, struct command_entry, command.name, + command, hash); + return hash; +} + +void register_commands(struct commands *command_list, struct command *commands, + uint32_t ncommands) { + for (uint32_t ci = 0; ci < ncommands; ++ci) { + register_command(command_list, commands[ci]); + } +} + +struct command *lookup_command(struct commands *command_list, + const char *name) { + HASHMAP_GET(&command_list->commands, struct command_entry, name, + struct command * command); + return command; +} + +struct command *lookup_command_by_hash(struct commands *commands, + uint32_t hash) { + HASHMAP_GET_BY_HASH(&commands->commands, struct command_entry, hash, + struct command * command); + return command; +} + +int32_t execute_command(struct command *command, struct commands *commands, + struct window *active_window, struct buffers *buffers, + int argc, const char *argv[]) { + + return command->fn( + (struct command_ctx){ + .buffers = buffers, + .active_window = active_window, + .userdata = command->userdata, + .commands = commands, + .self = command, + .saved_argv = {0}, + .saved_argc = 0, + }, + argc, argv); +} + +void command_ctx_push_arg(struct command_ctx *ctx, const char *argv) { + if (ctx->saved_argc < 64) { + ctx->saved_argv[ctx->saved_argc] = strdup(argv); + ++ctx->saved_argc; + } +} + +void command_ctx_free(struct command_ctx *ctx) { + for (uint32_t i = 0; i < ctx->saved_argc; ++i) { + free((char *)ctx->saved_argv[i]); + } + + ctx->saved_argc = 0; +} diff --git a/src/dged/command.h b/src/dged/command.h new file mode 100644 index 0000000..bbc57f2 --- /dev/null +++ b/src/dged/command.h @@ -0,0 +1,179 @@ +#ifndef _COMMAND_H +#define _COMMAND_H + +/** @file command.h + * Commands and command registries + */ +#include "hashmap.h" +#include <stdint.h> + +struct buffer; +struct buffers; +struct window; + +/** + * Execution context for a command + */ +struct command_ctx { + /** + * The current list of buffers. + * + * Can be used to insert new buffers or + * inspect existing. + */ + struct buffers *buffers; + + /** + * The currently active window. + */ + struct window *active_window; + + /** + * A registry of available commands. + * + * Can be used to execute other commands as part of a command implementation. + */ + struct commands *commands; + + /** + * The command that is currently being executed + */ + struct command *self; + + /** + * User data set up by the command currently being executed. + */ + void *userdata; + + const char *saved_argv[64]; + + int saved_argc; +}; + +/** A command function callback which holds the implementation of a command */ +typedef int32_t (*command_fn)(struct command_ctx ctx, int argc, + const char *argv[]); + +/** + * A command that can be bound to a key or executed directly + */ +struct command { + /** + * Name of the command + * + * Used to look the command up for execution and keybinds. + */ + const char *name; + + /** + * Implementation of command behavior + */ + command_fn fn; + + /** + * Userdata passed to each invocation of the command. + */ + void *userdata; +}; + +/** + * A command registry + */ +HASHMAP_ENTRY_TYPE(command_entry, struct command); + +struct commands { + HASHMAP(struct command_entry) commands; +}; + +/** + * Create a new command registry. + * + * @param[in] capacity The initial capacity for the registry + */ +struct commands command_registry_create(uint32_t capacity); + +/** + * Destroy a command registry. + * + * This will free all memory associated with stored commands. + * @param[in] commands A pointer to a commands structure created by @ref + * command_registry_create(uint32_t) + */ +void command_registry_destroy(struct commands *commands); + +/** + * Register a new command in the registry @ref commands. + * + * @param[in] commands The registry to insert into + * @param[in] command The command to insert + */ +uint32_t register_command(struct commands *commands, struct command command); + +/** + * Register multiple commands in the registry @ref commands "command_list". + * + * @param[in] command_list The registry to insert into + * @param[in] commands The commands to insert + * @param[in] ncommands Number of commands contained in @ref commands + */ +void register_commands(struct commands *command_list, struct command *commands, + uint32_t ncommands); + +/** + * Execute a command and return the result. + * + * @param[in] command The @ref command to execute + * @param[in] commands A @ref command "command registry" to use for context in + * the executed command. Can for example be used to implement commands that + * execute arbitrary other commands. + * @param[in] active_window A @ref window representing the currently active + * window in the editor. This provides a way to access the current buffer as + * well. + * @param[in] buffers The current list of buffers for context. Can be used for + * example to create a buffer list. + * @param[in] argc Number of arguments to the command. + * @param[in] argv The arguments to the command. + * + * @returns Integer representing the exit status where 0 means success and + * anything else means there was an error. + */ +int32_t execute_command(struct command *command, struct commands *commands, + struct window *active_window, struct buffers *buffers, + int argc, const char *argv[]); + +/** + * Hash the name of a command. + * + * @param[in] name The command name + * @returns An integer representing the hash of the name + */ +uint32_t hash_command_name(const char *name); + +/** + * Lookup a command by name. + * + * @param[in] commands The @ref commands "command registry" to look for the @ref + * command in. + * @param[in] name The name of the command to look for + * @returns A pointer to the command if found, NULL otherwise. + */ +struct command *lookup_command(struct commands *commands, const char *name); + +/** + * Lookup a command by hash. + * + * The hash value is expected to have been computed with @ref + * hash_command_name(const char* name). + * + * @param[in] commands The @ref commands "command registry" to look for the @ref + * command in. + * @param[in] hash The hash value for the name of the command to look for + * @returns A pointer to the command if found, NULL otherwise. + */ +struct command *lookup_command_by_hash(struct commands *commands, + uint32_t hash); + +void command_ctx_push_arg(struct command_ctx *ctx, const char *argv); +void command_ctx_free(struct command_ctx *ctx); + +#endif diff --git a/src/dged/display.c b/src/dged/display.c new file mode 100644 index 0000000..d9eeb11 --- /dev/null +++ b/src/dged/display.c @@ -0,0 +1,386 @@ +#define _DEFAULT_SOURCE +#include "display.h" + +#include "buffer.h" + +#include <stdarg.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <sys/ioctl.h> +#include <termios.h> +#include <unistd.h> + +#define ESC 0x1b + +struct display { + struct termios term; + struct termios orig_term; + uint32_t width; + uint32_t height; +}; + +enum render_cmd_type { + RenderCommand_DrawText = 0, + RenderCommand_PushFormat = 1, + RenderCommand_Repeat = 2, + RenderCommand_ClearFormat = 3, + RenderCommand_SetShowWhitespace = 4, +}; + +struct render_command { + enum render_cmd_type type; + union { + struct draw_text_cmd *draw_txt; + struct push_fmt_cmd *push_fmt; + struct repeat_cmd *repeat; + struct show_ws_cmd *show_ws; + }; +}; + +struct draw_text_cmd { + uint32_t col; + uint32_t row; + + uint8_t *data; + uint32_t len; +}; + +struct push_fmt_cmd { + uint8_t fmt[64]; + uint32_t len; +}; + +struct repeat_cmd { + uint32_t col; + uint32_t row; + uint8_t c; + uint32_t nrepeat; +}; + +struct show_ws_cmd { + bool show; +}; + +struct command_list { + struct render_command *cmds; + uint64_t ncmds; + uint64_t capacity; + + uint32_t xoffset; + uint32_t yoffset; + + void *(*allocator)(size_t); + + char name[16]; +}; + +struct winsize getsize() { + struct winsize ws; + ioctl(STDOUT_FILENO, TIOCGWINSZ, &ws); + return ws; +} + +struct display *display_create() { + + struct winsize ws = getsize(); + + // save old settings + struct termios orig_term; + tcgetattr(0, &orig_term); + + // set terminal to raw mode + struct termios term = {0}; + cfmakeraw(&term); + + tcsetattr(0, TCSADRAIN, &term); + + struct display *d = calloc(1, sizeof(struct display)); + d->orig_term = orig_term; + d->term = term; + d->height = ws.ws_row; + d->width = ws.ws_col; + return d; +} + +void display_resize(struct display *display) { + struct winsize sz = getsize(); + display->width = sz.ws_col; + display->height = sz.ws_row; +} + +void display_destroy(struct display *display) { + // reset old terminal mode + tcsetattr(0, TCSADRAIN, &display->orig_term); + + free(display); +} + +uint32_t display_width(struct display *display) { return display->width; } +uint32_t display_height(struct display *display) { return display->height; } + +void putbyte(uint8_t c) { + if (c != '\r') { + putc(c, stdout); + } +} + +void putbyte_ws(uint8_t c, bool show_whitespace) { + if (show_whitespace && c == '\t') { + fputs("\x1b[90m → \x1b[39m", stdout); + } else if (show_whitespace && c == ' ') { + fputs("\x1b[90m·\x1b[39m", stdout); + } else { + putbyte(c); + } +} + +void putbytes(uint8_t *line_bytes, uint32_t line_length, bool show_whitespace) { + for (uint32_t bytei = 0; bytei < line_length; ++bytei) { + uint8_t byte = line_bytes[bytei]; + putbyte_ws(byte, show_whitespace); + } +} + +void put_ansiparm(int n) { + int q = n / 10; + if (q != 0) { + int r = q / 10; + if (r != 0) { + putbyte((r % 10) + '0'); + } + putbyte((q % 10) + '0'); + } + putbyte((n % 10) + '0'); +} + +void display_move_cursor(struct display *display, uint32_t row, uint32_t col) { + putbyte(ESC); + putbyte('['); + put_ansiparm(row + 1); + putbyte(';'); + put_ansiparm(col + 1); + putbyte('H'); +} + +void display_clear(struct display *display) { + display_move_cursor(display, 0, 0); + uint8_t bytes[] = {ESC, '[', 'J'}; + putbytes(bytes, 3, false); +} + +struct command_list *command_list_create(uint32_t capacity, + void *(*allocator)(size_t), + uint32_t xoffset, uint32_t yoffset, + const char *name) { + struct command_list *command_list = allocator(sizeof(struct command_list)); + + command_list->capacity = capacity; + command_list->ncmds = 0; + command_list->xoffset = xoffset; + command_list->yoffset = yoffset; + strncpy(command_list->name, name, 15); + + command_list->cmds = allocator(sizeof(struct render_command) * capacity); + command_list->allocator = allocator; + + return command_list; +} + +struct render_command *add_command(struct command_list *list, + enum render_cmd_type tp) { + if (list->ncmds == list->capacity) { + /* TODO: better. Currently a bit tricky to provide dynamic scaling of this + * since it is initially allocated with the frame allocator that does not + * support realloc. + */ + return NULL; + } + + struct render_command *cmd = &list->cmds[list->ncmds]; + cmd->type = tp; + switch (tp) { + case RenderCommand_DrawText: + cmd->draw_txt = list->allocator(sizeof(struct draw_text_cmd)); + break; + case RenderCommand_Repeat: + cmd->repeat = list->allocator(sizeof(struct repeat_cmd)); + break; + case RenderCommand_PushFormat: + cmd->push_fmt = list->allocator(sizeof(struct push_fmt_cmd)); + break; + case RenderCommand_SetShowWhitespace: + cmd->show_ws = list->allocator(sizeof(struct show_ws_cmd)); + break; + case RenderCommand_ClearFormat: + break; + } + ++list->ncmds; + return cmd; +} + +void command_list_draw_text(struct command_list *list, uint32_t col, + uint32_t row, uint8_t *data, uint32_t len) { + struct draw_text_cmd *cmd = + add_command(list, RenderCommand_DrawText)->draw_txt; + cmd->data = data; + cmd->col = col; + cmd->row = row; + cmd->len = len; +} + +void command_list_draw_text_copy(struct command_list *list, uint32_t col, + uint32_t row, uint8_t *data, uint32_t len) { + uint8_t *bytes = (uint8_t *)list->allocator(len); + memcpy(bytes, data, len); + + command_list_draw_text(list, col, row, bytes, len); +} + +void command_list_draw_repeated(struct command_list *list, uint32_t col, + uint32_t row, uint8_t c, uint32_t nrepeat) { + struct repeat_cmd *cmd = add_command(list, RenderCommand_Repeat)->repeat; + cmd->col = col; + cmd->row = row; + cmd->c = c; + cmd->nrepeat = nrepeat; +} + +void command_list_set_index_color_fg(struct command_list *list, + uint8_t color_idx) { + struct push_fmt_cmd *cmd = + add_command(list, RenderCommand_PushFormat)->push_fmt; + + if (color_idx < 8) { + cmd->len = snprintf((char *)cmd->fmt, 64, "%d", 30 + color_idx); + } else if (color_idx < 16) { + cmd->len = snprintf((char *)cmd->fmt, 64, "%d", 90 + color_idx - 8); + } else { + cmd->len = snprintf((char *)cmd->fmt, 64, "38;5;%d", color_idx); + } +} + +void command_list_set_color_fg(struct command_list *list, uint8_t red, + uint8_t green, uint8_t blue) { + struct push_fmt_cmd *cmd = + add_command(list, RenderCommand_PushFormat)->push_fmt; + cmd->len = snprintf((char *)cmd->fmt, 64, "38;2;%d;%d;%d", red, green, blue); +} + +void command_list_set_index_color_bg(struct command_list *list, + uint8_t color_idx) { + struct push_fmt_cmd *cmd = + add_command(list, RenderCommand_PushFormat)->push_fmt; + if (color_idx < 8) { + cmd->len = snprintf((char *)cmd->fmt, 64, "%d", 40 + color_idx); + } else if (color_idx < 16) { + cmd->len = snprintf((char *)cmd->fmt, 64, "%d", 100 + color_idx - 8); + } else { + cmd->len = snprintf((char *)cmd->fmt, 64, "48;5;%d", color_idx); + } +} + +void command_list_set_color_bg(struct command_list *list, uint8_t red, + uint8_t green, uint8_t blue) { + struct push_fmt_cmd *cmd = + add_command(list, RenderCommand_PushFormat)->push_fmt; + cmd->len = snprintf((char *)cmd->fmt, 64, "48;2;%d;%d;%d", red, green, blue); +} + +void command_list_reset_color(struct command_list *list) { + add_command(list, RenderCommand_ClearFormat); +} + +void command_list_set_show_whitespace(struct command_list *list, bool show) { + add_command(list, RenderCommand_SetShowWhitespace)->show_ws->show = show; +} + +void display_render(struct display *display, + struct command_list *command_list) { + + struct command_list *cl = command_list; + uint8_t fmt_stack[256] = {0}; + fmt_stack[0] = ESC; + fmt_stack[1] = '['; + fmt_stack[2] = '0'; + uint32_t fmt_stack_len = 3; + bool show_whitespace_state = false; + + for (uint64_t cmdi = 0; cmdi < cl->ncmds; ++cmdi) { + struct render_command *cmd = &cl->cmds[cmdi]; + switch (cmd->type) { + case RenderCommand_DrawText: { + struct draw_text_cmd *txt_cmd = cmd->draw_txt; + display_move_cursor(display, txt_cmd->row + cl->yoffset, + txt_cmd->col + cl->xoffset); + putbytes(fmt_stack, fmt_stack_len, false); + putbyte('m'); + putbytes(txt_cmd->data, txt_cmd->len, show_whitespace_state); + break; + } + + case RenderCommand_Repeat: { + struct repeat_cmd *repeat_cmd = cmd->repeat; + display_move_cursor(display, repeat_cmd->row + cl->yoffset, + repeat_cmd->col + cl->xoffset); + putbytes(fmt_stack, fmt_stack_len, false); + putbyte('m'); + if (show_whitespace_state) { + for (uint32_t i = 0; i < repeat_cmd->nrepeat; ++i) { + putbyte_ws(repeat_cmd->c, show_whitespace_state); + } + } else { + char *buf = malloc(repeat_cmd->nrepeat + 1); + memset(buf, repeat_cmd->c, repeat_cmd->nrepeat); + buf[repeat_cmd->nrepeat] = '\0'; + fputs(buf, stdout); + free(buf); + } + break; + } + + case RenderCommand_PushFormat: { + struct push_fmt_cmd *fmt_cmd = cmd->push_fmt; + + fmt_stack[fmt_stack_len] = ';'; + ++fmt_stack_len; + + memcpy(fmt_stack + fmt_stack_len, fmt_cmd->fmt, fmt_cmd->len); + fmt_stack_len += fmt_cmd->len; + break; + } + + case RenderCommand_ClearFormat: + fmt_stack_len = 3; + break; + + case RenderCommand_SetShowWhitespace: + show_whitespace_state = cmd->show_ws->show; + break; + } + } +} + +void hide_cursor() { + putbyte(ESC); + putbyte('['); + putbyte('?'); + putbyte('2'); + putbyte('5'); + putbyte('l'); +} + +void show_cursor() { + putbyte(ESC); + putbyte('['); + putbyte('?'); + putbyte('2'); + putbyte('5'); + putbyte('h'); +} + +void display_begin_render(struct display *display) { hide_cursor(); } +void display_end_render(struct display *display) { + show_cursor(); + fflush(stdout); +} diff --git a/src/dged/display.h b/src/dged/display.h new file mode 100644 index 0000000..14dd246 --- /dev/null +++ b/src/dged/display.h @@ -0,0 +1,212 @@ +#include <stdbool.h> +#include <stddef.h> +#include <stdint.h> + +struct display; + +struct render_command; +struct command_list; + +/** + * Create a new display + * + * The only implementation of this is currently a termios one. + * @returns A pointer to the display. + */ +struct display *display_create(); + +/** + * Resize the display + * + * Resize the display to match the underlying size of the device. + * @param display The display to resize. + */ +void display_resize(struct display *display); + +/** + * Destroy the display. + * + * Clear all resources associated with the display and reset the underlying + * device to original state. + * @param display The display to destroy. + */ +void display_destroy(struct display *display); + +/** + * Get the current width of the display. + * + * @param display The display to get width for. + * @returns The width in number of chars as a positive integer. + */ +uint32_t display_width(struct display *display); + +/** + * Get the current height of the display. + * + * @param display The display to get height for. + * @returns The height in number of chars as a positive integer. + */ +uint32_t display_height(struct display *display); + +/** + * Clear the display + * + * This will clear all text from the display. + * @param display The display to clear. + */ +void display_clear(struct display *display); + +/** + * Move the cursor to the specified location + * + * Move the cursor to the specified row and column. + * @param display The display to move the cursor for. + * @param row The row to move the cursor to. + * @param col The col to move the cursor to. + */ +void display_move_cursor(struct display *display, uint32_t row, uint32_t col); + +/** + * Start a render pass on the display. + * + * A begin_render call can be followed by any number of render calls followed by + * a single end_render call. + * @param display The display to begin rendering on. + */ +void display_begin_render(struct display *display); + +/** + * Render a command list on the display. + * + * Render a command list on the given display. A command list is a series of + * rendering instructions. + * @param display The display to render on. + * @param command_list The command list to render. + */ +void display_render(struct display *display, struct command_list *command_list); + +/** + * Finish a render pass on the display. + * + * This tells the display that rendering is done for now and a flush is + * triggered to update the display hardware. + * @param display The display to end rendering on. + */ +void display_end_render(struct display *display); + +/** + * Create a new command list. + * + * A command list records a series of commands for drawing text to a display. + * @param capacity The capacity of the command list. + * @param allocator Allocation callback to use for data in the command list. + * @param xoffset Column offset to apply to all operations in the list. + * @param yoffset Row offset to apply to all operations in the list. + * @param name Name for the command list. Useful for debugging. + * @returns A pointer to the created command list. + */ +struct command_list *command_list_create(uint32_t capacity, + void *(*allocator)(size_t), + uint32_t xoffset, uint32_t yoffset, + const char *name); + +/** + * Enable/disable rendering of whitespace characters. + * + * ' ' will be rendered with a dot and '\t' as an arrow. + * @param list Command list to record command in. + * @param show True if whitespace chars should be displayed, false otherwise. + */ +void command_list_set_show_whitespace(struct command_list *list, bool show); + +/** + * Set background color + * + * Set the background color to use for following draw commands to the specified + * index. Note that color indices > 15 might not be supported on all displays. + * @param list The command list to record command in. + * @param color_idx The color index to use as background (0-255) + */ +void command_list_set_index_color_bg(struct command_list *list, + uint8_t color_idx); + +/** + * Set background color + * + * Set the background color to use for following draw commands to the specified + * RGB color. Note that this might not be supported on all displays. + * @param list The command list to record command in. + * @param red Red value. + * @param green Green value. + * @param blue Blue value. + */ +void command_list_set_color_bg(struct command_list *list, uint8_t red, + uint8_t green, uint8_t blue); + +/** + * Set foreground color + * + * Set the foreground color to use for following draw commands to the specified + * index. Note that color indices > 15 might not be supported on all displays. + * @param list The command list to record command in. + * @param color_idx The color index to use as foreground (0-255) + */ +void command_list_set_index_color_fg(struct command_list *list, + uint8_t color_idx); + +/** + * Set foreground color + * + * Set the foreground color to use for following draw commands to the specified + * RGB color. Note that this might not be supported on all displays. + * @param list The command list to record command in. + * @param red Red value. + * @param green Green value. + * @param blue Blue value. + */ +void command_list_set_color_fg(struct command_list *list, uint8_t red, + uint8_t green, uint8_t blue); + +/** + * Reset the color and styling information. + * + * The following draw commands will have their formatting reset to the default. + * @param list The command list to record command in. + */ +void command_list_reset_color(struct command_list *list); + +/** + * Draw text + * + * @param list Command list to record draw command in. + * @param col Column to start text at. + * @param row Row to start text at. + * @param data Bytes to write. + * @param len Number of bytes to write. + */ +void command_list_draw_text(struct command_list *list, uint32_t col, + uint32_t row, uint8_t *data, uint32_t len); + +/** + * Draw text, copying it to internal storage first. + * + * @param list Command list to record draw command in. + * @param col Column to start text at. + * @param row Row to start text at. + * @param data Bytes to write. + * @param len Number of bytes to write. + */ +void command_list_draw_text_copy(struct command_list *list, uint32_t col, + uint32_t row, uint8_t *data, uint32_t len); + +/** + * Draw a repeated character. + * + * @param list Command list to record draw command in. + * @param col Column to start text at. + * @param row Row to start text at. + * @param c Byte to repeat. + * @param nrepeat Number of times to repeat byte. + */ +void command_list_draw_repeated(struct command_list *list, uint32_t col, + uint32_t row, uint8_t c, uint32_t nrepeat); diff --git a/src/dged/hash.h b/src/dged/hash.h new file mode 100644 index 0000000..0fd689b --- /dev/null +++ b/src/dged/hash.h @@ -0,0 +1,11 @@ +#include <stdint.h> + +static uint32_t hash_name(const char *s) { + unsigned long hash = 5381; + int c; + + while ((c = *s++)) + hash = ((hash << 5) + hash) + c; /* hash * 33 + c */ + + return hash; +} diff --git a/src/dged/hashmap.h b/src/dged/hashmap.h new file mode 100644 index 0000000..405c193 --- /dev/null +++ b/src/dged/hashmap.h @@ -0,0 +1,86 @@ +#ifndef _HASHMAP_H +#define _HASHMAP_H + +#include "vec.h" +#include <stdint.h> + +#define HASHMAP_ENTRY_TYPE(name, entry) \ + struct name { \ + uint32_t key; \ + entry value; \ + } + +#define HASHMAP(entry) \ + struct { \ + VEC(entry) entries; \ + uint32_t (*hash_fn)(const char *); \ + } + +#define HASHMAP_INIT(map, initial_capacity, hasher) \ + VEC_INIT(&(map)->entries, initial_capacity) \ + (map)->hash_fn = hasher; + +#define HASHMAP_DESTROY(map) VEC_DESTROY(&(map)->entries) + +#define HASHMAP_INSERT(map, type, k, v, hash_var) \ + uint32_t key = (map)->hash_fn(k); \ + bool duplicate = false; \ + VEC_FOR_EACH(&(map)->entries, type *pair) { \ + if (pair->key == key) { \ + duplicate = true; \ + break; \ + } \ + } \ + if (!duplicate) { \ + VEC_PUSH(&(map)->entries, ((type){.key = key, .value = v})); \ + } \ + hash_var = key; + +#define HASHMAP_APPEND(map, type, k, var) \ + uint32_t key = (map)->hash_fn(k); \ + bool duplicate = false; \ + VEC_FOR_EACH(&(map)->entries, type *pair) { \ + if (pair->key == key) { \ + duplicate = true; \ + break; \ + } \ + } \ + type *v = NULL; \ + if (!duplicate) { \ + VEC_APPEND(&(map)->entries, v); \ + v->key = key; \ + } \ + var = v; + +#define HASHMAP_GET(map, type, k, var) \ + HASHMAP_GET_BY_HASH(map, type, (map)->hash_fn(k), var) + +#define HASHMAP_GET_BY_HASH(map, type, h, var) \ + type *res = NULL; \ + uint32_t needle = h; \ + VEC_FOR_EACH(&(map)->entries, type *pair) { \ + if (needle == pair->key) { \ + res = pair; \ + break; \ + } \ + } \ + var = res != NULL ? &(res->value) : NULL; + +#define HASHMAP_CONTAINS_KEY(map, key) \ + uint32_t needle = (map)->hash_fn(key); \ + bool exists = false; \ + VEC_FOR_EACH((map)->entries, struct pair *pair) { \ + if (needle == pair->key) { \ + exists = true; \ + break; \ + } \ + } \ + exists + +#define HASHMAP_FOR_EACH(map, var) VEC_FOR_EACH_INDEXED(&(map)->entries, var, i) + +#define HASHMAP_SIZE(map) VEC_SIZE(&(map)->entries) +#define HASHMAP_CAPACITY(map) VEC_CAPACITY(&(map)->entries) +#define HASHMAP_EMPTY(map) HASHMAP_SIZE == 0 + +#endif diff --git a/src/dged/keyboard.c b/src/dged/keyboard.c new file mode 100644 index 0000000..4b142ee --- /dev/null +++ b/src/dged/keyboard.c @@ -0,0 +1,159 @@ +#define _DEFAULT_SOURCE +#include "keyboard.h" +#include "reactor.h" +#include "stdio.h" +#include "utf8.h" + +#include <ctype.h> +#include <errno.h> +#include <stdlib.h> +#include <string.h> +#include <termios.h> +#include <unistd.h> + +struct keyboard keyboard_create(struct reactor *reactor) { + struct termios term; + tcgetattr(0, &term); + + // set input to non-blocking + term.c_cc[VMIN] = 0; + term.c_cc[VTIME] = 0; + tcsetattr(0, TCSADRAIN, &term); + return keyboard_create_fd(reactor, STDIN_FILENO); +} + +struct keyboard keyboard_create_fd(struct reactor *reactor, int fd) { + return (struct keyboard){ + .fd = fd, + .reactor_event_id = reactor_register_interest(reactor, fd, ReadInterest), + }; +} + +void parse_keys(uint8_t *bytes, uint32_t nbytes, struct key *out_keys, + uint32_t *out_nkeys) { + // TODO: can be optimized if "bytes" contains no special chars + uint32_t nkps = 0; + for (uint32_t bytei = 0; bytei < nbytes; ++bytei) { + uint8_t b = bytes[bytei]; + bool has_more = bytei + 1 < nbytes; + uint8_t next = has_more ? bytes[bytei + 1] : 0; + + struct key *kp = &out_keys[nkps]; + if (b == 0x1b) { // meta + kp->start = bytei; + kp->mod = Meta; + } else if (has_more && isalnum(next) && kp->mod & Meta && + (b == '[' || + b == '0')) { // special char (function keys, pgdn, etc) + kp->mod = Spec; + } else if (b == 0x7f) { // ? + kp->mod |= Ctrl; + kp->key = '?'; + kp->start = bytei; + kp->end = bytei + 1; + ++nkps; + } else if (iscntrl(b)) { // ctrl char + kp->mod |= Ctrl; + kp->key = b | 0x40; + kp->start = bytei; + kp->end = bytei + 1; + ++nkps; + } else { + if (kp->mod & Spec && b == '~') { + // skip tilde in special chars + kp->end = bytei + 1; + ++nkps; + } else if (kp->mod & Meta || kp->mod & Spec) { + kp->key = b; + kp->end = bytei + 1; + + if (kp->mod & Meta || (kp->mod & Spec && next != '~')) { + ++nkps; + } + } else if (utf8_byte_is_unicode_continuation(b)) { + // do nothing for these + } else if (utf8_byte_is_unicode_start(b)) { // unicode char + kp->mod = None; + kp->key = 0; + kp->start = bytei; + kp->end = bytei + utf8_nbytes(bytes + bytei, nbytes - bytei, 1); + ++nkps; + } else { // normal ASCII char + kp->mod = None; + kp->key = b; + kp->start = bytei; + kp->end = bytei + 1; + ++nkps; + } + } + } + + *out_nkeys = nkps; +} + +struct keyboard_update keyboard_update(struct keyboard *kbd, + struct reactor *reactor, + void *(*frame_alloc)(size_t)) { + + struct keyboard_update upd = (struct keyboard_update){ + .keys = NULL, + .nkeys = 0, + .nbytes = 0, + .raw = NULL, + }; + + // check if there is anything to do + if (!reactor_poll_event(reactor, kbd->reactor_event_id)) { + return upd; + } + + // read all input in chunks of `bufsize` bytes + const uint32_t bufsize = 128; + uint8_t *buf = malloc(bufsize), *writepos = buf; + int nbytes = 0, nread = 0; + while ((nread = read(kbd->fd, writepos, bufsize)) == bufsize) { + nbytes += bufsize; + buf = realloc(buf, nbytes + bufsize); + writepos = buf + nbytes; + } + + nbytes += nread; + + if (nbytes > 0) { + upd.nbytes = nbytes; + upd.raw = frame_alloc(nbytes); + memcpy(upd.raw, buf, nbytes); + upd.keys = frame_alloc(sizeof(struct key) * nbytes); + memset(upd.keys, 0, sizeof(struct key) * nbytes); + + parse_keys(upd.raw, upd.nbytes, upd.keys, &upd.nkeys); + } + + free(buf); + return upd; +} + +bool key_equal_char(struct key *key, uint8_t mod, uint8_t c) { + return key->key == c && key->mod == mod; +} + +bool key_equal(struct key *key1, struct key *key2) { + return key_equal_char(key1, key2->mod, key2->key); +} + +uint32_t key_name(struct key *key, char *buf, size_t capacity) { + const char *mod = ""; + switch (key->mod) { + case Ctrl: + mod = "c-"; + break; + case Meta: + mod = "m-"; + break; + case Spec: + mod = "special-"; + break; + } + + snprintf(buf, capacity, "%s%c", mod, tolower(key->key)); +} diff --git a/src/dged/keyboard.h b/src/dged/keyboard.h new file mode 100644 index 0000000..e602b69 --- /dev/null +++ b/src/dged/keyboard.h @@ -0,0 +1,145 @@ +#include <stdbool.h> +#include <stddef.h> +#include <stdint.h> + +/** + * Key press modifiers + * + * Modifiers a key press can have. + */ +enum modifiers { + /** No modifier, bare key press */ + None = 0, + + /** Ctrl key */ + Ctrl = 1 << 0, + + /** Meta (Alt) key */ + Meta = 1 << 1, + + /** Special key (F keys, arrow keys, etc) */ + Spec = 1 << 2, +}; + +/** Backspace key */ +#define BACKSPACE Ctrl, '?' +/** Tab key */ +#define TAB Ctrl, 'I' +/** Enter key */ +#define ENTER Ctrl, 'M' +/** Delete key */ +#define DELETE Spec, '3' + +/** Up arrow key */ +#define UP Spec, 'A' +/** Down arrow key */ +#define DOWN Spec, 'B' +/** Right arrow key */ +#define RIGHT Spec, 'C' +/** Left arrow key */ +#define LEFT Spec, 'D' + +/** + * A key press + */ +struct key { + /** The key pressed, will be 0 for a unicode char */ + uint8_t key; + /** Modifier keys pressed (or-ed together) */ + uint8_t mod; + /** Index where this key press starts in the raw input buffer */ + uint8_t start; + /** Index where this key press ends in the raw input buffer */ + uint8_t end; +}; + +/** + * The keyboard used to input characters. + */ +struct keyboard { + uint32_t reactor_event_id; + int fd; +}; + +/** + * The result of updating the keyboard + */ +struct keyboard_update { + /** The key presses */ + struct key *keys; + /** Number of key presses in @ref keys */ + uint32_t nkeys; + + /** The raw input */ + uint8_t *raw; + /** The number of bytes in the raw input */ + uint32_t nbytes; +}; + +struct reactor; + +/** + * Create a new keyboard + * + * @param reactor @ref reactor "Reactor" to use for polling keyboard for + * readiness. + * @returns The created keyboard. + */ +struct keyboard keyboard_create(struct reactor *reactor); + +/** + * Create a new keyboard, reading input from fd + * + * @param reactor @ref reactor "Reactor" to use for polling keyboard for + * readiness. + * @param fd The file descriptor to get input from + * @returns The created keyboard. + */ +struct keyboard keyboard_create_fd(struct reactor *reactor, int fd); + +/** + * Update the keyboard. + * + * This will check the reactor for readiness to avoid blocking. If there is + * data, it will be read and converted to key presses. + * + * @param kbd The @ref keyboard to update. + * @param reactor The @ref reactor used when creating the @ref keyboard. + * @returns An instance of @ref keyboard_update representing the result of the + * update operation. + */ +struct keyboard_update keyboard_update(struct keyboard *kbd, + struct reactor *reactor, + void *(*frame_alloc)(size_t)); + +/** + * Does key represent the same key press as mod and c. + * + * @param key The key to check. + * @param mod Modifier of a key to compare against. + * @param c Char of a key to compare against. + * @returns true if key represents the same key press as mod together with c, + * false otherwise + */ +bool key_equal_char(struct key *key, uint8_t mod, uint8_t c); + +/** + * Does key1 represent the same key press as key2? + * + * @param key1 First key to compare. + * @param key2 Second key to compare. + * @returns true if key1 and key2 represents the same key press, false + * otherwise. + */ +bool key_equal(struct key *key1, struct key *key2); + +/** + * Get a text representation of a key + * + * @param key @ref key "Key" to get text representation for. + * @param buf character buffer for holding the result. + * @param capacity The capacity of buf. + * + * @returns The number of characters written to buf. + */ +uint32_t key_name(struct key *key, char *buf, size_t capacity); diff --git a/src/dged/lang.c b/src/dged/lang.c new file mode 100644 index 0000000..6919780 --- /dev/null +++ b/src/dged/lang.c @@ -0,0 +1,160 @@ +#include "lang.h" +#include "minibuffer.h" +#include "settings.h" + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +void define_lang(const char *name, const char *id, const char *extensions, + uint32_t tab_width, const char *lang_srv) { + char namebuf[128] = {0}; + + size_t offs = snprintf(namebuf, 128, "languages.%s.", id); + + char *b = namebuf + offs; + snprintf(b, 128 - offs, "%s", "extensions"); + settings_register_setting( + namebuf, (struct setting_value){.type = Setting_String, + .string_value = (char *)extensions}); + + snprintf(b, 128 - offs, "%s", "tab-width"); + settings_register_setting(namebuf, + (struct setting_value){.type = Setting_Number, + .number_value = tab_width}); + + snprintf(b, 128 - offs, "%s", "lang-srv"); + settings_register_setting( + namebuf, (struct setting_value){.type = Setting_String, + .string_value = (char *)lang_srv}); + + snprintf(b, 128 - offs, "%s", "name"); + settings_register_setting( + namebuf, (struct setting_value){.type = Setting_String, + .string_value = (char *)name}); +} + +static struct language g_fundamental = { + .name = "Fundamental", + .tab_width = 4, + .lang_srv = NULL, +}; + +void languages_init(bool register_default) { + if (register_default) { + define_lang("C", "c", "c h", 2, "clangd"); + define_lang("C++", "cxx", "cpp cxx cc c++ hh h", 2, "clangd"); + define_lang("Rust", "rs", "rs", 4, "rust-analyzer"); + define_lang("Nix", "nix", "nix", 4, "rnix-lsp"); + } +} + +struct language lang_from_settings(const char *lang_path) { + char setting_name_buf[128] = {0}; + size_t offs = snprintf(setting_name_buf, 128, "%s.", lang_path); + char *b = setting_name_buf + offs; + + struct language l; + + snprintf(b, 128 - offs, "%s", "name"); + struct setting *name = settings_get(setting_name_buf); + l.name = name != NULL ? name->value.string_value : "Unknown"; + + snprintf(b, 128 - offs, "%s", "tab-width"); + struct setting *tab_width = settings_get(setting_name_buf); + + // fall back to global value + if (tab_width == NULL) { + tab_width = settings_get("editor.tab-width"); + } + l.tab_width = tab_width != NULL ? tab_width->value.number_value : 4; + + snprintf(b, 128 - offs, "%s", "lang-srv"); + struct setting *lang_srv = settings_get(setting_name_buf); + l.lang_srv = lang_srv->value.string_value; + + return l; +} + +void next_ext(const char *curr, const char **nxt, const char **end) { + if (curr == NULL) { + *nxt = *end = NULL; + return; + } + + *nxt = curr; + *end = curr + strlen(curr); + + const char *spc = strchr(curr, ' '); + if (spc != NULL) { + *end = spc; + } +} + +struct language lang_from_extension(const char *ext) { + + uint32_t extlen = strlen(ext); + if (extlen == 0) { + return g_fundamental; + } + + // get "languages.*" settings + struct setting **settings = NULL; + uint32_t nsettings = 0; + settings_get_prefix("languages.", &settings, &nsettings); + + // find the first one with a matching extension list + for (uint32_t i = 0; i < nsettings; ++i) { + struct setting *setting = settings[i]; + char *setting_name = strrchr(setting->path, '.'); + if (setting_name != NULL && + strncmp(setting_name + 1, "extensions", 10) == 0) { + const char *val = setting->value.string_value; + + // go over extensions + const char *cext = val, *nxt = NULL, *end = NULL; + next_ext(cext, &nxt, &end); + while (nxt != end) { + if (extlen == (end - nxt) && strncmp(ext, nxt, (end - nxt)) == 0) { + char lang_path[128] = {0}; + strncpy(lang_path, setting->path, setting_name - setting->path); + + free(settings); + return lang_from_settings(lang_path); + } + + cext = end + 1; + next_ext(cext, &nxt, &end); + } + } + } + + free(settings); + + // fall back to fundamental + return g_fundamental; +} + +struct language lang_from_id(const char *id) { + if (id == NULL || (strlen(id) == 3 && strncmp(id, "fnd", 3) == 0) || + strlen(id) == 0) { + return g_fundamental; + } + + char lang_path[128] = {0}; + snprintf(lang_path, 128, "languages.%s", id); + + // check that it exists + struct setting **settings = NULL; + uint32_t nsettings = 0; + + settings_get_prefix(lang_path, &settings, &nsettings); + free(settings); + + if (nsettings > 0) { + return lang_from_settings(lang_path); + } else { + minibuffer_echo_timeout(4, "failed to find language \"%s\"", id); + return lang_from_settings("languages.fnd"); + } +} diff --git a/src/dged/lang.h b/src/dged/lang.h new file mode 100644 index 0000000..984e207 --- /dev/null +++ b/src/dged/lang.h @@ -0,0 +1,46 @@ +#ifndef _LANG_H +#define _LANG_H + +#include <stdbool.h> +#include <stdint.h> + +/** + * Settings for a programming language. + */ +struct language { + /** Descriptive name of the programming language */ + const char *name; + + /** Tab width for indentation */ + uint32_t tab_width; + + /** Path to the language server */ + const char *lang_srv; +}; + +/** + * Initialize languages. + * + * @param[in] register_default Set to true to register some well known + * languages. + */ +void languages_init(bool register_default); + +/** + * Get a language config by file name extension. + * + * @param[in] ext File extension + * @returns A language config instance or the default language if not found. + */ +struct language lang_from_extension(const char *ext); + +/** + * Get a language config by id. The language id is a short (all-lowercase) + * string identifying the language. + * + * @param[in] id The language id. + * @returns A language config instance or the default language if not found. + */ +struct language lang_from_id(const char *id); + +#endif diff --git a/src/dged/minibuffer.c b/src/dged/minibuffer.c new file mode 100644 index 0000000..0ff32a8 --- /dev/null +++ b/src/dged/minibuffer.c @@ -0,0 +1,223 @@ +#include "minibuffer.h" +#include "binding.h" +#include "buffer.h" +#include "command.h" +#include "display.h" + +#include <stdarg.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +static struct minibuffer { + struct buffer *buffer; + struct timespec expires; + + char prompt[128]; + struct command_ctx prompt_command_ctx; + bool prompt_active; + bool clear; + + void (*update_callback)(); + +} g_minibuffer = {0}; + +void draw_prompt(struct command_list *commands, void *userdata) { + uint32_t len = strlen(g_minibuffer.prompt); + command_list_set_index_color_fg(commands, 4); + command_list_draw_text(commands, 0, 0, (uint8_t *)g_minibuffer.prompt, len); + command_list_reset_color(commands); +} + +int32_t minibuffer_execute() { + if (g_minibuffer.prompt_active) { + struct command_ctx *c = &g_minibuffer.prompt_command_ctx; + + struct text_chunk line = minibuffer_content(); + char *l = (char *)malloc(line.nbytes + 1); + memcpy(l, line.text, line.nbytes); + l[line.nbytes] = '\0'; + + // propagate any saved arguments + char *argv[64]; + for (uint32_t i = 0; i < c->saved_argc; ++i) { + argv[i] = (char *)c->saved_argv[i]; + } + argv[c->saved_argc] = l; + uint32_t argc = c->saved_argc + (line.nbytes > 0 ? 1 : 0); + + // split on ' ' + for (uint32_t bytei = 0; bytei < line.nbytes; ++bytei) { + uint8_t byte = line.text[bytei]; + if (byte == ' ' && argc < 64) { + l[bytei] = '\0'; + argv[argc] = l + bytei + 1; + ++argc; + } + } + + minibuffer_abort_prompt(); + int32_t res = execute_command(c->self, c->commands, c->active_window, + c->buffers, argc, (const char **)argv); + + free(l); + + return res; + } else { + return 0; + } +} + +struct update_hook_result update(struct buffer_view *view, + struct command_list *commands, uint32_t width, + uint32_t height, uint64_t frame_time, + void *userdata) { + struct timespec current; + struct minibuffer *mb = (struct minibuffer *)userdata; + clock_gettime(CLOCK_MONOTONIC, ¤t); + if ((!mb->prompt_active && current.tv_sec >= mb->expires.tv_sec) || + mb->clear) { + buffer_clear(view); + mb->clear = false; + } + + struct update_hook_result res = {0}; + if (mb->prompt_active) { + res.margins.left = strlen(mb->prompt); + draw_prompt(commands, NULL); + } + + if (mb->update_callback != NULL) { + mb->update_callback(); + } + + return res; +} + +void minibuffer_init(struct buffer *buffer) { + if (g_minibuffer.buffer != NULL) { + return; + } + + g_minibuffer.buffer = buffer; + g_minibuffer.clear = false; + buffer_add_update_hook(g_minibuffer.buffer, update, &g_minibuffer); +} + +void echo(uint32_t timeout, const char *fmt, va_list args) { + if (g_minibuffer.prompt_active || g_minibuffer.buffer == NULL) { + return; + } + + char buff[2048]; + size_t nbytes = vsnprintf(buff, 2048, fmt, args); + + // vsnprintf returns how many characters it would have wanted to write in case + // of overflow + buffer_set_text(g_minibuffer.buffer, (uint8_t *)buff, + nbytes > 2048 ? 2048 : nbytes); + g_minibuffer.clear = false; + + clock_gettime(CLOCK_MONOTONIC, &g_minibuffer.expires); + g_minibuffer.expires.tv_sec += timeout; +} + +void minibuffer_destroy() { + command_ctx_free(&g_minibuffer.prompt_command_ctx); +} + +struct text_chunk minibuffer_content() { + return buffer_get_line(g_minibuffer.buffer, 0); +} + +struct buffer *minibuffer_buffer() { + return g_minibuffer.buffer; +} + +void minibuffer_echo(const char *fmt, ...) { + va_list args; + va_start(args, fmt); + echo(1000, fmt, args); + va_end(args); +} + +void minibuffer_echo_timeout(uint32_t timeout, const char *fmt, ...) { + va_list args; + va_start(args, fmt); + echo(timeout, fmt, args); + va_end(args); +} + +void minibuffer_set_prompt_internal(const char *fmt, va_list args) { + vsnprintf(g_minibuffer.prompt, sizeof(g_minibuffer.prompt), fmt, args); +} + +int32_t minibuffer_prompt_internal(struct command_ctx command_ctx, + void (*update_callback)(), const char *fmt, + va_list args) { + if (g_minibuffer.buffer == NULL) { + return 1; + } + + minibuffer_clear(); + g_minibuffer.prompt_active = true; + + command_ctx_free(&g_minibuffer.prompt_command_ctx); + g_minibuffer.prompt_command_ctx = command_ctx; + + minibuffer_set_prompt_internal(fmt, args); + + if (update_callback != NULL) { + g_minibuffer.update_callback = update_callback; + } + + return 0; +} + +int32_t minibuffer_prompt(struct command_ctx command_ctx, const char *fmt, + ...) { + va_list args; + va_start(args, fmt); + int32_t r = minibuffer_prompt_internal(command_ctx, NULL, fmt, args); + va_end(args); + + return r; +} + +int32_t minibuffer_prompt_interactive(struct command_ctx command_ctx, + void (*update_callback)(), + const char *fmt, ...) { + va_list args; + va_start(args, fmt); + int32_t r = + minibuffer_prompt_internal(command_ctx, update_callback, fmt, args); + va_end(args); + + return r; +} + +void minibuffer_set_prompt(const char *fmt, ...) { + va_list args; + va_start(args, fmt); + minibuffer_set_prompt_internal(fmt, args); + va_end(args); +} + +void minibuffer_abort_prompt() { + minibuffer_clear(); + g_minibuffer.update_callback = NULL; + g_minibuffer.prompt_active = false; +} + +bool minibuffer_empty() { return !minibuffer_displaying(); } + +bool minibuffer_displaying() { + return g_minibuffer.buffer != NULL && !buffer_is_empty(g_minibuffer.buffer); +} + +void minibuffer_clear() { + g_minibuffer.expires.tv_sec = 0; + g_minibuffer.clear = true; +} + +bool minibuffer_focused() { return g_minibuffer.prompt_active; } diff --git a/src/dged/minibuffer.h b/src/dged/minibuffer.h new file mode 100644 index 0000000..24f54cf --- /dev/null +++ b/src/dged/minibuffer.h @@ -0,0 +1,108 @@ +#include <stdbool.h> +#include <stddef.h> +#include <stdint.h> +#include <time.h> + +struct buffer; +struct command_ctx; +struct keymap; + +/** + * Initialize the minibuffer. + * + * Note that the minibuffer is a global instance and this function will do + * nothing if called more than once. + * @param buffer underlying buffer to use for text IO in the minibuffer. + */ +void minibuffer_init(struct buffer *buffer); + +/** + * Destroy the minibuffer + * + * Note that this does not release the buffer used. + */ +void minibuffer_destroy(); + +struct text_chunk minibuffer_content(); + +struct buffer *minibuffer_buffer(); + +/** + * Echo a message to the minibuffer. + * + * @param fmt Format string for the message. + * @param ... Format arguments. + */ +void minibuffer_echo(const char *fmt, ...); + +/** + * Echo a message to the minibuffer that disappears after @ref timeout. + * + * @param timeout The timeout in seconds after which the message should + * disappear. + * @param fmt Format string for the message. + * @param ... Format arguments. + */ +void minibuffer_echo_timeout(uint32_t timeout, const char *fmt, ...); + +/** + * Prompt for user input in the minibuffer. + * + * This will move focus to the minibuffer and wait for user input, with the + * given prompt. + * @param command_ctx The command context to use to re-execute the calling + * command (or other command) when the user confirms the input. + * @param fmt Format string for the prompt. + * @param ... Format arguments. + * @returns 0 on success. + */ +int32_t minibuffer_prompt(struct command_ctx command_ctx, const char *fmt, ...); + +int32_t minibuffer_prompt_interactive(struct command_ctx command_ctx, + void (*update_callback)(), + const char *fmt, ...); + +void minibuffer_set_prompt(const char *fmt, ...); + +/** + * Evaluate the current contents of the minibuffer + * + * @returns zero on success, non-zero to indicate failure + */ +int32_t minibuffer_execute(); + +/** + * Abort the current minibuffer prompt. + * + * This returns focus to the previously focused window. + */ +void minibuffer_abort_prompt(); + +/** + * Minibuffer prompt args + */ +struct minibuffer_prompt_args { + int argc; + const char **argv; +}; + +/** + * Clear the current text in the minibuffer. + */ +void minibuffer_clear(); + +bool minibuffer_empty(); + +/** + * Is the minibuffer currently displaying something? + * + * @returns True if the minibuffer is displaying anything, false otherwise. + */ +bool minibuffer_displaying(); + +/** + * Is the minibuffer currently focused? + * + * @returns True if the minibuffer is currently focused, receiving user input. + */ +bool minibuffer_focused(); diff --git a/src/dged/reactor-epoll.c b/src/dged/reactor-epoll.c new file mode 100644 index 0000000..e488fef --- /dev/null +++ b/src/dged/reactor-epoll.c @@ -0,0 +1,76 @@ +#include "reactor.h" + +#include <stdio.h> +#include <stdlib.h> +#include <sys/epoll.h> + +struct reactor { + int epoll_fd; + void *events; +}; + +struct events { + struct epoll_event events[10]; + uint32_t nevents; +}; + +struct reactor *reactor_create() { + int epollfd = epoll_create1(0); + if (epollfd == -1) { + perror("epoll_create1"); + } + + struct reactor *r = (struct reactor *)calloc(1, sizeof(struct reactor)); + r->epoll_fd = epollfd; + r->events = calloc(1, sizeof(struct events)); + + return r; +} + +void reactor_destroy(struct reactor *reactor) { + free(reactor->events); + free(reactor); +} + +uint32_t reactor_register_interest(struct reactor *reactor, int fd, + enum interest interest) { + struct epoll_event ev; + ev.events = 0; + ev.events |= (interest & ReadInterest) != 0 ? EPOLLIN : 0; + ev.events |= (interest & WriteInterest) != 0 ? EPOLLOUT : 0; + ev.data.fd = fd; + if (epoll_ctl(reactor->epoll_fd, EPOLL_CTL_ADD, fd, &ev) < 0) { + perror("epoll_ctl"); + return -1; + } + + return fd; +} + +void reactor_unregister_interest(struct reactor *reactor, uint32_t ev_id) { + epoll_ctl(reactor->epoll_fd, EPOLL_CTL_DEL, ev_id, NULL); +} + +bool reactor_poll_event(struct reactor *reactor, uint32_t ev_id) { + struct events *events = (struct events *)reactor->events; + for (uint32_t ei = 0; ei < events->nevents; ++ei) { + struct epoll_event *ev = &events->events[ei]; + + if (ev->data.fd == ev_id) { + return true; + } + } + + return false; +} + +void reactor_update(struct reactor *reactor) { + struct events *events = (struct events *)reactor->events; + int nfds = epoll_wait(reactor->epoll_fd, events->events, 10, -1); + + if (nfds == -1) { + // TODO: log failure + } + + events->nevents = nfds; +} diff --git a/src/dged/reactor.h b/src/dged/reactor.h new file mode 100644 index 0000000..e54afda --- /dev/null +++ b/src/dged/reactor.h @@ -0,0 +1,17 @@ +#include <stdbool.h> +#include <stdint.h> + +enum interest { + ReadInterest = 1, + WriteInterest = 2, +}; + +struct reactor; + +struct reactor *reactor_create(); +void reactor_destroy(struct reactor *reactor); +void reactor_update(struct reactor *reactor); +bool reactor_poll_event(struct reactor *reactor, uint32_t ev_id); +uint32_t reactor_register_interest(struct reactor *reactor, int fd, + enum interest interest); +void reactor_unregister_interest(struct reactor *reactor, uint32_t ev_id); diff --git a/src/dged/settings.c b/src/dged/settings.c new file mode 100644 index 0000000..524aa9b --- /dev/null +++ b/src/dged/settings.c @@ -0,0 +1,95 @@ +#include "settings.h" +#include "command.h" +#include "hash.h" +#include "hashmap.h" +#include "minibuffer.h" +#include "vec.h" + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +static struct settings g_settings = {0}; + +void settings_init(uint32_t initial_capacity) { + HASHMAP_INIT(&g_settings.settings, initial_capacity, hash_name); +} + +void settings_destroy() { + HASHMAP_FOR_EACH(&g_settings.settings, struct setting_entry * entry) { + struct setting *setting = &entry->value; + if (setting->value.type == Setting_String) { + free(setting->value.string_value); + } + } + + HASHMAP_DESTROY(&g_settings.settings); +} + +void setting_set_value(struct setting *setting, struct setting_value val) { + if (setting->value.type == val.type) { + if (setting->value.type == Setting_String && val.string_value != NULL) { + setting->value.string_value = strdup(val.string_value); + } else { + setting->value = val; + } + } +} + +void settings_register_setting(const char *path, + struct setting_value default_value) { + HASHMAP_APPEND(&g_settings.settings, struct setting_entry, path, + struct setting_entry * s); + + if (s != NULL) { + struct setting *new_setting = &s->value; + new_setting->value.type = default_value.type; + setting_set_value(new_setting, default_value); + strncpy(new_setting->path, path, 128); + new_setting->path[127] = '\0'; + } +} + +struct setting *settings_get(const char *path) { + HASHMAP_GET(&g_settings.settings, struct setting_entry, path, + struct setting * s); + return s; +} + +void settings_get_prefix(const char *prefix, struct setting **settings_out[], + uint32_t *nsettings_out) { + + uint32_t capacity = 16; + VEC(struct setting *) res; + VEC_INIT(&res, 16); + HASHMAP_FOR_EACH(&g_settings.settings, struct setting_entry * entry) { + struct setting *setting = &entry->value; + if (strncmp(prefix, setting->path, strlen(prefix)) == 0) { + VEC_PUSH(&res, setting); + } + } + + *nsettings_out = VEC_SIZE(&res); + *settings_out = VEC_ENTRIES(&res); +} + +void settings_set(const char *path, struct setting_value value) { + struct setting *setting = settings_get(path); + if (setting != NULL) { + setting_set_value(setting, value); + } +} + +void setting_to_string(struct setting *setting, char *buf, size_t n) { + switch (setting->value.type) { + case Setting_Bool: + snprintf(buf, n, "%s", setting->value.bool_value ? "true" : "false"); + break; + case Setting_Number: + snprintf(buf, n, "%ld", setting->value.number_value); + break; + case Setting_String: + snprintf(buf, n, "%s", setting->value.string_value); + break; + } +} diff --git a/src/dged/settings.h b/src/dged/settings.h new file mode 100644 index 0000000..5d245d9 --- /dev/null +++ b/src/dged/settings.h @@ -0,0 +1,137 @@ +#include "hashmap.h" + +#include <stdbool.h> +#include <stdint.h> + +struct commands; + +/** + * The type of setting value. + */ +enum setting_type { + /** String setting. */ + Setting_String = 0, + + /** Number setting (a signed 64 bit integer). */ + Setting_Number, + + /** Boolean setting. */ + Setting_Bool, +}; + +/** + * Value for a setting. + */ +struct setting_value { + /** Type of setting. */ + enum setting_type type; + + union { + /** String setting. */ + char *string_value; + + /** Real number setting. */ + int64_t number_value; + + /** Boolean setting value. */ + bool bool_value; + }; +}; + +/** + * A single setting. + * + * A setting has a "path", denoted by a string + * containing a number (0-) of dots. + * Example: editor.tab-width. + */ +struct setting { + + /** Path of the setting. */ + char path[128]; + + /** Value of the setting. */ + struct setting_value value; +}; + +HASHMAP_ENTRY_TYPE(setting_entry, struct setting); + +/** + * A collection of settings. + */ +struct settings { + HASHMAP(struct setting_entry) settings; +}; + +/** + * Initialize the global collection of settings. + * + * @param initial_capacity Initial capacity of the settings collection. + * @returns Nothing, the settings collection is a global instance. + */ +void settings_init(uint32_t initial_capacity); + +/** + * Destroy the global collection of settings. + */ +void settings_destroy(); + +/** + * Register a new setting. + * + * @param path The path of the new setting on + * the form <category>.<sub-category>.<setting-name>. + * @param default_value The default value for the setting. + * All settings are required to declare a default value. + */ +void settings_register_setting(const char *path, + struct setting_value default_value); + +/** + * Retrieve a single setting by path. + * + * @param path The exact path of the setting on + * the form <category>.<sub-category>.<setting-name>. + * @returns A pointer to the setting if found, NULL otherwise. + */ +struct setting *settings_get(const char *path); + +/** + * Retrieve a collection of settings by prefix + * + * @param prefix Path prefix for the settings to retrieve. + * @param settings_out Pointer to an array that will be modified to point to the + * result. + * @param nsettings_out Pointer to an integer that will be set to the number of + * settings pointers in the result. + */ +void settings_get_prefix(const char *prefix, struct setting **settings_out[], + uint32_t *nsettings_out); + +/** + * Set a value for a setting. + * + * @param path The exact path of the setting on + * the form <category>.<sub-category>.<setting-name>. + * @param value The new value of the setting. The type has to match the declared + * type for the setting. If not, the new value is ignored. + */ +void settings_set(const char *path, struct setting_value value); + +/** + * Set a value for a setting. + * + * @param setting Pointer to a setting to set. + * @param value The new value of the setting. The type has to match the declared + * type for the setting. If not, the new value is ignored. + */ +void setting_set_value(struct setting *setting, struct setting_value val); + +/** + * Create a string representation for a setting. + * + * @param setting Pointer to a setting to turn into a string. + * @param buf Character buffer to store resulting string in. + * @param n Size in bytes of @ref buf. + */ +void setting_to_string(struct setting *setting, char *buf, size_t n); diff --git a/src/dged/text.c b/src/dged/text.c new file mode 100644 index 0000000..f8ba72d --- /dev/null +++ b/src/dged/text.c @@ -0,0 +1,496 @@ +#include "text.h" + +#include <assert.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#include "display.h" +#include "signal.h" +#include "utf8.h" + +enum flags { + LineChanged = 1 << 0, +}; + +struct line { + uint8_t *data; + uint8_t flags; + uint32_t nbytes; + uint32_t nchars; +}; + +struct text { + // raw bytes without any null terminators + struct line *lines; + uint32_t nlines; + uint32_t capacity; +}; + +struct text *text_create(uint32_t initial_capacity) { + struct text *txt = calloc(1, sizeof(struct text)); + txt->lines = calloc(initial_capacity, sizeof(struct line)); + txt->capacity = initial_capacity; + txt->nlines = 0; + + return txt; +} + +void text_destroy(struct text *text) { + for (uint32_t li = 0; li < text->nlines; ++li) { + free(text->lines[li].data); + text->lines[li].data = NULL; + text->lines[li].flags = 0; + text->lines[li].nbytes = 0; + text->lines[li].nchars = 0; + } + + free(text->lines); + + free(text); +} + +void text_clear(struct text *text) { + for (uint32_t li = 0; li < text->nlines; ++li) { + free(text->lines[li].data); + text->lines[li].data = NULL; + text->lines[li].flags = 0; + text->lines[li].nbytes = 0; + text->lines[li].nchars = 0; + } + + text->nlines = 0; +} + +// given `char_idx` as a character index, return the byte index +uint32_t charidx_to_byteidx(struct line *line, uint32_t char_idx) { + if (char_idx > line->nchars) { + return line->nbytes; + } + return utf8_nbytes(line->data, line->nbytes, char_idx); +} + +uint32_t text_col_to_byteindex(struct text *text, uint32_t line, uint32_t col) { + return charidx_to_byteidx(&text->lines[line], col); +} + +// given `byte_idx` as a byte index, return the character index +uint32_t byteidx_to_charidx(struct line *line, uint32_t byte_idx) { + if (byte_idx > line->nbytes) { + return line->nchars; + } + + return utf8_nchars(line->data, byte_idx); +} + +uint32_t text_byteindex_to_col(struct text *text, uint32_t line, + uint32_t byteindex) { + return byteidx_to_charidx(&text->lines[line], byteindex); +} + +void append_empty_lines(struct text *text, uint32_t numlines) { + + if (text->nlines + numlines >= text->capacity) { + text->capacity += text->capacity + numlines > text->capacity * 2 + ? numlines + 1 + : text->capacity; + text->lines = realloc(text->lines, sizeof(struct line) * text->capacity); + } + + for (uint32_t i = 0; i < numlines; ++i) { + struct line *nline = &text->lines[text->nlines]; + nline->data = NULL; + nline->nbytes = 0; + nline->nchars = 0; + nline->flags = 0; + + ++text->nlines; + } + + if (text->nlines > text->capacity) { + printf("text->nlines: %d, text->capacity: %d\n", text->nlines, + text->capacity); + raise(SIGTRAP); + } +} + +void ensure_line(struct text *text, uint32_t line) { + if (line >= text->nlines) { + append_empty_lines(text, line - text->nlines + 1); + } +} + +// It is assumed that `data` does not contain any \n, that is handled by +// higher-level functions +void insert_at(struct text *text, uint32_t line, uint32_t col, uint8_t *data, + uint32_t len, uint32_t nchars) { + + if (len == 0) { + return; + } + + ensure_line(text, line); + + struct line *l = &text->lines[line]; + + l->nbytes += len; + l->nchars += nchars; + l->flags = LineChanged; + l->data = realloc(l->data, l->nbytes); + + uint32_t bytei = charidx_to_byteidx(l, col); + + // move following bytes out of the way + if (bytei + len < l->nbytes) { + uint32_t start = bytei + len; + memmove(l->data + start, l->data + bytei, l->nbytes - start); + } + + // insert new chars + memcpy(l->data + bytei, data, len); +} + +uint32_t text_line_length(struct text *text, uint32_t lineidx) { + return text->lines[lineidx].nchars; +} + +uint32_t text_line_size(struct text *text, uint32_t lineidx) { + return text->lines[lineidx].nbytes; +} + +uint32_t text_num_lines(struct text *text) { return text->nlines; } + +void split_line(uint32_t col, struct line *line, struct line *next) { + uint8_t *data = line->data; + uint32_t nbytes = line->nbytes; + uint32_t nchars = line->nchars; + + uint32_t chari = col; + uint32_t bytei = charidx_to_byteidx(line, chari); + + line->nbytes = bytei; + line->nchars = chari; + next->nbytes = nbytes - bytei; + next->nchars = nchars - chari; + line->flags = next->flags = line->flags; + + next->data = NULL; + line->data = NULL; + + // first, handle some cases where the new line or the pre-existing one is + // empty + if (next->nbytes == 0) { + line->data = data; + } else if (line->nbytes == 0) { + next->data = data; + } else { + // actually split the line + next->data = (uint8_t *)realloc(next->data, next->nbytes); + memcpy(next->data, data + bytei, next->nbytes); + + line->data = (uint8_t *)realloc(line->data, line->nbytes); + memcpy(line->data, data, line->nbytes); + + free(data); + } +} + +void mark_lines_changed(struct text *text, uint32_t line, uint32_t nlines) { + for (uint32_t linei = line; linei < (line + nlines); ++linei) { + text->lines[linei].flags |= LineChanged; + } +} + +void shift_lines(struct text *text, uint32_t start, int32_t direction) { + struct line *dest = &text->lines[((int64_t)start + direction)]; + struct line *src = &text->lines[start]; + uint32_t nlines = text->nlines - (dest > src ? (start + direction) : start); + memmove(dest, src, nlines * sizeof(struct line)); +} + +void new_line_at(struct text *text, uint32_t line, uint32_t col) { + ensure_line(text, line); + + uint32_t newline = line + 1; + append_empty_lines(text, 1); + + mark_lines_changed(text, line, text->nlines - line); + + // move following lines out of the way, if there are any + if (newline + 1 < text->nlines) { + shift_lines(text, newline, 1); + } + + // split line if needed + split_line(col, &text->lines[line], &text->lines[newline]); +} + +void delete_line(struct text *text, uint32_t line) { + if (text->nlines == 0) { + return; + } + + mark_lines_changed(text, line, text->nlines - line); + + free(text->lines[line].data); + text->lines[line].data = NULL; + + if (line + 1 < text->nlines) { + shift_lines(text, line + 1, -1); + } + + --text->nlines; + text->lines[text->nlines].data = NULL; + text->lines[text->nlines].nbytes = 0; + text->lines[text->nlines].nchars = 0; +} + +void text_insert_at_inner(struct text *text, uint32_t line, uint32_t col, + uint8_t *bytes, uint32_t nbytes, + uint32_t *lines_added, uint32_t *cols_added, + bool force_newline) { + uint32_t linelen = 0, start_line = line; + + *cols_added = 0; + for (uint32_t bytei = 0; bytei < nbytes; ++bytei) { + uint8_t byte = bytes[bytei]; + if (byte == '\n') { + uint8_t *line_data = bytes + (bytei - linelen); + uint32_t nchars = utf8_nchars(line_data, linelen); + + insert_at(text, line, col, line_data, linelen, nchars); + + col += nchars; + + // only insert a newline if we have to + if (force_newline || linelen == 0 || col < text_line_length(text, line) || + line + 1 < text->nlines) { + new_line_at(text, line, col); + } + + ++line; + linelen = 0; + col = 0; + } else { + ++linelen; + } + } + + // handle remaining + if (linelen > 0) { + uint8_t *line_data = bytes + (nbytes - linelen); + uint32_t nchars = utf8_nchars(line_data, linelen); + insert_at(text, line, col, line_data, linelen, nchars); + *cols_added = nchars; + } + + *lines_added = line - start_line; +} + +void text_append(struct text *text, uint8_t *bytes, uint32_t nbytes, + uint32_t *lines_added, uint32_t *cols_added) { + uint32_t line = text->nlines > 0 ? text->nlines - 1 : 0; + uint32_t col = text_line_length(text, line); + + text_insert_at_inner(text, line, col, bytes, nbytes, lines_added, cols_added, + true); +} + +void text_insert_at(struct text *text, uint32_t line, uint32_t col, + uint8_t *bytes, uint32_t nbytes, uint32_t *lines_added, + uint32_t *cols_added) { + text_insert_at_inner(text, line, col, bytes, nbytes, lines_added, cols_added, + false); +} + +void text_delete(struct text *text, uint32_t start_line, uint32_t start_col, + uint32_t end_line, uint32_t end_col) { + + if (text->nlines == 0) { + return; + } + + uint32_t maxline = text->nlines > 0 ? text->nlines - 1 : 0; + + // make sure we stay inside + if (start_line > maxline) { + start_line = maxline; + start_col = text->lines[start_line].nchars > 0 + ? text->lines[start_line].nchars - 1 + : 0; + } + + if (end_line > maxline) { + end_line = maxline; + end_col = text->lines[end_line].nchars; + } + + struct line *firstline = &text->lines[start_line]; + struct line *lastline = &text->lines[end_line]; + + // clamp column + if (start_col > firstline->nchars) { + start_col = firstline->nchars > 0 ? firstline->nchars - 1 : 0; + } + + // handle deletion of newlines + if (end_col > lastline->nchars) { + if (end_line + 1 < text->nlines) { + end_col = 0; + ++end_line; + lastline = &text->lines[end_line]; + } else { + end_col = lastline->nchars; + } + } + + uint32_t bytei = utf8_nbytes(lastline->data, lastline->nbytes, end_col); + if (lastline == firstline) { + // in this case we can "overwrite" + uint32_t dstbytei = + utf8_nbytes(firstline->data, firstline->nbytes, start_col); + memcpy(firstline->data + dstbytei, lastline->data + bytei, + lastline->nbytes - bytei); + } else { + // otherwise we actually have to copy from the last line + insert_at(text, start_line, start_col, lastline->data + bytei, + lastline->nbytes - bytei, lastline->nchars - end_col); + } + + firstline->nchars = start_col + (lastline->nchars - end_col); + firstline->nbytes = + utf8_nbytes(firstline->data, firstline->nbytes, start_col) + + (lastline->nbytes - bytei); + + // delete full lines, backwards to not shift old, crappy data upwards + for (uint32_t linei = end_line >= text->nlines ? end_line - 1 : end_line; + linei > start_line; --linei) { + delete_line(text, linei); + } + + // if this is the last line in the buffer, and it turns out empty, remove it + if (firstline->nbytes == 0 && start_line == text->nlines - 1) { + delete_line(text, start_line); + } +} + +void text_for_each_chunk(struct text *text, chunk_cb callback, void *userdata) { + // if representation of text is changed, this can be changed as well + text_for_each_line(text, 0, text->nlines, callback, userdata); +} + +void text_for_each_line(struct text *text, uint32_t line, uint32_t nlines, + chunk_cb callback, void *userdata) { + uint32_t nlines_max = + (line + nlines) > text->nlines ? text->nlines : (line + nlines); + for (uint32_t li = line; li < nlines_max; ++li) { + struct line *src_line = &text->lines[li]; + struct text_chunk line = (struct text_chunk){ + .text = src_line->data, + .nbytes = src_line->nbytes, + .nchars = src_line->nchars, + .line = li, + }; + callback(&line, userdata); + } +} + +struct text_chunk text_get_line(struct text *text, uint32_t line) { + struct line *src_line = &text->lines[line]; + return (struct text_chunk){ + .text = src_line->data, + .nbytes = src_line->nbytes, + .nchars = src_line->nchars, + .line = line, + }; +} + +struct copy_cmd { + uint32_t line; + uint32_t byteoffset; + uint32_t nbytes; +}; + +struct text_chunk text_get_region(struct text *text, uint32_t start_line, + uint32_t start_col, uint32_t end_line, + uint32_t end_col) { + if (start_line == end_line && start_col == end_col) { + return (struct text_chunk){0}; + } + + struct line *first_line = &text->lines[start_line]; + struct line *last_line = &text->lines[end_line]; + + if (start_col > first_line->nchars) { + return (struct text_chunk){0}; + } + + // handle copying of newlines + if (end_col > last_line->nchars) { + ++end_line; + end_col = 0; + last_line = &text->lines[end_line]; + } + + uint32_t nlines = end_line - start_line + 1; + struct copy_cmd *copy_cmds = calloc(nlines, sizeof(struct copy_cmd)); + + uint32_t total_chars = 0, total_bytes = 0; + for (uint32_t line = start_line; line <= end_line; ++line) { + struct line *l = &text->lines[line]; + total_chars += l->nchars; + total_bytes += l->nbytes; + + struct copy_cmd *cmd = ©_cmds[line - start_line]; + cmd->line = line; + cmd->byteoffset = 0; + cmd->nbytes = l->nbytes; + } + + // correct first line + struct copy_cmd *cmd_first = ©_cmds[0]; + uint32_t byteoff = + utf8_nbytes(first_line->data, first_line->nbytes, start_col); + cmd_first->byteoffset += byteoff; + cmd_first->nbytes -= byteoff; + total_bytes -= byteoff; + total_chars -= start_col; + + // correct last line + struct copy_cmd *cmd_last = ©_cmds[nlines - 1]; + uint32_t byteindex = utf8_nbytes(last_line->data, last_line->nbytes, end_col); + cmd_last->nbytes -= (last_line->nbytes - byteindex); + total_bytes -= (last_line->nbytes - byteindex); + total_chars -= (last_line->nchars - end_col); + + uint8_t *data = (uint8_t *)malloc( + total_bytes + /* nr of newline chars */ (end_line - start_line)); + + // copy data + for (uint32_t cmdi = 0, curr = 0; cmdi < nlines; ++cmdi) { + struct copy_cmd *c = ©_cmds[cmdi]; + struct line *l = &text->lines[c->line]; + memcpy(data + curr, l->data + c->byteoffset, c->nbytes); + curr += c->nbytes; + + if (cmdi != (nlines - 1)) { + data[curr] = '\n'; + ++curr; + ++total_bytes; + ++total_chars; + } + } + + free(copy_cmds); + return (struct text_chunk){ + .text = data, + .line = 0, + .nbytes = total_bytes, + .nchars = total_chars, + .allocated = true, + }; +} + +bool text_line_contains_unicode(struct text *text, uint32_t line) { + return text->lines[line].nbytes != text->lines[line].nchars; +} diff --git a/src/dged/text.h b/src/dged/text.h new file mode 100644 index 0000000..fbee89b --- /dev/null +++ b/src/dged/text.h @@ -0,0 +1,54 @@ +#include <stdbool.h> +#include <stddef.h> +#include <stdint.h> + +// opaque so it is easier to change representation to gap, rope etc. +struct text; + +struct render_command; + +struct text *text_create(uint32_t initial_capacity); +void text_destroy(struct text *text); + +/** + * Clear the text without reclaiming memory + */ +void text_clear(struct text *text); + +void text_insert_at(struct text *text, uint32_t line, uint32_t col, + uint8_t *bytes, uint32_t nbytes, uint32_t *lines_added, + uint32_t *cols_added); + +void text_append(struct text *text, uint8_t *bytes, uint32_t nbytes, + uint32_t *lines_added, uint32_t *cols_added); + +void text_delete(struct text *text, uint32_t start_line, uint32_t start_col, + uint32_t end_line, uint32_t end_col); + +uint32_t text_num_lines(struct text *text); +uint32_t text_line_length(struct text *text, uint32_t lineidx); +uint32_t text_line_size(struct text *text, uint32_t lineidx); +uint32_t text_col_to_byteindex(struct text *text, uint32_t line, uint32_t col); +uint32_t text_byteindex_to_col(struct text *text, uint32_t line, + uint32_t byteindex); + +struct text_chunk { + uint8_t *text; + uint32_t nbytes; + uint32_t nchars; + uint32_t line; + bool allocated; +}; + +typedef void (*chunk_cb)(struct text_chunk *chunk, void *userdata); +void text_for_each_line(struct text *text, uint32_t line, uint32_t nlines, + chunk_cb callback, void *userdata); + +void text_for_each_chunk(struct text *text, chunk_cb callback, void *userdata); + +struct text_chunk text_get_line(struct text *text, uint32_t line); +struct text_chunk text_get_region(struct text *text, uint32_t start_line, + uint32_t start_col, uint32_t end_line, + uint32_t end_col); + +bool text_line_contains_unicode(struct text *text, uint32_t line); diff --git a/src/dged/undo.c b/src/dged/undo.c new file mode 100644 index 0000000..8f00f0f --- /dev/null +++ b/src/dged/undo.c @@ -0,0 +1,181 @@ +#include "undo.h" +#include "string.h" +#include "vec.h" + +#include <stdio.h> +#include <stdlib.h> + +void undo_init(struct undo_stack *undo, uint32_t initial_capacity) { + undo->top = INVALID_TOP; + undo->undo_in_progress = false; + VEC_INIT(&undo->records, initial_capacity); +} + +void undo_clear(struct undo_stack *undo) { + undo->top = INVALID_TOP; + VEC_CLEAR(&undo->records); +} + +void undo_destroy(struct undo_stack *undo) { + VEC_FOR_EACH(&undo->records, struct undo_record * rec) { + if (rec->type == Undo_Delete && rec->delete.data != NULL && + rec->delete.nbytes > 0) { + free(rec->delete.data); + } + } + + undo_clear(undo); + + VEC_DESTROY(&undo->records); +} + +uint32_t undo_push_boundary(struct undo_stack *undo, + struct undo_boundary boundary) { + + // we can only have one save point + if (boundary.save_point) { + VEC_FOR_EACH(&undo->records, struct undo_record * rec) { + if (rec->type == Undo_Boundary && rec->boundary.save_point) { + rec->boundary.save_point = false; + } + } + } + + VEC_APPEND(&undo->records, struct undo_record * rec); + rec->type = Undo_Boundary; + rec->boundary = boundary; + + if (!undo->undo_in_progress) { + undo->top = VEC_SIZE(&undo->records) - 1; + } + + return VEC_SIZE(&undo->records) - 1; +} + +bool pos_equal(struct position *a, struct position *b) { + return a->row == b->row && a->col == b->col; +} + +uint32_t undo_push_add(struct undo_stack *undo, struct undo_add add) { + + // "compress" + if (!VEC_EMPTY(&undo->records) && + VEC_BACK(&undo->records)->type == Undo_Add && + pos_equal(&VEC_BACK(&undo->records)->add.end, &add.begin)) { + VEC_BACK(&undo->records)->add.end = add.end; + } else { + VEC_APPEND(&undo->records, struct undo_record * rec); + rec->type = Undo_Add; + rec->add = add; + } + + if (!undo->undo_in_progress) { + undo->top = VEC_SIZE(&undo->records) - 1; + } + + return VEC_SIZE(&undo->records) - 1; +} + +uint32_t undo_push_delete(struct undo_stack *undo, struct undo_delete delete) { + VEC_APPEND(&undo->records, struct undo_record * rec); + rec->type = Undo_Delete; + rec->delete = delete; + + if (!undo->undo_in_progress) { + undo->top = VEC_SIZE(&undo->records) - 1; + } + + return VEC_SIZE(&undo->records) - 1; +} + +void undo_begin(struct undo_stack *undo) { undo->undo_in_progress = true; } + +void undo_next(struct undo_stack *undo, struct undo_record **records_out, + uint32_t *nrecords_out) { + *nrecords_out = 0; + *records_out = NULL; + + if (VEC_EMPTY(&undo->records)) { + return; + } + + if (undo->top == INVALID_TOP) { + // reset back to the top (redo) + undo->top = VEC_SIZE(&undo->records) - 1; + } + + uint32_t nrecords = 1; + struct undo_record *current = &VEC_ENTRIES(&undo->records)[undo->top]; + + // skip any leading boundaries + while (undo->top > 0 && current->type == Undo_Boundary) { + ++nrecords; + --undo->top; + current = &VEC_ENTRIES(&undo->records)[undo->top]; + } + + // find the next boundary + while (undo->top > 0 && current->type != Undo_Boundary) { + ++nrecords; + --undo->top; + current = &VEC_ENTRIES(&undo->records)[undo->top]; + } + + if (nrecords > 0) { + *records_out = calloc(nrecords, sizeof(struct undo_record)); + *nrecords_out = nrecords; + + struct undo_record *dest = *records_out; + + // copy backwards + for (uint32_t reci = undo->top + nrecords, outi = 0; reci > undo->top; + --reci, ++outi) { + dest[outi] = VEC_ENTRIES(&undo->records)[reci - 1]; + } + } + + if (undo->top > 0) { + --undo->top; + } else { + undo->top = INVALID_TOP; + } +} + +void undo_end(struct undo_stack *undo) { undo->undo_in_progress = false; } + +uint32_t undo_size(struct undo_stack *undo) { return VEC_SIZE(&undo->records); } +uint32_t undo_current_position(struct undo_stack *undo) { return undo->top; } + +size_t rec_to_str(struct undo_record *rec, char *buffer, size_t n) { + switch (rec->type) { + case Undo_Add: + return snprintf(buffer, n, "add { begin: (%d, %d) end: (%d, %d)}", + rec->add.begin.row, rec->add.begin.col, rec->add.end.row, + rec->add.end.col); + case Undo_Delete: + return snprintf(buffer, n, "delete { pos: (%d, %d), ptr: 0x%p, nbytes: %d}", + rec->delete.pos.row, rec->delete.pos.col, rec->delete.data, + rec->delete.nbytes); + default: + return snprintf(buffer, n, "boundary { save_point: %s }", + rec->boundary.save_point ? "yes" : "no"); + } +} + +const char *undo_dump(struct undo_stack *undo) { + uint32_t left = 8192; + const char *buf = malloc(left); + char *pos = (char *)buf; + pos[0] = '\0'; + + char rec_buf[256]; + VEC_FOR_EACH_INDEXED(&undo->records, struct undo_record * rec, reci) { + rec_to_str(rec, rec_buf, 256); + uint32_t written = snprintf(pos, left, "%d: [%s]%s\n", reci, rec_buf, + reci == undo->top ? " <- top" : ""); + left = written > left ? 0 : left - written; + pos += written; + } + + return buf; +} diff --git a/src/dged/undo.h b/src/dged/undo.h new file mode 100644 index 0000000..1ce3a8a --- /dev/null +++ b/src/dged/undo.h @@ -0,0 +1,66 @@ +#include "vec.h" +#include <stdbool.h> +#include <stdint.h> + +enum undo_record_type { + Undo_Boundary = 1, + Undo_Add = 2, + Undo_Delete = 3, +}; + +struct position { + uint32_t row; + uint32_t col; +}; + +struct undo_boundary { + bool save_point; +}; + +struct undo_add { + struct position begin; + struct position end; +}; + +struct undo_delete { + struct position pos; + uint8_t *data; + uint32_t nbytes; +}; + +struct undo_record { + enum undo_record_type type; + + union { + struct undo_boundary boundary; + struct undo_add add; + struct undo_delete delete; + }; +}; + +#define INVALID_TOP -1 + +struct undo_stack { + VEC(struct undo_record) records; + uint32_t top; + bool undo_in_progress; +}; + +void undo_init(struct undo_stack *undo, uint32_t initial_capacity); +void undo_clear(struct undo_stack *undo); +void undo_destroy(struct undo_stack *undo); + +uint32_t undo_push_boundary(struct undo_stack *undo, + struct undo_boundary boundary); + +uint32_t undo_push_add(struct undo_stack *undo, struct undo_add add); +uint32_t undo_push_delete(struct undo_stack *undo, struct undo_delete delete); + +void undo_begin(struct undo_stack *undo); +void undo_next(struct undo_stack *undo, struct undo_record **records_out, + uint32_t *nrecords_out); +void undo_end(struct undo_stack *undo); + +uint32_t undo_size(struct undo_stack *undo); +uint32_t undo_current_position(struct undo_stack *undo); +const char *undo_dump(struct undo_stack *undo); diff --git a/src/dged/utf8.c b/src/dged/utf8.c new file mode 100644 index 0000000..abf5ef7 --- /dev/null +++ b/src/dged/utf8.c @@ -0,0 +1,67 @@ +#include "utf8.h" + +#include <stdio.h> + +bool utf8_byte_is_unicode_start(uint8_t byte) { return (byte & 0xc0) == 0xc0; } +bool utf8_byte_is_unicode_continuation(uint8_t byte) { + return utf8_byte_is_unicode(byte) && !utf8_byte_is_unicode_start(byte); +} +bool utf8_byte_is_unicode(uint8_t byte) { return (byte & 0x80) != 0x0; } +bool utf8_byte_is_ascii(uint8_t byte) { return !utf8_byte_is_unicode(byte); } + +uint32_t utf8_nbytes_in_char(uint8_t byte) { + // length of char is the number of leading ones + // flip it and count number of leading zeros + uint8_t invb = ~byte; + return __builtin_clz((uint32_t)invb) - 24; +} + +// TODO: grapheme clusters, this returns the number of unicode code points +uint32_t utf8_nchars(uint8_t *bytes, uint32_t nbytes) { + uint32_t nchars = 0; + uint32_t expected = 0; + for (uint32_t bi = 0; bi < nbytes; ++bi) { + uint8_t byte = bytes[bi]; + if (utf8_byte_is_unicode(byte)) { + if (utf8_byte_is_unicode_start(byte)) { + expected = utf8_nbytes_in_char(byte) - 1; + } else { // continuation byte + --expected; + if (expected == 0) { + ++nchars; + } + } + } else { // ascii + ++nchars; + } + } + return nchars; +} + +// TODO: grapheme clusters, this uses the number of unicode code points +uint32_t utf8_nbytes(uint8_t *bytes, uint32_t nbytes, uint32_t nchars) { + + uint32_t bi = 0; + uint32_t chars = 0; + uint32_t expected = 0; + + while (chars < nchars && bi < nbytes) { + uint8_t byte = bytes[bi]; + if (utf8_byte_is_unicode(byte)) { + if (utf8_byte_is_unicode_start(byte)) { + expected = utf8_nbytes_in_char(byte) - 1; + } else { // continuation char + --expected; + if (expected == 0) { + ++chars; + } + } + } else { // ascii + ++chars; + } + + ++bi; + } + + return bi; +} diff --git a/src/dged/utf8.h b/src/dged/utf8.h new file mode 100644 index 0000000..59a959e --- /dev/null +++ b/src/dged/utf8.h @@ -0,0 +1,17 @@ +#include <stdbool.h> +#include <stdint.h> + +/*! + * \brief Return the number of chars the utf-8 sequence pointed at by `bytes` of + * length `nbytes`, represents + */ +uint32_t utf8_nchars(uint8_t *bytes, uint32_t nbytes); + +/* Return the number of bytes used to make up the next `nchars` characters */ +uint32_t utf8_nbytes(uint8_t *bytes, uint32_t nbytes, uint32_t nchars); + +/* true if `byte` is a unicode byte sequence start byte */ +bool utf8_byte_is_unicode_start(uint8_t byte); +bool utf8_byte_is_unicode_continuation(uint8_t byte); +bool utf8_byte_is_ascii(uint8_t byte); +bool utf8_byte_is_unicode(uint8_t byte); diff --git a/src/dged/vec.h b/src/dged/vec.h new file mode 100644 index 0000000..073f978 --- /dev/null +++ b/src/dged/vec.h @@ -0,0 +1,63 @@ +#ifndef _VEC_H +#define _VEC_H + +#include <stdlib.h> + +#define VEC(entry) \ + struct { \ + entry *entries; \ + uint32_t nentries; \ + uint32_t capacity; \ + } + +#define VEC_INIT(vec, initial_capacity) \ + (vec)->entries = malloc(sizeof((vec)->entries[0]) * initial_capacity); \ + (vec)->capacity = initial_capacity; \ + (vec)->nentries = 0; + +#define VEC_DESTROY(vec) \ + free((vec)->entries); \ + (vec)->entries = NULL; \ + (vec)->capacity = 0; \ + (vec)->nentries = 0; + +#define VEC_GROW(vec, new_size) \ + if (new_size > (vec)->capacity) { \ + (vec)->capacity = new_size; \ + (vec)->entries = realloc((vec)->entries, \ + (sizeof((vec)->entries[0]) * (vec)->capacity)); \ + } + +#define VEC_PUSH(vec, entry) \ + if ((vec)->nentries + 1 >= (vec)->capacity) { \ + VEC_GROW(vec, (vec)->capacity * 2); \ + } \ + \ + (vec)->entries[(vec)->nentries] = entry; \ + ++(vec)->nentries; + +#define VEC_APPEND(vec, var) \ + if ((vec)->nentries + 1 >= (vec)->capacity) { \ + VEC_GROW(vec, (vec)->capacity * 2); \ + } \ + \ + var = &((vec)->entries[(vec)->nentries]); \ + ++(vec)->nentries; + +#define VEC_FOR_EACH(vec, var) VEC_FOR_EACH_INDEXED(vec, var, i) + +#define VEC_FOR_EACH_INDEXED(vec, var, idx) \ + for (uint32_t keep = 1, idx = 0, size = (vec)->nentries; \ + keep && idx != size; keep = !keep, idx++) \ + for (var = (vec)->entries + idx; keep; keep = !keep) + +#define VEC_SIZE(vec) (vec)->nentries +#define VEC_CAPACITY(vec) (vec)->capacity +#define VEC_ENTRIES(vec) (vec)->entries +#define VEC_EMPTY(vec) ((vec)->nentries == 0) + +#define VEC_CLEAR(vec) (vec)->nentries = 0 +#define VEC_BACK(vec) \ + ((vec)->nentries > 0 ? &((vec)->entries[(vec)->nentries - 1]) : NULL) + +#endif diff --git a/src/dged/window.c b/src/dged/window.c new file mode 100644 index 0000000..f24997c --- /dev/null +++ b/src/dged/window.c @@ -0,0 +1,445 @@ +#include "binding.h" +#include "btree.h" +#include "buffer.h" +#include "command.h" +#include "display.h" +#include "minibuffer.h" + +enum window_type { + Window_Buffer, + Window_HSplit, + Window_VSplit, +}; + +struct window { + uint32_t x; + uint32_t y; + uint32_t width; + uint32_t height; + enum window_type type; + struct buffer_view buffer_view; + struct buffer *prev_buffer; + struct command_list *commands; + uint32_t relline; + uint32_t relcol; +}; + +BINTREE_ENTRY_TYPE(window_node, struct window); + +static struct windows { + BINTREE(window_node) windows; + struct window_node *active; + struct keymap keymap; +} g_windows; + +static struct window g_minibuffer_window; + +void windows_init(uint32_t height, uint32_t width, + struct buffer *initial_buffer, struct buffer *minibuffer) { + BINTREE_INIT(&g_windows.windows); + + g_minibuffer_window = (struct window){ + .buffer_view = buffer_view_create(minibuffer, false, false), + .prev_buffer = NULL, + .x = 0, + .y = height - 1, + .height = 1, + .width = width, + }; + + struct window root_window = (struct window){ + .buffer_view = buffer_view_create(initial_buffer, true, true), + .prev_buffer = NULL, + .height = height - 1, + .width = width, + .x = 0, + .y = 0, + }; + BINTREE_SET_ROOT(&g_windows.windows, root_window); + g_windows.active = BINTREE_ROOT(&g_windows.windows); +} + +static void window_tree_clear_sub(struct window_node *root_node) { + struct window_node *n = root_node; + BINTREE_FIRST(n); + while (n != NULL) { + struct window *w = &BINTREE_VALUE(n); + if (w->type == Window_Buffer) { + buffer_view_destroy(&w->buffer_view); + } + BINTREE_NEXT(n); + } + BINTREE_FREE_NODES(root_node, window_node); +} + +static void window_tree_clear() { + window_tree_clear_sub(BINTREE_ROOT(&g_windows.windows)); +} + +void windows_destroy() { window_tree_clear(); } + +struct window *root_window() { + return &BINTREE_VALUE(BINTREE_ROOT(&g_windows.windows)); +} + +struct window *minibuffer_window() { + return &g_minibuffer_window; +} + +static void window_tree_resize(struct window_node *root, uint32_t height, + uint32_t width) { + + /* due to the way tree traversal works, we need to disconnect the subtree from + * its potential parent. Otherwise the algorithm will traverse above the root + * of the subtree. */ + struct window_node *orig_parent = BINTREE_PARENT(root); + BINTREE_PARENT(root) = NULL; + + struct window *root_window = &BINTREE_VALUE(root); + uint32_t width_ratio_percent = (width * 100) / (root_window->width); + uint32_t height_ratio_percent = (height * 100) / (root_window->height); + root_window->width = width; + root_window->height = height; + + struct window_node *n = root; + BINTREE_FIRST(n); + while (n != NULL) { + struct window *w = &BINTREE_VALUE(n); + if (BINTREE_PARENT(n) != NULL && n != root) { + if (BINTREE_LEFT(BINTREE_PARENT(n)) == n) { + // if left child, use scale from root + w->width = (width_ratio_percent * w->width) / 100; + w->height = (height_ratio_percent * w->height) / 100; + } else { + // if right child, fill rest of space after left and parent resize + struct window *left_sibling = + &BINTREE_VALUE(BINTREE_LEFT(BINTREE_PARENT(n))); + struct window *parent = &BINTREE_VALUE(BINTREE_PARENT(n)); + + w->width = parent->width; + w->height = parent->height; + if (parent->type == Window_HSplit) { + w->y = parent->y + left_sibling->height; + w->height -= left_sibling->height; + } else { + w->x = parent->x + left_sibling->width; + w->width -= left_sibling->width; + } + } + } + BINTREE_NEXT(n); + } + + BINTREE_PARENT(root) = orig_parent; +} + +void windows_resize(uint32_t height, uint32_t width) { + g_minibuffer_window.width = width; + g_minibuffer_window.y = height - 1; + + window_tree_resize(BINTREE_ROOT(&g_windows.windows), height - 1, width); +} + +void windows_update(void *(*frame_alloc)(size_t), uint64_t frame_time) { + struct window_node *n = BINTREE_ROOT(&g_windows.windows); + BINTREE_FIRST(n); + while (n != NULL) { + struct window *w = &BINTREE_VALUE(n); + if (w->type == Window_Buffer) { + w->commands = command_list_create(w->height * w->width, frame_alloc, w->x, + w->y, w->buffer_view.buffer->name); + + buffer_update(&w->buffer_view, w->width, w->height, w->commands, + frame_time, &w->relline, &w->relcol); + } + + BINTREE_NEXT(n); + } + + struct window *w = &g_minibuffer_window; + w->commands = command_list_create(w->height * w->width, frame_alloc, w->x, + w->y, w->buffer_view.buffer->name); + buffer_update(&w->buffer_view, w->width, w->height, w->commands, frame_time, + &w->relline, &w->relcol); +} + +void windows_render(struct display *display) { + struct window_node *n = BINTREE_ROOT(&g_windows.windows); + BINTREE_FIRST(n); + while (n != NULL) { + struct window *w = &BINTREE_VALUE(n); + if (w->type == Window_Buffer) { + display_render(display, w->commands); + } + BINTREE_NEXT(n); + } + + display_render(display, g_minibuffer_window.commands); +} + +struct window_node *find_window(struct window *window) { + struct window_node *n = BINTREE_ROOT(&g_windows.windows); + BINTREE_FIRST(n); + while (n != NULL) { + struct window *w = &BINTREE_VALUE(n); + if (w == window) { + return n; + } + BINTREE_NEXT(n); + } + + return NULL; +} + +void windows_set_active(struct window *window) { + struct window_node *n = find_window(window); + if (n != NULL) { + g_windows.active = n; + } +} + +struct window *windows_get_active() { + return &BINTREE_VALUE(g_windows.active); +} + +void window_set_buffer(struct window *window, struct buffer *buffer) { + window->prev_buffer = window->buffer_view.buffer; + buffer_view_destroy(&window->buffer_view); + window->buffer_view = buffer_view_create(buffer, true, true); +} + +struct buffer *window_buffer(struct window *window) { + return window->buffer_view.buffer; +} + +struct buffer_view *window_buffer_view(struct window *window) { + return &window->buffer_view; +} + +struct buffer *window_prev_buffer(struct window *window) { + return window->prev_buffer; +} + +bool window_has_prev_buffer(struct window *window) { + return window->prev_buffer != NULL; +} + +struct buffer_location window_cursor_location(struct window *window) { + return (struct buffer_location){ + .col = window->relcol, + .line = window->relline, + }; +} +struct buffer_location window_absolute_cursor_location(struct window *window) { + return (struct buffer_location){ + .col = window->x + window->relcol, + .line = window->y + window->relline, + }; +} + +void window_close(struct window *window) { + // do not want to delete last window + if (window == root_window()) { + return; + } + + struct window_node *to_delete = find_window(window); + if (to_delete == NULL) { + return; + } + + // promote other child to parent + struct window_node *target = BINTREE_PARENT(to_delete); + struct window_node *source = BINTREE_RIGHT(target) == to_delete + ? BINTREE_LEFT(target) + : BINTREE_RIGHT(target); + + buffer_view_destroy(&window->buffer_view); + BINTREE_REMOVE(to_delete); + BINTREE_FREE_NODE(to_delete); + + BINTREE_VALUE(source).x = BINTREE_VALUE(target).x; + BINTREE_VALUE(source).y = BINTREE_VALUE(target).y; + uint32_t target_width = BINTREE_VALUE(target).width; + uint32_t target_height = BINTREE_VALUE(target).height; + + // copy the node value and set it's children as children of the target node + BINTREE_VALUE(target) = BINTREE_VALUE(source); + BINTREE_LEFT(target) = BINTREE_LEFT(source); + BINTREE_RIGHT(target) = BINTREE_RIGHT(source); + + // adopt the children + if (BINTREE_HAS_LEFT(source)) { + BINTREE_PARENT(BINTREE_LEFT(source)) = target; + } + + if (BINTREE_HAS_RIGHT(source)) { + BINTREE_PARENT(BINTREE_RIGHT(source)) = target; + } + + BINTREE_FREE_NODE(source); + + window_tree_resize(target, target_height, target_width); + BINTREE_FIRST(target); + windows_set_active(&BINTREE_VALUE(target)); +} + +void window_close_others(struct window *window) { + struct window_node *root = BINTREE_ROOT(&g_windows.windows); + + // copy window and make it suitable as a root window + struct window new_root = *window; + new_root.x = 0; + new_root.y = 0; + new_root.buffer_view = buffer_view_clone(&window->buffer_view); + new_root.width = BINTREE_VALUE(root).width; + new_root.height = BINTREE_VALUE(root).height; + + window_tree_clear(); + + // create new root window + BINTREE_SET_ROOT(&g_windows.windows, new_root); + windows_set_active(&BINTREE_VALUE(BINTREE_ROOT(&g_windows.windows))); +} + +void window_hsplit(struct window *window, struct window **new_window_a, + struct window **new_window_b) { + struct window_node *n = find_window(window); + if (n != NULL) { + struct window w = BINTREE_VALUE(n); + + if (w.type == Window_Buffer) { + struct window parent = {0}; + parent.type = Window_HSplit; + parent.x = w.x; + parent.y = w.y; + parent.width = w.width; + parent.height = w.height; + BINTREE_VALUE(n) = parent; + + /* Reuse the current window as the 'left' child, halving the height */ + w.height /= 2; + BINTREE_INSERT(n, w); + *new_window_a = &BINTREE_VALUE(BINTREE_LEFT(n)); + windows_set_active(*new_window_a); + + /* Create a new window for the split, showing the same buffer as the + * original window. + */ + struct window new_window = {0}; + new_window.type = Window_Buffer; + new_window.buffer_view = + buffer_view_create(w.buffer_view.buffer, true, true); + buffer_goto(&new_window.buffer_view, w.buffer_view.dot.line, + w.buffer_view.dot.col); + new_window.prev_buffer = w.prev_buffer; + new_window.x = w.x; + new_window.y = w.y + w.height; + new_window.width = w.width; + new_window.height = parent.height - w.height; + BINTREE_INSERT(n, new_window); + *new_window_b = &BINTREE_VALUE(BINTREE_RIGHT(n)); + } + } +} + +void window_vsplit(struct window *window, struct window **new_window_a, + struct window **new_window_b) { + struct window_node *n = find_window(window); + if (n != NULL) { + struct window w = BINTREE_VALUE(n); + + if (w.type == Window_Buffer) { + /* Create a new split container to use as parent */ + struct window parent = {0}; + parent.type = Window_VSplit; + parent.x = w.x; + parent.y = w.y; + parent.width = w.width; + parent.height = w.height; + BINTREE_VALUE(n) = parent; + + /* Reuse the current window as the 'left' child, halving the width */ + w.width /= 2; + BINTREE_INSERT(n, w); + *new_window_a = &BINTREE_VALUE(BINTREE_LEFT(n)); + windows_set_active(*new_window_a); + + /* Create a new window for the split, showing the same buffer as the + * original window. + */ + struct window new_window = {0}; + new_window.type = Window_Buffer; + new_window.buffer_view = + buffer_view_create(w.buffer_view.buffer, true, true); + buffer_goto(&new_window.buffer_view, w.buffer_view.dot.line, + w.buffer_view.dot.col); + new_window.prev_buffer = w.prev_buffer; + new_window.x = w.x + w.width; + new_window.y = w.y; + new_window.width = parent.width - w.width; + new_window.height = w.height; + BINTREE_INSERT(n, new_window); + *new_window_b = &BINTREE_VALUE(BINTREE_RIGHT(n)); + } + } +} + +void window_split(struct window *window, struct window **new_window_a, + struct window **new_window_b) { + /* The height * 2 is a horrible hack, we would need to know how big the font + actually is */ + window->height * 2 > window->width + ? window_hsplit(window, new_window_a, new_window_b) + : window_vsplit(window, new_window_a, new_window_b); +} + +struct window *windows_focus_next() { + struct window *active = windows_get_active(); + struct window_node *n = find_window(active); + BINTREE_NEXT(n); + while (n != NULL) { + struct window *w = &BINTREE_VALUE(n); + if (w->type == Window_Buffer) { + windows_set_active(w); + return w; + } + BINTREE_NEXT(n); + } + + // we have moved around + n = BINTREE_ROOT(&g_windows.windows); + BINTREE_FIRST(n); + if (n != NULL) { + windows_set_active(&BINTREE_VALUE(n)); + return &BINTREE_VALUE(n); + } + + // fall back to root + windows_set_active(root_window()); + return root_window(); +} + +struct window *windows_focus(uint32_t id) { + uint32_t curr_id = 0; + + struct window_node *n = BINTREE_ROOT(&g_windows.windows); + BINTREE_FIRST(n); + while (n != NULL) { + struct window *w = &BINTREE_VALUE(n); + if (w->type == Window_Buffer) { + if (curr_id == id) { + windows_set_active(w); + return w; + } + ++curr_id; + } + BINTREE_NEXT(n); + } + + return NULL; +} + +uint32_t window_width(struct window *window) { return window->width; } + +uint32_t window_height(struct window *window) { return window->height; } diff --git a/src/dged/window.h b/src/dged/window.h new file mode 100644 index 0000000..b3284e9 --- /dev/null +++ b/src/dged/window.h @@ -0,0 +1,48 @@ +#include <stdbool.h> +#include <stdint.h> + +#include "btree.h" + +struct command_list; +struct display; +struct keymap; +struct commands; +struct buffer; + +struct window; +struct windows; + +void windows_init(uint32_t height, uint32_t width, + struct buffer *initial_buffer, struct buffer *minibuffer); + +void windows_destroy(); +void windows_resize(uint32_t height, uint32_t width); +void windows_update(void *(*frame_alloc)(size_t), uint64_t frame_time); +void windows_render(struct display *display); + +struct window *root_window(); +struct window *minibuffer_window(); + +void windows_set_active(struct window *window); +struct window *windows_focus(uint32_t id); +struct window *windows_get_active(); +struct window *windows_focus_next(); + +void window_set_buffer(struct window *window, struct buffer *buffer); +struct buffer *window_buffer(struct window *window); +struct buffer_view *window_buffer_view(struct window *window); +struct buffer *window_prev_buffer(struct window *window); +bool window_has_prev_buffer(struct window *window); +struct buffer_location window_cursor_location(struct window *window); +struct buffer_location window_absolute_cursor_location(struct window *window); +uint32_t window_width(struct window *window); +uint32_t window_height(struct window *window); + +void window_close(struct window *window); +void window_close_others(struct window *window); +void window_split(struct window *window, struct window **new_window_a, + struct window **new_window_b); +void window_hsplit(struct window *window, struct window **new_window_a, + struct window **new_window_b); +void window_vsplit(struct window *window, struct window **new_window_a, + struct window **new_window_b); |