Makefile

@@ -1,4 +1,4 @@
-.PHONY: help full base os prng testing uuid all clean builddir build-test run-test codegen install build-lib ccodegen
+.PHONY: help full base os prng testing uuid all clean builddir build-test run-test install build-lib
 
 # External variables
 CC             = clang
@@ -7,7 +7,6 @@ AR             = ar
 BUILD_TYPE     = Debug
 BUILD_DIR      = libwapp-build/$(PLATFORM)-$(BUILD_TYPE)
 INSTALL_PREFIX = dist
-CODEGEN_INPUT  = ""
 RUNTIME_ASSERT = true
 
 # Internal variables
@@ -95,7 +94,7 @@ ifeq ($(KERNEL), Darwin)
 	ECHO_E = echo
 endif
 
-all: clean builddir codegen run-c-test full run-cc-test
+all: clean builddir run-c-test full run-cc-test
 
 help:
 	@$(ECHO_E) "$(BOLD)$(BLUE)Available build variables:$(RESET)"
@@ -105,7 +104,6 @@ help:
 	@$(ECHO_E) "  $(GREEN)BUILD_TYPE$(RESET)        Build type $(MAGENTA)[Debug | RelWithDebInfo | Release] $(YELLOW)(Default: Debug)$(RESET)."
 	@$(ECHO_E) "  $(GREEN)BUILD_DIR$(RESET)         Directory where build files will be written."
 	@$(ECHO_E) "  $(GREEN)INSTALL_PREFIX$(RESET)    Prefix where library and include files will be installed."
-	@$(ECHO_E) "  $(GREEN)CODEGEN_INPUT$(RESET)     Input file for code generation (See $(CYAN)codegen_custom_data_example.json$(RESET) for an example)."
 	@$(ECHO_E) "  $(GREEN)RUNTIME_ASSERT$(RESET)    Whether runtime asserts are enabled $(MAGENTA)[true | false] $(YELLOW)(Default: true)$(RESET)."
 	@$(ECHO_E) "  $(GREEN)$(RESET)                  $(BOLD)$(BG_RED)DISCLAIMER:$(RESET) Using this flag is not recommended as it disables safety checks"
 	@$(ECHO_E) "  $(GREEN)$(RESET)                  potentially leading to Undefined Behaviour."
@@ -167,10 +165,7 @@ run-cc-test: build-cc-test
 	@export LD_LIBRARY_PATH=$$LD_LIBRARY_PATH:"$(BUILD_DIR)" && "$(TEST_CXX_OUT)"
 	@rm "$(TEST_CXX_OUT)"
 
-codegen:
-	python3 -m codegen -f $(CODEGEN_INPUT)
-
-install: codegen build-lib
+install: build-lib
 	@mkdir -p "$(LIB_INSTALL)"
 	@cp -v "$(LIB_OUT)" "$(LIB_INSTALL)"
 	@mkdir -p "$(INCLUDE_INSTALL)"
@@ -180,6 +175,3 @@ build-lib: builddir
 	$(CC) -c $(CSTD) $(CFLAGS) $(BUILD_FLAGS) $(LIBFLAGS) $(LIB_SRC) -o "$(OBJ_OUT)"
 	$(AR) r "$(LIB_OUT)" "$(OBJ_OUT)"
 	@rm "$(OBJ_OUT)"
-
-ccodegen:
-	$(CC) $(CSTD) $(CFLAGS) $(BUILD_FLAGS) $(LIBFLAGS) -Isrc/os src/os/wapp_os.c ccodegen/*.c -o ccgen

README.md

@@ -1,3 +1,3 @@
 # Wizard Apprentice Standard Library
 
-A base layer for C/C++ projects
+A group of utilities for C/C++ projects

ccodegen/datatypes.c

@@ -1,522 +0,0 @@
-// vim:fileencoding=utf-8:foldmethod=marker
-
-#include "datatypes.h"
-#include "dbl_list.h"
-#include "type_enums.h"
-#include "wapp_core.h"
-
-#define ERR_MSG "Not enough capacity in dst buffer"
-#define CFILE_DISCLAIMER "/**\n" \
-  " * THIS FILE IS AUTOMATICALLY GENERATED. ANY MODIFICATIONS TO IT WILL BE OVERWRITTEN.\n" \
-  " */\n\n"
-
-void cobject_to_string(Str8 *dst, const CObject *object) {
-  wapp_debug_assert(dst != NULL && object != NULL, "`allocator`, `dst` and `object` should not be NULL");
-
-  switch (object->kind) {
-    case COBJECT_CTYPE:
-      ctype_to_string(dst, object->object.c_type);
-      break;
-    case COBJECT_CQUALIFIER:
-      cqualifier_to_string(dst, object->object.c_qualifier);
-      break;
-    case COBJECT_CPOINTERTYPE:
-      cpointertype_to_string(dst, object->object.c_pointertype);
-      break;
-    case COBJECT_CPOINTER:
-      cpointer_to_string(dst, &(object->object.c_pointer));
-      break;
-    case COBJECT_CENUMVAL:
-      cenumval_to_string(dst, &(object->object.c_enumval));
-      break;
-    case COBJECT_CENUM:
-      cenum_to_string(dst, &(object->object.c_enum));
-      break;
-    case COBJECT_CMACRO:
-      cmacro_to_string(dst, &(object->object.c_macro));
-      break;
-    case COBJECT_CSTRUCT:
-      cstruct_to_string(dst, &(object->object.c_struct));
-      break;
-    case COBJECT_CUSERTYPE:
-      cusertype_to_string(dst, &(object->object.c_usertype));
-      break;
-    case COBJECT_CDATATYPE:
-      cdatatype_to_string(dst, &(object->object.c_datatype));
-      break;
-    case COBJECT_CARG:
-      carg_to_string(dst, &(object->object.c_arg));
-      break;
-    case COBJECT_CFUNC:
-      cfunc_to_string(dst, &(object->object.c_func));
-      break;
-    case COBJECT_CINCULDE:
-      cinclude_to_string(dst, &(object->object.c_include));
-      break;
-    case COBJECT_CHEADER:
-      cheader_to_string(dst, &(object->object.c_header));
-      break;
-    case COBJECT_CSOURCE:
-      csource_to_string(dst, &(object->object.c_source));
-      break;
-    default:
-      break;
-  }
-}
-
-void ctype_to_string(Str8 *dst, CType ctype) {
-  wapp_runtime_assert(ctypes[ctype].size <= dst->capacity, ERR_MSG);
-  wapp_str8_copy_str8_capped(dst, &ctypes[ctype]);
-}
-
-void cqualifier_to_string(Str8 *dst, CQualifier cqualifier) {
-  wapp_runtime_assert(cqualifiers[cqualifier].size <= dst->capacity, ERR_MSG);
-  wapp_str8_copy_str8_capped(dst, &cqualifiers[cqualifier]);
-}
-
-void cpointertype_to_string(Str8 *dst, CPointerType cpointertype) {
-  wapp_runtime_assert(cpointertypes[cpointertype].size <= dst->capacity, ERR_MSG);
-  wapp_str8_copy_str8_capped(dst, &cpointertypes[cpointertype]);
-}
-
-void cpointer_to_string(Str8 *dst, const CPointer *cpointer) {
-  wapp_debug_assert(dst != NULL && cpointer != NULL, "`dst` and `cpointer` should not be NULL");
-
-  u64 total_size = cpointertypes[cpointer->type].size + cqualifiers[cpointer->qualifier].size;
-  wapp_runtime_assert(total_size <= dst->capacity, ERR_MSG);
-  wapp_str8_format(dst,
-                   WAPP_STR8_SPEC WAPP_STR8_SPEC,
-                   wapp_str8_varg(cpointertypes[cpointer->type]),
-                   wapp_str8_varg(cqualifiers[cpointer->qualifier]));
-}
-
-void cenumval_to_string(Str8 *dst, const CEnumVal *cenumval) {
-  wapp_debug_assert(dst != NULL && cenumval != NULL, "`dst` and `cenumval` should not be NULL");
-
-  Str8 tmp     = wapp_str8_buf(CCGEN_BUF_TINY);
-  u64 tmp_size = 0;
-  if (cenumval->value != NULL) {
-    wapp_str8_format(&tmp, " = %d", *(cenumval->value));
-    tmp_size = tmp.size;
-  }
-
-  u64 total_size = cenumval->name.size + tmp_size;
-  wapp_runtime_assert(total_size <= dst->capacity, ERR_MSG);
-  wapp_str8_format(dst,
-                   WAPP_STR8_SPEC WAPP_STR8_SPEC,
-                   wapp_str8_varg(cenumval->name),
-                   wapp_str8_varg(tmp));
-}
-
-void cenum_to_string(Str8 *dst, const CEnum *cenum) {
-  wapp_debug_assert(dst != NULL && cenum != NULL, "`dst` and `cenum` should not be NULL");
-
-  Str8 header = wapp_str8_buf(CCGEN_BUF_LARGE);
-  Str8 values = wapp_str8_buf(CCGEN_BUF_MAX);
-  Str8 footer = wapp_str8_buf(CCGEN_BUF_LARGE);
-  Str8 tmp    = wapp_str8_buf(CCGEN_BUF_LARGE);
-
-  if (cenum->add_typedef) {
-    wapp_str8_copy_cstr_capped(&header, "typedef enum {\n");
-    wapp_str8_format(&footer, "} " WAPP_STR8_SPEC ";\n", wapp_str8_varg(cenum->name));
-  } else {
-    wapp_str8_format(&header, "enum " WAPP_STR8_SPEC " {\n", wapp_str8_varg(cenum->name));
-    wapp_str8_copy_cstr_capped(&footer, "};\n");
-  }
-
-  for (u64 i = 0; i < cenum->values.node_count; ++i) {
-    cenumval_to_string(&tmp, wapp_cenumval_list_get(&(cenum->values), i)->item);
-    // Add 4 for extra characters
-    wapp_runtime_assert(tmp.size + 4 <= values.capacity - values.size, ERR_MSG);
-    wapp_str8_concat_capped(&values, &wapp_str8_lit_ro("  "));
-    wapp_str8_concat_capped(&values, &tmp);
-    wapp_str8_concat_capped(&values, &wapp_str8_lit_ro(",\n"));
-  }
-
-  u64 total_size = header.size + values.size + footer.size;
-  wapp_runtime_assert(total_size <= dst->capacity, ERR_MSG);
-  wapp_str8_format(dst,
-                   WAPP_STR8_SPEC WAPP_STR8_SPEC WAPP_STR8_SPEC,
-                   wapp_str8_varg(header),
-                   wapp_str8_varg(values),
-                   wapp_str8_varg(footer));
-}
-
-void cmacro_to_string(Str8 *dst, const CMacro *cmacro) {
-  wapp_debug_assert(dst != NULL && cmacro != NULL, "`dst` and `cmacro` should not be NULL");
-
-  Str8 def       = wapp_str8_lit("#define ");
-  u64 total_size = def.size + cmacro->name.size + cmacro->value.size + 1; // Add 1 for newline
-  wapp_runtime_assert(total_size <= dst->capacity, ERR_MSG);
-  wapp_str8_format(dst,
-                   WAPP_STR8_SPEC WAPP_STR8_SPEC " " WAPP_STR8_SPEC "\n",
-                   wapp_str8_varg(def),
-                   wapp_str8_varg(cmacro->name),
-                   wapp_str8_varg(cmacro->value));
-}
-
-void cstruct_to_string(Str8 *dst, const CStruct *cstruct) {
-  wapp_debug_assert(dst != NULL && cstruct != NULL, "`dst` and `cstruct` should not be NULL");
-
-  Str8 declaration = wapp_str8_buf(CCGEN_BUF_LARGE);
-  Str8 definition  = wapp_str8_buf(CCGEN_BUF_MAX);
-
-  declare_cstruct(&declaration, cstruct);
-  define_cstruct(&definition, cstruct);
-
-  u64 total_size = declaration.size + definition.size;
-  wapp_runtime_assert(total_size <= dst->capacity, ERR_MSG);
-  wapp_str8_format(dst, WAPP_STR8_SPEC WAPP_STR8_SPEC,
-                   wapp_str8_varg(declaration), wapp_str8_varg(definition));
-}
-
-void declare_cstruct(Str8 *dst, const CStruct *cstruct) {
-  wapp_debug_assert(dst != NULL && cstruct != NULL, "`dst` and `cstruct` should not be NULL");
-
-  Str8 tmp = wapp_str8_buf(CCGEN_BUF_MAX);
-  wapp_str8_format(&tmp,
-                   "typedef struct " WAPP_STR8_SPEC " " WAPP_STR8_SPEC ";\n",
-                   wapp_str8_varg(cstruct->name),
-                   wapp_str8_varg(cstruct->typedef_name.size > 0 ? cstruct->typedef_name : cstruct->name));
-
-  wapp_runtime_assert(tmp.size <= dst->capacity, ERR_MSG);
-  wapp_str8_copy_str8_capped(dst, &tmp);
-}
-
-void define_cstruct(Str8 *dst, const CStruct *cstruct) {
-  wapp_debug_assert(dst != NULL && cstruct != NULL, "`dst` and `cstruct` should not be NULL");
-
-  Str8 definition = wapp_str8_buf(CCGEN_BUF_LARGE);
-  Str8 args       = wapp_str8_buf(CCGEN_BUF_MAX);
-  Str8 footer     = wapp_str8_lit_ro("};\n");
-  Str8 tmp        = wapp_str8_buf(CCGEN_BUF_MEDIUM);
-
-  wapp_str8_format(&definition, "struct " WAPP_STR8_SPEC " {\n", wapp_str8_varg(cstruct->name));
-
-  for (u64 i = 0; i < cstruct->args.node_count; ++i) {
-    carg_to_string(&tmp, wapp_carg_list_get(&(cstruct->args), i)->item);
-    // Add 4 for extra characters
-    wapp_runtime_assert(tmp.size + 4 <= args.capacity - args.size, ERR_MSG);
-    wapp_str8_concat_capped(&args, &wapp_str8_lit_ro("  "));
-    wapp_str8_concat_capped(&args, &tmp);
-    wapp_str8_concat_capped(&args, &wapp_str8_lit_ro(";\n"));
-  }
-
-  u64 total_size = definition.size + args.size + footer.size;
-  wapp_runtime_assert(total_size <= dst->capacity, ERR_MSG);
-  wapp_str8_format(dst,
-                   WAPP_STR8_SPEC WAPP_STR8_SPEC WAPP_STR8_SPEC,
-                   wapp_str8_varg(definition),
-                   wapp_str8_varg(args),
-                   wapp_str8_varg(footer));
-}
-
-void cusertype_to_string(Str8 *dst, const CUserType *cusertype) {
-  wapp_debug_assert(dst != NULL && cusertype != NULL, "`dst` and `cusertype` should not be NULL");
-
-  switch (cusertype->kind) {
-    case CUSERTYPE_CENUM:
-      cenum_to_string(dst, &(cusertype->type.c_enum));
-      break;
-    case CUSERTYPE_CSTRUCT:
-      cstruct_to_string(dst, &(cusertype->type.c_struct));
-      break;
-    default:
-      break;
-  }
-}
-
-void cdatatype_to_string(Str8 *dst, const CDataType *cdatatype) {
-  wapp_debug_assert(dst != NULL && cdatatype != NULL, "`dst` and `cdatatype` should not be NULL");
-
-  switch (cdatatype->kind) {
-    case CDATATYPE_CTYPE:
-      ctype_to_string(dst, cdatatype->type.c_type);
-      break;
-    case CDATATYPE_CUSERTYPE:
-      cusertype_to_string(dst, &(cdatatype->type.c_usertype));
-      break;
-    case CDATATYPE_STR:
-      wapp_runtime_assert(cdatatype->type.str.size <= dst->capacity, ERR_MSG);
-      wapp_str8_copy_str8_capped(dst, &(cdatatype->type.str));
-      break;
-    default:
-      break;
-  }
-}
-
-void carg_to_string(Str8 *dst, const CArg *carg) {
-  wapp_debug_assert(dst != NULL && carg != NULL, "`dst` and `carg` should not be NULL");
-
-  Str8 qualifier = wapp_str8_buf(CCGEN_BUF_MEDIUM);
-  Str8 type      = wapp_str8_buf(CCGEN_BUF_LARGE);
-  Str8 pointer   = wapp_str8_buf(CCGEN_BUF_MEDIUM);
-  Str8 array     = wapp_str8_buf(CCGEN_BUF_MEDIUM);
-
-  cqualifier_to_string(&qualifier, carg->qualifier);
-  cdatatype_to_string(&type, &(carg->type));
-  wapp_str8_concat_capped(&type, &wapp_str8_lit_ro(" "));
-  cpointer_to_string(&pointer, &(carg->pointer));
-  if (carg->is_array) { wapp_str8_copy_cstr_capped(&array, "[]"); }
-
-  u64 total_size = qualifier.size + type.size + pointer.size + array.size + carg->name.size;
-  wapp_runtime_assert(total_size <= dst->capacity, ERR_MSG);
-  wapp_str8_format(dst, WAPP_STR8_SPEC WAPP_STR8_SPEC WAPP_STR8_SPEC WAPP_STR8_SPEC WAPP_STR8_SPEC,
-                   wapp_str8_varg(qualifier), wapp_str8_varg(type), wapp_str8_varg(pointer),
-                   wapp_str8_varg(carg->name), wapp_str8_varg(array));
-}
-
-void cfunc_to_string(Str8 *dst, const CFunc *cfunc) {
-  wapp_debug_assert(dst != NULL && cfunc != NULL, "`dst` and `cfunc` should not be NULL");
-
-  Str8 qualifiers = wapp_str8_buf(CCGEN_BUF_LARGE);
-  Str8 args       = wapp_str8_buf(CCGEN_BUF_LARGE);
-  Str8 ret_type   = wapp_str8_buf(CCGEN_BUF_SMALL);
-  Str8 pointer    = wapp_str8_buf(CCGEN_BUF_SMALL);
-  Str8 tmp        = wapp_str8_buf(CCGEN_BUF_MEDIUM);
-  CQualifier *qf  = NULL;
-  CArg *arg       = NULL;
-
-  for (u64 i = 0; i < cfunc->qualifiers.node_count; ++i) {
-    qf = wapp_cqualifier_list_get(&(cfunc->qualifiers), i)->item;
-    if (*qf == CQUALIFIER_NONE) { continue; }
-
-    cqualifier_to_string(&tmp, *qf);
-
-    wapp_runtime_assert(tmp.size + 1 <= qualifiers.capacity - qualifiers.size, ERR_MSG);
-    if (qualifiers.size > 0) { wapp_str8_concat_capped(&qualifiers, &wapp_str8_lit_ro(" ")); }
-
-    wapp_str8_concat_capped(&qualifiers, &tmp);
-  }
-
-  for (u64 i = 0; i < cfunc->args.node_count; ++i) {
-    arg = wapp_carg_list_get(&(cfunc->args), i)->item;
-    carg_to_string(&tmp, arg);
-
-    wapp_runtime_assert(tmp.size + 2 <= args.capacity - args.size, ERR_MSG);
-    wapp_str8_concat_capped(&args, &tmp);
-    if (i + 1 < cfunc->args.node_count) { wapp_str8_concat_capped(&args, &wapp_str8_lit_ro(", ")); }
-  }
-
-  cdatatype_to_string(&ret_type, &(cfunc->ret_type));
-  cpointer_to_string(&pointer, &(cfunc->pointer));
-
-  u64 total_size = cfunc->name.size + qualifiers.size + args.size + ret_type.size + pointer.size + 4;
-  wapp_runtime_assert(total_size <= dst->capacity, ERR_MSG);
-  wapp_str8_format(dst,
-                   WAPP_STR8_SPEC WAPP_STR8_SPEC " " WAPP_STR8_SPEC WAPP_STR8_SPEC "(" WAPP_STR8_SPEC ")",
-                   wapp_str8_varg(qualifiers),
-                   wapp_str8_varg(ret_type),
-                   wapp_str8_varg(pointer),
-                   wapp_str8_varg(cfunc->name),
-                   wapp_str8_varg(args));
-}
-
-void declare_cfunc(Str8 *dst, const CFunc *cfunc) {
-  wapp_debug_assert(dst != NULL && cfunc != NULL, "`dst` and `cfunc` should not be NULL");
-
-  Str8 tmp = wapp_str8_buf(CCGEN_BUF_MAX);
-  cfunc_to_string(&tmp, cfunc);
-
-  wapp_runtime_assert(tmp.size + 2 <= dst->capacity, ERR_MSG);
-  wapp_str8_format(dst, WAPP_STR8_SPEC ";\n", wapp_str8_varg(tmp));
-}
-
-void define_cfunc(Str8 *dst, const CFunc *cfunc) {
-  wapp_debug_assert(dst != NULL && cfunc != NULL, "`dst` and `cfunc` should not be NULL");
-
-  Str8 tmp = wapp_str8_buf(CCGEN_BUF_MAX);
-  cfunc_to_string(&tmp, cfunc);
-
-  wapp_runtime_assert(tmp.size + cfunc->body.size + 8 <= dst->capacity, ERR_MSG);
-  wapp_str8_format(dst, WAPP_STR8_SPEC " {\n" WAPP_STR8_SPEC "\n}\n\n",
-                   wapp_str8_varg(tmp), wapp_str8_varg(cfunc->body));
-}
-
-void cinclude_to_string(Str8 *dst, const CInclude *cinclude) {
-  wapp_debug_assert(dst != NULL && cinclude != NULL, "`dst` and `cinclude` should not be NULL");
-
-  Str8 header_str = wapp_str8_buf(CCGEN_BUF_LARGE);
-  if (!cheaderinclude_to_string(&header_str, &(cinclude->header))) { return; }
-
-  Str8 inc = wapp_str8_lit("#include ");
-  Str8 open_symbol = wapp_str8_buf(CCGEN_BUF_MIN);
-  Str8 close_symbol = wapp_str8_buf(CCGEN_BUF_MIN);
-
-  if (cinclude->is_local) {
-    wapp_str8_concat_capped(&open_symbol, &wapp_str8_lit_ro("\""));
-    wapp_str8_concat_capped(&close_symbol, &wapp_str8_lit_ro("\""));
-    if (cinclude->same_dir) { wapp_str8_concat_capped(&open_symbol, &wapp_str8_lit_ro("./")); }
-  } else {
-    wapp_str8_concat_capped(&open_symbol, &wapp_str8_lit_ro("<"));
-    wapp_str8_concat_capped(&close_symbol, &wapp_str8_lit_ro(">"));
-  }
-
-  u64 total_size = header_str.size + inc.size + open_symbol.size + close_symbol.size;
-  wapp_runtime_assert(total_size <= dst->capacity, ERR_MSG);
-  wapp_str8_format(dst,
-                   WAPP_STR8_SPEC WAPP_STR8_SPEC WAPP_STR8_SPEC WAPP_STR8_SPEC "\n",
-                   wapp_str8_varg(inc),
-                   wapp_str8_varg(open_symbol),
-                   wapp_str8_varg(header_str),
-                   wapp_str8_varg(close_symbol));
-}
-
-void cheader_to_string(Str8 *dst, const CHeader *cheader) {
-  wapp_debug_assert(dst != NULL && cheader != NULL, "`dst` and `cheader` should not be NULL");
-
-  Allocator arena = wapp_mem_arena_allocator_init(MB(64));
-  Str8 *output = wapp_str8_alloc_buf(&arena, KB(32));
-  wapp_runtime_assert(output != NULL, "Failed to allocate buffer");
-
-  Str8 header_guard_name = wapp_str8_buf(CCGEN_BUF_SMALL);
-  Str8 tmp = wapp_str8_buf(CCGEN_BUF_MAX);
-
-  // ADD HEADER GUARD AND START C LINKAGE
-  wapp_str8_to_upper(&header_guard_name, &(cheader->name));
-  wapp_str8_concat_capped(&header_guard_name, &wapp_str8_lit_ro("_H"));
-  wapp_str8_format(&tmp, "#ifndef " WAPP_STR8_SPEC "\n#define " WAPP_STR8_SPEC "\n\n"
-                   "#ifdef WAPP_PLATFORM_CPP\nBEGIN_C_LINKAGE\n#endif // !WAPP_PLATFORM_CPP\n\n",
-                   wapp_str8_varg(header_guard_name), wapp_str8_varg(header_guard_name));
-  wapp_str8_alloc_concat(&arena, output, &tmp);
-
-  for (u64 i = 0; i < cheader->includes.node_count; ++i) {
-    cinclude_to_string(&tmp, wapp_cinclude_list_get(&(cheader->includes), i)->item);
-    wapp_str8_alloc_concat(&arena, output, &tmp);
-  }
-  if (cheader->includes.node_count > 0) { wapp_str8_alloc_concat(&arena, output, &wapp_str8_lit_ro("\n")); }
-
-  for (u64 i = 0; i < cheader->macros.node_count; ++i) {
-    cmacro_to_string(&tmp, wapp_cmacro_list_get(&(cheader->macros), i)->item);
-    wapp_str8_alloc_concat(&arena, output, &tmp);
-  }
-  if (cheader->macros.node_count > 0) { wapp_str8_alloc_concat(&arena, output, &wapp_str8_lit_ro("\n")); }
-
-  if (cheader->cpp_macros.node_count > 0) {
-    wapp_str8_alloc_concat(&arena, output, &wapp_str8_lit_ro("#ifdef WAPP_PLATFORM_CPP\n"));
-
-    for (u64 i = 0; i < cheader->cpp_macros.node_count; ++i) {
-      cmacro_to_string(&tmp, wapp_cmacro_list_get(&(cheader->cpp_macros), i)->item);
-      wapp_str8_alloc_concat(&arena, output, &tmp);
-    }
-
-    wapp_str8_alloc_concat(&arena, output, &wapp_str8_lit_ro("#else\n"));
-
-    for (u64 i = 0; i < cheader->c_macros.node_count; ++i) {
-      cmacro_to_string(&tmp, wapp_cmacro_list_get(&(cheader->c_macros), i)->item);
-      wapp_str8_alloc_concat(&arena, output, &tmp);
-    }
-
-    wapp_str8_alloc_concat(&arena, output, &wapp_str8_lit_ro("#endif // !WAPP_PLATFORM_CPP\n\n"));
-  }
-
-  for (u64 i = 0; i < cheader->decl_types.node_count; ++i) {
-    declare_cstruct(&tmp, wapp_cstruct_list_get(&(cheader->decl_types), i)->item);
-    wapp_str8_alloc_concat(&arena, output, &tmp);
-  }
-  if (cheader->decl_types.node_count > 0) { wapp_str8_alloc_concat(&arena, output, &wapp_str8_lit_ro("\n")); }
-
-  for (u64 i = 0; i < cheader->types.node_count; ++i) {
-    cusertype_to_string(&tmp, wapp_cusertype_list_get(&(cheader->types), i)->item);
-    wapp_str8_concat_capped(&tmp, &wapp_str8_lit_ro("\n"));
-    wapp_str8_alloc_concat(&arena, output, &tmp);
-  }
-
-  for (u64 i = 0; i < cheader->funcs.node_count; ++i) {
-    declare_cfunc(&tmp, wapp_cfunc_list_get(&(cheader->funcs), i)->item);
-    wapp_str8_alloc_concat(&arena, output, &tmp);
-  }
-
-  // END C LINKAGE AND CLOSE HEADER GUARD
-  wapp_str8_format(&tmp, "\n#ifdef WAPP_PLATFORM_CPP\nEND_C_LINKAGE\n#endif // !WAPP_PLATFORM_CPP\n\n"
-                   "#endif // !" WAPP_STR8_SPEC "\n", wapp_str8_varg(header_guard_name));
-  wapp_str8_alloc_concat(&arena, output, &tmp);
-
-  wapp_runtime_assert(output->size <= dst->capacity, ERR_MSG);
-  wapp_str8_copy_str8_capped(dst, output);
-
-  wapp_mem_arena_allocator_destroy(&arena);
-}
-
-void csource_to_string(Str8 *dst, const CSource *csource) {
-  wapp_debug_assert(dst != NULL && csource != NULL, "`dst` and `csource` should not be NULL");
-
-  Allocator arena = wapp_mem_arena_allocator_init(MB(64));
-  Str8 *output = wapp_str8_alloc_buf(&arena, KB(32));
-  Str8 *internal_funcs_def = wapp_str8_alloc_buf(&arena, KB(16));
-  wapp_runtime_assert(output != NULL && internal_funcs_def != NULL, "Failed to allocate buffer");
-
-  Str8 tmp = wapp_str8_buf(CCGEN_BUF_MAX);
-
-  for (u64 i = 0; i < csource->includes.node_count; ++i) {
-    cinclude_to_string(&tmp, wapp_cinclude_list_get(&(csource->includes), i)->item);
-    wapp_str8_alloc_concat(&arena, output, &tmp);
-  }
-  if (csource->includes.node_count > 0) { wapp_str8_alloc_concat(&arena, output, &wapp_str8_lit_ro("\n")); }
-
-  for (u64 i = 0; i < csource->macros.node_count; ++i) {
-    cmacro_to_string(&tmp, wapp_cmacro_list_get(&(csource->macros), i)->item);
-    wapp_str8_alloc_concat(&arena, output, &tmp);
-  }
-  if (csource->macros.node_count > 0) { wapp_str8_alloc_concat(&arena, output, &wapp_str8_lit_ro("\n")); }
-
-  for (u64 i = 0; i < csource->decl_types.node_count; ++i) {
-    declare_cstruct(&tmp, wapp_cstruct_list_get(&(csource->decl_types), i)->item);
-    wapp_str8_alloc_concat(&arena, output, &tmp);
-  }
-  if (csource->decl_types.node_count > 0) { wapp_str8_alloc_concat(&arena, output, &wapp_str8_lit_ro("\n")); }
-
-  for (u64 i = 0; i < csource->types.node_count; ++i) {
-    cusertype_to_string(&tmp, wapp_cusertype_list_get(&(csource->types), i)->item);
-    wapp_str8_concat_capped(&tmp, &wapp_str8_lit_ro("\n"));
-    wapp_str8_alloc_concat(&arena, output, &tmp);
-  }
-
-  Str8RO _wapp_intern = wapp_str8_lit_ro("wapp_intern ");
-  for (u64 i = 0; i < csource->internal_funcs.node_count; ++i) {
-    declare_cfunc(&tmp, wapp_cfunc_list_get(&(csource->internal_funcs), i)->item);
-    wapp_str8_alloc_concat(&arena, output, &_internal);
-    wapp_str8_alloc_concat(&arena, output, &tmp);
-
-    define_cfunc(&tmp, wapp_cfunc_list_get(&(csource->internal_funcs), i)->item);
-    wapp_str8_alloc_concat(&arena, internal_funcs_def, &_internal);
-    wapp_str8_alloc_concat(&arena, internal_funcs_def, &tmp);
-  }
-  if (csource->internal_funcs.node_count > 0) { wapp_str8_alloc_concat(&arena, output, &wapp_str8_lit_ro("\n")); }
-
-  for (u64 i = 0; i < csource->funcs.node_count; ++i) {
-    define_cfunc(&tmp, wapp_cfunc_list_get(&(csource->funcs), i)->item);
-    wapp_str8_alloc_concat(&arena, output, &tmp);
-  }
-
-  wapp_runtime_assert(output->size + internal_funcs_def->size <= dst->capacity, ERR_MSG);
-  wapp_str8_copy_str8_capped(dst, output);
-  wapp_str8_concat_capped(dst, internal_funcs_def);
-
-  wapp_mem_arena_allocator_destroy(&arena);
-}
-
-b8 cheaderinclude_to_string(Str8 *dst, const CHeaderInclude *cheaderinclude) {
-  wapp_debug_assert(dst != NULL && cheaderinclude != NULL, "`dst` and `cheaderinclude` should not be NULL");
-
-  switch (cheaderinclude->kind) {
-    case C_HEADER_INCLUDE_STR:
-      wapp_runtime_assert(cheaderinclude->header.name.size <= dst->capacity, ERR_MSG);
-      wapp_str8_format(dst, WAPP_STR8_SPEC, wapp_str8_varg(cheaderinclude->header.name));
-      return true;
-    case C_HEADER_INCLUDE_HEADER:
-      // Take extension into account
-      wapp_runtime_assert(cheaderinclude->header.header.name.size + 2 <= dst->capacity, ERR_MSG);
-      wapp_str8_format(
-        dst,
-        WAPP_STR8_SPEC ".%s",
-        wapp_str8_varg(cheaderinclude->header.header.name),
-        cheaderinclude->header.header.extension == CFILE_EXT_H ? "h" : "c"
-      );
-      return true;
-    default:
-      return false;
-  }
-
-  return false;
-}

