Merge pull request 'refactor-xmake' (#2) from refactor-xmake into main

Reviewed-on: #2

.gitignore

@@ -7,6 +7,12 @@ out/
 out/Debug/
 out/Release/
 
+# xmake
+xmake/
+xmake/*
+.xmake
+.xmake/*
+
 # Cmake files
 CMakeCache.txt
 CMakeFiles/

CMakeLists.txt

@@ -1,39 +0,0 @@
-cmake_minimum_required(VERSION 3.20)
-project(calculator VERSION 1.0 LANGUAGES C)
-
-set(CMAKE_C_STANDARD 11)
-set(CMAKE_C_STANDARD_REQUIRED ON)
-
-# Export compile_commands.json (para clangd)
-set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
-
-add_compile_options(
-    -Wall
-    -Wextra
-    -Wpedantic
-)
-
-
-include_directories(include)
-
-add_library(arraylist_lib
-    src/arraylist.c
-)
-
-add_executable(arraylist_main src/main.c)
-
-target_link_libraries(arraylist_main arraylist_lib)
-
-function(enable_sanitizers target)
-    target_compile_options(${target} PRIVATE -fsanitize=address -fno-omit-frame-pointer)
-    target_link_options(${target} PRIVATE -fsanitize=address)
-endfunction()
-
-
-# ------------------------
-# Testing
-# ------------------------
-
-enable_testing()
-add_subdirectory(test)
-

README.md

@@ -0,0 +1 @@
+# Hola

include/arraylist.h

@@ -1,49 +0,0 @@
-#ifndef ARRAYLIST_H
-#define ARRAYLIST_H
-
-#include <inttypes.h>
-#include <stddef.h>
-#include <stdbool.h>
-
-typedef struct ArrayList ArrayList;
-
-typedef struct {
-    ArrayList *array;
-    size_t offset;
-} ArrayListSlice;
-
-typedef enum {
-    ARRLIST_OK = 0,
-    ARRLIST_OUT_OF_BOUNDS,
-    ARRLIST_BAD_ALLOC,
-    ARRLIST_ALLOC_OVERFLOW,
-    ARRLIST_EMPTY,
-    ARRLIST_NULL_ARG,
-    ARRLIST_INVALID_ELEM_SIZE,
-    ARRLIST_INVALID_CAPACITY,
-} ArrayListErr;
-
-ArrayList *arraylist_init(size_t capacity, size_t elem_size);
-ArrayListErr arraylist_destroy(ArrayList **arr);
-ArrayListErr arraylist_clear(ArrayList *arr);
-
-size_t arraylist_size(const ArrayList *arr);
-size_t arraylist_capacity(const ArrayList *arr);
-bool arraylist_is_empty(const ArrayList *arr);
-
-ArrayListErr arraylist_push_back(ArrayList *arr, void *data);
-ArrayListErr arraylist_insert(ArrayList*arr, size_t index, void *data);
-ArrayListErr arraylist_push_front(ArrayList* arr, void *data);
-
-// Here out can be null for not having anything writen
-ArrayListErr arraylist_pop_back(ArrayList *arr, void *out);
-ArrayListErr arraylist_remove_at(ArrayList *arr, size_t index, void *out);
-ArrayListErr arraylist_pop_front(ArrayList *arr, void *out);
-
-ArrayListErr arraylist_get(const ArrayList *arr, size_t index, void *out);
-ArrayListErr arraylist_set(ArrayList *arr, size_t index, void *data);
-
-ArrayListErr arraylist_resize(ArrayList *arr, size_t new_capacity);
-ArrayListErr arraylist_reserve(ArrayList *arr, size_t size_to_reserve);
-
-#endif

include/lae_arraylist.h

@@ -0,0 +1,90 @@
+#ifndef LAE_ARRAYLIST_H
+#define LAE_ARRAYLIST_H
+
+#include "lae_allocator.h"
+#include <inttypes.h>
+#include <stdbool.h>
+#include <stddef.h>
+
+typedef struct ArrayList ArrayList;
+
+typedef struct ArraySlice ArraySlice;
+
+typedef enum {
+    ARRLIST_OK = 0,
+    ARRLIST_OUT_OF_BOUNDS,
+    ARRLIST_BAD_ALLOC,
+    ARRLIST_ALLOC_OVERFLOW,
+    ARRLIST_EMPTY,
+    ARRLIST_NULL_ARG,
+    ARRLIST_INVALID_ELEM_SIZE,
+    ARRLIST_INVALID_CAPACITY,
+    ARRLIST_IS_BORROWED,
+    ARRLIST_INVALID_SLICE,
+    ARRLIST_INVALID_ARR,
+    ARRLIST_INVALID_START,
+    ARRLIST_BORROW_UNDERFLOW,
+} ArrayListErr;
+
+ArrayListErr arraylist_init(
+    ArrayList **arr,
+    Allocator allocator,
+    size_t capacity,
+    size_t elem_size);
+ArrayListErr arraylist_destroy(ArrayList **arr);
+ArrayListErr arraylist_clear(ArrayList *arr);
+ArrayList *arraylist_clone(const ArrayList *arr);
+
+size_t arraylist_size(const ArrayList *arr);
+size_t arraylist_capacity(const ArrayList *arr);
+bool arraylist_is_empty(const ArrayList *arr);
+
+ArrayListErr arraylist_push_back(ArrayList *arr, void *data);
+ArrayListErr arraylist_insert(ArrayList *arr, size_t index, void *data);
+ArrayListErr arraylist_push_front(ArrayList *arr, void *data);
+
+// Here out can be null for not having anything writen
+ArrayListErr arraylist_pop_back(ArrayList *arr, void *out);
+ArrayListErr arraylist_remove_at(ArrayList *arr, size_t index, void *out);
+ArrayListErr arraylist_pop_front(ArrayList *arr, void *out);
+
+ArrayListErr arraylist_get(const ArrayList *arr, size_t index, void *out);
+ArrayListErr arraylist_set(ArrayList *arr, size_t index, void *data);
+
+ArrayListErr arraylist_resize(ArrayList *arr, size_t new_capacity);
+ArrayListErr arraylist_reserve(ArrayList *arr, size_t size_to_reserve);
+
+// Slice stuff
+ArrayListErr arraylist_slice(
+    ArraySlice **slice,
+    Allocator allocator,
+    ArrayList *arr,
+    size_t start,
+    size_t len);
+
+ArrayListErr arraylist_slice_unsafe(
+    ArraySlice **slice,
+    Allocator allocator,
+    ArrayList *arr,
+    size_t start,
+    size_t len);
+
+ArrayListErr arrayslice_destroy(ArraySlice **slice);
+
+bool arrayslice_is_valid(const ArraySlice *slice);
+size_t arrayslice_size(const ArraySlice *slice);
+
+// peek and next can be null, get can't, like, why would you use get without
+// actually getting something?, for validating an index?, use size idiot
+ArrayListErr arrayslice_peek(const ArraySlice *slice, void *out);
+ArrayListErr arrayslice_next(ArraySlice *slice, void *out);
+
+ArrayListErr arrayslice_reset(ArraySlice *slice);
+ArrayListErr arrayslice_advance(ArraySlice *slice, size_t n);
+
+ArrayListErr arrayslice_to_arraylist(
+    ArrayList **arr,
+    Allocator allocator,
+    const ArraySlice *slice);
+
+#endif

src/arraylist.c

@@ -1,384 +0,0 @@
-#include "arraylist.h"
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdlib.h>
-#include <string.h>
-
-struct ArrayList{
-    uint8_t *buffer;
-    size_t capacity;
-    size_t len;
-    size_t elem_size;
-};
-
-// Grow and shrink factor is 2, 1.5 might give different results i guess
-// but i'm basing myself in that Rust implementation of array does use
-// 2 as the factor so i guess is good :)
-static ArrayListErr arraylist_grow(ArrayList *arr);
-static ArrayListErr arraylist_shrink(ArrayList *arr);
-
-ArrayList *arraylist_init(size_t capacity, size_t elem_size) {
-    if (capacity == 0) {
-        return NULL;
-    }
-
-    if (elem_size == 0) {
-        return NULL;
-    }
-
-    if (capacity > SIZE_MAX / elem_size) {
-        return NULL;
-    }
-
-    ArrayList *arr = malloc(sizeof(ArrayList));
-    if (arr == NULL) {
-        return NULL;
-    }
-    arr->capacity = capacity;
-    arr->elem_size = elem_size;
-    arr->len = 0;
-    arr->buffer = malloc(capacity * elem_size);
-    if (arr->buffer == NULL) {
-        free(arr);
-        return NULL;
-    }
-
-    return arr;
-}
-
-ArrayListErr arraylist_destroy(ArrayList **arr) {
-    if (arr == NULL || *arr == NULL) {
-        return ARRLIST_NULL_ARG;
-    }
-
-    // No problem on using free on NULL :)
-    free((*arr)->buffer);
-    free(*arr);
-    *arr = NULL;
-
-    return ARRLIST_OK;
-}
-
-ArrayListErr arraylist_clear(ArrayList *arr) {
-    if (arr == NULL) {
-        return ARRLIST_NULL_ARG;
-    }
-
-    memset(arr->buffer, 0, arr->capacity * arr->elem_size);
-    arr->capacity = 0;
-    arr->elem_size = 0;
-    arr->len = 0;
-    return ARRLIST_OK;
-}
-
-size_t arraylist_size(const ArrayList *arr) {
-    if (arr == NULL) {
-        return 0;
-    }
-    return arr->len;
-}
-
-size_t arraylist_capacity(const ArrayList *arr) {
-    if (arr == NULL) {
-        return 0;
-    }
-    return arr->capacity;
-}
-
-bool arraylist_is_empty(const ArrayList *arr) {
-    if (arr == NULL) {
-        return true;
-    }
-    return arr->len == 0;
-}
-
-static ArrayListErr arraylist_grow(ArrayList *arr) {
-    // We can asume is not null because is internal
-    // and only used by funtions that already verified
-    // arr is not null, same with shrink.
-    size_t new_capacity = arr->capacity * 2;
-
-    if (new_capacity > SIZE_MAX / arr->elem_size) {
-        return  ARRLIST_ALLOC_OVERFLOW;
-    }
-
-    void *tmp = realloc(arr->buffer, new_capacity * arr->elem_size);
-    if (tmp == NULL) {
-        return ARRLIST_BAD_ALLOC;
-    }
-
-    arr->capacity = new_capacity;
-    arr->buffer = tmp;
-    return ARRLIST_OK;
-}
-
-static ArrayListErr arraylist_shrink(ArrayList *arr) {
-    size_t new_capacity = arr->capacity / 2;
-
-    if (new_capacity > SIZE_MAX / arr->elem_size) {
-        return  ARRLIST_ALLOC_OVERFLOW;
-    }
-    
-    void *tmp = realloc(arr->buffer, new_capacity *arr->elem_size);
-    if (tmp == NULL) {
-        return ARRLIST_BAD_ALLOC;
-    }
-
-    arr->capacity = new_capacity;
-    arr->buffer = tmp;
-    return ARRLIST_OK;
-}
-
-ArrayListErr arraylist_push_back(ArrayList *arr, void *data) {
-    if (arr == NULL || data == NULL) {
-        return ARRLIST_NULL_ARG;
-    }
-
-    if (arr->len >= arr->capacity) {
-        ArrayListErr err = arraylist_grow(arr);
-
-        if (err != ARRLIST_OK) {
-            return err;
-        }
-    }
-
-    memcpy(arr->buffer + (arr->len * arr->elem_size), data, arr->elem_size);
-    arr->len++;
-    return ARRLIST_OK;
-}
-
-ArrayListErr arraylist_push_front(ArrayList *arr, void *data) {
-    if (arr == NULL || data == NULL) {
-        return ARRLIST_NULL_ARG;
-    }
-
-    if (arr->len >= arr->capacity) {
-        ArrayListErr err = arraylist_grow(arr);
-
-        if (err != ARRLIST_OK) {
-            return err;
-        }
-    }
-
-    // No problem if array is full because  it grows if it's full
-    memmove(
-        arr->buffer + arr->elem_size,
-        arr->buffer,
-        (arr->len) * arr->elem_size
-    );
-
-    memcpy(
-        arr->buffer,
-        data,
-        arr->elem_size);
-
-    arr->len++;
-
-    return ARRLIST_OK;
-}
-
-ArrayListErr arraylist_insert(ArrayList *arr, size_t index, void *data) {
-    if (arr == NULL || data == NULL) {
-        return ARRLIST_NULL_ARG;
-    }
-
-    if (index > arr->len) {
-        return ARRLIST_OUT_OF_BOUNDS;
-    }
-
-    if (arr->len >= arr->capacity) {
-        ArrayListErr err = arraylist_grow(arr);
-        if (err != ARRLIST_OK) {
-            return err;
-        }
-    }
-
-    memmove(
-        arr->buffer + ((index + 1) * arr->elem_size),
-        arr->buffer + (index * arr->elem_size),
-        (arr->len - index) * arr->elem_size);
-
-    memcpy(arr->buffer + (index * arr->elem_size),
-           data,
-           arr->elem_size);
-
-    arr->len++;
-
-    return ARRLIST_OK;
-}
-
-ArrayListErr arraylist_pop_back(ArrayList *arr, void *out) {
-    if (arr == NULL) {
-        return ARRLIST_NULL_ARG;
-    }
-
-    if (arr->len < 1) {
-        return ARRLIST_EMPTY;
-    }
-
-    if (arr->capacity / 4 > arr->len) {
-        ArrayListErr err = arraylist_shrink(arr);
-        if (err != ARRLIST_OK) {
-            return err;
-        }
-    }
-
-    if (out != NULL) {
-        memcpy(
-            out,
-            arr->buffer + (arr->len - 1) * arr->elem_size,
-            arr->elem_size);
-    }
-
-    arr->len--;
-
-    return ARRLIST_OK;
-}
-
-ArrayListErr arraylist_pop_front(ArrayList *arr, void *out) {
-    if (arr == NULL) {
-        return ARRLIST_NULL_ARG;
-    }
-
-    if (arr->len < 1) {
-        return ARRLIST_EMPTY;
-    }
-
-    if (arr->capacity / 4 > arr->len) {
-        ArrayListErr err = arraylist_shrink(arr);
-        if (err != ARRLIST_OK) {
-            return err;
-        }
-    }
-
-    if (out != NULL) {
-        memcpy(
-            out,
-            arr->buffer,
-            arr->elem_size
-        );
-    }
-
-    memmove(
-        arr->buffer,
-        arr->buffer + arr->elem_size,
-        (arr->len - 1) * arr->elem_size);
-
-    arr->len--;
-
-    return ARRLIST_OK;
-}
-
-ArrayListErr arraylist_remove_at(ArrayList *arr, size_t index, void *out) {
-    if (arr == NULL) {
-        return ARRLIST_NULL_ARG;
-    }
-
-    if (index >= arr->len) {
-        return ARRLIST_OUT_OF_BOUNDS;
-    }
-
-    if (arr->len < 1) {
-        return ARRLIST_OK;
-    }
-
-    if (out != NULL) {
-        memcpy(
-            out,
-            arr->buffer + (index * arr->elem_size),
-            arr->elem_size
-        );
-    }
-
-    memmove(
-        arr->buffer + (index * arr->elem_size),
-        arr->buffer + ((index + 1) * arr->elem_size),
-        (arr->len - index) * arr->elem_size);
-
-    arr->len--;
-
-    return ARRLIST_OK;
-}
-
-ArrayListErr arraylist_get(const ArrayList *arr, size_t index, void *out) {
-    if (arr == NULL || out == NULL) {
-        return ARRLIST_NULL_ARG;
-    }
-
-    if (index >= arr->capacity) {
-        return ARRLIST_OUT_OF_BOUNDS;
-    }
-
-    memcpy(
-        out,
-        arr->buffer + (index * arr->elem_size),
-        arr->elem_size);
-
-    return ARRLIST_OK;
-}
-
-ArrayListErr arraylist_set(ArrayList *arr, size_t index, void *data) {
-    if (arr == NULL || data == NULL) {
-        return ARRLIST_NULL_ARG;
-    }
-
-    if (index >= arr->capacity) {
-        return ARRLIST_OUT_OF_BOUNDS;
-    }
-
-    memcpy(
-        arr->buffer + (index * arr->elem_size),
-        data,
-        arr->elem_size);
-
-    return ARRLIST_OK;
-}
-
-ArrayListErr arraylist_resize(ArrayList *arr, size_t new_capacity) {
-    if (arr == NULL) {
-        return ARRLIST_NULL_ARG;
-    }
-
-    if (new_capacity < 1) {
-        return ARRLIST_INVALID_CAPACITY;
-    }
-
-    if (new_capacity > SIZE_MAX / arr->elem_size) {
-        return  ARRLIST_ALLOC_OVERFLOW;
-    }
-
-    uint8_t *tmp = realloc(arr->buffer, new_capacity * arr->elem_size);
-    if (tmp == NULL) {
-        return ARRLIST_BAD_ALLOC;
-    }
-
-    arr->buffer = tmp;
-    arr->capacity = new_capacity;
-    return ARRLIST_OK;
-}
-
-ArrayListErr arraylist_reserve(ArrayList *arr, size_t size_to_reserve) {
-    if (arr == NULL) {
-        return ARRLIST_NULL_ARG;
-    }
-
-    if (size_to_reserve < 1) {
-        return ARRLIST_INVALID_CAPACITY;
-    }
-
-    if (arr->capacity + size_to_reserve > SIZE_MAX / arr->elem_size) {
-        return  ARRLIST_ALLOC_OVERFLOW;
-    }
-
-    uint8_t *tmp = realloc(
-        arr->buffer,
-        (arr->capacity + size_to_reserve) * arr->elem_size);
-
-    if (tmp == NULL) {
-        return ARRLIST_BAD_ALLOC;
-    }
-
-    arr->buffer = tmp;
-    arr->capacity += size_to_reserve;
-    return ARRLIST_OK;
-}

src/lae_arraylist.c

@@ -0,0 +1,645 @@
+#include "lae_arraylist.h"
+#include "lae_allocator.h"
+#include <stdalign.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+struct ArrayList {
+    uint8_t *buffer;
+    size_t capacity;
+    size_t len;
+    size_t elem_size;
+    size_t borrows;
+
+    Allocator allocator;
+};
+
+struct ArraySlice {
+    ArrayList *arr;
+    size_t start;
+    size_t end;
+    size_t current;
+    bool is_safe;
+
+    Allocator allocator;
+};
+
+// Grow and shrink factor is 2, 1.5 might give different results i guess
+// but i'm basing myself in that Rust implementation of array does use
+// 2 as the factor so i guess is good :)
+static ArrayListErr arraylist_grow(ArrayList *arr);
+static ArrayListErr arraylist_shrink(ArrayList *arr);
+
+ArrayListErr arraylist_init(
+    ArrayList **arr,
+    Allocator allocator,
+    size_t capacity,
+    size_t elem_size) {
+    if (arr == NULL) {
+        return ARRLIST_NULL_ARG;
+    }
+
+    *arr = NULL;
+
+    if (capacity == 0) {
+        return ARRLIST_INVALID_CAPACITY;
+    }
+
+    if (elem_size == 0) {
+        return ARRLIST_INVALID_ELEM_SIZE;
+    }
+
+    if (capacity > SIZE_MAX / elem_size) {
+        return ARRLIST_INVALID_CAPACITY;
+    }
+
+    ArrayList *new_arr =
+        allocator.alloc(allocator.ctx, sizeof(ArrayList), alignof(ArrayList));
+    if (new_arr == NULL) {
+        return ARRLIST_BAD_ALLOC;
+    }
+
+    new_arr->capacity = capacity;
+    new_arr->elem_size = elem_size;
+    new_arr->len = 0;
+    new_arr->borrows = 0;
+    new_arr->buffer = allocator.alloc(allocator.ctx, capacity * elem_size, 0);
+    new_arr->allocator = allocator;
+    if (new_arr->buffer == NULL) {
+        allocator.free(
+            allocator.ctx,
+            new_arr,
+            sizeof(ArrayList),
+            alignof(ArrayList));
+        return ARRLIST_BAD_ALLOC;
+    }
+
+    *arr = new_arr;
+    return ARRLIST_OK;
+}
+
+ArrayListErr arraylist_destroy(ArrayList **arr) {
+    if (arr == NULL || *arr == NULL) {
+        return ARRLIST_NULL_ARG;
+    }
+
+    if ((*arr)->borrows > 0) {
+        return ARRLIST_IS_BORROWED;
+    }
+
+    ArrayList *tmp = *arr;
+
+    // No problem on using free on NULL :)
+    tmp->allocator.free(tmp->allocator.ctx, tmp->buffer, tmp->capacity, 0);
+    tmp->allocator
+        .free(tmp->allocator.ctx, tmp, sizeof(ArrayList), alignof(ArrayList));
+    *arr = NULL;
+
+    return ARRLIST_OK;
+}
+
+ArrayListErr arraylist_clear(ArrayList *arr) {
+    if (arr == NULL) {
+        return ARRLIST_NULL_ARG;
+    }
+
+    if (arr->borrows > 0) {
+        return ARRLIST_IS_BORROWED;
+    }
+
+    arr->len = 0;
+    return ARRLIST_OK;
+}
+
+size_t arraylist_size(const ArrayList *arr) {
+    if (arr == NULL) {
+        return 0;
+    }
+    return arr->len;
+}
+
+size_t arraylist_capacity(const ArrayList *arr) {
+    if (arr == NULL) {
+        return 0;
+    }
+    return arr->capacity;
+}
+
+bool arraylist_is_empty(const ArrayList *arr) {
+    if (arr == NULL) {
+        return true;
+    }
+    return arr->len == 0;
+}
+
+static ArrayListErr arraylist_grow(ArrayList *arr) {
+    // We can asume is not null because is internal
+    // and only used by funtions that already verified
+    // arr is not null, same with shrink.
+    size_t new_capacity = arr->capacity * 2;
+
+    if (new_capacity > SIZE_MAX / arr->elem_size) {
+        return ARRLIST_ALLOC_OVERFLOW;
+    }
+
+    void *tmp = realloc(arr->buffer, new_capacity * arr->elem_size);
+    if (tmp == NULL) {
+        return ARRLIST_BAD_ALLOC;
+    }
+
+    arr->capacity = new_capacity;
+    arr->buffer = tmp;
+    return ARRLIST_OK;
+}
+
+static ArrayListErr arraylist_shrink(ArrayList *arr) {
+    size_t new_capacity = arr->capacity / 2;
+
+    if (new_capacity > SIZE_MAX / arr->elem_size) {
+        return ARRLIST_ALLOC_OVERFLOW;
+    }
+
+    void *tmp = realloc(arr->buffer, new_capacity * arr->elem_size);
+    if (tmp == NULL) {
+        return ARRLIST_BAD_ALLOC;
+    }
+
+    arr->capacity = new_capacity;
+    arr->buffer = tmp;
+    return ARRLIST_OK;
+}
+
+ArrayListErr arraylist_push_back(ArrayList *arr, void *data) {
+    if (arr == NULL || data == NULL) {
+        return ARRLIST_NULL_ARG;
+    }
+
+    if (arr->borrows > 0) {
+        return ARRLIST_IS_BORROWED;
+    }
+
+    if (arr->len >= arr->capacity) {
+        ArrayListErr err = arraylist_grow(arr);
+
+        if (err != ARRLIST_OK) {
+            return err;
+        }
+    }
+
+    memcpy(arr->buffer + (arr->len * arr->elem_size), data, arr->elem_size);
+    arr->len++;
+    return ARRLIST_OK;
+}
+
+ArrayListErr arraylist_push_front(ArrayList *arr, void *data) {
+    if (arr == NULL || data == NULL) {
+        return ARRLIST_NULL_ARG;
+    }
+
+    if (arr->borrows > 0) {
+        return ARRLIST_IS_BORROWED;
+    }
+
+    if (arr->len >= arr->capacity) {
+        ArrayListErr err = arraylist_grow(arr);
+
+        if (err != ARRLIST_OK) {
+            return err;
+        }
+    }
+
+    // No problem if array is full because  it grows if it's full
+    memmove(
+        arr->buffer + arr->elem_size,
+        arr->buffer,
+        (arr->len) * arr->elem_size);
+
+    memcpy(arr->buffer, data, arr->elem_size);
+
+    arr->len++;
+
+    return ARRLIST_OK;
+}
+
+ArrayListErr arraylist_insert(ArrayList *arr, size_t index, void *data) {
+    if (arr == NULL || data == NULL) {
+        return ARRLIST_NULL_ARG;
+    }
+
+    if (arr->borrows > 0) {
+        return ARRLIST_IS_BORROWED;
+    }
+
+    if (index > arr->len) {
+        return ARRLIST_OUT_OF_BOUNDS;
+    }
+
+    if (arr->len >= arr->capacity) {
+        ArrayListErr err = arraylist_grow(arr);
+        if (err != ARRLIST_OK) {
+            return err;
+        }
+    }
+
+    memmove(
+        arr->buffer + ((index + 1) * arr->elem_size),
+        arr->buffer + (index * arr->elem_size),
+        (arr->len - index) * arr->elem_size);
+
+    memcpy(arr->buffer + (index * arr->elem_size), data, arr->elem_size);
+
+    arr->len++;
+
+    return ARRLIST_OK;
+}
+
+ArrayListErr arraylist_pop_back(ArrayList *arr, void *out) {
+    if (arr == NULL) {
+        return ARRLIST_NULL_ARG;
+    }
+
+    if (arr->borrows > 0) {
+        return ARRLIST_IS_BORROWED;
+    }
+
+    if (arr->len < 1) {
+        return ARRLIST_EMPTY;
+    }
+
+    if (arr->capacity / 4 > arr->len) {
+        ArrayListErr err = arraylist_shrink(arr);
+        if (err != ARRLIST_OK) {
+            return err;
+        }
+    }
+
+    if (out != NULL) {
+        memcpy(
+            out,
+            arr->buffer + (arr->len - 1) * arr->elem_size,
+            arr->elem_size);
+    }
+
+    arr->len--;
+
+    return ARRLIST_OK;
+}
+
+ArrayListErr arraylist_pop_front(ArrayList *arr, void *out) {
+    if (arr == NULL) {
+        return ARRLIST_NULL_ARG;
+    }
+
+    if (arr->borrows > 0) {
+        return ARRLIST_IS_BORROWED;
+    }
+
+    if (arr->len < 1) {
+        return ARRLIST_EMPTY;
+    }
+
+    if (arr->capacity / 4 > arr->len) {
+        ArrayListErr err = arraylist_shrink(arr);
+        if (err != ARRLIST_OK) {
+            return err;
+        }
+    }
+
+    if (out != NULL) {
+        memcpy(out, arr->buffer, arr->elem_size);
+    }
+
+    memmove(
+        arr->buffer,
+        arr->buffer + arr->elem_size,
+        (arr->len - 1) * arr->elem_size);
+
+    arr->len--;
+
+    return ARRLIST_OK;
+}
+
+ArrayListErr arraylist_remove_at(ArrayList *arr, size_t index, void *out) {
+    if (arr == NULL) {
+        return ARRLIST_NULL_ARG;
+    }
+
+    if (arr->borrows > 0) {
+        return ARRLIST_IS_BORROWED;
+    }
+
+    if (index >= arr->len) {
+        return ARRLIST_OUT_OF_BOUNDS;
+    }
+
+    if (arr->len < 1) {
+        return ARRLIST_EMPTY;
+    }
+
+    if (out != NULL) {
+        memcpy(out, arr->buffer + (index * arr->elem_size), arr->elem_size);
+    }
+
+    memmove(
+        arr->buffer + (index * arr->elem_size),
+        arr->buffer + ((index + 1) * arr->elem_size),
+        (arr->len - index) * arr->elem_size);
+
+    arr->len--;
+
+    return ARRLIST_OK;
+}
+
+ArrayListErr arraylist_get(const ArrayList *arr, size_t index, void *out) {
+    if (arr == NULL || out == NULL) {
+        return ARRLIST_NULL_ARG;
+    }
+
+    if (index >= arr->capacity) {
+        return ARRLIST_OUT_OF_BOUNDS;
+    }
+
+    memcpy(out, arr->buffer + (index * arr->elem_size), arr->elem_size);
+
+    return ARRLIST_OK;
+}
+
+ArrayListErr arraylist_set(ArrayList *arr, size_t index, void *data) {
+    if (arr == NULL || data == NULL) {
+        return ARRLIST_NULL_ARG;
+    }
+
+    if (index >= arr->capacity) {
+        return ARRLIST_OUT_OF_BOUNDS;
+    }
+
+    memcpy(arr->buffer + (index * arr->elem_size), data, arr->elem_size);
+
+    return ARRLIST_OK;
+}
+
+ArrayListErr arraylist_resize(ArrayList *arr, size_t new_capacity) {
+    if (arr == NULL) {
+        return ARRLIST_NULL_ARG;
+    }
+
+    if (arr->borrows > 0) {
+        return ARRLIST_IS_BORROWED;
+    }
+
+    if (new_capacity < 1) {
+        return ARRLIST_INVALID_CAPACITY;
+    }
+
+    if (new_capacity > SIZE_MAX / arr->elem_size) {
+        return ARRLIST_ALLOC_OVERFLOW;
+    }
+
+    uint8_t *tmp = realloc(arr->buffer, new_capacity * arr->elem_size);
+    if (tmp == NULL) {
+        return ARRLIST_BAD_ALLOC;
+    }
+
+    arr->buffer = tmp;
+    arr->capacity = new_capacity;
+    return ARRLIST_OK;
+}
+
+ArrayListErr arraylist_reserve(ArrayList *arr, size_t size_to_reserve) {
+    if (arr == NULL) {
+        return ARRLIST_NULL_ARG;
+    }
+
+    if (arr->borrows > 0) {
+        return ARRLIST_IS_BORROWED;
+    }
+
+    if (arr->capacity + size_to_reserve > SIZE_MAX / arr->elem_size ||
+        size_to_reserve > SIZE_MAX / arr->elem_size) {
+
+        return ARRLIST_ALLOC_OVERFLOW;
+    }
+
+    uint8_t *tmp = realloc(
+        arr->buffer,
+        (arr->capacity + size_to_reserve) * arr->elem_size);
+
+    if (tmp == NULL) {
+        return ARRLIST_BAD_ALLOC;
+    }
+
+    arr->buffer = tmp;
+    arr->capacity += size_to_reserve;
+    return ARRLIST_OK;
+}
+
+ArrayListErr arraylist_slice(
+    ArraySlice **slice,
+    Allocator allocator,
+    ArrayList *arr,
+    size_t start,
+    size_t len) {
+    if (arr == NULL || slice == NULL) {
+        return ARRLIST_NULL_ARG;
+    }
+
+    if (arr->len == 0) {
+        return ARRLIST_INVALID_ARR;
+    }
+
+    if (start > SIZE_MAX - len) {
+        return ARRLIST_INVALID_CAPACITY;
+    }
+
+    if (start + len > arr->len || len == 0) {
+        return ARRLIST_INVALID_START;
+    }
+
+    ArraySlice *new_slice =
+        allocator.alloc(allocator.ctx, sizeof(ArraySlice), alignof(ArraySlice));
+    if (new_slice == NULL) {
+        return ARRLIST_BAD_ALLOC;
+    }
+
+    new_slice->arr = arr;
+    new_slice->start = start;
+    new_slice->end = start + len;
+    new_slice->current = start;
+    new_slice->is_safe = true;
+    new_slice->allocator = allocator;
+
+    arr->borrows++;
+    *slice = new_slice;
+    return ARRLIST_OK;
+}
+
+ArrayListErr arraylist_slice_unsafe(
+    ArraySlice **slice,
+    Allocator allocator,
+    ArrayList *arr,
+    size_t start,
+    size_t len) {
+    if (arr == NULL || slice == NULL) {
+        return ARRLIST_NULL_ARG;
+    }
+
+    if (arr->len == 0) {
+        return ARRLIST_INVALID_ARR;
+    }
+
+    if (start > SIZE_MAX - len) {
+        return ARRLIST_INVALID_CAPACITY;
+    }
+
+    if (start + len > arr->len || len == 0) {
+        return ARRLIST_INVALID_START;
+    }
+
+    ArraySlice *new_slice =
+        allocator.alloc(allocator.ctx, sizeof(ArraySlice), alignof(ArraySlice));
+    if (new_slice == NULL) {
+        return ARRLIST_BAD_ALLOC;
+    }
+
+    new_slice->arr = arr;
+    new_slice->start = start;
+    new_slice->end = start + len;
+    new_slice->current = start;
+    new_slice->is_safe = false;
+    new_slice->allocator = allocator;
+
+    *slice = new_slice;
+    return ARRLIST_OK;
+}
+
+ArrayListErr arrayslice_destroy(ArraySlice **slice) {
+    if (slice == NULL || *slice == NULL) {
+        return ARRLIST_NULL_ARG;
+    }
+
+    if ((*slice)->is_safe) {
+        (*slice)->arr->borrows--;
+    }
+
+    (*slice)->allocator.free(
+        (*slice)->allocator.ctx,
+        *slice,
+        sizeof(ArraySlice),
+        alignof(ArraySlice));
+    *slice = NULL;
+
+    return ARRLIST_OK;
+}
+
+bool arrayslice_is_valid(const ArraySlice *slice) {
+    if (slice == NULL) {
+        return false;
+    }
+
+    return slice->current != slice->end;
+}
+
+size_t arrayslice_size(const ArraySlice *slice) {
+    if (slice == NULL) {
+        return 0;
+    }
+
+    return slice->end - slice->start;
+}
+
+ArrayListErr arrayslice_peek(const ArraySlice *slice, void *out) {
+    if (slice == NULL || out == NULL) {
+        return ARRLIST_NULL_ARG;
+    }
+
+    if (slice->current >= slice->end) {
+        return ARRLIST_INVALID_SLICE;
+    }
+
+    arraylist_get(slice->arr, slice->current, out);
+
+    return ARRLIST_OK;
+}
+
+ArrayListErr arrayslice_next(ArraySlice *slice, void *out) {
+    // HERE, it makes sense that you want to advance to the next
+    // without actually getting the value so it's good
+    if (slice == NULL) {
+        return ARRLIST_NULL_ARG;
+    }
+
+    if (slice->current == slice->end) {
+        return ARRLIST_INVALID_SLICE;
+    }
+
+    arraylist_get(slice->arr, slice->current, out);
+
+    slice->current++;
+    return ARRLIST_OK;
+}
+
+ArrayListErr arrayslice_reset(ArraySlice *slice) {
+    if (slice == NULL) {
+        return ARRLIST_NULL_ARG;
+    }
+
+    slice->current = slice->start;
+
+    return ARRLIST_OK;
+}
+
+ArrayListErr arrayslice_advance(ArraySlice *slice, size_t n) {
+    if (slice == NULL) {
+        return ARRLIST_NULL_ARG;
+    }
+
+    if (n > SIZE_MAX - slice->current || slice->current + n > slice->end) {
+        return ARRLIST_OUT_OF_BOUNDS;
+    }
+
+    slice->current += n;
+
+    return ARRLIST_OK;
+}
+
+ArrayListErr arrayslice_to_arraylist(
+    ArrayList **arr,
+    Allocator allocator,
+    const ArraySlice *slice) {
+    if (slice == NULL || slice->arr == NULL) {
+        return ARRLIST_NULL_ARG;
+    }
+
+    if (arr == NULL) {
+        return ARRLIST_NULL_ARG;
+    }
+
+    if (slice->start >= slice->end) {
+        return ARRLIST_INVALID_SLICE;
+    }
+
+    size_t len = slice->end - slice->start;
+
+    ArrayList *new_arr;
+    ArrayListErr init_err = arraylist_init(
+        &new_arr,
+        allocator,
+        arraylist_capacity(slice->arr),
+        slice->arr->elem_size);
+
+    if (init_err != ARRLIST_OK) {
+        return init_err;
+    }
+
+    memcpy(
+        new_arr->buffer,
+        slice->arr->buffer + (slice->start * slice->arr->elem_size),
+        slice->arr->elem_size * len);
+
+    new_arr->len = len;
+
+    *arr = new_arr;
+    return ARRLIST_OK;
+}

test/CMakeLists.txt

@@ -1,15 +0,0 @@
-find_package(cmocka REQUIRED)
-
-add_executable(test_arraylist test_arraylist.c)
-
-target_link_libraries(test_arraylist
-    arraylist_lib
-    cmocka::cmocka
-)
-
-enable_sanitizers(test_arraylist)
-
-target_compile_options(test_arraylist PRIVATE -fsanitize=address -fno-omit-frame-pointer)
-target_link_options(test_arraylist PRIVATE -fsanitize=address)
-
-add_test(NAME arraylist_tests COMMAND arraylists_arena)

xmake.lua

@@ -0,0 +1,94 @@
+set_project("lae_arraylist")
+set_version("1.0.0")
+
+set_languages("c11")
+
+add_rules("mode.debug", "mode.release")
+
+-- clang compile commands
+add_rules("plugin.compile_commands.autoupdate")
+
+-- =========================================================
+-- Options
+-- =========================================================
+
+option("tests")
+set_default(false)
+set_showmenu(true)
+option_end()
+
+option("example")
+set_default(false)
+set_showmenu(true)
+option_end()
+
+option("asan")
+set_default(false)
+set_showmenu(true)
+option_end()
+
+-- =========================================================
+-- Packages
+-- =========================================================
+
+-- Run xmake repo --add lae-repo https://laentropia-homelab.tail7368da.ts.net/laentropia/xmake-repo.git
+-- to add my repo :)
+
+add_requires("cmocka", { optional = true }) -- For tests
+add_requires("lae_allocator")
+
+-- =========================================================
+-- Library
+-- =========================================================
+
+target("lae_arraylist")
+set_kind("static")
+
+add_packages("lae_allocator", { public = true })
+
+add_files("src/lae_arraylist.c")
+
+add_headerfiles("include/*.h")
+
+add_includedirs("include", { public = true })
+
+if is_mode("debug") then
+	add_cflags("-Wall", "-Wextra", "-Wpedantic")
+end
+
+-- =========================================================
+-- Example executable
+-- =========================================================
+
+if has_config("example") then
+	target("example")
+	set_kind("binary")
+
+	add_deps("lae_arraylist")
+	add_packages("lae_allocator")
+
+	add_files("src/main.c")
+end
+
+-- =========================================================
+-- Tests
+-- =========================================================
+
+if has_config("tests") then
+	target("test_arraylist")
+	set_kind("binary")
+
+	add_files("test/test_arraylist.c")
+
+	add_deps("lae_arraylist")
+
+	add_packages("cmocka")
+
+	add_tests("default")
+
+	if has_config("asan") then
+		add_cflags("-fsanitize=address", "-fno-omit-frame-pointer", { force = true })
+
+		add_ldflags("-fsanitize=address", { force = true })
+	end
+end