Recreate base64 project
This commit is contained in:
3011
wapp/primitives/array/array.c
Normal file
3011
wapp/primitives/array/array.c
Normal file
File diff suppressed because it is too large
Load Diff
971
wapp/primitives/array/array.h
Normal file
971
wapp/primitives/array/array.h
Normal file
@@ -0,0 +1,971 @@
|
||||
/**
|
||||
* THIS FILE IS AUTOMATICALLY GENERATED. ANY MODIFICATIONS TO IT WILL BE OVERWRITTEN
|
||||
*/
|
||||
|
||||
#ifndef ARRAY_H
|
||||
#define ARRAY_H
|
||||
|
||||
#include "../../common/aliases/aliases.h"
|
||||
#include "../mem_allocator/mem_allocator.h"
|
||||
#include "../../common/misc/misc_utils.h"
|
||||
#include "../../common/aliases/aliases.h"
|
||||
#include "../../common/platform/platform.h"
|
||||
|
||||
#ifdef WAPP_PLATFORM_CPP
|
||||
BEGIN_C_LINKAGE
|
||||
#endif // !WAPP_PLATFORM_CPP
|
||||
|
||||
#define wapp_str8_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY) ((Str8Array *)_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY, sizeof(Str8)))
|
||||
#define wapp_void_ptr_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY) ((VoidPArray *)_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY, sizeof(void *)))
|
||||
#define wapp_b32_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY) ((B32Array *)_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY, sizeof(b32)))
|
||||
#define wapp_char_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY) ((CharArray *)_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY, sizeof(char)))
|
||||
#define wapp_c8_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY) ((C8Array *)_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY, sizeof(c8)))
|
||||
#define wapp_c16_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY) ((C16Array *)_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY, sizeof(c16)))
|
||||
#define wapp_c32_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY) ((C32Array *)_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY, sizeof(c32)))
|
||||
#define wapp_i8_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY) ((I8Array *)_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY, sizeof(i8)))
|
||||
#define wapp_i16_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY) ((I16Array *)_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY, sizeof(i16)))
|
||||
#define wapp_i32_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY) ((I32Array *)_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY, sizeof(i32)))
|
||||
#define wapp_i64_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY) ((I64Array *)_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY, sizeof(i64)))
|
||||
#define wapp_u8_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY) ((U8Array *)_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY, sizeof(u8)))
|
||||
#define wapp_u16_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY) ((U16Array *)_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY, sizeof(u16)))
|
||||
#define wapp_u32_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY) ((U32Array *)_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY, sizeof(u32)))
|
||||
#define wapp_u64_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY) ((U64Array *)_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY, sizeof(u64)))
|
||||
#define wapp_f32_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY) ((F32Array *)_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY, sizeof(f32)))
|
||||
#define wapp_f64_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY) ((F64Array *)_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY, sizeof(f64)))
|
||||
#define wapp_f128_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY) ((F128Array *)_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY, sizeof(f128)))
|
||||
#define wapp_iptr_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY) ((IptrArray *)_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY, sizeof(iptr)))
|
||||
#define wapp_uptr_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY) ((UptrArray *)_array_alloc_capacity(ALLOCATOR_PTR, CAPACITY, sizeof(uptr)))
|
||||
|
||||
#ifdef WAPP_PLATFORM_CPP
|
||||
#define wapp_str8_array(...) ([&]() { \
|
||||
persistent Str8 buf[wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(Str8, __VA_ARGS__) * 2)] = {__VA_ARGS__}; \
|
||||
return Str8Array{ \
|
||||
buf, \
|
||||
wapp_misc_utils_va_args_count(Str8, __VA_ARGS__), \
|
||||
wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(Str8, __VA_ARGS__) * 2), \
|
||||
sizeof(Str8) \
|
||||
}; \
|
||||
}())
|
||||
#define wapp_str8_array_with_capacity(CAPACITY) ([&]() { \
|
||||
persistent Str8 buf[CAPACITY] = {}; \
|
||||
return Str8Array{buf, 0, CAPACITY, sizeof(Str8)}; \
|
||||
}())
|
||||
#define wapp_str8_array_pop(ARRAY_PTR) (ARRAY_PTR != NULL && (ARRAY_PTR)->count > 0 ? \
|
||||
*_str8_array_pop(ARRAY_PTR) : \
|
||||
Str8{} \
|
||||
)
|
||||
#define wapp_void_ptr_array(...) ([&]() { \
|
||||
persistent void * buf[wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(void *, __VA_ARGS__) * 2)] = {__VA_ARGS__}; \
|
||||
return VoidPArray{ \
|
||||
buf, \
|
||||
wapp_misc_utils_va_args_count(void *, __VA_ARGS__), \
|
||||
wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(void *, __VA_ARGS__) * 2), \
|
||||
sizeof(void *) \
|
||||
}; \
|
||||
}())
|
||||
#define wapp_void_ptr_array_with_capacity(CAPACITY) ([&]() { \
|
||||
persistent void * buf[CAPACITY] = {}; \
|
||||
return VoidPArray{buf, 0, 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 *{} \
|
||||
)
|
||||
#define wapp_b32_array(...) ([&]() { \
|
||||
persistent b32 buf[wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(b32, __VA_ARGS__) * 2)] = {__VA_ARGS__}; \
|
||||
return B32Array{ \
|
||||
buf, \
|
||||
wapp_misc_utils_va_args_count(b32, __VA_ARGS__), \
|
||||
wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(b32, __VA_ARGS__) * 2), \
|
||||
sizeof(b32) \
|
||||
}; \
|
||||
}())
|
||||
#define wapp_b32_array_with_capacity(CAPACITY) ([&]() { \
|
||||
persistent b32 buf[CAPACITY] = {}; \
|
||||
return B32Array{buf, 0, CAPACITY, sizeof(b32)}; \
|
||||
}())
|
||||
#define wapp_b32_array_pop(ARRAY_PTR) (ARRAY_PTR != NULL && (ARRAY_PTR)->count > 0 ? \
|
||||
*_b32_array_pop(ARRAY_PTR) : \
|
||||
b32{} \
|
||||
)
|
||||
#define wapp_char_array(...) ([&]() { \
|
||||
persistent char buf[wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(char, __VA_ARGS__) * 2)] = {__VA_ARGS__}; \
|
||||
return CharArray{ \
|
||||
buf, \
|
||||
wapp_misc_utils_va_args_count(char, __VA_ARGS__), \
|
||||
wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(char, __VA_ARGS__) * 2), \
|
||||
sizeof(char) \
|
||||
}; \
|
||||
}())
|
||||
#define wapp_char_array_with_capacity(CAPACITY) ([&]() { \
|
||||
persistent char buf[CAPACITY] = {}; \
|
||||
return CharArray{buf, 0, CAPACITY, sizeof(char)}; \
|
||||
}())
|
||||
#define wapp_char_array_pop(ARRAY_PTR) (ARRAY_PTR != NULL && (ARRAY_PTR)->count > 0 ? \
|
||||
*_char_array_pop(ARRAY_PTR) : \
|
||||
char{} \
|
||||
)
|
||||
#define wapp_c8_array(...) ([&]() { \
|
||||
persistent c8 buf[wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(c8, __VA_ARGS__) * 2)] = {__VA_ARGS__}; \
|
||||
return C8Array{ \
|
||||
buf, \
|
||||
wapp_misc_utils_va_args_count(c8, __VA_ARGS__), \
|
||||
wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(c8, __VA_ARGS__) * 2), \
|
||||
sizeof(c8) \
|
||||
}; \
|
||||
}())
|
||||
#define wapp_c8_array_with_capacity(CAPACITY) ([&]() { \
|
||||
persistent c8 buf[CAPACITY] = {}; \
|
||||
return C8Array{buf, 0, CAPACITY, sizeof(c8)}; \
|
||||
}())
|
||||
#define wapp_c8_array_pop(ARRAY_PTR) (ARRAY_PTR != NULL && (ARRAY_PTR)->count > 0 ? \
|
||||
*_c8_array_pop(ARRAY_PTR) : \
|
||||
c8{} \
|
||||
)
|
||||
#define wapp_c16_array(...) ([&]() { \
|
||||
persistent c16 buf[wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(c16, __VA_ARGS__) * 2)] = {__VA_ARGS__}; \
|
||||
return C16Array{ \
|
||||
buf, \
|
||||
wapp_misc_utils_va_args_count(c16, __VA_ARGS__), \
|
||||
wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(c16, __VA_ARGS__) * 2), \
|
||||
sizeof(c16) \
|
||||
}; \
|
||||
}())
|
||||
#define wapp_c16_array_with_capacity(CAPACITY) ([&]() { \
|
||||
persistent c16 buf[CAPACITY] = {}; \
|
||||
return C16Array{buf, 0, CAPACITY, sizeof(c16)}; \
|
||||
}())
|
||||
#define wapp_c16_array_pop(ARRAY_PTR) (ARRAY_PTR != NULL && (ARRAY_PTR)->count > 0 ? \
|
||||
*_c16_array_pop(ARRAY_PTR) : \
|
||||
c16{} \
|
||||
)
|
||||
#define wapp_c32_array(...) ([&]() { \
|
||||
persistent c32 buf[wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(c32, __VA_ARGS__) * 2)] = {__VA_ARGS__}; \
|
||||
return C32Array{ \
|
||||
buf, \
|
||||
wapp_misc_utils_va_args_count(c32, __VA_ARGS__), \
|
||||
wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(c32, __VA_ARGS__) * 2), \
|
||||
sizeof(c32) \
|
||||
}; \
|
||||
}())
|
||||
#define wapp_c32_array_with_capacity(CAPACITY) ([&]() { \
|
||||
persistent c32 buf[CAPACITY] = {}; \
|
||||
return C32Array{buf, 0, CAPACITY, sizeof(c32)}; \
|
||||
}())
|
||||
#define wapp_c32_array_pop(ARRAY_PTR) (ARRAY_PTR != NULL && (ARRAY_PTR)->count > 0 ? \
|
||||
*_c32_array_pop(ARRAY_PTR) : \
|
||||
c32{} \
|
||||
)
|
||||
#define wapp_i8_array(...) ([&]() { \
|
||||
persistent i8 buf[wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(i8, __VA_ARGS__) * 2)] = {__VA_ARGS__}; \
|
||||
return I8Array{ \
|
||||
buf, \
|
||||
wapp_misc_utils_va_args_count(i8, __VA_ARGS__), \
|
||||
wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(i8, __VA_ARGS__) * 2), \
|
||||
sizeof(i8) \
|
||||
}; \
|
||||
}())
|
||||
#define wapp_i8_array_with_capacity(CAPACITY) ([&]() { \
|
||||
persistent i8 buf[CAPACITY] = {}; \
|
||||
return I8Array{buf, 0, CAPACITY, sizeof(i8)}; \
|
||||
}())
|
||||
#define wapp_i8_array_pop(ARRAY_PTR) (ARRAY_PTR != NULL && (ARRAY_PTR)->count > 0 ? \
|
||||
*_i8_array_pop(ARRAY_PTR) : \
|
||||
i8{} \
|
||||
)
|
||||
#define wapp_i16_array(...) ([&]() { \
|
||||
persistent i16 buf[wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(i16, __VA_ARGS__) * 2)] = {__VA_ARGS__}; \
|
||||
return I16Array{ \
|
||||
buf, \
|
||||
wapp_misc_utils_va_args_count(i16, __VA_ARGS__), \
|
||||
wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(i16, __VA_ARGS__) * 2), \
|
||||
sizeof(i16) \
|
||||
}; \
|
||||
}())
|
||||
#define wapp_i16_array_with_capacity(CAPACITY) ([&]() { \
|
||||
persistent i16 buf[CAPACITY] = {}; \
|
||||
return I16Array{buf, 0, CAPACITY, sizeof(i16)}; \
|
||||
}())
|
||||
#define wapp_i16_array_pop(ARRAY_PTR) (ARRAY_PTR != NULL && (ARRAY_PTR)->count > 0 ? \
|
||||
*_i16_array_pop(ARRAY_PTR) : \
|
||||
i16{} \
|
||||
)
|
||||
#define wapp_i32_array(...) ([&]() { \
|
||||
persistent i32 buf[wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(i32, __VA_ARGS__) * 2)] = {__VA_ARGS__}; \
|
||||
return I32Array{ \
|
||||
buf, \
|
||||
wapp_misc_utils_va_args_count(i32, __VA_ARGS__), \
|
||||
wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(i32, __VA_ARGS__) * 2), \
|
||||
sizeof(i32) \
|
||||
}; \
|
||||
}())
|
||||
#define wapp_i32_array_with_capacity(CAPACITY) ([&]() { \
|
||||
persistent i32 buf[CAPACITY] = {}; \
|
||||
return I32Array{buf, 0, CAPACITY, sizeof(i32)}; \
|
||||
}())
|
||||
#define wapp_i32_array_pop(ARRAY_PTR) (ARRAY_PTR != NULL && (ARRAY_PTR)->count > 0 ? \
|
||||
*_i32_array_pop(ARRAY_PTR) : \
|
||||
i32{} \
|
||||
)
|
||||
#define wapp_i64_array(...) ([&]() { \
|
||||
persistent i64 buf[wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(i64, __VA_ARGS__) * 2)] = {__VA_ARGS__}; \
|
||||
return I64Array{ \
|
||||
buf, \
|
||||
wapp_misc_utils_va_args_count(i64, __VA_ARGS__), \
|
||||
wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(i64, __VA_ARGS__) * 2), \
|
||||
sizeof(i64) \
|
||||
}; \
|
||||
}())
|
||||
#define wapp_i64_array_with_capacity(CAPACITY) ([&]() { \
|
||||
persistent i64 buf[CAPACITY] = {}; \
|
||||
return I64Array{buf, 0, CAPACITY, sizeof(i64)}; \
|
||||
}())
|
||||
#define wapp_i64_array_pop(ARRAY_PTR) (ARRAY_PTR != NULL && (ARRAY_PTR)->count > 0 ? \
|
||||
*_i64_array_pop(ARRAY_PTR) : \
|
||||
i64{} \
|
||||
)
|
||||
#define wapp_u8_array(...) ([&]() { \
|
||||
persistent u8 buf[wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(u8, __VA_ARGS__) * 2)] = {__VA_ARGS__}; \
|
||||
return U8Array{ \
|
||||
buf, \
|
||||
wapp_misc_utils_va_args_count(u8, __VA_ARGS__), \
|
||||
wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(u8, __VA_ARGS__) * 2), \
|
||||
sizeof(u8) \
|
||||
}; \
|
||||
}())
|
||||
#define wapp_u8_array_with_capacity(CAPACITY) ([&]() { \
|
||||
persistent u8 buf[CAPACITY] = {}; \
|
||||
return U8Array{buf, 0, CAPACITY, sizeof(u8)}; \
|
||||
}())
|
||||
#define wapp_u8_array_pop(ARRAY_PTR) (ARRAY_PTR != NULL && (ARRAY_PTR)->count > 0 ? \
|
||||
*_u8_array_pop(ARRAY_PTR) : \
|
||||
u8{} \
|
||||
)
|
||||
#define wapp_u16_array(...) ([&]() { \
|
||||
persistent u16 buf[wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(u16, __VA_ARGS__) * 2)] = {__VA_ARGS__}; \
|
||||
return U16Array{ \
|
||||
buf, \
|
||||
wapp_misc_utils_va_args_count(u16, __VA_ARGS__), \
|
||||
wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(u16, __VA_ARGS__) * 2), \
|
||||
sizeof(u16) \
|
||||
}; \
|
||||
}())
|
||||
#define wapp_u16_array_with_capacity(CAPACITY) ([&]() { \
|
||||
persistent u16 buf[CAPACITY] = {}; \
|
||||
return U16Array{buf, 0, CAPACITY, sizeof(u16)}; \
|
||||
}())
|
||||
#define wapp_u16_array_pop(ARRAY_PTR) (ARRAY_PTR != NULL && (ARRAY_PTR)->count > 0 ? \
|
||||
*_u16_array_pop(ARRAY_PTR) : \
|
||||
u16{} \
|
||||
)
|
||||
#define wapp_u32_array(...) ([&]() { \
|
||||
persistent u32 buf[wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(u32, __VA_ARGS__) * 2)] = {__VA_ARGS__}; \
|
||||
return U32Array{ \
|
||||
buf, \
|
||||
wapp_misc_utils_va_args_count(u32, __VA_ARGS__), \
|
||||
wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(u32, __VA_ARGS__) * 2), \
|
||||
sizeof(u32) \
|
||||
}; \
|
||||
}())
|
||||
#define wapp_u32_array_with_capacity(CAPACITY) ([&]() { \
|
||||
persistent u32 buf[CAPACITY] = {}; \
|
||||
return U32Array{buf, 0, CAPACITY, sizeof(u32)}; \
|
||||
}())
|
||||
#define wapp_u32_array_pop(ARRAY_PTR) (ARRAY_PTR != NULL && (ARRAY_PTR)->count > 0 ? \
|
||||
*_u32_array_pop(ARRAY_PTR) : \
|
||||
u32{} \
|
||||
)
|
||||
#define wapp_u64_array(...) ([&]() { \
|
||||
persistent u64 buf[wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(u64, __VA_ARGS__) * 2)] = {__VA_ARGS__}; \
|
||||
return U64Array{ \
|
||||
buf, \
|
||||
wapp_misc_utils_va_args_count(u64, __VA_ARGS__), \
|
||||
wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(u64, __VA_ARGS__) * 2), \
|
||||
sizeof(u64) \
|
||||
}; \
|
||||
}())
|
||||
#define wapp_u64_array_with_capacity(CAPACITY) ([&]() { \
|
||||
persistent u64 buf[CAPACITY] = {}; \
|
||||
return U64Array{buf, 0, CAPACITY, sizeof(u64)}; \
|
||||
}())
|
||||
#define wapp_u64_array_pop(ARRAY_PTR) (ARRAY_PTR != NULL && (ARRAY_PTR)->count > 0 ? \
|
||||
*_u64_array_pop(ARRAY_PTR) : \
|
||||
u64{} \
|
||||
)
|
||||
#define wapp_f32_array(...) ([&]() { \
|
||||
persistent f32 buf[wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(f32, __VA_ARGS__) * 2)] = {__VA_ARGS__}; \
|
||||
return F32Array{ \
|
||||
buf, \
|
||||
wapp_misc_utils_va_args_count(f32, __VA_ARGS__), \
|
||||
wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(f32, __VA_ARGS__) * 2), \
|
||||
sizeof(f32) \
|
||||
}; \
|
||||
}())
|
||||
#define wapp_f32_array_with_capacity(CAPACITY) ([&]() { \
|
||||
persistent f32 buf[CAPACITY] = {}; \
|
||||
return F32Array{buf, 0, CAPACITY, sizeof(f32)}; \
|
||||
}())
|
||||
#define wapp_f32_array_pop(ARRAY_PTR) (ARRAY_PTR != NULL && (ARRAY_PTR)->count > 0 ? \
|
||||
*_f32_array_pop(ARRAY_PTR) : \
|
||||
f32{} \
|
||||
)
|
||||
#define wapp_f64_array(...) ([&]() { \
|
||||
persistent f64 buf[wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(f64, __VA_ARGS__) * 2)] = {__VA_ARGS__}; \
|
||||
return F64Array{ \
|
||||
buf, \
|
||||
wapp_misc_utils_va_args_count(f64, __VA_ARGS__), \
|
||||
wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(f64, __VA_ARGS__) * 2), \
|
||||
sizeof(f64) \
|
||||
}; \
|
||||
}())
|
||||
#define wapp_f64_array_with_capacity(CAPACITY) ([&]() { \
|
||||
persistent f64 buf[CAPACITY] = {}; \
|
||||
return F64Array{buf, 0, CAPACITY, sizeof(f64)}; \
|
||||
}())
|
||||
#define wapp_f64_array_pop(ARRAY_PTR) (ARRAY_PTR != NULL && (ARRAY_PTR)->count > 0 ? \
|
||||
*_f64_array_pop(ARRAY_PTR) : \
|
||||
f64{} \
|
||||
)
|
||||
#define wapp_f128_array(...) ([&]() { \
|
||||
persistent f128 buf[wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(f128, __VA_ARGS__) * 2)] = {__VA_ARGS__}; \
|
||||
return F128Array{ \
|
||||
buf, \
|
||||
wapp_misc_utils_va_args_count(f128, __VA_ARGS__), \
|
||||
wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(f128, __VA_ARGS__) * 2), \
|
||||
sizeof(f128) \
|
||||
}; \
|
||||
}())
|
||||
#define wapp_f128_array_with_capacity(CAPACITY) ([&]() { \
|
||||
persistent f128 buf[CAPACITY] = {}; \
|
||||
return F128Array{buf, 0, CAPACITY, sizeof(f128)}; \
|
||||
}())
|
||||
#define wapp_f128_array_pop(ARRAY_PTR) (ARRAY_PTR != NULL && (ARRAY_PTR)->count > 0 ? \
|
||||
*_f128_array_pop(ARRAY_PTR) : \
|
||||
f128{} \
|
||||
)
|
||||
#define wapp_iptr_array(...) ([&]() { \
|
||||
persistent iptr buf[wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(iptr, __VA_ARGS__) * 2)] = {__VA_ARGS__}; \
|
||||
return IptrArray{ \
|
||||
buf, \
|
||||
wapp_misc_utils_va_args_count(iptr, __VA_ARGS__), \
|
||||
wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(iptr, __VA_ARGS__) * 2), \
|
||||
sizeof(iptr) \
|
||||
}; \
|
||||
}())
|
||||
#define wapp_iptr_array_with_capacity(CAPACITY) ([&]() { \
|
||||
persistent iptr buf[CAPACITY] = {}; \
|
||||
return IptrArray{buf, 0, CAPACITY, sizeof(iptr)}; \
|
||||
}())
|
||||
#define wapp_iptr_array_pop(ARRAY_PTR) (ARRAY_PTR != NULL && (ARRAY_PTR)->count > 0 ? \
|
||||
*_iptr_array_pop(ARRAY_PTR) : \
|
||||
iptr{} \
|
||||
)
|
||||
#define wapp_uptr_array(...) ([&]() { \
|
||||
persistent uptr buf[wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(uptr, __VA_ARGS__) * 2)] = {__VA_ARGS__}; \
|
||||
return UptrArray{ \
|
||||
buf, \
|
||||
wapp_misc_utils_va_args_count(uptr, __VA_ARGS__), \
|
||||
wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(uptr, __VA_ARGS__) * 2), \
|
||||
sizeof(uptr) \
|
||||
}; \
|
||||
}())
|
||||
#define wapp_uptr_array_with_capacity(CAPACITY) ([&]() { \
|
||||
persistent uptr buf[CAPACITY] = {}; \
|
||||
return UptrArray{buf, 0, CAPACITY, sizeof(uptr)}; \
|
||||
}())
|
||||
#define wapp_uptr_array_pop(ARRAY_PTR) (ARRAY_PTR != NULL && (ARRAY_PTR)->count > 0 ? \
|
||||
*_uptr_array_pop(ARRAY_PTR) : \
|
||||
uptr{} \
|
||||
)
|
||||
#else
|
||||
#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), \
|
||||
.item_size = sizeof(Str8) \
|
||||
})
|
||||
#define wapp_str8_array_with_capacity(CAPACITY) ((Str8Array){.items = (Str8[CAPACITY]){0}, .count = 0, .capacity = CAPACITY, .item_size = 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), \
|
||||
.item_size = sizeof(void *) \
|
||||
})
|
||||
#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_pop(ARRAY_PTR) (ARRAY_PTR != NULL && (ARRAY_PTR)->count > 0 ? \
|
||||
*_void_ptr_array_pop(ARRAY_PTR) : \
|
||||
(void *){0} \
|
||||
)
|
||||
#define wapp_b32_array(...) ((B32Array){ \
|
||||
.items = (b32[wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(b32, __VA_ARGS__) * 2)]){__VA_ARGS__}, \
|
||||
.count = wapp_misc_utils_va_args_count(b32, __VA_ARGS__), \
|
||||
.capacity = wapp_misc_utils_u64_round_up_pow2(wapp_misc_utils_va_args_count(b32, __VA_ARGS__) * 2), \
|
||||
.item_size = sizeof(b32) \
|
||||
})
|
||||
#define wapp_b32_array_with_capacity(CAPACITY) ((B32Array){.items = (b32[CAPACITY]){0}, .count = 0, .capacity = CAPACITY, .item_size = sizeof(b32)})
|
||||
#define wapp_b32_array_pop(ARRAY_PTR) (ARRAY_PTR != NULL && (ARRAY_PTR)->count > 0 ? \
|
||||
*_b32_array_pop(ARRAY_PTR) : \
|
||||
(b32){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), \
|
||||
.item_size = sizeof(char) \
|
||||
})
|
||||
#define wapp_char_array_with_capacity(CAPACITY) ((CharArray){.items = (char[CAPACITY]){0}, .count = 0, .capacity = CAPACITY, .item_size = 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), \
|
||||
.item_size = sizeof(c8) \
|
||||
})
|
||||
#define wapp_c8_array_with_capacity(CAPACITY) ((C8Array){.items = (c8[CAPACITY]){0}, .count = 0, .capacity = CAPACITY, .item_size = 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), \
|
||||
.item_size = sizeof(c16) \
|
||||
})
|
||||
#define wapp_c16_array_with_capacity(CAPACITY) ((C16Array){.items = (c16[CAPACITY]){0}, .count = 0, .capacity = CAPACITY, .item_size = 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), \
|
||||
.item_size = sizeof(c32) \
|
||||
})
|
||||
#define wapp_c32_array_with_capacity(CAPACITY) ((C32Array){.items = (c32[CAPACITY]){0}, .count = 0, .capacity = CAPACITY, .item_size = 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), \
|
||||
.item_size = sizeof(i8) \
|
||||
})
|
||||
#define wapp_i8_array_with_capacity(CAPACITY) ((I8Array){.items = (i8[CAPACITY]){0}, .count = 0, .capacity = CAPACITY, .item_size = 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), \
|
||||
.item_size = sizeof(i16) \
|
||||
})
|
||||
#define wapp_i16_array_with_capacity(CAPACITY) ((I16Array){.items = (i16[CAPACITY]){0}, .count = 0, .capacity = CAPACITY, .item_size = 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), \
|
||||
.item_size = sizeof(i32) \
|
||||
})
|
||||
#define wapp_i32_array_with_capacity(CAPACITY) ((I32Array){.items = (i32[CAPACITY]){0}, .count = 0, .capacity = CAPACITY, .item_size = 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), \
|
||||
.item_size = sizeof(i64) \
|
||||
})
|
||||
#define wapp_i64_array_with_capacity(CAPACITY) ((I64Array){.items = (i64[CAPACITY]){0}, .count = 0, .capacity = CAPACITY, .item_size = 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), \
|
||||
.item_size = sizeof(u8) \
|
||||
})
|
||||
#define wapp_u8_array_with_capacity(CAPACITY) ((U8Array){.items = (u8[CAPACITY]){0}, .count = 0, .capacity = CAPACITY, .item_size = 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), \
|
||||
.item_size = sizeof(u16) \
|
||||
})
|
||||
#define wapp_u16_array_with_capacity(CAPACITY) ((U16Array){.items = (u16[CAPACITY]){0}, .count = 0, .capacity = CAPACITY, .item_size = 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), \
|
||||
.item_size = sizeof(u32) \
|
||||
})
|
||||
#define wapp_u32_array_with_capacity(CAPACITY) ((U32Array){.items = (u32[CAPACITY]){0}, .count = 0, .capacity = CAPACITY, .item_size = 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), \
|
||||
.item_size = sizeof(u64) \
|
||||
})
|
||||
#define wapp_u64_array_with_capacity(CAPACITY) ((U64Array){.items = (u64[CAPACITY]){0}, .count = 0, .capacity = CAPACITY, .item_size = 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), \
|
||||
.item_size = sizeof(f32) \
|
||||
})
|
||||
#define wapp_f32_array_with_capacity(CAPACITY) ((F32Array){.items = (f32[CAPACITY]){0}, .count = 0, .capacity = CAPACITY, .item_size = 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), \
|
||||
.item_size = sizeof(f64) \
|
||||
})
|
||||
#define wapp_f64_array_with_capacity(CAPACITY) ((F64Array){.items = (f64[CAPACITY]){0}, .count = 0, .capacity = CAPACITY, .item_size = 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), \
|
||||
.item_size = sizeof(f128) \
|
||||
})
|
||||
#define wapp_f128_array_with_capacity(CAPACITY) ((F128Array){.items = (f128[CAPACITY]){0}, .count = 0, .capacity = CAPACITY, .item_size = 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), \
|
||||
.item_size = sizeof(iptr) \
|
||||
})
|
||||
#define wapp_iptr_array_with_capacity(CAPACITY) ((IptrArray){.items = (iptr[CAPACITY]){0}, .count = 0, .capacity = CAPACITY, .item_size = 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), \
|
||||
.item_size = sizeof(uptr) \
|
||||
})
|
||||
#define wapp_uptr_array_with_capacity(CAPACITY) ((UptrArray){.items = (uptr[CAPACITY]){0}, .count = 0, .capacity = CAPACITY, .item_size = sizeof(uptr)})
|
||||
#define wapp_uptr_array_pop(ARRAY_PTR) (ARRAY_PTR != NULL && (ARRAY_PTR)->count > 0 ? \
|
||||
*_uptr_array_pop(ARRAY_PTR) : \
|
||||
(uptr){0} \
|
||||
)
|
||||
#endif // !WAPP_PLATFORM_CPP
|
||||
|
||||
typedef struct str8 Str8;
|
||||
|
||||
typedef struct Str8Array Str8Array;
|
||||
struct Str8Array {
|
||||
Str8 *items;
|
||||
u64 count;
|
||||
u64 capacity;
|
||||
u64 item_size;
|
||||
};
|
||||
|
||||
typedef struct VoidPArray VoidPArray;
|
||||
struct VoidPArray {
|
||||
void * *items;
|
||||
u64 count;
|
||||
u64 capacity;
|
||||
u64 item_size;
|
||||
};
|
||||
|
||||
typedef struct B32Array B32Array;
|
||||
struct B32Array {
|
||||
b32 *items;
|
||||
u64 count;
|
||||
u64 capacity;
|
||||
u64 item_size;
|
||||
};
|
||||
|
||||
typedef struct CharArray CharArray;
|
||||
struct CharArray {
|
||||
char *items;
|
||||
u64 count;
|
||||
u64 capacity;
|
||||
u64 item_size;
|
||||
};
|
||||
|
||||
typedef struct C8Array C8Array;
|
||||
struct C8Array {
|
||||
c8 *items;
|
||||
u64 count;
|
||||
u64 capacity;
|
||||
u64 item_size;
|
||||
};
|
||||
|
||||
typedef struct C16Array C16Array;
|
||||
struct C16Array {
|
||||
c16 *items;
|
||||
u64 count;
|
||||
u64 capacity;
|
||||
u64 item_size;
|
||||
};
|
||||
|
||||
typedef struct C32Array C32Array;
|
||||
struct C32Array {
|
||||
c32 *items;
|
||||
u64 count;
|
||||
u64 capacity;
|
||||
u64 item_size;
|
||||
};
|
||||
|
||||
typedef struct I8Array I8Array;
|
||||
struct I8Array {
|
||||
i8 *items;
|
||||
u64 count;
|
||||
u64 capacity;
|
||||
u64 item_size;
|
||||
};
|
||||
|
||||
typedef struct I16Array I16Array;
|
||||
struct I16Array {
|
||||
i16 *items;
|
||||
u64 count;
|
||||
u64 capacity;
|
||||
u64 item_size;
|
||||
};
|
||||
|
||||
typedef struct I32Array I32Array;
|
||||
struct I32Array {
|
||||
i32 *items;
|
||||
u64 count;
|
||||
u64 capacity;
|
||||
u64 item_size;
|
||||
};
|
||||
|
||||
typedef struct I64Array I64Array;
|
||||
struct I64Array {
|
||||
i64 *items;
|
||||
u64 count;
|
||||
u64 capacity;
|
||||
u64 item_size;
|
||||
};
|
||||
|
||||
typedef struct U8Array U8Array;
|
||||
struct U8Array {
|
||||
u8 *items;
|
||||
u64 count;
|
||||
u64 capacity;
|
||||
u64 item_size;
|
||||
};
|
||||
|
||||
typedef struct U16Array U16Array;
|
||||
struct U16Array {
|
||||
u16 *items;
|
||||
u64 count;
|
||||
u64 capacity;
|
||||
u64 item_size;
|
||||
};
|
||||
|
||||
typedef struct U32Array U32Array;
|
||||
struct U32Array {
|
||||
u32 *items;
|
||||
u64 count;
|
||||
u64 capacity;
|
||||
u64 item_size;
|
||||
};
|
||||
|
||||
typedef struct U64Array U64Array;
|
||||
struct U64Array {
|
||||
u64 *items;
|
||||
u64 count;
|
||||
u64 capacity;
|
||||
u64 item_size;
|
||||
};
|
||||
|
||||
typedef struct F32Array F32Array;
|
||||
struct F32Array {
|
||||
f32 *items;
|
||||
u64 count;
|
||||
u64 capacity;
|
||||
u64 item_size;
|
||||
};
|
||||
|
||||
typedef struct F64Array F64Array;
|
||||
struct F64Array {
|
||||
f64 *items;
|
||||
u64 count;
|
||||
u64 capacity;
|
||||
u64 item_size;
|
||||
};
|
||||
|
||||
typedef struct F128Array F128Array;
|
||||
struct F128Array {
|
||||
f128 *items;
|
||||
u64 count;
|
||||
u64 capacity;
|
||||
u64 item_size;
|
||||
};
|
||||
|
||||
typedef struct IptrArray IptrArray;
|
||||
struct IptrArray {
|
||||
iptr *items;
|
||||
u64 count;
|
||||
u64 capacity;
|
||||
u64 item_size;
|
||||
};
|
||||
|
||||
typedef struct UptrArray UptrArray;
|
||||
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_extend_capped(Str8Array *array, const Str8Array *other);
|
||||
void wapp_str8_array_clear(Str8Array *array);
|
||||
void wapp_str8_array_copy_capped(const Str8Array *src, Str8Array *dst);
|
||||
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_extend_capped(VoidPArray *array, const VoidPArray *other);
|
||||
void wapp_void_ptr_array_clear(VoidPArray *array);
|
||||
void wapp_void_ptr_array_copy_capped(const VoidPArray *src, VoidPArray *dst);
|
||||
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);
|
||||
b32 *wapp_b32_array_get(const B32Array *array, u64 index);
|
||||
void wapp_b32_array_set(B32Array *array, u64 index, b32 *item);
|
||||
void wapp_b32_array_append_capped(B32Array *array, b32 *item);
|
||||
void wapp_b32_array_extend_capped(B32Array *array, const B32Array *other);
|
||||
void wapp_b32_array_clear(B32Array *array);
|
||||
void wapp_b32_array_copy_capped(const B32Array *src, B32Array *dst);
|
||||
B32Array *wapp_b32_array_append_alloc(const Allocator *allocator, B32Array *array, b32 *item);
|
||||
B32Array *wapp_b32_array_extend_alloc(const Allocator *allocator, B32Array *array, const B32Array *other);
|
||||
B32Array *wapp_b32_array_copy_alloc(const Allocator *allocator, const B32Array *src, B32Array *dst);
|
||||
b32 *_b32_array_pop(B32Array *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_extend_capped(CharArray *array, const CharArray *other);
|
||||
void wapp_char_array_clear(CharArray *array);
|
||||
void wapp_char_array_copy_capped(const CharArray *src, CharArray *dst);
|
||||
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_extend_capped(C8Array *array, const C8Array *other);
|
||||
void wapp_c8_array_clear(C8Array *array);
|
||||
void wapp_c8_array_copy_capped(const C8Array *src, C8Array *dst);
|
||||
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_extend_capped(C16Array *array, const C16Array *other);
|
||||
void wapp_c16_array_clear(C16Array *array);
|
||||
void wapp_c16_array_copy_capped(const C16Array *src, C16Array *dst);
|
||||
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_extend_capped(C32Array *array, const C32Array *other);
|
||||
void wapp_c32_array_clear(C32Array *array);
|
||||
void wapp_c32_array_copy_capped(const C32Array *src, C32Array *dst);
|
||||
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_extend_capped(I8Array *array, const I8Array *other);
|
||||
void wapp_i8_array_clear(I8Array *array);
|
||||
void wapp_i8_array_copy_capped(const I8Array *src, I8Array *dst);
|
||||
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_extend_capped(I16Array *array, const I16Array *other);
|
||||
void wapp_i16_array_clear(I16Array *array);
|
||||
void wapp_i16_array_copy_capped(const I16Array *src, I16Array *dst);
|
||||
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_extend_capped(I32Array *array, const I32Array *other);
|
||||
void wapp_i32_array_clear(I32Array *array);
|
||||
void wapp_i32_array_copy_capped(const I32Array *src, I32Array *dst);
|
||||
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_extend_capped(I64Array *array, const I64Array *other);
|
||||
void wapp_i64_array_clear(I64Array *array);
|
||||
void wapp_i64_array_copy_capped(const I64Array *src, I64Array *dst);
|
||||
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_extend_capped(U8Array *array, const U8Array *other);
|
||||
void wapp_u8_array_clear(U8Array *array);
|
||||
void wapp_u8_array_copy_capped(const U8Array *src, U8Array *dst);
|
||||
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_extend_capped(U16Array *array, const U16Array *other);
|
||||
void wapp_u16_array_clear(U16Array *array);
|
||||
void wapp_u16_array_copy_capped(const U16Array *src, U16Array *dst);
|
||||
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_extend_capped(U32Array *array, const U32Array *other);
|
||||
void wapp_u32_array_clear(U32Array *array);
|
||||
void wapp_u32_array_copy_capped(const U32Array *src, U32Array *dst);
|
||||
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_extend_capped(U64Array *array, const U64Array *other);
|
||||
void wapp_u64_array_clear(U64Array *array);
|
||||
void wapp_u64_array_copy_capped(const U64Array *src, U64Array *dst);
|
||||
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_extend_capped(F32Array *array, const F32Array *other);
|
||||
void wapp_f32_array_clear(F32Array *array);
|
||||
void wapp_f32_array_copy_capped(const F32Array *src, F32Array *dst);
|
||||
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_extend_capped(F64Array *array, const F64Array *other);
|
||||
void wapp_f64_array_clear(F64Array *array);
|
||||
void wapp_f64_array_copy_capped(const F64Array *src, F64Array *dst);
|
||||
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_extend_capped(F128Array *array, const F128Array *other);
|
||||
void wapp_f128_array_clear(F128Array *array);
|
||||
void wapp_f128_array_copy_capped(const F128Array *src, F128Array *dst);
|
||||
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_extend_capped(IptrArray *array, const IptrArray *other);
|
||||
void wapp_iptr_array_clear(IptrArray *array);
|
||||
void wapp_iptr_array_copy_capped(const IptrArray *src, IptrArray *dst);
|
||||
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_extend_capped(UptrArray *array, const UptrArray *other);
|
||||
void wapp_uptr_array_clear(UptrArray *array);
|
||||
void wapp_uptr_array_copy_capped(const UptrArray *src, UptrArray *dst);
|
||||
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);
|
||||
|
||||
#ifdef WAPP_PLATFORM_CPP
|
||||
END_C_LINKAGE
|
||||
#endif // !WAPP_PLATFORM_CPP
|
||||
|
||||
#endif // !ARRAY_H
|
||||
3813
wapp/primitives/dbl_list/dbl_list.c
Normal file
3813
wapp/primitives/dbl_list/dbl_list.c
Normal file
File diff suppressed because it is too large
Load Diff
507
wapp/primitives/dbl_list/dbl_list.h
Normal file
507
wapp/primitives/dbl_list/dbl_list.h
Normal file
@@ -0,0 +1,507 @@
|
||||
/**
|
||||
* THIS FILE IS AUTOMATICALLY GENERATED. ANY MODIFICATIONS TO IT WILL BE OVERWRITTEN
|
||||
*/
|
||||
|
||||
#ifndef DBL_LIST_H
|
||||
#define DBL_LIST_H
|
||||
|
||||
#include "../../common/aliases/aliases.h"
|
||||
#include "../../common/aliases/aliases.h"
|
||||
#include "../../common/platform/platform.h"
|
||||
|
||||
#ifdef WAPP_PLATFORM_CPP
|
||||
BEGIN_C_LINKAGE
|
||||
#endif // !WAPP_PLATFORM_CPP
|
||||
|
||||
#ifdef WAPP_PLATFORM_CPP
|
||||
#define wapp_str8_list_node(ITEM_PTR) Str8Node{ITEM_PTR, nullptr, nullptr}
|
||||
#define wapp_void_ptr_list_node(ITEM_PTR) VoidPNode{ITEM_PTR, nullptr, nullptr}
|
||||
#define wapp_b32_list_node(ITEM_PTR) B32Node{ITEM_PTR, nullptr, nullptr}
|
||||
#define wapp_char_list_node(ITEM_PTR) CharNode{ITEM_PTR, nullptr, nullptr}
|
||||
#define wapp_c8_list_node(ITEM_PTR) C8Node{ITEM_PTR, nullptr, nullptr}
|
||||
#define wapp_c16_list_node(ITEM_PTR) C16Node{ITEM_PTR, nullptr, nullptr}
|
||||
#define wapp_c32_list_node(ITEM_PTR) C32Node{ITEM_PTR, nullptr, nullptr}
|
||||
#define wapp_i8_list_node(ITEM_PTR) I8Node{ITEM_PTR, nullptr, nullptr}
|
||||
#define wapp_i16_list_node(ITEM_PTR) I16Node{ITEM_PTR, nullptr, nullptr}
|
||||
#define wapp_i32_list_node(ITEM_PTR) I32Node{ITEM_PTR, nullptr, nullptr}
|
||||
#define wapp_i64_list_node(ITEM_PTR) I64Node{ITEM_PTR, nullptr, nullptr}
|
||||
#define wapp_u8_list_node(ITEM_PTR) U8Node{ITEM_PTR, nullptr, nullptr}
|
||||
#define wapp_u16_list_node(ITEM_PTR) U16Node{ITEM_PTR, nullptr, nullptr}
|
||||
#define wapp_u32_list_node(ITEM_PTR) U32Node{ITEM_PTR, nullptr, nullptr}
|
||||
#define wapp_u64_list_node(ITEM_PTR) U64Node{ITEM_PTR, nullptr, nullptr}
|
||||
#define wapp_f32_list_node(ITEM_PTR) F32Node{ITEM_PTR, nullptr, nullptr}
|
||||
#define wapp_f64_list_node(ITEM_PTR) F64Node{ITEM_PTR, nullptr, nullptr}
|
||||
#define wapp_f128_list_node(ITEM_PTR) F128Node{ITEM_PTR, nullptr, nullptr}
|
||||
#define wapp_iptr_list_node(ITEM_PTR) IptrNode{ITEM_PTR, nullptr, nullptr}
|
||||
#define wapp_uptr_list_node(ITEM_PTR) UptrNode{ITEM_PTR, nullptr, nullptr}
|
||||
#else
|
||||
#define wapp_str8_list_node(ITEM_PTR) ((Str8Node){.item = ITEM_PTR})
|
||||
#define wapp_void_ptr_list_node(ITEM_PTR) ((VoidPNode){.item = ITEM_PTR})
|
||||
#define wapp_b32_list_node(ITEM_PTR) ((B32Node){.item = ITEM_PTR})
|
||||
#define wapp_char_list_node(ITEM_PTR) ((CharNode){.item = ITEM_PTR})
|
||||
#define wapp_c8_list_node(ITEM_PTR) ((C8Node){.item = ITEM_PTR})
|
||||
#define wapp_c16_list_node(ITEM_PTR) ((C16Node){.item = ITEM_PTR})
|
||||
#define wapp_c32_list_node(ITEM_PTR) ((C32Node){.item = ITEM_PTR})
|
||||
#define wapp_i8_list_node(ITEM_PTR) ((I8Node){.item = ITEM_PTR})
|
||||
#define wapp_i16_list_node(ITEM_PTR) ((I16Node){.item = ITEM_PTR})
|
||||
#define wapp_i32_list_node(ITEM_PTR) ((I32Node){.item = ITEM_PTR})
|
||||
#define wapp_i64_list_node(ITEM_PTR) ((I64Node){.item = ITEM_PTR})
|
||||
#define wapp_u8_list_node(ITEM_PTR) ((U8Node){.item = ITEM_PTR})
|
||||
#define wapp_u16_list_node(ITEM_PTR) ((U16Node){.item = ITEM_PTR})
|
||||
#define wapp_u32_list_node(ITEM_PTR) ((U32Node){.item = ITEM_PTR})
|
||||
#define wapp_u64_list_node(ITEM_PTR) ((U64Node){.item = ITEM_PTR})
|
||||
#define wapp_f32_list_node(ITEM_PTR) ((F32Node){.item = ITEM_PTR})
|
||||
#define wapp_f64_list_node(ITEM_PTR) ((F64Node){.item = ITEM_PTR})
|
||||
#define wapp_f128_list_node(ITEM_PTR) ((F128Node){.item = ITEM_PTR})
|
||||
#define wapp_iptr_list_node(ITEM_PTR) ((IptrNode){.item = ITEM_PTR})
|
||||
#define wapp_uptr_list_node(ITEM_PTR) ((UptrNode){.item = ITEM_PTR})
|
||||
#endif // !WAPP_PLATFORM_CPP
|
||||
|
||||
typedef struct str8 Str8;
|
||||
|
||||
typedef struct Str8Node Str8Node;
|
||||
struct Str8Node {
|
||||
Str8 *item;
|
||||
Str8Node *prev;
|
||||
Str8Node *next;
|
||||
};
|
||||
|
||||
typedef struct Str8List Str8List;
|
||||
struct Str8List {
|
||||
Str8Node *first;
|
||||
Str8Node *last;
|
||||
u64 node_count;
|
||||
};
|
||||
|
||||
typedef struct VoidPNode VoidPNode;
|
||||
struct VoidPNode {
|
||||
void * *item;
|
||||
VoidPNode *prev;
|
||||
VoidPNode *next;
|
||||
};
|
||||
|
||||
typedef struct VoidPList VoidPList;
|
||||
struct VoidPList {
|
||||
VoidPNode *first;
|
||||
VoidPNode *last;
|
||||
u64 node_count;
|
||||
};
|
||||
|
||||
typedef struct B32Node B32Node;
|
||||
struct B32Node {
|
||||
b32 *item;
|
||||
B32Node *prev;
|
||||
B32Node *next;
|
||||
};
|
||||
|
||||
typedef struct B32List B32List;
|
||||
struct B32List {
|
||||
B32Node *first;
|
||||
B32Node *last;
|
||||
u64 node_count;
|
||||
};
|
||||
|
||||
typedef struct CharNode CharNode;
|
||||
struct CharNode {
|
||||
char *item;
|
||||
CharNode *prev;
|
||||
CharNode *next;
|
||||
};
|
||||
|
||||
typedef struct CharList CharList;
|
||||
struct CharList {
|
||||
CharNode *first;
|
||||
CharNode *last;
|
||||
u64 node_count;
|
||||
};
|
||||
|
||||
typedef struct C8Node C8Node;
|
||||
struct C8Node {
|
||||
c8 *item;
|
||||
C8Node *prev;
|
||||
C8Node *next;
|
||||
};
|
||||
|
||||
typedef struct C8List C8List;
|
||||
struct C8List {
|
||||
C8Node *first;
|
||||
C8Node *last;
|
||||
u64 node_count;
|
||||
};
|
||||
|
||||
typedef struct C16Node C16Node;
|
||||
struct C16Node {
|
||||
c16 *item;
|
||||
C16Node *prev;
|
||||
C16Node *next;
|
||||
};
|
||||
|
||||
typedef struct C16List C16List;
|
||||
struct C16List {
|
||||
C16Node *first;
|
||||
C16Node *last;
|
||||
u64 node_count;
|
||||
};
|
||||
|
||||
typedef struct C32Node C32Node;
|
||||
struct C32Node {
|
||||
c32 *item;
|
||||
C32Node *prev;
|
||||
C32Node *next;
|
||||
};
|
||||
|
||||
typedef struct C32List C32List;
|
||||
struct C32List {
|
||||
C32Node *first;
|
||||
C32Node *last;
|
||||
u64 node_count;
|
||||
};
|
||||
|
||||
typedef struct I8Node I8Node;
|
||||
struct I8Node {
|
||||
i8 *item;
|
||||
I8Node *prev;
|
||||
I8Node *next;
|
||||
};
|
||||
|
||||
typedef struct I8List I8List;
|
||||
struct I8List {
|
||||
I8Node *first;
|
||||
I8Node *last;
|
||||
u64 node_count;
|
||||
};
|
||||
|
||||
typedef struct I16Node I16Node;
|
||||
struct I16Node {
|
||||
i16 *item;
|
||||
I16Node *prev;
|
||||
I16Node *next;
|
||||
};
|
||||
|
||||
typedef struct I16List I16List;
|
||||
struct I16List {
|
||||
I16Node *first;
|
||||
I16Node *last;
|
||||
u64 node_count;
|
||||
};
|
||||
|
||||
typedef struct I32Node I32Node;
|
||||
struct I32Node {
|
||||
i32 *item;
|
||||
I32Node *prev;
|
||||
I32Node *next;
|
||||
};
|
||||
|
||||
typedef struct I32List I32List;
|
||||
struct I32List {
|
||||
I32Node *first;
|
||||
I32Node *last;
|
||||
u64 node_count;
|
||||
};
|
||||
|
||||
typedef struct I64Node I64Node;
|
||||
struct I64Node {
|
||||
i64 *item;
|
||||
I64Node *prev;
|
||||
I64Node *next;
|
||||
};
|
||||
|
||||
typedef struct I64List I64List;
|
||||
struct I64List {
|
||||
I64Node *first;
|
||||
I64Node *last;
|
||||
u64 node_count;
|
||||
};
|
||||
|
||||
typedef struct U8Node U8Node;
|
||||
struct U8Node {
|
||||
u8 *item;
|
||||
U8Node *prev;
|
||||
U8Node *next;
|
||||
};
|
||||
|
||||
typedef struct U8List U8List;
|
||||
struct U8List {
|
||||
U8Node *first;
|
||||
U8Node *last;
|
||||
u64 node_count;
|
||||
};
|
||||
|
||||
typedef struct U16Node U16Node;
|
||||
struct U16Node {
|
||||
u16 *item;
|
||||
U16Node *prev;
|
||||
U16Node *next;
|
||||
};
|
||||
|
||||
typedef struct U16List U16List;
|
||||
struct U16List {
|
||||
U16Node *first;
|
||||
U16Node *last;
|
||||
u64 node_count;
|
||||
};
|
||||
|
||||
typedef struct U32Node U32Node;
|
||||
struct U32Node {
|
||||
u32 *item;
|
||||
U32Node *prev;
|
||||
U32Node *next;
|
||||
};
|
||||
|
||||
typedef struct U32List U32List;
|
||||
struct U32List {
|
||||
U32Node *first;
|
||||
U32Node *last;
|
||||
u64 node_count;
|
||||
};
|
||||
|
||||
typedef struct U64Node U64Node;
|
||||
struct U64Node {
|
||||
u64 *item;
|
||||
U64Node *prev;
|
||||
U64Node *next;
|
||||
};
|
||||
|
||||
typedef struct U64List U64List;
|
||||
struct U64List {
|
||||
U64Node *first;
|
||||
U64Node *last;
|
||||
u64 node_count;
|
||||
};
|
||||
|
||||
typedef struct F32Node F32Node;
|
||||
struct F32Node {
|
||||
f32 *item;
|
||||
F32Node *prev;
|
||||
F32Node *next;
|
||||
};
|
||||
|
||||
typedef struct F32List F32List;
|
||||
struct F32List {
|
||||
F32Node *first;
|
||||
F32Node *last;
|
||||
u64 node_count;
|
||||
};
|
||||
|
||||
typedef struct F64Node F64Node;
|
||||
struct F64Node {
|
||||
f64 *item;
|
||||
F64Node *prev;
|
||||
F64Node *next;
|
||||
};
|
||||
|
||||
typedef struct F64List F64List;
|
||||
struct F64List {
|
||||
F64Node *first;
|
||||
F64Node *last;
|
||||
u64 node_count;
|
||||
};
|
||||
|
||||
typedef struct F128Node F128Node;
|
||||
struct F128Node {
|
||||
f128 *item;
|
||||
F128Node *prev;
|
||||
F128Node *next;
|
||||
};
|
||||
|
||||
typedef struct F128List F128List;
|
||||
struct F128List {
|
||||
F128Node *first;
|
||||
F128Node *last;
|
||||
u64 node_count;
|
||||
};
|
||||
|
||||
typedef struct IptrNode IptrNode;
|
||||
struct IptrNode {
|
||||
iptr *item;
|
||||
IptrNode *prev;
|
||||
IptrNode *next;
|
||||
};
|
||||
|
||||
typedef struct IptrList IptrList;
|
||||
struct IptrList {
|
||||
IptrNode *first;
|
||||
IptrNode *last;
|
||||
u64 node_count;
|
||||
};
|
||||
|
||||
typedef struct UptrNode UptrNode;
|
||||
struct UptrNode {
|
||||
uptr *item;
|
||||
UptrNode *prev;
|
||||
UptrNode *next;
|
||||
};
|
||||
|
||||
typedef struct UptrList UptrList;
|
||||
struct UptrList {
|
||||
UptrNode *first;
|
||||
UptrNode *last;
|
||||
u64 node_count;
|
||||
};
|
||||
|
||||
Str8Node *wapp_str8_list_get(const Str8List *list, u64 index);
|
||||
void wapp_str8_list_push_front(Str8List *list, Str8Node *node);
|
||||
void wapp_str8_list_push_back(Str8List *list, Str8Node *node);
|
||||
void wapp_str8_list_insert(Str8List *list, Str8Node *node, u64 index);
|
||||
Str8Node *wapp_str8_list_pop_front(Str8List *list);
|
||||
Str8Node *wapp_str8_list_pop_back(Str8List *list);
|
||||
Str8Node *wapp_str8_list_remove(Str8List *list, u64 index);
|
||||
void wapp_str8_list_empty(Str8List *list);
|
||||
VoidPNode *wapp_void_ptr_list_get(const VoidPList *list, u64 index);
|
||||
void wapp_void_ptr_list_push_front(VoidPList *list, VoidPNode *node);
|
||||
void wapp_void_ptr_list_push_back(VoidPList *list, VoidPNode *node);
|
||||
void wapp_void_ptr_list_insert(VoidPList *list, VoidPNode *node, u64 index);
|
||||
VoidPNode *wapp_void_ptr_list_pop_front(VoidPList *list);
|
||||
VoidPNode *wapp_void_ptr_list_pop_back(VoidPList *list);
|
||||
VoidPNode *wapp_void_ptr_list_remove(VoidPList *list, u64 index);
|
||||
void wapp_void_ptr_list_empty(VoidPList *list);
|
||||
B32Node *wapp_b32_list_get(const B32List *list, u64 index);
|
||||
void wapp_b32_list_push_front(B32List *list, B32Node *node);
|
||||
void wapp_b32_list_push_back(B32List *list, B32Node *node);
|
||||
void wapp_b32_list_insert(B32List *list, B32Node *node, u64 index);
|
||||
B32Node *wapp_b32_list_pop_front(B32List *list);
|
||||
B32Node *wapp_b32_list_pop_back(B32List *list);
|
||||
B32Node *wapp_b32_list_remove(B32List *list, u64 index);
|
||||
void wapp_b32_list_empty(B32List *list);
|
||||
CharNode *wapp_char_list_get(const CharList *list, u64 index);
|
||||
void wapp_char_list_push_front(CharList *list, CharNode *node);
|
||||
void wapp_char_list_push_back(CharList *list, CharNode *node);
|
||||
void wapp_char_list_insert(CharList *list, CharNode *node, u64 index);
|
||||
CharNode *wapp_char_list_pop_front(CharList *list);
|
||||
CharNode *wapp_char_list_pop_back(CharList *list);
|
||||
CharNode *wapp_char_list_remove(CharList *list, u64 index);
|
||||
void wapp_char_list_empty(CharList *list);
|
||||
C8Node *wapp_c8_list_get(const C8List *list, u64 index);
|
||||
void wapp_c8_list_push_front(C8List *list, C8Node *node);
|
||||
void wapp_c8_list_push_back(C8List *list, C8Node *node);
|
||||
void wapp_c8_list_insert(C8List *list, C8Node *node, u64 index);
|
||||
C8Node *wapp_c8_list_pop_front(C8List *list);
|
||||
C8Node *wapp_c8_list_pop_back(C8List *list);
|
||||
C8Node *wapp_c8_list_remove(C8List *list, u64 index);
|
||||
void wapp_c8_list_empty(C8List *list);
|
||||
C16Node *wapp_c16_list_get(const C16List *list, u64 index);
|
||||
void wapp_c16_list_push_front(C16List *list, C16Node *node);
|
||||
void wapp_c16_list_push_back(C16List *list, C16Node *node);
|
||||
void wapp_c16_list_insert(C16List *list, C16Node *node, u64 index);
|
||||
C16Node *wapp_c16_list_pop_front(C16List *list);
|
||||
C16Node *wapp_c16_list_pop_back(C16List *list);
|
||||
C16Node *wapp_c16_list_remove(C16List *list, u64 index);
|
||||
void wapp_c16_list_empty(C16List *list);
|
||||
C32Node *wapp_c32_list_get(const C32List *list, u64 index);
|
||||
void wapp_c32_list_push_front(C32List *list, C32Node *node);
|
||||
void wapp_c32_list_push_back(C32List *list, C32Node *node);
|
||||
void wapp_c32_list_insert(C32List *list, C32Node *node, u64 index);
|
||||
C32Node *wapp_c32_list_pop_front(C32List *list);
|
||||
C32Node *wapp_c32_list_pop_back(C32List *list);
|
||||
C32Node *wapp_c32_list_remove(C32List *list, u64 index);
|
||||
void wapp_c32_list_empty(C32List *list);
|
||||
I8Node *wapp_i8_list_get(const I8List *list, u64 index);
|
||||
void wapp_i8_list_push_front(I8List *list, I8Node *node);
|
||||
void wapp_i8_list_push_back(I8List *list, I8Node *node);
|
||||
void wapp_i8_list_insert(I8List *list, I8Node *node, u64 index);
|
||||
I8Node *wapp_i8_list_pop_front(I8List *list);
|
||||
I8Node *wapp_i8_list_pop_back(I8List *list);
|
||||
I8Node *wapp_i8_list_remove(I8List *list, u64 index);
|
||||
void wapp_i8_list_empty(I8List *list);
|
||||
I16Node *wapp_i16_list_get(const I16List *list, u64 index);
|
||||
void wapp_i16_list_push_front(I16List *list, I16Node *node);
|
||||
void wapp_i16_list_push_back(I16List *list, I16Node *node);
|
||||
void wapp_i16_list_insert(I16List *list, I16Node *node, u64 index);
|
||||
I16Node *wapp_i16_list_pop_front(I16List *list);
|
||||
I16Node *wapp_i16_list_pop_back(I16List *list);
|
||||
I16Node *wapp_i16_list_remove(I16List *list, u64 index);
|
||||
void wapp_i16_list_empty(I16List *list);
|
||||
I32Node *wapp_i32_list_get(const I32List *list, u64 index);
|
||||
void wapp_i32_list_push_front(I32List *list, I32Node *node);
|
||||
void wapp_i32_list_push_back(I32List *list, I32Node *node);
|
||||
void wapp_i32_list_insert(I32List *list, I32Node *node, u64 index);
|
||||
I32Node *wapp_i32_list_pop_front(I32List *list);
|
||||
I32Node *wapp_i32_list_pop_back(I32List *list);
|
||||
I32Node *wapp_i32_list_remove(I32List *list, u64 index);
|
||||
void wapp_i32_list_empty(I32List *list);
|
||||
I64Node *wapp_i64_list_get(const I64List *list, u64 index);
|
||||
void wapp_i64_list_push_front(I64List *list, I64Node *node);
|
||||
void wapp_i64_list_push_back(I64List *list, I64Node *node);
|
||||
void wapp_i64_list_insert(I64List *list, I64Node *node, u64 index);
|
||||
I64Node *wapp_i64_list_pop_front(I64List *list);
|
||||
I64Node *wapp_i64_list_pop_back(I64List *list);
|
||||
I64Node *wapp_i64_list_remove(I64List *list, u64 index);
|
||||
void wapp_i64_list_empty(I64List *list);
|
||||
U8Node *wapp_u8_list_get(const U8List *list, u64 index);
|
||||
void wapp_u8_list_push_front(U8List *list, U8Node *node);
|
||||
void wapp_u8_list_push_back(U8List *list, U8Node *node);
|
||||
void wapp_u8_list_insert(U8List *list, U8Node *node, u64 index);
|
||||
U8Node *wapp_u8_list_pop_front(U8List *list);
|
||||
U8Node *wapp_u8_list_pop_back(U8List *list);
|
||||
U8Node *wapp_u8_list_remove(U8List *list, u64 index);
|
||||
void wapp_u8_list_empty(U8List *list);
|
||||
U16Node *wapp_u16_list_get(const U16List *list, u64 index);
|
||||
void wapp_u16_list_push_front(U16List *list, U16Node *node);
|
||||
void wapp_u16_list_push_back(U16List *list, U16Node *node);
|
||||
void wapp_u16_list_insert(U16List *list, U16Node *node, u64 index);
|
||||
U16Node *wapp_u16_list_pop_front(U16List *list);
|
||||
U16Node *wapp_u16_list_pop_back(U16List *list);
|
||||
U16Node *wapp_u16_list_remove(U16List *list, u64 index);
|
||||
void wapp_u16_list_empty(U16List *list);
|
||||
U32Node *wapp_u32_list_get(const U32List *list, u64 index);
|
||||
void wapp_u32_list_push_front(U32List *list, U32Node *node);
|
||||
void wapp_u32_list_push_back(U32List *list, U32Node *node);
|
||||
void wapp_u32_list_insert(U32List *list, U32Node *node, u64 index);
|
||||
U32Node *wapp_u32_list_pop_front(U32List *list);
|
||||
U32Node *wapp_u32_list_pop_back(U32List *list);
|
||||
U32Node *wapp_u32_list_remove(U32List *list, u64 index);
|
||||
void wapp_u32_list_empty(U32List *list);
|
||||
U64Node *wapp_u64_list_get(const U64List *list, u64 index);
|
||||
void wapp_u64_list_push_front(U64List *list, U64Node *node);
|
||||
void wapp_u64_list_push_back(U64List *list, U64Node *node);
|
||||
void wapp_u64_list_insert(U64List *list, U64Node *node, u64 index);
|
||||
U64Node *wapp_u64_list_pop_front(U64List *list);
|
||||
U64Node *wapp_u64_list_pop_back(U64List *list);
|
||||
U64Node *wapp_u64_list_remove(U64List *list, u64 index);
|
||||
void wapp_u64_list_empty(U64List *list);
|
||||
F32Node *wapp_f32_list_get(const F32List *list, u64 index);
|
||||
void wapp_f32_list_push_front(F32List *list, F32Node *node);
|
||||
void wapp_f32_list_push_back(F32List *list, F32Node *node);
|
||||
void wapp_f32_list_insert(F32List *list, F32Node *node, u64 index);
|
||||
F32Node *wapp_f32_list_pop_front(F32List *list);
|
||||
F32Node *wapp_f32_list_pop_back(F32List *list);
|
||||
F32Node *wapp_f32_list_remove(F32List *list, u64 index);
|
||||
void wapp_f32_list_empty(F32List *list);
|
||||
F64Node *wapp_f64_list_get(const F64List *list, u64 index);
|
||||
void wapp_f64_list_push_front(F64List *list, F64Node *node);
|
||||
void wapp_f64_list_push_back(F64List *list, F64Node *node);
|
||||
void wapp_f64_list_insert(F64List *list, F64Node *node, u64 index);
|
||||
F64Node *wapp_f64_list_pop_front(F64List *list);
|
||||
F64Node *wapp_f64_list_pop_back(F64List *list);
|
||||
F64Node *wapp_f64_list_remove(F64List *list, u64 index);
|
||||
void wapp_f64_list_empty(F64List *list);
|
||||
F128Node *wapp_f128_list_get(const F128List *list, u64 index);
|
||||
void wapp_f128_list_push_front(F128List *list, F128Node *node);
|
||||
void wapp_f128_list_push_back(F128List *list, F128Node *node);
|
||||
void wapp_f128_list_insert(F128List *list, F128Node *node, u64 index);
|
||||
F128Node *wapp_f128_list_pop_front(F128List *list);
|
||||
F128Node *wapp_f128_list_pop_back(F128List *list);
|
||||
F128Node *wapp_f128_list_remove(F128List *list, u64 index);
|
||||
void wapp_f128_list_empty(F128List *list);
|
||||
IptrNode *wapp_iptr_list_get(const IptrList *list, u64 index);
|
||||
void wapp_iptr_list_push_front(IptrList *list, IptrNode *node);
|
||||
void wapp_iptr_list_push_back(IptrList *list, IptrNode *node);
|
||||
void wapp_iptr_list_insert(IptrList *list, IptrNode *node, u64 index);
|
||||
IptrNode *wapp_iptr_list_pop_front(IptrList *list);
|
||||
IptrNode *wapp_iptr_list_pop_back(IptrList *list);
|
||||
IptrNode *wapp_iptr_list_remove(IptrList *list, u64 index);
|
||||
void wapp_iptr_list_empty(IptrList *list);
|
||||
UptrNode *wapp_uptr_list_get(const UptrList *list, u64 index);
|
||||
void wapp_uptr_list_push_front(UptrList *list, UptrNode *node);
|
||||
void wapp_uptr_list_push_back(UptrList *list, UptrNode *node);
|
||||
void wapp_uptr_list_insert(UptrList *list, UptrNode *node, u64 index);
|
||||
UptrNode *wapp_uptr_list_pop_front(UptrList *list);
|
||||
UptrNode *wapp_uptr_list_pop_back(UptrList *list);
|
||||
UptrNode *wapp_uptr_list_remove(UptrList *list, u64 index);
|
||||
void wapp_uptr_list_empty(UptrList *list);
|
||||
|
||||
#ifdef WAPP_PLATFORM_CPP
|
||||
END_C_LINKAGE
|
||||
#endif // !WAPP_PLATFORM_CPP
|
||||
|
||||
#endif // !DBL_LIST_H
|
||||
35
wapp/primitives/mem_allocator/mem_allocator.c
Normal file
35
wapp/primitives/mem_allocator/mem_allocator.c
Normal file
@@ -0,0 +1,35 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#include "mem_allocator.h"
|
||||
#include "../../common/aliases/aliases.h"
|
||||
#include "../../common/assert/assert.h"
|
||||
#include <stdlib.h>
|
||||
|
||||
void *wapp_mem_allocator_alloc(const Allocator *allocator, u64 size) {
|
||||
wapp_debug_assert(allocator != NULL && (allocator->alloc) != NULL, "`allocator` and `allocator->alloc` should not be NULL");
|
||||
return allocator->alloc(size, allocator->obj);
|
||||
}
|
||||
|
||||
void *wapp_mem_allocator_alloc_aligned(const Allocator *allocator, u64 size, u64 alignment) {
|
||||
wapp_debug_assert(allocator != NULL && (allocator->alloc_aligned) != NULL, "`allocator` and `allocator->alloc_aligned` should not be NULL");
|
||||
return allocator->alloc_aligned(size, alignment, allocator->obj);
|
||||
}
|
||||
|
||||
void *wapp_mem_allocator_realloc(const Allocator *allocator, void *ptr, u64 old_size, u64 new_size) {
|
||||
wapp_debug_assert(allocator != NULL && (allocator->realloc) != NULL, "`allocator` and `allocator->realloc` should not be NULL");
|
||||
return allocator->realloc(ptr, old_size, new_size, allocator->obj);
|
||||
}
|
||||
|
||||
void *wapp_mem_allocator_realloc_aligned(const Allocator *allocator, void *ptr, u64 old_size,
|
||||
u64 new_size, u64 alignment) {
|
||||
wapp_debug_assert(allocator != NULL && (allocator->realloc_aligned) != NULL, "`allocator` and `allocator->realloc_aligned` should not be NULL");
|
||||
return allocator->realloc_aligned(ptr, old_size, new_size, alignment, allocator->obj);
|
||||
}
|
||||
|
||||
void wapp_mem_allocator_free(const Allocator *allocator, void **ptr, u64 size) {
|
||||
if (!allocator || !(allocator->free)) {
|
||||
return;
|
||||
}
|
||||
|
||||
allocator->free(ptr, size, allocator->obj);
|
||||
}
|
||||
50
wapp/primitives/mem_allocator/mem_allocator.h
Normal file
50
wapp/primitives/mem_allocator/mem_allocator.h
Normal file
@@ -0,0 +1,50 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#ifndef MEM_ALLOCATOR_H
|
||||
#define MEM_ALLOCATOR_H
|
||||
|
||||
#include "../../common/aliases/aliases.h"
|
||||
#include "../../common/platform/platform.h"
|
||||
#include <string.h>
|
||||
|
||||
#ifdef WAPP_PLATFORM_CPP
|
||||
BEGIN_C_LINKAGE
|
||||
#endif // !WAPP_PLATFORM_CPP
|
||||
|
||||
typedef void *(MemAllocFunc)(u64 size, void *alloc_obj);
|
||||
typedef void *(MemAllocAlignedFunc)(u64 size, u64 alignment, void *alloc_obj);
|
||||
typedef void *(MemReallocFunc)(void *ptr, u64 old_size, u64 new_size, void *alloc_obj);
|
||||
typedef void *(MemReallocAlignedFunc)(void *ptr, u64 old_size, u64 new_size, u64 alignment, void *alloc_obj);
|
||||
typedef void (MemFreeFunc)(void **ptr, u64 size, void *alloc_obj);
|
||||
|
||||
typedef struct allocator Allocator;
|
||||
struct allocator {
|
||||
void *obj;
|
||||
MemAllocFunc *alloc;
|
||||
MemAllocAlignedFunc *alloc_aligned;
|
||||
MemReallocFunc *realloc;
|
||||
MemReallocAlignedFunc *realloc_aligned;
|
||||
MemFreeFunc *free;
|
||||
};
|
||||
|
||||
#ifdef WAPP_PLATFORM_CPP
|
||||
#define wapp_mem_allocator_invalid(ALLOCATOR) ([&]() { \
|
||||
Allocator alloc{}; \
|
||||
return memcmp(ALLOCATOR, &alloc, sizeof(Allocator)) == 0; \
|
||||
}())
|
||||
#else
|
||||
#define wapp_mem_allocator_invalid(ALLOCATOR) (memcmp(ALLOCATOR, &((Allocator){0}), sizeof(Allocator)) == 0)
|
||||
#endif // !WAPP_PLATFORM_CPP
|
||||
|
||||
void *wapp_mem_allocator_alloc(const Allocator *allocator, u64 size);
|
||||
void *wapp_mem_allocator_alloc_aligned(const Allocator *allocator, u64 size, u64 alignment);
|
||||
void *wapp_mem_allocator_realloc(const Allocator *allocator, void *ptr, u64 old_size, u64 new_size);
|
||||
void *wapp_mem_allocator_realloc_aligned(const Allocator *allocator, void *ptr, u64 old_size,
|
||||
u64 new_size, u64 alignment);
|
||||
void wapp_mem_allocator_free(const Allocator *allocator, void **ptr, u64 size);
|
||||
|
||||
#ifdef WAPP_PLATFORM_CPP
|
||||
END_C_LINKAGE
|
||||
#endif // !WAPP_PLATFORM_CPP
|
||||
|
||||
#endif // !MEM_ALLOCATOR_H
|
||||
446
wapp/primitives/strings/str8/str8.c
Normal file
446
wapp/primitives/strings/str8/str8.c
Normal file
@@ -0,0 +1,446 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#include "str8.h"
|
||||
#include "../../../common/aliases/aliases.h"
|
||||
#include "../../../common/assert/assert.h"
|
||||
#include "../../mem_allocator/mem_allocator.h"
|
||||
#include <stdarg.h>
|
||||
#include <stddef.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
#define STR8_BUF_ALLOC_SIZE(CAPACITY) (sizeof(Str8) + sizeof(c8) * CAPACITY)
|
||||
|
||||
Str8 *wapp_str8_alloc_buf(const Allocator *allocator, u64 capacity) {
|
||||
wapp_debug_assert(allocator != NULL, "`allocator` should not be NULL");
|
||||
|
||||
Str8 *str = wapp_mem_allocator_alloc(allocator, STR8_BUF_ALLOC_SIZE(capacity));
|
||||
if (!str) {
|
||||
goto RETURN_STR8;
|
||||
}
|
||||
|
||||
str->buf = (u8 *)str + sizeof(Str8);
|
||||
str->size = 0;
|
||||
str->capacity = capacity;
|
||||
|
||||
RETURN_STR8:
|
||||
return str;
|
||||
}
|
||||
|
||||
Str8 *wapp_str8_alloc_and_fill_buf(const Allocator *allocator, u64 capacity) {
|
||||
Str8 *out = wapp_str8_alloc_buf(allocator, capacity);
|
||||
if (out) {
|
||||
memset(out->buf, 0, capacity);
|
||||
out->size = capacity;
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
Str8 *wapp_str8_alloc_cstr(const Allocator *allocator, const char *str) {
|
||||
wapp_debug_assert(allocator != NULL && str != NULL, "`allocator` and `str` should not be NULL");
|
||||
|
||||
u64 length = strlen(str);
|
||||
Str8 *output = wapp_str8_alloc_buf(allocator, length * 2);
|
||||
if (!output) {
|
||||
goto RETURN_ALLOC_CSTR;
|
||||
}
|
||||
|
||||
output->size = length;
|
||||
memcpy(output->buf, str, length);
|
||||
|
||||
RETURN_ALLOC_CSTR:
|
||||
return output;
|
||||
}
|
||||
|
||||
Str8 *wapp_str8_alloc_str8(const Allocator *allocator, Str8RO *str) {
|
||||
wapp_debug_assert(allocator != NULL && str != NULL, "`allocator` and `str` should not be NULL");
|
||||
|
||||
Str8 *output = wapp_str8_alloc_buf(allocator, str->capacity);
|
||||
if (!output) {
|
||||
goto RETURN_ALLOC_STR8;
|
||||
}
|
||||
|
||||
output->size = str->size;
|
||||
memcpy(output->buf, str->buf, str->size);
|
||||
|
||||
RETURN_ALLOC_STR8:
|
||||
return output;
|
||||
}
|
||||
|
||||
Str8 *wapp_str8_alloc_substr(const Allocator *allocator, Str8RO *str, u64 start, u64 end) {
|
||||
wapp_debug_assert(allocator != NULL && str != NULL, "`allocator` and `str` should not be NULL");
|
||||
|
||||
Str8 *output = NULL;
|
||||
|
||||
if (start >= str->size || start >= end) {
|
||||
goto RETURN_ALLOC_SUBSTR;
|
||||
}
|
||||
|
||||
if (end > str->size) {
|
||||
end = str->size;
|
||||
}
|
||||
|
||||
output = wapp_str8_alloc_buf(allocator, str->capacity);
|
||||
if (!output) {
|
||||
goto RETURN_ALLOC_SUBSTR;
|
||||
}
|
||||
|
||||
output->size = end - start;
|
||||
memcpy(output->buf, str->buf + start, output->size);
|
||||
|
||||
RETURN_ALLOC_SUBSTR:
|
||||
return output;
|
||||
}
|
||||
|
||||
void wapp_str8_dealloc_buf(const Allocator *allocator, Str8 **str) {
|
||||
wapp_debug_assert(allocator != NULL && str != NULL && (*str) != NULL, "Either `allocator` is NULL or `str` is an invalid double pointer");
|
||||
wapp_mem_allocator_free(allocator, (void **)str, STR8_BUF_ALLOC_SIZE((*str)->capacity));
|
||||
}
|
||||
|
||||
c8 wapp_str8_get(const Str8 *str, u64 index) {
|
||||
if (index >= str->size) {
|
||||
return '\0';
|
||||
}
|
||||
|
||||
return str->buf[index];
|
||||
}
|
||||
|
||||
void wapp_str8_set(Str8 *str, u64 index, c8 c) {
|
||||
if (index >= str->size) {
|
||||
return;
|
||||
}
|
||||
|
||||
str->buf[index] = c;
|
||||
}
|
||||
|
||||
void wapp_str8_push_back(Str8 *str, c8 c) {
|
||||
if (!(str->size < str->capacity)) {
|
||||
return;
|
||||
}
|
||||
|
||||
u64 index = (str->size)++;
|
||||
wapp_str8_set(str, index, c);
|
||||
}
|
||||
|
||||
bool wapp_str8_equal(Str8RO *s1, Str8RO *s2) {
|
||||
if (s1->size != s2->size) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return wapp_str8_equal_to_count(s1, s2, s1->size);
|
||||
}
|
||||
|
||||
bool wapp_str8_equal_to_count(Str8RO* s1, Str8RO* s2, u64 count) {
|
||||
if (!s1 || !s2) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return memcmp(s1->buf, s2->buf, count) == 0;
|
||||
}
|
||||
|
||||
Str8 wapp_str8_slice(Str8RO *str, u64 start, u64 end) {
|
||||
if (start >= str->size || start >= end) {
|
||||
start = str->size;
|
||||
end = str->size;
|
||||
}
|
||||
|
||||
if (end > str->size) {
|
||||
end = str->size;
|
||||
}
|
||||
|
||||
return (Str8RO){
|
||||
.capacity = end - start,
|
||||
.size = end - start,
|
||||
.buf = str->buf + start,
|
||||
};
|
||||
}
|
||||
|
||||
Str8 *wapp_str8_alloc_concat(const Allocator *allocator, Str8 *dst, Str8RO *src) {
|
||||
wapp_debug_assert(allocator != NULL && dst != NULL && src != NULL, "`allocator`, `dst` and `src` should not be NULL");
|
||||
|
||||
Str8 *output = NULL;
|
||||
u64 remaining = dst->capacity - dst->size;
|
||||
if (src->size <= remaining) {
|
||||
output = dst;
|
||||
goto COPY_STRING_STR8_CONCAT;
|
||||
}
|
||||
|
||||
u64 capacity = dst->capacity + src->size;
|
||||
|
||||
output = wapp_str8_alloc_buf(allocator, capacity);
|
||||
if (!output) {
|
||||
goto RETURN_STR8_CONCAT;
|
||||
}
|
||||
|
||||
wapp_str8_concat_capped(output, dst);
|
||||
|
||||
COPY_STRING_STR8_CONCAT:
|
||||
wapp_str8_concat_capped(output, src);
|
||||
|
||||
RETURN_STR8_CONCAT:
|
||||
return output;
|
||||
}
|
||||
|
||||
void wapp_str8_concat_capped(Str8 *dst, Str8RO *src) {
|
||||
wapp_debug_assert(dst != NULL && src != NULL, "`dst` and `src` should not be NULL");
|
||||
|
||||
u64 remaining = dst->capacity - dst->size;
|
||||
u64 to_copy = remaining < src->size ? remaining : src->size;
|
||||
|
||||
memcpy(dst->buf + dst->size, src->buf, to_copy);
|
||||
dst->size += to_copy;
|
||||
}
|
||||
|
||||
void wapp_str8_copy_cstr_capped(Str8 *dst, const char *src) {
|
||||
wapp_debug_assert(dst != NULL && src != NULL, "`dst` and `src` should not be NULL");
|
||||
|
||||
u64 length = strlen(src);
|
||||
u64 to_copy = length <= dst->capacity ? length : dst->capacity;
|
||||
|
||||
memset(dst->buf, 0, dst->size);
|
||||
memcpy(dst->buf, src, to_copy);
|
||||
dst->size = to_copy;
|
||||
}
|
||||
|
||||
void wapp_str8_copy_str8_capped(Str8 *dst, Str8RO *src) {
|
||||
wapp_debug_assert(dst != NULL && src != NULL, "`dst` and `src` should not be NULL");
|
||||
|
||||
u64 to_copy = src->size <= dst->capacity ? src->size : dst->capacity;
|
||||
|
||||
memset(dst->buf, 0, dst->size);
|
||||
memcpy(dst->buf, src->buf, to_copy);
|
||||
dst->size = to_copy;
|
||||
}
|
||||
|
||||
void wapp_str8_copy_to_cstr(char *dst, Str8RO *src, u64 dst_capacity) {
|
||||
wapp_debug_assert(dst != NULL && src != NULL, "`dst` and `src` should not be NULL");
|
||||
|
||||
u64 to_copy = src->size < dst_capacity ? src->size : dst_capacity - 1;
|
||||
|
||||
memset(dst, 0, dst_capacity);
|
||||
memcpy(dst, src->buf, to_copy);
|
||||
}
|
||||
|
||||
void wapp_str8_format(Str8 *dst, const char *format, ...) {
|
||||
wapp_debug_assert(dst != NULL && format != NULL, "`dst` and `format` should not be NULL");
|
||||
|
||||
va_list args1;
|
||||
va_list args2;
|
||||
|
||||
va_start(args1, format);
|
||||
va_copy(args2, args1);
|
||||
|
||||
u64 total_size = vsnprintf(NULL, 0, format, args1);
|
||||
dst->size = total_size <= dst->capacity ? total_size : dst->capacity;
|
||||
|
||||
vsnprintf((char *)(dst->buf), dst->capacity, format, args2);
|
||||
|
||||
va_end(args1);
|
||||
va_end(args2);
|
||||
}
|
||||
|
||||
i64 wapp_str8_find(Str8RO *str, Str8RO substr) {
|
||||
if (!str || substr.size > str->size) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
// NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
|
||||
// MSVC Spectre mitigation warnings
|
||||
u64 char_index = 0;
|
||||
bool running = char_index < str->size;
|
||||
while (running) {
|
||||
const c8 *sub = str->buf + char_index;
|
||||
if (memcmp(sub, substr.buf, substr.size) == 0) {
|
||||
return char_index;
|
||||
}
|
||||
|
||||
++char_index;
|
||||
running = char_index < str->size;
|
||||
}
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
i64 wapp_str8_rfind(Str8RO *str, Str8RO substr) {
|
||||
if (!str || substr.size > str->size) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
// NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
|
||||
// MSVC Spectre mitigation warnings
|
||||
i64 char_index = str->size - substr.size;
|
||||
bool running = char_index >= 0;
|
||||
while (running) {
|
||||
const c8 *sub = str->buf + char_index;
|
||||
if (memcmp(sub, substr.buf, substr.size) == 0) {
|
||||
return char_index;
|
||||
}
|
||||
|
||||
--char_index;
|
||||
running = char_index >= 0;
|
||||
}
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
Str8List *wapp_str8_split_with_max(const Allocator *allocator, Str8RO *str, Str8RO *delimiter, i64 max_splits) {
|
||||
wapp_debug_assert(allocator != NULL && str != NULL && delimiter != NULL, "`allocator`, `str` and `delimiter` should not be NULL");
|
||||
|
||||
Str8List *output = wapp_mem_allocator_alloc(allocator, sizeof(Str8List));
|
||||
|
||||
if (delimiter->size > str->size) {
|
||||
Str8 *full = wapp_str8_alloc_str8(allocator, str);
|
||||
Str8Node *node = wapp_mem_allocator_alloc(allocator, sizeof(Str8Node));
|
||||
if (node) {
|
||||
node->item = full;
|
||||
wapp_str8_list_push_back(output, node);
|
||||
}
|
||||
|
||||
goto RETURN_STR8_SPLIT;
|
||||
}
|
||||
|
||||
i64 start = 0;
|
||||
i64 end = 0;
|
||||
i64 splits = 0;
|
||||
Str8 *rest = wapp_str8_alloc_str8(allocator, str);
|
||||
Str8 *before_str;
|
||||
|
||||
while ((end = wapp_str8_find(rest, *delimiter)) != -1) {
|
||||
if (max_splits > 0 && splits >= max_splits) {
|
||||
break;
|
||||
}
|
||||
|
||||
before_str = wapp_str8_alloc_substr(allocator, str, start, start + end);
|
||||
Str8Node *node = wapp_mem_allocator_alloc(allocator, sizeof(Str8Node));
|
||||
if (node && before_str) {
|
||||
node->item = before_str;
|
||||
wapp_str8_list_push_back(output, node);
|
||||
}
|
||||
|
||||
wapp_mem_allocator_free(allocator, (void **)&rest, sizeof(Str8));
|
||||
rest = wapp_str8_alloc_substr(allocator, str, start + end + delimiter->size, str->size);
|
||||
start += end + delimiter->size;
|
||||
|
||||
++splits;
|
||||
}
|
||||
|
||||
// Ensure the last part of the string after the delimiter is added to the list
|
||||
rest = wapp_str8_alloc_substr(allocator, str, start, str->size);
|
||||
Str8Node *node = wapp_mem_allocator_alloc(allocator, sizeof(Str8Node));
|
||||
if (node && rest) {
|
||||
node->item = rest;
|
||||
wapp_str8_list_push_back(output, node);
|
||||
}
|
||||
|
||||
RETURN_STR8_SPLIT:
|
||||
return output;
|
||||
}
|
||||
|
||||
Str8List *wapp_str8_rsplit_with_max(const Allocator *allocator, Str8RO *str, Str8RO *delimiter, i64 max_splits) {
|
||||
wapp_debug_assert(allocator != NULL && str != NULL && delimiter != NULL, "`allocator`, `str` and `delimiter` should not be NULL");
|
||||
|
||||
Str8List *output = wapp_mem_allocator_alloc(allocator, sizeof(Str8List));
|
||||
|
||||
if (delimiter->size > str->size) {
|
||||
Str8 *full = wapp_str8_alloc_str8(allocator, str);
|
||||
Str8Node *node = wapp_mem_allocator_alloc(allocator, sizeof(Str8Node));
|
||||
if (node && full) {
|
||||
node->item = full;
|
||||
wapp_str8_list_push_back(output, node);
|
||||
}
|
||||
|
||||
goto RETURN_STR8_SPLIT;
|
||||
}
|
||||
|
||||
i64 end = 0;
|
||||
i64 splits = 0;
|
||||
Str8 *rest = wapp_str8_alloc_str8(allocator, str);
|
||||
Str8 *after_str;
|
||||
|
||||
while ((end = wapp_str8_rfind(rest, *delimiter)) != -1) {
|
||||
if (max_splits > 0 && splits >= max_splits) {
|
||||
break;
|
||||
}
|
||||
|
||||
after_str = wapp_str8_alloc_substr(allocator, rest, end + delimiter->size, str->size);
|
||||
Str8Node *node = wapp_mem_allocator_alloc(allocator, sizeof(Str8Node));
|
||||
if (node) {
|
||||
node->item = after_str;
|
||||
wapp_str8_list_push_front(output, node);
|
||||
}
|
||||
|
||||
wapp_mem_allocator_free(allocator, (void **)&rest, sizeof(Str8));
|
||||
rest = wapp_str8_alloc_substr(allocator, rest, 0, end);
|
||||
|
||||
++splits;
|
||||
}
|
||||
|
||||
rest = wapp_str8_alloc_substr(allocator, str, 0, rest->size);
|
||||
Str8Node *node = wapp_mem_allocator_alloc(allocator, sizeof(Str8Node));
|
||||
if (node && rest) {
|
||||
node->item = rest;
|
||||
wapp_str8_list_push_front(output, node);
|
||||
}
|
||||
|
||||
RETURN_STR8_SPLIT:
|
||||
return output;
|
||||
}
|
||||
|
||||
Str8 *wapp_str8_join(const Allocator *allocator, const Str8List *list, Str8RO *delimiter) {
|
||||
wapp_debug_assert(allocator != NULL && list != NULL && delimiter != NULL, "`allocator`, `list` and `delimiter` should not be NULL");
|
||||
|
||||
u64 capacity = wapp_str8_list_total_size(list) + (delimiter->size * (list->node_count - 1));
|
||||
Str8 *output = wapp_str8_alloc_buf(allocator, capacity * 2);
|
||||
|
||||
// NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
|
||||
// MSVC Spectre mitigation warnings
|
||||
Str8Node *node;
|
||||
u64 node_index = 0;
|
||||
bool running = node_index < list->node_count;
|
||||
while (running) {
|
||||
node = wapp_str8_list_get(list, node_index);
|
||||
if (!node) {
|
||||
break;
|
||||
}
|
||||
|
||||
wapp_str8_concat_capped(output, node->item);
|
||||
|
||||
// NOTE (Abdelrahman): Comparison extracted to variable to silence
|
||||
// MSVC Spectre mitigation warnings
|
||||
bool not_last = node_index + 1 < list->node_count;
|
||||
if (not_last) {
|
||||
wapp_str8_concat_capped(output, delimiter);
|
||||
}
|
||||
|
||||
++node_index;
|
||||
running = node_index < list->node_count;
|
||||
}
|
||||
|
||||
return output;
|
||||
}
|
||||
|
||||
u64 wapp_str8_list_total_size(const Str8List *list) {
|
||||
if (!list) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
// NOTE (Abdelrahman): Uses a while loop instead of a for loop to get rid of
|
||||
// MSVC Spectre mitigation warnings
|
||||
Str8Node* node;
|
||||
u64 node_index = 0;
|
||||
u64 output = 0;
|
||||
bool running = node_index < list->node_count;
|
||||
while (running) {
|
||||
node = wapp_str8_list_get(list, node_index);
|
||||
if (!node) {
|
||||
break;
|
||||
}
|
||||
|
||||
output += node->item->size;
|
||||
++node_index;
|
||||
running = node_index < list->node_count;
|
||||
}
|
||||
|
||||
return output;
|
||||
}
|
||||
138
wapp/primitives/strings/str8/str8.h
Normal file
138
wapp/primitives/strings/str8/str8.h
Normal file
@@ -0,0 +1,138 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#ifndef STR8_H
|
||||
#define STR8_H
|
||||
|
||||
#include "../../../common/aliases/aliases.h"
|
||||
#include "../../../common/assert/assert.h"
|
||||
#include "../../../common/platform/platform.h"
|
||||
#include "../../../primitives/dbl_list/dbl_list.h"
|
||||
#include "../../mem_allocator/mem_allocator.h"
|
||||
#include <string.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
#ifdef WAPP_PLATFORM_CPP
|
||||
BEGIN_C_LINKAGE
|
||||
#endif // !WAPP_PLATFORM_CPP
|
||||
|
||||
typedef struct str8 Str8;
|
||||
struct str8 {
|
||||
u64 capacity;
|
||||
u64 size;
|
||||
c8 *buf;
|
||||
};
|
||||
|
||||
typedef const Str8 Str8RO;
|
||||
|
||||
/**
|
||||
* Utilities to be used with printf functions
|
||||
*/
|
||||
#define WAPP_STR8_SPEC "%.*s"
|
||||
#define wapp_str8_varg(STRING) (int)((STRING).size), (STRING).buf
|
||||
|
||||
/**
|
||||
* Str8 stack buffers
|
||||
*/
|
||||
|
||||
#ifdef WAPP_PLATFORM_CPP
|
||||
// Uses a lambda to achieve the same behaviour achieved by the C macro
|
||||
#define wapp_str8_buf(CAPACITY) ([&](){ \
|
||||
persistent c8 buf[CAPACITY] = {}; \
|
||||
memset(buf, 0, CAPACITY); \
|
||||
return Str8{CAPACITY, 0, buf}; \
|
||||
}())
|
||||
|
||||
// Uses a lambda to achieve the same behaviour achieved by the C macro
|
||||
#define wapp_str8_lit(STRING) ([&]() { \
|
||||
persistent c8 buf[sizeof(STRING) * 2] = {}; \
|
||||
memcpy(buf, STRING, sizeof(STRING)); \
|
||||
return Str8{(sizeof(STRING) - 1) * 2, sizeof(STRING) - 1, buf}; \
|
||||
}())
|
||||
|
||||
#define wapp_str8_lit_ro(STRING) Str8RO{sizeof(STRING) - 1, sizeof(STRING) - 1, (c8 *)STRING}
|
||||
#define wapp_str8_lit_ro_initialiser_list(STRING) {sizeof(STRING) - 1, sizeof(STRING) - 1, (c8 *)STRING}
|
||||
#else
|
||||
#define wapp_str8_buf(CAPACITY) ((Str8){.capacity = CAPACITY, .size = 0, .buf = (c8[CAPACITY]){0}})
|
||||
|
||||
// Utilises the fact that memcpy returns pointer to dest buffer and that getting
|
||||
// address of compound literals is valid in C to create a string on the stack
|
||||
#define wapp_str8_lit(STRING) ((Str8){.capacity = (sizeof(STRING) - 1) * 2, \
|
||||
.size = sizeof(STRING) - 1, \
|
||||
.buf = memcpy(&((c8 [sizeof(STRING) * 2]){0}), STRING, sizeof(STRING))})
|
||||
#define wapp_str8_lit_ro(STRING) ((Str8RO){.capacity = sizeof(STRING) - 1, \
|
||||
.size = sizeof(STRING) - 1, \
|
||||
.buf = (c8 *)STRING})
|
||||
// To be used only when initialising a static storage variable in compilers that don't support
|
||||
// initialisers with the syntax of wapp_str8_lit_ro (e.g. gcc). Should only be used when necessary
|
||||
// and only be assigned to a Str8RO variable to avoid any attempt at modifying the string
|
||||
#define wapp_str8_lit_ro_initialiser_list(STRING) {.capacity = sizeof(STRING) - 1, \
|
||||
.size = sizeof(STRING) - 1, \
|
||||
.buf = (c8 *)STRING}
|
||||
#endif // !WAPP_PLATFORM_CPP
|
||||
|
||||
/**
|
||||
* Str8 allocated buffers
|
||||
*/
|
||||
Str8 *wapp_str8_alloc_buf(const Allocator *allocator, u64 capacity);
|
||||
Str8 *wapp_str8_alloc_and_fill_buf(const Allocator *allocator, u64 capacity);
|
||||
Str8 *wapp_str8_alloc_cstr(const Allocator *allocator, const char *str);
|
||||
Str8 *wapp_str8_alloc_str8(const Allocator *allocator, Str8RO *str);
|
||||
Str8 *wapp_str8_alloc_substr(const Allocator *allocator, Str8RO *str, u64 start, u64 end);
|
||||
Str8 *wapp_str8_alloc_concat(const Allocator *allocator, Str8 *dst, Str8RO *src);
|
||||
// Only needed for allocators like malloc where each allocation has to be freed on its own.
|
||||
// No need to use it for allocators like Arena.
|
||||
void wapp_str8_dealloc_buf(const Allocator *allocator, Str8 **str);
|
||||
|
||||
/**
|
||||
* Str8 utilities
|
||||
*/
|
||||
c8 wapp_str8_get(Str8RO *str, u64 index);
|
||||
void wapp_str8_set(Str8 *str, u64 index, c8 c);
|
||||
void wapp_str8_push_back(Str8 *str, c8 c);
|
||||
bool wapp_str8_equal(Str8RO *s1, Str8RO *s2);
|
||||
bool wapp_str8_equal_to_count(Str8RO* s1, Str8RO* s2, u64 count);
|
||||
Str8 wapp_str8_slice(Str8RO *str, u64 start, u64 end);
|
||||
void wapp_str8_concat_capped(Str8 *dst, Str8RO *src);
|
||||
void wapp_str8_copy_cstr_capped(Str8 *dst, const char *src);
|
||||
void wapp_str8_copy_str8_capped(Str8 *dst, Str8RO *src);
|
||||
void wapp_str8_copy_to_cstr(char *dst, Str8RO *src, u64 dst_capacity);
|
||||
void wapp_str8_format(Str8 *dst, const char *format, ...);
|
||||
|
||||
/**
|
||||
* Str8 find functions
|
||||
*/
|
||||
i64 wapp_str8_find(Str8RO *str, Str8RO substr);
|
||||
i64 wapp_str8_rfind(Str8RO *str, Str8RO substr);
|
||||
|
||||
/**
|
||||
* Str8 split and join
|
||||
*/
|
||||
#define wapp_str8_split(ALLOCATOR, STR, DELIMITER) wapp_str8_split_with_max(ALLOCATOR, STR, DELIMITER, -1)
|
||||
#define wapp_str8_rsplit(ALLOCATOR, STR, DELIMITER) wapp_str8_rsplit_with_max(ALLOCATOR, STR, DELIMITER, -1)
|
||||
Str8List *wapp_str8_split_with_max(const Allocator *allocator, Str8RO *str, Str8RO *delimiter, i64 max_splits);
|
||||
Str8List *wapp_str8_rsplit_with_max(const Allocator *allocator, Str8RO *str, Str8RO *delimiter, i64 max_splits);
|
||||
Str8 *wapp_str8_join(const Allocator *allocator, const Str8List *list, Str8RO *delimiter);
|
||||
|
||||
/**
|
||||
* Str8 list utilities
|
||||
*/
|
||||
#ifdef WAPP_PLATFORM_CPP
|
||||
#define wapp_str8_node_from_cstr(STRING) wapp_str8_list_node([&]() { \
|
||||
persistent Str8 str = wapp_str8_lit(STRING); \
|
||||
return &str; \
|
||||
}())
|
||||
#define wapp_str8_node_from_str8(STRING) wapp_str8_list_node([&]() { \
|
||||
persistent Str8 str = STRING; \
|
||||
return &str; \
|
||||
}())
|
||||
#else
|
||||
#define wapp_str8_node_from_cstr(STRING) wapp_str8_list_node(&wapp_str8_lit(STRING))
|
||||
#define wapp_str8_node_from_str8(STRING) wapp_str8_list_node(&(STRING))
|
||||
#endif // !WAPP_PLATFORM_CPP
|
||||
u64 wapp_str8_list_total_size(const Str8List *list);
|
||||
|
||||
#ifdef WAPP_PLATFORM_CPP
|
||||
END_C_LINKAGE
|
||||
#endif // !WAPP_PLATFORM_CPP
|
||||
|
||||
#endif // !STR8_H
|
||||
12
wapp/primitives/wapp_primitives.c
Normal file
12
wapp/primitives/wapp_primitives.c
Normal file
@@ -0,0 +1,12 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#ifndef WAPP_PRIMITIVES_C
|
||||
#define WAPP_PRIMITIVES_C
|
||||
|
||||
#include "wapp_primitives.h"
|
||||
#include "array/array.c"
|
||||
#include "dbl_list/dbl_list.c"
|
||||
#include "mem_allocator/mem_allocator.c"
|
||||
#include "strings/str8/str8.c"
|
||||
|
||||
#endif // !WAPP_PRIMITIVES_C
|
||||
12
wapp/primitives/wapp_primitives.h
Normal file
12
wapp/primitives/wapp_primitives.h
Normal file
@@ -0,0 +1,12 @@
|
||||
// vim:fileencoding=utf-8:foldmethod=marker
|
||||
|
||||
#ifndef WAPP_PRIMITIVES_H
|
||||
#define WAPP_PRIMITIVES_H
|
||||
|
||||
#include "dbl_list/dbl_list.h"
|
||||
#include "array/array.h"
|
||||
#include "mem_allocator/mem_allocator.h"
|
||||
#include "strings/str8/str8.h"
|
||||
#include "../common/wapp_common.h"
|
||||
|
||||
#endif // !WAPP_PRIMITIVES_H
|
||||
Reference in New Issue
Block a user