WIP continue the work on arena allcoator implementation

README.md

@@ -31,3 +31,8 @@ are deferred, and called in the reverse order. This way the first gui function
 that captrues input can signal to the other function that input is captured,
 and the drawing of the gui elements can reflect the priority of the gui
 functions. Overlapping gui elements in raygui is the main painpoint imo.
+
+# TODO
+
+If there is an allocation error it does not actually cause a crash...
+FIX!!!

arena_allocator.c

@@ -0,0 +1,26 @@
+#include "cig.h"
+
+
+void *arena_allocator_alloc_func(
+    arena_allocator_t *this,
+    size_t bytes,
+    const char *file,
+    int line
+) {
+    allocator_t std_alloc = allocator_stdlib();
+    buffer_allocator_t ba = (buffer_allocator_t) {
+        .size=dyn_array_length(this->bytes),
+        .capacity=dyn_array_capacity(this->bytes),
+        .data=this->bytes
+    };
+}
+
+void arena_allocator_reset(arena_allocator_t *this) {
+}
+
+void arena_allocator_destroy(arena_allocator_t *this) {
+}
+
+allocator_t arena_allocator_interface(arena_allocator_t *this) {
+}
+

buffer_allocator.c

@@ -1,12 +1,13 @@
 #include "cig.h"
 
 void *buffer_allocator_alloc(buffer_allocator_t *this, size_t bytes) {
-    // TODO: use max-align
-    // also make the default function crash if outOf memory?
-    size_t new_size = this->size + bytes;
+    size_t address_of_new_data = (size_t) &this->data[this->size];
+    size_t offset = address_of_new_data % MAX_ALIGN;
+    size_t new_size = this->size + offset + bytes;
     if (new_size > this->capacity) {
         return NULL;
     }
+    this->size += offset;
     void *ptr = &this->data[this->size];
     this->size = new_size;
     return ptr;

cig.h

@@ -5,8 +5,8 @@
 #include <stdint.h>
 #include <stdlib.h>
 
-typedef union any_align { char c; int i; long l; long long ll; float f; double d; void *p; long double ld; } any_align_t;
-#define MAX_ALIGN (sizeof(any_align_t))
+typedef union any_align { char c; int i; long l; long long ll; float f; double d; void *p; } any_align_t;
+#define MAX_ALIGN ((size_t) sizeof(any_align_t))
 #define KB (1024)
 #define MB (KB * KB)
 #define GB (KB * KB * KB)
@@ -112,6 +112,11 @@ allocator_t borrow_allocator_interface(borrow_allocator_t *this);
 // beforehand. Instead the number of bytes allocated will be recorded and
 // updated, so that the whole thing can be reallocated as a single chunk that is
 // as large as it needs to be.
+//
+// This basically exists for allocations that live for a single 'tick' of an
+// application.
+// It is intended to eventually stabilize and find the required size of the
+// memory chunk that is needed for a single frame.
 typedef struct arena_allocator {
   borrow_allocator_t borrow_allocator;
   // Total size of bytes allocated. This allocator will only grow the
@@ -142,6 +147,7 @@ void *arena_allocator_alloc_func(
 
 void arena_allocator_reset(arena_allocator_t *this);
 void arena_allocator_destroy(arena_allocator_t *this);
+allocator_t arena_allocator_interface(arena_allocator_t *this);
 
 // dynamic arrays //////////////////////////////////////////////////////////////
 
@@ -234,6 +240,7 @@ void allocator_free_func(allocator_t this, void *ptr, const char *file, int line
 #include "buffer_allocator.c"
 #include "borrow_allocator.c"
 #include "dyn_array.c"
+#include "arena_allocator.c"
 
 #endif // ALLOCATOR_IMPLEMENTATION
 #endif // ALLOCATOR_H

test_macro_magic.c

@@ -23,6 +23,4 @@ Test(macro_magic, default_values) {
     cr_assert_eq(a1.is_true, true);
     cr_assert_eq(a2.is_true, true);
     cr_assert_eq(a3.is_true, false);
-    // TODO if there is an allocation error it does not actually cause a crash...
-    // FIX!!!
 }