From e98c877231bc1110267e99ea382d342714d32af8 Mon Sep 17 00:00:00 2001 From: Abdelrahman Date: Fri, 2 Jan 2026 15:38:25 +0000 Subject: [PATCH] Get rid of array structs --- src/base/array/array.c | 169 +++++++++++++------- src/base/array/array.h | 284 ++++++++++++++++++--------------- src/base/strings/str8/str8.c | 6 +- src/base/strings/str8/str8.h | 2 +- src/os/file/file.c | 20 +-- src/os/file/file.h | 4 +- tests/array/test_i32_array.c | 138 ++++++++-------- tests/array/test_i32_array.cc | 138 ++++++++-------- tests/array/test_str8_array.c | 8 +- tests/array/test_str8_array.cc | 8 +- tests/str8/test_str8.c | 6 +- tests/str8/test_str8.cc | 6 +- 12 files changed, 438 insertions(+), 351 deletions(-) diff --git a/src/base/array/array.c b/src/base/array/array.c index b7b3372..1b892d0 100644 --- a/src/base/array/array.c +++ b/src/base/array/array.c @@ -8,65 +8,113 @@ #include #define _offset_pointer(PTR, OFFSET) ((void *)((uptr)(PTR) + (OFFSET))) +#define _array_header(ARRAY) (ArrayHeader *)(_offset_pointer(ARRAY, -sizeof(ArrayHeader))) -wapp_persist inline void _array_validate(const GenericArray *array, u64 item_size); +wapp_persist inline void _array_validate(const GenericArray array, u64 item_size); -void *_array_get(GenericArray *array, u64 index, u64 item_size) { - wapp_runtime_assert(array != NULL, "`array` should not be NULL"); - _array_validate(array, item_size); - wapp_runtime_assert(index < array->count, "`index` is out of bounds"); +u64 _array_count(GenericArray array) { + wapp_debug_assert(array != NULL, "`array` should not be NULL"); - return _offset_pointer(array->items, array->item_size * index); + ArrayHeader *header = _array_header(array); + wapp_runtime_assert(WAPP_ARRAY_MAGIC == header->magic, "`array` is not a valid wapp array"); + + return header->count; } -void _array_set(GenericArray *array, u64 index, void *value, u64 item_size) { +u64 _array_capacity(GenericArray array) { + wapp_debug_assert(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"); + + return header->capacity; +} + +u64 _array_item_size(GenericArray array) { + wapp_debug_assert(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"); + + return header->item_size; +} + +void _array_set_count(GenericArray array, u64 count) { + wapp_debug_assert(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"); + + header->count = count; +} + +void *_array_get(GenericArray array, u64 index, u64 item_size) { + wapp_runtime_assert(array != NULL, "`array` should not be NULL"); + _array_validate(array, item_size); + + ArrayHeader *header = _array_header(array); + wapp_runtime_assert(index < header->count, "`index` is out of bounds"); + + return _offset_pointer(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); - memcpy(item, value, array->item_size); + + ArrayHeader *header = _array_header(array); + memcpy(item, value, header->item_size); } -void _array_append_capped(GenericArray *array, void *value, u64 item_size) { +void _array_append_capped(GenericArray array, void *value, u64 item_size) { wapp_runtime_assert(array != NULL, "`array` should not be NULL"); _array_validate(array, item_size); - if (array->count >= array->capacity) { return; } + ArrayHeader *header = _array_header(array); + if (header->count >= header->capacity) { return; } - u64 index = (array->count)++; + u64 index = (header->count)++; _array_set(array, index, value, item_size); } -void _array_extend_capped(GenericArray *dst, const GenericArray *src, u64 item_size) { +void _array_extend_capped(GenericArray dst, const GenericArray src, u64 item_size) { wapp_runtime_assert(dst != NULL && src != NULL, "`dst` and `src` should not be NULL"); _array_validate(dst, item_size); _array_validate(src, item_size); - u64 remaining_capacity = dst->capacity - dst->count; + ArrayHeader *src_header = _array_header(src); + ArrayHeader *dst_header = _array_header(dst); + u64 remaining_capacity = dst_header->capacity - dst_header->count; - u64 copy_count = src->count < remaining_capacity ? src->count : remaining_capacity; - void *dst_ptr = _offset_pointer(dst->items, dst->count * dst->item_size); - memcpy(dst_ptr, src->items, copy_count * src->item_size); - dst->count += copy_count; + u64 copy_count = src_header->count < remaining_capacity ? src_header->count : remaining_capacity; + void *dst_ptr = _offset_pointer(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) { +void _array_copy_capped(GenericArray dst, const GenericArray src, u64 item_size) { wapp_runtime_assert(dst != NULL && src != NULL, "`dst` and `src` should not be NULL"); _array_validate(dst, item_size); _array_validate(src, item_size); _array_clear(dst, item_size); - u64 copy_count = src->count < dst->capacity ? src->count : dst->capacity; - memcpy(dst->items, src->items, copy_count * src->item_size); - dst->count = copy_count; + + ArrayHeader *src_header = _array_header(src); + ArrayHeader *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, u64 item_size) { +GenericArray _array_append_alloc(const Allocator *allocator, GenericArray array, void *value, u64 item_size) { wapp_runtime_assert(allocator != NULL && array != NULL, "`allocator` and `array` should not be NULL"); _array_validate(array, item_size); - GenericArray *output = array; + GenericArray output = array; - if (array->count >= array->capacity) { - u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(array->capacity * 2); - output = (GenericArray *)_array_alloc_capacity(allocator, new_capacity, array->item_size, false); + ArrayHeader *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, header->item_size, false); if (!output) { output = array; goto RETURN_ARRAY_APPEND_ALLOC; @@ -80,17 +128,19 @@ RETURN_ARRAY_APPEND_ALLOC: return output; } -GenericArray *_array_extend_alloc(const Allocator *allocator, GenericArray *dst, const GenericArray *src, u64 item_size) { +GenericArray _array_extend_alloc(const Allocator *allocator, GenericArray dst, const GenericArray src, u64 item_size) { wapp_runtime_assert(allocator != NULL && dst != NULL && src != NULL, "`allocator`, `dst` and `src` should not be NULL"); _array_validate(dst, item_size); _array_validate(src, item_size); - GenericArray *output = dst; + GenericArray output = dst; - u64 remaining_capacity = dst->capacity - dst->count; - if (src->count >= remaining_capacity) { - u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(dst->capacity * 2); - output = (GenericArray *)_array_alloc_capacity(allocator, new_capacity, dst->item_size, false); + ArrayHeader *src_header = _array_header(src); + ArrayHeader *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, dst_header->item_size, false); if (!output) { output = dst; goto RETURN_ARRAY_EXTEND_ALLOC; @@ -104,16 +154,19 @@ RETURN_ARRAY_EXTEND_ALLOC: return output; } -GenericArray *_array_copy_alloc(const Allocator *allocator, GenericArray *dst, const GenericArray *src, u64 item_size) { +GenericArray _array_copy_alloc(const Allocator *allocator, GenericArray dst, const GenericArray src, u64 item_size) { wapp_runtime_assert(allocator != NULL && dst != NULL && src != NULL, "`allocator`, `dst` and `src` should not be NULL"); _array_validate(dst, item_size); _array_validate(src, item_size); - GenericArray *output = dst; + GenericArray output = dst; - if (src->count >= dst->capacity) { - u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(dst->capacity * 2); - output = (GenericArray *)_array_alloc_capacity(allocator, new_capacity, src->item_size, false); + ArrayHeader *src_header = _array_header(src); + ArrayHeader *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, + src_header->item_size, false); if (!output) { output = dst; goto RETURN_ARRAY_COPY_ALLOC; @@ -126,48 +179,50 @@ RETURN_ARRAY_COPY_ALLOC: return output; } -void *_array_pop(GenericArray *array, u64 item_size) { +void *_array_pop(GenericArray array, u64 item_size) { wapp_runtime_assert(array != NULL, "`array` should not be NULL"); _array_validate(array, item_size); - if (array->count == 0) { return NULL; } + ArrayHeader *header = _array_header(array); + if (header->count == 0) { return NULL; } - u64 index = array->count - 1; + u64 index = header->count - 1; void *out = _array_get(array, index, item_size); - --(array->count); + --(header->count); return out; } -void _array_clear(GenericArray *array, u64 item_size) { +void _array_clear(GenericArray array, u64 item_size) { wapp_runtime_assert(array != NULL, "`array` should not be NULL"); _array_validate(array, item_size); - array->count = 0; + ArrayHeader *header = _array_header(array); + header->count = 0; } -GenericArray *_array_alloc_capacity(const Allocator *allocator, u64 capacity, u64 item_size, b8 fill) { +GenericArray _array_alloc_capacity(const Allocator *allocator, u64 capacity, u64 item_size, b8 fill) { wapp_runtime_assert(allocator != NULL, "`allocator` should not be NULL"); - GenericArray *output = NULL; + GenericArray output = NULL; - u64 allocation_size = sizeof(GenericArray) + item_size * capacity; - - output = wapp_mem_allocator_alloc(allocator, allocation_size); - if (!output) { + u64 allocation_size = sizeof(ArrayHeader) + item_size * capacity; + ArrayHeader *header = wapp_mem_allocator_alloc(allocator, allocation_size); + if (!header) { goto RETURN_ARRAY_ALLOC; } - output->magic = WAPP_ARRAY_MAGIC; - output->count = fill ? capacity : 0; - output->capacity = capacity; - output->item_size = item_size; - output->items = (void *)(output + 1); + output = (u8 *)(header + 1); + header->magic = WAPP_ARRAY_MAGIC; + header->count = fill ? capacity : 0; + header->capacity = capacity; + header->item_size = item_size; RETURN_ARRAY_ALLOC: return output; } -wapp_persist inline void _array_validate(const GenericArray *array, u64 item_size) { - wapp_runtime_assert(WAPP_ARRAY_MAGIC == array->magic, "`array` is not a valid wapp array"); - wapp_runtime_assert(item_size == array->item_size, "Invalid item type provided"); +wapp_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"); } diff --git a/src/base/array/array.h b/src/base/array/array.h index d2049b3..31bafea 100644 --- a/src/base/array/array.h +++ b/src/base/array/array.h @@ -17,144 +17,176 @@ BEGIN_C_LINKAGE #define _calc_array_count(TYPE, ...) wapp_misc_utils_va_args_count(TYPE, __VA_ARGS__) #define _calc_array_capacity(TYPE, ...) wapp_misc_utils_u64_round_up_pow2(_calc_array_count(TYPE, __VA_ARGS__) * 2) -#define wapp_array_alloc_capacity(ELEM_TYPE, ARRAY_TYPE, ALLOCATOR_PTR, CAPACITY, FILL) \ - ((ARRAY_TYPE *)_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY, sizeof(ELEM_TYPE), FILL)) +#define wapp_array_alloc_capacity(TYPE, ALLOCATOR_PTR, CAPACITY, FILL) \ + ((TYPE *)_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY, sizeof(TYPE), FILL)) -#define WAPP_DEF_ARRAY_TYPE(T, NAME) \ - typedef struct { \ - u64 magic; \ - u64 count; \ - u64 capacity; \ - u64 item_size; \ - T *items; \ - } NAME +typedef struct Str8 Str8; + +// 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; #ifdef WAPP_PLATFORM_CPP -#define wapp_array(ELEM_TYPE, ARRAY_TYPE, ...) ([&]() { \ - wapp_persist ELEM_TYPE items[sizeof(ELEM_TYPE) == sizeof(*((ARRAY_TYPE{}).items)) ? \ - _calc_array_capacity(ELEM_TYPE, __VA_ARGS__) : -1 \ - ] = {__VA_ARGS__}; \ - \ - return ARRAY_TYPE{ \ - WAPP_ARRAY_MAGIC, \ - _calc_array_count(ELEM_TYPE, __VA_ARGS__), \ - _calc_array_capacity(ELEM_TYPE, __VA_ARGS__), \ - sizeof(ELEM_TYPE), \ - items, \ - }; \ +#define wapp_array(TYPE, ...) ([&]() { \ + u64 capacity = _calc_array_capacity(TYPE, __VA_ARGS__); \ + \ + TYPE items[_calc_array_capacity(TYPE, __VA_ARGS__)] = {__VA_ARGS__}; \ + \ + wapp_persist u8 array[ \ + sizeof(ArrayHeader) + _calc_array_capacity(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__); \ + header->item_size = sizeof(TYPE); \ + \ + u8 *buf = (u8 *)(header + 1); \ + memcpy(buf, items, capacity * sizeof(TYPE)); \ + return (TYPE *)buf; \ }()) -#define wapp_array_with_capacity(ELEM_TYPE, ARRAY_TYPE, CAPACITY, FILL) ([&]() { \ - wapp_persist ELEM_TYPE items[sizeof(ELEM_TYPE) == sizeof(*((ARRAY_TYPE{}).items)) ? \ - CAPACITY : -1] = {}; \ - \ - return ARRAY_TYPE{ \ - WAPP_ARRAY_MAGIC, \ - FILL ? CAPACITY : 0, \ - CAPACITY, \ - sizeof(ELEM_TYPE), \ - items, \ - }; \ +#define wapp_array_with_capacity(TYPE, CAPACITY, FILL) ([&]() { \ + wapp_persist u8 array[ \ + sizeof(ArrayHeader) + CAPACITY * sizeof(TYPE) \ + ] = {0}; \ + ArrayHeader *header = (ArrayHeader *)array; \ + header->magic = WAPP_ARRAY_MAGIC; \ + header->count = FILL ? CAPACITY : 0; \ + header->capacity = CAPACITY; \ + header->item_size = sizeof(TYPE); \ + \ + return (TYPE *)(header + 1); \ }()) -#define wapp_array_pop(ELEM_TYPE, ARRAY_PTR) ([&]() { \ - if (ARRAY_PTR == NULL || (ARRAY_PTR)->count == 0) { \ - ELEM_TYPE result{}; \ - return result; \ - } \ - \ - return *((ELEM_TYPE *)_array_pop((GenericArray *)ARRAY_PTR, sizeof(ELEM_TYPE))); \ +#define wapp_array_pop(TYPE, ARRAY) ([&]() { \ + if (ARRAY == NULL || _array_count((GenericArray)ARRAY) == 0) { \ + TYPE result{}; \ + return result; \ + } \ + \ + return *((TYPE *)_array_pop((GenericArray)ARRAY, sizeof(TYPE))); \ }()) #else -#define wapp_array(ELEM_TYPE, ARRAY_TYPE, ...) \ - ((ARRAY_TYPE){ \ - .magic = WAPP_ARRAY_MAGIC, \ - .count = _calc_array_count(ELEM_TYPE, __VA_ARGS__), \ - .capacity = _calc_array_capacity(ELEM_TYPE, __VA_ARGS__), \ - .item_size = sizeof(ELEM_TYPE), \ - .items = (ELEM_TYPE[sizeof(ELEM_TYPE) == sizeof(*((ARRAY_TYPE){0}.items)) ? \ - _calc_array_capacity(ELEM_TYPE, __VA_ARGS__) : \ - -1]){__VA_ARGS__} \ - }) -#define wapp_array_with_capacity(ELEM_TYPE, ARRAY_TYPE, CAPACITY, FILL) \ - ((ARRAY_TYPE){ \ - .magic = WAPP_ARRAY_MAGIC, \ - .count = FILL ? CAPACITY : 0, \ - .capacity = CAPACITY, \ - .item_size = sizeof(ELEM_TYPE), \ - .items = (ELEM_TYPE[sizeof(ELEM_TYPE) == sizeof(*((ARRAY_TYPE){0}.items)) ? \ - CAPACITY : -1]){0} \ - }) -#define wapp_array_pop(ELEM_TYPE, ARRAY_PTR) \ - (ARRAY_PTR != NULL && (ARRAY_PTR)->count > 0 ? \ - *((ELEM_TYPE *)_array_pop((GenericArray *)ARRAY_PTR, sizeof(ELEM_TYPE))) : \ - (ELEM_TYPE){0} \ +#define _stack_array(TYPE, SIZE) struct { ArrayHeader header; TYPE items[SIZE]; } +#define wapp_array(TYPE, ...) \ + (TYPE *)( \ + (_stack_array(TYPE, _calc_array_capacity(TYPE, __VA_ARGS__))){ \ + .header = { \ + .magic = WAPP_ARRAY_MAGIC, \ + .count = _calc_array_count(TYPE, __VA_ARGS__), \ + .capacity = _calc_array_capacity(TYPE, __VA_ARGS__), \ + .item_size = sizeof(TYPE), \ + }, \ + .items = {__VA_ARGS__}, \ + }.items \ + ) +#define wapp_array_with_capacity(TYPE, CAPACITY, FILL) \ + (TYPE *)( \ + (_stack_array(TYPE, CAPACITY)){ \ + .header = { \ + .magic = WAPP_ARRAY_MAGIC, \ + .count = FILL ? CAPACITY : 0, \ + .capacity = CAPACITY, \ + .item_size = sizeof(TYPE), \ + }, \ + .items = {0}, \ + }.items \ + ) +#define wapp_array_pop(TYPE, ARRAY) \ + (ARRAY != NULL && _array_count((GenericArray)ARRAY) > 0 ? \ + *((TYPE *)_array_pop((GenericArray)ARRAY, sizeof(TYPE))) : \ + (TYPE){0} \ ) #endif // !WAPP_PLATFORM_CPP -#define wapp_array_get(ELEM_TYPE, ARRAY_PTR, INDEX) \ - ((ELEM_TYPE *)_array_get((GenericArray *)ARRAY_PTR, INDEX, sizeof(ELEM_TYPE))) -#define wapp_array_set(ELEM_TYPE, ARRAY_PTR, INDEX, VALUE_PTR) \ - _array_set((GenericArray *)ARRAY_PTR, INDEX, (void *)VALUE_PTR, sizeof(ELEM_TYPE)) -#define wapp_array_append_capped(ELEM_TYPE, ARRAY_PTR, VALUE_PTR) \ - _array_append_capped((GenericArray *)ARRAY_PTR, (void *)VALUE_PTR, sizeof(ELEM_TYPE)) -#define wapp_array_extend_capped(ELEM_TYPE, DST_ARRAY_PTR, SRC_ARRAY_PTR) \ - _array_extend_capped( \ - (GenericArray *)DST_ARRAY_PTR, (GenericArray *)SRC_ARRAY_PTR, sizeof(ELEM_TYPE) \ - ) -#define wapp_array_copy_capped(ELEM_TYPE, DST_ARRAY_PTR, SRC_ARRAY_PTR) \ - _array_copy_capped( \ - (GenericArray *)DST_ARRAY_PTR, (GenericArray *)SRC_ARRAY_PTR, sizeof(ELEM_TYPE) \ - ) -#define wapp_array_append_alloc(ELEM_TYPE, ARRAY_TYPE, ALLOCATOR_PTR, ARRAY_PTR, VALUE_PTR) \ - (ARRAY_TYPE *)_array_append_alloc( \ - ALLOCATOR_PTR, (GenericArray *)ARRAY_PTR, (void *)VALUE_PTR, sizeof(ELEM_TYPE) \ - ) -#define wapp_array_extend_alloc(ELEM_TYPE, ARRAY_TYPE, ALLOCATOR_PTR, DST_ARRAY_PTR, SRC_ARRAY_PTR) \ - (ARRAY_TYPE *)_array_extend_alloc( \ - ALLOCATOR_PTR, (GenericArray *)DST_ARRAY_PTR, (GenericArray *)SRC_ARRAY_PTR, sizeof(ELEM_TYPE) \ - ) -#define wapp_array_copy_alloc(ELEM_TYPE, ARRAY_TYPE, ALLOCATOR_PTR, DST_ARRAY_PTR, SRC_ARRAY_PTR) \ - (ARRAY_TYPE *)_array_copy_alloc( \ - ALLOCATOR_PTR, (GenericArray *)DST_ARRAY_PTR, (GenericArray *)SRC_ARRAY_PTR, sizeof(ELEM_TYPE) \ - ) -#define wapp_array_clear(ELEM_TYPE, ARRAY_PTR) \ - _array_clear((GenericArray *)ARRAY_PTR, sizeof(ELEM_TYPE)) +#define wapp_array_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, \ + INDEX, \ + sizeof(TYPE))) +#define wapp_array_set(TYPE, ARRAY, INDEX, VALUE_PTR) \ + _array_set((GenericArray)ARRAY, \ + INDEX, \ + (u8 *)VALUE_PTR, \ + sizeof(TYPE)) +#define wapp_array_append_capped(TYPE, ARRAY, VALUE_PTR) \ + _array_append_capped((GenericArray)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, \ + sizeof(TYPE)) +#define wapp_array_copy_capped(TYPE, DST_ARRAY, SRC_ARRAY) \ + _array_copy_capped((GenericArray)DST_ARRAY, \ + (GenericArray)SRC_ARRAY, \ + sizeof(TYPE)) +#define wapp_array_append_alloc(TYPE, ALLOCATOR_PTR, ARRAY, VALUE_PTR) \ + (TYPE *)_array_append_alloc(ALLOCATOR_PTR, \ + (GenericArray)ARRAY, \ + (u8 *)VALUE_PTR, \ + sizeof(TYPE)) +#define wapp_array_extend_alloc(TYPE, ALLOCATOR_PTR, DST_ARRAY, SRC_ARRAY) \ + (TYPE *)_array_extend_alloc(ALLOCATOR_PTR, \ + (GenericArray)DST_ARRAY, \ + (GenericArray)SRC_ARRAY, \ + sizeof(TYPE)) +#define wapp_array_copy_alloc(TYPE, ALLOCATOR_PTR, DST_ARRAY, SRC_ARRAY) \ + (TYPE *)_array_copy_alloc(ALLOCATOR_PTR, \ + (GenericArray)DST_ARRAY, \ + (GenericArray)SRC_ARRAY, \ + sizeof(TYPE)) +#define wapp_array_clear(TYPE, ARRAY) \ + _array_clear((GenericArray)ARRAY, \ + sizeof(TYPE)) -WAPP_DEF_ARRAY_TYPE(void, GenericArray); +typedef struct header ArrayHeader; +struct header { + u64 magic; + u64 count; + u64 capacity; + u64 item_size; +}; -void *_array_get(GenericArray *array, u64 index, u64 item_size); -void _array_set(GenericArray *array, u64 index, void *value, u64 item_size); -void _array_append_capped(GenericArray *array, void *value, u64 item_size); -void _array_extend_capped(GenericArray *dst, const GenericArray *src, u64 item_size); -void _array_copy_capped(GenericArray *dst, const GenericArray *src, u64 item_size); -GenericArray *_array_append_alloc(const Allocator *allocator, GenericArray *array, void *value, u64 item_size); -GenericArray *_array_extend_alloc(const Allocator *allocator, GenericArray *dst, const GenericArray *src, u64 item_size); -GenericArray *_array_copy_alloc(const Allocator *allocator, GenericArray *dst, const GenericArray *src, u64 item_size); -void *_array_pop(GenericArray *array, u64 item_size); -void _array_clear(GenericArray *array, u64 item_size); -GenericArray *_array_alloc_capacity(const Allocator *allocator, u64 capacity, u64 item_size, b8 fill); - -// Base array types -typedef struct Str8 Str8; - -WAPP_DEF_ARRAY_TYPE(void *, VoidPtrArray); -WAPP_DEF_ARRAY_TYPE(c8 , C8Array); -WAPP_DEF_ARRAY_TYPE(c16 , C16Array); -WAPP_DEF_ARRAY_TYPE(c32 , C32Array); -WAPP_DEF_ARRAY_TYPE(u8 , U8Array); -WAPP_DEF_ARRAY_TYPE(u16 , U16Array); -WAPP_DEF_ARRAY_TYPE(u32 , U32Array); -WAPP_DEF_ARRAY_TYPE(u64 , U64Array); -WAPP_DEF_ARRAY_TYPE(b8 , B8Array); -WAPP_DEF_ARRAY_TYPE(i8 , I8Array); -WAPP_DEF_ARRAY_TYPE(i16 , I16Array); -WAPP_DEF_ARRAY_TYPE(i32 , I32Array); -WAPP_DEF_ARRAY_TYPE(i64 , I64Array); -WAPP_DEF_ARRAY_TYPE(f32 , F32Array); -WAPP_DEF_ARRAY_TYPE(f64 , F64Array); -WAPP_DEF_ARRAY_TYPE(f128 , F128Array); -WAPP_DEF_ARRAY_TYPE(uptr , UptrArray); -WAPP_DEF_ARRAY_TYPE(iptr , IptrArray); -WAPP_DEF_ARRAY_TYPE(Str8 , Str8Array); +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, u64 item_size); +GenericArray _array_extend_alloc(const Allocator *allocator, GenericArray dst, const GenericArray src, u64 item_size); +GenericArray _array_copy_alloc(const Allocator *allocator, GenericArray dst, const GenericArray src, u64 item_size); +void *_array_pop(GenericArray array, u64 item_size); +void _array_clear(GenericArray array, u64 item_size); +GenericArray _array_alloc_capacity(const Allocator *allocator, u64 capacity, u64 item_size, b8 fill); #ifdef WAPP_PLATFORM_CPP END_C_LINKAGE diff --git a/src/base/strings/str8/str8.c b/src/base/strings/str8/str8.c index 05ff0a1..2540053 100644 --- a/src/base/strings/str8/str8.c +++ b/src/base/strings/str8/str8.c @@ -275,15 +275,15 @@ void wapp_str8_to_upper(Str8 *dst, Str8RO *src) { } } -void wapp_str8_from_bytes(Str8 *dst, const U8Array *src) { +void wapp_str8_from_bytes(Str8 *dst, const U8Array src) { wapp_debug_assert(src != NULL && dst != NULL, "`dst` and `src` should not be NULL"); - u64 size = src->count * src->item_size; + u64 size = wapp_array_count(src) * wapp_array_item_size(src); wapp_debug_assert(dst->capacity >= size, "`dst` does not have enough capacity"); dst->size = size; - memcpy(dst->buf, src->items, size); + memcpy(dst->buf, src, size); } i64 wapp_str8_find(Str8RO *str, Str8RO substr) { diff --git a/src/base/strings/str8/str8.h b/src/base/strings/str8/str8.h index 1f8c3ae..81496cc 100644 --- a/src/base/strings/str8/str8.h +++ b/src/base/strings/str8/str8.h @@ -101,7 +101,7 @@ 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); +void wapp_str8_from_bytes(Str8 *dst, const U8Array src); /** * Str8 find functions diff --git a/src/os/file/file.c b/src/os/file/file.c index 022c601..223b42b 100644 --- a/src/os/file/file.c +++ b/src/os/file/file.c @@ -62,13 +62,13 @@ u64 wapp_file_get_length(File *file) { return output; } -u64 wapp_file_read(GenericArray *dst_buf, File *file, u64 item_count) { +u64 wapp_file_read(GenericArray dst_buf, File *file, u64 item_count) { wapp_debug_assert(dst_buf != NULL && file != NULL, "`dst_buf` and `file` should not be NULL."); u64 file_length = wapp_file_get_length(file); - u64 item_size = dst_buf->item_size; - u64 dst_byte_capacity = dst_buf->capacity * item_size; + u64 item_size = wapp_array_item_size(dst_buf); + u64 dst_byte_capacity = wapp_array_capacity(dst_buf) * item_size; u64 req_byte_count = item_count * item_size; u64 copy_byte_count = 0; @@ -78,24 +78,24 @@ u64 wapp_file_read(GenericArray *dst_buf, File *file, u64 item_count) { copy_byte_count = file_length <= dst_byte_capacity ? file_length : dst_byte_capacity; } - u64 count = fread(dst_buf->items, sizeof(u8), copy_byte_count, file); + u64 count = fread(dst_buf, sizeof(u8), copy_byte_count, file); if (ferror(file)) { return 0; } - dst_buf->count = count / item_size; + wapp_array_set_count(dst_buf, count / item_size); - return dst_buf->count; + return wapp_array_count(dst_buf); } -u64 wapp_file_write(const GenericArray *src_buf, File *file, u64 item_count) { +u64 wapp_file_write(const GenericArray src_buf, File *file, u64 item_count) { wapp_debug_assert(src_buf != NULL && file != NULL, "`src_buf` and `file` should not be NULL."); - u64 item_size = src_buf->item_size; - u64 src_byte_count = src_buf->count * item_size; + u64 item_size = wapp_array_item_size(src_buf); + u64 src_byte_count = wapp_array_count(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; - return fwrite(src_buf->items, sizeof(u8), to_copy, file); + return fwrite(src_buf, sizeof(u8), to_copy, file); } i32 wapp_file_flush(File *file) { diff --git a/src/os/file/file.h b/src/os/file/file.h index b778532..14417c3 100644 --- a/src/os/file/file.h +++ b/src/os/file/file.h @@ -44,8 +44,8 @@ File *wapp_file_open(Str8RO *filename, FileAccessMode mode); u64 wapp_file_get_current_position(File *file); i32 wapp_file_seek(File *file, u64 offset, FileSeekOrigin origin); u64 wapp_file_get_length(File *file); -u64 wapp_file_read(GenericArray *dst_buf, File *file, u64 item_count); -u64 wapp_file_write(const GenericArray *src_buf, File *file, u64 item_count); +u64 wapp_file_read(GenericArray dst_buf, File *file, u64 item_count); +u64 wapp_file_write(const GenericArray src_buf, File *file, u64 item_count); i32 wapp_file_flush(File *file); i32 wapp_file_close(File *file); diff --git a/tests/array/test_i32_array.c b/tests/array/test_i32_array.c index 4df162e..2096c0c 100644 --- a/tests/array/test_i32_array.c +++ b/tests/array/test_i32_array.c @@ -4,15 +4,15 @@ TestFuncResult test_i32_array(void) { b8 result; - I32Array array = wapp_array(i32, I32Array, 1, 2, 3, 4, 5, 6, 7); - result = array.count == 7 && array.capacity == 16; + I32Array array = wapp_array(i32, 1, 2, 3, 4, 5, 6, 7); + result = wapp_array_count(array) == 7 && wapp_array_capacity(array) == 16; i32 *item; - u64 count = array.count; + u64 count = wapp_array_count(array); u64 index = 0; b8 running = true; while (running) { - item = wapp_array_get(i32, &array, index); + item = wapp_array_get(i32, array, index); result = result && item && *item == (i32)(index + 1); ++index; @@ -25,11 +25,11 @@ TestFuncResult test_i32_array(void) { TestFuncResult test_i32_array_with_capacity(void) { b8 result; - I32Array array1 = wapp_array_with_capacity(i32, I32Array, 64, false); - result = array1.count == 0 && array1.capacity == 64; + I32Array array1 = wapp_array_with_capacity(i32, 64, false); + result = wapp_array_count(array1) == 0 && wapp_array_capacity(array1) == 64; - I32Array array2 = wapp_array_with_capacity(i32, I32Array, 64, true); - result = array2.count == 64 && array2.capacity == 64; + I32Array array2 = wapp_array_with_capacity(i32, 64, true); + result = wapp_array_count(array2) == 64 && wapp_array_capacity(array2) == 64; return wapp_tester_result(result); } @@ -37,14 +37,14 @@ TestFuncResult test_i32_array_with_capacity(void) { TestFuncResult test_i32_array_get(void) { b8 result = true; - I32Array array = wapp_array(i32, I32Array, 0, 1, 2, 3, 4, 5, 6, 7, 8); + I32Array array = wapp_array(i32, 0, 1, 2, 3, 4, 5, 6, 7, 8); i32 *item; - u64 count = array.count; + u64 count = wapp_array_count(array); u64 index = 0; b8 running = true; while (running) { - item = wapp_array_get(i32, &array, index); + item = wapp_array_get(i32, array, index); result = result && item && *item == (i32)index; ++index; @@ -57,16 +57,16 @@ TestFuncResult test_i32_array_get(void) { TestFuncResult test_i32_array_set(void) { b8 result = true; - I32Array array = wapp_array(i32, I32Array, 0, 1, 2, 3, 4, 5, 6, 7, 8); + I32Array array = wapp_array(i32, 0, 1, 2, 3, 4, 5, 6, 7, 8); i32 *item; - u64 count = array.count; + u64 count = wapp_array_count(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); + wapp_array_set(i32, array, index, &num); + item = wapp_array_get(i32, array, index); result = result && item && *item == (i32)(index * 2); ++index; @@ -79,17 +79,17 @@ TestFuncResult test_i32_array_set(void) { TestFuncResult test_i32_array_append_capped(void) { b8 result; - I32Array array = wapp_array_with_capacity(i32, I32Array, 64, false); - wapp_array_append_capped(i32, &array, &((i32){10})); + I32Array array = wapp_array_with_capacity(i32, 64, false); + wapp_array_append_capped(i32, array, &((i32){10})); - result = array.count == 1; - i32 *item = wapp_array_get(i32, &array, 0); + result = wapp_array_count(array) == 1; + i32 *item = wapp_array_get(i32, array, 0); result = result && item && *item == 10; - array = wapp_array(i32, I32Array, 1); - wapp_array_append_capped(i32, &array, &((i32){10})); + array = wapp_array(i32, 1); + wapp_array_append_capped(i32, array, &((i32){10})); - result = result && array.count == 2; + result = result && wapp_array_count(array) == 2; return wapp_tester_result(result); } @@ -97,14 +97,14 @@ TestFuncResult test_i32_array_append_capped(void) { TestFuncResult test_i32_array_extend_capped(void) { b8 result; - I32Array array1 = wapp_array(i32, I32Array, 1, 2, 3, 4); - I32Array array2 = wapp_array(i32, I32Array, 10, 20); + I32Array array1 = wapp_array(i32, 1, 2, 3, 4); + I32Array array2 = wapp_array(i32, 10, 20); - result = array1.count == 4 && array2.count == 2; + result = wapp_array_count(array1) == 4 && wapp_array_count(array2) == 2; - wapp_array_extend_capped(i32, &array1, &array2); + wapp_array_extend_capped(i32, array1, array2); - result = result && array1.count == 6; + result = result && wapp_array_count(array1) == 6; return wapp_tester_result(result); } @@ -112,31 +112,31 @@ TestFuncResult test_i32_array_extend_capped(void) { TestFuncResult test_i32_array_copy_capped(void) { b8 result; - I32Array src = wapp_array(i32, I32Array, 1, 2, 3, 4, 5); - I32Array dst1 = wapp_array(i32, I32Array, 1, 2, 3, 4, 5, 6); - I32Array dst2 = wapp_array(i32, I32Array, 1, 2); + I32Array src = wapp_array(i32, 1, 2, 3, 4, 5); + I32Array dst1 = wapp_array(i32, 1, 2, 3, 4, 5, 6); + I32Array dst2 = wapp_array(i32, 1, 2); u64 expected_count = 5; - wapp_array_copy_capped(i32, &dst1, &src); - result = dst1.count == expected_count; + wapp_array_copy_capped(i32, dst1, src); + result = wapp_array_count(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 && *wapp_array_get(i32, src, index) == *wapp_array_get(i32, dst1, index); ++index; running = index < expected_count; } expected_count = 4; - wapp_array_copy_capped(i32, &dst2, &src); - result = result && dst2.count == expected_count; + wapp_array_copy_capped(i32, dst2, src); + result = result && wapp_array_count(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 && *wapp_array_get(i32, src, index) == *wapp_array_get(i32, dst2, index); ++index; running = index < expected_count; @@ -150,9 +150,9 @@ TestFuncResult test_i32_array_alloc_capacity(void) { Allocator allocator = wapp_mem_arena_allocator_init(MiB(4)); u64 capacity = 32; - I32Array *array = wapp_array_alloc_capacity(i32, I32Array, &allocator, capacity, false); + I32Array array = wapp_array_alloc_capacity(i32, &allocator, capacity, false); - result = array && array->capacity == capacity; + result = array && wapp_array_capacity(array) == capacity; wapp_mem_arena_allocator_destroy(&allocator); @@ -163,23 +163,23 @@ TestFuncResult test_i32_array_append_alloc(void) { b8 result; Allocator allocator = wapp_mem_arena_allocator_init(MiB(4)); - I32Array array1 = wapp_array(i32, I32Array, 1, 2, 3, 4, 5, 6, 7, 8); - I32Array array2 = wapp_array(i32, I32Array, 1, 2); + I32Array array1 = wapp_array(i32, 1, 2, 3, 4, 5, 6, 7, 8); + I32Array array2 = wapp_array(i32, 1, 2); - I32Array *arr_ptr = wapp_array_append_alloc(i32, I32Array, &allocator, &array1, &((i32){10})); - result = arr_ptr == &array1; + I32Array arr_ptr = wapp_array_append_alloc(i32, &allocator, array1, &((i32){10})); + result = arr_ptr == array1; u64 count = 4; u64 index = 0; b8 running = true; while (running) { i32 num = (i32)index; - arr_ptr = wapp_array_append_alloc(i32, I32Array, &allocator, &array2, &num); + arr_ptr = wapp_array_append_alloc(i32, &allocator, array2, &num); ++index; running = index < count; } - result = result && arr_ptr != &array2; + result = result && arr_ptr != array2; wapp_mem_arena_allocator_destroy(&allocator); @@ -190,15 +190,15 @@ TestFuncResult test_i32_array_extend_alloc(void) { b8 result; Allocator allocator = wapp_mem_arena_allocator_init(MiB(4)); - I32Array array1 = wapp_array(i32, I32Array, 1, 2, 3, 4, 5, 6, 7, 8); - I32Array array2 = wapp_array(i32, I32Array, 1, 2); - I32Array array3 = wapp_array(i32, I32Array, 1, 2, 3, 4); + 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); - I32Array *arr_ptr = wapp_array_extend_alloc(i32, I32Array, &allocator, &array1, &array3); - result = arr_ptr == &array1; + I32Array arr_ptr = wapp_array_extend_alloc(i32, &allocator, array1, array3); + result = arr_ptr == array1; - arr_ptr = wapp_array_extend_alloc(i32, I32Array, &allocator, &array2, &array3); - result = result && arr_ptr != &array2; + arr_ptr = wapp_array_extend_alloc(i32, &allocator, array2, array3); + result = result && arr_ptr != array2; wapp_mem_arena_allocator_destroy(&allocator); @@ -209,32 +209,32 @@ TestFuncResult test_i32_array_copy_alloc(void) { b8 result; Allocator allocator = wapp_mem_arena_allocator_init(MiB(4)); - I32Array src = wapp_array(i32, I32Array, 1, 2, 3, 4, 5); - I32Array dst1 = wapp_array(i32, I32Array, 1, 2, 3, 4, 5, 6); - I32Array dst2 = wapp_array(i32, I32Array, 1, 2); - I32Array *array_ptr = NULL; + 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; u64 expected_count = 5; - array_ptr = wapp_array_copy_alloc(i32, I32Array, &allocator, &dst1, &src); - result = array_ptr->count == expected_count && array_ptr == &dst1; + array = wapp_array_copy_alloc(i32, &allocator, dst1, src); + result = wapp_array_count(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_ptr, index); + result = result && *wapp_array_get(i32, src, index) == *wapp_array_get(i32, array, index); ++index; running = index < expected_count; } expected_count = 5; - array_ptr = wapp_array_copy_alloc(i32, I32Array, &allocator, &dst2, &src); - result = result && array_ptr->count == expected_count && array_ptr != &dst2; + array = wapp_array_copy_alloc(i32, &allocator, dst2, src); + result = result && wapp_array_count(array) == expected_count && array != dst2; index = 0; running = true; while (running) { - result = result && *wapp_array_get(i32, &src, index) == *wapp_array_get(i32, array_ptr, index); + result = result && *wapp_array_get(i32, src, index) == *wapp_array_get(i32, array, index); ++index; running = index < expected_count; @@ -248,11 +248,11 @@ TestFuncResult test_i32_array_copy_alloc(void) { TestFuncResult test_i32_array_pop(void) { b8 result; - I32Array array1 = wapp_array(i32, I32Array, 0, 1, 2, 3, 4, 5, 6, 7, 8); - I32Array array2 = wapp_array_with_capacity(i32, I32Array, 32, false); + I32Array array1 = wapp_array(i32, 0, 1, 2, 3, 4, 5, 6, 7, 8); + I32Array array2 = wapp_array_with_capacity(i32, 32, false); - i32 item1 = wapp_array_pop(i32, &array1); - i32 item2 = wapp_array_pop(i32, &array2); + i32 item1 = wapp_array_pop(i32, array1); + i32 item2 = wapp_array_pop(i32, array2); result = item1 == 8 && item2 == 0; @@ -262,12 +262,12 @@ TestFuncResult test_i32_array_pop(void) { TestFuncResult test_i32_array_clear(void) { b8 result; - I32Array array = wapp_array(i32, I32Array, 0, 1, 2, 3, 4, 5, 6, 7, 8); - result = array.count == 9; + I32Array array = wapp_array(i32, 0, 1, 2, 3, 4, 5, 6, 7, 8); + result = wapp_array_count(array) == 9; - wapp_array_clear(i32, &array); + wapp_array_clear(i32, array); - result = result && array.count == 0; + result = result && wapp_array_count(array) == 0; return wapp_tester_result(result); } diff --git a/tests/array/test_i32_array.cc b/tests/array/test_i32_array.cc index 214f3fc..47e3382 100644 --- a/tests/array/test_i32_array.cc +++ b/tests/array/test_i32_array.cc @@ -4,15 +4,15 @@ TestFuncResult test_i32_array(void) { b8 result; - I32Array array = wapp_array(i32, I32Array, 1, 2, 3, 4, 5, 6, 7); - result = array.count == 7 && array.capacity == 16; + I32Array array = wapp_array(i32, 1, 2, 3, 4, 5, 6, 7); + result = wapp_array_count(array) == 7 && wapp_array_capacity(array) == 16; i32 *item; - u64 count = array.count; + u64 count = wapp_array_count(array); u64 index = 0; b8 running = true; while (running) { - item = wapp_array_get(i32, &array, index); + item = wapp_array_get(i32, array, index); result = result && item && (*item == (i32)(index + 1)); ++index; @@ -25,11 +25,11 @@ TestFuncResult test_i32_array(void) { TestFuncResult test_i32_array_with_capacity(void) { b8 result; - I32Array array1 = wapp_array_with_capacity(i32, I32Array, 64, false); - result = array1.count == 0 && array1.capacity == 64; + I32Array array1 = wapp_array_with_capacity(i32, 64, false); + result = wapp_array_count(array1) == 0 && wapp_array_capacity(array1) == 64; - I32Array array2 = wapp_array_with_capacity(i32, I32Array, 64, true); - result = array2.count == 64 && array2.capacity == 64; + I32Array array2 = wapp_array_with_capacity(i32, 64, true); + result = wapp_array_count(array2) == 64 && wapp_array_capacity(array2) == 64; return wapp_tester_result(result); } @@ -37,14 +37,14 @@ TestFuncResult test_i32_array_with_capacity(void) { TestFuncResult test_i32_array_get(void) { b8 result = true; - I32Array array = wapp_array(i32, I32Array, 0, 1, 2, 3, 4, 5, 6, 7, 8); + I32Array array = wapp_array(i32, 0, 1, 2, 3, 4, 5, 6, 7, 8); i32 *item; - u64 count = array.count; + u64 count = wapp_array_count(array); u64 index = 0; b8 running = true; while (running) { - item = wapp_array_get(i32, &array, index); + item = wapp_array_get(i32, array, index); result = result && item && (*item == (i32)index); ++index; @@ -57,16 +57,16 @@ TestFuncResult test_i32_array_get(void) { TestFuncResult test_i32_array_set(void) { b8 result = true; - I32Array array = wapp_array(i32, I32Array, 0, 1, 2, 3, 4, 5, 6, 7, 8); + I32Array array = wapp_array(i32, 0, 1, 2, 3, 4, 5, 6, 7, 8); i32 *item; - u64 count = array.count; + u64 count = wapp_array_count(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); + wapp_array_set(i32, array, index, &num); + item = wapp_array_get(i32, array, index); result = result && item && (*item == (i32)(index * 2)); ++index; @@ -79,19 +79,19 @@ TestFuncResult test_i32_array_set(void) { TestFuncResult test_i32_array_append_capped(void) { b8 result; - I32Array array = wapp_array_with_capacity(i32, I32Array, 64, false); + I32Array array = wapp_array_with_capacity(i32, 64, false); i32 item1 = 10; - wapp_array_append_capped(i32, &array, &item1); + wapp_array_append_capped(i32, array, &item1); - result = array.count == 1; - i32 *item = wapp_array_get(i32, &array, 0); + result = wapp_array_count(array) == 1; + i32 *item = wapp_array_get(i32, array, 0); result = result && item && *item == 10; - array = wapp_array(i32, I32Array, 1); + array = wapp_array(i32, 1); i32 item2 = 10; - wapp_array_append_capped(i32, &array, &item2); + wapp_array_append_capped(i32, array, &item2); - result = result && array.count == 2; + result = result && wapp_array_count(array) == 2; return wapp_tester_result(result); } @@ -99,14 +99,14 @@ TestFuncResult test_i32_array_append_capped(void) { TestFuncResult test_i32_array_extend_capped(void) { b8 result; - I32Array array1 = wapp_array(i32, I32Array, 1, 2, 3, 4); - I32Array array2 = wapp_array(i32, I32Array, 10, 20); + I32Array array1 = wapp_array(i32, 1, 2, 3, 4); + I32Array array2 = wapp_array(i32, 10, 20); - result = array1.count == 4 && array2.count == 2; + result = wapp_array_count(array1) == 4 && wapp_array_count(array2) == 2; - wapp_array_extend_capped(i32, &array1, &array2); + wapp_array_extend_capped(i32, array1, array2); - result = result && array1.count == 6; + result = result && wapp_array_count(array1) == 6; return wapp_tester_result(result); } @@ -114,31 +114,31 @@ TestFuncResult test_i32_array_extend_capped(void) { TestFuncResult test_i32_array_copy_capped(void) { b8 result; - I32Array src = wapp_array(i32, I32Array, 1, 2, 3, 4, 5); - I32Array dst1 = wapp_array(i32, I32Array, 1, 2, 3, 4, 5, 6); - I32Array dst2 = wapp_array(i32, I32Array, 1, 2); + I32Array src = wapp_array(i32, 1, 2, 3, 4, 5); + I32Array dst1 = wapp_array(i32, 1, 2, 3, 4, 5, 6); + I32Array dst2 = wapp_array(i32, 1, 2); u64 expected_count = 5; - wapp_array_copy_capped(i32, &dst1, &src); - result = dst1.count == expected_count; + wapp_array_copy_capped(i32, dst1, src); + result = wapp_array_count(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 && (*wapp_array_get(i32, src, index) == *wapp_array_get(i32, dst1, index)); ++index; running = index < expected_count; } expected_count = 4; - wapp_array_copy_capped(i32, &dst2, &src); - result = result && dst2.count == expected_count; + wapp_array_copy_capped(i32, dst2, src); + result = result && wapp_array_count(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 && (*wapp_array_get(i32, src, index) == *wapp_array_get(i32, dst2, index)); ++index; running = index < expected_count; @@ -152,9 +152,9 @@ TestFuncResult test_i32_array_alloc_capacity(void) { Allocator allocator = wapp_mem_arena_allocator_init(MiB(4)); u64 capacity = 32; - I32Array *array = wapp_array_alloc_capacity(i32, I32Array, &allocator, capacity, false); + I32Array array = wapp_array_alloc_capacity(i32, &allocator, capacity, false); - result = array && array->capacity == capacity; + result = array && wapp_array_capacity(array) == capacity; wapp_mem_arena_allocator_destroy(&allocator); @@ -165,24 +165,24 @@ TestFuncResult test_i32_array_append_alloc(void) { b8 result; Allocator allocator = wapp_mem_arena_allocator_init(MiB(4)); - I32Array array1 = wapp_array(i32, I32Array, 1, 2, 3, 4, 5, 6, 7, 8); - I32Array array2 = wapp_array(i32, I32Array, 1, 2); + I32Array array1 = wapp_array(i32, 1, 2, 3, 4, 5, 6, 7, 8); + I32Array array2 = wapp_array(i32, 1, 2); i32 num = 10; - I32Array *arr_ptr = wapp_array_append_alloc(i32, I32Array, &allocator, &array1, &num); - result = arr_ptr == &array1; + I32Array arr_ptr = wapp_array_append_alloc(i32, &allocator, array1, &num); + result = arr_ptr == array1; u64 count = 4; u64 index = 0; b8 running = true; while (running) { num = (i32)index; - arr_ptr = wapp_array_append_alloc(i32, I32Array, &allocator, &array2, &num); + arr_ptr = wapp_array_append_alloc(i32, &allocator, array2, &num); ++index; running = index < count; } - result = result && arr_ptr != &array2; + result = result && arr_ptr != array2; wapp_mem_arena_allocator_destroy(&allocator); @@ -193,15 +193,15 @@ TestFuncResult test_i32_array_extend_alloc(void) { b8 result; Allocator allocator = wapp_mem_arena_allocator_init(MiB(4)); - I32Array array1 = wapp_array(i32, I32Array, 1, 2, 3, 4, 5, 6, 7, 8); - I32Array array2 = wapp_array(i32, I32Array, 1, 2); - I32Array array3 = wapp_array(i32, I32Array, 1, 2, 3, 4); + 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); - I32Array *arr_ptr = wapp_array_extend_alloc(i32, I32Array, &allocator, &array1, &array3); - result = arr_ptr == &array1; + I32Array array = wapp_array_extend_alloc(i32, &allocator, array1, array3); + result = array == array1; - arr_ptr = wapp_array_extend_alloc(i32, I32Array, &allocator, &array2, &array3); - result = result && arr_ptr != &array2; + array = wapp_array_extend_alloc(i32, &allocator, array2, array3); + result = result && array != array2; wapp_mem_arena_allocator_destroy(&allocator); @@ -212,32 +212,32 @@ TestFuncResult test_i32_array_copy_alloc(void) { b8 result; Allocator allocator = wapp_mem_arena_allocator_init(MiB(4)); - I32Array src = wapp_array(i32, I32Array, 1, 2, 3, 4, 5); - I32Array dst1 = wapp_array(i32, I32Array, 1, 2, 3, 4, 5, 6); - I32Array dst2 = wapp_array(i32, I32Array, 1, 2); - I32Array *array_ptr = nullptr; + 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; u64 expected_count = 5; - array_ptr = wapp_array_copy_alloc(i32, I32Array, &allocator, &dst1, &src); - result = array_ptr->count == expected_count && array_ptr == &dst1; + array = wapp_array_copy_alloc(i32, &allocator, dst1, src); + result = wapp_array_count(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_ptr, index)); + result = result && (*wapp_array_get(i32, src, index) == *wapp_array_get(i32, array, index)); ++index; running = index < expected_count; } expected_count = 5; - array_ptr = wapp_array_copy_alloc(i32, I32Array, &allocator, &dst2, &src); - result = result && array_ptr->count == expected_count && array_ptr != &dst2; + array = wapp_array_copy_alloc(i32, &allocator, dst2, src); + result = result && wapp_array_count(array) == expected_count && array != dst2; index = 0; running = true; while (running) { - result = result && (*wapp_array_get(i32, &src, index) == *wapp_array_get(i32, array_ptr, index)); + result = result && (*wapp_array_get(i32, src, index) == *wapp_array_get(i32, array, index)); ++index; running = index < expected_count; @@ -251,12 +251,12 @@ TestFuncResult test_i32_array_copy_alloc(void) { TestFuncResult test_i32_array_clear(void) { b8 result; - I32Array array = wapp_array(i32, I32Array, 0, 1, 2, 3, 4, 5, 6, 7, 8); - result = array.count == 9; + I32Array array = wapp_array(i32, 0, 1, 2, 3, 4, 5, 6, 7, 8); + result = wapp_array_count(array) == 9; - wapp_array_clear(i32, &array); + wapp_array_clear(i32, array); - result = result && array.count == 0; + result = result && wapp_array_count(array) == 0; return wapp_tester_result(result); } @@ -264,11 +264,11 @@ TestFuncResult test_i32_array_clear(void) { TestFuncResult test_i32_array_pop(void) { b8 result; - I32Array array1 = wapp_array(i32, I32Array, 0, 1, 2, 3, 4, 5, 6, 7, 8); - I32Array array2 = wapp_array_with_capacity(i32, I32Array, 32, false); + I32Array array1 = wapp_array(i32, 0, 1, 2, 3, 4, 5, 6, 7, 8); + I32Array array2 = wapp_array_with_capacity(i32, 32, false); - i32 item1 = wapp_array_pop(i32, &array1); - i32 item2 = wapp_array_pop(i32, &array2); + i32 item1 = wapp_array_pop(i32, array1); + i32 item2 = wapp_array_pop(i32, array2); result = item1 == 8 && item2 == 0; diff --git a/tests/array/test_str8_array.c b/tests/array/test_str8_array.c index 49b2b98..392e622 100644 --- a/tests/array/test_str8_array.c +++ b/tests/array/test_str8_array.c @@ -6,15 +6,15 @@ TestFuncResult 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, Str8Array, wapp_str8_lit("Hello"), wapp_str8_lit("Hi"), wapp_str8_lit("Bye")); - result = array.count == 3 && array.capacity == 8; + 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; Str8 *item; - u64 count = array.count; + u64 count = wapp_array_count(array); u64 index = 0; b8 running = true; while (running) { - item = wapp_array_get(Str8, &array, index); + item = wapp_array_get(Str8, array, index); result = result && item && (wapp_str8_equal(item, &expected[index])); ++index; diff --git a/tests/array/test_str8_array.cc b/tests/array/test_str8_array.cc index ee9cdd8..4338854 100644 --- a/tests/array/test_str8_array.cc +++ b/tests/array/test_str8_array.cc @@ -10,16 +10,16 @@ TestFuncResult test_str8_array(void) { Str8 str1 = wapp_str8_lit("Hello"); Str8 str2 = wapp_str8_lit("Hi"); Str8 str3 = wapp_str8_lit("Bye"); - Str8Array array = wapp_array(Str8, Str8Array, str1, str2, str3); + Str8Array array = wapp_array(Str8, str1, str2, str3); - result = array.count == 3 && array.capacity == 8; + result = wapp_array_count(array) == 3 && wapp_array_capacity(array) == 8; Str8 *item; - u64 count = array.count; + u64 count = wapp_array_count(array); u64 index = 0; b8 running = true; while (running) { - item = wapp_array_get(Str8, &array, index); + item = wapp_array_get(Str8, array, index); result = result && item && (wapp_str8_equal(item, &expected[index])); ++index; diff --git a/tests/str8/test_str8.c b/tests/str8/test_str8.c index 8ef328f..70d9fa7 100644 --- a/tests/str8/test_str8.c +++ b/tests/str8/test_str8.c @@ -616,10 +616,10 @@ TestFuncResult test_str8_from_bytes(void) { b8 result; Str8 str = wapp_str8_buf(1024); - U8Array bytes = wapp_array(u8, U8Array, 'W', 'A', 'P', 'P'); - wapp_str8_from_bytes(&str, &bytes); + U8Array bytes = wapp_array(u8, 'W', 'A', 'P', 'P'); + wapp_str8_from_bytes(&str, bytes); - result = str.size == bytes.count * bytes.item_size; + result = str.size == wapp_array_count(bytes) * wapp_array_item_size(bytes); result = result && wapp_str8_equal(&str, &wapp_str8_lit_ro("WAPP")); return wapp_tester_result(result); diff --git a/tests/str8/test_str8.cc b/tests/str8/test_str8.cc index 41c610e..9236d42 100644 --- a/tests/str8/test_str8.cc +++ b/tests/str8/test_str8.cc @@ -617,10 +617,10 @@ TestFuncResult test_str8_from_bytes(void) { Str8 str = wapp_str8_buf(1024); Str8 expected = wapp_str8_lit_ro("WAPP"); - U8Array bytes = wapp_array(u8, U8Array, 'W', 'A', 'P', 'P'); - wapp_str8_from_bytes(&str, &bytes); + U8Array bytes = wapp_array(u8, 'W', 'A', 'P', 'P'); + wapp_str8_from_bytes(&str, bytes); - result = str.size == bytes.count * bytes.item_size; + result = str.size == wapp_array_count(bytes) * wapp_array_item_size(bytes); result = result && wapp_str8_equal(&str, &expected); return wapp_tester_result(result);