doylet/DN
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Array changes

Browse Source
This commit is contained in:
doylet
2026-07-08 14:24:07 +10:00
parent 378349ebbf
commit e255828a93
4 changed files with 926 additions and 478 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Single-Header/dn_single_header.cpp
+115 -101
View File
@@ -1,4 +1,4 @@
// Generated by the DN single header generator 2026-07-07 23:09:14
// Generated by the DN single header generator 2026-07-08 14:23:35
// DN: Single header generator commented out => #if defined(_CLANGD)
// #define DN_WITH_TESTS 1
@@ -5966,12 +5966,12 @@ DN_API DN_U64 DN_FNV1AHashU64FromBytes(void const *bytes, DN_USize count, DN_U64
//-----------------------------------------------------------------------------
// Block read - if your platform needs to do endian-swapping or can only
// handle aligned reads, do the conversion here
DN_FORCE_INLINE DN_U32 DN_MurmurHash3GetBlock32_(DN_U32 const *p, int i)
DN_FORCE_INLINE DN_U32 DN_Murmur3GetBlock32_(DN_U32 const *p, int i)
{
return p[i];
}
DN_FORCE_INLINE DN_U64 DN_MurmurHash3GetBlock64_(DN_U64 const *p, int i)
DN_FORCE_INLINE DN_U64 DN_Murmur3GetBlock64_(DN_U64 const *p, int i)
{
return p[i];
}
@@ -5979,7 +5979,7 @@ DN_FORCE_INLINE DN_U64 DN_MurmurHash3GetBlock64_(DN_U64 const *p, int i)
//-----------------------------------------------------------------------------
// Finalization mix - force all bits of a hash block to avalanche
DN_FORCE_INLINE DN_U32 DN_MurmurHash3FMix32_(DN_U32 h)
DN_FORCE_INLINE DN_U32 DN_Murmur3FMix32_(DN_U32 h)
{
h ^= h >> 16;
h *= 0x85ebca6b;
@@ -5989,7 +5989,7 @@ DN_FORCE_INLINE DN_U32 DN_MurmurHash3FMix32_(DN_U32 h)
return h;
}
DN_FORCE_INLINE DN_U64 DN_MurmurHash3FMix64_(DN_U64 k)
DN_FORCE_INLINE DN_U64 DN_Murmur3FMix64_(DN_U64 k)
{
k ^= k >> 33;
k *= 0xff51afd7ed558ccd;
@@ -5999,7 +5999,7 @@ DN_FORCE_INLINE DN_U64 DN_MurmurHash3FMix64_(DN_U64 k)
return k;
}
DN_API DN_U32 DN_MurmurHash3HashU128FromBytesX86(void const *bytes, int len, DN_U32 seed)
DN_API DN_U32 DN_Murmur3HashU128FromBytesX86(void const *bytes, int len, DN_U32 seed)
{
const DN_U8 *data = (const DN_U8 *)bytes;
const int nblocks = len / 4;
@@ -6016,7 +6016,7 @@ DN_API DN_U32 DN_MurmurHash3HashU128FromBytesX86(void const *bytes, int len, DN_
for (int i = -nblocks; i; i++)
{
DN_U32 k1 = DN_MurmurHash3GetBlock32_(blocks, i);
DN_U32 k1 = DN_Murmur3GetBlock32_(blocks, i);
k1 *= c1;
k1 = DN_MMH3_ROTL32(k1, 15);
@@ -6053,12 +6053,12 @@ DN_API DN_U32 DN_MurmurHash3HashU128FromBytesX86(void const *bytes, int len, DN_
h1 ^= len;
h1 = DN_MurmurHash3FMix32_(h1);
h1 = DN_Murmur3FMix32_(h1);
return h1;
}
DN_API DN_MurmurHash3 DN_MurmurHash3HashU128FromBytesX64(void const *bytes, int len, DN_U32 seed)
DN_API DN_Murmur3 DN_Murmur3HashU128FromBytesX64(void const *bytes, int len, DN_U32 seed)
{
const DN_U8 *data = (const DN_U8 *)bytes;
const int nblocks = len / 16;
@@ -6076,8 +6076,8 @@ DN_API DN_MurmurHash3 DN_MurmurHash3HashU128FromBytesX64(void const *bytes, int
for (int i = 0; i < nblocks; i++)
{
DN_U64 k1 = DN_MurmurHash3GetBlock64_(blocks, i * 2 + 0);
DN_U64 k2 = DN_MurmurHash3GetBlock64_(blocks, i * 2 + 1);
DN_U64 k1 = DN_Murmur3GetBlock64_(blocks, i * 2 + 0);
DN_U64 k2 = DN_Murmur3GetBlock64_(blocks, i * 2 + 1);
k1 *= c1;
k1 = DN_MMH3_ROTL64(k1, 31);
@@ -6158,28 +6158,28 @@ DN_API DN_MurmurHash3 DN_MurmurHash3HashU128FromBytesX64(void const *bytes, int
h1 += h2;
h2 += h1;
h1 = DN_MurmurHash3FMix64_(h1);
h2 = DN_MurmurHash3FMix64_(h2);
h1 = DN_Murmur3FMix64_(h1);
h2 = DN_Murmur3FMix64_(h2);
h1 += h2;
h2 += h1;
DN_MurmurHash3 result = {};
DN_Murmur3 result = {};
result.e[0] = h1;
result.e[1] = h2;
return result;
}
DN_API DN_U64 DN_MurmurHash3HashU64FromBytesX64(void const *bytes, int len, DN_U32 seed)
DN_API DN_U64 DN_Murmur3HashU64FromBytesX64(void const *bytes, int len, DN_U32 seed)
{
DN_MurmurHash3 hash = DN_MurmurHash3HashU128FromBytesX64(bytes, len, seed);
DN_Murmur3 hash = DN_Murmur3HashU128FromBytesX64(bytes, len, seed);
DN_U64 result = hash.e[0];
return result;
}
DN_API DN_U32 DN_MurmurHash3HashU32FromBytesX64(void const *bytes, int len, DN_U32 seed)
DN_API DN_U32 DN_Murmur3HashU32FromBytesX64(void const *bytes, int len, DN_U32 seed)
{
DN_MurmurHash3 hash = DN_MurmurHash3HashU128FromBytesX64(bytes, len, seed);
DN_Murmur3 hash = DN_Murmur3HashU128FromBytesX64(bytes, len, seed);
DN_U32 result = DN_Cast(DN_U32)hash.e[0];
return result;
}
@@ -8274,6 +8274,22 @@ DN_API void *DN_ArrayMakeArrayAssert(void *data, DN_USize *count, DN_USize max,
return result;
}
DN_API void *DN_ArrayMakeArrayArena(void **data, DN_USize *count, DN_USize *max, DN_USize elem_size, DN_Arena *arena, DN_USize make_count, DN_ZMem z_mem)
{
void *result = nullptr;
if (DN_ArrayPrepareArena(data, *count, max, elem_size, arena, make_count))
result = DN_ArrayMakeArray(*data, count, *max, elem_size, make_count, z_mem);
return result;
}
DN_API void *DN_ArrayMakeArrayPool(void **data, DN_USize *count, DN_USize *max, DN_USize elem_size, DN_Pool *pool, DN_USize make_count, DN_ZMem z_mem)
{
void *result = nullptr;
if (DN_ArrayPreparePool(data, *count, max, elem_size, pool, make_count))
result = DN_ArrayMakeArray(*data, count, *max, elem_size, make_count, z_mem);
return result;
}
DN_API void *DN_ArrayAddArray(void *data, DN_USize *count, DN_USize max, DN_USize elem_size, void const *elems, DN_USize elems_count, DN_ArrayAdd add)
{
void *result = DN_ArrayMakeArray(data, count, max, elem_size, elems_count, DN_ZMem_No);
@@ -8290,6 +8306,22 @@ DN_API void *DN_ArrayAddArray(void *data, DN_USize *count, DN_USize max, DN_USiz
return result;
}
DN_API void *DN_ArrayAddArrayArena(void **data, DN_USize *count, DN_USize *max, DN_USize elem_size, DN_Arena *arena, void const *elems, DN_USize elems_count, DN_ArrayAdd add)
{
void *result = nullptr;
if (DN_ArrayPrepareArena(data, *count, max, elem_size, arena, elems_count))
result = DN_ArrayAddArray(*data, count, *max, elem_size, elems, elems_count, add);
return result;
}
DN_API void *DN_ArrayAddArrayPool(void **data, DN_USize *count, DN_USize *max, DN_USize elem_size, DN_Pool *pool, void const *elems, DN_USize elems_count, DN_ArrayAdd add)
{
void *result = nullptr;
if (DN_ArrayPreparePool(data, *count, max, elem_size, pool, elems_count))
result = DN_ArrayAddArray(*data, count, *max, elem_size, elems, elems_count, add);
return result;
}
DN_API void *DN_ArrayAddArrayAssert(void *data, DN_USize *count, DN_USize max, DN_USize elem_size, void const *elems, DN_USize elems_count, DN_ArrayAdd add, DN_CallSite call_site)
{
void *result = DN_ArrayAddArray(data, count, max, elem_size, elems, elems_count, add);
@@ -8297,16 +8329,17 @@ DN_API void *DN_ArrayAddArrayAssert(void *data, DN_USize *count, DN_USize max, D
return result;
}
DN_API bool DN_ArrayResizeFromArena(void **data, DN_USize *count, DN_USize *max, DN_USize elem_size, DN_Pool *pool, DN_USize new_max)
static bool DN_ArrayResizeAllocator_(void **data, DN_USize *count, DN_USize *max, DN_USize elem_size, DN_Allocator allocator, DN_USize new_max)
{
bool result = true;
if (!max || new_max != *max) {
DN_USize bytes_to_alloc = elem_size * new_max;
void *buffer = DN_PoolNewArray(pool, DN_U8, bytes_to_alloc);
void *buffer = DN_AllocatorAlloc(allocator, bytes_to_alloc, alignof(DN_UPtr), DN_ZMem_No);
if (buffer) {
DN_USize bytes_to_copy = elem_size * DN_Min(*count, new_max);
DN_Memcpy(buffer, *data, bytes_to_copy);
DN_PoolDealloc(pool, *data);
if (allocator.type == DN_AllocatorType_Pool)
DN_PoolDealloc(DN_Cast(DN_Pool *)allocator.context, *data);
*data = buffer;
*count = DN_Min(*count, new_max);
if (max)
@@ -8319,87 +8352,58 @@ DN_API bool DN_ArrayResizeFromArena(void **data, DN_USize *count, DN_USize *max,
return result;
}
DN_API bool DN_ArrayResizeFromPool(void **data, DN_USize *count, DN_USize *max, DN_USize elem_size, DN_Pool *pool, DN_USize new_max)
DN_API bool DN_ArrayResizeArena(void **data, DN_USize *count, DN_USize *max, DN_USize elem_size, DN_Arena *arena, DN_USize new_max)
{
bool result = true;
if (!max || new_max != *max) {
DN_USize bytes_to_alloc = elem_size * new_max;
void *buffer = DN_PoolNewArray(pool, DN_U8, bytes_to_alloc);
if (buffer) {
DN_USize bytes_to_copy = elem_size * DN_Min(*count, new_max);
DN_Memcpy(buffer, *data, bytes_to_copy);
DN_PoolDealloc(pool, *data);
*data = buffer;
*count = DN_Min(*count, new_max);
if (max)
*max = new_max;
} else {
result = false;
}
}
DN_Allocator allocator = DN_AllocatorFromArena(arena);
bool result = DN_ArrayResizeAllocator_(data, count, max, elem_size, allocator, new_max);
return result;
}
DN_API bool DN_ArrayResizeFromArena(void **data, DN_USize *count, DN_USize *max, DN_USize elem_size, DN_Arena *arena, DN_USize new_max)
DN_API bool DN_ArrayResizePool(void **data, DN_USize *count, DN_USize *max, DN_USize elem_size, DN_Pool *pool, DN_USize new_max)
{
bool result = true;
if (!max || new_max != *max) {
DN_USize bytes_to_alloc = elem_size * new_max;
void *buffer = DN_ArenaNewArray(arena, DN_U8, bytes_to_alloc, DN_ZMem_No);
if (buffer) {
DN_USize bytes_to_copy = elem_size * DN_Min(*count, new_max);
DN_Memcpy(buffer, *data, bytes_to_copy);
*data = buffer;
*count = DN_Min(*count, new_max);
if (max)
*max = new_max;
} else {
result = false;
}
}
DN_Allocator allocator = DN_AllocatorFromPool(pool);
bool result = DN_ArrayResizeAllocator_(data, count, max, elem_size, allocator, new_max);
return result;
}
DN_API bool DN_ArrayGrowFromPool(void **data, DN_USize *max, DN_USize elem_size, DN_Pool *pool, DN_USize new_max)
DN_API bool DN_ArrayReservePool(void **data, DN_USize *max, DN_USize elem_size, DN_Pool *pool, DN_USize new_max)
{
bool result = true;
if (!max || new_max > *max) {
DN_USize count = 0;
result = DN_ArrayResizeFromPool(data, &count, max, elem_size, pool, new_max);
result = DN_ArrayResizePool(data, &count, max, elem_size, pool, new_max);
}
return result;
}
DN_API bool DN_ArrayGrowFromArena(void **data, DN_USize *max, DN_USize elem_size, DN_Arena *arena, DN_USize new_max)
DN_API bool DN_ArrayReserveArena(void **data, DN_USize *max, DN_USize elem_size, DN_Arena *arena, DN_USize new_max)
{
bool result = true;
if (!max || new_max > *max) {
DN_USize count = 0;
result = DN_ArrayResizeFromArena(data, &count, max, elem_size, arena, new_max);
result = DN_ArrayResizeArena(data, &count, max, elem_size, arena, new_max);
}
return result;
}
DN_API bool DN_ArrayGrowIfNeededFromPool(void **data, DN_USize count, DN_USize *max, DN_USize elem_size, DN_Pool *pool, DN_USize add_count)
DN_API bool DN_ArrayPreparePool(void **data, DN_USize count, DN_USize *max, DN_USize elem_size, DN_Pool *pool, DN_USize add_count)
{
bool result = true;
DN_USize new_count = count + add_count;
if (new_count > *max) {
DN_USize new_max = DN_Max(DN_Max(*max * 2, new_count), 8);
result = DN_ArrayResizeFromPool(data, &count, max, elem_size, pool, new_max);
result = DN_ArrayResizePool(data, &count, max, elem_size, pool, new_max);
}
return result;
}
DN_API bool DN_ArrayGrowIfNeededFromArena(void **data, DN_USize count, DN_USize *max, DN_USize elem_size, DN_Arena *arena, DN_USize add_count)
DN_API bool DN_ArrayPrepareArena(void **data, DN_USize count, DN_USize *max, DN_USize elem_size, DN_Arena *arena, DN_USize add_count)
{
bool result = true;
DN_USize new_count = count + add_count;
if (new_count > *max) {
DN_USize new_max = DN_Max(DN_Max(*max * 2, new_count), 8);
result = DN_ArrayResizeFromArena(data, &count, max, elem_size, arena, new_max);
result = DN_ArrayResizeArena(data, &count, max, elem_size, arena, new_max);
}
return result;
}
@@ -8407,7 +8411,7 @@ DN_API bool DN_ArrayGrowIfNeededFromArena(void **data, DN_USize count, DN_USize
DN_API DN_USize DN_ArrayCopyPtrArena(void **data, void const *src, DN_USize count, DN_USize elem_size, DN_Arena *arena)
{
DN_USize result = 0;
if (DN_ArrayGrowFromArena(data, /*max=*/ &result, elem_size, arena, /*new_max=*/ count))
if (DN_ArrayReserveArena(data, /*max=*/ &result, elem_size, arena, /*new_max=*/ count))
DN_Memcpy(*data, src, elem_size * count);
return result;
}
@@ -8422,7 +8426,7 @@ DN_API DN_USize DN_ArrayCopyPtrArenaAssert(void **data, void const *src, DN_USiz
DN_API DN_USize DN_ArrayCopyPtrPool(void **data, void const *src, DN_USize count, DN_USize elem_size, DN_Pool *pool)
{
DN_USize result = 0;
if (DN_ArrayGrowFromPool(data, /*max=*/ &result, elem_size, pool, /*new_max=*/ count))
if (DN_ArrayReservePool(data, /*max=*/ &result, elem_size, pool, /*new_max=*/ count))
DN_Memcpy(*data, src, elem_size * count);
return result;
}
@@ -8488,10 +8492,18 @@ DN_API void DN_RingRead(DN_Ring *ring, void *dest, DN_U64 dest_size)
ring->read_pos += dest_size;
}
DN_API DN_U32 DN_HTableHashFuncDefault(void const *key, DN_USize size)
DN_API DN_U32 DN_HTableHashFuncMurmur3KeyBytes(void const *key, DN_USize size)
{
DN_U32 const DEFAULT_SEED = 0xb255b383;
DN_U32 result = DN_MurmurHash3HashU32FromBytes(key, DN_Cast(int)size, DEFAULT_SEED);
DN_U32 result = DN_Murmur3HashU32FromBytes(key, DN_Cast(int)size, DEFAULT_SEED);
return result;
}
DN_API DN_U32 DN_HTableHashFuncMurmur3KeyStr8(void const *key, DN_USize size)
{
DN_Assert(size == sizeof(DN_Str8));
DN_Str8 *str8_key = DN_Cast(DN_Str8 *)key;
DN_U32 result = DN_HTableHashFuncMurmur3KeyBytes(str8_key->data, str8_key->count);
return result;
}
@@ -8513,7 +8525,7 @@ DN_API DN_HTableInitArgs DN_HTableInitArgsDefault_(void** kvs, DN_USize size_of_
{
DN_HTableInitArgs result = {};
DN_AssertF((*kvs) == 0, "The key-value pointer must be null as the hash table will allocate the objects and keep the pointer in sync with the table for you: %p", *kvs);
result.hash_func = DN_HTableHashFuncDefault;
result.hash_func = DN_HTableHashFuncMurmur3KeyBytes;
result.key_eq_func = DN_HTableKeyEqFuncMemcmp;
result.load_factor = 0.7f;
result.max = 0;
@@ -8615,18 +8627,18 @@ DN_API DN_HTableLookupResult DN_HTableLookup(DN_HTable const *table, void const
DN_Assert(DN_IsPowerOfTwo(table->max));
DN_U32 hash = table->hash_func(key, table->size_of_key);
if (hash < DN_HTableHashSentinel_FirstValid)
if (!DN_HTableHashIsValue(hash))
hash += DN_HTableHashSentinel_FirstValid;
DN_USize const mask = table->max - 1;
DN_USize index = hash & mask;
DN_USize probe_increment = 1;
for (DN_USize offset = 0; offset < table->max; offset++, probe_increment++) {
DN_HTableSlot slot = DN_HTableSlotFromIndex(table, index);
bool matched = slot.hash_u32 == DN_HTableHashSentinel_Empty;
bool matched = DN_HTableSlotIsEmpty(slot);
if (!matched && allow_tombstone == DN_HTableAllowTombstone_Yes)
matched = slot.hash_u32 == DN_HTableHashSentinel_Tomb;
matched = DN_HTableSlotIsTomb(slot);
if (!matched)
matched = slot.hash_u32 >= DN_HTableHashSentinel_FirstValid && slot.hash_u32 == hash && table->key_eq_func(slot.key, key, table->size_of_key);
matched = DN_HTableSlotIsValue(slot) && slot.hash_u32 == hash && table->key_eq_func(slot.key, key, table->size_of_key);
if (matched) {
result.slot = slot;
result.key_hash = hash;
@@ -8646,7 +8658,7 @@ DN_API DN_HTableSlot DN_HTableFind(DN_HTable const *table, void const *key)
{
DN_HTableLookupResult lookup = DN_HTableLookup(table, key, DN_HTableAllowTombstone_No);
DN_HTableSlot result = {};
if (lookup.slot.hash_u32 >= DN_HTableHashSentinel_FirstValid)
if (DN_HTableSlotIsValue(lookup.slot))
result = lookup.slot;
return result;
}
@@ -8689,7 +8701,7 @@ DN_API bool DN_HTableResize(DN_HTable *table, DN_USize new_max)
*table->kvs = new_kvs;
for (DN_ForIndexU(index, old_max)) {
DN_HTableSlot old_slot = DN_HTableSlotFromArgs_(old_kvs, table->size_of_kv, table->offset_of_hash, table->offset_of_key, table->offset_of_value, index);
if (old_slot.hash_u32 >= DN_HTableHashSentinel_FirstValid)
if (DN_HTableSlotIsValue(old_slot))
DN_HTableAdd(table, old_slot.key, old_slot.value);
}
@@ -8705,19 +8717,9 @@ DN_API bool DN_HTableResize(DN_HTable *table, DN_USize new_max)
return result;
}
DN_API void DN_HTableClear(DN_HTable *table)
DN_API DN_HTablePrepareResult DN_HTablePrepare(DN_HTable *table, DN_USize add_count)
{
for (DN_ForIndexU(index, table->max)) {
DN_HTableSlot slot = DN_HTableSlotFromIndex(table, index);
DN_Memset(slot.hash, DN_HTableHashSentinel_Empty, sizeof(slot.hash_u32));
}
table->tombs_count = 0;
table->count = 0;
}
DN_API DN_HTableResizeResult DN_HTableGrowMaybe(DN_HTable *table, DN_USize add_count)
{
DN_HTableResizeResult result = {};
DN_HTablePrepareResult result = {};
result.success = true;
DN_USize new_count = table->count + table->tombs_count + add_count;
DN_F32 new_load_factor = table->max ? new_count / DN_Cast(DN_F32) table->max : table->load_factor01;
@@ -8739,13 +8741,23 @@ DN_API DN_HTableResizeResult DN_HTableGrowMaybe(DN_HTable *table, DN_USize add_c
return result;
}
DN_API void DN_HTableClear(DN_HTable *table)
{
for (DN_ForIndexU(index, table->max)) {
DN_HTableSlot slot = DN_HTableSlotFromIndex(table, index);
DN_Memset(slot.hash, DN_HTableHashSentinel_Empty, sizeof(slot.hash_u32));
}
table->tombs_count = 0;
table->count = 0;
}
DN_API DN_HTableAddResult DN_HTableMake(DN_HTable* table, void* key)
{
// NOTE: First do the lookup ignoring tombstones. This probes the chain looking for the existence
// of the value.
DN_HTableLookupResult lookup = DN_HTableLookup(table, key, DN_HTableAllowTombstone_No);
bool load_factor_is_good = true;
if (lookup.slot.hash_u32 >= DN_HTableHashSentinel_FirstValid) {
if (DN_HTableSlotIsValue(lookup.slot)) {
// NOTE: If it exists, this is the easy path, we can update the slot returned in the lookup.
//
// Note that we do not check if `hash_u32` is the empty value, because that empty value might
@@ -8756,9 +8768,9 @@ DN_API DN_HTableAddResult DN_HTableMake(DN_HTable* table, void* key)
} else {
// NOTE: The value does not exist, look it up again but match on the first tombstone/empty slot
lookup = DN_HTableLookup(table, key, DN_HTableAllowTombstone_Yes);
bool add_will_use_new_slot = lookup.slot.hash_u32 == DN_HTableHashSentinel_Empty;
bool add_will_use_new_slot = DN_HTableSlotIsEmpty(lookup.slot);
if (add_will_use_new_slot) {
DN_HTableResizeResult resize = DN_HTableGrowMaybe(table, 1);
DN_HTablePrepareResult resize = DN_HTablePrepare(table, 1);
if (resize.success)
lookup = DN_HTableLookup(table, key, DN_HTableAllowTombstone_Yes);
else
@@ -8771,9 +8783,9 @@ DN_API DN_HTableAddResult DN_HTableMake(DN_HTable* table, void* key)
if (load_factor_is_good) {
result.success = true;
result.slot = lookup.slot;
if (result.slot.hash_u32 == DN_HTableHashSentinel_Empty) {
if (DN_HTableSlotIsEmpty(result.slot)) {
table->count++;
} else if (result.slot.hash_u32 == DN_HTableHashSentinel_Tomb) {
} else if (DN_HTableSlotIsTomb(result.slot)) {
DN_Assert(table->tombs_count);
table->tombs_count--;
table->count++;
@@ -8806,7 +8818,7 @@ DN_API DN_HTableAddResult DN_HTableAdd(DN_HTable* table, void* key, void* value)
DN_API bool DN_HTableDel(DN_HTable *table, void *key)
{
DN_HTableLookupResult lookup = DN_HTableLookup(table, key, DN_HTableAllowTombstone_No);
bool result = lookup.slot.hash_u32 >= DN_HTableHashSentinel_FirstValid;
bool result = DN_HTableSlotIsValue(lookup.slot);
if (result) {
DN_HTableHashType sentinel = DN_HTableHashSentinel_Tomb;
DN_Memcpy(lookup.slot.hash, &sentinel, sizeof(sentinel));
@@ -9308,7 +9320,7 @@ DN_API DN_TestCore DN_TestInit(DN_Arena *arena)
DN_TestCore result = {};
result.arena = arena;
result.pool = DN_PoolFromArena(arena, DN_POOL_DEFAULT_ALIGN);
DN_PArrayGrowFromPool(result.groups, &result.groups_max, &result.pool, 32);
DN_PArrayReservePool(result.groups, &result.groups_max, &result.pool, 32);
return result;
}
@@ -9316,10 +9328,12 @@ DN_API void DN_TestGroupBeginF(DN_TestCore *test, char const *fmt, ...)
{
DN_AssertF(!test->curr_group, "Previous test group (%.*s) must be ended before starting a new group", DN_Str8PrintFmt(test->curr_group->name));
// NOTE: ALlocate the group
DN_PArrayGrowIfNeededFromPool(test->groups, test->groups_count, &test->groups_max, &test->pool, 1);
// NOTE: Allocate the group
DN_PArrayPreparePool(test->groups, test->groups_count, &test->groups_max, &test->pool, 1);
DN_TestGroup *group = DN_PArrayMakeZ(test->groups, &test->groups_count, test->groups_max);
DN_PArrayGrowFromPool(group->entries, &group->entries_max, &test->pool, 32);
// NOTE: Initially allocate 32 test entries per group
DN_PArrayReservePool(group->entries, &group->entries_max, &test->pool, 32);
// NOTE: Set up the group
va_list args;
@@ -9346,7 +9360,7 @@ DN_API void DN_TestBeginF(DN_TestCore *test, char const *fmt, ...)
// NOTE:Allocate test entry
DN_TestGroup *group = test->curr_group;
DN_PArrayGrowIfNeededFromPool(group->entries, group->entries_count, &group->entries_max, &test->pool, 1);
DN_PArrayPreparePool(group->entries, group->entries_count, &group->entries_max, &test->pool, 1);
DN_AssertF(!group->curr_entry, "Test (%.*s) must be ended before starting another test in the group (%.*s)", DN_Str8PrintFmt(group->curr_entry->name), DN_Str8PrintFmt(group->name));
DN_TestEntry *entry = DN_PArrayMakeZ(group->entries, &group->entries_count, group->entries_max);
@@ -9490,7 +9504,7 @@ DN_API DN_TestDiagnosticRow *DN_TestVerifySetupFmtV(DN_TestCore *test, DN_CallSi
DN_TestEntry *entry = group->curr_entry;
entry->failed = true;
DN_PArrayGrowIfNeededFromPool(entry->diagnostics, entry->diagnostics_count, &entry->diagnostics_max, &test->pool, 1);
DN_PArrayPreparePool(entry->diagnostics, entry->diagnostics_count, &entry->diagnostics_max, &test->pool, 1);
result = DN_PArrayMakeZ(entry->diagnostics, &entry->diagnostics_count, entry->diagnostics_max);
result->expr = expr;
result->call_site = call_site;
@@ -11398,8 +11412,8 @@ DN_API void DN_LeakDump_(DN_LeakTracker *leak)
DN_U64 leak_count = 0;
DN_U64 leaked_bytes = 0;
for (DN_ForItSize(it, DN_LeakTrackerKV, leak->alloc_table_kvs, leak->alloc_table.max)) {
DN_LeakTrackerKV *kv = it.data;
if (kv->hash < DN_HTableHashSentinel_FirstValid)
DN_LeakTrackerKV *kv = it.data;
if (!DN_HTableHashIsValue(kv->hash))
continue;
DN_LeakAlloc *alloc = &kv->value;
Single-Header/dn_single_header.h
+349 -139
View File
@@ -1,4 +1,4 @@
// Generated by the DN single header generator 2026-07-07 23:09:14
// Generated by the DN single header generator 2026-07-08 14:23:34
#if !defined(DN_H)
#define DN_H
@@ -1721,25 +1721,24 @@ struct DN_TCCore // (T)hread (C)ontext sitting in thread-local storage
DN_Arena* frame_arena;
};
enum DN_TCDeinitArenas
{
typedef enum DN_TCDeinitArenas {
DN_TCDeinitArenas_No,
DN_TCDeinitArenas_Yes,
};
} DN_TCDeinitArenas;
typedef struct DN_PCG32 DN_PCG32;
struct DN_PCG32 { DN_U64 state; };
typedef struct DN_MurmurHash3 DN_MurmurHash3;
struct DN_MurmurHash3 { DN_U64 e[2]; };
enum DN_LogType
{
typedef struct DN_Murmur3 DN_Murmur3;
struct DN_Murmur3 { DN_U64 e[2]; };
typedef enum DN_LogType {
DN_LogType_Debug,
DN_LogType_Info,
DN_LogType_Warning,
DN_LogType_Error,
DN_LogType_Count,
};
} DN_LogType;
typedef enum DN_LogBold {
DN_LogBold_No,
@@ -1762,11 +1761,10 @@ struct DN_LogTypeParam
DN_Str8 str8;
};
enum DN_ANSIColourMode
{
typedef enum DN_ANSIColourMode {
DN_ANSIColourMode_Fg,
DN_ANSIColourMode_Bg,
};
} DN_ANSIColourMode;
typedef struct DN_LogDate DN_LogDate;
struct DN_LogDate
@@ -2065,7 +2063,7 @@ struct DN_HTableLookupResult
DN_HTableSlot slot; // KV object from `kvs`, always set (either empty, tombed, or active slot)
};
typedef struct DN_HTableResizeResult DN_HTableResizeResult;
typedef struct DN_HTableResizeResult DN_HTablePrepareResult;
struct DN_HTableResizeResult
{
bool success;
@@ -5256,15 +5254,15 @@ DN_API void DN_PCG32Advance
DN_API DN_U32 DN_FNV1AHashU32FromBytes (void const *bytes, DN_USize count, DN_U32 seed);
DN_API DN_U64 DN_FNV1AHashU64FromBytes (void const *bytes, DN_USize count, DN_U64 seed);
DN_API DN_U32 DN_MurmurHash3HashU32FromBytesX86 (void const *bytes, int len, DN_U32 seed);
DN_API DN_MurmurHash3 DN_MurmurHash3HashU128FromBytesX64 (void const *bytes, int len, DN_U32 seed);
DN_API DN_U64 DN_MurmurHash3HashU64FromBytesX64 (void const *bytes, int len, DN_U32 seed);
DN_API DN_U32 DN_MurmurHash3HashU32FromBytesX64 (void const *bytes, int len, DN_U32 seed);
DN_API DN_U32 DN_Murmur3HashU32FromBytesX86 (void const *bytes, int len, DN_U32 seed);
DN_API DN_Murmur3 DN_Murmur3HashU128FromBytesX64 (void const *bytes, int len, DN_U32 seed);
DN_API DN_U64 DN_Murmur3HashU64FromBytesX64 (void const *bytes, int len, DN_U32 seed);
DN_API DN_U32 DN_Murmur3HashU32FromBytesX64 (void const *bytes, int len, DN_U32 seed);
#if defined(DN_64_BIT)
#define DN_MurmurHash3HashU32FromBytes(bytes, len, seed) DN_MurmurHash3HashU32FromBytesX64(bytes, len, seed)
#define DN_Murmur3HashU32FromBytes(bytes, len, seed) DN_Murmur3HashU32FromBytesX64(bytes, len, seed)
#else
#define DN_MurmurHash3HashU32FromBytes(bytes, len, seed) DN_MurmurHash3HashU32FromBytesX86(bytes, len, seed)
#define DN_Murmur3HashU32FromBytes(bytes, len, seed) DN_Murmur3HashU32FromBytesX86(bytes, len, seed)
#endif
#define DN_ANSICodeBoldLit "\x1b[1m"
@@ -5810,9 +5808,9 @@ DN_API DN_RaycastV2 DN_RaycastLineIntersectV2
// dynamically shrunk or expanded.
//
// API
// ResizeFrom: Resizes the array to `new_max` erase elements if resizing to a smaller size
// GrowFrom: Expands the capacity of the array if `new_max > array.max` otherwise no-op
// GrowIfNeeded: Expands the capacity of the array if `array.count + add_count > array.max` otherwise no-op
// Resize: Resizes the array to `new_max` erase elements if resizing to a smaller size
// Reserve: Expands the capacity of the array if `new_max > max` otherwise no-op
// Prepare: Expands the capacity of the array if `count + add_count > max` otherwise no-op
//
// Variants
// PArray => Pointer (to) Array
@@ -5835,60 +5833,80 @@ DN_API DN_RaycastV2 DN_RaycastLineIntersectV2
// DN_USize max;
// } my_array = {};
// DN_Arena arena = {};
// DN_IArrayResizeFromArena(&my_array, &arena, 256);
// DN_IArrayResizeArena(&my_array, &arena, 256);
// MyStruct *item = DN_IArrayMake(&my_array, DN_ZMem_No);
//
#if defined(__cplusplus)
#define DN_PArrayFind(ptr, size, ptr_find, eq_func) DN_TArrayFind(ptr, size, ptr_find, eq_func)
#define DN_PArrayFindMemEq(ptr, size, ptr_find) DN_TArrayFindMemEq(ptr, size, ptr_find)
#define DN_PArrayResizeFromPool(ptr, ptr_size, ptr_max, pool, new_max) DN_TArrayResizeFromPool(&(ptr), ptr_size, ptr_max, pool, new_max)
#define DN_PArrayResizeFromArena(ptr, ptr_size, ptr_max, arena, new_max) DN_TArrayResizeFromArena(&(ptr), ptr_size, ptr_max, arena, new_max)
#define DN_PArrayGrowFromPool(ptr, ptr_max, pool, new_max) DN_TArrayGrowFromPool(&(ptr), ptr_max, pool, new_max)
#define DN_PArrayGrowFromArena(ptr, ptr_max, arena, new_max) DN_TArrayGrowFromArena(&(ptr), ptr_max, arena, new_max)
#define DN_PArrayGrowIfNeededFromPool(ptr, size, ptr_max, pool, add_count) DN_TArrayGrowIfNeededFromPool(&(ptr), size, ptr_max, pool, add_count)
#define DN_PArrayGrowIfNeededFromArena(ptr, size, ptr_max, arena, add_count) DN_TArrayGrowIfNeededFromArena(&(ptr), size, ptr_max, arena, add_count)
#define DN_PArrayCopyPtrPool(dest, src, count_, pool) DN_TArrayCopyPtrPool(&(dest), src, count_, pool)
#define DN_PArrayCopyPtrPoolAssert(dest, src, count_, pool) DN_TArrayCopyPtrPoolAssert(&(dest), src, count_, pool, DN_CallSiteNow)
#define DN_PArrayCopyPtrArena(dest, src, count_, arena) DN_TArrayCopyPtrArena(&(dest), src, count_, arena)
#define DN_PArrayCopyPtrArenaAssert(dest, src, count_, arena) DN_TArrayCopyPtrArenaAssert(&(dest), src, count_, arena, DN_CallSiteNow)
#define DN_PArrayFind(ptr, size, ptr_find, eq_func) DN_TArrayFind(ptr, size, ptr_find, eq_func)
#define DN_PArrayFindMemEq(ptr, size, ptr_find) DN_TArrayFindMemEq(ptr, size, ptr_find)
#define DN_PArrayResizePool(ptr, ptr_size, ptr_max, pool, new_max) DN_TArrayResizePool(&(ptr), ptr_size, ptr_max, pool, new_max)
#define DN_PArrayResizeArena(ptr, ptr_size, ptr_max, arena, new_max) DN_TArrayResizeArena(&(ptr), ptr_size, ptr_max, arena, new_max)
#define DN_PArrayReservePool(ptr, ptr_max, pool, new_max) DN_TArrayReservePool(&(ptr), ptr_max, pool, new_max)
#define DN_PArrayReserveArena(ptr, ptr_max, arena, new_max) DN_TArrayReserveArena(&(ptr), ptr_max, arena, new_max)
#define DN_PArrayPreparePool(ptr, size, ptr_max, pool, add_count) DN_TArrayPreparePool(&(ptr), size, ptr_max, pool, add_count)
#define DN_PArrayPrepareArena(ptr, size, ptr_max, arena, add_count) DN_TArrayPrepareArena(&(ptr), size, ptr_max, arena, add_count)
#define DN_PArrayCopyPtrPool(dest, src, count_, pool) DN_TArrayCopyPtrPool(&(dest), src, count_, pool)
#define DN_PArrayCopyPtrPoolAssert(dest, src, count_, pool) DN_TArrayCopyPtrPoolAssert(&(dest), src, count_, pool, DN_CallSiteNow)
#define DN_PArrayCopyPtrArena(dest, src, count_, arena) DN_TArrayCopyPtrArena(&(dest), src, count_, arena)
#define DN_PArrayCopyPtrArenaAssert(dest, src, count_, arena) DN_TArrayCopyPtrArenaAssert(&(dest), src, count_, arena, DN_CallSiteNow)
#define DN_PArrayMakeArray(ptr, ptr_size, max, count, z_mem) DN_TArrayMakeArray(ptr, ptr_size, max, count, z_mem)
#define DN_PArrayMakeArrayZ(ptr, ptr_size, max, count) DN_TArrayMakeArray(ptr, ptr_size, max, count, DN_ZMem_Yes)
#define DN_PArrayMakeArrayNoZ(ptr, ptr_size, max, count) DN_TArrayMakeArray(ptr, ptr_size, max, count, DN_ZMem_No)
#define DN_PArrayMakeArrayAssert(ptr, ptr_size, max, count, z_mem) DN_TArrayMakeArrayAssert(ptr, ptr_size, max, count, z_mem, DN_CallSiteNow)
#define DN_PArrayMakeArrayAssertZ(ptr, ptr_size, max, count) DN_TArrayMakeArrayAssert(ptr, ptr_size, max, count, DN_ZMem_Yes, DN_CallSiteNow)
#define DN_PArrayMakeArrayAssertNoZ(ptr, ptr_size, max, count) DN_TArrayMakeArrayAssert(ptr, ptr_size, max, count, DN_ZMem_No, DN_CallSiteNow)
#define DN_PArrayMakeArray(ptr, ptr_size, max, count, z_mem) DN_TArrayMakeArray(ptr, ptr_size, max, count, z_mem)
#define DN_PArrayMakeArrayZ(ptr, ptr_size, max, count) DN_TArrayMakeArray(ptr, ptr_size, max, count, DN_ZMem_Yes)
#define DN_PArrayMakeArrayNoZ(ptr, ptr_size, max, count) DN_TArrayMakeArray(ptr, ptr_size, max, count, DN_ZMem_No)
#define DN_PArrayMakeArrayAssert(ptr, ptr_size, max, count, z_mem) DN_TArrayMakeArrayAssert(ptr, ptr_size, max, count, z_mem, DN_CallSiteNow)
#define DN_PArrayMakeArrayAssertZ(ptr, ptr_size, max, count) DN_TArrayMakeArrayAssert(ptr, ptr_size, max, count, DN_ZMem_Yes, DN_CallSiteNow)
#define DN_PArrayMakeArrayAssertNoZ(ptr, ptr_size, max, count) DN_TArrayMakeArrayAssert(ptr, ptr_size, max, count, DN_ZMem_No, DN_CallSiteNow)
#define DN_PArrayMakeArrayArena(ptr, ptr_size, ptr_max, arena, count, z_mem) DN_TArrayMakeArrayArena(&(ptr), ptr_size, ptr_max, arena, count, z_mem)
#define DN_PArrayMakeArrayArenaZ(ptr, ptr_size, ptr_max, arena, count) DN_TArrayMakeArrayArena(&(ptr), ptr_size, ptr_max, arena, count, DN_ZMem_Yes)
#define DN_PArrayMakeArrayArenaNoZ(ptr, ptr_size, ptr_max, arena, count) DN_TArrayMakeArrayArena(&(ptr), ptr_size, ptr_max, arena, count, DN_ZMem_No)
#define DN_PArrayMakeArrayPool(ptr, ptr_size, ptr_max, pool, count, z_mem) DN_TArrayMakeArrayPool(&(ptr), ptr_size, ptr_max, pool, count, z_mem)
#define DN_PArrayMakeArrayPoolZ(ptr, ptr_size, ptr_max, pool, count) DN_TArrayMakeArrayPool(&(ptr), ptr_size, ptr_max, pool, count, DN_ZMem_Yes)
#define DN_PArrayMakeArrayPoolNoZ(ptr, ptr_size, ptr_max, pool, count) DN_TArrayMakeArrayPool(&(ptr), ptr_size, ptr_max, pool, count, DN_ZMem_No)
#define DN_PArrayMake(ptr, ptr_size, max, z_mem) DN_TArrayMakeArray(ptr, ptr_size, max, 1, z_mem)
#define DN_PArrayMakeZ(ptr, ptr_size, max) DN_TArrayMakeArray(ptr, ptr_size, max, 1, DN_ZMem_Yes)
#define DN_PArrayMakeNoZ(ptr, ptr_size, max) DN_TArrayMakeArray(ptr, ptr_size, max, 1, DN_ZMem_No)
#define DN_PArrayMakeAssert(ptr, ptr_size, max, z_mem) DN_TArrayMakeArrayAssert(ptr, ptr_size, max, 1, z_mem, DN_CallSiteNow)
#define DN_PArrayMakeAssertZ(ptr, ptr_size, max) DN_TArrayMakeArrayAssert(ptr, ptr_size, max, 1, DN_ZMem_Yes, DN_CallSiteNow)
#define DN_PArrayMakeAssertNoZ(ptr, ptr_size, max) DN_TArrayMakeArrayAssert(ptr, ptr_size, max, 1, DN_ZMem_No, DN_CallSiteNow)
#define DN_PArrayMake(ptr, ptr_size, max, z_mem) DN_TArrayMakeArray(ptr, ptr_size, max, 1, z_mem)
#define DN_PArrayMakeZ(ptr, ptr_size, max) DN_TArrayMakeArray(ptr, ptr_size, max, 1, DN_ZMem_Yes)
#define DN_PArrayMakeNoZ(ptr, ptr_size, max) DN_TArrayMakeArray(ptr, ptr_size, max, 1, DN_ZMem_No)
#define DN_PArrayMakeAssert(ptr, ptr_size, max, z_mem) DN_TArrayMakeArrayAssert(ptr, ptr_size, max, 1, z_mem, DN_CallSiteNow)
#define DN_PArrayMakeAssertZ(ptr, ptr_size, max) DN_TArrayMakeArrayAssert(ptr, ptr_size, max, 1, DN_ZMem_Yes, DN_CallSiteNow)
#define DN_PArrayMakeAssertNoZ(ptr, ptr_size, max) DN_TArrayMakeArrayAssert(ptr, ptr_size, max, 1, DN_ZMem_No, DN_CallSiteNow)
#define DN_PArrayMakeArena(ptr, ptr_size, ptr_max, arena, z_mem) DN_TArrayMakeArrayArena(&(ptr), ptr_size, ptr_max, arena, 1, z_mem)
#define DN_PArrayMakeArenaZ(ptr, ptr_size, ptr_max, arena) DN_TArrayMakeArrayArena(&(ptr), ptr_size, ptr_max, arena, 1, DN_ZMem_Yes)
#define DN_PArrayMakeArenaNoZ(ptr, ptr_size, ptr_max, arena) DN_TArrayMakeArrayArena(&(ptr), ptr_size, ptr_max, arena, 1, DN_ZMem_No)
#define DN_PArrayMakePool(ptr, ptr_size, ptr_max, pool, z_mem) DN_TArrayMakeArrayPool(&(ptr), ptr_size, ptr_max, pool, 1, z_mem)
#define DN_PArrayMakePoolZ(ptr, ptr_size, ptr_max, pool) DN_TArrayMakeArrayPool(&(ptr), ptr_size, ptr_max, pool, 1, DN_ZMem_Yes)
#define DN_PArrayMakePoolNoZ(ptr, ptr_size, ptr_max, pool) DN_TArrayMakeArrayPool(&(ptr), ptr_size, ptr_max, pool, 1, DN_ZMem_No)
#define DN_PArrayAddArray(ptr, ptr_size, max, items, count, add) DN_TArrayAddArray(ptr, ptr_size, max, items, count, add)
#define DN_PArrayAdd(ptr, ptr_size, max, item, add) DN_TArrayAddArray(ptr, ptr_size, max, &item, 1, add)
#define DN_PArrayAppendArray(ptr, ptr_size, max, items, count) DN_TArrayAddArray(ptr, ptr_size, max, items, count, DN_ArrayAdd_Append)
#define DN_PArrayAppend(ptr, ptr_size, max, item) DN_TArrayAddArray(ptr, ptr_size, max, &item, 1, DN_ArrayAdd_Append)
#define DN_PArrayAppendAssert(ptr, ptr_size, max, item) DN_TArrayAddArrayAssert(ptr, ptr_size, max, &item, 1, DN_ArrayAdd_Append, DN_CallSiteNow)
#define DN_PArrayPrependArray(ptr, ptr_size, max, items, count) DN_TArrayAddArray(ptr, ptr_size, max, items, count, DN_ArrayAdd_Prepend)
#define DN_PArrayPrepend(ptr, ptr_size, max, item) DN_TArrayAddArray(ptr, ptr_size, max, &item, 1, DN_ArrayAdd_Prepend)
#define DN_PArrayAddArray(ptr, ptr_size, max, items, count, add) DN_TArrayAddArray(ptr, ptr_size, max, items, count, add)
#define DN_PArrayAddArrayArena(ptr, ptr_size, ptr_max, arena, items, count, add) DN_TArrayAddArrayArena(&(ptr), ptr_size, ptr_max, arena, items, count, add)
#define DN_PArrayAddArrayPool(ptr, ptr_size, ptr_max, pool, items, count, add) DN_TArrayAddArrayPool(&(ptr), ptr_size, ptr_max, pool, items, count, add)
#define DN_PArrayAdd(ptr, ptr_size, max, item, add) DN_TArrayAddArray(ptr, ptr_size, max, &item, 1, add)
#define DN_PArrayAddArena(ptr, ptr_size, ptr_max, arena, item, add) DN_TArrayAddArrayArena(&(ptr), ptr_size, ptr_max, arena, &item, 1, add)
#define DN_PArrayAddPool(ptr, ptr_size, ptr_max, pool, item, add) DN_TArrayAddArrayPool(&(ptr), ptr_size, ptr_max, pool, &item, 1, add)
#define DN_PArrayAppendArray(ptr, ptr_size, max, items, count) DN_TArrayAddArray(ptr, ptr_size, max, items, count, DN_ArrayAdd_Append)
#define DN_PArrayAppend(ptr, ptr_size, max, item) DN_TArrayAddArray(ptr, ptr_size, max, &item, 1, DN_ArrayAdd_Append)
#define DN_PArrayAppendArena(ptr, ptr_size, ptr_max, arena, item) DN_TArrayAddArrayArena(&(ptr), ptr_size, ptr_max, arena, &item, 1, DN_ArrayAdd_Append)
#define DN_PArrayAppendPool(ptr, ptr_size, ptr_max, pool, item) DN_TArrayAddArrayPool(&(ptr), ptr_size, ptr_max, pool, &item, 1, DN_ArrayAdd_Append)
#define DN_PArrayAppendAssert(ptr, ptr_size, max, item) DN_TArrayAddArrayAssert(ptr, ptr_size, max, &item, 1, DN_ArrayAdd_Append, DN_CallSiteNow)
#define DN_PArrayPrependArray(ptr, ptr_size, max, items, count) DN_TArrayAddArray(ptr, ptr_size, max, items, count, DN_ArrayAdd_Prepend)
#define DN_PArrayPrepend(ptr, ptr_size, max, item) DN_TArrayAddArray(ptr, ptr_size, max, &item, 1, DN_ArrayAdd_Prepend)
#define DN_PArrayPrependArena(ptr, ptr_size, ptr_max, arena, item) DN_TArrayAddArrayArena(&(ptr), ptr_size, ptr_max, arena, &item, 1, DN_ArrayAdd_Prepend)
#define DN_PArrayPrependPool(ptr, ptr_size, ptr_max, pool, item) DN_TArrayAddArrayPool(&(ptr), ptr_size, ptr_max, pool, &item, 1, DN_ArrayAdd_Prepend)
#define DN_PArrayEraseRange(ptr, ptr_size, begin_index, count, erase) DN_TArrayEraseRange(ptr, ptr_size, begin_index, count, erase)
#define DN_PArrayErase(ptr, ptr_size, index, erase) DN_TArrayEraseRange(ptr, ptr_size, index, 1, erase)
#define DN_PArrayInsertArray(ptr, ptr_size, max, index, items, count) DN_TArrayInsertArray(ptr, ptr_size, max, index, items, count)
#define DN_PArrayInsert(ptr, ptr_size, max, index, item) DN_TArrayInsertArray(ptr, ptr_size, max, index, &item, 1)
#define DN_PArrayPopFront(ptr, ptr_size, max, count) DN_TArrayPopFront(ptr, ptr_size, count)
#define DN_PArrayPopBack(ptr, ptr_size, max, count) DN_TArrayPopBack(ptr, ptr_size, count)
#define DN_PArrayEraseRange(ptr, ptr_size, begin_index, count, erase) DN_TArrayEraseRange(ptr, ptr_size, begin_index, count, erase)
#define DN_PArrayErase(ptr, ptr_size, index, erase) DN_TArrayEraseRange(ptr, ptr_size, index, 1, erase)
#define DN_PArrayInsertArray(ptr, ptr_size, max, index, items, count) DN_TArrayInsertArray(ptr, ptr_size, max, index, items, count)
#define DN_PArrayInsert(ptr, ptr_size, max, index, item) DN_TArrayInsertArray(ptr, ptr_size, max, index, &item, 1)
#define DN_PArrayPopFront(ptr, ptr_size, max, count) DN_TArrayPopFront(ptr, ptr_size, count)
#define DN_PArrayPopBack(ptr, ptr_size, max, count) DN_TArrayPopBack(ptr, ptr_size, count)
#else
#define DN_PArrayFind(ptr, size, ptr_find, eq_func) DN_ArrayFind(ptr, size, sizeof(*(ptr)), ptr_find, eq_func)
#define DN_PArrayFindMemEq(ptr, size, ptr_find) DN_ArrayFindMemEq(ptr, size, sizeof(*(ptr)), ptr_find)
#define DN_PArrayResizeFromPool(ptr, ptr_size, ptr_max, pool, new_max) DN_ArrayResizeFromPool((void **)&(ptr), ptr_size, ptr_max, sizeof((ptr)[0]), pool, new_max)
#define DN_PArrayResizeFromArena(ptr, ptr_size, ptr_max, arena, new_max) DN_ArrayResizeFromArena((void **)&(ptr), ptr_size, ptr_max, sizeof((ptr)[0]), arena, new_max)
#define DN_PArrayGrowFromPool(ptr, ptr_max, pool, new_max) DN_ArrayGrowFromPool((void **)&(ptr), ptr_max, sizeof((ptr)[0]), pool, new_max)
#define DN_PArrayGrowFromArena(ptr, ptr_max, arena, new_max) DN_ArrayGrowFromArena((void **)&(ptr), ptr_max, sizeof((ptr)[0]), arena, new_max)
#define DN_PArrayGrowIfNeededFromPool(ptr, size, ptr_max, pool, add_count) DN_ArrayGrowIfNeededFromPool((void **)(ptr), size, ptr_max, sizeof((*ptr)[0]), pool, add_count)
#define DN_PArrayGrowIfNeededFromArena(ptr, size, ptr_max, arena, add_count) DN_ArrayGrowIfNeededFromArena((void **)(ptr), size, ptr_max, sizeof((*ptr)[0]), arena, add_count)
#define DN_PArrayResizePool(ptr, ptr_size, ptr_max, pool, new_max) DN_ArrayResizePool((void **)&(ptr), ptr_size, ptr_max, sizeof((ptr)[0]), pool, new_max)
#define DN_PArrayResizeArena(ptr, ptr_size, ptr_max, arena, new_max) DN_ArrayResizeArena((void **)&(ptr), ptr_size, ptr_max, sizeof((ptr)[0]), arena, new_max)
#define DN_PArrayReservePool(ptr, ptr_max, pool, new_max) DN_ArrayReservePool((void **)&(ptr), ptr_max, sizeof((ptr)[0]), pool, new_max)
#define DN_PArrayReserveArena(ptr, ptr_max, arena, new_max) DN_ArrayReserveArena((void **)&(ptr), ptr_max, sizeof((ptr)[0]), arena, new_max)
#define DN_PArrayPreparePool(ptr, size, ptr_max, pool, add_count) DN_ArrayPreparePool((void **)(ptr), size, ptr_max, sizeof((*ptr)[0]), pool, add_count)
#define DN_PArrayPrepareArena(ptr, size, ptr_max, arena, add_count) DN_ArrayPrepareArena((void **)(ptr), size, ptr_max, sizeof((*ptr)[0]), arena, add_count)
#define DN_PArrayCopyPtrPool(ptr_array, src, count_, pool) DN_ArrayCopyPtrPool(ptr_array, src, count_, sizeof((*ptr)[0]), pool)
#define DN_PArrayCopyPtrPoolAssert(ptr_array, src, count_, pool) DN_ArrayCopyPtrPool(ptr_array, src, count_, sizeof((*ptr)[0]), pool, DN_CallSiteNow)
#define DN_PArrayCopyPtrArena(ptr_array, src, count_, arena) DN_ArrayCopyPtrArena(ptr_array, src, count_, sizeof((*ptr)[0]), arena)
@@ -5900,6 +5918,12 @@ DN_API DN_RaycastV2 DN_RaycastLineIntersectV2
#define DN_PArrayMakeArrayAssert(ptr, ptr_size, max, count, z_mem) (DN_CppDeclType(&(ptr)[0]))DN_ArrayMakeArrayAssert(ptr, ptr_size, max, sizeof((ptr)[0]), count, z_mem, DN_CallSiteNow)
#define DN_PArrayMakeArrayAssertZ(ptr, ptr_size, max, count) (DN_CppDeclType(&(ptr)[0]))DN_ArrayMakeArrayAssert(ptr, ptr_size, max, sizeof((ptr)[0]), count, DN_ZMem_Yes, DN_CallSiteNow)
#define DN_PArrayMakeArrayAssertNoZ(ptr, ptr_size, max, count) (DN_CppDeclType(&(ptr)[0]))DN_ArrayMakeArrayAssert(ptr, ptr_size, max, sizeof((ptr)[0]), count, DN_ZMem_No, DN_CallSiteNow)
#define DN_PArrayMakeArrayArena(ptr, ptr_size, max, arena, count, z_mem) (DN_CppDeclType(&(ptr)[0]))DN_ArrayMakeArrayArena((void **)&(ptr), ptr_size, max, sizeof((ptr)[0]), arena, count, z_mem)
#define DN_PArrayMakeArrayArenaZ(ptr, ptr_size, max, arena, count) (DN_CppDeclType(&(ptr)[0]))DN_ArrayMakeArrayArena((void **)&(ptr), ptr_size, max, sizeof((ptr)[0]), arena, count, DN_ZMem_Yes)
#define DN_PArrayMakeArrayArenaNoZ(ptr, ptr_size, max, arena, count) (DN_CppDeclType(&(ptr)[0]))DN_ArrayMakeArrayArena((void **)&(ptr), ptr_size, max, sizeof((ptr)[0]), arena, count, DN_ZMem_No)
#define DN_PArrayMakeArrayPool(ptr, ptr_size, max, pool, count, z_mem) (DN_CppDeclType(&(ptr)[0]))DN_ArrayMakeArrayPool((void **)&(ptr), ptr_size, max, sizeof((ptr)[0]), pool, count, z_mem)
#define DN_PArrayMakeArrayPoolZ(ptr, ptr_size, max, pool, count) (DN_CppDeclType(&(ptr)[0]))DN_ArrayMakeArrayPool((void **)&(ptr), ptr_size, max, sizeof((ptr)[0]), pool, count, DN_ZMem_Yes)
#define DN_PArrayMakeArrayPoolNoZ(ptr, ptr_size, max, pool, count) (DN_CppDeclType(&(ptr)[0]))DN_ArrayMakeArrayPool((void **)&(ptr), ptr_size, max, sizeof((ptr)[0]), pool, count, DN_ZMem_No)
#define DN_PArrayMake(ptr, ptr_size, max, z_mem) (DN_CppDeclType(&(ptr)[0]))DN_ArrayMakeArray(ptr, ptr_size, max, sizeof((ptr)[0]), 1, z_mem)
#define DN_PArrayMakeZ(ptr, ptr_size, max) (DN_CppDeclType(&(ptr)[0]))DN_ArrayMakeArray(ptr, ptr_size, max, sizeof((ptr)[0]), 1, DN_ZMem_Yes)
@@ -5907,14 +5931,28 @@ DN_API DN_RaycastV2 DN_RaycastLineIntersectV2
#define DN_PArrayMakeAssert(ptr, ptr_size, max, z_mem) (DN_CppDeclType(&(ptr)[0]))DN_ArrayMakeArrayAssert(ptr, ptr_size, max, sizeof((ptr)[0]), 1, z_mem, DN_CallSiteNow)
#define DN_PArrayMakeAssertZ(ptr, ptr_size, max) (DN_CppDeclType(&(ptr)[0]))DN_ArrayMakeArrayAssert(ptr, ptr_size, max, sizeof((ptr)[0]), 1, DN_ZMem_Yes, DN_CallSiteNow)
#define DN_PArrayMakeAssertNoZ(ptr, ptr_size, max) (DN_CppDeclType(&(ptr)[0]))DN_ArrayMakeArrayAssert(ptr, ptr_size, max, sizeof((ptr)[0]), 1, DN_ZMem_No, DN_CallSiteNow)
#define DN_PArrayMakeArena(ptr, ptr_size, max, arena, z_mem) (DN_CppDeclType(&(ptr)[0]))DN_ArrayMakeArrayArena((void **)&(ptr), ptr_size, max, sizeof((ptr)[0]), arena, 1, z_mem)
#define DN_PArrayMakeArenaZ(ptr, ptr_size, max, arena) (DN_CppDeclType(&(ptr)[0]))DN_ArrayMakeArrayArena((void **)&(ptr), ptr_size, max, sizeof((ptr)[0]), arena, 1, DN_ZMem_Yes)
#define DN_PArrayMakeArenaNoZ(ptr, ptr_size, max, arena) (DN_CppDeclType(&(ptr)[0]))DN_ArrayMakeArrayArena((void **)&(ptr), ptr_size, max, sizeof((ptr)[0]), arena, 1, DN_ZMem_No)
#define DN_PArrayMakePool(ptr, ptr_size, max, pool, z_mem) (DN_CppDeclType(&(ptr)[0]))DN_ArrayMakeArrayPool((void **)&(ptr), ptr_size, max, sizeof((ptr)[0]), pool, 1, z_mem)
#define DN_PArrayMakePoolZ(ptr, ptr_size, max, pool) (DN_CppDeclType(&(ptr)[0]))DN_ArrayMakeArrayPool((void **)&(ptr), ptr_size, max, sizeof((ptr)[0]), pool, 1, DN_ZMem_Yes)
#define DN_PArrayMakePoolNoZ(ptr, ptr_size, max, pool) (DN_CppDeclType(&(ptr)[0]))DN_ArrayMakeArrayPool((void **)&(ptr), ptr_size, max, sizeof((ptr)[0]), pool, 1, DN_ZMem_No)
#define DN_PArrayAddArray(ptr, ptr_size, max, items, count, add) (DN_CppDeclType(&(ptr)[0]))DN_ArrayAddArray(ptr, ptr_size, max, sizeof((ptr)[0]), items, count, add)
#define DN_PArrayAddArrayArena(ptr, ptr_size, max, arena, items, count, add) (DN_CppDeclType(&(ptr)[0]))DN_ArrayAddArrayArena((void **)&(ptr), ptr_size, max, sizeof((ptr)[0]), arena, items, count, add)
#define DN_PArrayAddArrayPool(ptr, ptr_size, max, pool, items, count, add) (DN_CppDeclType(&(ptr)[0]))DN_ArrayAddArrayPool((void **)&(ptr), ptr_size, max, sizeof((ptr)[0]), pool, items, count, add)
#define DN_PArrayAdd(ptr, ptr_size, max, item, add) (DN_CppDeclType(&(ptr)[0]))DN_ArrayAddArray(ptr, ptr_size, max, sizeof((ptr)[0]), &item, 1, add)
#define DN_PArrayAddArena(ptr, ptr_size, max, arena, item, add) (DN_CppDeclType(&(ptr)[0]))DN_ArrayAddArrayArena((void **)&(ptr), ptr_size, max, sizeof((ptr)[0]), arena, &item, 1, add)
#define DN_PArrayAddPool(ptr, ptr_size, max, pool, item, add) (DN_CppDeclType(&(ptr)[0]))DN_ArrayAddArrayPool((void **)&(ptr), ptr_size, max, sizeof((ptr)[0]), pool, &item, 1, add)
#define DN_PArrayAppendArray(ptr, ptr_size, max, items, count) (DN_CppDeclType(&(ptr)[0]))DN_ArrayAddArray(ptr, ptr_size, max, sizeof((ptr)[0]), items, count, DN_ArrayAdd_Append)
#define DN_PArrayAppend(ptr, ptr_size, max, item) (DN_CppDeclType(&(ptr)[0]))DN_ArrayAddArray(ptr, ptr_size, max, sizeof((ptr)[0]), &item, 1, DN_ArrayAdd_Append)
#define DN_PArrayAppendArena(ptr, ptr_size, max, arena, item) (DN_CppDeclType(&(ptr)[0]))DN_ArrayAddArrayArena((void **)&(ptr), ptr_size, max, sizeof((ptr)[0]), arena, &item, 1, DN_ArrayAdd_Append)
#define DN_PArrayAppendPool(ptr, ptr_size, max, pool, item) (DN_CppDeclType(&(ptr)[0]))DN_ArrayAddArrayPool((void **)&(ptr), ptr_size, max, sizeof((ptr)[0]), pool, &item, 1, DN_ArrayAdd_Append)
#define DN_PArrayAppendAssert(ptr, ptr_size, max, item) (DN_CppDeclType(&(ptr)[0]))DN_ArrayAddArrayAssert(ptr, ptr_size, max, sizeof((ptr)[0]), &item, 1, DN_ArrayAdd_Append, DN_CallSiteNow)
#define DN_PArrayPrependArray(ptr, ptr_size, max, items, count) (DN_CppDeclType(&(ptr)[0]))DN_ArrayAddArray(ptr, ptr_size, max, sizeof((ptr)[0]), items, count, DN_ArrayAdd_Prepend)
#define DN_PArrayPrepend(ptr, ptr_size, max, item) (DN_CppDeclType(&(ptr)[0]))DN_ArrayAddArray(ptr, ptr_size, max, sizeof((ptr)[0]), &item, 1, DN_ArrayAdd_Prepend)
#define DN_PArrayPrependArena(ptr, ptr_size, max, arena, item) (DN_CppDeclType(&(ptr)[0]))DN_ArrayAddArrayArena((void **)&(ptr), ptr_size, max, sizeof((ptr)[0]), arena, &item, 1, DN_ArrayAdd_Prepend)
#define DN_PArrayPrependPool(ptr, ptr_size, max, pool, item) (DN_CppDeclType(&(ptr)[0]))DN_ArrayAddArrayPool((void **)&(ptr), ptr_size, max, sizeof((ptr)[0]), pool, &item, 1, DN_ArrayAdd_Prepend)
#define DN_PArrayEraseRange(ptr, ptr_size, begin_index, count, erase) DN_ArrayEraseRange(ptr, ptr_size, sizeof((ptr)[0]), begin_index, count, erase)
#define DN_PArrayErase(ptr, ptr_size, index, erase) DN_ArrayEraseRange(ptr, ptr_size, sizeof((ptr)[0]), index, 1, erase)
@@ -5940,14 +5978,26 @@ DN_API DN_RaycastV2 DN_RaycastLineIntersectV2
#define DN_LArrayMakeAssert(c_array, ptr_size, z_mem) DN_PArrayMakeAssert(c_array, ptr_size, DN_ArrayCountU(c_array), z_mem)
#define DN_LArrayMakeAssertZ(c_array, ptr_size) DN_PArrayMakeAssertZ(c_array, ptr_size, DN_ArrayCountU(c_array))
#define DN_LArrayMakeAssertNoZ(c_array, ptr_size) DN_PArrayMakeAssertNoZ(c_array, ptr_size, DN_ArrayCountU(c_array))
#define DN_LArrayMakeArena(c_array, ptr_size, arena, z_mem) DN_PArrayMakeArena(c_array, ptr_size, DN_ArrayCountU(c_array), arena, z_mem)
#define DN_LArrayMakeArenaZ(c_array, ptr_size, arena) DN_PArrayMakeArenaZ(c_array, ptr_size, DN_ArrayCountU(c_array), arena)
#define DN_LArrayMakeArenaNoZ(c_array, ptr_size, arena) DN_PArrayMakeArenaNoZ(c_array, ptr_size, DN_ArrayCountU(c_array), arena)
#define DN_LArrayMakePool(c_array, ptr_size, pool, z_mem) DN_PArrayMakePool(c_array, ptr_size, DN_ArrayCountU(c_array), pool, z_mem)
#define DN_LArrayMakePoolZ(c_array, ptr_size, pool) DN_PArrayMakePoolZ(c_array, ptr_size, DN_ArrayCountU(c_array), pool)
#define DN_LArrayMakePoolNoZ(c_array, ptr_size, pool) DN_PArrayMakePoolNoZ(c_array, ptr_size, DN_ArrayCountU(c_array), pool)
#define DN_LArrayAddArray(c_array, ptr_size, items, count, add) DN_PArrayAddArray(c_array, ptr_size, DN_ArrayCountU(c_array), items, count, add)
#define DN_LArrayAdd(c_array, ptr_size, item, add) DN_PArrayAdd(c_array, ptr_size, DN_ArrayCountU(c_array), item, add)
#define DN_LArrayAddArena(c_array, ptr_size, arena, item, add) DN_PArrayAddArena(c_array, ptr_size, DN_ArrayCountU(c_array), arena, item, add)
#define DN_LArrayAddPool(c_array, ptr_size, pool, item, add) DN_PArrayAddPool(c_array, ptr_size, DN_ArrayCountU(c_array), pool, item, add)
#define DN_LArrayAppendArray(c_array, ptr_size, items, count) DN_PArrayAppendArray(c_array, ptr_size, DN_ArrayCountU(c_array), items, count)
#define DN_LArrayAppend(c_array, ptr_size, item) DN_PArrayAppend(c_array, ptr_size, DN_ArrayCountU(c_array), item)
#define DN_LArrayAppendArena(c_array, ptr_size, arena, item) DN_PArrayAppendArena(c_array, ptr_size, DN_ArrayCountU(c_array), arena, item)
#define DN_LArrayAppendPool(c_array, ptr_size, pool, item) DN_PArrayAppendPool(c_array, ptr_size, DN_ArrayCountU(c_array), pool, item)
#define DN_LArrayAppendAssert(c_array, ptr_size, item) DN_PArrayAppendAssert(c_array, ptr_size, DN_ArrayCountU(c_array), item)
#define DN_LArrayPrependArray(c_array, ptr_size, items, count) DN_PArrayPrependArray(c_array, ptr_size, DN_ArrayCountU(c_array), items, count)
#define DN_LArrayPrepend(c_array, ptr_size, item) DN_PArrayPrepend(c_array, ptr_size, DN_ArrayCountU(c_array), item)
#define DN_LArrayPrependArena(c_array, ptr_size, arena, item) DN_PArrayPrependArena(c_array, ptr_size, DN_ArrayCountU(c_array), arena, item)
#define DN_LArrayPrependPool(c_array, ptr_size, pool, item) DN_PArrayPrependPool(c_array, ptr_size, DN_ArrayCountU(c_array), pool, item)
#define DN_LArrayEraseRange(c_array, ptr_size, begin_index, count, erase) DN_PArrayEraseRange(c_array, ptr_size, begin_index, count, erase)
#define DN_LArrayErase(c_array, ptr_size, index, erase) DN_PArrayErase(c_array, ptr_size, index, erase)
#define DN_LArrayInsertArray(c_array, ptr_size, index, items, count) DN_PArrayInsertArray(c_array, ptr_size, DN_ArrayCountU(c_array), index, items, count)
@@ -5957,12 +6007,12 @@ DN_API DN_RaycastV2 DN_RaycastLineIntersectV2
#define DN_IArrayFind(ptr_array, ptr_find, eq_func) DN_PArrayFind((ptr_array)->data, (ptr_array)->count, ptr_find, eq_func)
#define DN_IArrayFindMemEq(ptr_array, ptr_find) DN_PArrayFindMemEq((ptr_array)->data, (ptr_array)->count, ptr_find)
#define DN_IArrayResizeFromPool(ptr_array, pool, new_max) DN_PArrayResizeFromPool((ptr_array)->data, &(ptr_array)->count, &(ptr_array)->max, pool, new_max)
#define DN_IArrayResizeFromArena(ptr_array, arena, new_max) DN_PArrayResizeFromArena((ptr_array)->data, &(ptr_array)->count, &(ptr_array)->max, arena, new_max)
#define DN_IArrayGrowFromPool(ptr_array, pool, new_max) DN_PArrayGrowFromPool((ptr_array)->data, &(ptr_array)->max, pool, new_max)
#define DN_IArrayGrowFromArena(ptr_array, arena, new_max) DN_PArrayGrowFromArena((ptr_array)->data, &(ptr_array)->max, arena, new_max)
#define DN_IArrayGrowIfNeededFromPool(ptr_array, pool, add_count) DN_PArrayGrowIfNeededFromPool(&(ptr_array)->data, (ptr_array)->count, &(ptr_array)->max, pool, add_count)
#define DN_IArrayGrowIfNeededFromArena(ptr_array, arena, add_count) DN_PArrayGrowIfNeededFromArena(&(ptr_array)->data, (ptr_array)->count, &(ptr_array)->max, arena, add_count)
#define DN_IArrayResizePool(ptr_array, pool, new_max) DN_PArrayResizePool((ptr_array)->data, &(ptr_array)->count, &(ptr_array)->max, pool, new_max)
#define DN_IArrayResizeArena(ptr_array, arena, new_max) DN_PArrayResizeArena((ptr_array)->data, &(ptr_array)->count, &(ptr_array)->max, arena, new_max)
#define DN_IArrayReservePool(ptr_array, pool, new_max) DN_PArrayReservePool((ptr_array)->data, &(ptr_array)->max, pool, new_max)
#define DN_IArrayReserveArena(ptr_array, arena, new_max) DN_PArrayReserveArena((ptr_array)->data, &(ptr_array)->max, arena, new_max)
#define DN_IArrayPreparePool(ptr_array, pool, add_count) DN_PArrayPreparePool(&(ptr_array)->data, (ptr_array)->count, &(ptr_array)->max, pool, add_count)
#define DN_IArrayPrepareArena(ptr_array, arena, add_count) DN_PArrayPrepareArena(&(ptr_array)->data, (ptr_array)->count, &(ptr_array)->max, arena, add_count)
#define DN_IArrayCopyPtrPool(ptr_array, src, count_, pool) (ptr_array)->max = (ptr_array)->count = DN_PArrayCopyPtrPool((ptr_array), src, count_, pool)
#define DN_IArrayCopyPtrPoolAssert(ptr_array, src, count_, pool) (ptr_array)->max = (ptr_array)->count = DN_PArrayCopyPtrPoolAssert((ptr_array), src, count_, pool)
#define DN_IArrayCopyPtrArena(ptr_array, src, count_, arena) (ptr_array)->max = (ptr_array)->count = DN_PArrayCopyPtrArena((ptr_array), src, count_, arena)
@@ -5974,6 +6024,12 @@ DN_API DN_RaycastV2 DN_RaycastLineIntersectV2
#define DN_IArrayMakeArrayAssert(ptr_array, count_, z_mem) DN_PArrayMakeArrayAssert((ptr_array)->data, &(ptr_array)->count, (ptr_array)->max, count_, z_mem)
#define DN_IArrayMakeArrayAssertZ(ptr_array, count_) DN_PArrayMakeArrayAssertZ((ptr_array)->data, &(ptr_array)->count, (ptr_array)->max, count_)
#define DN_IArrayMakeArrayAssertNoZ(ptr_array, count_) DN_PArrayMakeArrayAssertNoZ((ptr_array)->data, &(ptr_array)->count, (ptr_array)->max, count_)
#define DN_IArrayMakeArrayArena(ptr_array, arena, count_, z_mem) DN_PArrayMakeArrayArena((ptr_array)->data, &(ptr_array)->count, &(ptr_array)->max, arena, count_, z_mem)
#define DN_IArrayMakeArrayArenaZ(ptr_array, arena, count_) DN_PArrayMakeArrayArenaZ((ptr_array)->data, &(ptr_array)->count, &(ptr_array)->max, arena, count_)
#define DN_IArrayMakeArrayArenaNoZ(ptr_array, arena, count_) DN_PArrayMakeArrayArenaNoZ((ptr_array)->data, &(ptr_array)->count, &(ptr_array)->max, arena, count_)
#define DN_IArrayMakeArrayPool(ptr_array, pool, count_, z_mem) DN_PArrayMakeArrayPool((ptr_array)->data, &(ptr_array)->count, &(ptr_array)->max, pool, count_, z_mem)
#define DN_IArrayMakeArrayPoolZ(ptr_array, pool, count_) DN_PArrayMakeArrayPoolZ((ptr_array)->data, &(ptr_array)->count, &(ptr_array)->max, pool, count_)
#define DN_IArrayMakeArrayPoolNoZ(ptr_array, pool, count_) DN_PArrayMakeArrayPoolNoZ((ptr_array)->data, &(ptr_array)->count, &(ptr_array)->max, pool, count_)
#define DN_IArrayMake(ptr_array, z_mem) DN_PArrayMake((ptr_array)->data, &(ptr_array)->count, (ptr_array)->max, z_mem)
#define DN_IArrayMakeZ(ptr_array) DN_PArrayMakeZ((ptr_array)->data, &(ptr_array)->count, (ptr_array)->max)
@@ -5981,14 +6037,29 @@ DN_API DN_RaycastV2 DN_RaycastLineIntersectV2
#define DN_IArrayMakeAssert(ptr_array, z_mem) DN_PArrayMakeAssert((ptr_array)->data, &(ptr_array)->count, (ptr_array)->max, z_mem)
#define DN_IArrayMakeAssertZ(ptr_array) DN_PArrayMakeAssertZ((ptr_array)->data, &(ptr_array)->count, (ptr_array)->max)
#define DN_IArrayMakeAssertNoZ(ptr_array) DN_PArrayMakeAssertNoZ((ptr_array)->data, &(ptr_array)->count, (ptr_array)->max)
#define DN_IArrayMakeArena(ptr_array, arena, z_mem) DN_PArrayMakeArena((ptr_array)->data, &(ptr_array)->count, &(ptr_array)->max, arena, z_mem)
#define DN_IArrayMakeArenaZ(ptr_array, arena) DN_PArrayMakeArenaZ((ptr_array)->data, &(ptr_array)->count, &(ptr_array)->max, arena)
#define DN_IArrayMakeArenaNoZ(ptr_array, arena) DN_PArrayMakeArenaNoZ((ptr_array)->data, &(ptr_array)->count, &(ptr_array)->max, arena)
#define DN_IArrayMakePool(ptr_array, pool, z_mem) DN_PArrayMakePool((ptr_array)->data, &(ptr_array)->count, &(ptr_array)->max, pool, z_mem)
#define DN_IArrayMakePoolZ(ptr_array, pool) DN_PArrayMakePoolZ((ptr_array)->data, &(ptr_array)->count, &(ptr_array)->max, pool)
#define DN_IArrayMakePoolNoZ(ptr_array, pool) DN_PArrayMakePoolNoZ((ptr_array)->data, &(ptr_array)->count, &(ptr_array)->max, pool)
#define DN_IArrayMakeNoZ(ptr_array) DN_PArrayMakeNoZ((ptr_array)->data, &(ptr_array)->count, (ptr_array)->max)
#define DN_IArrayAddArray(ptr_array, items, count_, add) DN_PArrayAddArray((ptr_array)->data, &(ptr_array)->count, (ptr_array)->max, items, count_, add)
#define DN_IArrayAddArrayArena(ptr_array, arena, items, count_, add) DN_PArrayAddArrayArena((ptr_array)->data, &(ptr_array)->count, &(ptr_array)->max, arena, items, count_, add)
#define DN_IArrayAddArrayPool(ptr_array, pool, items, count_, add) DN_PArrayAddArrayPool((ptr_array)->data, &(ptr_array)->count, &(ptr_array)->max, pool, items, count_, add)
#define DN_IArrayAdd(ptr_array, item, add) DN_PArrayAdd((ptr_array)->data, &(ptr_array)->count, (ptr_array)->max, item, add)
#define DN_IArrayAddArena(ptr_array, arena, item, add) DN_PArrayAddArena((ptr_array)->data, &(ptr_array)->count, &(ptr_array)->max, arena, item, add)
#define DN_IArrayAddPool(ptr_array, pool, item, add) DN_PArrayAddPool((ptr_array)->data, &(ptr_array)->count, &(ptr_array)->max, pool, item, add)
#define DN_IArrayAppendArray(ptr_array, items, count_) DN_PArrayAppendArray((ptr_array)->data, &(ptr_array)->count, (ptr_array)->max, items, count_)
#define DN_IArrayAppend(ptr_array, item) DN_PArrayAppend((ptr_array)->data, &(ptr_array)->count, (ptr_array)->max, item)
#define DN_IArrayAppendArena(ptr_array, arena, item) DN_PArrayAppendArena((ptr_array)->data, &(ptr_array)->count, &(ptr_array)->max, arena, item)
#define DN_IArrayAppendPool(ptr_array, pool, item) DN_PArrayAppendPool((ptr_array)->data, &(ptr_array)->count, &(ptr_array)->max, pool, item)
#define DN_IArrayAppendAssert(ptr_array, item) DN_PArrayAppendAssert((ptr_array)->data, &(ptr_array)->count, (ptr_array)->max, item)
#define DN_IArrayPrependArray(ptr_array, items, count_) DN_PArrayPrependArray((ptr_array)->data, &(ptr_array)->count, (ptr_array)->max, items, count_)
#define DN_IArrayPrepend(ptr_array, item) DN_PArrayPrepend((ptr_array)->data, &(ptr_array)->count, (ptr_array)->max, item)
#define DN_IArrayPrependArena(ptr_array, arena, item) DN_PArrayPrependArena((ptr_array)->data, &(ptr_array)->count, &(ptr_array)->max, arena, item)
#define DN_IArrayPrependPool(ptr_array, pool, item) DN_PArrayPrependPool((ptr_array)->data, &(ptr_array)->count, &(ptr_array)->max, pool, item)
#define DN_IArrayEraseRange(ptr_array, begin_index, count_, erase) DN_PArrayEraseRange((ptr_array)->data, &(ptr_array)->count, begin_index, count_, erase)
#define DN_IArrayErase(ptr_array, index, erase) DN_PArrayErase((ptr_array)->data, &(ptr_array)->count, index, erase)
#define DN_IArrayInsertArray(ptr_array, index, items, count_) DN_PArrayInsertArray((ptr_array)->data, &(ptr_array)->count, (ptr_array)->max, index, items, count_)
@@ -6016,14 +6087,18 @@ DN_API void* DN_ArrayPopBack (void *
DN_API DN_ArrayEraseResult DN_ArrayEraseRange (void *data, DN_USize *count, DN_USize elem_size, DN_USize begin_index, DN_ISize erase_count, DN_ArrayErase erase);
DN_API void* DN_ArrayMakeArray (void *data, DN_USize *count, DN_USize max, DN_USize elem_size, DN_USize make_count, DN_ZMem z_mem);
DN_API void* DN_ArrayMakeArrayAssert (void *data, DN_USize *count, DN_USize max, DN_USize elem_size, DN_USize make_count, DN_ZMem z_mem, DN_CallSite call_site);
DN_API void* DN_ArrayMakeArrayArena (void **data, DN_USize *count, DN_USize *max, DN_USize elem_size, DN_Arena *arena, DN_USize make_count, DN_ZMem z_mem);
DN_API void* DN_ArrayMakeArrayPool (void **data, DN_USize *count, DN_USize *max, DN_USize elem_size, DN_Pool *pool, DN_USize make_count, DN_ZMem z_mem);
DN_API void* DN_ArrayAddArray (void *data, DN_USize *count, DN_USize max, DN_USize elem_size, void const *elems, DN_USize elems_count, DN_ArrayAdd add);
DN_API void* DN_ArrayAddArrayAssert (void *data, DN_USize *count, DN_USize max, DN_USize elem_size, void const *elems, DN_USize elems_count, DN_ArrayAdd add, DN_CallSite call_site);
DN_API bool DN_ArrayResizeFromPool (void **data, DN_USize *count, DN_USize *max, DN_USize elem_size, DN_Pool *pool, DN_USize new_max);
DN_API bool DN_ArrayResizeFromArena (void **data, DN_USize *count, DN_USize *max, DN_USize elem_size, DN_Arena *arena, DN_USize new_max);
DN_API bool DN_ArrayGrowFromPool (void **data, DN_USize *max, DN_USize elem_size, DN_Pool *pool, DN_USize new_max);
DN_API bool DN_ArrayGrowFromArena (void **data, DN_USize *max, DN_USize elem_size, DN_Arena *arena, DN_USize new_max);
DN_API bool DN_ArrayGrowIfNeededFromPool (void **data, DN_USize count, DN_USize *max, DN_USize elem_size, DN_Pool *pool, DN_USize add_count);
DN_API bool DN_ArrayGrowIfNeededFromArena (void **data, DN_USize count, DN_USize *max, DN_USize elem_size, DN_Arena *arena, DN_USize add_count);
DN_API void* DN_ArrayAddArrayArena (void **data, DN_USize *count, DN_USize *max, DN_USize elem_size, void const *elems, DN_USize elems_count, DN_Arena *arena, DN_ArrayAdd add);
DN_API void* DN_ArrayAddArrayPool (void **data, DN_USize *count, DN_USize *max, DN_USize elem_size, void const *elems, DN_USize elems_count, DN_Pool *pool, DN_ArrayAdd add);
DN_API bool DN_ArrayResizePool (void **data, DN_USize *count, DN_USize *max, DN_USize elem_size, DN_Pool *pool, DN_USize new_max);
DN_API bool DN_ArrayResizeArena (void **data, DN_USize *count, DN_USize *max, DN_USize elem_size, DN_Arena *arena, DN_USize new_max);
DN_API bool DN_ArrayReservePool (void **data, DN_USize *max, DN_USize elem_size, DN_Pool *pool, DN_USize new_max);
DN_API bool DN_ArrayReserveArena (void **data, DN_USize *max, DN_USize elem_size, DN_Arena *arena, DN_USize new_max);
DN_API bool DN_ArrayPreparePool (void **data, DN_USize count, DN_USize *max, DN_USize elem_size, DN_Pool *pool, DN_USize add_count);
DN_API bool DN_ArrayPrepareArena (void **data, DN_USize count, DN_USize *max, DN_USize elem_size, DN_Arena *arena, DN_USize add_count);
DN_API DN_USize DN_ArrayCopyPtrArena (void **data, void const *src, DN_USize count, DN_USize elem_size, DN_Arena *arena);
DN_API DN_USize DN_ArrayCopyPtrArenaAssert (void **data, void const *src, DN_USize count, DN_USize elem_size, DN_Arena *arena, DN_CallSite call_site);
DN_API DN_USize DN_ArrayCopyPtrPool (void **data, void const *src, DN_USize count, DN_USize elem_size, DN_Pool *pool);
@@ -6042,12 +6117,28 @@ template <typename T> T* DN_TArrayMakeArrayAssertZ (T *dat
template <typename T> T* DN_TArrayMakeArrayAssertNoZ (T *data, DN_USize *count, DN_USize max, DN_USize make_count, DN_CallSite call_site);
template <typename T> T* DN_TArrayAddArray (T *data, DN_USize *count, DN_USize max, T const *elems, DN_USize elems_count, DN_ArrayAdd add);
template <typename T> T* DN_TArrayAddArrayAssert (T *data, DN_USize *count, DN_USize max, T const *elems, DN_USize elems_count, DN_ArrayAdd add, DN_CallSite call_site);
template <typename T> bool DN_TArrayResizeFromPool (T **data, DN_USize *count, DN_USize *max, DN_Pool *pool, DN_USize new_max);
template <typename T> bool DN_TArrayResizeFromArena (T **data, DN_USize *count, DN_USize *max, DN_Arena *arena, DN_USize new_max);
template <typename T> bool DN_TArrayGrowFromPool (T **data, DN_USize *max, DN_Pool *pool, DN_USize new_max);
template <typename T> bool DN_TArrayGrowFromArena (T **data, DN_USize *max, DN_Pool *pool, DN_USize new_max);
template <typename T> bool DN_TArrayGrowIfNeededFromPool (T **data, DN_USize count, DN_USize *max, DN_Pool *pool, DN_USize add_count);
template <typename T> bool DN_TArrayGrowIfNeededFromArena (T **data, DN_USize count, DN_USize *max, DN_Arena *pool, DN_USize add_count);
template <typename T> T* DN_TArrayMakeArrayArena (T **data, DN_USize *count, DN_USize *max, DN_Arena *arena, DN_USize make_count, DN_ZMem z_mem);
template <typename T> T* DN_TArrayMakeArrayArenaZ (T **data, DN_USize *count, DN_USize *max, DN_Arena *arena, DN_USize make_count);
template <typename T> T* DN_TArrayMakeArrayArenaNoZ (T **data, DN_USize *count, DN_USize *max, DN_Arena *arena, DN_USize make_count);
template <typename T> T* DN_TArrayMakeArrayPool (T **data, DN_USize *count, DN_USize *max, DN_Pool *pool, DN_USize make_count, DN_ZMem z_mem);
template <typename T> T* DN_TArrayMakeArrayPoolZ (T **data, DN_USize *count, DN_USize *max, DN_Pool *pool, DN_USize make_count);
template <typename T> T* DN_TArrayMakeArrayPoolNoZ (T **data, DN_USize *count, DN_USize *max, DN_Pool *pool, DN_USize make_count);
template <typename T> T* DN_TArrayAddArrayArena (T **data, DN_USize *count, DN_USize *max, DN_Arena *arena, T const *elems, DN_USize elems_count, DN_ArrayAdd add);
template <typename T> T* DN_TArrayAddArrayPool (T **data, DN_USize *count, DN_USize *max, DN_Pool *pool, T const *elems, DN_USize elems_count, DN_ArrayAdd add);
template <typename T> T* DN_TArrayMakeArena (T **data, DN_USize *count, DN_USize *max, DN_Arena *arena, DN_ZMem z_mem);
template <typename T> T* DN_TArrayMakeArenaZ (T **data, DN_USize *count, DN_USize *max, DN_Arena *arena);
template <typename T> T* DN_TArrayMakeArenaNoZ (T **data, DN_USize *count, DN_USize *max, DN_Arena *arena);
template <typename T> T* DN_TArrayMakePool (T **data, DN_USize *count, DN_USize *max, DN_Pool *pool, DN_ZMem z_mem);
template <typename T> T* DN_TArrayMakePoolZ (T **data, DN_USize *count, DN_USize *max, DN_Pool *pool);
template <typename T> T* DN_TArrayMakePoolNoZ (T **data, DN_USize *count, DN_USize *max, DN_Pool *pool);
template <typename T> T* DN_TArrayAddArena (T **data, DN_USize *count, DN_USize *max, DN_Arena *arena, T const *elems, DN_USize elems_count, DN_ArrayAdd add);
template <typename T> T* DN_TArrayAddPool (T **data, DN_USize *count, DN_USize *max, DN_Pool *pool, T const *elems, DN_USize elems_count, DN_ArrayAdd add);
template <typename T> bool DN_TArrayResizePool (T **data, DN_USize *count, DN_USize *max, DN_Pool *pool, DN_USize new_max);
template <typename T> bool DN_TArrayResizeArena (T **data, DN_USize *count, DN_USize *max, DN_Arena *arena, DN_USize new_max);
template <typename T> bool DN_TArrayReservePool (T **data, DN_USize *max, DN_Pool *pool, DN_USize new_max);
template <typename T> bool DN_TArrayReserveArena (T **data, DN_USize *max, DN_Pool *pool, DN_USize new_max);
template <typename T> bool DN_TArrayPreparePool (T **data, DN_USize count, DN_USize *max, DN_Pool *pool, DN_USize add_count);
template <typename T> bool DN_TArrayPrepareArena (T **data, DN_USize count, DN_USize *max, DN_Arena *pool, DN_USize add_count);
template <typename T> DN_USize DN_TArrayCopyPtrArena (T **data, T const *src, DN_USize count, DN_Arena *arena);
template <typename T> DN_USize DN_TArrayCopyPtrArenaAssert (T **data, T const *src, DN_USize count, DN_Arena *arena, DN_CallSite call_site);
template <typename T> DN_USize DN_TArrayCopyPtrPool (T **data, T const *src, DN_USize count, DN_Pool *pool);
@@ -6138,54 +6229,61 @@ DN_API void DN_RingRead
DN_HTableAdd(&table, &key, &value);
}
*/
DN_API DN_U32 DN_HTableHashFuncDefault (void const* key, DN_USize size);
DN_API bool DN_HTableKeyEqFuncMemcmp (void const* lhs, void const* rhs, DN_USize size);
DN_API bool DN_HTableKeyEqFuncStr8Eq (void const* lhs, void const* rhs, DN_USize size);
DN_API DN_U32 DN_HTableHashFuncMurmur3KeyBytes(void const* key, DN_USize size);
DN_API DN_U32 DN_HTableHashFuncMurmur3KeyStr8 (void const* key, DN_USize size);
DN_API bool DN_HTableKeyEqFuncMemcmp (void const* lhs, void const* rhs, DN_USize size);
DN_API bool DN_HTableKeyEqFuncStr8Eq (void const* lhs, void const* rhs, DN_USize size);
#define DN_HTableInitArgsDefault(KeyValueT, kvs_ptr, HashField, KeyField, ValueField) DN_HTableInitArgsDefault_(DN_Cast(void **)&kvs_ptr, sizeof(*kvs_ptr), offsetof(KeyValueT, HashField), sizeof(kvs_ptr->KeyField), offsetof(KeyValueT, KeyField), sizeof(kvs_ptr->ValueField), offsetof(KeyValueT, ValueField))
DN_API DN_HTableInitArgs DN_HTableInitArgsDefault_(void** kvs, DN_USize size_of_kvs, DN_USize offset_of_hash, DN_USize size_of_key, DN_USize offset_of_key, DN_USize size_of_value, DN_USize offset_of_value);
DN_API DN_HTableInitResult DN_HTableInitHeap (DN_HTableInitArgs args, DN_Heap heap);
DN_API DN_HTable DN_HTableInitHeapAssert (DN_HTableInitArgs args, DN_Heap heap);
DN_API DN_HTableInitResult DN_HTableInitPool (DN_HTableInitArgs args, DN_Pool pool, DN_HTableDeallocPoolOnDeinit dealloc_pool);
DN_API DN_HTable DN_HTableInitPoolAssert (DN_HTableInitArgs args, DN_Pool pool, DN_HTableDeallocPoolOnDeinit dealloc_pool);
DN_API void DN_HTableDeinit (DN_HTable* table);
#define DN_HTableInitArgsDefault(KeyValueT, kvs_ptr, HashField, KeyField, ValueField) DN_HTableInitArgsDefault_(DN_Cast(void **)&kvs_ptr, sizeof(*kvs_ptr), offsetof(KeyValueT, HashField), sizeof(kvs_ptr->KeyField), offsetof(KeyValueT, KeyField), sizeof(kvs_ptr->ValueField), offsetof(KeyValueT, ValueField))
DN_API DN_HTableInitArgs DN_HTableInitArgsDefault_ (void** kvs, DN_USize size_of_kvs, DN_USize offset_of_hash, DN_USize size_of_key, DN_USize offset_of_key, DN_USize size_of_value, DN_USize offset_of_value);
DN_API DN_HTableInitResult DN_HTableInitHeap (DN_HTableInitArgs args, DN_Heap heap);
DN_API DN_HTable DN_HTableInitHeapAssert (DN_HTableInitArgs args, DN_Heap heap);
DN_API DN_HTableInitResult DN_HTableInitPool (DN_HTableInitArgs args, DN_Pool pool, DN_HTableDeallocPoolOnDeinit dealloc_pool);
DN_API DN_HTable DN_HTableInitPoolAssert (DN_HTableInitArgs args, DN_Pool pool, DN_HTableDeallocPoolOnDeinit dealloc_pool);
DN_API void DN_HTableDeinit (DN_HTable* table);
DN_API DN_HTableLookupResult DN_HTableLookup (DN_HTable const* table, void const* key, DN_HTableAllowTombstone allow_tombstone);
DN_API DN_HTableSlot DN_HTableFind (DN_HTable const* table, void const* key);
DN_API void* DN_HTableValueFromFind (DN_HTable const* table, void const* key);
DN_API DN_HTableSlot DN_HTableSlotFromIndex (DN_HTable const* table, DN_USize index);
DN_API DN_HTableLookupResult DN_HTableLookup (DN_HTable const* table, void const* key, DN_HTableAllowTombstone allow_tombstone);
DN_API DN_HTableSlot DN_HTableFind (DN_HTable const* table, void const* key);
DN_API void* DN_HTableValueFromFind (DN_HTable const* table, void const* key);
DN_API DN_HTableSlot DN_HTableSlotFromIndex (DN_HTable const* table, DN_USize index);
#define DN_HTableSlotIsValue(slot) ((slot).hash_u32 >= DN_HTableHashSentinel_FirstValid)
#define DN_HTableSlotIsEmpty(slot) ((slot).hash_u32 == DN_HTableHashSentinel_Empty)
#define DN_HTableSlotIsTomb(slot) ((slot).hash_u32 == DN_HTableHashSentinel_Tomb)
#define DN_HTableHashIsValue(hash_u32) ((hash_u32) >= DN_HTableHashSentinel_FirstValid)
#define DN_HTableHashIsEmpty(hash_u32) ((hash_u32) == DN_HTableHashSentinel_Empty)
#define DN_HTableHashIsTomb(hash_u32) ((hash_u32) == DN_HTableHashSentinel_Tomb)
DN_API bool DN_HTableResize (DN_HTable* table, DN_USize new_max);
DN_API void DN_HTableClear (DN_HTable* table);
DN_API DN_HTableResizeResult DN_HTableGrowMaybe (DN_HTable* table, DN_USize add_count);
DN_API DN_HTableAddResult DN_HTableMake (DN_HTable* table, void* key);
DN_API DN_HTableAddResult DN_HTableAdd (DN_HTable* table, void* key, void* value);
DN_API bool DN_HTableDel (DN_HTable* table, void* key);
DN_API bool DN_HTableResize (DN_HTable* table, DN_USize new_max);
DN_API DN_HTablePrepareResult DN_HTablePrepare (DN_HTable* table, DN_USize add_count);
DN_API void DN_HTableClear (DN_HTable* table);
DN_API DN_HTableAddResult DN_HTableMake (DN_HTable* table, void* key);
DN_API DN_HTableAddResult DN_HTableAdd (DN_HTable* table, void* key, void* value);
DN_API bool DN_HTableDel (DN_HTable* table, void* key);
// NOTE: Binary Packer
DN_API bool DN_BinPackIsEndOfReadStream(DN_BinPack const *pack);
DN_API void DN_BinPackUSize (DN_BinPack *pack, DN_BinPackMode mode, DN_USize *item);
DN_API void DN_BinPackU64 (DN_BinPack *pack, DN_BinPackMode mode, DN_U64 *item);
DN_API void DN_BinPackU32 (DN_BinPack *pack, DN_BinPackMode mode, DN_U32 *item);
DN_API void DN_BinPackU16 (DN_BinPack *pack, DN_BinPackMode mode, DN_U16 *item);
DN_API void DN_BinPackU8 (DN_BinPack *pack, DN_BinPackMode mode, DN_U8 *item);
DN_API void DN_BinPackI64 (DN_BinPack *pack, DN_BinPackMode mode, DN_I64 *item);
DN_API void DN_BinPackI32 (DN_BinPack *pack, DN_BinPackMode mode, DN_I32 *item);
DN_API void DN_BinPackI16 (DN_BinPack *pack, DN_BinPackMode mode, DN_I16 *item);
DN_API void DN_BinPackI8 (DN_BinPack *pack, DN_BinPackMode mode, DN_I8 *item);
DN_API void DN_BinPackF64 (DN_BinPack *pack, DN_BinPackMode mode, DN_F64 *item);
DN_API void DN_BinPackF32 (DN_BinPack *pack, DN_BinPackMode mode, DN_F32 *item);
DN_API void DN_BinPackV2 (DN_BinPack *pack, DN_BinPackMode mode, DN_V2F32 *item);
DN_API void DN_BinPackV4 (DN_BinPack *pack, DN_BinPackMode mode, DN_V4F32 *item);
DN_API void DN_BinPackBool (DN_BinPack *pack, DN_BinPackMode mode, bool *item);
DN_API void DN_BinPackStr8FromArena (DN_BinPack *pack, DN_Arena *arena, DN_BinPackMode mode, DN_Str8 *string);
DN_API void DN_BinPackStr8FromPool (DN_BinPack *pack, DN_Pool *pool, DN_BinPackMode mode, DN_Str8 *string);
DN_API DN_Str8 DN_BinPackStr8FromBuffer (DN_BinPack *pack, DN_BinPackMode mode, char *ptr, DN_USize *size, DN_USize max);
DN_API void DN_BinPackBytesFromArena (DN_BinPack *pack, DN_Arena *arena, DN_BinPackMode mode, void **ptr, DN_USize *size);
DN_API void DN_BinPackBytesFromPool (DN_BinPack *pack, DN_Pool *pool, DN_BinPackMode mode, void **ptr, DN_USize *size);
DN_API void DN_BinPackCArray (DN_BinPack *pack, DN_BinPackMode mode, void *ptr, DN_USize size);
DN_API void DN_BinPackCBuffer (DN_BinPack *pack, DN_BinPackMode mode, char *ptr, DN_USize *size, DN_USize max);
DN_API DN_Str8 DN_BinPackBuild (DN_BinPack const *pack, DN_Arena *arena);
DN_API bool DN_BinPackIsEndOfReadStream(DN_BinPack const *pack);
DN_API void DN_BinPackUSize (DN_BinPack *pack, DN_BinPackMode mode, DN_USize *item);
DN_API void DN_BinPackU64 (DN_BinPack *pack, DN_BinPackMode mode, DN_U64 *item);
DN_API void DN_BinPackU32 (DN_BinPack *pack, DN_BinPackMode mode, DN_U32 *item);
DN_API void DN_BinPackU16 (DN_BinPack *pack, DN_BinPackMode mode, DN_U16 *item);
DN_API void DN_BinPackU8 (DN_BinPack *pack, DN_BinPackMode mode, DN_U8 *item);
DN_API void DN_BinPackI64 (DN_BinPack *pack, DN_BinPackMode mode, DN_I64 *item);
DN_API void DN_BinPackI32 (DN_BinPack *pack, DN_BinPackMode mode, DN_I32 *item);
DN_API void DN_BinPackI16 (DN_BinPack *pack, DN_BinPackMode mode, DN_I16 *item);
DN_API void DN_BinPackI8 (DN_BinPack *pack, DN_BinPackMode mode, DN_I8 *item);
DN_API void DN_BinPackF64 (DN_BinPack *pack, DN_BinPackMode mode, DN_F64 *item);
DN_API void DN_BinPackF32 (DN_BinPack *pack, DN_BinPackMode mode, DN_F32 *item);
DN_API void DN_BinPackV2 (DN_BinPack *pack, DN_BinPackMode mode, DN_V2F32 *item);
DN_API void DN_BinPackV4 (DN_BinPack *pack, DN_BinPackMode mode, DN_V4F32 *item);
DN_API void DN_BinPackBool (DN_BinPack *pack, DN_BinPackMode mode, bool *item);
DN_API void DN_BinPackStr8FromArena (DN_BinPack *pack, DN_Arena *arena, DN_BinPackMode mode, DN_Str8 *string);
DN_API void DN_BinPackStr8FromPool (DN_BinPack *pack, DN_Pool *pool, DN_BinPackMode mode, DN_Str8 *string);
DN_API DN_Str8 DN_BinPackStr8FromBuffer (DN_BinPack *pack, DN_BinPackMode mode, char *ptr, DN_USize *size, DN_USize max);
DN_API void DN_BinPackBytesFromArena (DN_BinPack *pack, DN_Arena *arena, DN_BinPackMode mode, void **ptr, DN_USize *size);
DN_API void DN_BinPackBytesFromPool (DN_BinPack *pack, DN_Pool *pool, DN_BinPackMode mode, void **ptr, DN_USize *size);
DN_API void DN_BinPackCArray (DN_BinPack *pack, DN_BinPackMode mode, void *ptr, DN_USize size);
DN_API void DN_BinPackCBuffer (DN_BinPack *pack, DN_BinPackMode mode, char *ptr, DN_USize *size, DN_USize max);
DN_API DN_Str8 DN_BinPackBuild (DN_BinPack const *pack, DN_Arena *arena);
// NOTE: CSV Tokeniser/Packer
// Overview
@@ -6786,44 +6884,156 @@ T *DN_TArrayAddArrayAssert(T *data, DN_USize *count, DN_USize max, T const *elem
}
template <typename T>
bool DN_TArrayResizeFromPool(T **data, DN_USize *count, DN_USize *max, DN_Pool *pool, DN_USize new_max)
T *DN_TArrayMakeArrayArena(T **data, DN_USize *count, DN_USize *max, DN_Arena *arena, DN_USize make_count, DN_ZMem z_mem)
{
bool result = DN_ArrayResizeFromPool(DN_Cast(void **)data, count, max, sizeof(**data), pool, new_max);
T *result = DN_Cast(T *)DN_ArrayMakeArrayArena(DN_Cast(void **)data, count, max, sizeof(**data), arena, make_count, z_mem);
return result;
}
template <typename T>
bool DN_TArrayResizeFromArena(T **data, DN_USize *count, DN_USize *max, DN_Arena *arena, DN_USize new_max)
T *DN_TArrayMakeArrayArenaZ(T **data, DN_USize *count, DN_USize *max, DN_Arena *arena, DN_USize make_count)
{
bool result = DN_ArrayResizeFromArena(DN_Cast(void **)data, count, max, sizeof(**data), arena, new_max);
T *result = DN_TArrayMakeArrayArena(data, count, max, arena, make_count, DN_ZMem_Yes);
return result;
}
template <typename T>
bool DN_TArrayGrowFromPool(T **data, DN_USize *max, DN_Pool *pool, DN_USize new_max)
T *DN_TArrayMakeArrayArenaNoZ(T **data, DN_USize *count, DN_USize *max, DN_Arena *arena, DN_USize make_count)
{
bool result = DN_ArrayGrowFromPool(DN_Cast(void **)data, max, sizeof(**data), pool, new_max);
T *result = DN_TArrayMakeArrayArena(data, count, max, arena, make_count, DN_ZMem_No);
return result;
}
template <typename T>
bool DN_TArrayGrowFromArena(T **data, DN_USize *max, DN_Arena *arena, DN_USize new_max)
T *DN_TArrayMakeArrayPool(T **data, DN_USize *count, DN_USize *max, DN_Pool *pool, DN_USize make_count, DN_ZMem z_mem)
{
bool result = DN_ArrayGrowFromArena(DN_Cast(void **)data, max, sizeof(**data), arena, new_max);
T *result = DN_Cast(T *)DN_ArrayMakeArrayPool(DN_Cast(void **)data, count, max, sizeof(**data), pool, make_count, z_mem);
return result;
}
template <typename T>
bool DN_TArrayGrowIfNeededFromPool(T **data, DN_USize count, DN_USize *max, DN_Pool *pool, DN_USize add_count)
T *DN_TArrayMakeArrayPoolZ(T **data, DN_USize *count, DN_USize *max, DN_Pool *pool, DN_USize make_count)
{
bool result = DN_ArrayGrowIfNeededFromPool(DN_Cast(void **)data, count, max, sizeof(**data), pool, add_count);
T *result = DN_TArrayMakeArrayPool(data, count, max, pool, make_count, DN_ZMem_Yes);
return result;
}
template <typename T>
bool DN_TArrayGrowIfNeededFromArena(T **data, DN_USize count, DN_USize *max, DN_Arena *arena, DN_USize add_count)
T *DN_TArrayMakeArrayPoolNoZ(T **data, DN_USize *count, DN_USize *max, DN_Pool *pool, DN_USize make_count)
{
bool result = DN_ArrayGrowIfNeededFromArena(DN_Cast(void **)data, count, max, sizeof(**data), arena, add_count);
T *result = DN_TArrayMakeArrayPool(data, count, max, pool, make_count, DN_ZMem_No);
return result;
}
template <typename T>
T *DN_TArrayAddArrayArena(T **data, DN_USize *count, DN_USize *max, DN_Arena *arena, T const *elems, DN_USize elems_count, DN_ArrayAdd add)
{
T *result = DN_Cast(T *)DN_ArrayAddArrayArena(DN_Cast(void **)data, count, max, sizeof(**data), arena, elems, elems_count, add);
return result;
}
template <typename T>
T *DN_TArrayAddArrayPool(T **data, DN_USize *count, DN_USize *max, DN_Pool *pool, T const *elems, DN_USize elems_count, DN_ArrayAdd add)
{
T *result = DN_Cast(T *)DN_ArrayAddArrayPool(DN_Cast(void **)data, count, max, sizeof(**data), pool, elems, elems_count, add);
return result;
}
template <typename T>
T *DN_TArrayMakeArena(T **data, DN_USize *count, DN_USize *max, DN_Arena *arena, DN_ZMem z_mem)
{
T *result = DN_TArrayMakeArrayArena(data, count, max, arena, 1, z_mem);
return result;
}
template <typename T>
T *DN_TArrayMakeArenaZ(T **data, DN_USize *count, DN_USize *max, DN_Arena *arena)
{
T *result = DN_TArrayMakeArrayArena(data, count, max, arena, 1, DN_ZMem_Yes);
return result;
}
template <typename T>
T *DN_TArrayMakeArenaNoZ(T **data, DN_USize *count, DN_USize *max, DN_Arena *arena)
{
T *result = DN_TArrayMakeArrayArena(data, count, max, arena, 1, DN_ZMem_No);
return result;
}
template <typename T>
T *DN_TArrayMakePool(T **data, DN_USize *count, DN_USize *max, DN_Pool *pool, DN_ZMem z_mem)
{
T *result = DN_TArrayMakeArrayPool(data, count, max, pool, 1, z_mem);
return result;
}
template <typename T>
T *DN_TArrayMakePoolZ(T **data, DN_USize *count, DN_USize *max, DN_Pool *pool)
{
T *result = DN_TArrayMakeArrayPool(data, count, max, pool, 1, DN_ZMem_Yes);
return result;
}
template <typename T>
T *DN_TArrayMakePoolNoZ(T **data, DN_USize *count, DN_USize *max, DN_Pool *pool)
{
T *result = DN_TArrayMakeArrayPool(data, count, max, pool, 1, DN_ZMem_No);
return result;
}
template <typename T>
T *DN_TArrayAddArena(T **data, DN_USize *count, DN_USize *max, DN_Arena *arena, T const *elems, DN_USize elems_count, DN_ArrayAdd add)
{
T *result = DN_TArrayAddArrayArena(data, count, max, arena, elems, elems_count, add);
return result;
}
template <typename T>
T *DN_TArrayAddPool(T **data, DN_USize *count, DN_USize *max, DN_Pool *pool, T const *elems, DN_USize elems_count, DN_ArrayAdd add)
{
T *result = DN_TArrayAddArrayPool(data, count, max, pool, elems, elems_count, add);
return result;
}
template <typename T>
bool DN_TArrayResizePool(T **data, DN_USize *count, DN_USize *max, DN_Pool *pool, DN_USize new_max)
{
bool result = DN_ArrayResizePool(DN_Cast(void **)data, count, max, sizeof(**data), pool, new_max);
return result;
}
template <typename T>
bool DN_TArrayResizeArena(T **data, DN_USize *count, DN_USize *max, DN_Arena *arena, DN_USize new_max)
{
bool result = DN_ArrayResizeArena(DN_Cast(void **)data, count, max, sizeof(**data), arena, new_max);
return result;
}
template <typename T>
bool DN_TArrayReservePool(T **data, DN_USize *max, DN_Pool *pool, DN_USize new_max)
{
bool result = DN_ArrayReservePool(DN_Cast(void **)data, max, sizeof(**data), pool, new_max);
return result;
}
template <typename T>
bool DN_TArrayReserveArena(T **data, DN_USize *max, DN_Arena *arena, DN_USize new_max)
{
bool result = DN_ArrayReserveArena(DN_Cast(void **)data, max, sizeof(**data), arena, new_max);
return result;
}
template <typename T>
bool DN_TArrayPreparePool(T **data, DN_USize count, DN_USize *max, DN_Pool *pool, DN_USize add_count)
{
bool result = DN_ArrayPreparePool(DN_Cast(void **)data, count, max, sizeof(**data), pool, add_count);
return result;
}
template <typename T>
bool DN_TArrayPrepareArena(T **data, DN_USize count, DN_USize *max, DN_Arena *arena, DN_USize add_count)
{
bool result = DN_ArrayPrepareArena(DN_Cast(void **)data, count, max, sizeof(**data), arena, add_count);
return result;
}