From a32ef945228d3903db3a5dbe9d25a45ca1092ac7 Mon Sep 17 00:00:00 2001 From: Abdelrahman Said Date: Mon, 29 Dec 2025 15:59:50 +0000 Subject: [PATCH 1/9] Test replacing spaces with tabs --- src/base/array/array.h | 242 ++++++++++++++++++++--------------------- 1 file changed, 121 insertions(+), 121 deletions(-) diff --git a/src/base/array/array.h b/src/base/array/array.h index d1412c2..f30be6f 100644 --- a/src/base/array/array.h +++ b/src/base/array/array.h @@ -17,144 +17,144 @@ BEGIN_C_LINKAGE #define _calc_array_count(TYPE, ...) wapp_misc_utils_va_args_count(TYPE, __VA_ARGS__) #define _calc_array_capacity(TYPE, ...) wapp_misc_utils_u64_round_up_pow2(_calc_array_count(TYPE, __VA_ARGS__) * 2) -#define wapp_array_alloc_capacity(ELEM_TYPE, ARRAY_TYPE, ALLOCATOR_PTR, CAPACITY, FILL) \ - ((ARRAY_TYPE *)_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY, sizeof(ELEM_TYPE), FILL)) +#define wapp_array_alloc_capacity(ELEM_TYPE, ARRAY_TYPE, ALLOCATOR_PTR, CAPACITY, FILL) \ + ((ARRAY_TYPE *)_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY, sizeof(ELEM_TYPE), FILL)) -#define WAPP_DEF_ARRAY_TYPE(T, NAME) \ - typedef struct { \ - u64 magic; \ - u64 count; \ - u64 capacity; \ - u64 item_size; \ - T *items; \ - } NAME +#define WAPP_DEF_ARRAY_TYPE(T, NAME) \ + typedef struct { \ + u64 magic; \ + u64 count; \ + u64 capacity; \ + u64 item_size; \ + T *items; \ + } NAME #ifdef WAPP_PLATFORM_CPP -#define wapp_array(ELEM_TYPE, ARRAY_TYPE, ...) ([&]() { \ - wapp_persist ELEM_TYPE items[sizeof(ELEM_TYPE) == sizeof(*((ARRAY_TYPE{}).items)) ? \ - _calc_array_capacity(ELEM_TYPE, __VA_ARGS__) : -1 \ - ] = {__VA_ARGS__}; \ - \ - return ARRAY_TYPE{ \ - WAPP_ARRAY_MAGIC, \ - _calc_array_count(ELEM_TYPE, __VA_ARGS__), \ - _calc_array_capacity(ELEM_TYPE, __VA_ARGS__), \ - sizeof(ELEM_TYPE), \ - items, \ - }; \ +#define wapp_array(ELEM_TYPE, ARRAY_TYPE, ...) ([&]() { \ + wapp_persist ELEM_TYPE items[sizeof(ELEM_TYPE) == sizeof(*((ARRAY_TYPE{}).items)) ? \ + _calc_array_capacity(ELEM_TYPE, __VA_ARGS__) : -1 \ + ] = {__VA_ARGS__}; \ + \ + return ARRAY_TYPE{ \ + WAPP_ARRAY_MAGIC, \ + _calc_array_count(ELEM_TYPE, __VA_ARGS__), \ + _calc_array_capacity(ELEM_TYPE, __VA_ARGS__), \ + sizeof(ELEM_TYPE), \ + items, \ + }; \ }()) -#define wapp_array_with_capacity(ELEM_TYPE, ARRAY_TYPE, CAPACITY, FILL) ([&]() { \ - wapp_persist ELEM_TYPE items[sizeof(ELEM_TYPE) == sizeof(*((ARRAY_TYPE{}).items)) ? \ - CAPACITY : -1] = {}; \ - \ - return ARRAY_TYPE{ \ - WAPP_ARRAY_MAGIC, \ - FILL ? CAPACITY : 0, \ - CAPACITY, \ - sizeof(ELEM_TYPE), \ - items, \ - }; \ +#define wapp_array_with_capacity(ELEM_TYPE, ARRAY_TYPE, CAPACITY, FILL) ([&]() { \ + wapp_persist ELEM_TYPE items[sizeof(ELEM_TYPE) == sizeof(*((ARRAY_TYPE{}).items)) ? \ + CAPACITY : -1] = {}; \ + \ + return ARRAY_TYPE{ \ + WAPP_ARRAY_MAGIC, \ + FILL ? CAPACITY : 0, \ + CAPACITY, \ + sizeof(ELEM_TYPE), \ + items, \ + }; \ }()) -#define wapp_array_pop(ELEM_TYPE, ARRAY_PTR) ([&]() { \ - if (ARRAY_PTR == NULL || (ARRAY_PTR)->count == 0) { \ - ELEM_TYPE result{}; \ - return result; \ - } \ - \ - return *((ELEM_TYPE *)_array_pop((GenericArray *)ARRAY_PTR, sizeof(ELEM_TYPE))); \ +#define wapp_array_pop(ELEM_TYPE, ARRAY_PTR) ([&]() { \ + if (ARRAY_PTR == NULL || (ARRAY_PTR)->count == 0) { \ + ELEM_TYPE result{}; \ + return result; \ + } \ + \ + return *((ELEM_TYPE *)_array_pop((GenericArray *)ARRAY_PTR, sizeof(ELEM_TYPE))); \ }()) #else -#define wapp_array(ELEM_TYPE, ARRAY_TYPE, ...) \ - ((ARRAY_TYPE){ \ - .magic = WAPP_ARRAY_MAGIC, \ - .count = _calc_array_count(ELEM_TYPE, __VA_ARGS__), \ - .capacity = _calc_array_capacity(ELEM_TYPE, __VA_ARGS__), \ - .item_size = sizeof(ELEM_TYPE), \ - .items = (ELEM_TYPE[sizeof(ELEM_TYPE) == sizeof(*((ARRAY_TYPE){0}.items)) ? \ - _calc_array_capacity(ELEM_TYPE, __VA_ARGS__) : \ - -1]){__VA_ARGS__} \ - }) -#define wapp_array_with_capacity(ELEM_TYPE, ARRAY_TYPE, CAPACITY, FILL) \ - ((ARRAY_TYPE){ \ - .magic = WAPP_ARRAY_MAGIC, \ - .count = FILL ? CAPACITY : 0, \ - .capacity = CAPACITY, \ - .item_size = sizeof(ELEM_TYPE), \ - .items = (ELEM_TYPE[sizeof(ELEM_TYPE) == sizeof(*((ARRAY_TYPE){0}.items)) ? \ - CAPACITY : -1]){0} \ - }) -#define wapp_array_pop(ELEM_TYPE, ARRAY_PTR) \ - (ARRAY_PTR != NULL && (ARRAY_PTR)->count > 0 ? \ - *((ELEM_TYPE *)_array_pop((GenericArray *)ARRAY_PTR, sizeof(ELEM_TYPE))) : \ - (ELEM_TYPE){0} \ - ) +#define wapp_array(ELEM_TYPE, ARRAY_TYPE, ...) \ + ((ARRAY_TYPE){ \ + .magic = WAPP_ARRAY_MAGIC, \ + .count = _calc_array_count(ELEM_TYPE, __VA_ARGS__), \ + .capacity = _calc_array_capacity(ELEM_TYPE, __VA_ARGS__), \ + .item_size = sizeof(ELEM_TYPE), \ + .items = (ELEM_TYPE[sizeof(ELEM_TYPE) == sizeof(*((ARRAY_TYPE){0}.items)) ? \ + _calc_array_capacity(ELEM_TYPE, __VA_ARGS__) : \ + -1]){__VA_ARGS__} \ + }) +#define wapp_array_with_capacity(ELEM_TYPE, ARRAY_TYPE, CAPACITY, FILL) \ + ((ARRAY_TYPE){ \ + .magic = WAPP_ARRAY_MAGIC, \ + .count = FILL ? CAPACITY : 0, \ + .capacity = CAPACITY, \ + .item_size = sizeof(ELEM_TYPE), \ + .items = (ELEM_TYPE[sizeof(ELEM_TYPE) == sizeof(*((ARRAY_TYPE){0}.items)) ? \ + CAPACITY : -1]){0} \ + }) +#define wapp_array_pop(ELEM_TYPE, ARRAY_PTR) \ + (ARRAY_PTR != NULL && (ARRAY_PTR)->count > 0 ? \ + *((ELEM_TYPE *)_array_pop((GenericArray *)ARRAY_PTR, sizeof(ELEM_TYPE))) : \ + (ELEM_TYPE){0} \ + ) #endif // !WAPP_PLATFORM_CPP -#define wapp_array_get(ELEM_TYPE, ARRAY_PTR, INDEX) \ - ((ELEM_TYPE *)_array_get((GenericArray *)ARRAY_PTR, INDEX, sizeof(ELEM_TYPE))) -#define wapp_array_set(ELEM_TYPE, ARRAY_PTR, INDEX, VALUE_PTR) \ - _array_set((GenericArray *)ARRAY_PTR, INDEX, (void *)VALUE_PTR, sizeof(ELEM_TYPE)) -#define wapp_array_append_capped(ELEM_TYPE, ARRAY_PTR, VALUE_PTR) \ - _array_append_capped((GenericArray *)ARRAY_PTR, (void *)VALUE_PTR, sizeof(ELEM_TYPE)) -#define wapp_array_extend_capped(ELEM_TYPE, DST_ARRAY_PTR, SRC_ARRAY_PTR) \ - _array_extend_capped( \ - (GenericArray *)DST_ARRAY_PTR, (GenericArray *)SRC_ARRAY_PTR, sizeof(ELEM_TYPE) \ - ) -#define wapp_array_copy_capped(ELEM_TYPE, DST_ARRAY_PTR, SRC_ARRAY_PTR) \ - _array_copy_capped( \ - (GenericArray *)DST_ARRAY_PTR, (GenericArray *)SRC_ARRAY_PTR, sizeof(ELEM_TYPE) \ - ) -#define wapp_array_append_alloc(ELEM_TYPE, ARRAY_TYPE, ALLOCATOR_PTR, ARRAY_PTR, VALUE_PTR) \ - (ARRAY_TYPE *)_array_append_alloc( \ - ALLOCATOR_PTR, (GenericArray *)ARRAY_PTR, (void *)VALUE_PTR, sizeof(ELEM_TYPE) \ - ) -#define wapp_array_extend_alloc(ELEM_TYPE, ARRAY_TYPE, ALLOCATOR_PTR, DST_ARRAY_PTR, SRC_ARRAY_PTR) \ - (ARRAY_TYPE *)_array_extend_alloc( \ - ALLOCATOR_PTR, (GenericArray *)DST_ARRAY_PTR, (GenericArray *)SRC_ARRAY_PTR, sizeof(ELEM_TYPE) \ - ) -#define wapp_array_copy_alloc(ELEM_TYPE, ARRAY_TYPE, ALLOCATOR_PTR, DST_ARRAY_PTR, SRC_ARRAY_PTR) \ - (ARRAY_TYPE *)_array_copy_alloc( \ - ALLOCATOR_PTR, (GenericArray *)DST_ARRAY_PTR, (GenericArray *)SRC_ARRAY_PTR, sizeof(ELEM_TYPE) \ - ) -#define wapp_array_clear(ELEM_TYPE, ARRAY_PTR) \ - _array_clear((GenericArray *)ARRAY_PTR, sizeof(ELEM_TYPE)) +#define wapp_array_get(ELEM_TYPE, ARRAY_PTR, INDEX) \ + ((ELEM_TYPE *)_array_get((GenericArray *)ARRAY_PTR, INDEX, sizeof(ELEM_TYPE))) +#define wapp_array_set(ELEM_TYPE, ARRAY_PTR, INDEX, VALUE_PTR) \ + _array_set((GenericArray *)ARRAY_PTR, INDEX, (void *)VALUE_PTR, sizeof(ELEM_TYPE)) +#define wapp_array_append_capped(ELEM_TYPE, ARRAY_PTR, VALUE_PTR) \ + _array_append_capped((GenericArray *)ARRAY_PTR, (void *)VALUE_PTR, sizeof(ELEM_TYPE)) +#define wapp_array_extend_capped(ELEM_TYPE, DST_ARRAY_PTR, SRC_ARRAY_PTR) \ + _array_extend_capped( \ + (GenericArray *)DST_ARRAY_PTR, (GenericArray *)SRC_ARRAY_PTR, sizeof(ELEM_TYPE) \ + ) +#define wapp_array_copy_capped(ELEM_TYPE, DST_ARRAY_PTR, SRC_ARRAY_PTR) \ + _array_copy_capped( \ + (GenericArray *)DST_ARRAY_PTR, (GenericArray *)SRC_ARRAY_PTR, sizeof(ELEM_TYPE) \ + ) +#define wapp_array_append_alloc(ELEM_TYPE, ARRAY_TYPE, ALLOCATOR_PTR, ARRAY_PTR, VALUE_PTR) \ + (ARRAY_TYPE *)_array_append_alloc( \ + ALLOCATOR_PTR, (GenericArray *)ARRAY_PTR, (void *)VALUE_PTR, sizeof(ELEM_TYPE) \ + ) +#define wapp_array_extend_alloc(ELEM_TYPE, ARRAY_TYPE, ALLOCATOR_PTR, DST_ARRAY_PTR, SRC_ARRAY_PTR) \ + (ARRAY_TYPE *)_array_extend_alloc( \ + ALLOCATOR_PTR, (GenericArray *)DST_ARRAY_PTR, (GenericArray *)SRC_ARRAY_PTR, sizeof(ELEM_TYPE) \ + ) +#define wapp_array_copy_alloc(ELEM_TYPE, ARRAY_TYPE, ALLOCATOR_PTR, DST_ARRAY_PTR, SRC_ARRAY_PTR) \ + (ARRAY_TYPE *)_array_copy_alloc( \ + ALLOCATOR_PTR, (GenericArray *)DST_ARRAY_PTR, (GenericArray *)SRC_ARRAY_PTR, sizeof(ELEM_TYPE) \ + ) +#define wapp_array_clear(ELEM_TYPE, ARRAY_PTR) \ + _array_clear((GenericArray *)ARRAY_PTR, sizeof(ELEM_TYPE)) WAPP_DEF_ARRAY_TYPE(void, GenericArray); -void *_array_get(GenericArray *array, u64 index, u64 item_size); -void _array_set(GenericArray *array, u64 index, void *value, u64 item_size); -void _array_append_capped(GenericArray *array, void *value, u64 item_size); -void _array_extend_capped(GenericArray *dst, const GenericArray *src, u64 item_size); -void _array_copy_capped(GenericArray *dst, const GenericArray *src, u64 item_size); -GenericArray *_array_append_alloc(const Allocator *allocator, GenericArray *array, void *value, u64 item_size); -GenericArray *_array_extend_alloc(const Allocator *allocator, GenericArray *dst, const GenericArray *src, u64 item_size); -GenericArray *_array_copy_alloc(const Allocator *allocator, GenericArray *dst, const GenericArray *src, u64 item_size); -void *_array_pop(GenericArray *array, u64 item_size); -void _array_clear(GenericArray *array, u64 item_size); -GenericArray *_array_alloc_capacity(const Allocator *allocator, u64 capacity, u64 item_size, b8 fill); +void *_array_get(GenericArray *array, u64 index, u64 item_size); +void _array_set(GenericArray *array, u64 index, void *value, u64 item_size); +void _array_append_capped(GenericArray *array, void *value, u64 item_size); +void _array_extend_capped(GenericArray *dst, const GenericArray *src, u64 item_size); +void _array_copy_capped(GenericArray *dst, const GenericArray *src, u64 item_size); +GenericArray *_array_append_alloc(const Allocator *allocator, GenericArray *array, void *value, u64 item_size); +GenericArray *_array_extend_alloc(const Allocator *allocator, GenericArray *dst, const GenericArray *src, u64 item_size); +GenericArray *_array_copy_alloc(const Allocator *allocator, GenericArray *dst, const GenericArray *src, u64 item_size); +void *_array_pop(GenericArray *array, u64 item_size); +void _array_clear(GenericArray *array, u64 item_size); +GenericArray *_array_alloc_capacity(const Allocator *allocator, u64 capacity, u64 item_size, b8 fill); // Base array types typedef struct str8 Str8; WAPP_DEF_ARRAY_TYPE(void *, VoidPtrArray); -WAPP_DEF_ARRAY_TYPE(c8 , C8Array); -WAPP_DEF_ARRAY_TYPE(c16 , C16Array); -WAPP_DEF_ARRAY_TYPE(c32 , C32Array); -WAPP_DEF_ARRAY_TYPE(u8 , U8Array); -WAPP_DEF_ARRAY_TYPE(u16 , U16Array); -WAPP_DEF_ARRAY_TYPE(u32 , U32Array); -WAPP_DEF_ARRAY_TYPE(u64 , U64Array); -WAPP_DEF_ARRAY_TYPE(b8 , B8Array); -WAPP_DEF_ARRAY_TYPE(i8 , I8Array); -WAPP_DEF_ARRAY_TYPE(i16 , I16Array); -WAPP_DEF_ARRAY_TYPE(i32 , I32Array); -WAPP_DEF_ARRAY_TYPE(i64 , I64Array); -WAPP_DEF_ARRAY_TYPE(f32 , F32Array); -WAPP_DEF_ARRAY_TYPE(f64 , F64Array); -WAPP_DEF_ARRAY_TYPE(f128 , F128Array); -WAPP_DEF_ARRAY_TYPE(uptr , UptrArray); -WAPP_DEF_ARRAY_TYPE(iptr , IptrArray); -WAPP_DEF_ARRAY_TYPE(Str8 , Str8Array); +WAPP_DEF_ARRAY_TYPE(c8 , C8Array); +WAPP_DEF_ARRAY_TYPE(c16 , C16Array); +WAPP_DEF_ARRAY_TYPE(c32 , C32Array); +WAPP_DEF_ARRAY_TYPE(u8 , U8Array); +WAPP_DEF_ARRAY_TYPE(u16 , U16Array); +WAPP_DEF_ARRAY_TYPE(u32 , U32Array); +WAPP_DEF_ARRAY_TYPE(u64 , U64Array); +WAPP_DEF_ARRAY_TYPE(b8 , B8Array); +WAPP_DEF_ARRAY_TYPE(i8 , I8Array); +WAPP_DEF_ARRAY_TYPE(i16 , I16Array); +WAPP_DEF_ARRAY_TYPE(i32 , I32Array); +WAPP_DEF_ARRAY_TYPE(i64 , I64Array); +WAPP_DEF_ARRAY_TYPE(f32 , F32Array); +WAPP_DEF_ARRAY_TYPE(f64 , F64Array); +WAPP_DEF_ARRAY_TYPE(f128 , F128Array); +WAPP_DEF_ARRAY_TYPE(uptr , UptrArray); +WAPP_DEF_ARRAY_TYPE(iptr , IptrArray); +WAPP_DEF_ARRAY_TYPE(Str8 , Str8Array); #ifdef WAPP_PLATFORM_CPP END_C_LINKAGE -- 2.39.5 From 31a22b74e943f82542c1ab923d91b8eb6c3d4505 Mon Sep 17 00:00:00 2001 From: Abdelrahman Said Date: Mon, 29 Dec 2025 21:21:09 +0000 Subject: [PATCH 2/9] Reformat base --- src/base/array/array.c | 190 ++++---- src/base/dbl_list/dbl_list.c | 302 ++++++------ src/base/dbl_list/dbl_list.h | 148 +++--- src/base/mem/allocator/mem_allocator.c | 26 +- src/base/mem/allocator/mem_allocator.h | 30 +- src/base/mem/utils/mem_utils.c | 22 +- src/base/strings/str8/str8.c | 612 ++++++++++++------------- src/base/strings/str8/str8.h | 104 ++--- 8 files changed, 717 insertions(+), 717 deletions(-) diff --git a/src/base/array/array.c b/src/base/array/array.c index 504fb2f..05f1efa 100644 --- a/src/base/array/array.c +++ b/src/base/array/array.c @@ -12,162 +12,162 @@ wapp_persist inline void _array_validate(const GenericArray *array, u64 item_size); void *_array_get(GenericArray *array, u64 index, u64 item_size) { - wapp_runtime_assert(array != NULL, "`array` should not be NULL"); - _array_validate(array, item_size); - wapp_runtime_assert(index < array->count, "`index` is out of bounds"); + wapp_runtime_assert(array != NULL, "`array` should not be NULL"); + _array_validate(array, item_size); + wapp_runtime_assert(index < array->count, "`index` is out of bounds"); - return _offset_pointer(array->items, array->item_size * index); + return _offset_pointer(array->items, array->item_size * index); } void _array_set(GenericArray *array, u64 index, void *value, u64 item_size) { - void *item = _array_get(array, index, item_size); - memcpy(item, value, array->item_size); + void *item = _array_get(array, index, item_size); + memcpy(item, value, array->item_size); } void _array_append_capped(GenericArray *array, void *value, u64 item_size) { - wapp_runtime_assert(array != NULL, "`array` should not be NULL"); - _array_validate(array, item_size); + wapp_runtime_assert(array != NULL, "`array` should not be NULL"); + _array_validate(array, item_size); - if (array->count >= array->capacity) { return; } + if (array->count >= array->capacity) { return; } - u64 index = (array->count)++; - _array_set(array, index, value, item_size); + u64 index = (array->count)++; + _array_set(array, index, value, item_size); } void _array_extend_capped(GenericArray *dst, const GenericArray *src, u64 item_size) { - wapp_runtime_assert(dst != NULL && src != NULL, "`dst` and `src` should not be NULL"); - _array_validate(dst, item_size); - _array_validate(src, item_size); + wapp_runtime_assert(dst != NULL && src != NULL, "`dst` and `src` should not be NULL"); + _array_validate(dst, item_size); + _array_validate(src, item_size); - u64 remaining_capacity = dst->capacity - dst->count; + u64 remaining_capacity = dst->capacity - dst->count; - u64 copy_count = src->count < remaining_capacity ? src->count : remaining_capacity; - void *dst_ptr = _offset_pointer(dst->items, dst->count * dst->item_size); - memcpy(dst_ptr, src->items, copy_count * src->item_size); - dst->count += copy_count; + u64 copy_count = src->count < remaining_capacity ? src->count : remaining_capacity; + void *dst_ptr = _offset_pointer(dst->items, dst->count * dst->item_size); + memcpy(dst_ptr, src->items, copy_count * src->item_size); + dst->count += copy_count; } void _array_copy_capped(GenericArray *dst, const GenericArray *src, u64 item_size) { - wapp_runtime_assert(dst != NULL && src != NULL, "`dst` and `src` should not be NULL"); - _array_validate(dst, item_size); - _array_validate(src, item_size); + wapp_runtime_assert(dst != NULL && src != NULL, "`dst` and `src` should not be NULL"); + _array_validate(dst, item_size); + _array_validate(src, item_size); - _array_clear(dst, item_size); - u64 copy_count = src->count < dst->capacity ? src->count : dst->capacity; - memcpy(dst->items, src->items, copy_count * src->item_size); - dst->count = copy_count; + _array_clear(dst, item_size); + u64 copy_count = src->count < dst->capacity ? src->count : dst->capacity; + memcpy(dst->items, src->items, copy_count * src->item_size); + dst->count = copy_count; } GenericArray *_array_append_alloc(const Allocator *allocator, GenericArray *array, void *value, u64 item_size) { - wapp_runtime_assert(allocator != NULL && array != NULL, "`allocator` and `array` should not be NULL"); - _array_validate(array, item_size); + wapp_runtime_assert(allocator != NULL && array != NULL, "`allocator` and `array` should not be NULL"); + _array_validate(array, item_size); - GenericArray *output = array; + GenericArray *output = array; - if (array->count >= array->capacity) { - u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(array->capacity * 2); - output = (GenericArray *)_array_alloc_capacity(allocator, new_capacity, array->item_size, false); - if (!output) { - output = array; - goto RETURN_ARRAY_APPEND_ALLOC; - } - _array_copy_capped(output, array, item_size); - } + if (array->count >= array->capacity) { + u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(array->capacity * 2); + output = (GenericArray *)_array_alloc_capacity(allocator, new_capacity, array->item_size, false); + if (!output) { + output = array; + goto RETURN_ARRAY_APPEND_ALLOC; + } + _array_copy_capped(output, array, item_size); + } - _array_append_capped(output, value, item_size); + _array_append_capped(output, value, item_size); RETURN_ARRAY_APPEND_ALLOC: - return output; + return output; } GenericArray *_array_extend_alloc(const Allocator *allocator, GenericArray *dst, const GenericArray *src, u64 item_size) { - wapp_runtime_assert(allocator != NULL && dst != NULL && src != NULL, "`allocator`, `dst` and `src` should not be NULL"); - _array_validate(dst, item_size); - _array_validate(src, item_size); + wapp_runtime_assert(allocator != NULL && dst != NULL && src != NULL, "`allocator`, `dst` and `src` should not be NULL"); + _array_validate(dst, item_size); + _array_validate(src, item_size); - GenericArray *output = dst; + GenericArray *output = dst; - u64 remaining_capacity = dst->capacity - dst->count; - if (src->count >= remaining_capacity) { - u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(dst->capacity * 2); - output = (GenericArray *)_array_alloc_capacity(allocator, new_capacity, dst->item_size, false); - if (!output) { - output = dst; - goto RETURN_ARRAY_EXTEND_ALLOC; - } - _array_copy_capped(output, dst, item_size); - } + u64 remaining_capacity = dst->capacity - dst->count; + if (src->count >= remaining_capacity) { + u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(dst->capacity * 2); + output = (GenericArray *)_array_alloc_capacity(allocator, new_capacity, dst->item_size, false); + if (!output) { + output = dst; + goto RETURN_ARRAY_EXTEND_ALLOC; + } + _array_copy_capped(output, dst, item_size); + } - _array_extend_capped(output, src, item_size); + _array_extend_capped(output, src, item_size); RETURN_ARRAY_EXTEND_ALLOC: - return output; + return output; } GenericArray *_array_copy_alloc(const Allocator *allocator, GenericArray *dst, const GenericArray *src, u64 item_size) { - wapp_runtime_assert(allocator != NULL && dst != NULL && src != NULL, "`allocator`, `dst` and `src` should not be NULL"); - _array_validate(dst, item_size); - _array_validate(src, item_size); + wapp_runtime_assert(allocator != NULL && dst != NULL && src != NULL, "`allocator`, `dst` and `src` should not be NULL"); + _array_validate(dst, item_size); + _array_validate(src, item_size); - GenericArray *output = dst; + GenericArray *output = dst; - if (src->count >= dst->capacity) { - u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(dst->capacity * 2); - output = (GenericArray *)_array_alloc_capacity(allocator, new_capacity, src->item_size, false); - if (!output) { - output = dst; - goto RETURN_ARRAY_COPY_ALLOC; - } - } + if (src->count >= dst->capacity) { + u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(dst->capacity * 2); + output = (GenericArray *)_array_alloc_capacity(allocator, new_capacity, src->item_size, false); + if (!output) { + output = dst; + goto RETURN_ARRAY_COPY_ALLOC; + } + } - _array_copy_capped(output, src, item_size); + _array_copy_capped(output, src, item_size); RETURN_ARRAY_COPY_ALLOC: - return output; + return output; } void *_array_pop(GenericArray *array, u64 item_size) { - wapp_runtime_assert(array != NULL, "`array` should not be NULL"); - _array_validate(array, item_size); + wapp_runtime_assert(array != NULL, "`array` should not be NULL"); + _array_validate(array, item_size); - if (array->count == 0) { return NULL; } + if (array->count == 0) { return NULL; } - u64 index = array->count - 1; - void *out = _array_get(array, index, item_size); - --(array->count); - return out; + u64 index = array->count - 1; + void *out = _array_get(array, index, item_size); + --(array->count); + return out; } void _array_clear(GenericArray *array, u64 item_size) { - wapp_runtime_assert(array != NULL, "`array` should not be NULL"); - _array_validate(array, item_size); + wapp_runtime_assert(array != NULL, "`array` should not be NULL"); + _array_validate(array, item_size); - array->count = 0; + array->count = 0; } GenericArray *_array_alloc_capacity(const Allocator *allocator, u64 capacity, u64 item_size, b8 fill) { - wapp_runtime_assert(allocator != NULL, "`allocator` should not be NULL"); + wapp_runtime_assert(allocator != NULL, "`allocator` should not be NULL"); - GenericArray *output = NULL; + GenericArray *output = NULL; - u64 allocation_size = sizeof(GenericArray) + item_size * capacity; + u64 allocation_size = sizeof(GenericArray) + item_size * capacity; - output = wapp_mem_allocator_alloc(allocator, allocation_size); - if (!output) { - goto RETURN_ARRAY_ALLOC; - } + output = wapp_mem_allocator_alloc(allocator, allocation_size); + if (!output) { + goto RETURN_ARRAY_ALLOC; + } - output->magic = WAPP_ARRAY_MAGIC; - output->count = fill ? capacity : 0; - output->capacity = capacity; - output->item_size = item_size; - output->items = (void *)(output + 1); + output->magic = WAPP_ARRAY_MAGIC; + output->count = fill ? capacity : 0; + output->capacity = capacity; + output->item_size = item_size; + output->items = (void *)(output + 1); RETURN_ARRAY_ALLOC: - return output; + return output; } wapp_persist inline void _array_validate(const GenericArray *array, u64 item_size) { - wapp_runtime_assert(WAPP_ARRAY_MAGIC == array->magic, "`array` is not a valid wapp array"); - wapp_runtime_assert(item_size == array->item_size, "Invalid item type provided"); + wapp_runtime_assert(WAPP_ARRAY_MAGIC == array->magic, "`array` is not a valid wapp array"); + wapp_runtime_assert(item_size == array->item_size, "Invalid item type provided"); } diff --git a/src/base/dbl_list/dbl_list.c b/src/base/dbl_list/dbl_list.c index 525d648..20c761c 100644 --- a/src/base/dbl_list/dbl_list.c +++ b/src/base/dbl_list/dbl_list.c @@ -12,247 +12,247 @@ wapp_intern inline void _dbl_list_validate(const GenericList *list, u64 item_siz wapp_intern inline void _dbl_list_node_validate(const GenericList *list, const GenericNode *node, u64 item_size); GenericList *_dbl_list_alloc(const Allocator *allocator, u64 item_size) { - wapp_debug_assert(allocator != NULL, "`allocator` should not be NULL"); + wapp_debug_assert(allocator != NULL, "`allocator` should not be NULL"); - GenericList *list = wapp_mem_allocator_alloc(allocator, sizeof(GenericList)); - if (!list) { goto DBL_LIST_ALLOC_RETURN; } + GenericList *list = wapp_mem_allocator_alloc(allocator, sizeof(GenericList)); + if (!list) { goto DBL_LIST_ALLOC_RETURN; } - memset((void *)list, 0, sizeof(GenericList)); - list->magic = WAPP_DBL_LIST_MAGIC; - list->item_size = item_size; + memset((void *)list, 0, sizeof(GenericList)); + list->magic = WAPP_DBL_LIST_MAGIC; + list->item_size = item_size; DBL_LIST_ALLOC_RETURN: - return list; + return list; } GenericNode *_dbl_list_node_alloc(const Allocator *allocator, u64 item_size) { - wapp_debug_assert(allocator != NULL, "`allocator` should not be NULL"); + wapp_debug_assert(allocator != NULL, "`allocator` should not be NULL"); - GenericNode *node = wapp_mem_allocator_alloc(allocator, sizeof(GenericNode)); - if (!node) { goto DBL_LIST_NODE_ALLOC_RETURN; } + GenericNode *node = wapp_mem_allocator_alloc(allocator, sizeof(GenericNode)); + if (!node) { goto DBL_LIST_NODE_ALLOC_RETURN; } - memset((void *)node, 0, sizeof(GenericNode)); - node->magic = WAPP_DBL_NODE_MAGIC; - node->item_size = item_size; + memset((void *)node, 0, sizeof(GenericNode)); + node->magic = WAPP_DBL_NODE_MAGIC; + node->item_size = item_size; DBL_LIST_NODE_ALLOC_RETURN: - return node; + return node; } GenericNode *_dbl_list_get(const GenericList *list, u64 index, u64 item_size) { - wapp_debug_assert(list != NULL, "`list` should not be NULL"); - _dbl_list_validate(list, item_size); - wapp_runtime_assert(index < list->node_count, "`index` is out of bounds"); + wapp_debug_assert(list != NULL, "`list` should not be NULL"); + _dbl_list_validate(list, item_size); + wapp_runtime_assert(index < list->node_count, "`index` is out of bounds"); - GenericNode *output = NULL; - GenericNode *current = list->first; - for (u64 i = 1; i <= index; ++i) { - current = current->next; - } + GenericNode *output = NULL; + GenericNode *current = list->first; + for (u64 i = 1; i <= index; ++i) { + current = current->next; + } - output = current; + output = current; - return output; + return output; } void _dbl_list_push_front(GenericList *list, GenericNode *node, u64 item_size) { - wapp_debug_assert(list != NULL && node != NULL && (node->item) != NULL, "`list`, `node` and `node->item` should not be NULL"); - _dbl_list_validate(list, item_size); - _dbl_list_node_validate(list, node, item_size); + wapp_debug_assert(list != NULL && node != NULL && (node->item) != NULL, "`list`, `node` and `node->item` should not be NULL"); + _dbl_list_validate(list, item_size); + _dbl_list_node_validate(list, node, item_size); - GenericList node_list = _node_to_list(node, item_size); + GenericList node_list = _node_to_list(node, item_size); - if (list->node_count == 0) { - *list = node_list; - return; - } + if (list->node_count == 0) { + *list = node_list; + return; + } - list->node_count += node_list.node_count; + list->node_count += node_list.node_count; - GenericNode *first = list->first; - if (first) { - first->prev = node_list.last; - } + GenericNode *first = list->first; + if (first) { + first->prev = node_list.last; + } - list->first = node_list.first; - node_list.last->next = first; + list->first = node_list.first; + node_list.last->next = first; } void _dbl_list_push_back(GenericList *list, GenericNode *node, u64 item_size) { - wapp_debug_assert(list != NULL && node != NULL && (node->item) != NULL, "`list`, `node` and `node->item` should not be NULL"); - _dbl_list_validate(list, item_size); - _dbl_list_node_validate(list, node, item_size); + wapp_debug_assert(list != NULL && node != NULL && (node->item) != NULL, "`list`, `node` and `node->item` should not be NULL"); + _dbl_list_validate(list, item_size); + _dbl_list_node_validate(list, node, item_size); - GenericList node_list = _node_to_list(node, item_size); + GenericList node_list = _node_to_list(node, item_size); - if (list->node_count == 0) { - *list = node_list; - return; - } + if (list->node_count == 0) { + *list = node_list; + return; + } - list->node_count += node_list.node_count; + list->node_count += node_list.node_count; - GenericNode *last = list->last; - if (last) { - last->next = node_list.first; - } + GenericNode *last = list->last; + if (last) { + last->next = node_list.first; + } - list->last = node_list.last; - node_list.first->prev = last; + list->last = node_list.last; + node_list.first->prev = last; } void _dbl_list_insert(GenericList *list, GenericNode *node, u64 index, u64 item_size) { - wapp_debug_assert(list != NULL && node != NULL && (node->item) != NULL, "`list`, `node` and `node->item` should not be NULL"); - _dbl_list_validate(list, item_size); - _dbl_list_node_validate(list, node, item_size); + wapp_debug_assert(list != NULL && node != NULL && (node->item) != NULL, "`list`, `node` and `node->item` should not be NULL"); + _dbl_list_validate(list, item_size); + _dbl_list_node_validate(list, node, item_size); - if (index == 0) { - _dbl_list_push_front(list, node, item_size); - return; - } else if (index == list->node_count) { - _dbl_list_push_back(list, node, item_size); - return; - } + if (index == 0) { + _dbl_list_push_front(list, node, item_size); + return; + } else if (index == list->node_count) { + _dbl_list_push_back(list, node, item_size); + return; + } - GenericNode *dst_node = _dbl_list_get(list, index, item_size); - if (!dst_node) { - return; - } + GenericNode *dst_node = _dbl_list_get(list, index, item_size); + if (!dst_node) { + return; + } - GenericList node_list = _node_to_list(node, item_size); + GenericList node_list = _node_to_list(node, item_size); - list->node_count += node_list.node_count; + list->node_count += node_list.node_count; - GenericNode *prev = dst_node->prev; + GenericNode *prev = dst_node->prev; - dst_node->prev = node_list.last; - prev->next = node_list.first; + dst_node->prev = node_list.last; + prev->next = node_list.first; - node_list.first->prev = prev; - node_list.last->next = dst_node; + node_list.first->prev = prev; + node_list.last->next = dst_node; } GenericNode *_dbl_list_pop_front(GenericList *list, u64 item_size) { - wapp_debug_assert(list != NULL, "`list` should not be NULL"); - _dbl_list_validate(list, item_size); + wapp_debug_assert(list != NULL, "`list` should not be NULL"); + _dbl_list_validate(list, item_size); - GenericNode *output = NULL; + GenericNode *output = NULL; - if (list->node_count == 0) { - goto RETURN_I32_LIST_POP_FRONT; - } + if (list->node_count == 0) { + goto RETURN_I32_LIST_POP_FRONT; + } - output = list->first; + output = list->first; - if (list->node_count == 1) { - *list = (GenericList){.magic = WAPP_DBL_LIST_MAGIC, .item_size = item_size}; - goto RETURN_I32_LIST_POP_FRONT; - } + if (list->node_count == 1) { + *list = (GenericList){.magic = WAPP_DBL_LIST_MAGIC, .item_size = item_size}; + goto RETURN_I32_LIST_POP_FRONT; + } - --(list->node_count); - list->first = output->next; + --(list->node_count); + list->first = output->next; - output->prev = output->next = NULL; + output->prev = output->next = NULL; RETURN_I32_LIST_POP_FRONT: - return output; + return output; } GenericNode *_dbl_list_pop_back(GenericList *list, u64 item_size) { - wapp_debug_assert(list != NULL, "`list` should not be NULL"); - _dbl_list_validate(list, item_size); + wapp_debug_assert(list != NULL, "`list` should not be NULL"); + _dbl_list_validate(list, item_size); - GenericNode *output = NULL; + GenericNode *output = NULL; - if (list->node_count == 0) { - goto RETURN_I32_LIST_POP_BACK; - } + if (list->node_count == 0) { + goto RETURN_I32_LIST_POP_BACK; + } - output = list->last; + output = list->last; - if (list->node_count == 1) { - *list = (GenericList){.magic = WAPP_DBL_LIST_MAGIC, .item_size = item_size}; - goto RETURN_I32_LIST_POP_BACK; - } + if (list->node_count == 1) { + *list = (GenericList){.magic = WAPP_DBL_LIST_MAGIC, .item_size = item_size}; + goto RETURN_I32_LIST_POP_BACK; + } - --(list->node_count); - list->last = output->prev; + --(list->node_count); + list->last = output->prev; - output->prev = output->next = NULL; + output->prev = output->next = NULL; RETURN_I32_LIST_POP_BACK: - return output; + return output; } GenericNode *_dbl_list_remove(GenericList *list, u64 index, u64 item_size) { - wapp_debug_assert(list != NULL, "`list` should not be NULL"); - _dbl_list_validate(list, item_size); + wapp_debug_assert(list != NULL, "`list` should not be NULL"); + _dbl_list_validate(list, item_size); - GenericNode *output = NULL; + GenericNode *output = NULL; - if (index == 0) { - output = _dbl_list_pop_front(list, item_size); - goto RETURN_I32_LIST_REMOVE; - } else if (index == list->node_count) { - output = _dbl_list_pop_back(list, item_size); - goto RETURN_I32_LIST_REMOVE; - } + if (index == 0) { + output = _dbl_list_pop_front(list, item_size); + goto RETURN_I32_LIST_REMOVE; + } else if (index == list->node_count) { + output = _dbl_list_pop_back(list, item_size); + goto RETURN_I32_LIST_REMOVE; + } - output = _dbl_list_get(list, index, item_size); - if (!output) { - goto RETURN_I32_LIST_REMOVE; - } + output = _dbl_list_get(list, index, item_size); + if (!output) { + goto RETURN_I32_LIST_REMOVE; + } - output->prev->next = output->next; - output->next->prev = output->prev; + output->prev->next = output->next; + output->next->prev = output->prev; - --(list->node_count); + --(list->node_count); - output->prev = output->next = NULL; + output->prev = output->next = NULL; RETURN_I32_LIST_REMOVE: - return output; + return output; } void _dbl_list_empty(GenericList *list, u64 item_size) { - wapp_debug_assert(list != NULL, "`list` should not be NULL"); - _dbl_list_validate(list, item_size); + wapp_debug_assert(list != NULL, "`list` should not be NULL"); + _dbl_list_validate(list, item_size); - u64 count = list->node_count; - for (u64 i = 0; i < count; ++i) { - _dbl_list_pop_back(list, item_size); - } + u64 count = list->node_count; + for (u64 i = 0; i < count; ++i) { + _dbl_list_pop_back(list, item_size); + } } wapp_intern GenericList _node_to_list(GenericNode *node, u64 item_size) { - GenericList output = { - .magic = WAPP_DBL_LIST_MAGIC, - .first = node, - .last = node, - .node_count = 1, - .item_size = item_size, - }; + GenericList output = { + .magic = WAPP_DBL_LIST_MAGIC, + .first = node, + .last = node, + .node_count = 1, + .item_size = item_size, + }; - while (output.first->prev != NULL) { - output.first = output.first->prev; - ++(output.node_count); - } + while (output.first->prev != NULL) { + output.first = output.first->prev; + ++(output.node_count); + } - while (output.last->next != NULL) { - output.last = output.last->next; - ++(output.node_count); - } + while (output.last->next != NULL) { + output.last = output.last->next; + ++(output.node_count); + } - return output; + return output; } wapp_intern void _dbl_list_validate(const GenericList *list, u64 item_size) { - wapp_runtime_assert(list->magic == WAPP_DBL_LIST_MAGIC, "`list` isn't a valid wapp list type"); - wapp_runtime_assert(list->item_size == item_size, "Invalid item provided"); + wapp_runtime_assert(list->magic == WAPP_DBL_LIST_MAGIC, "`list` isn't a valid wapp list type"); + wapp_runtime_assert(list->item_size == item_size, "Invalid item provided"); } wapp_intern void _dbl_list_node_validate(const GenericList *list, const GenericNode *node, u64 item_size) { - wapp_runtime_assert(node->magic == WAPP_DBL_NODE_MAGIC, "`node` isn't a valid wapp node type"); - wapp_runtime_assert(list->item_size == node->item_size, "Mismatched `list` and `node` types"); - wapp_runtime_assert(node->item_size == item_size, "Invalid item provided"); + wapp_runtime_assert(node->magic == WAPP_DBL_NODE_MAGIC, "`node` isn't a valid wapp node type"); + wapp_runtime_assert(list->item_size == node->item_size, "Mismatched `list` and `node` types"); + wapp_runtime_assert(node->item_size == item_size, "Invalid item provided"); } diff --git a/src/base/dbl_list/dbl_list.h b/src/base/dbl_list/dbl_list.h index 69895af..b739709 100644 --- a/src/base/dbl_list/dbl_list.h +++ b/src/base/dbl_list/dbl_list.h @@ -14,94 +14,94 @@ BEGIN_C_LINKAGE #define WAPP_DBL_LIST_MAGIC (u64)0x57415f444c5354 #define WAPP_DBL_NODE_MAGIC (u64)0x57415f444e44 -#define WAPP_DEF_DBL_LIST_TYPE(T, NODE_NAME, LIST_NAME) \ - typedef struct NODE_NAME NODE_NAME; \ - struct NODE_NAME { \ - u64 magic; \ - T *item; \ - NODE_NAME *prev; \ - NODE_NAME *next; \ - u64 item_size; \ - }; \ - \ - typedef struct { \ - u64 magic; \ - NODE_NAME *first; \ - NODE_NAME *last; \ - u64 node_count; \ - u64 item_size; \ - } LIST_NAME +#define WAPP_DEF_DBL_LIST_TYPE(T, NODE_NAME, LIST_NAME) \ + typedef struct NODE_NAME NODE_NAME; \ + struct NODE_NAME { \ + u64 magic; \ + T *item; \ + NODE_NAME *prev; \ + NODE_NAME *next; \ + u64 item_size; \ + }; \ + \ + typedef struct { \ + u64 magic; \ + NODE_NAME *first; \ + NODE_NAME *last; \ + u64 node_count; \ + u64 item_size; \ + } LIST_NAME #ifdef WAPP_PLATFORM_CPP -#define wapp_dbl_list(ELEM_TYPE, LIST_TYPE) \ - LIST_TYPE{WAPP_DBL_LIST_MAGIC, nullptr, nullptr, 0, sizeof(ELEM_TYPE)} -#define wapp_dbl_list_node(ELEM_TYPE, NODE_TYPE, ELEM_PTR) \ - NODE_TYPE{WAPP_DBL_NODE_MAGIC, ELEM_PTR, nullptr, nullptr, sizeof(ELEM_TYPE)} +#define wapp_dbl_list(ELEM_TYPE, LIST_TYPE) \ + LIST_TYPE{WAPP_DBL_LIST_MAGIC, nullptr, nullptr, 0, sizeof(ELEM_TYPE)} +#define wapp_dbl_list_node(ELEM_TYPE, NODE_TYPE, ELEM_PTR) \ + NODE_TYPE{WAPP_DBL_NODE_MAGIC, ELEM_PTR, nullptr, nullptr, sizeof(ELEM_TYPE)} #else -#define wapp_dbl_list(ELEM_TYPE, LIST_TYPE) ( \ - (LIST_TYPE){.magic = WAPP_DBL_LIST_MAGIC, .item_size = sizeof(ELEM_TYPE)} \ +#define wapp_dbl_list(ELEM_TYPE, LIST_TYPE) ( \ + (LIST_TYPE){.magic = WAPP_DBL_LIST_MAGIC, .item_size = sizeof(ELEM_TYPE)} \ ) -#define wapp_dbl_list_node(ELEM_TYPE, NODE_TYPE, ELEM_PTR) ( \ - (NODE_TYPE){.magic = WAPP_DBL_NODE_MAGIC, .item = ELEM_PTR, .item_size = sizeof(ELEM_TYPE)} \ +#define wapp_dbl_list_node(ELEM_TYPE, NODE_TYPE, ELEM_PTR) ( \ + (NODE_TYPE){.magic = WAPP_DBL_NODE_MAGIC, .item = ELEM_PTR, .item_size = sizeof(ELEM_TYPE)} \ ) #endif // !WAPP_PLATFORM_CPP -#define wapp_dbl_list_alloc(ELEM_TYPE, LIST_TYPE, ALLOCATOR) \ - (LIST_TYPE *)_dbl_list_alloc(ALLOCATOR, sizeof(ELEM_TYPE)) -#define wapp_dbl_list_node_alloc(ELEM_TYPE, NODE_TYPE, ALLOCATOR) \ - (NODE_TYPE *)_dbl_list_node_alloc(ALLOCATOR, sizeof(ELEM_TYPE)) -#define wapp_dbl_list_get(ELEM_TYPE, NODE_TYPE, LIST_PTR, ELEM_INDEX) \ - (NODE_TYPE *)_dbl_list_get((GenericList *)LIST_PTR, ELEM_INDEX, sizeof(ELEM_TYPE)) -#define wapp_dbl_list_push_front(ELEM_TYPE, LIST_PTR, NODE_PTR) \ - _dbl_list_push_front((GenericList *)LIST_PTR, (GenericNode *)NODE_PTR, sizeof(ELEM_TYPE)) -#define wapp_dbl_list_push_back(ELEM_TYPE, LIST_PTR, NODE_PTR) \ - _dbl_list_push_back((GenericList *)LIST_PTR, (GenericNode *)NODE_PTR, sizeof(ELEM_TYPE)) -#define wapp_dbl_list_insert(ELEM_TYPE, LIST_PTR, NODE_PTR, ELEM_INDEX) \ - _dbl_list_insert((GenericList *)LIST_PTR, (GenericNode *)NODE_PTR, ELEM_INDEX, sizeof(ELEM_TYPE)) -#define wapp_dbl_list_pop_front(ELEM_TYPE, NODE_TYPE, LIST_PTR) \ - (NODE_TYPE *)_dbl_list_pop_front((GenericList *)LIST_PTR, sizeof(ELEM_TYPE)) -#define wapp_dbl_list_pop_back(ELEM_TYPE, NODE_TYPE, LIST_PTR) \ - (NODE_TYPE *)_dbl_list_pop_back((GenericList *)LIST_PTR, sizeof(ELEM_TYPE)) -#define wapp_dbl_list_remove(ELEM_TYPE, NODE_TYPE, LIST_PTR, ELEM_INDEX) \ - (NODE_TYPE *)_dbl_list_remove((GenericList *)LIST_PTR, ELEM_INDEX, sizeof(ELEM_TYPE)) -#define wapp_dbl_list_empty(ELEM_TYPE, LIST_PTR) \ - _dbl_list_empty((GenericList *)LIST_PTR, sizeof(ELEM_TYPE)) +#define wapp_dbl_list_alloc(ELEM_TYPE, LIST_TYPE, ALLOCATOR) \ + (LIST_TYPE *)_dbl_list_alloc(ALLOCATOR, sizeof(ELEM_TYPE)) +#define wapp_dbl_list_node_alloc(ELEM_TYPE, NODE_TYPE, ALLOCATOR) \ + (NODE_TYPE *)_dbl_list_node_alloc(ALLOCATOR, sizeof(ELEM_TYPE)) +#define wapp_dbl_list_get(ELEM_TYPE, NODE_TYPE, LIST_PTR, ELEM_INDEX) \ + (NODE_TYPE *)_dbl_list_get((GenericList *)LIST_PTR, ELEM_INDEX, sizeof(ELEM_TYPE)) +#define wapp_dbl_list_push_front(ELEM_TYPE, LIST_PTR, NODE_PTR) \ + _dbl_list_push_front((GenericList *)LIST_PTR, (GenericNode *)NODE_PTR, sizeof(ELEM_TYPE)) +#define wapp_dbl_list_push_back(ELEM_TYPE, LIST_PTR, NODE_PTR) \ + _dbl_list_push_back((GenericList *)LIST_PTR, (GenericNode *)NODE_PTR, sizeof(ELEM_TYPE)) +#define wapp_dbl_list_insert(ELEM_TYPE, LIST_PTR, NODE_PTR, ELEM_INDEX) \ + _dbl_list_insert((GenericList *)LIST_PTR, (GenericNode *)NODE_PTR, ELEM_INDEX, sizeof(ELEM_TYPE)) +#define wapp_dbl_list_pop_front(ELEM_TYPE, NODE_TYPE, LIST_PTR) \ + (NODE_TYPE *)_dbl_list_pop_front((GenericList *)LIST_PTR, sizeof(ELEM_TYPE)) +#define wapp_dbl_list_pop_back(ELEM_TYPE, NODE_TYPE, LIST_PTR) \ + (NODE_TYPE *)_dbl_list_pop_back((GenericList *)LIST_PTR, sizeof(ELEM_TYPE)) +#define wapp_dbl_list_remove(ELEM_TYPE, NODE_TYPE, LIST_PTR, ELEM_INDEX) \ + (NODE_TYPE *)_dbl_list_remove((GenericList *)LIST_PTR, ELEM_INDEX, sizeof(ELEM_TYPE)) +#define wapp_dbl_list_empty(ELEM_TYPE, LIST_PTR) \ + _dbl_list_empty((GenericList *)LIST_PTR, sizeof(ELEM_TYPE)) WAPP_DEF_DBL_LIST_TYPE(void, GenericNode, GenericList); -GenericList *_dbl_list_alloc(const Allocator *allocator, u64 item_size); -GenericNode *_dbl_list_node_alloc(const Allocator *allocator, u64 item_size); -GenericNode *_dbl_list_get(const GenericList *list, u64 index, u64 item_size); -void _dbl_list_push_front(GenericList *list, GenericNode *node, u64 item_size); -void _dbl_list_push_back(GenericList *list, GenericNode *node, u64 item_size); -void _dbl_list_insert(GenericList *list, GenericNode *node, u64 index, u64 item_size); -GenericNode *_dbl_list_pop_front(GenericList *list, u64 item_size); -GenericNode *_dbl_list_pop_back(GenericList *list, u64 item_size); -GenericNode *_dbl_list_remove(GenericList *list, u64 index, u64 item_size); -void _dbl_list_empty(GenericList *list, u64 item_size); +GenericList *_dbl_list_alloc(const Allocator *allocator, u64 item_size); +GenericNode *_dbl_list_node_alloc(const Allocator *allocator, u64 item_size); +GenericNode *_dbl_list_get(const GenericList *list, u64 index, u64 item_size); +void _dbl_list_push_front(GenericList *list, GenericNode *node, u64 item_size); +void _dbl_list_push_back(GenericList *list, GenericNode *node, u64 item_size); +void _dbl_list_insert(GenericList *list, GenericNode *node, u64 index, u64 item_size); +GenericNode *_dbl_list_pop_front(GenericList *list, u64 item_size); +GenericNode *_dbl_list_pop_back(GenericList *list, u64 item_size); +GenericNode *_dbl_list_remove(GenericList *list, u64 index, u64 item_size); +void _dbl_list_empty(GenericList *list, u64 item_size); // Base list types typedef struct str8 Str8; -WAPP_DEF_DBL_LIST_TYPE(void *, VoidPtrNode, VoidPtrList); -WAPP_DEF_DBL_LIST_TYPE(c8 , C8Node , C8List); -WAPP_DEF_DBL_LIST_TYPE(c16 , C16Node , C16List); -WAPP_DEF_DBL_LIST_TYPE(c32 , C32Node , C32List); -WAPP_DEF_DBL_LIST_TYPE(u8 , U8Node , U8List); -WAPP_DEF_DBL_LIST_TYPE(u16 , U16Node , U16List); -WAPP_DEF_DBL_LIST_TYPE(u32 , U32Node , U32List); -WAPP_DEF_DBL_LIST_TYPE(u64 , U64Node , U64List); -WAPP_DEF_DBL_LIST_TYPE(b8 , B8Node , B8List); -WAPP_DEF_DBL_LIST_TYPE(i8 , I8Node , I8List); -WAPP_DEF_DBL_LIST_TYPE(i16 , I16Node , I16List); -WAPP_DEF_DBL_LIST_TYPE(i32 , I32Node , I32List); -WAPP_DEF_DBL_LIST_TYPE(i64 , I64Node , I64List); -WAPP_DEF_DBL_LIST_TYPE(f32 , F32Node , F32List); -WAPP_DEF_DBL_LIST_TYPE(f64 , F64Node , F64List); -WAPP_DEF_DBL_LIST_TYPE(f128 , F128Node , F128List); -WAPP_DEF_DBL_LIST_TYPE(uptr , UptrNode , UptrList); -WAPP_DEF_DBL_LIST_TYPE(iptr , IptrNode , IptrList); -WAPP_DEF_DBL_LIST_TYPE(Str8 , Str8Node , Str8List); +WAPP_DEF_DBL_LIST_TYPE(void * , VoidPtrNode , VoidPtrList); +WAPP_DEF_DBL_LIST_TYPE(c8 , C8Node , C8List); +WAPP_DEF_DBL_LIST_TYPE(c16 , C16Node , C16List); +WAPP_DEF_DBL_LIST_TYPE(c32 , C32Node , C32List); +WAPP_DEF_DBL_LIST_TYPE(u8 , U8Node , U8List); +WAPP_DEF_DBL_LIST_TYPE(u16 , U16Node , U16List); +WAPP_DEF_DBL_LIST_TYPE(u32 , U32Node , U32List); +WAPP_DEF_DBL_LIST_TYPE(u64 , U64Node , U64List); +WAPP_DEF_DBL_LIST_TYPE(b8 , B8Node , B8List); +WAPP_DEF_DBL_LIST_TYPE(i8 , I8Node , I8List); +WAPP_DEF_DBL_LIST_TYPE(i16 , I16Node , I16List); +WAPP_DEF_DBL_LIST_TYPE(i32 , I32Node , I32List); +WAPP_DEF_DBL_LIST_TYPE(i64 , I64Node , I64List); +WAPP_DEF_DBL_LIST_TYPE(f32 , F32Node , F32List); +WAPP_DEF_DBL_LIST_TYPE(f64 , F64Node , F64List); +WAPP_DEF_DBL_LIST_TYPE(f128 , F128Node , F128List); +WAPP_DEF_DBL_LIST_TYPE(uptr , UptrNode , UptrList); +WAPP_DEF_DBL_LIST_TYPE(iptr , IptrNode , IptrList); +WAPP_DEF_DBL_LIST_TYPE(Str8 , Str8Node , Str8List); #ifdef WAPP_PLATFORM_CPP END_C_LINKAGE diff --git a/src/base/mem/allocator/mem_allocator.c b/src/base/mem/allocator/mem_allocator.c index 89e14ec..fe82249 100644 --- a/src/base/mem/allocator/mem_allocator.c +++ b/src/base/mem/allocator/mem_allocator.c @@ -6,30 +6,30 @@ #include void *wapp_mem_allocator_alloc(const Allocator *allocator, u64 size) { - wapp_debug_assert(allocator != NULL && (allocator->alloc) != NULL, "`allocator` and `allocator->alloc` should not be NULL"); - return allocator->alloc(size, allocator->obj); + wapp_debug_assert(allocator != NULL && (allocator->alloc) != NULL, "`allocator` and `allocator->alloc` should not be NULL"); + return allocator->alloc(size, allocator->obj); } void *wapp_mem_allocator_alloc_aligned(const Allocator *allocator, u64 size, u64 alignment) { - wapp_debug_assert(allocator != NULL && (allocator->alloc_aligned) != NULL, "`allocator` and `allocator->alloc_aligned` should not be NULL"); - return allocator->alloc_aligned(size, alignment, allocator->obj); + wapp_debug_assert(allocator != NULL && (allocator->alloc_aligned) != NULL, "`allocator` and `allocator->alloc_aligned` should not be NULL"); + return allocator->alloc_aligned(size, alignment, allocator->obj); } void *wapp_mem_allocator_realloc(const Allocator *allocator, void *ptr, u64 old_size, u64 new_size) { - wapp_debug_assert(allocator != NULL && (allocator->realloc) != NULL, "`allocator` and `allocator->realloc` should not be NULL"); - return allocator->realloc(ptr, old_size, new_size, allocator->obj); + wapp_debug_assert(allocator != NULL && (allocator->realloc) != NULL, "`allocator` and `allocator->realloc` should not be NULL"); + return allocator->realloc(ptr, old_size, new_size, allocator->obj); } void *wapp_mem_allocator_realloc_aligned(const Allocator *allocator, void *ptr, u64 old_size, - u64 new_size, u64 alignment) { - wapp_debug_assert(allocator != NULL && (allocator->realloc_aligned) != NULL, "`allocator` and `allocator->realloc_aligned` should not be NULL"); - return allocator->realloc_aligned(ptr, old_size, new_size, alignment, allocator->obj); + u64 new_size, u64 alignment) { + wapp_debug_assert(allocator != NULL && (allocator->realloc_aligned) != NULL, "`allocator` and `allocator->realloc_aligned` should not be NULL"); + return allocator->realloc_aligned(ptr, old_size, new_size, alignment, allocator->obj); } void wapp_mem_allocator_free(const Allocator *allocator, void **ptr, u64 size) { - if (!allocator || !(allocator->free)) { - return; - } + if (!allocator || !(allocator->free)) { + return; + } - allocator->free(ptr, size, allocator->obj); + allocator->free(ptr, size, allocator->obj); } diff --git a/src/base/mem/allocator/mem_allocator.h b/src/base/mem/allocator/mem_allocator.h index 77d1f54..f7407d9 100644 --- a/src/base/mem/allocator/mem_allocator.h +++ b/src/base/mem/allocator/mem_allocator.h @@ -11,26 +11,26 @@ BEGIN_C_LINKAGE #endif // !WAPP_PLATFORM_CPP -typedef void *(MemAllocFunc)(u64 size, void *alloc_obj); -typedef void *(MemAllocAlignedFunc)(u64 size, u64 alignment, void *alloc_obj); -typedef void *(MemReallocFunc)(void *ptr, u64 old_size, u64 new_size, void *alloc_obj); -typedef void *(MemReallocAlignedFunc)(void *ptr, u64 old_size, u64 new_size, u64 alignment, void *alloc_obj); -typedef void (MemFreeFunc)(void **ptr, u64 size, void *alloc_obj); +typedef void *(MemAllocFunc)(u64 size, void *alloc_obj); +typedef void *(MemAllocAlignedFunc)(u64 size, u64 alignment, void *alloc_obj); +typedef void *(MemReallocFunc)(void *ptr, u64 old_size, u64 new_size, void *alloc_obj); +typedef void *(MemReallocAlignedFunc)(void *ptr, u64 old_size, u64 new_size, u64 alignment, void *alloc_obj); +typedef void (MemFreeFunc)(void **ptr, u64 size, void *alloc_obj); typedef struct allocator Allocator; struct allocator { - void *obj; - MemAllocFunc *alloc; - MemAllocAlignedFunc *alloc_aligned; - MemReallocFunc *realloc; - MemReallocAlignedFunc *realloc_aligned; - MemFreeFunc *free; + void *obj; + MemAllocFunc *alloc; + MemAllocAlignedFunc *alloc_aligned; + MemReallocFunc *realloc; + MemReallocAlignedFunc *realloc_aligned; + MemFreeFunc *free; }; #ifdef WAPP_PLATFORM_CPP -#define wapp_mem_allocator_invalid(ALLOCATOR) ([&]() { \ - Allocator alloc{}; \ - return memcmp(ALLOCATOR, &alloc, sizeof(Allocator)) == 0; \ +#define wapp_mem_allocator_invalid(ALLOCATOR) ([&]() { \ + Allocator alloc{}; \ + return memcmp(ALLOCATOR, &alloc, sizeof(Allocator)) == 0; \ }()) #else #define wapp_mem_allocator_invalid(ALLOCATOR) (memcmp(ALLOCATOR, &((Allocator){0}), sizeof(Allocator)) == 0) @@ -40,7 +40,7 @@ void *wapp_mem_allocator_alloc(const Allocator *allocator, u64 size); void *wapp_mem_allocator_alloc_aligned(const Allocator *allocator, u64 size, u64 alignment); void *wapp_mem_allocator_realloc(const Allocator *allocator, void *ptr, u64 old_size, u64 new_size); void *wapp_mem_allocator_realloc_aligned(const Allocator *allocator, void *ptr, u64 old_size, - u64 new_size, u64 alignment); + u64 new_size, u64 alignment); void wapp_mem_allocator_free(const Allocator *allocator, void **ptr, u64 size); #ifdef WAPP_PLATFORM_CPP diff --git a/src/base/mem/utils/mem_utils.c b/src/base/mem/utils/mem_utils.c index b308016..d344a36 100644 --- a/src/base/mem/utils/mem_utils.c +++ b/src/base/mem/utils/mem_utils.c @@ -8,19 +8,19 @@ wapp_intern b8 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"); - wapp_runtime_assert(is_power_of_two(alignment), "`alignment` value is not a power of two"); + wapp_debug_assert(ptr != NULL, "`ptr` should not be NULL"); + wapp_runtime_assert(is_power_of_two(alignment), "`alignment` value is not a power of two"); - uptr p = (uptr)ptr; - uptr align = (uptr)alignment; + uptr p = (uptr)ptr; + uptr align = (uptr)alignment; - // Similar to p % align, but it's a faster implementation that works fine - // because align is guaranteed to be a power of 2 - uptr modulo = p & (align - 1); + // Similar to p % align, but it's a faster implementation that works fine + // because align is guaranteed to be a power of 2 + uptr modulo = p & (align - 1); - if (modulo != 0) { - p += align - modulo; - } + if (modulo != 0) { + p += align - modulo; + } - return (void *)p; + return (void *)p; } diff --git a/src/base/strings/str8/str8.c b/src/base/strings/str8/str8.c index 25c6deb..59b5bc1 100644 --- a/src/base/strings/str8/str8.c +++ b/src/base/strings/str8/str8.c @@ -14,479 +14,479 @@ #define STR8_BUF_ALLOC_SIZE(CAPACITY) (sizeof(Str8) + sizeof(c8) * CAPACITY) Str8 *wapp_str8_alloc_buf(const Allocator *allocator, u64 capacity) { - wapp_debug_assert(allocator != NULL, "`allocator` should not be NULL"); + wapp_debug_assert(allocator != NULL, "`allocator` should not be NULL"); - Str8 *str = wapp_mem_allocator_alloc(allocator, STR8_BUF_ALLOC_SIZE(capacity)); - if (!str) { - goto RETURN_STR8; - } + Str8 *str = wapp_mem_allocator_alloc(allocator, STR8_BUF_ALLOC_SIZE(capacity)); + if (!str) { + goto RETURN_STR8; + } - str->buf = (u8 *)str + sizeof(Str8); - str->size = 0; - str->capacity = capacity; + str->buf = (u8 *)str + sizeof(Str8); + str->size = 0; + str->capacity = capacity; RETURN_STR8: - return str; + return str; } Str8 *wapp_str8_alloc_and_fill_buf(const Allocator *allocator, u64 capacity) { - Str8 *out = wapp_str8_alloc_buf(allocator, capacity); - if (out) { - memset(out->buf, 0, capacity); - out->size = capacity; - } - return out; + Str8 *out = wapp_str8_alloc_buf(allocator, capacity); + if (out) { + memset(out->buf, 0, capacity); + out->size = capacity; + } + return out; } Str8 *wapp_str8_alloc_cstr(const Allocator *allocator, const char *str) { - wapp_debug_assert(allocator != NULL && str != NULL, "`allocator` and `str` should not be NULL"); + wapp_debug_assert(allocator != NULL && str != NULL, "`allocator` and `str` should not be NULL"); - u64 length = strlen(str); - Str8 *output = wapp_str8_alloc_buf(allocator, length * 2); - if (!output) { - goto RETURN_ALLOC_CSTR; - } + u64 length = strlen(str); + Str8 *output = wapp_str8_alloc_buf(allocator, length * 2); + if (!output) { + goto RETURN_ALLOC_CSTR; + } - output->size = length; - memcpy(output->buf, str, length); + output->size = length; + memcpy(output->buf, str, length); RETURN_ALLOC_CSTR: - return output; + return output; } Str8 *wapp_str8_alloc_str8(const Allocator *allocator, Str8RO *str) { - wapp_debug_assert(allocator != NULL && str != NULL, "`allocator` and `str` should not be NULL"); + wapp_debug_assert(allocator != NULL && str != NULL, "`allocator` and `str` should not be NULL"); - Str8 *output = wapp_str8_alloc_buf(allocator, str->capacity); - if (!output) { - goto RETURN_ALLOC_STR8; - } + Str8 *output = wapp_str8_alloc_buf(allocator, str->capacity); + if (!output) { + goto RETURN_ALLOC_STR8; + } - output->size = str->size; - memcpy(output->buf, str->buf, str->size); + output->size = str->size; + memcpy(output->buf, str->buf, str->size); RETURN_ALLOC_STR8: - return output; + return output; } Str8 *wapp_str8_alloc_substr(const Allocator *allocator, Str8RO *str, u64 start, u64 end) { - wapp_debug_assert(allocator != NULL && str != NULL, "`allocator` and `str` should not be NULL"); + wapp_debug_assert(allocator != NULL && str != NULL, "`allocator` and `str` should not be NULL"); - Str8 *output = NULL; + Str8 *output = NULL; - if (start >= str->size || start >= end) { - goto RETURN_ALLOC_SUBSTR; - } + if (start >= str->size || start >= end) { + goto RETURN_ALLOC_SUBSTR; + } - if (end > str->size) { - end = str->size; - } + if (end > str->size) { + end = str->size; + } - output = wapp_str8_alloc_buf(allocator, str->capacity); - if (!output) { - goto RETURN_ALLOC_SUBSTR; - } + output = wapp_str8_alloc_buf(allocator, str->capacity); + if (!output) { + goto RETURN_ALLOC_SUBSTR; + } - output->size = end - start; - memcpy(output->buf, str->buf + start, output->size); + output->size = end - start; + memcpy(output->buf, str->buf + start, output->size); RETURN_ALLOC_SUBSTR: - return output; + return output; } void wapp_str8_dealloc_buf(const Allocator *allocator, Str8 **str) { - wapp_debug_assert(allocator != NULL && str != NULL && (*str) != NULL, "Either `allocator` is NULL or `str` is an invalid double pointer"); - wapp_mem_allocator_free(allocator, (void **)str, STR8_BUF_ALLOC_SIZE((*str)->capacity)); + wapp_debug_assert(allocator != NULL && str != NULL && (*str) != NULL, "Either `allocator` is NULL or `str` is an invalid double pointer"); + wapp_mem_allocator_free(allocator, (void **)str, STR8_BUF_ALLOC_SIZE((*str)->capacity)); } c8 wapp_str8_get(const Str8 *str, u64 index) { - if (index >= str->size) { - return '\0'; - } + if (index >= str->size) { + return '\0'; + } - return str->buf[index]; + return str->buf[index]; } void wapp_str8_set(Str8 *str, u64 index, c8 c) { - if (index >= str->size) { - return; - } + if (index >= str->size) { + return; + } - str->buf[index] = c; + str->buf[index] = c; } void wapp_str8_push_back(Str8 *str, c8 c) { - if (!(str->size < str->capacity)) { - return; - } + if (!(str->size < str->capacity)) { + return; + } - u64 index = (str->size)++; - wapp_str8_set(str, index, c); + u64 index = (str->size)++; + wapp_str8_set(str, index, c); } b8 wapp_str8_equal(Str8RO *s1, Str8RO *s2) { - if (s1->size != s2->size) { - return false; - } + if (s1->size != s2->size) { + return false; + } - return wapp_str8_equal_to_count(s1, s2, s1->size); + return wapp_str8_equal_to_count(s1, s2, s1->size); } b8 wapp_str8_equal_to_count(Str8RO* s1, Str8RO* s2, u64 count) { - if (!s1 || !s2) { - return false; - } + if (!s1 || !s2) { + return false; + } - return memcmp(s1->buf, s2->buf, count) == 0; + return memcmp(s1->buf, s2->buf, count) == 0; } Str8 wapp_str8_slice(Str8RO *str, u64 start, u64 end) { - if (start >= str->size || start >= end) { - start = str->size; - end = str->size; - } + if (start >= str->size || start >= end) { + start = str->size; + end = str->size; + } - if (end > str->size) { - end = str->size; - } + if (end > str->size) { + end = str->size; + } - return (Str8RO){ - .capacity = end - start, - .size = end - start, - .buf = str->buf + start, - }; + return (Str8RO){ + .capacity = end - start, + .size = end - start, + .buf = str->buf + start, + }; } Str8 *wapp_str8_alloc_concat(const Allocator *allocator, Str8 *dst, Str8RO *src) { - wapp_debug_assert(allocator != NULL && dst != NULL && src != NULL, "`allocator`, `dst` and `src` should not be NULL"); + wapp_debug_assert(allocator != NULL && dst != NULL && src != NULL, "`allocator`, `dst` and `src` should not be NULL"); - Str8 *output = NULL; - u64 remaining = dst->capacity - dst->size; - if (src->size <= remaining) { - output = dst; - goto SOURCE_STRING_STR8_CONCAT; - } + Str8 *output = NULL; + u64 remaining = dst->capacity - dst->size; + if (src->size <= remaining) { + output = dst; + goto SOURCE_STRING_STR8_CONCAT; + } - u64 capacity = dst->capacity + src->size; + u64 capacity = dst->capacity + src->size; - output = wapp_str8_alloc_buf(allocator, capacity); - if (!output) { - goto RETURN_STR8_CONCAT; - } + output = wapp_str8_alloc_buf(allocator, capacity); + if (!output) { + goto RETURN_STR8_CONCAT; + } - wapp_str8_concat_capped(output, dst); + wapp_str8_concat_capped(output, dst); SOURCE_STRING_STR8_CONCAT: - wapp_str8_concat_capped(output, src); + wapp_str8_concat_capped(output, src); RETURN_STR8_CONCAT: - return output; + return output; } void wapp_str8_concat_capped(Str8 *dst, Str8RO *src) { - wapp_debug_assert(dst != NULL && src != NULL, "`dst` and `src` should not be NULL"); + wapp_debug_assert(dst != NULL && src != NULL, "`dst` and `src` should not be NULL"); - u64 remaining = dst->capacity - dst->size; - u64 to_copy = remaining < src->size ? remaining : src->size; + u64 remaining = dst->capacity - dst->size; + u64 to_copy = remaining < src->size ? remaining : src->size; - memcpy(dst->buf + dst->size, src->buf, to_copy); - dst->size += to_copy; + memcpy(dst->buf + dst->size, src->buf, to_copy); + dst->size += to_copy; } void wapp_str8_copy_cstr_capped(Str8 *dst, const char *src) { - wapp_debug_assert(dst != NULL && src != NULL, "`dst` and `src` should not be NULL"); + wapp_debug_assert(dst != NULL && src != NULL, "`dst` and `src` should not be NULL"); - u64 length = strlen(src); - u64 to_copy = length <= dst->capacity ? length : dst->capacity; + u64 length = strlen(src); + u64 to_copy = length <= dst->capacity ? length : dst->capacity; - memset(dst->buf, 0, dst->size); - memcpy(dst->buf, src, to_copy); - dst->size = to_copy; + memset(dst->buf, 0, dst->size); + memcpy(dst->buf, src, to_copy); + dst->size = to_copy; } void wapp_str8_copy_str8_capped(Str8 *dst, Str8RO *src) { - wapp_debug_assert(dst != NULL && src != NULL, "`dst` and `src` should not be NULL"); + wapp_debug_assert(dst != NULL && src != NULL, "`dst` and `src` should not be NULL"); - u64 to_copy = src->size <= dst->capacity ? src->size : dst->capacity; + u64 to_copy = src->size <= dst->capacity ? src->size : dst->capacity; - memset(dst->buf, 0, dst->size); - memcpy(dst->buf, src->buf, to_copy); - dst->size = to_copy; + memset(dst->buf, 0, dst->size); + memcpy(dst->buf, src->buf, to_copy); + dst->size = to_copy; } void wapp_str8_copy_to_cstr(char *dst, Str8RO *src, u64 dst_capacity) { - wapp_debug_assert(dst != NULL && src != NULL, "`dst` and `src` should not be NULL"); + wapp_debug_assert(dst != NULL && src != NULL, "`dst` and `src` should not be NULL"); - u64 to_copy = src->size < dst_capacity ? src->size : dst_capacity - 1; + u64 to_copy = src->size < dst_capacity ? src->size : dst_capacity - 1; - memset(dst, 0, dst_capacity); - memcpy(dst, src->buf, to_copy); + memset(dst, 0, dst_capacity); + memcpy(dst, src->buf, to_copy); } void wapp_str8_format(Str8 *dst, const char *format, ...) { - wapp_debug_assert(dst != NULL && format != NULL, "`dst` and `format` should not be NULL"); + wapp_debug_assert(dst != NULL && format != NULL, "`dst` and `format` should not be NULL"); - va_list args1; - va_list args2; + va_list args1; + va_list args2; - va_start(args1, format); - va_copy(args2, args1); + va_start(args1, format); + va_copy(args2, args1); - u64 total_size = vsnprintf(NULL, 0, format, args1); - dst->size = total_size <= dst->capacity ? total_size : dst->capacity; + u64 total_size = vsnprintf(NULL, 0, format, args1); + dst->size = total_size <= dst->capacity ? total_size : dst->capacity; - vsnprintf((char *)(dst->buf), dst->capacity, format, args2); + vsnprintf((char *)(dst->buf), dst->capacity, format, args2); - va_end(args1); - va_end(args2); + va_end(args1); + 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"); + 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; + dst->size = src->size; - // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of - // MSVC Spectre mitigation warnings - u64 index = 0; - b8 running = true; - while (running) { - wapp_str8_set(dst, index, (u8)tolower(wapp_str8_get(src, index))); - ++index; - running = index < src->size; - } + // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of + // MSVC Spectre mitigation warnings + u64 index = 0; + b8 running = true; + while (running) { + wapp_str8_set(dst, index, (u8)tolower(wapp_str8_get(src, index))); + ++index; + running = index < src->size; + } } 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"); + 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; + dst->size = src->size; - // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of - // MSVC Spectre mitigation warnings - u64 index = 0; - b8 running = true; - while (running) { - wapp_str8_set(dst, index, (u8)toupper(wapp_str8_get(src, index))); - ++index; - running = index < src->size; - } + // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of + // MSVC Spectre mitigation warnings + u64 index = 0; + b8 running = true; + while (running) { + wapp_str8_set(dst, index, (u8)toupper(wapp_str8_get(src, index))); + ++index; + running = index < src->size; + } } void wapp_str8_from_bytes(Str8 *dst, const U8Array *src) { - wapp_debug_assert(src != NULL && dst != NULL, "`dst` and `src` should not be NULL"); + wapp_debug_assert(src != NULL && dst != NULL, "`dst` and `src` should not be NULL"); - u64 size = src->count * src->item_size; + u64 size = src->count * src->item_size; - wapp_debug_assert(dst->capacity >= size, "`dst` does not have enough capacity"); + wapp_debug_assert(dst->capacity >= size, "`dst` does not have enough capacity"); - dst->size = size; - memcpy(dst->buf, src->items, size); + 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; - } + if (!str || substr.size > str->size) { + return -1; + } - // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of - // MSVC Spectre mitigation warnings - u64 char_index = 0; - b8 running = char_index < str->size; - while (running) { - const c8 *sub = str->buf + char_index; - if (memcmp(sub, substr.buf, substr.size) == 0) { - return char_index; - } + // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of + // MSVC Spectre mitigation warnings + u64 char_index = 0; + b8 running = char_index < str->size; + while (running) { + const c8 *sub = str->buf + char_index; + if (memcmp(sub, substr.buf, substr.size) == 0) { + return char_index; + } - ++char_index; - running = char_index < str->size; - } + ++char_index; + running = char_index < str->size; + } - return -1; + return -1; } i64 wapp_str8_rfind(Str8RO *str, Str8RO substr) { - if (!str || substr.size > str->size) { - return -1; - } + if (!str || substr.size > str->size) { + return -1; + } - // 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; - b8 running = char_index >= 0; - while (running) { - const c8 *sub = str->buf + char_index; - if (memcmp(sub, substr.buf, substr.size) == 0) { - return char_index; - } + // 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; + b8 running = char_index >= 0; + while (running) { + const c8 *sub = str->buf + char_index; + if (memcmp(sub, substr.buf, substr.size) == 0) { + return char_index; + } - --char_index; - running = char_index >= 0; - } + --char_index; + running = char_index >= 0; + } - return -1; + return -1; } Str8List *wapp_str8_split_with_max(const Allocator *allocator, Str8RO *str, Str8RO *delimiter, i64 max_splits) { - wapp_debug_assert(allocator != NULL && str != NULL && delimiter != NULL, "`allocator`, `str` and `delimiter` should not be NULL"); + wapp_debug_assert(allocator != NULL && str != NULL && delimiter != NULL, "`allocator`, `str` and `delimiter` should not be NULL"); - Str8List *output = wapp_dbl_list_alloc(Str8, Str8List, allocator); + Str8List *output = wapp_dbl_list_alloc(Str8, Str8List, allocator); - if (delimiter->size > str->size) { - Str8 *full = wapp_str8_alloc_str8(allocator, str); - Str8Node *node = wapp_dbl_list_node_alloc(Str8, Str8Node, allocator); - if (node) { - node->item = full; - wapp_dbl_list_push_back(Str8, output, node); - } + if (delimiter->size > str->size) { + Str8 *full = wapp_str8_alloc_str8(allocator, str); + Str8Node *node = wapp_dbl_list_node_alloc(Str8, Str8Node, allocator); + if (node) { + node->item = full; + wapp_dbl_list_push_back(Str8, output, node); + } - goto RETURN_STR8_SPLIT; - } + goto RETURN_STR8_SPLIT; + } - i64 start = 0; - i64 end = 0; - i64 splits = 0; - Str8 *rest = wapp_str8_alloc_str8(allocator, str); - Str8 *before_str; + i64 start = 0; + i64 end = 0; + i64 splits = 0; + Str8 *rest = wapp_str8_alloc_str8(allocator, str); + Str8 *before_str; - while ((end = wapp_str8_find(rest, *delimiter)) != -1) { - if (max_splits > 0 && splits >= max_splits) { - break; - } + while ((end = wapp_str8_find(rest, *delimiter)) != -1) { + if (max_splits > 0 && splits >= max_splits) { + break; + } - before_str = wapp_str8_alloc_substr(allocator, str, start, start + end); - Str8Node *node = wapp_dbl_list_node_alloc(Str8, Str8Node, allocator); - if (node && before_str) { - node->item = before_str; - wapp_dbl_list_push_back(Str8, output, node); - } + before_str = wapp_str8_alloc_substr(allocator, str, start, start + end); + Str8Node *node = wapp_dbl_list_node_alloc(Str8, Str8Node, allocator); + if (node && before_str) { + node->item = before_str; + wapp_dbl_list_push_back(Str8, output, node); + } - wapp_mem_allocator_free(allocator, (void **)&rest, sizeof(Str8)); - rest = wapp_str8_alloc_substr(allocator, str, start + end + delimiter->size, str->size); - start += end + delimiter->size; + wapp_mem_allocator_free(allocator, (void **)&rest, sizeof(Str8)); + rest = wapp_str8_alloc_substr(allocator, str, start + end + delimiter->size, str->size); + start += end + delimiter->size; - ++splits; - } + ++splits; + } - // Ensure the last part of the string after the delimiter is added to the list - rest = wapp_str8_alloc_substr(allocator, str, start, str->size); - Str8Node *node = wapp_dbl_list_node_alloc(Str8, Str8Node, allocator); - if (node && rest) { - node->item = rest; - wapp_dbl_list_push_back(Str8, output, node); - } + // Ensure the last part of the string after the delimiter is added to the list + rest = wapp_str8_alloc_substr(allocator, str, start, str->size); + Str8Node *node = wapp_dbl_list_node_alloc(Str8, Str8Node, allocator); + if (node && rest) { + node->item = rest; + wapp_dbl_list_push_back(Str8, output, node); + } RETURN_STR8_SPLIT: - return output; + return output; } Str8List *wapp_str8_rsplit_with_max(const Allocator *allocator, Str8RO *str, Str8RO *delimiter, i64 max_splits) { - wapp_debug_assert(allocator != NULL && str != NULL && delimiter != NULL, "`allocator`, `str` and `delimiter` should not be NULL"); + wapp_debug_assert(allocator != NULL && str != NULL && delimiter != NULL, "`allocator`, `str` and `delimiter` should not be NULL"); - Str8List *output = wapp_dbl_list_alloc(Str8, Str8List, allocator); + Str8List *output = wapp_dbl_list_alloc(Str8, Str8List, allocator); - if (delimiter->size > str->size) { - Str8 *full = wapp_str8_alloc_str8(allocator, str); - Str8Node *node = wapp_dbl_list_node_alloc(Str8, Str8Node, allocator); - if (node && full) { - node->item = full; - wapp_dbl_list_push_back(Str8, output, node); - } + if (delimiter->size > str->size) { + Str8 *full = wapp_str8_alloc_str8(allocator, str); + Str8Node *node = wapp_dbl_list_node_alloc(Str8, Str8Node, allocator); + if (node && full) { + node->item = full; + wapp_dbl_list_push_back(Str8, output, node); + } - goto RETURN_STR8_SPLIT; - } + goto RETURN_STR8_SPLIT; + } - i64 end = 0; - i64 splits = 0; - Str8 *rest = wapp_str8_alloc_str8(allocator, str); - Str8 *after_str; + i64 end = 0; + i64 splits = 0; + Str8 *rest = wapp_str8_alloc_str8(allocator, str); + Str8 *after_str; - while ((end = wapp_str8_rfind(rest, *delimiter)) != -1) { - if (max_splits > 0 && splits >= max_splits) { - break; - } + while ((end = wapp_str8_rfind(rest, *delimiter)) != -1) { + if (max_splits > 0 && splits >= max_splits) { + break; + } - after_str = wapp_str8_alloc_substr(allocator, rest, end + delimiter->size, str->size); - Str8Node *node = wapp_dbl_list_node_alloc(Str8, Str8Node, allocator); - if (node) { - node->item = after_str; - wapp_dbl_list_push_front(Str8, output, node); - } + after_str = wapp_str8_alloc_substr(allocator, rest, end + delimiter->size, str->size); + Str8Node *node = wapp_dbl_list_node_alloc(Str8, Str8Node, allocator); + if (node) { + node->item = after_str; + wapp_dbl_list_push_front(Str8, output, node); + } - wapp_mem_allocator_free(allocator, (void **)&rest, sizeof(Str8)); - rest = wapp_str8_alloc_substr(allocator, rest, 0, end); + wapp_mem_allocator_free(allocator, (void **)&rest, sizeof(Str8)); + rest = wapp_str8_alloc_substr(allocator, rest, 0, end); - ++splits; - } + ++splits; + } - rest = wapp_str8_alloc_substr(allocator, str, 0, rest->size); - Str8Node *node = wapp_dbl_list_node_alloc(Str8, Str8Node, allocator); - if (node && rest) { - node->item = rest; - wapp_dbl_list_push_front(Str8, output, node); - } + rest = wapp_str8_alloc_substr(allocator, str, 0, rest->size); + Str8Node *node = wapp_dbl_list_node_alloc(Str8, Str8Node, allocator); + if (node && rest) { + node->item = rest; + wapp_dbl_list_push_front(Str8, output, node); + } RETURN_STR8_SPLIT: - return output; + return output; } Str8 *wapp_str8_join(const Allocator *allocator, const Str8List *list, Str8RO *delimiter) { - wapp_debug_assert(allocator != NULL && list != NULL && delimiter != NULL, "`allocator`, `list` and `delimiter` should not be NULL"); + wapp_debug_assert(allocator != NULL && list != NULL && delimiter != NULL, "`allocator`, `list` and `delimiter` should not be NULL"); - u64 capacity = wapp_str8_list_total_size(list) + (delimiter->size * (list->node_count - 1)); - Str8 *output = wapp_str8_alloc_buf(allocator, capacity * 2); + u64 capacity = wapp_str8_list_total_size(list) + (delimiter->size * (list->node_count - 1)); + Str8 *output = wapp_str8_alloc_buf(allocator, capacity * 2); - // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of - // MSVC Spectre mitigation warnings - Str8Node *node; - u64 node_index = 0; - b8 running = node_index < list->node_count; - while (running) { - node = wapp_dbl_list_get(Str8, Str8Node, list, node_index); - if (!node) { - break; - } + // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of + // MSVC Spectre mitigation warnings + Str8Node *node; + u64 node_index = 0; + b8 running = node_index < list->node_count; + while (running) { + node = wapp_dbl_list_get(Str8, Str8Node, list, node_index); + if (!node) { + break; + } - wapp_str8_concat_capped(output, node->item); + wapp_str8_concat_capped(output, node->item); - // NOTE (Abdelrahman): Comparison extracted to variable to silence - // MSVC Spectre mitigation warnings - b8 not_last = node_index + 1 < list->node_count; - if (not_last) { - wapp_str8_concat_capped(output, delimiter); - } + // NOTE (Abdelrahman): Comparison extracted to variable to silence + // MSVC Spectre mitigation warnings + b8 not_last = node_index + 1 < list->node_count; + if (not_last) { + wapp_str8_concat_capped(output, delimiter); + } - ++node_index; - running = node_index < list->node_count; - } + ++node_index; + running = node_index < list->node_count; + } - return output; + return output; } u64 wapp_str8_list_total_size(const Str8List *list) { - if (!list) { - return 0; - } + if (!list) { + return 0; + } - // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of - // MSVC Spectre mitigation warnings - Str8Node* node; - u64 node_index = 0; - u64 output = 0; - b8 running = node_index < list->node_count; - while (running) { - node = wapp_dbl_list_get(Str8, Str8Node, list, node_index); - if (!node) { - break; - } + // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of + // MSVC Spectre mitigation warnings + Str8Node* node; + u64 node_index = 0; + u64 output = 0; + b8 running = node_index < list->node_count; + while (running) { + node = wapp_dbl_list_get(Str8, Str8Node, list, node_index); + if (!node) { + break; + } - output += node->item->size; - ++node_index; - running = node_index < list->node_count; - } + output += node->item->size; + ++node_index; + running = node_index < list->node_count; + } - return output; + return output; } diff --git a/src/base/strings/str8/str8.h b/src/base/strings/str8/str8.h index 269b485..fb05756 100644 --- a/src/base/strings/str8/str8.h +++ b/src/base/strings/str8/str8.h @@ -17,9 +17,9 @@ BEGIN_C_LINKAGE typedef struct str8 Str8; struct str8 { - u64 capacity; - u64 size; - c8 *buf; + u64 capacity; + u64 size; + c8 *buf; }; typedef const Str8 Str8RO; @@ -36,17 +36,17 @@ typedef const Str8 Str8RO; #ifdef WAPP_PLATFORM_CPP // Uses a lambda to achieve the same behaviour achieved by the C macro -#define wapp_str8_buf(CAPACITY) ([&](){ \ - wapp_persist c8 buf[CAPACITY] = {}; \ - memset(buf, 0, CAPACITY); \ - return Str8{CAPACITY, 0, buf}; \ +#define wapp_str8_buf(CAPACITY) ([&](){ \ + wapp_persist c8 buf[CAPACITY] = {}; \ + memset(buf, 0, CAPACITY); \ + return Str8{CAPACITY, 0, buf}; \ }()) // Uses a lambda to achieve the same behaviour achieved by the C macro -#define wapp_str8_lit(STRING) ([&]() { \ - wapp_persist c8 buf[sizeof(STRING) * 2] = {}; \ - memcpy(buf, STRING, sizeof(STRING)); \ - return Str8{(sizeof(STRING) - 1) * 2, sizeof(STRING) - 1, buf}; \ +#define wapp_str8_lit(STRING) ([&]() { \ + wapp_persist c8 buf[sizeof(STRING) * 2] = {}; \ + memcpy(buf, STRING, sizeof(STRING)); \ + return Str8{(sizeof(STRING) - 1) * 2, sizeof(STRING) - 1, buf}; \ }()) #define wapp_str8_lit_ro(STRING) Str8RO{sizeof(STRING) - 1, sizeof(STRING) - 1, (c8 *)STRING} @@ -56,29 +56,29 @@ typedef const Str8 Str8RO; // Utilises the fact that memcpy returns pointer to dest buffer and that getting // address of compound literals is valid in C to create a string on the stack -#define wapp_str8_lit(STRING) ((Str8){.capacity = (sizeof(STRING) - 1) * 2, \ - .size = sizeof(STRING) - 1, \ - .buf = memcpy(&((c8 [sizeof(STRING) * 2]){0}), STRING, sizeof(STRING))}) -#define wapp_str8_lit_ro(STRING) ((Str8RO){.capacity = sizeof(STRING) - 1, \ - .size = sizeof(STRING) - 1, \ - .buf = (c8 *)STRING}) +#define wapp_str8_lit(STRING) ((Str8){.capacity = (sizeof(STRING) - 1) * 2, \ + .size = sizeof(STRING) - 1, \ + .buf = memcpy(&((c8 [sizeof(STRING) * 2]){0}), STRING, sizeof(STRING))}) +#define wapp_str8_lit_ro(STRING) ((Str8RO){.capacity = sizeof(STRING) - 1, \ + .size = sizeof(STRING) - 1, \ + .buf = (c8 *)STRING}) // To be used only when initialising a static storage variable in compilers that don't support // initialisers with the syntax of wapp_str8_lit_ro (e.g. gcc). Should only be used when necessary // and only be assigned to a Str8RO variable to avoid any attempt at modifying the string -#define wapp_str8_lit_ro_initialiser_list(STRING) {.capacity = sizeof(STRING) - 1, \ - .size = sizeof(STRING) - 1, \ - .buf = (c8 *)STRING} +#define wapp_str8_lit_ro_initialiser_list(STRING) {.capacity = sizeof(STRING) - 1, \ + .size = sizeof(STRING) - 1, \ + .buf = (c8 *)STRING} #endif // !WAPP_PLATFORM_CPP /** * Str8 allocated buffers */ -Str8 *wapp_str8_alloc_buf(const Allocator *allocator, u64 capacity); -Str8 *wapp_str8_alloc_and_fill_buf(const Allocator *allocator, u64 capacity); -Str8 *wapp_str8_alloc_cstr(const Allocator *allocator, const char *str); -Str8 *wapp_str8_alloc_str8(const Allocator *allocator, Str8RO *str); -Str8 *wapp_str8_alloc_substr(const Allocator *allocator, Str8RO *str, u64 start, u64 end); -Str8 *wapp_str8_alloc_concat(const Allocator *allocator, Str8 *dst, Str8RO *src); +Str8 *wapp_str8_alloc_buf(const Allocator *allocator, u64 capacity); +Str8 *wapp_str8_alloc_and_fill_buf(const Allocator *allocator, u64 capacity); +Str8 *wapp_str8_alloc_cstr(const Allocator *allocator, const char *str); +Str8 *wapp_str8_alloc_str8(const Allocator *allocator, Str8RO *str); +Str8 *wapp_str8_alloc_substr(const Allocator *allocator, Str8RO *str, u64 start, u64 end); +Str8 *wapp_str8_alloc_concat(const Allocator *allocator, Str8 *dst, Str8RO *src); // Only needed for allocators like malloc where each allocation has to be freed on its own. // No need to use it for allocators like Arena. void wapp_str8_dealloc_buf(const Allocator *allocator, Str8 **str); @@ -86,20 +86,20 @@ void wapp_str8_dealloc_buf(const Allocator *allocator, Str8 **str); /** * Str8 utilities */ -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); -b8 wapp_str8_equal(Str8RO *s1, Str8RO *s2); -b8 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); +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); +b8 wapp_str8_equal(Str8RO *s1, Str8RO *s2); +b8 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 @@ -112,9 +112,9 @@ i64 wapp_str8_rfind(Str8RO *str, Str8RO substr); */ #define wapp_str8_split(ALLOCATOR, STR, DELIMITER) wapp_str8_split_with_max(ALLOCATOR, STR, DELIMITER, -1) #define wapp_str8_rsplit(ALLOCATOR, STR, DELIMITER) wapp_str8_rsplit_with_max(ALLOCATOR, STR, DELIMITER, -1) -Str8List *wapp_str8_split_with_max(const Allocator *allocator, Str8RO *str, Str8RO *delimiter, i64 max_splits); -Str8List *wapp_str8_rsplit_with_max(const Allocator *allocator, Str8RO *str, Str8RO *delimiter, i64 max_splits); -Str8 *wapp_str8_join(const Allocator *allocator, const Str8List *list, Str8RO *delimiter); +Str8List *wapp_str8_split_with_max(const Allocator *allocator, Str8RO *str, Str8RO *delimiter, i64 max_splits); +Str8List *wapp_str8_rsplit_with_max(const Allocator *allocator, Str8RO *str, Str8RO *delimiter, i64 max_splits); +Str8 *wapp_str8_join(const Allocator *allocator, const Str8List *list, Str8RO *delimiter); /** * Str8 list utilities @@ -128,18 +128,18 @@ END_C_LINKAGE template constexpr bool is_lvalue(T&&) { - return std::is_lvalue_reference{}; + return std::is_lvalue_reference{}; } -#define wapp_str8_node_from_cstr(STRING) wapp_dbl_list_node(Str8, Str8Node, [&]() { \ - wapp_persist Str8 str = wapp_str8_lit(STRING); \ - return &str; \ +#define wapp_str8_node_from_cstr(STRING) wapp_dbl_list_node(Str8, Str8Node, [&]() { \ + wapp_persist Str8 str = wapp_str8_lit(STRING); \ + return &str; \ }()) -#define wapp_str8_node_from_str8(STRING) wapp_dbl_list_node(Str8, Str8Node, [&]() { \ - if (is_lvalue(STRING)) { return &STRING; } \ - \ - wapp_persist Str8 str = STRING; \ - return &str; \ +#define wapp_str8_node_from_str8(STRING) wapp_dbl_list_node(Str8, Str8Node, [&]() { \ + if (is_lvalue(STRING)) { return &STRING; } \ + \ + wapp_persist Str8 str = STRING; \ + return &str; \ }()) #else #define wapp_str8_node_from_cstr(STRING) wapp_dbl_list_node(Str8, Str8Node, &wapp_str8_lit(STRING)) -- 2.39.5 From ed72ccc139fcc8bc12a4530f6baa2ac4eee76c28 Mon Sep 17 00:00:00 2001 From: Abdelrahman Said Date: Mon, 29 Dec 2025 21:41:04 +0000 Subject: [PATCH 3/9] Reformat common --- src/common/aliases/aliases.h | 22 ++--- src/common/assert/assert.h | 46 ++++----- src/common/misc/misc_utils.h | 52 +++++----- src/common/platform/platform.h | 170 ++++++++++++++++----------------- 4 files changed, 145 insertions(+), 145 deletions(-) diff --git a/src/common/aliases/aliases.h b/src/common/aliases/aliases.h index a09467a..f51bac1 100644 --- a/src/common/aliases/aliases.h +++ b/src/common/aliases/aliases.h @@ -7,20 +7,20 @@ #include #if defined(WAPP_PLATFORM_C) && WAPP_PLATFORM_C_VERSION >= WAPP_PLATFORM_C11_VERSION && !defined(WAPP_PLATFORM_APPLE) - #include + #include - #if WAPP_PLATFORM_C_VERSION >= WAPP_PLATFORM_C23_VERSION - #define c8 char8_t - #else - #define c8 uint8_t - #endif // !WAPP_PLATFORM_C23_VERSION + #if WAPP_PLATFORM_C_VERSION >= WAPP_PLATFORM_C23_VERSION + #define c8 char8_t + #else + #define c8 uint8_t + #endif // !WAPP_PLATFORM_C23_VERSION - #define c16 char16_t - #define c32 char32_t + #define c16 char16_t + #define c32 char32_t #else - #define c8 uint8_t - #define c16 uint16_t - #define c32 uint32_t + #define c8 uint8_t + #define c16 uint16_t + #define c32 uint32_t #endif // !WAPP_PLATFORM_C #define u8 uint8_t diff --git a/src/common/assert/assert.h b/src/common/assert/assert.h index 67d7dbd..9e82e4e 100644 --- a/src/common/assert/assert.h +++ b/src/common/assert/assert.h @@ -16,42 +16,42 @@ BEGIN_C_LINKAGE #define wapp_static_assert(EXPR, MSG) extern char ASSERTION_FAILED[EXPR ? 1 : -1] #ifndef WAPP_NO_RUNTIME_ASSERT - #define wapp_runtime_assert(EXPR, MSG) __wapp_runtime_assert(EXPR, MSG) + #define wapp_runtime_assert(EXPR, MSG) __wapp_runtime_assert(EXPR, MSG) #else - #define wapp_runtime_assert(EXPR, MSG) + #define wapp_runtime_assert(EXPR, MSG) #endif #ifdef WAPP_DEBUG_ASSERT - #define wapp_debug_assert(EXPR, MSG) wapp_runtime_assert(EXPR, MSG) + #define wapp_debug_assert(EXPR, MSG) wapp_runtime_assert(EXPR, MSG) #else - #define wapp_debug_assert(EXPR, MSG) + #define wapp_debug_assert(EXPR, MSG) #endif #ifdef WAPP_PLATFORM_WINDOWS -#define __wapp_runtime_assert(EXPR, MSG) do { \ - __pragma(warning(push)) \ - __pragma(warning(disable:4127)) \ - if (!(EXPR)) { \ - __pragma(warning(pop)) \ - __runtime_assert_failed(EXPR, MSG); \ - } \ +#define __wapp_runtime_assert(EXPR, MSG) do { \ + __pragma(warning(push)) \ + __pragma(warning(disable:4127)) \ + if (!(EXPR)) { \ + __pragma(warning(pop)) \ + __runtime_assert_failed(EXPR, MSG); \ + } \ } while(false) #else -#define __wapp_runtime_assert(EXPR, MSG) do { \ - if (!(EXPR)) { \ - __runtime_assert_failed(EXPR, MSG); \ - } \ +#define __wapp_runtime_assert(EXPR, MSG) do { \ + if (!(EXPR)) { \ + __runtime_assert_failed(EXPR, MSG); \ + } \ } while(false) #endif // !WAPP_PLATFORM_WINDOWS -#define __runtime_assert_failed(EXPR, MSG) do { \ - fprintf( \ - stderr, \ - "%s:%d (In function `%s`): Assertion failed (%" PRIu32 ")\nDiagnostic: %s\n\n", \ - __FILE__, __LINE__, __func__, \ - EXPR, MSG \ - ); \ - abort(); \ +#define __runtime_assert_failed(EXPR, MSG) do { \ + fprintf( \ + stderr, \ + "%s:%d (In function `%s`): Assertion failed (%" PRIu32 ")\nDiagnostic: %s\n\n", \ + __FILE__, __LINE__, __func__, \ + EXPR, MSG \ + ); \ + abort(); \ } while(false) #ifdef WAPP_PLATFORM_CPP diff --git a/src/common/misc/misc_utils.h b/src/common/misc/misc_utils.h index 482699f..ebe105f 100644 --- a/src/common/misc/misc_utils.h +++ b/src/common/misc/misc_utils.h @@ -16,35 +16,35 @@ BEGIN_C_LINKAGE #define PiB(SIZE) (((u64)SIZE) << 50) #define EiB(SIZE) (((u64)SIZE) << 60) -#define KB(SIZE) (((u64)SIZE) * 1000llu) -#define MB(SIZE) (KB(SIZE) * 1000llu) -#define GB(SIZE) (MB(SIZE) * 1000llu) -#define TB(SIZE) (GB(SIZE) * 1000llu) -#define PB(SIZE) (TB(SIZE) * 1000llu) -#define EB(SIZE) (PB(SIZE) * 1000llu) +#define KB(SIZE) (((u64)SIZE) * 1000llu) +#define MB(SIZE) (KB(SIZE) * 1000llu) +#define GB(SIZE) (MB(SIZE) * 1000llu) +#define TB(SIZE) (GB(SIZE) * 1000llu) +#define PB(SIZE) (TB(SIZE) * 1000llu) +#define EB(SIZE) (PB(SIZE) * 1000llu) #define wapp_misc_utils_padding_size(SIZE) u8 reserved_padding[sizeof(void *) - ((SIZE) % sizeof(void *))] -#define U64_RSHIFT_OR_1(X) (((u64)X) | (((u64)X) >> 1)) -#define U64_RSHIFT_OR_2(X) (((u64)X) | (((u64)X) >> 2)) -#define U64_RSHIFT_OR_4(X) (((u64)X) | (((u64)X) >> 4)) -#define U64_RSHIFT_OR_8(X) (((u64)X) | (((u64)X) >> 8)) -#define U64_RSHIFT_OR_16(X) (((u64)X) | (((u64)X) >> 16)) -#define U64_RSHIFT_OR_32(X) (((u64)X) | (((u64)X) >> 32)) -#define wapp_misc_utils_u64_round_up_pow2(X) ( \ - ( \ - U64_RSHIFT_OR_32( \ - U64_RSHIFT_OR_16( \ - U64_RSHIFT_OR_8( \ - U64_RSHIFT_OR_4( \ - U64_RSHIFT_OR_2( \ - U64_RSHIFT_OR_1(X - 1) \ - ) \ - ) \ - ) \ - ) \ - ) \ - ) + 1 \ +#define U64_RSHIFT_OR_1(X) (((u64)X) | (((u64)X) >> 1)) +#define U64_RSHIFT_OR_2(X) (((u64)X) | (((u64)X) >> 2)) +#define U64_RSHIFT_OR_4(X) (((u64)X) | (((u64)X) >> 4)) +#define U64_RSHIFT_OR_8(X) (((u64)X) | (((u64)X) >> 8)) +#define U64_RSHIFT_OR_16(X) (((u64)X) | (((u64)X) >> 16)) +#define U64_RSHIFT_OR_32(X) (((u64)X) | (((u64)X) >> 32)) +#define wapp_misc_utils_u64_round_up_pow2(X) ( \ + ( \ + U64_RSHIFT_OR_32( \ + U64_RSHIFT_OR_16( \ + U64_RSHIFT_OR_8( \ + U64_RSHIFT_OR_4( \ + U64_RSHIFT_OR_2( \ + U64_RSHIFT_OR_1(X - 1) \ + ) \ + ) \ + ) \ + ) \ + ) \ + ) + 1 \ ) #ifdef WAPP_PLATFORM_CPP diff --git a/src/common/platform/platform.h b/src/common/platform/platform.h index 9891f86..907b696 100644 --- a/src/common/platform/platform.h +++ b/src/common/platform/platform.h @@ -4,111 +4,111 @@ #define PLATFORM_H #if defined(__ANDROID__) - #define WAPP_PLATFORM_ANDROID - #define WAPP_PLATFORM_POSIX + #define WAPP_PLATFORM_ANDROID + #define WAPP_PLATFORM_POSIX #elif defined(__FreeBSD__) - #define WAPP_PLATFORM_FREE_BSD - #define WAPP_PLATFORM_BSD - #define WAPP_PLATFORM_POSIX + #define WAPP_PLATFORM_FREE_BSD + #define WAPP_PLATFORM_BSD + #define WAPP_PLATFORM_POSIX #elif defined(__NetBSD__) - #define WAPP_PLATFORM_NET_BSD - #define WAPP_PLATFORM_BSD - #define WAPP_PLATFORM_POSIX + #define WAPP_PLATFORM_NET_BSD + #define WAPP_PLATFORM_BSD + #define WAPP_PLATFORM_POSIX #elif defined(__OpenBSD__) - #define WAPP_PLATFORM_OPEN_BSD - #define WAPP_PLATFORM_BSD - #define WAPP_PLATFORM_POSIX + #define WAPP_PLATFORM_OPEN_BSD + #define WAPP_PLATFORM_BSD + #define WAPP_PLATFORM_POSIX #elif defined(__DragonFly__) - #define WAPP_PLATFORM_DRAGON_FLY - #define WAPP_PLATFORM_BSD - #define WAPP_PLATFORM_POSIX + #define WAPP_PLATFORM_DRAGON_FLY + #define WAPP_PLATFORM_BSD + #define WAPP_PLATFORM_POSIX #elif defined(__bsdi__) - #define WAPP_PLATFORM_BSD - #define WAPP_PLATFORM_POSIX + #define WAPP_PLATFORM_BSD + #define WAPP_PLATFORM_POSIX #elif defined(__linux__) || defined(linux) || defined(__linux) || defined(__gnu_linux__) - #define WAPP_PLATFORM_LINUX - #define WAPP_PLATFORM_POSIX + #define WAPP_PLATFORM_LINUX + #define WAPP_PLATFORM_POSIX #elif defined(__GNU__) || defined(__gnu_hurd__) - #define WAPP_PLATFORM_GNU - #define WAPP_PLATFORM_POSIX + #define WAPP_PLATFORM_GNU + #define WAPP_PLATFORM_POSIX #elif defined(__APPLE__) || defined(__MACH__) - #include - #if TARGET_OS_IPHONE - #define WAPP_PLATFORM_IOS - #define WAPP_PLATFORM_APPLE - #define WAPP_PLATFORM_POSIX - #elif TARGET_OS_MAC - #define WAPP_PLATFORM_MACOS - #define WAPP_PLATFORM_APPLE - #define WAPP_PLATFORM_POSIX - #else - #error "Unrecognised Apple platform" - #endif + #include + #if TARGET_OS_IPHONE + #define WAPP_PLATFORM_IOS + #define WAPP_PLATFORM_APPLE + #define WAPP_PLATFORM_POSIX + #elif TARGET_OS_MAC + #define WAPP_PLATFORM_MACOS + #define WAPP_PLATFORM_APPLE + #define WAPP_PLATFORM_POSIX + #else + #error "Unrecognised Apple platform" + #endif #elif defined(_WIN64) - #define WAPP_PLATFORM_WINDOWS64 - #define WAPP_PLATFORM_WINDOWS + #define WAPP_PLATFORM_WINDOWS64 + #define WAPP_PLATFORM_WINDOWS #elif defined(_WIN32) - #define WAPP_PLATFORM_WINDOWS32 - #define WAPP_PLATFORM_WINDOWS + #define WAPP_PLATFORM_WINDOWS32 + #define WAPP_PLATFORM_WINDOWS #elif defined(__CYGWIN__) - #define WAPP_PLATFORM_CYGWIN - #define WAPP_PLATFORM_WINDOWS + #define WAPP_PLATFORM_CYGWIN + #define WAPP_PLATFORM_WINDOWS #elif defined(__unix__) || defined(__unix) - #define WAPP_PLATFORM_UNIX - #define WAPP_PLATFORM_POSIX + #define WAPP_PLATFORM_UNIX + #define WAPP_PLATFORM_POSIX #else - #error "Unrecognised platform" + #error "Unrecognised platform" #endif #ifdef __cplusplus - #define WAPP_PLATFORM_CPP - #define WAPP_PLATFORM_CPP_VERSION __cplusplus - #define WAPP_PLATFORM_CPP98_VERSION 199711L - #define WAPP_PLATFORM_CPP11_VERSION 201103L - #define WAPP_PLATFORM_CPP14_VERSION 201402L - #define WAPP_PLATFORM_CPP17_VERSION 201703L - #define WAPP_PLATFORM_CPP20_VERSION 202002L - #define WAPP_PLATFORM_CPP23_VERSION 202302L + #define WAPP_PLATFORM_CPP + #define WAPP_PLATFORM_CPP_VERSION __cplusplus + #define WAPP_PLATFORM_CPP98_VERSION 199711L + #define WAPP_PLATFORM_CPP11_VERSION 201103L + #define WAPP_PLATFORM_CPP14_VERSION 201402L + #define WAPP_PLATFORM_CPP17_VERSION 201703L + #define WAPP_PLATFORM_CPP20_VERSION 202002L + #define WAPP_PLATFORM_CPP23_VERSION 202302L - #if WAPP_PLATFORM_CPP_VERSION == WAPP_PLATFORM_CPP98_VERSION - #define WAPP_PLATFORM_CPP98 - #elif WAPP_PLATFORM_CPP_VERSION == WAPP_PLATFORM_CPP11_VERSION - #define WAPP_PLATFORM_CPP11 - #elif WAPP_PLATFORM_CPP_VERSION == WAPP_PLATFORM_CPP14_VERSION - #define WAPP_PLATFORM_CPP14 - #elif WAPP_PLATFORM_CPP_VERSION == WAPP_PLATFORM_CPP17_VERSION - #define WAPP_PLATFORM_CPP17 - #elif WAPP_PLATFORM_CPP_VERSION == WAPP_PLATFORM_CPP20_VERSION - #define WAPP_PLATFORM_CPP20 - #elif WAPP_PLATFORM_CPP_VERSION == WAPP_PLATFORM_CPP23_VERSION - #define WAPP_PLATFORM_CPP23 - #else - #error "Unrecognised C++ version" - #endif + #if WAPP_PLATFORM_CPP_VERSION == WAPP_PLATFORM_CPP98_VERSION + #define WAPP_PLATFORM_CPP98 + #elif WAPP_PLATFORM_CPP_VERSION == WAPP_PLATFORM_CPP11_VERSION + #define WAPP_PLATFORM_CPP11 + #elif WAPP_PLATFORM_CPP_VERSION == WAPP_PLATFORM_CPP14_VERSION + #define WAPP_PLATFORM_CPP14 + #elif WAPP_PLATFORM_CPP_VERSION == WAPP_PLATFORM_CPP17_VERSION + #define WAPP_PLATFORM_CPP17 + #elif WAPP_PLATFORM_CPP_VERSION == WAPP_PLATFORM_CPP20_VERSION + #define WAPP_PLATFORM_CPP20 + #elif WAPP_PLATFORM_CPP_VERSION == WAPP_PLATFORM_CPP23_VERSION + #define WAPP_PLATFORM_CPP23 + #else + #error "Unrecognised C++ version" + #endif #else - #define WAPP_PLATFORM_C + #define WAPP_PLATFORM_C - #if defined(__STDC_VERSION__) - #define WAPP_PLATFORM_C_VERSION __STDC_VERSION__ - #define WAPP_PLATFORM_C99_VERSION 199901L - #define WAPP_PLATFORM_C11_VERSION 201112L - #define WAPP_PLATFORM_C17_VERSION 201710L - #define WAPP_PLATFORM_C23_VERSION 202311L + #if defined(__STDC_VERSION__) + #define WAPP_PLATFORM_C_VERSION __STDC_VERSION__ + #define WAPP_PLATFORM_C99_VERSION 199901L + #define WAPP_PLATFORM_C11_VERSION 201112L + #define WAPP_PLATFORM_C17_VERSION 201710L + #define WAPP_PLATFORM_C23_VERSION 202311L - #if WAPP_PLATFORM_C_VERSION == WAPP_PLATFORM_C99_VERSION - #define WAPP_PLATFORM_C99 - #elif WAPP_PLATFORM_C_VERSION == WAPP_PLATFORM_C11_VERSION - #define WAPP_PLATFORM_C11 - #elif WAPP_PLATFORM_C_VERSION == WAPP_PLATFORM_C17_VERSION - #define WAPP_PLATFORM_C17 - #elif WAPP_PLATFORM_C_VERSION == WAPP_PLATFORM_C23_VERSION - #define WAPP_PLATFORM_C23 - #else - #error "Unrecognised C version" - #endif - #else - #define WAPP_PLATFORM_C89 - #endif + #if WAPP_PLATFORM_C_VERSION == WAPP_PLATFORM_C99_VERSION + #define WAPP_PLATFORM_C99 + #elif WAPP_PLATFORM_C_VERSION == WAPP_PLATFORM_C11_VERSION + #define WAPP_PLATFORM_C11 + #elif WAPP_PLATFORM_C_VERSION == WAPP_PLATFORM_C17_VERSION + #define WAPP_PLATFORM_C17 + #elif WAPP_PLATFORM_C_VERSION == WAPP_PLATFORM_C23_VERSION + #define WAPP_PLATFORM_C23 + #else + #error "Unrecognised C version" + #endif + #else + #define WAPP_PLATFORM_C89 + #endif #endif // !__cplusplus #endif // !PLATFORM_H -- 2.39.5 From 4333b1609002e26d53a5c3cd35309d0aa268f824 Mon Sep 17 00:00:00 2001 From: Abdelrahman Said Date: Mon, 29 Dec 2025 21:41:10 +0000 Subject: [PATCH 4/9] Reformat uuid --- src/uuid/uuid.c | 52 ++++++++++++++++++++++++------------------------- src/uuid/uuid.h | 2 +- 2 files changed, 27 insertions(+), 27 deletions(-) diff --git a/src/uuid/uuid.c b/src/uuid/uuid.c index 65de857..accec5b 100644 --- a/src/uuid/uuid.c +++ b/src/uuid/uuid.c @@ -11,48 +11,48 @@ typedef struct uuid4 UUID4; struct uuid4 { - u64 high; - u64 low; + u64 high; + u64 low; }; wapp_intern UUID4 generate_uuid4(void); -wapp_intern void uuid4_to_uuid(const UUID4* uuid4, WUUID *uuid); +wapp_intern void uuid4_to_uuid(const UUID4* uuid4, WUUID *uuid); WUUID *wapp_uuid_init_uuid4(WUUID *uuid) { - wapp_debug_assert(uuid != NULL, "`uuid` should not be NULL"); + wapp_debug_assert(uuid != NULL, "`uuid` should not be NULL"); - UUID4 uuid4 = generate_uuid4(); - uuid4_to_uuid(&uuid4, uuid); + UUID4 uuid4 = generate_uuid4(); + uuid4_to_uuid(&uuid4, uuid); - return uuid; + return uuid; } wapp_intern UUID4 generate_uuid4(void) { - wapp_persist XOR256State state = {0}; - wapp_persist b8 initialised = false; + wapp_persist XOR256State state = {0}; + wapp_persist b8 initialised = false; - if (!initialised) { - initialised = true; - state = wapp_prng_xorshift_init_state(); - } + if (!initialised) { + initialised = true; + state = wapp_prng_xorshift_init_state(); + } - UUID4 uuid = (UUID4){ - .high = wapp_prng_xorshift_256(&state), - .low = wapp_prng_xorshift_256(&state), - }; + UUID4 uuid = (UUID4){ + .high = wapp_prng_xorshift_256(&state), + .low = wapp_prng_xorshift_256(&state), + }; - uuid.high = (uuid.high & 0xffffffffffff0fff) | 0x0000000000004000; - uuid.low = (uuid.low & 0x3fffffffffffffff) | 0x8000000000000000; + uuid.high = (uuid.high & 0xffffffffffff0fff) | 0x0000000000004000; + uuid.low = (uuid.low & 0x3fffffffffffffff) | 0x8000000000000000; - return uuid; + return uuid; } wapp_intern void uuid4_to_uuid(const UUID4* uuid4, WUUID *uuid) { - u64 group1 = uuid4->high >> 32; - u64 group2 = (uuid4->high << 32) >> 48; - u64 group3 = (uuid4->high << 48) >> 48; - u64 group4 = uuid4->low >> 48; - u64 group5 = (uuid4->low << 16) >> 16; + u64 group1 = uuid4->high >> 32; + u64 group2 = (uuid4->high << 32) >> 48; + u64 group3 = (uuid4->high << 48) >> 48; + u64 group4 = uuid4->low >> 48; + u64 group5 = (uuid4->low << 16) >> 16; - wapp_str8_format(&(uuid->uuid), UUID_STR_FORMAT, group1, group2, group3, group4, group5); + wapp_str8_format(&(uuid->uuid), UUID_STR_FORMAT, group1, group2, group3, group4, group5); } diff --git a/src/uuid/uuid.h b/src/uuid/uuid.h index 0feedee..ed85fcd 100644 --- a/src/uuid/uuid.h +++ b/src/uuid/uuid.h @@ -17,7 +17,7 @@ BEGIN_C_LINKAGE typedef struct wapp_uuid WUUID; struct wapp_uuid { - Str8 uuid; + Str8 uuid; }; #define wapp_uuid_gen_uuid4() *(wapp_uuid_init_uuid4(&wapp_uuid_create())) -- 2.39.5 From 6abf510f7964c47c25c55bb521c2d8b93bc0265e Mon Sep 17 00:00:00 2001 From: Abdelrahman Said Date: Mon, 29 Dec 2025 21:42:52 +0000 Subject: [PATCH 5/9] Reformat prng --- src/prng/xorshift/xorshift.c | 122 +++++++++++++++++------------------ src/prng/xorshift/xorshift.h | 8 +-- 2 files changed, 65 insertions(+), 65 deletions(-) diff --git a/src/prng/xorshift/xorshift.c b/src/prng/xorshift/xorshift.c index 740edef..0dc7b2c 100644 --- a/src/prng/xorshift/xorshift.c +++ b/src/prng/xorshift/xorshift.c @@ -9,7 +9,7 @@ typedef struct split_mix_64_state SplitMix64State; struct split_mix_64_state { - u64 seed; + u64 seed; }; wapp_intern u64 rol64(u64 x, u64 bits); @@ -18,118 +18,118 @@ wapp_intern void seed_os_generator(void); wapp_intern u64 generate_random_number(void); XOR256State wapp_prng_xorshift_init_state(void) { - wapp_persist b8 seeded = false; - if (!seeded) { - seeded = true; - seed_os_generator(); - } + wapp_persist b8 seeded = false; + if (!seeded) { + seeded = true; + seed_os_generator(); + } - SplitMix64State sm64 = {.seed = generate_random_number()}; + SplitMix64State sm64 = {.seed = generate_random_number()}; - return (XOR256State){ - .x = split_mix_64(&sm64), - .y = split_mix_64(&sm64), - .z = split_mix_64(&sm64), - .w = split_mix_64(&sm64), - }; + return (XOR256State){ + .x = split_mix_64(&sm64), + .y = split_mix_64(&sm64), + .z = split_mix_64(&sm64), + .w = split_mix_64(&sm64), + }; } u64 wapp_prng_xorshift_256(XOR256State *state) { - u64 t = state->x ^ (state->x << 11); + u64 t = state->x ^ (state->x << 11); - state->x = state->y; - state->y = state->z; - state->z = state->w; - state->w = (state->w ^ (state->w >> 19)) ^ (t ^ (t >> 8)); + state->x = state->y; + state->y = state->z; + state->z = state->w; + state->w = (state->w ^ (state->w >> 19)) ^ (t ^ (t >> 8)); - return state->w; + return state->w; } u64 wapp_prng_xorshift_256ss(XOR256State *state) { - const u64 result = rol64(state->z * 5, 7) * 9; - const u64 t = state->z << 17; + const u64 result = rol64(state->z * 5, 7) * 9; + const u64 t = state->z << 17; - state->y ^= state->w; - state->x ^= state->z; - state->z ^= state->y; - state->w ^= state->x; + state->y ^= state->w; + state->x ^= state->z; + state->z ^= state->y; + state->w ^= state->x; - state->y ^= t; - state->x = rol64(state->x, 45); + state->y ^= t; + state->x = rol64(state->x, 45); - return result; + return result; } u64 wapp_prng_xorshift_256p(XOR256State *state) { - const u64 result = state->w + state->x; - const u64 t = state->z << 17; + const u64 result = state->w + state->x; + const u64 t = state->z << 17; - state->y ^= state->w; - state->x ^= state->z; - state->z ^= state->y; - state->w ^= state->x; + state->y ^= state->w; + state->x ^= state->z; + state->z ^= state->y; + state->w ^= state->x; - state->y ^= t; - state->x = rol64(state->x, 45); + state->y ^= t; + state->x = rol64(state->x, 45); - return result; + return result; } wapp_intern u64 rol64(u64 x, u64 bits) { - return (x << bits) | (x >> (64 - bits)); + return (x << bits) | (x >> (64 - bits)); } wapp_intern u64 split_mix_64(SplitMix64State *state) { - state->seed += 0x9E3779B97f4A7C15; + state->seed += 0x9E3779B97f4A7C15; - u64 result = state->seed; - result = (result ^ (result >> 30)) * 0xBF58476D1CE4E5B9; - result = (result ^ (result >> 27)) * 0x94D049BB133111EB; + u64 result = state->seed; + result = (result ^ (result >> 30)) * 0xBF58476D1CE4E5B9; + result = (result ^ (result >> 27)) * 0x94D049BB133111EB; - return result ^ (result >> 31); + return result ^ (result >> 31); } #if defined(WAPP_PLATFORM_C) && WAPP_PLATFORM_C_VERSION >= WAPP_PLATFORM_C11_VERSION #ifdef WAPP_PLATFORM_POSIX wapp_intern void seed_os_generator(void) { - struct timespec ts = {0}; - int result = clock_gettime(CLOCK_MONOTONIC_RAW, &ts); - wapp_runtime_assert(result == 0, "Invalid seed value"); + struct timespec ts = {0}; + int result = clock_gettime(CLOCK_MONOTONIC_RAW, &ts); + wapp_runtime_assert(result == 0, "Invalid seed value"); - srand48(ts.tv_nsec); + srand48(ts.tv_nsec); } wapp_intern u64 generate_random_number(void) { - return lrand48(); + return lrand48(); } #else wapp_intern void seed_os_generator(void) { - struct timespec ts = {0}; - int result = timespec_get(&ts, TIME_UTC); - wapp_runtime_assert(result != 0, "Invalid seed value"); + struct timespec ts = {0}; + int result = timespec_get(&ts, TIME_UTC); + wapp_runtime_assert(result != 0, "Invalid seed value"); - srand(ts.tv_nsec); + srand(ts.tv_nsec); } wapp_intern u64 generate_random_number(void) { - i32 n1 = rand(); - i32 n2 = rand(); + i32 n1 = rand(); + i32 n2 = rand(); - return (((u64)n1) << 32 | (u64)n2); + return (((u64)n1) << 32 | (u64)n2); } #endif // !WAPP_PLATFORM_POSIX #else wapp_intern void seed_os_generator(void) { - time_t result = time(NULL); - wapp_runtime_assert(result != (time_t)(-1), "Invalid seed value"); + time_t result = time(NULL); + wapp_runtime_assert(result != (time_t)(-1), "Invalid seed value"); - srand(result); + srand(result); } wapp_intern u64 generate_random_number(void) { - i32 n1 = rand(); - i32 n2 = rand(); + i32 n1 = rand(); + i32 n2 = rand(); - return (((u64)n1) << 32 | (u64)n2); + return (((u64)n1) << 32 | (u64)n2); } #endif // !WAPP_PLATFORM_C diff --git a/src/prng/xorshift/xorshift.h b/src/prng/xorshift/xorshift.h index 20d1aea..72eca29 100644 --- a/src/prng/xorshift/xorshift.h +++ b/src/prng/xorshift/xorshift.h @@ -12,10 +12,10 @@ BEGIN_C_LINKAGE typedef struct xor_256_state XOR256State; struct xor_256_state { - u64 x; - u64 y; - u64 z; - u64 w; + u64 x; + u64 y; + u64 z; + u64 w; }; XOR256State wapp_prng_xorshift_init_state(void); -- 2.39.5 From 0ba626601d6d5268b5d5600e5182a19799e8f4dd Mon Sep 17 00:00:00 2001 From: Abdelrahman Said Date: Mon, 29 Dec 2025 21:43:40 +0000 Subject: [PATCH 6/9] Reformat tester --- src/testing/tester/tester.c | 56 ++++++++++++++++++------------------- src/testing/tester/tester.h | 6 ++-- 2 files changed, 31 insertions(+), 31 deletions(-) diff --git a/src/testing/tester/tester.c b/src/testing/tester/tester.c index 6886209..fc8773b 100644 --- a/src/testing/tester/tester.c +++ b/src/testing/tester/tester.c @@ -11,45 +11,45 @@ wapp_intern void handle_test_result(TestFuncResult result); void run_tests(TestFunc *func1, ...) { - printf("\n"); + printf("\n"); - handle_test_result(func1()); + handle_test_result(func1()); - va_list args; - va_start(args, func1); + va_list args; + va_start(args, func1); - TestFunc *func = va_arg(args, TestFunc *); + TestFunc *func = va_arg(args, TestFunc *); - while (func) { - TestFuncResult result = func(); - handle_test_result(result); + while (func) { + TestFuncResult result = func(); + handle_test_result(result); - func = va_arg(args, TestFunc *); - } + func = va_arg(args, TestFunc *); + } - va_end(args); + va_end(args); - printf("\n"); + printf("\n"); } wapp_intern void handle_test_result(TestFuncResult result) { - TerminalColour colour; - Str8 result_text = wapp_str8_buf(64); + TerminalColour colour; + Str8 result_text = wapp_str8_buf(64); - if (result.passed) { - colour = WAPP_TERM_COLOUR_FG_BR_GREEN; - wapp_str8_copy_cstr_capped(&result_text, "PASSED"); - } else { - colour = WAPP_TERM_COLOUR_FG_BR_RED; - wapp_str8_copy_cstr_capped(&result_text, "FAILED"); - } + if (result.passed) { + colour = WAPP_TERM_COLOUR_FG_BR_GREEN; + wapp_str8_copy_cstr_capped(&result_text, "PASSED"); + } else { + colour = WAPP_TERM_COLOUR_FG_BR_RED; + wapp_str8_copy_cstr_capped(&result_text, "FAILED"); + } - printf("["); - wapp_shell_termcolour_print_text(&result_text, colour); - wapp_shell_termcolour_clear_colour(); - printf("] " WAPP_STR8_SPEC "\n", wapp_str8_varg(result.name)); + printf("["); + wapp_shell_termcolour_print_text(&result_text, colour); + wapp_shell_termcolour_clear_colour(); + printf("] " WAPP_STR8_SPEC "\n", wapp_str8_varg(result.name)); - if (!result.passed) { - exit(EXIT_FAILURE); - } + if (!result.passed) { + exit(EXIT_FAILURE); + } } diff --git a/src/testing/tester/tester.h b/src/testing/tester/tester.h index 33db2cd..11bd542 100644 --- a/src/testing/tester/tester.h +++ b/src/testing/tester/tester.h @@ -19,11 +19,11 @@ BEGIN_C_LINKAGE typedef struct test_func_result TestFuncResult; struct test_func_result { - Str8 name; - b8 passed; + Str8 name; + b8 passed; #ifdef WAPP_PLATFORM_WINDOWS - wapp_misc_utils_padding_size(sizeof(Str8RO) + sizeof(b8)); + wapp_misc_utils_padding_size(sizeof(Str8RO) + sizeof(b8)); #endif // WAPP_PLATFORM_WINDOWS }; -- 2.39.5 From b2419475aaf32c43bc8271a0a70f3a1e4836eee7 Mon Sep 17 00:00:00 2001 From: Abdelrahman Said Date: Mon, 29 Dec 2025 22:08:02 +0000 Subject: [PATCH 7/9] Reformat os --- src/os/allocators/arena/mem_arena.c | 154 +++++++-------- src/os/allocators/arena/mem_arena.h | 30 +-- src/os/allocators/arena/mem_arena_allocator.c | 46 ++--- src/os/allocators/arena/mem_arena_allocator.h | 16 +- src/os/cpath/cpath.c | 186 +++++++++--------- src/os/cpath/cpath.h | 12 +- src/os/file/file.c | 124 ++++++------ src/os/file/file.h | 56 +++--- src/os/shell/commander/commander.c | 108 +++++----- src/os/shell/commander/commander_output.h | 28 +-- .../shell/commander/posix/commander_posix.c | 12 +- src/os/shell/commander/win/commander_win.c | 14 +- .../shell/termcolour/posix/termcolour_posix.c | 36 ++-- src/os/shell/termcolour/termcolour.c | 12 +- src/os/shell/termcolour/terminal_colours.h | 36 ++-- src/os/shell/termcolour/win/termcolour_win.c | 76 +++---- src/os/shell/utils/shell_utils.h | 8 +- 17 files changed, 477 insertions(+), 477 deletions(-) diff --git a/src/os/allocators/arena/mem_arena.c b/src/os/allocators/arena/mem_arena.c index 221dee9..0a1876d 100644 --- a/src/os/allocators/arena/mem_arena.c +++ b/src/os/allocators/arena/mem_arena.c @@ -18,129 +18,129 @@ #define ARENA_MINIMUM_CAPACITY KiB(16) // Allocate minimum of 4 pages struct arena { - u8 *buf; - u8 *offset; - u64 capacity; - b8 committed; + u8 *buf; + u8 *offset; + u64 capacity; + b8 committed; #ifdef WAPP_PLATFORM_WINDOWS - wapp_misc_utils_padding_size(sizeof(u8 *) * 2 + sizeof(u64) + sizeof(b8)); + wapp_misc_utils_padding_size(sizeof(u8 *) * 2 + sizeof(u64) + sizeof(b8)); #endif // ifdef WAPP_PLATFORM_WINDOWS }; b8 wapp_mem_arena_init_custom(Arena **arena, u64 base_capacity, MemAllocFlags flags, b8 zero_buffer) { - if (!arena || *arena || base_capacity == 0) { - return false; - } + if (!arena || *arena || base_capacity == 0) { + return false; + } - *arena = (Arena *)calloc(1, sizeof(Arena)); - Arena *arena_ptr = *arena; - if (!arena_ptr) { - return false; - } + *arena = (Arena *)calloc(1, sizeof(Arena)); + Arena *arena_ptr = *arena; + if (!arena_ptr) { + return false; + } - u64 arena_capacity = wapp_misc_utils_u64_round_up_pow2( - base_capacity >= ARENA_MINIMUM_CAPACITY ? - base_capacity : - ARENA_MINIMUM_CAPACITY - ); + u64 arena_capacity = wapp_misc_utils_u64_round_up_pow2( + base_capacity >= ARENA_MINIMUM_CAPACITY ? + base_capacity : + ARENA_MINIMUM_CAPACITY + ); - arena_ptr->buf = (u8 *)wapp_mem_util_alloc(NULL, arena_capacity, WAPP_MEM_ACCESS_READ_WRITE, flags, - zero_buffer ? WAPP_MEM_INIT_INITIALISED : WAPP_MEM_INIT_UNINITIALISED); + arena_ptr->buf = (u8 *)wapp_mem_util_alloc(NULL, arena_capacity, WAPP_MEM_ACCESS_READ_WRITE, flags, + zero_buffer ? WAPP_MEM_INIT_INITIALISED : WAPP_MEM_INIT_UNINITIALISED); - if (!(arena_ptr->buf)) { - wapp_mem_arena_destroy(arena); - return false; - } + if (!(arena_ptr->buf)) { + wapp_mem_arena_destroy(arena); + return false; + } - arena_ptr->capacity = arena_capacity; - arena_ptr->offset = arena_ptr->buf; - arena_ptr->committed = (flags & WAPP_MEM_ALLOC_COMMIT) == WAPP_MEM_ALLOC_COMMIT; + arena_ptr->capacity = arena_capacity; + arena_ptr->offset = arena_ptr->buf; + arena_ptr->committed = (flags & WAPP_MEM_ALLOC_COMMIT) == WAPP_MEM_ALLOC_COMMIT; - return true; + return true; } void *wapp_mem_arena_alloc(Arena *arena, u64 size) { - return wapp_mem_arena_alloc_aligned(arena, size, DEFAULT_ALIGNMENT); + return wapp_mem_arena_alloc_aligned(arena, size, DEFAULT_ALIGNMENT); } void *wapp_mem_arena_alloc_aligned(Arena *arena, u64 size, u64 alignment) { - wapp_debug_assert(arena != NULL, "`arena` should not be NULL"); + wapp_debug_assert(arena != NULL, "`arena` should not be NULL"); - u8 *alloc_start = arena->offset; + u8 *alloc_start = arena->offset; - u8 *output = wapp_mem_util_align_forward((void *)alloc_start, alignment); - if (output + size >= arena->buf + arena->capacity) { - return NULL; - } + u8 *output = wapp_mem_util_align_forward((void *)alloc_start, alignment); + if (output + size >= arena->buf + arena->capacity) { + return NULL; + } - arena->offset = output + size; + arena->offset = output + size; #ifdef WAPP_PLATFORM_WINDOWS - if (!(arena->committed)) { - wapp_mem_util_alloc(alloc_start, (uptr)(arena->offset) - (uptr)(alloc_start), - WAPP_MEM_ACCESS_READ_WRITE, WAPP_MEM_ALLOC_COMMIT, - WAPP_MEM_INIT_UNINITIALISED); - } + if (!(arena->committed)) { + wapp_mem_util_alloc(alloc_start, (uptr)(arena->offset) - (uptr)(alloc_start), + WAPP_MEM_ACCESS_READ_WRITE, WAPP_MEM_ALLOC_COMMIT, + WAPP_MEM_INIT_UNINITIALISED); + } #endif // ifdef WAPP_PLATFORM_WINDOWS - memset(output, 0, size); + memset(output, 0, size); - return (void *)output; + return (void *)output; } void *wapp_mem_arena_realloc(Arena *arena, void *ptr, u64 old_size, u64 new_size) { - if ((u8*)ptr < arena->buf || (u8*)ptr > arena->offset || - arena->offset + new_size >= arena->buf + arena->capacity) { - return NULL; - } + if ((u8*)ptr < arena->buf || (u8*)ptr > arena->offset || + arena->offset + new_size >= arena->buf + arena->capacity) { + return NULL; + } - void *new_ptr = wapp_mem_arena_alloc(arena, new_size); - if (!new_ptr) { - return NULL; - } + void *new_ptr = wapp_mem_arena_alloc(arena, new_size); + if (!new_ptr) { + return NULL; + } - u64 copy_size = new_size <= old_size ? new_size : old_size; - memcpy(new_ptr, ptr, copy_size); + u64 copy_size = new_size <= old_size ? new_size : old_size; + memcpy(new_ptr, ptr, copy_size); - return new_ptr; + return new_ptr; } void *wapp_mem_arena_realloc_aligned(Arena *arena, void *ptr, u64 old_size, u64 new_size, u64 alignment) { - if ((u8*)ptr < arena->buf || (u8*)ptr > arena->offset || - arena->offset + new_size >= arena->buf + arena->capacity) { - return NULL; - } + if ((u8*)ptr < arena->buf || (u8*)ptr > arena->offset || + arena->offset + new_size >= arena->buf + arena->capacity) { + return NULL; + } - void *new_ptr = wapp_mem_arena_alloc_aligned(arena, new_size, alignment); - if (!new_ptr) { - return NULL; - } + void *new_ptr = wapp_mem_arena_alloc_aligned(arena, new_size, alignment); + if (!new_ptr) { + return NULL; + } - u64 copy_size = new_size <= old_size ? new_size : old_size; - memcpy(new_ptr, ptr, copy_size); + u64 copy_size = new_size <= old_size ? new_size : old_size; + memcpy(new_ptr, ptr, copy_size); - return new_ptr; + return new_ptr; } void wapp_mem_arena_clear(Arena *arena) { - wapp_debug_assert(arena != NULL, "`arena` should not be NULL"); + wapp_debug_assert(arena != NULL, "`arena` should not be NULL"); - memset(arena->buf, 0, arena->offset - arena->buf); - arena->offset = arena->buf; + memset(arena->buf, 0, arena->offset - arena->buf); + arena->offset = arena->buf; } void wapp_mem_arena_destroy(Arena **arena) { - wapp_debug_assert(arena != NULL && (*arena) != NULL, "`arena` double pointer is not valid"); + wapp_debug_assert(arena != NULL && (*arena) != NULL, "`arena` double pointer is not valid"); - Arena *arena_ptr = *arena; - if (arena_ptr->buf) { - wapp_mem_util_free(arena_ptr->buf, arena_ptr->capacity); - } + Arena *arena_ptr = *arena; + if (arena_ptr->buf) { + wapp_mem_util_free(arena_ptr->buf, arena_ptr->capacity); + } - arena_ptr->buf = arena_ptr->offset = NULL; - arena_ptr->capacity = 0; + arena_ptr->buf = arena_ptr->offset = NULL; + arena_ptr->capacity = 0; - free(*arena); - *arena = NULL; + free(*arena); + *arena = NULL; } diff --git a/src/os/allocators/arena/mem_arena.h b/src/os/allocators/arena/mem_arena.h index 653487d..af2210d 100644 --- a/src/os/allocators/arena/mem_arena.h +++ b/src/os/allocators/arena/mem_arena.h @@ -13,27 +13,27 @@ BEGIN_C_LINKAGE typedef struct arena Arena; -#define wapp_mem_arena_init(arena_dptr, base_capacity) \ - (wapp_mem_arena_init_custom(arena_dptr, base_capacity, WAPP_MEM_ALLOC_RESERVE, false)) -#define wapp_mem_arena_init_commit(arena_dptr, base_capacity) \ - (wapp_mem_arena_init_custom(arena_dptr, base_capacity, WAPP_MEM_ALLOC_RESERVE | WAPP_MEM_ALLOC_COMMIT, false)) -#define wapp_mem_arena_init_zero(arena_dptr, base_capacity) \ - (wapp_mem_arena_init_custom(arena_dptr, base_capacity, WAPP_MEM_ALLOC_RESERVE, true)) -#define wapp_mem_arena_init_commit_and_zero(arena_dptr, base_capacity) \ - (wapp_mem_arena_init_custom(arena_dptr, base_capacity, WAPP_MEM_ALLOC_RESERVE | WAPP_MEM_ALLOC_COMMIT, true)) +#define wapp_mem_arena_init(arena_dptr, base_capacity) \ + (wapp_mem_arena_init_custom(arena_dptr, base_capacity, WAPP_MEM_ALLOC_RESERVE, false)) +#define wapp_mem_arena_init_commit(arena_dptr, base_capacity) \ + (wapp_mem_arena_init_custom(arena_dptr, base_capacity, WAPP_MEM_ALLOC_RESERVE | WAPP_MEM_ALLOC_COMMIT, false)) +#define wapp_mem_arena_init_zero(arena_dptr, base_capacity) \ + (wapp_mem_arena_init_custom(arena_dptr, base_capacity, WAPP_MEM_ALLOC_RESERVE, true)) +#define wapp_mem_arena_init_commit_and_zero(arena_dptr, base_capacity) \ + (wapp_mem_arena_init_custom(arena_dptr, base_capacity, WAPP_MEM_ALLOC_RESERVE | WAPP_MEM_ALLOC_COMMIT, true)) /** * Arena initialisation function. `wapp_mem_arena_init_custom` provides the most * control over how the Arena is initialised. Wrapper macros are provided for * easier use. */ -b8 wapp_mem_arena_init_custom(Arena **arena, u64 base_capacity, MemAllocFlags flags, b8 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); -void *wapp_mem_arena_realloc_aligned(Arena *arena, void *ptr, u64 old_size, u64 new_size, u64 alignment); -void wapp_mem_arena_clear(Arena *arena); -void wapp_mem_arena_destroy(Arena **arena); +b8 wapp_mem_arena_init_custom(Arena **arena, u64 base_capacity, MemAllocFlags flags, b8 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); +void *wapp_mem_arena_realloc_aligned(Arena *arena, void *ptr, u64 old_size, u64 new_size, u64 alignment); +void wapp_mem_arena_clear(Arena *arena); +void wapp_mem_arena_destroy(Arena **arena); #ifdef WAPP_PLATFORM_CPP END_C_LINKAGE diff --git a/src/os/allocators/arena/mem_arena_allocator.c b/src/os/allocators/arena/mem_arena_allocator.c index d0aaa46..2ced4bd 100644 --- a/src/os/allocators/arena/mem_arena_allocator.c +++ b/src/os/allocators/arena/mem_arena_allocator.c @@ -9,51 +9,51 @@ wapp_intern inline void *mem_arena_alloc(u64 size, void *alloc_obj); wapp_intern inline void *mem_arena_alloc_aligned(u64 size, u64 alignment, void *alloc_obj); wapp_intern inline void *mem_arena_realloc(void *ptr, u64 old_size, u64 new_size, void *alloc_obj); wapp_intern inline void *mem_arena_realloc_aligned(void *ptr, u64 old_size, u64 new_size, u64 alignment, - void *alloc_obj); + void *alloc_obj); Allocator wapp_mem_arena_allocator_init_custom(u64 base_capacity, MemAllocFlags flags, b8 zero_buffer) { - Allocator allocator = {0}; - b8 initialised = wapp_mem_arena_init_custom((Arena **)(&allocator.obj), base_capacity, flags, zero_buffer); - if (!initialised) { - return allocator; - } + Allocator allocator = {0}; + b8 initialised = wapp_mem_arena_init_custom((Arena **)(&allocator.obj), base_capacity, flags, zero_buffer); + if (!initialised) { + return allocator; + } - allocator.alloc = mem_arena_alloc; - allocator.alloc_aligned = mem_arena_alloc_aligned; - allocator.realloc = mem_arena_realloc; - allocator.realloc_aligned = mem_arena_realloc_aligned; + allocator.alloc = mem_arena_alloc; + allocator.alloc_aligned = mem_arena_alloc_aligned; + allocator.realloc = mem_arena_realloc; + allocator.realloc_aligned = mem_arena_realloc_aligned; - return allocator; + return allocator; } void wapp_mem_arena_allocator_clear(Allocator *allocator) { - wapp_mem_arena_clear((Arena *)(allocator->obj)); + wapp_mem_arena_clear((Arena *)(allocator->obj)); } void wapp_mem_arena_allocator_destroy(Allocator *allocator) { - wapp_mem_arena_destroy((Arena **)(&(allocator->obj))); - *allocator = (Allocator){0}; + wapp_mem_arena_destroy((Arena **)(&(allocator->obj))); + *allocator = (Allocator){0}; } wapp_intern inline void *mem_arena_alloc(u64 size, void *alloc_obj) { - Arena *arena = (Arena *)alloc_obj; - return wapp_mem_arena_alloc(arena, size); + Arena *arena = (Arena *)alloc_obj; + return wapp_mem_arena_alloc(arena, size); } wapp_intern inline void *mem_arena_alloc_aligned(u64 size, u64 alignment, void *alloc_obj) { - Arena *arena = (Arena *)alloc_obj; - return wapp_mem_arena_alloc_aligned(arena, size, alignment); + Arena *arena = (Arena *)alloc_obj; + return wapp_mem_arena_alloc_aligned(arena, size, alignment); } wapp_intern inline void *mem_arena_realloc(void *ptr, u64 old_size, u64 new_size, void *alloc_obj) { - Arena *arena = (Arena *)alloc_obj; - return wapp_mem_arena_realloc(arena, ptr, old_size, new_size); + Arena *arena = (Arena *)alloc_obj; + return wapp_mem_arena_realloc(arena, ptr, old_size, new_size); } wapp_intern inline void *mem_arena_realloc_aligned(void *ptr, u64 old_size, u64 new_size, u64 alignment, - void *alloc_obj) { - Arena *arena = (Arena *)alloc_obj; - return wapp_mem_arena_realloc_aligned(arena, ptr, old_size, new_size, alignment); + void *alloc_obj) { + Arena *arena = (Arena *)alloc_obj; + return wapp_mem_arena_realloc_aligned(arena, ptr, old_size, new_size, alignment); } diff --git a/src/os/allocators/arena/mem_arena_allocator.h b/src/os/allocators/arena/mem_arena_allocator.h index 87c3d8b..06d4512 100644 --- a/src/os/allocators/arena/mem_arena_allocator.h +++ b/src/os/allocators/arena/mem_arena_allocator.h @@ -12,14 +12,14 @@ BEGIN_C_LINKAGE #endif // !WAPP_PLATFORM_CPP -#define wapp_mem_arena_allocator_init(base_capacity) \ - (wapp_mem_arena_allocator_init_custom(base_capacity, WAPP_MEM_ALLOC_RESERVE, false)) -#define wapp_mem_arena_allocator_init_commit(base_capacity) \ - (wapp_mem_arena_allocator_init_custom(base_capacity, WAPP_MEM_ALLOC_RESERVE | WAPP_MEM_ALLOC_COMMIT, false)) -#define wapp_mem_arena_allocator_init_zero(base_capacity) \ - (wapp_mem_arena_allocator_init_custom(base_capacity, WAPP_MEM_ALLOC_RESERVE, true)) -#define wapp_mem_arena_allocator_init_commit_and_zero(base_capacity) \ - (wapp_mem_arena_allocator_init_custom(base_capacity, WAPP_MEM_ALLOC_RESERVE | WAPP_MEM_ALLOC_COMMIT, true)) +#define wapp_mem_arena_allocator_init(base_capacity) \ + (wapp_mem_arena_allocator_init_custom(base_capacity, WAPP_MEM_ALLOC_RESERVE, false)) +#define wapp_mem_arena_allocator_init_commit(base_capacity) \ + (wapp_mem_arena_allocator_init_custom(base_capacity, WAPP_MEM_ALLOC_RESERVE | WAPP_MEM_ALLOC_COMMIT, false)) +#define wapp_mem_arena_allocator_init_zero(base_capacity) \ + (wapp_mem_arena_allocator_init_custom(base_capacity, WAPP_MEM_ALLOC_RESERVE, true)) +#define wapp_mem_arena_allocator_init_commit_and_zero(base_capacity) \ + (wapp_mem_arena_allocator_init_custom(base_capacity, WAPP_MEM_ALLOC_RESERVE | WAPP_MEM_ALLOC_COMMIT, true)) /** * Wraps an Arena in an Allocator object. It attempts to initialise the Arena diff --git a/src/os/cpath/cpath.c b/src/os/cpath/cpath.c index 7b11362..7789db7 100644 --- a/src/os/cpath/cpath.c +++ b/src/os/cpath/cpath.c @@ -12,124 +12,124 @@ #include u32 wapp_cpath_join_path(Str8 *dst, const Str8List *parts) { - if (!dst || !parts) { - return CPATH_JOIN_INVALID_ARGS; - } + if (!dst || !parts) { + return CPATH_JOIN_INVALID_ARGS; + } - if (parts->node_count == 0) { - return CPATH_JOIN_EMPTY_PARTS; - } + if (parts->node_count == 0) { + return CPATH_JOIN_EMPTY_PARTS; + } - Str8 separator = wapp_str8_buf(4); - wapp_str8_push_back(&separator, WAPP_PATH_SEP); + Str8 separator = wapp_str8_buf(4); + 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) { - return CPATH_JOIN_INSUFFICIENT_DST_CAPACITY; - } + u64 required_capacity = parts->node_count * separator.size + wapp_str8_list_total_size(parts); + if (dst->capacity < required_capacity) { + return CPATH_JOIN_INSUFFICIENT_DST_CAPACITY; + } - // Handle first node - const Str8Node *first_node = wapp_dbl_list_get(Str8, Str8Node, parts, 0); - wapp_str8_copy_str8_capped(dst, first_node->item); + // Handle first node + const Str8Node *first_node = wapp_dbl_list_get(Str8, Str8Node, parts, 0); + wapp_str8_copy_str8_capped(dst, first_node->item); - // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of - // MSVC Spectre mitigation warnings - const Str8Node *node = first_node; - u64 node_index = 1; - b8 running = node_index < parts->node_count; - while (running && node->next) { - node = node->next; - if (node->item->size == 0) { - continue; - } + // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of + // MSVC Spectre mitigation warnings + const Str8Node *node = first_node; + u64 node_index = 1; + b8 running = node_index < parts->node_count; + while (running && node->next) { + node = node->next; + if (node->item->size == 0) { + continue; + } - if (dst->size > 0) { - char dst_last = wapp_str8_get(dst, dst->size - 1); - char node_start = wapp_str8_get(node->item, 0); - b8 add_path_sep = dst_last != WAPP_PATH_SEP && node_start != WAPP_PATH_SEP; + if (dst->size > 0) { + char dst_last = wapp_str8_get(dst, dst->size - 1); + char node_start = wapp_str8_get(node->item, 0); + b8 add_path_sep = dst_last != WAPP_PATH_SEP && node_start != WAPP_PATH_SEP; - if (add_path_sep) { - wapp_str8_concat_capped(dst, &separator); - } - } + if (add_path_sep) { + wapp_str8_concat_capped(dst, &separator); + } + } - wapp_str8_concat_capped(dst, node->item); + wapp_str8_concat_capped(dst, node->item); - ++node_index; - running = node_index < parts->node_count; - } + ++node_index; + running = node_index < parts->node_count; + } - return CPATH_JOIN_SUCCESS; + return CPATH_JOIN_SUCCESS; } Str8 *dirup(const Allocator *allocator, Str8RO *path, u64 levels) { - Str8 *output = NULL; - if (!allocator || !path) { - goto RETURN_DIRUP; - } + Str8 *output = NULL; + if (!allocator || !path) { + goto RETURN_DIRUP; + } - b8 absolute = wapp_str8_get(path, 0) == WAPP_PATH_SEP; - Str8 separator = wapp_str8_buf(4); - wapp_str8_push_back(&separator, WAPP_PATH_SEP); + b8 absolute = wapp_str8_get(path, 0) == WAPP_PATH_SEP; + Str8 separator = wapp_str8_buf(4); + wapp_str8_push_back(&separator, WAPP_PATH_SEP); - if (path->size == 0) { - output = wapp_str8_alloc_buf(allocator, 16); - if (!output) { - goto RETURN_DIRUP; - } + if (path->size == 0) { + output = wapp_str8_alloc_buf(allocator, 16); + if (!output) { + goto RETURN_DIRUP; + } - wapp_str8_push_back(output, absolute ? WAPP_PATH_SEP : '.'); - goto RETURN_DIRUP; - } + wapp_str8_push_back(output, absolute ? WAPP_PATH_SEP : '.'); + goto RETURN_DIRUP; + } - if (levels < 1) { - output = wapp_str8_alloc_str8(allocator, path); - goto RETURN_DIRUP; - } + if (levels < 1) { + output = wapp_str8_alloc_str8(allocator, path); + goto RETURN_DIRUP; + } - Allocator tmp_arena = wapp_mem_arena_allocator_init(MiB(8)); - if (wapp_mem_allocator_invalid(&tmp_arena)) { - goto RETURN_DIRUP; - } + Allocator tmp_arena = wapp_mem_arena_allocator_init(MiB(8)); + if (wapp_mem_allocator_invalid(&tmp_arena)) { + goto RETURN_DIRUP; + } - Str8List *parts = wapp_str8_split(&tmp_arena, path, &separator); - if (!parts) { - goto RETURN_DIRUP; - } + Str8List *parts = wapp_str8_split(&tmp_arena, path, &separator); + if (!parts) { + goto RETURN_DIRUP; + } - if (levels >= parts->node_count) { - output = wapp_str8_alloc_buf(allocator, 16); - if (!output) { - goto LIST_CLEANUP_DIRUP; - } + if (levels >= parts->node_count) { + output = wapp_str8_alloc_buf(allocator, 16); + if (!output) { + goto LIST_CLEANUP_DIRUP; + } - wapp_str8_push_back(output, absolute ? WAPP_PATH_SEP : '.'); - } else { - for (u64 i = 0; i < levels; ++i) { - wapp_dbl_list_pop_back(Str8, Str8Node, parts); - } - - u64 alignment = sizeof(void *) * 2; - u64 alloc_size = wapp_str8_list_total_size(parts) + parts->node_count * separator.size; - u64 modulo = alloc_size & (alignment - 1); - alloc_size += alignment - modulo; + wapp_str8_push_back(output, absolute ? WAPP_PATH_SEP : '.'); + } else { + for (u64 i = 0; i < levels; ++i) { + wapp_dbl_list_pop_back(Str8, Str8Node, parts); + } + + u64 alignment = sizeof(void *) * 2; + u64 alloc_size = wapp_str8_list_total_size(parts) + parts->node_count * separator.size; + u64 modulo = alloc_size & (alignment - 1); + alloc_size += alignment - modulo; - output = wapp_str8_alloc_buf(allocator, alloc_size); - if (output) { - if (absolute) { - wapp_str8_push_back(output, WAPP_PATH_SEP); - } + output = wapp_str8_alloc_buf(allocator, alloc_size); + if (output) { + if (absolute) { + wapp_str8_push_back(output, WAPP_PATH_SEP); + } - Str8 *joined = wapp_str8_join(&tmp_arena, parts, &separator); - if (joined) { - wapp_str8_concat_capped(output, joined); - } - } - } + Str8 *joined = wapp_str8_join(&tmp_arena, parts, &separator); + if (joined) { + wapp_str8_concat_capped(output, joined); + } + } + } LIST_CLEANUP_DIRUP: - wapp_mem_arena_allocator_destroy(&tmp_arena); + wapp_mem_arena_allocator_destroy(&tmp_arena); RETURN_DIRUP: - return output; + return output; } diff --git a/src/os/cpath/cpath.h b/src/os/cpath/cpath.h index 823ef3c..91cfd1b 100644 --- a/src/os/cpath/cpath.h +++ b/src/os/cpath/cpath.h @@ -29,14 +29,14 @@ BEGIN_C_LINKAGE #define wapp_cpath_dirup(ALLOCATOR, PATH, COUNT) dirup(ALLOCATOR, PATH, COUNT) enum { - CPATH_JOIN_SUCCESS = 0, - CPATH_JOIN_INVALID_ARGS, - CPATH_JOIN_EMPTY_PARTS, - CPATH_JOIN_INSUFFICIENT_DST_CAPACITY, + CPATH_JOIN_SUCCESS = 0, + CPATH_JOIN_INVALID_ARGS, + CPATH_JOIN_EMPTY_PARTS, + CPATH_JOIN_INSUFFICIENT_DST_CAPACITY, }; -u32 wapp_cpath_join_path(Str8 *dst, const Str8List *parts); -Str8 *dirup(const Allocator *allocator, Str8RO *path, u64 levels); +u32 wapp_cpath_join_path(Str8 *dst, const Str8List *parts); +Str8 *dirup(const Allocator *allocator, Str8RO *path, u64 levels); #ifdef WAPP_PLATFORM_CPP END_C_LINKAGE diff --git a/src/os/file/file.c b/src/os/file/file.c index a7999ec..6cc9b26 100644 --- a/src/os/file/file.c +++ b/src/os/file/file.c @@ -9,101 +9,101 @@ #include File *wapp_file_open(Str8RO *filepath, FileAccessMode mode) { - wapp_persist 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+", - }; - wapp_persist c8 tmp[WAPP_PATH_MAX] = {0}; - wapp_debug_assert(filepath->size < WAPP_PATH_MAX, "`filepath` exceeds max path limit."); + wapp_persist 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+", + }; + wapp_persist 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); + memset(tmp, 0, WAPP_PATH_MAX); + memcpy(tmp, filepath->buf, filepath->size); - return fopen((const char *)tmp, modes[mode]); + 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); + 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."); - // TODO (Abdelrahman): Revisit conversion to long - return fseek(file, (long)offset, origin); + wapp_debug_assert(file != NULL, "`file` should not be NULL."); + // TODO (Abdelrahman): Revisit conversion to long + return fseek(file, (long)offset, origin); } u64 wapp_file_get_length(File *file) { - wapp_debug_assert(file != NULL, "`file` should not be NULL."); + wapp_debug_assert(file != NULL, "`file` should not be NULL."); - u64 current = wapp_file_get_current_position(file); + u64 current = wapp_file_get_current_position(file); - wapp_file_seek(file, 0, WAPP_SEEK_END); + wapp_file_seek(file, 0, WAPP_SEEK_END); - u64 output = ftell(file); + u64 output = ftell(file); - // Restore position - wapp_file_seek(file, current, WAPP_SEEK_START); + // Restore position + wapp_file_seek(file, current, WAPP_SEEK_START); - return output; + return output; } u64 wapp_file_read(GenericArray *dst_buf, File *file, u64 item_count) { - wapp_debug_assert(dst_buf != NULL && file != NULL, - "`dst_buf` and `file` should not be NULL."); + wapp_debug_assert(dst_buf != NULL && file != NULL, + "`dst_buf` and `file` should not be NULL."); - u64 file_length = wapp_file_get_length(file); - u64 item_size = dst_buf->item_size; - u64 dst_byte_capacity = dst_buf->capacity * item_size; - u64 req_byte_count = item_count * item_size; - u64 copy_byte_count = 0; + u64 file_length = wapp_file_get_length(file); + u64 item_size = dst_buf->item_size; + u64 dst_byte_capacity = dst_buf->capacity * item_size; + u64 req_byte_count = item_count * 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; - } + 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; + } - u64 count = fread(dst_buf->items, sizeof(u8), copy_byte_count, file); - if (ferror(file)) { return 0; } + u64 count = fread(dst_buf->items, sizeof(u8), copy_byte_count, file); + if (ferror(file)) { return 0; } - dst_buf->count = count / item_size; + dst_buf->count = count / item_size; - return dst_buf->count; + return dst_buf->count; } u64 wapp_file_write(const GenericArray *src_buf, File *file, u64 item_count) { - wapp_debug_assert(src_buf != NULL && file != NULL, - "`src_buf` and `file` should not be NULL."); + wapp_debug_assert(src_buf != NULL && file != NULL, + "`src_buf` and `file` should not be NULL."); - u64 item_size = src_buf->item_size; - u64 src_byte_count = src_buf->count * item_size; - u64 req_byte_count = item_count * item_size; - u64 to_copy = req_byte_count <= src_byte_count ? req_byte_count : src_byte_count; + u64 item_size = src_buf->item_size; + u64 src_byte_count = src_buf->count * item_size; + u64 req_byte_count = item_count * item_size; + u64 to_copy = req_byte_count <= src_byte_count ? req_byte_count : src_byte_count; - return fwrite(src_buf->items, sizeof(u8), to_copy, file); + return fwrite(src_buf->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); + 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); + wapp_debug_assert(file != NULL, "`file` should not be NULL."); + return fclose(file); } diff --git a/src/os/file/file.h b/src/os/file/file.h index df69a43..9132dfd 100644 --- a/src/os/file/file.h +++ b/src/os/file/file.h @@ -14,40 +14,40 @@ BEGIN_C_LINKAGE 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+ + 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, + FILE_ACCESS_MODE_COUNT, } FileAccessMode; typedef enum { - WAPP_SEEK_START = SEEK_SET, - WAPP_SEEK_CURRENT = SEEK_CUR, - WAPP_SEEK_END = SEEK_END, + 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_buf, File *file, u64 item_count); -u64 wapp_file_write(const GenericArray *src_buf, File *file, u64 item_count); -i32 wapp_file_flush(File *file); -i32 wapp_file_close(File *file); +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_buf, File *file, u64 item_count); +u64 wapp_file_write(const GenericArray *src_buf, File *file, u64 item_count); +i32 wapp_file_flush(File *file); +i32 wapp_file_close(File *file); #ifdef WAPP_PLATFORM_CPP END_C_LINKAGE diff --git a/src/os/shell/commander/commander.c b/src/os/shell/commander/commander.c index f7f2042..00845cd 100644 --- a/src/os/shell/commander/commander.c +++ b/src/os/shell/commander/commander.c @@ -21,81 +21,81 @@ wapp_intern inline CMDResult execute_command(Str8RO *cmd, CMDOutHandling out_han wapp_intern inline CMDError get_command_output(FILE *fp, CMDOutHandling out_handling, Str8 *out_buf); CMDResult wapp_shell_commander_execute(CMDOutHandling out_handling, Str8 *out_buf, const Str8List *cmd) { - if (!cmd) { - return CMD_NO_EXIT(SHELL_ERR_INVALID_ARGS); - } + if (!cmd) { + return CMD_NO_EXIT(SHELL_ERR_INVALID_ARGS); + } - Allocator arena = wapp_mem_arena_allocator_init(KiB(500)); + Allocator arena = wapp_mem_arena_allocator_init(KiB(500)); - Str8 *cmd_str = wapp_str8_join(&arena, cmd, &wapp_str8_lit_ro(" ")); - if (!cmd_str) { - wapp_mem_arena_allocator_destroy(&arena); - return CMD_NO_EXIT(SHELL_ERR_ALLOCATION_FAIL); - } + Str8 *cmd_str = wapp_str8_join(&arena, cmd, &wapp_str8_lit_ro(" ")); + if (!cmd_str) { + wapp_mem_arena_allocator_destroy(&arena); + return CMD_NO_EXIT(SHELL_ERR_ALLOCATION_FAIL); + } - // Redirect output - cmd_str = wapp_str8_alloc_concat(&arena, cmd_str, &wapp_str8_lit_ro(" 2>&1")); + // Redirect output + cmd_str = wapp_str8_alloc_concat(&arena, cmd_str, &wapp_str8_lit_ro(" 2>&1")); - CMDResult output = execute_command(cmd_str, out_handling, out_buf); + CMDResult output = execute_command(cmd_str, out_handling, out_buf); - wapp_mem_arena_allocator_destroy(&arena); + wapp_mem_arena_allocator_destroy(&arena); - return output; + return output; } wapp_intern inline CMDResult execute_command(Str8RO *cmd, CMDOutHandling out_handling, Str8 *out_buf) { - char cmd_buf[CMD_BUF_LEN] = {0}; - wapp_str8_copy_to_cstr(cmd_buf, cmd, CMD_BUF_LEN); + char cmd_buf[CMD_BUF_LEN] = {0}; + wapp_str8_copy_to_cstr(cmd_buf, cmd, CMD_BUF_LEN); - FILE *fp = wapp_shell_utils_popen(cmd_buf, "r"); - if (!fp) { - return CMD_NO_EXIT(SHELL_ERR_PROC_START_FAIL); - } + FILE *fp = wapp_shell_utils_popen(cmd_buf, "r"); + if (!fp) { + return CMD_NO_EXIT(SHELL_ERR_PROC_START_FAIL); + } - CMDResult output; + CMDResult output; - CMDError err = get_command_output(fp, out_handling, out_buf); - if (err > SHELL_ERR_NO_ERROR) { - output = CMD_NO_EXIT(err); - goto EXECUTE_COMMAND_CLOSE; - } + CMDError err = get_command_output(fp, out_handling, out_buf); + if (err > SHELL_ERR_NO_ERROR) { + output = CMD_NO_EXIT(err); + goto EXECUTE_COMMAND_CLOSE; + } - i32 st = EXIT_SUCCESS; - err = get_output_status(fp, &st); - if (err > SHELL_ERR_NO_ERROR) { - output = CMD_NO_EXIT(err); - goto EXECUTE_COMMAND_CLOSE; - } + i32 st = EXIT_SUCCESS; + err = get_output_status(fp, &st); + if (err > SHELL_ERR_NO_ERROR) { + output = CMD_NO_EXIT(err); + goto EXECUTE_COMMAND_CLOSE; + } - // Process is already closed in get_output_status - fp = NULL; + // Process is already closed in get_output_status + fp = NULL; - output = (CMDResult){ - .exited = true, - .exit_code = st, - .error = SHELL_ERR_NO_ERROR, - }; + output = (CMDResult){ + .exited = true, + .exit_code = st, + .error = SHELL_ERR_NO_ERROR, + }; EXECUTE_COMMAND_CLOSE: - if (fp) { - wapp_shell_utils_pclose(fp); - } - return output; + if (fp) { + wapp_shell_utils_pclose(fp); + } + return output; } wapp_intern inline CMDError get_command_output(FILE *fp, CMDOutHandling out_handling, Str8 *out_buf) { - Str8 out = wapp_str8_buf(OUT_BUF_LEN); + Str8 out = wapp_str8_buf(OUT_BUF_LEN); - out.size = fread((void *)out.buf, sizeof(u8), out.capacity, fp); - if (out_handling == SHELL_OUTPUT_CAPTURE && out_buf != NULL) { - if (out.size >= out_buf->capacity) { - return SHELL_ERR_OUT_BUF_FULL; - } + out.size = fread((void *)out.buf, sizeof(u8), out.capacity, fp); + if (out_handling == SHELL_OUTPUT_CAPTURE && out_buf != NULL) { + if (out.size >= out_buf->capacity) { + return SHELL_ERR_OUT_BUF_FULL; + } - wapp_str8_concat_capped(out_buf, &out); - } else if (out_handling == SHELL_OUTPUT_PRINT) { - printf(WAPP_STR8_SPEC, wapp_str8_varg(out)); - } + wapp_str8_concat_capped(out_buf, &out); + } else if (out_handling == SHELL_OUTPUT_PRINT) { + printf(WAPP_STR8_SPEC, wapp_str8_varg(out)); + } - return SHELL_ERR_NO_ERROR; + return SHELL_ERR_NO_ERROR; } diff --git a/src/os/shell/commander/commander_output.h b/src/os/shell/commander/commander_output.h index 1c914a3..7aed06a 100644 --- a/src/os/shell/commander/commander_output.h +++ b/src/os/shell/commander/commander_output.h @@ -11,29 +11,29 @@ BEGIN_C_LINKAGE #endif // !WAPP_PLATFORM_CPP typedef enum { - SHELL_OUTPUT_DISCARD, - SHELL_OUTPUT_PRINT, - SHELL_OUTPUT_CAPTURE, + SHELL_OUTPUT_DISCARD, + SHELL_OUTPUT_PRINT, + SHELL_OUTPUT_CAPTURE, } CMDOutHandling; typedef enum { - SHELL_ERR_NO_ERROR, - SHELL_ERR_INVALID_ARGS, - SHELL_ERR_ALLOCATION_FAIL, - SHELL_ERR_PROC_START_FAIL, - SHELL_ERR_OUT_BUF_FULL, - SHELL_ERR_PROC_EXIT_FAIL, + SHELL_ERR_NO_ERROR, + SHELL_ERR_INVALID_ARGS, + SHELL_ERR_ALLOCATION_FAIL, + SHELL_ERR_PROC_START_FAIL, + SHELL_ERR_OUT_BUF_FULL, + SHELL_ERR_PROC_EXIT_FAIL, } CMDError; typedef struct commander_result CMDResult; struct commander_result { - i32 exit_code; - CMDError error; - b8 exited; + i32 exit_code; + CMDError error; + b8 exited; #ifdef WAPP_PLATFORM_WINDOWS - #include "../../../../common/misc/misc_utils.h" - wapp_misc_utils_padding_size(sizeof(b8) + sizeof(i32) + sizeof(CMDError)); + #include "../../../../common/misc/misc_utils.h" + wapp_misc_utils_padding_size(sizeof(b8) + sizeof(i32) + sizeof(CMDError)); #endif // !WAPP_PLATFORM_WINDOWS }; diff --git a/src/os/shell/commander/posix/commander_posix.c b/src/os/shell/commander/posix/commander_posix.c index 06cd7c5..a25afb0 100644 --- a/src/os/shell/commander/posix/commander_posix.c +++ b/src/os/shell/commander/posix/commander_posix.c @@ -11,15 +11,15 @@ #include CMDError get_output_status(FILE *fp, i32 *status_out) { - *status_out = wapp_shell_utils_pclose(fp); + *status_out = wapp_shell_utils_pclose(fp); - if (!WIFEXITED(*status_out)) { - return SHELL_ERR_PROC_EXIT_FAIL; - } + if (!WIFEXITED(*status_out)) { + return SHELL_ERR_PROC_EXIT_FAIL; + } - *status_out = WEXITSTATUS(*status_out); + *status_out = WEXITSTATUS(*status_out); - return SHELL_ERR_NO_ERROR; + return SHELL_ERR_NO_ERROR; } #endif // !WAPP_PLATFORM_POSIX diff --git a/src/os/shell/commander/win/commander_win.c b/src/os/shell/commander/win/commander_win.c index d68611d..8be5df8 100644 --- a/src/os/shell/commander/win/commander_win.c +++ b/src/os/shell/commander/win/commander_win.c @@ -10,15 +10,15 @@ #include CMDError get_output_status(FILE *fp, i32 *status_out) { - if (!feof(fp)) { - // Ensure process is closed on failure - wapp_shell_utils_pclose(fp); - return SHELL_ERR_PROC_EXIT_FAIL; - } + if (!feof(fp)) { + // Ensure process is closed on failure + wapp_shell_utils_pclose(fp); + return SHELL_ERR_PROC_EXIT_FAIL; + } - *status_out = wapp_shell_utils_pclose(fp); + *status_out = wapp_shell_utils_pclose(fp); - return SHELL_ERR_NO_ERROR; + return SHELL_ERR_NO_ERROR; } #endif // !WAPP_PLATFORM_WINDOWS diff --git a/src/os/shell/termcolour/posix/termcolour_posix.c b/src/os/shell/termcolour/posix/termcolour_posix.c index 14af25e..8157773 100644 --- a/src/os/shell/termcolour/posix/termcolour_posix.c +++ b/src/os/shell/termcolour/posix/termcolour_posix.c @@ -10,27 +10,27 @@ #include wapp_intern Str8RO colours[COUNT_TERM_COLOUR] = { - [WAPP_TERM_COLOUR_FG_BLACK] = wapp_str8_lit_ro_initialiser_list("\033[30m"), - [WAPP_TERM_COLOUR_FG_RED] = wapp_str8_lit_ro_initialiser_list("\033[31m"), - [WAPP_TERM_COLOUR_FG_GREEN] = wapp_str8_lit_ro_initialiser_list("\033[32m"), - [WAPP_TERM_COLOUR_FG_BLUE] = wapp_str8_lit_ro_initialiser_list("\033[34m"), - [WAPP_TERM_COLOUR_FG_CYAN] = wapp_str8_lit_ro_initialiser_list("\033[36m"), - [WAPP_TERM_COLOUR_FG_MAGENTA] = wapp_str8_lit_ro_initialiser_list("\033[35m"), - [WAPP_TERM_COLOUR_FG_YELLOW] = wapp_str8_lit_ro_initialiser_list("\033[33m"), - [WAPP_TERM_COLOUR_FG_WHITE] = wapp_str8_lit_ro_initialiser_list("\033[37m"), - [WAPP_TERM_COLOUR_FG_BR_BLACK] = wapp_str8_lit_ro_initialiser_list("\033[90m"), - [WAPP_TERM_COLOUR_FG_BR_RED] = wapp_str8_lit_ro_initialiser_list("\033[91m"), - [WAPP_TERM_COLOUR_FG_BR_GREEN] = wapp_str8_lit_ro_initialiser_list("\033[92m"), - [WAPP_TERM_COLOUR_FG_BR_BLUE] = wapp_str8_lit_ro_initialiser_list("\033[94m"), - [WAPP_TERM_COLOUR_FG_BR_CYAN] = wapp_str8_lit_ro_initialiser_list("\033[96m"), - [WAPP_TERM_COLOUR_FG_BR_MAGENTA] = wapp_str8_lit_ro_initialiser_list("\033[95m"), - [WAPP_TERM_COLOUR_FG_BR_YELLOW] = wapp_str8_lit_ro_initialiser_list("\033[93m"), - [WAPP_TERM_COLOUR_FG_BR_WHITE] = wapp_str8_lit_ro_initialiser_list("\033[97m"), - [WAPP_TERM_COLOUR_CLEAR] = wapp_str8_lit_ro_initialiser_list("\033[0m"), + [WAPP_TERM_COLOUR_FG_BLACK] = wapp_str8_lit_ro_initialiser_list("\033[30m"), + [WAPP_TERM_COLOUR_FG_RED] = wapp_str8_lit_ro_initialiser_list("\033[31m"), + [WAPP_TERM_COLOUR_FG_GREEN] = wapp_str8_lit_ro_initialiser_list("\033[32m"), + [WAPP_TERM_COLOUR_FG_BLUE] = wapp_str8_lit_ro_initialiser_list("\033[34m"), + [WAPP_TERM_COLOUR_FG_CYAN] = wapp_str8_lit_ro_initialiser_list("\033[36m"), + [WAPP_TERM_COLOUR_FG_MAGENTA] = wapp_str8_lit_ro_initialiser_list("\033[35m"), + [WAPP_TERM_COLOUR_FG_YELLOW] = wapp_str8_lit_ro_initialiser_list("\033[33m"), + [WAPP_TERM_COLOUR_FG_WHITE] = wapp_str8_lit_ro_initialiser_list("\033[37m"), + [WAPP_TERM_COLOUR_FG_BR_BLACK] = wapp_str8_lit_ro_initialiser_list("\033[90m"), + [WAPP_TERM_COLOUR_FG_BR_RED] = wapp_str8_lit_ro_initialiser_list("\033[91m"), + [WAPP_TERM_COLOUR_FG_BR_GREEN] = wapp_str8_lit_ro_initialiser_list("\033[92m"), + [WAPP_TERM_COLOUR_FG_BR_BLUE] = wapp_str8_lit_ro_initialiser_list("\033[94m"), + [WAPP_TERM_COLOUR_FG_BR_CYAN] = wapp_str8_lit_ro_initialiser_list("\033[96m"), + [WAPP_TERM_COLOUR_FG_BR_MAGENTA] = wapp_str8_lit_ro_initialiser_list("\033[95m"), + [WAPP_TERM_COLOUR_FG_BR_YELLOW] = wapp_str8_lit_ro_initialiser_list("\033[93m"), + [WAPP_TERM_COLOUR_FG_BR_WHITE] = wapp_str8_lit_ro_initialiser_list("\033[97m"), + [WAPP_TERM_COLOUR_CLEAR] = wapp_str8_lit_ro_initialiser_list("\033[0m"), }; void print_coloured_text(Str8RO *text, TerminalColour colour) { - printf(WAPP_STR8_SPEC WAPP_STR8_SPEC, wapp_str8_varg(colours[colour]), wapp_str8_varg((*text))); + printf(WAPP_STR8_SPEC WAPP_STR8_SPEC, wapp_str8_varg(colours[colour]), wapp_str8_varg((*text))); } #endif // !WAPP_PLATFORM_POSIX diff --git a/src/os/shell/termcolour/termcolour.c b/src/os/shell/termcolour/termcolour.c index 56fcee0..9b5a566 100644 --- a/src/os/shell/termcolour/termcolour.c +++ b/src/os/shell/termcolour/termcolour.c @@ -5,14 +5,14 @@ #include "../../../base/strings/str8/str8.h" void wapp_shell_termcolour_print_text(Str8RO *text, TerminalColour colour) { - if (colour < WAPP_TERM_COLOUR_FG_BLACK || colour > WAPP_TERM_COLOUR_FG_BR_WHITE) { - return; - } + if (colour < WAPP_TERM_COLOUR_FG_BLACK || colour > WAPP_TERM_COLOUR_FG_BR_WHITE) { + return; + } - print_coloured_text(text, colour); + print_coloured_text(text, colour); } void wapp_shell_termcolour_clear_colour(void) { - Str8RO empty = wapp_str8_lit_ro(""); - print_coloured_text(&empty, WAPP_TERM_COLOUR_CLEAR); + Str8RO empty = wapp_str8_lit_ro(""); + print_coloured_text(&empty, WAPP_TERM_COLOUR_CLEAR); } diff --git a/src/os/shell/termcolour/terminal_colours.h b/src/os/shell/termcolour/terminal_colours.h index 1c0eaeb..8e864e6 100644 --- a/src/os/shell/termcolour/terminal_colours.h +++ b/src/os/shell/termcolour/terminal_colours.h @@ -11,25 +11,25 @@ BEGIN_C_LINKAGE #endif // !WAPP_PLATFORM_CPP typedef enum { - WAPP_TERM_COLOUR_FG_BLACK, - WAPP_TERM_COLOUR_FG_RED, - WAPP_TERM_COLOUR_FG_GREEN, - WAPP_TERM_COLOUR_FG_BLUE, - WAPP_TERM_COLOUR_FG_CYAN, - WAPP_TERM_COLOUR_FG_MAGENTA, - WAPP_TERM_COLOUR_FG_YELLOW, - WAPP_TERM_COLOUR_FG_WHITE, - WAPP_TERM_COLOUR_FG_BR_BLACK, - WAPP_TERM_COLOUR_FG_BR_RED, - WAPP_TERM_COLOUR_FG_BR_GREEN, - WAPP_TERM_COLOUR_FG_BR_BLUE, - WAPP_TERM_COLOUR_FG_BR_CYAN, - WAPP_TERM_COLOUR_FG_BR_MAGENTA, - WAPP_TERM_COLOUR_FG_BR_YELLOW, - WAPP_TERM_COLOUR_FG_BR_WHITE, - WAPP_TERM_COLOUR_CLEAR, + WAPP_TERM_COLOUR_FG_BLACK, + WAPP_TERM_COLOUR_FG_RED, + WAPP_TERM_COLOUR_FG_GREEN, + WAPP_TERM_COLOUR_FG_BLUE, + WAPP_TERM_COLOUR_FG_CYAN, + WAPP_TERM_COLOUR_FG_MAGENTA, + WAPP_TERM_COLOUR_FG_YELLOW, + WAPP_TERM_COLOUR_FG_WHITE, + WAPP_TERM_COLOUR_FG_BR_BLACK, + WAPP_TERM_COLOUR_FG_BR_RED, + WAPP_TERM_COLOUR_FG_BR_GREEN, + WAPP_TERM_COLOUR_FG_BR_BLUE, + WAPP_TERM_COLOUR_FG_BR_CYAN, + WAPP_TERM_COLOUR_FG_BR_MAGENTA, + WAPP_TERM_COLOUR_FG_BR_YELLOW, + WAPP_TERM_COLOUR_FG_BR_WHITE, + WAPP_TERM_COLOUR_CLEAR, - COUNT_TERM_COLOUR, + COUNT_TERM_COLOUR, } TerminalColour; #ifdef WAPP_PLATFORM_CPP diff --git a/src/os/shell/termcolour/win/termcolour_win.c b/src/os/shell/termcolour/win/termcolour_win.c index 7fb7fce..0ec6f62 100644 --- a/src/os/shell/termcolour/win/termcolour_win.c +++ b/src/os/shell/termcolour/win/termcolour_win.c @@ -15,59 +15,59 @@ typedef struct termcolour_data TermcolourData; struct termcolour_data { - HANDLE handle; - WORD default_colour; - WORD current_colour; + HANDLE handle; + WORD default_colour; + WORD current_colour; - wapp_misc_utils_padding_size(sizeof(HANDLE) + sizeof(WORD) + sizeof(WORD)); + wapp_misc_utils_padding_size(sizeof(HANDLE) + sizeof(WORD) + sizeof(WORD)); }; wapp_intern void init_data(TermcolourData *data); wapp_intern WORD colours[COUNT_TERM_COLOUR] = { - [WAPP_TERM_COLOUR_FG_BLACK] = 0, - [WAPP_TERM_COLOUR_FG_RED] = FOREGROUND_RED, - [WAPP_TERM_COLOUR_FG_GREEN] = FOREGROUND_GREEN, - [WAPP_TERM_COLOUR_FG_BLUE] = FOREGROUND_BLUE, - [WAPP_TERM_COLOUR_FG_CYAN] = FOREGROUND_GREEN | FOREGROUND_BLUE, - [WAPP_TERM_COLOUR_FG_MAGENTA] = FOREGROUND_RED | FOREGROUND_BLUE, - [WAPP_TERM_COLOUR_FG_YELLOW] = FOREGROUND_RED | FOREGROUND_GREEN, - [WAPP_TERM_COLOUR_FG_WHITE] = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE, - [WAPP_TERM_COLOUR_FG_BR_BLACK] = FOREGROUND_INTENSITY, - [WAPP_TERM_COLOUR_FG_BR_RED] = FOREGROUND_RED | FOREGROUND_INTENSITY, - [WAPP_TERM_COLOUR_FG_BR_GREEN] = FOREGROUND_GREEN | FOREGROUND_INTENSITY, - [WAPP_TERM_COLOUR_FG_BR_BLUE] = FOREGROUND_BLUE | FOREGROUND_INTENSITY, - [WAPP_TERM_COLOUR_FG_BR_CYAN] = FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_INTENSITY, - [WAPP_TERM_COLOUR_FG_BR_MAGENTA] = FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_INTENSITY, - [WAPP_TERM_COLOUR_FG_BR_YELLOW] = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY, - [WAPP_TERM_COLOUR_FG_BR_WHITE] = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_INTENSITY, + [WAPP_TERM_COLOUR_FG_BLACK] = 0, + [WAPP_TERM_COLOUR_FG_RED] = FOREGROUND_RED, + [WAPP_TERM_COLOUR_FG_GREEN] = FOREGROUND_GREEN, + [WAPP_TERM_COLOUR_FG_BLUE] = FOREGROUND_BLUE, + [WAPP_TERM_COLOUR_FG_CYAN] = FOREGROUND_GREEN | FOREGROUND_BLUE, + [WAPP_TERM_COLOUR_FG_MAGENTA] = FOREGROUND_RED | FOREGROUND_BLUE, + [WAPP_TERM_COLOUR_FG_YELLOW] = FOREGROUND_RED | FOREGROUND_GREEN, + [WAPP_TERM_COLOUR_FG_WHITE] = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE, + [WAPP_TERM_COLOUR_FG_BR_BLACK] = FOREGROUND_INTENSITY, + [WAPP_TERM_COLOUR_FG_BR_RED] = FOREGROUND_RED | FOREGROUND_INTENSITY, + [WAPP_TERM_COLOUR_FG_BR_GREEN] = FOREGROUND_GREEN | FOREGROUND_INTENSITY, + [WAPP_TERM_COLOUR_FG_BR_BLUE] = FOREGROUND_BLUE | FOREGROUND_INTENSITY, + [WAPP_TERM_COLOUR_FG_BR_CYAN] = FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_INTENSITY, + [WAPP_TERM_COLOUR_FG_BR_MAGENTA] = FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_INTENSITY, + [WAPP_TERM_COLOUR_FG_BR_YELLOW] = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY, + [WAPP_TERM_COLOUR_FG_BR_WHITE] = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_INTENSITY, }; void print_coloured_text(Str8RO *text, TerminalColour colour) { - wapp_persist TermcolourData data = {0}; - if (data.handle == 0) { - init_data(&data); - } + wapp_persist TermcolourData data = {0}; + if (data.handle == 0) { + init_data(&data); + } - if (colour == WAPP_TERM_COLOUR_CLEAR) { - data.current_colour = data.default_colour; - } else { - data.current_colour = colours[colour]; - } + if (colour == WAPP_TERM_COLOUR_CLEAR) { + data.current_colour = data.default_colour; + } else { + data.current_colour = colours[colour]; + } - SetConsoleTextAttribute(data.handle, data.current_colour); - printf(WAPP_STR8_SPEC, wapp_str8_varg((*text))); + SetConsoleTextAttribute(data.handle, data.current_colour); + printf(WAPP_STR8_SPEC, wapp_str8_varg((*text))); } wapp_intern void init_data(TermcolourData *data) { - // create handle - data->handle = GetStdHandle(STD_OUTPUT_HANDLE); + // create handle + data->handle = GetStdHandle(STD_OUTPUT_HANDLE); - // get console colour information - CONSOLE_SCREEN_BUFFER_INFO csbi; - GetConsoleScreenBufferInfo(data->handle, &csbi); - data->default_colour = csbi.wAttributes; - data->current_colour = data->default_colour; + // get console colour information + CONSOLE_SCREEN_BUFFER_INFO csbi; + GetConsoleScreenBufferInfo(data->handle, &csbi); + data->default_colour = csbi.wAttributes; + data->current_colour = data->default_colour; } #endif // !WAPP_PLATFORM_WINDOWS diff --git a/src/os/shell/utils/shell_utils.h b/src/os/shell/utils/shell_utils.h index 7ee387f..41ca649 100644 --- a/src/os/shell/utils/shell_utils.h +++ b/src/os/shell/utils/shell_utils.h @@ -12,11 +12,11 @@ BEGIN_C_LINKAGE #endif // !WAPP_PLATFORM_CPP #ifdef WAPP_PLATFORM_WINDOWS - #define wapp_shell_utils_popen _popen - #define wapp_shell_utils_pclose _pclose + #define wapp_shell_utils_popen _popen + #define wapp_shell_utils_pclose _pclose #else - #define wapp_shell_utils_popen popen - #define wapp_shell_utils_pclose pclose + #define wapp_shell_utils_popen popen + #define wapp_shell_utils_pclose pclose #endif /* ifdef WAPP_PLATFORM_WINDOWS */ #ifdef WAPP_PLATFORM_CPP -- 2.39.5 From 3efeef13c63a889c61a5b43dbef711586bbc5735 Mon Sep 17 00:00:00 2001 From: Abdelrahman Said Date: Mon, 29 Dec 2025 22:39:52 +0000 Subject: [PATCH 8/9] Reformat tests --- tests/allocator/test_allocator.c | 18 +- tests/allocator/test_allocator.cc | 18 +- tests/arena/test_arena.c | 130 +-- tests/arena/test_arena.cc | 130 +-- tests/array/test_i32_array.c | 334 ++++---- tests/array/test_i32_array.cc | 340 ++++---- tests/array/test_str8_array.c | 30 +- tests/array/test_str8_array.cc | 36 +- tests/cpath/test_cpath.c | 232 ++--- tests/cpath/test_cpath.cc | 258 +++--- tests/shell_commander/test_shell_commander.c | 70 +- tests/shell_commander/test_shell_commander.cc | 84 +- tests/str8/test_str8.c | 806 ++++++++--------- tests/str8/test_str8.cc | 810 +++++++++--------- tests/str8/test_str8_list.c | 360 ++++---- tests/str8/test_str8_list.cc | 368 ++++---- tests/wapptest.c | 132 +-- tests/wapptest.cc | 132 +-- 18 files changed, 2144 insertions(+), 2144 deletions(-) diff --git a/tests/allocator/test_allocator.c b/tests/allocator/test_allocator.c index 6fbb40d..b70f6bc 100644 --- a/tests/allocator/test_allocator.c +++ b/tests/allocator/test_allocator.c @@ -3,15 +3,15 @@ #include TestFuncResult test_arena_allocator(void) { - Allocator allocator = wapp_mem_arena_allocator_init(4096); - b8 result = allocator.obj != NULL && allocator.alloc != NULL && - allocator.alloc_aligned != NULL && - allocator.realloc != NULL && allocator.realloc_aligned != NULL && - allocator.free == NULL; - void *ptr = wapp_mem_allocator_alloc(&allocator, 20); - result = result && (ptr != NULL); + Allocator allocator = wapp_mem_arena_allocator_init(4096); + b8 result = allocator.obj != NULL && allocator.alloc != NULL && + allocator.alloc_aligned != NULL && + allocator.realloc != NULL && allocator.realloc_aligned != NULL && + allocator.free == NULL; + void *ptr = wapp_mem_allocator_alloc(&allocator, 20); + result = result && (ptr != NULL); - wapp_mem_arena_allocator_destroy(&allocator); + wapp_mem_arena_allocator_destroy(&allocator); - return wapp_tester_result(result); + return wapp_tester_result(result); } diff --git a/tests/allocator/test_allocator.cc b/tests/allocator/test_allocator.cc index 0a71579..2045eb7 100644 --- a/tests/allocator/test_allocator.cc +++ b/tests/allocator/test_allocator.cc @@ -3,15 +3,15 @@ #include TestFuncResult test_arena_allocator(void) { - Allocator allocator = wapp_mem_arena_allocator_init(4096); - b8 result = allocator.obj != nullptr && allocator.alloc != nullptr && - allocator.alloc_aligned != nullptr && - allocator.realloc != nullptr && allocator.realloc_aligned != nullptr && - allocator.free == nullptr; - void *ptr = wapp_mem_allocator_alloc(&allocator, 20); - result = result && (ptr != nullptr); + Allocator allocator = wapp_mem_arena_allocator_init(4096); + b8 result = allocator.obj != nullptr && allocator.alloc != nullptr && + allocator.alloc_aligned != nullptr && + allocator.realloc != nullptr && allocator.realloc_aligned != nullptr && + allocator.free == nullptr; + void *ptr = wapp_mem_allocator_alloc(&allocator, 20); + result = result && (ptr != nullptr); - wapp_mem_arena_allocator_destroy(&allocator); + wapp_mem_arena_allocator_destroy(&allocator); - return wapp_tester_result(result); + return wapp_tester_result(result); } diff --git a/tests/arena/test_arena.c b/tests/arena/test_arena.c index 9fea642..22fe14c 100644 --- a/tests/arena/test_arena.c +++ b/tests/arena/test_arena.c @@ -4,108 +4,108 @@ #define ARENA_CAPACITY KiB(16) -wapp_intern Arena *arena = NULL; -wapp_intern i32 count = 20; -wapp_intern i32 *array = NULL; +wapp_intern Arena *arena = NULL; +wapp_intern i32 count = 20; +wapp_intern i32 *array = NULL; TestFuncResult test_arena_init(void) { - b8 result = wapp_mem_arena_init(&arena, ARENA_CAPACITY); + b8 result = wapp_mem_arena_init(&arena, ARENA_CAPACITY); - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_arena_init_succeeds_when_reserving_very_large_size(void) { - Arena *large_arena = NULL; - u64 capacity = GiB(512); - b8 result = wapp_mem_arena_init(&large_arena, capacity); - if (result) { - wapp_mem_arena_destroy(&large_arena); - } + Arena *large_arena = NULL; + u64 capacity = GiB(512); + b8 result = wapp_mem_arena_init(&large_arena, capacity); + if (result) { + wapp_mem_arena_destroy(&large_arena); + } - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_arena_alloc_succeeds_when_within_capacity(void) { - array = wapp_mem_arena_alloc(arena, count * sizeof(i32)); - b8 result = array != NULL; + array = wapp_mem_arena_alloc(arena, count * sizeof(i32)); + b8 result = array != NULL; - for (i32 i = 0; i < count; ++i) { - array[i] = i * 10; - } + for (i32 i = 0; i < count; ++i) { + array[i] = i * 10; + } - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_arena_alloc_fails_when_over_capacity(void) { - u8 *bytes = wapp_mem_arena_alloc(arena, ARENA_CAPACITY * 2); - b8 result = bytes == NULL; + u8 *bytes = wapp_mem_arena_alloc(arena, ARENA_CAPACITY * 2); + b8 result = bytes == NULL; - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_arena_realloc_bigger_size(void) { - u64 old_count = 10; - u64 new_count = 20; - i32 *bytes = wapp_mem_arena_alloc(arena, old_count * sizeof(i32)); + u64 old_count = 10; + u64 new_count = 20; + i32 *bytes = wapp_mem_arena_alloc(arena, old_count * sizeof(i32)); - for (u64 i = 0; i < old_count; ++i) { - bytes[i] = (i32)i; - } + for (u64 i = 0; i < old_count; ++i) { + bytes[i] = (i32)i; + } - i32 *new_bytes = wapp_mem_arena_realloc(arena, bytes, old_count * sizeof(i32), new_count * sizeof(i32)); - if (!new_bytes) { - return wapp_tester_result(false); - } + i32 *new_bytes = wapp_mem_arena_realloc(arena, bytes, old_count * sizeof(i32), new_count * sizeof(i32)); + if (!new_bytes) { + return wapp_tester_result(false); + } - for (u64 i = 0; i < new_count; ++i) { - if (i < old_count && new_bytes[i] != bytes[i]) { - return wapp_tester_result(false); - } - } + for (u64 i = 0; i < new_count; ++i) { + if (i < old_count && new_bytes[i] != bytes[i]) { + return wapp_tester_result(false); + } + } - return wapp_tester_result(true); + return wapp_tester_result(true); } TestFuncResult test_arena_realloc_smaller_size(void) { - u64 old_count = 10; - u64 new_count = 5; - i32 *bytes = wapp_mem_arena_alloc(arena, old_count * sizeof(i32)); + u64 old_count = 10; + u64 new_count = 5; + i32 *bytes = wapp_mem_arena_alloc(arena, old_count * sizeof(i32)); - for (u64 i = 0; i < old_count; ++i) { - bytes[i] = (i32)i; - } + for (u64 i = 0; i < old_count; ++i) { + bytes[i] = (i32)i; + } - i32 *new_bytes = wapp_mem_arena_realloc(arena, bytes, old_count * sizeof(i32), new_count * sizeof(i32)); - if (!new_bytes) { - return wapp_tester_result(false); - } + i32 *new_bytes = wapp_mem_arena_realloc(arena, bytes, old_count * sizeof(i32), new_count * sizeof(i32)); + if (!new_bytes) { + return wapp_tester_result(false); + } - for (u64 i = 0; i < new_count; ++i) { - if (i < new_count && new_bytes[i] != bytes[i]) { - return wapp_tester_result(false); - } - } + for (u64 i = 0; i < new_count; ++i) { + if (i < new_count && new_bytes[i] != bytes[i]) { + return wapp_tester_result(false); + } + } - return wapp_tester_result(true); + return wapp_tester_result(true); } TestFuncResult test_arena_clear(void) { - wapp_mem_arena_clear(arena); - b8 result = true; + wapp_mem_arena_clear(arena); + b8 result = true; - for (i32 i = 0; i < count; ++i) { - if (array[i] != 0) { - result = false; - break; - } - } + for (i32 i = 0; i < count; ++i) { + if (array[i] != 0) { + result = false; + break; + } + } - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_arena_destroy(void) { - wapp_mem_arena_destroy(&arena); - b8 result = arena == NULL; + wapp_mem_arena_destroy(&arena); + b8 result = arena == NULL; - return wapp_tester_result(result); + return wapp_tester_result(result); } diff --git a/tests/arena/test_arena.cc b/tests/arena/test_arena.cc index a3e0a2e..1a1c0e4 100644 --- a/tests/arena/test_arena.cc +++ b/tests/arena/test_arena.cc @@ -4,108 +4,108 @@ #define ARENA_CAPACITY KiB(16) -wapp_intern Arena *arena = nullptr; -wapp_intern i32 count = 20; -wapp_intern i32 *array = nullptr; +wapp_intern Arena *arena = nullptr; +wapp_intern i32 count = 20; +wapp_intern i32 *array = nullptr; TestFuncResult test_arena_init(void) { - b8 result = wapp_mem_arena_init(&arena, ARENA_CAPACITY); + b8 result = wapp_mem_arena_init(&arena, ARENA_CAPACITY); - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_arena_init_succeeds_when_reserving_very_large_size(void) { - Arena *large_arena = nullptr; - u64 capacity = GiB(512); - b8 result = wapp_mem_arena_init(&large_arena, capacity); - if (result) { - wapp_mem_arena_destroy(&large_arena); - } + Arena *large_arena = nullptr; + u64 capacity = GiB(512); + b8 result = wapp_mem_arena_init(&large_arena, capacity); + if (result) { + wapp_mem_arena_destroy(&large_arena); + } - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_arena_alloc_succeeds_when_within_capacity(void) { - array = (i32 *)wapp_mem_arena_alloc(arena, count * sizeof(i32)); - b8 result = array != nullptr; + array = (i32 *)wapp_mem_arena_alloc(arena, count * sizeof(i32)); + b8 result = array != nullptr; - for (i32 i = 0; i < count; ++i) { - array[i] = i * 10; - } + for (i32 i = 0; i < count; ++i) { + array[i] = i * 10; + } - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_arena_alloc_fails_when_over_capacity(void) { - u8 *bytes = (u8 *)wapp_mem_arena_alloc(arena, ARENA_CAPACITY * 2); - b8 result = bytes == nullptr; + u8 *bytes = (u8 *)wapp_mem_arena_alloc(arena, ARENA_CAPACITY * 2); + b8 result = bytes == nullptr; - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_arena_realloc_bigger_size(void) { - u64 old_count = 10; - u64 new_count = 20; - i32 *bytes = (i32 *)wapp_mem_arena_alloc(arena, old_count * sizeof(i32)); + u64 old_count = 10; + u64 new_count = 20; + i32 *bytes = (i32 *)wapp_mem_arena_alloc(arena, old_count * sizeof(i32)); - for (u64 i = 0; i < old_count; ++i) { - bytes[i] = (i32)i; - } + for (u64 i = 0; i < old_count; ++i) { + bytes[i] = (i32)i; + } - i32 *new_bytes = (i32 *)wapp_mem_arena_realloc(arena, bytes, old_count * sizeof(i32), new_count * sizeof(i32)); - if (!new_bytes) { - return wapp_tester_result(false); - } + i32 *new_bytes = (i32 *)wapp_mem_arena_realloc(arena, bytes, old_count * sizeof(i32), new_count * sizeof(i32)); + if (!new_bytes) { + return wapp_tester_result(false); + } - for (u64 i = 0; i < new_count; ++i) { - if (i < old_count && new_bytes[i] != bytes[i]) { - return wapp_tester_result(false); - } - } + for (u64 i = 0; i < new_count; ++i) { + if (i < old_count && new_bytes[i] != bytes[i]) { + return wapp_tester_result(false); + } + } - return wapp_tester_result(true); + return wapp_tester_result(true); } TestFuncResult test_arena_realloc_smaller_size(void) { - u64 old_count = 10; - u64 new_count = 5; - i32 *bytes = (i32 *)wapp_mem_arena_alloc(arena, old_count * sizeof(i32)); + u64 old_count = 10; + u64 new_count = 5; + i32 *bytes = (i32 *)wapp_mem_arena_alloc(arena, old_count * sizeof(i32)); - for (u64 i = 0; i < old_count; ++i) { - bytes[i] = (i32)i; - } + for (u64 i = 0; i < old_count; ++i) { + bytes[i] = (i32)i; + } - i32 *new_bytes = (i32 *)wapp_mem_arena_realloc(arena, bytes, old_count * sizeof(i32), new_count * sizeof(i32)); - if (!new_bytes) { - return wapp_tester_result(false); - } + i32 *new_bytes = (i32 *)wapp_mem_arena_realloc(arena, bytes, old_count * sizeof(i32), new_count * sizeof(i32)); + if (!new_bytes) { + return wapp_tester_result(false); + } - for (u64 i = 0; i < new_count; ++i) { - if (i < new_count && new_bytes[i] != bytes[i]) { - return wapp_tester_result(false); - } - } + for (u64 i = 0; i < new_count; ++i) { + if (i < new_count && new_bytes[i] != bytes[i]) { + return wapp_tester_result(false); + } + } - return wapp_tester_result(true); + return wapp_tester_result(true); } TestFuncResult test_arena_clear(void) { - wapp_mem_arena_clear(arena); - b8 result = true; + wapp_mem_arena_clear(arena); + b8 result = true; - for (i32 i = 0; i < count; ++i) { - if (array[i] != 0) { - result = false; - break; - } - } + for (i32 i = 0; i < count; ++i) { + if (array[i] != 0) { + result = false; + break; + } + } - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_arena_destroy(void) { - wapp_mem_arena_destroy(&arena); - b8 result = arena == nullptr; + wapp_mem_arena_destroy(&arena); + b8 result = arena == nullptr; - return wapp_tester_result(result); + return wapp_tester_result(result); } diff --git a/tests/array/test_i32_array.c b/tests/array/test_i32_array.c index 450de1d..46ee525 100644 --- a/tests/array/test_i32_array.c +++ b/tests/array/test_i32_array.c @@ -2,272 +2,272 @@ #include "wapp.h" TestFuncResult test_i32_array(void) { - b8 result; + b8 result; - I32Array array = wapp_array(i32, I32Array, 1, 2, 3, 4, 5, 6, 7); - result = array.count == 7 && array.capacity == 16; + I32Array array = wapp_array(i32, I32Array, 1, 2, 3, 4, 5, 6, 7); + result = array.count == 7 && array.capacity == 16; - i32 *item; - u64 count = array.count; - u64 index = 0; - b8 running = true; - while (running) { - item = wapp_array_get(i32, &array, index); - result = result && item && *item == (i32)(index + 1); + i32 *item; + u64 count = array.count; + u64 index = 0; + b8 running = true; + while (running) { + item = wapp_array_get(i32, &array, index); + result = result && item && *item == (i32)(index + 1); - ++index; - running = index < count; - } + ++index; + running = index < count; + } - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_i32_array_with_capacity(void) { - b8 result; + b8 result; - I32Array array1 = wapp_array_with_capacity(i32, I32Array, 64, false); - result = array1.count == 0 && array1.capacity == 64; + I32Array array1 = wapp_array_with_capacity(i32, I32Array, 64, false); + result = array1.count == 0 && array1.capacity == 64; - I32Array array2 = wapp_array_with_capacity(i32, I32Array, 64, true); - result = array2.count == 64 && array2.capacity == 64; + I32Array array2 = wapp_array_with_capacity(i32, I32Array, 64, true); + result = array2.count == 64 && array2.capacity == 64; - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_i32_array_get(void) { - b8 result = true; + b8 result = true; - I32Array array = wapp_array(i32, I32Array, 0, 1, 2, 3, 4, 5, 6, 7, 8); + I32Array array = wapp_array(i32, I32Array, 0, 1, 2, 3, 4, 5, 6, 7, 8); - i32 *item; - u64 count = array.count; - u64 index = 0; - b8 running = true; - while (running) { - item = wapp_array_get(i32, &array, index); - result = result && item && *item == (i32)index; + i32 *item; + u64 count = array.count; + u64 index = 0; + b8 running = true; + while (running) { + item = wapp_array_get(i32, &array, index); + result = result && item && *item == (i32)index; - ++index; - running = index < count; - } + ++index; + running = index < count; + } - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_i32_array_set(void) { - b8 result = true; + b8 result = true; - I32Array array = wapp_array(i32, I32Array, 0, 1, 2, 3, 4, 5, 6, 7, 8); + I32Array array = wapp_array(i32, I32Array, 0, 1, 2, 3, 4, 5, 6, 7, 8); - i32 *item; - u64 count = array.count; - u64 index = 0; - b8 running = true; - while (running) { - i32 num = (i32)(index * 2); - wapp_array_set(i32, &array, index, &num); - item = wapp_array_get(i32, &array, index); - result = result && item && *item == (i32)(index * 2); + i32 *item; + u64 count = array.count; + u64 index = 0; + b8 running = true; + while (running) { + i32 num = (i32)(index * 2); + wapp_array_set(i32, &array, index, &num); + item = wapp_array_get(i32, &array, index); + result = result && item && *item == (i32)(index * 2); - ++index; - running = index < count; - } + ++index; + running = index < count; + } - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_i32_array_append_capped(void) { - b8 result; + b8 result; - I32Array array = wapp_array_with_capacity(i32, I32Array, 64, false); - wapp_array_append_capped(i32, &array, &((i32){10})); + I32Array array = wapp_array_with_capacity(i32, I32Array, 64, false); + wapp_array_append_capped(i32, &array, &((i32){10})); - result = array.count == 1; - i32 *item = wapp_array_get(i32, &array, 0); - result = result && item && *item == 10; + result = array.count == 1; + i32 *item = wapp_array_get(i32, &array, 0); + result = result && item && *item == 10; - array = wapp_array(i32, I32Array, 1); - wapp_array_append_capped(i32, &array, &((i32){10})); + array = wapp_array(i32, I32Array, 1); + wapp_array_append_capped(i32, &array, &((i32){10})); - result = result && array.count == 2; + result = result && array.count == 2; - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_i32_array_extend_capped(void) { - b8 result; + b8 result; - I32Array array1 = wapp_array(i32, I32Array, 1, 2, 3, 4); - I32Array array2 = wapp_array(i32, I32Array, 10, 20); + I32Array array1 = wapp_array(i32, I32Array, 1, 2, 3, 4); + I32Array array2 = wapp_array(i32, I32Array, 10, 20); - result = array1.count == 4 && array2.count == 2; + result = array1.count == 4 && array2.count == 2; - wapp_array_extend_capped(i32, &array1, &array2); + wapp_array_extend_capped(i32, &array1, &array2); - result = result && array1.count == 6; + result = result && array1.count == 6; - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_i32_array_copy_capped(void) { - b8 result; + b8 result; - I32Array src = wapp_array(i32, I32Array, 1, 2, 3, 4, 5); - I32Array dst1 = wapp_array(i32, I32Array, 1, 2, 3, 4, 5, 6); - I32Array dst2 = wapp_array(i32, I32Array, 1, 2); + I32Array src = wapp_array(i32, I32Array, 1, 2, 3, 4, 5); + I32Array dst1 = wapp_array(i32, I32Array, 1, 2, 3, 4, 5, 6); + I32Array dst2 = wapp_array(i32, I32Array, 1, 2); - u64 expected_count = 5; - wapp_array_copy_capped(i32, &dst1, &src); - result = dst1.count == expected_count; + u64 expected_count = 5; + wapp_array_copy_capped(i32, &dst1, &src); + result = dst1.count == expected_count; - u64 index = 0; - b8 running = true; - while (running) { - result = result && *wapp_array_get(i32, &src, index) == *wapp_array_get(i32, &dst1, index); + u64 index = 0; + b8 running = true; + while (running) { + result = result && *wapp_array_get(i32, &src, index) == *wapp_array_get(i32, &dst1, index); - ++index; - running = index < expected_count; - } + ++index; + running = index < expected_count; + } - expected_count = 4; - wapp_array_copy_capped(i32, &dst2, &src); - result = result && dst2.count == expected_count; + expected_count = 4; + wapp_array_copy_capped(i32, &dst2, &src); + result = result && dst2.count == expected_count; - index = 0; - running = true; - while (running) { - result = result && *wapp_array_get(i32, &src, index) == *wapp_array_get(i32, &dst2, index); + index = 0; + running = true; + while (running) { + result = result && *wapp_array_get(i32, &src, index) == *wapp_array_get(i32, &dst2, index); - ++index; - running = index < expected_count; - } + ++index; + running = index < expected_count; + } - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_i32_array_alloc_capacity(void) { - b8 result; + b8 result; - Allocator allocator = wapp_mem_arena_allocator_init(MiB(4)); - u64 capacity = 32; - I32Array *array = wapp_array_alloc_capacity(i32, I32Array, &allocator, capacity, false); + Allocator allocator = wapp_mem_arena_allocator_init(MiB(4)); + u64 capacity = 32; + I32Array *array = wapp_array_alloc_capacity(i32, I32Array, &allocator, capacity, false); - result = array && array->capacity == capacity; + result = array && array->capacity == capacity; - wapp_mem_arena_allocator_destroy(&allocator); + wapp_mem_arena_allocator_destroy(&allocator); - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_i32_array_append_alloc(void) { - b8 result; + b8 result; - Allocator allocator = wapp_mem_arena_allocator_init(MiB(4)); - I32Array array1 = wapp_array(i32, I32Array, 1, 2, 3, 4, 5, 6, 7, 8); - I32Array array2 = wapp_array(i32, I32Array, 1, 2); + Allocator allocator = wapp_mem_arena_allocator_init(MiB(4)); + I32Array array1 = wapp_array(i32, I32Array, 1, 2, 3, 4, 5, 6, 7, 8); + I32Array array2 = wapp_array(i32, I32Array, 1, 2); - I32Array *arr_ptr = wapp_array_append_alloc(i32, I32Array, &allocator, &array1, &((i32){10})); - result = arr_ptr == &array1; + I32Array *arr_ptr = wapp_array_append_alloc(i32, I32Array, &allocator, &array1, &((i32){10})); + result = arr_ptr == &array1; - u64 count = 4; - u64 index = 0; - b8 running = true; - while (running) { - i32 num = (i32)index; - arr_ptr = wapp_array_append_alloc(i32, I32Array, &allocator, &array2, &num); + u64 count = 4; + u64 index = 0; + b8 running = true; + while (running) { + i32 num = (i32)index; + arr_ptr = wapp_array_append_alloc(i32, I32Array, &allocator, &array2, &num); - ++index; - running = index < count; - } - result = result && arr_ptr != &array2; + ++index; + running = index < count; + } + result = result && arr_ptr != &array2; - wapp_mem_arena_allocator_destroy(&allocator); + wapp_mem_arena_allocator_destroy(&allocator); - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_i32_array_extend_alloc(void) { - b8 result; + b8 result; - Allocator allocator = wapp_mem_arena_allocator_init(MiB(4)); - I32Array array1 = wapp_array(i32, I32Array, 1, 2, 3, 4, 5, 6, 7, 8); - I32Array array2 = wapp_array(i32, I32Array, 1, 2); - I32Array array3 = wapp_array(i32, I32Array, 1, 2, 3, 4); + Allocator allocator = wapp_mem_arena_allocator_init(MiB(4)); + I32Array array1 = wapp_array(i32, I32Array, 1, 2, 3, 4, 5, 6, 7, 8); + I32Array array2 = wapp_array(i32, I32Array, 1, 2); + I32Array array3 = wapp_array(i32, I32Array, 1, 2, 3, 4); - I32Array *arr_ptr = wapp_array_extend_alloc(i32, I32Array, &allocator, &array1, &array3); - result = arr_ptr == &array1; + I32Array *arr_ptr = wapp_array_extend_alloc(i32, I32Array, &allocator, &array1, &array3); + result = arr_ptr == &array1; - arr_ptr = wapp_array_extend_alloc(i32, I32Array, &allocator, &array2, &array3); - result = result && arr_ptr != &array2; + arr_ptr = wapp_array_extend_alloc(i32, I32Array, &allocator, &array2, &array3); + result = result && arr_ptr != &array2; - wapp_mem_arena_allocator_destroy(&allocator); + wapp_mem_arena_allocator_destroy(&allocator); - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_i32_array_copy_alloc(void) { - b8 result; + b8 result; - Allocator allocator = wapp_mem_arena_allocator_init(MiB(4)); - I32Array src = wapp_array(i32, I32Array, 1, 2, 3, 4, 5); - I32Array dst1 = wapp_array(i32, I32Array, 1, 2, 3, 4, 5, 6); - I32Array dst2 = wapp_array(i32, I32Array, 1, 2); - I32Array *array_ptr = NULL; + Allocator allocator = wapp_mem_arena_allocator_init(MiB(4)); + I32Array src = wapp_array(i32, I32Array, 1, 2, 3, 4, 5); + I32Array dst1 = wapp_array(i32, I32Array, 1, 2, 3, 4, 5, 6); + I32Array dst2 = wapp_array(i32, I32Array, 1, 2); + I32Array *array_ptr = NULL; - u64 expected_count = 5; - array_ptr = wapp_array_copy_alloc(i32, I32Array, &allocator, &dst1, &src); - result = array_ptr->count == expected_count && array_ptr == &dst1; + u64 expected_count = 5; + array_ptr = wapp_array_copy_alloc(i32, I32Array, &allocator, &dst1, &src); + result = array_ptr->count == expected_count && array_ptr == &dst1; - u64 index = 0; - b8 running = true; - while (running) { - result = result && *wapp_array_get(i32, &src, index) == *wapp_array_get(i32, array_ptr, index); + u64 index = 0; + b8 running = true; + while (running) { + result = result && *wapp_array_get(i32, &src, index) == *wapp_array_get(i32, array_ptr, index); - ++index; - running = index < expected_count; - } + ++index; + running = index < expected_count; + } - expected_count = 5; - array_ptr = wapp_array_copy_alloc(i32, I32Array, &allocator, &dst2, &src); - result = result && array_ptr->count == expected_count && array_ptr != &dst2; + expected_count = 5; + array_ptr = wapp_array_copy_alloc(i32, I32Array, &allocator, &dst2, &src); + result = result && array_ptr->count == expected_count && array_ptr != &dst2; - index = 0; - running = true; - while (running) { - result = result && *wapp_array_get(i32, &src, index) == *wapp_array_get(i32, array_ptr, index); + index = 0; + running = true; + while (running) { + result = result && *wapp_array_get(i32, &src, index) == *wapp_array_get(i32, array_ptr, index); - ++index; - running = index < expected_count; - } + ++index; + running = index < expected_count; + } - wapp_mem_arena_allocator_destroy(&allocator); + wapp_mem_arena_allocator_destroy(&allocator); - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_i32_array_pop(void) { - b8 result; + b8 result; - I32Array array1 = wapp_array(i32, I32Array, 0, 1, 2, 3, 4, 5, 6, 7, 8); - I32Array array2 = wapp_array_with_capacity(i32, I32Array, 32, false); + I32Array array1 = wapp_array(i32, I32Array, 0, 1, 2, 3, 4, 5, 6, 7, 8); + I32Array array2 = wapp_array_with_capacity(i32, I32Array, 32, false); - i32 item1 = wapp_array_pop(i32, &array1); - i32 item2 = wapp_array_pop(i32, &array2); + i32 item1 = wapp_array_pop(i32, &array1); + i32 item2 = wapp_array_pop(i32, &array2); - result = item1 == 8 && item2 == 0; + result = item1 == 8 && item2 == 0; - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_i32_array_clear(void) { - b8 result; + b8 result; - I32Array array = wapp_array(i32, I32Array, 0, 1, 2, 3, 4, 5, 6, 7, 8); - result = array.count == 9; + I32Array array = wapp_array(i32, I32Array, 0, 1, 2, 3, 4, 5, 6, 7, 8); + result = array.count == 9; - wapp_array_clear(i32, &array); + wapp_array_clear(i32, &array); - result = result && array.count == 0; + result = result && array.count == 0; - return wapp_tester_result(result); + return wapp_tester_result(result); } diff --git a/tests/array/test_i32_array.cc b/tests/array/test_i32_array.cc index 9cc9251..2b4466c 100644 --- a/tests/array/test_i32_array.cc +++ b/tests/array/test_i32_array.cc @@ -2,275 +2,275 @@ #include "wapp.h" TestFuncResult test_i32_array(void) { - b8 result; + b8 result; - I32Array array = wapp_array(i32, I32Array, 1, 2, 3, 4, 5, 6, 7); - result = array.count == 7 && array.capacity == 16; + I32Array array = wapp_array(i32, I32Array, 1, 2, 3, 4, 5, 6, 7); + result = array.count == 7 && array.capacity == 16; - i32 *item; - u64 count = array.count; - u64 index = 0; - b8 running = true; - while (running) { - item = wapp_array_get(i32, &array, index); - result = result && item && (*item == (i32)(index + 1)); + i32 *item; + u64 count = array.count; + u64 index = 0; + b8 running = true; + while (running) { + item = wapp_array_get(i32, &array, index); + result = result && item && (*item == (i32)(index + 1)); - ++index; - running = index < count; - } + ++index; + running = index < count; + } - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_i32_array_with_capacity(void) { - b8 result; + b8 result; - I32Array array1 = wapp_array_with_capacity(i32, I32Array, 64, false); - result = array1.count == 0 && array1.capacity == 64; + I32Array array1 = wapp_array_with_capacity(i32, I32Array, 64, false); + result = array1.count == 0 && array1.capacity == 64; - I32Array array2 = wapp_array_with_capacity(i32, I32Array, 64, true); - result = array2.count == 64 && array2.capacity == 64; + I32Array array2 = wapp_array_with_capacity(i32, I32Array, 64, true); + result = array2.count == 64 && array2.capacity == 64; - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_i32_array_get(void) { - b8 result = true; + b8 result = true; - I32Array array = wapp_array(i32, I32Array, 0, 1, 2, 3, 4, 5, 6, 7, 8); + I32Array array = wapp_array(i32, I32Array, 0, 1, 2, 3, 4, 5, 6, 7, 8); - i32 *item; - u64 count = array.count; - u64 index = 0; - b8 running = true; - while (running) { - item = wapp_array_get(i32, &array, index); - result = result && item && (*item == (i32)index); + i32 *item; + u64 count = array.count; + u64 index = 0; + b8 running = true; + while (running) { + item = wapp_array_get(i32, &array, index); + result = result && item && (*item == (i32)index); - ++index; - running = index < count; - } + ++index; + running = index < count; + } - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_i32_array_set(void) { - b8 result = true; + b8 result = true; - I32Array array = wapp_array(i32, I32Array, 0, 1, 2, 3, 4, 5, 6, 7, 8); + I32Array array = wapp_array(i32, I32Array, 0, 1, 2, 3, 4, 5, 6, 7, 8); - i32 *item; - u64 count = array.count; - u64 index = 0; - b8 running = true; - while (running) { - i32 num = (i32)(index * 2); - wapp_array_set(i32, &array, index, &num); - item = wapp_array_get(i32, &array, index); - result = result && item && (*item == (i32)(index * 2)); + i32 *item; + u64 count = array.count; + u64 index = 0; + b8 running = true; + while (running) { + i32 num = (i32)(index * 2); + wapp_array_set(i32, &array, index, &num); + item = wapp_array_get(i32, &array, index); + result = result && item && (*item == (i32)(index * 2)); - ++index; - running = index < count; - } + ++index; + running = index < count; + } - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_i32_array_append_capped(void) { - b8 result; + b8 result; - I32Array array = wapp_array_with_capacity(i32, I32Array, 64, false); - i32 item1 = 10; - wapp_array_append_capped(i32, &array, &item1); + I32Array array = wapp_array_with_capacity(i32, I32Array, 64, false); + i32 item1 = 10; + wapp_array_append_capped(i32, &array, &item1); - result = array.count == 1; - i32 *item = wapp_array_get(i32, &array, 0); - result = result && item && *item == 10; + result = array.count == 1; + i32 *item = wapp_array_get(i32, &array, 0); + result = result && item && *item == 10; - array = wapp_array(i32, I32Array, 1); - i32 item2 = 10; - wapp_array_append_capped(i32, &array, &item2); + array = wapp_array(i32, I32Array, 1); + i32 item2 = 10; + wapp_array_append_capped(i32, &array, &item2); - result = result && array.count == 2; + result = result && array.count == 2; - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_i32_array_extend_capped(void) { - b8 result; + b8 result; - I32Array array1 = wapp_array(i32, I32Array, 1, 2, 3, 4); - I32Array array2 = wapp_array(i32, I32Array, 10, 20); + I32Array array1 = wapp_array(i32, I32Array, 1, 2, 3, 4); + I32Array array2 = wapp_array(i32, I32Array, 10, 20); - result = array1.count == 4 && array2.count == 2; + result = array1.count == 4 && array2.count == 2; - wapp_array_extend_capped(i32, &array1, &array2); + wapp_array_extend_capped(i32, &array1, &array2); - result = result && array1.count == 6; + result = result && array1.count == 6; - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_i32_array_copy_capped(void) { - b8 result; + b8 result; - I32Array src = wapp_array(i32, I32Array, 1, 2, 3, 4, 5); - I32Array dst1 = wapp_array(i32, I32Array, 1, 2, 3, 4, 5, 6); - I32Array dst2 = wapp_array(i32, I32Array, 1, 2); + I32Array src = wapp_array(i32, I32Array, 1, 2, 3, 4, 5); + I32Array dst1 = wapp_array(i32, I32Array, 1, 2, 3, 4, 5, 6); + I32Array dst2 = wapp_array(i32, I32Array, 1, 2); - u64 expected_count = 5; - wapp_array_copy_capped(i32, &dst1, &src); - result = dst1.count == expected_count; + u64 expected_count = 5; + wapp_array_copy_capped(i32, &dst1, &src); + result = dst1.count == expected_count; - u64 index = 0; - b8 running = true; - while (running) { - result = result && (*wapp_array_get(i32, &src, index) == *wapp_array_get(i32, &dst1, index)); + u64 index = 0; + b8 running = true; + while (running) { + result = result && (*wapp_array_get(i32, &src, index) == *wapp_array_get(i32, &dst1, index)); - ++index; - running = index < expected_count; - } + ++index; + running = index < expected_count; + } - expected_count = 4; - wapp_array_copy_capped(i32, &dst2, &src); - result = result && dst2.count == expected_count; + expected_count = 4; + wapp_array_copy_capped(i32, &dst2, &src); + result = result && dst2.count == expected_count; - index = 0; - running = true; - while (running) { - result = result && (*wapp_array_get(i32, &src, index) == *wapp_array_get(i32, &dst2, index)); + index = 0; + running = true; + while (running) { + result = result && (*wapp_array_get(i32, &src, index) == *wapp_array_get(i32, &dst2, index)); - ++index; - running = index < expected_count; - } + ++index; + running = index < expected_count; + } - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_i32_array_alloc_capacity(void) { - b8 result; + b8 result; - Allocator allocator = wapp_mem_arena_allocator_init(MiB(4)); - u64 capacity = 32; - I32Array *array = wapp_array_alloc_capacity(i32, I32Array, &allocator, capacity, false); + Allocator allocator = wapp_mem_arena_allocator_init(MiB(4)); + u64 capacity = 32; + I32Array *array = wapp_array_alloc_capacity(i32, I32Array, &allocator, capacity, false); - result = array && array->capacity == capacity; + result = array && array->capacity == capacity; - wapp_mem_arena_allocator_destroy(&allocator); + wapp_mem_arena_allocator_destroy(&allocator); - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_i32_array_append_alloc(void) { - b8 result; + b8 result; - Allocator allocator = wapp_mem_arena_allocator_init(MiB(4)); - I32Array array1 = wapp_array(i32, I32Array, 1, 2, 3, 4, 5, 6, 7, 8); - I32Array array2 = wapp_array(i32, I32Array, 1, 2); + Allocator allocator = wapp_mem_arena_allocator_init(MiB(4)); + I32Array array1 = wapp_array(i32, I32Array, 1, 2, 3, 4, 5, 6, 7, 8); + I32Array array2 = wapp_array(i32, I32Array, 1, 2); - i32 num = 10; - I32Array *arr_ptr = wapp_array_append_alloc(i32, I32Array, &allocator, &array1, &num); - result = arr_ptr == &array1; + i32 num = 10; + I32Array *arr_ptr = wapp_array_append_alloc(i32, I32Array, &allocator, &array1, &num); + result = arr_ptr == &array1; - u64 count = 4; - u64 index = 0; - b8 running = true; - while (running) { - num = (i32)index; - arr_ptr = wapp_array_append_alloc(i32, I32Array, &allocator, &array2, &num); + u64 count = 4; + u64 index = 0; + b8 running = true; + while (running) { + num = (i32)index; + arr_ptr = wapp_array_append_alloc(i32, I32Array, &allocator, &array2, &num); - ++index; - running = index < count; - } - result = result && arr_ptr != &array2; + ++index; + running = index < count; + } + result = result && arr_ptr != &array2; - wapp_mem_arena_allocator_destroy(&allocator); + wapp_mem_arena_allocator_destroy(&allocator); - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_i32_array_extend_alloc(void) { - b8 result; + b8 result; - Allocator allocator = wapp_mem_arena_allocator_init(MiB(4)); - I32Array array1 = wapp_array(i32, I32Array, 1, 2, 3, 4, 5, 6, 7, 8); - I32Array array2 = wapp_array(i32, I32Array, 1, 2); - I32Array array3 = wapp_array(i32, I32Array, 1, 2, 3, 4); + Allocator allocator = wapp_mem_arena_allocator_init(MiB(4)); + I32Array array1 = wapp_array(i32, I32Array, 1, 2, 3, 4, 5, 6, 7, 8); + I32Array array2 = wapp_array(i32, I32Array, 1, 2); + I32Array array3 = wapp_array(i32, I32Array, 1, 2, 3, 4); - I32Array *arr_ptr = wapp_array_extend_alloc(i32, I32Array, &allocator, &array1, &array3); - result = arr_ptr == &array1; + I32Array *arr_ptr = wapp_array_extend_alloc(i32, I32Array, &allocator, &array1, &array3); + result = arr_ptr == &array1; - arr_ptr = wapp_array_extend_alloc(i32, I32Array, &allocator, &array2, &array3); - result = result && arr_ptr != &array2; + arr_ptr = wapp_array_extend_alloc(i32, I32Array, &allocator, &array2, &array3); + result = result && arr_ptr != &array2; - wapp_mem_arena_allocator_destroy(&allocator); + wapp_mem_arena_allocator_destroy(&allocator); - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_i32_array_copy_alloc(void) { - b8 result; + b8 result; - Allocator allocator = wapp_mem_arena_allocator_init(MiB(4)); - I32Array src = wapp_array(i32, I32Array, 1, 2, 3, 4, 5); - I32Array dst1 = wapp_array(i32, I32Array, 1, 2, 3, 4, 5, 6); - I32Array dst2 = wapp_array(i32, I32Array, 1, 2); - I32Array *array_ptr = nullptr; + Allocator allocator = wapp_mem_arena_allocator_init(MiB(4)); + I32Array src = wapp_array(i32, I32Array, 1, 2, 3, 4, 5); + I32Array dst1 = wapp_array(i32, I32Array, 1, 2, 3, 4, 5, 6); + I32Array dst2 = wapp_array(i32, I32Array, 1, 2); + I32Array *array_ptr = nullptr; - u64 expected_count = 5; - array_ptr = wapp_array_copy_alloc(i32, I32Array, &allocator, &dst1, &src); - result = array_ptr->count == expected_count && array_ptr == &dst1; + u64 expected_count = 5; + array_ptr = wapp_array_copy_alloc(i32, I32Array, &allocator, &dst1, &src); + result = array_ptr->count == expected_count && array_ptr == &dst1; - u64 index = 0; - b8 running = true; - while (running) { - result = result && (*wapp_array_get(i32, &src, index) == *wapp_array_get(i32, array_ptr, index)); + u64 index = 0; + b8 running = true; + while (running) { + result = result && (*wapp_array_get(i32, &src, index) == *wapp_array_get(i32, array_ptr, index)); - ++index; - running = index < expected_count; - } + ++index; + running = index < expected_count; + } - expected_count = 5; - array_ptr = wapp_array_copy_alloc(i32, I32Array, &allocator, &dst2, &src); - result = result && array_ptr->count == expected_count && array_ptr != &dst2; + expected_count = 5; + array_ptr = wapp_array_copy_alloc(i32, I32Array, &allocator, &dst2, &src); + result = result && array_ptr->count == expected_count && array_ptr != &dst2; - index = 0; - running = true; - while (running) { - result = result && (*wapp_array_get(i32, &src, index) == *wapp_array_get(i32, array_ptr, index)); + index = 0; + running = true; + while (running) { + result = result && (*wapp_array_get(i32, &src, index) == *wapp_array_get(i32, array_ptr, index)); - ++index; - running = index < expected_count; - } + ++index; + running = index < expected_count; + } - wapp_mem_arena_allocator_destroy(&allocator); + wapp_mem_arena_allocator_destroy(&allocator); - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_i32_array_clear(void) { - b8 result; + b8 result; - I32Array array = wapp_array(i32, I32Array, 0, 1, 2, 3, 4, 5, 6, 7, 8); - result = array.count == 9; + I32Array array = wapp_array(i32, I32Array, 0, 1, 2, 3, 4, 5, 6, 7, 8); + result = array.count == 9; - wapp_array_clear(i32, &array); + wapp_array_clear(i32, &array); - result = result && array.count == 0; + result = result && array.count == 0; - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_i32_array_pop(void) { - b8 result; + b8 result; - I32Array array1 = wapp_array(i32, I32Array, 0, 1, 2, 3, 4, 5, 6, 7, 8); - I32Array array2 = wapp_array_with_capacity(i32, I32Array, 32, false); + I32Array array1 = wapp_array(i32, I32Array, 0, 1, 2, 3, 4, 5, 6, 7, 8); + I32Array array2 = wapp_array_with_capacity(i32, I32Array, 32, false); - i32 item1 = wapp_array_pop(i32, &array1); - i32 item2 = wapp_array_pop(i32, &array2); + i32 item1 = wapp_array_pop(i32, &array1); + i32 item2 = wapp_array_pop(i32, &array2); - result = item1 == 8 && item2 == 0; + result = item1 == 8 && item2 == 0; - return wapp_tester_result(result); + return wapp_tester_result(result); } diff --git a/tests/array/test_str8_array.c b/tests/array/test_str8_array.c index b77856b..b37a810 100644 --- a/tests/array/test_str8_array.c +++ b/tests/array/test_str8_array.c @@ -3,23 +3,23 @@ #include "test_str8_array.h" TestFuncResult test_str8_array(void) { - b8 result; + b8 result; - Str8 expected[] = {wapp_str8_lit("Hello"), wapp_str8_lit("Hi"), wapp_str8_lit("Bye")}; - Str8Array array = wapp_array(Str8, Str8Array, wapp_str8_lit("Hello"), wapp_str8_lit("Hi"), wapp_str8_lit("Bye")); - result = array.count == 3 && array.capacity == 8; + Str8 expected[] = {wapp_str8_lit("Hello"), wapp_str8_lit("Hi"), wapp_str8_lit("Bye")}; + Str8Array array = wapp_array(Str8, Str8Array, wapp_str8_lit("Hello"), wapp_str8_lit("Hi"), wapp_str8_lit("Bye")); + result = array.count == 3 && array.capacity == 8; - Str8 *item; - u64 count = array.count; - u64 index = 0; - b8 running = true; - while (running) { - item = wapp_array_get(Str8, &array, index); - result = result && item && (wapp_str8_equal(item, &expected[index])); + Str8 *item; + u64 count = array.count; + u64 index = 0; + b8 running = true; + while (running) { + item = wapp_array_get(Str8, &array, index); + result = result && item && (wapp_str8_equal(item, &expected[index])); - ++index; - running = index < count; - } + ++index; + running = index < count; + } - return wapp_tester_result(result); + return wapp_tester_result(result); } diff --git a/tests/array/test_str8_array.cc b/tests/array/test_str8_array.cc index c17d3b9..e099f03 100644 --- a/tests/array/test_str8_array.cc +++ b/tests/array/test_str8_array.cc @@ -3,28 +3,28 @@ #include "test_str8_array.h" TestFuncResult test_str8_array(void) { - b8 result; + b8 result; - Str8 expected[] = {wapp_str8_lit("Hello"), wapp_str8_lit("Hi"), wapp_str8_lit("Bye")}; + Str8 expected[] = {wapp_str8_lit("Hello"), wapp_str8_lit("Hi"), wapp_str8_lit("Bye")}; - Str8 str1 = wapp_str8_lit("Hello"); - Str8 str2 = wapp_str8_lit("Hi"); - Str8 str3 = wapp_str8_lit("Bye"); - Str8Array array = wapp_array(Str8, Str8Array, str1, str2, str3); + Str8 str1 = wapp_str8_lit("Hello"); + Str8 str2 = wapp_str8_lit("Hi"); + Str8 str3 = wapp_str8_lit("Bye"); + Str8Array array = wapp_array(Str8, Str8Array, str1, str2, str3); - result = array.count == 3 && array.capacity == 8; + result = array.count == 3 && array.capacity == 8; - Str8 *item; - u64 count = array.count; - u64 index = 0; - b8 running = true; - while (running) { - item = wapp_array_get(Str8, &array, index); - result = result && item && (wapp_str8_equal(item, &expected[index])); + Str8 *item; + u64 count = array.count; + u64 index = 0; + b8 running = true; + while (running) { + item = wapp_array_get(Str8, &array, index); + result = result && item && (wapp_str8_equal(item, &expected[index])); - ++index; - running = index < count; - } + ++index; + running = index < count; + } - return wapp_tester_result(result); + return wapp_tester_result(result); } diff --git a/tests/cpath/test_cpath.c b/tests/cpath/test_cpath.c index b5e6e19..8d70a0b 100644 --- a/tests/cpath/test_cpath.c +++ b/tests/cpath/test_cpath.c @@ -3,179 +3,179 @@ #include #include -#define MAIN_BUF_SIZE 4096 -#define TMP_BUF_SIZE 1024 +#define MAIN_BUF_SIZE 4096 +#define TMP_BUF_SIZE 1024 TestFuncResult test_cpath_join_path(void) { - b8 result; + b8 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); + 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", WAPP_PATH_SEP, WAPP_PATH_SEP, WAPP_PATH_SEP); - wapp_str8_format(&tmp, "%c", WAPP_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 = wapp_dbl_list(Str8, Str8List); - wapp_dbl_list_push_back(Str8, &parts, &wapp_str8_node_from_str8(tmp)); - wapp_dbl_list_push_back(Str8, &parts, &wapp_str8_node_from_cstr("home")); - wapp_dbl_list_push_back(Str8, &parts, &wapp_str8_node_from_cstr("abdelrahman")); - wapp_dbl_list_push_back(Str8, &parts, &wapp_str8_node_from_cstr("Documents")); + Str8List parts = wapp_dbl_list(Str8, Str8List); + wapp_dbl_list_push_back(Str8, &parts, &wapp_str8_node_from_str8(tmp)); + wapp_dbl_list_push_back(Str8, &parts, &wapp_str8_node_from_cstr("home")); + wapp_dbl_list_push_back(Str8, &parts, &wapp_str8_node_from_cstr("abdelrahman")); + wapp_dbl_list_push_back(Str8, &parts, &wapp_str8_node_from_cstr("Documents")); - wapp_cpath_join_path(&out, &parts); - result = wapp_str8_equal(&out, &expected); + wapp_cpath_join_path(&out, &parts); + result = wapp_str8_equal(&out, &expected); - wapp_dbl_list_pop_front(Str8, Str8Node, &parts); + wapp_dbl_list_pop_front(Str8, Str8Node, &parts); - wapp_str8_format(&expected, "home%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_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_cpath_join_path(&out, &parts); + result = result && wapp_str8_equal(&out, &expected); - wapp_str8_concat_capped(&tmp, &wapp_str8_lit_ro("home")); - wapp_dbl_list_pop_front(Str8, Str8Node, &parts); - wapp_dbl_list_push_front(Str8, &parts, &wapp_str8_node_from_str8(tmp)); + wapp_str8_concat_capped(&tmp, &wapp_str8_lit_ro("home")); + wapp_dbl_list_pop_front(Str8, Str8Node, &parts); + wapp_dbl_list_push_front(Str8, &parts, &wapp_str8_node_from_str8(tmp)); - wapp_str8_format(&expected, "%chome%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_PATH_SEP, WAPP_PATH_SEP); + 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_cpath_join_path(&out, &parts); + result = result && wapp_str8_equal(&out, &expected); - wapp_str8_format(&tmp, "home%c", WAPP_PATH_SEP); - wapp_dbl_list_pop_front(Str8, Str8Node, &parts); - wapp_dbl_list_push_front(Str8, &parts, &wapp_str8_node_from_cstr("home")); + wapp_str8_format(&tmp, "home%c", WAPP_PATH_SEP); + wapp_dbl_list_pop_front(Str8, Str8Node, &parts); + wapp_dbl_list_push_front(Str8, &parts, &wapp_str8_node_from_cstr("home")); - wapp_str8_format(&expected, "home%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_PATH_SEP); + wapp_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_cpath_join_path(&out, &parts); + result = result && wapp_str8_equal(&out, &expected); - wapp_dbl_list_empty(Str8, &parts); + wapp_dbl_list_empty(Str8, &parts); - wapp_str8_format(&tmp, "%chome", WAPP_PATH_SEP); - wapp_dbl_list_push_back(Str8, &parts, &wapp_str8_node_from_str8(tmp)); - wapp_dbl_list_push_back(Str8, &parts, &wapp_str8_node_from_cstr("")); + wapp_str8_format(&tmp, "%chome", WAPP_PATH_SEP); + wapp_dbl_list_push_back(Str8, &parts, &wapp_str8_node_from_str8(tmp)); + wapp_dbl_list_push_back(Str8, &parts, &wapp_str8_node_from_cstr("")); - wapp_str8_format(&expected, "%chome", WAPP_PATH_SEP); + wapp_str8_format(&expected, "%chome", WAPP_PATH_SEP); - wapp_cpath_join_path(&out, &parts); - result = result && wapp_str8_equal(&out, &expected); + wapp_cpath_join_path(&out, &parts); + result = result && wapp_str8_equal(&out, &expected); - wapp_dbl_list_pop_front(Str8, Str8Node, &parts); - wapp_dbl_list_push_back(Str8, &parts, &wapp_str8_node_from_cstr("")); + wapp_dbl_list_pop_front(Str8, Str8Node, &parts); + wapp_dbl_list_push_back(Str8, &parts, &wapp_str8_node_from_cstr("")); - wapp_str8_format(&expected, "%s", ""); + wapp_str8_format(&expected, "%s", ""); - wapp_cpath_join_path(&out, &parts); - result = result && wapp_str8_equal(&out, &expected); + wapp_cpath_join_path(&out, &parts); + result = result && wapp_str8_equal(&out, &expected); - wapp_dbl_list_pop_back(Str8, Str8Node, &parts); - wapp_dbl_list_push_back(Str8, &parts, &wapp_str8_node_from_cstr("home")); + wapp_dbl_list_pop_back(Str8, Str8Node, &parts); + wapp_dbl_list_push_back(Str8, &parts, &wapp_str8_node_from_cstr("home")); - wapp_str8_copy_cstr_capped(&expected, "home"); + wapp_str8_copy_cstr_capped(&expected, "home"); - wapp_cpath_join_path(&out, &parts); - result = result && wapp_str8_equal(&out, &expected); + wapp_cpath_join_path(&out, &parts); + result = result && wapp_str8_equal(&out, &expected); - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_cpath_dirname(void) { - Allocator arena = wapp_mem_arena_allocator_init(MiB(8)); - if (wapp_mem_allocator_invalid(&arena)) { - return wapp_tester_result(false); - } + Allocator arena = wapp_mem_arena_allocator_init(MiB(8)); + if (wapp_mem_allocator_invalid(&arena)) { + return wapp_tester_result(false); + } - b8 result; - Str8 *output = NULL; + b8 result; + Str8 *output = NULL; - Str8 expected = wapp_str8_buf(MAIN_BUF_SIZE); - Str8 tmp = wapp_str8_buf(TMP_BUF_SIZE); + Str8 expected = wapp_str8_buf(MAIN_BUF_SIZE); + Str8 tmp = wapp_str8_buf(TMP_BUF_SIZE); - // CASE 1 - wapp_str8_format(&tmp, "%c", WAPP_PATH_SEP); - wapp_str8_format(&expected, "%c", WAPP_PATH_SEP); + // CASE 1 + 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); + output = wapp_cpath_dirname(&arena, &tmp); + result = output != NULL && wapp_str8_equal(output, &expected); - // CASE 2 - wapp_str8_format(&expected, "%s", "."); + // CASE 2 + wapp_str8_format(&expected, "%s", "."); - output = wapp_cpath_dirname(&arena, &wapp_str8_lit("home")); - result = result && output != NULL && wapp_str8_equal(output, &expected); + output = wapp_cpath_dirname(&arena, &wapp_str8_lit("home")); + result = result && output != NULL && wapp_str8_equal(output, &expected); - // CASE 3 - output = wapp_cpath_dirname(&arena, &wapp_str8_lit("")); - result = result && output != NULL && wapp_str8_equal(output, &expected); + // CASE 3 + output = wapp_cpath_dirname(&arena, &wapp_str8_lit("")); + result = result && output != NULL && wapp_str8_equal(output, &expected); - // CASE 4 - wapp_str8_format(&tmp, "%chome%ctest", WAPP_PATH_SEP, WAPP_PATH_SEP); - wapp_str8_format(&expected, "%chome", WAPP_PATH_SEP); + // CASE 4 + 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); + output = wapp_cpath_dirname(&arena, &tmp); + result = result && output != NULL && wapp_str8_equal(output, &expected); - // CASE 5 - wapp_str8_format(&tmp, "%chome%ctest%c", WAPP_PATH_SEP, WAPP_PATH_SEP, WAPP_PATH_SEP); - wapp_str8_format(&expected, "%chome", WAPP_PATH_SEP); + // CASE 5 + 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); + output = wapp_cpath_dirname(&arena, &tmp); + result = result && output != NULL && wapp_str8_equal(output, &expected); - wapp_mem_arena_allocator_destroy(&arena); + wapp_mem_arena_allocator_destroy(&arena); - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_cpath_dirup(void) { - Allocator arena = wapp_mem_arena_allocator_init(MiB(8)); - if (wapp_mem_allocator_invalid(&arena)) { - return wapp_tester_result(false); - } + Allocator arena = wapp_mem_arena_allocator_init(MiB(8)); + if (wapp_mem_allocator_invalid(&arena)) { + return wapp_tester_result(false); + } - b8 result; - Str8 *output = NULL; + b8 result; + Str8 *output = NULL; - Str8 expected = wapp_str8_buf(MAIN_BUF_SIZE); - Str8 tmp = wapp_str8_buf(TMP_BUF_SIZE); + Str8 expected = wapp_str8_buf(MAIN_BUF_SIZE); + Str8 tmp = wapp_str8_buf(TMP_BUF_SIZE); - // CASE 1 - wapp_str8_format(&tmp, "%c", WAPP_PATH_SEP); - wapp_str8_format(&expected, "%c", WAPP_PATH_SEP); + // CASE 1 + 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); + output = wapp_cpath_dirup(&arena, &tmp, 3); + result = output != NULL && wapp_str8_equal(output, &expected); - // CASE 2 - wapp_str8_format(&tmp, "%chome%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_PATH_SEP, WAPP_PATH_SEP); - wapp_str8_format(&expected, "%c", WAPP_PATH_SEP); + // CASE 2 + 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); + 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", WAPP_PATH_SEP, WAPP_PATH_SEP); - wapp_str8_copy_cstr_capped(&expected, "."); + // CASE 3 + 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); + 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", WAPP_PATH_SEP, WAPP_PATH_SEP, WAPP_PATH_SEP); - wapp_str8_format(&expected, "%chome", WAPP_PATH_SEP); + // CASE 4 + 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); + 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", WAPP_PATH_SEP, WAPP_PATH_SEP); - wapp_str8_copy_cstr_capped(&expected, "home"); + // CASE 5 + 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); - result = result && output != NULL && wapp_str8_equal(output, &expected); + output = wapp_cpath_dirup(&arena, &tmp, 2); + result = result && output != NULL && wapp_str8_equal(output, &expected); - wapp_mem_arena_allocator_destroy(&arena); + wapp_mem_arena_allocator_destroy(&arena); - return wapp_tester_result(result); + return wapp_tester_result(result); } diff --git a/tests/cpath/test_cpath.cc b/tests/cpath/test_cpath.cc index 429c21b..d28bcca 100644 --- a/tests/cpath/test_cpath.cc +++ b/tests/cpath/test_cpath.cc @@ -3,202 +3,202 @@ #include #include -#define MAIN_BUF_SIZE 4096 -#define TMP_BUF_SIZE 1024 +#define MAIN_BUF_SIZE 4096 +#define TMP_BUF_SIZE 1024 TestFuncResult test_cpath_join_path(void) { - b8 result; + b8 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); + 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", WAPP_PATH_SEP, WAPP_PATH_SEP, WAPP_PATH_SEP); - wapp_str8_format(&tmp, "%c", WAPP_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 = wapp_dbl_list(Str8, Str8List); + Str8List parts = wapp_dbl_list(Str8, Str8List); - Str8Node tmp_node = wapp_str8_node_from_str8(tmp); - wapp_dbl_list_push_back(Str8, &parts, &tmp_node); + Str8Node tmp_node = wapp_str8_node_from_str8(tmp); + wapp_dbl_list_push_back(Str8, &parts, &tmp_node); - Str8Node home_node = wapp_str8_node_from_cstr("home"); - wapp_dbl_list_push_back(Str8, &parts, &home_node); + Str8Node home_node = wapp_str8_node_from_cstr("home"); + wapp_dbl_list_push_back(Str8, &parts, &home_node); - Str8Node user_node = wapp_str8_node_from_cstr("abdelrahman"); - wapp_dbl_list_push_back(Str8, &parts, &user_node); + Str8Node user_node = wapp_str8_node_from_cstr("abdelrahman"); + wapp_dbl_list_push_back(Str8, &parts, &user_node); - Str8Node docs_node = wapp_str8_node_from_cstr("Documents"); - wapp_dbl_list_push_back(Str8, &parts, &docs_node); + Str8Node docs_node = wapp_str8_node_from_cstr("Documents"); + wapp_dbl_list_push_back(Str8, &parts, &docs_node); - wapp_cpath_join_path(&out, &parts); - result = wapp_str8_equal(&out, &expected); + wapp_cpath_join_path(&out, &parts); + result = wapp_str8_equal(&out, &expected); - wapp_dbl_list_pop_front(Str8, Str8Node, &parts); + wapp_dbl_list_pop_front(Str8, Str8Node, &parts); - wapp_str8_format(&expected, "home%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_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_cpath_join_path(&out, &parts); + result = result && wapp_str8_equal(&out, &expected); - Str8RO str = wapp_str8_lit_ro("home"); - wapp_str8_concat_capped(&tmp, &str); - wapp_dbl_list_pop_front(Str8, Str8Node, &parts); + Str8RO str = wapp_str8_lit_ro("home"); + wapp_str8_concat_capped(&tmp, &str); + wapp_dbl_list_pop_front(Str8, Str8Node, &parts); - Str8Node tmp_node_2 = wapp_str8_node_from_str8(tmp); - wapp_dbl_list_push_front(Str8, &parts, &tmp_node_2); + Str8Node tmp_node_2 = wapp_str8_node_from_str8(tmp); + wapp_dbl_list_push_front(Str8, &parts, &tmp_node_2); - wapp_str8_format(&expected, "%chome%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_PATH_SEP, WAPP_PATH_SEP); + 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_cpath_join_path(&out, &parts); + result = result && wapp_str8_equal(&out, &expected); - wapp_str8_format(&tmp, "home%c", WAPP_PATH_SEP); - wapp_dbl_list_pop_front(Str8, Str8Node, &parts); + wapp_str8_format(&tmp, "home%c", WAPP_PATH_SEP); + wapp_dbl_list_pop_front(Str8, Str8Node, &parts); - Str8Node home_node_2 = wapp_str8_node_from_cstr("home"); - wapp_dbl_list_push_front(Str8, &parts, &home_node_2); + Str8Node home_node_2 = wapp_str8_node_from_cstr("home"); + wapp_dbl_list_push_front(Str8, &parts, &home_node_2); - wapp_str8_format(&expected, "home%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_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_cpath_join_path(&out, &parts); + result = result && wapp_str8_equal(&out, &expected); - wapp_dbl_list_empty(Str8, &parts); + wapp_dbl_list_empty(Str8, &parts); - wapp_str8_format(&tmp, "%chome", WAPP_PATH_SEP); + wapp_str8_format(&tmp, "%chome", WAPP_PATH_SEP); - Str8Node tmp_node_3 = wapp_str8_node_from_str8(tmp); - wapp_dbl_list_push_back(Str8, &parts, &tmp_node_3); + Str8Node tmp_node_3 = wapp_str8_node_from_str8(tmp); + wapp_dbl_list_push_back(Str8, &parts, &tmp_node_3); - Str8Node empty_node = wapp_str8_node_from_cstr(""); - wapp_dbl_list_push_back(Str8, &parts, &empty_node); + Str8Node empty_node = wapp_str8_node_from_cstr(""); + wapp_dbl_list_push_back(Str8, &parts, &empty_node); - wapp_str8_format(&expected, "%chome", WAPP_PATH_SEP); + wapp_str8_format(&expected, "%chome", WAPP_PATH_SEP); - wapp_cpath_join_path(&out, &parts); - result = result && wapp_str8_equal(&out, &expected); + wapp_cpath_join_path(&out, &parts); + result = result && wapp_str8_equal(&out, &expected); - wapp_dbl_list_pop_front(Str8, Str8Node, &parts); + wapp_dbl_list_pop_front(Str8, Str8Node, &parts); - Str8Node empty_node_2 = wapp_str8_node_from_cstr(""); - wapp_dbl_list_push_back(Str8, &parts, &empty_node_2); + Str8Node empty_node_2 = wapp_str8_node_from_cstr(""); + wapp_dbl_list_push_back(Str8, &parts, &empty_node_2); - wapp_str8_format(&expected, "%s", ""); + wapp_str8_format(&expected, "%s", ""); - wapp_cpath_join_path(&out, &parts); - result = result && wapp_str8_equal(&out, &expected); + wapp_cpath_join_path(&out, &parts); + result = result && wapp_str8_equal(&out, &expected); - wapp_dbl_list_pop_back(Str8, Str8Node, &parts); + wapp_dbl_list_pop_back(Str8, Str8Node, &parts); - Str8Node home_node_3 = wapp_str8_node_from_cstr("home"); - wapp_dbl_list_push_back(Str8, &parts, &home_node_3); + Str8Node home_node_3 = wapp_str8_node_from_cstr("home"); + wapp_dbl_list_push_back(Str8, &parts, &home_node_3); - wapp_str8_copy_cstr_capped(&expected, "home"); + wapp_str8_copy_cstr_capped(&expected, "home"); - wapp_cpath_join_path(&out, &parts); - result = result && wapp_str8_equal(&out, &expected); + wapp_cpath_join_path(&out, &parts); + result = result && wapp_str8_equal(&out, &expected); - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_cpath_dirname(void) { - Allocator arena = wapp_mem_arena_allocator_init(MiB(8)); - if (wapp_mem_allocator_invalid(&arena)) { - return wapp_tester_result(false); - } + Allocator arena = wapp_mem_arena_allocator_init(MiB(8)); + if (wapp_mem_allocator_invalid(&arena)) { + return wapp_tester_result(false); + } - b8 result; - Str8 *output = nullptr; + b8 result; + Str8 *output = nullptr; - Str8 expected = wapp_str8_buf(MAIN_BUF_SIZE); - Str8 tmp = wapp_str8_buf(TMP_BUF_SIZE); + Str8 expected = wapp_str8_buf(MAIN_BUF_SIZE); + Str8 tmp = wapp_str8_buf(TMP_BUF_SIZE); - // CASE 1 - wapp_str8_format(&tmp, "%c", WAPP_PATH_SEP); - wapp_str8_format(&expected, "%c", WAPP_PATH_SEP); + // CASE 1 + 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); + output = wapp_cpath_dirname(&arena, &tmp); + result = output != nullptr && wapp_str8_equal(output, &expected); - // CASE 2 - wapp_str8_format(&expected, "%s", "."); + // CASE 2 + wapp_str8_format(&expected, "%s", "."); - Str8 path = wapp_str8_lit("home"); - output = wapp_cpath_dirname(&arena, &path); - result = result && output != nullptr && wapp_str8_equal(output, &expected); + Str8 path = wapp_str8_lit("home"); + output = wapp_cpath_dirname(&arena, &path); + result = result && output != nullptr && wapp_str8_equal(output, &expected); - // CASE 3 - path = wapp_str8_lit(""); - output = wapp_cpath_dirname(&arena, &path); - result = result && output != nullptr && wapp_str8_equal(output, &expected); + // CASE 3 + path = wapp_str8_lit(""); + output = wapp_cpath_dirname(&arena, &path); + result = result && output != nullptr && wapp_str8_equal(output, &expected); - // CASE 4 - wapp_str8_format(&tmp, "%chome%ctest", WAPP_PATH_SEP, WAPP_PATH_SEP); - wapp_str8_format(&expected, "%chome", WAPP_PATH_SEP); + // CASE 4 + 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); + output = wapp_cpath_dirname(&arena, &tmp); + result = result && output != nullptr && wapp_str8_equal(output, &expected); - // CASE 5 - wapp_str8_format(&tmp, "%chome%ctest%c", WAPP_PATH_SEP, WAPP_PATH_SEP, WAPP_PATH_SEP); - wapp_str8_format(&expected, "%chome", WAPP_PATH_SEP); + // CASE 5 + 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); + output = wapp_cpath_dirname(&arena, &tmp); + result = result && output != nullptr && wapp_str8_equal(output, &expected); - wapp_mem_arena_allocator_destroy(&arena); + wapp_mem_arena_allocator_destroy(&arena); - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_cpath_dirup(void) { - Allocator arena = wapp_mem_arena_allocator_init(MiB(8)); - if (wapp_mem_allocator_invalid(&arena)) { - return wapp_tester_result(false); - } + Allocator arena = wapp_mem_arena_allocator_init(MiB(8)); + if (wapp_mem_allocator_invalid(&arena)) { + return wapp_tester_result(false); + } - b8 result; - Str8 *output = nullptr; + b8 result; + Str8 *output = nullptr; - Str8 expected = wapp_str8_buf(MAIN_BUF_SIZE); - Str8 tmp = wapp_str8_buf(TMP_BUF_SIZE); + Str8 expected = wapp_str8_buf(MAIN_BUF_SIZE); + Str8 tmp = wapp_str8_buf(TMP_BUF_SIZE); - // CASE 1 - wapp_str8_format(&tmp, "%c", WAPP_PATH_SEP); - wapp_str8_format(&expected, "%c", WAPP_PATH_SEP); + // CASE 1 + 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); + output = wapp_cpath_dirup(&arena, &tmp, 3); + result = output != nullptr && wapp_str8_equal(output, &expected); - // CASE 2 - wapp_str8_format(&tmp, "%chome%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_PATH_SEP, WAPP_PATH_SEP); - wapp_str8_format(&expected, "%c", WAPP_PATH_SEP); + // CASE 2 + 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); + 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", WAPP_PATH_SEP, WAPP_PATH_SEP); - wapp_str8_copy_cstr_capped(&expected, "."); + // CASE 3 + 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); + 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", WAPP_PATH_SEP, WAPP_PATH_SEP, WAPP_PATH_SEP); - wapp_str8_format(&expected, "%chome", WAPP_PATH_SEP); + // CASE 4 + 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); + 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", WAPP_PATH_SEP, WAPP_PATH_SEP); - wapp_str8_copy_cstr_capped(&expected, "home"); + // CASE 5 + 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); - result = result && output != nullptr && wapp_str8_equal(output, &expected); + output = wapp_cpath_dirup(&arena, &tmp, 2); + result = result && output != nullptr && wapp_str8_equal(output, &expected); - wapp_mem_arena_allocator_destroy(&arena); + wapp_mem_arena_allocator_destroy(&arena); - return wapp_tester_result(result); + return wapp_tester_result(result); } diff --git a/tests/shell_commander/test_shell_commander.c b/tests/shell_commander/test_shell_commander.c index c14fd2a..2d5f3f7 100644 --- a/tests/shell_commander/test_shell_commander.c +++ b/tests/shell_commander/test_shell_commander.c @@ -5,58 +5,58 @@ #include TestFuncResult test_commander_cmd_success(void) { - Str8List cmd = wapp_dbl_list(Str8, Str8List); - wapp_dbl_list_push_back(Str8, &cmd, &wapp_str8_node_from_cstr("echo")); - wapp_dbl_list_push_back(Str8, &cmd, &wapp_str8_node_from_cstr("hello world")); + Str8List cmd = wapp_dbl_list(Str8, Str8List); + wapp_dbl_list_push_back(Str8, &cmd, &wapp_str8_node_from_cstr("echo")); + wapp_dbl_list_push_back(Str8, &cmd, &wapp_str8_node_from_cstr("hello world")); - CMDResult result = wapp_shell_commander_execute(SHELL_OUTPUT_DISCARD, NULL, &cmd); - b8 succeeded = result.exited && result.exit_code == EXIT_SUCCESS && - result.error == SHELL_ERR_NO_ERROR; + CMDResult result = wapp_shell_commander_execute(SHELL_OUTPUT_DISCARD, NULL, &cmd); + b8 succeeded = result.exited && result.exit_code == EXIT_SUCCESS && + result.error == SHELL_ERR_NO_ERROR; - return wapp_tester_result(succeeded); + return wapp_tester_result(succeeded); } TestFuncResult test_commander_cmd_failure(void) { - Str8List cmd = wapp_dbl_list(Str8, Str8List); - wapp_dbl_list_push_back(Str8, &cmd, &wapp_str8_node_from_cstr("grep")); + Str8List cmd = wapp_dbl_list(Str8, Str8List); + wapp_dbl_list_push_back(Str8, &cmd, &wapp_str8_node_from_cstr("grep")); - CMDResult result = wapp_shell_commander_execute(SHELL_OUTPUT_DISCARD, NULL, &cmd); - b8 failed = result.exited && result.exit_code != EXIT_SUCCESS && - result.error == SHELL_ERR_NO_ERROR; + CMDResult result = wapp_shell_commander_execute(SHELL_OUTPUT_DISCARD, NULL, &cmd); + b8 failed = result.exited && result.exit_code != EXIT_SUCCESS && + result.error == SHELL_ERR_NO_ERROR; - return wapp_tester_result(failed); + return wapp_tester_result(failed); } TestFuncResult test_commander_cmd_out_buf_success(void) { - Str8 buf = wapp_str8_buf(64); - Str8 expected = wapp_str8_buf(64); - char msg[] = "hello world"; - wapp_str8_copy_cstr_capped(&expected, msg); + Str8 buf = wapp_str8_buf(64); + Str8 expected = wapp_str8_buf(64); + char msg[] = "hello world"; + wapp_str8_copy_cstr_capped(&expected, msg); - Str8List cmd = wapp_dbl_list(Str8, Str8List); - wapp_dbl_list_push_back(Str8, &cmd, &wapp_str8_node_from_cstr("echo")); - wapp_dbl_list_push_back(Str8, &cmd, &wapp_str8_node_from_cstr(msg)); + Str8List cmd = wapp_dbl_list(Str8, Str8List); + wapp_dbl_list_push_back(Str8, &cmd, &wapp_str8_node_from_cstr("echo")); + wapp_dbl_list_push_back(Str8, &cmd, &wapp_str8_node_from_cstr(msg)); - CMDResult result = wapp_shell_commander_execute(SHELL_OUTPUT_CAPTURE, &buf, &cmd); - b8 succeeded = result.exited && result.exit_code == EXIT_SUCCESS && - result.error == SHELL_ERR_NO_ERROR && wapp_str8_equal_to_count(&buf, &expected, strlen(msg)); + CMDResult result = wapp_shell_commander_execute(SHELL_OUTPUT_CAPTURE, &buf, &cmd); + b8 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); + return wapp_tester_result(succeeded); } TestFuncResult test_commander_cmd_out_buf_failure(void) { - Str8 buf = wapp_str8_buf(4); - Str8 expected = wapp_str8_buf(64); - char msg[] = "hello world"; - wapp_str8_copy_cstr_capped(&expected, msg); + Str8 buf = wapp_str8_buf(4); + Str8 expected = wapp_str8_buf(64); + char msg[] = "hello world"; + wapp_str8_copy_cstr_capped(&expected, msg); - Str8List cmd = wapp_dbl_list(Str8, Str8List); - wapp_dbl_list_push_back(Str8, &cmd, &wapp_str8_node_from_cstr("echo")); - wapp_dbl_list_push_back(Str8, &cmd, &wapp_str8_node_from_cstr(msg)); + Str8List cmd = wapp_dbl_list(Str8, Str8List); + wapp_dbl_list_push_back(Str8, &cmd, &wapp_str8_node_from_cstr("echo")); + wapp_dbl_list_push_back(Str8, &cmd, &wapp_str8_node_from_cstr(msg)); - CMDResult result = wapp_shell_commander_execute(SHELL_OUTPUT_CAPTURE, &buf, &cmd); - b8 failed = !result.exited && result.exit_code != EXIT_SUCCESS && - result.error == SHELL_ERR_OUT_BUF_FULL && !wapp_str8_equal(&buf, &expected); + CMDResult result = wapp_shell_commander_execute(SHELL_OUTPUT_CAPTURE, &buf, &cmd); + b8 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); + return wapp_tester_result(failed); } diff --git a/tests/shell_commander/test_shell_commander.cc b/tests/shell_commander/test_shell_commander.cc index 0420bae..0125108 100644 --- a/tests/shell_commander/test_shell_commander.cc +++ b/tests/shell_commander/test_shell_commander.cc @@ -5,65 +5,65 @@ #include TestFuncResult test_commander_cmd_success(void) { - Str8List cmd = wapp_dbl_list(Str8, Str8List); - Str8Node echo = wapp_str8_node_from_cstr("echo"); - Str8Node msg = wapp_str8_node_from_cstr("hello world"); - wapp_dbl_list_push_back(Str8, &cmd, &echo); - wapp_dbl_list_push_back(Str8, &cmd, &msg); + Str8List cmd = wapp_dbl_list(Str8, Str8List); + Str8Node echo = wapp_str8_node_from_cstr("echo"); + Str8Node msg = wapp_str8_node_from_cstr("hello world"); + wapp_dbl_list_push_back(Str8, &cmd, &echo); + wapp_dbl_list_push_back(Str8, &cmd, &msg); - CMDResult result = wapp_shell_commander_execute(SHELL_OUTPUT_DISCARD, nullptr, &cmd); - b8 succeeded = result.exited && result.exit_code == EXIT_SUCCESS && - result.error == SHELL_ERR_NO_ERROR; + CMDResult result = wapp_shell_commander_execute(SHELL_OUTPUT_DISCARD, nullptr, &cmd); + b8 succeeded = result.exited && result.exit_code == EXIT_SUCCESS && + result.error == SHELL_ERR_NO_ERROR; - return wapp_tester_result(succeeded); + return wapp_tester_result(succeeded); } TestFuncResult test_commander_cmd_failure(void) { - Str8List cmd = wapp_dbl_list(Str8, Str8List); - Str8Node grep = wapp_str8_node_from_cstr("grep"); - wapp_dbl_list_push_back(Str8, &cmd, &grep); + Str8List cmd = wapp_dbl_list(Str8, Str8List); + Str8Node grep = wapp_str8_node_from_cstr("grep"); + wapp_dbl_list_push_back(Str8, &cmd, &grep); - CMDResult result = wapp_shell_commander_execute(SHELL_OUTPUT_DISCARD, nullptr, &cmd); - b8 failed = result.exited && result.exit_code != EXIT_SUCCESS && - result.error == SHELL_ERR_NO_ERROR; + CMDResult result = wapp_shell_commander_execute(SHELL_OUTPUT_DISCARD, nullptr, &cmd); + b8 failed = result.exited && result.exit_code != EXIT_SUCCESS && + result.error == SHELL_ERR_NO_ERROR; - return wapp_tester_result(failed); + return wapp_tester_result(failed); } TestFuncResult test_commander_cmd_out_buf_success(void) { - Str8 buf = wapp_str8_buf(64); - Str8 expected = wapp_str8_buf(64); - char msg[] = "hello world"; - wapp_str8_copy_cstr_capped(&expected, msg); + Str8 buf = wapp_str8_buf(64); + Str8 expected = wapp_str8_buf(64); + char msg[] = "hello world"; + wapp_str8_copy_cstr_capped(&expected, msg); - Str8List cmd = wapp_dbl_list(Str8, Str8List); - Str8Node echo = wapp_str8_node_from_cstr("echo"); - Str8Node arg = wapp_str8_node_from_cstr(msg); - wapp_dbl_list_push_back(Str8, &cmd, &echo); - wapp_dbl_list_push_back(Str8, &cmd, &arg); + Str8List cmd = wapp_dbl_list(Str8, Str8List); + Str8Node echo = wapp_str8_node_from_cstr("echo"); + Str8Node arg = wapp_str8_node_from_cstr(msg); + wapp_dbl_list_push_back(Str8, &cmd, &echo); + wapp_dbl_list_push_back(Str8, &cmd, &arg); - CMDResult result = wapp_shell_commander_execute(SHELL_OUTPUT_CAPTURE, &buf, &cmd); - b8 succeeded = result.exited && result.exit_code == EXIT_SUCCESS && - result.error == SHELL_ERR_NO_ERROR && wapp_str8_equal_to_count(&buf, &expected, strlen(msg)); + CMDResult result = wapp_shell_commander_execute(SHELL_OUTPUT_CAPTURE, &buf, &cmd); + b8 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); + return wapp_tester_result(succeeded); } TestFuncResult test_commander_cmd_out_buf_failure(void) { - Str8 buf = wapp_str8_buf(4); - Str8 expected = wapp_str8_buf(64); - char msg[] = "hello world"; - wapp_str8_copy_cstr_capped(&expected, msg); + Str8 buf = wapp_str8_buf(4); + Str8 expected = wapp_str8_buf(64); + char msg[] = "hello world"; + wapp_str8_copy_cstr_capped(&expected, msg); - Str8List cmd = wapp_dbl_list(Str8, Str8List); - Str8Node echo = wapp_str8_node_from_cstr("echo"); - Str8Node arg = wapp_str8_node_from_cstr(msg); - wapp_dbl_list_push_back(Str8, &cmd, &echo); - wapp_dbl_list_push_back(Str8, &cmd, &arg); + Str8List cmd = wapp_dbl_list(Str8, Str8List); + Str8Node echo = wapp_str8_node_from_cstr("echo"); + Str8Node arg = wapp_str8_node_from_cstr(msg); + wapp_dbl_list_push_back(Str8, &cmd, &echo); + wapp_dbl_list_push_back(Str8, &cmd, &arg); - CMDResult result = wapp_shell_commander_execute(SHELL_OUTPUT_CAPTURE, &buf, &cmd); - b8 failed = !result.exited && result.exit_code != EXIT_SUCCESS && - result.error == SHELL_ERR_OUT_BUF_FULL && !wapp_str8_equal(&buf, &expected); + CMDResult result = wapp_shell_commander_execute(SHELL_OUTPUT_CAPTURE, &buf, &cmd); + b8 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); + return wapp_tester_result(failed); } diff --git a/tests/str8/test_str8.c b/tests/str8/test_str8.c index 9965531..ce36499 100644 --- a/tests/str8/test_str8.c +++ b/tests/str8/test_str8.c @@ -4,623 +4,623 @@ #define ARRLEN(ARR) (sizeof(ARR) / sizeof(ARR[0])) TestFuncResult test_str8_lit(void) { - b8 result; + b8 result; - Str8 s1 = wapp_str8_lit("Hello world"); - result = s1.capacity == 22 && s1.capacity != s1.size; + Str8 s1 = wapp_str8_lit("Hello world"); + result = s1.capacity == 22 && s1.capacity != s1.size; - Str8 s2 = wapp_str8_lit("Different strokes for different folks"); - result = result && s2.capacity == 74 && s2.capacity != s2.size; + Str8 s2 = wapp_str8_lit("Different strokes for different folks"); + result = result && s2.capacity == 74 && s2.capacity != s2.size; - Str8 s3 = wapp_str8_lit("Discretion is the better part of valour"); - result = result && s3.capacity == 78 && s3.capacity != s3.size; + Str8 s3 = wapp_str8_lit("Discretion is the better part of valour"); + result = result && s3.capacity == 78 && s3.capacity != s3.size; - Str8 s4 = wapp_str8_lit("Distance lends enchantment to the view"); - result = result && s4.capacity == 76 && s4.capacity != s4.size; + Str8 s4 = wapp_str8_lit("Distance lends enchantment to the view"); + result = result && s4.capacity == 76 && s4.capacity != s4.size; - Str8 s5 = wapp_str8_lit("Do as I say, not as I do"); - result = result && s5.capacity == 48 && s5.capacity != s5.size; + Str8 s5 = wapp_str8_lit("Do as I say, not as I do"); + result = result && s5.capacity == 48 && s5.capacity != s5.size; - Str8 s6 = wapp_str8_lit("Do as you would be done by"); - result = result && s6.capacity == 52 && s6.capacity != s6.size; + Str8 s6 = wapp_str8_lit("Do as you would be done by"); + result = result && s6.capacity == 52 && s6.capacity != s6.size; - Str8 s7 = wapp_str8_lit("Do unto others as you would have them do to you"); - result = result && s7.capacity == 94 && s7.capacity != s7.size; + Str8 s7 = wapp_str8_lit("Do unto others as you would have them do to you"); + result = result && s7.capacity == 94 && s7.capacity != s7.size; - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_str8_lit_ro(void) { - b8 result; + b8 result; - Str8RO s1 = wapp_str8_lit_ro("Hello world"); - result = s1.capacity == 11 && s1.capacity == s1.size; + Str8RO s1 = wapp_str8_lit_ro("Hello world"); + result = s1.capacity == 11 && s1.capacity == s1.size; - Str8RO s2 = wapp_str8_lit_ro("Different strokes for different folks"); - result = result && s2.capacity == 37 && s2.capacity == s2.size; + Str8RO s2 = wapp_str8_lit_ro("Different strokes for different folks"); + result = result && s2.capacity == 37 && s2.capacity == s2.size; - Str8RO s3 = wapp_str8_lit_ro("Discretion is the better part of valour"); - result = result && s3.capacity == 39 && s3.capacity == s3.size; + Str8RO s3 = wapp_str8_lit_ro("Discretion is the better part of valour"); + result = result && s3.capacity == 39 && s3.capacity == s3.size; - Str8RO s4 = wapp_str8_lit_ro("Distance lends enchantment to the view"); - result = result && s4.capacity == 38 && s4.capacity == s4.size; + Str8RO s4 = wapp_str8_lit_ro("Distance lends enchantment to the view"); + result = result && s4.capacity == 38 && s4.capacity == s4.size; - Str8RO s5 = wapp_str8_lit_ro("Do as I say, not as I do"); - result = result && s5.capacity == 24 && s5.capacity == s5.size; + Str8RO s5 = wapp_str8_lit_ro("Do as I say, not as I do"); + result = result && s5.capacity == 24 && s5.capacity == s5.size; - Str8RO s6 = wapp_str8_lit_ro("Do as you would be done by"); - result = result && s6.capacity == 26 && s6.capacity == s6.size; + Str8RO s6 = wapp_str8_lit_ro("Do as you would be done by"); + result = result && s6.capacity == 26 && s6.capacity == s6.size; - Str8RO s7 = wapp_str8_lit_ro("Do unto others as you would have them do to you"); - result = result && s7.capacity == 47 && s7.capacity == s7.size; + Str8RO s7 = wapp_str8_lit_ro("Do unto others as you would have them do to you"); + result = result && s7.capacity == 47 && s7.capacity == s7.size; - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_str8_buf(void) { - b8 result; + b8 result; - Str8 s1 = wapp_str8_buf(1024); - result = s1.capacity == 1024 && s1.size == 0; + Str8 s1 = wapp_str8_buf(1024); + result = s1.capacity == 1024 && s1.size == 0; - Str8 s2 = wapp_str8_buf(2048); - result = result && s2.capacity == 2048 && s2.size == 0; + Str8 s2 = wapp_str8_buf(2048); + result = result && s2.capacity == 2048 && s2.size == 0; - Str8 s3 = wapp_str8_buf(4096); - result = result && s3.capacity == 4096 && s3.size == 0; + Str8 s3 = wapp_str8_buf(4096); + result = result && s3.capacity == 4096 && s3.size == 0; - Str8 s4 = wapp_str8_buf(8192); - result = result && s4.capacity == 8192 && s4.size == 0; + Str8 s4 = wapp_str8_buf(8192); + result = result && s4.capacity == 8192 && s4.size == 0; - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_str8_alloc_buf(void) { - b8 result; - Allocator allocator = wapp_mem_arena_allocator_init(KiB(100)); - if (wapp_mem_allocator_invalid(&allocator)) { - return wapp_tester_result(false); - } + b8 result; + Allocator allocator = wapp_mem_arena_allocator_init(KiB(100)); + if (wapp_mem_allocator_invalid(&allocator)) { + return wapp_tester_result(false); + } - u64 capacity = 4096; + u64 capacity = 4096; - Str8 *s = wapp_str8_alloc_buf(&allocator, capacity); - if (!s) { - result = false; - goto TEST_ALLOC_BUF_CLEANUP; - } + Str8 *s = wapp_str8_alloc_buf(&allocator, capacity); + if (!s) { + result = false; + goto TEST_ALLOC_BUF_CLEANUP; + } - result = s->capacity == capacity; + result = s->capacity == capacity; - const char *cstr = "My name is Abdelrahman"; - wapp_str8_copy_cstr_capped(s, cstr); + const char *cstr = "My name is Abdelrahman"; + wapp_str8_copy_cstr_capped(s, cstr); - result = result && s->capacity == capacity && s->size == strlen(cstr) && memcmp(s->buf, cstr, s->size) == 0; + result = result && s->capacity == capacity && s->size == strlen(cstr) && memcmp(s->buf, cstr, s->size) == 0; TEST_ALLOC_BUF_CLEANUP: - wapp_mem_arena_allocator_destroy(&allocator); + wapp_mem_arena_allocator_destroy(&allocator); - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_str8_alloc_cstr(void) { - b8 result; - Allocator allocator = wapp_mem_arena_allocator_init(KiB(100)); - if (wapp_mem_allocator_invalid(&allocator)) { - return wapp_tester_result(false); - } + b8 result; + Allocator allocator = wapp_mem_arena_allocator_init(KiB(100)); + if (wapp_mem_allocator_invalid(&allocator)) { + return wapp_tester_result(false); + } - char *str = "Abdelrahman"; - u64 length = strlen(str); - Str8 *s = wapp_str8_alloc_cstr(&allocator, str); - if (!s) { - return wapp_tester_result(false); - } + char *str = "Abdelrahman"; + u64 length = strlen(str); + Str8 *s = wapp_str8_alloc_cstr(&allocator, str); + if (!s) { + return wapp_tester_result(false); + } - result = s->size == length && memcmp(s->buf, str, length) == 0; + result = s->size == length && memcmp(s->buf, str, length) == 0; - wapp_mem_arena_allocator_destroy(&allocator); + wapp_mem_arena_allocator_destroy(&allocator); - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_str8_alloc_str8(void) { - b8 result; - Allocator allocator = wapp_mem_arena_allocator_init(KiB(100)); - if (wapp_mem_allocator_invalid(&allocator)) { - return wapp_tester_result(false); - } + b8 result; + Allocator allocator = wapp_mem_arena_allocator_init(KiB(100)); + if (wapp_mem_allocator_invalid(&allocator)) { + return wapp_tester_result(false); + } - Str8 str = wapp_str8_lit("Abdelrahman"); - Str8 *s = wapp_str8_alloc_str8(&allocator, &str); - if (!s) { - return wapp_tester_result(false); - } + Str8 str = wapp_str8_lit("Abdelrahman"); + Str8 *s = wapp_str8_alloc_str8(&allocator, &str); + if (!s) { + return wapp_tester_result(false); + } - result = wapp_str8_equal(s, &str); + result = wapp_str8_equal(s, &str); - wapp_mem_arena_allocator_destroy(&allocator); + wapp_mem_arena_allocator_destroy(&allocator); - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_str8_alloc_substr(void) { - b8 result; - Allocator allocator = wapp_mem_arena_allocator_init(KiB(100)); - if (wapp_mem_allocator_invalid(&allocator)) { - return wapp_tester_result(false); - } + b8 result; + Allocator allocator = wapp_mem_arena_allocator_init(KiB(100)); + if (wapp_mem_allocator_invalid(&allocator)) { + return wapp_tester_result(false); + } - Str8 str = wapp_str8_lit("Abdelrahman"); - Str8 *s = wapp_str8_alloc_substr(&allocator, &str, 3, 8); - if (!s) { - return wapp_tester_result(false); - } + Str8 str = wapp_str8_lit("Abdelrahman"); + Str8 *s = wapp_str8_alloc_substr(&allocator, &str, 3, 8); + if (!s) { + return wapp_tester_result(false); + } - result = s->size == 5 && memcmp(s->buf, "elrah", s->size) == 0; + result = s->size == 5 && memcmp(s->buf, "elrah", s->size) == 0; - wapp_mem_arena_allocator_destroy(&allocator); + wapp_mem_arena_allocator_destroy(&allocator); - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_str8_get_index_within_bounds(void) { - b8 result; + b8 result; - Str8RO s1 = wapp_str8_lit_ro("Hello world"); - result = wapp_str8_get(&s1, 4) == 'o'; + Str8RO s1 = wapp_str8_lit_ro("Hello world"); + result = wapp_str8_get(&s1, 4) == 'o'; - Str8RO s2 = wapp_str8_lit_ro("Different strokes for different folks"); - result = result && wapp_str8_get(&s2, 0) == 'D'; + Str8RO s2 = wapp_str8_lit_ro("Different strokes for different folks"); + result = result && wapp_str8_get(&s2, 0) == 'D'; - Str8RO s3 = wapp_str8_lit_ro("Discretion is the better part of valour"); - result = result && wapp_str8_get(&s3, 13) == ' '; + Str8RO s3 = wapp_str8_lit_ro("Discretion is the better part of valour"); + result = result && wapp_str8_get(&s3, 13) == ' '; - Str8RO s4 = wapp_str8_lit_ro("Distance lends enchantment to the view"); - result = result && wapp_str8_get(&s4, 20) == 'n'; + Str8RO s4 = wapp_str8_lit_ro("Distance lends enchantment to the view"); + result = result && wapp_str8_get(&s4, 20) == 'n'; - Str8RO s5 = wapp_str8_lit_ro("Do as I say, not as I do"); - result = result && wapp_str8_get(&s5, 11) == ','; + Str8RO s5 = wapp_str8_lit_ro("Do as I say, not as I do"); + result = result && wapp_str8_get(&s5, 11) == ','; - Str8RO s6 = wapp_str8_lit_ro("Do as you would be done by"); - result = result && wapp_str8_get(&s6, 25) == 'y'; + Str8RO s6 = wapp_str8_lit_ro("Do as you would be done by"); + result = result && wapp_str8_get(&s6, 25) == 'y'; - Str8RO s7 = wapp_str8_lit_ro("Do unto others as you would have them do to you"); - result = result && wapp_str8_get(&s7, 16) == 's'; + Str8RO s7 = wapp_str8_lit_ro("Do unto others as you would have them do to you"); + result = result && wapp_str8_get(&s7, 16) == 's'; - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_str8_get_index_out_of_bounds(void) { - Str8 s1 = wapp_str8_lit("Hello world"); - b8 result = wapp_str8_get(&s1, 20) == '\0'; - return wapp_tester_result(result); + Str8 s1 = wapp_str8_lit("Hello world"); + b8 result = wapp_str8_get(&s1, 20) == '\0'; + return wapp_tester_result(result); } TestFuncResult test_str8_set(void) { - b8 result; + b8 result; - Str8 s1 = wapp_str8_lit("Hello world"); - wapp_str8_set(&s1, 4, 'f'); - result = wapp_str8_get(&s1, 4) == 'f'; + Str8 s1 = wapp_str8_lit("Hello world"); + wapp_str8_set(&s1, 4, 'f'); + result = wapp_str8_get(&s1, 4) == 'f'; - Str8 s2 = wapp_str8_lit("Different strokes for different folks"); - wapp_str8_set(&s2, 0, 'A'); - result = result && wapp_str8_get(&s2, 0) == 'A'; + Str8 s2 = wapp_str8_lit("Different strokes for different folks"); + wapp_str8_set(&s2, 0, 'A'); + result = result && wapp_str8_get(&s2, 0) == 'A'; - Str8 s3 = wapp_str8_lit("Discretion is the better part of valour"); - wapp_str8_set(&s3, 13, 'u'); - result = result && wapp_str8_get(&s3, 13) == 'u'; + Str8 s3 = wapp_str8_lit("Discretion is the better part of valour"); + wapp_str8_set(&s3, 13, 'u'); + result = result && wapp_str8_get(&s3, 13) == 'u'; - Str8 s4 = wapp_str8_lit("Distance lends enchantment to the view"); - wapp_str8_set(&s4, 20, 'R'); - result = result && wapp_str8_get(&s4, 20) == 'R'; + Str8 s4 = wapp_str8_lit("Distance lends enchantment to the view"); + wapp_str8_set(&s4, 20, 'R'); + result = result && wapp_str8_get(&s4, 20) == 'R'; - Str8 s5 = wapp_str8_lit("Do as I say, not as I do"); - wapp_str8_set(&s5, 11, '.'); - result = result && wapp_str8_get(&s5, 11) == '.'; + Str8 s5 = wapp_str8_lit("Do as I say, not as I do"); + wapp_str8_set(&s5, 11, '.'); + result = result && wapp_str8_get(&s5, 11) == '.'; - Str8 s6 = wapp_str8_lit("Do as you would be done by"); - wapp_str8_set(&s6, 25, 'w'); - result = result && wapp_str8_get(&s6, 25) == 'w'; + Str8 s6 = wapp_str8_lit("Do as you would be done by"); + wapp_str8_set(&s6, 25, 'w'); + result = result && wapp_str8_get(&s6, 25) == 'w'; - Str8 s7 = wapp_str8_lit("Do unto others as you would have them do to you"); - wapp_str8_set(&s7, 16, 'i'); - result = result && wapp_str8_get(&s7, 16) == 'i'; + Str8 s7 = wapp_str8_lit("Do unto others as you would have them do to you"); + wapp_str8_set(&s7, 16, 'i'); + result = result && wapp_str8_get(&s7, 16) == 'i'; - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_str8_push_back(void) { - b8 result; + b8 result; - Str8 expected = wapp_str8_lit("Abdelrahman"); - Str8 buf = wapp_str8_buf(64); - wapp_str8_push_back(&buf, 'A'); - wapp_str8_push_back(&buf, 'b'); - wapp_str8_push_back(&buf, 'd'); - wapp_str8_push_back(&buf, 'e'); - wapp_str8_push_back(&buf, 'l'); - wapp_str8_push_back(&buf, 'r'); - wapp_str8_push_back(&buf, 'a'); - wapp_str8_push_back(&buf, 'h'); - wapp_str8_push_back(&buf, 'm'); - wapp_str8_push_back(&buf, 'a'); - wapp_str8_push_back(&buf, 'n'); + Str8 expected = wapp_str8_lit("Abdelrahman"); + Str8 buf = wapp_str8_buf(64); + wapp_str8_push_back(&buf, 'A'); + wapp_str8_push_back(&buf, 'b'); + wapp_str8_push_back(&buf, 'd'); + wapp_str8_push_back(&buf, 'e'); + wapp_str8_push_back(&buf, 'l'); + wapp_str8_push_back(&buf, 'r'); + wapp_str8_push_back(&buf, 'a'); + wapp_str8_push_back(&buf, 'h'); + wapp_str8_push_back(&buf, 'm'); + wapp_str8_push_back(&buf, 'a'); + wapp_str8_push_back(&buf, 'n'); - result = wapp_str8_equal(&buf, &expected); + result = wapp_str8_equal(&buf, &expected); - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_str8_equal(void) { - b8 result; + b8 result; - Str8RO s1 = wapp_str8_lit_ro("hello"); - Str8RO s2 = wapp_str8_lit_ro("hell"); - Str8RO s3 = wapp_str8_lit_ro("hello"); - Str8RO s4 = wapp_str8_lit_ro("goodbye"); + Str8RO s1 = wapp_str8_lit_ro("hello"); + Str8RO s2 = wapp_str8_lit_ro("hell"); + Str8RO s3 = wapp_str8_lit_ro("hello"); + Str8RO s4 = wapp_str8_lit_ro("goodbye"); - result = wapp_str8_equal(&s1, &s2) == false; - result = result && wapp_str8_equal(&s1, &s3) == true; - result = result && wapp_str8_equal(&s1, &s4) == false; + result = wapp_str8_equal(&s1, &s2) == false; + result = result && wapp_str8_equal(&s1, &s3) == true; + result = result && wapp_str8_equal(&s1, &s4) == false; - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_str8_slice(void) { - b8 result; - Str8 s = wapp_str8_lit("Different strokes for different folks"); + b8 result; + Str8 s = wapp_str8_lit("Different strokes for different folks"); - Str8RO sub1 = wapp_str8_slice(&s, 3, 9); - result = sub1.size == 6 && sub1.capacity == 6; + Str8RO sub1 = wapp_str8_slice(&s, 3, 9); + result = sub1.size == 6 && sub1.capacity == 6; - Str8RO sub2 = wapp_str8_slice(&s, 18, 21); - result = result && sub2.size == 3 && sub2.capacity == 3; + Str8RO sub2 = wapp_str8_slice(&s, 18, 21); + result = result && sub2.size == 3 && sub2.capacity == 3; - Str8RO sub3 = wapp_str8_slice(&s, 5, 1); - result = result && sub3.size == 0 && sub3.capacity == 0; + Str8RO sub3 = wapp_str8_slice(&s, 5, 1); + result = result && sub3.size == 0 && sub3.capacity == 0; - Str8RO sub4 = wapp_str8_slice(&s, 70, 80); - result = result && sub4.size == 0 && sub4.capacity == 0; + Str8RO sub4 = wapp_str8_slice(&s, 70, 80); + result = result && sub4.size == 0 && sub4.capacity == 0; - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_str8_alloc_concat(void) { - b8 result; - Allocator arena = wapp_mem_arena_allocator_init(KiB(100)); + b8 result; + Allocator arena = wapp_mem_arena_allocator_init(KiB(100)); - Str8 str = wapp_str8_lit("Hello world"); - Str8 suffix1 = wapp_str8_lit(" from me."); - Str8 suffix2 = wapp_str8_lit(" This is my code."); - Str8 concat1 = wapp_str8_lit("Hello world from me."); - Str8 concat2 = wapp_str8_lit("Hello world from me. This is my code."); + Str8 str = wapp_str8_lit("Hello world"); + Str8 suffix1 = wapp_str8_lit(" from me."); + Str8 suffix2 = wapp_str8_lit(" This is my code."); + Str8 concat1 = wapp_str8_lit("Hello world from me."); + Str8 concat2 = wapp_str8_lit("Hello world from me. This is my code."); - Str8 *output; + Str8 *output; - output = wapp_str8_alloc_concat(&arena, &str, &suffix1); - result = output->size == concat1.size && wapp_str8_equal(output, &concat1); + output = wapp_str8_alloc_concat(&arena, &str, &suffix1); + result = output->size == concat1.size && wapp_str8_equal(output, &concat1); - output = wapp_str8_alloc_concat(&arena, output, &suffix2); - result = result && output->size == concat2.size && wapp_str8_equal(output, &concat2); + output = wapp_str8_alloc_concat(&arena, output, &suffix2); + result = result && output->size == concat2.size && wapp_str8_equal(output, &concat2); - wapp_mem_arena_allocator_destroy(&arena); + wapp_mem_arena_allocator_destroy(&arena); - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_str8_concat_capped(void) { - b8 result; + b8 result; - Str8 str = wapp_str8_lit("Hello world"); - Str8 suffix1 = wapp_str8_lit(" from me."); - Str8 suffix2 = wapp_str8_lit(" This is my code."); - Str8 concat1 = wapp_str8_lit("Hello world from me."); - Str8 concat2 = wapp_str8_lit("Hello world from me. T"); + Str8 str = wapp_str8_lit("Hello world"); + Str8 suffix1 = wapp_str8_lit(" from me."); + Str8 suffix2 = wapp_str8_lit(" This is my code."); + Str8 concat1 = wapp_str8_lit("Hello world from me."); + Str8 concat2 = wapp_str8_lit("Hello world from me. T"); - wapp_str8_concat_capped(&str, &suffix1); - result = str.size == concat1.size && wapp_str8_equal(&str, &concat1); + wapp_str8_concat_capped(&str, &suffix1); + result = str.size == concat1.size && wapp_str8_equal(&str, &concat1); - wapp_str8_concat_capped(&str, &suffix2); - result = result && str.size == concat2.size && wapp_str8_equal(&str, &concat2); + wapp_str8_concat_capped(&str, &suffix2); + result = result && str.size == concat2.size && wapp_str8_equal(&str, &concat2); - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_str8_copy_cstr_capped(void) { - b8 result; + b8 result; - Str8 buf = wapp_str8_buf(32); - const char *src1 = "Hello world"; - const char *src2 = "Hello world from the Wizard Apprentice standard library"; - Str8RO src1_cp = wapp_str8_lit_ro("Hello world"); - Str8RO src2_cp = wapp_str8_lit_ro("Hello world from the Wizard Appr"); + Str8 buf = wapp_str8_buf(32); + const char *src1 = "Hello world"; + const char *src2 = "Hello world from the Wizard Apprentice standard library"; + Str8RO src1_cp = wapp_str8_lit_ro("Hello world"); + Str8RO src2_cp = wapp_str8_lit_ro("Hello world from the Wizard Appr"); - wapp_str8_copy_cstr_capped(&buf, src1); - result = buf.size == src1_cp.size && wapp_str8_equal(&buf, &src1_cp); + wapp_str8_copy_cstr_capped(&buf, src1); + result = buf.size == src1_cp.size && wapp_str8_equal(&buf, &src1_cp); - wapp_str8_copy_cstr_capped(&buf, src2); - result = result && buf.size == src2_cp.size && buf.size == buf.capacity && wapp_str8_equal(&buf, &src2_cp); + wapp_str8_copy_cstr_capped(&buf, src2); + result = result && buf.size == src2_cp.size && buf.size == buf.capacity && wapp_str8_equal(&buf, &src2_cp); - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_str8_copy_str8_capped(void) { - b8 result; + b8 result; - Str8 buf = wapp_str8_buf(32); - Str8RO src1 = wapp_str8_lit_ro("Hello world"); - Str8RO src2 = wapp_str8_lit_ro("Hello world from the Wizard Apprentice standard library"); - Str8RO src2_cp = wapp_str8_lit_ro("Hello world from the Wizard Appr"); + Str8 buf = wapp_str8_buf(32); + Str8RO src1 = wapp_str8_lit_ro("Hello world"); + Str8RO src2 = wapp_str8_lit_ro("Hello world from the Wizard Apprentice standard library"); + Str8RO src2_cp = wapp_str8_lit_ro("Hello world from the Wizard Appr"); - wapp_str8_copy_str8_capped(&buf, &src1); - result = buf.size == src1.size && wapp_str8_equal(&buf, &src1); + wapp_str8_copy_str8_capped(&buf, &src1); + result = buf.size == src1.size && wapp_str8_equal(&buf, &src1); - wapp_str8_copy_str8_capped(&buf, &src2); - result = result && buf.size < src2.size && buf.size == buf.capacity && wapp_str8_equal(&buf, &src2_cp); + wapp_str8_copy_str8_capped(&buf, &src2); + result = result && buf.size < src2.size && buf.size == buf.capacity && wapp_str8_equal(&buf, &src2_cp); - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_str8_format(void) { - b8 result; + b8 result; - Str8 buf = wapp_str8_buf(128); - Str8 expected = wapp_str8_lit("My name is Abdelrahman and I am 35 years old"); + Str8 buf = wapp_str8_buf(128); + Str8 expected = wapp_str8_lit("My name is Abdelrahman and I am 35 years old"); - wapp_str8_format(&buf, "My name is %s and I am %u years old", "Abdelrahman", 35); + wapp_str8_format(&buf, "My name is %s and I am %u years old", "Abdelrahman", 35); - result = wapp_str8_equal(&buf, &expected); + result = wapp_str8_equal(&buf, &expected); - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_str8_find(void) { - b8 result; - Str8RO s = wapp_str8_lit("Do as I say, not as I do"); + b8 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; - result = result && (wapp_str8_find(&s, wapp_str8_lit_ro("not")) != -1); - result = result && (wapp_str8_find(&s, wapp_str8_lit_ro("as I say")) != -1); + result = wapp_str8_find(&s, wapp_str8_lit_ro("d")) != -1; + result = result && (wapp_str8_find(&s, wapp_str8_lit_ro("not")) != -1); + result = result && (wapp_str8_find(&s, wapp_str8_lit_ro("as I say")) != -1); - result = result && (wapp_str8_find(&s, wapp_str8_lit_ro("f")) == -1); - result = result && (wapp_str8_find(&s, wapp_str8_lit_ro("hello")) == -1); - result = result && (wapp_str8_find(&s, wapp_str8_lit_ro("not sa I")) == -1); - result = result && (wapp_str8_find(&s, wapp_str8_lit_ro("Do unto others as you would have them do to you")) == -1); + result = result && (wapp_str8_find(&s, wapp_str8_lit_ro("f")) == -1); + result = result && (wapp_str8_find(&s, wapp_str8_lit_ro("hello")) == -1); + result = result && (wapp_str8_find(&s, wapp_str8_lit_ro("not sa I")) == -1); + result = result && (wapp_str8_find(&s, wapp_str8_lit_ro("Do unto others as you would have them do to you")) == -1); - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_str8_rfind(void) { - b8 result; - Str8RO s = wapp_str8_lit("Do as I say, not as I do"); + b8 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; - result = result && (wapp_str8_rfind(&s, wapp_str8_lit_ro("not")) != -1); - result = result && (wapp_str8_rfind(&s, wapp_str8_lit_ro("as I say")) != -1); + result = wapp_str8_rfind(&s, wapp_str8_lit_ro("d")) != -1; + result = result && (wapp_str8_rfind(&s, wapp_str8_lit_ro("not")) != -1); + result = result && (wapp_str8_rfind(&s, wapp_str8_lit_ro("as I say")) != -1); - result = result && (wapp_str8_rfind(&s, wapp_str8_lit_ro("f")) == -1); - result = result && (wapp_str8_rfind(&s, wapp_str8_lit_ro("hello")) == -1); - result = result && (wapp_str8_rfind(&s, wapp_str8_lit_ro("not sa I")) == -1); - result = result && (wapp_str8_rfind(&s, wapp_str8_lit_ro("Do unto others as you would have them do to you")) == -1); + result = result && (wapp_str8_rfind(&s, wapp_str8_lit_ro("f")) == -1); + result = result && (wapp_str8_rfind(&s, wapp_str8_lit_ro("hello")) == -1); + result = result && (wapp_str8_rfind(&s, wapp_str8_lit_ro("not sa I")) == -1); + result = result && (wapp_str8_rfind(&s, wapp_str8_lit_ro("Do unto others as you would have them do to you")) == -1); - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_str8_split(void) { - b8 result; - Allocator arena = wapp_mem_arena_allocator_init(KiB(100)); + b8 result; + Allocator arena = wapp_mem_arena_allocator_init(KiB(100)); - Str8 str = wapp_str8_lit("hello world from me"); - Str8 delim1 = wapp_str8_lit(" "); - Str8 delim2 = wapp_str8_lit("from"); - Str8List *list1 = wapp_str8_split(&arena, &str, &delim1); - Str8List *list2 = wapp_str8_split(&arena, &str, &delim2); + Str8 str = wapp_str8_lit("hello world from me"); + Str8 delim1 = wapp_str8_lit(" "); + Str8 delim2 = wapp_str8_lit("from"); + Str8List *list1 = wapp_str8_split(&arena, &str, &delim1); + Str8List *list2 = wapp_str8_split(&arena, &str, &delim2); - Str8RO splits1[] = { - wapp_str8_slice(&str, 0, 5), - wapp_str8_slice(&str, 6, 11), - wapp_str8_slice(&str, 12, 16), - wapp_str8_slice(&str, 17, 19), - }; - Str8RO splits2[] = { - wapp_str8_slice(&str, 0, 12), - wapp_str8_slice(&str, 16, 19), - }; + Str8RO splits1[] = { + wapp_str8_slice(&str, 0, 5), + wapp_str8_slice(&str, 6, 11), + wapp_str8_slice(&str, 12, 16), + wapp_str8_slice(&str, 17, 19), + }; + Str8RO splits2[] = { + wapp_str8_slice(&str, 0, 12), + wapp_str8_slice(&str, 16, 19), + }; - u64 index1 = 0; - u64 count1 = ARRLEN(splits1); - b8 running1 = true; + u64 index1 = 0; + u64 count1 = ARRLEN(splits1); + b8 running1 = true; - u64 index2 = 0; - u64 count2 = ARRLEN(splits2); - b8 running2 = true; + u64 index2 = 0; + u64 count2 = ARRLEN(splits2); + b8 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; + 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; - // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of - // MSVC Spectre mitigation warnings - while (running1) { - Str8Node *node = wapp_dbl_list_get(Str8, Str8Node, list1, index1); - result = result && wapp_str8_equal(node->item, &(splits1[index1])); + // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of + // MSVC Spectre mitigation warnings + while (running1) { + Str8Node *node = wapp_dbl_list_get(Str8, Str8Node, list1, index1); + result = result && wapp_str8_equal(node->item, &(splits1[index1])); - ++index1; - running1 = index1 < count1; - } + ++index1; + running1 = index1 < count1; + } - // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of - // MSVC Spectre mitigation warnings - while (running2) { - Str8Node *node = wapp_dbl_list_get(Str8, Str8Node, list2, index2); - result = result && wapp_str8_equal(node->item, &(splits2[index2])); + // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of + // MSVC Spectre mitigation warnings + while (running2) { + Str8Node *node = wapp_dbl_list_get(Str8, Str8Node, list2, index2); + result = result && wapp_str8_equal(node->item, &(splits2[index2])); - ++index2; - running2 = index2 < count2; - } + ++index2; + running2 = index2 < count2; + } - wapp_mem_arena_allocator_destroy(&arena); + wapp_mem_arena_allocator_destroy(&arena); - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_str8_split_with_max(void) { - b8 result; - Allocator arena = wapp_mem_arena_allocator_init(KiB(100)); + b8 result; + Allocator arena = wapp_mem_arena_allocator_init(KiB(100)); - Str8 str = wapp_str8_lit("hello world from me"); - Str8 delim = wapp_str8_lit(" "); - Str8List *list = wapp_str8_split_with_max(&arena, &str, &delim, 2); + Str8 str = wapp_str8_lit("hello world from me"); + Str8 delim = wapp_str8_lit(" "); + Str8List *list = wapp_str8_split_with_max(&arena, &str, &delim, 2); - Str8RO splits[] = { - wapp_str8_slice(&str, 0, 5), - wapp_str8_slice(&str, 6, 11), - wapp_str8_slice(&str, 12, 19), - }; + Str8RO splits[] = { + wapp_str8_slice(&str, 0, 5), + wapp_str8_slice(&str, 6, 11), + wapp_str8_slice(&str, 12, 19), + }; - u64 index = 0; - u64 count = ARRLEN(splits); - b8 running = true; + u64 index = 0; + u64 count = ARRLEN(splits); + b8 running = true; - result = list->node_count == count && wapp_str8_list_total_size(list) == str.size - 2; + result = list->node_count == count && wapp_str8_list_total_size(list) == str.size - 2; - // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of - // MSVC Spectre mitigation warnings - while (running) { - Str8Node *node = wapp_dbl_list_get(Str8, Str8Node, list, index); - result = result && wapp_str8_equal(node->item, &(splits[index])); + // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of + // MSVC Spectre mitigation warnings + while (running) { + Str8Node *node = wapp_dbl_list_get(Str8, Str8Node, list, index); + result = result && wapp_str8_equal(node->item, &(splits[index])); - ++index; - running = index < count; - } + ++index; + running = index < count; + } - wapp_mem_arena_allocator_destroy(&arena); + wapp_mem_arena_allocator_destroy(&arena); - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_str8_rsplit(void) { - b8 result; - Allocator arena = wapp_mem_arena_allocator_init(KiB(100)); + b8 result; + Allocator arena = wapp_mem_arena_allocator_init(KiB(100)); - Str8 str = wapp_str8_lit("hello world from me"); - Str8 delim1 = wapp_str8_lit(" "); - Str8 delim2 = wapp_str8_lit("from"); - Str8List *list1 = wapp_str8_rsplit(&arena, &str, &delim1); - Str8List *list2 = wapp_str8_rsplit(&arena, &str, &delim2); + Str8 str = wapp_str8_lit("hello world from me"); + Str8 delim1 = wapp_str8_lit(" "); + Str8 delim2 = wapp_str8_lit("from"); + Str8List *list1 = wapp_str8_rsplit(&arena, &str, &delim1); + Str8List *list2 = wapp_str8_rsplit(&arena, &str, &delim2); - Str8RO splits1[] = { - wapp_str8_slice(&str, 0, 5), - wapp_str8_slice(&str, 6, 11), - wapp_str8_slice(&str, 12, 16), - wapp_str8_slice(&str, 17, 19), - }; - Str8RO splits2[] = { - wapp_str8_slice(&str, 0, 12), - wapp_str8_slice(&str, 16, 19), - }; + Str8RO splits1[] = { + wapp_str8_slice(&str, 0, 5), + wapp_str8_slice(&str, 6, 11), + wapp_str8_slice(&str, 12, 16), + wapp_str8_slice(&str, 17, 19), + }; + Str8RO splits2[] = { + wapp_str8_slice(&str, 0, 12), + wapp_str8_slice(&str, 16, 19), + }; - u64 index1 = 0; - u64 count1 = ARRLEN(splits1); - b8 running1 = true; + u64 index1 = 0; + u64 count1 = ARRLEN(splits1); + b8 running1 = true; - u64 index2 = 0; - u64 count2 = ARRLEN(splits2); - b8 running2 = true; + u64 index2 = 0; + u64 count2 = ARRLEN(splits2); + b8 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; + 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; - // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of - // MSVC Spectre mitigation warnings - while (running1) { - Str8Node *node = wapp_dbl_list_get(Str8, Str8Node, list1, index1); - result = result && wapp_str8_equal(node->item, &(splits1[index1])); + // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of + // MSVC Spectre mitigation warnings + while (running1) { + Str8Node *node = wapp_dbl_list_get(Str8, Str8Node, list1, index1); + result = result && wapp_str8_equal(node->item, &(splits1[index1])); - ++index1; - running1 = index1 < count1; - } + ++index1; + running1 = index1 < count1; + } - // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of - // MSVC Spectre mitigation warnings - while (running2) { - Str8Node *node = wapp_dbl_list_get(Str8, Str8Node, list2, index2); - result = result && wapp_str8_equal(node->item, &(splits2[index2])); + // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of + // MSVC Spectre mitigation warnings + while (running2) { + Str8Node *node = wapp_dbl_list_get(Str8, Str8Node, list2, index2); + result = result && wapp_str8_equal(node->item, &(splits2[index2])); - ++index2; - running2 = index2 < count2; - } + ++index2; + running2 = index2 < count2; + } - wapp_mem_arena_allocator_destroy(&arena); + wapp_mem_arena_allocator_destroy(&arena); - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_str8_rsplit_with_max(void) { - b8 result; - Allocator arena = wapp_mem_arena_allocator_init(KiB(100)); + b8 result; + Allocator arena = wapp_mem_arena_allocator_init(KiB(100)); - Str8 str = wapp_str8_lit("hello world from me"); - Str8 delim = wapp_str8_lit(" "); - Str8List *list = wapp_str8_rsplit_with_max(&arena, &str, &delim, 2); + Str8 str = wapp_str8_lit("hello world from me"); + Str8 delim = wapp_str8_lit(" "); + Str8List *list = wapp_str8_rsplit_with_max(&arena, &str, &delim, 2); - Str8RO splits[] = { - wapp_str8_slice(&str, 0, 11), - wapp_str8_slice(&str, 12, 16), - wapp_str8_slice(&str, 17, 19), - }; + Str8RO splits[] = { + wapp_str8_slice(&str, 0, 11), + wapp_str8_slice(&str, 12, 16), + wapp_str8_slice(&str, 17, 19), + }; - u64 index = 0; - u64 count = ARRLEN(splits); - b8 running = true; + u64 index = 0; + u64 count = ARRLEN(splits); + b8 running = true; - result = list->node_count == count && wapp_str8_list_total_size(list) == str.size - 2; + result = list->node_count == count && wapp_str8_list_total_size(list) == str.size - 2; - // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of - // MSVC Spectre mitigation warnings - while (running) { - Str8Node *node = wapp_dbl_list_get(Str8, Str8Node, list, index); - result = result && wapp_str8_equal(node->item, &(splits[index])); + // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of + // MSVC Spectre mitigation warnings + while (running) { + Str8Node *node = wapp_dbl_list_get(Str8, Str8Node, list, index); + result = result && wapp_str8_equal(node->item, &(splits[index])); - ++index; - running = index < count; - } + ++index; + running = index < count; + } - wapp_mem_arena_allocator_destroy(&arena); + wapp_mem_arena_allocator_destroy(&arena); - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_str8_join(void) { - b8 result; - Allocator arena = wapp_mem_arena_allocator_init(KiB(100)); + b8 result; + Allocator arena = wapp_mem_arena_allocator_init(KiB(100)); - Str8 str = wapp_str8_lit("hello world from me"); - Str8 delim1 = wapp_str8_lit(" "); - Str8 delim2 = wapp_str8_lit("from"); - Str8List *list1 = wapp_str8_rsplit(&arena, &str, &delim1); - Str8List *list2 = wapp_str8_rsplit(&arena, &str, &delim2); - Str8 *join1 = wapp_str8_join(&arena, list1, &delim1); - Str8 *join2 = wapp_str8_join(&arena, list2, &delim2); + Str8 str = wapp_str8_lit("hello world from me"); + Str8 delim1 = wapp_str8_lit(" "); + Str8 delim2 = wapp_str8_lit("from"); + Str8List *list1 = wapp_str8_rsplit(&arena, &str, &delim1); + Str8List *list2 = wapp_str8_rsplit(&arena, &str, &delim2); + Str8 *join1 = wapp_str8_join(&arena, list1, &delim1); + Str8 *join2 = wapp_str8_join(&arena, list2, &delim2); - result = join1->size == str.size && wapp_str8_equal(join1, &str); - result = result && join2->size == str.size && wapp_str8_equal(join2, &str); + result = join1->size == str.size && wapp_str8_equal(join1, &str); + result = result && join2->size == str.size && wapp_str8_equal(join2, &str); - wapp_mem_arena_allocator_destroy(&arena); + wapp_mem_arena_allocator_destroy(&arena); - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_str8_from_bytes(void) { - b8 result; + b8 result; - Str8 str = wapp_str8_buf(1024); - U8Array bytes = wapp_array(u8, U8Array, 'W', 'A', 'P', 'P'); - wapp_str8_from_bytes(&str, &bytes); + Str8 str = wapp_str8_buf(1024); + U8Array bytes = wapp_array(u8, U8Array, '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")); + result = str.size == bytes.count * bytes.item_size; + result = result && wapp_str8_equal(&str, &wapp_str8_lit_ro("WAPP")); - return wapp_tester_result(result); + return wapp_tester_result(result); } diff --git a/tests/str8/test_str8.cc b/tests/str8/test_str8.cc index 68295a0..151fdcb 100644 --- a/tests/str8/test_str8.cc +++ b/tests/str8/test_str8.cc @@ -4,624 +4,624 @@ #define ARRLEN(ARR) (sizeof(ARR) / sizeof(ARR[0])) TestFuncResult test_str8_lit(void) { - b8 result; + b8 result; - Str8 s1 = wapp_str8_lit("Hello world"); - result = s1.capacity == 22 && s1.capacity != s1.size; + Str8 s1 = wapp_str8_lit("Hello world"); + result = s1.capacity == 22 && s1.capacity != s1.size; - Str8 s2 = wapp_str8_lit("Different strokes for different folks"); - result = result && s2.capacity == 74 && s2.capacity != s2.size; + Str8 s2 = wapp_str8_lit("Different strokes for different folks"); + result = result && s2.capacity == 74 && s2.capacity != s2.size; - Str8 s3 = wapp_str8_lit("Discretion is the better part of valour"); - result = result && s3.capacity == 78 && s3.capacity != s3.size; + Str8 s3 = wapp_str8_lit("Discretion is the better part of valour"); + result = result && s3.capacity == 78 && s3.capacity != s3.size; - Str8 s4 = wapp_str8_lit("Distance lends enchantment to the view"); - result = result && s4.capacity == 76 && s4.capacity != s4.size; + Str8 s4 = wapp_str8_lit("Distance lends enchantment to the view"); + result = result && s4.capacity == 76 && s4.capacity != s4.size; - Str8 s5 = wapp_str8_lit("Do as I say, not as I do"); - result = result && s5.capacity == 48 && s5.capacity != s5.size; + Str8 s5 = wapp_str8_lit("Do as I say, not as I do"); + result = result && s5.capacity == 48 && s5.capacity != s5.size; - Str8 s6 = wapp_str8_lit("Do as you would be done by"); - result = result && s6.capacity == 52 && s6.capacity != s6.size; + Str8 s6 = wapp_str8_lit("Do as you would be done by"); + result = result && s6.capacity == 52 && s6.capacity != s6.size; - Str8 s7 = wapp_str8_lit("Do unto others as you would have them do to you"); - result = result && s7.capacity == 94 && s7.capacity != s7.size; + Str8 s7 = wapp_str8_lit("Do unto others as you would have them do to you"); + result = result && s7.capacity == 94 && s7.capacity != s7.size; - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_str8_lit_ro(void) { - b8 result; + b8 result; - Str8RO s1 = wapp_str8_lit_ro("Hello world"); - result = s1.capacity == 11 && s1.capacity == s1.size; + Str8RO s1 = wapp_str8_lit_ro("Hello world"); + result = s1.capacity == 11 && s1.capacity == s1.size; - Str8RO s2 = wapp_str8_lit_ro("Different strokes for different folks"); - result = result && s2.capacity == 37 && s2.capacity == s2.size; + Str8RO s2 = wapp_str8_lit_ro("Different strokes for different folks"); + result = result && s2.capacity == 37 && s2.capacity == s2.size; - Str8RO s3 = wapp_str8_lit_ro("Discretion is the better part of valour"); - result = result && s3.capacity == 39 && s3.capacity == s3.size; + Str8RO s3 = wapp_str8_lit_ro("Discretion is the better part of valour"); + result = result && s3.capacity == 39 && s3.capacity == s3.size; - Str8RO s4 = wapp_str8_lit_ro("Distance lends enchantment to the view"); - result = result && s4.capacity == 38 && s4.capacity == s4.size; + Str8RO s4 = wapp_str8_lit_ro("Distance lends enchantment to the view"); + result = result && s4.capacity == 38 && s4.capacity == s4.size; - Str8RO s5 = wapp_str8_lit_ro("Do as I say, not as I do"); - result = result && s5.capacity == 24 && s5.capacity == s5.size; + Str8RO s5 = wapp_str8_lit_ro("Do as I say, not as I do"); + result = result && s5.capacity == 24 && s5.capacity == s5.size; - Str8RO s6 = wapp_str8_lit_ro("Do as you would be done by"); - result = result && s6.capacity == 26 && s6.capacity == s6.size; + Str8RO s6 = wapp_str8_lit_ro("Do as you would be done by"); + result = result && s6.capacity == 26 && s6.capacity == s6.size; - Str8RO s7 = wapp_str8_lit_ro("Do unto others as you would have them do to you"); - result = result && s7.capacity == 47 && s7.capacity == s7.size; + Str8RO s7 = wapp_str8_lit_ro("Do unto others as you would have them do to you"); + result = result && s7.capacity == 47 && s7.capacity == s7.size; - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_str8_buf(void) { - b8 result; + b8 result; - Str8 s1 = wapp_str8_buf(1024); - result = s1.capacity == 1024 && s1.size == 0; + Str8 s1 = wapp_str8_buf(1024); + result = s1.capacity == 1024 && s1.size == 0; - Str8 s2 = wapp_str8_buf(2048); - result = result && s2.capacity == 2048 && s2.size == 0; + Str8 s2 = wapp_str8_buf(2048); + result = result && s2.capacity == 2048 && s2.size == 0; - Str8 s3 = wapp_str8_buf(4096); - result = result && s3.capacity == 4096 && s3.size == 0; + Str8 s3 = wapp_str8_buf(4096); + result = result && s3.capacity == 4096 && s3.size == 0; - Str8 s4 = wapp_str8_buf(8192); - result = result && s4.capacity == 8192 && s4.size == 0; + Str8 s4 = wapp_str8_buf(8192); + result = result && s4.capacity == 8192 && s4.size == 0; - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_str8_alloc_buf(void) { - b8 result; - Allocator allocator = wapp_mem_arena_allocator_init(KiB(100)); - if (wapp_mem_allocator_invalid(&allocator)) { - return wapp_tester_result(false); - } + b8 result; + Allocator allocator = wapp_mem_arena_allocator_init(KiB(100)); + if (wapp_mem_allocator_invalid(&allocator)) { + return wapp_tester_result(false); + } - u64 capacity = 4096; + u64 capacity = 4096; - Str8 *s = wapp_str8_alloc_buf(&allocator, capacity); - if (!s) { - result = false; - wapp_mem_arena_allocator_destroy(&allocator); - return wapp_tester_result(result); - } + Str8 *s = wapp_str8_alloc_buf(&allocator, capacity); + if (!s) { + result = false; + wapp_mem_arena_allocator_destroy(&allocator); + return wapp_tester_result(result); + } - result = s->capacity == capacity; + result = s->capacity == capacity; - const char *cstr = "My name is Abdelrahman"; - wapp_str8_copy_cstr_capped(s, cstr); + const char *cstr = "My name is Abdelrahman"; + wapp_str8_copy_cstr_capped(s, cstr); - result = result && s->capacity == capacity && s->size == strlen(cstr) && memcmp(s->buf, cstr, s->size) == 0; + result = result && s->capacity == capacity && s->size == strlen(cstr) && memcmp(s->buf, cstr, s->size) == 0; - wapp_mem_arena_allocator_destroy(&allocator); + wapp_mem_arena_allocator_destroy(&allocator); - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_str8_alloc_cstr(void) { - b8 result; - Allocator allocator = wapp_mem_arena_allocator_init(KiB(100)); - if (wapp_mem_allocator_invalid(&allocator)) { - return wapp_tester_result(false); - } + b8 result; + Allocator allocator = wapp_mem_arena_allocator_init(KiB(100)); + if (wapp_mem_allocator_invalid(&allocator)) { + return wapp_tester_result(false); + } - const char *str = "Abdelrahman"; - u64 length = strlen(str); - Str8 *s = wapp_str8_alloc_cstr(&allocator, str); - if (!s) { - return wapp_tester_result(false); - } + const char *str = "Abdelrahman"; + u64 length = strlen(str); + Str8 *s = wapp_str8_alloc_cstr(&allocator, str); + if (!s) { + return wapp_tester_result(false); + } - result = s->size == length && memcmp(s->buf, str, length) == 0; + result = s->size == length && memcmp(s->buf, str, length) == 0; - wapp_mem_arena_allocator_destroy(&allocator); + wapp_mem_arena_allocator_destroy(&allocator); - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_str8_alloc_str8(void) { - b8 result; - Allocator allocator = wapp_mem_arena_allocator_init(KiB(100)); - if (wapp_mem_allocator_invalid(&allocator)) { - return wapp_tester_result(false); - } + b8 result; + Allocator allocator = wapp_mem_arena_allocator_init(KiB(100)); + if (wapp_mem_allocator_invalid(&allocator)) { + return wapp_tester_result(false); + } - Str8 str = wapp_str8_lit("Abdelrahman"); - Str8 *s = wapp_str8_alloc_str8(&allocator, &str); - if (!s) { - return wapp_tester_result(false); - } + Str8 str = wapp_str8_lit("Abdelrahman"); + Str8 *s = wapp_str8_alloc_str8(&allocator, &str); + if (!s) { + return wapp_tester_result(false); + } - result = wapp_str8_equal(s, &str); + result = wapp_str8_equal(s, &str); - wapp_mem_arena_allocator_destroy(&allocator); + wapp_mem_arena_allocator_destroy(&allocator); - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_str8_alloc_substr(void) { - b8 result; - Allocator allocator = wapp_mem_arena_allocator_init(KiB(100)); - if (wapp_mem_allocator_invalid(&allocator)) { - return wapp_tester_result(false); - } + b8 result; + Allocator allocator = wapp_mem_arena_allocator_init(KiB(100)); + if (wapp_mem_allocator_invalid(&allocator)) { + return wapp_tester_result(false); + } - Str8 str = wapp_str8_lit("Abdelrahman"); - Str8 *s = wapp_str8_alloc_substr(&allocator, &str, 3, 8); - if (!s) { - return wapp_tester_result(false); - } + Str8 str = wapp_str8_lit("Abdelrahman"); + Str8 *s = wapp_str8_alloc_substr(&allocator, &str, 3, 8); + if (!s) { + return wapp_tester_result(false); + } - result = s->size == 5 && memcmp(s->buf, "elrah", s->size) == 0; + result = s->size == 5 && memcmp(s->buf, "elrah", s->size) == 0; - wapp_mem_arena_allocator_destroy(&allocator); + wapp_mem_arena_allocator_destroy(&allocator); - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_str8_get_index_within_bounds(void) { - b8 result; + b8 result; - Str8RO s1 = wapp_str8_lit_ro("Hello world"); - result = wapp_str8_get(&s1, 4) == 'o'; + Str8RO s1 = wapp_str8_lit_ro("Hello world"); + result = wapp_str8_get(&s1, 4) == 'o'; - Str8RO s2 = wapp_str8_lit_ro("Different strokes for different folks"); - result = result && wapp_str8_get(&s2, 0) == 'D'; + Str8RO s2 = wapp_str8_lit_ro("Different strokes for different folks"); + result = result && wapp_str8_get(&s2, 0) == 'D'; - Str8RO s3 = wapp_str8_lit_ro("Discretion is the better part of valour"); - result = result && wapp_str8_get(&s3, 13) == ' '; + Str8RO s3 = wapp_str8_lit_ro("Discretion is the better part of valour"); + result = result && wapp_str8_get(&s3, 13) == ' '; - Str8RO s4 = wapp_str8_lit_ro("Distance lends enchantment to the view"); - result = result && wapp_str8_get(&s4, 20) == 'n'; + Str8RO s4 = wapp_str8_lit_ro("Distance lends enchantment to the view"); + result = result && wapp_str8_get(&s4, 20) == 'n'; - Str8RO s5 = wapp_str8_lit_ro("Do as I say, not as I do"); - result = result && wapp_str8_get(&s5, 11) == ','; + Str8RO s5 = wapp_str8_lit_ro("Do as I say, not as I do"); + result = result && wapp_str8_get(&s5, 11) == ','; - Str8RO s6 = wapp_str8_lit_ro("Do as you would be done by"); - result = result && wapp_str8_get(&s6, 25) == 'y'; + Str8RO s6 = wapp_str8_lit_ro("Do as you would be done by"); + result = result && wapp_str8_get(&s6, 25) == 'y'; - Str8RO s7 = wapp_str8_lit_ro("Do unto others as you would have them do to you"); - result = result && wapp_str8_get(&s7, 16) == 's'; + Str8RO s7 = wapp_str8_lit_ro("Do unto others as you would have them do to you"); + result = result && wapp_str8_get(&s7, 16) == 's'; - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_str8_get_index_out_of_bounds(void) { - Str8 s1 = wapp_str8_lit("Hello world"); - b8 result = wapp_str8_get(&s1, 20) == '\0'; - return wapp_tester_result(result); + Str8 s1 = wapp_str8_lit("Hello world"); + b8 result = wapp_str8_get(&s1, 20) == '\0'; + return wapp_tester_result(result); } TestFuncResult test_str8_set(void) { - b8 result; + b8 result; - Str8 s1 = wapp_str8_lit("Hello world"); - wapp_str8_set(&s1, 4, 'f'); - result = wapp_str8_get(&s1, 4) == 'f'; + Str8 s1 = wapp_str8_lit("Hello world"); + wapp_str8_set(&s1, 4, 'f'); + result = wapp_str8_get(&s1, 4) == 'f'; - Str8 s2 = wapp_str8_lit("Different strokes for different folks"); - wapp_str8_set(&s2, 0, 'A'); - result = result && wapp_str8_get(&s2, 0) == 'A'; + Str8 s2 = wapp_str8_lit("Different strokes for different folks"); + wapp_str8_set(&s2, 0, 'A'); + result = result && wapp_str8_get(&s2, 0) == 'A'; - Str8 s3 = wapp_str8_lit("Discretion is the better part of valour"); - wapp_str8_set(&s3, 13, 'u'); - result = result && wapp_str8_get(&s3, 13) == 'u'; + Str8 s3 = wapp_str8_lit("Discretion is the better part of valour"); + wapp_str8_set(&s3, 13, 'u'); + result = result && wapp_str8_get(&s3, 13) == 'u'; - Str8 s4 = wapp_str8_lit("Distance lends enchantment to the view"); - wapp_str8_set(&s4, 20, 'R'); - result = result && wapp_str8_get(&s4, 20) == 'R'; + Str8 s4 = wapp_str8_lit("Distance lends enchantment to the view"); + wapp_str8_set(&s4, 20, 'R'); + result = result && wapp_str8_get(&s4, 20) == 'R'; - Str8 s5 = wapp_str8_lit("Do as I say, not as I do"); - wapp_str8_set(&s5, 11, '.'); - result = result && wapp_str8_get(&s5, 11) == '.'; + Str8 s5 = wapp_str8_lit("Do as I say, not as I do"); + wapp_str8_set(&s5, 11, '.'); + result = result && wapp_str8_get(&s5, 11) == '.'; - Str8 s6 = wapp_str8_lit("Do as you would be done by"); - wapp_str8_set(&s6, 25, 'w'); - result = result && wapp_str8_get(&s6, 25) == 'w'; + Str8 s6 = wapp_str8_lit("Do as you would be done by"); + wapp_str8_set(&s6, 25, 'w'); + result = result && wapp_str8_get(&s6, 25) == 'w'; - Str8 s7 = wapp_str8_lit("Do unto others as you would have them do to you"); - wapp_str8_set(&s7, 16, 'i'); - result = result && wapp_str8_get(&s7, 16) == 'i'; + Str8 s7 = wapp_str8_lit("Do unto others as you would have them do to you"); + wapp_str8_set(&s7, 16, 'i'); + result = result && wapp_str8_get(&s7, 16) == 'i'; - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_str8_push_back(void) { - b8 result; + b8 result; - Str8 expected = wapp_str8_lit("Abdelrahman"); - Str8 buf = wapp_str8_buf(64); - wapp_str8_push_back(&buf, 'A'); - wapp_str8_push_back(&buf, 'b'); - wapp_str8_push_back(&buf, 'd'); - wapp_str8_push_back(&buf, 'e'); - wapp_str8_push_back(&buf, 'l'); - wapp_str8_push_back(&buf, 'r'); - wapp_str8_push_back(&buf, 'a'); - wapp_str8_push_back(&buf, 'h'); - wapp_str8_push_back(&buf, 'm'); - wapp_str8_push_back(&buf, 'a'); - wapp_str8_push_back(&buf, 'n'); + Str8 expected = wapp_str8_lit("Abdelrahman"); + Str8 buf = wapp_str8_buf(64); + wapp_str8_push_back(&buf, 'A'); + wapp_str8_push_back(&buf, 'b'); + wapp_str8_push_back(&buf, 'd'); + wapp_str8_push_back(&buf, 'e'); + wapp_str8_push_back(&buf, 'l'); + wapp_str8_push_back(&buf, 'r'); + wapp_str8_push_back(&buf, 'a'); + wapp_str8_push_back(&buf, 'h'); + wapp_str8_push_back(&buf, 'm'); + wapp_str8_push_back(&buf, 'a'); + wapp_str8_push_back(&buf, 'n'); - result = wapp_str8_equal(&buf, &expected); + result = wapp_str8_equal(&buf, &expected); - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_str8_equal(void) { - b8 result; + b8 result; - Str8RO s1 = wapp_str8_lit_ro("hello"); - Str8RO s2 = wapp_str8_lit_ro("hell"); - Str8RO s3 = wapp_str8_lit_ro("hello"); - Str8RO s4 = wapp_str8_lit_ro("goodbye"); + Str8RO s1 = wapp_str8_lit_ro("hello"); + Str8RO s2 = wapp_str8_lit_ro("hell"); + Str8RO s3 = wapp_str8_lit_ro("hello"); + Str8RO s4 = wapp_str8_lit_ro("goodbye"); - result = wapp_str8_equal(&s1, &s2) == false; - result = result && wapp_str8_equal(&s1, &s3) == (b8)true; - result = result && wapp_str8_equal(&s1, &s4) == (b8)false; + result = wapp_str8_equal(&s1, &s2) == false; + result = result && wapp_str8_equal(&s1, &s3) == (b8)true; + result = result && wapp_str8_equal(&s1, &s4) == (b8)false; - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_str8_slice(void) { - b8 result; - Str8 s = wapp_str8_lit("Different strokes for different folks"); + b8 result; + Str8 s = wapp_str8_lit("Different strokes for different folks"); - Str8RO sub1 = wapp_str8_slice(&s, 3, 9); - result = sub1.size == 6 && sub1.capacity == 6; + Str8RO sub1 = wapp_str8_slice(&s, 3, 9); + result = sub1.size == 6 && sub1.capacity == 6; - Str8RO sub2 = wapp_str8_slice(&s, 18, 21); - result = result && sub2.size == 3 && sub2.capacity == 3; + Str8RO sub2 = wapp_str8_slice(&s, 18, 21); + result = result && sub2.size == 3 && sub2.capacity == 3; - Str8RO sub3 = wapp_str8_slice(&s, 5, 1); - result = result && sub3.size == 0 && sub3.capacity == 0; + Str8RO sub3 = wapp_str8_slice(&s, 5, 1); + result = result && sub3.size == 0 && sub3.capacity == 0; - Str8RO sub4 = wapp_str8_slice(&s, 70, 80); - result = result && sub4.size == 0 && sub4.capacity == 0; + Str8RO sub4 = wapp_str8_slice(&s, 70, 80); + result = result && sub4.size == 0 && sub4.capacity == 0; - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_str8_alloc_concat(void) { - b8 result; - Allocator arena = wapp_mem_arena_allocator_init(KiB(100)); + b8 result; + Allocator arena = wapp_mem_arena_allocator_init(KiB(100)); - Str8 str = wapp_str8_lit("Hello world"); - Str8 suffix1 = wapp_str8_lit(" from me."); - Str8 suffix2 = wapp_str8_lit(" This is my code."); - Str8 concat1 = wapp_str8_lit("Hello world from me."); - Str8 concat2 = wapp_str8_lit("Hello world from me. This is my code."); + Str8 str = wapp_str8_lit("Hello world"); + Str8 suffix1 = wapp_str8_lit(" from me."); + Str8 suffix2 = wapp_str8_lit(" This is my code."); + Str8 concat1 = wapp_str8_lit("Hello world from me."); + Str8 concat2 = wapp_str8_lit("Hello world from me. This is my code."); - Str8 *output; + Str8 *output; - output = wapp_str8_alloc_concat(&arena, &str, &suffix1); - result = output->size == concat1.size && wapp_str8_equal(output, &concat1); + output = wapp_str8_alloc_concat(&arena, &str, &suffix1); + result = output->size == concat1.size && wapp_str8_equal(output, &concat1); - output = wapp_str8_alloc_concat(&arena, output, &suffix2); - result = result && output->size == concat2.size && wapp_str8_equal(output, &concat2); + output = wapp_str8_alloc_concat(&arena, output, &suffix2); + result = result && output->size == concat2.size && wapp_str8_equal(output, &concat2); - wapp_mem_arena_allocator_destroy(&arena); + wapp_mem_arena_allocator_destroy(&arena); - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_str8_concat_capped(void) { - b8 result; + b8 result; - Str8 str = wapp_str8_lit("Hello world"); - Str8 suffix1 = wapp_str8_lit(" from me."); - Str8 suffix2 = wapp_str8_lit(" This is my code."); - Str8 concat1 = wapp_str8_lit("Hello world from me."); - Str8 concat2 = wapp_str8_lit("Hello world from me. T"); + Str8 str = wapp_str8_lit("Hello world"); + Str8 suffix1 = wapp_str8_lit(" from me."); + Str8 suffix2 = wapp_str8_lit(" This is my code."); + Str8 concat1 = wapp_str8_lit("Hello world from me."); + Str8 concat2 = wapp_str8_lit("Hello world from me. T"); - wapp_str8_concat_capped(&str, &suffix1); - result = str.size == concat1.size && wapp_str8_equal(&str, &concat1); + wapp_str8_concat_capped(&str, &suffix1); + result = str.size == concat1.size && wapp_str8_equal(&str, &concat1); - wapp_str8_concat_capped(&str, &suffix2); - result = result && str.size == concat2.size && wapp_str8_equal(&str, &concat2); + wapp_str8_concat_capped(&str, &suffix2); + result = result && str.size == concat2.size && wapp_str8_equal(&str, &concat2); - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_str8_copy_cstr_capped(void) { - b8 result; + b8 result; - Str8 buf = wapp_str8_buf(32); - const char *src1 = "Hello world"; - const char *src2 = "Hello world from the Wizard Apprentice standard library"; - Str8RO src1_cp = wapp_str8_lit_ro("Hello world"); - Str8RO src2_cp = wapp_str8_lit_ro("Hello world from the Wizard Appr"); + Str8 buf = wapp_str8_buf(32); + const char *src1 = "Hello world"; + const char *src2 = "Hello world from the Wizard Apprentice standard library"; + Str8RO src1_cp = wapp_str8_lit_ro("Hello world"); + Str8RO src2_cp = wapp_str8_lit_ro("Hello world from the Wizard Appr"); - wapp_str8_copy_cstr_capped(&buf, src1); - result = buf.size == src1_cp.size && wapp_str8_equal(&buf, &src1_cp); + wapp_str8_copy_cstr_capped(&buf, src1); + result = buf.size == src1_cp.size && wapp_str8_equal(&buf, &src1_cp); - wapp_str8_copy_cstr_capped(&buf, src2); - result = result && buf.size == src2_cp.size && buf.size == buf.capacity && wapp_str8_equal(&buf, &src2_cp); + wapp_str8_copy_cstr_capped(&buf, src2); + result = result && buf.size == src2_cp.size && buf.size == buf.capacity && wapp_str8_equal(&buf, &src2_cp); - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_str8_copy_str8_capped(void) { - b8 result; + b8 result; - Str8 buf = wapp_str8_buf(32); - Str8RO src1 = wapp_str8_lit_ro("Hello world"); - Str8RO src2 = wapp_str8_lit_ro("Hello world from the Wizard Apprentice standard library"); - Str8RO src2_cp = wapp_str8_lit_ro("Hello world from the Wizard Appr"); + Str8 buf = wapp_str8_buf(32); + Str8RO src1 = wapp_str8_lit_ro("Hello world"); + Str8RO src2 = wapp_str8_lit_ro("Hello world from the Wizard Apprentice standard library"); + Str8RO src2_cp = wapp_str8_lit_ro("Hello world from the Wizard Appr"); - wapp_str8_copy_str8_capped(&buf, &src1); - result = buf.size == src1.size && wapp_str8_equal(&buf, &src1); + wapp_str8_copy_str8_capped(&buf, &src1); + result = buf.size == src1.size && wapp_str8_equal(&buf, &src1); - wapp_str8_copy_str8_capped(&buf, &src2); - result = result && buf.size < src2.size && buf.size == buf.capacity && wapp_str8_equal(&buf, &src2_cp); + wapp_str8_copy_str8_capped(&buf, &src2); + result = result && buf.size < src2.size && buf.size == buf.capacity && wapp_str8_equal(&buf, &src2_cp); - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_str8_format(void) { - b8 result; + b8 result; - Str8 buf = wapp_str8_buf(128); - Str8 expected = wapp_str8_lit("My name is Abdelrahman and I am 35 years old"); + Str8 buf = wapp_str8_buf(128); + Str8 expected = wapp_str8_lit("My name is Abdelrahman and I am 35 years old"); - wapp_str8_format(&buf, "My name is %s and I am %u years old", "Abdelrahman", 35); + wapp_str8_format(&buf, "My name is %s and I am %u years old", "Abdelrahman", 35); - result = wapp_str8_equal(&buf, &expected); + result = wapp_str8_equal(&buf, &expected); - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_str8_find(void) { - b8 result; - Str8RO s = wapp_str8_lit("Do as I say, not as I do"); + b8 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; - result = result && (wapp_str8_find(&s, wapp_str8_lit_ro("not")) != -1); - result = result && (wapp_str8_find(&s, wapp_str8_lit_ro("as I say")) != -1); + result = wapp_str8_find(&s, wapp_str8_lit_ro("d")) != -1; + result = result && (wapp_str8_find(&s, wapp_str8_lit_ro("not")) != -1); + result = result && (wapp_str8_find(&s, wapp_str8_lit_ro("as I say")) != -1); - result = result && (wapp_str8_find(&s, wapp_str8_lit_ro("f")) == -1); - result = result && (wapp_str8_find(&s, wapp_str8_lit_ro("hello")) == -1); - result = result && (wapp_str8_find(&s, wapp_str8_lit_ro("not sa I")) == -1); - result = result && (wapp_str8_find(&s, wapp_str8_lit_ro("Do unto others as you would have them do to you")) == -1); + result = result && (wapp_str8_find(&s, wapp_str8_lit_ro("f")) == -1); + result = result && (wapp_str8_find(&s, wapp_str8_lit_ro("hello")) == -1); + result = result && (wapp_str8_find(&s, wapp_str8_lit_ro("not sa I")) == -1); + result = result && (wapp_str8_find(&s, wapp_str8_lit_ro("Do unto others as you would have them do to you")) == -1); - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_str8_rfind(void) { - b8 result; - Str8RO s = wapp_str8_lit("Do as I say, not as I do"); + b8 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; - result = result && (wapp_str8_rfind(&s, wapp_str8_lit_ro("not")) != -1); - result = result && (wapp_str8_rfind(&s, wapp_str8_lit_ro("as I say")) != -1); + result = wapp_str8_rfind(&s, wapp_str8_lit_ro("d")) != -1; + result = result && (wapp_str8_rfind(&s, wapp_str8_lit_ro("not")) != -1); + result = result && (wapp_str8_rfind(&s, wapp_str8_lit_ro("as I say")) != -1); - result = result && (wapp_str8_rfind(&s, wapp_str8_lit_ro("f")) == -1); - result = result && (wapp_str8_rfind(&s, wapp_str8_lit_ro("hello")) == -1); - result = result && (wapp_str8_rfind(&s, wapp_str8_lit_ro("not sa I")) == -1); - result = result && (wapp_str8_rfind(&s, wapp_str8_lit_ro("Do unto others as you would have them do to you")) == -1); + result = result && (wapp_str8_rfind(&s, wapp_str8_lit_ro("f")) == -1); + result = result && (wapp_str8_rfind(&s, wapp_str8_lit_ro("hello")) == -1); + result = result && (wapp_str8_rfind(&s, wapp_str8_lit_ro("not sa I")) == -1); + result = result && (wapp_str8_rfind(&s, wapp_str8_lit_ro("Do unto others as you would have them do to you")) == -1); - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_str8_split(void) { - b8 result; - Allocator arena = wapp_mem_arena_allocator_init(KiB(100)); + b8 result; + Allocator arena = wapp_mem_arena_allocator_init(KiB(100)); - Str8 str = wapp_str8_lit("hello world from me"); - Str8 delim1 = wapp_str8_lit(" "); - Str8 delim2 = wapp_str8_lit("from"); - Str8List *list1 = wapp_str8_split(&arena, &str, &delim1); - Str8List *list2 = wapp_str8_split(&arena, &str, &delim2); + Str8 str = wapp_str8_lit("hello world from me"); + Str8 delim1 = wapp_str8_lit(" "); + Str8 delim2 = wapp_str8_lit("from"); + Str8List *list1 = wapp_str8_split(&arena, &str, &delim1); + Str8List *list2 = wapp_str8_split(&arena, &str, &delim2); - Str8RO splits1[] = { - wapp_str8_slice(&str, 0, 5), - wapp_str8_slice(&str, 6, 11), - wapp_str8_slice(&str, 12, 16), - wapp_str8_slice(&str, 17, 19), - }; - Str8RO splits2[] = { - wapp_str8_slice(&str, 0, 12), - wapp_str8_slice(&str, 16, 19), - }; + Str8RO splits1[] = { + wapp_str8_slice(&str, 0, 5), + wapp_str8_slice(&str, 6, 11), + wapp_str8_slice(&str, 12, 16), + wapp_str8_slice(&str, 17, 19), + }; + Str8RO splits2[] = { + wapp_str8_slice(&str, 0, 12), + wapp_str8_slice(&str, 16, 19), + }; - u64 index1 = 0; - u64 count1 = ARRLEN(splits1); - b8 running1 = true; + u64 index1 = 0; + u64 count1 = ARRLEN(splits1); + b8 running1 = true; - u64 index2 = 0; - u64 count2 = ARRLEN(splits2); - b8 running2 = true; + u64 index2 = 0; + u64 count2 = ARRLEN(splits2); + b8 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; + 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; - // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of - // MSVC Spectre mitigation warnings - while (running1) { - Str8Node *node = wapp_dbl_list_get(Str8, Str8Node, list1, index1); - result = result && wapp_str8_equal(node->item, &(splits1[index1])); + // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of + // MSVC Spectre mitigation warnings + while (running1) { + Str8Node *node = wapp_dbl_list_get(Str8, Str8Node, list1, index1); + result = result && wapp_str8_equal(node->item, &(splits1[index1])); - ++index1; - running1 = index1 < count1; - } + ++index1; + running1 = index1 < count1; + } - // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of - // MSVC Spectre mitigation warnings - while (running2) { - Str8Node *node = wapp_dbl_list_get(Str8, Str8Node, list2, index2); - result = result && wapp_str8_equal(node->item, &(splits2[index2])); + // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of + // MSVC Spectre mitigation warnings + while (running2) { + Str8Node *node = wapp_dbl_list_get(Str8, Str8Node, list2, index2); + result = result && wapp_str8_equal(node->item, &(splits2[index2])); - ++index2; - running2 = index2 < count2; - } + ++index2; + running2 = index2 < count2; + } - wapp_mem_arena_allocator_destroy(&arena); + wapp_mem_arena_allocator_destroy(&arena); - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_str8_split_with_max(void) { - b8 result; - Allocator arena = wapp_mem_arena_allocator_init(KiB(100)); + b8 result; + Allocator arena = wapp_mem_arena_allocator_init(KiB(100)); - Str8 str = wapp_str8_lit("hello world from me"); - Str8 delim = wapp_str8_lit(" "); - Str8List *list = wapp_str8_split_with_max(&arena, &str, &delim, 2); + Str8 str = wapp_str8_lit("hello world from me"); + Str8 delim = wapp_str8_lit(" "); + Str8List *list = wapp_str8_split_with_max(&arena, &str, &delim, 2); - Str8RO splits[] = { - wapp_str8_slice(&str, 0, 5), - wapp_str8_slice(&str, 6, 11), - wapp_str8_slice(&str, 12, 19), - }; + Str8RO splits[] = { + wapp_str8_slice(&str, 0, 5), + wapp_str8_slice(&str, 6, 11), + wapp_str8_slice(&str, 12, 19), + }; - u64 index = 0; - u64 count = ARRLEN(splits); - b8 running = true; + u64 index = 0; + u64 count = ARRLEN(splits); + b8 running = true; - result = list->node_count == count && wapp_str8_list_total_size(list) == str.size - 2; + result = list->node_count == count && wapp_str8_list_total_size(list) == str.size - 2; - // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of - // MSVC Spectre mitigation warnings - while (running) { - Str8Node *node = wapp_dbl_list_get(Str8, Str8Node, list, index); - result = result && wapp_str8_equal(node->item, &(splits[index])); + // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of + // MSVC Spectre mitigation warnings + while (running) { + Str8Node *node = wapp_dbl_list_get(Str8, Str8Node, list, index); + result = result && wapp_str8_equal(node->item, &(splits[index])); - ++index; - running = index < count; - } + ++index; + running = index < count; + } - wapp_mem_arena_allocator_destroy(&arena); + wapp_mem_arena_allocator_destroy(&arena); - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_str8_rsplit(void) { - b8 result; - Allocator arena = wapp_mem_arena_allocator_init(KiB(100)); + b8 result; + Allocator arena = wapp_mem_arena_allocator_init(KiB(100)); - Str8 str = wapp_str8_lit("hello world from me"); - Str8 delim1 = wapp_str8_lit(" "); - Str8 delim2 = wapp_str8_lit("from"); - Str8List *list1 = wapp_str8_rsplit(&arena, &str, &delim1); - Str8List *list2 = wapp_str8_rsplit(&arena, &str, &delim2); + Str8 str = wapp_str8_lit("hello world from me"); + Str8 delim1 = wapp_str8_lit(" "); + Str8 delim2 = wapp_str8_lit("from"); + Str8List *list1 = wapp_str8_rsplit(&arena, &str, &delim1); + Str8List *list2 = wapp_str8_rsplit(&arena, &str, &delim2); - Str8RO splits1[] = { - wapp_str8_slice(&str, 0, 5), - wapp_str8_slice(&str, 6, 11), - wapp_str8_slice(&str, 12, 16), - wapp_str8_slice(&str, 17, 19), - }; - Str8RO splits2[] = { - wapp_str8_slice(&str, 0, 12), - wapp_str8_slice(&str, 16, 19), - }; + Str8RO splits1[] = { + wapp_str8_slice(&str, 0, 5), + wapp_str8_slice(&str, 6, 11), + wapp_str8_slice(&str, 12, 16), + wapp_str8_slice(&str, 17, 19), + }; + Str8RO splits2[] = { + wapp_str8_slice(&str, 0, 12), + wapp_str8_slice(&str, 16, 19), + }; - u64 index1 = 0; - u64 count1 = ARRLEN(splits1); - b8 running1 = true; + u64 index1 = 0; + u64 count1 = ARRLEN(splits1); + b8 running1 = true; - u64 index2 = 0; - u64 count2 = ARRLEN(splits2); - b8 running2 = true; + u64 index2 = 0; + u64 count2 = ARRLEN(splits2); + b8 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; + 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; - // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of - // MSVC Spectre mitigation warnings - while (running1) { - Str8Node *node = wapp_dbl_list_get(Str8, Str8Node, list1, index1); - result = result && wapp_str8_equal(node->item, &(splits1[index1])); + // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of + // MSVC Spectre mitigation warnings + while (running1) { + Str8Node *node = wapp_dbl_list_get(Str8, Str8Node, list1, index1); + result = result && wapp_str8_equal(node->item, &(splits1[index1])); - ++index1; - running1 = index1 < count1; - } + ++index1; + running1 = index1 < count1; + } - // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of - // MSVC Spectre mitigation warnings - while (running2) { - Str8Node *node = wapp_dbl_list_get(Str8, Str8Node, list2, index2); - result = result && wapp_str8_equal(node->item, &(splits2[index2])); + // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of + // MSVC Spectre mitigation warnings + while (running2) { + Str8Node *node = wapp_dbl_list_get(Str8, Str8Node, list2, index2); + result = result && wapp_str8_equal(node->item, &(splits2[index2])); - ++index2; - running2 = index2 < count2; - } + ++index2; + running2 = index2 < count2; + } - wapp_mem_arena_allocator_destroy(&arena); + wapp_mem_arena_allocator_destroy(&arena); - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_str8_rsplit_with_max(void) { - b8 result; - Allocator arena = wapp_mem_arena_allocator_init(KiB(100)); + b8 result; + Allocator arena = wapp_mem_arena_allocator_init(KiB(100)); - Str8 str = wapp_str8_lit("hello world from me"); - Str8 delim = wapp_str8_lit(" "); - Str8List *list = wapp_str8_rsplit_with_max(&arena, &str, &delim, 2); + Str8 str = wapp_str8_lit("hello world from me"); + Str8 delim = wapp_str8_lit(" "); + Str8List *list = wapp_str8_rsplit_with_max(&arena, &str, &delim, 2); - Str8RO splits[] = { - wapp_str8_slice(&str, 0, 11), - wapp_str8_slice(&str, 12, 16), - wapp_str8_slice(&str, 17, 19), - }; + Str8RO splits[] = { + wapp_str8_slice(&str, 0, 11), + wapp_str8_slice(&str, 12, 16), + wapp_str8_slice(&str, 17, 19), + }; - u64 index = 0; - u64 count = ARRLEN(splits); - b8 running = true; + u64 index = 0; + u64 count = ARRLEN(splits); + b8 running = true; - result = list->node_count == count && wapp_str8_list_total_size(list) == str.size - 2; + result = list->node_count == count && wapp_str8_list_total_size(list) == str.size - 2; - // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of - // MSVC Spectre mitigation warnings - while (running) { - Str8Node *node = wapp_dbl_list_get(Str8, Str8Node, list, index); - result = result && wapp_str8_equal(node->item, &(splits[index])); + // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of + // MSVC Spectre mitigation warnings + while (running) { + Str8Node *node = wapp_dbl_list_get(Str8, Str8Node, list, index); + result = result && wapp_str8_equal(node->item, &(splits[index])); - ++index; - running = index < count; - } + ++index; + running = index < count; + } - wapp_mem_arena_allocator_destroy(&arena); + wapp_mem_arena_allocator_destroy(&arena); - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_str8_join(void) { - b8 result; - Allocator arena = wapp_mem_arena_allocator_init(KiB(100)); + b8 result; + Allocator arena = wapp_mem_arena_allocator_init(KiB(100)); - Str8 str = wapp_str8_lit("hello world from me"); - Str8 delim1 = wapp_str8_lit(" "); - Str8 delim2 = wapp_str8_lit("from"); - Str8List *list1 = wapp_str8_rsplit(&arena, &str, &delim1); - Str8List *list2 = wapp_str8_rsplit(&arena, &str, &delim2); - Str8 *join1 = wapp_str8_join(&arena, list1, &delim1); - Str8 *join2 = wapp_str8_join(&arena, list2, &delim2); + Str8 str = wapp_str8_lit("hello world from me"); + Str8 delim1 = wapp_str8_lit(" "); + Str8 delim2 = wapp_str8_lit("from"); + Str8List *list1 = wapp_str8_rsplit(&arena, &str, &delim1); + Str8List *list2 = wapp_str8_rsplit(&arena, &str, &delim2); + Str8 *join1 = wapp_str8_join(&arena, list1, &delim1); + Str8 *join2 = wapp_str8_join(&arena, list2, &delim2); - result = join1->size == str.size && wapp_str8_equal(join1, &str); - result = result && join2->size == str.size && wapp_str8_equal(join2, &str); + result = join1->size == str.size && wapp_str8_equal(join1, &str); + result = result && join2->size == str.size && wapp_str8_equal(join2, &str); - wapp_mem_arena_allocator_destroy(&arena); + wapp_mem_arena_allocator_destroy(&arena); - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_str8_from_bytes(void) { - b8 result; + b8 result; - Str8 str = wapp_str8_buf(1024); - Str8 expected = wapp_str8_lit_ro("WAPP"); - U8Array bytes = wapp_array(u8, U8Array, 'W', 'A', 'P', 'P'); - wapp_str8_from_bytes(&str, &bytes); + Str8 str = wapp_str8_buf(1024); + Str8 expected = wapp_str8_lit_ro("WAPP"); + U8Array bytes = wapp_array(u8, U8Array, '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); + result = str.size == bytes.count * bytes.item_size; + result = result && wapp_str8_equal(&str, &expected); - return wapp_tester_result(result); + return wapp_tester_result(result); } diff --git a/tests/str8/test_str8_list.c b/tests/str8/test_str8_list.c index 2797b26..62a07f2 100644 --- a/tests/str8/test_str8_list.c +++ b/tests/str8/test_str8_list.c @@ -2,262 +2,262 @@ #include "wapp.h" TestFuncResult test_str8_list_get(void) { - b8 result; + b8 result; - Str8 s1 = wapp_str8_lit("1"); - Str8 s2 = wapp_str8_lit("2"); - Str8 s3 = wapp_str8_lit("3"); - Str8 s4 = wapp_str8_lit("4"); - Str8 s5 = wapp_str8_lit("5"); + Str8 s1 = wapp_str8_lit("1"); + Str8 s2 = wapp_str8_lit("2"); + Str8 s3 = wapp_str8_lit("3"); + Str8 s4 = wapp_str8_lit("4"); + Str8 s5 = wapp_str8_lit("5"); - Str8List list = wapp_dbl_list(Str8, Str8List); - Str8Node n1 = wapp_str8_node_from_str8(s1); - Str8Node n2 = wapp_str8_node_from_str8(s2); - Str8Node n3 = wapp_str8_node_from_str8(s3); - Str8Node n4 = wapp_str8_node_from_str8(s4); - Str8Node n5 = wapp_str8_node_from_str8(s5); + Str8List list = wapp_dbl_list(Str8, Str8List); + Str8Node n1 = wapp_str8_node_from_str8(s1); + Str8Node n2 = wapp_str8_node_from_str8(s2); + Str8Node n3 = wapp_str8_node_from_str8(s3); + Str8Node n4 = wapp_str8_node_from_str8(s4); + Str8Node n5 = wapp_str8_node_from_str8(s5); - wapp_dbl_list_push_back(Str8, &list, &n1); - wapp_dbl_list_push_back(Str8, &list, &n2); - wapp_dbl_list_push_back(Str8, &list, &n3); - wapp_dbl_list_push_back(Str8, &list, &n4); - wapp_dbl_list_push_back(Str8, &list, &n5); + wapp_dbl_list_push_back(Str8, &list, &n1); + wapp_dbl_list_push_back(Str8, &list, &n2); + wapp_dbl_list_push_back(Str8, &list, &n3); + wapp_dbl_list_push_back(Str8, &list, &n4); + wapp_dbl_list_push_back(Str8, &list, &n5); - Str8Node *node = wapp_dbl_list_get(Str8, Str8Node, &list, 0); - result = node->item == &s1 && wapp_str8_equal(node->item, &s1); + Str8Node *node = wapp_dbl_list_get(Str8, Str8Node, &list, 0); + result = node->item == &s1 && wapp_str8_equal(node->item, &s1); - node = wapp_dbl_list_get(Str8, Str8Node, &list, 1); - result = result && node->item == &s2 && wapp_str8_equal(node->item, &s2); + node = wapp_dbl_list_get(Str8, Str8Node, &list, 1); + result = result && node->item == &s2 && wapp_str8_equal(node->item, &s2); - node = wapp_dbl_list_get(Str8, Str8Node, &list, 2); - result = result && node->item == &s3 && wapp_str8_equal(node->item, &s3); + node = wapp_dbl_list_get(Str8, Str8Node, &list, 2); + result = result && node->item == &s3 && wapp_str8_equal(node->item, &s3); - node = wapp_dbl_list_get(Str8, Str8Node, &list, 3); - result = result && node->item == &s4 && wapp_str8_equal(node->item, &s4); + node = wapp_dbl_list_get(Str8, Str8Node, &list, 3); + result = result && node->item == &s4 && wapp_str8_equal(node->item, &s4); - node = wapp_dbl_list_get(Str8, Str8Node, &list, 4); - result = result && node->item == &s5 && wapp_str8_equal(node->item, &s5); + node = wapp_dbl_list_get(Str8, Str8Node, &list, 4); + result = result && node->item == &s5 && wapp_str8_equal(node->item, &s5); - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_str8_list_push_front(void) { - b8 result; + b8 result; - Str8 s1 = wapp_str8_lit("1"); - Str8 s2 = wapp_str8_lit("2"); - Str8 s3 = wapp_str8_lit("3"); + Str8 s1 = wapp_str8_lit("1"); + Str8 s2 = wapp_str8_lit("2"); + Str8 s3 = wapp_str8_lit("3"); - Str8List list = wapp_dbl_list(Str8, Str8List); - Str8Node n1 = wapp_str8_node_from_str8(s1); - Str8Node n2 = wapp_str8_node_from_str8(s2); - Str8Node n3 = wapp_str8_node_from_str8(s3); + Str8List list = wapp_dbl_list(Str8, Str8List); + Str8Node n1 = wapp_str8_node_from_str8(s1); + Str8Node n2 = wapp_str8_node_from_str8(s2); + Str8Node n3 = wapp_str8_node_from_str8(s3); - wapp_dbl_list_push_front(Str8, &list, &n1); - result = list.first == list.last && list.first == &n1 && list.first->item == &s1 && wapp_str8_list_total_size(&list) == 1 && list.node_count == 1; + wapp_dbl_list_push_front(Str8, &list, &n1); + result = list.first == list.last && list.first == &n1 && list.first->item == &s1 && wapp_str8_list_total_size(&list) == 1 && list.node_count == 1; - wapp_dbl_list_push_front(Str8, &list, &n2); - result = result && list.first == &n2 && list.first->item == &s2 && wapp_str8_list_total_size(&list) == 2 && list.node_count == 2; + wapp_dbl_list_push_front(Str8, &list, &n2); + result = result && list.first == &n2 && list.first->item == &s2 && wapp_str8_list_total_size(&list) == 2 && list.node_count == 2; - wapp_dbl_list_push_front(Str8, &list, &n3); - result = result && list.first == &n3 && list.first->item == &s3 && wapp_str8_list_total_size(&list) == 3 && list.node_count == 3; + wapp_dbl_list_push_front(Str8, &list, &n3); + result = result && list.first == &n3 && list.first->item == &s3 && wapp_str8_list_total_size(&list) == 3 && list.node_count == 3; - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_str8_list_push_back(void) { - b8 result; + b8 result; - Str8 s1 = wapp_str8_lit("1"); - Str8 s2 = wapp_str8_lit("2"); - Str8 s3 = wapp_str8_lit("3"); + Str8 s1 = wapp_str8_lit("1"); + Str8 s2 = wapp_str8_lit("2"); + Str8 s3 = wapp_str8_lit("3"); - Str8List list = wapp_dbl_list(Str8, Str8List); - Str8Node n1 = wapp_str8_node_from_str8(s1); - Str8Node n2 = wapp_str8_node_from_str8(s2); - Str8Node n3 = wapp_str8_node_from_str8(s3); + Str8List list = wapp_dbl_list(Str8, Str8List); + Str8Node n1 = wapp_str8_node_from_str8(s1); + Str8Node n2 = wapp_str8_node_from_str8(s2); + Str8Node n3 = wapp_str8_node_from_str8(s3); - wapp_dbl_list_push_back(Str8, &list, &n1); - result = list.first == list.last && list.last == &n1 && list.last->item == &s1 && wapp_str8_list_total_size(&list) == 1 && list.node_count == 1; + wapp_dbl_list_push_back(Str8, &list, &n1); + result = list.first == list.last && list.last == &n1 && list.last->item == &s1 && wapp_str8_list_total_size(&list) == 1 && list.node_count == 1; - wapp_dbl_list_push_back(Str8, &list, &n2); - result = result && list.last == &n2 && list.last->item == &s2 && wapp_str8_list_total_size(&list) == 2 && list.node_count == 2; + wapp_dbl_list_push_back(Str8, &list, &n2); + result = result && list.last == &n2 && list.last->item == &s2 && wapp_str8_list_total_size(&list) == 2 && list.node_count == 2; - wapp_dbl_list_push_back(Str8, &list, &n3); - result = result && list.last == &n3 && list.last->item == &s3 && wapp_str8_list_total_size(&list) == 3 && list.node_count == 3; + wapp_dbl_list_push_back(Str8, &list, &n3); + result = result && list.last == &n3 && list.last->item == &s3 && wapp_str8_list_total_size(&list) == 3 && list.node_count == 3; - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_str8_list_insert(void) { - b8 result; + b8 result; - Str8 s1 = wapp_str8_lit("1"); - Str8 s2 = wapp_str8_lit("2"); - Str8 s3 = wapp_str8_lit("3"); - Str8 s4 = wapp_str8_lit("4"); - Str8 s5 = wapp_str8_lit("5"); - Str8 s6 = wapp_str8_lit("6"); - Str8 s7 = wapp_str8_lit("7"); + Str8 s1 = wapp_str8_lit("1"); + Str8 s2 = wapp_str8_lit("2"); + Str8 s3 = wapp_str8_lit("3"); + Str8 s4 = wapp_str8_lit("4"); + Str8 s5 = wapp_str8_lit("5"); + Str8 s6 = wapp_str8_lit("6"); + Str8 s7 = wapp_str8_lit("7"); - Str8List list = wapp_dbl_list(Str8, Str8List); - Str8Node n1 = wapp_str8_node_from_str8(s1); - Str8Node n2 = wapp_str8_node_from_str8(s2); - Str8Node n3 = wapp_str8_node_from_str8(s3); - Str8Node n4 = wapp_str8_node_from_str8(s4); - Str8Node n5 = wapp_str8_node_from_str8(s5); - Str8Node n6 = wapp_str8_node_from_str8(s6); - Str8Node n7 = wapp_str8_node_from_str8(s7); + Str8List list = wapp_dbl_list(Str8, Str8List); + Str8Node n1 = wapp_str8_node_from_str8(s1); + Str8Node n2 = wapp_str8_node_from_str8(s2); + Str8Node n3 = wapp_str8_node_from_str8(s3); + Str8Node n4 = wapp_str8_node_from_str8(s4); + Str8Node n5 = wapp_str8_node_from_str8(s5); + Str8Node n6 = wapp_str8_node_from_str8(s6); + Str8Node n7 = wapp_str8_node_from_str8(s7); - wapp_dbl_list_push_back(Str8, &list, &n1); - wapp_dbl_list_push_back(Str8, &list, &n2); - wapp_dbl_list_push_back(Str8, &list, &n3); - wapp_dbl_list_push_back(Str8, &list, &n4); - wapp_dbl_list_push_back(Str8, &list, &n5); + wapp_dbl_list_push_back(Str8, &list, &n1); + wapp_dbl_list_push_back(Str8, &list, &n2); + wapp_dbl_list_push_back(Str8, &list, &n3); + wapp_dbl_list_push_back(Str8, &list, &n4); + wapp_dbl_list_push_back(Str8, &list, &n5); - Str8Node *node; - wapp_dbl_list_insert(Str8, &list, &n6, 2); - node = wapp_dbl_list_get(Str8, Str8Node, &list, 2); - result = node != NULL && node->item == &s6 && wapp_str8_list_total_size(&list) == 6 && list.node_count == 6; - wapp_dbl_list_insert(Str8, &list, &n7, 5); - node = wapp_dbl_list_get(Str8, Str8Node, &list, 5); - result = result && node != NULL && node->item == &s7 && wapp_str8_list_total_size(&list) == 7 && list.node_count == 7; + Str8Node *node; + wapp_dbl_list_insert(Str8, &list, &n6, 2); + node = wapp_dbl_list_get(Str8, Str8Node, &list, 2); + result = node != NULL && node->item == &s6 && wapp_str8_list_total_size(&list) == 6 && list.node_count == 6; + wapp_dbl_list_insert(Str8, &list, &n7, 5); + node = wapp_dbl_list_get(Str8, Str8Node, &list, 5); + result = result && node != NULL && node->item == &s7 && wapp_str8_list_total_size(&list) == 7 && list.node_count == 7; - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_str8_list_pop_front(void) { - b8 result; + b8 result; - Str8 s1 = wapp_str8_lit("1"); - Str8 s2 = wapp_str8_lit("2"); - Str8 s3 = wapp_str8_lit("3"); - Str8 s4 = wapp_str8_lit("4"); - Str8 s5 = wapp_str8_lit("5"); + Str8 s1 = wapp_str8_lit("1"); + Str8 s2 = wapp_str8_lit("2"); + Str8 s3 = wapp_str8_lit("3"); + Str8 s4 = wapp_str8_lit("4"); + Str8 s5 = wapp_str8_lit("5"); - Str8List list = wapp_dbl_list(Str8, Str8List); - Str8Node n1 = wapp_str8_node_from_str8(s1); - Str8Node n2 = wapp_str8_node_from_str8(s2); - Str8Node n3 = wapp_str8_node_from_str8(s3); - Str8Node n4 = wapp_str8_node_from_str8(s4); - Str8Node n5 = wapp_str8_node_from_str8(s5); + Str8List list = wapp_dbl_list(Str8, Str8List); + Str8Node n1 = wapp_str8_node_from_str8(s1); + Str8Node n2 = wapp_str8_node_from_str8(s2); + Str8Node n3 = wapp_str8_node_from_str8(s3); + Str8Node n4 = wapp_str8_node_from_str8(s4); + Str8Node n5 = wapp_str8_node_from_str8(s5); - wapp_dbl_list_push_back(Str8, &list, &n1); - wapp_dbl_list_push_back(Str8, &list, &n2); - wapp_dbl_list_push_back(Str8, &list, &n3); - wapp_dbl_list_push_back(Str8, &list, &n4); - wapp_dbl_list_push_back(Str8, &list, &n5); + wapp_dbl_list_push_back(Str8, &list, &n1); + wapp_dbl_list_push_back(Str8, &list, &n2); + wapp_dbl_list_push_back(Str8, &list, &n3); + wapp_dbl_list_push_back(Str8, &list, &n4); + wapp_dbl_list_push_back(Str8, &list, &n5); - Str8Node *node = wapp_dbl_list_pop_front(Str8, Str8Node, &list); - result = node == &n1 && node->item == &s1 && wapp_str8_equal(node->item, &s1) && wapp_str8_list_total_size(&list) == 4 && list.node_count == 4; + Str8Node *node = wapp_dbl_list_pop_front(Str8, Str8Node, &list); + result = node == &n1 && node->item == &s1 && wapp_str8_equal(node->item, &s1) && wapp_str8_list_total_size(&list) == 4 && list.node_count == 4; - node = wapp_dbl_list_pop_front(Str8, Str8Node, &list); - result = result && node == &n2 && node->item == &s2 && wapp_str8_equal(node->item, &s2) && wapp_str8_list_total_size(&list) == 3 && list.node_count == 3; + node = wapp_dbl_list_pop_front(Str8, Str8Node, &list); + result = result && node == &n2 && node->item == &s2 && wapp_str8_equal(node->item, &s2) && wapp_str8_list_total_size(&list) == 3 && list.node_count == 3; - node = wapp_dbl_list_pop_front(Str8, Str8Node, &list); - result = result && node == &n3 && node->item == &s3 && wapp_str8_equal(node->item, &s3) && wapp_str8_list_total_size(&list) == 2 && list.node_count == 2; + node = wapp_dbl_list_pop_front(Str8, Str8Node, &list); + result = result && node == &n3 && node->item == &s3 && wapp_str8_equal(node->item, &s3) && wapp_str8_list_total_size(&list) == 2 && list.node_count == 2; - node = wapp_dbl_list_pop_front(Str8, Str8Node, &list); - result = result && node == &n4 && node->item == &s4 && wapp_str8_equal(node->item, &s4) && wapp_str8_list_total_size(&list) == 1 && list.node_count == 1; + node = wapp_dbl_list_pop_front(Str8, Str8Node, &list); + result = result && node == &n4 && node->item == &s4 && wapp_str8_equal(node->item, &s4) && wapp_str8_list_total_size(&list) == 1 && list.node_count == 1; - node = wapp_dbl_list_pop_front(Str8, Str8Node, &list); - result = result && node == &n5 && node->item == &s5 && wapp_str8_equal(node->item, &s5) && wapp_str8_list_total_size(&list) == 0 && list.node_count == 0; + node = wapp_dbl_list_pop_front(Str8, Str8Node, &list); + result = result && node == &n5 && node->item == &s5 && wapp_str8_equal(node->item, &s5) && wapp_str8_list_total_size(&list) == 0 && list.node_count == 0; - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_str8_list_pop_back(void) { - b8 result; + b8 result; - Str8 s1 = wapp_str8_lit("1"); - Str8 s2 = wapp_str8_lit("2"); - Str8 s3 = wapp_str8_lit("3"); - Str8 s4 = wapp_str8_lit("4"); - Str8 s5 = wapp_str8_lit("5"); + Str8 s1 = wapp_str8_lit("1"); + Str8 s2 = wapp_str8_lit("2"); + Str8 s3 = wapp_str8_lit("3"); + Str8 s4 = wapp_str8_lit("4"); + Str8 s5 = wapp_str8_lit("5"); - Str8List list = wapp_dbl_list(Str8, Str8List); - Str8Node n1 = wapp_str8_node_from_str8(s1); - Str8Node n2 = wapp_str8_node_from_str8(s2); - Str8Node n3 = wapp_str8_node_from_str8(s3); - Str8Node n4 = wapp_str8_node_from_str8(s4); - Str8Node n5 = wapp_str8_node_from_str8(s5); + Str8List list = wapp_dbl_list(Str8, Str8List); + Str8Node n1 = wapp_str8_node_from_str8(s1); + Str8Node n2 = wapp_str8_node_from_str8(s2); + Str8Node n3 = wapp_str8_node_from_str8(s3); + Str8Node n4 = wapp_str8_node_from_str8(s4); + Str8Node n5 = wapp_str8_node_from_str8(s5); - wapp_dbl_list_push_front(Str8, &list, &n1); - wapp_dbl_list_push_front(Str8, &list, &n2); - wapp_dbl_list_push_front(Str8, &list, &n3); - wapp_dbl_list_push_front(Str8, &list, &n4); - wapp_dbl_list_push_front(Str8, &list, &n5); + wapp_dbl_list_push_front(Str8, &list, &n1); + wapp_dbl_list_push_front(Str8, &list, &n2); + wapp_dbl_list_push_front(Str8, &list, &n3); + wapp_dbl_list_push_front(Str8, &list, &n4); + wapp_dbl_list_push_front(Str8, &list, &n5); - Str8Node *node = wapp_dbl_list_pop_back(Str8, Str8Node, &list); - result = node == &n1 && node->item == &s1 && wapp_str8_equal(node->item, &s1) && wapp_str8_list_total_size(&list) == 4 && list.node_count == 4; + Str8Node *node = wapp_dbl_list_pop_back(Str8, Str8Node, &list); + result = node == &n1 && node->item == &s1 && wapp_str8_equal(node->item, &s1) && wapp_str8_list_total_size(&list) == 4 && list.node_count == 4; - node = wapp_dbl_list_pop_back(Str8, Str8Node, &list); - result = result && node == &n2 && node->item == &s2 && wapp_str8_equal(node->item, &s2) && wapp_str8_list_total_size(&list) == 3 && list.node_count == 3; + node = wapp_dbl_list_pop_back(Str8, Str8Node, &list); + result = result && node == &n2 && node->item == &s2 && wapp_str8_equal(node->item, &s2) && wapp_str8_list_total_size(&list) == 3 && list.node_count == 3; - node = wapp_dbl_list_pop_back(Str8, Str8Node, &list); - result = result && node == &n3 && node->item == &s3 && wapp_str8_equal(node->item, &s3) && wapp_str8_list_total_size(&list) == 2 && list.node_count == 2; + node = wapp_dbl_list_pop_back(Str8, Str8Node, &list); + result = result && node == &n3 && node->item == &s3 && wapp_str8_equal(node->item, &s3) && wapp_str8_list_total_size(&list) == 2 && list.node_count == 2; - node = wapp_dbl_list_pop_back(Str8, Str8Node, &list); - result = result && node == &n4 && node->item == &s4 && wapp_str8_equal(node->item, &s4) && wapp_str8_list_total_size(&list) == 1 && list.node_count == 1; + node = wapp_dbl_list_pop_back(Str8, Str8Node, &list); + result = result && node == &n4 && node->item == &s4 && wapp_str8_equal(node->item, &s4) && wapp_str8_list_total_size(&list) == 1 && list.node_count == 1; - node = wapp_dbl_list_pop_back(Str8, Str8Node, &list); - result = result && node == &n5 && node->item == &s5 && wapp_str8_equal(node->item, &s5) && wapp_str8_list_total_size(&list) == 0 && list.node_count == 0; + node = wapp_dbl_list_pop_back(Str8, Str8Node, &list); + result = result && node == &n5 && node->item == &s5 && wapp_str8_equal(node->item, &s5) && wapp_str8_list_total_size(&list) == 0 && list.node_count == 0; - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_str8_list_remove(void) { - b8 result; + b8 result; - Str8 s1 = wapp_str8_lit("1"); - Str8 s2 = wapp_str8_lit("2"); - Str8 s3 = wapp_str8_lit("3"); - Str8 s4 = wapp_str8_lit("4"); - Str8 s5 = wapp_str8_lit("5"); + Str8 s1 = wapp_str8_lit("1"); + Str8 s2 = wapp_str8_lit("2"); + Str8 s3 = wapp_str8_lit("3"); + Str8 s4 = wapp_str8_lit("4"); + Str8 s5 = wapp_str8_lit("5"); - Str8List list = wapp_dbl_list(Str8, Str8List); - Str8Node n1 = wapp_str8_node_from_str8(s1); - Str8Node n2 = wapp_str8_node_from_str8(s2); - Str8Node n3 = wapp_str8_node_from_str8(s3); - Str8Node n4 = wapp_str8_node_from_str8(s4); - Str8Node n5 = wapp_str8_node_from_str8(s5); + Str8List list = wapp_dbl_list(Str8, Str8List); + Str8Node n1 = wapp_str8_node_from_str8(s1); + Str8Node n2 = wapp_str8_node_from_str8(s2); + Str8Node n3 = wapp_str8_node_from_str8(s3); + Str8Node n4 = wapp_str8_node_from_str8(s4); + Str8Node n5 = wapp_str8_node_from_str8(s5); - wapp_dbl_list_push_back(Str8, &list, &n1); - wapp_dbl_list_push_back(Str8, &list, &n2); - wapp_dbl_list_push_back(Str8, &list, &n3); - wapp_dbl_list_push_back(Str8, &list, &n4); - wapp_dbl_list_push_back(Str8, &list, &n5); + wapp_dbl_list_push_back(Str8, &list, &n1); + wapp_dbl_list_push_back(Str8, &list, &n2); + wapp_dbl_list_push_back(Str8, &list, &n3); + wapp_dbl_list_push_back(Str8, &list, &n4); + wapp_dbl_list_push_back(Str8, &list, &n5); - Str8Node *node = wapp_dbl_list_remove(Str8, Str8Node, &list, 0); - result = node == &n1 && node->item == &s1 && wapp_str8_equal(node->item, &s1) && wapp_str8_list_total_size(&list) == 4 && list.node_count == 4; + Str8Node *node = wapp_dbl_list_remove(Str8, Str8Node, &list, 0); + result = node == &n1 && node->item == &s1 && wapp_str8_equal(node->item, &s1) && wapp_str8_list_total_size(&list) == 4 && list.node_count == 4; - node = wapp_dbl_list_remove(Str8, Str8Node, &list, 0); - result = result && node == &n2 && node->item == &s2 && wapp_str8_equal(node->item, &s2) && wapp_str8_list_total_size(&list) == 3 && list.node_count == 3; + node = wapp_dbl_list_remove(Str8, Str8Node, &list, 0); + result = result && node == &n2 && node->item == &s2 && wapp_str8_equal(node->item, &s2) && wapp_str8_list_total_size(&list) == 3 && list.node_count == 3; - node = wapp_dbl_list_remove(Str8, Str8Node, &list, 0); - result = result && node == &n3 && node->item == &s3 && wapp_str8_equal(node->item, &s3) && wapp_str8_list_total_size(&list) == 2 && list.node_count == 2; + node = wapp_dbl_list_remove(Str8, Str8Node, &list, 0); + result = result && node == &n3 && node->item == &s3 && wapp_str8_equal(node->item, &s3) && wapp_str8_list_total_size(&list) == 2 && list.node_count == 2; - node = wapp_dbl_list_remove(Str8, Str8Node, &list, 0); - result = result && node == &n4 && node->item == &s4 && wapp_str8_equal(node->item, &s4) && wapp_str8_list_total_size(&list) == 1 && list.node_count == 1; + node = wapp_dbl_list_remove(Str8, Str8Node, &list, 0); + result = result && node == &n4 && node->item == &s4 && wapp_str8_equal(node->item, &s4) && wapp_str8_list_total_size(&list) == 1 && list.node_count == 1; - node = wapp_dbl_list_remove(Str8, Str8Node, &list, 0); - result = result && node == &n5 && node->item == &s5 && wapp_str8_equal(node->item, &s5) && wapp_str8_list_total_size(&list) == 0 && list.node_count == 0; + node = wapp_dbl_list_remove(Str8, Str8Node, &list, 0); + result = result && node == &n5 && node->item == &s5 && wapp_str8_equal(node->item, &s5) && wapp_str8_list_total_size(&list) == 0 && list.node_count == 0; - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_str8_list_empty(void) { - b8 result; + b8 result; - Str8List list = wapp_dbl_list(Str8, Str8List); - wapp_dbl_list_push_back(Str8, &list, &wapp_str8_node_from_cstr("Hello")); - wapp_dbl_list_push_back(Str8, &list, &wapp_str8_node_from_cstr("from")); - wapp_dbl_list_push_back(Str8, &list, &wapp_str8_node_from_cstr("wizapp")); - wapp_dbl_list_push_back(Str8, &list, &wapp_str8_node_from_cstr("stdlib")); + Str8List list = wapp_dbl_list(Str8, Str8List); + wapp_dbl_list_push_back(Str8, &list, &wapp_str8_node_from_cstr("Hello")); + wapp_dbl_list_push_back(Str8, &list, &wapp_str8_node_from_cstr("from")); + wapp_dbl_list_push_back(Str8, &list, &wapp_str8_node_from_cstr("wizapp")); + wapp_dbl_list_push_back(Str8, &list, &wapp_str8_node_from_cstr("stdlib")); - wapp_dbl_list_empty(Str8, &list); + wapp_dbl_list_empty(Str8, &list); - result = list.first == NULL && list.last == NULL && list.node_count == 0 && wapp_str8_list_total_size(&list) == 0; + result = list.first == NULL && list.last == NULL && list.node_count == 0 && wapp_str8_list_total_size(&list) == 0; - return wapp_tester_result(result); + return wapp_tester_result(result); } diff --git a/tests/str8/test_str8_list.cc b/tests/str8/test_str8_list.cc index 407e46c..b0783cb 100644 --- a/tests/str8/test_str8_list.cc +++ b/tests/str8/test_str8_list.cc @@ -2,270 +2,270 @@ #include "wapp.h" TestFuncResult test_str8_list_get(void) { - b8 result; + b8 result; - Str8 s1 = wapp_str8_lit("1"); - Str8 s2 = wapp_str8_lit("2"); - Str8 s3 = wapp_str8_lit("3"); - Str8 s4 = wapp_str8_lit("4"); - Str8 s5 = wapp_str8_lit("5"); + Str8 s1 = wapp_str8_lit("1"); + Str8 s2 = wapp_str8_lit("2"); + Str8 s3 = wapp_str8_lit("3"); + Str8 s4 = wapp_str8_lit("4"); + Str8 s5 = wapp_str8_lit("5"); - Str8List list = wapp_dbl_list(Str8, Str8List); - Str8Node n1 = wapp_str8_node_from_str8(s1); - Str8Node n2 = wapp_str8_node_from_str8(s2); - Str8Node n3 = wapp_str8_node_from_str8(s3); - Str8Node n4 = wapp_str8_node_from_str8(s4); - Str8Node n5 = wapp_str8_node_from_str8(s5); + Str8List list = wapp_dbl_list(Str8, Str8List); + Str8Node n1 = wapp_str8_node_from_str8(s1); + Str8Node n2 = wapp_str8_node_from_str8(s2); + Str8Node n3 = wapp_str8_node_from_str8(s3); + Str8Node n4 = wapp_str8_node_from_str8(s4); + Str8Node n5 = wapp_str8_node_from_str8(s5); - wapp_dbl_list_push_back(Str8, &list, &n1); - wapp_dbl_list_push_back(Str8, &list, &n2); - wapp_dbl_list_push_back(Str8, &list, &n3); - wapp_dbl_list_push_back(Str8, &list, &n4); - wapp_dbl_list_push_back(Str8, &list, &n5); + wapp_dbl_list_push_back(Str8, &list, &n1); + wapp_dbl_list_push_back(Str8, &list, &n2); + wapp_dbl_list_push_back(Str8, &list, &n3); + wapp_dbl_list_push_back(Str8, &list, &n4); + wapp_dbl_list_push_back(Str8, &list, &n5); - Str8Node *node = wapp_dbl_list_get(Str8, Str8Node, &list, 0); - result = node->item == &s1 && wapp_str8_equal(node->item, &s1); + Str8Node *node = wapp_dbl_list_get(Str8, Str8Node, &list, 0); + result = node->item == &s1 && wapp_str8_equal(node->item, &s1); - node = wapp_dbl_list_get(Str8, Str8Node, &list, 1); - result = result && node->item == &s2 && wapp_str8_equal(node->item, &s2); + node = wapp_dbl_list_get(Str8, Str8Node, &list, 1); + result = result && node->item == &s2 && wapp_str8_equal(node->item, &s2); - node = wapp_dbl_list_get(Str8, Str8Node, &list, 2); - result = result && node->item == &s3 && wapp_str8_equal(node->item, &s3); + node = wapp_dbl_list_get(Str8, Str8Node, &list, 2); + result = result && node->item == &s3 && wapp_str8_equal(node->item, &s3); - node = wapp_dbl_list_get(Str8, Str8Node, &list, 3); - result = result && node->item == &s4 && wapp_str8_equal(node->item, &s4); + node = wapp_dbl_list_get(Str8, Str8Node, &list, 3); + result = result && node->item == &s4 && wapp_str8_equal(node->item, &s4); - node = wapp_dbl_list_get(Str8, Str8Node, &list, 4); - result = result && node->item == &s5 && wapp_str8_equal(node->item, &s5); + node = wapp_dbl_list_get(Str8, Str8Node, &list, 4); + result = result && node->item == &s5 && wapp_str8_equal(node->item, &s5); - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_str8_list_push_front(void) { - b8 result; + b8 result; - Str8 s1 = wapp_str8_lit("1"); - Str8 s2 = wapp_str8_lit("2"); - Str8 s3 = wapp_str8_lit("3"); + Str8 s1 = wapp_str8_lit("1"); + Str8 s2 = wapp_str8_lit("2"); + Str8 s3 = wapp_str8_lit("3"); - Str8List list = wapp_dbl_list(Str8, Str8List); - Str8Node n1 = wapp_str8_node_from_str8(s1); - Str8Node n2 = wapp_str8_node_from_str8(s2); - Str8Node n3 = wapp_str8_node_from_str8(s3); + Str8List list = wapp_dbl_list(Str8, Str8List); + Str8Node n1 = wapp_str8_node_from_str8(s1); + Str8Node n2 = wapp_str8_node_from_str8(s2); + Str8Node n3 = wapp_str8_node_from_str8(s3); - wapp_dbl_list_push_front(Str8, &list, &n1); - result = list.first == list.last && list.first == &n1 && list.first->item == &s1 && wapp_str8_list_total_size(&list) == 1 && list.node_count == 1; + wapp_dbl_list_push_front(Str8, &list, &n1); + result = list.first == list.last && list.first == &n1 && list.first->item == &s1 && wapp_str8_list_total_size(&list) == 1 && list.node_count == 1; - wapp_dbl_list_push_front(Str8, &list, &n2); - result = result && list.first == &n2 && list.first->item == &s2 && wapp_str8_list_total_size(&list) == 2 && list.node_count == 2; + wapp_dbl_list_push_front(Str8, &list, &n2); + result = result && list.first == &n2 && list.first->item == &s2 && wapp_str8_list_total_size(&list) == 2 && list.node_count == 2; - wapp_dbl_list_push_front(Str8, &list, &n3); - result = result && list.first == &n3 && list.first->item == &s3 && wapp_str8_list_total_size(&list) == 3 && list.node_count == 3; + wapp_dbl_list_push_front(Str8, &list, &n3); + result = result && list.first == &n3 && list.first->item == &s3 && wapp_str8_list_total_size(&list) == 3 && list.node_count == 3; - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_str8_list_push_back(void) { - b8 result; + b8 result; - Str8 s1 = wapp_str8_lit("1"); - Str8 s2 = wapp_str8_lit("2"); - Str8 s3 = wapp_str8_lit("3"); + Str8 s1 = wapp_str8_lit("1"); + Str8 s2 = wapp_str8_lit("2"); + Str8 s3 = wapp_str8_lit("3"); - Str8List list = wapp_dbl_list(Str8, Str8List); - Str8Node n1 = wapp_str8_node_from_str8(s1); - Str8Node n2 = wapp_str8_node_from_str8(s2); - Str8Node n3 = wapp_str8_node_from_str8(s3); + Str8List list = wapp_dbl_list(Str8, Str8List); + Str8Node n1 = wapp_str8_node_from_str8(s1); + Str8Node n2 = wapp_str8_node_from_str8(s2); + Str8Node n3 = wapp_str8_node_from_str8(s3); - wapp_dbl_list_push_back(Str8, &list, &n1); - result = list.first == list.last && list.last == &n1 && list.last->item == &s1 && wapp_str8_list_total_size(&list) == 1 && list.node_count == 1; + wapp_dbl_list_push_back(Str8, &list, &n1); + result = list.first == list.last && list.last == &n1 && list.last->item == &s1 && wapp_str8_list_total_size(&list) == 1 && list.node_count == 1; - wapp_dbl_list_push_back(Str8, &list, &n2); - result = result && list.last == &n2 && list.last->item == &s2 && wapp_str8_list_total_size(&list) == 2 && list.node_count == 2; + wapp_dbl_list_push_back(Str8, &list, &n2); + result = result && list.last == &n2 && list.last->item == &s2 && wapp_str8_list_total_size(&list) == 2 && list.node_count == 2; - wapp_dbl_list_push_back(Str8, &list, &n3); - result = result && list.last == &n3 && list.last->item == &s3 && wapp_str8_list_total_size(&list) == 3 && list.node_count == 3; + wapp_dbl_list_push_back(Str8, &list, &n3); + result = result && list.last == &n3 && list.last->item == &s3 && wapp_str8_list_total_size(&list) == 3 && list.node_count == 3; - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_str8_list_insert(void) { - b8 result; + b8 result; - Str8 s1 = wapp_str8_lit("1"); - Str8 s2 = wapp_str8_lit("2"); - Str8 s3 = wapp_str8_lit("3"); - Str8 s4 = wapp_str8_lit("4"); - Str8 s5 = wapp_str8_lit("5"); - Str8 s6 = wapp_str8_lit("6"); - Str8 s7 = wapp_str8_lit("7"); + Str8 s1 = wapp_str8_lit("1"); + Str8 s2 = wapp_str8_lit("2"); + Str8 s3 = wapp_str8_lit("3"); + Str8 s4 = wapp_str8_lit("4"); + Str8 s5 = wapp_str8_lit("5"); + Str8 s6 = wapp_str8_lit("6"); + Str8 s7 = wapp_str8_lit("7"); - Str8List list = wapp_dbl_list(Str8, Str8List); - Str8Node n1 = wapp_str8_node_from_str8(s1); - Str8Node n2 = wapp_str8_node_from_str8(s2); - Str8Node n3 = wapp_str8_node_from_str8(s3); - Str8Node n4 = wapp_str8_node_from_str8(s4); - Str8Node n5 = wapp_str8_node_from_str8(s5); - Str8Node n6 = wapp_str8_node_from_str8(s6); - Str8Node n7 = wapp_str8_node_from_str8(s7); + Str8List list = wapp_dbl_list(Str8, Str8List); + Str8Node n1 = wapp_str8_node_from_str8(s1); + Str8Node n2 = wapp_str8_node_from_str8(s2); + Str8Node n3 = wapp_str8_node_from_str8(s3); + Str8Node n4 = wapp_str8_node_from_str8(s4); + Str8Node n5 = wapp_str8_node_from_str8(s5); + Str8Node n6 = wapp_str8_node_from_str8(s6); + Str8Node n7 = wapp_str8_node_from_str8(s7); - wapp_dbl_list_push_back(Str8, &list, &n1); - wapp_dbl_list_push_back(Str8, &list, &n2); - wapp_dbl_list_push_back(Str8, &list, &n3); - wapp_dbl_list_push_back(Str8, &list, &n4); - wapp_dbl_list_push_back(Str8, &list, &n5); + wapp_dbl_list_push_back(Str8, &list, &n1); + wapp_dbl_list_push_back(Str8, &list, &n2); + wapp_dbl_list_push_back(Str8, &list, &n3); + wapp_dbl_list_push_back(Str8, &list, &n4); + wapp_dbl_list_push_back(Str8, &list, &n5); - Str8Node *node; - wapp_dbl_list_insert(Str8, &list, &n6, 2); - node = wapp_dbl_list_get(Str8, Str8Node, &list, 2); - result = node != NULL && node->item == &s6 && wapp_str8_list_total_size(&list) == 6 && list.node_count == 6; - wapp_dbl_list_insert(Str8, &list, &n7, 5); - node = wapp_dbl_list_get(Str8, Str8Node, &list, 5); - result = result && node != NULL && node->item == &s7 && wapp_str8_list_total_size(&list) == 7 && list.node_count == 7; + Str8Node *node; + wapp_dbl_list_insert(Str8, &list, &n6, 2); + node = wapp_dbl_list_get(Str8, Str8Node, &list, 2); + result = node != NULL && node->item == &s6 && wapp_str8_list_total_size(&list) == 6 && list.node_count == 6; + wapp_dbl_list_insert(Str8, &list, &n7, 5); + node = wapp_dbl_list_get(Str8, Str8Node, &list, 5); + result = result && node != NULL && node->item == &s7 && wapp_str8_list_total_size(&list) == 7 && list.node_count == 7; - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_str8_list_pop_front(void) { - b8 result; + b8 result; - Str8 s1 = wapp_str8_lit("1"); - Str8 s2 = wapp_str8_lit("2"); - Str8 s3 = wapp_str8_lit("3"); - Str8 s4 = wapp_str8_lit("4"); - Str8 s5 = wapp_str8_lit("5"); + Str8 s1 = wapp_str8_lit("1"); + Str8 s2 = wapp_str8_lit("2"); + Str8 s3 = wapp_str8_lit("3"); + Str8 s4 = wapp_str8_lit("4"); + Str8 s5 = wapp_str8_lit("5"); - Str8List list = wapp_dbl_list(Str8, Str8List); - Str8Node n1 = wapp_str8_node_from_str8(s1); - Str8Node n2 = wapp_str8_node_from_str8(s2); - Str8Node n3 = wapp_str8_node_from_str8(s3); - Str8Node n4 = wapp_str8_node_from_str8(s4); - Str8Node n5 = wapp_str8_node_from_str8(s5); + Str8List list = wapp_dbl_list(Str8, Str8List); + Str8Node n1 = wapp_str8_node_from_str8(s1); + Str8Node n2 = wapp_str8_node_from_str8(s2); + Str8Node n3 = wapp_str8_node_from_str8(s3); + Str8Node n4 = wapp_str8_node_from_str8(s4); + Str8Node n5 = wapp_str8_node_from_str8(s5); - wapp_dbl_list_push_back(Str8, &list, &n1); - wapp_dbl_list_push_back(Str8, &list, &n2); - wapp_dbl_list_push_back(Str8, &list, &n3); - wapp_dbl_list_push_back(Str8, &list, &n4); - wapp_dbl_list_push_back(Str8, &list, &n5); + wapp_dbl_list_push_back(Str8, &list, &n1); + wapp_dbl_list_push_back(Str8, &list, &n2); + wapp_dbl_list_push_back(Str8, &list, &n3); + wapp_dbl_list_push_back(Str8, &list, &n4); + wapp_dbl_list_push_back(Str8, &list, &n5); - Str8Node *node = wapp_dbl_list_pop_front(Str8, Str8Node, &list); - result = node == &n1 && node->item == &s1 && wapp_str8_equal(node->item, &s1) && wapp_str8_list_total_size(&list) == 4 && list.node_count == 4; + Str8Node *node = wapp_dbl_list_pop_front(Str8, Str8Node, &list); + result = node == &n1 && node->item == &s1 && wapp_str8_equal(node->item, &s1) && wapp_str8_list_total_size(&list) == 4 && list.node_count == 4; - node = wapp_dbl_list_pop_front(Str8, Str8Node, &list); - result = result && node == &n2 && node->item == &s2 && wapp_str8_equal(node->item, &s2) && wapp_str8_list_total_size(&list) == 3 && list.node_count == 3; + node = wapp_dbl_list_pop_front(Str8, Str8Node, &list); + result = result && node == &n2 && node->item == &s2 && wapp_str8_equal(node->item, &s2) && wapp_str8_list_total_size(&list) == 3 && list.node_count == 3; - node = wapp_dbl_list_pop_front(Str8, Str8Node, &list); - result = result && node == &n3 && node->item == &s3 && wapp_str8_equal(node->item, &s3) && wapp_str8_list_total_size(&list) == 2 && list.node_count == 2; + node = wapp_dbl_list_pop_front(Str8, Str8Node, &list); + result = result && node == &n3 && node->item == &s3 && wapp_str8_equal(node->item, &s3) && wapp_str8_list_total_size(&list) == 2 && list.node_count == 2; - node = wapp_dbl_list_pop_front(Str8, Str8Node, &list); - result = result && node == &n4 && node->item == &s4 && wapp_str8_equal(node->item, &s4) && wapp_str8_list_total_size(&list) == 1 && list.node_count == 1; + node = wapp_dbl_list_pop_front(Str8, Str8Node, &list); + result = result && node == &n4 && node->item == &s4 && wapp_str8_equal(node->item, &s4) && wapp_str8_list_total_size(&list) == 1 && list.node_count == 1; - node = wapp_dbl_list_pop_front(Str8, Str8Node, &list); - result = result && node == &n5 && node->item == &s5 && wapp_str8_equal(node->item, &s5) && wapp_str8_list_total_size(&list) == 0 && list.node_count == 0; + node = wapp_dbl_list_pop_front(Str8, Str8Node, &list); + result = result && node == &n5 && node->item == &s5 && wapp_str8_equal(node->item, &s5) && wapp_str8_list_total_size(&list) == 0 && list.node_count == 0; - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_str8_list_pop_back(void) { - b8 result; + b8 result; - Str8 s1 = wapp_str8_lit("1"); - Str8 s2 = wapp_str8_lit("2"); - Str8 s3 = wapp_str8_lit("3"); - Str8 s4 = wapp_str8_lit("4"); - Str8 s5 = wapp_str8_lit("5"); + Str8 s1 = wapp_str8_lit("1"); + Str8 s2 = wapp_str8_lit("2"); + Str8 s3 = wapp_str8_lit("3"); + Str8 s4 = wapp_str8_lit("4"); + Str8 s5 = wapp_str8_lit("5"); - Str8List list = wapp_dbl_list(Str8, Str8List); - Str8Node n1 = wapp_str8_node_from_str8(s1); - Str8Node n2 = wapp_str8_node_from_str8(s2); - Str8Node n3 = wapp_str8_node_from_str8(s3); - Str8Node n4 = wapp_str8_node_from_str8(s4); - Str8Node n5 = wapp_str8_node_from_str8(s5); + Str8List list = wapp_dbl_list(Str8, Str8List); + Str8Node n1 = wapp_str8_node_from_str8(s1); + Str8Node n2 = wapp_str8_node_from_str8(s2); + Str8Node n3 = wapp_str8_node_from_str8(s3); + Str8Node n4 = wapp_str8_node_from_str8(s4); + Str8Node n5 = wapp_str8_node_from_str8(s5); - wapp_dbl_list_push_front(Str8, &list, &n1); - wapp_dbl_list_push_front(Str8, &list, &n2); - wapp_dbl_list_push_front(Str8, &list, &n3); - wapp_dbl_list_push_front(Str8, &list, &n4); - wapp_dbl_list_push_front(Str8, &list, &n5); + wapp_dbl_list_push_front(Str8, &list, &n1); + wapp_dbl_list_push_front(Str8, &list, &n2); + wapp_dbl_list_push_front(Str8, &list, &n3); + wapp_dbl_list_push_front(Str8, &list, &n4); + wapp_dbl_list_push_front(Str8, &list, &n5); - Str8Node *node = wapp_dbl_list_pop_back(Str8, Str8Node, &list); - result = node == &n1 && node->item == &s1 && wapp_str8_equal(node->item, &s1) && wapp_str8_list_total_size(&list) == 4 && list.node_count == 4; + Str8Node *node = wapp_dbl_list_pop_back(Str8, Str8Node, &list); + result = node == &n1 && node->item == &s1 && wapp_str8_equal(node->item, &s1) && wapp_str8_list_total_size(&list) == 4 && list.node_count == 4; - node = wapp_dbl_list_pop_back(Str8, Str8Node, &list); - result = result && node == &n2 && node->item == &s2 && wapp_str8_equal(node->item, &s2) && wapp_str8_list_total_size(&list) == 3 && list.node_count == 3; + node = wapp_dbl_list_pop_back(Str8, Str8Node, &list); + result = result && node == &n2 && node->item == &s2 && wapp_str8_equal(node->item, &s2) && wapp_str8_list_total_size(&list) == 3 && list.node_count == 3; - node = wapp_dbl_list_pop_back(Str8, Str8Node, &list); - result = result && node == &n3 && node->item == &s3 && wapp_str8_equal(node->item, &s3) && wapp_str8_list_total_size(&list) == 2 && list.node_count == 2; + node = wapp_dbl_list_pop_back(Str8, Str8Node, &list); + result = result && node == &n3 && node->item == &s3 && wapp_str8_equal(node->item, &s3) && wapp_str8_list_total_size(&list) == 2 && list.node_count == 2; - node = wapp_dbl_list_pop_back(Str8, Str8Node, &list); - result = result && node == &n4 && node->item == &s4 && wapp_str8_equal(node->item, &s4) && wapp_str8_list_total_size(&list) == 1 && list.node_count == 1; + node = wapp_dbl_list_pop_back(Str8, Str8Node, &list); + result = result && node == &n4 && node->item == &s4 && wapp_str8_equal(node->item, &s4) && wapp_str8_list_total_size(&list) == 1 && list.node_count == 1; - node = wapp_dbl_list_pop_back(Str8, Str8Node, &list); - result = result && node == &n5 && node->item == &s5 && wapp_str8_equal(node->item, &s5) && wapp_str8_list_total_size(&list) == 0 && list.node_count == 0; + node = wapp_dbl_list_pop_back(Str8, Str8Node, &list); + result = result && node == &n5 && node->item == &s5 && wapp_str8_equal(node->item, &s5) && wapp_str8_list_total_size(&list) == 0 && list.node_count == 0; - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_str8_list_remove(void) { - b8 result; + b8 result; - Str8 s1 = wapp_str8_lit("1"); - Str8 s2 = wapp_str8_lit("2"); - Str8 s3 = wapp_str8_lit("3"); - Str8 s4 = wapp_str8_lit("4"); - Str8 s5 = wapp_str8_lit("5"); + Str8 s1 = wapp_str8_lit("1"); + Str8 s2 = wapp_str8_lit("2"); + Str8 s3 = wapp_str8_lit("3"); + Str8 s4 = wapp_str8_lit("4"); + Str8 s5 = wapp_str8_lit("5"); - Str8List list = wapp_dbl_list(Str8, Str8List); - Str8Node n1 = wapp_str8_node_from_str8(s1); - Str8Node n2 = wapp_str8_node_from_str8(s2); - Str8Node n3 = wapp_str8_node_from_str8(s3); - Str8Node n4 = wapp_str8_node_from_str8(s4); - Str8Node n5 = wapp_str8_node_from_str8(s5); + Str8List list = wapp_dbl_list(Str8, Str8List); + Str8Node n1 = wapp_str8_node_from_str8(s1); + Str8Node n2 = wapp_str8_node_from_str8(s2); + Str8Node n3 = wapp_str8_node_from_str8(s3); + Str8Node n4 = wapp_str8_node_from_str8(s4); + Str8Node n5 = wapp_str8_node_from_str8(s5); - wapp_dbl_list_push_back(Str8, &list, &n1); - wapp_dbl_list_push_back(Str8, &list, &n2); - wapp_dbl_list_push_back(Str8, &list, &n3); - wapp_dbl_list_push_back(Str8, &list, &n4); - wapp_dbl_list_push_back(Str8, &list, &n5); + wapp_dbl_list_push_back(Str8, &list, &n1); + wapp_dbl_list_push_back(Str8, &list, &n2); + wapp_dbl_list_push_back(Str8, &list, &n3); + wapp_dbl_list_push_back(Str8, &list, &n4); + wapp_dbl_list_push_back(Str8, &list, &n5); - Str8Node *node = wapp_dbl_list_remove(Str8, Str8Node, &list, 0); - result = node == &n1 && node->item == &s1 && wapp_str8_equal(node->item, &s1) && wapp_str8_list_total_size(&list) == 4 && list.node_count == 4; + Str8Node *node = wapp_dbl_list_remove(Str8, Str8Node, &list, 0); + result = node == &n1 && node->item == &s1 && wapp_str8_equal(node->item, &s1) && wapp_str8_list_total_size(&list) == 4 && list.node_count == 4; - node = wapp_dbl_list_remove(Str8, Str8Node, &list, 0); - result = result && node == &n2 && node->item == &s2 && wapp_str8_equal(node->item, &s2) && wapp_str8_list_total_size(&list) == 3 && list.node_count == 3; + node = wapp_dbl_list_remove(Str8, Str8Node, &list, 0); + result = result && node == &n2 && node->item == &s2 && wapp_str8_equal(node->item, &s2) && wapp_str8_list_total_size(&list) == 3 && list.node_count == 3; - node = wapp_dbl_list_remove(Str8, Str8Node, &list, 0); - result = result && node == &n3 && node->item == &s3 && wapp_str8_equal(node->item, &s3) && wapp_str8_list_total_size(&list) == 2 && list.node_count == 2; + node = wapp_dbl_list_remove(Str8, Str8Node, &list, 0); + result = result && node == &n3 && node->item == &s3 && wapp_str8_equal(node->item, &s3) && wapp_str8_list_total_size(&list) == 2 && list.node_count == 2; - node = wapp_dbl_list_remove(Str8, Str8Node, &list, 0); - result = result && node == &n4 && node->item == &s4 && wapp_str8_equal(node->item, &s4) && wapp_str8_list_total_size(&list) == 1 && list.node_count == 1; + node = wapp_dbl_list_remove(Str8, Str8Node, &list, 0); + result = result && node == &n4 && node->item == &s4 && wapp_str8_equal(node->item, &s4) && wapp_str8_list_total_size(&list) == 1 && list.node_count == 1; - node = wapp_dbl_list_remove(Str8, Str8Node, &list, 0); - result = result && node == &n5 && node->item == &s5 && wapp_str8_equal(node->item, &s5) && wapp_str8_list_total_size(&list) == 0 && list.node_count == 0; + node = wapp_dbl_list_remove(Str8, Str8Node, &list, 0); + result = result && node == &n5 && node->item == &s5 && wapp_str8_equal(node->item, &s5) && wapp_str8_list_total_size(&list) == 0 && list.node_count == 0; - return wapp_tester_result(result); + return wapp_tester_result(result); } TestFuncResult test_str8_list_empty(void) { - b8 result; + b8 result; - Str8List list = wapp_dbl_list(Str8, Str8List); + Str8List list = wapp_dbl_list(Str8, Str8List); - Str8Node hello = wapp_str8_node_from_cstr("Hello"); - wapp_dbl_list_push_back(Str8, &list, &hello); + Str8Node hello = wapp_str8_node_from_cstr("Hello"); + wapp_dbl_list_push_back(Str8, &list, &hello); - Str8Node from = wapp_str8_node_from_cstr("from"); - wapp_dbl_list_push_back(Str8, &list, &from); + Str8Node from = wapp_str8_node_from_cstr("from"); + wapp_dbl_list_push_back(Str8, &list, &from); - Str8Node wizapp = wapp_str8_node_from_cstr("wizapp"); - wapp_dbl_list_push_back(Str8, &list, &wizapp); + Str8Node wizapp = wapp_str8_node_from_cstr("wizapp"); + wapp_dbl_list_push_back(Str8, &list, &wizapp); - Str8Node stdlib = wapp_str8_node_from_cstr("stdlib"); - wapp_dbl_list_push_back(Str8, &list, &stdlib); + Str8Node stdlib = wapp_str8_node_from_cstr("stdlib"); + wapp_dbl_list_push_back(Str8, &list, &stdlib); - wapp_dbl_list_empty(Str8, &list); + wapp_dbl_list_empty(Str8, &list); - result = list.first == NULL && list.last == NULL && list.node_count == 0 && wapp_str8_list_total_size(&list) == 0; + result = list.first == NULL && list.last == NULL && list.node_count == 0 && wapp_str8_list_total_size(&list) == 0; - return wapp_tester_result(result); + return wapp_tester_result(result); } diff --git a/tests/wapptest.c b/tests/wapptest.c index 63d71a3..0e09109 100644 --- a/tests/wapptest.c +++ b/tests/wapptest.c @@ -10,71 +10,71 @@ #include int main(void) { - wapp_tester_run_tests( - test_arena_allocator, - test_arena_init, - test_arena_init_succeeds_when_reserving_very_large_size, - test_arena_alloc_succeeds_when_within_capacity, - test_arena_alloc_fails_when_over_capacity, - test_arena_realloc_bigger_size, - test_arena_realloc_smaller_size, - test_arena_clear, - test_arena_destroy, - test_str8_array, - test_i32_array, - test_i32_array_with_capacity, - test_i32_array_get, - test_i32_array_set, - test_i32_array_append_capped, - test_i32_array_extend_capped, - test_i32_array_copy_capped, - test_i32_array_alloc_capacity, - test_i32_array_append_alloc, - test_i32_array_extend_alloc, - test_i32_array_copy_alloc, - test_i32_array_pop, - test_i32_array_clear, - test_str8_lit, - test_str8_lit_ro, - test_str8_buf, - test_str8_alloc_buf, - test_str8_alloc_cstr, - test_str8_alloc_str8, - test_str8_alloc_substr, - test_str8_alloc_concat, - test_str8_get_index_within_bounds, - test_str8_get_index_out_of_bounds, - test_str8_set, - test_str8_equal, - test_str8_slice, - test_str8_concat_capped, - test_str8_copy_cstr_capped, - test_str8_copy_str8_capped, - test_str8_format, - test_str8_find, - test_str8_rfind, - test_str8_split, - test_str8_split_with_max, - 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, - test_str8_list_insert, - test_str8_list_pop_front, - test_str8_list_pop_back, - test_str8_list_remove, - test_str8_list_empty, - test_cpath_join_path, - test_cpath_dirname, - test_cpath_dirup, - test_commander_cmd_success, - test_commander_cmd_failure, - test_commander_cmd_out_buf_success, - test_commander_cmd_out_buf_failure - ); + wapp_tester_run_tests( + test_arena_allocator, + test_arena_init, + test_arena_init_succeeds_when_reserving_very_large_size, + test_arena_alloc_succeeds_when_within_capacity, + test_arena_alloc_fails_when_over_capacity, + test_arena_realloc_bigger_size, + test_arena_realloc_smaller_size, + test_arena_clear, + test_arena_destroy, + test_str8_array, + test_i32_array, + test_i32_array_with_capacity, + test_i32_array_get, + test_i32_array_set, + test_i32_array_append_capped, + test_i32_array_extend_capped, + test_i32_array_copy_capped, + test_i32_array_alloc_capacity, + test_i32_array_append_alloc, + test_i32_array_extend_alloc, + test_i32_array_copy_alloc, + test_i32_array_pop, + test_i32_array_clear, + test_str8_lit, + test_str8_lit_ro, + test_str8_buf, + test_str8_alloc_buf, + test_str8_alloc_cstr, + test_str8_alloc_str8, + test_str8_alloc_substr, + test_str8_alloc_concat, + test_str8_get_index_within_bounds, + test_str8_get_index_out_of_bounds, + test_str8_set, + test_str8_equal, + test_str8_slice, + test_str8_concat_capped, + test_str8_copy_cstr_capped, + test_str8_copy_str8_capped, + test_str8_format, + test_str8_find, + test_str8_rfind, + test_str8_split, + test_str8_split_with_max, + 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, + test_str8_list_insert, + test_str8_list_pop_front, + test_str8_list_pop_back, + test_str8_list_remove, + test_str8_list_empty, + test_cpath_join_path, + test_cpath_dirname, + test_cpath_dirup, + test_commander_cmd_success, + test_commander_cmd_failure, + test_commander_cmd_out_buf_success, + test_commander_cmd_out_buf_failure + ); - return EXIT_SUCCESS; + return EXIT_SUCCESS; } diff --git a/tests/wapptest.cc b/tests/wapptest.cc index 4ce3290..11a6e9b 100644 --- a/tests/wapptest.cc +++ b/tests/wapptest.cc @@ -10,71 +10,71 @@ #include int main(void) { - wapp_tester_run_tests( - test_arena_allocator, - test_arena_init, - test_arena_init_succeeds_when_reserving_very_large_size, - test_arena_alloc_succeeds_when_within_capacity, - test_arena_alloc_fails_when_over_capacity, - test_arena_realloc_bigger_size, - test_arena_realloc_smaller_size, - test_arena_clear, - test_arena_destroy, - test_str8_array, - test_i32_array, - test_i32_array_with_capacity, - test_i32_array_get, - test_i32_array_set, - test_i32_array_append_capped, - test_i32_array_extend_capped, - test_i32_array_clear, - test_i32_array_pop, - test_i32_array_copy_capped, - test_i32_array_alloc_capacity, - test_i32_array_append_alloc, - test_i32_array_extend_alloc, - test_i32_array_copy_alloc, - test_str8_lit, - test_str8_lit_ro, - test_str8_buf, - test_str8_alloc_buf, - test_str8_alloc_cstr, - test_str8_alloc_str8, - test_str8_alloc_substr, - test_str8_alloc_concat, - test_str8_get_index_within_bounds, - test_str8_get_index_out_of_bounds, - test_str8_set, - test_str8_equal, - test_str8_slice, - test_str8_concat_capped, - test_str8_copy_cstr_capped, - test_str8_copy_str8_capped, - test_str8_format, - test_str8_find, - test_str8_rfind, - test_str8_split, - test_str8_split_with_max, - 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, - test_str8_list_insert, - test_str8_list_pop_front, - test_str8_list_pop_back, - test_str8_list_remove, - test_str8_list_empty, - test_cpath_join_path, - test_cpath_dirname, - test_cpath_dirup, - test_commander_cmd_success, - test_commander_cmd_failure, - test_commander_cmd_out_buf_success, - test_commander_cmd_out_buf_failure - ); + wapp_tester_run_tests( + test_arena_allocator, + test_arena_init, + test_arena_init_succeeds_when_reserving_very_large_size, + test_arena_alloc_succeeds_when_within_capacity, + test_arena_alloc_fails_when_over_capacity, + test_arena_realloc_bigger_size, + test_arena_realloc_smaller_size, + test_arena_clear, + test_arena_destroy, + test_str8_array, + test_i32_array, + test_i32_array_with_capacity, + test_i32_array_get, + test_i32_array_set, + test_i32_array_append_capped, + test_i32_array_extend_capped, + test_i32_array_clear, + test_i32_array_pop, + test_i32_array_copy_capped, + test_i32_array_alloc_capacity, + test_i32_array_append_alloc, + test_i32_array_extend_alloc, + test_i32_array_copy_alloc, + test_str8_lit, + test_str8_lit_ro, + test_str8_buf, + test_str8_alloc_buf, + test_str8_alloc_cstr, + test_str8_alloc_str8, + test_str8_alloc_substr, + test_str8_alloc_concat, + test_str8_get_index_within_bounds, + test_str8_get_index_out_of_bounds, + test_str8_set, + test_str8_equal, + test_str8_slice, + test_str8_concat_capped, + test_str8_copy_cstr_capped, + test_str8_copy_str8_capped, + test_str8_format, + test_str8_find, + test_str8_rfind, + test_str8_split, + test_str8_split_with_max, + 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, + test_str8_list_insert, + test_str8_list_pop_front, + test_str8_list_pop_back, + test_str8_list_remove, + test_str8_list_empty, + test_cpath_join_path, + test_cpath_dirname, + test_cpath_dirup, + test_commander_cmd_success, + test_commander_cmd_failure, + test_commander_cmd_out_buf_success, + test_commander_cmd_out_buf_failure + ); - return EXIT_SUCCESS; + return EXIT_SUCCESS; } -- 2.39.5 From 8efe6773eaf75256a5b82cff3f5acc79ba6f7fa7 Mon Sep 17 00:00:00 2001 From: Abdelrahman Said Date: Mon, 29 Dec 2025 22:45:16 +0000 Subject: [PATCH 9/9] Reformat mem --- src/os/mem/mem_os.c | 12 ++++++------ src/os/mem/mem_os_ops.h | 16 ++++++++-------- src/os/mem/posix/mem_os_posix.c | 22 +++++++++++----------- src/os/mem/posix/mem_os_posix.h | 12 ++++++------ src/os/mem/win/mem_os_win.c | 24 ++++++++++++------------ src/os/mem/win/mem_os_win.h | 4 ++-- 6 files changed, 45 insertions(+), 45 deletions(-) diff --git a/src/os/mem/mem_os.c b/src/os/mem/mem_os.c index 95484f5..12bfd4d 100644 --- a/src/os/mem/mem_os.c +++ b/src/os/mem/mem_os.c @@ -16,15 +16,15 @@ #endif void *wapp_mem_util_alloc(void *addr, u64 size, MemAccess access, MemAllocFlags flags, MemInitType type) { - void *output = mem_util_allocate(addr, size, access, flags, type); + void *output = mem_util_allocate(addr, size, access, flags, type); - if (type == WAPP_MEM_INIT_INITIALISED) { - memset(output, 0, size); - } + if (type == WAPP_MEM_INIT_INITIALISED) { + memset(output, 0, size); + } - return output; + return output; } void wapp_mem_util_free(void *ptr, u64 size) { - mem_util_free(ptr, size); + mem_util_free(ptr, size); } diff --git a/src/os/mem/mem_os_ops.h b/src/os/mem/mem_os_ops.h index 09ec63d..357a1af 100644 --- a/src/os/mem/mem_os_ops.h +++ b/src/os/mem/mem_os_ops.h @@ -10,17 +10,17 @@ BEGIN_C_LINKAGE #endif // !WAPP_PLATFORM_CPP typedef enum mem_access { - WAPP_MEM_ACCESS_NONE, - WAPP_MEM_ACCESS_READ_ONLY, - WAPP_MEM_ACCESS_EXEC_ONLY, - WAPP_MEM_ACCESS_READ_WRITE, - WAPP_MEM_ACCESS_READ_EXEC, - WAPP_MEM_ACCESS_READ_WRITE_EXEC, + WAPP_MEM_ACCESS_NONE, + WAPP_MEM_ACCESS_READ_ONLY, + WAPP_MEM_ACCESS_EXEC_ONLY, + WAPP_MEM_ACCESS_READ_WRITE, + WAPP_MEM_ACCESS_READ_EXEC, + WAPP_MEM_ACCESS_READ_WRITE_EXEC, } MemAccess; typedef enum mem_init_type { - WAPP_MEM_INIT_UNINITIALISED, - WAPP_MEM_INIT_INITIALISED, + WAPP_MEM_INIT_UNINITIALISED, + WAPP_MEM_INIT_INITIALISED, } MemInitType; #ifdef WAPP_PLATFORM_CPP diff --git a/src/os/mem/posix/mem_os_posix.c b/src/os/mem/posix/mem_os_posix.c index e71729f..fb8b718 100644 --- a/src/os/mem/posix/mem_os_posix.c +++ b/src/os/mem/posix/mem_os_posix.c @@ -10,27 +10,27 @@ #include wapp_intern const i32 access_types[] = { - [WAPP_MEM_ACCESS_NONE] = PROT_NONE, - [WAPP_MEM_ACCESS_READ_ONLY] = PROT_READ, - [WAPP_MEM_ACCESS_EXEC_ONLY] = PROT_EXEC, - [WAPP_MEM_ACCESS_READ_WRITE] = PROT_READ | PROT_WRITE, - [WAPP_MEM_ACCESS_READ_EXEC] = PROT_READ | PROT_EXEC, - [WAPP_MEM_ACCESS_READ_WRITE_EXEC] = PROT_READ | PROT_WRITE | PROT_EXEC, + [WAPP_MEM_ACCESS_NONE] = PROT_NONE, + [WAPP_MEM_ACCESS_READ_ONLY] = PROT_READ, + [WAPP_MEM_ACCESS_EXEC_ONLY] = PROT_EXEC, + [WAPP_MEM_ACCESS_READ_WRITE] = PROT_READ | PROT_WRITE, + [WAPP_MEM_ACCESS_READ_EXEC] = PROT_READ | PROT_EXEC, + [WAPP_MEM_ACCESS_READ_WRITE_EXEC] = PROT_READ | PROT_WRITE | PROT_EXEC, }; void *mem_util_allocate(void *addr, u64 size, MemAccess access, MemAllocFlags flags, MemInitType type) { - (void)type; - i32 alloc_flags = flags | MAP_ANON | MAP_PRIVATE; + (void)type; + i32 alloc_flags = flags | MAP_ANON | MAP_PRIVATE; #if defined(WAPP_PLATFORM_LINUX) || defined(WAPP_PLATFORM_GNU) || defined(WAPP_PLATFORM_NET_BSD) - alloc_flags |= MAP_NORESERVE; + alloc_flags |= MAP_NORESERVE; #endif - return mmap(addr, size, access_types[access], alloc_flags, -1, 0); + return mmap(addr, size, access_types[access], alloc_flags, -1, 0); } void mem_util_free(void *ptr, u64 size) { - munmap(ptr, size); + munmap(ptr, size); } #endif // !WAPP_PLATFORM_POSIX diff --git a/src/os/mem/posix/mem_os_posix.h b/src/os/mem/posix/mem_os_posix.h index 4f9aa9b..3c14f1d 100644 --- a/src/os/mem/posix/mem_os_posix.h +++ b/src/os/mem/posix/mem_os_posix.h @@ -15,14 +15,14 @@ BEGIN_C_LINKAGE typedef enum mem_alloc_flags { #if defined(WAPP_PLATFORM_LINUX) || defined(WAPP_PLATFORM_GNU) - WAPP_MEM_ALLOC_RESERVE = 0, - WAPP_MEM_ALLOC_COMMIT = MAP_POPULATE, + WAPP_MEM_ALLOC_RESERVE = 0, + WAPP_MEM_ALLOC_COMMIT = MAP_POPULATE, #elif defined(WAPP_PLATFORM_FREE_BSD) - WAPP_MEM_ALLOC_RESERVE = 0, - WAPP_MEM_ALLOC_COMMIT = MAP_PREFAULT_READ, + WAPP_MEM_ALLOC_RESERVE = 0, + WAPP_MEM_ALLOC_COMMIT = MAP_PREFAULT_READ, #elif defined(WAPP_PLATFORM_BSD) || defined(WAPP_PLATFORM_UNIX) || defined(WAPP_PLATFORM_APPLE) - WAPP_MEM_ALLOC_RESERVE = 0, - WAPP_MEM_ALLOC_COMMIT = 0, + WAPP_MEM_ALLOC_RESERVE = 0, + WAPP_MEM_ALLOC_COMMIT = 0, #endif } MemAllocFlags; diff --git a/src/os/mem/win/mem_os_win.c b/src/os/mem/win/mem_os_win.c index 97c3469..c0f20fc 100644 --- a/src/os/mem/win/mem_os_win.c +++ b/src/os/mem/win/mem_os_win.c @@ -13,25 +13,25 @@ #include wapp_intern const i32 access_types[] = { - [WAPP_MEM_ACCESS_NONE] = PAGE_NOACCESS, - [WAPP_MEM_ACCESS_READ_ONLY] = PAGE_READONLY, - [WAPP_MEM_ACCESS_EXEC_ONLY] = PAGE_EXECUTE, - [WAPP_MEM_ACCESS_READ_WRITE] = PAGE_READWRITE, - [WAPP_MEM_ACCESS_READ_EXEC] = PAGE_EXECUTE_READ, - [WAPP_MEM_ACCESS_READ_WRITE_EXEC] = PAGE_EXECUTE_READWRITE, + [WAPP_MEM_ACCESS_NONE] = PAGE_NOACCESS, + [WAPP_MEM_ACCESS_READ_ONLY] = PAGE_READONLY, + [WAPP_MEM_ACCESS_EXEC_ONLY] = PAGE_EXECUTE, + [WAPP_MEM_ACCESS_READ_WRITE] = PAGE_READWRITE, + [WAPP_MEM_ACCESS_READ_EXEC] = PAGE_EXECUTE_READ, + [WAPP_MEM_ACCESS_READ_WRITE_EXEC] = PAGE_EXECUTE_READWRITE, }; void *mem_util_allocate(void *addr, u64 size, MemAccess access, MemAllocFlags flags, MemInitType type) { - // Ensure memory is committed if it's meant to be initialised - if (type == WAPP_MEM_INIT_INITIALISED) { - flags |= WAPP_MEM_ALLOC_COMMIT; - } + // Ensure memory is committed if it's meant to be initialised + if (type == WAPP_MEM_INIT_INITIALISED) { + flags |= WAPP_MEM_ALLOC_COMMIT; + } - return VirtualAlloc(addr, (SIZE_T)size, flags, access_types[access]); + return VirtualAlloc(addr, (SIZE_T)size, flags, access_types[access]); } void mem_util_free(void *ptr, u64 size) { - VirtualFree(ptr, size, MEM_RELEASE); + VirtualFree(ptr, size, MEM_RELEASE); } #endif // !WAPP_PLATFORM_WINDOWS diff --git a/src/os/mem/win/mem_os_win.h b/src/os/mem/win/mem_os_win.h index d6c405a..c93d11b 100644 --- a/src/os/mem/win/mem_os_win.h +++ b/src/os/mem/win/mem_os_win.h @@ -16,8 +16,8 @@ BEGIN_C_LINKAGE #include typedef enum mem_alloc_flags { - WAPP_MEM_ALLOC_RESERVE = MEM_RESERVE, - WAPP_MEM_ALLOC_COMMIT = MEM_COMMIT, + WAPP_MEM_ALLOC_RESERVE = MEM_RESERVE, + WAPP_MEM_ALLOC_COMMIT = MEM_COMMIT, } MemAllocFlags; #endif // !WAPP_PLATFORM_WINDOWS -- 2.39.5