Reorganise the code

src/aliases/aliases.h

@@ -0,0 +1,30 @@
+#ifndef ALIASES_H
+#define ALIASES_H
+
+#include <stdint.h>
+
+#define u8 uint8_t
+#define u16 uint16_t
+#define u32 uint32_t
+#define u64 uint64_t
+
+#define i8 int8_t
+#define i16 int16_t
+#define i32 int32_t
+#define i64 int64_t
+
+#define f32 float
+#define f64 double
+#define f128 long double
+
+#define uptr uintptr_t
+#define iptr intptr_t
+
+#define internal static
+#define persistent static
+
+#ifdef __cplusplus
+#define class_mem static
+#endif // __cplusplus
+
+#endif // !ALIASES_H

src/cpath/cpath.c

@@ -0,0 +1,87 @@
+#include "cpath.h"
+#include "aliases.h"
+#include <stdarg.h>
+#include <stdio.h>
+#include <string.h>
+
+#if defined(__unix__) || defined(__APPLE__) || defined(__ANDROID__)
+internal char path_sep = '/';
+#elif defined(_WIN32) || defined(_WIN64)
+internal char path_sep = '\\';
+#endif
+
+void join_root_and_leaf(const char *root, const char *leaf, char *dst);
+
+void join_path(char *dst, u64 count, ...) {
+  va_list args;
+
+  va_start(args, count);
+
+  for (u64 i = 0; i < count; ++i) {
+    join_root_and_leaf(dst, va_arg(args, const char *), dst);
+  }
+
+  va_end(args);
+}
+
+void dirup(char *dst, u64 levels, const char *path) {
+  if (levels < 1) {
+    return;
+  }
+
+  u64 end_index = 0;
+  u64 sep_count = 0;
+
+  u64 full_length;
+  u64 length;
+  length = full_length = strlen(path);
+
+  if (path[length - 1] == path_sep) {
+    --length;
+  }
+
+  for (u64 i = length - 1; i >= 0; --i) {
+    if (path[i] == path_sep) {
+      ++sep_count;
+      end_index = i;
+
+      if (sep_count == levels) {
+        break;
+      }
+    }
+  }
+
+  if (sep_count < levels) {
+    end_index = 0;
+  }
+
+  if (dst == path) {
+    memset(&dst[end_index], 0, full_length - end_index);
+  } else {
+    u64 dst_length = strlen(dst);
+    memset(dst, 0, dst_length);
+    strncpy(dst, path, end_index);
+  }
+}
+
+void join_root_and_leaf(const char *root, const char *leaf, char *dst) {
+  u64 root_length = strlen(root);
+  u64 root_end = root_length - 1;
+
+  u64 leaf_length = strlen(leaf);
+  u64 leaf_start = 0;
+
+  if (root[root_end] == path_sep) {
+    --root_end;
+  }
+
+  if (leaf[leaf_start] == path_sep) {
+    ++leaf_start;
+  }
+
+  memcpy(dst, root, ++root_end);
+
+  dst[root_end] = path_sep;
+
+  memcpy(&(dst[++root_end]), &(leaf[leaf_start]), leaf_length - leaf_start);
+}

src/cpath/cpath.h

@@ -0,0 +1,25 @@
+#ifndef PATH_UTILS_H
+#define PATH_UTILS_H
+
+#include "aliases.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+#define NUMPARTS(...)                                                          \
+  (sizeof((const char *[]){"", __VA_ARGS__}) / sizeof(const char *) - 1)
+
+#define wapp_cpath_join_path(DST, ...)                                         \
+  join_path(DST, NUMPARTS(__VA_ARGS__), __VA_ARGS__)
+#define wapp_cpath_dirname(DST, PATH) dirup(DST, 1, PATH)
+#define wapp_cpath_dirup(DST, COUNT, PATH) dirup(DST, COUNT, PATH)
+
+void join_path(char *dst, u64 count, ...);
+void dirup(char *dst, u64 levels, const char *path);
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+
+#endif // !PATH_UTILS_H

src/dstr/dstr.c

