diff --git a/Makefile b/Makefile index 722b58c..3209a58 100644 --- a/Makefile +++ b/Makefile @@ -34,9 +34,9 @@ override HEADER_INSTALL_CMD := scripts/header_install.sh ifeq ($(origin BUILD_FLAGS), undefined) ifeq ($(BUILD_TYPE),Debug) - BUILD_FLAGS += -g -fsanitize=address,undefined -DWAPP_DEBUG_ASSERT + BUILD_FLAGS += -g -fsanitize=address,undefined -DWP_DEBUG_ASSERT else ifeq ($(BUILD_TYPE),RelWithDebInfo) - BUILD_FLAGS += -g -O2 -fsanitize=address,undefined -DWAPP_DEBUG_ASSERT + BUILD_FLAGS += -g -O2 -fsanitize=address,undefined -DWP_DEBUG_ASSERT else ifeq ($(BUILD_TYPE),Release) BUILD_FLAGS += -O3 else @@ -46,7 +46,7 @@ endif # Disable runtime asserts ifeq ($(RUNTIME_ASSERT), false) - override BUILD_FLAGS += -DWAPP_NO_RUNTIME_ASSERT + override BUILD_FLAGS += -DWP_NO_RUNTIME_ASSERT endif ifeq ($(CC),gcc) diff --git a/VERSION b/VERSION index 26aaba0..227cea2 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -1.2.0 +2.0.0 diff --git a/src/base/array/array.c b/src/base/array/array.c index e47c125..bfb3ae8 100644 --- a/src/base/array/array.c +++ b/src/base/array/array.c @@ -7,177 +7,177 @@ #include "../../common/aliases/aliases.h" #include -#define _array_header(ARRAY) (ArrayHeader *)(wapp_pointer_offset(ARRAY, (i64)sizeof(ArrayHeader) * -1)) +#define _array_header(ARRAY) (WpArrayHeader *)(wpMiscUtilsOffsetPointer(ARRAY, (i64)sizeof(WpArrayHeader) * -1)) -wapp_persist inline void _array_validate(const GenericArray array, u64 item_size); +wp_persist inline void _array_validate(const WpArray array, u64 item_size); -u64 _array_count(GenericArray array) { - wapp_debug_assert(array != NULL, "`array` should not be NULL"); +u64 _arrayCount(WpArray array) { + wpDebugAssert(array != NULL, "`array` should not be NULL"); - ArrayHeader *header = _array_header(array); - wapp_runtime_assert(WAPP_ARRAY_MAGIC == header->magic, "`array` is not a valid wapp array"); + WpArrayHeader *header = _array_header(array); + wpRuntimeAssert(WP_ARRAY_MAGIC == header->magic, "`array` is not a valid wapp array"); return header->count; } -u64 _array_capacity(GenericArray array) { - wapp_debug_assert(array != NULL, "`array` should not be NULL"); +u64 _arrayCapacity(WpArray array) { + wpDebugAssert(array != NULL, "`array` should not be NULL"); - ArrayHeader *header = _array_header(array); - wapp_runtime_assert(WAPP_ARRAY_MAGIC == header->magic, "`array` is not a valid wapp array"); + WpArrayHeader *header = _array_header(array); + wpRuntimeAssert(WP_ARRAY_MAGIC == header->magic, "`array` is not a valid wapp array"); return header->capacity; } -u64 _array_item_size(GenericArray array) { - wapp_debug_assert(array != NULL, "`array` should not be NULL"); +u64 _arrayItemSize(WpArray array) { + wpDebugAssert(array != NULL, "`array` should not be NULL"); - ArrayHeader *header = _array_header(array); - wapp_runtime_assert(WAPP_ARRAY_MAGIC == header->magic, "`array` is not a valid wapp array"); + WpArrayHeader *header = _array_header(array); + wpRuntimeAssert(WP_ARRAY_MAGIC == header->magic, "`array` is not a valid wapp array"); return header->item_size; } -void _array_set_count(GenericArray array, u64 count) { - wapp_debug_assert(array != NULL, "`array` should not be NULL"); +void _arraySetCount(WpArray array, u64 count) { + wpDebugAssert(array != NULL, "`array` should not be NULL"); - ArrayHeader *header = _array_header(array); - wapp_runtime_assert(WAPP_ARRAY_MAGIC == header->magic, "`array` is not a valid wapp array"); + WpArrayHeader *header = _array_header(array); + wpRuntimeAssert(WP_ARRAY_MAGIC == header->magic, "`array` is not a valid wapp array"); header->count = count; } -void *_array_get(GenericArray array, u64 index, u64 item_size) { - wapp_runtime_assert(array != NULL, "`array` should not be NULL"); +void *_arrayGet(WpArray array, u64 index, u64 item_size) { + wpRuntimeAssert(array != NULL, "`array` should not be NULL"); _array_validate(array, item_size); - ArrayHeader *header = _array_header(array); - wapp_runtime_assert(index < header->count, "`index` is out of bounds"); + WpArrayHeader *header = _array_header(array); + wpRuntimeAssert(index < header->count, "`index` is out of bounds"); - return wapp_pointer_offset(array, header->item_size * index); + return wpMiscUtilsOffsetPointer(array, header->item_size * index); } -void _array_set(GenericArray array, u64 index, void *value, u64 item_size) { - void *item = _array_get(array, index, item_size); +void _arraySet(WpArray array, u64 index, void *value, u64 item_size) { + void *item = _arrayGet(array, index, item_size); - ArrayHeader *header = _array_header(array); + WpArrayHeader *header = _array_header(array); memcpy(item, value, header->item_size); } -void _array_append_capped(GenericArray array, void *value, u64 item_size) { - wapp_runtime_assert(array != NULL, "`array` should not be NULL"); +void _arrayAppendCapped(WpArray array, void *value, u64 item_size) { + wpRuntimeAssert(array != NULL, "`array` should not be NULL"); _array_validate(array, item_size); - ArrayHeader *header = _array_header(array); + WpArrayHeader *header = _array_header(array); if (header->count >= header->capacity) { return; } u64 index = (header->count)++; - _array_set(array, index, value, item_size); + _arraySet(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"); +void _arrayExtendCappend(WpArray dst, const WpArray src, u64 item_size) { + wpRuntimeAssert(dst != NULL && src != NULL, "`dst` and `src` should not be NULL"); _array_validate(dst, item_size); _array_validate(src, item_size); - ArrayHeader *src_header = _array_header(src); - ArrayHeader *dst_header = _array_header(dst); + WpArrayHeader *src_header = _array_header(src); + WpArrayHeader *dst_header = _array_header(dst); u64 remaining_capacity = dst_header->capacity - dst_header->count; u64 copy_count = src_header->count < remaining_capacity ? src_header->count : remaining_capacity; - void *dst_ptr = wapp_pointer_offset(dst, dst_header->count * dst_header->item_size); + void *dst_ptr = wpMiscUtilsOffsetPointer(dst, dst_header->count * dst_header->item_size); memcpy(dst_ptr, src, copy_count * src_header->item_size); dst_header->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"); +void _arrayCopyCapped(WpArray dst, const WpArray src, u64 item_size) { + wpRuntimeAssert(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); + _arrayClear(dst, item_size); - ArrayHeader *src_header = _array_header(src); - ArrayHeader *dst_header = _array_header(dst); + WpArrayHeader *src_header = _array_header(src); + WpArrayHeader *dst_header = _array_header(dst); u64 copy_count = src_header->count < dst_header->capacity ? src_header->count : dst_header->capacity; memcpy((void *)dst, (void *)src, copy_count * src_header->item_size); dst_header->count = copy_count; } -GenericArray _array_append_alloc(const Allocator *allocator, GenericArray array, void *value, - ArrayInitFlags flags, u64 item_size) { - wapp_runtime_assert(allocator != NULL && array != NULL, "`allocator` and `array` should not be NULL"); +WpArray _arrayAppendAlloc(const WpAllocator *allocator, WpArray array, void *value, + WpArrayInitFlags flags, u64 item_size) { + wpRuntimeAssert(allocator != NULL && array != NULL, "`allocator` and `array` should not be NULL"); _array_validate(array, item_size); - GenericArray output = array; + WpArray output = array; - ArrayHeader *header = _array_header(array); + WpArrayHeader *header = _array_header(array); if (header->count >= header->capacity) { - u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(header->capacity * 2); - output = (GenericArray )_array_alloc_capacity(allocator, new_capacity, flags, + u64 new_capacity = wpMiscUtilsU64RoundUpPow2(header->capacity * 2); + output = (WpArray )_arrayAllocCapacity(allocator, new_capacity, flags, header->item_size); if (!output) { output = array; goto RETURN_ARRAY_APPEND_ALLOC; } - _array_copy_capped(output, array, item_size); + _arrayCopyCapped(output, array, item_size); } - _array_append_capped(output, value, item_size); + _arrayAppendCapped(output, value, item_size); - if ((flags & ARRAY_INIT_FILLED) == ARRAY_INIT_FILLED) { - _array_set_count(output, _array_capacity(output)); + if ((flags & WP_ARRAY_INIT_FILLED) == WP_ARRAY_INIT_FILLED) { + _arraySetCount(output, _arrayCapacity(output)); } RETURN_ARRAY_APPEND_ALLOC: return output; } -GenericArray _array_extend_alloc(const Allocator *allocator, GenericArray dst, const GenericArray src, - ArrayInitFlags flags, u64 item_size) { - wapp_runtime_assert(allocator != NULL && dst != NULL && src != NULL, "`allocator`, `dst` and `src` should not be NULL"); +WpArray _arrayExtendAlloc(const WpAllocator *allocator, WpArray dst, const WpArray src, + WpArrayInitFlags flags, u64 item_size) { + wpRuntimeAssert(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; + WpArray output = dst; - ArrayHeader *src_header = _array_header(src); - ArrayHeader *dst_header = _array_header(dst); + WpArrayHeader *src_header = _array_header(src); + WpArrayHeader *dst_header = _array_header(dst); u64 remaining_capacity = dst_header->capacity - dst_header->count; if (src_header->count >= remaining_capacity) { - u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(dst_header->capacity * 2); - output = (GenericArray )_array_alloc_capacity(allocator, new_capacity, + u64 new_capacity = wpMiscUtilsU64RoundUpPow2(dst_header->capacity * 2); + output = (WpArray )_arrayAllocCapacity(allocator, new_capacity, flags, dst_header->item_size); if (!output) { output = dst; goto RETURN_ARRAY_EXTEND_ALLOC; } - _array_copy_capped(output, dst, item_size); + _arrayCopyCapped(output, dst, item_size); } - _array_extend_capped(output, src, item_size); + _arrayExtendCappend(output, src, item_size); - if ((flags & ARRAY_INIT_FILLED) == ARRAY_INIT_FILLED) { - _array_set_count(output, _array_capacity(output)); + if ((flags & WP_ARRAY_INIT_FILLED) == WP_ARRAY_INIT_FILLED) { + _arraySetCount(output, _arrayCapacity(output)); } RETURN_ARRAY_EXTEND_ALLOC: return output; } -GenericArray _array_copy_alloc(const Allocator *allocator, GenericArray dst, const GenericArray src, - ArrayInitFlags flags, u64 item_size) { - wapp_runtime_assert(allocator != NULL && dst != NULL && src != NULL, "`allocator`, `dst` and `src` should not be NULL"); +WpArray _arrayCopyAlloc(const WpAllocator *allocator, WpArray dst, const WpArray src, + WpArrayInitFlags flags, u64 item_size) { + wpRuntimeAssert(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; + WpArray output = dst; - ArrayHeader *src_header = _array_header(src); - ArrayHeader *dst_header = _array_header(dst); + WpArrayHeader *src_header = _array_header(src); + WpArrayHeader *dst_header = _array_header(dst); if (src_header->count >= dst_header->capacity) { - u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(dst_header->capacity * 2); - output = (GenericArray )_array_alloc_capacity(allocator, new_capacity, + u64 new_capacity = wpMiscUtilsU64RoundUpPow2(dst_header->capacity * 2); + output = (WpArray )_arrayAllocCapacity(allocator, new_capacity, flags, src_header->item_size); if (!output) { output = dst; @@ -185,82 +185,82 @@ GenericArray _array_copy_alloc(const Allocator *allocator, GenericArray dst, con } } - _array_copy_capped(output, src, item_size); + _arrayCopyCapped(output, src, item_size); - if ((flags & ARRAY_INIT_FILLED) == ARRAY_INIT_FILLED) { - _array_set_count(output, _array_capacity(output)); + if ((flags & WP_ARRAY_INIT_FILLED) == WP_ARRAY_INIT_FILLED) { + _arraySetCount(output, _arrayCapacity(output)); } RETURN_ARRAY_COPY_ALLOC: return output; } -void *_array_pop(GenericArray array, u64 item_size) { - wapp_runtime_assert(array != NULL, "`array` should not be NULL"); +void *_arrayPop(WpArray array, u64 item_size) { + wpRuntimeAssert(array != NULL, "`array` should not be NULL"); _array_validate(array, item_size); - ArrayHeader *header = _array_header(array); + WpArrayHeader *header = _array_header(array); if (header->count == 0) { return NULL; } u64 index = header->count - 1; - void *out = _array_get(array, index, item_size); + void *out = _arrayGet(array, index, item_size); --(header->count); return out; } -void _array_clear(GenericArray array, u64 item_size) { - wapp_runtime_assert(array != NULL, "`array` should not be NULL"); +void _arrayClear(WpArray array, u64 item_size) { + wpRuntimeAssert(array != NULL, "`array` should not be NULL"); _array_validate(array, item_size); - ArrayHeader *header = _array_header(array); + WpArrayHeader *header = _array_header(array); header->count = 0; } -u64 _array_calc_alloc_size(u64 capacity, u64 item_size) { - return sizeof(ArrayHeader) + item_size * capacity; +u64 _arrayCalcAllocSize(u64 capacity, u64 item_size) { + return sizeof(WpArrayHeader) + item_size * capacity; } -GenericArray _array_alloc_capacity(const Allocator *allocator, u64 capacity, ArrayInitFlags flags, +WpArray _arrayAllocCapacity(const WpAllocator *allocator, u64 capacity, WpArrayInitFlags flags, u64 item_size) { - wapp_runtime_assert(allocator != NULL, "`allocator` should not be NULL"); + wpRuntimeAssert(allocator != NULL, "`allocator` should not be NULL"); - GenericArray output = NULL; + WpArray output = NULL; - u64 allocation_size = _array_calc_alloc_size(capacity, item_size); - void *buffer = wapp_mem_allocator_alloc(allocator, allocation_size); + u64 allocation_size = _arrayCalcAllocSize(capacity, item_size); + void *buffer = wpMemAllocatorAlloc(allocator, allocation_size); if (!buffer) { goto RETURN_ARRAY_ALLOC; } - output = _array_from_preallocated_buffer(buffer, allocation_size, flags, item_size); + output = _arrayFromPreallocatedBuffer(buffer, allocation_size, flags, item_size); RETURN_ARRAY_ALLOC: return output; } -GenericArray _array_from_preallocated_buffer(void *buffer, u64 buffer_size, ArrayInitFlags flags, +WpArray _arrayFromPreallocatedBuffer(void *buffer, u64 buffer_size, WpArrayInitFlags flags, u64 item_size) { - wapp_runtime_assert(buffer != NULL, "`buffer` should not be NULL"); + wpRuntimeAssert(buffer != NULL, "`buffer` should not be NULL"); - i64 data_buffer_size = (i64)buffer_size - (i64)(sizeof(ArrayHeader)); + i64 data_buffer_size = (i64)buffer_size - (i64)(sizeof(WpArrayHeader)); if (data_buffer_size <= 0) { return NULL; } u64 item_capacity = (u64)data_buffer_size / item_size; - ArrayHeader *header = (ArrayHeader *)buffer; - GenericArray output = (u8 *)(header + 1); - header->magic = WAPP_ARRAY_MAGIC; - header->count = flags & ARRAY_INIT_FILLED ? item_capacity : 0; + WpArrayHeader *header = (WpArrayHeader *)buffer; + WpArray output = (u8 *)(header + 1); + header->magic = WP_ARRAY_MAGIC; + header->count = flags & WP_ARRAY_INIT_FILLED ? item_capacity : 0; header->capacity = item_capacity; header->item_size = item_size; return output; } -wapp_persist inline void _array_validate(const GenericArray array, u64 item_size) { - ArrayHeader *header = _array_header(array); - wapp_runtime_assert(WAPP_ARRAY_MAGIC == header->magic, "`array` is not a valid wapp array"); - wapp_runtime_assert(item_size == header->item_size, "Invalid item type provided"); +wp_persist inline void _array_validate(const WpArray array, u64 item_size) { + WpArrayHeader *header = _array_header(array); + wpRuntimeAssert(WP_ARRAY_MAGIC == header->magic, "`array` is not a valid wapp array"); + wpRuntimeAssert(item_size == header->item_size, "Invalid item type provided"); } diff --git a/src/base/array/array.h b/src/base/array/array.h index f996a23..746a95d 100644 --- a/src/base/array/array.h +++ b/src/base/array/array.h @@ -8,209 +8,209 @@ #include "../../common/aliases/aliases.h" #include "../../common/platform/platform.h" -#ifdef WAPP_PLATFORM_CPP +#ifdef WP_PLATFORM_CPP BEGIN_C_LINKAGE -#endif // !WAPP_PLATFORM_CPP +#endif // !WP_PLATFORM_CPP -#define WAPP_ARRAY_MAGIC (u64)0x57415f415252 +#define WP_ARRAY_MAGIC (u64)0x57415f415252 -#define _calc_array_count(TYPE, ...) wapp_misc_utils_va_args_count(TYPE, __VA_ARGS__) -#define _calc_array_capacity(TYPE, ...) wapp_misc_utils_u64_round_up_pow2(_calc_array_count(TYPE, __VA_ARGS__) * 2) +#define _calcArrayCount(TYPE, ...) wpMiscUtilsVaArgsCount(TYPE, __VA_ARGS__) +#define _calcArrayCapacity(TYPE, ...) wpMiscUtilsU64RoundUpPow2(_calcArrayCount(TYPE, __VA_ARGS__) * 2) -typedef struct Str8 Str8; +typedef struct WpStr8 WpStr8; // NOTE (Abdelrahman): Typedefs to distinguish arrays from regular pointers -typedef void *GenericArray; -typedef void **VoidPtrArray; -typedef c8 *C8Array; -typedef c16 *C16Array; -typedef c32 *C32Array; -typedef u8 *U8Array; -typedef u16 *U16Array; -typedef u32 *U32Array; -typedef u64 *U64Array; -typedef b8 *B8Array; -typedef i8 *I8Array; -typedef i16 *I16Array; -typedef i32 *I32Array; -typedef i64 *I64Array; -typedef f32 *F32Array; -typedef f64 *F64Array; -typedef f128 *F128Array; -typedef uptr *UptrArray; -typedef iptr *IptrArray; -typedef Str8 *Str8Array; +typedef void *WpArray; +typedef void **WpVoidPtrArray; +typedef c8 *WpC8Array; +typedef c16 *WpC16Array; +typedef c32 *WpC32Array; +typedef u8 *WpU8Array; +typedef u16 *WpU16Array; +typedef u32 *WpU32Array; +typedef u64 *WpU64Array; +typedef b8 *WpB8Array; +typedef i8 *WpI8Array; +typedef i16 *WpI16Array; +typedef i32 *WpI32Array; +typedef i64 *WpI64Array; +typedef f32 *WpF32Array; +typedef f64 *WpF64Array; +typedef f128 *WpF128Array; +typedef uptr *WpUptrArray; +typedef iptr *WpIptrArray; +typedef WpStr8 *WpStr8Array; typedef enum { - ARRAY_INIT_NONE = 0, - ARRAY_INIT_FILLED = 1 << 1, -} ArrayInitFlags; + WP_ARRAY_INIT_NONE = 0, + WP_ARRAY_INIT_FILLED = 1 << 1, +} WpArrayInitFlags; -#ifdef WAPP_PLATFORM_CPP -#define wapp_array(TYPE, ...) ([&]() { \ - u64 capacity = _calc_array_capacity(TYPE, __VA_ARGS__); \ +#ifdef WP_PLATFORM_CPP +#define wpArray(TYPE, ...) ([&]() { \ + u64 capacity = _calcArrayCapacity(TYPE, __VA_ARGS__); \ \ - TYPE items[_calc_array_capacity(TYPE, __VA_ARGS__)] = {__VA_ARGS__}; \ + TYPE items[_calcArrayCapacity(TYPE, __VA_ARGS__)] = {__VA_ARGS__}; \ \ - wapp_persist u8 array[ \ - sizeof(ArrayHeader) + _calc_array_capacity(TYPE, __VA_ARGS__) * sizeof(TYPE) \ + wp_persist u8 array[ \ + sizeof(WpArrayHeader) + _calcArrayCapacity(TYPE, __VA_ARGS__) * sizeof(TYPE) \ ] = {0}; \ - ArrayHeader *header = (ArrayHeader *)array; \ - header->magic = WAPP_ARRAY_MAGIC; \ - header->count = _calc_array_count(TYPE, __VA_ARGS__); \ - header->capacity = _calc_array_capacity(TYPE, __VA_ARGS__); \ + WpArrayHeader *header = (WpArrayHeader *)array; \ + header->magic = WP_ARRAY_MAGIC; \ + header->count = _calcArrayCount(TYPE, __VA_ARGS__); \ + header->capacity = _calcArrayCapacity(TYPE, __VA_ARGS__); \ header->item_size = sizeof(TYPE); \ \ u8 *buf = (u8 *)(header + 1); \ memcpy(buf, items, capacity * sizeof(TYPE)); \ return (TYPE *)buf; \ }()) -#define wapp_array_with_capacity(TYPE, CAPACITY, FLAGS) ([&]() { \ - wapp_persist u8 array[ \ - sizeof(ArrayHeader) + CAPACITY * sizeof(TYPE) \ +#define wpArrayWithCapacity(TYPE, CAPACITY, FLAGS) ([&]() { \ + wp_persist u8 array[ \ + sizeof(WpArrayHeader) + CAPACITY * sizeof(TYPE) \ ] = {0}; \ - ArrayHeader *header = (ArrayHeader *)array; \ - header->magic = WAPP_ARRAY_MAGIC; \ - header->count = (FLAGS & ARRAY_INIT_FILLED) ? CAPACITY : 0; \ + WpArrayHeader *header = (WpArrayHeader *)array; \ + header->magic = WP_ARRAY_MAGIC; \ + header->count = (FLAGS & WP_ARRAY_INIT_FILLED) ? CAPACITY : 0; \ header->capacity = CAPACITY; \ header->item_size = sizeof(TYPE); \ \ return (TYPE *)(header + 1); \ }()) -#define wapp_array_pop(TYPE, ARRAY) ([&]() { \ - if (ARRAY == NULL || _array_count((GenericArray)ARRAY) == 0) { \ +#define wpArrayPop(TYPE, ARRAY) ([&]() { \ + if (ARRAY == NULL || _arrayCount((WpArray)ARRAY) == 0) { \ TYPE result{}; \ return result; \ } \ \ - return *((TYPE *)_array_pop((GenericArray)ARRAY, sizeof(TYPE))); \ + return *((TYPE *)_arrayPop((WpArray)ARRAY, sizeof(TYPE))); \ }()) #else -#define _stack_array(TYPE, SIZE) struct {ArrayHeader header; \ +#define _stackArray(TYPE, SIZE) struct {WpArrayHeader header; \ TYPE items[SIZE]; \ - wapp_misc_utils_reserve_padding(sizeof(ArrayHeader) + \ - sizeof(TYPE) * SIZE);} -#define wapp_array(TYPE, ...) \ + wpMiscUtilsReservePadding(sizeof(WpArrayHeader) + \ + sizeof(TYPE) * SIZE);} +#define wpArray(TYPE, ...) \ ((TYPE *)( \ - (_stack_array(TYPE, _calc_array_capacity(TYPE, __VA_ARGS__))){ \ + (_stackArray(TYPE, _calcArrayCapacity(TYPE, __VA_ARGS__))){ \ .header = { \ - .magic = WAPP_ARRAY_MAGIC, \ - .count = _calc_array_count(TYPE, __VA_ARGS__), \ - .capacity = _calc_array_capacity(TYPE, __VA_ARGS__), \ + .magic = WP_ARRAY_MAGIC, \ + .count = _calcArrayCount(TYPE, __VA_ARGS__), \ + .capacity = _calcArrayCapacity(TYPE, __VA_ARGS__), \ .item_size = sizeof(TYPE), \ }, \ .items = {__VA_ARGS__}, \ }.items \ )) -#define wapp_array_with_capacity(TYPE, CAPACITY, FLAGS) \ +#define wpArrayWithCapacity(TYPE, CAPACITY, FLAGS) \ ((TYPE *)( \ - (_stack_array(TYPE, CAPACITY)){ \ + (_stackArray(TYPE, CAPACITY)){ \ .header = { \ - .magic = WAPP_ARRAY_MAGIC, \ - .count = (FLAGS & ARRAY_INIT_FILLED) ? CAPACITY : 0, \ + .magic = WP_ARRAY_MAGIC, \ + .count = (FLAGS & WP_ARRAY_INIT_FILLED) ? CAPACITY : 0, \ .capacity = CAPACITY, \ .item_size = sizeof(TYPE), \ }, \ .items = {0}, \ }.items \ )) -#define wapp_array_pop(TYPE, ARRAY) \ - (ARRAY == NULL || _array_count((GenericArray)ARRAY) == 0 ? \ +#define wpArrayPop(TYPE, ARRAY) \ + (ARRAY == NULL || _arrayCount((WpArray)ARRAY) == 0 ? \ (TYPE){0} : \ - *((TYPE *)_array_pop((GenericArray)ARRAY, sizeof(TYPE))) \ + *((TYPE *)_arrayPop((WpArray)ARRAY, sizeof(TYPE))) \ ) -#endif // !WAPP_PLATFORM_CPP +#endif // !WP_PLATFORM_CPP -#define wapp_array_count(ARRAY) \ - (_array_count((GenericArray)ARRAY)) -#define wapp_array_capacity(ARRAY) \ - (_array_capacity((GenericArray)ARRAY)) -#define wapp_array_item_size(ARRAY) \ - (_array_item_size((GenericArray)ARRAY)) -#define wapp_array_set_count(ARRAY, COUNT) \ - (_array_set_count((GenericArray)ARRAY, COUNT)) -#define wapp_array_get(TYPE, ARRAY, INDEX) \ - ((TYPE *)_array_get((GenericArray)ARRAY, \ +#define wpArrayCount(ARRAY) \ + (_arrayCount((WpArray)ARRAY)) +#define wpArrayCapacity(ARRAY) \ + (_arrayCapacity((WpArray)ARRAY)) +#define wpArrayItemSize(ARRAY) \ + (_arrayItemSize((WpArray)ARRAY)) +#define wpArraySetCount(ARRAY, COUNT) \ + (_arraySetCount((WpArray)ARRAY, COUNT)) +#define wpArrayGet(TYPE, ARRAY, INDEX) \ + ((TYPE *)_arrayGet((WpArray)ARRAY, \ INDEX, \ sizeof(TYPE))) -#define wapp_array_set(TYPE, ARRAY, INDEX, VALUE_PTR) \ - (_array_set((GenericArray)ARRAY, \ +#define wpArraySet(TYPE, ARRAY, INDEX, VALUE_PTR) \ + (_arraySet((WpArray)ARRAY, \ INDEX, \ (u8 *)VALUE_PTR, \ sizeof(TYPE))) -#define wapp_array_append_capped(TYPE, ARRAY, VALUE_PTR) \ - (_array_append_capped((GenericArray)ARRAY, \ +#define wpArrayAppendCapped(TYPE, ARRAY, VALUE_PTR) \ + (_arrayAppendCapped((WpArray)ARRAY, \ (u8 *)VALUE_PTR, \ sizeof(TYPE))) -#define wapp_array_extend_capped(TYPE, DST_ARRAY, SRC_ARRAY) \ - (_array_extend_capped((GenericArray)DST_ARRAY, \ - (GenericArray)SRC_ARRAY, \ +#define wpArrayExtendCapped(TYPE, DST_ARRAY, SRC_ARRAY) \ + (_arrayExtendCappend((WpArray)DST_ARRAY, \ + (WpArray)SRC_ARRAY, \ sizeof(TYPE))) -#define wapp_array_copy_capped(TYPE, DST_ARRAY, SRC_ARRAY) \ - (_array_copy_capped((GenericArray)DST_ARRAY, \ - (GenericArray)SRC_ARRAY, \ +#define wpArrayCopyCapped(TYPE, DST_ARRAY, SRC_ARRAY) \ + (_arrayCopyCapped((WpArray)DST_ARRAY, \ + (WpArray)SRC_ARRAY, \ sizeof(TYPE))) -#define wapp_array_append_alloc(TYPE, ALLOCATOR_PTR, ARRAY, VALUE_PTR, FLAGS) \ - ((TYPE *)_array_append_alloc(ALLOCATOR_PTR, \ - (GenericArray)ARRAY, \ +#define wpArrayAppendAlloc(TYPE, ALLOCATOR_PTR, ARRAY, VALUE_PTR, FLAGS) \ + ((TYPE *)_arrayAppendAlloc(ALLOCATOR_PTR, \ + (WpArray)ARRAY, \ (u8 *)VALUE_PTR, \ FLAGS, \ sizeof(TYPE))) -#define wapp_array_extend_alloc(TYPE, ALLOCATOR_PTR, DST_ARRAY, SRC_ARRAY, FLAGS) \ - ((TYPE *)_array_extend_alloc(ALLOCATOR_PTR, \ - (GenericArray)DST_ARRAY, \ - (GenericArray)SRC_ARRAY, \ +#define wpArrayExtendAlloc(TYPE, ALLOCATOR_PTR, DST_ARRAY, SRC_ARRAY, FLAGS) \ + ((TYPE *)_arrayExtendAlloc(ALLOCATOR_PTR, \ + (WpArray)DST_ARRAY, \ + (WpArray)SRC_ARRAY, \ FLAGS, \ sizeof(TYPE))) -#define wapp_array_copy_alloc(TYPE, ALLOCATOR_PTR, DST_ARRAY, SRC_ARRAY, FLAGS) \ - ((TYPE *)_array_copy_alloc(ALLOCATOR_PTR, \ - (GenericArray)DST_ARRAY, \ - (GenericArray)SRC_ARRAY, \ +#define wpArrayCopyAlloc(TYPE, ALLOCATOR_PTR, DST_ARRAY, SRC_ARRAY, FLAGS) \ + ((TYPE *)_arrayCopyAlloc(ALLOCATOR_PTR, \ + (WpArray)DST_ARRAY, \ + (WpArray)SRC_ARRAY, \ FLAGS, \ sizeof(TYPE))) -#define wapp_array_clear(TYPE, ARRAY) \ - (_array_clear((GenericArray)ARRAY, \ +#define wpArrayClear(TYPE, ARRAY) \ + (_arrayClear((WpArray)ARRAY, \ sizeof(TYPE))) -#define wapp_array_calc_alloc_size(TYPE, CAPACITY) _array_calc_alloc_size(CAPACITY, sizeof(TYPE)) -#define wapp_array_alloc_capacity(TYPE, ALLOCATOR_PTR, CAPACITY, FLAGS) \ - ((TYPE *)_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY, FLAGS, sizeof(TYPE))) -#define wapp_array_from_preallcated_buffer(TYPE, BUFFER, BUFFER_SIZE) \ +#define wpArrayCalcAllocSize(TYPE, CAPACITY) _arrayCalcAllocSize(CAPACITY, sizeof(TYPE)) +#define wpArrayAllocCapacity(TYPE, ALLOCATOR_PTR, CAPACITY, FLAGS) \ + ((TYPE *)_arrayAllocCapacity(ALLOCATOR_PTR, CAPACITY, FLAGS, sizeof(TYPE))) +#define wpArrayFromPreallcatedBuffer(TYPE, BUFFER, BUFFER_SIZE) \ ((TYPE *)_array_from_preallcated_buffer(BUFFER, BUFFER_SIZE, sizeof(TYPE))) -typedef struct header ArrayHeader; -struct header { +typedef struct WpArrayHeader WpArrayHeader; +struct WpArrayHeader { u64 magic; u64 count; u64 capacity; u64 item_size; }; -u64 _array_count(GenericArray array); -u64 _array_capacity(GenericArray array); -u64 _array_item_size(GenericArray array); -void _array_set_count(GenericArray array, u64 count); -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, - ArrayInitFlags flags, u64 item_size); -GenericArray _array_extend_alloc(const Allocator *allocator, GenericArray dst, const GenericArray src, - ArrayInitFlags flags, u64 item_size); -GenericArray _array_copy_alloc(const Allocator *allocator, GenericArray dst, const GenericArray src, - ArrayInitFlags flags, u64 item_size); -void *_array_pop(GenericArray array, u64 item_size); -void _array_clear(GenericArray array, u64 item_size); -u64 _array_calc_alloc_size(u64 capacity, u64 item_size); -GenericArray _array_alloc_capacity(const Allocator *allocator, u64 capacity, ArrayInitFlags flags, - u64 item_size); -GenericArray _array_from_preallocated_buffer(void *buffer, u64 buffer_size, ArrayInitFlags flags, - u64 item_size); +u64 _arrayCount(WpArray array); +u64 _arrayCapacity(WpArray array); +u64 _arrayItemSize(WpArray array); +void _arraySetCount(WpArray array, u64 count); +void *_arrayGet(WpArray array, u64 index, u64 item_size); +void _arraySet(WpArray array, u64 index, void *value, u64 item_size); +void _arrayAppendCapped(WpArray array, void *value, u64 item_size); +void _arrayExtendCappend(WpArray dst, const WpArray src, u64 item_size); +void _arrayCopyCapped(WpArray dst, const WpArray src, u64 item_size); +WpArray _arrayAppendAlloc(const WpAllocator *allocator, WpArray array, void *value, + WpArrayInitFlags flags, u64 item_size); +WpArray _arrayExtendAlloc(const WpAllocator *allocator, WpArray dst, const WpArray src, + WpArrayInitFlags flags, u64 item_size); +WpArray _arrayCopyAlloc(const WpAllocator *allocator, WpArray dst, const WpArray src, + WpArrayInitFlags flags, u64 item_size); +void *_arrayPop(WpArray array, u64 item_size); +void _arrayClear(WpArray array, u64 item_size); +u64 _arrayCalcAllocSize(u64 capacity, u64 item_size); +WpArray _arrayAllocCapacity(const WpAllocator *allocator, u64 capacity, WpArrayInitFlags flags, + u64 item_size); +WpArray _arrayFromPreallocatedBuffer(void *buffer, u64 buffer_size, WpArrayInitFlags flags, + u64 item_size); -#ifdef WAPP_PLATFORM_CPP +#ifdef WP_PLATFORM_CPP END_C_LINKAGE -#endif // !WAPP_PLATFORM_CPP +#endif // !WP_PLATFORM_CPP #endif // !ARRAY_H diff --git a/src/base/dbl_list/dbl_list.c b/src/base/dbl_list/dbl_list.c index 8937738..43f0e80 100644 --- a/src/base/dbl_list/dbl_list.c +++ b/src/base/dbl_list/dbl_list.c @@ -7,46 +7,46 @@ #include "../../common/platform/platform.h" #include -wapp_intern GenericList _node_to_list(GenericNode *node, u64 item_size); -wapp_intern inline void _dbl_list_validate(const GenericList *list, u64 item_size); -wapp_intern inline void _dbl_list_node_validate(const GenericList *list, const GenericNode *node, u64 item_size); +wp_intern WpDblList _node_to_list(WpDblNode *node, u64 item_size); +wp_intern inline void _dblListValidate(const WpDblList *list, u64 item_size); +wp_intern inline void _dblListNodeValidate(const WpDblList *list, const WpDblNode *node, u64 item_size); -GenericList *_dbl_list_alloc(const Allocator *allocator, u64 item_size) { - wapp_debug_assert(allocator != NULL, "`allocator` should not be NULL"); +WpDblList *_dblListAlloc(const WpAllocator *allocator, u64 item_size) { + wpDebugAssert(allocator != NULL, "`allocator` should not be NULL"); - GenericList *list = wapp_mem_allocator_alloc(allocator, sizeof(GenericList)); + WpDblList *list = wpMemAllocatorAlloc(allocator, sizeof(WpDblList)); if (!list) { goto DBL_LIST_ALLOC_RETURN; } - memset((void *)list, 0, sizeof(GenericList)); - list->magic = WAPP_DBL_LIST_MAGIC; + memset((void *)list, 0, sizeof(WpDblList)); + list->magic = WP_DBL_LIST_MAGIC; list->item_size = item_size; DBL_LIST_ALLOC_RETURN: return list; } -GenericNode *_dbl_list_node_alloc(const Allocator *allocator, void *item, u64 item_size) { - wapp_debug_assert(allocator != NULL, "`allocator` should not be NULL"); +WpDblNode *_dblListNodeAlloc(const WpAllocator *allocator, void *item, u64 item_size) { + wpDebugAssert(allocator != NULL, "`allocator` should not be NULL"); - GenericNode *node = wapp_mem_allocator_alloc(allocator, sizeof(GenericNode)); + WpDblNode *node = wpMemAllocatorAlloc(allocator, sizeof(WpDblNode)); if (!node) { goto DBL_LIST_NODE_ALLOC_RETURN; } - memset((void *)node, 0, sizeof(GenericNode)); + memset((void *)node, 0, sizeof(WpDblNode)); node->item = item; - node->header.magic = WAPP_DBL_NODE_MAGIC; + node->header.magic = WP_DBL_NODE_MAGIC; node->header.item_size = item_size; DBL_LIST_NODE_ALLOC_RETURN: 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"); +WpDblNode *_dblListGet(const WpDblList *list, u64 index, u64 item_size) { + wpDebugAssert(list != NULL, "`list` should not be NULL"); + _dblListValidate(list, item_size); + wpRuntimeAssert(index < list->node_count, "`index` is out of bounds"); - GenericNode *output = NULL; - GenericNode *current = list->first; + WpDblNode *output = NULL; + WpDblNode *current = list->first; for (u64 i = 1; i <= index; ++i) { current = current->header.next; } @@ -56,12 +56,12 @@ GenericNode *_dbl_list_get(const GenericList *list, u64 index, u64 item_size) { 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); +void _dblListPushFront(WpDblList *list, WpDblNode *node, u64 item_size) { + wpDebugAssert(list != NULL && node != NULL && (node->item) != NULL, "`list`, `node` and `node->item` should not be NULL"); + _dblListValidate(list, item_size); + _dblListNodeValidate(list, node, item_size); - GenericList node_list = _node_to_list(node, item_size); + WpDblList node_list = _node_to_list(node, item_size); if (list->node_count == 0) { *list = node_list; @@ -70,7 +70,7 @@ void _dbl_list_push_front(GenericList *list, GenericNode *node, u64 item_size) { list->node_count += node_list.node_count; - GenericNode *first = list->first; + WpDblNode *first = list->first; if (first) { first->header.prev = node_list.last; } @@ -79,12 +79,12 @@ void _dbl_list_push_front(GenericList *list, GenericNode *node, u64 item_size) { node_list.last->header.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); +void _dblListPushBack(WpDblList *list, WpDblNode *node, u64 item_size) { + wpDebugAssert(list != NULL && node != NULL && (node->item) != NULL, "`list`, `node` and `node->item` should not be NULL"); + _dblListValidate(list, item_size); + _dblListNodeValidate(list, node, item_size); - GenericList node_list = _node_to_list(node, item_size); + WpDblList node_list = _node_to_list(node, item_size); if (list->node_count == 0) { *list = node_list; @@ -93,7 +93,7 @@ void _dbl_list_push_back(GenericList *list, GenericNode *node, u64 item_size) { list->node_count += node_list.node_count; - GenericNode *last = list->last; + WpDblNode *last = list->last; if (last) { last->header.next = node_list.first; } @@ -102,29 +102,29 @@ void _dbl_list_push_back(GenericList *list, GenericNode *node, u64 item_size) { node_list.first->header.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); +void _dblListInsert(WpDblList *list, WpDblNode *node, u64 index, u64 item_size) { + wpDebugAssert(list != NULL && node != NULL && (node->item) != NULL, "`list`, `node` and `node->item` should not be NULL"); + _dblListValidate(list, item_size); + _dblListNodeValidate(list, node, item_size); if (index == 0) { - _dbl_list_push_front(list, node, item_size); + _dblListPushFront(list, node, item_size); return; } else if (index == list->node_count) { - _dbl_list_push_back(list, node, item_size); + _dblListPushBack(list, node, item_size); return; } - GenericNode *dst_node = _dbl_list_get(list, index, item_size); + WpDblNode *dst_node = _dblListGet(list, index, item_size); if (!dst_node) { return; } - GenericList node_list = _node_to_list(node, item_size); + WpDblList node_list = _node_to_list(node, item_size); list->node_count += node_list.node_count; - GenericNode *prev = dst_node->header.prev; + WpDblNode *prev = dst_node->header.prev; dst_node->header.prev = node_list.last; prev->header.next = node_list.first; @@ -133,11 +133,11 @@ void _dbl_list_insert(GenericList *list, GenericNode *node, u64 index, u64 item_ node_list.last->header.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); +WpDblNode *_dblListPopFront(WpDblList *list, u64 item_size) { + wpDebugAssert(list != NULL, "`list` should not be NULL"); + _dblListValidate(list, item_size); - GenericNode *output = NULL; + WpDblNode *output = NULL; if (list->node_count == 0) { goto RETURN_LIST_POP_FRONT; @@ -146,7 +146,7 @@ GenericNode *_dbl_list_pop_front(GenericList *list, u64 item_size) { output = list->first; if (list->node_count == 1) { - *list = (GenericList){.magic = WAPP_DBL_LIST_MAGIC, .item_size = item_size}; + *list = (WpDblList){.magic = WP_DBL_LIST_MAGIC, .item_size = item_size}; goto RETURN_LIST_POP_FRONT; } @@ -159,11 +159,11 @@ RETURN_LIST_POP_FRONT: 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); +WpDblNode *_dblListPopBack(WpDblList *list, u64 item_size) { + wpDebugAssert(list != NULL, "`list` should not be NULL"); + _dblListValidate(list, item_size); - GenericNode *output = NULL; + WpDblNode *output = NULL; if (list->node_count == 0) { goto RETURN_LIST_POP_BACK; @@ -172,7 +172,7 @@ GenericNode *_dbl_list_pop_back(GenericList *list, u64 item_size) { output = list->last; if (list->node_count == 1) { - *list = (GenericList){.magic = WAPP_DBL_LIST_MAGIC, .item_size = item_size}; + *list = (WpDblList){.magic = WP_DBL_LIST_MAGIC, .item_size = item_size}; goto RETURN_LIST_POP_BACK; } @@ -185,21 +185,21 @@ RETURN_LIST_POP_BACK: 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); +WpDblNode *_dblListRemove(WpDblList *list, u64 index, u64 item_size) { + wpDebugAssert(list != NULL, "`list` should not be NULL"); + _dblListValidate(list, item_size); - GenericNode *output = NULL; + WpDblNode *output = NULL; if (index == 0) { - output = _dbl_list_pop_front(list, item_size); + output = _dblListPopFront(list, item_size); goto RETURN_LIST_REMOVE; } else if (index == list->node_count) { - output = _dbl_list_pop_back(list, item_size); + output = _dblListPopBack(list, item_size); goto RETURN_LIST_REMOVE; } - output = _dbl_list_get(list, index, item_size); + output = _dblListGet(list, index, item_size); if (!output) { goto RETURN_LIST_REMOVE; } @@ -215,19 +215,19 @@ RETURN_LIST_REMOVE: 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); +void _dblListEmpty(WpDblList *list, u64 item_size) { + wpDebugAssert(list != NULL, "`list` should not be NULL"); + _dblListValidate(list, item_size); u64 count = list->node_count; for (u64 i = 0; i < count; ++i) { - _dbl_list_pop_back(list, item_size); + _dblListPopBack(list, item_size); } } -wapp_intern GenericList _node_to_list(GenericNode *node, u64 item_size) { - GenericList output = { - .magic = WAPP_DBL_LIST_MAGIC, +wp_intern WpDblList _node_to_list(WpDblNode *node, u64 item_size) { + WpDblList output = { + .magic = WP_DBL_LIST_MAGIC, .first = node, .last = node, .node_count = 1, @@ -247,13 +247,13 @@ wapp_intern GenericList _node_to_list(GenericNode *node, u64 item_size) { return output; } -wapp_intern inline 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"); +wp_intern inline void _dblListValidate(const WpDblList *list, u64 item_size) { + wpRuntimeAssert(list->magic == WP_DBL_LIST_MAGIC, "`list` isn't a valid wp list type"); + wpRuntimeAssert(list->item_size == item_size, "Invalid item provided"); } -wapp_intern inline void _dbl_list_node_validate(const GenericList *list, const GenericNode *node, u64 item_size) { - wapp_runtime_assert(node->header.magic == WAPP_DBL_NODE_MAGIC, "`node` isn't a valid wapp node type"); - wapp_runtime_assert(list->item_size == node->header.item_size, "Mismatched `list` and `node` types"); - wapp_runtime_assert(node->header.item_size == item_size, "Invalid item provided"); +wp_intern inline void _dblListNodeValidate(const WpDblList *list, const WpDblNode *node, u64 item_size) { + wpRuntimeAssert(node->header.magic == WP_DBL_NODE_MAGIC, "`node` isn't a valid wp node type"); + wpRuntimeAssert(list->item_size == node->header.item_size, "Mismatched `list` and `node` types"); + wpRuntimeAssert(node->header.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 eb9c68f..708785e 100644 --- a/src/base/dbl_list/dbl_list.h +++ b/src/base/dbl_list/dbl_list.h @@ -7,24 +7,24 @@ #include "../../common/aliases/aliases.h" #include "../../common/platform/platform.h" -#ifdef WAPP_PLATFORM_CPP +#ifdef WP_PLATFORM_CPP BEGIN_C_LINKAGE -#endif // !WAPP_PLATFORM_CPP +#endif // !WP_PLATFORM_CPP -#define WAPP_DBL_LIST_MAGIC (u64)0x57415f444c5354 -#define WAPP_DBL_NODE_MAGIC (u64)0x57415f444e44 +#define WP_DBL_LIST_MAGIC (u64)0x57415f444c5354 +#define WP_DBL_NODE_MAGIC (u64)0x57415f444e44 -typedef struct GenericNode GenericNode; +typedef struct WpDblNode WpDblNode; typedef struct { u64 magic; u64 item_size; - GenericNode *prev; - GenericNode *next; -} NodeHeader; + WpDblNode *prev; + WpDblNode *next; +} WpDblNodeHeader; -struct GenericNode { - NodeHeader header; +struct WpDblNode { + WpDblNodeHeader header; void *item; }; @@ -32,153 +32,153 @@ typedef struct { u64 magic; u64 node_count; u64 item_size; - GenericNode *first; - GenericNode *last; -} GenericList; + WpDblNode *first; + WpDblNode *last; +} WpDblList; -// NOTE (Abdelrahman): GenericList typedefs for readability -typedef GenericList VoidPtrList; -typedef GenericList C8List; -typedef GenericList C16List; -typedef GenericList C32List; -typedef GenericList U8List; -typedef GenericList U16List; -typedef GenericList U32List; -typedef GenericList U64List; -typedef GenericList B8List; -typedef GenericList I8List; -typedef GenericList I16List; -typedef GenericList I32List; -typedef GenericList I64List; -typedef GenericList F32List; -typedef GenericList F64List; -typedef GenericList F128List; -typedef GenericList UptrList; -typedef GenericList IptrList; -typedef GenericList Str8List; +// NOTE (Abdelrahman): WpDblList typedefs for readability +typedef WpDblList WpVoidPtrList; +typedef WpDblList WpC8List; +typedef WpDblList WpC16List; +typedef WpDblList WpC32List; +typedef WpDblList WpU8List; +typedef WpDblList WpU16List; +typedef WpDblList WpU32List; +typedef WpDblList WpU64List; +typedef WpDblList WpB8List; +typedef WpDblList WpI8List; +typedef WpDblList WpI16List; +typedef WpDblList WpI32List; +typedef WpDblList WpI64List; +typedef WpDblList WpF32List; +typedef WpDblList WpF64List; +typedef WpDblList WpF128List; +typedef WpDblList WpUptrList; +typedef WpDblList WpIptrList; +typedef WpDblList WpStr8List; -// NOTE (Abdelrahman): GenericNode typedefs for readability -typedef GenericNode VoidPtrNode; -typedef GenericNode C8Node; -typedef GenericNode C16Node; -typedef GenericNode C32Node; -typedef GenericNode U8Node; -typedef GenericNode U16Node; -typedef GenericNode U32Node; -typedef GenericNode U64Node; -typedef GenericNode B8Node; -typedef GenericNode I8Node; -typedef GenericNode I16Node; -typedef GenericNode I32Node; -typedef GenericNode I64Node; -typedef GenericNode F32Node; -typedef GenericNode F64Node; -typedef GenericNode F128Node; -typedef GenericNode UptrNode; -typedef GenericNode IptrNode; -typedef GenericNode Str8Node; +// NOTE (Abdelrahman): WpDblNode typedefs for readability +typedef WpDblNode WpVoidPtrNode; +typedef WpDblNode WpC8Node; +typedef WpDblNode WpC16Node; +typedef WpDblNode WpC32Node; +typedef WpDblNode WpU8Node; +typedef WpDblNode WpU16Node; +typedef WpDblNode WpU32Node; +typedef WpDblNode WpU64Node; +typedef WpDblNode WpB8Node; +typedef WpDblNode WpI8Node; +typedef WpDblNode WpI16Node; +typedef WpDblNode WpI32Node; +typedef WpDblNode WpI64Node; +typedef WpDblNode WpF32Node; +typedef WpDblNode WpF64Node; +typedef WpDblNode WpF128Node; +typedef WpDblNode WpUptrNode; +typedef WpDblNode WpIptrNode; +typedef WpDblNode WpStr8Node; -#ifdef WAPP_PLATFORM_CPP -#define wapp_dbl_list(TYPE) \ - GenericList{WAPP_DBL_LIST_MAGIC, 0, sizeof(TYPE), nullptr, nullptr} -#define _dbl_list_node(TYPE, ITEM_PTR) ([&]() { \ - wapp_persist GenericNode node = { \ - NodeHeader{WAPP_DBL_NODE_MAGIC, sizeof(TYPE), nullptr, nullptr}, \ +#ifdef WP_PLATFORM_CPP +#define wpDblList(TYPE) \ + WpDblList{WP_DBL_LIST_MAGIC, 0, sizeof(TYPE), nullptr, nullptr} +#define _dblListNode(TYPE, ITEM_PTR) ([&]() { \ + wp_persist WpDblNode node = { \ + WpDblNodeHeader{WP_DBL_NODE_MAGIC, sizeof(TYPE), nullptr, nullptr}, \ ITEM_PTR, \ }; \ \ return &node; \ }()) #else -#define wapp_dbl_list(TYPE) ( \ - (GenericList){.magic = WAPP_DBL_LIST_MAGIC, .item_size = sizeof(TYPE)} \ +#define wpDblList(TYPE) ( \ + (WpDblList){.magic = WP_DBL_LIST_MAGIC, .item_size = sizeof(TYPE)} \ ) -#define _dbl_list_node(TYPE, ITEM_PTR) ( \ - &((GenericNode){.header = {.magic = WAPP_DBL_NODE_MAGIC, .item_size = sizeof(TYPE)}, \ +#define _dblListNode(TYPE, ITEM_PTR) ( \ + &((WpDblNode){.header = {.magic = WP_DBL_NODE_MAGIC, .item_size = sizeof(TYPE)}, \ .item = ITEM_PTR}) \ ) -#endif // !WAPP_PLATFORM_CPP +#endif // !WP_PLATFORM_CPP -#define wapp_dbl_list_alloc(TYPE, ALLOCATOR) \ - (_dbl_list_alloc(ALLOCATOR, sizeof(TYPE))) -#define wapp_dbl_list_get(TYPE, LIST_PTR, ITEM_INDEX) \ - ((TYPE *)(_dbl_list_get(LIST_PTR, ITEM_INDEX, sizeof(TYPE))->item)) -#define wapp_dbl_list_get_node(TYPE, LIST_PTR, ITEM_INDEX) \ - (_dbl_list_get(LIST_PTR, ITEM_INDEX, sizeof(TYPE))) -#define wapp_dbl_list_get_node_item(TYPE, NODE_PTR) \ +#define wpDblListAlloc(TYPE, ALLOCATOR) \ + (_dblListAlloc(ALLOCATOR, sizeof(TYPE))) +#define wpDblListGet(TYPE, LIST_PTR, ITEM_INDEX) \ + ((TYPE *)(_dblListGet(LIST_PTR, ITEM_INDEX, sizeof(TYPE))->item)) +#define wpDblListGetNode(TYPE, LIST_PTR, ITEM_INDEX) \ + (_dblListGet(LIST_PTR, ITEM_INDEX, sizeof(TYPE))) +#define wpDblListGetNodeItem(TYPE, NODE_PTR) \ ((TYPE *)( \ (NODE_PTR == NULL) ? \ NULL : \ (NODE_PTR)->item \ )) -#define wapp_dbl_list_push_front(TYPE, LIST_PTR, ITEM_PTR) \ - (_dbl_list_push_front(LIST_PTR, _dbl_list_node(TYPE, ITEM_PTR), sizeof(TYPE))) -#define wapp_dbl_list_push_back(TYPE, LIST_PTR, ITEM_PTR) \ - (_dbl_list_push_back(LIST_PTR, _dbl_list_node(TYPE, ITEM_PTR), sizeof(TYPE))) -#define wapp_dbl_list_insert(TYPE, LIST_PTR, ITEM_PTR, ITEM_INDEX) \ - (_dbl_list_insert(LIST_PTR, _dbl_list_node(TYPE, ITEM_PTR), \ +#define wpDblListPushFront(TYPE, LIST_PTR, ITEM_PTR) \ + (_dblListPushFront(LIST_PTR, _dblListNode(TYPE, ITEM_PTR), sizeof(TYPE))) +#define wpDblListPushBack(TYPE, LIST_PTR, ITEM_PTR) \ + (_dblListPushBack(LIST_PTR, _dblListNode(TYPE, ITEM_PTR), sizeof(TYPE))) +#define wpDblListInsert(TYPE, LIST_PTR, ITEM_PTR, ITEM_INDEX) \ + (_dblListInsert(LIST_PTR, _dblListNode(TYPE, ITEM_PTR), \ ITEM_INDEX, sizeof(TYPE))) -#define wapp_dbl_list_push_front_alloc(TYPE, ALLOCATOR, LIST_PTR, ITEM_PTR) \ - (_dbl_list_push_front(LIST_PTR, _dbl_list_node_alloc(ALLOCATOR, ITEM_PTR, sizeof(TYPE)), \ +#define wpDblListPushFrontAlloc(TYPE, ALLOCATOR, LIST_PTR, ITEM_PTR) \ + (_dblListPushFront(LIST_PTR, _dblListNodeAlloc(ALLOCATOR, ITEM_PTR, sizeof(TYPE)), \ sizeof(TYPE))) -#define wapp_dbl_list_push_back_alloc(TYPE, ALLOCATOR, LIST_PTR, ITEM_PTR) \ - (_dbl_list_push_back(LIST_PTR, _dbl_list_node_alloc(ALLOCATOR, ITEM_PTR, sizeof(TYPE)), \ +#define wpDblListPushBackAlloc(TYPE, ALLOCATOR, LIST_PTR, ITEM_PTR) \ + (_dblListPushBack(LIST_PTR, _dblListNodeAlloc(ALLOCATOR, ITEM_PTR, sizeof(TYPE)), \ sizeof(TYPE))) -#define wapp_dbl_list_insert_alloc(TYPE, ALLOCATOR, LIST_PTR, ITEM_PTR, ITEM_INDEX) \ - (_dbl_list_insert(LIST_PTR, _dbl_list_node_alloc(ALLOCATOR, ITEM_PTR, sizeof(TYPE)), \ +#define wpDblListInsertAlloc(TYPE, ALLOCATOR, LIST_PTR, ITEM_PTR, ITEM_INDEX) \ + (_dblListInsert(LIST_PTR, _dblListNodeAlloc(ALLOCATOR, ITEM_PTR, sizeof(TYPE)), \ ITEM_INDEX, sizeof(TYPE))) -#define wapp_dbl_list_pop_front(TYPE, LIST_PTR) \ +#define wpDblListPopFront(TYPE, LIST_PTR) \ ((TYPE *)( \ (LIST_PTR == NULL || (LIST_PTR)->node_count == 0) ? \ NULL : \ - _dbl_list_pop_front(LIST_PTR, sizeof(TYPE))->item \ + _dblListPopFront(LIST_PTR, sizeof(TYPE))->item \ )) -#define wapp_dbl_list_pop_back(TYPE, LIST_PTR) \ +#define wpDblListPopBack(TYPE, LIST_PTR) \ ((TYPE *)( \ (LIST_PTR == NULL || (LIST_PTR)->node_count == 0) ? \ NULL : \ - _dbl_list_pop_back(LIST_PTR, sizeof(TYPE))->item \ + _dblListPopBack(LIST_PTR, sizeof(TYPE))->item \ )) -#define wapp_dbl_list_remove(TYPE, LIST_PTR, ITEM_INDEX) \ +#define wpDblListRemove(TYPE, LIST_PTR, ITEM_INDEX) \ ((TYPE *)( \ (LIST_PTR == NULL || (LIST_PTR)->node_count == 0 || ITEM_INDEX >= (LIST_PTR)->node_count) ? \ NULL : \ - _dbl_list_remove(LIST_PTR, ITEM_INDEX, sizeof(TYPE))->item \ + _dblListRemove(LIST_PTR, ITEM_INDEX, sizeof(TYPE))->item \ )) -#define wapp_dbl_list_pop_front_node(TYPE, LIST_PTR) \ +#define wpDblListPopFrontNode(TYPE, LIST_PTR) \ ( \ (LIST_PTR == NULL || (LIST_PTR)->node_count == 0) ? \ NULL : \ - _dbl_list_pop_front(LIST_PTR, sizeof(TYPE)) \ + _dblListPopFront(LIST_PTR, sizeof(TYPE)) \ ) -#define wapp_dbl_list_pop_back_node(TYPE, LIST_PTR) \ +#define wpDblListPopBackNode(TYPE, LIST_PTR) \ ( \ (LIST_PTR == NULL || (LIST_PTR)->node_count == 0) ? \ NULL : \ - _dbl_list_pop_back(LIST_PTR, sizeof(TYPE)) \ + _dblListPopBack(LIST_PTR, sizeof(TYPE)) \ ) -#define wapp_dbl_list_remove_node(TYPE, LIST_PTR, ITEM_INDEX) \ +#define wpDblListRemoveNode(TYPE, LIST_PTR, ITEM_INDEX) \ ( \ (LIST_PTR == NULL || (LIST_PTR)->node_count == 0 || ITEM_INDEX >= (LIST_PTR)->node_count) ? \ NULL : \ - _dbl_list_remove(LIST_PTR, ITEM_INDEX, sizeof(TYPE)) \ + _dblListRemove(LIST_PTR, ITEM_INDEX, sizeof(TYPE)) \ ) -#define wapp_dbl_list_empty(TYPE, LIST_PTR) \ - (_dbl_list_empty(LIST_PTR, sizeof(TYPE))) +#define wpDblListEmpty(TYPE, LIST_PTR) \ + (_dblListEmpty(LIST_PTR, sizeof(TYPE))) -GenericList *_dbl_list_alloc(const Allocator *allocator, u64 item_size); -GenericNode *_dbl_list_node_alloc(const Allocator *allocator, void *item, 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); +WpDblList *_dblListAlloc(const WpAllocator *allocator, u64 item_size); +WpDblNode *_dblListNodeAlloc(const WpAllocator *allocator, void *item, u64 item_size); +WpDblNode *_dblListGet(const WpDblList *list, u64 index, u64 item_size); +void _dblListPushFront(WpDblList *list, WpDblNode *node, u64 item_size); +void _dblListPushBack(WpDblList *list, WpDblNode *node, u64 item_size); +void _dblListInsert(WpDblList *list, WpDblNode *node, u64 index, u64 item_size); +WpDblNode *_dblListPopFront(WpDblList *list, u64 item_size); +WpDblNode *_dblListPopBack(WpDblList *list, u64 item_size); +WpDblNode *_dblListRemove(WpDblList *list, u64 index, u64 item_size); +void _dblListEmpty(WpDblList *list, u64 item_size); -#ifdef WAPP_PLATFORM_CPP +#ifdef WP_PLATFORM_CPP END_C_LINKAGE -#endif // !WAPP_PLATFORM_CPP +#endif // !WP_PLATFORM_CPP #endif // !DBL_LIST_H diff --git a/src/base/mem/allocator/mem_allocator.c b/src/base/mem/allocator/mem_allocator.c index d9b0a50..216d863 100644 --- a/src/base/mem/allocator/mem_allocator.c +++ b/src/base/mem/allocator/mem_allocator.c @@ -5,28 +5,28 @@ #include "../../../common/assert/assert.h" #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"); +void *wpMemAllocatorAlloc(const WpAllocator *allocator, u64 size) { + wpDebugAssert(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"); +void *wpMemAllocatorAllocAligned(const WpAllocator *allocator, u64 size, u64 alignment) { + wpDebugAssert(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"); +void *wpMemAllocatorRealloc(const WpAllocator *allocator, void *ptr, u64 old_size, u64 new_size) { + wpDebugAssert(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, +void *wpMemAllocatorReallocAligned(const WpAllocator *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"); + wpDebugAssert(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) { +void wpMemAllocatorFree(const WpAllocator *allocator, void **ptr, u64 size) { if (!allocator || !(allocator->free)) { return; } diff --git a/src/base/mem/allocator/mem_allocator.h b/src/base/mem/allocator/mem_allocator.h index add3ca4..ac3940f 100644 --- a/src/base/mem/allocator/mem_allocator.h +++ b/src/base/mem/allocator/mem_allocator.h @@ -7,44 +7,44 @@ #include "../../../common/platform/platform.h" #include -#ifdef WAPP_PLATFORM_CPP +#ifdef WP_PLATFORM_CPP BEGIN_C_LINKAGE -#endif // !WAPP_PLATFORM_CPP +#endif // !WP_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 *(WpMemAllocFunc)(u64 size, void *alloc_obj); +typedef void *(WpMemAllocAlignedFunc)(u64 size, u64 alignment, void *alloc_obj); +typedef void *(WpMemReallocFunc)(void *ptr, u64 old_size, u64 new_size, void *alloc_obj); +typedef void *(WpMemReallocAlignedFunc)(void *ptr, u64 old_size, u64 new_size, u64 alignment, void *alloc_obj); +typedef void (WpMemFreeFunc)(void **ptr, u64 size, void *alloc_obj); -typedef struct Allocator Allocator; -struct Allocator { +typedef struct WpAllocator WpAllocator; +struct WpAllocator { void *obj; - MemAllocFunc *alloc; - MemAllocAlignedFunc *alloc_aligned; - MemReallocFunc *realloc; - MemReallocAlignedFunc *realloc_aligned; - MemFreeFunc *free; + WpMemAllocFunc *alloc; + WpMemAllocAlignedFunc *alloc_aligned; + WpMemReallocFunc *realloc; + WpMemReallocAlignedFunc *realloc_aligned; + WpMemFreeFunc *free; }; -#ifdef WAPP_PLATFORM_CPP -#define wapp_mem_allocator_invalid(ALLOCATOR) ([&]() { \ - Allocator alloc{}; \ - return memcmp(ALLOCATOR, &alloc, sizeof(Allocator)) == 0; \ +#ifdef WP_PLATFORM_CPP +#define wpMemAllocatorInvalid(ALLOCATOR) ([&]() { \ + WpAllocator alloc{}; \ + return memcmp(ALLOCATOR, &alloc, sizeof(WpAllocator)) == 0; \ }()) #else -#define wapp_mem_allocator_invalid(ALLOCATOR) (memcmp(ALLOCATOR, &((Allocator){0}), sizeof(Allocator)) == 0) -#endif // !WAPP_PLATFORM_CPP +#define wpMemAllocatorInvalid(ALLOCATOR) (memcmp(ALLOCATOR, &((WpAllocator){0}), sizeof(WpAllocator)) == 0) +#endif // !WP_PLATFORM_CPP -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, +void *wpMemAllocatorAlloc(const WpAllocator *allocator, u64 size); +void *wpMemAllocatorAllocAligned(const WpAllocator *allocator, u64 size, u64 alignment); +void *wpMemAllocatorRealloc(const WpAllocator *allocator, void *ptr, u64 old_size, u64 new_size); +void *wpMemAllocatorReallocAligned(const WpAllocator *allocator, void *ptr, u64 old_size, u64 new_size, u64 alignment); -void wapp_mem_allocator_free(const Allocator *allocator, void **ptr, u64 size); +void wpMemAllocatorFree(const WpAllocator *allocator, void **ptr, u64 size); -#ifdef WAPP_PLATFORM_CPP +#ifdef WP_PLATFORM_CPP END_C_LINKAGE -#endif // !WAPP_PLATFORM_CPP +#endif // !WP_PLATFORM_CPP #endif // !MEM_ALLOCATOR_H diff --git a/src/base/mem/utils/mem_utils.c b/src/base/mem/utils/mem_utils.c index 9328c8f..87bbcb4 100644 --- a/src/base/mem/utils/mem_utils.c +++ b/src/base/mem/utils/mem_utils.c @@ -6,9 +6,9 @@ #include "../../../common/misc/misc_utils.h" #include -void *wapp_mem_util_align_forward(void *ptr, u64 alignment) { - wapp_debug_assert(ptr != NULL, "`ptr` should not be NULL"); - wapp_runtime_assert(wapp_is_power_of_two(alignment), "`alignment` value is not a power of two"); +void *wpMemUtilAlignForward(void *ptr, u64 alignment) { + wpDebugAssert(ptr != NULL, "`ptr` should not be NULL"); + wpRuntimeAssert(wpMiscUtilsIsPowerOfTwo(alignment), "`alignment` value is not a power of two"); uptr p = (uptr)ptr; uptr align = (uptr)alignment; diff --git a/src/base/mem/utils/mem_utils.h b/src/base/mem/utils/mem_utils.h index ca7f781..9b6d4b5 100644 --- a/src/base/mem/utils/mem_utils.h +++ b/src/base/mem/utils/mem_utils.h @@ -6,14 +6,14 @@ #include "../../../common/aliases/aliases.h" #include "../../../common/platform/platform.h" -#ifdef WAPP_PLATFORM_CPP +#ifdef WP_PLATFORM_CPP BEGIN_C_LINKAGE -#endif // !WAPP_PLATFORM_CPP +#endif // !WP_PLATFORM_CPP -void *wapp_mem_util_align_forward(void *ptr, u64 alignment); +void *wpMemUtilAlignForward(void *ptr, u64 alignment); -#ifdef WAPP_PLATFORM_CPP +#ifdef WP_PLATFORM_CPP END_C_LINKAGE -#endif // !WAPP_PLATFORM_CPP +#endif // !WP_PLATFORM_CPP #endif // !MEM_UTILS_H diff --git a/src/base/queue/queue.c b/src/base/queue/queue.c index b6cb0bb..a82eb32 100644 --- a/src/base/queue/queue.c +++ b/src/base/queue/queue.c @@ -6,15 +6,15 @@ #include "../../common/misc/misc_utils.h" #include -void _queue_push(GenericQueue *queue, void *item, u64 item_size) { - wapp_debug_assert(queue != NULL, "`queue` should not be NULL"); - wapp_runtime_assert(item_size == wapp_array_item_size(queue->items), "Invalid type"); +void _queuePush(WpQueue *queue, void *item, u64 item_size) { + wpDebugAssert(queue != NULL, "`queue` should not be NULL"); + wpRuntimeAssert(item_size == wpArrayItemSize(queue->items), "Invalid type"); - u64 capacity = wapp_array_capacity(queue->items); + u64 capacity = wpArrayCapacity(queue->items); if (queue->count >= capacity) { return; } u64 index = (queue->back)++; - _array_set(queue->items, index, item, item_size); + _arraySet(queue->items, index, item, item_size); ++(queue->count); if (queue->back >= capacity) { @@ -22,30 +22,30 @@ void _queue_push(GenericQueue *queue, void *item, u64 item_size) { } } -GenericQueue *_queue_push_alloc(const Allocator *allocator, GenericQueue *queue, void *item, u64 item_size) { - wapp_debug_assert(allocator != NULL && queue != NULL && item != NULL, +WpQueue *_queuePushAlloc(const WpAllocator *allocator, WpQueue *queue, void *item, u64 item_size) { + wpDebugAssert(allocator != NULL && queue != NULL && item != NULL, "`allocator`, `queue` and `item` should not be NULL"); - wapp_runtime_assert(item_size == wapp_array_item_size(queue->items), "Invalid type"); + wpRuntimeAssert(item_size == wpArrayItemSize(queue->items), "Invalid type"); - GenericQueue *output = queue; + WpQueue *output = queue; - u64 capacity = wapp_array_capacity(queue->items); + u64 capacity = wpArrayCapacity(queue->items); // NOTE (Abdelrahman): Extracted into variable to fix MSVC error b8 queue_full = queue->count >= capacity; if (queue_full) { - u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(capacity * 2); - u64 array_size = _array_calc_alloc_size(new_capacity, item_size); - u64 alloc_size = sizeof(GenericQueue) + array_size; - void *buffer = wapp_mem_allocator_alloc(allocator, alloc_size); + u64 new_capacity = wpMiscUtilsU64RoundUpPow2(capacity * 2); + u64 array_size = _arrayCalcAllocSize(new_capacity, item_size); + u64 alloc_size = sizeof(WpQueue) + array_size; + void *buffer = wpMemAllocatorAlloc(allocator, alloc_size); if (!buffer) { goto RETURN_QUEUE_PUSH_ALLOC; } memset((void *)buffer, 0, alloc_size); - output = (GenericQueue *)buffer; - output->items = _array_from_preallocated_buffer((void *)(output + 1), array_size, ARRAY_INIT_FILLED, item_size); + output = (WpQueue *)buffer; + output->items = _arrayFromPreallocatedBuffer((void *)(output + 1), array_size, WP_ARRAY_INIT_FILLED, item_size); // NOTE (Abdelrahman): When the queue is full, the front and back indices should // always be the same @@ -84,25 +84,25 @@ GenericQueue *_queue_push_alloc(const Allocator *allocator, GenericQueue *queue, output->count = queue->count; } - _queue_push(output, item, item_size); + _queuePush(output, item, item_size); RETURN_QUEUE_PUSH_ALLOC: return output; } -void *_queue_pop(GenericQueue *queue, u64 item_size) { - wapp_debug_assert(queue != NULL, "`queue` should not be NULL"); - wapp_runtime_assert(item_size == wapp_array_item_size(queue->items), "Invalid type"); +void *_queuePop(WpQueue *queue, u64 item_size) { + wpDebugAssert(queue != NULL, "`queue` should not be NULL"); + wpRuntimeAssert(item_size == wpArrayItemSize(queue->items), "Invalid type"); if (queue->count == 0) { return NULL; } u64 index = (queue->front)++; --(queue->count); - u64 capacity = wapp_array_capacity(queue->items); + u64 capacity = wpArrayCapacity(queue->items); if (queue->front >= capacity) { queue->front = 0; } - return _array_get(queue->items, index, item_size); + return _arrayGet(queue->items, index, item_size); } diff --git a/src/base/queue/queue.h b/src/base/queue/queue.h index 6e84ef2..f04cf29 100644 --- a/src/base/queue/queue.h +++ b/src/base/queue/queue.h @@ -8,42 +8,42 @@ #include "../../common/aliases/aliases.h" #include "../../common/platform/platform.h" -#ifdef WAPP_PLATFORM_CPP +#ifdef WP_PLATFORM_CPP BEGIN_C_LINKAGE -#endif // !WAPP_PLATFORM_CPP +#endif // !WP_PLATFORM_CPP typedef struct { - GenericArray items; + WpArray items; u64 front; u64 back; u64 count; -} GenericQueue; +} WpQueue; -// NOTE (Abdelrahman): GenericQueue typedefs for readability -typedef GenericQueue VoidPtrQueue; -typedef GenericQueue C8Queue; -typedef GenericQueue C16Queue; -typedef GenericQueue C32Queue; -typedef GenericQueue U8Queue; -typedef GenericQueue U16Queue; -typedef GenericQueue U32Queue; -typedef GenericQueue U64Queue; -typedef GenericQueue B8Queue; -typedef GenericQueue I8Queue; -typedef GenericQueue I16Queue; -typedef GenericQueue I32Queue; -typedef GenericQueue I64Queue; -typedef GenericQueue F32Queue; -typedef GenericQueue F64Queue; -typedef GenericQueue F128Queue; -typedef GenericQueue UptrQueue; -typedef GenericQueue IptrQueue; -typedef GenericQueue Str8Queue; +// NOTE (Abdelrahman): WpQueue typedefs for readability +typedef WpQueue WpVoidPtrQueue; +typedef WpQueue WpC8Queue; +typedef WpQueue WpC16Queue; +typedef WpQueue WpC32Queue; +typedef WpQueue WpU8Queue; +typedef WpQueue WpU16Queue; +typedef WpQueue WpU32Queue; +typedef WpQueue WpU64Queue; +typedef WpQueue WpB8Queue; +typedef WpQueue WpI8Queue; +typedef WpQueue WpI16Queue; +typedef WpQueue WpI32Queue; +typedef WpQueue WpI64Queue; +typedef WpQueue WpF32Queue; +typedef WpQueue WpF64Queue; +typedef WpQueue WpF128Queue; +typedef WpQueue WpUptrQueue; +typedef WpQueue WpIptrQueue; +typedef WpQueue WpStr8Queue; -#ifdef WAPP_PLATFORM_CPP -#define wapp_queue(TYPE, CAPACITY) ([&]() { \ - wapp_persist GenericArray arr = wapp_array_with_capacity(TYPE, CAPACITY, ARRAY_INIT_FILLED); \ - wapp_persist GenericQueue queue = { \ +#ifdef WP_PLATFORM_CPP +#define wpQueue(TYPE, CAPACITY) ([&]() { \ + wp_persist WpArray arr = wpArrayWithCapacity(TYPE, CAPACITY, WP_ARRAY_INIT_FILLED); \ + wp_persist WpQueue queue = { \ arr, \ 0, \ 0, \ @@ -52,9 +52,9 @@ typedef GenericQueue Str8Queue; \ return queue; \ }()) -#define wapp_queue_alloc(TYPE, ALLOCATOR_PTR, CAPACITY) ([&]() { \ - wapp_persist GenericQueue queue = { \ - wapp_array_alloc_capacity(TYPE, ALLOCATOR_PTR, CAPACITY, ARRAY_INIT_FILLED), \ +#define wpQueueAlloc(TYPE, ALLOCATOR_PTR, CAPACITY) ([&]() { \ + wp_persist WpQueue queue = { \ + wpArrayAllocCapacity(TYPE, ALLOCATOR_PTR, CAPACITY, WP_ARRAY_INIT_FILLED), \ 0, \ 0, \ 0, \ @@ -63,38 +63,38 @@ typedef GenericQueue Str8Queue; return queue; \ }()) #else -#define wapp_queue(TYPE, CAPACITY) ((GenericQueue){ \ - .items = wapp_array_with_capacity(TYPE, CAPACITY, ARRAY_INIT_FILLED), \ +#define wpQueue(TYPE, CAPACITY) ((WpQueue){ \ + .items = wpArrayWithCapacity(TYPE, CAPACITY, WP_ARRAY_INIT_FILLED), \ .front = 0, \ .back = 0, \ .count = 0, \ }) -#define wapp_queue_alloc(TYPE, ALLOCATOR_PTR, CAPACITY) ((GenericQueue){ \ - .items = wapp_array_alloc_capacity(TYPE, ALLOCATOR_PTR, CAPACITY, ARRAY_INIT_FILLED), \ +#define wpQueueAlloc(TYPE, ALLOCATOR_PTR, CAPACITY) ((WpQueue){ \ + .items = wpArrayAllocCapacity(TYPE, ALLOCATOR_PTR, CAPACITY, WP_ARRAY_INIT_FILLED), \ .front = 0, \ .back = 0, \ .count = 0, \ }) -#endif // !WAPP_PLATFORM_CPP +#endif // !WP_PLATFORM_CPP -#define wapp_queue_capacity(QUEUE_PTR) (wapp_array_capacity((QUEUE_PTR)->items)) -#define wapp_queue_item_size(QUEUE_PTR) (wapp_array_item_size((QUEUE_PTR)->items)) -#define wapp_queue_push(TYPE, QUEUE_PTR, VALUE_PTR) ( \ - _queue_push(QUEUE_PTR, VALUE_PTR, sizeof(TYPE)) \ +#define wpQueueCapacity(QUEUE_PTR) (wpArrayCapacity((QUEUE_PTR)->items)) +#define wpQueueItemSize(QUEUE_PTR) (wpArrayItemSize((QUEUE_PTR)->items)) +#define wpQueuePush(TYPE, QUEUE_PTR, VALUE_PTR) ( \ + _queuePush(QUEUE_PTR, VALUE_PTR, sizeof(TYPE)) \ ) -#define wapp_queue_push_alloc(TYPE, ALLOCATOR_PTR, QUEUE_PTR, VALUE_PTR) ( \ - _queue_push_alloc(ALLOCATOR_PTR, QUEUE_PTR, VALUE_PTR, sizeof(TYPE)) \ +#define wpQueuePushAlloc(TYPE, ALLOCATOR_PTR, QUEUE_PTR, VALUE_PTR) ( \ + _queuePushAlloc(ALLOCATOR_PTR, QUEUE_PTR, VALUE_PTR, sizeof(TYPE)) \ ) -#define wapp_queue_pop(TYPE, QUEUE_PTR) ( \ - (TYPE *)_queue_pop(QUEUE_PTR, sizeof(TYPE)) \ +#define wpQueuePop(TYPE, QUEUE_PTR) ( \ + (TYPE *)_queuePop(QUEUE_PTR, sizeof(TYPE)) \ ) -void _queue_push(GenericQueue *queue, void *item, u64 item_size); -GenericQueue *_queue_push_alloc(const Allocator *allocator, GenericQueue *queue, void *item, u64 item_size); -void *_queue_pop(GenericQueue *queue, u64 item_size); +void _queuePush(WpQueue *queue, void *item, u64 item_size); +WpQueue *_queuePushAlloc(const WpAllocator *allocator, WpQueue *queue, void *item, u64 item_size); +void *_queuePop(WpQueue *queue, u64 item_size); -#ifdef WAPP_PLATFORM_CPP +#ifdef WP_PLATFORM_CPP END_C_LINKAGE -#endif // !WAPP_PLATFORM_CPP +#endif // !WP_PLATFORM_CPP #endif // !QUEUE_H diff --git a/src/base/strings/str8/str8.c b/src/base/strings/str8/str8.c index d9b6694..a1e36da 100644 --- a/src/base/strings/str8/str8.c +++ b/src/base/strings/str8/str8.c @@ -11,17 +11,17 @@ #include #include -#define STR8_BUF_ALLOC_SIZE(CAPACITY) (sizeof(Str8) + sizeof(c8) * CAPACITY) +#define STR8_BUF_ALLOC_SIZE(CAPACITY) (sizeof(WpStr8) + sizeof(c8) * CAPACITY) -Str8 *wapp_str8_alloc_buf(const Allocator *allocator, u64 capacity) { - wapp_debug_assert(allocator != NULL, "`allocator` should not be NULL"); +WpStr8 *wpStr8AllocBuf(const WpAllocator *allocator, u64 capacity) { + wpDebugAssert(allocator != NULL, "`allocator` should not be NULL"); - Str8 *str = wapp_mem_allocator_alloc(allocator, STR8_BUF_ALLOC_SIZE(capacity)); + WpStr8 *str = wpMemAllocatorAlloc(allocator, STR8_BUF_ALLOC_SIZE(capacity)); if (!str) { goto RETURN_STR8; } - str->buf = (u8 *)str + sizeof(Str8); + str->buf = (u8 *)str + sizeof(WpStr8); str->size = 0; str->capacity = capacity; @@ -29,8 +29,8 @@ RETURN_STR8: return str; } -Str8 *wapp_str8_alloc_and_fill_buf(const Allocator *allocator, u64 capacity) { - Str8 *out = wapp_str8_alloc_buf(allocator, capacity); +WpStr8 *wpStr8AllocAndFillBuf(const WpAllocator *allocator, u64 capacity) { + WpStr8 *out = wpStr8AllocBuf(allocator, capacity); if (out) { memset(out->buf, 0, capacity); out->size = capacity; @@ -38,11 +38,11 @@ Str8 *wapp_str8_alloc_and_fill_buf(const Allocator *allocator, u64 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"); +WpStr8 *wpStr8AllocCstr(const WpAllocator *allocator, const char *str) { + wpDebugAssert(allocator != NULL && str != NULL, "`allocator` and `str` should not be NULL"); u64 length = strlen(str); - Str8 *output = wapp_str8_alloc_buf(allocator, length * 2); + WpStr8 *output = wpStr8AllocBuf(allocator, length * 2); if (!output) { goto RETURN_ALLOC_CSTR; } @@ -54,10 +54,10 @@ RETURN_ALLOC_CSTR: 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"); +WpStr8 *wpStr8AllocStr8(const WpAllocator *allocator, WpStr8RO *str) { + wpDebugAssert(allocator != NULL && str != NULL, "`allocator` and `str` should not be NULL"); - Str8 *output = wapp_str8_alloc_buf(allocator, str->capacity); + WpStr8 *output = wpStr8AllocBuf(allocator, str->capacity); if (!output) { goto RETURN_ALLOC_STR8; } @@ -69,10 +69,10 @@ RETURN_ALLOC_STR8: 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"); +WpStr8 *wpStr8AllocSubstr(const WpAllocator *allocator, WpStr8RO *str, u64 start, u64 end) { + wpDebugAssert(allocator != NULL && str != NULL, "`allocator` and `str` should not be NULL"); - Str8 *output = NULL; + WpStr8 *output = NULL; if (start >= str->size || start >= end) { goto RETURN_ALLOC_SUBSTR; @@ -82,7 +82,7 @@ Str8 *wapp_str8_alloc_substr(const Allocator *allocator, Str8RO *str, u64 start, end = str->size; } - output = wapp_str8_alloc_buf(allocator, str->capacity); + output = wpStr8AllocBuf(allocator, str->capacity); if (!output) { goto RETURN_ALLOC_SUBSTR; } @@ -94,12 +94,12 @@ RETURN_ALLOC_SUBSTR: 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)); +void wpStr8DeallocBuf(const WpAllocator *allocator, WpStr8 **str) { + wpDebugAssert(allocator != NULL && str != NULL && (*str) != NULL, "Either `allocator` is NULL or `str` is an invalid double pointer"); + wpMemAllocatorFree(allocator, (void **)str, STR8_BUF_ALLOC_SIZE((*str)->capacity)); } -c8 wapp_str8_get(const Str8 *str, u64 index) { +c8 wpStr8Get(const WpStr8 *str, u64 index) { if (index >= str->size) { return '\0'; } @@ -107,7 +107,7 @@ c8 wapp_str8_get(const Str8 *str, u64 index) { return str->buf[index]; } -void wapp_str8_set(Str8 *str, u64 index, c8 c) { +void wpStr8Set(WpStr8 *str, u64 index, c8 c) { if (index >= str->size) { return; } @@ -115,24 +115,24 @@ void wapp_str8_set(Str8 *str, u64 index, c8 c) { str->buf[index] = c; } -void wapp_str8_push_back(Str8 *str, c8 c) { +void wpStr8PushBack(WpStr8 *str, c8 c) { if (!(str->size < str->capacity)) { return; } u64 index = (str->size)++; - wapp_str8_set(str, index, c); + wpStr8Set(str, index, c); } -b8 wapp_str8_equal(Str8RO *s1, Str8RO *s2) { +b8 wpStr8Equal(WpStr8RO *s1, WpStr8RO *s2) { if (s1->size != s2->size) { return false; } - return wapp_str8_equal_to_count(s1, s2, s1->size); + return wpStr8EqualToCount(s1, s2, s1->size); } -b8 wapp_str8_equal_to_count(Str8RO* s1, Str8RO* s2, u64 count) { +b8 wpStr8EqualToCount(WpStr8RO* s1, WpStr8RO* s2, u64 count) { if (!s1 || !s2) { return false; } @@ -140,7 +140,7 @@ b8 wapp_str8_equal_to_count(Str8RO* s1, Str8RO* s2, u64 count) { return memcmp(s1->buf, s2->buf, count) == 0; } -Str8 wapp_str8_slice(Str8RO *str, u64 start, u64 end) { +WpStr8 wpStr8Slice(WpStr8RO *str, u64 start, u64 end) { if (start >= str->size || start >= end) { start = str->size; end = str->size; @@ -150,17 +150,17 @@ Str8 wapp_str8_slice(Str8RO *str, u64 start, u64 end) { end = str->size; } - return (Str8RO){ + return (WpStr8RO){ .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"); +WpStr8 *wpStr8AllocConcat(const WpAllocator *allocator, WpStr8 *dst, WpStr8RO *src) { + wpDebugAssert(allocator != NULL && dst != NULL && src != NULL, "`allocator`, `dst` and `src` should not be NULL"); - Str8 *output = NULL; + WpStr8 *output = NULL; u64 remaining = dst->capacity - dst->size; if (src->size <= remaining) { output = dst; @@ -169,22 +169,22 @@ Str8 *wapp_str8_alloc_concat(const Allocator *allocator, Str8 *dst, Str8RO *src) u64 capacity = dst->capacity + src->size; - output = wapp_str8_alloc_buf(allocator, capacity); + output = wpStr8AllocBuf(allocator, capacity); if (!output) { goto RETURN_STR8_CONCAT; } - wapp_str8_concat_capped(output, dst); + wpStr8ConcatCapped(output, dst); SOURCE_STRING_STR8_CONCAT: - wapp_str8_concat_capped(output, src); + wpStr8ConcatCapped(output, src); RETURN_STR8_CONCAT: 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"); +void wpStr8ConcatCapped(WpStr8 *dst, WpStr8RO *src) { + wpDebugAssert(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; @@ -193,8 +193,8 @@ void wapp_str8_concat_capped(Str8 *dst, Str8RO *src) { 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"); +void wpStr8CopyCstrCapped(WpStr8 *dst, const char *src) { + wpDebugAssert(dst != NULL && src != NULL, "`dst` and `src` should not be NULL"); u64 length = strlen(src); u64 to_copy = length <= dst->capacity ? length : dst->capacity; @@ -204,8 +204,8 @@ void wapp_str8_copy_cstr_capped(Str8 *dst, const char *src) { 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"); +void wpStr8CopyStr8Capped(WpStr8 *dst, WpStr8RO *src) { + wpDebugAssert(dst != NULL && src != NULL, "`dst` and `src` should not be NULL"); u64 to_copy = src->size <= dst->capacity ? src->size : dst->capacity; @@ -214,8 +214,8 @@ void wapp_str8_copy_str8_capped(Str8 *dst, Str8RO *src) { 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"); +void wpStr8CopyToCstr(char *dst, WpStr8RO *src, u64 dst_capacity) { + wpDebugAssert(dst != NULL && src != NULL, "`dst` and `src` should not be NULL"); u64 to_copy = src->size < dst_capacity ? src->size : dst_capacity - 1; @@ -223,8 +223,8 @@ void wapp_str8_copy_to_cstr(char *dst, Str8RO *src, u64 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"); +void wpStr8Format(WpStr8 *dst, const char *format, ...) { + wpDebugAssert(dst != NULL && format != NULL, "`dst` and `format` should not be NULL"); va_list args1; va_list args2; @@ -241,9 +241,9 @@ void wapp_str8_format(Str8 *dst, const char *format, ...) { va_end(args2); } -void wapp_str8_to_lower(Str8 *dst, Str8RO *src) { - wapp_debug_assert(src != NULL && dst != NULL, "`dst` and `src` should not be NULL"); - wapp_debug_assert(dst->capacity >= src->capacity, "`dst` does not have enough capacity"); +void wpStr8ToLower(WpStr8 *dst, WpStr8RO *src) { + wpDebugAssert(src != NULL && dst != NULL, "`dst` and `src` should not be NULL"); + wpDebugAssert(dst->capacity >= src->capacity, "`dst` does not have enough capacity"); dst->size = src->size; @@ -252,15 +252,15 @@ void wapp_str8_to_lower(Str8 *dst, Str8RO *src) { u64 index = 0; b8 running = true; while (running) { - wapp_str8_set(dst, index, (u8)tolower(wapp_str8_get(src, index))); + wpStr8Set(dst, index, (u8)tolower(wpStr8Get(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"); +void wpStr8ToUpper(WpStr8 *dst, WpStr8RO *src) { + wpDebugAssert(src != NULL && dst != NULL, "`dst` and `src` should not be NULL"); + wpDebugAssert(dst->capacity >= src->capacity, "`dst` does not have enough capacity"); dst->size = src->size; @@ -269,24 +269,24 @@ void wapp_str8_to_upper(Str8 *dst, Str8RO *src) { u64 index = 0; b8 running = true; while (running) { - wapp_str8_set(dst, index, (u8)toupper(wapp_str8_get(src, index))); + wpStr8Set(dst, index, (u8)toupper(wpStr8Get(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"); +void wpStr8FromBytes(WpStr8 *dst, const WpU8Array src) { + wpDebugAssert(src != NULL && dst != NULL, "`dst` and `src` should not be NULL"); - u64 size = wapp_array_count(src) * wapp_array_item_size(src); + u64 size = wpArrayCount(src) * wpArrayItemSize(src); - wapp_debug_assert(dst->capacity >= size, "`dst` does not have enough capacity"); + wpDebugAssert(dst->capacity >= size, "`dst` does not have enough capacity"); dst->size = size; memcpy(dst->buf, src, size); } -i64 wapp_str8_find(Str8RO *str, Str8RO substr) { +i64 wpStr8Find(WpStr8RO *str, WpStr8RO substr) { if (!str || substr.size > str->size) { return -1; } @@ -308,7 +308,7 @@ i64 wapp_str8_find(Str8RO *str, Str8RO substr) { return -1; } -i64 wapp_str8_rfind(Str8RO *str, Str8RO substr) { +i64 wpStr8Rfind(WpStr8RO *str, WpStr8RO substr) { if (!str || substr.size > str->size) { return -1; } @@ -330,15 +330,15 @@ i64 wapp_str8_rfind(Str8RO *str, Str8RO substr) { 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"); +WpStr8List *wpStr8SplitWithMax(const WpAllocator *allocator, WpStr8RO *str, WpStr8RO *delimiter, i64 max_splits) { + wpDebugAssert(allocator != NULL && str != NULL && delimiter != NULL, "`allocator`, `str` and `delimiter` should not be NULL"); - Str8List *output = wapp_dbl_list_alloc(Str8, allocator); + WpStr8List *output = wpDblListAlloc(WpStr8, allocator); if (delimiter->size > str->size) { - Str8 *full = wapp_str8_alloc_str8(allocator, str); + WpStr8 *full = wpStr8AllocStr8(allocator, str); if (full) { - wapp_dbl_list_push_back_alloc(Str8, allocator, output, full); + wpDblListPushBackAlloc(WpStr8, allocator, output, full); } goto RETURN_STR8_SPLIT; @@ -347,45 +347,45 @@ Str8List *wapp_str8_split_with_max(const Allocator *allocator, Str8RO *str, Str8 i64 start = 0; i64 end = 0; i64 splits = 0; - Str8 *rest = wapp_str8_alloc_str8(allocator, str); - Str8 *before_str; + WpStr8 *rest = wpStr8AllocStr8(allocator, str); + WpStr8 *before_str; - while ((end = wapp_str8_find(rest, *delimiter)) != -1) { + while ((end = wpStr8Find(rest, *delimiter)) != -1) { if (max_splits > 0 && splits >= max_splits) { break; } - before_str = wapp_str8_alloc_substr(allocator, str, start, start + end); + before_str = wpStr8AllocSubstr(allocator, str, start, start + end); if (before_str) { - wapp_dbl_list_push_back_alloc(Str8, allocator, output, before_str); + wpDblListPushBackAlloc(WpStr8, allocator, output, before_str); } - wapp_mem_allocator_free(allocator, (void **)&rest, sizeof(Str8)); - rest = wapp_str8_alloc_substr(allocator, str, start + end + delimiter->size, str->size); + wpMemAllocatorFree(allocator, (void **)&rest, sizeof(WpStr8)); + rest = wpStr8AllocSubstr(allocator, str, start + end + delimiter->size, str->size); start += end + delimiter->size; ++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); + rest = wpStr8AllocSubstr(allocator, str, start, str->size); if (rest) { - wapp_dbl_list_push_back_alloc(Str8, allocator, output, rest); + wpDblListPushBackAlloc(WpStr8, allocator, output, rest); } RETURN_STR8_SPLIT: 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"); +WpStr8List *wpStr8RsplitWithMax(const WpAllocator *allocator, WpStr8RO *str, WpStr8RO *delimiter, i64 max_splits) { + wpDebugAssert(allocator != NULL && str != NULL && delimiter != NULL, "`allocator`, `str` and `delimiter` should not be NULL"); - Str8List *output = wapp_dbl_list_alloc(Str8, allocator); + WpStr8List *output = wpDblListAlloc(WpStr8, allocator); if (delimiter->size > str->size) { - Str8 *full = wapp_str8_alloc_str8(allocator, str); + WpStr8 *full = wpStr8AllocStr8(allocator, str); if (full) { - wapp_dbl_list_push_back_alloc(Str8, allocator, output, full); + wpDblListPushBackAlloc(WpStr8, allocator, output, full); } goto RETURN_STR8_SPLIT; @@ -393,58 +393,58 @@ Str8List *wapp_str8_rsplit_with_max(const Allocator *allocator, Str8RO *str, Str i64 end = 0; i64 splits = 0; - Str8 *rest = wapp_str8_alloc_str8(allocator, str); - Str8 *after_str; + WpStr8 *rest = wpStr8AllocStr8(allocator, str); + WpStr8 *after_str; - while ((end = wapp_str8_rfind(rest, *delimiter)) != -1) { + while ((end = wpStr8Rfind(rest, *delimiter)) != -1) { if (max_splits > 0 && splits >= max_splits) { break; } - after_str = wapp_str8_alloc_substr(allocator, rest, end + delimiter->size, str->size); + after_str = wpStr8AllocSubstr(allocator, rest, end + delimiter->size, str->size); if (after_str) { - wapp_dbl_list_push_front_alloc(Str8, allocator, output, after_str); + wpDblListPushFrontAlloc(WpStr8, allocator, output, after_str); } - wapp_mem_allocator_free(allocator, (void **)&rest, sizeof(Str8)); - rest = wapp_str8_alloc_substr(allocator, rest, 0, end); + wpMemAllocatorFree(allocator, (void **)&rest, sizeof(WpStr8)); + rest = wpStr8AllocSubstr(allocator, rest, 0, end); ++splits; } - rest = wapp_str8_alloc_substr(allocator, str, 0, rest->size); + rest = wpStr8AllocSubstr(allocator, str, 0, rest->size); if (rest) { - wapp_dbl_list_push_front_alloc(Str8, allocator, output, rest); + wpDblListPushFrontAlloc(WpStr8, allocator, output, rest); } RETURN_STR8_SPLIT: 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"); +WpStr8 *wpStr8Join(const WpAllocator *allocator, const WpStr8List *list, WpStr8RO *delimiter) { + wpDebugAssert(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 = wpStr8ListTotalSize(list) + (delimiter->size * (list->node_count - 1)); + WpStr8 *output = wpStr8AllocBuf(allocator, capacity * 2); // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of // MSVC Spectre mitigation warnings - Str8 *node; + WpStr8 *node; u64 node_index = 0; b8 running = node_index < list->node_count; while (running) { - node = wapp_dbl_list_get(Str8, list, node_index); + node = wpDblListGet(WpStr8, list, node_index); if (!node) { break; } - wapp_str8_concat_capped(output, node); + wpStr8ConcatCapped(output, node); // 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); + wpStr8ConcatCapped(output, delimiter); } ++node_index; @@ -454,19 +454,19 @@ Str8 *wapp_str8_join(const Allocator *allocator, const Str8List *list, Str8RO *d return output; } -u64 wapp_str8_list_total_size(const Str8List *list) { +u64 wpStr8ListTotalSize(const WpStr8List *list) { if (!list) { return 0; } // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of // MSVC Spectre mitigation warnings - Str8 *node; + WpStr8 *node; u64 node_index = 0; u64 output = 0; b8 running = node_index < list->node_count; while (running) { - node = wapp_dbl_list_get(Str8, list, node_index); + node = wpDblListGet(WpStr8, list, node_index); if (!node) { break; } diff --git a/src/base/strings/str8/str8.h b/src/base/strings/str8/str8.h index 1ae83e6..e3c1ef0 100644 --- a/src/base/strings/str8/str8.h +++ b/src/base/strings/str8/str8.h @@ -11,120 +11,120 @@ #include "../../mem/allocator/mem_allocator.h" #include -#ifdef WAPP_PLATFORM_CPP +#ifdef WP_PLATFORM_CPP BEGIN_C_LINKAGE -#endif // !WAPP_PLATFORM_CPP +#endif // !WP_PLATFORM_CPP -typedef struct Str8 Str8; -struct Str8 { +typedef struct WpStr8 WpStr8; +struct WpStr8 { u64 capacity; u64 size; c8 *buf; }; -typedef const Str8 Str8RO; +typedef const WpStr8 WpStr8RO; /** * Utilities to be used with printf functions */ -#define WAPP_STR8_SPEC "%.*s" -#define wapp_str8_varg(STRING) (int)((STRING).size), (STRING).buf +#define WP_STR8_SPEC "%.*s" +#define wpStr8Varg(STRING) (int)((STRING).size), (STRING).buf /** - * Str8 stack buffers + * WpStr8 stack buffers */ -#ifdef WAPP_PLATFORM_CPP +#ifdef WP_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 wpStr8Buf(CAPACITY) ([&](){ \ + wp_persist c8 buf[CAPACITY] = {}; \ + memset(buf, 0, CAPACITY); \ + return WpStr8{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 wpStr8Lit(STRING) ([&]() { \ + wp_persist c8 buf[sizeof(STRING) * 2] = {}; \ + memcpy(buf, STRING, sizeof(STRING)); \ + return WpStr8{(sizeof(STRING) - 1) * 2, sizeof(STRING) - 1, buf}; \ }()) -#define wapp_str8_lit_ro(STRING) Str8RO{sizeof(STRING) - 1, sizeof(STRING) - 1, (c8 *)STRING} -#define wapp_str8_lit_ro_initialiser_list(STRING) {sizeof(STRING) - 1, sizeof(STRING) - 1, (c8 *)STRING} +#define wpStr8LitRo(STRING) WpStr8RO{sizeof(STRING) - 1, sizeof(STRING) - 1, (c8 *)STRING} +#define wpStr8LitRoInitialiserList(STRING) {sizeof(STRING) - 1, sizeof(STRING) - 1, (c8 *)STRING} #else -#define wapp_str8_buf(CAPACITY) ((Str8){.capacity = CAPACITY, .size = 0, .buf = (c8[CAPACITY]){0}}) +#define wpStr8Buf(CAPACITY) ((WpStr8){.capacity = CAPACITY, .size = 0, .buf = (c8[CAPACITY]){0}}) // 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, \ +#define wpStr8Lit(STRING) ((WpStr8){.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, \ +#define wpStr8LitRo(STRING) ((WpStr8RO){.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, \ +// initialisers with the syntax of wpStr8LitRo (e.g. gcc). Should only be used when necessary +// and only be assigned to a WpStr8RO variable to avoid any attempt at modifying the string +#define wpStr8LitRoInitialiserList(STRING) {.capacity = sizeof(STRING) - 1, \ + .size = sizeof(STRING) - 1, \ .buf = (c8 *)STRING} -#endif // !WAPP_PLATFORM_CPP +#endif // !WP_PLATFORM_CPP /** - * Str8 allocated buffers + * WpStr8 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); +WpStr8 *wpStr8AllocBuf(const WpAllocator *allocator, u64 capacity); +WpStr8 *wpStr8AllocAndFillBuf(const WpAllocator *allocator, u64 capacity); +WpStr8 *wpStr8AllocCstr(const WpAllocator *allocator, const char *str); +WpStr8 *wpStr8AllocStr8(const WpAllocator *allocator, WpStr8RO *str); +WpStr8 *wpStr8AllocSubstr(const WpAllocator *allocator, WpStr8RO *str, u64 start, u64 end); +WpStr8 *wpStr8AllocConcat(const WpAllocator *allocator, WpStr8 *dst, WpStr8RO *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); +void wpStr8DeallocBuf(const WpAllocator *allocator, WpStr8 **str); /** - * Str8 utilities + * WpStr8 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 wpStr8Get(WpStr8RO *str, u64 index); +void wpStr8Set(WpStr8 *str, u64 index, c8 c); +void wpStr8PushBack(WpStr8 *str, c8 c); +b8 wpStr8Equal(WpStr8RO *s1, WpStr8RO *s2); +b8 wpStr8EqualToCount(WpStr8RO* s1, WpStr8RO* s2, u64 count); +WpStr8 wpStr8Slice(WpStr8RO *str, u64 start, u64 end); +void wpStr8ConcatCapped(WpStr8 *dst, WpStr8RO *src); +void wpStr8CopyCstrCapped(WpStr8 *dst, const char *src); +void wpStr8CopyStr8Capped(WpStr8 *dst, WpStr8RO *src); +void wpStr8CopyToCstr(char *dst, WpStr8RO *src, u64 dst_capacity); +void wpStr8Format(WpStr8 *dst, const char *format, ...); +void wpStr8ToLower(WpStr8 *dst, WpStr8RO *src); +void wpStr8ToUpper(WpStr8 *dst, WpStr8RO *src); +void wpStr8FromBytes(WpStr8 *dst, const WpU8Array src); /** - * Str8 find functions + * WpStr8 find functions */ -i64 wapp_str8_find(Str8RO *str, Str8RO substr); -i64 wapp_str8_rfind(Str8RO *str, Str8RO substr); +i64 wpStr8Find(WpStr8RO *str, WpStr8RO substr); +i64 wpStr8Rfind(WpStr8RO *str, WpStr8RO substr); /** - * Str8 split and join + * WpStr8 split and join */ -#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); +#define wpStr8Split(ALLOCATOR, STR, DELIMITER) wpStr8SplitWithMax(ALLOCATOR, STR, DELIMITER, -1) +#define wpStr8Rsplit(ALLOCATOR, STR, DELIMITER) wpStr8RsplitWithMax(ALLOCATOR, STR, DELIMITER, -1) +WpStr8List *wpStr8SplitWithMax(const WpAllocator *allocator, WpStr8RO *str, WpStr8RO *delimiter, i64 max_splits); +WpStr8List *wpStr8RsplitWithMax(const WpAllocator *allocator, WpStr8RO *str, WpStr8RO *delimiter, i64 max_splits); +WpStr8 *wpStr8Join(const WpAllocator *allocator, const WpStr8List *list, WpStr8RO *delimiter); /** - * Str8 list utilities + * WpStr8 list utilities */ -u64 wapp_str8_list_total_size(const Str8List *list); +u64 wpStr8ListTotalSize(const WpStr8List *list); -#ifdef WAPP_PLATFORM_CPP +#ifdef WP_PLATFORM_CPP END_C_LINKAGE -#endif // !WAPP_PLATFORM_CPP +#endif // !WP_PLATFORM_CPP #endif // !STR8_H diff --git a/src/common/aliases/aliases.h b/src/common/aliases/aliases.h index b51b135..01d52c0 100644 --- a/src/common/aliases/aliases.h +++ b/src/common/aliases/aliases.h @@ -6,14 +6,14 @@ #include "../platform/platform.h" #include -#if defined(WAPP_PLATFORM_C) && WAPP_PLATFORM_C_VERSION >= WAPP_PLATFORM_C11_VERSION && !defined(WAPP_PLATFORM_APPLE) +#if defined(WP_PLATFORM_C) && WP_PLATFORM_C_VERSION >= WP_PLATFORM_C11_VERSION && !defined(WP_PLATFORM_APPLE) #include - #if WAPP_PLATFORM_C_VERSION >= WAPP_PLATFORM_C23_VERSION + #if WP_PLATFORM_C_VERSION >= WP_PLATFORM_C23_VERSION typedef char8_t c8; #else typedef uint8_t c8; - #endif // !WAPP_PLATFORM_C23_VERSION + #endif // !WP_PLATFORM_C23_VERSION typedef char16_t c16; typedef char32_t c32; @@ -21,7 +21,7 @@ typedef uint8_t c8; typedef uint16_t c16; typedef uint32_t c32; -#endif // !WAPP_PLATFORM_C +#endif // !WP_PLATFORM_C typedef uint8_t u8; typedef uint16_t u16; @@ -30,7 +30,7 @@ typedef uint64_t u64; typedef uint8_t b8; -#ifndef WAPP_PLATFORM_CPP +#ifndef WP_PLATFORM_CPP #ifndef false #define false (b8)0 @@ -40,7 +40,7 @@ typedef uint8_t b8; #define true (b8)1 #endif // !true -#endif // !WAPP_PLATFORM_CPP +#endif // !WP_PLATFORM_CPP typedef int8_t i8; typedef int16_t i16; @@ -54,14 +54,14 @@ typedef long double f128; typedef uintptr_t uptr; typedef intptr_t iptr; -#define wapp_extern extern -#define wapp_intern static -#define wapp_persist static +#define wp_extern extern +#define wp_intern static +#define wp_persist static -#ifdef WAPP_PLATFORM_CPP -#define wapp_class_mem static -#define BEGIN_C_LINKAGE wapp_extern "C" { +#ifdef WP_PLATFORM_CPP +#define wp_class_mem static +#define BEGIN_C_LINKAGE wp_extern "C" { #define END_C_LINKAGE } -#endif // WAPP_PLATFORM_CPP +#endif // WP_PLATFORM_CPP #endif // !ALIASES_H diff --git a/src/common/assert/assert.h b/src/common/assert/assert.h index e7ffb3c..ab062b6 100644 --- a/src/common/assert/assert.h +++ b/src/common/assert/assert.h @@ -9,42 +9,42 @@ #include #include -#ifdef WAPP_PLATFORM_CPP +#ifdef WP_PLATFORM_CPP BEGIN_C_LINKAGE -#endif // !WAPP_PLATFORM_CPP +#endif // !WP_PLATFORM_CPP -#define wapp_static_assert(EXPR, MSG) wapp_extern char ASSERTION_FAILED[EXPR ? 1 : -1] +#define wpStaticAssert(EXPR, MSG) wp_extern char ASSERTION_FAILED[EXPR ? 1 : -1] -#ifndef WAPP_NO_RUNTIME_ASSERT - #define wapp_runtime_assert(EXPR, MSG) __wapp_runtime_assert(EXPR, MSG) +#ifndef WP_NO_RUNTIME_ASSERT + #define wpRuntimeAssert(EXPR, MSG) _runtimeAssert(EXPR, MSG) #else - #define wapp_runtime_assert(EXPR, MSG) + #define wpRuntimeAssert(EXPR, MSG) #endif -#ifdef WAPP_DEBUG_ASSERT - #define wapp_debug_assert(EXPR, MSG) wapp_runtime_assert(EXPR, MSG) +#ifdef WP_DEBUG_ASSERT + #define wpDebugAssert(EXPR, MSG) wpRuntimeAssert(EXPR, MSG) #else - #define wapp_debug_assert(EXPR, MSG) + #define wpDebugAssert(EXPR, MSG) #endif -#ifdef WAPP_PLATFORM_WINDOWS -#define __wapp_runtime_assert(EXPR, MSG) do { \ +#ifdef WP_PLATFORM_WINDOWS +#define _runtimeAssert(EXPR, MSG) do { \ __pragma(warning(push)) \ __pragma(warning(disable:4127)) \ if (!(EXPR)) { \ __pragma(warning(pop)) \ - __runtime_assert_failed(EXPR, MSG); \ + _runtimeAssertFailed(EXPR, MSG); \ } \ } while(false) #else -#define __wapp_runtime_assert(EXPR, MSG) do { \ +#define _runtimeAssert(EXPR, MSG) do { \ if (!(EXPR)) { \ - __runtime_assert_failed(EXPR, MSG); \ + _runtimeAssertFailed(EXPR, MSG); \ } \ } while(false) -#endif // !WAPP_PLATFORM_WINDOWS +#endif // !WP_PLATFORM_WINDOWS -#define __runtime_assert_failed(EXPR, MSG) do { \ +#define _runtimeAssertFailed(EXPR, MSG) do { \ fprintf( \ stderr, \ "%s:%d (In function `%s`): Assertion failed (%" PRIu32 ")\nDiagnostic: %s\n\n", \ @@ -54,8 +54,8 @@ BEGIN_C_LINKAGE abort(); \ } while(false) -#ifdef WAPP_PLATFORM_CPP +#ifdef WP_PLATFORM_CPP END_C_LINKAGE -#endif // !WAPP_PLATFORM_CPP +#endif // !WP_PLATFORM_CPP #endif // !WAPP_ASSERT_H diff --git a/src/common/misc/misc_utils.h b/src/common/misc/misc_utils.h index 6608fe8..1b9f34f 100644 --- a/src/common/misc/misc_utils.h +++ b/src/common/misc/misc_utils.h @@ -5,9 +5,9 @@ #include "../aliases/aliases.h" -#ifdef WAPP_PLATFORM_CPP +#ifdef WP_PLATFORM_CPP BEGIN_C_LINKAGE -#endif // !WAPP_PLATFORM_CPP +#endif // !WP_PLATFORM_CPP #define KiB(SIZE) (((u64)SIZE) << 10) #define MiB(SIZE) (((u64)SIZE) << 20) @@ -23,7 +23,7 @@ BEGIN_C_LINKAGE #define PB(SIZE) (TB(SIZE) * 1000llu) #define EB(SIZE) (PB(SIZE) * 1000llu) -#define wapp_misc_utils_reserve_padding(SIZE) u8 reserved_padding[sizeof(void *) - ((SIZE) % sizeof(void *))] +#define wpMiscUtilsReservePadding(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)) @@ -31,7 +31,7 @@ BEGIN_C_LINKAGE #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) ( \ +#define wpMiscUtilsU64RoundUpPow2(X) ( \ ( \ U64_RSHIFT_OR_32( \ U64_RSHIFT_OR_16( \ @@ -47,17 +47,17 @@ BEGIN_C_LINKAGE ) + 1 \ ) -#define wapp_is_power_of_two(NUM) ((NUM & (NUM - 1)) == 0) -#define wapp_pointer_offset(PTR, OFFSET) ((void *)((uptr)(PTR) + (OFFSET))) +#define wpMiscUtilsIsPowerOfTwo(NUM) ((NUM & (NUM - 1)) == 0) +#define wpMiscUtilsOffsetPointer(PTR, OFFSET) ((void *)((uptr)(PTR) + (OFFSET))) -#ifdef WAPP_PLATFORM_CPP +#ifdef WP_PLATFORM_CPP END_C_LINKAGE #include -#define wapp_misc_utils_va_args_count(T, ...) (std::tuple_size::value) +#define wpMiscUtilsVaArgsCount(T, ...) (std::tuple_size::value) #else -#define wapp_misc_utils_va_args_count(T, ...) (sizeof((T[]){__VA_ARGS__})/sizeof(T)) -#endif // !WAPP_PLATFORM_CPP +#define wpMiscUtilsVaArgsCount(T, ...) (sizeof((T[]){__VA_ARGS__})/sizeof(T)) +#endif // !WP_PLATFORM_CPP #endif // !MISC_UTILS_H diff --git a/src/common/platform/platform.h b/src/common/platform/platform.h index 907b696..a73fd8f 100644 --- a/src/common/platform/platform.h +++ b/src/common/platform/platform.h @@ -4,110 +4,110 @@ #define PLATFORM_H #if defined(__ANDROID__) - #define WAPP_PLATFORM_ANDROID - #define WAPP_PLATFORM_POSIX + #define WP_PLATFORM_ANDROID + #define WP_PLATFORM_POSIX #elif defined(__FreeBSD__) - #define WAPP_PLATFORM_FREE_BSD - #define WAPP_PLATFORM_BSD - #define WAPP_PLATFORM_POSIX + #define WP_PLATFORM_FREE_BSD + #define WP_PLATFORM_BSD + #define WP_PLATFORM_POSIX #elif defined(__NetBSD__) - #define WAPP_PLATFORM_NET_BSD - #define WAPP_PLATFORM_BSD - #define WAPP_PLATFORM_POSIX + #define WP_PLATFORM_NET_BSD + #define WP_PLATFORM_BSD + #define WP_PLATFORM_POSIX #elif defined(__OpenBSD__) - #define WAPP_PLATFORM_OPEN_BSD - #define WAPP_PLATFORM_BSD - #define WAPP_PLATFORM_POSIX + #define WP_PLATFORM_OPEN_BSD + #define WP_PLATFORM_BSD + #define WP_PLATFORM_POSIX #elif defined(__DragonFly__) - #define WAPP_PLATFORM_DRAGON_FLY - #define WAPP_PLATFORM_BSD - #define WAPP_PLATFORM_POSIX + #define WP_PLATFORM_DRAGON_FLY + #define WP_PLATFORM_BSD + #define WP_PLATFORM_POSIX #elif defined(__bsdi__) - #define WAPP_PLATFORM_BSD - #define WAPP_PLATFORM_POSIX + #define WP_PLATFORM_BSD + #define WP_PLATFORM_POSIX #elif defined(__linux__) || defined(linux) || defined(__linux) || defined(__gnu_linux__) - #define WAPP_PLATFORM_LINUX - #define WAPP_PLATFORM_POSIX + #define WP_PLATFORM_LINUX + #define WP_PLATFORM_POSIX #elif defined(__GNU__) || defined(__gnu_hurd__) - #define WAPP_PLATFORM_GNU - #define WAPP_PLATFORM_POSIX + #define WP_PLATFORM_GNU + #define WP_PLATFORM_POSIX #elif defined(__APPLE__) || defined(__MACH__) #include #if TARGET_OS_IPHONE - #define WAPP_PLATFORM_IOS - #define WAPP_PLATFORM_APPLE - #define WAPP_PLATFORM_POSIX + #define WP_PLATFORM_IOS + #define WP_PLATFORM_APPLE + #define WP_PLATFORM_POSIX #elif TARGET_OS_MAC - #define WAPP_PLATFORM_MACOS - #define WAPP_PLATFORM_APPLE - #define WAPP_PLATFORM_POSIX + #define WP_PLATFORM_MACOS + #define WP_PLATFORM_APPLE + #define WP_PLATFORM_POSIX #else #error "Unrecognised Apple platform" #endif #elif defined(_WIN64) - #define WAPP_PLATFORM_WINDOWS64 - #define WAPP_PLATFORM_WINDOWS + #define WP_PLATFORM_WINDOWS64 + #define WP_PLATFORM_WINDOWS #elif defined(_WIN32) - #define WAPP_PLATFORM_WINDOWS32 - #define WAPP_PLATFORM_WINDOWS + #define WP_PLATFORM_WINDOWS32 + #define WP_PLATFORM_WINDOWS #elif defined(__CYGWIN__) - #define WAPP_PLATFORM_CYGWIN - #define WAPP_PLATFORM_WINDOWS + #define WP_PLATFORM_CYGWIN + #define WP_PLATFORM_WINDOWS #elif defined(__unix__) || defined(__unix) - #define WAPP_PLATFORM_UNIX - #define WAPP_PLATFORM_POSIX + #define WP_PLATFORM_UNIX + #define WP_PLATFORM_POSIX #else #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 WP_PLATFORM_CPP + #define WP_PLATFORM_CPP_VERSION __cplusplus + #define WP_PLATFORM_CPP98_VERSION 199711L + #define WP_PLATFORM_CPP11_VERSION 201103L + #define WP_PLATFORM_CPP14_VERSION 201402L + #define WP_PLATFORM_CPP17_VERSION 201703L + #define WP_PLATFORM_CPP20_VERSION 202002L + #define WP_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 + #if WP_PLATFORM_CPP_VERSION == WP_PLATFORM_CPP98_VERSION + #define WP_PLATFORM_CPP98 + #elif WP_PLATFORM_CPP_VERSION == WP_PLATFORM_CPP11_VERSION + #define WP_PLATFORM_CPP11 + #elif WP_PLATFORM_CPP_VERSION == WP_PLATFORM_CPP14_VERSION + #define WP_PLATFORM_CPP14 + #elif WP_PLATFORM_CPP_VERSION == WP_PLATFORM_CPP17_VERSION + #define WP_PLATFORM_CPP17 + #elif WP_PLATFORM_CPP_VERSION == WP_PLATFORM_CPP20_VERSION + #define WP_PLATFORM_CPP20 + #elif WP_PLATFORM_CPP_VERSION == WP_PLATFORM_CPP23_VERSION + #define WP_PLATFORM_CPP23 #else #error "Unrecognised C++ version" #endif #else - #define WAPP_PLATFORM_C + #define WP_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 + #define WP_PLATFORM_C_VERSION __STDC_VERSION__ + #define WP_PLATFORM_C99_VERSION 199901L + #define WP_PLATFORM_C11_VERSION 201112L + #define WP_PLATFORM_C17_VERSION 201710L + #define WP_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 + #if WP_PLATFORM_C_VERSION == WP_PLATFORM_C99_VERSION + #define WP_PLATFORM_C99 + #elif WP_PLATFORM_C_VERSION == WP_PLATFORM_C11_VERSION + #define WP_PLATFORM_C11 + #elif WP_PLATFORM_C_VERSION == WP_PLATFORM_C17_VERSION + #define WP_PLATFORM_C17 + #elif WP_PLATFORM_C_VERSION == WP_PLATFORM_C23_VERSION + #define WP_PLATFORM_C23 #else #error "Unrecognised C version" #endif #else - #define WAPP_PLATFORM_C89 + #define WP_PLATFORM_C89 #endif #endif // !__cplusplus diff --git a/src/log/log.c b/src/log/log.c index 0ef1b4b..4026c60 100644 --- a/src/log/log.c +++ b/src/log/log.c @@ -11,115 +11,115 @@ #define MIN_LOG_MSG_LENGTH 32 #define TIME_BUF_CAPACITY 70 -wapp_intern Str8RO L_BRACKET = wapp_str8_lit_ro("["); -wapp_intern Str8RO R_BRACKET_SPACE = wapp_str8_lit_ro("] "); -wapp_intern Str8RO R_BRACKET_NEWLINE = wapp_str8_lit_ro("]\n"); +wp_intern WpStr8RO L_BRACKET = wpStr8LitRo("["); +wp_intern WpStr8RO R_BRACKET_SPACE = wpStr8LitRo("] "); +wp_intern WpStr8RO R_BRACKET_NEWLINE = wpStr8LitRo("]\n"); typedef struct { - WFile *outlog; - WFile *errlog; - LogLevel level; + WpFile *outlog; + WpFile *errlog; + WpLogLevel level; - wapp_misc_utils_reserve_padding(2 * sizeof(WFile *) + sizeof(LogLevel)); + wpMiscUtilsReservePadding(2 * sizeof(WpFile *) + sizeof(WpLogLevel)); } LogConfig; -wapp_intern LogConfig LOG_CONFIG = { - .level = WAPP_LOG_DEBUG, +wp_intern LogConfig LOG_CONFIG = { + .level = WP_LOG_LEVEL_DEBUG, }; -wapp_intern Str8RO LOG_LEVEL_STRINGS[COUNT_LOG_LEVEL] = { - [WAPP_LOG_FATAL] = wapp_str8_lit_ro_initialiser_list("fatal "), - [WAPP_LOG_CRITICAL] = wapp_str8_lit_ro_initialiser_list("critical "), - [WAPP_LOG_ERROR] = wapp_str8_lit_ro_initialiser_list("error "), - [WAPP_LOG_WARNING] = wapp_str8_lit_ro_initialiser_list("warning "), - [WAPP_LOG_INFO] = wapp_str8_lit_ro_initialiser_list("info "), - [WAPP_LOG_DEBUG] = wapp_str8_lit_ro_initialiser_list("debug "), +wp_intern WpStr8RO LOG_LEVEL_STRINGS[COUNT_LOG_LEVEL] = { + [WP_LOG_LEVEL_FATAL] = wpStr8LitRoInitialiserList("fatal "), + [WP_LOG_LEVEL_CRITICAL] = wpStr8LitRoInitialiserList("critical "), + [WP_LOG_LEVEL_ERROR] = wpStr8LitRoInitialiserList("error "), + [WP_LOG_LEVEL_WARNING] = wpStr8LitRoInitialiserList("warning "), + [WP_LOG_LEVEL_INFO] = wpStr8LitRoInitialiserList("info "), + [WP_LOG_LEVEL_DEBUG] = wpStr8LitRoInitialiserList("debug "), }; -wapp_intern void _get_current_time_string(Str8 *dst); -wapp_intern void _write_log_line(WFile *fp, const Logger *logger, Str8 msg, LogLevel level); +wp_intern void _get_current_time_string(WpStr8 *dst); +wp_intern void _write_log_line(WpFile *fp, const WpLogger *logger, WpStr8 msg, WpLogLevel level); -void wapp_log_set_level(LogLevel level) { +void wpLogSetLevel(WpLogLevel level) { LOG_CONFIG.level = level; } -void wapp_log_configure(WFile *outlog, WFile *errlog, LogLevel level) { +void wpLogConfigure(WpFile *outlog, WpFile *errlog, WpLogLevel level) { LOG_CONFIG.outlog = outlog; LOG_CONFIG.errlog = errlog; LOG_CONFIG.level = level; } -Logger wapp_log_make_logger(Str8 name) { - return (Logger){ .name = name }; +WpLogger wpLogMakeLogger(WpStr8 name) { + return (WpLogger){ .name = name }; } -void wapp_log_debug(const Logger *logger, Str8 msg) { - wapp_debug_assert(logger != NULL, "`logger` should not be NULL"); - if (LOG_CONFIG.level < WAPP_LOG_DEBUG) { return; } +void wpLogDebug(const WpLogger *logger, WpStr8 msg) { + wpDebugAssert(logger != NULL, "`logger` should not be NULL"); + if (LOG_CONFIG.level < WP_LOG_LEVEL_DEBUG) { return; } - WFile *fp = LOG_CONFIG.outlog != NULL ? LOG_CONFIG.outlog : wapp_file_stdout(); - _write_log_line(fp, logger, msg, WAPP_LOG_DEBUG); + WpFile *fp = LOG_CONFIG.outlog != NULL ? LOG_CONFIG.outlog : wpFileStdout(); + _write_log_line(fp, logger, msg, WP_LOG_LEVEL_DEBUG); } -void wapp_log_info(const Logger *logger, Str8 msg) { - wapp_debug_assert(logger != NULL, "`logger` should not be NULL"); - if (LOG_CONFIG.level < WAPP_LOG_INFO) { return; } +void wpLogInfo(const WpLogger *logger, WpStr8 msg) { + wpDebugAssert(logger != NULL, "`logger` should not be NULL"); + if (LOG_CONFIG.level < WP_LOG_LEVEL_INFO) { return; } - WFile *fp = LOG_CONFIG.outlog != NULL ? LOG_CONFIG.outlog : wapp_file_stdout(); - _write_log_line(fp, logger, msg, WAPP_LOG_INFO); + WpFile *fp = LOG_CONFIG.outlog != NULL ? LOG_CONFIG.outlog : wpFileStdout(); + _write_log_line(fp, logger, msg, WP_LOG_LEVEL_INFO); } -void wapp_log_warning(const Logger *logger, Str8 msg) { - wapp_debug_assert(logger != NULL, "`logger` should not be NULL"); - if (LOG_CONFIG.level < WAPP_LOG_WARNING) { return; } +void wpLogWarning(const WpLogger *logger, WpStr8 msg) { + wpDebugAssert(logger != NULL, "`logger` should not be NULL"); + if (LOG_CONFIG.level < WP_LOG_LEVEL_WARNING) { return; } - WFile *fp = LOG_CONFIG.outlog != NULL ? LOG_CONFIG.outlog : wapp_file_stdout(); - _write_log_line(fp, logger, msg, WAPP_LOG_WARNING); + WpFile *fp = LOG_CONFIG.outlog != NULL ? LOG_CONFIG.outlog : wpFileStdout(); + _write_log_line(fp, logger, msg, WP_LOG_LEVEL_WARNING); } -void wapp_log_error(const Logger *logger, Str8 msg) { - wapp_debug_assert(logger != NULL, "`logger` should not be NULL"); - if (LOG_CONFIG.level < WAPP_LOG_ERROR) { return; } +void wpLogError(const WpLogger *logger, WpStr8 msg) { + wpDebugAssert(logger != NULL, "`logger` should not be NULL"); + if (LOG_CONFIG.level < WP_LOG_LEVEL_ERROR) { return; } - WFile *fp = LOG_CONFIG.errlog != NULL ? LOG_CONFIG.errlog : wapp_file_stderr(); - _write_log_line(fp, logger, msg, WAPP_LOG_ERROR); + WpFile *fp = LOG_CONFIG.errlog != NULL ? LOG_CONFIG.errlog : wpFileStderr(); + _write_log_line(fp, logger, msg, WP_LOG_LEVEL_ERROR); } -void wapp_log_critical(const Logger *logger, Str8 msg) { - wapp_debug_assert(logger != NULL, "`logger` should not be NULL"); - if (LOG_CONFIG.level < WAPP_LOG_CRITICAL) { return; } +void wpLogCritical(const WpLogger *logger, WpStr8 msg) { + wpDebugAssert(logger != NULL, "`logger` should not be NULL"); + if (LOG_CONFIG.level < WP_LOG_LEVEL_CRITICAL) { return; } - WFile *fp = LOG_CONFIG.errlog != NULL ? LOG_CONFIG.errlog : wapp_file_stderr(); - _write_log_line(fp, logger, msg, WAPP_LOG_CRITICAL); + WpFile *fp = LOG_CONFIG.errlog != NULL ? LOG_CONFIG.errlog : wpFileStderr(); + _write_log_line(fp, logger, msg, WP_LOG_LEVEL_CRITICAL); } -void wapp_log_fatal(const Logger *logger, Str8 msg) { - wapp_debug_assert(logger != NULL, "`logger` should not be NULL"); - if (LOG_CONFIG.level < WAPP_LOG_FATAL) { return; } +void wpLogFatal(const WpLogger *logger, WpStr8 msg) { + wpDebugAssert(logger != NULL, "`logger` should not be NULL"); + if (LOG_CONFIG.level < WP_LOG_LEVEL_FATAL) { return; } - WFile *fp = LOG_CONFIG.errlog != NULL ? LOG_CONFIG.errlog : wapp_file_stderr(); - _write_log_line(fp, logger, msg, WAPP_LOG_FATAL); + WpFile *fp = LOG_CONFIG.errlog != NULL ? LOG_CONFIG.errlog : wpFileStderr(); + _write_log_line(fp, logger, msg, WP_LOG_LEVEL_FATAL); } -wapp_intern void _get_current_time_string(Str8 *dst) { +wp_intern void _get_current_time_string(WpStr8 *dst) { // TODO (Abdelrahman): Replace with proper date/time utilities char buf[TIME_BUF_CAPACITY]; time_t now = time(NULL); struct tm utc; gmtime_r(&now, &utc); strftime(buf, sizeof(buf), "%FT%TZ ", &utc); - wapp_str8_copy_cstr_capped(dst, buf); + wpStr8CopyCstrCapped(dst, buf); } -wapp_intern void _write_log_line(WFile *fp, const Logger *logger, Str8 msg, LogLevel level) { - Str8 padding = wapp_str8_buf(MIN_LOG_MSG_LENGTH); +wp_intern void _write_log_line(WpFile *fp, const WpLogger *logger, WpStr8 msg, WpLogLevel level) { + WpStr8 padding = wpStr8Buf(MIN_LOG_MSG_LENGTH); u32 padding_size = msg.size < MIN_LOG_MSG_LENGTH ? MIN_LOG_MSG_LENGTH - msg.size + 1 : 0; - wapp_str8_format(&padding, "%-*s", padding_size, " "); + wpStr8Format(&padding, "%-*s", padding_size, " "); - Str8 time_str = wapp_str8_buf(TIME_BUF_CAPACITY); + WpStr8 time_str = wpStr8Buf(TIME_BUF_CAPACITY); _get_current_time_string(&time_str); - Str8RO **strings = wapp_array( - Str8RO *, + WpStr8RO **strings = wpArray( + WpStr8RO *, &time_str, &L_BRACKET, &LOG_LEVEL_STRINGS[level], @@ -131,7 +131,7 @@ wapp_intern void _write_log_line(WFile *fp, const Logger *logger, Str8 msg, LogL &R_BRACKET_NEWLINE ); - for (u64 i = 0; i < wapp_array_count(strings); ++i) { - wapp_file_write_str8(strings[i], fp); + for (u64 i = 0; i < wpArrayCount(strings); ++i) { + wpFileWriteStr8(strings[i], fp); } } diff --git a/src/log/log.h b/src/log/log.h index f6605d1..3a4dbb0 100644 --- a/src/log/log.h +++ b/src/log/log.h @@ -7,28 +7,28 @@ #include "../base/strings/str8/str8.h" typedef enum { - WAPP_LOG_FATAL, - WAPP_LOG_CRITICAL, - WAPP_LOG_ERROR, - WAPP_LOG_WARNING, - WAPP_LOG_INFO, - WAPP_LOG_DEBUG, + WP_LOG_LEVEL_FATAL, + WP_LOG_LEVEL_CRITICAL, + WP_LOG_LEVEL_ERROR, + WP_LOG_LEVEL_WARNING, + WP_LOG_LEVEL_INFO, + WP_LOG_LEVEL_DEBUG, COUNT_LOG_LEVEL, -} LogLevel; +} WpLogLevel; typedef struct { - Str8 name; -} Logger; + WpStr8 name; +} WpLogger; -void wapp_log_set_level(LogLevel level); -void wapp_log_configure(WFile *outlog, WFile *errlog, LogLevel level); -Logger wapp_log_make_logger(Str8 name); -void wapp_log_debug(const Logger *logger, Str8 msg); -void wapp_log_info(const Logger *logger, Str8 msg); -void wapp_log_warning(const Logger *logger, Str8 msg); -void wapp_log_error(const Logger *logger, Str8 msg); -void wapp_log_critical(const Logger *logger, Str8 msg); -void wapp_log_fatal(const Logger *logger, Str8 msg); +void wpLogSetLevel(WpLogLevel level); +void wpLogConfigure(WpFile *outlog, WpFile *errlog, WpLogLevel level); +WpLogger wpLogMakeLogger(WpStr8 name); +void wpLogDebug(const WpLogger *logger, WpStr8 msg); +void wpLogInfo(const WpLogger *logger, WpStr8 msg); +void wpLogWarning(const WpLogger *logger, WpStr8 msg); +void wpLogError(const WpLogger *logger, WpStr8 msg); +void wpLogCritical(const WpLogger *logger, WpStr8 msg); +void wpLogFatal(const WpLogger *logger, WpStr8 msg); #endif // !LOG_H diff --git a/src/oldnames.h b/src/oldnames.h new file mode 100644 index 0000000..1cb59bf --- /dev/null +++ b/src/oldnames.h @@ -0,0 +1,597 @@ +// vim:fileencoding=utf-8:foldmethod=marker +// +// oldnames.h — backward-compatible #define mappings for renames in the +// wizapp-stdlib naming-conventions branch. +// +// Every public API symbol that was renamed is mapped from its old name to +// its new name so that existing code continues to compile without changes. +// +// Rename patterns applied across all modules: +// wapp_xxx() → wpXxx() +// WAPP_XXX → WP_XXX +// GenericXxx → WpXxx +// SHELL_XXX → WP_SHELL_XXX +// _xxx_yyy() → _xxxYyy() +// +// Sections: Constants → Types → Functions + +#ifndef OLDNAMES_H +#define OLDNAMES_H + +// ============================================================================ +// ===== Constants ===== +// ============================================================================ + +// --- Aliases --- + +#define WAPP_PLATFORM_CPP WP_PLATFORM_CPP +#define WAPP_PLATFORM_C WP_PLATFORM_C + +// --- Arena --- + +#define WAPP_MEM_ALLOC_RESERVE WP_MEM_ALLOC_RESERVE +#define WAPP_MEM_ALLOC_COMMIT WP_MEM_ALLOC_COMMIT + +// --- Array --- + +#define WAPP_ARRAY_MAGIC WP_ARRAY_MAGIC +#define ARRAY_INIT_NONE WP_ARRAY_INIT_NONE +#define ARRAY_INIT_FILLED WP_ARRAY_INIT_FILLED + +// --- Assert --- + +#define WAPP_NO_RUNTIME_ASSERT WP_NO_RUNTIME_ASSERT +#define WAPP_DEBUG_ASSERT WP_DEBUG_ASSERT + +// --- CPath --- + +#define WAPP_PATH_SEP WP_PATH_SEP +#define WAPP_PATH_MAX WP_PATH_MAX + +#define CPATH_JOIN_SUCCESS WP_CPATH_JOIN_RESULT_SUCCESS +#define CPATH_JOIN_INVALID_ARGS WP_CPATH_JOIN_RESULT_INVALID_ARGS +#define CPATH_JOIN_EMPTY_PARTS WP_CPATH_JOIN_RESULT_EMPTY_PARTS +#define CPATH_JOIN_INSUFFICIENT_DST_CAPACITY WP_CPATH_JOIN_RESULT_INSUFFICIENT_DST_CAPACITY + +// --- DblList --- + +#define WAPP_DBL_LIST_MAGIC WP_DBL_LIST_MAGIC +#define WAPP_DBL_NODE_MAGIC WP_DBL_NODE_MAGIC + +// --- File --- + +#define WAPP_ACCESS_READ WP_ACCESS_READ +#define WAPP_ACCESS_WRITE WP_ACCESS_WRITE +#define WAPP_ACCESS_APPEND WP_ACCESS_APPEND +#define WAPP_ACCESS_READ_EX WP_ACCESS_READ_EX +#define WAPP_ACCESS_WRITE_EX WP_ACCESS_WRITE_EX +#define WAPP_ACCESS_APPEND_EX WP_ACCESS_APPEND_EX +#define WAPP_ACCESS_WRITE_FAIL_ON_EXIST WP_ACCESS_WRITE_FAIL_ON_EXIST +#define WAPP_ACCESS_WRITE_FAIL_ON_EXIST_EX WP_ACCESS_WRITE_FAIL_ON_EXIST_EX +#define WAPP_SEEK_START WP_SEEK_START +#define WAPP_SEEK_CURRENT WP_SEEK_CURRENT +#define WAPP_SEEK_END WP_SEEK_END +#define END_OF_LINE WP_END_OF_LINE + +// --- Log --- + +#define WAPP_LOG_FATAL WP_LOG_LEVEL_FATAL +#define WAPP_LOG_CRITICAL WP_LOG_LEVEL_CRITICAL +#define WAPP_LOG_ERROR WP_LOG_LEVEL_ERROR +#define WAPP_LOG_WARNING WP_LOG_LEVEL_WARNING +#define WAPP_LOG_INFO WP_LOG_LEVEL_INFO +#define WAPP_LOG_DEBUG WP_LOG_LEVEL_DEBUG + +// --- Mem Os --- + +#define WAPP_MEM_ACCESS_NONE WP_MEM_ACCESS_NONE +#define WAPP_MEM_ACCESS_READ_ONLY WP_MEM_ACCESS_READ_ONLY +#define WAPP_MEM_ACCESS_EXEC_ONLY WP_MEM_ACCESS_EXEC_ONLY +#define WAPP_MEM_ACCESS_READ_WRITE WP_MEM_ACCESS_READ_WRITE +#define WAPP_MEM_ACCESS_READ_EXEC WP_MEM_ACCESS_READ_EXEC +#define WAPP_MEM_ACCESS_READ_WRITE_EXEC WP_MEM_ACCESS_READ_WRITE_EXEC +#define WAPP_MEM_INIT_UNINITIALISED WP_MEM_INIT_UNINITIALISED +#define WAPP_MEM_INIT_INITIALISED WP_MEM_INIT_INITIALISED + +// --- Platform --- + +#define WAPP_PLATFORM_ANDROID WP_PLATFORM_ANDROID +#define WAPP_PLATFORM_FREE_BSD WP_PLATFORM_FREE_BSD +#define WAPP_PLATFORM_NET_BSD WP_PLATFORM_NET_BSD +#define WAPP_PLATFORM_OPEN_BSD WP_PLATFORM_OPEN_BSD +#define WAPP_PLATFORM_DRAGON_FLY WP_PLATFORM_DRAGON_FLY +#define WAPP_PLATFORM_BSD WP_PLATFORM_BSD +#define WAPP_PLATFORM_POSIX WP_PLATFORM_POSIX +#define WAPP_PLATFORM_LINUX WP_PLATFORM_LINUX +#define WAPP_PLATFORM_GNU WP_PLATFORM_GNU +#define WAPP_PLATFORM_IOS WP_PLATFORM_IOS +#define WAPP_PLATFORM_APPLE WP_PLATFORM_APPLE +#define WAPP_PLATFORM_MACOS WP_PLATFORM_MACOS +#define WAPP_PLATFORM_WINDOWS64 WP_PLATFORM_WINDOWS64 +#define WAPP_PLATFORM_WINDOWS32 WP_PLATFORM_WINDOWS32 +#define WAPP_PLATFORM_WINDOWS WP_PLATFORM_WINDOWS +#define WAPP_PLATFORM_CYGWIN WP_PLATFORM_CYGWIN +#define WAPP_PLATFORM_UNIX WP_PLATFORM_UNIX +#define WAPP_PLATFORM_CPP_VERSION WP_PLATFORM_CPP_VERSION +#define WAPP_PLATFORM_CPP98_VERSION WP_PLATFORM_CPP98_VERSION +#define WAPP_PLATFORM_CPP11_VERSION WP_PLATFORM_CPP11_VERSION +#define WAPP_PLATFORM_CPP14_VERSION WP_PLATFORM_CPP14_VERSION +#define WAPP_PLATFORM_CPP17_VERSION WP_PLATFORM_CPP17_VERSION +#define WAPP_PLATFORM_CPP20_VERSION WP_PLATFORM_CPP20_VERSION +#define WAPP_PLATFORM_CPP23_VERSION WP_PLATFORM_CPP23_VERSION +#define WAPP_PLATFORM_CPP98 WP_PLATFORM_CPP98 +#define WAPP_PLATFORM_CPP11 WP_PLATFORM_CPP11 +#define WAPP_PLATFORM_CPP14 WP_PLATFORM_CPP14 +#define WAPP_PLATFORM_CPP17 WP_PLATFORM_CPP17 +#define WAPP_PLATFORM_CPP20 WP_PLATFORM_CPP20 +#define WAPP_PLATFORM_CPP23 WP_PLATFORM_CPP23 +#define WAPP_PLATFORM_C_VERSION WP_PLATFORM_C_VERSION +#define WAPP_PLATFORM_C99_VERSION WP_PLATFORM_C99_VERSION +#define WAPP_PLATFORM_C11_VERSION WP_PLATFORM_C11_VERSION +#define WAPP_PLATFORM_C17_VERSION WP_PLATFORM_C17_VERSION +#define WAPP_PLATFORM_C23_VERSION WP_PLATFORM_C23_VERSION +#define WAPP_PLATFORM_C99 WP_PLATFORM_C99 +#define WAPP_PLATFORM_C11 WP_PLATFORM_C11 +#define WAPP_PLATFORM_C17 WP_PLATFORM_C17 +#define WAPP_PLATFORM_C23 WP_PLATFORM_C23 +#define WAPP_PLATFORM_C89 WP_PLATFORM_C89 + +// --- Shell Commander --- + +#define SHELL_OUTPUT_DISCARD WP_SHELL_OUTPUT_DISCARD +#define SHELL_OUTPUT_PRINT WP_SHELL_OUTPUT_PRINT +#define SHELL_OUTPUT_CAPTURE WP_SHELL_OUTPUT_CAPTURE +#define SHELL_ERR_NO_ERROR WP_SHELL_ERR_NO_ERROR +#define SHELL_ERR_INVALID_ARGS WP_SHELL_ERR_INVALID_ARGS +#define SHELL_ERR_ALLOCATION_FAIL WP_SHELL_ERR_ALLOCATION_FAIL +#define SHELL_ERR_PROC_START_FAIL WP_SHELL_ERR_PROC_START_FAIL +#define SHELL_ERR_OUT_BUF_FULL WP_SHELL_ERR_OUT_BUF_FULL +#define SHELL_ERR_PROC_EXIT_FAIL WP_SHELL_ERR_PROC_EXIT_FAIL + +// --- Shell Termcolour --- + +#define WAPP_TERM_COLOUR_FG_BLACK WP_TERM_COLOUR_FG_BLACK +#define WAPP_TERM_COLOUR_FG_RED WP_TERM_COLOUR_FG_RED +#define WAPP_TERM_COLOUR_FG_GREEN WP_TERM_COLOUR_FG_GREEN +#define WAPP_TERM_COLOUR_FG_BLUE WP_TERM_COLOUR_FG_BLUE +#define WAPP_TERM_COLOUR_FG_CYAN WP_TERM_COLOUR_FG_CYAN +#define WAPP_TERM_COLOUR_FG_MAGENTA WP_TERM_COLOUR_FG_MAGENTA +#define WAPP_TERM_COLOUR_FG_YELLOW WP_TERM_COLOUR_FG_YELLOW +#define WAPP_TERM_COLOUR_FG_WHITE WP_TERM_COLOUR_FG_WHITE +#define WAPP_TERM_COLOUR_FG_BR_BLACK WP_TERM_COLOUR_FG_BR_BLACK +#define WAPP_TERM_COLOUR_FG_BR_RED WP_TERM_COLOUR_FG_BR_RED +#define WAPP_TERM_COLOUR_FG_BR_GREEN WP_TERM_COLOUR_FG_BR_GREEN +#define WAPP_TERM_COLOUR_FG_BR_BLUE WP_TERM_COLOUR_FG_BR_BLUE +#define WAPP_TERM_COLOUR_FG_BR_CYAN WP_TERM_COLOUR_FG_BR_CYAN +#define WAPP_TERM_COLOUR_FG_BR_MAGENTA WP_TERM_COLOUR_FG_BR_MAGENTA +#define WAPP_TERM_COLOUR_FG_BR_YELLOW WP_TERM_COLOUR_FG_BR_YELLOW +#define WAPP_TERM_COLOUR_FG_BR_WHITE WP_TERM_COLOUR_FG_BR_WHITE +#define WAPP_TERM_COLOUR_CLEAR WP_TERM_COLOUR_CLEAR + +// --- Str8 --- + +#define WAPP_STR8_SPEC WP_STR8_SPEC + +// --- UUID --- + +#define UUID_BUF_LENGTH WP_UUID_BUF_LENGTH +#define WAPP_UUID_SPEC WP_UUID_SPEC + +// ============================================================================ +// ===== Types ===== +// ============================================================================ + +// --- Aliases --- + +#define wapp_extern wp_extern +#define wapp_intern wp_intern +#define wapp_persist wp_persist +#define wapp_class_mem wp_class_mem + +// --- Arena --- + +#define Arena WpArena + +// --- Array --- + +#define GenericArray WpArray +#define VoidPtrArray WpVoidPtrArray +#define C8Array WpC8Array +#define C16Array WpC16Array +#define C32Array WpC32Array +#define U8Array WpU8Array +#define U16Array WpU16Array +#define U32Array WpU32Array +#define U64Array WpU64Array +#define B8Array WpB8Array +#define I8Array WpI8Array +#define I16Array WpI16Array +#define I32Array WpI32Array +#define I64Array WpI64Array +#define F32Array WpF32Array +#define F64Array WpF64Array +#define F128Array WpF128Array +#define UptrArray WpUptrArray +#define IptrArray WpIptrArray +#define Str8Array WpStr8Array +#define ArrayHeader WpArrayHeader +#define ArrayInitFlags WpArrayInitFlags + +// --- DblList --- + +#define GenericNode WpDblNode +#define NodeHeader WpDblNodeHeader +#define GenericList WpDblList +#define VoidPtrList WpVoidPtrList +#define C8List WpC8List +#define C16List WpC16List +#define C32List WpC32List +#define U8List WpU8List +#define U16List WpU16List +#define U32List WpU32List +#define U64List WpU64List +#define B8List WpB8List +#define I8List WpI8List +#define I16List WpI16List +#define I32List WpI32List +#define I64List WpI64List +#define F32List WpF32List +#define F64List WpF64List +#define F128List WpF128List +#define UptrList WpUptrList +#define IptrList WpIptrList +#define Str8List WpStr8List +#define VoidPtrNode WpVoidPtrNode +#define C8Node WpC8Node +#define C16Node WpC16Node +#define C32Node WpC32Node +#define U8Node WpU8Node +#define U16Node WpU16Node +#define U32Node WpU32Node +#define U64Node WpU64Node +#define B8Node WpB8Node +#define I8Node WpI8Node +#define I16Node WpI16Node +#define I32Node WpI32Node +#define I64Node WpI64Node +#define F32Node WpF32Node +#define F64Node WpF64Node +#define F128Node WpF128Node +#define UptrNode WpUptrNode +#define IptrNode WpIptrNode +#define Str8Node WpStr8Node + +// --- File --- + +#define WFile WpFile +#define FileAccessMode WpFileAccessMode +#define FileSeekOrigin WpFileSeekOrigin + +// --- Log --- + +#define LogLevel WpLogLevel +#define Logger WpLogger + +// --- Mem Allocator --- + +#define Allocator WpAllocator +#define MemAllocFunc WpMemAllocFunc +#define MemAllocAlignedFunc WpMemAllocAlignedFunc +#define MemReallocFunc WpMemReallocFunc +#define MemReallocAlignedFunc WpMemReallocAlignedFunc +#define MemFreeFunc WpMemFreeFunc + +// --- Mem Os --- + +#define MemAccess WpMemAccess +#define MemInitType WpMemInitType +#define MemAllocFlags WpMemAllocFlags + +// --- PRNG Xorshift --- + +#define XOR256State WpXor256State + +// --- Queue --- + +#define GenericQueue WpQueue +#define VoidPtrQueue WpVoidPtrQueue +#define C8Queue WpC8Queue +#define C16Queue WpC16Queue +#define C32Queue WpC32Queue +#define U8Queue WpU8Queue +#define U16Queue WpU16Queue +#define U32Queue WpU32Queue +#define U64Queue WpU64Queue +#define B8Queue WpB8Queue +#define I8Queue WpI8Queue +#define I16Queue WpI16Queue +#define I32Queue WpI32Queue +#define I64Queue WpI64Queue +#define F32Queue WpF32Queue +#define F64Queue WpF64Queue +#define F128Queue WpF128Queue +#define UptrQueue WpUptrQueue +#define IptrQueue WpIptrQueue +#define Str8Queue WpStr8Queue + +// --- Shell Commander --- + +#define CMDResult WpCmdResult +#define CMDOutHandling WpCmdOutHandling +#define CMDError WpCmdError + +// --- Shell Termcolour --- + +#define TerminalColour WpTerminalColour + +// --- Str8 --- + +#define Str8 WpStr8 +#define Str8RO WpStr8RO + +// --- Tester --- + +#define TestFuncResult WpTestFuncResult +#define TestFunc WpTestFunc + +// --- UUID --- + +#define WUUID WpUuid + +// ============================================================================ +// ===== Functions ===== +// ============================================================================ + +// --- Arena --- + +#define wapp_mem_arena_init_allocated wpMemArenaInitAllocated +#define wapp_mem_arena_init_allocated_commit wpMemArenaInitAllocatedCommit +#define wapp_mem_arena_init_allocated_zero wpMemArenaInitAllocatedZero +#define wapp_mem_arena_init_allocated_commit_and_zero wpMemArenaInitAllocatedCommitAndZero +#define wapp_mem_arena_init_allocated_custom wpMemArenaInitAllocatedCustom +#define wapp_mem_arena_init_buffer wpMemArenaInitBuffer +#define wapp_mem_arena_alloc wpMemArenaAlloc +#define wapp_mem_arena_alloc_aligned wpMemArenaAllocAligned +#define wapp_mem_arena_realloc wpMemArenaRealloc +#define wapp_mem_arena_realloc_aligned wpMemArenaReallocAligned +#define wapp_mem_arena_temp_begin wpMemArenaTempBegin +#define wapp_mem_arena_temp_end wpMemArenaTempEnd +#define wapp_mem_arena_clear wpMemArenaClear +#define wapp_mem_arena_destroy wpMemArenaDestroy + +#define wapp_mem_arena_allocator_init wpMemArenaAllocatorInit +#define wapp_mem_arena_allocator_init_commit wpMemArenaAllocatorInitCommit +#define wapp_mem_arena_allocator_init_zero wpMemArenaAllocatorInitZero +#define wapp_mem_arena_allocator_init_commit_and_zero wpMemArenaAllocatorInitCommitAndZero +#define wapp_mem_arena_allocator_init_custom wpMemArenaAllocatorInitCustom +#define wapp_mem_arena_allocator_init_with_buffer wpMemArenaAllocatorInitWithBuffer +#define wapp_mem_arena_allocator_temp_begin wpMemArenaAllocatorTempBegin +#define wapp_mem_arena_allocator_temp_end wpMemArenaAllocatorTempEnd +#define wapp_mem_arena_allocator_clear wpMemArenaAllocatorClear +#define wapp_mem_arena_allocator_destroy wpMemArenaAllocatorDestroy + +// --- Array --- + +#define wapp_array wpArray +#define wapp_array_with_capacity wpArrayWithCapacity +#define wapp_array_pop wpArrayPop +#define wapp_array_count wpArrayCount +#define wapp_array_capacity wpArrayCapacity +#define wapp_array_item_size wpArrayItemSize +#define wapp_array_set_count wpArraySetCount +#define wapp_array_get wpArrayGet +#define wapp_array_set wpArraySet +#define wapp_array_append_capped wpArrayAppendCapped +#define wapp_array_extend_capped wpArrayExtendCapped +#define wapp_array_copy_capped wpArrayCopyCapped +#define wapp_array_append_alloc wpArrayAppendAlloc +#define wapp_array_extend_alloc wpArrayExtendAlloc +#define wapp_array_copy_alloc wpArrayCopyAlloc +#define wapp_array_clear wpArrayClear +#define wapp_array_calc_alloc_size wpArrayCalcAllocSize +#define wapp_array_alloc_capacity wpArrayAllocCapacity +#define wapp_array_from_preallcated_buffer wpArrayFromPreallcatedBuffer + +// --- Assert --- + +#define wapp_static_assert wpStaticAssert +#define wapp_runtime_assert wpRuntimeAssert +#define wapp_debug_assert wpDebugAssert + +// --- CPath --- + +#define wapp_cpath_dirname wpCpathDirname +#define wapp_cpath_dirup wpCpathDirup +#define wapp_cpath_join_path wpCpathJoinPath +#define dirup _dirup + +// --- DblList --- + +#define wapp_dbl_list wpDblList +#define wapp_dbl_list_alloc wpDblListAlloc +#define wapp_dbl_list_get wpDblListGet +#define wapp_dbl_list_get_node wpDblListGetNode +#define wapp_dbl_list_get_node_item wpDblListGetNodeItem +#define wapp_dbl_list_push_front wpDblListPushFront +#define wapp_dbl_list_push_back wpDblListPushBack +#define wapp_dbl_list_insert wpDblListInsert +#define wapp_dbl_list_push_front_alloc wpDblListPushFrontAlloc +#define wapp_dbl_list_push_back_alloc wpDblListPushBackAlloc +#define wapp_dbl_list_insert_alloc wpDblListInsertAlloc +#define wapp_dbl_list_pop_front wpDblListPopFront +#define wapp_dbl_list_pop_back wpDblListPopBack +#define wapp_dbl_list_remove wpDblListRemove +#define wapp_dbl_list_pop_front_node wpDblListPopFrontNode +#define wapp_dbl_list_pop_back_node wpDblListPopBackNode +#define wapp_dbl_list_remove_node wpDblListRemoveNode +#define wapp_dbl_list_empty wpDblListEmpty + +#define _dbl_list_alloc _dblListAlloc +#define _dbl_list_node_alloc _dblListNodeAlloc +#define _dbl_list_get _dblListGet +#define _dbl_list_push_front _dblListPushFront +#define _dbl_list_push_back _dblListPushBack +#define _dbl_list_insert _dblListInsert +#define _dbl_list_pop_front _dblListPopFront +#define _dbl_list_pop_back _dblListPopBack +#define _dbl_list_remove _dblListRemove +#define _dbl_list_empty _dblListEmpty + +// --- File --- + +#define wapp_file_stdin wpFileStdin +#define wapp_file_stdout wpFileStdout +#define wapp_file_stderr wpFileStderr +#define wapp_file_open wpFileOpen +#define wapp_file_get_current_position wpFileGetCurrentPosition +#define wapp_file_seek wpFileSeek +#define wapp_file_get_length wpFileGetLength +#define wapp_file_read wpFileRead +#define wapp_file_write wpFileWrite +#define wapp_file_read_str8 wpFileReadStr8 +#define wapp_file_write_str8 wpFileWriteStr8 +#define wapp_file_read_array wpFileReadArray +#define wapp_file_write_array wpFileWriteArray +#define wapp_file_flush wpFileFlush +#define wapp_file_close wpFileClose +#define wapp_file_rename wpFileRename +#define wapp_file_remove wpFileRemove + +#define _file_open _fileOpen +#define _file_seek _fileSeek +#define _file_read _fileRead +#define _file_write _fileWrite +#define _file_flush _fileFlush +#define _file_close _fileClose +#define _file_rename _fileRename +#define _file_remove _fileRemove + +// --- Log --- + +#define wapp_log_set_level wpLogSetLevel +#define wapp_log_configure wpLogConfigure +#define wapp_log_make_logger wpLogMakeLogger +#define wapp_log_debug wpLogDebug +#define wapp_log_info wpLogInfo +#define wapp_log_warning wpLogWarning +#define wapp_log_error wpLogError +#define wapp_log_critical wpLogCritical +#define wapp_log_fatal wpLogFatal + +// --- Mem Allocator --- + +#define wapp_mem_allocator_invalid wpMemAllocatorInvalid +#define wapp_mem_allocator_alloc wpMemAllocatorAlloc +#define wapp_mem_allocator_alloc_aligned wpMemAllocatorAllocAligned +#define wapp_mem_allocator_realloc wpMemAllocatorRealloc +#define wapp_mem_allocator_realloc_aligned wpMemAllocatorReallocAligned +#define wapp_mem_allocator_free wpMemAllocatorFree + +// --- Mem Os --- + +#define wapp_os_mem_alloc wpOsMemAlloc +#define wapp_os_mem_free wpOsMemFree +#define os_mem_allocate _osMemAllocate +#define os_mem_free _osMemFree + +// --- Mem Utils --- + +#define wapp_mem_util_align_forward wpMemUtilAlignForward + +// --- Misc Utils --- + +#define wapp_misc_utils_reserve_padding wpMiscUtilsReservePadding +#define wapp_misc_utils_u64_round_up_pow2 wpMiscUtilsU64RoundUpPow2 +#define wapp_is_power_of_two wpMiscUtilsIsPowerOfTwo +#define wapp_pointer_offset wpMiscUtilsOffsetPointer +#define wapp_misc_utils_va_args_count wpMiscUtilsVaArgsCount + +// --- PRNG Xorshift --- + +#define wapp_prng_xorshift_init_state wpPrngXorshiftInit +#define wapp_prng_xorshift_256 wpPrngXorshift256 +#define wapp_prng_xorshift_256ss wpPrngXorshift256ss +#define wapp_prng_xorshift_256p wpPrngXorshift256p + +// --- Queue --- + +#define wapp_queue wpQueue +#define wapp_queue_alloc wpQueueAlloc +#define wapp_queue_capacity wpQueueCapacity +#define wapp_queue_item_size wpQueueItemSize +#define wapp_queue_push wpQueuePush +#define wapp_queue_push_alloc wpQueuePushAlloc +#define wapp_queue_pop wpQueuePop + +#define _queue_push _queuePush +#define _queue_push_alloc _queuePushAlloc +#define _queue_pop _queuePop + +// --- Shell Commander --- + +#define CMD_NO_EXIT wpCmdNoExit +#define wapp_shell_commander_execute wpShellCommanderExecute +#define get_output_status _getOutputStatus + +// --- Shell Termcolour --- + +#define wapp_shell_termcolour_print_text wpShellTermcolourPrintText +#define wapp_shell_termcolour_clear_colour wpShellTermcolourClearColour +#define print_coloured_text _printColouredText + +// --- Shell Utils --- + +#define wapp_shell_utils_popen wpShellUtilsPopen +#define wapp_shell_utils_pclose wpShellUtilsPclose + +// --- Str8 --- + +#define wapp_str8_varg wpStr8Varg +#define wapp_str8_buf wpStr8Buf +#define wapp_str8_lit wpStr8Lit +#define wapp_str8_lit_ro wpStr8LitRo +#define wapp_str8_lit_ro_initialiser_list wpStr8LitRoInitialiserList +#define wapp_str8_alloc_buf wpStr8AllocBuf +#define wapp_str8_alloc_and_fill_buf wpStr8AllocAndFillBuf +#define wapp_str8_alloc_cstr wpStr8AllocCstr +#define wapp_str8_alloc_str8 wpStr8AllocStr8 +#define wapp_str8_alloc_substr wpStr8AllocSubstr +#define wapp_str8_alloc_concat wpStr8AllocConcat +#define wapp_str8_dealloc_buf wpStr8DeallocBuf +#define wapp_str8_get wpStr8Get +#define wapp_str8_set wpStr8Set +#define wapp_str8_push_back wpStr8PushBack +#define wapp_str8_equal wpStr8Equal +#define wapp_str8_equal_to_count wpStr8EqualToCount +#define wapp_str8_slice wpStr8Slice +#define wapp_str8_concat_capped wpStr8ConcatCapped +#define wapp_str8_copy_cstr_capped wpStr8CopyCstrCapped +#define wapp_str8_copy_str8_capped wpStr8CopyStr8Capped +#define wapp_str8_copy_to_cstr wpStr8CopyToCstr +#define wapp_str8_format wpStr8Format +#define wapp_str8_to_lower wpStr8ToLower +#define wapp_str8_to_upper wpStr8ToUpper +#define wapp_str8_from_bytes wpStr8FromBytes +#define wapp_str8_find wpStr8Find +#define wapp_str8_rfind wpStr8Rfind +#define wapp_str8_split wpStr8Split +#define wapp_str8_rsplit wpStr8Rsplit +#define wapp_str8_split_with_max wpStr8SplitWithMax +#define wapp_str8_rsplit_with_max wpStr8RsplitWithMax +#define wapp_str8_join wpStr8Join +#define wapp_str8_list_total_size wpStr8ListTotalSize + +// --- Tester --- + +#define wapp_tester_result wpTesterResult +#define wapp_tester_run wpTesterRun +#define run_tests _runTests + +// --- UUID --- + +#define wapp_uuid_varg wpUuidVarg +#define wapp_uuid_gen_uuid4 wpUuidGenUuid4 +#define wapp_uuid_create wpUuidCreate +#define wapp_uuid_init_uuid4 wpUuidInitUuid4 + +#endif // !OLDNAMES_H diff --git a/src/os/allocators/arena/mem_arena.c b/src/os/allocators/arena/mem_arena.c index 314dcb0..35f28c6 100644 --- a/src/os/allocators/arena/mem_arena.c +++ b/src/os/allocators/arena/mem_arena.c @@ -21,7 +21,7 @@ typedef enum { ARENA_STORAGE_TYPE_BUFFER, } ArenaStorageType; -struct Arena { +struct WpArena { u8 *buf; u8 *offset; u8 *prev_offset; @@ -29,99 +29,99 @@ struct Arena { ArenaStorageType type; b8 committed; - wapp_misc_utils_reserve_padding(sizeof(u8 *) * 3 + sizeof(u64) + sizeof(ArenaStorageType) + sizeof(b8)); + wpMiscUtilsReservePadding(sizeof(u8 *) * 3 + sizeof(u64) + sizeof(ArenaStorageType) + sizeof(b8)); }; -b8 wapp_mem_arena_init_buffer(Arena **arena, u8 *buffer, u64 buffer_size) { - if (!arena || *arena || buffer_size < sizeof(Arena)) { +b8 wpMemArenaInitBuffer(WpArena **arena, u8 *buffer, u64 buffer_size) { + if (!arena || *arena || buffer_size < sizeof(WpArena)) { return false; } - *arena = (Arena *)buffer; - Arena *arena_ptr = *arena; + *arena = (WpArena *)buffer; + WpArena *arena_ptr = *arena; arena_ptr->buf = (u8 *)(arena_ptr + 1); arena_ptr->offset = arena_ptr->buf; arena_ptr->prev_offset = NULL; - arena_ptr->capacity = buffer_size - sizeof(Arena); + arena_ptr->capacity = buffer_size - sizeof(WpArena); arena_ptr->type = ARENA_STORAGE_TYPE_BUFFER; arena_ptr->committed = true; return true; } -b8 wapp_mem_arena_init_allocated_custom(Arena **arena, u64 base_capacity, MemAllocFlags flags, b8 zero_buffer) { +b8 wpMemArenaInitAllocatedCustom(WpArena **arena, u64 base_capacity, WpMemAllocFlags flags, b8 zero_buffer) { if (!arena || *arena || base_capacity == 0) { return false; } - u64 size = sizeof(Arena) + (base_capacity >= ARENA_MINIMUM_CAPACITY ? base_capacity : ARENA_MINIMUM_CAPACITY); - u64 alloc_size = wapp_misc_utils_u64_round_up_pow2(size); - u8 *allocated = (u8 *)wapp_os_mem_alloc(NULL, alloc_size, WAPP_MEM_ACCESS_READ_WRITE, flags, - zero_buffer ? WAPP_MEM_INIT_INITIALISED : WAPP_MEM_INIT_UNINITIALISED); + u64 size = sizeof(WpArena) + (base_capacity >= ARENA_MINIMUM_CAPACITY ? base_capacity : ARENA_MINIMUM_CAPACITY); + u64 alloc_size = wpMiscUtilsU64RoundUpPow2(size); + u8 *allocated = (u8 *)wpOsMemAlloc(NULL, alloc_size, WP_MEM_ACCESS_READ_WRITE, flags, + zero_buffer ? WP_MEM_INIT_INITIALISED : WP_MEM_INIT_UNINITIALISED); if (!allocated) { return false; } - b8 committed = (flags & WAPP_MEM_ALLOC_COMMIT) == WAPP_MEM_ALLOC_COMMIT; + b8 committed = (flags & WP_MEM_ALLOC_COMMIT) == WP_MEM_ALLOC_COMMIT; -#ifdef WAPP_PLATFORM_WINDOWS +#ifdef WP_PLATFORM_WINDOWS if (!committed) { - wapp_os_mem_alloc(allocated, sizeof(Arena), WAPP_MEM_ACCESS_READ_WRITE, WAPP_MEM_ALLOC_COMMIT, - WAPP_MEM_INIT_INITIALISED); + wpOsMemAlloc(allocated, sizeof(WpArena), WP_MEM_ACCESS_READ_WRITE, WP_MEM_ALLOC_COMMIT, + WP_MEM_INIT_INITIALISED); } -#endif // ifdef WAPP_PLATFORM_WINDOWS +#endif // ifdef WP_PLATFORM_WINDOWS - if (!wapp_mem_arena_init_buffer(arena, allocated, alloc_size)) { - wapp_mem_arena_destroy(arena); + if (!wpMemArenaInitBuffer(arena, allocated, alloc_size)) { + wpMemArenaDestroy(arena); return false; } - Arena *arena_ptr = *arena; + WpArena *arena_ptr = *arena; arena_ptr->type = ARENA_STORAGE_TYPE_ALLOCATED; arena_ptr->committed = committed; return true; } -void *wapp_mem_arena_alloc(Arena *arena, u64 size) { - return wapp_mem_arena_alloc_aligned(arena, size, DEFAULT_ALIGNMENT); +void *wpMemArenaAlloc(WpArena *arena, u64 size) { + return wpMemArenaAllocAligned(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"); +void *wpMemArenaAllocAligned(WpArena *arena, u64 size, u64 alignment) { + wpDebugAssert(arena != NULL, "`arena` should not be NULL"); u8 *alloc_start = arena->offset; - u8 *output = wapp_mem_util_align_forward((void *)alloc_start, alignment); + u8 *output = wpMemUtilAlignForward((void *)alloc_start, alignment); if (output + size >= arena->buf + arena->capacity) { return NULL; } arena->offset = output + size; -#ifdef WAPP_PLATFORM_WINDOWS +#ifdef WP_PLATFORM_WINDOWS if (arena->type == ARENA_STORAGE_TYPE_ALLOCATED && !(arena->committed)) { - wapp_os_mem_alloc(alloc_start, (uptr)(arena->offset) - (uptr)(alloc_start), - WAPP_MEM_ACCESS_READ_WRITE, WAPP_MEM_ALLOC_COMMIT, - WAPP_MEM_INIT_UNINITIALISED); + wpOsMemAlloc(alloc_start, (uptr)(arena->offset) - (uptr)(alloc_start), + WP_MEM_ACCESS_READ_WRITE, WP_MEM_ALLOC_COMMIT, + WP_MEM_INIT_UNINITIALISED); } -#endif // ifdef WAPP_PLATFORM_WINDOWS +#endif // ifdef WP_PLATFORM_WINDOWS memset(output, 0, size); return (void *)output; } -void *wapp_mem_arena_realloc(Arena *arena, void *ptr, u64 old_size, u64 new_size) { - wapp_debug_assert(arena != NULL, "`arena` should not be NULL"); +void *wpMemArenaRealloc(WpArena *arena, void *ptr, u64 old_size, u64 new_size) { + wpDebugAssert(arena != NULL, "`arena` should not be 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); + void *new_ptr = wpMemArenaAlloc(arena, new_size); if (!new_ptr) { return NULL; } @@ -132,15 +132,15 @@ void *wapp_mem_arena_realloc(Arena *arena, void *ptr, u64 old_size, u64 new_size return new_ptr; } -void *wapp_mem_arena_realloc_aligned(Arena *arena, void *ptr, u64 old_size, u64 new_size, u64 alignment) { - wapp_debug_assert(arena != NULL, "`arena` should not be NULL"); +void *wpMemArenaReallocAligned(WpArena *arena, void *ptr, u64 old_size, u64 new_size, u64 alignment) { + wpDebugAssert(arena != NULL, "`arena` should not be 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); + void *new_ptr = wpMemArenaAllocAligned(arena, new_size, alignment); if (!new_ptr) { return NULL; } @@ -151,8 +151,8 @@ void *wapp_mem_arena_realloc_aligned(Arena *arena, void *ptr, u64 old_size, u64 return new_ptr; } -void wapp_mem_arena_temp_begin(Arena *arena) { - wapp_debug_assert(arena != NULL, "`arena` should not be NULL"); +void wpMemArenaTempBegin(WpArena *arena) { + wpDebugAssert(arena != NULL, "`arena` should not be NULL"); if (arena->prev_offset != NULL) { return; @@ -161,8 +161,8 @@ void wapp_mem_arena_temp_begin(Arena *arena) { arena->prev_offset = arena->offset; } -void wapp_mem_arena_temp_end(Arena *arena) { - wapp_debug_assert(arena != NULL, "`arena` should not be NULL"); +void wpMemArenaTempEnd(WpArena *arena) { + wpDebugAssert(arena != NULL, "`arena` should not be NULL"); if (arena->prev_offset == NULL) { return; @@ -172,20 +172,20 @@ void wapp_mem_arena_temp_end(Arena *arena) { arena->prev_offset = NULL; } -void wapp_mem_arena_clear(Arena *arena) { - wapp_debug_assert(arena != NULL, "`arena` should not be NULL"); +void wpMemArenaClear(WpArena *arena) { + wpDebugAssert(arena != NULL, "`arena` should not be NULL"); 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"); +void wpMemArenaDestroy(WpArena **arena) { + wpDebugAssert(arena != NULL && (*arena) != NULL, "`arena` double pointer is not valid"); - Arena *arena_ptr = *arena; + WpArena *arena_ptr = *arena; if (arena_ptr->type == ARENA_STORAGE_TYPE_ALLOCATED) { - wapp_os_mem_free(*arena, sizeof(Arena) + arena_ptr->capacity); + wpOsMemFree(*arena, sizeof(WpArena) + arena_ptr->capacity); } *arena = NULL; diff --git a/src/os/allocators/arena/mem_arena.h b/src/os/allocators/arena/mem_arena.h index 3859f39..5e4c516 100644 --- a/src/os/allocators/arena/mem_arena.h +++ b/src/os/allocators/arena/mem_arena.h @@ -7,39 +7,39 @@ #include "../../../common/aliases/aliases.h" #include "../../../common/platform/platform.h" -#ifdef WAPP_PLATFORM_CPP +#ifdef WP_PLATFORM_CPP BEGIN_C_LINKAGE -#endif // !WAPP_PLATFORM_CPP +#endif // !WP_PLATFORM_CPP -typedef struct Arena Arena; +typedef struct WpArena WpArena; -#define wapp_mem_arena_init_allocated(arena_dptr, base_capacity) \ - (wapp_mem_arena_init_allocated_custom(arena_dptr, base_capacity, WAPP_MEM_ALLOC_RESERVE, false)) -#define wapp_mem_arena_init_allocated_commit(arena_dptr, base_capacity) \ - (wapp_mem_arena_init_allocated_custom(arena_dptr, base_capacity, WAPP_MEM_ALLOC_RESERVE | WAPP_MEM_ALLOC_COMMIT, false)) -#define wapp_mem_arena_init_allocated_zero(arena_dptr, base_capacity) \ - (wapp_mem_arena_init_allocated_custom(arena_dptr, base_capacity, WAPP_MEM_ALLOC_RESERVE, true)) -#define wapp_mem_arena_init_allocated_commit_and_zero(arena_dptr, base_capacity) \ - (wapp_mem_arena_init_allocated_custom(arena_dptr, base_capacity, WAPP_MEM_ALLOC_RESERVE | WAPP_MEM_ALLOC_COMMIT, true)) +#define wpMemArenaInitAllocated(arena_dptr, base_capacity) \ + (wpMemArenaInitAllocatedCustom(arena_dptr, base_capacity, WP_MEM_ALLOC_RESERVE, false)) +#define wpMemArenaInitAllocatedCommit(arena_dptr, base_capacity) \ + (wpMemArenaInitAllocatedCustom(arena_dptr, base_capacity, WP_MEM_ALLOC_RESERVE | WP_MEM_ALLOC_COMMIT, false)) +#define wpMemArenaInitAllocatedZero(arena_dptr, base_capacity) \ + (wpMemArenaInitAllocatedCustom(arena_dptr, base_capacity, WP_MEM_ALLOC_RESERVE, true)) +#define wpMemArenaInitAllocatedCommitAndZero(arena_dptr, base_capacity) \ + (wpMemArenaInitAllocatedCustom(arena_dptr, base_capacity, WP_MEM_ALLOC_RESERVE | WP_MEM_ALLOC_COMMIT, true)) /** - * Arena initialisation function. `wapp_mem_arena_init_allocated_custom` provides the most - * control over how the Arena is initialised. Wrapper macros are provided for + * WpArena initialisation function. `wpMemArenaInitAllocatedCustom` provides the most + * control over how the WpArena is initialised. Wrapper macros are provided for * easier use. */ -b8 wapp_mem_arena_init_allocated_custom(Arena **arena, u64 base_capacity, MemAllocFlags flags, b8 zero_buffer); -b8 wapp_mem_arena_init_buffer(Arena **arena, u8 *buffer, u64 buffer_size); -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_temp_begin(Arena *arena); -void wapp_mem_arena_temp_end(Arena *arena); -void wapp_mem_arena_clear(Arena *arena); -void wapp_mem_arena_destroy(Arena **arena); +b8 wpMemArenaInitAllocatedCustom(WpArena **arena, u64 base_capacity, WpMemAllocFlags flags, b8 zero_buffer); +b8 wpMemArenaInitBuffer(WpArena **arena, u8 *buffer, u64 buffer_size); +void *wpMemArenaAlloc(WpArena *arena, u64 size); +void *wpMemArenaAllocAligned(WpArena *arena, u64 size, u64 alignment); +void *wpMemArenaRealloc(WpArena *arena, void *ptr, u64 old_size, u64 new_size); +void *wpMemArenaReallocAligned(WpArena *arena, void *ptr, u64 old_size, u64 new_size, u64 alignment); +void wpMemArenaTempBegin(WpArena *arena); +void wpMemArenaTempEnd(WpArena *arena); +void wpMemArenaClear(WpArena *arena); +void wpMemArenaDestroy(WpArena **arena); -#ifdef WAPP_PLATFORM_CPP +#ifdef WP_PLATFORM_CPP END_C_LINKAGE -#endif // !WAPP_PLATFORM_CPP +#endif // !WP_PLATFORM_CPP #endif // !MEM_ARENA_H diff --git a/src/os/allocators/arena/mem_arena_allocator.c b/src/os/allocators/arena/mem_arena_allocator.c index fa020db..0d1a0f0 100644 --- a/src/os/allocators/arena/mem_arena_allocator.c +++ b/src/os/allocators/arena/mem_arena_allocator.c @@ -6,16 +6,16 @@ #include "../../../common/aliases/aliases.h" #include "../../../common/assert/assert.h" -wapp_intern void initialise_arena_allocator(Allocator *allocator); -wapp_intern void *mem_arena_alloc(u64 size, void *alloc_obj); -wapp_intern void *mem_arena_alloc_aligned(u64 size, u64 alignment, void *alloc_obj); -wapp_intern void *mem_arena_realloc(void *ptr, u64 old_size, u64 new_size, void *alloc_obj); -wapp_intern void *mem_arena_realloc_aligned(void *ptr, u64 old_size, u64 new_size, u64 alignment, +wp_intern void initialise_arena_allocator(WpAllocator *allocator); +wp_intern void *mem_arena_alloc(u64 size, void *alloc_obj); +wp_intern void *mem_arena_alloc_aligned(u64 size, u64 alignment, void *alloc_obj); +wp_intern void *mem_arena_realloc(void *ptr, u64 old_size, u64 new_size, void *alloc_obj); +wp_intern void *mem_arena_realloc_aligned(void *ptr, u64 old_size, u64 new_size, u64 alignment, void *alloc_obj); -Allocator wapp_mem_arena_allocator_init_with_buffer(u8 *buffer, u64 buffer_size) { - Allocator allocator = {0}; - b8 initialised = wapp_mem_arena_init_buffer((Arena **)(&allocator.obj), buffer, buffer_size); +WpAllocator wpMemArenaAllocatorInitWithBuffer(u8 *buffer, u64 buffer_size) { + WpAllocator allocator = {0}; + b8 initialised = wpMemArenaInitBuffer((WpArena **)(&allocator.obj), buffer, buffer_size); if (!initialised) { return allocator; } @@ -25,9 +25,9 @@ Allocator wapp_mem_arena_allocator_init_with_buffer(u8 *buffer, u64 buffer_size) return allocator; } -Allocator wapp_mem_arena_allocator_init_custom(u64 base_capacity, MemAllocFlags flags, b8 zero_buffer) { - Allocator allocator = {0}; - b8 initialised = wapp_mem_arena_init_allocated_custom((Arena **)(&allocator.obj), base_capacity, flags, zero_buffer); +WpAllocator wpMemArenaAllocatorInitCustom(u64 base_capacity, WpMemAllocFlags flags, b8 zero_buffer) { + WpAllocator allocator = {0}; + b8 initialised = wpMemArenaInitAllocatedCustom((WpArena **)(&allocator.obj), base_capacity, flags, zero_buffer); if (!initialised) { return allocator; } @@ -37,51 +37,51 @@ Allocator wapp_mem_arena_allocator_init_custom(u64 base_capacity, MemAllocFlags return allocator; } -void wapp_mem_arena_allocator_temp_begin(const Allocator *allocator) { - wapp_debug_assert(allocator != NULL, "`allocator` should not be NULL"); - wapp_mem_arena_temp_begin((Arena *)(allocator->obj)); +void wpMemArenaAllocatorTempBegin(const WpAllocator *allocator) { + wpDebugAssert(allocator != NULL, "`allocator` should not be NULL"); + wpMemArenaTempBegin((WpArena *)(allocator->obj)); } -void wapp_mem_arena_allocator_temp_end(const Allocator *allocator) { - wapp_debug_assert(allocator != NULL, "`allocator` should not be NULL"); - wapp_mem_arena_temp_end((Arena *)(allocator->obj)); +void wpMemArenaAllocatorTempEnd(const WpAllocator *allocator) { + wpDebugAssert(allocator != NULL, "`allocator` should not be NULL"); + wpMemArenaTempEnd((WpArena *)(allocator->obj)); } -void wapp_mem_arena_allocator_clear(Allocator *allocator) { - wapp_debug_assert(allocator != NULL, "`allocator` should not be NULL"); - wapp_mem_arena_clear((Arena *)(allocator->obj)); +void wpMemArenaAllocatorClear(WpAllocator *allocator) { + wpDebugAssert(allocator != NULL, "`allocator` should not be NULL"); + wpMemArenaClear((WpArena *)(allocator->obj)); } -void wapp_mem_arena_allocator_destroy(Allocator *allocator) { - wapp_debug_assert(allocator != NULL, "`allocator` should not be NULL"); - wapp_mem_arena_destroy((Arena **)(&(allocator->obj))); - *allocator = (Allocator){0}; +void wpMemArenaAllocatorDestroy(WpAllocator *allocator) { + wpDebugAssert(allocator != NULL, "`allocator` should not be NULL"); + wpMemArenaDestroy((WpArena **)(&(allocator->obj))); + *allocator = (WpAllocator){0}; } -wapp_intern void initialise_arena_allocator(Allocator *allocator) { +wp_intern void initialise_arena_allocator(WpAllocator *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; } -wapp_intern void *mem_arena_alloc(u64 size, void *alloc_obj) { - Arena *arena = (Arena *)alloc_obj; - return wapp_mem_arena_alloc(arena, size); +wp_intern void *mem_arena_alloc(u64 size, void *alloc_obj) { + WpArena *arena = (WpArena *)alloc_obj; + return wpMemArenaAlloc(arena, size); } -wapp_intern 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); +wp_intern void *mem_arena_alloc_aligned(u64 size, u64 alignment, void *alloc_obj) { + WpArena *arena = (WpArena *)alloc_obj; + return wpMemArenaAllocAligned(arena, size, alignment); } -wapp_intern 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); +wp_intern void *mem_arena_realloc(void *ptr, u64 old_size, u64 new_size, void *alloc_obj) { + WpArena *arena = (WpArena *)alloc_obj; + return wpMemArenaRealloc(arena, ptr, old_size, new_size); } -wapp_intern void *mem_arena_realloc_aligned(void *ptr, u64 old_size, u64 new_size, u64 alignment, +wp_intern 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); + WpArena *arena = (WpArena *)alloc_obj; + return wpMemArenaReallocAligned(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 bd88379..789cbb2 100644 --- a/src/os/allocators/arena/mem_arena_allocator.h +++ b/src/os/allocators/arena/mem_arena_allocator.h @@ -8,39 +8,39 @@ #include "../../../common/platform/platform.h" #include "../../../base/mem/allocator/mem_allocator.h" -#ifdef WAPP_PLATFORM_CPP +#ifdef WP_PLATFORM_CPP BEGIN_C_LINKAGE -#endif // !WAPP_PLATFORM_CPP +#endif // !WP_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 wpMemArenaAllocatorInit(base_capacity) \ + (wpMemArenaAllocatorInitCustom(base_capacity, WP_MEM_ALLOC_RESERVE, false)) +#define wpMemArenaAllocatorInitCommit(base_capacity) \ + (wpMemArenaAllocatorInitCustom(base_capacity, WP_MEM_ALLOC_RESERVE | WP_MEM_ALLOC_COMMIT, false)) +#define wpMemArenaAllocatorInitZero(base_capacity) \ + (wpMemArenaAllocatorInitCustom(base_capacity, WP_MEM_ALLOC_RESERVE, true)) +#define wpMemArenaAllocatorInitCommitAndZero(base_capacity) \ + (wpMemArenaAllocatorInitCustom(base_capacity, WP_MEM_ALLOC_RESERVE | WP_MEM_ALLOC_COMMIT, true)) /** - * Wraps an Arena in an Allocator object. It attempts to initialise the Arena + * Wraps a WpArena in a WpAllocator object. It attempts to initialise the WpArena * and, if successful, defines the operations supported by it to be used by the - * Allocator. + * WpAllocator. * - * An Arena allocator only supports normal allocation and aligned allocation. + * An WpArena allocator only supports normal allocation and aligned allocation. * Reallocation, aligned reallocation and freeing aren't implemented. * - * The `wapp_mem_arena_allocator_init_custom` provides the most control over how - * the Arena is initialised. Wrapper macros are provided for easier use. + * The `wpMemArenaAllocatorInitCustom` provides the most control over how + * the WpArena is initialised. Wrapper macros are provided for easier use. */ -Allocator wapp_mem_arena_allocator_init_custom(u64 base_capacity, MemAllocFlags flags, b8 zero_buffer); -Allocator wapp_mem_arena_allocator_init_with_buffer(u8 *buffer, u64 buffer_size); -void wapp_mem_arena_allocator_temp_begin(const Allocator *allocator); -void wapp_mem_arena_allocator_temp_end(const Allocator *allocator); -void wapp_mem_arena_allocator_clear(Allocator *allocator); -void wapp_mem_arena_allocator_destroy(Allocator *allocator); +WpAllocator wpMemArenaAllocatorInitCustom(u64 base_capacity, WpMemAllocFlags flags, b8 zero_buffer); +WpAllocator wpMemArenaAllocatorInitWithBuffer(u8 *buffer, u64 buffer_size); +void wpMemArenaAllocatorTempBegin(const WpAllocator *allocator); +void wpMemArenaAllocatorTempEnd(const WpAllocator *allocator); +void wpMemArenaAllocatorClear(WpAllocator *allocator); +void wpMemArenaAllocatorDestroy(WpAllocator *allocator); -#ifdef WAPP_PLATFORM_CPP +#ifdef WP_PLATFORM_CPP END_C_LINKAGE -#endif // !WAPP_PLATFORM_CPP +#endif // !WP_PLATFORM_CPP #endif // !MEM_ARENA_ALLOCATOR_H diff --git a/src/os/cpath/cpath.c b/src/os/cpath/cpath.c index 5449518..a78d17a 100644 --- a/src/os/cpath/cpath.c +++ b/src/os/cpath/cpath.c @@ -8,128 +8,126 @@ #include "../../base/mem/allocator/mem_allocator.h" #include "../../base/strings/str8/str8.h" #include -#include -#include -u32 wapp_cpath_join_path(Str8 *dst, const Str8List *parts) { +u32 wpCpathJoinPath(WpStr8 *dst, const WpStr8List *parts) { if (!dst || !parts) { - return CPATH_JOIN_INVALID_ARGS; + return WP_CPATH_JOIN_RESULT_INVALID_ARGS; } if (parts->node_count == 0) { - return CPATH_JOIN_EMPTY_PARTS; + return WP_CPATH_JOIN_RESULT_EMPTY_PARTS; } - Str8 separator = wapp_str8_buf(4); - wapp_str8_push_back(&separator, WAPP_PATH_SEP); + WpStr8 separator = wpStr8Buf(4); + wpStr8PushBack(&separator, WP_PATH_SEP); - u64 required_capacity = parts->node_count * separator.size + wapp_str8_list_total_size(parts); + u64 required_capacity = parts->node_count * separator.size + wpStr8ListTotalSize(parts); if (dst->capacity < required_capacity) { - return CPATH_JOIN_INSUFFICIENT_DST_CAPACITY; + return WP_CPATH_JOIN_RESULT_INSUFFICIENT_DST_CAPACITY; } // Handle first node - Str8 *first_node = wapp_dbl_list_get(Str8, parts, 0); - wapp_str8_copy_str8_capped(dst, first_node); + WpStr8 *first_node = wpDblListGet(WpStr8, parts, 0); + wpStr8CopyStr8Capped(dst, first_node); // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of // MSVC Spectre mitigation warnings - Str8 *node = first_node; + WpStr8 *node = first_node; u64 node_index = 1; b8 running = node_index < parts->node_count; while (running) { - node = wapp_dbl_list_get(Str8, parts, node_index); + node = wpDblListGet(WpStr8, parts, node_index); if (node->size == 0) { goto CPATH_JOIN_LOOP_END; } if (dst->size > 0) { - char dst_last = wapp_str8_get(dst, dst->size - 1); - char node_start = wapp_str8_get(node, 0); - b8 add_path_sep = dst_last != WAPP_PATH_SEP && node_start != WAPP_PATH_SEP; + char dst_last = wpStr8Get(dst, dst->size - 1); + char node_start = wpStr8Get(node, 0); + b8 add_path_sep = dst_last != WP_PATH_SEP && node_start != WP_PATH_SEP; if (add_path_sep) { - wapp_str8_concat_capped(dst, &separator); + wpStr8ConcatCapped(dst, &separator); } } - wapp_str8_concat_capped(dst, node); + wpStr8ConcatCapped(dst, node); CPATH_JOIN_LOOP_END: ++node_index; running = node_index < parts->node_count; } - return CPATH_JOIN_SUCCESS; + return WP_CPATH_JOIN_RESULT_SUCCESS; } -Str8 *dirup(const Allocator *allocator, Str8RO *path, u64 levels) { - Str8 *output = NULL; +WpStr8 *_dirup(const WpAllocator *allocator, WpStr8RO *path, u64 levels) { + WpStr8 *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 = wpStr8Get(path, 0) == WP_PATH_SEP; + WpStr8 separator = wpStr8Buf(4); + wpStr8PushBack(&separator, WP_PATH_SEP); if (path->size == 0) { - output = wapp_str8_alloc_buf(allocator, 16); + output = wpStr8AllocBuf(allocator, 16); if (!output) { goto RETURN_DIRUP; } - wapp_str8_push_back(output, absolute ? WAPP_PATH_SEP : '.'); + wpStr8PushBack(output, absolute ? WP_PATH_SEP : '.'); goto RETURN_DIRUP; } if (levels < 1) { - output = wapp_str8_alloc_str8(allocator, path); + output = wpStr8AllocStr8(allocator, path); goto RETURN_DIRUP; } - Allocator tmp_arena = wapp_mem_arena_allocator_init(MiB(8)); - if (wapp_mem_allocator_invalid(&tmp_arena)) { + WpAllocator tmp_arena = wpMemArenaAllocatorInit(MiB(8)); + if (wpMemAllocatorInvalid(&tmp_arena)) { goto RETURN_DIRUP; } - Str8List *parts = wapp_str8_split(&tmp_arena, path, &separator); + WpStr8List *parts = wpStr8Split(&tmp_arena, path, &separator); if (!parts) { goto RETURN_DIRUP; } if (levels >= parts->node_count) { - output = wapp_str8_alloc_buf(allocator, 16); + output = wpStr8AllocBuf(allocator, 16); if (!output) { goto LIST_CLEANUP_DIRUP; } - wapp_str8_push_back(output, absolute ? WAPP_PATH_SEP : '.'); + wpStr8PushBack(output, absolute ? WP_PATH_SEP : '.'); } else { for (u64 i = 0; i < levels; ++i) { - wapp_dbl_list_pop_back(Str8, parts); + wpDblListPopBack(WpStr8, parts); } u64 alignment = sizeof(void *) * 2; - u64 alloc_size = wapp_str8_list_total_size(parts) + parts->node_count * separator.size; + u64 alloc_size = wpStr8ListTotalSize(parts) + parts->node_count * separator.size; u64 modulo = alloc_size & (alignment - 1); alloc_size += alignment - modulo; - output = wapp_str8_alloc_buf(allocator, alloc_size); + output = wpStr8AllocBuf(allocator, alloc_size); if (output) { if (absolute) { - wapp_str8_push_back(output, WAPP_PATH_SEP); + wpStr8PushBack(output, WP_PATH_SEP); } - Str8 *joined = wapp_str8_join(&tmp_arena, parts, &separator); + WpStr8 *joined = wpStr8Join(&tmp_arena, parts, &separator); if (joined) { - wapp_str8_concat_capped(output, joined); + wpStr8ConcatCapped(output, joined); } } } LIST_CLEANUP_DIRUP: - wapp_mem_arena_allocator_destroy(&tmp_arena); + wpMemArenaAllocatorDestroy(&tmp_arena); RETURN_DIRUP: return output; diff --git a/src/os/cpath/cpath.h b/src/os/cpath/cpath.h index d481822..d87506a 100644 --- a/src/os/cpath/cpath.h +++ b/src/os/cpath/cpath.h @@ -8,38 +8,38 @@ #include "../../base/mem/allocator/mem_allocator.h" #include "../../base/strings/str8/str8.h" -#ifdef WAPP_PLATFORM_CPP +#ifdef WP_PLATFORM_CPP BEGIN_C_LINKAGE -#endif // !WAPP_PLATFORM_CPP +#endif // !WP_PLATFORM_CPP -#ifdef WAPP_PLATFORM_POSIX +#ifdef WP_PLATFORM_POSIX #include -#define WAPP_PATH_SEP '/' -#define WAPP_PATH_MAX PATH_MAX -#elif defined(WAPP_PLATFORM_WINDOWS) +#define WP_PATH_SEP '/' +#define WP_PATH_MAX PATH_MAX +#elif defined(WP_PLATFORM_WINDOWS) #define WIN32_LEAN_AND_MEAN #include -#define WAPP_PATH_SEP '\\' -#define WAPP_PATH_MAX MAX_PATH +#define WP_PATH_SEP '\\' +#define WP_PATH_MAX MAX_PATH #else #error "Unrecognised platform" #endif -#define wapp_cpath_dirname(ALLOCATOR, PATH) dirup(ALLOCATOR, PATH, 1) -#define wapp_cpath_dirup(ALLOCATOR, PATH, COUNT) dirup(ALLOCATOR, PATH, COUNT) +#define wpCpathDirname(ALLOCATOR, PATH) _dirup(ALLOCATOR, PATH, 1) +#define wpCpathDirup(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, -}; +typedef enum { + WP_CPATH_JOIN_RESULT_SUCCESS = 0, + WP_CPATH_JOIN_RESULT_INVALID_ARGS, + WP_CPATH_JOIN_RESULT_EMPTY_PARTS, + WP_CPATH_JOIN_RESULT_INSUFFICIENT_DST_CAPACITY, +} WpCpathJoinResult; -u32 wapp_cpath_join_path(Str8 *dst, const Str8List *parts); -Str8 *dirup(const Allocator *allocator, Str8RO *path, u64 levels); +WpCpathJoinResult wpCpathJoinPath(WpStr8 *dst, const WpStr8List *parts); +WpStr8 *_dirup(const WpAllocator *allocator, WpStr8RO *path, u64 levels); -#ifdef WAPP_PLATFORM_CPP +#ifdef WP_PLATFORM_CPP END_C_LINKAGE -#endif // !WAPP_PLATFORM_CPP +#endif // !WP_PLATFORM_CPP #endif // !CPATH_H diff --git a/src/os/file/file.c b/src/os/file/file.c index 1c2d614..9822620 100644 --- a/src/os/file/file.c +++ b/src/os/file/file.c @@ -7,77 +7,77 @@ #include "../../base/array/array.h" #include "../../base/strings/str8/str8.h" -WFile *wapp_file_open(const Allocator *allocator, Str8RO *filepath, FileAccessMode mode) { - wapp_debug_assert(allocator != NULL && filepath != NULL, "`allocator` and `filepath` should not be NULL"); - wapp_debug_assert(filepath->size < WAPP_PATH_MAX, "`filepath` exceeds max path limit."); - return _file_open(allocator, filepath, mode); +WpFile *wpFileOpen(const WpAllocator *allocator, WpStr8RO *filepath, WpFileAccessMode mode) { + wpDebugAssert(allocator != NULL && filepath != NULL, "`allocator` and `filepath` should not be NULL"); + wpDebugAssert(filepath->size < WP_PATH_MAX, "`filepath` exceeds max path limit."); + return _fileOpen(allocator, filepath, mode); } -i64 wapp_file_get_current_position(WFile *file) { - wapp_debug_assert(file != NULL, "`file` should not be NULL."); - return _file_seek(file, 0, WAPP_SEEK_CURRENT); +i64 wpFileGetCurrentPosition(WpFile *file) { + wpDebugAssert(file != NULL, "`file` should not be NULL."); + return _fileSeek(file, 0, WP_SEEK_CURRENT); } -i64 wapp_file_seek(WFile *file, i64 offset, FileSeekOrigin origin) { - wapp_debug_assert(file != NULL, "`file` should not be NULL."); - return _file_seek(file, offset, origin); +i64 wpFileSeek(WpFile *file, i64 offset, WpFileSeekOrigin origin) { + wpDebugAssert(file != NULL, "`file` should not be NULL."); + return _fileSeek(file, offset, origin); } -i64 wapp_file_get_length(WFile *file) { - wapp_debug_assert(file != NULL, "`file` should not be NULL."); +i64 wpFileGetLength(WpFile *file) { + wpDebugAssert(file != NULL, "`file` should not be NULL."); - i64 current = wapp_file_get_current_position(file); + i64 current = wpFileGetCurrentPosition(file); - _file_seek(file, 0, WAPP_SEEK_END); + _fileSeek(file, 0, WP_SEEK_END); - i64 output = wapp_file_get_current_position(file); + i64 output = wpFileGetCurrentPosition(file); // Restore position - _file_seek(file, current, WAPP_SEEK_START); + _fileSeek(file, current, WP_SEEK_START); return output; } -u64 wapp_file_read(void *dst_buf, WFile *file, u64 byte_count) { - wapp_debug_assert(dst_buf != NULL && file != NULL, +u64 wpFileRead(void *dst_buf, WpFile *file, u64 byte_count) { + wpDebugAssert(dst_buf != NULL && file != NULL, "`dst_buf` and `file` should not be NULL."); - i64 file_length = wapp_file_get_length(file); + i64 file_length = wpFileGetLength(file); if (file_length < 0) { return 0; } - return _file_read(dst_buf, byte_count, file, file_length); + return _fileRead(dst_buf, byte_count, file, file_length); } -i64 wapp_file_write(const void *src_buf, WFile *file, u64 byte_count) { - wapp_debug_assert(src_buf != NULL && file != NULL, +i64 wpFileWrite(const void *src_buf, WpFile *file, u64 byte_count) { + wpDebugAssert(src_buf != NULL && file != NULL, "`src_buf` and `file` should not be NULL."); - return _file_write(src_buf, file, byte_count); + return _fileWrite(src_buf, file, byte_count); } -u64 wapp_file_read_str8(Str8 *str, WFile *file) { - wapp_debug_assert(str != NULL, "`str` should not be NULL."); - return wapp_file_read((void *)(str->buf), file, str->size); +u64 wpFileReadStr8(WpStr8 *str, WpFile *file) { + wpDebugAssert(str != NULL, "`str` should not be NULL."); + return wpFileRead((void *)(str->buf), file, str->size); } -i64 wapp_file_write_str8(Str8RO *str, WFile *file) { - wapp_debug_assert(str != NULL, "`str` should not be NULL."); - return wapp_file_write((void *)(str->buf), file, str->size); +i64 wpFileWriteStr8(WpStr8RO *str, WpFile *file) { + wpDebugAssert(str != NULL, "`str` should not be NULL."); + return wpFileWrite((void *)(str->buf), file, str->size); } -u64 wapp_file_read_array(GenericArray dst_buf, WFile *file, u64 item_count) { - wapp_debug_assert(dst_buf != NULL && file != NULL, +u64 wpFileReadArray(WpArray dst_buf, WpFile *file, u64 item_count) { + wpDebugAssert(dst_buf != NULL && file != NULL, "`dst_buf` and `file` should not be NULL."); - i64 _file_length = wapp_file_get_length(file); + i64 _file_length = wpFileGetLength(file); if (_file_length < 0) { return 0; } u64 file_length = (u64)_file_length; - u64 item_size = wapp_array_item_size(dst_buf); - u64 dst_byte_capacity = wapp_array_capacity(dst_buf) * item_size; + u64 item_size = wpArrayItemSize(dst_buf); + u64 dst_byte_capacity = wpArrayCapacity(dst_buf) * item_size; u64 req_byte_count = item_count * item_size; u64 copy_byte_count = 0; @@ -87,26 +87,26 @@ u64 wapp_file_read_array(GenericArray dst_buf, WFile *file, u64 item_count) { copy_byte_count = file_length <= dst_byte_capacity ? file_length : dst_byte_capacity; } - u64 byte_count = _file_read(dst_buf, copy_byte_count, file, file_length); + u64 byte_count = _fileRead(dst_buf, copy_byte_count, file, file_length); if (byte_count == 0) { return 0; } - wapp_array_set_count(dst_buf, byte_count / item_size); + wpArraySetCount(dst_buf, byte_count / item_size); - return wapp_array_count(dst_buf); + return wpArrayCount(dst_buf); } -i64 wapp_file_write_array(const GenericArray src_buf, WFile *file, u64 item_count) { - wapp_debug_assert(src_buf != NULL && file != NULL, +i64 wpFileWriteArray(const WpArray src_buf, WpFile *file, u64 item_count) { + wpDebugAssert(src_buf != NULL && file != NULL, "`src_buf` and `file` should not be NULL."); - u64 item_size = wapp_array_item_size(src_buf); - u64 src_byte_count = wapp_array_count(src_buf) * item_size; + u64 item_size = wpArrayItemSize(src_buf); + u64 src_byte_count = wpArrayCount(src_buf) * 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; - i64 bytes_written = _file_write(src_buf, file, to_copy); + i64 bytes_written = _fileWrite(src_buf, file, to_copy); if (bytes_written < 0) { return 0; } @@ -114,26 +114,26 @@ i64 wapp_file_write_array(const GenericArray src_buf, WFile *file, u64 item_coun return (u64)bytes_written / item_size; } -i32 wapp_file_flush(WFile *file) { - wapp_debug_assert(file != NULL, "`file` should not be NULL."); - return _file_flush(file); +i32 wpFileFlush(WpFile *file) { + wpDebugAssert(file != NULL, "`file` should not be NULL."); + return _fileFlush(file); } -i32 wapp_file_close(WFile *file) { - wapp_debug_assert(file != NULL, "`file` should not be NULL."); - return _file_close(file); +i32 wpFileClose(WpFile *file) { + wpDebugAssert(file != NULL, "`file` should not be NULL."); + return _fileClose(file); } -i32 wapp_file_rename(Str8RO *old_filepath, Str8RO *new_filepath) { - wapp_debug_assert(old_filepath != NULL && new_filepath != NULL, +i32 wpFileRename(WpStr8RO *old_filepath, WpStr8RO *new_filepath) { + wpDebugAssert(old_filepath != NULL && new_filepath != NULL, "`old_filepath` and `new_filepath` should not be NULL"); - wapp_debug_assert(old_filepath->size < WAPP_PATH_MAX, "`old_filepath` exceeds max path limit."); - wapp_debug_assert(new_filepath->size < WAPP_PATH_MAX, "`new_filepath` exceeds max path limit."); - return _file_rename(old_filepath, new_filepath); + wpDebugAssert(old_filepath->size < WP_PATH_MAX, "`old_filepath` exceeds max path limit."); + wpDebugAssert(new_filepath->size < WP_PATH_MAX, "`new_filepath` exceeds max path limit."); + return _fileRename(old_filepath, new_filepath); } -i32 wapp_file_remove(Str8RO *filepath) { - wapp_debug_assert(filepath != NULL, "`filepath` should not be NULL"); - wapp_debug_assert(filepath->size < WAPP_PATH_MAX, "`filepath` exceeds max path limit."); - return _file_remove(filepath); +i32 wpFileRemove(WpStr8RO *filepath) { + wpDebugAssert(filepath != NULL, "`filepath` should not be NULL"); + wpDebugAssert(filepath->size < WP_PATH_MAX, "`filepath` exceeds max path limit."); + return _fileRemove(filepath); } diff --git a/src/os/file/file.h b/src/os/file/file.h index 888ab99..73f8231 100644 --- a/src/os/file/file.h +++ b/src/os/file/file.h @@ -7,71 +7,71 @@ #include "../../common/aliases/aliases.h" #include "../../base/strings/str8/str8.h" -#ifdef WAPP_PLATFORM_CPP +#ifdef WP_PLATFORM_CPP BEGIN_C_LINKAGE -#endif // !WAPP_PLATFORM_CPP +#endif // !WP_PLATFORM_CPP -typedef struct WFile WFile; +typedef struct WpFile WpFile; typedef enum { - WAPP_ACCESS_READ, // Equivalent to r - WAPP_ACCESS_WRITE, // Equivalent to w - WAPP_ACCESS_APPEND, // Equivalent to a - WAPP_ACCESS_READ_EX, // Equivalent to r+ - WAPP_ACCESS_WRITE_EX, // Equivalent to w+ - WAPP_ACCESS_APPEND_EX, // Equivalent to a+ - WAPP_ACCESS_WRITE_FAIL_ON_EXIST, // Equivalent to wx - WAPP_ACCESS_WRITE_FAIL_ON_EXIST_EX, // Equivalent to wx+ + WP_ACCESS_READ, // Equivalent to r + WP_ACCESS_WRITE, // Equivalent to w + WP_ACCESS_APPEND, // Equivalent to a + WP_ACCESS_READ_EX, // Equivalent to r+ + WP_ACCESS_WRITE_EX, // Equivalent to w+ + WP_ACCESS_APPEND_EX, // Equivalent to a+ + WP_ACCESS_WRITE_FAIL_ON_EXIST, // Equivalent to wx + WP_ACCESS_WRITE_FAIL_ON_EXIST_EX, // Equivalent to wx+ - FILE_ACCESS_MODE_COUNT, -} FileAccessMode; + COUNT_FILE_ACCESS_MODE, +} WpFileAccessMode; typedef enum { - WAPP_SEEK_START, - WAPP_SEEK_CURRENT, - WAPP_SEEK_END, + WP_SEEK_START, + WP_SEEK_CURRENT, + WP_SEEK_END, - FILE_SEEK_ORIGIN_COUNT, -} FileSeekOrigin; + COUNT_FILE_SEEK_ORIGIN, +} WpFileSeekOrigin; // Return value should not be cached as it's not guaranteed to remain the same. Always call -// wapp_file_stdin to get the standard input stream -wapp_extern WFile *wapp_file_stdin(void); +// wpFileStdin to get the standard input stream +wp_extern WpFile *wpFileStdin(void); // Return value should not be cached as it's not guaranteed to remain the same. Always call -// wapp_file_stdout to get the standard output stream -wapp_extern WFile *wapp_file_stdout(void); +// wpFileStdout to get the standard output stream +wp_extern WpFile *wpFileStdout(void); // Return value should not be cached as it's not guaranteed to remain the same. Always call -// wapp_file_stderr to get the standard error stream -wapp_extern WFile *wapp_file_stderr(void); +// wpFileStderr to get the standard error stream +wp_extern WpFile *wpFileStderr(void); -WFile *wapp_file_open(const Allocator *allocator, Str8RO *filepath, FileAccessMode mode); -i64 wapp_file_get_current_position(WFile *file); -i64 wapp_file_seek(WFile *file, i64 offset, FileSeekOrigin origin); -i64 wapp_file_get_length(WFile *file); -u64 wapp_file_read(void *dst_buf, WFile *file, u64 byte_count); -i64 wapp_file_write(const void *src_buf, WFile *file, u64 byte_count); -u64 wapp_file_read_str8(Str8 *str, WFile *file); -i64 wapp_file_write_str8(Str8RO *str, WFile *file); -u64 wapp_file_read_array(GenericArray dst_buf, WFile *file, u64 item_count); -i64 wapp_file_write_array(const GenericArray src_buf, WFile *file, u64 item_count); -i32 wapp_file_flush(WFile *file); -i32 wapp_file_close(WFile *file); -i32 wapp_file_rename(Str8RO *old_filepath, Str8RO *new_filepath); -i32 wapp_file_remove(Str8RO *filepath); +WpFile *wpFileOpen(const WpAllocator *allocator, WpStr8RO *filepath, WpFileAccessMode mode); +i64 wpFileGetCurrentPosition(WpFile *file); +i64 wpFileSeek(WpFile *file, i64 offset, WpFileSeekOrigin origin); +i64 wpFileGetLength(WpFile *file); +u64 wpFileRead(void *dst_buf, WpFile *file, u64 byte_count); +i64 wpFileWrite(const void *src_buf, WpFile *file, u64 byte_count); +u64 wpFileReadStr8(WpStr8 *str, WpFile *file); +i64 wpFileWriteStr8(WpStr8RO *str, WpFile *file); +u64 wpFileReadArray(WpArray dst_buf, WpFile *file, u64 item_count); +i64 wpFileWriteArray(const WpArray src_buf, WpFile *file, u64 item_count); +i32 wpFileFlush(WpFile *file); +i32 wpFileClose(WpFile *file); +i32 wpFileRename(WpStr8RO *old_filepath, WpStr8RO *new_filepath); +i32 wpFileRemove(WpStr8RO *filepath); -wapp_extern WFile *_file_open(const Allocator *allocator, Str8RO *filepath, FileAccessMode mode); -wapp_extern i64 _file_seek(WFile *file, i64 offset, FileSeekOrigin origin); -wapp_extern u64 _file_read(void *dst_buf, u64 byte_count, WFile *file, u64 file_length); -wapp_extern i64 _file_write(const void *src_buf, WFile *file, u64 byte_count); -wapp_extern i32 _file_flush(WFile *file); -wapp_extern i32 _file_close(WFile *file); -wapp_extern i32 _file_rename(Str8RO *old_filepath, Str8RO *new_filepath); -wapp_extern i32 _file_remove(Str8RO *filepath); +wp_extern WpFile *_fileOpen(const WpAllocator *allocator, WpStr8RO *filepath, WpFileAccessMode mode); +wp_extern i64 _fileSeek(WpFile *file, i64 offset, WpFileSeekOrigin origin); +wp_extern u64 _fileRead(void *dst_buf, u64 byte_count, WpFile *file, u64 file_length); +wp_extern i64 _fileWrite(const void *src_buf, WpFile *file, u64 byte_count); +wp_extern i32 _fileFlush(WpFile *file); +wp_extern i32 _fileClose(WpFile *file); +wp_extern i32 _fileRename(WpStr8RO *old_filepath, WpStr8RO *new_filepath); +wp_extern i32 _fileRemove(WpStr8RO *filepath); -#ifdef WAPP_PLATFORM_CPP +#ifdef WP_PLATFORM_CPP END_C_LINKAGE -#endif // !WAPP_PLATFORM_CPP +#endif // !WP_PLATFORM_CPP #endif // !FILE_H diff --git a/src/os/file/posix/file_posix.c b/src/os/file/posix/file_posix.c index 345c144..3a3fafd 100644 --- a/src/os/file/posix/file_posix.c +++ b/src/os/file/posix/file_posix.c @@ -3,7 +3,7 @@ #include "file_posix.h" #include "../../../common/platform/platform.h" -#ifdef WAPP_PLATFORM_POSIX +#ifdef WP_PLATFORM_POSIX #include "../file.h" #include "../../cpath/cpath.h" @@ -11,62 +11,62 @@ #include "../../../base/array/array.h" #include "../../../base/strings/str8/str8.h" -#ifdef WAPP_PLATFORM_APPLE +#ifdef WP_PLATFORM_APPLE #define _FILE_OFFSET_BITS 64 #define lseek64 lseek -#endif // !WAPP_PLATFORM_APPLE +#endif // !WP_PLATFORM_APPLE #define __USE_LARGEFILE64 #include #include #include -wapp_intern i32 file_flags[FILE_ACCESS_MODE_COUNT] = { - [WAPP_ACCESS_READ] = O_RDONLY, - [WAPP_ACCESS_WRITE] = O_WRONLY | O_CREAT, - [WAPP_ACCESS_APPEND] = O_WRONLY | O_APPEND | O_CREAT, - [WAPP_ACCESS_READ_EX] = O_RDWR, - [WAPP_ACCESS_WRITE_EX] = O_RDWR | O_CREAT, - [WAPP_ACCESS_APPEND_EX] = O_RDWR | O_APPEND | O_CREAT, - [WAPP_ACCESS_WRITE_FAIL_ON_EXIST] = O_WRONLY | O_CREAT | O_EXCL, - [WAPP_ACCESS_WRITE_FAIL_ON_EXIST_EX] = O_RDWR | O_CREAT | O_EXCL, +wp_intern i32 file_flags[COUNT_FILE_ACCESS_MODE] = { + [WP_ACCESS_READ] = O_RDONLY, + [WP_ACCESS_WRITE] = O_WRONLY | O_CREAT, + [WP_ACCESS_APPEND] = O_WRONLY | O_APPEND | O_CREAT, + [WP_ACCESS_READ_EX] = O_RDWR, + [WP_ACCESS_WRITE_EX] = O_RDWR | O_CREAT, + [WP_ACCESS_APPEND_EX] = O_RDWR | O_APPEND | O_CREAT, + [WP_ACCESS_WRITE_FAIL_ON_EXIST] = O_WRONLY | O_CREAT | O_EXCL, + [WP_ACCESS_WRITE_FAIL_ON_EXIST_EX] = O_RDWR | O_CREAT | O_EXCL, }; -wapp_intern mode_t file_modes[FILE_ACCESS_MODE_COUNT] = { - [WAPP_ACCESS_READ] = 0, - [WAPP_ACCESS_WRITE] = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP, - [WAPP_ACCESS_APPEND] = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP, - [WAPP_ACCESS_READ_EX] = 0, - [WAPP_ACCESS_WRITE_EX] = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP, - [WAPP_ACCESS_APPEND_EX] = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP, - [WAPP_ACCESS_WRITE_FAIL_ON_EXIST] = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP, - [WAPP_ACCESS_WRITE_FAIL_ON_EXIST_EX] = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP, +wp_intern mode_t file_modes[COUNT_FILE_ACCESS_MODE] = { + [WP_ACCESS_READ] = 0, + [WP_ACCESS_WRITE] = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP, + [WP_ACCESS_APPEND] = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP, + [WP_ACCESS_READ_EX] = 0, + [WP_ACCESS_WRITE_EX] = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP, + [WP_ACCESS_APPEND_EX] = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP, + [WP_ACCESS_WRITE_FAIL_ON_EXIST] = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP, + [WP_ACCESS_WRITE_FAIL_ON_EXIST_EX] = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP, }; -wapp_intern i32 file_seek_origins[FILE_SEEK_ORIGIN_COUNT] = { - [WAPP_SEEK_START] = SEEK_SET, - [WAPP_SEEK_CURRENT] = SEEK_CUR, - [WAPP_SEEK_END] = SEEK_END, +wp_intern i32 file_seek_origins[COUNT_FILE_SEEK_ORIGIN] = { + [WP_SEEK_START] = SEEK_SET, + [WP_SEEK_CURRENT] = SEEK_CUR, + [WP_SEEK_END] = SEEK_END, }; -WFile *wapp_file_stdin(void) { - wapp_persist WFile _stdin = { .fd = STDIN_FILENO }; +WpFile *wpFileStdin(void) { + wp_persist WpFile _stdin = { .fd = STDIN_FILENO }; return &_stdin; } -WFile *wapp_file_stdout(void) { - wapp_persist WFile _stdout = { .fd = STDOUT_FILENO }; +WpFile *wpFileStdout(void) { + wp_persist WpFile _stdout = { .fd = STDOUT_FILENO }; return &_stdout; } -WFile *wapp_file_stderr(void) { - wapp_persist WFile _stderr = { .fd = STDERR_FILENO }; +WpFile *wpFileStderr(void) { + wp_persist WpFile _stderr = { .fd = STDERR_FILENO }; return &_stderr; } -WFile *_file_open(const Allocator *allocator, Str8RO *filepath, FileAccessMode mode) { - wapp_persist c8 tmp[WAPP_PATH_MAX] = {0}; - memset(tmp, 0, WAPP_PATH_MAX); +WpFile *_fileOpen(const WpAllocator *allocator, WpStr8RO *filepath, WpFileAccessMode mode) { + wp_persist c8 tmp[WP_PATH_MAX] = {0}; + memset(tmp, 0, WP_PATH_MAX); memcpy(tmp, filepath->buf, filepath->size); i32 fd = open((const char *)tmp, file_flags[mode], file_modes[mode]); @@ -74,7 +74,7 @@ WFile *_file_open(const Allocator *allocator, Str8RO *filepath, FileAccessMode m return NULL; } - WFile *output = wapp_mem_allocator_alloc(allocator, sizeof(WFile)); + WpFile *output = wpMemAllocatorAlloc(allocator, sizeof(WpFile)); if (output) { output->fd = fd; } @@ -82,11 +82,11 @@ WFile *_file_open(const Allocator *allocator, Str8RO *filepath, FileAccessMode m return output; } -i64 _file_seek(WFile *file, i64 offset, FileSeekOrigin origin) { +i64 _fileSeek(WpFile *file, i64 offset, WpFileSeekOrigin origin) { return lseek64(file->fd, offset, file_seek_origins[origin]); } -u64 _file_read(void *dst_buf, u64 byte_count, WFile *file, u64 file_length) { +u64 _fileRead(void *dst_buf, u64 byte_count, WpFile *file, u64 file_length) { u64 copy_byte_count = file_length <= byte_count ? file_length : byte_count; i64 count = read(file->fd, dst_buf, copy_byte_count); @@ -95,40 +95,40 @@ u64 _file_read(void *dst_buf, u64 byte_count, WFile *file, u64 file_length) { return count; } -i64 _file_write(const void *src_buf, WFile *file, u64 byte_count) { +i64 _fileWrite(const void *src_buf, WpFile *file, u64 byte_count) { return write(file->fd, src_buf, byte_count); } -i32 _file_flush(WFile *file) { +i32 _fileFlush(WpFile *file) { return fsync(file->fd); } -i32 _file_close(WFile *file) { +i32 _fileClose(WpFile *file) { return close(file->fd); } -i32 _file_rename(Str8RO *old_filepath, Str8RO *new_filepath) { - wapp_persist c8 old_tmp[WAPP_PATH_MAX] = {0}; - wapp_persist c8 new_tmp[WAPP_PATH_MAX] = {0}; - memset(old_tmp, 0, WAPP_PATH_MAX); +i32 _fileRename(WpStr8RO *old_filepath, WpStr8RO *new_filepath) { + wp_persist c8 old_tmp[WP_PATH_MAX] = {0}; + wp_persist c8 new_tmp[WP_PATH_MAX] = {0}; + memset(old_tmp, 0, WP_PATH_MAX); memcpy(old_tmp, old_filepath->buf, old_filepath->size); - memset(new_tmp, 0, WAPP_PATH_MAX); + memset(new_tmp, 0, WP_PATH_MAX); memcpy(new_tmp, new_filepath->buf, new_filepath->size); i32 link_result = link((const char *)old_tmp, (const char *)new_tmp); if (link_result == 0) { - _file_remove(old_filepath); + _fileRemove(old_filepath); } return link_result; } -i32 _file_remove(Str8RO *filepath) { - wapp_persist c8 tmp[WAPP_PATH_MAX] = {0}; - memset(tmp, 0, WAPP_PATH_MAX); +i32 _fileRemove(WpStr8RO *filepath) { + wp_persist c8 tmp[WP_PATH_MAX] = {0}; + memset(tmp, 0, WP_PATH_MAX); memcpy(tmp, filepath->buf, filepath->size); return unlink((const char *)tmp); } -#endif // !WAPP_PLATFORM_POSIX +#endif // !WP_PLATFORM_POSIX diff --git a/src/os/file/posix/file_posix.h b/src/os/file/posix/file_posix.h index 46a38ed..47c8036 100644 --- a/src/os/file/posix/file_posix.h +++ b/src/os/file/posix/file_posix.h @@ -6,22 +6,22 @@ #include "../../../common/aliases/aliases.h" #include "../../../common/platform/platform.h" -#ifdef WAPP_PLATFORM_CPP +#ifdef WP_PLATFORM_CPP BEGIN_C_LINKAGE -#endif // !WAPP_PLATFORM_CPP +#endif // !WP_PLATFORM_CPP -#ifdef WAPP_PLATFORM_POSIX +#ifdef WP_PLATFORM_POSIX -#define END_OF_LINE "\n" +#define WP_END_OF_LINE "\n" -struct WFile { +struct WpFile { i32 fd; }; -#endif // !WAPP_PLATFORM_POSIX +#endif // !WP_PLATFORM_POSIX -#ifdef WAPP_PLATFORM_CPP +#ifdef WP_PLATFORM_CPP END_C_LINKAGE -#endif // !WAPP_PLATFORM_CPP +#endif // !WP_PLATFORM_CPP #endif // !FILE_POSIX_H diff --git a/src/os/file/win/file_win.c b/src/os/file/win/file_win.c index 8f40778..0c4dd09 100644 --- a/src/os/file/win/file_win.c +++ b/src/os/file/win/file_win.c @@ -3,7 +3,7 @@ #include "file_win.h" #include "../../../common/platform/platform.h" -#ifdef WAPP_PLATFORM_WINDOWS +#ifdef WP_PLATFORM_WINDOWS #include "../file.h" #include "../../cpath/cpath.h" @@ -15,66 +15,66 @@ #include #include -wapp_intern DWORD file_accesses[FILE_ACCESS_MODE_COUNT] = { - [WAPP_ACCESS_READ] = FILE_READ_DATA, - [WAPP_ACCESS_WRITE] = FILE_WRITE_DATA, - [WAPP_ACCESS_APPEND] = FILE_APPEND_DATA, - [WAPP_ACCESS_READ_EX] = FILE_READ_DATA | FILE_WRITE_DATA, - [WAPP_ACCESS_WRITE_EX] = FILE_READ_DATA | FILE_WRITE_DATA, - [WAPP_ACCESS_APPEND_EX] = FILE_READ_DATA | FILE_APPEND_DATA, - [WAPP_ACCESS_WRITE_FAIL_ON_EXIST] = FILE_WRITE_DATA, - [WAPP_ACCESS_WRITE_FAIL_ON_EXIST_EX] = FILE_READ_DATA | FILE_WRITE_DATA, +wp_intern DWORD file_accesses[COUNT_FILE_ACCESS_MODE] = { + [WP_ACCESS_READ] = FILE_READ_DATA, + [WP_ACCESS_WRITE] = FILE_WRITE_DATA, + [WP_ACCESS_APPEND] = FILE_APPEND_DATA, + [WP_ACCESS_READ_EX] = FILE_READ_DATA | FILE_WRITE_DATA, + [WP_ACCESS_WRITE_EX] = FILE_READ_DATA | FILE_WRITE_DATA, + [WP_ACCESS_APPEND_EX] = FILE_READ_DATA | FILE_APPEND_DATA, + [WP_ACCESS_WRITE_FAIL_ON_EXIST] = FILE_WRITE_DATA, + [WP_ACCESS_WRITE_FAIL_ON_EXIST_EX] = FILE_READ_DATA | FILE_WRITE_DATA, }; -wapp_intern DWORD creation_dispositions[FILE_ACCESS_MODE_COUNT] = { - [WAPP_ACCESS_READ] = OPEN_EXISTING, - [WAPP_ACCESS_WRITE] = CREATE_ALWAYS, - [WAPP_ACCESS_APPEND] = OPEN_ALWAYS, - [WAPP_ACCESS_READ_EX] = OPEN_EXISTING, - [WAPP_ACCESS_WRITE_EX] = CREATE_ALWAYS, - [WAPP_ACCESS_APPEND_EX] = OPEN_ALWAYS, - [WAPP_ACCESS_WRITE_FAIL_ON_EXIST] = CREATE_NEW, - [WAPP_ACCESS_WRITE_FAIL_ON_EXIST_EX] = CREATE_NEW, +wp_intern DWORD creation_dispositions[COUNT_FILE_ACCESS_MODE] = { + [WP_ACCESS_READ] = OPEN_EXISTING, + [WP_ACCESS_WRITE] = CREATE_ALWAYS, + [WP_ACCESS_APPEND] = OPEN_ALWAYS, + [WP_ACCESS_READ_EX] = OPEN_EXISTING, + [WP_ACCESS_WRITE_EX] = CREATE_ALWAYS, + [WP_ACCESS_APPEND_EX] = OPEN_ALWAYS, + [WP_ACCESS_WRITE_FAIL_ON_EXIST] = CREATE_NEW, + [WP_ACCESS_WRITE_FAIL_ON_EXIST_EX] = CREATE_NEW, }; -wapp_intern DWORD sharing_modes[FILE_ACCESS_MODE_COUNT] = { - [WAPP_ACCESS_READ] = FILE_SHARE_READ | FILE_SHARE_WRITE, - [WAPP_ACCESS_WRITE] = FILE_SHARE_READ, - [WAPP_ACCESS_APPEND] = FILE_SHARE_READ, - [WAPP_ACCESS_READ_EX] = FILE_SHARE_READ | FILE_SHARE_WRITE, - [WAPP_ACCESS_WRITE_EX] = FILE_SHARE_READ, - [WAPP_ACCESS_APPEND_EX] = FILE_SHARE_READ, - [WAPP_ACCESS_WRITE_FAIL_ON_EXIST] = FILE_SHARE_READ, - [WAPP_ACCESS_WRITE_FAIL_ON_EXIST_EX] = FILE_SHARE_READ, +wp_intern DWORD sharing_modes[COUNT_FILE_ACCESS_MODE] = { + [WP_ACCESS_READ] = FILE_SHARE_READ | FILE_SHARE_WRITE, + [WP_ACCESS_WRITE] = FILE_SHARE_READ, + [WP_ACCESS_APPEND] = FILE_SHARE_READ, + [WP_ACCESS_READ_EX] = FILE_SHARE_READ | FILE_SHARE_WRITE, + [WP_ACCESS_WRITE_EX] = FILE_SHARE_READ, + [WP_ACCESS_APPEND_EX] = FILE_SHARE_READ, + [WP_ACCESS_WRITE_FAIL_ON_EXIST] = FILE_SHARE_READ, + [WP_ACCESS_WRITE_FAIL_ON_EXIST_EX] = FILE_SHARE_READ, }; -wapp_intern DWORD file_seek_origins[FILE_SEEK_ORIGIN_COUNT] = { - [WAPP_SEEK_START] = FILE_BEGIN, - [WAPP_SEEK_CURRENT] = FILE_CURRENT, - [WAPP_SEEK_END] = FILE_END, +wp_intern DWORD file_seek_origins[COUNT_FILE_SEEK_ORIGIN] = { + [WP_SEEK_START] = FILE_BEGIN, + [WP_SEEK_CURRENT] = FILE_CURRENT, + [WP_SEEK_END] = FILE_END, }; -WFile *wapp_file_stdin(void) { - wapp_persist WFile _stdin = { .fh = INVALID_HANDLE_VALUE }; +WpFile *wpFileStdin(void) { + wp_persist WpFile _stdin = { .fh = INVALID_HANDLE_VALUE }; _stdin.fh = GetStdHandle(STD_INPUT_HANDLE); return &_stdin; } -WFile *wapp_file_stdout(void) { - wapp_persist WFile _stdout = { .fh = INVALID_HANDLE_VALUE }; +WpFile *wpFileStdout(void) { + wp_persist WpFile _stdout = { .fh = INVALID_HANDLE_VALUE }; _stdout.fh = GetStdHandle(STD_OUTPUT_HANDLE); return &_stdout; } -WFile *wapp_file_stderr(void) { - wapp_persist WFile _stderr = { .fh = INVALID_HANDLE_VALUE }; +WpFile *wpFileStderr(void) { + wp_persist WpFile _stderr = { .fh = INVALID_HANDLE_VALUE }; _stderr.fh = GetStdHandle(STD_ERROR_HANDLE); return &_stderr; } -WFile *_file_open(const Allocator *allocator, Str8RO *filepath, FileAccessMode mode) { - wapp_persist c8 tmp[WAPP_PATH_MAX] = {0}; - memset(tmp, 0, WAPP_PATH_MAX); +WpFile *_fileOpen(const WpAllocator *allocator, WpStr8RO *filepath, WpFileAccessMode mode) { + wp_persist c8 tmp[WP_PATH_MAX] = {0}; + memset(tmp, 0, WP_PATH_MAX); memcpy(tmp, filepath->buf, filepath->size); HANDLE fh = CreateFileA((LPCSTR)tmp, @@ -88,7 +88,7 @@ WFile *_file_open(const Allocator *allocator, Str8RO *filepath, FileAccessMode m return NULL; } - WFile *output = wapp_mem_allocator_alloc(allocator, sizeof(WFile)); + WpFile *output = wpMemAllocatorAlloc(allocator, sizeof(WpFile)); if (output) { output->fh = fh; } @@ -96,7 +96,7 @@ WFile *_file_open(const Allocator *allocator, Str8RO *filepath, FileAccessMode m return output; } -i64 _file_seek(WFile *file, i64 offset, FileSeekOrigin origin) { +i64 _fileSeek(WpFile *file, i64 offset, WpFileSeekOrigin origin) { LARGE_INTEGER distance = {0}; LARGE_INTEGER output = {0}; @@ -109,9 +109,9 @@ i64 _file_seek(WFile *file, i64 offset, FileSeekOrigin origin) { return output.QuadPart; } -u64 _file_read(void* dst_buf, u64 byte_count, WFile* file, u64 file_length) { +u64 _fileRead(void* dst_buf, u64 byte_count, WpFile* file, u64 file_length) { u64 copy_byte_count = file_length <= byte_count ? file_length : byte_count; - wapp_debug_assert(copy_byte_count <= DWORD_MAX, "Attempting to read large number of bytes at once"); + wpDebugAssert(copy_byte_count <= DWORD_MAX, "Attempting to read large number of bytes at once"); DWORD read_count = 0; if (!ReadFile(file->fh, dst_buf, (DWORD)copy_byte_count, &read_count, NULL)) { @@ -121,8 +121,8 @@ u64 _file_read(void* dst_buf, u64 byte_count, WFile* file, u64 file_length) { return (u64)read_count; } -i64 _file_write(const void *src_buf, WFile *file, u64 byte_count) { - wapp_debug_assert(byte_count <= DWORD_MAX, "Attempting to write large number of bytes at once"); +i64 _fileWrite(const void *src_buf, WpFile *file, u64 byte_count) { + wpDebugAssert(byte_count <= DWORD_MAX, "Attempting to write large number of bytes at once"); DWORD write_count = 0; if (!WriteFile(file->fh, src_buf, (DWORD)byte_count, &write_count, NULL)) { @@ -131,7 +131,7 @@ i64 _file_write(const void *src_buf, WFile *file, u64 byte_count) { return (i64)write_count; } -i32 _file_flush(WFile *file) { +i32 _fileFlush(WpFile *file) { if (!FlushFileBuffers(file->fh)) { return -1; } @@ -139,7 +139,7 @@ i32 _file_flush(WFile *file) { return 0; } -i32 _file_close(WFile *file) { +i32 _fileClose(WpFile *file) { if (!CloseHandle(file->fh)) { return -1; } @@ -147,12 +147,12 @@ i32 _file_close(WFile *file) { return 0; } -i32 _file_rename(Str8RO *old_filepath, Str8RO *new_filepath) { - wapp_persist c8 old_tmp[WAPP_PATH_MAX] = {0}; - wapp_persist c8 new_tmp[WAPP_PATH_MAX] = {0}; - memset(old_tmp, 0, WAPP_PATH_MAX); +i32 _fileRename(WpStr8RO *old_filepath, WpStr8RO *new_filepath) { + wp_persist c8 old_tmp[WP_PATH_MAX] = {0}; + wp_persist c8 new_tmp[WP_PATH_MAX] = {0}; + memset(old_tmp, 0, WP_PATH_MAX); memcpy(old_tmp, old_filepath->buf, old_filepath->size); - memset(new_tmp, 0, WAPP_PATH_MAX); + memset(new_tmp, 0, WP_PATH_MAX); memcpy(new_tmp, new_filepath->buf, new_filepath->size); if (!MoveFile((LPCSTR)old_tmp, (LPCSTR)new_tmp)) { @@ -162,9 +162,9 @@ i32 _file_rename(Str8RO *old_filepath, Str8RO *new_filepath) { return 0; } -i32 _file_remove(Str8RO *filepath) { - wapp_persist c8 tmp[WAPP_PATH_MAX] = {0}; - memset(tmp, 0, WAPP_PATH_MAX); +i32 _fileRemove(WpStr8RO *filepath) { + wp_persist c8 tmp[WP_PATH_MAX] = {0}; + memset(tmp, 0, WP_PATH_MAX); memcpy(tmp, filepath->buf, filepath->size); if (!DeleteFile((LPCSTR)tmp)) { @@ -174,4 +174,4 @@ i32 _file_remove(Str8RO *filepath) { return 0; } -#endif // !WAPP_PLATFORM_WINDOWS +#endif // !WP_PLATFORM_WINDOWS diff --git a/src/os/file/win/file_win.h b/src/os/file/win/file_win.h index 69d579a..c6b2a4e 100644 --- a/src/os/file/win/file_win.h +++ b/src/os/file/win/file_win.h @@ -6,26 +6,26 @@ #include "../../../common/aliases/aliases.h" #include "../../../common/platform/platform.h" -#ifdef WAPP_PLATFORM_CPP +#ifdef WP_PLATFORM_CPP BEGIN_C_LINKAGE -#endif // !WAPP_PLATFORM_CPP +#endif // !WP_PLATFORM_CPP -#ifdef WAPP_PLATFORM_WINDOWS +#ifdef WP_PLATFORM_WINDOWS -#define END_OF_LINE "\r\n" +#define WP_END_OF_LINE "\r\n" #define WIN32_LEAN_AND_MEAN #include #include -struct WFile { +struct WpFile { HANDLE fh; }; -#endif // !WAPP_PLATFORM_WINDOWS +#endif // !WP_PLATFORM_WINDOWS -#ifdef WAPP_PLATFORM_CPP +#ifdef WP_PLATFORM_CPP END_C_LINKAGE -#endif // !WAPP_PLATFORM_CPP +#endif // !WP_PLATFORM_CPP #endif // !FILE_WIN_H diff --git a/src/os/mem/mem_os.c b/src/os/mem/mem_os.c index f8ddab5..792addf 100644 --- a/src/os/mem/mem_os.c +++ b/src/os/mem/mem_os.c @@ -7,24 +7,24 @@ #include #include -#if defined(WAPP_PLATFORM_WINDOWS) +#if defined(WP_PLATFORM_WINDOWS) #include "win/mem_os_win.h" -#elif defined(WAPP_PLATFORM_POSIX) +#elif defined(WP_PLATFORM_POSIX) #include "posix/mem_os_posix.h" #else #error "Unrecognised platform" #endif -void *wapp_os_mem_alloc(void *addr, u64 size, MemAccess access, MemAllocFlags flags, MemInitType type) { - void *output = os_mem_allocate(addr, size, access, flags, type); +void *wpOsMemAlloc(void *addr, u64 size, WpMemAccess access, WpMemAllocFlags flags, WpMemInitType type) { + void *output = _osMemAllocate(addr, size, access, flags, type); - if (type == WAPP_MEM_INIT_INITIALISED) { + if (type == WP_MEM_INIT_INITIALISED) { memset(output, 0, size); } return output; } -void wapp_os_mem_free(void *ptr, u64 size) { - os_mem_free(ptr, size); +void wpOsMemFree(void *ptr, u64 size) { + _osMemFree(ptr, size); } diff --git a/src/os/mem/mem_os.h b/src/os/mem/mem_os.h index 5681ef7..6ece5d4 100644 --- a/src/os/mem/mem_os.h +++ b/src/os/mem/mem_os.h @@ -8,26 +8,26 @@ #include "mem_os_ops.h" -#ifdef WAPP_PLATFORM_CPP +#ifdef WP_PLATFORM_CPP BEGIN_C_LINKAGE -#endif // !WAPP_PLATFORM_CPP +#endif // !WP_PLATFORM_CPP -#if defined(WAPP_PLATFORM_WINDOWS) +#if defined(WP_PLATFORM_WINDOWS) #include "win/mem_os_win.h" -#elif defined(WAPP_PLATFORM_POSIX) +#elif defined(WP_PLATFORM_POSIX) #include "posix/mem_os_posix.h" #else #error "Unrecognised platform" #endif -void *wapp_os_mem_alloc(void *addr, u64 size, MemAccess access, MemAllocFlags flags, MemInitType type); -void wapp_os_mem_free(void *ptr, u64 size); +void *wpOsMemAlloc(void *addr, u64 size, WpMemAccess access, WpMemAllocFlags flags, WpMemInitType type); +void wpOsMemFree(void *ptr, u64 size); -wapp_extern void *os_mem_allocate(void *addr, u64 size, MemAccess access, MemAllocFlags flags, MemInitType type); -wapp_extern void os_mem_free(void *ptr, u64 size); +wp_extern void *_osMemAllocate(void *addr, u64 size, WpMemAccess access, WpMemAllocFlags flags, WpMemInitType type); +wp_extern void _osMemFree(void *ptr, u64 size); -#ifdef WAPP_PLATFORM_CPP +#ifdef WP_PLATFORM_CPP END_C_LINKAGE -#endif // !WAPP_PLATFORM_CPP +#endif // !WP_PLATFORM_CPP #endif // !MEM_OS_H diff --git a/src/os/mem/mem_os_ops.h b/src/os/mem/mem_os_ops.h index 357a1af..8184e38 100644 --- a/src/os/mem/mem_os_ops.h +++ b/src/os/mem/mem_os_ops.h @@ -5,26 +5,26 @@ #include "../../common/platform/platform.h" -#ifdef WAPP_PLATFORM_CPP +#ifdef WP_PLATFORM_CPP BEGIN_C_LINKAGE -#endif // !WAPP_PLATFORM_CPP +#endif // !WP_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, -} MemAccess; +typedef enum { + WP_MEM_ACCESS_NONE, + WP_MEM_ACCESS_READ_ONLY, + WP_MEM_ACCESS_EXEC_ONLY, + WP_MEM_ACCESS_READ_WRITE, + WP_MEM_ACCESS_READ_EXEC, + WP_MEM_ACCESS_READ_WRITE_EXEC, +} WpMemAccess; -typedef enum mem_init_type { - WAPP_MEM_INIT_UNINITIALISED, - WAPP_MEM_INIT_INITIALISED, -} MemInitType; +typedef enum { + WP_MEM_INIT_UNINITIALISED, + WP_MEM_INIT_INITIALISED, +} WpMemInitType; -#ifdef WAPP_PLATFORM_CPP +#ifdef WP_PLATFORM_CPP END_C_LINKAGE -#endif // !WAPP_PLATFORM_CPP +#endif // !WP_PLATFORM_CPP #endif // !MEM_OS_OPS_H diff --git a/src/os/mem/posix/mem_os_posix.c b/src/os/mem/posix/mem_os_posix.c index 8143af2..23cddda 100644 --- a/src/os/mem/posix/mem_os_posix.c +++ b/src/os/mem/posix/mem_os_posix.c @@ -3,34 +3,34 @@ #include "../../../common/aliases/aliases.h" #include "../../../common/platform/platform.h" -#ifdef WAPP_PLATFORM_POSIX +#ifdef WP_PLATFORM_POSIX #include "mem_os_posix.h" #include "../mem_os_ops.h" #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, +wp_intern const i32 access_types[] = { + [WP_MEM_ACCESS_NONE] = PROT_NONE, + [WP_MEM_ACCESS_READ_ONLY] = PROT_READ, + [WP_MEM_ACCESS_EXEC_ONLY] = PROT_EXEC, + [WP_MEM_ACCESS_READ_WRITE] = PROT_READ | PROT_WRITE, + [WP_MEM_ACCESS_READ_EXEC] = PROT_READ | PROT_EXEC, + [WP_MEM_ACCESS_READ_WRITE_EXEC] = PROT_READ | PROT_WRITE | PROT_EXEC, }; -void *os_mem_allocate(void *addr, u64 size, MemAccess access, MemAllocFlags flags, MemInitType type) { +void *_osMemAllocate(void *addr, u64 size, WpMemAccess access, WpMemAllocFlags flags, WpMemInitType type) { (void)type; i32 alloc_flags = flags | MAP_ANON | MAP_PRIVATE; -#if defined(WAPP_PLATFORM_LINUX) || defined(WAPP_PLATFORM_GNU) || defined(WAPP_PLATFORM_NET_BSD) +#if defined(WP_PLATFORM_LINUX) || defined(WP_PLATFORM_GNU) || defined(WP_PLATFORM_NET_BSD) alloc_flags |= MAP_NORESERVE; #endif return mmap(addr, size, access_types[access], alloc_flags, -1, 0); } -void os_mem_free(void *ptr, u64 size) { +void _osMemFree(void *ptr, u64 size) { munmap(ptr, size); } -#endif // !WAPP_PLATFORM_POSIX +#endif // !WP_PLATFORM_POSIX diff --git a/src/os/mem/posix/mem_os_posix.h b/src/os/mem/posix/mem_os_posix.h index 967cc78..9f2805b 100644 --- a/src/os/mem/posix/mem_os_posix.h +++ b/src/os/mem/posix/mem_os_posix.h @@ -5,31 +5,31 @@ #include "../../../common/platform/platform.h" -#ifdef WAPP_PLATFORM_CPP +#ifdef WP_PLATFORM_CPP BEGIN_C_LINKAGE -#endif // !WAPP_PLATFORM_CPP +#endif // !WP_PLATFORM_CPP -#ifdef WAPP_PLATFORM_POSIX +#ifdef WP_PLATFORM_POSIX #include -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, -#elif defined(WAPP_PLATFORM_FREE_BSD) - 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, +typedef enum { +#if defined(WP_PLATFORM_LINUX) || defined(WP_PLATFORM_GNU) + WP_MEM_ALLOC_RESERVE = 0, + WP_MEM_ALLOC_COMMIT = MAP_POPULATE, +#elif defined(WP_PLATFORM_FREE_BSD) + WP_MEM_ALLOC_RESERVE = 0, + WP_MEM_ALLOC_COMMIT = MAP_PREFAULT_READ, +#elif defined(WP_PLATFORM_BSD) || defined(WP_PLATFORM_UNIX) || defined(WP_PLATFORM_APPLE) + WP_MEM_ALLOC_RESERVE = 0, + WP_MEM_ALLOC_COMMIT = 0, #endif -} MemAllocFlags; +} WpMemAllocFlags; -#endif // !WAPP_PLATFORM_POSIX +#endif // !WP_PLATFORM_POSIX -#ifdef WAPP_PLATFORM_CPP +#ifdef WP_PLATFORM_CPP END_C_LINKAGE -#endif // !WAPP_PLATFORM_CPP +#endif // !WP_PLATFORM_CPP #endif // !MEM_OS_POSIX_H diff --git a/src/os/mem/win/mem_os_win.c b/src/os/mem/win/mem_os_win.c index abfbe3b..a7e6e5f 100644 --- a/src/os/mem/win/mem_os_win.c +++ b/src/os/mem/win/mem_os_win.c @@ -3,7 +3,7 @@ #include "../../../common/aliases/aliases.h" #include "../../../common/platform/platform.h" -#ifdef WAPP_PLATFORM_WINDOWS +#ifdef WP_PLATFORM_WINDOWS #include "mem_os_win.h" #include "../mem_os_ops.h" @@ -12,26 +12,26 @@ #include #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, +wp_intern const i32 access_types[] = { + [WP_MEM_ACCESS_NONE] = PAGE_NOACCESS, + [WP_MEM_ACCESS_READ_ONLY] = PAGE_READONLY, + [WP_MEM_ACCESS_EXEC_ONLY] = PAGE_EXECUTE, + [WP_MEM_ACCESS_READ_WRITE] = PAGE_READWRITE, + [WP_MEM_ACCESS_READ_EXEC] = PAGE_EXECUTE_READ, + [WP_MEM_ACCESS_READ_WRITE_EXEC] = PAGE_EXECUTE_READWRITE, }; -void *os_mem_allocate(void *addr, u64 size, MemAccess access, MemAllocFlags flags, MemInitType type) { +void *_osMemAllocate(void *addr, u64 size, WpMemAccess access, WpMemAllocFlags flags, WpMemInitType type) { // Ensure memory is committed if it's meant to be initialised - if (type == WAPP_MEM_INIT_INITIALISED) { - flags |= WAPP_MEM_ALLOC_COMMIT; + if (type == WP_MEM_INIT_INITIALISED) { + flags |= WP_MEM_ALLOC_COMMIT; } return VirtualAlloc(addr, (SIZE_T)size, flags, access_types[access]); } -void os_mem_free(void *ptr, u64 size) { +void _osMemFree(void *ptr, u64 size) { VirtualFree(ptr, size, MEM_RELEASE); } -#endif // !WAPP_PLATFORM_WINDOWS +#endif // !WP_PLATFORM_WINDOWS diff --git a/src/os/mem/win/mem_os_win.h b/src/os/mem/win/mem_os_win.h index e0a63eb..229caad 100644 --- a/src/os/mem/win/mem_os_win.h +++ b/src/os/mem/win/mem_os_win.h @@ -5,25 +5,25 @@ #include "../../../common/platform/platform.h" -#ifdef WAPP_PLATFORM_CPP +#ifdef WP_PLATFORM_CPP BEGIN_C_LINKAGE -#endif // !WAPP_PLATFORM_CPP +#endif // !WP_PLATFORM_CPP -#ifdef WAPP_PLATFORM_WINDOWS +#ifdef WP_PLATFORM_WINDOWS #define WIN32_LEAN_AND_MEAN #include #include -typedef enum mem_alloc_flags { - WAPP_MEM_ALLOC_RESERVE = MEM_RESERVE, - WAPP_MEM_ALLOC_COMMIT = MEM_COMMIT, -} MemAllocFlags; +typedef enum { + WP_MEM_ALLOC_RESERVE = MEM_RESERVE, + WP_MEM_ALLOC_COMMIT = MEM_COMMIT, +} WpMemAllocFlags; -#endif // !WAPP_PLATFORM_WINDOWS +#endif // !WP_PLATFORM_WINDOWS -#ifdef WAPP_PLATFORM_CPP +#ifdef WP_PLATFORM_CPP END_C_LINKAGE -#endif // !WAPP_PLATFORM_CPP +#endif // !WP_PLATFORM_CPP #endif // !MEM_OS_WIN_H diff --git a/src/os/shell/commander/commander.c b/src/os/shell/commander/commander.c index b48c91a..476c202 100644 --- a/src/os/shell/commander/commander.c +++ b/src/os/shell/commander/commander.c @@ -17,85 +17,85 @@ #define CMD_BUF_LEN 8192 #define OUT_BUF_LEN 4096 -wapp_intern CMDResult execute_command(Str8RO *cmd, CMDOutHandling out_handling, Str8 *out_buf); -wapp_intern CMDError get_command_output(FILE *fp, CMDOutHandling out_handling, Str8 *out_buf); +wp_intern WpCmdResult executeCommand(WpStr8RO *cmd, WpCmdOutHandling out_handling, WpStr8 *out_buf); +wp_intern WpCmdError getCommandOutput(FILE *fp, WpCmdOutHandling out_handling, WpStr8 *out_buf); -CMDResult wapp_shell_commander_execute(CMDOutHandling out_handling, Str8 *out_buf, const Str8List *cmd) { +WpCmdResult wpShellCommanderExecute(WpCmdOutHandling out_handling, WpStr8 *out_buf, const WpStr8List *cmd) { if (!cmd) { - return CMD_NO_EXIT(SHELL_ERR_INVALID_ARGS); + return wpCmdNoExit(WP_SHELL_ERR_INVALID_ARGS); } - Allocator arena = wapp_mem_arena_allocator_init(KiB(500)); + WpAllocator arena = wpMemArenaAllocatorInit(KiB(500)); - Str8 *cmd_str = wapp_str8_join(&arena, cmd, &wapp_str8_lit_ro(" ")); + WpStr8 *cmd_str = wpStr8Join(&arena, cmd, &wpStr8LitRo(" ")); if (!cmd_str) { - wapp_mem_arena_allocator_destroy(&arena); - return CMD_NO_EXIT(SHELL_ERR_ALLOCATION_FAIL); + wpMemArenaAllocatorDestroy(&arena); + return wpCmdNoExit(WP_SHELL_ERR_ALLOCATION_FAIL); } // Redirect output - cmd_str = wapp_str8_alloc_concat(&arena, cmd_str, &wapp_str8_lit_ro(" 2>&1")); + cmd_str = wpStr8AllocConcat(&arena, cmd_str, &wpStr8LitRo(" 2>&1")); - CMDResult output = execute_command(cmd_str, out_handling, out_buf); + WpCmdResult output = executeCommand(cmd_str, out_handling, out_buf); - wapp_mem_arena_allocator_destroy(&arena); + wpMemArenaAllocatorDestroy(&arena); return output; } -wapp_intern CMDResult execute_command(Str8RO *cmd, CMDOutHandling out_handling, Str8 *out_buf) { +wp_intern WpCmdResult executeCommand(WpStr8RO *cmd, WpCmdOutHandling out_handling, WpStr8 *out_buf) { char cmd_buf[CMD_BUF_LEN] = {0}; - wapp_str8_copy_to_cstr(cmd_buf, cmd, CMD_BUF_LEN); + wpStr8CopyToCstr(cmd_buf, cmd, CMD_BUF_LEN); - FILE *fp = wapp_shell_utils_popen(cmd_buf, "r"); + FILE *fp = wpShellUtilsPopen(cmd_buf, "r"); if (!fp) { - return CMD_NO_EXIT(SHELL_ERR_PROC_START_FAIL); + return wpCmdNoExit(WP_SHELL_ERR_PROC_START_FAIL); } - CMDResult output; + WpCmdResult 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; + WpCmdError err = getCommandOutput(fp, out_handling, out_buf); + if (err > WP_SHELL_ERR_NO_ERROR) { + output = wpCmdNoExit(err); + goto executeCommand_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; + err = _getOutputStatus(fp, &st); + if (err > WP_SHELL_ERR_NO_ERROR) { + output = wpCmdNoExit(err); + goto executeCommand_CLOSE; } - // Process is already closed in get_output_status + // Process is already closed in _getOutputStatus fp = NULL; - output = (CMDResult){ + output = (WpCmdResult){ .exited = true, .exit_code = st, - .error = SHELL_ERR_NO_ERROR, + .error = WP_SHELL_ERR_NO_ERROR, }; -EXECUTE_COMMAND_CLOSE: +executeCommand_CLOSE: if (fp) { - wapp_shell_utils_pclose(fp); + wpShellUtilsPclose(fp); } return output; } -wapp_intern CMDError get_command_output(FILE *fp, CMDOutHandling out_handling, Str8 *out_buf) { - Str8 out = wapp_str8_buf(OUT_BUF_LEN); +wp_intern WpCmdError getCommandOutput(FILE *fp, WpCmdOutHandling out_handling, WpStr8 *out_buf) { + WpStr8 out = wpStr8Buf(OUT_BUF_LEN); out.size = fread((void *)out.buf, sizeof(c8), out.capacity, fp); - if (out_handling == SHELL_OUTPUT_CAPTURE && out_buf != NULL) { + if (out_handling == WP_SHELL_OUTPUT_CAPTURE && out_buf != NULL) { if (out.size >= out_buf->capacity) { - return SHELL_ERR_OUT_BUF_FULL; + return WP_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)); + wpStr8ConcatCapped(out_buf, &out); + } else if (out_handling == WP_SHELL_OUTPUT_PRINT) { + printf(WP_STR8_SPEC, wpStr8Varg(out)); } - return SHELL_ERR_NO_ERROR; + return WP_SHELL_ERR_NO_ERROR; } diff --git a/src/os/shell/commander/commander.h b/src/os/shell/commander/commander.h index b4c6f6f..891a4f4 100644 --- a/src/os/shell/commander/commander.h +++ b/src/os/shell/commander/commander.h @@ -12,18 +12,18 @@ // TODO (Abdelrahman): This module needs rethinking -#ifdef WAPP_PLATFORM_CPP +#ifdef WP_PLATFORM_CPP BEGIN_C_LINKAGE -#endif // !WAPP_PLATFORM_CPP +#endif // !WP_PLATFORM_CPP -#define CMD_NO_EXIT(ERR) ((CMDResult){.exited = false, .exit_code = EXIT_FAILURE, .error = ERR}) +#define wpCmdNoExit(ERR) ((WpCmdResult){.exited = false, .exit_code = EXIT_FAILURE, .error = ERR}) -CMDResult wapp_shell_commander_execute(CMDOutHandling out_handling, Str8 *out_buf, const Str8List *cmd); +WpCmdResult wpShellCommanderExecute(WpCmdOutHandling out_handling, WpStr8 *out_buf, const WpStr8List *cmd); -wapp_extern CMDError get_output_status(FILE *fp, i32 *status_out); +wp_extern WpCmdError _getOutputStatus(FILE *fp, i32 *status_out); -#ifdef WAPP_PLATFORM_CPP +#ifdef WP_PLATFORM_CPP END_C_LINKAGE -#endif // !WAPP_PLATFORM_CPP +#endif // !WP_PLATFORM_CPP #endif // !COMMANDER_H diff --git a/src/os/shell/commander/commander_output.h b/src/os/shell/commander/commander_output.h index fe45993..4d18d48 100644 --- a/src/os/shell/commander/commander_output.h +++ b/src/os/shell/commander/commander_output.h @@ -7,36 +7,36 @@ #include "../../../common/platform/platform.h" #include "../../../common/misc/misc_utils.h" -#ifdef WAPP_PLATFORM_CPP +#ifdef WP_PLATFORM_CPP BEGIN_C_LINKAGE -#endif // !WAPP_PLATFORM_CPP +#endif // !WP_PLATFORM_CPP typedef enum { - SHELL_OUTPUT_DISCARD, - SHELL_OUTPUT_PRINT, - SHELL_OUTPUT_CAPTURE, -} CMDOutHandling; + WP_SHELL_OUTPUT_DISCARD, + WP_SHELL_OUTPUT_PRINT, + WP_SHELL_OUTPUT_CAPTURE, +} WpCmdOutHandling; 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, -} CMDError; + WP_SHELL_ERR_NO_ERROR, + WP_SHELL_ERR_INVALID_ARGS, + WP_SHELL_ERR_ALLOCATION_FAIL, + WP_SHELL_ERR_PROC_START_FAIL, + WP_SHELL_ERR_OUT_BUF_FULL, + WP_SHELL_ERR_PROC_EXIT_FAIL, +} WpCmdError; -typedef struct CMDResult CMDResult; -struct CMDResult { +typedef struct WpCmdResult WpCmdResult; +struct WpCmdResult { i32 exit_code; - CMDError error; + WpCmdError error; b8 exited; - wapp_misc_utils_reserve_padding(sizeof(b8) + sizeof(i32) + sizeof(CMDError)); + wpMiscUtilsReservePadding(sizeof(b8) + sizeof(i32) + sizeof(WpCmdError)); }; -#ifdef WAPP_PLATFORM_CPP +#ifdef WP_PLATFORM_CPP END_C_LINKAGE -#endif // !WAPP_PLATFORM_CPP +#endif // !WP_PLATFORM_CPP #endif // !COMMANDER_OUTPUT_H diff --git a/src/os/shell/commander/posix/commander_posix.c b/src/os/shell/commander/posix/commander_posix.c index a25afb0..0b1069c 100644 --- a/src/os/shell/commander/posix/commander_posix.c +++ b/src/os/shell/commander/posix/commander_posix.c @@ -3,23 +3,23 @@ #include "../../../../common/aliases/aliases.h" #include "../../../../common/platform/platform.h" -#ifdef WAPP_PLATFORM_POSIX +#ifdef WP_PLATFORM_POSIX #include "../commander_output.h" #include "../../utils/shell_utils.h" #include #include -CMDError get_output_status(FILE *fp, i32 *status_out) { - *status_out = wapp_shell_utils_pclose(fp); +WpCmdError _getOutputStatus(FILE *fp, i32 *status_out) { + *status_out = wpShellUtilsPclose(fp); if (!WIFEXITED(*status_out)) { - return SHELL_ERR_PROC_EXIT_FAIL; + return WP_SHELL_ERR_PROC_EXIT_FAIL; } *status_out = WEXITSTATUS(*status_out); - return SHELL_ERR_NO_ERROR; + return WP_SHELL_ERR_NO_ERROR; } -#endif // !WAPP_PLATFORM_POSIX +#endif // !WP_PLATFORM_POSIX diff --git a/src/os/shell/commander/win/commander_win.c b/src/os/shell/commander/win/commander_win.c index 8be5df8..daf764e 100644 --- a/src/os/shell/commander/win/commander_win.c +++ b/src/os/shell/commander/win/commander_win.c @@ -3,22 +3,22 @@ #include "../../../../common/aliases/aliases.h" #include "../../../../common/platform/platform.h" -#ifdef WAPP_PLATFORM_WINDOWS +#ifdef WP_PLATFORM_WINDOWS #include "../commander_output.h" #include "../../utils/shell_utils.h" #include -CMDError get_output_status(FILE *fp, i32 *status_out) { +WpCmdError _getOutputStatus(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; + wpShellUtilsPclose(fp); + return WP_SHELL_ERR_PROC_EXIT_FAIL; } - *status_out = wapp_shell_utils_pclose(fp); + *status_out = wpShellUtilsPclose(fp); - return SHELL_ERR_NO_ERROR; + return WP_SHELL_ERR_NO_ERROR; } -#endif // !WAPP_PLATFORM_WINDOWS +#endif // !WP_PLATFORM_WINDOWS diff --git a/src/os/shell/termcolour/posix/termcolour_posix.c b/src/os/shell/termcolour/posix/termcolour_posix.c index 48f7964..4489d1e 100644 --- a/src/os/shell/termcolour/posix/termcolour_posix.c +++ b/src/os/shell/termcolour/posix/termcolour_posix.c @@ -4,33 +4,33 @@ #include "../../../../common/platform/platform.h" #include "../../../../base/strings/str8/str8.h" -#ifdef WAPP_PLATFORM_POSIX +#ifdef WP_PLATFORM_POSIX #include "../terminal_colours.h" #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"), +wp_intern WpStr8RO colours[COUNT_TERM_COLOUR] = { + [WP_TERM_COLOUR_FG_BLACK] = wpStr8LitRoInitialiserList("\033[30m"), + [WP_TERM_COLOUR_FG_RED] = wpStr8LitRoInitialiserList("\033[31m"), + [WP_TERM_COLOUR_FG_GREEN] = wpStr8LitRoInitialiserList("\033[32m"), + [WP_TERM_COLOUR_FG_BLUE] = wpStr8LitRoInitialiserList("\033[34m"), + [WP_TERM_COLOUR_FG_CYAN] = wpStr8LitRoInitialiserList("\033[36m"), + [WP_TERM_COLOUR_FG_MAGENTA] = wpStr8LitRoInitialiserList("\033[35m"), + [WP_TERM_COLOUR_FG_YELLOW] = wpStr8LitRoInitialiserList("\033[33m"), + [WP_TERM_COLOUR_FG_WHITE] = wpStr8LitRoInitialiserList("\033[37m"), + [WP_TERM_COLOUR_FG_BR_BLACK] = wpStr8LitRoInitialiserList("\033[90m"), + [WP_TERM_COLOUR_FG_BR_RED] = wpStr8LitRoInitialiserList("\033[91m"), + [WP_TERM_COLOUR_FG_BR_GREEN] = wpStr8LitRoInitialiserList("\033[92m"), + [WP_TERM_COLOUR_FG_BR_BLUE] = wpStr8LitRoInitialiserList("\033[94m"), + [WP_TERM_COLOUR_FG_BR_CYAN] = wpStr8LitRoInitialiserList("\033[96m"), + [WP_TERM_COLOUR_FG_BR_MAGENTA] = wpStr8LitRoInitialiserList("\033[95m"), + [WP_TERM_COLOUR_FG_BR_YELLOW] = wpStr8LitRoInitialiserList("\033[93m"), + [WP_TERM_COLOUR_FG_BR_WHITE] = wpStr8LitRoInitialiserList("\033[97m"), + [WP_TERM_COLOUR_CLEAR] = wpStr8LitRoInitialiserList("\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))); +void _printColouredText(WpStr8RO *text, WpTerminalColour colour) { + printf(WP_STR8_SPEC WP_STR8_SPEC, wpStr8Varg(colours[colour]), wpStr8Varg((*text))); } -#endif // !WAPP_PLATFORM_POSIX +#endif // !WP_PLATFORM_POSIX diff --git a/src/os/shell/termcolour/termcolour.c b/src/os/shell/termcolour/termcolour.c index 9b5a566..a3da8fb 100644 --- a/src/os/shell/termcolour/termcolour.c +++ b/src/os/shell/termcolour/termcolour.c @@ -4,15 +4,15 @@ #include "terminal_colours.h" #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) { +void wpShellTermcolourPrintText(WpStr8RO *text, WpTerminalColour colour) { + if (colour < WP_TERM_COLOUR_FG_BLACK || colour > WP_TERM_COLOUR_FG_BR_WHITE) { return; } - print_coloured_text(text, colour); + _printColouredText(text, colour); } -void wapp_shell_termcolour_clear_colour(void) { - Str8RO empty = wapp_str8_lit_ro(""); - print_coloured_text(&empty, WAPP_TERM_COLOUR_CLEAR); +void wpShellTermcolourClearColour(void) { + WpStr8RO empty = wpStr8LitRo(""); + _printColouredText(&empty, WP_TERM_COLOUR_CLEAR); } diff --git a/src/os/shell/termcolour/termcolour.h b/src/os/shell/termcolour/termcolour.h index 24076b1..9343da4 100644 --- a/src/os/shell/termcolour/termcolour.h +++ b/src/os/shell/termcolour/termcolour.h @@ -8,19 +8,19 @@ #include "../../../common/platform/platform.h" #include "../../../base/strings/str8/str8.h" -#ifdef WAPP_PLATFORM_CPP +#ifdef WP_PLATFORM_CPP BEGIN_C_LINKAGE -#endif // !WAPP_PLATFORM_CPP +#endif // !WP_PLATFORM_CPP // TODO (Abdelrahman): Look into moving away from stdio in the implementation -void wapp_shell_termcolour_print_text(Str8RO *text, TerminalColour colour); -void wapp_shell_termcolour_clear_colour(void); +void wpShellTermcolourPrintText(WpStr8RO *text, WpTerminalColour colour); +void wpShellTermcolourClearColour(void); -wapp_extern void print_coloured_text(Str8RO *text, TerminalColour colour); +wp_extern void _printColouredText(WpStr8RO *text, WpTerminalColour colour); -#ifdef WAPP_PLATFORM_CPP +#ifdef WP_PLATFORM_CPP END_C_LINKAGE -#endif // !WAPP_PLATFORM_CPP +#endif // !WP_PLATFORM_CPP #endif // !TERM_COLOUR_H diff --git a/src/os/shell/termcolour/terminal_colours.h b/src/os/shell/termcolour/terminal_colours.h index 8e864e6..6c1a328 100644 --- a/src/os/shell/termcolour/terminal_colours.h +++ b/src/os/shell/termcolour/terminal_colours.h @@ -6,34 +6,34 @@ #include "../../../common/aliases/aliases.h" #include "../../../common/platform/platform.h" -#ifdef WAPP_PLATFORM_CPP +#ifdef WP_PLATFORM_CPP BEGIN_C_LINKAGE -#endif // !WAPP_PLATFORM_CPP +#endif // !WP_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, + WP_TERM_COLOUR_FG_BLACK, + WP_TERM_COLOUR_FG_RED, + WP_TERM_COLOUR_FG_GREEN, + WP_TERM_COLOUR_FG_BLUE, + WP_TERM_COLOUR_FG_CYAN, + WP_TERM_COLOUR_FG_MAGENTA, + WP_TERM_COLOUR_FG_YELLOW, + WP_TERM_COLOUR_FG_WHITE, + WP_TERM_COLOUR_FG_BR_BLACK, + WP_TERM_COLOUR_FG_BR_RED, + WP_TERM_COLOUR_FG_BR_GREEN, + WP_TERM_COLOUR_FG_BR_BLUE, + WP_TERM_COLOUR_FG_BR_CYAN, + WP_TERM_COLOUR_FG_BR_MAGENTA, + WP_TERM_COLOUR_FG_BR_YELLOW, + WP_TERM_COLOUR_FG_BR_WHITE, + WP_TERM_COLOUR_CLEAR, COUNT_TERM_COLOUR, -} TerminalColour; +} WpTerminalColour; -#ifdef WAPP_PLATFORM_CPP +#ifdef WP_PLATFORM_CPP END_C_LINKAGE -#endif // !WAPP_PLATFORM_CPP +#endif // !WP_PLATFORM_CPP #endif // !TERMINAL_COLOURS_H diff --git a/src/os/shell/termcolour/win/termcolour_win.c b/src/os/shell/termcolour/win/termcolour_win.c index f3c5609..af8e911 100644 --- a/src/os/shell/termcolour/win/termcolour_win.c +++ b/src/os/shell/termcolour/win/termcolour_win.c @@ -4,7 +4,7 @@ #include "../../../../common/platform/platform.h" #include "../../../../base/strings/str8/str8.h" -#ifdef WAPP_PLATFORM_WINDOWS +#ifdef WP_PLATFORM_WINDOWS #include "../terminal_colours.h" #include "../../../../common/misc/misc_utils.h" @@ -19,47 +19,47 @@ struct TermcolourData { WORD default_colour; WORD current_colour; - wapp_misc_utils_reserve_padding(sizeof(HANDLE) + sizeof(WORD) + sizeof(WORD)); + wpMiscUtilsReservePadding(sizeof(HANDLE) + sizeof(WORD) + sizeof(WORD)); }; -wapp_intern void init_data(TermcolourData *data); +wp_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, +wp_intern WORD colours[COUNT_TERM_COLOUR] = { + [WP_TERM_COLOUR_FG_BLACK] = 0, + [WP_TERM_COLOUR_FG_RED] = FOREGROUND_RED, + [WP_TERM_COLOUR_FG_GREEN] = FOREGROUND_GREEN, + [WP_TERM_COLOUR_FG_BLUE] = FOREGROUND_BLUE, + [WP_TERM_COLOUR_FG_CYAN] = FOREGROUND_GREEN | FOREGROUND_BLUE, + [WP_TERM_COLOUR_FG_MAGENTA] = FOREGROUND_RED | FOREGROUND_BLUE, + [WP_TERM_COLOUR_FG_YELLOW] = FOREGROUND_RED | FOREGROUND_GREEN, + [WP_TERM_COLOUR_FG_WHITE] = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE, + [WP_TERM_COLOUR_FG_BR_BLACK] = FOREGROUND_INTENSITY, + [WP_TERM_COLOUR_FG_BR_RED] = FOREGROUND_RED | FOREGROUND_INTENSITY, + [WP_TERM_COLOUR_FG_BR_GREEN] = FOREGROUND_GREEN | FOREGROUND_INTENSITY, + [WP_TERM_COLOUR_FG_BR_BLUE] = FOREGROUND_BLUE | FOREGROUND_INTENSITY, + [WP_TERM_COLOUR_FG_BR_CYAN] = FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_INTENSITY, + [WP_TERM_COLOUR_FG_BR_MAGENTA] = FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_INTENSITY, + [WP_TERM_COLOUR_FG_BR_YELLOW] = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY, + [WP_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}; +void _printColouredText(WpStr8RO *text, WpTerminalColour colour) { + wp_persist TermcolourData data = {0}; if (data.handle == 0) { init_data(&data); } - if (colour == WAPP_TERM_COLOUR_CLEAR) { + if (colour == WP_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))); + printf(WP_STR8_SPEC, wpStr8Varg((*text))); } -wapp_intern void init_data(TermcolourData *data) { +wp_intern void init_data(TermcolourData *data) { // create handle data->handle = GetStdHandle(STD_OUTPUT_HANDLE); @@ -70,4 +70,4 @@ wapp_intern void init_data(TermcolourData *data) { data->current_colour = data->default_colour; } -#endif // !WAPP_PLATFORM_WINDOWS +#endif // !WP_PLATFORM_WINDOWS diff --git a/src/os/shell/utils/shell_utils.h b/src/os/shell/utils/shell_utils.h index a9d8195..20a94ed 100644 --- a/src/os/shell/utils/shell_utils.h +++ b/src/os/shell/utils/shell_utils.h @@ -7,20 +7,20 @@ #include "../../../common/platform/platform.h" #include -#ifdef WAPP_PLATFORM_CPP +#ifdef WP_PLATFORM_CPP BEGIN_C_LINKAGE -#endif // !WAPP_PLATFORM_CPP +#endif // !WP_PLATFORM_CPP -#ifdef WAPP_PLATFORM_WINDOWS - #define wapp_shell_utils_popen _popen - #define wapp_shell_utils_pclose _pclose +#ifdef WP_PLATFORM_WINDOWS + #define wpShellUtilsPopen _popen + #define wpShellUtilsPclose _pclose #else - #define wapp_shell_utils_popen popen - #define wapp_shell_utils_pclose pclose -#endif /* ifdef WAPP_PLATFORM_WINDOWS */ + #define wpShellUtilsPopen popen + #define wpShellUtilsPclose pclose +#endif /* ifdef WP_PLATFORM_WINDOWS */ -#ifdef WAPP_PLATFORM_CPP +#ifdef WP_PLATFORM_CPP END_C_LINKAGE -#endif // !WAPP_PLATFORM_CPP +#endif // !WP_PLATFORM_CPP #endif // !SHELL_UTILS_H diff --git a/src/prng/xorshift/xorshift.c b/src/prng/xorshift/xorshift.c index d681924..b41d5c2 100644 --- a/src/prng/xorshift/xorshift.c +++ b/src/prng/xorshift/xorshift.c @@ -12,13 +12,13 @@ struct SplitMix64State { u64 seed; }; -wapp_intern u64 rol64(u64 x, u64 bits); -wapp_intern u64 split_mix_64(SplitMix64State *state); -wapp_intern void seed_os_generator(void); -wapp_intern u64 generate_random_number(void); +wp_intern u64 rol64(u64 x, u64 bits); +wp_intern u64 split_mix_64(SplitMix64State *state); +wp_intern void seed_os_generator(void); +wp_intern u64 generate_random_number(void); -XOR256State wapp_prng_xorshift_init_state(void) { - wapp_persist b8 seeded = false; +WpXor256State wpPrngXorshiftInit(void) { + wp_persist b8 seeded = false; if (!seeded) { seeded = true; seed_os_generator(); @@ -26,7 +26,7 @@ XOR256State wapp_prng_xorshift_init_state(void) { SplitMix64State sm64 = {.seed = generate_random_number()}; - return (XOR256State){ + return (WpXor256State){ .x = split_mix_64(&sm64), .y = split_mix_64(&sm64), .z = split_mix_64(&sm64), @@ -34,7 +34,7 @@ XOR256State wapp_prng_xorshift_init_state(void) { }; } -u64 wapp_prng_xorshift_256(XOR256State *state) { +u64 wpPrngXorshift256(WpXor256State *state) { u64 t = state->x ^ (state->x << 11); state->x = state->y; @@ -45,7 +45,7 @@ u64 wapp_prng_xorshift_256(XOR256State *state) { return state->w; } -u64 wapp_prng_xorshift_256ss(XOR256State *state) { +u64 wpPrngXorshift256ss(WpXor256State *state) { const u64 result = rol64(state->z * 5, 7) * 9; const u64 t = state->z << 17; @@ -60,7 +60,7 @@ u64 wapp_prng_xorshift_256ss(XOR256State *state) { return result; } -u64 wapp_prng_xorshift_256p(XOR256State *state) { +u64 wpPrngXorshift256p(WpXor256State *state) { const u64 result = state->w + state->x; const u64 t = state->z << 17; @@ -75,11 +75,11 @@ u64 wapp_prng_xorshift_256p(XOR256State *state) { return result; } -wapp_intern u64 rol64(u64 x, u64 bits) { +wp_intern u64 rol64(u64 x, u64 bits) { return (x << bits) | (x >> (64 - bits)); } -wapp_intern u64 split_mix_64(SplitMix64State *state) { +wp_intern u64 split_mix_64(SplitMix64State *state) { state->seed += 0x9E3779B97f4A7C15; u64 result = state->seed; @@ -89,47 +89,47 @@ wapp_intern u64 split_mix_64(SplitMix64State *state) { 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) { +#if defined(WP_PLATFORM_C) && WP_PLATFORM_C_VERSION >= WP_PLATFORM_C11_VERSION +#ifdef WP_PLATFORM_POSIX +wp_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"); + wpRuntimeAssert(result == 0, "Invalid seed value"); srand48(ts.tv_nsec); } -wapp_intern u64 generate_random_number(void) { +wp_intern u64 generate_random_number(void) { return lrand48(); } #else -wapp_intern void seed_os_generator(void) { +wp_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"); + wpRuntimeAssert(result != 0, "Invalid seed value"); srand(ts.tv_nsec); } -wapp_intern u64 generate_random_number(void) { +wp_intern u64 generate_random_number(void) { i32 n1 = rand(); i32 n2 = rand(); return (((u64)n1) << 32 | (u64)n2); } -#endif // !WAPP_PLATFORM_POSIX +#endif // !WP_PLATFORM_POSIX #else -wapp_intern void seed_os_generator(void) { +wp_intern void seed_os_generator(void) { time_t result = time(NULL); - wapp_runtime_assert(result != (time_t)(-1), "Invalid seed value"); + wpRuntimeAssert(result != (time_t)(-1), "Invalid seed value"); srand(result); } -wapp_intern u64 generate_random_number(void) { +wp_intern u64 generate_random_number(void) { i32 n1 = rand(); i32 n2 = rand(); return (((u64)n1) << 32 | (u64)n2); } -#endif // !WAPP_PLATFORM_C +#endif // !WP_PLATFORM_C diff --git a/src/prng/xorshift/xorshift.h b/src/prng/xorshift/xorshift.h index 7a66d05..48258cb 100644 --- a/src/prng/xorshift/xorshift.h +++ b/src/prng/xorshift/xorshift.h @@ -6,25 +6,25 @@ #include "../../common/aliases/aliases.h" #include "../../common/platform/platform.h" -#ifdef WAPP_PLATFORM_CPP +#ifdef WP_PLATFORM_CPP BEGIN_C_LINKAGE -#endif // !WAPP_PLATFORM_CPP +#endif // !WP_PLATFORM_CPP -typedef struct XOR256State XOR256State; -struct XOR256State { +typedef struct WpXor256State WpXor256State; +struct WpXor256State { u64 x; u64 y; u64 z; u64 w; }; -XOR256State wapp_prng_xorshift_init_state(void); -u64 wapp_prng_xorshift_256(XOR256State *state); -u64 wapp_prng_xorshift_256ss(XOR256State *state); -u64 wapp_prng_xorshift_256p(XOR256State *state); +WpXor256State wpPrngXorshiftInit(void); +u64 wpPrngXorshift256(WpXor256State *state); +u64 wpPrngXorshift256ss(WpXor256State *state); +u64 wpPrngXorshift256p(WpXor256State *state); -#ifdef WAPP_PLATFORM_CPP +#ifdef WP_PLATFORM_CPP END_C_LINKAGE -#endif // !WAPP_PLATFORM_CPP +#endif // !WP_PLATFORM_CPP #endif // !XORSHIFT_H diff --git a/src/testing/tester/tester.c b/src/testing/tester/tester.c index fc8773b..d80e534 100644 --- a/src/testing/tester/tester.c +++ b/src/testing/tester/tester.c @@ -8,23 +8,23 @@ #include #include -wapp_intern void handle_test_result(TestFuncResult result); +wp_intern void handleTestResult(WpTestFuncResult result); -void run_tests(TestFunc *func1, ...) { +void _runTests(WpTestFunc *func1, ...) { printf("\n"); - handle_test_result(func1()); + handleTestResult(func1()); va_list args; va_start(args, func1); - TestFunc *func = va_arg(args, TestFunc *); + WpTestFunc *func = va_arg(args, WpTestFunc *); while (func) { - TestFuncResult result = func(); - handle_test_result(result); + WpTestFuncResult result = func(); + handleTestResult(result); - func = va_arg(args, TestFunc *); + func = va_arg(args, WpTestFunc *); } va_end(args); @@ -32,22 +32,22 @@ void run_tests(TestFunc *func1, ...) { printf("\n"); } -wapp_intern void handle_test_result(TestFuncResult result) { - TerminalColour colour; - Str8 result_text = wapp_str8_buf(64); +wp_intern void handleTestResult(WpTestFuncResult result) { + WpTerminalColour colour; + WpStr8 result_text = wpStr8Buf(64); if (result.passed) { - colour = WAPP_TERM_COLOUR_FG_BR_GREEN; - wapp_str8_copy_cstr_capped(&result_text, "PASSED"); + colour = WP_TERM_COLOUR_FG_BR_GREEN; + wpStr8CopyCstrCapped(&result_text, "PASSED"); } else { - colour = WAPP_TERM_COLOUR_FG_BR_RED; - wapp_str8_copy_cstr_capped(&result_text, "FAILED"); + colour = WP_TERM_COLOUR_FG_BR_RED; + wpStr8CopyCstrCapped(&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)); + wpShellTermcolourPrintText(&result_text, colour); + wpShellTermcolourClearColour(); + printf("] " WP_STR8_SPEC "\n", wpStr8Varg(result.name)); if (!result.passed) { exit(EXIT_FAILURE); diff --git a/src/testing/tester/tester.h b/src/testing/tester/tester.h index 74b592c..5ac7d8c 100644 --- a/src/testing/tester/tester.h +++ b/src/testing/tester/tester.h @@ -7,30 +7,30 @@ #include "../../common/platform/platform.h" #include "../../base/strings/str8/str8.h" -#ifdef WAPP_PLATFORM_CPP +#ifdef WP_PLATFORM_CPP BEGIN_C_LINKAGE -#define wapp_tester_result(PASSED) (TestFuncResult{wapp_str8_lit_ro(__func__), PASSED, {}}) +#define wpTesterResult(PASSED) (WpTestFuncResult{wpStr8LitRo(__func__), PASSED, {}}) #else -#define wapp_tester_result(PASSED) ((TestFuncResult){.name = wapp_str8_lit_ro(__func__), .passed = PASSED}) -#endif // !WAPP_PLATFORM_CPP +#define wpTesterResult(PASSED) ((WpTestFuncResult){.name = wpStr8LitRo(__func__), .passed = PASSED}) +#endif // !WP_PLATFORM_CPP -#define wapp_tester_run_tests(...) run_tests(__VA_ARGS__, NULL) +#define wpTesterRun(...) _runTests(__VA_ARGS__, NULL) -typedef struct TestFuncResult TestFuncResult; -struct TestFuncResult { - Str8 name; +typedef struct WpTestFuncResult WpTestFuncResult; +struct WpTestFuncResult { + WpStr8 name; b8 passed; - wapp_misc_utils_reserve_padding(sizeof(Str8) + sizeof(b8)); + wpMiscUtilsReservePadding(sizeof(WpStr8) + sizeof(b8)); }; -typedef TestFuncResult(TestFunc)(void); +typedef WpTestFuncResult(WpTestFunc)(void); -void run_tests(TestFunc *func1, ...); +void _runTests(WpTestFunc *func1, ...); -#ifdef WAPP_PLATFORM_CPP +#ifdef WP_PLATFORM_CPP END_C_LINKAGE -#endif // !WAPP_PLATFORM_CPP +#endif // !WP_PLATFORM_CPP #endif // !TESTER_H diff --git a/src/uuid/uuid.c b/src/uuid/uuid.c index 06993fb..8f50e26 100644 --- a/src/uuid/uuid.c +++ b/src/uuid/uuid.c @@ -15,11 +15,11 @@ struct UUID4 { u64 low; }; -wapp_intern UUID4 generate_uuid4(void); -wapp_intern void uuid4_to_uuid(const UUID4* uuid4, WUUID *uuid); +wp_intern UUID4 generate_uuid4(void); +wp_intern void uuid4_to_uuid(const UUID4* uuid4, WpUuid *uuid); -WUUID *wapp_uuid_init_uuid4(WUUID *uuid) { - wapp_debug_assert(uuid != NULL, "`uuid` should not be NULL"); +WpUuid *wpUuidInitUuid4(WpUuid *uuid) { + wpDebugAssert(uuid != NULL, "`uuid` should not be NULL"); UUID4 uuid4 = generate_uuid4(); uuid4_to_uuid(&uuid4, uuid); @@ -27,18 +27,18 @@ WUUID *wapp_uuid_init_uuid4(WUUID *uuid) { return uuid; } -wapp_intern UUID4 generate_uuid4(void) { - wapp_persist XOR256State state = {0}; - wapp_persist b8 initialised = false; +wp_intern UUID4 generate_uuid4(void) { + wp_persist WpXor256State state = {0}; + wp_persist b8 initialised = false; if (!initialised) { initialised = true; - state = wapp_prng_xorshift_init_state(); + state = wpPrngXorshiftInit(); } UUID4 uuid = (UUID4){ - .high = wapp_prng_xorshift_256(&state), - .low = wapp_prng_xorshift_256(&state), + .high = wpPrngXorshift256(&state), + .low = wpPrngXorshift256(&state), }; uuid.high = (uuid.high & 0xffffffffffff0fff) | 0x0000000000004000; @@ -47,12 +47,12 @@ wapp_intern UUID4 generate_uuid4(void) { return uuid; } -wapp_intern void uuid4_to_uuid(const UUID4* uuid4, WUUID *uuid) { +wp_intern void uuid4_to_uuid(const UUID4* uuid4, WpUuid *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; - wapp_str8_format(&(uuid->uuid), UUID_STR_FORMAT, group1, group2, group3, group4, group5); + wpStr8Format(&(uuid->uuid), UUID_STR_FORMAT, group1, group2, group3, group4, group5); } diff --git a/src/uuid/uuid.h b/src/uuid/uuid.h index 09fdcab..51a7fdd 100644 --- a/src/uuid/uuid.h +++ b/src/uuid/uuid.h @@ -7,44 +7,44 @@ #include "../common/platform/platform.h" #include "../base/strings/str8/str8.h" -#ifdef WAPP_PLATFORM_CPP +#ifdef WP_PLATFORM_CPP BEGIN_C_LINKAGE -#endif // !WAPP_PLATFORM_CPP +#endif // !WP_PLATFORM_CPP -#define UUID_BUF_LENGTH 48 -#define WAPP_UUID_SPEC WAPP_STR8_SPEC -#define wapp_uuid_varg(WUUID) wapp_str8_varg((WUUID).uuid) +#define WP_UUID_BUF_LENGTH 48 +#define WP_UUID_SPEC WP_STR8_SPEC +#define wpUuidVarg(WpUuid) wpStr8Varg((WpUuid).uuid) -typedef struct WUUID WUUID; -struct WUUID { - Str8 uuid; +typedef struct WpUuid WpUuid; +struct WpUuid { + WpStr8 uuid; }; // TODO (Abdelrahman): Update UUID implementation to work properly with C++ and tests for validation -#ifdef WAPP_PLATFORM_CPP -#define wapp_uuid_gen_uuid4() ([&](){ \ - wapp_persist WUUID uuid = wapp_uuid_create(); \ - return *(wapp_uuid_init_uuid4(&uuid)); \ +#ifdef WP_PLATFORM_CPP +#define wpUuidGenUuid4() ([&](){ \ + wp_persist WpUuid uuid = wpUuidCreate(); \ + return *(wpUuidInitUuid4(&uuid)); \ }()) #else -#define wapp_uuid_gen_uuid4() *(wapp_uuid_init_uuid4(&wapp_uuid_create())) +#define wpUuidGenUuid4() *(wpUuidInitUuid4(&wpUuidCreate())) #endif /* Low level UUID API */ -#ifdef WAPP_PLATFORM_CPP -#define wapp_uuid_create() ([&](){ return WUUID{wapp_str8_buf(UUID_BUF_LENGTH)}; }()) +#ifdef WP_PLATFORM_CPP +#define wpUuidCreate() ([&](){ return WpUuid{wpStr8Buf(WP_UUID_BUF_LENGTH)}; }()) #else -#define wapp_uuid_create() ((WUUID){.uuid = wapp_str8_buf(UUID_BUF_LENGTH)}) +#define wpUuidCreate() ((WpUuid){.uuid = wpStr8Buf(WP_UUID_BUF_LENGTH)}) #endif // Just returns the same pointer that was passed in with the UUID initialised. // Fails when passed a NULL pointer. -WUUID *wapp_uuid_init_uuid4(WUUID *uuid); +WpUuid *wpUuidInitUuid4(WpUuid *uuid); -#ifdef WAPP_PLATFORM_CPP +#ifdef WP_PLATFORM_CPP END_C_LINKAGE -#endif // !WAPP_PLATFORM_CPP +#endif // !WP_PLATFORM_CPP #endif // !UUID_H diff --git a/tests/allocator/test_allocator.c b/tests/allocator/test_allocator.c index 28b5336..525d1b7 100644 --- a/tests/allocator/test_allocator.c +++ b/tests/allocator/test_allocator.c @@ -6,62 +6,62 @@ // allocation are aligned to power of 2 boundaries, the number of i32 values needed is hardcoded. #define TEMP_BUF_SIZE (40 + sizeof(i32) * 8) -wapp_intern u8 temp_buf[TEMP_BUF_SIZE] = {0}; -wapp_intern Allocator temp_allocator = {0}; +wp_intern u8 temp_buf[TEMP_BUF_SIZE] = {0}; +wp_intern WpAllocator temp_allocator = {0}; -TestFuncResult test_arena_allocator(void) { - Allocator allocator = wapp_mem_arena_allocator_init(4096); +WpTestFuncResult test_arena_allocator(void) { + WpAllocator allocator = wpMemArenaAllocatorInit(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); + void *ptr = wpMemAllocatorAlloc(&allocator, 20); result = result && (ptr != NULL); - wapp_mem_arena_allocator_destroy(&allocator); + wpMemArenaAllocatorDestroy(&allocator); - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_arena_allocator_with_buffer(void) { +WpTestFuncResult test_arena_allocator_with_buffer(void) { u8 buffer[KiB(4)] = {0}; - Allocator allocator = wapp_mem_arena_allocator_init_with_buffer(buffer, KiB(4)); + WpAllocator allocator = wpMemArenaAllocatorInitWithBuffer(buffer, KiB(4)); 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); + void *ptr = wpMemAllocatorAlloc(&allocator, 20); result = result && (ptr != NULL); - wapp_mem_arena_allocator_destroy(&allocator); + wpMemArenaAllocatorDestroy(&allocator); - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_arena_allocator_temp_begin(void) { - temp_allocator = wapp_mem_arena_allocator_init_with_buffer(temp_buf, TEMP_BUF_SIZE); +WpTestFuncResult test_arena_allocator_temp_begin(void) { + temp_allocator = wpMemArenaAllocatorInitWithBuffer(temp_buf, TEMP_BUF_SIZE); - i32 *num1 = (i32 *)wapp_mem_allocator_alloc(&temp_allocator, sizeof(i32)); + i32 *num1 = (i32 *)wpMemAllocatorAlloc(&temp_allocator, sizeof(i32)); b8 result = num1 != NULL; - wapp_mem_arena_allocator_temp_begin(&temp_allocator); - i32 *num2 = (i32 *)wapp_mem_allocator_alloc(&temp_allocator, sizeof(i32)); + wpMemArenaAllocatorTempBegin(&temp_allocator); + i32 *num2 = (i32 *)wpMemAllocatorAlloc(&temp_allocator, sizeof(i32)); result = result && num2 != NULL; - i32 *num3 = (i32 *)wapp_mem_allocator_alloc(&temp_allocator, sizeof(i32)); + i32 *num3 = (i32 *)wpMemAllocatorAlloc(&temp_allocator, sizeof(i32)); result = result && num3 == NULL; - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_arena_allocator_temp_end(void) { - wapp_mem_arena_allocator_temp_end(&temp_allocator); - i32 *num1 = (i32 *)wapp_mem_allocator_alloc(&temp_allocator, sizeof(i32)); +WpTestFuncResult test_arena_allocator_temp_end(void) { + wpMemArenaAllocatorTempEnd(&temp_allocator); + i32 *num1 = (i32 *)wpMemAllocatorAlloc(&temp_allocator, sizeof(i32)); b8 result = num1 != NULL; - i32 *num2 = (i32 *)wapp_mem_allocator_alloc(&temp_allocator, sizeof(i32)); + i32 *num2 = (i32 *)wpMemAllocatorAlloc(&temp_allocator, sizeof(i32)); result = result && num2 == NULL; - wapp_mem_arena_allocator_destroy(&temp_allocator); + wpMemArenaAllocatorDestroy(&temp_allocator); - return wapp_tester_result(result); + return wpTesterResult(result); } diff --git a/tests/allocator/test_allocator.cc b/tests/allocator/test_allocator.cc index 2ce49fd..35b8b80 100644 --- a/tests/allocator/test_allocator.cc +++ b/tests/allocator/test_allocator.cc @@ -6,62 +6,62 @@ // allocation are aligned to power of 2 boundaries, the number of i32 values needed is hardcoded. #define TEMP_BUF_SIZE (40 + sizeof(i32) * 8) -wapp_intern u8 temp_buf[TEMP_BUF_SIZE] = {}; -wapp_intern Allocator temp_allocator = {}; +wp_intern u8 temp_buf[TEMP_BUF_SIZE] = {}; +wp_intern WpAllocator temp_allocator = {}; -TestFuncResult test_arena_allocator(void) { - Allocator allocator = wapp_mem_arena_allocator_init(4096); +WpTestFuncResult test_arena_allocator(void) { + WpAllocator allocator = wpMemArenaAllocatorInit(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); + void *ptr = wpMemAllocatorAlloc(&allocator, 20); result = result && (ptr != nullptr); - wapp_mem_arena_allocator_destroy(&allocator); + wpMemArenaAllocatorDestroy(&allocator); - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_arena_allocator_with_buffer(void) { +WpTestFuncResult test_arena_allocator_with_buffer(void) { u8 buffer[KiB(4)] = {0}; - Allocator allocator = wapp_mem_arena_allocator_init_with_buffer(buffer, KiB(4)); + WpAllocator allocator = wpMemArenaAllocatorInitWithBuffer(buffer, KiB(4)); 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); + void *ptr = wpMemAllocatorAlloc(&allocator, 20); result = result && (ptr != NULL); - wapp_mem_arena_allocator_destroy(&allocator); + wpMemArenaAllocatorDestroy(&allocator); - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_arena_allocator_temp_begin(void) { - temp_allocator = wapp_mem_arena_allocator_init_with_buffer(temp_buf, TEMP_BUF_SIZE); +WpTestFuncResult test_arena_allocator_temp_begin(void) { + temp_allocator = wpMemArenaAllocatorInitWithBuffer(temp_buf, TEMP_BUF_SIZE); - i32 *num1 = (i32 *)wapp_mem_allocator_alloc(&temp_allocator, sizeof(i32)); + i32 *num1 = (i32 *)wpMemAllocatorAlloc(&temp_allocator, sizeof(i32)); b8 result = num1 != NULL; - wapp_mem_arena_allocator_temp_begin(&temp_allocator); - i32 *num2 = (i32 *)wapp_mem_allocator_alloc(&temp_allocator, sizeof(i32)); + wpMemArenaAllocatorTempBegin(&temp_allocator); + i32 *num2 = (i32 *)wpMemAllocatorAlloc(&temp_allocator, sizeof(i32)); result = result && num2 != NULL; - i32 *num3 = (i32 *)wapp_mem_allocator_alloc(&temp_allocator, sizeof(i32)); + i32 *num3 = (i32 *)wpMemAllocatorAlloc(&temp_allocator, sizeof(i32)); result = result && num3 == NULL; - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_arena_allocator_temp_end(void) { - wapp_mem_arena_allocator_temp_end(&temp_allocator); - i32 *num1 = (i32 *)wapp_mem_allocator_alloc(&temp_allocator, sizeof(i32)); +WpTestFuncResult test_arena_allocator_temp_end(void) { + wpMemArenaAllocatorTempEnd(&temp_allocator); + i32 *num1 = (i32 *)wpMemAllocatorAlloc(&temp_allocator, sizeof(i32)); b8 result = num1 != NULL; - i32 *num2 = (i32 *)wapp_mem_allocator_alloc(&temp_allocator, sizeof(i32)); + i32 *num2 = (i32 *)wpMemAllocatorAlloc(&temp_allocator, sizeof(i32)); result = result && num2 == NULL; - wapp_mem_arena_allocator_destroy(&temp_allocator); + wpMemArenaAllocatorDestroy(&temp_allocator); - return wapp_tester_result(result); + return wpTesterResult(result); } diff --git a/tests/allocator/test_allocator.h b/tests/allocator/test_allocator.h index c223416..0fd518f 100644 --- a/tests/allocator/test_allocator.h +++ b/tests/allocator/test_allocator.h @@ -3,9 +3,9 @@ #include "wapp.h" -TestFuncResult test_arena_allocator(void); -TestFuncResult test_arena_allocator_with_buffer(void); -TestFuncResult test_arena_allocator_temp_begin(void); -TestFuncResult test_arena_allocator_temp_end(void); +WpTestFuncResult test_arena_allocator(void); +WpTestFuncResult test_arena_allocator_with_buffer(void); +WpTestFuncResult test_arena_allocator_temp_begin(void); +WpTestFuncResult test_arena_allocator_temp_end(void); #endif // !TEST_ALLOCATOR_H diff --git a/tests/arena/test_arena.c b/tests/arena/test_arena.c index 205fd64..c4487a0 100644 --- a/tests/arena/test_arena.c +++ b/tests/arena/test_arena.c @@ -4,143 +4,143 @@ #define ARENA_CAPACITY KiB(16) #define ARENA_BUF_SIZE KiB(4) -// NOTE (Abdelrahman): Cannot query size of Arena here so it's hardcoded. Similarly, since arena +// NOTE (Abdelrahman): Cannot query size of WpArena here so it's hardcoded. Similarly, since arena // allocation are aligned to power of 2 boundaries, the number of i32 values needed is hardcoded. #define TEMP_BUF_SIZE (40 + sizeof(i32) * 8) -wapp_intern Arena *arena = NULL; -wapp_intern i32 count = 20; -wapp_intern i32 *array = NULL; -wapp_intern Arena *buf_arena = NULL; -wapp_intern u8 buf[ARENA_BUF_SIZE] = {0}; -wapp_intern Arena *temp_arena = NULL; -wapp_intern u8 temp_buf[TEMP_BUF_SIZE] = {0}; +wp_intern WpArena *arena = NULL; +wp_intern i32 count = 20; +wp_intern i32 *array = NULL; +wp_intern WpArena *buf_arena = NULL; +wp_intern u8 buf[ARENA_BUF_SIZE] = {0}; +wp_intern WpArena *temp_arena = NULL; +wp_intern u8 temp_buf[TEMP_BUF_SIZE] = {0}; -TestFuncResult test_arena_init_buffer(void) { - b8 result = wapp_mem_arena_init_buffer(&buf_arena, buf, ARENA_BUF_SIZE); - return wapp_tester_result(result); +WpTestFuncResult test_arena_init_buffer(void) { + b8 result = wpMemArenaInitBuffer(&buf_arena, buf, ARENA_BUF_SIZE); + return wpTesterResult(result); } -TestFuncResult test_arena_init_allocated(void) { - b8 result = wapp_mem_arena_init_allocated(&arena, ARENA_CAPACITY); +WpTestFuncResult test_arena_init_allocated(void) { + b8 result = wpMemArenaInitAllocated(&arena, ARENA_CAPACITY); - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_arena_init_succeeds_when_reserving_very_large_size(void) { - Arena *large_arena = NULL; +WpTestFuncResult test_arena_init_succeeds_when_reserving_very_large_size(void) { + WpArena *large_arena = NULL; u64 capacity = GiB(512); - b8 result = wapp_mem_arena_init_allocated(&large_arena, capacity); + b8 result = wpMemArenaInitAllocated(&large_arena, capacity); if (result) { - wapp_mem_arena_destroy(&large_arena); + wpMemArenaDestroy(&large_arena); } - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_arena_alloc_with_buffer(void) { - i32 *arr = (i32 *)wapp_mem_arena_alloc(arena, count * sizeof(i32)); +WpTestFuncResult test_arena_alloc_with_buffer(void) { + i32 *arr = (i32 *)wpMemArenaAlloc(arena, count * sizeof(i32)); b8 result = arr != NULL; for (i32 i = 0; i < count; ++i) { arr[i] = i * 10; } - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_arena_alloc_succeeds_when_within_capacity(void) { - array = wapp_mem_arena_alloc(arena, count * sizeof(i32)); +WpTestFuncResult test_arena_alloc_succeeds_when_within_capacity(void) { + array = wpMemArenaAlloc(arena, count * sizeof(i32)); b8 result = array != NULL; for (i32 i = 0; i < count; ++i) { array[i] = i * 10; } - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_arena_alloc_fails_when_over_capacity(void) { - u8 *bytes = wapp_mem_arena_alloc(arena, ARENA_CAPACITY * 2); +WpTestFuncResult test_arena_alloc_fails_when_over_capacity(void) { + u8 *bytes = wpMemArenaAlloc(arena, ARENA_CAPACITY * 2); b8 result = bytes == NULL; - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_arena_realloc_bigger_size(void) { +WpTestFuncResult 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)); + i32 *bytes = wpMemArenaAlloc(arena, old_count * sizeof(i32)); 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)); + i32 *new_bytes = wpMemArenaRealloc(arena, bytes, old_count * sizeof(i32), new_count * sizeof(i32)); if (!new_bytes) { - return wapp_tester_result(false); + return wpTesterResult(false); } for (u64 i = 0; i < new_count; ++i) { if (i < old_count && new_bytes[i] != bytes[i]) { - return wapp_tester_result(false); + return wpTesterResult(false); } } - return wapp_tester_result(true); + return wpTesterResult(true); } -TestFuncResult test_arena_realloc_smaller_size(void) { +WpTestFuncResult 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)); + i32 *bytes = wpMemArenaAlloc(arena, old_count * sizeof(i32)); 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)); + i32 *new_bytes = wpMemArenaRealloc(arena, bytes, old_count * sizeof(i32), new_count * sizeof(i32)); if (!new_bytes) { - return wapp_tester_result(false); + return wpTesterResult(false); } for (u64 i = 0; i < new_count; ++i) { if (i < new_count && new_bytes[i] != bytes[i]) { - return wapp_tester_result(false); + return wpTesterResult(false); } } - return wapp_tester_result(true); + return wpTesterResult(true); } -TestFuncResult test_arena_temp_begin(void) { - b8 result = wapp_mem_arena_init_buffer(&temp_arena, temp_buf, TEMP_BUF_SIZE); - i32 *num1 = (i32 *)wapp_mem_arena_alloc(temp_arena, sizeof(i32)); +WpTestFuncResult test_arena_temp_begin(void) { + b8 result = wpMemArenaInitBuffer(&temp_arena, temp_buf, TEMP_BUF_SIZE); + i32 *num1 = (i32 *)wpMemArenaAlloc(temp_arena, sizeof(i32)); result = result && num1 != NULL; - wapp_mem_arena_temp_begin(temp_arena); - i32 *num2 = (i32 *)wapp_mem_arena_alloc(temp_arena, sizeof(i32)); + wpMemArenaTempBegin(temp_arena); + i32 *num2 = (i32 *)wpMemArenaAlloc(temp_arena, sizeof(i32)); result = result && num2 != NULL; - i32 *num3 = (i32 *)wapp_mem_arena_alloc(temp_arena, sizeof(i32)); + i32 *num3 = (i32 *)wpMemArenaAlloc(temp_arena, sizeof(i32)); result = result && num3 == NULL; - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_arena_temp_end(void) { - wapp_mem_arena_temp_end(temp_arena); - i32 *num1 = (i32 *)wapp_mem_arena_alloc(temp_arena, sizeof(i32)); +WpTestFuncResult test_arena_temp_end(void) { + wpMemArenaTempEnd(temp_arena); + i32 *num1 = (i32 *)wpMemArenaAlloc(temp_arena, sizeof(i32)); b8 result = num1 != NULL; - i32 *num2 = (i32 *)wapp_mem_arena_alloc(temp_arena, sizeof(i32)); + i32 *num2 = (i32 *)wpMemArenaAlloc(temp_arena, sizeof(i32)); result = result && num2 == NULL; - wapp_mem_arena_destroy(&temp_arena); + wpMemArenaDestroy(&temp_arena); - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_arena_clear(void) { - wapp_mem_arena_clear(arena); +WpTestFuncResult test_arena_clear(void) { + wpMemArenaClear(arena); b8 result = true; for (i32 i = 0; i < count; ++i) { @@ -150,19 +150,19 @@ TestFuncResult test_arena_clear(void) { } } - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_arena_destroy_buffer(void) { - wapp_mem_arena_destroy(&buf_arena); +WpTestFuncResult test_arena_destroy_buffer(void) { + wpMemArenaDestroy(&buf_arena); b8 result = buf_arena == NULL; - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_arena_destroy_allocated(void) { - wapp_mem_arena_destroy(&arena); +WpTestFuncResult test_arena_destroy_allocated(void) { + wpMemArenaDestroy(&arena); b8 result = arena == NULL; - return wapp_tester_result(result); + return wpTesterResult(result); } diff --git a/tests/arena/test_arena.cc b/tests/arena/test_arena.cc index 00a9f0b..6b2b89d 100644 --- a/tests/arena/test_arena.cc +++ b/tests/arena/test_arena.cc @@ -4,143 +4,143 @@ #define ARENA_CAPACITY KiB(16) #define ARENA_BUF_SIZE KiB(4) -// NOTE (Abdelrahman): Cannot query size of Arena here so it's hardcoded. Similarly, since arena +// NOTE (Abdelrahman): Cannot query size of WpArena here so it's hardcoded. Similarly, since arena // allocation are aligned to power of 2 boundaries, the number of i32 values needed is hardcoded. #define TEMP_BUF_SIZE (40 + sizeof(i32) * 8) -wapp_intern Arena *arena = NULL; -wapp_intern i32 count = 20; -wapp_intern i32 *array = NULL; -wapp_intern Arena *buf_arena = NULL; -wapp_intern u8 buf[ARENA_BUF_SIZE] = {}; -wapp_intern Arena *temp_arena = NULL; -wapp_intern u8 temp_buf[TEMP_BUF_SIZE] = {}; +wp_intern WpArena *arena = NULL; +wp_intern i32 count = 20; +wp_intern i32 *array = NULL; +wp_intern WpArena *buf_arena = NULL; +wp_intern u8 buf[ARENA_BUF_SIZE] = {}; +wp_intern WpArena *temp_arena = NULL; +wp_intern u8 temp_buf[TEMP_BUF_SIZE] = {}; -TestFuncResult test_arena_init_buffer(void) { - b8 result = wapp_mem_arena_init_buffer(&buf_arena, buf, ARENA_BUF_SIZE); - return wapp_tester_result(result); +WpTestFuncResult test_arena_init_buffer(void) { + b8 result = wpMemArenaInitBuffer(&buf_arena, buf, ARENA_BUF_SIZE); + return wpTesterResult(result); } -TestFuncResult test_arena_init_allocated(void) { - b8 result = wapp_mem_arena_init_allocated(&arena, ARENA_CAPACITY); +WpTestFuncResult test_arena_init_allocated(void) { + b8 result = wpMemArenaInitAllocated(&arena, ARENA_CAPACITY); - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_arena_init_succeeds_when_reserving_very_large_size(void) { - Arena *large_arena = nullptr; +WpTestFuncResult test_arena_init_succeeds_when_reserving_very_large_size(void) { + WpArena *large_arena = nullptr; u64 capacity = GiB(512); - b8 result = wapp_mem_arena_init_allocated(&large_arena, capacity); + b8 result = wpMemArenaInitAllocated(&large_arena, capacity); if (result) { - wapp_mem_arena_destroy(&large_arena); + wpMemArenaDestroy(&large_arena); } - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_arena_alloc_with_buffer(void) { - i32 *arr = (i32 *)wapp_mem_arena_alloc(arena, count * sizeof(i32)); +WpTestFuncResult test_arena_alloc_with_buffer(void) { + i32 *arr = (i32 *)wpMemArenaAlloc(arena, count * sizeof(i32)); b8 result = arr != NULL; for (i32 i = 0; i < count; ++i) { arr[i] = i * 10; } - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_arena_alloc_succeeds_when_within_capacity(void) { - array = (i32 *)wapp_mem_arena_alloc(arena, count * sizeof(i32)); +WpTestFuncResult test_arena_alloc_succeeds_when_within_capacity(void) { + array = (i32 *)wpMemArenaAlloc(arena, count * sizeof(i32)); b8 result = array != nullptr; for (i32 i = 0; i < count; ++i) { array[i] = i * 10; } - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_arena_alloc_fails_when_over_capacity(void) { - u8 *bytes = (u8 *)wapp_mem_arena_alloc(arena, ARENA_CAPACITY * 2); +WpTestFuncResult test_arena_alloc_fails_when_over_capacity(void) { + u8 *bytes = (u8 *)wpMemArenaAlloc(arena, ARENA_CAPACITY * 2); b8 result = bytes == nullptr; - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_arena_realloc_bigger_size(void) { +WpTestFuncResult 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)); + i32 *bytes = (i32 *)wpMemArenaAlloc(arena, old_count * sizeof(i32)); 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)); + i32 *new_bytes = (i32 *)wpMemArenaRealloc(arena, bytes, old_count * sizeof(i32), new_count * sizeof(i32)); if (!new_bytes) { - return wapp_tester_result(false); + return wpTesterResult(false); } for (u64 i = 0; i < new_count; ++i) { if (i < old_count && new_bytes[i] != bytes[i]) { - return wapp_tester_result(false); + return wpTesterResult(false); } } - return wapp_tester_result(true); + return wpTesterResult(true); } -TestFuncResult test_arena_realloc_smaller_size(void) { +WpTestFuncResult 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)); + i32 *bytes = (i32 *)wpMemArenaAlloc(arena, old_count * sizeof(i32)); 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)); + i32 *new_bytes = (i32 *)wpMemArenaRealloc(arena, bytes, old_count * sizeof(i32), new_count * sizeof(i32)); if (!new_bytes) { - return wapp_tester_result(false); + return wpTesterResult(false); } for (u64 i = 0; i < new_count; ++i) { if (i < new_count && new_bytes[i] != bytes[i]) { - return wapp_tester_result(false); + return wpTesterResult(false); } } - return wapp_tester_result(true); + return wpTesterResult(true); } -TestFuncResult test_arena_temp_begin(void) { - b8 result = wapp_mem_arena_init_buffer(&temp_arena, temp_buf, TEMP_BUF_SIZE); - i32 *num1 = (i32 *)wapp_mem_arena_alloc(temp_arena, sizeof(i32)); +WpTestFuncResult test_arena_temp_begin(void) { + b8 result = wpMemArenaInitBuffer(&temp_arena, temp_buf, TEMP_BUF_SIZE); + i32 *num1 = (i32 *)wpMemArenaAlloc(temp_arena, sizeof(i32)); result = result && num1 != NULL; - wapp_mem_arena_temp_begin(temp_arena); - i32 *num2 = (i32 *)wapp_mem_arena_alloc(temp_arena, sizeof(i32)); + wpMemArenaTempBegin(temp_arena); + i32 *num2 = (i32 *)wpMemArenaAlloc(temp_arena, sizeof(i32)); result = result && num2 != NULL; - i32 *num3 = (i32 *)wapp_mem_arena_alloc(temp_arena, sizeof(i32)); + i32 *num3 = (i32 *)wpMemArenaAlloc(temp_arena, sizeof(i32)); result = result && num3 == NULL; - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_arena_temp_end(void) { - wapp_mem_arena_temp_end(temp_arena); - i32 *num1 = (i32 *)wapp_mem_arena_alloc(temp_arena, sizeof(i32)); +WpTestFuncResult test_arena_temp_end(void) { + wpMemArenaTempEnd(temp_arena); + i32 *num1 = (i32 *)wpMemArenaAlloc(temp_arena, sizeof(i32)); b8 result = num1 != NULL; - i32 *num2 = (i32 *)wapp_mem_arena_alloc(temp_arena, sizeof(i32)); + i32 *num2 = (i32 *)wpMemArenaAlloc(temp_arena, sizeof(i32)); result = result && num2 == NULL; - wapp_mem_arena_destroy(&temp_arena); + wpMemArenaDestroy(&temp_arena); - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_arena_clear(void) { - wapp_mem_arena_clear(arena); +WpTestFuncResult test_arena_clear(void) { + wpMemArenaClear(arena); b8 result = true; for (i32 i = 0; i < count; ++i) { @@ -150,19 +150,19 @@ TestFuncResult test_arena_clear(void) { } } - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_arena_destroy_buffer(void) { - wapp_mem_arena_destroy(&buf_arena); +WpTestFuncResult test_arena_destroy_buffer(void) { + wpMemArenaDestroy(&buf_arena); b8 result = buf_arena == NULL; - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_arena_destroy_allocated(void) { - wapp_mem_arena_destroy(&arena); +WpTestFuncResult test_arena_destroy_allocated(void) { + wpMemArenaDestroy(&arena); b8 result = arena == nullptr; - return wapp_tester_result(result); + return wpTesterResult(result); } diff --git a/tests/arena/test_arena.h b/tests/arena/test_arena.h index 06ea137..4b7ee87 100644 --- a/tests/arena/test_arena.h +++ b/tests/arena/test_arena.h @@ -3,18 +3,18 @@ #include "wapp.h" -TestFuncResult test_arena_init_buffer(void); -TestFuncResult test_arena_init_allocated(void); -TestFuncResult test_arena_init_succeeds_when_reserving_very_large_size(void); -TestFuncResult test_arena_alloc_with_buffer(void); -TestFuncResult test_arena_alloc_succeeds_when_within_capacity(void); -TestFuncResult test_arena_alloc_fails_when_over_capacity(void); -TestFuncResult test_arena_realloc_bigger_size(void); -TestFuncResult test_arena_realloc_smaller_size(void); -TestFuncResult test_arena_clear(void); -TestFuncResult test_arena_temp_begin(void); -TestFuncResult test_arena_temp_end(void); -TestFuncResult test_arena_destroy_buffer(void); -TestFuncResult test_arena_destroy_allocated(void); +WpTestFuncResult test_arena_init_buffer(void); +WpTestFuncResult test_arena_init_allocated(void); +WpTestFuncResult test_arena_init_succeeds_when_reserving_very_large_size(void); +WpTestFuncResult test_arena_alloc_with_buffer(void); +WpTestFuncResult test_arena_alloc_succeeds_when_within_capacity(void); +WpTestFuncResult test_arena_alloc_fails_when_over_capacity(void); +WpTestFuncResult test_arena_realloc_bigger_size(void); +WpTestFuncResult test_arena_realloc_smaller_size(void); +WpTestFuncResult test_arena_clear(void); +WpTestFuncResult test_arena_temp_begin(void); +WpTestFuncResult test_arena_temp_end(void); +WpTestFuncResult test_arena_destroy_buffer(void); +WpTestFuncResult test_arena_destroy_allocated(void); #endif // !TEST_ARENA_H diff --git a/tests/array/test_i32_array.c b/tests/array/test_i32_array.c index 8086f70..66ab702 100644 --- a/tests/array/test_i32_array.c +++ b/tests/array/test_i32_array.c @@ -1,172 +1,172 @@ #include "test_i32_array.h" #include "wapp.h" -TestFuncResult test_i32_array(void) { +WpTestFuncResult test_i32_array(void) { b8 result; - I32Array array = wapp_array(i32, 1, 2, 3, 4, 5, 6, 7); - result = wapp_array_count(array) == 7 && wapp_array_capacity(array) == 16; + WpI32Array array = wpArray(i32, 1, 2, 3, 4, 5, 6, 7); + result = wpArrayCount(array) == 7 && wpArrayCapacity(array) == 16; i32 *item; - u64 count = wapp_array_count(array); + u64 count = wpArrayCount(array); u64 index = 0; b8 running = true; while (running) { - item = wapp_array_get(i32, array, index); + item = wpArrayGet(i32, array, index); result = result && item && *item == (i32)(index + 1); ++index; running = index < count; } - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_i32_array_with_capacity(void) { +WpTestFuncResult test_i32_array_with_capacity(void) { b8 result; - I32Array array1 = wapp_array_with_capacity(i32, 64, ARRAY_INIT_NONE); - result = wapp_array_count(array1) == 0 && wapp_array_capacity(array1) == 64; + WpI32Array array1 = wpArrayWithCapacity(i32, 64, WP_ARRAY_INIT_NONE); + result = wpArrayCount(array1) == 0 && wpArrayCapacity(array1) == 64; - I32Array array2 = wapp_array_with_capacity(i32, 64, ARRAY_INIT_FILLED); - result = wapp_array_count(array2) == 64 && wapp_array_capacity(array2) == 64; + WpI32Array array2 = wpArrayWithCapacity(i32, 64, WP_ARRAY_INIT_FILLED); + result = wpArrayCount(array2) == 64 && wpArrayCapacity(array2) == 64; - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_i32_array_get(void) { +WpTestFuncResult test_i32_array_get(void) { b8 result = true; - I32Array array = wapp_array(i32, 0, 1, 2, 3, 4, 5, 6, 7, 8); + WpI32Array array = wpArray(i32, 0, 1, 2, 3, 4, 5, 6, 7, 8); i32 *item; - u64 count = wapp_array_count(array); + u64 count = wpArrayCount(array); u64 index = 0; b8 running = true; while (running) { - item = wapp_array_get(i32, array, index); + item = wpArrayGet(i32, array, index); result = result && item && *item == (i32)index; ++index; running = index < count; } - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_i32_array_set(void) { +WpTestFuncResult test_i32_array_set(void) { b8 result = true; - I32Array array = wapp_array(i32, 0, 1, 2, 3, 4, 5, 6, 7, 8); + WpI32Array array = wpArray(i32, 0, 1, 2, 3, 4, 5, 6, 7, 8); i32 *item; - u64 count = wapp_array_count(array); + u64 count = wpArrayCount(array); 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); + wpArraySet(i32, array, index, &num); + item = wpArrayGet(i32, array, index); result = result && item && *item == (i32)(index * 2); ++index; running = index < count; } - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_i32_array_append_capped(void) { +WpTestFuncResult test_i32_array_append_capped(void) { b8 result; - I32Array array = wapp_array_with_capacity(i32, 64, ARRAY_INIT_NONE); - wapp_array_append_capped(i32, array, &((i32){10})); + WpI32Array array = wpArrayWithCapacity(i32, 64, WP_ARRAY_INIT_NONE); + wpArrayAppendCapped(i32, array, &((i32){10})); - result = wapp_array_count(array) == 1; - i32 *item = wapp_array_get(i32, array, 0); + result = wpArrayCount(array) == 1; + i32 *item = wpArrayGet(i32, array, 0); result = result && item && *item == 10; - array = wapp_array(i32, 1); - wapp_array_append_capped(i32, array, &((i32){10})); + array = wpArray(i32, 1); + wpArrayAppendCapped(i32, array, &((i32){10})); - result = result && wapp_array_count(array) == 2; + result = result && wpArrayCount(array) == 2; - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_i32_array_extend_capped(void) { +WpTestFuncResult test_i32_array_extend_capped(void) { b8 result; - I32Array array1 = wapp_array(i32, 1, 2, 3, 4); - I32Array array2 = wapp_array(i32, 10, 20); + WpI32Array array1 = wpArray(i32, 1, 2, 3, 4); + WpI32Array array2 = wpArray(i32, 10, 20); - result = wapp_array_count(array1) == 4 && wapp_array_count(array2) == 2; + result = wpArrayCount(array1) == 4 && wpArrayCount(array2) == 2; - wapp_array_extend_capped(i32, array1, array2); + wpArrayExtendCapped(i32, array1, array2); - result = result && wapp_array_count(array1) == 6; + result = result && wpArrayCount(array1) == 6; - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_i32_array_copy_capped(void) { +WpTestFuncResult test_i32_array_copy_capped(void) { b8 result; - I32Array src = wapp_array(i32, 1, 2, 3, 4, 5); - I32Array dst1 = wapp_array(i32, 1, 2, 3, 4, 5, 6); - I32Array dst2 = wapp_array(i32, 1, 2); + WpI32Array src = wpArray(i32, 1, 2, 3, 4, 5); + WpI32Array dst1 = wpArray(i32, 1, 2, 3, 4, 5, 6); + WpI32Array dst2 = wpArray(i32, 1, 2); u64 expected_count = 5; - wapp_array_copy_capped(i32, dst1, src); - result = wapp_array_count(dst1) == expected_count; + wpArrayCopyCapped(i32, dst1, src); + result = wpArrayCount(dst1) == expected_count; u64 index = 0; b8 running = true; while (running) { - result = result && *wapp_array_get(i32, src, index) == *wapp_array_get(i32, dst1, index); + result = result && *wpArrayGet(i32, src, index) == *wpArrayGet(i32, dst1, index); ++index; running = index < expected_count; } expected_count = 4; - wapp_array_copy_capped(i32, dst2, src); - result = result && wapp_array_count(dst2) == expected_count; + wpArrayCopyCapped(i32, dst2, src); + result = result && wpArrayCount(dst2) == expected_count; index = 0; running = true; while (running) { - result = result && *wapp_array_get(i32, src, index) == *wapp_array_get(i32, dst2, index); + result = result && *wpArrayGet(i32, src, index) == *wpArrayGet(i32, dst2, index); ++index; running = index < expected_count; } - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_i32_array_alloc_capacity(void) { +WpTestFuncResult test_i32_array_alloc_capacity(void) { b8 result; - Allocator allocator = wapp_mem_arena_allocator_init(MiB(4)); + WpAllocator allocator = wpMemArenaAllocatorInit(MiB(4)); u64 capacity = 32; - I32Array array = wapp_array_alloc_capacity(i32, &allocator, capacity, ARRAY_INIT_NONE); + WpI32Array array = wpArrayAllocCapacity(i32, &allocator, capacity, WP_ARRAY_INIT_NONE); - result = array && wapp_array_capacity(array) == capacity; + result = array && wpArrayCapacity(array) == capacity; - wapp_mem_arena_allocator_destroy(&allocator); + wpMemArenaAllocatorDestroy(&allocator); - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_i32_array_append_alloc(void) { +WpTestFuncResult test_i32_array_append_alloc(void) { b8 result; - Allocator allocator = wapp_mem_arena_allocator_init(MiB(4)); - I32Array array1 = wapp_array(i32, 1, 2, 3, 4, 5, 6, 7, 8); - I32Array array2 = wapp_array(i32, 1, 2); + WpAllocator allocator = wpMemArenaAllocatorInit(MiB(4)); + WpI32Array array1 = wpArray(i32, 1, 2, 3, 4, 5, 6, 7, 8); + WpI32Array array2 = wpArray(i32, 1, 2); - I32Array arr_ptr = wapp_array_append_alloc(i32, &allocator, array1, &((i32){10}), ARRAY_INIT_NONE); + WpI32Array arr_ptr = wpArrayAppendAlloc(i32, &allocator, array1, &((i32){10}), WP_ARRAY_INIT_NONE); result = arr_ptr == array1; u64 count = 4; @@ -174,100 +174,100 @@ TestFuncResult test_i32_array_append_alloc(void) { b8 running = true; while (running) { i32 num = (i32)index; - arr_ptr = wapp_array_append_alloc(i32, &allocator, array2, &num, ARRAY_INIT_NONE); + arr_ptr = wpArrayAppendAlloc(i32, &allocator, array2, &num, WP_ARRAY_INIT_NONE); ++index; running = index < count; } result = result && arr_ptr != array2; - wapp_mem_arena_allocator_destroy(&allocator); + wpMemArenaAllocatorDestroy(&allocator); - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_i32_array_extend_alloc(void) { +WpTestFuncResult test_i32_array_extend_alloc(void) { b8 result; - Allocator allocator = wapp_mem_arena_allocator_init(MiB(4)); - I32Array array1 = wapp_array(i32, 1, 2, 3, 4, 5, 6, 7, 8); - I32Array array2 = wapp_array(i32, 1, 2); - I32Array array3 = wapp_array(i32, 1, 2, 3, 4); + WpAllocator allocator = wpMemArenaAllocatorInit(MiB(4)); + WpI32Array array1 = wpArray(i32, 1, 2, 3, 4, 5, 6, 7, 8); + WpI32Array array2 = wpArray(i32, 1, 2); + WpI32Array array3 = wpArray(i32, 1, 2, 3, 4); - I32Array arr_ptr = wapp_array_extend_alloc(i32, &allocator, array1, array3, ARRAY_INIT_NONE); + WpI32Array arr_ptr = wpArrayExtendAlloc(i32, &allocator, array1, array3, WP_ARRAY_INIT_NONE); result = arr_ptr == array1; - arr_ptr = wapp_array_extend_alloc(i32, &allocator, array2, array3, ARRAY_INIT_NONE); + arr_ptr = wpArrayExtendAlloc(i32, &allocator, array2, array3, WP_ARRAY_INIT_NONE); result = result && arr_ptr != array2; - wapp_mem_arena_allocator_destroy(&allocator); + wpMemArenaAllocatorDestroy(&allocator); - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_i32_array_copy_alloc(void) { +WpTestFuncResult test_i32_array_copy_alloc(void) { b8 result; - Allocator allocator = wapp_mem_arena_allocator_init(MiB(4)); - I32Array src = wapp_array(i32, 1, 2, 3, 4, 5); - I32Array dst1 = wapp_array(i32, 1, 2, 3, 4, 5, 6); - I32Array dst2 = wapp_array(i32, 1, 2); - I32Array array = NULL; + WpAllocator allocator = wpMemArenaAllocatorInit(MiB(4)); + WpI32Array src = wpArray(i32, 1, 2, 3, 4, 5); + WpI32Array dst1 = wpArray(i32, 1, 2, 3, 4, 5, 6); + WpI32Array dst2 = wpArray(i32, 1, 2); + WpI32Array array = NULL; u64 expected_count = 5; - array = wapp_array_copy_alloc(i32, &allocator, dst1, src, ARRAY_INIT_NONE); - result = wapp_array_count(array) == expected_count && array == dst1; + array = wpArrayCopyAlloc(i32, &allocator, dst1, src, WP_ARRAY_INIT_NONE); + result = wpArrayCount(array) == expected_count && array == dst1; u64 index = 0; b8 running = true; while (running) { - result = result && *wapp_array_get(i32, src, index) == *wapp_array_get(i32, array, index); + result = result && *wpArrayGet(i32, src, index) == *wpArrayGet(i32, array, index); ++index; running = index < expected_count; } expected_count = 5; - array = wapp_array_copy_alloc(i32, &allocator, dst2, src, ARRAY_INIT_NONE); - result = result && wapp_array_count(array) == expected_count && array != dst2; + array = wpArrayCopyAlloc(i32, &allocator, dst2, src, WP_ARRAY_INIT_NONE); + result = result && wpArrayCount(array) == expected_count && array != dst2; index = 0; running = true; while (running) { - result = result && *wapp_array_get(i32, src, index) == *wapp_array_get(i32, array, index); + result = result && *wpArrayGet(i32, src, index) == *wpArrayGet(i32, array, index); ++index; running = index < expected_count; } - wapp_mem_arena_allocator_destroy(&allocator); + wpMemArenaAllocatorDestroy(&allocator); - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_i32_array_pop(void) { +WpTestFuncResult test_i32_array_pop(void) { b8 result; - I32Array array1 = wapp_array(i32, 0, 1, 2, 3, 4, 5, 6, 7, 8); - I32Array array2 = wapp_array_with_capacity(i32, 32, ARRAY_INIT_NONE); + WpI32Array array1 = wpArray(i32, 0, 1, 2, 3, 4, 5, 6, 7, 8); + WpI32Array array2 = wpArrayWithCapacity(i32, 32, WP_ARRAY_INIT_NONE); - i32 item1 = wapp_array_pop(i32, array1); - i32 item2 = wapp_array_pop(i32, array2); + i32 item1 = wpArrayPop(i32, array1); + i32 item2 = wpArrayPop(i32, array2); result = item1 == 8 && item2 == 0; - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_i32_array_clear(void) { +WpTestFuncResult test_i32_array_clear(void) { b8 result; - I32Array array = wapp_array(i32, 0, 1, 2, 3, 4, 5, 6, 7, 8); - result = wapp_array_count(array) == 9; + WpI32Array array = wpArray(i32, 0, 1, 2, 3, 4, 5, 6, 7, 8); + result = wpArrayCount(array) == 9; - wapp_array_clear(i32, array); + wpArrayClear(i32, array); - result = result && wapp_array_count(array) == 0; + result = result && wpArrayCount(array) == 0; - return wapp_tester_result(result); + return wpTesterResult(result); } diff --git a/tests/array/test_i32_array.cc b/tests/array/test_i32_array.cc index 38d6ee1..d15ca21 100644 --- a/tests/array/test_i32_array.cc +++ b/tests/array/test_i32_array.cc @@ -1,175 +1,175 @@ #include "test_i32_array.h" #include "wapp.h" -TestFuncResult test_i32_array(void) { +WpTestFuncResult test_i32_array(void) { b8 result; - I32Array array = wapp_array(i32, 1, 2, 3, 4, 5, 6, 7); - result = wapp_array_count(array) == 7 && wapp_array_capacity(array) == 16; + WpI32Array array = wpArray(i32, 1, 2, 3, 4, 5, 6, 7); + result = wpArrayCount(array) == 7 && wpArrayCapacity(array) == 16; i32 *item; - u64 count = wapp_array_count(array); + u64 count = wpArrayCount(array); u64 index = 0; b8 running = true; while (running) { - item = wapp_array_get(i32, array, index); + item = wpArrayGet(i32, array, index); result = result && item && (*item == (i32)(index + 1)); ++index; running = index < count; } - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_i32_array_with_capacity(void) { +WpTestFuncResult test_i32_array_with_capacity(void) { b8 result; - I32Array array1 = wapp_array_with_capacity(i32, 64, ARRAY_INIT_NONE); - result = wapp_array_count(array1) == 0 && wapp_array_capacity(array1) == 64; + WpI32Array array1 = wpArrayWithCapacity(i32, 64, WP_ARRAY_INIT_NONE); + result = wpArrayCount(array1) == 0 && wpArrayCapacity(array1) == 64; - I32Array array2 = wapp_array_with_capacity(i32, 64, ARRAY_INIT_FILLED); - result = wapp_array_count(array2) == 64 && wapp_array_capacity(array2) == 64; + WpI32Array array2 = wpArrayWithCapacity(i32, 64, WP_ARRAY_INIT_FILLED); + result = wpArrayCount(array2) == 64 && wpArrayCapacity(array2) == 64; - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_i32_array_get(void) { +WpTestFuncResult test_i32_array_get(void) { b8 result = true; - I32Array array = wapp_array(i32, 0, 1, 2, 3, 4, 5, 6, 7, 8); + WpI32Array array = wpArray(i32, 0, 1, 2, 3, 4, 5, 6, 7, 8); i32 *item; - u64 count = wapp_array_count(array); + u64 count = wpArrayCount(array); u64 index = 0; b8 running = true; while (running) { - item = wapp_array_get(i32, array, index); + item = wpArrayGet(i32, array, index); result = result && item && (*item == (i32)index); ++index; running = index < count; } - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_i32_array_set(void) { +WpTestFuncResult test_i32_array_set(void) { b8 result = true; - I32Array array = wapp_array(i32, 0, 1, 2, 3, 4, 5, 6, 7, 8); + WpI32Array array = wpArray(i32, 0, 1, 2, 3, 4, 5, 6, 7, 8); i32 *item; - u64 count = wapp_array_count(array); + u64 count = wpArrayCount(array); 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); + wpArraySet(i32, array, index, &num); + item = wpArrayGet(i32, array, index); result = result && item && (*item == (i32)(index * 2)); ++index; running = index < count; } - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_i32_array_append_capped(void) { +WpTestFuncResult test_i32_array_append_capped(void) { b8 result; - I32Array array = wapp_array_with_capacity(i32, 64, ARRAY_INIT_NONE); + WpI32Array array = wpArrayWithCapacity(i32, 64, WP_ARRAY_INIT_NONE); i32 item1 = 10; - wapp_array_append_capped(i32, array, &item1); + wpArrayAppendCapped(i32, array, &item1); - result = wapp_array_count(array) == 1; - i32 *item = wapp_array_get(i32, array, 0); + result = wpArrayCount(array) == 1; + i32 *item = wpArrayGet(i32, array, 0); result = result && item && *item == 10; - array = wapp_array(i32, 1); + array = wpArray(i32, 1); i32 item2 = 10; - wapp_array_append_capped(i32, array, &item2); + wpArrayAppendCapped(i32, array, &item2); - result = result && wapp_array_count(array) == 2; + result = result && wpArrayCount(array) == 2; - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_i32_array_extend_capped(void) { +WpTestFuncResult test_i32_array_extend_capped(void) { b8 result; - I32Array array1 = wapp_array(i32, 1, 2, 3, 4); - I32Array array2 = wapp_array(i32, 10, 20); + WpI32Array array1 = wpArray(i32, 1, 2, 3, 4); + WpI32Array array2 = wpArray(i32, 10, 20); - result = wapp_array_count(array1) == 4 && wapp_array_count(array2) == 2; + result = wpArrayCount(array1) == 4 && wpArrayCount(array2) == 2; - wapp_array_extend_capped(i32, array1, array2); + wpArrayExtendCapped(i32, array1, array2); - result = result && wapp_array_count(array1) == 6; + result = result && wpArrayCount(array1) == 6; - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_i32_array_copy_capped(void) { +WpTestFuncResult test_i32_array_copy_capped(void) { b8 result; - I32Array src = wapp_array(i32, 1, 2, 3, 4, 5); - I32Array dst1 = wapp_array(i32, 1, 2, 3, 4, 5, 6); - I32Array dst2 = wapp_array(i32, 1, 2); + WpI32Array src = wpArray(i32, 1, 2, 3, 4, 5); + WpI32Array dst1 = wpArray(i32, 1, 2, 3, 4, 5, 6); + WpI32Array dst2 = wpArray(i32, 1, 2); u64 expected_count = 5; - wapp_array_copy_capped(i32, dst1, src); - result = wapp_array_count(dst1) == expected_count; + wpArrayCopyCapped(i32, dst1, src); + result = wpArrayCount(dst1) == expected_count; u64 index = 0; b8 running = true; while (running) { - result = result && (*wapp_array_get(i32, src, index) == *wapp_array_get(i32, dst1, index)); + result = result && (*wpArrayGet(i32, src, index) == *wpArrayGet(i32, dst1, index)); ++index; running = index < expected_count; } expected_count = 4; - wapp_array_copy_capped(i32, dst2, src); - result = result && wapp_array_count(dst2) == expected_count; + wpArrayCopyCapped(i32, dst2, src); + result = result && wpArrayCount(dst2) == expected_count; index = 0; running = true; while (running) { - result = result && (*wapp_array_get(i32, src, index) == *wapp_array_get(i32, dst2, index)); + result = result && (*wpArrayGet(i32, src, index) == *wpArrayGet(i32, dst2, index)); ++index; running = index < expected_count; } - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_i32_array_alloc_capacity(void) { +WpTestFuncResult test_i32_array_alloc_capacity(void) { b8 result; - Allocator allocator = wapp_mem_arena_allocator_init(MiB(4)); + WpAllocator allocator = wpMemArenaAllocatorInit(MiB(4)); u64 capacity = 32; - I32Array array = wapp_array_alloc_capacity(i32, &allocator, capacity, ARRAY_INIT_NONE); + WpI32Array array = wpArrayAllocCapacity(i32, &allocator, capacity, WP_ARRAY_INIT_NONE); - result = array && wapp_array_capacity(array) == capacity; + result = array && wpArrayCapacity(array) == capacity; - wapp_mem_arena_allocator_destroy(&allocator); + wpMemArenaAllocatorDestroy(&allocator); - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_i32_array_append_alloc(void) { +WpTestFuncResult test_i32_array_append_alloc(void) { b8 result; - Allocator allocator = wapp_mem_arena_allocator_init(MiB(4)); - I32Array array1 = wapp_array(i32, 1, 2, 3, 4, 5, 6, 7, 8); - I32Array array2 = wapp_array(i32, 1, 2); + WpAllocator allocator = wpMemArenaAllocatorInit(MiB(4)); + WpI32Array array1 = wpArray(i32, 1, 2, 3, 4, 5, 6, 7, 8); + WpI32Array array2 = wpArray(i32, 1, 2); i32 num = 10; - I32Array arr_ptr = wapp_array_append_alloc(i32, &allocator, array1, &num, ARRAY_INIT_NONE); + WpI32Array arr_ptr = wpArrayAppendAlloc(i32, &allocator, array1, &num, WP_ARRAY_INIT_NONE); result = arr_ptr == array1; u64 count = 4; @@ -177,100 +177,100 @@ TestFuncResult test_i32_array_append_alloc(void) { b8 running = true; while (running) { num = (i32)index; - arr_ptr = wapp_array_append_alloc(i32, &allocator, array2, &num, ARRAY_INIT_NONE); + arr_ptr = wpArrayAppendAlloc(i32, &allocator, array2, &num, WP_ARRAY_INIT_NONE); ++index; running = index < count; } result = result && arr_ptr != array2; - wapp_mem_arena_allocator_destroy(&allocator); + wpMemArenaAllocatorDestroy(&allocator); - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_i32_array_extend_alloc(void) { +WpTestFuncResult test_i32_array_extend_alloc(void) { b8 result; - Allocator allocator = wapp_mem_arena_allocator_init(MiB(4)); - I32Array array1 = wapp_array(i32, 1, 2, 3, 4, 5, 6, 7, 8); - I32Array array2 = wapp_array(i32, 1, 2); - I32Array array3 = wapp_array(i32, 1, 2, 3, 4); + WpAllocator allocator = wpMemArenaAllocatorInit(MiB(4)); + WpI32Array array1 = wpArray(i32, 1, 2, 3, 4, 5, 6, 7, 8); + WpI32Array array2 = wpArray(i32, 1, 2); + WpI32Array array3 = wpArray(i32, 1, 2, 3, 4); - I32Array array = wapp_array_extend_alloc(i32, &allocator, array1, array3, ARRAY_INIT_NONE); + WpI32Array array = wpArrayExtendAlloc(i32, &allocator, array1, array3, WP_ARRAY_INIT_NONE); result = array == array1; - array = wapp_array_extend_alloc(i32, &allocator, array2, array3, ARRAY_INIT_NONE); + array = wpArrayExtendAlloc(i32, &allocator, array2, array3, WP_ARRAY_INIT_NONE); result = result && array != array2; - wapp_mem_arena_allocator_destroy(&allocator); + wpMemArenaAllocatorDestroy(&allocator); - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_i32_array_copy_alloc(void) { +WpTestFuncResult test_i32_array_copy_alloc(void) { b8 result; - Allocator allocator = wapp_mem_arena_allocator_init(MiB(4)); - I32Array src = wapp_array(i32, 1, 2, 3, 4, 5); - I32Array dst1 = wapp_array(i32, 1, 2, 3, 4, 5, 6); - I32Array dst2 = wapp_array(i32, 1, 2); - I32Array array = nullptr; + WpAllocator allocator = wpMemArenaAllocatorInit(MiB(4)); + WpI32Array src = wpArray(i32, 1, 2, 3, 4, 5); + WpI32Array dst1 = wpArray(i32, 1, 2, 3, 4, 5, 6); + WpI32Array dst2 = wpArray(i32, 1, 2); + WpI32Array array = nullptr; u64 expected_count = 5; - array = wapp_array_copy_alloc(i32, &allocator, dst1, src, ARRAY_INIT_NONE); - result = wapp_array_count(array) == expected_count && array == dst1; + array = wpArrayCopyAlloc(i32, &allocator, dst1, src, WP_ARRAY_INIT_NONE); + result = wpArrayCount(array) == expected_count && array == dst1; u64 index = 0; b8 running = true; while (running) { - result = result && (*wapp_array_get(i32, src, index) == *wapp_array_get(i32, array, index)); + result = result && (*wpArrayGet(i32, src, index) == *wpArrayGet(i32, array, index)); ++index; running = index < expected_count; } expected_count = 5; - array = wapp_array_copy_alloc(i32, &allocator, dst2, src, ARRAY_INIT_NONE); - result = result && wapp_array_count(array) == expected_count && array != dst2; + array = wpArrayCopyAlloc(i32, &allocator, dst2, src, WP_ARRAY_INIT_NONE); + result = result && wpArrayCount(array) == expected_count && array != dst2; index = 0; running = true; while (running) { - result = result && (*wapp_array_get(i32, src, index) == *wapp_array_get(i32, array, index)); + result = result && (*wpArrayGet(i32, src, index) == *wpArrayGet(i32, array, index)); ++index; running = index < expected_count; } - wapp_mem_arena_allocator_destroy(&allocator); + wpMemArenaAllocatorDestroy(&allocator); - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_i32_array_clear(void) { +WpTestFuncResult test_i32_array_clear(void) { b8 result; - I32Array array = wapp_array(i32, 0, 1, 2, 3, 4, 5, 6, 7, 8); - result = wapp_array_count(array) == 9; + WpI32Array array = wpArray(i32, 0, 1, 2, 3, 4, 5, 6, 7, 8); + result = wpArrayCount(array) == 9; - wapp_array_clear(i32, array); + wpArrayClear(i32, array); - result = result && wapp_array_count(array) == 0; + result = result && wpArrayCount(array) == 0; - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_i32_array_pop(void) { +WpTestFuncResult test_i32_array_pop(void) { b8 result; - I32Array array1 = wapp_array(i32, 0, 1, 2, 3, 4, 5, 6, 7, 8); - I32Array array2 = wapp_array_with_capacity(i32, 32, ARRAY_INIT_NONE); + WpI32Array array1 = wpArray(i32, 0, 1, 2, 3, 4, 5, 6, 7, 8); + WpI32Array array2 = wpArrayWithCapacity(i32, 32, WP_ARRAY_INIT_NONE); - i32 item1 = wapp_array_pop(i32, array1); - i32 item2 = wapp_array_pop(i32, array2); + i32 item1 = wpArrayPop(i32, array1); + i32 item2 = wpArrayPop(i32, array2); result = item1 == 8 && item2 == 0; - return wapp_tester_result(result); + return wpTesterResult(result); } diff --git a/tests/array/test_i32_array.h b/tests/array/test_i32_array.h index aa7b9f8..05a932a 100644 --- a/tests/array/test_i32_array.h +++ b/tests/array/test_i32_array.h @@ -3,18 +3,18 @@ #include "wapp.h" -TestFuncResult test_i32_array(void); -TestFuncResult test_i32_array_with_capacity(void); -TestFuncResult test_i32_array_get(void); -TestFuncResult test_i32_array_set(void); -TestFuncResult test_i32_array_append_capped(void); -TestFuncResult test_i32_array_extend_capped(void); -TestFuncResult test_i32_array_copy_capped(void); -TestFuncResult test_i32_array_alloc_capacity(void); -TestFuncResult test_i32_array_append_alloc(void); -TestFuncResult test_i32_array_extend_alloc(void); -TestFuncResult test_i32_array_copy_alloc(void); -TestFuncResult test_i32_array_pop(void); -TestFuncResult test_i32_array_clear(void); +WpTestFuncResult test_i32_array(void); +WpTestFuncResult test_i32_array_with_capacity(void); +WpTestFuncResult test_i32_array_get(void); +WpTestFuncResult test_i32_array_set(void); +WpTestFuncResult test_i32_array_append_capped(void); +WpTestFuncResult test_i32_array_extend_capped(void); +WpTestFuncResult test_i32_array_copy_capped(void); +WpTestFuncResult test_i32_array_alloc_capacity(void); +WpTestFuncResult test_i32_array_append_alloc(void); +WpTestFuncResult test_i32_array_extend_alloc(void); +WpTestFuncResult test_i32_array_copy_alloc(void); +WpTestFuncResult test_i32_array_pop(void); +WpTestFuncResult test_i32_array_clear(void); #endif // !TEST_INT_ARRAY_H diff --git a/tests/array/test_str8_array.c b/tests/array/test_str8_array.c index 392e622..fc2827b 100644 --- a/tests/array/test_str8_array.c +++ b/tests/array/test_str8_array.c @@ -2,24 +2,24 @@ #include "test_str8_array.h" -TestFuncResult test_str8_array(void) { +WpTestFuncResult test_str8_array(void) { b8 result; - Str8 expected[] = {wapp_str8_lit("Hello"), wapp_str8_lit("Hi"), wapp_str8_lit("Bye")}; - Str8Array array = wapp_array(Str8, wapp_str8_lit("Hello"), wapp_str8_lit("Hi"), wapp_str8_lit("Bye")); - result = wapp_array_count(array) == 3 && wapp_array_capacity(array) == 8; + WpStr8 expected[] = {wpStr8Lit("Hello"), wpStr8Lit("Hi"), wpStr8Lit("Bye")}; + WpStr8Array array = wpArray(WpStr8, wpStr8Lit("Hello"), wpStr8Lit("Hi"), wpStr8Lit("Bye")); + result = wpArrayCount(array) == 3 && wpArrayCapacity(array) == 8; - Str8 *item; - u64 count = wapp_array_count(array); + WpStr8 *item; + u64 count = wpArrayCount(array); u64 index = 0; b8 running = true; while (running) { - item = wapp_array_get(Str8, array, index); - result = result && item && (wapp_str8_equal(item, &expected[index])); + item = wpArrayGet(WpStr8, array, index); + result = result && item && (wpStr8Equal(item, &expected[index])); ++index; running = index < count; } - return wapp_tester_result(result); + return wpTesterResult(result); } diff --git a/tests/array/test_str8_array.cc b/tests/array/test_str8_array.cc index 4338854..a949ab3 100644 --- a/tests/array/test_str8_array.cc +++ b/tests/array/test_str8_array.cc @@ -2,29 +2,29 @@ #include "test_str8_array.h" -TestFuncResult test_str8_array(void) { +WpTestFuncResult test_str8_array(void) { b8 result; - Str8 expected[] = {wapp_str8_lit("Hello"), wapp_str8_lit("Hi"), wapp_str8_lit("Bye")}; + WpStr8 expected[] = {wpStr8Lit("Hello"), wpStr8Lit("Hi"), wpStr8Lit("Bye")}; - Str8 str1 = wapp_str8_lit("Hello"); - Str8 str2 = wapp_str8_lit("Hi"); - Str8 str3 = wapp_str8_lit("Bye"); - Str8Array array = wapp_array(Str8, str1, str2, str3); + WpStr8 str1 = wpStr8Lit("Hello"); + WpStr8 str2 = wpStr8Lit("Hi"); + WpStr8 str3 = wpStr8Lit("Bye"); + WpStr8Array array = wpArray(WpStr8, str1, str2, str3); - result = wapp_array_count(array) == 3 && wapp_array_capacity(array) == 8; + result = wpArrayCount(array) == 3 && wpArrayCapacity(array) == 8; - Str8 *item; - u64 count = wapp_array_count(array); + WpStr8 *item; + u64 count = wpArrayCount(array); u64 index = 0; b8 running = true; while (running) { - item = wapp_array_get(Str8, array, index); - result = result && item && (wapp_str8_equal(item, &expected[index])); + item = wpArrayGet(WpStr8, array, index); + result = result && item && (wpStr8Equal(item, &expected[index])); ++index; running = index < count; } - return wapp_tester_result(result); + return wpTesterResult(result); } diff --git a/tests/array/test_str8_array.h b/tests/array/test_str8_array.h index 945e5f3..7b71b56 100644 --- a/tests/array/test_str8_array.h +++ b/tests/array/test_str8_array.h @@ -5,6 +5,6 @@ #include "wapp.h" -TestFuncResult test_str8_array(void); +WpTestFuncResult test_str8_array(void); #endif // !TEST_STR8_ARRAY_H diff --git a/tests/cpath/test_cpath.c b/tests/cpath/test_cpath.c index a24253e..16c3dbb 100644 --- a/tests/cpath/test_cpath.c +++ b/tests/cpath/test_cpath.c @@ -6,176 +6,176 @@ #define MAIN_BUF_SIZE 4096 #define TMP_BUF_SIZE 1024 -TestFuncResult test_cpath_join_path(void) { +WpTestFuncResult test_cpath_join_path(void) { 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); + WpStr8 expected = wpStr8Buf(MAIN_BUF_SIZE); + WpStr8 out = wpStr8Buf(MAIN_BUF_SIZE); + WpStr8 tmp = wpStr8Buf(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); + wpStr8Format(&expected, "%chome%cabdelrahman%cDocuments", WP_PATH_SEP, WP_PATH_SEP, WP_PATH_SEP); + wpStr8Format(&tmp, "%c", WP_PATH_SEP); - Str8List parts = wapp_dbl_list(Str8); - wapp_dbl_list_push_back(Str8, &parts, &tmp); - wapp_dbl_list_push_back(Str8, &parts, &wapp_str8_lit("home")); - wapp_dbl_list_push_back(Str8, &parts, &wapp_str8_lit("abdelrahman")); - wapp_dbl_list_push_back(Str8, &parts, &wapp_str8_lit("Documents")); + WpStr8List parts = wpDblList(WpStr8); + wpDblListPushBack(WpStr8, &parts, &tmp); + wpDblListPushBack(WpStr8, &parts, &wpStr8Lit("home")); + wpDblListPushBack(WpStr8, &parts, &wpStr8Lit("abdelrahman")); + wpDblListPushBack(WpStr8, &parts, &wpStr8Lit("Documents")); - wapp_cpath_join_path(&out, &parts); - result = wapp_str8_equal(&out, &expected); + wpCpathJoinPath(&out, &parts); + result = wpStr8Equal(&out, &expected); - wapp_dbl_list_pop_front(Str8, &parts); + wpDblListPopFront(WpStr8, &parts); - wapp_str8_format(&expected, "home%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_PATH_SEP); + wpStr8Format(&expected, "home%cabdelrahman%cDocuments", WP_PATH_SEP, WP_PATH_SEP); - wapp_cpath_join_path(&out, &parts); - result = result && wapp_str8_equal(&out, &expected); + wpCpathJoinPath(&out, &parts); + result = result && wpStr8Equal(&out, &expected); - wapp_str8_concat_capped(&tmp, &wapp_str8_lit_ro("home")); - wapp_dbl_list_pop_front(Str8, &parts); - wapp_dbl_list_push_front(Str8, &parts, &tmp); + wpStr8ConcatCapped(&tmp, &wpStr8LitRo("home")); + wpDblListPopFront(WpStr8, &parts); + wpDblListPushFront(WpStr8, &parts, &tmp); - wapp_str8_format(&expected, "%chome%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_PATH_SEP, WAPP_PATH_SEP); + wpStr8Format(&expected, "%chome%cabdelrahman%cDocuments", WP_PATH_SEP, WP_PATH_SEP, WP_PATH_SEP); - wapp_cpath_join_path(&out, &parts); - result = result && wapp_str8_equal(&out, &expected); + wpCpathJoinPath(&out, &parts); + result = result && wpStr8Equal(&out, &expected); - wapp_str8_format(&tmp, "home%c", WAPP_PATH_SEP); - wapp_dbl_list_pop_front(Str8, &parts); - wapp_dbl_list_push_front(Str8, &parts, &wapp_str8_lit("home")); + wpStr8Format(&tmp, "home%c", WP_PATH_SEP); + wpDblListPopFront(WpStr8, &parts); + wpDblListPushFront(WpStr8, &parts, &wpStr8Lit("home")); - wapp_str8_format(&expected, "home%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_PATH_SEP); + wpStr8Format(&expected, "home%cabdelrahman%cDocuments", WP_PATH_SEP, WP_PATH_SEP); - wapp_cpath_join_path(&out, &parts); - result = result && wapp_str8_equal(&out, &expected); + wpCpathJoinPath(&out, &parts); + result = result && wpStr8Equal(&out, &expected); - wapp_dbl_list_empty(Str8, &parts); + wpDblListEmpty(WpStr8, &parts); - wapp_str8_format(&tmp, "%chome", WAPP_PATH_SEP); - wapp_dbl_list_push_back(Str8, &parts, &tmp); - wapp_dbl_list_push_back(Str8, &parts, &wapp_str8_lit("")); + wpStr8Format(&tmp, "%chome", WP_PATH_SEP); + wpDblListPushBack(WpStr8, &parts, &tmp); + wpDblListPushBack(WpStr8, &parts, &wpStr8Lit("")); - wapp_str8_format(&expected, "%chome", WAPP_PATH_SEP); + wpStr8Format(&expected, "%chome", WP_PATH_SEP); - wapp_cpath_join_path(&out, &parts); - result = result && wapp_str8_equal(&out, &expected); + wpCpathJoinPath(&out, &parts); + result = result && wpStr8Equal(&out, &expected); - wapp_dbl_list_pop_front(Str8, &parts); - wapp_dbl_list_push_back(Str8, &parts, &wapp_str8_lit("")); + wpDblListPopFront(WpStr8, &parts); + wpDblListPushBack(WpStr8, &parts, &wpStr8Lit("")); - wapp_str8_format(&expected, "%s", ""); + wpStr8Format(&expected, "%s", ""); - wapp_cpath_join_path(&out, &parts); - result = result && wapp_str8_equal(&out, &expected); + wpCpathJoinPath(&out, &parts); + result = result && wpStr8Equal(&out, &expected); - wapp_dbl_list_pop_back(Str8, &parts); - wapp_dbl_list_push_back(Str8, &parts, &wapp_str8_lit("home")); + wpDblListPopBack(WpStr8, &parts); + wpDblListPushBack(WpStr8, &parts, &wpStr8Lit("home")); - wapp_str8_copy_cstr_capped(&expected, "home"); + wpStr8CopyCstrCapped(&expected, "home"); - wapp_cpath_join_path(&out, &parts); - result = result && wapp_str8_equal(&out, &expected); + wpCpathJoinPath(&out, &parts); + result = result && wpStr8Equal(&out, &expected); - return wapp_tester_result(result); + return wpTesterResult(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); +WpTestFuncResult test_cpath_dirname(void) { + WpAllocator arena = wpMemArenaAllocatorInit(MiB(8)); + if (wpMemAllocatorInvalid(&arena)) { + return wpTesterResult(false); } b8 result; - Str8 *output = NULL; + WpStr8 *output = NULL; - Str8 expected = wapp_str8_buf(MAIN_BUF_SIZE); - Str8 tmp = wapp_str8_buf(TMP_BUF_SIZE); + WpStr8 expected = wpStr8Buf(MAIN_BUF_SIZE); + WpStr8 tmp = wpStr8Buf(TMP_BUF_SIZE); // CASE 1 - wapp_str8_format(&tmp, "%c", WAPP_PATH_SEP); - wapp_str8_format(&expected, "%c", WAPP_PATH_SEP); + wpStr8Format(&tmp, "%c", WP_PATH_SEP); + wpStr8Format(&expected, "%c", WP_PATH_SEP); - output = wapp_cpath_dirname(&arena, &tmp); - result = output != NULL && wapp_str8_equal(output, &expected); + output = wpCpathDirname(&arena, &tmp); + result = output != NULL && wpStr8Equal(output, &expected); // CASE 2 - wapp_str8_format(&expected, "%s", "."); + wpStr8Format(&expected, "%s", "."); - output = wapp_cpath_dirname(&arena, &wapp_str8_lit("home")); - result = result && output != NULL && wapp_str8_equal(output, &expected); + output = wpCpathDirname(&arena, &wpStr8Lit("home")); + result = result && output != NULL && wpStr8Equal(output, &expected); // CASE 3 - output = wapp_cpath_dirname(&arena, &wapp_str8_lit("")); - result = result && output != NULL && wapp_str8_equal(output, &expected); + output = wpCpathDirname(&arena, &wpStr8Lit("")); + result = result && output != NULL && wpStr8Equal(output, &expected); // CASE 4 - wapp_str8_format(&tmp, "%chome%ctest", WAPP_PATH_SEP, WAPP_PATH_SEP); - wapp_str8_format(&expected, "%chome", WAPP_PATH_SEP); + wpStr8Format(&tmp, "%chome%ctest", WP_PATH_SEP, WP_PATH_SEP); + wpStr8Format(&expected, "%chome", WP_PATH_SEP); - output = wapp_cpath_dirname(&arena, &tmp); - result = result && output != NULL && wapp_str8_equal(output, &expected); + output = wpCpathDirname(&arena, &tmp); + result = result && output != NULL && wpStr8Equal(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); + wpStr8Format(&tmp, "%chome%ctest%c", WP_PATH_SEP, WP_PATH_SEP, WP_PATH_SEP); + wpStr8Format(&expected, "%chome", WP_PATH_SEP); - output = wapp_cpath_dirname(&arena, &tmp); - result = result && output != NULL && wapp_str8_equal(output, &expected); + output = wpCpathDirname(&arena, &tmp); + result = result && output != NULL && wpStr8Equal(output, &expected); - wapp_mem_arena_allocator_destroy(&arena); + wpMemArenaAllocatorDestroy(&arena); - return wapp_tester_result(result); + return wpTesterResult(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); +WpTestFuncResult test_cpath_dirup(void) { + WpAllocator arena = wpMemArenaAllocatorInit(MiB(8)); + if (wpMemAllocatorInvalid(&arena)) { + return wpTesterResult(false); } b8 result; - Str8 *output = NULL; + WpStr8 *output = NULL; - Str8 expected = wapp_str8_buf(MAIN_BUF_SIZE); - Str8 tmp = wapp_str8_buf(TMP_BUF_SIZE); + WpStr8 expected = wpStr8Buf(MAIN_BUF_SIZE); + WpStr8 tmp = wpStr8Buf(TMP_BUF_SIZE); // CASE 1 - wapp_str8_format(&tmp, "%c", WAPP_PATH_SEP); - wapp_str8_format(&expected, "%c", WAPP_PATH_SEP); + wpStr8Format(&tmp, "%c", WP_PATH_SEP); + wpStr8Format(&expected, "%c", WP_PATH_SEP); - output = wapp_cpath_dirup(&arena, &tmp, 3); - result = output != NULL && wapp_str8_equal(output, &expected); + output = wpCpathDirup(&arena, &tmp, 3); + result = output != NULL && wpStr8Equal(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); + wpStr8Format(&tmp, "%chome%cabdelrahman%cDocuments", WP_PATH_SEP, WP_PATH_SEP, WP_PATH_SEP); + wpStr8Format(&expected, "%c", WP_PATH_SEP); - output = wapp_cpath_dirup(&arena, &tmp, 3); - result = result && output != NULL && wapp_str8_equal(output, &expected); + output = wpCpathDirup(&arena, &tmp, 3); + result = result && output != NULL && wpStr8Equal(output, &expected); // CASE 3 - wapp_str8_format(&tmp, "home%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_PATH_SEP); - wapp_str8_copy_cstr_capped(&expected, "."); + wpStr8Format(&tmp, "home%cabdelrahman%cDocuments", WP_PATH_SEP, WP_PATH_SEP); + wpStr8CopyCstrCapped(&expected, "."); - output = wapp_cpath_dirup(&arena, &tmp, 3); - result = result && output != NULL && wapp_str8_equal(output, &expected); + output = wpCpathDirup(&arena, &tmp, 3); + result = result && output != NULL && wpStr8Equal(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); + wpStr8Format(&tmp, "%chome%cabdelrahman%cDocuments", WP_PATH_SEP, WP_PATH_SEP, WP_PATH_SEP); + wpStr8Format(&expected, "%chome", WP_PATH_SEP); - output = wapp_cpath_dirup(&arena, &tmp, 2); - result = result && output != NULL && wapp_str8_equal(output, &expected); + output = wpCpathDirup(&arena, &tmp, 2); + result = result && output != NULL && wpStr8Equal(output, &expected); // CASE 5 - wapp_str8_format(&tmp, "home%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_PATH_SEP); - wapp_str8_copy_cstr_capped(&expected, "home"); + wpStr8Format(&tmp, "home%cabdelrahman%cDocuments", WP_PATH_SEP, WP_PATH_SEP); + wpStr8CopyCstrCapped(&expected, "home"); - output = wapp_cpath_dirup(&arena, &tmp, 2); - result = result && output != NULL && wapp_str8_equal(output, &expected); + output = wpCpathDirup(&arena, &tmp, 2); + result = result && output != NULL && wpStr8Equal(output, &expected); - wapp_mem_arena_allocator_destroy(&arena); + wpMemArenaAllocatorDestroy(&arena); - return wapp_tester_result(result); + return wpTesterResult(result); } diff --git a/tests/cpath/test_cpath.cc b/tests/cpath/test_cpath.cc index c012e29..7ec7a30 100644 --- a/tests/cpath/test_cpath.cc +++ b/tests/cpath/test_cpath.cc @@ -6,196 +6,196 @@ #define MAIN_BUF_SIZE 4096 #define TMP_BUF_SIZE 1024 -TestFuncResult test_cpath_join_path(void) { +WpTestFuncResult test_cpath_join_path(void) { 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); + WpStr8 expected = wpStr8Buf(MAIN_BUF_SIZE); + WpStr8 out = wpStr8Buf(MAIN_BUF_SIZE); + WpStr8 tmp = wpStr8Buf(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); + wpStr8Format(&expected, "%chome%cabdelrahman%cDocuments", WP_PATH_SEP, WP_PATH_SEP, WP_PATH_SEP); + wpStr8Format(&tmp, "%c", WP_PATH_SEP); - Str8List parts = wapp_dbl_list(Str8); + WpStr8List parts = wpDblList(WpStr8); - wapp_dbl_list_push_back(Str8, &parts, &tmp); + wpDblListPushBack(WpStr8, &parts, &tmp); - Str8 home = wapp_str8_lit("home"); - wapp_dbl_list_push_back(Str8, &parts, &home); + WpStr8 home = wpStr8Lit("home"); + wpDblListPushBack(WpStr8, &parts, &home); - Str8 user = wapp_str8_lit("abdelrahman"); - wapp_dbl_list_push_back(Str8, &parts, &user); + WpStr8 user = wpStr8Lit("abdelrahman"); + wpDblListPushBack(WpStr8, &parts, &user); - Str8 docs = wapp_str8_lit("Documents"); - wapp_dbl_list_push_back(Str8, &parts, &docs); + WpStr8 docs = wpStr8Lit("Documents"); + wpDblListPushBack(WpStr8, &parts, &docs); - wapp_cpath_join_path(&out, &parts); - result = wapp_str8_equal(&out, &expected); + wpCpathJoinPath(&out, &parts); + result = wpStr8Equal(&out, &expected); - wapp_dbl_list_pop_front(Str8, &parts); + wpDblListPopFront(WpStr8, &parts); - wapp_str8_format(&expected, "home%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_PATH_SEP); + wpStr8Format(&expected, "home%cabdelrahman%cDocuments", WP_PATH_SEP, WP_PATH_SEP); - wapp_cpath_join_path(&out, &parts); - result = result && wapp_str8_equal(&out, &expected); + wpCpathJoinPath(&out, &parts); + result = result && wpStr8Equal(&out, &expected); - Str8RO str = wapp_str8_lit_ro("home"); - wapp_str8_concat_capped(&tmp, &str); - wapp_dbl_list_pop_front(Str8, &parts); + WpStr8RO str = wpStr8LitRo("home"); + wpStr8ConcatCapped(&tmp, &str); + wpDblListPopFront(WpStr8, &parts); - wapp_dbl_list_push_front(Str8, &parts, &tmp); + wpDblListPushFront(WpStr8, &parts, &tmp); - wapp_str8_format(&expected, "%chome%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_PATH_SEP, WAPP_PATH_SEP); + wpStr8Format(&expected, "%chome%cabdelrahman%cDocuments", WP_PATH_SEP, WP_PATH_SEP, WP_PATH_SEP); - wapp_cpath_join_path(&out, &parts); - result = result && wapp_str8_equal(&out, &expected); + wpCpathJoinPath(&out, &parts); + result = result && wpStr8Equal(&out, &expected); - wapp_str8_format(&tmp, "home%c", WAPP_PATH_SEP); - wapp_dbl_list_pop_front(Str8, &parts); + wpStr8Format(&tmp, "home%c", WP_PATH_SEP); + wpDblListPopFront(WpStr8, &parts); - Str8 home_2 = wapp_str8_lit("home"); - wapp_dbl_list_push_front(Str8, &parts, &home_2); + WpStr8 home_2 = wpStr8Lit("home"); + wpDblListPushFront(WpStr8, &parts, &home_2); - wapp_str8_format(&expected, "home%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_PATH_SEP); + wpStr8Format(&expected, "home%cabdelrahman%cDocuments", WP_PATH_SEP, WP_PATH_SEP); - wapp_cpath_join_path(&out, &parts); - result = result && wapp_str8_equal(&out, &expected); + wpCpathJoinPath(&out, &parts); + result = result && wpStr8Equal(&out, &expected); - wapp_dbl_list_empty(Str8, &parts); + wpDblListEmpty(WpStr8, &parts); - wapp_str8_format(&tmp, "%chome", WAPP_PATH_SEP); + wpStr8Format(&tmp, "%chome", WP_PATH_SEP); - wapp_dbl_list_push_back(Str8, &parts, &tmp); + wpDblListPushBack(WpStr8, &parts, &tmp); - Str8 empty = wapp_str8_lit(""); - wapp_dbl_list_push_back(Str8, &parts, &empty); + WpStr8 empty = wpStr8Lit(""); + wpDblListPushBack(WpStr8, &parts, &empty); - wapp_str8_format(&expected, "%chome", WAPP_PATH_SEP); + wpStr8Format(&expected, "%chome", WP_PATH_SEP); - wapp_cpath_join_path(&out, &parts); - result = result && wapp_str8_equal(&out, &expected); + wpCpathJoinPath(&out, &parts); + result = result && wpStr8Equal(&out, &expected); - wapp_dbl_list_pop_front(Str8, &parts); + wpDblListPopFront(WpStr8, &parts); - Str8 empty_2 = wapp_str8_lit(""); - wapp_dbl_list_push_back(Str8, &parts, &empty_2); + WpStr8 empty_2 = wpStr8Lit(""); + wpDblListPushBack(WpStr8, &parts, &empty_2); - wapp_str8_format(&expected, "%s", ""); + wpStr8Format(&expected, "%s", ""); - wapp_cpath_join_path(&out, &parts); - result = result && wapp_str8_equal(&out, &expected); + wpCpathJoinPath(&out, &parts); + result = result && wpStr8Equal(&out, &expected); - wapp_dbl_list_pop_back(Str8, &parts); + wpDblListPopBack(WpStr8, &parts); - Str8 home_3 = wapp_str8_lit("home"); - wapp_dbl_list_push_back(Str8, &parts, &home_3); + WpStr8 home_3 = wpStr8Lit("home"); + wpDblListPushBack(WpStr8, &parts, &home_3); - wapp_str8_copy_cstr_capped(&expected, "home"); + wpStr8CopyCstrCapped(&expected, "home"); - wapp_cpath_join_path(&out, &parts); - result = result && wapp_str8_equal(&out, &expected); + wpCpathJoinPath(&out, &parts); + result = result && wpStr8Equal(&out, &expected); - return wapp_tester_result(result); + return wpTesterResult(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); +WpTestFuncResult test_cpath_dirname(void) { + WpAllocator arena = wpMemArenaAllocatorInit(MiB(8)); + if (wpMemAllocatorInvalid(&arena)) { + return wpTesterResult(false); } b8 result; - Str8 *output = nullptr; + WpStr8 *output = nullptr; - Str8 expected = wapp_str8_buf(MAIN_BUF_SIZE); - Str8 tmp = wapp_str8_buf(TMP_BUF_SIZE); + WpStr8 expected = wpStr8Buf(MAIN_BUF_SIZE); + WpStr8 tmp = wpStr8Buf(TMP_BUF_SIZE); // CASE 1 - wapp_str8_format(&tmp, "%c", WAPP_PATH_SEP); - wapp_str8_format(&expected, "%c", WAPP_PATH_SEP); + wpStr8Format(&tmp, "%c", WP_PATH_SEP); + wpStr8Format(&expected, "%c", WP_PATH_SEP); - output = wapp_cpath_dirname(&arena, &tmp); - result = output != nullptr && wapp_str8_equal(output, &expected); + output = wpCpathDirname(&arena, &tmp); + result = output != nullptr && wpStr8Equal(output, &expected); // CASE 2 - wapp_str8_format(&expected, "%s", "."); + wpStr8Format(&expected, "%s", "."); - Str8 path = wapp_str8_lit("home"); - output = wapp_cpath_dirname(&arena, &path); - result = result && output != nullptr && wapp_str8_equal(output, &expected); + WpStr8 path = wpStr8Lit("home"); + output = wpCpathDirname(&arena, &path); + result = result && output != nullptr && wpStr8Equal(output, &expected); // CASE 3 - path = wapp_str8_lit(""); - output = wapp_cpath_dirname(&arena, &path); - result = result && output != nullptr && wapp_str8_equal(output, &expected); + path = wpStr8Lit(""); + output = wpCpathDirname(&arena, &path); + result = result && output != nullptr && wpStr8Equal(output, &expected); // CASE 4 - wapp_str8_format(&tmp, "%chome%ctest", WAPP_PATH_SEP, WAPP_PATH_SEP); - wapp_str8_format(&expected, "%chome", WAPP_PATH_SEP); + wpStr8Format(&tmp, "%chome%ctest", WP_PATH_SEP, WP_PATH_SEP); + wpStr8Format(&expected, "%chome", WP_PATH_SEP); - output = wapp_cpath_dirname(&arena, &tmp); - result = result && output != nullptr && wapp_str8_equal(output, &expected); + output = wpCpathDirname(&arena, &tmp); + result = result && output != nullptr && wpStr8Equal(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); + wpStr8Format(&tmp, "%chome%ctest%c", WP_PATH_SEP, WP_PATH_SEP, WP_PATH_SEP); + wpStr8Format(&expected, "%chome", WP_PATH_SEP); - output = wapp_cpath_dirname(&arena, &tmp); - result = result && output != nullptr && wapp_str8_equal(output, &expected); + output = wpCpathDirname(&arena, &tmp); + result = result && output != nullptr && wpStr8Equal(output, &expected); - wapp_mem_arena_allocator_destroy(&arena); + wpMemArenaAllocatorDestroy(&arena); - return wapp_tester_result(result); + return wpTesterResult(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); +WpTestFuncResult test_cpath_dirup(void) { + WpAllocator arena = wpMemArenaAllocatorInit(MiB(8)); + if (wpMemAllocatorInvalid(&arena)) { + return wpTesterResult(false); } b8 result; - Str8 *output = nullptr; + WpStr8 *output = nullptr; - Str8 expected = wapp_str8_buf(MAIN_BUF_SIZE); - Str8 tmp = wapp_str8_buf(TMP_BUF_SIZE); + WpStr8 expected = wpStr8Buf(MAIN_BUF_SIZE); + WpStr8 tmp = wpStr8Buf(TMP_BUF_SIZE); // CASE 1 - wapp_str8_format(&tmp, "%c", WAPP_PATH_SEP); - wapp_str8_format(&expected, "%c", WAPP_PATH_SEP); + wpStr8Format(&tmp, "%c", WP_PATH_SEP); + wpStr8Format(&expected, "%c", WP_PATH_SEP); - output = wapp_cpath_dirup(&arena, &tmp, 3); - result = output != nullptr && wapp_str8_equal(output, &expected); + output = wpCpathDirup(&arena, &tmp, 3); + result = output != nullptr && wpStr8Equal(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); + wpStr8Format(&tmp, "%chome%cabdelrahman%cDocuments", WP_PATH_SEP, WP_PATH_SEP, WP_PATH_SEP); + wpStr8Format(&expected, "%c", WP_PATH_SEP); - output = wapp_cpath_dirup(&arena, &tmp, 3); - result = result && output != nullptr && wapp_str8_equal(output, &expected); + output = wpCpathDirup(&arena, &tmp, 3); + result = result && output != nullptr && wpStr8Equal(output, &expected); // CASE 3 - wapp_str8_format(&tmp, "home%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_PATH_SEP); - wapp_str8_copy_cstr_capped(&expected, "."); + wpStr8Format(&tmp, "home%cabdelrahman%cDocuments", WP_PATH_SEP, WP_PATH_SEP); + wpStr8CopyCstrCapped(&expected, "."); - output = wapp_cpath_dirup(&arena, &tmp, 3); - result = result && output != nullptr && wapp_str8_equal(output, &expected); + output = wpCpathDirup(&arena, &tmp, 3); + result = result && output != nullptr && wpStr8Equal(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); + wpStr8Format(&tmp, "%chome%cabdelrahman%cDocuments", WP_PATH_SEP, WP_PATH_SEP, WP_PATH_SEP); + wpStr8Format(&expected, "%chome", WP_PATH_SEP); - output = wapp_cpath_dirup(&arena, &tmp, 2); - result = result && output != nullptr && wapp_str8_equal(output, &expected); + output = wpCpathDirup(&arena, &tmp, 2); + result = result && output != nullptr && wpStr8Equal(output, &expected); // CASE 5 - wapp_str8_format(&tmp, "home%cabdelrahman%cDocuments", WAPP_PATH_SEP, WAPP_PATH_SEP); - wapp_str8_copy_cstr_capped(&expected, "home"); + wpStr8Format(&tmp, "home%cabdelrahman%cDocuments", WP_PATH_SEP, WP_PATH_SEP); + wpStr8CopyCstrCapped(&expected, "home"); - output = wapp_cpath_dirup(&arena, &tmp, 2); - result = result && output != nullptr && wapp_str8_equal(output, &expected); + output = wpCpathDirup(&arena, &tmp, 2); + result = result && output != nullptr && wpStr8Equal(output, &expected); - wapp_mem_arena_allocator_destroy(&arena); + wpMemArenaAllocatorDestroy(&arena); - return wapp_tester_result(result); + return wpTesterResult(result); } diff --git a/tests/cpath/test_cpath.h b/tests/cpath/test_cpath.h index 6613009..33efae0 100644 --- a/tests/cpath/test_cpath.h +++ b/tests/cpath/test_cpath.h @@ -3,8 +3,8 @@ #include "wapp.h" -TestFuncResult test_cpath_join_path(void); -TestFuncResult test_cpath_dirname(void); -TestFuncResult test_cpath_dirup(void); +WpTestFuncResult test_cpath_join_path(void); +WpTestFuncResult test_cpath_dirname(void); +WpTestFuncResult test_cpath_dirup(void); #endif // !TEST_CPATH_H diff --git a/tests/file/test_file.c b/tests/file/test_file.c index 7025e8d..d49ef8c 100644 --- a/tests/file/test_file.c +++ b/tests/file/test_file.c @@ -3,48 +3,48 @@ #include "test_file.h" #define DST_CAPACITY 5 -wapp_intern Allocator arena = {0}; -wapp_intern Str8RO test_filename = wapp_str8_lit_ro_initialiser_list("wapptest.bin"); -wapp_intern Str8RO new_filename = wapp_str8_lit_ro_initialiser_list("wapptest2.bin"); -wapp_intern WFile *test_fp = NULL; -wapp_intern I32Array src_array1 = wapp_array(i32, 0, 1, 2, 3, 4); -wapp_intern I32Array src_array2 = wapp_array(i32, 5, 6, 7, 8, 9); -wapp_intern I32Array src_array3 = wapp_array(i32, 10, 11, 12, 13, 14); -wapp_intern I32Array dst_array = wapp_array_with_capacity(i32, DST_CAPACITY, false); -wapp_intern i32 dst_buf[DST_CAPACITY] = {0}; +wp_intern WpAllocator arena = {0}; +wp_intern WpStr8RO test_filename = wpStr8LitRoInitialiserList("wapptest.bin"); +wp_intern WpStr8RO new_filename = wpStr8LitRoInitialiserList("wapptest2.bin"); +wp_intern WpFile *test_fp = NULL; +wp_intern WpI32Array src_array1 = wpArray(i32, 0, 1, 2, 3, 4); +wp_intern WpI32Array src_array2 = wpArray(i32, 5, 6, 7, 8, 9); +wp_intern WpI32Array src_array3 = wpArray(i32, 10, 11, 12, 13, 14); +wp_intern WpI32Array dst_array = wpArrayWithCapacity(i32, DST_CAPACITY, false); +wp_intern i32 dst_buf[DST_CAPACITY] = {0}; -TestFuncResult test_wapp_file_open(void) { - arena = wapp_mem_arena_allocator_init(KiB(16)); - test_fp = wapp_file_open(&arena, &test_filename, WAPP_ACCESS_WRITE_EX); - return wapp_tester_result(test_fp != NULL); +WpTestFuncResult test_wapp_file_open(void) { + arena = wpMemArenaAllocatorInit(KiB(16)); + test_fp = wpFileOpen(&arena, &test_filename, WP_ACCESS_WRITE_EX); + return wpTesterResult(test_fp != NULL); } -TestFuncResult test_wapp_file_get_current_position(void) { - i64 pos = wapp_file_get_current_position(test_fp); - return wapp_tester_result(pos == 0); +WpTestFuncResult test_wapp_file_get_current_position(void) { + i64 pos = wpFileGetCurrentPosition(test_fp); + return wpTesterResult(pos == 0); } -TestFuncResult test_wapp_file_seek(void) { - wapp_file_write_array((GenericArray)src_array1, test_fp, wapp_array_count(src_array1)); +WpTestFuncResult test_wapp_file_seek(void) { + wpFileWriteArray((WpArray)src_array1, test_fp, wpArrayCount(src_array1)); - i64 seek_result = wapp_file_seek(test_fp, 0, WAPP_SEEK_END); - b8 result = seek_result == (i64)(wapp_array_count(src_array1) * wapp_array_item_size(src_array1)); + i64 seek_result = wpFileSeek(test_fp, 0, WP_SEEK_END); + b8 result = seek_result == (i64)(wpArrayCount(src_array1) * wpArrayItemSize(src_array1)); - wapp_file_seek(test_fp, 0, WAPP_SEEK_START); + wpFileSeek(test_fp, 0, WP_SEEK_START); - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_wapp_file_get_length(void) { - i64 length = wapp_file_get_length(test_fp); - return wapp_tester_result(length == (i64)(wapp_array_count(src_array1) * wapp_array_item_size(src_array1))); +WpTestFuncResult test_wapp_file_get_length(void) { + i64 length = wpFileGetLength(test_fp); + return wpTesterResult(length == (i64)(wpArrayCount(src_array1) * wpArrayItemSize(src_array1))); } -TestFuncResult test_wapp_file_read(void) { - wapp_file_seek(test_fp, 0, WAPP_SEEK_START); +WpTestFuncResult test_wapp_file_read(void) { + wpFileSeek(test_fp, 0, WP_SEEK_START); u64 byte_count = DST_CAPACITY * sizeof(i32); - u64 count = wapp_file_read((void *)dst_buf, test_fp, byte_count); + u64 count = wpFileRead((void *)dst_buf, test_fp, byte_count); b8 result = count == byte_count; // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of @@ -52,67 +52,67 @@ TestFuncResult test_wapp_file_read(void) { u64 index = 0; b8 running = true; while (running) { - result = result && (dst_buf[index] == *wapp_array_get(i32, src_array1, index)); + result = result && (dst_buf[index] == *wpArrayGet(i32, src_array1, index)); ++index; running = index < DST_CAPACITY; } - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_wapp_file_write(void) { - wapp_file_seek(test_fp, 0, WAPP_SEEK_END); +WpTestFuncResult test_wapp_file_write(void) { + wpFileSeek(test_fp, 0, WP_SEEK_END); - u64 expected_count = wapp_array_count(src_array2) * wapp_array_item_size(src_array2); - i64 count = wapp_file_write((void *)src_array2, test_fp, expected_count); + u64 expected_count = wpArrayCount(src_array2) * wpArrayItemSize(src_array2); + i64 count = wpFileWrite((void *)src_array2, test_fp, expected_count); - return wapp_tester_result(count >= 0 && (u64)count == expected_count); + return wpTesterResult(count >= 0 && (u64)count == expected_count); } -TestFuncResult test_wapp_file_read_array(void) { - wapp_file_seek(test_fp, 0, WAPP_SEEK_START); +WpTestFuncResult test_wapp_file_read_array(void) { + wpFileSeek(test_fp, 0, WP_SEEK_START); - u64 count = wapp_file_read_array((GenericArray)dst_array, test_fp, wapp_array_count(src_array1)); - b8 result = count == wapp_array_count(src_array1) && - wapp_array_count(dst_array) == wapp_array_count(src_array1); + u64 count = wpFileReadArray((WpArray)dst_array, test_fp, wpArrayCount(src_array1)); + b8 result = count == wpArrayCount(src_array1) && + wpArrayCount(dst_array) == wpArrayCount(src_array1); // 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) { - result = result && (*wapp_array_get(i32, dst_array, index) == *wapp_array_get(i32, src_array1, index)); + result = result && (*wpArrayGet(i32, dst_array, index) == *wpArrayGet(i32, src_array1, index)); ++index; - running = index < wapp_array_count(dst_array); + running = index < wpArrayCount(dst_array); } - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_wapp_file_write_array(void) { - wapp_file_seek(test_fp, 0, WAPP_SEEK_END); +WpTestFuncResult test_wapp_file_write_array(void) { + wpFileSeek(test_fp, 0, WP_SEEK_END); - i64 count = wapp_file_write_array((GenericArray)src_array3, test_fp, wapp_array_count(src_array3)); + i64 count = wpFileWriteArray((WpArray)src_array3, test_fp, wpArrayCount(src_array3)); - return wapp_tester_result(count >= 0 && (u64)count == wapp_array_count(src_array3)); + return wpTesterResult(count >= 0 && (u64)count == wpArrayCount(src_array3)); } -TestFuncResult test_wapp_file_flush(void) { - i32 flush_result = wapp_file_flush(test_fp); - return wapp_tester_result(flush_result == 0); +WpTestFuncResult test_wapp_file_flush(void) { + i32 flush_result = wpFileFlush(test_fp); + return wpTesterResult(flush_result == 0); } -TestFuncResult test_wapp_file_close(void) { - i32 close_result = wapp_file_close(test_fp); - return wapp_tester_result(close_result == 0); +WpTestFuncResult test_wapp_file_close(void) { + i32 close_result = wpFileClose(test_fp); + return wpTesterResult(close_result == 0); } -TestFuncResult test_wapp_file_rename(void) { - i32 rename_result = wapp_file_rename(&test_filename, &new_filename); - return wapp_tester_result(rename_result == 0); +WpTestFuncResult test_wapp_file_rename(void) { + i32 rename_result = wpFileRename(&test_filename, &new_filename); + return wpTesterResult(rename_result == 0); } -TestFuncResult test_wapp_file_remove(void) { - i32 remove_result = wapp_file_remove(&new_filename); - return wapp_tester_result(remove_result == 0); +WpTestFuncResult test_wapp_file_remove(void) { + i32 remove_result = wpFileRemove(&new_filename); + return wpTesterResult(remove_result == 0); } diff --git a/tests/file/test_file.cc b/tests/file/test_file.cc index 046d17a..d79ce06 100644 --- a/tests/file/test_file.cc +++ b/tests/file/test_file.cc @@ -3,52 +3,52 @@ #include "test_file.h" #define DST_CAPACITY 5 -wapp_intern Allocator arena = {}; -wapp_intern Str8RO test_filename = wapp_str8_lit_ro_initialiser_list("wapptest.bin"); -wapp_intern Str8RO new_filename = wapp_str8_lit_ro_initialiser_list("wapptest2.bin"); -wapp_intern WFile *test_fp = NULL; -wapp_intern i32 dst_buf[DST_CAPACITY] = {0}; -wapp_intern I32Array src_array1; -wapp_intern I32Array src_array2; -wapp_intern I32Array src_array3; -wapp_intern I32Array dst_array ; +wp_intern WpAllocator arena = {}; +wp_intern WpStr8RO test_filename = wpStr8LitRoInitialiserList("wapptest.bin"); +wp_intern WpStr8RO new_filename = wpStr8LitRoInitialiserList("wapptest2.bin"); +wp_intern WpFile *test_fp = NULL; +wp_intern i32 dst_buf[DST_CAPACITY] = {0}; +wp_intern WpI32Array src_array1; +wp_intern WpI32Array src_array2; +wp_intern WpI32Array src_array3; +wp_intern WpI32Array dst_array ; -TestFuncResult test_wapp_file_open(void) { - arena = wapp_mem_arena_allocator_init(KiB(16)); - src_array1 = wapp_array(i32, 0, 1, 2, 3, 4); - src_array2 = wapp_array(i32, 5, 6, 7, 8, 9); - src_array3 = wapp_array(i32, 10, 11, 12, 13, 14); - dst_array = wapp_array_with_capacity(i32, DST_CAPACITY, false); - test_fp = wapp_file_open(&arena, &test_filename, WAPP_ACCESS_WRITE_EX); - return wapp_tester_result(test_fp != NULL); +WpTestFuncResult test_wapp_file_open(void) { + arena = wpMemArenaAllocatorInit(KiB(16)); + src_array1 = wpArray(i32, 0, 1, 2, 3, 4); + src_array2 = wpArray(i32, 5, 6, 7, 8, 9); + src_array3 = wpArray(i32, 10, 11, 12, 13, 14); + dst_array = wpArrayWithCapacity(i32, DST_CAPACITY, false); + test_fp = wpFileOpen(&arena, &test_filename, WP_ACCESS_WRITE_EX); + return wpTesterResult(test_fp != NULL); } -TestFuncResult test_wapp_file_get_current_position(void) { - i64 pos = wapp_file_get_current_position(test_fp); - return wapp_tester_result(pos == 0); +WpTestFuncResult test_wapp_file_get_current_position(void) { + i64 pos = wpFileGetCurrentPosition(test_fp); + return wpTesterResult(pos == 0); } -TestFuncResult test_wapp_file_seek(void) { - wapp_file_write_array((GenericArray)src_array1, test_fp, wapp_array_count(src_array1)); +WpTestFuncResult test_wapp_file_seek(void) { + wpFileWriteArray((WpArray)src_array1, test_fp, wpArrayCount(src_array1)); - i64 seek_result = wapp_file_seek(test_fp, 0, WAPP_SEEK_END); - b8 result = seek_result == (i64)(wapp_array_count(src_array1) * wapp_array_item_size(src_array1)); + i64 seek_result = wpFileSeek(test_fp, 0, WP_SEEK_END); + b8 result = seek_result == (i64)(wpArrayCount(src_array1) * wpArrayItemSize(src_array1)); - wapp_file_seek(test_fp, 0, WAPP_SEEK_START); + wpFileSeek(test_fp, 0, WP_SEEK_START); - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_wapp_file_get_length(void) { - i64 length = wapp_file_get_length(test_fp); - return wapp_tester_result(length == (i64)(wapp_array_count(src_array1) * wapp_array_item_size(src_array1))); +WpTestFuncResult test_wapp_file_get_length(void) { + i64 length = wpFileGetLength(test_fp); + return wpTesterResult(length == (i64)(wpArrayCount(src_array1) * wpArrayItemSize(src_array1))); } -TestFuncResult test_wapp_file_read(void) { - wapp_file_seek(test_fp, 0, WAPP_SEEK_START); +WpTestFuncResult test_wapp_file_read(void) { + wpFileSeek(test_fp, 0, WP_SEEK_START); u64 byte_count = DST_CAPACITY * sizeof(i32); - u64 count = wapp_file_read((void *)dst_buf, test_fp, byte_count); + u64 count = wpFileRead((void *)dst_buf, test_fp, byte_count); b8 result = count == byte_count; // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of @@ -56,67 +56,67 @@ TestFuncResult test_wapp_file_read(void) { u64 index = 0; b8 running = true; while (running) { - result = result && (dst_buf[index] == *wapp_array_get(i32, src_array1, index)); + result = result && (dst_buf[index] == *wpArrayGet(i32, src_array1, index)); ++index; running = index < DST_CAPACITY; } - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_wapp_file_write(void) { - wapp_file_seek(test_fp, 0, WAPP_SEEK_END); +WpTestFuncResult test_wapp_file_write(void) { + wpFileSeek(test_fp, 0, WP_SEEK_END); - u64 expected_count = wapp_array_count(src_array2) * wapp_array_item_size(src_array2); - i64 count = wapp_file_write((void *)src_array2, test_fp, expected_count); + u64 expected_count = wpArrayCount(src_array2) * wpArrayItemSize(src_array2); + i64 count = wpFileWrite((void *)src_array2, test_fp, expected_count); - return wapp_tester_result(count >= 0 && (u64)count == expected_count); + return wpTesterResult(count >= 0 && (u64)count == expected_count); } -TestFuncResult test_wapp_file_read_array(void) { - wapp_file_seek(test_fp, 0, WAPP_SEEK_START); +WpTestFuncResult test_wapp_file_read_array(void) { + wpFileSeek(test_fp, 0, WP_SEEK_START); - u64 count = wapp_file_read_array((GenericArray)dst_array, test_fp, wapp_array_count(src_array1)); - b8 result = count == wapp_array_count(src_array1) && - wapp_array_count(dst_array) == wapp_array_count(src_array1); + u64 count = wpFileReadArray((WpArray)dst_array, test_fp, wpArrayCount(src_array1)); + b8 result = count == wpArrayCount(src_array1) && + wpArrayCount(dst_array) == wpArrayCount(src_array1); // 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) { - result = result && (*wapp_array_get(i32, dst_array, index) == *wapp_array_get(i32, src_array1, index)); + result = result && (*wpArrayGet(i32, dst_array, index) == *wpArrayGet(i32, src_array1, index)); ++index; - running = index < wapp_array_count(dst_array); + running = index < wpArrayCount(dst_array); } - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_wapp_file_write_array(void) { - wapp_file_seek(test_fp, 0, WAPP_SEEK_END); +WpTestFuncResult test_wapp_file_write_array(void) { + wpFileSeek(test_fp, 0, WP_SEEK_END); - i64 count = wapp_file_write_array((GenericArray)src_array3, test_fp, wapp_array_count(src_array3)); + i64 count = wpFileWriteArray((WpArray)src_array3, test_fp, wpArrayCount(src_array3)); - return wapp_tester_result(count >= 0 && (u64)count == wapp_array_count(src_array3)); + return wpTesterResult(count >= 0 && (u64)count == wpArrayCount(src_array3)); } -TestFuncResult test_wapp_file_flush(void) { - i32 flush_result = wapp_file_flush(test_fp); - return wapp_tester_result(flush_result == 0); +WpTestFuncResult test_wapp_file_flush(void) { + i32 flush_result = wpFileFlush(test_fp); + return wpTesterResult(flush_result == 0); } -TestFuncResult test_wapp_file_close(void) { - i32 close_result = wapp_file_close(test_fp); - return wapp_tester_result(close_result == 0); +WpTestFuncResult test_wapp_file_close(void) { + i32 close_result = wpFileClose(test_fp); + return wpTesterResult(close_result == 0); } -TestFuncResult test_wapp_file_rename(void) { - i32 rename_result = wapp_file_rename(&test_filename, &new_filename); - return wapp_tester_result(rename_result == 0); +WpTestFuncResult test_wapp_file_rename(void) { + i32 rename_result = wpFileRename(&test_filename, &new_filename); + return wpTesterResult(rename_result == 0); } -TestFuncResult test_wapp_file_remove(void) { - i32 remove_result = wapp_file_remove(&new_filename); - return wapp_tester_result(remove_result == 0); +WpTestFuncResult test_wapp_file_remove(void) { + i32 remove_result = wpFileRemove(&new_filename); + return wpTesterResult(remove_result == 0); } diff --git a/tests/file/test_file.h b/tests/file/test_file.h index 6797afe..163baca 100644 --- a/tests/file/test_file.h +++ b/tests/file/test_file.h @@ -5,17 +5,17 @@ #include "wapp.h" -TestFuncResult test_wapp_file_open(void); -TestFuncResult test_wapp_file_get_current_position(void); -TestFuncResult test_wapp_file_seek(void); -TestFuncResult test_wapp_file_get_length(void); -TestFuncResult test_wapp_file_read(void); -TestFuncResult test_wapp_file_write(void); -TestFuncResult test_wapp_file_read_array(void); -TestFuncResult test_wapp_file_write_array(void); -TestFuncResult test_wapp_file_flush(void); -TestFuncResult test_wapp_file_close(void); -TestFuncResult test_wapp_file_rename(void); -TestFuncResult test_wapp_file_remove(void); +WpTestFuncResult test_wapp_file_open(void); +WpTestFuncResult test_wapp_file_get_current_position(void); +WpTestFuncResult test_wapp_file_seek(void); +WpTestFuncResult test_wapp_file_get_length(void); +WpTestFuncResult test_wapp_file_read(void); +WpTestFuncResult test_wapp_file_write(void); +WpTestFuncResult test_wapp_file_read_array(void); +WpTestFuncResult test_wapp_file_write_array(void); +WpTestFuncResult test_wapp_file_flush(void); +WpTestFuncResult test_wapp_file_close(void); +WpTestFuncResult test_wapp_file_rename(void); +WpTestFuncResult test_wapp_file_remove(void); #endif // !TEST_FILE_H diff --git a/tests/queue/test_queue.c b/tests/queue/test_queue.c index 1370f2d..9b62493 100644 --- a/tests/queue/test_queue.c +++ b/tests/queue/test_queue.c @@ -5,12 +5,12 @@ #define CAPACITY 8 -TestFuncResult test_queue_push(void) { - I32Queue queue = wapp_queue(i32, CAPACITY); +WpTestFuncResult test_queue_push(void) { + WpI32Queue queue = wpQueue(i32, CAPACITY); for (u64 i = 0; i < CAPACITY; ++i) { i32 item = (i32)i; - wapp_queue_push(i32, &queue, &item); + wpQueuePush(i32, &queue, &item); } b8 result = true; @@ -19,45 +19,45 @@ TestFuncResult test_queue_push(void) { result = result && value != NULL && *value == (i32)i; } - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_queue_push_alloc(void) { - Allocator arena = wapp_mem_arena_allocator_init(MiB(64)); - I32Queue queue = wapp_queue(i32, CAPACITY); +WpTestFuncResult test_queue_push_alloc(void) { + WpAllocator arena = wpMemArenaAllocatorInit(MiB(64)); + WpI32Queue queue = wpQueue(i32, CAPACITY); for (u64 i = 0; i < CAPACITY; ++i) { i32 item = (i32)i; - wapp_queue_push(i32, &queue, &item); + wpQueuePush(i32, &queue, &item); } b8 result = true; i32 item = 8; u64 new_capacity = CAPACITY * 2; - I32Queue *new_queue = wapp_queue_push_alloc(i32, &arena, &queue, &item); + WpI32Queue *new_queue = wpQueuePushAlloc(i32, &arena, &queue, &item); if (new_queue && new_queue != &queue) { queue = *new_queue; } - u64 capacity = wapp_queue_capacity(&queue); + u64 capacity = wpQueueCapacity(&queue); result = result && capacity == new_capacity; for (u64 i = 0; i < 2; ++i) { - wapp_queue_pop(i32, &queue); + wpQueuePop(i32, &queue); } - u64 remaining = wapp_queue_capacity(&queue) - queue.count; + u64 remaining = wpQueueCapacity(&queue) - queue.count; for (u64 i = 0; i < remaining; ++i) { item = (i32)(remaining + i); - wapp_queue_push(i32, &queue, &item); + wpQueuePush(i32, &queue, &item); } ++item; - new_queue = wapp_queue_push_alloc(i32, &arena, &queue, &item); + new_queue = wpQueuePushAlloc(i32, &arena, &queue, &item); if (new_queue && new_queue != &queue) { queue = *new_queue; } - result = result && wapp_queue_capacity(&queue) == new_capacity * 2; + result = result && wpQueueCapacity(&queue) == new_capacity * 2; i32 *arr = (i32 *)queue.items; for (u64 i = 0; i < queue.count; ++i) { @@ -65,34 +65,34 @@ TestFuncResult test_queue_push_alloc(void) { result = result && arr[i] == (i32)(2 + i); } - wapp_mem_arena_allocator_destroy(&arena); + wpMemArenaAllocatorDestroy(&arena); - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_queue_pop(void) { - I32Queue queue = wapp_queue(i32, CAPACITY); +WpTestFuncResult test_queue_pop(void) { + WpI32Queue queue = wpQueue(i32, CAPACITY); for (u64 i = 0; i < CAPACITY; ++i) { i32 item = (i32)i; - wapp_queue_push(i32, &queue, &item); + wpQueuePush(i32, &queue, &item); } b8 result = true; u64 half_count = queue.count / 2; for (u64 i = 0; i < half_count; ++i) { - i32 *value = wapp_queue_pop(i32, &queue); + i32 *value = wpQueuePop(i32, &queue); result = result && value != NULL && *value == (i32)i; } for (u64 i = 0; i < half_count; ++i) { i32 item = (i32)i + CAPACITY; - wapp_queue_push(i32, &queue, &item); + wpQueuePush(i32, &queue, &item); } for (u64 i = 0; i < CAPACITY; ++i) { - i32 *value = wapp_queue_pop(i32, &queue); + i32 *value = wpQueuePop(i32, &queue); result = result && value != NULL && *value == (i32)half_count + (i32)i; } - return wapp_tester_result(result); + return wpTesterResult(result); } diff --git a/tests/queue/test_queue.cc b/tests/queue/test_queue.cc index b6a2092..c17dd2a 100644 --- a/tests/queue/test_queue.cc +++ b/tests/queue/test_queue.cc @@ -3,12 +3,12 @@ #define CAPACITY 8 -TestFuncResult test_queue_push(void) { - I32Queue queue = wapp_queue(i32, CAPACITY); +WpTestFuncResult test_queue_push(void) { + WpI32Queue queue = wpQueue(i32, CAPACITY); for (u64 i = 0; i < CAPACITY; ++i) { i32 item = (i32)i; - wapp_queue_push(i32, &queue, &item); + wpQueuePush(i32, &queue, &item); } b8 result = true; @@ -17,45 +17,45 @@ TestFuncResult test_queue_push(void) { result = result && value != NULL && *value == (i32)i; } - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_queue_push_alloc(void) { - Allocator arena = wapp_mem_arena_allocator_init(MiB(64)); - I32Queue queue = wapp_queue(i32, CAPACITY); +WpTestFuncResult test_queue_push_alloc(void) { + WpAllocator arena = wpMemArenaAllocatorInit(MiB(64)); + WpI32Queue queue = wpQueue(i32, CAPACITY); for (u64 i = 0; i < CAPACITY; ++i) { i32 item = (i32)i; - wapp_queue_push(i32, &queue, &item); + wpQueuePush(i32, &queue, &item); } b8 result = true; i32 item = 8; u64 new_capacity = CAPACITY * 2; - I32Queue *new_queue = wapp_queue_push_alloc(i32, &arena, &queue, &item); + WpI32Queue *new_queue = wpQueuePushAlloc(i32, &arena, &queue, &item); if (new_queue && new_queue != &queue) { queue = *new_queue; } - u64 capacity = wapp_queue_capacity(&queue); + u64 capacity = wpQueueCapacity(&queue); result = result && capacity == new_capacity; for (u64 i = 0; i < 2; ++i) { - wapp_queue_pop(i32, &queue); + wpQueuePop(i32, &queue); } - u64 remaining = wapp_queue_capacity(&queue) - queue.count; + u64 remaining = wpQueueCapacity(&queue) - queue.count; for (u64 i = 0; i < remaining; ++i) { item = (i32)(remaining + i); - wapp_queue_push(i32, &queue, &item); + wpQueuePush(i32, &queue, &item); } ++item; - new_queue = wapp_queue_push_alloc(i32, &arena, &queue, &item); + new_queue = wpQueuePushAlloc(i32, &arena, &queue, &item); if (new_queue && new_queue != &queue) { queue = *new_queue; } - result = result && wapp_queue_capacity(&queue) == new_capacity * 2; + result = result && wpQueueCapacity(&queue) == new_capacity * 2; i32 *arr = (i32 *)queue.items; for (u64 i = 0; i < queue.count; ++i) { @@ -63,34 +63,34 @@ TestFuncResult test_queue_push_alloc(void) { result = result && arr[i] == (i32)(2 + i); } - wapp_mem_arena_allocator_destroy(&arena); + wpMemArenaAllocatorDestroy(&arena); - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_queue_pop(void) { - I32Queue queue = wapp_queue(i32, CAPACITY); +WpTestFuncResult test_queue_pop(void) { + WpI32Queue queue = wpQueue(i32, CAPACITY); for (u64 i = 0; i < CAPACITY; ++i) { i32 item = (i32)i; - wapp_queue_push(i32, &queue, &item); + wpQueuePush(i32, &queue, &item); } b8 result = true; u64 half_count = queue.count / 2; for (u64 i = 0; i < half_count; ++i) { - i32 *value = wapp_queue_pop(i32, &queue); + i32 *value = wpQueuePop(i32, &queue); result = result && value != NULL && *value == (i32)i; } for (u64 i = 0; i < half_count; ++i) { i32 item = (i32)i + CAPACITY; - wapp_queue_push(i32, &queue, &item); + wpQueuePush(i32, &queue, &item); } for (u64 i = 0; i < CAPACITY; ++i) { - i32 *value = wapp_queue_pop(i32, &queue); + i32 *value = wpQueuePop(i32, &queue); result = result && value != NULL && *value == (i32)half_count + (i32)i; } - return wapp_tester_result(result); + return wpTesterResult(result); } diff --git a/tests/queue/test_queue.h b/tests/queue/test_queue.h index 32382e2..c8a1fe9 100644 --- a/tests/queue/test_queue.h +++ b/tests/queue/test_queue.h @@ -5,8 +5,8 @@ #include "wapp.h" -TestFuncResult test_queue_push(void); -TestFuncResult test_queue_push_alloc(void); -TestFuncResult test_queue_pop(void); +WpTestFuncResult test_queue_push(void); +WpTestFuncResult test_queue_push_alloc(void); +WpTestFuncResult test_queue_pop(void); #endif // !TEST_QUEUE_H diff --git a/tests/shell_commander/test_shell_commander.c b/tests/shell_commander/test_shell_commander.c index c0126be..93d82d8 100644 --- a/tests/shell_commander/test_shell_commander.c +++ b/tests/shell_commander/test_shell_commander.c @@ -4,59 +4,59 @@ #include #include -TestFuncResult test_commander_cmd_success(void) { - Str8List cmd = wapp_dbl_list(Str8); - wapp_dbl_list_push_back(Str8, &cmd, &wapp_str8_lit("echo")); - wapp_dbl_list_push_back(Str8, &cmd, &wapp_str8_lit("hello world")); +WpTestFuncResult test_commander_cmd_success(void) { + WpStr8List cmd = wpDblList(WpStr8); + wpDblListPushBack(WpStr8, &cmd, &wpStr8Lit("echo")); + wpDblListPushBack(WpStr8, &cmd, &wpStr8Lit("hello world")); - CMDResult result = wapp_shell_commander_execute(SHELL_OUTPUT_DISCARD, NULL, &cmd); + WpCmdResult result = wpShellCommanderExecute(WP_SHELL_OUTPUT_DISCARD, NULL, &cmd); b8 succeeded = result.exited && result.exit_code == EXIT_SUCCESS && - result.error == SHELL_ERR_NO_ERROR; + result.error == WP_SHELL_ERR_NO_ERROR; - return wapp_tester_result(succeeded); + return wpTesterResult(succeeded); } -TestFuncResult test_commander_cmd_failure(void) { - Str8List cmd = wapp_dbl_list(Str8); - wapp_dbl_list_push_back(Str8, &cmd, &wapp_str8_lit("grep")); +WpTestFuncResult test_commander_cmd_failure(void) { + WpStr8List cmd = wpDblList(WpStr8); + wpDblListPushBack(WpStr8, &cmd, &wpStr8Lit("grep")); - CMDResult result = wapp_shell_commander_execute(SHELL_OUTPUT_DISCARD, NULL, &cmd); + WpCmdResult result = wpShellCommanderExecute(WP_SHELL_OUTPUT_DISCARD, NULL, &cmd); b8 failed = result.exited && result.exit_code != EXIT_SUCCESS && - result.error == SHELL_ERR_NO_ERROR; + result.error == WP_SHELL_ERR_NO_ERROR; - return wapp_tester_result(failed); + return wpTesterResult(failed); } -TestFuncResult test_commander_cmd_out_buf_success(void) { - Str8 buf = wapp_str8_buf(64); - Str8 expected = wapp_str8_buf(64); +WpTestFuncResult test_commander_cmd_out_buf_success(void) { + WpStr8 buf = wpStr8Buf(64); + WpStr8 expected = wpStr8Buf(64); char msg[] = "hello world"; - wapp_str8_copy_cstr_capped(&expected, msg); + wpStr8CopyCstrCapped(&expected, msg); - Str8List cmd = wapp_dbl_list(Str8); - wapp_dbl_list_push_back(Str8, &cmd, &wapp_str8_lit("echo")); - wapp_dbl_list_push_back(Str8, &cmd, &wapp_str8_lit(msg)); + WpStr8List cmd = wpDblList(WpStr8); + wpDblListPushBack(WpStr8, &cmd, &wpStr8Lit("echo")); + wpDblListPushBack(WpStr8, &cmd, &wpStr8Lit(msg)); - CMDResult result = wapp_shell_commander_execute(SHELL_OUTPUT_CAPTURE, &buf, &cmd); + WpCmdResult result = wpShellCommanderExecute(WP_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)); + result.error == WP_SHELL_ERR_NO_ERROR && wpStr8EqualToCount(&buf, &expected, strlen(msg)); - return wapp_tester_result(succeeded); + return wpTesterResult(succeeded); } -TestFuncResult test_commander_cmd_out_buf_failure(void) { - Str8 buf = wapp_str8_buf(4); - Str8 expected = wapp_str8_buf(64); +WpTestFuncResult test_commander_cmd_out_buf_failure(void) { + WpStr8 buf = wpStr8Buf(4); + WpStr8 expected = wpStr8Buf(64); char msg[] = "hello world"; - wapp_str8_copy_cstr_capped(&expected, msg); + wpStr8CopyCstrCapped(&expected, msg); - Str8List cmd = wapp_dbl_list(Str8); - wapp_dbl_list_push_back(Str8, &cmd, &wapp_str8_lit("echo")); - wapp_dbl_list_push_back(Str8, &cmd, &wapp_str8_lit(msg)); + WpStr8List cmd = wpDblList(WpStr8); + wpDblListPushBack(WpStr8, &cmd, &wpStr8Lit("echo")); + wpDblListPushBack(WpStr8, &cmd, &wpStr8Lit(msg)); - CMDResult result = wapp_shell_commander_execute(SHELL_OUTPUT_CAPTURE, &buf, &cmd); + WpCmdResult result = wpShellCommanderExecute(WP_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); + result.error == WP_SHELL_ERR_OUT_BUF_FULL && !wpStr8Equal(&buf, &expected); - return wapp_tester_result(failed); + return wpTesterResult(failed); } diff --git a/tests/shell_commander/test_shell_commander.cc b/tests/shell_commander/test_shell_commander.cc index b48217c..d22aa59 100644 --- a/tests/shell_commander/test_shell_commander.cc +++ b/tests/shell_commander/test_shell_commander.cc @@ -4,66 +4,66 @@ #include #include -TestFuncResult test_commander_cmd_success(void) { - Str8List cmd = wapp_dbl_list(Str8); - Str8 echo = wapp_str8_lit("echo"); - Str8 msg = wapp_str8_lit("hello world"); - wapp_dbl_list_push_back(Str8, &cmd, &echo); - wapp_dbl_list_push_back(Str8, &cmd, &msg); +WpTestFuncResult test_commander_cmd_success(void) { + WpStr8List cmd = wpDblList(WpStr8); + WpStr8 echo = wpStr8Lit("echo"); + WpStr8 msg = wpStr8Lit("hello world"); + wpDblListPushBack(WpStr8, &cmd, &echo); + wpDblListPushBack(WpStr8, &cmd, &msg); - CMDResult result = wapp_shell_commander_execute(SHELL_OUTPUT_DISCARD, nullptr, &cmd); + WpCmdResult result = wpShellCommanderExecute(WP_SHELL_OUTPUT_DISCARD, nullptr, &cmd); b8 succeeded = result.exited && result.exit_code == EXIT_SUCCESS && - result.error == SHELL_ERR_NO_ERROR; + result.error == WP_SHELL_ERR_NO_ERROR; - return wapp_tester_result(succeeded); + return wpTesterResult(succeeded); } -TestFuncResult test_commander_cmd_failure(void) { - Str8List cmd = wapp_dbl_list(Str8); - Str8 grep = wapp_str8_lit("grep"); - wapp_dbl_list_push_back(Str8, &cmd, &grep); +WpTestFuncResult test_commander_cmd_failure(void) { + WpStr8List cmd = wpDblList(WpStr8); + WpStr8 grep = wpStr8Lit("grep"); + wpDblListPushBack(WpStr8, &cmd, &grep); - CMDResult result = wapp_shell_commander_execute(SHELL_OUTPUT_DISCARD, nullptr, &cmd); + WpCmdResult result = wpShellCommanderExecute(WP_SHELL_OUTPUT_DISCARD, nullptr, &cmd); b8 failed = result.exited && result.exit_code != EXIT_SUCCESS && - result.error == SHELL_ERR_NO_ERROR; + result.error == WP_SHELL_ERR_NO_ERROR; - return wapp_tester_result(failed); + return wpTesterResult(failed); } -TestFuncResult test_commander_cmd_out_buf_success(void) { - Str8 buf = wapp_str8_buf(64); - Str8 expected = wapp_str8_buf(64); +WpTestFuncResult test_commander_cmd_out_buf_success(void) { + WpStr8 buf = wpStr8Buf(64); + WpStr8 expected = wpStr8Buf(64); char msg[] = "hello world"; - wapp_str8_copy_cstr_capped(&expected, msg); + wpStr8CopyCstrCapped(&expected, msg); - Str8List cmd = wapp_dbl_list(Str8); - Str8 echo = wapp_str8_lit("echo"); - Str8 arg = wapp_str8_lit(msg); - wapp_dbl_list_push_back(Str8, &cmd, &echo); - wapp_dbl_list_push_back(Str8, &cmd, &arg); + WpStr8List cmd = wpDblList(WpStr8); + WpStr8 echo = wpStr8Lit("echo"); + WpStr8 arg = wpStr8Lit(msg); + wpDblListPushBack(WpStr8, &cmd, &echo); + wpDblListPushBack(WpStr8, &cmd, &arg); - CMDResult result = wapp_shell_commander_execute(SHELL_OUTPUT_CAPTURE, &buf, &cmd); + WpCmdResult result = wpShellCommanderExecute(WP_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)); + result.error == WP_SHELL_ERR_NO_ERROR && wpStr8EqualToCount(&buf, &expected, strlen(msg)); - return wapp_tester_result(succeeded); + return wpTesterResult(succeeded); } -TestFuncResult test_commander_cmd_out_buf_failure(void) { - Str8 buf = wapp_str8_buf(4); - Str8 expected = wapp_str8_buf(64); +WpTestFuncResult test_commander_cmd_out_buf_failure(void) { + WpStr8 buf = wpStr8Buf(4); + WpStr8 expected = wpStr8Buf(64); char msg[] = "hello world"; - wapp_str8_copy_cstr_capped(&expected, msg); + wpStr8CopyCstrCapped(&expected, msg); - Str8List cmd = wapp_dbl_list(Str8); - Str8 echo = wapp_str8_lit("echo"); - Str8 arg = wapp_str8_lit(msg); - wapp_dbl_list_push_back(Str8, &cmd, &echo); - wapp_dbl_list_push_back(Str8, &cmd, &arg); + WpStr8List cmd = wpDblList(WpStr8); + WpStr8 echo = wpStr8Lit("echo"); + WpStr8 arg = wpStr8Lit(msg); + wpDblListPushBack(WpStr8, &cmd, &echo); + wpDblListPushBack(WpStr8, &cmd, &arg); - CMDResult result = wapp_shell_commander_execute(SHELL_OUTPUT_CAPTURE, &buf, &cmd); + WpCmdResult result = wpShellCommanderExecute(WP_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); + result.error == WP_SHELL_ERR_OUT_BUF_FULL && !wpStr8Equal(&buf, &expected); - return wapp_tester_result(failed); + return wpTesterResult(failed); } diff --git a/tests/shell_commander/test_shell_commander.h b/tests/shell_commander/test_shell_commander.h index ea547c7..8849395 100644 --- a/tests/shell_commander/test_shell_commander.h +++ b/tests/shell_commander/test_shell_commander.h @@ -3,9 +3,9 @@ #include "wapp.h" -TestFuncResult test_commander_cmd_success(void); -TestFuncResult test_commander_cmd_failure(void); -TestFuncResult test_commander_cmd_out_buf_success(void); -TestFuncResult test_commander_cmd_out_buf_failure(void); +WpTestFuncResult test_commander_cmd_success(void); +WpTestFuncResult test_commander_cmd_failure(void); +WpTestFuncResult test_commander_cmd_out_buf_success(void); +WpTestFuncResult test_commander_cmd_out_buf_failure(void); #endif // !TEST_SHELL_COMMANDER_H diff --git a/tests/str8/test_str8.c b/tests/str8/test_str8.c index 4ef2dca..69dd30e 100644 --- a/tests/str8/test_str8.c +++ b/tests/str8/test_str8.c @@ -3,88 +3,88 @@ #define ARRLEN(ARR) (sizeof(ARR) / sizeof(ARR[0])) -TestFuncResult test_str8_lit(void) { +WpTestFuncResult test_str8_lit(void) { b8 result; - Str8 s1 = wapp_str8_lit("Hello world"); + WpStr8 s1 = wpStr8Lit("Hello world"); result = s1.capacity == 22 && s1.capacity != s1.size; - Str8 s2 = wapp_str8_lit("Different strokes for different folks"); + WpStr8 s2 = wpStr8Lit("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"); + WpStr8 s3 = wpStr8Lit("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"); + WpStr8 s4 = wpStr8Lit("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"); + WpStr8 s5 = wpStr8Lit("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"); + WpStr8 s6 = wpStr8Lit("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"); + WpStr8 s7 = wpStr8Lit("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 wpTesterResult(result); } -TestFuncResult test_str8_lit_ro(void) { +WpTestFuncResult test_str8_lit_ro(void) { b8 result; - Str8RO s1 = wapp_str8_lit_ro("Hello world"); + WpStr8RO s1 = wpStr8LitRo("Hello world"); result = s1.capacity == 11 && s1.capacity == s1.size; - Str8RO s2 = wapp_str8_lit_ro("Different strokes for different folks"); + WpStr8RO s2 = wpStr8LitRo("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"); + WpStr8RO s3 = wpStr8LitRo("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"); + WpStr8RO s4 = wpStr8LitRo("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"); + WpStr8RO s5 = wpStr8LitRo("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"); + WpStr8RO s6 = wpStr8LitRo("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"); + WpStr8RO s7 = wpStr8LitRo("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 wpTesterResult(result); } -TestFuncResult test_str8_buf(void) { +WpTestFuncResult test_str8_buf(void) { b8 result; - Str8 s1 = wapp_str8_buf(1024); + WpStr8 s1 = wpStr8Buf(1024); result = s1.capacity == 1024 && s1.size == 0; - Str8 s2 = wapp_str8_buf(2048); + WpStr8 s2 = wpStr8Buf(2048); result = result && s2.capacity == 2048 && s2.size == 0; - Str8 s3 = wapp_str8_buf(4096); + WpStr8 s3 = wpStr8Buf(4096); result = result && s3.capacity == 4096 && s3.size == 0; - Str8 s4 = wapp_str8_buf(8192); + WpStr8 s4 = wpStr8Buf(8192); result = result && s4.capacity == 8192 && s4.size == 0; - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_str8_alloc_buf(void) { +WpTestFuncResult 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); + WpAllocator allocator = wpMemArenaAllocatorInit(KiB(100)); + if (wpMemAllocatorInvalid(&allocator)) { + return wpTesterResult(false); } u64 capacity = 4096; - Str8 *s = wapp_str8_alloc_buf(&allocator, capacity); + WpStr8 *s = wpStr8AllocBuf(&allocator, capacity); if (!s) { result = false; goto TEST_ALLOC_BUF_CLEANUP; @@ -93,340 +93,340 @@ TestFuncResult test_str8_alloc_buf(void) { result = s->capacity == capacity; const char *cstr = "My name is Abdelrahman"; - wapp_str8_copy_cstr_capped(s, cstr); + wpStr8CopyCstrCapped(s, cstr); 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); + wpMemArenaAllocatorDestroy(&allocator); - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_str8_alloc_cstr(void) { +WpTestFuncResult 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); + WpAllocator allocator = wpMemArenaAllocatorInit(KiB(100)); + if (wpMemAllocatorInvalid(&allocator)) { + return wpTesterResult(false); } char *str = "Abdelrahman"; u64 length = strlen(str); - Str8 *s = wapp_str8_alloc_cstr(&allocator, str); + WpStr8 *s = wpStr8AllocCstr(&allocator, str); if (!s) { - return wapp_tester_result(false); + return wpTesterResult(false); } result = s->size == length && memcmp(s->buf, str, length) == 0; - wapp_mem_arena_allocator_destroy(&allocator); + wpMemArenaAllocatorDestroy(&allocator); - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_str8_alloc_str8(void) { +WpTestFuncResult 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); + WpAllocator allocator = wpMemArenaAllocatorInit(KiB(100)); + if (wpMemAllocatorInvalid(&allocator)) { + return wpTesterResult(false); } - Str8 str = wapp_str8_lit("Abdelrahman"); - Str8 *s = wapp_str8_alloc_str8(&allocator, &str); + WpStr8 str = wpStr8Lit("Abdelrahman"); + WpStr8 *s = wpStr8AllocStr8(&allocator, &str); if (!s) { - return wapp_tester_result(false); + return wpTesterResult(false); } - result = wapp_str8_equal(s, &str); + result = wpStr8Equal(s, &str); - wapp_mem_arena_allocator_destroy(&allocator); + wpMemArenaAllocatorDestroy(&allocator); - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_str8_alloc_substr(void) { +WpTestFuncResult 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); + WpAllocator allocator = wpMemArenaAllocatorInit(KiB(100)); + if (wpMemAllocatorInvalid(&allocator)) { + return wpTesterResult(false); } - Str8 str = wapp_str8_lit("Abdelrahman"); - Str8 *s = wapp_str8_alloc_substr(&allocator, &str, 3, 8); + WpStr8 str = wpStr8Lit("Abdelrahman"); + WpStr8 *s = wpStr8AllocSubstr(&allocator, &str, 3, 8); if (!s) { - return wapp_tester_result(false); + return wpTesterResult(false); } result = s->size == 5 && memcmp(s->buf, "elrah", s->size) == 0; - wapp_mem_arena_allocator_destroy(&allocator); + wpMemArenaAllocatorDestroy(&allocator); - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_str8_get_index_within_bounds(void) { +WpTestFuncResult test_str8_get_index_within_bounds(void) { b8 result; - Str8RO s1 = wapp_str8_lit_ro("Hello world"); - result = wapp_str8_get(&s1, 4) == 'o'; + WpStr8RO s1 = wpStr8LitRo("Hello world"); + result = wpStr8Get(&s1, 4) == 'o'; - Str8RO s2 = wapp_str8_lit_ro("Different strokes for different folks"); - result = result && wapp_str8_get(&s2, 0) == 'D'; + WpStr8RO s2 = wpStr8LitRo("Different strokes for different folks"); + result = result && wpStr8Get(&s2, 0) == 'D'; - Str8RO s3 = wapp_str8_lit_ro("Discretion is the better part of valour"); - result = result && wapp_str8_get(&s3, 13) == ' '; + WpStr8RO s3 = wpStr8LitRo("Discretion is the better part of valour"); + result = result && wpStr8Get(&s3, 13) == ' '; - Str8RO s4 = wapp_str8_lit_ro("Distance lends enchantment to the view"); - result = result && wapp_str8_get(&s4, 20) == 'n'; + WpStr8RO s4 = wpStr8LitRo("Distance lends enchantment to the view"); + result = result && wpStr8Get(&s4, 20) == 'n'; - Str8RO s5 = wapp_str8_lit_ro("Do as I say, not as I do"); - result = result && wapp_str8_get(&s5, 11) == ','; + WpStr8RO s5 = wpStr8LitRo("Do as I say, not as I do"); + result = result && wpStr8Get(&s5, 11) == ','; - Str8RO s6 = wapp_str8_lit_ro("Do as you would be done by"); - result = result && wapp_str8_get(&s6, 25) == 'y'; + WpStr8RO s6 = wpStr8LitRo("Do as you would be done by"); + result = result && wpStr8Get(&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'; + WpStr8RO s7 = wpStr8LitRo("Do unto others as you would have them do to you"); + result = result && wpStr8Get(&s7, 16) == 's'; - return wapp_tester_result(result); + return wpTesterResult(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); +WpTestFuncResult test_str8_get_index_out_of_bounds(void) { + WpStr8 s1 = wpStr8Lit("Hello world"); + b8 result = wpStr8Get(&s1, 20) == '\0'; + return wpTesterResult(result); } -TestFuncResult test_str8_set(void) { +WpTestFuncResult test_str8_set(void) { b8 result; - Str8 s1 = wapp_str8_lit("Hello world"); - wapp_str8_set(&s1, 4, 'f'); - result = wapp_str8_get(&s1, 4) == 'f'; + WpStr8 s1 = wpStr8Lit("Hello world"); + wpStr8Set(&s1, 4, 'f'); + result = wpStr8Get(&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'; + WpStr8 s2 = wpStr8Lit("Different strokes for different folks"); + wpStr8Set(&s2, 0, 'A'); + result = result && wpStr8Get(&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'; + WpStr8 s3 = wpStr8Lit("Discretion is the better part of valour"); + wpStr8Set(&s3, 13, 'u'); + result = result && wpStr8Get(&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'; + WpStr8 s4 = wpStr8Lit("Distance lends enchantment to the view"); + wpStr8Set(&s4, 20, 'R'); + result = result && wpStr8Get(&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) == '.'; + WpStr8 s5 = wpStr8Lit("Do as I say, not as I do"); + wpStr8Set(&s5, 11, '.'); + result = result && wpStr8Get(&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'; + WpStr8 s6 = wpStr8Lit("Do as you would be done by"); + wpStr8Set(&s6, 25, 'w'); + result = result && wpStr8Get(&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'; + WpStr8 s7 = wpStr8Lit("Do unto others as you would have them do to you"); + wpStr8Set(&s7, 16, 'i'); + result = result && wpStr8Get(&s7, 16) == 'i'; - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_str8_push_back(void) { +WpTestFuncResult test_str8_push_back(void) { 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'); + WpStr8 expected = wpStr8Lit("Abdelrahman"); + WpStr8 buf = wpStr8Buf(64); + wpStr8PushBack(&buf, 'A'); + wpStr8PushBack(&buf, 'b'); + wpStr8PushBack(&buf, 'd'); + wpStr8PushBack(&buf, 'e'); + wpStr8PushBack(&buf, 'l'); + wpStr8PushBack(&buf, 'r'); + wpStr8PushBack(&buf, 'a'); + wpStr8PushBack(&buf, 'h'); + wpStr8PushBack(&buf, 'm'); + wpStr8PushBack(&buf, 'a'); + wpStr8PushBack(&buf, 'n'); - result = wapp_str8_equal(&buf, &expected); + result = wpStr8Equal(&buf, &expected); - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_str8_equal(void) { +WpTestFuncResult test_str8_equal(void) { 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"); + WpStr8RO s1 = wpStr8LitRo("hello"); + WpStr8RO s2 = wpStr8LitRo("hell"); + WpStr8RO s3 = wpStr8LitRo("hello"); + WpStr8RO s4 = wpStr8LitRo("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 = wpStr8Equal(&s1, &s2) == false; + result = result && wpStr8Equal(&s1, &s3) == true; + result = result && wpStr8Equal(&s1, &s4) == false; - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_str8_slice(void) { +WpTestFuncResult test_str8_slice(void) { b8 result; - Str8 s = wapp_str8_lit("Different strokes for different folks"); + WpStr8 s = wpStr8Lit("Different strokes for different folks"); - Str8RO sub1 = wapp_str8_slice(&s, 3, 9); + WpStr8RO sub1 = wpStr8Slice(&s, 3, 9); result = sub1.size == 6 && sub1.capacity == 6; - Str8RO sub2 = wapp_str8_slice(&s, 18, 21); + WpStr8RO sub2 = wpStr8Slice(&s, 18, 21); result = result && sub2.size == 3 && sub2.capacity == 3; - Str8RO sub3 = wapp_str8_slice(&s, 5, 1); + WpStr8RO sub3 = wpStr8Slice(&s, 5, 1); result = result && sub3.size == 0 && sub3.capacity == 0; - Str8RO sub4 = wapp_str8_slice(&s, 70, 80); + WpStr8RO sub4 = wpStr8Slice(&s, 70, 80); result = result && sub4.size == 0 && sub4.capacity == 0; - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_str8_alloc_concat(void) { +WpTestFuncResult test_str8_alloc_concat(void) { b8 result; - Allocator arena = wapp_mem_arena_allocator_init(KiB(100)); + WpAllocator arena = wpMemArenaAllocatorInit(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."); + WpStr8 str = wpStr8Lit("Hello world"); + WpStr8 suffix1 = wpStr8Lit(" from me."); + WpStr8 suffix2 = wpStr8Lit(" This is my code."); + WpStr8 concat1 = wpStr8Lit("Hello world from me."); + WpStr8 concat2 = wpStr8Lit("Hello world from me. This is my code."); - Str8 *output; + WpStr8 *output; - output = wapp_str8_alloc_concat(&arena, &str, &suffix1); - result = output->size == concat1.size && wapp_str8_equal(output, &concat1); + output = wpStr8AllocConcat(&arena, &str, &suffix1); + result = output->size == concat1.size && wpStr8Equal(output, &concat1); - output = wapp_str8_alloc_concat(&arena, output, &suffix2); - result = result && output->size == concat2.size && wapp_str8_equal(output, &concat2); + output = wpStr8AllocConcat(&arena, output, &suffix2); + result = result && output->size == concat2.size && wpStr8Equal(output, &concat2); - wapp_mem_arena_allocator_destroy(&arena); + wpMemArenaAllocatorDestroy(&arena); - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_str8_concat_capped(void) { +WpTestFuncResult test_str8_concat_capped(void) { 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"); + WpStr8 str = wpStr8Lit("Hello world"); + WpStr8 suffix1 = wpStr8Lit(" from me."); + WpStr8 suffix2 = wpStr8Lit(" This is my code."); + WpStr8 concat1 = wpStr8Lit("Hello world from me."); + WpStr8 concat2 = wpStr8Lit("Hello world from me. T"); - wapp_str8_concat_capped(&str, &suffix1); - result = str.size == concat1.size && wapp_str8_equal(&str, &concat1); + wpStr8ConcatCapped(&str, &suffix1); + result = str.size == concat1.size && wpStr8Equal(&str, &concat1); - wapp_str8_concat_capped(&str, &suffix2); - result = result && str.size == concat2.size && wapp_str8_equal(&str, &concat2); + wpStr8ConcatCapped(&str, &suffix2); + result = result && str.size == concat2.size && wpStr8Equal(&str, &concat2); - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_str8_copy_cstr_capped(void) { +WpTestFuncResult test_str8_copy_cstr_capped(void) { b8 result; - Str8 buf = wapp_str8_buf(32); + WpStr8 buf = wpStr8Buf(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"); + WpStr8RO src1_cp = wpStr8LitRo("Hello world"); + WpStr8RO src2_cp = wpStr8LitRo("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); + wpStr8CopyCstrCapped(&buf, src1); + result = buf.size == src1_cp.size && wpStr8Equal(&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); + wpStr8CopyCstrCapped(&buf, src2); + result = result && buf.size == src2_cp.size && buf.size == buf.capacity && wpStr8Equal(&buf, &src2_cp); - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_str8_copy_str8_capped(void) { +WpTestFuncResult test_str8_copy_str8_capped(void) { 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"); + WpStr8 buf = wpStr8Buf(32); + WpStr8RO src1 = wpStr8LitRo("Hello world"); + WpStr8RO src2 = wpStr8LitRo("Hello world from the Wizard Apprentice standard library"); + WpStr8RO src2_cp = wpStr8LitRo("Hello world from the Wizard Appr"); - wapp_str8_copy_str8_capped(&buf, &src1); - result = buf.size == src1.size && wapp_str8_equal(&buf, &src1); + wpStr8CopyStr8Capped(&buf, &src1); + result = buf.size == src1.size && wpStr8Equal(&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); + wpStr8CopyStr8Capped(&buf, &src2); + result = result && buf.size < src2.size && buf.size == buf.capacity && wpStr8Equal(&buf, &src2_cp); - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_str8_format(void) { +WpTestFuncResult test_str8_format(void) { b8 result; - Str8 buf = wapp_str8_buf(128); - Str8 expected = wapp_str8_lit("My name is Abdelrahman and I am 35 years old"); + WpStr8 buf = wpStr8Buf(128); + WpStr8 expected = wpStr8Lit("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); + wpStr8Format(&buf, "My name is %s and I am %u years old", "Abdelrahman", 35); - result = wapp_str8_equal(&buf, &expected); + result = wpStr8Equal(&buf, &expected); - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_str8_find(void) { +WpTestFuncResult test_str8_find(void) { b8 result; - Str8RO s = wapp_str8_lit("Do as I say, not as I do"); + WpStr8RO s = wpStr8Lit("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 = wpStr8Find(&s, wpStr8LitRo("d")) != -1; + result = result && (wpStr8Find(&s, wpStr8LitRo("not")) != -1); + result = result && (wpStr8Find(&s, wpStr8LitRo("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 && (wpStr8Find(&s, wpStr8LitRo("f")) == -1); + result = result && (wpStr8Find(&s, wpStr8LitRo("hello")) == -1); + result = result && (wpStr8Find(&s, wpStr8LitRo("not sa I")) == -1); + result = result && (wpStr8Find(&s, wpStr8LitRo("Do unto others as you would have them do to you")) == -1); - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_str8_rfind(void) { +WpTestFuncResult test_str8_rfind(void) { b8 result; - Str8RO s = wapp_str8_lit("Do as I say, not as I do"); + WpStr8RO s = wpStr8Lit("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 = wpStr8Rfind(&s, wpStr8LitRo("d")) != -1; + result = result && (wpStr8Rfind(&s, wpStr8LitRo("not")) != -1); + result = result && (wpStr8Rfind(&s, wpStr8LitRo("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 && (wpStr8Rfind(&s, wpStr8LitRo("f")) == -1); + result = result && (wpStr8Rfind(&s, wpStr8LitRo("hello")) == -1); + result = result && (wpStr8Rfind(&s, wpStr8LitRo("not sa I")) == -1); + result = result && (wpStr8Rfind(&s, wpStr8LitRo("Do unto others as you would have them do to you")) == -1); - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_str8_split(void) { +WpTestFuncResult test_str8_split(void) { b8 result; - Allocator arena = wapp_mem_arena_allocator_init(KiB(100)); + WpAllocator arena = wpMemArenaAllocatorInit(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); + WpStr8 str = wpStr8Lit("hello world from me"); + WpStr8 delim1 = wpStr8Lit(" "); + WpStr8 delim2 = wpStr8Lit("from"); + WpStr8List *list1 = wpStr8Split(&arena, &str, &delim1); + WpStr8List *list2 = wpStr8Split(&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), + WpStr8RO splits1[] = { + wpStr8Slice(&str, 0, 5), + wpStr8Slice(&str, 6, 11), + wpStr8Slice(&str, 12, 16), + wpStr8Slice(&str, 17, 19), }; - Str8RO splits2[] = { - wapp_str8_slice(&str, 0, 12), - wapp_str8_slice(&str, 16, 19), + WpStr8RO splits2[] = { + wpStr8Slice(&str, 0, 12), + wpStr8Slice(&str, 16, 19), }; u64 index1 = 0; @@ -437,14 +437,14 @@ TestFuncResult test_str8_split(void) { 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 && wpStr8ListTotalSize(list1) == str.size - 3; + result = result && list2->node_count == count2 && wpStr8ListTotalSize(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) { - Str8 *node = wapp_dbl_list_get(Str8, list1, index1); - result = result && wapp_str8_equal(node, &(splits1[index1])); + WpStr8 *node = wpDblListGet(WpStr8, list1, index1); + result = result && wpStr8Equal(node, &(splits1[index1])); ++index1; running1 = index1 < count1; @@ -453,72 +453,72 @@ TestFuncResult test_str8_split(void) { // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of // MSVC Spectre mitigation warnings while (running2) { - Str8 *node = wapp_dbl_list_get(Str8, list2, index2); - result = result && wapp_str8_equal(node, &(splits2[index2])); + WpStr8 *node = wpDblListGet(WpStr8, list2, index2); + result = result && wpStr8Equal(node, &(splits2[index2])); ++index2; running2 = index2 < count2; } - wapp_mem_arena_allocator_destroy(&arena); + wpMemArenaAllocatorDestroy(&arena); - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_str8_split_with_max(void) { +WpTestFuncResult test_str8_split_with_max(void) { b8 result; - Allocator arena = wapp_mem_arena_allocator_init(KiB(100)); + WpAllocator arena = wpMemArenaAllocatorInit(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); + WpStr8 str = wpStr8Lit("hello world from me"); + WpStr8 delim = wpStr8Lit(" "); + WpStr8List *list = wpStr8SplitWithMax(&arena, &str, &delim, 2); - Str8RO splits[] = { - wapp_str8_slice(&str, 0, 5), - wapp_str8_slice(&str, 6, 11), - wapp_str8_slice(&str, 12, 19), + WpStr8RO splits[] = { + wpStr8Slice(&str, 0, 5), + wpStr8Slice(&str, 6, 11), + wpStr8Slice(&str, 12, 19), }; 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 && wpStr8ListTotalSize(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) { - Str8 *node = wapp_dbl_list_get(Str8, list, index); - result = result && wapp_str8_equal(node, &(splits[index])); + WpStr8 *node = wpDblListGet(WpStr8, list, index); + result = result && wpStr8Equal(node, &(splits[index])); ++index; running = index < count; } - wapp_mem_arena_allocator_destroy(&arena); + wpMemArenaAllocatorDestroy(&arena); - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_str8_rsplit(void) { +WpTestFuncResult test_str8_rsplit(void) { b8 result; - Allocator arena = wapp_mem_arena_allocator_init(KiB(100)); + WpAllocator arena = wpMemArenaAllocatorInit(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); + WpStr8 str = wpStr8Lit("hello world from me"); + WpStr8 delim1 = wpStr8Lit(" "); + WpStr8 delim2 = wpStr8Lit("from"); + WpStr8List *list1 = wpStr8Rsplit(&arena, &str, &delim1); + WpStr8List *list2 = wpStr8Rsplit(&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), + WpStr8RO splits1[] = { + wpStr8Slice(&str, 0, 5), + wpStr8Slice(&str, 6, 11), + wpStr8Slice(&str, 12, 16), + wpStr8Slice(&str, 17, 19), }; - Str8RO splits2[] = { - wapp_str8_slice(&str, 0, 12), - wapp_str8_slice(&str, 16, 19), + WpStr8RO splits2[] = { + wpStr8Slice(&str, 0, 12), + wpStr8Slice(&str, 16, 19), }; u64 index1 = 0; @@ -529,14 +529,14 @@ TestFuncResult test_str8_rsplit(void) { 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 && wpStr8ListTotalSize(list1) == str.size - 3; + result = result && list2->node_count == count2 && wpStr8ListTotalSize(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) { - Str8 *node = wapp_dbl_list_get(Str8, list1, index1); - result = result && wapp_str8_equal(node, &(splits1[index1])); + WpStr8 *node = wpDblListGet(WpStr8, list1, index1); + result = result && wpStr8Equal(node, &(splits1[index1])); ++index1; running1 = index1 < count1; @@ -545,82 +545,82 @@ TestFuncResult test_str8_rsplit(void) { // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of // MSVC Spectre mitigation warnings while (running2) { - Str8 *node = wapp_dbl_list_get(Str8, list2, index2); - result = result && wapp_str8_equal(node, &(splits2[index2])); + WpStr8 *node = wpDblListGet(WpStr8, list2, index2); + result = result && wpStr8Equal(node, &(splits2[index2])); ++index2; running2 = index2 < count2; } - wapp_mem_arena_allocator_destroy(&arena); + wpMemArenaAllocatorDestroy(&arena); - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_str8_rsplit_with_max(void) { +WpTestFuncResult test_str8_rsplit_with_max(void) { b8 result; - Allocator arena = wapp_mem_arena_allocator_init(KiB(100)); + WpAllocator arena = wpMemArenaAllocatorInit(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); + WpStr8 str = wpStr8Lit("hello world from me"); + WpStr8 delim = wpStr8Lit(" "); + WpStr8List *list = wpStr8RsplitWithMax(&arena, &str, &delim, 2); - Str8RO splits[] = { - wapp_str8_slice(&str, 0, 11), - wapp_str8_slice(&str, 12, 16), - wapp_str8_slice(&str, 17, 19), + WpStr8RO splits[] = { + wpStr8Slice(&str, 0, 11), + wpStr8Slice(&str, 12, 16), + wpStr8Slice(&str, 17, 19), }; 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 && wpStr8ListTotalSize(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) { - Str8 *node = wapp_dbl_list_get(Str8, list, index); - result = result && wapp_str8_equal(node, &(splits[index])); + WpStr8 *node = wpDblListGet(WpStr8, list, index); + result = result && wpStr8Equal(node, &(splits[index])); ++index; running = index < count; } - wapp_mem_arena_allocator_destroy(&arena); + wpMemArenaAllocatorDestroy(&arena); - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_str8_join(void) { +WpTestFuncResult test_str8_join(void) { b8 result; - Allocator arena = wapp_mem_arena_allocator_init(KiB(100)); + WpAllocator arena = wpMemArenaAllocatorInit(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); + WpStr8 str = wpStr8Lit("hello world from me"); + WpStr8 delim1 = wpStr8Lit(" "); + WpStr8 delim2 = wpStr8Lit("from"); + WpStr8List *list1 = wpStr8Rsplit(&arena, &str, &delim1); + WpStr8List *list2 = wpStr8Rsplit(&arena, &str, &delim2); + WpStr8 *join1 = wpStr8Join(&arena, list1, &delim1); + WpStr8 *join2 = wpStr8Join(&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 && wpStr8Equal(join1, &str); + result = result && join2->size == str.size && wpStr8Equal(join2, &str); - wapp_mem_arena_allocator_destroy(&arena); + wpMemArenaAllocatorDestroy(&arena); - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_str8_from_bytes(void) { +WpTestFuncResult test_str8_from_bytes(void) { b8 result; - Str8 str = wapp_str8_buf(1024); - U8Array bytes = wapp_array(u8, 'W', 'A', 'P', 'P'); - wapp_str8_from_bytes(&str, bytes); + WpStr8 str = wpStr8Buf(1024); + WpU8Array bytes = wpArray(u8, 'W', 'A', 'P', 'P'); + wpStr8FromBytes(&str, bytes); - result = str.size == wapp_array_count(bytes) * wapp_array_item_size(bytes); - result = result && wapp_str8_equal(&str, &wapp_str8_lit_ro("WAPP")); + result = str.size == wpArrayCount(bytes) * wpArrayItemSize(bytes); + result = result && wpStr8Equal(&str, &wpStr8LitRo("WAPP")); - return wapp_tester_result(result); + return wpTesterResult(result); } diff --git a/tests/str8/test_str8.cc b/tests/str8/test_str8.cc index 251d31b..02822c2 100644 --- a/tests/str8/test_str8.cc +++ b/tests/str8/test_str8.cc @@ -3,430 +3,430 @@ #define ARRLEN(ARR) (sizeof(ARR) / sizeof(ARR[0])) -TestFuncResult test_str8_lit(void) { +WpTestFuncResult test_str8_lit(void) { b8 result; - Str8 s1 = wapp_str8_lit("Hello world"); + WpStr8 s1 = wpStr8Lit("Hello world"); result = s1.capacity == 22 && s1.capacity != s1.size; - Str8 s2 = wapp_str8_lit("Different strokes for different folks"); + WpStr8 s2 = wpStr8Lit("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"); + WpStr8 s3 = wpStr8Lit("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"); + WpStr8 s4 = wpStr8Lit("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"); + WpStr8 s5 = wpStr8Lit("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"); + WpStr8 s6 = wpStr8Lit("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"); + WpStr8 s7 = wpStr8Lit("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 wpTesterResult(result); } -TestFuncResult test_str8_lit_ro(void) { +WpTestFuncResult test_str8_lit_ro(void) { b8 result; - Str8RO s1 = wapp_str8_lit_ro("Hello world"); + WpStr8RO s1 = wpStr8LitRo("Hello world"); result = s1.capacity == 11 && s1.capacity == s1.size; - Str8RO s2 = wapp_str8_lit_ro("Different strokes for different folks"); + WpStr8RO s2 = wpStr8LitRo("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"); + WpStr8RO s3 = wpStr8LitRo("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"); + WpStr8RO s4 = wpStr8LitRo("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"); + WpStr8RO s5 = wpStr8LitRo("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"); + WpStr8RO s6 = wpStr8LitRo("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"); + WpStr8RO s7 = wpStr8LitRo("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 wpTesterResult(result); } -TestFuncResult test_str8_buf(void) { +WpTestFuncResult test_str8_buf(void) { b8 result; - Str8 s1 = wapp_str8_buf(1024); + WpStr8 s1 = wpStr8Buf(1024); result = s1.capacity == 1024 && s1.size == 0; - Str8 s2 = wapp_str8_buf(2048); + WpStr8 s2 = wpStr8Buf(2048); result = result && s2.capacity == 2048 && s2.size == 0; - Str8 s3 = wapp_str8_buf(4096); + WpStr8 s3 = wpStr8Buf(4096); result = result && s3.capacity == 4096 && s3.size == 0; - Str8 s4 = wapp_str8_buf(8192); + WpStr8 s4 = wpStr8Buf(8192); result = result && s4.capacity == 8192 && s4.size == 0; - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_str8_alloc_buf(void) { +WpTestFuncResult 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); + WpAllocator allocator = wpMemArenaAllocatorInit(KiB(100)); + if (wpMemAllocatorInvalid(&allocator)) { + return wpTesterResult(false); } u64 capacity = 4096; - Str8 *s = wapp_str8_alloc_buf(&allocator, capacity); + WpStr8 *s = wpStr8AllocBuf(&allocator, capacity); if (!s) { result = false; - wapp_mem_arena_allocator_destroy(&allocator); - return wapp_tester_result(result); + wpMemArenaAllocatorDestroy(&allocator); + return wpTesterResult(result); } result = s->capacity == capacity; const char *cstr = "My name is Abdelrahman"; - wapp_str8_copy_cstr_capped(s, cstr); + wpStr8CopyCstrCapped(s, cstr); result = result && s->capacity == capacity && s->size == strlen(cstr) && memcmp(s->buf, cstr, s->size) == 0; - wapp_mem_arena_allocator_destroy(&allocator); + wpMemArenaAllocatorDestroy(&allocator); - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_str8_alloc_cstr(void) { +WpTestFuncResult 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); + WpAllocator allocator = wpMemArenaAllocatorInit(KiB(100)); + if (wpMemAllocatorInvalid(&allocator)) { + return wpTesterResult(false); } const char *str = "Abdelrahman"; u64 length = strlen(str); - Str8 *s = wapp_str8_alloc_cstr(&allocator, str); + WpStr8 *s = wpStr8AllocCstr(&allocator, str); if (!s) { - return wapp_tester_result(false); + return wpTesterResult(false); } result = s->size == length && memcmp(s->buf, str, length) == 0; - wapp_mem_arena_allocator_destroy(&allocator); + wpMemArenaAllocatorDestroy(&allocator); - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_str8_alloc_str8(void) { +WpTestFuncResult 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); + WpAllocator allocator = wpMemArenaAllocatorInit(KiB(100)); + if (wpMemAllocatorInvalid(&allocator)) { + return wpTesterResult(false); } - Str8 str = wapp_str8_lit("Abdelrahman"); - Str8 *s = wapp_str8_alloc_str8(&allocator, &str); + WpStr8 str = wpStr8Lit("Abdelrahman"); + WpStr8 *s = wpStr8AllocStr8(&allocator, &str); if (!s) { - return wapp_tester_result(false); + return wpTesterResult(false); } - result = wapp_str8_equal(s, &str); + result = wpStr8Equal(s, &str); - wapp_mem_arena_allocator_destroy(&allocator); + wpMemArenaAllocatorDestroy(&allocator); - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_str8_alloc_substr(void) { +WpTestFuncResult 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); + WpAllocator allocator = wpMemArenaAllocatorInit(KiB(100)); + if (wpMemAllocatorInvalid(&allocator)) { + return wpTesterResult(false); } - Str8 str = wapp_str8_lit("Abdelrahman"); - Str8 *s = wapp_str8_alloc_substr(&allocator, &str, 3, 8); + WpStr8 str = wpStr8Lit("Abdelrahman"); + WpStr8 *s = wpStr8AllocSubstr(&allocator, &str, 3, 8); if (!s) { - return wapp_tester_result(false); + return wpTesterResult(false); } result = s->size == 5 && memcmp(s->buf, "elrah", s->size) == 0; - wapp_mem_arena_allocator_destroy(&allocator); + wpMemArenaAllocatorDestroy(&allocator); - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_str8_get_index_within_bounds(void) { +WpTestFuncResult test_str8_get_index_within_bounds(void) { b8 result; - Str8RO s1 = wapp_str8_lit_ro("Hello world"); - result = wapp_str8_get(&s1, 4) == 'o'; + WpStr8RO s1 = wpStr8LitRo("Hello world"); + result = wpStr8Get(&s1, 4) == 'o'; - Str8RO s2 = wapp_str8_lit_ro("Different strokes for different folks"); - result = result && wapp_str8_get(&s2, 0) == 'D'; + WpStr8RO s2 = wpStr8LitRo("Different strokes for different folks"); + result = result && wpStr8Get(&s2, 0) == 'D'; - Str8RO s3 = wapp_str8_lit_ro("Discretion is the better part of valour"); - result = result && wapp_str8_get(&s3, 13) == ' '; + WpStr8RO s3 = wpStr8LitRo("Discretion is the better part of valour"); + result = result && wpStr8Get(&s3, 13) == ' '; - Str8RO s4 = wapp_str8_lit_ro("Distance lends enchantment to the view"); - result = result && wapp_str8_get(&s4, 20) == 'n'; + WpStr8RO s4 = wpStr8LitRo("Distance lends enchantment to the view"); + result = result && wpStr8Get(&s4, 20) == 'n'; - Str8RO s5 = wapp_str8_lit_ro("Do as I say, not as I do"); - result = result && wapp_str8_get(&s5, 11) == ','; + WpStr8RO s5 = wpStr8LitRo("Do as I say, not as I do"); + result = result && wpStr8Get(&s5, 11) == ','; - Str8RO s6 = wapp_str8_lit_ro("Do as you would be done by"); - result = result && wapp_str8_get(&s6, 25) == 'y'; + WpStr8RO s6 = wpStr8LitRo("Do as you would be done by"); + result = result && wpStr8Get(&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'; + WpStr8RO s7 = wpStr8LitRo("Do unto others as you would have them do to you"); + result = result && wpStr8Get(&s7, 16) == 's'; - return wapp_tester_result(result); + return wpTesterResult(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); +WpTestFuncResult test_str8_get_index_out_of_bounds(void) { + WpStr8 s1 = wpStr8Lit("Hello world"); + b8 result = wpStr8Get(&s1, 20) == '\0'; + return wpTesterResult(result); } -TestFuncResult test_str8_set(void) { +WpTestFuncResult test_str8_set(void) { b8 result; - Str8 s1 = wapp_str8_lit("Hello world"); - wapp_str8_set(&s1, 4, 'f'); - result = wapp_str8_get(&s1, 4) == 'f'; + WpStr8 s1 = wpStr8Lit("Hello world"); + wpStr8Set(&s1, 4, 'f'); + result = wpStr8Get(&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'; + WpStr8 s2 = wpStr8Lit("Different strokes for different folks"); + wpStr8Set(&s2, 0, 'A'); + result = result && wpStr8Get(&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'; + WpStr8 s3 = wpStr8Lit("Discretion is the better part of valour"); + wpStr8Set(&s3, 13, 'u'); + result = result && wpStr8Get(&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'; + WpStr8 s4 = wpStr8Lit("Distance lends enchantment to the view"); + wpStr8Set(&s4, 20, 'R'); + result = result && wpStr8Get(&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) == '.'; + WpStr8 s5 = wpStr8Lit("Do as I say, not as I do"); + wpStr8Set(&s5, 11, '.'); + result = result && wpStr8Get(&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'; + WpStr8 s6 = wpStr8Lit("Do as you would be done by"); + wpStr8Set(&s6, 25, 'w'); + result = result && wpStr8Get(&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'; + WpStr8 s7 = wpStr8Lit("Do unto others as you would have them do to you"); + wpStr8Set(&s7, 16, 'i'); + result = result && wpStr8Get(&s7, 16) == 'i'; - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_str8_push_back(void) { +WpTestFuncResult test_str8_push_back(void) { 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'); + WpStr8 expected = wpStr8Lit("Abdelrahman"); + WpStr8 buf = wpStr8Buf(64); + wpStr8PushBack(&buf, 'A'); + wpStr8PushBack(&buf, 'b'); + wpStr8PushBack(&buf, 'd'); + wpStr8PushBack(&buf, 'e'); + wpStr8PushBack(&buf, 'l'); + wpStr8PushBack(&buf, 'r'); + wpStr8PushBack(&buf, 'a'); + wpStr8PushBack(&buf, 'h'); + wpStr8PushBack(&buf, 'm'); + wpStr8PushBack(&buf, 'a'); + wpStr8PushBack(&buf, 'n'); - result = wapp_str8_equal(&buf, &expected); + result = wpStr8Equal(&buf, &expected); - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_str8_equal(void) { +WpTestFuncResult test_str8_equal(void) { 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"); + WpStr8RO s1 = wpStr8LitRo("hello"); + WpStr8RO s2 = wpStr8LitRo("hell"); + WpStr8RO s3 = wpStr8LitRo("hello"); + WpStr8RO s4 = wpStr8LitRo("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 = wpStr8Equal(&s1, &s2) == false; + result = result && wpStr8Equal(&s1, &s3) == (b8)true; + result = result && wpStr8Equal(&s1, &s4) == (b8)false; - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_str8_slice(void) { +WpTestFuncResult test_str8_slice(void) { b8 result; - Str8 s = wapp_str8_lit("Different strokes for different folks"); + WpStr8 s = wpStr8Lit("Different strokes for different folks"); - Str8RO sub1 = wapp_str8_slice(&s, 3, 9); + WpStr8RO sub1 = wpStr8Slice(&s, 3, 9); result = sub1.size == 6 && sub1.capacity == 6; - Str8RO sub2 = wapp_str8_slice(&s, 18, 21); + WpStr8RO sub2 = wpStr8Slice(&s, 18, 21); result = result && sub2.size == 3 && sub2.capacity == 3; - Str8RO sub3 = wapp_str8_slice(&s, 5, 1); + WpStr8RO sub3 = wpStr8Slice(&s, 5, 1); result = result && sub3.size == 0 && sub3.capacity == 0; - Str8RO sub4 = wapp_str8_slice(&s, 70, 80); + WpStr8RO sub4 = wpStr8Slice(&s, 70, 80); result = result && sub4.size == 0 && sub4.capacity == 0; - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_str8_alloc_concat(void) { +WpTestFuncResult test_str8_alloc_concat(void) { b8 result; - Allocator arena = wapp_mem_arena_allocator_init(KiB(100)); + WpAllocator arena = wpMemArenaAllocatorInit(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."); + WpStr8 str = wpStr8Lit("Hello world"); + WpStr8 suffix1 = wpStr8Lit(" from me."); + WpStr8 suffix2 = wpStr8Lit(" This is my code."); + WpStr8 concat1 = wpStr8Lit("Hello world from me."); + WpStr8 concat2 = wpStr8Lit("Hello world from me. This is my code."); - Str8 *output; + WpStr8 *output; - output = wapp_str8_alloc_concat(&arena, &str, &suffix1); - result = output->size == concat1.size && wapp_str8_equal(output, &concat1); + output = wpStr8AllocConcat(&arena, &str, &suffix1); + result = output->size == concat1.size && wpStr8Equal(output, &concat1); - output = wapp_str8_alloc_concat(&arena, output, &suffix2); - result = result && output->size == concat2.size && wapp_str8_equal(output, &concat2); + output = wpStr8AllocConcat(&arena, output, &suffix2); + result = result && output->size == concat2.size && wpStr8Equal(output, &concat2); - wapp_mem_arena_allocator_destroy(&arena); + wpMemArenaAllocatorDestroy(&arena); - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_str8_concat_capped(void) { +WpTestFuncResult test_str8_concat_capped(void) { 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"); + WpStr8 str = wpStr8Lit("Hello world"); + WpStr8 suffix1 = wpStr8Lit(" from me."); + WpStr8 suffix2 = wpStr8Lit(" This is my code."); + WpStr8 concat1 = wpStr8Lit("Hello world from me."); + WpStr8 concat2 = wpStr8Lit("Hello world from me. T"); - wapp_str8_concat_capped(&str, &suffix1); - result = str.size == concat1.size && wapp_str8_equal(&str, &concat1); + wpStr8ConcatCapped(&str, &suffix1); + result = str.size == concat1.size && wpStr8Equal(&str, &concat1); - wapp_str8_concat_capped(&str, &suffix2); - result = result && str.size == concat2.size && wapp_str8_equal(&str, &concat2); + wpStr8ConcatCapped(&str, &suffix2); + result = result && str.size == concat2.size && wpStr8Equal(&str, &concat2); - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_str8_copy_cstr_capped(void) { +WpTestFuncResult test_str8_copy_cstr_capped(void) { b8 result; - Str8 buf = wapp_str8_buf(32); + WpStr8 buf = wpStr8Buf(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"); + WpStr8RO src1_cp = wpStr8LitRo("Hello world"); + WpStr8RO src2_cp = wpStr8LitRo("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); + wpStr8CopyCstrCapped(&buf, src1); + result = buf.size == src1_cp.size && wpStr8Equal(&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); + wpStr8CopyCstrCapped(&buf, src2); + result = result && buf.size == src2_cp.size && buf.size == buf.capacity && wpStr8Equal(&buf, &src2_cp); - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_str8_copy_str8_capped(void) { +WpTestFuncResult test_str8_copy_str8_capped(void) { 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"); + WpStr8 buf = wpStr8Buf(32); + WpStr8RO src1 = wpStr8LitRo("Hello world"); + WpStr8RO src2 = wpStr8LitRo("Hello world from the Wizard Apprentice standard library"); + WpStr8RO src2_cp = wpStr8LitRo("Hello world from the Wizard Appr"); - wapp_str8_copy_str8_capped(&buf, &src1); - result = buf.size == src1.size && wapp_str8_equal(&buf, &src1); + wpStr8CopyStr8Capped(&buf, &src1); + result = buf.size == src1.size && wpStr8Equal(&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); + wpStr8CopyStr8Capped(&buf, &src2); + result = result && buf.size < src2.size && buf.size == buf.capacity && wpStr8Equal(&buf, &src2_cp); - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_str8_format(void) { +WpTestFuncResult test_str8_format(void) { b8 result; - Str8 buf = wapp_str8_buf(128); - Str8 expected = wapp_str8_lit("My name is Abdelrahman and I am 35 years old"); + WpStr8 buf = wpStr8Buf(128); + WpStr8 expected = wpStr8Lit("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); + wpStr8Format(&buf, "My name is %s and I am %u years old", "Abdelrahman", 35); - result = wapp_str8_equal(&buf, &expected); + result = wpStr8Equal(&buf, &expected); - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_str8_find(void) { +WpTestFuncResult test_str8_find(void) { b8 result; - Str8RO s = wapp_str8_lit("Do as I say, not as I do"); + WpStr8RO s = wpStr8Lit("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 = wpStr8Find(&s, wpStr8LitRo("d")) != -1; + result = result && (wpStr8Find(&s, wpStr8LitRo("not")) != -1); + result = result && (wpStr8Find(&s, wpStr8LitRo("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 && (wpStr8Find(&s, wpStr8LitRo("f")) == -1); + result = result && (wpStr8Find(&s, wpStr8LitRo("hello")) == -1); + result = result && (wpStr8Find(&s, wpStr8LitRo("not sa I")) == -1); + result = result && (wpStr8Find(&s, wpStr8LitRo("Do unto others as you would have them do to you")) == -1); - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_str8_rfind(void) { +WpTestFuncResult test_str8_rfind(void) { b8 result; - Str8RO s = wapp_str8_lit("Do as I say, not as I do"); + WpStr8RO s = wpStr8Lit("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 = wpStr8Rfind(&s, wpStr8LitRo("d")) != -1; + result = result && (wpStr8Rfind(&s, wpStr8LitRo("not")) != -1); + result = result && (wpStr8Rfind(&s, wpStr8LitRo("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 && (wpStr8Rfind(&s, wpStr8LitRo("f")) == -1); + result = result && (wpStr8Rfind(&s, wpStr8LitRo("hello")) == -1); + result = result && (wpStr8Rfind(&s, wpStr8LitRo("not sa I")) == -1); + result = result && (wpStr8Rfind(&s, wpStr8LitRo("Do unto others as you would have them do to you")) == -1); - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_str8_split(void) { +WpTestFuncResult test_str8_split(void) { b8 result; - Allocator arena = wapp_mem_arena_allocator_init(KiB(100)); + WpAllocator arena = wpMemArenaAllocatorInit(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); + WpStr8 str = wpStr8Lit("hello world from me"); + WpStr8 delim1 = wpStr8Lit(" "); + WpStr8 delim2 = wpStr8Lit("from"); + WpStr8List *list1 = wpStr8Split(&arena, &str, &delim1); + WpStr8List *list2 = wpStr8Split(&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), + WpStr8RO splits1[] = { + wpStr8Slice(&str, 0, 5), + wpStr8Slice(&str, 6, 11), + wpStr8Slice(&str, 12, 16), + wpStr8Slice(&str, 17, 19), }; - Str8RO splits2[] = { - wapp_str8_slice(&str, 0, 12), - wapp_str8_slice(&str, 16, 19), + WpStr8RO splits2[] = { + wpStr8Slice(&str, 0, 12), + wpStr8Slice(&str, 16, 19), }; u64 index1 = 0; @@ -437,14 +437,14 @@ TestFuncResult test_str8_split(void) { 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 && wpStr8ListTotalSize(list1) == str.size - 3; + result = result && list2->node_count == count2 && wpStr8ListTotalSize(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) { - Str8 *node = wapp_dbl_list_get(Str8, list1, index1); - result = result && wapp_str8_equal(node, &(splits1[index1])); + WpStr8 *node = wpDblListGet(WpStr8, list1, index1); + result = result && wpStr8Equal(node, &(splits1[index1])); ++index1; running1 = index1 < count1; @@ -453,72 +453,72 @@ TestFuncResult test_str8_split(void) { // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of // MSVC Spectre mitigation warnings while (running2) { - Str8 *node = wapp_dbl_list_get(Str8, list2, index2); - result = result && wapp_str8_equal(node, &(splits2[index2])); + WpStr8 *node = wpDblListGet(WpStr8, list2, index2); + result = result && wpStr8Equal(node, &(splits2[index2])); ++index2; running2 = index2 < count2; } - wapp_mem_arena_allocator_destroy(&arena); + wpMemArenaAllocatorDestroy(&arena); - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_str8_split_with_max(void) { +WpTestFuncResult test_str8_split_with_max(void) { b8 result; - Allocator arena = wapp_mem_arena_allocator_init(KiB(100)); + WpAllocator arena = wpMemArenaAllocatorInit(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); + WpStr8 str = wpStr8Lit("hello world from me"); + WpStr8 delim = wpStr8Lit(" "); + WpStr8List *list = wpStr8SplitWithMax(&arena, &str, &delim, 2); - Str8RO splits[] = { - wapp_str8_slice(&str, 0, 5), - wapp_str8_slice(&str, 6, 11), - wapp_str8_slice(&str, 12, 19), + WpStr8RO splits[] = { + wpStr8Slice(&str, 0, 5), + wpStr8Slice(&str, 6, 11), + wpStr8Slice(&str, 12, 19), }; 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 && wpStr8ListTotalSize(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) { - Str8 *node = wapp_dbl_list_get(Str8, list, index); - result = result && wapp_str8_equal(node, &(splits[index])); + WpStr8 *node = wpDblListGet(WpStr8, list, index); + result = result && wpStr8Equal(node, &(splits[index])); ++index; running = index < count; } - wapp_mem_arena_allocator_destroy(&arena); + wpMemArenaAllocatorDestroy(&arena); - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_str8_rsplit(void) { +WpTestFuncResult test_str8_rsplit(void) { b8 result; - Allocator arena = wapp_mem_arena_allocator_init(KiB(100)); + WpAllocator arena = wpMemArenaAllocatorInit(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); + WpStr8 str = wpStr8Lit("hello world from me"); + WpStr8 delim1 = wpStr8Lit(" "); + WpStr8 delim2 = wpStr8Lit("from"); + WpStr8List *list1 = wpStr8Rsplit(&arena, &str, &delim1); + WpStr8List *list2 = wpStr8Rsplit(&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), + WpStr8RO splits1[] = { + wpStr8Slice(&str, 0, 5), + wpStr8Slice(&str, 6, 11), + wpStr8Slice(&str, 12, 16), + wpStr8Slice(&str, 17, 19), }; - Str8RO splits2[] = { - wapp_str8_slice(&str, 0, 12), - wapp_str8_slice(&str, 16, 19), + WpStr8RO splits2[] = { + wpStr8Slice(&str, 0, 12), + wpStr8Slice(&str, 16, 19), }; u64 index1 = 0; @@ -529,14 +529,14 @@ TestFuncResult test_str8_rsplit(void) { 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 && wpStr8ListTotalSize(list1) == str.size - 3; + result = result && list2->node_count == count2 && wpStr8ListTotalSize(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) { - Str8 *node = wapp_dbl_list_get(Str8, list1, index1); - result = result && wapp_str8_equal(node, &(splits1[index1])); + WpStr8 *node = wpDblListGet(WpStr8, list1, index1); + result = result && wpStr8Equal(node, &(splits1[index1])); ++index1; running1 = index1 < count1; @@ -545,83 +545,83 @@ TestFuncResult test_str8_rsplit(void) { // NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of // MSVC Spectre mitigation warnings while (running2) { - Str8 *node = wapp_dbl_list_get(Str8, list2, index2); - result = result && wapp_str8_equal(node, &(splits2[index2])); + WpStr8 *node = wpDblListGet(WpStr8, list2, index2); + result = result && wpStr8Equal(node, &(splits2[index2])); ++index2; running2 = index2 < count2; } - wapp_mem_arena_allocator_destroy(&arena); + wpMemArenaAllocatorDestroy(&arena); - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_str8_rsplit_with_max(void) { +WpTestFuncResult test_str8_rsplit_with_max(void) { b8 result; - Allocator arena = wapp_mem_arena_allocator_init(KiB(100)); + WpAllocator arena = wpMemArenaAllocatorInit(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); + WpStr8 str = wpStr8Lit("hello world from me"); + WpStr8 delim = wpStr8Lit(" "); + WpStr8List *list = wpStr8RsplitWithMax(&arena, &str, &delim, 2); - Str8RO splits[] = { - wapp_str8_slice(&str, 0, 11), - wapp_str8_slice(&str, 12, 16), - wapp_str8_slice(&str, 17, 19), + WpStr8RO splits[] = { + wpStr8Slice(&str, 0, 11), + wpStr8Slice(&str, 12, 16), + wpStr8Slice(&str, 17, 19), }; 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 && wpStr8ListTotalSize(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) { - Str8 *node = wapp_dbl_list_get(Str8, list, index); - result = result && wapp_str8_equal(node, &(splits[index])); + WpStr8 *node = wpDblListGet(WpStr8, list, index); + result = result && wpStr8Equal(node, &(splits[index])); ++index; running = index < count; } - wapp_mem_arena_allocator_destroy(&arena); + wpMemArenaAllocatorDestroy(&arena); - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_str8_join(void) { +WpTestFuncResult test_str8_join(void) { b8 result; - Allocator arena = wapp_mem_arena_allocator_init(KiB(100)); + WpAllocator arena = wpMemArenaAllocatorInit(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); + WpStr8 str = wpStr8Lit("hello world from me"); + WpStr8 delim1 = wpStr8Lit(" "); + WpStr8 delim2 = wpStr8Lit("from"); + WpStr8List *list1 = wpStr8Rsplit(&arena, &str, &delim1); + WpStr8List *list2 = wpStr8Rsplit(&arena, &str, &delim2); + WpStr8 *join1 = wpStr8Join(&arena, list1, &delim1); + WpStr8 *join2 = wpStr8Join(&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 && wpStr8Equal(join1, &str); + result = result && join2->size == str.size && wpStr8Equal(join2, &str); - wapp_mem_arena_allocator_destroy(&arena); + wpMemArenaAllocatorDestroy(&arena); - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_str8_from_bytes(void) { +WpTestFuncResult test_str8_from_bytes(void) { b8 result; - Str8 str = wapp_str8_buf(1024); - Str8 expected = wapp_str8_lit_ro("WAPP"); - U8Array bytes = wapp_array(u8, 'W', 'A', 'P', 'P'); - wapp_str8_from_bytes(&str, bytes); + WpStr8 str = wpStr8Buf(1024); + WpStr8 expected = wpStr8LitRo("WAPP"); + WpU8Array bytes = wpArray(u8, 'W', 'A', 'P', 'P'); + wpStr8FromBytes(&str, bytes); - result = str.size == wapp_array_count(bytes) * wapp_array_item_size(bytes); - result = result && wapp_str8_equal(&str, &expected); + result = str.size == wpArrayCount(bytes) * wpArrayItemSize(bytes); + result = result && wpStr8Equal(&str, &expected); - return wapp_tester_result(result); + return wpTesterResult(result); } diff --git a/tests/str8/test_str8.h b/tests/str8/test_str8.h index f3a2221..35b6438 100644 --- a/tests/str8/test_str8.h +++ b/tests/str8/test_str8.h @@ -3,31 +3,31 @@ #include "wapp.h" -TestFuncResult test_str8_lit(void); -TestFuncResult test_str8_lit_ro(void); -TestFuncResult test_str8_buf(void); -TestFuncResult test_str8_alloc_buf(void); -TestFuncResult test_str8_alloc_cstr(void); -TestFuncResult test_str8_alloc_str8(void); -TestFuncResult test_str8_alloc_substr(void); -TestFuncResult test_str8_alloc_concat(void); -TestFuncResult test_str8_get_index_within_bounds(void); -TestFuncResult test_str8_get_index_out_of_bounds(void); -TestFuncResult test_str8_set(void); -TestFuncResult test_str8_push_back(void); -TestFuncResult test_str8_equal(void); -TestFuncResult test_str8_slice(void); -TestFuncResult test_str8_concat_capped(void); -TestFuncResult test_str8_copy_cstr_capped(void); -TestFuncResult test_str8_copy_str8_capped(void); -TestFuncResult test_str8_format(void); -TestFuncResult test_str8_find(void); -TestFuncResult test_str8_rfind(void); -TestFuncResult test_str8_split(void); -TestFuncResult test_str8_split_with_max(void); -TestFuncResult test_str8_rsplit(void); -TestFuncResult test_str8_rsplit_with_max(void); -TestFuncResult test_str8_join(void); -TestFuncResult test_str8_from_bytes(void); +WpTestFuncResult test_str8_lit(void); +WpTestFuncResult test_str8_lit_ro(void); +WpTestFuncResult test_str8_buf(void); +WpTestFuncResult test_str8_alloc_buf(void); +WpTestFuncResult test_str8_alloc_cstr(void); +WpTestFuncResult test_str8_alloc_str8(void); +WpTestFuncResult test_str8_alloc_substr(void); +WpTestFuncResult test_str8_alloc_concat(void); +WpTestFuncResult test_str8_get_index_within_bounds(void); +WpTestFuncResult test_str8_get_index_out_of_bounds(void); +WpTestFuncResult test_str8_set(void); +WpTestFuncResult test_str8_push_back(void); +WpTestFuncResult test_str8_equal(void); +WpTestFuncResult test_str8_slice(void); +WpTestFuncResult test_str8_concat_capped(void); +WpTestFuncResult test_str8_copy_cstr_capped(void); +WpTestFuncResult test_str8_copy_str8_capped(void); +WpTestFuncResult test_str8_format(void); +WpTestFuncResult test_str8_find(void); +WpTestFuncResult test_str8_rfind(void); +WpTestFuncResult test_str8_split(void); +WpTestFuncResult test_str8_split_with_max(void); +WpTestFuncResult test_str8_rsplit(void); +WpTestFuncResult test_str8_rsplit_with_max(void); +WpTestFuncResult test_str8_join(void); +WpTestFuncResult test_str8_from_bytes(void); #endif // !TEST_STR8_H diff --git a/tests/str8/test_str8_list.c b/tests/str8/test_str8_list.c index 525d682..9c375e0 100644 --- a/tests/str8/test_str8_list.c +++ b/tests/str8/test_str8_list.c @@ -1,230 +1,230 @@ #include "test_str8_list.h" #include "wapp.h" -TestFuncResult test_str8_list_get(void) { +WpTestFuncResult test_str8_list_get(void) { 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"); + WpStr8 s1 = wpStr8Lit("1"); + WpStr8 s2 = wpStr8Lit("2"); + WpStr8 s3 = wpStr8Lit("3"); + WpStr8 s4 = wpStr8Lit("4"); + WpStr8 s5 = wpStr8Lit("5"); - Str8List list = wapp_dbl_list(Str8); + WpStr8List list = wpDblList(WpStr8); - wapp_dbl_list_push_back(Str8, &list, &s1); - wapp_dbl_list_push_back(Str8, &list, &s2); - wapp_dbl_list_push_back(Str8, &list, &s3); - wapp_dbl_list_push_back(Str8, &list, &s4); - wapp_dbl_list_push_back(Str8, &list, &s5); + wpDblListPushBack(WpStr8, &list, &s1); + wpDblListPushBack(WpStr8, &list, &s2); + wpDblListPushBack(WpStr8, &list, &s3); + wpDblListPushBack(WpStr8, &list, &s4); + wpDblListPushBack(WpStr8, &list, &s5); - Str8 *node = wapp_dbl_list_get(Str8, &list, 0); - result = node == &s1 && wapp_str8_equal(node, &s1); + WpStr8 *node = wpDblListGet(WpStr8, &list, 0); + result = node == &s1 && wpStr8Equal(node, &s1); - node = wapp_dbl_list_get(Str8, &list, 1); - result = result && node == &s2 && wapp_str8_equal(node, &s2); + node = wpDblListGet(WpStr8, &list, 1); + result = result && node == &s2 && wpStr8Equal(node, &s2); - node = wapp_dbl_list_get(Str8, &list, 2); - result = result && node == &s3 && wapp_str8_equal(node, &s3); + node = wpDblListGet(WpStr8, &list, 2); + result = result && node == &s3 && wpStr8Equal(node, &s3); - node = wapp_dbl_list_get(Str8, &list, 3); - result = result && node == &s4 && wapp_str8_equal(node, &s4); + node = wpDblListGet(WpStr8, &list, 3); + result = result && node == &s4 && wpStr8Equal(node, &s4); - node = wapp_dbl_list_get(Str8, &list, 4); - result = result && node == &s5 && wapp_str8_equal(node, &s5); + node = wpDblListGet(WpStr8, &list, 4); + result = result && node == &s5 && wpStr8Equal(node, &s5); - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_str8_list_push_front(void) { +WpTestFuncResult test_str8_list_push_front(void) { b8 result; - Str8 s1 = wapp_str8_lit("1"); - Str8 s2 = wapp_str8_lit("2"); - Str8 s3 = wapp_str8_lit("3"); + WpStr8 s1 = wpStr8Lit("1"); + WpStr8 s2 = wpStr8Lit("2"); + WpStr8 s3 = wpStr8Lit("3"); - Str8List list = wapp_dbl_list(Str8); + WpStr8List list = wpDblList(WpStr8); - wapp_dbl_list_push_front(Str8, &list, &s1); - result = list.first == list.last && list.first->item == &s1 && wapp_str8_list_total_size(&list) == 1 && list.node_count == 1; + wpDblListPushFront(WpStr8, &list, &s1); + result = list.first == list.last && list.first->item == &s1 && wpStr8ListTotalSize(&list) == 1 && list.node_count == 1; - wapp_dbl_list_push_front(Str8, &list, &s2); - result = result && list.first->item == &s2 && wapp_str8_list_total_size(&list) == 2 && list.node_count == 2; + wpDblListPushFront(WpStr8, &list, &s2); + result = result && list.first->item == &s2 && wpStr8ListTotalSize(&list) == 2 && list.node_count == 2; - wapp_dbl_list_push_front(Str8, &list, &s3); - result = result && list.first->item == &s3 && wapp_str8_list_total_size(&list) == 3 && list.node_count == 3; + wpDblListPushFront(WpStr8, &list, &s3); + result = result && list.first->item == &s3 && wpStr8ListTotalSize(&list) == 3 && list.node_count == 3; - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_str8_list_push_back(void) { +WpTestFuncResult test_str8_list_push_back(void) { b8 result; - Str8 s1 = wapp_str8_lit("1"); - Str8 s2 = wapp_str8_lit("2"); - Str8 s3 = wapp_str8_lit("3"); + WpStr8 s1 = wpStr8Lit("1"); + WpStr8 s2 = wpStr8Lit("2"); + WpStr8 s3 = wpStr8Lit("3"); - Str8List list = wapp_dbl_list(Str8); + WpStr8List list = wpDblList(WpStr8); - wapp_dbl_list_push_back(Str8, &list, &s1); - result = list.first == list.last && list.last->item == &s1 && wapp_str8_list_total_size(&list) == 1 && list.node_count == 1; + wpDblListPushBack(WpStr8, &list, &s1); + result = list.first == list.last && list.last->item == &s1 && wpStr8ListTotalSize(&list) == 1 && list.node_count == 1; - wapp_dbl_list_push_back(Str8, &list, &s2); - result = result && list.last->item == &s2 && wapp_str8_list_total_size(&list) == 2 && list.node_count == 2; + wpDblListPushBack(WpStr8, &list, &s2); + result = result && list.last->item == &s2 && wpStr8ListTotalSize(&list) == 2 && list.node_count == 2; - wapp_dbl_list_push_back(Str8, &list, &s3); - result = result && list.last->item == &s3 && wapp_str8_list_total_size(&list) == 3 && list.node_count == 3; + wpDblListPushBack(WpStr8, &list, &s3); + result = result && list.last->item == &s3 && wpStr8ListTotalSize(&list) == 3 && list.node_count == 3; - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_str8_list_insert(void) { +WpTestFuncResult test_str8_list_insert(void) { 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"); + WpStr8 s1 = wpStr8Lit("1"); + WpStr8 s2 = wpStr8Lit("2"); + WpStr8 s3 = wpStr8Lit("3"); + WpStr8 s4 = wpStr8Lit("4"); + WpStr8 s5 = wpStr8Lit("5"); + WpStr8 s6 = wpStr8Lit("6"); + WpStr8 s7 = wpStr8Lit("7"); - Str8List list = wapp_dbl_list(Str8); + WpStr8List list = wpDblList(WpStr8); - wapp_dbl_list_push_back(Str8, &list, &s1); - wapp_dbl_list_push_back(Str8, &list, &s2); - wapp_dbl_list_push_back(Str8, &list, &s3); - wapp_dbl_list_push_back(Str8, &list, &s4); - wapp_dbl_list_push_back(Str8, &list, &s5); + wpDblListPushBack(WpStr8, &list, &s1); + wpDblListPushBack(WpStr8, &list, &s2); + wpDblListPushBack(WpStr8, &list, &s3); + wpDblListPushBack(WpStr8, &list, &s4); + wpDblListPushBack(WpStr8, &list, &s5); - Str8 *node; - wapp_dbl_list_insert(Str8, &list, &s6, 2); - node = wapp_dbl_list_get(Str8, &list, 2); - result = node != NULL && node == &s6 && wapp_str8_list_total_size(&list) == 6 && list.node_count == 6; - wapp_dbl_list_insert(Str8, &list, &s7, 5); - node = wapp_dbl_list_get(Str8, &list, 5); - result = result && node != NULL && node == &s7 && wapp_str8_list_total_size(&list) == 7 && list.node_count == 7; + WpStr8 *node; + wpDblListInsert(WpStr8, &list, &s6, 2); + node = wpDblListGet(WpStr8, &list, 2); + result = node != NULL && node == &s6 && wpStr8ListTotalSize(&list) == 6 && list.node_count == 6; + wpDblListInsert(WpStr8, &list, &s7, 5); + node = wpDblListGet(WpStr8, &list, 5); + result = result && node != NULL && node == &s7 && wpStr8ListTotalSize(&list) == 7 && list.node_count == 7; - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_str8_list_pop_front(void) { +WpTestFuncResult test_str8_list_pop_front(void) { 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"); + WpStr8 s1 = wpStr8Lit("1"); + WpStr8 s2 = wpStr8Lit("2"); + WpStr8 s3 = wpStr8Lit("3"); + WpStr8 s4 = wpStr8Lit("4"); + WpStr8 s5 = wpStr8Lit("5"); - Str8List list = wapp_dbl_list(Str8); + WpStr8List list = wpDblList(WpStr8); - wapp_dbl_list_push_back(Str8, &list, &s1); - wapp_dbl_list_push_back(Str8, &list, &s2); - wapp_dbl_list_push_back(Str8, &list, &s3); - wapp_dbl_list_push_back(Str8, &list, &s4); - wapp_dbl_list_push_back(Str8, &list, &s5); + wpDblListPushBack(WpStr8, &list, &s1); + wpDblListPushBack(WpStr8, &list, &s2); + wpDblListPushBack(WpStr8, &list, &s3); + wpDblListPushBack(WpStr8, &list, &s4); + wpDblListPushBack(WpStr8, &list, &s5); - Str8 *node = wapp_dbl_list_pop_front(Str8, &list); - result = node == &s1 && wapp_str8_equal(node, &s1) && wapp_str8_list_total_size(&list) == 4 && list.node_count == 4; + WpStr8 *node = wpDblListPopFront(WpStr8, &list); + result = node == &s1 && wpStr8Equal(node, &s1) && wpStr8ListTotalSize(&list) == 4 && list.node_count == 4; - node = wapp_dbl_list_pop_front(Str8, &list); - result = result && node == &s2 && wapp_str8_equal(node, &s2) && wapp_str8_list_total_size(&list) == 3 && list.node_count == 3; + node = wpDblListPopFront(WpStr8, &list); + result = result && node == &s2 && wpStr8Equal(node, &s2) && wpStr8ListTotalSize(&list) == 3 && list.node_count == 3; - node = wapp_dbl_list_pop_front(Str8, &list); - result = result && node == &s3 && wapp_str8_equal(node, &s3) && wapp_str8_list_total_size(&list) == 2 && list.node_count == 2; + node = wpDblListPopFront(WpStr8, &list); + result = result && node == &s3 && wpStr8Equal(node, &s3) && wpStr8ListTotalSize(&list) == 2 && list.node_count == 2; - node = wapp_dbl_list_pop_front(Str8, &list); - result = result && node == &s4 && wapp_str8_equal(node, &s4) && wapp_str8_list_total_size(&list) == 1 && list.node_count == 1; + node = wpDblListPopFront(WpStr8, &list); + result = result && node == &s4 && wpStr8Equal(node, &s4) && wpStr8ListTotalSize(&list) == 1 && list.node_count == 1; - node = wapp_dbl_list_pop_front(Str8, &list); - result = result && node == &s5 && wapp_str8_equal(node, &s5) && wapp_str8_list_total_size(&list) == 0 && list.node_count == 0; + node = wpDblListPopFront(WpStr8, &list); + result = result && node == &s5 && wpStr8Equal(node, &s5) && wpStr8ListTotalSize(&list) == 0 && list.node_count == 0; - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_str8_list_pop_back(void) { +WpTestFuncResult test_str8_list_pop_back(void) { 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"); + WpStr8 s1 = wpStr8Lit("1"); + WpStr8 s2 = wpStr8Lit("2"); + WpStr8 s3 = wpStr8Lit("3"); + WpStr8 s4 = wpStr8Lit("4"); + WpStr8 s5 = wpStr8Lit("5"); - Str8List list = wapp_dbl_list(Str8); + WpStr8List list = wpDblList(WpStr8); - wapp_dbl_list_push_front(Str8, &list, &s1); - wapp_dbl_list_push_front(Str8, &list, &s2); - wapp_dbl_list_push_front(Str8, &list, &s3); - wapp_dbl_list_push_front(Str8, &list, &s4); - wapp_dbl_list_push_front(Str8, &list, &s5); + wpDblListPushFront(WpStr8, &list, &s1); + wpDblListPushFront(WpStr8, &list, &s2); + wpDblListPushFront(WpStr8, &list, &s3); + wpDblListPushFront(WpStr8, &list, &s4); + wpDblListPushFront(WpStr8, &list, &s5); - Str8 *node = wapp_dbl_list_pop_back(Str8, &list); - result = node == &s1 && wapp_str8_equal(node, &s1) && wapp_str8_list_total_size(&list) == 4 && list.node_count == 4; + WpStr8 *node = wpDblListPopBack(WpStr8, &list); + result = node == &s1 && wpStr8Equal(node, &s1) && wpStr8ListTotalSize(&list) == 4 && list.node_count == 4; - node = wapp_dbl_list_pop_back(Str8, &list); - result = result && node == &s2 && wapp_str8_equal(node, &s2) && wapp_str8_list_total_size(&list) == 3 && list.node_count == 3; + node = wpDblListPopBack(WpStr8, &list); + result = result && node == &s2 && wpStr8Equal(node, &s2) && wpStr8ListTotalSize(&list) == 3 && list.node_count == 3; - node = wapp_dbl_list_pop_back(Str8, &list); - result = result && node == &s3 && wapp_str8_equal(node, &s3) && wapp_str8_list_total_size(&list) == 2 && list.node_count == 2; + node = wpDblListPopBack(WpStr8, &list); + result = result && node == &s3 && wpStr8Equal(node, &s3) && wpStr8ListTotalSize(&list) == 2 && list.node_count == 2; - node = wapp_dbl_list_pop_back(Str8, &list); - result = result && node == &s4 && wapp_str8_equal(node, &s4) && wapp_str8_list_total_size(&list) == 1 && list.node_count == 1; + node = wpDblListPopBack(WpStr8, &list); + result = result && node == &s4 && wpStr8Equal(node, &s4) && wpStr8ListTotalSize(&list) == 1 && list.node_count == 1; - node = wapp_dbl_list_pop_back(Str8, &list); - result = result && node == &s5 && wapp_str8_equal(node, &s5) && wapp_str8_list_total_size(&list) == 0 && list.node_count == 0; + node = wpDblListPopBack(WpStr8, &list); + result = result && node == &s5 && wpStr8Equal(node, &s5) && wpStr8ListTotalSize(&list) == 0 && list.node_count == 0; - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_str8_list_remove(void) { +WpTestFuncResult test_str8_list_remove(void) { 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"); + WpStr8 s1 = wpStr8Lit("1"); + WpStr8 s2 = wpStr8Lit("2"); + WpStr8 s3 = wpStr8Lit("3"); + WpStr8 s4 = wpStr8Lit("4"); + WpStr8 s5 = wpStr8Lit("5"); - Str8List list = wapp_dbl_list(Str8); + WpStr8List list = wpDblList(WpStr8); - wapp_dbl_list_push_back(Str8, &list, &s1); - wapp_dbl_list_push_back(Str8, &list, &s2); - wapp_dbl_list_push_back(Str8, &list, &s3); - wapp_dbl_list_push_back(Str8, &list, &s4); - wapp_dbl_list_push_back(Str8, &list, &s5); + wpDblListPushBack(WpStr8, &list, &s1); + wpDblListPushBack(WpStr8, &list, &s2); + wpDblListPushBack(WpStr8, &list, &s3); + wpDblListPushBack(WpStr8, &list, &s4); + wpDblListPushBack(WpStr8, &list, &s5); - Str8 *node = wapp_dbl_list_remove(Str8, &list, 0); - result = node == &s1 && wapp_str8_equal(node, &s1) && wapp_str8_list_total_size(&list) == 4 && list.node_count == 4; + WpStr8 *node = wpDblListRemove(WpStr8, &list, 0); + result = node == &s1 && wpStr8Equal(node, &s1) && wpStr8ListTotalSize(&list) == 4 && list.node_count == 4; - node = wapp_dbl_list_remove(Str8, &list, 0); - result = result && node == &s2 && wapp_str8_equal(node, &s2) && wapp_str8_list_total_size(&list) == 3 && list.node_count == 3; + node = wpDblListRemove(WpStr8, &list, 0); + result = result && node == &s2 && wpStr8Equal(node, &s2) && wpStr8ListTotalSize(&list) == 3 && list.node_count == 3; - node = wapp_dbl_list_remove(Str8, &list, 0); - result = result && node == &s3 && wapp_str8_equal(node, &s3) && wapp_str8_list_total_size(&list) == 2 && list.node_count == 2; + node = wpDblListRemove(WpStr8, &list, 0); + result = result && node == &s3 && wpStr8Equal(node, &s3) && wpStr8ListTotalSize(&list) == 2 && list.node_count == 2; - node = wapp_dbl_list_remove(Str8, &list, 0); - result = result && node == &s4 && wapp_str8_equal(node, &s4) && wapp_str8_list_total_size(&list) == 1 && list.node_count == 1; + node = wpDblListRemove(WpStr8, &list, 0); + result = result && node == &s4 && wpStr8Equal(node, &s4) && wpStr8ListTotalSize(&list) == 1 && list.node_count == 1; - node = wapp_dbl_list_remove(Str8, &list, 0); - result = result && node == &s5 && wapp_str8_equal(node, &s5) && wapp_str8_list_total_size(&list) == 0 && list.node_count == 0; + node = wpDblListRemove(WpStr8, &list, 0); + result = result && node == &s5 && wpStr8Equal(node, &s5) && wpStr8ListTotalSize(&list) == 0 && list.node_count == 0; - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_str8_list_empty(void) { +WpTestFuncResult test_str8_list_empty(void) { b8 result; - Str8List list = wapp_dbl_list(Str8); - wapp_dbl_list_push_back(Str8, &list, &wapp_str8_lit("Hello")); - wapp_dbl_list_push_back(Str8, &list, &wapp_str8_lit("from")); - wapp_dbl_list_push_back(Str8, &list, &wapp_str8_lit("wizapp")); - wapp_dbl_list_push_back(Str8, &list, &wapp_str8_lit("stdlib")); + WpStr8List list = wpDblList(WpStr8); + wpDblListPushBack(WpStr8, &list, &wpStr8Lit("Hello")); + wpDblListPushBack(WpStr8, &list, &wpStr8Lit("from")); + wpDblListPushBack(WpStr8, &list, &wpStr8Lit("wizapp")); + wpDblListPushBack(WpStr8, &list, &wpStr8Lit("stdlib")); - wapp_dbl_list_empty(Str8, &list); + wpDblListEmpty(WpStr8, &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 && wpStr8ListTotalSize(&list) == 0; - return wapp_tester_result(result); + return wpTesterResult(result); } diff --git a/tests/str8/test_str8_list.cc b/tests/str8/test_str8_list.cc index 48d233e..6a5aee3 100644 --- a/tests/str8/test_str8_list.cc +++ b/tests/str8/test_str8_list.cc @@ -1,238 +1,238 @@ #include "test_str8_list.h" #include "wapp.h" -TestFuncResult test_str8_list_get(void) { +WpTestFuncResult test_str8_list_get(void) { 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"); + WpStr8 s1 = wpStr8Lit("1"); + WpStr8 s2 = wpStr8Lit("2"); + WpStr8 s3 = wpStr8Lit("3"); + WpStr8 s4 = wpStr8Lit("4"); + WpStr8 s5 = wpStr8Lit("5"); - Str8List list = wapp_dbl_list(Str8); + WpStr8List list = wpDblList(WpStr8); - wapp_dbl_list_push_back(Str8, &list, &s1); - wapp_dbl_list_push_back(Str8, &list, &s2); - wapp_dbl_list_push_back(Str8, &list, &s3); - wapp_dbl_list_push_back(Str8, &list, &s4); - wapp_dbl_list_push_back(Str8, &list, &s5); + wpDblListPushBack(WpStr8, &list, &s1); + wpDblListPushBack(WpStr8, &list, &s2); + wpDblListPushBack(WpStr8, &list, &s3); + wpDblListPushBack(WpStr8, &list, &s4); + wpDblListPushBack(WpStr8, &list, &s5); - Str8 *node = wapp_dbl_list_get(Str8, &list, 0); - result = node == &s1 && wapp_str8_equal(node, &s1); + WpStr8 *node = wpDblListGet(WpStr8, &list, 0); + result = node == &s1 && wpStr8Equal(node, &s1); - node = wapp_dbl_list_get(Str8, &list, 1); - result = result && node == &s2 && wapp_str8_equal(node, &s2); + node = wpDblListGet(WpStr8, &list, 1); + result = result && node == &s2 && wpStr8Equal(node, &s2); - node = wapp_dbl_list_get(Str8, &list, 2); - result = result && node == &s3 && wapp_str8_equal(node, &s3); + node = wpDblListGet(WpStr8, &list, 2); + result = result && node == &s3 && wpStr8Equal(node, &s3); - node = wapp_dbl_list_get(Str8, &list, 3); - result = result && node == &s4 && wapp_str8_equal(node, &s4); + node = wpDblListGet(WpStr8, &list, 3); + result = result && node == &s4 && wpStr8Equal(node, &s4); - node = wapp_dbl_list_get(Str8, &list, 4); - result = result && node == &s5 && wapp_str8_equal(node, &s5); + node = wpDblListGet(WpStr8, &list, 4); + result = result && node == &s5 && wpStr8Equal(node, &s5); - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_str8_list_push_front(void) { +WpTestFuncResult test_str8_list_push_front(void) { b8 result; - Str8 s1 = wapp_str8_lit("1"); - Str8 s2 = wapp_str8_lit("2"); - Str8 s3 = wapp_str8_lit("3"); + WpStr8 s1 = wpStr8Lit("1"); + WpStr8 s2 = wpStr8Lit("2"); + WpStr8 s3 = wpStr8Lit("3"); - Str8List list = wapp_dbl_list(Str8); + WpStr8List list = wpDblList(WpStr8); - wapp_dbl_list_push_front(Str8, &list, &s1); - result = list.first == list.last && list.first->item == &s1 && wapp_str8_list_total_size(&list) == 1 && list.node_count == 1; + wpDblListPushFront(WpStr8, &list, &s1); + result = list.first == list.last && list.first->item == &s1 && wpStr8ListTotalSize(&list) == 1 && list.node_count == 1; - wapp_dbl_list_push_front(Str8, &list, &s2); - result = result && list.first->item == &s2 && wapp_str8_list_total_size(&list) == 2 && list.node_count == 2; + wpDblListPushFront(WpStr8, &list, &s2); + result = result && list.first->item == &s2 && wpStr8ListTotalSize(&list) == 2 && list.node_count == 2; - wapp_dbl_list_push_front(Str8, &list, &s3); - result = result && list.first->item == &s3 && wapp_str8_list_total_size(&list) == 3 && list.node_count == 3; + wpDblListPushFront(WpStr8, &list, &s3); + result = result && list.first->item == &s3 && wpStr8ListTotalSize(&list) == 3 && list.node_count == 3; - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_str8_list_push_back(void) { +WpTestFuncResult test_str8_list_push_back(void) { b8 result; - Str8 s1 = wapp_str8_lit("1"); - Str8 s2 = wapp_str8_lit("2"); - Str8 s3 = wapp_str8_lit("3"); + WpStr8 s1 = wpStr8Lit("1"); + WpStr8 s2 = wpStr8Lit("2"); + WpStr8 s3 = wpStr8Lit("3"); - Str8List list = wapp_dbl_list(Str8); + WpStr8List list = wpDblList(WpStr8); - wapp_dbl_list_push_back(Str8, &list, &s1); - result = list.first == list.last && list.last->item == &s1 && wapp_str8_list_total_size(&list) == 1 && list.node_count == 1; + wpDblListPushBack(WpStr8, &list, &s1); + result = list.first == list.last && list.last->item == &s1 && wpStr8ListTotalSize(&list) == 1 && list.node_count == 1; - wapp_dbl_list_push_back(Str8, &list, &s2); - result = result && list.last->item == &s2 && wapp_str8_list_total_size(&list) == 2 && list.node_count == 2; + wpDblListPushBack(WpStr8, &list, &s2); + result = result && list.last->item == &s2 && wpStr8ListTotalSize(&list) == 2 && list.node_count == 2; - wapp_dbl_list_push_back(Str8, &list, &s3); - result = result && list.last->item == &s3 && wapp_str8_list_total_size(&list) == 3 && list.node_count == 3; + wpDblListPushBack(WpStr8, &list, &s3); + result = result && list.last->item == &s3 && wpStr8ListTotalSize(&list) == 3 && list.node_count == 3; - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_str8_list_insert(void) { +WpTestFuncResult test_str8_list_insert(void) { 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"); + WpStr8 s1 = wpStr8Lit("1"); + WpStr8 s2 = wpStr8Lit("2"); + WpStr8 s3 = wpStr8Lit("3"); + WpStr8 s4 = wpStr8Lit("4"); + WpStr8 s5 = wpStr8Lit("5"); + WpStr8 s6 = wpStr8Lit("6"); + WpStr8 s7 = wpStr8Lit("7"); - Str8List list = wapp_dbl_list(Str8); + WpStr8List list = wpDblList(WpStr8); - wapp_dbl_list_push_back(Str8, &list, &s1); - wapp_dbl_list_push_back(Str8, &list, &s2); - wapp_dbl_list_push_back(Str8, &list, &s3); - wapp_dbl_list_push_back(Str8, &list, &s4); - wapp_dbl_list_push_back(Str8, &list, &s5); + wpDblListPushBack(WpStr8, &list, &s1); + wpDblListPushBack(WpStr8, &list, &s2); + wpDblListPushBack(WpStr8, &list, &s3); + wpDblListPushBack(WpStr8, &list, &s4); + wpDblListPushBack(WpStr8, &list, &s5); - Str8 *node; - wapp_dbl_list_insert(Str8, &list, &s6, 2); - node = wapp_dbl_list_get(Str8, &list, 2); - result = node != NULL && node == &s6 && wapp_str8_list_total_size(&list) == 6 && list.node_count == 6; - wapp_dbl_list_insert(Str8, &list, &s7, 5); - node = wapp_dbl_list_get(Str8, &list, 5); - result = result && node != NULL && node == &s7 && wapp_str8_list_total_size(&list) == 7 && list.node_count == 7; + WpStr8 *node; + wpDblListInsert(WpStr8, &list, &s6, 2); + node = wpDblListGet(WpStr8, &list, 2); + result = node != NULL && node == &s6 && wpStr8ListTotalSize(&list) == 6 && list.node_count == 6; + wpDblListInsert(WpStr8, &list, &s7, 5); + node = wpDblListGet(WpStr8, &list, 5); + result = result && node != NULL && node == &s7 && wpStr8ListTotalSize(&list) == 7 && list.node_count == 7; - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_str8_list_pop_front(void) { +WpTestFuncResult test_str8_list_pop_front(void) { 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"); + WpStr8 s1 = wpStr8Lit("1"); + WpStr8 s2 = wpStr8Lit("2"); + WpStr8 s3 = wpStr8Lit("3"); + WpStr8 s4 = wpStr8Lit("4"); + WpStr8 s5 = wpStr8Lit("5"); - Str8List list = wapp_dbl_list(Str8); + WpStr8List list = wpDblList(WpStr8); - wapp_dbl_list_push_back(Str8, &list, &s1); - wapp_dbl_list_push_back(Str8, &list, &s2); - wapp_dbl_list_push_back(Str8, &list, &s3); - wapp_dbl_list_push_back(Str8, &list, &s4); - wapp_dbl_list_push_back(Str8, &list, &s5); + wpDblListPushBack(WpStr8, &list, &s1); + wpDblListPushBack(WpStr8, &list, &s2); + wpDblListPushBack(WpStr8, &list, &s3); + wpDblListPushBack(WpStr8, &list, &s4); + wpDblListPushBack(WpStr8, &list, &s5); - Str8 *node = wapp_dbl_list_pop_front(Str8, &list); - result = node == &s1 && wapp_str8_equal(node, &s1) && wapp_str8_list_total_size(&list) == 4 && list.node_count == 4; + WpStr8 *node = wpDblListPopFront(WpStr8, &list); + result = node == &s1 && wpStr8Equal(node, &s1) && wpStr8ListTotalSize(&list) == 4 && list.node_count == 4; - node = wapp_dbl_list_pop_front(Str8, &list); - result = result && node == &s2 && wapp_str8_equal(node, &s2) && wapp_str8_list_total_size(&list) == 3 && list.node_count == 3; + node = wpDblListPopFront(WpStr8, &list); + result = result && node == &s2 && wpStr8Equal(node, &s2) && wpStr8ListTotalSize(&list) == 3 && list.node_count == 3; - node = wapp_dbl_list_pop_front(Str8, &list); - result = result && node == &s3 && wapp_str8_equal(node, &s3) && wapp_str8_list_total_size(&list) == 2 && list.node_count == 2; + node = wpDblListPopFront(WpStr8, &list); + result = result && node == &s3 && wpStr8Equal(node, &s3) && wpStr8ListTotalSize(&list) == 2 && list.node_count == 2; - node = wapp_dbl_list_pop_front(Str8, &list); - result = result && node == &s4 && wapp_str8_equal(node, &s4) && wapp_str8_list_total_size(&list) == 1 && list.node_count == 1; + node = wpDblListPopFront(WpStr8, &list); + result = result && node == &s4 && wpStr8Equal(node, &s4) && wpStr8ListTotalSize(&list) == 1 && list.node_count == 1; - node = wapp_dbl_list_pop_front(Str8, &list); - result = result && node == &s5 && wapp_str8_equal(node, &s5) && wapp_str8_list_total_size(&list) == 0 && list.node_count == 0; + node = wpDblListPopFront(WpStr8, &list); + result = result && node == &s5 && wpStr8Equal(node, &s5) && wpStr8ListTotalSize(&list) == 0 && list.node_count == 0; - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_str8_list_pop_back(void) { +WpTestFuncResult test_str8_list_pop_back(void) { 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"); + WpStr8 s1 = wpStr8Lit("1"); + WpStr8 s2 = wpStr8Lit("2"); + WpStr8 s3 = wpStr8Lit("3"); + WpStr8 s4 = wpStr8Lit("4"); + WpStr8 s5 = wpStr8Lit("5"); - Str8List list = wapp_dbl_list(Str8); + WpStr8List list = wpDblList(WpStr8); - wapp_dbl_list_push_front(Str8, &list, &s1); - wapp_dbl_list_push_front(Str8, &list, &s2); - wapp_dbl_list_push_front(Str8, &list, &s3); - wapp_dbl_list_push_front(Str8, &list, &s4); - wapp_dbl_list_push_front(Str8, &list, &s5); + wpDblListPushFront(WpStr8, &list, &s1); + wpDblListPushFront(WpStr8, &list, &s2); + wpDblListPushFront(WpStr8, &list, &s3); + wpDblListPushFront(WpStr8, &list, &s4); + wpDblListPushFront(WpStr8, &list, &s5); - Str8 *node = wapp_dbl_list_pop_back(Str8, &list); - result = node == &s1 && wapp_str8_equal(node, &s1) && wapp_str8_list_total_size(&list) == 4 && list.node_count == 4; + WpStr8 *node = wpDblListPopBack(WpStr8, &list); + result = node == &s1 && wpStr8Equal(node, &s1) && wpStr8ListTotalSize(&list) == 4 && list.node_count == 4; - node = wapp_dbl_list_pop_back(Str8, &list); - result = result && node == &s2 && wapp_str8_equal(node, &s2) && wapp_str8_list_total_size(&list) == 3 && list.node_count == 3; + node = wpDblListPopBack(WpStr8, &list); + result = result && node == &s2 && wpStr8Equal(node, &s2) && wpStr8ListTotalSize(&list) == 3 && list.node_count == 3; - node = wapp_dbl_list_pop_back(Str8, &list); - result = result && node == &s3 && wapp_str8_equal(node, &s3) && wapp_str8_list_total_size(&list) == 2 && list.node_count == 2; + node = wpDblListPopBack(WpStr8, &list); + result = result && node == &s3 && wpStr8Equal(node, &s3) && wpStr8ListTotalSize(&list) == 2 && list.node_count == 2; - node = wapp_dbl_list_pop_back(Str8, &list); - result = result && node == &s4 && wapp_str8_equal(node, &s4) && wapp_str8_list_total_size(&list) == 1 && list.node_count == 1; + node = wpDblListPopBack(WpStr8, &list); + result = result && node == &s4 && wpStr8Equal(node, &s4) && wpStr8ListTotalSize(&list) == 1 && list.node_count == 1; - node = wapp_dbl_list_pop_back(Str8, &list); - result = result && node == &s5 && wapp_str8_equal(node, &s5) && wapp_str8_list_total_size(&list) == 0 && list.node_count == 0; + node = wpDblListPopBack(WpStr8, &list); + result = result && node == &s5 && wpStr8Equal(node, &s5) && wpStr8ListTotalSize(&list) == 0 && list.node_count == 0; - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_str8_list_remove(void) { +WpTestFuncResult test_str8_list_remove(void) { 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"); + WpStr8 s1 = wpStr8Lit("1"); + WpStr8 s2 = wpStr8Lit("2"); + WpStr8 s3 = wpStr8Lit("3"); + WpStr8 s4 = wpStr8Lit("4"); + WpStr8 s5 = wpStr8Lit("5"); - Str8List list = wapp_dbl_list(Str8); + WpStr8List list = wpDblList(WpStr8); - wapp_dbl_list_push_back(Str8, &list, &s1); - wapp_dbl_list_push_back(Str8, &list, &s2); - wapp_dbl_list_push_back(Str8, &list, &s3); - wapp_dbl_list_push_back(Str8, &list, &s4); - wapp_dbl_list_push_back(Str8, &list, &s5); + wpDblListPushBack(WpStr8, &list, &s1); + wpDblListPushBack(WpStr8, &list, &s2); + wpDblListPushBack(WpStr8, &list, &s3); + wpDblListPushBack(WpStr8, &list, &s4); + wpDblListPushBack(WpStr8, &list, &s5); - Str8 *node = wapp_dbl_list_remove(Str8, &list, 0); - result = node == &s1 && wapp_str8_equal(node, &s1) && wapp_str8_list_total_size(&list) == 4 && list.node_count == 4; + WpStr8 *node = wpDblListRemove(WpStr8, &list, 0); + result = node == &s1 && wpStr8Equal(node, &s1) && wpStr8ListTotalSize(&list) == 4 && list.node_count == 4; - node = wapp_dbl_list_remove(Str8, &list, 0); - result = result && node == &s2 && wapp_str8_equal(node, &s2) && wapp_str8_list_total_size(&list) == 3 && list.node_count == 3; + node = wpDblListRemove(WpStr8, &list, 0); + result = result && node == &s2 && wpStr8Equal(node, &s2) && wpStr8ListTotalSize(&list) == 3 && list.node_count == 3; - node = wapp_dbl_list_remove(Str8, &list, 0); - result = result && node == &s3 && wapp_str8_equal(node, &s3) && wapp_str8_list_total_size(&list) == 2 && list.node_count == 2; + node = wpDblListRemove(WpStr8, &list, 0); + result = result && node == &s3 && wpStr8Equal(node, &s3) && wpStr8ListTotalSize(&list) == 2 && list.node_count == 2; - node = wapp_dbl_list_remove(Str8, &list, 0); - result = result && node == &s4 && wapp_str8_equal(node, &s4) && wapp_str8_list_total_size(&list) == 1 && list.node_count == 1; + node = wpDblListRemove(WpStr8, &list, 0); + result = result && node == &s4 && wpStr8Equal(node, &s4) && wpStr8ListTotalSize(&list) == 1 && list.node_count == 1; - node = wapp_dbl_list_remove(Str8, &list, 0); - result = result && node == &s5 && wapp_str8_equal(node, &s5) && wapp_str8_list_total_size(&list) == 0 && list.node_count == 0; + node = wpDblListRemove(WpStr8, &list, 0); + result = result && node == &s5 && wpStr8Equal(node, &s5) && wpStr8ListTotalSize(&list) == 0 && list.node_count == 0; - return wapp_tester_result(result); + return wpTesterResult(result); } -TestFuncResult test_str8_list_empty(void) { +WpTestFuncResult test_str8_list_empty(void) { b8 result; - Str8List list = wapp_dbl_list(Str8); + WpStr8List list = wpDblList(WpStr8); - Str8 hello = wapp_str8_lit("Hello"); - wapp_dbl_list_push_back(Str8, &list, &hello); + WpStr8 hello = wpStr8Lit("Hello"); + wpDblListPushBack(WpStr8, &list, &hello); - Str8 from = wapp_str8_lit("from"); - wapp_dbl_list_push_back(Str8, &list, &from); + WpStr8 from = wpStr8Lit("from"); + wpDblListPushBack(WpStr8, &list, &from); - Str8 wizapp = wapp_str8_lit("wizapp"); - wapp_dbl_list_push_back(Str8, &list, &wizapp); + WpStr8 wizapp = wpStr8Lit("wizapp"); + wpDblListPushBack(WpStr8, &list, &wizapp); - Str8 stdlib = wapp_str8_lit("stdlib"); - wapp_dbl_list_push_back(Str8, &list, &stdlib); + WpStr8 stdlib = wpStr8Lit("stdlib"); + wpDblListPushBack(WpStr8, &list, &stdlib); - wapp_dbl_list_empty(Str8, &list); + wpDblListEmpty(WpStr8, &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 && wpStr8ListTotalSize(&list) == 0; - return wapp_tester_result(result); + return wpTesterResult(result); } diff --git a/tests/str8/test_str8_list.h b/tests/str8/test_str8_list.h index 963227e..0a5e2ec 100644 --- a/tests/str8/test_str8_list.h +++ b/tests/str8/test_str8_list.h @@ -3,13 +3,13 @@ #include "wapp.h" -TestFuncResult test_str8_list_get(void); -TestFuncResult test_str8_list_push_front(void); -TestFuncResult test_str8_list_push_back(void); -TestFuncResult test_str8_list_insert(void); -TestFuncResult test_str8_list_pop_front(void); -TestFuncResult test_str8_list_pop_back(void); -TestFuncResult test_str8_list_remove(void); -TestFuncResult test_str8_list_empty(void); +WpTestFuncResult test_str8_list_get(void); +WpTestFuncResult test_str8_list_push_front(void); +WpTestFuncResult test_str8_list_push_back(void); +WpTestFuncResult test_str8_list_insert(void); +WpTestFuncResult test_str8_list_pop_front(void); +WpTestFuncResult test_str8_list_pop_back(void); +WpTestFuncResult test_str8_list_remove(void); +WpTestFuncResult test_str8_list_empty(void); #endif // !TEST_STR8_LIST_H diff --git a/tests/wapptest.c b/tests/wapptest.c index 0846b98..d355bf1 100644 --- a/tests/wapptest.c +++ b/tests/wapptest.c @@ -12,7 +12,7 @@ #include int main(void) { - wapp_tester_run_tests( + wpTesterRun( test_arena_allocator, test_arena_allocator_with_buffer, test_arena_allocator_temp_begin, diff --git a/tests/wapptest.cc b/tests/wapptest.cc index 0846b98..d355bf1 100644 --- a/tests/wapptest.cc +++ b/tests/wapptest.cc @@ -12,7 +12,7 @@ #include int main(void) { - wapp_tester_run_tests( + wpTesterRun( test_arena_allocator, test_arena_allocator_with_buffer, test_arena_allocator_temp_begin,