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

Change boolean size to 1 byte

Browse Source
This commit is contained in:
Abdelrahman Said
2025-12-07 12:17:40 +00:00
parent 432e4a48d5
commit 9c5b95c229
41 changed files with 489 additions and 364 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -44,7 +44,7 @@ void wapp_void_ptr_array_extend_capped(VoidPArray *array, const VoidPArray *othe
// MSVC Spectre mitigation warnings
u64 items_to_add = other->count;
u64 item_index = 0;
b32 running = true;
b8 running = true;
while (running) {
item = wapp_void_ptr_array_get(other, item_index);
++item_index;
@@ -74,7 +74,7 @@ void wapp_void_ptr_array_copy_capped(const VoidPArray *src, VoidPArray *dst) {
// MSVC Spectre mitigation warnings
u64 to_copy = src->count < dst->capacity ? src->count : dst->capacity;
u64 item_index = 0;
b32 running = true;
b8 running = true;
while (running) {
item = wapp_void_ptr_array_get(src, item_index);
++item_index;
@@ -193,7 +193,7 @@ void wapp_str8_array_extend_capped(Str8Array *array, const Str8Array *other) {
// MSVC Spectre mitigation warnings
u64 items_to_add = other->count;
u64 item_index = 0;
b32 running = true;
b8 running = true;
while (running) {
item = wapp_str8_array_get(other, item_index);
++item_index;
@@ -223,7 +223,7 @@ void wapp_str8_array_copy_capped(const Str8Array *src, Str8Array *dst) {
// MSVC Spectre mitigation warnings
u64 to_copy = src->count < dst->capacity ? src->count : dst->capacity;
u64 item_index = 0;
b32 running = true;
b8 running = true;
while (running) {
item = wapp_str8_array_get(src, item_index);
++item_index;
@@ -308,43 +308,43 @@ Str8 *_str8_array_pop(Str8Array *array) {
return out;
}
b32 *wapp_b32_array_get(const B32Array *array, u64 index) {
b8 *wapp_b8_array_get(const B8Array *array, u64 index) {
wapp_debug_assert(array != NULL, "`array` should not be NULL");
wapp_runtime_assert(index < array->count, "`index` is out of bounds");
u8 *ptr = (u8 *)(array->items) + (array->item_size * index);
return (b32 *)ptr;
return (b8 *)ptr;
}
void wapp_b32_array_set(B32Array *array, u64 index, b32 *item) {
b32 *ptr = wapp_b32_array_get(array, index);
void wapp_b8_array_set(B8Array *array, u64 index, b8 *item) {
b8 *ptr = wapp_b8_array_get(array, index);
memcpy((void *)ptr, (void *)item, array->item_size);
}
void wapp_b32_array_append_capped(B32Array *array, b32 *item) {
void wapp_b8_array_append_capped(B8Array *array, b8 *item) {
wapp_debug_assert(array != NULL, "`array` should not be NULL");
wapp_runtime_assert(array->count < array->capacity, "`array` is full");
u64 index = (array->count)++;
wapp_b32_array_set(array, index, item);
wapp_b8_array_set(array, index, item);
}
void wapp_b32_array_extend_capped(B32Array *array, const B32Array *other) {
void wapp_b8_array_extend_capped(B8Array *array, const B8Array *other) {
wapp_debug_assert(array != NULL && other != NULL, "`array` and `other` should not be NULL");
u64 remaining_capacity = array->capacity - array->count;
wapp_runtime_assert(other->count < remaining_capacity, "`array` does not have enough capacity");
b32 *item;
b8 *item;
// NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
// MSVC Spectre mitigation warnings
u64 items_to_add = other->count;
u64 item_index = 0;
b32 running = true;
b8 running = true;
while (running) {
item = wapp_b32_array_get(other, item_index);
item = wapp_b8_array_get(other, item_index);
++item_index;
running = item_index < items_to_add;
@@ -352,29 +352,29 @@ void wapp_b32_array_extend_capped(B32Array *array, const B32Array *other) {
continue;
}
wapp_b32_array_append_capped(array, item);
wapp_b8_array_append_capped(array, item);
}
}
void wapp_b32_array_clear(B32Array *array) {
void wapp_b8_array_clear(B8Array *array) {
wapp_debug_assert(array != NULL, "`array` should not be NULL");
array->count = 0;
}
void wapp_b32_array_copy_capped(const B32Array *src, B32Array *dst) {
void wapp_b8_array_copy_capped(const B8Array *src, B8Array *dst) {
wapp_debug_assert(src != NULL && dst != NULL, "`src` and `dst` should not be NULL");
wapp_b32_array_clear(dst);
wapp_b8_array_clear(dst);
b32 *item;
b8 *item;
// NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
// MSVC Spectre mitigation warnings
u64 to_copy = src->count < dst->capacity ? src->count : dst->capacity;
u64 item_index = 0;
b32 running = true;
b8 running = true;
while (running) {
item = wapp_b32_array_get(src, item_index);
item = wapp_b8_array_get(src, item_index);
++item_index;
running = item_index < to_copy;
@@ -382,77 +382,77 @@ void wapp_b32_array_copy_capped(const B32Array *src, B32Array *dst) {
continue;
}
wapp_b32_array_append_capped(dst, item);
wapp_b8_array_append_capped(dst, item);
}
}
B32Array *wapp_b32_array_append_alloc(const Allocator *allocator, B32Array *array, b32 *item) {
B8Array *wapp_b8_array_append_alloc(const Allocator *allocator, B8Array *array, b8 *item) {
wapp_debug_assert(allocator != NULL && array != NULL, "`allocator` and `array` should not be NULL");
B32Array *output = array;
B8Array *output = array;
if (array->count >= array->capacity) {
u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(array->capacity * 2);
output = (B32Array *)_array_alloc_capacity(allocator, new_capacity, array->item_size);
output = (B8Array *)_array_alloc_capacity(allocator, new_capacity, array->item_size);
if (!output) {
output = array;
goto RETURN_B32_ARRAY_APPEND_ALLOC;
goto RETURN_B8_ARRAY_APPEND_ALLOC;
}
wapp_b32_array_copy_capped(array, output);
wapp_b8_array_copy_capped(array, output);
}
wapp_b32_array_append_capped(output, item);
wapp_b8_array_append_capped(output, item);
RETURN_B32_ARRAY_APPEND_ALLOC:
RETURN_B8_ARRAY_APPEND_ALLOC:
return output;
}
B32Array *wapp_b32_array_extend_alloc(const Allocator *allocator, B32Array *array, const B32Array *other) {
B8Array *wapp_b8_array_extend_alloc(const Allocator *allocator, B8Array *array, const B8Array *other) {
wapp_debug_assert(allocator != NULL && array != NULL && other != NULL, "`allocator`, `array` and `other` should not be NULL");
B32Array *output = array;
B8Array *output = array;
u64 remaining_capacity = array->capacity - array->count;
if (other->count >= remaining_capacity) {
u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(array->capacity * 2);
output = (B32Array *)_array_alloc_capacity(allocator, new_capacity, array->item_size);
output = (B8Array *)_array_alloc_capacity(allocator, new_capacity, array->item_size);
if (!output) {
output = array;
goto RETURN_B32_ARRAY_EXTEND_ALLOC;
goto RETURN_B8_ARRAY_EXTEND_ALLOC;
}
wapp_b32_array_copy_capped(array, output);
wapp_b8_array_copy_capped(array, output);
}
wapp_b32_array_extend_capped(output, other);
wapp_b8_array_extend_capped(output, other);
RETURN_B32_ARRAY_EXTEND_ALLOC:
RETURN_B8_ARRAY_EXTEND_ALLOC:
return output;
}
B32Array *wapp_b32_array_copy_alloc(const Allocator *allocator, const B32Array *src, B32Array *dst) {
B8Array *wapp_b8_array_copy_alloc(const Allocator *allocator, const B8Array *src, B8Array *dst) {
wapp_debug_assert(allocator != NULL && src != NULL && dst != NULL, "`allocator`, `src` and `dst` should not be NULL");
B32Array *output = dst;
B8Array *output = dst;
if (src->count >= dst->capacity) {
u64 new_capacity = wapp_misc_utils_u64_round_up_pow2(dst->capacity * 2);
output = (B32Array *)_array_alloc_capacity(allocator, new_capacity, src->item_size);
output = (B8Array *)_array_alloc_capacity(allocator, new_capacity, src->item_size);
if (!output) {
output = dst;
goto RETURN_B32_ARRAY_COPY_ALLOC;
goto RETURN_B8_ARRAY_COPY_ALLOC;
}
}
wapp_b32_array_clear(output);
wapp_b32_array_copy_capped(src, output);
wapp_b8_array_clear(output);
wapp_b8_array_copy_capped(src, output);
RETURN_B32_ARRAY_COPY_ALLOC:
RETURN_B8_ARRAY_COPY_ALLOC:
return output;
}
b32 *_b32_array_pop(B32Array *array) {
b8 *_b8_array_pop(B8Array *array) {
u64 index = array->count - 1;
b32 *out = wapp_b32_array_get(array, index);
b8 *out = wapp_b8_array_get(array, index);
--(array->count);
return out;
}
@@ -491,7 +491,7 @@ void wapp_char_array_extend_capped(CharArray *array, const CharArray *other) {
// MSVC Spectre mitigation warnings
u64 items_to_add = other->count;
u64 item_index = 0;
b32 running = true;
b8 running = true;
while (running) {
item = wapp_char_array_get(other, item_index);
++item_index;
@@ -521,7 +521,7 @@ void wapp_char_array_copy_capped(const CharArray *src, CharArray *dst) {
// MSVC Spectre mitigation warnings
u64 to_copy = src->count < dst->capacity ? src->count : dst->capacity;
u64 item_index = 0;
b32 running = true;
b8 running = true;
while (running) {
item = wapp_char_array_get(src, item_index);
++item_index;
@@ -640,7 +640,7 @@ void wapp_c8_array_extend_capped(C8Array *array, const C8Array *other) {
// MSVC Spectre mitigation warnings
u64 items_to_add = other->count;
u64 item_index = 0;
b32 running = true;
b8 running = true;
while (running) {
item = wapp_c8_array_get(other, item_index);
++item_index;
@@ -670,7 +670,7 @@ void wapp_c8_array_copy_capped(const C8Array *src, C8Array *dst) {
// MSVC Spectre mitigation warnings
u64 to_copy = src->count < dst->capacity ? src->count : dst->capacity;
u64 item_index = 0;
b32 running = true;
b8 running = true;
while (running) {
item = wapp_c8_array_get(src, item_index);
++item_index;
@@ -789,7 +789,7 @@ void wapp_c16_array_extend_capped(C16Array *array, const C16Array *other) {
// MSVC Spectre mitigation warnings
u64 items_to_add = other->count;
u64 item_index = 0;
b32 running = true;
b8 running = true;
while (running) {
item = wapp_c16_array_get(other, item_index);
++item_index;
@@ -819,7 +819,7 @@ void wapp_c16_array_copy_capped(const C16Array *src, C16Array *dst) {
// MSVC Spectre mitigation warnings
u64 to_copy = src->count < dst->capacity ? src->count : dst->capacity;
u64 item_index = 0;
b32 running = true;
b8 running = true;
while (running) {
item = wapp_c16_array_get(src, item_index);
++item_index;
@@ -938,7 +938,7 @@ void wapp_c32_array_extend_capped(C32Array *array, const C32Array *other) {
// MSVC Spectre mitigation warnings
u64 items_to_add = other->count;
u64 item_index = 0;
b32 running = true;
b8 running = true;
while (running) {
item = wapp_c32_array_get(other, item_index);
++item_index;
@@ -968,7 +968,7 @@ void wapp_c32_array_copy_capped(const C32Array *src, C32Array *dst) {
// MSVC Spectre mitigation warnings
u64 to_copy = src->count < dst->capacity ? src->count : dst->capacity;
u64 item_index = 0;
b32 running = true;
b8 running = true;
while (running) {
item = wapp_c32_array_get(src, item_index);
++item_index;
@@ -1087,7 +1087,7 @@ void wapp_i8_array_extend_capped(I8Array *array, const I8Array *other) {
// MSVC Spectre mitigation warnings
u64 items_to_add = other->count;
u64 item_index = 0;
b32 running = true;
b8 running = true;
while (running) {
item = wapp_i8_array_get(other, item_index);
++item_index;
@@ -1117,7 +1117,7 @@ void wapp_i8_array_copy_capped(const I8Array *src, I8Array *dst) {
// MSVC Spectre mitigation warnings
u64 to_copy = src->count < dst->capacity ? src->count : dst->capacity;
u64 item_index = 0;
b32 running = true;
b8 running = true;
while (running) {
item = wapp_i8_array_get(src, item_index);
++item_index;
@@ -1236,7 +1236,7 @@ void wapp_i16_array_extend_capped(I16Array *array, const I16Array *other) {
// MSVC Spectre mitigation warnings
u64 items_to_add = other->count;
u64 item_index = 0;
b32 running = true;
b8 running = true;
while (running) {
item = wapp_i16_array_get(other, item_index);
++item_index;
@@ -1266,7 +1266,7 @@ void wapp_i16_array_copy_capped(const I16Array *src, I16Array *dst) {
// MSVC Spectre mitigation warnings
u64 to_copy = src->count < dst->capacity ? src->count : dst->capacity;
u64 item_index = 0;
b32 running = true;
b8 running = true;
while (running) {
item = wapp_i16_array_get(src, item_index);
++item_index;
@@ -1385,7 +1385,7 @@ void wapp_i32_array_extend_capped(I32Array *array, const I32Array *other) {
// MSVC Spectre mitigation warnings
u64 items_to_add = other->count;
u64 item_index = 0;
b32 running = true;
b8 running = true;
while (running) {
item = wapp_i32_array_get(other, item_index);
++item_index;
@@ -1415,7 +1415,7 @@ void wapp_i32_array_copy_capped(const I32Array *src, I32Array *dst) {
// MSVC Spectre mitigation warnings
u64 to_copy = src->count < dst->capacity ? src->count : dst->capacity;
u64 item_index = 0;
b32 running = true;
b8 running = true;
while (running) {
item = wapp_i32_array_get(src, item_index);
++item_index;
@@ -1534,7 +1534,7 @@ void wapp_i64_array_extend_capped(I64Array *array, const I64Array *other) {
// MSVC Spectre mitigation warnings
u64 items_to_add = other->count;
u64 item_index = 0;
b32 running = true;
b8 running = true;
while (running) {
item = wapp_i64_array_get(other, item_index);
++item_index;
@@ -1564,7 +1564,7 @@ void wapp_i64_array_copy_capped(const I64Array *src, I64Array *dst) {
// MSVC Spectre mitigation warnings
u64 to_copy = src->count < dst->capacity ? src->count : dst->capacity;
u64 item_index = 0;
b32 running = true;
b8 running = true;
while (running) {
item = wapp_i64_array_get(src, item_index);
++item_index;
@@ -1683,7 +1683,7 @@ void wapp_u8_array_extend_capped(U8Array *array, const U8Array *other) {
// MSVC Spectre mitigation warnings
u64 items_to_add = other->count;
u64 item_index = 0;
b32 running = true;
b8 running = true;
while (running) {
item = wapp_u8_array_get(other, item_index);
++item_index;
@@ -1713,7 +1713,7 @@ void wapp_u8_array_copy_capped(const U8Array *src, U8Array *dst) {
// MSVC Spectre mitigation warnings
u64 to_copy = src->count < dst->capacity ? src->count : dst->capacity;
u64 item_index = 0;
b32 running = true;
b8 running = true;
while (running) {
item = wapp_u8_array_get(src, item_index);
++item_index;
@@ -1832,7 +1832,7 @@ void wapp_u16_array_extend_capped(U16Array *array, const U16Array *other) {
// MSVC Spectre mitigation warnings
u64 items_to_add = other->count;
u64 item_index = 0;
b32 running = true;
b8 running = true;
while (running) {
item = wapp_u16_array_get(other, item_index);
++item_index;
@@ -1862,7 +1862,7 @@ void wapp_u16_array_copy_capped(const U16Array *src, U16Array *dst) {
// MSVC Spectre mitigation warnings
u64 to_copy = src->count < dst->capacity ? src->count : dst->capacity;
u64 item_index = 0;
b32 running = true;
b8 running = true;
while (running) {
item = wapp_u16_array_get(src, item_index);
++item_index;
@@ -1981,7 +1981,7 @@ void wapp_u32_array_extend_capped(U32Array *array, const U32Array *other) {
// MSVC Spectre mitigation warnings
u64 items_to_add = other->count;
u64 item_index = 0;
b32 running = true;
b8 running = true;
while (running) {
item = wapp_u32_array_get(other, item_index);
++item_index;
@@ -2011,7 +2011,7 @@ void wapp_u32_array_copy_capped(const U32Array *src, U32Array *dst) {
// MSVC Spectre mitigation warnings
u64 to_copy = src->count < dst->capacity ? src->count : dst->capacity;
u64 item_index = 0;
b32 running = true;
b8 running = true;
while (running) {
item = wapp_u32_array_get(src, item_index);
++item_index;
@@ -2130,7 +2130,7 @@ void wapp_u64_array_extend_capped(U64Array *array, const U64Array *other) {
// MSVC Spectre mitigation warnings
u64 items_to_add = other->count;
u64 item_index = 0;
b32 running = true;
b8 running = true;
while (running) {
item = wapp_u64_array_get(other, item_index);
++item_index;
@@ -2160,7 +2160,7 @@ void wapp_u64_array_copy_capped(const U64Array *src, U64Array *dst) {
// MSVC Spectre mitigation warnings
u64 to_copy = src->count < dst->capacity ? src->count : dst->capacity;
u64 item_index = 0;
b32 running = true;
b8 running = true;
while (running) {
item = wapp_u64_array_get(src, item_index);
++item_index;
@@ -2279,7 +2279,7 @@ void wapp_f32_array_extend_capped(F32Array *array, const F32Array *other) {
// MSVC Spectre mitigation warnings
u64 items_to_add = other->count;
u64 item_index = 0;
b32 running = true;
b8 running = true;
while (running) {
item = wapp_f32_array_get(other, item_index);
++item_index;
@@ -2309,7 +2309,7 @@ void wapp_f32_array_copy_capped(const F32Array *src, F32Array *dst) {
// MSVC Spectre mitigation warnings
u64 to_copy = src->count < dst->capacity ? src->count : dst->capacity;
u64 item_index = 0;
b32 running = true;
b8 running = true;
while (running) {
item = wapp_f32_array_get(src, item_index);
++item_index;
@@ -2428,7 +2428,7 @@ void wapp_f64_array_extend_capped(F64Array *array, const F64Array *other) {
// MSVC Spectre mitigation warnings
u64 items_to_add = other->count;
u64 item_index = 0;
b32 running = true;
b8 running = true;
while (running) {
item = wapp_f64_array_get(other, item_index);
++item_index;
@@ -2458,7 +2458,7 @@ void wapp_f64_array_copy_capped(const F64Array *src, F64Array *dst) {
// MSVC Spectre mitigation warnings
u64 to_copy = src->count < dst->capacity ? src->count : dst->capacity;
u64 item_index = 0;
b32 running = true;
b8 running = true;
while (running) {
item = wapp_f64_array_get(src, item_index);
++item_index;
@@ -2577,7 +2577,7 @@ void wapp_f128_array_extend_capped(F128Array *array, const F128Array *other) {
// MSVC Spectre mitigation warnings
u64 items_to_add = other->count;
u64 item_index = 0;
b32 running = true;
b8 running = true;
while (running) {
item = wapp_f128_array_get(other, item_index);
++item_index;
@@ -2607,7 +2607,7 @@ void wapp_f128_array_copy_capped(const F128Array *src, F128Array *dst) {
// MSVC Spectre mitigation warnings
u64 to_copy = src->count < dst->capacity ? src->count : dst->capacity;
u64 item_index = 0;
b32 running = true;
b8 running = true;
while (running) {
item = wapp_f128_array_get(src, item_index);
++item_index;
@@ -2726,7 +2726,7 @@ void wapp_iptr_array_extend_capped(IptrArray *array, const IptrArray *other) {
// MSVC Spectre mitigation warnings
u64 items_to_add = other->count;
u64 item_index = 0;
b32 running = true;
b8 running = true;
while (running) {
item = wapp_iptr_array_get(other, item_index);
++item_index;
@@ -2756,7 +2756,7 @@ void wapp_iptr_array_copy_capped(const IptrArray *src, IptrArray *dst) {
// MSVC Spectre mitigation warnings
u64 to_copy = src->count < dst->capacity ? src->count : dst->capacity;
u64 item_index = 0;
b32 running = true;
b8 running = true;
while (running) {
item = wapp_iptr_array_get(src, item_index);
++item_index;
@@ -2875,7 +2875,7 @@ void wapp_uptr_array_extend_capped(UptrArray *array, const UptrArray *other) {
// MSVC Spectre mitigation warnings
u64 items_to_add = other->count;
u64 item_index = 0;
b32 running = true;
b8 running = true;
while (running) {
item = wapp_uptr_array_get(other, item_index);
++item_index;
@@ -2905,7 +2905,7 @@ void wapp_uptr_array_copy_capped(const UptrArray *src, UptrArray *dst) {
// MSVC Spectre mitigation warnings
u64 to_copy = src->count < dst->capacity ? src->count : dst->capacity;
u64 item_index = 0;
b32 running = true;
b8 running = true;
while (running) {
item = wapp_uptr_array_get(src, item_index);
++item_index;