@@ -0,0 +1,223 @@
+#include "dstr.h"
+#include "aliases.h"
+#include "mem_allocator.h"
+#include "mem_libc.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+// Use this scalar to allocate extra memory in order to avoid having to
+// constantly reallocate
+#define CAPACITY_SCALAR 8
+
+struct dstr {
+  Allocator allocator;
+  u64 capacity;
+  u64 size;
+  char buf[];
+};
+
+String *wapp_dstr_with_capacity(u64 capacity, const Allocator *allocator) {
+  Allocator alloc;
+  if (allocator) {
+    alloc = *allocator;
+  } else {
+    alloc = wapp_mem_libc_allocator();
+  }
+
+  String *out =
+      (String *)wapp_mem_allocator_alloc(&alloc, sizeof(String) + capacity + 1);
+  if (!out) {
+    return NULL;
+  }
+
+  out->allocator = alloc;
+  out->capacity = capacity;
+  out->size = 0;
+
+  return out;
+}
+
+String *wapp_dstr_from_string(const char *str, const Allocator *allocator) {
+  if (!str) {
+    return NULL;
+  }
+
+  u64 length = strlen(str);
+
+  u64 capacity = length * CAPACITY_SCALAR;
+
+  String *out = wapp_dstr_with_capacity(capacity, allocator);
+  if (!out) {
+    return NULL;
+  }
+
+  out->size = length;
+  strncpy(out->buf, str, length + 1);
+
+  return out;
+}
+
+void wapp_dstr_update(String **dst, const char *src) {
+  if (!dst || !(*dst)) {
+    return;
+  }
+
+  u64 length = strlen(src);
+
+  String *str = *dst;
+
+  if (length < str->capacity) {
+    memset(str->buf, 0, str->capacity);
+
+    str->size = length;
+
+    strncpy(str->buf, src, length + 1);
+  } else {
+    u64 capacity = length * CAPACITY_SCALAR;
+
+    String *tmp = (String *)wapp_mem_allocator_realloc(
+        &(str->allocator), *dst, sizeof(String) + capacity + 1);
+    if (!tmp) {
+      return;
+    }
+
+    tmp->capacity = capacity;
+    tmp->size = length;
+    strncpy(tmp->buf, src, length + 1);
+
+    *dst = tmp;
+  }
+}
+
+void wapp_dstr_free(String **str) {
+  if (!str || !(*str)) {
+    return;
+  }
+
+  String *str_ptr = *str;
+  wapp_mem_allocator_free(&(str_ptr->allocator), (void **)str);
+}
+
+void wapp_dstr_concat(String **dst, const char *src) {
+  if (!dst || !(*dst)) {
+    return;
+  }
+
+  u64 src_length = strlen(src);
+  if (src_length == 0) {
+    return;
+  }
+
+  u64 new_length = (*dst)->size + src_length;
+
+  char str[new_length + 1];
+  memset(str, 0, new_length + 1);
+
+  strncpy(str, (*dst)->buf, (*dst)->size);
+  strncat(str, src, new_length + 1 - (*dst)->size);
+
+  wapp_dstr_update(dst, str);
+}
+
+void wapp_dstr_append(String **dst, char c) {
+  if (!dst || !(*dst)) {
+    return;
+  }
+
+  u64 new_length = (*dst)->size + 1;
+
+  char str[new_length + 1];
+  memset(str, 0, new_length + 1);
+
+  strncpy(str, (*dst)->buf, (*dst)->size);
+  str[(*dst)->size] = c;
+
+  wapp_dstr_update(dst, str);
+}
+
+void wapp_dstr_resize(String **str) {
+  if (!str || !(*str)) {
+    return;
+  }
+
+  String *str_ptr = *str;
+  u64 capacity = (*str)->size;
+
+  String *tmp = (String *)wapp_mem_allocator_realloc(
+      &(str_ptr->allocator), *str, sizeof(String) + capacity + 1);
+  if (!tmp) {
+    return;
+  }
+
+  tmp->capacity = capacity;
+
+  *str = tmp;
+}
+
+void wapp_dstr_clear(String *str) {
+  if (!str || str->size == 0) {
+    return;
+  }
+
+  memset(str->buf, 0, str->capacity);
+  str->size = 0;
+}
+
+void wapp_dstr_print(const String *str) {
+  if (!str) {
+    return;
+  }
+
+  printf("%.*s\n", (i32)str->size, str->buf);
+}
+
+i64 wapp_dstr_find(const String *str, const char *substr) {
+  if (!str || !substr) {
+    return -1;
+  }
+
+  u64 substr_length = strlen(substr);
+  if (substr_length == 0 || substr_length > str->size) {
+    return -1;
+  }
+
+  const char *s1;
+  for (u64 i = 0; i < str->size; ++i) {
+    if (i + substr_length > str->size) {
+      break;
+    }
+
+    s1 = &(str->buf[i]);
+
+    if (strncmp(s1, substr, substr_length) == 0) {
+      return i;
+    }
+  }
+
+  return -1;
+}
+
+u64 wapp_dstr_length(const String *str) {
+  if (!str) {
+    return 0;
+  }
+
+  return str->size;
+}
+
+u64 wapp_dstr_capacity(const String *str) {
+  if (!str) {
+    return 0;
+  }
+
+  return str->capacity;
+}
+
+const char *wapp_dstr_to_cstr(const String *str) {
+  if (!str) {
+    return "";
+  }
+
+  return str->buf;
+}

