diff --git a/codegen/array/make_array.py b/codegen/array/make_array.py index 7fd249d..8d10957 100644 --- a/codegen/array/make_array.py +++ b/codegen/array/make_array.py @@ -51,10 +51,6 @@ def make_array(user_datatypes: Dict[CDataType, ArrayData] = {}): header=str(convert_to_relative(WAPP_SRC_ROOT / "primitives" / "mem_allocator" / "mem_allocator.h", out_dir)).replace("\\", "/"), local=True, ), - CInclude( - header=str(convert_to_relative(WAPP_SRC_ROOT / "primitives" / "strings" / "str8" / "str8.h", out_dir)).replace("\\", "/"), - local=True, - ), CInclude( header=str(convert_to_relative(WAPP_SRC_ROOT / "common" / "misc" / "misc_utils.h", out_dir)).replace("\\", "/"), local=True, @@ -66,6 +62,9 @@ def make_array(user_datatypes: Dict[CDataType, ArrayData] = {}): datatypes: dict[CDataType, ArrayData] = { "Str8": ArrayData( array_typename="Str8Array", + hdr_decl_types=[ + CStruct(name="str8", cargs=[], typedef_name="Str8"), + ], ), } @@ -111,6 +110,8 @@ def make_array(user_datatypes: Dict[CDataType, ArrayData] = {}): source.includes.extend(common_includes) + generic_funcs = [] + for _type, array_data in datatypes.items(): type_string = get_datatype_string(_type) clean_type_string = type_string.replace(" ", "").replace("*", "_ptr") @@ -123,8 +124,29 @@ def make_array(user_datatypes: Dict[CDataType, ArrayData] = {}): CArg(name="items", _type=type_string, pointer=CPointer(_type=CPointerType.SINGLE)), CArg(name="count", _type=CType.U64), CArg(name="capacity", _type=CType.U64), + CArg(name="item_size", _type=CType.U64), ], ) + + if isinstance(_type, str) and _type == "void *": + alloc_capacity_func = CFunc( + name=f"_array_alloc_capacity", + ret_type=array, + args=[ + CArg(name="allocator", _type="Allocator", pointer=CPointer(CPointerType.SINGLE), qualifier=CQualifier.CONST), + CArg(name="capacity", _type=CType.U64), + CArg(name="item_size", _type=CType.U64), + ], + body=__format_func_body( + filename=snippets_dir / "alloc_capacity", + type_string=type_string, + type_string_upper=type_string_upper, + type_string_lower=type_string_lower, + array_typename=array_data.array_typename, + ), + pointer=CPointer(CPointerType.SINGLE), + ) + generic_funcs.append(alloc_capacity_func) stack_array_macro = CMacro( name=f"wapp_{type_string_lower}_array(...)", @@ -148,6 +170,28 @@ def make_array(user_datatypes: Dict[CDataType, ArrayData] = {}): ), ) + alloc_capacity_array_macro = CMacro( + name=f"wapp_{type_string_lower}_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY)", + value=__format_func_body( + filename=snippets_dir / "alloc_capacity_macro", + type_string=type_string, + type_string_upper=type_string_upper, + type_string_lower=type_string_lower, + array_typename=array_data.array_typename, + ), + ) + + array_pop_macro = CMacro( + name=f"wapp_{type_string_lower}_array_pop(ARRAY_PTR)", + value=__format_func_body( + filename=snippets_dir / "array_pop_macro", + type_string=type_string, + type_string_upper=type_string_upper, + type_string_lower=type_string_lower, + array_typename=array_data.array_typename, + ), + ) + get_func = CFunc( name=f"wapp_{type_string_lower}_array_get", ret_type=type_string, @@ -171,7 +215,7 @@ def make_array(user_datatypes: Dict[CDataType, ArrayData] = {}): args=[ CArg(name="array", _type=array, pointer=CPointer(CPointerType.SINGLE)), CArg(name="index", _type=CType.U64), - CArg(name="item", _type=type_string), + CArg(name="item", _type=type_string, pointer=CPointer(CPointerType.SINGLE)), ], body=__format_func_body( filename=snippets_dir / "array_set", @@ -187,7 +231,7 @@ def make_array(user_datatypes: Dict[CDataType, ArrayData] = {}): ret_type=CType.VOID, args=[ CArg(name="array", _type=array, pointer=CPointer(CPointerType.SINGLE)), - CArg(name="item", _type=type_string), + CArg(name="item", _type=type_string, pointer=CPointer(CPointerType.SINGLE)), ], body=__format_func_body( filename=snippets_dir / "append_capped", @@ -229,21 +273,6 @@ def make_array(user_datatypes: Dict[CDataType, ArrayData] = {}): ), ) - pop_func = CFunc( - name=f"wapp_{type_string_lower}_array_pop", - ret_type=type_string, - args=[ - CArg(name="array", _type=array, pointer=CPointer(CPointerType.SINGLE)), - ], - body=__format_func_body( - filename=snippets_dir / "array_pop", - type_string=type_string, - type_string_upper=type_string_upper, - type_string_lower=type_string_lower, - array_typename=array_data.array_typename, - ), - ) - copy_capped_func = CFunc( name=f"wapp_{type_string_lower}_array_copy_capped", ret_type=CType.VOID, @@ -260,30 +289,13 @@ def make_array(user_datatypes: Dict[CDataType, ArrayData] = {}): ), ) - alloc_capacity_func = CFunc( - name=f"wapp_{type_string_lower}_array_alloc_capacity", - ret_type=array, - args=[ - CArg(name="allocator", _type="Allocator", pointer=CPointer(CPointerType.SINGLE), qualifier=CQualifier.CONST), - CArg(name="capacity", _type=CType.U64), - ], - body=__format_func_body( - filename=snippets_dir / "alloc_capacity", - type_string=type_string, - type_string_upper=type_string_upper, - type_string_lower=type_string_lower, - array_typename=array_data.array_typename, - ), - pointer=CPointer(CPointerType.SINGLE), - ) - append_alloc_func = CFunc( name=f"wapp_{type_string_lower}_array_append_alloc", ret_type=array, args=[ CArg(name="allocator", _type="Allocator", pointer=CPointer(CPointerType.SINGLE), qualifier=CQualifier.CONST), CArg(name="array", _type=array, pointer=CPointer(CPointerType.SINGLE)), - CArg(name="item", _type=type_string), + CArg(name="item", _type=type_string, pointer=CPointer(CPointerType.SINGLE)), ], body=__format_func_body( filename=snippets_dir / "append_alloc", @@ -331,8 +343,29 @@ def make_array(user_datatypes: Dict[CDataType, ArrayData] = {}): pointer=CPointer(CPointerType.SINGLE), ) + pop_func = CFunc( + name=f"_{type_string_lower}_array_pop", + ret_type=type_string, + args=[ + CArg(name="array", _type=array, pointer=CPointer(CPointerType.SINGLE)), + ], + body=__format_func_body( + filename=snippets_dir / "array_pop", + type_string=type_string, + type_string_upper=type_string_upper, + type_string_lower=type_string_lower, + array_typename=array_data.array_typename, + ), + pointer=CPointer(CPointerType.SINGLE), + ) + header.decl_types.extend(array_data.hdr_decl_types) - header.macros.extend([stack_array_macro, stack_capacity_array_macro]) + header.macros.extend([ + stack_array_macro, + stack_capacity_array_macro, + alloc_capacity_array_macro, + array_pop_macro, + ]) header.types.extend([array]) header.funcs.extend([ get_func, @@ -340,16 +373,17 @@ def make_array(user_datatypes: Dict[CDataType, ArrayData] = {}): append_capped_func, extend_capped_func, clear_func, - pop_func, copy_capped_func, - alloc_capacity_func, append_alloc_func, extend_alloc_func, copy_alloc_func, + pop_func, ]) source.decl_types.extend(array_data.src_decl_types) source.funcs = header.funcs + + header.funcs.extend(generic_funcs) header.save(out_dir) source.save(out_dir) diff --git a/codegen/array/snippets/alloc_capacity b/codegen/array/snippets/alloc_capacity index 0b030cb..4977ccd 100644 --- a/codegen/array/snippets/alloc_capacity +++ b/codegen/array/snippets/alloc_capacity @@ -1,18 +1,19 @@ - u64 allocation_size = sizeof({ArrayType}) + sizeof({T}) * capacity; - {ArrayType} *array = NULL; + u64 allocation_size = sizeof({ArrayType}) + item_size * capacity; + {ArrayType} *array = NULL; if (!allocator) {{ - goto RETURN_{Tupper}_ARRAY_ALLOC; + goto RETURN_GENERIC_ARRAY_ALLOC; }} array = wapp_mem_allocator_alloc(allocator, allocation_size); if (!array) {{ - goto RETURN_{Tupper}_ARRAY_ALLOC; + goto RETURN_GENERIC_ARRAY_ALLOC; }} - array->items = ({T} *)((u8 *)array + sizeof({ArrayType})); - array->count = 0; - array->capacity = capacity; + array->items = ({T} *)((u8 *)array + sizeof({ArrayType})); + array->count = 0; + array->capacity = capacity; + array->item_size = item_size; -RETURN_{Tupper}_ARRAY_ALLOC: +RETURN_GENERIC_ARRAY_ALLOC: return array; diff --git a/codegen/array/snippets/alloc_capacity_macro b/codegen/array/snippets/alloc_capacity_macro new file mode 100644 index 0000000..b3094c1 --- /dev/null +++ b/codegen/array/snippets/alloc_capacity_macro @@ -0,0 +1 @@ +(({ArrayType} *)_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY, sizeof({T}))) diff --git a/codegen/array/snippets/append_alloc b/codegen/array/snippets/append_alloc index 7ffd5e1..216a77c 100644 --- a/codegen/array/snippets/append_alloc +++ b/codegen/array/snippets/append_alloc @@ -6,7 +6,7 @@ if (array->count >= array->capacity) {{ u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(array->capacity * 2); - output = wapp_{Tlower}_array_alloc_capacity(allocator, new_capacity); + output = ({ArrayType} *)_array_alloc_capacity(allocator, new_capacity, array->item_size); if (!output) {{ output = array; goto RETURN_{Tupper}_ARRAY_APPEND_ALLOC; diff --git a/codegen/array/snippets/append_capped b/codegen/array/snippets/append_capped index fb0e63b..17d6100 100644 --- a/codegen/array/snippets/append_capped +++ b/codegen/array/snippets/append_capped @@ -2,4 +2,5 @@ return; }} - array->items[(array->count)++] = item; + u64 index = (array->count)++; + wapp_{Tlower}_array_set(array, index, item); diff --git a/codegen/array/snippets/array_get b/codegen/array/snippets/array_get index 615d681..b8e5125 100644 --- a/codegen/array/snippets/array_get +++ b/codegen/array/snippets/array_get @@ -2,4 +2,5 @@ return NULL; }} - return &(array->items[index]); + u8 *ptr = (u8 *)(array->items) + (array->item_size * index); + return ({T} *)ptr; diff --git a/codegen/array/snippets/array_pop b/codegen/array/snippets/array_pop index 5ee63cc..f30681e 100644 --- a/codegen/array/snippets/array_pop +++ b/codegen/array/snippets/array_pop @@ -1,5 +1,4 @@ - if (!array || array->count == 0) {{ - return ({T}){{0}}; - }} - - return array->items[--(array->count)]; + u64 index = array->count - 1; + {T} *out = wapp_{Tlower}_array_get(array, index); + --(array->count); + return out; diff --git a/codegen/array/snippets/array_pop_macro b/codegen/array/snippets/array_pop_macro new file mode 100644 index 0000000..5fb1c49 --- /dev/null +++ b/codegen/array/snippets/array_pop_macro @@ -0,0 +1,4 @@ +(ARRAY_PTR != NULL && (ARRAY_PTR)->count > 0 ? \ + *_{Tlower}_array_pop(ARRAY_PTR) : \ + ({T}){{0}} \ +) diff --git a/codegen/array/snippets/array_set b/codegen/array/snippets/array_set index fd41402..bacedc8 100644 --- a/codegen/array/snippets/array_set +++ b/codegen/array/snippets/array_set @@ -1,5 +1,6 @@ - if (!array || index >= array->count) {{ + {T} *ptr = wapp_{Tlower}_array_get(array, index); + if (!ptr) {{ return; }} - array->items[index] = item; + memcpy((void *)ptr, (void *)item, array->item_size); diff --git a/codegen/array/snippets/copy_alloc b/codegen/array/snippets/copy_alloc index eff1280..32e9fc9 100644 --- a/codegen/array/snippets/copy_alloc +++ b/codegen/array/snippets/copy_alloc @@ -6,7 +6,7 @@ if (src->count >= dst->capacity) {{ u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(dst->capacity * 2); - output = wapp_{Tlower}_array_alloc_capacity(allocator, new_capacity); + output = ({ArrayType} *)_array_alloc_capacity(allocator, new_capacity, src->item_size); if (!output) {{ output = dst; goto RETURN_{Tupper}_ARRAY_COPY_ALLOC; diff --git a/codegen/array/snippets/copy_capped b/codegen/array/snippets/copy_capped index 41651df..4bb1961 100644 --- a/codegen/array/snippets/copy_capped +++ b/codegen/array/snippets/copy_capped @@ -20,5 +20,5 @@ continue; }} - wapp_{Tlower}_array_append_capped(dst, *item); + wapp_{Tlower}_array_append_capped(dst, item); }} diff --git a/codegen/array/snippets/extend_alloc b/codegen/array/snippets/extend_alloc index 971fd33..1db2c12 100644 --- a/codegen/array/snippets/extend_alloc +++ b/codegen/array/snippets/extend_alloc @@ -7,7 +7,7 @@ u64 remaining_capacity = array->capacity - array->count; if (other->count >= remaining_capacity) {{ u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(array->capacity * 2); - output = wapp_{Tlower}_array_alloc_capacity(allocator, new_capacity); + output = ({ArrayType} *)_array_alloc_capacity(allocator, new_capacity, array->item_size); if (!output) {{ output = array; goto RETURN_{Tupper}_ARRAY_EXTEND_ALLOC; diff --git a/codegen/array/snippets/extend_capped b/codegen/array/snippets/extend_capped index cf64202..89c772f 100644 --- a/codegen/array/snippets/extend_capped +++ b/codegen/array/snippets/extend_capped @@ -23,5 +23,5 @@ continue; }} - wapp_{Tlower}_array_append_capped(array, *item); - }} \ No newline at end of file + wapp_{Tlower}_array_append_capped(array, item); + }} diff --git a/codegen/array/snippets/stack_array b/codegen/array/snippets/stack_array index e513a40..1f986c9 100644 --- a/codegen/array/snippets/stack_array +++ b/codegen/array/snippets/stack_array @@ -1,5 +1,6 @@ (({ArrayType}){{ \ .items = ({T}[wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count({T}, __VA_ARGS__) * 2)]){{__VA_ARGS__}}, \ .count = wapp_misc_utils_va_args_count({T}, __VA_ARGS__), \ - .capacity = wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count({T}, __VA_ARGS__) * 2) \ + .capacity = wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count({T}, __VA_ARGS__) * 2), \ + .item_size = sizeof({T}) \ }}) diff --git a/codegen/array/snippets/stack_capacity_array b/codegen/array/snippets/stack_capacity_array index 0b03163..9d78e4b 100644 --- a/codegen/array/snippets/stack_capacity_array +++ b/codegen/array/snippets/stack_capacity_array @@ -1 +1 @@ -(({ArrayType}){{.items = ({T}[CAPACITY]){{0}}, .count = 0, .capacity = CAPACITY}}) +(({ArrayType}){{.items = ({T}[CAPACITY]){{0}}, .count = 0, .capacity = CAPACITY, .item_size = sizeof({T})}}) diff --git a/src/primitives/array/array.c b/src/primitives/array/array.c index a26512b..b761a41 100644 --- a/src/primitives/array/array.c +++ b/src/primitives/array/array.c @@ -4,7 +4,6 @@ #include "./array.h" #include "../mem_allocator/mem_allocator.h" -#include "../strings/str8/str8.h" #include "../../common/misc/misc_utils.h" #include "../../common/aliases/aliases.h" #include "../../common/platform/platform.h" @@ -16,23 +15,26 @@ Str8 *wapp_str8_array_get(const Str8Array *array, u64 index) { return NULL; } - return &(array->items[index]); + u8 *ptr = (u8 *)(array->items) + (array->item_size * index); + return (Str8 *)ptr; } -void wapp_str8_array_set(Str8Array *array, u64 index, Str8 item) { - if (!array || index >= array->count) { +void wapp_str8_array_set(Str8Array *array, u64 index, Str8 *item) { + Str8 *ptr = wapp_str8_array_get(array, index); + if (!ptr) { return; } - array->items[index] = item; + memcpy((void *)ptr, (void *)item, array->item_size); } -void wapp_str8_array_append_capped(Str8Array *array, Str8 item) { +void wapp_str8_array_append_capped(Str8Array *array, Str8 *item) { if (!array || array->count >= array->capacity) { return; } - array->items[(array->count)++] = item; + u64 index = (array->count)++; + wapp_str8_array_set(array, index, item); } void wapp_str8_array_extend_capped(Str8Array *array, const Str8Array *other) { @@ -61,7 +63,7 @@ void wapp_str8_array_extend_capped(Str8Array *array, const Str8Array *other) { continue; } - wapp_str8_array_append_capped(array, *item); + wapp_str8_array_append_capped(array, item); } } @@ -73,14 +75,6 @@ void wapp_str8_array_clear(Str8Array *array) { array->count = 0; } -Str8 wapp_str8_array_pop(Str8Array *array) { - if (!array || array->count == 0) { - return (Str8){0}; - } - - return array->items[--(array->count)]; -} - void wapp_str8_array_copy_capped(const Str8Array *src, Str8Array *dst) { if (!src || !dst) { return; @@ -104,32 +98,11 @@ void wapp_str8_array_copy_capped(const Str8Array *src, Str8Array *dst) { continue; } - wapp_str8_array_append_capped(dst, *item); + wapp_str8_array_append_capped(dst, item); } } -Str8Array *wapp_str8_array_alloc_capacity(const Allocator *allocator, u64 capacity) { - u64 allocation_size = sizeof(Str8Array) + sizeof(Str8) * capacity; - Str8Array *array = NULL; - - if (!allocator) { - goto RETURN_STR8_ARRAY_ALLOC; - } - - array = wapp_mem_allocator_alloc(allocator, allocation_size); - if (!array) { - goto RETURN_STR8_ARRAY_ALLOC; - } - - array->items = (Str8 *)((u8 *)array + sizeof(Str8Array)); - array->count = 0; - array->capacity = capacity; - -RETURN_STR8_ARRAY_ALLOC: - return array; -} - -Str8Array *wapp_str8_array_append_alloc(const Allocator *allocator, Str8Array *array, Str8 item) { +Str8Array *wapp_str8_array_append_alloc(const Allocator *allocator, Str8Array *array, Str8 *item) { Str8Array *output = array; if (!allocator || !array) { @@ -138,7 +111,7 @@ Str8Array *wapp_str8_array_append_alloc(const Allocator *allocator, Str8Array *a if (array->count >= array->capacity) { u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(array->capacity * 2); - output = wapp_str8_array_alloc_capacity(allocator, new_capacity); + output = (Str8Array *)_array_alloc_capacity(allocator, new_capacity, array->item_size); if (!output) { output = array; goto RETURN_STR8_ARRAY_APPEND_ALLOC; @@ -162,7 +135,7 @@ Str8Array *wapp_str8_array_extend_alloc(const Allocator *allocator, Str8Array *a u64 remaining_capacity = array->capacity - array->count; if (other->count >= remaining_capacity) { u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(array->capacity * 2); - output = wapp_str8_array_alloc_capacity(allocator, new_capacity); + output = (Str8Array *)_array_alloc_capacity(allocator, new_capacity, array->item_size); if (!output) { output = array; goto RETURN_STR8_ARRAY_EXTEND_ALLOC; @@ -185,7 +158,7 @@ Str8Array *wapp_str8_array_copy_alloc(const Allocator *allocator, const Str8Arra if (src->count >= dst->capacity) { u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(dst->capacity * 2); - output = wapp_str8_array_alloc_capacity(allocator, new_capacity); + output = (Str8Array *)_array_alloc_capacity(allocator, new_capacity, src->item_size); if (!output) { output = dst; goto RETURN_STR8_ARRAY_COPY_ALLOC; @@ -199,28 +172,38 @@ RETURN_STR8_ARRAY_COPY_ALLOC: return output; } +Str8 *_str8_array_pop(Str8Array *array) { + u64 index = array->count - 1; + Str8 *out = wapp_str8_array_get(array, index); + --(array->count); + return out; +} + void * *wapp_void_ptr_array_get(const VoidPArray *array, u64 index) { if (!array || index >= array->count) { return NULL; } - return &(array->items[index]); + u8 *ptr = (u8 *)(array->items) + (array->item_size * index); + return (void * *)ptr; } -void wapp_void_ptr_array_set(VoidPArray *array, u64 index, void * item) { - if (!array || index >= array->count) { +void wapp_void_ptr_array_set(VoidPArray *array, u64 index, void * *item) { + void * *ptr = wapp_void_ptr_array_get(array, index); + if (!ptr) { return; } - array->items[index] = item; + memcpy((void *)ptr, (void *)item, array->item_size); } -void wapp_void_ptr_array_append_capped(VoidPArray *array, void * item) { +void wapp_void_ptr_array_append_capped(VoidPArray *array, void * *item) { if (!array || array->count >= array->capacity) { return; } - array->items[(array->count)++] = item; + u64 index = (array->count)++; + wapp_void_ptr_array_set(array, index, item); } void wapp_void_ptr_array_extend_capped(VoidPArray *array, const VoidPArray *other) { @@ -249,7 +232,7 @@ void wapp_void_ptr_array_extend_capped(VoidPArray *array, const VoidPArray *othe continue; } - wapp_void_ptr_array_append_capped(array, *item); + wapp_void_ptr_array_append_capped(array, item); } } @@ -261,14 +244,6 @@ void wapp_void_ptr_array_clear(VoidPArray *array) { array->count = 0; } -void * wapp_void_ptr_array_pop(VoidPArray *array) { - if (!array || array->count == 0) { - return (void *){0}; - } - - return array->items[--(array->count)]; -} - void wapp_void_ptr_array_copy_capped(const VoidPArray *src, VoidPArray *dst) { if (!src || !dst) { return; @@ -292,32 +267,11 @@ void wapp_void_ptr_array_copy_capped(const VoidPArray *src, VoidPArray *dst) { continue; } - wapp_void_ptr_array_append_capped(dst, *item); + wapp_void_ptr_array_append_capped(dst, item); } } -VoidPArray *wapp_void_ptr_array_alloc_capacity(const Allocator *allocator, u64 capacity) { - u64 allocation_size = sizeof(VoidPArray) + sizeof(void *) * capacity; - VoidPArray *array = NULL; - - if (!allocator) { - goto RETURN_VOID_PTR_ARRAY_ALLOC; - } - - array = wapp_mem_allocator_alloc(allocator, allocation_size); - if (!array) { - goto RETURN_VOID_PTR_ARRAY_ALLOC; - } - - array->items = (void * *)((u8 *)array + sizeof(VoidPArray)); - array->count = 0; - array->capacity = capacity; - -RETURN_VOID_PTR_ARRAY_ALLOC: - return array; -} - -VoidPArray *wapp_void_ptr_array_append_alloc(const Allocator *allocator, VoidPArray *array, void * item) { +VoidPArray *wapp_void_ptr_array_append_alloc(const Allocator *allocator, VoidPArray *array, void * *item) { VoidPArray *output = array; if (!allocator || !array) { @@ -326,7 +280,7 @@ VoidPArray *wapp_void_ptr_array_append_alloc(const Allocator *allocator, VoidPAr if (array->count >= array->capacity) { u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(array->capacity * 2); - output = wapp_void_ptr_array_alloc_capacity(allocator, new_capacity); + output = (VoidPArray *)_array_alloc_capacity(allocator, new_capacity, array->item_size); if (!output) { output = array; goto RETURN_VOID_PTR_ARRAY_APPEND_ALLOC; @@ -350,7 +304,7 @@ VoidPArray *wapp_void_ptr_array_extend_alloc(const Allocator *allocator, VoidPAr u64 remaining_capacity = array->capacity - array->count; if (other->count >= remaining_capacity) { u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(array->capacity * 2); - output = wapp_void_ptr_array_alloc_capacity(allocator, new_capacity); + output = (VoidPArray *)_array_alloc_capacity(allocator, new_capacity, array->item_size); if (!output) { output = array; goto RETURN_VOID_PTR_ARRAY_EXTEND_ALLOC; @@ -373,7 +327,7 @@ VoidPArray *wapp_void_ptr_array_copy_alloc(const Allocator *allocator, const Voi if (src->count >= dst->capacity) { u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(dst->capacity * 2); - output = wapp_void_ptr_array_alloc_capacity(allocator, new_capacity); + output = (VoidPArray *)_array_alloc_capacity(allocator, new_capacity, src->item_size); if (!output) { output = dst; goto RETURN_VOID_PTR_ARRAY_COPY_ALLOC; @@ -387,28 +341,38 @@ RETURN_VOID_PTR_ARRAY_COPY_ALLOC: return output; } +void * *_void_ptr_array_pop(VoidPArray *array) { + u64 index = array->count - 1; + void * *out = wapp_void_ptr_array_get(array, index); + --(array->count); + return out; +} + bool *wapp_bool_array_get(const BoolArray *array, u64 index) { if (!array || index >= array->count) { return NULL; } - return &(array->items[index]); + u8 *ptr = (u8 *)(array->items) + (array->item_size * index); + return (bool *)ptr; } -void wapp_bool_array_set(BoolArray *array, u64 index, bool item) { - if (!array || index >= array->count) { +void wapp_bool_array_set(BoolArray *array, u64 index, bool *item) { + bool *ptr = wapp_bool_array_get(array, index); + if (!ptr) { return; } - array->items[index] = item; + memcpy((void *)ptr, (void *)item, array->item_size); } -void wapp_bool_array_append_capped(BoolArray *array, bool item) { +void wapp_bool_array_append_capped(BoolArray *array, bool *item) { if (!array || array->count >= array->capacity) { return; } - array->items[(array->count)++] = item; + u64 index = (array->count)++; + wapp_bool_array_set(array, index, item); } void wapp_bool_array_extend_capped(BoolArray *array, const BoolArray *other) { @@ -437,7 +401,7 @@ void wapp_bool_array_extend_capped(BoolArray *array, const BoolArray *other) { continue; } - wapp_bool_array_append_capped(array, *item); + wapp_bool_array_append_capped(array, item); } } @@ -449,14 +413,6 @@ void wapp_bool_array_clear(BoolArray *array) { array->count = 0; } -bool wapp_bool_array_pop(BoolArray *array) { - if (!array || array->count == 0) { - return (bool){0}; - } - - return array->items[--(array->count)]; -} - void wapp_bool_array_copy_capped(const BoolArray *src, BoolArray *dst) { if (!src || !dst) { return; @@ -480,32 +436,11 @@ void wapp_bool_array_copy_capped(const BoolArray *src, BoolArray *dst) { continue; } - wapp_bool_array_append_capped(dst, *item); + wapp_bool_array_append_capped(dst, item); } } -BoolArray *wapp_bool_array_alloc_capacity(const Allocator *allocator, u64 capacity) { - u64 allocation_size = sizeof(BoolArray) + sizeof(bool) * capacity; - BoolArray *array = NULL; - - if (!allocator) { - goto RETURN_BOOL_ARRAY_ALLOC; - } - - array = wapp_mem_allocator_alloc(allocator, allocation_size); - if (!array) { - goto RETURN_BOOL_ARRAY_ALLOC; - } - - array->items = (bool *)((u8 *)array + sizeof(BoolArray)); - array->count = 0; - array->capacity = capacity; - -RETURN_BOOL_ARRAY_ALLOC: - return array; -} - -BoolArray *wapp_bool_array_append_alloc(const Allocator *allocator, BoolArray *array, bool item) { +BoolArray *wapp_bool_array_append_alloc(const Allocator *allocator, BoolArray *array, bool *item) { BoolArray *output = array; if (!allocator || !array) { @@ -514,7 +449,7 @@ BoolArray *wapp_bool_array_append_alloc(const Allocator *allocator, BoolArray *a if (array->count >= array->capacity) { u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(array->capacity * 2); - output = wapp_bool_array_alloc_capacity(allocator, new_capacity); + output = (BoolArray *)_array_alloc_capacity(allocator, new_capacity, array->item_size); if (!output) { output = array; goto RETURN_BOOL_ARRAY_APPEND_ALLOC; @@ -538,7 +473,7 @@ BoolArray *wapp_bool_array_extend_alloc(const Allocator *allocator, BoolArray *a u64 remaining_capacity = array->capacity - array->count; if (other->count >= remaining_capacity) { u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(array->capacity * 2); - output = wapp_bool_array_alloc_capacity(allocator, new_capacity); + output = (BoolArray *)_array_alloc_capacity(allocator, new_capacity, array->item_size); if (!output) { output = array; goto RETURN_BOOL_ARRAY_EXTEND_ALLOC; @@ -561,7 +496,7 @@ BoolArray *wapp_bool_array_copy_alloc(const Allocator *allocator, const BoolArra if (src->count >= dst->capacity) { u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(dst->capacity * 2); - output = wapp_bool_array_alloc_capacity(allocator, new_capacity); + output = (BoolArray *)_array_alloc_capacity(allocator, new_capacity, src->item_size); if (!output) { output = dst; goto RETURN_BOOL_ARRAY_COPY_ALLOC; @@ -575,28 +510,38 @@ RETURN_BOOL_ARRAY_COPY_ALLOC: return output; } +bool *_bool_array_pop(BoolArray *array) { + u64 index = array->count - 1; + bool *out = wapp_bool_array_get(array, index); + --(array->count); + return out; +} + char *wapp_char_array_get(const CharArray *array, u64 index) { if (!array || index >= array->count) { return NULL; } - return &(array->items[index]); + u8 *ptr = (u8 *)(array->items) + (array->item_size * index); + return (char *)ptr; } -void wapp_char_array_set(CharArray *array, u64 index, char item) { - if (!array || index >= array->count) { +void wapp_char_array_set(CharArray *array, u64 index, char *item) { + char *ptr = wapp_char_array_get(array, index); + if (!ptr) { return; } - array->items[index] = item; + memcpy((void *)ptr, (void *)item, array->item_size); } -void wapp_char_array_append_capped(CharArray *array, char item) { +void wapp_char_array_append_capped(CharArray *array, char *item) { if (!array || array->count >= array->capacity) { return; } - array->items[(array->count)++] = item; + u64 index = (array->count)++; + wapp_char_array_set(array, index, item); } void wapp_char_array_extend_capped(CharArray *array, const CharArray *other) { @@ -625,7 +570,7 @@ void wapp_char_array_extend_capped(CharArray *array, const CharArray *other) { continue; } - wapp_char_array_append_capped(array, *item); + wapp_char_array_append_capped(array, item); } } @@ -637,14 +582,6 @@ void wapp_char_array_clear(CharArray *array) { array->count = 0; } -char wapp_char_array_pop(CharArray *array) { - if (!array || array->count == 0) { - return (char){0}; - } - - return array->items[--(array->count)]; -} - void wapp_char_array_copy_capped(const CharArray *src, CharArray *dst) { if (!src || !dst) { return; @@ -668,32 +605,11 @@ void wapp_char_array_copy_capped(const CharArray *src, CharArray *dst) { continue; } - wapp_char_array_append_capped(dst, *item); + wapp_char_array_append_capped(dst, item); } } -CharArray *wapp_char_array_alloc_capacity(const Allocator *allocator, u64 capacity) { - u64 allocation_size = sizeof(CharArray) + sizeof(char) * capacity; - CharArray *array = NULL; - - if (!allocator) { - goto RETURN_CHAR_ARRAY_ALLOC; - } - - array = wapp_mem_allocator_alloc(allocator, allocation_size); - if (!array) { - goto RETURN_CHAR_ARRAY_ALLOC; - } - - array->items = (char *)((u8 *)array + sizeof(CharArray)); - array->count = 0; - array->capacity = capacity; - -RETURN_CHAR_ARRAY_ALLOC: - return array; -} - -CharArray *wapp_char_array_append_alloc(const Allocator *allocator, CharArray *array, char item) { +CharArray *wapp_char_array_append_alloc(const Allocator *allocator, CharArray *array, char *item) { CharArray *output = array; if (!allocator || !array) { @@ -702,7 +618,7 @@ CharArray *wapp_char_array_append_alloc(const Allocator *allocator, CharArray *a if (array->count >= array->capacity) { u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(array->capacity * 2); - output = wapp_char_array_alloc_capacity(allocator, new_capacity); + output = (CharArray *)_array_alloc_capacity(allocator, new_capacity, array->item_size); if (!output) { output = array; goto RETURN_CHAR_ARRAY_APPEND_ALLOC; @@ -726,7 +642,7 @@ CharArray *wapp_char_array_extend_alloc(const Allocator *allocator, CharArray *a u64 remaining_capacity = array->capacity - array->count; if (other->count >= remaining_capacity) { u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(array->capacity * 2); - output = wapp_char_array_alloc_capacity(allocator, new_capacity); + output = (CharArray *)_array_alloc_capacity(allocator, new_capacity, array->item_size); if (!output) { output = array; goto RETURN_CHAR_ARRAY_EXTEND_ALLOC; @@ -749,7 +665,7 @@ CharArray *wapp_char_array_copy_alloc(const Allocator *allocator, const CharArra if (src->count >= dst->capacity) { u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(dst->capacity * 2); - output = wapp_char_array_alloc_capacity(allocator, new_capacity); + output = (CharArray *)_array_alloc_capacity(allocator, new_capacity, src->item_size); if (!output) { output = dst; goto RETURN_CHAR_ARRAY_COPY_ALLOC; @@ -763,28 +679,38 @@ RETURN_CHAR_ARRAY_COPY_ALLOC: return output; } +char *_char_array_pop(CharArray *array) { + u64 index = array->count - 1; + char *out = wapp_char_array_get(array, index); + --(array->count); + return out; +} + c8 *wapp_c8_array_get(const C8Array *array, u64 index) { if (!array || index >= array->count) { return NULL; } - return &(array->items[index]); + u8 *ptr = (u8 *)(array->items) + (array->item_size * index); + return (c8 *)ptr; } -void wapp_c8_array_set(C8Array *array, u64 index, c8 item) { - if (!array || index >= array->count) { +void wapp_c8_array_set(C8Array *array, u64 index, c8 *item) { + c8 *ptr = wapp_c8_array_get(array, index); + if (!ptr) { return; } - array->items[index] = item; + memcpy((void *)ptr, (void *)item, array->item_size); } -void wapp_c8_array_append_capped(C8Array *array, c8 item) { +void wapp_c8_array_append_capped(C8Array *array, c8 *item) { if (!array || array->count >= array->capacity) { return; } - array->items[(array->count)++] = item; + u64 index = (array->count)++; + wapp_c8_array_set(array, index, item); } void wapp_c8_array_extend_capped(C8Array *array, const C8Array *other) { @@ -813,7 +739,7 @@ void wapp_c8_array_extend_capped(C8Array *array, const C8Array *other) { continue; } - wapp_c8_array_append_capped(array, *item); + wapp_c8_array_append_capped(array, item); } } @@ -825,14 +751,6 @@ void wapp_c8_array_clear(C8Array *array) { array->count = 0; } -c8 wapp_c8_array_pop(C8Array *array) { - if (!array || array->count == 0) { - return (c8){0}; - } - - return array->items[--(array->count)]; -} - void wapp_c8_array_copy_capped(const C8Array *src, C8Array *dst) { if (!src || !dst) { return; @@ -856,32 +774,11 @@ void wapp_c8_array_copy_capped(const C8Array *src, C8Array *dst) { continue; } - wapp_c8_array_append_capped(dst, *item); + wapp_c8_array_append_capped(dst, item); } } -C8Array *wapp_c8_array_alloc_capacity(const Allocator *allocator, u64 capacity) { - u64 allocation_size = sizeof(C8Array) + sizeof(c8) * capacity; - C8Array *array = NULL; - - if (!allocator) { - goto RETURN_C8_ARRAY_ALLOC; - } - - array = wapp_mem_allocator_alloc(allocator, allocation_size); - if (!array) { - goto RETURN_C8_ARRAY_ALLOC; - } - - array->items = (c8 *)((u8 *)array + sizeof(C8Array)); - array->count = 0; - array->capacity = capacity; - -RETURN_C8_ARRAY_ALLOC: - return array; -} - -C8Array *wapp_c8_array_append_alloc(const Allocator *allocator, C8Array *array, c8 item) { +C8Array *wapp_c8_array_append_alloc(const Allocator *allocator, C8Array *array, c8 *item) { C8Array *output = array; if (!allocator || !array) { @@ -890,7 +787,7 @@ C8Array *wapp_c8_array_append_alloc(const Allocator *allocator, C8Array *array, if (array->count >= array->capacity) { u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(array->capacity * 2); - output = wapp_c8_array_alloc_capacity(allocator, new_capacity); + output = (C8Array *)_array_alloc_capacity(allocator, new_capacity, array->item_size); if (!output) { output = array; goto RETURN_C8_ARRAY_APPEND_ALLOC; @@ -914,7 +811,7 @@ C8Array *wapp_c8_array_extend_alloc(const Allocator *allocator, C8Array *array, u64 remaining_capacity = array->capacity - array->count; if (other->count >= remaining_capacity) { u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(array->capacity * 2); - output = wapp_c8_array_alloc_capacity(allocator, new_capacity); + output = (C8Array *)_array_alloc_capacity(allocator, new_capacity, array->item_size); if (!output) { output = array; goto RETURN_C8_ARRAY_EXTEND_ALLOC; @@ -937,7 +834,7 @@ C8Array *wapp_c8_array_copy_alloc(const Allocator *allocator, const C8Array *src if (src->count >= dst->capacity) { u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(dst->capacity * 2); - output = wapp_c8_array_alloc_capacity(allocator, new_capacity); + output = (C8Array *)_array_alloc_capacity(allocator, new_capacity, src->item_size); if (!output) { output = dst; goto RETURN_C8_ARRAY_COPY_ALLOC; @@ -951,28 +848,38 @@ RETURN_C8_ARRAY_COPY_ALLOC: return output; } +c8 *_c8_array_pop(C8Array *array) { + u64 index = array->count - 1; + c8 *out = wapp_c8_array_get(array, index); + --(array->count); + return out; +} + c16 *wapp_c16_array_get(const C16Array *array, u64 index) { if (!array || index >= array->count) { return NULL; } - return &(array->items[index]); + u8 *ptr = (u8 *)(array->items) + (array->item_size * index); + return (c16 *)ptr; } -void wapp_c16_array_set(C16Array *array, u64 index, c16 item) { - if (!array || index >= array->count) { +void wapp_c16_array_set(C16Array *array, u64 index, c16 *item) { + c16 *ptr = wapp_c16_array_get(array, index); + if (!ptr) { return; } - array->items[index] = item; + memcpy((void *)ptr, (void *)item, array->item_size); } -void wapp_c16_array_append_capped(C16Array *array, c16 item) { +void wapp_c16_array_append_capped(C16Array *array, c16 *item) { if (!array || array->count >= array->capacity) { return; } - array->items[(array->count)++] = item; + u64 index = (array->count)++; + wapp_c16_array_set(array, index, item); } void wapp_c16_array_extend_capped(C16Array *array, const C16Array *other) { @@ -1001,7 +908,7 @@ void wapp_c16_array_extend_capped(C16Array *array, const C16Array *other) { continue; } - wapp_c16_array_append_capped(array, *item); + wapp_c16_array_append_capped(array, item); } } @@ -1013,14 +920,6 @@ void wapp_c16_array_clear(C16Array *array) { array->count = 0; } -c16 wapp_c16_array_pop(C16Array *array) { - if (!array || array->count == 0) { - return (c16){0}; - } - - return array->items[--(array->count)]; -} - void wapp_c16_array_copy_capped(const C16Array *src, C16Array *dst) { if (!src || !dst) { return; @@ -1044,32 +943,11 @@ void wapp_c16_array_copy_capped(const C16Array *src, C16Array *dst) { continue; } - wapp_c16_array_append_capped(dst, *item); + wapp_c16_array_append_capped(dst, item); } } -C16Array *wapp_c16_array_alloc_capacity(const Allocator *allocator, u64 capacity) { - u64 allocation_size = sizeof(C16Array) + sizeof(c16) * capacity; - C16Array *array = NULL; - - if (!allocator) { - goto RETURN_C16_ARRAY_ALLOC; - } - - array = wapp_mem_allocator_alloc(allocator, allocation_size); - if (!array) { - goto RETURN_C16_ARRAY_ALLOC; - } - - array->items = (c16 *)((u8 *)array + sizeof(C16Array)); - array->count = 0; - array->capacity = capacity; - -RETURN_C16_ARRAY_ALLOC: - return array; -} - -C16Array *wapp_c16_array_append_alloc(const Allocator *allocator, C16Array *array, c16 item) { +C16Array *wapp_c16_array_append_alloc(const Allocator *allocator, C16Array *array, c16 *item) { C16Array *output = array; if (!allocator || !array) { @@ -1078,7 +956,7 @@ C16Array *wapp_c16_array_append_alloc(const Allocator *allocator, C16Array *arra if (array->count >= array->capacity) { u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(array->capacity * 2); - output = wapp_c16_array_alloc_capacity(allocator, new_capacity); + output = (C16Array *)_array_alloc_capacity(allocator, new_capacity, array->item_size); if (!output) { output = array; goto RETURN_C16_ARRAY_APPEND_ALLOC; @@ -1102,7 +980,7 @@ C16Array *wapp_c16_array_extend_alloc(const Allocator *allocator, C16Array *arra u64 remaining_capacity = array->capacity - array->count; if (other->count >= remaining_capacity) { u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(array->capacity * 2); - output = wapp_c16_array_alloc_capacity(allocator, new_capacity); + output = (C16Array *)_array_alloc_capacity(allocator, new_capacity, array->item_size); if (!output) { output = array; goto RETURN_C16_ARRAY_EXTEND_ALLOC; @@ -1125,7 +1003,7 @@ C16Array *wapp_c16_array_copy_alloc(const Allocator *allocator, const C16Array * if (src->count >= dst->capacity) { u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(dst->capacity * 2); - output = wapp_c16_array_alloc_capacity(allocator, new_capacity); + output = (C16Array *)_array_alloc_capacity(allocator, new_capacity, src->item_size); if (!output) { output = dst; goto RETURN_C16_ARRAY_COPY_ALLOC; @@ -1139,28 +1017,38 @@ RETURN_C16_ARRAY_COPY_ALLOC: return output; } +c16 *_c16_array_pop(C16Array *array) { + u64 index = array->count - 1; + c16 *out = wapp_c16_array_get(array, index); + --(array->count); + return out; +} + c32 *wapp_c32_array_get(const C32Array *array, u64 index) { if (!array || index >= array->count) { return NULL; } - return &(array->items[index]); + u8 *ptr = (u8 *)(array->items) + (array->item_size * index); + return (c32 *)ptr; } -void wapp_c32_array_set(C32Array *array, u64 index, c32 item) { - if (!array || index >= array->count) { +void wapp_c32_array_set(C32Array *array, u64 index, c32 *item) { + c32 *ptr = wapp_c32_array_get(array, index); + if (!ptr) { return; } - array->items[index] = item; + memcpy((void *)ptr, (void *)item, array->item_size); } -void wapp_c32_array_append_capped(C32Array *array, c32 item) { +void wapp_c32_array_append_capped(C32Array *array, c32 *item) { if (!array || array->count >= array->capacity) { return; } - array->items[(array->count)++] = item; + u64 index = (array->count)++; + wapp_c32_array_set(array, index, item); } void wapp_c32_array_extend_capped(C32Array *array, const C32Array *other) { @@ -1189,7 +1077,7 @@ void wapp_c32_array_extend_capped(C32Array *array, const C32Array *other) { continue; } - wapp_c32_array_append_capped(array, *item); + wapp_c32_array_append_capped(array, item); } } @@ -1201,14 +1089,6 @@ void wapp_c32_array_clear(C32Array *array) { array->count = 0; } -c32 wapp_c32_array_pop(C32Array *array) { - if (!array || array->count == 0) { - return (c32){0}; - } - - return array->items[--(array->count)]; -} - void wapp_c32_array_copy_capped(const C32Array *src, C32Array *dst) { if (!src || !dst) { return; @@ -1232,32 +1112,11 @@ void wapp_c32_array_copy_capped(const C32Array *src, C32Array *dst) { continue; } - wapp_c32_array_append_capped(dst, *item); + wapp_c32_array_append_capped(dst, item); } } -C32Array *wapp_c32_array_alloc_capacity(const Allocator *allocator, u64 capacity) { - u64 allocation_size = sizeof(C32Array) + sizeof(c32) * capacity; - C32Array *array = NULL; - - if (!allocator) { - goto RETURN_C32_ARRAY_ALLOC; - } - - array = wapp_mem_allocator_alloc(allocator, allocation_size); - if (!array) { - goto RETURN_C32_ARRAY_ALLOC; - } - - array->items = (c32 *)((u8 *)array + sizeof(C32Array)); - array->count = 0; - array->capacity = capacity; - -RETURN_C32_ARRAY_ALLOC: - return array; -} - -C32Array *wapp_c32_array_append_alloc(const Allocator *allocator, C32Array *array, c32 item) { +C32Array *wapp_c32_array_append_alloc(const Allocator *allocator, C32Array *array, c32 *item) { C32Array *output = array; if (!allocator || !array) { @@ -1266,7 +1125,7 @@ C32Array *wapp_c32_array_append_alloc(const Allocator *allocator, C32Array *arra if (array->count >= array->capacity) { u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(array->capacity * 2); - output = wapp_c32_array_alloc_capacity(allocator, new_capacity); + output = (C32Array *)_array_alloc_capacity(allocator, new_capacity, array->item_size); if (!output) { output = array; goto RETURN_C32_ARRAY_APPEND_ALLOC; @@ -1290,7 +1149,7 @@ C32Array *wapp_c32_array_extend_alloc(const Allocator *allocator, C32Array *arra u64 remaining_capacity = array->capacity - array->count; if (other->count >= remaining_capacity) { u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(array->capacity * 2); - output = wapp_c32_array_alloc_capacity(allocator, new_capacity); + output = (C32Array *)_array_alloc_capacity(allocator, new_capacity, array->item_size); if (!output) { output = array; goto RETURN_C32_ARRAY_EXTEND_ALLOC; @@ -1313,7 +1172,7 @@ C32Array *wapp_c32_array_copy_alloc(const Allocator *allocator, const C32Array * if (src->count >= dst->capacity) { u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(dst->capacity * 2); - output = wapp_c32_array_alloc_capacity(allocator, new_capacity); + output = (C32Array *)_array_alloc_capacity(allocator, new_capacity, src->item_size); if (!output) { output = dst; goto RETURN_C32_ARRAY_COPY_ALLOC; @@ -1327,28 +1186,38 @@ RETURN_C32_ARRAY_COPY_ALLOC: return output; } +c32 *_c32_array_pop(C32Array *array) { + u64 index = array->count - 1; + c32 *out = wapp_c32_array_get(array, index); + --(array->count); + return out; +} + i8 *wapp_i8_array_get(const I8Array *array, u64 index) { if (!array || index >= array->count) { return NULL; } - return &(array->items[index]); + u8 *ptr = (u8 *)(array->items) + (array->item_size * index); + return (i8 *)ptr; } -void wapp_i8_array_set(I8Array *array, u64 index, i8 item) { - if (!array || index >= array->count) { +void wapp_i8_array_set(I8Array *array, u64 index, i8 *item) { + i8 *ptr = wapp_i8_array_get(array, index); + if (!ptr) { return; } - array->items[index] = item; + memcpy((void *)ptr, (void *)item, array->item_size); } -void wapp_i8_array_append_capped(I8Array *array, i8 item) { +void wapp_i8_array_append_capped(I8Array *array, i8 *item) { if (!array || array->count >= array->capacity) { return; } - array->items[(array->count)++] = item; + u64 index = (array->count)++; + wapp_i8_array_set(array, index, item); } void wapp_i8_array_extend_capped(I8Array *array, const I8Array *other) { @@ -1377,7 +1246,7 @@ void wapp_i8_array_extend_capped(I8Array *array, const I8Array *other) { continue; } - wapp_i8_array_append_capped(array, *item); + wapp_i8_array_append_capped(array, item); } } @@ -1389,14 +1258,6 @@ void wapp_i8_array_clear(I8Array *array) { array->count = 0; } -i8 wapp_i8_array_pop(I8Array *array) { - if (!array || array->count == 0) { - return (i8){0}; - } - - return array->items[--(array->count)]; -} - void wapp_i8_array_copy_capped(const I8Array *src, I8Array *dst) { if (!src || !dst) { return; @@ -1420,32 +1281,11 @@ void wapp_i8_array_copy_capped(const I8Array *src, I8Array *dst) { continue; } - wapp_i8_array_append_capped(dst, *item); + wapp_i8_array_append_capped(dst, item); } } -I8Array *wapp_i8_array_alloc_capacity(const Allocator *allocator, u64 capacity) { - u64 allocation_size = sizeof(I8Array) + sizeof(i8) * capacity; - I8Array *array = NULL; - - if (!allocator) { - goto RETURN_I8_ARRAY_ALLOC; - } - - array = wapp_mem_allocator_alloc(allocator, allocation_size); - if (!array) { - goto RETURN_I8_ARRAY_ALLOC; - } - - array->items = (i8 *)((u8 *)array + sizeof(I8Array)); - array->count = 0; - array->capacity = capacity; - -RETURN_I8_ARRAY_ALLOC: - return array; -} - -I8Array *wapp_i8_array_append_alloc(const Allocator *allocator, I8Array *array, i8 item) { +I8Array *wapp_i8_array_append_alloc(const Allocator *allocator, I8Array *array, i8 *item) { I8Array *output = array; if (!allocator || !array) { @@ -1454,7 +1294,7 @@ I8Array *wapp_i8_array_append_alloc(const Allocator *allocator, I8Array *array, if (array->count >= array->capacity) { u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(array->capacity * 2); - output = wapp_i8_array_alloc_capacity(allocator, new_capacity); + output = (I8Array *)_array_alloc_capacity(allocator, new_capacity, array->item_size); if (!output) { output = array; goto RETURN_I8_ARRAY_APPEND_ALLOC; @@ -1478,7 +1318,7 @@ I8Array *wapp_i8_array_extend_alloc(const Allocator *allocator, I8Array *array, u64 remaining_capacity = array->capacity - array->count; if (other->count >= remaining_capacity) { u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(array->capacity * 2); - output = wapp_i8_array_alloc_capacity(allocator, new_capacity); + output = (I8Array *)_array_alloc_capacity(allocator, new_capacity, array->item_size); if (!output) { output = array; goto RETURN_I8_ARRAY_EXTEND_ALLOC; @@ -1501,7 +1341,7 @@ I8Array *wapp_i8_array_copy_alloc(const Allocator *allocator, const I8Array *src if (src->count >= dst->capacity) { u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(dst->capacity * 2); - output = wapp_i8_array_alloc_capacity(allocator, new_capacity); + output = (I8Array *)_array_alloc_capacity(allocator, new_capacity, src->item_size); if (!output) { output = dst; goto RETURN_I8_ARRAY_COPY_ALLOC; @@ -1515,28 +1355,38 @@ RETURN_I8_ARRAY_COPY_ALLOC: return output; } +i8 *_i8_array_pop(I8Array *array) { + u64 index = array->count - 1; + i8 *out = wapp_i8_array_get(array, index); + --(array->count); + return out; +} + i16 *wapp_i16_array_get(const I16Array *array, u64 index) { if (!array || index >= array->count) { return NULL; } - return &(array->items[index]); + u8 *ptr = (u8 *)(array->items) + (array->item_size * index); + return (i16 *)ptr; } -void wapp_i16_array_set(I16Array *array, u64 index, i16 item) { - if (!array || index >= array->count) { +void wapp_i16_array_set(I16Array *array, u64 index, i16 *item) { + i16 *ptr = wapp_i16_array_get(array, index); + if (!ptr) { return; } - array->items[index] = item; + memcpy((void *)ptr, (void *)item, array->item_size); } -void wapp_i16_array_append_capped(I16Array *array, i16 item) { +void wapp_i16_array_append_capped(I16Array *array, i16 *item) { if (!array || array->count >= array->capacity) { return; } - array->items[(array->count)++] = item; + u64 index = (array->count)++; + wapp_i16_array_set(array, index, item); } void wapp_i16_array_extend_capped(I16Array *array, const I16Array *other) { @@ -1565,7 +1415,7 @@ void wapp_i16_array_extend_capped(I16Array *array, const I16Array *other) { continue; } - wapp_i16_array_append_capped(array, *item); + wapp_i16_array_append_capped(array, item); } } @@ -1577,14 +1427,6 @@ void wapp_i16_array_clear(I16Array *array) { array->count = 0; } -i16 wapp_i16_array_pop(I16Array *array) { - if (!array || array->count == 0) { - return (i16){0}; - } - - return array->items[--(array->count)]; -} - void wapp_i16_array_copy_capped(const I16Array *src, I16Array *dst) { if (!src || !dst) { return; @@ -1608,32 +1450,11 @@ void wapp_i16_array_copy_capped(const I16Array *src, I16Array *dst) { continue; } - wapp_i16_array_append_capped(dst, *item); + wapp_i16_array_append_capped(dst, item); } } -I16Array *wapp_i16_array_alloc_capacity(const Allocator *allocator, u64 capacity) { - u64 allocation_size = sizeof(I16Array) + sizeof(i16) * capacity; - I16Array *array = NULL; - - if (!allocator) { - goto RETURN_I16_ARRAY_ALLOC; - } - - array = wapp_mem_allocator_alloc(allocator, allocation_size); - if (!array) { - goto RETURN_I16_ARRAY_ALLOC; - } - - array->items = (i16 *)((u8 *)array + sizeof(I16Array)); - array->count = 0; - array->capacity = capacity; - -RETURN_I16_ARRAY_ALLOC: - return array; -} - -I16Array *wapp_i16_array_append_alloc(const Allocator *allocator, I16Array *array, i16 item) { +I16Array *wapp_i16_array_append_alloc(const Allocator *allocator, I16Array *array, i16 *item) { I16Array *output = array; if (!allocator || !array) { @@ -1642,7 +1463,7 @@ I16Array *wapp_i16_array_append_alloc(const Allocator *allocator, I16Array *arra if (array->count >= array->capacity) { u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(array->capacity * 2); - output = wapp_i16_array_alloc_capacity(allocator, new_capacity); + output = (I16Array *)_array_alloc_capacity(allocator, new_capacity, array->item_size); if (!output) { output = array; goto RETURN_I16_ARRAY_APPEND_ALLOC; @@ -1666,7 +1487,7 @@ I16Array *wapp_i16_array_extend_alloc(const Allocator *allocator, I16Array *arra u64 remaining_capacity = array->capacity - array->count; if (other->count >= remaining_capacity) { u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(array->capacity * 2); - output = wapp_i16_array_alloc_capacity(allocator, new_capacity); + output = (I16Array *)_array_alloc_capacity(allocator, new_capacity, array->item_size); if (!output) { output = array; goto RETURN_I16_ARRAY_EXTEND_ALLOC; @@ -1689,7 +1510,7 @@ I16Array *wapp_i16_array_copy_alloc(const Allocator *allocator, const I16Array * if (src->count >= dst->capacity) { u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(dst->capacity * 2); - output = wapp_i16_array_alloc_capacity(allocator, new_capacity); + output = (I16Array *)_array_alloc_capacity(allocator, new_capacity, src->item_size); if (!output) { output = dst; goto RETURN_I16_ARRAY_COPY_ALLOC; @@ -1703,28 +1524,38 @@ RETURN_I16_ARRAY_COPY_ALLOC: return output; } +i16 *_i16_array_pop(I16Array *array) { + u64 index = array->count - 1; + i16 *out = wapp_i16_array_get(array, index); + --(array->count); + return out; +} + i32 *wapp_i32_array_get(const I32Array *array, u64 index) { if (!array || index >= array->count) { return NULL; } - return &(array->items[index]); + u8 *ptr = (u8 *)(array->items) + (array->item_size * index); + return (i32 *)ptr; } -void wapp_i32_array_set(I32Array *array, u64 index, i32 item) { - if (!array || index >= array->count) { +void wapp_i32_array_set(I32Array *array, u64 index, i32 *item) { + i32 *ptr = wapp_i32_array_get(array, index); + if (!ptr) { return; } - array->items[index] = item; + memcpy((void *)ptr, (void *)item, array->item_size); } -void wapp_i32_array_append_capped(I32Array *array, i32 item) { +void wapp_i32_array_append_capped(I32Array *array, i32 *item) { if (!array || array->count >= array->capacity) { return; } - array->items[(array->count)++] = item; + u64 index = (array->count)++; + wapp_i32_array_set(array, index, item); } void wapp_i32_array_extend_capped(I32Array *array, const I32Array *other) { @@ -1753,7 +1584,7 @@ void wapp_i32_array_extend_capped(I32Array *array, const I32Array *other) { continue; } - wapp_i32_array_append_capped(array, *item); + wapp_i32_array_append_capped(array, item); } } @@ -1765,14 +1596,6 @@ void wapp_i32_array_clear(I32Array *array) { array->count = 0; } -i32 wapp_i32_array_pop(I32Array *array) { - if (!array || array->count == 0) { - return (i32){0}; - } - - return array->items[--(array->count)]; -} - void wapp_i32_array_copy_capped(const I32Array *src, I32Array *dst) { if (!src || !dst) { return; @@ -1796,32 +1619,11 @@ void wapp_i32_array_copy_capped(const I32Array *src, I32Array *dst) { continue; } - wapp_i32_array_append_capped(dst, *item); + wapp_i32_array_append_capped(dst, item); } } -I32Array *wapp_i32_array_alloc_capacity(const Allocator *allocator, u64 capacity) { - u64 allocation_size = sizeof(I32Array) + sizeof(i32) * capacity; - I32Array *array = NULL; - - if (!allocator) { - goto RETURN_I32_ARRAY_ALLOC; - } - - array = wapp_mem_allocator_alloc(allocator, allocation_size); - if (!array) { - goto RETURN_I32_ARRAY_ALLOC; - } - - array->items = (i32 *)((u8 *)array + sizeof(I32Array)); - array->count = 0; - array->capacity = capacity; - -RETURN_I32_ARRAY_ALLOC: - return array; -} - -I32Array *wapp_i32_array_append_alloc(const Allocator *allocator, I32Array *array, i32 item) { +I32Array *wapp_i32_array_append_alloc(const Allocator *allocator, I32Array *array, i32 *item) { I32Array *output = array; if (!allocator || !array) { @@ -1830,7 +1632,7 @@ I32Array *wapp_i32_array_append_alloc(const Allocator *allocator, I32Array *arra if (array->count >= array->capacity) { u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(array->capacity * 2); - output = wapp_i32_array_alloc_capacity(allocator, new_capacity); + output = (I32Array *)_array_alloc_capacity(allocator, new_capacity, array->item_size); if (!output) { output = array; goto RETURN_I32_ARRAY_APPEND_ALLOC; @@ -1854,7 +1656,7 @@ I32Array *wapp_i32_array_extend_alloc(const Allocator *allocator, I32Array *arra u64 remaining_capacity = array->capacity - array->count; if (other->count >= remaining_capacity) { u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(array->capacity * 2); - output = wapp_i32_array_alloc_capacity(allocator, new_capacity); + output = (I32Array *)_array_alloc_capacity(allocator, new_capacity, array->item_size); if (!output) { output = array; goto RETURN_I32_ARRAY_EXTEND_ALLOC; @@ -1877,7 +1679,7 @@ I32Array *wapp_i32_array_copy_alloc(const Allocator *allocator, const I32Array * if (src->count >= dst->capacity) { u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(dst->capacity * 2); - output = wapp_i32_array_alloc_capacity(allocator, new_capacity); + output = (I32Array *)_array_alloc_capacity(allocator, new_capacity, src->item_size); if (!output) { output = dst; goto RETURN_I32_ARRAY_COPY_ALLOC; @@ -1891,28 +1693,38 @@ RETURN_I32_ARRAY_COPY_ALLOC: return output; } +i32 *_i32_array_pop(I32Array *array) { + u64 index = array->count - 1; + i32 *out = wapp_i32_array_get(array, index); + --(array->count); + return out; +} + i64 *wapp_i64_array_get(const I64Array *array, u64 index) { if (!array || index >= array->count) { return NULL; } - return &(array->items[index]); + u8 *ptr = (u8 *)(array->items) + (array->item_size * index); + return (i64 *)ptr; } -void wapp_i64_array_set(I64Array *array, u64 index, i64 item) { - if (!array || index >= array->count) { +void wapp_i64_array_set(I64Array *array, u64 index, i64 *item) { + i64 *ptr = wapp_i64_array_get(array, index); + if (!ptr) { return; } - array->items[index] = item; + memcpy((void *)ptr, (void *)item, array->item_size); } -void wapp_i64_array_append_capped(I64Array *array, i64 item) { +void wapp_i64_array_append_capped(I64Array *array, i64 *item) { if (!array || array->count >= array->capacity) { return; } - array->items[(array->count)++] = item; + u64 index = (array->count)++; + wapp_i64_array_set(array, index, item); } void wapp_i64_array_extend_capped(I64Array *array, const I64Array *other) { @@ -1941,7 +1753,7 @@ void wapp_i64_array_extend_capped(I64Array *array, const I64Array *other) { continue; } - wapp_i64_array_append_capped(array, *item); + wapp_i64_array_append_capped(array, item); } } @@ -1953,14 +1765,6 @@ void wapp_i64_array_clear(I64Array *array) { array->count = 0; } -i64 wapp_i64_array_pop(I64Array *array) { - if (!array || array->count == 0) { - return (i64){0}; - } - - return array->items[--(array->count)]; -} - void wapp_i64_array_copy_capped(const I64Array *src, I64Array *dst) { if (!src || !dst) { return; @@ -1984,32 +1788,11 @@ void wapp_i64_array_copy_capped(const I64Array *src, I64Array *dst) { continue; } - wapp_i64_array_append_capped(dst, *item); + wapp_i64_array_append_capped(dst, item); } } -I64Array *wapp_i64_array_alloc_capacity(const Allocator *allocator, u64 capacity) { - u64 allocation_size = sizeof(I64Array) + sizeof(i64) * capacity; - I64Array *array = NULL; - - if (!allocator) { - goto RETURN_I64_ARRAY_ALLOC; - } - - array = wapp_mem_allocator_alloc(allocator, allocation_size); - if (!array) { - goto RETURN_I64_ARRAY_ALLOC; - } - - array->items = (i64 *)((u8 *)array + sizeof(I64Array)); - array->count = 0; - array->capacity = capacity; - -RETURN_I64_ARRAY_ALLOC: - return array; -} - -I64Array *wapp_i64_array_append_alloc(const Allocator *allocator, I64Array *array, i64 item) { +I64Array *wapp_i64_array_append_alloc(const Allocator *allocator, I64Array *array, i64 *item) { I64Array *output = array; if (!allocator || !array) { @@ -2018,7 +1801,7 @@ I64Array *wapp_i64_array_append_alloc(const Allocator *allocator, I64Array *arra if (array->count >= array->capacity) { u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(array->capacity * 2); - output = wapp_i64_array_alloc_capacity(allocator, new_capacity); + output = (I64Array *)_array_alloc_capacity(allocator, new_capacity, array->item_size); if (!output) { output = array; goto RETURN_I64_ARRAY_APPEND_ALLOC; @@ -2042,7 +1825,7 @@ I64Array *wapp_i64_array_extend_alloc(const Allocator *allocator, I64Array *arra u64 remaining_capacity = array->capacity - array->count; if (other->count >= remaining_capacity) { u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(array->capacity * 2); - output = wapp_i64_array_alloc_capacity(allocator, new_capacity); + output = (I64Array *)_array_alloc_capacity(allocator, new_capacity, array->item_size); if (!output) { output = array; goto RETURN_I64_ARRAY_EXTEND_ALLOC; @@ -2065,7 +1848,7 @@ I64Array *wapp_i64_array_copy_alloc(const Allocator *allocator, const I64Array * if (src->count >= dst->capacity) { u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(dst->capacity * 2); - output = wapp_i64_array_alloc_capacity(allocator, new_capacity); + output = (I64Array *)_array_alloc_capacity(allocator, new_capacity, src->item_size); if (!output) { output = dst; goto RETURN_I64_ARRAY_COPY_ALLOC; @@ -2079,28 +1862,38 @@ RETURN_I64_ARRAY_COPY_ALLOC: return output; } +i64 *_i64_array_pop(I64Array *array) { + u64 index = array->count - 1; + i64 *out = wapp_i64_array_get(array, index); + --(array->count); + return out; +} + u8 *wapp_u8_array_get(const U8Array *array, u64 index) { if (!array || index >= array->count) { return NULL; } - return &(array->items[index]); + u8 *ptr = (u8 *)(array->items) + (array->item_size * index); + return (u8 *)ptr; } -void wapp_u8_array_set(U8Array *array, u64 index, u8 item) { - if (!array || index >= array->count) { +void wapp_u8_array_set(U8Array *array, u64 index, u8 *item) { + u8 *ptr = wapp_u8_array_get(array, index); + if (!ptr) { return; } - array->items[index] = item; + memcpy((void *)ptr, (void *)item, array->item_size); } -void wapp_u8_array_append_capped(U8Array *array, u8 item) { +void wapp_u8_array_append_capped(U8Array *array, u8 *item) { if (!array || array->count >= array->capacity) { return; } - array->items[(array->count)++] = item; + u64 index = (array->count)++; + wapp_u8_array_set(array, index, item); } void wapp_u8_array_extend_capped(U8Array *array, const U8Array *other) { @@ -2129,7 +1922,7 @@ void wapp_u8_array_extend_capped(U8Array *array, const U8Array *other) { continue; } - wapp_u8_array_append_capped(array, *item); + wapp_u8_array_append_capped(array, item); } } @@ -2141,14 +1934,6 @@ void wapp_u8_array_clear(U8Array *array) { array->count = 0; } -u8 wapp_u8_array_pop(U8Array *array) { - if (!array || array->count == 0) { - return (u8){0}; - } - - return array->items[--(array->count)]; -} - void wapp_u8_array_copy_capped(const U8Array *src, U8Array *dst) { if (!src || !dst) { return; @@ -2172,32 +1957,11 @@ void wapp_u8_array_copy_capped(const U8Array *src, U8Array *dst) { continue; } - wapp_u8_array_append_capped(dst, *item); + wapp_u8_array_append_capped(dst, item); } } -U8Array *wapp_u8_array_alloc_capacity(const Allocator *allocator, u64 capacity) { - u64 allocation_size = sizeof(U8Array) + sizeof(u8) * capacity; - U8Array *array = NULL; - - if (!allocator) { - goto RETURN_U8_ARRAY_ALLOC; - } - - array = wapp_mem_allocator_alloc(allocator, allocation_size); - if (!array) { - goto RETURN_U8_ARRAY_ALLOC; - } - - array->items = (u8 *)((u8 *)array + sizeof(U8Array)); - array->count = 0; - array->capacity = capacity; - -RETURN_U8_ARRAY_ALLOC: - return array; -} - -U8Array *wapp_u8_array_append_alloc(const Allocator *allocator, U8Array *array, u8 item) { +U8Array *wapp_u8_array_append_alloc(const Allocator *allocator, U8Array *array, u8 *item) { U8Array *output = array; if (!allocator || !array) { @@ -2206,7 +1970,7 @@ U8Array *wapp_u8_array_append_alloc(const Allocator *allocator, U8Array *array, if (array->count >= array->capacity) { u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(array->capacity * 2); - output = wapp_u8_array_alloc_capacity(allocator, new_capacity); + output = (U8Array *)_array_alloc_capacity(allocator, new_capacity, array->item_size); if (!output) { output = array; goto RETURN_U8_ARRAY_APPEND_ALLOC; @@ -2230,7 +1994,7 @@ U8Array *wapp_u8_array_extend_alloc(const Allocator *allocator, U8Array *array, u64 remaining_capacity = array->capacity - array->count; if (other->count >= remaining_capacity) { u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(array->capacity * 2); - output = wapp_u8_array_alloc_capacity(allocator, new_capacity); + output = (U8Array *)_array_alloc_capacity(allocator, new_capacity, array->item_size); if (!output) { output = array; goto RETURN_U8_ARRAY_EXTEND_ALLOC; @@ -2253,7 +2017,7 @@ U8Array *wapp_u8_array_copy_alloc(const Allocator *allocator, const U8Array *src if (src->count >= dst->capacity) { u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(dst->capacity * 2); - output = wapp_u8_array_alloc_capacity(allocator, new_capacity); + output = (U8Array *)_array_alloc_capacity(allocator, new_capacity, src->item_size); if (!output) { output = dst; goto RETURN_U8_ARRAY_COPY_ALLOC; @@ -2267,28 +2031,38 @@ RETURN_U8_ARRAY_COPY_ALLOC: return output; } +u8 *_u8_array_pop(U8Array *array) { + u64 index = array->count - 1; + u8 *out = wapp_u8_array_get(array, index); + --(array->count); + return out; +} + u16 *wapp_u16_array_get(const U16Array *array, u64 index) { if (!array || index >= array->count) { return NULL; } - return &(array->items[index]); + u8 *ptr = (u8 *)(array->items) + (array->item_size * index); + return (u16 *)ptr; } -void wapp_u16_array_set(U16Array *array, u64 index, u16 item) { - if (!array || index >= array->count) { +void wapp_u16_array_set(U16Array *array, u64 index, u16 *item) { + u16 *ptr = wapp_u16_array_get(array, index); + if (!ptr) { return; } - array->items[index] = item; + memcpy((void *)ptr, (void *)item, array->item_size); } -void wapp_u16_array_append_capped(U16Array *array, u16 item) { +void wapp_u16_array_append_capped(U16Array *array, u16 *item) { if (!array || array->count >= array->capacity) { return; } - array->items[(array->count)++] = item; + u64 index = (array->count)++; + wapp_u16_array_set(array, index, item); } void wapp_u16_array_extend_capped(U16Array *array, const U16Array *other) { @@ -2317,7 +2091,7 @@ void wapp_u16_array_extend_capped(U16Array *array, const U16Array *other) { continue; } - wapp_u16_array_append_capped(array, *item); + wapp_u16_array_append_capped(array, item); } } @@ -2329,14 +2103,6 @@ void wapp_u16_array_clear(U16Array *array) { array->count = 0; } -u16 wapp_u16_array_pop(U16Array *array) { - if (!array || array->count == 0) { - return (u16){0}; - } - - return array->items[--(array->count)]; -} - void wapp_u16_array_copy_capped(const U16Array *src, U16Array *dst) { if (!src || !dst) { return; @@ -2360,32 +2126,11 @@ void wapp_u16_array_copy_capped(const U16Array *src, U16Array *dst) { continue; } - wapp_u16_array_append_capped(dst, *item); + wapp_u16_array_append_capped(dst, item); } } -U16Array *wapp_u16_array_alloc_capacity(const Allocator *allocator, u64 capacity) { - u64 allocation_size = sizeof(U16Array) + sizeof(u16) * capacity; - U16Array *array = NULL; - - if (!allocator) { - goto RETURN_U16_ARRAY_ALLOC; - } - - array = wapp_mem_allocator_alloc(allocator, allocation_size); - if (!array) { - goto RETURN_U16_ARRAY_ALLOC; - } - - array->items = (u16 *)((u8 *)array + sizeof(U16Array)); - array->count = 0; - array->capacity = capacity; - -RETURN_U16_ARRAY_ALLOC: - return array; -} - -U16Array *wapp_u16_array_append_alloc(const Allocator *allocator, U16Array *array, u16 item) { +U16Array *wapp_u16_array_append_alloc(const Allocator *allocator, U16Array *array, u16 *item) { U16Array *output = array; if (!allocator || !array) { @@ -2394,7 +2139,7 @@ U16Array *wapp_u16_array_append_alloc(const Allocator *allocator, U16Array *arra if (array->count >= array->capacity) { u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(array->capacity * 2); - output = wapp_u16_array_alloc_capacity(allocator, new_capacity); + output = (U16Array *)_array_alloc_capacity(allocator, new_capacity, array->item_size); if (!output) { output = array; goto RETURN_U16_ARRAY_APPEND_ALLOC; @@ -2418,7 +2163,7 @@ U16Array *wapp_u16_array_extend_alloc(const Allocator *allocator, U16Array *arra u64 remaining_capacity = array->capacity - array->count; if (other->count >= remaining_capacity) { u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(array->capacity * 2); - output = wapp_u16_array_alloc_capacity(allocator, new_capacity); + output = (U16Array *)_array_alloc_capacity(allocator, new_capacity, array->item_size); if (!output) { output = array; goto RETURN_U16_ARRAY_EXTEND_ALLOC; @@ -2441,7 +2186,7 @@ U16Array *wapp_u16_array_copy_alloc(const Allocator *allocator, const U16Array * if (src->count >= dst->capacity) { u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(dst->capacity * 2); - output = wapp_u16_array_alloc_capacity(allocator, new_capacity); + output = (U16Array *)_array_alloc_capacity(allocator, new_capacity, src->item_size); if (!output) { output = dst; goto RETURN_U16_ARRAY_COPY_ALLOC; @@ -2455,28 +2200,38 @@ RETURN_U16_ARRAY_COPY_ALLOC: return output; } +u16 *_u16_array_pop(U16Array *array) { + u64 index = array->count - 1; + u16 *out = wapp_u16_array_get(array, index); + --(array->count); + return out; +} + u32 *wapp_u32_array_get(const U32Array *array, u64 index) { if (!array || index >= array->count) { return NULL; } - return &(array->items[index]); + u8 *ptr = (u8 *)(array->items) + (array->item_size * index); + return (u32 *)ptr; } -void wapp_u32_array_set(U32Array *array, u64 index, u32 item) { - if (!array || index >= array->count) { +void wapp_u32_array_set(U32Array *array, u64 index, u32 *item) { + u32 *ptr = wapp_u32_array_get(array, index); + if (!ptr) { return; } - array->items[index] = item; + memcpy((void *)ptr, (void *)item, array->item_size); } -void wapp_u32_array_append_capped(U32Array *array, u32 item) { +void wapp_u32_array_append_capped(U32Array *array, u32 *item) { if (!array || array->count >= array->capacity) { return; } - array->items[(array->count)++] = item; + u64 index = (array->count)++; + wapp_u32_array_set(array, index, item); } void wapp_u32_array_extend_capped(U32Array *array, const U32Array *other) { @@ -2505,7 +2260,7 @@ void wapp_u32_array_extend_capped(U32Array *array, const U32Array *other) { continue; } - wapp_u32_array_append_capped(array, *item); + wapp_u32_array_append_capped(array, item); } } @@ -2517,14 +2272,6 @@ void wapp_u32_array_clear(U32Array *array) { array->count = 0; } -u32 wapp_u32_array_pop(U32Array *array) { - if (!array || array->count == 0) { - return (u32){0}; - } - - return array->items[--(array->count)]; -} - void wapp_u32_array_copy_capped(const U32Array *src, U32Array *dst) { if (!src || !dst) { return; @@ -2548,32 +2295,11 @@ void wapp_u32_array_copy_capped(const U32Array *src, U32Array *dst) { continue; } - wapp_u32_array_append_capped(dst, *item); + wapp_u32_array_append_capped(dst, item); } } -U32Array *wapp_u32_array_alloc_capacity(const Allocator *allocator, u64 capacity) { - u64 allocation_size = sizeof(U32Array) + sizeof(u32) * capacity; - U32Array *array = NULL; - - if (!allocator) { - goto RETURN_U32_ARRAY_ALLOC; - } - - array = wapp_mem_allocator_alloc(allocator, allocation_size); - if (!array) { - goto RETURN_U32_ARRAY_ALLOC; - } - - array->items = (u32 *)((u8 *)array + sizeof(U32Array)); - array->count = 0; - array->capacity = capacity; - -RETURN_U32_ARRAY_ALLOC: - return array; -} - -U32Array *wapp_u32_array_append_alloc(const Allocator *allocator, U32Array *array, u32 item) { +U32Array *wapp_u32_array_append_alloc(const Allocator *allocator, U32Array *array, u32 *item) { U32Array *output = array; if (!allocator || !array) { @@ -2582,7 +2308,7 @@ U32Array *wapp_u32_array_append_alloc(const Allocator *allocator, U32Array *arra if (array->count >= array->capacity) { u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(array->capacity * 2); - output = wapp_u32_array_alloc_capacity(allocator, new_capacity); + output = (U32Array *)_array_alloc_capacity(allocator, new_capacity, array->item_size); if (!output) { output = array; goto RETURN_U32_ARRAY_APPEND_ALLOC; @@ -2606,7 +2332,7 @@ U32Array *wapp_u32_array_extend_alloc(const Allocator *allocator, U32Array *arra u64 remaining_capacity = array->capacity - array->count; if (other->count >= remaining_capacity) { u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(array->capacity * 2); - output = wapp_u32_array_alloc_capacity(allocator, new_capacity); + output = (U32Array *)_array_alloc_capacity(allocator, new_capacity, array->item_size); if (!output) { output = array; goto RETURN_U32_ARRAY_EXTEND_ALLOC; @@ -2629,7 +2355,7 @@ U32Array *wapp_u32_array_copy_alloc(const Allocator *allocator, const U32Array * if (src->count >= dst->capacity) { u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(dst->capacity * 2); - output = wapp_u32_array_alloc_capacity(allocator, new_capacity); + output = (U32Array *)_array_alloc_capacity(allocator, new_capacity, src->item_size); if (!output) { output = dst; goto RETURN_U32_ARRAY_COPY_ALLOC; @@ -2643,28 +2369,38 @@ RETURN_U32_ARRAY_COPY_ALLOC: return output; } +u32 *_u32_array_pop(U32Array *array) { + u64 index = array->count - 1; + u32 *out = wapp_u32_array_get(array, index); + --(array->count); + return out; +} + u64 *wapp_u64_array_get(const U64Array *array, u64 index) { if (!array || index >= array->count) { return NULL; } - return &(array->items[index]); + u8 *ptr = (u8 *)(array->items) + (array->item_size * index); + return (u64 *)ptr; } -void wapp_u64_array_set(U64Array *array, u64 index, u64 item) { - if (!array || index >= array->count) { +void wapp_u64_array_set(U64Array *array, u64 index, u64 *item) { + u64 *ptr = wapp_u64_array_get(array, index); + if (!ptr) { return; } - array->items[index] = item; + memcpy((void *)ptr, (void *)item, array->item_size); } -void wapp_u64_array_append_capped(U64Array *array, u64 item) { +void wapp_u64_array_append_capped(U64Array *array, u64 *item) { if (!array || array->count >= array->capacity) { return; } - array->items[(array->count)++] = item; + u64 index = (array->count)++; + wapp_u64_array_set(array, index, item); } void wapp_u64_array_extend_capped(U64Array *array, const U64Array *other) { @@ -2693,7 +2429,7 @@ void wapp_u64_array_extend_capped(U64Array *array, const U64Array *other) { continue; } - wapp_u64_array_append_capped(array, *item); + wapp_u64_array_append_capped(array, item); } } @@ -2705,14 +2441,6 @@ void wapp_u64_array_clear(U64Array *array) { array->count = 0; } -u64 wapp_u64_array_pop(U64Array *array) { - if (!array || array->count == 0) { - return (u64){0}; - } - - return array->items[--(array->count)]; -} - void wapp_u64_array_copy_capped(const U64Array *src, U64Array *dst) { if (!src || !dst) { return; @@ -2736,32 +2464,11 @@ void wapp_u64_array_copy_capped(const U64Array *src, U64Array *dst) { continue; } - wapp_u64_array_append_capped(dst, *item); + wapp_u64_array_append_capped(dst, item); } } -U64Array *wapp_u64_array_alloc_capacity(const Allocator *allocator, u64 capacity) { - u64 allocation_size = sizeof(U64Array) + sizeof(u64) * capacity; - U64Array *array = NULL; - - if (!allocator) { - goto RETURN_U64_ARRAY_ALLOC; - } - - array = wapp_mem_allocator_alloc(allocator, allocation_size); - if (!array) { - goto RETURN_U64_ARRAY_ALLOC; - } - - array->items = (u64 *)((u8 *)array + sizeof(U64Array)); - array->count = 0; - array->capacity = capacity; - -RETURN_U64_ARRAY_ALLOC: - return array; -} - -U64Array *wapp_u64_array_append_alloc(const Allocator *allocator, U64Array *array, u64 item) { +U64Array *wapp_u64_array_append_alloc(const Allocator *allocator, U64Array *array, u64 *item) { U64Array *output = array; if (!allocator || !array) { @@ -2770,7 +2477,7 @@ U64Array *wapp_u64_array_append_alloc(const Allocator *allocator, U64Array *arra if (array->count >= array->capacity) { u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(array->capacity * 2); - output = wapp_u64_array_alloc_capacity(allocator, new_capacity); + output = (U64Array *)_array_alloc_capacity(allocator, new_capacity, array->item_size); if (!output) { output = array; goto RETURN_U64_ARRAY_APPEND_ALLOC; @@ -2794,7 +2501,7 @@ U64Array *wapp_u64_array_extend_alloc(const Allocator *allocator, U64Array *arra u64 remaining_capacity = array->capacity - array->count; if (other->count >= remaining_capacity) { u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(array->capacity * 2); - output = wapp_u64_array_alloc_capacity(allocator, new_capacity); + output = (U64Array *)_array_alloc_capacity(allocator, new_capacity, array->item_size); if (!output) { output = array; goto RETURN_U64_ARRAY_EXTEND_ALLOC; @@ -2817,7 +2524,7 @@ U64Array *wapp_u64_array_copy_alloc(const Allocator *allocator, const U64Array * if (src->count >= dst->capacity) { u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(dst->capacity * 2); - output = wapp_u64_array_alloc_capacity(allocator, new_capacity); + output = (U64Array *)_array_alloc_capacity(allocator, new_capacity, src->item_size); if (!output) { output = dst; goto RETURN_U64_ARRAY_COPY_ALLOC; @@ -2831,28 +2538,38 @@ RETURN_U64_ARRAY_COPY_ALLOC: return output; } +u64 *_u64_array_pop(U64Array *array) { + u64 index = array->count - 1; + u64 *out = wapp_u64_array_get(array, index); + --(array->count); + return out; +} + f32 *wapp_f32_array_get(const F32Array *array, u64 index) { if (!array || index >= array->count) { return NULL; } - return &(array->items[index]); + u8 *ptr = (u8 *)(array->items) + (array->item_size * index); + return (f32 *)ptr; } -void wapp_f32_array_set(F32Array *array, u64 index, f32 item) { - if (!array || index >= array->count) { +void wapp_f32_array_set(F32Array *array, u64 index, f32 *item) { + f32 *ptr = wapp_f32_array_get(array, index); + if (!ptr) { return; } - array->items[index] = item; + memcpy((void *)ptr, (void *)item, array->item_size); } -void wapp_f32_array_append_capped(F32Array *array, f32 item) { +void wapp_f32_array_append_capped(F32Array *array, f32 *item) { if (!array || array->count >= array->capacity) { return; } - array->items[(array->count)++] = item; + u64 index = (array->count)++; + wapp_f32_array_set(array, index, item); } void wapp_f32_array_extend_capped(F32Array *array, const F32Array *other) { @@ -2881,7 +2598,7 @@ void wapp_f32_array_extend_capped(F32Array *array, const F32Array *other) { continue; } - wapp_f32_array_append_capped(array, *item); + wapp_f32_array_append_capped(array, item); } } @@ -2893,14 +2610,6 @@ void wapp_f32_array_clear(F32Array *array) { array->count = 0; } -f32 wapp_f32_array_pop(F32Array *array) { - if (!array || array->count == 0) { - return (f32){0}; - } - - return array->items[--(array->count)]; -} - void wapp_f32_array_copy_capped(const F32Array *src, F32Array *dst) { if (!src || !dst) { return; @@ -2924,32 +2633,11 @@ void wapp_f32_array_copy_capped(const F32Array *src, F32Array *dst) { continue; } - wapp_f32_array_append_capped(dst, *item); + wapp_f32_array_append_capped(dst, item); } } -F32Array *wapp_f32_array_alloc_capacity(const Allocator *allocator, u64 capacity) { - u64 allocation_size = sizeof(F32Array) + sizeof(f32) * capacity; - F32Array *array = NULL; - - if (!allocator) { - goto RETURN_F32_ARRAY_ALLOC; - } - - array = wapp_mem_allocator_alloc(allocator, allocation_size); - if (!array) { - goto RETURN_F32_ARRAY_ALLOC; - } - - array->items = (f32 *)((u8 *)array + sizeof(F32Array)); - array->count = 0; - array->capacity = capacity; - -RETURN_F32_ARRAY_ALLOC: - return array; -} - -F32Array *wapp_f32_array_append_alloc(const Allocator *allocator, F32Array *array, f32 item) { +F32Array *wapp_f32_array_append_alloc(const Allocator *allocator, F32Array *array, f32 *item) { F32Array *output = array; if (!allocator || !array) { @@ -2958,7 +2646,7 @@ F32Array *wapp_f32_array_append_alloc(const Allocator *allocator, F32Array *arra if (array->count >= array->capacity) { u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(array->capacity * 2); - output = wapp_f32_array_alloc_capacity(allocator, new_capacity); + output = (F32Array *)_array_alloc_capacity(allocator, new_capacity, array->item_size); if (!output) { output = array; goto RETURN_F32_ARRAY_APPEND_ALLOC; @@ -2982,7 +2670,7 @@ F32Array *wapp_f32_array_extend_alloc(const Allocator *allocator, F32Array *arra u64 remaining_capacity = array->capacity - array->count; if (other->count >= remaining_capacity) { u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(array->capacity * 2); - output = wapp_f32_array_alloc_capacity(allocator, new_capacity); + output = (F32Array *)_array_alloc_capacity(allocator, new_capacity, array->item_size); if (!output) { output = array; goto RETURN_F32_ARRAY_EXTEND_ALLOC; @@ -3005,7 +2693,7 @@ F32Array *wapp_f32_array_copy_alloc(const Allocator *allocator, const F32Array * if (src->count >= dst->capacity) { u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(dst->capacity * 2); - output = wapp_f32_array_alloc_capacity(allocator, new_capacity); + output = (F32Array *)_array_alloc_capacity(allocator, new_capacity, src->item_size); if (!output) { output = dst; goto RETURN_F32_ARRAY_COPY_ALLOC; @@ -3019,28 +2707,38 @@ RETURN_F32_ARRAY_COPY_ALLOC: return output; } +f32 *_f32_array_pop(F32Array *array) { + u64 index = array->count - 1; + f32 *out = wapp_f32_array_get(array, index); + --(array->count); + return out; +} + f64 *wapp_f64_array_get(const F64Array *array, u64 index) { if (!array || index >= array->count) { return NULL; } - return &(array->items[index]); + u8 *ptr = (u8 *)(array->items) + (array->item_size * index); + return (f64 *)ptr; } -void wapp_f64_array_set(F64Array *array, u64 index, f64 item) { - if (!array || index >= array->count) { +void wapp_f64_array_set(F64Array *array, u64 index, f64 *item) { + f64 *ptr = wapp_f64_array_get(array, index); + if (!ptr) { return; } - array->items[index] = item; + memcpy((void *)ptr, (void *)item, array->item_size); } -void wapp_f64_array_append_capped(F64Array *array, f64 item) { +void wapp_f64_array_append_capped(F64Array *array, f64 *item) { if (!array || array->count >= array->capacity) { return; } - array->items[(array->count)++] = item; + u64 index = (array->count)++; + wapp_f64_array_set(array, index, item); } void wapp_f64_array_extend_capped(F64Array *array, const F64Array *other) { @@ -3069,7 +2767,7 @@ void wapp_f64_array_extend_capped(F64Array *array, const F64Array *other) { continue; } - wapp_f64_array_append_capped(array, *item); + wapp_f64_array_append_capped(array, item); } } @@ -3081,14 +2779,6 @@ void wapp_f64_array_clear(F64Array *array) { array->count = 0; } -f64 wapp_f64_array_pop(F64Array *array) { - if (!array || array->count == 0) { - return (f64){0}; - } - - return array->items[--(array->count)]; -} - void wapp_f64_array_copy_capped(const F64Array *src, F64Array *dst) { if (!src || !dst) { return; @@ -3112,32 +2802,11 @@ void wapp_f64_array_copy_capped(const F64Array *src, F64Array *dst) { continue; } - wapp_f64_array_append_capped(dst, *item); + wapp_f64_array_append_capped(dst, item); } } -F64Array *wapp_f64_array_alloc_capacity(const Allocator *allocator, u64 capacity) { - u64 allocation_size = sizeof(F64Array) + sizeof(f64) * capacity; - F64Array *array = NULL; - - if (!allocator) { - goto RETURN_F64_ARRAY_ALLOC; - } - - array = wapp_mem_allocator_alloc(allocator, allocation_size); - if (!array) { - goto RETURN_F64_ARRAY_ALLOC; - } - - array->items = (f64 *)((u8 *)array + sizeof(F64Array)); - array->count = 0; - array->capacity = capacity; - -RETURN_F64_ARRAY_ALLOC: - return array; -} - -F64Array *wapp_f64_array_append_alloc(const Allocator *allocator, F64Array *array, f64 item) { +F64Array *wapp_f64_array_append_alloc(const Allocator *allocator, F64Array *array, f64 *item) { F64Array *output = array; if (!allocator || !array) { @@ -3146,7 +2815,7 @@ F64Array *wapp_f64_array_append_alloc(const Allocator *allocator, F64Array *arra if (array->count >= array->capacity) { u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(array->capacity * 2); - output = wapp_f64_array_alloc_capacity(allocator, new_capacity); + output = (F64Array *)_array_alloc_capacity(allocator, new_capacity, array->item_size); if (!output) { output = array; goto RETURN_F64_ARRAY_APPEND_ALLOC; @@ -3170,7 +2839,7 @@ F64Array *wapp_f64_array_extend_alloc(const Allocator *allocator, F64Array *arra u64 remaining_capacity = array->capacity - array->count; if (other->count >= remaining_capacity) { u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(array->capacity * 2); - output = wapp_f64_array_alloc_capacity(allocator, new_capacity); + output = (F64Array *)_array_alloc_capacity(allocator, new_capacity, array->item_size); if (!output) { output = array; goto RETURN_F64_ARRAY_EXTEND_ALLOC; @@ -3193,7 +2862,7 @@ F64Array *wapp_f64_array_copy_alloc(const Allocator *allocator, const F64Array * if (src->count >= dst->capacity) { u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(dst->capacity * 2); - output = wapp_f64_array_alloc_capacity(allocator, new_capacity); + output = (F64Array *)_array_alloc_capacity(allocator, new_capacity, src->item_size); if (!output) { output = dst; goto RETURN_F64_ARRAY_COPY_ALLOC; @@ -3207,28 +2876,38 @@ RETURN_F64_ARRAY_COPY_ALLOC: return output; } +f64 *_f64_array_pop(F64Array *array) { + u64 index = array->count - 1; + f64 *out = wapp_f64_array_get(array, index); + --(array->count); + return out; +} + f128 *wapp_f128_array_get(const F128Array *array, u64 index) { if (!array || index >= array->count) { return NULL; } - return &(array->items[index]); + u8 *ptr = (u8 *)(array->items) + (array->item_size * index); + return (f128 *)ptr; } -void wapp_f128_array_set(F128Array *array, u64 index, f128 item) { - if (!array || index >= array->count) { +void wapp_f128_array_set(F128Array *array, u64 index, f128 *item) { + f128 *ptr = wapp_f128_array_get(array, index); + if (!ptr) { return; } - array->items[index] = item; + memcpy((void *)ptr, (void *)item, array->item_size); } -void wapp_f128_array_append_capped(F128Array *array, f128 item) { +void wapp_f128_array_append_capped(F128Array *array, f128 *item) { if (!array || array->count >= array->capacity) { return; } - array->items[(array->count)++] = item; + u64 index = (array->count)++; + wapp_f128_array_set(array, index, item); } void wapp_f128_array_extend_capped(F128Array *array, const F128Array *other) { @@ -3257,7 +2936,7 @@ void wapp_f128_array_extend_capped(F128Array *array, const F128Array *other) { continue; } - wapp_f128_array_append_capped(array, *item); + wapp_f128_array_append_capped(array, item); } } @@ -3269,14 +2948,6 @@ void wapp_f128_array_clear(F128Array *array) { array->count = 0; } -f128 wapp_f128_array_pop(F128Array *array) { - if (!array || array->count == 0) { - return (f128){0}; - } - - return array->items[--(array->count)]; -} - void wapp_f128_array_copy_capped(const F128Array *src, F128Array *dst) { if (!src || !dst) { return; @@ -3300,32 +2971,11 @@ void wapp_f128_array_copy_capped(const F128Array *src, F128Array *dst) { continue; } - wapp_f128_array_append_capped(dst, *item); + wapp_f128_array_append_capped(dst, item); } } -F128Array *wapp_f128_array_alloc_capacity(const Allocator *allocator, u64 capacity) { - u64 allocation_size = sizeof(F128Array) + sizeof(f128) * capacity; - F128Array *array = NULL; - - if (!allocator) { - goto RETURN_F128_ARRAY_ALLOC; - } - - array = wapp_mem_allocator_alloc(allocator, allocation_size); - if (!array) { - goto RETURN_F128_ARRAY_ALLOC; - } - - array->items = (f128 *)((u8 *)array + sizeof(F128Array)); - array->count = 0; - array->capacity = capacity; - -RETURN_F128_ARRAY_ALLOC: - return array; -} - -F128Array *wapp_f128_array_append_alloc(const Allocator *allocator, F128Array *array, f128 item) { +F128Array *wapp_f128_array_append_alloc(const Allocator *allocator, F128Array *array, f128 *item) { F128Array *output = array; if (!allocator || !array) { @@ -3334,7 +2984,7 @@ F128Array *wapp_f128_array_append_alloc(const Allocator *allocator, F128Array *a if (array->count >= array->capacity) { u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(array->capacity * 2); - output = wapp_f128_array_alloc_capacity(allocator, new_capacity); + output = (F128Array *)_array_alloc_capacity(allocator, new_capacity, array->item_size); if (!output) { output = array; goto RETURN_F128_ARRAY_APPEND_ALLOC; @@ -3358,7 +3008,7 @@ F128Array *wapp_f128_array_extend_alloc(const Allocator *allocator, F128Array *a u64 remaining_capacity = array->capacity - array->count; if (other->count >= remaining_capacity) { u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(array->capacity * 2); - output = wapp_f128_array_alloc_capacity(allocator, new_capacity); + output = (F128Array *)_array_alloc_capacity(allocator, new_capacity, array->item_size); if (!output) { output = array; goto RETURN_F128_ARRAY_EXTEND_ALLOC; @@ -3381,7 +3031,7 @@ F128Array *wapp_f128_array_copy_alloc(const Allocator *allocator, const F128Arra if (src->count >= dst->capacity) { u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(dst->capacity * 2); - output = wapp_f128_array_alloc_capacity(allocator, new_capacity); + output = (F128Array *)_array_alloc_capacity(allocator, new_capacity, src->item_size); if (!output) { output = dst; goto RETURN_F128_ARRAY_COPY_ALLOC; @@ -3395,28 +3045,38 @@ RETURN_F128_ARRAY_COPY_ALLOC: return output; } +f128 *_f128_array_pop(F128Array *array) { + u64 index = array->count - 1; + f128 *out = wapp_f128_array_get(array, index); + --(array->count); + return out; +} + iptr *wapp_iptr_array_get(const IptrArray *array, u64 index) { if (!array || index >= array->count) { return NULL; } - return &(array->items[index]); + u8 *ptr = (u8 *)(array->items) + (array->item_size * index); + return (iptr *)ptr; } -void wapp_iptr_array_set(IptrArray *array, u64 index, iptr item) { - if (!array || index >= array->count) { +void wapp_iptr_array_set(IptrArray *array, u64 index, iptr *item) { + iptr *ptr = wapp_iptr_array_get(array, index); + if (!ptr) { return; } - array->items[index] = item; + memcpy((void *)ptr, (void *)item, array->item_size); } -void wapp_iptr_array_append_capped(IptrArray *array, iptr item) { +void wapp_iptr_array_append_capped(IptrArray *array, iptr *item) { if (!array || array->count >= array->capacity) { return; } - array->items[(array->count)++] = item; + u64 index = (array->count)++; + wapp_iptr_array_set(array, index, item); } void wapp_iptr_array_extend_capped(IptrArray *array, const IptrArray *other) { @@ -3445,7 +3105,7 @@ void wapp_iptr_array_extend_capped(IptrArray *array, const IptrArray *other) { continue; } - wapp_iptr_array_append_capped(array, *item); + wapp_iptr_array_append_capped(array, item); } } @@ -3457,14 +3117,6 @@ void wapp_iptr_array_clear(IptrArray *array) { array->count = 0; } -iptr wapp_iptr_array_pop(IptrArray *array) { - if (!array || array->count == 0) { - return (iptr){0}; - } - - return array->items[--(array->count)]; -} - void wapp_iptr_array_copy_capped(const IptrArray *src, IptrArray *dst) { if (!src || !dst) { return; @@ -3488,32 +3140,11 @@ void wapp_iptr_array_copy_capped(const IptrArray *src, IptrArray *dst) { continue; } - wapp_iptr_array_append_capped(dst, *item); + wapp_iptr_array_append_capped(dst, item); } } -IptrArray *wapp_iptr_array_alloc_capacity(const Allocator *allocator, u64 capacity) { - u64 allocation_size = sizeof(IptrArray) + sizeof(iptr) * capacity; - IptrArray *array = NULL; - - if (!allocator) { - goto RETURN_IPTR_ARRAY_ALLOC; - } - - array = wapp_mem_allocator_alloc(allocator, allocation_size); - if (!array) { - goto RETURN_IPTR_ARRAY_ALLOC; - } - - array->items = (iptr *)((u8 *)array + sizeof(IptrArray)); - array->count = 0; - array->capacity = capacity; - -RETURN_IPTR_ARRAY_ALLOC: - return array; -} - -IptrArray *wapp_iptr_array_append_alloc(const Allocator *allocator, IptrArray *array, iptr item) { +IptrArray *wapp_iptr_array_append_alloc(const Allocator *allocator, IptrArray *array, iptr *item) { IptrArray *output = array; if (!allocator || !array) { @@ -3522,7 +3153,7 @@ IptrArray *wapp_iptr_array_append_alloc(const Allocator *allocator, IptrArray *a if (array->count >= array->capacity) { u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(array->capacity * 2); - output = wapp_iptr_array_alloc_capacity(allocator, new_capacity); + output = (IptrArray *)_array_alloc_capacity(allocator, new_capacity, array->item_size); if (!output) { output = array; goto RETURN_IPTR_ARRAY_APPEND_ALLOC; @@ -3546,7 +3177,7 @@ IptrArray *wapp_iptr_array_extend_alloc(const Allocator *allocator, IptrArray *a u64 remaining_capacity = array->capacity - array->count; if (other->count >= remaining_capacity) { u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(array->capacity * 2); - output = wapp_iptr_array_alloc_capacity(allocator, new_capacity); + output = (IptrArray *)_array_alloc_capacity(allocator, new_capacity, array->item_size); if (!output) { output = array; goto RETURN_IPTR_ARRAY_EXTEND_ALLOC; @@ -3569,7 +3200,7 @@ IptrArray *wapp_iptr_array_copy_alloc(const Allocator *allocator, const IptrArra if (src->count >= dst->capacity) { u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(dst->capacity * 2); - output = wapp_iptr_array_alloc_capacity(allocator, new_capacity); + output = (IptrArray *)_array_alloc_capacity(allocator, new_capacity, src->item_size); if (!output) { output = dst; goto RETURN_IPTR_ARRAY_COPY_ALLOC; @@ -3583,28 +3214,38 @@ RETURN_IPTR_ARRAY_COPY_ALLOC: return output; } +iptr *_iptr_array_pop(IptrArray *array) { + u64 index = array->count - 1; + iptr *out = wapp_iptr_array_get(array, index); + --(array->count); + return out; +} + uptr *wapp_uptr_array_get(const UptrArray *array, u64 index) { if (!array || index >= array->count) { return NULL; } - return &(array->items[index]); + u8 *ptr = (u8 *)(array->items) + (array->item_size * index); + return (uptr *)ptr; } -void wapp_uptr_array_set(UptrArray *array, u64 index, uptr item) { - if (!array || index >= array->count) { +void wapp_uptr_array_set(UptrArray *array, u64 index, uptr *item) { + uptr *ptr = wapp_uptr_array_get(array, index); + if (!ptr) { return; } - array->items[index] = item; + memcpy((void *)ptr, (void *)item, array->item_size); } -void wapp_uptr_array_append_capped(UptrArray *array, uptr item) { +void wapp_uptr_array_append_capped(UptrArray *array, uptr *item) { if (!array || array->count >= array->capacity) { return; } - array->items[(array->count)++] = item; + u64 index = (array->count)++; + wapp_uptr_array_set(array, index, item); } void wapp_uptr_array_extend_capped(UptrArray *array, const UptrArray *other) { @@ -3633,7 +3274,7 @@ void wapp_uptr_array_extend_capped(UptrArray *array, const UptrArray *other) { continue; } - wapp_uptr_array_append_capped(array, *item); + wapp_uptr_array_append_capped(array, item); } } @@ -3645,14 +3286,6 @@ void wapp_uptr_array_clear(UptrArray *array) { array->count = 0; } -uptr wapp_uptr_array_pop(UptrArray *array) { - if (!array || array->count == 0) { - return (uptr){0}; - } - - return array->items[--(array->count)]; -} - void wapp_uptr_array_copy_capped(const UptrArray *src, UptrArray *dst) { if (!src || !dst) { return; @@ -3676,32 +3309,11 @@ void wapp_uptr_array_copy_capped(const UptrArray *src, UptrArray *dst) { continue; } - wapp_uptr_array_append_capped(dst, *item); + wapp_uptr_array_append_capped(dst, item); } } -UptrArray *wapp_uptr_array_alloc_capacity(const Allocator *allocator, u64 capacity) { - u64 allocation_size = sizeof(UptrArray) + sizeof(uptr) * capacity; - UptrArray *array = NULL; - - if (!allocator) { - goto RETURN_UPTR_ARRAY_ALLOC; - } - - array = wapp_mem_allocator_alloc(allocator, allocation_size); - if (!array) { - goto RETURN_UPTR_ARRAY_ALLOC; - } - - array->items = (uptr *)((u8 *)array + sizeof(UptrArray)); - array->count = 0; - array->capacity = capacity; - -RETURN_UPTR_ARRAY_ALLOC: - return array; -} - -UptrArray *wapp_uptr_array_append_alloc(const Allocator *allocator, UptrArray *array, uptr item) { +UptrArray *wapp_uptr_array_append_alloc(const Allocator *allocator, UptrArray *array, uptr *item) { UptrArray *output = array; if (!allocator || !array) { @@ -3710,7 +3322,7 @@ UptrArray *wapp_uptr_array_append_alloc(const Allocator *allocator, UptrArray *a if (array->count >= array->capacity) { u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(array->capacity * 2); - output = wapp_uptr_array_alloc_capacity(allocator, new_capacity); + output = (UptrArray *)_array_alloc_capacity(allocator, new_capacity, array->item_size); if (!output) { output = array; goto RETURN_UPTR_ARRAY_APPEND_ALLOC; @@ -3734,7 +3346,7 @@ UptrArray *wapp_uptr_array_extend_alloc(const Allocator *allocator, UptrArray *a u64 remaining_capacity = array->capacity - array->count; if (other->count >= remaining_capacity) { u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(array->capacity * 2); - output = wapp_uptr_array_alloc_capacity(allocator, new_capacity); + output = (UptrArray *)_array_alloc_capacity(allocator, new_capacity, array->item_size); if (!output) { output = array; goto RETURN_UPTR_ARRAY_EXTEND_ALLOC; @@ -3757,7 +3369,7 @@ UptrArray *wapp_uptr_array_copy_alloc(const Allocator *allocator, const UptrArra if (src->count >= dst->capacity) { u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(dst->capacity * 2); - output = wapp_uptr_array_alloc_capacity(allocator, new_capacity); + output = (UptrArray *)_array_alloc_capacity(allocator, new_capacity, src->item_size); if (!output) { output = dst; goto RETURN_UPTR_ARRAY_COPY_ALLOC; @@ -3771,3 +3383,32 @@ RETURN_UPTR_ARRAY_COPY_ALLOC: return output; } +uptr *_uptr_array_pop(UptrArray *array) { + u64 index = array->count - 1; + uptr *out = wapp_uptr_array_get(array, index); + --(array->count); + return out; +} + +VoidPArray *_array_alloc_capacity(const Allocator *allocator, u64 capacity, u64 item_size) { + u64 allocation_size = sizeof(VoidPArray) + item_size * capacity; + VoidPArray *array = NULL; + + if (!allocator) { + goto RETURN_GENERIC_ARRAY_ALLOC; + } + + array = wapp_mem_allocator_alloc(allocator, allocation_size); + if (!array) { + goto RETURN_GENERIC_ARRAY_ALLOC; + } + + array->items = (void * *)((u8 *)array + sizeof(VoidPArray)); + array->count = 0; + array->capacity = capacity; + array->item_size = item_size; + +RETURN_GENERIC_ARRAY_ALLOC: + return array; +} + diff --git a/src/primitives/array/array.h b/src/primitives/array/array.h index ce2b48f..c4efc2a 100644 --- a/src/primitives/array/array.h +++ b/src/primitives/array/array.h @@ -6,7 +6,6 @@ #define ARRAY_H #include "../mem_allocator/mem_allocator.h" -#include "../strings/str8/str8.h" #include "../../common/misc/misc_utils.h" #include "../../common/aliases/aliases.h" #include "../../common/platform/platform.h" @@ -15,129 +14,252 @@ #define wapp_str8_array(...) ((Str8Array){ \ .items = (Str8[wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(Str8, __VA_ARGS__) * 2)]){__VA_ARGS__}, \ .count = wapp_misc_utils_va_args_count(Str8, __VA_ARGS__), \ - .capacity = wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(Str8, __VA_ARGS__) * 2) \ + .capacity = wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(Str8, __VA_ARGS__) * 2), \ + .item_size = sizeof(Str8) \ }) -#define wapp_str8_array_with_capacity(CAPACITY) ((Str8Array){.items = (Str8[CAPACITY]){0}, .count = 0, .capacity = CAPACITY}) +#define wapp_str8_array_with_capacity(CAPACITY) ((Str8Array){.items = (Str8[CAPACITY]){0}, .count = 0, .capacity = CAPACITY, .item_size = sizeof(Str8)}) +#define wapp_str8_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY) ((Str8Array *)_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY, sizeof(Str8))) +#define wapp_str8_array_pop(ARRAY_PTR) (ARRAY_PTR != NULL && (ARRAY_PTR)->count > 0 ? \ + *_str8_array_pop(ARRAY_PTR) : \ + (Str8){0} \ +) #define wapp_void_ptr_array(...) ((VoidPArray){ \ .items = (void *[wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(void *, __VA_ARGS__) * 2)]){__VA_ARGS__}, \ .count = wapp_misc_utils_va_args_count(void *, __VA_ARGS__), \ - .capacity = wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(void *, __VA_ARGS__) * 2) \ + .capacity = wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(void *, __VA_ARGS__) * 2), \ + .item_size = sizeof(void *) \ }) -#define wapp_void_ptr_array_with_capacity(CAPACITY) ((VoidPArray){.items = (void *[CAPACITY]){0}, .count = 0, .capacity = CAPACITY}) +#define wapp_void_ptr_array_with_capacity(CAPACITY) ((VoidPArray){.items = (void *[CAPACITY]){0}, .count = 0, .capacity = CAPACITY, .item_size = sizeof(void *)}) +#define wapp_void_ptr_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY) ((VoidPArray *)_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY, sizeof(void *))) +#define wapp_void_ptr_array_pop(ARRAY_PTR) (ARRAY_PTR != NULL && (ARRAY_PTR)->count > 0 ? \ + *_void_ptr_array_pop(ARRAY_PTR) : \ + (void *){0} \ +) #define wapp_bool_array(...) ((BoolArray){ \ .items = (bool[wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(bool, __VA_ARGS__) * 2)]){__VA_ARGS__}, \ .count = wapp_misc_utils_va_args_count(bool, __VA_ARGS__), \ - .capacity = wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(bool, __VA_ARGS__) * 2) \ + .capacity = wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(bool, __VA_ARGS__) * 2), \ + .item_size = sizeof(bool) \ }) -#define wapp_bool_array_with_capacity(CAPACITY) ((BoolArray){.items = (bool[CAPACITY]){0}, .count = 0, .capacity = CAPACITY}) +#define wapp_bool_array_with_capacity(CAPACITY) ((BoolArray){.items = (bool[CAPACITY]){0}, .count = 0, .capacity = CAPACITY, .item_size = sizeof(bool)}) +#define wapp_bool_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY) ((BoolArray *)_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY, sizeof(bool))) +#define wapp_bool_array_pop(ARRAY_PTR) (ARRAY_PTR != NULL && (ARRAY_PTR)->count > 0 ? \ + *_bool_array_pop(ARRAY_PTR) : \ + (bool){0} \ +) #define wapp_char_array(...) ((CharArray){ \ .items = (char[wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(char, __VA_ARGS__) * 2)]){__VA_ARGS__}, \ .count = wapp_misc_utils_va_args_count(char, __VA_ARGS__), \ - .capacity = wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(char, __VA_ARGS__) * 2) \ + .capacity = wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(char, __VA_ARGS__) * 2), \ + .item_size = sizeof(char) \ }) -#define wapp_char_array_with_capacity(CAPACITY) ((CharArray){.items = (char[CAPACITY]){0}, .count = 0, .capacity = CAPACITY}) +#define wapp_char_array_with_capacity(CAPACITY) ((CharArray){.items = (char[CAPACITY]){0}, .count = 0, .capacity = CAPACITY, .item_size = sizeof(char)}) +#define wapp_char_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY) ((CharArray *)_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY, sizeof(char))) +#define wapp_char_array_pop(ARRAY_PTR) (ARRAY_PTR != NULL && (ARRAY_PTR)->count > 0 ? \ + *_char_array_pop(ARRAY_PTR) : \ + (char){0} \ +) #define wapp_c8_array(...) ((C8Array){ \ .items = (c8[wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(c8, __VA_ARGS__) * 2)]){__VA_ARGS__}, \ .count = wapp_misc_utils_va_args_count(c8, __VA_ARGS__), \ - .capacity = wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(c8, __VA_ARGS__) * 2) \ + .capacity = wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(c8, __VA_ARGS__) * 2), \ + .item_size = sizeof(c8) \ }) -#define wapp_c8_array_with_capacity(CAPACITY) ((C8Array){.items = (c8[CAPACITY]){0}, .count = 0, .capacity = CAPACITY}) +#define wapp_c8_array_with_capacity(CAPACITY) ((C8Array){.items = (c8[CAPACITY]){0}, .count = 0, .capacity = CAPACITY, .item_size = sizeof(c8)}) +#define wapp_c8_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY) ((C8Array *)_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY, sizeof(c8))) +#define wapp_c8_array_pop(ARRAY_PTR) (ARRAY_PTR != NULL && (ARRAY_PTR)->count > 0 ? \ + *_c8_array_pop(ARRAY_PTR) : \ + (c8){0} \ +) #define wapp_c16_array(...) ((C16Array){ \ .items = (c16[wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(c16, __VA_ARGS__) * 2)]){__VA_ARGS__}, \ .count = wapp_misc_utils_va_args_count(c16, __VA_ARGS__), \ - .capacity = wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(c16, __VA_ARGS__) * 2) \ + .capacity = wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(c16, __VA_ARGS__) * 2), \ + .item_size = sizeof(c16) \ }) -#define wapp_c16_array_with_capacity(CAPACITY) ((C16Array){.items = (c16[CAPACITY]){0}, .count = 0, .capacity = CAPACITY}) +#define wapp_c16_array_with_capacity(CAPACITY) ((C16Array){.items = (c16[CAPACITY]){0}, .count = 0, .capacity = CAPACITY, .item_size = sizeof(c16)}) +#define wapp_c16_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY) ((C16Array *)_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY, sizeof(c16))) +#define wapp_c16_array_pop(ARRAY_PTR) (ARRAY_PTR != NULL && (ARRAY_PTR)->count > 0 ? \ + *_c16_array_pop(ARRAY_PTR) : \ + (c16){0} \ +) #define wapp_c32_array(...) ((C32Array){ \ .items = (c32[wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(c32, __VA_ARGS__) * 2)]){__VA_ARGS__}, \ .count = wapp_misc_utils_va_args_count(c32, __VA_ARGS__), \ - .capacity = wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(c32, __VA_ARGS__) * 2) \ + .capacity = wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(c32, __VA_ARGS__) * 2), \ + .item_size = sizeof(c32) \ }) -#define wapp_c32_array_with_capacity(CAPACITY) ((C32Array){.items = (c32[CAPACITY]){0}, .count = 0, .capacity = CAPACITY}) +#define wapp_c32_array_with_capacity(CAPACITY) ((C32Array){.items = (c32[CAPACITY]){0}, .count = 0, .capacity = CAPACITY, .item_size = sizeof(c32)}) +#define wapp_c32_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY) ((C32Array *)_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY, sizeof(c32))) +#define wapp_c32_array_pop(ARRAY_PTR) (ARRAY_PTR != NULL && (ARRAY_PTR)->count > 0 ? \ + *_c32_array_pop(ARRAY_PTR) : \ + (c32){0} \ +) #define wapp_i8_array(...) ((I8Array){ \ .items = (i8[wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(i8, __VA_ARGS__) * 2)]){__VA_ARGS__}, \ .count = wapp_misc_utils_va_args_count(i8, __VA_ARGS__), \ - .capacity = wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(i8, __VA_ARGS__) * 2) \ + .capacity = wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(i8, __VA_ARGS__) * 2), \ + .item_size = sizeof(i8) \ }) -#define wapp_i8_array_with_capacity(CAPACITY) ((I8Array){.items = (i8[CAPACITY]){0}, .count = 0, .capacity = CAPACITY}) +#define wapp_i8_array_with_capacity(CAPACITY) ((I8Array){.items = (i8[CAPACITY]){0}, .count = 0, .capacity = CAPACITY, .item_size = sizeof(i8)}) +#define wapp_i8_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY) ((I8Array *)_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY, sizeof(i8))) +#define wapp_i8_array_pop(ARRAY_PTR) (ARRAY_PTR != NULL && (ARRAY_PTR)->count > 0 ? \ + *_i8_array_pop(ARRAY_PTR) : \ + (i8){0} \ +) #define wapp_i16_array(...) ((I16Array){ \ .items = (i16[wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(i16, __VA_ARGS__) * 2)]){__VA_ARGS__}, \ .count = wapp_misc_utils_va_args_count(i16, __VA_ARGS__), \ - .capacity = wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(i16, __VA_ARGS__) * 2) \ + .capacity = wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(i16, __VA_ARGS__) * 2), \ + .item_size = sizeof(i16) \ }) -#define wapp_i16_array_with_capacity(CAPACITY) ((I16Array){.items = (i16[CAPACITY]){0}, .count = 0, .capacity = CAPACITY}) +#define wapp_i16_array_with_capacity(CAPACITY) ((I16Array){.items = (i16[CAPACITY]){0}, .count = 0, .capacity = CAPACITY, .item_size = sizeof(i16)}) +#define wapp_i16_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY) ((I16Array *)_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY, sizeof(i16))) +#define wapp_i16_array_pop(ARRAY_PTR) (ARRAY_PTR != NULL && (ARRAY_PTR)->count > 0 ? \ + *_i16_array_pop(ARRAY_PTR) : \ + (i16){0} \ +) #define wapp_i32_array(...) ((I32Array){ \ .items = (i32[wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(i32, __VA_ARGS__) * 2)]){__VA_ARGS__}, \ .count = wapp_misc_utils_va_args_count(i32, __VA_ARGS__), \ - .capacity = wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(i32, __VA_ARGS__) * 2) \ + .capacity = wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(i32, __VA_ARGS__) * 2), \ + .item_size = sizeof(i32) \ }) -#define wapp_i32_array_with_capacity(CAPACITY) ((I32Array){.items = (i32[CAPACITY]){0}, .count = 0, .capacity = CAPACITY}) +#define wapp_i32_array_with_capacity(CAPACITY) ((I32Array){.items = (i32[CAPACITY]){0}, .count = 0, .capacity = CAPACITY, .item_size = sizeof(i32)}) +#define wapp_i32_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY) ((I32Array *)_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY, sizeof(i32))) +#define wapp_i32_array_pop(ARRAY_PTR) (ARRAY_PTR != NULL && (ARRAY_PTR)->count > 0 ? \ + *_i32_array_pop(ARRAY_PTR) : \ + (i32){0} \ +) #define wapp_i64_array(...) ((I64Array){ \ .items = (i64[wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(i64, __VA_ARGS__) * 2)]){__VA_ARGS__}, \ .count = wapp_misc_utils_va_args_count(i64, __VA_ARGS__), \ - .capacity = wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(i64, __VA_ARGS__) * 2) \ + .capacity = wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(i64, __VA_ARGS__) * 2), \ + .item_size = sizeof(i64) \ }) -#define wapp_i64_array_with_capacity(CAPACITY) ((I64Array){.items = (i64[CAPACITY]){0}, .count = 0, .capacity = CAPACITY}) +#define wapp_i64_array_with_capacity(CAPACITY) ((I64Array){.items = (i64[CAPACITY]){0}, .count = 0, .capacity = CAPACITY, .item_size = sizeof(i64)}) +#define wapp_i64_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY) ((I64Array *)_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY, sizeof(i64))) +#define wapp_i64_array_pop(ARRAY_PTR) (ARRAY_PTR != NULL && (ARRAY_PTR)->count > 0 ? \ + *_i64_array_pop(ARRAY_PTR) : \ + (i64){0} \ +) #define wapp_u8_array(...) ((U8Array){ \ .items = (u8[wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(u8, __VA_ARGS__) * 2)]){__VA_ARGS__}, \ .count = wapp_misc_utils_va_args_count(u8, __VA_ARGS__), \ - .capacity = wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(u8, __VA_ARGS__) * 2) \ + .capacity = wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(u8, __VA_ARGS__) * 2), \ + .item_size = sizeof(u8) \ }) -#define wapp_u8_array_with_capacity(CAPACITY) ((U8Array){.items = (u8[CAPACITY]){0}, .count = 0, .capacity = CAPACITY}) +#define wapp_u8_array_with_capacity(CAPACITY) ((U8Array){.items = (u8[CAPACITY]){0}, .count = 0, .capacity = CAPACITY, .item_size = sizeof(u8)}) +#define wapp_u8_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY) ((U8Array *)_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY, sizeof(u8))) +#define wapp_u8_array_pop(ARRAY_PTR) (ARRAY_PTR != NULL && (ARRAY_PTR)->count > 0 ? \ + *_u8_array_pop(ARRAY_PTR) : \ + (u8){0} \ +) #define wapp_u16_array(...) ((U16Array){ \ .items = (u16[wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(u16, __VA_ARGS__) * 2)]){__VA_ARGS__}, \ .count = wapp_misc_utils_va_args_count(u16, __VA_ARGS__), \ - .capacity = wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(u16, __VA_ARGS__) * 2) \ + .capacity = wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(u16, __VA_ARGS__) * 2), \ + .item_size = sizeof(u16) \ }) -#define wapp_u16_array_with_capacity(CAPACITY) ((U16Array){.items = (u16[CAPACITY]){0}, .count = 0, .capacity = CAPACITY}) +#define wapp_u16_array_with_capacity(CAPACITY) ((U16Array){.items = (u16[CAPACITY]){0}, .count = 0, .capacity = CAPACITY, .item_size = sizeof(u16)}) +#define wapp_u16_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY) ((U16Array *)_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY, sizeof(u16))) +#define wapp_u16_array_pop(ARRAY_PTR) (ARRAY_PTR != NULL && (ARRAY_PTR)->count > 0 ? \ + *_u16_array_pop(ARRAY_PTR) : \ + (u16){0} \ +) #define wapp_u32_array(...) ((U32Array){ \ .items = (u32[wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(u32, __VA_ARGS__) * 2)]){__VA_ARGS__}, \ .count = wapp_misc_utils_va_args_count(u32, __VA_ARGS__), \ - .capacity = wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(u32, __VA_ARGS__) * 2) \ + .capacity = wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(u32, __VA_ARGS__) * 2), \ + .item_size = sizeof(u32) \ }) -#define wapp_u32_array_with_capacity(CAPACITY) ((U32Array){.items = (u32[CAPACITY]){0}, .count = 0, .capacity = CAPACITY}) +#define wapp_u32_array_with_capacity(CAPACITY) ((U32Array){.items = (u32[CAPACITY]){0}, .count = 0, .capacity = CAPACITY, .item_size = sizeof(u32)}) +#define wapp_u32_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY) ((U32Array *)_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY, sizeof(u32))) +#define wapp_u32_array_pop(ARRAY_PTR) (ARRAY_PTR != NULL && (ARRAY_PTR)->count > 0 ? \ + *_u32_array_pop(ARRAY_PTR) : \ + (u32){0} \ +) #define wapp_u64_array(...) ((U64Array){ \ .items = (u64[wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(u64, __VA_ARGS__) * 2)]){__VA_ARGS__}, \ .count = wapp_misc_utils_va_args_count(u64, __VA_ARGS__), \ - .capacity = wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(u64, __VA_ARGS__) * 2) \ + .capacity = wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(u64, __VA_ARGS__) * 2), \ + .item_size = sizeof(u64) \ }) -#define wapp_u64_array_with_capacity(CAPACITY) ((U64Array){.items = (u64[CAPACITY]){0}, .count = 0, .capacity = CAPACITY}) +#define wapp_u64_array_with_capacity(CAPACITY) ((U64Array){.items = (u64[CAPACITY]){0}, .count = 0, .capacity = CAPACITY, .item_size = sizeof(u64)}) +#define wapp_u64_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY) ((U64Array *)_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY, sizeof(u64))) +#define wapp_u64_array_pop(ARRAY_PTR) (ARRAY_PTR != NULL && (ARRAY_PTR)->count > 0 ? \ + *_u64_array_pop(ARRAY_PTR) : \ + (u64){0} \ +) #define wapp_f32_array(...) ((F32Array){ \ .items = (f32[wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(f32, __VA_ARGS__) * 2)]){__VA_ARGS__}, \ .count = wapp_misc_utils_va_args_count(f32, __VA_ARGS__), \ - .capacity = wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(f32, __VA_ARGS__) * 2) \ + .capacity = wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(f32, __VA_ARGS__) * 2), \ + .item_size = sizeof(f32) \ }) -#define wapp_f32_array_with_capacity(CAPACITY) ((F32Array){.items = (f32[CAPACITY]){0}, .count = 0, .capacity = CAPACITY}) +#define wapp_f32_array_with_capacity(CAPACITY) ((F32Array){.items = (f32[CAPACITY]){0}, .count = 0, .capacity = CAPACITY, .item_size = sizeof(f32)}) +#define wapp_f32_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY) ((F32Array *)_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY, sizeof(f32))) +#define wapp_f32_array_pop(ARRAY_PTR) (ARRAY_PTR != NULL && (ARRAY_PTR)->count > 0 ? \ + *_f32_array_pop(ARRAY_PTR) : \ + (f32){0} \ +) #define wapp_f64_array(...) ((F64Array){ \ .items = (f64[wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(f64, __VA_ARGS__) * 2)]){__VA_ARGS__}, \ .count = wapp_misc_utils_va_args_count(f64, __VA_ARGS__), \ - .capacity = wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(f64, __VA_ARGS__) * 2) \ + .capacity = wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(f64, __VA_ARGS__) * 2), \ + .item_size = sizeof(f64) \ }) -#define wapp_f64_array_with_capacity(CAPACITY) ((F64Array){.items = (f64[CAPACITY]){0}, .count = 0, .capacity = CAPACITY}) +#define wapp_f64_array_with_capacity(CAPACITY) ((F64Array){.items = (f64[CAPACITY]){0}, .count = 0, .capacity = CAPACITY, .item_size = sizeof(f64)}) +#define wapp_f64_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY) ((F64Array *)_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY, sizeof(f64))) +#define wapp_f64_array_pop(ARRAY_PTR) (ARRAY_PTR != NULL && (ARRAY_PTR)->count > 0 ? \ + *_f64_array_pop(ARRAY_PTR) : \ + (f64){0} \ +) #define wapp_f128_array(...) ((F128Array){ \ .items = (f128[wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(f128, __VA_ARGS__) * 2)]){__VA_ARGS__}, \ .count = wapp_misc_utils_va_args_count(f128, __VA_ARGS__), \ - .capacity = wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(f128, __VA_ARGS__) * 2) \ + .capacity = wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(f128, __VA_ARGS__) * 2), \ + .item_size = sizeof(f128) \ }) -#define wapp_f128_array_with_capacity(CAPACITY) ((F128Array){.items = (f128[CAPACITY]){0}, .count = 0, .capacity = CAPACITY}) +#define wapp_f128_array_with_capacity(CAPACITY) ((F128Array){.items = (f128[CAPACITY]){0}, .count = 0, .capacity = CAPACITY, .item_size = sizeof(f128)}) +#define wapp_f128_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY) ((F128Array *)_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY, sizeof(f128))) +#define wapp_f128_array_pop(ARRAY_PTR) (ARRAY_PTR != NULL && (ARRAY_PTR)->count > 0 ? \ + *_f128_array_pop(ARRAY_PTR) : \ + (f128){0} \ +) #define wapp_iptr_array(...) ((IptrArray){ \ .items = (iptr[wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(iptr, __VA_ARGS__) * 2)]){__VA_ARGS__}, \ .count = wapp_misc_utils_va_args_count(iptr, __VA_ARGS__), \ - .capacity = wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(iptr, __VA_ARGS__) * 2) \ + .capacity = wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(iptr, __VA_ARGS__) * 2), \ + .item_size = sizeof(iptr) \ }) -#define wapp_iptr_array_with_capacity(CAPACITY) ((IptrArray){.items = (iptr[CAPACITY]){0}, .count = 0, .capacity = CAPACITY}) +#define wapp_iptr_array_with_capacity(CAPACITY) ((IptrArray){.items = (iptr[CAPACITY]){0}, .count = 0, .capacity = CAPACITY, .item_size = sizeof(iptr)}) +#define wapp_iptr_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY) ((IptrArray *)_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY, sizeof(iptr))) +#define wapp_iptr_array_pop(ARRAY_PTR) (ARRAY_PTR != NULL && (ARRAY_PTR)->count > 0 ? \ + *_iptr_array_pop(ARRAY_PTR) : \ + (iptr){0} \ +) #define wapp_uptr_array(...) ((UptrArray){ \ .items = (uptr[wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(uptr, __VA_ARGS__) * 2)]){__VA_ARGS__}, \ .count = wapp_misc_utils_va_args_count(uptr, __VA_ARGS__), \ - .capacity = wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(uptr, __VA_ARGS__) * 2) \ + .capacity = wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(uptr, __VA_ARGS__) * 2), \ + .item_size = sizeof(uptr) \ }) -#define wapp_uptr_array_with_capacity(CAPACITY) ((UptrArray){.items = (uptr[CAPACITY]){0}, .count = 0, .capacity = CAPACITY}) +#define wapp_uptr_array_with_capacity(CAPACITY) ((UptrArray){.items = (uptr[CAPACITY]){0}, .count = 0, .capacity = CAPACITY, .item_size = sizeof(uptr)}) +#define wapp_uptr_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY) ((UptrArray *)_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY, sizeof(uptr))) +#define wapp_uptr_array_pop(ARRAY_PTR) (ARRAY_PTR != NULL && (ARRAY_PTR)->count > 0 ? \ + *_uptr_array_pop(ARRAY_PTR) : \ + (uptr){0} \ +) + +typedef struct str8 Str8; typedef struct Str8Array Str8Array; struct Str8Array { Str8 *items; u64 count; u64 capacity; + u64 item_size; }; typedef struct VoidPArray VoidPArray; @@ -145,6 +267,7 @@ struct VoidPArray { void * *items; u64 count; u64 capacity; + u64 item_size; }; typedef struct BoolArray BoolArray; @@ -152,6 +275,7 @@ struct BoolArray { bool *items; u64 count; u64 capacity; + u64 item_size; }; typedef struct CharArray CharArray; @@ -159,6 +283,7 @@ struct CharArray { char *items; u64 count; u64 capacity; + u64 item_size; }; typedef struct C8Array C8Array; @@ -166,6 +291,7 @@ struct C8Array { c8 *items; u64 count; u64 capacity; + u64 item_size; }; typedef struct C16Array C16Array; @@ -173,6 +299,7 @@ struct C16Array { c16 *items; u64 count; u64 capacity; + u64 item_size; }; typedef struct C32Array C32Array; @@ -180,6 +307,7 @@ struct C32Array { c32 *items; u64 count; u64 capacity; + u64 item_size; }; typedef struct I8Array I8Array; @@ -187,6 +315,7 @@ struct I8Array { i8 *items; u64 count; u64 capacity; + u64 item_size; }; typedef struct I16Array I16Array; @@ -194,6 +323,7 @@ struct I16Array { i16 *items; u64 count; u64 capacity; + u64 item_size; }; typedef struct I32Array I32Array; @@ -201,6 +331,7 @@ struct I32Array { i32 *items; u64 count; u64 capacity; + u64 item_size; }; typedef struct I64Array I64Array; @@ -208,6 +339,7 @@ struct I64Array { i64 *items; u64 count; u64 capacity; + u64 item_size; }; typedef struct U8Array U8Array; @@ -215,6 +347,7 @@ struct U8Array { u8 *items; u64 count; u64 capacity; + u64 item_size; }; typedef struct U16Array U16Array; @@ -222,6 +355,7 @@ struct U16Array { u16 *items; u64 count; u64 capacity; + u64 item_size; }; typedef struct U32Array U32Array; @@ -229,6 +363,7 @@ struct U32Array { u32 *items; u64 count; u64 capacity; + u64 item_size; }; typedef struct U64Array U64Array; @@ -236,6 +371,7 @@ struct U64Array { u64 *items; u64 count; u64 capacity; + u64 item_size; }; typedef struct F32Array F32Array; @@ -243,6 +379,7 @@ struct F32Array { f32 *items; u64 count; u64 capacity; + u64 item_size; }; typedef struct F64Array F64Array; @@ -250,6 +387,7 @@ struct F64Array { f64 *items; u64 count; u64 capacity; + u64 item_size; }; typedef struct F128Array F128Array; @@ -257,6 +395,7 @@ struct F128Array { f128 *items; u64 count; u64 capacity; + u64 item_size; }; typedef struct IptrArray IptrArray; @@ -264,6 +403,7 @@ struct IptrArray { iptr *items; u64 count; u64 capacity; + u64 item_size; }; typedef struct UptrArray UptrArray; @@ -271,227 +411,209 @@ struct UptrArray { uptr *items; u64 count; u64 capacity; + u64 item_size; }; Str8 *wapp_str8_array_get(const Str8Array *array, u64 index); -void wapp_str8_array_set(Str8Array *array, u64 index, Str8 item); -void wapp_str8_array_append_capped(Str8Array *array, Str8 item); +void wapp_str8_array_set(Str8Array *array, u64 index, Str8 *item); +void wapp_str8_array_append_capped(Str8Array *array, Str8 *item); void wapp_str8_array_extend_capped(Str8Array *array, const Str8Array *other); void wapp_str8_array_clear(Str8Array *array); -Str8 wapp_str8_array_pop(Str8Array *array); void wapp_str8_array_copy_capped(const Str8Array *src, Str8Array *dst); -Str8Array *wapp_str8_array_alloc_capacity(const Allocator *allocator, u64 capacity); -Str8Array *wapp_str8_array_append_alloc(const Allocator *allocator, Str8Array *array, Str8 item); +Str8Array *wapp_str8_array_append_alloc(const Allocator *allocator, Str8Array *array, Str8 *item); Str8Array *wapp_str8_array_extend_alloc(const Allocator *allocator, Str8Array *array, const Str8Array *other); Str8Array *wapp_str8_array_copy_alloc(const Allocator *allocator, const Str8Array *src, Str8Array *dst); +Str8 *_str8_array_pop(Str8Array *array); void * *wapp_void_ptr_array_get(const VoidPArray *array, u64 index); -void wapp_void_ptr_array_set(VoidPArray *array, u64 index, void * item); -void wapp_void_ptr_array_append_capped(VoidPArray *array, void * item); +void wapp_void_ptr_array_set(VoidPArray *array, u64 index, void * *item); +void wapp_void_ptr_array_append_capped(VoidPArray *array, void * *item); void wapp_void_ptr_array_extend_capped(VoidPArray *array, const VoidPArray *other); void wapp_void_ptr_array_clear(VoidPArray *array); -void * wapp_void_ptr_array_pop(VoidPArray *array); void wapp_void_ptr_array_copy_capped(const VoidPArray *src, VoidPArray *dst); -VoidPArray *wapp_void_ptr_array_alloc_capacity(const Allocator *allocator, u64 capacity); -VoidPArray *wapp_void_ptr_array_append_alloc(const Allocator *allocator, VoidPArray *array, void * item); +VoidPArray *wapp_void_ptr_array_append_alloc(const Allocator *allocator, VoidPArray *array, void * *item); VoidPArray *wapp_void_ptr_array_extend_alloc(const Allocator *allocator, VoidPArray *array, const VoidPArray *other); VoidPArray *wapp_void_ptr_array_copy_alloc(const Allocator *allocator, const VoidPArray *src, VoidPArray *dst); +void * *_void_ptr_array_pop(VoidPArray *array); bool *wapp_bool_array_get(const BoolArray *array, u64 index); -void wapp_bool_array_set(BoolArray *array, u64 index, bool item); -void wapp_bool_array_append_capped(BoolArray *array, bool item); +void wapp_bool_array_set(BoolArray *array, u64 index, bool *item); +void wapp_bool_array_append_capped(BoolArray *array, bool *item); void wapp_bool_array_extend_capped(BoolArray *array, const BoolArray *other); void wapp_bool_array_clear(BoolArray *array); -bool wapp_bool_array_pop(BoolArray *array); void wapp_bool_array_copy_capped(const BoolArray *src, BoolArray *dst); -BoolArray *wapp_bool_array_alloc_capacity(const Allocator *allocator, u64 capacity); -BoolArray *wapp_bool_array_append_alloc(const Allocator *allocator, BoolArray *array, bool item); +BoolArray *wapp_bool_array_append_alloc(const Allocator *allocator, BoolArray *array, bool *item); BoolArray *wapp_bool_array_extend_alloc(const Allocator *allocator, BoolArray *array, const BoolArray *other); BoolArray *wapp_bool_array_copy_alloc(const Allocator *allocator, const BoolArray *src, BoolArray *dst); +bool *_bool_array_pop(BoolArray *array); char *wapp_char_array_get(const CharArray *array, u64 index); -void wapp_char_array_set(CharArray *array, u64 index, char item); -void wapp_char_array_append_capped(CharArray *array, char item); +void wapp_char_array_set(CharArray *array, u64 index, char *item); +void wapp_char_array_append_capped(CharArray *array, char *item); void wapp_char_array_extend_capped(CharArray *array, const CharArray *other); void wapp_char_array_clear(CharArray *array); -char wapp_char_array_pop(CharArray *array); void wapp_char_array_copy_capped(const CharArray *src, CharArray *dst); -CharArray *wapp_char_array_alloc_capacity(const Allocator *allocator, u64 capacity); -CharArray *wapp_char_array_append_alloc(const Allocator *allocator, CharArray *array, char item); +CharArray *wapp_char_array_append_alloc(const Allocator *allocator, CharArray *array, char *item); CharArray *wapp_char_array_extend_alloc(const Allocator *allocator, CharArray *array, const CharArray *other); CharArray *wapp_char_array_copy_alloc(const Allocator *allocator, const CharArray *src, CharArray *dst); +char *_char_array_pop(CharArray *array); c8 *wapp_c8_array_get(const C8Array *array, u64 index); -void wapp_c8_array_set(C8Array *array, u64 index, c8 item); -void wapp_c8_array_append_capped(C8Array *array, c8 item); +void wapp_c8_array_set(C8Array *array, u64 index, c8 *item); +void wapp_c8_array_append_capped(C8Array *array, c8 *item); void wapp_c8_array_extend_capped(C8Array *array, const C8Array *other); void wapp_c8_array_clear(C8Array *array); -c8 wapp_c8_array_pop(C8Array *array); void wapp_c8_array_copy_capped(const C8Array *src, C8Array *dst); -C8Array *wapp_c8_array_alloc_capacity(const Allocator *allocator, u64 capacity); -C8Array *wapp_c8_array_append_alloc(const Allocator *allocator, C8Array *array, c8 item); +C8Array *wapp_c8_array_append_alloc(const Allocator *allocator, C8Array *array, c8 *item); C8Array *wapp_c8_array_extend_alloc(const Allocator *allocator, C8Array *array, const C8Array *other); C8Array *wapp_c8_array_copy_alloc(const Allocator *allocator, const C8Array *src, C8Array *dst); +c8 *_c8_array_pop(C8Array *array); c16 *wapp_c16_array_get(const C16Array *array, u64 index); -void wapp_c16_array_set(C16Array *array, u64 index, c16 item); -void wapp_c16_array_append_capped(C16Array *array, c16 item); +void wapp_c16_array_set(C16Array *array, u64 index, c16 *item); +void wapp_c16_array_append_capped(C16Array *array, c16 *item); void wapp_c16_array_extend_capped(C16Array *array, const C16Array *other); void wapp_c16_array_clear(C16Array *array); -c16 wapp_c16_array_pop(C16Array *array); void wapp_c16_array_copy_capped(const C16Array *src, C16Array *dst); -C16Array *wapp_c16_array_alloc_capacity(const Allocator *allocator, u64 capacity); -C16Array *wapp_c16_array_append_alloc(const Allocator *allocator, C16Array *array, c16 item); +C16Array *wapp_c16_array_append_alloc(const Allocator *allocator, C16Array *array, c16 *item); C16Array *wapp_c16_array_extend_alloc(const Allocator *allocator, C16Array *array, const C16Array *other); C16Array *wapp_c16_array_copy_alloc(const Allocator *allocator, const C16Array *src, C16Array *dst); +c16 *_c16_array_pop(C16Array *array); c32 *wapp_c32_array_get(const C32Array *array, u64 index); -void wapp_c32_array_set(C32Array *array, u64 index, c32 item); -void wapp_c32_array_append_capped(C32Array *array, c32 item); +void wapp_c32_array_set(C32Array *array, u64 index, c32 *item); +void wapp_c32_array_append_capped(C32Array *array, c32 *item); void wapp_c32_array_extend_capped(C32Array *array, const C32Array *other); void wapp_c32_array_clear(C32Array *array); -c32 wapp_c32_array_pop(C32Array *array); void wapp_c32_array_copy_capped(const C32Array *src, C32Array *dst); -C32Array *wapp_c32_array_alloc_capacity(const Allocator *allocator, u64 capacity); -C32Array *wapp_c32_array_append_alloc(const Allocator *allocator, C32Array *array, c32 item); +C32Array *wapp_c32_array_append_alloc(const Allocator *allocator, C32Array *array, c32 *item); C32Array *wapp_c32_array_extend_alloc(const Allocator *allocator, C32Array *array, const C32Array *other); C32Array *wapp_c32_array_copy_alloc(const Allocator *allocator, const C32Array *src, C32Array *dst); +c32 *_c32_array_pop(C32Array *array); i8 *wapp_i8_array_get(const I8Array *array, u64 index); -void wapp_i8_array_set(I8Array *array, u64 index, i8 item); -void wapp_i8_array_append_capped(I8Array *array, i8 item); +void wapp_i8_array_set(I8Array *array, u64 index, i8 *item); +void wapp_i8_array_append_capped(I8Array *array, i8 *item); void wapp_i8_array_extend_capped(I8Array *array, const I8Array *other); void wapp_i8_array_clear(I8Array *array); -i8 wapp_i8_array_pop(I8Array *array); void wapp_i8_array_copy_capped(const I8Array *src, I8Array *dst); -I8Array *wapp_i8_array_alloc_capacity(const Allocator *allocator, u64 capacity); -I8Array *wapp_i8_array_append_alloc(const Allocator *allocator, I8Array *array, i8 item); +I8Array *wapp_i8_array_append_alloc(const Allocator *allocator, I8Array *array, i8 *item); I8Array *wapp_i8_array_extend_alloc(const Allocator *allocator, I8Array *array, const I8Array *other); I8Array *wapp_i8_array_copy_alloc(const Allocator *allocator, const I8Array *src, I8Array *dst); +i8 *_i8_array_pop(I8Array *array); i16 *wapp_i16_array_get(const I16Array *array, u64 index); -void wapp_i16_array_set(I16Array *array, u64 index, i16 item); -void wapp_i16_array_append_capped(I16Array *array, i16 item); +void wapp_i16_array_set(I16Array *array, u64 index, i16 *item); +void wapp_i16_array_append_capped(I16Array *array, i16 *item); void wapp_i16_array_extend_capped(I16Array *array, const I16Array *other); void wapp_i16_array_clear(I16Array *array); -i16 wapp_i16_array_pop(I16Array *array); void wapp_i16_array_copy_capped(const I16Array *src, I16Array *dst); -I16Array *wapp_i16_array_alloc_capacity(const Allocator *allocator, u64 capacity); -I16Array *wapp_i16_array_append_alloc(const Allocator *allocator, I16Array *array, i16 item); +I16Array *wapp_i16_array_append_alloc(const Allocator *allocator, I16Array *array, i16 *item); I16Array *wapp_i16_array_extend_alloc(const Allocator *allocator, I16Array *array, const I16Array *other); I16Array *wapp_i16_array_copy_alloc(const Allocator *allocator, const I16Array *src, I16Array *dst); +i16 *_i16_array_pop(I16Array *array); i32 *wapp_i32_array_get(const I32Array *array, u64 index); -void wapp_i32_array_set(I32Array *array, u64 index, i32 item); -void wapp_i32_array_append_capped(I32Array *array, i32 item); +void wapp_i32_array_set(I32Array *array, u64 index, i32 *item); +void wapp_i32_array_append_capped(I32Array *array, i32 *item); void wapp_i32_array_extend_capped(I32Array *array, const I32Array *other); void wapp_i32_array_clear(I32Array *array); -i32 wapp_i32_array_pop(I32Array *array); void wapp_i32_array_copy_capped(const I32Array *src, I32Array *dst); -I32Array *wapp_i32_array_alloc_capacity(const Allocator *allocator, u64 capacity); -I32Array *wapp_i32_array_append_alloc(const Allocator *allocator, I32Array *array, i32 item); +I32Array *wapp_i32_array_append_alloc(const Allocator *allocator, I32Array *array, i32 *item); I32Array *wapp_i32_array_extend_alloc(const Allocator *allocator, I32Array *array, const I32Array *other); I32Array *wapp_i32_array_copy_alloc(const Allocator *allocator, const I32Array *src, I32Array *dst); +i32 *_i32_array_pop(I32Array *array); i64 *wapp_i64_array_get(const I64Array *array, u64 index); -void wapp_i64_array_set(I64Array *array, u64 index, i64 item); -void wapp_i64_array_append_capped(I64Array *array, i64 item); +void wapp_i64_array_set(I64Array *array, u64 index, i64 *item); +void wapp_i64_array_append_capped(I64Array *array, i64 *item); void wapp_i64_array_extend_capped(I64Array *array, const I64Array *other); void wapp_i64_array_clear(I64Array *array); -i64 wapp_i64_array_pop(I64Array *array); void wapp_i64_array_copy_capped(const I64Array *src, I64Array *dst); -I64Array *wapp_i64_array_alloc_capacity(const Allocator *allocator, u64 capacity); -I64Array *wapp_i64_array_append_alloc(const Allocator *allocator, I64Array *array, i64 item); +I64Array *wapp_i64_array_append_alloc(const Allocator *allocator, I64Array *array, i64 *item); I64Array *wapp_i64_array_extend_alloc(const Allocator *allocator, I64Array *array, const I64Array *other); I64Array *wapp_i64_array_copy_alloc(const Allocator *allocator, const I64Array *src, I64Array *dst); +i64 *_i64_array_pop(I64Array *array); u8 *wapp_u8_array_get(const U8Array *array, u64 index); -void wapp_u8_array_set(U8Array *array, u64 index, u8 item); -void wapp_u8_array_append_capped(U8Array *array, u8 item); +void wapp_u8_array_set(U8Array *array, u64 index, u8 *item); +void wapp_u8_array_append_capped(U8Array *array, u8 *item); void wapp_u8_array_extend_capped(U8Array *array, const U8Array *other); void wapp_u8_array_clear(U8Array *array); -u8 wapp_u8_array_pop(U8Array *array); void wapp_u8_array_copy_capped(const U8Array *src, U8Array *dst); -U8Array *wapp_u8_array_alloc_capacity(const Allocator *allocator, u64 capacity); -U8Array *wapp_u8_array_append_alloc(const Allocator *allocator, U8Array *array, u8 item); +U8Array *wapp_u8_array_append_alloc(const Allocator *allocator, U8Array *array, u8 *item); U8Array *wapp_u8_array_extend_alloc(const Allocator *allocator, U8Array *array, const U8Array *other); U8Array *wapp_u8_array_copy_alloc(const Allocator *allocator, const U8Array *src, U8Array *dst); +u8 *_u8_array_pop(U8Array *array); u16 *wapp_u16_array_get(const U16Array *array, u64 index); -void wapp_u16_array_set(U16Array *array, u64 index, u16 item); -void wapp_u16_array_append_capped(U16Array *array, u16 item); +void wapp_u16_array_set(U16Array *array, u64 index, u16 *item); +void wapp_u16_array_append_capped(U16Array *array, u16 *item); void wapp_u16_array_extend_capped(U16Array *array, const U16Array *other); void wapp_u16_array_clear(U16Array *array); -u16 wapp_u16_array_pop(U16Array *array); void wapp_u16_array_copy_capped(const U16Array *src, U16Array *dst); -U16Array *wapp_u16_array_alloc_capacity(const Allocator *allocator, u64 capacity); -U16Array *wapp_u16_array_append_alloc(const Allocator *allocator, U16Array *array, u16 item); +U16Array *wapp_u16_array_append_alloc(const Allocator *allocator, U16Array *array, u16 *item); U16Array *wapp_u16_array_extend_alloc(const Allocator *allocator, U16Array *array, const U16Array *other); U16Array *wapp_u16_array_copy_alloc(const Allocator *allocator, const U16Array *src, U16Array *dst); +u16 *_u16_array_pop(U16Array *array); u32 *wapp_u32_array_get(const U32Array *array, u64 index); -void wapp_u32_array_set(U32Array *array, u64 index, u32 item); -void wapp_u32_array_append_capped(U32Array *array, u32 item); +void wapp_u32_array_set(U32Array *array, u64 index, u32 *item); +void wapp_u32_array_append_capped(U32Array *array, u32 *item); void wapp_u32_array_extend_capped(U32Array *array, const U32Array *other); void wapp_u32_array_clear(U32Array *array); -u32 wapp_u32_array_pop(U32Array *array); void wapp_u32_array_copy_capped(const U32Array *src, U32Array *dst); -U32Array *wapp_u32_array_alloc_capacity(const Allocator *allocator, u64 capacity); -U32Array *wapp_u32_array_append_alloc(const Allocator *allocator, U32Array *array, u32 item); +U32Array *wapp_u32_array_append_alloc(const Allocator *allocator, U32Array *array, u32 *item); U32Array *wapp_u32_array_extend_alloc(const Allocator *allocator, U32Array *array, const U32Array *other); U32Array *wapp_u32_array_copy_alloc(const Allocator *allocator, const U32Array *src, U32Array *dst); +u32 *_u32_array_pop(U32Array *array); u64 *wapp_u64_array_get(const U64Array *array, u64 index); -void wapp_u64_array_set(U64Array *array, u64 index, u64 item); -void wapp_u64_array_append_capped(U64Array *array, u64 item); +void wapp_u64_array_set(U64Array *array, u64 index, u64 *item); +void wapp_u64_array_append_capped(U64Array *array, u64 *item); void wapp_u64_array_extend_capped(U64Array *array, const U64Array *other); void wapp_u64_array_clear(U64Array *array); -u64 wapp_u64_array_pop(U64Array *array); void wapp_u64_array_copy_capped(const U64Array *src, U64Array *dst); -U64Array *wapp_u64_array_alloc_capacity(const Allocator *allocator, u64 capacity); -U64Array *wapp_u64_array_append_alloc(const Allocator *allocator, U64Array *array, u64 item); +U64Array *wapp_u64_array_append_alloc(const Allocator *allocator, U64Array *array, u64 *item); U64Array *wapp_u64_array_extend_alloc(const Allocator *allocator, U64Array *array, const U64Array *other); U64Array *wapp_u64_array_copy_alloc(const Allocator *allocator, const U64Array *src, U64Array *dst); +u64 *_u64_array_pop(U64Array *array); f32 *wapp_f32_array_get(const F32Array *array, u64 index); -void wapp_f32_array_set(F32Array *array, u64 index, f32 item); -void wapp_f32_array_append_capped(F32Array *array, f32 item); +void wapp_f32_array_set(F32Array *array, u64 index, f32 *item); +void wapp_f32_array_append_capped(F32Array *array, f32 *item); void wapp_f32_array_extend_capped(F32Array *array, const F32Array *other); void wapp_f32_array_clear(F32Array *array); -f32 wapp_f32_array_pop(F32Array *array); void wapp_f32_array_copy_capped(const F32Array *src, F32Array *dst); -F32Array *wapp_f32_array_alloc_capacity(const Allocator *allocator, u64 capacity); -F32Array *wapp_f32_array_append_alloc(const Allocator *allocator, F32Array *array, f32 item); +F32Array *wapp_f32_array_append_alloc(const Allocator *allocator, F32Array *array, f32 *item); F32Array *wapp_f32_array_extend_alloc(const Allocator *allocator, F32Array *array, const F32Array *other); F32Array *wapp_f32_array_copy_alloc(const Allocator *allocator, const F32Array *src, F32Array *dst); +f32 *_f32_array_pop(F32Array *array); f64 *wapp_f64_array_get(const F64Array *array, u64 index); -void wapp_f64_array_set(F64Array *array, u64 index, f64 item); -void wapp_f64_array_append_capped(F64Array *array, f64 item); +void wapp_f64_array_set(F64Array *array, u64 index, f64 *item); +void wapp_f64_array_append_capped(F64Array *array, f64 *item); void wapp_f64_array_extend_capped(F64Array *array, const F64Array *other); void wapp_f64_array_clear(F64Array *array); -f64 wapp_f64_array_pop(F64Array *array); void wapp_f64_array_copy_capped(const F64Array *src, F64Array *dst); -F64Array *wapp_f64_array_alloc_capacity(const Allocator *allocator, u64 capacity); -F64Array *wapp_f64_array_append_alloc(const Allocator *allocator, F64Array *array, f64 item); +F64Array *wapp_f64_array_append_alloc(const Allocator *allocator, F64Array *array, f64 *item); F64Array *wapp_f64_array_extend_alloc(const Allocator *allocator, F64Array *array, const F64Array *other); F64Array *wapp_f64_array_copy_alloc(const Allocator *allocator, const F64Array *src, F64Array *dst); +f64 *_f64_array_pop(F64Array *array); f128 *wapp_f128_array_get(const F128Array *array, u64 index); -void wapp_f128_array_set(F128Array *array, u64 index, f128 item); -void wapp_f128_array_append_capped(F128Array *array, f128 item); +void wapp_f128_array_set(F128Array *array, u64 index, f128 *item); +void wapp_f128_array_append_capped(F128Array *array, f128 *item); void wapp_f128_array_extend_capped(F128Array *array, const F128Array *other); void wapp_f128_array_clear(F128Array *array); -f128 wapp_f128_array_pop(F128Array *array); void wapp_f128_array_copy_capped(const F128Array *src, F128Array *dst); -F128Array *wapp_f128_array_alloc_capacity(const Allocator *allocator, u64 capacity); -F128Array *wapp_f128_array_append_alloc(const Allocator *allocator, F128Array *array, f128 item); +F128Array *wapp_f128_array_append_alloc(const Allocator *allocator, F128Array *array, f128 *item); F128Array *wapp_f128_array_extend_alloc(const Allocator *allocator, F128Array *array, const F128Array *other); F128Array *wapp_f128_array_copy_alloc(const Allocator *allocator, const F128Array *src, F128Array *dst); +f128 *_f128_array_pop(F128Array *array); iptr *wapp_iptr_array_get(const IptrArray *array, u64 index); -void wapp_iptr_array_set(IptrArray *array, u64 index, iptr item); -void wapp_iptr_array_append_capped(IptrArray *array, iptr item); +void wapp_iptr_array_set(IptrArray *array, u64 index, iptr *item); +void wapp_iptr_array_append_capped(IptrArray *array, iptr *item); void wapp_iptr_array_extend_capped(IptrArray *array, const IptrArray *other); void wapp_iptr_array_clear(IptrArray *array); -iptr wapp_iptr_array_pop(IptrArray *array); void wapp_iptr_array_copy_capped(const IptrArray *src, IptrArray *dst); -IptrArray *wapp_iptr_array_alloc_capacity(const Allocator *allocator, u64 capacity); -IptrArray *wapp_iptr_array_append_alloc(const Allocator *allocator, IptrArray *array, iptr item); +IptrArray *wapp_iptr_array_append_alloc(const Allocator *allocator, IptrArray *array, iptr *item); IptrArray *wapp_iptr_array_extend_alloc(const Allocator *allocator, IptrArray *array, const IptrArray *other); IptrArray *wapp_iptr_array_copy_alloc(const Allocator *allocator, const IptrArray *src, IptrArray *dst); +iptr *_iptr_array_pop(IptrArray *array); uptr *wapp_uptr_array_get(const UptrArray *array, u64 index); -void wapp_uptr_array_set(UptrArray *array, u64 index, uptr item); -void wapp_uptr_array_append_capped(UptrArray *array, uptr item); +void wapp_uptr_array_set(UptrArray *array, u64 index, uptr *item); +void wapp_uptr_array_append_capped(UptrArray *array, uptr *item); void wapp_uptr_array_extend_capped(UptrArray *array, const UptrArray *other); void wapp_uptr_array_clear(UptrArray *array); -uptr wapp_uptr_array_pop(UptrArray *array); void wapp_uptr_array_copy_capped(const UptrArray *src, UptrArray *dst); -UptrArray *wapp_uptr_array_alloc_capacity(const Allocator *allocator, u64 capacity); -UptrArray *wapp_uptr_array_append_alloc(const Allocator *allocator, UptrArray *array, uptr item); +UptrArray *wapp_uptr_array_append_alloc(const Allocator *allocator, UptrArray *array, uptr *item); UptrArray *wapp_uptr_array_extend_alloc(const Allocator *allocator, UptrArray *array, const UptrArray *other); UptrArray *wapp_uptr_array_copy_alloc(const Allocator *allocator, const UptrArray *src, UptrArray *dst); +uptr *_uptr_array_pop(UptrArray *array); +VoidPArray *_array_alloc_capacity(const Allocator *allocator, u64 capacity, u64 item_size); #endif // !ARRAY_H diff --git a/tests/array/test_i32_array.c b/tests/array/test_i32_array.c index 8c0c120..5206c0c 100644 --- a/tests/array/test_i32_array.c +++ b/tests/array/test_i32_array.c @@ -62,7 +62,7 @@ TestFuncResult test_i32_array_set(void) { u64 index = 0; bool running = true; while (running) { - wapp_i32_array_set(&array, index, (i32)(index * 2)); + wapp_i32_array_set(&array, index, &((i32){index * 2})); item = wapp_i32_array_get(&array, index); result = result && item && (*item == (i32)(index * 2)); @@ -77,15 +77,15 @@ TestFuncResult test_i32_array_append_capped(void) { bool result; I32Array array = wapp_i32_array_with_capacity(64); - wapp_i32_array_append_capped(&array, 10); + wapp_i32_array_append_capped(&array, &((i32){10})); result = array.count == 1; i32 *item = wapp_i32_array_get(&array, 0); result = result && item && *item == 10; array = wapp_i32_array(1); - wapp_i32_array_append_capped(&array, 10); - wapp_i32_array_append_capped(&array, 20); + wapp_i32_array_append_capped(&array, &((i32){10})); + wapp_i32_array_append_capped(&array, &((i32){20})); result = result && array.count == 2; @@ -195,14 +195,14 @@ TestFuncResult test_i32_array_append_alloc(void) { I32Array array1 = wapp_i32_array(1, 2, 3, 4, 5, 6, 7, 8); I32Array array2 = wapp_i32_array(1, 2); - I32Array *arr_ptr = wapp_i32_array_append_alloc(&allocator, &array1, 10); + I32Array *arr_ptr = wapp_i32_array_append_alloc(&allocator, &array1, &((i32){10})); result = arr_ptr == &array1; u64 count = 4; u64 index = 0; bool running = true; while (running) { - arr_ptr = wapp_i32_array_append_alloc(&allocator, &array2, (i32)index); + arr_ptr = wapp_i32_array_append_alloc(&allocator, &array2, &((i32){index})); ++index; running = index < count;