ccodegen/datatypes.h

@@ -1,280 +0,0 @@
-// vim:fileencoding=utf-8:foldmethod=marker
-
-#ifndef DATATYPES_H
-#define DATATYPES_H
-
-#include "wapp_core.h"
-#include "dbl_list.h"
-#include "type_enums.h"
-
-#ifndef CCGEN_BUF_MIN
-#define CCGEN_BUF_MIN 16
-#endif // !CCGEN_BUF_MIN
-
-#ifndef CCGEN_BUF_TINY
-#define CCGEN_BUF_TINY 32
-#endif // !CCGEN_BUF_TINY
-
-#ifndef CCGEN_BUF_SMALL
-#define CCGEN_BUF_SMALL 512
-#endif // !CCGEN_BUF_SMALL
-
-#ifndef CCGEN_BUF_MEDIUM
-#define CCGEN_BUF_MEDIUM 1024
-#endif // !CCGEN_BUF_MEDIUM
-
-#ifndef CCGEN_BUF_LARGE
-#define CCGEN_BUF_LARGE 4096
-#endif // !CCGEN_BUF_LARGE
-
-#ifndef CCGEN_BUF_MAX
-#define CCGEN_BUF_MAX 8192
-#endif // !CCGEN_BUF_MAX
-
-#define CENUM(NAME, VALUES, TYPEDEF) ((CEnum){ .name = (NAME), .values = (VALUES), .add_typedef = (TYPEDEF) })
-#define CSTRUCT(NAME, ARGS, TYPEDEF_NAME_PTR) ((CStruct){ .name = (NAME), .args = (ARGS), .typedef_name = (TYPEDEF_NAME_PTR) })
-
-#define CUSERTYPE_ENUM(ENUM) ((CUserType){ .kind = CUSERTYPE_CENUM, .type.c_enum = ENUM })
-#define CUSERTYPE_STRUCT(STRUCT) ((CUserType){ .kind = CUSERTYPE_CSTRUCT, .type.c_struct = STRUCT })
-
-#define CDATATYPE_CTYPE(VALUE) ((CDataType){ .kind = CDATATYPE_CTYPE, .type.c_type = (VALUE) })
-#define CDATATYPE_USERTYPE(USERTYPE) ((CDataType){ .kind = CDATATYPE_CUSERTYPE, .type.c_usertype = (USERTYPE) })
-#define CDATATYPE_STR(STR) ((CDataType){ .kind = CDATATYPE_STR, .type.str = (STR) })
-
-#define CHEADERINCLUDE_STR(NAME) ((CHeaderInclude){ .kind = C_HEADER_INCLUDE_STR, .header.name = (NAME) })
-#define CHEADERINCLUDE_CHEADER(CHEADER) ((CHeaderInclude){ .kind = C_HEADER_INCLUDE_HEADER, .header.header = (CHEADER) })
-
-#define COBJECT_TYPE(VALUE)                                                    \
-  ((CObject){ .kind = COBJECT_CTYPE, .object.c_type = (VALUE) })
-#define COBJECT_QUALIFIER(VALUE)                                               \
-  ((CObject){ .kind = COBJECT_CQUALIFIER, .object.c_qualifier = (VALUE) })
-#define COBJECT_POINTERTYPE(VALUE)                                             \
-  ((CObject){ .kind = COBJECT_CPOINTERTYPE, .object.c_pointertype = (VALUE) })
-#define COBJECT_POINTER(CPOINTER)                                              \
-  ((CObject){ .kind = COBJECT_CPOINTER, .object.c_pointer = (CPOINTER) })
-#define COBJECT_ENUMVAL(CENUMVAL)                                              \
-  ((CObject){ .kind = COBJECT_CENUMVAL, .object.c_enumval = (CENUMVAL) })
-#define COBJECT_ENUM(ENUM)                                                     \
-  ((CObject){ .kind = COBJECT_CENUM, .object.c_enum = (ENUM) })
-#define COBJECT_MACRO(CMACRO)                                                  \
-  ((CObject){ .kind = COBJECT_CMACRO, .object.c_macro = (CMACRO) })
-#define COBJECT_STRUCT(STRUCT)                                                 \
-  ((CObject){ .kind = COBJECT_CSTRUCT, .object.c_struct = STRUCT })
-#define COBJECT_USERTYPE(USERTYPE)                                             \
-  ((CObject){ .kind = COBJECT_CUSERTYPE, .object.c_usertype = (USERTYPE) })
-#define COBJECT_DATATYPE(DATATYPE)                                             \
-  ((CObject){ .kind = COBJECT_CDATATYPE, .object.c_datatype = (DATATYPE) })
-#define COBJECT_ARG(CARG)                                                      \
-  ((CObject){ .kind = COBJECT_CARG, .object.c_arg = (CARG) })
-#define COBJECT_FUNC(CFUNC)                                                    \
-  ((CObject){ .kind = COBJECT_CFUNC, .object.c_func = (CFUNC) })
-#define COBJECT_INCULDE(CINCLUDE)                                              \
-  ((CObject){ .kind = COBJECT_CINCULDE, .object.c_include = (CINCLUDE) })
-#define COBJECT_HEADER(CHEADER)                                                \
-  ((CObject){ .kind = COBJECT_CHEADER, .object.c_header = (CHEADER) })
-#define COBJECT_SOURCE(CSOURCE)                                                \
-  ((CObject){ .kind = COBJECT_CSOURCE, .object.c_source = (CSOURCE) })
-
-typedef enum {
-  CUSERTYPE_CENUM,
-  CUSERTYPE_CSTRUCT,
-
-  COUNT_CUSERTYPEKIND,
-} CUserTypeKind;
-
-typedef enum {
-  CDATATYPE_CTYPE,
-  CDATATYPE_CUSERTYPE,
-  CDATATYPE_STR,
-
-  COUNT_CDATATYPEKIND,
-} CDataTypeKind;
-
-typedef enum {
-  CFILE_EXT_H,
-  CFILE_EXT_C,
-
-  COUNT_CFILE_EXT,
-} CFileExtension;
-
-typedef enum {
-  C_HEADER_INCLUDE_STR,
-  C_HEADER_INCLUDE_HEADER,
-
-  COUNT_CHEADERINCLUDEKIND,
-} CHeaderIncludeKind;
-
-typedef enum {
-  COBJECT_CTYPE,
-  COBJECT_CQUALIFIER,
-  COBJECT_CPOINTERTYPE,
-  COBJECT_CPOINTER,
-  COBJECT_CENUMVAL,
-  COBJECT_CENUM,
-  COBJECT_CMACRO,
-  COBJECT_CSTRUCT,
-  COBJECT_CUSERTYPE,
-  COBJECT_CDATATYPE,
-  COBJECT_CARG,
-  COBJECT_CFUNC,
-  COBJECT_CINCULDE,
-  COBJECT_CHEADER,
-  COBJECT_CSOURCE,
-
-  COUNT_COBJECTKIND,
-} CObjectKind;
-
-typedef struct cpointer        CPointer;
-typedef struct cenumval        CEnumVal;
-typedef struct cenum           CEnum;
-typedef struct cmacro          CMacro;
-typedef struct cstruct         CStruct;
-typedef struct cusertype       CUserType;
-typedef struct cdatatype       CDataType;
-typedef struct carg            CArg;
-typedef struct cfunc           CFunc;
-typedef struct cheader_include CHeaderInclude;
-typedef struct cinclude        CInclude;
-typedef struct cheader         CHeader;
-typedef struct csource         CSource;
-typedef struct cobject         CObject;
-
-struct cpointer {
-  CPointerType type;
-  CQualifier qualifier;
-};
-
-struct cenumval {
-  Str8 name;
-  i32 *value;
-};
-
-struct cenum {
-  Str8 name;
-  CEnumValList values;
-  b8 add_typedef;
-};
-
-struct cmacro {
-  Str8 name;
-  Str8 value;
-};
-
-struct cstruct {
-  Str8 name;
-  CArgList args;
-  Str8 typedef_name;
-};
-
-struct cusertype {
-  CUserTypeKind kind;
-  union {
-    CEnum c_enum;
-    CStruct c_struct;
-  } type;
-};
-
-struct cdatatype {
-  CDataTypeKind kind;
-  union {
-    CType c_type;
-    CUserType c_usertype;
-    Str8 str;
-  } type;
-};
-
-struct carg {
-  Str8 name;
-  CDataType type;
-  CPointer pointer;
-  CQualifier qualifier;
-  b8 is_array;
-};
-
-struct cfunc {
-  Str8 name;
-  CDataType ret_type;
-  CArgList args;
-  Str8 body;
-  CPointer pointer;
-  CQualifierList qualifiers;
-};
-
-#define CFILE_ARGS          \
-  Str8 name;                \
-  CFileExtension extension; \
-  CIncludeList includes;    \
-  CUserTypeList types;      \
-  CFuncList funcs;          \
-  CStructList decl_types;   \
-  CMacroList macros;        \
-  CMacroList c_macros;      \
-  CMacroList cpp_macros     \
-
-struct cheader {
-  CFILE_ARGS;
-};
-
-struct csource {
-  CFILE_ARGS;
-  CFuncList internal_funcs;
-};
-
-struct cheader_include {
-  CHeaderIncludeKind kind;
-  union {
-    Str8 name;
-    CHeader header;
-  } header;
-};
-
-struct cinclude {
-  CHeaderInclude header;
-  b8 is_local;
-  b8 same_dir;
-};
-
-struct cobject {
-  CObjectKind kind;
-  union {
-    CType c_type;
-    CQualifier c_qualifier;
-    CPointerType c_pointertype;
-    CPointer c_pointer;
-    CEnumVal c_enumval;
-    CEnum c_enum;
-    CMacro c_macro;
-    CStruct c_struct;
-    CUserType c_usertype;
-    CDataType c_datatype;
-    CArg c_arg;
-    CFunc c_func;
-    CInclude c_include;
-    CHeader c_header;
-    CSource c_source;
-  } object;
-};
-
-void cobject_to_string(Str8 *dst, const CObject *object);
-void ctype_to_string(Str8 *dst, CType ctype);
-void cqualifier_to_string(Str8 *dst, CQualifier cqualifier);
-void cpointertype_to_string(Str8 *dst, CPointerType cpointertype);
-void cpointer_to_string(Str8 *dst, const CPointer *cpointer);
-void cenumval_to_string(Str8 *dst, const CEnumVal *cenumval);
-void cenum_to_string(Str8 *dst, const CEnum *cenum);
-void cmacro_to_string(Str8 *dst, const CMacro *cmacro);
-void cstruct_to_string(Str8 *dst, const CStruct *cstruct);
-void declare_cstruct(Str8 *dst, const CStruct *cstruct);
-void define_cstruct(Str8 *dst, const CStruct *cstruct);
-void cusertype_to_string(Str8 *dst, const CUserType *cusertype);
-void cdatatype_to_string(Str8 *dst, const CDataType *cdatatype);
-void carg_to_string(Str8 *dst, const CArg *carg);
-void cfunc_to_string(Str8 *dst, const CFunc *cfunc);
-void declare_cfunc(Str8 *dst, const CFunc *cfunc);
-void define_cfunc(Str8 *dst, const CFunc *cfunc);
-void cinclude_to_string(Str8 *dst, const CInclude *cinclude);
-void cheader_to_string(Str8 *dst, const CHeader *cheader);
-void csource_to_string(Str8 *dst, const CSource *csource);
-b8 cheaderinclude_to_string(Str8 *dst, const CHeaderInclude *cheaderinclude);
-
-#endif // !DATATYPES_H

ccodegen/dbl_list.h

