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

Update DN from seasight

Browse Source
This commit is contained in:
doylet
2025-11-04 23:31:58 +11:00
parent ed483537c6
commit a17925904d
10 changed files with 3885 additions and 4101 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Source/Base/dn_base.cpp
+4 -8
View File
@@ -1550,20 +1550,16 @@ DN_API DN_USize DN_FmtVSize(DN_FMT_ATTRIB char const *fmt, va_list args)
DN_API DN_USize DN_CStr8Size(char const *src)
{
DN_USize result = 0;
for (;src && src[0] != 0; src++, result++) {
src++;
result++;
}
for (; src && src[0] != 0; src++, result++)
;
return result;
}
DN_API DN_USize DN_CStr16Size(wchar_t const *src)
{
DN_USize result = 0;
while (src && src[0] != 0) {
src++;
result++;
}
for (; src && src[0] != 0; src++, result++)
;
return result;
}
Source/Core/dn_core_debug.cpp
+1 -1
View File
@@ -394,7 +394,7 @@ DN_API DN_ProfilerZone DN_Profiler_BeginZone(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 (DN_Str8HasData(anchor->name) && anchor->name != name)
if (anchor->name.size && 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
Source/Core/dn_core_demo.cpp
+3 -3
View File
@@ -602,7 +602,7 @@ void DN_Docs_Demo()
DN_ProfilerAnchor *read_anchors = DN_Profiler_ReadBuffer();
for (DN_USize index = 0; index < DN_PROFILER_ANCHOR_BUFFER_SIZE; index++) {
DN_ProfilerAnchor *anchor = read_anchors + index;
if (DN_Str8HasData(anchor->name)) {
if (anchor->name.size) {
// ...
}
}
@@ -614,7 +614,7 @@ void DN_Docs_Demo()
DN_ProfilerAnchor *write_anchors = DN_Profiler_WriteBuffer();
for (DN_USize index = 0; index < DN_PROFILER_ANCHOR_BUFFER_SIZE; index++) {
DN_ProfilerAnchor *anchor = write_anchors + index;
if (DN_Str8HasData(anchor->name)) {
if (anchor->name.size) {
// ...
}
}
@@ -1039,7 +1039,7 @@ void DN_Docs_Demo()
// NOTE: DN_Str8x32FromFmt
{
DN_Str8x32 string = DN_Str8x32FromFmt("%" PRIu64, 123123);
DN_Str8x32 string = DN_Str8x32FromFmt("%d", 123123);
if (0) // Prints "123123"
printf("%.*s", DN_Str8PrintFmt(string));
}
Source/Extra/dn_csv.cpp
+8 -8
View File
@@ -17,7 +17,7 @@ static bool DN_CSV_TokeniserValid(DN_CSVTokeniser *tokeniser)
static bool DN_CSV_TokeniserNextRow(DN_CSVTokeniser *tokeniser)
{
bool result = false;
if (DN_CSV_TokeniserValid(tokeniser) && DN_Str8HasData(tokeniser->string)) {
if (DN_CSV_TokeniserValid(tokeniser) && tokeniser->string.size) {
// 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
@@ -39,7 +39,7 @@ static DN_Str8 DN_CSV_TokeniserNextField(DN_CSVTokeniser *tokeniser)
if (!DN_CSV_TokeniserValid(tokeniser))
return result;
if (!DN_Str8HasData(tokeniser->string)) {
if (tokeniser->string.size == 0) {
tokeniser->bad = true;
return result;
}
@@ -146,7 +146,7 @@ static int DN_CSV_TokeniserNextN(DN_CSVTokeniser *tokeniser, DN_Str8 *fields, in
int result = 0;
for (; result < fields_size; result++) {
fields[result] = column_iterator ? DN_CSV_TokeniserNextColumn(tokeniser) : DN_CSV_TokeniserNextField(tokeniser);
if (!DN_CSV_TokeniserValid(tokeniser) || !DN_Str8HasData(fields[result]))
if (!DN_CSV_TokeniserValid(tokeniser) || fields[result].size == 0)
break;
}
@@ -176,8 +176,8 @@ static void DN_CSV_TokeniserSkipLineN(DN_CSVTokeniser *tokeniser, int count)
static void DN_CSV_PackU64(DN_CSVPack *pack, DN_CSVSerialise serialise, DN_U64 *value)
{
if (serialise == DN_CSVSerialise_Read) {
DN_Str8 csv_value = DN_CSV_TokeniserNextColumn(&pack->read_tokeniser);
DN_Str8ToU64Result to_u64 = DN_Str8ToU64(csv_value, 0);
DN_Str8 csv_value = DN_CSV_TokeniserNextColumn(&pack->read_tokeniser);
DN_U64FromResult to_u64 = DN_U64FromStr8(csv_value, 0);
DN_Assert(to_u64.success);
*value = to_u64.value;
} else {
@@ -188,8 +188,8 @@ static void DN_CSV_PackU64(DN_CSVPack *pack, DN_CSVSerialise serialise, DN_U64 *
static void DN_CSV_PackI64(DN_CSVPack *pack, DN_CSVSerialise serialise, DN_I64 *value)
{
if (serialise == DN_CSVSerialise_Read) {
DN_Str8 csv_value = DN_CSV_TokeniserNextColumn(&pack->read_tokeniser);
DN_Str8ToI64Result to_i64 = DN_Str8ToI64(csv_value, 0);
DN_Str8 csv_value = DN_CSV_TokeniserNextColumn(&pack->read_tokeniser);
DN_I64FromResult to_i64 = DN_I64FromStr8(csv_value, 0);
DN_Assert(to_i64.success);
*value = to_i64.value;
} else {
@@ -250,7 +250,7 @@ static void DN_CSV_PackStr8(DN_CSVPack *pack, DN_CSVSerialise serialise, DN_Str8
{
if (serialise == DN_CSVSerialise_Read) {
DN_Str8 csv_value = DN_CSV_TokeniserNextColumn(&pack->read_tokeniser);
*str8 = DN_Str8FromStr8(arena, csv_value);
*str8 = DN_Str8FromStr8Arena(arena, csv_value);
} else {
DN_Str8BuilderAppendF(&pack->write_builder, "%s%.*s", pack->write_column++ ? "," : "", DN_Str8PrintFmt(*str8));
}
Source/Extra/dn_tests.cpp
+33 -27
View File
@@ -239,10 +239,10 @@ static void DN_RefImpl_CPUReportDump() // Print out supported instruction set fe
static DN_UTCore DN_Tests_Base()
{
DN_UTCore result = DN_UT_Init();
#if defined(DN_PLATFORM_WIN32) && defined(DN_COMPILER_MSVC)
DN_RefImplCPUReport ref_cpu_report = DN_RefImplCPUReport_Init();
DN_UT_LogF(&result, "DN_Base\n");
{
#if defined(DN_PLATFORM_WIN32) && defined(DN_COMPILER_MSVC)
DN_RefImplCPUReport ref_cpu_report = DN_RefImplCPUReport_Init();
for (DN_UT_Test(&result, "Query CPUID")) {
DN_CPUReport cpu_report = DN_CPUGetReport();
@@ -278,30 +278,30 @@ static DN_UTCore DN_Tests_Base()
DN_UT_Assert(&result, DN_CPUHasFeature(&cpu_report, DN_CPUFeature_SSE4A) == ref_cpu_report.SSE4a());
DN_UT_Assert(&result, DN_CPUHasFeature(&cpu_report, DN_CPUFeature_SSSE3) == ref_cpu_report.SSSE3());
// NOTE: Feature flags we haven't bothered detecting yet but are in MSDN's example /////////////
#if 0
DN_UT_Assert(&result, DN_CPUHasFeature(&cpu_report, DN_CPUFeature_ADX) == DN_RefImplCPUReport::ADX());
DN_UT_Assert(&result, DN_CPUHasFeature(&cpu_report, DN_CPUFeature_BMI1) == DN_RefImplCPUReport::BMI1());
DN_UT_Assert(&result, DN_CPUHasFeature(&cpu_report, DN_CPUFeature_BMI2) == DN_RefImplCPUReport::BMI2());
DN_UT_Assert(&result, DN_CPUHasFeature(&cpu_report, DN_CPUFeature_CLFSH) == DN_RefImplCPUReport::CLFSH());
DN_UT_Assert(&result, DN_CPUHasFeature(&cpu_report, DN_CPUFeature_CX8) == DN_RefImplCPUReport::CX8());
DN_UT_Assert(&result, DN_CPUHasFeature(&cpu_report, DN_CPUFeature_ERMS) == DN_RefImplCPUReport::ERMS());
DN_UT_Assert(&result, DN_CPUHasFeature(&cpu_report, DN_CPUFeature_FSGSBASE) == DN_RefImplCPUReport::FSGSBASE());
DN_UT_Assert(&result, DN_CPUHasFeature(&cpu_report, DN_CPUFeature_FXSR) == DN_RefImplCPUReport::FXSR());
DN_UT_Assert(&result, DN_CPUHasFeature(&cpu_report, DN_CPUFeature_HLE) == DN_RefImplCPUReport::HLE());
DN_UT_Assert(&result, DN_CPUHasFeature(&cpu_report, DN_CPUFeature_INVPCID) == DN_RefImplCPUReport::INVPCID());
DN_UT_Assert(&result, DN_CPUHasFeature(&cpu_report, DN_CPUFeature_LAHF) == DN_RefImplCPUReport::LAHF());
DN_UT_Assert(&result, DN_CPUHasFeature(&cpu_report, DN_CPUFeature_LZCNT) == DN_RefImplCPUReport::LZCNT());
DN_UT_Assert(&result, DN_CPUHasFeature(&cpu_report, DN_CPUFeature_MSR) == DN_RefImplCPUReport::MSR());
DN_UT_Assert(&result, DN_CPUHasFeature(&cpu_report, DN_CPUFeature_OSXSAVE) == DN_RefImplCPUReport::OSXSAVE());
DN_UT_Assert(&result, DN_CPUHasFeature(&cpu_report, DN_CPUFeature_PREFETCHWT1) == DN_RefImplCPUReport::PREFETCHWT1());
DN_UT_Assert(&result, DN_CPUHasFeature(&cpu_report, DN_CPUFeature_RTM) == DN_RefImplCPUReport::RTM());
DN_UT_Assert(&result, DN_CPUHasFeature(&cpu_report, DN_CPUFeature_SEP) == DN_RefImplCPUReport::SEP());
DN_UT_Assert(&result, DN_CPUHasFeature(&cpu_report, DN_CPUFeature_SYSCALL) == DN_RefImplCPUReport::SYSCALL());
DN_UT_Assert(&result, DN_CPUHasFeature(&cpu_report, DN_CPUFeature_TBM) == DN_RefImplCPUReport::TBM());
DN_UT_Assert(&result, DN_CPUHasFeature(&cpu_report, DN_CPUFeature_XOP) == DN_RefImplCPUReport::XOP());
DN_UT_Assert(&result, DN_CPUHasFeature(&cpu_report, DN_CPUFeature_XSAVE) == DN_RefImplCPUReport::XSAVE());
#endif
// NOTE: Feature flags we haven't bothered detecting yet but are in MSDN's example /////////////
#if 0
DN_UT_Assert(&result, DN_CPUHasFeature(&cpu_report, DN_CPUFeature_ADX) == DN_RefImplCPUReport::ADX());
DN_UT_Assert(&result, DN_CPUHasFeature(&cpu_report, DN_CPUFeature_BMI1) == DN_RefImplCPUReport::BMI1());
DN_UT_Assert(&result, DN_CPUHasFeature(&cpu_report, DN_CPUFeature_BMI2) == DN_RefImplCPUReport::BMI2());
DN_UT_Assert(&result, DN_CPUHasFeature(&cpu_report, DN_CPUFeature_CLFSH) == DN_RefImplCPUReport::CLFSH());
DN_UT_Assert(&result, DN_CPUHasFeature(&cpu_report, DN_CPUFeature_CX8) == DN_RefImplCPUReport::CX8());
DN_UT_Assert(&result, DN_CPUHasFeature(&cpu_report, DN_CPUFeature_ERMS) == DN_RefImplCPUReport::ERMS());
DN_UT_Assert(&result, DN_CPUHasFeature(&cpu_report, DN_CPUFeature_FSGSBASE) == DN_RefImplCPUReport::FSGSBASE());
DN_UT_Assert(&result, DN_CPUHasFeature(&cpu_report, DN_CPUFeature_FXSR) == DN_RefImplCPUReport::FXSR());
DN_UT_Assert(&result, DN_CPUHasFeature(&cpu_report, DN_CPUFeature_HLE) == DN_RefImplCPUReport::HLE());
DN_UT_Assert(&result, DN_CPUHasFeature(&cpu_report, DN_CPUFeature_INVPCID) == DN_RefImplCPUReport::INVPCID());
DN_UT_Assert(&result, DN_CPUHasFeature(&cpu_report, DN_CPUFeature_LAHF) == DN_RefImplCPUReport::LAHF());
DN_UT_Assert(&result, DN_CPUHasFeature(&cpu_report, DN_CPUFeature_LZCNT) == DN_RefImplCPUReport::LZCNT());
DN_UT_Assert(&result, DN_CPUHasFeature(&cpu_report, DN_CPUFeature_MSR) == DN_RefImplCPUReport::MSR());
DN_UT_Assert(&result, DN_CPUHasFeature(&cpu_report, DN_CPUFeature_OSXSAVE) == DN_RefImplCPUReport::OSXSAVE());
DN_UT_Assert(&result, DN_CPUHasFeature(&cpu_report, DN_CPUFeature_PREFETCHWT1) == DN_RefImplCPUReport::PREFETCHWT1());
DN_UT_Assert(&result, DN_CPUHasFeature(&cpu_report, DN_CPUFeature_RTM) == DN_RefImplCPUReport::RTM());
DN_UT_Assert(&result, DN_CPUHasFeature(&cpu_report, DN_CPUFeature_SEP) == DN_RefImplCPUReport::SEP());
DN_UT_Assert(&result, DN_CPUHasFeature(&cpu_report, DN_CPUFeature_SYSCALL) == DN_RefImplCPUReport::SYSCALL());
DN_UT_Assert(&result, DN_CPUHasFeature(&cpu_report, DN_CPUFeature_TBM) == DN_RefImplCPUReport::TBM());
DN_UT_Assert(&result, DN_CPUHasFeature(&cpu_report, DN_CPUFeature_XOP) == DN_RefImplCPUReport::XOP());
DN_UT_Assert(&result, DN_CPUHasFeature(&cpu_report, DN_CPUFeature_XSAVE) == DN_RefImplCPUReport::XSAVE());
#endif
}
#endif // defined(DN_PLATFORM_WIN32) && defined(DN_COMPILER_MSVC)
@@ -309,6 +309,12 @@ static DN_UTCore DN_Tests_Base()
char buffer[512];
DN_Arena arena = DN_ArenaFromBuffer(buffer, sizeof(buffer), DN_ArenaFlags_NoPoison | DN_ArenaFlags_AllocCanLeak);
// NOTE: CStr8Size
{
DN_USize size = DN_CStr8Size("hello");
DN_UT_AssertF(&result, size == 5, "size=%zu", size);
}
// NOTE: Str8FromFmtArena
{
DN_Str8 str8 = DN_Str8FromFmtArena(&arena, "Foo Bar %d", 5);
@@ -1667,7 +1673,7 @@ DN_Str8 const DN_UT_HASH_STRING_[] =
void DN_Tests_KeccakDispatch_(DN_UTCore *test, int hash_type, DN_Str8 input)
{
DN_OSTLSTMem tmem = DN_OS_TLSTMem(nullptr);
DN_Str8 input_hex = DN_CVT_HexFromBytes(tmem.arena, input.data, input.size);
DN_Str8 input_hex = DN_HexFromBytesPtrArena(input.data, input.size, tmem.arena);
switch (hash_type) {
case Hash_SHA3_224: {
Source/OS/dn_os_posix.cpp
+14 -14
View File
@@ -196,7 +196,7 @@ DN_API DN_OSDiskSpace DN_OS_DiskSpace(DN_Str8 path)
{
DN_OSTLSTMem tmem = DN_OS_TLSPushTMem(nullptr);
DN_OSDiskSpace result = {};
DN_Str8 path_z_terminated = DN_Str8FromStr8(tmem.arena, path);
DN_Str8 path_z_terminated = DN_Str8FromStr8Arena(tmem.arena, path);
struct statvfs info = {};
if (statvfs(path_z_terminated.data, &info) != 0)
@@ -598,7 +598,7 @@ DN_API bool DN_OS_PathMakeDir(DN_Str8 path)
DN_USize path_indexes_size = 0;
uint16_t path_indexes[64] = {};
DN_Str8 copy = DN_Str8FromStr8(tmem.arena, path);
DN_Str8 copy = DN_Str8FromStr8Arena(tmem.arena, path);
for (DN_USize index = copy.size - 1; index < copy.size; index--) {
bool first_char = index == (copy.size - 1);
char ch = copy.data[index];
@@ -910,7 +910,7 @@ DN_API DN_OSExecAsyncHandle DN_OS_ExecAsync(DN_Slice<DN_Str8> cmd_line,
for (DN_ForIndexU(arg_index, cmd_line.size)) {
DN_Str8 arg = cmd_line.data[arg_index];
argv[arg_index] = DN_Str8FromStr8(tmem.arena, arg).data; // NOTE: Copy string to guarantee it is null-terminated
argv[arg_index] = DN_Str8FromStr8Arena(tmem.arena, arg).data; // NOTE: Copy string to guarantee it is null-terminated
}
// NOTE: Change the working directory if there is one
@@ -928,7 +928,7 @@ DN_API DN_OSExecAsyncHandle DN_OS_ExecAsync(DN_Slice<DN_Str8> cmd_line,
if (args->working_dir.size) {
prev_working_dir = get_current_dir_name();
DN_Str8 working_dir = DN_Str8FromStr8(tmem.arena, args->working_dir);
DN_Str8 working_dir = DN_Str8FromStr8Arena(tmem.arena, args->working_dir);
if (chdir(working_dir.data) == -1) {
result.os_error_code = errno;
DN_OS_ErrSinkAppendF(
@@ -1294,7 +1294,7 @@ DN_API void DN_Posix_ThreadSetName(DN_Str8 name)
(void)name;
#else
DN_OSTLSTMem tmem = DN_OS_TLSPushTMem(nullptr);
DN_Str8 copy = DN_Str8FromStr8(tmem.arena, name);
DN_Str8 copy = DN_Str8FromStr8Arena(tmem.arena, name);
pthread_t thread = pthread_self();
pthread_setname_np(thread, (char *)copy.data);
#endif
@@ -1340,23 +1340,23 @@ DN_API DN_POSIXProcSelfStatus DN_Posix_ProcSelfStatus()
result.name_size = DN_Min(str8.size, 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_Str8Slice(line, PID.size, line.size));
DN_Str8ToU64Result to_u64 = DN_Str8ToU64(str8, 0);
result.pid = to_u64.value;
DN_Str8 str8 = DN_Str8TrimWhitespaceAround(DN_Str8Slice(line, PID.size, line.size));
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_Str8Slice(line, VM_SIZE.size, line.size));
DN_Assert(DN_Str8EndsWith(size_with_kb, DN_Str8Lit("kB")));
DN_Str8 vm_size = DN_Str8BSplit(size_with_kb, DN_Str8Lit(" ")).lhs;
DN_Str8ToU64Result to_u64 = DN_Str8ToU64(vm_size, 0);
result.vm_size = DN_Kilobytes(to_u64.value);
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_Str8Slice(line, VM_PEAK.size, line.size));
DN_Assert(DN_Str8EndsWith(size_with_kb, DN_Str8Lit("kB")));
DN_Str8 vm_size = DN_Str8BSplit(size_with_kb, DN_Str8Lit(" ")).lhs;
DN_Str8ToU64Result to_u64 = DN_Str8ToU64(vm_size, 0);
result.vm_peak = DN_Kilobytes(to_u64.value);
DN_Str8 vm_size = DN_Str8BSplit(size_with_kb, DN_Str8Lit(" ")).lhs;
DN_U64FromResult to_u64 = DN_U64FromStr8(vm_size, 0);
result.vm_peak = DN_Kilobytes(to_u64.value);
DN_Assert(to_u64.success);
}
}
Source/Standalone/dn_keccak.h
+11 -11
View File
@@ -227,7 +227,7 @@ DN_KCBytes32 DN_KC_Keccak256(void const *src, uint64_t size);
DN_KCBytes48 DN_KC_Keccak384(void const *src, uint64_t size);
DN_KCBytes64 DN_KC_Keccak512(void const *src, uint64_t size);
#if defined(DN_BASE_STRING_H)
#if defined(DN_BASE_H)
// NOTE: SHA3 - Helpers for DN data structures ////////////////////////////////////////////////////
DN_KCBytes28 DN_KC_SHA3_224Str8(DN_Str8 string);
DN_KCBytes32 DN_KC_SHA3_256Str8(DN_Str8 string);
@@ -239,7 +239,7 @@ DN_KCBytes28 DN_KC_Keccak224Str8(DN_Str8 string);
DN_KCBytes32 DN_KC_Keccak256Str8(DN_Str8 string);
DN_KCBytes48 DN_KC_Keccak384Str8(DN_Str8 string);
DN_KCBytes64 DN_KC_Keccak512Str8(DN_Str8 string);
#endif // DN_BASE_STRING_H
#endif // DN_BASE_H
// NOTE: Helper functions //////////////////////////////////////////////////////////////////////////
// Convert a binary buffer into its hex representation into dest. The dest
@@ -262,13 +262,13 @@ int DN_KC_Bytes32Equals(DN_KCBytes32 const *a, DN_KCBytes32 const *b);
int DN_KC_Bytes48Equals(DN_KCBytes48 const *a, DN_KCBytes48 const *b);
int DN_KC_Bytes64Equals(DN_KCBytes64 const *a, DN_KCBytes64 const *b);
#if defined(DN_BASE_STRING_H)
#if defined(DN_BASE_H)
// NOTE: Other helper functions for DN data structures ////////////////////////////////////////////
// Converts a 64 character hex string into the 32 byte binary representation.
// Invalid hex characters in the string will be represented as 0.
// hex: Must be exactly a 64 character hex string.
DN_KCBytes32 DN_KC_Hex64ToBytes(DN_Str8 hex);
#endif // DN_BASE_STRING_H
#endif // DN_BASE_H
#endif // DN_KC_H
#if defined(DN_KC_IMPLEMENTATION)
@@ -518,7 +518,7 @@ DN_KCBytes64 DN_KC_Keccak512(void const *src, size_t size)
return result;
}
#if defined(DN_BASE_STRING_H)
#if defined(DN_BASE_H)
// NOTE: SHA3 - Helpers for DN data structures ////////////////////////////////////////////////////
DN_KCBytes28 DN_KC_SHA3_224Str8(DN_Str8 string)
{
@@ -547,9 +547,9 @@ DN_KCBytes64 DN_KC_SHA3_512Str8(DN_Str8 string)
DN_KC_SHA3_512Ptr(string.data, string.size, result.data, sizeof(result));
return result;
}
#endif // DN_BASE_STRING_H
#endif // DN_BASE_H
#if defined(DN_BASE_STRING_H)
#if defined(DN_BASE_H)
// NOTE: Keccak - Helpers for DN data structures //////////////////////////////////////////////////
DN_KCBytes28 DN_KC_Keccak224Str8(DN_Str8 string)
{
@@ -578,7 +578,7 @@ DN_KCBytes64 DN_KC_Keccak512Str8(DN_Str8 string)
DN_KC_Keccak512Ptr(string.data, string.size, result.data, sizeof(result));
return result;
}
#endif // DN_BASE_STRING_H
#endif // DN_BASE_H
// NOTE: Helper functions //////////////////////////////////////////////////////////////////////////
void DN_KC_HexFromBytes(void const *src, size_t src_size, char *dest, size_t dest_size)
@@ -653,14 +653,14 @@ int DN_KC_Bytes64Equals(DN_KCBytes64 const *a, DN_KCBytes64 const *b)
return result;
}
#if defined(DN_BASE_STRING_H)
#if defined(DN_BASE_H)
// NOTE: Other helper functions for DN data structures ////////////////////////////////////////////
DN_KCBytes32 DN_KC_Hex64ToBytes(DN_Str8 hex)
{
DN_KC_ASSERT(hex.size == 64);
DN_KCBytes32 result;
DN_CVT_BytesFromHexPtr(hex, result.data, sizeof(result));
DN_BytesFromHexStr8(hex, result.data, sizeof(result));
return result;
}
#endif // DN_BASE_STRING_H
#endif // DN_BASE_H
#endif // DN_KC_IMPLEMENTATION