krzosa/wasm_transcript_browser
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

buffer16 api work

Browse Source
This commit is contained in:
Krzosa Karol
2025-04-10 22:07:14 +02:00
parent 13295a2fcd
commit c8a4d19a72
13 changed files with 342 additions and 240 deletions
Download Patch File Download Diff File Expand all files Collapse all files

270
src/text_editor/text_editor_buffer.c → src/text_editor/buffer16.c
View File

@@ -1,74 +1,57 @@
#define BUFFER_DEBUG 1
typedef struct caret_t caret_t;
struct caret_t {
i64 ifront;
union {
r1i64_t range;
i64 pos[2];
};
};
typedef struct xy_t xy_t;
struct xy_t {
i64 col;
i64 line;
};
typedef struct edit16_t edit16_t;
struct edit16_t {
r1i64_t range;
s16_t string;
};
// @todo: redo tree
typedef array(edit16_t) array_edit16_t;
typedef array(caret_t) array_caret_t;
typedef struct history16_t history16_t;
struct history16_t {
array_edit16_t edits;
array_caret_t carets;
};
typedef array(history16_t) array_history16_t;
typedef struct buffer16_id_t buffer16_id_t;
struct buffer16_id_t { i64 e; };
typedef struct buffer16_t buffer16_t;
struct buffer16_t {
s8_t name;
buffer16_id_t id;
i32 change_id;
i8 edit_phase;
struct {
b8 dirty: 1;
b8 history: 1;
b8 line_starts: 1;
} flags;
union {
s16_t string;
u16 *data;
struct {
u16 *str;
i64 len;
};
};
i64 cap;
array_i64_t line_starts;
array_history16_t undo_stack;
array_history16_t redo_stack;
alo_t alo;
};
gb i64 buffer_raw_ids;
const b32 dont_kill_selection = false;
const b32 kill_selection = true;
fn void buffer16_multi_cursor_apply_edits(buffer16_t *buffer, array_edit16_t edits);
///////////////////////////////
// caret helpers
///////////////////////////////
fn i64 caret_get_front(caret_t caret) {
i64 result = caret.pos[caret.ifront];
return result;
}
fn i64 caret_get_back(caret_t caret) {
i64 result = caret.pos[(caret.ifront + 1) % 2];
return result;
}
fn caret_t caret_make(i64 front, i64 back) {
caret_t result = {0};
if (front >= back) {
result.range.min = back;
result.range.max = front;
result.ifront = 1;
} else {
result.range.min = front;
result.range.max = back;
result.ifront = 0;
}
return result;
}
fn caret_t caret_set_front(caret_t caret, i64 pos) {
i64 back = caret_get_back(caret);
caret_t result = caret_make(pos, back);
return result;
}
fn caret_t caret_set_back(caret_t caret, i64 pos) {
i64 front = caret_get_front(caret);
caret_t result = caret_make(front, pos);
return result;
}
fn b32 carets_are_equal(caret_t a, caret_t b) {
b32 result = r1i64_are_equal(a.range, b.range) && a.ifront == b.ifront;
return result;
}
fn b32 carets_overlap(caret_t a, caret_t b) {
b32 result = r1i64_overlap(a.range, b.range);
return result;
}
///////////////////////////////
// buffer helpers
@@ -181,47 +164,6 @@ fn r1i64_t buffer16_clamp_range(buffer16_t *buffer, r1i64_t range) {
return result;
}
fn i64 caret_get_front(caret_t caret) {
i64 result = caret.pos[caret.ifront];
return result;
}
fn i64 caret_get_back(caret_t caret) {
i64 result = caret.pos[(caret.ifront + 1) % 2];
return result;
}
fn caret_t caret_make(i64 front, i64 back) {
caret_t result = {0};
if (front >= back) {
result.range.min = back;
result.range.max = front;
result.ifront = 1;
} else {
result.range.min = front;
result.range.max = back;
result.ifront = 0;
}
return result;
}
fn caret_t caret_set_front(caret_t caret, i64 pos) {
i64 back = caret_get_back(caret);
caret_t result = caret_make(pos, back);
return result;
}
fn caret_t caret_set_back(caret_t caret, i64 pos) {
i64 front = caret_get_front(caret);
caret_t result = caret_make(front, pos);
return result;
}
fn b32 carets_are_equal(caret_t a, caret_t b) {
b32 result = r1i64_are_equal(a.range, b.range) && a.ifront == b.ifront;
return result;
}
fn i64 buffer16_get_word_start(buffer16_t *buffer, i64 pos) {
pos = CLAMP(pos, (i64)0, buffer->len);
for (i64 i = pos - 1; i >= 0; i -= 1) {
@@ -257,7 +199,7 @@ fn i64 buffer16_get_next_word_end(buffer16_t *buffer, i64 pos) {
// semantics - proper max is one past last index
if (!(i < buffer->len))
break;
fn if (prev == L'\n' || (prev && prev != buffer->str[i]) || char16_is_word(buffer->str[i])) {
if (prev == L'\n' || (prev && prev != buffer->str[i]) || char16_is_word(buffer->str[i])) {
break;
}
prev = buffer->str[i];
@@ -271,7 +213,7 @@ fn i64 buffer16_get_prev_word_start(buffer16_t *buffer, i64 pos) {
u16 prev = 0;
i64 i = pos - 1;
for (; i >= 0; i -= 1) {
fn if (prev == L'\n' || (prev && prev != buffer->str[i]) || char16_is_word(buffer->str[i])) {
if (prev == L'\n' || (prev && prev != buffer->str[i]) || char16_is_word(buffer->str[i])) {
break;
}
pos = i;
@@ -332,20 +274,6 @@ fn i64 buffer16_offset_pos_by_line(buffer16_t *buffer, i64 pos, i64 line_offset)
// raw buffer operations
///////////////////////////////
fn void buffer16_raw_init(alo_t alo, buffer16_t *buffer, s8_t name, i64 size) {
buffer->id = (buffer16_id_t){++buffer_raw_ids};
buffer->name = name;
buffer->alo = alo;
buffer->cap = size;
buffer->data = alloc_array(alo, u16, size);
array_init(alo, &buffer->line_starts, 128);
array_init(alo, &buffer->undo_stack, 128);
array_init(alo, &buffer->redo_stack, 128);
buffer->flags.line_starts = true;
buffer->flags.history = true;
array_add(&buffer->line_starts, 0);
}
fn void buffer16_raw_grow(buffer16_t *buffer, i64 change_size) {
i64 new_size = buffer->len + change_size;
if (new_size > buffer->cap) {
@@ -453,6 +381,32 @@ fn void buffer16_raw_replace_text(buffer16_t *buffer, r1i64_t range, s16_t strin
#endif
}
///////////////////////////////
// buffer multicursor + history
///////////////////////////////
fn void buffer16_init(alo_t alo, buffer16_t *buffer, s8_t name, i64 size) {
buffer->id = (buffer16_id_t){++buffer_raw_ids};
buffer->name = name;
buffer->alo = alo;
buffer->cap = size;
buffer->data = alloc_array(alo, u16, size);
array_init(alo, &buffer->line_starts, 128);
array_init(alo, &buffer->undo_stack, 128);
array_init(alo, &buffer->redo_stack, 128);
buffer->flags.line_starts = true;
buffer->flags.history = true;
array_add(&buffer->line_starts, 0);
}
fn void buffer16_deinit(buffer16_t *buffer) {
// @todo: verify this works
array_dealloc(&buffer->line_starts);
dealloc(buffer->alo, buffer->data);
buffer16_dealloc_history_array(buffer, &buffer->undo_stack);
buffer16_dealloc_history_array(buffer, &buffer->redo_stack);
}
fn void buffer16_save_history_before_merge_cursor(buffer16_t *buffer, array_history16_t *stack, array_caret_t *carets) {
if (!buffer->flags.history) {
return;
@@ -473,24 +427,25 @@ fn void buffer16_save_history_before_apply_edits(buffer16_t *buffer, array_histo
// make reverse edits
array_for(edit16_t, it, &entry->edits) {
it->range = (r1i64_t){it->range.min, it->range.min + it->string.len};
it->string = s16_alo_copy(buffer->alo, buffer16_get_string(buffer, it->range));
r1i64_t new_range = {it->range.min, it->range.min + it->string.len};
s16_t string = buffer16_get_string(buffer, it->range);
it->string = s16_copy_ex(buffer->alo, string);
it->range = new_range;
}
ma_temp_t scratch = ma_begin_scratch1(buffer->alo.object);
array_edit16_t temp_edit = {0};
array_copy(ma_temp_alo(scratch), &temp_edit, &entry->edits);
array_copy(malot(scratch), &temp_edit, &entry->edits);
// fix reverse edits
for (int i = 0; i < edits->len; i += 1) {
edit16_t *it = edits->data + i;
i64 remove_size = r1i64_size(it->range);
i64 insert_size = it->string.len;
array_for(edit16_t, edit, edits) {
i64 remove_size = r1i64_size(edit->range);
i64 insert_size = edit->string.len;
i64 offset = insert_size - remove_size;
for (int j = 0; j < entry->edits.len; j += 1) {
for (i64 i = 0; i < entry->edits.len; i += 1) {
edit16_t *new_edit = entry->edits.data + i;
edit16_t *old_edit = temp_edit.data + i;
if (old_edit->range.min > it->range.min) {
if (old_edit->range.min > edit->range.min) {
new_edit->range.min += offset;
new_edit->range.max += offset;
}
@@ -520,11 +475,12 @@ fn void buffer16_redo_edit(buffer16_t *buffer, array_caret_t *carets) {
}
fn void buffer16_undo_edit(buffer16_t *buffer, array_caret_t *carets) {
if (!buffer->flags.history || buffer->redo_stack.len <= 0) {
if (!buffer->flags.history || buffer->undo_stack.len <= 0) {
return;
}
history16_t entry = array_pop(&buffer->undo_stack);
buffer16_save_history_before_merge_cursor(buffer, &buffer->redo_stack, carets);
buffer16_save_history_before_apply_edits(buffer, &buffer->redo_stack, &entry.edits);
buffer16_multi_cursor_apply_edits(buffer, entry.edits);
@@ -557,10 +513,6 @@ fn void buffer16_dealloc_history_entries(buffer16_t *buffer, array_history16_t *
}
fn void buffer16_clear_redo_stack(buffer16_t *buffer) {
buffer16_dealloc_history_entries(buffer, &buffer->redo_stack);
}
fn void buffer16_dealloc_history_array(buffer16_t *buffer, array_history16_t *entries) {
buffer16_dealloc_history_entries(buffer, entries);
array_dealloc(entries);
@@ -575,7 +527,7 @@ fn array_edit16_t buffer16_begin_edit(alo_t alo, buffer16_t *buffer, array_caret
buffer->edit_phase += 1;
assert(carets->len);
buffer16_save_history_before_merge_cursor(buffer, &buffer->undo_stack, carets);
buffer16_clear_redo_stack(buffer);
buffer16_dealloc_history_entries(buffer, &buffer->redo_stack);
}
array_edit16_t edits = (array_edit16_t){.alo = alo};
return edits;
@@ -596,7 +548,7 @@ fn void buffer16_adjust_carets(array_edit16_t *edits, array_caret_t *carets) {
assert(edits->alo.object == carets->alo.object);
array_caret_t new_carets = {0};
array_copy(ma_temp_alo(scratch), &new_carets, carets);
array_copy(malot(scratch), &new_carets, carets);
array_for(edit16_t, it, edits) {
i64 remove_size = r1i64_size(it->range);
i64 insert_size = it->string.len;
@@ -643,7 +595,7 @@ fn void buffer16_end_edit(buffer16_t *buffer, array_edit16_t *edits, array_caret
assert(buffer->alo.object == edits->alo.object);
array_caret_t new_carets = {0};
array_copy(ma_temp_alo(scratch), &new_carets, carets);
array_copy(malot(scratch), &new_carets, carets);
array_for(edit16_t, it, edits) {
i64 remove_size = r1i64_size(it->range);
i64 insert_size = it->string.len;
@@ -679,7 +631,7 @@ fn void buffer16_end_edit(buffer16_t *buffer, array_edit16_t *edits, array_caret
ma_end_scratch(scratch);
}
void caret_merge_sort(i64 Count, caret_t *First, caret_t *Temp) {
fn void caret_merge_sort(i64 Count, caret_t *First, caret_t *Temp) {
// SortKey = range.min
if (Count == 1) {
// NOTE(casey): No work to do.
@@ -733,7 +685,7 @@ void caret_merge_sort(i64 Count, caret_t *First, caret_t *Temp) {
}
}
void edit16_merge_sort(i64 Count, edit16_t *First, edit16_t *Temp) {
fn void edit16_merge_sort(i64 Count, edit16_t *First, edit16_t *Temp) {
// SortKey = range.min
if (Count == 1) {
// NOTE(casey): No work to do.
@@ -814,7 +766,7 @@ fn void buffer16_multi_cursor_apply_edits(buffer16_t *buffer, array_edit16_t edi
{
ma_temp_t scratch = ma_begin_scratch1(buffer->alo.object);
array_edit16_t edits_copy = {0};
array_copy(ma_temp_alo(scratch), &edits_copy, &edits);
array_copy(malot(scratch), &edits_copy, &edits);
if (edits.len > 1) edit16_merge_sort(edits.len, edits_copy.data, edits.data);
edits = edits_copy;
ma_end_scratch(scratch);
@@ -854,7 +806,7 @@ fn void buffer16_merge_carets(buffer16_t *buffer, array_caret_t *carets) {
ma_temp_t scratch = ma_begin_scratch1(buffer->alo.object);
array_caret_t c1 = {0};
array_copy(ma_temp_alo(scratch), &c1, carets);
array_copy(malot(scratch), &c1, carets);
if (carets->len > 1) {
caret_merge_sort(carets->len, c1.data, carets->data);
}
@@ -887,7 +839,7 @@ fn_test void buffer16_test(void) {
{
s16_t string = s16("thing itself");
buffer16_t *buffer = ma_push_type(scratch.arena, buffer16_t);
buffer16_raw_init(ma_temp_alo(scratch), buffer, S8_FILE_AND_LINE, 16);
buffer16_init(malot(scratch), buffer, S8_FILE_AND_LINE, 16);
buffer16_raw_replace_text(buffer, r1i64_null, string);
assert(s16_are_equal(buffer->string, string));
assert(buffer->cap == 16);
@@ -919,7 +871,7 @@ fn_test void buffer16_test(void) {
{
s16_t string = s16("thing itself_and meme");
buffer16_t *buffer = ma_push_type(scratch.arena, buffer16_t);
buffer16_raw_init(ma_temp_alo(scratch), buffer, S8_FILE_AND_LINE, 10);
buffer16_init(malot(scratch), buffer, S8_FILE_AND_LINE, 10);
buffer16_raw_replace_text(buffer, r1i64_null, string);
r1i64_t range = buffer16_enclose_word(buffer, 18);
buffer16_raw_replace_text(buffer, range, s16("cat"));
@@ -934,7 +886,7 @@ fn_test void buffer16_test(void) {
{
buffer16_t *buffer = ma_push_type(scratch.arena, buffer16_t);
buffer16_raw_init(ma_temp_alo(scratch), buffer, S8_FILE_AND_LINE, 16);
buffer16_init(malot(scratch), buffer, S8_FILE_AND_LINE, 16);
for (int i = 0; i < 16; i += 1) {
buffer16_raw_replace_text(buffer, r1i64_null, s16("line of memes\n"));
}
@@ -942,14 +894,15 @@ fn_test void buffer16_test(void) {
}
{
s16_t string = s16("some thing or another and stuff like that");
s16_t meme_string = s16("meme meme or another and stuff like that");
buffer16_t *buffer = ma_push_type(scratch.arena, buffer16_t);
buffer16_raw_init(ma_temp_alo(scratch), buffer, S8_FILE_AND_LINE, 128);
buffer16_raw_replace_text(buffer, r1i64_null, s16("some thing or another and stuff like that"));
buffer16_init(malot(scratch), buffer, S8_FILE_AND_LINE, 128);
buffer16_raw_replace_text(buffer, r1i64_null, string);
{
array_caret_t carets = {0};
array_init(ma_temp_alo(scratch), &carets, 32);
array_init(malot(scratch), &carets, 32);
array_add(&carets, caret_make(0, 4));
array_add(&carets, caret_make(3, 8));
array_add(&carets, caret_make(3, 8));
@@ -964,12 +917,12 @@ fn_test void buffer16_test(void) {
{
array_caret_t carets = {0};
array_init(ma_temp_alo(scratch), &carets, 32);
array_init(malot(scratch), &carets, 32);
array_add(&carets, caret_make(0, 4));
array_add(&carets, caret_make(0, 3));
array_add(&carets, caret_make(5, 10));
array_edit16_t edits = buffer16_begin_edit(ma_temp_alo(scratch), buffer, &carets);
array_edit16_t edits = buffer16_begin_edit(malot(scratch), buffer, &carets);
buffer16_merge_carets(buffer, &carets);
assert(carets.len == 2);
@@ -979,7 +932,14 @@ fn_test void buffer16_test(void) {
}
buffer16_end_edit(buffer, &edits, &carets, kill_selection);
assert(s16_are_equal(buffer->string, s16("meme meme or another and stuff like that")));
assert(s16_are_equal(buffer->string, meme_string));
for (i32 i = 0; i < 32; i += 1) {
buffer16_undo_edit(buffer, &carets);
assert(s16_are_equal(buffer->string, string));
buffer16_redo_edit(buffer, &carets);
assert(s16_are_equal(buffer->string, meme_string));
}
}
}

129
src/text_editor/buffer16.h Normal file
View File

@@ -0,0 +1,129 @@
typedef struct caret_t caret_t;
struct caret_t {
i64 ifront;
union {
r1i64_t range;
i64 pos[2];
};
};
typedef struct xy_t xy_t;
struct xy_t {
i64 col;
i64 line;
};
typedef struct edit16_t edit16_t;
struct edit16_t {
r1i64_t range;
s16_t string;
};
// @todo: redo tree
typedef array(edit16_t) array_edit16_t;
typedef array(caret_t) array_caret_t;
typedef struct history16_t history16_t;
struct history16_t {
array_edit16_t edits;
array_caret_t carets;
};
typedef array(history16_t) array_history16_t;
typedef struct buffer16_id_t buffer16_id_t;
struct buffer16_id_t { i64 e; };
typedef struct buffer16_t buffer16_t;
struct buffer16_t {
s8_t name;
buffer16_id_t id;
i32 change_id;
i8 edit_phase;
struct {
b8 dirty: 1;
b8 history: 1;
b8 line_starts: 1;
} flags;
union {
s16_t string;
u16 *data;
struct {
u16 *str;
i64 len;
};
};
i64 cap;
array_i64_t line_starts;
array_history16_t undo_stack;
array_history16_t redo_stack;
alo_t alo;
};
const b32 dont_kill_selection = false;
const b32 kill_selection = true;
///////////////////////////////
// caret helpers
fn caret_t caret_make(i64 front, i64 back);
fn i64 caret_get_front(caret_t caret);
fn i64 caret_get_back(caret_t caret);
fn caret_t caret_set_front(caret_t caret, i64 pos);
fn caret_t caret_set_back(caret_t caret, i64 pos);
fn b32 carets_are_equal(caret_t a, caret_t b);
fn b32 carets_overlap(caret_t a, caret_t b);
///////////////////////////////
// buffer helpers
fn i64 buffer16_pos_to_line(buffer16_t *buffer, i64 pos);
fn r1i64_t buffer16_get_line_range(buffer16_t *buffer, i64 line);
fn r1i64_t buffer16_get_line_range_full(buffer16_t *buffer, i64 line, i64 *eof);
fn xy_t buffer16_pos_to_xy(buffer16_t *buffer, i64 pos);
fn i64 buffer16_xy_to_pos(buffer16_t *buffer, xy_t xy);
fn i64 buffer16_xy_to_pos_without_new_line(buffer16_t *buffer, xy_t xy);
fn s16_t buffer16_get_string(buffer16_t *buffer, r1i64_t range);
fn s16_t buffer16_get_line_string(buffer16_t *buffer, i64 line);
fn r1i64_t buffer16_get_range_end(buffer16_t *buffer);
fn r1i64_t buffer16_get_range(buffer16_t *buffer);
fn i64 buffer16_clamp_pos(buffer16_t *buffer, i64 pos);
fn r1i64_t buffer16_clamp_range(buffer16_t *buffer, r1i64_t range);
fn i64 buffer16_get_word_start(buffer16_t *buffer, i64 pos);
fn i64 buffer16_get_word_end(buffer16_t *buffer, i64 pos);
fn i64 buffer16_get_next_word_end(buffer16_t *buffer, i64 pos);
fn i64 buffer16_get_prev_word_start(buffer16_t *buffer, i64 pos);
fn i64 buffer16_get_line_start(buffer16_t *buffer, i64 pos, i64 *eof);
fn i64 buffer16_get_line_end(buffer16_t *buffer, i64 pos, i64 *eof);
fn i64 buffer16_get_line_start_full(buffer16_t *buffer, i64 pos);
fn i64 buffer16_get_line_end_full(buffer16_t *buffer, i64 pos);
fn r1i64_t buffer16_enclose_word(buffer16_t *buffer, i64 pos);
fn u16 buffer16_get_char(buffer16_t *buffer, i64 pos);
fn i64 buffer16_offset_pos_by_line(buffer16_t *buffer, i64 pos, i64 line_offset);
///////////////////////////////
// buffer raw textural operations. no history
fn void buffer16_raw_grow(buffer16_t *buffer, i64 change_size);
fn void buffer16_raw_replace_text(buffer16_t *buffer, r1i64_t range, s16_t string);
///////////////////////////////
// buffer multicursor + history
fn void buffer16_init(alo_t alo, buffer16_t *buffer, s8_t name, i64 size);
fn void buffer16_deinit(buffer16_t *buffer);
fn void buffer16_add_edit(array_edit16_t *edits, r1i64_t range, s16_t string);
fn array_edit16_t buffer16_begin_edit(alo_t alo, buffer16_t *buffer, array_caret_t *carets);
fn void buffer16_end_edit(buffer16_t *buffer, array_edit16_t *edits, array_caret_t *carets, b32 kill_selection);
fn void buffer16_merge_carets(buffer16_t *buffer, array_caret_t *carets);
fn void buffer16_adjust_carets(array_edit16_t *edits, array_caret_t *carets);
fn void buffer16_redo_edit(buffer16_t *buffer, array_caret_t *carets);
fn void buffer16_undo_edit(buffer16_t *buffer, array_caret_t *carets);
fn void buffer16_save_history_before_merge_cursor(buffer16_t *buffer, array_history16_t *stack, array_caret_t *carets);
fn void buffer16_save_history_before_apply_edits(buffer16_t *buffer, array_history16_t *stack, array_edit16_t *edits);
fn void buffer16_pre_begin_edit_save_caret_history(buffer16_t *buffer, array_caret_t *carets);
fn void buffer16_dealloc_history_entries(buffer16_t *buffer, array_history16_t *entries);
fn void buffer16_dealloc_history_array(buffer16_t *buffer, array_history16_t *entries);
fn void buffer16_multi_cursor_apply_edits(buffer16_t *buffer, array_edit16_t edits);

185
src/text_editor/core_array.c
View File

@@ -1,185 +0,0 @@
typedef enum {
alokind_alloc,
alokind_dealloc,
} alokind_t;
typedef struct alo_t alo_t;
struct alo_t {
void *object;
void *(*proc)(alo_t alo, alokind_t kind, void *ptr, size_t size);
};
fn void *arena_alo_proc(alo_t alo, alokind_t kind, void *ptr, size_t size) {
ma_arena_t *ma = alo.object;
if (kind == alokind_alloc) {
return ma_push_size(alo.object, size);
} else if (kind == alokind_dealloc) {
return NULL;
} else_is_invalid;
return NULL;
}
fn alo_t ma_alo(ma_arena_t *arena) {
return (alo_t){arena, arena_alo_proc};
}
fn alo_t ma_temp_alo(ma_temp_t temp) {
return ma_alo(temp.arena);
}
fn void dealloc(alo_t alo, void *ptr) {
alo.proc(alo, alokind_dealloc, ptr, 0);
}
fn void *alloc_size(alo_t alo, size_t size) {
return alo.proc(alo, alokind_alloc, NULL, size);
}
#define alloc_type(alo, type) (type *)alloc_size((aloc), sizeof(type))
#define alloc_array(alo, type, count) (type *)alloc_size((alo), sizeof(type) * (count))
#define array(type) struct { alo_t alo; type *data; i64 len; i64 cap; }
typedef array(void) array_void_t;
typedef array(i64) array_i64_t;
#define arrisz(x) sizeof((x)->data[0])
#define arrcst(x) ((array_void_t *)(x))
#define array_init(a, this, count) (array__init((a), arrcst(this), arrisz(this), (count)))
#define array_add(this, ...) (array__grow(arrcst(this), arrisz(this), 1), (this)->data[(this)->len++] = __VA_ARGS__)
#define array_pop(this) (assert_expr((this)->len > 0), (this)->data[--(this)->len])
#define array_dealloc(this) (dealloc((this)->alo, (this)->data))
#define array_addn(this, n) (array__grow(arrcst(this), arrisz(this), (n)), (this)->len += (n), &(this)->data[(this)->len - (n)])
#define array_insert(this, i, item) (array__insert(arrcst(this), arrisz(this), (i)), (this)->data[(i)] = (item))
#define array_swapdel(this, i) (assert_expr((i) < (this)->len), (this)->data[(i)] = (this)->data[--(this)->len])
#define array_del(this, i) (array__del(arrcst(this), arrisz(this), (i), 1))
#define array_deln(this, i, count) (array__del(arrcst(this), arrisz(this), (i), (count)))
#define array_copy(alo, dst, src) (array__copy((alo), arrcst(dst), (array_void_t *)(src), arrisz(dst)))
#define array_last(x) ((x)->data[(x)->len - 1])
#define array_for(type, it, array) for (type *it = (array)->data; it < (array)->data + (array)->len; it += 1)
fn void array__init(alo_t alo, array_void_t *this, size_t item_size, i64 count) {
assert(this->data == NULL);
this->data = alloc_size(alo, item_size * count);
this->cap = count;
this->len = 0;
this->alo = alo;
}
fn void array__copy(alo_t alo, array_void_t *dst, array_void_t *src, size_t item_size) {
dst->data = alloc_size(alo, item_size * src->cap);
memory_copy(dst->data, src->data, item_size * src->len);
dst->cap = src->cap;
dst->len = src->len;
dst->alo = alo;
}
fn void array__grow(array_void_t *this, size_t item_size, i64 item_count) {
if (this->len + 1 > this->cap) {
i64 new_cap = this->cap == 0 ? 16 : (this->cap + item_count - 1) * 2;
void *new_data = alloc_size(this->alo, new_cap * item_size);
if (this->data) {
memory_copy(new_data, this->data, this->len*item_size);
dealloc(this->alo, this->data);
}
this->data = new_data;
this->cap = new_cap;
}
}
fn void array__del(array_void_t *this, size_t item_size, i64 idx, i64 count) {
if (count == 0) return;
assert(idx >= 0 && idx < this->len);
assert((idx + count) > 0 && (idx + count) <= this->len);
i64 right_len = this->len - idx - count;
u8 *data = (u8 *)this->data;
memory_move(data + idx * item_size, data + (idx + count) * item_size, right_len * item_size);
this->len -= count;
}
fn void array__insert(array_void_t *this, size_t item_size, i64 idx) {
array__grow(this, item_size, 1);
assert(idx >= 0);
assert(idx <= this->len);
assert(this->alo.object);
u8 *data = (u8 *)this->data;
i64 right_len = this->len - idx;
memory_move(data + (idx + 1) * item_size, data + idx * item_size, item_size * right_len);
this->len += 1;
}
fn_test void test_array(void) {
ma_temp_t scratch = ma_begin_scratch();
{
array_i64_t arr = (array_i64_t){.alo = ma_temp_alo(scratch)};
for (int i = 0; i < 512; i += 1) {
array_add(&arr, i);
}
for (int i = 0; i < 512; i += 1) {
assert(arr.data[i] == i);
}
assert(arr.len == 512);
assert(arr.cap == 512);
for (int i = 511; i >= 0; i -= 1) {
i64 a = array_pop(&arr);
assert(a == i);
}
assert(arr.len == 0);
array_dealloc(&arr);
}
{
array_i64_t arr = (array_i64_t){.alo = ma_temp_alo(scratch)};
i64 *i = array_addn(&arr, 10);
assert(arr.len == 10 && arr.cap == 16);
i64 *j = array_addn(&arr, 2);
assert(i == arr.data);
assert(j == arr.data + 10);
array_dealloc(&arr);
}
{
array_i64_t arr = (array_i64_t){.alo = ma_temp_alo(scratch)};
for (int i = 0; i < 512; i += 1) {
array_add(&arr, i);
}
array_insert(&arr, 256, 111);
assert(arr.data[256] == 111);
assert(arr.data[255] == 255);
assert(arr.data[257] == 256);
assert(arr.len == 513);
array_insert(&arr, 4, 222);
assert(arr.len == 514);
assert(arr.data[4] == 222);
assert(arr.data[3] == 3);
assert(arr.data[5] == 4);
array_swapdel(&arr, 2);
assert(arr.len == 513);
assert(arr.data[2] == 511);
assert(arr.data[1] == 1);
assert(arr.data[3] == 3);
array_i64_t copy = {0};
array_copy(ma_temp_alo(scratch), &copy, &arr);
for (i64 i = 0; i < arr.len; i += 1) {
assert(arr.data[i] == copy.data[i]);
}
assert(copy.len == arr.len);
}
ma_end_scratch(scratch);
}
fn s16_t s16_alo_copy(alo_t ma, s16_t string) {
i64 byte_size = sizeof(u16) * string.len;
u16 *copy = (u16 *)alloc_size(ma, byte_size + sizeof(u16));
memory_copy(copy, string.str, byte_size);
copy[string.len] = 0;
s16_t result = s16_make(copy, string.len);
return result;
}

4
src/text_editor/text_editor_main.c
View File

@@ -2,6 +2,7 @@
#include "os/os.h"
#include "app/app.h"
#include "profiler/profiler.h"
#include "buffer16.h"
// #include "ui/ui.h"
@@ -10,8 +11,7 @@
#include "app/app.c"
#include "profiler/profiler.c"
#include "render/render.c"
#include "core_array.c"
#include "text_editor_buffer.c"
#include "buffer16.c"
// #include "ui/ui.c"
#include "text_editor.gen.c"