@@ -1,222 +0,0 @@
-// vim:fileencoding=utf-8:foldmethod=marker
-
-#ifndef CCGEN_DBL_LIST_H
-#define CCGEN_DBL_LIST_H
-
-#include "wapp_core.h"
-#include "type_enums.h"
-
-#ifdef WAPP_PLATFORM_CPP
-BEGIN_C_LINKAGE
-#endif // !WAPP_PLATFORM_CPP
-
-#ifdef WAPP_PLATFORM_CPP
-#define wapp_cenumval_list_node(ITEM_PTR) CEnumValNode{ITEM_PTR, nullptr, nullptr}
-#define wapp_carg_list_node(ITEM_PTR) CArgNode{ITEM_PTR, nullptr, nullptr}
-#define wapp_cqualifier_list_node(ITEM_PTR) CQualifierNode{ITEM_PTR, nullptr, nullptr}
-#define wapp_cinclude_list_node(ITEM_PTR) CIncludeNode{ITEM_PTR, nullptr, nullptr}
-#define wapp_cusertype_list_node(ITEM_PTR) CUserTypeNode{ITEM_PTR, nullptr, nullptr}
-#define wapp_cfunc_list_node(ITEM_PTR) CFuncNode{ITEM_PTR, nullptr, nullptr}
-#define wapp_cstruct_list_node(ITEM_PTR) CStructNode{ITEM_PTR, nullptr, nullptr}
-#define wapp_cmacro_list_node(ITEM_PTR) CMacroNode{ITEM_PTR, nullptr, nullptr}
-#else
-#define wapp_cenumval_list_node(ITEM_PTR) ((CEnumValNode){.item = ITEM_PTR})
-#define wapp_carg_list_node(ITEM_PTR) ((CArgNode){.item = ITEM_PTR})
-#define wapp_cqualifier_list_node(ITEM_PTR) ((CQualifierNode){.item = ITEM_PTR})
-#define wapp_cinclude_list_node(ITEM_PTR) ((CIncludeNode){.item = ITEM_PTR})
-#define wapp_cusertype_list_node(ITEM_PTR) ((CUserTypeNode){.item = ITEM_PTR})
-#define wapp_cfunc_list_node(ITEM_PTR) ((CFuncNode){.item = ITEM_PTR})
-#define wapp_cstruct_list_node(ITEM_PTR) ((CStructNode){.item = ITEM_PTR})
-#define wapp_cmacro_list_node(ITEM_PTR) ((CMacroNode){.item = ITEM_PTR})
-#endif // !WAPP_PLATFORM_CPP
-
-typedef struct cenumval CEnumVal;
-typedef struct carg CArg;
-typedef struct cinclude CInclude;
-typedef struct cusertype CUserType;
-typedef struct cfunc CFunc;
-typedef struct cstruct CStruct;
-typedef struct cmacro CMacro;
-
-typedef struct CEnumValNode CEnumValNode;
-struct CEnumValNode {
-  CEnumVal *item;
-  CEnumValNode *prev;
-  CEnumValNode *next;
-};
-
-typedef struct CEnumValList CEnumValList;
-struct CEnumValList {
-  CEnumValNode *first;
-  CEnumValNode *last;
-  u64 node_count;
-};
-
-typedef struct CArgNode CArgNode;
-struct CArgNode {
-  CArg *item;
-  CArgNode *prev;
-  CArgNode *next;
-};
-
-typedef struct CArgList CArgList;
-struct CArgList {
-  CArgNode *first;
-  CArgNode *last;
-  u64 node_count;
-};
-
-typedef struct CQualifierNode CQualifierNode;
-struct CQualifierNode {
-  CQualifier *item;
-  CQualifierNode *prev;
-  CQualifierNode *next;
-};
-
-typedef struct CQualifierList CQualifierList;
-struct CQualifierList {
-  CQualifierNode *first;
-  CQualifierNode *last;
-  u64 node_count;
-};
-
-typedef struct CIncludeNode CIncludeNode;
-struct CIncludeNode {
-  CInclude *item;
-  CIncludeNode *prev;
-  CIncludeNode *next;
-};
-
-typedef struct CIncludeList CIncludeList;
-struct CIncludeList {
-  CIncludeNode *first;
-  CIncludeNode *last;
-  u64 node_count;
-};
-
-typedef struct CUserTypeNode CUserTypeNode;
-struct CUserTypeNode {
-  CUserType *item;
-  CUserTypeNode *prev;
-  CUserTypeNode *next;
-};
-
-typedef struct CUserTypeList CUserTypeList;
-struct CUserTypeList {
-  CUserTypeNode *first;
-  CUserTypeNode *last;
-  u64 node_count;
-};
-
-typedef struct CFuncNode CFuncNode;
-struct CFuncNode {
-  CFunc *item;
-  CFuncNode *prev;
-  CFuncNode *next;
-};
-
-typedef struct CFuncList CFuncList;
-struct CFuncList {
-  CFuncNode *first;
-  CFuncNode *last;
-  u64 node_count;
-};
-
-typedef struct CStructNode CStructNode;
-struct CStructNode {
-  CStruct *item;
-  CStructNode *prev;
-  CStructNode *next;
-};
-
-typedef struct CStructList CStructList;
-struct CStructList {
-  CStructNode *first;
-  CStructNode *last;
-  u64 node_count;
-};
-
-typedef struct CMacroNode CMacroNode;
-struct CMacroNode {
-  CMacro *item;
-  CMacroNode *prev;
-  CMacroNode *next;
-};
-
-typedef struct CMacroList CMacroList;
-struct CMacroList {
-  CMacroNode *first;
-  CMacroNode *last;
-  u64 node_count;
-};
-
-CEnumValNode *wapp_cenumval_list_get(const CEnumValList *list, u64 index);
-void wapp_cenumval_list_push_front(CEnumValList *list, CEnumValNode *node);
-void wapp_cenumval_list_push_back(CEnumValList *list, CEnumValNode *node);
-void wapp_cenumval_list_insert(CEnumValList *list, CEnumValNode *node, u64 index);
-CEnumValNode *wapp_cenumval_list_pop_front(CEnumValList *list);
-CEnumValNode *wapp_cenumval_list_pop_back(CEnumValList *list);
-CEnumValNode *wapp_cenumval_list_remove(CEnumValList *list, u64 index);
-void wapp_cenumval_list_empty(CEnumValList *list);
-CArgNode *wapp_carg_list_get(const CArgList *list, u64 index);
-void wapp_carg_list_push_front(CArgList *list, CArgNode *node);
-void wapp_carg_list_push_back(CArgList *list, CArgNode *node);
-void wapp_carg_list_insert(CArgList *list, CArgNode *node, u64 index);
-CArgNode *wapp_carg_list_pop_front(CArgList *list);
-CArgNode *wapp_carg_list_pop_back(CArgList *list);
-CArgNode *wapp_carg_list_remove(CArgList *list, u64 index);
-void wapp_carg_list_empty(CArgList *list);
-CQualifierNode *wapp_cqualifier_list_get(const CQualifierList *list, u64 index);
-void wapp_cqualifier_list_push_front(CQualifierList *list, CQualifierNode *node);
-void wapp_cqualifier_list_push_back(CQualifierList *list, CQualifierNode *node);
-void wapp_cqualifier_list_insert(CQualifierList *list, CQualifierNode *node, u64 index);
-CQualifierNode *wapp_cqualifier_list_pop_front(CQualifierList *list);
-CQualifierNode *wapp_cqualifier_list_pop_back(CQualifierList *list);
-CQualifierNode *wapp_cqualifier_list_remove(CQualifierList *list, u64 index);
-void wapp_cqualifier_list_empty(CQualifierList *list);
-CIncludeNode *wapp_cinclude_list_get(const CIncludeList *list, u64 index);
-void wapp_cinclude_list_push_front(CIncludeList *list, CIncludeNode *node);
-void wapp_cinclude_list_push_back(CIncludeList *list, CIncludeNode *node);
-void wapp_cinclude_list_insert(CIncludeList *list, CIncludeNode *node, u64 index);
-CIncludeNode *wapp_cinclude_list_pop_front(CIncludeList *list);
-CIncludeNode *wapp_cinclude_list_pop_back(CIncludeList *list);
-CIncludeNode *wapp_cinclude_list_remove(CIncludeList *list, u64 index);
-void wapp_cinclude_list_empty(CIncludeList *list);
-CUserTypeNode *wapp_cusertype_list_get(const CUserTypeList *list, u64 index);
-void wapp_cusertype_list_push_front(CUserTypeList *list, CUserTypeNode *node);
-void wapp_cusertype_list_push_back(CUserTypeList *list, CUserTypeNode *node);
-void wapp_cusertype_list_insert(CUserTypeList *list, CUserTypeNode *node, u64 index);
-CUserTypeNode *wapp_cusertype_list_pop_front(CUserTypeList *list);
-CUserTypeNode *wapp_cusertype_list_pop_back(CUserTypeList *list);
-CUserTypeNode *wapp_cusertype_list_remove(CUserTypeList *list, u64 index);
-void wapp_cusertype_list_empty(CUserTypeList *list);
-CFuncNode *wapp_cfunc_list_get(const CFuncList *list, u64 index);
-void wapp_cfunc_list_push_front(CFuncList *list, CFuncNode *node);
-void wapp_cfunc_list_push_back(CFuncList *list, CFuncNode *node);
-void wapp_cfunc_list_insert(CFuncList *list, CFuncNode *node, u64 index);
-CFuncNode *wapp_cfunc_list_pop_front(CFuncList *list);
-CFuncNode *wapp_cfunc_list_pop_back(CFuncList *list);
-CFuncNode *wapp_cfunc_list_remove(CFuncList *list, u64 index);
-void wapp_cfunc_list_empty(CFuncList *list);
-CStructNode *wapp_cstruct_list_get(const CStructList *list, u64 index);
-void wapp_cstruct_list_push_front(CStructList *list, CStructNode *node);
-void wapp_cstruct_list_push_back(CStructList *list, CStructNode *node);
-void wapp_cstruct_list_insert(CStructList *list, CStructNode *node, u64 index);
-CStructNode *wapp_cstruct_list_pop_front(CStructList *list);
-CStructNode *wapp_cstruct_list_pop_back(CStructList *list);
-CStructNode *wapp_cstruct_list_remove(CStructList *list, u64 index);
-void wapp_cstruct_list_empty(CStructList *list);
-CMacroNode *wapp_cmacro_list_get(const CMacroList *list, u64 index);
-void wapp_cmacro_list_push_front(CMacroList *list, CMacroNode *node);
-void wapp_cmacro_list_push_back(CMacroList *list, CMacroNode *node);
-void wapp_cmacro_list_insert(CMacroList *list, CMacroNode *node, u64 index);
-CMacroNode *wapp_cmacro_list_pop_front(CMacroList *list);
-CMacroNode *wapp_cmacro_list_pop_back(CMacroList *list);
-CMacroNode *wapp_cmacro_list_remove(CMacroList *list, u64 index);
-void wapp_cmacro_list_empty(CMacroList *list);
-
-#ifdef WAPP_PLATFORM_CPP
-END_C_LINKAGE
-#endif // !WAPP_PLATFORM_CPP
-
-#endif // !DBL_LIST_H

ccodegen/main.c

@@ -1,10 +0,0 @@
-// vim:fileencoding=utf-8:foldmethod=marker
-
-#include "datatypes.h"
-#include "type_enums.h"
-#include "wapp_core.h"
-#include <stdio.h>
-
-int main(void) {
-  return 0;
-}

ccodegen/type_enums.h

@@ -1,84 +0,0 @@
-// vim:fileencoding=utf-8:foldmethod=marker
-
-#ifndef TYPE_ENUMS_H
-#define TYPE_ENUMS_H
-
-#include "wapp_core.h"
-
-typedef enum {
-  CTYPE_VOID,
-  CTYPE_B8,
-  CTYPE_CHAR,
-  CTYPE_C8,
-  CTYPE_C16,
-  CTYPE_C32,
-  CTYPE_I8,
-  CTYPE_I16,
-  CTYPE_I32,
-  CTYPE_I64,
-  CTYPE_U8,
-  CTYPE_U16,
-  CTYPE_U32,
-  CTYPE_U64,
-  CTYPE_F32,
-  CTYPE_F64,
-  CTYPE_F128,
-  CTYPE_IPTR,
-  CTYPE_UPTR,
-
-  COUNT_CTYPE,
-} CType;
-wapp_intern Str8RO ctypes[COUNT_CTYPE] = {
-  [CTYPE_VOID] = wapp_str8_lit_ro("void"),
-  [CTYPE_B8]   = wapp_str8_lit_ro("b8"),
-  [CTYPE_CHAR] = wapp_str8_lit_ro("char"),
-  [CTYPE_C8]   = wapp_str8_lit_ro("c8"),
-  [CTYPE_C16]  = wapp_str8_lit_ro("c16"),
-  [CTYPE_C32]  = wapp_str8_lit_ro("c32"),
-  [CTYPE_I8]   = wapp_str8_lit_ro("i8"),
-  [CTYPE_I16]  = wapp_str8_lit_ro("i16"),
-  [CTYPE_I32]  = wapp_str8_lit_ro("i32"),
-  [CTYPE_I64]  = wapp_str8_lit_ro("i64"),
-  [CTYPE_U8]   = wapp_str8_lit_ro("u8"),
-  [CTYPE_U16]  = wapp_str8_lit_ro("u16"),
-  [CTYPE_U32]  = wapp_str8_lit_ro("u32"),
-  [CTYPE_U64]  = wapp_str8_lit_ro("u64"),
-  [CTYPE_F32]  = wapp_str8_lit_ro("f32"),
-  [CTYPE_F64]  = wapp_str8_lit_ro("f64"),
-  [CTYPE_F128] = wapp_str8_lit_ro("f128"),
-  [CTYPE_IPTR] = wapp_str8_lit_ro("iptr"),
-  [CTYPE_UPTR] = wapp_str8_lit_ro("uptr"),
-};
-
-typedef enum {
-  CQUALIFIER_NONE,
-  CQUALIFIER_CONST,
-  CQUALIFIER_EXTERNAL,
-  CQUALIFIER_INTERNAL,
-  CQUALIFIER_PERSISTENT,
-
-  COUNT_CQUALIFIER,
-} CQualifier;
-wapp_intern Str8RO cqualifiers[COUNT_CQUALIFIER] = {
-  [CQUALIFIER_NONE]       = wapp_str8_lit_ro(""),
-  [CQUALIFIER_CONST]      = wapp_str8_lit_ro("const "),
-  [CQUALIFIER_EXTERNAL]   = wapp_str8_lit_ro("wapp_extern "),
-  [CQUALIFIER_INTERNAL]   = wapp_str8_lit_ro("wapp_intern "),
-  [CQUALIFIER_PERSISTENT] = wapp_str8_lit_ro("wapp_persist "),
-};
-
-
-typedef enum {
-  CPOINTERTYPE_NONE,
-  CPOINTERTYPE_SINGLE,
-  CPOINTERTYPE_DOUBLE,
-
-  COUNT_CPOINTERTYPE,
-} CPointerType;
-wapp_intern Str8RO cpointertypes[COUNT_CPOINTERTYPE] = {
-  [CPOINTERTYPE_NONE]   = wapp_str8_lit_ro(""),
-  [CPOINTERTYPE_SINGLE] = wapp_str8_lit_ro("*"),
-  [CPOINTERTYPE_DOUBLE] = wapp_str8_lit_ro("**"),
-};
-
-#endif // !TYPE_ENUMS_H

codegen/__main__.py

@@ -1,47 +0,0 @@
-import json
-from typing import Dict
-from pathlib import Path
-from codegen.datatypes import CDataType, CStruct
-from codegen.constants import WAPP_REPO_ROOT, DBL_LIST_DATA
-from codegen.dbl_list.make_dbl_list import DblListData, make_dbl_list
-
-
-def main(types_file: Path | None):
-    dbl_list_datatypes: Dict[CDataType, DblListData] = {}
-
-    if types_file is not None and types_file.is_file() and "json" in types_file.suffix.lower():
-        with types_file.open("r") as infile:
-            datatypes = json.load(infile)
-            dbl_list_data = datatypes.get(DBL_LIST_DATA)
-
-            if dbl_list_data is not None and isinstance(dbl_list_data, dict):
-                dbl_list_datatypes = {k: DblListData.from_dict(v) for k, v in dbl_list_data.items()}
-
-    make_dbl_list(dbl_list_datatypes)
-
-    # Save example types file
-    custom_struct = CStruct(name="custom_type", cargs=[], typedef_name="CustomType")
-    example = {
-        DBL_LIST_DATA: {
-            "CustomType": DblListData(
-                node_typename="CustomTypeNode",
-                list_typename="CustomTypeList",
-                hdr_decl_types=[custom_struct],
-            ).to_dict()
-        },
-    }
-
-    example_file = WAPP_REPO_ROOT / "codegen_custom_data_example.json"
-    with example_file.open("w") as outfile:
-        json.dump(example, outfile, indent=2)
-
-
-if __name__ == "__main__":
-    from argparse import ArgumentParser
-
-    parser = ArgumentParser()
-    parser.add_argument("-f", "--types-file", type=Path, help="JSON file containing custom types for codegen")
-
-    args = parser.parse_args()
-
-    main(args.types_file)

codegen/constants.py

@@ -1,9 +0,0 @@
-from pathlib import Path
-
-# Paths
-PACKAGE_DIR = Path(__file__).parent.resolve()
-WAPP_REPO_ROOT = PACKAGE_DIR.parent
-WAPP_SRC_ROOT = WAPP_REPO_ROOT / "src"
-
-# Dictionary Keys
-DBL_LIST_DATA = "dbl_list_data"

codegen/datatypes.py

@@ -1,503 +0,0 @@
-from enum import Enum
-from pathlib import Path
-from typing import Optional, Union, List, Dict, Type, Any, TypeVar, cast
-from dataclasses import dataclass, asdict, field, fields
-
-from codegen.constants import WAPP_SRC_ROOT
-from codegen.utils import convert_to_relative
-
-E = TypeVar("E", bound="Enum")
-S = TypeVar("S", bound="SerialisableDataclass")
-F = TypeVar("F", bound="CFile")
-
-@dataclass
-class SerialisableDataclass:
-    def to_dict(self) -> Dict[str, Any]:
-        d = asdict(self)
-        for f in fields(self):
-            member = getattr(self, f.name)
-
-            if isinstance(member, list):
-                d[f.name] = [self.__serialise_member(i) for i in member]
-            else:
-                d[f.name] = self.__serialise_member(member)
-
-        return d
-
-    def __serialise_member(self, member: Any) -> Any:
-        if isinstance(member, Enum):
-            return member.value
-        elif isinstance(member, SerialisableDataclass):
-            return member.to_dict()
-
-        return member
-
-    @staticmethod
-    def to_enum_value(value: Any, _type: Type[E]) -> "E":
-        if isinstance(value, _type):
-            return value
-
-        return _type(value)
-
-    @staticmethod
-    def to_c_usertype(value: dict[str, Any]) -> "CUserType":
-        try:
-            output = CStruct.from_dict(value)
-        except TypeError:
-            output = CEnum.from_dict(value)
-
-        return output
-
-    @staticmethod
-    def to_cdatatype(value: Any) -> "CDataType":
-        if isinstance(value, dict):
-            output = SerialisableDataclass.to_c_usertype(value)
-        else:
-            try:
-                output = CType(value)
-            except ValueError:
-                output = value
-
-        return output
-
-    @classmethod
-    def from_dict(cls: Type[S], d: Dict[str, Any]) -> "S":
-        return cls(**d)
-
-
-class CType(Enum):
-    VOID = "void"
-    BOOL = "b8"
-    CHAR = "char"
-    C8   = "c8"
-    C16  = "c16"
-    C32  = "c32"
-    I8   = "i8"
-    I16  = "i16"
-    I32  = "i32"
-    I64  = "i64"
-    U8   = "u8"
-    U16  = "u16"
-    U32  = "u32"
-    U64  = "u64"
-    F32  = "f32"
-    F64  = "f64"
-    F128 = "f128"
-    IPTR = "iptr"
-    UPTR = "uptr"
-
-    def __str__(self) -> str:
-        return self.value
-
-
-class CQualifier(Enum):
-    NONE       = ""
-    CONST      = "const "
-    EXTERNAL   = "wapp_extern "
-    INTERNAL   = "wapp_intern "
-    PERSISTENT = "wapp_persist "
-
-    def __str__(self) -> str:
-        return self.value
-
-
-class CPointerType(Enum):
-    NONE   = ""
-    SINGLE = "*"
-    DOUBLE = "**"
-
-    def __str__(self) -> str:
-        return self.value
-
-
-@dataclass
-class CPointer(SerialisableDataclass):
-    _type: CPointerType = CPointerType.NONE
-    qualifier: CQualifier = CQualifier.NONE
-
-    def __str__(self) -> str:
-        return str(self._type) + str(self.qualifier)
-
-    @classmethod
-    def from_dict(cls: Type["CPointer"], d: Dict[str, Any]) -> "CPointer":
-        ptr = CPointer(**d)
-        ptr._type = CPointer.to_enum_value(ptr._type, CPointerType)
-        ptr.qualifier = CPointer.to_enum_value(ptr.qualifier, CQualifier)
-        return ptr
-
-
-@dataclass
-class CEnumVal(SerialisableDataclass):
-    name: str
-    value: Optional[int] = None
-
-    def __str__(self) -> str:
-        return self.name + "" if self.value is None else f" = {self.value}"
-
-
-@dataclass
-class CEnum(SerialisableDataclass):
-    name: str
-    values: List[CEnumVal]
-    typedef: bool = False
-
-    def __str__(self) -> str:
-        if self.typedef:
-            header = "typedef enum {\n"
-            footer = f"}} {self.name};\n"
-        else:
-            header = f"enum {self.name} {{\n"
-            footer = "};\n"
-
-        values = ""
-        for value in self.values:
-            values += f"  {str(value)},\n"
-
-        return header + values + footer
-
-    @classmethod
-    def from_dict(cls: Type["CEnum"], d: Dict[str, Any]) -> "CEnum":
-        e = CEnum(**d)
-        e.values = [CEnumVal.from_dict(v) for v in e.values if isinstance(v, dict)]
-        return e
-
-
-@dataclass
-class CMacro(SerialisableDataclass):
-    name: str
-    value: str
-
-    def __str__(self) -> str:
-        return f"#define {self.name} {self.value}\n"
-
-
-@dataclass
-class CStruct(SerialisableDataclass):
-    name: str
-    cargs: List["CArg"]
-    typedef_name: Optional[str] = None
-
-    def __str__(self) -> str:
-        return self.declare() + self.define()
-
-    def declare(self) -> str:
-        declaration = f"typedef struct {self.name} {self.typedef_name if self.typedef_name is not None else self.name};\n"
-        return declaration
-
-    def define(self):
-        definition = f"struct {self.name} {{\n"
-        args = ""
-        for arg in self.cargs:
-            args += f"  {str(arg)};\n"
-        footer = "};\n"
-
-        return definition + args + footer;
-
-    @classmethod
-    def from_dict(cls: Type["CStruct"], d: Dict[str, Any]) -> "CStruct":
-        s = CStruct(**d)
-        s.cargs = [CArg.from_dict(v) for v in s.cargs if isinstance(v, dict)]
-        return s
-
-
-CUserType = Union[CStruct, CEnum]
-CDataType = Union[CType, CUserType, str]
-
-
-@dataclass
-class CArg(SerialisableDataclass):
-    name: str
-    _type: CDataType
-    array: bool = False
-    pointer: CPointer = field(default_factory=CPointer)
-    qualifier: CQualifier = CQualifier.NONE
-
-    def __str__(self) -> str:
-        qualifier = str(self.qualifier)
-        _type = get_datatype_string(self._type) + " "
-        pointer = str(self.pointer)
-        array = "[]" if self.array else ""
-
-        return qualifier + _type + pointer + self.name + array
-
-    @classmethod
-    def from_dict(cls: Type["CArg"], d: Dict[str, Any]) -> "CArg":
-        arg = CArg(**d)
-        arg._type = CArg.to_cdatatype(arg._type)
-
-        if isinstance(arg.pointer, dict):
-            arg.pointer = CPointer.from_dict(arg.pointer)
-
-        arg.qualifier = CArg.to_enum_value(arg.qualifier, CQualifier)
-
-        return arg
-
-
-@dataclass
-class CFunc(SerialisableDataclass):
-    name: str
-    ret_type: CDataType
-    args: List[CArg]
-    body: str
-    pointer: CPointer = field(default_factory=CPointer)
-    qualifiers: List[CQualifier] = field(default_factory=list)
-
-    def __str__(self) -> str:
-        qualifiers = ""
-        for qualifier in self.qualifiers:
-            if qualifier == CQualifier.NONE:
-                continue
-            if len(qualifiers) > 0:
-                qualifiers += " "
-            qualifiers += f"{str(qualifier)}"
-
-        args = ""
-        for i, arg in enumerate(self.args):
-            args += f"{str(arg)}"
-            if i + 1 < len(self.args):
-                args += ", "
-
-        return qualifiers + get_datatype_string(self.ret_type) + " " + str(self.pointer) + self.name + f"({args})"
-
-    def declare(self) -> str:
-        return f"{str(self)};\n"
-
-    def define(self) -> str:
-        return f"{str(self)} {{\n{self.body}\n}}\n\n"
-
-    @classmethod
-    def from_dict(cls: Type["CFunc"], d: Dict[str, Any]) -> "CFunc":
-        f = CFunc(**d)
-        f.ret_type = CFunc.to_cdatatype(f.ret_type)
-        f.args = [CArg.from_dict(v) for v in f.args if isinstance(v, dict)]
-        f.qualifiers = [CFunc.to_enum_value(v, CQualifier) for v in f.qualifiers]
-
-        if isinstance(f.pointer, dict):
-            f.pointer = CPointer.from_dict(f.pointer)
-
-        return f
-
-
-@dataclass
-class CInclude(SerialisableDataclass):
-    header: Union[str, "CHeader"]
-    local: bool = False
-    same_dir: bool = False
-
-    def __str__(self) -> str:
-        if isinstance(self.header, CHeader):
-            name = f"{self.header.name}.{self.header.extension}"
-        else:
-            name = self.header
-
-        if self.local:
-            open_symbol = '"'
-            close_symbol = '"'
-
-            if self.same_dir:
-                name = f"./{name}"
-        else:
-            open_symbol = '<'
-            close_symbol = '>'
-        
-        return f"#include {open_symbol}{name}{close_symbol}\n"
-
-    @classmethod
-    def from_dict(cls: Type["CInclude"], d: Dict[str, Any]) -> "CInclude":
-        inc = CInclude(**d)
-
-        if isinstance(inc.header, dict):
-            inc.header = CHeader.from_dict(inc.header)
-
-        return inc
-
-
-@dataclass
-class CFile(SerialisableDataclass):
-    name: str
-    extension: str
-    includes: List[CInclude] = field(default_factory=list)
-    types: List[CUserType] = field(default_factory=list)
-    funcs: List[CFunc] = field(default_factory=list)
-    decl_types: List[CStruct] = field(default_factory=list)
-    macros: List[CMacro] = field(default_factory=list)
-    c_macros: List[CMacro] = field(default_factory=list)
-    cpp_macros: List[CMacro] = field(default_factory=list)
-
-    def save(self, output_dir: Path):
-        self.includes.extend(
-            [
-                CInclude(
-                    header=str(convert_to_relative(WAPP_SRC_ROOT / "common" / "aliases" / "aliases.h", output_dir)).replace("\\", "/"),
-                    local=True,
-                ),
-                CInclude(
-                    header=str(convert_to_relative(WAPP_SRC_ROOT / "common" / "platform" / "platform.h", output_dir)).replace("\\", "/"),
-                    local=True,
-                )
-            ]
-        )
-        output_file = output_dir / f"{self.name}.{self.extension}"
-        with open(output_file, "w+") as outfile:
-            outfile.write(str(self))
-
-    def __str__(self) -> str:
-        return """\
-/**
- * THIS FILE IS AUTOMATICALLY GENERATED. ANY MODIFICATIONS TO IT WILL BE OVERWRITTEN.
- */
-
-"""
-
-    @classmethod
-    def from_dict(cls: Type["CFile"], d: Dict[str, Any]) -> "CFile":
-        f = CFile(**d)
-        f.deserialise_c_file_data()
-
-        return f
-
-    def deserialise_c_file_data(self) -> None:
-        self.includes = [CInclude.from_dict(v) for v in self.includes if isinstance(v, dict)]
-        self.types = [CFile.to_c_usertype(v) for v in self.types if isinstance(v, dict)]
-        self.funcs = [CFunc.from_dict(v) for v in self.funcs if isinstance(v, dict)]
-        self.decl_types = [CStruct.from_dict(v) for v in self.decl_types if isinstance(v, dict)]
-        self.macros = [CMacro.from_dict(v) for v in self.macros if isinstance(v, dict)]
-        self.c_macros = [CMacro.from_dict(v) for v in self.c_macros if isinstance(v, dict)]
-        self.cpp_macros = [CMacro.from_dict(v) for v in self.cpp_macros if isinstance(v, dict)]
-
-
-@dataclass
-class CHeader(CFile):
-    extension: str = "h"
-
-    def __str__(self) -> str:
-        name_upper = self.name.upper()
-        header_guard_name = f"{name_upper}_H"
-        header_guard_open = f"#ifndef {header_guard_name}\n#define {header_guard_name}\n\n"
-        header_guard_close = f"#endif // !{header_guard_name}\n"
-
-        c_linkage_open = "#ifdef WAPP_PLATFORM_CPP\nBEGIN_C_LINKAGE\n#endif // !WAPP_PLATFORM_CPP\n\n"
-        c_linkage_close = "\n#ifdef WAPP_PLATFORM_CPP\nEND_C_LINKAGE\n#endif // !WAPP_PLATFORM_CPP\n\n"
-
-        includes = _get_includes_string(self.includes)
-
-        macros = ""
-        for macro in self.macros:
-            macros += str(macro)
-        if len(macros) > 0:
-            macros += "\n"
-
-        if len(self.cpp_macros) > 0:
-            macros += "#ifdef WAPP_PLATFORM_CPP\n"
-            for macro in self.cpp_macros:
-                macros += str(macro)
-            macros += "#else\n"
-            for macro in self.c_macros:
-                macros += str(macro)
-            macros += "#endif // !WAPP_PLATFORM_CPP\n\n"
-
-        forward_declarations = ""
-        for _type in self.decl_types:
-            forward_declarations += _type.declare()
-        if len(forward_declarations) > 0:
-            forward_declarations += "\n"
-
-        types = ""
-        for _type in self.types:
-            types += str(_type) + "\n"
-
-        funcs = ""
-        for func in self.funcs:
-            funcs += func.declare()
-
-        return (
-            super().__str__() +
-            header_guard_open +
-            includes +
-            c_linkage_open +
-            macros +
-            forward_declarations +
-            types +
-            funcs +
-            c_linkage_close +
-            header_guard_close
-        )
-
-    @classmethod
-    def from_dict(cls: Type["CHeader"], d: Dict[str, Any]) -> "CHeader":
-        return cast("CHeader", super().from_dict(d))
-
-
-@dataclass
-class CSource(CFile):
-    extension: str = "c"
-    internal_funcs: List[CFunc] = field(default_factory=list)
-
-    def __str__(self) -> str:
-        includes = _get_includes_string(self.includes)
-
-        macros = ""
-        for macro in self.macros:
-            macros += str(macro)
-        if len(macros) > 0:
-            macros += "\n"
-
-        forward_declarations = ""
-        for _type in self.decl_types:
-            forward_declarations += _type.declare()
-        if len(forward_declarations) > 0:
-            forward_declarations += "\n"
-
-        types = ""
-        for _type in self.types:
-            types += str(_type) + "\n"
-
-        internal_funcs_decl = ""
-        internal_funcs_def = ""
-        for func in self.internal_funcs:
-            internal_funcs_decl += func.declare()
-            internal_funcs_def += func.define()
-
-        if len(internal_funcs_decl) > 0:
-            internal_funcs_decl += "\n"
-
-        funcs = ""
-        for func in self.funcs:
-            funcs += func.define()
-
-        return (
-            super().__str__() +
-            includes +
-            macros +
-            forward_declarations +
-            types +
-            internal_funcs_decl +
-            funcs +
-            internal_funcs_def
-        )
-
-    @classmethod
-    def from_dict(cls: Type["CSource"], d: Dict[str, Any]) -> "CSource":
-        s = CSource(**d)
-        s.deserialise_c_file_data()
-        s.internal_funcs = [CFunc.from_dict(v) for v in s.funcs if isinstance(v, dict)]
-        return s
-
-
-def get_datatype_string(_type: CDataType) -> str:
-    if isinstance(_type, CType):
-        return str(_type)
-    elif isinstance(_type, CStruct) or isinstance(_type, CEnum):
-        return _type.name
-    elif isinstance(_type, str):
-        return _type
-
-
-def _get_includes_string(includes: List[CInclude]) -> str:
-    output = ""
-    for include in sorted(includes, key=lambda inc: inc.local, reverse=True):
-        output += str(include)
-    if len(output) > 0:
-        output += "\n"
-
-    return output

