buffer16 api work

src/core/core.c

@@ -62,6 +62,7 @@
 #include "core_type_info.c"
 #include "core_hash.c"
 #include "core_hash_table.c"
+#include "core_array.c"
 #ifndef DONT_INCLUDE_GENERATED_MATH
 #include "core_math.gen.c"
 #endif

src/core/core.h

@@ -15,3 +15,4 @@
 #include "core_platform.h"
 #include "core_hash_table.h"
 #include "core_ctx.h"
+#include "core_array.h"

src/core/core_array.c

@@ -0,0 +1,116 @@
+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 = malot(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 = malot(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 = malot(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(malot(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);
+}

src/core/core_array.h

@@ -0,0 +1,24 @@
+#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);
+fn void array__copy(alo_t alo, array_void_t *dst, array_void_t *src, size_t item_size);
+fn void array__grow(array_void_t *this, size_t item_size, i64 item_count);
+fn void array__del(array_void_t *this, size_t item_size, i64 idx, i64 count);
+fn void array__insert(array_void_t *this, size_t item_size, i64 idx);

src/core/core_ctx.c

@@ -11,4 +11,30 @@ gb_thread thread_ctx_t global_thread_context = {
 fn void core_init(void) {
     tcx = &global_thread_context;
     os_core_init();
-}
+}
+
+fn void *ma_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 malo(ma_arena_t *arena) {
+    return (alo_t){arena, ma_arena_alo_proc};
+}
+
+fn alo_t malot(ma_temp_t temp) {
+    return malo(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);
+}

src/core/core_ctx.h

@@ -19,4 +19,22 @@ enum {
     tcx_slot_app,
 };
 
+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);
+};
+
+#define alloc_type(alo, type) (type *)alloc_size((aloc), sizeof(type))
+#define alloc_array(alo, type, count) (type *)alloc_size((alo), sizeof(type) * (count))
+fn alo_t malo(ma_arena_t *arena);
+fn alo_t malot(ma_temp_t temp);
+fn void  dealloc(alo_t alo, void *ptr);
+fn void *alloc_size(alo_t alo, size_t size);
+
 gb_thread thread_ctx_t *tcx;

src/core/core_string16.c

@@ -489,6 +489,15 @@ fn sb16_t s16_split(ma_arena_t *ma, s16_t string, s16_t find, s16_split_t flags)
     return result;
 }
 
+fn s16_t s16_copy_ex(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;
+}
+
 fn_test void test_string16(void) {
     ma_temp_t scratch = ma_begin_scratch();