Makefile

@@ -1,5 +1,3 @@
-.PHONY: help full prng testing uuid core primitives all clean builddir build-test run-test codegen install build-lib ccodegen
-
 # External variables
 CC             = clang
 CXX            = clang++
@@ -31,11 +29,11 @@ override LIB_INSTALL        := $(ABS_INSTALL_PREFIX)/lib
 override HEADER_INSTALL_CMD := scripts/header_install.sh
 
 ifeq ($(BUILD_TYPE),Debug)
-	override CFLAGS += -g -fsanitize=address,undefined -DWAPP_DEBUG_ASSERT
+	CFLAGS += -g -fsanitize=address,undefined -DWAPP_DEBUG_ASSERT
 else ifeq ($(BUILD_TYPE),RelWithDebInfo)
-	override CFLAGS += -g -O2 -fsanitize=address,undefined -DWAPP_DEBUG_ASSERT
+	CFLAGS += -g -O2 -fsanitize=address,undefined -DWAPP_DEBUG_ASSERT
 else ifeq ($(BUILD_TYPE),Release)
-	override CFLAGS += -O3
+	CFLAGS += -O3
 else
 	$(error Invalid BUILD type '$(BUILD_TYPE)'. Use 'Debug', 'RelWithDebInfo' or 'Release')
 endif
@@ -45,7 +43,9 @@ ifeq ($(CC),gcc)
   export ASAN_OPTIONS=verify_asan_link_order=0
 endif
 
-all: clean builddir codegen run-c-test full run-cc-test ccodegen
+.PHONY: help full prng testing uuid core primitives all clean builddir build-test run-test codegen install build-lib
+
+all: clean builddir codegen run-c-test full run-cc-test
 
 help:
 	@echo "Available build variables:"
@@ -126,6 +126,3 @@ build-lib: builddir
 	$(CC) -c $(CSTD) $(CFLAGS) $(LIBFLAGS) $(LIB_SRC) -o $(OBJ_OUT)
 	$(AR) r $(LIB_OUT) $(OBJ_OUT)
 	@rm $(OBJ_OUT)