codegen/dbl_list/make_dbl_list.py

@@ -1,339 +0,0 @@
-from pathlib import Path
-from dataclasses import dataclass, field
-from typing import List, Dict, Any, Type
-from codegen.constants import WAPP_SRC_ROOT
-from codegen.utils import load_func_body_from_file, convert_to_relative
-from codegen.datatypes import (
-    CDataType,
-    CMacro,
-    CStruct,
-    CFunc,
-    CHeader,
-    CSource,
-    CArg,
-    CType,
-    CPointer,
-    CPointerType,
-    CQualifier,
-    CInclude,
-    SerialisableDataclass,
-    get_datatype_string,
-)
-
-
-@dataclass
-class DblListData(SerialisableDataclass):
-    node_typename: str
-    list_typename: str
-    hdr_decl_types: List[CStruct] = field(default_factory=list)
-    src_decl_types: List[CStruct] = field(default_factory=list)
-
-    @classmethod
-    def from_dict(cls: Type["DblListData"], d: Dict[str, Any]) -> "DblListData":
-        data = DblListData(**d)
-        data.hdr_decl_types = [CStruct.from_dict(v) for v in data.hdr_decl_types if isinstance(v, dict)]
-        data.src_decl_types = [CStruct.from_dict(v) for v in data.src_decl_types if isinstance(v, dict)]
-        return data
-
-
-def make_dbl_list(user_datatypes: Dict[CDataType, DblListData] = {}):
-    def __format_func_body(
-        filename: Path,
-        type_string: str,
-        type_string_upper: str,
-        type_string_lower: str,
-        node_typename: str,
-        list_typename: str
-    ):
-        return load_func_body_from_file(filename).format(
-            T=type_string,
-            NodeType=node_typename,
-            ListType=list_typename,
-            Tupper=type_string_upper,
-            Tlower=type_string_lower,
-        )
-
-    out_dir = WAPP_SRC_ROOT / "base" / "dbl_list"
-    out_dir.mkdir(parents=True, exist_ok=True)
-
-    common_decl_types: List[CStruct] = []
-
-    datatypes: dict[CDataType, DblListData] = {
-        CType.VOID: DblListData(node_typename="GenericNode", list_typename="GenericList"),
-        "void *": DblListData(node_typename="VoidPNode", list_typename="VoidPList"),
-        "Str8": DblListData(
-            node_typename="Str8Node",
-            list_typename="Str8List",
-            hdr_decl_types=[
-                CStruct(name="str8", cargs=[], typedef_name="Str8"),
-            ],
-        ),
-    }
-
-    for _type in CType:
-        if _type == CType.VOID:
-            continue
-
-        type_title = _type.value.title()
-        datatypes[_type] = DblListData(
-            node_typename=f"{type_title}Node",
-            list_typename=f"{type_title}List",
-        )
-
-    datatypes.update(user_datatypes)
-
-    snippets_dir = Path(__file__).parent / "snippets"
-
-    header = CHeader(
-        name="dbl_list",
-        decl_types=[*common_decl_types],
-        includes=[],
-        types=[],
-        funcs=[]
-    )
-
-    source = CSource(
-        name=header.name,
-        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"),
-        ],
-        internal_funcs=[],
-        funcs=header.funcs
-    )
-
-    for _type, dbl_list_data in datatypes.items():
-        type_string = get_datatype_string(_type)
-        clean_type_string = type_string.replace(" ", "").replace("*", "_ptr")
-        type_string_upper = clean_type_string.upper()
-        type_string_lower = clean_type_string.lower()
-
-        node = CStruct(
-            name=dbl_list_data.node_typename,
-            cargs=[
-                CArg(name="item", _type=type_string, pointer=CPointer(_type=CPointerType.SINGLE)),
-            ],
-        )
-        node.cargs.extend([
-            CArg(name="prev", _type=node, pointer=CPointer(_type=CPointerType.SINGLE)),
-            CArg(name="next", _type=node, pointer=CPointer(_type=CPointerType.SINGLE)),
-        ])
-        
-        dl_list = CStruct(
-            name=dbl_list_data.list_typename,
-            cargs=[
-                CArg(name="first", _type=node, pointer=CPointer(_type=CPointerType.SINGLE)),
-                CArg(name="last", _type=node, pointer=CPointer(_type=CPointerType.SINGLE)),
-                CArg(name="node_count", _type=CType.U64),
-            ],
-        )
-
-        header.types.extend([node, dl_list])
-        header.decl_types.extend(dbl_list_data.hdr_decl_types)
-        source.decl_types.extend(dbl_list_data.src_decl_types)
-        if isinstance(_type, CType) and _type == CType.VOID:
-            # Don't define any functions for the generic node and list
-            continue
-
-        node_cmacro = CMacro(
-            name=f"wapp_{type_string_lower}_list_node(ITEM_PTR)",
-            value=__format_func_body(
-                filename=snippets_dir / "list_node",
-                type_string=type_string,
-                type_string_upper=type_string_upper,
-                type_string_lower=type_string_lower,
-                node_typename=dbl_list_data.node_typename,
-                list_typename=dbl_list_data.list_typename
-            ),
-        )
-
-        node_cppmacro = CMacro(
-            name=f"wapp_{type_string_lower}_list_node(ITEM_PTR)",
-            value=__format_func_body(
-                filename=snippets_dir / "list_node_cpp",
-                type_string=type_string,
-                type_string_upper=type_string_upper,
-                type_string_lower=type_string_lower,
-                node_typename=dbl_list_data.node_typename,
-                list_typename=dbl_list_data.list_typename
-            ),
-        )
-
-        get_func = CFunc(
-            name=f"wapp_{type_string_lower}_list_get",
-            ret_type=node,
-            args=[
-                CArg(name="list", _type=dl_list, pointer=CPointer(CPointerType.SINGLE), qualifier=CQualifier.CONST),
-                CArg(name="index", _type=CType.U64),
-            ],
-            body=__format_func_body(
-                filename=snippets_dir / "list_get",
-                type_string=type_string,
-                type_string_upper=type_string_upper,
-                type_string_lower=type_string_lower,
-                node_typename=dbl_list_data.node_typename,
-                list_typename=dbl_list_data.list_typename
-            ),
-            pointer=CPointer(CPointerType.SINGLE),
-        )
-
-        push_front_func = CFunc(
-            name=f"wapp_{type_string_lower}_list_push_front",
-            ret_type=CType.VOID,
-            args=[
-                CArg(name="list", _type=dl_list, pointer=CPointer(CPointerType.SINGLE)),
-                CArg(name="node", _type=node, pointer=CPointer(CPointerType.SINGLE)),
-            ],
-            body=__format_func_body(
-                filename=snippets_dir / "list_push_front",
-                type_string=type_string,
-                type_string_upper=type_string_upper,
-                type_string_lower=type_string_lower,
-                node_typename=dbl_list_data.node_typename,
-                list_typename=dbl_list_data.list_typename
-            ),
-        )
-
-        push_back_func = CFunc(
-            name=f"wapp_{type_string_lower}_list_push_back",
-            ret_type=CType.VOID,
-            args=[
-                CArg(name="list", _type=dl_list, pointer=CPointer(CPointerType.SINGLE)),
-                CArg(name="node", _type=node, pointer=CPointer(CPointerType.SINGLE)),
-            ],
-            body=__format_func_body(
-                filename=snippets_dir / "list_push_back",
-                type_string=type_string,
-                type_string_upper=type_string_upper,
-                type_string_lower=type_string_lower,
-                node_typename=dbl_list_data.node_typename,
-                list_typename=dbl_list_data.list_typename
-            ),
-        )
-
-        insert_func = CFunc(
-            name=f"wapp_{type_string_lower}_list_insert",
-            ret_type=CType.VOID,
-            args=[
-                CArg(name="list", _type=dl_list, pointer=CPointer(CPointerType.SINGLE)),
-                CArg(name="node", _type=node, pointer=CPointer(CPointerType.SINGLE)),
-                CArg(name="index", _type=CType.U64),
-            ],
-            body=__format_func_body(
-                filename=snippets_dir / "list_insert",
-                type_string=type_string,
-                type_string_upper=type_string_upper,
-                type_string_lower=type_string_lower,
-                node_typename=dbl_list_data.node_typename,
-                list_typename=dbl_list_data.list_typename
-            ),
-        )
-
-        pop_front_func = CFunc(
-            name=f"wapp_{type_string_lower}_list_pop_front",
-            ret_type=node,
-            args=[
-                CArg(name="list", _type=dl_list, pointer=CPointer(CPointerType.SINGLE)),
-            ],
-            body=__format_func_body(
-                filename=snippets_dir / "list_pop_front",
-                type_string=type_string,
-                type_string_upper=type_string_upper,
-                type_string_lower=type_string_lower,
-                node_typename=dbl_list_data.node_typename,
-                list_typename=dbl_list_data.list_typename
-            ),
-            pointer=CPointer(CPointerType.SINGLE),
-        )
-
-        pop_back_func = CFunc(
-            name=f"wapp_{type_string_lower}_list_pop_back",
-            ret_type=node,
-            args=[
-                CArg(name="list", _type=dl_list, pointer=CPointer(CPointerType.SINGLE)),
-            ],
-            body=__format_func_body(
-                filename=snippets_dir / "list_pop_back",
-                type_string=type_string,
-                type_string_upper=type_string_upper,
-                type_string_lower=type_string_lower,
-                node_typename=dbl_list_data.node_typename,
-                list_typename=dbl_list_data.list_typename
-            ),
-            pointer=CPointer(CPointerType.SINGLE),
-        )
-
-        remove_func = CFunc(
-            name=f"wapp_{type_string_lower}_list_remove",
-            ret_type=node,
-            args=[
-                CArg(name="list", _type=dl_list, pointer=CPointer(CPointerType.SINGLE)),
-                CArg(name="index", _type=CType.U64),
-            ],
-            body=__format_func_body(
-                filename=snippets_dir / "list_remove",
-                type_string=type_string,
-                type_string_upper=type_string_upper,
-                type_string_lower=type_string_lower,
-                node_typename=dbl_list_data.node_typename,
-                list_typename=dbl_list_data.list_typename
-            ),
-            pointer=CPointer(CPointerType.SINGLE),
-        )
-
-        empty_func = CFunc(
-            name=f"wapp_{type_string_lower}_list_empty",
-            ret_type=CType.VOID,
-            args=[
-                CArg(name="list", _type=dl_list, pointer=CPointer(CPointerType.SINGLE)),
-            ],
-            body=__format_func_body(
-                filename=snippets_dir / "list_empty",
-                type_string=type_string,
-                type_string_upper=type_string_upper,
-                type_string_lower=type_string_lower,
-                node_typename=dbl_list_data.node_typename,
-                list_typename=dbl_list_data.list_typename
-            ),
-        )
-
-        node_to_list_func = CFunc(
-            name=f"{type_string_lower}_node_to_list",
-            ret_type=dl_list,
-            args=[
-                CArg(name="node", _type=node, pointer=CPointer(CPointerType.SINGLE)),
-            ],
-            body=__format_func_body(
-                filename=snippets_dir / "node_to_list",
-                type_string=type_string,
-                type_string_upper=type_string_upper,
-                type_string_lower=type_string_lower,
-                node_typename=dbl_list_data.node_typename,
-                list_typename=dbl_list_data.list_typename
-            ),
-            qualifiers=[CQualifier.INTERNAL],
-        )
-
-        header.c_macros.append(node_cmacro)
-        header.cpp_macros.append(node_cppmacro)
-        header.funcs.extend([
-            get_func,
-            push_front_func,
-            push_back_func,
-            insert_func,
-            pop_front_func,
-            pop_back_func,
-            remove_func,
-            empty_func,
-        ])
-
-        source.internal_funcs.append(node_to_list_func)
-        source.funcs = header.funcs
-
-    header.save(out_dir)
-    source.save(out_dir)

codegen/dbl_list/snippets/list_empty

@@ -1,6 +0,0 @@
-  wapp_debug_assert(list != NULL, "`list` should not be NULL");
-
-  u64 count = list->node_count;
-  for (u64 i = 0; i < count; ++i) {{
-    wapp_{Tlower}_list_pop_back(list);
-  }}

codegen/dbl_list/snippets/list_get

@@ -1,11 +0,0 @@
-  wapp_runtime_assert(index < list->node_count, "`index` is out of bounds");
-
-  {NodeType} *output  = NULL;
-  {NodeType} *current = list->first;
-  for (u64 i = 1; i <= index; ++i) {{
-    current = current->next;
-  }}
-
-  output = current;
-
-  return output;

codegen/dbl_list/snippets/list_insert

@@ -1,26 +0,0 @@
-  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);
-    return;
-  }} else if (index == list->node_count) {{
-    wapp_{Tlower}_list_push_back(list, node);
-    return;
-  }}
-
-  {NodeType} *dst_node = wapp_{Tlower}_list_get(list, index);
-  if (!dst_node) {{
-    return;
-  }}
-
-  {ListType} node_list = {Tlower}_node_to_list(node);
-
-  list->node_count += node_list.node_count;
-
-  {NodeType} *prev = dst_node->prev;
-
-  dst_node->prev = node_list.last;
-  prev->next     = node_list.first;
-
-  node_list.first->prev = prev;
-  node_list.last->next  = dst_node;

codegen/dbl_list/snippets/list_node

@@ -1 +0,0 @@
-(({NodeType}){{.item = ITEM_PTR}})

codegen/dbl_list/snippets/list_node_cpp

@@ -1 +0,0 @@
-{NodeType}{{ITEM_PTR, nullptr, nullptr}}

codegen/dbl_list/snippets/list_pop_back

@@ -1,22 +0,0 @@
-  wapp_debug_assert(list != NULL, "`list` should not be NULL");
-
-  {NodeType} *output = NULL;
-
-  if (list->node_count == 0) {{
-    goto RETURN_{Tupper}_LIST_POP_BACK;
-  }}
-
-  output = list->last;
-
-  if (list->node_count == 1) {{
-    *list = ({ListType}){{0}};
-    goto RETURN_{Tupper}_LIST_POP_BACK;
-  }}
-
-  --(list->node_count);
-  list->last = output->prev;
-
-  output->prev = output->next = NULL;
-
-RETURN_{Tupper}_LIST_POP_BACK:
-  return output;

codegen/dbl_list/snippets/list_pop_front

@@ -1,22 +0,0 @@
-  wapp_debug_assert(list != NULL, "`list` should not be NULL");
-
-  {NodeType} *output = NULL;
-
-  if (list->node_count == 0) {{
-    goto RETURN_{Tupper}_LIST_POP_FRONT;
-  }}
-
-  output = list->first;
-
-  if (list->node_count == 1) {{
-    *list = ({ListType}){{0}};
-    goto RETURN_{Tupper}_LIST_POP_FRONT;
-  }}
-
-  --(list->node_count);
-  list->first = output->next;
-
-  output->prev = output->next = NULL;
-
-RETURN_{Tupper}_LIST_POP_FRONT:
-  return output;

codegen/dbl_list/snippets/list_push_back

@@ -1,18 +0,0 @@
-  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);
-
-  if (list->node_count == 0) {{
-    *list = node_list;
-    return;
-  }}
-
-  list->node_count += node_list.node_count;
-
-  {NodeType} *last = list->last;
-  if (last) {{
-    last->next = node_list.first;
-  }}
-
-  list->last            = node_list.last;
-  node_list.first->prev = last;

codegen/dbl_list/snippets/list_push_front

@@ -1,18 +0,0 @@
-  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);
-
-  if (list->node_count == 0) {{
-    *list = node_list;
-    return;
-  }}
-
-  list->node_count += node_list.node_count;
-
-  {NodeType} *first = list->first;
-  if (first) {{
-    first->prev = node_list.last;
-  }}
-
-  list->first          = node_list.first;
-  node_list.last->next = first;

codegen/dbl_list/snippets/list_remove

@@ -1,26 +0,0 @@
-  wapp_debug_assert(list != NULL, "`list` should not be NULL");
-
-  {NodeType} *output = NULL;
-
-  if (index == 0) {{
-    output = wapp_{Tlower}_list_pop_front(list);
-    goto RETURN_{Tupper}_LIST_REMOVE;
-  }} else if (index == list->node_count) {{
-    output = wapp_{Tlower}_list_pop_back(list);
-    goto RETURN_{Tupper}_LIST_REMOVE;
-  }}
-
-  output = wapp_{Tlower}_list_get(list, index);
-  if (!output) {{
-    goto RETURN_{Tupper}_LIST_REMOVE;
-  }}
-
-  output->prev->next = output->next;
-  output->next->prev = output->prev;
-
-  --(list->node_count);
-
-  output->prev = output->next = NULL;
-
-RETURN_{Tupper}_LIST_REMOVE:
-  return output;

codegen/dbl_list/snippets/node_to_list

@@ -1,13 +0,0 @@
-  {ListType} output = {{.first = node, .last = node, .node_count = 1}};
-
-  while (output.first->prev != NULL) {{
-    output.first = output.first->prev;
-    ++(output.node_count);
-  }}
-
-  while (output.last->next != NULL) {{
-    output.last = output.last->next;
-    ++(output.node_count);
-  }}
-
-  return output;

codegen/utils.py

@@ -1,18 +0,0 @@
-import os
-import sys
-from pathlib import Path
-
-
-def load_func_body_from_file(filename: Path) -> str:
-    with open(filename, "r") as infile:
-        return infile.read().rstrip()
-
-
-def convert_to_relative(path: Path, target: Path) -> Path:
-    major = sys.version_info.major
-    minor = sys.version_info.minor
-
-    if major >= 3 and minor >= 12:
-        return path.relative_to(target, walk_up=True)
-    else:
-        return Path(os.path.relpath(str(path), start=str(target)))

codegen_custom_data_example.json

@@ -1,16 +0,0 @@
-{
-  "dbl_list_data": {
-    "CustomType": {
-      "node_typename": "CustomTypeNode",
-      "list_typename": "CustomTypeList",
-      "hdr_decl_types": [
-        {
-          "name": "custom_type",
-          "cargs": [],
-          "typedef_name": "CustomType"
-        }
-      ],
-      "src_decl_types": []
-    }
-  }
-}

src/base/array/array.c

@@ -9,7 +9,7 @@
 
 #define _offset_pointer(PTR, OFFSET) ((void *)((uptr)(PTR) + (OFFSET)))
 