src/dstr/dstr.h

@@ -0,0 +1,31 @@
+#ifndef DSTR_H
+#define DSTR_H
+
+#include "aliases.h"
+#include "mem_allocator.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+typedef struct dstr String;
+
+String *wapp_dstr_with_capacity(u64 capacity, const Allocator *allocator);
+String *wapp_dstr_from_string(const char *str, const Allocator *allocator);
+void wapp_dstr_update(String **dst, const char *src);
+void wapp_dstr_free(String **str);
+void wapp_dstr_concat(String **dst, const char *src);
+void wapp_dstr_append(String **dst, char c);
+void wapp_dstr_resize(String **str);
+void wapp_dstr_clear(String *str);
+void wapp_dstr_print(const String *str);
+i64 wapp_dstr_find(const String *str, const char *substr);
+u64 wapp_dstr_length(const String *str);
+u64 wapp_dstr_capacity(const String *str);
+const char *wapp_dstr_to_cstr(const String *str);
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+
+#endif // !DSTR_H

src/mem/arena/mem_arena.c

@@ -0,0 +1,233 @@
+#include "mem_arena.h"
+#include "aliases.h"
+#include "mem_utils.h"
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifndef DEFAULT_ALIGNMENT
+// Why 2 * sizeof(void *) instead of sizeof(void *)
+// https://handmade.network/forums/t/6860-alignment_arena_allocator
+#define DEFAULT_ALIGNMENT (2 * sizeof(void *))
+#endif /* ifndef DEFAULT_ALIGNMENT */
+
+#define ARENA_MINIMUM_CAPACITY 1024
+
+typedef struct base_arena BaseArena;
+struct base_arena {
+  u8 *buf;
+  u8 *offset;
+  u64 capacity;
+  BaseArena *prev;
+  BaseArena *next;
+};
+
+struct growing_arena {
+  BaseArena *active_arena;
+  u64 count;
+  u64 initial_capacity;
+};
+
+internal bool base_arena_init(BaseArena *arena, u64 capacity);
+internal void *base_arena_alloc_aligned(BaseArena *arena, u64 size,
+                                        u64 alignment);
+internal void base_arena_clear(BaseArena *arena);
+internal void base_arena_destroy(BaseArena *arena);
+
+// PUBLIC API
+
+bool wapp_mem_arena_init(Arena **arena, u64 base_capacity) {
+  if (!arena || *arena || base_capacity == 0) {
+    return false;
+  }
+
+  *arena = (Arena *)calloc(1, sizeof(Arena));
+  Arena *arena_ptr = *arena;
+  if (!arena_ptr) {
+    return false;
+  }
+
+  arena_ptr->active_arena = (BaseArena *)calloc(1, sizeof(BaseArena));
+  if (!(arena_ptr->active_arena)) {
+    wapp_mem_arena_destroy(arena);
+    return false;
+  }
+
+  if (!base_arena_init(arena_ptr->active_arena, base_capacity)) {
+    wapp_mem_arena_destroy(arena);
+    return false;
+  }
+
+  arena_ptr->count = 1;
+  arena_ptr->initial_capacity = base_capacity;
+
+  return true;
+}
+
+void *wapp_mem_arena_alloc(Arena *arena, u64 size) {
+  return wapp_mem_arena_alloc_aligned(arena, size, DEFAULT_ALIGNMENT);
+}
+
+void *wapp_mem_arena_alloc_aligned(Arena *arena, u64 size, u64 alignment) {
+  if (!arena || !(arena->active_arena)) {
+    return NULL;
+  }
+
+  void *output = base_arena_alloc_aligned(arena->active_arena, size, alignment);
+  if (!output) {
+    if (arena->active_arena->next) {
+      arena->active_arena = arena->active_arena->next;
+    } else {
+      arena->active_arena->next = (BaseArena *)calloc(1, sizeof(BaseArena));
+      if (!(arena->active_arena->next)) {
+        return NULL;
+      }
+
+      if (!base_arena_init(arena->active_arena->next,
+                           arena->initial_capacity)) {
+        free(arena->active_arena->next);
+        return NULL;
+      }
+
+      arena->active_arena->next->prev = arena->active_arena;
+      arena->active_arena = arena->active_arena->next;
+
+      ++(arena->count);
+    }
+
+    output = base_arena_alloc_aligned(arena->active_arena, size, alignment);
+    if (!output) {
+      return NULL;
+    }
+  }
+
+  memset(output, 0, size);
+
+  return output;
+}
+
+void wapp_mem_arena_clear(Arena *arena) {
+  if (!arena) {
+    return;
+  }
+
+  BaseArena *last_active = NULL;
+  while (arena->active_arena) {
+    base_arena_clear(arena->active_arena);
+
+    last_active = arena->active_arena;
+
+    arena->active_arena = arena->active_arena->prev;
+  }
+
+  arena->active_arena = last_active;
+}
+
+void wapp_mem_arena_destroy(Arena **arena) {
+  if (!arena) {
+    return;
+  }
+
+  Arena *arena_ptr = *arena;
+  if (!arena_ptr) {
+    return;
+  }
+
+  BaseArena *current;
+  BaseArena *next;
+  BaseArena *prev;
+
+  current = arena_ptr->active_arena->next;
+  while (current) {
+    next = current->next;
+
+    base_arena_destroy(current);
+    free(current);
+
+    current = next;
+  }
+
+  current = arena_ptr->active_arena->prev;
+  while (current) {
+    prev = current->prev;
+
+    base_arena_destroy(current);
+    free(current);
+
+    current = prev;
+  }
+
+  base_arena_destroy(arena_ptr->active_arena);
+
+  free(arena_ptr->active_arena);
+  arena_ptr->active_arena = NULL;
+
+  arena_ptr->count = 0;
+  arena_ptr->initial_capacity = 0;
+
+  free(*arena);
+  *arena = NULL;
+}
+
+// INTERNAL FUNCTIONS
+
+internal bool base_arena_init(BaseArena *arena, u64 capacity) {
+  if (!arena || arena->buf || capacity == 0) {
+    return false;
+  }
+
+  u64 arena_capacity =
+      capacity >= ARENA_MINIMUM_CAPACITY ? capacity : ARENA_MINIMUM_CAPACITY;
+
+  arena->buf = (u8 *)calloc(arena_capacity, sizeof(u8));
+  if (!(arena->buf)) {
+    return false;
+  }
+
+  arena->capacity = arena_capacity;
+  arena->offset = arena->buf;
+  arena->prev = arena->next = NULL;
+
+  return true;
+}
+
+internal void *base_arena_alloc_aligned(BaseArena *arena, u64 size,
+                                        u64 alignment) {
+  if (!arena) {
+    return NULL;
+  }
+
+  u8 *alloc_start = arena->offset;
+
+  u8 *output = wapp_mem_util_align_forward((void *)alloc_start, alignment);
+  if (output + size >= arena->buf + arena->capacity) {
+    return NULL;
+  }
+
+  arena->offset = output + size;
+
+  return (void *)output;
+}
+
+internal void base_arena_clear(BaseArena *arena) {
+  if (!arena) {
+    return;
+  }
+
+  memset(arena->buf, 0, arena->offset - arena->buf);
+  arena->offset = arena->buf;
+}
+
+internal void base_arena_destroy(BaseArena *arena) {
+  if (!arena) {
+    return;
+  }
+
+  if (arena->buf) {
+    free(arena->buf);
+  }
+
+  arena->buf = arena->offset = NULL;
+  arena->capacity = 0;
+  arena->prev = arena->next = NULL;
+}

