Refactor strings and allocator to primitives

src/primitives/dbl_list/dbl_list.h

@@ -0,0 +1,484 @@
+/**
+ * THIS FILE IS AUTOMATICALLY GENERATED. ANY MODIFICATIONS TO IT WILL BE OVERWRITTEN
+ */
+
+#ifndef DBL_LIST_H
+#define DBL_LIST_H
+
+#include "../../common/aliases/aliases.h"
+#include "../../common/platform/platform.h"
+#include <stdbool.h>
+
+#ifdef WAPP_PLATFORM_CPP
+BEGIN_C_LINKAGE
+#endif // !WAPP_PLATFORM_CPP
+
+#define wapp_str8_list_node(ITEM_PTR) ((Str8Node){.item = ITEM_PTR})
+#define wapp_void_ptr_list_node(ITEM_PTR) ((VoidPNode){.item = ITEM_PTR})
+#define wapp_bool_list_node(ITEM_PTR) ((BoolNode){.item = ITEM_PTR})
+#define wapp_char_list_node(ITEM_PTR) ((CharNode){.item = ITEM_PTR})
+#define wapp_c8_list_node(ITEM_PTR) ((C8Node){.item = ITEM_PTR})
+#define wapp_c16_list_node(ITEM_PTR) ((C16Node){.item = ITEM_PTR})
+#define wapp_c32_list_node(ITEM_PTR) ((C32Node){.item = ITEM_PTR})
+#define wapp_i8_list_node(ITEM_PTR) ((I8Node){.item = ITEM_PTR})
+#define wapp_i16_list_node(ITEM_PTR) ((I16Node){.item = ITEM_PTR})
+#define wapp_i32_list_node(ITEM_PTR) ((I32Node){.item = ITEM_PTR})
+#define wapp_i64_list_node(ITEM_PTR) ((I64Node){.item = ITEM_PTR})
+#define wapp_u8_list_node(ITEM_PTR) ((U8Node){.item = ITEM_PTR})
+#define wapp_u16_list_node(ITEM_PTR) ((U16Node){.item = ITEM_PTR})
+#define wapp_u32_list_node(ITEM_PTR) ((U32Node){.item = ITEM_PTR})
+#define wapp_u64_list_node(ITEM_PTR) ((U64Node){.item = ITEM_PTR})
+#define wapp_f32_list_node(ITEM_PTR) ((F32Node){.item = ITEM_PTR})
+#define wapp_f64_list_node(ITEM_PTR) ((F64Node){.item = ITEM_PTR})
+#define wapp_f128_list_node(ITEM_PTR) ((F128Node){.item = ITEM_PTR})
+#define wapp_iptr_list_node(ITEM_PTR) ((IptrNode){.item = ITEM_PTR})
+#define wapp_uptr_list_node(ITEM_PTR) ((UptrNode){.item = ITEM_PTR})
+
+typedef struct str8 Str8;
+
+typedef struct Str8Node Str8Node;
+struct Str8Node {
+  Str8 *item;
+  Str8Node *prev;
+  Str8Node *next;
+};
+
+typedef struct Str8List Str8List;
+struct Str8List {
+  Str8Node *first;
+  Str8Node *last;
+  u64 node_count;
+};
+
+typedef struct VoidPNode VoidPNode;
+struct VoidPNode {
+  void * *item;
+  VoidPNode *prev;
+  VoidPNode *next;
+};
+
+typedef struct VoidPList VoidPList;
+struct VoidPList {
+  VoidPNode *first;
+  VoidPNode *last;
+  u64 node_count;
+};
+
+typedef struct BoolNode BoolNode;
+struct BoolNode {
+  bool *item;
+  BoolNode *prev;
+  BoolNode *next;
+};
+
+typedef struct BoolList BoolList;
+struct BoolList {
+  BoolNode *first;
+  BoolNode *last;
+  u64 node_count;
+};
+
+typedef struct CharNode CharNode;
+struct CharNode {
+  char *item;
+  CharNode *prev;
+  CharNode *next;
+};
+
+typedef struct CharList CharList;
+struct CharList {
+  CharNode *first;
+  CharNode *last;
+  u64 node_count;
+};
+
+typedef struct C8Node C8Node;
+struct C8Node {
+  c8 *item;
+  C8Node *prev;
+  C8Node *next;
+};
+
+typedef struct C8List C8List;
+struct C8List {
+  C8Node *first;
+  C8Node *last;
+  u64 node_count;
+};
+
+typedef struct C16Node C16Node;
+struct C16Node {
+  c16 *item;
+  C16Node *prev;
+  C16Node *next;
+};
+
+typedef struct C16List C16List;
+struct C16List {
+  C16Node *first;
+  C16Node *last;
+  u64 node_count;
+};
+
+typedef struct C32Node C32Node;
+struct C32Node {
+  c32 *item;
+  C32Node *prev;
+  C32Node *next;
+};
+
+typedef struct C32List C32List;
+struct C32List {
+  C32Node *first;
+  C32Node *last;
+  u64 node_count;
+};
+
+typedef struct I8Node I8Node;
+struct I8Node {
+  i8 *item;
+  I8Node *prev;
+  I8Node *next;
+};
+
+typedef struct I8List I8List;
+struct I8List {
+  I8Node *first;
+  I8Node *last;
+  u64 node_count;
+};
+
+typedef struct I16Node I16Node;
+struct I16Node {
+  i16 *item;
+  I16Node *prev;
+  I16Node *next;
+};
+
+typedef struct I16List I16List;
+struct I16List {
+  I16Node *first;
+  I16Node *last;
+  u64 node_count;
+};
+
+typedef struct I32Node I32Node;
+struct I32Node {
+  i32 *item;
+  I32Node *prev;
+  I32Node *next;
+};
+
+typedef struct I32List I32List;
+struct I32List {
+  I32Node *first;
+  I32Node *last;
+  u64 node_count;
+};
+
+typedef struct I64Node I64Node;
+struct I64Node {
+  i64 *item;
+  I64Node *prev;
+  I64Node *next;
+};
+
+typedef struct I64List I64List;
+struct I64List {
+  I64Node *first;
+  I64Node *last;
+  u64 node_count;
+};
+
+typedef struct U8Node U8Node;
+struct U8Node {
+  u8 *item;
+  U8Node *prev;
+  U8Node *next;
+};
+
+typedef struct U8List U8List;
+struct U8List {
+  U8Node *first;
+  U8Node *last;
+  u64 node_count;
+};
+
+typedef struct U16Node U16Node;
+struct U16Node {
+  u16 *item;
+  U16Node *prev;
+  U16Node *next;
+};
+
+typedef struct U16List U16List;
+struct U16List {
+  U16Node *first;
+  U16Node *last;
+  u64 node_count;
+};
+
+typedef struct U32Node U32Node;
+struct U32Node {
+  u32 *item;
+  U32Node *prev;
+  U32Node *next;
+};
+
+typedef struct U32List U32List;
+struct U32List {
+  U32Node *first;
+  U32Node *last;
+  u64 node_count;
+};
+
+typedef struct U64Node U64Node;
+struct U64Node {
+  u64 *item;
+  U64Node *prev;
+  U64Node *next;
+};
+
+typedef struct U64List U64List;
+struct U64List {
+  U64Node *first;
+  U64Node *last;
+  u64 node_count;
+};
+
+typedef struct F32Node F32Node;
+struct F32Node {
+  f32 *item;
+  F32Node *prev;
+  F32Node *next;
+};
+
+typedef struct F32List F32List;
+struct F32List {
+  F32Node *first;
+  F32Node *last;
+  u64 node_count;
+};
+
+typedef struct F64Node F64Node;
+struct F64Node {
+  f64 *item;
+  F64Node *prev;
+  F64Node *next;
+};
+
+typedef struct F64List F64List;
+struct F64List {
+  F64Node *first;
+  F64Node *last;
+  u64 node_count;
+};
+
+typedef struct F128Node F128Node;
+struct F128Node {
+  f128 *item;
+  F128Node *prev;
+  F128Node *next;
+};
+
+typedef struct F128List F128List;
+struct F128List {
+  F128Node *first;
+  F128Node *last;
+  u64 node_count;
+};
+
+typedef struct IptrNode IptrNode;
+struct IptrNode {
+  iptr *item;
+  IptrNode *prev;
+  IptrNode *next;
+};
+
+typedef struct IptrList IptrList;
+struct IptrList {
+  IptrNode *first;
+  IptrNode *last;
+  u64 node_count;
+};
+
+typedef struct UptrNode UptrNode;
+struct UptrNode {
+  uptr *item;
+  UptrNode *prev;
+  UptrNode *next;
+};
+
+typedef struct UptrList UptrList;
+struct UptrList {
+  UptrNode *first;
+  UptrNode *last;
+  u64 node_count;
+};
+
+Str8Node *wapp_str8_list_get(const Str8List *list, u64 index);
+void wapp_str8_list_push_front(Str8List *list, Str8Node *node);
+void wapp_str8_list_push_back(Str8List *list, Str8Node *node);
+void wapp_str8_list_insert(Str8List *list, Str8Node *node, u64 index);
+Str8Node *wapp_str8_list_pop_front(Str8List *list);
+Str8Node *wapp_str8_list_pop_back(Str8List *list);
+Str8Node *wapp_str8_list_remove(Str8List *list, u64 index);
+void wapp_str8_list_empty(Str8List *list);
+VoidPNode *wapp_void_ptr_list_get(const VoidPList *list, u64 index);
+void wapp_void_ptr_list_push_front(VoidPList *list, VoidPNode *node);
+void wapp_void_ptr_list_push_back(VoidPList *list, VoidPNode *node);
+void wapp_void_ptr_list_insert(VoidPList *list, VoidPNode *node, u64 index);
+VoidPNode *wapp_void_ptr_list_pop_front(VoidPList *list);
+VoidPNode *wapp_void_ptr_list_pop_back(VoidPList *list);
+VoidPNode *wapp_void_ptr_list_remove(VoidPList *list, u64 index);
+void wapp_void_ptr_list_empty(VoidPList *list);
+BoolNode *wapp_bool_list_get(const BoolList *list, u64 index);
+void wapp_bool_list_push_front(BoolList *list, BoolNode *node);
+void wapp_bool_list_push_back(BoolList *list, BoolNode *node);
+void wapp_bool_list_insert(BoolList *list, BoolNode *node, u64 index);
+BoolNode *wapp_bool_list_pop_front(BoolList *list);
+BoolNode *wapp_bool_list_pop_back(BoolList *list);
+BoolNode *wapp_bool_list_remove(BoolList *list, u64 index);
+void wapp_bool_list_empty(BoolList *list);
+CharNode *wapp_char_list_get(const CharList *list, u64 index);
+void wapp_char_list_push_front(CharList *list, CharNode *node);
+void wapp_char_list_push_back(CharList *list, CharNode *node);
+void wapp_char_list_insert(CharList *list, CharNode *node, u64 index);
+CharNode *wapp_char_list_pop_front(CharList *list);
+CharNode *wapp_char_list_pop_back(CharList *list);
+CharNode *wapp_char_list_remove(CharList *list, u64 index);
+void wapp_char_list_empty(CharList *list);
+C8Node *wapp_c8_list_get(const C8List *list, u64 index);
+void wapp_c8_list_push_front(C8List *list, C8Node *node);
+void wapp_c8_list_push_back(C8List *list, C8Node *node);
+void wapp_c8_list_insert(C8List *list, C8Node *node, u64 index);
+C8Node *wapp_c8_list_pop_front(C8List *list);
+C8Node *wapp_c8_list_pop_back(C8List *list);
+C8Node *wapp_c8_list_remove(C8List *list, u64 index);
+void wapp_c8_list_empty(C8List *list);
+C16Node *wapp_c16_list_get(const C16List *list, u64 index);
+void wapp_c16_list_push_front(C16List *list, C16Node *node);
+void wapp_c16_list_push_back(C16List *list, C16Node *node);
+void wapp_c16_list_insert(C16List *list, C16Node *node, u64 index);
+C16Node *wapp_c16_list_pop_front(C16List *list);
+C16Node *wapp_c16_list_pop_back(C16List *list);
+C16Node *wapp_c16_list_remove(C16List *list, u64 index);
+void wapp_c16_list_empty(C16List *list);
+C32Node *wapp_c32_list_get(const C32List *list, u64 index);
+void wapp_c32_list_push_front(C32List *list, C32Node *node);
+void wapp_c32_list_push_back(C32List *list, C32Node *node);
+void wapp_c32_list_insert(C32List *list, C32Node *node, u64 index);
+C32Node *wapp_c32_list_pop_front(C32List *list);
+C32Node *wapp_c32_list_pop_back(C32List *list);
+C32Node *wapp_c32_list_remove(C32List *list, u64 index);
+void wapp_c32_list_empty(C32List *list);
+I8Node *wapp_i8_list_get(const I8List *list, u64 index);
+void wapp_i8_list_push_front(I8List *list, I8Node *node);
+void wapp_i8_list_push_back(I8List *list, I8Node *node);
+void wapp_i8_list_insert(I8List *list, I8Node *node, u64 index);
+I8Node *wapp_i8_list_pop_front(I8List *list);
+I8Node *wapp_i8_list_pop_back(I8List *list);
+I8Node *wapp_i8_list_remove(I8List *list, u64 index);
+void wapp_i8_list_empty(I8List *list);
+I16Node *wapp_i16_list_get(const I16List *list, u64 index);
+void wapp_i16_list_push_front(I16List *list, I16Node *node);
+void wapp_i16_list_push_back(I16List *list, I16Node *node);
+void wapp_i16_list_insert(I16List *list, I16Node *node, u64 index);
+I16Node *wapp_i16_list_pop_front(I16List *list);
+I16Node *wapp_i16_list_pop_back(I16List *list);
+I16Node *wapp_i16_list_remove(I16List *list, u64 index);
+void wapp_i16_list_empty(I16List *list);
+I32Node *wapp_i32_list_get(const I32List *list, u64 index);
+void wapp_i32_list_push_front(I32List *list, I32Node *node);
+void wapp_i32_list_push_back(I32List *list, I32Node *node);
+void wapp_i32_list_insert(I32List *list, I32Node *node, u64 index);
+I32Node *wapp_i32_list_pop_front(I32List *list);
+I32Node *wapp_i32_list_pop_back(I32List *list);
+I32Node *wapp_i32_list_remove(I32List *list, u64 index);
+void wapp_i32_list_empty(I32List *list);
+I64Node *wapp_i64_list_get(const I64List *list, u64 index);
+void wapp_i64_list_push_front(I64List *list, I64Node *node);
+void wapp_i64_list_push_back(I64List *list, I64Node *node);
+void wapp_i64_list_insert(I64List *list, I64Node *node, u64 index);
+I64Node *wapp_i64_list_pop_front(I64List *list);
+I64Node *wapp_i64_list_pop_back(I64List *list);
+I64Node *wapp_i64_list_remove(I64List *list, u64 index);
+void wapp_i64_list_empty(I64List *list);
+U8Node *wapp_u8_list_get(const U8List *list, u64 index);
+void wapp_u8_list_push_front(U8List *list, U8Node *node);
+void wapp_u8_list_push_back(U8List *list, U8Node *node);
+void wapp_u8_list_insert(U8List *list, U8Node *node, u64 index);
+U8Node *wapp_u8_list_pop_front(U8List *list);
+U8Node *wapp_u8_list_pop_back(U8List *list);
+U8Node *wapp_u8_list_remove(U8List *list, u64 index);
+void wapp_u8_list_empty(U8List *list);
+U16Node *wapp_u16_list_get(const U16List *list, u64 index);
+void wapp_u16_list_push_front(U16List *list, U16Node *node);
+void wapp_u16_list_push_back(U16List *list, U16Node *node);
+void wapp_u16_list_insert(U16List *list, U16Node *node, u64 index);
+U16Node *wapp_u16_list_pop_front(U16List *list);
+U16Node *wapp_u16_list_pop_back(U16List *list);
+U16Node *wapp_u16_list_remove(U16List *list, u64 index);
+void wapp_u16_list_empty(U16List *list);
+U32Node *wapp_u32_list_get(const U32List *list, u64 index);
+void wapp_u32_list_push_front(U32List *list, U32Node *node);
+void wapp_u32_list_push_back(U32List *list, U32Node *node);
+void wapp_u32_list_insert(U32List *list, U32Node *node, u64 index);
+U32Node *wapp_u32_list_pop_front(U32List *list);
+U32Node *wapp_u32_list_pop_back(U32List *list);
+U32Node *wapp_u32_list_remove(U32List *list, u64 index);
+void wapp_u32_list_empty(U32List *list);
+U64Node *wapp_u64_list_get(const U64List *list, u64 index);
+void wapp_u64_list_push_front(U64List *list, U64Node *node);
+void wapp_u64_list_push_back(U64List *list, U64Node *node);
+void wapp_u64_list_insert(U64List *list, U64Node *node, u64 index);
+U64Node *wapp_u64_list_pop_front(U64List *list);
+U64Node *wapp_u64_list_pop_back(U64List *list);
+U64Node *wapp_u64_list_remove(U64List *list, u64 index);
+void wapp_u64_list_empty(U64List *list);
+F32Node *wapp_f32_list_get(const F32List *list, u64 index);
+void wapp_f32_list_push_front(F32List *list, F32Node *node);
+void wapp_f32_list_push_back(F32List *list, F32Node *node);
+void wapp_f32_list_insert(F32List *list, F32Node *node, u64 index);
+F32Node *wapp_f32_list_pop_front(F32List *list);
+F32Node *wapp_f32_list_pop_back(F32List *list);
+F32Node *wapp_f32_list_remove(F32List *list, u64 index);
+void wapp_f32_list_empty(F32List *list);
+F64Node *wapp_f64_list_get(const F64List *list, u64 index);
+void wapp_f64_list_push_front(F64List *list, F64Node *node);
+void wapp_f64_list_push_back(F64List *list, F64Node *node);
+void wapp_f64_list_insert(F64List *list, F64Node *node, u64 index);
+F64Node *wapp_f64_list_pop_front(F64List *list);
+F64Node *wapp_f64_list_pop_back(F64List *list);
+F64Node *wapp_f64_list_remove(F64List *list, u64 index);
+void wapp_f64_list_empty(F64List *list);
+F128Node *wapp_f128_list_get(const F128List *list, u64 index);
+void wapp_f128_list_push_front(F128List *list, F128Node *node);
+void wapp_f128_list_push_back(F128List *list, F128Node *node);
+void wapp_f128_list_insert(F128List *list, F128Node *node, u64 index);
+F128Node *wapp_f128_list_pop_front(F128List *list);
+F128Node *wapp_f128_list_pop_back(F128List *list);
+F128Node *wapp_f128_list_remove(F128List *list, u64 index);
+void wapp_f128_list_empty(F128List *list);
+IptrNode *wapp_iptr_list_get(const IptrList *list, u64 index);
+void wapp_iptr_list_push_front(IptrList *list, IptrNode *node);
+void wapp_iptr_list_push_back(IptrList *list, IptrNode *node);
+void wapp_iptr_list_insert(IptrList *list, IptrNode *node, u64 index);
+IptrNode *wapp_iptr_list_pop_front(IptrList *list);
+IptrNode *wapp_iptr_list_pop_back(IptrList *list);
+IptrNode *wapp_iptr_list_remove(IptrList *list, u64 index);
+void wapp_iptr_list_empty(IptrList *list);
+UptrNode *wapp_uptr_list_get(const UptrList *list, u64 index);
+void wapp_uptr_list_push_front(UptrList *list, UptrNode *node);
+void wapp_uptr_list_push_back(UptrList *list, UptrNode *node);
+void wapp_uptr_list_insert(UptrList *list, UptrNode *node, u64 index);
+UptrNode *wapp_uptr_list_pop_front(UptrList *list);
+UptrNode *wapp_uptr_list_pop_back(UptrList *list);
+UptrNode *wapp_uptr_list_remove(UptrList *list, u64 index);
+void wapp_uptr_list_empty(UptrList *list);
+
+#ifdef WAPP_PLATFORM_CPP
+END_C_LINKAGE
+#endif // !WAPP_PLATFORM_CPP
+
+#endif // !DBL_LIST_H

