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

Various naming scheme updates

Browse Source
This commit is contained in:
doylet
2025-09-03 22:49:29 +10:00
parent af77df23f5
commit 338be96138
35 changed files with 1193 additions and 1723 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Source/Base/dn_base_containers.cpp
+1 -1
View File
@@ -691,7 +691,7 @@ DN_DSMap<T> DN_DSMap_Init(DN_Arena *arena, DN_U32 size, DN_DSMapFlags flags)
if (!DN_Check(arena))
return result;
result.arena = arena;
result.pool = DN_Pool_Init(arena, DN_POOL_DEFAULT_ALIGN);
result.pool = DN_Pool_FromArena(arena, DN_POOL_DEFAULT_ALIGN);
result.hash_to_slot = DN_Arena_NewArray(result.arena, DN_U32, size, DN_ZeroMem_Yes);
result.slots = DN_Arena_NewArray(result.arena, DN_DSMapSlot<T>, size, DN_ZeroMem_Yes);
result.occupied = 1; // For sentinel
Source/Base/dn_base_convert.cpp
+58 -30
View File
@@ -1,5 +1,33 @@
#define DN_CONVERT_CPP
#include "../dn_base_inc.h"
DN_API DN_NibbleFromU8Result DN_CVT_NibbleFromU8(DN_U8 u8)
{
static char const *table = "0123456789abcdef";
DN_U8 lhs = (u8 >> 0) & 0xF;
DN_U8 rhs = (u8 >> 4) & 0xF;
DN_NibbleFromU8Result result = {};
result.nibble0 = table[rhs];
result.nibble1 = table[lhs];
return result;
}
DN_API DN_U8 DN_CVT_U8FromHexNibble(char hex)
{
bool digit = hex >= '0' && hex <= '9';
bool upper = hex >= 'A' && hex <= 'F';
bool lower = hex >= 'a' && hex <= 'f';
DN_U8 result = 0xFF;
if (digit)
result = hex - '0';
if (upper)
result = hex - 'A' + 10;
if (lower)
result = hex - 'a' + 10;
return result;
}
DN_API int DN_CVT_FmtBuffer3DotTruncate(char *buffer, int size, DN_FMT_ATTRIB char const *fmt, ...)
{
va_list args;
@@ -14,7 +42,7 @@ DN_API int DN_CVT_FmtBuffer3DotTruncate(char *buffer, int size, DN_FMT_ATTRIB ch
return result;
}
DN_API DN_CVTU64Str8 DN_CVT_U64ToStr8(DN_U64 val, char separator)
DN_API DN_CVTU64Str8 DN_CVT_Str8FromU64(DN_U64 val, char separator)
{
DN_CVTU64Str8 result = {};
if (val == 0) {
@@ -47,7 +75,7 @@ DN_API DN_CVTU64Str8 DN_CVT_U64ToStr8(DN_U64 val, char separator)
return result;
}
DN_API DN_CVTU64Bytes DN_CVT_U64ToBytes(DN_U64 bytes, DN_CVTBytesType type)
DN_API DN_CVTU64Bytes DN_CVT_BytesFromU64(DN_U64 bytes, DN_CVTBytesType type)
{
DN_Assert(type != DN_CVTBytesType_Count);
DN_CVTU64Bytes result = {};
@@ -64,10 +92,10 @@ DN_API DN_CVTU64Bytes DN_CVT_U64ToBytes(DN_U64 bytes, DN_CVTBytesType type)
return result;
}
DN_API DN_Str8 DN_CVT_U64ToBytesStr8(DN_Arena *arena, DN_U64 bytes, DN_CVTBytesType desired_type)
DN_API DN_Str8 DN_CVT_BytesStr8FromU64(DN_Arena *arena, DN_U64 bytes, DN_CVTBytesType desired_type)
{
DN_CVTU64Bytes byte_size = DN_CVT_U64ToBytes(bytes, desired_type);
DN_Str8 result = DN_Str8_InitF(arena, "%.2f%.*s", byte_size.bytes, DN_STR_FMT(byte_size.suffix));
DN_CVTU64Bytes byte_size = DN_CVT_BytesFromU64(bytes, desired_type);
DN_Str8 result = DN_Str8_FromF(arena, "%.2f%.*s", byte_size.bytes, DN_STR_FMT(byte_size.suffix));
return result;
}
@@ -86,15 +114,15 @@ DN_API DN_Str8 DN_CVT_BytesTypeToStr8(DN_CVTBytesType type)
return result;
}
DN_API DN_Str8 DN_CVT_U64ToAge(DN_Arena *arena, DN_U64 age_s, DN_CVTU64AgeUnit unit)
DN_API DN_Str8 DN_CVT_AgeFromU64(DN_Arena *arena, DN_U64 age_s, DN_CVTU64AgeUnit unit)
{
DN_Str8 result = {};
if (!arena)
return result;
char buffer[512];
DN_Arena stack_arena = DN_Arena_InitFromBuffer(buffer, sizeof(buffer), DN_ArenaFlags_NoPoison);
DN_Str8Builder builder = DN_Str8Builder_Init(&stack_arena);
DN_Arena stack_arena = DN_Arena_FromBuffer(buffer, sizeof(buffer), DN_ArenaFlags_NoPoison);
DN_Str8Builder builder = DN_Str8Builder_FromArena(&stack_arena);
DN_U64 remainder = age_s;
if (unit & DN_CVTU64AgeUnit_Year) {
@@ -142,15 +170,15 @@ DN_API DN_Str8 DN_CVT_U64ToAge(DN_Arena *arena, DN_U64 age_s, DN_CVTU64AgeUnit u
return result;
}
DN_API DN_Str8 DN_CVT_F64ToAge(DN_Arena *arena, DN_F64 age_s, DN_CVTU64AgeUnit unit)
DN_API DN_Str8 DN_CVT_AgeFromF64(DN_Arena *arena, DN_F64 age_s, DN_CVTU64AgeUnit unit)
{
DN_Str8 result = {};
if (!arena)
return result;
char buffer[256];
DN_Arena stack_arena = DN_Arena_InitFromBuffer(buffer, sizeof(buffer), DN_ArenaFlags_NoPoison);
DN_Str8Builder builder = DN_Str8Builder_Init(&stack_arena);
DN_Arena stack_arena = DN_Arena_FromBuffer(buffer, sizeof(buffer), DN_ArenaFlags_NoPoison);
DN_Str8Builder builder = DN_Str8Builder_FromArena(&stack_arena);
DN_F64 remainder = age_s;
if (unit & DN_CVTU64AgeUnit_Year) {
@@ -202,7 +230,7 @@ DN_API DN_Str8 DN_CVT_F64ToAge(DN_Arena *arena, DN_F64 age_s, DN_CVTU64AgeUnit u
return result;
}
DN_API DN_U64 DN_CVT_HexToU64(DN_Str8 hex)
DN_API DN_U64 DN_CVT_U64FromHex(DN_Str8 hex)
{
DN_Str8 real_hex = DN_Str8_TrimPrefix(DN_Str8_TrimPrefix(hex, DN_STR8("0x")), DN_STR8("0X"));
DN_USize max_hex_size = sizeof(DN_U64) * 2 /*hex chars per byte*/;
@@ -211,16 +239,16 @@ DN_API DN_U64 DN_CVT_HexToU64(DN_Str8 hex)
DN_USize size = DN_Min(max_hex_size, real_hex.size);
DN_U64 result = 0;
for (DN_USize index = 0; index < size; index++) {
char ch = real_hex.data[index];
DN_CharHexToU8 val = DN_Char_HexToU8(ch);
if (!val.success)
char ch = real_hex.data[index];
DN_U8 val = DN_CVT_U8FromHexNibble(ch);
if (val == 0xFF)
break;
result = (result << 4) | val.value;
result = (result << 4) | val;
}
return result;
}
DN_API DN_Str8 DN_CVT_U64ToHex(DN_Arena *arena, DN_U64 number, uint32_t flags)
DN_API DN_Str8 DN_CVT_HexFromU64(DN_Arena *arena, DN_U64 number, uint32_t flags)
{
DN_Str8 prefix = {};
if ((flags & DN_CVTU64HexStrFlags_0xPrefix))
@@ -238,7 +266,7 @@ DN_API DN_Str8 DN_CVT_U64ToHex(DN_Arena *arena, DN_U64 number, uint32_t flags)
return result;
}
DN_API DN_CVTU64HexStr DN_CVT_U64ToHexStr8(DN_U64 number, DN_CVTU64HexStrFlags flags)
DN_API DN_CVTU64HexStr DN_CVT_HexFromU64Str8(DN_U64 number, DN_CVTU64HexStrFlags flags)
{
DN_Str8 prefix = {};
if (flags & DN_CVTU64HexStrFlags_0xPrefix)
@@ -260,7 +288,7 @@ DN_API DN_CVTU64HexStr DN_CVT_U64ToHexStr8(DN_U64 number, DN_CVTU64HexStrFlags f
return result;
}
DN_API bool DN_CVT_BytesToHexPtr(void const *src, DN_USize src_size, char *dest, DN_USize dest_size)
DN_API bool DN_CVT_HexFromBytesPtr(void const *src, DN_USize src_size, char *dest, DN_USize dest_size)
{
if (!src || !dest)
return false;
@@ -281,7 +309,7 @@ DN_API bool DN_CVT_BytesToHexPtr(void const *src, DN_USize src_size, char *dest,
return true;
}
DN_API DN_Str8 DN_CVT_BytesToHex(DN_Arena *arena, void const *src, DN_USize size)
DN_API DN_Str8 DN_CVT_HexFromBytes(DN_Arena *arena, void const *src, DN_USize size)
{
DN_Str8 result = {};
if (!src || size <= 0)
@@ -289,12 +317,12 @@ DN_API DN_Str8 DN_CVT_BytesToHex(DN_Arena *arena, void const *src, DN_USize size
result = DN_Str8_Alloc(arena, size * 2, DN_ZeroMem_No);
result.data[result.size] = 0;
bool converted = DN_CVT_BytesToHexPtr(src, size, result.data, result.size);
bool converted = DN_CVT_HexFromBytesPtr(src, size, result.data, result.size);
DN_Assert(converted);
return result;
}
DN_API DN_USize DN_CVT_HexToBytesPtrUnchecked(DN_Str8 hex, void *dest, DN_USize dest_size)
DN_API DN_USize DN_CVT_BytesFromHexPtrUnchecked(DN_Str8 hex, void *dest, DN_USize dest_size)
{
DN_USize result = 0;
unsigned char *dest_u8 = DN_CAST(unsigned char *) dest;
@@ -302,8 +330,8 @@ DN_API DN_USize DN_CVT_HexToBytesPtrUnchecked(DN_Str8 hex, void *dest, DN_USize
for (DN_USize hex_index = 0; hex_index < hex.size; hex_index += 2, result += 1) {
char hex01 = hex.data[hex_index];
char hex02 = (hex_index + 1 < hex.size) ? hex.data[hex_index + 1] : 0;
char bit4_01 = DN_Char_HexToU8(hex01).value;
char bit4_02 = DN_Char_HexToU8(hex02).value;
char bit4_01 = DN_CVT_U8FromHexNibble(hex01);
char bit4_02 = DN_CVT_U8FromHexNibble(hex02);
char byte = (bit4_01 << 4) | (bit4_02 << 0);
dest_u8[result] = byte;
}
@@ -312,7 +340,7 @@ DN_API DN_USize DN_CVT_HexToBytesPtrUnchecked(DN_Str8 hex, void *dest, DN_USize
return result;
}
DN_API DN_USize DN_CVT_HexToBytesPtr(DN_Str8 hex, void *dest, DN_USize dest_size)
DN_API DN_USize DN_CVT_BytesFromHexPtr(DN_Str8 hex, void *dest, DN_USize dest_size)
{
hex = DN_Str8_TrimPrefix(hex, DN_STR8("0x"));
hex = DN_Str8_TrimPrefix(hex, DN_STR8("0X"));
@@ -329,22 +357,22 @@ DN_API DN_USize DN_CVT_HexToBytesPtr(DN_Str8 hex, void *dest, DN_USize dest_size
if (hex.size <= 0 || !DN_Check(dest_size >= min_buffer_size))
return result;
result = DN_CVT_HexToBytesPtrUnchecked(hex, dest, dest_size);
result = DN_CVT_BytesFromHexPtrUnchecked(hex, dest, dest_size);
return result;
}
DN_API DN_Str8 DN_CVT_HexToBytesUnchecked(DN_Arena *arena, DN_Str8 hex)
DN_API DN_Str8 DN_CVT_BytesFromHexUnchecked(DN_Arena *arena, DN_Str8 hex)
{
DN_USize hex_size_rounded_up = hex.size + (hex.size % 2);
DN_Str8 result = DN_Str8_Alloc(arena, (hex_size_rounded_up / 2), DN_ZeroMem_No);
if (result.data) {
DN_USize bytes_written = DN_CVT_HexToBytesPtr(hex, result.data, result.size);
DN_USize bytes_written = DN_CVT_BytesFromHexPtr(hex, result.data, result.size);
DN_Assert(bytes_written == result.size);
}
return result;
}
DN_API DN_Str8 DN_CVT_HexToBytes(DN_Arena *arena, DN_Str8 hex)
DN_API DN_Str8 DN_CVT_BytesFromHex(DN_Arena *arena, DN_Str8 hex)
{
hex = DN_Str8_TrimPrefix(hex, DN_STR8("0x"));
hex = DN_Str8_TrimPrefix(hex, DN_STR8("0X"));
@@ -356,6 +384,6 @@ DN_API DN_Str8 DN_CVT_HexToBytes(DN_Arena *arena, DN_Str8 hex)
if (!DN_Check(DN_Str8_IsAll(hex, DN_Str8IsAll_Hex)))
return result;
result = DN_CVT_HexToBytesUnchecked(arena, hex);
result = DN_CVT_BytesFromHexUnchecked(arena, hex);
return result;
}
Source/Base/dn_base_convert.h
+37 -28
View File
@@ -54,35 +54,44 @@ enum DN_CVTU64AgeUnit_
DN_CVTU64AgeUnit_All = DN_CVTU64AgeUnit_HMS | DN_CVTU64AgeUnit_Day | DN_CVTU64AgeUnit_Week | DN_CVTU64AgeUnit_Year,
};
DN_API int DN_CVT_FmtBuffer3DotTruncate (char *buffer, int size, DN_FMT_ATTRIB char const *fmt, ...);
DN_API DN_CVTU64Str8 DN_CVT_U64ToStr8 (DN_U64 val, char separator);
DN_API DN_CVTU64Bytes DN_CVT_U64ToBytes (DN_U64 bytes, DN_CVTBytesType type);
#define DN_CVT_U64ToBytesAuto(bytes) DN_CVT_U64ToBytes(bytes, DN_CVTBytesType_Auto)
DN_API DN_Str8 DN_CVT_U64ToBytesStr8 (DN_Arena *arena, DN_U64 bytes, DN_CVTBytesType type);
#define DN_CVT_U64ToBytesStr8Auto(arena, bytes) DN_CVT_U64ToBytesStr8(arena, bytes, DN_CVTBytesType_Auto)
#define DN_CVT_U64ToBytesStr8FromTLS(bytes, type) DN_CVT_U64ToBytesStr8(DN_OS_TLSTopArena(), bytes, type)
#define DN_CVT_U64ToBytesStr8AutoFromTLS(bytes) DN_CVT_U64ToBytesStr8(DN_OS_TLSTopArena(), bytes, DN_CVTBytesType_Auto)
#define DN_CVT_U64ToBytesStr8FromFrame(bytes, type) DN_CVT_U64ToBytesStr8(DN_OS_TLSFrameArena(), bytes, type)
#define DN_CVT_U64ToBytesStr8AutoFromFrame(bytes) DN_CVT_U64ToBytesStr8(DN_OS_TLSFrameArena(), bytes, DN_CVTBytesType_Auto)
DN_API DN_Str8 DN_CVT_BytesTypeToStr8 (DN_CVTBytesType type);
DN_API DN_Str8 DN_CVT_U64ToAge (DN_Arena *arena, DN_U64 age_s, DN_CVTU64AgeUnit unit);
DN_API DN_Str8 DN_CVT_F64ToAge (DN_Arena *arena, DN_F64 age_s, DN_CVTU64AgeUnit unit);
struct DN_NibbleFromU8Result
{
char nibble0;
char nibble1;
};
DN_API DN_U64 DN_CVT_HexToU64 (DN_Str8 hex);
DN_API DN_Str8 DN_CVT_U64ToHex (DN_Arena *arena, DN_U64 number, DN_CVTU64HexStrFlags flags);
#define DN_CVT_U64ToHexFromFrame(number, flags) DN_CVT_U64ToHex(DN_OS_TLSFrameArena(), number, flags)
DN_API DN_CVTU64HexStr DN_CVT_U64ToHexStr (DN_U64 number, DN_CVTU64HexStrFlags flags);
DN_API DN_NibbleFromU8Result DN_CVT_NibbleFromU8 (DN_U8 u8);
DN_API DN_U8 DN_CVT_U8FromHexNibble (char hex);
DN_API bool DN_CVT_BytesToHexPtr (void const *src, DN_USize src_size, char *dest, DN_USize dest_size);
DN_API DN_Str8 DN_CVT_BytesToHex (DN_Arena *arena, void const *src, DN_USize size);
#define DN_CVT_BytesToHexFromTLS(...) DN_CVT_BytesToHex(DN_OS_TLSTopArena(), __VA_ARGS__)
#define DN_CVT_BytesToHexFromFrame(...) DN_CVT_BytesToHex(DN_OS_TLSFrameArena(), __VA_ARGS__)
DN_API int DN_CVT_FmtBuffer3DotTruncate (char *buffer, int size, DN_FMT_ATTRIB char const *fmt, ...);
DN_API DN_CVTU64Str8 DN_CVT_Str8FromU64 (DN_U64 val, char separator);
DN_API DN_CVTU64Bytes DN_CVT_BytesFromU64 (DN_U64 bytes, DN_CVTBytesType type);
#define DN_CVT_BytesFromU64Auto(bytes) DN_CVT_BytesFromU64(bytes, DN_CVTBytesType_Auto)
DN_API DN_Str8 DN_CVT_BytesStr8FromU64 (DN_Arena *arena, DN_U64 bytes, DN_CVTBytesType type);
#define DN_CVT_BytesStr8FromU64Auto(arena, bytes) DN_CVT_BytesStr8FromU64(arena, bytes, DN_CVTBytesType_Auto)
#define DN_CVT_BytesStr8FromTLS(bytes, type) DN_CVT_BytesStr8FromU64(DN_OS_TLSTopArena(), bytes, type)
#define DN_CVT_BytesStr8FromU64AutoTLS(bytes) DN_CVT_BytesStr8FromU64(DN_OS_TLSTopArena(), bytes, DN_CVTBytesType_Auto)
#define DN_CVT_BytesStr8FromU64Frame(bytes, type) DN_CVT_BytesStr8FromU64(DN_OS_TLSFrameArena(), bytes, type)
#define DN_CVT_BytesStr8FromU64AutoFrame(bytes) DN_CVT_BytesStr8FromU64(DN_OS_TLSFrameArena(), bytes, DN_CVTBytesType_Auto)
DN_API DN_Str8 DN_CVT_BytesTypeToStr8 (DN_CVTBytesType type);
DN_API DN_Str8 DN_CVT_AgeFromU64 (DN_Arena *arena, DN_U64 age_s, DN_CVTU64AgeUnit unit);
DN_API DN_Str8 DN_CVT_AgeFromF64 (DN_Arena *arena, DN_F64 age_s, DN_CVTU64AgeUnit unit);
DN_API DN_USize DN_CVT_HexToBytesPtrUnchecked (DN_Str8 hex, void *dest, DN_USize dest_size);
DN_API DN_USize DN_CVT_HexToBytesPtr (DN_Str8 hex, void *dest, DN_USize dest_size);
DN_API DN_Str8 DN_CVT_HexToBytesUnchecked (DN_Arena *arena, DN_Str8 hex);
#define DN_CVT_HexToBytesUncheckedFromTLS(...) DN_CVT_HexToBytesUnchecked(DN_OS_TLSTopArena(), __VA_ARGS__)
DN_API DN_Str8 DN_CVT_HexToBytes (DN_Arena *arena, DN_Str8 hex);
#define DN_CVT_HexToBytesFromFrame(...) DN_CVT_HexToBytes(DN_OS_TLSFrameArena(), __VA_ARGS__)
#define DN_CVT_HexToBytesFromTLS(...) DN_CVT_HexToBytes(DN_OS_TLSTopArena(), __VA_ARGS__)
DN_API DN_U64 DN_CVT_U64FromHex (DN_Str8 hex);
DN_API DN_Str8 DN_CVT_HexFromU64 (DN_Arena *arena, DN_U64 number, DN_CVTU64HexStrFlags flags);
#define DN_CVT_HexFromU64Frame(number, flags) DN_CVT_HexFromU64(DN_OS_TLSFrameArena(), number, flags)
DN_API DN_CVTU64HexStr DN_CVT_HexFromU64Str (DN_U64 number, DN_CVTU64HexStrFlags flags);
DN_API bool DN_CVT_HexFromBytesPtr (void const *src, DN_USize src_size, char *dest, DN_USize dest_size);
DN_API DN_Str8 DN_CVT_HexFromBytes (DN_Arena *arena, void const *src, DN_USize size);
#define DN_CVT_HexFromBytesTLS(...) DN_CVT_HexFromBytes(DN_OS_TLSTopArena(), __VA_ARGS__)
#define DN_CVT_HexFromBytesFrame(...) DN_CVT_HexFromBytes(DN_OS_TLSFrameArena(), __VA_ARGS__)
DN_API DN_USize DN_CVT_BytesFromHexPtrUnchecked (DN_Str8 hex, void *dest, DN_USize dest_size);
DN_API DN_USize DN_CVT_BytesFromHexPtr (DN_Str8 hex, void *dest, DN_USize dest_size);
DN_API DN_Str8 DN_CVT_BytesFromHexUnchecked (DN_Arena *arena, DN_Str8 hex);
#define DN_CVT_BytesFromHexUncheckedFromTLS(...) DN_CVT_BytesFromHexUnchecked(DN_OS_TLSTopArena(), __VA_ARGS__)
DN_API DN_Str8 DN_CVT_BytesFromHex (DN_Arena *arena, DN_Str8 hex);
#define DN_CVT_BytesFromHexFrame(...) DN_CVT_BytesFromHex(DN_OS_TLSFrameArena(), __VA_ARGS__)
#define DN_CVT_BytesFromHexTLS(...) DN_CVT_BytesFromHex(DN_OS_TLSTopArena(), __VA_ARGS__)
#endif // defined(DN_BASE_CONVERT_H)
Source/Base/dn_base_mem.cpp
+11 -9
View File
@@ -1,6 +1,8 @@
#define DN_BASE_MEM_CPP
static DN_ArenaBlock *DN_Arena_BlockInitFromMemFuncs_(DN_U64 reserve, DN_U64 commit, bool track_alloc, bool alloc_can_leak, DN_ArenaMemFuncs mem_funcs)
#include "../dn_base_inc.h"
static DN_ArenaBlock *DN_Arena_BlockFromMemFuncs_(DN_U64 reserve, DN_U64 commit, bool track_alloc, bool alloc_can_leak, DN_ArenaMemFuncs mem_funcs)
{
DN_ArenaBlock *result = nullptr;
switch (mem_funcs.type) {
@@ -51,11 +53,11 @@ static DN_ArenaBlock *DN_Arena_BlockInitFromMemFuncs_(DN_U64 reserve, DN_U64 com
return result;
}
static DN_ArenaBlock *DN_Arena_BlockInitFlagsFromMemFuncs_(DN_U64 reserve, DN_U64 commit, DN_ArenaFlags flags, DN_ArenaMemFuncs mem_funcs)
static DN_ArenaBlock *DN_Arena_BlockFlagsFromMemFuncs_(DN_U64 reserve, DN_U64 commit, DN_ArenaFlags flags, DN_ArenaMemFuncs mem_funcs)
{
bool track_alloc = (flags & DN_ArenaFlags_NoAllocTrack) == 0;
bool alloc_can_leak = flags & DN_ArenaFlags_AllocCanLeak;
DN_ArenaBlock *result = DN_Arena_BlockInitFromMemFuncs_(reserve, commit, track_alloc, alloc_can_leak, mem_funcs);
DN_ArenaBlock *result = DN_Arena_BlockFromMemFuncs_(reserve, commit, track_alloc, alloc_can_leak, mem_funcs);
if (result && ((flags & DN_ArenaFlags_NoPoison) == 0))
DN_ASanPoisonMemoryRegion(DN_CAST(char *) result + DN_ARENA_HEADER_SIZE, result->commit - DN_ARENA_HEADER_SIZE);
return result;
@@ -77,7 +79,7 @@ static void DN_Arena_UpdateStatsOnNewBlock_(DN_Arena *arena, DN_ArenaBlock const
}
}
DN_API DN_Arena DN_Arena_InitFromBuffer(void *buffer, DN_USize size, DN_ArenaFlags flags)
DN_API DN_Arena DN_Arena_FromBuffer(void *buffer, DN_USize size, DN_ArenaFlags flags)
{
DN_Assert(buffer);
DN_AssertF(DN_ARENA_HEADER_SIZE < size, "Buffer (%zu bytes) too small, need atleast %zu bytes to store arena metadata", size, DN_ARENA_HEADER_SIZE);
@@ -98,13 +100,13 @@ DN_API DN_Arena DN_Arena_InitFromBuffer(void *buffer, DN_USize size, DN_ArenaFla
return result;
}
DN_API DN_Arena DN_Arena_InitFromMemFuncs(DN_U64 reserve, DN_U64 commit, DN_ArenaFlags flags, DN_ArenaMemFuncs mem_funcs)
DN_API DN_Arena DN_Arena_FromMemFuncs(DN_U64 reserve, DN_U64 commit, DN_ArenaFlags flags, DN_ArenaMemFuncs mem_funcs)
{
DN_Arena result = {};
result.flags = flags;
result.mem_funcs = mem_funcs;
result.flags |= DN_ArenaFlags_MemFuncs;
result.curr = DN_Arena_BlockInitFlagsFromMemFuncs_(reserve, commit, flags, mem_funcs);
result.curr = DN_Arena_BlockFlagsFromMemFuncs_(reserve, commit, flags, mem_funcs);
DN_Arena_UpdateStatsOnNewBlock_(&result, result.curr);
return result;
}
@@ -177,7 +179,7 @@ DN_API bool DN_Arena_Grow(DN_Arena *arena, DN_U64 reserve, DN_U64 commit)
return false;
bool result = false;
DN_ArenaBlock *new_block = DN_Arena_BlockInitFlagsFromMemFuncs_(reserve, commit, arena->flags, arena->mem_funcs);
DN_ArenaBlock *new_block = DN_Arena_BlockFlagsFromMemFuncs_(reserve, commit, arena->flags, arena->mem_funcs);
if (new_block) {
result = true;
new_block->prev = arena->curr;
@@ -194,7 +196,7 @@ DN_API void *DN_Arena_Alloc(DN_Arena *arena, DN_U64 size, uint8_t align, DN_Zero
return nullptr;
if (!arena->curr) {
arena->curr = DN_Arena_BlockInitFlagsFromMemFuncs_(DN_ARENA_RESERVE_SIZE, DN_ARENA_COMMIT_SIZE, arena->flags, arena->mem_funcs);
arena->curr = DN_Arena_BlockFlagsFromMemFuncs_(DN_ARENA_RESERVE_SIZE, DN_ARENA_COMMIT_SIZE, arena->flags, arena->mem_funcs);
DN_Arena_UpdateStatsOnNewBlock_(arena, arena->curr);
}
@@ -394,7 +396,7 @@ DN_ArenaTempMemScope::~DN_ArenaTempMemScope()
}
// NOTE: DN_Pool ///////////////////////////////////////////////////////////////////////////////////
DN_API DN_Pool DN_Pool_Init(DN_Arena *arena, uint8_t align)
DN_API DN_Pool DN_Pool_FromArena(DN_Arena *arena, uint8_t align)
{
DN_Pool result = {};
if (arena) {
Source/Base/dn_base_mem.h
+3 -3
View File
@@ -199,8 +199,8 @@ struct DN_Pool
DN_U8 align;
};
DN_API DN_Arena DN_Arena_InitFromBuffer (void *buffer, DN_USize size, DN_ArenaFlags flags);
DN_API DN_Arena DN_Arena_InitFromMemFuncs (DN_U64 reserve, DN_U64 commit, DN_ArenaFlags flags, DN_ArenaMemFuncs mem_funcs);
DN_API DN_Arena DN_Arena_FromBuffer (void *buffer, DN_USize size, DN_ArenaFlags flags);
DN_API DN_Arena DN_Arena_FromMemFuncs (DN_U64 reserve, DN_U64 commit, DN_ArenaFlags flags, DN_ArenaMemFuncs mem_funcs);
DN_API void DN_Arena_Deinit (DN_Arena *arena);
DN_API bool DN_Arena_Commit (DN_Arena *arena, DN_U64 size);
DN_API bool DN_Arena_CommitTo (DN_Arena *arena, DN_U64 pos);
@@ -224,7 +224,7 @@ DN_API void DN_Arena_TempMemEnd (DN_ArenaTem
#define DN_Arena_NewCopy(arena, T, src) (T *)DN_Arena_Copy (arena, (src), sizeof(T), alignof(T))
#define DN_Arena_NewArrayCopy(arena, T, src, count) (T *)DN_Arena_Copy (arena, (src), sizeof(T) * (count), alignof(T))
DN_API DN_Pool DN_Pool_Init (DN_Arena *arena, DN_U8 align);
DN_API DN_Pool DN_Pool_FromArena (DN_Arena *arena, DN_U8 align);
DN_API bool DN_Pool_IsValid (DN_Pool const *pool);
DN_API void * DN_Pool_Alloc (DN_Pool *pool, DN_USize size);
DN_API DN_Str8 DN_Pool_AllocStr8FV (DN_Pool *pool, DN_FMT_ATTRIB char const *fmt, va_list args);
Source/Base/dn_base_string.cpp
+89 -114
View File
@@ -1,5 +1,7 @@
#define DN_STRING_CPP
#include "../dn_base_inc.h"
// NOTE: DN_CStr8 //////////////////////////////////////////////////////////////////////////////////
DN_API DN_USize DN_CStr8_FSize(DN_FMT_ATTRIB char const *fmt, ...)
{
@@ -56,13 +58,47 @@ DN_API bool operator!=(DN_Str16 const &lhs, DN_Str16 const &rhs)
}
// NOTE: DN_Str8 ///////////////////////////////////////////////////////////////////////////////////
DN_API DN_Str8 DN_Str8_InitCStr8(char const *src)
DN_API DN_Str8 DN_Str8_Alloc(DN_Arena *arena, DN_USize size, DN_ZeroMem zero_mem)
{
DN_Str8 result = {};
result.data = DN_Arena_NewArray(arena, char, size + 1, zero_mem);
if (result.data)
result.size = size;
result.data[result.size] = 0;
return result;
}
DN_API DN_Str8 DN_Str8_FromCStr8(char const *src)
{
DN_USize size = DN_CStr8_Size(src);
DN_Str8 result = DN_Str8_Init(src, size);
return result;
}
DN_API DN_Str8 DN_Str8_FromF(DN_Arena *arena, DN_FMT_ATTRIB char const *fmt, ...)
{
va_list va;
va_start(va, fmt);
DN_Str8 result = DN_Str8_FromFV(arena, fmt, va);
va_end(va);
return result;
}
DN_API DN_Str8 DN_Str8_FromFV(DN_Arena *arena, DN_FMT_ATTRIB char const *fmt, va_list args)
{
DN_Str8 result = {};
if (!fmt)
return result;
DN_USize size = DN_CStr8_FVSize(fmt, args);
if (size) {
result = DN_Str8_Alloc(arena, size, DN_ZeroMem_No);
if (DN_Str8_HasData(result))
DN_VSNPrintF(result.data, DN_SaturateCastISizeToInt(size + 1 /*null-terminator*/), fmt, args);
}
return result;
}
DN_API bool DN_Str8_IsAll(DN_Str8 string, DN_Str8IsAll is_all)
{
bool result = DN_Str8_HasData(string);
@@ -114,13 +150,13 @@ DN_API DN_Str8 DN_Str8_Advance(DN_Str8 string, DN_USize amount)
DN_API DN_Str8 DN_Str8_NextLine(DN_Str8 string)
{
DN_Str8 result = DN_Str8_BinarySplit(string, DN_STR8("\n")).rhs;
DN_Str8 result = DN_Str8_BSplit(string, DN_STR8("\n")).rhs;
return result;
}
DN_API DN_Str8BinarySplitResult DN_Str8_BinarySplitArray(DN_Str8 string, DN_Str8 const *find, DN_USize find_size)
DN_API DN_Str8BSplitResult DN_Str8_BSplitArray(DN_Str8 string, DN_Str8 const *find, DN_USize find_size)
{
DN_Str8BinarySplitResult result = {};
DN_Str8BSplitResult result = {};
if (!DN_Str8_HasData(string) || !find || find_size == 0)
return result;
@@ -141,15 +177,15 @@ DN_API DN_Str8BinarySplitResult DN_Str8_BinarySplitArray(DN_Str8 string, DN_Str8
return result;
}
DN_API DN_Str8BinarySplitResult DN_Str8_BinarySplit(DN_Str8 string, DN_Str8 find)
DN_API DN_Str8BSplitResult DN_Str8_BSplit(DN_Str8 string, DN_Str8 find)
{
DN_Str8BinarySplitResult result = DN_Str8_BinarySplitArray(string, &find, 1);
DN_Str8BSplitResult result = DN_Str8_BSplitArray(string, &find, 1);
return result;
}
DN_API DN_Str8BinarySplitResult DN_Str8_BinarySplitLastArray(DN_Str8 string, DN_Str8 const *find, DN_USize find_size)
DN_API DN_Str8BSplitResult DN_Str8_BSplitLastArray(DN_Str8 string, DN_Str8 const *find, DN_USize find_size)
{
DN_Str8BinarySplitResult result = {};
DN_Str8BSplitResult result = {};
if (!DN_Str8_HasData(string) || !find || find_size == 0)
return result;
@@ -170,9 +206,9 @@ DN_API DN_Str8BinarySplitResult DN_Str8_BinarySplitLastArray(DN_Str8 string, DN_
return result;
}
DN_API DN_Str8BinarySplitResult DN_Str8_BinarySplitLast(DN_Str8 string, DN_Str8 find)
DN_API DN_Str8BSplitResult DN_Str8_BSplitLast(DN_Str8 string, DN_Str8 find)
{
DN_Str8BinarySplitResult result = DN_Str8_BinarySplitLastArray(string, &find, 1);
DN_Str8BSplitResult result = DN_Str8_BSplitLastArray(string, &find, 1);
return result;
}
@@ -182,10 +218,10 @@ DN_API DN_USize DN_Str8_Split(DN_Str8 string, DN_Str8 delimiter, DN_Str8 *splits
if (!DN_Str8_HasData(string) || !DN_Str8_HasData(delimiter) || delimiter.size <= 0)
return result;
DN_Str8BinarySplitResult split = {};
DN_Str8BSplitResult split = {};
DN_Str8 first = string;
do {
split = DN_Str8_BinarySplit(first, delimiter);
split = DN_Str8_BSplit(first, delimiter);
if (split.lhs.size || mode == DN_Str8SplitIncludeEmptyStrings_Yes) {
if (splits && result < splits_count)
splits[result] = split.lhs;
@@ -212,9 +248,6 @@ DN_API DN_Slice<DN_Str8> DN_Str8_SplitAlloc(DN_Arena *arena, DN_Str8 string, DN_
DN_API DN_Str8FindResult DN_Str8_FindStr8Array(DN_Str8 string, DN_Str8 const *find, DN_USize find_size, DN_Str8EqCase eq_case)
{
DN_Str8FindResult result = {};
if (!DN_Str8_HasData(string) || !find || find_size == 0)
return result;
for (DN_USize index = 0; !result.found && index < string.size; index++) {
for (DN_USize find_index = 0; find_index < find_size; find_index++) {
DN_Str8 find_item = find[find_index];
@@ -261,7 +294,7 @@ DN_API DN_Str8FindResult DN_Str8_Find(DN_Str8 string, uint32_t flags)
DN_API DN_Str8 DN_Str8_Segment(DN_Arena *arena, DN_Str8 src, DN_USize segment_size, char segment_char)
{
if (!segment_size || !DN_Str8_HasData(src)) {
DN_Str8 result = DN_Str8_Copy(arena, src);
DN_Str8 result = DN_Str8_FromStr8(arena, src);
return result;
}
@@ -288,7 +321,7 @@ DN_API DN_Str8 DN_Str8_Segment(DN_Arena *arena, DN_Str8 src, DN_USize segment_si
DN_API DN_Str8 DN_Str8_ReverseSegment(DN_Arena *arena, DN_Str8 src, DN_USize segment_size, char segment_char)
{
if (!segment_size || !DN_Str8_HasData(src)) {
DN_Str8 result = DN_Str8_Copy(arena, src);
DN_Str8 result = DN_Str8_FromStr8(arena, src);
return result;
}
@@ -473,7 +506,7 @@ DN_API DN_Str8 DN_Str8_TrimByteOrderMark(DN_Str8 string)
DN_API DN_Str8 DN_Str8_FileNameFromPath(DN_Str8 path)
{
DN_Str8 separators[] = {DN_STR8("/"), DN_STR8("\\")};
DN_Str8BinarySplitResult split = DN_Str8_BinarySplitLastArray(path, separators, DN_ArrayCountU(separators));
DN_Str8BSplitResult split = DN_Str8_BSplitLastArray(path, separators, DN_ArrayCountU(separators));
DN_Str8 result = DN_Str8_HasData(split.rhs) ? split.rhs : split.lhs;
return result;
}
@@ -487,14 +520,14 @@ DN_API DN_Str8 DN_Str8_FileNameNoExtension(DN_Str8 path)
DN_API DN_Str8 DN_Str8_FilePathNoExtension(DN_Str8 path)
{
DN_Str8BinarySplitResult split = DN_Str8_BinarySplitLast(path, DN_STR8("."));
DN_Str8BSplitResult split = DN_Str8_BSplitLast(path, DN_STR8("."));
DN_Str8 result = split.lhs;
return result;
}
DN_API DN_Str8 DN_Str8_FileExtension(DN_Str8 path)
{
DN_Str8BinarySplitResult split = DN_Str8_BinarySplitLast(path, DN_STR8("."));
DN_Str8BSplitResult split = DN_Str8_BSplitLast(path, DN_STR8("."));
DN_Str8 result = split.rhs;
return result;
}
@@ -502,7 +535,7 @@ DN_API DN_Str8 DN_Str8_FileExtension(DN_Str8 path)
DN_API DN_Str8 DN_Str8_FileDirectoryFromPath(DN_Str8 path)
{
DN_Str8 separators[] = {DN_STR8("/"), DN_STR8("\\")};
DN_Str8BinarySplitResult split = DN_Str8_BinarySplitLastArray(path, separators, DN_ArrayCountU(separators));
DN_Str8BSplitResult split = DN_Str8_BSplitLastArray(path, separators, DN_ArrayCountU(separators));
DN_Str8 result = split.lhs;
return result;
}
@@ -611,7 +644,7 @@ DN_API DN_Str8 DN_Str8_AppendF(DN_Arena *arena, DN_Str8 string, char const *fmt,
DN_API DN_Str8 DN_Str8_AppendFV(DN_Arena *arena, DN_Str8 string, char const *fmt, va_list args)
{
// TODO: Calculate size and write into one buffer instead of 2 appends
DN_Str8 append = DN_Str8_InitFV(arena, fmt, args);
DN_Str8 append = DN_Str8_FromFV(arena, fmt, args);
DN_Str8 result = DN_Str8_Alloc(arena, string.size + append.size, DN_ZeroMem_No);
DN_Memcpy(result.data, string.data, string.size);
DN_Memcpy(result.data + string.size, append.data, append.size);
@@ -629,7 +662,7 @@ DN_API DN_Str8 DN_Str8_FillF(DN_Arena *arena, DN_USize count, char const *fmt, .
DN_API DN_Str8 DN_Str8_FillFV(DN_Arena *arena, DN_USize count, char const *fmt, va_list args)
{
DN_Str8 fill = DN_Str8_InitFV(arena, fmt, args);
DN_Str8 fill = DN_Str8_FromFV(arena, fmt, args);
DN_Str8 result = DN_Str8_Alloc(arena, count * fill.size, DN_ZeroMem_No);
for (DN_USize index = 0; index < count; index++) {
void *dest = result.data + (index * fill.size);
@@ -655,15 +688,15 @@ DN_API DN_Str8DotTruncateResult DN_Str8_DotTruncateMiddle(DN_Arena *arena, DN_St
{
DN_Str8DotTruncateResult result = {};
if (str8.size <= (side_size * 2)) {
result.str8 = DN_Str8_Copy(arena, str8);
result.str8 = DN_Str8_FromStr8(arena, str8);
return result;
}
DN_Str8 head = DN_Str8_Slice(str8, 0, side_size);
DN_Str8 tail = DN_Str8_Slice(str8, str8.size - side_size, side_size);
DN_MSVC_WARNING_PUSH
DN_MSVC_WARNING_DISABLE(6284) // Object passed as _Param_(3) when a string is required in call to 'DN_Str8_InitF' Actual type: 'struct DN_Str8'
result.str8 = DN_Str8_InitF(arena, "%S%S%S", head, truncator, tail);
DN_MSVC_WARNING_DISABLE(6284) // Object passed as _Param_(3) when a string is required in call to 'DN_Str8_FromF' Actual type: 'struct DN_Str8'
result.str8 = DN_Str8_FromF(arena, "%S%S%S", head, truncator, tail);
DN_MSVC_WARNING_POP
result.truncated = true;
return result;
@@ -671,7 +704,7 @@ DN_API DN_Str8DotTruncateResult DN_Str8_DotTruncateMiddle(DN_Arena *arena, DN_St
DN_API DN_Str8 DN_Str8_Lower(DN_Arena *arena, DN_Str8 string)
{
DN_Str8 result = DN_Str8_Copy(arena, string);
DN_Str8 result = DN_Str8_FromStr8(arena, string);
for (DN_ForIndexU(index, result.size))
result.data[index] = DN_Char_ToLower(result.data[index]);
return result;
@@ -679,7 +712,7 @@ DN_API DN_Str8 DN_Str8_Lower(DN_Arena *arena, DN_Str8 string)
DN_API DN_Str8 DN_Str8_Upper(DN_Arena *arena, DN_Str8 string)
{
DN_Str8 result = DN_Str8_Copy(arena, string);
DN_Str8 result = DN_Str8_FromStr8(arena, string);
for (DN_ForIndexU(index, result.size))
result.data[index] = DN_Char_ToUpper(result.data[index]);
return result;
@@ -699,41 +732,7 @@ DN_API bool operator!=(DN_Str8 const &lhs, DN_Str8 const &rhs)
}
#endif
DN_API DN_Str8 DN_Str8_InitF(DN_Arena *arena, DN_FMT_ATTRIB char const *fmt, ...)
{
va_list va;
va_start(va, fmt);
DN_Str8 result = DN_Str8_InitFV(arena, fmt, va);
va_end(va);
return result;
}
DN_API DN_Str8 DN_Str8_InitFV(DN_Arena *arena, DN_FMT_ATTRIB char const *fmt, va_list args)
{
DN_Str8 result = {};
if (!fmt)
return result;
DN_USize size = DN_CStr8_FVSize(fmt, args);
if (size) {
result = DN_Str8_Alloc(arena, size, DN_ZeroMem_No);
if (DN_Str8_HasData(result))
DN_VSNPrintF(result.data, DN_SaturateCastISizeToInt(size + 1 /*null-terminator*/), fmt, args);
}
return result;
}
DN_API DN_Str8 DN_Str8_Alloc(DN_Arena *arena, DN_USize size, DN_ZeroMem zero_mem)
{
DN_Str8 result = {};
result.data = DN_Arena_NewArray(arena, char, size + 1, zero_mem);
if (result.data)
result.size = size;
result.data[result.size] = 0;
return result;
}
DN_API DN_Str8 DN_Str8_Copy(DN_Arena *arena, DN_Str8 string)
DN_API DN_Str8 DN_Str8_FromStr8(DN_Arena *arena, DN_Str8 string)
{
DN_Str8 result = DN_Str8_Alloc(arena, string.size, DN_ZeroMem_No);
if (DN_Str8_HasData(result)) {
@@ -744,31 +743,35 @@ DN_API DN_Str8 DN_Str8_Copy(DN_Arena *arena, DN_Str8 string)
}
// NOTE: DN_Str8Builder ////////////////////////////////////////////////////////////////////////////
DN_API DN_Str8Builder DN_Str8Builder_Init(DN_Arena *arena)
DN_API DN_Str8Builder DN_Str8Builder_FromArena(DN_Arena *arena)
{
DN_Str8Builder result = {};
result.arena = arena;
return result;
}
DN_API DN_Str8Builder DN_Str8Builder_InitArrayRef(DN_Arena *arena,
DN_Str8 const *strings,
DN_USize size)
DN_API DN_Str8Builder DN_Str8Builder_FromStr8PtrRef(DN_Arena *arena, DN_Str8 const *strings, DN_USize size)
{
DN_Str8Builder result = DN_Str8Builder_Init(arena);
DN_Str8Builder result = DN_Str8Builder_FromArena(arena);
DN_Str8Builder_AppendArrayRef(&result, strings, size);
return result;
}
DN_API DN_Str8Builder DN_Str8Builder_InitArrayCopy(DN_Arena *arena,
DN_Str8 const *strings,
DN_USize size)
DN_API DN_Str8Builder DN_Str8Builder_FromStr8PtrCopy(DN_Arena *arena, DN_Str8 const *strings, DN_USize size)
{
DN_Str8Builder result = DN_Str8Builder_Init(arena);
DN_Str8Builder result = DN_Str8Builder_FromArena(arena);
DN_Str8Builder_AppendArrayCopy(&result, strings, size);
return result;
}
DN_API DN_Str8Builder DN_Str8Builder_FromBuilder(DN_Arena *arena, DN_Str8Builder const *builder)
{
DN_Str8Builder result = DN_Str8Builder_FromArena(arena);
DN_Str8Builder_AppendBuilderCopy(&result, builder);
return result;
}
DN_API bool DN_Str8Builder_AddArrayRef(DN_Str8Builder *builder, DN_Str8 const *strings, DN_USize size, DN_Str8BuilderAdd add)
{
if (!builder)
@@ -830,7 +833,7 @@ DN_API bool DN_Str8Builder_AddArrayCopy(DN_Str8Builder *builder, DN_Str8 const *
bool result = true;
DN_Str8 *strings_copy = DN_Arena_NewArray(builder->arena, DN_Str8, size, DN_ZeroMem_No);
for (DN_ForIndexU(index, size)) {
strings_copy[index] = DN_Str8_Copy(builder->arena, strings[index]);
strings_copy[index] = DN_Str8_FromStr8(builder->arena, strings[index]);
if (strings_copy[index].size != strings[index].size) {
result = false;
break;
@@ -848,7 +851,7 @@ DN_API bool DN_Str8Builder_AddArrayCopy(DN_Str8Builder *builder, DN_Str8 const *
DN_API bool DN_Str8Builder_AddFV(DN_Str8Builder *builder, DN_Str8BuilderAdd add, DN_FMT_ATTRIB char const *fmt, va_list args)
{
DN_Str8 string = DN_Str8_InitFV(builder->arena, fmt, args);
DN_Str8 string = DN_Str8_FromFV(builder->arena, fmt, args);
DN_ArenaTempMem temp_mem = DN_Arena_TempMemBegin(builder->arena);
bool result = DN_Str8Builder_AddArrayRef(builder, &string, 1, add);
if (!result)
@@ -913,7 +916,7 @@ static bool DN_Str8Builder_AppendBuilder_(DN_Str8Builder *dest, DN_Str8Builder c
link->string = it->string;
if (copy) {
link->string = DN_Str8_Copy(dest->arena, it->string);
link->string = DN_Str8_FromStr8(dest->arena, it->string);
if (link->string.size != it->string.size) {
result = false;
break;
@@ -985,13 +988,6 @@ DN_API bool DN_Str8Builder_Erase(DN_Str8Builder *builder, DN_Str8 string)
return false;
}
DN_API DN_Str8Builder DN_Str8Builder_Copy(DN_Arena *arena, DN_Str8Builder const *builder)
{
DN_Str8Builder result = DN_Str8Builder_Init(arena);
DN_Str8Builder_AppendBuilderCopy(&result, builder);
return result;
}
DN_API DN_Str8 DN_Str8Builder_Build(DN_Str8Builder const *builder, DN_Arena *arena)
{
DN_Str8 result = DN_Str8Builder_BuildDelimited(builder, DN_STR8(""), arena);
@@ -1038,12 +1034,22 @@ DN_API DN_Slice<DN_Str8> DN_Str8Builder_BuildSlice(DN_Str8Builder const *builder
DN_USize slice_index = 0;
for (DN_Str8Link *link = builder->head; link; link = link->next)
result.data[slice_index++] = DN_Str8_Copy(arena, link->string);
result.data[slice_index++] = DN_Str8_FromStr8(arena, link->string);
DN_Assert(slice_index == builder->count);
return result;
}
DN_API DN_Str8 DN_LStr8_AppendF(char *buf, DN_USize *buf_size, DN_USize buf_max, char const *fmt, ...)
{
va_list args;
va_start(args, fmt);
*buf_size += DN_VSNPrintF(buf + *buf_size, DN_CAST(int)(buf_max - *buf_size), fmt, args);
va_end(args);
DN_Str8 result = DN_Str8_Init(buf, *buf_size);
return result;
}
// NOTE: DN_Char ///////////////////////////////////////////////////////////////////////////////////
DN_API bool DN_Char_IsAlphabet(char ch)
{
@@ -1075,37 +1081,6 @@ DN_API bool DN_Char_IsHex(char ch)
return result;
}
DN_API DN_CharHexToU8 DN_Char_HexToU8(char ch)
{
DN_CharHexToU8 result = {};
result.success = true;
if (ch >= 'a' && ch <= 'f')
result.value = ch - 'a' + 10;
else if (ch >= 'A' && ch <= 'F')
result.value = ch - 'A' + 10;
else if (ch >= '0' && ch <= '9')
result.value = ch - '0';
else
result.success = false;
return result;
}
static char constexpr DN_HEX_LUT[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
DN_API char DN_Char_ToHex(char ch)
{
char result = DN_CAST(char) - 1;
if (ch < 16)
result = DN_HEX_LUT[DN_CAST(uint8_t) ch];
return result;
}
DN_API char DN_Char_ToHexUnchecked(char ch)
{
char result = DN_HEX_LUT[DN_CAST(uint8_t) ch];
return result;
}
DN_API char DN_Char_ToLower(char ch)
{
char result = ch;
Source/Base/dn_base_string.h
+125 -389
View File
@@ -1,10 +1,13 @@
#if !defined(DN_BASE_STRING_H)
#define DN_BASE_STRING_H
#include "../dn_base_inc.h"
#if !defined(DN_STB_SPRINTF_HEADER_ONLY)
#define STB_SPRINTF_IMPLEMENTATION
#define STB_SPRINTF_STATIC
#endif
DN_MSVC_WARNING_PUSH
DN_MSVC_WARNING_DISABLE(4505) // Unused function warning
DN_GCC_WARNING_PUSH
@@ -25,7 +28,7 @@ struct DN_Str8Link
DN_Str8Link *prev; // The prev string in the linked list
};
struct DN_Str8BinarySplitResult
struct DN_Str8BSplitResult
{
DN_Str8 lhs;
DN_Str8 rhs;
@@ -87,20 +90,6 @@ struct DN_Str8DotTruncateResult
DN_Str8 str8;
};
#if !defined(DN_NO_FSTR8)
template <DN_USize N>
struct DN_FStr8
{
char data[N + 1];
DN_USize size;
char *begin() { return data; }
char *end() { return data + size; }
char const *begin() const { return data; }
char const *end() const { return data + size; }
};
#endif // !defined(DN_NO_FSTR8)
struct DN_Str8Builder
{
DN_Arena *arena; // Allocator to use to back the string list
@@ -116,391 +105,138 @@ enum DN_Str8BuilderAdd
DN_Str8BuilderAdd_Prepend,
};
// NOTE: DN_CStr8 //////////////////////////////////////////////////////////////////////////////////
template <DN_USize N> constexpr DN_USize DN_CStr8_ArrayUCount (char const (&literal)[N]) { (void)literal; return N - 1; }
template <DN_USize N> constexpr DN_USize DN_CStr8_ArrayICount (char const (&literal)[N]) { (void)literal; return N - 1; }
DN_API DN_USize DN_CStr8_FSize (DN_FMT_ATTRIB char const *fmt, ...);
DN_API DN_USize DN_CStr8_FVSize (DN_FMT_ATTRIB char const *fmt, va_list args);
DN_API DN_USize DN_CStr8_Size (char const *a);
DN_API DN_USize DN_CStr16_Size (wchar_t const *a);
// NOTE: DN_Str16 //////////////////////////////////////////////////////////////////////////////////
#define DN_STR16(string) DN_Str16{(wchar_t *)(string), sizeof(string)/sizeof(string[0]) - 1}
#define DN_Str16_HasData(string) ((string).data && (string).size)
#if defined(__cplusplus)
DN_API bool operator== (DN_Str16 const &lhs, DN_Str16 const &rhs);
DN_API bool operator!= (DN_Str16 const &lhs, DN_Str16 const &rhs);
#endif
// NOTE: DN_Str8 ///////////////////////////////////////////////////////////////////////////////////
#define DN_STR8(string) DN_Str8{(char *)(string), (sizeof(string) - 1)}
#define DN_STR_FMT(string) (int)((string).size), (string).data
#define DN_Str8_Init(data, size) DN_Str8{(char *)(data), (size_t)(size)}
DN_API DN_Str8 DN_Str8_InitCStr8 (char const *src);
#define DN_Str8_HasData(string) ((string).data && (string).size)
DN_API bool DN_Str8_IsAll (DN_Str8 string, DN_Str8IsAll is_all);
DN_API DN_Str8 DN_Str8_InitF (DN_Arena *arena, DN_FMT_ATTRIB char const *fmt, ...);
DN_API DN_Str8 DN_Str8_InitFV (DN_Arena *arena, DN_FMT_ATTRIB char const *fmt, va_list args);
DN_API DN_Str8 DN_Str8_Alloc (DN_Arena *arena, DN_USize size, DN_ZeroMem zero_mem);
DN_API DN_Str8 DN_Str8_Copy (DN_Arena *arena, DN_Str8 string);
DN_API char * DN_Str8_End (DN_Str8 string);
DN_API DN_Str8 DN_Str8_Slice (DN_Str8 string, DN_USize offset, DN_USize size);
DN_API DN_Str8 DN_Str8_Advance (DN_Str8 string, DN_USize amount);
DN_API DN_Str8 DN_Str8_NextLine (DN_Str8 string);
DN_API DN_Str8BinarySplitResult DN_Str8_BinarySplitArray (DN_Str8 string, DN_Str8 const *find, DN_USize find_size);
DN_API DN_Str8BinarySplitResult DN_Str8_BinarySplit (DN_Str8 string, DN_Str8 find);
DN_API DN_Str8BinarySplitResult DN_Str8_BinarySplitLastArray (DN_Str8 string, DN_Str8 const *find, DN_USize find_size);
DN_API DN_Str8BinarySplitResult DN_Str8_BinarySplitLast (DN_Str8 string, DN_Str8 find);
DN_API DN_USize DN_Str8_Split (DN_Str8 string, DN_Str8 delimiter, DN_Str8 *splits, DN_USize splits_count, DN_Str8SplitIncludeEmptyStrings mode);
DN_API DN_Slice<DN_Str8> DN_Str8_SplitAlloc (DN_Arena *arena, DN_Str8 string, DN_Str8 delimiter, DN_Str8SplitIncludeEmptyStrings mode);
DN_API DN_Str8FindResult DN_Str8_FindStr8Array (DN_Str8 string, DN_Str8 const *find, DN_USize find_size, DN_Str8EqCase eq_case);
DN_API DN_Str8FindResult DN_Str8_FindStr8 (DN_Str8 string, DN_Str8 find, DN_Str8EqCase eq_case);
DN_API DN_Str8FindResult DN_Str8_Find (DN_Str8 string, uint32_t flags);
DN_API DN_Str8 DN_Str8_Segment (DN_Arena *arena, DN_Str8 src, DN_USize segment_size, char segment_char);
DN_API DN_Str8 DN_Str8_ReverseSegment (DN_Arena *arena, DN_Str8 src, DN_USize segment_size, char segment_char);
DN_API bool DN_Str8_Eq (DN_Str8 lhs, DN_Str8 rhs, DN_Str8EqCase eq_case = DN_Str8EqCase_Sensitive);
DN_API bool DN_Str8_EqInsensitive (DN_Str8 lhs, DN_Str8 rhs);
DN_API bool DN_Str8_StartsWith (DN_Str8 string, DN_Str8 prefix, DN_Str8EqCase eq_case = DN_Str8EqCase_Sensitive);
DN_API bool DN_Str8_StartsWithInsensitive (DN_Str8 string, DN_Str8 prefix);
DN_API bool DN_Str8_EndsWith (DN_Str8 string, DN_Str8 prefix, DN_Str8EqCase eq_case = DN_Str8EqCase_Sensitive);
DN_API bool DN_Str8_EndsWithInsensitive (DN_Str8 string, DN_Str8 prefix);
DN_API bool DN_Str8_HasChar (DN_Str8 string, char ch);
DN_API DN_Str8 DN_Str8_TrimPrefix (DN_Str8 string, DN_Str8 prefix, DN_Str8EqCase eq_case = DN_Str8EqCase_Sensitive);
DN_API DN_Str8 DN_Str8_TrimHexPrefix (DN_Str8 string);
DN_API DN_Str8 DN_Str8_TrimSuffix (DN_Str8 string, DN_Str8 suffix, DN_Str8EqCase eq_case = DN_Str8EqCase_Sensitive);
DN_API DN_Str8 DN_Str8_TrimAround (DN_Str8 string, DN_Str8 trim_string);
DN_API DN_Str8 DN_Str8_TrimHeadWhitespace (DN_Str8 string);
DN_API DN_Str8 DN_Str8_TrimTailWhitespace (DN_Str8 string);
DN_API DN_Str8 DN_Str8_TrimWhitespaceAround (DN_Str8 string);
DN_API DN_Str8 DN_Str8_TrimByteOrderMark (DN_Str8 string);
DN_API DN_Str8 DN_Str8_FileNameFromPath (DN_Str8 path);
DN_API DN_Str8 DN_Str8_FileNameNoExtension (DN_Str8 path);
DN_API DN_Str8 DN_Str8_FilePathNoExtension (DN_Str8 path);
DN_API DN_Str8 DN_Str8_FileExtension (DN_Str8 path);
DN_API DN_Str8 DN_Str8_FileDirectoryFromPath (DN_Str8 path);
DN_API DN_Str8ToU64Result DN_Str8_ToU64 (DN_Str8 string, char separator);
DN_API DN_Str8ToI64Result DN_Str8_ToI64 (DN_Str8 string, char separator);
DN_API DN_Str8 DN_Str8_AppendF (DN_Arena *arena, DN_Str8 string, char const *fmt, ...);
DN_API DN_Str8 DN_Str8_AppendFV (DN_Arena *arena, DN_Str8 string, char const *fmt, va_list args);
DN_API DN_Str8 DN_Str8_FillF (DN_Arena *arena, DN_USize count, char const *fmt, ...);
DN_API DN_Str8 DN_Str8_FillFV (DN_Arena *arena, DN_USize count, char const *fmt, va_list args);
DN_API void DN_Str8_Remove (DN_Str8 *string, DN_USize offset, DN_USize size);
DN_API DN_Str8DotTruncateResult DN_Str8_DotTruncateMiddle (DN_Arena *arena, DN_Str8 str8, uint32_t side_size, DN_Str8 truncator);
DN_API DN_Str8 DN_Str8_Lower (DN_Arena *arena, DN_Str8 string);
DN_API DN_Str8 DN_Str8_Upper (DN_Arena *arena, DN_Str8 string);
#if defined(__cplusplus)
DN_API bool operator== (DN_Str8 const &lhs, DN_Str8 const &rhs);
DN_API bool operator!= (DN_Str8 const &lhs, DN_Str8 const &rhs);
#endif
// NOTE: DN_Str8Builder ////////////////////////////////////////////////////////////////////////////
DN_API DN_Str8Builder DN_Str8Builder_Init (DN_Arena *arena);
DN_API DN_Str8Builder DN_Str8Builder_InitArrayRef (DN_Arena *arena, DN_Str8 const *strings, DN_USize size);
DN_API DN_Str8Builder DN_Str8Builder_InitArrayCopy (DN_Arena *arena, DN_Str8 const *strings, DN_USize size);
template <DN_USize N> DN_Str8Builder DN_Str8Builder_InitCArrayRef (DN_Arena *arena, DN_Str8 const (&array)[N]);
template <DN_USize N> DN_Str8Builder DN_Str8Builder_InitCArrayCopy (DN_Arena *arena, DN_Str8 const (&array)[N]);
DN_API bool DN_Str8Builder_AddArrayRef (DN_Str8Builder *builder, DN_Str8 const *strings, DN_USize size, DN_Str8BuilderAdd add);
DN_API bool DN_Str8Builder_AddArrayCopy (DN_Str8Builder *builder, DN_Str8 const *strings, DN_USize size, DN_Str8BuilderAdd add);
DN_API bool DN_Str8Builder_AddFV (DN_Str8Builder *builder, DN_Str8BuilderAdd add, DN_FMT_ATTRIB char const *fmt, va_list args);
#define DN_Str8Builder_AppendArrayRef(builder, strings, size) DN_Str8Builder_AddArrayRef(builder, strings, size, DN_Str8BuilderAdd_Append)
#define DN_Str8Builder_AppendArrayCopy(builder, strings, size) DN_Str8Builder_AddArrayCopy(builder, strings, size, DN_Str8BuilderAdd_Append)
#define DN_Str8Builder_AppendSliceRef(builder, slice) DN_Str8Builder_AddArrayRef(builder, slice.data, slice.size, DN_Str8BuilderAdd_Append)
#define DN_Str8Builder_AppendSliceCopy(builder, slice) DN_Str8Builder_AddArrayCopy(builder, slice.data, slice.size, DN_Str8BuilderAdd_Append)
DN_API bool DN_Str8Builder_AppendRef (DN_Str8Builder *builder, DN_Str8 string);
DN_API bool DN_Str8Builder_AppendCopy (DN_Str8Builder *builder, DN_Str8 string);
#define DN_Str8Builder_AppendFV(builder, fmt, args) DN_Str8Builder_AddFV(builder, DN_Str8BuilderAdd_Append, fmt, args)
DN_API bool DN_Str8Builder_AppendF (DN_Str8Builder *builder, DN_FMT_ATTRIB char const *fmt, ...);
DN_API bool DN_Str8Builder_AppendBytesRef (DN_Str8Builder *builder, void const *ptr, DN_USize size);
DN_API bool DN_Str8Builder_AppendBytesCopy (DN_Str8Builder *builder, void const *ptr, DN_USize size);
DN_API bool DN_Str8Builder_AppendBuilderRef (DN_Str8Builder *dest, DN_Str8Builder const *src);
DN_API bool DN_Str8Builder_AppendBuilderCopy (DN_Str8Builder *dest, DN_Str8Builder const *src);
#define DN_Str8Builder_PrependArrayRef(builder, strings, size) DN_Str8Builder_AddArrayRef(builder, strings, size, DN_Str8BuilderAdd_Prepend)
#define DN_Str8Builder_PrependArrayCopy(builder, strings, size) DN_Str8Builder_AddArrayCopy(builder, strings, size, DN_Str8BuilderAdd_Prepend)
#define DN_Str8Builder_PrependSliceRef(builder, slice) DN_Str8Builder_AddArrayRef(builder, slice.data, slice.size, DN_Str8BuilderAdd_Prepend)
#define DN_Str8Builder_PrependSliceCopy(builder, slice) DN_Str8Builder_AddArrayCopy(builder, slice.data, slice.size, DN_Str8BuilderAdd_Prepend)
DN_API bool DN_Str8Builder_PrependRef (DN_Str8Builder *builder, DN_Str8 string);
DN_API bool DN_Str8Builder_PrependCopy (DN_Str8Builder *builder, DN_Str8 string);
#define DN_Str8Builder_PrependFV(builder, fmt, args) DN_Str8Builder_AddFV(builder, DN_Str8BuilderAdd_Prepend, fmt, args)
DN_API bool DN_Str8Builder_PrependF (DN_Str8Builder *builder, DN_FMT_ATTRIB char const *fmt, ...);
DN_API bool DN_Str8Builder_Erase (DN_Str8Builder *builder, DN_Str8 string);
DN_API DN_Str8Builder DN_Str8Builder_Copy (DN_Arena *arena, DN_Str8Builder const *builder);
DN_API DN_Str8 DN_Str8Builder_Build (DN_Str8Builder const *builder, DN_Arena *arena);
DN_API DN_Str8 DN_Str8Builder_BuildDelimited (DN_Str8Builder const *builder, DN_Str8 delimiter, DN_Arena *arena);
DN_API DN_Slice<DN_Str8> DN_Str8Builder_BuildSlice (DN_Str8Builder const *builder, DN_Arena *arena);
// NOTE: DN_FStr8 //////////////////////////////////////////////////////////////////////////////////
#if !defined(DN_NO_FSTR8)
template <DN_USize N> DN_FStr8<N> DN_FStr8_InitF (DN_FMT_ATTRIB char const *fmt, ...);
template <DN_USize N> DN_FStr8<N> DN_FStr8_InitFV (char const *fmt, va_list args);
template <DN_USize N> DN_USize DN_FStr8_Max (DN_FStr8<N> const *string);
template <DN_USize N> void DN_FStr8_Clear (DN_FStr8<N> *string);
template <DN_USize N> bool DN_FStr8_AddFV (DN_FStr8<N> *string, DN_FMT_ATTRIB char const *fmt, va_list va);
template <DN_USize N> bool DN_FStr8_AddF (DN_FStr8<N> *string, DN_FMT_ATTRIB char const *fmt, ...);
template <DN_USize N> bool DN_FStr8_AddCStr8 (DN_FStr8<N> *string, char const *value, DN_USize size);
template <DN_USize N> bool DN_FStr8_Add (DN_FStr8<N> *string, DN_Str8 value);
template <DN_USize N> DN_Str8 DN_FStr8_ToStr8 (DN_FStr8<N> const *string);
template <DN_USize N> bool DN_FStr8_Eq (DN_FStr8<N> const *lhs, DN_FStr8<N> const *rhs, DN_Str8EqCase eq_case);
template <DN_USize N> bool DN_FStr8_EqStr8 (DN_FStr8<N> const *lhs, DN_Str8 rhs, DN_Str8EqCase eq_case);
template <DN_USize N> bool DN_FStr8_EqInsensitive (DN_FStr8<N> const *lhs, DN_FStr8<N> const *rhs);
template <DN_USize N> bool DN_FStr8_EqStr8Insensitive (DN_FStr8<N> const *lhs, DN_Str8 rhs);
template <DN_USize A, DN_USize B> bool DN_FStr8_EqFStr8 (DN_FStr8<A> const *lhs, DN_FStr8<B> const *rhs, DN_Str8EqCase eq_case);
template <DN_USize A, DN_USize B> bool DN_FStr8_EqFStr8Insensitive (DN_FStr8<A> const *lhs, DN_FStr8<B> const *rhs);
template <DN_USize N> bool operator== (DN_FStr8<N> const &lhs, DN_FStr8<N> const &rhs);
template <DN_USize N> bool operator!= (DN_FStr8<N> const &lhs, DN_FStr8<N> const &rhs);
template <DN_USize N> bool operator== (DN_FStr8<N> const &lhs, DN_Str8 const &rhs);
template <DN_USize N> bool operator!= (DN_FStr8<N> const &lhs, DN_Str8 const &rhs);
#endif // !defined(DN_NO_FSTR8)
// NOTE: DN_Char ///////////////////////////////////////////////////////////////////////////////////
struct DN_CharHexToU8
struct DN_Str8x64
{
bool success;
uint8_t value;
char data[64];
DN_USize size;
};
DN_API bool DN_Char_IsAlphabet (char ch);
DN_API bool DN_Char_IsDigit (char ch);
DN_API bool DN_Char_IsAlphaNum (char ch);
DN_API bool DN_Char_IsWhitespace (char ch);
DN_API bool DN_Char_IsHex (char ch);
DN_API DN_CharHexToU8 DN_Char_HexToU8 (char ch);
DN_API char DN_Char_ToHex (char ch);
DN_API char DN_Char_ToHexUnchecked (char ch);
DN_API char DN_Char_ToLower (char ch);
DN_API char DN_Char_ToUpper (char ch);
// NOTE: DN_UTF ////////////////////////////////////////////////////////////////////////////////////
DN_API int DN_UTF8_EncodeCodepoint (uint8_t utf8[4], uint32_t codepoint);
DN_API int DN_UTF16_EncodeCodepoint (uint16_t utf16[2], uint32_t codepoint);
// NOTE: DN_Str8Builder ///////////////////////////////////////////////////////////////////////////
template <DN_USize N>
DN_Str8Builder DN_Str8Builder_InitCArrayRef(DN_Arena *arena, DN_Str8 const (&array)[N])
struct DN_Str8x256
{
DN_Str8Builder result = DN_Str8Builder_InitArrayRef(arena, array, N);
return result;
}
char data[256];
DN_USize size;
};
template <DN_USize N>
DN_Str8Builder DN_Str8Builder_InitCArrayCopy(DN_Arena *arena, DN_Str8 const (&array)[N])
{
DN_Str8Builder result = DN_Str8Builder_InitArrayCopy(arena, array, N);
return result;
}
DN_API DN_USize DN_CStr8_FSize (DN_FMT_ATTRIB char const *fmt, ...);
DN_API DN_USize DN_CStr8_FVSize (DN_FMT_ATTRIB char const *fmt, va_list args);
DN_API DN_USize DN_CStr8_Size (char const *a);
DN_API DN_USize DN_CStr16_Size (wchar_t const *a);
template <DN_USize N>
bool DN_Str8Builder_AddCArrayRef(DN_Str8Builder *builder, DN_Str8 const (&array)[N], DN_Str8BuilderAdd add)
{
bool result = DN_Str8Builder_AddArrayRef(builder, array, N, add);
return result;
}
#define DN_STR16(string) DN_Str16{(wchar_t *)(string), sizeof(string)/sizeof(string[0]) - 1}
#define DN_Str16_HasData(string) ((string).data && (string).size)
template <DN_USize N>
bool DN_Str8Builder_AddCArrayCopy(DN_Str8Builder *builder, DN_Str8 const (&array)[N], DN_Str8BuilderAdd add)
{
bool result = DN_Str8Builder_AddArrayCopy(builder, array, N, add);
return result;
}
#if defined(__cplusplus)
DN_API bool operator== (DN_Str16 const &lhs, DN_Str16 const &rhs);
DN_API bool operator!= (DN_Str16 const &lhs, DN_Str16 const &rhs);
#endif
#if !defined(DN_NO_FSTR8)
// NOTE: DN_FStr8 //////////////////////////////////////////////////////////////////////////////////
template <DN_USize N>
DN_FStr8<N> DN_FStr8_InitF(DN_FMT_ATTRIB char const *fmt, ...)
{
DN_FStr8<N> result = {};
if (fmt) {
va_list args;
va_start(args, fmt);
DN_FStr8_AddFV(&result, fmt, args);
va_end(args);
}
return result;
}
#define DN_STR8(string) DN_Str8{(char *)(string), (sizeof(string) - 1)}
#define DN_STR_FMT(string) (int)((string).size), (string).data
#define DN_Str8_Init(data, size) DN_Str8{(char *)(data), (size_t)(size)}
#define DN_Str8_HasData(string) ((string).data && (string).size)
DN_API DN_Str8 DN_Str8_Alloc (DN_Arena *arena, DN_USize size, DN_ZeroMem zero_mem);
DN_API DN_Str8 DN_Str8_FromCStr8 (char const *src);
DN_API DN_Str8 DN_Str8_FromF (DN_Arena *arena, DN_FMT_ATTRIB char const *fmt, ...);
DN_API DN_Str8 DN_Str8_FromFV (DN_Arena *arena, DN_FMT_ATTRIB char const *fmt, va_list args);
DN_API DN_Str8 DN_Str8_FromStr8 (DN_Arena *arena, DN_Str8 string);
DN_API bool DN_Str8_IsAll (DN_Str8 string, DN_Str8IsAll is_all);
DN_API char * DN_Str8_End (DN_Str8 string);
DN_API DN_Str8 DN_Str8_Slice (DN_Str8 string, DN_USize offset, DN_USize size);
DN_API DN_Str8 DN_Str8_Advance (DN_Str8 string, DN_USize amount);
DN_API DN_Str8 DN_Str8_NextLine (DN_Str8 string);
DN_API DN_Str8BSplitResult DN_Str8_BSplitArray (DN_Str8 string, DN_Str8 const *find, DN_USize find_size);
DN_API DN_Str8BSplitResult DN_Str8_BSplit (DN_Str8 string, DN_Str8 find);
DN_API DN_Str8BSplitResult DN_Str8_BSplitLastArray (DN_Str8 string, DN_Str8 const *find, DN_USize find_size);
DN_API DN_Str8BSplitResult DN_Str8_BSplitLast (DN_Str8 string, DN_Str8 find);
DN_API DN_USize DN_Str8_Split (DN_Str8 string, DN_Str8 delimiter, DN_Str8 *splits, DN_USize splits_count, DN_Str8SplitIncludeEmptyStrings mode);
DN_API DN_Slice<DN_Str8> DN_Str8_SplitAlloc (DN_Arena *arena, DN_Str8 string, DN_Str8 delimiter, DN_Str8SplitIncludeEmptyStrings mode);
DN_API DN_Str8FindResult DN_Str8_FindStr8Array (DN_Str8 string, DN_Str8 const *find, DN_USize find_size, DN_Str8EqCase eq_case);
DN_API DN_Str8FindResult DN_Str8_FindStr8 (DN_Str8 string, DN_Str8 find, DN_Str8EqCase eq_case);
DN_API DN_Str8FindResult DN_Str8_Find (DN_Str8 string, uint32_t flags);
DN_API DN_Str8 DN_Str8_Segment (DN_Arena *arena, DN_Str8 src, DN_USize segment_size, char segment_char);
DN_API DN_Str8 DN_Str8_ReverseSegment (DN_Arena *arena, DN_Str8 src, DN_USize segment_size, char segment_char);
DN_API bool DN_Str8_Eq (DN_Str8 lhs, DN_Str8 rhs, DN_Str8EqCase eq_case = DN_Str8EqCase_Sensitive);
DN_API bool DN_Str8_EqInsensitive (DN_Str8 lhs, DN_Str8 rhs);
DN_API bool DN_Str8_StartsWith (DN_Str8 string, DN_Str8 prefix, DN_Str8EqCase eq_case = DN_Str8EqCase_Sensitive);
DN_API bool DN_Str8_StartsWithInsensitive (DN_Str8 string, DN_Str8 prefix);
DN_API bool DN_Str8_EndsWith (DN_Str8 string, DN_Str8 prefix, DN_Str8EqCase eq_case = DN_Str8EqCase_Sensitive);
DN_API bool DN_Str8_EndsWithInsensitive (DN_Str8 string, DN_Str8 prefix);
DN_API bool DN_Str8_HasChar (DN_Str8 string, char ch);
DN_API DN_Str8 DN_Str8_TrimPrefix (DN_Str8 string, DN_Str8 prefix, DN_Str8EqCase eq_case = DN_Str8EqCase_Sensitive);
DN_API DN_Str8 DN_Str8_TrimHexPrefix (DN_Str8 string);
DN_API DN_Str8 DN_Str8_TrimSuffix (DN_Str8 string, DN_Str8 suffix, DN_Str8EqCase eq_case = DN_Str8EqCase_Sensitive);
DN_API DN_Str8 DN_Str8_TrimAround (DN_Str8 string, DN_Str8 trim_string);
DN_API DN_Str8 DN_Str8_TrimHeadWhitespace (DN_Str8 string);
DN_API DN_Str8 DN_Str8_TrimTailWhitespace (DN_Str8 string);
DN_API DN_Str8 DN_Str8_TrimWhitespaceAround (DN_Str8 string);
DN_API DN_Str8 DN_Str8_TrimByteOrderMark (DN_Str8 string);
DN_API DN_Str8 DN_Str8_FileNameFromPath (DN_Str8 path);
DN_API DN_Str8 DN_Str8_FileNameNoExtension (DN_Str8 path);
DN_API DN_Str8 DN_Str8_FilePathNoExtension (DN_Str8 path);
DN_API DN_Str8 DN_Str8_FileExtension (DN_Str8 path);
DN_API DN_Str8 DN_Str8_FileDirectoryFromPath (DN_Str8 path);
DN_API DN_Str8ToU64Result DN_Str8_ToU64 (DN_Str8 string, char separator);
DN_API DN_Str8ToI64Result DN_Str8_ToI64 (DN_Str8 string, char separator);
DN_API DN_Str8 DN_Str8_AppendF (DN_Arena *arena, DN_Str8 string, char const *fmt, ...);
DN_API DN_Str8 DN_Str8_AppendFV (DN_Arena *arena, DN_Str8 string, char const *fmt, va_list args);
DN_API DN_Str8 DN_Str8_FillF (DN_Arena *arena, DN_USize count, char const *fmt, ...);
DN_API DN_Str8 DN_Str8_FillFV (DN_Arena *arena, DN_USize count, char const *fmt, va_list args);
DN_API void DN_Str8_Remove (DN_Str8 *string, DN_USize offset, DN_USize size);
DN_API DN_Str8DotTruncateResult DN_Str8_DotTruncateMiddle (DN_Arena *arena, DN_Str8 str8, uint32_t side_size, DN_Str8 truncator);
DN_API DN_Str8 DN_Str8_Lower (DN_Arena *arena, DN_Str8 string);
DN_API DN_Str8 DN_Str8_Upper (DN_Arena *arena, DN_Str8 string);
#if defined(__cplusplus)
DN_API bool operator== (DN_Str8 const &lhs, DN_Str8 const &rhs);
DN_API bool operator!= (DN_Str8 const &lhs, DN_Str8 const &rhs);
#endif
template <DN_USize N>
DN_FStr8<N> DN_FStr8_InitFV(char const *fmt, va_list args)
{
DN_FStr8<N> result = {};
DN_FStr8_AddFV(&result, fmt, args);
return result;
}
DN_API DN_Str8 DN_LStr8_AppendF (char *buf, DN_USize *buf_size, DN_USize buf_max, char const *fmt, ...);
#define DN_IStr8_AppendF(struct_ptr, fmt, ...) DN_LStr8_AppendF((struct_ptr)->data, &(struct_ptr)->size, DN_ArrayCountU((struct_ptr)->data), fmt, ##__VA_ARGS__)
#define DN_Str8_FromIStr8(struct_ptr) DN_Str8_Init((struct_ptr)->data, (struct_ptr)->size)
template <DN_USize N>
DN_USize DN_FStr8_Max(DN_FStr8<N> const *)
{
DN_USize result = N;
return result;
}
template <DN_USize N>
void DN_FStr8_Clear(DN_FStr8<N> *string)
{
*string = {};
}
DN_API DN_Str8Builder DN_Str8Builder_FromArena (DN_Arena *arena);
DN_API DN_Str8Builder DN_Str8Builder_FromStr8PtrRef (DN_Arena *arena, DN_Str8 const *strings, DN_USize size);
DN_API DN_Str8Builder DN_Str8Builder_FromStr8PtrCopy (DN_Arena *arena, DN_Str8 const *strings, DN_USize size);
DN_API DN_Str8Builder DN_Str8Builder_FromBuilder (DN_Arena *arena, DN_Str8Builder const *builder);
DN_API bool DN_Str8Builder_AddArrayRef (DN_Str8Builder *builder, DN_Str8 const *strings, DN_USize size, DN_Str8BuilderAdd add);
DN_API bool DN_Str8Builder_AddArrayCopy (DN_Str8Builder *builder, DN_Str8 const *strings, DN_USize size, DN_Str8BuilderAdd add);
DN_API bool DN_Str8Builder_AddFV (DN_Str8Builder *builder, DN_Str8BuilderAdd add, DN_FMT_ATTRIB char const *fmt, va_list args);
#define DN_Str8Builder_AppendArrayRef(builder, strings, size) DN_Str8Builder_AddArrayRef(builder, strings, size, DN_Str8BuilderAdd_Append)
#define DN_Str8Builder_AppendArrayCopy(builder, strings, size) DN_Str8Builder_AddArrayCopy(builder, strings, size, DN_Str8BuilderAdd_Append)
#define DN_Str8Builder_AppendSliceRef(builder, slice) DN_Str8Builder_AddArrayRef(builder, slice.data, slice.size, DN_Str8BuilderAdd_Append)
#define DN_Str8Builder_AppendSliceCopy(builder, slice) DN_Str8Builder_AddArrayCopy(builder, slice.data, slice.size, DN_Str8BuilderAdd_Append)
DN_API bool DN_Str8Builder_AppendRef (DN_Str8Builder *builder, DN_Str8 string);
DN_API bool DN_Str8Builder_AppendCopy (DN_Str8Builder *builder, DN_Str8 string);
#define DN_Str8Builder_AppendFV(builder, fmt, args) DN_Str8Builder_AddFV(builder, DN_Str8BuilderAdd_Append, fmt, args)
DN_API bool DN_Str8Builder_AppendF (DN_Str8Builder *builder, DN_FMT_ATTRIB char const *fmt, ...);
DN_API bool DN_Str8Builder_AppendBytesRef (DN_Str8Builder *builder, void const *ptr, DN_USize size);
DN_API bool DN_Str8Builder_AppendBytesCopy (DN_Str8Builder *builder, void const *ptr, DN_USize size);
DN_API bool DN_Str8Builder_AppendBuilderRef (DN_Str8Builder *dest, DN_Str8Builder const *src);
DN_API bool DN_Str8Builder_AppendBuilderCopy (DN_Str8Builder *dest, DN_Str8Builder const *src);
#define DN_Str8Builder_PrependArrayRef(builder, strings, size) DN_Str8Builder_AddArrayRef(builder, strings, size, DN_Str8BuilderAdd_Prepend)
#define DN_Str8Builder_PrependArrayCopy(builder, strings, size) DN_Str8Builder_AddArrayCopy(builder, strings, size, DN_Str8BuilderAdd_Prepend)
#define DN_Str8Builder_PrependSliceRef(builder, slice) DN_Str8Builder_AddArrayRef(builder, slice.data, slice.size, DN_Str8BuilderAdd_Prepend)
#define DN_Str8Builder_PrependSliceCopy(builder, slice) DN_Str8Builder_AddArrayCopy(builder, slice.data, slice.size, DN_Str8BuilderAdd_Prepend)
DN_API bool DN_Str8Builder_PrependRef (DN_Str8Builder *builder, DN_Str8 string);
DN_API bool DN_Str8Builder_PrependCopy (DN_Str8Builder *builder, DN_Str8 string);
#define DN_Str8Builder_PrependFV(builder, fmt, args) DN_Str8Builder_AddFV(builder, DN_Str8BuilderAdd_Prepend, fmt, args)
DN_API bool DN_Str8Builder_PrependF (DN_Str8Builder *builder, DN_FMT_ATTRIB char const *fmt, ...);
DN_API bool DN_Str8Builder_Erase (DN_Str8Builder *builder, DN_Str8 string);
DN_API DN_Str8 DN_Str8Builder_Build (DN_Str8Builder const *builder, DN_Arena *arena);
DN_API DN_Str8 DN_Str8Builder_BuildDelimited (DN_Str8Builder const *builder, DN_Str8 delimiter, DN_Arena *arena);
DN_API DN_Slice<DN_Str8> DN_Str8Builder_BuildSlice (DN_Str8Builder const *builder, DN_Arena *arena);
template <DN_USize N>
bool DN_FStr8_AddFV(DN_FStr8<N> *string, DN_FMT_ATTRIB char const *fmt, va_list args)
{
bool result = false;
if (!string || !fmt)
return result;
DN_API bool DN_Char_IsAlphabet (char ch);
DN_API bool DN_Char_IsDigit (char ch);
DN_API bool DN_Char_IsAlphaNum (char ch);
DN_API bool DN_Char_IsWhitespace (char ch);
DN_API bool DN_Char_IsHex (char ch);
DN_API char DN_Char_ToHex (char ch);
DN_API char DN_Char_ToHexUnchecked (char ch);
DN_API char DN_Char_ToLower (char ch);
DN_API char DN_Char_ToUpper (char ch);
DN_USize require = DN_CStr8_FVSize(fmt, args) + 1 /*null_terminate*/;
DN_USize space = (N + 1) - string->size;
result = require <= space;
string->size += DN_VSNPrintF(string->data + string->size, DN_CAST(int) space, fmt, args);
// NOTE: snprintf returns the required size of the format string
// irrespective of if there's space or not.
string->size = DN_Min(string->size, N);
return result;
}
template <DN_USize N>
bool DN_FStr8_AddF(DN_FStr8<N> *string, DN_FMT_ATTRIB char const *fmt, ...)
{
bool result = false;
if (!string || !fmt)
return result;
va_list args;
va_start(args, fmt);
result = DN_FStr8_AddFV(string, fmt, args);
va_end(args);
return result;
}
template <DN_USize N>
bool DN_FStr8_AddCStr8(DN_FStr8<N> *string, char const *src, DN_USize size)
{
DN_Assert(string->size <= N);
bool result = false;
if (!string || !src || size == 0 || string->size >= N)
return result;
DN_USize space = N - string->size;
result = size <= space;
DN_Memcpy(string->data + string->size, src, DN_Min(space, size));
string->size = DN_Min(string->size + size, N);
string->data[string->size] = 0;
return result;
}
template <DN_USize N>
bool DN_FStr8_Add(DN_FStr8<N> *string, DN_Str8 src)
{
bool result = DN_FStr8_AddCStr8(string, src.data, src.size);
return result;
}
template <DN_USize N>
DN_Str8 DN_FStr8_ToStr8(DN_FStr8<N> const *string)
{
DN_Str8 result = {};
if (!string || string->size <= 0)
return result;
result.data = DN_CAST(char *) string->data;
result.size = string->size;
return result;
}
template <DN_USize N>
bool DN_FStr8_Eq(DN_FStr8<N> const *lhs, DN_FStr8<N> const *rhs, DN_Str8EqCase eq_case)
{
DN_Str8 lhs_s8 = DN_FStr8_ToStr8(lhs);
DN_Str8 rhs_s8 = DN_FStr8_ToStr8(rhs);
bool result = DN_Str8_Eq(lhs_s8, rhs_s8, eq_case);
return result;
}
template <DN_USize N>
bool DN_FStr8_EqStr8(DN_FStr8<N> const *lhs, DN_Str8 rhs, DN_Str8EqCase eq_case)
{
DN_Str8 lhs_s8 = DN_FStr8_ToStr8(lhs);
bool result = DN_Str8_Eq(lhs_s8, rhs, eq_case);
return result;
}
template <DN_USize N>
bool DN_FStr8_EqInsensitive(DN_FStr8<N> const *lhs, DN_FStr8<N> const *rhs)
{
DN_Str8 lhs_s8 = DN_FStr8_ToStr8(lhs);
DN_Str8 rhs_s8 = DN_FStr8_ToStr8(rhs);
bool result = DN_Str8_Eq(lhs_s8, rhs_s8, DN_Str8EqCase_Insensitive);
return result;
}
template <DN_USize N>
bool DN_FStr8_EqStr8Insensitive(DN_FStr8<N> const *lhs, DN_Str8 rhs)
{
DN_Str8 lhs_s8 = DN_FStr8_ToStr8(lhs);
bool result = DN_Str8_Eq(lhs_s8, rhs, DN_Str8EqCase_Insensitive);
return result;
}
template <DN_USize A, DN_USize B>
bool DN_FStr8_EqFStr8(DN_FStr8<A> const *lhs, DN_FStr8<B> const *rhs, DN_Str8EqCase eq_case)
{
DN_Str8 lhs_s8 = DN_FStr8_ToStr8(lhs);
DN_Str8 rhs_s8 = DN_FStr8_ToStr8(rhs);
bool result = DN_Str8_Eq(lhs_s8, rhs_s8, eq_case);
return result;
}
template <DN_USize A, DN_USize B>
bool DN_FStr8_EqFStr8Insensitive(DN_FStr8<A> const *lhs, DN_FStr8<B> const *rhs)
{
DN_Str8 lhs_s8 = DN_FStr8_ToStr8(lhs);
DN_Str8 rhs_s8 = DN_FStr8_ToStr8(rhs);
bool result = DN_Str8_Eq(lhs_s8, rhs_s8, DN_Str8EqCase_Insensitive);
return result;
}
template <DN_USize N>
bool operator==(DN_FStr8<N> const &lhs, DN_FStr8<N> const &rhs)
{
bool result = DN_FStr8_Eq(&lhs, &rhs, DN_Str8EqCase_Sensitive);
return result;
}
template <DN_USize N>
bool operator!=(DN_FStr8<N> const &lhs, DN_FStr8<N> const &rhs)
{
bool result = !(lhs == rhs);
return result;
}
template <DN_USize N>
bool operator==(DN_FStr8<N> const &lhs, DN_Str8 const &rhs)
{
bool result = DN_Str8_Eq(DN_FStr8_ToStr8(&lhs), rhs, DN_Str8EqCase_Insensitive);
return result;
}
template <DN_USize N>
bool operator!=(DN_FStr8<N> const &lhs, DN_Str8 const &rhs)
{
bool result = !(lhs == rhs);
return result;
}
#endif // !defined(DN_NO_FSTR8)
DN_API int DN_UTF8_EncodeCodepoint (uint8_t utf8[4], uint32_t codepoint);
DN_API int DN_UTF16_EncodeCodepoint (uint16_t utf16[2], uint32_t codepoint);
#endif // !defined(DN_BASE_STRING_H)