refactor: xmake is now in use

src/lae_arena.c

@@ -0,0 +1,225 @@
+#include "lae_arena.h"
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+struct Arena {
+    uint8_t* buffer;
+    size_t   capacity;
+    size_t   offset;
+};
+
+ArenaErr arena_init(Arena** arena, size_t capacity) {
+    if (arena == NULL) {
+        return ARENA_NULL_ARG;
+    }
+
+    if (capacity < 1) {
+        return ARENA_INVALID_SIZE;
+    }
+
+    Arena* new_arena = malloc(sizeof(Arena));
+    if (new_arena == NULL) {
+        return ARENA_BAD_ALLOC;
+    }
+
+    void* buffer = malloc(capacity);
+    if (buffer == NULL) {
+        return ARENA_BAD_ALLOC;
+    }
+
+    *new_arena = (Arena){
+        .buffer   = buffer,
+        .capacity = capacity,
+        .offset   = 0,
+    };
+
+    *arena = new_arena;
+
+    return ARENA_OK;
+}
+
+ArenaErr arena_destroy(Arena** arena) {
+    if (arena == NULL || *arena == NULL) {
+        return ARENA_NULL_ARG;
+    }
+
+    free((*arena)->buffer);
+    (*arena)->buffer   = NULL;
+    (*arena)->offset   = 0;
+    (*arena)->capacity = 0;
+    free(*arena);
+    *arena = NULL;
+
+    return ARENA_OK;
+}
+
+ArenaPointer arena_alloc(Arena* arena, size_t size, size_t alignment) {
+    if (arena == NULL) {
+        return (ArenaPointer){.is_valid = false, .err = ARENA_NULL_ARG};
+    }
+
+    if (size < 1) {
+        return (ArenaPointer){.is_valid = false, .err = ARENA_INVALID_SIZE};
+    }
+
+    if (alignment < 1) {
+        return (ArenaPointer){.is_valid = false, .err = ARENA_INVALID_ALIGN};
+    }
+
+    ArenaSizeResult padding = arena_get_align_padding(arena, alignment);
+    if (!padding.is_valid) {
+        return (ArenaPointer){.is_valid = false, .err = padding.err};
+    }
+
+    ArenaErr cap_err = arena_ensure_capacity(arena, size, alignment);
+    if (cap_err != ARENA_OK) {
+        return (ArenaPointer){.is_valid = false, .err = ARENA_OUT_OF_SPACE};
+    }
+
+    if (arena->offset + padding.val + size > arena->capacity) {
+        return (ArenaPointer){.is_valid = false, .err = ARENA_OUT_OF_SPACE};
+    }
+
+    if (arena->offset > SIZE_MAX - padding.val - size) {
+        return (ArenaPointer){.is_valid = false,
+                              .err      = ARENA_CAPACITY_OVERFLOW};
+    }
+
+    size_t aligned_offset = arena->offset + padding.val;
+
+    arena->offset = aligned_offset + size;
+    return (ArenaPointer){.is_valid = true,
+                          .offset   = aligned_offset,
+                          .arena    = arena};
+}
+
+ArenaErr arena_ensure_capacity(Arena* arena, size_t size, size_t alignment) {
+    if (arena == NULL) {
+        return ARENA_NULL_ARG;
+    }
+
+    if (size == 0 || size == SIZE_MAX) {
+        return ARENA_INVALID_SIZE;
+    }
+
+    if (alignment == 0 || (alignment & (alignment - 1)) != 0) {
+        return ARENA_INVALID_ALIGN;
+    }
+
+    ArenaSizeResult padding_res = arena_get_align_padding(arena, alignment);
+    if (!padding_res.is_valid) {
+        return padding_res.err;
+    }
+
+    size_t padding = padding_res.val;
+
+    while (true) {
+        size_t required;
+
+        if (arena->offset > SIZE_MAX - padding) {
+            return ARENA_CAPACITY_OVERFLOW;
+        }
+        required = arena->offset + padding;
+
+        if (required > SIZE_MAX - size) {
+            return ARENA_CAPACITY_OVERFLOW;
+        }
+        required += size;
+
+        if (required <= arena->capacity) {
+            return ARENA_OK;
+        }
+
+        size_t new_capacity;
+
+        if (arena->capacity > SIZE_MAX / 2) {
+            return ARENA_CAPACITY_OVERFLOW;
+        }
+
+        new_capacity = arena->capacity * 2;
+
+        if (new_capacity < required) {
+            new_capacity = required;
+        }
+
+        ArenaErr err = arena_realloc(arena, new_capacity);
+        if (err != ARENA_OK) {
+            return err;
+        }
+    }
+}
+
+ArenaPointer
+arena_push(Arena* arena, void* data, size_t size, size_t alignment) {
+    if (arena == NULL || data == NULL) {
+        return (ArenaPointer){.is_valid = false, .err = ARENA_NULL_ARG};
+    }
+
+    if (size < 1) {
+        return (ArenaPointer){.is_valid = false, .err = ARENA_INVALID_SIZE};
+    }
+
+    if (size < 1) {
+        return (ArenaPointer){.is_valid = false, .err = ARENA_INVALID_ALIGN};
+    }
+
+    ArenaErr err = arena_ensure_capacity(arena, size, alignment);
+    if (err != ARENA_OK) {
+        return (ArenaPointer){.is_valid = false, .err = err};
+    }
+
+    ArenaPointer pointer = arena_alloc(arena, size, alignment);
+    if (!pointer.is_valid) {
+        return pointer;
+    }
+
+    memcpy(arena_unwrap_pointer(pointer), data, size);
+
+    return pointer;
+}
+
+ArenaErr arena_realloc(Arena* arena, size_t new_capacity) {
+    if (arena == NULL) {
+        return ARENA_NULL_ARG;
+    }
+
+    if (new_capacity < 1) {
+        return ARENA_INVALID_SIZE;
+    }
+
+    uint8_t* tmp = realloc(arena->buffer, new_capacity);
+    if (tmp == NULL) {
+        return ARENA_BAD_ALLOC;
+    }
+
+    arena->buffer   = tmp;
+    arena->capacity = new_capacity;
+    return ARENA_OK;
+}
+
+ArenaSizeResult arena_get_align_padding(Arena* arena, size_t alignment) {
+    if (arena == NULL) {
+        return (ArenaSizeResult){.is_valid = false, .err = ARENA_NULL_ARG};
+    }
+
+    if (alignment == 0 || (alignment & (alignment - 1)) != 0) {
+        return (ArenaSizeResult){.is_valid = false, .err = ARENA_INVALID_ALIGN};
+    }
+
+    uintptr_t current_address = (uintptr_t)(arena->buffer + arena->offset);
+
+    size_t mask    = alignment - 1;
+    size_t padding = (size_t)(-current_address) & mask;
+
+    return (ArenaSizeResult){.is_valid = true, .val = padding};
+}
+
+void* arena_unwrap_pointer(ArenaPointer p) {
+    if (!p.is_valid) {
+        return NULL;
+    }
+    return p.arena->buffer + p.offset;
+}