abdelrahman/wizapp-stdlib
0
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

File utilities and datatype implementation for a C-based code generator (#5)

Browse Source 
Co-authored-by: Abdelrahman Said <said.abdelrahman@flawlessai.com>
Reviewed-on: #5
Co-authored-by: Abdelrahman <said.abdelrahman89@gmail.com>
Co-committed-by: Abdelrahman <said.abdelrahman89@gmail.com>
This commit is contained in:
Abdelrahman Said
2025-09-20 13:48:08 +00:00
committed by Abdelrahman Said
parent 09e96f8112
commit 14bd6ce5fd
52 changed files with 3814 additions and 944 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
Makefile
View File

@@ -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

522
ccodegen/datatypes.c Normal file
View File

@@ -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;
}

280
ccodegen/datatypes.h Normal file
View File

@@ -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

1526
ccodegen/dbl_list.c Normal file
View File

File diff suppressed because it is too large Load Diff

222
ccodegen/dbl_list.h Normal file
View File

@@ -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

10
ccodegen/main.c Normal file
View File

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

84
ccodegen/type_enums.h Normal file
View File

@@ -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

522
codegen/array/make_array.py
View File

@@ -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

2
codegen/array/snippets/alloc_capacity
View File

@@ -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);

2
codegen/datatypes.py
View File

