From d4834f45c0dc3a11ecab5dad6af433374b82de46 Mon Sep 17 00:00:00 2001 From: doylet Date: Thu, 25 Jun 2026 21:49:16 +1000 Subject: [PATCH] Update to .count for strings --- Single-Header/dn_single_header.cpp | 1344 ++++++++++++++-------------- Single-Header/dn_single_header.h | 368 ++++---- Source/External/stb_sprintf.h | 2 +- Source/Extra/dn_tests.cpp | 106 +-- Source/OS/dn_os_posix.cpp | 38 +- Source/OS/dn_os_w32.cpp | 122 +-- Source/Standalone/dn_ini.c | 122 +-- Source/Standalone/dn_ini.h | 10 +- Source/dn.cpp | 1074 +++++++++++----------- Source/dn.h | 309 ++++--- build.bat | 4 +- single_header_generator.cpp | 4 +- 12 files changed, 1797 insertions(+), 1706 deletions(-) diff --git a/Single-Header/dn_single_header.cpp b/Single-Header/dn_single_header.cpp index 3134307..45408a7 100644 --- a/Single-Header/dn_single_header.cpp +++ b/Single-Header/dn_single_header.cpp @@ -1,6 +1,4 @@ -// Generated by the DN single header generator 2026-06-23 23:16:54 - -#define DN_BASE_CPP +// Generated by the DN single header generator 2026-06-25 21:37:26 // DN: Single header generator commented out => #if defined(_CLANGD) // #define DN_ARENA_TEMP_MEM_UAF_GUARD 1 @@ -182,7 +180,7 @@ DN_API void DN_Init(DN_Core *dn, DN_InitFlags flags, DN_TCInitArgs args) DN_USize longest_feature_name = 0; for (DN_ForIndexU(feature_index, DN_CPUFeature_Count)) { DN_CPUFeatureDecl feature_decl = g_dn_cpu_feature_decl[feature_index]; - longest_feature_name = DN_Max(longest_feature_name, feature_decl.label.size); + longest_feature_name = DN_Max(longest_feature_name, feature_decl.label.count); } for (DN_ForIndexU(feature_index, DN_CPUFeature_Count)) { @@ -194,7 +192,7 @@ DN_API void DN_Init(DN_Core *dn, DN_InitFlags flags, DN_TCInitArgs args) DN_Str8Lit("..."), " %.*s:%*s%s\n", DN_Str8PrintFmt(feature_decl.label), - DN_Cast(int)(longest_feature_name - feature_decl.label.size), + DN_Cast(int)(longest_feature_name - feature_decl.label.count), "", has_feature ? "available" : "not available"); } @@ -271,23 +269,23 @@ DN_API bool DN_VerifyArgs(DN_VerifyType type, bool expr, DN_CallSite call_site, return result; } -DN_API bool DN_MemStartsWith(void const *lhs, DN_USize lhs_size, void const *rhs, DN_USize rhs_size) +DN_API bool DN_MemStartsWith(void const *lhs, DN_USize lhs_count, void const *rhs, DN_USize rhs_count) { bool result = false; - if (lhs_size >= rhs_size) - result = DN_MemEqUnsafe(lhs, rhs, rhs_size); + if (lhs_count >= rhs_count) + result = DN_MemEqUnsafe(lhs, rhs, rhs_count); return result; } -DN_API bool DN_MemEq(void const *lhs, DN_USize lhs_size, void const *rhs, DN_USize rhs_size) +DN_API bool DN_MemEq(void const *lhs, DN_USize lhs_count, void const *rhs, DN_USize rhs_count) { - bool result = lhs_size == rhs_size && DN_Memcmp(lhs, rhs, rhs_size) == 0; + bool result = lhs_count == rhs_count && DN_Memcmp(lhs, rhs, rhs_count) == 0; return result; } -DN_API bool DN_MemEqUnsafe(void const *lhs, void const *rhs, DN_USize size) +DN_API bool DN_MemEqUnsafe(void const *lhs, void const *rhs, DN_USize count) { - bool result = DN_Memcmp(lhs, rhs, size) == 0; + bool result = DN_Memcmp(lhs, rhs, count) == 0; return result; } @@ -1164,10 +1162,10 @@ DN_API DN_MemStats DN_MemStatsSum(DN_MemStats lhs, DN_MemStats rhs) return result; } -DN_API DN_MemStats DN_MemStatsSumArray(DN_MemStats const *array, DN_USize size) +DN_API DN_MemStats DN_MemStatsSumArray(DN_MemStats const *array, DN_USize count) { DN_MemStats result = {}; - for (DN_ForItSize(it, DN_MemStats const, array, size)) { + for (DN_ForItSize(it, DN_MemStats const, array, count)) { DN_MemStats stats = *it.data; result.info.used += stats.info.used; result.info.commit += stats.info.commit; @@ -1910,7 +1908,7 @@ static void DN_ErrSinkAddMsgToStr8Builder_(DN_Str8Builder *builder, DN_ErrSinkMs DN_Str8PrintFmt(file_name), it->call_site.line, DN_Str8PrintFmt(it->call_site.function), - it->msg.size ? " " : "", + it->msg.count ? " " : "", DN_Str8PrintFmt(it->msg)); } } @@ -1956,7 +1954,7 @@ DN_API bool DN_ErrSinkEndLogError_(DN_ErrSink *err, DN_CallSite call_site, DN_St // NOTE: Build the error string DN_Str8Builder builder = DN_Str8BuilderFromArena(err->arena); { - if (err_msg.size) { + if (err_msg.count) { DN_Str8BuilderAppendRef(&builder, err_msg); DN_Str8BuilderAppendRef(&builder, DN_Str8Lit(":")); } else { @@ -2321,14 +2319,14 @@ DN_API DN_U64FromResult DN_U64FromStr8(DN_Str8 string, char separator) { // NOTE: Argument check DN_U64FromResult result = {}; - if (string.size == 0) { + if (string.count == 0) { result.success = true; return result; } // NOTE: Sanitize input/output DN_Str8 trim_string = DN_Str8TrimWhitespaceAround(string); - if (trim_string.size == 0) { + if (trim_string.count == 0) { result.success = true; return result; } @@ -2342,7 +2340,7 @@ DN_API DN_U64FromResult DN_U64FromStr8(DN_Str8 string, char separator) } // NOTE: Convert the string number to the binary number - for (DN_USize index = start_index; index < trim_string.size; index++) { + for (DN_USize index = start_index; index < trim_string.count; index++) { char ch = trim_string.data[index]; if (index) { if (separator != 0 && ch == separator) @@ -2409,13 +2407,13 @@ DN_API DN_U64 DN_U64FromHexPtrUnsafe(void const *hex, DN_USize hex_count) DN_API DN_U64FromResult DN_U64FromHexStr8(DN_Str8 hex) { - DN_U64FromResult result = DN_U64FromHexPtr(hex.data, hex.size); + DN_U64FromResult result = DN_U64FromHexPtr(hex.data, hex.count); return result; } DN_API DN_U64 DN_U64FromHexStr8Unsafe(DN_Str8 hex) { - DN_U64 result = DN_U64FromHexPtrUnsafe(hex.data, hex.size); + DN_U64 result = DN_U64FromHexPtrUnsafe(hex.data, hex.count); return result; } @@ -2478,14 +2476,14 @@ DN_API DN_I64FromResult DN_I64FromStr8(DN_Str8 string, char separator) { // NOTE: Argument check DN_I64FromResult result = {}; - if (string.size == 0) { + if (string.count == 0) { result.success = true; return result; } // NOTE: Sanitize input/output DN_Str8 trim_string = DN_Str8TrimWhitespaceAround(string); - if (trim_string.size == 0) { + if (trim_string.count == 0) { result.success = true; return result; } @@ -2500,7 +2498,7 @@ DN_API DN_I64FromResult DN_I64FromStr8(DN_Str8 string, char separator) } // NOTE: Convert the string number to the binary number - for (DN_USize index = start_index; index < trim_string.size; index++) { + for (DN_USize index = start_index; index < trim_string.count; index++) { char ch = trim_string.data[index]; if (index) { if (separator != 0 && ch == separator) @@ -2543,11 +2541,11 @@ DN_API bool DN_U8x32Eq(DN_U8x32 const *lhs, DN_U8x32 const *rhs) return result; } -DN_API DN_U8x32 DN_U8x32FromBytesLeftPadZ(DN_U8 const *ptr, DN_USize count) +DN_API DN_U8x32 DN_U8x32FromBytesLeftPadZ(DN_U8 const *ptr, DN_USize size) { DN_U8x32 result = {}; - DN_Assert(count <= sizeof(result.data)); - DN_Memcpy(result.data + sizeof(result.data) - count, ptr, count); + DN_Assert(size <= sizeof(result.data)); + DN_Memcpy(result.data + sizeof(result.data) - size, ptr, size); return result; } @@ -2555,15 +2553,15 @@ DN_API DN_U8x32 DN_U8x32FromHexUnsafe(DN_Str8 hex_32b) { DN_U8x32 result = {}; hex_32b = DN_Str8TrimHexPrefix(hex_32b); - DN_Assert(hex_32b.size <= sizeof(result.data) * 2); - DN_BytesFromHexPtr(hex_32b.data, hex_32b.size, result.data, sizeof(result.data)); + DN_Assert(hex_32b.count <= sizeof(result.data) * 2); + DN_BytesFromHexPtr(hex_32b.data, hex_32b.count, result.data, sizeof(result.data)); return result; } DN_API DN_U8x32FromResult DN_U8x32FromHex(DN_Str8 hex_32b) { DN_U8x32FromResult result = {}; - DN_USize bytes_written = DN_BytesFromHexPtr(hex_32b.data, hex_32b.size, result.value.data, sizeof(result.value.data)); + DN_USize bytes_written = DN_BytesFromHexPtr(hex_32b.data, hex_32b.count, result.value.data, sizeof(result.value.data)); if (bytes_written == sizeof(result.value.data)) result.success = true; return result; @@ -2573,7 +2571,7 @@ DN_API DN_U8x32FromResult DN_U8x32FromDecimalStr8(DN_Str8 decimal) { DN_U8x32FromResult result = {}; result.success = true; - for (DN_USize i = 0; i < decimal.size; i++) { + for (DN_USize i = 0; i < decimal.count; i++) { DN_U8 digit = decimal.data[i]; if (!DN_CharIsDigit(digit)) { result.success = false; @@ -2650,7 +2648,7 @@ DN_API DN_FmtAppendResult DN_FmtVAppend(char *buf, DN_USize *buf_size, DN_USize *buf_size = buf_max - 1; DN_Assert(*buf_size <= (buf_max - 1)); result.str8 = DN_Str8FromPtr(buf, *buf_size); - result.truncated = result.str8.size != (starting_size + result.size_req); + result.truncated = result.str8.count != (starting_size + result.size_req); return result; } @@ -2669,12 +2667,12 @@ DN_API DN_FmtAppendResult DN_FmtAppendTruncate(char *buf, DN_USize *buf_size, DN va_start(args, fmt); DN_FmtAppendResult result = DN_FmtVAppend(buf, buf_size, buf_max, fmt, args); if (result.truncated) - DN_Memcpy(result.str8.data + result.str8.size - truncator.size, truncator.data, truncator.size); + DN_Memcpy(result.str8.data + result.str8.count - truncator.count, truncator.data, truncator.count); va_end(args); return result; } -DN_API DN_USize DN_FmtSize(DN_FMT_ATTRIB char const *fmt, ...) +DN_API DN_USize DN_FmtCount(DN_FMT_ATTRIB char const *fmt, ...) { va_list args; va_start(args, fmt); @@ -2683,7 +2681,7 @@ DN_API DN_USize DN_FmtSize(DN_FMT_ATTRIB char const *fmt, ...) return result; } -DN_API DN_USize DN_FmtVSize(DN_FMT_ATTRIB char const *fmt, va_list args) +DN_API DN_USize DN_FmtVCount(DN_FMT_ATTRIB char const *fmt, va_list args) { va_list args_copy; va_copy(args_copy, args); @@ -2692,7 +2690,7 @@ DN_API DN_USize DN_FmtVSize(DN_FMT_ATTRIB char const *fmt, va_list args) return result; } -DN_API DN_USize DN_CStr8Size(char const *src) +DN_API DN_USize DN_CStr8Count(char const *src) { DN_USize result = 0; for (; src && src[0] != 0; src++, result++) @@ -2700,7 +2698,7 @@ DN_API DN_USize DN_CStr8Size(char const *src) return result; } -DN_API DN_USize DN_CStr16Size(wchar_t const *src) +DN_API DN_USize DN_CStr16Count(wchar_t const *src) { DN_USize result = 0; for (; src && src[0] != 0; src++, result++) @@ -2708,33 +2706,33 @@ DN_API DN_USize DN_CStr16Size(wchar_t const *src) return result; } -DN_API DN_Str8 DN_Str8AllocAllocator(DN_USize size, DN_ZMem z_mem, DN_Allocator allocator) +DN_API DN_Str8 DN_Str8AllocAllocator(DN_USize count, DN_ZMem z_mem, DN_Allocator allocator) { DN_Str8 result = {}; - result.data = DN_Cast(char *) DN_AllocatorAlloc(allocator, size + 1, alignof(char), z_mem); + result.data = DN_Cast(char *) DN_AllocatorAlloc(allocator, count + 1, alignof(char), z_mem); if (result.data) { - result.size = size; - result.data[result.size] = 0; + result.count = count; + result.data[result.count] = 0; } return result; } -DN_API DN_Str8 DN_Str8AllocArena(DN_USize size, DN_ZMem z_mem, DN_Arena *arena) +DN_API DN_Str8 DN_Str8AllocArena(DN_USize count, DN_ZMem z_mem, DN_Arena *arena) { - DN_Str8 result = DN_Str8AllocAllocator(size, z_mem, DN_AllocatorFromArena(arena)); + DN_Str8 result = DN_Str8AllocAllocator(count, z_mem, DN_AllocatorFromArena(arena)); return result; } -DN_API DN_Str8 DN_Str8AllocPool(DN_USize size, DN_Pool *pool) +DN_API DN_Str8 DN_Str8AllocPool(DN_USize count, DN_Pool *pool) { - DN_Str8 result = DN_Str8AllocAllocator(size, DN_ZMem_No, DN_AllocatorFromPool(pool)); + DN_Str8 result = DN_Str8AllocAllocator(count, DN_ZMem_No, DN_AllocatorFromPool(pool)); return result; } DN_API DN_Str8 DN_Str8FromCStr8(char const *src) { - DN_USize size = DN_CStr8Size(src); - DN_Str8 result = DN_Str8FromPtr(src, size); + DN_USize count = DN_CStr8Count(src); + DN_Str8 result = DN_Str8FromPtr(src, count); return result; } @@ -2745,30 +2743,30 @@ DN_API DN_Str8 DN_Str8FromCStr8Arena(char const *src, DN_Arena *arena) return result; } -DN_API DN_Str8 DN_Str8FromPtrArena(void const *data, DN_USize size, DN_Arena *arena) +DN_API DN_Str8 DN_Str8FromPtrArena(void const *data, DN_USize count, DN_Arena *arena) { - DN_Str8 result = DN_Str8AllocArena(size, DN_ZMem_No, arena); - if (result.size) - DN_Memcpy(result.data, data, size); + DN_Str8 result = DN_Str8AllocArena(count, DN_ZMem_No, arena); + if (result.count) + DN_Memcpy(result.data, data, count); return result; } -DN_API DN_Str8 DN_Str8FromPtrPool(void const *data, DN_USize size, DN_Pool *pool) +DN_API DN_Str8 DN_Str8FromPtrPool(void const *data, DN_USize count, DN_Pool *pool) { - DN_Str8 result = DN_Str8AllocPool(size, pool); - if (result.size) - DN_Memcpy(result.data, data, size); + DN_Str8 result = DN_Str8AllocPool(count, pool); + if (result.count) + DN_Memcpy(result.data, data, count); return result; } DN_API DN_Str8 DN_Str8FromStr8Allocator(DN_Str8 string, DN_Allocator allocator) { DN_Str8 result = {}; - result.data = DN_Cast(char *) DN_AllocatorAlloc(allocator, string.size + 1, alignof(char), DN_ZMem_No); + result.data = DN_Cast(char *) DN_AllocatorAlloc(allocator, string.count + 1, alignof(char), DN_ZMem_No); if (result.data) { - DN_Memcpy(result.data, string.data, string.size); - result.data[string.size] = 0; - result.size = string.size; + DN_Memcpy(result.data, string.data, string.count); + result.data[string.count] = 0; + result.count = string.count; } return result; } @@ -2787,12 +2785,12 @@ DN_API DN_Str8 DN_Str8FromStr8Pool(DN_Str8 string, DN_Pool *pool) DN_API DN_Str8 DN_Str8FromFmtVAllocator(DN_Allocator allocator, DN_FMT_ATTRIB char const *fmt, va_list args) { - DN_USize size = DN_FmtVSize(fmt, args); - DN_Str8 result = DN_Str8AllocAllocator(size, DN_ZMem_No, allocator); + DN_USize count = DN_FmtVCount(fmt, args); + DN_Str8 result = DN_Str8AllocAllocator(count, DN_ZMem_No, allocator); if (result.data) { DN_USize written = 0; - DN_FmtVAppend(result.data, &written, result.size + 1, fmt, args); - DN_Assert(written == result.size); + DN_FmtVAppend(result.data, &written, result.count + 1, fmt, args); + DN_Assert(written == result.count); } return result; } @@ -2841,7 +2839,7 @@ DN_API DN_Str8x16 DN_Str8x16FromFmt(DN_FMT_ATTRIB char const *fmt, ...) va_list args; va_start(args, fmt); DN_Str8x16 result = {}; - DN_FmtVAppend(result.data, &result.size, sizeof(result.data), fmt, args); + DN_FmtVAppend(result.data, &result.count, sizeof(result.data), fmt, args); va_end(args); return result; } @@ -2849,7 +2847,7 @@ DN_API DN_Str8x16 DN_Str8x16FromFmt(DN_FMT_ATTRIB char const *fmt, ...) DN_API DN_Str8x16 DN_Str8x16FromFmtVArena(DN_FMT_ATTRIB char const *fmt, va_list args) { DN_Str8x16 result = {}; - DN_FmtVAppend(result.data, &result.size, sizeof(result.data), fmt, args); + DN_FmtVAppend(result.data, &result.count, sizeof(result.data), fmt, args); return result; } @@ -2858,7 +2856,7 @@ DN_API DN_Str8x32 DN_Str8x32FromFmt(DN_FMT_ATTRIB char const *fmt, ...) va_list args; va_start(args, fmt); DN_Str8x32 result = {}; - DN_FmtVAppend(result.data, &result.size, sizeof(result.data), fmt, args); + DN_FmtVAppend(result.data, &result.count, sizeof(result.data), fmt, args); va_end(args); return result; } @@ -2866,7 +2864,7 @@ DN_API DN_Str8x32 DN_Str8x32FromFmt(DN_FMT_ATTRIB char const *fmt, ...) DN_API DN_Str8x32 DN_Str8x32FromFmtVArena(DN_FMT_ATTRIB char const *fmt, va_list args) { DN_Str8x32 result = {}; - DN_FmtVAppend(result.data, &result.size, sizeof(result.data), fmt, args); + DN_FmtVAppend(result.data, &result.count, sizeof(result.data), fmt, args); return result; } @@ -2875,7 +2873,7 @@ DN_API DN_Str8x64 DN_Str8x64FromFmt(DN_FMT_ATTRIB char const *fmt, ...) va_list args; va_start(args, fmt); DN_Str8x64 result = {}; - DN_FmtVAppend(result.data, &result.size, sizeof(result.data), fmt, args); + DN_FmtVAppend(result.data, &result.count, sizeof(result.data), fmt, args); va_end(args); return result; } @@ -2883,7 +2881,7 @@ DN_API DN_Str8x64 DN_Str8x64FromFmt(DN_FMT_ATTRIB char const *fmt, ...) DN_API DN_Str8x64 DN_Str8x64FromFmtV(DN_FMT_ATTRIB char const *fmt, va_list args) { DN_Str8x64 result = {}; - DN_FmtVAppend(result.data, &result.size, sizeof(result.data), fmt, args); + DN_FmtVAppend(result.data, &result.count, sizeof(result.data), fmt, args); return result; } @@ -2892,7 +2890,7 @@ DN_API DN_Str8x128 DN_Str8x128FromFmt(DN_FMT_ATTRIB char const *fmt, ...) va_list args; va_start(args, fmt); DN_Str8x128 result = {}; - DN_FmtVAppend(result.data, &result.size, sizeof(result.data), fmt, args); + DN_FmtVAppend(result.data, &result.count, sizeof(result.data), fmt, args); va_end(args); return result; } @@ -2900,7 +2898,7 @@ DN_API DN_Str8x128 DN_Str8x128FromFmt(DN_FMT_ATTRIB char const *fmt, ...) DN_API DN_Str8x128 DN_Str8x128FromFmtVArena(DN_FMT_ATTRIB char const *fmt, va_list args) { DN_Str8x128 result = {}; - DN_FmtVAppend(result.data, &result.size, sizeof(result.data), fmt, args); + DN_FmtVAppend(result.data, &result.count, sizeof(result.data), fmt, args); return result; } @@ -2909,7 +2907,7 @@ DN_API DN_Str8x256 DN_Str8x256FromFmt(DN_FMT_ATTRIB char const *fmt, ...) va_list args; va_start(args, fmt); DN_Str8x256 result = {}; - DN_FmtVAppend(result.data, &result.size, sizeof(result.data), fmt, args); + DN_FmtVAppend(result.data, &result.count, sizeof(result.data), fmt, args); va_end(args); return result; } @@ -2917,7 +2915,7 @@ DN_API DN_Str8x256 DN_Str8x256FromFmt(DN_FMT_ATTRIB char const *fmt, ...) DN_API DN_Str8x256 DN_Str8x256FromFmtVArena(DN_FMT_ATTRIB char const *fmt, va_list args) { DN_Str8x256 result = {}; - DN_FmtVAppend(result.data, &result.size, sizeof(result.data), fmt, args); + DN_FmtVAppend(result.data, &result.count, sizeof(result.data), fmt, args); return result; } @@ -2926,7 +2924,7 @@ DN_API DN_Str8x512 DN_Str8x512FromFmt(DN_FMT_ATTRIB char const *fmt, ...) va_list args; va_start(args, fmt); DN_Str8x512 result = {}; - DN_FmtVAppend(result.data, &result.size, sizeof(result.data), fmt, args); + DN_FmtVAppend(result.data, &result.count, sizeof(result.data), fmt, args); va_end(args); return result; } @@ -2934,7 +2932,7 @@ DN_API DN_Str8x512 DN_Str8x512FromFmt(DN_FMT_ATTRIB char const *fmt, ...) DN_API DN_Str8x512 DN_Str8x512FromFmtVArena(DN_FMT_ATTRIB char const *fmt, va_list args) { DN_Str8x512 result = {}; - DN_FmtVAppend(result.data, &result.size, sizeof(result.data), fmt, args); + DN_FmtVAppend(result.data, &result.count, sizeof(result.data), fmt, args); return result; } @@ -2943,7 +2941,7 @@ DN_API DN_Str8x1024 DN_Str8x1024FromFmt(DN_FMT_ATTRIB char const *fmt, ...) va_list args; va_start(args, fmt); DN_Str8x1024 result = {}; - DN_FmtVAppend(result.data, &result.size, sizeof(result.data), fmt, args); + DN_FmtVAppend(result.data, &result.count, sizeof(result.data), fmt, args); va_end(args); return result; } @@ -2951,7 +2949,7 @@ DN_API DN_Str8x1024 DN_Str8x1024FromFmt(DN_FMT_ATTRIB char const *fmt, ...) DN_API DN_Str8x1024 DN_Str8x1024FromFmtVArena(DN_FMT_ATTRIB char const *fmt, va_list args) { DN_Str8x1024 result = {}; - DN_FmtVAppend(result.data, &result.size, sizeof(result.data), fmt, args); + DN_FmtVAppend(result.data, &result.count, sizeof(result.data), fmt, args); return result; } @@ -2965,7 +2963,7 @@ DN_API void DN_Str8x16AppendFmt(DN_Str8x16 *str, DN_FMT_ATTRIB char const *fmt, DN_API void DN_Str8x16AppendFmtV(DN_Str8x16 *str, DN_FMT_ATTRIB char const *fmt, va_list args) { - DN_FmtVAppend(str->data, &str->size, sizeof(str->data), fmt, args); + DN_FmtVAppend(str->data, &str->count, sizeof(str->data), fmt, args); } DN_API void DN_Str8x32AppendFmt(DN_Str8x32 *str, DN_FMT_ATTRIB char const *fmt, ...) @@ -2978,7 +2976,7 @@ DN_API void DN_Str8x32AppendFmt(DN_Str8x32 *str, DN_FMT_ATTRIB char const *fmt, DN_API void DN_Str8x32AppendFmtV(DN_Str8x32 *str, DN_FMT_ATTRIB char const *fmt, va_list args) { - DN_FmtVAppend(str->data, &str->size, sizeof(str->data), fmt, args); + DN_FmtVAppend(str->data, &str->count, sizeof(str->data), fmt, args); } DN_API void DN_Str8x64AppendFmt(DN_Str8x64 *str, DN_FMT_ATTRIB char const *fmt, ...) @@ -2991,7 +2989,7 @@ DN_API void DN_Str8x64AppendFmt(DN_Str8x64 *str, DN_FMT_ATTRIB char const *fmt, DN_API void DN_Str8x64AppendFmtV(DN_Str8x64 *str, DN_FMT_ATTRIB char const *fmt, va_list args) { - DN_FmtVAppend(str->data, &str->size, sizeof(str->data), fmt, args); + DN_FmtVAppend(str->data, &str->count, sizeof(str->data), fmt, args); } DN_API void DN_Str8x128AppendFmt(DN_Str8x128 *str, DN_FMT_ATTRIB char const *fmt, ...) @@ -3004,7 +3002,7 @@ DN_API void DN_Str8x128AppendFmt(DN_Str8x128 *str, DN_FMT_ATTRIB char const *fmt DN_API void DN_Str8x128AppendFmtV(DN_Str8x128 *str, DN_FMT_ATTRIB char const *fmt, va_list args) { - DN_FmtVAppend(str->data, &str->size, sizeof(str->data), fmt, args); + DN_FmtVAppend(str->data, &str->count, sizeof(str->data), fmt, args); } DN_API void DN_Str8x256AppendFmt(DN_Str8x256 *str, DN_FMT_ATTRIB char const *fmt, ...) @@ -3017,7 +3015,7 @@ DN_API void DN_Str8x256AppendFmt(DN_Str8x256 *str, DN_FMT_ATTRIB char const *fmt DN_API void DN_Str8x256AppendFmtV(DN_Str8x256 *str, DN_FMT_ATTRIB char const *fmt, va_list args) { - DN_FmtVAppend(str->data, &str->size, sizeof(str->data), fmt, args); + DN_FmtVAppend(str->data, &str->count, sizeof(str->data), fmt, args); } DN_API void DN_Str8x512AppendFmt(DN_Str8x512 *str, DN_FMT_ATTRIB char const *fmt, ...) @@ -3030,7 +3028,7 @@ DN_API void DN_Str8x512AppendFmt(DN_Str8x512 *str, DN_FMT_ATTRIB char const *fmt DN_API void DN_Str8x512AppendFmtV(DN_Str8x512 *str, DN_FMT_ATTRIB char const *fmt, va_list args) { - DN_FmtVAppend(str->data, &str->size, sizeof(str->data), fmt, args); + DN_FmtVAppend(str->data, &str->count, sizeof(str->data), fmt, args); } DN_API void DN_Str8x1024AppendFmt(DN_Str8x1024 *str, DN_FMT_ATTRIB char const *fmt, ...) @@ -3043,7 +3041,7 @@ DN_API void DN_Str8x1024AppendFmt(DN_Str8x1024 *str, DN_FMT_ATTRIB char const *f DN_API void DN_Str8x1024AppendFmtV(DN_Str8x1024 *str, DN_FMT_ATTRIB char const *fmt, va_list args) { - DN_FmtVAppend(str->data, &str->size, sizeof(str->data), fmt, args); + DN_FmtVAppend(str->data, &str->count, sizeof(str->data), fmt, args); } DN_API DN_Str8x32 DN_Str8x32FromU64(DN_U64 val, char separator) @@ -3053,16 +3051,16 @@ DN_API DN_Str8x32 DN_Str8x32FromU64(DN_U64 val, char separator) DN_USize temp_index = 0; // NOTE: Write the digits the first, up to [0, 2] digits that do not need a thousandth separator - DN_USize range_without_separator = temp.size % 3; + DN_USize range_without_separator = temp.count % 3; for (; temp_index < range_without_separator; temp_index++) - result.data[result.size++] = temp.data[temp_index]; + result.data[result.count++] = temp.data[temp_index]; // NOTE: Write the subsequent digits and every 3rd digit, add the seperator DN_USize digit_counter = 0; - for (; temp_index < temp.size; temp_index++, digit_counter++) { + for (; temp_index < temp.count; temp_index++, digit_counter++) { if (separator && temp_index && (digit_counter % 3 == 0)) - result.data[result.size++] = separator; - result.data[result.size++] = temp.data[temp_index]; + result.data[result.count++] = separator; + result.data[result.count++] = temp.data[temp_index]; } return result; } @@ -3070,19 +3068,19 @@ DN_API DN_Str8x32 DN_Str8x32FromU64(DN_U64 val, char separator) DN_API bool DN_Str8IsAll(DN_Str8 string, DN_Str8IsAllType is_all) { - bool result = string.size; + bool result = string.count; if (!result) return result; switch (is_all) { case DN_Str8IsAllType_Digits: { - for (DN_USize index = 0; result && index < string.size; index++) + for (DN_USize index = 0; result && index < string.count; index++) result = string.data[index] >= '0' && string.data[index] <= '9'; } break; case DN_Str8IsAllType_Hex: { DN_Str8 trimmed = DN_Str8TrimPrefix(string, DN_Str8Lit("0x"), DN_Str8EqCase_Insensitive); - for (DN_USize index = 0; result && index < trimmed.size; index++) { + for (DN_USize index = 0; result && index < trimmed.count; index++) { char ch = trimmed.data[index]; result = (ch >= '0' && ch <= '9') || (ch >= 'a' && ch <= 'f') || (ch >= 'A' && ch <= 'F'); } @@ -3094,19 +3092,19 @@ DN_API bool DN_Str8IsAll(DN_Str8 string, DN_Str8IsAllType is_all) DN_API char *DN_Str8End(DN_Str8 string) { - char *result = string.data + string.size; + char *result = string.data + string.count; return result; } -DN_API DN_Str8 DN_Str8Subset(DN_Str8 string, DN_USize offset, DN_USize size) +DN_API DN_Str8 DN_Str8Subset(DN_Str8 string, DN_USize offset, DN_USize count) { DN_Str8 result = DN_Str8FromPtr(string.data, 0); - if (string.size == 0) + if (string.count == 0) return result; - DN_USize capped_offset = DN_Min(offset, string.size); - DN_USize max_size = string.size - capped_offset; - DN_USize capped_size = DN_Min(size, max_size); + DN_USize capped_offset = DN_Min(offset, string.count); + DN_USize max_size = string.count - capped_offset; + DN_USize capped_size = DN_Min(count, max_size); result = DN_Str8FromPtr(string.data + capped_offset, capped_size); return result; } @@ -3126,19 +3124,19 @@ DN_API DN_Str8 DN_Str8NextLine(DN_Str8 string) DN_API DN_Str8BSplitResult DN_Str8BSplitArray(DN_Str8 string, DN_Str8 const *find, DN_USize find_size) { DN_Str8BSplitResult result = {}; - if (string.size == 0 || !find || find_size == 0) + if (string.count == 0 || !find || find_size == 0) return result; result.lhs = string; - for (DN_USize index = 0; !result.rhs.data && index < string.size; index++) { + for (DN_USize index = 0; !result.rhs.data && index < string.count; index++) { for (DN_USize find_index = 0; find_index < find_size; find_index++) { DN_Str8 find_item = find[find_index]; - DN_Str8 string_slice = DN_Str8Subset(string, index, find_item.size); + DN_Str8 string_slice = DN_Str8Subset(string, index, find_item.count); if (DN_Str8Eq(string_slice, find_item)) { result.input_index = find_index; - result.lhs.size = index; - result.rhs.data = string_slice.data + find_item.size; - result.rhs.size = string.size - (index + find_item.size); + result.lhs.count = index; + result.rhs.data = string_slice.data + find_item.count; + result.rhs.count = string.count - (index + find_item.count); break; } } @@ -3156,18 +3154,18 @@ DN_API DN_Str8BSplitResult DN_Str8BSplit(DN_Str8 string, DN_Str8 find) DN_API DN_Str8BSplitResult DN_Str8BSplitLastArray(DN_Str8 string, DN_Str8 const *find, DN_USize find_size) { DN_Str8BSplitResult result = {}; - if (string.size == 0 || !find || find_size == 0) + if (string.count == 0 || !find || find_size == 0) return result; result.lhs = string; - for (DN_USize index = string.size - 1; !result.rhs.data && index < string.size; index--) { + for (DN_USize index = string.count - 1; !result.rhs.data && index < string.count; index--) { for (DN_USize find_index = 0; find_index < find_size; find_index++) { DN_Str8 find_item = find[find_index]; - DN_Str8 string_slice = DN_Str8Subset(string, index, find_item.size); + DN_Str8 string_slice = DN_Str8Subset(string, index, find_item.count); if (DN_Str8Eq(string_slice, find_item)) { - result.lhs.size = index; - result.rhs.data = string_slice.data + find_item.size; - result.rhs.size = string.size - (index + find_item.size); + result.lhs.count = index; + result.rhs.data = string_slice.data + find_item.count; + result.rhs.count = string.count - (index + find_item.count); break; } } @@ -3185,7 +3183,7 @@ DN_API DN_Str8BSplitResult DN_Str8BSplitLast(DN_Str8 string, DN_Str8 find) DN_API DN_USize DN_Str8Split(DN_Str8 string, DN_Str8 delimiter, DN_Str8 *splits, DN_USize splits_count, DN_Str8SplitFlags flags) { DN_USize result = 0; // The number of splits in the actual string. - if (string.size == 0 || delimiter.size == 0 || delimiter.size <= 0) + if (string.count == 0 || delimiter.count == 0 || delimiter.count <= 0) return result; DN_Str8 it = string; @@ -3204,12 +3202,12 @@ DN_API DN_USize DN_Str8Split(DN_Str8 string, DN_Str8 delimiter, DN_Str8 *splits, it = sub_split.rhs; } - if (item.size || allow_empty_strings) { + if (item.count || allow_empty_strings) { if (splits && result < splits_count) splits[result] = item; result++; } - } while (it.size); + } while (it.count); return result; } @@ -3229,17 +3227,17 @@ DN_API DN_Str8SplitResult DN_Str8SplitArena(DN_Str8 string, DN_Str8 delimiter, D DN_API DN_Str8FindResult DN_Str8FindStr8Array(DN_Str8 string, DN_Str8 const *find, DN_USize find_size, DN_Str8EqCase eq_case) { DN_Str8FindResult result = {}; - for (DN_USize index = 0; !result.found && index < string.size; index++) { + for (DN_USize index = 0; !result.found && index < string.count; index++) { for (DN_USize find_index = 0; find_index < find_size; find_index++) { DN_Str8 find_item = find[find_index]; - DN_Str8 string_slice = DN_Str8Subset(string, index, find_item.size); + DN_Str8 string_slice = DN_Str8Subset(string, index, find_item.count); if (DN_Str8Eq(string_slice, find_item, eq_case)) { result.found = true; result.index = index; result.start_to_before_match = DN_Str8FromPtr(string.data, index); - result.match = DN_Str8FromPtr(string.data + index, find_item.size); - result.match_to_end_of_buffer = DN_Str8FromPtr(result.match.data, string.size - index); - result.after_match_to_end_of_buffer = DN_Str8Advance(result.match_to_end_of_buffer, find_item.size); + result.match = DN_Str8FromPtr(string.data + index, find_item.count); + result.match_to_end_of_buffer = DN_Str8FromPtr(result.match.data, string.count - index); + result.after_match_to_end_of_buffer = DN_Str8Advance(result.match_to_end_of_buffer, find_item.count); break; } } @@ -3256,7 +3254,7 @@ DN_API DN_Str8FindResult DN_Str8FindStr8(DN_Str8 string, DN_Str8 find, DN_Str8Eq DN_API DN_Str8FindResult DN_Str8Find(DN_Str8 string, DN_Str8FindFlag flags) { DN_Str8FindResult result = {}; - for (DN_USize index = 0; !result.found && index < string.size; index++) { + for (DN_USize index = 0; !result.found && index < string.count; index++) { result.found |= ((flags & DN_Str8FindFlag_Digit) && DN_CharIsDigit(string.data[index])); result.found |= ((flags & DN_Str8FindFlag_Alphabet) && DN_CharIsAlphabet(string.data[index])); result.found |= ((flags & DN_Str8FindFlag_Whitespace) && DN_CharIsWhitespace(string.data[index])); @@ -3265,7 +3263,7 @@ DN_API DN_Str8FindResult DN_Str8Find(DN_Str8 string, DN_Str8FindFlag flags) if (result.found) { result.index = index; result.match = DN_Str8FromPtr(string.data + index, 1); - result.match_to_end_of_buffer = DN_Str8FromPtr(result.match.data, string.size - index); + result.match_to_end_of_buffer = DN_Str8FromPtr(result.match.data, string.count - index); result.after_match_to_end_of_buffer = DN_Str8Advance(result.match_to_end_of_buffer, 1); } } @@ -3274,50 +3272,50 @@ DN_API DN_Str8FindResult DN_Str8Find(DN_Str8 string, DN_Str8FindFlag flags) DN_API DN_Str8 DN_Str8Segment(DN_Arena *arena, DN_Str8 src, DN_USize segment_size, char segment_char) { - if (!segment_size || src.size == 0) { + if (!segment_size || src.count == 0) { DN_Str8 result = DN_Str8FromStr8Arena(src, arena); return result; } - DN_USize segments = src.size / segment_size; - if (src.size % segment_size == 0) + DN_USize segments = src.count / segment_size; + if (src.count % segment_size == 0) segments--; DN_USize segment_counter = 0; - DN_Str8 result = DN_Str8AllocArena(src.size + segments, DN_ZMem_Yes, arena); + DN_Str8 result = DN_Str8AllocArena(src.count + segments, DN_ZMem_Yes, arena); DN_USize write_index = 0; - for (DN_ForIndexU(src_index, src.size)) { + for (DN_ForIndexU(src_index, src.count)) { result.data[write_index++] = src.data[src_index]; if ((src_index + 1) % segment_size == 0 && segment_counter < segments) { result.data[write_index++] = segment_char; segment_counter++; } - DN_AssertF(write_index <= result.size, "result.size=%zu, write_index=%zu", result.size, write_index); + DN_AssertF(write_index <= result.count, "result.count=%zu, write_index=%zu", result.count, write_index); } - DN_AssertF(write_index == result.size, "result.size=%zu, write_index=%zu", result.size, write_index); + DN_AssertF(write_index == result.count, "result.count=%zu, write_index=%zu", result.count, write_index); return result; } DN_API DN_Str8 DN_Str8ReverseSegment(DN_Arena *arena, DN_Str8 src, DN_USize segment_size, char segment_char) { - if (!segment_size || src.size == 0) { + if (!segment_size || src.count == 0) { DN_Str8 result = DN_Str8FromStr8Arena(src, arena); return result; } - DN_USize segments = src.size / segment_size; - if (src.size % segment_size == 0) + DN_USize segments = src.count / segment_size; + if (src.count % segment_size == 0) segments--; DN_USize write_counter = 0; DN_USize segment_counter = 0; - DN_Str8 result = DN_Str8AllocArena(src.size + segments, DN_ZMem_Yes, arena); - DN_USize write_index = result.size - 1; + DN_Str8 result = DN_Str8AllocArena(src.count + segments, DN_ZMem_Yes, arena); + DN_USize write_index = result.count - 1; DN_MSVC_WARNING_PUSH DN_MSVC_WARNING_DISABLE(6293) // NOTE: Ill-defined loop - for (DN_USize src_index = src.size - 1; src_index < src.size; src_index--) { + for (DN_USize src_index = src.count - 1; src_index < src.count; src_index--) { DN_MSVC_WARNING_POP result.data[write_index--] = src.data[src_index]; if (++write_counter % segment_size == 0 && segment_counter < segments) { @@ -3332,16 +3330,16 @@ DN_API DN_Str8 DN_Str8ReverseSegment(DN_Arena *arena, DN_Str8 src, DN_USize segm DN_API bool DN_Str8Eq(DN_Str8 lhs, DN_Str8 rhs, DN_Str8EqCase eq_case) { - if (lhs.size != rhs.size) + if (lhs.count != rhs.count) return false; bool result = true; switch (eq_case) { case DN_Str8EqCase_Sensitive: { - result = (DN_Memcmp(lhs.data, rhs.data, lhs.size) == 0); + result = (DN_Memcmp(lhs.data, rhs.data, lhs.count) == 0); } break; case DN_Str8EqCase_Insensitive: { - for (DN_USize index = 0; index < lhs.size && result; index++) + for (DN_USize index = 0; index < lhs.count && result; index++) result = (DN_CharToLower(lhs.data[index]) == DN_CharToLower(rhs.data[index])); } break; } @@ -3356,7 +3354,7 @@ DN_API bool DN_Str8EqInsensitive(DN_Str8 lhs, DN_Str8 rhs) DN_API bool DN_Str8StartsWith(DN_Str8 string, DN_Str8 prefix, DN_Str8EqCase eq_case) { - DN_Str8 substring = {string.data, DN_Min(prefix.size, string.size)}; + DN_Str8 substring = {string.data, DN_Min(prefix.count, string.count)}; bool result = DN_Str8Eq(substring, prefix, eq_case); return result; } @@ -3369,7 +3367,7 @@ DN_API bool DN_Str8StartsWithInsensitive(DN_Str8 string, DN_Str8 prefix) DN_API bool DN_Str8EndsWith(DN_Str8 string, DN_Str8 suffix, DN_Str8EqCase eq_case) { - DN_Str8 substring = {string.data + string.size - suffix.size, DN_Min(string.size, suffix.size)}; + DN_Str8 substring = {string.data + string.count - suffix.count, DN_Min(string.count, suffix.count)}; bool result = DN_Str8Eq(substring, suffix, eq_case); return result; } @@ -3383,7 +3381,7 @@ DN_API bool DN_Str8EndsWithInsensitive(DN_Str8 string, DN_Str8 suffix) DN_API bool DN_Str8HasChar(DN_Str8 string, char ch) { bool result = false; - for (DN_USize index = 0; !result && index < string.size; index++) + for (DN_USize index = 0; !result && index < string.count; index++) result = string.data[index] == ch; return result; } @@ -3392,8 +3390,8 @@ DN_API DN_Str8 DN_Str8TrimPrefix(DN_Str8 string, DN_Str8 prefix, DN_Str8EqCase e { DN_Str8 result = string; if (DN_Str8StartsWith(string, prefix, eq_case)) { - result.data += prefix.size; - result.size -= prefix.size; + result.data += prefix.count; + result.count -= prefix.count; } return result; } @@ -3408,7 +3406,7 @@ DN_API DN_Str8 DN_Str8TrimSuffix(DN_Str8 string, DN_Str8 suffix, DN_Str8EqCase e { DN_Str8 result = string; if (DN_Str8EndsWith(string, suffix, eq_case)) - result.size -= suffix.size; + result.count -= suffix.count; return result; } @@ -3422,11 +3420,11 @@ DN_API DN_Str8 DN_Str8TrimAround(DN_Str8 string, DN_Str8 trim_string) DN_API DN_Str8 DN_Str8TrimHeadWhitespace(DN_Str8 string) { DN_Str8 result = string; - if (string.size == 0) + if (string.count == 0) return result; char const *start = string.data; - char const *end = string.data + string.size; + char const *end = string.data + string.count; while (start < end && DN_CharIsWhitespace(start[0])) start++; @@ -3437,11 +3435,11 @@ DN_API DN_Str8 DN_Str8TrimHeadWhitespace(DN_Str8 string) DN_API DN_Str8 DN_Str8TrimTailWhitespace(DN_Str8 string) { DN_Str8 result = string; - if (string.size == 0) + if (string.count == 0) return result; char const *start = string.data; - char const *end = string.data + string.size; + char const *end = string.data + string.count; while (end > start && DN_CharIsWhitespace(end[-1])) end--; @@ -3459,7 +3457,7 @@ DN_API DN_Str8 DN_Str8TrimWhitespaceAround(DN_Str8 string) DN_API DN_Str8 DN_Str8TrimByteOrderMark(DN_Str8 string) { DN_Str8 result = string; - if (result.size == 0) + if (result.count == 0) return result; // TODO(dn): This is little endian @@ -3481,7 +3479,7 @@ DN_API DN_Str8 DN_Str8FileNameFromPath(DN_Str8 path) { DN_Str8 separators[] = {DN_Str8Lit("/"), DN_Str8Lit("\\")}; DN_Str8BSplitResult split = DN_Str8BSplitLastArray(path, separators, DN_ArrayCountU(separators)); - DN_Str8 result = split.rhs.size ? split.rhs : split.lhs; + DN_Str8 result = split.rhs.count ? split.rhs : split.lhs; return result; } @@ -3527,9 +3525,9 @@ DN_API DN_Str8 DN_Str8AppendFV(DN_Arena *arena, DN_Str8 string, char const *fmt, { // TODO: Calculate size and write into one buffer instead of 2 appends DN_Str8 append = DN_Str8FromFmtVArena(arena, fmt, args); - DN_Str8 result = DN_Str8AllocArena(string.size + append.size, DN_ZMem_No, arena); - DN_Memcpy(result.data, string.data, string.size); - DN_Memcpy(result.data + string.size, append.data, append.size); + DN_Str8 result = DN_Str8AllocArena(string.count + append.count, DN_ZMem_No, arena); + DN_Memcpy(result.data, string.data, string.count); + DN_Memcpy(result.data + string.count, append.data, append.count); return result; } @@ -3545,25 +3543,25 @@ DN_API DN_Str8 DN_Str8FillF(DN_Arena *arena, DN_USize count, char const *fmt, .. DN_API DN_Str8 DN_Str8FillFV(DN_Arena *arena, DN_USize count, char const *fmt, va_list args) { DN_Str8 fill = DN_Str8FromFmtVArena(arena, fmt, args); - DN_Str8 result = DN_Str8AllocArena(count * fill.size, DN_ZMem_No, arena); + DN_Str8 result = DN_Str8AllocArena(count * fill.count, DN_ZMem_No, arena); for (DN_USize index = 0; index < count; index++) { - void *dest = result.data + (index * fill.size); - DN_Memcpy(dest, fill.data, fill.size); + void *dest = result.data + (index * fill.count); + DN_Memcpy(dest, fill.data, fill.count); } return result; } -DN_API void DN_Str8Remove(DN_Str8 *string, DN_USize offset, DN_USize size) +DN_API void DN_Str8Remove(DN_Str8 *string, DN_USize offset, DN_USize count) { - if (!string || string->size) + if (!string || string->count) return; - char *end = string->data + string->size; + char *end = string->data + string->count; char *dest = DN_Min(string->data + offset, end); - char *src = DN_Min(string->data + offset + size, end); + char *src = DN_Min(string->data + offset + count, end); DN_USize bytes_to_move = end - src; DN_Memmove(dest, src, bytes_to_move); - string->size -= bytes_to_move; + string->count -= bytes_to_move; } DN_API DN_Str8TruncResult DN_Str8TruncMiddlePtr(DN_Str8 str8, DN_USize side_size, DN_Str8 truncator, char *dest, DN_USize dest_max) @@ -3571,34 +3569,34 @@ DN_API DN_Str8TruncResult DN_Str8TruncMiddlePtr(DN_Str8 str8, DN_USize side_size DN_Assert(side_size <= DN_USIZE_MAX / 2); if (dest) { // NOTE: If the user passes the dest buffer, we expect it to be sized correctly. - if ((side_size * 2) >= str8.size) { - DN_Assert(dest_max >= str8.size + 1 /*null*/); + if ((side_size * 2) >= str8.count) { + DN_Assert(dest_max >= str8.count + 1 /*null*/); } else { - DN_Assert(dest_max >= (2 * side_size + truncator.size) + 1 /*null*/); + DN_Assert(dest_max >= (2 * side_size + truncator.count) + 1 /*null*/); } } DN_Str8TruncResult result = {}; - if (str8.size <= (side_size * 2)) { - result.size_req = str8.size; + if (str8.count <= (side_size * 2)) { + result.count_req = str8.count; if (dest) { - DN_Memcpy(dest, str8.data, str8.size); - dest[str8.size] = 0; - result.str8 = DN_Str8FromPtr(dest, result.size_req); + DN_Memcpy(dest, str8.data, str8.count); + dest[str8.count] = 0; + result.str8 = DN_Str8FromPtr(dest, result.count_req); } return result; } DN_Str8 head = DN_Str8Subset(str8, 0, side_size); - DN_Str8 tail = DN_Str8Subset(str8, str8.size - side_size, side_size); + DN_Str8 tail = DN_Str8Subset(str8, str8.count - side_size, side_size); DN_USize dest_size = 0; if (dest) { DN_FmtAppendResult append_result = DN_FmtAppend(dest, &dest_size, dest_max, "%.*s%.*s%.*s", DN_Str8PrintFmt(head), DN_Str8PrintFmt(truncator), DN_Str8PrintFmt(tail)); result.str8 = append_result.str8; result.truncated = true; - result.size_req = result.str8.size; + result.count_req = result.str8.count; } else { - result.size_req = DN_FmtSize("%.*s%.*s%.*s", DN_Str8PrintFmt(head), DN_Str8PrintFmt(truncator), DN_Str8PrintFmt(tail)); + result.count_req = DN_FmtCount("%.*s%.*s%.*s", DN_Str8PrintFmt(head), DN_Str8PrintFmt(truncator), DN_Str8PrintFmt(tail)); result.truncated = true; } @@ -3608,15 +3606,15 @@ DN_API DN_Str8TruncResult DN_Str8TruncMiddlePtr(DN_Str8 str8, DN_USize side_size DN_API DN_Str8TruncResult DN_Str8TruncMiddle(DN_Str8 str8, DN_USize side_size, DN_Str8 truncator, DN_Arena *arena) { DN_Str8TruncResult trunc = DN_Str8TruncMiddlePtr(str8, side_size, truncator, nullptr, 0); - DN_Str8 dest = DN_Str8AllocArena(trunc.size_req, DN_ZMem_No, arena); - DN_Str8TruncResult result = DN_Str8TruncMiddlePtr(str8, side_size, truncator, dest.data, dest.size + 1); + DN_Str8 dest = DN_Str8AllocArena(trunc.count_req, DN_ZMem_No, arena); + DN_Str8TruncResult result = DN_Str8TruncMiddlePtr(str8, side_size, truncator, dest.data, dest.count + 1); return result; } DN_API DN_Str8 DN_Str8Lower(DN_Str8 string, DN_Arena *arena) { DN_Str8 result = DN_Str8FromStr8Arena(string, arena); - for (DN_ForIndexU(index, result.size)) + for (DN_ForIndexU(index, result.count)) result.data[index] = DN_CharToLower(result.data[index]); return result; } @@ -3624,7 +3622,7 @@ DN_API DN_Str8 DN_Str8Lower(DN_Str8 string, DN_Arena *arena) DN_API DN_Str8 DN_Str8Upper(DN_Str8 string, DN_Arena *arena) { DN_Str8 result = DN_Str8FromStr8Arena(string, arena); - for (DN_ForIndexU(index, result.size)) + for (DN_ForIndexU(index, result.count)) result.data[index] = DN_CharToUpper(result.data[index]); return result; } @@ -3637,18 +3635,18 @@ DN_API DN_Str8 DN_Str8Replace(DN_Str8 string, DN_Str8EqCase eq_case) { DN_Str8 result = {}; - if (string.size == 0 || find.size == 0 || find.size > string.size || find.size == 0 || string.size == 0) { + if (string.count == 0 || find.count == 0 || find.count > string.count || find.count == 0 || string.count == 0) { result = DN_Str8FromStr8Arena(string, arena); return result; } DN_TCScratch scratch = DN_TCScratchBeginArena(&arena, 1); DN_Str8Builder string_builder = DN_Str8BuilderFromArena(&scratch.arena); - DN_USize max = string.size - find.size; + DN_USize max = string.count - find.count; DN_USize head = start_index; for (DN_USize tail = head; tail <= max; tail++) { - DN_Str8 check = DN_Str8Subset(string, tail, find.size); + DN_Str8 check = DN_Str8Subset(string, tail, find.count); if (!DN_Str8Eq(check, find, eq_case)) continue; @@ -3664,15 +3662,15 @@ DN_API DN_Str8 DN_Str8Replace(DN_Str8 string, DN_Str8 range = DN_Str8Subset(string, head, (tail - head)); DN_Str8BuilderAppendRef(&string_builder, range); DN_Str8BuilderAppendRef(&string_builder, replace); - head = tail + find.size; - tail += find.size - 1; // NOTE: -1 since the for loop will post increment us past the end of the find string + head = tail + find.count; + tail += find.count - 1; // NOTE: -1 since the for loop will post increment us past the end of the find string } if (string_builder.string_size == 0) { // NOTE: No replacement possible, so we just do a full-copy result = DN_Str8FromStr8Arena(string, arena); } else { - DN_Str8 remainder = DN_Str8FromPtr(string.data + head, string.size - head); + DN_Str8 remainder = DN_Str8FromPtr(string.data + head, string.count - head); DN_Str8BuilderAppendRef(&string_builder, remainder); result = DN_Str8FromStr8BuilderArena(&string_builder, arena); } @@ -3697,9 +3695,9 @@ DN_API DN_Str8 DN_Str8PadNewLinesAllocator(DN_Str8 string, DN_Str8 pad_string, D DN_TCScratch scratch = DN_TCScratchBeginAllocator(&allocator, 1); DN_Str8Builder builder = DN_Str8BuilderFromArena(&scratch.arena); DN_Str8 it = string; - while (it.size) { + while (it.count) { DN_Str8BSplitResult split = DN_Str8BSplit(it, DN_Str8Lit("\n")); - DN_Str8BuilderAppendRef(&builder, DN_Str8FromPtr(split.lhs.data, split.lhs.size + 1)); + DN_Str8BuilderAppendRef(&builder, DN_Str8FromPtr(split.lhs.data, split.lhs.count + 1)); it = split.rhs; } @@ -3764,16 +3762,16 @@ DN_API DN_Str8 DN_Str8LineBreakAllocator(DN_Str8 src, DN_USize desired_width, DN char* start = src.data; char* end = src.data; DN_Str8 it = src; - while (it.size) { + while (it.count) { DN_Str8 splitters[] = {DN_Str8Lit(" "), DN_Str8Lit("\n")}; DN_Str8BSplitResult split = DN_Str8BSplitArray(it, splitters, DN_ArrayCountU(splitters)); DN_USize curr_line_length = end - start; // Handle explicit newlines in input if (split.input_index == 1 /*the newline*/) { - if (curr_line_length == 0 && split.lhs.size) + if (curr_line_length == 0 && split.lhs.count) start = split.lhs.data; - if (split.lhs.size) + if (split.lhs.count) end = DN_Str8End(split.lhs); DN_Str8BuilderAppendRef(&builder, DN_Str8FromPtr(start, end - start)); start = split.rhs.data; @@ -3783,7 +3781,7 @@ DN_API DN_Str8 DN_Str8LineBreakAllocator(DN_Str8 src, DN_USize desired_width, DN } // Skip empty segments (multiple spaces, leading/trailing spaces) - if (split.lhs.size == 0) { + if (split.lhs.count == 0) { it = split.rhs; continue; } @@ -3797,7 +3795,7 @@ DN_API DN_Str8 DN_Str8LineBreakAllocator(DN_Str8 src, DN_USize desired_width, DN } // Check if adding this word (plus separator space) would overflow - DN_USize combined_length = curr_line_length + 1 + split.lhs.size; + DN_USize combined_length = curr_line_length + 1 + split.lhs.count; if (combined_length > desired_width) { // Commit current line, start new line with current word DN_Str8BuilderAppendRef(&builder, DN_Str8FromPtr(start, end - start)); @@ -3816,7 +3814,7 @@ DN_API DN_Str8 DN_Str8LineBreakAllocator(DN_Str8 src, DN_USize desired_width, DN DN_Str8BuilderAppendRef(&builder, DN_Str8FromPtr(start, end - start)); } else { DN_Str8 it = src; - while (it.size) { + while (it.count) { DN_Str8 chunk = DN_Str8Subset(it, 0, desired_width); DN_Str8BuilderAppendRef(&builder, chunk); it = DN_Str8Advance(it, desired_width); @@ -3899,19 +3897,19 @@ DN_API DN_Str8FindResult DN_Str8FindStr8AVX512F(DN_Str8 string, DN_Str8 find) { // NOTE: Algorithm as described in http://0x80.pl/articles/simd-strfind.html DN_Str8FindResult result = {}; - if (string.size == 0 || find.size == 0 || find.size > string.size) + if (string.count == 0 || find.count == 0 || find.count > string.count) return result; __m512i const find_first_ch = _mm512_set1_epi8(find.data[0]); - __m512i const find_last_ch = _mm512_set1_epi8(find.data[find.size - 1]); + __m512i const find_last_ch = _mm512_set1_epi8(find.data[find.count - 1]); - DN_USize const search_size = string.size - find.size; + DN_USize const search_size = string.count - find.count; DN_USize simd_iterations = search_size / sizeof(__m512i); char const *ptr = string.data; while (simd_iterations--) { __m512i find_first_ch_block = _mm512_loadu_si512(ptr); - __m512i find_last_ch_block = _mm512_loadu_si512(ptr + find.size - 1); + __m512i find_last_ch_block = _mm512_loadu_si512(ptr + find.count - 1); // NOTE: AVX512F does not have a cmpeq so we use XOR to place a 0 bit // where matches are found. @@ -3955,25 +3953,25 @@ DN_API DN_Str8FindResult DN_Str8FindStr8AVX512F(DN_Str8 string, DN_Str8 find) uint64_t const lsb_zero_pos = _tzcnt_u64(zero_byte_mask); char const *base_ptr = ptr + (4 * lsb_zero_pos); - if (DN_Memcmp(base_ptr + 0, find.data, find.size) == 0) { + if (DN_Memcmp(base_ptr + 0, find.data, find.count) == 0) { result.found = true; result.index = base_ptr - string.data; - } else if (DN_Memcmp(base_ptr + 1, find.data, find.size) == 0) { + } else if (DN_Memcmp(base_ptr + 1, find.data, find.count) == 0) { result.found = true; result.index = base_ptr - string.data + 1; - } else if (DN_Memcmp(base_ptr + 2, find.data, find.size) == 0) { + } else if (DN_Memcmp(base_ptr + 2, find.data, find.count) == 0) { result.found = true; result.index = base_ptr - string.data + 2; - } else if (DN_Memcmp(base_ptr + 3, find.data, find.size) == 0) { + } else if (DN_Memcmp(base_ptr + 3, find.data, find.count) == 0) { result.found = true; result.index = base_ptr - string.data + 3; } if (result.found) { result.start_to_before_match = DN_Str8FromPtr(string.data, result.index); - result.match = DN_Str8FromPtr(string.data + result.index, find.size); - result.match_to_end_of_buffer = DN_Str8FromPtr(result.match.data, string.size - result.index); - result.after_match_to_end_of_buffer = DN_Str8Advance(result.match_to_end_of_buffer, find.size); + result.match = DN_Str8FromPtr(string.data + result.index, find.count); + result.match_to_end_of_buffer = DN_Str8FromPtr(result.match.data, string.count - result.index); + result.after_match_to_end_of_buffer = DN_Str8Advance(result.match_to_end_of_buffer, find.count); return result; } @@ -3983,15 +3981,15 @@ DN_API DN_Str8FindResult DN_Str8FindStr8AVX512F(DN_Str8 string, DN_Str8 find) ptr += sizeof(__m512i); } - for (DN_USize index = ptr - string.data; index < string.size; index++) { - DN_Str8 string_slice = DN_Str8Subset(string, index, find.size); + for (DN_USize index = ptr - string.data; index < string.count; index++) { + DN_Str8 string_slice = DN_Str8Subset(string, index, find.count); if (DN_Str8Eq(string_slice, find)) { result.found = true; result.index = index; result.start_to_before_match = DN_Str8FromPtr(string.data, index); - result.match = DN_Str8FromPtr(string.data + index, find.size); - result.match_to_end_of_buffer = DN_Str8FromPtr(result.match.data, string.size - index); - result.after_match_to_end_of_buffer = DN_Str8Advance(result.match_to_end_of_buffer, find.size); + result.match = DN_Str8FromPtr(string.data + index, find.count); + result.match_to_end_of_buffer = DN_Str8FromPtr(result.match.data, string.count - index); + result.after_match_to_end_of_buffer = DN_Str8Advance(result.match_to_end_of_buffer, find.count); return result; } } @@ -4003,20 +4001,20 @@ DN_API DN_Str8FindResult DN_Str8FindLastStr8AVX512F(DN_Str8 string, DN_Str8 find { // NOTE: Algorithm as described in http://0x80.pl/articles/simd-strfind.html DN_Str8FindResult result = {}; - if (string.size == 0 || find.size == 0 || find.size > string.size) + if (string.count == 0 || find.count == 0 || find.count > string.count) return result; __m512i const find_first_ch = _mm512_set1_epi8(find.data[0]); - __m512i const find_last_ch = _mm512_set1_epi8(find.data[find.size - 1]); + __m512i const find_last_ch = _mm512_set1_epi8(find.data[find.count - 1]); - DN_USize const search_size = string.size - find.size; + DN_USize const search_size = string.count - find.count; DN_USize simd_iterations = search_size / sizeof(__m512i); char const *ptr = string.data + search_size + 1; while (simd_iterations--) { ptr -= sizeof(__m512i); __m512i find_first_ch_block = _mm512_loadu_si512(ptr); - __m512i find_last_ch_block = _mm512_loadu_si512(ptr + find.size - 1); + __m512i find_last_ch_block = _mm512_loadu_si512(ptr + find.count - 1); // NOTE: AVX512F does not have a cmpeq so we use XOR to place a 0 bit // where matches are found. @@ -4060,24 +4058,24 @@ DN_API DN_Str8FindResult DN_Str8FindLastStr8AVX512F(DN_Str8 string, DN_Str8 find uint64_t const lsb_zero_pos = _tzcnt_u64(zero_byte_mask); char const *base_ptr = ptr + (4 * lsb_zero_pos); - if (DN_Memcmp(base_ptr + 0, find.data, find.size) == 0) { + if (DN_Memcmp(base_ptr + 0, find.data, find.count) == 0) { result.found = true; result.index = base_ptr - string.data; - } else if (DN_Memcmp(base_ptr + 1, find.data, find.size) == 0) { + } else if (DN_Memcmp(base_ptr + 1, find.data, find.count) == 0) { result.found = true; result.index = base_ptr - string.data + 1; - } else if (DN_Memcmp(base_ptr + 2, find.data, find.size) == 0) { + } else if (DN_Memcmp(base_ptr + 2, find.data, find.count) == 0) { result.found = true; result.index = base_ptr - string.data + 2; - } else if (DN_Memcmp(base_ptr + 3, find.data, find.size) == 0) { + } else if (DN_Memcmp(base_ptr + 3, find.data, find.count) == 0) { result.found = true; result.index = base_ptr - string.data + 3; } if (result.found) { result.start_to_before_match = DN_Str8FromPtr(string.data, result.index); - result.match = DN_Str8FromPtr(string.data + result.index, find.size); - result.match_to_end_of_buffer = DN_Str8FromPtr(result.match.data, string.size - result.index); + result.match = DN_Str8FromPtr(string.data + result.index, find.count); + result.match_to_end_of_buffer = DN_Str8FromPtr(result.match.data, string.count - result.index); return result; } @@ -4085,14 +4083,14 @@ DN_API DN_Str8FindResult DN_Str8FindLastStr8AVX512F(DN_Str8 string, DN_Str8 find } } - for (DN_USize index = ptr - string.data - 1; index < string.size; index--) { - DN_Str8 string_slice = DN_Str8Subset(string, index, find.size); + for (DN_USize index = ptr - string.data - 1; index < string.count; index--) { + DN_Str8 string_slice = DN_Str8Subset(string, index, find.count); if (DN_Str8Eq(string_slice, find)) { result.found = true; result.index = index; result.start_to_before_match = DN_Str8FromPtr(string.data, index); - result.match = DN_Str8FromPtr(string.data + index, find.size); - result.match_to_end_of_buffer = DN_Str8FromPtr(result.match.data, string.size - index); + result.match = DN_Str8FromPtr(string.data + index, find.count); + result.match_to_end_of_buffer = DN_Str8FromPtr(result.match.data, string.count - index); return result; } } @@ -4106,8 +4104,8 @@ DN_API DN_Str8BSplitResult DN_Str8BSplitAVX512F(DN_Str8 string, DN_Str8 find) DN_Str8FindResult find_result = DN_Str8FindAVX512F(string, find); if (find_result.found) { result.lhs.data = string.data; - result.lhs.size = find_result.index; - result.rhs = DN_Str8Advance(find_result.match_to_end_of_buffer, find.size); + result.lhs.count = find_result.index; + result.rhs = DN_Str8Advance(find_result.match_to_end_of_buffer, find.count); } else { result.lhs = string; } @@ -4121,8 +4119,8 @@ DN_API DN_Str8BSplitResult DN_Str8BSplitLastAVX512F(DN_Str8 string, DN_Str8 find DN_Str8FindResult find_result = DN_Str8FindLastAVX512F(string, find); if (find_result.found) { result.lhs.data = string.data; - result.lhs.size = find_result.index; - result.rhs = DN_Str8Advance(find_result.match_to_end_of_buffer, find.size); + result.lhs.count = find_result.index; + result.rhs = DN_Str8Advance(find_result.match_to_end_of_buffer, find.count); } else { result.lhs = string; } @@ -4133,20 +4131,20 @@ DN_API DN_Str8BSplitResult DN_Str8BSplitLastAVX512F(DN_Str8 string, DN_Str8 find DN_API DN_USize DN_Str8SplitAVX512F(DN_Str8 string, DN_Str8 delimiter, DN_Str8 *splits, DN_USize splits_count, DN_Str8SplitFlags flags) { DN_USize result = 0; // The number of splits in the actual string. - if (string.size == 0 || delimiter.size == 0 || delimiter.size <= 0) + if (string.count == 0 || delimiter.count == 0 || delimiter.count <= 0) return result; DN_Str8BSplitResult split = {}; DN_Str8 first = string; do { split = DN_Str8BSplitAVX512F(first, delimiter); - if (split.lhs.size || DN_BitIsNotSet(flags, DN_Str8SplitFlags_ExcludeEmptyStrings)) { + if (split.lhs.count || DN_BitIsNotSet(flags, DN_Str8SplitFlags_ExcludeEmptyStrings)) { if (splits && result < splits_count) splits[result] = split.lhs; result++; } first = split.rhs; - } while (first.size); + } while (first.count); return result; } @@ -4173,9 +4171,9 @@ DN_API DN_Str8 DN_Str8SliceRender(DN_Str8Slice slice, DN_Str8 separator, DN_Aren DN_USize total_size = 0; for (DN_USize index = 0; index < slice.count; index++) { if (index) - total_size += separator.size; + total_size += separator.count; DN_Str8 item = slice.data[index]; - total_size += item.size; + total_size += item.count; } result = DN_Str8AllocArena(total_size, DN_ZMem_No, arena); @@ -4183,12 +4181,12 @@ DN_API DN_Str8 DN_Str8SliceRender(DN_Str8Slice slice, DN_Str8 separator, DN_Aren DN_USize write_index = 0; for (DN_USize index = 0; index < slice.count; index++) { if (index) { - DN_Memcpy(result.data + write_index, separator.data, separator.size); - write_index += separator.size; + DN_Memcpy(result.data + write_index, separator.data, separator.count); + write_index += separator.count; } DN_Str8 item = slice.data[index]; - DN_Memcpy(result.data + write_index, item.data, item.size); - write_index += item.size; + DN_Memcpy(result.data + write_index, item.data, item.count); + write_index += item.count; } } @@ -4205,8 +4203,8 @@ DN_API int DN_Str8CompareNatural(DN_Str8 lhs, DN_Str8 rhs, DN_Str8EqCase eq_case { const char *lhs_it = lhs.data; const char *rhs_it = rhs.data; - const char *lhs_end = lhs.data + lhs.size; - const char *rhs_end = rhs.data + rhs.size; + const char *lhs_end = lhs.data + lhs.count; + const char *rhs_end = rhs.data + rhs.count; while (lhs_it < lhs_end && rhs_it < rhs_end) { // NOTE: Skip leading spaces @@ -4267,8 +4265,8 @@ DN_API int DN_Str8CompareLexicographic(DN_Str8 lhs, DN_Str8 rhs, DN_Str8EqCase e { const char *lhs_it = lhs.data; const char *rhs_it = rhs.data; - const char *lhs_end = lhs.data + lhs.size; - const char *rhs_end = rhs.data + rhs.size; + const char *lhs_end = lhs.data + lhs.count; + const char *rhs_end = rhs.data + rhs.count; while (lhs_it < lhs_end && rhs_it < rhs_end) { char lhs_ch = *lhs_it; @@ -4286,9 +4284,9 @@ DN_API int DN_Str8CompareLexicographic(DN_Str8 lhs, DN_Str8 rhs, DN_Str8EqCase e } // NOTE: One string is prefix of other; shorter comes first - if (lhs.size < rhs.size) + if (lhs.count < rhs.count) return -1; - if (rhs.size < lhs.size) + if (rhs.count < lhs.count) return 1; return 0; } @@ -4296,9 +4294,9 @@ DN_API int DN_Str8CompareLexicographic(DN_Str8 lhs, DN_Str8 rhs, DN_Str8EqCase e DN_API bool DN_Str16Eq(DN_Str16 lhs, DN_Str16 rhs) { - if (lhs.size != rhs.size) + if (lhs.count != rhs.count) return false; - bool result = (DN_Memcmp(lhs.data, rhs.data, lhs.size) == 0); + bool result = (DN_Memcmp(lhs.data, rhs.data, lhs.count) == 0); return result; } @@ -4312,9 +4310,9 @@ DN_API DN_Str16 DN_Str16SliceRender(DN_Str16Slice slice, DN_Str16 separator, DN_ DN_USize total_size = 0; for (DN_USize index = 0; index < slice.count; index++) { if (index) - total_size += separator.size; + total_size += separator.count; DN_Str16 item = slice.data[index]; - total_size += item.size; + total_size += item.count; } result = {DN_ArenaNewArray(arena, wchar_t, total_size + 1, DN_ZMem_No), total_size}; @@ -4322,12 +4320,12 @@ DN_API DN_Str16 DN_Str16SliceRender(DN_Str16Slice slice, DN_Str16 separator, DN_ DN_USize write_index = 0; for (DN_USize index = 0; index < slice.count; index++) { if (index) { - DN_Memcpy(result.data + write_index, separator.data, separator.size * sizeof(result.data[0])); - write_index += separator.size; + DN_Memcpy(result.data + write_index, separator.data, separator.count * sizeof(result.data[0])); + write_index += separator.count; } DN_Str16 item = slice.data[index]; - DN_Memcpy(result.data + write_index, item.data, item.size * sizeof(result.data[0])); - write_index += item.size; + DN_Memcpy(result.data + write_index, item.data, item.count * sizeof(result.data[0])); + write_index += item.count; } } @@ -4348,17 +4346,17 @@ DN_API DN_Str8Builder DN_Str8BuilderFromArena(DN_Arena *arena) return result; } -DN_API DN_Str8Builder DN_Str8BuilderFromStr8PtrRef(DN_Arena *arena, DN_Str8 const *strings, DN_USize size) +DN_API DN_Str8Builder DN_Str8BuilderFromStr8PtrRef(DN_Arena *arena, DN_Str8 const *strings, DN_USize count) { DN_Str8Builder result = DN_Str8BuilderFromArena(arena); - DN_Str8BuilderAppendArrayRef(&result, strings, size); + DN_Str8BuilderAppendArrayRef(&result, strings, count); return result; } -DN_API DN_Str8Builder DN_Str8BuilderFromStr8PtrCopy(DN_Arena *arena, DN_Str8 const *strings, DN_USize size) +DN_API DN_Str8Builder DN_Str8BuilderFromStr8PtrCopy(DN_Arena *arena, DN_Str8 const *strings, DN_USize count) { DN_Str8Builder result = DN_Str8BuilderFromArena(arena); - DN_Str8BuilderAppendArrayCopy(&result, strings, size); + DN_Str8BuilderAppendArrayCopy(&result, strings, count); return result; } @@ -4369,21 +4367,21 @@ DN_API DN_Str8Builder DN_Str8BuilderFromBuilder(DN_Arena *arena, DN_Str8Builder return result; } -DN_API bool DN_Str8BuilderAddArrayRef(DN_Str8Builder *builder, DN_Str8 const *strings, DN_USize size, DN_Str8BuilderAdd add) +DN_API bool DN_Str8BuilderAddArrayRef(DN_Str8Builder *builder, DN_Str8 const *strings, DN_USize count, DN_Str8BuilderAdd add) { if (!builder) return false; - if (!strings || size <= 0) + if (!strings || count <= 0) return true; // NOTE: Allocate the links - DN_Str8Link *links = DN_ArenaNewArrayNoZ(builder->arena, DN_Str8Link, size); + DN_Str8Link *links = DN_ArenaNewArrayNoZ(builder->arena, DN_Str8Link, count); if (!links) return false; if (add == DN_Str8BuilderAdd_Append) { - for (DN_ForIndexU(index, size)) { + for (DN_ForIndexU(index, count)) { DN_Str8 string = strings[index]; DN_Str8Link *link = links + index; link->string = string; @@ -4394,13 +4392,13 @@ DN_API bool DN_Str8BuilderAddArrayRef(DN_Str8Builder *builder, DN_Str8 const *st builder->head = link; builder->tail = link; builder->count++; - builder->string_size += string.size; + builder->string_size += string.count; } } else { DN_Assert(add == DN_Str8BuilderAdd_Prepend); DN_MSVC_WARNING_PUSH DN_MSVC_WARNING_DISABLE(6293) // NOTE: Ill-defined loop - for (DN_USize index = size - 1; index < size; index--) { + for (DN_USize index = count - 1; index < count; index--) { DN_MSVC_WARNING_POP DN_Str8 string = strings[index]; DN_Str8Link *link = links + index; @@ -4410,33 +4408,33 @@ DN_API bool DN_Str8BuilderAddArrayRef(DN_Str8Builder *builder, DN_Str8 const *st if (!builder->tail) builder->tail = link; builder->count++; - builder->string_size += string.size; + builder->string_size += string.count; } } return true; } -DN_API bool DN_Str8BuilderAddArrayCopy(DN_Str8Builder *builder, DN_Str8 const *strings, DN_USize size, DN_Str8BuilderAdd add) +DN_API bool DN_Str8BuilderAddArrayCopy(DN_Str8Builder *builder, DN_Str8 const *strings, DN_USize count, DN_Str8BuilderAdd add) { if (!builder) return false; - if (!strings || size <= 0) + if (!strings || count <= 0) return true; bool result = true; DN_U64 arena_p = DN_MemListPos(builder->arena->mem); - DN_Str8 *strings_copy = DN_ArenaNewArrayNoZ(builder->arena, DN_Str8, size); - for (DN_ForIndexU(index, size)) { + DN_Str8 *strings_copy = DN_ArenaNewArrayNoZ(builder->arena, DN_Str8, count); + for (DN_ForIndexU(index, count)) { strings_copy[index] = DN_Str8FromStr8Arena(strings[index], builder->arena); - if (strings_copy[index].size != strings[index].size) { + if (strings_copy[index].count != strings[index].count) { result = false; break; } } if (result) - result = DN_Str8BuilderAddArrayRef(builder, strings_copy, size, add); + result = DN_Str8BuilderAddArrayRef(builder, strings_copy, count, add); else DN_MemListPopTo(builder->arena->mem, arena_p); return result; @@ -4473,16 +4471,16 @@ DN_API bool DN_Str8BuilderAppendF(DN_Str8Builder *builder, DN_FMT_ATTRIB char co return result; } -DN_API bool DN_Str8BuilderAppendBytesRef(DN_Str8Builder *builder, void const *ptr, DN_USize size) +DN_API bool DN_Str8BuilderAppendBytesRef(DN_Str8Builder *builder, void const *ptr, DN_USize count) { - DN_Str8 input = DN_Str8FromPtr(ptr, size); + DN_Str8 input = DN_Str8FromPtr(ptr, count); bool result = DN_Str8BuilderAppendRef(builder, input); return result; } -DN_API bool DN_Str8BuilderAppendBytesCopy(DN_Str8Builder *builder, void const *ptr, DN_USize size) +DN_API bool DN_Str8BuilderAppendBytesCopy(DN_Str8Builder *builder, void const *ptr, DN_USize count) { - DN_Str8 input = DN_Str8FromPtr(ptr, size); + DN_Str8 input = DN_Str8FromPtr(ptr, count); bool result = DN_Str8BuilderAppendCopy(builder, input); return result; } @@ -4508,7 +4506,7 @@ static bool DN_Str8BuilderAppendBuilder_(DN_Str8Builder *dest, DN_Str8Builder co if (copy) { link->string = DN_Str8FromStr8Arena(it->string, &arena); - if (link->string.size != it->string.size) { + if (link->string.count != it->string.count) { result = false; break; } @@ -4573,7 +4571,7 @@ DN_API bool DN_Str8BuilderErase(DN_Str8Builder *builder, DN_Str8 string) for (DN_Str8Link **it = &builder->head; *it; it = &((*it)->next)) { if (DN_Str8Eq((*it)->string, string)) { *it = (*it)->next; - builder->string_size -= string.size; + builder->string_size -= string.count; builder->count -= 1; return true; } @@ -4599,23 +4597,23 @@ DN_API DN_Str8 DN_Str8FromStr8BuilderDelimitAllocator(DN_Str8Builder const *buil if (!builder || builder->string_size <= 0 || builder->count <= 0) return result; - DN_USize size_for_delimiter = delimiter.size ? ((builder->count - 1) * delimiter.size) : 0; - result = DN_Str8AllocAllocator(builder->string_size + size_for_delimiter, DN_ZMem_No, allocator); + DN_USize count_for_delimiter = delimiter.count ? ((builder->count - 1) * delimiter.count) : 0; + result = DN_Str8AllocAllocator(builder->string_size + count_for_delimiter, DN_ZMem_No, allocator); if (!result.data) return result; DN_USize write_count = 0; for (DN_Str8Link *link = builder->head; link; link = link->next) { - DN_Memcpy(result.data + write_count, link->string.data, link->string.size); - write_count += link->string.size; - if (link->next && delimiter.size) { - DN_Memcpy(result.data + write_count, delimiter.data, delimiter.size); - write_count += delimiter.size; + DN_Memcpy(result.data + write_count, link->string.data, link->string.count); + write_count += link->string.count; + if (link->next && delimiter.count) { + DN_Memcpy(result.data + write_count, delimiter.data, delimiter.count); + write_count += delimiter.count; } } result.data[write_count] = 0; - DN_Assert(write_count == builder->string_size + size_for_delimiter); + DN_Assert(write_count == builder->string_size + count_for_delimiter); return result; } @@ -4671,23 +4669,23 @@ DN_API DN_UTF8DecodeResult DN_UTF8Decode(DN_Str8 stream) { DN_UTF8DecodeResult result = {}; result.remaining = stream; - if (stream.size <= 0) + if (stream.count <= 0) return result; DN_U8 b0 = DN_Cast(DN_U8)stream.data[0]; - DN_U8 b1 = DN_Cast(DN_U8)(stream.size >= 2 ? stream.data[1] : 0); - DN_U8 b2 = DN_Cast(DN_U8)(stream.size >= 3 ? stream.data[2] : 0); - DN_U8 b3 = DN_Cast(DN_U8)(stream.size >= 4 ? stream.data[3] : 0); + DN_U8 b1 = DN_Cast(DN_U8)(stream.count >= 2 ? stream.data[1] : 0); + DN_U8 b2 = DN_Cast(DN_U8)(stream.count >= 3 ? stream.data[2] : 0); + DN_U8 b3 = DN_Cast(DN_U8)(stream.count >= 4 ? stream.data[3] : 0); if ((b0 & 0b1000'0000) == 0) { result.codepoint = b0; result.success = true; - result.remaining = DN_Str8FromPtr(stream.data + 1, stream.size - 1); + result.remaining = DN_Str8FromPtr(stream.data + 1, stream.count - 1); return result; } if ((b0 & 0b1110'0000) == 0b1100'0000) { - if (stream.size < 2) + if (stream.count < 2) return result; if ((b1 & 0b1100'0000) != 0b1000'0000) return result; @@ -4696,12 +4694,12 @@ DN_API DN_UTF8DecodeResult DN_UTF8Decode(DN_Str8 stream) return result; result.codepoint = cp; result.success = true; - result.remaining = DN_Str8FromPtr(stream.data + 2, stream.size - 2); + result.remaining = DN_Str8FromPtr(stream.data + 2, stream.count - 2); return result; } if ((b0 & 0b1111'0000) == 0b1110'0000) { - if (stream.size < 3) + if (stream.count < 3) return result; if ((b1 & 0b1100'0000) != 0b1000'0000) return result; @@ -4712,12 +4710,12 @@ DN_API DN_UTF8DecodeResult DN_UTF8Decode(DN_Str8 stream) return result; result.codepoint = cp; result.success = true; - result.remaining = DN_Str8FromPtr(stream.data + 3, stream.size - 3); + result.remaining = DN_Str8FromPtr(stream.data + 3, stream.count - 3); return result; } if ((b0 & 0b1111'1000) == 0b1111'0000) { - if (stream.size < 4) + if (stream.count < 4) return result; if ((b1 & 0b1100'0000) != 0b1000'0000) return result; @@ -4733,7 +4731,7 @@ DN_API DN_UTF8DecodeResult DN_UTF8Decode(DN_Str8 stream) return result; result.codepoint = cp; result.success = true; - result.remaining = DN_Str8FromPtr(stream.data + 4, stream.size - 4); + result.remaining = DN_Str8FromPtr(stream.data + 4, stream.count - 4); return result; } @@ -4812,7 +4810,7 @@ DN_API DN_USize DN_BytesFromHex(DN_Str8 hex, void *dest, DN_USize dest_count) { DN_Str8 hex_trimmed = DN_Str8TrimHexPrefix(hex); DN_USize result = 0; - if (hex_trimmed.size > (dest_count * 2)) + if (hex_trimmed.count > (dest_count * 2)) return result; DN_U8 *ptr = DN_Cast(DN_U8 *) dest; @@ -4820,7 +4818,7 @@ DN_API DN_USize DN_BytesFromHex(DN_Str8 hex, void *dest, DN_USize dest_count) // NOTE: We are given an odd-sized hex string e.g.: 'F' instead of '0F', we 'left-pad' the parser // and support reading the single nibble as 'F' - if (hex_trimmed.size % 2 != 0) { + if (hex_trimmed.count % 2 != 0) { DN_U8 nibble0 = 0; DN_U8 nibble1 = DN_U8FromHexNibble(hex_trimmed.data[index++]); if (nibble1 == 0xFF) @@ -4830,7 +4828,7 @@ DN_API DN_USize DN_BytesFromHex(DN_Str8 hex, void *dest, DN_USize dest_count) } // NOTE: Parse the rest of the hex which is in byte pairs - for (; index < hex_trimmed.size; index += 2) { + for (; index < hex_trimmed.count; index += 2) { DN_U8 nibble0 = DN_U8FromHexNibble(hex_trimmed.data[index + 0]); DN_U8 nibble1 = DN_U8FromHexNibble(hex_trimmed.data[index + 1]); if (nibble0 == 0xFF || nibble1 == 0xFF) @@ -4843,7 +4841,7 @@ DN_API DN_USize DN_BytesFromHex(DN_Str8 hex, void *dest, DN_USize dest_count) DN_API DN_Str8 DN_BytesFromHexArena(DN_Str8 hex, DN_Arena *arena) { - DN_Str8 result = DN_BytesFromHexPtrArena(hex.data, hex.size, arena); + DN_Str8 result = DN_BytesFromHexPtrArena(hex.data, hex.count, arena); return result; } @@ -4856,22 +4854,22 @@ DN_API DN_USize DN_BytesFromHexPtr(char const *hex, DN_USize hex_count, void *de DN_API DN_Str8 DN_BytesFromHexPtrArena(char const *hex, DN_USize hex_count, DN_Arena *arena) { DN_Str8 hex_trimmed = DN_Str8TrimHexPrefix(DN_Str8FromPtr(hex, hex_count)); - DN_Assert(hex_trimmed.size % 2 == 0); + DN_Assert(hex_trimmed.count % 2 == 0); DN_Str8 result = {}; - result.data = DN_ArenaNewArray(arena, char, hex_trimmed.size / 2, DN_ZMem_No); + result.data = DN_ArenaNewArray(arena, char, hex_trimmed.count / 2, DN_ZMem_No); if (result.data) - result.size = DN_BytesFromHex(hex_trimmed, result.data, hex_trimmed.size / 2); + result.count = DN_BytesFromHex(hex_trimmed, result.data, hex_trimmed.count / 2); return result; } DN_API DN_Str8 DN_BytesFromHexPtrPool(char const *hex, DN_USize hex_count, DN_Pool *pool) { DN_Str8 hex_trimmed = DN_Str8TrimHexPrefix(DN_Str8FromPtr(hex, hex_count)); - DN_Assert(hex_trimmed.size % 2 == 0); + DN_Assert(hex_trimmed.count % 2 == 0); DN_Str8 result = {}; - result.data = DN_PoolNewArray(pool, char, hex_trimmed.size / 2); + result.data = DN_PoolNewArray(pool, char, hex_trimmed.count / 2); if (result.data) - result.size = DN_BytesFromHex(hex_trimmed, result.data, hex_trimmed.size / 2); + result.count = DN_BytesFromHex(hex_trimmed, result.data, hex_trimmed.count / 2); return result; } @@ -4880,7 +4878,7 @@ DN_API DN_U8x16 DN_BytesFromHex32Ptr(char const *hex, DN_USize hex_count) { DN_U8x16 result = {}; DN_Str8 hex_trimmed = DN_Str8TrimHexPrefix(DN_Str8FromPtr(hex, hex_count)); - DN_Assert(hex_trimmed.size / 2 == sizeof result.data); + DN_Assert(hex_trimmed.count / 2 == sizeof result.data); DN_USize bytes_written = DN_BytesFromHex(hex_trimmed, result.data, sizeof result.data); DN_Assert(bytes_written == sizeof result.data); return result; @@ -4890,7 +4888,7 @@ DN_API DN_U8x32 DN_BytesFromHex64Ptr(char const *hex, DN_USize hex_count) { DN_U8x32 result = {}; DN_Str8 hex_trimmed = DN_Str8TrimHexPrefix(DN_Str8FromPtr(hex, hex_count)); - DN_Assert(hex_trimmed.size / 2 == sizeof result.data); + DN_Assert(hex_trimmed.count / 2 == sizeof result.data); DN_USize bytes_written = DN_BytesFromHex(hex_trimmed, result.data, sizeof result.data); DN_Assert(bytes_written == sizeof result.data); return result; @@ -4899,10 +4897,10 @@ DN_API DN_U8x32 DN_BytesFromHex64Ptr(char const *hex, DN_USize hex_count) DN_API DN_HexU64 DN_HexFromU64(DN_U64 value, DN_HexFromU64Type type) { DN_HexU64 result = {}; - DN_USize size = DN_HexFromPtrBytes(&value, sizeof(value), result.data, sizeof(result.data), DN_TrimLeadingZero_No); - result.size = DN_SaturateCastUSizeToU8(size); + DN_USize count = DN_HexFromPtrBytes(&value, sizeof(value), result.data, sizeof(result.data), DN_TrimLeadingZero_No); + result.count = DN_SaturateCastUSizeToU8(count); if (type == DN_HexFromU64Type_Uppercase) { - for (DN_USize index = 0; index < result.size; index++) + for (DN_USize index = 0; index < result.count; index++) result.data[index] = DN_CharToUpper(result.data[index]); } return result; @@ -4946,24 +4944,24 @@ DN_API DN_Str8 DN_HexFromPtrBytesArena(void const *bytes, DN_USize bytes_count, if (bytes_count) { result.data = DN_ArenaNewArray(arena, char, bytes_count * 2, DN_ZMem_No); if (result.data) - result.size = DN_HexFromPtrBytes(bytes, bytes_count, result.data, bytes_count * 2, trim_leading_z); + result.count = DN_HexFromPtrBytes(bytes, bytes_count, result.data, bytes_count * 2, trim_leading_z); } return result; } DN_API DN_USize DN_HexFromStr8Bytes(DN_Str8 bytes, void *hex, DN_USize hex_count, DN_TrimLeadingZero trim_leading_z) { - DN_USize result = DN_HexFromPtrBytes(bytes.data, bytes.size, hex, hex_count, trim_leading_z); + DN_USize result = DN_HexFromPtrBytes(bytes.data, bytes.count, hex, hex_count, trim_leading_z); return result; } DN_API DN_Str8 DN_HexFromStr8BytesArena(DN_Str8 bytes, DN_Arena *arena, DN_TrimLeadingZero trim_leading_z) { DN_Str8 result = {}; - if (bytes.size) { - result.data = DN_ArenaNewArray(arena, char, bytes.size * 2, DN_ZMem_No); + if (bytes.count) { + result.data = DN_ArenaNewArray(arena, char, bytes.count * 2, DN_ZMem_No); if (result.data) - result.size = DN_HexFromStr8Bytes(bytes, result.data, bytes.size * 2, trim_leading_z); + result.count = DN_HexFromStr8Bytes(bytes, result.data, bytes.count * 2, trim_leading_z); } return result; } @@ -4972,8 +4970,8 @@ DN_API DN_Hex32 DN_Hex32FromPtr16b(void const *bytes, DN_USize bytes_count, DN_T { DN_Hex32 result = {}; DN_Assert(bytes_count * 2 == sizeof result.data - 1); - result.size = DN_HexFromPtrBytes(bytes, bytes_count, result.data, sizeof result.data, trim_leading_z); - DN_Assert(result.size <= sizeof result.data - 1); + result.count = DN_HexFromPtrBytes(bytes, bytes_count, result.data, sizeof result.data, trim_leading_z); + DN_Assert(result.count <= sizeof result.data - 1); return result; } @@ -4981,8 +4979,8 @@ DN_API DN_Hex64 DN_Hex64FromPtr32b(void const *bytes, DN_USize bytes_count, DN_T { DN_Hex64 result = {}; DN_Assert(bytes_count * 2 == sizeof result.data - 1); - result.size = DN_HexFromPtrBytes(bytes, bytes_count, result.data, sizeof result.data, trim_leading_z); - DN_Assert(result.size <= sizeof result.data - 1); + result.count = DN_HexFromPtrBytes(bytes, bytes_count, result.data, sizeof result.data, trim_leading_z); + DN_Assert(result.count <= sizeof result.data - 1); return result; } @@ -4990,8 +4988,8 @@ DN_API DN_Hex128 DN_Hex128FromPtr64b(void const *bytes, DN_USize bytes_count, DN { DN_Hex128 result = {}; DN_Assert(bytes_count * 2 == sizeof result.data - 1); - result.size = DN_HexFromPtrBytes(bytes, bytes_count, result.data, sizeof result.data, trim_leading_z); - DN_Assert(result.size <= sizeof result.data - 1); + result.count = DN_HexFromPtrBytes(bytes, bytes_count, result.data, sizeof result.data, trim_leading_z); + DN_Assert(result.count <= sizeof result.data - 1); return result; } @@ -5010,7 +5008,7 @@ DN_API DN_Str8x128 DN_AgeStr8FromMsU64(DN_U64 duration_ms, DN_AgeUnit units) DN_USize value_usize = remainder_ms / (DN_SecFromYears(1) * 1000); remainder_ms -= DN_SecFromYears(value_usize) * 1000; if (value_usize) - DN_FmtAppend(result.data, &result.size, sizeof(result.data), "%s%zu%.*s", result.size ? " " : "", value_usize, DN_Str8PrintFmt(unit_suffix)); + DN_FmtAppend(result.data, &result.count, sizeof(result.data), "%s%zu%.*s", result.count ? " " : "", value_usize, DN_Str8PrintFmt(unit_suffix)); } if (units & DN_AgeUnit_Week) { @@ -5018,7 +5016,7 @@ DN_API DN_Str8x128 DN_AgeStr8FromMsU64(DN_U64 duration_ms, DN_AgeUnit units) DN_USize value_usize = remainder_ms / (DN_SecFromWeeks(1) * 1000); remainder_ms -= DN_SecFromWeeks(value_usize) * 1000; if (value_usize) - DN_FmtAppend(result.data, &result.size, sizeof(result.data), "%s%zu%.*s", result.size ? " " : "", value_usize, DN_Str8PrintFmt(unit_suffix)); + DN_FmtAppend(result.data, &result.count, sizeof(result.data), "%s%zu%.*s", result.count ? " " : "", value_usize, DN_Str8PrintFmt(unit_suffix)); } if (units & DN_AgeUnit_Day) { @@ -5026,7 +5024,7 @@ DN_API DN_Str8x128 DN_AgeStr8FromMsU64(DN_U64 duration_ms, DN_AgeUnit units) DN_USize value_usize = remainder_ms / (DN_SecFromDays(1) * 1000); remainder_ms -= DN_SecFromDays(value_usize) * 1000; if (value_usize) - DN_FmtAppend(result.data, &result.size, sizeof(result.data), "%s%zu%.*s", result.size ? " " : "", value_usize, DN_Str8PrintFmt(unit_suffix)); + DN_FmtAppend(result.data, &result.count, sizeof(result.data), "%s%zu%.*s", result.count ? " " : "", value_usize, DN_Str8PrintFmt(unit_suffix)); } if (units & DN_AgeUnit_Hr) { @@ -5034,7 +5032,7 @@ DN_API DN_Str8x128 DN_AgeStr8FromMsU64(DN_U64 duration_ms, DN_AgeUnit units) DN_USize value_usize = remainder_ms / (DN_SecFromHours(1) * 1000); remainder_ms -= DN_SecFromHours(value_usize) * 1000; if (value_usize) - DN_FmtAppend(result.data, &result.size, sizeof(result.data), "%s%zu%.*s", result.size ? " " : "", value_usize, DN_Str8PrintFmt(unit_suffix)); + DN_FmtAppend(result.data, &result.count, sizeof(result.data), "%s%zu%.*s", result.count ? " " : "", value_usize, DN_Str8PrintFmt(unit_suffix)); } if (units & DN_AgeUnit_Min) { @@ -5042,20 +5040,20 @@ DN_API DN_Str8x128 DN_AgeStr8FromMsU64(DN_U64 duration_ms, DN_AgeUnit units) DN_USize value_usize = remainder_ms / (DN_SecFromMins(1) * 1000); remainder_ms -= DN_SecFromMins(value_usize) * 1000; if (value_usize) - DN_FmtAppend(result.data, &result.size, sizeof(result.data), "%s%zu%.*s", result.size ? " " : "", value_usize, DN_Str8PrintFmt(unit_suffix)); + DN_FmtAppend(result.data, &result.count, sizeof(result.data), "%s%zu%.*s", result.count ? " " : "", value_usize, DN_Str8PrintFmt(unit_suffix)); } if (units & DN_AgeUnit_Sec) { unit_suffix = DN_Str8Lit("s"); if (units & DN_AgeUnit_FractionalSec) { DN_F64 remainder_s = remainder_ms / 1000.0; - DN_FmtAppend(result.data, &result.size, sizeof(result.data), "%s%.3f%.*s", result.size ? " " : "", remainder_s, DN_Str8PrintFmt(unit_suffix)); + DN_FmtAppend(result.data, &result.count, sizeof(result.data), "%s%.3f%.*s", result.count ? " " : "", remainder_s, DN_Str8PrintFmt(unit_suffix)); remainder_ms = 0; } else { DN_USize value_usize = remainder_ms / 1000; remainder_ms -= DN_Cast(DN_USize)(value_usize * 1000); if (value_usize) - DN_FmtAppend(result.data, &result.size, sizeof(result.data), "%s%zu%.*s", result.size ? " " : "", value_usize, DN_Str8PrintFmt(unit_suffix)); + DN_FmtAppend(result.data, &result.count, sizeof(result.data), "%s%zu%.*s", result.count ? " " : "", value_usize, DN_Str8PrintFmt(unit_suffix)); } } @@ -5064,12 +5062,12 @@ DN_API DN_Str8x128 DN_AgeStr8FromMsU64(DN_U64 duration_ms, DN_AgeUnit units) DN_Assert((units & DN_AgeUnit_FractionalSec) == 0); DN_USize value_usize = remainder_ms; remainder_ms -= value_usize; - if (value_usize || result.size == 0) - DN_FmtAppend(result.data, &result.size, sizeof(result.data), "%s%zu%.*s", result.size ? " " : "", value_usize, DN_Str8PrintFmt(unit_suffix)); + if (value_usize || result.count == 0) + DN_FmtAppend(result.data, &result.count, sizeof(result.data), "%s%zu%.*s", result.count ? " " : "", value_usize, DN_Str8PrintFmt(unit_suffix)); } - if (result.size == 0) - DN_FmtAppend(result.data, &result.size, sizeof(result.data), "0%.*s", DN_Str8PrintFmt(unit_suffix)); + if (result.count == 0) + DN_FmtAppend(result.data, &result.count, sizeof(result.data), "0%.*s", DN_Str8PrintFmt(unit_suffix)); return result; } @@ -5291,7 +5289,7 @@ DN_API DN_ProfilerZone DN_ProfilerBeginZone(DN_Profiler *profiler, DN_Str8 name, // TODO: We need per-thread-local-storage profiler so that we can use these apis // across threads. For now, we let them overwrite each other but this is not tenable. #if 0 - if (anchor->name.size && anchor->name != name) + if (anchor->name.count && anchor->name != name) DN_AssertF(name == anchor->name, "Potentially overwriting a zone by accident? Anchor is '%.*s', name is '%.*s'", DN_Str8PrintFmt(anchor->name), DN_Str8PrintFmt(name)); #endif @@ -5378,10 +5376,10 @@ DN_API DN_USize DN_ProfilerFmtAnchor(DN_ProfilerAnchor anchor, DN_U64 tsc_freque DN_API DN_Str8 DN_ProfilerFmtAnchorStr8(DN_ProfilerAnchor anchor, DN_U64 tsc_frequency, DN_Arena *arena) { DN_Str8 result = {}; - DN_USize size_req = DN_ProfilerFmtAnchor(anchor, tsc_frequency, nullptr, 0); - if (size_req) { - result = DN_Str8AllocArena(size_req, DN_ZMem_No, arena); - DN_ProfilerFmtAnchor(anchor, tsc_frequency, result.data, result.size + 1); + DN_USize count_req = DN_ProfilerFmtAnchor(anchor, tsc_frequency, nullptr, 0); + if (count_req) { + result = DN_Str8AllocArena(count_req, DN_ZMem_No, arena); + DN_ProfilerFmtAnchor(anchor, tsc_frequency, result.data, result.count + 1); } return result; } @@ -5688,18 +5686,18 @@ DN_API void DN_PCG32Advance(DN_PCG32 *rng, DN_U64 delta) } // Default values recommended by: http://isthe.com/chongo/tech/comp/fnv/ -DN_API DN_U32 DN_FNV1AHashU32FromBytes(void const *bytes, DN_USize size, DN_U32 hash) +DN_API DN_U32 DN_FNV1AHashU32FromBytes(void const *bytes, DN_USize count, DN_U32 hash) { - auto buffer = DN_Cast(DN_U8 const *)bytes; - for (DN_USize i = 0; i < size; i++) - hash = (buffer[i] ^ hash) * 16777619 /*FNV Prime*/; - return hash; + auto buffer = DN_Cast(DN_U8 const *)bytes; + for (DN_USize i = 0; i < count; i++) + hash = (buffer[i] ^ hash) * 16777619 /*FNV Prime*/; + return hash; } -DN_API DN_U64 DN_FNV1AHashU64FromBytes(void const *bytes, DN_USize size, DN_U64 hash) +DN_API DN_U64 DN_FNV1AHashU64FromBytes(void const *bytes, DN_USize count, DN_U64 hash) { auto buffer = DN_Cast(DN_U8 const *)bytes; - for (DN_USize i = 0; i < size; i++) + for (DN_USize i = 0; i < count; i++) hash = (buffer[i] ^ hash) * 1099511628211 /*FNV Prime*/; return hash; } @@ -6012,8 +6010,8 @@ DN_API DN_LogPrefixSize DN_LogMakePrefix(DN_LogStyle style, DN_LogTypeParam type } static DN_USize max_type_length = 0; - max_type_length = DN_Max(max_type_length, type_str8.size); - int type_padding = DN_Cast(int)(max_type_length - type_str8.size); + max_type_length = DN_Max(max_type_length, type_str8.count); + int type_padding = DN_Cast(int)(max_type_length - type_str8.count); DN_Str8x32 colour_esc = {}; DN_Str8 bold_esc = {}; @@ -6052,12 +6050,12 @@ DN_API DN_LogPrefixSize DN_LogMakePrefix(DN_LogStyle style, DN_LogTypeParam type call_site.line); // line number static DN_USize max_header_length = 0; - DN_USize size_no_ansi_codes = size - colour_esc.size - reset_esc.size - bold_esc.size; + DN_USize size_no_ansi_codes = size - colour_esc.count - reset_esc.count - bold_esc.count; max_header_length = DN_Max(max_header_length, size_no_ansi_codes); DN_USize header_padding = max_header_length - size_no_ansi_codes; DN_LogPrefixSize result = {}; - result.size = size; + result.count = size; result.padding = header_padding; return result; } @@ -7399,12 +7397,12 @@ DN_API DN_Str8x256 DN_M4ColumnMajorString(DN_M4 mat) for (int row = 0; row < 4; row++) { for (int it = 0; it < 4; it++) { if (it == 0) - DN_FmtAppend(result.data, &result.size, sizeof(result.data), "|"); - DN_FmtAppend(result.data, &result.size, sizeof(result.data), "%.5f", mat.columns[it][row]); + DN_FmtAppend(result.data, &result.count, sizeof(result.data), "|"); + DN_FmtAppend(result.data, &result.count, sizeof(result.data), "%.5f", mat.columns[it][row]); if (it != 3) - DN_FmtAppend(result.data, &result.size, sizeof(result.data), ", "); + DN_FmtAppend(result.data, &result.count, sizeof(result.data), ", "); else - DN_FmtAppend(result.data, &result.size, sizeof(result.data), "|\n"); + DN_FmtAppend(result.data, &result.count, sizeof(result.data), "|\n"); } } return result; @@ -7853,22 +7851,22 @@ struct DN_ArrayFindEqMemcmpContext_ void const *find; }; -DN_API void *DN_SliceAllocArena(void **data, DN_USize *slice_size_field, DN_USize size, DN_USize elem_size, DN_U8 align, DN_ZMem zmem, DN_Arena *arena) +DN_API void *DN_SliceAllocArena(void **data, DN_USize *slice_size_field, DN_USize count, DN_USize elem_size, DN_U8 align, DN_ZMem zmem, DN_Arena *arena) { void *result = *data; - *data = DN_ArenaAlloc(arena, size * elem_size, align, zmem); + *data = DN_ArenaAlloc(arena, count * elem_size, align, zmem); if (*data) - *slice_size_field = size; + *slice_size_field = count; return result; } -DN_API DN_ArrayFindResult DN_ArrayFind(void *data, DN_USize size, DN_USize elem_size, void const *find, DN_ArrayFindEqFunc *eq_func) +DN_API DN_ArrayFindResult DN_ArrayFind(void *data, DN_USize count, DN_USize elem_size, void const *find, DN_ArrayFindEqFunc *eq_func) { DN_ArrayFindResult result = {}; DN_Assert(data); DN_Assert(elem_size); if (find) { - for (DN_ForIndexU(index, size)) { + for (DN_ForIndexU(index, count)) { DN_U8 *it = DN_Cast(DN_U8 *) data + (index * elem_size); if (eq_func(it, find)) { result.index = index; @@ -7888,12 +7886,12 @@ static bool DN_ArrayFindEqMemEqUnsafe_(void const *lhs, void const *find) return result; } -DN_API DN_ArrayFindResult DN_ArrayFindMemEq(void *data, DN_USize size, DN_USize elem_size, void const *find) +DN_API DN_ArrayFindResult DN_ArrayFindMemEq(void *data, DN_USize count, DN_USize elem_size, void const *find) { DN_ArrayFindEqMemcmpContext_ context = {}; context.elem_size = elem_size; context.find = find; - DN_ArrayFindResult result = DN_ArrayFind(data, size, elem_size, &context, DN_ArrayFindEqMemEqUnsafe_); + DN_ArrayFindResult result = DN_ArrayFind(data, count, elem_size, &context, DN_ArrayFindEqMemEqUnsafe_); return result; } @@ -7948,116 +7946,116 @@ DN_API void *DN_ArrayPopBack(void *data, DN_USize *size, DN_USize elem_size, DN_ return DN_Cast(char *)data + (*size * elem_size); } -DN_API DN_ArrayEraseResult DN_ArrayEraseRange(void *data, DN_USize *size, DN_USize elem_size, DN_USize begin_index, DN_ISize count, DN_ArrayErase erase) +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_ArrayEraseResult result = {}; result.it_index = begin_index; - if (!data || !size || *size == 0 || count == 0) + if (!data || !count || *count == 0 || erase_count == 0) return result; // Compute the range to erase DN_USize start = 0, end = 0; - if (count < 0) { + if (erase_count < 0) { // Erase backwards from begin_index, not inclusive of begin_index // Range: [begin_index + count, begin_index) // Which is: [begin_index - abs(count), begin_index) - DN_USize abs_count = DN_Abs(count); - start = (begin_index > abs_count) ? (begin_index - abs_count) : 0; + DN_USize abs_erase_count = DN_Abs(erase_count); + start = (begin_index > abs_erase_count) ? (begin_index - abs_erase_count) : 0; end = begin_index; } else { start = begin_index; - end = begin_index + count; + end = begin_index + erase_count; } // Clamp indices to valid bounds - start = DN_Min(start, *size); - end = DN_Min(end, *size); + start = DN_Min(start, *count); + end = DN_Min(end, *count); // Erase the range [start, end) - DN_USize erase_count = end > start ? end - start : 0; - if (erase_count) { + DN_USize real_erase_count = end > start ? end - start : 0; + if (real_erase_count) { char *dest = (char *)data + (elem_size * start); - char *array_end = (char *)data + (elem_size * *size); - char *src = dest + (elem_size * erase_count); + char *array_end = (char *)data + (elem_size * *count); + char *src = dest + (elem_size * real_erase_count); if (erase == DN_ArrayErase_Stable) { DN_USize move_size = array_end - src; DN_Memmove(dest, src, move_size); } else { - char *unstable_src = array_end - (elem_size * erase_count); + char *unstable_src = array_end - (elem_size * real_erase_count); DN_USize move_size = array_end - unstable_src; DN_Memcpy(dest, unstable_src, move_size); } - *size -= erase_count; + *count -= real_erase_count; } result.items_erased = erase_count; // NOTE: If we are erasing from the current index of the iterator to the end of the array then // there's no more elements in the array to iterate. So the returned index should b // one-past-last index - if (begin_index == start && end >= *size) { - result.it_index = *size; + if (begin_index == start && end >= *count) { + result.it_index = *count; } else { result.it_index = start ? start - 1 : 0; } return result; } -DN_API void *DN_ArrayMakeArray(void *data, DN_USize *size, DN_USize max, DN_USize elem_size, DN_USize make_count, DN_ZMem z_mem) +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) { void *result = nullptr; - DN_USize new_size = *size + make_count; - if (new_size <= max) { - result = DN_Cast(char *) data + (elem_size * size[0]); - *size = new_size; + DN_USize new_count = *count + make_count; + if (new_count <= max) { + result = DN_Cast(char *) data + (elem_size * count[0]); + *count = new_count; if (z_mem == DN_ZMem_Yes) DN_Memset(result, 0, elem_size * make_count); } return result; } -DN_API void *DN_ArrayMakeArrayAssert(void *data, DN_USize *size, DN_USize max, DN_USize elem_size, DN_USize make_count, DN_ZMem z_mem, DN_CallSite call_site) +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) { - void *result = DN_ArrayMakeArray(data, size, max, elem_size, make_count, z_mem); - DN_AssertCallSiteF(result, call_site, "Array out of space, failed to add %zu items: array=%p size=%zu max=%zu", make_count, data, *size, max); + void *result = DN_ArrayMakeArray(data, count, max, elem_size, make_count, z_mem); + DN_AssertCallSiteF(result, call_site, "Array out of space, failed to add %zu items: array=%p size=%zu max=%zu", make_count, data, *count, max); return result; } -DN_API void *DN_ArrayAddArray(void *data, DN_USize *size, DN_USize max, DN_USize elem_size, void const *elems, DN_USize elems_count, DN_ArrayAdd add) +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, size, max, elem_size, elems_count, DN_ZMem_No); + void *result = DN_ArrayMakeArray(data, count, max, elem_size, elems_count, DN_ZMem_No); if (result) { if (add == DN_ArrayAdd_Append) { DN_Memcpy(result, elems, elems_count * elem_size); } else { char *move_dest = DN_Cast(char *)data + (elems_count * elem_size); // Shift elements forward char *move_src = DN_Cast(char *)data; - DN_Memmove(move_dest, move_src, elem_size * size[0]); + DN_Memmove(move_dest, move_src, elem_size * count[0]); DN_Memcpy(data, elems, elem_size * elems_count); } } return result; } -DN_API void *DN_ArrayAddArrayAssert(void *data, DN_USize *size, DN_USize max, DN_USize elem_size, void const *elems, DN_USize elems_count, DN_ArrayAdd add, DN_CallSite call_site) +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, size, max, elem_size, elems, elems_count, add); - DN_AssertCallSiteF(result, call_site, "Array out of space, failed to add %zu items: array=%p size=%zu max=%zu", elems_count, data, *size, max); + void *result = DN_ArrayAddArray(data, count, max, elem_size, elems, elems_count, add); + DN_AssertCallSiteF(result, call_site, "Array out of space, failed to add %zu items: array=%p size=%zu max=%zu", elems_count, data, *count, max); return result; } -DN_API bool DN_ArrayResizeFromArena(void **data, DN_USize *size, 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_Pool *pool, DN_USize new_max) { bool result = true; if (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(*size, new_max); + 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; - *max = new_max; - *size = DN_Min(*size, new_max); + *data = buffer; + *max = new_max; + *count = DN_Min(*count, new_max); } else { result = false; } @@ -8066,19 +8064,19 @@ DN_API bool DN_ArrayResizeFromArena(void **data, DN_USize *size, DN_USize *max, return result; } -DN_API bool DN_ArrayResizeFromPool(void **data, DN_USize *size, DN_USize *max, DN_USize elem_size, DN_Pool *pool, DN_USize new_max) +DN_API bool DN_ArrayResizeFromPool(void **data, DN_USize *count, DN_USize *max, DN_USize elem_size, DN_Pool *pool, DN_USize new_max) { bool result = true; if (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(*size, new_max); + 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; - *max = new_max; - *size = DN_Min(*size, new_max); + *data = buffer; + *max = new_max; + *count = DN_Min(*count, new_max); } else { result = false; } @@ -8087,18 +8085,18 @@ DN_API bool DN_ArrayResizeFromPool(void **data, DN_USize *size, DN_USize *max, D return result; } -DN_API bool DN_ArrayResizeFromArena(void **data, DN_USize *size, DN_USize *max, DN_USize elem_size, DN_Arena *arena, 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) { bool result = true; if (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(*size, new_max); + DN_USize bytes_to_copy = elem_size * DN_Min(*count, new_max); DN_Memcpy(buffer, *data, bytes_to_copy); - *data = buffer; - *max = new_max; - *size = DN_Min(*size, new_max); + *data = buffer; + *max = new_max; + *count = DN_Min(*count, new_max); } else { result = false; } @@ -8107,41 +8105,41 @@ DN_API bool DN_ArrayResizeFromArena(void **data, DN_USize *size, DN_USize *max, return result; } -DN_API bool DN_ArrayGrowFromPool(void **data, DN_USize size, DN_USize *max, DN_USize elem_size, DN_Pool *pool, DN_USize new_max) +DN_API bool DN_ArrayGrowFromPool(void **data, DN_USize count, DN_USize *max, DN_USize elem_size, DN_Pool *pool, DN_USize new_max) { bool result = true; if (new_max > *max) - result = DN_ArrayResizeFromPool(data, &size, max, elem_size, pool, new_max); + result = DN_ArrayResizeFromPool(data, &count, max, elem_size, pool, new_max); return result; } -DN_API bool DN_ArrayGrowFromArena(void **data, DN_USize size, DN_USize *max, DN_USize elem_size, DN_Arena *arena, DN_USize new_max) +DN_API bool DN_ArrayGrowFromArena(void **data, DN_USize count, DN_USize *max, DN_USize elem_size, DN_Arena *arena, DN_USize new_max) { bool result = true; if (new_max > *max) - result = DN_ArrayResizeFromArena(data, &size, max, elem_size, arena, new_max); + result = DN_ArrayResizeFromArena(data, &count, max, elem_size, arena, new_max); return result; } -DN_API bool DN_ArrayGrowIfNeededFromPool(void **data, DN_USize size, DN_USize *max, DN_USize elem_size, DN_Pool *pool, DN_USize add_count) +DN_API bool DN_ArrayGrowIfNeededFromPool(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_size = size + add_count; - if (new_size > *max) { - DN_USize new_max = DN_Max(DN_Max(*max * 2, new_size), 8); - result = DN_ArrayResizeFromPool(data, &size, max, elem_size, pool, new_max); + 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); } return result; } -DN_API bool DN_ArrayGrowIfNeededFromArena(void **data, DN_USize size, DN_USize *max, DN_USize elem_size, DN_Arena *arena, 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) { bool result = true; - DN_USize new_size = size + add_count; - if (new_size > *max) { - DN_USize new_max = DN_Max(DN_Max(*max * 2, new_size), 8); - result = DN_ArrayResizeFromArena(data, &size, max, elem_size, arena, new_max); + 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); } return result; } @@ -8592,25 +8590,25 @@ bool DN_DSMapEraseKeyStr8(DN_DSMap *map, DN_Str8 key) } template -DN_DSMapKey DN_DSMapKeyBuffer(DN_DSMap const *map, void const *data, DN_USize size) +DN_DSMapKey DN_DSMapKeyBuffer(DN_DSMap const *map, void const *data, DN_USize count) { - DN_Assert(size > 0 && size <= UINT32_MAX); + DN_Assert(count > 0 && count <= UINT32_MAX); DN_DSMapKey result = {}; result.type = DN_DSMapKeyType_Buffer; result.buffer_data = data; - result.buffer_size = DN_Cast(DN_U32) size; + result.buffer_size = DN_Cast(DN_U32) count; result.hash = DN_DSMapHash(map, result); return result; } template -DN_DSMapKey DN_DSMapKeyBufferAsU64NoHash(DN_DSMap const *map, void const *data, DN_USize size) +DN_DSMapKey DN_DSMapKeyBufferAsU64NoHash(DN_DSMap const *map, void const *data, DN_USize count) { DN_DSMapKey result = {}; result.type = DN_DSMapKeyType_BufferAsU64NoHash; result.buffer_data = data; - result.buffer_size = DN_Cast(DN_U32) size; - DN_Assert(size >= sizeof(result.hash)); + result.buffer_size = DN_Cast(DN_U32) count; + DN_Assert(count >= sizeof(result.hash)); DN_Memcpy(&result.hash, data, sizeof(result.hash)); return result; } @@ -8628,7 +8626,7 @@ DN_DSMapKey DN_DSMapKeyU64(DN_DSMap const *map, DN_U64 u64) template DN_DSMapKey DN_DSMapKeyStr8(DN_DSMap const *map, DN_Str8 string) { - DN_DSMapKey result = DN_DSMapKeyBuffer(map, string.data, string.size); + DN_DSMapKey result = DN_DSMapKeyBuffer(map, string.data, string.count); return result; } @@ -8693,25 +8691,25 @@ DN_API void DN_BinPackU64(DN_BinPack *pack, DN_BinPackMode mode, DN_U64 *item) } } -DN_API void DN_BinPackVarInt_(DN_BinPack *pack, DN_BinPackMode mode, void *item, DN_USize size) +DN_API void DN_BinPackVarInt_(DN_BinPack *pack, DN_BinPackMode mode, void *item, DN_USize count) { DN_U64 value = 0; - DN_AssertF(size <= sizeof(value), + DN_AssertF(count <= sizeof(value), "An item larger than 64 bits (%zu) is trying to be packed as a variable integer which is not supported", - size * 8); + count * 8); if (mode == DN_BinPackMode_Serialise) // Read `item` into U64 `value` - DN_Memcpy(&value, item, size); + DN_Memcpy(&value, item, count); DN_BinPackU64(pack, mode, &value); if (mode == DN_BinPackMode_Deserialise) // Write U64 `value` into `item` - DN_Memcpy(item, &value, size); + DN_Memcpy(item, &value, count); } DN_API bool DN_BinPackIsEndOfReadStream(DN_BinPack const *pack) { - bool result = pack->read_index == pack->read.size; + bool result = pack->read_index == pack->read.count; return result; } @@ -8786,25 +8784,25 @@ 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_BinPackVarInt_(pack, mode, &string->size, sizeof(string->size)); + DN_BinPackVarInt_(pack, mode, &string->count, sizeof(string->count)); if (mode == DN_BinPackMode_Serialise) { - DN_Str8BuilderAppendBytesCopy(&pack->writer, string->data, string->size); + DN_Str8BuilderAppendBytesCopy(&pack->writer, string->data, string->count); } else { - DN_Str8 src = DN_Str8Subset(pack->read, pack->read_index, string->size); - *string = DN_Str8FromStr8Arena(src, arena); - pack->read_index += src.size; + DN_Str8 src = DN_Str8Subset(pack->read, pack->read_index, string->count); + *string = DN_Str8FromStr8Arena(src, arena); + pack->read_index += src.count; } } DN_API void DN_BinPackStr8FromPool(DN_BinPack *pack, DN_Pool *pool, DN_BinPackMode mode, DN_Str8 *string) { - DN_BinPackVarInt_(pack, mode, &string->size, sizeof(string->size)); + DN_BinPackVarInt_(pack, mode, &string->count, sizeof(string->count)); if (mode == DN_BinPackMode_Serialise) { - DN_Str8BuilderAppendBytesCopy(&pack->writer, string->data, string->size); + DN_Str8BuilderAppendBytesCopy(&pack->writer, string->data, string->count); } else { - DN_Str8 src = DN_Str8Subset(pack->read, pack->read_index, string->size); - *string = DN_Str8FromStr8Pool(src, pool); - pack->read_index += src.size; + DN_Str8 src = DN_Str8Subset(pack->read, pack->read_index, string->count); + *string = DN_Str8FromStr8Pool(src, pool); + pack->read_index += src.count; } } @@ -8820,7 +8818,7 @@ DN_API void DN_BinPackBytesFromArena(DN_BinPack *pack, DN_Arena *arena, DN_BinPa DN_Str8 string = DN_Str8FromPtr(*ptr, *size); DN_BinPackStr8FromArena(pack, arena, mode, &string); *ptr = string.data; - *size = string.size; + *size = string.count; } DN_API void DN_BinPackBytesFromPool(DN_BinPack *pack, DN_Pool *pool, DN_BinPackMode mode, void **ptr, DN_USize *size) @@ -8828,7 +8826,7 @@ DN_API void DN_BinPackBytesFromPool(DN_BinPack *pack, DN_Pool *pool, DN_BinPackM DN_Str8 string = DN_Str8FromPtr(*ptr, *size); DN_BinPackStr8FromPool(pack, pool, mode, &string); *ptr = string.data; - *size = string.size; + *size = string.count; } DN_API void DN_BinPackCArray(DN_BinPack *pack, DN_BinPackMode mode, void *ptr, DN_USize size) @@ -8838,9 +8836,9 @@ DN_API void DN_BinPackCArray(DN_BinPack *pack, DN_BinPackMode mode, void *ptr, D DN_Str8BuilderAppendBytesCopy(&pack->writer, ptr, size); } else { DN_Str8 src = DN_Str8Subset(pack->read, pack->read_index, size); - DN_Assert(src.size == size); - DN_Memcpy(ptr, src.data, DN_Min(src.size, size)); - pack->read_index += src.size; + DN_Assert(src.count == size); + DN_Memcpy(ptr, src.data, DN_Min(src.count, size)); + pack->read_index += src.count; } } @@ -8883,7 +8881,7 @@ DN_API bool DN_CSVTokeniserValid(DN_CSVTokeniser *tokeniser) static void DN_CSVTokeniserEatNewLines_(DN_CSVTokeniser *tokeniser) { - char const *end = tokeniser->string.data + tokeniser->string.size; + char const *end = tokeniser->string.data + tokeniser->string.count; while (tokeniser->it[0] == '\n' || tokeniser->it[0] == '\r') if (++tokeniser->it == end) break; @@ -8892,12 +8890,12 @@ static void DN_CSVTokeniserEatNewLines_(DN_CSVTokeniser *tokeniser) DN_API bool DN_CSVTokeniserNextRow(DN_CSVTokeniser *tokeniser) { bool result = false; - if (DN_CSVTokeniserValid(tokeniser) && tokeniser->string.size) { + if (DN_CSVTokeniserValid(tokeniser) && tokeniser->string.count) { // NOTE: First time querying row iterator is nil, let tokeniser advance if (tokeniser->it) { // NOTE: Only advance the tokeniser if we're at the end of the line and // there's more to tokenise. - char const *end = tokeniser->string.data + tokeniser->string.size; + char const *end = tokeniser->string.data + tokeniser->string.count; if (tokeniser->it != end && tokeniser->end_of_line) { tokeniser->end_of_line = false; result = true; @@ -8914,13 +8912,13 @@ DN_API DN_Str8 DN_CSVTokeniserNextField(DN_CSVTokeniser *tokeniser) if (!DN_CSVTokeniserValid(tokeniser)) return result; - if (tokeniser->string.size == 0) { + if (tokeniser->string.count == 0) { tokeniser->bad = true; return result; } // NOTE: First time tokeniser is invoked with a string, set up initial state. - char const *string_end = tokeniser->string.data + tokeniser->string.size; + char const *string_end = tokeniser->string.data + tokeniser->string.count; if (!tokeniser->it) { tokeniser->it = tokeniser->string.data; DN_CSVTokeniserEatNewLines_(tokeniser); // NOTE: Skip any leading new lines @@ -8983,7 +8981,7 @@ DN_API DN_Str8 DN_CSVTokeniserNextField(DN_CSVTokeniser *tokeniser) // NOTE: Generate the record result.data = DN_Cast(char *) begin; - result.size = DN_Cast(int)(end - begin); + result.count = DN_Cast(int)(end - begin); return result; } @@ -9128,7 +9126,7 @@ DN_API void DN_CSVPackBuffer(DN_CSVPack *pack, DN_CSVSerialise serialise, void * { if (serialise == DN_CSVSerialise_Read) { DN_Str8 csv_value = DN_CSVTokeniserNextColumn(&pack->read_tokeniser); - *size = DN_Min(*size, csv_value.size); + *size = DN_Min(*size, csv_value.count); DN_Memcpy(dest, csv_value.data, *size); } else { DN_Str8BuilderAppendF(&pack->write_builder, "%s%.*s", pack->write_column++ ? "," : "", DN_Cast(int)(*size), DN_Cast(char *)dest); @@ -9191,8 +9189,8 @@ DN_API void DN_LeakTrackAlloc_(DN_LeakTracker *leak, void *ptr, DN_USize size, b } // NOTE: Pointer was reused, clean up the prior entry - leak->alloc_table_bytes_allocated_for_stack_traces -= alloc->stack_trace.size; - leak->alloc_table_bytes_allocated_for_stack_traces -= alloc->freed_stack_trace.size; + leak->alloc_table_bytes_allocated_for_stack_traces -= alloc->stack_trace.count; + leak->alloc_table_bytes_allocated_for_stack_traces -= alloc->freed_stack_trace.count; DN_OS_MemDealloc(alloc->stack_trace.data); DN_OS_MemDealloc(alloc->freed_stack_trace.data); @@ -9203,7 +9201,7 @@ DN_API void DN_LeakTrackAlloc_(DN_LeakTracker *leak, void *ptr, DN_USize size, b alloc->size = size; alloc->stack_trace = stack_trace; alloc->flags |= leak_permitted ? DN_LeakAllocFlag_LeakPermitted : 0; - leak->alloc_table_bytes_allocated_for_stack_traces += alloc->stack_trace.size; + leak->alloc_table_bytes_allocated_for_stack_traces += alloc->stack_trace.count; DN_TicketMutex_End(&leak->alloc_table_mutex); } @@ -9249,10 +9247,10 @@ DN_API void DN_LeakTrackDealloc_(DN_LeakTracker *leak, void *ptr) DN_Str8PrintFmt(stack_trace)); } - DN_Assert(alloc->freed_stack_trace.size == 0); + DN_Assert(alloc->freed_stack_trace.count == 0); alloc->flags |= DN_LeakAllocFlag_Freed; alloc->freed_stack_trace = stack_trace; - leak->alloc_table_bytes_allocated_for_stack_traces += alloc->freed_stack_trace.size; + leak->alloc_table_bytes_allocated_for_stack_traces += alloc->freed_stack_trace.count; DN_TicketMutex_End(&leak->alloc_table_mutex); } @@ -9374,20 +9372,20 @@ DN_API DN_Str8 DN_Str8FromHeapF(DN_FMT_ATTRIB char const *fmt, ...) { va_list args; va_start(args, fmt); - DN_USize size = DN_FmtVSize(fmt, args); - DN_Str8 result = DN_Str8FromHeap(size, DN_ZMem_No); - DN_VSNPrintF(result.data, DN_Cast(int)(result.size + 1), fmt, args); + DN_USize count = DN_FmtVCount(fmt, args); + DN_Str8 result = DN_Str8FromHeap(count, DN_ZMem_No); + DN_VSNPrintF(result.data, DN_Cast(int)(result.count + 1), fmt, args); va_end(args); return result; } -DN_API DN_Str8 DN_Str8FromHeap(DN_USize size, DN_ZMem z_mem) +DN_API DN_Str8 DN_Str8FromHeap(DN_USize count, DN_ZMem z_mem) { DN_Str8 result = {}; - result.data = DN_Cast(char *)DN_OS_MemAlloc(size + 1, z_mem); + result.data = DN_Cast(char *)DN_OS_MemAlloc(count + 1, z_mem); if (result.data) { - result.size = size; - result.data[result.size] = 0; + result.count = count; + result.data[result.count] = 0; } return result; } @@ -9398,11 +9396,11 @@ DN_API DN_Str8 DN_Str8PadNewLines(DN_Arena *arena, DN_Str8 src, DN_Str8 pad) DN_TCScratch scratch = DN_TCScratchBeginArena(&arena, 1); DN_Str8Builder builder = DN_Str8BuilderFromArena(&scratch.arena); DN_Str8BSplitResult split = DN_Str8BSplit(src, DN_Str8Lit("\n")); - while (split.lhs.size) { + while (split.lhs.count) { DN_Str8BuilderAppendRef(&builder, pad); DN_Str8BuilderAppendRef(&builder, split.lhs); split = DN_Str8BSplit(split.rhs, DN_Str8Lit("\n")); - if (split.lhs.size) + if (split.lhs.count) DN_Str8BuilderAppendRef(&builder, DN_Str8Lit("\n")); } DN_Str8 result = DN_Str8FromStr8BuilderArena(&builder, arena); @@ -9421,12 +9419,12 @@ DN_API DN_Str8 DN_Str8BuilderBuildFromHeap(DN_Str8Builder const *builder) return result; for (DN_Str8Link *link = builder->head; link; link = link->next) { - DN_Memcpy(result.data + result.size, link->string.data, link->string.size); - result.size += link->string.size; + DN_Memcpy(result.data + result.count, link->string.data, link->string.count); + result.count += link->string.count; } - result.data[result.size] = 0; - DN_Assert(result.size == builder->string_size); + result.data[result.count] = 0; + DN_Assert(result.count == builder->string_size); return result; } @@ -9494,7 +9492,7 @@ DN_API void DN_OS_LogPrint(DN_LogTypeParam type, void *user_data, DN_CallSite ca DN_TicketMutex_Begin(&os->log_file_mutex); { if (print_prefix) { - DN_OS_FileWrite(&os->log_file, DN_Str8FromPtr(prefix_buffer, prefix_size.size), nullptr); + DN_OS_FileWrite(&os->log_file, DN_Str8FromPtr(prefix_buffer, prefix_size.count), nullptr); DN_OS_FileWriteF(&os->log_file, nullptr, "%*s ", DN_Cast(int) prefix_size.padding, ""); } DN_OS_FileWriteFV(&os->log_file, nullptr, fmt, args_copy); @@ -9507,7 +9505,7 @@ DN_API void DN_OS_LogPrint(DN_LogTypeParam type, void *user_data, DN_CallSite ca DN_TicketMutex_Begin(&os->log_mutex); { if (print_prefix) - DN_OS_PrintF(DN_OSPrintDest_Err, "%.*s%*s ", DN_Cast(int) prefix_size.size, prefix_buffer, DN_Cast(int) prefix_size.padding, ""); + DN_OS_PrintF(DN_OSPrintDest_Err, "%.*s%*s ", DN_Cast(int) prefix_size.count, prefix_buffer, DN_Cast(int) prefix_size.padding, ""); if (DN_BitIsSet(flags, DN_LogFlags_NoNewLine)) DN_OS_PrintFV(DN_OSPrintDest_Err, fmt, args); @@ -9658,7 +9656,7 @@ DN_API bool DN_OS_PathIsOlderThan(DN_Str8 path, DN_Str8 check_against) DN_API bool DN_OS_FileWrite(DN_OSFile *file, DN_Str8 buffer, DN_ErrSink *error) { - bool result = DN_OS_FileWritePtr(file, buffer.data, buffer.size, error); + bool result = DN_OS_FileWritePtr(file, buffer.data, buffer.count, error); return result; } @@ -9731,7 +9729,7 @@ DN_API DN_Str8 DN_OS_FileReadAll(DN_Allocator allocator, DN_Str8 path, DN_ErrSin // NOTE: Read all DN_OSFile file = DN_OS_FileOpen(path, DN_OSFileOpen_OpenIfExist, DN_OSFileAccess_Read, err); - DN_OSFileRead read = DN_OS_FileRead(&file, result.data, result.size, err); + DN_OSFileRead read = DN_OS_FileRead(&file, result.data, result.count, err); bool failed = file.error || !read.success; if (allocator.type == DN_AllocatorType_Arena) { @@ -9844,10 +9842,10 @@ DN_API DN_Str8 DN_OS_Str8FromPathInfoType(DN_OSPathInfoType type) DN_API bool DN_OS_PathAddRef(DN_Arena *arena, DN_OSPath *fs_path, DN_Str8 path) { - if (!arena || !fs_path || path.size == 0) + if (!arena || !fs_path || path.count == 0) return false; - if (path.size <= 0) + if (path.count <= 0) return true; DN_Str8 const delimiter_array[] = { @@ -9860,7 +9858,7 @@ DN_API bool DN_OS_PathAddRef(DN_Arena *arena, DN_OSPath *fs_path, DN_Str8 path) for (;;) { DN_Str8BSplitResult delimiter = DN_Str8BSplitArray(path, delimiter_array, DN_ArrayCountU(delimiter_array)); for (; delimiter.lhs.data; delimiter = DN_Str8BSplitArray(delimiter.rhs, delimiter_array, DN_ArrayCountU(delimiter_array))) { - if (delimiter.lhs.size <= 0) + if (delimiter.lhs.count <= 0) continue; DN_OSPathLink *link = DN_ArenaNew(arena, DN_OSPathLink, DN_ZMem_Yes); @@ -9875,7 +9873,7 @@ DN_API bool DN_OS_PathAddRef(DN_Arena *arena, DN_OSPath *fs_path, DN_Str8 path) fs_path->head = link; fs_path->tail = link; fs_path->links_size += 1; - fs_path->string_size += delimiter.lhs.size; + fs_path->string_size += delimiter.lhs.count; } if (!delimiter.lhs.data) @@ -9888,7 +9886,7 @@ DN_API bool DN_OS_PathAddRef(DN_Arena *arena, DN_OSPath *fs_path, DN_Str8 path) DN_API bool DN_OS_PathAdd(DN_Arena *arena, DN_OSPath *fs_path, DN_Str8 path) { DN_Str8 copy = DN_Str8FromStr8Arena(path, arena); - bool result = copy.size ? true : DN_OS_PathAddRef(arena, fs_path, copy); + bool result = copy.count ? true : DN_OS_PathAddRef(arena, fs_path, copy); return result; } @@ -9910,7 +9908,7 @@ DN_API bool DN_OS_PathPop(DN_OSPath *fs_path) if (fs_path->tail) { DN_Assert(fs_path->head); fs_path->links_size -= 1; - fs_path->string_size -= fs_path->tail->string.size; + fs_path->string_size -= fs_path->tail->string.count; fs_path->tail = fs_path->tail->prev; if (fs_path->tail) fs_path->tail->next = nullptr; @@ -9968,23 +9966,23 @@ DN_API DN_Str8 DN_OS_PathBuildWithSeparator(DN_Arena *arena, DN_OSPath const *fs return result; // NOTE: Each link except the last one needs the path separator appended to it, '/' or '\\' - DN_USize string_size = (fs_path->has_prefix_path_separator ? path_separator.size : 0) + fs_path->string_size + ((fs_path->links_size - 1) * path_separator.size); + DN_USize string_size = (fs_path->has_prefix_path_separator ? path_separator.count : 0) + fs_path->string_size + ((fs_path->links_size - 1) * path_separator.count); result = DN_Str8AllocArena(string_size, DN_ZMem_No, arena); if (result.data) { char *dest = result.data; if (fs_path->has_prefix_path_separator) { - DN_Memcpy(dest, path_separator.data, path_separator.size); - dest += path_separator.size; + DN_Memcpy(dest, path_separator.data, path_separator.count); + dest += path_separator.count; } for (DN_OSPathLink *link = fs_path->head; link; link = link->next) { DN_Str8 string = link->string; - DN_Memcpy(dest, string.data, string.size); - dest += string.size; + DN_Memcpy(dest, string.data, string.count); + dest += string.count; if (link != fs_path->tail) { - DN_Memcpy(dest, path_separator.data, path_separator.size); - dest += path_separator.size; + DN_Memcpy(dest, path_separator.data, path_separator.count); + dest += path_separator.count; } } } @@ -10038,7 +10036,7 @@ DN_API void DN_OS_ThreadSetNameFmt(char const *fmt, ...) tls->name = DN_Str8x64FromFmtV(fmt, args); va_end(args); - DN_Str8 name = DN_Str8FromPtr(tls->name.data, tls->name.size); + DN_Str8 name = DN_Str8FromPtr(tls->name.data, tls->name.count); #if defined(DN_PLATFORM_WIN32) DN_OS_W32ThreadSetName(name); #else @@ -10335,13 +10333,13 @@ DN_API void DN_OS_Print(DN_OSPrintDest dest, DN_Str8 string) } // NOTE: Write the string - DN_Assert(string.size < DN_Cast(unsigned long) - 1); + DN_Assert(string.count < DN_Cast(unsigned long) - 1); unsigned long bytes_written = 0; (void)bytes_written; if (print_to_console) - WriteConsoleA(print_handle, string.data, DN_Cast(unsigned long) string.size, &bytes_written, nullptr); + WriteConsoleA(print_handle, string.data, DN_Cast(unsigned long) string.count, &bytes_written, nullptr); else - WriteFile(print_handle, string.data, DN_Cast(unsigned long) string.size, &bytes_written, nullptr); + WriteFile(print_handle, string.data, DN_Cast(unsigned long) string.count, &bytes_written, nullptr); #else fprintf(dest == DN_OSPrintDest_Out ? stdout : stderr, "%.*s", DN_Str8PrintFmt(string)); #endif @@ -10365,7 +10363,7 @@ DN_API void DN_OS_PrintFStyle(DN_OSPrintDest dest, DN_LogStyle style, DN_FMT_ATT DN_API void DN_OS_PrintStyle(DN_OSPrintDest dest, DN_LogStyle style, DN_Str8 string) { - if (string.data && string.size) { + if (string.data && string.count) { if (style.colour) { DN_Str8x32 colour = DN_Str8x32FromANSIColourCodeU8RGB(DN_ANSIColourMode_Fg, style.r, style.g, style.b); DN_OS_Print(dest, DN_Str8FromStruct(&colour)); @@ -10382,7 +10380,7 @@ static char *DN_OS_PrintVSPrintfChunker_(const char *buf, void *user, int len) { DN_Str8 string = {}; string.data = DN_Cast(char *) buf; - string.size = len; + string.count = len; DN_OSPrintDest dest = DN_Cast(DN_OSPrintDest) DN_Cast(uintptr_t) user; DN_OS_Print(dest, string); @@ -10654,7 +10652,7 @@ DN_API DN_StackTraceFrame DN_StackTraceRawFrameToFrame(DN_Arena *arena, DN_Stack // NOTE: Construct result - DN_Str16 file_name16 = DN_Str16FromPtr(line.FileName, DN_CStr16Size(line.FileName)); + DN_Str16 file_name16 = DN_Str16FromPtr(line.FileName, DN_CStr16Count(line.FileName)); DN_Str16 function_name16 = DN_Str16FromPtr(symbol->Name, symbol->NameLen); DN_StackTraceFrame result = {}; @@ -10663,9 +10661,9 @@ DN_API DN_StackTraceFrame DN_StackTraceRawFrameToFrame(DN_Arena *arena, DN_Stack result.file_name = DN_OS_W32Str16ToStr8(arena, file_name16); result.function_name = DN_OS_W32Str16ToStr8(arena, function_name16); - if (result.function_name.size == 0) + if (result.function_name.count == 0) result.function_name = DN_Str8Lit(""); - if (result.file_name.size == 0) + if (result.file_name.count == 0) result.file_name = DN_Str8Lit(""); #else DN_StackTraceFrame result = {}; @@ -10915,7 +10913,7 @@ DN_API void DN_OS_GenBytesSecure(void *buffer, DN_U32 size) DN_API bool DN_OS_SetEnvVar(DN_Str8 name, DN_Str8 value) { - DN_VerifyWarning(false, "Unimplemented function"); + DN_VerifyWarningF(false, "Unimplemented function"); (void)name; (void)value; bool result = false; @@ -11137,7 +11135,7 @@ DN_API DN_OSFile DN_OS_FileOpen(DN_Str8 path, DN_ErrSink *error) { DN_OSFile result = {}; - if (path.size == 0 || path.size <= 0) + if (path.count == 0 || path.count <= 0) return result; if ((access & ~(DN_OSFileAccess_All) || ((access & DN_OSFileAccess_All) == 0))) { @@ -11264,7 +11262,7 @@ DN_API void DN_OS_FileClose(DN_OSFile *file) DN_API DN_OSPathInfo DN_OS_PathInfo(DN_Str8 path) { DN_OSPathInfo result = {}; - if (path.size == 0) + if (path.count == 0) return result; struct stat file_stat; @@ -11288,7 +11286,7 @@ DN_API DN_OSPathInfo DN_OS_PathInfo(DN_Str8 path) DN_API bool DN_OS_PathDelete(DN_Str8 path) { bool result = false; - if (path.size) + if (path.count) result = remove(path.data) == 0; return result; } @@ -11296,7 +11294,7 @@ DN_API bool DN_OS_PathDelete(DN_Str8 path) DN_API bool DN_OS_PathIsFile(DN_Str8 path) { bool result = false; - if (path.size == 0) + if (path.count == 0) return result; struct stat stat_result; @@ -11308,7 +11306,7 @@ DN_API bool DN_OS_PathIsFile(DN_Str8 path) DN_API bool DN_OS_PathIsDir(DN_Str8 path) { bool result = false; - if (path.size == 0) + if (path.count == 0) return result; struct stat stat_result; @@ -11328,8 +11326,8 @@ DN_API bool DN_OS_PathMakeDir(DN_Str8 path) uint16_t path_indexes[64] = {}; DN_Str8 copy = DN_Str8FromStr8Arena(path, &scratch.arena); - for (DN_USize index = copy.size - 1; index < copy.size; index--) { - bool first_char = index == (copy.size - 1); + for (DN_USize index = copy.count - 1; index < copy.count; index--) { + bool first_char = index == (copy.count - 1); char ch = copy.data[index]; if (ch == '/' || first_char) { char temp = copy.data[index]; @@ -11392,12 +11390,12 @@ DN_API bool DN_OS_PathIterateDir(DN_Str8 path, DN_OSDirIterator *it) if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0) continue; - DN_USize name_size = DN_CStr8Size(entry->d_name); - DN_USize clamped_size = DN_Min(sizeof(it->buffer) - 1, name_size); - DN_AssertF(name_size == clamped_size, "name: %s, name_size: %zu, clamped_size: %zu", entry->d_name, name_size, clamped_size); - DN_Memcpy(it->buffer, entry->d_name, clamped_size); - it->buffer[clamped_size] = 0; - it->file_name = DN_Str8FromPtr(it->buffer, clamped_size); + DN_USize name_count = DN_CStr8Count(entry->d_name); + DN_USize clamped_count = DN_Min(sizeof(it->buffer) - 1, name_count); + DN_AssertF(name_count == clamped_count, "name: %s, name_size: %zu, clamped_size: %zu", entry->d_name, name_count, clamped_count); + DN_Memcpy(it->buffer, entry->d_name, clamped_count); + it->buffer[clamped_count] = 0; + it->file_name = DN_Str8FromPtr(it->buffer, clamped_count); return true; } @@ -11658,7 +11656,7 @@ DN_API DN_OSExecAsyncHandle DN_OS_ExecAsync(DN_Str8Slice cmd_line, free(prev_working_dir); }; - if (args->working_dir.size) { + if (args->working_dir.count) { prev_working_dir = get_current_dir_name(); DN_Str8 working_dir = DN_Str8FromStr8Arena(args->working_dir, &scratch.arena); if (chdir(working_dir.data) == -1) { @@ -12106,23 +12104,23 @@ DN_API DN_OSPosixProcSelfStatus DN_OS_PosixProcSelfStatus() for (DN_ForItSize(line_it, DN_Str8, lines.data, lines.count)) { DN_Str8 line = DN_Str8TrimWhitespaceAround(*line_it.data); if (DN_Str8StartsWith(line, NAME, DN_Str8EqCase_Insensitive)) { - DN_Str8 str8 = DN_Str8TrimWhitespaceAround(DN_Str8Subset(line, NAME.size, line.size)); - result.name_size = DN_Min(str8.size, sizeof(result.name)); + DN_Str8 str8 = DN_Str8TrimWhitespaceAround(DN_Str8Subset(line, NAME.count, line.count)); + result.name_size = DN_Min(str8.count, sizeof(result.name)); DN_Memcpy(result.name, str8.data, result.name_size); } else if (DN_Str8StartsWith(line, PID, DN_Str8EqCase_Insensitive)) { - DN_Str8 str8 = DN_Str8TrimWhitespaceAround(DN_Str8Subset(line, PID.size, line.size)); + DN_Str8 str8 = DN_Str8TrimWhitespaceAround(DN_Str8Subset(line, PID.count, line.count)); DN_U64FromResult to_u64 = DN_U64FromStr8(str8, 0); result.pid = to_u64.value; DN_Assert(to_u64.success); } else if (DN_Str8StartsWith(line, VM_SIZE, DN_Str8EqCase_Insensitive)) { - DN_Str8 size_with_kb = DN_Str8TrimWhitespaceAround(DN_Str8Subset(line, VM_SIZE.size, line.size)); + DN_Str8 size_with_kb = DN_Str8TrimWhitespaceAround(DN_Str8Subset(line, VM_SIZE.count, line.count)); DN_Assert(DN_Str8EndsWith(size_with_kb, DN_Str8Lit("kB"))); DN_Str8 vm_size = DN_Str8BSplit(size_with_kb, DN_Str8Lit(" ")).lhs; DN_U64FromResult to_u64 = DN_U64FromStr8(vm_size, 0); result.vm_size = DN_Kilobytes(to_u64.value); DN_Assert(to_u64.success); } else if (DN_Str8StartsWith(line, VM_PEAK, DN_Str8EqCase_Insensitive)) { - DN_Str8 size_with_kb = DN_Str8TrimWhitespaceAround(DN_Str8Subset(line, VM_PEAK.size, line.size)); + DN_Str8 size_with_kb = DN_Str8TrimWhitespaceAround(DN_Str8Subset(line, VM_PEAK.count, line.count)); DN_Assert(DN_Str8EndsWith(size_with_kb, DN_Str8Lit("kB"))); DN_Str8 vm_size = DN_Str8BSplit(size_with_kb, DN_Str8Lit(" ")).lhs; DN_U64FromResult to_u64 = DN_U64FromStr8(vm_size, 0); @@ -12475,7 +12473,7 @@ DN_API bool DN_OS_FileMove(DN_Str8 src, DN_Str8 dest, bool overwrite, DN_ErrSink DN_API DN_OSFile DN_OS_FileOpen(DN_Str8 path, DN_OSFileOpen open_mode, DN_OSFileAccess access, DN_ErrSink *err) { DN_OSFile result = {}; - if (path.size == 0 || path.size <= 0) + if (path.count == 0 || path.count <= 0) return result; if ((access & ~DN_OSFileAccess_All) || ((access & DN_OSFileAccess_All) == 0)) { @@ -12625,7 +12623,7 @@ DN_API void DN_OS_FileClose(DN_OSFile *file) DN_API DN_OSPathInfo DN_OS_PathInfo(DN_Str8 path) { DN_OSPathInfo result = {}; - if (path.size == 0) + if (path.count == 0) return result; DN_TCScratch scratch = DN_TCScratchBeginArena(nullptr, 0); @@ -12661,12 +12659,12 @@ DN_API DN_OSPathInfo DN_OS_PathInfo(DN_Str8 path) DN_API bool DN_OS_PathDelete(DN_Str8 path) { bool result = false; - if (path.size == 0) + if (path.count == 0) return result; DN_TCScratch scratch = DN_TCScratchBeginArena(nullptr, 0); DN_Str16 path16 = DN_OS_W32Str8ToStr16(&scratch.arena, path); - if (path16.size) { + if (path16.count) { result = DeleteFileW(path16.data); if (!result) result = RemoveDirectoryW(path16.data); @@ -12678,12 +12676,12 @@ DN_API bool DN_OS_PathDelete(DN_Str8 path) DN_API bool DN_OS_PathIsFile(DN_Str8 path) { bool result = false; - if (path.size == 0) + if (path.count == 0) return result; DN_TCScratch scratch = DN_TCScratchBeginArena(nullptr, 0); DN_Str16 path16 = DN_OS_W32Str8ToStr16(&scratch.arena, path); - if (path16.size) { + if (path16.count) { WIN32_FILE_ATTRIBUTE_DATA attrib_data = {}; if (GetFileAttributesExW(path16.data, GetFileExInfoStandard, &attrib_data)) result = (attrib_data.dwFileAttributes != INVALID_FILE_ATTRIBUTES) && @@ -12696,12 +12694,12 @@ DN_API bool DN_OS_PathIsFile(DN_Str8 path) DN_API bool DN_OS_PathIsDir(DN_Str8 path) { bool result = false; - if (path.size == 0) + if (path.count == 0) return result; DN_TCScratch scratch = DN_TCScratchBeginArena(nullptr, 0); DN_Str16 path16 = DN_OS_W32Str8ToStr16(&scratch.arena, path); - if (path16.size) { + if (path16.count) { WIN32_FILE_ATTRIBUTE_DATA attrib_data = {}; if (GetFileAttributesExW(path16.data, GetFileExInfoStandard, &attrib_data)) result = (attrib_data.dwFileAttributes != INVALID_FILE_ATTRIBUTES) && @@ -12730,8 +12728,8 @@ DN_API bool DN_OS_PathMakeDir(DN_Str8 path) // If we find a file at some point in the path we fail out because the // series of directories can not be made if a file exists with the same // name. - for (DN_USize index = 0; index < path16.size; index++) { - bool first_char = index == (path16.size - 1); + for (DN_USize index = 0; index < path16.count; index++) { + bool first_char = index == (path16.count - 1); wchar_t ch = path16.data[index]; if (ch == '/' || ch == '\\' || first_char) { wchar_t temp = path16.data[index]; @@ -12767,7 +12765,7 @@ DN_API bool DN_OS_PathMakeDir(DN_Str8 path) DN_API bool DN_OS_PathIterateDir(DN_Str8 path, DN_OSDirIterator *it) { - if (path.size == 0 || !it || path.size <= 0) + if (path.count == 0 || !it || path.count <= 0) return false; DN_TCScratch scratch = DN_TCScratchBeginArena(nullptr, 0); @@ -12793,7 +12791,7 @@ DN_API bool DN_OS_PathIterateDir(DN_Str8 path, DN_OSDirIterator *it) } path16 = DN_OS_W32Str8ToStr16(&scratch.arena, adjusted_path); - if (path16.size <= 0) { // Conversion error + if (path16.count <= 0) { // Conversion error DN_TCScratchEnd(&scratch); return false; } @@ -12975,7 +12973,7 @@ DN_API DN_OSExecResult DN_OS_ExecWait(DN_OSExecAsyncHandle handle, DN_Arena *are result = DN_OS_ExecPump(handle, stdout_buffer, &stdout_size, stderr_buffer, &stderr_size, wait_ms, err); DN_Str8BuilderAppendCopy(&stdout_builder, result.stdout_text); DN_Str8BuilderAppendCopy(&stderr_builder, result.stderr_text); - wait_ms = (result.stdout_text.size || result.stderr_text.size) ? FAST_WAIT_TIME_MS : SLOW_WAIT_TIME_MS; + wait_ms = (result.stdout_text.count || result.stderr_text.count) ? FAST_WAIT_TIME_MS : SLOW_WAIT_TIME_MS; } // NOTE: Get stdout/stderr. If no arena is passed this is a no-op @@ -13004,7 +13002,7 @@ DN_API DN_OSExecAsyncHandle DN_OS_ExecAsync(DN_Str8Slice cmd_line, DN_OSExecArgs DN_Str8 env_block8 = DN_Str8FromStr8BuilderDelimitArena(&env_builder, DN_Str8Lit("\0"), &scratch.arena); DN_Str16 env_block16 = {}; - if (env_block8.size) + if (env_block8.count) env_block16 = DN_OS_W32Str8ToStr16(&scratch.arena, env_block8); // NOTE: Stdout/err security attributes @@ -13485,17 +13483,17 @@ DN_API DN_Str16 DN_OS_W32ErrorCodeToMsg16Alloc(DN_U32 error_code) } wchar_t *result16 = nullptr; - DWORD size = FormatMessageW(/*DWORD dwFlags */ flags | FORMAT_MESSAGE_ALLOCATE_BUFFER, - /*LPCVOID lpSource */ module_to_get_errors_from, - /*DWORD dwMessageId */ error_code, - /*DWORD dwLanguageId*/ 0, - /*LPWSTR lpBuffer */ (LPWSTR)&result16, - /*DWORD nSize */ 0, - /*va_list *Arguments */ nullptr); + DWORD count = FormatMessageW(/*DWORD dwFlags */ flags | FORMAT_MESSAGE_ALLOCATE_BUFFER, + /*LPCVOID lpSource */ module_to_get_errors_from, + /*DWORD dwMessageId */ error_code, + /*DWORD dwLanguageId*/ 0, + /*LPWSTR lpBuffer */ (LPWSTR)&result16, + /*DWORD nSize */ 0, + /*va_list *Arguments */ nullptr); DN_Str16 result = {}; result.data = result16; - result.size = size; + result.count = count; return result; } @@ -13504,7 +13502,7 @@ DN_API DN_OSW32Error DN_OS_W32ErrorCodeToMsgAlloc(DN_U32 error_code) DN_OSW32Error result = {}; result.code = error_code; DN_Str16 error16 = DN_OS_W32ErrorCodeToMsg16Alloc(error_code); - if (error16.size) + if (error16.count) result.msg = DN_OS_W32Str16ToStr8FromHeap(error16); if (error16.data) LocalFree(error16.data); @@ -13517,7 +13515,7 @@ DN_API DN_OSW32Error DN_OS_W32ErrorCodeToMsg(DN_Arena *arena, DN_U32 error_code) result.code = error_code; if (arena) { DN_Str16 error16 = DN_OS_W32ErrorCodeToMsg16Alloc(error_code); - if (error16.size) + if (error16.count) result.msg = DN_OS_W32Str16ToStr8(arena, error16); if (error16.data) LocalFree(error16.data); @@ -13562,10 +13560,10 @@ DN_API void DN_OS_W32MakeProcessDPIAware() DN_API DN_Str16 DN_OS_W32Str8ToStr16(DN_Arena *arena, DN_Str8 src) { DN_Str16 result = {}; - if (!arena || src.size == 0) + if (!arena || src.count == 0) return result; - int required_size = MultiByteToWideChar(CP_UTF8, 0 /*dwFlags*/, src.data, DN_Cast(int) src.size, nullptr /*dest*/, 0 /*dest size*/); + int required_size = MultiByteToWideChar(CP_UTF8, 0 /*dwFlags*/, src.data, DN_Cast(int) src.count, nullptr /*dest*/, 0 /*dest size*/); if (required_size <= 0) return result; @@ -13573,12 +13571,12 @@ DN_API DN_Str16 DN_OS_W32Str8ToStr16(DN_Arena *arena, DN_Str8 src) if (!buffer) return result; - int chars_written = MultiByteToWideChar(CP_UTF8, 0 /*dwFlags*/, src.data, DN_Cast(int) src.size, buffer, required_size); + int chars_written = MultiByteToWideChar(CP_UTF8, 0 /*dwFlags*/, src.data, DN_Cast(int) src.count, buffer, required_size); DN_Assert(chars_written == required_size); if (chars_written == required_size) { - result.data = buffer; - result.size = chars_written; - result.data[result.size] = 0; + result.data = buffer; + result.count = chars_written; + result.data[result.count] = 0; } return result; } @@ -13586,14 +13584,14 @@ DN_API DN_Str16 DN_OS_W32Str8ToStr16(DN_Arena *arena, DN_Str8 src) DN_API int DN_OS_W32Str8ToStr16Buffer(DN_Str8 src, wchar_t *dest, int dest_size) { int result = 0; - if (src.size == 0) + if (src.count == 0) return result; - result = MultiByteToWideChar(CP_UTF8, 0 /*dwFlags*/, src.data, DN_Cast(int) src.size, nullptr /*dest*/, 0 /*dest size*/); + result = MultiByteToWideChar(CP_UTF8, 0 /*dwFlags*/, src.data, DN_Cast(int) src.count, nullptr /*dest*/, 0 /*dest size*/); if (result <= 0 || result > dest_size || !dest) return result; - result = MultiByteToWideChar(CP_UTF8, 0 /*dwFlags*/, src.data, DN_Cast(int) src.size, dest, DN_Cast(int) dest_size); + result = MultiByteToWideChar(CP_UTF8, 0 /*dwFlags*/, src.data, DN_Cast(int) src.count, dest, DN_Cast(int) dest_size); dest[DN_Min(result, dest_size - 1)] = 0; return result; } @@ -13601,10 +13599,10 @@ DN_API int DN_OS_W32Str8ToStr16Buffer(DN_Str8 src, wchar_t *dest, int dest_size) DN_API int DN_OS_W32Str16ToStr8Buffer(DN_Str16 src, char *dest, int dest_size) { int result = 0; - if (src.size == 0) + if (src.count == 0) return result; - int src_size = DN_SaturateCastISizeToInt(src.size); + int src_size = DN_SaturateCastISizeToInt(src.count); if (src_size <= 0) return result; @@ -13620,10 +13618,10 @@ DN_API int DN_OS_W32Str16ToStr8Buffer(DN_Str16 src, char *dest, int dest_size) DN_API DN_Str8 DN_OS_W32Str16ToStr8(DN_Arena *arena, DN_Str16 src) { DN_Str8 result = {}; - if (!arena || src.size == 0) + if (!arena || src.count == 0) return result; - int src_size = DN_SaturateCastISizeToInt(src.size); + int src_size = DN_SaturateCastISizeToInt(src.count); if (src_size <= 0) return result; @@ -13635,25 +13633,25 @@ DN_API DN_Str8 DN_OS_W32Str16ToStr8(DN_Arena *arena, DN_Str16 src) // null-termination already so no-need to +1 the required size DN_Arena temp = DN_ArenaTempBeginFromArena(arena); DN_Str8 buffer = DN_Str8AllocArena(required_size, DN_ZMem_No, &temp); - if (buffer.size) { - int chars_written = WideCharToMultiByte(CP_UTF8, 0 /*dwFlags*/, src.data, src_size, buffer.data, DN_Cast(int) buffer.size, nullptr, nullptr); + if (buffer.count) { + int chars_written = WideCharToMultiByte(CP_UTF8, 0 /*dwFlags*/, src.data, src_size, buffer.data, DN_Cast(int) buffer.count, nullptr, nullptr); DN_Assert(chars_written == required_size); if (chars_written == required_size) { result = buffer; - result.data[result.size] = 0; + result.data[result.count] = 0; } } - DN_ArenaTempEnd(&temp, result.size == DN_Cast(DN_USize)required_size ? DN_ArenaReset_No : DN_ArenaReset_Yes); + DN_ArenaTempEnd(&temp, result.count == DN_Cast(DN_USize)required_size ? DN_ArenaReset_No : DN_ArenaReset_Yes); return result; } DN_API DN_Str8 DN_OS_W32Str16ToStr8FromHeap(DN_Str16 src) { DN_Str8 result = {}; - if (src.size == 0) + if (src.count == 0) return result; - int src_size = DN_SaturateCastISizeToInt(src.size); + int src_size = DN_SaturateCastISizeToInt(src.count); if (src_size <= 0) return result; @@ -13664,14 +13662,14 @@ DN_API DN_Str8 DN_OS_W32Str16ToStr8FromHeap(DN_Str16 src) // NOTE: Str8 allocate ensures there's one extra byte for // null-termination already so no-need to +1 the required size DN_Str8 buffer = DN_Str8FromHeap(required_size, DN_ZMem_No); - if (buffer.size == 0) + if (buffer.count == 0) return result; - int chars_written = WideCharToMultiByte(CP_UTF8, 0 /*dwFlags*/, src.data, src_size, buffer.data, DN_Cast(int) buffer.size, nullptr, nullptr); + int chars_written = WideCharToMultiByte(CP_UTF8, 0 /*dwFlags*/, src.data, src_size, buffer.data, DN_Cast(int) buffer.count, nullptr, nullptr); DN_Assert(chars_written == required_size); if (chars_written == required_size) { result = buffer; - result.data[result.size] = 0; + result.data[result.count] = 0; } else { DN_OS_MemDealloc(buffer.data); buffer = {}; @@ -13702,9 +13700,9 @@ DN_API DN_Str16 DN_OS_W32EXEPathW(DN_Arena *arena) index_of_last_slash = module_path[index] == '\\' ? index : 0; result.data = DN_ArenaNewArray(arena, wchar_t, module_size + 1, DN_ZMem_No); - result.size = module_size; - DN_Memcpy(result.data, module_path, sizeof(wchar_t) * result.size); - result.data[result.size] = 0; + result.count = module_size; + DN_Memcpy(result.data, module_path, sizeof(wchar_t) * result.count); + result.data[result.count] = 0; DN_TCScratchEnd(&scratch); return result; } @@ -13731,9 +13729,9 @@ DN_API DN_Str16 DN_OS_W32EXEDirW(DN_Arena *arena) index_of_last_slash = module_path[index] == '\\' ? index : 0; result.data = DN_ArenaNewArray(arena, wchar_t, index_of_last_slash + 1, DN_ZMem_No); - result.size = index_of_last_slash; - DN_Memcpy(result.data, module_path, sizeof(wchar_t) * result.size); - result.data[result.size] = 0; + result.count = index_of_last_slash; + DN_Memcpy(result.data, module_path, sizeof(wchar_t) * result.count); + result.data[result.count] = 0; DN_TCScratchEnd(&scratch); return result; } @@ -13750,13 +13748,13 @@ DN_API DN_Str8 DN_OS_W32WorkingDir(DN_Arena *arena, DN_Str8 suffix) DN_API DN_Str16 DN_OS_W32WorkingDirW(DN_Arena *arena, DN_Str16 suffix) { - DN_Assert(suffix.size >= 0); + DN_Assert(suffix.count >= 0); DN_Str16 result = {}; // NOTE: required_size is the size required *including* the null-terminator DN_TCScratch scratch = DN_TCScratchBeginArena(&arena, 1); unsigned long required_size = GetCurrentDirectoryW(0, nullptr); - unsigned long desired_size = required_size + DN_Cast(unsigned long) suffix.size; + unsigned long desired_size = required_size + DN_Cast(unsigned long) suffix.count; wchar_t *scratch_w_path = DN_ArenaNewArray(&scratch.arena, wchar_t, desired_size, DN_ZMem_No); if (!scratch_w_path) { @@ -13777,9 +13775,9 @@ DN_API DN_Str16 DN_OS_W32WorkingDirW(DN_Arena *arena, DN_Str16 suffix) return result; } - if (suffix.size) { + if (suffix.count) { DN_Memcpy(w_path, scratch_w_path, sizeof(*scratch_w_path) * bytes_written_wo_null_terminator); - DN_Memcpy(w_path + bytes_written_wo_null_terminator, suffix.data, sizeof(suffix.data[0]) * suffix.size); + DN_Memcpy(w_path + bytes_written_wo_null_terminator, suffix.data, sizeof(suffix.data[0]) * suffix.count); w_path[desired_size] = 0; } @@ -13815,14 +13813,14 @@ DN_API bool DN_OS_W32DirWIterate(DN_Str16 path, DN_OSW32FolderIteratorW *it) if (find_data.cFileName[0] == '.' || (find_data.cFileName[0] == '.' && find_data.cFileName[1] == '.')) continue; - it->file_name.size = DN_CStr16Size(find_data.cFileName); - DN_Assert(it->file_name.size < (DN_ArrayCountU(it->file_name_buf) - 1)); - DN_Memcpy(it->file_name.data, find_data.cFileName, it->file_name.size * sizeof(wchar_t)); - it->file_name_buf[it->file_name.size] = 0; + it->file_name.count = DN_CStr16Count(find_data.cFileName); + DN_Assert(it->file_name.count < (DN_ArrayCountU(it->file_name_buf) - 1)); + DN_Memcpy(it->file_name.data, find_data.cFileName, it->file_name.count * sizeof(wchar_t)); + it->file_name_buf[it->file_name.count] = 0; break; } while (FindNextFileW(it->handle, &find_data) != 0); - bool result = it->file_name.size > 0; + bool result = it->file_name.count > 0; if (!result) FindClose(it->handle); return result; @@ -14155,13 +14153,13 @@ static DN_UTCore DN_TST_Base() for (DN_UT_Test(&result, "Age from U64: 1001 converts to 1s 1ms (seconds and ms)")) { DN_Str8x128 str8 = DN_AgeStr8FromMsU64(1001, DN_AgeUnit_Sec | DN_AgeUnit_Ms); DN_Str8 expect = DN_Str8Lit("1s 1ms"); - DN_UT_AssertF(&result, DN_MemEq(str8.data, str8.size, expect.data, expect.size), "str8=%.*s, expect=%.*s", DN_Str8PrintFmt(str8), DN_Str8PrintFmt(expect)); + DN_UT_AssertF(&result, DN_MemEq(str8.data, str8.count, expect.data, expect.count), "str8=%.*s, expect=%.*s", DN_Str8PrintFmt(str8), DN_Str8PrintFmt(expect)); } for (DN_UT_Test(&result, "Age from U64: 1001 converts to 1.001s (fractional)")) { DN_Str8x128 str8 = DN_AgeStr8FromMsU64(1001, DN_AgeUnit_FractionalSec); DN_Str8 expect = DN_Str8Lit("1.001s"); - DN_UT_AssertF(&result, DN_MemEq(str8.data, str8.size, expect.data, expect.size), "str8=%.*s, expect=%.*s", DN_Str8PrintFmt(str8), DN_Str8PrintFmt(expect)); + DN_UT_AssertF(&result, DN_MemEq(str8.data, str8.count, expect.data, expect.count), "str8=%.*s, expect=%.*s", DN_Str8PrintFmt(str8), DN_Str8PrintFmt(expect)); } for (DN_UT_Test(&result, "FmtAppendTruncate: String truncates with 3 dots")) { @@ -14501,12 +14499,12 @@ static DN_UTCore DN_TST_BaseBytesHex() DN_UT_AssertF(&test, DN_Str8Eq(bytes, DN_Str8Lit("\xf6\xed\x00")), "number_hex=%.*s", - DN_Str8PrintFmt(DN_HexFromPtrBytesArena(bytes.data, bytes.size, &scratch.arena, DN_TrimLeadingZero_No))); + DN_Str8PrintFmt(DN_HexFromPtrBytesArena(bytes.data, bytes.count, &scratch.arena, DN_TrimLeadingZero_No))); } for (DN_UT_Test(&test, "Convert empty bytes to string", number)) { DN_Str8 bytes = DN_Str8Lit(""); - DN_Str8 as_hex = DN_HexFromPtrBytesArena(bytes.data, bytes.size, &scratch.arena, DN_TrimLeadingZero_No); + DN_Str8 as_hex = DN_HexFromPtrBytesArena(bytes.data, bytes.count, &scratch.arena, DN_TrimLeadingZero_No); DN_UT_AssertF(&test, DN_Str8Eq(as_hex, DN_Str8Lit("")), "as_hex=%.*s", DN_Str8PrintFmt(as_hex)); } } @@ -15864,13 +15862,13 @@ DN_Str8 const DN_UT_HASH_STRING_[] = void DN_TST_KeccakDispatch_(DN_UTCore *test, int hash_type, DN_Str8 input) { DN_TCScratch scratch = DN_TCScratchBeginArena(nullptr, 0); - DN_Str8 input_hex = DN_HexFromPtrBytesArena(input.data, input.size, &scratch.arena, DN_TrimLeadingZero_No); + DN_Str8 input_hex = DN_HexFromPtrBytesArena(input.data, input.count, &scratch.arena, DN_TrimLeadingZero_No); switch (hash_type) { case Hash_SHA3_224: { - DN_SHA3U8x28 hash = DN_SHA3Hash224b(input.data, input.size); + DN_SHA3U8x28 hash = DN_SHA3Hash224b(input.data, input.count); DN_SHA3U8x28 expect; - DN_RefImpl_FIPS202_SHA3_224_(DN_Cast(uint8_t *) input.data, input.size, (uint8_t *)expect.data); + DN_RefImpl_FIPS202_SHA3_224_(DN_Cast(uint8_t *) input.data, input.count, (uint8_t *)expect.data); DN_Str8 hash_hex = DN_HexFromPtrBytesArena(hash.data, DN_ArrayCountU(hash.data), &scratch.arena, DN_TrimLeadingZero_No); DN_Str8 expect_hex = DN_HexFromPtrBytesArena(expect.data, DN_ArrayCountU(expect.data), &scratch.arena, DN_TrimLeadingZero_No); @@ -15885,9 +15883,9 @@ void DN_TST_KeccakDispatch_(DN_UTCore *test, int hash_type, DN_Str8 input) } break; case Hash_SHA3_256: { - DN_SHA3U8x32 hash = DN_SHA3Hash256b(input.data, input.size); + DN_SHA3U8x32 hash = DN_SHA3Hash256b(input.data, input.count); DN_SHA3U8x32 expect; - DN_RefImpl_FIPS202_SHA3_256_(DN_Cast(uint8_t *) input.data, input.size, (uint8_t *)expect.data); + DN_RefImpl_FIPS202_SHA3_256_(DN_Cast(uint8_t *) input.data, input.count, (uint8_t *)expect.data); DN_Str8 hash_hex = DN_HexFromPtrBytesArena(hash.data, DN_ArrayCountU(hash.data), &scratch.arena, DN_TrimLeadingZero_No); DN_Str8 expect_hex = DN_HexFromPtrBytesArena(expect.data, DN_ArrayCountU(expect.data), &scratch.arena, DN_TrimLeadingZero_No); @@ -15902,9 +15900,9 @@ void DN_TST_KeccakDispatch_(DN_UTCore *test, int hash_type, DN_Str8 input) } break; case Hash_SHA3_384: { - DN_SHA3U8x48 hash = DN_SHA3Hash384b(input.data, input.size); + DN_SHA3U8x48 hash = DN_SHA3Hash384b(input.data, input.count); DN_SHA3U8x48 expect; - DN_RefImpl_FIPS202_SHA3_384_(DN_Cast(uint8_t *) input.data, input.size, (uint8_t *)expect.data); + DN_RefImpl_FIPS202_SHA3_384_(DN_Cast(uint8_t *) input.data, input.count, (uint8_t *)expect.data); DN_Str8 hash_hex = DN_HexFromPtrBytesArena(hash.data, DN_ArrayCountU(hash.data), &scratch.arena, DN_TrimLeadingZero_No); DN_Str8 expect_hex = DN_HexFromPtrBytesArena(expect.data, DN_ArrayCountU(expect.data), &scratch.arena, DN_TrimLeadingZero_No); @@ -15919,9 +15917,9 @@ void DN_TST_KeccakDispatch_(DN_UTCore *test, int hash_type, DN_Str8 input) } break; case Hash_SHA3_512: { - DN_SHA3U8x64 hash = DN_SHA3Hash512b(input.data, input.size); + DN_SHA3U8x64 hash = DN_SHA3Hash512b(input.data, input.count); DN_SHA3U8x64 expect; - DN_RefImpl_FIPS202_SHA3_512_(DN_Cast(uint8_t *) input.data, input.size, (uint8_t *)expect.data); + DN_RefImpl_FIPS202_SHA3_512_(DN_Cast(uint8_t *) input.data, input.count, (uint8_t *)expect.data); DN_Str8 hash_hex = DN_HexFromPtrBytesArena(hash.data, DN_ArrayCountU(hash.data), &scratch.arena, DN_TrimLeadingZero_No); DN_Str8 expect_hex = DN_HexFromPtrBytesArena(expect.data, DN_ArrayCountU(expect.data), &scratch.arena, DN_TrimLeadingZero_No); @@ -15936,9 +15934,9 @@ void DN_TST_KeccakDispatch_(DN_UTCore *test, int hash_type, DN_Str8 input) } break; case Hash_Keccak_224: { - DN_SHA3U8x28 hash = DN_KeccakHash224b(input.data, input.size); + DN_SHA3U8x28 hash = DN_KeccakHash224b(input.data, input.count); DN_SHA3U8x28 expect; - DN_RefImpl_Keccak_(1152, 448, DN_Cast(uint8_t *) input.data, input.size, 0x01, (uint8_t *)expect.data, sizeof(expect)); + DN_RefImpl_Keccak_(1152, 448, DN_Cast(uint8_t *) input.data, input.count, 0x01, (uint8_t *)expect.data, sizeof(expect)); DN_Str8 hash_hex = DN_HexFromPtrBytesArena(hash.data, DN_ArrayCountU(hash.data), &scratch.arena, DN_TrimLeadingZero_No); DN_Str8 expect_hex = DN_HexFromPtrBytesArena(expect.data, DN_ArrayCountU(expect.data), &scratch.arena, DN_TrimLeadingZero_No); @@ -15953,9 +15951,9 @@ void DN_TST_KeccakDispatch_(DN_UTCore *test, int hash_type, DN_Str8 input) } break; case Hash_Keccak_256: { - DN_SHA3U8x32 hash = DN_KeccakHash256b(input.data, input.size); + DN_SHA3U8x32 hash = DN_KeccakHash256b(input.data, input.count); DN_SHA3U8x32 expect; - DN_RefImpl_Keccak_(1088, 512, DN_Cast(uint8_t *) input.data, input.size, 0x01, (uint8_t *)expect.data, sizeof(expect)); + DN_RefImpl_Keccak_(1088, 512, DN_Cast(uint8_t *) input.data, input.count, 0x01, (uint8_t *)expect.data, sizeof(expect)); DN_Str8 hash_hex = DN_HexFromPtrBytesArena(hash.data, DN_ArrayCountU(hash.data), &scratch.arena, DN_TrimLeadingZero_No); DN_Str8 expect_hex = DN_HexFromPtrBytesArena(expect.data, DN_ArrayCountU(expect.data), &scratch.arena, DN_TrimLeadingZero_No); @@ -15970,9 +15968,9 @@ void DN_TST_KeccakDispatch_(DN_UTCore *test, int hash_type, DN_Str8 input) } break; case Hash_Keccak_384: { - DN_SHA3U8x48 hash = DN_KeccakHash384b(input.data, input.size); + DN_SHA3U8x48 hash = DN_KeccakHash384b(input.data, input.count); DN_SHA3U8x48 expect; - DN_RefImpl_Keccak_(832, 768, DN_Cast(uint8_t *) input.data, input.size, 0x01, (uint8_t *)expect.data, sizeof(expect)); + DN_RefImpl_Keccak_(832, 768, DN_Cast(uint8_t *) input.data, input.count, 0x01, (uint8_t *)expect.data, sizeof(expect)); DN_Str8 hash_hex = DN_HexFromPtrBytesArena(hash.data, DN_ArrayCountU(hash.data), &scratch.arena, DN_TrimLeadingZero_No); DN_Str8 expect_hex = DN_HexFromPtrBytesArena(expect.data, DN_ArrayCountU(expect.data), &scratch.arena, DN_TrimLeadingZero_No); @@ -15987,9 +15985,9 @@ void DN_TST_KeccakDispatch_(DN_UTCore *test, int hash_type, DN_Str8 input) } break; case Hash_Keccak_512: { - DN_SHA3U8x64 hash = DN_KeccakHash512b(input.data, input.size); + DN_SHA3U8x64 hash = DN_KeccakHash512b(input.data, input.count); DN_SHA3U8x64 expect; - DN_RefImpl_Keccak_(576, 1024, DN_Cast(uint8_t *) input.data, input.size, 0x01, (uint8_t *)expect.data, sizeof(expect)); + DN_RefImpl_Keccak_(576, 1024, DN_Cast(uint8_t *) input.data, input.count, 0x01, (uint8_t *)expect.data, sizeof(expect)); DN_Str8 hash_hex = DN_HexFromPtrBytesArena(hash.data, DN_ArrayCountU(hash.data), &scratch.arena, DN_TrimLeadingZero_No); DN_Str8 expect_hex = DN_HexFromPtrBytesArena(expect.data, DN_ArrayCountU(expect.data), &scratch.arena, DN_TrimLeadingZero_No); @@ -16024,7 +16022,7 @@ DN_UTCore DN_TST_Keccak() for (int hash_type = 0; hash_type < Hash_Count; hash_type++) { DN_PCG32 rng = DN_PCG32Init(0xd48e'be21'2af8'733d); for (DN_Str8 input : INPUTS) { - DN_UT_BeginF(&result, "%.*s - Input: %.*s", DN_Str8PrintFmt(DN_UT_HASH_STRING_[hash_type]), DN_Cast(int) DN_Min(input.size, 54), input.data); + DN_UT_BeginF(&result, "%.*s - Input: %.*s", DN_Str8PrintFmt(DN_UT_HASH_STRING_[hash_type]), DN_Cast(int) DN_Min(input.count, 54), input.data); DN_TST_KeccakDispatch_(&result, hash_type, input); DN_UT_End(&result); } @@ -16093,8 +16091,8 @@ static DN_UTCore DN_TST_OS() for (DN_UT_Test(&result, "Query executable directory")) { DN_TCScratch scratch = DN_TCScratchBeginArena(nullptr, 0); DN_Str8 os_result = DN_OS_EXEDir(&scratch.arena); - DN_UT_Assert(&result, os_result.size); - DN_UT_AssertF(&result, DN_OS_PathIsDir(os_result), "result(%zu): %.*s", os_result.size, DN_Str8PrintFmt(os_result)); + DN_UT_Assert(&result, os_result.count); + DN_UT_AssertF(&result, DN_OS_PathIsDir(os_result), "result(%zu): %.*s", os_result.count, DN_Str8PrintFmt(os_result)); DN_TCScratchEnd(&scratch); } @@ -16144,9 +16142,9 @@ static DN_UTCore DN_TST_OS() // NOTE: Read step DN_TCScratch scratch = DN_TCScratchBeginArena(nullptr, 0); DN_Str8 read_file = DN_OS_FileReadAllArena(&scratch.arena, SRC_FILE, nullptr); - DN_UT_AssertF(&result, read_file.size, "Failed to load file"); - DN_UT_AssertF(&result, read_file.size == 4, "File read wrong amount of bytes (%zu)", read_file.size); - DN_UT_AssertF(&result, DN_Str8Eq(read_file, DN_Str8Lit("1234")), "Read %zu bytes instead of the expected 4: '%.*s'", read_file.size, DN_Str8PrintFmt(read_file)); + DN_UT_AssertF(&result, read_file.count, "Failed to load file"); + DN_UT_AssertF(&result, read_file.count == 4, "File read wrong amount of bytes (%zu)", read_file.count); + DN_UT_AssertF(&result, DN_Str8Eq(read_file, DN_Str8Lit("1234")), "Read %zu bytes instead of the expected 4: '%.*s'", read_file.count, DN_Str8PrintFmt(read_file)); // NOTE: Copy step DN_Str8 const COPY_FILE = DN_Str8Lit("dn_result_file_copy"); @@ -16362,13 +16360,13 @@ static DN_UTCore DN_TST_BaseStrings() { for (DN_UT_Test(&result, "Str8 literal")) { DN_Str8 string = DN_Str8Lit("AB"); - DN_UT_AssertF(&result, string.size == 2, "size: %zu", string.size); + DN_UT_AssertF(&result, string.count == 2, "size: %zu", string.count); DN_UT_AssertF(&result, string.data[0] == 'A', "string[0]: %c", string.data[0]); DN_UT_AssertF(&result, string.data[1] == 'B', "string[1]: %c", string.data[1]); } for (DN_UT_Test(&result, "C-string length")) { - DN_USize size = DN_CStr8Size("hello"); + DN_USize size = DN_CStr8Count("hello"); DN_UT_AssertF(&result, size == 5, "size=%zu", size); } @@ -16399,7 +16397,7 @@ static DN_UTCore DN_TST_BaseStrings() for (DN_UT_Test(&result, "Initialise with format string")) { DN_TCScratch scratch = DN_TCScratchBeginArena(nullptr, 0); DN_Str8 string = DN_Str8FromFmtArena(&scratch.arena, "%s", "AB"); - DN_UT_AssertF(&result, string.size == 2, "size: %zu", string.size); + DN_UT_AssertF(&result, string.count == 2, "size: %zu", string.count); DN_UT_AssertF(&result, string.data[0] == 'A', "string[0]: %c", string.data[0]); DN_UT_AssertF(&result, string.data[1] == 'B', "string[1]: %c", string.data[1]); DN_UT_AssertF(&result, string.data[2] == 0, "string[2]: %c", string.data[2]); @@ -16410,7 +16408,7 @@ static DN_UTCore DN_TST_BaseStrings() DN_TCScratch scratch = DN_TCScratchBeginArena(nullptr, 0); DN_Str8 string = DN_Str8Lit("AB"); DN_Str8 copy = DN_Str8FromStr8Arena(string, &scratch.arena); - DN_UT_AssertF(&result, copy.size == 2, "size: %zu", copy.size); + DN_UT_AssertF(&result, copy.count == 2, "size: %zu", copy.count); DN_UT_AssertF(&result, copy.data[0] == 'A', "copy[0]: %c", copy.data[0]); DN_UT_AssertF(&result, copy.data[1] == 'B', "copy[1]: %c", copy.data[1]); DN_UT_AssertF(&result, copy.data[2] == 0, "copy[2]: %c", copy.data[2]); @@ -16425,7 +16423,7 @@ static DN_UTCore DN_TST_BaseStrings() for (DN_UT_Test(&result, "Allocate string from arena")) { DN_TCScratch scratch = DN_TCScratchBeginArena(nullptr, 0); DN_Str8 string = DN_Str8AllocArena(2, DN_ZMem_No, &scratch.arena); - DN_UT_AssertF(&result, string.size == 2, "size: %zu", string.size); + DN_UT_AssertF(&result, string.count == 2, "size: %zu", string.count); DN_TCScratchEnd(&scratch); } @@ -16625,7 +16623,7 @@ static DN_UTCore DN_TST_BaseStrings() DN_UT_Assert(&result, !str_result.found); DN_UT_Assert(&result, str_result.index == 0); DN_UT_Assert(&result, str_result.match.data == nullptr); - DN_UT_Assert(&result, str_result.match.size == 0); + DN_UT_Assert(&result, str_result.match.count == 0); } for (DN_UT_Test(&result, "Find: String (char) is in buffer")) { @@ -16666,7 +16664,7 @@ static DN_UTCore DN_TST_BaseStrings() char dest[64] = {}; DN_Str8TruncResult res = DN_Str8TruncMiddlePtr(str, 5, trunc, dest, sizeof(dest)); DN_UT_Assert(&result, !res.truncated); - DN_UT_Assert(&result, res.size_req == 5); + DN_UT_Assert(&result, res.count_req == 5); DN_UT_AssertF(&result, DN_Str8Eq(res.str8, DN_Str8Lit("Hello")), "%.*s", DN_Str8PrintFmt(res.str8)); } @@ -16676,7 +16674,7 @@ static DN_UTCore DN_TST_BaseStrings() char dest[64] = {}; DN_Str8TruncResult res = DN_Str8TruncMiddlePtr(str, 5, trunc, dest, sizeof(dest)); DN_UT_Assert(&result, !res.truncated); - DN_UT_Assert(&result, res.size_req == 10); + DN_UT_Assert(&result, res.count_req == 10); DN_UT_AssertF(&result, DN_Str8Eq(res.str8, DN_Str8Lit("HelloWorld")), "%.*s", DN_Str8PrintFmt(res.str8)); } @@ -16686,7 +16684,7 @@ static DN_UTCore DN_TST_BaseStrings() char dest[64] = {}; DN_Str8TruncResult res = DN_Str8TruncMiddlePtr(str, 5, trunc, dest, sizeof(dest)); DN_UT_Assert(&result, res.truncated); - DN_UT_Assert(&result, res.size_req == 13); // 5 + 3 + 5 + DN_UT_Assert(&result, res.count_req == 13); // 5 + 3 + 5 DN_UT_AssertF(&result, DN_Str8Eq(res.str8, DN_Str8Lit("Hello...World")), "%.*s", DN_Str8PrintFmt(res.str8)); } @@ -16696,7 +16694,7 @@ static DN_UTCore DN_TST_BaseStrings() char dest[64] = {}; DN_Str8TruncResult res = DN_Str8TruncMiddlePtr(str, 5, trunc, dest, sizeof(dest)); DN_UT_Assert(&result, res.truncated); - DN_UT_Assert(&result, res.size_req == 10); // 5 + 0 + 5 + DN_UT_Assert(&result, res.count_req == 10); // 5 + 0 + 5 DN_UT_AssertF(&result, DN_Str8Eq(res.str8, DN_Str8Lit("HelloWorld")), "%.*s", DN_Str8PrintFmt(res.str8)); } @@ -16706,7 +16704,7 @@ static DN_UTCore DN_TST_BaseStrings() char dest[64] = {}; DN_Str8TruncResult res = DN_Str8TruncMiddlePtr(str, 0, trunc, dest, sizeof(dest)); DN_UT_Assert(&result, res.truncated); - DN_UT_Assert(&result, res.size_req == 3); + DN_UT_Assert(&result, res.count_req == 3); DN_UT_AssertF(&result, DN_Str8Eq(res.str8, DN_Str8Lit("...")), "%.*s", DN_Str8PrintFmt(res.str8)); } @@ -16715,17 +16713,17 @@ static DN_UTCore DN_TST_BaseStrings() DN_Str8 trunc = DN_Str8Lit("..."); DN_Str8TruncResult res = DN_Str8TruncMiddlePtr(str, 5, trunc, nullptr, 0); DN_UT_Assert(&result, res.truncated); - DN_UT_Assert(&result, res.size_req == 13); + DN_UT_Assert(&result, res.count_req == 13); DN_UT_Assert(&result, res.str8.data == nullptr); } - for (DN_UT_Test(&result, "TruncMiddlePtr: size_req is consistent between dry-run and actual")) { + for (DN_UT_Test(&result, "TruncMiddlePtr: count_req is consistent between dry-run and actual")) { DN_Str8 str = DN_Str8Lit("HelloBeautifulWorld"); DN_Str8 trunc = DN_Str8Lit("..."); DN_Str8TruncResult dry = DN_Str8TruncMiddlePtr(str, 5, trunc, nullptr, 0); char dest[64] = {}; DN_Str8TruncResult actual = DN_Str8TruncMiddlePtr(str, 5, trunc, dest, sizeof(dest)); - DN_UT_Assert(&result, dry.size_req == actual.size_req); + DN_UT_Assert(&result, dry.count_req == actual.count_req); DN_UT_Assert(&result, dry.truncated == actual.truncated); } @@ -16735,7 +16733,7 @@ static DN_UTCore DN_TST_BaseStrings() char dest[14] = {}; // Exactly 2*5 + 3 + 1 DN_Str8TruncResult res = DN_Str8TruncMiddlePtr(str, 5, trunc, dest, sizeof(dest)); DN_UT_Assert(&result, res.truncated); - DN_UT_Assert(&result, res.size_req == 13); + DN_UT_Assert(&result, res.count_req == 13); DN_UT_AssertF(&result, DN_Str8Eq(res.str8, DN_Str8Lit("Hello...World")), "%.*s", DN_Str8PrintFmt(res.str8)); } @@ -16745,7 +16743,7 @@ static DN_UTCore DN_TST_BaseStrings() char dest[64] = {}; DN_Str8TruncResult res = DN_Str8TruncMiddlePtr(str, 1, trunc, dest, sizeof(dest)); DN_UT_Assert(&result, res.truncated); - DN_UT_Assert(&result, res.size_req == 5); // 1 + 3 + 1 + DN_UT_Assert(&result, res.count_req == 5); // 1 + 3 + 1 DN_UT_AssertF(&result, DN_Str8Eq(res.str8, DN_Str8Lit("H...d")), "%.*s", DN_Str8PrintFmt(res.str8)); } @@ -16755,7 +16753,7 @@ static DN_UTCore DN_TST_BaseStrings() char dest[64] = {}; DN_Str8TruncResult res = DN_Str8TruncMiddlePtr(str, 100, trunc, dest, sizeof(dest)); DN_UT_Assert(&result, !res.truncated); - DN_UT_Assert(&result, res.size_req == 5); + DN_UT_Assert(&result, res.count_req == 5); DN_UT_AssertF(&result, DN_Str8Eq(res.str8, DN_Str8Lit("Hello")), "%.*s", DN_Str8PrintFmt(res.str8)); } @@ -16766,9 +16764,9 @@ static DN_UTCore DN_TST_BaseStrings() DN_Str8 trunc = DN_Str8Lit("..."); DN_Str8TruncResult res = DN_Str8TruncMiddle(str, 5, trunc, &scratch.arena); DN_UT_Assert(&result, res.truncated); - DN_UT_Assert(&result, res.size_req == 13); + DN_UT_Assert(&result, res.count_req == 13); DN_UT_AssertF(&result, DN_Str8Eq(res.str8, DN_Str8Lit("Hello...World")), "%.*s", DN_Str8PrintFmt(res.str8)); - DN_UT_Assert(&result, res.str8.data[res.str8.size] == '\0'); + DN_UT_Assert(&result, res.str8.data[res.str8.count] == '\0'); DN_TCScratchEnd(&scratch); } } @@ -16816,8 +16814,8 @@ static DN_UTCore DN_TST_Win() int size_returned = DN_OS_W32Str16ToStr8Buffer(input16, nullptr, 0); char const EXPECTED[] = {'S', 't', 'r', 'i', 'n', 'g', 0}; - DN_UT_AssertF(&result, DN_Cast(int) string8.size == size_returned, "string_size: %d, result: %d", DN_Cast(int) string8.size, size_returned); - DN_UT_AssertF(&result, DN_Cast(int) string8.size == DN_ArrayCountU(EXPECTED) - 1, "string_size: %d, expected: %zu", DN_Cast(int) string8.size, DN_ArrayCountU(EXPECTED) - 1); + DN_UT_AssertF(&result, DN_Cast(int) string8.count == size_returned, "string_size: %d, result: %d", DN_Cast(int) string8.count, size_returned); + DN_UT_AssertF(&result, DN_Cast(int) string8.count == DN_ArrayCountU(EXPECTED) - 1, "string_size: %d, expected: %zu", DN_Cast(int) string8.count, DN_ArrayCountU(EXPECTED) - 1); DN_UT_Assert(&result, DN_Memcmp(EXPECTED, string8.data, sizeof(EXPECTED)) == 0); } DN_TCScratchEnd(&scratch); @@ -16840,7 +16838,7 @@ static DN_UTCore DN_TST_Net() label = DN_Str8Lit("CURL"); #endif - if (label.size) { + if (label.count) { DN_UT_LogF(&result, "DN_NET\n"); DN_MemList mem = DN_MemListFromHeap(DN_Megabytes(4), DN_MemFlags_Nil); @@ -16859,8 +16857,8 @@ static DN_UTCore DN_TST_Net() DN_NETResponse response = net_interface.wait_for_response(request, &arena, UINT32_MAX); DN_UT_AssertF(&result, response.http_status == 200, "http_status=%u", response.http_status); DN_UT_AssertF(&result, response.state == DN_NETResponseState_HTTP, "state=%u", response.state); - DN_UT_AssertF(&result, response.error_str8.size == 0, "%.*s", DN_Str8PrintFmt(response.error_str8)); - DN_UT_Assert(&result, response.body.size); + DN_UT_AssertF(&result, response.error_str8.count == 0, "%.*s", DN_Str8PrintFmt(response.error_str8)); + DN_UT_Assert(&result, response.body.count); } for (DN_UT_Test(&result, "%.*s WaitForResponse HTTP POST request", DN_Str8PrintFmt(label))) { @@ -16868,8 +16866,8 @@ static DN_UTCore DN_TST_Net() DN_NETResponse response = net_interface.wait_for_any_response(&net, &arena, UINT32_MAX); DN_UT_AssertF(&result, response.http_status == 200, "http_status=%u", response.http_status); DN_UT_AssertF(&result, response.state == DN_NETResponseState_HTTP, "state=%u", response.state); - DN_UT_AssertF(&result, response.error_str8.size == 0, "error=%.*s", DN_Str8PrintFmt(response.error_str8)); - DN_UT_Assert(&result, response.body.size); + DN_UT_AssertF(&result, response.error_str8.count == 0, "error=%.*s", DN_Str8PrintFmt(response.error_str8)); + DN_UT_Assert(&result, response.body.count); } for (DN_UT_Test(&result, "%.*s WaitForResponse WS request", DN_Str8PrintFmt(label))) { @@ -17016,6 +17014,18 @@ bool DN_NET_ResponseHasFailed(DN_NETResponse const* resp) return result; } +bool DN_NET_ResponseHasSucceeded(DN_NETResponse const* resp) +{ + bool result = !DN_NET_ResponseHasFailed(resp); + return result; +} + +bool DN_NET_ResponseIsReady(DN_NETResponse const* resp) +{ + bool result = resp && resp->state != DN_NETResponseState_Nil; + return result; +} + DN_Str8 DN_NET_Str8DiagnosticFromResponse(DN_NETResponse const* resp, DN_Arena *arena) { DN_TCScratch scratch = DN_TCScratchBeginArena(&arena, 1); @@ -17027,12 +17037,12 @@ DN_Str8 DN_NET_Str8DiagnosticFromResponse(DN_NETResponse const* resp, DN_Arena * DN_Str8BuilderAppendF(&builder, " %u", resp->http_status); } DN_Str8BuilderAppendF(&builder, ")"); - if (resp->body.size || resp->error_str8.size) { + if (resp->body.count || resp->error_str8.count) { DN_Str8BuilderAppendRef(&builder, DN_Str8Lit(" with ")); - if (resp->body.size) + if (resp->body.count) DN_Str8BuilderAppendF(&builder, "%.*s", DN_Str8PrintFmt(resp->body)); - if (resp->error_str8.size) - DN_Str8BuilderAppendF(&builder, "%s%.*s", resp->body.size ? ". " : "", DN_Str8PrintFmt(resp->error_str8)); + if (resp->error_str8.count) + DN_Str8BuilderAppendF(&builder, "%s%.*s", resp->body.count ? ". " : "", DN_Str8PrintFmt(resp->error_str8)); } DN_Str8 result = DN_Str8FromStr8BuilderArena(&builder, arena); DN_TCScratchEnd(&scratch); @@ -17113,7 +17123,7 @@ enum DN_NETCurlRingEventType DN_NETCurlRingEventType_DeinitRequest, }; -struct DN_NETCurlRingEvent +struct DN_NETCurlRingEvent_ { DN_NETCurlRingEventType type; DN_NETRequestHandle request; @@ -17185,18 +17195,18 @@ static int32_t DN_NET_CurlThreadEntryPoint_(DN_OSThread *thread) // NOTE: Handle events sitting in the ring queue for (bool dequeue_ring = true; dequeue_ring;) { - DN_NETCurlRingEvent event = {}; + DN_NETCurlRingEvent_ event = {}; for (DN_OS_MutexScope(&curl->ring_mutex)) { if (DN_RingHasData(&curl->ring, sizeof(event))) DN_RingRead(&curl->ring, &event, sizeof(event)); } - DN_NETRequest *req = DN_NET_RequestFromHandle(event.request); - DN_NETCurlRequest *curl_req = DN_NET_CurlRequestFromRequest_(req); switch (event.type) { case DN_NETCurlRingEventType_Nil: dequeue_ring = false; break; case DN_NETCurlRingEventType_DoRequest: { + DN_NETRequest *req = DN_NET_RequestFromHandle(event.request); + DN_NETCurlRequest *curl_req = DN_NET_CurlRequestFromRequest_(req); DN_Assert(req->response.state == DN_NETResponseState_Nil); DN_Assert(req->type != DN_NETRequestType_Nil); @@ -17214,11 +17224,13 @@ static int32_t DN_NET_CurlThreadEntryPoint_(DN_OSThread *thread) } break; case DN_NETCurlRingEventType_SendWS: { + DN_NETRequest *req = DN_NET_RequestFromHandle(event.request); + DN_NETCurlRequest *curl_req = DN_NET_CurlRequestFromRequest_(req); DN_Str8 payload = {}; for (DN_OS_MutexScope(&curl->ring_mutex)) { DN_Assert(DN_RingHasData(&curl->ring, event.ws_send_size)); payload = DN_Str8AllocArena(event.ws_send_size, DN_ZMem_No, &tmem.arena); - DN_RingRead(&curl->ring, payload.data, payload.size); + DN_RingRead(&curl->ring, payload.data, payload.count); } DN_U32 curlws_flag = 0; @@ -17234,12 +17246,14 @@ static int32_t DN_NET_CurlThreadEntryPoint_(DN_OSThread *thread) DN_Assert(req->response.state >= DN_NETResponseState_WSOpen && req->response.state <= DN_NETResponseState_WSPong); DN_USize sent = 0; - CURLcode send_result = curl_ws_send(curl_req->handle, payload.data, payload.size, &sent, 0, curlws_flag); + CURLcode send_result = curl_ws_send(curl_req->handle, payload.data, payload.count, &sent, 0, curlws_flag); DN_AssertF(send_result == CURLE_OK, "Failed to send: %s", curl_easy_strerror(send_result)); - DN_AssertF(sent == payload.size, "Failed to send all bytes (%zu vs %zu)", sent, payload.size); + DN_AssertF(sent == payload.count, "Failed to send all bytes (%zu vs %zu)", sent, payload.count); } break; case DN_NETCurlRingEventType_ReceivedWSReceipt: { + DN_NETRequest *req = DN_NET_RequestFromHandle(event.request); + DN_NETCurlRequest *curl_req = DN_NET_CurlRequestFromRequest_(req); DN_Assert(req->type == DN_NETRequestType_WS); DN_Assert(req->response.state >= DN_NETResponseState_WSOpen && req->response.state <= DN_NETResponseState_WSPong); req->response.state = DN_NETResponseState_WSOpen; @@ -17259,6 +17273,9 @@ static int32_t DN_NET_CurlThreadEntryPoint_(DN_OSThread *thread) } break; case DN_NETCurlRingEventType_DeinitRequest: { + DN_NETRequest *req = DN_NET_RequestFromHandle(event.request); + DN_NETCurlRequest *curl_req = DN_NET_CurlRequestFromRequest_(req); + DN_Assert(event.request.handle != 0); DN_NETRequest *request = DN_Cast(DN_NETRequest *) event.request.handle; @@ -17284,7 +17301,7 @@ static int32_t DN_NET_CurlThreadEntryPoint_(DN_OSThread *thread) // NOTE: Zero the struct preserving just the data we need to retain DN_NETRequest resetter = {}; resetter.arena = request->arena; - resetter.gen = request->gen; + resetter.gen = request->gen + 1; DN_Memcpy(resetter.context, request->context, sizeof(resetter.context)); *request = resetter; @@ -17330,7 +17347,7 @@ static int32_t DN_NET_CurlThreadEntryPoint_(DN_OSThread *thread) req->response.state = DN_NETResponseState_Error; } } else { - DN_USize curl_extended_error_size = DN_CStr8Size(curl_req->error); + DN_USize curl_extended_error_size = DN_CStr8Count(curl_req->error); req->response.state = DN_NETResponseState_Error; req->response.error_str8 = DN_Str8FromFmtArena(&req->start_response_arena, "HTTP request '%.*s' failed (CURL %d): %s%s%s%s", @@ -17406,9 +17423,9 @@ static int32_t DN_NET_CurlThreadEntryPoint_(DN_OSThread *thread) // NOTE: Allocate and read (we use meta->bytesleft as per comment from initial recv) if (meta->bytesleft) { DN_Str8 buffer = DN_Str8AllocArena(meta->bytesleft, DN_ZMem_No, &req->start_response_arena); - DN_Assert(buffer.size == DN_Cast(DN_USize)meta->bytesleft); - receive_result = curl_ws_recv(curl_req->handle, buffer.data, buffer.size, &buffer.size, &meta); - DN_Assert(buffer.size == DN_Cast(DN_USize)meta->len); + DN_Assert(buffer.count == DN_Cast(DN_USize)meta->bytesleft); + receive_result = curl_ws_recv(curl_req->handle, buffer.data, buffer.count, &buffer.count, &meta); + DN_Assert(buffer.count == DN_Cast(DN_USize)meta->len); DN_Str8BuilderAppendRef(&curl_req->str8_builder, buffer); } @@ -17453,7 +17470,7 @@ static int32_t DN_NET_CurlThreadEntryPoint_(DN_OSThread *thread) if (receive_result == CURLE_GOT_NOTHING) { req->response.state = DN_NETResponseState_WSClose; } else if (receive_result != CURLE_OK) { - DN_USize curl_extended_error_size = DN_CStr8Size(curl_req->error); + DN_USize curl_extended_error_size = DN_CStr8Count(curl_req->error); req->response.state = DN_NETResponseState_Error; req->response.error_str8 = DN_Str8FromFmtArena(&req->start_response_arena, "Websocket receive '%.*s' failed (CURL %d): %s%s%s%s", @@ -17510,7 +17527,7 @@ void DN_NET_CurlInit(DN_NETCore *net, char *base, DN_U64 base_size) curl->list_mutex = DN_OS_MutexInit(); curl->thread_curlm = DN_Cast(CURLM *) curl_multi_init(); - DN_FmtAppend(curl->thread.name.data, &curl->thread.name.size, sizeof(curl->thread.name.data), "NET (CURL)"); + DN_FmtAppend(curl->thread.name.data, &curl->thread.name.count, sizeof(curl->thread.name.data), "NET (CURL)"); DN_OS_ThreadInit(&curl->thread, DN_NET_CurlThreadEntryPoint_, nullptr, DN_TCInitArgsDefault(), net); } @@ -17579,7 +17596,7 @@ static DN_NETRequestHandle DN_NET_CurlDoRequest_(DN_NETCore *net, DN_Str8 url, D // NOTE: Assign HTTP headers for (DN_ForItSize(it, DN_Str8, req->args.headers, req->args.headers_size)) { - DN_Assert(it.data->data[it.data->size] == 0); + DN_Assert(it.data->data[it.data->count] == 0); curl_req->slist = curl_slist_append(curl_req->slist, it.data->data); } curl_easy_setopt(curl, CURLOPT_HTTPHEADER, curl_req->slist); @@ -17600,10 +17617,10 @@ static DN_NETRequestHandle DN_NET_CurlDoRequest_(DN_NETCore *net, DN_Str8 url, D curl_easy_setopt(curl, CURLOPT_HTTPGET, 1); } else if (DN_Str8EqInsensitive(req->method, POST)) { curl_easy_setopt(curl, CURLOPT_POST, 1); - if (req->args.payload.size > DN_Gigabytes(2)) - curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE_LARGE, req->args.payload.size); + if (req->args.payload.count > DN_Gigabytes(2)) + curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE_LARGE, req->args.payload.count); else - curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, req->args.payload.size); + curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, req->args.payload.count); curl_easy_setopt(curl, CURLOPT_COPYPOSTFIELDS, req->args.payload.data); } else { DN_AssertInvalidCodePathF("Unimplemented"); @@ -17613,13 +17630,20 @@ static DN_NETRequestHandle DN_NET_CurlDoRequest_(DN_NETCore *net, DN_Str8 url, D // NOTE: Handle basic auth if (req->args.flags & DN_NETDoHTTPFlags_BasicAuth) { - if (req->args.username.size && req->args.password.size) { - DN_Assert(req->args.username.data[req->args.username.size] == 0); - DN_Assert(req->args.password.data[req->args.password.size] == 0); + if (req->args.username.count && req->args.password.count) { + DN_Assert(req->args.username.data[req->args.username.count] == 0); + DN_Assert(req->args.password.data[req->args.password.count] == 0); curl_easy_setopt(curl, CURLOPT_USERNAME, req->args.username.data); curl_easy_setopt(curl, CURLOPT_PASSWORD, req->args.password.data); } } + + if (req->args.flags & DN_NETDoHTTPFlags_DisableSSLVerify) { + // NOTE: Disable peer verification (checks if cert is signed by trusted CA) + // NOTE: Disable host verification (checks if cert matches hostname) + curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L); + curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0L); + } } // NOTE: Dispatch the request to the CURL thread @@ -17633,9 +17657,9 @@ static DN_NETRequestHandle DN_NET_CurlDoRequest_(DN_NETCore *net, DN_Str8 url, D // NOTE: Enqueue request to go into CURL's ring queue. The CURL thread will sleep and wait for // bytes to come in for the request and then dump the response into the done list to be consumed // via wait for response - DN_NETCurlRingEvent event = {}; - event.type = DN_NETCurlRingEventType_DoRequest; - event.request = result; + DN_NETCurlRingEvent_ event = {}; + event.type = DN_NETCurlRingEventType_DoRequest; + event.request = result; for (DN_OS_MutexScope(&curl_core->ring_mutex)) DN_RingWriteStruct(&curl_core->ring, &event); @@ -17673,16 +17697,16 @@ void DN_NET_CurlDoWSSend(DN_NETRequestHandle handle, DN_Str8 payload, DN_NETWSSe DN_NETCurlCore *curl = DN_Cast(DN_NETCurlCore *) net->context; DN_Assert(curl); - DN_NETCurlRingEvent event = {}; + DN_NETCurlRingEvent_ event = {}; event.type = DN_NETCurlRingEventType_SendWS; event.request = handle; - event.ws_send_size = payload.size; + event.ws_send_size = payload.count; event.ws_send = send; for (DN_OS_MutexScope(&curl->ring_mutex)) { - DN_Assert(DN_RingHasSpace(&curl->ring, payload.size)); + DN_Assert(DN_RingHasSpace(&curl->ring, payload.count)); DN_RingWriteStruct(&curl->ring, &event); - DN_RingWrite(&curl->ring, payload.data, payload.size); + DN_RingWrite(&curl->ring, payload.data, payload.count); } curl_multi_wakeup(curl->thread_curlm); } @@ -17694,7 +17718,7 @@ static DN_NETResponse DN_NET_CurlHandleFinishedRequest_(DN_NETCurlCore *curl, DN DN_NETCurlRequest *curl_req = DN_NET_CurlRequestFromRequest_(req); { result.body = DN_Str8FromStr8BuilderArena(&curl_req->str8_builder, arena); - if (result.error_str8.size) + if (result.error_str8.count) result.error_str8 = DN_Str8FromStr8Arena(result.error_str8, arena); } @@ -17723,10 +17747,9 @@ static DN_NETResponse DN_NET_CurlHandleFinishedRequest_(DN_NETCurlCore *curl, DN DN_DoublyLLAppend(curl->deinit_list, req); } - // NOTE: Submit the post-request event to the CURL thread - DN_NETCurlRingEvent event = {}; - event.request = DN_NET_HandleFromRequest(req); + DN_NETCurlRingEvent_ event = {}; + event.request = DN_NET_HandleFromRequest(req); if (continue_ws_request) { event.type = DN_NETCurlRingEventType_ReceivedWSReceipt; } else { @@ -18003,7 +18026,7 @@ DN_NETRequestHandle DN_NET_EmcDoHTTP(DN_NETCore *net, DN_Str8 url, DN_Str8 metho if (req->args.headers_size) { char **headers = DN_ArenaNewArray(&req->start_response_arena, char *, req->args.headers_size + 1, DN_ZMem_Yes); for (DN_ForItSize(it, DN_Str8, req->args.headers, req->args.headers_size)) { - DN_Assert(it.data->data[it.data->size] == 0); + DN_Assert(it.data->data[it.data->count] == 0); headers[it.index] = it.data->data; } fetch_attribs.requestHeaders = headers; @@ -18172,6 +18195,7 @@ static DN_NETResponse DN_NET_EmcHandleFinishedRequest_(DN_NETCore *net, DN_NETEm DN_NETEmcCore *emc = DN_Cast(DN_NETEmcCore *) net->context; request->next = emc->free_list; request->prev = nullptr; + request->gen++; emc->free_list = request; } diff --git a/Single-Header/dn_single_header.h b/Single-Header/dn_single_header.h index e1b763e..245c57f 100644 --- a/Single-Header/dn_single_header.h +++ b/Single-Header/dn_single_header.h @@ -1,4 +1,4 @@ -// Generated by the DN single header generator 2026-06-23 23:16:53 +// Generated by the DN single header generator 2026-06-25 21:37:26 #if !defined(DN_H) #define DN_H @@ -6,39 +6,26 @@ // NOTE: DN // NOTE: Getting Started -// Include this mega header `dn.h` and define the following symbols to `1` to conditionally -// enable the interfaces for those features. Additionally in the same or different translation -// unit, include `dn.cpp` with the same symbols defined to enable the implementation of these -// features. -// -// See the configuration section for more information on other symbols that can be defined. -// -// The following is a single translation unit example: +// - Copy the entire DN folder to your project and include `dn.h` alongside your headers and +// include `dn.cpp` in one of your implementation files that has `dn.h` included in its scope, +// an example. There are #defines to selectively enable features of the library (see the +// configuration section for more info), example: /* - #define DN_WITH_OS 1 - #define DN_WITH_NET 0 - #define DN_WITH_NET_CURL 0 - #define DN_WITH_NET_EMSCRIPTEN 0 - #include "dn.h" + #define DN_WITH_OS 1 // Enable OS features (like virtual mem, TLS, file system, threads) + #include "dn.h" - #define DN_CPP_WITH_TESTS 1 - #include "dn.cpp" + #define DN_CPP_WITH_TESTS 1 + #include "dn.cpp" - int main() - { - DN_Core core = {}; - DN_Init(&core, DN_InitFlags_Nil, DN_TCInitArgsDefault()); - return 0; - } + int main() + { + DN_Core core = {}; + DN_Init(&core, DN_InitFlags_Nil, DN_TCInitArgsDefault()); + return 0; + } */ -// - The base layer (dn_base.h) which provides primitives that do not require a host operating -// system (e.g. freestanding) such as string manipulation, compiler intrinsics and containers. -// This layer is unconditionallly always available by compiling with this library. -// -// - The OS layer (dn_os.h) which provides primitives that use the OS such as file IO, threading -// synchronisation, memory allocation. This layer is OPTIONAL. -// -// - Extra layer provides helper utilities that are opt-in. These layers are OPTIONAL. +// - `DN/Standalone` contains utilities that are self-contained and can be used without `dn.h` in +// a similar manner, typically a single header and single implementation file. // NOTE: Configuration @@ -775,7 +762,7 @@ enum DN_ZMem struct DN_Str8 { char *data; // The bytes of the string - DN_USize size; // The number of bytes in the string + DN_USize count; // The number of bytes in the string }; struct DN_Str8Slice @@ -784,18 +771,18 @@ struct DN_Str8Slice DN_USize count; }; -struct DN_Str8x16 { char data[16]; DN_USize size; }; -struct DN_Str8x32 { char data[32]; DN_USize size; }; -struct DN_Str8x64 { char data[64]; DN_USize size; }; -struct DN_Str8x128 { char data[128]; DN_USize size; }; -struct DN_Str8x256 { char data[256]; DN_USize size; }; -struct DN_Str8x512 { char data[512]; DN_USize size; }; -struct DN_Str8x1024 { char data[1024]; DN_USize size; }; +struct DN_Str8x16 { char data[16]; DN_USize count; }; +struct DN_Str8x32 { char data[32]; DN_USize count; }; +struct DN_Str8x64 { char data[64]; DN_USize count; }; +struct DN_Str8x128 { char data[128]; DN_USize count; }; +struct DN_Str8x256 { char data[256]; DN_USize count; }; +struct DN_Str8x512 { char data[512]; DN_USize count; }; +struct DN_Str8x1024 { char data[1024]; DN_USize count; }; struct DN_Str16 // A pointer and length style string that holds slices to UTF16 bytes. { - wchar_t *data; // The UTF16 bytes of the string - DN_USize size; // The number of characters in the string + wchar_t *data; // The UTF16 bytes of the string + DN_USize count; // The number of characters in the string }; struct DN_Str16Slice @@ -910,14 +897,14 @@ struct DN_TicketMutex }; -struct DN_Hex32 { char data[32 + 1]; DN_USize size; }; -struct DN_Hex64 { char data[64 + 1]; DN_USize size; }; -struct DN_Hex128 { char data[128 + 1]; DN_USize size; }; +struct DN_Hex32 { char data[32 + 1]; DN_USize count; }; +struct DN_Hex64 { char data[64 + 1]; DN_USize count; }; +struct DN_Hex128 { char data[128 + 1]; DN_USize count; }; struct DN_HexU64 { char data[(sizeof(DN_U64) * 2) + 1 /*null-terminator*/]; - DN_U8 size; + DN_U8 count; }; enum DN_HexFromU64Type @@ -1110,11 +1097,11 @@ enum DN_MemFuncsType DN_MemFuncsType_Virtual, }; -typedef void *(DN_MemHeapAllocFunc)(DN_USize size); +typedef void *(DN_MemHeapAllocFunc)(DN_USize count); typedef void (DN_MemHeapDeallocFunc)(void *ptr); -typedef void *(DN_MemVirtualReserveFunc)(DN_USize size, DN_MemCommit commit, DN_MemPage page_flags); -typedef bool (DN_MemVirtualCommitFunc)(void *ptr, DN_USize size, DN_U32 page_flags); -typedef void (DN_MemVirtualReleaseFunc)(void *ptr, DN_USize size); +typedef void *(DN_MemVirtualReserveFunc)(DN_USize count, DN_MemCommit commit, DN_MemPage page_flags); +typedef bool (DN_MemVirtualCommitFunc)(void *ptr, DN_USize count, DN_U32 page_flags); +typedef void (DN_MemVirtualReleaseFunc)(void *ptr, DN_USize count); struct DN_MemFuncs { DN_MemFuncsType type; @@ -1387,7 +1374,7 @@ struct DN_Str8TruncResult { bool truncated; DN_Str8 str8; - DN_USize size_req; // Not including null-terminator + DN_USize count_req; // Not including null-terminator }; struct DN_Str8SplitResult @@ -1669,7 +1656,7 @@ struct DN_LogDate struct DN_LogPrefixSize { - DN_USize size; + DN_USize count; DN_USize padding; }; @@ -1832,7 +1819,7 @@ struct DN_ArrayEraseResult // The next index your for-index should be set to such that you can continue // to iterate the remainder of the array, e.g: // - // for (DN_USize index = 0; index < array.size; index++) { + // for (DN_USize index = 0; index < array.count; index++) { // if (erase) // index = DN_FArray_EraseRange(&array, index, -3, DN_ArrayErase_Unstable); // } @@ -2574,7 +2561,7 @@ STBSP__PUBLICDEF int STB_SPRINTF_DECORATE(vsprintfcb)(STBSP_SPRINTFCB *callback, { DN_Str8 str8 = va_arg(va, DN_Str8); s = (char *)str8.data; - l = (uint32_t)str8.size; + l = (uint32_t)str8.count; lead[0] = 0; tail[0] = 0; pr = 0; @@ -4224,9 +4211,9 @@ DN_API bool DN_VerifyArgs #define DN_VSPrintF(...) STB_SPRINTF_DECORATE(vsprintf)(__VA_ARGS__) #define DN_VSNPrintF(...) STB_SPRINTF_DECORATE(vsnprintf)(__VA_ARGS__) -DN_API bool DN_MemStartsWith (void const *lhs, DN_USize lhs_size, void const *rhs, DN_USize rhs_size); -DN_API bool DN_MemEq (void const *lhs, DN_USize lhs_size, void const *rhs, DN_USize rhs_size); -DN_API bool DN_MemEqUnsafe (void const *lhs, void const *rhs, DN_USize size); +DN_API bool DN_MemStartsWith (void const *lhs, DN_USize lhs_count, void const *rhs, DN_USize rhs_count); +DN_API bool DN_MemEq (void const *lhs, DN_USize lhs_count, void const *rhs, DN_USize rhs_count); +DN_API bool DN_MemEqUnsafe (void const *lhs, void const *rhs, DN_USize count); #if defined(__cplusplus) template T* DN_MemCopyObjT (T *dest, T const *src, DN_USize count); #define DN_MemCopyObj(dest, src, count) DN_MemCopyObjT(dest, src, count) @@ -4359,12 +4346,14 @@ DN_API void DN_ASanUnpoisonMemoryRegion DN_API DN_F32 DN_EpsilonClampF32 (DN_F32 value, DN_F32 target, DN_F32 epsilon); DN_API DN_MemStats DN_MemStatsSum (DN_MemStats lhs, DN_MemStats rhs); -DN_API DN_MemStats DN_MemStatsSumArray (DN_MemStats const *array, DN_USize size); +DN_API DN_MemStats DN_MemStatsSumArray (DN_MemStats const *array, DN_USize count); -// NOTE: `MemList` is an implementation of a classical `Arena` (e.g. bump allocator, can dynamically -// grow, frees by bumping pointer back, sub-divides a block of memory). The term `Arena` is reserved -// as a thin-layer over the functionality here to provide some use-after-free protection. See -// `Arena` for more info. +// NOTE: MemList +// Overview +// `MemList` is an implementation of a classical `Arena` (e.g. bump allocator, can dynamically +// grow, frees by bumping pointer back, sub-divides a block of memory). The term `Arena` is +// reserved as a thin-layer over the functionality here to provide some use-after-free protection. +// See `Arena` for more info. DN_API DN_MemList DN_MemListFromBuffer (void *buffer, DN_USize size, DN_MemFlags flags); DN_API DN_MemList DN_MemListFromMemFuncs (DN_U64 reserve, DN_U64 commit, DN_MemFlags flags, DN_MemFuncs mem_funcs); DN_API void DN_MemListDeinit (DN_MemList *mem); @@ -4529,7 +4518,7 @@ DN_API DN_I64FromResult DN_I64FromPtr DN_API DN_I64 DN_I64FromPtrUnsafe (void const *data, DN_USize size, char separator); DN_API bool DN_U8x32Eq (DN_U8x32 const *lhs, DN_U8x32 const *rhs); -DN_API DN_U8x32 DN_U8x32FromBytesLeftPadZ (DN_U8 const *ptr, DN_USize count); +DN_API DN_U8x32 DN_U8x32FromBytesLeftPadZ (DN_U8 const *ptr, DN_USize size); DN_API DN_U8x32 DN_U8x32FromHexUnsafe (DN_Str8 hex_32b); DN_API DN_U8x32FromResult DN_U8x32FromHex (DN_Str8 hex_32b); DN_API DN_U8x32FromResult DN_U8x32FromDecimalStr8 (DN_Str8 decimal); // Write decimal string (e.g. "12345") as big-endian 256-bit value @@ -4537,33 +4526,33 @@ DN_API DN_U8x32FromResult DN_U8x32FromDecimalStr8 DN_API DN_Allocator DN_AllocatorFromMemList (DN_MemList *mem); DN_API DN_Allocator DN_AllocatorFromArena (DN_Arena *arena); DN_API DN_Allocator DN_AllocatorFromPool (DN_Pool *pool); -DN_API void* DN_AllocatorAlloc (DN_Allocator allocator, DN_USize size, DN_U8 align, DN_ZMem z_mem); +DN_API void* DN_AllocatorAlloc (DN_Allocator allocator, DN_USize count, DN_U8 align, DN_ZMem z_mem); -DN_API DN_USize DN_FmtVSize (DN_FMT_ATTRIB char const *fmt, va_list args); -DN_API DN_USize DN_FmtSize (DN_FMT_ATTRIB char const *fmt, ...); +DN_API DN_USize DN_FmtVCount (DN_FMT_ATTRIB char const *fmt, va_list args); +DN_API DN_USize DN_FmtCount (DN_FMT_ATTRIB char const *fmt, ...); DN_API DN_FmtAppendResult DN_FmtVAppend (char *buf, DN_USize *buf_size, DN_USize buf_max, char const *fmt, va_list args); DN_API DN_FmtAppendResult DN_FmtAppend (char *buf, DN_USize *buf_size, DN_USize buf_max, char const *fmt, ...); DN_API DN_FmtAppendResult DN_FmtAppendTruncate (char *buf, DN_USize *buf_size, DN_USize buf_max, DN_Str8 truncator, char const *fmt, ...); -DN_API DN_USize DN_CStr8Size (char const *src); -DN_API DN_USize DN_CStr16Size (wchar_t const *src); +DN_API DN_USize DN_CStr8Count (char const *src); +DN_API DN_USize DN_CStr16Count (wchar_t const *src); #define DN_Str16Lit(string) DN_Str16{(wchar_t *)(string), sizeof(string)/sizeof(string[0]) - 1} -#define DN_Str16FromPtr(data, size) DN_Literal(DN_Str16){(wchar_t *)(data), (DN_USize)(size)} +#define DN_Str16FromPtr(data, count) DN_Literal(DN_Str16){(wchar_t *)(data), (DN_USize)(count)} #define DN_Str8Lit(c_str) DN_Literal(DN_Str8){(char *)(c_str), sizeof(c_str) - 1} -#define DN_Str8PrintFmt(string) (int)((string).size), (string).data +#define DN_Str8PrintFmt(string) (int)((string).count), (string).data -#define DN_Str8FromPtr(data, size) DN_Literal(DN_Str8){(char *)(data), (DN_USize)(size)} -#define DN_Str8FromStruct(ptr) DN_Str8FromPtr((ptr)->data, (ptr)->size) +#define DN_Str8FromPtr(data, count) DN_Literal(DN_Str8){(char *)(data), (DN_USize)(count)} +#define DN_Str8FromStruct(ptr) DN_Str8FromPtr((ptr)->data, (ptr)->count) #define DN_Str8FromLitArray(c_array) DN_Str8FromPtr(c_array, DN_ArrayCountU(c_array)) -DN_API DN_Str8 DN_Str8AllocAllocator (DN_USize size, DN_ZMem z_mem, DN_Allocator allocator); -DN_API DN_Str8 DN_Str8AllocArena (DN_USize size, DN_ZMem z_mem, DN_Arena *arena); -DN_API DN_Str8 DN_Str8AllocPool (DN_USize size, DN_Pool *pool); +DN_API DN_Str8 DN_Str8AllocAllocator (DN_USize count, DN_ZMem z_mem, DN_Allocator allocator); +DN_API DN_Str8 DN_Str8AllocArena (DN_USize count, DN_ZMem z_mem, DN_Arena *arena); +DN_API DN_Str8 DN_Str8AllocPool (DN_USize count, DN_Pool *pool); DN_API DN_Str8 DN_Str8FromCStr8 (char const *src); DN_API DN_Str8 DN_Str8FromCStr8Arena (char const *src, DN_Arena *arena); -DN_API DN_Str8 DN_Str8FromPtrArena (void const *data, DN_USize size, DN_Arena *arena); -DN_API DN_Str8 DN_Str8FromPtrPool (void const *data, DN_USize size, DN_Pool *pool); +DN_API DN_Str8 DN_Str8FromPtrArena (void const *data, DN_USize count, DN_Arena *arena); +DN_API DN_Str8 DN_Str8FromPtrPool (void const *data, DN_USize count, DN_Pool *pool); DN_API DN_Str8 DN_Str8FromStr8Allocator (DN_Str8 string, DN_Allocator allocator); DN_API DN_Str8 DN_Str8FromStr8Arena (DN_Str8 string, DN_Arena *arena); DN_API DN_Str8 DN_Str8FromStr8Pool (DN_Str8 string, DN_Pool *pool); @@ -4606,7 +4595,7 @@ DN_API void DN_Str8x1024AppendFmtV DN_API DN_Str8x32 DN_Str8x32FromU64 (DN_U64 val, char separator); DN_API bool DN_Str8IsAll (DN_Str8 string, DN_Str8IsAllType is_all); DN_API char * DN_Str8End (DN_Str8 string); -DN_API DN_Str8 DN_Str8Subset (DN_Str8 string, DN_USize offset, DN_USize size); +DN_API DN_Str8 DN_Str8Subset (DN_Str8 string, DN_USize offset, DN_USize count); DN_API DN_Str8 DN_Str8Advance (DN_Str8 string, DN_USize amount); DN_API DN_Str8 DN_Str8NextLine (DN_Str8 string); DN_API DN_Str8BSplitResult DN_Str8BSplitArray (DN_Str8 string, DN_Str8 const *find, DN_USize find_size); @@ -4646,7 +4635,7 @@ DN_API DN_Str8 DN_Str8AppendF DN_API DN_Str8 DN_Str8AppendFV (DN_Arena *arena, DN_Str8 string, char const *fmt, va_list args); DN_API DN_Str8 DN_Str8FillF (DN_Arena *arena, DN_USize count, char const *fmt, ...); DN_API DN_Str8 DN_Str8FillFV (DN_Arena *arena, DN_USize count, char const *fmt, va_list args); -DN_API void DN_Str8Remove (DN_Str8 *string, DN_USize offset, DN_USize size); +DN_API void DN_Str8Remove (DN_Str8 *string, DN_USize offset, DN_USize count); DN_API DN_Str8TruncResult DN_Str8TruncMiddlePtr (DN_Str8 str8, DN_USize side_size, DN_Str8 truncator, char *dest, DN_USize dest_max); DN_API DN_Str8TruncResult DN_Str8TruncMiddle (DN_Str8 str8, DN_USize side_size, DN_Str8 truncator, DN_Arena *arena); DN_API DN_Str8 DN_Str8Lower (DN_Str8 string, DN_Arena *arena); @@ -4679,28 +4668,28 @@ DN_API DN_Str16 DN_Str16SliceRender DN_API DN_Str16 DN_Str16RenderSpaceSep (DN_Str16Slice array, DN_Arena *arena); DN_API DN_Str8Builder DN_Str8BuilderFromArena (DN_Arena *arena); -DN_API DN_Str8Builder DN_Str8BuilderFromStr8PtrRef (DN_Arena *arena, DN_Str8 const *strings, DN_USize size); -DN_API DN_Str8Builder DN_Str8BuilderFromStr8PtrCopy (DN_Arena *arena, DN_Str8 const *strings, DN_USize size); +DN_API DN_Str8Builder DN_Str8BuilderFromStr8PtrRef (DN_Arena *arena, DN_Str8 const *strings, DN_USize count); +DN_API DN_Str8Builder DN_Str8BuilderFromStr8PtrCopy (DN_Arena *arena, DN_Str8 const *strings, DN_USize count); DN_API DN_Str8Builder DN_Str8BuilderFromBuilder (DN_Arena *arena, DN_Str8Builder const *builder); -DN_API bool DN_Str8BuilderAddArrayRef (DN_Str8Builder *builder, DN_Str8 const *strings, DN_USize size, DN_Str8BuilderAdd add); -DN_API bool DN_Str8BuilderAddArrayCopy (DN_Str8Builder *builder, DN_Str8 const *strings, DN_USize size, DN_Str8BuilderAdd add); +DN_API bool DN_Str8BuilderAddArrayRef (DN_Str8Builder *builder, DN_Str8 const *strings, DN_USize count, DN_Str8BuilderAdd add); +DN_API bool DN_Str8BuilderAddArrayCopy (DN_Str8Builder *builder, DN_Str8 const *strings, DN_USize count, DN_Str8BuilderAdd add); DN_API bool DN_Str8BuilderAddFV (DN_Str8Builder *builder, DN_Str8BuilderAdd add, DN_FMT_ATTRIB char const *fmt, va_list args); #define DN_Str8BuilderAppendArrayRef(builder, strings, size) DN_Str8BuilderAddArrayRef(builder, strings, size, DN_Str8BuilderAdd_Append) #define DN_Str8BuilderAppendArrayCopy(builder, strings, size) DN_Str8BuilderAddArrayCopy(builder, strings, size, DN_Str8BuilderAdd_Append) -#define DN_Str8BuilderAppendSliceRef(builder, slice) DN_Str8BuilderAddArrayRef(builder, slice.data, slice.size, DN_Str8BuilderAdd_Append) -#define DN_Str8BuilderAppendSliceCopy(builder, slice) DN_Str8BuilderAddArrayCopy(builder, slice.data, slice.size, DN_Str8BuilderAdd_Append) +#define DN_Str8BuilderAppendSliceRef(builder, slice) DN_Str8BuilderAddArrayRef(builder, slice.data, slice.count, DN_Str8BuilderAdd_Append) +#define DN_Str8BuilderAppendSliceCopy(builder, slice) DN_Str8BuilderAddArrayCopy(builder, slice.data, slice.count, DN_Str8BuilderAdd_Append) DN_API bool DN_Str8BuilderAppendRef (DN_Str8Builder *builder, DN_Str8 string); DN_API bool DN_Str8BuilderAppendCopy (DN_Str8Builder *builder, DN_Str8 string); #define DN_Str8BuilderAppendFV(builder, fmt, args) DN_Str8BuilderAddFV(builder, DN_Str8BuilderAdd_Append, fmt, args) DN_API bool DN_Str8BuilderAppendF (DN_Str8Builder *builder, DN_FMT_ATTRIB char const *fmt, ...); -DN_API bool DN_Str8BuilderAppendBytesRef (DN_Str8Builder *builder, void const *ptr, DN_USize size); -DN_API bool DN_Str8BuilderAppendBytesCopy (DN_Str8Builder *builder, void const *ptr, DN_USize size); +DN_API bool DN_Str8BuilderAppendBytesRef (DN_Str8Builder *builder, void const *ptr, DN_USize count); +DN_API bool DN_Str8BuilderAppendBytesCopy (DN_Str8Builder *builder, void const *ptr, DN_USize count); DN_API bool DN_Str8BuilderAppendBuilderRef (DN_Str8Builder *dest, DN_Str8Builder const *src); DN_API bool DN_Str8BuilderAppendBuilderCopy (DN_Str8Builder *dest, DN_Str8Builder const *src); #define DN_Str8BuilderPrependArrayRef(builder, strings, size) DN_Str8BuilderAddArrayRef(builder, strings, size, DN_Str8BuilderAdd_Prepend) #define DN_Str8BuilderPrependArrayCopy(builder, strings, size) DN_Str8BuilderAddArrayCopy(builder, strings, size, DN_Str8BuilderAdd_Prepend) -#define DN_Str8BuilderPrependSliceRef(builder, slice) DN_Str8BuilderAddArrayRef(builder, slice.data, slice.size, DN_Str8BuilderAdd_Prepend) -#define DN_Str8BuilderPrependSliceCopy(builder, slice) DN_Str8BuilderAddArrayCopy(builder, slice.data, slice.size, DN_Str8BuilderAdd_Prepend) +#define DN_Str8BuilderPrependSliceRef(builder, slice) DN_Str8BuilderAddArrayRef(builder, slice.data, slice.count, DN_Str8BuilderAdd_Prepend) +#define DN_Str8BuilderPrependSliceCopy(builder, slice) DN_Str8BuilderAddArrayCopy(builder, slice.data, slice.count, DN_Str8BuilderAdd_Prepend) DN_API bool DN_Str8BuilderPrependRef (DN_Str8Builder *builder, DN_Str8 string); DN_API bool DN_Str8BuilderPrependCopy (DN_Str8Builder *builder, DN_Str8 string); #define DN_Str8BuilderPrependFV(builder, fmt, args) DN_Str8BuilderAddFV(builder, DN_Str8BuilderAdd_Prepend, fmt, args) @@ -4843,8 +4832,8 @@ DN_API void DN_PCG32Advance #define DN_FNV1A64_SEED 14695981039346656037ULL #endif -DN_API DN_U32 DN_FNV1AHashU32FromBytes (void const *bytes, DN_USize size, DN_U32 seed); -DN_API DN_U64 DN_FNV1AHashU64FromBytes (void const *bytes, DN_USize size, DN_U64 seed); +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); @@ -5402,7 +5391,7 @@ DN_API DN_RaycastV2 DN_RaycastLineIntersectV2 // 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.size + add_count > array.max` otherwise no-op +// GrowIfNeeded: Expands the capacity of the array if `array.count + add_count > array.max` otherwise no-op // // Variants // PArray => Pointer (to) Array @@ -5412,7 +5401,7 @@ DN_API DN_RaycastV2 DN_RaycastLineIntersectV2 // automatically using DN_ArrayCountU(l_array). // // MyStruct buffer[TB_ASType_Count] = {}; -// DN_USize size = 0; +// DN_USize count = 0; // MyStruct *item_0 = DN_PArrayMake(buffer, &size, DN_ArrayCountU(buffer), DN_ZMem_No); // MyStruct *item_1 = DN_LArrayMake(buffer, &size, DN_ZMem_No); // @@ -5590,44 +5579,44 @@ DN_API DN_RaycastV2 DN_RaycastLineIntersectV2 #define DN_ISliceAllocArena(slice_ptr, count_, zmem, arena) (DN_CppDeclType(&((slice_ptr)->data[0])))DN_SliceAllocArena((void **)&((slice_ptr)->data), &((slice_ptr)->count), count_, sizeof((slice_ptr)->data[0]), alignof(DN_CppDeclType((slice_ptr)->data[0])), zmem, arena) -DN_API void* DN_SliceAllocArena (void **data, DN_USize *slice_size_field, DN_USize size, DN_USize elem_size, DN_U8 align, DN_ZMem zmem, DN_Arena *arena); +DN_API void* DN_SliceAllocArena (void **data, DN_USize *slice_size_field, DN_USize count, DN_USize elem_size, DN_U8 align, DN_ZMem zmem, DN_Arena *arena); -DN_API DN_ArrayFindResult DN_ArrayFind (void *data, DN_USize size, DN_USize elem_size, void const *find, DN_ArrayFindEqFunc *eq_func); -DN_API DN_ArrayFindResult DN_ArrayFindMemEq (void *data, DN_USize size, DN_USize elem_size, void const *find); -DN_API void* DN_ArrayInsertArray (void *data, DN_USize *size, DN_USize max, DN_USize elem_size, DN_USize index, void const *items, DN_USize count); -DN_API void* DN_ArrayPopFront (void *data, DN_USize *size, DN_USize elem_size, DN_USize count); -DN_API void* DN_ArrayPopBack (void *data, DN_USize *size, DN_USize elem_size, DN_USize count); -DN_API DN_ArrayEraseResult DN_ArrayEraseRange (void *data, DN_USize *size, DN_USize elem_size, DN_USize begin_index, DN_ISize count, DN_ArrayErase erase); -DN_API void* DN_ArrayMakeArray (void *data, DN_USize *size, DN_USize max, DN_USize elem_size, DN_USize make_count, DN_ZMem z_mem); -DN_API void* DN_ArrayMakeArrayAssert (void *data, DN_USize *size, DN_USize max, DN_USize elem_size, DN_USize make_count, DN_ZMem z_mem, DN_CallSite call_site); -DN_API void* DN_ArrayAddArray (void *data, DN_USize *size, 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 *size, 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 *size, DN_USize *max, DN_USize elem_size, DN_Pool *pool, DN_USize new_max); -DN_API bool DN_ArrayResizeFromArena (void **data, DN_USize *size, DN_USize *max, DN_USize elem_size, DN_Arena *arena, DN_USize new_max); -DN_API bool DN_ArrayGrowFromPool (void **data, DN_USize size, DN_USize *max, DN_USize elem_size, DN_Pool *pool, DN_USize new_max); -DN_API bool DN_ArrayGrowFromArena (void **data, DN_USize size, DN_USize *max, DN_USize elem_size, DN_Arena *arena, DN_USize new_max); -DN_API bool DN_ArrayGrowIfNeededFromPool (void **data, DN_USize size, DN_USize *max, DN_USize elem_size, DN_Pool *pool, DN_USize add_count); -DN_API bool DN_ArrayGrowIfNeededFromArena (void **data, DN_USize size, DN_USize *max, DN_USize elem_size, DN_Arena *arena, DN_USize add_count); +DN_API DN_ArrayFindResult DN_ArrayFind (void *data, DN_USize count, DN_USize elem_size, void const *find, DN_ArrayFindEqFunc *eq_func); +DN_API DN_ArrayFindResult DN_ArrayFindMemEq (void *data, DN_USize count, DN_USize elem_size, void const *find); +DN_API void* DN_ArrayInsertArray (void *data, DN_USize *count, DN_USize max, DN_USize elem_size, DN_USize index, void const *items, DN_USize items_count); +DN_API void* DN_ArrayPopFront (void *data, DN_USize *count, DN_USize elem_size, DN_USize pop_count); +DN_API void* DN_ArrayPopBack (void *data, DN_USize *count, DN_USize elem_size, DN_USize pop_count); +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_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 count, DN_USize *max, DN_USize elem_size, DN_Pool *pool, DN_USize new_max); +DN_API bool DN_ArrayGrowFromArena (void **data, DN_USize count, 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); #if defined (__cplusplus) -template DN_ArrayFindResult DN_TArrayFind (T *data, DN_USize size, void const *find, DN_ArrayFindEqFunc *eq_func); -template DN_ArrayFindResult DN_TArrayFindMemEq (T *data, DN_USize size, void const *find, DN_ArrayFindEqFunc *eq_func); -template T* DN_TArrayInsertArray (T *data, DN_USize *size, DN_USize max, DN_USize index, void const *items, DN_USize count); -template T* DN_TArrayPopFront (T *data, DN_USize *size, DN_USize count); -template T* DN_TArrayPopBack (T *data, DN_USize *size, DN_USize count); -template DN_ArrayEraseResult DN_TArrayEraseRange (T *data, DN_USize *size, DN_USize begin_index, DN_ISize count, DN_ArrayErase erase); -template T* DN_TArrayMakeArray (T *data, DN_USize *size, DN_USize max, DN_USize make_count, DN_ZMem z_mem); -template T* DN_TArrayMakeArrayAssert (T *data, DN_USize *size, DN_USize max, DN_USize make_count, DN_ZMem z_mem, DN_CallSite call_site); -template T* DN_TArrayMakeArrayAssertZ (T *data, DN_USize *size, DN_USize max, DN_USize make_count, DN_CallSite call_site); -template T* DN_TArrayMakeArrayAssertNoZ (T *data, DN_USize *size, DN_USize max, DN_USize make_count, DN_CallSite call_site); -template T* DN_TArrayAddArray (T *data, DN_USize *size, DN_USize max, T const *elems, DN_USize elems_count, DN_ArrayAdd add); -template T* DN_TArrayAddArrayAssert (T *data, DN_USize *size, DN_USize max, T const *elems, DN_USize elems_count, DN_ArrayAdd add, DN_CallSite call_site); -template bool DN_TArrayResizeFromPool (T **data, DN_USize *size, DN_USize *max, DN_Pool *pool, DN_USize new_max); -template bool DN_TArrayResizeFromArena (T **data, DN_USize *size, DN_USize *max, DN_Arena *arena, DN_USize new_max); -template bool DN_TArrayGrowFromPool (T **data, DN_USize size, DN_USize *max, DN_Pool *pool, DN_USize new_max); -template bool DN_TArrayGrowFromArena (T **data, DN_USize size, DN_USize *max, DN_Pool *pool, DN_USize new_max); -template bool DN_TArrayGrowIfNeededFromPool (T **data, DN_USize size, DN_USize *max, DN_Pool *pool, DN_USize add_count); -template bool DN_TArrayGrowIfNeededFromArena (T **data, DN_USize size, DN_USize *max, DN_Arena *pool, DN_USize add_count); +template DN_ArrayFindResult DN_TArrayFind (T *data, DN_USize count, void const *find, DN_ArrayFindEqFunc *eq_func); +template DN_ArrayFindResult DN_TArrayFindMemEq (T *data, DN_USize count, void const *find, DN_ArrayFindEqFunc *eq_func); +template T* DN_TArrayInsertArray (T *data, DN_USize *count, DN_USize max, DN_USize index, void const *items, DN_USize pop_count); +template T* DN_TArrayPopFront (T *data, DN_USize *count, DN_USize pop_count); +template T* DN_TArrayPopBack (T *data, DN_USize *count, DN_USize pop_count); +template DN_ArrayEraseResult DN_TArrayEraseRange (T *data, DN_USize *count, DN_USize begin_index, DN_ISize erase_count, DN_ArrayErase erase); +template T* DN_TArrayMakeArray (T *data, DN_USize *count, DN_USize max, DN_USize make_count, DN_ZMem z_mem); +template T* DN_TArrayMakeArrayAssert (T *data, DN_USize *count, DN_USize max, DN_USize make_count, DN_ZMem z_mem, DN_CallSite call_site); +template T* DN_TArrayMakeArrayAssertZ (T *data, DN_USize *count, DN_USize max, DN_USize make_count, DN_CallSite call_site); +template T* DN_TArrayMakeArrayAssertNoZ (T *data, DN_USize *count, DN_USize max, DN_USize make_count, DN_CallSite call_site); +template T* DN_TArrayAddArray (T *data, DN_USize *count, DN_USize max, T const *elems, DN_USize elems_count, DN_ArrayAdd add); +template 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 bool DN_TArrayResizeFromPool (T **data, DN_USize *count, DN_USize *max, DN_Pool *pool, DN_USize new_max); +template bool DN_TArrayResizeFromArena (T **data, DN_USize *count, DN_USize *max, DN_Arena *arena, DN_USize new_max); +template bool DN_TArrayGrowFromPool (T **data, DN_USize count, DN_USize *max, DN_Pool *pool, DN_USize new_max); +template bool DN_TArrayGrowFromArena (T **data, DN_USize count, DN_USize *max, DN_Pool *pool, DN_USize new_max); +template bool DN_TArrayGrowIfNeededFromPool (T **data, DN_USize count, DN_USize *max, DN_Pool *pool, DN_USize add_count); +template bool DN_TArrayGrowIfNeededFromArena (T **data, DN_USize count, DN_USize *max, DN_Arena *pool, DN_USize add_count); #endif DN_API void* DN_SinglyLLDetach (void **link, void **next); @@ -5660,8 +5649,8 @@ template bool DN_DSMapResize (DN_DSMap template bool DN_DSMapErase (DN_DSMap *map, DN_DSMapKey key); template bool DN_DSMapEraseKeyU64 (DN_DSMap *map, DN_U64 key); template bool DN_DSMapEraseKeyStr8 (DN_DSMap *map, DN_Str8 key); -template DN_DSMapKey DN_DSMapKeyBuffer (DN_DSMap const *map, void const *data, DN_USize size); -template DN_DSMapKey DN_DSMapKeyBufferAsU64NoHash (DN_DSMap const *map, void const *data, DN_USize size); +template DN_DSMapKey DN_DSMapKeyBuffer (DN_DSMap const *map, void const *data, DN_USize count); +template DN_DSMapKey DN_DSMapKeyBufferAsU64NoHash (DN_DSMap const *map, void const *data, DN_USize count); template DN_DSMapKey DN_DSMapKeyU64 (DN_DSMap const *map, DN_U64 u64); template DN_DSMapKey DN_DSMapKeyStr8 (DN_DSMap const *map, DN_Str8 string); #define DN_DSMapKeyCStr8(map, string) DN_DSMapKeyBuffer(map, string, sizeof((string))/sizeof((string)[0]) - 1) @@ -5881,19 +5870,19 @@ DN_API DN_Arena DN_ArenaFromHeap (D DN_API DN_Arena DN_ArenaFromVMem (DN_U64 reserve, DN_U64 commit, DN_MemFlags flags); DN_API DN_Str8 DN_Str8FromHeapF (DN_FMT_ATTRIB char const *fmt, ...); -DN_API DN_Str8 DN_Str8FromHeap (DN_USize size, DN_ZMem z_mem); +DN_API DN_Str8 DN_Str8FromHeap (DN_USize count, DN_ZMem z_mem); DN_API DN_Str8 DN_Str8BuilderBuildFromHeap (DN_Str8Builder const *builder); DN_API void DN_OS_LogPrint (DN_LogTypeParam type, void *user_data, DN_CallSite call_site, DN_FMT_ATTRIB char const *fmt, va_list args); DN_API void DN_OS_SetLogPrintFuncToOS (); -DN_API void * DN_OS_MemReserve (DN_USize size, DN_MemCommit commit, DN_MemPage page_flags); -DN_API bool DN_OS_MemCommit (void *ptr, DN_USize size, DN_U32 page_flags); -DN_API void DN_OS_MemDecommit (void *ptr, DN_USize size); -DN_API void DN_OS_MemRelease (void *ptr, DN_USize size); -DN_API int DN_OS_MemProtect (void *ptr, DN_USize size, DN_U32 page_flags); +DN_API void * DN_OS_MemReserve (DN_USize count, DN_MemCommit commit, DN_MemPage page_flags); +DN_API bool DN_OS_MemCommit (void *ptr, DN_USize count, DN_U32 page_flags); +DN_API void DN_OS_MemDecommit (void *ptr, DN_USize count); +DN_API void DN_OS_MemRelease (void *ptr, DN_USize count); +DN_API int DN_OS_MemProtect (void *ptr, DN_USize count, DN_U32 page_flags); -DN_API void * DN_OS_MemAlloc (DN_USize size, DN_ZMem z_mem); +DN_API void * DN_OS_MemAlloc (DN_USize count, DN_ZMem z_mem); DN_API void DN_OS_MemDealloc (void *ptr); DN_API DN_Date DN_OS_DateLocalTimeNow (); @@ -5931,8 +5920,8 @@ DN_API bool DN_OS_FileCopy (D DN_API bool DN_OS_FileMove (DN_Str8 src, DN_Str8 dest, bool overwrite, DN_ErrSink *err); DN_API DN_OSFile DN_OS_FileOpen (DN_Str8 path, DN_OSFileOpen open_mode, DN_OSFileAccess access, DN_ErrSink *err); -DN_API DN_OSFileRead DN_OS_FileRead (DN_OSFile *file, void *buffer, DN_USize size, DN_ErrSink *err); -DN_API bool DN_OS_FileWritePtr (DN_OSFile *file, void const *data, DN_USize size, DN_ErrSink *err); +DN_API DN_OSFileRead DN_OS_FileRead (DN_OSFile *file, void *buffer, DN_USize count, DN_ErrSink *err); +DN_API bool DN_OS_FileWritePtr (DN_OSFile *file, void const *data, DN_USize count, DN_ErrSink *err); DN_API bool DN_OS_FileWrite (DN_OSFile *file, DN_Str8 buffer, DN_ErrSink *err); DN_API bool DN_OS_FileWriteFV (DN_OSFile *file, DN_ErrSink *err, DN_FMT_ATTRIB char const *fmt, va_list args); DN_API bool DN_OS_FileWriteF (DN_OSFile *file, DN_ErrSink *err, DN_FMT_ATTRIB char const *fmt, ...); @@ -6155,128 +6144,128 @@ template T *DN_MemCopyObjT(T *dest, T const *src, DN_USize count) } template -DN_ArrayFindResult DN_TArrayFind(T *data, DN_USize size, void const *find, DN_ArrayFindEqFunc *eq_func) +DN_ArrayFindResult DN_TArrayFind(T *data, DN_USize count, void const *find, DN_ArrayFindEqFunc *eq_func) { - DN_ArrayFindResult result = DN_ArrayFind(data, size, sizeof(*data), find, eq_func); + DN_ArrayFindResult result = DN_ArrayFind(data, count, sizeof(*data), find, eq_func); return result; } template -DN_ArrayFindResult DN_TArrayFindMemEq(T *data, DN_USize size, void const *find) +DN_ArrayFindResult DN_TArrayFindMemEq(T *data, DN_USize count, void const *find) { - DN_ArrayFindResult result = DN_ArrayFindMemEq(data, size, sizeof(*data), find); + DN_ArrayFindResult result = DN_ArrayFindMemEq(data, count, sizeof(*data), find); return result; } template -T *DN_TArrayInsertArray(T *data, DN_USize *size, DN_USize max, DN_USize index, T const *items, DN_USize count) +T *DN_TArrayInsertArray(T *data, DN_USize *count, DN_USize max, DN_USize index, T const *items, DN_USize items_count) { - T *result = DN_Cast(T *)DN_ArrayInsertArray(data, size, max, sizeof(*data), index, items, count); + T *result = DN_Cast(T *)DN_ArrayInsertArray(data, count, max, sizeof(*data), index, items, items_count); return result; } template -T *DN_TArrayPopFront(T *data, DN_USize *size, DN_USize count) +T *DN_TArrayPopFront(T *data, DN_USize *count, DN_USize pop_count) { - T *result = DN_Cast(T *)DN_ArrayPopFront(data, size, sizeof(*data), count); + T *result = DN_Cast(T *)DN_ArrayPopFront(data, count, sizeof(*data), pop_count); return result; } template -T *DN_TArrayPopBack(T *data, DN_USize *size, DN_USize count) +T *DN_TArrayPopBack(T *data, DN_USize *count, DN_USize pop_count) { - T *result = DN_Cast(T *)DN_ArrayPopBack(data, size, sizeof(*data), count); + T *result = DN_Cast(T *)DN_ArrayPopBack(data, count, sizeof(*data), pop_count); return result; } template -DN_ArrayEraseResult DN_TArrayEraseRange(T *data, DN_USize *size, DN_USize begin_index, DN_ISize count, DN_ArrayErase erase) +DN_ArrayEraseResult DN_TArrayEraseRange(T *data, DN_USize *count, DN_USize begin_index, DN_ISize erase_count, DN_ArrayErase erase) { - DN_ArrayEraseResult result = DN_ArrayEraseRange(data, size, sizeof(*data), begin_index, count, erase); + DN_ArrayEraseResult result = DN_ArrayEraseRange(data, count, sizeof(*data), begin_index, erase_count, erase); return result; } template -T *DN_TArrayMakeArray(T *data, DN_USize *size, DN_USize max, DN_USize make_count, DN_ZMem z_mem) +T *DN_TArrayMakeArray(T *data, DN_USize *count, DN_USize max, DN_USize make_count, DN_ZMem z_mem) { - T *result = DN_Cast(T *)DN_ArrayMakeArray(data, size, max, sizeof(*data), make_count, z_mem); + T *result = DN_Cast(T *)DN_ArrayMakeArray(data, count, max, sizeof(*data), make_count, z_mem); return result; } template -T *DN_TArrayMakeArrayAssert(T *data, DN_USize *size, DN_USize max, DN_USize make_count, DN_ZMem z_mem, DN_CallSite call_site) +T *DN_TArrayMakeArrayAssert(T *data, DN_USize *count, DN_USize max, DN_USize make_count, DN_ZMem z_mem, DN_CallSite call_site) { - T *result = DN_Cast(T *)DN_ArrayMakeArrayAssert(data, size, max, sizeof(*data), make_count, z_mem, call_site); + T *result = DN_Cast(T *)DN_ArrayMakeArrayAssert(data, count, max, sizeof(*data), make_count, z_mem, call_site); return result; } template -T *DN_TArrayMakeArrayAssertZ(T *data, DN_USize *size, DN_USize max, DN_USize make_count, DN_CallSite call_site) +T *DN_TArrayMakeArrayAssertZ(T *data, DN_USize *count, DN_USize max, DN_USize make_count, DN_CallSite call_site) { - T* result = DN_TArrayMakeArrayAssert(data, size, max, make_count, DN_ZMem_Yes, call_site); + T* result = DN_TArrayMakeArrayAssert(data, count, max, make_count, DN_ZMem_Yes, call_site); return result; } template -T *DN_TArrayMakeArrayAssertNoZ(T *data, DN_USize *size, DN_USize max, DN_USize make_count, DN_CallSite call_site) +T *DN_TArrayMakeArrayAssertNoZ(T *data, DN_USize *count, DN_USize max, DN_USize make_count, DN_CallSite call_site) { - T* result = DN_TArrayMakeArrayAssert(data, size, max, make_count, DN_ZMem_No, call_site); + T* result = DN_TArrayMakeArrayAssert(data, count, max, make_count, DN_ZMem_No, call_site); return result; } template -T *DN_TArrayAddArray(T *data, DN_USize *size, DN_USize max, T const *elems, DN_USize elems_count, DN_ArrayAdd add) +T *DN_TArrayAddArray(T *data, DN_USize *count, DN_USize max, T const *elems, DN_USize elems_count, DN_ArrayAdd add) { - T* result = DN_Cast(T *)DN_ArrayAddArray(data, size, max, sizeof(*elems), elems, elems_count, add); + T* result = DN_Cast(T *)DN_ArrayAddArray(data, count, max, sizeof(*elems), elems, elems_count, add); return result; } template -T *DN_TArrayAddArrayAssert(T *data, DN_USize *size, DN_USize max, T const *elems, DN_USize elems_count, DN_ArrayAdd add, DN_CallSite call_site) +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) { - T* result = DN_Cast(T *)DN_ArrayAddArrayAssert(data, size, max, sizeof(*elems), elems, elems_count, add, call_site); + T* result = DN_Cast(T *)DN_ArrayAddArrayAssert(data, count, max, sizeof(*elems), elems, elems_count, add, call_site); return result; } template -bool DN_TArrayResizeFromPool(T **data, DN_USize *size, DN_USize *max, DN_Pool *pool, DN_USize new_max) +bool DN_TArrayResizeFromPool(T **data, DN_USize *count, DN_USize *max, DN_Pool *pool, DN_USize new_max) { - bool result = DN_ArrayResizeFromPool(DN_Cast(void **)data, size, max, sizeof(**data), pool, new_max); + bool result = DN_ArrayResizeFromPool(DN_Cast(void **)data, count, max, sizeof(**data), pool, new_max); return result; } template -bool DN_TArrayResizeFromArena(T **data, DN_USize *size, DN_USize *max, DN_Arena *arena, DN_USize new_max) +bool DN_TArrayResizeFromArena(T **data, DN_USize *count, DN_USize *max, DN_Arena *arena, DN_USize new_max) { - bool result = DN_ArrayResizeFromArena(DN_Cast(void **)data, size, max, sizeof(**data), arena, new_max); + bool result = DN_ArrayResizeFromArena(DN_Cast(void **)data, count, max, sizeof(**data), arena, new_max); return result; } template -bool DN_TArrayGrowFromPool(T **data, DN_USize size, DN_USize *max, DN_Pool *pool, DN_USize new_max) +bool DN_TArrayGrowFromPool(T **data, DN_USize count, DN_USize *max, DN_Pool *pool, DN_USize new_max) { - bool result = DN_ArrayGrowFromPool(DN_Cast(void **)data, size, max, sizeof(**data), pool, new_max); + bool result = DN_ArrayGrowFromPool(DN_Cast(void **)data, count, max, sizeof(**data), pool, new_max); return result; } template -bool DN_TArrayGrowFromArena(T **data, DN_USize size, DN_USize *max, DN_Arena *arena, DN_USize new_max) +bool DN_TArrayGrowFromArena(T **data, DN_USize count, DN_USize *max, DN_Arena *arena, DN_USize new_max) { - bool result = DN_ArrayGrowFromArena(DN_Cast(void **)data, size, max, sizeof(**data), arena, new_max); + bool result = DN_ArrayGrowFromArena(DN_Cast(void **)data, count, max, sizeof(**data), arena, new_max); return result; } template -bool DN_TArrayGrowIfNeededFromPool(T **data, DN_USize size, DN_USize *max, DN_Pool *pool, DN_USize add_count) +bool DN_TArrayGrowIfNeededFromPool(T **data, DN_USize count, DN_USize *max, DN_Pool *pool, DN_USize add_count) { - bool result = DN_ArrayGrowIfNeededFromPool(DN_Cast(void **)data, size, max, sizeof(**data), pool, add_count); + bool result = DN_ArrayGrowIfNeededFromPool(DN_Cast(void **)data, count, max, sizeof(**data), pool, add_count); return result; } template -bool DN_TArrayGrowIfNeededFromArena(T **data, DN_USize size, DN_USize *max, DN_Arena *arena, DN_USize add_count) +bool DN_TArrayGrowIfNeededFromArena(T **data, DN_USize count, DN_USize *max, DN_Arena *arena, DN_USize add_count) { - bool result = DN_ArrayGrowIfNeededFromArena(DN_Cast(void **)data, size, max, sizeof(**data), arena, add_count); + bool result = DN_ArrayGrowIfNeededFromArena(DN_Cast(void **)data, count, max, sizeof(**data), arena, add_count); return result; } #endif // defined(__cplusplus) @@ -6311,10 +6300,12 @@ enum DN_NETWSSend DN_NETWSSend_Pong, }; -enum DN_NETDoHTTPFlags +typedef DN_U32 DN_NETDoHTTPFlags; +enum DN_NETDoHTTPFlags_ { - DN_NETDoHTTPFlags_Nil = 0, - DN_NETDoHTTPFlags_BasicAuth = 1 << 0, + DN_NETDoHTTPFlags_Nil = 0, + DN_NETDoHTTPFlags_BasicAuth = 1 << 0, + DN_NETDoHTTPFlags_DisableSSLVerify = 1 << 1, }; struct DN_NETDoHTTPArgs @@ -6338,6 +6329,8 @@ struct DN_NETRequestHandle struct DN_NETResponse { + // NOTE: When filling these fields, all their values are copied internally in the library so the + // values do not need to persist past the initial invocation of the HTTP/WS request. // NOTE: Common to WS and HTTP responses DN_NETRequestType type; DN_NETResponseState state; @@ -6396,10 +6389,24 @@ struct DN_NETCore DN_NETInterface api; }; +// NOTE: NET +// Overview +// Defines a multi-threaded interface for doing network requests (via the `DN_NETInterface` +// object) in the core struct. On top of this is a asynchronous API provided to the caller along +// the lines of, do http/ws followed to dispatch a request followed by a blocking wait for +// response function. +// +// API +// DN_NET_ResponseHasFailed +// After a response has been dispatched via do http/ws the returned handle's status can be +// queried using this function. A request has failed if the `state` has returned +// `DN_NETResponseState_Error`, or the returned HTTP status code was `>= 400`. DN_Str8 DN_NET_Str8FromResponseState (DN_NETResponseState state); DN_NETRequest * DN_NET_RequestFromHandle (DN_NETRequestHandle handle); DN_NETRequestHandle DN_NET_HandleFromRequest (DN_NETRequest *request); bool DN_NET_ResponseHasFailed (DN_NETResponse const* resp); +bool DN_NET_ResponseHasSucceeded (DN_NETResponse const* resp); +bool DN_NET_ResponseIsReady (DN_NETResponse const* resp); DN_Str8 DN_NET_Str8DiagnosticFromResponse(DN_NETResponse const* resp, DN_Arena *arena); // NOTE: Internal functions for different networking implementations to use @@ -6409,6 +6416,15 @@ void DN_NET_EndFinishedRequest (DN_NETRequest *request); #endif #if DN_WITH_NET_CURL +#if defined(DN_COMPILER_MSVC) || defined(DN_COMPILER_CLANG_CL) +#pragma comment(lib, "advapi32") +#pragma comment(lib, "ws2_32") +#pragma comment(lib, "wldap32") +#pragma comment(lib, "crypt32") +#pragma comment(lib, "secur32") +#pragma comment(lib, "Iphlpapi") +#endif + #if !DN_WITH_OS || !DN_WITH_NET #error "NET API with CURL requires #define DN_WITH_NET 1 and #define DN_WITH_OS 1" #endif diff --git a/Source/External/stb_sprintf.h b/Source/External/stb_sprintf.h index 94610c7..67d3273 100644 --- a/Source/External/stb_sprintf.h +++ b/Source/External/stb_sprintf.h @@ -614,7 +614,7 @@ STBSP__PUBLICDEF int STB_SPRINTF_DECORATE(vsprintfcb)(STBSP_SPRINTFCB *callback, { DN_Str8 str8 = va_arg(va, DN_Str8); s = (char *)str8.data; - l = (uint32_t)str8.size; + l = (uint32_t)str8.count; lead[0] = 0; tail[0] = 0; pr = 0; diff --git a/Source/Extra/dn_tests.cpp b/Source/Extra/dn_tests.cpp index 657289c..32939ed 100644 --- a/Source/Extra/dn_tests.cpp +++ b/Source/Extra/dn_tests.cpp @@ -319,13 +319,13 @@ static DN_UTCore DN_TST_Base() for (DN_UT_Test(&result, "Age from U64: 1001 converts to 1s 1ms (seconds and ms)")) { DN_Str8x128 str8 = DN_AgeStr8FromMsU64(1001, DN_AgeUnit_Sec | DN_AgeUnit_Ms); DN_Str8 expect = DN_Str8Lit("1s 1ms"); - DN_UT_AssertF(&result, DN_MemEq(str8.data, str8.size, expect.data, expect.size), "str8=%.*s, expect=%.*s", DN_Str8PrintFmt(str8), DN_Str8PrintFmt(expect)); + DN_UT_AssertF(&result, DN_MemEq(str8.data, str8.count, expect.data, expect.count), "str8=%.*s, expect=%.*s", DN_Str8PrintFmt(str8), DN_Str8PrintFmt(expect)); } for (DN_UT_Test(&result, "Age from U64: 1001 converts to 1.001s (fractional)")) { DN_Str8x128 str8 = DN_AgeStr8FromMsU64(1001, DN_AgeUnit_FractionalSec); DN_Str8 expect = DN_Str8Lit("1.001s"); - DN_UT_AssertF(&result, DN_MemEq(str8.data, str8.size, expect.data, expect.size), "str8=%.*s, expect=%.*s", DN_Str8PrintFmt(str8), DN_Str8PrintFmt(expect)); + DN_UT_AssertF(&result, DN_MemEq(str8.data, str8.count, expect.data, expect.count), "str8=%.*s, expect=%.*s", DN_Str8PrintFmt(str8), DN_Str8PrintFmt(expect)); } for (DN_UT_Test(&result, "FmtAppendTruncate: String truncates with 3 dots")) { @@ -665,12 +665,12 @@ static DN_UTCore DN_TST_BaseBytesHex() DN_UT_AssertF(&test, DN_Str8Eq(bytes, DN_Str8Lit("\xf6\xed\x00")), "number_hex=%.*s", - DN_Str8PrintFmt(DN_HexFromPtrBytesArena(bytes.data, bytes.size, &scratch.arena, DN_TrimLeadingZero_No))); + DN_Str8PrintFmt(DN_HexFromPtrBytesArena(bytes.data, bytes.count, &scratch.arena, DN_TrimLeadingZero_No))); } for (DN_UT_Test(&test, "Convert empty bytes to string", number)) { DN_Str8 bytes = DN_Str8Lit(""); - DN_Str8 as_hex = DN_HexFromPtrBytesArena(bytes.data, bytes.size, &scratch.arena, DN_TrimLeadingZero_No); + DN_Str8 as_hex = DN_HexFromPtrBytesArena(bytes.data, bytes.count, &scratch.arena, DN_TrimLeadingZero_No); DN_UT_AssertF(&test, DN_Str8Eq(as_hex, DN_Str8Lit("")), "as_hex=%.*s", DN_Str8PrintFmt(as_hex)); } } @@ -1541,13 +1541,13 @@ DN_Str8 const DN_UT_HASH_STRING_[] = void DN_TST_KeccakDispatch_(DN_UTCore *test, int hash_type, DN_Str8 input) { DN_TCScratch scratch = DN_TCScratchBeginArena(nullptr, 0); - DN_Str8 input_hex = DN_HexFromPtrBytesArena(input.data, input.size, &scratch.arena, DN_TrimLeadingZero_No); + DN_Str8 input_hex = DN_HexFromPtrBytesArena(input.data, input.count, &scratch.arena, DN_TrimLeadingZero_No); switch (hash_type) { case Hash_SHA3_224: { - DN_SHA3U8x28 hash = DN_SHA3Hash224b(input.data, input.size); + DN_SHA3U8x28 hash = DN_SHA3Hash224b(input.data, input.count); DN_SHA3U8x28 expect; - DN_RefImpl_FIPS202_SHA3_224_(DN_Cast(uint8_t *) input.data, input.size, (uint8_t *)expect.data); + DN_RefImpl_FIPS202_SHA3_224_(DN_Cast(uint8_t *) input.data, input.count, (uint8_t *)expect.data); DN_Str8 hash_hex = DN_HexFromPtrBytesArena(hash.data, DN_ArrayCountU(hash.data), &scratch.arena, DN_TrimLeadingZero_No); DN_Str8 expect_hex = DN_HexFromPtrBytesArena(expect.data, DN_ArrayCountU(expect.data), &scratch.arena, DN_TrimLeadingZero_No); @@ -1562,9 +1562,9 @@ void DN_TST_KeccakDispatch_(DN_UTCore *test, int hash_type, DN_Str8 input) } break; case Hash_SHA3_256: { - DN_SHA3U8x32 hash = DN_SHA3Hash256b(input.data, input.size); + DN_SHA3U8x32 hash = DN_SHA3Hash256b(input.data, input.count); DN_SHA3U8x32 expect; - DN_RefImpl_FIPS202_SHA3_256_(DN_Cast(uint8_t *) input.data, input.size, (uint8_t *)expect.data); + DN_RefImpl_FIPS202_SHA3_256_(DN_Cast(uint8_t *) input.data, input.count, (uint8_t *)expect.data); DN_Str8 hash_hex = DN_HexFromPtrBytesArena(hash.data, DN_ArrayCountU(hash.data), &scratch.arena, DN_TrimLeadingZero_No); DN_Str8 expect_hex = DN_HexFromPtrBytesArena(expect.data, DN_ArrayCountU(expect.data), &scratch.arena, DN_TrimLeadingZero_No); @@ -1579,9 +1579,9 @@ void DN_TST_KeccakDispatch_(DN_UTCore *test, int hash_type, DN_Str8 input) } break; case Hash_SHA3_384: { - DN_SHA3U8x48 hash = DN_SHA3Hash384b(input.data, input.size); + DN_SHA3U8x48 hash = DN_SHA3Hash384b(input.data, input.count); DN_SHA3U8x48 expect; - DN_RefImpl_FIPS202_SHA3_384_(DN_Cast(uint8_t *) input.data, input.size, (uint8_t *)expect.data); + DN_RefImpl_FIPS202_SHA3_384_(DN_Cast(uint8_t *) input.data, input.count, (uint8_t *)expect.data); DN_Str8 hash_hex = DN_HexFromPtrBytesArena(hash.data, DN_ArrayCountU(hash.data), &scratch.arena, DN_TrimLeadingZero_No); DN_Str8 expect_hex = DN_HexFromPtrBytesArena(expect.data, DN_ArrayCountU(expect.data), &scratch.arena, DN_TrimLeadingZero_No); @@ -1596,9 +1596,9 @@ void DN_TST_KeccakDispatch_(DN_UTCore *test, int hash_type, DN_Str8 input) } break; case Hash_SHA3_512: { - DN_SHA3U8x64 hash = DN_SHA3Hash512b(input.data, input.size); + DN_SHA3U8x64 hash = DN_SHA3Hash512b(input.data, input.count); DN_SHA3U8x64 expect; - DN_RefImpl_FIPS202_SHA3_512_(DN_Cast(uint8_t *) input.data, input.size, (uint8_t *)expect.data); + DN_RefImpl_FIPS202_SHA3_512_(DN_Cast(uint8_t *) input.data, input.count, (uint8_t *)expect.data); DN_Str8 hash_hex = DN_HexFromPtrBytesArena(hash.data, DN_ArrayCountU(hash.data), &scratch.arena, DN_TrimLeadingZero_No); DN_Str8 expect_hex = DN_HexFromPtrBytesArena(expect.data, DN_ArrayCountU(expect.data), &scratch.arena, DN_TrimLeadingZero_No); @@ -1613,9 +1613,9 @@ void DN_TST_KeccakDispatch_(DN_UTCore *test, int hash_type, DN_Str8 input) } break; case Hash_Keccak_224: { - DN_SHA3U8x28 hash = DN_KeccakHash224b(input.data, input.size); + DN_SHA3U8x28 hash = DN_KeccakHash224b(input.data, input.count); DN_SHA3U8x28 expect; - DN_RefImpl_Keccak_(1152, 448, DN_Cast(uint8_t *) input.data, input.size, 0x01, (uint8_t *)expect.data, sizeof(expect)); + DN_RefImpl_Keccak_(1152, 448, DN_Cast(uint8_t *) input.data, input.count, 0x01, (uint8_t *)expect.data, sizeof(expect)); DN_Str8 hash_hex = DN_HexFromPtrBytesArena(hash.data, DN_ArrayCountU(hash.data), &scratch.arena, DN_TrimLeadingZero_No); DN_Str8 expect_hex = DN_HexFromPtrBytesArena(expect.data, DN_ArrayCountU(expect.data), &scratch.arena, DN_TrimLeadingZero_No); @@ -1630,9 +1630,9 @@ void DN_TST_KeccakDispatch_(DN_UTCore *test, int hash_type, DN_Str8 input) } break; case Hash_Keccak_256: { - DN_SHA3U8x32 hash = DN_KeccakHash256b(input.data, input.size); + DN_SHA3U8x32 hash = DN_KeccakHash256b(input.data, input.count); DN_SHA3U8x32 expect; - DN_RefImpl_Keccak_(1088, 512, DN_Cast(uint8_t *) input.data, input.size, 0x01, (uint8_t *)expect.data, sizeof(expect)); + DN_RefImpl_Keccak_(1088, 512, DN_Cast(uint8_t *) input.data, input.count, 0x01, (uint8_t *)expect.data, sizeof(expect)); DN_Str8 hash_hex = DN_HexFromPtrBytesArena(hash.data, DN_ArrayCountU(hash.data), &scratch.arena, DN_TrimLeadingZero_No); DN_Str8 expect_hex = DN_HexFromPtrBytesArena(expect.data, DN_ArrayCountU(expect.data), &scratch.arena, DN_TrimLeadingZero_No); @@ -1647,9 +1647,9 @@ void DN_TST_KeccakDispatch_(DN_UTCore *test, int hash_type, DN_Str8 input) } break; case Hash_Keccak_384: { - DN_SHA3U8x48 hash = DN_KeccakHash384b(input.data, input.size); + DN_SHA3U8x48 hash = DN_KeccakHash384b(input.data, input.count); DN_SHA3U8x48 expect; - DN_RefImpl_Keccak_(832, 768, DN_Cast(uint8_t *) input.data, input.size, 0x01, (uint8_t *)expect.data, sizeof(expect)); + DN_RefImpl_Keccak_(832, 768, DN_Cast(uint8_t *) input.data, input.count, 0x01, (uint8_t *)expect.data, sizeof(expect)); DN_Str8 hash_hex = DN_HexFromPtrBytesArena(hash.data, DN_ArrayCountU(hash.data), &scratch.arena, DN_TrimLeadingZero_No); DN_Str8 expect_hex = DN_HexFromPtrBytesArena(expect.data, DN_ArrayCountU(expect.data), &scratch.arena, DN_TrimLeadingZero_No); @@ -1664,9 +1664,9 @@ void DN_TST_KeccakDispatch_(DN_UTCore *test, int hash_type, DN_Str8 input) } break; case Hash_Keccak_512: { - DN_SHA3U8x64 hash = DN_KeccakHash512b(input.data, input.size); + DN_SHA3U8x64 hash = DN_KeccakHash512b(input.data, input.count); DN_SHA3U8x64 expect; - DN_RefImpl_Keccak_(576, 1024, DN_Cast(uint8_t *) input.data, input.size, 0x01, (uint8_t *)expect.data, sizeof(expect)); + DN_RefImpl_Keccak_(576, 1024, DN_Cast(uint8_t *) input.data, input.count, 0x01, (uint8_t *)expect.data, sizeof(expect)); DN_Str8 hash_hex = DN_HexFromPtrBytesArena(hash.data, DN_ArrayCountU(hash.data), &scratch.arena, DN_TrimLeadingZero_No); DN_Str8 expect_hex = DN_HexFromPtrBytesArena(expect.data, DN_ArrayCountU(expect.data), &scratch.arena, DN_TrimLeadingZero_No); @@ -1701,7 +1701,7 @@ DN_UTCore DN_TST_Keccak() for (int hash_type = 0; hash_type < Hash_Count; hash_type++) { DN_PCG32 rng = DN_PCG32Init(0xd48e'be21'2af8'733d); for (DN_Str8 input : INPUTS) { - DN_UT_BeginF(&result, "%.*s - Input: %.*s", DN_Str8PrintFmt(DN_UT_HASH_STRING_[hash_type]), DN_Cast(int) DN_Min(input.size, 54), input.data); + DN_UT_BeginF(&result, "%.*s - Input: %.*s", DN_Str8PrintFmt(DN_UT_HASH_STRING_[hash_type]), DN_Cast(int) DN_Min(input.count, 54), input.data); DN_TST_KeccakDispatch_(&result, hash_type, input); DN_UT_End(&result); } @@ -1770,8 +1770,8 @@ static DN_UTCore DN_TST_OS() for (DN_UT_Test(&result, "Query executable directory")) { DN_TCScratch scratch = DN_TCScratchBeginArena(nullptr, 0); DN_Str8 os_result = DN_OS_EXEDir(&scratch.arena); - DN_UT_Assert(&result, os_result.size); - DN_UT_AssertF(&result, DN_OS_PathIsDir(os_result), "result(%zu): %.*s", os_result.size, DN_Str8PrintFmt(os_result)); + DN_UT_Assert(&result, os_result.count); + DN_UT_AssertF(&result, DN_OS_PathIsDir(os_result), "result(%zu): %.*s", os_result.count, DN_Str8PrintFmt(os_result)); DN_TCScratchEnd(&scratch); } @@ -1821,9 +1821,9 @@ static DN_UTCore DN_TST_OS() // NOTE: Read step DN_TCScratch scratch = DN_TCScratchBeginArena(nullptr, 0); DN_Str8 read_file = DN_OS_FileReadAllArena(&scratch.arena, SRC_FILE, nullptr); - DN_UT_AssertF(&result, read_file.size, "Failed to load file"); - DN_UT_AssertF(&result, read_file.size == 4, "File read wrong amount of bytes (%zu)", read_file.size); - DN_UT_AssertF(&result, DN_Str8Eq(read_file, DN_Str8Lit("1234")), "Read %zu bytes instead of the expected 4: '%.*s'", read_file.size, DN_Str8PrintFmt(read_file)); + DN_UT_AssertF(&result, read_file.count, "Failed to load file"); + DN_UT_AssertF(&result, read_file.count == 4, "File read wrong amount of bytes (%zu)", read_file.count); + DN_UT_AssertF(&result, DN_Str8Eq(read_file, DN_Str8Lit("1234")), "Read %zu bytes instead of the expected 4: '%.*s'", read_file.count, DN_Str8PrintFmt(read_file)); // NOTE: Copy step DN_Str8 const COPY_FILE = DN_Str8Lit("dn_result_file_copy"); @@ -2039,13 +2039,13 @@ static DN_UTCore DN_TST_BaseStrings() { for (DN_UT_Test(&result, "Str8 literal")) { DN_Str8 string = DN_Str8Lit("AB"); - DN_UT_AssertF(&result, string.size == 2, "size: %zu", string.size); + DN_UT_AssertF(&result, string.count == 2, "size: %zu", string.count); DN_UT_AssertF(&result, string.data[0] == 'A', "string[0]: %c", string.data[0]); DN_UT_AssertF(&result, string.data[1] == 'B', "string[1]: %c", string.data[1]); } for (DN_UT_Test(&result, "C-string length")) { - DN_USize size = DN_CStr8Size("hello"); + DN_USize size = DN_CStr8Count("hello"); DN_UT_AssertF(&result, size == 5, "size=%zu", size); } @@ -2076,7 +2076,7 @@ static DN_UTCore DN_TST_BaseStrings() for (DN_UT_Test(&result, "Initialise with format string")) { DN_TCScratch scratch = DN_TCScratchBeginArena(nullptr, 0); DN_Str8 string = DN_Str8FromFmtArena(&scratch.arena, "%s", "AB"); - DN_UT_AssertF(&result, string.size == 2, "size: %zu", string.size); + DN_UT_AssertF(&result, string.count == 2, "size: %zu", string.count); DN_UT_AssertF(&result, string.data[0] == 'A', "string[0]: %c", string.data[0]); DN_UT_AssertF(&result, string.data[1] == 'B', "string[1]: %c", string.data[1]); DN_UT_AssertF(&result, string.data[2] == 0, "string[2]: %c", string.data[2]); @@ -2087,7 +2087,7 @@ static DN_UTCore DN_TST_BaseStrings() DN_TCScratch scratch = DN_TCScratchBeginArena(nullptr, 0); DN_Str8 string = DN_Str8Lit("AB"); DN_Str8 copy = DN_Str8FromStr8Arena(string, &scratch.arena); - DN_UT_AssertF(&result, copy.size == 2, "size: %zu", copy.size); + DN_UT_AssertF(&result, copy.count == 2, "size: %zu", copy.count); DN_UT_AssertF(&result, copy.data[0] == 'A', "copy[0]: %c", copy.data[0]); DN_UT_AssertF(&result, copy.data[1] == 'B', "copy[1]: %c", copy.data[1]); DN_UT_AssertF(&result, copy.data[2] == 0, "copy[2]: %c", copy.data[2]); @@ -2102,7 +2102,7 @@ static DN_UTCore DN_TST_BaseStrings() for (DN_UT_Test(&result, "Allocate string from arena")) { DN_TCScratch scratch = DN_TCScratchBeginArena(nullptr, 0); DN_Str8 string = DN_Str8AllocArena(2, DN_ZMem_No, &scratch.arena); - DN_UT_AssertF(&result, string.size == 2, "size: %zu", string.size); + DN_UT_AssertF(&result, string.count == 2, "size: %zu", string.count); DN_TCScratchEnd(&scratch); } @@ -2302,7 +2302,7 @@ static DN_UTCore DN_TST_BaseStrings() DN_UT_Assert(&result, !str_result.found); DN_UT_Assert(&result, str_result.index == 0); DN_UT_Assert(&result, str_result.match.data == nullptr); - DN_UT_Assert(&result, str_result.match.size == 0); + DN_UT_Assert(&result, str_result.match.count == 0); } for (DN_UT_Test(&result, "Find: String (char) is in buffer")) { @@ -2343,7 +2343,7 @@ static DN_UTCore DN_TST_BaseStrings() char dest[64] = {}; DN_Str8TruncResult res = DN_Str8TruncMiddlePtr(str, 5, trunc, dest, sizeof(dest)); DN_UT_Assert(&result, !res.truncated); - DN_UT_Assert(&result, res.size_req == 5); + DN_UT_Assert(&result, res.count_req == 5); DN_UT_AssertF(&result, DN_Str8Eq(res.str8, DN_Str8Lit("Hello")), "%.*s", DN_Str8PrintFmt(res.str8)); } @@ -2353,7 +2353,7 @@ static DN_UTCore DN_TST_BaseStrings() char dest[64] = {}; DN_Str8TruncResult res = DN_Str8TruncMiddlePtr(str, 5, trunc, dest, sizeof(dest)); DN_UT_Assert(&result, !res.truncated); - DN_UT_Assert(&result, res.size_req == 10); + DN_UT_Assert(&result, res.count_req == 10); DN_UT_AssertF(&result, DN_Str8Eq(res.str8, DN_Str8Lit("HelloWorld")), "%.*s", DN_Str8PrintFmt(res.str8)); } @@ -2363,7 +2363,7 @@ static DN_UTCore DN_TST_BaseStrings() char dest[64] = {}; DN_Str8TruncResult res = DN_Str8TruncMiddlePtr(str, 5, trunc, dest, sizeof(dest)); DN_UT_Assert(&result, res.truncated); - DN_UT_Assert(&result, res.size_req == 13); // 5 + 3 + 5 + DN_UT_Assert(&result, res.count_req == 13); // 5 + 3 + 5 DN_UT_AssertF(&result, DN_Str8Eq(res.str8, DN_Str8Lit("Hello...World")), "%.*s", DN_Str8PrintFmt(res.str8)); } @@ -2373,7 +2373,7 @@ static DN_UTCore DN_TST_BaseStrings() char dest[64] = {}; DN_Str8TruncResult res = DN_Str8TruncMiddlePtr(str, 5, trunc, dest, sizeof(dest)); DN_UT_Assert(&result, res.truncated); - DN_UT_Assert(&result, res.size_req == 10); // 5 + 0 + 5 + DN_UT_Assert(&result, res.count_req == 10); // 5 + 0 + 5 DN_UT_AssertF(&result, DN_Str8Eq(res.str8, DN_Str8Lit("HelloWorld")), "%.*s", DN_Str8PrintFmt(res.str8)); } @@ -2383,7 +2383,7 @@ static DN_UTCore DN_TST_BaseStrings() char dest[64] = {}; DN_Str8TruncResult res = DN_Str8TruncMiddlePtr(str, 0, trunc, dest, sizeof(dest)); DN_UT_Assert(&result, res.truncated); - DN_UT_Assert(&result, res.size_req == 3); + DN_UT_Assert(&result, res.count_req == 3); DN_UT_AssertF(&result, DN_Str8Eq(res.str8, DN_Str8Lit("...")), "%.*s", DN_Str8PrintFmt(res.str8)); } @@ -2392,17 +2392,17 @@ static DN_UTCore DN_TST_BaseStrings() DN_Str8 trunc = DN_Str8Lit("..."); DN_Str8TruncResult res = DN_Str8TruncMiddlePtr(str, 5, trunc, nullptr, 0); DN_UT_Assert(&result, res.truncated); - DN_UT_Assert(&result, res.size_req == 13); + DN_UT_Assert(&result, res.count_req == 13); DN_UT_Assert(&result, res.str8.data == nullptr); } - for (DN_UT_Test(&result, "TruncMiddlePtr: size_req is consistent between dry-run and actual")) { + for (DN_UT_Test(&result, "TruncMiddlePtr: count_req is consistent between dry-run and actual")) { DN_Str8 str = DN_Str8Lit("HelloBeautifulWorld"); DN_Str8 trunc = DN_Str8Lit("..."); DN_Str8TruncResult dry = DN_Str8TruncMiddlePtr(str, 5, trunc, nullptr, 0); char dest[64] = {}; DN_Str8TruncResult actual = DN_Str8TruncMiddlePtr(str, 5, trunc, dest, sizeof(dest)); - DN_UT_Assert(&result, dry.size_req == actual.size_req); + DN_UT_Assert(&result, dry.count_req == actual.count_req); DN_UT_Assert(&result, dry.truncated == actual.truncated); } @@ -2412,7 +2412,7 @@ static DN_UTCore DN_TST_BaseStrings() char dest[14] = {}; // Exactly 2*5 + 3 + 1 DN_Str8TruncResult res = DN_Str8TruncMiddlePtr(str, 5, trunc, dest, sizeof(dest)); DN_UT_Assert(&result, res.truncated); - DN_UT_Assert(&result, res.size_req == 13); + DN_UT_Assert(&result, res.count_req == 13); DN_UT_AssertF(&result, DN_Str8Eq(res.str8, DN_Str8Lit("Hello...World")), "%.*s", DN_Str8PrintFmt(res.str8)); } @@ -2422,7 +2422,7 @@ static DN_UTCore DN_TST_BaseStrings() char dest[64] = {}; DN_Str8TruncResult res = DN_Str8TruncMiddlePtr(str, 1, trunc, dest, sizeof(dest)); DN_UT_Assert(&result, res.truncated); - DN_UT_Assert(&result, res.size_req == 5); // 1 + 3 + 1 + DN_UT_Assert(&result, res.count_req == 5); // 1 + 3 + 1 DN_UT_AssertF(&result, DN_Str8Eq(res.str8, DN_Str8Lit("H...d")), "%.*s", DN_Str8PrintFmt(res.str8)); } @@ -2432,7 +2432,7 @@ static DN_UTCore DN_TST_BaseStrings() char dest[64] = {}; DN_Str8TruncResult res = DN_Str8TruncMiddlePtr(str, 100, trunc, dest, sizeof(dest)); DN_UT_Assert(&result, !res.truncated); - DN_UT_Assert(&result, res.size_req == 5); + DN_UT_Assert(&result, res.count_req == 5); DN_UT_AssertF(&result, DN_Str8Eq(res.str8, DN_Str8Lit("Hello")), "%.*s", DN_Str8PrintFmt(res.str8)); } @@ -2443,9 +2443,9 @@ static DN_UTCore DN_TST_BaseStrings() DN_Str8 trunc = DN_Str8Lit("..."); DN_Str8TruncResult res = DN_Str8TruncMiddle(str, 5, trunc, &scratch.arena); DN_UT_Assert(&result, res.truncated); - DN_UT_Assert(&result, res.size_req == 13); + DN_UT_Assert(&result, res.count_req == 13); DN_UT_AssertF(&result, DN_Str8Eq(res.str8, DN_Str8Lit("Hello...World")), "%.*s", DN_Str8PrintFmt(res.str8)); - DN_UT_Assert(&result, res.str8.data[res.str8.size] == '\0'); + DN_UT_Assert(&result, res.str8.data[res.str8.count] == '\0'); DN_TCScratchEnd(&scratch); } } @@ -2493,8 +2493,8 @@ static DN_UTCore DN_TST_Win() int size_returned = DN_OS_W32Str16ToStr8Buffer(input16, nullptr, 0); char const EXPECTED[] = {'S', 't', 'r', 'i', 'n', 'g', 0}; - DN_UT_AssertF(&result, DN_Cast(int) string8.size == size_returned, "string_size: %d, result: %d", DN_Cast(int) string8.size, size_returned); - DN_UT_AssertF(&result, DN_Cast(int) string8.size == DN_ArrayCountU(EXPECTED) - 1, "string_size: %d, expected: %zu", DN_Cast(int) string8.size, DN_ArrayCountU(EXPECTED) - 1); + DN_UT_AssertF(&result, DN_Cast(int) string8.count == size_returned, "string_size: %d, result: %d", DN_Cast(int) string8.count, size_returned); + DN_UT_AssertF(&result, DN_Cast(int) string8.count == DN_ArrayCountU(EXPECTED) - 1, "string_size: %d, expected: %zu", DN_Cast(int) string8.count, DN_ArrayCountU(EXPECTED) - 1); DN_UT_Assert(&result, DN_Memcmp(EXPECTED, string8.data, sizeof(EXPECTED)) == 0); } DN_TCScratchEnd(&scratch); @@ -2517,7 +2517,7 @@ static DN_UTCore DN_TST_Net() label = DN_Str8Lit("CURL"); #endif - if (label.size) { + if (label.count) { DN_UT_LogF(&result, "DN_NET\n"); DN_MemList mem = DN_MemListFromHeap(DN_Megabytes(4), DN_MemFlags_Nil); @@ -2536,8 +2536,8 @@ static DN_UTCore DN_TST_Net() DN_NETResponse response = net_interface.wait_for_response(request, &arena, UINT32_MAX); DN_UT_AssertF(&result, response.http_status == 200, "http_status=%u", response.http_status); DN_UT_AssertF(&result, response.state == DN_NETResponseState_HTTP, "state=%u", response.state); - DN_UT_AssertF(&result, response.error_str8.size == 0, "%.*s", DN_Str8PrintFmt(response.error_str8)); - DN_UT_Assert(&result, response.body.size); + DN_UT_AssertF(&result, response.error_str8.count == 0, "%.*s", DN_Str8PrintFmt(response.error_str8)); + DN_UT_Assert(&result, response.body.count); } for (DN_UT_Test(&result, "%.*s WaitForResponse HTTP POST request", DN_Str8PrintFmt(label))) { @@ -2545,8 +2545,8 @@ static DN_UTCore DN_TST_Net() DN_NETResponse response = net_interface.wait_for_any_response(&net, &arena, UINT32_MAX); DN_UT_AssertF(&result, response.http_status == 200, "http_status=%u", response.http_status); DN_UT_AssertF(&result, response.state == DN_NETResponseState_HTTP, "state=%u", response.state); - DN_UT_AssertF(&result, response.error_str8.size == 0, "error=%.*s", DN_Str8PrintFmt(response.error_str8)); - DN_UT_Assert(&result, response.body.size); + DN_UT_AssertF(&result, response.error_str8.count == 0, "error=%.*s", DN_Str8PrintFmt(response.error_str8)); + DN_UT_Assert(&result, response.body.count); } for (DN_UT_Test(&result, "%.*s WaitForResponse WS request", DN_Str8PrintFmt(label))) { diff --git a/Source/OS/dn_os_posix.cpp b/Source/OS/dn_os_posix.cpp index 7bfab03..fe8425d 100644 --- a/Source/OS/dn_os_posix.cpp +++ b/Source/OS/dn_os_posix.cpp @@ -441,7 +441,7 @@ DN_API DN_OSFile DN_OS_FileOpen(DN_Str8 path, DN_ErrSink *error) { DN_OSFile result = {}; - if (path.size == 0 || path.size <= 0) + if (path.count == 0 || path.count <= 0) return result; if ((access & ~(DN_OSFileAccess_All) || ((access & DN_OSFileAccess_All) == 0))) { @@ -568,7 +568,7 @@ DN_API void DN_OS_FileClose(DN_OSFile *file) DN_API DN_OSPathInfo DN_OS_PathInfo(DN_Str8 path) { DN_OSPathInfo result = {}; - if (path.size == 0) + if (path.count == 0) return result; struct stat file_stat; @@ -592,7 +592,7 @@ DN_API DN_OSPathInfo DN_OS_PathInfo(DN_Str8 path) DN_API bool DN_OS_PathDelete(DN_Str8 path) { bool result = false; - if (path.size) + if (path.count) result = remove(path.data) == 0; return result; } @@ -600,7 +600,7 @@ DN_API bool DN_OS_PathDelete(DN_Str8 path) DN_API bool DN_OS_PathIsFile(DN_Str8 path) { bool result = false; - if (path.size == 0) + if (path.count == 0) return result; struct stat stat_result; @@ -612,7 +612,7 @@ DN_API bool DN_OS_PathIsFile(DN_Str8 path) DN_API bool DN_OS_PathIsDir(DN_Str8 path) { bool result = false; - if (path.size == 0) + if (path.count == 0) return result; struct stat stat_result; @@ -632,8 +632,8 @@ DN_API bool DN_OS_PathMakeDir(DN_Str8 path) uint16_t path_indexes[64] = {}; DN_Str8 copy = DN_Str8FromStr8Arena(path, &scratch.arena); - for (DN_USize index = copy.size - 1; index < copy.size; index--) { - bool first_char = index == (copy.size - 1); + for (DN_USize index = copy.count - 1; index < copy.count; index--) { + bool first_char = index == (copy.count - 1); char ch = copy.data[index]; if (ch == '/' || first_char) { char temp = copy.data[index]; @@ -696,12 +696,12 @@ DN_API bool DN_OS_PathIterateDir(DN_Str8 path, DN_OSDirIterator *it) if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0) continue; - DN_USize name_size = DN_CStr8Size(entry->d_name); - DN_USize clamped_size = DN_Min(sizeof(it->buffer) - 1, name_size); - DN_AssertF(name_size == clamped_size, "name: %s, name_size: %zu, clamped_size: %zu", entry->d_name, name_size, clamped_size); - DN_Memcpy(it->buffer, entry->d_name, clamped_size); - it->buffer[clamped_size] = 0; - it->file_name = DN_Str8FromPtr(it->buffer, clamped_size); + DN_USize name_count = DN_CStr8Count(entry->d_name); + DN_USize clamped_count = DN_Min(sizeof(it->buffer) - 1, name_count); + DN_AssertF(name_count == clamped_count, "name: %s, name_size: %zu, clamped_size: %zu", entry->d_name, name_count, clamped_count); + DN_Memcpy(it->buffer, entry->d_name, clamped_count); + it->buffer[clamped_count] = 0; + it->file_name = DN_Str8FromPtr(it->buffer, clamped_count); return true; } @@ -962,7 +962,7 @@ DN_API DN_OSExecAsyncHandle DN_OS_ExecAsync(DN_Str8Slice cmd_line, free(prev_working_dir); }; - if (args->working_dir.size) { + if (args->working_dir.count) { prev_working_dir = get_current_dir_name(); DN_Str8 working_dir = DN_Str8FromStr8Arena(args->working_dir, &scratch.arena); if (chdir(working_dir.data) == -1) { @@ -1410,23 +1410,23 @@ DN_API DN_OSPosixProcSelfStatus DN_OS_PosixProcSelfStatus() for (DN_ForItSize(line_it, DN_Str8, lines.data, lines.count)) { DN_Str8 line = DN_Str8TrimWhitespaceAround(*line_it.data); if (DN_Str8StartsWith(line, NAME, DN_Str8EqCase_Insensitive)) { - DN_Str8 str8 = DN_Str8TrimWhitespaceAround(DN_Str8Subset(line, NAME.size, line.size)); - result.name_size = DN_Min(str8.size, sizeof(result.name)); + DN_Str8 str8 = DN_Str8TrimWhitespaceAround(DN_Str8Subset(line, NAME.count, line.count)); + result.name_size = DN_Min(str8.count, sizeof(result.name)); DN_Memcpy(result.name, str8.data, result.name_size); } else if (DN_Str8StartsWith(line, PID, DN_Str8EqCase_Insensitive)) { - DN_Str8 str8 = DN_Str8TrimWhitespaceAround(DN_Str8Subset(line, PID.size, line.size)); + DN_Str8 str8 = DN_Str8TrimWhitespaceAround(DN_Str8Subset(line, PID.count, line.count)); DN_U64FromResult to_u64 = DN_U64FromStr8(str8, 0); result.pid = to_u64.value; DN_Assert(to_u64.success); } else if (DN_Str8StartsWith(line, VM_SIZE, DN_Str8EqCase_Insensitive)) { - DN_Str8 size_with_kb = DN_Str8TrimWhitespaceAround(DN_Str8Subset(line, VM_SIZE.size, line.size)); + DN_Str8 size_with_kb = DN_Str8TrimWhitespaceAround(DN_Str8Subset(line, VM_SIZE.count, line.count)); DN_Assert(DN_Str8EndsWith(size_with_kb, DN_Str8Lit("kB"))); DN_Str8 vm_size = DN_Str8BSplit(size_with_kb, DN_Str8Lit(" ")).lhs; DN_U64FromResult to_u64 = DN_U64FromStr8(vm_size, 0); result.vm_size = DN_Kilobytes(to_u64.value); DN_Assert(to_u64.success); } else if (DN_Str8StartsWith(line, VM_PEAK, DN_Str8EqCase_Insensitive)) { - DN_Str8 size_with_kb = DN_Str8TrimWhitespaceAround(DN_Str8Subset(line, VM_PEAK.size, line.size)); + DN_Str8 size_with_kb = DN_Str8TrimWhitespaceAround(DN_Str8Subset(line, VM_PEAK.count, line.count)); DN_Assert(DN_Str8EndsWith(size_with_kb, DN_Str8Lit("kB"))); DN_Str8 vm_size = DN_Str8BSplit(size_with_kb, DN_Str8Lit(" ")).lhs; DN_U64FromResult to_u64 = DN_U64FromStr8(vm_size, 0); diff --git a/Source/OS/dn_os_w32.cpp b/Source/OS/dn_os_w32.cpp index ce14913..60932ea 100644 --- a/Source/OS/dn_os_w32.cpp +++ b/Source/OS/dn_os_w32.cpp @@ -336,7 +336,7 @@ DN_API bool DN_OS_FileMove(DN_Str8 src, DN_Str8 dest, bool overwrite, DN_ErrSink DN_API DN_OSFile DN_OS_FileOpen(DN_Str8 path, DN_OSFileOpen open_mode, DN_OSFileAccess access, DN_ErrSink *err) { DN_OSFile result = {}; - if (path.size == 0 || path.size <= 0) + if (path.count == 0 || path.count <= 0) return result; if ((access & ~DN_OSFileAccess_All) || ((access & DN_OSFileAccess_All) == 0)) { @@ -486,7 +486,7 @@ DN_API void DN_OS_FileClose(DN_OSFile *file) DN_API DN_OSPathInfo DN_OS_PathInfo(DN_Str8 path) { DN_OSPathInfo result = {}; - if (path.size == 0) + if (path.count == 0) return result; DN_TCScratch scratch = DN_TCScratchBeginArena(nullptr, 0); @@ -522,12 +522,12 @@ DN_API DN_OSPathInfo DN_OS_PathInfo(DN_Str8 path) DN_API bool DN_OS_PathDelete(DN_Str8 path) { bool result = false; - if (path.size == 0) + if (path.count == 0) return result; DN_TCScratch scratch = DN_TCScratchBeginArena(nullptr, 0); DN_Str16 path16 = DN_OS_W32Str8ToStr16(&scratch.arena, path); - if (path16.size) { + if (path16.count) { result = DeleteFileW(path16.data); if (!result) result = RemoveDirectoryW(path16.data); @@ -539,12 +539,12 @@ DN_API bool DN_OS_PathDelete(DN_Str8 path) DN_API bool DN_OS_PathIsFile(DN_Str8 path) { bool result = false; - if (path.size == 0) + if (path.count == 0) return result; DN_TCScratch scratch = DN_TCScratchBeginArena(nullptr, 0); DN_Str16 path16 = DN_OS_W32Str8ToStr16(&scratch.arena, path); - if (path16.size) { + if (path16.count) { WIN32_FILE_ATTRIBUTE_DATA attrib_data = {}; if (GetFileAttributesExW(path16.data, GetFileExInfoStandard, &attrib_data)) result = (attrib_data.dwFileAttributes != INVALID_FILE_ATTRIBUTES) && @@ -557,12 +557,12 @@ DN_API bool DN_OS_PathIsFile(DN_Str8 path) DN_API bool DN_OS_PathIsDir(DN_Str8 path) { bool result = false; - if (path.size == 0) + if (path.count == 0) return result; DN_TCScratch scratch = DN_TCScratchBeginArena(nullptr, 0); DN_Str16 path16 = DN_OS_W32Str8ToStr16(&scratch.arena, path); - if (path16.size) { + if (path16.count) { WIN32_FILE_ATTRIBUTE_DATA attrib_data = {}; if (GetFileAttributesExW(path16.data, GetFileExInfoStandard, &attrib_data)) result = (attrib_data.dwFileAttributes != INVALID_FILE_ATTRIBUTES) && @@ -591,8 +591,8 @@ DN_API bool DN_OS_PathMakeDir(DN_Str8 path) // If we find a file at some point in the path we fail out because the // series of directories can not be made if a file exists with the same // name. - for (DN_USize index = 0; index < path16.size; index++) { - bool first_char = index == (path16.size - 1); + for (DN_USize index = 0; index < path16.count; index++) { + bool first_char = index == (path16.count - 1); wchar_t ch = path16.data[index]; if (ch == '/' || ch == '\\' || first_char) { wchar_t temp = path16.data[index]; @@ -628,7 +628,7 @@ DN_API bool DN_OS_PathMakeDir(DN_Str8 path) DN_API bool DN_OS_PathIterateDir(DN_Str8 path, DN_OSDirIterator *it) { - if (path.size == 0 || !it || path.size <= 0) + if (path.count == 0 || !it || path.count <= 0) return false; DN_TCScratch scratch = DN_TCScratchBeginArena(nullptr, 0); @@ -654,7 +654,7 @@ DN_API bool DN_OS_PathIterateDir(DN_Str8 path, DN_OSDirIterator *it) } path16 = DN_OS_W32Str8ToStr16(&scratch.arena, adjusted_path); - if (path16.size <= 0) { // Conversion error + if (path16.count <= 0) { // Conversion error DN_TCScratchEnd(&scratch); return false; } @@ -836,7 +836,7 @@ DN_API DN_OSExecResult DN_OS_ExecWait(DN_OSExecAsyncHandle handle, DN_Arena *are result = DN_OS_ExecPump(handle, stdout_buffer, &stdout_size, stderr_buffer, &stderr_size, wait_ms, err); DN_Str8BuilderAppendCopy(&stdout_builder, result.stdout_text); DN_Str8BuilderAppendCopy(&stderr_builder, result.stderr_text); - wait_ms = (result.stdout_text.size || result.stderr_text.size) ? FAST_WAIT_TIME_MS : SLOW_WAIT_TIME_MS; + wait_ms = (result.stdout_text.count || result.stderr_text.count) ? FAST_WAIT_TIME_MS : SLOW_WAIT_TIME_MS; } // NOTE: Get stdout/stderr. If no arena is passed this is a no-op @@ -865,7 +865,7 @@ DN_API DN_OSExecAsyncHandle DN_OS_ExecAsync(DN_Str8Slice cmd_line, DN_OSExecArgs DN_Str8 env_block8 = DN_Str8FromStr8BuilderDelimitArena(&env_builder, DN_Str8Lit("\0"), &scratch.arena); DN_Str16 env_block16 = {}; - if (env_block8.size) + if (env_block8.count) env_block16 = DN_OS_W32Str8ToStr16(&scratch.arena, env_block8); // NOTE: Stdout/err security attributes @@ -1346,17 +1346,17 @@ DN_API DN_Str16 DN_OS_W32ErrorCodeToMsg16Alloc(DN_U32 error_code) } wchar_t *result16 = nullptr; - DWORD size = FormatMessageW(/*DWORD dwFlags */ flags | FORMAT_MESSAGE_ALLOCATE_BUFFER, - /*LPCVOID lpSource */ module_to_get_errors_from, - /*DWORD dwMessageId */ error_code, - /*DWORD dwLanguageId*/ 0, - /*LPWSTR lpBuffer */ (LPWSTR)&result16, - /*DWORD nSize */ 0, - /*va_list *Arguments */ nullptr); + DWORD count = FormatMessageW(/*DWORD dwFlags */ flags | FORMAT_MESSAGE_ALLOCATE_BUFFER, + /*LPCVOID lpSource */ module_to_get_errors_from, + /*DWORD dwMessageId */ error_code, + /*DWORD dwLanguageId*/ 0, + /*LPWSTR lpBuffer */ (LPWSTR)&result16, + /*DWORD nSize */ 0, + /*va_list *Arguments */ nullptr); DN_Str16 result = {}; result.data = result16; - result.size = size; + result.count = count; return result; } @@ -1365,7 +1365,7 @@ DN_API DN_OSW32Error DN_OS_W32ErrorCodeToMsgAlloc(DN_U32 error_code) DN_OSW32Error result = {}; result.code = error_code; DN_Str16 error16 = DN_OS_W32ErrorCodeToMsg16Alloc(error_code); - if (error16.size) + if (error16.count) result.msg = DN_OS_W32Str16ToStr8FromHeap(error16); if (error16.data) LocalFree(error16.data); @@ -1378,7 +1378,7 @@ DN_API DN_OSW32Error DN_OS_W32ErrorCodeToMsg(DN_Arena *arena, DN_U32 error_code) result.code = error_code; if (arena) { DN_Str16 error16 = DN_OS_W32ErrorCodeToMsg16Alloc(error_code); - if (error16.size) + if (error16.count) result.msg = DN_OS_W32Str16ToStr8(arena, error16); if (error16.data) LocalFree(error16.data); @@ -1423,10 +1423,10 @@ DN_API void DN_OS_W32MakeProcessDPIAware() DN_API DN_Str16 DN_OS_W32Str8ToStr16(DN_Arena *arena, DN_Str8 src) { DN_Str16 result = {}; - if (!arena || src.size == 0) + if (!arena || src.count == 0) return result; - int required_size = MultiByteToWideChar(CP_UTF8, 0 /*dwFlags*/, src.data, DN_Cast(int) src.size, nullptr /*dest*/, 0 /*dest size*/); + int required_size = MultiByteToWideChar(CP_UTF8, 0 /*dwFlags*/, src.data, DN_Cast(int) src.count, nullptr /*dest*/, 0 /*dest size*/); if (required_size <= 0) return result; @@ -1434,12 +1434,12 @@ DN_API DN_Str16 DN_OS_W32Str8ToStr16(DN_Arena *arena, DN_Str8 src) if (!buffer) return result; - int chars_written = MultiByteToWideChar(CP_UTF8, 0 /*dwFlags*/, src.data, DN_Cast(int) src.size, buffer, required_size); + int chars_written = MultiByteToWideChar(CP_UTF8, 0 /*dwFlags*/, src.data, DN_Cast(int) src.count, buffer, required_size); DN_Assert(chars_written == required_size); if (chars_written == required_size) { - result.data = buffer; - result.size = chars_written; - result.data[result.size] = 0; + result.data = buffer; + result.count = chars_written; + result.data[result.count] = 0; } return result; } @@ -1447,14 +1447,14 @@ DN_API DN_Str16 DN_OS_W32Str8ToStr16(DN_Arena *arena, DN_Str8 src) DN_API int DN_OS_W32Str8ToStr16Buffer(DN_Str8 src, wchar_t *dest, int dest_size) { int result = 0; - if (src.size == 0) + if (src.count == 0) return result; - result = MultiByteToWideChar(CP_UTF8, 0 /*dwFlags*/, src.data, DN_Cast(int) src.size, nullptr /*dest*/, 0 /*dest size*/); + result = MultiByteToWideChar(CP_UTF8, 0 /*dwFlags*/, src.data, DN_Cast(int) src.count, nullptr /*dest*/, 0 /*dest size*/); if (result <= 0 || result > dest_size || !dest) return result; - result = MultiByteToWideChar(CP_UTF8, 0 /*dwFlags*/, src.data, DN_Cast(int) src.size, dest, DN_Cast(int) dest_size); + result = MultiByteToWideChar(CP_UTF8, 0 /*dwFlags*/, src.data, DN_Cast(int) src.count, dest, DN_Cast(int) dest_size); dest[DN_Min(result, dest_size - 1)] = 0; return result; } @@ -1462,10 +1462,10 @@ DN_API int DN_OS_W32Str8ToStr16Buffer(DN_Str8 src, wchar_t *dest, int dest_size) DN_API int DN_OS_W32Str16ToStr8Buffer(DN_Str16 src, char *dest, int dest_size) { int result = 0; - if (src.size == 0) + if (src.count == 0) return result; - int src_size = DN_SaturateCastISizeToInt(src.size); + int src_size = DN_SaturateCastISizeToInt(src.count); if (src_size <= 0) return result; @@ -1481,10 +1481,10 @@ DN_API int DN_OS_W32Str16ToStr8Buffer(DN_Str16 src, char *dest, int dest_size) DN_API DN_Str8 DN_OS_W32Str16ToStr8(DN_Arena *arena, DN_Str16 src) { DN_Str8 result = {}; - if (!arena || src.size == 0) + if (!arena || src.count == 0) return result; - int src_size = DN_SaturateCastISizeToInt(src.size); + int src_size = DN_SaturateCastISizeToInt(src.count); if (src_size <= 0) return result; @@ -1496,25 +1496,25 @@ DN_API DN_Str8 DN_OS_W32Str16ToStr8(DN_Arena *arena, DN_Str16 src) // null-termination already so no-need to +1 the required size DN_Arena temp = DN_ArenaTempBeginFromArena(arena); DN_Str8 buffer = DN_Str8AllocArena(required_size, DN_ZMem_No, &temp); - if (buffer.size) { - int chars_written = WideCharToMultiByte(CP_UTF8, 0 /*dwFlags*/, src.data, src_size, buffer.data, DN_Cast(int) buffer.size, nullptr, nullptr); + if (buffer.count) { + int chars_written = WideCharToMultiByte(CP_UTF8, 0 /*dwFlags*/, src.data, src_size, buffer.data, DN_Cast(int) buffer.count, nullptr, nullptr); DN_Assert(chars_written == required_size); if (chars_written == required_size) { result = buffer; - result.data[result.size] = 0; + result.data[result.count] = 0; } } - DN_ArenaTempEnd(&temp, result.size == DN_Cast(DN_USize)required_size ? DN_ArenaReset_No : DN_ArenaReset_Yes); + DN_ArenaTempEnd(&temp, result.count == DN_Cast(DN_USize)required_size ? DN_ArenaReset_No : DN_ArenaReset_Yes); return result; } DN_API DN_Str8 DN_OS_W32Str16ToStr8FromHeap(DN_Str16 src) { DN_Str8 result = {}; - if (src.size == 0) + if (src.count == 0) return result; - int src_size = DN_SaturateCastISizeToInt(src.size); + int src_size = DN_SaturateCastISizeToInt(src.count); if (src_size <= 0) return result; @@ -1525,14 +1525,14 @@ DN_API DN_Str8 DN_OS_W32Str16ToStr8FromHeap(DN_Str16 src) // NOTE: Str8 allocate ensures there's one extra byte for // null-termination already so no-need to +1 the required size DN_Str8 buffer = DN_Str8FromHeap(required_size, DN_ZMem_No); - if (buffer.size == 0) + if (buffer.count == 0) return result; - int chars_written = WideCharToMultiByte(CP_UTF8, 0 /*dwFlags*/, src.data, src_size, buffer.data, DN_Cast(int) buffer.size, nullptr, nullptr); + int chars_written = WideCharToMultiByte(CP_UTF8, 0 /*dwFlags*/, src.data, src_size, buffer.data, DN_Cast(int) buffer.count, nullptr, nullptr); DN_Assert(chars_written == required_size); if (chars_written == required_size) { result = buffer; - result.data[result.size] = 0; + result.data[result.count] = 0; } else { DN_OS_MemDealloc(buffer.data); buffer = {}; @@ -1563,9 +1563,9 @@ DN_API DN_Str16 DN_OS_W32EXEPathW(DN_Arena *arena) index_of_last_slash = module_path[index] == '\\' ? index : 0; result.data = DN_ArenaNewArray(arena, wchar_t, module_size + 1, DN_ZMem_No); - result.size = module_size; - DN_Memcpy(result.data, module_path, sizeof(wchar_t) * result.size); - result.data[result.size] = 0; + result.count = module_size; + DN_Memcpy(result.data, module_path, sizeof(wchar_t) * result.count); + result.data[result.count] = 0; DN_TCScratchEnd(&scratch); return result; } @@ -1592,9 +1592,9 @@ DN_API DN_Str16 DN_OS_W32EXEDirW(DN_Arena *arena) index_of_last_slash = module_path[index] == '\\' ? index : 0; result.data = DN_ArenaNewArray(arena, wchar_t, index_of_last_slash + 1, DN_ZMem_No); - result.size = index_of_last_slash; - DN_Memcpy(result.data, module_path, sizeof(wchar_t) * result.size); - result.data[result.size] = 0; + result.count = index_of_last_slash; + DN_Memcpy(result.data, module_path, sizeof(wchar_t) * result.count); + result.data[result.count] = 0; DN_TCScratchEnd(&scratch); return result; } @@ -1611,13 +1611,13 @@ DN_API DN_Str8 DN_OS_W32WorkingDir(DN_Arena *arena, DN_Str8 suffix) DN_API DN_Str16 DN_OS_W32WorkingDirW(DN_Arena *arena, DN_Str16 suffix) { - DN_Assert(suffix.size >= 0); + DN_Assert(suffix.count >= 0); DN_Str16 result = {}; // NOTE: required_size is the size required *including* the null-terminator DN_TCScratch scratch = DN_TCScratchBeginArena(&arena, 1); unsigned long required_size = GetCurrentDirectoryW(0, nullptr); - unsigned long desired_size = required_size + DN_Cast(unsigned long) suffix.size; + unsigned long desired_size = required_size + DN_Cast(unsigned long) suffix.count; wchar_t *scratch_w_path = DN_ArenaNewArray(&scratch.arena, wchar_t, desired_size, DN_ZMem_No); if (!scratch_w_path) { @@ -1638,9 +1638,9 @@ DN_API DN_Str16 DN_OS_W32WorkingDirW(DN_Arena *arena, DN_Str16 suffix) return result; } - if (suffix.size) { + if (suffix.count) { DN_Memcpy(w_path, scratch_w_path, sizeof(*scratch_w_path) * bytes_written_wo_null_terminator); - DN_Memcpy(w_path + bytes_written_wo_null_terminator, suffix.data, sizeof(suffix.data[0]) * suffix.size); + DN_Memcpy(w_path + bytes_written_wo_null_terminator, suffix.data, sizeof(suffix.data[0]) * suffix.count); w_path[desired_size] = 0; } @@ -1676,14 +1676,14 @@ DN_API bool DN_OS_W32DirWIterate(DN_Str16 path, DN_OSW32FolderIteratorW *it) if (find_data.cFileName[0] == '.' || (find_data.cFileName[0] == '.' && find_data.cFileName[1] == '.')) continue; - it->file_name.size = DN_CStr16Size(find_data.cFileName); - DN_Assert(it->file_name.size < (DN_ArrayCountU(it->file_name_buf) - 1)); - DN_Memcpy(it->file_name.data, find_data.cFileName, it->file_name.size * sizeof(wchar_t)); - it->file_name_buf[it->file_name.size] = 0; + it->file_name.count = DN_CStr16Count(find_data.cFileName); + DN_Assert(it->file_name.count < (DN_ArrayCountU(it->file_name_buf) - 1)); + DN_Memcpy(it->file_name.data, find_data.cFileName, it->file_name.count * sizeof(wchar_t)); + it->file_name_buf[it->file_name.count] = 0; break; } while (FindNextFileW(it->handle, &find_data) != 0); - bool result = it->file_name.size > 0; + bool result = it->file_name.count > 0; if (!result) FindClose(it->handle); return result; diff --git a/Source/Standalone/dn_ini.c b/Source/Standalone/dn_ini.c index 6df1b7a..2ec3d9e 100644 --- a/Source/Standalone/dn_ini.c +++ b/Source/Standalone/dn_ini.c @@ -41,7 +41,7 @@ DN_INIStr8 DN_INI_Str8FromPtr(char const *data, size_t count) { DN_INIStr8 result = {}; result.data = (char *)data; - result.size = count; + result.count = count; return result; } @@ -82,20 +82,20 @@ DN_INIStr8FromResult DN_INI_Str8FromINI(DN_INICore const *ini, char *buffer, siz if (it != &ini->first_section) { DN_INI_Str8BuilderAppend_(&builder, "["); for (DN_INISection *parent = it->parent; parent; parent = parent->parent) - if (parent->name.size) + if (parent->name.count) parent_stack[parent_stack_count++] = parent; for (size_t index = parent_stack_count - 1; index < parent_stack_count; index--) { DN_INISection *parent = parent_stack[index]; - DN_INI_Str8BuilderAppend_(&builder, "%.*s.", (int)parent->name.size, parent->name.data); + DN_INI_Str8BuilderAppend_(&builder, "%.*s.", (int)parent->name.count, parent->name.data); } parent_stack_count = 0; - DN_INI_Str8BuilderAppend_(&builder, "%.*s]\n", (int)it->name.size, it->name.data); + DN_INI_Str8BuilderAppend_(&builder, "%.*s]\n", (int)it->name.count, it->name.data); } for (DN_INIField *field = it->first_field; field; field = field->next) { - DN_INI_Str8BuilderAppend_(&builder, "%.*s = ", (int)field->key.size, field->key.data); + DN_INI_Str8BuilderAppend_(&builder, "%.*s = ", (int)field->key.count, field->key.data); switch (field->value_type) { - case DN_INIFieldType_String: DN_INI_Str8BuilderAppend_(&builder, "%.*s\n", (int)field->value.size, field->value.data); break; + case DN_INIFieldType_String: DN_INI_Str8BuilderAppend_(&builder, "%.*s\n", (int)field->value.count, field->value.data); break; case DN_INIFieldType_Bool: DN_INI_Str8BuilderAppend_(&builder, "%d\n", field->value_bool); break; case DN_INIFieldType_USize: DN_INI_Str8BuilderAppend_(&builder, "%zu\n", field->value_usize); break; } @@ -113,7 +113,7 @@ DN_INIStr8FromResult DN_INI_Str8FromINI(DN_INICore const *ini, char *buffer, siz result.size_req = builder.size_req; if (buffer) { result.str8.data = builder.data; - result.str8.size = builder.used; + result.str8.count = builder.used; result.success = true; } else { result.success = true; @@ -124,7 +124,7 @@ DN_INIStr8FromResult DN_INI_Str8FromINI(DN_INICore const *ini, char *buffer, siz static bool DN_INI_Str8Eq(DN_INIStr8 lhs, DN_INIStr8 rhs) { - bool result = lhs.size == rhs.size && DN_INI_Memcmp(lhs.data, rhs.data, lhs.size) == 0; + bool result = lhs.count == rhs.count && DN_INI_Memcmp(lhs.data, rhs.data, lhs.count) == 0; return result; } @@ -132,11 +132,11 @@ static DN_INIStr8 DN_INI_Str8Slice(DN_INIStr8 slice, size_t offset, size_t size) { DN_INIStr8 result = {}; if (slice.data) { - size_t max_offset = slice.size; + size_t max_offset = slice.count; size_t final_offset = offset <= max_offset ? offset : max_offset; - size_t max_size = slice.size - final_offset; + size_t max_size = slice.count - final_offset; result.data = slice.data + final_offset; - result.size = size <= max_size ? size : max_size; + result.count = size <= max_size ? size : max_size; } return result; } @@ -144,15 +144,15 @@ static DN_INIStr8 DN_INI_Str8Slice(DN_INIStr8 slice, size_t offset, size_t size) static DN_INIStr8BSplit DN_INI_Str8BSplit(DN_INIStr8 str8, DN_INIStr8 find) { DN_INIStr8BSplit result = {}; - if (find.size > str8.size) + if (find.count > str8.count) return result; - for (size_t index = 0; index < (str8.size - find.size) + 1; index++) { - DN_INIStr8 slice = DN_INI_Str8FromPtr(str8.data + index, find.size); + for (size_t index = 0; index < (str8.count - find.count) + 1; index++) { + DN_INIStr8 slice = DN_INI_Str8FromPtr(str8.data + index, find.count); if (DN_INI_Str8Eq(slice, find)) { result.lhs = DN_INI_Str8FromPtr(str8.data, (size_t)index); - size_t rhs_size = (size_t)(str8.size - (index + 1)); - DN_INI_Assert(rhs_size < str8.size); + size_t rhs_size = (size_t)(str8.count - (index + 1)); + DN_INI_Assert(rhs_size < str8.count); result.rhs = DN_INI_Str8FromPtr(str8.data + index + 1, rhs_size); break; } @@ -166,16 +166,16 @@ static DN_INIStr8BSplit DN_INI_Str8BSplit(DN_INIStr8 str8, DN_INIStr8 find) static DN_INIStr8BSplit DN_INI_Str8BSplitReverse(DN_INIStr8 str8, DN_INIStr8 find) { DN_INIStr8BSplit result = {}; - if (find.size > str8.size) + if (find.count > str8.count) return result; - for (size_t index = str8.size - find.size; index > 0; index--) { - DN_INIStr8 slice = DN_INI_Str8FromPtr(str8.data + index, find.size); + for (size_t index = str8.count - find.count; index > 0; index--) { + DN_INIStr8 slice = DN_INI_Str8FromPtr(str8.data + index, find.count); if (DN_INI_Str8Eq(slice, find)) { result.lhs = DN_INI_Str8FromPtr(str8.data, (size_t)index); - size_t rhs_size = (size_t)(str8.size - index - find.size); - DN_INI_Assert(rhs_size < str8.size); - result.rhs = DN_INI_Str8FromPtr(str8.data + index + find.size, rhs_size); + size_t rhs_size = (size_t)(str8.count - index - find.count); + DN_INI_Assert(rhs_size < str8.count); + result.rhs = DN_INI_Str8FromPtr(str8.data + index + find.count, rhs_size); break; } } @@ -399,7 +399,7 @@ DN_INISection *DN_INI_ChildSectionFromStr8(DN_INISection *section, DN_INIStr8 st DN_INISection *curr = section; while (result) { DN_INIStr8BSplit split = DN_INI_Str8BSplit(section_name, DN_INIStr8Lit(".")); - if (split.lhs.size == 0) + if (split.lhs.count == 0) break; result = 0; @@ -426,8 +426,8 @@ DN_INIField *DN_INI_FieldFromSectionStr8(DN_INISection *section, DN_INIStr8 str8 DN_INIStr8BSplit split = DN_INI_Str8BSplitReverse(str8, DN_INIStr8Lit(".")); DN_INIStr8 find_key = str8; DN_INISection *find_section = section; - if (split.rhs.size) { - find_section = DN_INI_ChildSectionFromCStr(section, split.lhs.data, split.lhs.size); + if (split.rhs.count) { + find_section = DN_INI_ChildSectionFromCStr(section, split.lhs.data, split.lhs.count); find_key = split.rhs; } @@ -458,20 +458,20 @@ DN_INIFieldUSize DN_INI_FieldUSizeFromSectionStr8(DN_INISection *section, DN_INI // NOTE: Try parse string as USize // NOTE: Sanitize input/output DN_INIStr8 value = result.field->value; - while (value.size && DN_INI_CharIsWhitespace_(value.data[0])) { + while (value.count && DN_INI_CharIsWhitespace_(value.data[0])) { value.data++; - value.size--; + value.count--; } // NOTE: Handle prefix '+' - if (value.size && value.data[0] == '+') { + if (value.count && value.data[0] == '+') { value.data++; - value.size--; + value.count--; } // NOTE: Convert the string number to the binary number size_t value_usize = 0; - for (size_t index = 0; index < value.size; index++) { + for (size_t index = 0; index < value.count; index++) { char ch = value.data[index]; uint64_t digit = ch - '0'; if (!(ch >= '0' && ch <= '9')) @@ -556,10 +556,10 @@ DN_INICore DN_INI_ParseFromPtr(char const *buf, size_t count, char *base, size_t curr_section = &result.first_section; for (;;) { DN_INIStr8BSplit split = DN_INI_Str8BSplit(section_name, DN_INIStr8Lit(".")); - if (split.lhs.size == 0) + if (split.lhs.count == 0) break; - DN_INISection *next_section = DN_INI_ChildSectionFromCStr(parent, split.lhs.data, split.lhs.size); + DN_INISection *next_section = DN_INI_ChildSectionFromCStr(parent, split.lhs.data, split.lhs.count); if (!next_section) { result.total_sections_count++; next_section = (DN_INISection *)DN_INI_ArenaAlloc(&arena, sizeof(*parent)); @@ -598,7 +598,7 @@ DN_INICore DN_INI_ParseFromPtr(char const *buf, size_t count, char *base, size_t if (field) { field->key.data = token.data; - field->key.size = token.count; + field->key.count = token.count; } if (curr_section) { @@ -623,7 +623,7 @@ DN_INICore DN_INI_ParseFromPtr(char const *buf, size_t count, char *base, size_t result.memory_required += bytes_req; if (curr_section && field) { DN_INI_Assert(curr_section->fields_count); - DN_INI_Assert(field->key.size); + DN_INI_Assert(field->key.count); char *string = (char *)DN_INI_ArenaAlloc(&arena, bytes_req); if (!string) { @@ -634,16 +634,16 @@ DN_INICore DN_INI_ParseFromPtr(char const *buf, size_t count, char *base, size_t if (tokeniser.prev_token.type == DN_INITokenType_Value) { field->value.data = string; - field->value.size = 0; + field->value.count = 0; for (size_t index = 0; index < tokeniser.prev_token.count; index++) { char ch = tokeniser.prev_token.data[index]; char next = index + 1 < tokeniser.prev_token.count ? tokeniser.prev_token.data[index + 1] : 0; if (ch == '\\' && next == 'n') { - field->value.data[field->value.size++] = '\n'; + field->value.data[field->value.count++] = '\n'; index++; } else { - field->value.data[field->value.size++] = ch; + field->value.data[field->value.count++] = ch; } } } else { @@ -657,10 +657,10 @@ DN_INICore DN_INI_ParseFromPtr(char const *buf, size_t count, char *base, size_t char ch = token.data[index]; char next = index + 1 < token.count ? token.data[index + 1] : 0; if (ch == '\\' && next == 'n') { - field->value.data[field->value.size++] = '\n'; + field->value.data[field->value.count++] = '\n'; index++; } else { - field->value.data[field->value.size++] = ch; + field->value.data[field->value.count++] = ch; } } } @@ -682,7 +682,7 @@ DN_INICore DN_INI_ParseFromPtr(char const *buf, size_t count, char *base, size_t result.memory_required += bytes_req; if (curr_section && field) { DN_INI_Assert(curr_section->fields_count); - DN_INI_Assert(field->key.size); + DN_INI_Assert(field->key.count); if (bytes_req) { field->value.data = (char *)DN_INI_ArenaAlloc(&arena, bytes_req); if (!field->value.data) { @@ -694,16 +694,16 @@ DN_INICore DN_INI_ParseFromPtr(char const *buf, size_t count, char *base, size_t char ch = token.data[index]; char next = index + 1 < token.count ? token.data[index + 1] : 0; if (ch == '\\' && next == 'n') { - field->value.data[field->value.size++] = '\n'; + field->value.data[field->value.count++] = '\n'; index++; } else { - field->value.data[field->value.size++] = ch; + field->value.data[field->value.count++] = ch; } } - DN_INI_Assert(field->value.size <= bytes_req); + DN_INI_Assert(field->value.count <= bytes_req); } else { field->value.data = token.data; - field->value.size = token.count; + field->value.count = token.count; } } } break; @@ -738,8 +738,8 @@ DN_INISection *DN_INI_AppendSectionF(DN_INICore *ini, DN_INIArena *arena, DN_INI if (arena && arena->used + mem_req <= arena->max) { result = (DN_INISection *)DN_INI_ArenaAlloc(arena, sizeof(*result)); result->name.data = (char *)DN_INI_ArenaAlloc(arena, size_req + 1); - result->name.size = size_req; - vsnprintf(result->name.data, result->name.size + 1, fmt, args_copy); + result->name.count = size_req; + vsnprintf(result->name.data, result->name.count + 1, fmt, args_copy); if (!section) section = &ini->first_section; @@ -766,13 +766,13 @@ DN_INISection *DN_INI_AppendSectionF(DN_INICore *ini, DN_INIArena *arena, DN_INI static DN_INIField *DN_INI_AllocFieldInternal(DN_INIStr8 key, DN_INIArena *arena) { DN_INIField *result = 0; - size_t mem_req = sizeof(*result) + (key.size + 1); + size_t mem_req = sizeof(*result) + (key.count + 1); if (arena->used + mem_req <= arena->max) { result = (DN_INIField *)DN_INI_ArenaAlloc(arena, sizeof(*result)); - result->key.data = (char *)DN_INI_ArenaAlloc(arena, key.size + 1); - result->key.size = key.size; - DN_INI_Memcpy(result->key.data, key.data, key.size); - result->key.data[result->key.size] = 0; + result->key.data = (char *)DN_INI_ArenaAlloc(arena, key.count + 1); + result->key.count = key.count; + DN_INI_Memcpy(result->key.data, key.data, key.count); + result->key.data[result->key.count] = 0; } return result; } @@ -780,13 +780,13 @@ static DN_INIField *DN_INI_AllocFieldInternal(DN_INIStr8 key, DN_INIArena *arena DN_INIField *DN_INI_AppendKeyBool(DN_INICore *ini, DN_INIArena *arena, DN_INISection *section, DN_INIStr8 key, bool value) { DN_INIField *result = 0; - size_t mem_req = sizeof(*result) + key.size + sizeof(value); + size_t mem_req = sizeof(*result) + key.count + sizeof(value); ini->memory_required += mem_req; if (arena && arena->used + mem_req <= arena->max) { result = DN_INI_AllocFieldInternal(key, arena); result->value_bool = value; result->value_type = DN_INIFieldType_Bool; - DN_INI_Memcpy(result->key.data, key.data, key.size); + DN_INI_Memcpy(result->key.data, key.data, key.count); DN_INI_AppendValue(section, result); } return result; @@ -802,13 +802,13 @@ DN_INIField *DN_INI_AppendKeyPtrBool(DN_INICore *ini, DN_INIArena *arena, DN_INI DN_INIField *DN_INI_AppendKeyUSize(DN_INICore *ini, DN_INIArena *arena, DN_INISection *section, DN_INIStr8 key, size_t value) { DN_INIField *result = 0; - size_t mem_req = sizeof(*result) + key.size + sizeof(value); + size_t mem_req = sizeof(*result) + key.count + sizeof(value); ini->memory_required += mem_req; if (arena && arena->used + mem_req <= arena->max) { result = DN_INI_AllocFieldInternal(key, arena); result->value_usize = value; result->value_type = DN_INIFieldType_USize; - DN_INI_Memcpy(result->key.data, key.data, key.size); + DN_INI_Memcpy(result->key.data, key.data, key.count); DN_INI_AppendValue(section, result); } return result; @@ -824,12 +824,12 @@ DN_INIField *DN_INI_AppendKeyPtrUSize(DN_INICore *ini, DN_INIArena *arena, DN_IN DN_INIField *DN_INI_AppendKeyCStr8(DN_INICore *ini, DN_INIArena *arena, DN_INISection *section, DN_INIStr8 key, char const *value, size_t value_size) { DN_INIField *result = 0; - size_t mem_req = sizeof(*result) + (key.size + 1) + value_size; + size_t mem_req = sizeof(*result) + (key.count + 1) + value_size; ini->memory_required += mem_req; if (arena && arena->used + mem_req <= arena->max) { result = DN_INI_AllocFieldInternal(key, arena); result->value.data = (char *)DN_INI_ArenaAlloc(arena, value_size); - result->value.size = value_size; + result->value.count = value_size; result->value_type = DN_INIFieldType_String; DN_INI_Memcpy(result->value.data, value, value_size); DN_INI_AppendValue(section, result); @@ -846,14 +846,14 @@ DN_INIField *DN_INI_AppendKeyF(DN_INICore *ini, DN_INIArena *arena, DN_INISectio va_end(args); DN_INIField *result = 0; - size_t mem_req = sizeof(*result) + (key.size + 1) + (size_req + 1); + size_t mem_req = sizeof(*result) + (key.count + 1) + (size_req + 1); ini->memory_required += mem_req; if (arena && arena->used + mem_req <= arena->max) { result = DN_INI_AllocFieldInternal(key, arena); result->value.data = (char *)DN_INI_ArenaAlloc(arena, size_req + 1); - result->value.size = size_req; - vsnprintf(result->value.data, result->value.size + 1, fmt, args_copy); - result->value.data[result->value.size] = 0; + result->value.count = size_req; + vsnprintf(result->value.data, result->value.count + 1, fmt, args_copy); + result->value.data[result->value.count] = 0; DN_INI_AppendValue(section, result); } va_end(args_copy); diff --git a/Source/Standalone/dn_ini.h b/Source/Standalone/dn_ini.h index 3a82ca4..c8758fe 100644 --- a/Source/Standalone/dn_ini.h +++ b/Source/Standalone/dn_ini.h @@ -48,13 +48,13 @@ // NOTE: Calculate the number of bytes required to parse the buffer and make one single // allocation - DN_INICore ini = DN_INI_ParseFromPtr(ini_buffer.data, ini_buffer.size, NULL, 0); + DN_INICore ini = DN_INI_ParseFromPtr(ini_buffer.data, ini_buffer.count, NULL, 0); size_t parse_buffer_size = ini.memory_required; char* parse_buffer = calloc(1, parse_buffer_size); // NOTE: Parse the buffer into the `ini` object from the single allocation. No additional // allocations are made - ini = DN_INI_ParseFromPtr(ini_buffer.data, ini_buffer.size, parse_buffer, parse_buffer_size); + ini = DN_INI_ParseFromPtr(ini_buffer.data, ini_buffer.count, parse_buffer, parse_buffer_size); // NOTE: Process the ini file // The .INI file parsed into a tree, resembling @@ -75,7 +75,7 @@ printf("My Section Foo XYZ: %zu fields\n", my_section_foo_xyz->fields_count); for (DN_INIField *field = my_section_foo->first_field; field; field = field->next) - printf(" %.*s: %.*s\n", (int)field->key.size, field->key.data, (int)field->value.size, field->value.data); + printf(" %.*s: %.*s\n", (int)field->key.count, field->key.data, (int)field->value.count, field->value.data); // Alternatively you can access the section directly by specifying the fully qualified path from // the section, e.g.: @@ -87,7 +87,7 @@ // You may also lookup the field directly by specifying the fully qualified path DN_INIField *my_section_item = DN_INI_FieldFromSectionStr8(&ini.first_section, DN_INIStr8Lit("my_section.item")); if (my_section_item) - printf(" %.*s: %.*s\n", (int)my_section_item->key.size, my_section_item->key.data, (int)my_section_item->value.size, my_section_item->value.data); + printf(" %.*s: %.*s\n", (int)my_section_item->key.count, my_section_item->key.data, (int)my_section_item->value.count, my_section_item->value.data); // NOTE: Release memory, `ini` and its contents are invalidated and should not be used free(parse_buffer); @@ -137,7 +137,7 @@ typedef enum DN_INITokenType { typedef struct DN_INIStr8 { char *data; - size_t size; + size_t count; } DN_INIStr8; #if defined(__cplusplus) diff --git a/Source/dn.cpp b/Source/dn.cpp index bc9156d..2bd10a2 100644 --- a/Source/dn.cpp +++ b/Source/dn.cpp @@ -1,5 +1,3 @@ -#define DN_BASE_CPP - #if defined(_CLANGD) #define DN_ARENA_TEMP_MEM_UAF_GUARD 1 #define DN_WITH_OS 1 @@ -180,7 +178,7 @@ DN_API void DN_Init(DN_Core *dn, DN_InitFlags flags, DN_TCInitArgs args) DN_USize longest_feature_name = 0; for (DN_ForIndexU(feature_index, DN_CPUFeature_Count)) { DN_CPUFeatureDecl feature_decl = g_dn_cpu_feature_decl[feature_index]; - longest_feature_name = DN_Max(longest_feature_name, feature_decl.label.size); + longest_feature_name = DN_Max(longest_feature_name, feature_decl.label.count); } for (DN_ForIndexU(feature_index, DN_CPUFeature_Count)) { @@ -192,7 +190,7 @@ DN_API void DN_Init(DN_Core *dn, DN_InitFlags flags, DN_TCInitArgs args) DN_Str8Lit("..."), " %.*s:%*s%s\n", DN_Str8PrintFmt(feature_decl.label), - DN_Cast(int)(longest_feature_name - feature_decl.label.size), + DN_Cast(int)(longest_feature_name - feature_decl.label.count), "", has_feature ? "available" : "not available"); } @@ -269,23 +267,23 @@ DN_API bool DN_VerifyArgs(DN_VerifyType type, bool expr, DN_CallSite call_site, return result; } -DN_API bool DN_MemStartsWith(void const *lhs, DN_USize lhs_size, void const *rhs, DN_USize rhs_size) +DN_API bool DN_MemStartsWith(void const *lhs, DN_USize lhs_count, void const *rhs, DN_USize rhs_count) { bool result = false; - if (lhs_size >= rhs_size) - result = DN_MemEqUnsafe(lhs, rhs, rhs_size); + if (lhs_count >= rhs_count) + result = DN_MemEqUnsafe(lhs, rhs, rhs_count); return result; } -DN_API bool DN_MemEq(void const *lhs, DN_USize lhs_size, void const *rhs, DN_USize rhs_size) +DN_API bool DN_MemEq(void const *lhs, DN_USize lhs_count, void const *rhs, DN_USize rhs_count) { - bool result = lhs_size == rhs_size && DN_Memcmp(lhs, rhs, rhs_size) == 0; + bool result = lhs_count == rhs_count && DN_Memcmp(lhs, rhs, rhs_count) == 0; return result; } -DN_API bool DN_MemEqUnsafe(void const *lhs, void const *rhs, DN_USize size) +DN_API bool DN_MemEqUnsafe(void const *lhs, void const *rhs, DN_USize count) { - bool result = DN_Memcmp(lhs, rhs, size) == 0; + bool result = DN_Memcmp(lhs, rhs, count) == 0; return result; } @@ -1162,10 +1160,10 @@ DN_API DN_MemStats DN_MemStatsSum(DN_MemStats lhs, DN_MemStats rhs) return result; } -DN_API DN_MemStats DN_MemStatsSumArray(DN_MemStats const *array, DN_USize size) +DN_API DN_MemStats DN_MemStatsSumArray(DN_MemStats const *array, DN_USize count) { DN_MemStats result = {}; - for (DN_ForItSize(it, DN_MemStats const, array, size)) { + for (DN_ForItSize(it, DN_MemStats const, array, count)) { DN_MemStats stats = *it.data; result.info.used += stats.info.used; result.info.commit += stats.info.commit; @@ -1908,7 +1906,7 @@ static void DN_ErrSinkAddMsgToStr8Builder_(DN_Str8Builder *builder, DN_ErrSinkMs DN_Str8PrintFmt(file_name), it->call_site.line, DN_Str8PrintFmt(it->call_site.function), - it->msg.size ? " " : "", + it->msg.count ? " " : "", DN_Str8PrintFmt(it->msg)); } } @@ -1954,7 +1952,7 @@ DN_API bool DN_ErrSinkEndLogError_(DN_ErrSink *err, DN_CallSite call_site, DN_St // NOTE: Build the error string DN_Str8Builder builder = DN_Str8BuilderFromArena(err->arena); { - if (err_msg.size) { + if (err_msg.count) { DN_Str8BuilderAppendRef(&builder, err_msg); DN_Str8BuilderAppendRef(&builder, DN_Str8Lit(":")); } else { @@ -2319,14 +2317,14 @@ DN_API DN_U64FromResult DN_U64FromStr8(DN_Str8 string, char separator) { // NOTE: Argument check DN_U64FromResult result = {}; - if (string.size == 0) { + if (string.count == 0) { result.success = true; return result; } // NOTE: Sanitize input/output DN_Str8 trim_string = DN_Str8TrimWhitespaceAround(string); - if (trim_string.size == 0) { + if (trim_string.count == 0) { result.success = true; return result; } @@ -2340,7 +2338,7 @@ DN_API DN_U64FromResult DN_U64FromStr8(DN_Str8 string, char separator) } // NOTE: Convert the string number to the binary number - for (DN_USize index = start_index; index < trim_string.size; index++) { + for (DN_USize index = start_index; index < trim_string.count; index++) { char ch = trim_string.data[index]; if (index) { if (separator != 0 && ch == separator) @@ -2407,13 +2405,13 @@ DN_API DN_U64 DN_U64FromHexPtrUnsafe(void const *hex, DN_USize hex_count) DN_API DN_U64FromResult DN_U64FromHexStr8(DN_Str8 hex) { - DN_U64FromResult result = DN_U64FromHexPtr(hex.data, hex.size); + DN_U64FromResult result = DN_U64FromHexPtr(hex.data, hex.count); return result; } DN_API DN_U64 DN_U64FromHexStr8Unsafe(DN_Str8 hex) { - DN_U64 result = DN_U64FromHexPtrUnsafe(hex.data, hex.size); + DN_U64 result = DN_U64FromHexPtrUnsafe(hex.data, hex.count); return result; } @@ -2476,14 +2474,14 @@ DN_API DN_I64FromResult DN_I64FromStr8(DN_Str8 string, char separator) { // NOTE: Argument check DN_I64FromResult result = {}; - if (string.size == 0) { + if (string.count == 0) { result.success = true; return result; } // NOTE: Sanitize input/output DN_Str8 trim_string = DN_Str8TrimWhitespaceAround(string); - if (trim_string.size == 0) { + if (trim_string.count == 0) { result.success = true; return result; } @@ -2498,7 +2496,7 @@ DN_API DN_I64FromResult DN_I64FromStr8(DN_Str8 string, char separator) } // NOTE: Convert the string number to the binary number - for (DN_USize index = start_index; index < trim_string.size; index++) { + for (DN_USize index = start_index; index < trim_string.count; index++) { char ch = trim_string.data[index]; if (index) { if (separator != 0 && ch == separator) @@ -2541,11 +2539,11 @@ DN_API bool DN_U8x32Eq(DN_U8x32 const *lhs, DN_U8x32 const *rhs) return result; } -DN_API DN_U8x32 DN_U8x32FromBytesLeftPadZ(DN_U8 const *ptr, DN_USize count) +DN_API DN_U8x32 DN_U8x32FromBytesLeftPadZ(DN_U8 const *ptr, DN_USize size) { DN_U8x32 result = {}; - DN_Assert(count <= sizeof(result.data)); - DN_Memcpy(result.data + sizeof(result.data) - count, ptr, count); + DN_Assert(size <= sizeof(result.data)); + DN_Memcpy(result.data + sizeof(result.data) - size, ptr, size); return result; } @@ -2553,15 +2551,15 @@ DN_API DN_U8x32 DN_U8x32FromHexUnsafe(DN_Str8 hex_32b) { DN_U8x32 result = {}; hex_32b = DN_Str8TrimHexPrefix(hex_32b); - DN_Assert(hex_32b.size <= sizeof(result.data) * 2); - DN_BytesFromHexPtr(hex_32b.data, hex_32b.size, result.data, sizeof(result.data)); + DN_Assert(hex_32b.count <= sizeof(result.data) * 2); + DN_BytesFromHexPtr(hex_32b.data, hex_32b.count, result.data, sizeof(result.data)); return result; } DN_API DN_U8x32FromResult DN_U8x32FromHex(DN_Str8 hex_32b) { DN_U8x32FromResult result = {}; - DN_USize bytes_written = DN_BytesFromHexPtr(hex_32b.data, hex_32b.size, result.value.data, sizeof(result.value.data)); + DN_USize bytes_written = DN_BytesFromHexPtr(hex_32b.data, hex_32b.count, result.value.data, sizeof(result.value.data)); if (bytes_written == sizeof(result.value.data)) result.success = true; return result; @@ -2571,7 +2569,7 @@ DN_API DN_U8x32FromResult DN_U8x32FromDecimalStr8(DN_Str8 decimal) { DN_U8x32FromResult result = {}; result.success = true; - for (DN_USize i = 0; i < decimal.size; i++) { + for (DN_USize i = 0; i < decimal.count; i++) { DN_U8 digit = decimal.data[i]; if (!DN_CharIsDigit(digit)) { result.success = false; @@ -2648,7 +2646,7 @@ DN_API DN_FmtAppendResult DN_FmtVAppend(char *buf, DN_USize *buf_size, DN_USize *buf_size = buf_max - 1; DN_Assert(*buf_size <= (buf_max - 1)); result.str8 = DN_Str8FromPtr(buf, *buf_size); - result.truncated = result.str8.size != (starting_size + result.size_req); + result.truncated = result.str8.count != (starting_size + result.size_req); return result; } @@ -2667,12 +2665,12 @@ DN_API DN_FmtAppendResult DN_FmtAppendTruncate(char *buf, DN_USize *buf_size, DN va_start(args, fmt); DN_FmtAppendResult result = DN_FmtVAppend(buf, buf_size, buf_max, fmt, args); if (result.truncated) - DN_Memcpy(result.str8.data + result.str8.size - truncator.size, truncator.data, truncator.size); + DN_Memcpy(result.str8.data + result.str8.count - truncator.count, truncator.data, truncator.count); va_end(args); return result; } -DN_API DN_USize DN_FmtSize(DN_FMT_ATTRIB char const *fmt, ...) +DN_API DN_USize DN_FmtCount(DN_FMT_ATTRIB char const *fmt, ...) { va_list args; va_start(args, fmt); @@ -2681,7 +2679,7 @@ DN_API DN_USize DN_FmtSize(DN_FMT_ATTRIB char const *fmt, ...) return result; } -DN_API DN_USize DN_FmtVSize(DN_FMT_ATTRIB char const *fmt, va_list args) +DN_API DN_USize DN_FmtVCount(DN_FMT_ATTRIB char const *fmt, va_list args) { va_list args_copy; va_copy(args_copy, args); @@ -2690,7 +2688,7 @@ DN_API DN_USize DN_FmtVSize(DN_FMT_ATTRIB char const *fmt, va_list args) return result; } -DN_API DN_USize DN_CStr8Size(char const *src) +DN_API DN_USize DN_CStr8Count(char const *src) { DN_USize result = 0; for (; src && src[0] != 0; src++, result++) @@ -2698,7 +2696,7 @@ DN_API DN_USize DN_CStr8Size(char const *src) return result; } -DN_API DN_USize DN_CStr16Size(wchar_t const *src) +DN_API DN_USize DN_CStr16Count(wchar_t const *src) { DN_USize result = 0; for (; src && src[0] != 0; src++, result++) @@ -2706,33 +2704,33 @@ DN_API DN_USize DN_CStr16Size(wchar_t const *src) return result; } -DN_API DN_Str8 DN_Str8AllocAllocator(DN_USize size, DN_ZMem z_mem, DN_Allocator allocator) +DN_API DN_Str8 DN_Str8AllocAllocator(DN_USize count, DN_ZMem z_mem, DN_Allocator allocator) { DN_Str8 result = {}; - result.data = DN_Cast(char *) DN_AllocatorAlloc(allocator, size + 1, alignof(char), z_mem); + result.data = DN_Cast(char *) DN_AllocatorAlloc(allocator, count + 1, alignof(char), z_mem); if (result.data) { - result.size = size; - result.data[result.size] = 0; + result.count = count; + result.data[result.count] = 0; } return result; } -DN_API DN_Str8 DN_Str8AllocArena(DN_USize size, DN_ZMem z_mem, DN_Arena *arena) +DN_API DN_Str8 DN_Str8AllocArena(DN_USize count, DN_ZMem z_mem, DN_Arena *arena) { - DN_Str8 result = DN_Str8AllocAllocator(size, z_mem, DN_AllocatorFromArena(arena)); + DN_Str8 result = DN_Str8AllocAllocator(count, z_mem, DN_AllocatorFromArena(arena)); return result; } -DN_API DN_Str8 DN_Str8AllocPool(DN_USize size, DN_Pool *pool) +DN_API DN_Str8 DN_Str8AllocPool(DN_USize count, DN_Pool *pool) { - DN_Str8 result = DN_Str8AllocAllocator(size, DN_ZMem_No, DN_AllocatorFromPool(pool)); + DN_Str8 result = DN_Str8AllocAllocator(count, DN_ZMem_No, DN_AllocatorFromPool(pool)); return result; } DN_API DN_Str8 DN_Str8FromCStr8(char const *src) { - DN_USize size = DN_CStr8Size(src); - DN_Str8 result = DN_Str8FromPtr(src, size); + DN_USize count = DN_CStr8Count(src); + DN_Str8 result = DN_Str8FromPtr(src, count); return result; } @@ -2743,30 +2741,30 @@ DN_API DN_Str8 DN_Str8FromCStr8Arena(char const *src, DN_Arena *arena) return result; } -DN_API DN_Str8 DN_Str8FromPtrArena(void const *data, DN_USize size, DN_Arena *arena) +DN_API DN_Str8 DN_Str8FromPtrArena(void const *data, DN_USize count, DN_Arena *arena) { - DN_Str8 result = DN_Str8AllocArena(size, DN_ZMem_No, arena); - if (result.size) - DN_Memcpy(result.data, data, size); + DN_Str8 result = DN_Str8AllocArena(count, DN_ZMem_No, arena); + if (result.count) + DN_Memcpy(result.data, data, count); return result; } -DN_API DN_Str8 DN_Str8FromPtrPool(void const *data, DN_USize size, DN_Pool *pool) +DN_API DN_Str8 DN_Str8FromPtrPool(void const *data, DN_USize count, DN_Pool *pool) { - DN_Str8 result = DN_Str8AllocPool(size, pool); - if (result.size) - DN_Memcpy(result.data, data, size); + DN_Str8 result = DN_Str8AllocPool(count, pool); + if (result.count) + DN_Memcpy(result.data, data, count); return result; } DN_API DN_Str8 DN_Str8FromStr8Allocator(DN_Str8 string, DN_Allocator allocator) { DN_Str8 result = {}; - result.data = DN_Cast(char *) DN_AllocatorAlloc(allocator, string.size + 1, alignof(char), DN_ZMem_No); + result.data = DN_Cast(char *) DN_AllocatorAlloc(allocator, string.count + 1, alignof(char), DN_ZMem_No); if (result.data) { - DN_Memcpy(result.data, string.data, string.size); - result.data[string.size] = 0; - result.size = string.size; + DN_Memcpy(result.data, string.data, string.count); + result.data[string.count] = 0; + result.count = string.count; } return result; } @@ -2785,12 +2783,12 @@ DN_API DN_Str8 DN_Str8FromStr8Pool(DN_Str8 string, DN_Pool *pool) DN_API DN_Str8 DN_Str8FromFmtVAllocator(DN_Allocator allocator, DN_FMT_ATTRIB char const *fmt, va_list args) { - DN_USize size = DN_FmtVSize(fmt, args); - DN_Str8 result = DN_Str8AllocAllocator(size, DN_ZMem_No, allocator); + DN_USize count = DN_FmtVCount(fmt, args); + DN_Str8 result = DN_Str8AllocAllocator(count, DN_ZMem_No, allocator); if (result.data) { DN_USize written = 0; - DN_FmtVAppend(result.data, &written, result.size + 1, fmt, args); - DN_Assert(written == result.size); + DN_FmtVAppend(result.data, &written, result.count + 1, fmt, args); + DN_Assert(written == result.count); } return result; } @@ -2839,7 +2837,7 @@ DN_API DN_Str8x16 DN_Str8x16FromFmt(DN_FMT_ATTRIB char const *fmt, ...) va_list args; va_start(args, fmt); DN_Str8x16 result = {}; - DN_FmtVAppend(result.data, &result.size, sizeof(result.data), fmt, args); + DN_FmtVAppend(result.data, &result.count, sizeof(result.data), fmt, args); va_end(args); return result; } @@ -2847,7 +2845,7 @@ DN_API DN_Str8x16 DN_Str8x16FromFmt(DN_FMT_ATTRIB char const *fmt, ...) DN_API DN_Str8x16 DN_Str8x16FromFmtVArena(DN_FMT_ATTRIB char const *fmt, va_list args) { DN_Str8x16 result = {}; - DN_FmtVAppend(result.data, &result.size, sizeof(result.data), fmt, args); + DN_FmtVAppend(result.data, &result.count, sizeof(result.data), fmt, args); return result; } @@ -2856,7 +2854,7 @@ DN_API DN_Str8x32 DN_Str8x32FromFmt(DN_FMT_ATTRIB char const *fmt, ...) va_list args; va_start(args, fmt); DN_Str8x32 result = {}; - DN_FmtVAppend(result.data, &result.size, sizeof(result.data), fmt, args); + DN_FmtVAppend(result.data, &result.count, sizeof(result.data), fmt, args); va_end(args); return result; } @@ -2864,7 +2862,7 @@ DN_API DN_Str8x32 DN_Str8x32FromFmt(DN_FMT_ATTRIB char const *fmt, ...) DN_API DN_Str8x32 DN_Str8x32FromFmtVArena(DN_FMT_ATTRIB char const *fmt, va_list args) { DN_Str8x32 result = {}; - DN_FmtVAppend(result.data, &result.size, sizeof(result.data), fmt, args); + DN_FmtVAppend(result.data, &result.count, sizeof(result.data), fmt, args); return result; } @@ -2873,7 +2871,7 @@ DN_API DN_Str8x64 DN_Str8x64FromFmt(DN_FMT_ATTRIB char const *fmt, ...) va_list args; va_start(args, fmt); DN_Str8x64 result = {}; - DN_FmtVAppend(result.data, &result.size, sizeof(result.data), fmt, args); + DN_FmtVAppend(result.data, &result.count, sizeof(result.data), fmt, args); va_end(args); return result; } @@ -2881,7 +2879,7 @@ DN_API DN_Str8x64 DN_Str8x64FromFmt(DN_FMT_ATTRIB char const *fmt, ...) DN_API DN_Str8x64 DN_Str8x64FromFmtV(DN_FMT_ATTRIB char const *fmt, va_list args) { DN_Str8x64 result = {}; - DN_FmtVAppend(result.data, &result.size, sizeof(result.data), fmt, args); + DN_FmtVAppend(result.data, &result.count, sizeof(result.data), fmt, args); return result; } @@ -2890,7 +2888,7 @@ DN_API DN_Str8x128 DN_Str8x128FromFmt(DN_FMT_ATTRIB char const *fmt, ...) va_list args; va_start(args, fmt); DN_Str8x128 result = {}; - DN_FmtVAppend(result.data, &result.size, sizeof(result.data), fmt, args); + DN_FmtVAppend(result.data, &result.count, sizeof(result.data), fmt, args); va_end(args); return result; } @@ -2898,7 +2896,7 @@ DN_API DN_Str8x128 DN_Str8x128FromFmt(DN_FMT_ATTRIB char const *fmt, ...) DN_API DN_Str8x128 DN_Str8x128FromFmtVArena(DN_FMT_ATTRIB char const *fmt, va_list args) { DN_Str8x128 result = {}; - DN_FmtVAppend(result.data, &result.size, sizeof(result.data), fmt, args); + DN_FmtVAppend(result.data, &result.count, sizeof(result.data), fmt, args); return result; } @@ -2907,7 +2905,7 @@ DN_API DN_Str8x256 DN_Str8x256FromFmt(DN_FMT_ATTRIB char const *fmt, ...) va_list args; va_start(args, fmt); DN_Str8x256 result = {}; - DN_FmtVAppend(result.data, &result.size, sizeof(result.data), fmt, args); + DN_FmtVAppend(result.data, &result.count, sizeof(result.data), fmt, args); va_end(args); return result; } @@ -2915,7 +2913,7 @@ DN_API DN_Str8x256 DN_Str8x256FromFmt(DN_FMT_ATTRIB char const *fmt, ...) DN_API DN_Str8x256 DN_Str8x256FromFmtVArena(DN_FMT_ATTRIB char const *fmt, va_list args) { DN_Str8x256 result = {}; - DN_FmtVAppend(result.data, &result.size, sizeof(result.data), fmt, args); + DN_FmtVAppend(result.data, &result.count, sizeof(result.data), fmt, args); return result; } @@ -2924,7 +2922,7 @@ DN_API DN_Str8x512 DN_Str8x512FromFmt(DN_FMT_ATTRIB char const *fmt, ...) va_list args; va_start(args, fmt); DN_Str8x512 result = {}; - DN_FmtVAppend(result.data, &result.size, sizeof(result.data), fmt, args); + DN_FmtVAppend(result.data, &result.count, sizeof(result.data), fmt, args); va_end(args); return result; } @@ -2932,7 +2930,7 @@ DN_API DN_Str8x512 DN_Str8x512FromFmt(DN_FMT_ATTRIB char const *fmt, ...) DN_API DN_Str8x512 DN_Str8x512FromFmtVArena(DN_FMT_ATTRIB char const *fmt, va_list args) { DN_Str8x512 result = {}; - DN_FmtVAppend(result.data, &result.size, sizeof(result.data), fmt, args); + DN_FmtVAppend(result.data, &result.count, sizeof(result.data), fmt, args); return result; } @@ -2941,7 +2939,7 @@ DN_API DN_Str8x1024 DN_Str8x1024FromFmt(DN_FMT_ATTRIB char const *fmt, ...) va_list args; va_start(args, fmt); DN_Str8x1024 result = {}; - DN_FmtVAppend(result.data, &result.size, sizeof(result.data), fmt, args); + DN_FmtVAppend(result.data, &result.count, sizeof(result.data), fmt, args); va_end(args); return result; } @@ -2949,7 +2947,7 @@ DN_API DN_Str8x1024 DN_Str8x1024FromFmt(DN_FMT_ATTRIB char const *fmt, ...) DN_API DN_Str8x1024 DN_Str8x1024FromFmtVArena(DN_FMT_ATTRIB char const *fmt, va_list args) { DN_Str8x1024 result = {}; - DN_FmtVAppend(result.data, &result.size, sizeof(result.data), fmt, args); + DN_FmtVAppend(result.data, &result.count, sizeof(result.data), fmt, args); return result; } @@ -2963,7 +2961,7 @@ DN_API void DN_Str8x16AppendFmt(DN_Str8x16 *str, DN_FMT_ATTRIB char const *fmt, DN_API void DN_Str8x16AppendFmtV(DN_Str8x16 *str, DN_FMT_ATTRIB char const *fmt, va_list args) { - DN_FmtVAppend(str->data, &str->size, sizeof(str->data), fmt, args); + DN_FmtVAppend(str->data, &str->count, sizeof(str->data), fmt, args); } DN_API void DN_Str8x32AppendFmt(DN_Str8x32 *str, DN_FMT_ATTRIB char const *fmt, ...) @@ -2976,7 +2974,7 @@ DN_API void DN_Str8x32AppendFmt(DN_Str8x32 *str, DN_FMT_ATTRIB char const *fmt, DN_API void DN_Str8x32AppendFmtV(DN_Str8x32 *str, DN_FMT_ATTRIB char const *fmt, va_list args) { - DN_FmtVAppend(str->data, &str->size, sizeof(str->data), fmt, args); + DN_FmtVAppend(str->data, &str->count, sizeof(str->data), fmt, args); } DN_API void DN_Str8x64AppendFmt(DN_Str8x64 *str, DN_FMT_ATTRIB char const *fmt, ...) @@ -2989,7 +2987,7 @@ DN_API void DN_Str8x64AppendFmt(DN_Str8x64 *str, DN_FMT_ATTRIB char const *fmt, DN_API void DN_Str8x64AppendFmtV(DN_Str8x64 *str, DN_FMT_ATTRIB char const *fmt, va_list args) { - DN_FmtVAppend(str->data, &str->size, sizeof(str->data), fmt, args); + DN_FmtVAppend(str->data, &str->count, sizeof(str->data), fmt, args); } DN_API void DN_Str8x128AppendFmt(DN_Str8x128 *str, DN_FMT_ATTRIB char const *fmt, ...) @@ -3002,7 +3000,7 @@ DN_API void DN_Str8x128AppendFmt(DN_Str8x128 *str, DN_FMT_ATTRIB char const *fmt DN_API void DN_Str8x128AppendFmtV(DN_Str8x128 *str, DN_FMT_ATTRIB char const *fmt, va_list args) { - DN_FmtVAppend(str->data, &str->size, sizeof(str->data), fmt, args); + DN_FmtVAppend(str->data, &str->count, sizeof(str->data), fmt, args); } DN_API void DN_Str8x256AppendFmt(DN_Str8x256 *str, DN_FMT_ATTRIB char const *fmt, ...) @@ -3015,7 +3013,7 @@ DN_API void DN_Str8x256AppendFmt(DN_Str8x256 *str, DN_FMT_ATTRIB char const *fmt DN_API void DN_Str8x256AppendFmtV(DN_Str8x256 *str, DN_FMT_ATTRIB char const *fmt, va_list args) { - DN_FmtVAppend(str->data, &str->size, sizeof(str->data), fmt, args); + DN_FmtVAppend(str->data, &str->count, sizeof(str->data), fmt, args); } DN_API void DN_Str8x512AppendFmt(DN_Str8x512 *str, DN_FMT_ATTRIB char const *fmt, ...) @@ -3028,7 +3026,7 @@ DN_API void DN_Str8x512AppendFmt(DN_Str8x512 *str, DN_FMT_ATTRIB char const *fmt DN_API void DN_Str8x512AppendFmtV(DN_Str8x512 *str, DN_FMT_ATTRIB char const *fmt, va_list args) { - DN_FmtVAppend(str->data, &str->size, sizeof(str->data), fmt, args); + DN_FmtVAppend(str->data, &str->count, sizeof(str->data), fmt, args); } DN_API void DN_Str8x1024AppendFmt(DN_Str8x1024 *str, DN_FMT_ATTRIB char const *fmt, ...) @@ -3041,7 +3039,7 @@ DN_API void DN_Str8x1024AppendFmt(DN_Str8x1024 *str, DN_FMT_ATTRIB char const *f DN_API void DN_Str8x1024AppendFmtV(DN_Str8x1024 *str, DN_FMT_ATTRIB char const *fmt, va_list args) { - DN_FmtVAppend(str->data, &str->size, sizeof(str->data), fmt, args); + DN_FmtVAppend(str->data, &str->count, sizeof(str->data), fmt, args); } DN_API DN_Str8x32 DN_Str8x32FromU64(DN_U64 val, char separator) @@ -3051,16 +3049,16 @@ DN_API DN_Str8x32 DN_Str8x32FromU64(DN_U64 val, char separator) DN_USize temp_index = 0; // NOTE: Write the digits the first, up to [0, 2] digits that do not need a thousandth separator - DN_USize range_without_separator = temp.size % 3; + DN_USize range_without_separator = temp.count % 3; for (; temp_index < range_without_separator; temp_index++) - result.data[result.size++] = temp.data[temp_index]; + result.data[result.count++] = temp.data[temp_index]; // NOTE: Write the subsequent digits and every 3rd digit, add the seperator DN_USize digit_counter = 0; - for (; temp_index < temp.size; temp_index++, digit_counter++) { + for (; temp_index < temp.count; temp_index++, digit_counter++) { if (separator && temp_index && (digit_counter % 3 == 0)) - result.data[result.size++] = separator; - result.data[result.size++] = temp.data[temp_index]; + result.data[result.count++] = separator; + result.data[result.count++] = temp.data[temp_index]; } return result; } @@ -3068,19 +3066,19 @@ DN_API DN_Str8x32 DN_Str8x32FromU64(DN_U64 val, char separator) DN_API bool DN_Str8IsAll(DN_Str8 string, DN_Str8IsAllType is_all) { - bool result = string.size; + bool result = string.count; if (!result) return result; switch (is_all) { case DN_Str8IsAllType_Digits: { - for (DN_USize index = 0; result && index < string.size; index++) + for (DN_USize index = 0; result && index < string.count; index++) result = string.data[index] >= '0' && string.data[index] <= '9'; } break; case DN_Str8IsAllType_Hex: { DN_Str8 trimmed = DN_Str8TrimPrefix(string, DN_Str8Lit("0x"), DN_Str8EqCase_Insensitive); - for (DN_USize index = 0; result && index < trimmed.size; index++) { + for (DN_USize index = 0; result && index < trimmed.count; index++) { char ch = trimmed.data[index]; result = (ch >= '0' && ch <= '9') || (ch >= 'a' && ch <= 'f') || (ch >= 'A' && ch <= 'F'); } @@ -3092,19 +3090,19 @@ DN_API bool DN_Str8IsAll(DN_Str8 string, DN_Str8IsAllType is_all) DN_API char *DN_Str8End(DN_Str8 string) { - char *result = string.data + string.size; + char *result = string.data + string.count; return result; } -DN_API DN_Str8 DN_Str8Subset(DN_Str8 string, DN_USize offset, DN_USize size) +DN_API DN_Str8 DN_Str8Subset(DN_Str8 string, DN_USize offset, DN_USize count) { DN_Str8 result = DN_Str8FromPtr(string.data, 0); - if (string.size == 0) + if (string.count == 0) return result; - DN_USize capped_offset = DN_Min(offset, string.size); - DN_USize max_size = string.size - capped_offset; - DN_USize capped_size = DN_Min(size, max_size); + DN_USize capped_offset = DN_Min(offset, string.count); + DN_USize max_size = string.count - capped_offset; + DN_USize capped_size = DN_Min(count, max_size); result = DN_Str8FromPtr(string.data + capped_offset, capped_size); return result; } @@ -3124,19 +3122,19 @@ DN_API DN_Str8 DN_Str8NextLine(DN_Str8 string) DN_API DN_Str8BSplitResult DN_Str8BSplitArray(DN_Str8 string, DN_Str8 const *find, DN_USize find_size) { DN_Str8BSplitResult result = {}; - if (string.size == 0 || !find || find_size == 0) + if (string.count == 0 || !find || find_size == 0) return result; result.lhs = string; - for (DN_USize index = 0; !result.rhs.data && index < string.size; index++) { + for (DN_USize index = 0; !result.rhs.data && index < string.count; index++) { for (DN_USize find_index = 0; find_index < find_size; find_index++) { DN_Str8 find_item = find[find_index]; - DN_Str8 string_slice = DN_Str8Subset(string, index, find_item.size); + DN_Str8 string_slice = DN_Str8Subset(string, index, find_item.count); if (DN_Str8Eq(string_slice, find_item)) { result.input_index = find_index; - result.lhs.size = index; - result.rhs.data = string_slice.data + find_item.size; - result.rhs.size = string.size - (index + find_item.size); + result.lhs.count = index; + result.rhs.data = string_slice.data + find_item.count; + result.rhs.count = string.count - (index + find_item.count); break; } } @@ -3154,18 +3152,18 @@ DN_API DN_Str8BSplitResult DN_Str8BSplit(DN_Str8 string, DN_Str8 find) DN_API DN_Str8BSplitResult DN_Str8BSplitLastArray(DN_Str8 string, DN_Str8 const *find, DN_USize find_size) { DN_Str8BSplitResult result = {}; - if (string.size == 0 || !find || find_size == 0) + if (string.count == 0 || !find || find_size == 0) return result; result.lhs = string; - for (DN_USize index = string.size - 1; !result.rhs.data && index < string.size; index--) { + for (DN_USize index = string.count - 1; !result.rhs.data && index < string.count; index--) { for (DN_USize find_index = 0; find_index < find_size; find_index++) { DN_Str8 find_item = find[find_index]; - DN_Str8 string_slice = DN_Str8Subset(string, index, find_item.size); + DN_Str8 string_slice = DN_Str8Subset(string, index, find_item.count); if (DN_Str8Eq(string_slice, find_item)) { - result.lhs.size = index; - result.rhs.data = string_slice.data + find_item.size; - result.rhs.size = string.size - (index + find_item.size); + result.lhs.count = index; + result.rhs.data = string_slice.data + find_item.count; + result.rhs.count = string.count - (index + find_item.count); break; } } @@ -3183,7 +3181,7 @@ DN_API DN_Str8BSplitResult DN_Str8BSplitLast(DN_Str8 string, DN_Str8 find) DN_API DN_USize DN_Str8Split(DN_Str8 string, DN_Str8 delimiter, DN_Str8 *splits, DN_USize splits_count, DN_Str8SplitFlags flags) { DN_USize result = 0; // The number of splits in the actual string. - if (string.size == 0 || delimiter.size == 0 || delimiter.size <= 0) + if (string.count == 0 || delimiter.count == 0 || delimiter.count <= 0) return result; DN_Str8 it = string; @@ -3202,12 +3200,12 @@ DN_API DN_USize DN_Str8Split(DN_Str8 string, DN_Str8 delimiter, DN_Str8 *splits, it = sub_split.rhs; } - if (item.size || allow_empty_strings) { + if (item.count || allow_empty_strings) { if (splits && result < splits_count) splits[result] = item; result++; } - } while (it.size); + } while (it.count); return result; } @@ -3227,17 +3225,17 @@ DN_API DN_Str8SplitResult DN_Str8SplitArena(DN_Str8 string, DN_Str8 delimiter, D DN_API DN_Str8FindResult DN_Str8FindStr8Array(DN_Str8 string, DN_Str8 const *find, DN_USize find_size, DN_Str8EqCase eq_case) { DN_Str8FindResult result = {}; - for (DN_USize index = 0; !result.found && index < string.size; index++) { + for (DN_USize index = 0; !result.found && index < string.count; index++) { for (DN_USize find_index = 0; find_index < find_size; find_index++) { DN_Str8 find_item = find[find_index]; - DN_Str8 string_slice = DN_Str8Subset(string, index, find_item.size); + DN_Str8 string_slice = DN_Str8Subset(string, index, find_item.count); if (DN_Str8Eq(string_slice, find_item, eq_case)) { result.found = true; result.index = index; result.start_to_before_match = DN_Str8FromPtr(string.data, index); - result.match = DN_Str8FromPtr(string.data + index, find_item.size); - result.match_to_end_of_buffer = DN_Str8FromPtr(result.match.data, string.size - index); - result.after_match_to_end_of_buffer = DN_Str8Advance(result.match_to_end_of_buffer, find_item.size); + result.match = DN_Str8FromPtr(string.data + index, find_item.count); + result.match_to_end_of_buffer = DN_Str8FromPtr(result.match.data, string.count - index); + result.after_match_to_end_of_buffer = DN_Str8Advance(result.match_to_end_of_buffer, find_item.count); break; } } @@ -3254,7 +3252,7 @@ DN_API DN_Str8FindResult DN_Str8FindStr8(DN_Str8 string, DN_Str8 find, DN_Str8Eq DN_API DN_Str8FindResult DN_Str8Find(DN_Str8 string, DN_Str8FindFlag flags) { DN_Str8FindResult result = {}; - for (DN_USize index = 0; !result.found && index < string.size; index++) { + for (DN_USize index = 0; !result.found && index < string.count; index++) { result.found |= ((flags & DN_Str8FindFlag_Digit) && DN_CharIsDigit(string.data[index])); result.found |= ((flags & DN_Str8FindFlag_Alphabet) && DN_CharIsAlphabet(string.data[index])); result.found |= ((flags & DN_Str8FindFlag_Whitespace) && DN_CharIsWhitespace(string.data[index])); @@ -3263,7 +3261,7 @@ DN_API DN_Str8FindResult DN_Str8Find(DN_Str8 string, DN_Str8FindFlag flags) if (result.found) { result.index = index; result.match = DN_Str8FromPtr(string.data + index, 1); - result.match_to_end_of_buffer = DN_Str8FromPtr(result.match.data, string.size - index); + result.match_to_end_of_buffer = DN_Str8FromPtr(result.match.data, string.count - index); result.after_match_to_end_of_buffer = DN_Str8Advance(result.match_to_end_of_buffer, 1); } } @@ -3272,50 +3270,50 @@ DN_API DN_Str8FindResult DN_Str8Find(DN_Str8 string, DN_Str8FindFlag flags) DN_API DN_Str8 DN_Str8Segment(DN_Arena *arena, DN_Str8 src, DN_USize segment_size, char segment_char) { - if (!segment_size || src.size == 0) { + if (!segment_size || src.count == 0) { DN_Str8 result = DN_Str8FromStr8Arena(src, arena); return result; } - DN_USize segments = src.size / segment_size; - if (src.size % segment_size == 0) + DN_USize segments = src.count / segment_size; + if (src.count % segment_size == 0) segments--; DN_USize segment_counter = 0; - DN_Str8 result = DN_Str8AllocArena(src.size + segments, DN_ZMem_Yes, arena); + DN_Str8 result = DN_Str8AllocArena(src.count + segments, DN_ZMem_Yes, arena); DN_USize write_index = 0; - for (DN_ForIndexU(src_index, src.size)) { + for (DN_ForIndexU(src_index, src.count)) { result.data[write_index++] = src.data[src_index]; if ((src_index + 1) % segment_size == 0 && segment_counter < segments) { result.data[write_index++] = segment_char; segment_counter++; } - DN_AssertF(write_index <= result.size, "result.size=%zu, write_index=%zu", result.size, write_index); + DN_AssertF(write_index <= result.count, "result.count=%zu, write_index=%zu", result.count, write_index); } - DN_AssertF(write_index == result.size, "result.size=%zu, write_index=%zu", result.size, write_index); + DN_AssertF(write_index == result.count, "result.count=%zu, write_index=%zu", result.count, write_index); return result; } DN_API DN_Str8 DN_Str8ReverseSegment(DN_Arena *arena, DN_Str8 src, DN_USize segment_size, char segment_char) { - if (!segment_size || src.size == 0) { + if (!segment_size || src.count == 0) { DN_Str8 result = DN_Str8FromStr8Arena(src, arena); return result; } - DN_USize segments = src.size / segment_size; - if (src.size % segment_size == 0) + DN_USize segments = src.count / segment_size; + if (src.count % segment_size == 0) segments--; DN_USize write_counter = 0; DN_USize segment_counter = 0; - DN_Str8 result = DN_Str8AllocArena(src.size + segments, DN_ZMem_Yes, arena); - DN_USize write_index = result.size - 1; + DN_Str8 result = DN_Str8AllocArena(src.count + segments, DN_ZMem_Yes, arena); + DN_USize write_index = result.count - 1; DN_MSVC_WARNING_PUSH DN_MSVC_WARNING_DISABLE(6293) // NOTE: Ill-defined loop - for (DN_USize src_index = src.size - 1; src_index < src.size; src_index--) { + for (DN_USize src_index = src.count - 1; src_index < src.count; src_index--) { DN_MSVC_WARNING_POP result.data[write_index--] = src.data[src_index]; if (++write_counter % segment_size == 0 && segment_counter < segments) { @@ -3330,16 +3328,16 @@ DN_API DN_Str8 DN_Str8ReverseSegment(DN_Arena *arena, DN_Str8 src, DN_USize segm DN_API bool DN_Str8Eq(DN_Str8 lhs, DN_Str8 rhs, DN_Str8EqCase eq_case) { - if (lhs.size != rhs.size) + if (lhs.count != rhs.count) return false; bool result = true; switch (eq_case) { case DN_Str8EqCase_Sensitive: { - result = (DN_Memcmp(lhs.data, rhs.data, lhs.size) == 0); + result = (DN_Memcmp(lhs.data, rhs.data, lhs.count) == 0); } break; case DN_Str8EqCase_Insensitive: { - for (DN_USize index = 0; index < lhs.size && result; index++) + for (DN_USize index = 0; index < lhs.count && result; index++) result = (DN_CharToLower(lhs.data[index]) == DN_CharToLower(rhs.data[index])); } break; } @@ -3354,7 +3352,7 @@ DN_API bool DN_Str8EqInsensitive(DN_Str8 lhs, DN_Str8 rhs) DN_API bool DN_Str8StartsWith(DN_Str8 string, DN_Str8 prefix, DN_Str8EqCase eq_case) { - DN_Str8 substring = {string.data, DN_Min(prefix.size, string.size)}; + DN_Str8 substring = {string.data, DN_Min(prefix.count, string.count)}; bool result = DN_Str8Eq(substring, prefix, eq_case); return result; } @@ -3367,7 +3365,7 @@ DN_API bool DN_Str8StartsWithInsensitive(DN_Str8 string, DN_Str8 prefix) DN_API bool DN_Str8EndsWith(DN_Str8 string, DN_Str8 suffix, DN_Str8EqCase eq_case) { - DN_Str8 substring = {string.data + string.size - suffix.size, DN_Min(string.size, suffix.size)}; + DN_Str8 substring = {string.data + string.count - suffix.count, DN_Min(string.count, suffix.count)}; bool result = DN_Str8Eq(substring, suffix, eq_case); return result; } @@ -3381,7 +3379,7 @@ DN_API bool DN_Str8EndsWithInsensitive(DN_Str8 string, DN_Str8 suffix) DN_API bool DN_Str8HasChar(DN_Str8 string, char ch) { bool result = false; - for (DN_USize index = 0; !result && index < string.size; index++) + for (DN_USize index = 0; !result && index < string.count; index++) result = string.data[index] == ch; return result; } @@ -3390,8 +3388,8 @@ DN_API DN_Str8 DN_Str8TrimPrefix(DN_Str8 string, DN_Str8 prefix, DN_Str8EqCase e { DN_Str8 result = string; if (DN_Str8StartsWith(string, prefix, eq_case)) { - result.data += prefix.size; - result.size -= prefix.size; + result.data += prefix.count; + result.count -= prefix.count; } return result; } @@ -3406,7 +3404,7 @@ DN_API DN_Str8 DN_Str8TrimSuffix(DN_Str8 string, DN_Str8 suffix, DN_Str8EqCase e { DN_Str8 result = string; if (DN_Str8EndsWith(string, suffix, eq_case)) - result.size -= suffix.size; + result.count -= suffix.count; return result; } @@ -3420,11 +3418,11 @@ DN_API DN_Str8 DN_Str8TrimAround(DN_Str8 string, DN_Str8 trim_string) DN_API DN_Str8 DN_Str8TrimHeadWhitespace(DN_Str8 string) { DN_Str8 result = string; - if (string.size == 0) + if (string.count == 0) return result; char const *start = string.data; - char const *end = string.data + string.size; + char const *end = string.data + string.count; while (start < end && DN_CharIsWhitespace(start[0])) start++; @@ -3435,11 +3433,11 @@ DN_API DN_Str8 DN_Str8TrimHeadWhitespace(DN_Str8 string) DN_API DN_Str8 DN_Str8TrimTailWhitespace(DN_Str8 string) { DN_Str8 result = string; - if (string.size == 0) + if (string.count == 0) return result; char const *start = string.data; - char const *end = string.data + string.size; + char const *end = string.data + string.count; while (end > start && DN_CharIsWhitespace(end[-1])) end--; @@ -3457,7 +3455,7 @@ DN_API DN_Str8 DN_Str8TrimWhitespaceAround(DN_Str8 string) DN_API DN_Str8 DN_Str8TrimByteOrderMark(DN_Str8 string) { DN_Str8 result = string; - if (result.size == 0) + if (result.count == 0) return result; // TODO(dn): This is little endian @@ -3479,7 +3477,7 @@ DN_API DN_Str8 DN_Str8FileNameFromPath(DN_Str8 path) { DN_Str8 separators[] = {DN_Str8Lit("/"), DN_Str8Lit("\\")}; DN_Str8BSplitResult split = DN_Str8BSplitLastArray(path, separators, DN_ArrayCountU(separators)); - DN_Str8 result = split.rhs.size ? split.rhs : split.lhs; + DN_Str8 result = split.rhs.count ? split.rhs : split.lhs; return result; } @@ -3525,9 +3523,9 @@ DN_API DN_Str8 DN_Str8AppendFV(DN_Arena *arena, DN_Str8 string, char const *fmt, { // TODO: Calculate size and write into one buffer instead of 2 appends DN_Str8 append = DN_Str8FromFmtVArena(arena, fmt, args); - DN_Str8 result = DN_Str8AllocArena(string.size + append.size, DN_ZMem_No, arena); - DN_Memcpy(result.data, string.data, string.size); - DN_Memcpy(result.data + string.size, append.data, append.size); + DN_Str8 result = DN_Str8AllocArena(string.count + append.count, DN_ZMem_No, arena); + DN_Memcpy(result.data, string.data, string.count); + DN_Memcpy(result.data + string.count, append.data, append.count); return result; } @@ -3543,25 +3541,25 @@ DN_API DN_Str8 DN_Str8FillF(DN_Arena *arena, DN_USize count, char const *fmt, .. DN_API DN_Str8 DN_Str8FillFV(DN_Arena *arena, DN_USize count, char const *fmt, va_list args) { DN_Str8 fill = DN_Str8FromFmtVArena(arena, fmt, args); - DN_Str8 result = DN_Str8AllocArena(count * fill.size, DN_ZMem_No, arena); + DN_Str8 result = DN_Str8AllocArena(count * fill.count, DN_ZMem_No, arena); for (DN_USize index = 0; index < count; index++) { - void *dest = result.data + (index * fill.size); - DN_Memcpy(dest, fill.data, fill.size); + void *dest = result.data + (index * fill.count); + DN_Memcpy(dest, fill.data, fill.count); } return result; } -DN_API void DN_Str8Remove(DN_Str8 *string, DN_USize offset, DN_USize size) +DN_API void DN_Str8Remove(DN_Str8 *string, DN_USize offset, DN_USize count) { - if (!string || string->size) + if (!string || string->count) return; - char *end = string->data + string->size; + char *end = string->data + string->count; char *dest = DN_Min(string->data + offset, end); - char *src = DN_Min(string->data + offset + size, end); + char *src = DN_Min(string->data + offset + count, end); DN_USize bytes_to_move = end - src; DN_Memmove(dest, src, bytes_to_move); - string->size -= bytes_to_move; + string->count -= bytes_to_move; } DN_API DN_Str8TruncResult DN_Str8TruncMiddlePtr(DN_Str8 str8, DN_USize side_size, DN_Str8 truncator, char *dest, DN_USize dest_max) @@ -3569,34 +3567,34 @@ DN_API DN_Str8TruncResult DN_Str8TruncMiddlePtr(DN_Str8 str8, DN_USize side_size DN_Assert(side_size <= DN_USIZE_MAX / 2); if (dest) { // NOTE: If the user passes the dest buffer, we expect it to be sized correctly. - if ((side_size * 2) >= str8.size) { - DN_Assert(dest_max >= str8.size + 1 /*null*/); + if ((side_size * 2) >= str8.count) { + DN_Assert(dest_max >= str8.count + 1 /*null*/); } else { - DN_Assert(dest_max >= (2 * side_size + truncator.size) + 1 /*null*/); + DN_Assert(dest_max >= (2 * side_size + truncator.count) + 1 /*null*/); } } DN_Str8TruncResult result = {}; - if (str8.size <= (side_size * 2)) { - result.size_req = str8.size; + if (str8.count <= (side_size * 2)) { + result.count_req = str8.count; if (dest) { - DN_Memcpy(dest, str8.data, str8.size); - dest[str8.size] = 0; - result.str8 = DN_Str8FromPtr(dest, result.size_req); + DN_Memcpy(dest, str8.data, str8.count); + dest[str8.count] = 0; + result.str8 = DN_Str8FromPtr(dest, result.count_req); } return result; } DN_Str8 head = DN_Str8Subset(str8, 0, side_size); - DN_Str8 tail = DN_Str8Subset(str8, str8.size - side_size, side_size); + DN_Str8 tail = DN_Str8Subset(str8, str8.count - side_size, side_size); DN_USize dest_size = 0; if (dest) { DN_FmtAppendResult append_result = DN_FmtAppend(dest, &dest_size, dest_max, "%.*s%.*s%.*s", DN_Str8PrintFmt(head), DN_Str8PrintFmt(truncator), DN_Str8PrintFmt(tail)); result.str8 = append_result.str8; result.truncated = true; - result.size_req = result.str8.size; + result.count_req = result.str8.count; } else { - result.size_req = DN_FmtSize("%.*s%.*s%.*s", DN_Str8PrintFmt(head), DN_Str8PrintFmt(truncator), DN_Str8PrintFmt(tail)); + result.count_req = DN_FmtCount("%.*s%.*s%.*s", DN_Str8PrintFmt(head), DN_Str8PrintFmt(truncator), DN_Str8PrintFmt(tail)); result.truncated = true; } @@ -3606,15 +3604,15 @@ DN_API DN_Str8TruncResult DN_Str8TruncMiddlePtr(DN_Str8 str8, DN_USize side_size DN_API DN_Str8TruncResult DN_Str8TruncMiddle(DN_Str8 str8, DN_USize side_size, DN_Str8 truncator, DN_Arena *arena) { DN_Str8TruncResult trunc = DN_Str8TruncMiddlePtr(str8, side_size, truncator, nullptr, 0); - DN_Str8 dest = DN_Str8AllocArena(trunc.size_req, DN_ZMem_No, arena); - DN_Str8TruncResult result = DN_Str8TruncMiddlePtr(str8, side_size, truncator, dest.data, dest.size + 1); + DN_Str8 dest = DN_Str8AllocArena(trunc.count_req, DN_ZMem_No, arena); + DN_Str8TruncResult result = DN_Str8TruncMiddlePtr(str8, side_size, truncator, dest.data, dest.count + 1); return result; } DN_API DN_Str8 DN_Str8Lower(DN_Str8 string, DN_Arena *arena) { DN_Str8 result = DN_Str8FromStr8Arena(string, arena); - for (DN_ForIndexU(index, result.size)) + for (DN_ForIndexU(index, result.count)) result.data[index] = DN_CharToLower(result.data[index]); return result; } @@ -3622,7 +3620,7 @@ DN_API DN_Str8 DN_Str8Lower(DN_Str8 string, DN_Arena *arena) DN_API DN_Str8 DN_Str8Upper(DN_Str8 string, DN_Arena *arena) { DN_Str8 result = DN_Str8FromStr8Arena(string, arena); - for (DN_ForIndexU(index, result.size)) + for (DN_ForIndexU(index, result.count)) result.data[index] = DN_CharToUpper(result.data[index]); return result; } @@ -3635,18 +3633,18 @@ DN_API DN_Str8 DN_Str8Replace(DN_Str8 string, DN_Str8EqCase eq_case) { DN_Str8 result = {}; - if (string.size == 0 || find.size == 0 || find.size > string.size || find.size == 0 || string.size == 0) { + if (string.count == 0 || find.count == 0 || find.count > string.count || find.count == 0 || string.count == 0) { result = DN_Str8FromStr8Arena(string, arena); return result; } DN_TCScratch scratch = DN_TCScratchBeginArena(&arena, 1); DN_Str8Builder string_builder = DN_Str8BuilderFromArena(&scratch.arena); - DN_USize max = string.size - find.size; + DN_USize max = string.count - find.count; DN_USize head = start_index; for (DN_USize tail = head; tail <= max; tail++) { - DN_Str8 check = DN_Str8Subset(string, tail, find.size); + DN_Str8 check = DN_Str8Subset(string, tail, find.count); if (!DN_Str8Eq(check, find, eq_case)) continue; @@ -3662,15 +3660,15 @@ DN_API DN_Str8 DN_Str8Replace(DN_Str8 string, DN_Str8 range = DN_Str8Subset(string, head, (tail - head)); DN_Str8BuilderAppendRef(&string_builder, range); DN_Str8BuilderAppendRef(&string_builder, replace); - head = tail + find.size; - tail += find.size - 1; // NOTE: -1 since the for loop will post increment us past the end of the find string + head = tail + find.count; + tail += find.count - 1; // NOTE: -1 since the for loop will post increment us past the end of the find string } if (string_builder.string_size == 0) { // NOTE: No replacement possible, so we just do a full-copy result = DN_Str8FromStr8Arena(string, arena); } else { - DN_Str8 remainder = DN_Str8FromPtr(string.data + head, string.size - head); + DN_Str8 remainder = DN_Str8FromPtr(string.data + head, string.count - head); DN_Str8BuilderAppendRef(&string_builder, remainder); result = DN_Str8FromStr8BuilderArena(&string_builder, arena); } @@ -3695,9 +3693,9 @@ DN_API DN_Str8 DN_Str8PadNewLinesAllocator(DN_Str8 string, DN_Str8 pad_string, D DN_TCScratch scratch = DN_TCScratchBeginAllocator(&allocator, 1); DN_Str8Builder builder = DN_Str8BuilderFromArena(&scratch.arena); DN_Str8 it = string; - while (it.size) { + while (it.count) { DN_Str8BSplitResult split = DN_Str8BSplit(it, DN_Str8Lit("\n")); - DN_Str8BuilderAppendRef(&builder, DN_Str8FromPtr(split.lhs.data, split.lhs.size + 1)); + DN_Str8BuilderAppendRef(&builder, DN_Str8FromPtr(split.lhs.data, split.lhs.count + 1)); it = split.rhs; } @@ -3762,16 +3760,16 @@ DN_API DN_Str8 DN_Str8LineBreakAllocator(DN_Str8 src, DN_USize desired_width, DN char* start = src.data; char* end = src.data; DN_Str8 it = src; - while (it.size) { + while (it.count) { DN_Str8 splitters[] = {DN_Str8Lit(" "), DN_Str8Lit("\n")}; DN_Str8BSplitResult split = DN_Str8BSplitArray(it, splitters, DN_ArrayCountU(splitters)); DN_USize curr_line_length = end - start; // Handle explicit newlines in input if (split.input_index == 1 /*the newline*/) { - if (curr_line_length == 0 && split.lhs.size) + if (curr_line_length == 0 && split.lhs.count) start = split.lhs.data; - if (split.lhs.size) + if (split.lhs.count) end = DN_Str8End(split.lhs); DN_Str8BuilderAppendRef(&builder, DN_Str8FromPtr(start, end - start)); start = split.rhs.data; @@ -3781,7 +3779,7 @@ DN_API DN_Str8 DN_Str8LineBreakAllocator(DN_Str8 src, DN_USize desired_width, DN } // Skip empty segments (multiple spaces, leading/trailing spaces) - if (split.lhs.size == 0) { + if (split.lhs.count == 0) { it = split.rhs; continue; } @@ -3795,7 +3793,7 @@ DN_API DN_Str8 DN_Str8LineBreakAllocator(DN_Str8 src, DN_USize desired_width, DN } // Check if adding this word (plus separator space) would overflow - DN_USize combined_length = curr_line_length + 1 + split.lhs.size; + DN_USize combined_length = curr_line_length + 1 + split.lhs.count; if (combined_length > desired_width) { // Commit current line, start new line with current word DN_Str8BuilderAppendRef(&builder, DN_Str8FromPtr(start, end - start)); @@ -3814,7 +3812,7 @@ DN_API DN_Str8 DN_Str8LineBreakAllocator(DN_Str8 src, DN_USize desired_width, DN DN_Str8BuilderAppendRef(&builder, DN_Str8FromPtr(start, end - start)); } else { DN_Str8 it = src; - while (it.size) { + while (it.count) { DN_Str8 chunk = DN_Str8Subset(it, 0, desired_width); DN_Str8BuilderAppendRef(&builder, chunk); it = DN_Str8Advance(it, desired_width); @@ -3897,19 +3895,19 @@ DN_API DN_Str8FindResult DN_Str8FindStr8AVX512F(DN_Str8 string, DN_Str8 find) { // NOTE: Algorithm as described in http://0x80.pl/articles/simd-strfind.html DN_Str8FindResult result = {}; - if (string.size == 0 || find.size == 0 || find.size > string.size) + if (string.count == 0 || find.count == 0 || find.count > string.count) return result; __m512i const find_first_ch = _mm512_set1_epi8(find.data[0]); - __m512i const find_last_ch = _mm512_set1_epi8(find.data[find.size - 1]); + __m512i const find_last_ch = _mm512_set1_epi8(find.data[find.count - 1]); - DN_USize const search_size = string.size - find.size; + DN_USize const search_size = string.count - find.count; DN_USize simd_iterations = search_size / sizeof(__m512i); char const *ptr = string.data; while (simd_iterations--) { __m512i find_first_ch_block = _mm512_loadu_si512(ptr); - __m512i find_last_ch_block = _mm512_loadu_si512(ptr + find.size - 1); + __m512i find_last_ch_block = _mm512_loadu_si512(ptr + find.count - 1); // NOTE: AVX512F does not have a cmpeq so we use XOR to place a 0 bit // where matches are found. @@ -3953,25 +3951,25 @@ DN_API DN_Str8FindResult DN_Str8FindStr8AVX512F(DN_Str8 string, DN_Str8 find) uint64_t const lsb_zero_pos = _tzcnt_u64(zero_byte_mask); char const *base_ptr = ptr + (4 * lsb_zero_pos); - if (DN_Memcmp(base_ptr + 0, find.data, find.size) == 0) { + if (DN_Memcmp(base_ptr + 0, find.data, find.count) == 0) { result.found = true; result.index = base_ptr - string.data; - } else if (DN_Memcmp(base_ptr + 1, find.data, find.size) == 0) { + } else if (DN_Memcmp(base_ptr + 1, find.data, find.count) == 0) { result.found = true; result.index = base_ptr - string.data + 1; - } else if (DN_Memcmp(base_ptr + 2, find.data, find.size) == 0) { + } else if (DN_Memcmp(base_ptr + 2, find.data, find.count) == 0) { result.found = true; result.index = base_ptr - string.data + 2; - } else if (DN_Memcmp(base_ptr + 3, find.data, find.size) == 0) { + } else if (DN_Memcmp(base_ptr + 3, find.data, find.count) == 0) { result.found = true; result.index = base_ptr - string.data + 3; } if (result.found) { result.start_to_before_match = DN_Str8FromPtr(string.data, result.index); - result.match = DN_Str8FromPtr(string.data + result.index, find.size); - result.match_to_end_of_buffer = DN_Str8FromPtr(result.match.data, string.size - result.index); - result.after_match_to_end_of_buffer = DN_Str8Advance(result.match_to_end_of_buffer, find.size); + result.match = DN_Str8FromPtr(string.data + result.index, find.count); + result.match_to_end_of_buffer = DN_Str8FromPtr(result.match.data, string.count - result.index); + result.after_match_to_end_of_buffer = DN_Str8Advance(result.match_to_end_of_buffer, find.count); return result; } @@ -3981,15 +3979,15 @@ DN_API DN_Str8FindResult DN_Str8FindStr8AVX512F(DN_Str8 string, DN_Str8 find) ptr += sizeof(__m512i); } - for (DN_USize index = ptr - string.data; index < string.size; index++) { - DN_Str8 string_slice = DN_Str8Subset(string, index, find.size); + for (DN_USize index = ptr - string.data; index < string.count; index++) { + DN_Str8 string_slice = DN_Str8Subset(string, index, find.count); if (DN_Str8Eq(string_slice, find)) { result.found = true; result.index = index; result.start_to_before_match = DN_Str8FromPtr(string.data, index); - result.match = DN_Str8FromPtr(string.data + index, find.size); - result.match_to_end_of_buffer = DN_Str8FromPtr(result.match.data, string.size - index); - result.after_match_to_end_of_buffer = DN_Str8Advance(result.match_to_end_of_buffer, find.size); + result.match = DN_Str8FromPtr(string.data + index, find.count); + result.match_to_end_of_buffer = DN_Str8FromPtr(result.match.data, string.count - index); + result.after_match_to_end_of_buffer = DN_Str8Advance(result.match_to_end_of_buffer, find.count); return result; } } @@ -4001,20 +3999,20 @@ DN_API DN_Str8FindResult DN_Str8FindLastStr8AVX512F(DN_Str8 string, DN_Str8 find { // NOTE: Algorithm as described in http://0x80.pl/articles/simd-strfind.html DN_Str8FindResult result = {}; - if (string.size == 0 || find.size == 0 || find.size > string.size) + if (string.count == 0 || find.count == 0 || find.count > string.count) return result; __m512i const find_first_ch = _mm512_set1_epi8(find.data[0]); - __m512i const find_last_ch = _mm512_set1_epi8(find.data[find.size - 1]); + __m512i const find_last_ch = _mm512_set1_epi8(find.data[find.count - 1]); - DN_USize const search_size = string.size - find.size; + DN_USize const search_size = string.count - find.count; DN_USize simd_iterations = search_size / sizeof(__m512i); char const *ptr = string.data + search_size + 1; while (simd_iterations--) { ptr -= sizeof(__m512i); __m512i find_first_ch_block = _mm512_loadu_si512(ptr); - __m512i find_last_ch_block = _mm512_loadu_si512(ptr + find.size - 1); + __m512i find_last_ch_block = _mm512_loadu_si512(ptr + find.count - 1); // NOTE: AVX512F does not have a cmpeq so we use XOR to place a 0 bit // where matches are found. @@ -4058,24 +4056,24 @@ DN_API DN_Str8FindResult DN_Str8FindLastStr8AVX512F(DN_Str8 string, DN_Str8 find uint64_t const lsb_zero_pos = _tzcnt_u64(zero_byte_mask); char const *base_ptr = ptr + (4 * lsb_zero_pos); - if (DN_Memcmp(base_ptr + 0, find.data, find.size) == 0) { + if (DN_Memcmp(base_ptr + 0, find.data, find.count) == 0) { result.found = true; result.index = base_ptr - string.data; - } else if (DN_Memcmp(base_ptr + 1, find.data, find.size) == 0) { + } else if (DN_Memcmp(base_ptr + 1, find.data, find.count) == 0) { result.found = true; result.index = base_ptr - string.data + 1; - } else if (DN_Memcmp(base_ptr + 2, find.data, find.size) == 0) { + } else if (DN_Memcmp(base_ptr + 2, find.data, find.count) == 0) { result.found = true; result.index = base_ptr - string.data + 2; - } else if (DN_Memcmp(base_ptr + 3, find.data, find.size) == 0) { + } else if (DN_Memcmp(base_ptr + 3, find.data, find.count) == 0) { result.found = true; result.index = base_ptr - string.data + 3; } if (result.found) { result.start_to_before_match = DN_Str8FromPtr(string.data, result.index); - result.match = DN_Str8FromPtr(string.data + result.index, find.size); - result.match_to_end_of_buffer = DN_Str8FromPtr(result.match.data, string.size - result.index); + result.match = DN_Str8FromPtr(string.data + result.index, find.count); + result.match_to_end_of_buffer = DN_Str8FromPtr(result.match.data, string.count - result.index); return result; } @@ -4083,14 +4081,14 @@ DN_API DN_Str8FindResult DN_Str8FindLastStr8AVX512F(DN_Str8 string, DN_Str8 find } } - for (DN_USize index = ptr - string.data - 1; index < string.size; index--) { - DN_Str8 string_slice = DN_Str8Subset(string, index, find.size); + for (DN_USize index = ptr - string.data - 1; index < string.count; index--) { + DN_Str8 string_slice = DN_Str8Subset(string, index, find.count); if (DN_Str8Eq(string_slice, find)) { result.found = true; result.index = index; result.start_to_before_match = DN_Str8FromPtr(string.data, index); - result.match = DN_Str8FromPtr(string.data + index, find.size); - result.match_to_end_of_buffer = DN_Str8FromPtr(result.match.data, string.size - index); + result.match = DN_Str8FromPtr(string.data + index, find.count); + result.match_to_end_of_buffer = DN_Str8FromPtr(result.match.data, string.count - index); return result; } } @@ -4104,8 +4102,8 @@ DN_API DN_Str8BSplitResult DN_Str8BSplitAVX512F(DN_Str8 string, DN_Str8 find) DN_Str8FindResult find_result = DN_Str8FindAVX512F(string, find); if (find_result.found) { result.lhs.data = string.data; - result.lhs.size = find_result.index; - result.rhs = DN_Str8Advance(find_result.match_to_end_of_buffer, find.size); + result.lhs.count = find_result.index; + result.rhs = DN_Str8Advance(find_result.match_to_end_of_buffer, find.count); } else { result.lhs = string; } @@ -4119,8 +4117,8 @@ DN_API DN_Str8BSplitResult DN_Str8BSplitLastAVX512F(DN_Str8 string, DN_Str8 find DN_Str8FindResult find_result = DN_Str8FindLastAVX512F(string, find); if (find_result.found) { result.lhs.data = string.data; - result.lhs.size = find_result.index; - result.rhs = DN_Str8Advance(find_result.match_to_end_of_buffer, find.size); + result.lhs.count = find_result.index; + result.rhs = DN_Str8Advance(find_result.match_to_end_of_buffer, find.count); } else { result.lhs = string; } @@ -4131,20 +4129,20 @@ DN_API DN_Str8BSplitResult DN_Str8BSplitLastAVX512F(DN_Str8 string, DN_Str8 find DN_API DN_USize DN_Str8SplitAVX512F(DN_Str8 string, DN_Str8 delimiter, DN_Str8 *splits, DN_USize splits_count, DN_Str8SplitFlags flags) { DN_USize result = 0; // The number of splits in the actual string. - if (string.size == 0 || delimiter.size == 0 || delimiter.size <= 0) + if (string.count == 0 || delimiter.count == 0 || delimiter.count <= 0) return result; DN_Str8BSplitResult split = {}; DN_Str8 first = string; do { split = DN_Str8BSplitAVX512F(first, delimiter); - if (split.lhs.size || DN_BitIsNotSet(flags, DN_Str8SplitFlags_ExcludeEmptyStrings)) { + if (split.lhs.count || DN_BitIsNotSet(flags, DN_Str8SplitFlags_ExcludeEmptyStrings)) { if (splits && result < splits_count) splits[result] = split.lhs; result++; } first = split.rhs; - } while (first.size); + } while (first.count); return result; } @@ -4171,9 +4169,9 @@ DN_API DN_Str8 DN_Str8SliceRender(DN_Str8Slice slice, DN_Str8 separator, DN_Aren DN_USize total_size = 0; for (DN_USize index = 0; index < slice.count; index++) { if (index) - total_size += separator.size; + total_size += separator.count; DN_Str8 item = slice.data[index]; - total_size += item.size; + total_size += item.count; } result = DN_Str8AllocArena(total_size, DN_ZMem_No, arena); @@ -4181,12 +4179,12 @@ DN_API DN_Str8 DN_Str8SliceRender(DN_Str8Slice slice, DN_Str8 separator, DN_Aren DN_USize write_index = 0; for (DN_USize index = 0; index < slice.count; index++) { if (index) { - DN_Memcpy(result.data + write_index, separator.data, separator.size); - write_index += separator.size; + DN_Memcpy(result.data + write_index, separator.data, separator.count); + write_index += separator.count; } DN_Str8 item = slice.data[index]; - DN_Memcpy(result.data + write_index, item.data, item.size); - write_index += item.size; + DN_Memcpy(result.data + write_index, item.data, item.count); + write_index += item.count; } } @@ -4203,8 +4201,8 @@ DN_API int DN_Str8CompareNatural(DN_Str8 lhs, DN_Str8 rhs, DN_Str8EqCase eq_case { const char *lhs_it = lhs.data; const char *rhs_it = rhs.data; - const char *lhs_end = lhs.data + lhs.size; - const char *rhs_end = rhs.data + rhs.size; + const char *lhs_end = lhs.data + lhs.count; + const char *rhs_end = rhs.data + rhs.count; while (lhs_it < lhs_end && rhs_it < rhs_end) { // NOTE: Skip leading spaces @@ -4265,8 +4263,8 @@ DN_API int DN_Str8CompareLexicographic(DN_Str8 lhs, DN_Str8 rhs, DN_Str8EqCase e { const char *lhs_it = lhs.data; const char *rhs_it = rhs.data; - const char *lhs_end = lhs.data + lhs.size; - const char *rhs_end = rhs.data + rhs.size; + const char *lhs_end = lhs.data + lhs.count; + const char *rhs_end = rhs.data + rhs.count; while (lhs_it < lhs_end && rhs_it < rhs_end) { char lhs_ch = *lhs_it; @@ -4284,9 +4282,9 @@ DN_API int DN_Str8CompareLexicographic(DN_Str8 lhs, DN_Str8 rhs, DN_Str8EqCase e } // NOTE: One string is prefix of other; shorter comes first - if (lhs.size < rhs.size) + if (lhs.count < rhs.count) return -1; - if (rhs.size < lhs.size) + if (rhs.count < lhs.count) return 1; return 0; } @@ -4294,9 +4292,9 @@ DN_API int DN_Str8CompareLexicographic(DN_Str8 lhs, DN_Str8 rhs, DN_Str8EqCase e DN_API bool DN_Str16Eq(DN_Str16 lhs, DN_Str16 rhs) { - if (lhs.size != rhs.size) + if (lhs.count != rhs.count) return false; - bool result = (DN_Memcmp(lhs.data, rhs.data, lhs.size) == 0); + bool result = (DN_Memcmp(lhs.data, rhs.data, lhs.count) == 0); return result; } @@ -4310,9 +4308,9 @@ DN_API DN_Str16 DN_Str16SliceRender(DN_Str16Slice slice, DN_Str16 separator, DN_ DN_USize total_size = 0; for (DN_USize index = 0; index < slice.count; index++) { if (index) - total_size += separator.size; + total_size += separator.count; DN_Str16 item = slice.data[index]; - total_size += item.size; + total_size += item.count; } result = {DN_ArenaNewArray(arena, wchar_t, total_size + 1, DN_ZMem_No), total_size}; @@ -4320,12 +4318,12 @@ DN_API DN_Str16 DN_Str16SliceRender(DN_Str16Slice slice, DN_Str16 separator, DN_ DN_USize write_index = 0; for (DN_USize index = 0; index < slice.count; index++) { if (index) { - DN_Memcpy(result.data + write_index, separator.data, separator.size * sizeof(result.data[0])); - write_index += separator.size; + DN_Memcpy(result.data + write_index, separator.data, separator.count * sizeof(result.data[0])); + write_index += separator.count; } DN_Str16 item = slice.data[index]; - DN_Memcpy(result.data + write_index, item.data, item.size * sizeof(result.data[0])); - write_index += item.size; + DN_Memcpy(result.data + write_index, item.data, item.count * sizeof(result.data[0])); + write_index += item.count; } } @@ -4346,17 +4344,17 @@ DN_API DN_Str8Builder DN_Str8BuilderFromArena(DN_Arena *arena) return result; } -DN_API DN_Str8Builder DN_Str8BuilderFromStr8PtrRef(DN_Arena *arena, DN_Str8 const *strings, DN_USize size) +DN_API DN_Str8Builder DN_Str8BuilderFromStr8PtrRef(DN_Arena *arena, DN_Str8 const *strings, DN_USize count) { DN_Str8Builder result = DN_Str8BuilderFromArena(arena); - DN_Str8BuilderAppendArrayRef(&result, strings, size); + DN_Str8BuilderAppendArrayRef(&result, strings, count); return result; } -DN_API DN_Str8Builder DN_Str8BuilderFromStr8PtrCopy(DN_Arena *arena, DN_Str8 const *strings, DN_USize size) +DN_API DN_Str8Builder DN_Str8BuilderFromStr8PtrCopy(DN_Arena *arena, DN_Str8 const *strings, DN_USize count) { DN_Str8Builder result = DN_Str8BuilderFromArena(arena); - DN_Str8BuilderAppendArrayCopy(&result, strings, size); + DN_Str8BuilderAppendArrayCopy(&result, strings, count); return result; } @@ -4367,21 +4365,21 @@ DN_API DN_Str8Builder DN_Str8BuilderFromBuilder(DN_Arena *arena, DN_Str8Builder return result; } -DN_API bool DN_Str8BuilderAddArrayRef(DN_Str8Builder *builder, DN_Str8 const *strings, DN_USize size, DN_Str8BuilderAdd add) +DN_API bool DN_Str8BuilderAddArrayRef(DN_Str8Builder *builder, DN_Str8 const *strings, DN_USize count, DN_Str8BuilderAdd add) { if (!builder) return false; - if (!strings || size <= 0) + if (!strings || count <= 0) return true; // NOTE: Allocate the links - DN_Str8Link *links = DN_ArenaNewArrayNoZ(builder->arena, DN_Str8Link, size); + DN_Str8Link *links = DN_ArenaNewArrayNoZ(builder->arena, DN_Str8Link, count); if (!links) return false; if (add == DN_Str8BuilderAdd_Append) { - for (DN_ForIndexU(index, size)) { + for (DN_ForIndexU(index, count)) { DN_Str8 string = strings[index]; DN_Str8Link *link = links + index; link->string = string; @@ -4392,13 +4390,13 @@ DN_API bool DN_Str8BuilderAddArrayRef(DN_Str8Builder *builder, DN_Str8 const *st builder->head = link; builder->tail = link; builder->count++; - builder->string_size += string.size; + builder->string_size += string.count; } } else { DN_Assert(add == DN_Str8BuilderAdd_Prepend); DN_MSVC_WARNING_PUSH DN_MSVC_WARNING_DISABLE(6293) // NOTE: Ill-defined loop - for (DN_USize index = size - 1; index < size; index--) { + for (DN_USize index = count - 1; index < count; index--) { DN_MSVC_WARNING_POP DN_Str8 string = strings[index]; DN_Str8Link *link = links + index; @@ -4408,33 +4406,33 @@ DN_API bool DN_Str8BuilderAddArrayRef(DN_Str8Builder *builder, DN_Str8 const *st if (!builder->tail) builder->tail = link; builder->count++; - builder->string_size += string.size; + builder->string_size += string.count; } } return true; } -DN_API bool DN_Str8BuilderAddArrayCopy(DN_Str8Builder *builder, DN_Str8 const *strings, DN_USize size, DN_Str8BuilderAdd add) +DN_API bool DN_Str8BuilderAddArrayCopy(DN_Str8Builder *builder, DN_Str8 const *strings, DN_USize count, DN_Str8BuilderAdd add) { if (!builder) return false; - if (!strings || size <= 0) + if (!strings || count <= 0) return true; bool result = true; DN_U64 arena_p = DN_MemListPos(builder->arena->mem); - DN_Str8 *strings_copy = DN_ArenaNewArrayNoZ(builder->arena, DN_Str8, size); - for (DN_ForIndexU(index, size)) { + DN_Str8 *strings_copy = DN_ArenaNewArrayNoZ(builder->arena, DN_Str8, count); + for (DN_ForIndexU(index, count)) { strings_copy[index] = DN_Str8FromStr8Arena(strings[index], builder->arena); - if (strings_copy[index].size != strings[index].size) { + if (strings_copy[index].count != strings[index].count) { result = false; break; } } if (result) - result = DN_Str8BuilderAddArrayRef(builder, strings_copy, size, add); + result = DN_Str8BuilderAddArrayRef(builder, strings_copy, count, add); else DN_MemListPopTo(builder->arena->mem, arena_p); return result; @@ -4471,16 +4469,16 @@ DN_API bool DN_Str8BuilderAppendF(DN_Str8Builder *builder, DN_FMT_ATTRIB char co return result; } -DN_API bool DN_Str8BuilderAppendBytesRef(DN_Str8Builder *builder, void const *ptr, DN_USize size) +DN_API bool DN_Str8BuilderAppendBytesRef(DN_Str8Builder *builder, void const *ptr, DN_USize count) { - DN_Str8 input = DN_Str8FromPtr(ptr, size); + DN_Str8 input = DN_Str8FromPtr(ptr, count); bool result = DN_Str8BuilderAppendRef(builder, input); return result; } -DN_API bool DN_Str8BuilderAppendBytesCopy(DN_Str8Builder *builder, void const *ptr, DN_USize size) +DN_API bool DN_Str8BuilderAppendBytesCopy(DN_Str8Builder *builder, void const *ptr, DN_USize count) { - DN_Str8 input = DN_Str8FromPtr(ptr, size); + DN_Str8 input = DN_Str8FromPtr(ptr, count); bool result = DN_Str8BuilderAppendCopy(builder, input); return result; } @@ -4506,7 +4504,7 @@ static bool DN_Str8BuilderAppendBuilder_(DN_Str8Builder *dest, DN_Str8Builder co if (copy) { link->string = DN_Str8FromStr8Arena(it->string, &arena); - if (link->string.size != it->string.size) { + if (link->string.count != it->string.count) { result = false; break; } @@ -4571,7 +4569,7 @@ DN_API bool DN_Str8BuilderErase(DN_Str8Builder *builder, DN_Str8 string) for (DN_Str8Link **it = &builder->head; *it; it = &((*it)->next)) { if (DN_Str8Eq((*it)->string, string)) { *it = (*it)->next; - builder->string_size -= string.size; + builder->string_size -= string.count; builder->count -= 1; return true; } @@ -4597,23 +4595,23 @@ DN_API DN_Str8 DN_Str8FromStr8BuilderDelimitAllocator(DN_Str8Builder const *buil if (!builder || builder->string_size <= 0 || builder->count <= 0) return result; - DN_USize size_for_delimiter = delimiter.size ? ((builder->count - 1) * delimiter.size) : 0; - result = DN_Str8AllocAllocator(builder->string_size + size_for_delimiter, DN_ZMem_No, allocator); + DN_USize count_for_delimiter = delimiter.count ? ((builder->count - 1) * delimiter.count) : 0; + result = DN_Str8AllocAllocator(builder->string_size + count_for_delimiter, DN_ZMem_No, allocator); if (!result.data) return result; DN_USize write_count = 0; for (DN_Str8Link *link = builder->head; link; link = link->next) { - DN_Memcpy(result.data + write_count, link->string.data, link->string.size); - write_count += link->string.size; - if (link->next && delimiter.size) { - DN_Memcpy(result.data + write_count, delimiter.data, delimiter.size); - write_count += delimiter.size; + DN_Memcpy(result.data + write_count, link->string.data, link->string.count); + write_count += link->string.count; + if (link->next && delimiter.count) { + DN_Memcpy(result.data + write_count, delimiter.data, delimiter.count); + write_count += delimiter.count; } } result.data[write_count] = 0; - DN_Assert(write_count == builder->string_size + size_for_delimiter); + DN_Assert(write_count == builder->string_size + count_for_delimiter); return result; } @@ -4669,23 +4667,23 @@ DN_API DN_UTF8DecodeResult DN_UTF8Decode(DN_Str8 stream) { DN_UTF8DecodeResult result = {}; result.remaining = stream; - if (stream.size <= 0) + if (stream.count <= 0) return result; DN_U8 b0 = DN_Cast(DN_U8)stream.data[0]; - DN_U8 b1 = DN_Cast(DN_U8)(stream.size >= 2 ? stream.data[1] : 0); - DN_U8 b2 = DN_Cast(DN_U8)(stream.size >= 3 ? stream.data[2] : 0); - DN_U8 b3 = DN_Cast(DN_U8)(stream.size >= 4 ? stream.data[3] : 0); + DN_U8 b1 = DN_Cast(DN_U8)(stream.count >= 2 ? stream.data[1] : 0); + DN_U8 b2 = DN_Cast(DN_U8)(stream.count >= 3 ? stream.data[2] : 0); + DN_U8 b3 = DN_Cast(DN_U8)(stream.count >= 4 ? stream.data[3] : 0); if ((b0 & 0b1000'0000) == 0) { result.codepoint = b0; result.success = true; - result.remaining = DN_Str8FromPtr(stream.data + 1, stream.size - 1); + result.remaining = DN_Str8FromPtr(stream.data + 1, stream.count - 1); return result; } if ((b0 & 0b1110'0000) == 0b1100'0000) { - if (stream.size < 2) + if (stream.count < 2) return result; if ((b1 & 0b1100'0000) != 0b1000'0000) return result; @@ -4694,12 +4692,12 @@ DN_API DN_UTF8DecodeResult DN_UTF8Decode(DN_Str8 stream) return result; result.codepoint = cp; result.success = true; - result.remaining = DN_Str8FromPtr(stream.data + 2, stream.size - 2); + result.remaining = DN_Str8FromPtr(stream.data + 2, stream.count - 2); return result; } if ((b0 & 0b1111'0000) == 0b1110'0000) { - if (stream.size < 3) + if (stream.count < 3) return result; if ((b1 & 0b1100'0000) != 0b1000'0000) return result; @@ -4710,12 +4708,12 @@ DN_API DN_UTF8DecodeResult DN_UTF8Decode(DN_Str8 stream) return result; result.codepoint = cp; result.success = true; - result.remaining = DN_Str8FromPtr(stream.data + 3, stream.size - 3); + result.remaining = DN_Str8FromPtr(stream.data + 3, stream.count - 3); return result; } if ((b0 & 0b1111'1000) == 0b1111'0000) { - if (stream.size < 4) + if (stream.count < 4) return result; if ((b1 & 0b1100'0000) != 0b1000'0000) return result; @@ -4731,7 +4729,7 @@ DN_API DN_UTF8DecodeResult DN_UTF8Decode(DN_Str8 stream) return result; result.codepoint = cp; result.success = true; - result.remaining = DN_Str8FromPtr(stream.data + 4, stream.size - 4); + result.remaining = DN_Str8FromPtr(stream.data + 4, stream.count - 4); return result; } @@ -4810,7 +4808,7 @@ DN_API DN_USize DN_BytesFromHex(DN_Str8 hex, void *dest, DN_USize dest_count) { DN_Str8 hex_trimmed = DN_Str8TrimHexPrefix(hex); DN_USize result = 0; - if (hex_trimmed.size > (dest_count * 2)) + if (hex_trimmed.count > (dest_count * 2)) return result; DN_U8 *ptr = DN_Cast(DN_U8 *) dest; @@ -4818,7 +4816,7 @@ DN_API DN_USize DN_BytesFromHex(DN_Str8 hex, void *dest, DN_USize dest_count) // NOTE: We are given an odd-sized hex string e.g.: 'F' instead of '0F', we 'left-pad' the parser // and support reading the single nibble as 'F' - if (hex_trimmed.size % 2 != 0) { + if (hex_trimmed.count % 2 != 0) { DN_U8 nibble0 = 0; DN_U8 nibble1 = DN_U8FromHexNibble(hex_trimmed.data[index++]); if (nibble1 == 0xFF) @@ -4828,7 +4826,7 @@ DN_API DN_USize DN_BytesFromHex(DN_Str8 hex, void *dest, DN_USize dest_count) } // NOTE: Parse the rest of the hex which is in byte pairs - for (; index < hex_trimmed.size; index += 2) { + for (; index < hex_trimmed.count; index += 2) { DN_U8 nibble0 = DN_U8FromHexNibble(hex_trimmed.data[index + 0]); DN_U8 nibble1 = DN_U8FromHexNibble(hex_trimmed.data[index + 1]); if (nibble0 == 0xFF || nibble1 == 0xFF) @@ -4841,7 +4839,7 @@ DN_API DN_USize DN_BytesFromHex(DN_Str8 hex, void *dest, DN_USize dest_count) DN_API DN_Str8 DN_BytesFromHexArena(DN_Str8 hex, DN_Arena *arena) { - DN_Str8 result = DN_BytesFromHexPtrArena(hex.data, hex.size, arena); + DN_Str8 result = DN_BytesFromHexPtrArena(hex.data, hex.count, arena); return result; } @@ -4854,22 +4852,22 @@ DN_API DN_USize DN_BytesFromHexPtr(char const *hex, DN_USize hex_count, void *de DN_API DN_Str8 DN_BytesFromHexPtrArena(char const *hex, DN_USize hex_count, DN_Arena *arena) { DN_Str8 hex_trimmed = DN_Str8TrimHexPrefix(DN_Str8FromPtr(hex, hex_count)); - DN_Assert(hex_trimmed.size % 2 == 0); + DN_Assert(hex_trimmed.count % 2 == 0); DN_Str8 result = {}; - result.data = DN_ArenaNewArray(arena, char, hex_trimmed.size / 2, DN_ZMem_No); + result.data = DN_ArenaNewArray(arena, char, hex_trimmed.count / 2, DN_ZMem_No); if (result.data) - result.size = DN_BytesFromHex(hex_trimmed, result.data, hex_trimmed.size / 2); + result.count = DN_BytesFromHex(hex_trimmed, result.data, hex_trimmed.count / 2); return result; } DN_API DN_Str8 DN_BytesFromHexPtrPool(char const *hex, DN_USize hex_count, DN_Pool *pool) { DN_Str8 hex_trimmed = DN_Str8TrimHexPrefix(DN_Str8FromPtr(hex, hex_count)); - DN_Assert(hex_trimmed.size % 2 == 0); + DN_Assert(hex_trimmed.count % 2 == 0); DN_Str8 result = {}; - result.data = DN_PoolNewArray(pool, char, hex_trimmed.size / 2); + result.data = DN_PoolNewArray(pool, char, hex_trimmed.count / 2); if (result.data) - result.size = DN_BytesFromHex(hex_trimmed, result.data, hex_trimmed.size / 2); + result.count = DN_BytesFromHex(hex_trimmed, result.data, hex_trimmed.count / 2); return result; } @@ -4878,7 +4876,7 @@ DN_API DN_U8x16 DN_BytesFromHex32Ptr(char const *hex, DN_USize hex_count) { DN_U8x16 result = {}; DN_Str8 hex_trimmed = DN_Str8TrimHexPrefix(DN_Str8FromPtr(hex, hex_count)); - DN_Assert(hex_trimmed.size / 2 == sizeof result.data); + DN_Assert(hex_trimmed.count / 2 == sizeof result.data); DN_USize bytes_written = DN_BytesFromHex(hex_trimmed, result.data, sizeof result.data); DN_Assert(bytes_written == sizeof result.data); return result; @@ -4888,7 +4886,7 @@ DN_API DN_U8x32 DN_BytesFromHex64Ptr(char const *hex, DN_USize hex_count) { DN_U8x32 result = {}; DN_Str8 hex_trimmed = DN_Str8TrimHexPrefix(DN_Str8FromPtr(hex, hex_count)); - DN_Assert(hex_trimmed.size / 2 == sizeof result.data); + DN_Assert(hex_trimmed.count / 2 == sizeof result.data); DN_USize bytes_written = DN_BytesFromHex(hex_trimmed, result.data, sizeof result.data); DN_Assert(bytes_written == sizeof result.data); return result; @@ -4897,10 +4895,10 @@ DN_API DN_U8x32 DN_BytesFromHex64Ptr(char const *hex, DN_USize hex_count) DN_API DN_HexU64 DN_HexFromU64(DN_U64 value, DN_HexFromU64Type type) { DN_HexU64 result = {}; - DN_USize size = DN_HexFromPtrBytes(&value, sizeof(value), result.data, sizeof(result.data), DN_TrimLeadingZero_No); - result.size = DN_SaturateCastUSizeToU8(size); + DN_USize count = DN_HexFromPtrBytes(&value, sizeof(value), result.data, sizeof(result.data), DN_TrimLeadingZero_No); + result.count = DN_SaturateCastUSizeToU8(count); if (type == DN_HexFromU64Type_Uppercase) { - for (DN_USize index = 0; index < result.size; index++) + for (DN_USize index = 0; index < result.count; index++) result.data[index] = DN_CharToUpper(result.data[index]); } return result; @@ -4944,24 +4942,24 @@ DN_API DN_Str8 DN_HexFromPtrBytesArena(void const *bytes, DN_USize bytes_count, if (bytes_count) { result.data = DN_ArenaNewArray(arena, char, bytes_count * 2, DN_ZMem_No); if (result.data) - result.size = DN_HexFromPtrBytes(bytes, bytes_count, result.data, bytes_count * 2, trim_leading_z); + result.count = DN_HexFromPtrBytes(bytes, bytes_count, result.data, bytes_count * 2, trim_leading_z); } return result; } DN_API DN_USize DN_HexFromStr8Bytes(DN_Str8 bytes, void *hex, DN_USize hex_count, DN_TrimLeadingZero trim_leading_z) { - DN_USize result = DN_HexFromPtrBytes(bytes.data, bytes.size, hex, hex_count, trim_leading_z); + DN_USize result = DN_HexFromPtrBytes(bytes.data, bytes.count, hex, hex_count, trim_leading_z); return result; } DN_API DN_Str8 DN_HexFromStr8BytesArena(DN_Str8 bytes, DN_Arena *arena, DN_TrimLeadingZero trim_leading_z) { DN_Str8 result = {}; - if (bytes.size) { - result.data = DN_ArenaNewArray(arena, char, bytes.size * 2, DN_ZMem_No); + if (bytes.count) { + result.data = DN_ArenaNewArray(arena, char, bytes.count * 2, DN_ZMem_No); if (result.data) - result.size = DN_HexFromStr8Bytes(bytes, result.data, bytes.size * 2, trim_leading_z); + result.count = DN_HexFromStr8Bytes(bytes, result.data, bytes.count * 2, trim_leading_z); } return result; } @@ -4970,8 +4968,8 @@ DN_API DN_Hex32 DN_Hex32FromPtr16b(void const *bytes, DN_USize bytes_count, DN_T { DN_Hex32 result = {}; DN_Assert(bytes_count * 2 == sizeof result.data - 1); - result.size = DN_HexFromPtrBytes(bytes, bytes_count, result.data, sizeof result.data, trim_leading_z); - DN_Assert(result.size <= sizeof result.data - 1); + result.count = DN_HexFromPtrBytes(bytes, bytes_count, result.data, sizeof result.data, trim_leading_z); + DN_Assert(result.count <= sizeof result.data - 1); return result; } @@ -4979,8 +4977,8 @@ DN_API DN_Hex64 DN_Hex64FromPtr32b(void const *bytes, DN_USize bytes_count, DN_T { DN_Hex64 result = {}; DN_Assert(bytes_count * 2 == sizeof result.data - 1); - result.size = DN_HexFromPtrBytes(bytes, bytes_count, result.data, sizeof result.data, trim_leading_z); - DN_Assert(result.size <= sizeof result.data - 1); + result.count = DN_HexFromPtrBytes(bytes, bytes_count, result.data, sizeof result.data, trim_leading_z); + DN_Assert(result.count <= sizeof result.data - 1); return result; } @@ -4988,8 +4986,8 @@ DN_API DN_Hex128 DN_Hex128FromPtr64b(void const *bytes, DN_USize bytes_count, DN { DN_Hex128 result = {}; DN_Assert(bytes_count * 2 == sizeof result.data - 1); - result.size = DN_HexFromPtrBytes(bytes, bytes_count, result.data, sizeof result.data, trim_leading_z); - DN_Assert(result.size <= sizeof result.data - 1); + result.count = DN_HexFromPtrBytes(bytes, bytes_count, result.data, sizeof result.data, trim_leading_z); + DN_Assert(result.count <= sizeof result.data - 1); return result; } @@ -5008,7 +5006,7 @@ DN_API DN_Str8x128 DN_AgeStr8FromMsU64(DN_U64 duration_ms, DN_AgeUnit units) DN_USize value_usize = remainder_ms / (DN_SecFromYears(1) * 1000); remainder_ms -= DN_SecFromYears(value_usize) * 1000; if (value_usize) - DN_FmtAppend(result.data, &result.size, sizeof(result.data), "%s%zu%.*s", result.size ? " " : "", value_usize, DN_Str8PrintFmt(unit_suffix)); + DN_FmtAppend(result.data, &result.count, sizeof(result.data), "%s%zu%.*s", result.count ? " " : "", value_usize, DN_Str8PrintFmt(unit_suffix)); } if (units & DN_AgeUnit_Week) { @@ -5016,7 +5014,7 @@ DN_API DN_Str8x128 DN_AgeStr8FromMsU64(DN_U64 duration_ms, DN_AgeUnit units) DN_USize value_usize = remainder_ms / (DN_SecFromWeeks(1) * 1000); remainder_ms -= DN_SecFromWeeks(value_usize) * 1000; if (value_usize) - DN_FmtAppend(result.data, &result.size, sizeof(result.data), "%s%zu%.*s", result.size ? " " : "", value_usize, DN_Str8PrintFmt(unit_suffix)); + DN_FmtAppend(result.data, &result.count, sizeof(result.data), "%s%zu%.*s", result.count ? " " : "", value_usize, DN_Str8PrintFmt(unit_suffix)); } if (units & DN_AgeUnit_Day) { @@ -5024,7 +5022,7 @@ DN_API DN_Str8x128 DN_AgeStr8FromMsU64(DN_U64 duration_ms, DN_AgeUnit units) DN_USize value_usize = remainder_ms / (DN_SecFromDays(1) * 1000); remainder_ms -= DN_SecFromDays(value_usize) * 1000; if (value_usize) - DN_FmtAppend(result.data, &result.size, sizeof(result.data), "%s%zu%.*s", result.size ? " " : "", value_usize, DN_Str8PrintFmt(unit_suffix)); + DN_FmtAppend(result.data, &result.count, sizeof(result.data), "%s%zu%.*s", result.count ? " " : "", value_usize, DN_Str8PrintFmt(unit_suffix)); } if (units & DN_AgeUnit_Hr) { @@ -5032,7 +5030,7 @@ DN_API DN_Str8x128 DN_AgeStr8FromMsU64(DN_U64 duration_ms, DN_AgeUnit units) DN_USize value_usize = remainder_ms / (DN_SecFromHours(1) * 1000); remainder_ms -= DN_SecFromHours(value_usize) * 1000; if (value_usize) - DN_FmtAppend(result.data, &result.size, sizeof(result.data), "%s%zu%.*s", result.size ? " " : "", value_usize, DN_Str8PrintFmt(unit_suffix)); + DN_FmtAppend(result.data, &result.count, sizeof(result.data), "%s%zu%.*s", result.count ? " " : "", value_usize, DN_Str8PrintFmt(unit_suffix)); } if (units & DN_AgeUnit_Min) { @@ -5040,20 +5038,20 @@ DN_API DN_Str8x128 DN_AgeStr8FromMsU64(DN_U64 duration_ms, DN_AgeUnit units) DN_USize value_usize = remainder_ms / (DN_SecFromMins(1) * 1000); remainder_ms -= DN_SecFromMins(value_usize) * 1000; if (value_usize) - DN_FmtAppend(result.data, &result.size, sizeof(result.data), "%s%zu%.*s", result.size ? " " : "", value_usize, DN_Str8PrintFmt(unit_suffix)); + DN_FmtAppend(result.data, &result.count, sizeof(result.data), "%s%zu%.*s", result.count ? " " : "", value_usize, DN_Str8PrintFmt(unit_suffix)); } if (units & DN_AgeUnit_Sec) { unit_suffix = DN_Str8Lit("s"); if (units & DN_AgeUnit_FractionalSec) { DN_F64 remainder_s = remainder_ms / 1000.0; - DN_FmtAppend(result.data, &result.size, sizeof(result.data), "%s%.3f%.*s", result.size ? " " : "", remainder_s, DN_Str8PrintFmt(unit_suffix)); + DN_FmtAppend(result.data, &result.count, sizeof(result.data), "%s%.3f%.*s", result.count ? " " : "", remainder_s, DN_Str8PrintFmt(unit_suffix)); remainder_ms = 0; } else { DN_USize value_usize = remainder_ms / 1000; remainder_ms -= DN_Cast(DN_USize)(value_usize * 1000); if (value_usize) - DN_FmtAppend(result.data, &result.size, sizeof(result.data), "%s%zu%.*s", result.size ? " " : "", value_usize, DN_Str8PrintFmt(unit_suffix)); + DN_FmtAppend(result.data, &result.count, sizeof(result.data), "%s%zu%.*s", result.count ? " " : "", value_usize, DN_Str8PrintFmt(unit_suffix)); } } @@ -5062,12 +5060,12 @@ DN_API DN_Str8x128 DN_AgeStr8FromMsU64(DN_U64 duration_ms, DN_AgeUnit units) DN_Assert((units & DN_AgeUnit_FractionalSec) == 0); DN_USize value_usize = remainder_ms; remainder_ms -= value_usize; - if (value_usize || result.size == 0) - DN_FmtAppend(result.data, &result.size, sizeof(result.data), "%s%zu%.*s", result.size ? " " : "", value_usize, DN_Str8PrintFmt(unit_suffix)); + if (value_usize || result.count == 0) + DN_FmtAppend(result.data, &result.count, sizeof(result.data), "%s%zu%.*s", result.count ? " " : "", value_usize, DN_Str8PrintFmt(unit_suffix)); } - if (result.size == 0) - DN_FmtAppend(result.data, &result.size, sizeof(result.data), "0%.*s", DN_Str8PrintFmt(unit_suffix)); + if (result.count == 0) + DN_FmtAppend(result.data, &result.count, sizeof(result.data), "0%.*s", DN_Str8PrintFmt(unit_suffix)); return result; } @@ -5289,7 +5287,7 @@ DN_API DN_ProfilerZone DN_ProfilerBeginZone(DN_Profiler *profiler, DN_Str8 name, // TODO: We need per-thread-local-storage profiler so that we can use these apis // across threads. For now, we let them overwrite each other but this is not tenable. #if 0 - if (anchor->name.size && anchor->name != name) + if (anchor->name.count && anchor->name != name) DN_AssertF(name == anchor->name, "Potentially overwriting a zone by accident? Anchor is '%.*s', name is '%.*s'", DN_Str8PrintFmt(anchor->name), DN_Str8PrintFmt(name)); #endif @@ -5376,10 +5374,10 @@ DN_API DN_USize DN_ProfilerFmtAnchor(DN_ProfilerAnchor anchor, DN_U64 tsc_freque DN_API DN_Str8 DN_ProfilerFmtAnchorStr8(DN_ProfilerAnchor anchor, DN_U64 tsc_frequency, DN_Arena *arena) { DN_Str8 result = {}; - DN_USize size_req = DN_ProfilerFmtAnchor(anchor, tsc_frequency, nullptr, 0); - if (size_req) { - result = DN_Str8AllocArena(size_req, DN_ZMem_No, arena); - DN_ProfilerFmtAnchor(anchor, tsc_frequency, result.data, result.size + 1); + DN_USize count_req = DN_ProfilerFmtAnchor(anchor, tsc_frequency, nullptr, 0); + if (count_req) { + result = DN_Str8AllocArena(count_req, DN_ZMem_No, arena); + DN_ProfilerFmtAnchor(anchor, tsc_frequency, result.data, result.count + 1); } return result; } @@ -5686,18 +5684,18 @@ DN_API void DN_PCG32Advance(DN_PCG32 *rng, DN_U64 delta) } // Default values recommended by: http://isthe.com/chongo/tech/comp/fnv/ -DN_API DN_U32 DN_FNV1AHashU32FromBytes(void const *bytes, DN_USize size, DN_U32 hash) +DN_API DN_U32 DN_FNV1AHashU32FromBytes(void const *bytes, DN_USize count, DN_U32 hash) { - auto buffer = DN_Cast(DN_U8 const *)bytes; - for (DN_USize i = 0; i < size; i++) - hash = (buffer[i] ^ hash) * 16777619 /*FNV Prime*/; - return hash; + auto buffer = DN_Cast(DN_U8 const *)bytes; + for (DN_USize i = 0; i < count; i++) + hash = (buffer[i] ^ hash) * 16777619 /*FNV Prime*/; + return hash; } -DN_API DN_U64 DN_FNV1AHashU64FromBytes(void const *bytes, DN_USize size, DN_U64 hash) +DN_API DN_U64 DN_FNV1AHashU64FromBytes(void const *bytes, DN_USize count, DN_U64 hash) { auto buffer = DN_Cast(DN_U8 const *)bytes; - for (DN_USize i = 0; i < size; i++) + for (DN_USize i = 0; i < count; i++) hash = (buffer[i] ^ hash) * 1099511628211 /*FNV Prime*/; return hash; } @@ -6010,8 +6008,8 @@ DN_API DN_LogPrefixSize DN_LogMakePrefix(DN_LogStyle style, DN_LogTypeParam type } static DN_USize max_type_length = 0; - max_type_length = DN_Max(max_type_length, type_str8.size); - int type_padding = DN_Cast(int)(max_type_length - type_str8.size); + max_type_length = DN_Max(max_type_length, type_str8.count); + int type_padding = DN_Cast(int)(max_type_length - type_str8.count); DN_Str8x32 colour_esc = {}; DN_Str8 bold_esc = {}; @@ -6050,12 +6048,12 @@ DN_API DN_LogPrefixSize DN_LogMakePrefix(DN_LogStyle style, DN_LogTypeParam type call_site.line); // line number static DN_USize max_header_length = 0; - DN_USize size_no_ansi_codes = size - colour_esc.size - reset_esc.size - bold_esc.size; + DN_USize size_no_ansi_codes = size - colour_esc.count - reset_esc.count - bold_esc.count; max_header_length = DN_Max(max_header_length, size_no_ansi_codes); DN_USize header_padding = max_header_length - size_no_ansi_codes; DN_LogPrefixSize result = {}; - result.size = size; + result.count = size; result.padding = header_padding; return result; } @@ -7397,12 +7395,12 @@ DN_API DN_Str8x256 DN_M4ColumnMajorString(DN_M4 mat) for (int row = 0; row < 4; row++) { for (int it = 0; it < 4; it++) { if (it == 0) - DN_FmtAppend(result.data, &result.size, sizeof(result.data), "|"); - DN_FmtAppend(result.data, &result.size, sizeof(result.data), "%.5f", mat.columns[it][row]); + DN_FmtAppend(result.data, &result.count, sizeof(result.data), "|"); + DN_FmtAppend(result.data, &result.count, sizeof(result.data), "%.5f", mat.columns[it][row]); if (it != 3) - DN_FmtAppend(result.data, &result.size, sizeof(result.data), ", "); + DN_FmtAppend(result.data, &result.count, sizeof(result.data), ", "); else - DN_FmtAppend(result.data, &result.size, sizeof(result.data), "|\n"); + DN_FmtAppend(result.data, &result.count, sizeof(result.data), "|\n"); } } return result; @@ -7851,22 +7849,22 @@ struct DN_ArrayFindEqMemcmpContext_ void const *find; }; -DN_API void *DN_SliceAllocArena(void **data, DN_USize *slice_size_field, DN_USize size, DN_USize elem_size, DN_U8 align, DN_ZMem zmem, DN_Arena *arena) +DN_API void *DN_SliceAllocArena(void **data, DN_USize *slice_size_field, DN_USize count, DN_USize elem_size, DN_U8 align, DN_ZMem zmem, DN_Arena *arena) { void *result = *data; - *data = DN_ArenaAlloc(arena, size * elem_size, align, zmem); + *data = DN_ArenaAlloc(arena, count * elem_size, align, zmem); if (*data) - *slice_size_field = size; + *slice_size_field = count; return result; } -DN_API DN_ArrayFindResult DN_ArrayFind(void *data, DN_USize size, DN_USize elem_size, void const *find, DN_ArrayFindEqFunc *eq_func) +DN_API DN_ArrayFindResult DN_ArrayFind(void *data, DN_USize count, DN_USize elem_size, void const *find, DN_ArrayFindEqFunc *eq_func) { DN_ArrayFindResult result = {}; DN_Assert(data); DN_Assert(elem_size); if (find) { - for (DN_ForIndexU(index, size)) { + for (DN_ForIndexU(index, count)) { DN_U8 *it = DN_Cast(DN_U8 *) data + (index * elem_size); if (eq_func(it, find)) { result.index = index; @@ -7886,12 +7884,12 @@ static bool DN_ArrayFindEqMemEqUnsafe_(void const *lhs, void const *find) return result; } -DN_API DN_ArrayFindResult DN_ArrayFindMemEq(void *data, DN_USize size, DN_USize elem_size, void const *find) +DN_API DN_ArrayFindResult DN_ArrayFindMemEq(void *data, DN_USize count, DN_USize elem_size, void const *find) { DN_ArrayFindEqMemcmpContext_ context = {}; context.elem_size = elem_size; context.find = find; - DN_ArrayFindResult result = DN_ArrayFind(data, size, elem_size, &context, DN_ArrayFindEqMemEqUnsafe_); + DN_ArrayFindResult result = DN_ArrayFind(data, count, elem_size, &context, DN_ArrayFindEqMemEqUnsafe_); return result; } @@ -7946,116 +7944,116 @@ DN_API void *DN_ArrayPopBack(void *data, DN_USize *size, DN_USize elem_size, DN_ return DN_Cast(char *)data + (*size * elem_size); } -DN_API DN_ArrayEraseResult DN_ArrayEraseRange(void *data, DN_USize *size, DN_USize elem_size, DN_USize begin_index, DN_ISize count, DN_ArrayErase erase) +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_ArrayEraseResult result = {}; result.it_index = begin_index; - if (!data || !size || *size == 0 || count == 0) + if (!data || !count || *count == 0 || erase_count == 0) return result; // Compute the range to erase DN_USize start = 0, end = 0; - if (count < 0) { + if (erase_count < 0) { // Erase backwards from begin_index, not inclusive of begin_index // Range: [begin_index + count, begin_index) // Which is: [begin_index - abs(count), begin_index) - DN_USize abs_count = DN_Abs(count); - start = (begin_index > abs_count) ? (begin_index - abs_count) : 0; + DN_USize abs_erase_count = DN_Abs(erase_count); + start = (begin_index > abs_erase_count) ? (begin_index - abs_erase_count) : 0; end = begin_index; } else { start = begin_index; - end = begin_index + count; + end = begin_index + erase_count; } // Clamp indices to valid bounds - start = DN_Min(start, *size); - end = DN_Min(end, *size); + start = DN_Min(start, *count); + end = DN_Min(end, *count); // Erase the range [start, end) - DN_USize erase_count = end > start ? end - start : 0; - if (erase_count) { + DN_USize real_erase_count = end > start ? end - start : 0; + if (real_erase_count) { char *dest = (char *)data + (elem_size * start); - char *array_end = (char *)data + (elem_size * *size); - char *src = dest + (elem_size * erase_count); + char *array_end = (char *)data + (elem_size * *count); + char *src = dest + (elem_size * real_erase_count); if (erase == DN_ArrayErase_Stable) { DN_USize move_size = array_end - src; DN_Memmove(dest, src, move_size); } else { - char *unstable_src = array_end - (elem_size * erase_count); + char *unstable_src = array_end - (elem_size * real_erase_count); DN_USize move_size = array_end - unstable_src; DN_Memcpy(dest, unstable_src, move_size); } - *size -= erase_count; + *count -= real_erase_count; } result.items_erased = erase_count; // NOTE: If we are erasing from the current index of the iterator to the end of the array then // there's no more elements in the array to iterate. So the returned index should b // one-past-last index - if (begin_index == start && end >= *size) { - result.it_index = *size; + if (begin_index == start && end >= *count) { + result.it_index = *count; } else { result.it_index = start ? start - 1 : 0; } return result; } -DN_API void *DN_ArrayMakeArray(void *data, DN_USize *size, DN_USize max, DN_USize elem_size, DN_USize make_count, DN_ZMem z_mem) +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) { void *result = nullptr; - DN_USize new_size = *size + make_count; - if (new_size <= max) { - result = DN_Cast(char *) data + (elem_size * size[0]); - *size = new_size; + DN_USize new_count = *count + make_count; + if (new_count <= max) { + result = DN_Cast(char *) data + (elem_size * count[0]); + *count = new_count; if (z_mem == DN_ZMem_Yes) DN_Memset(result, 0, elem_size * make_count); } return result; } -DN_API void *DN_ArrayMakeArrayAssert(void *data, DN_USize *size, DN_USize max, DN_USize elem_size, DN_USize make_count, DN_ZMem z_mem, DN_CallSite call_site) +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) { - void *result = DN_ArrayMakeArray(data, size, max, elem_size, make_count, z_mem); - DN_AssertCallSiteF(result, call_site, "Array out of space, failed to add %zu items: array=%p size=%zu max=%zu", make_count, data, *size, max); + void *result = DN_ArrayMakeArray(data, count, max, elem_size, make_count, z_mem); + DN_AssertCallSiteF(result, call_site, "Array out of space, failed to add %zu items: array=%p size=%zu max=%zu", make_count, data, *count, max); return result; } -DN_API void *DN_ArrayAddArray(void *data, DN_USize *size, DN_USize max, DN_USize elem_size, void const *elems, DN_USize elems_count, DN_ArrayAdd add) +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, size, max, elem_size, elems_count, DN_ZMem_No); + void *result = DN_ArrayMakeArray(data, count, max, elem_size, elems_count, DN_ZMem_No); if (result) { if (add == DN_ArrayAdd_Append) { DN_Memcpy(result, elems, elems_count * elem_size); } else { char *move_dest = DN_Cast(char *)data + (elems_count * elem_size); // Shift elements forward char *move_src = DN_Cast(char *)data; - DN_Memmove(move_dest, move_src, elem_size * size[0]); + DN_Memmove(move_dest, move_src, elem_size * count[0]); DN_Memcpy(data, elems, elem_size * elems_count); } } return result; } -DN_API void *DN_ArrayAddArrayAssert(void *data, DN_USize *size, DN_USize max, DN_USize elem_size, void const *elems, DN_USize elems_count, DN_ArrayAdd add, DN_CallSite call_site) +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, size, max, elem_size, elems, elems_count, add); - DN_AssertCallSiteF(result, call_site, "Array out of space, failed to add %zu items: array=%p size=%zu max=%zu", elems_count, data, *size, max); + void *result = DN_ArrayAddArray(data, count, max, elem_size, elems, elems_count, add); + DN_AssertCallSiteF(result, call_site, "Array out of space, failed to add %zu items: array=%p size=%zu max=%zu", elems_count, data, *count, max); return result; } -DN_API bool DN_ArrayResizeFromArena(void **data, DN_USize *size, 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_Pool *pool, DN_USize new_max) { bool result = true; if (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(*size, new_max); + 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; - *max = new_max; - *size = DN_Min(*size, new_max); + *data = buffer; + *max = new_max; + *count = DN_Min(*count, new_max); } else { result = false; } @@ -8064,19 +8062,19 @@ DN_API bool DN_ArrayResizeFromArena(void **data, DN_USize *size, DN_USize *max, return result; } -DN_API bool DN_ArrayResizeFromPool(void **data, DN_USize *size, DN_USize *max, DN_USize elem_size, DN_Pool *pool, DN_USize new_max) +DN_API bool DN_ArrayResizeFromPool(void **data, DN_USize *count, DN_USize *max, DN_USize elem_size, DN_Pool *pool, DN_USize new_max) { bool result = true; if (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(*size, new_max); + 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; - *max = new_max; - *size = DN_Min(*size, new_max); + *data = buffer; + *max = new_max; + *count = DN_Min(*count, new_max); } else { result = false; } @@ -8085,18 +8083,18 @@ DN_API bool DN_ArrayResizeFromPool(void **data, DN_USize *size, DN_USize *max, D return result; } -DN_API bool DN_ArrayResizeFromArena(void **data, DN_USize *size, DN_USize *max, DN_USize elem_size, DN_Arena *arena, 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) { bool result = true; if (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(*size, new_max); + DN_USize bytes_to_copy = elem_size * DN_Min(*count, new_max); DN_Memcpy(buffer, *data, bytes_to_copy); - *data = buffer; - *max = new_max; - *size = DN_Min(*size, new_max); + *data = buffer; + *max = new_max; + *count = DN_Min(*count, new_max); } else { result = false; } @@ -8105,41 +8103,41 @@ DN_API bool DN_ArrayResizeFromArena(void **data, DN_USize *size, DN_USize *max, return result; } -DN_API bool DN_ArrayGrowFromPool(void **data, DN_USize size, DN_USize *max, DN_USize elem_size, DN_Pool *pool, DN_USize new_max) +DN_API bool DN_ArrayGrowFromPool(void **data, DN_USize count, DN_USize *max, DN_USize elem_size, DN_Pool *pool, DN_USize new_max) { bool result = true; if (new_max > *max) - result = DN_ArrayResizeFromPool(data, &size, max, elem_size, pool, new_max); + result = DN_ArrayResizeFromPool(data, &count, max, elem_size, pool, new_max); return result; } -DN_API bool DN_ArrayGrowFromArena(void **data, DN_USize size, DN_USize *max, DN_USize elem_size, DN_Arena *arena, DN_USize new_max) +DN_API bool DN_ArrayGrowFromArena(void **data, DN_USize count, DN_USize *max, DN_USize elem_size, DN_Arena *arena, DN_USize new_max) { bool result = true; if (new_max > *max) - result = DN_ArrayResizeFromArena(data, &size, max, elem_size, arena, new_max); + result = DN_ArrayResizeFromArena(data, &count, max, elem_size, arena, new_max); return result; } -DN_API bool DN_ArrayGrowIfNeededFromPool(void **data, DN_USize size, DN_USize *max, DN_USize elem_size, DN_Pool *pool, DN_USize add_count) +DN_API bool DN_ArrayGrowIfNeededFromPool(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_size = size + add_count; - if (new_size > *max) { - DN_USize new_max = DN_Max(DN_Max(*max * 2, new_size), 8); - result = DN_ArrayResizeFromPool(data, &size, max, elem_size, pool, new_max); + 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); } return result; } -DN_API bool DN_ArrayGrowIfNeededFromArena(void **data, DN_USize size, DN_USize *max, DN_USize elem_size, DN_Arena *arena, 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) { bool result = true; - DN_USize new_size = size + add_count; - if (new_size > *max) { - DN_USize new_max = DN_Max(DN_Max(*max * 2, new_size), 8); - result = DN_ArrayResizeFromArena(data, &size, max, elem_size, arena, new_max); + 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); } return result; } @@ -8590,25 +8588,25 @@ bool DN_DSMapEraseKeyStr8(DN_DSMap *map, DN_Str8 key) } template -DN_DSMapKey DN_DSMapKeyBuffer(DN_DSMap const *map, void const *data, DN_USize size) +DN_DSMapKey DN_DSMapKeyBuffer(DN_DSMap const *map, void const *data, DN_USize count) { - DN_Assert(size > 0 && size <= UINT32_MAX); + DN_Assert(count > 0 && count <= UINT32_MAX); DN_DSMapKey result = {}; result.type = DN_DSMapKeyType_Buffer; result.buffer_data = data; - result.buffer_size = DN_Cast(DN_U32) size; + result.buffer_size = DN_Cast(DN_U32) count; result.hash = DN_DSMapHash(map, result); return result; } template -DN_DSMapKey DN_DSMapKeyBufferAsU64NoHash(DN_DSMap const *map, void const *data, DN_USize size) +DN_DSMapKey DN_DSMapKeyBufferAsU64NoHash(DN_DSMap const *map, void const *data, DN_USize count) { DN_DSMapKey result = {}; result.type = DN_DSMapKeyType_BufferAsU64NoHash; result.buffer_data = data; - result.buffer_size = DN_Cast(DN_U32) size; - DN_Assert(size >= sizeof(result.hash)); + result.buffer_size = DN_Cast(DN_U32) count; + DN_Assert(count >= sizeof(result.hash)); DN_Memcpy(&result.hash, data, sizeof(result.hash)); return result; } @@ -8626,7 +8624,7 @@ DN_DSMapKey DN_DSMapKeyU64(DN_DSMap const *map, DN_U64 u64) template DN_DSMapKey DN_DSMapKeyStr8(DN_DSMap const *map, DN_Str8 string) { - DN_DSMapKey result = DN_DSMapKeyBuffer(map, string.data, string.size); + DN_DSMapKey result = DN_DSMapKeyBuffer(map, string.data, string.count); return result; } @@ -8691,25 +8689,25 @@ DN_API void DN_BinPackU64(DN_BinPack *pack, DN_BinPackMode mode, DN_U64 *item) } } -DN_API void DN_BinPackVarInt_(DN_BinPack *pack, DN_BinPackMode mode, void *item, DN_USize size) +DN_API void DN_BinPackVarInt_(DN_BinPack *pack, DN_BinPackMode mode, void *item, DN_USize count) { DN_U64 value = 0; - DN_AssertF(size <= sizeof(value), + DN_AssertF(count <= sizeof(value), "An item larger than 64 bits (%zu) is trying to be packed as a variable integer which is not supported", - size * 8); + count * 8); if (mode == DN_BinPackMode_Serialise) // Read `item` into U64 `value` - DN_Memcpy(&value, item, size); + DN_Memcpy(&value, item, count); DN_BinPackU64(pack, mode, &value); if (mode == DN_BinPackMode_Deserialise) // Write U64 `value` into `item` - DN_Memcpy(item, &value, size); + DN_Memcpy(item, &value, count); } DN_API bool DN_BinPackIsEndOfReadStream(DN_BinPack const *pack) { - bool result = pack->read_index == pack->read.size; + bool result = pack->read_index == pack->read.count; return result; } @@ -8784,25 +8782,25 @@ 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_BinPackVarInt_(pack, mode, &string->size, sizeof(string->size)); + DN_BinPackVarInt_(pack, mode, &string->count, sizeof(string->count)); if (mode == DN_BinPackMode_Serialise) { - DN_Str8BuilderAppendBytesCopy(&pack->writer, string->data, string->size); + DN_Str8BuilderAppendBytesCopy(&pack->writer, string->data, string->count); } else { - DN_Str8 src = DN_Str8Subset(pack->read, pack->read_index, string->size); - *string = DN_Str8FromStr8Arena(src, arena); - pack->read_index += src.size; + DN_Str8 src = DN_Str8Subset(pack->read, pack->read_index, string->count); + *string = DN_Str8FromStr8Arena(src, arena); + pack->read_index += src.count; } } DN_API void DN_BinPackStr8FromPool(DN_BinPack *pack, DN_Pool *pool, DN_BinPackMode mode, DN_Str8 *string) { - DN_BinPackVarInt_(pack, mode, &string->size, sizeof(string->size)); + DN_BinPackVarInt_(pack, mode, &string->count, sizeof(string->count)); if (mode == DN_BinPackMode_Serialise) { - DN_Str8BuilderAppendBytesCopy(&pack->writer, string->data, string->size); + DN_Str8BuilderAppendBytesCopy(&pack->writer, string->data, string->count); } else { - DN_Str8 src = DN_Str8Subset(pack->read, pack->read_index, string->size); - *string = DN_Str8FromStr8Pool(src, pool); - pack->read_index += src.size; + DN_Str8 src = DN_Str8Subset(pack->read, pack->read_index, string->count); + *string = DN_Str8FromStr8Pool(src, pool); + pack->read_index += src.count; } } @@ -8818,7 +8816,7 @@ DN_API void DN_BinPackBytesFromArena(DN_BinPack *pack, DN_Arena *arena, DN_BinPa DN_Str8 string = DN_Str8FromPtr(*ptr, *size); DN_BinPackStr8FromArena(pack, arena, mode, &string); *ptr = string.data; - *size = string.size; + *size = string.count; } DN_API void DN_BinPackBytesFromPool(DN_BinPack *pack, DN_Pool *pool, DN_BinPackMode mode, void **ptr, DN_USize *size) @@ -8826,7 +8824,7 @@ DN_API void DN_BinPackBytesFromPool(DN_BinPack *pack, DN_Pool *pool, DN_BinPackM DN_Str8 string = DN_Str8FromPtr(*ptr, *size); DN_BinPackStr8FromPool(pack, pool, mode, &string); *ptr = string.data; - *size = string.size; + *size = string.count; } DN_API void DN_BinPackCArray(DN_BinPack *pack, DN_BinPackMode mode, void *ptr, DN_USize size) @@ -8836,9 +8834,9 @@ DN_API void DN_BinPackCArray(DN_BinPack *pack, DN_BinPackMode mode, void *ptr, D DN_Str8BuilderAppendBytesCopy(&pack->writer, ptr, size); } else { DN_Str8 src = DN_Str8Subset(pack->read, pack->read_index, size); - DN_Assert(src.size == size); - DN_Memcpy(ptr, src.data, DN_Min(src.size, size)); - pack->read_index += src.size; + DN_Assert(src.count == size); + DN_Memcpy(ptr, src.data, DN_Min(src.count, size)); + pack->read_index += src.count; } } @@ -8881,7 +8879,7 @@ DN_API bool DN_CSVTokeniserValid(DN_CSVTokeniser *tokeniser) static void DN_CSVTokeniserEatNewLines_(DN_CSVTokeniser *tokeniser) { - char const *end = tokeniser->string.data + tokeniser->string.size; + char const *end = tokeniser->string.data + tokeniser->string.count; while (tokeniser->it[0] == '\n' || tokeniser->it[0] == '\r') if (++tokeniser->it == end) break; @@ -8890,12 +8888,12 @@ static void DN_CSVTokeniserEatNewLines_(DN_CSVTokeniser *tokeniser) DN_API bool DN_CSVTokeniserNextRow(DN_CSVTokeniser *tokeniser) { bool result = false; - if (DN_CSVTokeniserValid(tokeniser) && tokeniser->string.size) { + if (DN_CSVTokeniserValid(tokeniser) && tokeniser->string.count) { // NOTE: First time querying row iterator is nil, let tokeniser advance if (tokeniser->it) { // NOTE: Only advance the tokeniser if we're at the end of the line and // there's more to tokenise. - char const *end = tokeniser->string.data + tokeniser->string.size; + char const *end = tokeniser->string.data + tokeniser->string.count; if (tokeniser->it != end && tokeniser->end_of_line) { tokeniser->end_of_line = false; result = true; @@ -8912,13 +8910,13 @@ DN_API DN_Str8 DN_CSVTokeniserNextField(DN_CSVTokeniser *tokeniser) if (!DN_CSVTokeniserValid(tokeniser)) return result; - if (tokeniser->string.size == 0) { + if (tokeniser->string.count == 0) { tokeniser->bad = true; return result; } // NOTE: First time tokeniser is invoked with a string, set up initial state. - char const *string_end = tokeniser->string.data + tokeniser->string.size; + char const *string_end = tokeniser->string.data + tokeniser->string.count; if (!tokeniser->it) { tokeniser->it = tokeniser->string.data; DN_CSVTokeniserEatNewLines_(tokeniser); // NOTE: Skip any leading new lines @@ -8981,7 +8979,7 @@ DN_API DN_Str8 DN_CSVTokeniserNextField(DN_CSVTokeniser *tokeniser) // NOTE: Generate the record result.data = DN_Cast(char *) begin; - result.size = DN_Cast(int)(end - begin); + result.count = DN_Cast(int)(end - begin); return result; } @@ -9126,7 +9124,7 @@ DN_API void DN_CSVPackBuffer(DN_CSVPack *pack, DN_CSVSerialise serialise, void * { if (serialise == DN_CSVSerialise_Read) { DN_Str8 csv_value = DN_CSVTokeniserNextColumn(&pack->read_tokeniser); - *size = DN_Min(*size, csv_value.size); + *size = DN_Min(*size, csv_value.count); DN_Memcpy(dest, csv_value.data, *size); } else { DN_Str8BuilderAppendF(&pack->write_builder, "%s%.*s", pack->write_column++ ? "," : "", DN_Cast(int)(*size), DN_Cast(char *)dest); @@ -9189,8 +9187,8 @@ DN_API void DN_LeakTrackAlloc_(DN_LeakTracker *leak, void *ptr, DN_USize size, b } // NOTE: Pointer was reused, clean up the prior entry - leak->alloc_table_bytes_allocated_for_stack_traces -= alloc->stack_trace.size; - leak->alloc_table_bytes_allocated_for_stack_traces -= alloc->freed_stack_trace.size; + leak->alloc_table_bytes_allocated_for_stack_traces -= alloc->stack_trace.count; + leak->alloc_table_bytes_allocated_for_stack_traces -= alloc->freed_stack_trace.count; DN_OS_MemDealloc(alloc->stack_trace.data); DN_OS_MemDealloc(alloc->freed_stack_trace.data); @@ -9201,7 +9199,7 @@ DN_API void DN_LeakTrackAlloc_(DN_LeakTracker *leak, void *ptr, DN_USize size, b alloc->size = size; alloc->stack_trace = stack_trace; alloc->flags |= leak_permitted ? DN_LeakAllocFlag_LeakPermitted : 0; - leak->alloc_table_bytes_allocated_for_stack_traces += alloc->stack_trace.size; + leak->alloc_table_bytes_allocated_for_stack_traces += alloc->stack_trace.count; DN_TicketMutex_End(&leak->alloc_table_mutex); } @@ -9247,10 +9245,10 @@ DN_API void DN_LeakTrackDealloc_(DN_LeakTracker *leak, void *ptr) DN_Str8PrintFmt(stack_trace)); } - DN_Assert(alloc->freed_stack_trace.size == 0); + DN_Assert(alloc->freed_stack_trace.count == 0); alloc->flags |= DN_LeakAllocFlag_Freed; alloc->freed_stack_trace = stack_trace; - leak->alloc_table_bytes_allocated_for_stack_traces += alloc->freed_stack_trace.size; + leak->alloc_table_bytes_allocated_for_stack_traces += alloc->freed_stack_trace.count; DN_TicketMutex_End(&leak->alloc_table_mutex); } @@ -9372,20 +9370,20 @@ DN_API DN_Str8 DN_Str8FromHeapF(DN_FMT_ATTRIB char const *fmt, ...) { va_list args; va_start(args, fmt); - DN_USize size = DN_FmtVSize(fmt, args); - DN_Str8 result = DN_Str8FromHeap(size, DN_ZMem_No); - DN_VSNPrintF(result.data, DN_Cast(int)(result.size + 1), fmt, args); + DN_USize count = DN_FmtVCount(fmt, args); + DN_Str8 result = DN_Str8FromHeap(count, DN_ZMem_No); + DN_VSNPrintF(result.data, DN_Cast(int)(result.count + 1), fmt, args); va_end(args); return result; } -DN_API DN_Str8 DN_Str8FromHeap(DN_USize size, DN_ZMem z_mem) +DN_API DN_Str8 DN_Str8FromHeap(DN_USize count, DN_ZMem z_mem) { DN_Str8 result = {}; - result.data = DN_Cast(char *)DN_OS_MemAlloc(size + 1, z_mem); + result.data = DN_Cast(char *)DN_OS_MemAlloc(count + 1, z_mem); if (result.data) { - result.size = size; - result.data[result.size] = 0; + result.count = count; + result.data[result.count] = 0; } return result; } @@ -9396,11 +9394,11 @@ DN_API DN_Str8 DN_Str8PadNewLines(DN_Arena *arena, DN_Str8 src, DN_Str8 pad) DN_TCScratch scratch = DN_TCScratchBeginArena(&arena, 1); DN_Str8Builder builder = DN_Str8BuilderFromArena(&scratch.arena); DN_Str8BSplitResult split = DN_Str8BSplit(src, DN_Str8Lit("\n")); - while (split.lhs.size) { + while (split.lhs.count) { DN_Str8BuilderAppendRef(&builder, pad); DN_Str8BuilderAppendRef(&builder, split.lhs); split = DN_Str8BSplit(split.rhs, DN_Str8Lit("\n")); - if (split.lhs.size) + if (split.lhs.count) DN_Str8BuilderAppendRef(&builder, DN_Str8Lit("\n")); } DN_Str8 result = DN_Str8FromStr8BuilderArena(&builder, arena); @@ -9419,12 +9417,12 @@ DN_API DN_Str8 DN_Str8BuilderBuildFromHeap(DN_Str8Builder const *builder) return result; for (DN_Str8Link *link = builder->head; link; link = link->next) { - DN_Memcpy(result.data + result.size, link->string.data, link->string.size); - result.size += link->string.size; + DN_Memcpy(result.data + result.count, link->string.data, link->string.count); + result.count += link->string.count; } - result.data[result.size] = 0; - DN_Assert(result.size == builder->string_size); + result.data[result.count] = 0; + DN_Assert(result.count == builder->string_size); return result; } @@ -9492,7 +9490,7 @@ DN_API void DN_OS_LogPrint(DN_LogTypeParam type, void *user_data, DN_CallSite ca DN_TicketMutex_Begin(&os->log_file_mutex); { if (print_prefix) { - DN_OS_FileWrite(&os->log_file, DN_Str8FromPtr(prefix_buffer, prefix_size.size), nullptr); + DN_OS_FileWrite(&os->log_file, DN_Str8FromPtr(prefix_buffer, prefix_size.count), nullptr); DN_OS_FileWriteF(&os->log_file, nullptr, "%*s ", DN_Cast(int) prefix_size.padding, ""); } DN_OS_FileWriteFV(&os->log_file, nullptr, fmt, args_copy); @@ -9505,7 +9503,7 @@ DN_API void DN_OS_LogPrint(DN_LogTypeParam type, void *user_data, DN_CallSite ca DN_TicketMutex_Begin(&os->log_mutex); { if (print_prefix) - DN_OS_PrintF(DN_OSPrintDest_Err, "%.*s%*s ", DN_Cast(int) prefix_size.size, prefix_buffer, DN_Cast(int) prefix_size.padding, ""); + DN_OS_PrintF(DN_OSPrintDest_Err, "%.*s%*s ", DN_Cast(int) prefix_size.count, prefix_buffer, DN_Cast(int) prefix_size.padding, ""); if (DN_BitIsSet(flags, DN_LogFlags_NoNewLine)) DN_OS_PrintFV(DN_OSPrintDest_Err, fmt, args); @@ -9656,7 +9654,7 @@ DN_API bool DN_OS_PathIsOlderThan(DN_Str8 path, DN_Str8 check_against) DN_API bool DN_OS_FileWrite(DN_OSFile *file, DN_Str8 buffer, DN_ErrSink *error) { - bool result = DN_OS_FileWritePtr(file, buffer.data, buffer.size, error); + bool result = DN_OS_FileWritePtr(file, buffer.data, buffer.count, error); return result; } @@ -9729,7 +9727,7 @@ DN_API DN_Str8 DN_OS_FileReadAll(DN_Allocator allocator, DN_Str8 path, DN_ErrSin // NOTE: Read all DN_OSFile file = DN_OS_FileOpen(path, DN_OSFileOpen_OpenIfExist, DN_OSFileAccess_Read, err); - DN_OSFileRead read = DN_OS_FileRead(&file, result.data, result.size, err); + DN_OSFileRead read = DN_OS_FileRead(&file, result.data, result.count, err); bool failed = file.error || !read.success; if (allocator.type == DN_AllocatorType_Arena) { @@ -9842,10 +9840,10 @@ DN_API DN_Str8 DN_OS_Str8FromPathInfoType(DN_OSPathInfoType type) DN_API bool DN_OS_PathAddRef(DN_Arena *arena, DN_OSPath *fs_path, DN_Str8 path) { - if (!arena || !fs_path || path.size == 0) + if (!arena || !fs_path || path.count == 0) return false; - if (path.size <= 0) + if (path.count <= 0) return true; DN_Str8 const delimiter_array[] = { @@ -9858,7 +9856,7 @@ DN_API bool DN_OS_PathAddRef(DN_Arena *arena, DN_OSPath *fs_path, DN_Str8 path) for (;;) { DN_Str8BSplitResult delimiter = DN_Str8BSplitArray(path, delimiter_array, DN_ArrayCountU(delimiter_array)); for (; delimiter.lhs.data; delimiter = DN_Str8BSplitArray(delimiter.rhs, delimiter_array, DN_ArrayCountU(delimiter_array))) { - if (delimiter.lhs.size <= 0) + if (delimiter.lhs.count <= 0) continue; DN_OSPathLink *link = DN_ArenaNew(arena, DN_OSPathLink, DN_ZMem_Yes); @@ -9873,7 +9871,7 @@ DN_API bool DN_OS_PathAddRef(DN_Arena *arena, DN_OSPath *fs_path, DN_Str8 path) fs_path->head = link; fs_path->tail = link; fs_path->links_size += 1; - fs_path->string_size += delimiter.lhs.size; + fs_path->string_size += delimiter.lhs.count; } if (!delimiter.lhs.data) @@ -9886,7 +9884,7 @@ DN_API bool DN_OS_PathAddRef(DN_Arena *arena, DN_OSPath *fs_path, DN_Str8 path) DN_API bool DN_OS_PathAdd(DN_Arena *arena, DN_OSPath *fs_path, DN_Str8 path) { DN_Str8 copy = DN_Str8FromStr8Arena(path, arena); - bool result = copy.size ? true : DN_OS_PathAddRef(arena, fs_path, copy); + bool result = copy.count ? true : DN_OS_PathAddRef(arena, fs_path, copy); return result; } @@ -9908,7 +9906,7 @@ DN_API bool DN_OS_PathPop(DN_OSPath *fs_path) if (fs_path->tail) { DN_Assert(fs_path->head); fs_path->links_size -= 1; - fs_path->string_size -= fs_path->tail->string.size; + fs_path->string_size -= fs_path->tail->string.count; fs_path->tail = fs_path->tail->prev; if (fs_path->tail) fs_path->tail->next = nullptr; @@ -9966,23 +9964,23 @@ DN_API DN_Str8 DN_OS_PathBuildWithSeparator(DN_Arena *arena, DN_OSPath const *fs return result; // NOTE: Each link except the last one needs the path separator appended to it, '/' or '\\' - DN_USize string_size = (fs_path->has_prefix_path_separator ? path_separator.size : 0) + fs_path->string_size + ((fs_path->links_size - 1) * path_separator.size); + DN_USize string_size = (fs_path->has_prefix_path_separator ? path_separator.count : 0) + fs_path->string_size + ((fs_path->links_size - 1) * path_separator.count); result = DN_Str8AllocArena(string_size, DN_ZMem_No, arena); if (result.data) { char *dest = result.data; if (fs_path->has_prefix_path_separator) { - DN_Memcpy(dest, path_separator.data, path_separator.size); - dest += path_separator.size; + DN_Memcpy(dest, path_separator.data, path_separator.count); + dest += path_separator.count; } for (DN_OSPathLink *link = fs_path->head; link; link = link->next) { DN_Str8 string = link->string; - DN_Memcpy(dest, string.data, string.size); - dest += string.size; + DN_Memcpy(dest, string.data, string.count); + dest += string.count; if (link != fs_path->tail) { - DN_Memcpy(dest, path_separator.data, path_separator.size); - dest += path_separator.size; + DN_Memcpy(dest, path_separator.data, path_separator.count); + dest += path_separator.count; } } } @@ -10036,7 +10034,7 @@ DN_API void DN_OS_ThreadSetNameFmt(char const *fmt, ...) tls->name = DN_Str8x64FromFmtV(fmt, args); va_end(args); - DN_Str8 name = DN_Str8FromPtr(tls->name.data, tls->name.size); + DN_Str8 name = DN_Str8FromPtr(tls->name.data, tls->name.count); #if defined(DN_PLATFORM_WIN32) DN_OS_W32ThreadSetName(name); #else @@ -10333,13 +10331,13 @@ DN_API void DN_OS_Print(DN_OSPrintDest dest, DN_Str8 string) } // NOTE: Write the string - DN_Assert(string.size < DN_Cast(unsigned long) - 1); + DN_Assert(string.count < DN_Cast(unsigned long) - 1); unsigned long bytes_written = 0; (void)bytes_written; if (print_to_console) - WriteConsoleA(print_handle, string.data, DN_Cast(unsigned long) string.size, &bytes_written, nullptr); + WriteConsoleA(print_handle, string.data, DN_Cast(unsigned long) string.count, &bytes_written, nullptr); else - WriteFile(print_handle, string.data, DN_Cast(unsigned long) string.size, &bytes_written, nullptr); + WriteFile(print_handle, string.data, DN_Cast(unsigned long) string.count, &bytes_written, nullptr); #else fprintf(dest == DN_OSPrintDest_Out ? stdout : stderr, "%.*s", DN_Str8PrintFmt(string)); #endif @@ -10363,7 +10361,7 @@ DN_API void DN_OS_PrintFStyle(DN_OSPrintDest dest, DN_LogStyle style, DN_FMT_ATT DN_API void DN_OS_PrintStyle(DN_OSPrintDest dest, DN_LogStyle style, DN_Str8 string) { - if (string.data && string.size) { + if (string.data && string.count) { if (style.colour) { DN_Str8x32 colour = DN_Str8x32FromANSIColourCodeU8RGB(DN_ANSIColourMode_Fg, style.r, style.g, style.b); DN_OS_Print(dest, DN_Str8FromStruct(&colour)); @@ -10380,7 +10378,7 @@ static char *DN_OS_PrintVSPrintfChunker_(const char *buf, void *user, int len) { DN_Str8 string = {}; string.data = DN_Cast(char *) buf; - string.size = len; + string.count = len; DN_OSPrintDest dest = DN_Cast(DN_OSPrintDest) DN_Cast(uintptr_t) user; DN_OS_Print(dest, string); @@ -10652,7 +10650,7 @@ DN_API DN_StackTraceFrame DN_StackTraceRawFrameToFrame(DN_Arena *arena, DN_Stack // NOTE: Construct result - DN_Str16 file_name16 = DN_Str16FromPtr(line.FileName, DN_CStr16Size(line.FileName)); + DN_Str16 file_name16 = DN_Str16FromPtr(line.FileName, DN_CStr16Count(line.FileName)); DN_Str16 function_name16 = DN_Str16FromPtr(symbol->Name, symbol->NameLen); DN_StackTraceFrame result = {}; @@ -10661,9 +10659,9 @@ DN_API DN_StackTraceFrame DN_StackTraceRawFrameToFrame(DN_Arena *arena, DN_Stack result.file_name = DN_OS_W32Str16ToStr8(arena, file_name16); result.function_name = DN_OS_W32Str16ToStr8(arena, function_name16); - if (result.function_name.size == 0) + if (result.function_name.count == 0) result.function_name = DN_Str8Lit(""); - if (result.file_name.size == 0) + if (result.file_name.count == 0) result.file_name = DN_Str8Lit(""); #else DN_StackTraceFrame result = {}; @@ -10750,6 +10748,18 @@ bool DN_NET_ResponseHasFailed(DN_NETResponse const* resp) return result; } +bool DN_NET_ResponseHasSucceeded(DN_NETResponse const* resp) +{ + bool result = !DN_NET_ResponseHasFailed(resp); + return result; +} + +bool DN_NET_ResponseIsReady(DN_NETResponse const* resp) +{ + bool result = resp && resp->state != DN_NETResponseState_Nil; + return result; +} + DN_Str8 DN_NET_Str8DiagnosticFromResponse(DN_NETResponse const* resp, DN_Arena *arena) { DN_TCScratch scratch = DN_TCScratchBeginArena(&arena, 1); @@ -10761,12 +10771,12 @@ DN_Str8 DN_NET_Str8DiagnosticFromResponse(DN_NETResponse const* resp, DN_Arena * DN_Str8BuilderAppendF(&builder, " %u", resp->http_status); } DN_Str8BuilderAppendF(&builder, ")"); - if (resp->body.size || resp->error_str8.size) { + if (resp->body.count || resp->error_str8.count) { DN_Str8BuilderAppendRef(&builder, DN_Str8Lit(" with ")); - if (resp->body.size) + if (resp->body.count) DN_Str8BuilderAppendF(&builder, "%.*s", DN_Str8PrintFmt(resp->body)); - if (resp->error_str8.size) - DN_Str8BuilderAppendF(&builder, "%s%.*s", resp->body.size ? ". " : "", DN_Str8PrintFmt(resp->error_str8)); + if (resp->error_str8.count) + DN_Str8BuilderAppendF(&builder, "%s%.*s", resp->body.count ? ". " : "", DN_Str8PrintFmt(resp->error_str8)); } DN_Str8 result = DN_Str8FromStr8BuilderArena(&builder, arena); DN_TCScratchEnd(&scratch); @@ -10847,7 +10857,7 @@ enum DN_NETCurlRingEventType DN_NETCurlRingEventType_DeinitRequest, }; -struct DN_NETCurlRingEvent +struct DN_NETCurlRingEvent_ { DN_NETCurlRingEventType type; DN_NETRequestHandle request; @@ -10919,18 +10929,18 @@ static int32_t DN_NET_CurlThreadEntryPoint_(DN_OSThread *thread) // NOTE: Handle events sitting in the ring queue for (bool dequeue_ring = true; dequeue_ring;) { - DN_NETCurlRingEvent event = {}; + DN_NETCurlRingEvent_ event = {}; for (DN_OS_MutexScope(&curl->ring_mutex)) { if (DN_RingHasData(&curl->ring, sizeof(event))) DN_RingRead(&curl->ring, &event, sizeof(event)); } - DN_NETRequest *req = DN_NET_RequestFromHandle(event.request); - DN_NETCurlRequest *curl_req = DN_NET_CurlRequestFromRequest_(req); switch (event.type) { case DN_NETCurlRingEventType_Nil: dequeue_ring = false; break; case DN_NETCurlRingEventType_DoRequest: { + DN_NETRequest *req = DN_NET_RequestFromHandle(event.request); + DN_NETCurlRequest *curl_req = DN_NET_CurlRequestFromRequest_(req); DN_Assert(req->response.state == DN_NETResponseState_Nil); DN_Assert(req->type != DN_NETRequestType_Nil); @@ -10948,11 +10958,13 @@ static int32_t DN_NET_CurlThreadEntryPoint_(DN_OSThread *thread) } break; case DN_NETCurlRingEventType_SendWS: { + DN_NETRequest *req = DN_NET_RequestFromHandle(event.request); + DN_NETCurlRequest *curl_req = DN_NET_CurlRequestFromRequest_(req); DN_Str8 payload = {}; for (DN_OS_MutexScope(&curl->ring_mutex)) { DN_Assert(DN_RingHasData(&curl->ring, event.ws_send_size)); payload = DN_Str8AllocArena(event.ws_send_size, DN_ZMem_No, &tmem.arena); - DN_RingRead(&curl->ring, payload.data, payload.size); + DN_RingRead(&curl->ring, payload.data, payload.count); } DN_U32 curlws_flag = 0; @@ -10968,12 +10980,14 @@ static int32_t DN_NET_CurlThreadEntryPoint_(DN_OSThread *thread) DN_Assert(req->response.state >= DN_NETResponseState_WSOpen && req->response.state <= DN_NETResponseState_WSPong); DN_USize sent = 0; - CURLcode send_result = curl_ws_send(curl_req->handle, payload.data, payload.size, &sent, 0, curlws_flag); + CURLcode send_result = curl_ws_send(curl_req->handle, payload.data, payload.count, &sent, 0, curlws_flag); DN_AssertF(send_result == CURLE_OK, "Failed to send: %s", curl_easy_strerror(send_result)); - DN_AssertF(sent == payload.size, "Failed to send all bytes (%zu vs %zu)", sent, payload.size); + DN_AssertF(sent == payload.count, "Failed to send all bytes (%zu vs %zu)", sent, payload.count); } break; case DN_NETCurlRingEventType_ReceivedWSReceipt: { + DN_NETRequest *req = DN_NET_RequestFromHandle(event.request); + DN_NETCurlRequest *curl_req = DN_NET_CurlRequestFromRequest_(req); DN_Assert(req->type == DN_NETRequestType_WS); DN_Assert(req->response.state >= DN_NETResponseState_WSOpen && req->response.state <= DN_NETResponseState_WSPong); req->response.state = DN_NETResponseState_WSOpen; @@ -10993,6 +11007,9 @@ static int32_t DN_NET_CurlThreadEntryPoint_(DN_OSThread *thread) } break; case DN_NETCurlRingEventType_DeinitRequest: { + DN_NETRequest *req = DN_NET_RequestFromHandle(event.request); + DN_NETCurlRequest *curl_req = DN_NET_CurlRequestFromRequest_(req); + DN_Assert(event.request.handle != 0); DN_NETRequest *request = DN_Cast(DN_NETRequest *) event.request.handle; @@ -11018,7 +11035,7 @@ static int32_t DN_NET_CurlThreadEntryPoint_(DN_OSThread *thread) // NOTE: Zero the struct preserving just the data we need to retain DN_NETRequest resetter = {}; resetter.arena = request->arena; - resetter.gen = request->gen; + resetter.gen = request->gen + 1; DN_Memcpy(resetter.context, request->context, sizeof(resetter.context)); *request = resetter; @@ -11064,7 +11081,7 @@ static int32_t DN_NET_CurlThreadEntryPoint_(DN_OSThread *thread) req->response.state = DN_NETResponseState_Error; } } else { - DN_USize curl_extended_error_size = DN_CStr8Size(curl_req->error); + DN_USize curl_extended_error_size = DN_CStr8Count(curl_req->error); req->response.state = DN_NETResponseState_Error; req->response.error_str8 = DN_Str8FromFmtArena(&req->start_response_arena, "HTTP request '%.*s' failed (CURL %d): %s%s%s%s", @@ -11140,9 +11157,9 @@ static int32_t DN_NET_CurlThreadEntryPoint_(DN_OSThread *thread) // NOTE: Allocate and read (we use meta->bytesleft as per comment from initial recv) if (meta->bytesleft) { DN_Str8 buffer = DN_Str8AllocArena(meta->bytesleft, DN_ZMem_No, &req->start_response_arena); - DN_Assert(buffer.size == DN_Cast(DN_USize)meta->bytesleft); - receive_result = curl_ws_recv(curl_req->handle, buffer.data, buffer.size, &buffer.size, &meta); - DN_Assert(buffer.size == DN_Cast(DN_USize)meta->len); + DN_Assert(buffer.count == DN_Cast(DN_USize)meta->bytesleft); + receive_result = curl_ws_recv(curl_req->handle, buffer.data, buffer.count, &buffer.count, &meta); + DN_Assert(buffer.count == DN_Cast(DN_USize)meta->len); DN_Str8BuilderAppendRef(&curl_req->str8_builder, buffer); } @@ -11187,7 +11204,7 @@ static int32_t DN_NET_CurlThreadEntryPoint_(DN_OSThread *thread) if (receive_result == CURLE_GOT_NOTHING) { req->response.state = DN_NETResponseState_WSClose; } else if (receive_result != CURLE_OK) { - DN_USize curl_extended_error_size = DN_CStr8Size(curl_req->error); + DN_USize curl_extended_error_size = DN_CStr8Count(curl_req->error); req->response.state = DN_NETResponseState_Error; req->response.error_str8 = DN_Str8FromFmtArena(&req->start_response_arena, "Websocket receive '%.*s' failed (CURL %d): %s%s%s%s", @@ -11244,7 +11261,7 @@ void DN_NET_CurlInit(DN_NETCore *net, char *base, DN_U64 base_size) curl->list_mutex = DN_OS_MutexInit(); curl->thread_curlm = DN_Cast(CURLM *) curl_multi_init(); - DN_FmtAppend(curl->thread.name.data, &curl->thread.name.size, sizeof(curl->thread.name.data), "NET (CURL)"); + DN_FmtAppend(curl->thread.name.data, &curl->thread.name.count, sizeof(curl->thread.name.data), "NET (CURL)"); DN_OS_ThreadInit(&curl->thread, DN_NET_CurlThreadEntryPoint_, nullptr, DN_TCInitArgsDefault(), net); } @@ -11313,7 +11330,7 @@ static DN_NETRequestHandle DN_NET_CurlDoRequest_(DN_NETCore *net, DN_Str8 url, D // NOTE: Assign HTTP headers for (DN_ForItSize(it, DN_Str8, req->args.headers, req->args.headers_size)) { - DN_Assert(it.data->data[it.data->size] == 0); + DN_Assert(it.data->data[it.data->count] == 0); curl_req->slist = curl_slist_append(curl_req->slist, it.data->data); } curl_easy_setopt(curl, CURLOPT_HTTPHEADER, curl_req->slist); @@ -11334,10 +11351,10 @@ static DN_NETRequestHandle DN_NET_CurlDoRequest_(DN_NETCore *net, DN_Str8 url, D curl_easy_setopt(curl, CURLOPT_HTTPGET, 1); } else if (DN_Str8EqInsensitive(req->method, POST)) { curl_easy_setopt(curl, CURLOPT_POST, 1); - if (req->args.payload.size > DN_Gigabytes(2)) - curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE_LARGE, req->args.payload.size); + if (req->args.payload.count > DN_Gigabytes(2)) + curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE_LARGE, req->args.payload.count); else - curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, req->args.payload.size); + curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, req->args.payload.count); curl_easy_setopt(curl, CURLOPT_COPYPOSTFIELDS, req->args.payload.data); } else { DN_AssertInvalidCodePathF("Unimplemented"); @@ -11347,13 +11364,20 @@ static DN_NETRequestHandle DN_NET_CurlDoRequest_(DN_NETCore *net, DN_Str8 url, D // NOTE: Handle basic auth if (req->args.flags & DN_NETDoHTTPFlags_BasicAuth) { - if (req->args.username.size && req->args.password.size) { - DN_Assert(req->args.username.data[req->args.username.size] == 0); - DN_Assert(req->args.password.data[req->args.password.size] == 0); + if (req->args.username.count && req->args.password.count) { + DN_Assert(req->args.username.data[req->args.username.count] == 0); + DN_Assert(req->args.password.data[req->args.password.count] == 0); curl_easy_setopt(curl, CURLOPT_USERNAME, req->args.username.data); curl_easy_setopt(curl, CURLOPT_PASSWORD, req->args.password.data); } } + + if (req->args.flags & DN_NETDoHTTPFlags_DisableSSLVerify) { + // NOTE: Disable peer verification (checks if cert is signed by trusted CA) + // NOTE: Disable host verification (checks if cert matches hostname) + curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L); + curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0L); + } } // NOTE: Dispatch the request to the CURL thread @@ -11367,9 +11391,9 @@ static DN_NETRequestHandle DN_NET_CurlDoRequest_(DN_NETCore *net, DN_Str8 url, D // NOTE: Enqueue request to go into CURL's ring queue. The CURL thread will sleep and wait for // bytes to come in for the request and then dump the response into the done list to be consumed // via wait for response - DN_NETCurlRingEvent event = {}; - event.type = DN_NETCurlRingEventType_DoRequest; - event.request = result; + DN_NETCurlRingEvent_ event = {}; + event.type = DN_NETCurlRingEventType_DoRequest; + event.request = result; for (DN_OS_MutexScope(&curl_core->ring_mutex)) DN_RingWriteStruct(&curl_core->ring, &event); @@ -11407,16 +11431,16 @@ void DN_NET_CurlDoWSSend(DN_NETRequestHandle handle, DN_Str8 payload, DN_NETWSSe DN_NETCurlCore *curl = DN_Cast(DN_NETCurlCore *) net->context; DN_Assert(curl); - DN_NETCurlRingEvent event = {}; + DN_NETCurlRingEvent_ event = {}; event.type = DN_NETCurlRingEventType_SendWS; event.request = handle; - event.ws_send_size = payload.size; + event.ws_send_size = payload.count; event.ws_send = send; for (DN_OS_MutexScope(&curl->ring_mutex)) { - DN_Assert(DN_RingHasSpace(&curl->ring, payload.size)); + DN_Assert(DN_RingHasSpace(&curl->ring, payload.count)); DN_RingWriteStruct(&curl->ring, &event); - DN_RingWrite(&curl->ring, payload.data, payload.size); + DN_RingWrite(&curl->ring, payload.data, payload.count); } curl_multi_wakeup(curl->thread_curlm); } @@ -11428,7 +11452,7 @@ static DN_NETResponse DN_NET_CurlHandleFinishedRequest_(DN_NETCurlCore *curl, DN DN_NETCurlRequest *curl_req = DN_NET_CurlRequestFromRequest_(req); { result.body = DN_Str8FromStr8BuilderArena(&curl_req->str8_builder, arena); - if (result.error_str8.size) + if (result.error_str8.count) result.error_str8 = DN_Str8FromStr8Arena(result.error_str8, arena); } @@ -11457,10 +11481,9 @@ static DN_NETResponse DN_NET_CurlHandleFinishedRequest_(DN_NETCurlCore *curl, DN DN_DoublyLLAppend(curl->deinit_list, req); } - // NOTE: Submit the post-request event to the CURL thread - DN_NETCurlRingEvent event = {}; - event.request = DN_NET_HandleFromRequest(req); + DN_NETCurlRingEvent_ event = {}; + event.request = DN_NET_HandleFromRequest(req); if (continue_ws_request) { event.type = DN_NETCurlRingEventType_ReceivedWSReceipt; } else { @@ -11737,7 +11760,7 @@ DN_NETRequestHandle DN_NET_EmcDoHTTP(DN_NETCore *net, DN_Str8 url, DN_Str8 metho if (req->args.headers_size) { char **headers = DN_ArenaNewArray(&req->start_response_arena, char *, req->args.headers_size + 1, DN_ZMem_Yes); for (DN_ForItSize(it, DN_Str8, req->args.headers, req->args.headers_size)) { - DN_Assert(it.data->data[it.data->size] == 0); + DN_Assert(it.data->data[it.data->count] == 0); headers[it.index] = it.data->data; } fetch_attribs.requestHeaders = headers; @@ -11906,6 +11929,7 @@ static DN_NETResponse DN_NET_EmcHandleFinishedRequest_(DN_NETCore *net, DN_NETEm DN_NETEmcCore *emc = DN_Cast(DN_NETEmcCore *) net->context; request->next = emc->free_list; request->prev = nullptr; + request->gen++; emc->free_list = request; } diff --git a/Source/dn.h b/Source/dn.h index 6267aed..8ec373b 100644 --- a/Source/dn.h +++ b/Source/dn.h @@ -760,7 +760,7 @@ enum DN_ZMem struct DN_Str8 { char *data; // The bytes of the string - DN_USize size; // The number of bytes in the string + DN_USize count; // The number of bytes in the string }; struct DN_Str8Slice @@ -769,18 +769,18 @@ struct DN_Str8Slice DN_USize count; }; -struct DN_Str8x16 { char data[16]; DN_USize size; }; -struct DN_Str8x32 { char data[32]; DN_USize size; }; -struct DN_Str8x64 { char data[64]; DN_USize size; }; -struct DN_Str8x128 { char data[128]; DN_USize size; }; -struct DN_Str8x256 { char data[256]; DN_USize size; }; -struct DN_Str8x512 { char data[512]; DN_USize size; }; -struct DN_Str8x1024 { char data[1024]; DN_USize size; }; +struct DN_Str8x16 { char data[16]; DN_USize count; }; +struct DN_Str8x32 { char data[32]; DN_USize count; }; +struct DN_Str8x64 { char data[64]; DN_USize count; }; +struct DN_Str8x128 { char data[128]; DN_USize count; }; +struct DN_Str8x256 { char data[256]; DN_USize count; }; +struct DN_Str8x512 { char data[512]; DN_USize count; }; +struct DN_Str8x1024 { char data[1024]; DN_USize count; }; struct DN_Str16 // A pointer and length style string that holds slices to UTF16 bytes. { - wchar_t *data; // The UTF16 bytes of the string - DN_USize size; // The number of characters in the string + wchar_t *data; // The UTF16 bytes of the string + DN_USize count; // The number of characters in the string }; struct DN_Str16Slice @@ -895,14 +895,14 @@ struct DN_TicketMutex }; -struct DN_Hex32 { char data[32 + 1]; DN_USize size; }; -struct DN_Hex64 { char data[64 + 1]; DN_USize size; }; -struct DN_Hex128 { char data[128 + 1]; DN_USize size; }; +struct DN_Hex32 { char data[32 + 1]; DN_USize count; }; +struct DN_Hex64 { char data[64 + 1]; DN_USize count; }; +struct DN_Hex128 { char data[128 + 1]; DN_USize count; }; struct DN_HexU64 { char data[(sizeof(DN_U64) * 2) + 1 /*null-terminator*/]; - DN_U8 size; + DN_U8 count; }; enum DN_HexFromU64Type @@ -1095,11 +1095,11 @@ enum DN_MemFuncsType DN_MemFuncsType_Virtual, }; -typedef void *(DN_MemHeapAllocFunc)(DN_USize size); +typedef void *(DN_MemHeapAllocFunc)(DN_USize count); typedef void (DN_MemHeapDeallocFunc)(void *ptr); -typedef void *(DN_MemVirtualReserveFunc)(DN_USize size, DN_MemCommit commit, DN_MemPage page_flags); -typedef bool (DN_MemVirtualCommitFunc)(void *ptr, DN_USize size, DN_U32 page_flags); -typedef void (DN_MemVirtualReleaseFunc)(void *ptr, DN_USize size); +typedef void *(DN_MemVirtualReserveFunc)(DN_USize count, DN_MemCommit commit, DN_MemPage page_flags); +typedef bool (DN_MemVirtualCommitFunc)(void *ptr, DN_USize count, DN_U32 page_flags); +typedef void (DN_MemVirtualReleaseFunc)(void *ptr, DN_USize count); struct DN_MemFuncs { DN_MemFuncsType type; @@ -1372,7 +1372,7 @@ struct DN_Str8TruncResult { bool truncated; DN_Str8 str8; - DN_USize size_req; // Not including null-terminator + DN_USize count_req; // Not including null-terminator }; struct DN_Str8SplitResult @@ -1654,7 +1654,7 @@ struct DN_LogDate struct DN_LogPrefixSize { - DN_USize size; + DN_USize count; DN_USize padding; }; @@ -1817,7 +1817,7 @@ struct DN_ArrayEraseResult // The next index your for-index should be set to such that you can continue // to iterate the remainder of the array, e.g: // - // for (DN_USize index = 0; index < array.size; index++) { + // for (DN_USize index = 0; index < array.count; index++) { // if (erase) // index = DN_FArray_EraseRange(&array, index, -3, DN_ArrayErase_Unstable); // } @@ -2281,9 +2281,9 @@ DN_API bool DN_VerifyArgs #define DN_VSPrintF(...) STB_SPRINTF_DECORATE(vsprintf)(__VA_ARGS__) #define DN_VSNPrintF(...) STB_SPRINTF_DECORATE(vsnprintf)(__VA_ARGS__) -DN_API bool DN_MemStartsWith (void const *lhs, DN_USize lhs_size, void const *rhs, DN_USize rhs_size); -DN_API bool DN_MemEq (void const *lhs, DN_USize lhs_size, void const *rhs, DN_USize rhs_size); -DN_API bool DN_MemEqUnsafe (void const *lhs, void const *rhs, DN_USize size); +DN_API bool DN_MemStartsWith (void const *lhs, DN_USize lhs_count, void const *rhs, DN_USize rhs_count); +DN_API bool DN_MemEq (void const *lhs, DN_USize lhs_count, void const *rhs, DN_USize rhs_count); +DN_API bool DN_MemEqUnsafe (void const *lhs, void const *rhs, DN_USize count); #if defined(__cplusplus) template T* DN_MemCopyObjT (T *dest, T const *src, DN_USize count); #define DN_MemCopyObj(dest, src, count) DN_MemCopyObjT(dest, src, count) @@ -2416,7 +2416,7 @@ DN_API void DN_ASanUnpoisonMemoryRegion DN_API DN_F32 DN_EpsilonClampF32 (DN_F32 value, DN_F32 target, DN_F32 epsilon); DN_API DN_MemStats DN_MemStatsSum (DN_MemStats lhs, DN_MemStats rhs); -DN_API DN_MemStats DN_MemStatsSumArray (DN_MemStats const *array, DN_USize size); +DN_API DN_MemStats DN_MemStatsSumArray (DN_MemStats const *array, DN_USize count); // NOTE: MemList // Overview @@ -2588,7 +2588,7 @@ DN_API DN_I64FromResult DN_I64FromPtr DN_API DN_I64 DN_I64FromPtrUnsafe (void const *data, DN_USize size, char separator); DN_API bool DN_U8x32Eq (DN_U8x32 const *lhs, DN_U8x32 const *rhs); -DN_API DN_U8x32 DN_U8x32FromBytesLeftPadZ (DN_U8 const *ptr, DN_USize count); +DN_API DN_U8x32 DN_U8x32FromBytesLeftPadZ (DN_U8 const *ptr, DN_USize size); DN_API DN_U8x32 DN_U8x32FromHexUnsafe (DN_Str8 hex_32b); DN_API DN_U8x32FromResult DN_U8x32FromHex (DN_Str8 hex_32b); DN_API DN_U8x32FromResult DN_U8x32FromDecimalStr8 (DN_Str8 decimal); // Write decimal string (e.g. "12345") as big-endian 256-bit value @@ -2596,33 +2596,33 @@ DN_API DN_U8x32FromResult DN_U8x32FromDecimalStr8 DN_API DN_Allocator DN_AllocatorFromMemList (DN_MemList *mem); DN_API DN_Allocator DN_AllocatorFromArena (DN_Arena *arena); DN_API DN_Allocator DN_AllocatorFromPool (DN_Pool *pool); -DN_API void* DN_AllocatorAlloc (DN_Allocator allocator, DN_USize size, DN_U8 align, DN_ZMem z_mem); +DN_API void* DN_AllocatorAlloc (DN_Allocator allocator, DN_USize count, DN_U8 align, DN_ZMem z_mem); -DN_API DN_USize DN_FmtVSize (DN_FMT_ATTRIB char const *fmt, va_list args); -DN_API DN_USize DN_FmtSize (DN_FMT_ATTRIB char const *fmt, ...); +DN_API DN_USize DN_FmtVCount (DN_FMT_ATTRIB char const *fmt, va_list args); +DN_API DN_USize DN_FmtCount (DN_FMT_ATTRIB char const *fmt, ...); DN_API DN_FmtAppendResult DN_FmtVAppend (char *buf, DN_USize *buf_size, DN_USize buf_max, char const *fmt, va_list args); DN_API DN_FmtAppendResult DN_FmtAppend (char *buf, DN_USize *buf_size, DN_USize buf_max, char const *fmt, ...); DN_API DN_FmtAppendResult DN_FmtAppendTruncate (char *buf, DN_USize *buf_size, DN_USize buf_max, DN_Str8 truncator, char const *fmt, ...); -DN_API DN_USize DN_CStr8Size (char const *src); -DN_API DN_USize DN_CStr16Size (wchar_t const *src); +DN_API DN_USize DN_CStr8Count (char const *src); +DN_API DN_USize DN_CStr16Count (wchar_t const *src); #define DN_Str16Lit(string) DN_Str16{(wchar_t *)(string), sizeof(string)/sizeof(string[0]) - 1} -#define DN_Str16FromPtr(data, size) DN_Literal(DN_Str16){(wchar_t *)(data), (DN_USize)(size)} +#define DN_Str16FromPtr(data, count) DN_Literal(DN_Str16){(wchar_t *)(data), (DN_USize)(count)} #define DN_Str8Lit(c_str) DN_Literal(DN_Str8){(char *)(c_str), sizeof(c_str) - 1} -#define DN_Str8PrintFmt(string) (int)((string).size), (string).data +#define DN_Str8PrintFmt(string) (int)((string).count), (string).data -#define DN_Str8FromPtr(data, size) DN_Literal(DN_Str8){(char *)(data), (DN_USize)(size)} -#define DN_Str8FromStruct(ptr) DN_Str8FromPtr((ptr)->data, (ptr)->size) +#define DN_Str8FromPtr(data, count) DN_Literal(DN_Str8){(char *)(data), (DN_USize)(count)} +#define DN_Str8FromStruct(ptr) DN_Str8FromPtr((ptr)->data, (ptr)->count) #define DN_Str8FromLitArray(c_array) DN_Str8FromPtr(c_array, DN_ArrayCountU(c_array)) -DN_API DN_Str8 DN_Str8AllocAllocator (DN_USize size, DN_ZMem z_mem, DN_Allocator allocator); -DN_API DN_Str8 DN_Str8AllocArena (DN_USize size, DN_ZMem z_mem, DN_Arena *arena); -DN_API DN_Str8 DN_Str8AllocPool (DN_USize size, DN_Pool *pool); +DN_API DN_Str8 DN_Str8AllocAllocator (DN_USize count, DN_ZMem z_mem, DN_Allocator allocator); +DN_API DN_Str8 DN_Str8AllocArena (DN_USize count, DN_ZMem z_mem, DN_Arena *arena); +DN_API DN_Str8 DN_Str8AllocPool (DN_USize count, DN_Pool *pool); DN_API DN_Str8 DN_Str8FromCStr8 (char const *src); DN_API DN_Str8 DN_Str8FromCStr8Arena (char const *src, DN_Arena *arena); -DN_API DN_Str8 DN_Str8FromPtrArena (void const *data, DN_USize size, DN_Arena *arena); -DN_API DN_Str8 DN_Str8FromPtrPool (void const *data, DN_USize size, DN_Pool *pool); +DN_API DN_Str8 DN_Str8FromPtrArena (void const *data, DN_USize count, DN_Arena *arena); +DN_API DN_Str8 DN_Str8FromPtrPool (void const *data, DN_USize count, DN_Pool *pool); DN_API DN_Str8 DN_Str8FromStr8Allocator (DN_Str8 string, DN_Allocator allocator); DN_API DN_Str8 DN_Str8FromStr8Arena (DN_Str8 string, DN_Arena *arena); DN_API DN_Str8 DN_Str8FromStr8Pool (DN_Str8 string, DN_Pool *pool); @@ -2665,7 +2665,7 @@ DN_API void DN_Str8x1024AppendFmtV DN_API DN_Str8x32 DN_Str8x32FromU64 (DN_U64 val, char separator); DN_API bool DN_Str8IsAll (DN_Str8 string, DN_Str8IsAllType is_all); DN_API char * DN_Str8End (DN_Str8 string); -DN_API DN_Str8 DN_Str8Subset (DN_Str8 string, DN_USize offset, DN_USize size); +DN_API DN_Str8 DN_Str8Subset (DN_Str8 string, DN_USize offset, DN_USize count); DN_API DN_Str8 DN_Str8Advance (DN_Str8 string, DN_USize amount); DN_API DN_Str8 DN_Str8NextLine (DN_Str8 string); DN_API DN_Str8BSplitResult DN_Str8BSplitArray (DN_Str8 string, DN_Str8 const *find, DN_USize find_size); @@ -2705,7 +2705,7 @@ DN_API DN_Str8 DN_Str8AppendF DN_API DN_Str8 DN_Str8AppendFV (DN_Arena *arena, DN_Str8 string, char const *fmt, va_list args); DN_API DN_Str8 DN_Str8FillF (DN_Arena *arena, DN_USize count, char const *fmt, ...); DN_API DN_Str8 DN_Str8FillFV (DN_Arena *arena, DN_USize count, char const *fmt, va_list args); -DN_API void DN_Str8Remove (DN_Str8 *string, DN_USize offset, DN_USize size); +DN_API void DN_Str8Remove (DN_Str8 *string, DN_USize offset, DN_USize count); DN_API DN_Str8TruncResult DN_Str8TruncMiddlePtr (DN_Str8 str8, DN_USize side_size, DN_Str8 truncator, char *dest, DN_USize dest_max); DN_API DN_Str8TruncResult DN_Str8TruncMiddle (DN_Str8 str8, DN_USize side_size, DN_Str8 truncator, DN_Arena *arena); DN_API DN_Str8 DN_Str8Lower (DN_Str8 string, DN_Arena *arena); @@ -2738,28 +2738,28 @@ DN_API DN_Str16 DN_Str16SliceRender DN_API DN_Str16 DN_Str16RenderSpaceSep (DN_Str16Slice array, DN_Arena *arena); DN_API DN_Str8Builder DN_Str8BuilderFromArena (DN_Arena *arena); -DN_API DN_Str8Builder DN_Str8BuilderFromStr8PtrRef (DN_Arena *arena, DN_Str8 const *strings, DN_USize size); -DN_API DN_Str8Builder DN_Str8BuilderFromStr8PtrCopy (DN_Arena *arena, DN_Str8 const *strings, DN_USize size); +DN_API DN_Str8Builder DN_Str8BuilderFromStr8PtrRef (DN_Arena *arena, DN_Str8 const *strings, DN_USize count); +DN_API DN_Str8Builder DN_Str8BuilderFromStr8PtrCopy (DN_Arena *arena, DN_Str8 const *strings, DN_USize count); DN_API DN_Str8Builder DN_Str8BuilderFromBuilder (DN_Arena *arena, DN_Str8Builder const *builder); -DN_API bool DN_Str8BuilderAddArrayRef (DN_Str8Builder *builder, DN_Str8 const *strings, DN_USize size, DN_Str8BuilderAdd add); -DN_API bool DN_Str8BuilderAddArrayCopy (DN_Str8Builder *builder, DN_Str8 const *strings, DN_USize size, DN_Str8BuilderAdd add); +DN_API bool DN_Str8BuilderAddArrayRef (DN_Str8Builder *builder, DN_Str8 const *strings, DN_USize count, DN_Str8BuilderAdd add); +DN_API bool DN_Str8BuilderAddArrayCopy (DN_Str8Builder *builder, DN_Str8 const *strings, DN_USize count, DN_Str8BuilderAdd add); DN_API bool DN_Str8BuilderAddFV (DN_Str8Builder *builder, DN_Str8BuilderAdd add, DN_FMT_ATTRIB char const *fmt, va_list args); #define DN_Str8BuilderAppendArrayRef(builder, strings, size) DN_Str8BuilderAddArrayRef(builder, strings, size, DN_Str8BuilderAdd_Append) #define DN_Str8BuilderAppendArrayCopy(builder, strings, size) DN_Str8BuilderAddArrayCopy(builder, strings, size, DN_Str8BuilderAdd_Append) -#define DN_Str8BuilderAppendSliceRef(builder, slice) DN_Str8BuilderAddArrayRef(builder, slice.data, slice.size, DN_Str8BuilderAdd_Append) -#define DN_Str8BuilderAppendSliceCopy(builder, slice) DN_Str8BuilderAddArrayCopy(builder, slice.data, slice.size, DN_Str8BuilderAdd_Append) +#define DN_Str8BuilderAppendSliceRef(builder, slice) DN_Str8BuilderAddArrayRef(builder, slice.data, slice.count, DN_Str8BuilderAdd_Append) +#define DN_Str8BuilderAppendSliceCopy(builder, slice) DN_Str8BuilderAddArrayCopy(builder, slice.data, slice.count, DN_Str8BuilderAdd_Append) DN_API bool DN_Str8BuilderAppendRef (DN_Str8Builder *builder, DN_Str8 string); DN_API bool DN_Str8BuilderAppendCopy (DN_Str8Builder *builder, DN_Str8 string); #define DN_Str8BuilderAppendFV(builder, fmt, args) DN_Str8BuilderAddFV(builder, DN_Str8BuilderAdd_Append, fmt, args) DN_API bool DN_Str8BuilderAppendF (DN_Str8Builder *builder, DN_FMT_ATTRIB char const *fmt, ...); -DN_API bool DN_Str8BuilderAppendBytesRef (DN_Str8Builder *builder, void const *ptr, DN_USize size); -DN_API bool DN_Str8BuilderAppendBytesCopy (DN_Str8Builder *builder, void const *ptr, DN_USize size); +DN_API bool DN_Str8BuilderAppendBytesRef (DN_Str8Builder *builder, void const *ptr, DN_USize count); +DN_API bool DN_Str8BuilderAppendBytesCopy (DN_Str8Builder *builder, void const *ptr, DN_USize count); DN_API bool DN_Str8BuilderAppendBuilderRef (DN_Str8Builder *dest, DN_Str8Builder const *src); DN_API bool DN_Str8BuilderAppendBuilderCopy (DN_Str8Builder *dest, DN_Str8Builder const *src); #define DN_Str8BuilderPrependArrayRef(builder, strings, size) DN_Str8BuilderAddArrayRef(builder, strings, size, DN_Str8BuilderAdd_Prepend) #define DN_Str8BuilderPrependArrayCopy(builder, strings, size) DN_Str8BuilderAddArrayCopy(builder, strings, size, DN_Str8BuilderAdd_Prepend) -#define DN_Str8BuilderPrependSliceRef(builder, slice) DN_Str8BuilderAddArrayRef(builder, slice.data, slice.size, DN_Str8BuilderAdd_Prepend) -#define DN_Str8BuilderPrependSliceCopy(builder, slice) DN_Str8BuilderAddArrayCopy(builder, slice.data, slice.size, DN_Str8BuilderAdd_Prepend) +#define DN_Str8BuilderPrependSliceRef(builder, slice) DN_Str8BuilderAddArrayRef(builder, slice.data, slice.count, DN_Str8BuilderAdd_Prepend) +#define DN_Str8BuilderPrependSliceCopy(builder, slice) DN_Str8BuilderAddArrayCopy(builder, slice.data, slice.count, DN_Str8BuilderAdd_Prepend) DN_API bool DN_Str8BuilderPrependRef (DN_Str8Builder *builder, DN_Str8 string); DN_API bool DN_Str8BuilderPrependCopy (DN_Str8Builder *builder, DN_Str8 string); #define DN_Str8BuilderPrependFV(builder, fmt, args) DN_Str8BuilderAddFV(builder, DN_Str8BuilderAdd_Prepend, fmt, args) @@ -2902,8 +2902,8 @@ DN_API void DN_PCG32Advance #define DN_FNV1A64_SEED 14695981039346656037ULL #endif -DN_API DN_U32 DN_FNV1AHashU32FromBytes (void const *bytes, DN_USize size, DN_U32 seed); -DN_API DN_U64 DN_FNV1AHashU64FromBytes (void const *bytes, DN_USize size, DN_U64 seed); +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); @@ -3461,7 +3461,7 @@ DN_API DN_RaycastV2 DN_RaycastLineIntersectV2 // 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.size + add_count > array.max` otherwise no-op +// GrowIfNeeded: Expands the capacity of the array if `array.count + add_count > array.max` otherwise no-op // // Variants // PArray => Pointer (to) Array @@ -3471,7 +3471,7 @@ DN_API DN_RaycastV2 DN_RaycastLineIntersectV2 // automatically using DN_ArrayCountU(l_array). // // MyStruct buffer[TB_ASType_Count] = {}; -// DN_USize size = 0; +// DN_USize count = 0; // MyStruct *item_0 = DN_PArrayMake(buffer, &size, DN_ArrayCountU(buffer), DN_ZMem_No); // MyStruct *item_1 = DN_LArrayMake(buffer, &size, DN_ZMem_No); // @@ -3649,44 +3649,44 @@ DN_API DN_RaycastV2 DN_RaycastLineIntersectV2 #define DN_ISliceAllocArena(slice_ptr, count_, zmem, arena) (DN_CppDeclType(&((slice_ptr)->data[0])))DN_SliceAllocArena((void **)&((slice_ptr)->data), &((slice_ptr)->count), count_, sizeof((slice_ptr)->data[0]), alignof(DN_CppDeclType((slice_ptr)->data[0])), zmem, arena) -DN_API void* DN_SliceAllocArena (void **data, DN_USize *slice_size_field, DN_USize size, DN_USize elem_size, DN_U8 align, DN_ZMem zmem, DN_Arena *arena); +DN_API void* DN_SliceAllocArena (void **data, DN_USize *slice_size_field, DN_USize count, DN_USize elem_size, DN_U8 align, DN_ZMem zmem, DN_Arena *arena); -DN_API DN_ArrayFindResult DN_ArrayFind (void *data, DN_USize size, DN_USize elem_size, void const *find, DN_ArrayFindEqFunc *eq_func); -DN_API DN_ArrayFindResult DN_ArrayFindMemEq (void *data, DN_USize size, DN_USize elem_size, void const *find); -DN_API void* DN_ArrayInsertArray (void *data, DN_USize *size, DN_USize max, DN_USize elem_size, DN_USize index, void const *items, DN_USize count); -DN_API void* DN_ArrayPopFront (void *data, DN_USize *size, DN_USize elem_size, DN_USize count); -DN_API void* DN_ArrayPopBack (void *data, DN_USize *size, DN_USize elem_size, DN_USize count); -DN_API DN_ArrayEraseResult DN_ArrayEraseRange (void *data, DN_USize *size, DN_USize elem_size, DN_USize begin_index, DN_ISize count, DN_ArrayErase erase); -DN_API void* DN_ArrayMakeArray (void *data, DN_USize *size, DN_USize max, DN_USize elem_size, DN_USize make_count, DN_ZMem z_mem); -DN_API void* DN_ArrayMakeArrayAssert (void *data, DN_USize *size, DN_USize max, DN_USize elem_size, DN_USize make_count, DN_ZMem z_mem, DN_CallSite call_site); -DN_API void* DN_ArrayAddArray (void *data, DN_USize *size, 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 *size, 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 *size, DN_USize *max, DN_USize elem_size, DN_Pool *pool, DN_USize new_max); -DN_API bool DN_ArrayResizeFromArena (void **data, DN_USize *size, DN_USize *max, DN_USize elem_size, DN_Arena *arena, DN_USize new_max); -DN_API bool DN_ArrayGrowFromPool (void **data, DN_USize size, DN_USize *max, DN_USize elem_size, DN_Pool *pool, DN_USize new_max); -DN_API bool DN_ArrayGrowFromArena (void **data, DN_USize size, DN_USize *max, DN_USize elem_size, DN_Arena *arena, DN_USize new_max); -DN_API bool DN_ArrayGrowIfNeededFromPool (void **data, DN_USize size, DN_USize *max, DN_USize elem_size, DN_Pool *pool, DN_USize add_count); -DN_API bool DN_ArrayGrowIfNeededFromArena (void **data, DN_USize size, DN_USize *max, DN_USize elem_size, DN_Arena *arena, DN_USize add_count); +DN_API DN_ArrayFindResult DN_ArrayFind (void *data, DN_USize count, DN_USize elem_size, void const *find, DN_ArrayFindEqFunc *eq_func); +DN_API DN_ArrayFindResult DN_ArrayFindMemEq (void *data, DN_USize count, DN_USize elem_size, void const *find); +DN_API void* DN_ArrayInsertArray (void *data, DN_USize *count, DN_USize max, DN_USize elem_size, DN_USize index, void const *items, DN_USize items_count); +DN_API void* DN_ArrayPopFront (void *data, DN_USize *count, DN_USize elem_size, DN_USize pop_count); +DN_API void* DN_ArrayPopBack (void *data, DN_USize *count, DN_USize elem_size, DN_USize pop_count); +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_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 count, DN_USize *max, DN_USize elem_size, DN_Pool *pool, DN_USize new_max); +DN_API bool DN_ArrayGrowFromArena (void **data, DN_USize count, 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); #if defined (__cplusplus) -template DN_ArrayFindResult DN_TArrayFind (T *data, DN_USize size, void const *find, DN_ArrayFindEqFunc *eq_func); -template DN_ArrayFindResult DN_TArrayFindMemEq (T *data, DN_USize size, void const *find, DN_ArrayFindEqFunc *eq_func); -template T* DN_TArrayInsertArray (T *data, DN_USize *size, DN_USize max, DN_USize index, void const *items, DN_USize count); -template T* DN_TArrayPopFront (T *data, DN_USize *size, DN_USize count); -template T* DN_TArrayPopBack (T *data, DN_USize *size, DN_USize count); -template DN_ArrayEraseResult DN_TArrayEraseRange (T *data, DN_USize *size, DN_USize begin_index, DN_ISize count, DN_ArrayErase erase); -template T* DN_TArrayMakeArray (T *data, DN_USize *size, DN_USize max, DN_USize make_count, DN_ZMem z_mem); -template T* DN_TArrayMakeArrayAssert (T *data, DN_USize *size, DN_USize max, DN_USize make_count, DN_ZMem z_mem, DN_CallSite call_site); -template T* DN_TArrayMakeArrayAssertZ (T *data, DN_USize *size, DN_USize max, DN_USize make_count, DN_CallSite call_site); -template T* DN_TArrayMakeArrayAssertNoZ (T *data, DN_USize *size, DN_USize max, DN_USize make_count, DN_CallSite call_site); -template T* DN_TArrayAddArray (T *data, DN_USize *size, DN_USize max, T const *elems, DN_USize elems_count, DN_ArrayAdd add); -template T* DN_TArrayAddArrayAssert (T *data, DN_USize *size, DN_USize max, T const *elems, DN_USize elems_count, DN_ArrayAdd add, DN_CallSite call_site); -template bool DN_TArrayResizeFromPool (T **data, DN_USize *size, DN_USize *max, DN_Pool *pool, DN_USize new_max); -template bool DN_TArrayResizeFromArena (T **data, DN_USize *size, DN_USize *max, DN_Arena *arena, DN_USize new_max); -template bool DN_TArrayGrowFromPool (T **data, DN_USize size, DN_USize *max, DN_Pool *pool, DN_USize new_max); -template bool DN_TArrayGrowFromArena (T **data, DN_USize size, DN_USize *max, DN_Pool *pool, DN_USize new_max); -template bool DN_TArrayGrowIfNeededFromPool (T **data, DN_USize size, DN_USize *max, DN_Pool *pool, DN_USize add_count); -template bool DN_TArrayGrowIfNeededFromArena (T **data, DN_USize size, DN_USize *max, DN_Arena *pool, DN_USize add_count); +template DN_ArrayFindResult DN_TArrayFind (T *data, DN_USize count, void const *find, DN_ArrayFindEqFunc *eq_func); +template DN_ArrayFindResult DN_TArrayFindMemEq (T *data, DN_USize count, void const *find, DN_ArrayFindEqFunc *eq_func); +template T* DN_TArrayInsertArray (T *data, DN_USize *count, DN_USize max, DN_USize index, void const *items, DN_USize pop_count); +template T* DN_TArrayPopFront (T *data, DN_USize *count, DN_USize pop_count); +template T* DN_TArrayPopBack (T *data, DN_USize *count, DN_USize pop_count); +template DN_ArrayEraseResult DN_TArrayEraseRange (T *data, DN_USize *count, DN_USize begin_index, DN_ISize erase_count, DN_ArrayErase erase); +template T* DN_TArrayMakeArray (T *data, DN_USize *count, DN_USize max, DN_USize make_count, DN_ZMem z_mem); +template T* DN_TArrayMakeArrayAssert (T *data, DN_USize *count, DN_USize max, DN_USize make_count, DN_ZMem z_mem, DN_CallSite call_site); +template T* DN_TArrayMakeArrayAssertZ (T *data, DN_USize *count, DN_USize max, DN_USize make_count, DN_CallSite call_site); +template T* DN_TArrayMakeArrayAssertNoZ (T *data, DN_USize *count, DN_USize max, DN_USize make_count, DN_CallSite call_site); +template T* DN_TArrayAddArray (T *data, DN_USize *count, DN_USize max, T const *elems, DN_USize elems_count, DN_ArrayAdd add); +template 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 bool DN_TArrayResizeFromPool (T **data, DN_USize *count, DN_USize *max, DN_Pool *pool, DN_USize new_max); +template bool DN_TArrayResizeFromArena (T **data, DN_USize *count, DN_USize *max, DN_Arena *arena, DN_USize new_max); +template bool DN_TArrayGrowFromPool (T **data, DN_USize count, DN_USize *max, DN_Pool *pool, DN_USize new_max); +template bool DN_TArrayGrowFromArena (T **data, DN_USize count, DN_USize *max, DN_Pool *pool, DN_USize new_max); +template bool DN_TArrayGrowIfNeededFromPool (T **data, DN_USize count, DN_USize *max, DN_Pool *pool, DN_USize add_count); +template bool DN_TArrayGrowIfNeededFromArena (T **data, DN_USize count, DN_USize *max, DN_Arena *pool, DN_USize add_count); #endif DN_API void* DN_SinglyLLDetach (void **link, void **next); @@ -3719,8 +3719,8 @@ template bool DN_DSMapResize (DN_DSMap template bool DN_DSMapErase (DN_DSMap *map, DN_DSMapKey key); template bool DN_DSMapEraseKeyU64 (DN_DSMap *map, DN_U64 key); template bool DN_DSMapEraseKeyStr8 (DN_DSMap *map, DN_Str8 key); -template DN_DSMapKey DN_DSMapKeyBuffer (DN_DSMap const *map, void const *data, DN_USize size); -template DN_DSMapKey DN_DSMapKeyBufferAsU64NoHash (DN_DSMap const *map, void const *data, DN_USize size); +template DN_DSMapKey DN_DSMapKeyBuffer (DN_DSMap const *map, void const *data, DN_USize count); +template DN_DSMapKey DN_DSMapKeyBufferAsU64NoHash (DN_DSMap const *map, void const *data, DN_USize count); template DN_DSMapKey DN_DSMapKeyU64 (DN_DSMap const *map, DN_U64 u64); template DN_DSMapKey DN_DSMapKeyStr8 (DN_DSMap const *map, DN_Str8 string); #define DN_DSMapKeyCStr8(map, string) DN_DSMapKeyBuffer(map, string, sizeof((string))/sizeof((string)[0]) - 1) @@ -3940,19 +3940,19 @@ DN_API DN_Arena DN_ArenaFromHeap (D DN_API DN_Arena DN_ArenaFromVMem (DN_U64 reserve, DN_U64 commit, DN_MemFlags flags); DN_API DN_Str8 DN_Str8FromHeapF (DN_FMT_ATTRIB char const *fmt, ...); -DN_API DN_Str8 DN_Str8FromHeap (DN_USize size, DN_ZMem z_mem); +DN_API DN_Str8 DN_Str8FromHeap (DN_USize count, DN_ZMem z_mem); DN_API DN_Str8 DN_Str8BuilderBuildFromHeap (DN_Str8Builder const *builder); DN_API void DN_OS_LogPrint (DN_LogTypeParam type, void *user_data, DN_CallSite call_site, DN_FMT_ATTRIB char const *fmt, va_list args); DN_API void DN_OS_SetLogPrintFuncToOS (); -DN_API void * DN_OS_MemReserve (DN_USize size, DN_MemCommit commit, DN_MemPage page_flags); -DN_API bool DN_OS_MemCommit (void *ptr, DN_USize size, DN_U32 page_flags); -DN_API void DN_OS_MemDecommit (void *ptr, DN_USize size); -DN_API void DN_OS_MemRelease (void *ptr, DN_USize size); -DN_API int DN_OS_MemProtect (void *ptr, DN_USize size, DN_U32 page_flags); +DN_API void * DN_OS_MemReserve (DN_USize count, DN_MemCommit commit, DN_MemPage page_flags); +DN_API bool DN_OS_MemCommit (void *ptr, DN_USize count, DN_U32 page_flags); +DN_API void DN_OS_MemDecommit (void *ptr, DN_USize count); +DN_API void DN_OS_MemRelease (void *ptr, DN_USize count); +DN_API int DN_OS_MemProtect (void *ptr, DN_USize count, DN_U32 page_flags); -DN_API void * DN_OS_MemAlloc (DN_USize size, DN_ZMem z_mem); +DN_API void * DN_OS_MemAlloc (DN_USize count, DN_ZMem z_mem); DN_API void DN_OS_MemDealloc (void *ptr); DN_API DN_Date DN_OS_DateLocalTimeNow (); @@ -3990,8 +3990,8 @@ DN_API bool DN_OS_FileCopy (D DN_API bool DN_OS_FileMove (DN_Str8 src, DN_Str8 dest, bool overwrite, DN_ErrSink *err); DN_API DN_OSFile DN_OS_FileOpen (DN_Str8 path, DN_OSFileOpen open_mode, DN_OSFileAccess access, DN_ErrSink *err); -DN_API DN_OSFileRead DN_OS_FileRead (DN_OSFile *file, void *buffer, DN_USize size, DN_ErrSink *err); -DN_API bool DN_OS_FileWritePtr (DN_OSFile *file, void const *data, DN_USize size, DN_ErrSink *err); +DN_API DN_OSFileRead DN_OS_FileRead (DN_OSFile *file, void *buffer, DN_USize count, DN_ErrSink *err); +DN_API bool DN_OS_FileWritePtr (DN_OSFile *file, void const *data, DN_USize count, DN_ErrSink *err); DN_API bool DN_OS_FileWrite (DN_OSFile *file, DN_Str8 buffer, DN_ErrSink *err); DN_API bool DN_OS_FileWriteFV (DN_OSFile *file, DN_ErrSink *err, DN_FMT_ATTRIB char const *fmt, va_list args); DN_API bool DN_OS_FileWriteF (DN_OSFile *file, DN_ErrSink *err, DN_FMT_ATTRIB char const *fmt, ...); @@ -4214,128 +4214,128 @@ template T *DN_MemCopyObjT(T *dest, T const *src, DN_USize count) } template -DN_ArrayFindResult DN_TArrayFind(T *data, DN_USize size, void const *find, DN_ArrayFindEqFunc *eq_func) +DN_ArrayFindResult DN_TArrayFind(T *data, DN_USize count, void const *find, DN_ArrayFindEqFunc *eq_func) { - DN_ArrayFindResult result = DN_ArrayFind(data, size, sizeof(*data), find, eq_func); + DN_ArrayFindResult result = DN_ArrayFind(data, count, sizeof(*data), find, eq_func); return result; } template -DN_ArrayFindResult DN_TArrayFindMemEq(T *data, DN_USize size, void const *find) +DN_ArrayFindResult DN_TArrayFindMemEq(T *data, DN_USize count, void const *find) { - DN_ArrayFindResult result = DN_ArrayFindMemEq(data, size, sizeof(*data), find); + DN_ArrayFindResult result = DN_ArrayFindMemEq(data, count, sizeof(*data), find); return result; } template -T *DN_TArrayInsertArray(T *data, DN_USize *size, DN_USize max, DN_USize index, T const *items, DN_USize count) +T *DN_TArrayInsertArray(T *data, DN_USize *count, DN_USize max, DN_USize index, T const *items, DN_USize items_count) { - T *result = DN_Cast(T *)DN_ArrayInsertArray(data, size, max, sizeof(*data), index, items, count); + T *result = DN_Cast(T *)DN_ArrayInsertArray(data, count, max, sizeof(*data), index, items, items_count); return result; } template -T *DN_TArrayPopFront(T *data, DN_USize *size, DN_USize count) +T *DN_TArrayPopFront(T *data, DN_USize *count, DN_USize pop_count) { - T *result = DN_Cast(T *)DN_ArrayPopFront(data, size, sizeof(*data), count); + T *result = DN_Cast(T *)DN_ArrayPopFront(data, count, sizeof(*data), pop_count); return result; } template -T *DN_TArrayPopBack(T *data, DN_USize *size, DN_USize count) +T *DN_TArrayPopBack(T *data, DN_USize *count, DN_USize pop_count) { - T *result = DN_Cast(T *)DN_ArrayPopBack(data, size, sizeof(*data), count); + T *result = DN_Cast(T *)DN_ArrayPopBack(data, count, sizeof(*data), pop_count); return result; } template -DN_ArrayEraseResult DN_TArrayEraseRange(T *data, DN_USize *size, DN_USize begin_index, DN_ISize count, DN_ArrayErase erase) +DN_ArrayEraseResult DN_TArrayEraseRange(T *data, DN_USize *count, DN_USize begin_index, DN_ISize erase_count, DN_ArrayErase erase) { - DN_ArrayEraseResult result = DN_ArrayEraseRange(data, size, sizeof(*data), begin_index, count, erase); + DN_ArrayEraseResult result = DN_ArrayEraseRange(data, count, sizeof(*data), begin_index, erase_count, erase); return result; } template -T *DN_TArrayMakeArray(T *data, DN_USize *size, DN_USize max, DN_USize make_count, DN_ZMem z_mem) +T *DN_TArrayMakeArray(T *data, DN_USize *count, DN_USize max, DN_USize make_count, DN_ZMem z_mem) { - T *result = DN_Cast(T *)DN_ArrayMakeArray(data, size, max, sizeof(*data), make_count, z_mem); + T *result = DN_Cast(T *)DN_ArrayMakeArray(data, count, max, sizeof(*data), make_count, z_mem); return result; } template -T *DN_TArrayMakeArrayAssert(T *data, DN_USize *size, DN_USize max, DN_USize make_count, DN_ZMem z_mem, DN_CallSite call_site) +T *DN_TArrayMakeArrayAssert(T *data, DN_USize *count, DN_USize max, DN_USize make_count, DN_ZMem z_mem, DN_CallSite call_site) { - T *result = DN_Cast(T *)DN_ArrayMakeArrayAssert(data, size, max, sizeof(*data), make_count, z_mem, call_site); + T *result = DN_Cast(T *)DN_ArrayMakeArrayAssert(data, count, max, sizeof(*data), make_count, z_mem, call_site); return result; } template -T *DN_TArrayMakeArrayAssertZ(T *data, DN_USize *size, DN_USize max, DN_USize make_count, DN_CallSite call_site) +T *DN_TArrayMakeArrayAssertZ(T *data, DN_USize *count, DN_USize max, DN_USize make_count, DN_CallSite call_site) { - T* result = DN_TArrayMakeArrayAssert(data, size, max, make_count, DN_ZMem_Yes, call_site); + T* result = DN_TArrayMakeArrayAssert(data, count, max, make_count, DN_ZMem_Yes, call_site); return result; } template -T *DN_TArrayMakeArrayAssertNoZ(T *data, DN_USize *size, DN_USize max, DN_USize make_count, DN_CallSite call_site) +T *DN_TArrayMakeArrayAssertNoZ(T *data, DN_USize *count, DN_USize max, DN_USize make_count, DN_CallSite call_site) { - T* result = DN_TArrayMakeArrayAssert(data, size, max, make_count, DN_ZMem_No, call_site); + T* result = DN_TArrayMakeArrayAssert(data, count, max, make_count, DN_ZMem_No, call_site); return result; } template -T *DN_TArrayAddArray(T *data, DN_USize *size, DN_USize max, T const *elems, DN_USize elems_count, DN_ArrayAdd add) +T *DN_TArrayAddArray(T *data, DN_USize *count, DN_USize max, T const *elems, DN_USize elems_count, DN_ArrayAdd add) { - T* result = DN_Cast(T *)DN_ArrayAddArray(data, size, max, sizeof(*elems), elems, elems_count, add); + T* result = DN_Cast(T *)DN_ArrayAddArray(data, count, max, sizeof(*elems), elems, elems_count, add); return result; } template -T *DN_TArrayAddArrayAssert(T *data, DN_USize *size, DN_USize max, T const *elems, DN_USize elems_count, DN_ArrayAdd add, DN_CallSite call_site) +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) { - T* result = DN_Cast(T *)DN_ArrayAddArrayAssert(data, size, max, sizeof(*elems), elems, elems_count, add, call_site); + T* result = DN_Cast(T *)DN_ArrayAddArrayAssert(data, count, max, sizeof(*elems), elems, elems_count, add, call_site); return result; } template -bool DN_TArrayResizeFromPool(T **data, DN_USize *size, DN_USize *max, DN_Pool *pool, DN_USize new_max) +bool DN_TArrayResizeFromPool(T **data, DN_USize *count, DN_USize *max, DN_Pool *pool, DN_USize new_max) { - bool result = DN_ArrayResizeFromPool(DN_Cast(void **)data, size, max, sizeof(**data), pool, new_max); + bool result = DN_ArrayResizeFromPool(DN_Cast(void **)data, count, max, sizeof(**data), pool, new_max); return result; } template -bool DN_TArrayResizeFromArena(T **data, DN_USize *size, DN_USize *max, DN_Arena *arena, DN_USize new_max) +bool DN_TArrayResizeFromArena(T **data, DN_USize *count, DN_USize *max, DN_Arena *arena, DN_USize new_max) { - bool result = DN_ArrayResizeFromArena(DN_Cast(void **)data, size, max, sizeof(**data), arena, new_max); + bool result = DN_ArrayResizeFromArena(DN_Cast(void **)data, count, max, sizeof(**data), arena, new_max); return result; } template -bool DN_TArrayGrowFromPool(T **data, DN_USize size, DN_USize *max, DN_Pool *pool, DN_USize new_max) +bool DN_TArrayGrowFromPool(T **data, DN_USize count, DN_USize *max, DN_Pool *pool, DN_USize new_max) { - bool result = DN_ArrayGrowFromPool(DN_Cast(void **)data, size, max, sizeof(**data), pool, new_max); + bool result = DN_ArrayGrowFromPool(DN_Cast(void **)data, count, max, sizeof(**data), pool, new_max); return result; } template -bool DN_TArrayGrowFromArena(T **data, DN_USize size, DN_USize *max, DN_Arena *arena, DN_USize new_max) +bool DN_TArrayGrowFromArena(T **data, DN_USize count, DN_USize *max, DN_Arena *arena, DN_USize new_max) { - bool result = DN_ArrayGrowFromArena(DN_Cast(void **)data, size, max, sizeof(**data), arena, new_max); + bool result = DN_ArrayGrowFromArena(DN_Cast(void **)data, count, max, sizeof(**data), arena, new_max); return result; } template -bool DN_TArrayGrowIfNeededFromPool(T **data, DN_USize size, DN_USize *max, DN_Pool *pool, DN_USize add_count) +bool DN_TArrayGrowIfNeededFromPool(T **data, DN_USize count, DN_USize *max, DN_Pool *pool, DN_USize add_count) { - bool result = DN_ArrayGrowIfNeededFromPool(DN_Cast(void **)data, size, max, sizeof(**data), pool, add_count); + bool result = DN_ArrayGrowIfNeededFromPool(DN_Cast(void **)data, count, max, sizeof(**data), pool, add_count); return result; } template -bool DN_TArrayGrowIfNeededFromArena(T **data, DN_USize size, DN_USize *max, DN_Arena *arena, DN_USize add_count) +bool DN_TArrayGrowIfNeededFromArena(T **data, DN_USize count, DN_USize *max, DN_Arena *arena, DN_USize add_count) { - bool result = DN_ArrayGrowIfNeededFromArena(DN_Cast(void **)data, size, max, sizeof(**data), arena, add_count); + bool result = DN_ArrayGrowIfNeededFromArena(DN_Cast(void **)data, count, max, sizeof(**data), arena, add_count); return result; } #endif // defined(__cplusplus) @@ -4370,10 +4370,12 @@ enum DN_NETWSSend DN_NETWSSend_Pong, }; -enum DN_NETDoHTTPFlags +typedef DN_U32 DN_NETDoHTTPFlags; +enum DN_NETDoHTTPFlags_ { - DN_NETDoHTTPFlags_Nil = 0, - DN_NETDoHTTPFlags_BasicAuth = 1 << 0, + DN_NETDoHTTPFlags_Nil = 0, + DN_NETDoHTTPFlags_BasicAuth = 1 << 0, + DN_NETDoHTTPFlags_DisableSSLVerify = 1 << 1, }; struct DN_NETDoHTTPArgs @@ -4397,6 +4399,8 @@ struct DN_NETRequestHandle struct DN_NETResponse { + // NOTE: When filling these fields, all their values are copied internally in the library so the + // values do not need to persist past the initial invocation of the HTTP/WS request. // NOTE: Common to WS and HTTP responses DN_NETRequestType type; DN_NETResponseState state; @@ -4455,10 +4459,24 @@ struct DN_NETCore DN_NETInterface api; }; +// NOTE: NET +// Overview +// Defines a multi-threaded interface for doing network requests (via the `DN_NETInterface` +// object) in the core struct. On top of this is a asynchronous API provided to the caller along +// the lines of, do http/ws followed to dispatch a request followed by a blocking wait for +// response function. +// +// API +// DN_NET_ResponseHasFailed +// After a response has been dispatched via do http/ws the returned handle's status can be +// queried using this function. A request has failed if the `state` has returned +// `DN_NETResponseState_Error`, or the returned HTTP status code was `>= 400`. DN_Str8 DN_NET_Str8FromResponseState (DN_NETResponseState state); DN_NETRequest * DN_NET_RequestFromHandle (DN_NETRequestHandle handle); DN_NETRequestHandle DN_NET_HandleFromRequest (DN_NETRequest *request); bool DN_NET_ResponseHasFailed (DN_NETResponse const* resp); +bool DN_NET_ResponseHasSucceeded (DN_NETResponse const* resp); +bool DN_NET_ResponseIsReady (DN_NETResponse const* resp); DN_Str8 DN_NET_Str8DiagnosticFromResponse(DN_NETResponse const* resp, DN_Arena *arena); // NOTE: Internal functions for different networking implementations to use @@ -4468,6 +4486,15 @@ void DN_NET_EndFinishedRequest (DN_NETRequest *request); #endif #if DN_WITH_NET_CURL +#if defined(DN_COMPILER_MSVC) || defined(DN_COMPILER_CLANG_CL) +#pragma comment(lib, "advapi32") +#pragma comment(lib, "ws2_32") +#pragma comment(lib, "wldap32") +#pragma comment(lib, "crypt32") +#pragma comment(lib, "secur32") +#pragma comment(lib, "Iphlpapi") +#endif + #if !DN_WITH_OS || !DN_WITH_NET #error "NET API with CURL requires #define DN_WITH_NET 1 and #define DN_WITH_OS 1" #endif diff --git a/build.bat b/build.bat index d6dd741..368237f 100644 --- a/build.bat +++ b/build.bat @@ -57,8 +57,8 @@ pushd %build_dir% call %build_dir%\single_header_generator.exe %script_dir%\Source %script_dir%\Single-Header || echo Single header generation failed&& exit /b 1 REM Build the single header using the single header (to test that the generated single header) - call cl %script_dir%\single_header_generator.cpp -Z7 -nologo -link -D USE_SINGLE_HEADER || echo Single header generator build failed&& exit /b 1 - call %build_dir%\single_header_generator.exe %script_dir%\Source %script_dir%\Single-Header -D USE_SINGLE_HEADER || echo Single header generation failed&& exit /b 1 + call cl %script_dir%\single_header_generator.cpp -Z7 -nologo -D USE_SINGLE_HEADER -link || echo Single header generator build failed&& exit /b 1 + call %build_dir%\single_header_generator.exe %script_dir%\Source %script_dir%\Single-Header || echo Single header generation failed&& exit /b 1 ) where /q clang-cl && ( diff --git a/single_header_generator.cpp b/single_header_generator.cpp index bd94b75..6b6b0c6 100644 --- a/single_header_generator.cpp +++ b/single_header_generator.cpp @@ -32,7 +32,7 @@ static void AppendCppFileLineByLine(DN_Str8Builder *dest, DN_Str8 cpp_path) DN_ErrSinkEndExitIfErrorF(err, -1, "Failed to load file from '%S' for appending", cpp_path); bool inside_clangd_preprocessor_block = false; - for (DN_Str8 walker = buffer; walker.size;) { + for (DN_Str8 walker = buffer; walker.count;) { // NOTE: Trim the whitespace, mainly for windows, the file we read will have \r\n whereas we just want to emit \n DN_Str8BSplitResult split = DN_Str8BSplit(walker, DN_Str8Lit("\n")); DN_Str8 line = DN_Str8TrimTailWhitespace(split.lhs); @@ -81,7 +81,7 @@ static void AppendCppFileLineByLine(DN_Str8Builder *dest, DN_Str8 cpp_path) DN_Str8BuilderAppendCopy(dest, line); DN_Str8BuilderAppendRef(dest, DN_Str8Lit("\n")); - if (extra_include_path.size) + if (extra_include_path.count) AppendCppFileLineByLine(dest, extra_include_path); } DN_TCScratchEnd(&scratch);