Do massive overhaul and simplification of DN
This commit is contained in:
+981
-19
File diff suppressed because it is too large
Load Diff
+753
-278
File diff suppressed because it is too large
Load Diff
@@ -1,15 +1,15 @@
|
||||
#if !defined(DN_BASE_ASSERT_H)
|
||||
#define DN_BASE_ASSERT_H
|
||||
|
||||
#define DN_HardAssertF(expr, fmt, ...) \
|
||||
do { \
|
||||
if (!(expr)) { \
|
||||
#define DN_HardAssertF(expr, fmt, ...) \
|
||||
do { \
|
||||
if (!(expr)) { \
|
||||
DN_Str8 stack_trace_ = DN_StackTraceWalkStr8FromHeap(128 /*limit*/, 2 /*skip*/); \
|
||||
DN_LOG_ErrorF("Hard assertion [" #expr "], stack trace was:\n\n%.*s\n\n" fmt, \
|
||||
DN_Str8PrintFmt(stack_trace_), \
|
||||
##__VA_ARGS__); \
|
||||
DN_DebugBreak; \
|
||||
} \
|
||||
DN_LogErrorF("Hard assertion [" #expr "], stack trace was:\n\n%.*s\n\n" fmt, \
|
||||
DN_Str8PrintFmt(stack_trace_), \
|
||||
##__VA_ARGS__); \
|
||||
DN_DebugBreak; \
|
||||
} \
|
||||
} while (0)
|
||||
#define DN_HardAssert(expr) DN_HardAssertF(expr, "")
|
||||
|
||||
@@ -33,7 +33,7 @@
|
||||
do { \
|
||||
if (!(expr)) { \
|
||||
DN_Str8 stack_trace_ = DN_StackTraceWalkStr8FromHeap(128 /*limit*/, 2 /*skip*/); \
|
||||
DN_LOG_ErrorF("Assertion [" #expr "], stack trace was:\n\n%.*s\n\n" fmt, \
|
||||
DN_LogErrorF("Assertion [" #expr "], stack trace was:\n\n%.*s\n\n" fmt, \
|
||||
DN_Str8PrintFmt(stack_trace_), \
|
||||
##__VA_ARGS__); \
|
||||
DN_DebugBreak; \
|
||||
@@ -46,7 +46,7 @@
|
||||
if (!(expr) && once) { \
|
||||
once = false; \
|
||||
DN_Str8 stack_trace_ = DN_StackTraceWalkStr8FromHeap(128 /*limit*/, 2 /*skip*/); \
|
||||
DN_LOG_ErrorF("Assertion [" #expr "], stack trace was:\n\n%.*s\n\n" fmt, \
|
||||
DN_LogErrorF("Assertion [" #expr "], stack trace was:\n\n%.*s\n\n" fmt, \
|
||||
DN_Str8PrintFmt(stack_trace_), \
|
||||
##__VA_ARGS__); \
|
||||
DN_DebugBreak; \
|
||||
@@ -68,10 +68,10 @@
|
||||
#define DN_Check(expr) DN_CheckF(expr, "")
|
||||
#if defined(DN_NO_CHECK_BREAK)
|
||||
#define DN_CheckF(expr, fmt, ...) \
|
||||
((expr) ? true : (DN_LOG_WarningF(fmt, ##__VA_ARGS__), false))
|
||||
((expr) ? true : (DN_LogWarningF(fmt, ##__VA_ARGS__), false))
|
||||
#else
|
||||
#define DN_CheckF(expr, fmt, ...) \
|
||||
((expr) ? true : (DN_LOG_ErrorF(fmt, ##__VA_ARGS__), DN_StackTracePrint(128 /*limit*/), DN_DebugBreak, false))
|
||||
((expr) ? true : (DN_LogErrorF(fmt, ##__VA_ARGS__), DN_StackTracePrint(128 /*limit*/), DN_DebugBreak, false))
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
@@ -1,160 +0,0 @@
|
||||
#if !defined(DN_BASE_COMPILER_H)
|
||||
#define DN_BASE_COMPILER_H
|
||||
|
||||
// NOTE: Compiler identification
|
||||
// Warning! Order is important here, clang-cl on Windows defines _MSC_VER
|
||||
#if defined(_MSC_VER)
|
||||
#if defined(__clang__)
|
||||
#define DN_COMPILER_CLANG_CL
|
||||
#define DN_COMPILER_CLANG
|
||||
#else
|
||||
#define DN_COMPILER_MSVC
|
||||
#endif
|
||||
#elif defined(__clang__)
|
||||
#define DN_COMPILER_CLANG
|
||||
#elif defined(__GNUC__)
|
||||
#define DN_COMPILER_GCC
|
||||
#endif
|
||||
|
||||
// NOTE: __has_feature
|
||||
// MSVC for example does not support the feature detection macro for instance so we compile it out
|
||||
#if defined(__has_feature)
|
||||
#define DN_HAS_FEATURE(expr) __has_feature(expr)
|
||||
#else
|
||||
#define DN_HAS_FEATURE(expr) 0
|
||||
#endif
|
||||
|
||||
// NOTE: __has_builtin
|
||||
// MSVC for example does not support the feature detection macro for instance so we compile it out
|
||||
#if defined(__has_builtin)
|
||||
#define DN_HAS_BUILTIN(expr) __has_builtin(expr)
|
||||
#else
|
||||
#define DN_HAS_BUILTIN(expr) 0
|
||||
#endif
|
||||
|
||||
// NOTE: Warning suppression macros
|
||||
#if defined(DN_COMPILER_MSVC)
|
||||
#define DN_MSVC_WARNING_PUSH __pragma(warning(push))
|
||||
#define DN_MSVC_WARNING_DISABLE(...) __pragma(warning(disable :##__VA_ARGS__))
|
||||
#define DN_MSVC_WARNING_POP __pragma(warning(pop))
|
||||
#else
|
||||
#define DN_MSVC_WARNING_PUSH
|
||||
#define DN_MSVC_WARNING_DISABLE(...)
|
||||
#define DN_MSVC_WARNING_POP
|
||||
#endif
|
||||
|
||||
#if defined(DN_COMPILER_CLANG) || defined(DN_COMPILER_GCC) || defined(DN_COMPILER_CLANG_CL)
|
||||
#define DN_GCC_WARNING_PUSH _Pragma("GCC diagnostic push")
|
||||
#define DN_GCC_WARNING_DISABLE_HELPER_0(x) #x
|
||||
#define DN_GCC_WARNING_DISABLE_HELPER_1(y) DN_GCC_WARNING_DISABLE_HELPER_0(GCC diagnostic ignored #y)
|
||||
#define DN_GCC_WARNING_DISABLE(warning) _Pragma(DN_GCC_WARNING_DISABLE_HELPER_1(warning))
|
||||
#define DN_GCC_WARNING_POP _Pragma("GCC diagnostic pop")
|
||||
#else
|
||||
#define DN_GCC_WARNING_PUSH
|
||||
#define DN_GCC_WARNING_DISABLE(...)
|
||||
#define DN_GCC_WARNING_POP
|
||||
#endif
|
||||
|
||||
// NOTE: Host OS identification
|
||||
#if defined(_WIN32)
|
||||
#define DN_OS_WIN32
|
||||
#elif defined(__gnu_linux__) || defined(__linux__)
|
||||
#define DN_OS_UNIX
|
||||
#endif
|
||||
|
||||
// NOTE: Platform identification
|
||||
#if !defined(DN_PLATFORM_EMSCRIPTEN) && \
|
||||
!defined(DN_PLATFORM_POSIX) && \
|
||||
!defined(DN_PLATFORM_WIN32)
|
||||
#if defined(__aarch64__) || defined(_M_ARM64)
|
||||
#define DN_PLATFORM_ARM64
|
||||
#elif defined(__EMSCRIPTEN__)
|
||||
#define DN_PLATFORM_EMSCRIPTEN
|
||||
#elif defined(DN_OS_WIN32)
|
||||
#define DN_PLATFORM_WIN32
|
||||
#else
|
||||
#define DN_PLATFORM_POSIX
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// NOTE: Windows crap
|
||||
#if defined(DN_COMPILER_MSVC) || defined(DN_COMPILER_CLANG_CL)
|
||||
#if defined(_CRT_SECURE_NO_WARNINGS)
|
||||
#define DN_CRT_SECURE_NO_WARNINGS_PREVIOUSLY_DEFINED
|
||||
#else
|
||||
#define _CRT_SECURE_NO_WARNINGS
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// NOTE: Force Inline
|
||||
#if defined(DN_COMPILER_MSVC) || defined(DN_COMPILER_CLANG_CL)
|
||||
#define DN_FORCE_INLINE __forceinline
|
||||
#else
|
||||
#define DN_FORCE_INLINE inline __attribute__((always_inline))
|
||||
#endif
|
||||
|
||||
// NOTE: Function/Variable Annotations
|
||||
#if defined(DN_STATIC_API)
|
||||
#define DN_API static
|
||||
#else
|
||||
#define DN_API
|
||||
#endif
|
||||
|
||||
// NOTE: C/CPP Literals
|
||||
// Declare struct literals that work in both C and C++ because the syntax is different between
|
||||
// languages.
|
||||
#if 0
|
||||
struct Foo { int a; }
|
||||
struct Foo foo = DN_LITERAL(Foo){32}; // Works on both C and C++
|
||||
#endif
|
||||
|
||||
#if defined(__cplusplus)
|
||||
#define DN_Literal(T) T
|
||||
#else
|
||||
#define DN_Literal(T) (T)
|
||||
#endif
|
||||
|
||||
// NOTE: Thread Locals
|
||||
#if defined(__cplusplus)
|
||||
#define DN_THREAD_LOCAL thread_local
|
||||
#else
|
||||
#define DN_THREAD_LOCAL _Thread_local
|
||||
#endif
|
||||
|
||||
// NOTE: C variadic argument annotations
|
||||
// TODO: Other compilers
|
||||
#if defined(DN_COMPILER_MSVC)
|
||||
#define DN_FMT_ATTRIB _Printf_format_string_
|
||||
#else
|
||||
#define DN_FMT_ATTRIB
|
||||
#endif
|
||||
|
||||
// NOTE: Type Cast
|
||||
#define DN_Cast(val) (val)
|
||||
|
||||
// NOTE: Zero initialisation macro
|
||||
#if defined(__cplusplus)
|
||||
#define DN_ZeroInit {}
|
||||
#else
|
||||
#define DN_ZeroInit {0}
|
||||
#endif
|
||||
|
||||
// NOTE: Address sanitizer
|
||||
#if !defined(DN_ASAN_POISON)
|
||||
#define DN_ASAN_POISON 0
|
||||
#endif
|
||||
|
||||
#if !defined(DN_ASAN_VET_POISON)
|
||||
#define DN_ASAN_VET_POISON 0
|
||||
#endif
|
||||
|
||||
#define DN_ASAN_POISON_ALIGNMENT 8
|
||||
|
||||
#if !defined(DN_ASAN_POISON_GUARD_SIZE)
|
||||
#define DN_ASAN_POISON_GUARD_SIZE 128
|
||||
#endif
|
||||
|
||||
#if DN_HAS_FEATURE(address_sanitizer) || defined(__SANITIZE_ADDRESS__)
|
||||
#include <sanitizer/asan_interface.h>
|
||||
#endif
|
||||
#endif // !defined(DN_BASE_COMPILER_H)
|
||||
+122
-825
File diff suppressed because it is too large
Load Diff
+221
-321
@@ -1,8 +1,70 @@
|
||||
#if !defined(DN_CONTAINERS_H)
|
||||
#define DN_CONTAINERS_H
|
||||
// Containers that are imlpemented using primarily macros for operating on data structures that are
|
||||
// embedded into a C style struct or from a set of defined variables from the available scope. Keep
|
||||
// it stupid simple, structs and functions. Minimal amount of container types with flexible
|
||||
// construction leads to less duplicated container code and less template meta-programming.
|
||||
//
|
||||
// PArray => Pointer (to) Array
|
||||
// LArray => Literal Array
|
||||
// Define a C array and size. (P) array macros take a pointer to the aray, its size and its max
|
||||
// capacity. The (L) array macros take the literal array and derives the max capacity
|
||||
// automatically using DN_ArrayCountU(l_array).
|
||||
//
|
||||
// MyStruct buffer[TB_ASType_Count] = {};
|
||||
// DN_USize size = 0;
|
||||
// MyStruct *item_0 = DN_PArrayMake(buffer, &size, DN_ArrayCountU(buffer), DN_ZMem_No);
|
||||
// MyStruct *item_1 = DN_LArrayMake(buffer, &size, DN_ZMem_No);
|
||||
//
|
||||
// IArray => Intrusive Array
|
||||
// Define a struct with the members `data`, `size` and `max`:
|
||||
//
|
||||
// struct MyArray {
|
||||
// MyStruct *data;
|
||||
// DN_USize size;
|
||||
// DN_USize max;
|
||||
// } my_array = {};
|
||||
// MyStruct *item = DN_IArrayMake(&my_array, DN_ZMem_No);
|
||||
//
|
||||
// ISinglyLL => Intrusive Singly Linked List
|
||||
// Define a struct with the members `next`:
|
||||
//
|
||||
// struct MyLinkItem {
|
||||
// int data;
|
||||
// MyLinkItem *next;
|
||||
// } my_link = {};
|
||||
//
|
||||
// MyLinkItem *first_item = DN_ISinglyLLDetach(&my_link, MyLinkItem);
|
||||
//
|
||||
// DoublyLL => Doubly Linked List
|
||||
// Define a struct with the members `next` and `prev`. This list has null pointers for head->prev
|
||||
// and tail->next.
|
||||
//
|
||||
// struct MyLinkItem {
|
||||
// int data;
|
||||
// MyLinkItem *next;
|
||||
// MyLinkItem *prev;
|
||||
// } my_link = {};
|
||||
//
|
||||
// MyLinkItem first_item = {}, second_item = {};
|
||||
// DN_DoublyLLAppend(&first_item, &second_item); // first_item -> second_item
|
||||
//
|
||||
// SentinelDoublyLL => Sentinel Doubly Linked List
|
||||
// Uses a sentinel/dummy node as the list head. The sentinel points to itself when empty.
|
||||
// Define a struct with the members `next` and `prev`:
|
||||
//
|
||||
// struct MyLinkItem {
|
||||
// int data;
|
||||
// MyLinkItem *next;
|
||||
// MyLinkItem *prev;
|
||||
// } my_list = {};
|
||||
//
|
||||
// DN_SentinelDoublyLLInit(&my_list);
|
||||
// DN_SentinelDoublyLLAppend(&my_list, &new_item);
|
||||
// DN_SentinelDoublyLLForEach(it, &my_list) { /* ... */ }
|
||||
|
||||
#if defined(_CLANGD)
|
||||
#include "../dn.h"
|
||||
#include "../dn.h"
|
||||
#endif
|
||||
|
||||
struct DN_Ring
|
||||
@@ -13,7 +75,6 @@ struct DN_Ring
|
||||
DN_U64 read_pos;
|
||||
};
|
||||
|
||||
// NOTE: DN_CArray /////////////////////////////////////////////////////////////////////////////////
|
||||
enum DN_ArrayErase
|
||||
{
|
||||
DN_ArrayErase_Unstable,
|
||||
@@ -45,42 +106,6 @@ template <typename T> struct DN_ArrayFindResult
|
||||
DN_USize index; // Index to the value if a match is found, 0 otherwise
|
||||
};
|
||||
|
||||
#if !defined(DN_NO_SARRAY)
|
||||
// NOTE: DN_SArray /////////////////////////////////////////////////////////////////////////////////
|
||||
template <typename T> struct DN_SArray
|
||||
{
|
||||
T *data; // Pointer to the start of the array items in the block of memory
|
||||
DN_USize size; // Number of items currently in the array
|
||||
DN_USize max; // Maximum number of items this array can store
|
||||
|
||||
T *begin() { return data; }
|
||||
T *end () { return data + size; }
|
||||
T const *begin() const { return data; }
|
||||
T const *end () const { return data + size; }
|
||||
};
|
||||
#endif // !defined(DN_NO_SARRAY)
|
||||
|
||||
#if !defined(DN_NO_FARRAY)
|
||||
// NOTE: DN_FArray /////////////////////////////////////////////////////////////////////////////////
|
||||
template <typename T, DN_USize N> struct DN_FArray
|
||||
{
|
||||
T data[N]; // Pointer to the start of the array items in the block of memory
|
||||
DN_USize size; // Number of items currently in the array
|
||||
|
||||
T *begin() { return data; }
|
||||
T *end () { return data + size; }
|
||||
T const *begin() const { return data; }
|
||||
T const *end () const { return data + size; }
|
||||
};
|
||||
|
||||
template <typename T> using DN_FArray8 = DN_FArray<T, 8>;
|
||||
template <typename T> using DN_FArray16 = DN_FArray<T, 16>;
|
||||
template <typename T> using DN_FArray32 = DN_FArray<T, 32>;
|
||||
template <typename T> using DN_FArray64 = DN_FArray<T, 64>;
|
||||
#endif // !defined(DN_NO_FARRAY)
|
||||
|
||||
#if !defined(DN_NO_DSMAP)
|
||||
// NOTE: DN_DSMap //////////////////////////////////////////////////////////////////////////////////
|
||||
enum DN_DSMapKeyType
|
||||
{
|
||||
// Key | Key Hash | Map Index
|
||||
@@ -136,93 +161,29 @@ template <typename T> struct DN_DSMapResult
|
||||
DN_DSMapSlot<T> *slot;
|
||||
T *value;
|
||||
};
|
||||
#endif // !defined(DN_NO_DSMAP)
|
||||
|
||||
#if !defined(DN_NO_LIST)
|
||||
// NOTE: DN_List ///////////////////////////////////////////////////////////////////////////////////
|
||||
template <typename T> struct DN_ListChunk
|
||||
{
|
||||
T *data;
|
||||
DN_USize size;
|
||||
DN_USize count;
|
||||
DN_ListChunk<T> *next;
|
||||
DN_ListChunk<T> *prev;
|
||||
};
|
||||
#define DN_ISinglyLLDetach(list) (decltype(list))DN_SinglyLLDetach((void **)&(list), (void **)&(list)->next)
|
||||
|
||||
template <typename T> struct DN_ListIterator
|
||||
{
|
||||
DN_B32 init; // True if DN_List_Iterate has been called at-least once on this iterator
|
||||
DN_ListChunk<T> *chunk; // The chunk that the iterator is reading from
|
||||
DN_USize chunk_data_index; // The index in the chunk the iterator is referencing
|
||||
DN_USize index; // The index of the item in the list as if it was flat array
|
||||
T *data; // Pointer to the data the iterator is referencing. Nullptr if invalid.
|
||||
};
|
||||
#define DN_SentinelDoublyLLInit(list) (list)->next = (list)->prev = (list)
|
||||
#define DN_SentinelDoublyLLIsSentinel(list, item) ((list) == (item))
|
||||
#define DN_SentinelDoublyLLIsEmpty(list) (!(list) || ((list) == (list)->next))
|
||||
#define DN_SentinelDoublyLLIsInit(list) ((list)->next && (list)->prev)
|
||||
#define DN_SentinelDoublyLLHasItems(list) ((list) && ((list) != (list)->next))
|
||||
#define DN_SentinelDoublyLLForEach(it, list) auto *it = (list)->next; (it) != (list); (it) = (it)->next
|
||||
|
||||
template <typename T> struct DN_List
|
||||
{
|
||||
DN_USize count; // Cumulative count of all items made across all list chunks
|
||||
DN_USize chunk_size; // When new ListChunk's are required, the minimum 'data' entries to allocate for that node.
|
||||
DN_ListChunk<T> *head;
|
||||
DN_ListChunk<T> *tail;
|
||||
};
|
||||
#endif // !defined(DN_NO_LIST)
|
||||
|
||||
// NOTE: Macros for operating on data structures that are embedded into a C style struct or from a
|
||||
// set of defined variables from the available scope. Keep it stupid simple, structs and functions.
|
||||
// Minimal amount of container types with flexible construction leads to less duplicated container
|
||||
// code and less template meta-programming.
|
||||
//
|
||||
// LArray => Literal Array
|
||||
// Define a C array and size:
|
||||
//
|
||||
// ```
|
||||
// MyStruct buffer[TB_ASType_Count] = {};
|
||||
// DN_USize size = 0;
|
||||
// MyStruct *item = DN_LArray_Make(buffer, size, DN_ArrayCountU(buffer), DN_ZMem_No);
|
||||
// ```
|
||||
//
|
||||
// IArray => Intrusive Array
|
||||
// Define a struct with the members 'data', 'size' and 'max':
|
||||
//
|
||||
// ```
|
||||
// struct MyArray {
|
||||
// MyStruct *data;
|
||||
// DN_USize size;
|
||||
// DN_USize max;
|
||||
// } my_array = {};
|
||||
//
|
||||
// MyStruct *item = DN_IArray_Make(&my_array, MyArray, DN_ZMem_No);
|
||||
// ```
|
||||
// ISLList => Intrusive Singly Linked List
|
||||
// Define a struct with the members 'next':
|
||||
//
|
||||
// ```
|
||||
// struct MyLinkItem {
|
||||
// int data;
|
||||
// MyLinkItem *next;
|
||||
// } my_link = {};
|
||||
//
|
||||
// MyLinkItem *first_item = DN_ISLList_Detach(&my_link, MyLinkItem);
|
||||
// ```
|
||||
|
||||
#define DN_DLList_Init(list) \
|
||||
(list)->next = (list)->prev = (list)
|
||||
|
||||
#define DN_DLList_IsSentinel(list, item) ((list) == (item))
|
||||
|
||||
#define DN_DLList_InitArena(list, T, arena) \
|
||||
#define DN_SentinelDoublyLLInitArena(list, T, arena) \
|
||||
do { \
|
||||
(list) = DN_ArenaNew(arena, T, DN_ZMem_Yes); \
|
||||
DN_DLList_Init(list); \
|
||||
(list) = DN_ArenaNew(arena, T, DN_ZMem_Yes); \
|
||||
DN_SentinelDoublyLLInit(list); \
|
||||
} while (0)
|
||||
|
||||
#define DN_DLList_InitPool(list, T, pool) \
|
||||
do { \
|
||||
(list) = DN_PoolNew(pool, T); \
|
||||
DN_DLList_Init(list); \
|
||||
#define DN_SentinelDoublyLLInitPool(list, T, pool) \
|
||||
do { \
|
||||
(list) = DN_PoolNew(pool, T); \
|
||||
DN_SentinelDoublyLLInit(list); \
|
||||
} while (0)
|
||||
|
||||
#define DN_DLList_Detach(item) \
|
||||
#define DN_SentinelDoublyLLDetach(item) \
|
||||
do { \
|
||||
if (item) { \
|
||||
(item)->prev->next = (item)->next; \
|
||||
@@ -232,47 +193,47 @@ template <typename T> struct DN_List
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
#define DN_DLList_Dequeue(list, dest_ptr) \
|
||||
if (DN_DLList_HasItems(list)) { \
|
||||
dest_ptr = (list)->next; \
|
||||
DN_DLList_Detach(dest_ptr); \
|
||||
#define DN_SentinelDoublyLLDequeue(list, dest_ptr) \
|
||||
if (DN_SentinelDoublyLLHasItems(list)) { \
|
||||
dest_ptr = (list)->next; \
|
||||
DN_SentinelDoublyLLDetach(dest_ptr); \
|
||||
}
|
||||
|
||||
#define DN_DLList_Append(list, item) \
|
||||
do { \
|
||||
if (item) { \
|
||||
if ((item)->next) \
|
||||
DN_DLList_Detach(item); \
|
||||
(item)->next = (list)->next; \
|
||||
(item)->prev = (list); \
|
||||
(item)->next->prev = (item); \
|
||||
(item)->prev->next = (item); \
|
||||
} \
|
||||
#define DN_SentinelDoublyLLAppend(list, item) \
|
||||
do { \
|
||||
if (item) { \
|
||||
if ((item)->next) \
|
||||
DN_SentinelDoublyLLDetach(item); \
|
||||
(item)->next = (list)->next; \
|
||||
(item)->prev = (list); \
|
||||
(item)->next->prev = (item); \
|
||||
(item)->prev->next = (item); \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
#define DN_DLList_Prepend(list, item) \
|
||||
do { \
|
||||
if (item) { \
|
||||
if ((item)->next) \
|
||||
DN_DLList_Detach(item); \
|
||||
(item)->next = (list); \
|
||||
(item)->prev = (list)->prev; \
|
||||
(item)->next->prev = (item); \
|
||||
(item)->prev->next = (item); \
|
||||
} \
|
||||
#define DN_SentinelDoublyLLPrepend(list, item) \
|
||||
do { \
|
||||
if (item) { \
|
||||
if ((item)->next) \
|
||||
DN_SentinelDoublyLLDetach(item); \
|
||||
(item)->next = (list); \
|
||||
(item)->prev = (list)->prev; \
|
||||
(item)->next->prev = (item); \
|
||||
(item)->prev->next = (item); \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
#define DN_DLList_IsEmpty(list) \
|
||||
(!(list) || ((list) == (list)->next))
|
||||
|
||||
#define DN_DLList_IsInit(list) \
|
||||
((list)->next && (list)->prev)
|
||||
|
||||
#define DN_DLList_HasItems(list) \
|
||||
((list) && ((list) != (list)->next))
|
||||
|
||||
#define DN_DLList_ForEach(it, list) \
|
||||
auto *it = (list)->next; (it) != (list); (it) = (it)->next
|
||||
// DoublyLL => Non-intrusive Doubly Linked List
|
||||
// A simple doubly linked list where each node has `next` and `prev` pointers.
|
||||
// The head is passed as a pointer-to-pointer to allow head updates.
|
||||
//
|
||||
// struct MyLinkItem {
|
||||
// int data;
|
||||
// MyLinkItem *next;
|
||||
// MyLinkItem *prev;
|
||||
// } *head = nullptr;
|
||||
// DN_DoublyLLAppend(&head, new_item);
|
||||
// for (MyLinkItem *it = head; it; it = it->next) { /* ... */ }
|
||||
|
||||
#define DN_DoublyLLDetach(head, ptr) \
|
||||
do { \
|
||||
@@ -317,182 +278,121 @@ template <typename T> struct DN_List
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
#define DN_ISLList_Detach(list) (decltype(list))DN_CSLList_Detach((void **)&(list), (void **)&(list)->next)
|
||||
// NOTE: For C++ we need to cast the void* returned in these functions to the concrete type. In C,
|
||||
// no cast is needed.
|
||||
#if defined(__cplusplus)
|
||||
#define DN_CppDeclType(x) decltype(x)
|
||||
#else
|
||||
#define DN_CppDeclType
|
||||
#endif
|
||||
|
||||
#define DN_LArray_ResizeFromPool(c_array, size, max, pool, new_max) DN_CArray2_ResizeFromPool((void **)&(c_array), size, max, sizeof((c_array)[0]), pool, new_max)
|
||||
#define DN_LArray_GrowFromPool(c_array, size, max, pool, new_max) DN_CArray2_GrowFromPool((void **)&(c_array), size, max, sizeof((c_array)[0]), pool, new_max)
|
||||
#define DN_LArray_GrowIfNeededFromPool(c_array, size, max, pool, add_count) DN_CArray2_GrowIfNeededFromPool((void **)(c_array), size, max, sizeof((c_array)[0]), pool, add_count)
|
||||
#define DN_LArray_MakeArray(c_array, size, max, count, z_mem) (decltype(&(c_array)[0]))DN_CArray2_MakeArray(c_array, size, max, sizeof((c_array)[0]), count, z_mem)
|
||||
#define DN_LArray_MakeArrayZ(c_array, size, max, count) (decltype(&(c_array)[0]))DN_CArray2_MakeArray(c_array, size, max, sizeof((c_array)[0]), count, DN_ZMem_Yes)
|
||||
#define DN_LArray_Make(c_array, size, max, z_mem) (decltype(&(c_array)[0]))DN_CArray2_MakeArray(c_array, size, max, sizeof((c_array)[0]), 1, z_mem)
|
||||
#define DN_LArray_MakeZ(c_array, size, max) (decltype(&(c_array)[0]))DN_CArray2_MakeArray(c_array, size, max, sizeof((c_array)[0]), 1, DN_ZMem_Yes)
|
||||
#define DN_LArray_AddArray(c_array, size, max, items, count, add) (decltype(&(c_array)[0]))DN_CArray2_AddArray(c_array, size, max, sizeof((c_array)[0]), items, count, add)
|
||||
#define DN_LArray_Add(c_array, size, max, item, add) (decltype(&(c_array)[0]))DN_CArray2_AddArray(c_array, size, max, sizeof((c_array)[0]), &item, 1, add)
|
||||
#define DN_LArray_AppendArray(c_array, size, max, items, count) (decltype(&(c_array)[0]))DN_CArray2_AddArray(c_array, size, max, sizeof((c_array)[0]), items, count, DN_ArrayAdd_Append)
|
||||
#define DN_LArray_Append(c_array, size, max, item) (decltype(&(c_array)[0]))DN_CArray2_AddArray(c_array, size, max, sizeof((c_array)[0]), &item, 1, DN_ArrayAdd_Append)
|
||||
#define DN_LArray_PrependArray(c_array, size, max, items, count) (decltype(&(c_array)[0]))DN_CArray2_AddArray(c_array, size, max, sizeof((c_array)[0]), items, count, DN_ArrayAdd_Prepend)
|
||||
#define DN_LArray_Prepend(c_array, size, max, item) (decltype(&(c_array)[0]))DN_CArray2_AddArray(c_array, size, max, sizeof((c_array)[0]), &item, 1, DN_ArrayAdd_Prepend)
|
||||
#define DN_LArray_EraseRange(c_array, size, begin_index, count, erase) DN_CArray2_EraseRange(c_array, size, sizeof((c_array)[0]), begin_index, count, erase)
|
||||
#define DN_LArray_Erase(c_array, size, index, erase) DN_CArray2_EraseRange(c_array, size, sizeof((c_array)[0]), index, 1, erase)
|
||||
#define DN_LArray_InsertArray(c_array, size, max, index, items, count) (decltype(&(c_array)[0]))DN_CArray2_InsertArray(c_array, size, max, sizeof((c_array)[0]), index, items, count)
|
||||
#define DN_LArray_Insert(c_array, size, max, index, item) (decltype(&(c_array)[0]))DN_CArray2_InsertArray(c_array, size, max, sizeof((c_array)[0]), index, &item, 1)
|
||||
#define DN_PArrayResizeFromPool(ptr, size, max, pool, new_max) DN_CArrayResizeFromPool((void **)&(ptr), size, max, sizeof((ptr)[0]), pool, new_max)
|
||||
#define DN_PArrayGrowFromPool(ptr, size, max, pool, new_max) DN_CArrayGrowFromPool((void **)&(ptr), size, max, sizeof((ptr)[0]), pool, new_max)
|
||||
#define DN_PArrayGrowIfNeededFromPool(ptr, size, max, pool, add_count) DN_CArrayGrowIfNeededFromPool((void **)(ptr), size, max, sizeof((ptr)[0]), pool, add_count)
|
||||
#define DN_PArrayMakeArray(ptr, size, max, count, z_mem) (DN_CppDeclType(&(ptr)[0]))DN_CArrayMakeArray(ptr, size, max, sizeof((ptr)[0]), count, z_mem)
|
||||
#define DN_PArrayMakeArrayZ(ptr, size, max, count) (DN_CppDeclType(&(ptr)[0]))DN_CArrayMakeArray(ptr, size, max, sizeof((ptr)[0]), count, DN_ZMem_Yes)
|
||||
#define DN_PArrayMake(ptr, size, max, z_mem) (DN_CppDeclType(&(ptr)[0]))DN_CArrayMakeArray(ptr, size, max, sizeof((ptr)[0]), 1, z_mem)
|
||||
#define DN_PArrayMakeZ(ptr, size, max) (DN_CppDeclType(&(ptr)[0]))DN_CArrayMakeArray(ptr, size, max, sizeof((ptr)[0]), 1, DN_ZMem_Yes)
|
||||
#define DN_PArrayAddArray(ptr, size, max, items, count, add) (DN_CppDeclType(&(ptr)[0]))DN_CArrayAddArray(ptr, size, max, sizeof((ptr)[0]), items, count, add)
|
||||
#define DN_PArrayAdd(ptr, size, max, item, add) (DN_CppDeclType(&(ptr)[0]))DN_CArrayAddArray(ptr, size, max, sizeof((ptr)[0]), &item, 1, add)
|
||||
#define DN_PArrayAppendArray(ptr, size, max, items, count) (DN_CppDeclType(&(ptr)[0]))DN_CArrayAddArray(ptr, size, max, sizeof((ptr)[0]), items, count, DN_ArrayAdd_Append)
|
||||
#define DN_PArrayAppend(ptr, size, max, item) (DN_CppDeclType(&(ptr)[0]))DN_CArrayAddArray(ptr, size, max, sizeof((ptr)[0]), &item, 1, DN_ArrayAdd_Append)
|
||||
#define DN_PArrayPrependArray(ptr, size, max, items, count) (DN_CppDeclType(&(ptr)[0]))DN_CArrayAddArray(ptr, size, max, sizeof((ptr)[0]), items, count, DN_ArrayAdd_Prepend)
|
||||
#define DN_PArrayPrepend(ptr, size, max, item) (DN_CppDeclType(&(ptr)[0]))DN_CArrayAddArray(ptr, size, max, sizeof((ptr)[0]), &item, 1, DN_ArrayAdd_Prepend)
|
||||
#define DN_PArrayEraseRange(ptr, size, begin_index, count, erase) DN_CArrayEraseRange(ptr, size, sizeof((ptr)[0]), begin_index, count, erase)
|
||||
#define DN_PArrayErase(ptr, size, index, erase) DN_CArrayEraseRange(ptr, size, sizeof((ptr)[0]), index, 1, erase)
|
||||
#define DN_PArrayInsertArray(ptr, size, max, index, items, count) (DN_CppDeclType(&(ptr)[0]))DN_CArrayInsertArray(ptr, size, max, sizeof((ptr)[0]), index, items, count)
|
||||
#define DN_PArrayInsert(ptr, size, max, index, item) (DN_CppDeclType(&(ptr)[0]))DN_CArrayInsertArray(ptr, size, max, sizeof((ptr)[0]), index, &item, 1)
|
||||
#define DN_PArrayPopFront(ptr, size, max, count) (DN_CppDeclType(&(ptr)[0]))DN_CArrayPopFront(ptr, size, sizeof((ptr)[0]), count)
|
||||
#define DN_PArrayPopBack(ptr, size, max, count) (DN_CppDeclType(&(ptr)[0]))DN_CArrayPopBack(ptr, size, sizeof((ptr)[0]), count)
|
||||
|
||||
#define DN_IArray_ResizeFromPool(array, pool, new_max) DN_CArray2_ResizeFromPool((void **)(&(array)->data), &(array)->size, &(array)->max, sizeof((array)->data[0]), pool, new_max)
|
||||
#define DN_IArray_GrowFromPool(array, pool, new_max) DN_CArray2_GrowFromPool((void **)(&(array)->data), &(array)->size, &(array)->max, sizeof((array)->data[0]), pool, new_max)
|
||||
#define DN_IArray_GrowIfNeededFromPool(array, pool, add_count) DN_CArray2_GrowIfNeededFromPool((void **)(&(array)->data), (array)->size, &(array)->max, sizeof((array)->data[0]), pool, add_count)
|
||||
#define DN_IArray_MakeArray(array, count, z_mem) (decltype(&((array)->data)[0]))DN_CArray2_MakeArray((array)->data, &(array)->size, (array)->max, sizeof(((array)->data)[0]), count, z_mem)
|
||||
#define DN_IArray_MakeArrayZ(array, count) (decltype(&((array)->data)[0]))DN_CArray2_MakeArray((array)->data, &(array)->size, (array)->max, sizeof(((array)->data)[0]), count, DN_ZMem_Yes)
|
||||
#define DN_IArray_Make(array, z_mem) (decltype(&((array)->data)[0]))DN_CArray2_MakeArray((array)->data, &(array)->size, (array)->max, sizeof(((array)->data)[0]), 1, z_mem)
|
||||
#define DN_IArray_MakeZ(array) (decltype(&((array)->data)[0]))DN_CArray2_MakeArray((array)->data, &(array)->size, (array)->max, sizeof(((array)->data)[0]), 1, DN_ZMem_Yes)
|
||||
#define DN_IArray_AddArray(array, items, count, add) (decltype(&((array)->data)[0]))DN_CArray2_AddArray((array)->data, &(array)->size, (array)->max, sizeof(((array)->data)[0]), items, count, add)
|
||||
#define DN_IArray_Add(array, item, add) (decltype(&((array)->data)[0]))DN_CArray2_AddArray((array)->data, &(array)->size, (array)->max, sizeof(((array)->data)[0]), &item, 1, add)
|
||||
#define DN_IArray_AppendArray(array, items, count) (decltype(&((array)->data)[0]))DN_CArray2_AddArray((array)->data, &(array)->size, (array)->max, sizeof(((array)->data)[0]), items, count, DN_ArrayAdd_Append)
|
||||
#define DN_IArray_Append(array, item) (decltype(&((array)->data)[0]))DN_CArray2_AddArray((array)->data, &(array)->size, (array)->max, sizeof(((array)->data)[0]), &item, 1, DN_ArrayAdd_Append)
|
||||
#define DN_IArray_PrependArray(array, items, count) (decltype(&((array)->data)[0]))DN_CArray2_AddArray((array)->data, &(array)->size, (array)->max, sizeof(((array)->data)[0]), items, count, DN_ArrayAdd_Prepend)
|
||||
#define DN_IArray_Prepend(array, item) (decltype(&((array)->data)[0]))DN_CArray2_AddArray((array)->data, &(array)->size, (array)->max, sizeof(((array)->data)[0]), &item, 1, DN_ArrayAdd_Prepend)
|
||||
#define DN_IArray_EraseRange(array, begin_index, count, erase) DN_CArray2_EraseRange((array)->data, &(array)->size, sizeof(((array)->data)[0]), begin_index, count, erase)
|
||||
#define DN_IArray_Erase(array, index, erase) DN_CArray2_EraseRange((array)->data, &(array)->size, sizeof(((array)->data)[0]), index, 1, erase)
|
||||
#define DN_IArray_InsertArray(array, index, items, count) (decltype(&((array)->data)[0]))DN_CArray2_InsertArray((array)->data, &(array)->size, (array)->max, sizeof(((array)->data)[0]), index, items, count)
|
||||
#define DN_IArray_Insert(array, index, item, count) (decltype(&((array)->data)[0]))DN_CArray2_InsertArray((array)->data, &(array)->size, (array)->max, sizeof(((array)->data)[0]), index, &item, 1)
|
||||
#define DN_LArrayResizeFromPool(c_array, size, pool, new_max) DN_PArrayResizeFromPool(c_array, size, DN_ArrayCountU(c_array), pool, new_max)
|
||||
#define DN_LArrayGrowFromPool(c_array, size, pool, new_max) DN_PArrayGrowFromPool(c_array, size, DN_ArrayCountU(c_array), pool, new_max)
|
||||
#define DN_LArrayGrowIfNeededFromPool(c_array, size, pool, add_count) DN_PArrayGrowIfNeededFromPool(c_array, size, DN_ArrayCountU(c_array), pool, add_count)
|
||||
#define DN_LArrayMakeArray(c_array, size, count, z_mem) DN_PArrayMakeArray(c_array, size, DN_ArrayCountU(c_array), count, z_mem)
|
||||
#define DN_LArrayMakeArrayZ(c_array, size, count) DN_PArrayMakeArrayZ(c_array, size, DN_ArrayCountU(c_array), count)
|
||||
#define DN_LArrayMake(c_array, size, z_mem) DN_PArrayMake(c_array, size, DN_ArrayCountU(c_array), z_mem)
|
||||
#define DN_LArrayMakeZ(c_array, size, max) DN_PArrayMakeZ(c_array, size, DN_ArrayCountU(c_array), max)
|
||||
#define DN_LArrayAddArray(c_array, size, items, count, add) DN_PArrayAddArray(c_array, size, DN_ArrayCountU(c_array), items, count, add)
|
||||
#define DN_LArrayAdd(c_array, size, item, add) DN_PArrayAdd(c_array, size, DN_ArrayCountU(c_array), item, add)
|
||||
#define DN_LArrayAppendArray(c_array, size, items, count) DN_PArrayAppendArray(c_array, size, DN_ArrayCountU(c_array), items, count)
|
||||
#define DN_LArrayAppend(c_array, size, item) DN_PArrayAppend(c_array, size, DN_ArrayCountU(c_array), item)
|
||||
#define DN_LArrayPrependArray(c_array, size, items, count) DN_PArrayPrependArray(c_array, size, DN_ArrayCountU(c_array), items, count)
|
||||
#define DN_LArrayPrepend(c_array, size, item) DN_PArrayPrepend(c_array, size, DN_ArrayCountU(c_array), item)
|
||||
#define DN_LArrayEraseRange(c_array, size, begin_index, count, erase) DN_PArrayEraseRange(c_array, size, DN_ArrayCountU(c_array), begin_index, count, erase)
|
||||
#define DN_LArrayErase(c_array, size, index, erase) DN_PArrayErase(c_array, size, DN_ArrayCountU(c_array), index, erase)
|
||||
#define DN_LArrayInsertArray(c_array, size, index, items, count) DN_PArrayInsertArray(c_array, size, DN_ArrayCountU(c_array), index, items, count)
|
||||
#define DN_LArrayInsert(c_array, size, index, item) DN_PArrayInsert(c_array, size, DN_ArrayCountU(c_array), index, item)
|
||||
#define DN_LArrayPopFront(c_array, size, count) DN_PArrayPopFront(c_array, size, DN_ArrayCountU(c_array), count)
|
||||
#define DN_LArrayPopBack(c_array, size, count) DN_PArrayPopBack(c_array, size, DN_ArrayCountU(c_array), count)
|
||||
|
||||
DN_API DN_ArrayEraseResult DN_CArray2_EraseRange (void *data, DN_USize *size, DN_USize elem_size, DN_USize begin_index, DN_ISize count, DN_ArrayErase erase);
|
||||
DN_API void *DN_CArray2_MakeArray (void *data, DN_USize *size, DN_USize max, DN_USize data_size, DN_USize make_size, DN_ZMem z_mem);
|
||||
DN_API void *DN_CArray2_AddArray (void *data, DN_USize *size, DN_USize max, DN_USize data_size, void const *elems, DN_USize elems_count, DN_ArrayAdd add);
|
||||
DN_API bool DN_CArray2_Resize (void **data, DN_USize *size, DN_USize *max, DN_USize data_size, DN_Pool *pool, DN_USize new_max);
|
||||
DN_API bool DN_CArray2_Grow (void **data, DN_USize *size, DN_USize *max, DN_USize data_size, DN_Pool *pool, DN_USize new_max);
|
||||
DN_API bool DN_CArray2_GrowIfNeededFromPool (void **data, DN_USize size, DN_USize *max, DN_USize data_size, DN_Pool *pool);
|
||||
DN_API void *DN_CSLList_Detach (void **link, void **next);
|
||||
#define DN_IArrayResizeFromPool(array, pool, new_max) DN_CArrayResizeFromPool((void **)(&(array)->data), &(array)->size, &(array)->max, sizeof((array)->data[0]), pool, new_max)
|
||||
#define DN_IArrayGrowFromPool(array, pool, new_max) DN_CArrayGrowFromPool((void **)(&(array)->data), (array)->size, &(array)->max, sizeof((array)->data[0]), pool, new_max)
|
||||
#define DN_IArrayGrowIfNeededFromPool(array, pool, add_count) DN_CArrayGrowIfNeededFromPool((void **)(&(array)->data), (array)->size, &(array)->max, sizeof((array)->data[0]), pool, add_count)
|
||||
#define DN_IArrayMakeArray(array, count, z_mem) (DN_CppDeclType(&((array)->data)[0]))DN_CArrayMakeArray((array)->data, &(array)->size, (array)->max, sizeof(((array)->data)[0]), count, z_mem)
|
||||
#define DN_IArrayMakeArrayZ(array, count) (DN_CppDeclType(&((array)->data)[0]))DN_CArrayMakeArray((array)->data, &(array)->size, (array)->max, sizeof(((array)->data)[0]), count, DN_ZMem_Yes)
|
||||
#define DN_IArrayMake(array, z_mem) (DN_CppDeclType(&((array)->data)[0]))DN_CArrayMakeArray((array)->data, &(array)->size, (array)->max, sizeof(((array)->data)[0]), 1, z_mem)
|
||||
#define DN_IArrayMakeZ(array) (DN_CppDeclType(&((array)->data)[0]))DN_CArrayMakeArray((array)->data, &(array)->size, (array)->max, sizeof(((array)->data)[0]), 1, DN_ZMem_Yes)
|
||||
#define DN_IArrayAddArray(array, items, count, add) (DN_CppDeclType(&((array)->data)[0]))DN_CArrayAddArray((array)->data, &(array)->size, (array)->max, sizeof(((array)->data)[0]), items, count, add)
|
||||
#define DN_IArrayAdd(array, item, add) (DN_CppDeclType(&((array)->data)[0]))DN_CArrayAddArray((array)->data, &(array)->size, (array)->max, sizeof(((array)->data)[0]), &item, 1, add)
|
||||
#define DN_IArrayAppendArray(array, items, count) (DN_CppDeclType(&((array)->data)[0]))DN_CArrayAddArray((array)->data, &(array)->size, (array)->max, sizeof(((array)->data)[0]), items, count, DN_ArrayAdd_Append)
|
||||
#define DN_IArrayAppend(array, item) (DN_CppDeclType(&((array)->data)[0]))DN_CArrayAddArray((array)->data, &(array)->size, (array)->max, sizeof(((array)->data)[0]), &item, 1, DN_ArrayAdd_Append)
|
||||
#define DN_IArrayPrependArray(array, items, count) (DN_CppDeclType(&((array)->data)[0]))DN_CArrayAddArray((array)->data, &(array)->size, (array)->max, sizeof(((array)->data)[0]), items, count, DN_ArrayAdd_Prepend)
|
||||
#define DN_IArrayPrepend(array, item) (DN_CppDeclType(&((array)->data)[0]))DN_CArrayAddArray((array)->data, &(array)->size, (array)->max, sizeof(((array)->data)[0]), &item, 1, DN_ArrayAdd_Prepend)
|
||||
#define DN_IArrayEraseRange(array, begin_index, count, erase) DN_CArrayEraseRange((array)->data, &(array)->size, sizeof(((array)->data)[0]), begin_index, count, erase)
|
||||
#define DN_IArrayErase(array, index, erase) DN_CArrayEraseRange((array)->data, &(array)->size, sizeof(((array)->data)[0]), index, 1, erase)
|
||||
#define DN_IArrayInsertArray(array, index, items, count) (DN_CppDeclType(&((array)->data)[0]))DN_CArrayInsertArray((array)->data, &(array)->size, (array)->max, sizeof(((array)->data)[0]), index, items, count)
|
||||
#define DN_IArrayInsert(array, index, item, count) (DN_CppDeclType(&((array)->data)[0]))DN_CArrayInsertArray((array)->data, &(array)->size, (array)->max, sizeof(((array)->data)[0]), index, &item, 1)
|
||||
#define DN_IArrayPopFront(array, count) (DN_CppDeclType(&((array)->data)[0]))DN_CArrayPopFront((array)->data, &(array)->size, sizeof(((array)->data)[0]), count)
|
||||
#define DN_IArrayPopBack(array, count) (DN_CppDeclType(&((array)->data)[0]))DN_CArrayPopBack((array)->data, &(array)->size, sizeof(((array)->data)[0]), count)
|
||||
|
||||
DN_API bool DN_Ring_HasSpace (DN_Ring const *ring, DN_U64 size);
|
||||
DN_API bool DN_Ring_HasData (DN_Ring const *ring, DN_U64 size);
|
||||
DN_API void DN_Ring_Write (DN_Ring *ring, void const *src, DN_U64 src_size);
|
||||
#define DN_Ring_WriteStruct(ring, item) DN_Ring_Write((ring), (item), sizeof(*(item)))
|
||||
DN_API void DN_Ring_Read (DN_Ring *ring, void *dest, DN_U64 dest_size);
|
||||
#define DN_Ring_ReadStruct(ring, dest) DN_Ring_Read((ring), (dest), sizeof(*(dest)))
|
||||
#define DN_ISliceAllocArena(T, slice_ptr, count_, zmem, arena) (T *)DN_SliceAllocArena((void **)&((slice_ptr)->data), &((slice_ptr)->count), count_, sizeof(T), alignof(T), zmem, arena)
|
||||
|
||||
template <typename T> DN_ArrayEraseResult DN_CArray_EraseRange (T *data, DN_USize *size, DN_USize begin_index, DN_ISize count, DN_ArrayErase erase);
|
||||
template <typename T> T * DN_CArray_MakeArray (T *data, DN_USize *size, DN_USize max, DN_USize count, DN_ZMem z_mem);
|
||||
template <typename T> T * DN_CArray_InsertArray (T *data, DN_USize *size, DN_USize max, DN_USize index, T const *items, DN_USize count);
|
||||
template <typename T> T DN_CArray_PopFront (T *data, DN_USize *size, DN_USize count);
|
||||
template <typename T> T DN_CArray_PopBack (T *data, DN_USize *size, DN_USize count);
|
||||
template <typename T> DN_ArrayFindResult<T> DN_CArray_Find (T *data, DN_USize size, T const &value);
|
||||
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);
|
||||
|
||||
// NOTE: DN_SArray /////////////////////////////////////////////////////////////////////////////////
|
||||
#if !defined(DN_NO_SARRAY)
|
||||
template <typename T> DN_SArray<T> DN_SArray_Init (DN_Arena *arena, DN_USize size, DN_ZMem z_mem);
|
||||
template <typename T> DN_SArray<T> DN_SArray_InitSlice (DN_Arena *arena, DN_Slice<T> slice, DN_USize size, DN_ZMem z_mem);
|
||||
template <typename T, size_t N> DN_SArray<T> DN_SArray_InitCArray (DN_Arena *arena, T const (&array)[N], DN_USize size, DN_ZMem);
|
||||
template <typename T> DN_SArray<T> DN_SArray_InitBuffer (T* buffer, DN_USize size);
|
||||
template <typename T> bool DN_SArray_IsValid (DN_SArray<T> const *array);
|
||||
template <typename T> DN_Slice<T> DN_SArray_Slice (DN_SArray<T> const *array);
|
||||
template <typename T> T * DN_SArray_AddArray (DN_SArray<T> *array, T const *items, DN_USize count);
|
||||
template <typename T, DN_USize N> T * DN_SArray_AddCArray (DN_SArray<T> *array, T const (&items)[N]);
|
||||
template <typename T> T * DN_SArray_Add (DN_SArray<T> *array, T const &item);
|
||||
#define DN_SArray_AddArrayAssert(...) DN_HardAssert(DN_SArray_AddArray(__VA_ARGS__))
|
||||
#define DN_SArray_AddCArrayAssert(...) DN_HardAssert(DN_SArray_AddCArray(__VA_ARGS__))
|
||||
#define DN_SArray_AddAssert(...) DN_HardAssert(DN_SArray_Add(__VA_ARGS__))
|
||||
template <typename T> T * DN_SArray_MakeArray (DN_SArray<T> *array, DN_USize count, DN_ZMem z_mem);
|
||||
template <typename T> T * DN_SArray_Make (DN_SArray<T> *array, DN_ZMem z_mem);
|
||||
#define DN_SArray_MakeArrayAssert(...) DN_HardAssert(DN_SArray_MakeArray(__VA_ARGS__))
|
||||
#define DN_SArray_MakeAssert(...) DN_HardAssert(DN_SArray_Make(__VA_ARGS__))
|
||||
template <typename T> T * DN_SArray_InsertArray (DN_SArray<T> *array, DN_USize index, T const *items, DN_USize count);
|
||||
template <typename T, DN_USize N> T * DN_SArray_InsertCArray (DN_SArray<T> *array, DN_USize index, T const (&items)[N]);
|
||||
template <typename T> T * DN_SArray_Insert (DN_SArray<T> *array, DN_USize index, T const &item);
|
||||
#define DN_SArray_InsertArrayAssert(...) DN_HardAssert(DN_SArray_InsertArray(__VA_ARGS__))
|
||||
#define DN_SArray_InsertCArrayAssert(...) DN_HardAssert(DN_SArray_InsertCArray(__VA_ARGS__))
|
||||
#define DN_SArray_InsertAssert(...) DN_HardAssert(DN_SArray_Insert(__VA_ARGS__))
|
||||
template <typename T> T DN_SArray_PopFront (DN_SArray<T> *array, DN_USize count);
|
||||
template <typename T> T DN_SArray_PopBack (DN_SArray<T> *array, DN_USize count);
|
||||
template <typename T> DN_ArrayEraseResult DN_SArray_EraseRange (DN_SArray<T> *array, DN_USize begin_index, DN_ISize count, DN_ArrayErase erase);
|
||||
template <typename T> void DN_SArray_Clear (DN_SArray<T> *array);
|
||||
#endif // !defined(DN_NO_SARRAY)
|
||||
DN_API void* DN_CArrayInsertArray (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_CArrayPopFront (void *data, DN_USize *size, DN_USize elem_size, DN_USize count);
|
||||
DN_API void* DN_CArrayPopBack (void *data, DN_USize *size, DN_USize elem_size, DN_USize count);
|
||||
DN_API DN_ArrayEraseResult DN_CArrayEraseRange (void *data, DN_USize *size, DN_USize elem_size, DN_USize begin_index, DN_ISize count, DN_ArrayErase erase);
|
||||
DN_API void* DN_CArrayMakeArray (void *data, DN_USize *size, DN_USize max, DN_USize data_size, DN_USize make_size, DN_ZMem z_mem);
|
||||
DN_API void* DN_CArrayAddArray (void *data, DN_USize *size, DN_USize max, DN_USize data_size, void const *elems, DN_USize elems_count, DN_ArrayAdd add);
|
||||
DN_API bool DN_CArrayResizeFromPool (void **data, DN_USize *size, DN_USize *max, DN_USize data_size, DN_Pool *pool, DN_USize new_max);
|
||||
DN_API bool DN_CArrayGrowFromPool (void **data, DN_USize size, DN_USize *max, DN_USize data_size, DN_Pool *pool, DN_USize new_max);
|
||||
DN_API bool DN_CArrayGrowIfNeededFromPool (void **data, DN_USize size, DN_USize *max, DN_USize data_size, DN_Pool *pool);
|
||||
|
||||
#if !defined(DN_NO_FARRAY)
|
||||
#define DN_FArray_ToSArray(array) DN_SArray_InitBuffer((array)->data, DN_ArrayCountU((array)->data))
|
||||
template <typename T, DN_USize N> DN_FArray<T, N> DN_FArray_Init (T const *array, DN_USize count);
|
||||
#define DN_FArray_HasData(array) ((array).data && (array).size)
|
||||
template <typename T, DN_USize N> DN_FArray<T, N> DN_FArray_InitSlice (DN_Slice<T> slice);
|
||||
template <typename T, DN_USize N, DN_USize K> DN_FArray<T, N> DN_FArray_InitCArray (T const (&items)[K]);
|
||||
template <typename T, DN_USize N> bool DN_FArray_IsValid (DN_FArray<T, N> const *array);
|
||||
template <typename T, DN_USize N> DN_USize DN_FArray_Max (DN_FArray<T, N> const *) { return N; }
|
||||
template <typename T, DN_USize N> DN_Slice<T> DN_FArray_Slice (DN_FArray<T, N> const *array);
|
||||
template <typename T, DN_USize N> T * DN_FArray_AddArray (DN_FArray<T, N> *array, T const *items, DN_USize count);
|
||||
template <typename T, DN_USize N, DN_USize K> T * DN_FArray_AddCArray (DN_FArray<T, N> *array, T const (&items)[K]);
|
||||
template <typename T, DN_USize N> T * DN_FArray_Add (DN_FArray<T, N> *array, T const &item);
|
||||
#define DN_FArray_AddArrayAssert(...) DN_HardAssert(DN_FArray_AddArray(__VA_ARGS__))
|
||||
#define DN_FArray_AddCArrayAssert(...) DN_HardAssert(DN_FArray_AddCArray(__VA_ARGS__))
|
||||
#define DN_FArray_AddAssert(...) DN_HardAssert(DN_FArray_Add(__VA_ARGS__))
|
||||
template <typename T, DN_USize N> T * DN_FArray_MakeArray (DN_FArray<T, N> *array, DN_USize count, DN_ZMem z_mem);
|
||||
template <typename T, DN_USize N> T * DN_FArray_Make (DN_FArray<T, N> *array, DN_ZMem z_mem);
|
||||
#define DN_FArray_MakeArrayAssert(...) DN_HardAssert(DN_FArray_MakeArray(__VA_ARGS__))
|
||||
#define DN_FArray_MakeAssert(...) DN_HardAssert(DN_FArray_Make(__VA_ARGS__))
|
||||
template <typename T, DN_USize N> T * DN_FArray_InsertArray (DN_FArray<T, N> *array, T const &item, DN_USize index);
|
||||
template <typename T, DN_USize N, DN_USize K> T * DN_FArray_InsertCArray (DN_FArray<T, N> *array, DN_USize index, T const (&items)[K]);
|
||||
template <typename T, DN_USize N> T * DN_FArray_Insert (DN_FArray<T, N> *array, DN_USize index, T const &item);
|
||||
#define DN_FArray_InsertArrayAssert(...) DN_HardAssert(DN_FArray_InsertArray(__VA_ARGS__))
|
||||
#define DN_FArray_InsertAssert(...) DN_HardAssert(DN_FArray_Insert(__VA_ARGS__))
|
||||
template <typename T, DN_USize N> T DN_FArray_PopFront (DN_FArray<T, N> *array, DN_USize count);
|
||||
template <typename T, DN_USize N> T DN_FArray_PopBack (DN_FArray<T, N> *array, DN_USize count);
|
||||
template <typename T, DN_USize N> DN_ArrayFindResult<T> DN_FArray_Find (DN_FArray<T, N> *array, T const &find);
|
||||
template <typename T, DN_USize N> DN_ArrayEraseResult DN_FArray_EraseRange (DN_FArray<T, N> *array, DN_USize begin_index, DN_ISize count, DN_ArrayErase erase);
|
||||
template <typename T, DN_USize N> void DN_FArray_Clear (DN_FArray<T, N> *array);
|
||||
#endif // !defined(DN_NO_FARRAY)
|
||||
DN_API void* DN_SinglyLLDetach (void **link, void **next);
|
||||
|
||||
#if !defined(DN_NO_SLICE)
|
||||
#define DN_TO_SLICE(val) DN_Slice_Init((val)->data, (val)->size)
|
||||
#define DN_Slice_InitCArray(array) DN_Slice_Init(array, DN_ArrayCountU(array))
|
||||
template <typename T> DN_Slice<T> DN_Slice_Init (T* const data, DN_USize size);
|
||||
template <typename T, DN_USize N> DN_Slice<T> DN_Slice_InitCArrayCopy (DN_Arena *arena, T const (&array)[N]);
|
||||
template <typename T> DN_Slice<T> DN_Slice_Copy (DN_Arena *arena, DN_Slice<T> slice);
|
||||
template <typename T> DN_Slice<T> DN_Slice_CopyPtr (DN_Arena *arena, T* const data, DN_USize size);
|
||||
template <typename T> DN_Slice<T> DN_Slice_Alloc (DN_Arena *arena, DN_USize size, DN_ZMem z_mem);
|
||||
DN_Str8 DN_Slice_Str8Render (DN_Arena *arena, DN_Slice<DN_Str8> array, DN_Str8 separator);
|
||||
DN_Str8 DN_Slice_Str8RenderSpaceSeparated (DN_Arena *arena, DN_Slice<DN_Str8> array);
|
||||
DN_Str16 DN_Slice_Str16Render (DN_Arena *arena, DN_Slice<DN_Str16> array, DN_Str16 separator);
|
||||
DN_Str16 DN_Slice_Str16RenderSpaceSeparated(DN_Arena *arena, DN_Slice<DN_Str16> array);
|
||||
#endif // !defined(DN_NO_SLICE)
|
||||
DN_API bool DN_RingHasSpace (DN_Ring const *ring, DN_U64 size);
|
||||
DN_API bool DN_RingHasData (DN_Ring const *ring, DN_U64 size);
|
||||
DN_API void DN_RingWrite (DN_Ring *ring, void const *src, DN_U64 src_size);
|
||||
#define DN_RingWriteStruct(ring, item) DN_RingWrite((ring), (item), sizeof(*(item)))
|
||||
DN_API void DN_RingRead (DN_Ring *ring, void *dest, DN_U64 dest_size);
|
||||
#define DN_RingReadStruct(ring, dest) DN_RingRead((ring), (dest), sizeof(*(dest)))
|
||||
|
||||
#if !defined(DN_NO_DSMAP)
|
||||
template <typename T> DN_DSMap<T> DN_DSMap_Init (DN_Arena *arena, DN_U32 size, DN_DSMapFlags flags);
|
||||
template <typename T> void DN_DSMap_Deinit (DN_DSMap<T> *map, DN_ZMem z_mem);
|
||||
template <typename T> bool DN_DSMap_IsValid (DN_DSMap<T> const *map);
|
||||
template <typename T> DN_U32 DN_DSMap_Hash (DN_DSMap<T> const *map, DN_DSMapKey key);
|
||||
template <typename T> DN_U32 DN_DSMap_HashToSlotIndex (DN_DSMap<T> const *map, DN_DSMapKey key);
|
||||
template <typename T> DN_DSMapResult<T> DN_DSMap_Find (DN_DSMap<T> const *map, DN_DSMapKey key);
|
||||
template <typename T> DN_DSMapResult<T> DN_DSMap_Make (DN_DSMap<T> *map, DN_DSMapKey key);
|
||||
template <typename T> DN_DSMapResult<T> DN_DSMap_Set (DN_DSMap<T> *map, DN_DSMapKey key, T const &value);
|
||||
template <typename T> DN_DSMapResult<T> DN_DSMap_FindKeyU64 (DN_DSMap<T> const *map, DN_U64 key);
|
||||
template <typename T> DN_DSMapResult<T> DN_DSMap_MakeKeyU64 (DN_DSMap<T> *map, DN_U64 key);
|
||||
template <typename T> DN_DSMapResult<T> DN_DSMap_SetKeyU64 (DN_DSMap<T> *map, DN_U64 key, T const &value);
|
||||
template <typename T> DN_DSMapResult<T> DN_DSMap_FindKeyStr8 (DN_DSMap<T> const *map, DN_Str8 key);
|
||||
template <typename T> DN_DSMapResult<T> DN_DSMap_MakeKeyStr8 (DN_DSMap<T> *map, DN_Str8 key);
|
||||
template <typename T> DN_DSMapResult<T> DN_DSMap_SetKeyStr8 (DN_DSMap<T> *map, DN_Str8 key, T const &value);
|
||||
template <typename T> bool DN_DSMap_Resize (DN_DSMap<T> *map, DN_U32 size);
|
||||
template <typename T> bool DN_DSMap_Erase (DN_DSMap<T> *map, DN_DSMapKey key);
|
||||
template <typename T> bool DN_DSMap_EraseKeyU64 (DN_DSMap<T> *map, DN_U64 key);
|
||||
template <typename T> bool DN_DSMap_EraseKeyStr8 (DN_DSMap<T> *map, DN_Str8 key);
|
||||
template <typename T> DN_DSMapKey DN_DSMap_KeyBuffer (DN_DSMap<T> const *map, void const *data, DN_U32 size);
|
||||
template <typename T> DN_DSMapKey DN_DSMap_KeyBufferAsU64NoHash (DN_DSMap<T> const *map, void const *data, DN_U32 size);
|
||||
template <typename T> DN_DSMapKey DN_DSMap_KeyU64 (DN_DSMap<T> const *map, DN_U64 u64);
|
||||
template <typename T> DN_DSMapKey DN_DSMap_KeyStr8 (DN_DSMap<T> const *map, DN_Str8 string);
|
||||
#define DN_DSMap_KeyCStr8(map, string) DN_DSMap_KeyBuffer(map, string, sizeof((string))/sizeof((string)[0]) - 1)
|
||||
DN_API DN_DSMapKey DN_DSMap_KeyU64NoHash (DN_U64 u64);
|
||||
DN_API bool DN_DSMap_KeyEquals (DN_DSMapKey lhs, DN_DSMapKey rhs);
|
||||
DN_API bool operator== (DN_DSMapKey lhs, DN_DSMapKey rhs);
|
||||
#endif // !defined(DN_NO_DSMAP)
|
||||
|
||||
#if !defined(DN_NO_LIST)
|
||||
template <typename T> DN_List<T> DN_List_Init (DN_USize chunk_size);
|
||||
template <typename T, size_t N> DN_List<T> DN_List_InitCArray (DN_Arena *arena, DN_USize chunk_size, T const (&array)[N]);
|
||||
template <typename T> T * DN_List_At (DN_List<T> *list, DN_USize index, DN_ListChunk<T> **at_chunk);
|
||||
template <typename T> void DN_List_Clear (DN_List<T> *list);
|
||||
template <typename T> bool DN_List_Iterate (DN_List<T> *list, DN_ListIterator<T> *it, DN_USize start_index);
|
||||
template <typename T> T * DN_List_MakeArena (DN_List<T> *list, DN_Arena *arena, DN_USize count);
|
||||
template <typename T> T * DN_List_MakePool (DN_List<T> *list, DN_Pool *pool, DN_USize count);
|
||||
template <typename T> T * DN_List_AddArena (DN_List<T> *list, DN_Arena *arena, T const &value);
|
||||
template <typename T> T * DN_List_AddPool (DN_List<T> *list, DN_Pool *pool, T const &value);
|
||||
template <typename T> void DN_List_AddListArena (DN_List<T> *list, DN_Arena *arena, DN_List<T> other);
|
||||
template <typename T> void DN_List_AddListArena (DN_List<T> *list, DN_Pool *pool, DN_List<T> other);
|
||||
template <typename T> DN_Slice<T> DN_List_ToSliceCopy (DN_List<T> const *list, DN_Arena* arena);
|
||||
#endif // !defined(DN_NO_LIST)
|
||||
template <typename T> DN_DSMap<T> DN_DSMapInit (DN_Arena *arena, DN_U32 size, DN_DSMapFlags flags);
|
||||
template <typename T> void DN_DSMapDeinit (DN_DSMap<T> *map, DN_ZMem z_mem);
|
||||
template <typename T> bool DN_DSMapIsValid (DN_DSMap<T> const *map);
|
||||
template <typename T> DN_U32 DN_DSMapHash (DN_DSMap<T> const *map, DN_DSMapKey key);
|
||||
template <typename T> DN_U32 DN_DSMapHashToSlotIndex (DN_DSMap<T> const *map, DN_DSMapKey key);
|
||||
template <typename T> DN_DSMapResult<T> DN_DSMapFind (DN_DSMap<T> const *map, DN_DSMapKey key);
|
||||
template <typename T> DN_DSMapResult<T> DN_DSMapMake (DN_DSMap<T> *map, DN_DSMapKey key);
|
||||
template <typename T> DN_DSMapResult<T> DN_DSMapSet (DN_DSMap<T> *map, DN_DSMapKey key, T const &value);
|
||||
template <typename T> DN_DSMapResult<T> DN_DSMapFindKeyU64 (DN_DSMap<T> const *map, DN_U64 key);
|
||||
template <typename T> DN_DSMapResult<T> DN_DSMapMakeKeyU64 (DN_DSMap<T> *map, DN_U64 key);
|
||||
template <typename T> DN_DSMapResult<T> DN_DSMapSetKeyU64 (DN_DSMap<T> *map, DN_U64 key, T const &value);
|
||||
template <typename T> DN_DSMapResult<T> DN_DSMapFindKeyStr8 (DN_DSMap<T> const *map, DN_Str8 key);
|
||||
template <typename T> DN_DSMapResult<T> DN_DSMapMakeKeyStr8 (DN_DSMap<T> *map, DN_Str8 key);
|
||||
template <typename T> DN_DSMapResult<T> DN_DSMapSetKeyStr8 (DN_DSMap<T> *map, DN_Str8 key, T const &value);
|
||||
template <typename T> bool DN_DSMapResize (DN_DSMap<T> *map, DN_U32 size);
|
||||
template <typename T> bool DN_DSMapErase (DN_DSMap<T> *map, DN_DSMapKey key);
|
||||
template <typename T> bool DN_DSMapEraseKeyU64 (DN_DSMap<T> *map, DN_U64 key);
|
||||
template <typename T> bool DN_DSMapEraseKeyStr8 (DN_DSMap<T> *map, DN_Str8 key);
|
||||
template <typename T> DN_DSMapKey DN_DSMapKeyBuffer (DN_DSMap<T> const *map, void const *data, DN_U32 size);
|
||||
template <typename T> DN_DSMapKey DN_DSMapKeyBufferAsU64NoHash (DN_DSMap<T> const *map, void const *data, DN_U32 size);
|
||||
template <typename T> DN_DSMapKey DN_DSMapKeyU64 (DN_DSMap<T> const *map, DN_U64 u64);
|
||||
template <typename T> DN_DSMapKey DN_DSMapKeyStr8 (DN_DSMap<T> const *map, DN_Str8 string);
|
||||
#define DN_DSMapKeyCStr8(map, string) DN_DSMapKeyBuffer(map, string, sizeof((string))/sizeof((string)[0]) - 1)
|
||||
DN_API DN_DSMapKey DN_DSMapKeyU64NoHash (DN_U64 u64);
|
||||
DN_API bool DN_DSMapKeyEquals (DN_DSMapKey lhs, DN_DSMapKey rhs);
|
||||
DN_API bool operator== (DN_DSMapKey lhs, DN_DSMapKey rhs);
|
||||
#endif // !defined(DN_CONTAINER_H)
|
||||
|
||||
@@ -15,12 +15,9 @@ DN_API void DN_LeakTrackAlloc_(DN_LeakTracker *leak, void *ptr, DN_USize size, b
|
||||
DN_TicketMutex_End(&leak->alloc_table_mutex);
|
||||
};
|
||||
|
||||
// NOTE: If the entry was not added, we are reusing a pointer that has been freed.
|
||||
// TODO: Add API for always making the item but exposing a var to indicate if the item was newly created or it
|
||||
// already existed.
|
||||
DN_Str8 stack_trace = DN_StackTraceWalkStr8FromHeap(128, 3 /*skip*/);
|
||||
DN_DSMap<DN_LeakAlloc> *alloc_table = &leak->alloc_table;
|
||||
DN_DSMapResult<DN_LeakAlloc> alloc_entry = DN_DSMap_MakeKeyU64(alloc_table, DN_Cast(DN_U64) ptr);
|
||||
DN_DSMapResult<DN_LeakAlloc> alloc_entry = DN_DSMapMakeKeyU64(alloc_table, DN_Cast(DN_U64) ptr);
|
||||
DN_LeakAlloc *alloc = alloc_entry.value;
|
||||
if (alloc_entry.found) {
|
||||
if ((alloc->flags & DN_LeakAllocFlag_Freed) == 0) {
|
||||
@@ -76,7 +73,7 @@ DN_API void DN_LeakTrackDealloc_(DN_LeakTracker *leak, void *ptr)
|
||||
|
||||
DN_Str8 stack_trace = DN_StackTraceWalkStr8FromHeap(128, 3 /*skip*/);
|
||||
DN_DSMap<DN_LeakAlloc> *alloc_table = &leak->alloc_table;
|
||||
DN_DSMapResult<DN_LeakAlloc> alloc_entry = DN_DSMap_FindKeyU64(alloc_table, DN_Cast(uintptr_t) ptr);
|
||||
DN_DSMapResult<DN_LeakAlloc> alloc_entry = DN_DSMapFindKeyU64(alloc_table, DN_Cast(uintptr_t) ptr);
|
||||
DN_HardAssertF(alloc_entry.found,
|
||||
"Allocated pointer can not be removed as it does not exist in the "
|
||||
"allocation table. When this memory was allocated, the pointer was "
|
||||
@@ -128,7 +125,7 @@ DN_API void DN_LeakDump_(DN_LeakTracker *leak)
|
||||
leaked_bytes += alloc->size;
|
||||
leak_count++;
|
||||
DN_Str8x32 alloc_size = DN_ByteCountStr8x32(alloc->size);
|
||||
DN_LOG_WarningF(
|
||||
DN_LogWarningF(
|
||||
"Pointer (0x%p) leaked %.*s at:\n"
|
||||
"%.*s",
|
||||
alloc->ptr,
|
||||
@@ -139,6 +136,6 @@ DN_API void DN_LeakDump_(DN_LeakTracker *leak)
|
||||
|
||||
if (leak_count) {
|
||||
DN_Str8x32 leak_size = DN_ByteCountStr8x32(leaked_bytes);
|
||||
DN_LOG_WarningF("There were %I64u leaked allocations totalling %.*s", leak_count, DN_Str8PrintFmt(leak_size));
|
||||
DN_LogWarningF("There were %I64u leaked allocations totalling %.*s", leak_count, DN_Str8PrintFmt(leak_size));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
#define DN_BASE_LEAK_H
|
||||
|
||||
#if defined(_CLANGD)
|
||||
#include "../dn_base_inc.h"
|
||||
#include "../dn.h"
|
||||
#endif
|
||||
|
||||
enum DN_LeakAllocFlag
|
||||
|
||||
@@ -1,130 +0,0 @@
|
||||
#define DN_BASE_LOG_CPP
|
||||
|
||||
#if defined(_CLANDG)
|
||||
#include "../dn.h"
|
||||
#endif
|
||||
|
||||
static DN_LOGEmitFromTypeFVFunc *g_dn_base_log_emit_from_type_fv_func_;
|
||||
static void *g_dn_base_log_emit_from_type_fv_user_context_;
|
||||
|
||||
DN_API DN_Str8 DN_LOG_ColourEscapeCodeStr8FromRGB(DN_LOGColourType colour, DN_U8 r, DN_U8 g, DN_U8 b)
|
||||
{
|
||||
DN_THREAD_LOCAL char buffer[32];
|
||||
buffer[0] = 0;
|
||||
DN_Str8 result = {};
|
||||
result.size = DN_SNPrintF(buffer,
|
||||
DN_ArrayCountU(buffer),
|
||||
"\x1b[%d;2;%u;%u;%um",
|
||||
colour == DN_LOGColourType_Fg ? 38 : 48,
|
||||
r,
|
||||
g,
|
||||
b);
|
||||
result.data = buffer;
|
||||
return result;
|
||||
}
|
||||
|
||||
DN_API DN_Str8 DN_LOG_ColourEscapeCodeStr8FromU32(DN_LOGColourType colour, DN_U32 value)
|
||||
{
|
||||
DN_U8 r = DN_Cast(DN_U8)(value >> 24);
|
||||
DN_U8 g = DN_Cast(DN_U8)(value >> 16);
|
||||
DN_U8 b = DN_Cast(DN_U8)(value >> 8);
|
||||
DN_Str8 result = DN_LOG_ColourEscapeCodeStr8FromRGB(colour, r, g, b);
|
||||
return result;
|
||||
}
|
||||
|
||||
DN_API DN_LOGPrefixSize DN_LOG_MakePrefix(DN_LOGStyle style, DN_LOGTypeParam type, DN_CallSite call_site, DN_LOGDate date, char *dest, DN_USize dest_size)
|
||||
{
|
||||
DN_Str8 type_str8 = type.str8;
|
||||
if (type.is_u32_enum) {
|
||||
switch (type.u32) {
|
||||
case DN_LOGType_Debug: type_str8 = DN_Str8Lit("DEBUG"); break;
|
||||
case DN_LOGType_Info: type_str8 = DN_Str8Lit("INFO "); break;
|
||||
case DN_LOGType_Warning: type_str8 = DN_Str8Lit("WARN"); break;
|
||||
case DN_LOGType_Error: type_str8 = DN_Str8Lit("ERROR"); break;
|
||||
case DN_LOGType_Count: type_str8 = DN_Str8Lit("BADXX"); break;
|
||||
}
|
||||
}
|
||||
|
||||
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);
|
||||
|
||||
DN_Str8 colour_esc = {};
|
||||
DN_Str8 bold_esc = {};
|
||||
DN_Str8 reset_esc = {};
|
||||
if (style.colour) {
|
||||
bold_esc = DN_Str8Lit(DN_LOG_BoldEscapeCode);
|
||||
reset_esc = DN_Str8Lit(DN_LOG_ResetEscapeCode);
|
||||
colour_esc = DN_LOG_ColourEscapeCodeStr8FromRGB(DN_LOGColourType_Fg, style.r, style.g, style.b);
|
||||
}
|
||||
|
||||
DN_Str8 file_name = DN_Str8FileNameFromPath(call_site.file);
|
||||
DN_GCC_WARNING_PUSH
|
||||
DN_GCC_WARNING_DISABLE(-Wformat)
|
||||
DN_GCC_WARNING_DISABLE(-Wformat-extra-args)
|
||||
DN_MSVC_WARNING_PUSH
|
||||
DN_MSVC_WARNING_DISABLE(4477)
|
||||
int size = DN_SNPrintF(dest,
|
||||
DN_Cast(int)dest_size,
|
||||
"%04u-%02u-%02uT%02u:%02u:%02u" // date
|
||||
"%S" // colour
|
||||
"%S" // bold
|
||||
" %S" // type
|
||||
"%.*s" // type padding
|
||||
"%S" // reset
|
||||
" %S" // file name
|
||||
":%05I32u " // line number
|
||||
,
|
||||
date.year,
|
||||
date.month,
|
||||
date.day,
|
||||
date.hour,
|
||||
date.minute,
|
||||
date.second,
|
||||
colour_esc, // colour
|
||||
bold_esc, // bold
|
||||
type_str8, // type
|
||||
DN_Cast(int) type_padding,
|
||||
"", // type padding
|
||||
reset_esc, // reset
|
||||
file_name, // file name
|
||||
call_site.line); // line number
|
||||
DN_MSVC_WARNING_POP // '%S' requires an argument of type 'wchar_t *', but variadic argument 7 has type 'DN_Str8'
|
||||
DN_GCC_WARNING_POP
|
||||
|
||||
static DN_USize max_header_length = 0;
|
||||
DN_USize size_no_ansi_codes = size - colour_esc.size - reset_esc.size - bold_esc.size;
|
||||
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.padding = header_padding;
|
||||
return result;
|
||||
}
|
||||
|
||||
DN_API void DN_LOG_SetEmitFromTypeFVFunc(DN_LOGEmitFromTypeFVFunc *print_func, void *user_data)
|
||||
{
|
||||
g_dn_base_log_emit_from_type_fv_func_ = print_func;
|
||||
g_dn_base_log_emit_from_type_fv_user_context_ = user_data;
|
||||
}
|
||||
|
||||
DN_API void DN_LOG_EmitFromType(DN_LOGTypeParam type, DN_CallSite call_site, DN_FMT_ATTRIB char const *fmt, ...)
|
||||
{
|
||||
DN_LOGEmitFromTypeFVFunc *func = g_dn_base_log_emit_from_type_fv_func_;
|
||||
void *user_context = g_dn_base_log_emit_from_type_fv_user_context_;
|
||||
if (func) {
|
||||
va_list args;
|
||||
va_start(args, fmt);
|
||||
func(type, user_context, call_site, fmt, args);
|
||||
va_end(args);
|
||||
}
|
||||
}
|
||||
|
||||
DN_API DN_LOGTypeParam DN_LOG_MakeU32LogTypeParam(DN_LOGType type)
|
||||
{
|
||||
DN_LOGTypeParam result = {};
|
||||
result.is_u32_enum = true;
|
||||
result.u32 = type;
|
||||
return result;
|
||||
}
|
||||
@@ -1,74 +0,0 @@
|
||||
#if !defined(DN_BASE_LOG_H)
|
||||
#define DN_BASE_LOG_H
|
||||
|
||||
#if defined(_CLANGD)
|
||||
#include "../dn.h"
|
||||
#endif
|
||||
|
||||
enum DN_LOGType
|
||||
{
|
||||
DN_LOGType_Debug,
|
||||
DN_LOGType_Info,
|
||||
DN_LOGType_Warning,
|
||||
DN_LOGType_Error,
|
||||
DN_LOGType_Count,
|
||||
};
|
||||
|
||||
enum DN_LOGBold
|
||||
{
|
||||
DN_LOGBold_No,
|
||||
DN_LOGBold_Yes,
|
||||
};
|
||||
|
||||
struct DN_LOGStyle
|
||||
{
|
||||
DN_LOGBold bold;
|
||||
bool colour;
|
||||
DN_U8 r, g, b;
|
||||
};
|
||||
|
||||
struct DN_LOGTypeParam
|
||||
{
|
||||
bool is_u32_enum;
|
||||
DN_U32 u32;
|
||||
DN_Str8 str8;
|
||||
};
|
||||
|
||||
enum DN_LOGColourType
|
||||
{
|
||||
DN_LOGColourType_Fg,
|
||||
DN_LOGColourType_Bg,
|
||||
};
|
||||
|
||||
struct DN_LOGDate
|
||||
{
|
||||
DN_U16 year;
|
||||
DN_U8 month;
|
||||
DN_U8 day;
|
||||
|
||||
DN_U8 hour;
|
||||
DN_U8 minute;
|
||||
DN_U8 second;
|
||||
};
|
||||
|
||||
struct DN_LOGPrefixSize
|
||||
{
|
||||
DN_USize size;
|
||||
DN_USize padding;
|
||||
};
|
||||
|
||||
typedef void DN_LOGEmitFromTypeFVFunc(DN_LOGTypeParam type, void *user_data, DN_CallSite call_site, DN_FMT_ATTRIB char const *fmt, va_list args);
|
||||
|
||||
#define DN_LOG_ResetEscapeCode "\x1b[0m"
|
||||
#define DN_LOG_BoldEscapeCode "\x1b[1m"
|
||||
DN_API DN_Str8 DN_LOG_ColourEscapeCodeStr8FromRGB(DN_LOGColourType colour, DN_U8 r, DN_U8 g, DN_U8 b);
|
||||
DN_API DN_Str8 DN_LOG_ColourEscapeCodeStr8FromU32(DN_LOGColourType colour, DN_U32 value);
|
||||
DN_API DN_LOGPrefixSize DN_LOG_MakePrefix (DN_LOGStyle style, DN_LOGTypeParam type, DN_CallSite call_site, DN_LOGDate date, char *dest, DN_USize dest_size);
|
||||
DN_API void DN_LOG_SetEmitFromTypeFVFunc (DN_LOGEmitFromTypeFVFunc *print_func, void *user_data);
|
||||
DN_API void DN_LOG_EmitFromType (DN_LOGTypeParam type, DN_CallSite call_site, DN_FMT_ATTRIB char const *fmt, ...);
|
||||
DN_API DN_LOGTypeParam DN_LOG_MakeU32LogTypeParam (DN_LOGType type);
|
||||
#define DN_LOG_DebugF(fmt, ...) DN_LOG_EmitFromType(DN_LOG_MakeU32LogTypeParam(DN_LOGType_Debug), DN_CALL_SITE, fmt, ##__VA_ARGS__)
|
||||
#define DN_LOG_InfoF(fmt, ...) DN_LOG_EmitFromType(DN_LOG_MakeU32LogTypeParam(DN_LOGType_Info), DN_CALL_SITE, fmt, ##__VA_ARGS__)
|
||||
#define DN_LOG_WarningF(fmt, ...) DN_LOG_EmitFromType(DN_LOG_MakeU32LogTypeParam(DN_LOGType_Warning), DN_CALL_SITE, fmt, ##__VA_ARGS__)
|
||||
#define DN_LOG_ErrorF(fmt, ...) DN_LOG_EmitFromType(DN_LOG_MakeU32LogTypeParam(DN_LOGType_Error), DN_CALL_SITE, fmt, ##__VA_ARGS__)
|
||||
#endif // !defined(DN_BASE_LOG_H)
|
||||
@@ -1,60 +0,0 @@
|
||||
#if !defined(DN_BASE_OS_H)
|
||||
#define DN_BASE_OS_H
|
||||
|
||||
#if defined(_CLANGD)
|
||||
#include "../dn.h"
|
||||
#endif
|
||||
|
||||
// NOTE: OS primitives that the OS layer can provide for the base layer but is optional.
|
||||
|
||||
struct DN_StackTraceFrame
|
||||
{
|
||||
DN_U64 address;
|
||||
DN_U64 line_number;
|
||||
DN_Str8 file_name;
|
||||
DN_Str8 function_name;
|
||||
};
|
||||
|
||||
struct DN_StackTraceRawFrame
|
||||
{
|
||||
void *process;
|
||||
DN_U64 base_addr;
|
||||
};
|
||||
|
||||
struct DN_StackTraceWalkResult
|
||||
{
|
||||
void *process; // [Internal] Windows handle to the process
|
||||
DN_U64 *base_addr; // The addresses of the functions in the stack trace
|
||||
DN_U16 size; // The number of `base_addr`'s stored from the walk
|
||||
};
|
||||
|
||||
struct DN_StackTraceWalkResultIterator
|
||||
{
|
||||
DN_StackTraceRawFrame raw_frame;
|
||||
DN_U16 index;
|
||||
};
|
||||
|
||||
|
||||
#if defined(DN_FREESTANDING)
|
||||
#define DN_StackTraceWalkStr8FromHeap(...) DN_Str8Lit("N/A")
|
||||
#define DN_StackTraceWalk(...)
|
||||
#define DN_StackTraceWalkResultIterate(...)
|
||||
#define DN_StackTraceWalkResultToStr8(...) DN_Str8Lit("N/A")
|
||||
#define DN_StackTraceWalkStr8(...) DN_Str8Lit("N/A")
|
||||
#define DN_StackTraceWalkStr8FromHeap(...) DN_Str8Lit("N/A")
|
||||
#define DN_StackTraceGetFrames(...)
|
||||
#define DN_StackTraceRawFrameToFrame(...)
|
||||
#define DN_StackTracePrint(...)
|
||||
#define DN_StackTraceReloadSymbols(...)
|
||||
#else
|
||||
DN_API DN_StackTraceWalkResult DN_StackTraceWalk (struct DN_Arena *arena, DN_U16 limit);
|
||||
DN_API bool DN_StackTraceWalkResultIterate(DN_StackTraceWalkResultIterator *it, DN_StackTraceWalkResult const *walk);
|
||||
DN_API DN_Str8 DN_StackTraceWalkResultToStr8 (struct DN_Arena *arena, DN_StackTraceWalkResult const *walk, DN_U16 skip);
|
||||
DN_API DN_Str8 DN_StackTraceWalkStr8 (struct DN_Arena *arena, DN_U16 limit, DN_U16 skip);
|
||||
DN_API DN_Str8 DN_StackTraceWalkStr8FromHeap (DN_U16 limit, DN_U16 skip);
|
||||
DN_API DN_Slice<DN_StackTraceFrame> DN_StackTraceGetFrames (struct DN_Arena *arena, DN_U16 limit);
|
||||
DN_API DN_StackTraceFrame DN_StackTraceRawFrameToFrame (struct DN_Arena *arena, DN_StackTraceRawFrame raw_frame);
|
||||
DN_API void DN_StackTracePrint (DN_U16 limit);
|
||||
DN_API void DN_StackTraceReloadSymbols ();
|
||||
#endif
|
||||
#endif // !defined(DN_BASE_OS_H)
|
||||
Reference in New Issue
Block a user