@@ -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.
*/
"""

30
codegen/dbl_list/make_dbl_list.py
View File

@@ -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

103
src/core/file/file.c Normal file
View File

@@ -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 <stdio.h>
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);
}

72
src/core/file/file.h Normal file
View File

@@ -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 <stdio.h>
#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

7
src/core/mem/arena/mem_arena.c
View File

@@ -6,7 +6,6 @@
#include "../../../common/assert/assert.h"
#include "../../../common/misc/misc_utils.h"
#include "../../os/mem/mem_os.h"
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
@@ -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;
}

3
src/core/mem/arena/mem_arena.h
View File

@@ -6,7 +6,6 @@
#include "../../../common/aliases/aliases.h"
#include "../../../common/platform/platform.h"
#include "../../os/mem/mem_os.h"
#include <stdbool.h>
#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);

4
src/core/mem/arena/mem_arena_allocator.c
View File

@@ -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;
}

3
src/core/mem/arena/mem_arena_allocator.h
View File

@@ -7,7 +7,6 @@
#include "../../../common/platform/platform.h"
#include "../../../primitives/mem_allocator/mem_allocator.h"
#include "../../os/mem/mem_os.h"
#include <stdbool.h>
#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);

3
src/core/mem/utils/mem_utils.c
View File

@@ -3,10 +3,9 @@
#include "mem_utils.h"
#include "../../../common/aliases/aliases.h"
#include "../../../common/assert/assert.h"
#include <stdbool.h>
#include <stddef.h>
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");

21
src/core/os/cpath/cpath.c
View File

@@ -8,7 +8,6 @@
#include "../../../primitives/mem_allocator/mem_allocator.h"
#include "../../../primitives/strings/str8/str8.h"
#include <stdarg.h>
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
@@ -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);

8
src/core/os/cpath/cpath.h
View File

@@ -13,9 +13,13 @@ BEGIN_C_LINKAGE
#endif // !WAPP_PLATFORM_CPP
#ifdef WAPP_PLATFORM_POSIX
#define PATH_SEP '/'
#include <limits.h>
#define WAPP_PATH_SEP '/'
#define WAPP_PATH_MAX PATH_MAX
#elif defined(WAPP_PLATFORM_WINDOWS)
#define PATH_SEP '\\'
#include <windows.h>
#define WAPP_PATH_SEP '\\'
#define WAPP_PATH_MAX MAX_PATH
#else
#error "Unrecognised platform"
#endif

1
src/core/os/mem/mem_os.c
View File

@@ -5,7 +5,6 @@
#include "../../../common/aliases/aliases.h"
#include "../../../common/platform/platform.h"
#include <assert.h>
#include <stdbool.h>
#include <string.h>
#if defined(WAPP_PLATFORM_WINDOWS)

1
src/core/os/shell/commander/commander.c
View File

@@ -10,7 +10,6 @@
#include "../../../../primitives/mem_allocator/mem_allocator.h"
#include "../../../../primitives/strings/str8/str8.h"
#include <stdarg.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

1
src/core/os/shell/commander/commander.h
View File

@@ -7,7 +7,6 @@
#include "../../../../common/aliases/aliases.h"
#include "../../../../common/platform/platform.h"
#include "../../../../primitives/strings/str8/str8.h"
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>

5
src/core/os/shell/commander/commander_output.h
View File

@@ -5,7 +5,6 @@
#include "../../../../common/aliases/aliases.h"
#include "../../../../common/platform/platform.h"
#include <stdbool.h>
#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
};

1
src/core/wapp_core.c
View File

@@ -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"

1
src/core/wapp_core.h
View File

@@ -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"

311
src/primitives/array/array.c
View File

@@ -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 <stddef.h>
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;

97
src/primitives/array/array.h
View File

@@ -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

360
src/primitives/dbl_list/dbl_list.c
View File

@@ -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 <stddef.h>
#include <assert.h>
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;

55
src/primitives/dbl_list/dbl_list.h
View File

@@ -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);

50
src/primitives/strings/str8/str8.c
View File

@@ -4,11 +4,11 @@
#include "../../../common/aliases/aliases.h"
#include "../../../common/assert/assert.h"
#include "../../mem_allocator/mem_allocator.h"
#include <ctype.h>
#include <stdarg.h>
#include <stddef.h>
#include <stdio.h>
#include <string.h>
#include <stdbool.h>
#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) {

9
src/primitives/strings/str8/str8.h
View File

@@ -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 <string.h>
#include <stdbool.h>
#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

3
src/prng/xorshift/xorshift.c
View File

@@ -4,7 +4,6 @@
#include "../../common/aliases/aliases.h"
#include "../../common/assert/assert.h"
#include "../../common/platform/platform.h"
#include <stdbool.h>
#include <stdlib.h>
#include <time.h>
@@ -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();

5
src/testing/tester/tester.h
View File

@@ -6,7 +6,6 @@
#include "../../common/misc/misc_utils.h"
#include "../../common/platform/platform.h"
#include "../../primitives/strings/str8/str8.h"
#include <stdbool.h>
#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
};

3
src/uuid/uuid.c
View File

@@ -5,7 +5,6 @@
#include "../common/assert/assert.h"
#include "../primitives/strings/str8/str8.h"
#include "../prng/xorshift/xorshift.h"
#include <stdbool.h>
#include <inttypes.h>
#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;

3
tests/allocator/test_allocator.c
View File

@@ -1,11 +1,10 @@
#include "test_allocator.h"
#include "wapp.h"
#include <stdbool.h>
#include <stdlib.h>
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;

3
tests/allocator/test_allocator.cc
View File

@@ -1,11 +1,10 @@
#include "test_allocator.h"
#include "wapp.h"
#include <stdbool.h>
#include <stdlib.h>
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;

13
tests/arena/test_arena.c
View File

@@ -1,6 +1,5 @@
#include "test_arena.h"
#include "wapp.h"
#include <stdbool.h>
#include <stdlib.h>
#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);
}

13
tests/arena/test_arena.cc
View File

@@ -1,6 +1,5 @@
#include "test_arena.h"
#include "wapp.h"
#include <stdbool.h>
#include <stdlib.h>
#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);
}

39
tests/array/test_i32_array.c
View File

@@ -1,9 +1,8 @@
#include "test_i32_array.h"
#include "wapp.h"
#include <stdbool.h>
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));

39
tests/array/test_i32_array.cc
View File

@@ -1,9 +1,8 @@
#include "test_i32_array.h"
#include "wapp.h"
#include <stdbool.h>
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));

51
tests/cpath/test_cpath.c
View File

@@ -2,20 +2,19 @@
#include "wapp.h"
#include <string.h>
#include <stdio.h>
#include <stdbool.h>
#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);

51
tests/cpath/test_cpath.cc
View File

@@ -2,20 +2,19 @@
#include "wapp.h"
#include <string.h>
#include <stdio.h>
#include <stdbool.h>
#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);

9
tests/shell_commander/test_shell_commander.c
View File

@@ -1,6 +1,5 @@
#include "test_shell_commander.h"
#include "wapp.h"
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
@@ -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);

9
tests/shell_commander/test_shell_commander.cc
View File

@@ -1,6 +1,5 @@
#include "test_shell_commander.h"
#include "wapp.h"
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
@@ -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);

76
tests/str8/test_str8.c
View File

@@ -1,11 +1,10 @@
#include "test_str8.h"
#include "wapp.h"
#include <stdbool.h>
#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);
}

77
tests/str8/test_str8.cc
View File

@@ -1,11 +1,10 @@
#include "test_str8.h"
#include "wapp.h"
#include <stdbool.h>
#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);
}

1
tests/str8/test_str8.h
View File

@@ -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

16
tests/str8/test_str8_list.c
View File

@@ -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"));

16
tests/str8/test_str8_list.cc
View File

@@ -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 = {};

1
tests/wapptest.c
View File

@@ -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,

1
tests/wapptest.cc
View File

@@ -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,