Replace bool, true and false with aliases

Makefile

@@ -12,7 +12,7 @@ LIB_OUT      = $(BUILD_DIR)/libwapp.so
 TEST_OUT     = $(BUILD_DIR)/wapptest
 
 ifeq ($(BUILD_TYPE),debug)
-	CFLAGS += -g -fsanitize=address,undefined
+	CFLAGS += -g -fsanitize=address,undefined -DWAPP_DEBUG_ASSERT
 else ifeq ($(BUILD_TYPE),release)
 	CFLAGS += -O3
 else

codegen/array/make_array.py

@@ -46,7 +46,10 @@ def make_array(user_datatypes: Dict[CDataType, ArrayData] = {}):
     out_dir.mkdir(parents=True, exist_ok=True)
 
     common_includes: List[CInclude] = [
-        CInclude(header="stdbool.h"),
+        CInclude(
+            header=str(convert_to_relative(WAPP_SRC_ROOT / "common" / "aliases" / "aliases.h", out_dir)).replace("\\", "/"),
+            local=True,
+        ),
         CInclude(
             header=str(convert_to_relative(WAPP_SRC_ROOT / "primitives" / "mem_allocator" / "mem_allocator.h", out_dir)).replace("\\", "/"),
             local=True,
@@ -74,11 +77,6 @@ def make_array(user_datatypes: Dict[CDataType, ArrayData] = {}):
                 array_typename="VoidPArray",
             )
             continue
-        elif _type == CType.BOOL:
-            datatypes[_type.value] = ArrayData(
-                array_typename="BoolArray",
-            )
-            continue
 
         type_title = _type.value.title()
         datatypes[_type.value] = ArrayData(
@@ -103,7 +101,10 @@ def make_array(user_datatypes: Dict[CDataType, ArrayData] = {}):
         includes=[
             CInclude(header, local=True, same_dir=True),
             CInclude(header="stddef.h"),
-            CInclude(header="assert.h"),
+            CInclude(
+                header=str(convert_to_relative(WAPP_SRC_ROOT / "common" / "assert" / "assert.h", out_dir)).replace("\\", "/"),
+                local=True
+            ),
         ],
         internal_funcs=[],
         funcs=header.funcs

codegen/array/snippets/alloc_capacity

@@ -1,4 +1,4 @@
-  assert(allocator != NULL);
+  wapp_debug_assert(allocator != NULL, "`array` should not be NULL");
 
   u64 allocation_size = sizeof({ArrayType}) + item_size * capacity;
   {ArrayType} *array  = wapp_mem_allocator_alloc(allocator, allocation_size);

codegen/array/snippets/append_alloc

@@ -1,4 +1,4 @@
-  assert(allocator != NULL && array != NULL);
+  wapp_debug_assert(allocator != NULL && array != NULL, "`allocator` and `array` should not be NULL");
 
   {ArrayType} *output = array;
 

codegen/array/snippets/append_capped

@@ -1,4 +1,5 @@
-  assert(array != NULL && array->count < array->capacity);
+  wapp_debug_assert(array != NULL, "`array` should not be NULL");
+  wapp_runtime_assert(array->count < array->capacity, "`array` is full");
 
   u64 index = (array->count)++;
   wapp_{Tlower}_array_set(array, index, item);

codegen/array/snippets/array_get

@@ -1,4 +1,5 @@
-  assert(array != NULL && index < array->count);
+  wapp_debug_assert(array != NULL, "`array` should not be NULL");
+  wapp_runtime_assert(index < array->count, "`index` is out of bounds");
 
   u8 *ptr = (u8 *)(array->items) + (array->item_size * index);
   return ({T} *)ptr;

codegen/array/snippets/clear

@@ -1,2 +1,2 @@
-  assert(array != NULL);
+  wapp_debug_assert(array != NULL, "`array` should not be NULL");
   array->count = 0;

codegen/array/snippets/copy_alloc

@@ -1,4 +1,4 @@
-  assert(allocator != NULL && src != NULL && dst != NULL);
+  wapp_debug_assert(allocator != NULL && src != NULL && dst != NULL, "`allocator`, `src` and `dst` should not be NULL");
 
   {ArrayType} *output = dst;
 

codegen/array/snippets/copy_capped

@@ -1,4 +1,4 @@
-  assert(src != NULL && dst != NULL);
+  wapp_debug_assert(src != NULL && dst != NULL, "`src` and `dst` should not be NULL");
 
   wapp_{Tlower}_array_clear(dst);
 
@@ -8,7 +8,7 @@
   // MSVC Spectre mitigation warnings
   u64 to_copy    = src->count < dst->capacity ? src->count : dst->capacity;
   u64 item_index = 0;
-  bool running   = true;
+  b32 running    = true;
   while (running) {{
     item = wapp_{Tlower}_array_get(src, item_index);
     ++item_index;

codegen/array/snippets/extend_alloc

@@ -1,4 +1,4 @@
-  assert(allocator != NULL && array != NULL && other != NULL);
+  wapp_debug_assert(allocator != NULL && array != NULL && other != NULL, "`allocator`, `array` and `other` should not be NULL");
 
   {ArrayType} *output = array;
 

codegen/array/snippets/extend_capped

@@ -1,7 +1,7 @@
-  assert(array != NULL && other != NULL);
+  wapp_debug_assert(array != NULL && other != NULL, "`array` and `other` should not be NULL");
 
   u64 remaining_capacity = array->capacity - array->count;
-  assert(other->count < remaining_capacity);
+  wapp_runtime_assert(other->count < remaining_capacity, "`array` does not have enough capacity");
 
   {T} *item;
 
@@ -9,7 +9,7 @@
   // MSVC Spectre mitigation warnings
   u64 items_to_add = other->count;
   u64 item_index   = 0;
-  bool running     = true;
+  b32 running      = true;
   while (running) {{
     item = wapp_{Tlower}_array_get(other, item_index);
     ++item_index;

codegen/datatypes.py

@@ -9,7 +9,7 @@ from codegen.utils import convert_to_relative
 
 class CType(Enum):
     VOID = "void"
-    BOOL = "bool"
+    BOOL = "b32"
     CHAR = "char"
     C8   = "c8"
     C16  = "c16"

codegen/dbl_list/make_dbl_list.py

@@ -2,7 +2,7 @@ from pathlib import Path
 from dataclasses import dataclass, field
 from typing import List, Dict
 from codegen.constants import WAPP_SRC_ROOT
-from codegen.utils import load_func_body_from_file
+from codegen.utils import load_func_body_from_file, convert_to_relative
 from codegen.datatypes import (
     CDataType,
     CMacro,
@@ -49,7 +49,10 @@ def make_dbl_list(user_datatypes: Dict[CDataType, DblListData] = {}):
     out_dir.mkdir(parents=True, exist_ok=True)
 
     common_includes: List[CInclude] = [
-        CInclude(header="stdbool.h")
+        CInclude(
+            header=str(convert_to_relative(WAPP_SRC_ROOT / "common" / "aliases" / "aliases.h", out_dir)).replace("\\", "/"),
+            local=True,
+        )
     ]
 
     common_decl_types: List[CStruct] = []
@@ -95,6 +98,10 @@ def make_dbl_list(user_datatypes: Dict[CDataType, DblListData] = {}):
         decl_types=[*common_decl_types],
         includes=[
             CInclude(header, local=True, same_dir=True),
+            CInclude(
+                header=str(convert_to_relative(WAPP_SRC_ROOT / "common" / "assert" / "assert.h", out_dir)).replace("\\", "/"),
+                local=True
+            ),
             CInclude(header="stddef.h"),
             CInclude(header="assert.h"),
         ],

codegen/dbl_list/snippets/list_empty

@@ -1,4 +1,4 @@
-  assert(list != NULL);
+  wapp_debug_assert(list != NULL, "`list` should not be NULL");
 
   u64 count = list->node_count;
   for (u64 i = 0; i < count; ++i) {{

codegen/dbl_list/snippets/list_get

@@ -1,4 +1,4 @@
-  assert(index < list->node_count);
+  wapp_runtime_assert(index < list->node_count, "`index` is out of bounds");
 
   {NodeType} *output  = NULL;
   {NodeType} *current = list->first;

codegen/dbl_list/snippets/list_insert

@@ -1,4 +1,4 @@
-  assert(list != NULL && node != NULL && (node->item) != NULL);
+  wapp_debug_assert(list != NULL && node != NULL && (node->item) != NULL, "`list`, `node` and `node->item` should not be NULL");
 
   if (index == 0) {{
     wapp_{Tlower}_list_push_front(list, node);

codegen/dbl_list/snippets/list_pop_back

@@ -1,4 +1,4 @@
-  assert(list != NULL);
+  wapp_debug_assert(list != NULL, "`list` should not be NULL");
 
   {NodeType} *output = NULL;
 

codegen/dbl_list/snippets/list_pop_front

@@ -1,4 +1,4 @@
-  assert(list != NULL);
+  wapp_debug_assert(list != NULL, "`list` should not be NULL");
 
   {NodeType} *output = NULL;
 

codegen/dbl_list/snippets/list_push_back

@@ -1,4 +1,4 @@
-  assert(list != NULL && node != NULL && (node->item) != NULL);
+  wapp_debug_assert(list != NULL && node != NULL && (node->item) != NULL, "`list`, `node` and `node->item` should not be NULL");
 
   {ListType} node_list = {Tlower}_node_to_list(node);
 

codegen/dbl_list/snippets/list_push_front

@@ -1,4 +1,4 @@
-  assert(list != NULL && node != NULL && (node->item) != NULL);
+  wapp_debug_assert(list != NULL && node != NULL && (node->item) != NULL, "`list`, `node` and `node->item` should not be NULL");
 
   {ListType} node_list = {Tlower}_node_to_list(node);
 

codegen/dbl_list/snippets/list_remove

@@ -1,4 +1,4 @@
-  assert(list != NULL);
+  wapp_debug_assert(list != NULL, "`list` should not be NULL");
 
   {NodeType} *output = NULL;
 

src/common/aliases/aliases.h

@@ -28,6 +28,16 @@
 #define u32 uint32_t
 #define u64 uint64_t
 
+#define b32 uint32_t
+
+#ifndef false
+#define false (b32)0
+#endif
+
+#ifndef true
+#define true (b32)1
+#endif
+
 #define i8 int8_t
 #define i16 int16_t
 #define i32 int32_t

src/common/assert/assert.h

@@ -0,0 +1,27 @@
+// vim:fileencoding=utf-8:foldmethod=marker
+
+#include "../aliases/aliases.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <inttypes.h>
+
+#define wapp_static_assert(EXPR, MSG) extern char ASSERTION_FAILED[EXPR ? 1 : -1]
+#define wapp_runtime_assert(EXPR, MSG) __wapp_runtime_assert(EXPR, MSG)
+
+#ifdef WAPP_DEBUG_ASSERT
+  #define wapp_debug_assert(EXPR, MSG) wapp_runtime_assert(EXPR, MSG)
+#else
+  #define wapp_debug_assert(EXPR, MSG)
+#endif
+
+#define __wapp_runtime_assert(EXPR, MSG) do {                                         \
+  if (!(EXPR)) {                                                                      \
+    fprintf(                                                                          \
+      stderr,                                                                         \
+      "%s:%d (In function `%s`): Assertion failed (%" PRIu32 ")\nDiagnostic: %s\n\n", \
+      __FILE__, __LINE__, __func__,                                                   \
+      EXPR, MSG                                                                       \
+    );                                                                                \
+    abort();                                                                          \
+  }                                                                                   \
+} while(false)

src/common/wapp_common.h

@@ -4,6 +4,7 @@
 #define WAPP_COMMON_H
 
 #include "aliases/aliases.h"
+#include "assert/assert.h"
 #include "misc/misc_utils.h"
 #include "platform/platform.h"
 

src/core/mem/arena/mem_arena.c

@@ -3,12 +3,12 @@
 #include "mem_arena.h"
 #include "../utils/mem_utils.h"
 #include "../../../common/aliases/aliases.h"
+#include "../../../common/assert/assert.h"
 #include "../../../common/misc/misc_utils.h"
 #include "../../os/mem/mem_os.h"
 #include <stdbool.h>
 #include <stdlib.h>
 #include <string.h>
-#include <assert.h>
 
 #ifndef DEFAULT_ALIGNMENT
 // Why 2 * sizeof(void *) instead of sizeof(void *)
@@ -66,7 +66,7 @@ void *wapp_mem_arena_alloc(Arena *arena, u64 size) {
 }
 
 void *wapp_mem_arena_alloc_aligned(Arena *arena, u64 size, u64 alignment) {
-  assert(arena != NULL);
+  wapp_debug_assert(arena != NULL, "`arena` should not be NULL");
 
   u8 *alloc_start = arena->offset;
 
@@ -125,14 +125,14 @@ void *wapp_mem_arena_realloc_aligned(Arena *arena, void *ptr, u64 old_size, u64
 }
 
 void wapp_mem_arena_clear(Arena *arena) {
-  assert(arena != NULL);
+  wapp_debug_assert(arena != NULL, "`arena` should not be NULL");
 
   memset(arena->buf, 0, arena->offset - arena->buf);
   arena->offset = arena->buf;
 }
 
 void wapp_mem_arena_destroy(Arena **arena) {
-  assert(arena != NULL && (*arena) != NULL);
+  wapp_debug_assert(arena != NULL && (*arena) != NULL, "`arena` double pointer is not valid");
 
   Arena *arena_ptr = *arena;
   if (arena_ptr->buf) {

src/core/mem/utils/mem_utils.c

@@ -2,15 +2,15 @@
 
 #include "mem_utils.h"
 #include "../../../common/aliases/aliases.h"
+#include "../../../common/assert/assert.h"
 #include <stdbool.h>
 #include <stddef.h>
-#include <assert.h>
 
 internal bool is_power_of_two(u64 num) { return (num & (num - 1)) == 0; }
 
 void *wapp_mem_util_align_forward(void *ptr, u64 alignment) {
-  assert(ptr != NULL);
-  assert(is_power_of_two(alignment));
+  wapp_debug_assert(ptr != NULL, "`ptr` should not be NULL");
+  wapp_runtime_assert(is_power_of_two(alignment), "`alignment` value is not a power of two");
 
   uptr p = (uptr)ptr;
   uptr align = (uptr)alignment;

src/primitives/array/array.h

@@ -5,11 +5,11 @@
 #ifndef ARRAY_H
 #define ARRAY_H
 
+#include "../../common/aliases/aliases.h"
 #include "../mem_allocator/mem_allocator.h"
 #include "../../common/misc/misc_utils.h"
 #include "../../common/aliases/aliases.h"
 #include "../../common/platform/platform.h"
-#include <stdbool.h>
 
 #define wapp_str8_array(...) ((Str8Array){ \
   .items = (Str8[wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(Str8, __VA_ARGS__) * 2)]){__VA_ARGS__}, \
@@ -35,17 +35,17 @@
   *_void_ptr_array_pop(ARRAY_PTR) : \
   (void *){0} \
 )
-#define wapp_bool_array(...) ((BoolArray){ \
-  .items = (bool[wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(bool, __VA_ARGS__) * 2)]){__VA_ARGS__}, \
-  .count = wapp_misc_utils_va_args_count(bool, __VA_ARGS__), \
-  .capacity = wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(bool, __VA_ARGS__) * 2), \
-  .item_size = sizeof(bool) \
+#define wapp_b32_array(...) ((B32Array){ \
+  .items = (b32[wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(b32, __VA_ARGS__) * 2)]){__VA_ARGS__}, \
+  .count = wapp_misc_utils_va_args_count(b32, __VA_ARGS__), \
+  .capacity = wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(b32, __VA_ARGS__) * 2), \
+  .item_size = sizeof(b32) \
 })
-#define wapp_bool_array_with_capacity(CAPACITY) ((BoolArray){.items = (bool[CAPACITY]){0}, .count = 0, .capacity = CAPACITY, .item_size = sizeof(bool)})
-#define wapp_bool_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY) ((BoolArray *)_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY, sizeof(bool)))
-#define wapp_bool_array_pop(ARRAY_PTR) (ARRAY_PTR != NULL && (ARRAY_PTR)->count > 0 ? \
-  *_bool_array_pop(ARRAY_PTR) : \
-  (bool){0} \
+#define wapp_b32_array_with_capacity(CAPACITY) ((B32Array){.items = (b32[CAPACITY]){0}, .count = 0, .capacity = CAPACITY, .item_size = sizeof(b32)})
+#define wapp_b32_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY) ((B32Array *)_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY, sizeof(b32)))
+#define wapp_b32_array_pop(ARRAY_PTR) (ARRAY_PTR != NULL && (ARRAY_PTR)->count > 0 ? \
+  *_b32_array_pop(ARRAY_PTR) : \
+  (b32){0} \
 )
 #define wapp_char_array(...) ((CharArray){ \
   .items = (char[wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(char, __VA_ARGS__) * 2)]){__VA_ARGS__}, \
@@ -270,9 +270,9 @@ struct VoidPArray {
   u64 item_size;
 };
 
-typedef struct BoolArray BoolArray;
-struct BoolArray {
-  bool *items;
+typedef struct B32Array B32Array;
+struct B32Array {
+  b32 *items;
   u64 count;
   u64 capacity;
   u64 item_size;
@@ -434,16 +434,16 @@ VoidPArray *wapp_void_ptr_array_append_alloc(const Allocator *allocator, VoidPAr
 VoidPArray *wapp_void_ptr_array_extend_alloc(const Allocator *allocator, VoidPArray *array, const VoidPArray *other);
 VoidPArray *wapp_void_ptr_array_copy_alloc(const Allocator *allocator, const VoidPArray *src, VoidPArray *dst);
 void * *_void_ptr_array_pop(VoidPArray *array);
-bool *wapp_bool_array_get(const BoolArray *array, u64 index);
-void wapp_bool_array_set(BoolArray *array, u64 index, bool *item);
-void wapp_bool_array_append_capped(BoolArray *array, bool *item);
-void wapp_bool_array_extend_capped(BoolArray *array, const BoolArray *other);
-void wapp_bool_array_clear(BoolArray *array);
-void wapp_bool_array_copy_capped(const BoolArray *src, BoolArray *dst);
-BoolArray *wapp_bool_array_append_alloc(const Allocator *allocator, BoolArray *array, bool *item);
-BoolArray *wapp_bool_array_extend_alloc(const Allocator *allocator, BoolArray *array, const BoolArray *other);
-BoolArray *wapp_bool_array_copy_alloc(const Allocator *allocator, const BoolArray *src, BoolArray *dst);
-bool *_bool_array_pop(BoolArray *array);
+b32 *wapp_b32_array_get(const B32Array *array, u64 index);
+void wapp_b32_array_set(B32Array *array, u64 index, b32 *item);
+void wapp_b32_array_append_capped(B32Array *array, b32 *item);
+void wapp_b32_array_extend_capped(B32Array *array, const B32Array *other);
+void wapp_b32_array_clear(B32Array *array);
+void wapp_b32_array_copy_capped(const B32Array *src, B32Array *dst);
+B32Array *wapp_b32_array_append_alloc(const Allocator *allocator, B32Array *array, b32 *item);
+B32Array *wapp_b32_array_extend_alloc(const Allocator *allocator, B32Array *array, const B32Array *other);
+B32Array *wapp_b32_array_copy_alloc(const Allocator *allocator, const B32Array *src, B32Array *dst);
+b32 *_b32_array_pop(B32Array *array);
 char *wapp_char_array_get(const CharArray *array, u64 index);
 void wapp_char_array_set(CharArray *array, u64 index, char *item);
 void wapp_char_array_append_capped(CharArray *array, char *item);

src/primitives/dbl_list/dbl_list.h

@@ -5,13 +5,13 @@
 #ifndef DBL_LIST_H
 #define DBL_LIST_H
 
+#include "../../common/aliases/aliases.h"
 #include "../../common/aliases/aliases.h"
 #include "../../common/platform/platform.h"
-#include <stdbool.h>
 
 #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_b32_list_node(ITEM_PTR) ((B32Node){.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})
@@ -60,17 +60,17 @@ struct VoidPList {
   u64 node_count;
 };
 
-typedef struct BoolNode BoolNode;
-struct BoolNode {
-  bool *item;
-  BoolNode *prev;
-  BoolNode *next;
+typedef struct B32Node B32Node;
+struct B32Node {
+  b32 *item;
+  B32Node *prev;
+  B32Node *next;
 };
 
-typedef struct BoolList BoolList;
-struct BoolList {
-  BoolNode *first;
-  BoolNode *last;
+typedef struct B32List B32List;
+struct B32List {
+  B32Node *first;
+  B32Node *last;
   u64 node_count;
 };
 
@@ -328,14 +328,14 @@ 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);
+B32Node *wapp_b32_list_get(const B32List *list, u64 index);
+void wapp_b32_list_push_front(B32List *list, B32Node *node);
+void wapp_b32_list_push_back(B32List *list, B32Node *node);
+void wapp_b32_list_insert(B32List *list, B32Node *node, u64 index);
+B32Node *wapp_b32_list_pop_front(B32List *list);
+B32Node *wapp_b32_list_pop_back(B32List *list);
+B32Node *wapp_b32_list_remove(B32List *list, u64 index);
+void wapp_b32_list_empty(B32List *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);

src/primitives/mem_allocator/mem_allocator.c

@@ -2,27 +2,27 @@
 
 #include "mem_allocator.h"
 #include "../../common/aliases/aliases.h"
+#include "../../common/assert/assert.h"
 #include <stdlib.h>
-#include <assert.h>
 
 void *wapp_mem_allocator_alloc(const Allocator *allocator, u64 size) {
-  assert(allocator != NULL && (allocator->alloc) != NULL);
+  wapp_debug_assert(allocator != NULL && (allocator->alloc) != NULL, "`allocator` and `allocator->alloc` should not be NULL");
   return allocator->alloc(size, allocator->obj);
 }
 
 void *wapp_mem_allocator_alloc_aligned(const Allocator *allocator, u64 size, u64 alignment) {
-  assert(allocator != NULL && (allocator->alloc_aligned) != NULL);
+  wapp_debug_assert(allocator != NULL && (allocator->alloc_aligned) != NULL, "`allocator` and `allocator->alloc_aligned` should not be 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) {
-  assert(allocator != NULL && (allocator->realloc) != NULL);
+  wapp_debug_assert(allocator != NULL && (allocator->realloc) != NULL, "`allocator` and `allocator->realloc` should not be 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) {
-  assert(allocator != NULL && (allocator->realloc_aligned) != NULL);
+  wapp_debug_assert(allocator != NULL && (allocator->realloc_aligned) != NULL, "`allocator` and `allocator->realloc_aligned` should not be NULL");
   return allocator->realloc_aligned(ptr, old_size, new_size, alignment, allocator->obj);
 }
 

src/primitives/strings/str8/str8.c

@@ -2,18 +2,18 @@
 
 #include "str8.h"
 #include "../../../common/aliases/aliases.h"
+#include "../../../common/assert/assert.h"
 #include "../../mem_allocator/mem_allocator.h"
 #include <stdarg.h>
 #include <stddef.h>
 #include <stdio.h>
 #include <string.h>
 #include <stdbool.h>
-#include <assert.h>
 
 #define STR8_BUF_ALLOC_SIZE(CAPACITY) (sizeof(Str8) + sizeof(c8) * CAPACITY)
 
 Str8 *wapp_str8_alloc_buf(const Allocator *allocator, u64 capacity) {
-  assert(allocator != NULL);
+  wapp_debug_assert(allocator != NULL, "`allocator` should not be NULL");
 
   Str8 *str = wapp_mem_allocator_alloc(allocator, STR8_BUF_ALLOC_SIZE(capacity));
   if (!str) {
@@ -29,7 +29,7 @@ RETURN_STR8:
 }
 
 Str8 *wapp_str8_alloc_cstr(const Allocator *allocator, const char *str) {
-  assert(allocator != NULL && str != NULL);
+  wapp_debug_assert(allocator != NULL && str != NULL, "`allocator` and `str` should not be NULL");
 
   u64 length = strlen(str);
   Str8 *output     = wapp_str8_alloc_buf(allocator, length * 2);
@@ -45,7 +45,7 @@ RETURN_ALLOC_CSTR:
 }
 
 Str8 *wapp_str8_alloc_str8(const Allocator *allocator, Str8RO *str) {
-  assert(allocator != NULL && str != NULL);
+  wapp_debug_assert(allocator != NULL && str != NULL, "`allocator` and `str` should not be NULL");
 
   Str8 *output = wapp_str8_alloc_buf(allocator, str->capacity);
   if (!output) {
@@ -60,7 +60,7 @@ RETURN_ALLOC_STR8:
 }
 
 Str8 *wapp_str8_alloc_substr(const Allocator *allocator, Str8RO *str, u64 start, u64 end) {
-  assert(allocator != NULL && str != NULL);
+  wapp_debug_assert(allocator != NULL && str != NULL, "`allocator` and `str` should not be NULL");
 
   Str8 *output = NULL;
 
@@ -85,7 +85,7 @@ RETURN_ALLOC_SUBSTR:
 }
 
 void wapp_str8_dealloc_buf(const Allocator *allocator, Str8 **str) {
-  assert(allocator != NULL && str != NULL && (*str) != NULL);
+  wapp_debug_assert(allocator != NULL && str != NULL && (*str) != NULL, "Either `allocator` is NULL or `str` is an invalid double pointer");
   wapp_mem_allocator_free(allocator, (void **)str, STR8_BUF_ALLOC_SIZE((*str)->capacity));
 }
 
@@ -148,7 +148,7 @@ Str8 wapp_str8_slice(Str8RO *str, u64 start, u64 end) {
 }
 
 Str8 *wapp_str8_alloc_concat(const Allocator *allocator, Str8 *dst, Str8RO *src) {
-  assert(allocator != NULL && dst != NULL && src != NULL);
+  wapp_debug_assert(allocator != NULL && dst != NULL && src != NULL, "`allocator`, `dst` and `src` should not be NULL");
 
   Str8 *output  = NULL;
   u64 remaining = dst->capacity - dst->size;
@@ -174,7 +174,7 @@ RETURN_STR8_CONCAT:
 }
 
 void wapp_str8_concat_capped(Str8 *dst, Str8RO *src) {
-  assert(dst != NULL && src != NULL);
+  wapp_debug_assert(dst != NULL && src != NULL, "`dst` and `src` should not be NULL");
 
   u64 remaining = dst->capacity - dst->size;
   u64 to_copy   = remaining < src->size ? remaining : src->size;
@@ -184,7 +184,7 @@ void wapp_str8_concat_capped(Str8 *dst, Str8RO *src) {
 }
 
 void wapp_str8_copy_cstr_capped(Str8 *dst, const char *src) {
-  assert(dst != NULL && src != NULL);
+  wapp_debug_assert(dst != NULL && src != NULL, "`dst` and `src` should not be NULL");
 
   u64 length  = strlen(src);
   u64 to_copy = length <= dst->capacity ? length : dst->capacity;
@@ -195,7 +195,7 @@ void wapp_str8_copy_cstr_capped(Str8 *dst, const char *src) {
 }
 
 void wapp_str8_copy_str8_capped(Str8 *dst, Str8RO *src) {
-  assert(dst != NULL && src != NULL);
+  wapp_debug_assert(dst != NULL && src != NULL, "`dst` and `src` should not be NULL");
 
   u64 to_copy = src->size <= dst->capacity ? src->size : dst->capacity;
 
@@ -205,7 +205,7 @@ void wapp_str8_copy_str8_capped(Str8 *dst, Str8RO *src) {
 }
 
 void wapp_str8_copy_to_cstr(char *dst, Str8RO *src, u64 dst_capacity) {
-  assert(dst != NULL && src != NULL);
+  wapp_debug_assert(dst != NULL && src != NULL, "`dst` and `src` should not be NULL");
 
   u64 to_copy = src->size < dst_capacity ? src->size : dst_capacity - 1;
 
@@ -214,7 +214,7 @@ void wapp_str8_copy_to_cstr(char *dst, Str8RO *src, u64 dst_capacity) {
 }
 
 void wapp_str8_format(Str8 *dst, const char *format, ...) {
-  assert(dst != NULL && format != NULL);
+  wapp_debug_assert(dst != NULL && format != NULL, "`dst` and `format` should not be NULL");
 
   va_list args1;
   va_list args2;
@@ -276,7 +276,7 @@ i64 wapp_str8_rfind(Str8RO *str, Str8RO substr) {
 }
 
 Str8List *wapp_str8_split_with_max(const Allocator *allocator, Str8RO *str, Str8RO *delimiter, i64 max_splits) {
-  assert(allocator != NULL && str != NULL && delimiter != NULL);
+  wapp_debug_assert(allocator != NULL && str != NULL && delimiter != NULL, "`allocator`, `str` and `delimiter` should not be NULL");
 
   Str8List *output = wapp_mem_allocator_alloc(allocator, sizeof(Str8List));
 
@@ -329,7 +329,7 @@ RETURN_STR8_SPLIT:
 }
 
 Str8List *wapp_str8_rsplit_with_max(const Allocator *allocator, Str8RO *str, Str8RO *delimiter, i64 max_splits) {
-  assert(allocator != NULL && str != NULL && delimiter != NULL);
+  wapp_debug_assert(allocator != NULL && str != NULL && delimiter != NULL, "`allocator`, `str` and `delimiter` should not be NULL");
 
   Str8List *output = wapp_mem_allocator_alloc(allocator, sizeof(Str8List));
 
@@ -379,7 +379,7 @@ RETURN_STR8_SPLIT:
 }
 
 Str8 *wapp_str8_join(const Allocator *allocator, const Str8List *list, Str8RO *delimiter) {
-  assert(allocator != NULL && list != NULL && delimiter != NULL);
+  wapp_debug_assert(allocator != NULL && list != NULL && delimiter != NULL, "`allocator`, `list` and `delimiter` should not be NULL");
 
   u64 capacity = wapp_str8_list_total_size(list) + (delimiter->size * (list->node_count - 1));
   Str8 *output = wapp_str8_alloc_buf(allocator, capacity * 2);

src/prng/xorshift/xorshift.c

@@ -2,8 +2,8 @@
 
 #include "xorshift.h"
 #include "../../common/aliases/aliases.h"
+#include "../../common/assert/assert.h"
 #include "../../common/platform/platform.h"
-#include <assert.h>
 #include <stdbool.h>
 #include <stdlib.h>
 #include <time.h>
@@ -95,7 +95,7 @@ internal u64 split_mix_64(SplitMix64State *state) {
 internal void seed_os_generator(void) {
     struct timespec ts = {0};
     int result = clock_gettime(CLOCK_MONOTONIC_RAW, &ts);
-    assert(result == 0);
+    wapp_runtime_assert(result == 0, "Invalid seed value");
 
     srand48(ts.tv_nsec);
 }
@@ -107,7 +107,7 @@ internal u64 generate_random_number(void) {
 internal void seed_os_generator(void) {
     struct timespec ts = {0};
     int result = timespec_get(&ts, TIME_UTC);
-    assert(result != 0);
+    wapp_runtime_assert(result != 0, "Invalid seed value");
 
     srand(ts.tv_nsec);
 }
@@ -122,7 +122,7 @@ internal u64 generate_random_number(void) {
 #else
 internal void seed_os_generator(void) {
     time_t result = time(NULL);
-    assert(result != (time_t)(-1));
+    wapp_runtime_assert(result != (time_t)(-1), "Invalid seed value");
 
     srand(result);
 }

src/uuid/uuid.c

@@ -2,11 +2,11 @@
 
 #include "uuid.h"
 #include "../common/aliases/aliases.h"
+#include "../common/assert/assert.h"
 #include "../primitives/strings/str8/str8.h"
 #include "../prng/xorshift/xorshift.h"
 #include <stdbool.h>
 #include <inttypes.h>
-#include <assert.h>
 
 #define UUID_STR_FORMAT ("%.8" PRIx64 "-%.4" PRIx64 "-%.4" PRIx64 "-%.4" PRIx64 "-%.12" PRIx64)
 
@@ -20,7 +20,7 @@ internal UUID4 generate_uuid4(void);
 internal void  uuid4_to_uuid(const UUID4* uuid4, UUID *uuid);
 
 UUID *wapp_uuid_init_uuid4(UUID *uuid) {
-  assert(uuid != NULL);
+  wapp_debug_assert(uuid != NULL, "`uuid` should not be NULL");
 
   UUID4 uuid4 = generate_uuid4();
   uuid4_to_uuid(&uuid4, uuid);