-void *_array_get(Array *array, u64 index, u64 item_size) {
+void *_array_get(GenericArray *array, u64 index, u64 item_size) {
   wapp_runtime_assert(array != NULL, "`array` should not be NULL");
   wapp_runtime_assert(WAPP_ARRAY_MAGIC == array->magic, "`array` is not a valid wapp array");
   wapp_runtime_assert(item_size == array->item_size, "Invalid item type provided");
@@ -18,12 +18,12 @@ void *_array_get(Array *array, u64 index, u64 item_size) {
   return _offset_pointer(array->items, array->item_size * index);
 }
 
-void _array_set(Array *array, u64 index, void *value, u64 item_size) {
+void _array_set(GenericArray *array, u64 index, void *value, u64 item_size) {
   void *item = _array_get(array, index, item_size);
   memcpy(item, value, array->item_size);
 }
 
-void _array_append_capped(Array *array, void *value, u64 item_size) {
+void _array_append_capped(GenericArray *array, void *value, u64 item_size) {
   wapp_runtime_assert(array != NULL, "`array` should not be NULL");
   wapp_runtime_assert(WAPP_ARRAY_MAGIC == array->magic, "`array` is not a valid wapp array");
   wapp_runtime_assert(item_size == array->item_size, "Invalid item type provided");
@@ -34,7 +34,7 @@ void _array_append_capped(Array *array, void *value, u64 item_size) {
   _array_set(array, index, value, item_size);
 }
 
-void _array_extend_capped(Array *dst, const Array *src, u64 item_size) {
+void _array_extend_capped(GenericArray *dst, const GenericArray *src, u64 item_size) {
   wapp_runtime_assert(dst != NULL && src != NULL, "`dst` and `src` should not be NULL");
   wapp_runtime_assert(WAPP_ARRAY_MAGIC == dst->magic, "`dst` is not a valid wapp array");
   wapp_runtime_assert(WAPP_ARRAY_MAGIC == src->magic, "`src` is not a valid wapp array");
@@ -48,7 +48,7 @@ void _array_extend_capped(Array *dst, const Array *src, u64 item_size) {
   dst->count += copy_count;
 }
 
-void _array_copy_capped(Array *dst, const Array *src, u64 item_size) {
+void _array_copy_capped(GenericArray *dst, const GenericArray *src, u64 item_size) {
   wapp_runtime_assert(dst != NULL && src != NULL, "`dst` and `src` should not be NULL");
   wapp_runtime_assert(WAPP_ARRAY_MAGIC == dst->magic, "`dst` is not a valid wapp array");
   wapp_runtime_assert(WAPP_ARRAY_MAGIC == src->magic, "`src` is not a valid wapp array");
@@ -60,16 +60,16 @@ void _array_copy_capped(Array *dst, const Array *src, u64 item_size) {
   dst->count = copy_count;
 }
 
-Array *_array_append_alloc(const Allocator *allocator, Array *array, void *value, u64 item_size) {
+GenericArray *_array_append_alloc(const Allocator *allocator, GenericArray *array, void *value, u64 item_size) {
   wapp_runtime_assert(allocator != NULL && array != NULL, "`allocator` and `array` should not be NULL");
   wapp_runtime_assert(WAPP_ARRAY_MAGIC == array->magic, "`array` is not a valid wapp array");
   wapp_runtime_assert(item_size == array->item_size, "Invalid item type provided");
 
-  Array *output = array;
+  GenericArray *output = array;
 
   if (array->count >= array->capacity) {
     u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(array->capacity * 2);
-    output           = (Array *)_array_alloc_capacity(allocator, new_capacity, array->item_size);
+    output           = (GenericArray *)_array_alloc_capacity(allocator, new_capacity, array->item_size);
     if (!output) {
       output = array;
       goto RETURN_ARRAY_APPEND_ALLOC;
@@ -83,18 +83,18 @@ RETURN_ARRAY_APPEND_ALLOC:
   return output;
 }
 
-Array *_array_extend_alloc(const Allocator *allocator, Array *dst, const Array *src, u64 item_size) {
+GenericArray *_array_extend_alloc(const Allocator *allocator, GenericArray *dst, const GenericArray *src, u64 item_size) {
   wapp_runtime_assert(allocator != NULL && dst != NULL && src != NULL, "`allocator`, `dst` and `src` should not be NULL");
   wapp_runtime_assert(WAPP_ARRAY_MAGIC == dst->magic, "`dst` is not a valid wapp array");
   wapp_runtime_assert(WAPP_ARRAY_MAGIC == src->magic, "`src` is not a valid wapp array");
   wapp_runtime_assert(item_size == dst->item_size && item_size == src->item_size, "Invalid item type provided");
 
-  Array *output = dst;
+  GenericArray *output = dst;
 
   u64 remaining_capacity = dst->capacity - dst->count;
   if (src->count >= remaining_capacity) {
     u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(dst->capacity * 2);
-    output           = (Array *)_array_alloc_capacity(allocator, new_capacity, dst->item_size);
+    output           = (GenericArray *)_array_alloc_capacity(allocator, new_capacity, dst->item_size);
     if (!output) {
       output = dst;
       goto RETURN_ARRAY_EXTEND_ALLOC;
@@ -108,17 +108,17 @@ RETURN_ARRAY_EXTEND_ALLOC:
   return output;
 }
 
-Array *_array_copy_alloc(const Allocator *allocator, Array *dst, const Array *src, u64 item_size) {
+GenericArray *_array_copy_alloc(const Allocator *allocator, GenericArray *dst, const GenericArray *src, u64 item_size) {
   wapp_runtime_assert(allocator != NULL && dst != NULL && src != NULL, "`allocator`, `dst` and `src` should not be NULL");
   wapp_runtime_assert(WAPP_ARRAY_MAGIC == dst->magic, "`dst` is not a valid wapp array");
   wapp_runtime_assert(WAPP_ARRAY_MAGIC == src->magic, "`src` is not a valid wapp array");
   wapp_runtime_assert(item_size == dst->item_size && item_size == src->item_size, "Invalid item type provided");
 
-  Array *output = dst;
+  GenericArray *output = dst;
 
   if (src->count >= dst->capacity) {
     u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(dst->capacity * 2);
-    output           = (Array *)_array_alloc_capacity(allocator, new_capacity, src->item_size);
+    output           = (GenericArray *)_array_alloc_capacity(allocator, new_capacity, src->item_size);
     if (!output) {
       output = dst;
       goto RETURN_ARRAY_COPY_ALLOC;
@@ -131,7 +131,7 @@ RETURN_ARRAY_COPY_ALLOC:
   return output;
 }
 
-void *_array_pop(Array *array, u64 item_size) {
+void *_array_pop(GenericArray *array, u64 item_size) {
   wapp_runtime_assert(array != NULL, "`array` should not be NULL");
   wapp_runtime_assert(WAPP_ARRAY_MAGIC == array->magic, "`array` is not a valid wapp array");
   wapp_runtime_assert(item_size == array->item_size, "Invalid item type provided");
@@ -144,7 +144,7 @@ void *_array_pop(Array *array, u64 item_size) {
   return out;
 }
 
-void _array_clear(Array *array, u64 item_size) {
+void _array_clear(GenericArray *array, u64 item_size) {
   wapp_runtime_assert(array != NULL, "`array` should not be NULL");
   wapp_runtime_assert(WAPP_ARRAY_MAGIC == array->magic, "`array` is not a valid wapp array");
   wapp_runtime_assert(item_size == array->item_size, "Invalid item type provided");
@@ -152,12 +152,12 @@ void _array_clear(Array *array, u64 item_size) {
   array->count = 0;
 }
 
-Array *_array_alloc_capacity(const Allocator *allocator, u64 capacity, u64 item_size) {
+GenericArray *_array_alloc_capacity(const Allocator *allocator, u64 capacity, u64 item_size) {
   wapp_runtime_assert(allocator != NULL, "`allocator` should not be NULL");
 
-  Array *output = NULL;
+  GenericArray *output = NULL;
 
-  u64 allocation_size = sizeof(Array) + item_size * capacity;
+  u64 allocation_size = sizeof(GenericArray) + item_size * capacity;
 
   output = wapp_mem_allocator_alloc(allocator, allocation_size);
   if (!output) {

src/base/array/array.h

@@ -12,7 +12,7 @@
 BEGIN_C_LINKAGE
 #endif // !WAPP_PLATFORM_CPP
 
-#define WAPP_ARRAY_MAGIC (u64)0x57415F415252
+#define WAPP_ARRAY_MAGIC (u64)0x57415f415252
 
 #define _calc_array_count(TYPE, ...) wapp_misc_utils_va_args_count(TYPE, __VA_ARGS__)
 #define _calc_array_capacity(TYPE, ...) wapp_misc_utils_u64_round_up_pow2(_calc_array_count(TYPE, __VA_ARGS__) * 2)
@@ -61,7 +61,7 @@ BEGIN_C_LINKAGE
     return result;                                                                       \
   }                                                                                      \
                                                                                          \
-  return *((ELEM_TYPE *)_array_pop((Array *)ARRAY_PTR, sizeof(ELEM_TYPE)));              \
+  return *((ELEM_TYPE *)_array_pop((GenericArray *)ARRAY_PTR, sizeof(ELEM_TYPE)));              \
 }())
 #else
 #define wapp_array(ELEM_TYPE, ARRAY_TYPE, ...)                                      \
@@ -85,43 +85,53 @@ BEGIN_C_LINKAGE
   })
 #define wapp_array_pop(ELEM_TYPE, ARRAY_PTR)                                        \
   (ARRAY_PTR != NULL && (ARRAY_PTR)->count > 0 ?                                    \
-    *((ELEM_TYPE *)_array_pop((Array *)ARRAY_PTR, sizeof(ELEM_TYPE))) :             \
+    *((ELEM_TYPE *)_array_pop((GenericArray *)ARRAY_PTR, sizeof(ELEM_TYPE))) :             \
     (ELEM_TYPE){0}                                                                  \
   )
 #endif // !WAPP_PLATFORM_CPP
 
 #define wapp_array_get(ELEM_TYPE, ARRAY_PTR, INDEX)                                                 \
-  ((ELEM_TYPE *)_array_get((Array *)ARRAY_PTR, INDEX, sizeof(ELEM_TYPE)))
+  ((ELEM_TYPE *)_array_get((GenericArray *)ARRAY_PTR, INDEX, sizeof(ELEM_TYPE)))
 #define wapp_array_set(ELEM_TYPE, ARRAY_PTR, INDEX, VALUE_PTR)                                      \
-  _array_set((Array *)ARRAY_PTR, INDEX, (void *)VALUE_PTR, sizeof(ELEM_TYPE))
+  _array_set((GenericArray *)ARRAY_PTR, INDEX, (void *)VALUE_PTR, sizeof(ELEM_TYPE))
 #define wapp_array_append_capped(ELEM_TYPE, ARRAY_PTR, VALUE_PTR)                                   \
-  _array_append_capped((Array *)ARRAY_PTR, (void *)VALUE_PTR, sizeof(ELEM_TYPE))
+  _array_append_capped((GenericArray *)ARRAY_PTR, (void *)VALUE_PTR, sizeof(ELEM_TYPE))
 #define wapp_array_extend_capped(ELEM_TYPE, DST_ARRAY_PTR, SRC_ARRAY_PTR)                           \
-  _array_extend_capped((Array *)DST_ARRAY_PTR, (Array *)SRC_ARRAY_PTR, sizeof(ELEM_TYPE))
+  _array_extend_capped(                                                                             \
+    (GenericArray *)DST_ARRAY_PTR, (GenericArray *)SRC_ARRAY_PTR, sizeof(ELEM_TYPE)                 \
+  )
 #define wapp_array_copy_capped(ELEM_TYPE, DST_ARRAY_PTR, SRC_ARRAY_PTR)                             \
-  _array_copy_capped((Array *)DST_ARRAY_PTR, (Array *)SRC_ARRAY_PTR, sizeof(ELEM_TYPE))
+  _array_copy_capped(                                                                               \
+    (GenericArray *)DST_ARRAY_PTR, (GenericArray *)SRC_ARRAY_PTR, sizeof(ELEM_TYPE)                 \
+  )
 #define wapp_array_append_alloc(ELEM_TYPE, ARRAY_TYPE, ALLOCATOR_PTR, ARRAY_PTR, VALUE_PTR)         \
-  (ARRAY_TYPE *)_array_append_alloc(ALLOCATOR_PTR, (Array *)ARRAY_PTR, (void *)VALUE_PTR, sizeof(ELEM_TYPE))
+  (ARRAY_TYPE *)_array_append_alloc(                                                                \
+    ALLOCATOR_PTR, (GenericArray *)ARRAY_PTR, (void *)VALUE_PTR, sizeof(ELEM_TYPE)                  \
+  )
 #define wapp_array_extend_alloc(ELEM_TYPE, ARRAY_TYPE, ALLOCATOR_PTR, DST_ARRAY_PTR, SRC_ARRAY_PTR) \
-  (ARRAY_TYPE *)_array_extend_alloc(ALLOCATOR_PTR, (Array *)DST_ARRAY_PTR, (Array *)SRC_ARRAY_PTR, sizeof(ELEM_TYPE))
+  (ARRAY_TYPE *)_array_extend_alloc(                                                                \
+    ALLOCATOR_PTR, (GenericArray *)DST_ARRAY_PTR, (GenericArray *)SRC_ARRAY_PTR, sizeof(ELEM_TYPE)  \
+  )
 #define wapp_array_copy_alloc(ELEM_TYPE, ARRAY_TYPE, ALLOCATOR_PTR, DST_ARRAY_PTR, SRC_ARRAY_PTR)   \
-  (ARRAY_TYPE *)_array_copy_alloc(ALLOCATOR_PTR, (Array *)DST_ARRAY_PTR, (Array *)SRC_ARRAY_PTR, sizeof(ELEM_TYPE))
+  (ARRAY_TYPE *)_array_copy_alloc(                                                                  \
+    ALLOCATOR_PTR, (GenericArray *)DST_ARRAY_PTR, (GenericArray *)SRC_ARRAY_PTR, sizeof(ELEM_TYPE)  \
+  )
 #define wapp_array_clear(ELEM_TYPE, ARRAY_PTR)                                                      \
-  _array_clear((Array *)ARRAY_PTR, sizeof(ELEM_TYPE))
+  _array_clear((GenericArray *)ARRAY_PTR, sizeof(ELEM_TYPE))
 
-WAPP_DEF_ARRAY_TYPE(void, Array);
+WAPP_DEF_ARRAY_TYPE(void, GenericArray);
 
-void  *_array_get(Array *array, u64 index, u64 item_size);
-void   _array_set(Array *array, u64 index, void *value, u64 item_size);
-void   _array_append_capped(Array *array, void *value, u64 item_size);
-void   _array_extend_capped(Array *dst, const Array *src, u64 item_size);
-void   _array_copy_capped(Array *dst, const Array *src, u64 item_size);
-Array *_array_append_alloc(const Allocator *allocator, Array *array, void *value, u64 item_size);
-Array *_array_extend_alloc(const Allocator *allocator, Array *dst, const Array *src, u64 item_size);
-Array *_array_copy_alloc(const Allocator *allocator, Array *dst, const Array *src, u64 item_size);
-void  *_array_pop(Array *array, u64 item_size);
-void   _array_clear(Array *array, u64 item_size);
-Array *_array_alloc_capacity(const Allocator *allocator, u64 capacity, u64 item_size);
+void         *_array_get(GenericArray *array, u64 index, u64 item_size);
+void          _array_set(GenericArray *array, u64 index, void *value, u64 item_size);
+void          _array_append_capped(GenericArray *array, void *value, u64 item_size);
+void          _array_extend_capped(GenericArray *dst, const GenericArray *src, u64 item_size);
+void          _array_copy_capped(GenericArray *dst, const GenericArray *src, u64 item_size);
+GenericArray *_array_append_alloc(const Allocator *allocator, GenericArray *array, void *value, u64 item_size);
+GenericArray *_array_extend_alloc(const Allocator *allocator, GenericArray *dst, const GenericArray *src, u64 item_size);
+GenericArray *_array_copy_alloc(const Allocator *allocator, GenericArray *dst, const GenericArray *src, u64 item_size);
+void         *_array_pop(GenericArray *array, u64 item_size);
+void          _array_clear(GenericArray *array, u64 item_size);
+GenericArray *_array_alloc_capacity(const Allocator *allocator, u64 capacity, u64 item_size);
 
 // Base array types
 typedef struct str8 Str8;

src/base/dbl_list/dbl_list.h

@@ -1,10 +1,7 @@
-/**
- * THIS FILE IS AUTOMATICALLY GENERATED. ANY MODIFICATIONS TO IT WILL BE OVERWRITTEN.
- */
-
 #ifndef DBL_LIST_H
 #define DBL_LIST_H
 
+#include "../mem/allocator/mem_allocator.h"
 #include "../../common/aliases/aliases.h"
 #include "../../common/platform/platform.h"
 
@@ -12,506 +9,97 @@
 BEGIN_C_LINKAGE
 #endif // !WAPP_PLATFORM_CPP
 
+#define WAPP_DBL_LIST_MAGIC (u64)0x57415f444c5354
+#define WAPP_DBL_NODE_MAGIC (u64)0x57415f444e44
+
+#define WAPP_DEF_DBL_LIST_TYPE(T, NODE_NAME, LIST_NAME) \
+  typedef struct NODE_NAME NODE_NAME;                   \
+  struct NODE_NAME {                                    \
+    u64 magic;                                          \
+    T *item;                                            \
+    NODE_NAME *prev;                                    \
+    NODE_NAME *next;                                    \
+    u64 item_size;                                      \
+  };                                                    \
+                                                        \
+  typedef struct {                                      \
+    u64 magic;                                          \
+    NODE_NAME *first;                                   \
+    NODE_NAME *last;                                    \
+    u64 node_count;                                     \
+    u64 item_size;                                      \
+  } LIST_NAME
+
 #ifdef WAPP_PLATFORM_CPP
-#define wapp_void_ptr_list_node(ITEM_PTR) VoidPNode{ITEM_PTR, nullptr, nullptr}
-#define wapp_str8_list_node(ITEM_PTR) Str8Node{ITEM_PTR, nullptr, nullptr}
-#define wapp_b8_list_node(ITEM_PTR) B8Node{ITEM_PTR, nullptr, nullptr}
-#define wapp_char_list_node(ITEM_PTR) CharNode{ITEM_PTR, nullptr, nullptr}
-#define wapp_c8_list_node(ITEM_PTR) C8Node{ITEM_PTR, nullptr, nullptr}
-#define wapp_c16_list_node(ITEM_PTR) C16Node{ITEM_PTR, nullptr, nullptr}
-#define wapp_c32_list_node(ITEM_PTR) C32Node{ITEM_PTR, nullptr, nullptr}
-#define wapp_i8_list_node(ITEM_PTR) I8Node{ITEM_PTR, nullptr, nullptr}
-#define wapp_i16_list_node(ITEM_PTR) I16Node{ITEM_PTR, nullptr, nullptr}
-#define wapp_i32_list_node(ITEM_PTR) I32Node{ITEM_PTR, nullptr, nullptr}
-#define wapp_i64_list_node(ITEM_PTR) I64Node{ITEM_PTR, nullptr, nullptr}
-#define wapp_u8_list_node(ITEM_PTR) U8Node{ITEM_PTR, nullptr, nullptr}
-#define wapp_u16_list_node(ITEM_PTR) U16Node{ITEM_PTR, nullptr, nullptr}
-#define wapp_u32_list_node(ITEM_PTR) U32Node{ITEM_PTR, nullptr, nullptr}
-#define wapp_u64_list_node(ITEM_PTR) U64Node{ITEM_PTR, nullptr, nullptr}
-#define wapp_f32_list_node(ITEM_PTR) F32Node{ITEM_PTR, nullptr, nullptr}
-#define wapp_f64_list_node(ITEM_PTR) F64Node{ITEM_PTR, nullptr, nullptr}
-#define wapp_f128_list_node(ITEM_PTR) F128Node{ITEM_PTR, nullptr, nullptr}
-#define wapp_iptr_list_node(ITEM_PTR) IptrNode{ITEM_PTR, nullptr, nullptr}
-#define wapp_uptr_list_node(ITEM_PTR) UptrNode{ITEM_PTR, nullptr, nullptr}
+#define wapp_dbl_list(ELEM_TYPE, LIST_TYPE)                                     \
+  LIST_TYPE{WAPP_DBL_LIST_MAGIC, nullptr, nullptr, 0, sizeof(ELEM_TYPE)}
+#define wapp_dbl_list_node(ELEM_TYPE, NODE_TYPE, ELEM_PTR)                      \
+  NODE_TYPE{WAPP_DBL_NODE_MAGIC, ELEM_PTR, nullptr, nullptr, sizeof(ELEM_TYPE)}
 #else
-#define wapp_void_ptr_list_node(ITEM_PTR) ((VoidPNode){.item = ITEM_PTR})
-#define wapp_str8_list_node(ITEM_PTR) ((Str8Node){.item = ITEM_PTR})
-#define wapp_b8_list_node(ITEM_PTR) ((B8Node){.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})
+#define wapp_dbl_list(ELEM_TYPE, LIST_TYPE) (                                                 \
+  (LIST_TYPE){.magic = WAPP_DBL_LIST_MAGIC, .item_size = sizeof(ELEM_TYPE)}                   \
+)
+#define wapp_dbl_list_node(ELEM_TYPE, NODE_TYPE, ELEM_PTR) (                                  \
+  (NODE_TYPE){.magic = WAPP_DBL_NODE_MAGIC, .item = ELEM_PTR, .item_size = sizeof(ELEM_TYPE)} \
+)
 #endif // !WAPP_PLATFORM_CPP
 
+#define wapp_dbl_list_alloc(ELEM_TYPE, LIST_TYPE, ALLOCATOR)                                        \
+  (LIST_TYPE *)_dbl_list_alloc(ALLOCATOR, sizeof(ELEM_TYPE))
+#define wapp_dbl_list_node_alloc(ELEM_TYPE, NODE_TYPE, ALLOCATOR)                                   \
+  (NODE_TYPE *)_dbl_list_node_alloc(ALLOCATOR, sizeof(ELEM_TYPE))
+#define wapp_dbl_list_get(ELEM_TYPE, NODE_TYPE, LIST_PTR, ELEM_INDEX)                               \
+  (NODE_TYPE *)_dbl_list_get((GenericList *)LIST_PTR, ELEM_INDEX, sizeof(ELEM_TYPE))
+#define wapp_dbl_list_push_front(ELEM_TYPE, LIST_PTR, NODE_PTR)                                     \
+  _dbl_list_push_front((GenericList *)LIST_PTR, (GenericNode *)NODE_PTR, sizeof(ELEM_TYPE))
+#define wapp_dbl_list_push_back(ELEM_TYPE, LIST_PTR, NODE_PTR)                                      \
+  _dbl_list_push_back((GenericList *)LIST_PTR, (GenericNode *)NODE_PTR, sizeof(ELEM_TYPE))
+#define wapp_dbl_list_insert(ELEM_TYPE, LIST_PTR, NODE_PTR, ELEM_INDEX)                             \
+  _dbl_list_insert((GenericList *)LIST_PTR, (GenericNode *)NODE_PTR, ELEM_INDEX, sizeof(ELEM_TYPE))
+#define wapp_dbl_list_pop_front(ELEM_TYPE, NODE_TYPE, LIST_PTR)                                     \
+  (NODE_TYPE *)_dbl_list_pop_front((GenericList *)LIST_PTR, sizeof(ELEM_TYPE))
+#define wapp_dbl_list_pop_back(ELEM_TYPE, NODE_TYPE, LIST_PTR)                                      \
+  (NODE_TYPE *)_dbl_list_pop_back((GenericList *)LIST_PTR, sizeof(ELEM_TYPE))
+#define wapp_dbl_list_remove(ELEM_TYPE, NODE_TYPE, LIST_PTR, ELEM_INDEX)                            \
+  (NODE_TYPE *)_dbl_list_remove((GenericList *)LIST_PTR, ELEM_INDEX, sizeof(ELEM_TYPE))
+#define wapp_dbl_list_empty(ELEM_TYPE, LIST_PTR)                                                    \
+  _dbl_list_empty((GenericList *)LIST_PTR, sizeof(ELEM_TYPE))
+
+WAPP_DEF_DBL_LIST_TYPE(void, GenericNode, GenericList);
+
+GenericList *_dbl_list_alloc(const Allocator *allocator, u64 item_size);
+GenericNode *_dbl_list_node_alloc(const Allocator *allocator, u64 item_size);
+GenericNode *_dbl_list_get(const GenericList *list, u64 index, u64 item_size);
+void         _dbl_list_push_front(GenericList *list, GenericNode *node, u64 item_size);
+void         _dbl_list_push_back(GenericList *list, GenericNode *node, u64 item_size);
+void         _dbl_list_insert(GenericList *list, GenericNode *node, u64 index, u64 item_size);
+GenericNode *_dbl_list_pop_front(GenericList *list, u64 item_size);
+GenericNode *_dbl_list_pop_back(GenericList *list, u64 item_size);
+GenericNode *_dbl_list_remove(GenericList *list, u64 index, u64 item_size);
+void         _dbl_list_empty(GenericList *list, u64 item_size);
+
+// Base list types
 typedef struct str8 Str8;
 
-typedef struct GenericNode GenericNode;
-struct GenericNode {
-  void *item;
-  GenericNode *prev;
-  GenericNode *next;
-};
-
-typedef struct GenericList GenericList;
-struct GenericList {
-  GenericNode *first;
-  GenericNode *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 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 B8Node B8Node;
-struct B8Node {
-  b8 *item;
-  B8Node *prev;
-  B8Node *next;
-};
-
-typedef struct B8List B8List;
-struct B8List {
-  B8Node *first;
-  B8Node *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;
-};
-
-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);
-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);
-B8Node *wapp_b8_list_get(const B8List *list, u64 index);
-void wapp_b8_list_push_front(B8List *list, B8Node *node);
-void wapp_b8_list_push_back(B8List *list, B8Node *node);
-void wapp_b8_list_insert(B8List *list, B8Node *node, u64 index);
-B8Node *wapp_b8_list_pop_front(B8List *list);
-B8Node *wapp_b8_list_pop_back(B8List *list);
-B8Node *wapp_b8_list_remove(B8List *list, u64 index);
-void wapp_b8_list_empty(B8List *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);
+WAPP_DEF_DBL_LIST_TYPE(void *, VoidPtrNode, VoidPtrList);
+WAPP_DEF_DBL_LIST_TYPE(c8    , C8Node     , C8List);
+WAPP_DEF_DBL_LIST_TYPE(c16   , C16Node    , C16List);
+WAPP_DEF_DBL_LIST_TYPE(c32   , C32Node    , C32List);
+WAPP_DEF_DBL_LIST_TYPE(u8    , U8Node     , U8List);
+WAPP_DEF_DBL_LIST_TYPE(u16   , U16Node    , U16List);
+WAPP_DEF_DBL_LIST_TYPE(u32   , U32Node    , U32List);
+WAPP_DEF_DBL_LIST_TYPE(u64   , U64Node    , U64List);
+WAPP_DEF_DBL_LIST_TYPE(b8    , B8Node     , B8List);
+WAPP_DEF_DBL_LIST_TYPE(i8    , I8Node     , I8List);
+WAPP_DEF_DBL_LIST_TYPE(i16   , I16Node    , I16List);
+WAPP_DEF_DBL_LIST_TYPE(i32   , I32Node    , I32List);
+WAPP_DEF_DBL_LIST_TYPE(i64   , I64Node    , I64List);
+WAPP_DEF_DBL_LIST_TYPE(f32   , F32Node    , F32List);
+WAPP_DEF_DBL_LIST_TYPE(f64   , F64Node    , F64List);
+WAPP_DEF_DBL_LIST_TYPE(f128  , F128Node   , F128List);
+WAPP_DEF_DBL_LIST_TYPE(uptr  , UptrNode   , UptrList);
+WAPP_DEF_DBL_LIST_TYPE(iptr  , IptrNode   , IptrList);
+WAPP_DEF_DBL_LIST_TYPE(Str8  , Str8Node   , Str8List);
 
 #ifdef WAPP_PLATFORM_CPP
 END_C_LINKAGE

src/base/strings/str8/str8.c

@@ -333,14 +333,14 @@ i64 wapp_str8_rfind(Str8RO *str, Str8RO substr) {
 Str8List *wapp_str8_split_with_max(const Allocator *allocator, Str8RO *str, Str8RO *delimiter, i64 max_splits) {
   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));
+  Str8List *output = wapp_dbl_list_alloc(Str8, Str8List, allocator);
 
   if (delimiter->size > str->size) {
     Str8 *full     = wapp_str8_alloc_str8(allocator, str);
-    Str8Node *node = wapp_mem_allocator_alloc(allocator, sizeof(Str8Node));
+    Str8Node *node = wapp_dbl_list_node_alloc(Str8, Str8Node, allocator);
     if (node) {
       node->item = full;
-      wapp_str8_list_push_back(output, node);
+      wapp_dbl_list_push_back(Str8, output, node);
     }
 
     goto RETURN_STR8_SPLIT;
@@ -358,10 +358,10 @@ Str8List *wapp_str8_split_with_max(const Allocator *allocator, Str8RO *str, Str8
     }
 
     before_str     = wapp_str8_alloc_substr(allocator, str, start, start + end);
-    Str8Node *node = wapp_mem_allocator_alloc(allocator, sizeof(Str8Node));
+    Str8Node *node = wapp_dbl_list_node_alloc(Str8, Str8Node, allocator);
     if (node && before_str) {
       node->item = before_str;
-      wapp_str8_list_push_back(output, node);
+      wapp_dbl_list_push_back(Str8, output, node);
     }
 
     wapp_mem_allocator_free(allocator, (void **)&rest, sizeof(Str8));
@@ -373,10 +373,10 @@ Str8List *wapp_str8_split_with_max(const Allocator *allocator, Str8RO *str, Str8
 
   // 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));
+  Str8Node *node = wapp_dbl_list_node_alloc(Str8, Str8Node, allocator);
   if (node && rest) {
     node->item = rest;
-    wapp_str8_list_push_back(output, node);
+    wapp_dbl_list_push_back(Str8, output, node);
   }
 
 RETURN_STR8_SPLIT:
@@ -386,14 +386,14 @@ RETURN_STR8_SPLIT:
 Str8List *wapp_str8_rsplit_with_max(const Allocator *allocator, Str8RO *str, Str8RO *delimiter, i64 max_splits) {
   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));
+  Str8List *output = wapp_dbl_list_alloc(Str8, Str8List, allocator);
 
   if (delimiter->size > str->size) {
     Str8 *full     = wapp_str8_alloc_str8(allocator, str);
-    Str8Node *node = wapp_mem_allocator_alloc(allocator, sizeof(Str8Node));
+    Str8Node *node = wapp_dbl_list_node_alloc(Str8, Str8Node, allocator);
     if (node && full) {
       node->item = full;
-      wapp_str8_list_push_back(output, node);
+      wapp_dbl_list_push_back(Str8, output, node);
     }
 
     goto RETURN_STR8_SPLIT;
@@ -410,10 +410,10 @@ Str8List *wapp_str8_rsplit_with_max(const Allocator *allocator, Str8RO *str, Str
     }
 
     after_str     = wapp_str8_alloc_substr(allocator, rest, end + delimiter->size, str->size);
-    Str8Node *node = wapp_mem_allocator_alloc(allocator, sizeof(Str8Node));
+    Str8Node *node = wapp_dbl_list_node_alloc(Str8, Str8Node, allocator);
     if (node) {
       node->item = after_str;
-      wapp_str8_list_push_front(output, node);
+      wapp_dbl_list_push_front(Str8, output, node);
     }
 
     wapp_mem_allocator_free(allocator, (void **)&rest, sizeof(Str8));
@@ -423,10 +423,10 @@ Str8List *wapp_str8_rsplit_with_max(const Allocator *allocator, Str8RO *str, Str
   }
 
   rest           = wapp_str8_alloc_substr(allocator, str, 0, rest->size);
-  Str8Node *node = wapp_mem_allocator_alloc(allocator, sizeof(Str8Node));
+  Str8Node *node = wapp_dbl_list_node_alloc(Str8, Str8Node, allocator);
   if (node && rest) {
     node->item = rest;
-    wapp_str8_list_push_front(output, node);
+    wapp_dbl_list_push_front(Str8, output, node);
   }
 
 RETURN_STR8_SPLIT:
@@ -445,7 +445,7 @@ Str8 *wapp_str8_join(const Allocator *allocator, const Str8List *list, Str8RO *d
   u64 node_index = 0;
   b8 running    = node_index < list->node_count;
   while (running) {
-    node = wapp_str8_list_get(list, node_index);
+    node = wapp_dbl_list_get(Str8, Str8Node, list, node_index);
     if (!node) {
         break;
     }
@@ -478,7 +478,7 @@ u64 wapp_str8_list_total_size(const Str8List *list) {
   u64 output     = 0;
   b8 running    = node_index < list->node_count;
   while (running) {
-      node = wapp_str8_list_get(list, node_index);
+      node = wapp_dbl_list_get(Str8, Str8Node, list, node_index);
       if (!node) {
           break;
       }

src/base/strings/str8/str8.h

@@ -119,23 +119,31 @@ Str8     *wapp_str8_join(const Allocator *allocator, const Str8List *list, Str8R
 /**
  * Str8 list utilities
  */
-#ifdef WAPP_PLATFORM_CPP
-#define wapp_str8_node_from_cstr(STRING) wapp_str8_list_node([&]() { \
-  wapp_persist Str8 str = wapp_str8_lit(STRING);                      \
-  return &str;                                                      \
-}())
-#define wapp_str8_node_from_str8(STRING) wapp_str8_list_node([&]() { \
-  wapp_persist Str8 str = STRING;                                     \
-  return &str;                                                      \
-}())
-#else
-#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))
-#endif // !WAPP_PLATFORM_CPP
 u64 wapp_str8_list_total_size(const Str8List *list);
 
 #ifdef WAPP_PLATFORM_CPP
 END_C_LINKAGE
+
+#include <type_traits>
+
+template <typename T>
+constexpr bool is_lvalue(T&&) {
+  return std::is_lvalue_reference<T>{};
+}
+
+#define wapp_str8_node_from_cstr(STRING) wapp_dbl_list_node(Str8, Str8Node, [&]() { \
+  wapp_persist Str8 str = wapp_str8_lit(STRING);                                    \
+  return &str;                                                                      \
+}())
+#define wapp_str8_node_from_str8(STRING) wapp_dbl_list_node(Str8, Str8Node, [&]() { \
+  if (is_lvalue(STRING)) { return &STRING; }                                        \
+                                                                                    \
+  wapp_persist Str8 str = STRING;                                                   \
+  return &str;                                                                      \
+}())
+#else
+#define wapp_str8_node_from_cstr(STRING) wapp_dbl_list_node(Str8, Str8Node, &wapp_str8_lit(STRING))
+#define wapp_str8_node_from_str8(STRING) wapp_dbl_list_node(Str8, Str8Node, &(STRING))
 #endif // !WAPP_PLATFORM_CPP
 
 #endif // !STR8_H

src/os/cpath/cpath.c

@@ -29,7 +29,7 @@ u32 wapp_cpath_join_path(Str8 *dst, const Str8List *parts) {
   }
 
   // Handle first node
-  const Str8Node *first_node = wapp_str8_list_get(parts, 0);
+  const Str8Node *first_node = wapp_dbl_list_get(Str8, Str8Node, parts, 0);
   wapp_str8_copy_str8_capped(dst, first_node->item);
 
   // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
@@ -106,7 +106,7 @@ Str8 *dirup(const Allocator *allocator, Str8RO *path, u64 levels) {
     wapp_str8_push_back(output, absolute ? WAPP_PATH_SEP : '.');
   } else {
     for (u64 i = 0; i < levels; ++i) {
-      wapp_str8_list_pop_back(parts);
+      wapp_dbl_list_pop_back(Str8, Str8Node, parts);
     }
     
     u64 alignment  = sizeof(void *) * 2;

src/os/file/file.c

@@ -62,7 +62,7 @@ u64 wapp_file_get_length(File *file) {
   return output;
 }
 
-u64 wapp_file_read(Array *dst_buf, File *file, u64 item_count) {
+u64 wapp_file_read(GenericArray *dst_buf, File *file, u64 item_count) {
   wapp_debug_assert(dst_buf != NULL && file != NULL,
                     "`dst_buf` and `file` should not be NULL.");
 
@@ -86,7 +86,7 @@ u64 wapp_file_read(Array *dst_buf, File *file, u64 item_count) {
   return dst_buf->count;
 }
 
-u64 wapp_file_write(const Array *src_buf, File *file, u64 item_count) {
+u64 wapp_file_write(const GenericArray *src_buf, File *file, u64 item_count) {
   wapp_debug_assert(src_buf != NULL && file != NULL,
                     "`src_buf` and `file` should not be NULL.");
 

src/os/file/file.h

@@ -44,8 +44,8 @@ File *wapp_file_open(Str8RO *filename, FileAccessMode mode);
 u64   wapp_file_get_current_position(File *file);
 i32   wapp_file_seek(File *file, u64 offset, FileSeekOrigin origin);
 u64   wapp_file_get_length(File *file);
-u64   wapp_file_read(Array *dst_buf, File *file, u64 item_count);
-u64   wapp_file_write(const Array *src_buf, File *file, u64 item_count);
+u64   wapp_file_read(GenericArray *dst_buf, File *file, u64 item_count);
+u64   wapp_file_write(const GenericArray *src_buf, File *file, u64 item_count);
 i32   wapp_file_flush(File *file);
 i32   wapp_file_close(File *file);
 

tests/cpath/test_cpath.c

@@ -16,16 +16,16 @@ TestFuncResult test_cpath_join_path(void) {
   wapp_str8_format(&expected, "%chome%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_PATH_SEP, WAPP_PATH_SEP);
   wapp_str8_format(&tmp, "%c", WAPP_PATH_SEP);
 
-  Str8List parts = {0};
-  wapp_str8_list_push_back(&parts, &wapp_str8_node_from_str8(tmp));
-  wapp_str8_list_push_back(&parts, &wapp_str8_node_from_cstr("home"));
-  wapp_str8_list_push_back(&parts, &wapp_str8_node_from_cstr("abdelrahman"));
-  wapp_str8_list_push_back(&parts, &wapp_str8_node_from_cstr("Documents"));
+  Str8List parts = wapp_dbl_list(Str8, Str8List);
+  wapp_dbl_list_push_back(Str8, &parts, &wapp_str8_node_from_str8(tmp));
+  wapp_dbl_list_push_back(Str8, &parts, &wapp_str8_node_from_cstr("home"));
+  wapp_dbl_list_push_back(Str8, &parts, &wapp_str8_node_from_cstr("abdelrahman"));
+  wapp_dbl_list_push_back(Str8, &parts, &wapp_str8_node_from_cstr("Documents"));
 
   wapp_cpath_join_path(&out, &parts);
   result = wapp_str8_equal(&out, &expected);
 
-  wapp_str8_list_pop_front(&parts);
+  wapp_dbl_list_pop_front(Str8, Str8Node, &parts);
 
   wapp_str8_format(&expected, "home%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_PATH_SEP);
 
@@ -33,8 +33,8 @@ TestFuncResult test_cpath_join_path(void) {
   result = result && wapp_str8_equal(&out, &expected);
 
   wapp_str8_concat_capped(&tmp, &wapp_str8_lit_ro("home"));
-  wapp_str8_list_pop_front(&parts);
-  wapp_str8_list_push_front(&parts, &wapp_str8_node_from_str8(tmp));
+  wapp_dbl_list_pop_front(Str8, Str8Node, &parts);
+  wapp_dbl_list_push_front(Str8, &parts, &wapp_str8_node_from_str8(tmp));
 
   wapp_str8_format(&expected, "%chome%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_PATH_SEP, WAPP_PATH_SEP);
 
@@ -42,35 +42,35 @@ TestFuncResult test_cpath_join_path(void) {
   result = result && wapp_str8_equal(&out, &expected);
 
   wapp_str8_format(&tmp, "home%c", WAPP_PATH_SEP);
-  wapp_str8_list_pop_front(&parts);
-  wapp_str8_list_push_front(&parts, &wapp_str8_node_from_cstr("home"));
+  wapp_dbl_list_pop_front(Str8, Str8Node, &parts);
+  wapp_dbl_list_push_front(Str8, &parts, &wapp_str8_node_from_cstr("home"));
 
   wapp_str8_format(&expected, "home%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_PATH_SEP);
 
   wapp_cpath_join_path(&out, &parts);
   result = result && wapp_str8_equal(&out, &expected);
 
-  wapp_str8_list_empty(&parts);
+  wapp_dbl_list_empty(Str8, &parts);
 
   wapp_str8_format(&tmp, "%chome", WAPP_PATH_SEP);
-  wapp_str8_list_push_back(&parts, &wapp_str8_node_from_str8(tmp));
-  wapp_str8_list_push_back(&parts, &wapp_str8_node_from_cstr(""));
+  wapp_dbl_list_push_back(Str8, &parts, &wapp_str8_node_from_str8(tmp));
+  wapp_dbl_list_push_back(Str8, &parts, &wapp_str8_node_from_cstr(""));
 
   wapp_str8_format(&expected, "%chome", WAPP_PATH_SEP);
 
   wapp_cpath_join_path(&out, &parts);
   result = result && wapp_str8_equal(&out, &expected);
 
-  wapp_str8_list_pop_front(&parts);
-  wapp_str8_list_push_back(&parts, &wapp_str8_node_from_cstr(""));
+  wapp_dbl_list_pop_front(Str8, Str8Node, &parts);
+  wapp_dbl_list_push_back(Str8, &parts, &wapp_str8_node_from_cstr(""));
 
   wapp_str8_format(&expected, "%s", "");
 
   wapp_cpath_join_path(&out, &parts);
   result = result && wapp_str8_equal(&out, &expected);
 
-  wapp_str8_list_pop_back(&parts);
-  wapp_str8_list_push_back(&parts, &wapp_str8_node_from_cstr("home"));
+  wapp_dbl_list_pop_back(Str8, Str8Node, &parts);
+  wapp_dbl_list_push_back(Str8, &parts, &wapp_str8_node_from_cstr("home"));
 
   wapp_str8_copy_cstr_capped(&expected, "home");
 

tests/cpath/test_cpath.cc

@@ -16,24 +16,24 @@ TestFuncResult test_cpath_join_path(void) {
   wapp_str8_format(&expected, "%chome%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_PATH_SEP, WAPP_PATH_SEP);
   wapp_str8_format(&tmp, "%c", WAPP_PATH_SEP);
 
-  Str8List parts = {};
+  Str8List parts = wapp_dbl_list(Str8, Str8List);
 
   Str8Node tmp_node = wapp_str8_node_from_str8(tmp);
-  wapp_str8_list_push_back(&parts, &tmp_node);
+  wapp_dbl_list_push_back(Str8, &parts, &tmp_node);
 
   Str8Node home_node = wapp_str8_node_from_cstr("home");
-  wapp_str8_list_push_back(&parts, &home_node);
+  wapp_dbl_list_push_back(Str8, &parts, &home_node);
 
   Str8Node user_node = wapp_str8_node_from_cstr("abdelrahman");
-  wapp_str8_list_push_back(&parts, &user_node);
+  wapp_dbl_list_push_back(Str8, &parts, &user_node);
 
   Str8Node docs_node = wapp_str8_node_from_cstr("Documents");
-  wapp_str8_list_push_back(&parts, &docs_node);
+  wapp_dbl_list_push_back(Str8, &parts, &docs_node);
 
   wapp_cpath_join_path(&out, &parts);
   result = wapp_str8_equal(&out, &expected);
 
-  wapp_str8_list_pop_front(&parts);
+  wapp_dbl_list_pop_front(Str8, Str8Node, &parts);
 
   wapp_str8_format(&expected, "home%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_PATH_SEP);
 
@@ -42,10 +42,10 @@ TestFuncResult test_cpath_join_path(void) {
 
   Str8RO str = wapp_str8_lit_ro("home");
   wapp_str8_concat_capped(&tmp, &str);
-  wapp_str8_list_pop_front(&parts);
+  wapp_dbl_list_pop_front(Str8, Str8Node, &parts);
 
   Str8Node tmp_node_2 = wapp_str8_node_from_str8(tmp);
-  wapp_str8_list_push_front(&parts, &tmp_node_2);
+  wapp_dbl_list_push_front(Str8, &parts, &tmp_node_2);
 
   wapp_str8_format(&expected, "%chome%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_PATH_SEP, WAPP_PATH_SEP);
 
@@ -53,45 +53,45 @@ TestFuncResult test_cpath_join_path(void) {
   result = result && wapp_str8_equal(&out, &expected);
 
   wapp_str8_format(&tmp, "home%c", WAPP_PATH_SEP);
-  wapp_str8_list_pop_front(&parts);
+  wapp_dbl_list_pop_front(Str8, Str8Node, &parts);
 
   Str8Node home_node_2 = wapp_str8_node_from_cstr("home");
-  wapp_str8_list_push_front(&parts, &home_node_2);
+  wapp_dbl_list_push_front(Str8, &parts, &home_node_2);
 
   wapp_str8_format(&expected, "home%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_PATH_SEP);
 
   wapp_cpath_join_path(&out, &parts);
   result = result && wapp_str8_equal(&out, &expected);
 
-  wapp_str8_list_empty(&parts);
+  wapp_dbl_list_empty(Str8, &parts);
 
   wapp_str8_format(&tmp, "%chome", WAPP_PATH_SEP);
 
   Str8Node tmp_node_3 = wapp_str8_node_from_str8(tmp);
-  wapp_str8_list_push_back(&parts, &tmp_node_3);
+  wapp_dbl_list_push_back(Str8, &parts, &tmp_node_3);
 
   Str8Node empty_node = wapp_str8_node_from_cstr("");
-  wapp_str8_list_push_back(&parts, &empty_node);
+  wapp_dbl_list_push_back(Str8, &parts, &empty_node);
 
   wapp_str8_format(&expected, "%chome", WAPP_PATH_SEP);
 
   wapp_cpath_join_path(&out, &parts);
   result = result && wapp_str8_equal(&out, &expected);
 
-  wapp_str8_list_pop_front(&parts);
+  wapp_dbl_list_pop_front(Str8, Str8Node, &parts);
 
   Str8Node empty_node_2 = wapp_str8_node_from_cstr("");
-  wapp_str8_list_push_back(&parts, &empty_node_2);
+  wapp_dbl_list_push_back(Str8, &parts, &empty_node_2);
 
   wapp_str8_format(&expected, "%s", "");
 
   wapp_cpath_join_path(&out, &parts);
   result = result && wapp_str8_equal(&out, &expected);
 
-  wapp_str8_list_pop_back(&parts);
+  wapp_dbl_list_pop_back(Str8, Str8Node, &parts);
 
   Str8Node home_node_3 = wapp_str8_node_from_cstr("home");
-  wapp_str8_list_push_back(&parts, &home_node_3);
+  wapp_dbl_list_push_back(Str8, &parts, &home_node_3);
 
   wapp_str8_copy_cstr_capped(&expected, "home");
 

tests/shell_commander/test_shell_commander.c

@@ -5,9 +5,9 @@
 #include <string.h>
 
 TestFuncResult test_commander_cmd_success(void) {
-  Str8List cmd = {0};
-  wapp_str8_list_push_back(&cmd, &wapp_str8_node_from_cstr("echo"));
-  wapp_str8_list_push_back(&cmd, &wapp_str8_node_from_cstr("hello world"));
+  Str8List cmd = wapp_dbl_list(Str8, Str8List);
+  wapp_dbl_list_push_back(Str8, &cmd, &wapp_str8_node_from_cstr("echo"));
+  wapp_dbl_list_push_back(Str8, &cmd, &wapp_str8_node_from_cstr("hello world"));
 
   CMDResult result = wapp_shell_commander_execute(SHELL_OUTPUT_DISCARD, NULL, &cmd);
   b8 succeeded    = result.exited && result.exit_code == EXIT_SUCCESS &&
@@ -17,8 +17,8 @@ TestFuncResult test_commander_cmd_success(void) {
 }
 
 TestFuncResult test_commander_cmd_failure(void) {
-  Str8List cmd = {0};
-  wapp_str8_list_push_back(&cmd, &wapp_str8_node_from_cstr("grep"));
+  Str8List cmd = wapp_dbl_list(Str8, Str8List);
+  wapp_dbl_list_push_back(Str8, &cmd, &wapp_str8_node_from_cstr("grep"));
 
   CMDResult result = wapp_shell_commander_execute(SHELL_OUTPUT_DISCARD, NULL, &cmd);
   b8 failed       = result.exited && result.exit_code != EXIT_SUCCESS &&
@@ -33,9 +33,9 @@ TestFuncResult test_commander_cmd_out_buf_success(void) {
   char msg[]        = "hello world";
   wapp_str8_copy_cstr_capped(&expected, msg);
 
-  Str8List cmd = {0};
-  wapp_str8_list_push_back(&cmd, &wapp_str8_node_from_cstr("echo"));
-  wapp_str8_list_push_back(&cmd, &wapp_str8_node_from_cstr(msg));
+  Str8List cmd = wapp_dbl_list(Str8, Str8List);
+  wapp_dbl_list_push_back(Str8, &cmd, &wapp_str8_node_from_cstr("echo"));
+  wapp_dbl_list_push_back(Str8, &cmd, &wapp_str8_node_from_cstr(msg));
 
   CMDResult result = wapp_shell_commander_execute(SHELL_OUTPUT_CAPTURE, &buf, &cmd);
   b8 succeeded    = result.exited && result.exit_code == EXIT_SUCCESS &&
@@ -50,9 +50,9 @@ TestFuncResult test_commander_cmd_out_buf_failure(void) {
   char msg[]       = "hello world";
   wapp_str8_copy_cstr_capped(&expected, msg);
 
-  Str8List cmd = {0};
-  wapp_str8_list_push_back(&cmd, &wapp_str8_node_from_cstr("echo"));
-  wapp_str8_list_push_back(&cmd, &wapp_str8_node_from_cstr(msg));
+  Str8List cmd = wapp_dbl_list(Str8, Str8List);
+  wapp_dbl_list_push_back(Str8, &cmd, &wapp_str8_node_from_cstr("echo"));
+  wapp_dbl_list_push_back(Str8, &cmd, &wapp_str8_node_from_cstr(msg));
 
   CMDResult result = wapp_shell_commander_execute(SHELL_OUTPUT_CAPTURE, &buf, &cmd);
   b8 failed       = !result.exited && result.exit_code != EXIT_SUCCESS &&

tests/shell_commander/test_shell_commander.cc

@@ -5,11 +5,11 @@
 #include <string.h>
 
 TestFuncResult test_commander_cmd_success(void) {
-  Str8List cmd  = {};
+  Str8List cmd  = wapp_dbl_list(Str8, Str8List);
   Str8Node echo = wapp_str8_node_from_cstr("echo");
   Str8Node msg  = wapp_str8_node_from_cstr("hello world");
-  wapp_str8_list_push_back(&cmd, &echo);
-  wapp_str8_list_push_back(&cmd, &msg);
+  wapp_dbl_list_push_back(Str8, &cmd, &echo);
+  wapp_dbl_list_push_back(Str8, &cmd, &msg);
 
   CMDResult result = wapp_shell_commander_execute(SHELL_OUTPUT_DISCARD, nullptr, &cmd);
   b8 succeeded    = result.exited && result.exit_code == EXIT_SUCCESS &&
@@ -19,9 +19,9 @@ TestFuncResult test_commander_cmd_success(void) {
 }
 
 TestFuncResult test_commander_cmd_failure(void) {
-  Str8List cmd  = {};
+  Str8List cmd  = wapp_dbl_list(Str8, Str8List);
   Str8Node grep = wapp_str8_node_from_cstr("grep");
-  wapp_str8_list_push_back(&cmd, &grep);
+  wapp_dbl_list_push_back(Str8, &cmd, &grep);
 
   CMDResult result = wapp_shell_commander_execute(SHELL_OUTPUT_DISCARD, nullptr, &cmd);
   b8 failed       = result.exited && result.exit_code != EXIT_SUCCESS &&
@@ -36,11 +36,11 @@ TestFuncResult test_commander_cmd_out_buf_success(void) {
   char msg[]        = "hello world";
   wapp_str8_copy_cstr_capped(&expected, msg);
 
-  Str8List cmd  = {};
+  Str8List cmd  = wapp_dbl_list(Str8, Str8List);
   Str8Node echo = wapp_str8_node_from_cstr("echo");
   Str8Node arg  = wapp_str8_node_from_cstr(msg);
-  wapp_str8_list_push_back(&cmd, &echo);
-  wapp_str8_list_push_back(&cmd, &arg);
+  wapp_dbl_list_push_back(Str8, &cmd, &echo);
+  wapp_dbl_list_push_back(Str8, &cmd, &arg);
 
   CMDResult result = wapp_shell_commander_execute(SHELL_OUTPUT_CAPTURE, &buf, &cmd);
   b8 succeeded    = result.exited && result.exit_code == EXIT_SUCCESS &&
@@ -55,11 +55,11 @@ TestFuncResult test_commander_cmd_out_buf_failure(void) {
   char msg[]       = "hello world";
   wapp_str8_copy_cstr_capped(&expected, msg);
 
-  Str8List cmd  = {};
+  Str8List cmd  = wapp_dbl_list(Str8, Str8List);
   Str8Node echo = wapp_str8_node_from_cstr("echo");
   Str8Node arg  = wapp_str8_node_from_cstr(msg);
-  wapp_str8_list_push_back(&cmd, &echo);
-  wapp_str8_list_push_back(&cmd, &arg);
+  wapp_dbl_list_push_back(Str8, &cmd, &echo);
+  wapp_dbl_list_push_back(Str8, &cmd, &arg);
 
   CMDResult result = wapp_shell_commander_execute(SHELL_OUTPUT_CAPTURE, &buf, &cmd);
   b8 failed       = !result.exited && result.exit_code != EXIT_SUCCESS &&

tests/str8/test_str8.c

@@ -443,7 +443,7 @@ TestFuncResult test_str8_split(void) {
   // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
   // MSVC Spectre mitigation warnings
   while (running1) {
-    Str8Node *node = wapp_str8_list_get(list1, index1);
+    Str8Node *node = wapp_dbl_list_get(Str8, Str8Node, list1, index1);
     result = result && wapp_str8_equal(node->item, &(splits1[index1]));
 
     ++index1;
@@ -453,7 +453,7 @@ TestFuncResult test_str8_split(void) {
   // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
   // MSVC Spectre mitigation warnings
   while (running2) {
-    Str8Node *node = wapp_str8_list_get(list2, index2);
+    Str8Node *node = wapp_dbl_list_get(Str8, Str8Node, list2, index2);
     result = result && wapp_str8_equal(node->item, &(splits2[index2]));
 
     ++index2;
@@ -488,7 +488,7 @@ TestFuncResult test_str8_split_with_max(void) {
   // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
   // MSVC Spectre mitigation warnings
   while (running) {
-    Str8Node *node = wapp_str8_list_get(list, index);
+    Str8Node *node = wapp_dbl_list_get(Str8, Str8Node, list, index);
     result = result && wapp_str8_equal(node->item, &(splits[index]));
 
     ++index;
@@ -535,7 +535,7 @@ TestFuncResult test_str8_rsplit(void) {
   // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
   // MSVC Spectre mitigation warnings
   while (running1) {
-    Str8Node *node = wapp_str8_list_get(list1, index1);
+    Str8Node *node = wapp_dbl_list_get(Str8, Str8Node, list1, index1);
     result = result && wapp_str8_equal(node->item, &(splits1[index1]));
 
     ++index1;
@@ -545,7 +545,7 @@ TestFuncResult test_str8_rsplit(void) {
   // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
   // MSVC Spectre mitigation warnings
   while (running2) {
-    Str8Node *node = wapp_str8_list_get(list2, index2);
+    Str8Node *node = wapp_dbl_list_get(Str8, Str8Node, list2, index2);
     result = result && wapp_str8_equal(node->item, &(splits2[index2]));
 
     ++index2;
@@ -580,7 +580,7 @@ TestFuncResult test_str8_rsplit_with_max(void) {
   // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
   // MSVC Spectre mitigation warnings
   while (running) {
-    Str8Node *node = wapp_str8_list_get(list, index);
+    Str8Node *node = wapp_dbl_list_get(Str8, Str8Node, list, index);
     result = result && wapp_str8_equal(node->item, &(splits[index]));
 
     ++index;

tests/str8/test_str8.cc

@@ -443,7 +443,7 @@ TestFuncResult test_str8_split(void) {
   // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
   // MSVC Spectre mitigation warnings
   while (running1) {
-    Str8Node *node = wapp_str8_list_get(list1, index1);
+    Str8Node *node = wapp_dbl_list_get(Str8, Str8Node, list1, index1);
     result = result && wapp_str8_equal(node->item, &(splits1[index1]));
 
     ++index1;
@@ -453,7 +453,7 @@ TestFuncResult test_str8_split(void) {
   // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
   // MSVC Spectre mitigation warnings
   while (running2) {
-    Str8Node *node = wapp_str8_list_get(list2, index2);
+    Str8Node *node = wapp_dbl_list_get(Str8, Str8Node, list2, index2);
     result = result && wapp_str8_equal(node->item, &(splits2[index2]));
 
     ++index2;
@@ -488,7 +488,7 @@ TestFuncResult test_str8_split_with_max(void) {
   // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
   // MSVC Spectre mitigation warnings
   while (running) {
-    Str8Node *node = wapp_str8_list_get(list, index);
+    Str8Node *node = wapp_dbl_list_get(Str8, Str8Node, list, index);
     result = result && wapp_str8_equal(node->item, &(splits[index]));
 
     ++index;
@@ -535,7 +535,7 @@ TestFuncResult test_str8_rsplit(void) {
   // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
   // MSVC Spectre mitigation warnings
   while (running1) {
-    Str8Node *node = wapp_str8_list_get(list1, index1);
+    Str8Node *node = wapp_dbl_list_get(Str8, Str8Node, list1, index1);
     result = result && wapp_str8_equal(node->item, &(splits1[index1]));
 
     ++index1;
@@ -545,7 +545,7 @@ TestFuncResult test_str8_rsplit(void) {
   // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
   // MSVC Spectre mitigation warnings
   while (running2) {
-    Str8Node *node = wapp_str8_list_get(list2, index2);
+    Str8Node *node = wapp_dbl_list_get(Str8, Str8Node, list2, index2);
     result = result && wapp_str8_equal(node->item, &(splits2[index2]));
 
     ++index2;
@@ -580,7 +580,7 @@ TestFuncResult test_str8_rsplit_with_max(void) {
   // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
   // MSVC Spectre mitigation warnings
   while (running) {
-    Str8Node *node = wapp_str8_list_get(list, index);
+    Str8Node *node = wapp_dbl_list_get(Str8, Str8Node, list, index);
     result = result && wapp_str8_equal(node->item, &(splits[index]));
 
     ++index;

tests/str8/test_str8_list.c

@@ -10,32 +10,32 @@ TestFuncResult test_str8_list_get(void) {
   Str8 s4 = wapp_str8_lit("4");
   Str8 s5 = wapp_str8_lit("5");
 
-  Str8List list = {0};
-  Str8Node n1   = { .item = &s1 };
-  Str8Node n2   = { .item = &s2 };
-  Str8Node n3   = { .item = &s3 };
-  Str8Node n4   = { .item = &s4 };
-  Str8Node n5   = { .item = &s5 };
+  Str8List list = wapp_dbl_list(Str8, Str8List);
+  Str8Node n1   = wapp_str8_node_from_str8(s1);
+  Str8Node n2   = wapp_str8_node_from_str8(s2);
+  Str8Node n3   = wapp_str8_node_from_str8(s3);
+  Str8Node n4   = wapp_str8_node_from_str8(s4);
+  Str8Node n5   = wapp_str8_node_from_str8(s5);
 
-  wapp_str8_list_push_back(&list, &n1);
-  wapp_str8_list_push_back(&list, &n2);
-  wapp_str8_list_push_back(&list, &n3);
-  wapp_str8_list_push_back(&list, &n4);
-  wapp_str8_list_push_back(&list, &n5);
+  wapp_dbl_list_push_back(Str8, &list, &n1);
+  wapp_dbl_list_push_back(Str8, &list, &n2);
+  wapp_dbl_list_push_back(Str8, &list, &n3);
+  wapp_dbl_list_push_back(Str8, &list, &n4);
+  wapp_dbl_list_push_back(Str8, &list, &n5);
 
-  Str8Node *node = wapp_str8_list_get(&list, 0);
+  Str8Node *node = wapp_dbl_list_get(Str8, Str8Node, &list, 0);
   result = node->item == &s1 && wapp_str8_equal(node->item, &s1);
 
-  node = wapp_str8_list_get(&list, 1);
+  node = wapp_dbl_list_get(Str8, Str8Node, &list, 1);
   result = result && node->item == &s2 && wapp_str8_equal(node->item, &s2);
 
-  node = wapp_str8_list_get(&list, 2);
+  node = wapp_dbl_list_get(Str8, Str8Node, &list, 2);
   result = result && node->item == &s3 && wapp_str8_equal(node->item, &s3);
 
-  node = wapp_str8_list_get(&list, 3);
+  node = wapp_dbl_list_get(Str8, Str8Node, &list, 3);
   result = result && node->item == &s4 && wapp_str8_equal(node->item, &s4);
 
-  node = wapp_str8_list_get(&list, 4);
+  node = wapp_dbl_list_get(Str8, Str8Node, &list, 4);
   result = result && node->item == &s5 && wapp_str8_equal(node->item, &s5);
 
   return wapp_tester_result(result);
@@ -48,18 +48,18 @@ TestFuncResult test_str8_list_push_front(void) {
   Str8 s2 = wapp_str8_lit("2");
   Str8 s3 = wapp_str8_lit("3");
 
-  Str8List list = {0};
-  Str8Node n1   = { .item = &s1 };
-  Str8Node n2   = { .item = &s2 };
-  Str8Node n3   = { .item = &s3 };
+  Str8List list = wapp_dbl_list(Str8, Str8List);
+  Str8Node n1   = wapp_str8_node_from_str8(s1);
+  Str8Node n2   = wapp_str8_node_from_str8(s2);
+  Str8Node n3   = wapp_str8_node_from_str8(s3);
 
-  wapp_str8_list_push_front(&list, &n1);
+  wapp_dbl_list_push_front(Str8, &list, &n1);
   result = list.first == list.last && list.first == &n1 && list.first->item == &s1 && wapp_str8_list_total_size(&list) == 1 && list.node_count == 1;
 
-  wapp_str8_list_push_front(&list, &n2);
+  wapp_dbl_list_push_front(Str8, &list, &n2);
   result = result && list.first == &n2 && list.first->item == &s2 && wapp_str8_list_total_size(&list) == 2 && list.node_count == 2;
 
-  wapp_str8_list_push_front(&list, &n3);
+  wapp_dbl_list_push_front(Str8, &list, &n3);
   result = result && list.first == &n3 && list.first->item == &s3 && wapp_str8_list_total_size(&list) == 3 && list.node_count == 3;
 
   return wapp_tester_result(result);
@@ -72,18 +72,18 @@ TestFuncResult test_str8_list_push_back(void) {
   Str8 s2 = wapp_str8_lit("2");
   Str8 s3 = wapp_str8_lit("3");
 
-  Str8List list = {0};
-  Str8Node n1   = { .item = &s1 };
-  Str8Node n2   = { .item = &s2 };
-  Str8Node n3   = { .item = &s3 };
+  Str8List list = wapp_dbl_list(Str8, Str8List);
+  Str8Node n1   = wapp_str8_node_from_str8(s1);
+  Str8Node n2   = wapp_str8_node_from_str8(s2);
+  Str8Node n3   = wapp_str8_node_from_str8(s3);
 
-  wapp_str8_list_push_back(&list, &n1);
+  wapp_dbl_list_push_back(Str8, &list, &n1);
   result = list.first == list.last && list.last == &n1 && list.last->item == &s1 && wapp_str8_list_total_size(&list) == 1 && list.node_count == 1;
 
-  wapp_str8_list_push_back(&list, &n2);
+  wapp_dbl_list_push_back(Str8, &list, &n2);
   result = result && list.last == &n2 && list.last->item == &s2 && wapp_str8_list_total_size(&list) == 2 && list.node_count == 2;
 
-  wapp_str8_list_push_back(&list, &n3);
+  wapp_dbl_list_push_back(Str8, &list, &n3);
   result = result && list.last == &n3 && list.last->item == &s3 && wapp_str8_list_total_size(&list) == 3 && list.node_count == 3;
 
   return wapp_tester_result(result);
@@ -100,27 +100,27 @@ TestFuncResult test_str8_list_insert(void) {
   Str8 s6 = wapp_str8_lit("6");
   Str8 s7 = wapp_str8_lit("7");
 
-  Str8List list = {0};
-  Str8Node n1   = { .item = &s1 };
-  Str8Node n2   = { .item = &s2 };
-  Str8Node n3   = { .item = &s3 };
-  Str8Node n4   = { .item = &s4 };
-  Str8Node n5   = { .item = &s5 };
-  Str8Node n6   = { .item = &s6 };
-  Str8Node n7   = { .item = &s7 };
+  Str8List list = wapp_dbl_list(Str8, Str8List);
+  Str8Node n1   = wapp_str8_node_from_str8(s1);
+  Str8Node n2   = wapp_str8_node_from_str8(s2);
+  Str8Node n3   = wapp_str8_node_from_str8(s3);
+  Str8Node n4   = wapp_str8_node_from_str8(s4);
+  Str8Node n5   = wapp_str8_node_from_str8(s5);
+  Str8Node n6   = wapp_str8_node_from_str8(s6);
+  Str8Node n7   = wapp_str8_node_from_str8(s7);
 
-  wapp_str8_list_push_back(&list, &n1);
-  wapp_str8_list_push_back(&list, &n2);
-  wapp_str8_list_push_back(&list, &n3);
-  wapp_str8_list_push_back(&list, &n4);
-  wapp_str8_list_push_back(&list, &n5);
+  wapp_dbl_list_push_back(Str8, &list, &n1);
+  wapp_dbl_list_push_back(Str8, &list, &n2);
+  wapp_dbl_list_push_back(Str8, &list, &n3);
+  wapp_dbl_list_push_back(Str8, &list, &n4);
+  wapp_dbl_list_push_back(Str8, &list, &n5);
 
   Str8Node *node;
-  wapp_str8_list_insert(&list, &n6, 2);
-  node   = wapp_str8_list_get(&list, 2);
+  wapp_dbl_list_insert(Str8, &list, &n6, 2);
+  node   = wapp_dbl_list_get(Str8, Str8Node, &list, 2);
   result = node != NULL && node->item == &s6 && wapp_str8_list_total_size(&list) == 6 && list.node_count == 6;
-  wapp_str8_list_insert(&list, &n7, 5);
-  node   = wapp_str8_list_get(&list, 5);
+  wapp_dbl_list_insert(Str8, &list, &n7, 5);
+  node   = wapp_dbl_list_get(Str8, Str8Node, &list, 5);
   result = result && node != NULL && node->item == &s7 && wapp_str8_list_total_size(&list) == 7 && list.node_count == 7;
 
   return wapp_tester_result(result);
@@ -135,32 +135,32 @@ TestFuncResult test_str8_list_pop_front(void) {
   Str8 s4 = wapp_str8_lit("4");
   Str8 s5 = wapp_str8_lit("5");
 
-  Str8List list = {0};
-  Str8Node n1   = { .item = &s1 };
-  Str8Node n2   = { .item = &s2 };
-  Str8Node n3   = { .item = &s3 };
-  Str8Node n4   = { .item = &s4 };
-  Str8Node n5   = { .item = &s5 };
+  Str8List list = wapp_dbl_list(Str8, Str8List);
+  Str8Node n1   = wapp_str8_node_from_str8(s1);
+  Str8Node n2   = wapp_str8_node_from_str8(s2);
+  Str8Node n3   = wapp_str8_node_from_str8(s3);
+  Str8Node n4   = wapp_str8_node_from_str8(s4);
+  Str8Node n5   = wapp_str8_node_from_str8(s5);
 
-  wapp_str8_list_push_back(&list, &n1);
-  wapp_str8_list_push_back(&list, &n2);
-  wapp_str8_list_push_back(&list, &n3);
-  wapp_str8_list_push_back(&list, &n4);
-  wapp_str8_list_push_back(&list, &n5);
+  wapp_dbl_list_push_back(Str8, &list, &n1);
+  wapp_dbl_list_push_back(Str8, &list, &n2);
+  wapp_dbl_list_push_back(Str8, &list, &n3);
+  wapp_dbl_list_push_back(Str8, &list, &n4);
+  wapp_dbl_list_push_back(Str8, &list, &n5);
 
-  Str8Node *node = wapp_str8_list_pop_front(&list);
+  Str8Node *node = wapp_dbl_list_pop_front(Str8, Str8Node, &list);
   result = node == &n1 && node->item == &s1 && wapp_str8_equal(node->item, &s1) && wapp_str8_list_total_size(&list) == 4 && list.node_count == 4;
 
-  node = wapp_str8_list_pop_front(&list);
+  node = wapp_dbl_list_pop_front(Str8, Str8Node, &list);
   result = result && node == &n2 && node->item == &s2 && wapp_str8_equal(node->item, &s2) && wapp_str8_list_total_size(&list) == 3 && list.node_count == 3;
 
-  node = wapp_str8_list_pop_front(&list);
+  node = wapp_dbl_list_pop_front(Str8, Str8Node, &list);
   result = result && node == &n3 && node->item == &s3 && wapp_str8_equal(node->item, &s3) && wapp_str8_list_total_size(&list) == 2 && list.node_count == 2;
 
-  node = wapp_str8_list_pop_front(&list);
+  node = wapp_dbl_list_pop_front(Str8, Str8Node, &list);
   result = result && node == &n4 && node->item == &s4 && wapp_str8_equal(node->item, &s4) && wapp_str8_list_total_size(&list) == 1 && list.node_count == 1;
 
-  node = wapp_str8_list_pop_front(&list);
+  node = wapp_dbl_list_pop_front(Str8, Str8Node, &list);
   result = result && node == &n5 && node->item == &s5 && wapp_str8_equal(node->item, &s5) && wapp_str8_list_total_size(&list) == 0 && list.node_count == 0;
 
   return wapp_tester_result(result);
@@ -175,32 +175,32 @@ TestFuncResult test_str8_list_pop_back(void) {
   Str8 s4 = wapp_str8_lit("4");
   Str8 s5 = wapp_str8_lit("5");
 
-  Str8List list = {0};
-  Str8Node n1   = { .item = &s1 };
-  Str8Node n2   = { .item = &s2 };
-  Str8Node n3   = { .item = &s3 };
-  Str8Node n4   = { .item = &s4 };
-  Str8Node n5   = { .item = &s5 };
+  Str8List list = wapp_dbl_list(Str8, Str8List);
+  Str8Node n1   = wapp_str8_node_from_str8(s1);
+  Str8Node n2   = wapp_str8_node_from_str8(s2);
+  Str8Node n3   = wapp_str8_node_from_str8(s3);
+  Str8Node n4   = wapp_str8_node_from_str8(s4);
+  Str8Node n5   = wapp_str8_node_from_str8(s5);
 
-  wapp_str8_list_push_front(&list, &n1);
-  wapp_str8_list_push_front(&list, &n2);
-  wapp_str8_list_push_front(&list, &n3);
-  wapp_str8_list_push_front(&list, &n4);
-  wapp_str8_list_push_front(&list, &n5);
+  wapp_dbl_list_push_front(Str8, &list, &n1);
+  wapp_dbl_list_push_front(Str8, &list, &n2);
+  wapp_dbl_list_push_front(Str8, &list, &n3);
+  wapp_dbl_list_push_front(Str8, &list, &n4);
+  wapp_dbl_list_push_front(Str8, &list, &n5);
 
-  Str8Node *node = wapp_str8_list_pop_back(&list);
+  Str8Node *node = wapp_dbl_list_pop_back(Str8, Str8Node, &list);
   result = node == &n1 && node->item == &s1 && wapp_str8_equal(node->item, &s1) && wapp_str8_list_total_size(&list) == 4 && list.node_count == 4;
 
-  node = wapp_str8_list_pop_back(&list);
+  node = wapp_dbl_list_pop_back(Str8, Str8Node, &list);
   result = result && node == &n2 && node->item == &s2 && wapp_str8_equal(node->item, &s2) && wapp_str8_list_total_size(&list) == 3 && list.node_count == 3;
 
-  node = wapp_str8_list_pop_back(&list);
+  node = wapp_dbl_list_pop_back(Str8, Str8Node, &list);
   result = result && node == &n3 && node->item == &s3 && wapp_str8_equal(node->item, &s3) && wapp_str8_list_total_size(&list) == 2 && list.node_count == 2;
 
-  node = wapp_str8_list_pop_back(&list);
+  node = wapp_dbl_list_pop_back(Str8, Str8Node, &list);
   result = result && node == &n4 && node->item == &s4 && wapp_str8_equal(node->item, &s4) && wapp_str8_list_total_size(&list) == 1 && list.node_count == 1;
 
-  node = wapp_str8_list_pop_back(&list);
+  node = wapp_dbl_list_pop_back(Str8, Str8Node, &list);
   result = result && node == &n5 && node->item == &s5 && wapp_str8_equal(node->item, &s5) && wapp_str8_list_total_size(&list) == 0 && list.node_count == 0;
 
   return wapp_tester_result(result);
@@ -215,32 +215,32 @@ TestFuncResult test_str8_list_remove(void) {
   Str8 s4 = wapp_str8_lit("4");
   Str8 s5 = wapp_str8_lit("5");
 
-  Str8List list = {0};
-  Str8Node n1   = { .item = &s1 };
-  Str8Node n2   = { .item = &s2 };
-  Str8Node n3   = { .item = &s3 };
-  Str8Node n4   = { .item = &s4 };
-  Str8Node n5   = { .item = &s5 };
+  Str8List list = wapp_dbl_list(Str8, Str8List);
+  Str8Node n1   = wapp_str8_node_from_str8(s1);
+  Str8Node n2   = wapp_str8_node_from_str8(s2);
+  Str8Node n3   = wapp_str8_node_from_str8(s3);
+  Str8Node n4   = wapp_str8_node_from_str8(s4);
+  Str8Node n5   = wapp_str8_node_from_str8(s5);
 
-  wapp_str8_list_push_back(&list, &n1);
-  wapp_str8_list_push_back(&list, &n2);
-  wapp_str8_list_push_back(&list, &n3);
-  wapp_str8_list_push_back(&list, &n4);
-  wapp_str8_list_push_back(&list, &n5);
+  wapp_dbl_list_push_back(Str8, &list, &n1);
+  wapp_dbl_list_push_back(Str8, &list, &n2);
+  wapp_dbl_list_push_back(Str8, &list, &n3);
+  wapp_dbl_list_push_back(Str8, &list, &n4);
+  wapp_dbl_list_push_back(Str8, &list, &n5);
 
-  Str8Node *node = wapp_str8_list_remove(&list, 0);
+  Str8Node *node = wapp_dbl_list_remove(Str8, Str8Node, &list, 0);
   result = node == &n1 && node->item == &s1 && wapp_str8_equal(node->item, &s1) && wapp_str8_list_total_size(&list) == 4 && list.node_count == 4;
 
-  node = wapp_str8_list_remove(&list, 0);
+  node = wapp_dbl_list_remove(Str8, Str8Node, &list, 0);
   result = result && node == &n2 && node->item == &s2 && wapp_str8_equal(node->item, &s2) && wapp_str8_list_total_size(&list) == 3 && list.node_count == 3;
 
-  node = wapp_str8_list_remove(&list, 0);
+  node = wapp_dbl_list_remove(Str8, Str8Node, &list, 0);
   result = result && node == &n3 && node->item == &s3 && wapp_str8_equal(node->item, &s3) && wapp_str8_list_total_size(&list) == 2 && list.node_count == 2;
 
-  node = wapp_str8_list_remove(&list, 0);
+  node = wapp_dbl_list_remove(Str8, Str8Node, &list, 0);
   result = result && node == &n4 && node->item == &s4 && wapp_str8_equal(node->item, &s4) && wapp_str8_list_total_size(&list) == 1 && list.node_count == 1;
 
-  node = wapp_str8_list_remove(&list, 0);
+  node = wapp_dbl_list_remove(Str8, Str8Node, &list, 0);
   result = result && node == &n5 && node->item == &s5 && wapp_str8_equal(node->item, &s5) && wapp_str8_list_total_size(&list) == 0 && list.node_count == 0;
 
   return wapp_tester_result(result);
@@ -249,13 +249,13 @@ TestFuncResult test_str8_list_remove(void) {
 TestFuncResult test_str8_list_empty(void) {
   b8 result;
 
-  Str8List list = {0};
-  wapp_str8_list_push_back(&list, &wapp_str8_node_from_cstr("Hello"));
-  wapp_str8_list_push_back(&list, &wapp_str8_node_from_cstr("from"));
-  wapp_str8_list_push_back(&list, &wapp_str8_node_from_cstr("wizapp"));
-  wapp_str8_list_push_back(&list, &wapp_str8_node_from_cstr("stdlib"));
+  Str8List list = wapp_dbl_list(Str8, Str8List);
+  wapp_dbl_list_push_back(Str8, &list, &wapp_str8_node_from_cstr("Hello"));
+  wapp_dbl_list_push_back(Str8, &list, &wapp_str8_node_from_cstr("from"));
+  wapp_dbl_list_push_back(Str8, &list, &wapp_str8_node_from_cstr("wizapp"));
+  wapp_dbl_list_push_back(Str8, &list, &wapp_str8_node_from_cstr("stdlib"));
 
-  wapp_str8_list_empty(&list);
+  wapp_dbl_list_empty(Str8, &list);
 
   result = list.first == NULL && list.last == NULL && list.node_count == 0 && wapp_str8_list_total_size(&list) == 0;
 

tests/str8/test_str8_list.cc

@@ -10,32 +10,32 @@ TestFuncResult test_str8_list_get(void) {
   Str8 s4 = wapp_str8_lit("4");
   Str8 s5 = wapp_str8_lit("5");
 
-  Str8List list = {};
-  Str8Node n1   = { &s1, nullptr, nullptr };
-  Str8Node n2   = { &s2, nullptr, nullptr };
-  Str8Node n3   = { &s3, nullptr, nullptr };
-  Str8Node n4   = { &s4, nullptr, nullptr };
-  Str8Node n5   = { &s5, nullptr, nullptr };
+  Str8List list = wapp_dbl_list(Str8, Str8List);
+  Str8Node n1   = wapp_str8_node_from_str8(s1);
+  Str8Node n2   = wapp_str8_node_from_str8(s2);
+  Str8Node n3   = wapp_str8_node_from_str8(s3);
+  Str8Node n4   = wapp_str8_node_from_str8(s4);
+  Str8Node n5   = wapp_str8_node_from_str8(s5);
 
-  wapp_str8_list_push_back(&list, &n1);
-  wapp_str8_list_push_back(&list, &n2);
-  wapp_str8_list_push_back(&list, &n3);
-  wapp_str8_list_push_back(&list, &n4);
-  wapp_str8_list_push_back(&list, &n5);
+  wapp_dbl_list_push_back(Str8, &list, &n1);
+  wapp_dbl_list_push_back(Str8, &list, &n2);
+  wapp_dbl_list_push_back(Str8, &list, &n3);
+  wapp_dbl_list_push_back(Str8, &list, &n4);
+  wapp_dbl_list_push_back(Str8, &list, &n5);
 
-  Str8Node *node = wapp_str8_list_get(&list, 0);
+  Str8Node *node = wapp_dbl_list_get(Str8, Str8Node, &list, 0);
   result = node->item == &s1 && wapp_str8_equal(node->item, &s1);
 
-  node = wapp_str8_list_get(&list, 1);
+  node = wapp_dbl_list_get(Str8, Str8Node, &list, 1);
   result = result && node->item == &s2 && wapp_str8_equal(node->item, &s2);
 
-  node = wapp_str8_list_get(&list, 2);
+  node = wapp_dbl_list_get(Str8, Str8Node, &list, 2);
   result = result && node->item == &s3 && wapp_str8_equal(node->item, &s3);
 
-  node = wapp_str8_list_get(&list, 3);
+  node = wapp_dbl_list_get(Str8, Str8Node, &list, 3);
   result = result && node->item == &s4 && wapp_str8_equal(node->item, &s4);
 
-  node = wapp_str8_list_get(&list, 4);
+  node = wapp_dbl_list_get(Str8, Str8Node, &list, 4);
   result = result && node->item == &s5 && wapp_str8_equal(node->item, &s5);
 
   return wapp_tester_result(result);
@@ -48,18 +48,18 @@ TestFuncResult test_str8_list_push_front(void) {
   Str8 s2 = wapp_str8_lit("2");
   Str8 s3 = wapp_str8_lit("3");
 
-  Str8List list = {};
-  Str8Node n1   = { &s1, nullptr, nullptr };
-  Str8Node n2   = { &s2, nullptr, nullptr };
-  Str8Node n3   = { &s3, nullptr, nullptr };
+  Str8List list = wapp_dbl_list(Str8, Str8List);
+  Str8Node n1   = wapp_str8_node_from_str8(s1);
+  Str8Node n2   = wapp_str8_node_from_str8(s2);
+  Str8Node n3   = wapp_str8_node_from_str8(s3);
 
-  wapp_str8_list_push_front(&list, &n1);
+  wapp_dbl_list_push_front(Str8, &list, &n1);
   result = list.first == list.last && list.first == &n1 && list.first->item == &s1 && wapp_str8_list_total_size(&list) == 1 && list.node_count == 1;
 
-  wapp_str8_list_push_front(&list, &n2);
+  wapp_dbl_list_push_front(Str8, &list, &n2);
   result = result && list.first == &n2 && list.first->item == &s2 && wapp_str8_list_total_size(&list) == 2 && list.node_count == 2;
 
-  wapp_str8_list_push_front(&list, &n3);
+  wapp_dbl_list_push_front(Str8, &list, &n3);
   result = result && list.first == &n3 && list.first->item == &s3 && wapp_str8_list_total_size(&list) == 3 && list.node_count == 3;
 
   return wapp_tester_result(result);
@@ -72,18 +72,18 @@ TestFuncResult test_str8_list_push_back(void) {
   Str8 s2 = wapp_str8_lit("2");
   Str8 s3 = wapp_str8_lit("3");
 
-  Str8List list = {};
-  Str8Node n1   = { &s1, nullptr, nullptr };
-  Str8Node n2   = { &s2, nullptr, nullptr };
-  Str8Node n3   = { &s3, nullptr, nullptr };
+  Str8List list = wapp_dbl_list(Str8, Str8List);
+  Str8Node n1   = wapp_str8_node_from_str8(s1);
+  Str8Node n2   = wapp_str8_node_from_str8(s2);
+  Str8Node n3   = wapp_str8_node_from_str8(s3);
 
-  wapp_str8_list_push_back(&list, &n1);
+  wapp_dbl_list_push_back(Str8, &list, &n1);
   result = list.first == list.last && list.last == &n1 && list.last->item == &s1 && wapp_str8_list_total_size(&list) == 1 && list.node_count == 1;
 
-  wapp_str8_list_push_back(&list, &n2);
+  wapp_dbl_list_push_back(Str8, &list, &n2);
   result = result && list.last == &n2 && list.last->item == &s2 && wapp_str8_list_total_size(&list) == 2 && list.node_count == 2;
 
-  wapp_str8_list_push_back(&list, &n3);
+  wapp_dbl_list_push_back(Str8, &list, &n3);
   result = result && list.last == &n3 && list.last->item == &s3 && wapp_str8_list_total_size(&list) == 3 && list.node_count == 3;
 
   return wapp_tester_result(result);
@@ -100,27 +100,27 @@ TestFuncResult test_str8_list_insert(void) {
   Str8 s6 = wapp_str8_lit("6");
   Str8 s7 = wapp_str8_lit("7");
 
-  Str8List list = {};
-  Str8Node n1   = { &s1, nullptr, nullptr };
-  Str8Node n2   = { &s2, nullptr, nullptr };
-  Str8Node n3   = { &s3, nullptr, nullptr };
-  Str8Node n4   = { &s4, nullptr, nullptr };
-  Str8Node n5   = { &s5, nullptr, nullptr };
-  Str8Node n6   = { &s6, nullptr, nullptr };
-  Str8Node n7   = { &s7, nullptr, nullptr };
+  Str8List list = wapp_dbl_list(Str8, Str8List);
+  Str8Node n1   = wapp_str8_node_from_str8(s1);
+  Str8Node n2   = wapp_str8_node_from_str8(s2);
+  Str8Node n3   = wapp_str8_node_from_str8(s3);
+  Str8Node n4   = wapp_str8_node_from_str8(s4);
+  Str8Node n5   = wapp_str8_node_from_str8(s5);
+  Str8Node n6   = wapp_str8_node_from_str8(s6);
+  Str8Node n7   = wapp_str8_node_from_str8(s7);
 
-  wapp_str8_list_push_back(&list, &n1);
-  wapp_str8_list_push_back(&list, &n2);
-  wapp_str8_list_push_back(&list, &n3);
-  wapp_str8_list_push_back(&list, &n4);
-  wapp_str8_list_push_back(&list, &n5);
+  wapp_dbl_list_push_back(Str8, &list, &n1);
+  wapp_dbl_list_push_back(Str8, &list, &n2);
+  wapp_dbl_list_push_back(Str8, &list, &n3);
+  wapp_dbl_list_push_back(Str8, &list, &n4);
+  wapp_dbl_list_push_back(Str8, &list, &n5);
 
   Str8Node *node;
-  wapp_str8_list_insert(&list, &n6, 2);
-  node   = wapp_str8_list_get(&list, 2);
+  wapp_dbl_list_insert(Str8, &list, &n6, 2);
+  node   = wapp_dbl_list_get(Str8, Str8Node, &list, 2);
   result = node != NULL && node->item == &s6 && wapp_str8_list_total_size(&list) == 6 && list.node_count == 6;
-  wapp_str8_list_insert(&list, &n7, 5);
-  node   = wapp_str8_list_get(&list, 5);
+  wapp_dbl_list_insert(Str8, &list, &n7, 5);
+  node   = wapp_dbl_list_get(Str8, Str8Node, &list, 5);
   result = result && node != NULL && node->item == &s7 && wapp_str8_list_total_size(&list) == 7 && list.node_count == 7;
 
   return wapp_tester_result(result);
@@ -135,32 +135,32 @@ TestFuncResult test_str8_list_pop_front(void) {
   Str8 s4 = wapp_str8_lit("4");
   Str8 s5 = wapp_str8_lit("5");
 
-  Str8List list = {};
-  Str8Node n1   = { &s1, nullptr, nullptr };
-  Str8Node n2   = { &s2, nullptr, nullptr };
-  Str8Node n3   = { &s3, nullptr, nullptr };
-  Str8Node n4   = { &s4, nullptr, nullptr };
-  Str8Node n5   = { &s5, nullptr, nullptr };
+  Str8List list = wapp_dbl_list(Str8, Str8List);
+  Str8Node n1   = wapp_str8_node_from_str8(s1);
+  Str8Node n2   = wapp_str8_node_from_str8(s2);
+  Str8Node n3   = wapp_str8_node_from_str8(s3);
+  Str8Node n4   = wapp_str8_node_from_str8(s4);
+  Str8Node n5   = wapp_str8_node_from_str8(s5);
 
-  wapp_str8_list_push_back(&list, &n1);
-  wapp_str8_list_push_back(&list, &n2);
-  wapp_str8_list_push_back(&list, &n3);
-  wapp_str8_list_push_back(&list, &n4);
-  wapp_str8_list_push_back(&list, &n5);
+  wapp_dbl_list_push_back(Str8, &list, &n1);
+  wapp_dbl_list_push_back(Str8, &list, &n2);
+  wapp_dbl_list_push_back(Str8, &list, &n3);
+  wapp_dbl_list_push_back(Str8, &list, &n4);
+  wapp_dbl_list_push_back(Str8, &list, &n5);
 
-  Str8Node *node = wapp_str8_list_pop_front(&list);
+  Str8Node *node = wapp_dbl_list_pop_front(Str8, Str8Node, &list);
   result = node == &n1 && node->item == &s1 && wapp_str8_equal(node->item, &s1) && wapp_str8_list_total_size(&list) == 4 && list.node_count == 4;
 
-  node = wapp_str8_list_pop_front(&list);
+  node = wapp_dbl_list_pop_front(Str8, Str8Node, &list);
   result = result && node == &n2 && node->item == &s2 && wapp_str8_equal(node->item, &s2) && wapp_str8_list_total_size(&list) == 3 && list.node_count == 3;
 
-  node = wapp_str8_list_pop_front(&list);
+  node = wapp_dbl_list_pop_front(Str8, Str8Node, &list);
   result = result && node == &n3 && node->item == &s3 && wapp_str8_equal(node->item, &s3) && wapp_str8_list_total_size(&list) == 2 && list.node_count == 2;
 
-  node = wapp_str8_list_pop_front(&list);
+  node = wapp_dbl_list_pop_front(Str8, Str8Node, &list);
   result = result && node == &n4 && node->item == &s4 && wapp_str8_equal(node->item, &s4) && wapp_str8_list_total_size(&list) == 1 && list.node_count == 1;
 
-  node = wapp_str8_list_pop_front(&list);
+  node = wapp_dbl_list_pop_front(Str8, Str8Node, &list);
   result = result && node == &n5 && node->item == &s5 && wapp_str8_equal(node->item, &s5) && wapp_str8_list_total_size(&list) == 0 && list.node_count == 0;
 
   return wapp_tester_result(result);
@@ -175,32 +175,32 @@ TestFuncResult test_str8_list_pop_back(void) {
   Str8 s4 = wapp_str8_lit("4");
   Str8 s5 = wapp_str8_lit("5");
 
-  Str8List list = {};
-  Str8Node n1   = { &s1, nullptr, nullptr };
-  Str8Node n2   = { &s2, nullptr, nullptr };
-  Str8Node n3   = { &s3, nullptr, nullptr };
-  Str8Node n4   = { &s4, nullptr, nullptr };
-  Str8Node n5   = { &s5, nullptr, nullptr };
+  Str8List list = wapp_dbl_list(Str8, Str8List);
+  Str8Node n1   = wapp_str8_node_from_str8(s1);
+  Str8Node n2   = wapp_str8_node_from_str8(s2);
+  Str8Node n3   = wapp_str8_node_from_str8(s3);
+  Str8Node n4   = wapp_str8_node_from_str8(s4);
+  Str8Node n5   = wapp_str8_node_from_str8(s5);
 
-  wapp_str8_list_push_front(&list, &n1);
-  wapp_str8_list_push_front(&list, &n2);
-  wapp_str8_list_push_front(&list, &n3);
-  wapp_str8_list_push_front(&list, &n4);
-  wapp_str8_list_push_front(&list, &n5);
+  wapp_dbl_list_push_front(Str8, &list, &n1);
+  wapp_dbl_list_push_front(Str8, &list, &n2);
+  wapp_dbl_list_push_front(Str8, &list, &n3);
+  wapp_dbl_list_push_front(Str8, &list, &n4);
+  wapp_dbl_list_push_front(Str8, &list, &n5);
 
-  Str8Node *node = wapp_str8_list_pop_back(&list);
+  Str8Node *node = wapp_dbl_list_pop_back(Str8, Str8Node, &list);
   result = node == &n1 && node->item == &s1 && wapp_str8_equal(node->item, &s1) && wapp_str8_list_total_size(&list) == 4 && list.node_count == 4;
 
-  node = wapp_str8_list_pop_back(&list);
+  node = wapp_dbl_list_pop_back(Str8, Str8Node, &list);
   result = result && node == &n2 && node->item == &s2 && wapp_str8_equal(node->item, &s2) && wapp_str8_list_total_size(&list) == 3 && list.node_count == 3;
 
-  node = wapp_str8_list_pop_back(&list);
+  node = wapp_dbl_list_pop_back(Str8, Str8Node, &list);
   result = result && node == &n3 && node->item == &s3 && wapp_str8_equal(node->item, &s3) && wapp_str8_list_total_size(&list) == 2 && list.node_count == 2;
 
-  node = wapp_str8_list_pop_back(&list);
+  node = wapp_dbl_list_pop_back(Str8, Str8Node, &list);
   result = result && node == &n4 && node->item == &s4 && wapp_str8_equal(node->item, &s4) && wapp_str8_list_total_size(&list) == 1 && list.node_count == 1;
 
-  node = wapp_str8_list_pop_back(&list);
+  node = wapp_dbl_list_pop_back(Str8, Str8Node, &list);
   result = result && node == &n5 && node->item == &s5 && wapp_str8_equal(node->item, &s5) && wapp_str8_list_total_size(&list) == 0 && list.node_count == 0;
 
   return wapp_tester_result(result);
@@ -215,32 +215,32 @@ TestFuncResult test_str8_list_remove(void) {
   Str8 s4 = wapp_str8_lit("4");
   Str8 s5 = wapp_str8_lit("5");
 
-  Str8List list = {};
-  Str8Node n1   = { &s1, nullptr, nullptr };
-  Str8Node n2   = { &s2, nullptr, nullptr };
-  Str8Node n3   = { &s3, nullptr, nullptr };
-  Str8Node n4   = { &s4, nullptr, nullptr };
-  Str8Node n5   = { &s5, nullptr, nullptr };
+  Str8List list = wapp_dbl_list(Str8, Str8List);
+  Str8Node n1   = wapp_str8_node_from_str8(s1);
+  Str8Node n2   = wapp_str8_node_from_str8(s2);
+  Str8Node n3   = wapp_str8_node_from_str8(s3);
+  Str8Node n4   = wapp_str8_node_from_str8(s4);
+  Str8Node n5   = wapp_str8_node_from_str8(s5);
 
-  wapp_str8_list_push_back(&list, &n1);
-  wapp_str8_list_push_back(&list, &n2);
-  wapp_str8_list_push_back(&list, &n3);
-  wapp_str8_list_push_back(&list, &n4);
-  wapp_str8_list_push_back(&list, &n5);
+  wapp_dbl_list_push_back(Str8, &list, &n1);
+  wapp_dbl_list_push_back(Str8, &list, &n2);
+  wapp_dbl_list_push_back(Str8, &list, &n3);
+  wapp_dbl_list_push_back(Str8, &list, &n4);
+  wapp_dbl_list_push_back(Str8, &list, &n5);
 
-  Str8Node *node = wapp_str8_list_remove(&list, 0);
+  Str8Node *node = wapp_dbl_list_remove(Str8, Str8Node, &list, 0);
   result = node == &n1 && node->item == &s1 && wapp_str8_equal(node->item, &s1) && wapp_str8_list_total_size(&list) == 4 && list.node_count == 4;
 
-  node = wapp_str8_list_remove(&list, 0);
+  node = wapp_dbl_list_remove(Str8, Str8Node, &list, 0);
   result = result && node == &n2 && node->item == &s2 && wapp_str8_equal(node->item, &s2) && wapp_str8_list_total_size(&list) == 3 && list.node_count == 3;
 
-  node = wapp_str8_list_remove(&list, 0);
+  node = wapp_dbl_list_remove(Str8, Str8Node, &list, 0);
   result = result && node == &n3 && node->item == &s3 && wapp_str8_equal(node->item, &s3) && wapp_str8_list_total_size(&list) == 2 && list.node_count == 2;
 
-  node = wapp_str8_list_remove(&list, 0);
+  node = wapp_dbl_list_remove(Str8, Str8Node, &list, 0);
   result = result && node == &n4 && node->item == &s4 && wapp_str8_equal(node->item, &s4) && wapp_str8_list_total_size(&list) == 1 && list.node_count == 1;
 
-  node = wapp_str8_list_remove(&list, 0);
+  node = wapp_dbl_list_remove(Str8, Str8Node, &list, 0);
   result = result && node == &n5 && node->item == &s5 && wapp_str8_equal(node->item, &s5) && wapp_str8_list_total_size(&list) == 0 && list.node_count == 0;
 
   return wapp_tester_result(result);
@@ -249,21 +249,21 @@ TestFuncResult test_str8_list_remove(void) {
 TestFuncResult test_str8_list_empty(void) {
   b8 result;
 
-  Str8List list = {};
+  Str8List list = wapp_dbl_list(Str8, Str8List);
 
   Str8Node hello = wapp_str8_node_from_cstr("Hello");
-  wapp_str8_list_push_back(&list, &hello);
+  wapp_dbl_list_push_back(Str8, &list, &hello);
 
   Str8Node from = wapp_str8_node_from_cstr("from");
-  wapp_str8_list_push_back(&list, &from);
+  wapp_dbl_list_push_back(Str8, &list, &from);
 
   Str8Node wizapp = wapp_str8_node_from_cstr("wizapp");
-  wapp_str8_list_push_back(&list, &wizapp);
+  wapp_dbl_list_push_back(Str8, &list, &wizapp);
 
   Str8Node stdlib = wapp_str8_node_from_cstr("stdlib");
-  wapp_str8_list_push_back(&list, &stdlib);
+  wapp_dbl_list_push_back(Str8, &list, &stdlib);
 
-  wapp_str8_list_empty(&list);
+  wapp_dbl_list_empty(Str8, &list);
 
   result = list.first == NULL && list.last == NULL && list.node_count == 0 && wapp_str8_list_total_size(&list) == 0;