src/mem/arena/mem_arena.h

@@ -0,0 +1,23 @@
+#ifndef MEM_ARENA_H
+#define MEM_ARENA_H
+
+#include "aliases.h"
+#include <stdbool.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+typedef struct growing_arena Arena;
+
+bool wapp_mem_arena_init(Arena **arena, u64 base_capacity);
+void *wapp_mem_arena_alloc(Arena *arena, u64 size);
+void *wapp_mem_arena_alloc_aligned(Arena *arena, u64 size, u64 alignment);
+void wapp_mem_arena_clear(Arena *arena);
+void wapp_mem_arena_destroy(Arena **arena);
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+
+#endif // !MEM_ARENA_H

src/mem/util/mem_utils.c

@@ -0,0 +1,28 @@
+#include "mem_utils.h"
+#include "aliases.h"
+#include <assert.h>
+#include <stdbool.h>
+#include <stdlib.h>
+
+internal bool is_power_of_two(u64 num) { return (num & (num - 1)) == 0; }
+
+void *wapp_mem_util_align_forward(void *ptr, u64 alignment) {
+  if (!ptr) {
+    return NULL;
+  }
+
+  assert(is_power_of_two(alignment));
+
+  uptr p = (uptr)ptr;
+  uptr align = (uptr)alignment;
+
+  // Similar to p % align, but it's a faster implementation that works fine
+  // because align is guaranteed to be a power of 2
+  uptr modulo = p & (align - 1);
+
+  if (modulo != 0) {
+    p += align - modulo;
+  }
+
+  return (void *)p;
+}

src/mem/util/mem_utils.h

@@ -0,0 +1,16 @@
+#ifndef MEM_UTILS_H
+#define MEM_UTILS_H
+
+#include "aliases.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+void *wapp_mem_util_align_forward(void *ptr, u64 alignment);
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+
+#endif // !MEM_UTILS_H