diff --git a/Code/Dqn.h b/Code/Dqn.h index 85ba963..268f9b9 100644 --- a/Code/Dqn.h +++ b/Code/Dqn.h @@ -206,9 +206,9 @@ STBSP__PUBLICDEF void STB_SPRINTF_DECORATE(set_separators)(char comma, char peri b = tmp; \ } while (0) -#define DQN_LEN_AND_STR(string) CharCount(str), string -#define DQN_STR_AND_LEN(string) string, CharCount(string) -#define DQN_STR_AND_LEN_I(string) string, (int)CharCount(string) +#define DQN_LEN_AND_STR(string) Dqn_CharCount(str), string +#define DQN_STR_AND_LEN(string) string, Dqn_CharCount(string) +#define DQN_STR_AND_LEN_I(string) string, (int)Dqn_CharCount(string) #define DQN_FOR_EACH(i, limit) for (isize (i) = 0; (i) < (isize)(limit); ++(i)) #define DQN_FOR_EACH_REVERSE(i, limit) for (isize (i) = (isize)(limit-1); (i) >= 0; --(i)) @@ -263,10 +263,10 @@ const f32 F32_MAX = FLT_MAX; const isize ISIZE_MAX = PTRDIFF_MAX; const usize USIZE_MAX = SIZE_MAX; -template constexpr usize ArrayCount (T const (&)[N]) { return N; } -template constexpr isize ArrayCountI(T const (&)[N]) { return N; } -template constexpr usize CharCount (char const (&)[N]) { return N - 1; } -template constexpr isize CharCountI (char const (&)[N]) { return N - 1; } +template constexpr usize Dqn_ArrayCount (T const (&)[N]) { return N; } +template constexpr isize Dqn_ArrayCountI(T const (&)[N]) { return N; } +template constexpr usize Dqn_CharCount (char const (&)[N]) { return N - 1; } +template constexpr isize Dqn_CharCountI (char const (&)[N]) { return N - 1; } template struct DqnDefer @@ -502,7 +502,7 @@ T *Dqn_MemZero(T *src) // ------------------------------------------------------------------------------------------------- // -// NOTE: MemArena +// NOTE: Dqn_MemArena // // ------------------------------------------------------------------------------------------------- using MemSize = usize; @@ -517,20 +517,20 @@ struct MemBlock MemBlock *next; }; -enum MemArenaFlag +enum Dqn_MemArenaFlag { - MemArenaFlag_NoCRTAllocation = (1 << 0), // If my_calloc/my_free aren't null, it defaults to calloc and free, setting this flag disables that + Dqn_MemArenaFlag_NoCRTAllocation = (1 << 0), // If my_calloc/my_free aren't null, it defaults to calloc and free, setting this flag disables that }; // TODO(doyle): We should try support function pointer syntax (maybe) for inspection -typedef void *(MemArenaCallocFunction)(size_t bytes); -typedef void (MemArenaFreeFunction) (void *ptr, size_t bytes_to_free); -struct MemArena +typedef void *(Dqn_MemArenaCallocFunction)(size_t bytes); +typedef void (Dqn_MemArenaFreeFunction) (void *ptr, size_t bytes_to_free); +struct Dqn_MemArena { // NOTE: Configuration (fill once) - MemArenaCallocFunction *my_calloc; // If nullptr, use CRT calloc unless disabled in flags - MemArenaFreeFunction *my_free; // If nullptr, use CRT free unless disabled in flags - u32 flags; + Dqn_MemArenaCallocFunction *my_calloc; // If nullptr, use CRT calloc unless disabled in flags + Dqn_MemArenaFreeFunction *my_free; // If nullptr, use CRT free unless disabled in flags + u32 flags; // NOTE: Read Only u8 fixed_mem[DQN_KILOBYTES(16)]; @@ -541,11 +541,11 @@ struct MemArena int total_allocated_mem_blocks; }; -struct MemArenaScopedRegion +struct Dqn_MemArenaScopedRegion { - MemArenaScopedRegion(MemArena *arena); - ~MemArenaScopedRegion(); - MemArena *arena; + Dqn_MemArenaScopedRegion(Dqn_MemArena *arena); + ~Dqn_MemArenaScopedRegion(); + Dqn_MemArena *arena; MemBlock *curr_mem_block; usize curr_mem_block_used; MemBlock *top_mem_block; @@ -560,13 +560,13 @@ struct MemArenaScopedRegion #define DQN_DEBUG_PARAMS #endif -#define MEM_ARENA_ALLOC(arena, size) MemArena_Alloc(arena, size DQN_DEBUG_PARAMS); -#define MEM_ARENA_ALLOC_ARRAY(arena, T, num) (T *)MemArena_Alloc(arena, sizeof(T) * num DQN_DEBUG_PARAMS); -#define MEM_ARENA_ALLOC_STRUCT(arena, T) (T *)MemArena_Alloc(arena, sizeof(T) DQN_DEBUG_PARAMS); -#define MEM_ARENA_RESERVE(arena, size) MemArena_Reserve(arena, size DQN_DEBUG_PARAMS); -#define MEM_ARENA_RESERVE_FROM(arena, src, size) MemArena_ReserveFrom(arena, src, size DQN_DEBUG_PARAMS); -#define MEM_ARENA_CLEAR_USED(arena) MemArena_ClearUsed(arena DQN_DEBUG_PARAMS); -#define MEM_ARENA_FREE(arena) MemArena_Free +#define MEM_ARENA_ALLOC(arena, size) Dqn_MemArena_Alloc(arena, size DQN_DEBUG_PARAMS); +#define MEM_ARENA_ALLOC_ARRAY(arena, T, num) (T *)Dqn_MemArena_Alloc(arena, sizeof(T) * num DQN_DEBUG_PARAMS); +#define MEM_ARENA_ALLOC_STRUCT(arena, T) (T *)Dqn_MemArena_Alloc(arena, sizeof(T) DQN_DEBUG_PARAMS); +#define MEM_ARENA_RESERVE(arena, size) Dqn_MemArena_Reserve(arena, size DQN_DEBUG_PARAMS); +#define MEM_ARENA_RESERVE_FROM(arena, src, size) Dqn_MemArena_ReserveFrom(arena, src, size DQN_DEBUG_PARAMS); +#define MEM_ARENA_CLEAR_USED(arena) Dqn_MemArena_ClearUsed(arena DQN_DEBUG_PARAMS); +#define MEM_ARENA_FREE(arena) Dqn_MemArena_Free // ------------------------------------------------------------------------------------------------- // @@ -621,7 +621,7 @@ struct Slice #define SLICE_LITERAL(string) Slice(DQN_STR_AND_LEN(string)) template -inline Slice Slice_CopyNullTerminated(MemArena *arena, T const *src, isize len) +inline Slice Slice_CopyNullTerminated(Dqn_MemArena *arena, T const *src, isize len) { Slice result = {}; result.len = len; @@ -632,14 +632,14 @@ inline Slice Slice_CopyNullTerminated(MemArena *arena, T const *src, isize le } template -inline Slice Slice_CopyNullTerminated(MemArena *arena, Slice const src) +inline Slice Slice_CopyNullTerminated(Dqn_MemArena *arena, Slice const src) { Slice result = Slice_CopyNullTerminated(arena, src.buf, src.len); return result; } template -inline Slice Slice_Copy(MemArena *arena, T const *src, isize len) +inline Slice Slice_Copy(Dqn_MemArena *arena, T const *src, isize len) { Slice result = {}; result.len = len; @@ -649,7 +649,7 @@ inline Slice Slice_Copy(MemArena *arena, T const *src, isize len) } template -inline Slice Slice_Copy(MemArena *arena, Slice const src) +inline Slice Slice_Copy(Dqn_MemArena *arena, Slice const src) { Slice result = Slice_Copy(arena, src.buf, src.len); return result; @@ -765,21 +765,21 @@ FIXED_ARRAY_TEMPLATE_DECL T *Dqn_FixedArray_Find(Dqn_FixedArray *a, T * // ------------------------------------------------------------------------------------------------- // -// NOTE: FixedStack +// NOTE: Dqn_FixedStack // // ------------------------------------------------------------------------------------------------- -template using FixedStack = Dqn_FixedArray; -template T FixedStack_Pop (FixedStack *array) { T result = *Dqn_FixedArray_Peek(array); Dqn_FixedArray_Pop(array, 1); return result; } -template T *FixedStack_Peek (FixedStack *array) { return Dqn_FixedArray_Peek(array); } -template T *FixedStack_Push (FixedStack *array, T item) { return Dqn_FixedArray_Add(array, item); } -template void FixedStack_Clear(FixedStack *array) { Dqn_FixedArray_Clear(array); } +template using Dqn_FixedStack = Dqn_FixedArray; +template T Dqn_FixedStack_Pop (Dqn_FixedStack *array) { T result = *Dqn_FixedArray_Peek(array); Dqn_FixedArray_Pop(array, 1); return result; } +template T *Dqn_FixedStack_Peek (Dqn_FixedStack *array) { return Dqn_FixedArray_Peek(array); } +template T *Dqn_FixedStack_Push (Dqn_FixedStack *array, T item) { return Dqn_FixedArray_Add(array, item); } +template void Dqn_FixedStack_Clear(Dqn_FixedStack *array) { Dqn_FixedArray_Clear(array); } // ------------------------------------------------------------------------------------------------- // -// NOTE: StaticArray +// NOTE: Dqn_StaticArray // // ------------------------------------------------------------------------------------------------- -template struct StaticArray +template struct Dqn_StaticArray { T *data; isize len; @@ -793,30 +793,30 @@ template struct StaticArray T const *operator+(isize i) const { DQN_ASSERT_MSG(i >= 0 && i < len, "%d >= 0 && %d < %d", i, len); return data + i; } T *operator+(isize i) { DQN_ASSERT_MSG(i >= 0 && i < len, "%d >= 0 && %d < %d", i, len); return data + i; } }; -template StaticArray StaticArray_InitMemory (T *memory, isize max, isize len = 0) { StaticArray result = {}; result.data = memory; result.len = len; result.max = max; return result; } -template T *StaticArray_Add (StaticArray *a, T const *items, isize num) { DQN_ASSERT(a->len + num <= a->max); T *result = static_cast(Dqn_MemCopy(a->data + a->len, items, sizeof(T) * num)); a->len += num; return result; } -template T *StaticArray_Add (StaticArray *a, T const item) { DQN_ASSERT(a->len < a->max); a->data[a->len++] = item; return &a->data[a->len - 1]; } -template T *StaticArray_Make (StaticArray *a, isize num) { DQN_ASSERT(a->len + num <= a->max); T *result = a->data + a->len; a->len += num; return result;} -template void StaticArray_Clear (StaticArray *a) { a->len = 0; } -template void StaticArray_EraseStable (StaticArray *a, isize index) { EraseStableFromCArray(a->data, a->len--, a->max, index); } -template void StaticArray_EraseUnstable(StaticArray *a, isize index) { DQN_ASSERT(index >= 0 && index < a->len); if (--a->len == 0) return; a->data[index] = a->data[a->len]; } -template void StaticArray_Pop (StaticArray *a, isize num) { DQN_ASSERT(a->len - num >= 0); a->len -= num; } -template T *StaticArray_Peek (StaticArray *a) { T *result = (a->len == 0) ? nullptr : a->data + (a->len - 1); return result; } +template Dqn_StaticArray Dqn_StaticArray_InitMemory (T *memory, isize max, isize len = 0) { Dqn_StaticArray result = {}; result.data = memory; result.len = len; result.max = max; return result; } +template T *Dqn_StaticArray_Add (Dqn_StaticArray *a, T const *items, isize num) { DQN_ASSERT(a->len + num <= a->max); T *result = static_cast(Dqn_MemCopy(a->data + a->len, items, sizeof(T) * num)); a->len += num; return result; } +template T *Dqn_StaticArray_Add (Dqn_StaticArray *a, T const item) { DQN_ASSERT(a->len < a->max); a->data[a->len++] = item; return &a->data[a->len - 1]; } +template T *Dqn_StaticArray_Make (Dqn_StaticArray *a, isize num) { DQN_ASSERT(a->len + num <= a->max); T *result = a->data + a->len; a->len += num; return result;} +template void Dqn_StaticArray_Clear (Dqn_StaticArray *a) { a->len = 0; } +template void Dqn_StaticArray_EraseStable (Dqn_StaticArray *a, isize index) { EraseStableFromCArray(a->data, a->len--, a->max, index); } +template void Dqn_StaticArray_EraseUnstable(Dqn_StaticArray *a, isize index) { DQN_ASSERT(index >= 0 && index < a->len); if (--a->len == 0) return; a->data[index] = a->data[a->len]; } +template void Dqn_StaticArray_Pop (Dqn_StaticArray *a, isize num) { DQN_ASSERT(a->len - num >= 0); a->len -= num; } +template T *Dqn_StaticArray_Peek (Dqn_StaticArray *a) { T *result = (a->len == 0) ? nullptr : a->data + (a->len - 1); return result; } // ------------------------------------------------------------------------------------------------- // -// NOTE: FixedString +// NOTE: Dqn_FixedString // // ------------------------------------------------------------------------------------------------- template -struct FixedString +struct Dqn_FixedString { union { char data[MAX_]; char str[MAX_]; char buf[MAX_]; }; isize len; isize Max() const { return MAX_; } - FixedString() { data[0] = 0; len = 0; } - FixedString(char const *fmt, ...); + Dqn_FixedString() { data[0] = 0; len = 0; } + Dqn_FixedString(char const *fmt, ...); char const &operator[] (isize i) const { DQN_ASSERT_MSG(i >= 0 && i < len, "%d >= 0 && %d < %d", i, len); return data[i]; } char &operator[] (isize i) { DQN_ASSERT_MSG(i >= 0 && i < len, "%d >= 0 && %d < %d", i, len); return data[i]; } @@ -826,8 +826,8 @@ struct FixedString char *end () { return data + len; } }; -template void FixedString_Clear (FixedString *str) { *str = {}; } -template void FixedString_AppendVFmt(FixedString *str, char const *fmt, va_list va) +template void Dqn_FixedString_Clear (Dqn_FixedString *str) { *str = {}; } +template void Dqn_FixedString_AppendVFmt(Dqn_FixedString *str, char const *fmt, va_list va) { isize require = stbsp_vsnprintf(nullptr, 0, fmt, va) + 1; isize space = MAX_ - str->len; @@ -835,15 +835,15 @@ template void FixedString_AppendVFmt(FixedString *str, char c str->len += stbsp_vsnprintf(str->data + str->len, static_cast(space), fmt, va); } -template void FixedString_AppendFmt(FixedString *str, char const *fmt, ...) +template void Dqn_FixedString_AppendFmt(Dqn_FixedString *str, char const *fmt, ...) { va_list va; va_start(va, fmt); - FixedString_AppendVFmt(str, fmt, va); + Dqn_FixedString_AppendVFmt(str, fmt, va); va_end(va); } -template void FixedString_Append(FixedString *str, char const *src, isize len = -1) +template void Dqn_FixedString_Append(Dqn_FixedString *str, char const *src, isize len = -1) { if (len == -1) len = (isize)strlen(src); isize space = MAX_ - str->len; @@ -853,12 +853,12 @@ template void FixedString_Append(FixedString *str, char const str->str[str->len] = 0; } -template FixedString::FixedString(char const *fmt, ...) +template Dqn_FixedString::Dqn_FixedString(char const *fmt, ...) { *this = {}; va_list va; va_start(va, fmt); - FixedString_AppendVFmt(this, fmt, va); + Dqn_FixedString_AppendVFmt(this, fmt, va); va_end(va); } @@ -957,12 +957,12 @@ void Dqn_Log(Dqn_LogType type, char const *file, usize file_len, char const *fun // ------------------------------------------------------------------------------------------------- // -// NOTE: MemArena Internal +// NOTE: Dqn_MemArena Internal // // ------------------------------------------------------------------------------------------------- -FILE_SCOPE MemBlock *MemArena__AllocateBlock(MemArena *arena, usize requested_size) +FILE_SCOPE MemBlock *Dqn_MemArena__AllocateBlock(Dqn_MemArena *arena, usize requested_size) { - usize mem_block_size = DQN_MAX(ArrayCount(arena->fixed_mem), requested_size); + usize mem_block_size = DQN_MAX(Dqn_ArrayCount(arena->fixed_mem), requested_size); usize const allocate_size = sizeof(*arena->curr_mem_block) + mem_block_size; MemBlock *result = nullptr; @@ -973,7 +973,7 @@ FILE_SCOPE MemBlock *MemArena__AllocateBlock(MemArena *arena, usize requested_si } else { - if (!(arena->flags & MemArenaFlag_NoCRTAllocation)) + if (!(arena->flags & Dqn_MemArenaFlag_NoCRTAllocation)) result = static_cast(calloc(1, allocate_size)); } @@ -987,7 +987,7 @@ FILE_SCOPE MemBlock *MemArena__AllocateBlock(MemArena *arena, usize requested_si return result; } -FILE_SCOPE void MemArena__FreeBlock(MemArena *arena, MemBlock *block) +FILE_SCOPE void Dqn_MemArena__FreeBlock(Dqn_MemArena *arena, MemBlock *block) { if (!block) return; @@ -1007,13 +1007,13 @@ FILE_SCOPE void MemArena__FreeBlock(MemArena *arena, MemBlock *block) } else { - if (!(arena->flags & MemArenaFlag_NoCRTAllocation)) + if (!(arena->flags & Dqn_MemArenaFlag_NoCRTAllocation)) free(block); } } } -FILE_SCOPE void MemArena__AttachBlock(MemArena *arena, MemBlock *new_block) +FILE_SCOPE void Dqn_MemArena__AttachBlock(Dqn_MemArena *arena, MemBlock *new_block) { DQN_ASSERT(arena->curr_mem_block); DQN_ASSERT(arena->top_mem_block->next == nullptr); @@ -1022,7 +1022,7 @@ FILE_SCOPE void MemArena__AttachBlock(MemArena *arena, MemBlock *new_block) arena->top_mem_block = new_block; } -FILE_SCOPE void MemArena__LazyInit(MemArena *arena) +FILE_SCOPE void Dqn_MemArena__LazyInit(Dqn_MemArena *arena) { if (!arena->curr_mem_block) { @@ -1030,7 +1030,7 @@ FILE_SCOPE void MemArena__LazyInit(MemArena *arena) arena->fixed_mem_block = {}; arena->fixed_mem_block.allocated_by_user_or_fixed_mem = true; arena->fixed_mem_block.memory = arena->fixed_mem; - arena->fixed_mem_block.size = ArrayCount(arena->fixed_mem); + arena->fixed_mem_block.size = Dqn_ArrayCount(arena->fixed_mem); arena->curr_mem_block = &arena->fixed_mem_block; arena->top_mem_block = arena->curr_mem_block; } @@ -1039,15 +1039,15 @@ FILE_SCOPE void MemArena__LazyInit(MemArena *arena) // ------------------------------------------------------------------------------------------------- // -// NOTE: MemArena +// NOTE: Dqn_MemArena // // ------------------------------------------------------------------------------------------------- -void *MemArena_Alloc(MemArena *arena, usize size DQN_DEBUG_ARGS) +void *Dqn_MemArena_Alloc(Dqn_MemArena *arena, usize size DQN_DEBUG_ARGS) { #if defined(DQN_DEBUG_MEM_ARENA_LOGGING) (void)file; (void)file_len; (void)func; (void)func_len; (void)line; #endif - MemArena__LazyInit(arena); + Dqn_MemArena__LazyInit(arena); b32 need_new_mem_block = true; for (MemBlock *mem_block = arena->curr_mem_block; mem_block; mem_block = mem_block->next) @@ -1063,9 +1063,9 @@ void *MemArena_Alloc(MemArena *arena, usize size DQN_DEBUG_ARGS) if (need_new_mem_block) { - MemBlock *new_block = MemArena__AllocateBlock(arena, size); + MemBlock *new_block = Dqn_MemArena__AllocateBlock(arena, size); if (!new_block) return nullptr; - MemArena__AttachBlock(arena, new_block); + Dqn_MemArena__AttachBlock(arena, new_block); arena->curr_mem_block = arena->top_mem_block; } @@ -1076,7 +1076,7 @@ void *MemArena_Alloc(MemArena *arena, usize size DQN_DEBUG_ARGS) } -void MemArena_Free(MemArena *arena DQN_DEBUG_ARGS) +void Dqn_MemArena_Free(Dqn_MemArena *arena DQN_DEBUG_ARGS) { #if defined(DQN_DEBUG_MEM_ARENA_LOGGING) (void)file; (void)file_len; (void)func; (void)func_len; (void)line; @@ -1085,7 +1085,7 @@ void MemArena_Free(MemArena *arena DQN_DEBUG_ARGS) { MemBlock *block_to_free = mem_block; mem_block = block_to_free->prev; - MemArena__FreeBlock(arena, block_to_free); + Dqn_MemArena__FreeBlock(arena, block_to_free); } auto my_calloc = arena->my_calloc; @@ -1098,41 +1098,41 @@ void MemArena_Free(MemArena *arena DQN_DEBUG_ARGS) } -b32 MemArena_Reserve(MemArena *arena, usize size DQN_DEBUG_ARGS) +b32 Dqn_MemArena_Reserve(Dqn_MemArena *arena, usize size DQN_DEBUG_ARGS) { #if defined(DQN_DEBUG_MEM_ARENA_LOGGING) (void)file; (void)file_len; (void)func; (void)func_len; (void)line; #endif - MemArena__LazyInit(arena); + Dqn_MemArena__LazyInit(arena); MemSize remaining_space = arena->top_mem_block->size - arena->top_mem_block->used; if (remaining_space >= size) return true; - MemBlock *new_block = MemArena__AllocateBlock(arena, size); + MemBlock *new_block = Dqn_MemArena__AllocateBlock(arena, size); if (!new_block) return false; - MemArena__AttachBlock(arena, new_block); + Dqn_MemArena__AttachBlock(arena, new_block); return true; } -void MemArena_ReserveFrom(MemArena *arena, void *memory, usize size DQN_DEBUG_ARGS) +void Dqn_MemArena_ReserveFrom(Dqn_MemArena *arena, void *memory, usize size DQN_DEBUG_ARGS) { #if defined(DQN_DEBUG_MEM_ARENA_LOGGING) (void)file; (void)file_len; (void)func; (void)func_len; (void)line; #endif DQN_ASSERT_MSG(size >= sizeof(*arena->curr_mem_block), "(%zu >= %zu) There needs to be enough space to encode the MemBlock struct into the memory buffer", size, sizeof(*arena->curr_mem_block)); - MemArena__LazyInit(arena); + Dqn_MemArena__LazyInit(arena); auto *mem_block = static_cast(memory); *mem_block = {}; mem_block->memory = static_cast(memory) + sizeof(*mem_block); mem_block->size = size - sizeof(*mem_block); mem_block->allocated_by_user_or_fixed_mem = true; - MemArena__AttachBlock(arena, mem_block); + Dqn_MemArena__AttachBlock(arena, mem_block); } -void MemArena_ClearUsed(MemArena *arena DQN_DEBUG_ARGS) +void Dqn_MemArena_ClearUsed(Dqn_MemArena *arena DQN_DEBUG_ARGS) { #if defined(DQN_DEBUG_MEM_ARENA_LOGGING) (void)file; (void)file_len; (void)func; (void)func_len; (void)line; @@ -1143,12 +1143,12 @@ void MemArena_ClearUsed(MemArena *arena DQN_DEBUG_ARGS) } -MemArenaScopedRegion MemArena_MakeScopedRegion(MemArena *arena) +Dqn_MemArenaScopedRegion Dqn_MemArena_MakeScopedRegion(Dqn_MemArena *arena) { - return MemArenaScopedRegion(arena); + return Dqn_MemArenaScopedRegion(arena); } -MemArenaScopedRegion::MemArenaScopedRegion(MemArena *arena) +Dqn_MemArenaScopedRegion::Dqn_MemArenaScopedRegion(Dqn_MemArena *arena) { this->arena = arena; this->curr_mem_block = arena->curr_mem_block; @@ -1156,13 +1156,13 @@ MemArenaScopedRegion::MemArenaScopedRegion(MemArena *arena) this->top_mem_block = arena->top_mem_block; } -MemArenaScopedRegion::~MemArenaScopedRegion() +Dqn_MemArenaScopedRegion::~Dqn_MemArenaScopedRegion() { while (this->top_mem_block != this->arena->top_mem_block) { MemBlock *block_to_free = this->arena->top_mem_block; this->arena->top_mem_block = block_to_free->prev; - MemArena__FreeBlock(this->arena, block_to_free); + Dqn_MemArena__FreeBlock(this->arena, block_to_free); } for (MemBlock *mem_block = this->arena->top_mem_block; mem_block != this->curr_mem_block; mem_block = mem_block->prev) @@ -1175,7 +1175,7 @@ template FILE_SCOPE char *Dqn_StringBuilder__GetWriteBufferAndUpdateUsage(Dqn_StringBuilder *builder, usize size_required) { char *result = builder->fixed_mem + builder->fixed_mem_used; - usize space = ArrayCount(builder->fixed_mem) - builder->fixed_mem_used; + usize space = Dqn_ArrayCount(builder->fixed_mem) - builder->fixed_mem_used; usize *usage = &builder->fixed_mem_used; if (builder->last_mem_buf) @@ -1292,7 +1292,7 @@ char *Dqn_StringBuilder_BuildFromMalloc(Dqn_StringBuilder *builder, isize *le } template -char *Dqn_StringBuilder_BuildFromArena(Dqn_StringBuilder *builder, MemArena *arena, isize *len = nullptr) +char *Dqn_StringBuilder_BuildFromArena(Dqn_StringBuilder *builder, Dqn_MemArena *arena, isize *len = nullptr) { isize len_w_null_terminator = Dqn_StringBuilder_BuildLen(builder); char *result = MEM_ARENA_ALLOC_ARRAY(arena, char, len_w_null_terminator); diff --git a/Code/Dqn_UnitTests.cpp b/Code/Dqn_UnitTests.cpp index af8ca4b..2086124 100644 --- a/Code/Dqn_UnitTests.cpp +++ b/Code/Dqn_UnitTests.cpp @@ -2,12 +2,12 @@ struct TestState { - MemArena arena; - int indent_level; - Slice name; - Slice fail_expr; - Slice fail_msg; - bool scope_started; + Dqn_MemArena arena; + int indent_level; + Slice name; + Slice fail_expr; + Slice fail_msg; + bool scope_started; }; struct TestingState @@ -63,9 +63,9 @@ void TestingState_PrintGroupResult(TestingState const *result) bool all_tests_passed = (result->num_tests_ok_in_group == result->num_tests_in_group); char buf[256] = {}; - int len = snprintf(buf, ArrayCount(buf), "%02d/%02d Tests Passed ", result->num_tests_ok_in_group, result->num_tests_in_group); + int len = snprintf(buf, Dqn_ArrayCount(buf), "%02d/%02d Tests Passed ", result->num_tests_ok_in_group, result->num_tests_in_group); isize remaining_len = DESIRED_LEN - len - 1; - remaining_len = (all_tests_passed) ? remaining_len - CharCount(STATUS_OK) : remaining_len - CharCount(STATUS_FAIL); + remaining_len = (all_tests_passed) ? remaining_len - Dqn_CharCount(STATUS_OK) : remaining_len - Dqn_CharCount(STATUS_FAIL); remaining_len = DQN_MAX(remaining_len, 0); DQN_FOR_EACH(i, remaining_len) fprintf(stdout, " "); @@ -85,8 +85,8 @@ void TestState_PrintResult(TestState const *result) char const STATUS_OK[] = "OK"; char const STATUS_FAIL[] = "FAIL"; - isize remaining_len = DESIRED_LEN - result->name.len - CharCount(INDENT); - remaining_len = (result->fail_expr.str) ? remaining_len - CharCount(STATUS_FAIL) : remaining_len - CharCount(STATUS_OK); + isize remaining_len = DESIRED_LEN - result->name.len - Dqn_CharCount(INDENT); + remaining_len = (result->fail_expr.str) ? remaining_len - Dqn_CharCount(STATUS_FAIL) : remaining_len - Dqn_CharCount(STATUS_OK); remaining_len = DQN_MAX(remaining_len, 0); DQN_FOR_EACH(i, remaining_len) fprintf(stdout, "."); @@ -123,7 +123,7 @@ FILE_SCOPE void UnitTests() DQN_DEFER { free(result); }; char constexpr EXPECT_STR[] = "Acd"; - TEST_EXPECT_MSG(testing_state, len == CharCountI(EXPECT_STR) + 1 /*null terminator*/, "len: %zd", len); + TEST_EXPECT_MSG(testing_state, len == Dqn_CharCountI(EXPECT_STR) + 1 /*null terminator*/, "len: %zd", len); TEST_EXPECT_MSG(testing_state, strncmp(result, EXPECT_STR, len) == 0, "result: %s", result); } @@ -137,7 +137,7 @@ FILE_SCOPE void UnitTests() DQN_DEFER { free(result); }; char constexpr EXPECT_STR[] = ""; - TEST_EXPECT_MSG(testing_state, len == CharCountI(EXPECT_STR) + 1 /*null terminator*/, "len: %zd", len); + TEST_EXPECT_MSG(testing_state, len == Dqn_CharCountI(EXPECT_STR) + 1 /*null terminator*/, "len: %zd", len); TEST_EXPECT_MSG(testing_state, strncmp(result, EXPECT_STR, len) == 0, "result: %s", result); } @@ -151,7 +151,7 @@ FILE_SCOPE void UnitTests() DQN_DEFER { free(result); }; char constexpr EXPECT_STR[] = "Acd"; - TEST_EXPECT_MSG(testing_state, len == CharCountI(EXPECT_STR) + 1 /*null terminator*/, "len: %zd", len); + TEST_EXPECT_MSG(testing_state, len == Dqn_CharCountI(EXPECT_STR) + 1 /*null terminator*/, "len: %zd", len); TEST_EXPECT_MSG(testing_state, strncmp(result, EXPECT_STR, len) == 0, "result: %s", result); } @@ -164,7 +164,7 @@ FILE_SCOPE void UnitTests() DQN_DEFER { free(result); }; char constexpr EXPECT_STR[] = ""; - TEST_EXPECT_MSG(testing_state, len == CharCountI(EXPECT_STR) + 1 /*null terminator*/, "len: %zd", len); + TEST_EXPECT_MSG(testing_state, len == Dqn_CharCountI(EXPECT_STR) + 1 /*null terminator*/, "len: %zd", len); TEST_EXPECT_MSG(testing_state, strncmp(result, EXPECT_STR, len) == 0, "result: %s", result); } @@ -179,7 +179,7 @@ FILE_SCOPE void UnitTests() DQN_DEFER { free(result); }; char constexpr EXPECT_STR[] = "Aztec"; - TEST_EXPECT_MSG(testing_state, len == CharCountI(EXPECT_STR) + 1 /*null terminator*/, "len: %zd", len); + TEST_EXPECT_MSG(testing_state, len == Dqn_CharCountI(EXPECT_STR) + 1 /*null terminator*/, "len: %zd", len); TEST_EXPECT_MSG(testing_state, strncmp(result, EXPECT_STR, len) == 0, "result: %s", result); } } @@ -196,7 +196,7 @@ FILE_SCOPE void UnitTests() DQN_DEFER { free(result); }; char constexpr EXPECT_STR[] = "ab"; - TEST_EXPECT_MSG(testing_state, len == CharCountI(EXPECT_STR) + 1 /*null terminator*/, "len: %zd", len); + TEST_EXPECT_MSG(testing_state, len == Dqn_CharCountI(EXPECT_STR) + 1 /*null terminator*/, "len: %zd", len); TEST_EXPECT_MSG(testing_state, strncmp(result, EXPECT_STR, len) == 0, "result: %s", result); } @@ -212,7 +212,7 @@ FILE_SCOPE void UnitTests() DQN_DEFER { free(result); }; char constexpr EXPECT_STR[] = "Number: 4, String: Hello Sailor, Extra Stuff"; - TEST_EXPECT_MSG(testing_state, len == CharCountI(EXPECT_STR) + 1 /*null terminator*/, "len: %zd", len); + TEST_EXPECT_MSG(testing_state, len == Dqn_CharCountI(EXPECT_STR) + 1 /*null terminator*/, "len: %zd", len); TEST_EXPECT_MSG(testing_state, strncmp(result, EXPECT_STR, len) == 0, "result: %s", result); } @@ -225,7 +225,7 @@ FILE_SCOPE void UnitTests() DQN_DEFER { free(result); }; char constexpr EXPECT_STR[] = ""; - TEST_EXPECT_MSG(testing_state, len == CharCountI(EXPECT_STR) + 1 /*null terminator*/, "len: %zd", len); + TEST_EXPECT_MSG(testing_state, len == Dqn_CharCountI(EXPECT_STR) + 1 /*null terminator*/, "len: %zd", len); TEST_EXPECT_MSG(testing_state, strncmp(result, EXPECT_STR, len) == 0, "result: %s", result); } } @@ -242,7 +242,7 @@ FILE_SCOPE void UnitTests() { TEST_START_SCOPE(testing_state, "Initialise from raw array"); int raw_array[] = {1, 2}; - auto array = Dqn_FixedArray_Init(raw_array, (int)ArrayCount(raw_array)); + auto array = Dqn_FixedArray_Init(raw_array, (int)Dqn_ArrayCount(raw_array)); TEST_EXPECT(testing_state, array.len == 2); TEST_EXPECT(testing_state, array[0] == 1); TEST_EXPECT(testing_state, array[1] == 2); @@ -252,7 +252,7 @@ FILE_SCOPE void UnitTests() { TEST_START_SCOPE(testing_state, "Erase stable 1 element from array"); int raw_array[] = {1, 2, 3}; - auto array = Dqn_FixedArray_Init(raw_array, (int)ArrayCount(raw_array)); + auto array = Dqn_FixedArray_Init(raw_array, (int)Dqn_ArrayCount(raw_array)); Dqn_FixedArray_EraseStable(&array, 1); TEST_EXPECT(testing_state, array.len == 2); TEST_EXPECT(testing_state, array[0] == 1); @@ -263,7 +263,7 @@ FILE_SCOPE void UnitTests() { TEST_START_SCOPE(testing_state, "Erase unstable 1 element from array"); int raw_array[] = {1, 2, 3}; - auto array = Dqn_FixedArray_Init(raw_array, (int)ArrayCount(raw_array)); + auto array = Dqn_FixedArray_Init(raw_array, (int)Dqn_ArrayCount(raw_array)); Dqn_FixedArray_EraseUnstable(&array, 0); TEST_EXPECT(testing_state, array.len == 2); TEST_EXPECT(testing_state, array[0] == 3); @@ -275,7 +275,7 @@ FILE_SCOPE void UnitTests() TEST_START_SCOPE(testing_state, "Add 1 element to array"); int const ITEM = 2; int raw_array[] = {1}; - auto array = Dqn_FixedArray_Init(raw_array, (int)ArrayCount(raw_array)); + auto array = Dqn_FixedArray_Init(raw_array, (int)Dqn_ArrayCount(raw_array)); Dqn_FixedArray_Add(&array, ITEM); TEST_EXPECT(testing_state, array.len == 2); TEST_EXPECT(testing_state, array[0] == 1); @@ -286,7 +286,7 @@ FILE_SCOPE void UnitTests() { TEST_START_SCOPE(testing_state, "Clear array"); int raw_array[] = {1}; - auto array = Dqn_FixedArray_Init(raw_array, (int)ArrayCount(raw_array)); + auto array = Dqn_FixedArray_Init(raw_array, (int)Dqn_ArrayCount(raw_array)); Dqn_FixedArray_Clear(&array); TEST_EXPECT(testing_state, array.len == 0); }