src/primitives/mem_allocator/mem_allocator.c

@@ -0,0 +1,44 @@
+#include "mem_allocator.h"
+#include "../../common/aliases/aliases.h"
+#include <stdlib.h>
+
+void *wapp_mem_allocator_alloc(const Allocator *allocator, u64 size) {
+  if (!allocator || !(allocator->alloc)) {
+    return NULL;
+  }
+
+  return allocator->alloc(size, allocator->obj);
+}
+
+void *wapp_mem_allocator_alloc_aligned(const Allocator *allocator, u64 size, u64 alignment) {
+  if (!allocator || !(allocator->alloc_aligned)) {
+    return NULL;
+  }
+
+  return allocator->alloc_aligned(size, alignment, allocator->obj);
+}
+
+void *wapp_mem_allocator_realloc(const Allocator *allocator, void *ptr, u64 old_size, u64 new_size) {
+  if (!allocator || !(allocator->realloc)) {
+    return NULL;
+  }
+
+  return allocator->realloc(ptr, old_size, new_size, allocator->obj);
+}
+
+void *wapp_mem_allocator_realloc_aligned(const Allocator *allocator, void *ptr, u64 old_size,
+                                         u64 new_size, u64 alignment) {
+  if (!allocator || !(allocator->realloc_aligned)) {
+    return NULL;
+  }
+
+  return allocator->realloc_aligned(ptr, old_size, new_size, alignment, allocator->obj);
+}
+
+void wapp_mem_allocator_free(const Allocator *allocator, void **ptr, u64 size) {
+  if (!allocator || !(allocator->free)) {
+    return;
+  }
+
+  allocator->free(ptr, size, allocator->obj);
+}

