From 14bd6ce5fd40fdb8e9b5eb445eedd8a139ba417c Mon Sep 17 00:00:00 2001 From: Abdelrahman Date: Sat, 20 Sep 2025 13:48:08 +0000 Subject: [PATCH] File utilities and datatype implementation for a C-based code generator (#5) Co-authored-by: Abdelrahman Said Reviewed-on: http://git.thewizardapprentice.com/abdelrahman/wizapp-stdlib/pulls/5 Co-authored-by: Abdelrahman Co-committed-by: Abdelrahman --- Makefile | 13 +- ccodegen/datatypes.c | 522 ++++++ ccodegen/datatypes.h | 280 +++ ccodegen/dbl_list.c | 1526 +++++++++++++++++ ccodegen/dbl_list.h | 222 +++ ccodegen/main.c | 10 + ccodegen/type_enums.h | 84 + codegen/array/make_array.py | 522 +++--- codegen/array/snippets/alloc_capacity | 2 +- codegen/datatypes.py | 2 +- codegen/dbl_list/make_dbl_list.py | 30 +- src/core/file/file.c | 103 ++ src/core/file/file.h | 72 + src/core/mem/arena/mem_arena.c | 7 +- src/core/mem/arena/mem_arena.h | 3 +- src/core/mem/arena/mem_arena_allocator.c | 4 +- src/core/mem/arena/mem_arena_allocator.h | 3 +- src/core/mem/utils/mem_utils.c | 3 +- src/core/os/cpath/cpath.c | 21 +- src/core/os/cpath/cpath.h | 8 +- src/core/os/mem/mem_os.c | 1 - src/core/os/shell/commander/commander.c | 1 - src/core/os/shell/commander/commander.h | 1 - .../os/shell/commander/commander_output.h | 5 +- src/core/wapp_core.c | 1 + src/core/wapp_core.h | 1 + src/primitives/array/array.c | 311 ++-- src/primitives/array/array.h | 97 +- src/primitives/dbl_list/dbl_list.c | 360 ++-- src/primitives/dbl_list/dbl_list.h | 55 +- src/primitives/strings/str8/str8.c | 50 +- src/primitives/strings/str8/str8.h | 9 +- src/prng/xorshift/xorshift.c | 3 +- src/testing/tester/tester.h | 5 +- src/uuid/uuid.c | 3 +- tests/allocator/test_allocator.c | 3 +- tests/allocator/test_allocator.cc | 3 +- tests/arena/test_arena.c | 13 +- tests/arena/test_arena.cc | 13 +- tests/array/test_i32_array.c | 39 +- tests/array/test_i32_array.cc | 39 +- tests/cpath/test_cpath.c | 51 +- tests/cpath/test_cpath.cc | 51 +- tests/shell_commander/test_shell_commander.c | 9 +- tests/shell_commander/test_shell_commander.cc | 9 +- tests/str8/test_str8.c | 76 +- tests/str8/test_str8.cc | 77 +- tests/str8/test_str8.h | 1 + tests/str8/test_str8_list.c | 16 +- tests/str8/test_str8_list.cc | 16 +- tests/wapptest.c | 1 + tests/wapptest.cc | 1 + 52 files changed, 3814 insertions(+), 944 deletions(-) create mode 100644 ccodegen/datatypes.c create mode 100644 ccodegen/datatypes.h create mode 100644 ccodegen/dbl_list.c create mode 100644 ccodegen/dbl_list.h create mode 100644 ccodegen/main.c create mode 100644 ccodegen/type_enums.h create mode 100644 src/core/file/file.c create mode 100644 src/core/file/file.h diff --git a/Makefile b/Makefile index 10168e9..a432c0e 100644 --- a/Makefile +++ b/Makefile @@ -1,3 +1,5 @@ +.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++ @@ -29,11 +31,11 @@ override LIB_INSTALL := $(ABS_INSTALL_PREFIX)/lib override HEADER_INSTALL_CMD := scripts/header_install.sh ifeq ($(BUILD_TYPE),Debug) - CFLAGS += -g -fsanitize=address,undefined -DWAPP_DEBUG_ASSERT + override CFLAGS += -g -fsanitize=address,undefined -DWAPP_DEBUG_ASSERT else ifeq ($(BUILD_TYPE),RelWithDebInfo) - CFLAGS += -g -O2 -fsanitize=address,undefined -DWAPP_DEBUG_ASSERT + override CFLAGS += -g -O2 -fsanitize=address,undefined -DWAPP_DEBUG_ASSERT else ifeq ($(BUILD_TYPE),Release) - CFLAGS += -O3 + override CFLAGS += -O3 else $(error Invalid BUILD type '$(BUILD_TYPE)'. Use 'Debug', 'RelWithDebInfo' or 'Release') endif @@ -43,8 +45,6 @@ ifeq ($(CC),gcc) export ASAN_OPTIONS=verify_asan_link_order=0 endif -.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: @@ -126,3 +126,6 @@ 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 diff --git a/ccodegen/datatypes.c b/ccodegen/datatypes.c new file mode 100644 index 0000000..454bc80 --- /dev/null +++ b/ccodegen/datatypes.c @@ -0,0 +1,522 @@ +// 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; +} diff --git a/ccodegen/datatypes.h b/ccodegen/datatypes.h new file mode 100644 index 0000000..8b89a9d --- /dev/null +++ b/ccodegen/datatypes.h @@ -0,0 +1,280 @@ +// 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 diff --git a/ccodegen/dbl_list.c b/ccodegen/dbl_list.c new file mode 100644 index 0000000..d479933 --- /dev/null +++ b/ccodegen/dbl_list.c @@ -0,0 +1,1526 @@ +// vim:fileencoding=utf-8:foldmethod=marker + +#include "./dbl_list.h" +#include "wapp_core.h" +#include + +internal CEnumValList cenumval_node_to_list(CEnumValNode *node); +internal CArgList carg_node_to_list(CArgNode *node); +internal CQualifierList cqualifier_node_to_list(CQualifierNode *node); +internal CIncludeList cinclude_node_to_list(CIncludeNode *node); +internal CUserTypeList cusertype_node_to_list(CUserTypeNode *node); +internal CFuncList cfunc_node_to_list(CFuncNode *node); +internal CStructList cstruct_node_to_list(CStructNode *node); +internal CMacroList cmacro_node_to_list(CMacroNode *node); + +CEnumValNode *wapp_cenumval_list_get(const CEnumValList *list, u64 index) { + wapp_runtime_assert(index < list->node_count, "`index` is out of bounds"); + + CEnumValNode *output = NULL; + CEnumValNode *current = list->first; + for (u64 i = 1; i <= index; ++i) { + current = current->next; + } + + output = current; + + return output; +} + +void wapp_cenumval_list_push_front(CEnumValList *list, CEnumValNode *node) { + wapp_debug_assert(list != NULL && node != NULL && (node->item) != NULL, "`list`, `node` and `node->item` should not be NULL"); + + CEnumValList node_list = cenumval_node_to_list(node); + + if (list->node_count == 0) { + *list = node_list; + return; + } + + list->node_count += node_list.node_count; + + CEnumValNode *first = list->first; + if (first) { + first->prev = node_list.last; + } + + list->first = node_list.first; + node_list.last->next = first; +} + +void wapp_cenumval_list_push_back(CEnumValList *list, CEnumValNode *node) { + wapp_debug_assert(list != NULL && node != NULL && (node->item) != NULL, "`list`, `node` and `node->item` should not be NULL"); + + CEnumValList node_list = cenumval_node_to_list(node); + + if (list->node_count == 0) { + *list = node_list; + return; + } + + list->node_count += node_list.node_count; + + CEnumValNode *last = list->last; + if (last) { + last->next = node_list.first; + } + + list->last = node_list.last; + node_list.first->prev = last; +} + +void wapp_cenumval_list_insert(CEnumValList *list, CEnumValNode *node, u64 index) { + wapp_debug_assert(list != NULL && node != NULL && (node->item) != NULL, "`list`, `node` and `node->item` should not be NULL"); + + if (index == 0) { + wapp_cenumval_list_push_front(list, node); + return; + } else if (index == list->node_count) { + wapp_cenumval_list_push_back(list, node); + return; + } + + CEnumValNode *dst_node = wapp_cenumval_list_get(list, index); + if (!dst_node) { + return; + } + + CEnumValList node_list = cenumval_node_to_list(node); + + list->node_count += node_list.node_count; + + CEnumValNode *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; +} + +CEnumValNode *wapp_cenumval_list_pop_front(CEnumValList *list) { + wapp_debug_assert(list != NULL, "`list` should not be NULL"); + + CEnumValNode *output = NULL; + + if (list->node_count == 0) { + goto RETURN_CENUMVAL_LIST_POP_FRONT; + } + + output = list->first; + + if (list->node_count == 1) { + *list = (CEnumValList){0}; + goto RETURN_CENUMVAL_LIST_POP_FRONT; + } + + --(list->node_count); + list->first = output->next; + + output->prev = output->next = NULL; + +RETURN_CENUMVAL_LIST_POP_FRONT: + return output; +} + +CEnumValNode *wapp_cenumval_list_pop_back(CEnumValList *list) { + wapp_debug_assert(list != NULL, "`list` should not be NULL"); + + CEnumValNode *output = NULL; + + if (list->node_count == 0) { + goto RETURN_CENUMVAL_LIST_POP_BACK; + } + + output = list->last; + + if (list->node_count == 1) { + *list = (CEnumValList){0}; + goto RETURN_CENUMVAL_LIST_POP_BACK; + } + + --(list->node_count); + list->last = output->prev; + + output->prev = output->next = NULL; + +RETURN_CENUMVAL_LIST_POP_BACK: + return output; +} + +CEnumValNode *wapp_cenumval_list_remove(CEnumValList *list, u64 index) { + wapp_debug_assert(list != NULL, "`list` should not be NULL"); + + CEnumValNode *output = NULL; + + if (index == 0) { + output = wapp_cenumval_list_pop_front(list); + goto RETURN_CENUMVAL_LIST_REMOVE; + } else if (index == list->node_count) { + output = wapp_cenumval_list_pop_back(list); + goto RETURN_CENUMVAL_LIST_REMOVE; + } + + output = wapp_cenumval_list_get(list, index); + if (!output) { + goto RETURN_CENUMVAL_LIST_REMOVE; + } + + output->prev->next = output->next; + output->next->prev = output->prev; + + --(list->node_count); + + output->prev = output->next = NULL; + +RETURN_CENUMVAL_LIST_REMOVE: + return output; +} + +void wapp_cenumval_list_empty(CEnumValList *list) { + wapp_debug_assert(list != NULL, "`list` should not be NULL"); + + u64 count = list->node_count; + for (u64 i = 0; i < count; ++i) { + wapp_cenumval_list_pop_back(list); + } +} + +CArgNode *wapp_carg_list_get(const CArgList *list, u64 index) { + wapp_runtime_assert(index < list->node_count, "`index` is out of bounds"); + + CArgNode *output = NULL; + CArgNode *current = list->first; + for (u64 i = 1; i <= index; ++i) { + current = current->next; + } + + output = current; + + return output; +} + +void wapp_carg_list_push_front(CArgList *list, CArgNode *node) { + wapp_debug_assert(list != NULL && node != NULL && (node->item) != NULL, "`list`, `node` and `node->item` should not be NULL"); + + CArgList node_list = carg_node_to_list(node); + + if (list->node_count == 0) { + *list = node_list; + return; + } + + list->node_count += node_list.node_count; + + CArgNode *first = list->first; + if (first) { + first->prev = node_list.last; + } + + list->first = node_list.first; + node_list.last->next = first; +} + +void wapp_carg_list_push_back(CArgList *list, CArgNode *node) { + wapp_debug_assert(list != NULL && node != NULL && (node->item) != NULL, "`list`, `node` and `node->item` should not be NULL"); + + CArgList node_list = carg_node_to_list(node); + + if (list->node_count == 0) { + *list = node_list; + return; + } + + list->node_count += node_list.node_count; + + CArgNode *last = list->last; + if (last) { + last->next = node_list.first; + } + + list->last = node_list.last; + node_list.first->prev = last; +} + +void wapp_carg_list_insert(CArgList *list, CArgNode *node, u64 index) { + wapp_debug_assert(list != NULL && node != NULL && (node->item) != NULL, "`list`, `node` and `node->item` should not be NULL"); + + if (index == 0) { + wapp_carg_list_push_front(list, node); + return; + } else if (index == list->node_count) { + wapp_carg_list_push_back(list, node); + return; + } + + CArgNode *dst_node = wapp_carg_list_get(list, index); + if (!dst_node) { + return; + } + + CArgList node_list = carg_node_to_list(node); + + list->node_count += node_list.node_count; + + CArgNode *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; +} + +CArgNode *wapp_carg_list_pop_front(CArgList *list) { + wapp_debug_assert(list != NULL, "`list` should not be NULL"); + + CArgNode *output = NULL; + + if (list->node_count == 0) { + goto RETURN_CARG_LIST_POP_FRONT; + } + + output = list->first; + + if (list->node_count == 1) { + *list = (CArgList){0}; + goto RETURN_CARG_LIST_POP_FRONT; + } + + --(list->node_count); + list->first = output->next; + + output->prev = output->next = NULL; + +RETURN_CARG_LIST_POP_FRONT: + return output; +} + +CArgNode *wapp_carg_list_pop_back(CArgList *list) { + wapp_debug_assert(list != NULL, "`list` should not be NULL"); + + CArgNode *output = NULL; + + if (list->node_count == 0) { + goto RETURN_CARG_LIST_POP_BACK; + } + + output = list->last; + + if (list->node_count == 1) { + *list = (CArgList){0}; + goto RETURN_CARG_LIST_POP_BACK; + } + + --(list->node_count); + list->last = output->prev; + + output->prev = output->next = NULL; + +RETURN_CARG_LIST_POP_BACK: + return output; +} + +CArgNode *wapp_carg_list_remove(CArgList *list, u64 index) { + wapp_debug_assert(list != NULL, "`list` should not be NULL"); + + CArgNode *output = NULL; + + if (index == 0) { + output = wapp_carg_list_pop_front(list); + goto RETURN_CARG_LIST_REMOVE; + } else if (index == list->node_count) { + output = wapp_carg_list_pop_back(list); + goto RETURN_CARG_LIST_REMOVE; + } + + output = wapp_carg_list_get(list, index); + if (!output) { + goto RETURN_CARG_LIST_REMOVE; + } + + output->prev->next = output->next; + output->next->prev = output->prev; + + --(list->node_count); + + output->prev = output->next = NULL; + +RETURN_CARG_LIST_REMOVE: + return output; +} + +void wapp_carg_list_empty(CArgList *list) { + wapp_debug_assert(list != NULL, "`list` should not be NULL"); + + u64 count = list->node_count; + for (u64 i = 0; i < count; ++i) { + wapp_carg_list_pop_back(list); + } +} + +CQualifierNode *wapp_cqualifier_list_get(const CQualifierList *list, u64 index) { + wapp_runtime_assert(index < list->node_count, "`index` is out of bounds"); + + CQualifierNode *output = NULL; + CQualifierNode *current = list->first; + for (u64 i = 1; i <= index; ++i) { + current = current->next; + } + + output = current; + + return output; +} + +void wapp_cqualifier_list_push_front(CQualifierList *list, CQualifierNode *node) { + wapp_debug_assert(list != NULL && node != NULL && (node->item) != NULL, "`list`, `node` and `node->item` should not be NULL"); + + CQualifierList node_list = cqualifier_node_to_list(node); + + if (list->node_count == 0) { + *list = node_list; + return; + } + + list->node_count += node_list.node_count; + + CQualifierNode *first = list->first; + if (first) { + first->prev = node_list.last; + } + + list->first = node_list.first; + node_list.last->next = first; +} + +void wapp_cqualifier_list_push_back(CQualifierList *list, CQualifierNode *node) { + wapp_debug_assert(list != NULL && node != NULL && (node->item) != NULL, "`list`, `node` and `node->item` should not be NULL"); + + CQualifierList node_list = cqualifier_node_to_list(node); + + if (list->node_count == 0) { + *list = node_list; + return; + } + + list->node_count += node_list.node_count; + + CQualifierNode *last = list->last; + if (last) { + last->next = node_list.first; + } + + list->last = node_list.last; + node_list.first->prev = last; +} + +void wapp_cqualifier_list_insert(CQualifierList *list, CQualifierNode *node, u64 index) { + wapp_debug_assert(list != NULL && node != NULL && (node->item) != NULL, "`list`, `node` and `node->item` should not be NULL"); + + if (index == 0) { + wapp_cqualifier_list_push_front(list, node); + return; + } else if (index == list->node_count) { + wapp_cqualifier_list_push_back(list, node); + return; + } + + CQualifierNode *dst_node = wapp_cqualifier_list_get(list, index); + if (!dst_node) { + return; + } + + CQualifierList node_list = cqualifier_node_to_list(node); + + list->node_count += node_list.node_count; + + CQualifierNode *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; +} + +CQualifierNode *wapp_cqualifier_list_pop_front(CQualifierList *list) { + wapp_debug_assert(list != NULL, "`list` should not be NULL"); + + CQualifierNode *output = NULL; + + if (list->node_count == 0) { + goto RETURN_CQUALIFIER_LIST_POP_FRONT; + } + + output = list->first; + + if (list->node_count == 1) { + *list = (CQualifierList){0}; + goto RETURN_CQUALIFIER_LIST_POP_FRONT; + } + + --(list->node_count); + list->first = output->next; + + output->prev = output->next = NULL; + +RETURN_CQUALIFIER_LIST_POP_FRONT: + return output; +} + +CQualifierNode *wapp_cqualifier_list_pop_back(CQualifierList *list) { + wapp_debug_assert(list != NULL, "`list` should not be NULL"); + + CQualifierNode *output = NULL; + + if (list->node_count == 0) { + goto RETURN_CQUALIFIER_LIST_POP_BACK; + } + + output = list->last; + + if (list->node_count == 1) { + *list = (CQualifierList){0}; + goto RETURN_CQUALIFIER_LIST_POP_BACK; + } + + --(list->node_count); + list->last = output->prev; + + output->prev = output->next = NULL; + +RETURN_CQUALIFIER_LIST_POP_BACK: + return output; +} + +CQualifierNode *wapp_cqualifier_list_remove(CQualifierList *list, u64 index) { + wapp_debug_assert(list != NULL, "`list` should not be NULL"); + + CQualifierNode *output = NULL; + + if (index == 0) { + output = wapp_cqualifier_list_pop_front(list); + goto RETURN_CQUALIFIER_LIST_REMOVE; + } else if (index == list->node_count) { + output = wapp_cqualifier_list_pop_back(list); + goto RETURN_CQUALIFIER_LIST_REMOVE; + } + + output = wapp_cqualifier_list_get(list, index); + if (!output) { + goto RETURN_CQUALIFIER_LIST_REMOVE; + } + + output->prev->next = output->next; + output->next->prev = output->prev; + + --(list->node_count); + + output->prev = output->next = NULL; + +RETURN_CQUALIFIER_LIST_REMOVE: + return output; +} + +void wapp_cqualifier_list_empty(CQualifierList *list) { + wapp_debug_assert(list != NULL, "`list` should not be NULL"); + + u64 count = list->node_count; + for (u64 i = 0; i < count; ++i) { + wapp_cqualifier_list_pop_back(list); + } +} + +CIncludeNode *wapp_cinclude_list_get(const CIncludeList *list, u64 index) { + wapp_runtime_assert(index < list->node_count, "`index` is out of bounds"); + + CIncludeNode *output = NULL; + CIncludeNode *current = list->first; + for (u64 i = 1; i <= index; ++i) { + current = current->next; + } + + output = current; + + return output; +} + +void wapp_cinclude_list_push_front(CIncludeList *list, CIncludeNode *node) { + wapp_debug_assert(list != NULL && node != NULL && (node->item) != NULL, "`list`, `node` and `node->item` should not be NULL"); + + CIncludeList node_list = cinclude_node_to_list(node); + + if (list->node_count == 0) { + *list = node_list; + return; + } + + list->node_count += node_list.node_count; + + CIncludeNode *first = list->first; + if (first) { + first->prev = node_list.last; + } + + list->first = node_list.first; + node_list.last->next = first; +} + +void wapp_cinclude_list_push_back(CIncludeList *list, CIncludeNode *node) { + wapp_debug_assert(list != NULL && node != NULL && (node->item) != NULL, "`list`, `node` and `node->item` should not be NULL"); + + CIncludeList node_list = cinclude_node_to_list(node); + + if (list->node_count == 0) { + *list = node_list; + return; + } + + list->node_count += node_list.node_count; + + CIncludeNode *last = list->last; + if (last) { + last->next = node_list.first; + } + + list->last = node_list.last; + node_list.first->prev = last; +} + +void wapp_cinclude_list_insert(CIncludeList *list, CIncludeNode *node, u64 index) { + wapp_debug_assert(list != NULL && node != NULL && (node->item) != NULL, "`list`, `node` and `node->item` should not be NULL"); + + if (index == 0) { + wapp_cinclude_list_push_front(list, node); + return; + } else if (index == list->node_count) { + wapp_cinclude_list_push_back(list, node); + return; + } + + CIncludeNode *dst_node = wapp_cinclude_list_get(list, index); + if (!dst_node) { + return; + } + + CIncludeList node_list = cinclude_node_to_list(node); + + list->node_count += node_list.node_count; + + CIncludeNode *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; +} + +CIncludeNode *wapp_cinclude_list_pop_front(CIncludeList *list) { + wapp_debug_assert(list != NULL, "`list` should not be NULL"); + + CIncludeNode *output = NULL; + + if (list->node_count == 0) { + goto RETURN_CINCLUDE_LIST_POP_FRONT; + } + + output = list->first; + + if (list->node_count == 1) { + *list = (CIncludeList){0}; + goto RETURN_CINCLUDE_LIST_POP_FRONT; + } + + --(list->node_count); + list->first = output->next; + + output->prev = output->next = NULL; + +RETURN_CINCLUDE_LIST_POP_FRONT: + return output; +} + +CIncludeNode *wapp_cinclude_list_pop_back(CIncludeList *list) { + wapp_debug_assert(list != NULL, "`list` should not be NULL"); + + CIncludeNode *output = NULL; + + if (list->node_count == 0) { + goto RETURN_CINCLUDE_LIST_POP_BACK; + } + + output = list->last; + + if (list->node_count == 1) { + *list = (CIncludeList){0}; + goto RETURN_CINCLUDE_LIST_POP_BACK; + } + + --(list->node_count); + list->last = output->prev; + + output->prev = output->next = NULL; + +RETURN_CINCLUDE_LIST_POP_BACK: + return output; +} + +CIncludeNode *wapp_cinclude_list_remove(CIncludeList *list, u64 index) { + wapp_debug_assert(list != NULL, "`list` should not be NULL"); + + CIncludeNode *output = NULL; + + if (index == 0) { + output = wapp_cinclude_list_pop_front(list); + goto RETURN_CINCLUDE_LIST_REMOVE; + } else if (index == list->node_count) { + output = wapp_cinclude_list_pop_back(list); + goto RETURN_CINCLUDE_LIST_REMOVE; + } + + output = wapp_cinclude_list_get(list, index); + if (!output) { + goto RETURN_CINCLUDE_LIST_REMOVE; + } + + output->prev->next = output->next; + output->next->prev = output->prev; + + --(list->node_count); + + output->prev = output->next = NULL; + +RETURN_CINCLUDE_LIST_REMOVE: + return output; +} + +void wapp_cinclude_list_empty(CIncludeList *list) { + wapp_debug_assert(list != NULL, "`list` should not be NULL"); + + u64 count = list->node_count; + for (u64 i = 0; i < count; ++i) { + wapp_cinclude_list_pop_back(list); + } +} + +CUserTypeNode *wapp_cusertype_list_get(const CUserTypeList *list, u64 index) { + wapp_runtime_assert(index < list->node_count, "`index` is out of bounds"); + + CUserTypeNode *output = NULL; + CUserTypeNode *current = list->first; + for (u64 i = 1; i <= index; ++i) { + current = current->next; + } + + output = current; + + return output; +} + +void wapp_cusertype_list_push_front(CUserTypeList *list, CUserTypeNode *node) { + wapp_debug_assert(list != NULL && node != NULL && (node->item) != NULL, "`list`, `node` and `node->item` should not be NULL"); + + CUserTypeList node_list = cusertype_node_to_list(node); + + if (list->node_count == 0) { + *list = node_list; + return; + } + + list->node_count += node_list.node_count; + + CUserTypeNode *first = list->first; + if (first) { + first->prev = node_list.last; + } + + list->first = node_list.first; + node_list.last->next = first; +} + +void wapp_cusertype_list_push_back(CUserTypeList *list, CUserTypeNode *node) { + wapp_debug_assert(list != NULL && node != NULL && (node->item) != NULL, "`list`, `node` and `node->item` should not be NULL"); + + CUserTypeList node_list = cusertype_node_to_list(node); + + if (list->node_count == 0) { + *list = node_list; + return; + } + + list->node_count += node_list.node_count; + + CUserTypeNode *last = list->last; + if (last) { + last->next = node_list.first; + } + + list->last = node_list.last; + node_list.first->prev = last; +} + +void wapp_cusertype_list_insert(CUserTypeList *list, CUserTypeNode *node, u64 index) { + wapp_debug_assert(list != NULL && node != NULL && (node->item) != NULL, "`list`, `node` and `node->item` should not be NULL"); + + if (index == 0) { + wapp_cusertype_list_push_front(list, node); + return; + } else if (index == list->node_count) { + wapp_cusertype_list_push_back(list, node); + return; + } + + CUserTypeNode *dst_node = wapp_cusertype_list_get(list, index); + if (!dst_node) { + return; + } + + CUserTypeList node_list = cusertype_node_to_list(node); + + list->node_count += node_list.node_count; + + CUserTypeNode *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; +} + +CUserTypeNode *wapp_cusertype_list_pop_front(CUserTypeList *list) { + wapp_debug_assert(list != NULL, "`list` should not be NULL"); + + CUserTypeNode *output = NULL; + + if (list->node_count == 0) { + goto RETURN_CUSERTYPE_LIST_POP_FRONT; + } + + output = list->first; + + if (list->node_count == 1) { + *list = (CUserTypeList){0}; + goto RETURN_CUSERTYPE_LIST_POP_FRONT; + } + + --(list->node_count); + list->first = output->next; + + output->prev = output->next = NULL; + +RETURN_CUSERTYPE_LIST_POP_FRONT: + return output; +} + +CUserTypeNode *wapp_cusertype_list_pop_back(CUserTypeList *list) { + wapp_debug_assert(list != NULL, "`list` should not be NULL"); + + CUserTypeNode *output = NULL; + + if (list->node_count == 0) { + goto RETURN_CUSERTYPE_LIST_POP_BACK; + } + + output = list->last; + + if (list->node_count == 1) { + *list = (CUserTypeList){0}; + goto RETURN_CUSERTYPE_LIST_POP_BACK; + } + + --(list->node_count); + list->last = output->prev; + + output->prev = output->next = NULL; + +RETURN_CUSERTYPE_LIST_POP_BACK: + return output; +} + +CUserTypeNode *wapp_cusertype_list_remove(CUserTypeList *list, u64 index) { + wapp_debug_assert(list != NULL, "`list` should not be NULL"); + + CUserTypeNode *output = NULL; + + if (index == 0) { + output = wapp_cusertype_list_pop_front(list); + goto RETURN_CUSERTYPE_LIST_REMOVE; + } else if (index == list->node_count) { + output = wapp_cusertype_list_pop_back(list); + goto RETURN_CUSERTYPE_LIST_REMOVE; + } + + output = wapp_cusertype_list_get(list, index); + if (!output) { + goto RETURN_CUSERTYPE_LIST_REMOVE; + } + + output->prev->next = output->next; + output->next->prev = output->prev; + + --(list->node_count); + + output->prev = output->next = NULL; + +RETURN_CUSERTYPE_LIST_REMOVE: + return output; +} + +void wapp_cusertype_list_empty(CUserTypeList *list) { + wapp_debug_assert(list != NULL, "`list` should not be NULL"); + + u64 count = list->node_count; + for (u64 i = 0; i < count; ++i) { + wapp_cusertype_list_pop_back(list); + } +} + +CFuncNode *wapp_cfunc_list_get(const CFuncList *list, u64 index) { + wapp_runtime_assert(index < list->node_count, "`index` is out of bounds"); + + CFuncNode *output = NULL; + CFuncNode *current = list->first; + for (u64 i = 1; i <= index; ++i) { + current = current->next; + } + + output = current; + + return output; +} + +void wapp_cfunc_list_push_front(CFuncList *list, CFuncNode *node) { + wapp_debug_assert(list != NULL && node != NULL && (node->item) != NULL, "`list`, `node` and `node->item` should not be NULL"); + + CFuncList node_list = cfunc_node_to_list(node); + + if (list->node_count == 0) { + *list = node_list; + return; + } + + list->node_count += node_list.node_count; + + CFuncNode *first = list->first; + if (first) { + first->prev = node_list.last; + } + + list->first = node_list.first; + node_list.last->next = first; +} + +void wapp_cfunc_list_push_back(CFuncList *list, CFuncNode *node) { + wapp_debug_assert(list != NULL && node != NULL && (node->item) != NULL, "`list`, `node` and `node->item` should not be NULL"); + + CFuncList node_list = cfunc_node_to_list(node); + + if (list->node_count == 0) { + *list = node_list; + return; + } + + list->node_count += node_list.node_count; + + CFuncNode *last = list->last; + if (last) { + last->next = node_list.first; + } + + list->last = node_list.last; + node_list.first->prev = last; +} + +void wapp_cfunc_list_insert(CFuncList *list, CFuncNode *node, u64 index) { + wapp_debug_assert(list != NULL && node != NULL && (node->item) != NULL, "`list`, `node` and `node->item` should not be NULL"); + + if (index == 0) { + wapp_cfunc_list_push_front(list, node); + return; + } else if (index == list->node_count) { + wapp_cfunc_list_push_back(list, node); + return; + } + + CFuncNode *dst_node = wapp_cfunc_list_get(list, index); + if (!dst_node) { + return; + } + + CFuncList node_list = cfunc_node_to_list(node); + + list->node_count += node_list.node_count; + + CFuncNode *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; +} + +CFuncNode *wapp_cfunc_list_pop_front(CFuncList *list) { + wapp_debug_assert(list != NULL, "`list` should not be NULL"); + + CFuncNode *output = NULL; + + if (list->node_count == 0) { + goto RETURN_CFUNC_LIST_POP_FRONT; + } + + output = list->first; + + if (list->node_count == 1) { + *list = (CFuncList){0}; + goto RETURN_CFUNC_LIST_POP_FRONT; + } + + --(list->node_count); + list->first = output->next; + + output->prev = output->next = NULL; + +RETURN_CFUNC_LIST_POP_FRONT: + return output; +} + +CFuncNode *wapp_cfunc_list_pop_back(CFuncList *list) { + wapp_debug_assert(list != NULL, "`list` should not be NULL"); + + CFuncNode *output = NULL; + + if (list->node_count == 0) { + goto RETURN_CFUNC_LIST_POP_BACK; + } + + output = list->last; + + if (list->node_count == 1) { + *list = (CFuncList){0}; + goto RETURN_CFUNC_LIST_POP_BACK; + } + + --(list->node_count); + list->last = output->prev; + + output->prev = output->next = NULL; + +RETURN_CFUNC_LIST_POP_BACK: + return output; +} + +CFuncNode *wapp_cfunc_list_remove(CFuncList *list, u64 index) { + wapp_debug_assert(list != NULL, "`list` should not be NULL"); + + CFuncNode *output = NULL; + + if (index == 0) { + output = wapp_cfunc_list_pop_front(list); + goto RETURN_CFUNC_LIST_REMOVE; + } else if (index == list->node_count) { + output = wapp_cfunc_list_pop_back(list); + goto RETURN_CFUNC_LIST_REMOVE; + } + + output = wapp_cfunc_list_get(list, index); + if (!output) { + goto RETURN_CFUNC_LIST_REMOVE; + } + + output->prev->next = output->next; + output->next->prev = output->prev; + + --(list->node_count); + + output->prev = output->next = NULL; + +RETURN_CFUNC_LIST_REMOVE: + return output; +} + +void wapp_cfunc_list_empty(CFuncList *list) { + wapp_debug_assert(list != NULL, "`list` should not be NULL"); + + u64 count = list->node_count; + for (u64 i = 0; i < count; ++i) { + wapp_cfunc_list_pop_back(list); + } +} + +CStructNode *wapp_cstruct_list_get(const CStructList *list, u64 index) { + wapp_runtime_assert(index < list->node_count, "`index` is out of bounds"); + + CStructNode *output = NULL; + CStructNode *current = list->first; + for (u64 i = 1; i <= index; ++i) { + current = current->next; + } + + output = current; + + return output; +} + +void wapp_cstruct_list_push_front(CStructList *list, CStructNode *node) { + wapp_debug_assert(list != NULL && node != NULL && (node->item) != NULL, "`list`, `node` and `node->item` should not be NULL"); + + CStructList node_list = cstruct_node_to_list(node); + + if (list->node_count == 0) { + *list = node_list; + return; + } + + list->node_count += node_list.node_count; + + CStructNode *first = list->first; + if (first) { + first->prev = node_list.last; + } + + list->first = node_list.first; + node_list.last->next = first; +} + +void wapp_cstruct_list_push_back(CStructList *list, CStructNode *node) { + wapp_debug_assert(list != NULL && node != NULL && (node->item) != NULL, "`list`, `node` and `node->item` should not be NULL"); + + CStructList node_list = cstruct_node_to_list(node); + + if (list->node_count == 0) { + *list = node_list; + return; + } + + list->node_count += node_list.node_count; + + CStructNode *last = list->last; + if (last) { + last->next = node_list.first; + } + + list->last = node_list.last; + node_list.first->prev = last; +} + +void wapp_cstruct_list_insert(CStructList *list, CStructNode *node, u64 index) { + wapp_debug_assert(list != NULL && node != NULL && (node->item) != NULL, "`list`, `node` and `node->item` should not be NULL"); + + if (index == 0) { + wapp_cstruct_list_push_front(list, node); + return; + } else if (index == list->node_count) { + wapp_cstruct_list_push_back(list, node); + return; + } + + CStructNode *dst_node = wapp_cstruct_list_get(list, index); + if (!dst_node) { + return; + } + + CStructList node_list = cstruct_node_to_list(node); + + list->node_count += node_list.node_count; + + CStructNode *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; +} + +CStructNode *wapp_cstruct_list_pop_front(CStructList *list) { + wapp_debug_assert(list != NULL, "`list` should not be NULL"); + + CStructNode *output = NULL; + + if (list->node_count == 0) { + goto RETURN_CSTRUCT_LIST_POP_FRONT; + } + + output = list->first; + + if (list->node_count == 1) { + *list = (CStructList){0}; + goto RETURN_CSTRUCT_LIST_POP_FRONT; + } + + --(list->node_count); + list->first = output->next; + + output->prev = output->next = NULL; + +RETURN_CSTRUCT_LIST_POP_FRONT: + return output; +} + +CStructNode *wapp_cstruct_list_pop_back(CStructList *list) { + wapp_debug_assert(list != NULL, "`list` should not be NULL"); + + CStructNode *output = NULL; + + if (list->node_count == 0) { + goto RETURN_CSTRUCT_LIST_POP_BACK; + } + + output = list->last; + + if (list->node_count == 1) { + *list = (CStructList){0}; + goto RETURN_CSTRUCT_LIST_POP_BACK; + } + + --(list->node_count); + list->last = output->prev; + + output->prev = output->next = NULL; + +RETURN_CSTRUCT_LIST_POP_BACK: + return output; +} + +CStructNode *wapp_cstruct_list_remove(CStructList *list, u64 index) { + wapp_debug_assert(list != NULL, "`list` should not be NULL"); + + CStructNode *output = NULL; + + if (index == 0) { + output = wapp_cstruct_list_pop_front(list); + goto RETURN_CSTRUCT_LIST_REMOVE; + } else if (index == list->node_count) { + output = wapp_cstruct_list_pop_back(list); + goto RETURN_CSTRUCT_LIST_REMOVE; + } + + output = wapp_cstruct_list_get(list, index); + if (!output) { + goto RETURN_CSTRUCT_LIST_REMOVE; + } + + output->prev->next = output->next; + output->next->prev = output->prev; + + --(list->node_count); + + output->prev = output->next = NULL; + +RETURN_CSTRUCT_LIST_REMOVE: + return output; +} + +void wapp_cstruct_list_empty(CStructList *list) { + wapp_debug_assert(list != NULL, "`list` should not be NULL"); + + u64 count = list->node_count; + for (u64 i = 0; i < count; ++i) { + wapp_cstruct_list_pop_back(list); + } +} + +CMacroNode *wapp_cmacro_list_get(const CMacroList *list, u64 index) { + wapp_runtime_assert(index < list->node_count, "`index` is out of bounds"); + + CMacroNode *output = NULL; + CMacroNode *current = list->first; + for (u64 i = 1; i <= index; ++i) { + current = current->next; + } + + output = current; + + return output; +} + +void wapp_cmacro_list_push_front(CMacroList *list, CMacroNode *node) { + wapp_debug_assert(list != NULL && node != NULL && (node->item) != NULL, "`list`, `node` and `node->item` should not be NULL"); + + CMacroList node_list = cmacro_node_to_list(node); + + if (list->node_count == 0) { + *list = node_list; + return; + } + + list->node_count += node_list.node_count; + + CMacroNode *first = list->first; + if (first) { + first->prev = node_list.last; + } + + list->first = node_list.first; + node_list.last->next = first; +} + +void wapp_cmacro_list_push_back(CMacroList *list, CMacroNode *node) { + wapp_debug_assert(list != NULL && node != NULL && (node->item) != NULL, "`list`, `node` and `node->item` should not be NULL"); + + CMacroList node_list = cmacro_node_to_list(node); + + if (list->node_count == 0) { + *list = node_list; + return; + } + + list->node_count += node_list.node_count; + + CMacroNode *last = list->last; + if (last) { + last->next = node_list.first; + } + + list->last = node_list.last; + node_list.first->prev = last; +} + +void wapp_cmacro_list_insert(CMacroList *list, CMacroNode *node, u64 index) { + wapp_debug_assert(list != NULL && node != NULL && (node->item) != NULL, "`list`, `node` and `node->item` should not be NULL"); + + if (index == 0) { + wapp_cmacro_list_push_front(list, node); + return; + } else if (index == list->node_count) { + wapp_cmacro_list_push_back(list, node); + return; + } + + CMacroNode *dst_node = wapp_cmacro_list_get(list, index); + if (!dst_node) { + return; + } + + CMacroList node_list = cmacro_node_to_list(node); + + list->node_count += node_list.node_count; + + CMacroNode *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; +} + +CMacroNode *wapp_cmacro_list_pop_front(CMacroList *list) { + wapp_debug_assert(list != NULL, "`list` should not be NULL"); + + CMacroNode *output = NULL; + + if (list->node_count == 0) { + goto RETURN_CMACRO_LIST_POP_FRONT; + } + + output = list->first; + + if (list->node_count == 1) { + *list = (CMacroList){0}; + goto RETURN_CMACRO_LIST_POP_FRONT; + } + + --(list->node_count); + list->first = output->next; + + output->prev = output->next = NULL; + +RETURN_CMACRO_LIST_POP_FRONT: + return output; +} + +CMacroNode *wapp_cmacro_list_pop_back(CMacroList *list) { + wapp_debug_assert(list != NULL, "`list` should not be NULL"); + + CMacroNode *output = NULL; + + if (list->node_count == 0) { + goto RETURN_CMACRO_LIST_POP_BACK; + } + + output = list->last; + + if (list->node_count == 1) { + *list = (CMacroList){0}; + goto RETURN_CMACRO_LIST_POP_BACK; + } + + --(list->node_count); + list->last = output->prev; + + output->prev = output->next = NULL; + +RETURN_CMACRO_LIST_POP_BACK: + return output; +} + +CMacroNode *wapp_cmacro_list_remove(CMacroList *list, u64 index) { + wapp_debug_assert(list != NULL, "`list` should not be NULL"); + + CMacroNode *output = NULL; + + if (index == 0) { + output = wapp_cmacro_list_pop_front(list); + goto RETURN_CMACRO_LIST_REMOVE; + } else if (index == list->node_count) { + output = wapp_cmacro_list_pop_back(list); + goto RETURN_CMACRO_LIST_REMOVE; + } + + output = wapp_cmacro_list_get(list, index); + if (!output) { + goto RETURN_CMACRO_LIST_REMOVE; + } + + output->prev->next = output->next; + output->next->prev = output->prev; + + --(list->node_count); + + output->prev = output->next = NULL; + +RETURN_CMACRO_LIST_REMOVE: + return output; +} + +void wapp_cmacro_list_empty(CMacroList *list) { + wapp_debug_assert(list != NULL, "`list` should not be NULL"); + + u64 count = list->node_count; + for (u64 i = 0; i < count; ++i) { + wapp_cmacro_list_pop_back(list); + } +} + +internal CEnumValList cenumval_node_to_list(CEnumValNode *node) { + CEnumValList 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; +} + +internal CArgList carg_node_to_list(CArgNode *node) { + CArgList 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; +} + +internal CQualifierList cqualifier_node_to_list(CQualifierNode *node) { + CQualifierList 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; +} + +internal CIncludeList cinclude_node_to_list(CIncludeNode *node) { + CIncludeList 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; +} + +internal CUserTypeList cusertype_node_to_list(CUserTypeNode *node) { + CUserTypeList 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; +} + +internal CFuncList cfunc_node_to_list(CFuncNode *node) { + CFuncList 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; +} + +internal CStructList cstruct_node_to_list(CStructNode *node) { + CStructList 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; +} + +internal CMacroList cmacro_node_to_list(CMacroNode *node) { + CMacroList 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; +} diff --git a/ccodegen/dbl_list.h b/ccodegen/dbl_list.h new file mode 100644 index 0000000..2d2c299 --- /dev/null +++ b/ccodegen/dbl_list.h @@ -0,0 +1,222 @@ +// 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 diff --git a/ccodegen/main.c b/ccodegen/main.c new file mode 100644 index 0000000..7dceaf3 --- /dev/null +++ b/ccodegen/main.c @@ -0,0 +1,10 @@ +// vim:fileencoding=utf-8:foldmethod=marker + +#include "datatypes.h" +#include "type_enums.h" +#include "wapp_core.h" +#include + +int main(void) { + return 0; +} diff --git a/ccodegen/type_enums.h b/ccodegen/type_enums.h new file mode 100644 index 0000000..2c5f4d2 --- /dev/null +++ b/ccodegen/type_enums.h @@ -0,0 +1,84 @@ +// vim:fileencoding=utf-8:foldmethod=marker + +#ifndef TYPE_ENUMS_H +#define TYPE_ENUMS_H + +#include "wapp_core.h" + +typedef enum { + CTYPE_VOID, + CTYPE_B32, + 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_B32] = 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 diff --git a/codegen/array/make_array.py b/codegen/array/make_array.py index eb0a66b..eaaed02 100644 --- a/codegen/array/make_array.py +++ b/codegen/array/make_array.py @@ -54,10 +54,6 @@ 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, @@ -71,6 +67,8 @@ def make_array(user_datatypes: Dict[CDataType, ArrayData] = {}): common_decl_types: List[CStruct] = [] datatypes: dict[CDataType, ArrayData] = { + CType.VOID: ArrayData(array_typename="GenericArray"), + "void *": ArrayData(array_typename="VoidPArray"), "Str8": ArrayData( array_typename="Str8Array", hdr_decl_types=[ @@ -81,13 +79,10 @@ def make_array(user_datatypes: Dict[CDataType, ArrayData] = {}): for _type in CType: if _type == CType.VOID: - datatypes["void *"] = ArrayData( - array_typename="VoidPArray", - ) continue type_title = _type.value.title() - datatypes[_type.value] = ArrayData( + datatypes[_type] = ArrayData( array_typename=f"{type_title}Array", ) @@ -108,11 +103,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 @@ -141,7 +136,7 @@ def make_array(user_datatypes: Dict[CDataType, ArrayData] = {}): ], ) - if isinstance(_type, str) and _type == "void *": + if isinstance(_type, CType) and _type == CType.VOID: alloc_capacity_func = CFunc( name=f"_array_alloc_capacity", ret_type=array, @@ -160,275 +155,276 @@ def make_array(user_datatypes: Dict[CDataType, ArrayData] = {}): pointer=CPointer(CPointerType.SINGLE), ) generic_funcs.append(alloc_capacity_func) - - stack_array_cmacro = CMacro( - name=f"wapp_{type_string_lower}_array(...)", - value=__format_func_body( - filename=snippets_dir / "stack_array", - type_string=type_string, - type_string_upper=type_string_upper, - type_string_lower=type_string_lower, - array_typename=array_data.array_typename, - ), - ) - stack_array_cppmacro = CMacro( - name=f"wapp_{type_string_lower}_array(...)", - value=__format_func_body( - filename=snippets_dir / "stack_array_cpp", - type_string=type_string, - type_string_upper=type_string_upper, - type_string_lower=type_string_lower, - array_typename=array_data.array_typename, - ), - ) + else: + stack_array_cmacro = CMacro( + name=f"wapp_{type_string_lower}_array(...)", + value=__format_func_body( + filename=snippets_dir / "stack_array", + type_string=type_string, + type_string_upper=type_string_upper, + type_string_lower=type_string_lower, + array_typename=array_data.array_typename, + ), + ) + stack_array_cppmacro = CMacro( + name=f"wapp_{type_string_lower}_array(...)", + value=__format_func_body( + filename=snippets_dir / "stack_array_cpp", + type_string=type_string, + type_string_upper=type_string_upper, + type_string_lower=type_string_lower, + array_typename=array_data.array_typename, + ), + ) - stack_capacity_array_cmacro = CMacro( - name=f"wapp_{type_string_lower}_array_with_capacity(CAPACITY)", - value=__format_func_body( - filename=snippets_dir / "stack_capacity_array", - type_string=type_string, - type_string_upper=type_string_upper, - type_string_lower=type_string_lower, - array_typename=array_data.array_typename, - ), - ) - stack_capacity_array_cppmacro = CMacro( - name=f"wapp_{type_string_lower}_array_with_capacity(CAPACITY)", - value=__format_func_body( - filename=snippets_dir / "stack_capacity_array_cpp", - type_string=type_string, - type_string_upper=type_string_upper, - type_string_lower=type_string_lower, - array_typename=array_data.array_typename, - ), - ) + stack_capacity_array_cmacro = CMacro( + name=f"wapp_{type_string_lower}_array_with_capacity(CAPACITY)", + value=__format_func_body( + filename=snippets_dir / "stack_capacity_array", + type_string=type_string, + type_string_upper=type_string_upper, + type_string_lower=type_string_lower, + array_typename=array_data.array_typename, + ), + ) + stack_capacity_array_cppmacro = CMacro( + name=f"wapp_{type_string_lower}_array_with_capacity(CAPACITY)", + value=__format_func_body( + filename=snippets_dir / "stack_capacity_array_cpp", + type_string=type_string, + type_string_upper=type_string_upper, + type_string_lower=type_string_lower, + array_typename=array_data.array_typename, + ), + ) - alloc_capacity_array_macro = CMacro( - name=f"wapp_{type_string_lower}_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY)", - value=__format_func_body( - filename=snippets_dir / "alloc_capacity_macro", - type_string=type_string, - type_string_upper=type_string_upper, - type_string_lower=type_string_lower, - array_typename=array_data.array_typename, - ), - ) + alloc_capacity_array_macro = CMacro( + name=f"wapp_{type_string_lower}_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY)", + value=__format_func_body( + filename=snippets_dir / "alloc_capacity_macro", + type_string=type_string, + type_string_upper=type_string_upper, + type_string_lower=type_string_lower, + array_typename=array_data.array_typename, + ), + ) - array_pop_cmacro = CMacro( - name=f"wapp_{type_string_lower}_array_pop(ARRAY_PTR)", - value=__format_func_body( - filename=snippets_dir / "array_pop_macro", - type_string=type_string, - type_string_upper=type_string_upper, - type_string_lower=type_string_lower, - array_typename=array_data.array_typename, - ), - ) - array_pop_cppmacro = CMacro( - name=f"wapp_{type_string_lower}_array_pop(ARRAY_PTR)", - value=__format_func_body( - filename=snippets_dir / "array_pop_macro_cpp", - type_string=type_string, - type_string_upper=type_string_upper, - type_string_lower=type_string_lower, - array_typename=array_data.array_typename, - ), - ) + array_pop_cmacro = CMacro( + name=f"wapp_{type_string_lower}_array_pop(ARRAY_PTR)", + value=__format_func_body( + filename=snippets_dir / "array_pop_macro", + type_string=type_string, + type_string_upper=type_string_upper, + type_string_lower=type_string_lower, + array_typename=array_data.array_typename, + ), + ) + array_pop_cppmacro = CMacro( + name=f"wapp_{type_string_lower}_array_pop(ARRAY_PTR)", + value=__format_func_body( + filename=snippets_dir / "array_pop_macro_cpp", + type_string=type_string, + type_string_upper=type_string_upper, + type_string_lower=type_string_lower, + array_typename=array_data.array_typename, + ), + ) - get_func = CFunc( - name=f"wapp_{type_string_lower}_array_get", - ret_type=type_string, - args=[ - CArg(name="array", _type=array, pointer=CPointer(CPointerType.SINGLE), qualifier=CQualifier.CONST), - CArg(name="index", _type=CType.U64), - ], - body=__format_func_body( - filename=snippets_dir / "array_get", - type_string=type_string, - type_string_upper=type_string_upper, - type_string_lower=type_string_lower, - array_typename=array_data.array_typename, - ), - pointer=CPointer(CPointerType.SINGLE), - ) + get_func = CFunc( + name=f"wapp_{type_string_lower}_array_get", + ret_type=type_string, + args=[ + CArg(name="array", _type=array, pointer=CPointer(CPointerType.SINGLE), qualifier=CQualifier.CONST), + CArg(name="index", _type=CType.U64), + ], + body=__format_func_body( + filename=snippets_dir / "array_get", + type_string=type_string, + type_string_upper=type_string_upper, + type_string_lower=type_string_lower, + array_typename=array_data.array_typename, + ), + pointer=CPointer(CPointerType.SINGLE), + ) - set_func = CFunc( - name=f"wapp_{type_string_lower}_array_set", - ret_type=CType.VOID, - args=[ - CArg(name="array", _type=array, pointer=CPointer(CPointerType.SINGLE)), - CArg(name="index", _type=CType.U64), - CArg(name="item", _type=type_string, pointer=CPointer(CPointerType.SINGLE)), - ], - body=__format_func_body( - filename=snippets_dir / "array_set", - type_string=type_string, - type_string_upper=type_string_upper, - type_string_lower=type_string_lower, - array_typename=array_data.array_typename, - ), - ) + set_func = CFunc( + name=f"wapp_{type_string_lower}_array_set", + ret_type=CType.VOID, + args=[ + CArg(name="array", _type=array, pointer=CPointer(CPointerType.SINGLE)), + CArg(name="index", _type=CType.U64), + CArg(name="item", _type=type_string, pointer=CPointer(CPointerType.SINGLE)), + ], + body=__format_func_body( + filename=snippets_dir / "array_set", + type_string=type_string, + type_string_upper=type_string_upper, + type_string_lower=type_string_lower, + array_typename=array_data.array_typename, + ), + ) - append_capped_func = CFunc( - name=f"wapp_{type_string_lower}_array_append_capped", - ret_type=CType.VOID, - args=[ - CArg(name="array", _type=array, pointer=CPointer(CPointerType.SINGLE)), - CArg(name="item", _type=type_string, pointer=CPointer(CPointerType.SINGLE)), - ], - body=__format_func_body( - filename=snippets_dir / "append_capped", - type_string=type_string, - type_string_upper=type_string_upper, - type_string_lower=type_string_lower, - array_typename=array_data.array_typename, - ), - ) + append_capped_func = CFunc( + name=f"wapp_{type_string_lower}_array_append_capped", + ret_type=CType.VOID, + args=[ + CArg(name="array", _type=array, pointer=CPointer(CPointerType.SINGLE)), + CArg(name="item", _type=type_string, pointer=CPointer(CPointerType.SINGLE)), + ], + body=__format_func_body( + filename=snippets_dir / "append_capped", + type_string=type_string, + type_string_upper=type_string_upper, + type_string_lower=type_string_lower, + array_typename=array_data.array_typename, + ), + ) - extend_capped_func = CFunc( - name=f"wapp_{type_string_lower}_array_extend_capped", - ret_type=CType.VOID, - args=[ - CArg(name="array", _type=array, pointer=CPointer(CPointerType.SINGLE)), - CArg(name="other", _type=array, pointer=CPointer(CPointerType.SINGLE), qualifier=CQualifier.CONST), - ], - body=__format_func_body( - filename=snippets_dir / "extend_capped", - type_string=type_string, - type_string_upper=type_string_upper, - type_string_lower=type_string_lower, - array_typename=array_data.array_typename, - ), - ) + extend_capped_func = CFunc( + name=f"wapp_{type_string_lower}_array_extend_capped", + ret_type=CType.VOID, + args=[ + CArg(name="array", _type=array, pointer=CPointer(CPointerType.SINGLE)), + CArg(name="other", _type=array, pointer=CPointer(CPointerType.SINGLE), qualifier=CQualifier.CONST), + ], + body=__format_func_body( + filename=snippets_dir / "extend_capped", + type_string=type_string, + type_string_upper=type_string_upper, + type_string_lower=type_string_lower, + array_typename=array_data.array_typename, + ), + ) - clear_func = CFunc( - name=f"wapp_{type_string_lower}_array_clear", - ret_type=CType.VOID, - args=[ - CArg(name="array", _type=array, pointer=CPointer(CPointerType.SINGLE)), - ], - body=__format_func_body( - filename=snippets_dir / "clear", - type_string=type_string, - type_string_upper=type_string_upper, - type_string_lower=type_string_lower, - array_typename=array_data.array_typename, - ), - ) + clear_func = CFunc( + name=f"wapp_{type_string_lower}_array_clear", + ret_type=CType.VOID, + args=[ + CArg(name="array", _type=array, pointer=CPointer(CPointerType.SINGLE)), + ], + body=__format_func_body( + filename=snippets_dir / "clear", + type_string=type_string, + type_string_upper=type_string_upper, + type_string_lower=type_string_lower, + array_typename=array_data.array_typename, + ), + ) - copy_capped_func = CFunc( - name=f"wapp_{type_string_lower}_array_copy_capped", - ret_type=CType.VOID, - args=[ - CArg(name="src", _type=array, pointer=CPointer(CPointerType.SINGLE), qualifier=CQualifier.CONST), - CArg(name="dst", _type=array, pointer=CPointer(CPointerType.SINGLE)), - ], - body=__format_func_body( - filename=snippets_dir / "copy_capped", - type_string=type_string, - type_string_upper=type_string_upper, - type_string_lower=type_string_lower, - array_typename=array_data.array_typename, - ), - ) + copy_capped_func = CFunc( + name=f"wapp_{type_string_lower}_array_copy_capped", + ret_type=CType.VOID, + args=[ + CArg(name="src", _type=array, pointer=CPointer(CPointerType.SINGLE), qualifier=CQualifier.CONST), + CArg(name="dst", _type=array, pointer=CPointer(CPointerType.SINGLE)), + ], + body=__format_func_body( + filename=snippets_dir / "copy_capped", + type_string=type_string, + type_string_upper=type_string_upper, + type_string_lower=type_string_lower, + array_typename=array_data.array_typename, + ), + ) - append_alloc_func = CFunc( - name=f"wapp_{type_string_lower}_array_append_alloc", - ret_type=array, - args=[ - CArg(name="allocator", _type="Allocator", pointer=CPointer(CPointerType.SINGLE), qualifier=CQualifier.CONST), - CArg(name="array", _type=array, pointer=CPointer(CPointerType.SINGLE)), - CArg(name="item", _type=type_string, pointer=CPointer(CPointerType.SINGLE)), - ], - body=__format_func_body( - filename=snippets_dir / "append_alloc", - type_string=type_string, - type_string_upper=type_string_upper, - type_string_lower=type_string_lower, - array_typename=array_data.array_typename, - ), - pointer=CPointer(CPointerType.SINGLE), - ) + append_alloc_func = CFunc( + name=f"wapp_{type_string_lower}_array_append_alloc", + ret_type=array, + args=[ + CArg(name="allocator", _type="Allocator", pointer=CPointer(CPointerType.SINGLE), qualifier=CQualifier.CONST), + CArg(name="array", _type=array, pointer=CPointer(CPointerType.SINGLE)), + CArg(name="item", _type=type_string, pointer=CPointer(CPointerType.SINGLE)), + ], + body=__format_func_body( + filename=snippets_dir / "append_alloc", + type_string=type_string, + type_string_upper=type_string_upper, + type_string_lower=type_string_lower, + array_typename=array_data.array_typename, + ), + pointer=CPointer(CPointerType.SINGLE), + ) - extend_alloc_func = CFunc( - name=f"wapp_{type_string_lower}_array_extend_alloc", - ret_type=array, - args=[ - CArg(name="allocator", _type="Allocator", pointer=CPointer(CPointerType.SINGLE), qualifier=CQualifier.CONST), - CArg(name="array", _type=array, pointer=CPointer(CPointerType.SINGLE)), - CArg(name="other", _type=array, pointer=CPointer(CPointerType.SINGLE), qualifier=CQualifier.CONST), - ], - body=__format_func_body( - filename=snippets_dir / "extend_alloc", - type_string=type_string, - type_string_upper=type_string_upper, - type_string_lower=type_string_lower, - array_typename=array_data.array_typename, - ), - pointer=CPointer(CPointerType.SINGLE), - ) + extend_alloc_func = CFunc( + name=f"wapp_{type_string_lower}_array_extend_alloc", + ret_type=array, + args=[ + CArg(name="allocator", _type="Allocator", pointer=CPointer(CPointerType.SINGLE), qualifier=CQualifier.CONST), + CArg(name="array", _type=array, pointer=CPointer(CPointerType.SINGLE)), + CArg(name="other", _type=array, pointer=CPointer(CPointerType.SINGLE), qualifier=CQualifier.CONST), + ], + body=__format_func_body( + filename=snippets_dir / "extend_alloc", + type_string=type_string, + type_string_upper=type_string_upper, + type_string_lower=type_string_lower, + array_typename=array_data.array_typename, + ), + pointer=CPointer(CPointerType.SINGLE), + ) - copy_alloc_func = CFunc( - name=f"wapp_{type_string_lower}_array_copy_alloc", - ret_type=array, - args=[ - CArg(name="allocator", _type="Allocator", pointer=CPointer(CPointerType.SINGLE), qualifier=CQualifier.CONST), - CArg(name="src", _type=array, pointer=CPointer(CPointerType.SINGLE), qualifier=CQualifier.CONST), - CArg(name="dst", _type=array, pointer=CPointer(CPointerType.SINGLE)), - ], - body=__format_func_body( - filename=snippets_dir / "copy_alloc", - type_string=type_string, - type_string_upper=type_string_upper, - type_string_lower=type_string_lower, - array_typename=array_data.array_typename, - ), - pointer=CPointer(CPointerType.SINGLE), - ) + copy_alloc_func = CFunc( + name=f"wapp_{type_string_lower}_array_copy_alloc", + ret_type=array, + args=[ + CArg(name="allocator", _type="Allocator", pointer=CPointer(CPointerType.SINGLE), qualifier=CQualifier.CONST), + CArg(name="src", _type=array, pointer=CPointer(CPointerType.SINGLE), qualifier=CQualifier.CONST), + CArg(name="dst", _type=array, pointer=CPointer(CPointerType.SINGLE)), + ], + body=__format_func_body( + filename=snippets_dir / "copy_alloc", + type_string=type_string, + type_string_upper=type_string_upper, + type_string_lower=type_string_lower, + array_typename=array_data.array_typename, + ), + pointer=CPointer(CPointerType.SINGLE), + ) - pop_func = CFunc( - name=f"_{type_string_lower}_array_pop", - ret_type=type_string, - args=[ - CArg(name="array", _type=array, pointer=CPointer(CPointerType.SINGLE)), - ], - body=__format_func_body( - filename=snippets_dir / "array_pop", - type_string=type_string, - type_string_upper=type_string_upper, - type_string_lower=type_string_lower, - array_typename=array_data.array_typename, - ), - pointer=CPointer(CPointerType.SINGLE), - ) + pop_func = CFunc( + name=f"_{type_string_lower}_array_pop", + ret_type=type_string, + args=[ + CArg(name="array", _type=array, pointer=CPointer(CPointerType.SINGLE)), + ], + body=__format_func_body( + filename=snippets_dir / "array_pop", + type_string=type_string, + type_string_upper=type_string_upper, + type_string_lower=type_string_lower, + array_typename=array_data.array_typename, + ), + pointer=CPointer(CPointerType.SINGLE), + ) + + header.macros.extend([ + alloc_capacity_array_macro, + ]) + header.c_macros.extend([ + stack_array_cmacro, + stack_capacity_array_cmacro, + array_pop_cmacro, + ]) + header.cpp_macros.extend([ + stack_array_cppmacro, + stack_capacity_array_cppmacro, + array_pop_cppmacro, + ]) + header.funcs.extend([ + get_func, + set_func, + append_capped_func, + extend_capped_func, + clear_func, + copy_capped_func, + append_alloc_func, + extend_alloc_func, + copy_alloc_func, + pop_func, + ]) header.decl_types.extend(array_data.hdr_decl_types) - header.macros.extend([ - alloc_capacity_array_macro, - ]) - header.c_macros.extend([ - stack_array_cmacro, - stack_capacity_array_cmacro, - array_pop_cmacro, - ]) - header.cpp_macros.extend([ - stack_array_cppmacro, - stack_capacity_array_cppmacro, - array_pop_cppmacro, - ]) header.types.extend([array]) - header.funcs.extend([ - get_func, - set_func, - append_capped_func, - extend_capped_func, - clear_func, - copy_capped_func, - append_alloc_func, - extend_alloc_func, - copy_alloc_func, - pop_func, - ]) source.decl_types.extend(array_data.src_decl_types) source.funcs = header.funcs diff --git a/codegen/array/snippets/alloc_capacity b/codegen/array/snippets/alloc_capacity index 0fb0f4b..1fe9e13 100644 --- a/codegen/array/snippets/alloc_capacity +++ b/codegen/array/snippets/alloc_capacity @@ -1,4 +1,4 @@ - wapp_debug_assert(allocator != NULL, "`array` should not be NULL"); + wapp_debug_assert(allocator != NULL, "`allocator` should not be NULL"); u64 allocation_size = sizeof({ArrayType}) + item_size * capacity; {ArrayType} *array = wapp_mem_allocator_alloc(allocator, allocation_size); diff --git a/codegen/datatypes.py b/codegen/datatypes.py index 0e7b8e7..32b53a2 100644 --- a/codegen/datatypes.py +++ b/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. */ """ diff --git a/codegen/dbl_list/make_dbl_list.py b/codegen/dbl_list/make_dbl_list.py index 4bcc167..975cac7 100644 --- a/codegen/dbl_list/make_dbl_list.py +++ b/codegen/dbl_list/make_dbl_list.py @@ -56,16 +56,11 @@ 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] = { + 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", @@ -77,14 +72,10 @@ def make_dbl_list(user_datatypes: Dict[CDataType, DblListData] = {}): for _type in CType: if _type == CType.VOID: - datatypes["void *"] = DblListData( - node_typename="VoidPNode", - list_typename="VoidPList", - ) continue type_title = _type.value.title() - datatypes[_type.value] = DblListData( + datatypes[_type] = DblListData( node_typename=f"{type_title}Node", list_typename=f"{type_title}List", ) @@ -111,16 +102,11 @@ 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") @@ -147,6 +133,13 @@ def make_dbl_list(user_datatypes: Dict[CDataType, DblListData] = {}): ], ) + 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( @@ -326,10 +319,8 @@ def make_dbl_list(user_datatypes: Dict[CDataType, DblListData] = {}): qualifiers=[CQualifier.INTERNAL], ) - header.decl_types.extend(dbl_list_data.hdr_decl_types) header.c_macros.append(node_cmacro) header.cpp_macros.append(node_cppmacro) - header.types.extend([node, dl_list]) header.funcs.extend([ get_func, push_front_func, @@ -341,7 +332,6 @@ def make_dbl_list(user_datatypes: Dict[CDataType, DblListData] = {}): empty_func, ]) - source.decl_types.extend(dbl_list_data.src_decl_types) source.internal_funcs.append(node_to_list_func) source.funcs = header.funcs diff --git a/src/core/file/file.c b/src/core/file/file.c new file mode 100644 index 0000000..cd69fba --- /dev/null +++ b/src/core/file/file.c @@ -0,0 +1,103 @@ +// vim:fileencoding=utf-8:foldmethod=marker + +#include "file.h" +#include "../os/cpath/cpath.h" +#include "../../common/assert/assert.h" +#include "../../common/aliases/aliases.h" +#include "../../primitives/array/array.h" +#include "../../primitives/strings/str8/str8.h" +#include + +File *wapp_file_open(Str8RO *filepath, FileAccessMode mode) { + persistent const char *modes[FILE_ACCESS_MODE_COUNT] = { + [WAPP_FA_MODE_R] = "r", + [WAPP_FA_MODE_W] = "w", + [WAPP_FA_MODE_A] = "a", + [WAPP_FA_MODE_R_EX] = "r+", + [WAPP_FA_MODE_W_EX] = "w+", + [WAPP_FA_MODE_A_EX] = "a+", + [WAPP_FA_MODE_RB] = "rb", + [WAPP_FA_MODE_WB] = "wb", + [WAPP_FA_MODE_AB] = "ab", + [WAPP_FA_MODE_RB_EX] = "rb+", + [WAPP_FA_MODE_WB_EX] = "wb+", + [WAPP_FA_MODE_AB_EX] = "ab+", + [WAPP_FA_MODE_WX] = "wx", + [WAPP_FA_MODE_WX_EX] = "wx+", + [WAPP_FA_MODE_WBX] = "wbx", + [WAPP_FA_MODE_WBX_EX] = "wbx+", + }; + persistent c8 tmp[WAPP_PATH_MAX] = {0}; + wapp_debug_assert(filepath->size < WAPP_PATH_MAX, "`filepath` exceeds max path limit."); + + memset(tmp, 0, WAPP_PATH_MAX); + memcpy(tmp, filepath->buf, filepath->size); + + return fopen((const char *)tmp, modes[mode]); +} + +u64 wapp_file_get_current_position(File *file) { + wapp_debug_assert(file != NULL, "`file` should not be NULL."); + return (u64)ftell(file); +} + +i32 wapp_file_seek(File *file, u64 offset, FileSeekOrigin origin) { + wapp_debug_assert(file != NULL, "`file` should not be NULL."); + return fseek(file, offset, origin); +} + +u64 wapp_file_get_length(File *file) { + wapp_debug_assert(file != NULL, "`file` should not be NULL."); + + u64 current = wapp_file_get_current_position(file); + + wapp_file_seek(file, 0, WAPP_SEEK_END); + + u64 output = ftell(file); + + // Restore position + wapp_file_seek(file, current, WAPP_SEEK_START); + + return output; +} + +u64 wapp_file_read(GenericArray *dst, File *file, u64 item_count) { + wapp_debug_assert(dst != NULL && dst->items != NULL && file != NULL, + "`dst`, `dst->items` and `file` should not be NULL."); + + u64 file_length = wapp_file_get_length(file); + u64 dst_byte_capacity = dst->item_size * dst->capacity; + u64 req_byte_count = item_count * dst->item_size; + u64 copy_byte_count = 0; + + if (req_byte_count <= file_length && req_byte_count <= dst_byte_capacity) { + copy_byte_count = req_byte_count; + } else { + copy_byte_count = file_length <= dst_byte_capacity ? file_length : dst_byte_capacity; + } + + dst->count = fread(dst->items, sizeof(u8), copy_byte_count, file) / dst->item_size; + + return dst->count; +} + +u64 wapp_file_write(const GenericArray *src, File *file, u64 item_count) { + wapp_debug_assert(src != NULL && src->items != NULL && file != NULL, + "`src`, `src->items` and `file` should not be NULL."); + + u64 src_byte_count = src->count * src->item_size; + u64 req_byte_count = item_count * src->item_size; + u64 to_copy = req_byte_count <= src_byte_count ? req_byte_count : src_byte_count; + + return fwrite(src->items, sizeof(u8), to_copy, file); +} + +i32 wapp_file_flush(File *file) { + wapp_debug_assert(file != NULL, "`file` should not be NULL."); + return fflush(file); +} + +i32 wapp_file_close(File *file) { + wapp_debug_assert(file != NULL, "`file` should not be NULL."); + return fclose(file); +} diff --git a/src/core/file/file.h b/src/core/file/file.h new file mode 100644 index 0000000..7822e68 --- /dev/null +++ b/src/core/file/file.h @@ -0,0 +1,72 @@ +// vim:fileencoding=utf-8:foldmethod=marker + +#ifndef FILE_H +#define FILE_H + +#include "../../common/aliases/aliases.h" +#include "../../primitives/array/array.h" +#include "../../primitives/strings/str8/str8.h" +#include + +#ifdef WAPP_PLATFORM_CPP +BEGIN_C_LINKAGE +#endif // !WAPP_PLATFORM_CPP + +#ifdef WAPP_PLATFORM_CPP +#define wapp_file_item_to_array(ITEM) (GenericArray{&(ITEM), 1, 1, sizeof(ITEM)}) +#define wapp_file_array_to_item(TYPE, ARRAY) (sizeof(TYPE) == (ARRAY).item_size && (ARRAY).count == 1 ? \ + *((TYPE *)((ARRAY).items)) : \ + TYPE{}) +#else +#define wapp_file_item_to_array(ITEM) ((GenericArray){.items = &(ITEM), \ + .count = 1, \ + .capacity = 1, \ + .item_size = sizeof(ITEM)}) +#define wapp_file_array_to_item(TYPE, ARRAY) (sizeof(TYPE) == (ARRAY).item_size && (ARRAY).count == 1 ? \ + *((TYPE *)((ARRAY).items)) : \ + (TYPE){0}) +#endif // !WAPP_PLATFORM_CPP + +typedef FILE File; + +typedef enum { + WAPP_FA_MODE_R, // Equivalent to r + WAPP_FA_MODE_W, // Equivalent to w + WAPP_FA_MODE_A, // Equivalent to a + WAPP_FA_MODE_R_EX, // Equivalent to r+ + WAPP_FA_MODE_W_EX, // Equivalent to w+ + WAPP_FA_MODE_A_EX, // Equivalent to a+ + WAPP_FA_MODE_RB, // Equivalent to rb + WAPP_FA_MODE_WB, // Equivalent to wb + WAPP_FA_MODE_AB, // Equivalent to ab + WAPP_FA_MODE_RB_EX, // Equivalent to rb+ + WAPP_FA_MODE_WB_EX, // Equivalent to wb+ + WAPP_FA_MODE_AB_EX, // Equivalent to ab+ + WAPP_FA_MODE_WX, // Equivalent to wx + WAPP_FA_MODE_WX_EX, // Equivalent to wx+ + WAPP_FA_MODE_WBX, // Equivalent to wbx + WAPP_FA_MODE_WBX_EX, // Equivalent to wbx+ + + FILE_ACCESS_MODE_COUNT, +} FileAccessMode; + +typedef enum { + WAPP_SEEK_START = SEEK_SET, + WAPP_SEEK_CURRENT = SEEK_CUR, + WAPP_SEEK_END = SEEK_END, +} FileSeekOrigin; + +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(GenericArray *dst, File *file, u64 item_count); +u64 wapp_file_write(const GenericArray *src, File *file, u64 item_count); +i32 wapp_file_flush(File *file); +i32 wapp_file_close(File *file); + +#ifdef WAPP_PLATFORM_CPP +END_C_LINKAGE +#endif // !WAPP_PLATFORM_CPP + +#endif // !FILE_H diff --git a/src/core/mem/arena/mem_arena.c b/src/core/mem/arena/mem_arena.c index aa8d9fe..11b3a49 100644 --- a/src/core/mem/arena/mem_arena.c +++ b/src/core/mem/arena/mem_arena.c @@ -6,7 +6,6 @@ #include "../../../common/assert/assert.h" #include "../../../common/misc/misc_utils.h" #include "../../os/mem/mem_os.h" -#include #include #include @@ -22,14 +21,14 @@ struct arena { u8 *buf; u8 *offset; u64 capacity; - bool committed; + b32 committed; #ifdef WAPP_PLATFORM_WINDOWS - wapp_misc_utils_padding_size(sizeof(u8 *) * 2 + sizeof(u64) + sizeof(bool)); + wapp_misc_utils_padding_size(sizeof(u8 *) * 2 + sizeof(u64) + sizeof(b32)); #endif // ifdef WAPP_PLATFORM_WINDOWS }; -bool wapp_mem_arena_init_custom(Arena **arena, u64 base_capacity, MemAllocFlags flags, bool zero_buffer) { +b32 wapp_mem_arena_init_custom(Arena **arena, u64 base_capacity, MemAllocFlags flags, b32 zero_buffer) { if (!arena || *arena || base_capacity == 0) { return false; } diff --git a/src/core/mem/arena/mem_arena.h b/src/core/mem/arena/mem_arena.h index ec05f32..79d72b2 100644 --- a/src/core/mem/arena/mem_arena.h +++ b/src/core/mem/arena/mem_arena.h @@ -6,7 +6,6 @@ #include "../../../common/aliases/aliases.h" #include "../../../common/platform/platform.h" #include "../../os/mem/mem_os.h" -#include #ifdef WAPP_PLATFORM_CPP BEGIN_C_LINKAGE @@ -28,7 +27,7 @@ typedef struct arena Arena; * control over how the Arena is initialised. Wrapper macros are provided for * easier use. */ -bool wapp_mem_arena_init_custom(Arena **arena, u64 base_capacity, MemAllocFlags flags, bool zero_buffer); +b32 wapp_mem_arena_init_custom(Arena **arena, u64 base_capacity, MemAllocFlags flags, b32 zero_buffer); void *wapp_mem_arena_alloc(Arena *arena, u64 size); void *wapp_mem_arena_alloc_aligned(Arena *arena, u64 size, u64 alignment); void *wapp_mem_arena_realloc(Arena *arena, void *ptr, u64 old_size, u64 new_size); diff --git a/src/core/mem/arena/mem_arena_allocator.c b/src/core/mem/arena/mem_arena_allocator.c index 4ac0a29..efa538b 100644 --- a/src/core/mem/arena/mem_arena_allocator.c +++ b/src/core/mem/arena/mem_arena_allocator.c @@ -12,9 +12,9 @@ internal inline void *mem_arena_realloc_aligned(void *ptr, u64 old_size, u64 new void *alloc_obj); -Allocator wapp_mem_arena_allocator_init_custom(u64 base_capacity, MemAllocFlags flags, bool zero_buffer) { +Allocator wapp_mem_arena_allocator_init_custom(u64 base_capacity, MemAllocFlags flags, b32 zero_buffer) { Allocator allocator = {0}; - bool initialised = wapp_mem_arena_init_custom((Arena **)(&allocator.obj), base_capacity, flags, zero_buffer); + b32 initialised = wapp_mem_arena_init_custom((Arena **)(&allocator.obj), base_capacity, flags, zero_buffer); if (!initialised) { return allocator; } diff --git a/src/core/mem/arena/mem_arena_allocator.h b/src/core/mem/arena/mem_arena_allocator.h index f0bd4c3..8fae2f4 100644 --- a/src/core/mem/arena/mem_arena_allocator.h +++ b/src/core/mem/arena/mem_arena_allocator.h @@ -7,7 +7,6 @@ #include "../../../common/platform/platform.h" #include "../../../primitives/mem_allocator/mem_allocator.h" #include "../../os/mem/mem_os.h" -#include #ifdef WAPP_PLATFORM_CPP BEGIN_C_LINKAGE @@ -33,7 +32,7 @@ BEGIN_C_LINKAGE * The `wapp_mem_arena_allocator_init_custom` provides the most control over how * the Arena is initialised. Wrapper macros are provided for easier use. */ -Allocator wapp_mem_arena_allocator_init_custom(u64 base_capacity, MemAllocFlags flags, bool zero_buffer); +Allocator wapp_mem_arena_allocator_init_custom(u64 base_capacity, MemAllocFlags flags, b32 zero_buffer); void wapp_mem_arena_allocator_clear(Allocator *allocator); void wapp_mem_arena_allocator_destroy(Allocator *allocator); diff --git a/src/core/mem/utils/mem_utils.c b/src/core/mem/utils/mem_utils.c index 01a07ce..1ff94a4 100644 --- a/src/core/mem/utils/mem_utils.c +++ b/src/core/mem/utils/mem_utils.c @@ -3,10 +3,9 @@ #include "mem_utils.h" #include "../../../common/aliases/aliases.h" #include "../../../common/assert/assert.h" -#include #include -internal bool is_power_of_two(u64 num) { return (num & (num - 1)) == 0; } +internal b32 is_power_of_two(u64 num) { return (num & (num - 1)) == 0; } void *wapp_mem_util_align_forward(void *ptr, u64 alignment) { wapp_debug_assert(ptr != NULL, "`ptr` should not be NULL"); diff --git a/src/core/os/cpath/cpath.c b/src/core/os/cpath/cpath.c index dd895b5..e92518a 100644 --- a/src/core/os/cpath/cpath.c +++ b/src/core/os/cpath/cpath.c @@ -8,7 +8,6 @@ #include "../../../primitives/mem_allocator/mem_allocator.h" #include "../../../primitives/strings/str8/str8.h" #include -#include #include #include @@ -22,7 +21,7 @@ u32 wapp_cpath_join_path(Str8 *dst, const Str8List *parts) { } Str8 separator = wapp_str8_buf(4); - wapp_str8_push_back(&separator, PATH_SEP); + wapp_str8_push_back(&separator, WAPP_PATH_SEP); u64 required_capacity = parts->node_count * separator.size + wapp_str8_list_total_size(parts); if (dst->capacity < required_capacity) { @@ -37,7 +36,7 @@ u32 wapp_cpath_join_path(Str8 *dst, const Str8List *parts) { // MSVC Spectre mitigation warnings const Str8Node *node = first_node; u64 node_index = 1; - bool running = node_index < parts->node_count; + b32 running = node_index < parts->node_count; while (running && node->next) { node = node->next; if (node->item->size == 0) { @@ -45,9 +44,9 @@ u32 wapp_cpath_join_path(Str8 *dst, const Str8List *parts) { } if (dst->size > 0) { - char dst_last = wapp_str8_get(dst, dst->size - 1); - char node_start = wapp_str8_get(node->item, 0); - bool add_path_sep = dst_last != PATH_SEP && node_start != PATH_SEP; + char dst_last = wapp_str8_get(dst, dst->size - 1); + char node_start = wapp_str8_get(node->item, 0); + b32 add_path_sep = dst_last != WAPP_PATH_SEP && node_start != WAPP_PATH_SEP; if (add_path_sep) { wapp_str8_concat_capped(dst, &separator); @@ -69,9 +68,9 @@ Str8 *dirup(const Allocator *allocator, Str8RO *path, u64 levels) { goto RETURN_DIRUP; } - bool absolute = wapp_str8_get(path, 0) == PATH_SEP; + b32 absolute = wapp_str8_get(path, 0) == WAPP_PATH_SEP; Str8 separator = wapp_str8_buf(4); - wapp_str8_push_back(&separator, PATH_SEP); + wapp_str8_push_back(&separator, WAPP_PATH_SEP); if (path->size == 0) { output = wapp_str8_alloc_buf(allocator, 16); @@ -79,7 +78,7 @@ Str8 *dirup(const Allocator *allocator, Str8RO *path, u64 levels) { goto RETURN_DIRUP; } - wapp_str8_push_back(output, absolute ? PATH_SEP : '.'); + wapp_str8_push_back(output, absolute ? WAPP_PATH_SEP : '.'); goto RETURN_DIRUP; } @@ -104,7 +103,7 @@ Str8 *dirup(const Allocator *allocator, Str8RO *path, u64 levels) { goto LIST_CLEANUP_DIRUP; } - wapp_str8_push_back(output, absolute ? PATH_SEP : '.'); + wapp_str8_push_back(output, absolute ? WAPP_PATH_SEP : '.'); } else { for (u64 i = 0; i < levels; ++i) { wapp_str8_list_pop_back(parts); @@ -118,7 +117,7 @@ Str8 *dirup(const Allocator *allocator, Str8RO *path, u64 levels) { output = wapp_str8_alloc_buf(allocator, alloc_size); if (output) { if (absolute) { - wapp_str8_push_back(output, PATH_SEP); + wapp_str8_push_back(output, WAPP_PATH_SEP); } Str8 *joined = wapp_str8_join(&tmp_arena, parts, &separator); diff --git a/src/core/os/cpath/cpath.h b/src/core/os/cpath/cpath.h index f8363d5..7453985 100644 --- a/src/core/os/cpath/cpath.h +++ b/src/core/os/cpath/cpath.h @@ -13,9 +13,13 @@ BEGIN_C_LINKAGE #endif // !WAPP_PLATFORM_CPP #ifdef WAPP_PLATFORM_POSIX -#define PATH_SEP '/' +#include +#define WAPP_PATH_SEP '/' +#define WAPP_PATH_MAX PATH_MAX #elif defined(WAPP_PLATFORM_WINDOWS) -#define PATH_SEP '\\' +#include +#define WAPP_PATH_SEP '\\' +#define WAPP_PATH_MAX MAX_PATH #else #error "Unrecognised platform" #endif diff --git a/src/core/os/mem/mem_os.c b/src/core/os/mem/mem_os.c index 9e3ee04..2679b2c 100644 --- a/src/core/os/mem/mem_os.c +++ b/src/core/os/mem/mem_os.c @@ -5,7 +5,6 @@ #include "../../../common/aliases/aliases.h" #include "../../../common/platform/platform.h" #include -#include #include #if defined(WAPP_PLATFORM_WINDOWS) diff --git a/src/core/os/shell/commander/commander.c b/src/core/os/shell/commander/commander.c index 3420582..52da856 100644 --- a/src/core/os/shell/commander/commander.c +++ b/src/core/os/shell/commander/commander.c @@ -10,7 +10,6 @@ #include "../../../../primitives/mem_allocator/mem_allocator.h" #include "../../../../primitives/strings/str8/str8.h" #include -#include #include #include #include diff --git a/src/core/os/shell/commander/commander.h b/src/core/os/shell/commander/commander.h index 3a54657..7fca6ee 100644 --- a/src/core/os/shell/commander/commander.h +++ b/src/core/os/shell/commander/commander.h @@ -7,7 +7,6 @@ #include "../../../../common/aliases/aliases.h" #include "../../../../common/platform/platform.h" #include "../../../../primitives/strings/str8/str8.h" -#include #include #include diff --git a/src/core/os/shell/commander/commander_output.h b/src/core/os/shell/commander/commander_output.h index 32b2b12..b596194 100644 --- a/src/core/os/shell/commander/commander_output.h +++ b/src/core/os/shell/commander/commander_output.h @@ -5,7 +5,6 @@ #include "../../../../common/aliases/aliases.h" #include "../../../../common/platform/platform.h" -#include #ifdef WAPP_PLATFORM_CPP BEGIN_C_LINKAGE @@ -30,11 +29,11 @@ typedef struct commander_result CMDResult; struct commander_result { i32 exit_code; CMDError error; - bool exited; + b32 exited; #ifdef WAPP_PLATFORM_WINDOWS #include "../../../../common/misc/misc_utils.h" - wapp_misc_utils_padding_size(sizeof(bool) + sizeof(i32) + sizeof(CMDError)); + wapp_misc_utils_padding_size(sizeof(b32) + sizeof(i32) + sizeof(CMDError)); #endif // !WAPP_PLATFORM_WINDOWS }; diff --git a/src/core/wapp_core.c b/src/core/wapp_core.c index 34d8bcb..eb11156 100644 --- a/src/core/wapp_core.c +++ b/src/core/wapp_core.c @@ -4,6 +4,7 @@ #define WAPP_CORE_C #include "wapp_core.h" +#include "file/file.c" #include "os/shell/termcolour/posix/termcolour_posix.c" #include "os/shell/termcolour/win/termcolour_win.c" #include "os/shell/termcolour/termcolour.c" diff --git a/src/core/wapp_core.h b/src/core/wapp_core.h index 54320cd..964508a 100644 --- a/src/core/wapp_core.h +++ b/src/core/wapp_core.h @@ -3,6 +3,7 @@ #ifndef WAPP_CORE_H #define WAPP_CORE_H +#include "file/file.h" #include "os/shell/termcolour/termcolour.h" #include "os/shell/termcolour/terminal_colours.h" #include "os/shell/commander/commander.h" diff --git a/src/primitives/array/array.c b/src/primitives/array/array.c index 207e8f1..b7b2176 100644 --- a/src/primitives/array/array.c +++ b/src/primitives/array/array.c @@ -1,165 +1,15 @@ /** - * 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" #include "../../common/platform/platform.h" #include -Str8 *wapp_str8_array_get(const Str8Array *array, u64 index) { - wapp_debug_assert(array != NULL, "`array` should not be NULL"); - wapp_runtime_assert(index < array->count, "`index` is out of bounds"); - - u8 *ptr = (u8 *)(array->items) + (array->item_size * index); - return (Str8 *)ptr; -} - -void wapp_str8_array_set(Str8Array *array, u64 index, Str8 *item) { - Str8 *ptr = wapp_str8_array_get(array, index); - - memcpy((void *)ptr, (void *)item, array->item_size); -} - -void wapp_str8_array_append_capped(Str8Array *array, Str8 *item) { - wapp_debug_assert(array != NULL, "`array` should not be NULL"); - wapp_runtime_assert(array->count < array->capacity, "`array` is full"); - - u64 index = (array->count)++; - wapp_str8_array_set(array, index, item); -} - -void wapp_str8_array_extend_capped(Str8Array *array, const Str8Array *other) { - wapp_debug_assert(array != NULL && other != NULL, "`array` and `other` should not be NULL"); - - u64 remaining_capacity = array->capacity - array->count; - wapp_runtime_assert(other->count < remaining_capacity, "`array` does not have enough capacity"); - - Str8 *item; - - // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of - // MSVC Spectre mitigation warnings - u64 items_to_add = other->count; - u64 item_index = 0; - b32 running = true; - while (running) { - item = wapp_str8_array_get(other, item_index); - ++item_index; - running = item_index < items_to_add; - - if (!item) { - continue; - } - - wapp_str8_array_append_capped(array, item); - } -} - -void wapp_str8_array_clear(Str8Array *array) { - wapp_debug_assert(array != NULL, "`array` should not be NULL"); - array->count = 0; -} - -void wapp_str8_array_copy_capped(const Str8Array *src, Str8Array *dst) { - wapp_debug_assert(src != NULL && dst != NULL, "`src` and `dst` should not be NULL"); - - wapp_str8_array_clear(dst); - - Str8 *item; - - // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of - // MSVC Spectre mitigation warnings - u64 to_copy = src->count < dst->capacity ? src->count : dst->capacity; - u64 item_index = 0; - b32 running = true; - while (running) { - item = wapp_str8_array_get(src, item_index); - ++item_index; - running = item_index < to_copy; - - if (!item) { - continue; - } - - wapp_str8_array_append_capped(dst, item); - } -} - -Str8Array *wapp_str8_array_append_alloc(const Allocator *allocator, Str8Array *array, Str8 *item) { - wapp_debug_assert(allocator != NULL && array != NULL, "`allocator` and `array` should not be NULL"); - - Str8Array *output = array; - - if (array->count >= array->capacity) { - u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(array->capacity * 2); - output = (Str8Array *)_array_alloc_capacity(allocator, new_capacity, array->item_size); - if (!output) { - output = array; - goto RETURN_STR8_ARRAY_APPEND_ALLOC; - } - wapp_str8_array_copy_capped(array, output); - } - - wapp_str8_array_append_capped(output, item); - -RETURN_STR8_ARRAY_APPEND_ALLOC: - return output; -} - -Str8Array *wapp_str8_array_extend_alloc(const Allocator *allocator, Str8Array *array, const Str8Array *other) { - wapp_debug_assert(allocator != NULL && array != NULL && other != NULL, "`allocator`, `array` and `other` should not be NULL"); - - Str8Array *output = array; - - u64 remaining_capacity = array->capacity - array->count; - if (other->count >= remaining_capacity) { - u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(array->capacity * 2); - output = (Str8Array *)_array_alloc_capacity(allocator, new_capacity, array->item_size); - if (!output) { - output = array; - goto RETURN_STR8_ARRAY_EXTEND_ALLOC; - } - wapp_str8_array_copy_capped(array, output); - } - - wapp_str8_array_extend_capped(output, other); - -RETURN_STR8_ARRAY_EXTEND_ALLOC: - return output; -} - -Str8Array *wapp_str8_array_copy_alloc(const Allocator *allocator, const Str8Array *src, Str8Array *dst) { - wapp_debug_assert(allocator != NULL && src != NULL && dst != NULL, "`allocator`, `src` and `dst` should not be NULL"); - - Str8Array *output = dst; - - if (src->count >= dst->capacity) { - u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(dst->capacity * 2); - output = (Str8Array *)_array_alloc_capacity(allocator, new_capacity, src->item_size); - if (!output) { - output = dst; - goto RETURN_STR8_ARRAY_COPY_ALLOC; - } - } - - wapp_str8_array_clear(output); - wapp_str8_array_copy_capped(src, output); - -RETURN_STR8_ARRAY_COPY_ALLOC: - return output; -} - -Str8 *_str8_array_pop(Str8Array *array) { - u64 index = array->count - 1; - Str8 *out = wapp_str8_array_get(array, index); - --(array->count); - return out; -} - void * *wapp_void_ptr_array_get(const VoidPArray *array, u64 index) { wapp_debug_assert(array != NULL, "`array` should not be NULL"); wapp_runtime_assert(index < array->count, "`index` is out of bounds"); @@ -309,6 +159,155 @@ void * *_void_ptr_array_pop(VoidPArray *array) { return out; } +Str8 *wapp_str8_array_get(const Str8Array *array, u64 index) { + wapp_debug_assert(array != NULL, "`array` should not be NULL"); + wapp_runtime_assert(index < array->count, "`index` is out of bounds"); + + u8 *ptr = (u8 *)(array->items) + (array->item_size * index); + return (Str8 *)ptr; +} + +void wapp_str8_array_set(Str8Array *array, u64 index, Str8 *item) { + Str8 *ptr = wapp_str8_array_get(array, index); + + memcpy((void *)ptr, (void *)item, array->item_size); +} + +void wapp_str8_array_append_capped(Str8Array *array, Str8 *item) { + wapp_debug_assert(array != NULL, "`array` should not be NULL"); + wapp_runtime_assert(array->count < array->capacity, "`array` is full"); + + u64 index = (array->count)++; + wapp_str8_array_set(array, index, item); +} + +void wapp_str8_array_extend_capped(Str8Array *array, const Str8Array *other) { + wapp_debug_assert(array != NULL && other != NULL, "`array` and `other` should not be NULL"); + + u64 remaining_capacity = array->capacity - array->count; + wapp_runtime_assert(other->count < remaining_capacity, "`array` does not have enough capacity"); + + Str8 *item; + + // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of + // MSVC Spectre mitigation warnings + u64 items_to_add = other->count; + u64 item_index = 0; + b32 running = true; + while (running) { + item = wapp_str8_array_get(other, item_index); + ++item_index; + running = item_index < items_to_add; + + if (!item) { + continue; + } + + wapp_str8_array_append_capped(array, item); + } +} + +void wapp_str8_array_clear(Str8Array *array) { + wapp_debug_assert(array != NULL, "`array` should not be NULL"); + array->count = 0; +} + +void wapp_str8_array_copy_capped(const Str8Array *src, Str8Array *dst) { + wapp_debug_assert(src != NULL && dst != NULL, "`src` and `dst` should not be NULL"); + + wapp_str8_array_clear(dst); + + Str8 *item; + + // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of + // MSVC Spectre mitigation warnings + u64 to_copy = src->count < dst->capacity ? src->count : dst->capacity; + u64 item_index = 0; + b32 running = true; + while (running) { + item = wapp_str8_array_get(src, item_index); + ++item_index; + running = item_index < to_copy; + + if (!item) { + continue; + } + + wapp_str8_array_append_capped(dst, item); + } +} + +Str8Array *wapp_str8_array_append_alloc(const Allocator *allocator, Str8Array *array, Str8 *item) { + wapp_debug_assert(allocator != NULL && array != NULL, "`allocator` and `array` should not be NULL"); + + Str8Array *output = array; + + if (array->count >= array->capacity) { + u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(array->capacity * 2); + output = (Str8Array *)_array_alloc_capacity(allocator, new_capacity, array->item_size); + if (!output) { + output = array; + goto RETURN_STR8_ARRAY_APPEND_ALLOC; + } + wapp_str8_array_copy_capped(array, output); + } + + wapp_str8_array_append_capped(output, item); + +RETURN_STR8_ARRAY_APPEND_ALLOC: + return output; +} + +Str8Array *wapp_str8_array_extend_alloc(const Allocator *allocator, Str8Array *array, const Str8Array *other) { + wapp_debug_assert(allocator != NULL && array != NULL && other != NULL, "`allocator`, `array` and `other` should not be NULL"); + + Str8Array *output = array; + + u64 remaining_capacity = array->capacity - array->count; + if (other->count >= remaining_capacity) { + u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(array->capacity * 2); + output = (Str8Array *)_array_alloc_capacity(allocator, new_capacity, array->item_size); + if (!output) { + output = array; + goto RETURN_STR8_ARRAY_EXTEND_ALLOC; + } + wapp_str8_array_copy_capped(array, output); + } + + wapp_str8_array_extend_capped(output, other); + +RETURN_STR8_ARRAY_EXTEND_ALLOC: + return output; +} + +Str8Array *wapp_str8_array_copy_alloc(const Allocator *allocator, const Str8Array *src, Str8Array *dst) { + wapp_debug_assert(allocator != NULL && src != NULL && dst != NULL, "`allocator`, `src` and `dst` should not be NULL"); + + Str8Array *output = dst; + + if (src->count >= dst->capacity) { + u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(dst->capacity * 2); + output = (Str8Array *)_array_alloc_capacity(allocator, new_capacity, src->item_size); + if (!output) { + output = dst; + goto RETURN_STR8_ARRAY_COPY_ALLOC; + } + } + + wapp_str8_array_clear(output); + wapp_str8_array_copy_capped(src, output); + +RETURN_STR8_ARRAY_COPY_ALLOC: + return output; +} + +Str8 *_str8_array_pop(Str8Array *array) { + u64 index = array->count - 1; + Str8 *out = wapp_str8_array_get(array, index); + --(array->count); + return out; +} + b32 *wapp_b32_array_get(const B32Array *array, u64 index) { wapp_debug_assert(array != NULL, "`array` should not be NULL"); wapp_runtime_assert(index < array->count, "`index` is out of bounds"); @@ -2991,16 +2990,16 @@ uptr *_uptr_array_pop(UptrArray *array) { return out; } -VoidPArray *_array_alloc_capacity(const Allocator *allocator, u64 capacity, u64 item_size) { - wapp_debug_assert(allocator != NULL, "`array` should not be NULL"); +GenericArray *_array_alloc_capacity(const Allocator *allocator, u64 capacity, u64 item_size) { + wapp_debug_assert(allocator != NULL, "`allocator` should not be NULL"); - u64 allocation_size = sizeof(VoidPArray) + item_size * capacity; - VoidPArray *array = wapp_mem_allocator_alloc(allocator, allocation_size); + u64 allocation_size = sizeof(GenericArray) + item_size * capacity; + GenericArray *array = wapp_mem_allocator_alloc(allocator, allocation_size); if (!array) { goto RETURN_GENERIC_ARRAY_ALLOC; } - array->items = (void * *)((u8 *)array + sizeof(VoidPArray)); + array->items = (void *)((u8 *)array + sizeof(GenericArray)); array->count = 0; array->capacity = capacity; array->item_size = item_size; diff --git a/src/primitives/array/array.h b/src/primitives/array/array.h index a786faa..c0eb503 100644 --- a/src/primitives/array/array.h +++ b/src/primitives/array/array.h @@ -1,11 +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. */ #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" @@ -15,8 +14,8 @@ BEGIN_C_LINKAGE #endif // !WAPP_PLATFORM_CPP -#define wapp_str8_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY) ((Str8Array *)_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY, sizeof(Str8))) #define wapp_void_ptr_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY) ((VoidPArray *)_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY, sizeof(void *))) +#define wapp_str8_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY) ((Str8Array *)_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY, sizeof(Str8))) #define wapp_b32_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY) ((B32Array *)_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY, sizeof(b32))) #define wapp_char_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY) ((CharArray *)_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY, sizeof(char))) #define wapp_c8_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY) ((C8Array *)_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY, sizeof(c8))) @@ -37,23 +36,6 @@ BEGIN_C_LINKAGE #define wapp_uptr_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY) ((UptrArray *)_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY, sizeof(uptr))) #ifdef WAPP_PLATFORM_CPP -#define wapp_str8_array(...) ([&]() { \ - persistent Str8 buf[wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(Str8, __VA_ARGS__) * 2)] = {__VA_ARGS__}; \ - return Str8Array{ \ - buf, \ - wapp_misc_utils_va_args_count(Str8, __VA_ARGS__), \ - wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(Str8, __VA_ARGS__) * 2), \ - sizeof(Str8) \ - }; \ -}()) -#define wapp_str8_array_with_capacity(CAPACITY) ([&]() { \ - persistent Str8 buf[CAPACITY] = {}; \ - return Str8Array{buf, 0, CAPACITY, sizeof(Str8)}; \ -}()) -#define wapp_str8_array_pop(ARRAY_PTR) (ARRAY_PTR != NULL && (ARRAY_PTR)->count > 0 ? \ - *_str8_array_pop(ARRAY_PTR) : \ - Str8{} \ -) #define wapp_void_ptr_array(...) ([&]() { \ persistent void * buf[wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(void *, __VA_ARGS__) * 2)] = {__VA_ARGS__}; \ return VoidPArray{ \ @@ -71,6 +53,23 @@ BEGIN_C_LINKAGE *_void_ptr_array_pop(ARRAY_PTR) : \ void *{} \ ) +#define wapp_str8_array(...) ([&]() { \ + persistent Str8 buf[wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(Str8, __VA_ARGS__) * 2)] = {__VA_ARGS__}; \ + return Str8Array{ \ + buf, \ + wapp_misc_utils_va_args_count(Str8, __VA_ARGS__), \ + wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(Str8, __VA_ARGS__) * 2), \ + sizeof(Str8) \ + }; \ +}()) +#define wapp_str8_array_with_capacity(CAPACITY) ([&]() { \ + persistent Str8 buf[CAPACITY] = {}; \ + return Str8Array{buf, 0, CAPACITY, sizeof(Str8)}; \ +}()) +#define wapp_str8_array_pop(ARRAY_PTR) (ARRAY_PTR != NULL && (ARRAY_PTR)->count > 0 ? \ + *_str8_array_pop(ARRAY_PTR) : \ + Str8{} \ +) #define wapp_b32_array(...) ([&]() { \ persistent b32 buf[wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(b32, __VA_ARGS__) * 2)] = {__VA_ARGS__}; \ return B32Array{ \ @@ -378,17 +377,6 @@ BEGIN_C_LINKAGE uptr{} \ ) #else -#define wapp_str8_array(...) ((Str8Array){ \ - .items = (Str8[wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(Str8, __VA_ARGS__) * 2)]){__VA_ARGS__}, \ - .count = wapp_misc_utils_va_args_count(Str8, __VA_ARGS__), \ - .capacity = wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(Str8, __VA_ARGS__) * 2), \ - .item_size = sizeof(Str8) \ -}) -#define wapp_str8_array_with_capacity(CAPACITY) ((Str8Array){.items = (Str8[CAPACITY]){0}, .count = 0, .capacity = CAPACITY, .item_size = sizeof(Str8)}) -#define wapp_str8_array_pop(ARRAY_PTR) (ARRAY_PTR != NULL && (ARRAY_PTR)->count > 0 ? \ - *_str8_array_pop(ARRAY_PTR) : \ - (Str8){0} \ -) #define wapp_void_ptr_array(...) ((VoidPArray){ \ .items = (void *[wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(void *, __VA_ARGS__) * 2)]){__VA_ARGS__}, \ .count = wapp_misc_utils_va_args_count(void *, __VA_ARGS__), \ @@ -400,6 +388,17 @@ BEGIN_C_LINKAGE *_void_ptr_array_pop(ARRAY_PTR) : \ (void *){0} \ ) +#define wapp_str8_array(...) ((Str8Array){ \ + .items = (Str8[wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(Str8, __VA_ARGS__) * 2)]){__VA_ARGS__}, \ + .count = wapp_misc_utils_va_args_count(Str8, __VA_ARGS__), \ + .capacity = wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(Str8, __VA_ARGS__) * 2), \ + .item_size = sizeof(Str8) \ +}) +#define wapp_str8_array_with_capacity(CAPACITY) ((Str8Array){.items = (Str8[CAPACITY]){0}, .count = 0, .capacity = CAPACITY, .item_size = sizeof(Str8)}) +#define wapp_str8_array_pop(ARRAY_PTR) (ARRAY_PTR != NULL && (ARRAY_PTR)->count > 0 ? \ + *_str8_array_pop(ARRAY_PTR) : \ + (Str8){0} \ +) #define wapp_b32_array(...) ((B32Array){ \ .items = (b32[wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(b32, __VA_ARGS__) * 2)]){__VA_ARGS__}, \ .count = wapp_misc_utils_va_args_count(b32, __VA_ARGS__), \ @@ -602,9 +601,9 @@ BEGIN_C_LINKAGE typedef struct str8 Str8; -typedef struct Str8Array Str8Array; -struct Str8Array { - Str8 *items; +typedef struct GenericArray GenericArray; +struct GenericArray { + void *items; u64 count; u64 capacity; u64 item_size; @@ -618,6 +617,14 @@ struct VoidPArray { u64 item_size; }; +typedef struct Str8Array Str8Array; +struct Str8Array { + Str8 *items; + u64 count; + u64 capacity; + u64 item_size; +}; + typedef struct B32Array B32Array; struct B32Array { b32 *items; @@ -762,16 +769,6 @@ struct UptrArray { u64 item_size; }; -Str8 *wapp_str8_array_get(const Str8Array *array, u64 index); -void wapp_str8_array_set(Str8Array *array, u64 index, Str8 *item); -void wapp_str8_array_append_capped(Str8Array *array, Str8 *item); -void wapp_str8_array_extend_capped(Str8Array *array, const Str8Array *other); -void wapp_str8_array_clear(Str8Array *array); -void wapp_str8_array_copy_capped(const Str8Array *src, Str8Array *dst); -Str8Array *wapp_str8_array_append_alloc(const Allocator *allocator, Str8Array *array, Str8 *item); -Str8Array *wapp_str8_array_extend_alloc(const Allocator *allocator, Str8Array *array, const Str8Array *other); -Str8Array *wapp_str8_array_copy_alloc(const Allocator *allocator, const Str8Array *src, Str8Array *dst); -Str8 *_str8_array_pop(Str8Array *array); void * *wapp_void_ptr_array_get(const VoidPArray *array, u64 index); void wapp_void_ptr_array_set(VoidPArray *array, u64 index, void * *item); void wapp_void_ptr_array_append_capped(VoidPArray *array, void * *item); @@ -782,6 +779,16 @@ VoidPArray *wapp_void_ptr_array_append_alloc(const Allocator *allocator, VoidPAr VoidPArray *wapp_void_ptr_array_extend_alloc(const Allocator *allocator, VoidPArray *array, const VoidPArray *other); VoidPArray *wapp_void_ptr_array_copy_alloc(const Allocator *allocator, const VoidPArray *src, VoidPArray *dst); void * *_void_ptr_array_pop(VoidPArray *array); +Str8 *wapp_str8_array_get(const Str8Array *array, u64 index); +void wapp_str8_array_set(Str8Array *array, u64 index, Str8 *item); +void wapp_str8_array_append_capped(Str8Array *array, Str8 *item); +void wapp_str8_array_extend_capped(Str8Array *array, const Str8Array *other); +void wapp_str8_array_clear(Str8Array *array); +void wapp_str8_array_copy_capped(const Str8Array *src, Str8Array *dst); +Str8Array *wapp_str8_array_append_alloc(const Allocator *allocator, Str8Array *array, Str8 *item); +Str8Array *wapp_str8_array_extend_alloc(const Allocator *allocator, Str8Array *array, const Str8Array *other); +Str8Array *wapp_str8_array_copy_alloc(const Allocator *allocator, const Str8Array *src, Str8Array *dst); +Str8 *_str8_array_pop(Str8Array *array); b32 *wapp_b32_array_get(const B32Array *array, u64 index); void wapp_b32_array_set(B32Array *array, u64 index, b32 *item); void wapp_b32_array_append_capped(B32Array *array, b32 *item); @@ -962,7 +969,7 @@ UptrArray *wapp_uptr_array_append_alloc(const Allocator *allocator, UptrArray *a UptrArray *wapp_uptr_array_extend_alloc(const Allocator *allocator, UptrArray *array, const UptrArray *other); UptrArray *wapp_uptr_array_copy_alloc(const Allocator *allocator, const UptrArray *src, UptrArray *dst); uptr *_uptr_array_pop(UptrArray *array); -VoidPArray *_array_alloc_capacity(const Allocator *allocator, u64 capacity, u64 item_size); +GenericArray *_array_alloc_capacity(const Allocator *allocator, u64 capacity, u64 item_size); #ifdef WAPP_PLATFORM_CPP END_C_LINKAGE diff --git a/src/primitives/dbl_list/dbl_list.c b/src/primitives/dbl_list/dbl_list.c index 9578b7f..3cb9d5c 100644 --- a/src/primitives/dbl_list/dbl_list.c +++ b/src/primitives/dbl_list/dbl_list.c @@ -1,17 +1,15 @@ /** - * 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 -#include -internal Str8List str8_node_to_list(Str8Node *node); internal VoidPList void_ptr_node_to_list(VoidPNode *node); +internal Str8List str8_node_to_list(Str8Node *node); internal B32List b32_node_to_list(B32Node *node); internal CharList char_node_to_list(CharNode *node); internal C8List c8_node_to_list(C8Node *node); @@ -31,179 +29,6 @@ internal F128List f128_node_to_list(F128Node *node); internal IptrList iptr_node_to_list(IptrNode *node); internal UptrList uptr_node_to_list(UptrNode *node); -Str8Node *wapp_str8_list_get(const Str8List *list, u64 index) { - wapp_runtime_assert(index < list->node_count, "`index` is out of bounds"); - - Str8Node *output = NULL; - Str8Node *current = list->first; - for (u64 i = 1; i <= index; ++i) { - current = current->next; - } - - output = current; - - return output; -} - -void wapp_str8_list_push_front(Str8List *list, Str8Node *node) { - wapp_debug_assert(list != NULL && node != NULL && (node->item) != NULL, "`list`, `node` and `node->item` should not be NULL"); - - Str8List node_list = str8_node_to_list(node); - - if (list->node_count == 0) { - *list = node_list; - return; - } - - list->node_count += node_list.node_count; - - Str8Node *first = list->first; - if (first) { - first->prev = node_list.last; - } - - list->first = node_list.first; - node_list.last->next = first; -} - -void wapp_str8_list_push_back(Str8List *list, Str8Node *node) { - wapp_debug_assert(list != NULL && node != NULL && (node->item) != NULL, "`list`, `node` and `node->item` should not be NULL"); - - Str8List node_list = str8_node_to_list(node); - - if (list->node_count == 0) { - *list = node_list; - return; - } - - list->node_count += node_list.node_count; - - Str8Node *last = list->last; - if (last) { - last->next = node_list.first; - } - - list->last = node_list.last; - node_list.first->prev = last; -} - -void wapp_str8_list_insert(Str8List *list, Str8Node *node, u64 index) { - wapp_debug_assert(list != NULL && node != NULL && (node->item) != NULL, "`list`, `node` and `node->item` should not be NULL"); - - if (index == 0) { - wapp_str8_list_push_front(list, node); - return; - } else if (index == list->node_count) { - wapp_str8_list_push_back(list, node); - return; - } - - Str8Node *dst_node = wapp_str8_list_get(list, index); - if (!dst_node) { - return; - } - - Str8List node_list = str8_node_to_list(node); - - list->node_count += node_list.node_count; - - Str8Node *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; -} - -Str8Node *wapp_str8_list_pop_front(Str8List *list) { - wapp_debug_assert(list != NULL, "`list` should not be NULL"); - - Str8Node *output = NULL; - - if (list->node_count == 0) { - goto RETURN_STR8_LIST_POP_FRONT; - } - - output = list->first; - - if (list->node_count == 1) { - *list = (Str8List){0}; - goto RETURN_STR8_LIST_POP_FRONT; - } - - --(list->node_count); - list->first = output->next; - - output->prev = output->next = NULL; - -RETURN_STR8_LIST_POP_FRONT: - return output; -} - -Str8Node *wapp_str8_list_pop_back(Str8List *list) { - wapp_debug_assert(list != NULL, "`list` should not be NULL"); - - Str8Node *output = NULL; - - if (list->node_count == 0) { - goto RETURN_STR8_LIST_POP_BACK; - } - - output = list->last; - - if (list->node_count == 1) { - *list = (Str8List){0}; - goto RETURN_STR8_LIST_POP_BACK; - } - - --(list->node_count); - list->last = output->prev; - - output->prev = output->next = NULL; - -RETURN_STR8_LIST_POP_BACK: - return output; -} - -Str8Node *wapp_str8_list_remove(Str8List *list, u64 index) { - wapp_debug_assert(list != NULL, "`list` should not be NULL"); - - Str8Node *output = NULL; - - if (index == 0) { - output = wapp_str8_list_pop_front(list); - goto RETURN_STR8_LIST_REMOVE; - } else if (index == list->node_count) { - output = wapp_str8_list_pop_back(list); - goto RETURN_STR8_LIST_REMOVE; - } - - output = wapp_str8_list_get(list, index); - if (!output) { - goto RETURN_STR8_LIST_REMOVE; - } - - output->prev->next = output->next; - output->next->prev = output->prev; - - --(list->node_count); - - output->prev = output->next = NULL; - -RETURN_STR8_LIST_REMOVE: - return output; -} - -void wapp_str8_list_empty(Str8List *list) { - wapp_debug_assert(list != NULL, "`list` should not be NULL"); - - u64 count = list->node_count; - for (u64 i = 0; i < count; ++i) { - wapp_str8_list_pop_back(list); - } -} - VoidPNode *wapp_void_ptr_list_get(const VoidPList *list, u64 index) { wapp_runtime_assert(index < list->node_count, "`index` is out of bounds"); @@ -377,6 +202,179 @@ void wapp_void_ptr_list_empty(VoidPList *list) { } } +Str8Node *wapp_str8_list_get(const Str8List *list, u64 index) { + wapp_runtime_assert(index < list->node_count, "`index` is out of bounds"); + + Str8Node *output = NULL; + Str8Node *current = list->first; + for (u64 i = 1; i <= index; ++i) { + current = current->next; + } + + output = current; + + return output; +} + +void wapp_str8_list_push_front(Str8List *list, Str8Node *node) { + wapp_debug_assert(list != NULL && node != NULL && (node->item) != NULL, "`list`, `node` and `node->item` should not be NULL"); + + Str8List node_list = str8_node_to_list(node); + + if (list->node_count == 0) { + *list = node_list; + return; + } + + list->node_count += node_list.node_count; + + Str8Node *first = list->first; + if (first) { + first->prev = node_list.last; + } + + list->first = node_list.first; + node_list.last->next = first; +} + +void wapp_str8_list_push_back(Str8List *list, Str8Node *node) { + wapp_debug_assert(list != NULL && node != NULL && (node->item) != NULL, "`list`, `node` and `node->item` should not be NULL"); + + Str8List node_list = str8_node_to_list(node); + + if (list->node_count == 0) { + *list = node_list; + return; + } + + list->node_count += node_list.node_count; + + Str8Node *last = list->last; + if (last) { + last->next = node_list.first; + } + + list->last = node_list.last; + node_list.first->prev = last; +} + +void wapp_str8_list_insert(Str8List *list, Str8Node *node, u64 index) { + wapp_debug_assert(list != NULL && node != NULL && (node->item) != NULL, "`list`, `node` and `node->item` should not be NULL"); + + if (index == 0) { + wapp_str8_list_push_front(list, node); + return; + } else if (index == list->node_count) { + wapp_str8_list_push_back(list, node); + return; + } + + Str8Node *dst_node = wapp_str8_list_get(list, index); + if (!dst_node) { + return; + } + + Str8List node_list = str8_node_to_list(node); + + list->node_count += node_list.node_count; + + Str8Node *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; +} + +Str8Node *wapp_str8_list_pop_front(Str8List *list) { + wapp_debug_assert(list != NULL, "`list` should not be NULL"); + + Str8Node *output = NULL; + + if (list->node_count == 0) { + goto RETURN_STR8_LIST_POP_FRONT; + } + + output = list->first; + + if (list->node_count == 1) { + *list = (Str8List){0}; + goto RETURN_STR8_LIST_POP_FRONT; + } + + --(list->node_count); + list->first = output->next; + + output->prev = output->next = NULL; + +RETURN_STR8_LIST_POP_FRONT: + return output; +} + +Str8Node *wapp_str8_list_pop_back(Str8List *list) { + wapp_debug_assert(list != NULL, "`list` should not be NULL"); + + Str8Node *output = NULL; + + if (list->node_count == 0) { + goto RETURN_STR8_LIST_POP_BACK; + } + + output = list->last; + + if (list->node_count == 1) { + *list = (Str8List){0}; + goto RETURN_STR8_LIST_POP_BACK; + } + + --(list->node_count); + list->last = output->prev; + + output->prev = output->next = NULL; + +RETURN_STR8_LIST_POP_BACK: + return output; +} + +Str8Node *wapp_str8_list_remove(Str8List *list, u64 index) { + wapp_debug_assert(list != NULL, "`list` should not be NULL"); + + Str8Node *output = NULL; + + if (index == 0) { + output = wapp_str8_list_pop_front(list); + goto RETURN_STR8_LIST_REMOVE; + } else if (index == list->node_count) { + output = wapp_str8_list_pop_back(list); + goto RETURN_STR8_LIST_REMOVE; + } + + output = wapp_str8_list_get(list, index); + if (!output) { + goto RETURN_STR8_LIST_REMOVE; + } + + output->prev->next = output->next; + output->next->prev = output->prev; + + --(list->node_count); + + output->prev = output->next = NULL; + +RETURN_STR8_LIST_REMOVE: + return output; +} + +void wapp_str8_list_empty(Str8List *list) { + wapp_debug_assert(list != NULL, "`list` should not be NULL"); + + u64 count = list->node_count; + for (u64 i = 0; i < count; ++i) { + wapp_str8_list_pop_back(list); + } +} + B32Node *wapp_b32_list_get(const B32List *list, u64 index) { wapp_runtime_assert(index < list->node_count, "`index` is out of bounds"); @@ -3491,8 +3489,8 @@ void wapp_uptr_list_empty(UptrList *list) { } } -internal Str8List str8_node_to_list(Str8Node *node) { - Str8List output = {.first = node, .last = node, .node_count = 1}; +internal VoidPList void_ptr_node_to_list(VoidPNode *node) { + VoidPList output = {.first = node, .last = node, .node_count = 1}; while (output.first->prev != NULL) { output.first = output.first->prev; @@ -3507,8 +3505,8 @@ internal Str8List str8_node_to_list(Str8Node *node) { return output; } -internal VoidPList void_ptr_node_to_list(VoidPNode *node) { - VoidPList output = {.first = node, .last = node, .node_count = 1}; +internal Str8List str8_node_to_list(Str8Node *node) { + Str8List output = {.first = node, .last = node, .node_count = 1}; while (output.first->prev != NULL) { output.first = output.first->prev; diff --git a/src/primitives/dbl_list/dbl_list.h b/src/primitives/dbl_list/dbl_list.h index 80f3eae..c91543e 100644 --- a/src/primitives/dbl_list/dbl_list.h +++ b/src/primitives/dbl_list/dbl_list.h @@ -1,11 +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. */ #ifndef DBL_LIST_H #define DBL_LIST_H -#include "../../common/aliases/aliases.h" #include "../../common/aliases/aliases.h" #include "../../common/platform/platform.h" @@ -14,8 +13,8 @@ BEGIN_C_LINKAGE #endif // !WAPP_PLATFORM_CPP #ifdef WAPP_PLATFORM_CPP -#define wapp_str8_list_node(ITEM_PTR) Str8Node{ITEM_PTR, nullptr, nullptr} #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_b32_list_node(ITEM_PTR) B32Node{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} @@ -35,8 +34,8 @@ BEGIN_C_LINKAGE #define wapp_iptr_list_node(ITEM_PTR) IptrNode{ITEM_PTR, nullptr, nullptr} #define wapp_uptr_list_node(ITEM_PTR) UptrNode{ITEM_PTR, nullptr, nullptr} #else -#define wapp_str8_list_node(ITEM_PTR) ((Str8Node){.item = ITEM_PTR}) #define wapp_void_ptr_list_node(ITEM_PTR) ((VoidPNode){.item = ITEM_PTR}) +#define wapp_str8_list_node(ITEM_PTR) ((Str8Node){.item = ITEM_PTR}) #define wapp_b32_list_node(ITEM_PTR) ((B32Node){.item = ITEM_PTR}) #define wapp_char_list_node(ITEM_PTR) ((CharNode){.item = ITEM_PTR}) #define wapp_c8_list_node(ITEM_PTR) ((C8Node){.item = ITEM_PTR}) @@ -59,17 +58,17 @@ BEGIN_C_LINKAGE typedef struct str8 Str8; -typedef struct Str8Node Str8Node; -struct Str8Node { - Str8 *item; - Str8Node *prev; - Str8Node *next; +typedef struct GenericNode GenericNode; +struct GenericNode { + void *item; + GenericNode *prev; + GenericNode *next; }; -typedef struct Str8List Str8List; -struct Str8List { - Str8Node *first; - Str8Node *last; +typedef struct GenericList GenericList; +struct GenericList { + GenericNode *first; + GenericNode *last; u64 node_count; }; @@ -87,6 +86,20 @@ struct VoidPList { 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 B32Node B32Node; struct B32Node { b32 *item; @@ -339,14 +352,6 @@ struct UptrList { u64 node_count; }; -Str8Node *wapp_str8_list_get(const Str8List *list, u64 index); -void wapp_str8_list_push_front(Str8List *list, Str8Node *node); -void wapp_str8_list_push_back(Str8List *list, Str8Node *node); -void wapp_str8_list_insert(Str8List *list, Str8Node *node, u64 index); -Str8Node *wapp_str8_list_pop_front(Str8List *list); -Str8Node *wapp_str8_list_pop_back(Str8List *list); -Str8Node *wapp_str8_list_remove(Str8List *list, u64 index); -void wapp_str8_list_empty(Str8List *list); VoidPNode *wapp_void_ptr_list_get(const VoidPList *list, u64 index); void wapp_void_ptr_list_push_front(VoidPList *list, VoidPNode *node); void wapp_void_ptr_list_push_back(VoidPList *list, VoidPNode *node); @@ -355,6 +360,14 @@ VoidPNode *wapp_void_ptr_list_pop_front(VoidPList *list); VoidPNode *wapp_void_ptr_list_pop_back(VoidPList *list); VoidPNode *wapp_void_ptr_list_remove(VoidPList *list, u64 index); void wapp_void_ptr_list_empty(VoidPList *list); +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); B32Node *wapp_b32_list_get(const B32List *list, u64 index); void wapp_b32_list_push_front(B32List *list, B32Node *node); void wapp_b32_list_push_back(B32List *list, B32Node *node); diff --git a/src/primitives/strings/str8/str8.c b/src/primitives/strings/str8/str8.c index 7a507db..76b97e6 100644 --- a/src/primitives/strings/str8/str8.c +++ b/src/primitives/strings/str8/str8.c @@ -4,11 +4,11 @@ #include "../../../common/aliases/aliases.h" #include "../../../common/assert/assert.h" #include "../../mem_allocator/mem_allocator.h" +#include #include #include #include #include -#include #define STR8_BUF_ALLOC_SIZE(CAPACITY) (sizeof(Str8) + sizeof(c8) * CAPACITY) @@ -123,7 +123,7 @@ void wapp_str8_push_back(Str8 *str, c8 c) { wapp_str8_set(str, index, c); } -bool wapp_str8_equal(Str8RO *s1, Str8RO *s2) { +b32 wapp_str8_equal(Str8RO *s1, Str8RO *s2) { if (s1->size != s2->size) { return false; } @@ -131,7 +131,7 @@ bool wapp_str8_equal(Str8RO *s1, Str8RO *s2) { return wapp_str8_equal_to_count(s1, s2, s1->size); } -bool wapp_str8_equal_to_count(Str8RO* s1, Str8RO* s2, u64 count) { +b32 wapp_str8_equal_to_count(Str8RO* s1, Str8RO* s2, u64 count) { if (!s1 || !s2) { return false; } @@ -163,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 COPY_STRING_STR8_CONCAT; + goto SOURCE_STRING_STR8_CONCAT; } u64 capacity = dst->capacity + src->size; @@ -175,7 +175,7 @@ Str8 *wapp_str8_alloc_concat(const Allocator *allocator, Str8 *dst, Str8RO *src) wapp_str8_concat_capped(output, dst); -COPY_STRING_STR8_CONCAT: +SOURCE_STRING_STR8_CONCAT: wapp_str8_concat_capped(output, src); RETURN_STR8_CONCAT: @@ -240,6 +240,36 @@ 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))); + } +} + +void wapp_str8_from_bytes(Str8 *dst, const U8Array *src) { + u64 size = src->count * src->item_size; + + wapp_debug_assert(src != NULL && dst != NULL, "`dst` and `src` should not be NULL"); + wapp_debug_assert(dst->capacity >= size, "`dst` does not have enough capacity"); + + dst->size = size; + memcpy(dst->buf, src->items, size); +} + i64 wapp_str8_find(Str8RO *str, Str8RO substr) { if (!str || substr.size > str->size) { return -1; @@ -248,7 +278,7 @@ i64 wapp_str8_find(Str8RO *str, Str8RO substr) { // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of // MSVC Spectre mitigation warnings u64 char_index = 0; - bool running = char_index < str->size; + b32 running = char_index < str->size; while (running) { const c8 *sub = str->buf + char_index; if (memcmp(sub, substr.buf, substr.size) == 0) { @@ -270,7 +300,7 @@ i64 wapp_str8_rfind(Str8RO *str, Str8RO substr) { // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of // MSVC Spectre mitigation warnings i64 char_index = str->size - substr.size; - bool running = char_index >= 0; + b32 running = char_index >= 0; while (running) { const c8 *sub = str->buf + char_index; if (memcmp(sub, substr.buf, substr.size) == 0) { @@ -397,7 +427,7 @@ Str8 *wapp_str8_join(const Allocator *allocator, const Str8List *list, Str8RO *d // MSVC Spectre mitigation warnings Str8Node *node; u64 node_index = 0; - bool running = node_index < list->node_count; + b32 running = node_index < list->node_count; while (running) { node = wapp_str8_list_get(list, node_index); if (!node) { @@ -408,7 +438,7 @@ Str8 *wapp_str8_join(const Allocator *allocator, const Str8List *list, Str8RO *d // NOTE (Abdelrahman): Comparison extracted to variable to silence // MSVC Spectre mitigation warnings - bool not_last = node_index + 1 < list->node_count; + b32 not_last = node_index + 1 < list->node_count; if (not_last) { wapp_str8_concat_capped(output, delimiter); } @@ -430,7 +460,7 @@ u64 wapp_str8_list_total_size(const Str8List *list) { Str8Node* node; u64 node_index = 0; u64 output = 0; - bool running = node_index < list->node_count; + b32 running = node_index < list->node_count; while (running) { node = wapp_str8_list_get(list, node_index); if (!node) { diff --git a/src/primitives/strings/str8/str8.h b/src/primitives/strings/str8/str8.h index b74ffc8..1d48e93 100644 --- a/src/primitives/strings/str8/str8.h +++ b/src/primitives/strings/str8/str8.h @@ -6,10 +6,10 @@ #include "../../../common/aliases/aliases.h" #include "../../../common/assert/assert.h" #include "../../../common/platform/platform.h" +#include "../../../primitives/array/array.h" #include "../../../primitives/dbl_list/dbl_list.h" #include "../../mem_allocator/mem_allocator.h" #include -#include #ifdef WAPP_PLATFORM_CPP BEGIN_C_LINKAGE @@ -89,14 +89,17 @@ void wapp_str8_dealloc_buf(const Allocator *allocator, Str8 **str); c8 wapp_str8_get(Str8RO *str, u64 index); void wapp_str8_set(Str8 *str, u64 index, c8 c); void wapp_str8_push_back(Str8 *str, c8 c); -bool wapp_str8_equal(Str8RO *s1, Str8RO *s2); -bool wapp_str8_equal_to_count(Str8RO* s1, Str8RO* s2, u64 count); +b32 wapp_str8_equal(Str8RO *s1, Str8RO *s2); +b32 wapp_str8_equal_to_count(Str8RO* s1, Str8RO* s2, u64 count); Str8 wapp_str8_slice(Str8RO *str, u64 start, u64 end); void wapp_str8_concat_capped(Str8 *dst, Str8RO *src); void wapp_str8_copy_cstr_capped(Str8 *dst, const char *src); void wapp_str8_copy_str8_capped(Str8 *dst, Str8RO *src); void wapp_str8_copy_to_cstr(char *dst, Str8RO *src, u64 dst_capacity); void wapp_str8_format(Str8 *dst, const char *format, ...); +void wapp_str8_to_lower(Str8 *dst, Str8RO *src); +void wapp_str8_to_upper(Str8 *dst, Str8RO *src); +void wapp_str8_from_bytes(Str8 *dst, const U8Array *src); /** * Str8 find functions diff --git a/src/prng/xorshift/xorshift.c b/src/prng/xorshift/xorshift.c index a6e3417..1f2193c 100644 --- a/src/prng/xorshift/xorshift.c +++ b/src/prng/xorshift/xorshift.c @@ -4,7 +4,6 @@ #include "../../common/aliases/aliases.h" #include "../../common/assert/assert.h" #include "../../common/platform/platform.h" -#include #include #include @@ -19,7 +18,7 @@ internal void seed_os_generator(void); internal u64 generate_random_number(void); XOR256State wapp_prng_xorshift_init_state(void) { - persistent bool seeded = false; + persistent b32 seeded = false; if (!seeded) { seeded = true; seed_os_generator(); diff --git a/src/testing/tester/tester.h b/src/testing/tester/tester.h index c8dace5..08469c6 100644 --- a/src/testing/tester/tester.h +++ b/src/testing/tester/tester.h @@ -6,7 +6,6 @@ #include "../../common/misc/misc_utils.h" #include "../../common/platform/platform.h" #include "../../primitives/strings/str8/str8.h" -#include #ifdef WAPP_PLATFORM_CPP BEGIN_C_LINKAGE @@ -23,10 +22,10 @@ BEGIN_C_LINKAGE typedef struct test_func_result TestFuncResult; struct test_func_result { Str8RO name; - bool passed; + b32 passed; #ifdef WAPP_PLATFORM_WINDOWS - wapp_misc_utils_padding_size(sizeof(Str8RO) + sizeof(bool)); + wapp_misc_utils_padding_size(sizeof(Str8RO) + sizeof(b32)); #endif // WAPP_PLATFORM_WINDOWS }; diff --git a/src/uuid/uuid.c b/src/uuid/uuid.c index 30c234c..c20bd6a 100644 --- a/src/uuid/uuid.c +++ b/src/uuid/uuid.c @@ -5,7 +5,6 @@ #include "../common/assert/assert.h" #include "../primitives/strings/str8/str8.h" #include "../prng/xorshift/xorshift.h" -#include #include #define UUID_STR_FORMAT ("%.8" PRIx64 "-%.4" PRIx64 "-%.4" PRIx64 "-%.4" PRIx64 "-%.12" PRIx64) @@ -30,7 +29,7 @@ UUID *wapp_uuid_init_uuid4(UUID *uuid) { internal UUID4 generate_uuid4(void) { persistent XOR256State state = {0}; - persistent bool initialised = false; + persistent b32 initialised = false; if (!initialised) { initialised = true; diff --git a/tests/allocator/test_allocator.c b/tests/allocator/test_allocator.c index 9d02517..1e73ec9 100644 --- a/tests/allocator/test_allocator.c +++ b/tests/allocator/test_allocator.c @@ -1,11 +1,10 @@ #include "test_allocator.h" #include "wapp.h" -#include #include TestFuncResult test_arena_allocator(void) { Allocator allocator = wapp_mem_arena_allocator_init(4096); - bool result = allocator.obj != NULL && allocator.alloc != NULL && + b32 result = allocator.obj != NULL && allocator.alloc != NULL && allocator.alloc_aligned != NULL && allocator.realloc != NULL && allocator.realloc_aligned != NULL && allocator.free == NULL; diff --git a/tests/allocator/test_allocator.cc b/tests/allocator/test_allocator.cc index ffce876..c0e6a50 100644 --- a/tests/allocator/test_allocator.cc +++ b/tests/allocator/test_allocator.cc @@ -1,11 +1,10 @@ #include "test_allocator.h" #include "wapp.h" -#include #include TestFuncResult test_arena_allocator(void) { Allocator allocator = wapp_mem_arena_allocator_init(4096); - bool result = allocator.obj != nullptr && allocator.alloc != nullptr && + b32 result = allocator.obj != nullptr && allocator.alloc != nullptr && allocator.alloc_aligned != nullptr && allocator.realloc != nullptr && allocator.realloc_aligned != nullptr && allocator.free == nullptr; diff --git a/tests/arena/test_arena.c b/tests/arena/test_arena.c index c13abff..55b792e 100644 --- a/tests/arena/test_arena.c +++ b/tests/arena/test_arena.c @@ -1,6 +1,5 @@ #include "test_arena.h" #include "wapp.h" -#include #include #define ARENA_CAPACITY KB(16) @@ -10,7 +9,7 @@ internal i32 count = 20; internal i32 *array = NULL; TestFuncResult test_arena_init(void) { - bool result = wapp_mem_arena_init(&arena, ARENA_CAPACITY); + b32 result = wapp_mem_arena_init(&arena, ARENA_CAPACITY); return wapp_tester_result(result); } @@ -18,7 +17,7 @@ TestFuncResult test_arena_init(void) { TestFuncResult test_arena_init_succeeds_when_reserving_very_large_size(void) { Arena *large_arena = NULL; u64 capacity = GB(512); - bool result = wapp_mem_arena_init(&large_arena, capacity); + b32 result = wapp_mem_arena_init(&large_arena, capacity); if (result) { wapp_mem_arena_destroy(&large_arena); } @@ -28,7 +27,7 @@ TestFuncResult test_arena_init_succeeds_when_reserving_very_large_size(void) { TestFuncResult test_arena_alloc_succeeds_when_within_capacity(void) { array = wapp_mem_arena_alloc(arena, count * sizeof(i32)); - bool result = array != NULL; + b32 result = array != NULL; for (i32 i = 0; i < count; ++i) { array[i] = i * 10; @@ -39,7 +38,7 @@ TestFuncResult test_arena_alloc_succeeds_when_within_capacity(void) { TestFuncResult test_arena_alloc_fails_when_over_capacity(void) { u8 *bytes = wapp_mem_arena_alloc(arena, ARENA_CAPACITY * 2); - bool result = bytes == NULL; + b32 result = bytes == NULL; return wapp_tester_result(result); } @@ -92,7 +91,7 @@ TestFuncResult test_arena_realloc_smaller_size(void) { TestFuncResult test_arena_clear(void) { wapp_mem_arena_clear(arena); - bool result = true; + b32 result = true; for (i32 i = 0; i < count; ++i) { if (array[i] != 0) { @@ -106,7 +105,7 @@ TestFuncResult test_arena_clear(void) { TestFuncResult test_arena_destroy(void) { wapp_mem_arena_destroy(&arena); - bool result = arena == NULL; + b32 result = arena == NULL; return wapp_tester_result(result); } diff --git a/tests/arena/test_arena.cc b/tests/arena/test_arena.cc index b934f98..b0da436 100644 --- a/tests/arena/test_arena.cc +++ b/tests/arena/test_arena.cc @@ -1,6 +1,5 @@ #include "test_arena.h" #include "wapp.h" -#include #include #define ARENA_CAPACITY KB(16) @@ -10,7 +9,7 @@ internal i32 count = 20; internal i32 *array = nullptr; TestFuncResult test_arena_init(void) { - bool result = wapp_mem_arena_init(&arena, ARENA_CAPACITY); + b32 result = wapp_mem_arena_init(&arena, ARENA_CAPACITY); return wapp_tester_result(result); } @@ -18,7 +17,7 @@ TestFuncResult test_arena_init(void) { TestFuncResult test_arena_init_succeeds_when_reserving_very_large_size(void) { Arena *large_arena = nullptr; u64 capacity = GB(512); - bool result = wapp_mem_arena_init(&large_arena, capacity); + b32 result = wapp_mem_arena_init(&large_arena, capacity); if (result) { wapp_mem_arena_destroy(&large_arena); } @@ -28,7 +27,7 @@ TestFuncResult test_arena_init_succeeds_when_reserving_very_large_size(void) { TestFuncResult test_arena_alloc_succeeds_when_within_capacity(void) { array = (i32 *)wapp_mem_arena_alloc(arena, count * sizeof(i32)); - bool result = array != nullptr; + b32 result = array != nullptr; for (i32 i = 0; i < count; ++i) { array[i] = i * 10; @@ -39,7 +38,7 @@ TestFuncResult test_arena_alloc_succeeds_when_within_capacity(void) { TestFuncResult test_arena_alloc_fails_when_over_capacity(void) { u8 *bytes = (u8 *)wapp_mem_arena_alloc(arena, ARENA_CAPACITY * 2); - bool result = bytes == nullptr; + b32 result = bytes == nullptr; return wapp_tester_result(result); } @@ -92,7 +91,7 @@ TestFuncResult test_arena_realloc_smaller_size(void) { TestFuncResult test_arena_clear(void) { wapp_mem_arena_clear(arena); - bool result = true; + b32 result = true; for (i32 i = 0; i < count; ++i) { if (array[i] != 0) { @@ -106,7 +105,7 @@ TestFuncResult test_arena_clear(void) { TestFuncResult test_arena_destroy(void) { wapp_mem_arena_destroy(&arena); - bool result = arena == nullptr; + b32 result = arena == nullptr; return wapp_tester_result(result); } diff --git a/tests/array/test_i32_array.c b/tests/array/test_i32_array.c index f8f82d4..a2e108c 100644 --- a/tests/array/test_i32_array.c +++ b/tests/array/test_i32_array.c @@ -1,9 +1,8 @@ #include "test_i32_array.h" #include "wapp.h" -#include TestFuncResult test_i32_array(void) { - bool result; + b32 result; I32Array array = wapp_i32_array(1, 2, 3, 4, 5, 6, 7); result = array.count == 7 && array.capacity == 16; @@ -11,7 +10,7 @@ TestFuncResult test_i32_array(void) { i32 *item; u64 count = array.count; u64 index = 0; - bool running = true; + b32 running = true; while (running) { item = wapp_i32_array_get(&array, index); result = result && item && (*item == (i32)(index + 1)); @@ -24,7 +23,7 @@ TestFuncResult test_i32_array(void) { } TestFuncResult test_i32_array_with_capacity(void) { - bool result; + b32 result; I32Array array = wapp_i32_array_with_capacity(64); result = array.count == 0 && array.capacity == 64; @@ -33,14 +32,14 @@ TestFuncResult test_i32_array_with_capacity(void) { } TestFuncResult test_i32_array_get(void) { - bool result = true; + b32 result = true; I32Array array = wapp_i32_array(0, 1, 2, 3, 4, 5, 6, 7, 8); i32 *item; u64 count = array.count; u64 index = 0; - bool running = true; + b32 running = true; while (running) { item = wapp_i32_array_get(&array, index); result = result && item && (*item == (i32)index); @@ -53,14 +52,14 @@ TestFuncResult test_i32_array_get(void) { } TestFuncResult test_i32_array_set(void) { - bool result = true; + b32 result = true; I32Array array = wapp_i32_array(0, 1, 2, 3, 4, 5, 6, 7, 8); i32 *item; u64 count = array.count; u64 index = 0; - bool running = true; + b32 running = true; while (running) { i32 num = (i32)(index * 2); wapp_i32_array_set(&array, index, &num); @@ -75,7 +74,7 @@ TestFuncResult test_i32_array_set(void) { } TestFuncResult test_i32_array_append_capped(void) { - bool result; + b32 result; I32Array array = wapp_i32_array_with_capacity(64); wapp_i32_array_append_capped(&array, &((i32){10})); @@ -93,7 +92,7 @@ TestFuncResult test_i32_array_append_capped(void) { } TestFuncResult test_i32_array_extend_capped(void) { - bool result; + b32 result; I32Array array1 = wapp_i32_array(1, 2, 3, 4); I32Array array2 = wapp_i32_array(10, 20); @@ -108,7 +107,7 @@ TestFuncResult test_i32_array_extend_capped(void) { } TestFuncResult test_i32_array_clear(void) { - bool result; + b32 result; I32Array array = wapp_i32_array(0, 1, 2, 3, 4, 5, 6, 7, 8); result = array.count == 9; @@ -121,7 +120,7 @@ TestFuncResult test_i32_array_clear(void) { } TestFuncResult test_i32_array_pop(void) { - bool result; + b32 result; I32Array array1 = wapp_i32_array(0, 1, 2, 3, 4, 5, 6, 7, 8); I32Array array2 = wapp_i32_array_with_capacity(32); @@ -135,7 +134,7 @@ TestFuncResult test_i32_array_pop(void) { } TestFuncResult test_i32_array_copy_capped(void) { - bool result; + b32 result; I32Array src = wapp_i32_array(1, 2, 3, 4, 5); I32Array dst1 = wapp_i32_array(1, 2, 3, 4, 5, 6); @@ -146,7 +145,7 @@ TestFuncResult test_i32_array_copy_capped(void) { result = dst1.count == expected_count; u64 index = 0; - bool running = true; + b32 running = true; while (running) { result = result && (*wapp_i32_array_get(&src, index) == *wapp_i32_array_get(&dst1, index)); @@ -171,7 +170,7 @@ TestFuncResult test_i32_array_copy_capped(void) { } TestFuncResult test_i32_array_alloc_capacity(void) { - bool result; + b32 result; Allocator allocator = wapp_mem_arena_allocator_init(MB(4)); u64 capacity = 32; @@ -185,7 +184,7 @@ TestFuncResult test_i32_array_alloc_capacity(void) { } TestFuncResult test_i32_array_append_alloc(void) { - bool result; + b32 result; Allocator allocator = wapp_mem_arena_allocator_init(MB(4)); I32Array array1 = wapp_i32_array(1, 2, 3, 4, 5, 6, 7, 8); @@ -196,7 +195,7 @@ TestFuncResult test_i32_array_append_alloc(void) { u64 count = 4; u64 index = 0; - bool running = true; + b32 running = true; while (running) { i32 num = (i32)index; arr_ptr = wapp_i32_array_append_alloc(&allocator, &array2, &num); @@ -212,7 +211,7 @@ TestFuncResult test_i32_array_append_alloc(void) { } TestFuncResult test_i32_array_extend_alloc(void) { - bool result; + b32 result; Allocator allocator = wapp_mem_arena_allocator_init(MB(4)); I32Array array1 = wapp_i32_array(1, 2, 3, 4, 5, 6, 7, 8); @@ -231,7 +230,7 @@ TestFuncResult test_i32_array_extend_alloc(void) { } TestFuncResult test_i32_array_copy_alloc(void) { - bool result; + b32 result; Allocator allocator = wapp_mem_arena_allocator_init(MB(4)); I32Array src = wapp_i32_array(1, 2, 3, 4, 5); @@ -244,7 +243,7 @@ TestFuncResult test_i32_array_copy_alloc(void) { result = array_ptr->count == expected_count && array_ptr == &dst1; u64 index = 0; - bool running = true; + b32 running = true; while (running) { result = result && (*wapp_i32_array_get(&src, index) == *wapp_i32_array_get(array_ptr, index)); diff --git a/tests/array/test_i32_array.cc b/tests/array/test_i32_array.cc index 2009984..fa92de6 100644 --- a/tests/array/test_i32_array.cc +++ b/tests/array/test_i32_array.cc @@ -1,9 +1,8 @@ #include "test_i32_array.h" #include "wapp.h" -#include TestFuncResult test_i32_array(void) { - bool result; + b32 result; I32Array array = wapp_i32_array(1, 2, 3, 4, 5, 6, 7); result = array.count == 7 && array.capacity == 16; @@ -11,7 +10,7 @@ TestFuncResult test_i32_array(void) { i32 *item; u64 count = array.count; u64 index = 0; - bool running = true; + b32 running = true; while (running) { item = wapp_i32_array_get(&array, index); result = result && item && (*item == (i32)(index + 1)); @@ -24,7 +23,7 @@ TestFuncResult test_i32_array(void) { } TestFuncResult test_i32_array_with_capacity(void) { - bool result; + b32 result; I32Array array = wapp_i32_array_with_capacity(64); result = array.count == 0 && array.capacity == 64; @@ -33,14 +32,14 @@ TestFuncResult test_i32_array_with_capacity(void) { } TestFuncResult test_i32_array_get(void) { - bool result = true; + b32 result = true; I32Array array = wapp_i32_array(0, 1, 2, 3, 4, 5, 6, 7, 8); i32 *item; u64 count = array.count; u64 index = 0; - bool running = true; + b32 running = true; while (running) { item = wapp_i32_array_get(&array, index); result = result && item && (*item == (i32)index); @@ -53,14 +52,14 @@ TestFuncResult test_i32_array_get(void) { } TestFuncResult test_i32_array_set(void) { - bool result = true; + b32 result = true; I32Array array = wapp_i32_array(0, 1, 2, 3, 4, 5, 6, 7, 8); i32 *item; u64 count = array.count; u64 index = 0; - bool running = true; + b32 running = true; while (running) { i32 num = (i32)(index * 2); wapp_i32_array_set(&array, index, &num); @@ -75,7 +74,7 @@ TestFuncResult test_i32_array_set(void) { } TestFuncResult test_i32_array_append_capped(void) { - bool result; + b32 result; I32Array array = wapp_i32_array_with_capacity(64); i32 item1 = 10; @@ -95,7 +94,7 @@ TestFuncResult test_i32_array_append_capped(void) { } TestFuncResult test_i32_array_extend_capped(void) { - bool result; + b32 result; I32Array array1 = wapp_i32_array(1, 2, 3, 4); I32Array array2 = wapp_i32_array(10, 20); @@ -110,7 +109,7 @@ TestFuncResult test_i32_array_extend_capped(void) { } TestFuncResult test_i32_array_clear(void) { - bool result; + b32 result; I32Array array = wapp_i32_array(0, 1, 2, 3, 4, 5, 6, 7, 8); result = array.count == 9; @@ -123,7 +122,7 @@ TestFuncResult test_i32_array_clear(void) { } TestFuncResult test_i32_array_pop(void) { - bool result; + b32 result; I32Array array1 = wapp_i32_array(0, 1, 2, 3, 4, 5, 6, 7, 8); I32Array array2 = wapp_i32_array_with_capacity(32); @@ -137,7 +136,7 @@ TestFuncResult test_i32_array_pop(void) { } TestFuncResult test_i32_array_copy_capped(void) { - bool result; + b32 result; I32Array src = wapp_i32_array(1, 2, 3, 4, 5); I32Array dst1 = wapp_i32_array(1, 2, 3, 4, 5, 6); @@ -148,7 +147,7 @@ TestFuncResult test_i32_array_copy_capped(void) { result = dst1.count == expected_count; u64 index = 0; - bool running = true; + b32 running = true; while (running) { result = result && (*wapp_i32_array_get(&src, index) == *wapp_i32_array_get(&dst1, index)); @@ -173,7 +172,7 @@ TestFuncResult test_i32_array_copy_capped(void) { } TestFuncResult test_i32_array_alloc_capacity(void) { - bool result; + b32 result; Allocator allocator = wapp_mem_arena_allocator_init(MB(4)); u64 capacity = 32; @@ -187,7 +186,7 @@ TestFuncResult test_i32_array_alloc_capacity(void) { } TestFuncResult test_i32_array_append_alloc(void) { - bool result; + b32 result; Allocator allocator = wapp_mem_arena_allocator_init(MB(4)); I32Array array1 = wapp_i32_array(1, 2, 3, 4, 5, 6, 7, 8); @@ -199,7 +198,7 @@ TestFuncResult test_i32_array_append_alloc(void) { u64 count = 4; u64 index = 0; - bool running = true; + b32 running = true; while (running) { i32 num = (i32)index; arr_ptr = wapp_i32_array_append_alloc(&allocator, &array2, &num); @@ -215,7 +214,7 @@ TestFuncResult test_i32_array_append_alloc(void) { } TestFuncResult test_i32_array_extend_alloc(void) { - bool result; + b32 result; Allocator allocator = wapp_mem_arena_allocator_init(MB(4)); I32Array array1 = wapp_i32_array(1, 2, 3, 4, 5, 6, 7, 8); @@ -234,7 +233,7 @@ TestFuncResult test_i32_array_extend_alloc(void) { } TestFuncResult test_i32_array_copy_alloc(void) { - bool result; + b32 result; Allocator allocator = wapp_mem_arena_allocator_init(MB(4)); I32Array src = wapp_i32_array(1, 2, 3, 4, 5); @@ -247,7 +246,7 @@ TestFuncResult test_i32_array_copy_alloc(void) { result = array_ptr->count == expected_count && array_ptr == &dst1; u64 index = 0; - bool running = true; + b32 running = true; while (running) { result = result && (*wapp_i32_array_get(&src, index) == *wapp_i32_array_get(array_ptr, index)); diff --git a/tests/cpath/test_cpath.c b/tests/cpath/test_cpath.c index 003d740..f7fc65a 100644 --- a/tests/cpath/test_cpath.c +++ b/tests/cpath/test_cpath.c @@ -2,20 +2,19 @@ #include "wapp.h" #include #include -#include #define MAIN_BUF_SIZE 4096 #define TMP_BUF_SIZE 1024 TestFuncResult test_cpath_join_path(void) { - bool result; + b32 result; Str8 expected = wapp_str8_buf(MAIN_BUF_SIZE); Str8 out = wapp_str8_buf(MAIN_BUF_SIZE); Str8 tmp = wapp_str8_buf(TMP_BUF_SIZE); - wapp_str8_format(&expected, "%chome%cabdelrahman%cDocuments", PATH_SEP, PATH_SEP, PATH_SEP); - wapp_str8_format(&tmp, "%c", PATH_SEP); + 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)); @@ -28,7 +27,7 @@ TestFuncResult test_cpath_join_path(void) { wapp_str8_list_pop_front(&parts); - wapp_str8_format(&expected, "home%cabdelrahman%cDocuments", PATH_SEP, PATH_SEP); + 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); @@ -37,27 +36,27 @@ TestFuncResult test_cpath_join_path(void) { wapp_str8_list_pop_front(&parts); wapp_str8_list_push_front(&parts, &wapp_str8_node_from_str8(tmp)); - wapp_str8_format(&expected, "%chome%cabdelrahman%cDocuments", PATH_SEP, PATH_SEP, PATH_SEP); + wapp_str8_format(&expected, "%chome%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_PATH_SEP, WAPP_PATH_SEP); wapp_cpath_join_path(&out, &parts); result = result && wapp_str8_equal(&out, &expected); - wapp_str8_format(&tmp, "home%c", PATH_SEP); + 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_str8_format(&expected, "home%cabdelrahman%cDocuments", PATH_SEP, PATH_SEP); + 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_str8_format(&tmp, "%chome", PATH_SEP); + 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_str8_format(&expected, "%chome", PATH_SEP); + wapp_str8_format(&expected, "%chome", WAPP_PATH_SEP); wapp_cpath_join_path(&out, &parts); result = result && wapp_str8_equal(&out, &expected); @@ -87,15 +86,15 @@ TestFuncResult test_cpath_dirname(void) { return wapp_tester_result(false); } - bool result; + b32 result; Str8 *output = NULL; Str8 expected = wapp_str8_buf(MAIN_BUF_SIZE); Str8 tmp = wapp_str8_buf(TMP_BUF_SIZE); // CASE 1 - wapp_str8_format(&tmp, "%c", PATH_SEP); - wapp_str8_format(&expected, "%c", PATH_SEP); + wapp_str8_format(&tmp, "%c", WAPP_PATH_SEP); + wapp_str8_format(&expected, "%c", WAPP_PATH_SEP); output = wapp_cpath_dirname(&arena, &tmp); result = output != NULL && wapp_str8_equal(output, &expected); @@ -111,15 +110,15 @@ TestFuncResult test_cpath_dirname(void) { result = result && output != NULL && wapp_str8_equal(output, &expected); // CASE 4 - wapp_str8_format(&tmp, "%chome%ctest", PATH_SEP, PATH_SEP); - wapp_str8_format(&expected, "%chome", PATH_SEP); + wapp_str8_format(&tmp, "%chome%ctest", WAPP_PATH_SEP, WAPP_PATH_SEP); + wapp_str8_format(&expected, "%chome", WAPP_PATH_SEP); output = wapp_cpath_dirname(&arena, &tmp); result = result && output != NULL && wapp_str8_equal(output, &expected); // CASE 5 - wapp_str8_format(&tmp, "%chome%ctest%c", PATH_SEP, PATH_SEP, PATH_SEP); - wapp_str8_format(&expected, "%chome", PATH_SEP); + wapp_str8_format(&tmp, "%chome%ctest%c", WAPP_PATH_SEP, WAPP_PATH_SEP, WAPP_PATH_SEP); + wapp_str8_format(&expected, "%chome", WAPP_PATH_SEP); output = wapp_cpath_dirname(&arena, &tmp); result = result && output != NULL && wapp_str8_equal(output, &expected); @@ -135,42 +134,42 @@ TestFuncResult test_cpath_dirup(void) { return wapp_tester_result(false); } - bool result; + b32 result; Str8 *output = NULL; Str8 expected = wapp_str8_buf(MAIN_BUF_SIZE); Str8 tmp = wapp_str8_buf(TMP_BUF_SIZE); // CASE 1 - wapp_str8_format(&tmp, "%c", PATH_SEP); - wapp_str8_format(&expected, "%c", PATH_SEP); + wapp_str8_format(&tmp, "%c", WAPP_PATH_SEP); + wapp_str8_format(&expected, "%c", WAPP_PATH_SEP); output = wapp_cpath_dirup(&arena, &tmp, 3); result = output != NULL && wapp_str8_equal(output, &expected); // CASE 2 - wapp_str8_format(&tmp, "%chome%cabdelrahman%cDocuments", PATH_SEP, PATH_SEP, PATH_SEP); - wapp_str8_format(&expected, "%c", PATH_SEP); + wapp_str8_format(&tmp, "%chome%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_PATH_SEP, WAPP_PATH_SEP); + wapp_str8_format(&expected, "%c", WAPP_PATH_SEP); output = wapp_cpath_dirup(&arena, &tmp, 3); result = result && output != NULL && wapp_str8_equal(output, &expected); // CASE 3 - wapp_str8_format(&tmp, "home%cabdelrahman%cDocuments", PATH_SEP, PATH_SEP); + wapp_str8_format(&tmp, "home%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_PATH_SEP); wapp_str8_copy_cstr_capped(&expected, "."); output = wapp_cpath_dirup(&arena, &tmp, 3); result = result && output != NULL && wapp_str8_equal(output, &expected); // CASE 4 - wapp_str8_format(&tmp, "%chome%cabdelrahman%cDocuments", PATH_SEP, PATH_SEP, PATH_SEP); - wapp_str8_format(&expected, "%chome", PATH_SEP); + wapp_str8_format(&tmp, "%chome%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_PATH_SEP, WAPP_PATH_SEP); + wapp_str8_format(&expected, "%chome", WAPP_PATH_SEP); output = wapp_cpath_dirup(&arena, &tmp, 2); result = result && output != NULL && wapp_str8_equal(output, &expected); // CASE 5 - wapp_str8_format(&tmp, "home%cabdelrahman%cDocuments", PATH_SEP, PATH_SEP); + wapp_str8_format(&tmp, "home%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_PATH_SEP); wapp_str8_copy_cstr_capped(&expected, "home"); output = wapp_cpath_dirup(&arena, &tmp, 2); diff --git a/tests/cpath/test_cpath.cc b/tests/cpath/test_cpath.cc index 92cae3a..1acd075 100644 --- a/tests/cpath/test_cpath.cc +++ b/tests/cpath/test_cpath.cc @@ -2,20 +2,19 @@ #include "wapp.h" #include #include -#include #define MAIN_BUF_SIZE 4096 #define TMP_BUF_SIZE 1024 TestFuncResult test_cpath_join_path(void) { - bool result; + b32 result; Str8 expected = wapp_str8_buf(MAIN_BUF_SIZE); Str8 out = wapp_str8_buf(MAIN_BUF_SIZE); Str8 tmp = wapp_str8_buf(TMP_BUF_SIZE); - wapp_str8_format(&expected, "%chome%cabdelrahman%cDocuments", PATH_SEP, PATH_SEP, PATH_SEP); - wapp_str8_format(&tmp, "%c", PATH_SEP); + 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 = {}; @@ -36,7 +35,7 @@ TestFuncResult test_cpath_join_path(void) { wapp_str8_list_pop_front(&parts); - wapp_str8_format(&expected, "home%cabdelrahman%cDocuments", PATH_SEP, PATH_SEP); + 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); @@ -48,25 +47,25 @@ TestFuncResult test_cpath_join_path(void) { Str8Node tmp_node_2 = wapp_str8_node_from_str8(tmp); wapp_str8_list_push_front(&parts, &tmp_node_2); - wapp_str8_format(&expected, "%chome%cabdelrahman%cDocuments", PATH_SEP, PATH_SEP, PATH_SEP); + wapp_str8_format(&expected, "%chome%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_PATH_SEP, WAPP_PATH_SEP); wapp_cpath_join_path(&out, &parts); result = result && wapp_str8_equal(&out, &expected); - wapp_str8_format(&tmp, "home%c", PATH_SEP); + wapp_str8_format(&tmp, "home%c", WAPP_PATH_SEP); wapp_str8_list_pop_front(&parts); Str8Node home_node_2 = wapp_str8_node_from_cstr("home"); wapp_str8_list_push_front(&parts, &home_node_2); - wapp_str8_format(&expected, "home%cabdelrahman%cDocuments", PATH_SEP, PATH_SEP); + 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_str8_format(&tmp, "%chome", PATH_SEP); + 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); @@ -74,7 +73,7 @@ TestFuncResult test_cpath_join_path(void) { Str8Node empty_node = wapp_str8_node_from_cstr(""); wapp_str8_list_push_back(&parts, &empty_node); - wapp_str8_format(&expected, "%chome", PATH_SEP); + wapp_str8_format(&expected, "%chome", WAPP_PATH_SEP); wapp_cpath_join_path(&out, &parts); result = result && wapp_str8_equal(&out, &expected); @@ -108,15 +107,15 @@ TestFuncResult test_cpath_dirname(void) { return wapp_tester_result(false); } - bool result; + b32 result; Str8 *output = nullptr; Str8 expected = wapp_str8_buf(MAIN_BUF_SIZE); Str8 tmp = wapp_str8_buf(TMP_BUF_SIZE); // CASE 1 - wapp_str8_format(&tmp, "%c", PATH_SEP); - wapp_str8_format(&expected, "%c", PATH_SEP); + wapp_str8_format(&tmp, "%c", WAPP_PATH_SEP); + wapp_str8_format(&expected, "%c", WAPP_PATH_SEP); output = wapp_cpath_dirname(&arena, &tmp); result = output != nullptr && wapp_str8_equal(output, &expected); @@ -134,15 +133,15 @@ TestFuncResult test_cpath_dirname(void) { result = result && output != nullptr && wapp_str8_equal(output, &expected); // CASE 4 - wapp_str8_format(&tmp, "%chome%ctest", PATH_SEP, PATH_SEP); - wapp_str8_format(&expected, "%chome", PATH_SEP); + wapp_str8_format(&tmp, "%chome%ctest", WAPP_PATH_SEP, WAPP_PATH_SEP); + wapp_str8_format(&expected, "%chome", WAPP_PATH_SEP); output = wapp_cpath_dirname(&arena, &tmp); result = result && output != nullptr && wapp_str8_equal(output, &expected); // CASE 5 - wapp_str8_format(&tmp, "%chome%ctest%c", PATH_SEP, PATH_SEP, PATH_SEP); - wapp_str8_format(&expected, "%chome", PATH_SEP); + wapp_str8_format(&tmp, "%chome%ctest%c", WAPP_PATH_SEP, WAPP_PATH_SEP, WAPP_PATH_SEP); + wapp_str8_format(&expected, "%chome", WAPP_PATH_SEP); output = wapp_cpath_dirname(&arena, &tmp); result = result && output != nullptr && wapp_str8_equal(output, &expected); @@ -158,42 +157,42 @@ TestFuncResult test_cpath_dirup(void) { return wapp_tester_result(false); } - bool result; + b32 result; Str8 *output = nullptr; Str8 expected = wapp_str8_buf(MAIN_BUF_SIZE); Str8 tmp = wapp_str8_buf(TMP_BUF_SIZE); // CASE 1 - wapp_str8_format(&tmp, "%c", PATH_SEP); - wapp_str8_format(&expected, "%c", PATH_SEP); + wapp_str8_format(&tmp, "%c", WAPP_PATH_SEP); + wapp_str8_format(&expected, "%c", WAPP_PATH_SEP); output = wapp_cpath_dirup(&arena, &tmp, 3); result = output != nullptr && wapp_str8_equal(output, &expected); // CASE 2 - wapp_str8_format(&tmp, "%chome%cabdelrahman%cDocuments", PATH_SEP, PATH_SEP, PATH_SEP); - wapp_str8_format(&expected, "%c", PATH_SEP); + wapp_str8_format(&tmp, "%chome%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_PATH_SEP, WAPP_PATH_SEP); + wapp_str8_format(&expected, "%c", WAPP_PATH_SEP); output = wapp_cpath_dirup(&arena, &tmp, 3); result = result && output != nullptr && wapp_str8_equal(output, &expected); // CASE 3 - wapp_str8_format(&tmp, "home%cabdelrahman%cDocuments", PATH_SEP, PATH_SEP); + wapp_str8_format(&tmp, "home%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_PATH_SEP); wapp_str8_copy_cstr_capped(&expected, "."); output = wapp_cpath_dirup(&arena, &tmp, 3); result = result && output != nullptr && wapp_str8_equal(output, &expected); // CASE 4 - wapp_str8_format(&tmp, "%chome%cabdelrahman%cDocuments", PATH_SEP, PATH_SEP, PATH_SEP); - wapp_str8_format(&expected, "%chome", PATH_SEP); + wapp_str8_format(&tmp, "%chome%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_PATH_SEP, WAPP_PATH_SEP); + wapp_str8_format(&expected, "%chome", WAPP_PATH_SEP); output = wapp_cpath_dirup(&arena, &tmp, 2); result = result && output != nullptr && wapp_str8_equal(output, &expected); // CASE 5 - wapp_str8_format(&tmp, "home%cabdelrahman%cDocuments", PATH_SEP, PATH_SEP); + wapp_str8_format(&tmp, "home%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_PATH_SEP); wapp_str8_copy_cstr_capped(&expected, "home"); output = wapp_cpath_dirup(&arena, &tmp, 2); diff --git a/tests/shell_commander/test_shell_commander.c b/tests/shell_commander/test_shell_commander.c index 3682320..1f650e7 100644 --- a/tests/shell_commander/test_shell_commander.c +++ b/tests/shell_commander/test_shell_commander.c @@ -1,6 +1,5 @@ #include "test_shell_commander.h" #include "wapp.h" -#include #include #include #include @@ -11,7 +10,7 @@ TestFuncResult test_commander_cmd_success(void) { wapp_str8_list_push_back(&cmd, &wapp_str8_node_from_cstr("hello world")); CMDResult result = wapp_shell_commander_execute(SHELL_OUTPUT_DISCARD, NULL, &cmd); - bool succeeded = result.exited && result.exit_code == EXIT_SUCCESS && + b32 succeeded = result.exited && result.exit_code == EXIT_SUCCESS && result.error == SHELL_ERR_NO_ERROR; return wapp_tester_result(succeeded); @@ -22,7 +21,7 @@ TestFuncResult test_commander_cmd_failure(void) { wapp_str8_list_push_back(&cmd, &wapp_str8_node_from_cstr("grep")); CMDResult result = wapp_shell_commander_execute(SHELL_OUTPUT_DISCARD, NULL, &cmd); - bool failed = result.exited && result.exit_code != EXIT_SUCCESS && + b32 failed = result.exited && result.exit_code != EXIT_SUCCESS && result.error == SHELL_ERR_NO_ERROR; return wapp_tester_result(failed); @@ -39,7 +38,7 @@ TestFuncResult test_commander_cmd_out_buf_success(void) { wapp_str8_list_push_back(&cmd, &wapp_str8_node_from_cstr(msg)); CMDResult result = wapp_shell_commander_execute(SHELL_OUTPUT_CAPTURE, &buf, &cmd); - bool succeeded = result.exited && result.exit_code == EXIT_SUCCESS && + b32 succeeded = result.exited && result.exit_code == EXIT_SUCCESS && result.error == SHELL_ERR_NO_ERROR && wapp_str8_equal_to_count(&buf, &expected, strlen(msg)); return wapp_tester_result(succeeded); @@ -56,7 +55,7 @@ TestFuncResult test_commander_cmd_out_buf_failure(void) { wapp_str8_list_push_back(&cmd, &wapp_str8_node_from_cstr(msg)); CMDResult result = wapp_shell_commander_execute(SHELL_OUTPUT_CAPTURE, &buf, &cmd); - bool failed = !result.exited && result.exit_code != EXIT_SUCCESS && + b32 failed = !result.exited && result.exit_code != EXIT_SUCCESS && result.error == SHELL_ERR_OUT_BUF_FULL && !wapp_str8_equal(&buf, &expected); return wapp_tester_result(failed); diff --git a/tests/shell_commander/test_shell_commander.cc b/tests/shell_commander/test_shell_commander.cc index 2594055..192f75d 100644 --- a/tests/shell_commander/test_shell_commander.cc +++ b/tests/shell_commander/test_shell_commander.cc @@ -1,6 +1,5 @@ #include "test_shell_commander.h" #include "wapp.h" -#include #include #include #include @@ -13,7 +12,7 @@ TestFuncResult test_commander_cmd_success(void) { wapp_str8_list_push_back(&cmd, &msg); CMDResult result = wapp_shell_commander_execute(SHELL_OUTPUT_DISCARD, nullptr, &cmd); - bool succeeded = result.exited && result.exit_code == EXIT_SUCCESS && + b32 succeeded = result.exited && result.exit_code == EXIT_SUCCESS && result.error == SHELL_ERR_NO_ERROR; return wapp_tester_result(succeeded); @@ -25,7 +24,7 @@ TestFuncResult test_commander_cmd_failure(void) { wapp_str8_list_push_back(&cmd, &grep); CMDResult result = wapp_shell_commander_execute(SHELL_OUTPUT_DISCARD, nullptr, &cmd); - bool failed = result.exited && result.exit_code != EXIT_SUCCESS && + b32 failed = result.exited && result.exit_code != EXIT_SUCCESS && result.error == SHELL_ERR_NO_ERROR; return wapp_tester_result(failed); @@ -44,7 +43,7 @@ TestFuncResult test_commander_cmd_out_buf_success(void) { wapp_str8_list_push_back(&cmd, &arg); CMDResult result = wapp_shell_commander_execute(SHELL_OUTPUT_CAPTURE, &buf, &cmd); - bool succeeded = result.exited && result.exit_code == EXIT_SUCCESS && + b32 succeeded = result.exited && result.exit_code == EXIT_SUCCESS && result.error == SHELL_ERR_NO_ERROR && wapp_str8_equal_to_count(&buf, &expected, strlen(msg)); return wapp_tester_result(succeeded); @@ -63,7 +62,7 @@ TestFuncResult test_commander_cmd_out_buf_failure(void) { wapp_str8_list_push_back(&cmd, &arg); CMDResult result = wapp_shell_commander_execute(SHELL_OUTPUT_CAPTURE, &buf, &cmd); - bool failed = !result.exited && result.exit_code != EXIT_SUCCESS && + b32 failed = !result.exited && result.exit_code != EXIT_SUCCESS && result.error == SHELL_ERR_OUT_BUF_FULL && !wapp_str8_equal(&buf, &expected); return wapp_tester_result(failed); diff --git a/tests/str8/test_str8.c b/tests/str8/test_str8.c index 053c1da..d6f393a 100644 --- a/tests/str8/test_str8.c +++ b/tests/str8/test_str8.c @@ -1,11 +1,10 @@ #include "test_str8.h" #include "wapp.h" -#include #define ARRLEN(ARR) (sizeof(ARR) / sizeof(ARR[0])) TestFuncResult test_str8_lit(void) { - bool result; + b32 result; Str8 s1 = wapp_str8_lit("Hello world"); result = s1.capacity == 22 && s1.capacity != s1.size; @@ -32,7 +31,7 @@ TestFuncResult test_str8_lit(void) { } TestFuncResult test_str8_lit_ro(void) { - bool result; + b32 result; Str8RO s1 = wapp_str8_lit_ro("Hello world"); result = s1.capacity == 11 && s1.capacity == s1.size; @@ -59,7 +58,7 @@ TestFuncResult test_str8_lit_ro(void) { } TestFuncResult test_str8_buf(void) { - bool result; + b32 result; Str8 s1 = wapp_str8_buf(1024); result = s1.capacity == 1024 && s1.size == 0; @@ -77,7 +76,7 @@ TestFuncResult test_str8_buf(void) { } TestFuncResult test_str8_alloc_buf(void) { - bool result; + b32 result; Allocator allocator = wapp_mem_arena_allocator_init(KB(100)); if (wapp_mem_allocator_invalid(&allocator)) { return wapp_tester_result(false); @@ -105,7 +104,7 @@ TEST_ALLOC_BUF_CLEANUP: } TestFuncResult test_str8_alloc_cstr(void) { - bool result; + b32 result; Allocator allocator = wapp_mem_arena_allocator_init(KB(100)); if (wapp_mem_allocator_invalid(&allocator)) { return wapp_tester_result(false); @@ -126,7 +125,7 @@ TestFuncResult test_str8_alloc_cstr(void) { } TestFuncResult test_str8_alloc_str8(void) { - bool result; + b32 result; Allocator allocator = wapp_mem_arena_allocator_init(KB(100)); if (wapp_mem_allocator_invalid(&allocator)) { return wapp_tester_result(false); @@ -146,7 +145,7 @@ TestFuncResult test_str8_alloc_str8(void) { } TestFuncResult test_str8_alloc_substr(void) { - bool result; + b32 result; Allocator allocator = wapp_mem_arena_allocator_init(KB(100)); if (wapp_mem_allocator_invalid(&allocator)) { return wapp_tester_result(false); @@ -166,7 +165,7 @@ TestFuncResult test_str8_alloc_substr(void) { } TestFuncResult test_str8_get_index_within_bounds(void) { - bool result; + b32 result; Str8RO s1 = wapp_str8_lit_ro("Hello world"); result = wapp_str8_get(&s1, 4) == 'o'; @@ -194,12 +193,12 @@ TestFuncResult test_str8_get_index_within_bounds(void) { TestFuncResult test_str8_get_index_out_of_bounds(void) { Str8 s1 = wapp_str8_lit("Hello world"); - bool result = wapp_str8_get(&s1, 20) == '\0'; + b32 result = wapp_str8_get(&s1, 20) == '\0'; return wapp_tester_result(result); } TestFuncResult test_str8_set(void) { - bool result; + b32 result; Str8 s1 = wapp_str8_lit("Hello world"); wapp_str8_set(&s1, 4, 'f'); @@ -233,7 +232,7 @@ TestFuncResult test_str8_set(void) { } TestFuncResult test_str8_push_back(void) { - bool result; + b32 result; Str8 expected = wapp_str8_lit("Abdelrahman"); Str8 buf = wapp_str8_buf(64); @@ -255,7 +254,7 @@ TestFuncResult test_str8_push_back(void) { } TestFuncResult test_str8_equal(void) { - bool result; + b32 result; Str8RO s1 = wapp_str8_lit_ro("hello"); Str8RO s2 = wapp_str8_lit_ro("hell"); @@ -270,7 +269,7 @@ TestFuncResult test_str8_equal(void) { } TestFuncResult test_str8_slice(void) { - bool result; + b32 result; Str8 s = wapp_str8_lit("Different strokes for different folks"); Str8RO sub1 = wapp_str8_slice(&s, 3, 9); @@ -289,7 +288,7 @@ TestFuncResult test_str8_slice(void) { } TestFuncResult test_str8_alloc_concat(void) { - bool result; + b32 result; Allocator arena = wapp_mem_arena_allocator_init(KB(100)); Str8 str = wapp_str8_lit("Hello world"); @@ -312,7 +311,7 @@ TestFuncResult test_str8_alloc_concat(void) { } TestFuncResult test_str8_concat_capped(void) { - bool result; + b32 result; Str8 str = wapp_str8_lit("Hello world"); Str8 suffix1 = wapp_str8_lit(" from me."); @@ -330,7 +329,7 @@ TestFuncResult test_str8_concat_capped(void) { } TestFuncResult test_str8_copy_cstr_capped(void) { - bool result; + b32 result; Str8 buf = wapp_str8_buf(32); const char *src1 = "Hello world"; @@ -348,7 +347,7 @@ TestFuncResult test_str8_copy_cstr_capped(void) { } TestFuncResult test_str8_copy_str8_capped(void) { - bool result; + b32 result; Str8 buf = wapp_str8_buf(32); Str8RO src1 = wapp_str8_lit_ro("Hello world"); @@ -365,7 +364,7 @@ TestFuncResult test_str8_copy_str8_capped(void) { } TestFuncResult test_str8_format(void) { - bool result; + b32 result; Str8 buf = wapp_str8_buf(128); Str8 expected = wapp_str8_lit("My name is Abdelrahman and I am 35 years old"); @@ -378,7 +377,7 @@ TestFuncResult test_str8_format(void) { } TestFuncResult test_str8_find(void) { - bool result; + b32 result; Str8RO s = wapp_str8_lit("Do as I say, not as I do"); result = wapp_str8_find(&s, wapp_str8_lit_ro("d")) != -1; @@ -394,7 +393,7 @@ TestFuncResult test_str8_find(void) { } TestFuncResult test_str8_rfind(void) { - bool result; + b32 result; Str8RO s = wapp_str8_lit("Do as I say, not as I do"); result = wapp_str8_rfind(&s, wapp_str8_lit_ro("d")) != -1; @@ -410,7 +409,7 @@ TestFuncResult test_str8_rfind(void) { } TestFuncResult test_str8_split(void) { - bool result; + b32 result; Allocator arena = wapp_mem_arena_allocator_init(KB(100)); Str8 str = wapp_str8_lit("hello world from me"); @@ -432,11 +431,11 @@ TestFuncResult test_str8_split(void) { u64 index1 = 0; u64 count1 = ARRLEN(splits1); - bool running1 = true; + b32 running1 = true; u64 index2 = 0; u64 count2 = ARRLEN(splits2); - bool running2 = true; + b32 running2 = true; result = list1->node_count == count1 && wapp_str8_list_total_size(list1) == str.size - 3; result = result && list2->node_count == count2 && wapp_str8_list_total_size(list2) == str.size - 4; @@ -467,7 +466,7 @@ TestFuncResult test_str8_split(void) { } TestFuncResult test_str8_split_with_max(void) { - bool result; + b32 result; Allocator arena = wapp_mem_arena_allocator_init(KB(100)); Str8 str = wapp_str8_lit("hello world from me"); @@ -482,7 +481,7 @@ TestFuncResult test_str8_split_with_max(void) { u64 index = 0; u64 count = ARRLEN(splits); - bool running = true; + b32 running = true; result = list->node_count == count && wapp_str8_list_total_size(list) == str.size - 2; @@ -502,7 +501,7 @@ TestFuncResult test_str8_split_with_max(void) { } TestFuncResult test_str8_rsplit(void) { - bool result; + b32 result; Allocator arena = wapp_mem_arena_allocator_init(KB(100)); Str8 str = wapp_str8_lit("hello world from me"); @@ -524,11 +523,11 @@ TestFuncResult test_str8_rsplit(void) { u64 index1 = 0; u64 count1 = ARRLEN(splits1); - bool running1 = true; + b32 running1 = true; u64 index2 = 0; u64 count2 = ARRLEN(splits2); - bool running2 = true; + b32 running2 = true; result = list1->node_count == count1 && wapp_str8_list_total_size(list1) == str.size - 3; result = result && list2->node_count == count2 && wapp_str8_list_total_size(list2) == str.size - 4; @@ -559,7 +558,7 @@ TestFuncResult test_str8_rsplit(void) { } TestFuncResult test_str8_rsplit_with_max(void) { - bool result; + b32 result; Allocator arena = wapp_mem_arena_allocator_init(KB(100)); Str8 str = wapp_str8_lit("hello world from me"); @@ -574,7 +573,7 @@ TestFuncResult test_str8_rsplit_with_max(void) { u64 index = 0; u64 count = ARRLEN(splits); - bool running = true; + b32 running = true; result = list->node_count == count && wapp_str8_list_total_size(list) == str.size - 2; @@ -594,7 +593,7 @@ TestFuncResult test_str8_rsplit_with_max(void) { } TestFuncResult test_str8_join(void) { - bool result; + b32 result; Allocator arena = wapp_mem_arena_allocator_init(KB(100)); Str8 str = wapp_str8_lit("hello world from me"); @@ -612,3 +611,16 @@ TestFuncResult test_str8_join(void) { return wapp_tester_result(result); } + +TestFuncResult test_str8_from_bytes(void) { + b32 result; + + Str8 str = wapp_str8_buf(1024); + U8Array bytes = wapp_u8_array('W', 'A', 'P', 'P'); + wapp_str8_from_bytes(&str, &bytes); + + result = str.size == bytes.count * bytes.item_size; + result = result && wapp_str8_equal(&str, &wapp_str8_lit_ro("WAPP")); + + return wapp_tester_result(result); +} diff --git a/tests/str8/test_str8.cc b/tests/str8/test_str8.cc index fc2a42f..b46dbee 100644 --- a/tests/str8/test_str8.cc +++ b/tests/str8/test_str8.cc @@ -1,11 +1,10 @@ #include "test_str8.h" #include "wapp.h" -#include #define ARRLEN(ARR) (sizeof(ARR) / sizeof(ARR[0])) TestFuncResult test_str8_lit(void) { - bool result; + b32 result; Str8 s1 = wapp_str8_lit("Hello world"); result = s1.capacity == 22 && s1.capacity != s1.size; @@ -32,7 +31,7 @@ TestFuncResult test_str8_lit(void) { } TestFuncResult test_str8_lit_ro(void) { - bool result; + b32 result; Str8RO s1 = wapp_str8_lit_ro("Hello world"); result = s1.capacity == 11 && s1.capacity == s1.size; @@ -59,7 +58,7 @@ TestFuncResult test_str8_lit_ro(void) { } TestFuncResult test_str8_buf(void) { - bool result; + b32 result; Str8 s1 = wapp_str8_buf(1024); result = s1.capacity == 1024 && s1.size == 0; @@ -77,7 +76,7 @@ TestFuncResult test_str8_buf(void) { } TestFuncResult test_str8_alloc_buf(void) { - bool result; + b32 result; Allocator allocator = wapp_mem_arena_allocator_init(KB(100)); if (wapp_mem_allocator_invalid(&allocator)) { return wapp_tester_result(false); @@ -105,7 +104,7 @@ TestFuncResult test_str8_alloc_buf(void) { } TestFuncResult test_str8_alloc_cstr(void) { - bool result; + b32 result; Allocator allocator = wapp_mem_arena_allocator_init(KB(100)); if (wapp_mem_allocator_invalid(&allocator)) { return wapp_tester_result(false); @@ -126,7 +125,7 @@ TestFuncResult test_str8_alloc_cstr(void) { } TestFuncResult test_str8_alloc_str8(void) { - bool result; + b32 result; Allocator allocator = wapp_mem_arena_allocator_init(KB(100)); if (wapp_mem_allocator_invalid(&allocator)) { return wapp_tester_result(false); @@ -146,7 +145,7 @@ TestFuncResult test_str8_alloc_str8(void) { } TestFuncResult test_str8_alloc_substr(void) { - bool result; + b32 result; Allocator allocator = wapp_mem_arena_allocator_init(KB(100)); if (wapp_mem_allocator_invalid(&allocator)) { return wapp_tester_result(false); @@ -166,7 +165,7 @@ TestFuncResult test_str8_alloc_substr(void) { } TestFuncResult test_str8_get_index_within_bounds(void) { - bool result; + b32 result; Str8RO s1 = wapp_str8_lit_ro("Hello world"); result = wapp_str8_get(&s1, 4) == 'o'; @@ -194,12 +193,12 @@ TestFuncResult test_str8_get_index_within_bounds(void) { TestFuncResult test_str8_get_index_out_of_bounds(void) { Str8 s1 = wapp_str8_lit("Hello world"); - bool result = wapp_str8_get(&s1, 20) == '\0'; + b32 result = wapp_str8_get(&s1, 20) == '\0'; return wapp_tester_result(result); } TestFuncResult test_str8_set(void) { - bool result; + b32 result; Str8 s1 = wapp_str8_lit("Hello world"); wapp_str8_set(&s1, 4, 'f'); @@ -233,7 +232,7 @@ TestFuncResult test_str8_set(void) { } TestFuncResult test_str8_push_back(void) { - bool result; + b32 result; Str8 expected = wapp_str8_lit("Abdelrahman"); Str8 buf = wapp_str8_buf(64); @@ -255,7 +254,7 @@ TestFuncResult test_str8_push_back(void) { } TestFuncResult test_str8_equal(void) { - bool result; + b32 result; Str8RO s1 = wapp_str8_lit_ro("hello"); Str8RO s2 = wapp_str8_lit_ro("hell"); @@ -270,7 +269,7 @@ TestFuncResult test_str8_equal(void) { } TestFuncResult test_str8_slice(void) { - bool result; + b32 result; Str8 s = wapp_str8_lit("Different strokes for different folks"); Str8RO sub1 = wapp_str8_slice(&s, 3, 9); @@ -289,7 +288,7 @@ TestFuncResult test_str8_slice(void) { } TestFuncResult test_str8_alloc_concat(void) { - bool result; + b32 result; Allocator arena = wapp_mem_arena_allocator_init(KB(100)); Str8 str = wapp_str8_lit("Hello world"); @@ -312,7 +311,7 @@ TestFuncResult test_str8_alloc_concat(void) { } TestFuncResult test_str8_concat_capped(void) { - bool result; + b32 result; Str8 str = wapp_str8_lit("Hello world"); Str8 suffix1 = wapp_str8_lit(" from me."); @@ -330,7 +329,7 @@ TestFuncResult test_str8_concat_capped(void) { } TestFuncResult test_str8_copy_cstr_capped(void) { - bool result; + b32 result; Str8 buf = wapp_str8_buf(32); const char *src1 = "Hello world"; @@ -348,7 +347,7 @@ TestFuncResult test_str8_copy_cstr_capped(void) { } TestFuncResult test_str8_copy_str8_capped(void) { - bool result; + b32 result; Str8 buf = wapp_str8_buf(32); Str8RO src1 = wapp_str8_lit_ro("Hello world"); @@ -365,7 +364,7 @@ TestFuncResult test_str8_copy_str8_capped(void) { } TestFuncResult test_str8_format(void) { - bool result; + b32 result; Str8 buf = wapp_str8_buf(128); Str8 expected = wapp_str8_lit("My name is Abdelrahman and I am 35 years old"); @@ -378,7 +377,7 @@ TestFuncResult test_str8_format(void) { } TestFuncResult test_str8_find(void) { - bool result; + b32 result; Str8RO s = wapp_str8_lit("Do as I say, not as I do"); result = wapp_str8_find(&s, wapp_str8_lit_ro("d")) != -1; @@ -394,7 +393,7 @@ TestFuncResult test_str8_find(void) { } TestFuncResult test_str8_rfind(void) { - bool result; + b32 result; Str8RO s = wapp_str8_lit("Do as I say, not as I do"); result = wapp_str8_rfind(&s, wapp_str8_lit_ro("d")) != -1; @@ -410,7 +409,7 @@ TestFuncResult test_str8_rfind(void) { } TestFuncResult test_str8_split(void) { - bool result; + b32 result; Allocator arena = wapp_mem_arena_allocator_init(KB(100)); Str8 str = wapp_str8_lit("hello world from me"); @@ -432,11 +431,11 @@ TestFuncResult test_str8_split(void) { u64 index1 = 0; u64 count1 = ARRLEN(splits1); - bool running1 = true; + b32 running1 = true; u64 index2 = 0; u64 count2 = ARRLEN(splits2); - bool running2 = true; + b32 running2 = true; result = list1->node_count == count1 && wapp_str8_list_total_size(list1) == str.size - 3; result = result && list2->node_count == count2 && wapp_str8_list_total_size(list2) == str.size - 4; @@ -467,7 +466,7 @@ TestFuncResult test_str8_split(void) { } TestFuncResult test_str8_split_with_max(void) { - bool result; + b32 result; Allocator arena = wapp_mem_arena_allocator_init(KB(100)); Str8 str = wapp_str8_lit("hello world from me"); @@ -482,7 +481,7 @@ TestFuncResult test_str8_split_with_max(void) { u64 index = 0; u64 count = ARRLEN(splits); - bool running = true; + b32 running = true; result = list->node_count == count && wapp_str8_list_total_size(list) == str.size - 2; @@ -502,7 +501,7 @@ TestFuncResult test_str8_split_with_max(void) { } TestFuncResult test_str8_rsplit(void) { - bool result; + b32 result; Allocator arena = wapp_mem_arena_allocator_init(KB(100)); Str8 str = wapp_str8_lit("hello world from me"); @@ -524,11 +523,11 @@ TestFuncResult test_str8_rsplit(void) { u64 index1 = 0; u64 count1 = ARRLEN(splits1); - bool running1 = true; + b32 running1 = true; u64 index2 = 0; u64 count2 = ARRLEN(splits2); - bool running2 = true; + b32 running2 = true; result = list1->node_count == count1 && wapp_str8_list_total_size(list1) == str.size - 3; result = result && list2->node_count == count2 && wapp_str8_list_total_size(list2) == str.size - 4; @@ -559,7 +558,7 @@ TestFuncResult test_str8_rsplit(void) { } TestFuncResult test_str8_rsplit_with_max(void) { - bool result; + b32 result; Allocator arena = wapp_mem_arena_allocator_init(KB(100)); Str8 str = wapp_str8_lit("hello world from me"); @@ -574,7 +573,7 @@ TestFuncResult test_str8_rsplit_with_max(void) { u64 index = 0; u64 count = ARRLEN(splits); - bool running = true; + b32 running = true; result = list->node_count == count && wapp_str8_list_total_size(list) == str.size - 2; @@ -594,7 +593,7 @@ TestFuncResult test_str8_rsplit_with_max(void) { } TestFuncResult test_str8_join(void) { - bool result; + b32 result; Allocator arena = wapp_mem_arena_allocator_init(KB(100)); Str8 str = wapp_str8_lit("hello world from me"); @@ -612,3 +611,17 @@ TestFuncResult test_str8_join(void) { return wapp_tester_result(result); } + +TestFuncResult test_str8_from_bytes(void) { + b32 result; + + Str8 str = wapp_str8_buf(1024); + Str8 expected = wapp_str8_lit_ro("WAPP"); + U8Array bytes = wapp_u8_array('W', 'A', 'P', 'P'); + wapp_str8_from_bytes(&str, &bytes); + + result = str.size == bytes.count * bytes.item_size; + result = result && wapp_str8_equal(&str, &expected); + + return wapp_tester_result(result); +} diff --git a/tests/str8/test_str8.h b/tests/str8/test_str8.h index 5ed90c0..f3a2221 100644 --- a/tests/str8/test_str8.h +++ b/tests/str8/test_str8.h @@ -28,5 +28,6 @@ TestFuncResult test_str8_split_with_max(void); TestFuncResult test_str8_rsplit(void); TestFuncResult test_str8_rsplit_with_max(void); TestFuncResult test_str8_join(void); +TestFuncResult test_str8_from_bytes(void); #endif // !TEST_STR8_H diff --git a/tests/str8/test_str8_list.c b/tests/str8/test_str8_list.c index d47e55c..044f31a 100644 --- a/tests/str8/test_str8_list.c +++ b/tests/str8/test_str8_list.c @@ -2,7 +2,7 @@ #include "wapp.h" TestFuncResult test_str8_list_get(void) { - bool result; + b32 result; Str8 s1 = wapp_str8_lit("1"); Str8 s2 = wapp_str8_lit("2"); @@ -42,7 +42,7 @@ TestFuncResult test_str8_list_get(void) { } TestFuncResult test_str8_list_push_front(void) { - bool result; + b32 result; Str8 s1 = wapp_str8_lit("1"); Str8 s2 = wapp_str8_lit("2"); @@ -66,7 +66,7 @@ TestFuncResult test_str8_list_push_front(void) { } TestFuncResult test_str8_list_push_back(void) { - bool result; + b32 result; Str8 s1 = wapp_str8_lit("1"); Str8 s2 = wapp_str8_lit("2"); @@ -90,7 +90,7 @@ TestFuncResult test_str8_list_push_back(void) { } TestFuncResult test_str8_list_insert(void) { - bool result; + b32 result; Str8 s1 = wapp_str8_lit("1"); Str8 s2 = wapp_str8_lit("2"); @@ -127,7 +127,7 @@ TestFuncResult test_str8_list_insert(void) { } TestFuncResult test_str8_list_pop_front(void) { - bool result; + b32 result; Str8 s1 = wapp_str8_lit("1"); Str8 s2 = wapp_str8_lit("2"); @@ -167,7 +167,7 @@ TestFuncResult test_str8_list_pop_front(void) { } TestFuncResult test_str8_list_pop_back(void) { - bool result; + b32 result; Str8 s1 = wapp_str8_lit("1"); Str8 s2 = wapp_str8_lit("2"); @@ -207,7 +207,7 @@ TestFuncResult test_str8_list_pop_back(void) { } TestFuncResult test_str8_list_remove(void) { - bool result; + b32 result; Str8 s1 = wapp_str8_lit("1"); Str8 s2 = wapp_str8_lit("2"); @@ -247,7 +247,7 @@ TestFuncResult test_str8_list_remove(void) { } TestFuncResult test_str8_list_empty(void) { - bool result; + b32 result; Str8List list = {0}; wapp_str8_list_push_back(&list, &wapp_str8_node_from_cstr("Hello")); diff --git a/tests/str8/test_str8_list.cc b/tests/str8/test_str8_list.cc index 4359445..52e72de 100644 --- a/tests/str8/test_str8_list.cc +++ b/tests/str8/test_str8_list.cc @@ -2,7 +2,7 @@ #include "wapp.h" TestFuncResult test_str8_list_get(void) { - bool result; + b32 result; Str8 s1 = wapp_str8_lit("1"); Str8 s2 = wapp_str8_lit("2"); @@ -42,7 +42,7 @@ TestFuncResult test_str8_list_get(void) { } TestFuncResult test_str8_list_push_front(void) { - bool result; + b32 result; Str8 s1 = wapp_str8_lit("1"); Str8 s2 = wapp_str8_lit("2"); @@ -66,7 +66,7 @@ TestFuncResult test_str8_list_push_front(void) { } TestFuncResult test_str8_list_push_back(void) { - bool result; + b32 result; Str8 s1 = wapp_str8_lit("1"); Str8 s2 = wapp_str8_lit("2"); @@ -90,7 +90,7 @@ TestFuncResult test_str8_list_push_back(void) { } TestFuncResult test_str8_list_insert(void) { - bool result; + b32 result; Str8 s1 = wapp_str8_lit("1"); Str8 s2 = wapp_str8_lit("2"); @@ -127,7 +127,7 @@ TestFuncResult test_str8_list_insert(void) { } TestFuncResult test_str8_list_pop_front(void) { - bool result; + b32 result; Str8 s1 = wapp_str8_lit("1"); Str8 s2 = wapp_str8_lit("2"); @@ -167,7 +167,7 @@ TestFuncResult test_str8_list_pop_front(void) { } TestFuncResult test_str8_list_pop_back(void) { - bool result; + b32 result; Str8 s1 = wapp_str8_lit("1"); Str8 s2 = wapp_str8_lit("2"); @@ -207,7 +207,7 @@ TestFuncResult test_str8_list_pop_back(void) { } TestFuncResult test_str8_list_remove(void) { - bool result; + b32 result; Str8 s1 = wapp_str8_lit("1"); Str8 s2 = wapp_str8_lit("2"); @@ -247,7 +247,7 @@ TestFuncResult test_str8_list_remove(void) { } TestFuncResult test_str8_list_empty(void) { - bool result; + b32 result; Str8List list = {}; diff --git a/tests/wapptest.c b/tests/wapptest.c index d75dc79..a134adf 100644 --- a/tests/wapptest.c +++ b/tests/wapptest.c @@ -56,6 +56,7 @@ int main(void) { test_str8_rsplit, test_str8_rsplit_with_max, test_str8_join, + test_str8_from_bytes, test_str8_list_get, test_str8_list_push_front, test_str8_list_push_back, diff --git a/tests/wapptest.cc b/tests/wapptest.cc index d75dc79..a134adf 100644 --- a/tests/wapptest.cc +++ b/tests/wapptest.cc @@ -56,6 +56,7 @@ int main(void) { test_str8_rsplit, test_str8_rsplit_with_max, test_str8_join, + test_str8_from_bytes, test_str8_list_get, test_str8_list_push_front, test_str8_list_push_back,