-
-ccodegen:
-	$(CC) $(CSTD) $(CFLAGS) $(LIBFLAGS) -Isrc/core src/core/wapp_core.c ccodegen/*.c -o ccgen

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 _internal = wapp_str8_lit_ro("internal ");
-  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);
-}
-
-b32 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;
-  b32 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;
-  b32 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;
-  b32 is_local;
-  b32 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);
-b32 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_BOOL,
-  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;
-internal Str8RO ctypes[COUNT_CTYPE] = {
-  [CTYPE_VOID] = wapp_str8_lit_ro("void"),
-  [CTYPE_BOOL] = wapp_str8_lit_ro("b32"),
-  [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;
-internal Str8RO cqualifiers[COUNT_CQUALIFIER] = {
-  [CQUALIFIER_NONE]       = wapp_str8_lit_ro(""),
-  [CQUALIFIER_CONST]      = wapp_str8_lit_ro("const "),
-  [CQUALIFIER_EXTERNAL]   = wapp_str8_lit_ro("external "),
-  [CQUALIFIER_INTERNAL]   = wapp_str8_lit_ro("internal "),
-  [CQUALIFIER_PERSISTENT] = wapp_str8_lit_ro("persistent "),
-};
-
-
-typedef enum {
-  CPOINTERTYPE_NONE,
-  CPOINTERTYPE_SINGLE,
-  CPOINTERTYPE_DOUBLE,
-
-  COUNT_CPOINTERTYPE,
-} CPointerType;
-internal 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/array/make_array.py

@@ -54,6 +54,10 @@ def make_array(user_datatypes: Dict[CDataType, ArrayData] = {}):
     out_dir.mkdir(parents=True, exist_ok=True)
 
     common_includes: List[CInclude] = [
+        CInclude(
+            header=str(convert_to_relative(WAPP_SRC_ROOT / "common" / "aliases" / "aliases.h", out_dir)).replace("\\", "/"),
+            local=True,
+        ),
         CInclude(
             header=str(convert_to_relative(WAPP_SRC_ROOT / "primitives" / "mem_allocator" / "mem_allocator.h", out_dir)).replace("\\", "/"),
             local=True,
@@ -104,11 +108,11 @@ def make_array(user_datatypes: Dict[CDataType, ArrayData] = {}):
         decl_types=[*common_decl_types],
         includes=[
             CInclude(header, local=True, same_dir=True),
+            CInclude(header="stddef.h"),
             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

codegen/datatypes.py

@@ -344,7 +344,7 @@ class CFile(SerialisableDataclass):
     def __str__(self) -> str:
         return """\
 /**
- * THIS FILE IS AUTOMATICALLY GENERATED. ANY MODIFICATIONS TO IT WILL BE OVERWRITTEN.
+ * THIS FILE IS AUTOMATICALLY GENERATED. ANY MODIFICATIONS TO IT WILL BE OVERWRITTEN
  */
 
 """

codegen/dbl_list/make_dbl_list.py

@@ -56,6 +56,13 @@ def make_dbl_list(user_datatypes: Dict[CDataType, DblListData] = {}):
     out_dir = WAPP_SRC_ROOT / "primitives" / "dbl_list"
     out_dir.mkdir(parents=True, exist_ok=True)
 
+    common_includes: List[CInclude] = [
+        CInclude(
+            header=str(convert_to_relative(WAPP_SRC_ROOT / "common" / "aliases" / "aliases.h", out_dir)).replace("\\", "/"),
+            local=True,
+        )
+    ]
+
     common_decl_types: List[CStruct] = []
 
     datatypes: dict[CDataType, DblListData] = {
@@ -104,11 +111,16 @@ def make_dbl_list(user_datatypes: Dict[CDataType, DblListData] = {}):
                 local=True
             ),
             CInclude(header="stddef.h"),
+            CInclude(header="assert.h"),
         ],
         internal_funcs=[],
         funcs=header.funcs
     )
 
+    if len(common_includes) > 0:
+        header.includes.extend(common_includes)
+        source.includes.extend(common_includes)
+
     for _type, dbl_list_data in datatypes.items():
         type_string = get_datatype_string(_type)
         clean_type_string = type_string.replace(" ", "").replace("*", "_ptr")

src/primitives/array/array.c

@@ -1,9 +1,10 @@
 /**
- * THIS FILE IS AUTOMATICALLY GENERATED. ANY MODIFICATIONS TO IT WILL BE OVERWRITTEN.
+ * THIS FILE IS AUTOMATICALLY GENERATED. ANY MODIFICATIONS TO IT WILL BE OVERWRITTEN
  */
 
 #include "./array.h"
 #include "../../common/assert/assert.h"
+#include "../../common/aliases/aliases.h"
 #include "../mem_allocator/mem_allocator.h"
 #include "../../common/misc/misc_utils.h"
 #include "../../common/aliases/aliases.h"

src/primitives/array/array.h

@@ -1,10 +1,11 @@
 /**
- * THIS FILE IS AUTOMATICALLY GENERATED. ANY MODIFICATIONS TO IT WILL BE OVERWRITTEN.
+ * THIS FILE IS AUTOMATICALLY GENERATED. ANY MODIFICATIONS TO IT WILL BE OVERWRITTEN
  */
 
 #ifndef ARRAY_H
 #define ARRAY_H
 
+#include "../../common/aliases/aliases.h"
 #include "../mem_allocator/mem_allocator.h"
 #include "../../common/misc/misc_utils.h"
 #include "../../common/aliases/aliases.h"

src/primitives/dbl_list/dbl_list.c

@@ -1,12 +1,14 @@
 /**
- * THIS FILE IS AUTOMATICALLY GENERATED. ANY MODIFICATIONS TO IT WILL BE OVERWRITTEN.
+ * THIS FILE IS AUTOMATICALLY GENERATED. ANY MODIFICATIONS TO IT WILL BE OVERWRITTEN
  */
 
 #include "./dbl_list.h"
 #include "../../common/assert/assert.h"
 #include "../../common/aliases/aliases.h"
+#include "../../common/aliases/aliases.h"
 #include "../../common/platform/platform.h"
 #include <stddef.h>
+#include <assert.h>
 
 internal Str8List str8_node_to_list(Str8Node *node);
 internal VoidPList void_ptr_node_to_list(VoidPNode *node);

src/primitives/dbl_list/dbl_list.h

@@ -1,10 +1,11 @@
 /**
- * THIS FILE IS AUTOMATICALLY GENERATED. ANY MODIFICATIONS TO IT WILL BE OVERWRITTEN.
+ * THIS FILE IS AUTOMATICALLY GENERATED. ANY MODIFICATIONS TO IT WILL BE OVERWRITTEN
  */
 
 #ifndef DBL_LIST_H
 #define DBL_LIST_H
 
+#include "../../common/aliases/aliases.h"
 #include "../../common/aliases/aliases.h"
 #include "../../common/platform/platform.h"
 

src/primitives/strings/str8/str8.c

@@ -4,7 +4,6 @@
 #include "../../../common/aliases/aliases.h"
 #include "../../../common/assert/assert.h"
 #include "../../mem_allocator/mem_allocator.h"
-#include <ctype.h>
 #include <stdarg.h>
 #include <stddef.h>
 #include <stdio.h>
@@ -164,7 +163,7 @@ Str8 *wapp_str8_alloc_concat(const Allocator *allocator, Str8 *dst, Str8RO *src)
   u64 remaining = dst->capacity - dst->size;
   if (src->size <= remaining) {
     output = dst;
-    goto SOURCE_STRING_STR8_CONCAT;
+    goto COPY_STRING_STR8_CONCAT;
   }
 
   u64 capacity = dst->capacity + src->size;
@@ -176,7 +175,7 @@ Str8 *wapp_str8_alloc_concat(const Allocator *allocator, Str8 *dst, Str8RO *src)
 
   wapp_str8_concat_capped(output, dst);
 
-SOURCE_STRING_STR8_CONCAT:
+COPY_STRING_STR8_CONCAT:
   wapp_str8_concat_capped(output, src);
 
 RETURN_STR8_CONCAT:
@@ -241,26 +240,6 @@ void wapp_str8_format(Str8 *dst, const char *format, ...) {
   va_end(args2);
 }
 
-void wapp_str8_to_lower(Str8 *dst, Str8RO *src) {
-  wapp_debug_assert(src != NULL && dst != NULL, "`dst` and `src` should not be NULL");
-  wapp_debug_assert(dst->capacity >= src->capacity, "`dst` does not have enough capacity");
-
-  dst->size = src->size;
-  for (u64 i = 0; i < src->size; ++i) {
-    wapp_str8_set(dst, i, tolower(wapp_str8_get(src, i)));
-  }
-}
-
-void wapp_str8_to_upper(Str8 *dst, Str8RO *src) {
-  wapp_debug_assert(src != NULL && dst != NULL, "`dst` and `src` should not be NULL");
-  wapp_debug_assert(dst->capacity >= src->capacity, "`dst` does not have enough capacity");
-
-  dst->size = src->size;
-  for (u64 i = 0; i < src->size; ++i) {
-    wapp_str8_set(dst, i, toupper(wapp_str8_get(src, i)));
-  }
-}
-
 i64 wapp_str8_find(Str8RO *str, Str8RO substr) {
   if (!str || substr.size > str->size) {
     return -1;

src/primitives/strings/str8/str8.h

@@ -97,8 +97,6 @@ void wapp_str8_copy_cstr_capped(Str8 *dst, const char *src);
 void wapp_str8_copy_str8_capped(Str8 *dst, Str8RO *src);
 void wapp_str8_copy_to_cstr(char *dst, Str8RO *src, u64 dst_capacity);
 void wapp_str8_format(Str8 *dst, const char *format, ...);
-void wapp_str8_to_lower(Str8 *dst, Str8RO *src);
-void wapp_str8_to_upper(Str8 *dst, Str8RO *src);
 
 /**
  * Str8 find functions