src/primitives/mem_allocator/mem_allocator.h

@@ -0,0 +1,43 @@
+#ifndef MEM_ALLOCATOR_H
+#define MEM_ALLOCATOR_H
+
+#include "../../common/aliases/aliases.h"
+#include "../../common/platform/platform.h"
+#include <string.h>
+
+#ifdef WAPP_PLATFORM_CPP
+BEGIN_C_LINKAGE
+#endif // WAPP_PLATFORM_CPP
+
+typedef void *(MemAllocFunc)(u64 size, void *alloc_obj);
+typedef void *(MemAllocAlignedFunc)(u64 size, u64 alignment, void *alloc_obj);
+typedef void *(MemReallocFunc)(void *ptr, u64 old_size, u64 new_size, void *alloc_obj);
+typedef void *(MemReallocAlignedFunc)(void *ptr, u64 old_size, u64 new_size, u64 alignment, void *alloc_obj);
+typedef void  (MemFreeFunc)(void **ptr, u64 size, void *alloc_obj);
+
+
+typedef struct allocator Allocator;
+struct allocator {
+  void *obj;
+  MemAllocFunc *alloc;
+  MemAllocAlignedFunc *alloc_aligned;
+  MemReallocFunc *realloc;
+  MemReallocAlignedFunc *realloc_aligned;
+  MemFreeFunc *free;
+};
+
+#define wapp_mem_allocator_invalid(ALLOCATOR) (memcmp(ALLOCATOR, &((Allocator){0}), sizeof(Allocator)) == 0)
+
+
+void *wapp_mem_allocator_alloc(const Allocator *allocator, u64 size);
+void *wapp_mem_allocator_alloc_aligned(const Allocator *allocator, u64 size, u64 alignment);
+void *wapp_mem_allocator_realloc(const Allocator *allocator, void *ptr, u64 old_size, u64 new_size);
+void *wapp_mem_allocator_realloc_aligned(const Allocator *allocator, void *ptr, u64 old_size,
+                                         u64 new_size, u64 alignment);
+void wapp_mem_allocator_free(const Allocator *allocator, void **ptr, u64 size);
+
+#ifdef WAPP_PLATFORM_CPP
+END_C_LINKAGE
+#endif // WAPP_PLATFORM_CPP
+
+#endif // !MEM_ALLOCATOR_H

src/primitives/strings/str8/str8.c

@@ -0,0 +1,468 @@
+#include "str8.h"
+#include "../../../common/aliases/aliases.h"
+#include "../../mem_allocator/mem_allocator.h"
+#include <stdarg.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdbool.h>
+
+#define STR8_BUF_ALLOC_SIZE(CAPACITY) (sizeof(Str8) + sizeof(c8) * CAPACITY)
+
+Str8 *wapp_str8_alloc_buf(const Allocator *allocator, u64 capacity) {
+  Str8 *str = NULL;
+
+  if (!allocator) {
+    goto RETURN_STR8;
+  }
+
+  str = wapp_mem_allocator_alloc(allocator, STR8_BUF_ALLOC_SIZE(capacity));
+  if (!str) {
+    goto RETURN_STR8;
+  }
+
+  str->buf      = (u8 *)str + sizeof(Str8);
+  str->size     = 0;
+  str->capacity = capacity;
+
+RETURN_STR8:
+  return str;
+}
+
+Str8 *wapp_str8_alloc_cstr(const Allocator *allocator, const char *str) {
+  Str8 *output = NULL;
+
+  if (!allocator || !str) {
+    goto RETURN_ALLOC_CSTR;
+  }
+
+  u64 length = strlen(str);
+  output     = wapp_str8_alloc_buf(allocator, length * 2);
+  if (!output) {
+    goto RETURN_ALLOC_CSTR;
+  }
+
+  output->size = length;
+  memcpy(output->buf, str, length);
+
+RETURN_ALLOC_CSTR:
+  return output;
+}
+
+Str8 *wapp_str8_alloc_str8(const Allocator *allocator, Str8RO *str) {
+  Str8 *output = NULL;
+
+  if (!allocator || !str) {
+    goto RETURN_ALLOC_STR8;
+  }
+
+  output = wapp_str8_alloc_buf(allocator, str->capacity);
+  if (!output) {
+    goto RETURN_ALLOC_STR8;
+  }
+
+  output->size = str->size;
+  memcpy(output->buf, str->buf, str->size);
+
+RETURN_ALLOC_STR8:
+  return output;
+}
+
+Str8 *wapp_str8_alloc_substr(const Allocator *allocator, Str8RO *str, u64 start, u64 end) {
+  Str8 *output = NULL;
+  if (!allocator || !str) {
+    goto RETURN_ALLOC_SUBSTR;
+  }
+
+  if (start >= str->size || start >= end) {
+    goto RETURN_ALLOC_SUBSTR;
+  }
+
+  if (end > str->size) {
+    end = str->size;
+  }
+
+  output = wapp_str8_alloc_buf(allocator, str->capacity);
+  if (!output) {
+    goto RETURN_ALLOC_SUBSTR;
+  }
+
+  output->size = end - start;
+  memcpy(output->buf, str->buf + start, output->size);
+
+RETURN_ALLOC_SUBSTR:
+  return output;
+}
+
+void wapp_str8_dealloc_buf(const Allocator *allocator, Str8 **str) {
+  if (!allocator || !str || !(*str)) {
+    return;
+  }
+
+  wapp_mem_allocator_free(allocator, (void **)str, STR8_BUF_ALLOC_SIZE((*str)->capacity));
+}
+
+c8 wapp_str8_get(const Str8 *str, u64 index) {
+  if (index >= str->size) {
+    return '\0';
+  }
+
+  return str->buf[index];
+}
+
+void wapp_str8_set(Str8 *str, u64 index, c8 c) {
+  if (index >= str->size) {
+    return;
+  }
+
+  str->buf[index] = c;
+}
+
+void wapp_str8_push_back(Str8 *str, c8 c) {
+  if (!(str->size < str->capacity)) {
+    return;
+  }
+
+  u64 index = (str->size)++;
+  wapp_str8_set(str, index, c);
+}
+
+bool wapp_str8_equal(Str8RO *s1, Str8RO *s2) {
+  if (s1->size != s2->size) {
+    return false;
+  }
+
+  return wapp_str8_equal_to_count(s1, s2, s1->size);
+}
+
+bool wapp_str8_equal_to_count(Str8RO* s1, Str8RO* s2, u64 count) {
+    if (!s1 || !s2) {
+        return false;
+    }
+
+    return memcmp(s1->buf, s2->buf, count) == 0;
+}
+
+Str8 wapp_str8_slice(Str8RO *str, u64 start, u64 end) {
+  if (start >= str->size || start >= end) {
+    start = str->size;
+    end   = str->size;
+  }
+
+  if (end > str->size) {
+    end = str->size;
+  }
+
+  return (Str8RO){
+    .capacity = end - start,
+    .size     = end - start,
+    .buf      = str->buf + start,
+  };
+}
+
+Str8 *wapp_str8_alloc_concat(const Allocator *allocator, Str8 *dst, Str8RO *src) {
+  if (!allocator || !dst || !src) {
+    return NULL;
+  }
+
+  Str8 *output  = NULL;
+  u64 remaining = dst->capacity - dst->size;
+  if (src->size <= remaining) {
+    output = dst;
+    goto COPY_STRING_STR8_CONCAT;
+  }
+
+  u64 capacity = dst->capacity + src->size;
+
+  output = wapp_str8_alloc_buf(allocator, capacity);
+  if (!output) {
+    goto RETURN_STR8_CONCAT;
+  }
+
+  wapp_str8_concat_capped(output, dst);
+
+COPY_STRING_STR8_CONCAT:
+  wapp_str8_concat_capped(output, src);
+
+RETURN_STR8_CONCAT:
+  return output;
+}
+
+void wapp_str8_concat_capped(Str8 *dst, Str8RO *src) {
+  if (!dst || !src) {
+    return;
+  }
+
+  u64 remaining = dst->capacity - dst->size;
+  u64 to_copy   = remaining < src->size ? remaining : src->size;
+
+  memcpy(dst->buf + dst->size, src->buf, to_copy);
+  dst->size += to_copy;
+}
+
+void wapp_str8_copy_cstr_capped(Str8 *dst, const char *src) {
+  if (!dst || !src) {
+    return;
+  }
+
+  u64 length  = strlen(src);
+  u64 to_copy = length <= dst->capacity ? length : dst->capacity;
+
+  memset(dst->buf, 0, dst->size);
+  memcpy(dst->buf, src, to_copy);
+  dst->size = to_copy;
+}
+
+void wapp_str8_copy_str8_capped(Str8 *dst, Str8RO *src) {
+  if (!dst || !src) {
+    return;
+  }
+
+  u64 to_copy = src->size <= dst->capacity ? src->size : dst->capacity;
+
+  memset(dst->buf, 0, dst->size);
+  memcpy(dst->buf, src->buf, to_copy);
+  dst->size = to_copy;
+}
+
+void wapp_str8_copy_to_cstr(char *dst, Str8RO *src, u64 dst_capacity) {
+  if (!dst || !src) {
+    return;
+  }
+
+  u64 to_copy = src->size < dst_capacity ? src->size : dst_capacity - 1;
+
+  memset(dst, 0, dst_capacity);
+  memcpy(dst, src->buf, to_copy);
+}
+
+void wapp_str8_format(Str8 *dst, const char *format, ...) {
+  if (!dst || !format) {
+    return;
+  }
+
+  va_list args1;
+  va_list args2;
+
+  va_start(args1, format);
+  va_copy(args2, args1);
+
+  u64 total_size = vsnprintf(NULL, 0, format, args1);
+  dst->size      = total_size <= dst->capacity ? total_size : dst->capacity;
+
+  vsnprintf((char *)(dst->buf), dst->capacity, format, args2);
+
+  va_end(args1);
+  va_end(args2);
+}
+
+i64 wapp_str8_find(Str8RO *str, Str8RO substr) {
+  if (!str || substr.size > str->size) {
+    return -1;
+  }
+
+  // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
+  // MSVC Spectre mitigation warnings
+  u64 char_index = 0;
+  bool running   = true;
+  while (running) {
+    const c8 *sub = str->buf + char_index;
+    if (memcmp(sub, substr.buf, substr.size) == 0) {
+      return char_index;
+    }
+
+    ++char_index;
+    running = char_index < str->size;
+  }
+
+  return -1;
+}
+
+i64 wapp_str8_rfind(Str8RO *str, Str8RO substr) {
+  if (!str || substr.size > str->size) {
+    return -1;
+  }
+
+  // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
+  // MSVC Spectre mitigation warnings
+  i64 char_index = str->size - substr.size;
+  bool running   = true;
+  while (running) {
+    const c8 *sub = str->buf + char_index;
+    if (memcmp(sub, substr.buf, substr.size) == 0) {
+      return char_index;
+    }
+
+    --char_index;
+    running = char_index >= 0;
+  }
+
+  return -1;
+}
+
+Str8List *wapp_str8_split_with_max(const Allocator *allocator, Str8RO *str, Str8RO *delimiter, i64 max_splits) {
+  if (!allocator || !str || !delimiter) {
+    return NULL;
+  }
+
+  Str8List *output = wapp_mem_allocator_alloc(allocator, sizeof(Str8List));
+
+  if (delimiter->size > str->size) {
+    Str8 *full     = wapp_str8_alloc_str8(allocator, str);
+    Str8Node *node = wapp_mem_allocator_alloc(allocator, sizeof(Str8Node));
+    if (node) {
+      node->item = full;
+      wapp_str8_list_push_back(output, node);
+    }
+
+    goto RETURN_STR8_SPLIT;
+  }
+
+  i64 start   = 0;
+  i64 end     = 0;
+  i64 splits  = 0;
+  Str8 *rest = wapp_str8_alloc_str8(allocator, str);
+  Str8 *before_str;
+
+  while ((end = wapp_str8_find(rest, *delimiter)) != -1) {
+    if (max_splits > 0 && splits >= max_splits) {
+      break;
+    }
+
+    before_str     = wapp_str8_alloc_substr(allocator, str, start, start + end);
+    Str8Node *node = wapp_mem_allocator_alloc(allocator, sizeof(Str8Node));
+    if (node) {
+      node->item = before_str;
+      wapp_str8_list_push_back(output, node);
+    }
+
+    wapp_mem_allocator_free(allocator, (void **)&rest, sizeof(Str8));
+    rest   = wapp_str8_alloc_substr(allocator, str, start + end + delimiter->size, str->size);
+    start += end + delimiter->size;
+
+    ++splits;
+  }
+
+  // Ensure the last part of the string after the delimiter is added to the list
+  rest           = wapp_str8_alloc_substr(allocator, str, start, str->size);
+  Str8Node *node = wapp_mem_allocator_alloc(allocator, sizeof(Str8Node));
+  if (node) {
+    node->item = rest;
+    wapp_str8_list_push_back(output, node);
+  }
+
+RETURN_STR8_SPLIT:
+  return output;
+}
+
+Str8List *wapp_str8_rsplit_with_max(const Allocator *allocator, Str8RO *str, Str8RO *delimiter, i64 max_splits) {
+  if (!allocator || !str || !delimiter) {
+    return NULL;
+  }
+
+  Str8List *output = wapp_mem_allocator_alloc(allocator, sizeof(Str8List));
+
+  if (delimiter->size > str->size) {
+    Str8 *full     = wapp_str8_alloc_str8(allocator, str);
+    Str8Node *node = wapp_mem_allocator_alloc(allocator, sizeof(Str8Node));
+    if (node) {
+      node->item = full;
+      wapp_str8_list_push_back(output, node);
+    }
+
+    goto RETURN_STR8_SPLIT;
+  }
+
+  i64 end     = 0;
+  i64 splits  = 0;
+  Str8 *rest = wapp_str8_alloc_str8(allocator, str);
+  Str8 *after_str;
+
+  while ((end = wapp_str8_rfind(rest, *delimiter)) != -1) {
+    if (max_splits > 0 && splits >= max_splits) {
+      break;
+    }
+
+    after_str     = wapp_str8_alloc_substr(allocator, rest, end + delimiter->size, str->size);
+    Str8Node *node = wapp_mem_allocator_alloc(allocator, sizeof(Str8Node));
+    if (node) {
+      node->item = after_str;
+      wapp_str8_list_push_front(output, node);
+    }
+
+    wapp_mem_allocator_free(allocator, (void **)&rest, sizeof(Str8));
+    rest   = wapp_str8_alloc_substr(allocator, rest, 0, end);
+
+    ++splits;
+  }
+
+  rest           = wapp_str8_alloc_substr(allocator, str, 0, rest->size);
+  Str8Node *node = wapp_mem_allocator_alloc(allocator, sizeof(Str8Node));
+  if (node) {
+    node->item = rest;
+    wapp_str8_list_push_front(output, node);
+  }
+
+RETURN_STR8_SPLIT:
+  return output;
+}
+
+Str8 *wapp_str8_join(const Allocator *allocator, const Str8List *list, Str8RO *delimiter) {
+  if (!allocator || !list || !delimiter) {
+    return NULL;
+  }
+
+  u64 capacity = wapp_str8_list_total_size(list) + (delimiter->size * (list->node_count - 1));
+  Str8 *output = wapp_str8_alloc_buf(allocator, capacity * 2);
+
+  // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
+  // MSVC Spectre mitigation warnings
+  Str8Node *node;
+  u64 node_index = 0;
+  bool running   = true;
+  while (running) {
+    node = wapp_str8_list_get(list, node_index);
+    if (!node) {
+        break;
+    }
+
+    wapp_str8_concat_capped(output, node->item);
+
+    // NOTE (Abdelrahman): Comparison extracted to variable to silence
+    // MSVC Spectre mitigation warnings
+    bool not_last = node_index + 1 < list->node_count;
+    if (not_last) {
+      wapp_str8_concat_capped(output, delimiter);
+    }
+
+    ++node_index;
+    running = node_index < list->node_count;
+  }
+
+  return output;
+}
+
+u64 wapp_str8_list_total_size(const Str8List *list) {
+  if (!list) {
+    return 0;
+  }
+
+  // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
+  // MSVC Spectre mitigation warnings
+  Str8Node* node;
+  u64 node_index = 0;
+  u64 output     = 0;
+  bool running   = true;
+  while (running) {
+      node = wapp_str8_list_get(list, node_index);
+      if (!node) {
+          break;
+      }
+
+      output += node->item->size;
+      ++node_index;
+      running = node_index < list->node_count;
+  }
+
+  return output;
+}

src/primitives/strings/str8/str8.h

@@ -0,0 +1,103 @@
+#ifndef STR8_H
+#define STR8_H
+
+#include "../../../common/aliases/aliases.h"
+#include "../../../common/platform/platform.h"
+#include "../../../primitives/dbl_list/dbl_list.h"
+#include "../../mem_allocator/mem_allocator.h"
+#include <string.h>
+#include <stdbool.h>
+
+#ifdef WAPP_PLATFORM_CPP
+BEGIN_C_LINKAGE
+#endif // !WAPP_PLATFORM_CPP
+
+typedef struct str8 Str8;
+struct str8 {
+  u64 capacity;
+  u64 size;
+  c8 *buf;
+};
+
+typedef const Str8 Str8RO;
+
+/**
+ * Utilities to be used with printf functions
+ */
+#define WAPP_STR8_SPEC "%.*s"
+#define wapp_str8_varg(STRING) (int)((STRING).size), (STRING).buf
+
+/**
+ * Str8 stack buffers
+ */
+#define wapp_str8_buf(CAPACITY) ((Str8){.capacity = CAPACITY, .size = 0, .buf = (c8[CAPACITY]){0}})
+
+// Utilises the fact that memcpy returns pointer to dest buffer and that getting
+// address of compound literals is valid in C to create a string on the stack
+#define wapp_str8_lit(STRING) ((Str8){.capacity = (sizeof(STRING) - 1) * 2, \
+                                      .size     = sizeof(STRING) - 1,       \
+                                      .buf      = memcpy(&((c8 [sizeof(STRING) * 2]){0}), STRING, sizeof(STRING))})
+#define wapp_str8_lit_ro(STRING) ((Str8RO){.capacity = sizeof(STRING) - 1, \
+                                           .size     = sizeof(STRING) - 1, \
+                                           .buf      = (c8 *)STRING})
+// To be used only when initialising a static storage variable in compilers that don't support
+// initialisers with the syntax of wapp_str8_lit_ro (e.g. gcc). Should only be used when necessary
+// and only be assigned to a Str8RO variable to avoid any attempt at modifying the string
+#define wapp_str8_lit_ro_initialiser_list(STRING) {.capacity = sizeof(STRING) - 1, \
+                                                   .size     = sizeof(STRING) - 1, \
+                                                   .buf      = (c8 *)STRING}
+
+/**
+ * Str8 allocated buffers
+ */
+Str8 *wapp_str8_alloc_buf(const Allocator *allocator, u64 capacity);
+Str8 *wapp_str8_alloc_cstr(const Allocator *allocator, const char *str);
+Str8 *wapp_str8_alloc_str8(const Allocator *allocator, Str8RO *str);
+Str8 *wapp_str8_alloc_substr(const Allocator *allocator, Str8RO *str, u64 start, u64 end);
+Str8 *wapp_str8_alloc_concat(const Allocator *allocator, Str8 *dst, Str8RO *src);
+// Only needed for allocators like malloc where each allocation has to be freed on its own.
+// No need to use it for allocators like Arena.
+void wapp_str8_dealloc_buf(const Allocator *allocator, Str8 **str);
+
+/**
+ * Str8 utilities
+ */
+c8   wapp_str8_get(Str8RO *str, u64 index);
+void wapp_str8_set(Str8 *str, u64 index, c8 c);
+void wapp_str8_push_back(Str8 *str, c8 c);
+bool wapp_str8_equal(Str8RO *s1, Str8RO *s2);
+bool wapp_str8_equal_to_count(Str8RO* s1, Str8RO* s2, u64 count);
+Str8 wapp_str8_slice(Str8RO *str, u64 start, u64 end);
+void wapp_str8_concat_capped(Str8 *dst, Str8RO *src);
+void wapp_str8_copy_cstr_capped(Str8 *dst, const char *src);
+void wapp_str8_copy_str8_capped(Str8 *dst, Str8RO *src);
+void wapp_str8_copy_to_cstr(char *dst, Str8RO *src, u64 dst_capacity);
+void wapp_str8_format(Str8 *dst, const char *format, ...);
+
+/**
+ * Str8 find functions
+ */
+i64 wapp_str8_find(Str8RO *str, Str8RO substr);
+i64 wapp_str8_rfind(Str8RO *str, Str8RO substr);
+
+/**
+ * Str8 split and join
+ */
+#define wapp_str8_split(ALLOCATOR, STR, DELIMITER) wapp_str8_split_with_max(ALLOCATOR, STR, DELIMITER, -1)
+#define wapp_str8_rsplit(ALLOCATOR, STR, DELIMITER) wapp_str8_rsplit_with_max(ALLOCATOR, STR, DELIMITER, -1)
+Str8List *wapp_str8_split_with_max(const Allocator *allocator, Str8RO *str, Str8RO *delimiter, i64 max_splits);
+Str8List *wapp_str8_rsplit_with_max(const Allocator *allocator, Str8RO *str, Str8RO *delimiter, i64 max_splits);
+Str8     *wapp_str8_join(const Allocator *allocator, const Str8List *list, Str8RO *delimiter);
+
+/**
+ * Str8 list utilities
+ */
+#define wapp_str8_node_from_cstr(STRING) wapp_str8_list_node(&wapp_str8_lit(STRING))
+#define wapp_str8_node_from_str8(STRING) wapp_str8_list_node(&(STRING))
+u64 wapp_str8_list_total_size(const Str8List *list);
+
+#ifdef WAPP_PLATFORM_CPP
+END_C_LINKAGE
+#endif // !WAPP_PLATFORM_CPP
+
+#endif // !STR8_H

src/primitives/wapp_primitives.c

@@ -0,0 +1,10 @@
+#ifndef WAPP_PRIMITIVES_C
+#define WAPP_PRIMITIVES_C
+
+#include "wapp_primitives.h"
+#include "array/array.c"
+#include "dbl_list/dbl_list.c"
+#include "mem_allocator/mem_allocator.c"
+#include "strings/str8/str8.c"
+
+#endif // !WAPP_PRIMITIVES_C

src/primitives/wapp_primitives.h

@@ -0,0 +1,10 @@
+#ifndef WAPP_PRIMITIVES_H
+#define WAPP_PRIMITIVES_H
+
+#include "dbl_list/dbl_list.h"
+#include "array/array.h"
+#include "mem_allocator/mem_allocator.h"
+#include "strings/str8/str8.h"
+#include "../common/wapp_common.h"
+
+#endif // !WAPP_PRIMITIVES_H