From 0ab226f739a3b1cb0d1de72ddaa281717f53e6eb Mon Sep 17 00:00:00 2001 From: Ed_ Date: Wed, 12 Feb 2025 14:38:18 -0500 Subject: [PATCH] adding prefixes to source They'll be removed on demand in libgen repo --- source/base/arena.c | 158 ++-- source/base/arena.h | 158 ++-- source/base/base_types.h | 472 +++++------ source/base/command_line.c | 110 +-- source/base/command_line.h | 122 +-- source/base/context_cracking.h | 280 +++---- source/base/debug.c | 2 +- source/base/debug.h | 48 +- source/base/entry_point.c | 32 +- source/base/entry_point.h | 8 +- source/base/file.h | 16 +- source/base/generic_macros.h | 128 ++- source/base/linkage.h | 22 +- source/base/logger.c | 68 +- source/base/logger.h | 86 +- source/base/macros.h | 158 ++-- source/base/markup.c | 6 +- source/base/markup.h | 14 +- source/base/math.h | 1148 +++++++++++++------------- source/base/memory.h | 714 ++++++++--------- source/base/memory_substrate.c | 326 ++++---- source/base/memory_substrate.h | 272 +++---- source/base/platform.h | 4 +- source/base/profiling.h | 76 +- source/base/ring.h | 46 +- source/base/sort.h | 4 +- source/base/space.h | 80 +- source/base/strings.c | 1258 ++++++++++++++--------------- source/base/strings.h | 1374 ++++++++++++++++---------------- source/base/text.c | 38 +- source/base/text.h | 94 +-- source/base/thread_context.c | 70 +- source/base/thread_context.h | 96 +-- source/base/time.c | 40 +- source/base/time.h | 118 +-- source/base/toolchain.h | 134 ++-- source/mdesk/mdesk.c | 632 +++++++-------- source/mdesk/mdesk.h | 616 +++++++------- source/os/linux/os_linux.c | 730 ++++++++--------- source/os/linux/os_linux.h | 148 ++-- source/os/os.c | 83 +- source/os/os.h | 492 ++++++------ source/os/win32/os_win32.c | 972 +++++++++++----------- source/os/win32/os_win32.h | 140 ++-- third_party/stb/stb_sprintf.h | 38 +- 45 files changed, 5811 insertions(+), 5820 deletions(-) diff --git a/source/base/arena.c b/source/base/arena.c index 0f43e63..cf20681 100644 --- a/source/base/arena.c +++ b/source/base/arena.c @@ -7,82 +7,82 @@ // Licensed under the MIT license (https://opensource.org/license/mit/) //////////////////////////////// -//~ rjf: Arena Functions +//~ rjf: MD_Arena Functions //- rjf: arena creation/destruction -Arena* -arena__alloc(ArenaParams* optional_params) +MD_Arena* +md_arena__alloc(MD_ArenaParams* optional_params) { - ArenaParams params = optional_params ? *optional_params : (ArenaParams){0}; + MD_ArenaParams params = optional_params ? *optional_params : (MD_ArenaParams){0}; - SPTR const varena_header_size = align_pow2(size_of(VArena), MD_DEFAULT_MEMORY_ALIGNMENT); - SPTR const header_size = align_pow2(size_of(Arena), MD_DEFAULT_MEMORY_ALIGNMENT); + MD_SPTR const varena_header_size = md_align_pow2(size_of(MD_VArena), MD_DEFAULT_MEMORY_ALIGNMENT); + MD_SPTR const header_size = md_align_pow2(size_of(MD_Arena), MD_DEFAULT_MEMORY_ALIGNMENT); - U64 const varena_reserve_size = VARENA_DEFAULT_RESERVE; + MD_U64 const varena_reserve_size = MD_VARENA_DEFAULT_RESERVE; - B32 is_virtual = allocator_type(params.backing) & AllocatorType_VArena; - params.flags |= ArenaFlag_Virtual * is_virtual; + MD_B32 is_virtual = md_allocator_type(params.backing) & MD_AllocatorType_VArena; + params.flags |= MD_ArenaFlag_Virtual * is_virtual; - if (params.backing.proc == nullptr) params.backing = default_allocator(); - if (params.block_size == 0 ) params.block_size = ARENA_DEFAULT_BLOCK_SIZE; + if (params.backing.proc == md_nullptr) params.backing = md_default_allocator(); + if (params.block_size == 0 ) params.block_size = MD_ARENA_DEFAULT_BLOCK_SIZE; - SSIZE alloc_size = is_virtual ? header_size : params.block_size; + MD_SSIZE md_alloc_size = is_virtual ? header_size : params.block_size; - void* base = alloc(params.backing, alloc_size); + void* base = md_alloc(params.backing, md_alloc_size); // rjf: extract arena header & fill - Arena* arena = (Arena*) base; - arena->prev = nullptr; + MD_Arena* arena = (MD_Arena*) base; + arena->prev = md_nullptr; arena->current = arena; arena->backing = params.backing; arena->base_pos = 0; arena->pos = header_size; arena->block_size = params.block_size; arena->flags = params.flags; - asan_unpoison_memory_region(base, sizeof(Arena)); + md_asan_unpoison_memory_region(base, sizeof(MD_Arena)); return arena; } //- rjf: arena push/pop core functions void* -arena_push(Arena* arena, SSIZE size, SSIZE align) +md_arena_push(MD_Arena* arena, MD_SSIZE size, MD_SSIZE align) { - SPTR const header_size = align_pow2(size_of(Arena), MD_DEFAULT_MEMORY_ALIGNMENT); + MD_SPTR const header_size = md_align_pow2(size_of(MD_Arena), MD_DEFAULT_MEMORY_ALIGNMENT); - Arena* current = arena->current; - SPTR curr_sptr = scast(SPTR, current); + MD_Arena* current = arena->current; + MD_SPTR curr_sptr = md_scast(MD_SPTR, current); - SSIZE aligned_size = align_pow2(size, align); + MD_SSIZE aligned_size = md_align_pow2(size, align); - SPTR pos_pre = current->pos; - SPTR pos_pst = pos_pre + aligned_size; + MD_SPTR pos_pre = current->pos; + MD_SPTR pos_pst = pos_pre + aligned_size; - B32 is_virtual = arena->flags & ArenaFlag_Virtual; + MD_B32 is_virtual = arena->flags & MD_ArenaFlag_Virtual; // rjf: chain, if needed - if ( current->block_size < pos_pst && ! (arena->flags & ArenaFlag_NoChain) ) + if ( current->block_size < pos_pst && ! (arena->flags & MD_ArenaFlag_NoChain) ) { - Arena* new_block = nullptr; + MD_Arena* new_block = md_nullptr; - B32 vmem_chain = is_virtual && (arena->flags & ArenaFlag_NoChainVirtual); + MD_B32 vmem_chain = is_virtual && (arena->flags & MD_ArenaFlag_NoChainVirtual); if (vmem_chain) { - SPTR const varena_header_size = align_pow2(size_of(VArena), MD_DEFAULT_MEMORY_ALIGNMENT); - SPTR const arena_block_size = VARENA_DEFAULT_RESERVE - varena_header_size; + MD_SPTR const varena_header_size = md_align_pow2(size_of(MD_VArena), MD_DEFAULT_MEMORY_ALIGNMENT); + MD_SPTR const md_arena_block_size = MD_VARENA_DEFAULT_RESERVE - varena_header_size; - VArena* vcurrent = rcast(VArena*, arena->backing.data); + MD_VArena* vcurrent = md_rcast(MD_VArena*, arena->backing.data); - VArena* new_vm = varena_alloc(.reserve_size = vcurrent->reserve, .commit_size = vcurrent->commit_size); - new_block = arena_alloc(.backing = varena_allocator(new_vm), .block_size = arena_block_size); + MD_VArena* new_vm = md_varena_alloc(.reserve_size = vcurrent->reserve, .commit_size = vcurrent->commit_size); + new_block = md_arena_alloc(.backing = md_varena_allocator(new_vm), .block_size = md_arena_block_size); } else { - SPTR const arena_block_size = arena->block_size + header_size; - new_block = arena_alloc(.backing = arena->backing, .block_size = arena_block_size); + MD_SPTR const md_arena_block_size = arena->block_size + header_size; + new_block = md_arena_alloc(.backing = arena->backing, .block_size = md_arena_block_size); } new_block->base_pos = current->base_pos + current->block_size; - sll_stack_push_n(arena->current, new_block, prev); + md_sll_stack_push_n(arena->current, new_block, prev); current = new_block; pos_pre = current->pos; @@ -92,23 +92,23 @@ arena_push(Arena* arena, SSIZE size, SSIZE align) // rjf: push onto current block void* result = 0; { - result = scast(void*, curr_sptr + pos_pre); + result = md_scast(void*, curr_sptr + pos_pre); current->pos = pos_pst; - asan_unpoison_memory_region(result, size); + md_asan_unpoison_memory_region(result, size); } if (is_virtual) { // Sync virtual arena - void* vresult = alloc_align(arena->backing, size, align); - assert(vresult == result); + void* vresult = md_alloc_align(arena->backing, size, align); + md_assert(vresult == result); } // rjf: panic on failure - #if OS_FEATURE_GRAPHICAL - if(unlikely(result == 0)) + #if MD_OS_FEATURE_GRAPHICAL + if(md_unlikely(result == 0)) { - os_graphical_message(1, str8_lit("Fatal Allocation Failure"), str8_lit("Unexpected memory allocation failure.")); - os_abort(1); + md_os_graphical_message(1, md_str8_lit("Fatal Allocation Failure"), md_str8_lit("Unexpected memory allocation failure.")); + md_os_abort(1); } #endif @@ -116,77 +116,77 @@ arena_push(Arena* arena, SSIZE size, SSIZE align) } void -arena_pop_to(Arena *arena, SSIZE pos) +md_arena_pop_to(MD_Arena *arena, MD_SSIZE pos) { - SPTR const header_size = align_pow2(size_of(Arena), MD_DEFAULT_MEMORY_ALIGNMENT); + MD_SPTR const header_size = md_align_pow2(size_of(MD_Arena), MD_DEFAULT_MEMORY_ALIGNMENT); - Arena* current = arena->current; - AllocatorInfo backing = current->backing; - B32 is_virtual = allocator_type(backing) & AllocatorType_VArena; + MD_Arena* current = arena->current; + MD_AllocatorInfo backing = current->backing; + MD_B32 is_virtual = md_allocator_type(backing) & MD_AllocatorType_VArena; - SSIZE big_pos = clamp_bot(header_size, pos); + MD_SSIZE big_pos = md_clamp_bot(header_size, pos); // If base position is larger than the position to pop to: // We are in a previous arena and msut free the current - for(Arena* prev = 0; current->base_pos >= big_pos; current = prev) + for(MD_Arena* prev = 0; current->base_pos >= big_pos; current = prev) { prev = current->prev; if (is_virtual) { - varena_release(rcast(VArena*, current->backing.data)); + md_varena_release(md_rcast(MD_VArena*, current->backing.data)); } - else if (allocator_query_support(backing) & AllocatorQuery_Free) { - alloc_free(current->backing, current); + else if (md_allocator_query_support(backing) & MD_AllocatorQuery_Free) { + md_alloc_free(current->backing, current); } } arena->current = current; - SSIZE new_pos = big_pos - current->base_pos; - assert_always(new_pos <= current->pos); - asan_poison_memory_region((U8*)current + new_pos, (current->pos - new_pos)); + MD_SSIZE new_pos = big_pos - current->base_pos; + md_assert_always(new_pos <= current->pos); + md_asan_poison_memory_region((MD_U8*)current + new_pos, (current->pos - new_pos)); current->pos = new_pos; if (is_virtual) { - varena_rewind(rcast(VArena*, current->backing.data), current->pos); + varena_rewind(md_rcast(MD_VArena*, current->backing.data), current->pos); } } -void* arena_allocator_proc(void* allocator_data, AllocatorMode mode, SSIZE size, SSIZE alignment, void* old_memory, SSIZE old_size, U64 flags) +void* md_arena_allocator_proc(void* allocator_data, MD_AllocatorMode mode, MD_SSIZE size, MD_SSIZE alignment, void* old_memory, MD_SSIZE old_size, MD_U64 flags) { - Arena* arena = rcast(Arena*, allocator_data); + MD_Arena* arena = md_rcast(MD_Arena*, allocator_data); - void* allocated_ptr = nullptr; + void* allocated_ptr = md_nullptr; switch (mode) { - case AllocatorMode_Alloc: + case MD_AllocatorMode_Alloc: { - allocated_ptr = arena_push(arena, size, alignment); + allocated_ptr = md_arena_push(arena, size, alignment); } break; - case AllocatorMode_Free: + case MD_AllocatorMode_Free: { } break; - case AllocatorMode_FreeAll: + case MD_AllocatorMode_FreeAll: { - arena_release(arena); + md_arena_release(arena); } break; - case AllocatorMode_Resize: + case MD_AllocatorMode_Resize: { - assert(old_memory != nullptr); - assert(old_size > 0); - assert_msg(old_size == size, "Requested resize when none needed"); + md_assert(old_memory != md_nullptr); + md_assert(old_size > 0); + md_assert_msg(old_size == size, "Requested md_resize when none needed"); - size = align_pow2(size, alignment); - old_size = align_pow2(size, alignment); + size = md_align_pow2(size, alignment); + old_size = md_align_pow2(size, alignment); - SPTR old_memory_offset = scast(SPTR, old_memory) + old_size; - SPTR current_offset = arena->pos; + MD_SPTR old_memory_offset = md_scast(MD_SPTR, old_memory) + old_size; + MD_SPTR current_offset = arena->pos; - assert_msg(old_memory_offset == current_offset, "Cannot resize existing allocation in VArena unless it was the last allocated"); + md_assert_msg(old_memory_offset == current_offset, "Cannot md_resize existing allocation in MD_VArena unless it was the last allocated"); - B32 requested_shrink = size >= old_size; + MD_B32 requested_shrink = size >= old_size; if (requested_shrink) { arena->pos -= size; allocated_ptr = old_memory; @@ -198,15 +198,15 @@ void* arena_allocator_proc(void* allocator_data, AllocatorMode mode, SSIZE size, } break; - case AllocatorMode_QueryType: + case MD_AllocatorMode_QueryType: { - return (void*) AllocatorType_Arena; + return (void*) MD_AllocatorType_Arena; } break; - case AllocatorMode_QuerySupport: + case MD_AllocatorMode_QuerySupport: { - return (void*) (AllocatorQuery_Alloc | AllocatorQuery_Resize | AllocatorQuery_FreeAll); + return (void*) (MD_AllocatorQuery_Alloc | MD_AllocatorQuery_Resize | MD_AllocatorQuery_FreeAll); } break; } diff --git a/source/base/arena.h b/source/base/arena.h index d613830..deb0b2c 100644 --- a/source/base/arena.h +++ b/source/base/arena.h @@ -11,27 +11,27 @@ //////////////////////////////// //~ rjf: Types -typedef U32 ArenaFlags; +typedef MD_U32 MD_ArenaFlags; enum { // Don't chain this arena - ArenaFlag_NoChain = (1 << 0), - // Only relevant if backing is virtual memory, will prevent allocating a new backing VArena when the current block exhausts - // Will assume backing can chain multiple block_size arenas however. If there is an allocation failure it will assert. - ArenaFlag_NoChainVirtual = (1 << 1), - // Backing allocator identified as VArena during initialization - ArenaFlag_Virtual = (1 << 2), + MD_ArenaFlag_NoChain = (1 << 0), + // Only relevant if backing is virtual memory, will prevent allocating a new backing MD_VArena when the current block exhausts + // Will assume backing can chain multiple block_size arenas however. If there is an allocation failure it will md_assert. + MD_ArenaFlag_NoChainVirtual = (1 << 1), + // Backing allocator identified as MD_VArena during initialization + MD_ArenaFlag_Virtual = (1 << 2), }; -typedef struct ArenaParams ArenaParams; -struct ArenaParams +typedef struct MD_ArenaParams MD_ArenaParams; +struct MD_ArenaParams { - AllocatorInfo backing; - ArenaFlags flags; - U64 block_size; // If chaining VArenas set this to the reserve size + MD_AllocatorInfo backing; + MD_ArenaFlags flags; + MD_U64 block_size; // If chaining VArenas set this to the reserve size }; -#define ARENA_DEFAULT_BLOCK_SIZE VARENA_DEFAULT_RESERVE - align_pow2(size_of(VArena), MD_DEFAULT_MEMORY_ALIGNMENT) +#define MD_ARENA_DEFAULT_BLOCK_SIZE MD_VARENA_DEFAULT_RESERVE - md_align_pow2(size_of(MD_VArena), MD_DEFAULT_MEMORY_ALIGNMENT) /* NOTE(Ed): The original metadesk arena is a combination of several concepts into a single interface * An OS virtual memory allocation scheme @@ -40,136 +40,136 @@ struct ArenaParams The virtual memory has been abstracted into a backing allocator, and chaining still supports reserving new virtual address regions . - (can be disabled with ArenaFlag_NoChainVirtual) + (can be disabled with MD_ArenaFlag_NoChainVirtual) - If large pages are desired, see VArena. + If large pages are desired, see MD_VArena. */ -typedef struct Arena Arena; -struct Arena +typedef struct MD_Arena MD_Arena; +struct MD_Arena { - Arena* prev; // Previous arena in chain - Arena* current; // Current arena in chain - AllocatorInfo backing; - SSIZE base_pos; // Tracks how main arenas have been chained - SSIZE pos; - SSIZE block_size; - ArenaFlags flags; + MD_Arena* prev; // Previous arena in chain + MD_Arena* current; // Current arena in chain + MD_AllocatorInfo backing; + MD_SSIZE base_pos; // Tracks how main arenas have been chained + MD_SSIZE pos; + MD_SSIZE block_size; + MD_ArenaFlags flags; }; -// static_assert(size_of(Arena) <= ARENA_HEADER_SIZE, "sizeof(Arena) <= ARENA_HEADER_SIZE"); +// static_assert(size_of(MD_Arena) <= ARENA_HEADER_SIZE, "sizeof(MD_Arena) <= ARENA_HEADER_SIZE"); -typedef struct TempArena TempArena; -struct TempArena +typedef struct MD_TempArena MD_TempArena; +struct MD_TempArena { - Arena* arena; - SSIZE pos; + MD_Arena* arena; + MD_SSIZE pos; }; //////////////////////////////// -//~ rjf: Arena Functions +//~ rjf: MD_Arena Functions -MD_API void* arena_allocator_proc(void* allocator_data, AllocatorMode mode, SSIZE size, SSIZE alignment, void* old_memory, SSIZE old_size, U64 flags); +MD_API void* md_arena_allocator_proc(void* allocator_data, MD_AllocatorMode mode, MD_SSIZE size, MD_SSIZE alignment, void* old_memory, MD_SSIZE old_size, MD_U64 flags); -force_inline AllocatorInfo arena_allocator(Arena* arena) { AllocatorInfo info = { arena_allocator_proc, arena}; return info; } +md_force_inline MD_AllocatorInfo md_arena_allocator(MD_Arena* arena) { MD_AllocatorInfo info = { md_arena_allocator_proc, arena}; return info; } -// Useful for providing an arena to scratch_begin_alloc -force_inline Arena* -extract_arena(AllocatorInfo ainfo) { - if (allocator_type(ainfo) == AllocatorType_Arena) { - return (Arena*) ainfo.data; +// Useful for providing an arena to md_scratch_begin_alloc +md_force_inline MD_Arena* +md_extract_arena(MD_AllocatorInfo ainfo) { + if (md_allocator_type(ainfo) == MD_AllocatorType_Arena) { + return (MD_Arena*) ainfo.data; } - return nullptr; + return md_nullptr; } //- rjf: arena creation/destruction -MD_API Arena* arena__alloc(ArenaParams* params); -#define arena_alloc(...) arena__alloc( &(ArenaParams){ __VA_ARGS__ } ) +MD_API MD_Arena* md_arena__alloc(MD_ArenaParams* params); +#define md_arena_alloc(...) md_arena__alloc( &(MD_ArenaParams){ __VA_ARGS__ } ) -void arena_release(Arena *arena); +void md_arena_release(MD_Arena *arena); //- rjf: arena push/pop/pos core functions -MD_API void* arena_push (Arena* arena, SSIZE size, SSIZE align); - U64 arena_pos (Arena* arena); -MD_API void arena_pop_to(Arena* arena, SSIZE pos); +MD_API void* md_arena_push (MD_Arena* arena, MD_SSIZE size, MD_SSIZE align); + MD_U64 md_arena_pos (MD_Arena* arena); +MD_API void md_arena_pop_to(MD_Arena* arena, MD_SSIZE pos); //- rjf: arena push/pop helpers -void arena_clear(Arena* arena); -void arena_pop (Arena* arena, SSIZE amt); +void md_arena_clear(MD_Arena* arena); +void md_arena_pop (MD_Arena* arena, MD_SSIZE amt); //- rjf: temporary arena scopes -TempArena temp_arena_begin(Arena* arena); -void temp_arena_end(TempArena temp); +MD_TempArena temp_arena_begin(MD_Arena* arena); +void temp_arena_end(MD_TempArena temp); //- rjf: push helper macros -#ifndef push_array -#define push_array_no_zero_aligned(a, T, c, align) (T *)arena_push((a), sizeof(T) * (c), (align)) -#define push_array_aligned(a, T, c, align) (T *)memory_zero(push_array_no_zero_aligned(a, T, c, align), sizeof(T) * (c)) -#define push_array_no_zero(a, T, c) push_array_no_zero_aligned(a, T, c, max(8, align_of(T))) -#define push_array(a, T, c) push_array_aligned (a, T, c, max(8, align_of(T))) +#ifndef md_push_array_ +#define md_push_array__no_zero_aligned(a, T, c, align) (T *)md_arena_push((a), sizeof(T) * (c), (align)) +#define md_push_array__aligned(a, T, c, align) (T *)md_memory_zero(md_push_array__no_zero_aligned(a, T, c, align), sizeof(T) * (c)) +#define md_push_array__no_zero(a, T, c) md_push_array__no_zero_aligned(a, T, c, md_max(8, md_align_of(T))) +#define md_push_array_(a, T, c) md_push_array__aligned (a, T, c, md_max(8, md_align_of(T))) #endif // Inlines inline void -arena_release(Arena* arena) { - for (Arena* n = arena->current, *prev = 0; n != 0; n = prev) { +md_arena_release(MD_Arena* arena) { + for (MD_Arena* n = arena->current, *prev = 0; n != 0; n = prev) { prev = n->prev; - alloc_free(arena->backing, n); + md_alloc_free(arena->backing, n); } } -inline U64 -arena_pos(Arena *arena) { - Arena* current = arena->current; - U64 pos = current->base_pos + current->pos; +inline MD_U64 +md_arena_pos(MD_Arena *arena) { + MD_Arena* current = arena->current; + MD_U64 pos = current->base_pos + current->pos; return pos; } //- rjf: arena push/pop helpers -force_inline void arena_clear(Arena* arena) { arena_pop_to(arena, 0); } +md_force_inline void md_arena_clear(MD_Arena* arena) { md_arena_pop_to(arena, 0); } inline void -arena_pop(Arena* arena, SSIZE amt) { - SSIZE pos_old = arena_pos(arena); - SSIZE pos_new = pos_old; +md_arena_pop(MD_Arena* arena, MD_SSIZE amt) { + MD_SSIZE pos_old = md_arena_pos(arena); + MD_SSIZE pos_new = pos_old; if (amt < pos_old) { pos_new = pos_old - amt; } - arena_pop_to(arena, pos_new); + md_arena_pop_to(arena, pos_new); } //- rjf: temporary arena scopes -inline TempArena -temp_begin(Arena* arena) { - U64 pos = arena_pos(arena); - TempArena temp = {arena, pos}; +inline MD_TempArena +md_temp_begin(MD_Arena* arena) { + MD_U64 pos = md_arena_pos(arena); + MD_TempArena temp = {arena, pos}; return temp; } -force_inline void temp_end(TempArena temp) { arena_pop_to(temp.arena, temp.pos); } +md_force_inline void md_temp_end(MD_TempArena temp) { md_arena_pop_to(temp.arena, temp.pos); } // ======================================== DEFAULT_ALLOCATOR ===================================================== #ifndef MD_OVERRIDE_DEFAULT_ALLOCATOR -// The default allocator for this base module is the Arena allocator with a VArena backing -// NOTE(Ed): In order for this to work, either the os entry_point must have been utilized or os_init needs to be called. -inline AllocatorInfo -default_allocator() +// The default allocator for this base module is the MD_Arena allocator with a MD_VArena backing +// NOTE(Ed): In order for this to work, either the os md_entry_point must have been utilized or md_os_init needs to be called. +inline MD_AllocatorInfo +md_default_allocator() { - local_persist thread_local Arena* arena = nullptr; - if (arena == nullptr) { - VArena* backing_vmem = varena_alloc(.flags = 0, .base_addr = 0x0, .reserve_size = VARENA_DEFAULT_RESERVE, .commit_size = VARENA_DEFAULT_COMMIT); - arena = arena_alloc(.backing = varena_allocator(backing_vmem), .block_size = VARENA_DEFAULT_RESERVE); + md_local_persist md_thread_local MD_Arena* arena = md_nullptr; + if (arena == md_nullptr) { + MD_VArena* backing_vmem = md_varena_alloc(.flags = 0, .base_addr = 0x0, .reserve_size = MD_VARENA_DEFAULT_RESERVE, .commit_size = MD_VARENA_DEFAULT_COMMIT); + arena = md_arena_alloc(.backing = md_varena_allocator(backing_vmem), .block_size = MD_VARENA_DEFAULT_RESERVE); } - AllocatorInfo info = { arena_allocator_proc, arena }; + MD_AllocatorInfo info = { md_arena_allocator_proc, arena }; return info; } #endif diff --git a/source/base/base_types.h b/source/base/base_types.h index d1d159e..c5d5019 100644 --- a/source/base/base_types.h +++ b/source/base/base_types.h @@ -7,65 +7,65 @@ # include "platform.h" #endif -#if defined( COMPILER_MSVC ) +#if defined( MD_COMPILER_MSVC ) # if _MSC_VER < 1300 -typedef unsigned char, U8; -typedef signed char, S8; -typedef unsigned short, U16; -typedef signed short, S16; -typedef unsigned int, U32; -typedef signed int, S32; +typedef unsigned char, MD_U8; +typedef signed char, MD_S8; +typedef unsigned short, MD_U16; +typedef signed short, MD_S16; +typedef unsigned int, MD_U32; +typedef signed int, MD_S32; # else -typedef unsigned __int8 U8; -typedef signed __int8 S8; -typedef unsigned __int16 U16; -typedef signed __int16 S16; -typedef unsigned __int32 U32; -typedef signed __int32 S32; +typedef unsigned __int8 MD_U8; +typedef signed __int8 MD_S8; +typedef unsigned __int16 MD_U16; +typedef signed __int16 MD_S16; +typedef unsigned __int32 MD_U32; +typedef signed __int32 MD_S32; # endif -typedef unsigned __int64 U64; -typedef signed __int64 S64; +typedef unsigned __int64 MD_U64; +typedef signed __int64 MD_S64; #else # include -typedef uint8_t, U8; -typedef int8_t, S8; -typedef uint16_t, U16; -typedef int16_t, S16; -typedef uint32_t, U32; -typedef int32_t, S32; -typedef uint64_t, U64; -typedef int64_t, S64; +typedef uint8_t, MD_U8; +typedef int8_t, MD_S8; +typedef uint16_t, MD_U16; +typedef int16_t, MD_S16; +typedef uint32_t, MD_U32; +typedef int32_t, MD_S32; +typedef uint64_t, MD_U64; +typedef int64_t, MD_S64; #endif typedef struct U128 U128; struct U128 { - U64 data[2]; + MD_U64 data[2]; }; -static_assert( sizeof( U8 ) == sizeof( S8 ), "sizeof(U8) != sizeof(S8)" ); -static_assert( sizeof( U16 ) == sizeof( S16 ), "sizeof(U16) != sizeof(sS6)" ); -static_assert( sizeof( U32 ) == sizeof( S32 ), "sizeof(U32) != sizeof(sS2)" ); -static_assert( sizeof( U64 ) == sizeof( S64 ), "sizeof(U64) != sizeof(sS4)" ); +static_assert( sizeof( MD_U8 ) == sizeof( MD_S8 ), "sizeof(MD_U8) != sizeof(MD_S8)" ); +static_assert( sizeof( MD_U16 ) == sizeof( MD_S16 ), "sizeof(MD_U16) != sizeof(sS6)" ); +static_assert( sizeof( MD_U32 ) == sizeof( MD_S32 ), "sizeof(MD_U32) != sizeof(sS2)" ); +static_assert( sizeof( MD_U64 ) == sizeof( MD_S64 ), "sizeof(MD_U64) != sizeof(sS4)" ); -static_assert( sizeof( U8 ) == 1, "sizeof(U8) != 1" ); -static_assert( sizeof( U16 ) == 2, "sizeof(U16) != 2" ); -static_assert( sizeof( U32 ) == 4, "sizeof(U32) != 4" ); -static_assert( sizeof( U64 ) == 8, "sizeof(U64) != 8" ); +static_assert( sizeof( MD_U8 ) == 1, "sizeof(MD_U8) != 1" ); +static_assert( sizeof( MD_U16 ) == 2, "sizeof(MD_U16) != 2" ); +static_assert( sizeof( MD_U32 ) == 4, "sizeof(MD_U32) != 4" ); +static_assert( sizeof( MD_U64 ) == 8, "sizeof(MD_U64) != 8" ); -typedef size_t USIZE; -typedef ptrdiff_t SSIZE; +typedef size_t MD_USIZE; +typedef ptrdiff_t MD_SSIZE; -static_assert( sizeof( USIZE ) == sizeof( SSIZE ), "sizeof(USIZE) != sizeof(SSIZE)" ); +static_assert( sizeof( MD_USIZE ) == sizeof( MD_SSIZE ), "sizeof(MD_USIZE) != sizeof(MD_SSIZE)" ); #ifndef size_of -#define size_of( x ) ( SSIZE )( sizeof( x ) ) +#define size_of( x ) ( MD_SSIZE )( sizeof( x ) ) #endif // NOTE: (u)zpl_intptr is only here for semantic reasons really as this library will only support 32/64 bit OSes. #if defined( _WIN64 ) -typedef signed __int64 SPTR; -typedef unsigned __int64 UPTR; +typedef signed __int64 MD_SPTR; +typedef unsigned __int64 MD_UPTR; #elif defined( _WIN32 ) // NOTE; To mark types changing their size, e.g. zpl_intptr # ifndef _W64 @@ -75,254 +75,254 @@ typedef unsigned __int64 UPTR; # define _W64 # endif # endif -typedef _W64 signed int SPTR; -typedef _W64 unsigned int UPTR; +typedef _W64 signed int MD_SPTR; +typedef _W64 unsigned int MD_UPTR; #else -typedef uintptr_t UPTR; -typedef intptr_t SPTR; +typedef uintptr_t MD_UPTR; +typedef intptr_t MD_SPTR; #endif -static_assert( sizeof( UPTR ) == sizeof( SPTR ), "sizeof(UPTR) != sizeof(SPTR)" ); +static_assert( sizeof( MD_UPTR ) == sizeof( MD_SPTR ), "sizeof(MD_UPTR) != sizeof(MD_SPTR)" ); -typedef float F32; -typedef double F64; +typedef float MD_F32; +typedef double MD_F64; -static_assert( sizeof( F32 ) == 4, "sizeof(F32) != 4" ); -static_assert( sizeof( F64 ) == 8, "sizeof(F64) != 8" ); +static_assert( sizeof( MD_F32 ) == 4, "sizeof(MD_F32) != 4" ); +static_assert( sizeof( MD_F64 ) == 8, "sizeof(MD_F64) != 8" ); -typedef S8 B8; -typedef S16 B16; -typedef S32 B32; +typedef MD_S8 MD_B8; +typedef MD_S16 MD_B16; +typedef MD_S32 MD_B32; -typedef void VoidProc(void); -distinct_register_selector(VoidProc); +typedef void MD_VoidProc(void); +md_distinct_register_selector(MD_VoidProc); //////////////////////////////// //~ NOTE(allen): Constants -#define SIGN32 0x80000000 -#define EXPONENT32 0x7F800000 -#define MANTISSA32 0x007FFFFF +#define MD_SIGN32 0x80000000 +#define MD_EXPONENT32 0x7F800000 +#define MD_MANTISSA32 0x007FFFFF -#define BIG_GOLDEN32 1.61803398875f -#define SMALL_GOLDEN32 0.61803398875f +#define MD_BIG_GOLDEN32 1.61803398875f +#define MD_SMALL_GOLDEN32 0.61803398875f -#define PI32 3.1415926535897f +#define MD_PI32 3.1415926535897f -#define MACHINE_EPSILON64 4.94065645841247e-324 +#define MD_MACHINE_EPSILON64 4.94065645841247e-324 -#define MIN_U8 0u -#define MAX_U8 0xffu -#define MIN_S8 ( -0x7f - 1 ) -#define MAX_S8 0x7f +#define MD_MIN_U8 0u +#define MD_MAX_U8 0xffu +#define MD_MIN_S8 ( -0x7f - 1 ) +#define MD_MAX_S8 0x7f -#define MIN_U16 0u -#define MAX_U16 0xffffu -#define MIN_S16 ( -0x7fff - 1 ) -#define MAX_S16 0x7fff +#define MD_MIN_U16 0u +#define MD_MAX_U16 0xffffu +#define MD_MIN_S16 ( -0x7fff - 1 ) +#define MD_MAX_S16 0x7fff -#define MIN_U32 0u -#define MAX_U32 0xffffffffu -#define MIN_S32 ( -0x7fffffff - 1 ) -#define MAX_S32 0x7fffffff +#define MD_MIN_U32 0u +#define MD_MAX_U32 0xffffffffu +#define MD_MIN_S32 ( -0x7fffffff - 1 ) +#define MD_MAX_S32 0x7fffffff -#define MIN_U64 0ull -#define MAX_U64 0xffffffffffffffffull -#define MIN_S64 ( -0x7fffffffffffffffll - 1 ) -#define MAX_S64 0x7fffffffffffffffll +#define MD_MIN_U64 0ull +#define MD_MAX_U64 0xffffffffffffffffull +#define MD_MIN_S64 ( -0x7fffffffffffffffll - 1 ) +#define MD_MAX_S64 0x7fffffffffffffffll -#if ARCH_32BIT -# define MIN_USIZE U32_MIN -# define MAX_USIZE U32_MAX +#if MD_ARCH_32BIT +# define MD_MIN_USIZE U32_MIN +# define MD_MAX_USIZE U32_MAX # define MIN_SSIZE S32_MIN # define MAX_SSIZE S32_MAX -#elif ARCH_64BIT -# define MIN_USIZE U64_MIN -# define MAX_USIZE U64_MAX +#elif MD_ARCH_64BIT +# define MD_MIN_USIZE U64_MIN +# define MD_MAX_USIZE U64_MAX # define MIN_SSIZE S64_MIN # define MAX_SSIZE S64_MAX #else # error Unknown architecture size. This library only supports 32 bit and 64 bit architectures. #endif -#define MIN_F32 1.17549435e-38f -#define MAX_F32 3.40282347e+38f -#define MIN_F64 2.2250738585072014e-308 -#define MAX_F64 1.7976931348623157e+308 +#define MD_MIN_F32 1.17549435e-38f +#define MD_MAX_F32 3.40282347e+38f +#define MD_MIN_F64 2.2250738585072014e-308 +#define MD_MAX_F64 1.7976931348623157e+308 -#define BITMASK1 0x00000001 -#define BITMASK2 0x00000003 -#define BITMASK3 0x00000007 -#define BITMASK4 0x0000000f -#define BITMASK5 0x0000001f -#define BITMASK6 0x0000003f -#define BITMASK7 0x0000007f -#define BITMASK8 0x000000ff -#define BITMASK9 0x000001ff -#define BITMASK10 0x000003ff -#define BITMASK11 0x000007ff -#define BITMASK12 0x00000fff -#define BITMASK13 0x00001fff -#define BITMASK14 0x00003fff -#define BITMASK15 0x00007fff -#define BITMASK16 0x0000ffff -#define BITMASK17 0x0001ffff -#define BITMASK18 0x0003ffff -#define BITMASK19 0x0007ffff -#define BITMASK20 0x000fffff -#define BITMASK21 0x001fffff -#define BITMASK22 0x003fffff -#define BITMASK23 0x007fffff -#define BITMASK24 0x00ffffff -#define BITMASK25 0x01ffffff -#define BITMASK26 0x03ffffff -#define BITMASK27 0x07ffffff -#define BITMASK28 0x0fffffff -#define BITMASK29 0x1fffffff -#define BITMASK30 0x3fffffff -#define BITMASK31 0x7fffffff -#define BITMASK32 0xffffffff +#define MD_BITMASK1 0x00000001 +#define MD_BITMASK2 0x00000003 +#define MD_BITMASK3 0x00000007 +#define MD_BITMASK4 0x0000000f +#define MD_BITMASK5 0x0000001f +#define MD_BITMASK6 0x0000003f +#define MD_BITMASK7 0x0000007f +#define MD_BITMASK8 0x000000ff +#define MD_BITMASK9 0x000001ff +#define MD_BITMASK10 0x000003ff +#define MD_BITMASK11 0x000007ff +#define MD_BITMASK12 0x00000fff +#define MD_BITMASK13 0x00001fff +#define MD_BITMASK14 0x00003fff +#define MD_BITMASK15 0x00007fff +#define MD_BITMASK16 0x0000ffff +#define MD_BITMASK17 0x0001ffff +#define MD_BITMASK18 0x0003ffff +#define MD_BITMASK19 0x0007ffff +#define MD_BITMASK20 0x000fffff +#define MD_BITMASK21 0x001fffff +#define MD_BITMASK22 0x003fffff +#define MD_BITMASK23 0x007fffff +#define MD_BITMASK24 0x00ffffff +#define MD_BITMASK25 0x01ffffff +#define MD_BITMASK26 0x03ffffff +#define MD_BITMASK27 0x07ffffff +#define MD_BITMASK28 0x0fffffff +#define MD_BITMASK29 0x1fffffff +#define MD_BITMASK30 0x3fffffff +#define MD_BITMASK31 0x7fffffff +#define MD_BITMASK32 0xffffffff -#define BITMASK33 0x00000001ffffffffull -#define BITMASK34 0x00000003ffffffffull -#define BITMASK35 0x00000007ffffffffull -#define BITMASK36 0x0000000fffffffffull -#define BITMASK37 0x0000001fffffffffull -#define BITMASK38 0x0000003fffffffffull -#define BITMASK39 0x0000007fffffffffull -#define BITMASK40 0x000000ffffffffffull -#define BITMASK41 0x000001ffffffffffull -#define BITMASK42 0x000003ffffffffffull -#define BITMASK43 0x000007ffffffffffull -#define BITMASK44 0x00000fffffffffffull -#define BITMASK45 0x00001fffffffffffull -#define BITMASK46 0x00003fffffffffffull -#define BITMASK47 0x00007fffffffffffull -#define BITMASK48 0x0000ffffffffffffull -#define BITMASK49 0x0001ffffffffffffull -#define BITMASK50 0x0003ffffffffffffull -#define BITMASK51 0x0007ffffffffffffull -#define BITMASK52 0x000fffffffffffffull -#define BITMASK53 0x001fffffffffffffull -#define BITMASK54 0x003fffffffffffffull -#define BITMASK55 0x007fffffffffffffull -#define BITMASK56 0x00ffffffffffffffull -#define BITMASK57 0x01ffffffffffffffull -#define BITMASK58 0x03ffffffffffffffull -#define BITMASK59 0x07ffffffffffffffull -#define BITMASK60 0x0fffffffffffffffull -#define BITMASK61 0x1fffffffffffffffull -#define BITMASK62 0x3fffffffffffffffull -#define BITMASK63 0x7fffffffffffffffull -#define BITMASK64 0xffffffffffffffffull +#define MD_BITMASK33 0x00000001ffffffffull +#define MD_BITMASK34 0x00000003ffffffffull +#define MD_BITMASK35 0x00000007ffffffffull +#define MD_BITMASK36 0x0000000fffffffffull +#define MD_BITMASK37 0x0000001fffffffffull +#define MD_BITMASK38 0x0000003fffffffffull +#define MD_BITMASK39 0x0000007fffffffffull +#define MD_BITMASK40 0x000000ffffffffffull +#define MD_BITMASK41 0x000001ffffffffffull +#define MD_BITMASK42 0x000003ffffffffffull +#define MD_BITMASK43 0x000007ffffffffffull +#define MD_BITMASK44 0x00000fffffffffffull +#define MD_BITMASK45 0x00001fffffffffffull +#define MD_BITMASK46 0x00003fffffffffffull +#define MD_BITMASK47 0x00007fffffffffffull +#define MD_BITMASK48 0x0000ffffffffffffull +#define MD_BITMASK49 0x0001ffffffffffffull +#define MD_BITMASK50 0x0003ffffffffffffull +#define MD_BITMASK51 0x0007ffffffffffffull +#define MD_BITMASK52 0x000fffffffffffffull +#define MD_BITMASK53 0x001fffffffffffffull +#define MD_BITMASK54 0x003fffffffffffffull +#define MD_BITMASK55 0x007fffffffffffffull +#define MD_BITMASK56 0x00ffffffffffffffull +#define MD_BITMASK57 0x01ffffffffffffffull +#define MD_BITMASK58 0x03ffffffffffffffull +#define MD_BITMASK59 0x07ffffffffffffffull +#define MD_BITMASK60 0x0fffffffffffffffull +#define MD_BITMASK61 0x1fffffffffffffffull +#define MD_BITMASK62 0x3fffffffffffffffull +#define MD_BITMASK63 0x7fffffffffffffffull +#define MD_BITMASK64 0xffffffffffffffffull -#define BIT1 (1 << 0) -#define BIT2 (1 << 1) -#define BIT3 (1 << 2) -#define BIT4 (1 << 3) -#define BIT5 (1 << 4) -#define BIT6 (1 << 5) -#define BIT7 (1 << 6) -#define BIT8 (1 << 7) -#define BIT9 (1 << 8) -#define BIT10 (1 << 9) -#define BIT11 (1 << 10) -#define BIT12 (1 << 11) -#define BIT13 (1 << 12) -#define BIT14 (1 << 13) -#define BIT15 (1 << 14) -#define BIT16 (1 << 15) -#define BIT17 (1 << 16) -#define BIT18 (1 << 17) -#define BIT19 (1 << 18) -#define BIT20 (1 << 19) -#define BIT21 (1 << 20) -#define BIT22 (1 << 21) -#define BIT23 (1 << 22) -#define BIT24 (1 << 23) -#define BIT25 (1 << 24) -#define BIT26 (1 << 25) -#define BIT27 (1 << 26) -#define BIT28 (1 << 27) -#define BIT29 (1 << 28) -#define BIT30 (1 << 29) -#define BIT31 (1 << 30) -#define BIT32 (1 << 31) +#define MD_BIT1 (1 << 0) +#define MD_BIT2 (1 << 1) +#define MD_BIT3 (1 << 2) +#define MD_BIT4 (1 << 3) +#define MD_BIT5 (1 << 4) +#define MD_BIT6 (1 << 5) +#define MD_BIT7 (1 << 6) +#define MD_BIT8 (1 << 7) +#define MD_BIT9 (1 << 8) +#define MD_BIT10 (1 << 9) +#define MD_BIT11 (1 << 10) +#define MD_BIT12 (1 << 11) +#define MD_BIT13 (1 << 12) +#define MD_BIT14 (1 << 13) +#define MD_BIT15 (1 << 14) +#define MD_BIT16 (1 << 15) +#define MD_BIT17 (1 << 16) +#define MD_BIT18 (1 << 17) +#define MD_BIT19 (1 << 18) +#define MD_BIT20 (1 << 19) +#define MD_BIT21 (1 << 20) +#define MD_BIT22 (1 << 21) +#define MD_BIT23 (1 << 22) +#define MD_BIT24 (1 << 23) +#define MD_BIT25 (1 << 24) +#define MD_BIT26 (1 << 25) +#define MD_BIT27 (1 << 26) +#define MD_BIT28 (1 << 27) +#define MD_BIT29 (1 << 28) +#define MD_BIT30 (1 << 29) +#define MD_BIT31 (1 << 30) +#define MD_BIT32 (1 << 31) -#define BIT33 (1ull << 32) -#define BIT34 (1ull << 33) -#define BIT35 (1ull << 34) -#define BIT36 (1ull << 35) -#define BIT37 (1ull << 36) -#define BIT38 (1ull << 37) -#define BIT39 (1ull << 38) -#define BIT40 (1ull << 39) -#define BIT41 (1ull << 40) -#define BIT42 (1ull << 41) -#define BIT43 (1ull << 42) -#define BIT44 (1ull << 43) -#define BIT45 (1ull << 44) -#define BIT46 (1ull << 45) -#define BIT47 (1ull << 46) -#define BIT48 (1ull << 47) -#define BIT49 (1ull << 48) -#define BIT50 (1ull << 49) -#define BIT51 (1ull << 50) -#define BIT52 (1ull << 51) -#define BIT53 (1ull << 52) -#define BIT54 (1ull << 53) -#define BIT55 (1ull << 54) -#define BIT56 (1ull << 55) -#define BIT57 (1ull << 56) -#define BIT58 (1ull << 57) -#define BIT59 (1ull << 58) -#define BIT60 (1ull << 59) -#define BIT61 (1ull << 60) -#define BIT62 (1ull << 61) -#define BIT63 (1ull << 62) -#define BIT64 (1ull << 63) +#define MD_BIT33 (1ull << 32) +#define MD_BIT34 (1ull << 33) +#define MD_BIT35 (1ull << 34) +#define MD_BIT36 (1ull << 35) +#define MD_BIT37 (1ull << 36) +#define MD_BIT38 (1ull << 37) +#define MD_BIT39 (1ull << 38) +#define MD_BIT40 (1ull << 39) +#define MD_BIT41 (1ull << 40) +#define MD_BIT42 (1ull << 41) +#define MD_BIT43 (1ull << 42) +#define MD_BIT44 (1ull << 43) +#define MD_BIT45 (1ull << 44) +#define MD_BIT46 (1ull << 45) +#define MD_BIT47 (1ull << 46) +#define MD_BIT48 (1ull << 47) +#define MD_BIT49 (1ull << 48) +#define MD_BIT50 (1ull << 49) +#define MD_BIT51 (1ull << 50) +#define MD_BIT52 (1ull << 51) +#define MD_BIT53 (1ull << 52) +#define MD_BIT54 (1ull << 53) +#define MD_BIT55 (1ull << 54) +#define MD_BIT56 (1ull << 55) +#define MD_BIT57 (1ull << 56) +#define MD_BIT58 (1ull << 57) +#define MD_BIT59 (1ull << 58) +#define MD_BIT60 (1ull << 59) +#define MD_BIT61 (1ull << 60) +#define MD_BIT62 (1ull << 61) +#define MD_BIT63 (1ull << 62) +#define MD_BIT64 (1ull << 63) //////////////////////////////// //~ Globally Unique Ids -typedef union Guid Guid; -union Guid +typedef union MD_Guid MD_Guid; +union MD_Guid { struct { - U32 data1; - U16 data2; - U16 data3; - U8 data4[8]; + MD_U32 data1; + MD_U16 data2; + MD_U16 data3; + MD_U8 data4[8]; }; - U8 v[16]; + MD_U8 v[16]; }; -static_assert(size_of(Guid) == 16, "Guid is not 16 bytes"); +static_assert(size_of(MD_Guid) == 16, "MD_Guid is not 16 bytes"); //////////////////////////////// //~ Arrays -typedef struct U16Array U16Array; -struct U16Array +typedef struct MD_U16Array MD_U16Array; +struct MD_U16Array { - U64 count; - U16* v; + MD_U64 count; + MD_U16* v; }; -typedef struct U32Array U32Array; -struct U32Array +typedef struct MD_U32Array MD_U32Array; +struct MD_U32Array { - U64 count; - U32* v; + MD_U64 count; + MD_U32* v; }; -typedef struct U64Array U64Array; -struct U64Array +typedef struct MD_U64Array MD_U64Array; +struct MD_U64Array { - U64 count; - U64* v; + MD_U64 count; + MD_U64* v; }; -typedef struct U128Array U128Array; -struct U128Array +typedef struct MD_U128Array MD_U128Array; +struct MD_U128Array { - U64 count; + MD_U64 count; U128* v; }; diff --git a/source/base/command_line.c b/source/base/command_line.c index 0b15be7..23b4e75 100644 --- a/source/base/command_line.c +++ b/source/base/command_line.c @@ -8,24 +8,24 @@ //////////////////////////////// //~ NOTE(rjf): Command Line Option Parsing -CmdLineOpt** -cmd_line_slot_from_string(CmdLine* cmd_line, String8 string) { - CmdLineOpt** slot = 0; +MD_CmdLineOpt** +md_cmd_line_slot_from_string(MD_CmdLine* cmd_line, MD_String8 string) { + MD_CmdLineOpt** slot = 0; if (cmd_line->option_table_size != 0) { - U64 hash = cmd_line_hash_from_string(string); - U64 bucket = hash % cmd_line->option_table_size; + MD_U64 hash = md_cmd_line_hash_from_string(string); + MD_U64 bucket = hash % cmd_line->option_table_size; slot = &cmd_line->option_table[bucket]; } return slot; } -CmdLineOpt* -cmd_line_opt_from_slot(CmdLineOpt** slot, String8 string) { - CmdLineOpt* result = 0; - for (CmdLineOpt* var = *slot; var; var = var->hash_next) +MD_CmdLineOpt* +md_cmd_line_opt_from_slot(MD_CmdLineOpt** slot, MD_String8 string) { + MD_CmdLineOpt* result = 0; + for (MD_CmdLineOpt* var = *slot; var; var = var->hash_next) { - if (str8_match(string, var->string, 0)) { + if (md_str8_match(string, var->string, 0)) { result = var; break; } @@ -33,73 +33,73 @@ cmd_line_opt_from_slot(CmdLineOpt** slot, String8 string) { return result; } -CmdLineOpt* -cmd_line_insert_opt__ainfo(AllocatorInfo ainfo, CmdLine* cmd_line, String8 string, String8List values) +MD_CmdLineOpt* +md_cmd_line_insert_opt__ainfo(MD_AllocatorInfo ainfo, MD_CmdLine* cmd_line, MD_String8 string, MD_String8List values) { - CmdLineOpt *var = 0; - CmdLineOpt **slot = cmd_line_slot_from_string(cmd_line, string); - CmdLineOpt *existing_var = cmd_line_opt_from_slot(slot, string); + MD_CmdLineOpt *var = 0; + MD_CmdLineOpt **slot = md_cmd_line_slot_from_string(cmd_line, string); + MD_CmdLineOpt *existing_var = md_cmd_line_opt_from_slot(slot, string); if(existing_var != 0) { var = existing_var; } else { - var = alloc_array(ainfo, CmdLineOpt, 1); + var = md_alloc_array(ainfo, MD_CmdLineOpt, 1); var->hash_next = *slot; - var->hash = cmd_line_hash_from_string(string); - var->string = str8_copy(ainfo, string); + var->hash = md_cmd_line_hash_from_string(string); + var->string = md_str8_copy(ainfo, string); var->value_strings = values; - StringJoin join = {0}; - join.pre = str8_lit(""); - join.sep = str8_lit(","); - join.post = str8_lit(""); + MD_StringJoin join = {0}; + join.pre = md_str8_lit(""); + join.sep = md_str8_lit(","); + join.post = md_str8_lit(""); - var->value_string = str8_list_join(ainfo, &var->value_strings, &join); + var->value_string = md_str8_list_join(ainfo, &var->value_strings, &join); *slot = var; - cmd_line_push_opt(&cmd_line->options, var); + md_cmd_line_push_opt(&cmd_line->options, var); } return var; } -CmdLine -cmd_line_from_string_list__ainfo(AllocatorInfo ainfo, String8List command_line) +MD_CmdLine +md_cmd_line_from_string_list__ainfo(MD_AllocatorInfo ainfo, MD_String8List command_line) { - CmdLine parsed = {0}; + MD_CmdLine parsed = {0}; parsed.exe_name = command_line.first->string; // NOTE(rjf): Set up config option table. { parsed.option_table_size = 4096; - parsed.option_table = alloc_array(ainfo, CmdLineOpt*, parsed.option_table_size); + parsed.option_table = md_alloc_array(ainfo, MD_CmdLineOpt*, parsed.option_table_size); } // NOTE(rjf): Parse command line. - B32 after_passthrough_option = 0; - B32 first_passthrough = 1; - for (String8Node* node = command_line.first->next, *next = 0; node != 0; node = next) + MD_B32 after_passthrough_option = 0; + MD_B32 first_passthrough = 1; + for (MD_String8Node* node = command_line.first->next, *next = 0; node != 0; node = next) { next = node->next; - String8 option_name = node->string; + MD_String8 option_name = node->string; // NOTE(rjf): Look at -- or - at the start of an argument to determine if it's // a flag option. All arguments after a single "--" (with no trailing string // on the command line will be considered as input files. - B32 is_option = 1; + MD_B32 is_option = 1; if(after_passthrough_option == 0) { - if (str8_match(node->string, str8_lit("--"), 0)) { + if (md_str8_match(node->string, md_str8_lit("--"), 0)) { after_passthrough_option = 1; is_option = 0; } - else if (str8_match(str8_prefix(node->string, 2), str8_lit("--"), 0)) { - option_name = str8_skip(option_name, 2); + else if (md_str8_match(md_str8_prefix(node->string, 2), md_str8_lit("--"), 0)) { + option_name = md_str8_skip(option_name, 2); } - else if (str8_match(str8_prefix(node->string, 1), str8_lit("-"), 0)) { - option_name = str8_skip(option_name, 1); + else if (md_str8_match(md_str8_prefix(node->string, 1), md_str8_lit("-"), 0)) { + option_name = md_str8_skip(option_name, 1); } else { is_option = 0; @@ -113,49 +113,49 @@ cmd_line_from_string_list__ainfo(AllocatorInfo ainfo, String8List command_line) // NOTE(rjf): This string is an option. if(is_option) { - B32 has_arguments = 0; - U64 arg_signifier_position1 = str8_find_needle(option_name, 0, str8_lit(":"), 0); - U64 arg_signifier_position2 = str8_find_needle(option_name, 0, str8_lit("="), 0); - U64 arg_signifier_position = min(arg_signifier_position1, arg_signifier_position2); - String8 arg_portion_this_string = str8_skip(option_name, arg_signifier_position+1); + MD_B32 has_arguments = 0; + MD_U64 arg_signifier_position1 = md_str8_find_needle(option_name, 0, md_str8_lit(":"), 0); + MD_U64 arg_signifier_position2 = md_str8_find_needle(option_name, 0, md_str8_lit("="), 0); + MD_U64 arg_signifier_position = md_min(arg_signifier_position1, arg_signifier_position2); + MD_String8 arg_portion_this_string = md_str8_skip(option_name, arg_signifier_position+1); if (arg_signifier_position < option_name.size) { has_arguments = 1; } - option_name = str8_prefix(option_name, arg_signifier_position); + option_name = md_str8_prefix(option_name, arg_signifier_position); - String8List arguments = {0}; + MD_String8List arguments = {0}; // NOTE(rjf): Parse arguments. if (has_arguments) { - for (String8Node* n = node; n; n = n->next) + for (MD_String8Node* n = node; n; n = n->next) { next = n->next; - String8 string = n->string; + MD_String8 string = n->string; if (n == node) { string = arg_portion_this_string; } - U8 splits[] = { ',' }; - String8List args_in_this_string = str8_split(ainfo, string, splits, array_count(splits), 0); - for (String8Node* sub_arg = args_in_this_string.first; sub_arg; sub_arg = sub_arg->next) { - str8_list_push(ainfo, &arguments, sub_arg->string); + MD_U8 splits[] = { ',' }; + MD_String8List args_in_this_string = md_str8_split(ainfo, string, splits, md_array_count(splits), 0); + for (MD_String8Node* sub_arg = args_in_this_string.first; sub_arg; sub_arg = sub_arg->next) { + md_str8_list_push(ainfo, &arguments, sub_arg->string); } - if ( !str8_match(str8_postfix(n->string, 1), str8_lit(","), 0) && (n != node || arg_portion_this_string.size != 0)) { + if ( !md_str8_match(md_str8_postfix(n->string, 1), md_str8_lit(","), 0) && (n != node || arg_portion_this_string.size != 0)) { break; } } } // NOTE(rjf): Register config variable. - cmd_line_insert_opt(ainfo, &parsed, option_name, arguments); + md_cmd_line_insert_opt(ainfo, &parsed, option_name, arguments); } // NOTE(rjf): Default path, treat as a passthrough config option to be // handled by tool-specific code. - else if ( !str8_match(node->string, str8_lit("--"), 0) || !first_passthrough) { - str8_list_push(ainfo, &parsed.inputs, node->string); + else if ( !md_str8_match(node->string, md_str8_lit("--"), 0) || !first_passthrough) { + md_str8_list_push(ainfo, &parsed.inputs, node->string); after_passthrough_option = 1; first_passthrough = 0; } diff --git a/source/base/command_line.h b/source/base/command_line.h index c9a506c..3652f3b 100644 --- a/source/base/command_line.h +++ b/source/base/command_line.h @@ -9,98 +9,98 @@ //////////////////////////////// //~ rjf: Parsed Command Line Types -typedef struct CmdLineOpt CmdLineOpt; -struct CmdLineOpt +typedef struct MD_CmdLineOpt MD_CmdLineOpt; +struct MD_CmdLineOpt { - CmdLineOpt* next; - CmdLineOpt* hash_next; - U64 hash; - String8 string; - String8List value_strings; - String8 value_string; + MD_CmdLineOpt* next; + MD_CmdLineOpt* hash_next; + MD_U64 hash; + MD_String8 string; + MD_String8List value_strings; + MD_String8 value_string; }; -typedef struct CmdLineOptList CmdLineOptList; -struct CmdLineOptList +typedef struct MD_CmdLineOptList MD_CmdLineOptList; +struct MD_CmdLineOptList { - U64 count; - CmdLineOpt* first; - CmdLineOpt* last; + MD_U64 count; + MD_CmdLineOpt* first; + MD_CmdLineOpt* last; }; -typedef struct CmdLine CmdLine; -struct CmdLine +typedef struct MD_CmdLine MD_CmdLine; +struct MD_CmdLine { - String8 exe_name; - CmdLineOptList options; - String8List inputs; - U64 option_table_size; - CmdLineOpt** option_table; + MD_String8 exe_name; + MD_CmdLineOptList options; + MD_String8List inputs; + MD_U64 option_table_size; + MD_CmdLineOpt** option_table; }; //////////////////////////////// //~ NOTE(rjf): Command Line Option Parsing - U64 cmd_line_hash_from_string(String8 string); -MD_API CmdLineOpt** cmd_line_slot_from_string(CmdLine* cmd_line, String8 string); -MD_API CmdLineOpt* cmd_line_opt_from_slot (CmdLineOpt** slot, String8 string); - void cmd_line_push_opt (CmdLineOptList* list, CmdLineOpt* var); + MD_U64 md_cmd_line_hash_from_string(MD_String8 string); +MD_API MD_CmdLineOpt** md_cmd_line_slot_from_string(MD_CmdLine* cmd_line, MD_String8 string); +MD_API MD_CmdLineOpt* md_cmd_line_opt_from_slot (MD_CmdLineOpt** slot, MD_String8 string); + void md_cmd_line_push_opt (MD_CmdLineOptList* list, MD_CmdLineOpt* var); -CmdLineOpt* cmd_line_opt_from_string (CmdLine* cmd_line, String8 name); -String8List cmd_line_strings (CmdLine* cmd_line, String8 name); -String8 cmd_line_string (CmdLine* cmd_line, String8 name); -B32 cmd_line_has_flag (CmdLine* cmd_line, String8 name); -B32 cmd_line_has_argument (CmdLine* cmd_line, String8 name); +MD_CmdLineOpt* md_cmd_line_opt_from_string (MD_CmdLine* cmd_line, MD_String8 name); +MD_String8List md_cmd_line_strings (MD_CmdLine* cmd_line, MD_String8 name); +MD_String8 md_cmd_line_string (MD_CmdLine* cmd_line, MD_String8 name); +MD_B32 md_cmd_line_has_flag (MD_CmdLine* cmd_line, MD_String8 name); +MD_B32 md_cmd_line_has_argument (MD_CmdLine* cmd_line, MD_String8 name); -inline CmdLineOpt* cmd_line_insert_opt__arena (Arena* arena, CmdLine* cmd_line, String8 string, String8List values); -MD_API CmdLineOpt* cmd_line_insert_opt__ainfo (AllocatorInfo ainfo, CmdLine* cmd_line, String8 string, String8List values); -inline CmdLine cmd_line_from_string_list__arena(Arena* arena, String8List arguments); -MD_API CmdLine cmd_line_from_string_list__ainfo(AllocatorInfo ainfo, String8List arguments); +inline MD_CmdLineOpt* md_cmd_line_insert_opt__arena (MD_Arena* arena, MD_CmdLine* cmd_line, MD_String8 string, MD_String8List values); +MD_API MD_CmdLineOpt* md_cmd_line_insert_opt__ainfo (MD_AllocatorInfo ainfo, MD_CmdLine* cmd_line, MD_String8 string, MD_String8List values); +inline MD_CmdLine md_cmd_line_from_string_list__arena(MD_Arena* arena, MD_String8List arguments); +MD_API MD_CmdLine md_cmd_line_from_string_list__ainfo(MD_AllocatorInfo ainfo, MD_String8List arguments); -#define cmd_line_insert_opt(allocator, cmd_line, string, values) \ +#define md_cmd_line_insert_opt(allocator, cmd_line, string, values) \ _Generic(allocator, \ - Arena*: cmd_line_insert_opt__arena, \ - AllocatorInfo: cmd_line_insert_opt__ainfo, \ - default: assert_generic_sel_fail \ -) generic_call(allocator, cmd_line, string, values) + MD_Arena*: md_cmd_line_insert_opt__arena, \ + MD_AllocatorInfo: md_cmd_line_insert_opt__ainfo, \ + default: md_assert_generic_sel_fail \ +) md_generic_call(allocator, cmd_line, string, values) -#define cmd_line_from_string_list(allocator, arguments) \ +#define md_cmd_line_from_string_list(allocator, arguments) \ _Generic(allocator, \ - Arena*: cmd_line_from_string_list__arena, \ - AllocatorInfo: cmd_line_from_string_list__ainfo, \ - default: assert_generic_sel_fail \ -) generic_call(allocator, arguments) + MD_Arena*: md_cmd_line_from_string_list__arena, \ + MD_AllocatorInfo: md_cmd_line_from_string_list__ainfo, \ + default: md_assert_generic_sel_fail \ +) md_generic_call(allocator, arguments) -inline U64 -cmd_line_hash_from_string(String8 string) { - U64 result = 5381; - for(U64 i = 0; i < string.size; i += 1) { +inline MD_U64 +md_cmd_line_hash_from_string(MD_String8 string) { + MD_U64 result = 5381; + for(MD_U64 i = 0; i < string.size; i += 1) { result = ((result << 5) + result) + string.str[i]; } return result; } -force_inline CmdLineOpt* cmd_line_insert_opt__arena (Arena* arena, CmdLine* cmd_line, String8 string, String8List values) { return cmd_line_insert_opt__ainfo (arena_allocator(arena), cmd_line, string, values); } -force_inline CmdLine cmd_line_from_string_list__arena(Arena* arena, String8List command_line) { return cmd_line_from_string_list__ainfo(arena_allocator(arena), command_line); } +md_force_inline MD_CmdLineOpt* md_cmd_line_insert_opt__arena (MD_Arena* arena, MD_CmdLine* cmd_line, MD_String8 string, MD_String8List values) { return md_cmd_line_insert_opt__ainfo (md_arena_allocator(arena), cmd_line, string, values); } +md_force_inline MD_CmdLine md_cmd_line_from_string_list__arena(MD_Arena* arena, MD_String8List command_line) { return md_cmd_line_from_string_list__ainfo(md_arena_allocator(arena), command_line); } -inline CmdLineOpt* cmd_line_opt_from_string(CmdLine *cmd_line, String8 name) { return cmd_line_opt_from_slot(cmd_line_slot_from_string(cmd_line, name), name); } -inline B32 cmd_line_has_flag (CmdLine *cmd_line, String8 name) { CmdLineOpt *var = cmd_line_opt_from_string(cmd_line, name); return(var != 0); } -inline B32 cmd_line_has_argument (CmdLine *cmd_line, String8 name) { CmdLineOpt *var = cmd_line_opt_from_string(cmd_line, name); return(var != 0 && var->value_strings.node_count > 0); } +inline MD_CmdLineOpt* md_cmd_line_opt_from_string(MD_CmdLine *cmd_line, MD_String8 name) { return md_cmd_line_opt_from_slot(md_cmd_line_slot_from_string(cmd_line, name), name); } +inline MD_B32 md_cmd_line_has_flag (MD_CmdLine *cmd_line, MD_String8 name) { MD_CmdLineOpt *var = md_cmd_line_opt_from_string(cmd_line, name); return(var != 0); } +inline MD_B32 md_cmd_line_has_argument (MD_CmdLine *cmd_line, MD_String8 name) { MD_CmdLineOpt *var = md_cmd_line_opt_from_string(cmd_line, name); return(var != 0 && var->value_strings.md_node_count > 0); } -inline String8List -cmd_line_strings(CmdLine *cmd_line, String8 name) { - String8List result = {0}; - CmdLineOpt* var = cmd_line_opt_from_string(cmd_line, name); +inline MD_String8List +md_cmd_line_strings(MD_CmdLine *cmd_line, MD_String8 name) { + MD_String8List result = {0}; + MD_CmdLineOpt* var = md_cmd_line_opt_from_string(cmd_line, name); if (var != 0) { result = var->value_strings; } return result; } -inline String8 -cmd_line_string(CmdLine *cmd_line, String8 name) { - String8 result = {0}; - CmdLineOpt* var = cmd_line_opt_from_string(cmd_line, name); +inline MD_String8 +md_cmd_line_string(MD_CmdLine *cmd_line, MD_String8 name) { + MD_String8 result = {0}; + MD_CmdLineOpt* var = md_cmd_line_opt_from_string(cmd_line, name); if (var != 0) { result = var->value_string; } return result; } -inline void cmd_line_push_opt(CmdLineOptList* list, CmdLineOpt* var) { sll_queue_push(list->first, list->last, var); list->count += 1; } +inline void md_cmd_line_push_opt(MD_CmdLineOptList* list, MD_CmdLineOpt* var) { md_sll_queue_push(list->first, list->last, var); list->count += 1; } diff --git a/source/base/context_cracking.h b/source/base/context_cracking.h index 60e8c7d..58e3545 100644 --- a/source/base/context_cracking.h +++ b/source/base/context_cracking.h @@ -7,68 +7,68 @@ //////////////////////////////// //~ rjf: Build Options -#if ! defined(BUILD_DEBUG) -# define BUILD_DEBUG 1 +#if ! defined(MD_BUILD_DEBUG) +# define MD_BUILD_DEBUG 1 #endif -#if ! defined(BUILD_STATIC) -# define BUILD_STATIC 0 +#if ! defined(MD_BUILD_STATIC) +# define MD_BUILD_STATIC 0 #endif -#if ! defined(BUILD_DYANMIC) -# define BUILD_DYANMIC 0 +#if ! defined(MD_BUILD_DYANMIC) +# define MD_BUILD_DYANMIC 0 #endif -#if ! defined(BUILD_API_EXPORT) -# define BUILD_API_EXPORT 0 +#if ! defined(MD_BUILD_API_EXPORT) +# define MD_BUILD_API_EXPORT 0 #endif -#if !defined(BUILD_ENTRY_DEFINING_UNIT) -# define BUILD_ENTRY_DEFINING_UNIT 0 +#if !defined(MD_BUILD_ENTRY_DEFINING_UNIT) +# define MD_BUILD_ENTRY_DEFINING_UNIT 0 #endif -#if !defined(BUILD_CONSOLE_INTERFACE) -# define BUILD_CONSOLE_INTERFACE 0 +#if !defined(MD_BUILD_CONSOLE_INTERFACE) +# define MD_BUILD_CONSOLE_INTERFACE 0 #endif -#if !defined(BUILD_VERSION_MAJOR) -# define BUILD_VERSION_MAJOR 0 +#if !defined(MD_BUILD_VERSION_MAJOR) +# define MD_BUILD_VERSION_MAJOR 0 #endif -#if !defined(BUILD_VERSION_MINOR) -# define BUILD_VERSION_MINOR 1 +#if !defined(MD_BUILD_VERSION_MINOR) +# define MD_BUILD_VERSION_MINOR 1 #endif -#if !defined(BUILD_VERSION_PATCH) -# define BUILD_VERSION_PATCH 0 +#if !defined(MD_BUILD_VERSION_PATCH) +# define MD_BUILD_VERSION_PATCH 0 #endif -#define BUILD_VERSION_STRING_LITERAL stringify(BUILD_VERSION_MAJOR) "." stringify(BUILD_VERSION_MINOR) "." stringify(BUILD_VERSION_PATCH) +#define MD_BUILD_VERSION_STRING_LITERAL md_stringify(MD_BUILD_VERSION_MAJOR) "." md_stringify(MD_BUILD_VERSION_MINOR) "." md_stringify(MD_BUILD_VERSION_PATCH) -#if BUILD_DEBUG -# define BUILD_MODE_STRING_LITERAL_APPEND " [Debug]" +#if MD_BUILD_DEBUG +# define MD_BUILD_MODE_STRING_LITERAL_APPEND " [Debug]" #else -# define BUILD_MODE_STRING_LITERAL_APPEND "" +# define MD_BUILD_MODE_STRING_LITERAL_APPEND "" #endif -#if defined(BUILD_GIT_HASH) -# define BUILD_GIT_HASH_STRING_LITERAL_APPEND " [" BUILD_GIT_HASH "]" +#if defined(MD_BUILD_GIT_HASH) +# define MD_BUILD_GIT_HASH_STRING_LITERAL_APPEND " [" MD_BUILD_GIT_HASH "]" #else -# define BUILD_GIT_HASH_STRING_LITERAL_APPEND "" +# define MD_BUILD_GIT_HASH_STRING_LITERAL_APPEND "" #endif -#if !defined(BUILD_TITLE) -# define BUILD_TITLE "Untitled" +#if !defined(MD_BUILD_TITLE) +# define MD_BUILD_TITLE "Untitled" #endif -#if !defined(BUILD_RELEASE_PHASE_STRING_LITERAL) -# define BUILD_RELEASE_PHASE_STRING_LITERAL "ALPHA" +#if !defined(MD_BUILD_RELEASE_PHASE_STRING_LITERAL) +# define MD_BUILD_RELEASE_PHASE_STRING_LITERAL "ALPHA" #endif -#if !defined(BUILD_ISSUES_LINK_STRING_LITERAL) -# define BUILD_ISSUES_LINK_STRING_LITERAL "ADD_BUILD_ISSUES_LINK" +#if !defined(MD_BUILD_ISSUES_LINK_STRING_LITERAL) +# define MD_BUILD_ISSUES_LINK_STRING_LITERAL "ADD_BUILD_ISSUES_LINK" #endif -#define BUILD_TITLE_STRING_LITERAL BUILD_TITLE " (" BUILD_VERSION_STRING_LITERAL " " BUILD_RELEASE_PHASE_STRING_LITERAL ") - " __DATE__ "" BUILD_GIT_HASH_STRING_LITERAL_APPEND BUILD_MODE_STRING_LITERAL_APPEND +#define MD_BUILD_TITLE_STRING_LITERAL MD_BUILD_TITLE " (" MD_BUILD_VERSION_STRING_LITERAL " " MD_BUILD_RELEASE_PHASE_STRING_LITERAL ") - " __DATE__ "" MD_BUILD_GIT_HASH_STRING_LITERAL_APPEND MD_BUILD_MODE_STRING_LITERAL_APPEND #pragma endregion Build Options @@ -76,83 +76,83 @@ #if defined( _MSC_VER ) # pragma message("Detected MSVC") -// # define COMPILER_CLANG 0 -# define COMPILER_MSVC 1 -// # define COMPILER_GCC 0 +// # define MD_COMPILER_CLANG 0 +# define MD_COMPILER_MSVC 1 +// # define MD_COMPILER_GCC 0 # if _MSC_VER >= 1920 -# define COMPILER_MSVC_YEAR 2019 +# define MD_COMPILER_MSVC_YEAR 2019 # elif _MSC_VER >= 1910 -# define COMPILER_MSVC_YEAR 2017 +# define MD_COMPILER_MSVC_YEAR 2017 # elif _MSC_VER >= 1900 -# define COMPILER_MSVC_YEAR 2015 +# define MD_COMPILER_MSVC_YEAR 2015 # elif _MSC_VER >= 1800 -# define COMPILER_MSVC_YEAR 2013 +# define MD_COMPILER_MSVC_YEAR 2013 # elif _MSC_VER >= 1700 -# define COMPILER_MSVC_YEAR 2012 +# define MD_COMPILER_MSVC_YEAR 2012 # elif _MSC_VER >= 1600 -# define COMPILER_MSVC_YEAR 2010 +# define MD_COMPILER_MSVC_YEAR 2010 # elif _MSC_VER >= 1500 # define M_DCOMPILER_MSVC_YEAR 2008 # elif _MSC_VER >= 1400 -# define COMPILER_MSVC_YEAR 2005 +# define MD_COMPILER_MSVC_YEAR 2005 # else -# define COMPILER_MSVC_YEAR 0 +# define MD_COMPILER_MSVC_YEAR 0 # endif #elif defined( __GNUC__ ) # pragma message("Detected GCC") -// # define COMPILER_CLANG 0 -// # define COMPILER_MSVC 0 -# define COMPILER_GCC 1 +// # define MD_COMPILER_CLANG 0 +// # define MD_COMPILER_MSVC 0 +# define MD_COMPILER_GCC 1 #elif defined( __clang__ ) # pragma message("Detected CLANG") -# define COMPILER_CLANG 1 -// # define COMPILER_MSVC 0 -// # define COMPILER_GCC 0 +# define MD_COMPILER_CLANG 1 +// # define MD_COMPILER_MSVC 0 +// # define MD_COMPILER_GCC 0 #else # error Unknown compiler #endif #if defined( __has_attribute ) -# define HAS_ATTRIBUTE( attribute ) __has_attribute( attribute ) +# define MD_HAS_ATTRIBUTE( attribute ) __has_attribute( attribute ) #else -# define HAS_ATTRIBUTE( attribute ) ( 0 ) +# define MD_HAS_ATTRIBUTE( attribute ) ( 0 ) #endif -#if defined(GCC_VERSION_CHECK) -# undef GCC_VERSION_CHECK +#if defined(MD_GCC_VERSION_CHECK) +# undef MD_GCC_VERSION_CHECK #endif #if defined(GEN_GCC_VERSION) -# define GCC_VERSION_CHECK(major,minor,patch) (GEN_GCC_VERSION >= GEN_VERSION_ENCODE(major, minor, patch)) +# define MD_GCC_VERSION_CHECK(major,minor,patch) (GEN_GCC_VERSION >= GEN_VERSION_ENCODE(major, minor, patch)) #else -# define GCC_VERSION_CHECK(major,minor,patch) (0) +# define MD_GCC_VERSION_CHECK(major,minor,patch) (0) #endif #pragma endregion Vendor #pragma region Language -#if ! defined(LANG_C) +#if ! defined(MD_LANG_C) # ifdef __cplusplus -# define LANG_C 0 -# define LANG_CPP 1 +# define MD_LANG_C 0 +# define MD_LANG_CPP 1 # else # if defined(__STDC__) -# define LANG_C 1 -# define LANG_CPP 0 +# define MD_LANG_C 1 +# define MD_LANG_CPP 0 # else // Fallback for very old C compilers -# define LANG_C 1 -# define LANG_CPP 0 +# define MD_LANG_C 1 +# define MD_LANG_CPP 0 # endif # endif #endif -#if LANG_C +#if MD_LANG_C # pragma message("MD: Detected C") #endif -#if LANG_CPP +#if MD_LANG_CPP # pragma message("MD: Detected CPP") #endif @@ -160,56 +160,56 @@ #pragma region Hardware Architecture -#if COMPILER_CLANG +#if MD_COMPILER_CLANG # if defined(__amd64__) || defined(__amd64) || defined(__x86_64__) || defined(__x86_64) -# define ARCH_X64 1 +# define MD_ARCH_X64 1 # elif defined(i386) || defined(__i386) || defined(__i386__) -# define ARCH_X86 1 +# define MD_ARCH_X86 1 # elif defined(__aarch64__) -# define ARCH_ARM64 1 +# define MD_ARCH_ARM64 1 # elif defined(__arm__) -# define ARCH_ARM32 1 +# define MD_ARCH_ARM32 1 # else # error Architecture not supported. # endif -#endif // COMPILER_CLANG +#endif // MD_COMPILER_CLANG -#if COMPILER_MSVC +#if MD_COMPILER_MSVC # if defined(_M_AMD64) -# define ARCH_X64 1 +# define MD_ARCH_X64 1 # elif defined(_M_IX86) -# define ARCH_X86 1 +# define MD_ARCH_X86 1 # elif defined(_M_ARM64) -# define ARCH_ARM64 1 +# define MD_ARCH_ARM64 1 # elif defined(_M_ARM) -# define ARCH_ARM32 1 +# define MD_ARCH_ARM32 1 # else # error Architecture not supported. # endif -#endif // COMPILER_MSVC +#endif // MD_COMPILER_MSVC -#if COMPILER_GCC +#if MD_COMPILER_GCC # if defined(__amd64__) || defined(__amd64) || defined(__x86_64__) || defined(__x86_64) -# define ARCH_X64 1 +# define MD_ARCH_X64 1 # elif defined(i386) || defined(__i386) || defined(__i386__) -# define ARCH_X86 1 +# define MD_ARCH_X86 1 # elif defined(__aarch64__) -# define ARCH_ARM64 1 +# define MD_ARCH_ARM64 1 # elif defined(__arm__) -# define ARCH_ARM32 1 +# define MD_ARCH_ARM32 1 # else # error Architecture not supported. # endif -#endif // COMPILER_GCC +#endif // MD_COMPILER_GCC -#if defined(ARCH_X64) -# define ARCH_64BIT 1 -#elif defined(ARCH_X86) -# define ARCH_32BIT 1 +#if defined(MD_ARCH_X64) +# define MD_ARCH_64BIT 1 +#elif defined(MD_ARCH_X86) +# define MD_ARCH_32BIT 1 #endif -#if ARCH_ARM32 || ARCH_ARM64 || ARCH_X64 || ARCH_X86 -# define ARCH_LITTLE_ENDIAN 1 +#if MD_ARCH_ARM32 || MD_ARCH_ARM64 || MD_ARCH_X64 || MD_ARCH_X86 +# define MD_ARCH_LITTLE_ENDIAN 1 #else # error Endianness of this architecture not understood by context cracker. #endif @@ -219,46 +219,46 @@ #pragma region Operating System #if defined( _WIN32 ) || defined( _WIN64 ) -# ifndef OS_WINDOWS -# define OS_WINDOWS 1 +# ifndef MD_OS_WINDOWS +# define MD_OS_WINDOWS 1 # endif #elif defined( __APPLE__ ) && defined( __MACH__ ) -# ifndef OS_OSX -# define OS_OSX 1 +# ifndef MD_OS_OSX +# define MD_OS_OSX 1 # endif -# ifndef OS_MACOS -# define OS_MACOS 1 +# ifndef MD_OS_MACOS +# define MD_OS_MACOS 1 # endif #elif defined( __unix__ ) -# ifndef OS_UNIX -# define OS_UNIX 1 +# ifndef MD_OS_UNIX +# define MD_OS_UNIX 1 # endif # if defined( ANDROID ) || defined( __ANDROID__ ) -# ifndef OS_ANDROID -# define OS_ANDROID 1 +# ifndef MD_OS_ANDROID +# define MD_OS_ANDROID 1 # endif -# ifndef OS_LINUX -# define OS_LINUX 1 +# ifndef MD_OS_LINUX +# define MD_OS_LINUX 1 # endif # elif defined( __linux__ ) -# ifndef OS_LINUX -# define OS_LINUX 1 +# ifndef MD_OS_LINUX +# define MD_OS_LINUX 1 # endif # elif defined( __FreeBSD__ ) || defined( __FreeBSD_kernel__ ) -# ifndef OS_FREEBSD -# define OS_FREEBSD 1 +# ifndef MD_OS_FREEBSD +# define MD_OS_FREEBSD 1 # endif # elif defined( __OpenBSD__ ) -# ifndef OS_OPENBSD -# define OS_OPENBSD 1 +# ifndef MD_OS_OPENBSD +# define MD_OS_OPENBSD 1 # endif # elif defined( __EMSCRIPTEN__ ) -# ifndef OS_EMSCRIPTEN -# define OS_EMSCRIPTEN 1 +# ifndef MD_OS_EMSCRIPTEN +# define MD_OS_EMSCRIPTEN 1 # endif # elif defined( __CYGWIN__ ) -# ifndef OS_CYGWIN -# define OS_CYGWIN 1 +# ifndef MD_OS_CYGWIN +# define MD_OS_CYGWIN 1 # endif # else # error This UNIX operating system is not supported @@ -272,55 +272,55 @@ //////////////////////////////// //~ rjf: Zero All Undefined Options -#if !defined(ARCH_32BIT) -# define ARCH_32BIT 0 +#if !defined(MD_ARCH_32BIT) +# define MD_ARCH_32BIT 0 #endif -#if !defined(ARCH_64BIT) -# define ARCH_64BIT 0 +#if !defined(MD_ARCH_64BIT) +# define MD_ARCH_64BIT 0 #endif -#if !defined(ARCH_X64) -# define ARCH_X64 0 +#if !defined(MD_ARCH_X64) +# define MD_ARCH_X64 0 #endif -#if !defined(ARCH_X86) -# define ARCH_X86 0 +#if !defined(MD_ARCH_X86) +# define MD_ARCH_X86 0 #endif -#if !defined(ARCH_ARM64) -# define ARCH_ARM64 0 +#if !defined(MD_ARCH_ARM64) +# define MD_ARCH_ARM64 0 #endif -#if !defined(ARCH_ARM32) -# define ARCH_ARM32 0 +#if !defined(MD_ARCH_ARM32) +# define MD_ARCH_ARM32 0 #endif -#if !defined(COMPILER_MSVC) -# define COMPILER_MSVC 0 +#if !defined(MD_COMPILER_MSVC) +# define MD_COMPILER_MSVC 0 #endif -#if !defined(COMPILER_GCC) -# define COMPILER_GCC 0 +#if !defined(MD_COMPILER_GCC) +# define MD_COMPILER_GCC 0 #endif -#if !defined(COMPILER_CLANG) -# define COMPILER_CLANG 0 +#if !defined(MD_COMPILER_CLANG) +# define MD_COMPILER_CLANG 0 #endif -#if !defined(OS_WINDOWS) -# define OS_WINDOWS 0 +#if !defined(MD_OS_WINDOWS) +# define MD_OS_WINDOWS 0 #endif -#if !defined(OS_LINUX) -# define OS_LINUX 0 +#if !defined(MD_OS_LINUX) +# define MD_OS_LINUX 0 #endif -#if !defined(OS_MAC) -# define OS_MAC 0 +#if !defined(MD_OS_MAC) +# define MD_OS_MAC 0 #endif -#if !defined(LANG_CPP) -# define LANG_CPP 0 +#if !defined(MD_LANG_CPP) +# define MD_LANG_CPP 0 #endif -#if !defined(LANG_C) -# define LANG_C 0 +#if !defined(MD_LANG_C) +# define MD_LANG_C 0 #endif //////////////////////////////// //~ rjf: Unsupported Errors -#if ARCH_X86 +#if MD_ARCH_X86 # error You tried to build in x86 (32 bit) mode, but currently, only building in x64 (64 bit) mode is supported. #endif -#if ! ARCH_X64 +#if ! MD_ARCH_X64 # error You tried to build with an unsupported architecture. Currently, only building in x64 mode is supported. #endif diff --git a/source/base/debug.c b/source/base/debug.c index a313553..13d42d4 100644 --- a/source/base/debug.c +++ b/source/base/debug.c @@ -7,7 +7,7 @@ #define md__printf_err( fmt, ... ) fprintf( stderr, fmt, __VA_ARGS__ ) #define md__printf_err_va( fmt, va ) vfprintf( stderr, fmt, va ) -void assert_handler( char const* condition, char const* file, char const* function, S32 line, char const* msg, ... ) +void md_assert_handler( char const* condition, char const* file, char const* function, MD_S32 line, char const* msg, ... ) { md__printf_err( "%s - %s:(%d): Assert Failure: ", file, function, line ); diff --git a/source/base/debug.h b/source/base/debug.h index 7dced1a..2d26231 100644 --- a/source/base/debug.h +++ b/source/base/debug.h @@ -11,53 +11,53 @@ //////////////////////////////// //~ rjf: Asserts -#ifndef trap -# if COMPILER_MSVC +#ifndef md_trap +# if MD_COMPILER_MSVC # if _MSC_VER < 1300 -# define trap() __asm int 3 /* Trap to debugger! */ +# define md_trap() __asm int 3 /* Trap to debugger! */ # else -# define trap() __debugbreak() +# define md_trap() __debugbreak() # endif -# elif COMPILER_CLANG || COMPILER_GCC -# define trap() __builtin_trap() +# elif MD_COMPILER_CLANG || MD_COMPILER_GCC +# define md_trap() __builtin_trap() # else -# error Unknown trap intrinsic for this compiler. +# error Unknown md_trap intrinsic for this compiler. # endif #endif -#define assert_msg( cond, msg, ... ) \ +#define md_assert_msg( cond, msg, ... ) \ do \ { \ if ( ! ( cond ) ) \ { \ - assert_handler( #cond, __FILE__, __func__, scast( S64, __LINE__ ), msg, ##__VA_ARGS__ ); \ - trap(); \ + md_assert_handler( #cond, __FILE__, __func__, md_scast( MD_S64, __LINE__ ), msg, ##__VA_ARGS__ ); \ + md_trap(); \ } \ } while ( 0 ) -#ifndef assert_always -#define assert_always(x) do { if ( !(x) ) { trap(); } } while(0) +#ifndef md_assert_always +#define md_assert_always(x) do { if ( !(x) ) { md_trap(); } } while(0) #endif -#ifndef assert -# if BUILD_DEBUG -# define assert(x) assert_always(x) +#ifndef md_assert +# if MD_BUILD_DEBUG +# define md_assert(x) md_assert_always(x) # else -# define assert(x) (void)(x) +# define md_assert(x) (void)(x) # endif #endif -#ifndef invalid_path -#define invalid_path assert( ! "Invalid Path!") +#ifndef md_invalid_path +#define md_invalid_path md_assert( ! "Invalid Path!") #endif -#ifndef not_implemented -#define not_implemented assert( ! "Not Implemented!") +#ifndef md_not_implemented +#define md_not_implemented md_assert( ! "Not Implemented!") #endif -#ifndef no_op -#define no_op ((void)0) +#ifndef md_no_op +#define md_no_op ((void)0) #endif #ifndef md_static_assert -#define md_static_assert(C, ID) global U8 glue(ID, __LINE__)[ (C) ? 1 : -1 ] +#define md_static_assert(C, ID) md_global MD_U8 md_glue(ID, __LINE__)[ (C) ? 1 : -1 ] #endif -MD_API void assert_handler( char const* condition, char const* file, char const* function, S32 line, char const* msg, ... ); +MD_API void md_assert_handler( char const* condition, char const* file, char const* function, MD_S32 line, char const* msg, ... ); diff --git a/source/base/entry_point.c b/source/base/entry_point.c index dad247d..20e118d 100644 --- a/source/base/entry_point.c +++ b/source/base/entry_point.c @@ -9,39 +9,39 @@ // Copyright (c) 2024 Epic Games Tools // Licensed under the MIT license (https://opensource.org/license/mit/) -void main_thread_base_entry_point(MainThread_EntryPointProc* entry_point, char** arguments, U64 arguments_count) +void md_main_thread_base_entry_point(MD_MainThread_EntryPointProc* md_entry_point, char** arguments, MD_U64 arguments_count) { -#if PROFILE_TELEMETRY - local_persist U8 tm_data[MB(64)]; +#if MD_PROFILE_TELEMETRY + md_local_persist MD_U8 tm_data[MD_MB(64)]; tmLoadLibrary(TM_RELEASE); tmSetMaxThreadCount(256); tmInitialize(sizeof(tm_data), (char *)tm_data); #endif - thread_namef("[main thread]"); + md_thread_namef("[main thread]"); - TempArena scratch = scratch_begin(0, 0); + MD_TempArena scratch = md_scratch_begin(0, 0); - String8List command_line_argument_strings = os_string_list_from_argcv(scratch.arena, (int)arguments_count, arguments); - CmdLine cmdline = cmd_line_from_string_list(scratch.arena, command_line_argument_strings); - B32 capture = cmd_line_has_flag(&cmdline, str8_lit("capture")); + MD_String8List command_line_argument_strings = md_os_string_list_from_argcv(scratch.arena, (int)arguments_count, arguments); + MD_CmdLine cmdline = md_cmd_line_from_string_list(scratch.arena, command_line_argument_strings); + MD_B32 capture = md_cmd_line_has_flag(&cmdline, md_str8_lit("capture")); if (capture) { - prof_begin_capture(arguments[0]); + md_prof_begin_capture(arguments[0]); } - entry_point(&cmdline); + md_entry_point(&cmdline); if (capture) { - prof_end_capture(); + md_prof_end_capture(); } scratch_end(scratch); } void -supplement_thread_base_entry_point(SupplementThread_EntryPointProc* entry_point, void* params) +md_supplement_thread_base_entry_point(MD_SupplementThread_EntryPointProc* md_entry_point, void* params) { - TCTX tctx; - tctx_init_and_equip(&tctx); - entry_point(params); - tctx_release(); + MD_TCTX md_tctx; + md_tctx_init_and_equip(&md_tctx); + md_entry_point(params); + md_tctx_release(); } diff --git a/source/base/entry_point.h b/source/base/entry_point.h index 9198aae..11e7c65 100644 --- a/source/base/entry_point.h +++ b/source/base/entry_point.h @@ -8,8 +8,8 @@ // Copyright (c) 2024 Epic Games Tools // Licensed under the MIT license (https://opensource.org/license/mit/) -typedef void (MainThread_EntryPointProc) (CmdLine* cmd_line); -typedef void (SupplementThread_EntryPointProc)(void* params); +typedef void (MD_MainThread_EntryPointProc) (MD_CmdLine* cmd_line); +typedef void (MD_SupplementThread_EntryPointProc)(void* params); -MD_API void main_thread_base_entry_point (MainThread_EntryPointProc* entry_point, char** arguments, U64 arguments_count); -MD_API void supplement_thread_base_entry_point(SupplementThread_EntryPointProc* entry_point, void* params); +MD_API void md_main_thread_base_entry_point (MD_MainThread_EntryPointProc* md_entry_point, char** arguments, MD_U64 arguments_count); +MD_API void md_supplement_thread_base_entry_point(MD_SupplementThread_EntryPointProc* md_entry_point, void* params); diff --git a/source/base/file.h b/source/base/file.h index 1b1e013..7e1ec4e 100644 --- a/source/base/file.h +++ b/source/base/file.h @@ -7,17 +7,17 @@ //////////////////////////////// //~ allen: Files -typedef U32 FilePropertyFlags; +typedef MD_U32 MD_FilePropertyFlags; enum { - FilePropertyFlag_IsFolder = (1 << 0), + MD_FilePropertyFlag_IsFolder = (1 << 0), }; -typedef struct FileProperties FileProperties; -struct FileProperties +typedef struct MD_FileProperties MD_FileProperties; +struct MD_FileProperties { - U64 size; - DenseTime modified; - DenseTime created; - FilePropertyFlags flags; + MD_U64 size; + MD_DenseTime modified; + MD_DenseTime created; + MD_FilePropertyFlags flags; }; diff --git a/source/base/generic_macros.h b/source/base/generic_macros.h index 4818b5c..078eb21 100644 --- a/source/base/generic_macros.h +++ b/source/base/generic_macros.h @@ -1,7 +1,5 @@ #ifdef INTELLISENSE_DIRECTIVES # pragma once -// NOTE(Ed): For C++ generation, this file will not be injected, any macros that are used will either be injected as transparent defines -// or have their usage removed during the library generation pass. #endif // ____ _ ______ _ _ ____ _ __ _ @@ -19,42 +17,42 @@ // Additional info: https://www.chiark.greenend.org.uk/~sgtatham/quasiblog/c11-generic/ // -------------------------------------------------------------------------------------------------------------------------------------------- -#ifndef COMMA_OPERATOR -#define COMMA_OPERATOR , // The comma operator is used by preprocessor macros to delimit arguments, so we have to represent it via a macro to prevent parsing incorrectly. +#ifndef MD_COMMA_OPERATOR +#define MD_COMMA_OPERATOR , // The comma operator is used by preprocessor macros to delimit arguments, so we have to represent it via a macro to prevent parsing incorrectly. #endif // Helper macros for argument selection -#ifndef select_arg_1 -#define select_arg_1( _1, ... ) _1 // <-- Of all th args passed pick _1. -#define select_arg_2( _1, _2, ... ) _2 // <-- Of all the args passed pick _2. -#define select_arg_3( _1, _2, _3, ... ) _3 // etc.. +#ifndef md_select_arg_1 +#define md_select_arg_1( _1, ... ) _1 // <-- Of all th args passed pick _1. +#define md_select_arg_2( _1, _2, ... ) _2 // <-- Of all the args passed pick _2. +#define md_select_arg_3( _1, _2, _3, ... ) _3 // etc.. -#define generic_sel_entry_type select_arg_1 // Use the arg expansion macro to select arg 1 which should have the type. -#define generic_sel_entry_function select_arg_2 // Use the arg expansion macro to select arg 2 which should have the function. -#define generic_sel_entry_comma_delimiter select_arg_3 // Use the arg expansion macro to select arg 3 which should have the comma delimiter ','. +#define md_generic_sel_entry_type md_select_arg_1 // Use the arg expansion macro to select arg 1 which should have the type. +#define md_generic_sel_entry_function md_select_arg_2 // Use the arg expansion macro to select arg 2 which should have the function. +#define md_generic_sel_entry_comma_delimiter md_select_arg_3 // Use the arg expansion macro to select arg 3 which should have the comma delimiter ','. #endif -#ifndef generic_call -#define generic_call // Just used to indicate where the call "occurs" +#ifndef md_generic_call +#define md_generic_call // Just used to indicate where the call "occurs" #endif // ---------------------------------------------------------------------------------------------------------------------------------- -#ifndef if_generic_selector_defined_include_slot -// if_generic_selector_defined_include_slot( macro ) includes a _Generic slot only if the specified macro is defined (as type, function_name). +#ifndef md_if_generic_selector_defined_include_slot +// md_if_generic_selector_defined_include_slot( macro ) includes a _Generic slot only if the specified macro is defined (as type, function_name). // It takes advantage of the fact that if the macro is defined, then the expanded text will contain a comma. // Expands to ',' if it can find (type): (function) -// Where generic_sel_entry_comma_delimiter is specifically looking for that , -#define if_generic_selector_defined_include_slot( slot_exp ) generic_sel_entry_comma_delimiter( slot_exp, generic_sel_entry_type( slot_exp, ): generic_sel_entry_function( slot_exp, ) COMMA_OPERATOR, , ) +// Where md_generic_sel_entry_comma_delimiter is specifically looking for that , +#define md_if_generic_selector_defined_include_slot( slot_exp ) md_generic_sel_entry_comma_delimiter( slot_exp, md_generic_sel_entry_type( slot_exp, ): md_generic_sel_entry_function( slot_exp, ) MD_COMMA_OPERATOR, , ) // ^ Selects the comma ^ is the type ^ is the function ^ Insert a comma // The slot won't exist if that comma is not found. #endif // For the occastion where an expression didn't resolve to a selection option the "default: " will be set to: -typedef struct UNRESOLVED_GENERIC_SELECTION UNRESOLVED_GENERIC_SELECTION; -struct UNRESOLVED_GENERIC_SELECTION { +typedef struct MD_UNRESOLVED_GENERIC_SELECTION MD_UNRESOLVED_GENERIC_SELECTION; +struct MD_UNRESOLVED_GENERIC_SELECTION { void* _THE_VOID_SLOT_; }; -UNRESOLVED_GENERIC_SELECTION const assert_generic_sel_fail = {0}; +MD_UNRESOLVED_GENERIC_SELECTION const md_assert_generic_sel_fail = {0}; // Which will provide the message: error: called object type 'struct NO_RESOLVED_GENERIC_SELECTION' is not a function or function pointer // ---------------------------------------------------------------------------------------------------------------------------------- @@ -63,10 +61,10 @@ UNRESOLVED_GENERIC_SELECTION const assert_generic_sel_fail = {0}; #define function_generic_example( selector_arg ) _Generic( \ (selector_arg), /* Select Via Expression*/ \ /* Extendibility slots: */ \ - if_generic_selector_defined_include_slot( GENERIC_SLOT_1__function_sig ) \ - if_generic_selector_defined_include_slot( GENERIC_SLOT_2__function_sig ) \ - default: assert_generic_sel_fail \ -) generic_call( selector_arg ) + md_if_generic_selector_defined_include_slot( MD_GENERIC_SLOT_1__function_sig ) \ + md_if_generic_selector_defined_include_slot( GENERIC_SLOT_2__function_sig ) \ + default: md_assert_generic_sel_fail \ +) md_generic_call( selector_arg ) // ---------------------------------------------------------------------------------------------------------------------------------- // Then each definiton of a function has an associated define: @@ -78,56 +76,56 @@ UNRESOLVED_GENERIC_SELECTION const assert_generic_sel_fail = {0}; // Concrete example: // To add support for long: -#define GENERIC_SLOT_1__example_hash long, generic_example_hash__P_long -size_t generic_example_hash__P_long( long val ) { return val * 2654435761ull; } +#define MD_GENERIC_SLOT_1__example_hash long, md_generic_example_hash__P_long +size_t md_generic_example_hash__P_long( long val ) { return val * 2654435761ull; } // To add support for long long: -#define GENERIC_SLOT_2__example_hash long long, generic_example_hash__P_long_long -size_t generic_example_hash__P_long_long( long long val ) { return val * 2654435761ull; } +#define GENERIC_SLOT_2__example_hash long long, md_generic_example_hash__P_long_long +size_t md_generic_example_hash__P_long_long( long long val ) { return val * 2654435761ull; } // If using an Editor with support for syntax hightlighting macros: -// GENERIC_SLOT_1__example_hash and GENERIC_SLOT_2__example_hash should show color highlighting indicating the slot is enabled, +// MD_GENERIC_SLOT_1__example_hash and GENERIC_SLOT_2__example_hash should show color highlighting indicating the slot is enabled, // or, "defined" for usage during the compilation pass that handles the _Generic instrinsic. #define generic_example_hash( function_arguments ) _Generic( \ (function_arguments), /* Select Via Expression*/ \ /* Extendibility slots: */ \ - if_generic_selector_defined_include_slot( GENERIC_SLOT_1__example_hash ) \ - if_generic_selector_defined_include_slot( GENERIC_SLOT_2__example_hash ) \ - if_generic_selector_defined_include_slot( GENERIC_SLOT_3__example_hash ) \ - if_generic_selector_defined_include_slot( GENERIC_SLOT_4__example_hash ) \ - if_generic_selector_defined_include_slot( GENERIC_SLOT_5__example_hash ) \ - if_generic_selector_defined_include_slot( GENERIC_SLOT_6__example_hash ) \ - if_generic_selector_defined_include_slot( GENERIC_SLOT_7__example_hash ) \ - if_generic_selector_defined_include_slot( GENERIC_SLOT_8__example_hash ) \ - default: assert_generic_sel_fail \ -) generic_call( function_arguments ) + md_if_generic_selector_defined_include_slot( MD_GENERIC_SLOT_1__example_hash ) \ + md_if_generic_selector_defined_include_slot( GENERIC_SLOT_2__example_hash ) \ + md_if_generic_selector_defined_include_slot( GENERIC_SLOT_3__example_hash ) \ + md_if_generic_selector_defined_include_slot( GENERIC_SLOT_4__example_hash ) \ + md_if_generic_selector_defined_include_slot( GENERIC_SLOT_5__example_hash ) \ + md_if_generic_selector_defined_include_slot( GENERIC_SLOT_6__example_hash ) \ + md_if_generic_selector_defined_include_slot( GENERIC_SLOT_7__example_hash ) \ + md_if_generic_selector_defined_include_slot( GENERIC_SLOT_8__example_hash ) \ + default: md_assert_generic_sel_fail \ +) md_generic_call( function_arguments ) // Additional Variations: // If the function takes more than one argument the following is used: -#define function_generic_example_varadic( selector_arg, ... ) _Generic( \ +#define md_function_generic_example_varadic( selector_arg, ... ) _Generic( \ (selector_arg), \ - if_generic_selector_defined_include_slot( GENERIC_SLOT_1__function_sig ) \ - if_generic_selector_defined_include_slot( GENERIC_SLOT_2__function_sig ) \ + md_if_generic_selector_defined_include_slot( MD_GENERIC_SLOT_1__function_sig ) \ + md_if_generic_selector_defined_include_slot( GENERIC_SLOT_2__function_sig ) \ /* ... */ \ - if_generic_selector_defined_include_slot(GENERIC_SLOT_N__function_sig ) \ - default: assert_generic_sel_fail \ -) generic_call( selector_arg, __VA_ARG__ ) + md_if_generic_selector_defined_include_slot(GENERIC_SLOT_N__function_sig ) \ + default: md_assert_generic_sel_fail \ +) md_generic_call( selector_arg, __VA_ARG__ ) // If the function does not take the arugment as a parameter: -#define function_generic_example_direct_type( selector_arg ) _Generic( \ -( type_to_expression(selector_arg) ), \ - if_generic_selector_defined_include_slot( GENERIC_SLOT_1__function_sig ) \ - if_generic_selector_defined_include_slot( GENERIC_SLOT_2__function_sig ) \ +#define md_function_generic_example_direct_type( selector_arg ) _Generic( \ +( md_type_to_expression(selector_arg) ), \ + md_if_generic_selector_defined_include_slot( MD_GENERIC_SLOT_1__function_sig ) \ + md_if_generic_selector_defined_include_slot( GENERIC_SLOT_2__function_sig ) \ /* ... */ \ - if_generic_selector_defined_include_slot(GENERIC_SLOT_N__function_sig ) \ - default: assert_generic_sel_fail \ -) generic_call(selector_arg) + md_if_generic_selector_defined_include_slot(GENERIC_SLOT_N__function_sig ) \ + default: md_assert_generic_sel_fail \ +) md_generic_call(selector_arg) -#ifndef type_to_expression +#ifndef md_type_to_expression // Used to keep the _Generic keyword happy as bare types are not considered "expressions" -#define type_to_expression(type) (* (type*)NULL) +#define md_type_to_expression(type) (* (type*)NULL) // Instead of using this macro, it should be directly expanded by code generation. #endif @@ -136,14 +134,14 @@ size_t generic_example_hash__P_long_long( long long val ) { return val * 2654435 #define example_with__l2(expr) _Generic( \ (expr), \ - S64 : example_with_s64, \ - default: assert_generic_sel_fail \ + MD_S64 : example_with_s64, \ + default: md_assert_generic_sel_fail \ ) #define example_with(expr) \ _Generic((expr), \ - SSIZE : example_with_SSIZEZ \ + MD_SSIZE : example_with_SSIZEZ \ default : example_with_not_SSIZE(allocator, in) \ -) generic_call(allocator, in) +) md_generic_call(allocator, in) // This can be made more concise with he following "layer" indicating _Generic macros @@ -152,21 +150,21 @@ _Generic((expr), \ #define example_with_generic_layers(expr) \ _Generic( (expr), \ - S64 : example_with_s64, \ + MD_S64 : example_with_s64, \ _Generic_L2((expr), \ - SSIZE: example_with_SSIZZE \ - default: assert_generic_sel_fail \ + MD_SSIZE: example_with_SSIZZE \ + default: md_assert_generic_sel_fail \ ), \ -) generic_call(expr) +) md_generic_call(expr) // Removing example definitions #undef example_with #undef example_with__l2 #undef example_with_generic_layers #undef function_generic_example -#undef GENERIC_SLOT_1__example_hash +#undef MD_GENERIC_SLOT_1__example_hash #undef GENERIC_SLOT_2__example_hash #undef generic_example_hash -#undef function_generic_example_varadic -#undef function_generic_example_direct_type +#undef md_function_generic_example_varadic +#undef md_function_generic_example_direct_type #undef generic_example_do_something_with diff --git a/source/base/linkage.h b/source/base/linkage.h index 4280ac5..e7f7449 100644 --- a/source/base/linkage.h +++ b/source/base/linkage.h @@ -4,9 +4,9 @@ #endif #ifndef MD_API -#if COMPILER_MSVC -# if BUILD_DYANMIC -# if BUILD_API_EXPORT +#if MD_COMPILER_MSVC +# if MD_BUILD_DYANMIC +# if MD_BUILD_API_EXPORT # define MD_API __declspec(dllexport) # else # define MD_API __declspec(dllimport) @@ -15,7 +15,7 @@ # define MD_API // Empty for static builds # endif #else -# ifdef BUILD_DYANMIC +# ifdef MD_BUILD_DYANMIC # define MD_API __attribute__((visibility("default"))) # else # define MD_API // Empty for static builds @@ -24,7 +24,7 @@ #endif // GEN_API #ifndef MD_API_C_BEGIN -# if LANG_C +# if MD_LANG_C # define MD_API_C_BEGIN # define MD_API_C_END # define MD_API_C @@ -35,15 +35,15 @@ # endif #endif -#ifndef global // Global variables -# if BUILD_API_EXPORT || BUILD_STATIC -# define global +#ifndef md_global // Global variables +# if MD_BUILD_API_EXPORT || MD_BUILD_STATIC +# define md_global # else -# define global static +# define md_global static # endif #endif // Internal Linkage -#ifndef internal -#define internal static +#ifndef md_internal +#define md_internal static #endif diff --git a/source/base/logger.c b/source/base/logger.c index 72af63b..3a204a7 100644 --- a/source/base/logger.c +++ b/source/base/logger.c @@ -9,40 +9,40 @@ //////////////////////////////// //~ rjf: Globals/Thread-Locals -MD_API_C thread_static Log* log_active; -#if !BUILD_SUPPLEMENTARY_UNIT -MD_API_C thread_static Log* log_active = 0; +MD_API_C md_thread_static MD_Log* md_log_active; +#if !MD_BUILD_SUPPLEMENTARY_UNIT +MD_API_C md_thread_static MD_Log* md_log_active = 0; #endif //////////////////////////////// -//~ rjf: Log Creation/Selection +//~ rjf: MD_Log Creation/Selection void -log_select(Log* log) { - log_active = log; +md_log_select(MD_Log* log) { + md_log_active = log; } //////////////////////////////// -//~ rjf: Log Building +//~ rjf: MD_Log Building void -log_msg(LogMsgKind kind, String8 string) { - if(log_active != 0 && log_active->top_scope != 0) { - String8 string_copy = str8_copy(log_active->arena, string); - str8_list_push(log_active->arena, &log_active->top_scope->strings[kind], string_copy); +md_log_msg(MD_LogMsgKind kind, MD_String8 string) { + if(md_log_active != 0 && md_log_active->top_scope != 0) { + MD_String8 md_string_copy = md_str8_copy(md_log_active->arena, string); + md_str8_list_push(md_log_active->arena, &md_log_active->top_scope->strings[kind], md_string_copy); } } void -log_msgf(LogMsgKind kind, char *fmt, ...) { - if(log_active != 0) +md_log_msgf(MD_LogMsgKind kind, char *fmt, ...) { + if(md_log_active != 0) { - TempArena scratch = scratch_begin(0, 0); + MD_TempArena scratch = md_scratch_begin(0, 0); va_list args; va_start(args, fmt); - String8 string = str8fv(scratch.arena, fmt, args); - log_msg(kind, string); + MD_String8 string = md_str8fv(scratch.arena, fmt, args); + md_log_msg(kind, string); va_end(args); scratch_end(scratch); @@ -50,39 +50,39 @@ log_msgf(LogMsgKind kind, char *fmt, ...) { } //////////////////////////////// -//~ rjf: Log Scopes +//~ rjf: MD_Log Scopes void -log_scope_begin(void) { - if (log_active != 0) { - U64 pos = arena_pos(log_active->arena); - LogScope* scope = push_array(log_active->arena, LogScope, 1); +md_log_scope_begin(void) { + if (md_log_active != 0) { + MD_U64 pos = md_arena_pos(md_log_active->arena); + MD_LogScope* scope = md_push_array_(md_log_active->arena, MD_LogScope, 1); scope->pos = pos; - sll_stack_push(log_active->top_scope, scope); + md_sll_stack_push(md_log_active->top_scope, scope); } } -LogScopeResult -log_scope_end(Arena *arena) +MD_LogScopeResult +md_log_scope_end(MD_Arena *arena) { - LogScopeResult result = {0}; - if(log_active != 0) + MD_LogScopeResult result = {0}; + if(md_log_active != 0) { - LogScope* scope = log_active->top_scope; + MD_LogScope* scope = md_log_active->top_scope; if(scope != 0) { - sll_stack_pop(log_active->top_scope); + md_sll_stack_pop(md_log_active->top_scope); if(arena != 0) { - for (each_enum_val(LogMsgKind, kind)) { - TempArena scratch = scratch_begin(&arena, 1); - String8 - result_unindented = str8_list_join(scratch.arena, &scope->strings[kind], 0); - result.strings[kind] = indented_from_string(arena, result_unindented); + for (md_each_enum_val(MD_LogMsgKind, kind)) { + MD_TempArena scratch = md_scratch_begin(&arena, 1); + MD_String8 + result_unindented = md_str8_list_join(scratch.arena, &scope->strings[kind], 0); + result.strings[kind] = md_indented_from_string(arena, result_unindented); scratch_end(scratch); } } - arena_pop_to(log_active->arena, scope->pos); + md_arena_pop_to(md_log_active->arena, scope->pos); } } return result; diff --git a/source/base/logger.h b/source/base/logger.h index 48957ff..4f491fa 100644 --- a/source/base/logger.h +++ b/source/base/logger.h @@ -10,77 +10,77 @@ // Licensed under the MIT license (https://opensource.org/license/mit/) //////////////////////////////// -//~ rjf: Log Types +//~ rjf: MD_Log Types -typedef enum LogMsgKind LogMsgKind; -enum LogMsgKind +typedef enum MD_LogMsgKind MD_LogMsgKind; +enum MD_LogMsgKind { - LogMsgKind_Info, - LogMsgKind_UserError, - LogMsgKind_COUNT + MD_LogMsgKind_Info, + MD_LogMsgKind_UserError, + MD_LogMsgKind_COUNT }; -typedef struct LogScope LogScope; -struct LogScope +typedef struct MD_LogScope MD_LogScope; +struct MD_LogScope { - LogScope* next; - U64 pos; - String8List strings[LogMsgKind_COUNT]; + MD_LogScope* next; + MD_U64 pos; + MD_String8List strings[MD_LogMsgKind_COUNT]; }; -typedef struct LogScopeResult LogScopeResult; -struct LogScopeResult +typedef struct MD_LogScopeResult MD_LogScopeResult; +struct MD_LogScopeResult { - String8 strings[LogMsgKind_COUNT]; + MD_String8 strings[MD_LogMsgKind_COUNT]; }; -typedef struct Log Log; -struct Log +typedef struct MD_Log MD_Log; +struct MD_Log { - Arena* arena; - LogScope* top_scope; + MD_Arena* arena; + MD_LogScope* top_scope; }; -#ifndef LOG_DEFAULT_ARENA_BLOCK_SIZE -#define LOG_DEFAULT_ARENA_BLOCK_SIZE VARENA_DEFAULT_RESERVE +#ifndef MD_LOG_DEFAULT_ARENA_BLOCK_SIZE +#define MD_LOG_DEFAULT_ARENA_BLOCK_SIZE MD_VARENA_DEFAULT_RESERVE #endif //////////////////////////////// -//~ rjf: Log Creation/Selection +//~ rjf: MD_Log Creation/Selection - Log* log_alloc(AllocatorInfo ainfo, U64 arena_block_size); - void log_release(Log* log); -MD_API void log_select (Log* log); + MD_Log* md_log_alloc(MD_AllocatorInfo ainfo, MD_U64 md_arena_block_size); + void md_log_release(MD_Log* log); +MD_API void md_log_select (MD_Log* log); -inline Log* -log_alloc(AllocatorInfo ainfo, U64 arena_block_size) { - if (arena_block_size == 0) { - arena_block_size = LOG_DEFAULT_ARENA_BLOCK_SIZE; +inline MD_Log* +md_log_alloc(MD_AllocatorInfo ainfo, MD_U64 md_arena_block_size) { + if (md_arena_block_size == 0) { + md_arena_block_size = MD_LOG_DEFAULT_ARENA_BLOCK_SIZE; } - Arena* arena = arena_alloc(.backing = ainfo, .block_size = arena_block_size); - Log* log = push_array(arena, Log, 1); + MD_Arena* arena = md_arena_alloc(.backing = ainfo, .block_size = md_arena_block_size); + MD_Log* log = md_push_array_(arena, MD_Log, 1); log->arena = arena; return log; } -inline void log_release(Log* log) { arena_release(log->arena); } +inline void md_log_release(MD_Log* log) { md_arena_release(log->arena); } //////////////////////////////// -//~ rjf: Log Building +//~ rjf: MD_Log Building -MD_API void log_msg (LogMsgKind kind, String8 string); -MD_API void log_msgf(LogMsgKind kind, char* fmt, ...); +MD_API void md_log_msg (MD_LogMsgKind kind, MD_String8 string); +MD_API void md_log_msgf(MD_LogMsgKind kind, char* fmt, ...); -#define log_info(s) log_msg (LogMsgKind_Info, (s)) -#define log_infof(fmt, ...) log_msgf(LogMsgKind_Info, (fmt), __VA_ARGS__) -#define log_user_error(s) log_msg (LogMsgKind_UserError, (s)) -#define log_user_errorf(fmt, ...) log_msgf(LogMsgKind_UserError, (fmt), __VA_ARGS__) +#define md_log_info(s) md_log_msg (MD_LogMsgKind_Info, (s)) +#define md_log_infof(fmt, ...) md_log_msgf(MD_LogMsgKind_Info, (fmt), __VA_ARGS__) +#define md_log_user_error(s) md_log_msg (MD_LogMsgKind_UserError, (s)) +#define md_log_user_errorf(fmt, ...) md_log_msgf(MD_LogMsgKind_UserError, (fmt), __VA_ARGS__) -#define log_info_named_block(s) defer_loop(log_infof("%S:\n{\n", (s)), log_infof("}\n")) -#define log_info_named_blockf(fmt, ...) defer_loop((log_infof(fmt, __VA_ARGS__), log_infof(":\n{\n")), log_infof("}\n")) +#define md_log_info_named_block(s) md_defer_loop(md_log_infof("%S:\n{\n", (s)), md_log_infof("}\n")) +#define md_log_info_named_blockf(fmt, ...) md_defer_loop((md_log_infof(fmt, __VA_ARGS__), md_log_infof(":\n{\n")), md_log_infof("}\n")) //////////////////////////////// -//~ rjf: Log Scopes +//~ rjf: MD_Log Scopes - void log_scope_begin(void); -MD_API LogScopeResult log_scope_end(Arena* arena); + void md_log_scope_begin(void); +MD_API MD_LogScopeResult md_log_scope_end(MD_Arena* arena); diff --git a/source/base/macros.h b/source/base/macros.h index 1d8de2c..8b995ef 100644 --- a/source/base/macros.h +++ b/source/base/macros.h @@ -7,71 +7,71 @@ //////////////////////////////// //~ rjf: Branch Predictor Hints -#if COMPILER_CLANG -# define expect(expr, val) __builtin_expect((expr), (val)) +#if MD_COMPILER_CLANG +# define md_expect(expr, val) __builtin_expect((expr), (val)) #else -# define expect(expr, val) (expr) +# define md_expect(expr, val) (expr) #endif -#define likely(expr) expect(expr, 1) -#define unlikely(expr) expect(expr, 0) +#define md_likely(expr) md_expect(expr, 1) +#define md_unlikely(expr) md_expect(expr, 0) //////////////////////////////// //~ erg: type casting -#if LANG_CPP -# ifndef ccast -# define ccast( type, value ) ( const_cast< type >( (value) ) ) +#if MD_LANG_CPP +# ifndef md_ccast +# define md_ccast( type, value ) ( const_cast< type >( (value) ) ) # endif -# ifndef pcast -# define pcast( type, value ) ( * reinterpret_cast< type* >( & ( value ) ) ) +# ifndef md_pcast +# define md_pcast( type, value ) ( * reinterpret_cast< type* >( & ( value ) ) ) # endif -# ifndef rcast -# define rcast( type, value ) reinterpret_cast< type >( value ) +# ifndef md_rcast +# define md_rcast( type, value ) reinterpret_cast< type >( value ) # endif -# ifndef scast -# define scast( type, value ) static_cast< type >( value ) +# ifndef md_scast +# define md_scast( type, value ) static_cast< type >( value ) # endif #else -# ifndef ccast -# define ccast( type, value ) ( (type)(value) ) +# ifndef md_ccast +# define md_ccast( type, value ) ( (type)(value) ) # endif -# ifndef pcast -# define pcast( type, value ) ( * (type*)(& value) ) +# ifndef md_pcast +# define md_pcast( type, value ) ( * (type*)(& value) ) # endif -# ifndef rcast -# define rcast( type, value ) ( (type)(value) ) +# ifndef md_rcast +# define md_rcast( type, value ) ( (type)(value) ) # endif -# ifndef scast -# define scast( type, value ) ( (type)(value) ) +# ifndef md_scast +# define md_scast( type, value ) ( (type)(value) ) # endif #endif -#if ! defined(typeof) && ( ! LANG_C || __STDC_VERSION__ < 202311L) -# if ! LANG_C +#if ! defined(typeof) && ( ! MD_LANG_C || __STDC_VERSION__ < 202311L) +# if ! MD_LANG_C # define typeof decltype # elif defined(_MSC_VER) # define typeof __typeof__ # elif defined(__GNUC__) || defined(__clang__) # define typeof __typeof__ # else -# error "Compiler not supported" +# error "MD_Compiler not supported" # endif #endif -#if LANG_C +#if MD_LANG_C # if __STDC_VERSION__ >= 202311L -# define enum_underlying(type) : type +# define md_enum_underlying(type) : type # else -# define enum_underlying(type) +# define md_enum_underlying(type) # endif #else -# define enum_underlying(type) : type +# define md_enum_underlying(type) : type #endif -#if LANG_C -# ifndef nullptr -# define nullptr NULL +#if MD_LANG_C +# ifndef md_nullptr +# define md_nullptr NULL # endif # ifndef MD_REMOVE_PTR @@ -79,13 +79,13 @@ # endif #endif -#if ! defined(PARAM_DEFAULT) && LANG_CPP -# define PARAM_DEFAULT = {} +#if ! defined(MD_PARAM_DEFAULT) && MD_LANG_CPP +# define MD_PARAM_DEFAULT = {} #else -# define PARAM_DEFAULT +# define MD_PARAM_DEFAULT #endif -#if LANG_C +#if MD_LANG_C # ifndef static_assert # undef static_assert # if __STDC_VERSION__ >= 201112L @@ -96,86 +96,86 @@ # endif #endif -#ifndef force_inline -# if COMPILER_MSVC -# define force_inline __forceinline -# elif COMPILER_GCC -# define force_inline inline __attribute__((__always_inline__)) -# elif COMPILER_CLANG +#ifndef md_force_inline +# if MD_COMPILER_MSVC +# define md_force_inline __forceinline +# elif MD_COMPILER_GCC +# define md_force_inline inline __attribute__((__always_inline__)) +# elif MD_COMPILER_CLANG # if __has_attribute(__always_inline__) -# define force_inline inline __attribute__((__always_inline__)) +# define md_force_inline inline __attribute__((__always_inline__)) # else -# define force_inline +# define md_force_inline # endif # else -# define force_inline +# define md_force_inline # endif #endif -#ifndef never_inline -# if COMPILER_MSVC -# define never_inline __declspec( noinline ) -# elif COMPILER_GCC -# define never_inline __attribute__( ( __noinline__ ) ) -# elif COMPILER_CLANG +#ifndef md_never_inline +# if MD_COMPILER_MSVC +# define md_never_inline __declspec( noinline ) +# elif MD_COMPILER_GCC +# define md_never_inline __attribute__( ( __noinline__ ) ) +# elif MD_COMPILER_CLANG # if __has_attribute(__always_inline__) -# define never_inline __attribute__( ( __noinline__ ) ) +# define md_never_inline __attribute__( ( __noinline__ ) ) # else -# define never_inline +# define md_never_inline # endif # else -# define never_inline +# define md_never_inline # endif #endif //////////////////////////////// //~ rjf: For-Loop Construct Macros -#ifndef defer_loop -#define defer_loop(begin, end) for (int _i_ = ((begin), 0); ! _i_; _i_ += 1, (end)) +#ifndef md_defer_loop +#define md_defer_loop(begin, end) for (int _i_ = ((begin), 0); ! _i_; _i_ += 1, (end)) #endif -#ifndef defer_loop_checked -#define defer_loop_checked(begin, end) for (int _i_ = 2 * ! (begin); (_i_ == 2 ? ((end), 0) : !_i_); _i_ += 1, (end)) +#ifndef md_defer_loop_checked +#define md_defer_loop_checked(begin, end) for (int _i_ = 2 * ! (begin); (_i_ == 2 ? ((end), 0) : !_i_); _i_ += 1, (end)) #endif -#ifndef each_enum_val -#define each_enum_val(type, it) type it = (type) 0; it < type ## _COUNT; it = (type)( it + 1 ) +#ifndef md_each_enum_val +#define md_each_enum_val(type, it) type it = (type) 0; it < type ## _COUNT; it = (type)( it + 1 ) #endif -#ifndef each_non_zero_enum_val -#define each_non_zero_enum_val(type, it) type it = (type) 1; it < type ## _COUNT; it = (type)( it + 1 ) +#ifndef md_each_non_zero_enum_val +#define md_each_non_zero_enum_val(type, it) type it = (type) 1; it < type ## _COUNT; it = (type)( it + 1 ) #endif -#ifndef stringify -#define stringify_(S) #S -#define stringify(S) stringify_(S) +#ifndef md_stringify +#define md_stringify_(S) #S +#define md_stringify(S) md_stringify_(S) #endif -#ifndef glue -#define glue_(A, B) A ## B -#define glue(A, B) glue_(A,B) +#ifndef md_glue +#define md_glue_(A, B) A ## B +#define md_glue(A, B) md_glue_(A,B) #endif -#define src_line_str stringify(__LINE__) +#define md_src_line_str md_stringify(__LINE__) -#ifndef do_once -#define do_once() \ - local_persist int __do_once_counter_##src_line_str = 0; \ - for(; __do_once_counter_##src_line_str != 1; __do_once_counter_##src_line_str = 1 ) \ +#ifndef md_do_once +#define md_do_once() \ + md_local_persist int __do_once_counter_##md_src_line_str = 0; \ + for(; __do_once_counter_##md_src_line_str != 1; __do_once_counter_##md_src_line_str = 1 ) \ -#define do_once_defer( expression ) \ - local_persist int __do_once_counter_##src_line_str = 0; \ - for(;__do_once_counter_##src_line_str != 1; __do_once_counter_##src_line_str = 1, (expression)) \ +#define md_do_once_defer( expression ) \ + md_local_persist int __do_once_counter_##md_src_line_str = 0; \ + for(;__do_once_counter_##md_src_line_str != 1; __do_once_counter_##md_src_line_str = 1, (expression)) \ -#define do_once_start \ +#define md_do_once_start \ do \ { \ - local_persist \ + md_local_persist \ bool done = false; \ if ( done ) \ break; \ done = true; -#define do_once_end \ +#define md_do_once_end \ } \ while(0); #endif diff --git a/source/base/markup.c b/source/base/markup.c index 8f03233..aac2d26 100644 --- a/source/base/markup.c +++ b/source/base/markup.c @@ -4,7 +4,7 @@ #endif inline void -set_thread_name(String8 string) { - prof_thread_name("%.*s", str8_varg(string)); - os_set_thread_name(string); +md_set_thread_name(MD_String8 string) { + md_prof_thread_name("%.*s", md_str8_varg(string)); + md_os_set_thread_name(string); } diff --git a/source/base/markup.h b/source/base/markup.h index bfaf878..ea129d5 100644 --- a/source/base/markup.h +++ b/source/base/markup.h @@ -8,21 +8,21 @@ // Copyright (c) 2024 Epic Games Tools // Licensed under the MIT license (https://opensource.org/license/mit/) -MD_API void set_thread_name(String8 string); +MD_API void md_set_thread_name(MD_String8 string); inline void -set_thread_namef(char *fmt, ...) +md_set_thread_namef(char *fmt, ...) { - TempArena scratch = scratch_begin(0, 0); + MD_TempArena scratch = md_scratch_begin(0, 0); va_list args; va_start(args, fmt); - String8 string = str8fv(scratch.arena, fmt, args); - set_thread_name(string); + MD_String8 string = md_str8fv(scratch.arena, fmt, args); + md_set_thread_name(string); va_end(args); scratch_end(scratch); } -#define thread_namef(...) (set_thread_namef(__VA_ARGS__)) -#define thread_name(str) (set_thread_name(str)) +#define md_thread_namef(...) (md_set_thread_namef(__VA_ARGS__)) +#define md_thread_name(str) (md_set_thread_name(str)) diff --git a/source/base/math.h b/source/base/math.h index 4247f95..3418216 100644 --- a/source/base/math.h +++ b/source/base/math.h @@ -17,167 +17,167 @@ //- rjf: 2-vectors -typedef union Vec2F32 Vec2F32; -union Vec2F32 +typedef union MD_Vec2F32 MD_Vec2F32; +union MD_Vec2F32 { struct { - F32 x; - F32 y; + MD_F32 x; + MD_F32 y; }; - F32 v[2]; + MD_F32 v[2]; }; -typedef union Vec2S64 Vec2S64; -union Vec2S64 +typedef union MD_Vec2S64 MD_Vec2S64; +union MD_Vec2S64 { struct { - S64 x; - S64 y; + MD_S64 x; + MD_S64 y; }; - S64 v[2]; + MD_S64 v[2]; }; -typedef union Vec2S32 Vec2S32; -union Vec2S32 +typedef union MD_Vec2S32 MD_Vec2S32; +union MD_Vec2S32 { struct { - S32 x; - S32 y; + MD_S32 x; + MD_S32 y; }; - S32 v[2]; + MD_S32 v[2]; }; -typedef union Vec2S16 Vec2S16; -union Vec2S16 +typedef union MD_Vec2S16 MD_Vec2S16; +union MD_Vec2S16 { struct { - S16 x; - S16 y; + MD_S16 x; + MD_S16 y; }; - S16 v[2]; + MD_S16 v[2]; }; //- rjf: 3-vectors -typedef union Vec3F32 Vec3F32; -union Vec3F32 +typedef union MD_Vec3F32 MD_Vec3F32; +union MD_Vec3F32 { struct { - F32 x; - F32 y; - F32 z; + MD_F32 x; + MD_F32 y; + MD_F32 z; }; struct { - Vec2F32 xy; - F32 _z0; + MD_Vec2F32 xy; + MD_F32 _z0; }; struct { - F32 _x0; - Vec2F32 yz; + MD_F32 _x0; + MD_Vec2F32 yz; }; - F32 v[3]; + MD_F32 v[3]; }; -typedef union Vec3S32 Vec3S32; -union Vec3S32 +typedef union MD_Vec3S32 MD_Vec3S32; +union MD_Vec3S32 { struct { - S32 x; - S32 y; - S32 z; + MD_S32 x; + MD_S32 y; + MD_S32 z; }; struct { - Vec2S32 xy; - S32 _z0; + MD_Vec2S32 xy; + MD_S32 _z0; }; struct { - S32 _x0; - Vec2S32 yz; + MD_S32 _x0; + MD_Vec2S32 yz; }; - S32 v[3]; + MD_S32 v[3]; }; //- rjf: 4-vectors -typedef union Vec4F32 Vec4F32; -union Vec4F32 +typedef union MD_Vec4F32 MD_Vec4F32; +union MD_Vec4F32 { struct { - F32 x; - F32 y; - F32 z; - F32 w; + MD_F32 x; + MD_F32 y; + MD_F32 z; + MD_F32 w; }; struct { - Vec2F32 xy; - Vec2F32 zw; + MD_Vec2F32 xy; + MD_Vec2F32 zw; }; struct { - Vec3F32 xyz; - F32 _z0; + MD_Vec3F32 xyz; + MD_F32 _z0; }; struct { - F32 _x0; - Vec3F32 yzw; + MD_F32 _x0; + MD_Vec3F32 yzw; }; - F32 v[4]; + MD_F32 v[4]; }; -typedef union Vec4S32 Vec4S32; -union Vec4S32 +typedef union MD_Vec4S32 MD_Vec4S32; +union MD_Vec4S32 { struct { - S32 x; - S32 y; - S32 z; - S32 w; + MD_S32 x; + MD_S32 y; + MD_S32 z; + MD_S32 w; }; struct { - Vec2S32 xy; - Vec2S32 zw; + MD_Vec2S32 xy; + MD_Vec2S32 zw; }; struct { - Vec3S32 xyz; - S32 _z0; + MD_Vec3S32 xyz; + MD_S32 _z0; }; struct { - S32 _x0; - Vec3S32 yzw; + MD_S32 _x0; + MD_Vec3S32 yzw; }; - S32 v[4]; + MD_S32 v[4]; }; //////////////////////////////// //~ rjf: Matrix Types -typedef struct Mat3x3F32 Mat3x3F32; -struct Mat3x3F32 +typedef struct MD_Mat3x3F32 MD_Mat3x3F32; +struct MD_Mat3x3F32 { - F32 v[3][3]; + MD_F32 v[3][3]; }; -typedef struct Mat4x4F32 Mat4x4F32; -struct Mat4x4F32 +typedef struct MD_Mat4x4F32 MD_Mat4x4F32; +struct MD_Mat4x4F32 { - F32 v[4][4]; + MD_F32 v[4][4]; }; //////////////////////////////// @@ -185,37 +185,37 @@ struct Mat4x4F32 //- rjf: 1-range -typedef union Rng1U32 Rng1U32; -union Rng1U32 +typedef union MD_Rng1U32 MD_Rng1U32; +union MD_Rng1U32 { struct { - U32 min; - U32 max; + MD_U32 md_min; + MD_U32 md_max; }; - U32 v[2]; + MD_U32 v[2]; }; -typedef union Rng1S32 Rng1S32; -union Rng1S32 +typedef union MD_Rng1S32 MD_Rng1S32; +union MD_Rng1S32 { struct { - S32 min; - S32 max; + MD_S32 md_min; + MD_S32 md_max; }; - S32 v[2]; + MD_S32 v[2]; }; -typedef union Rng1U64 Rng1U64; -union Rng1U64 +typedef union MD_Rng1U64 MD_Rng1U64; +union MD_Rng1U64 { struct { - U64 min; - U64 max; + MD_U64 md_min; + MD_U64 md_max; }; - U64 v[2]; + MD_U64 v[2]; }; typedef union Rng1S64 Rng1S64; @@ -223,10 +223,10 @@ union Rng1S64 { struct { - S64 min; - S64 max; + MD_S64 md_min; + MD_S64 md_max; }; - S64 v[2]; + MD_S64 v[2]; }; typedef union Rng1F32 Rng1F32; @@ -234,129 +234,129 @@ union Rng1F32 { struct { - F32 min; - F32 max; + MD_F32 md_min; + MD_F32 md_max; }; - F32 v[2]; + MD_F32 v[2]; }; //- rjf: 2-range (rectangles) -typedef union Rng2S16 Rng2S16; -union Rng2S16 +typedef union MD_Rng2S16 MD_Rng2S16; +union MD_Rng2S16 { struct { - Vec2S16 min; - Vec2S16 max; + MD_Vec2S16 md_min; + MD_Vec2S16 md_max; }; struct { - Vec2S16 p0; - Vec2S16 p1; + MD_Vec2S16 p0; + MD_Vec2S16 p1; }; struct { - S16 x0; - S16 y0; - S16 x1; - S16 y1; + MD_S16 x0; + MD_S16 y0; + MD_S16 x1; + MD_S16 y1; }; - Vec2S16 v[2]; + MD_Vec2S16 v[2]; }; -typedef union Rng2S32 Rng2S32; -union Rng2S32 +typedef union MD_Rng2S32 MD_Rng2S32; +union MD_Rng2S32 { struct { - Vec2S32 min; - Vec2S32 max; + MD_Vec2S32 md_min; + MD_Vec2S32 md_max; }; struct { - Vec2S32 p0; - Vec2S32 p1; + MD_Vec2S32 p0; + MD_Vec2S32 p1; }; struct { - S32 x0; - S32 y0; - S32 x1; - S32 y1; + MD_S32 x0; + MD_S32 y0; + MD_S32 x1; + MD_S32 y1; }; - Vec2S32 v[2]; + MD_Vec2S32 v[2]; }; -typedef union Rng2F32 Rng2F32; -union Rng2F32 +typedef union MD_Rng2F32 MD_Rng2F32; +union MD_Rng2F32 { struct { - Vec2F32 min; - Vec2F32 max; + MD_Vec2F32 md_min; + MD_Vec2F32 md_max; }; struct { - Vec2F32 p0; - Vec2F32 p1; + MD_Vec2F32 p0; + MD_Vec2F32 p1; }; struct { - F32 x0; - F32 y0; - F32 x1; - F32 y1; + MD_F32 x0; + MD_F32 y0; + MD_F32 x1; + MD_F32 y1; }; - Vec2F32 v[2]; + MD_Vec2F32 v[2]; }; -typedef union Rng2S64 Rng2S64; -union Rng2S64 +typedef union MD_Rng2S64 MD_Rng2S64; +union MD_Rng2S64 { struct { - Vec2S64 min; - Vec2S64 max; + MD_Vec2S64 md_min; + MD_Vec2S64 md_max; }; struct { - Vec2S64 p0; - Vec2S64 p1; + MD_Vec2S64 p0; + MD_Vec2S64 p1; }; struct { - S64 x0; - S64 y0; - S64 x1; - S64 y1; + MD_S64 x0; + MD_S64 y0; + MD_S64 x1; + MD_S64 y1; }; - Vec2S64 v[2]; + MD_Vec2S64 v[2]; }; //////////////////////////////// //~ rjf: List Types -typedef struct Rng1S64Node Rng1S64Node; -struct Rng1S64Node +typedef struct MD_Rng1S64Node MD_Rng1S64Node; +struct MD_Rng1S64Node { - Rng1S64Node* next; + MD_Rng1S64Node* next; Rng1S64 v; }; -typedef struct Rng1S64List Rng1S64List; -struct Rng1S64List +typedef struct MD_Rng1S64List MD_Rng1S64List; +struct MD_Rng1S64List { - Rng1S64Node* first; - Rng1S64Node* last; - U64 count; + MD_Rng1S64Node* first; + MD_Rng1S64Node* last; + MD_U64 count; }; -typedef struct Rng1S64Array Rng1S64Array; -struct Rng1S64Array +typedef struct MD_Rng1S64Array MD_Rng1S64Array; +struct MD_Rng1S64Array { Rng1S64* v; - U64 count; + MD_U64 count; }; //////////////////////////////// @@ -369,248 +369,248 @@ struct Rng1S64Array #define md_max(A, B) (((A) > (B)) ? (A) : (B)) #endif -#ifndef clamp_top -#define clamp_top(A, X) md_min(A, X) +#ifndef md_clamp_top +#define md_clamp_top(A, X) md_min(A, X) #endif -#ifndef clamp_bot -#define clamp_bot(X, B) md_max(X, B) +#ifndef md_clamp_bot +#define md_clamp_bot(X, B) md_max(X, B) #endif -#define clamp(A, X, B) (((X) < (A)) ? (A) : ((X) > (B)) ? (B) : (X)) +#define md_clamp(A, X, B) (((X) < (A)) ? (A) : ((X) > (B)) ? (B) : (X)) //////////////////////////////// //~ rjf: Scalar Ops -#define abs_s64(v) (S64)llabs(v) +#define md_abs_s64(v) (MD_S64)llabs(v) -#define sqrt_f32(v) sqrtf(v) -#define mod_f32(a, b) fmodf((a), (b)) -#define pow_f32(b, e) powf((b), (e)) -#define ceil_f32(v) ceilf(v) -#define floor_f32(v) floorf(v) -#define round_f32(v) roundf(v) -#define abs_f32(v) fabsf(v) +#define md_sqrt_f32(v) sqrtf(v) +#define md_mod_f32(a, b) fmodf((a), (b)) +#define md_pow_f32(b, e) powf((b), (e)) +#define md_ceil_f32(v) ceilf(v) +#define md_floor_f32(v) floorf(v) +#define md_round_f32(v) roundf(v) +#define md_abs_f32(v) fabsf(v) -#define radians_from_turns_f32(v) ((v) * 2 * 3.1415926535897f) -#define turns_from_radians_f32(v) ((v) / 2 * 3.1415926535897f) -#define degrees_from_turns_f32(v) ((v) * 360.f) -#define turns_from_degrees_f32(v) ((v) / 360.f) +#define md_radians_from_turns_f32(v) ((v) * 2 * 3.1415926535897f) +#define md_turns_from_radians_f32(v) ((v) / 2 * 3.1415926535897f) +#define md_degrees_from_turns_f32(v) ((v) * 360.f) +#define md_turns_from_degrees_f32(v) ((v) / 360.f) -#define degrees_from_radians_f32(v) (degrees_from_turns_f32(turns_from_radians_f32(v))) -#define radians_from_degrees_f32(v) (radians_from_turns_f32(turns_from_degrees_f32(v))) +#define md_degrees_from_radians_f32(v) (md_degrees_from_turns_f32(md_turns_from_radians_f32(v))) +#define md_radians_from_degrees_f32(v) (md_radians_from_turns_f32(md_turns_from_degrees_f32(v))) -#define sin_f32(v) sinf( radians_from_turns_f32(v) ) -#define cos_f32(v) cosf( radians_from_turns_f32(v) ) -#define tan_f32(v) tanf( radians_from_turns_f32(v) ) +#define md_sin_f32(v) sinf( md_radians_from_turns_f32(v) ) +#define md_cos_f32(v) cosf( md_radians_from_turns_f32(v) ) +#define md_tan_f32(v) tanf( md_radians_from_turns_f32(v) ) -#define sqrt_f64(v) sqrt(v) -#define mod_f64(a, b) fmod((a), (b)) -#define pow_f64(b, e) pow((b), (e)) -#define ceil_f64(v) ceil(v) -#define floor_f64(v) floor(v) -#define round_f64(v) round(v) -#define abs_f64(v) fabs(v) +#define md_sqrt_f64(v) sqrt(v) +#define md_mod_f64(a, b) fmod((a), (b)) +#define md_pow_f64(b, e) pow((b), (e)) +#define md_ceil_f64(v) ceil(v) +#define md_floor_f64(v) floor(v) +#define md_round_f64(v) round(v) +#define md_abs_f64(v) fabs(v) -#define radians_from_turns_f64(v) ((v) * 2 * 3.1415926535897) -#define turns_from_radians_f64(v) ((v) / 2 * 3.1415926535897) -#define degrees_from_turns_f64(v) ((v) * 360.0) +#define md_radians_from_turns_f64(v) ((v) * 2 * 3.1415926535897) +#define md_turns_from_radians_f64(v) ((v) / 2 * 3.1415926535897) +#define md_degrees_from_turns_f64(v) ((v) * 360.0) #define turns_from_degrees_f64(v) ((v) / 360.0) -#define degrees_from_radians_f64(v) (degrees_from_turns_f64(turns_from_radians_f64(v))) -#define radians_from_degrees_f64(v) (radians_from_turns_f64(turns_from_degrees_f64(v))) +#define md_degrees_from_radians_f64(v) (md_degrees_from_turns_f64(md_turns_from_radians_f64(v))) +#define md_radians_from_degrees_f64(v) (md_radians_from_turns_f64(turns_from_degrees_f64(v))) -#define sin_f64(v) sin(radians_from_turns_f64(v)) -#define cos_f64(v) cos(radians_from_turns_f64(v)) -#define tan_f64(v) tan(radians_from_turns_f64(v)) +#define md_sin_f64(v) sin(md_radians_from_turns_f64(v)) +#define md_cos_f64(v) cos(md_radians_from_turns_f64(v)) +#define md_tan_f64(v) tan(md_radians_from_turns_f64(v)) -inline F32 mix_1f32(F32 a, F32 b, F32 t) { F32 c = (a + (b - a) * clamp(0.f, t, 1.f)); return c; } -inline F64 mix_1f64(F64 a, F64 b, F64 t) { F64 c = (a + (b - a) * clamp(0.0, t, 1.0)); return c; } +inline MD_F32 md_mix_1f32(MD_F32 a, MD_F32 b, MD_F32 t) { MD_F32 c = (a + (b - a) * md_clamp(0.f, t, 1.f)); return c; } +inline MD_F64 md_mix_1f64(MD_F64 a, MD_F64 b, MD_F64 t) { MD_F64 c = (a + (b - a) * md_clamp(0.0, t, 1.0)); return c; } //////////////////////////////// //~ rjf: Vector Ops // ==================== 2D Vectors ==================== -#define v2f32(x, y) vec_2f32((x), (y)) -inline Vec2F32 vec_2f32 (F32 x, F32 y) { Vec2F32 v = { x, y }; return v; } -inline Vec2F32 add_2f32 (Vec2F32 a, Vec2F32 b) { Vec2F32 c = {a.x + b.x, a.y + b.y}; return c; } -inline Vec2F32 sub_2f32 (Vec2F32 a, Vec2F32 b) { Vec2F32 c = {a.x - b.x, a.y - b.y}; return c; } -inline Vec2F32 mul_2f32 (Vec2F32 a, Vec2F32 b) { Vec2F32 c = {a.x * b.x, a.y * b.y}; return c; } -inline Vec2F32 div_2f32 (Vec2F32 a, Vec2F32 b) { Vec2F32 c = {a.x / b.x, a.y / b.y}; return c; } -inline Vec2F32 scale_2f32 (Vec2F32 v, F32 s) { Vec2F32 c = {v.x * s, v.y * s }; return c; } -inline F32 dot_2f32 (Vec2F32 a, Vec2F32 b) { F32 c = a.x * b.x + a.y * b.y; return c; } -inline F32 length_squared_2f32(Vec2F32 v) { F32 c = v.x * v.x + v.y * v.y; return c; } -inline F32 length_2f32 (Vec2F32 v) { F32 c = sqrt_f32(v.x*v.x + v.y*v.y); return c; } -inline Vec2F32 normalize_2f32 (Vec2F32 v) { v = scale_2f32(v, 1.f / length_2f32(v)); return v; } -inline Vec2F32 mix_2f32 (Vec2F32 a, Vec2F32 b, F32 t) { Vec2F32 c = {mix_1f32(a.x, b.x, t), mix_1f32(a.y, b.y, t)}; return c; } +#define md_v2f32(x, y) md_vec_2f32((x), (y)) +inline MD_Vec2F32 md_vec_2f32 (MD_F32 x, MD_F32 y) { MD_Vec2F32 v = { x, y }; return v; } +inline MD_Vec2F32 md_add_2f32 (MD_Vec2F32 a, MD_Vec2F32 b) { MD_Vec2F32 c = {a.x + b.x, a.y + b.y}; return c; } +inline MD_Vec2F32 md_sub_2f32 (MD_Vec2F32 a, MD_Vec2F32 b) { MD_Vec2F32 c = {a.x - b.x, a.y - b.y}; return c; } +inline MD_Vec2F32 md_mul_2f32 (MD_Vec2F32 a, MD_Vec2F32 b) { MD_Vec2F32 c = {a.x * b.x, a.y * b.y}; return c; } +inline MD_Vec2F32 md_div_2f32 (MD_Vec2F32 a, MD_Vec2F32 b) { MD_Vec2F32 c = {a.x / b.x, a.y / b.y}; return c; } +inline MD_Vec2F32 md_scale_2f32 (MD_Vec2F32 v, MD_F32 s) { MD_Vec2F32 c = {v.x * s, v.y * s }; return c; } +inline MD_F32 md_dot_2f32 (MD_Vec2F32 a, MD_Vec2F32 b) { MD_F32 c = a.x * b.x + a.y * b.y; return c; } +inline MD_F32 md_length_squared_2f32(MD_Vec2F32 v) { MD_F32 c = v.x * v.x + v.y * v.y; return c; } +inline MD_F32 md_length_2f32 (MD_Vec2F32 v) { MD_F32 c = md_sqrt_f32(v.x*v.x + v.y*v.y); return c; } +inline MD_Vec2F32 md_normalize_2f32 (MD_Vec2F32 v) { v = md_scale_2f32(v, 1.f / md_length_2f32(v)); return v; } +inline MD_Vec2F32 md_mix_2f32 (MD_Vec2F32 a, MD_Vec2F32 b, MD_F32 t) { MD_Vec2F32 c = {md_mix_1f32(a.x, b.x, t), md_mix_1f32(a.y, b.y, t)}; return c; } -#define v2s64(x, y) vec_2s64((x), (y)) -inline Vec2S64 vec_2s64 (S64 x, S64 y) { Vec2S64 v = { x, y }; return v; } -inline Vec2S64 add_2s64 (Vec2S64 a, Vec2S64 b) { Vec2S64 c = {a.x + b.x, a.y + b.y}; return c; } -inline Vec2S64 sub_2s64 (Vec2S64 a, Vec2S64 b) { Vec2S64 c = {a.x - b.x, a.y - b.y}; return c; } -inline Vec2S64 mul_2s64 (Vec2S64 a, Vec2S64 b) { Vec2S64 c = {a.x * b.x, a.y * b.y}; return c; } -inline Vec2S64 div_2s64 (Vec2S64 a, Vec2S64 b) { Vec2S64 c = {a.x / b.x, a.y / b.y}; return c; } -inline Vec2S64 scale_2s64 (Vec2S64 v, S64 s) { Vec2S64 c = {v.x * s, v.y * s }; return c; } -inline S64 dot_2s64 (Vec2S64 a, Vec2S64 b) { S64 c = a.x * b.x + a.y * b.y; return c; } -inline S64 length_squared_2s64(Vec2S64 v) { S64 c = v.x * v.x + v.y * v.y; return c; } -inline S64 length_2s64 (Vec2S64 v) { S64 c = (S64)sqrt_f64((F64)(v.x*v.x + v.y*v.y)); return c; } -inline Vec2S64 normalize_2s64 (Vec2S64 v) { v = scale_2s64(v, (S64)(1.f / length_2s64(v))); return v; } -inline Vec2S64 mix_2s64 (Vec2S64 a, Vec2S64 b, F32 t) { Vec2S64 c = {(S64)mix_1f32((F32)a.x, (F32)b.x, t), (S64)mix_1f32((F32)a.y, (F32)b.y, t)}; return c; } +#define md_v2s64(x, y) md_vec_2s64((x), (y)) +inline MD_Vec2S64 md_vec_2s64 (MD_S64 x, MD_S64 y) { MD_Vec2S64 v = { x, y }; return v; } +inline MD_Vec2S64 md_add_2s64 (MD_Vec2S64 a, MD_Vec2S64 b) { MD_Vec2S64 c = {a.x + b.x, a.y + b.y}; return c; } +inline MD_Vec2S64 md_sub_2s64 (MD_Vec2S64 a, MD_Vec2S64 b) { MD_Vec2S64 c = {a.x - b.x, a.y - b.y}; return c; } +inline MD_Vec2S64 md_mul_2s64 (MD_Vec2S64 a, MD_Vec2S64 b) { MD_Vec2S64 c = {a.x * b.x, a.y * b.y}; return c; } +inline MD_Vec2S64 md_div_2s64 (MD_Vec2S64 a, MD_Vec2S64 b) { MD_Vec2S64 c = {a.x / b.x, a.y / b.y}; return c; } +inline MD_Vec2S64 md_scale_2s64 (MD_Vec2S64 v, MD_S64 s) { MD_Vec2S64 c = {v.x * s, v.y * s }; return c; } +inline MD_S64 md_dot_2s64 (MD_Vec2S64 a, MD_Vec2S64 b) { MD_S64 c = a.x * b.x + a.y * b.y; return c; } +inline MD_S64 md_length_squared_2s64(MD_Vec2S64 v) { MD_S64 c = v.x * v.x + v.y * v.y; return c; } +inline MD_S64 md_length_2s64 (MD_Vec2S64 v) { MD_S64 c = (MD_S64)md_sqrt_f64((MD_F64)(v.x*v.x + v.y*v.y)); return c; } +inline MD_Vec2S64 md_normalize_2s64 (MD_Vec2S64 v) { v = md_scale_2s64(v, (MD_S64)(1.f / md_length_2s64(v))); return v; } +inline MD_Vec2S64 md_mix_2s64 (MD_Vec2S64 a, MD_Vec2S64 b, MD_F32 t) { MD_Vec2S64 c = {(MD_S64)md_mix_1f32((MD_F32)a.x, (MD_F32)b.x, t), (MD_S64)md_mix_1f32((MD_F32)a.y, (MD_F32)b.y, t)}; return c; } -#define v2s32(x, y) vec_2s32((x), (y)) -inline Vec2S32 vec_2s32 (S32 x, S32 y) { Vec2S32 v = { x, y }; return v; } -inline Vec2S32 add_2s32 (Vec2S32 a, Vec2S32 b) { Vec2S32 c = {a.x + b.x, a.y + b.y}; return c; } -inline Vec2S32 sub_2s32 (Vec2S32 a, Vec2S32 b) { Vec2S32 c = {a.x - b.x, a.y - b.y}; return c; } -inline Vec2S32 mul_2s32 (Vec2S32 a, Vec2S32 b) { Vec2S32 c = {a.x * b.x, a.y * b.y}; return c; } -inline Vec2S32 div_2s32 (Vec2S32 a, Vec2S32 b) { Vec2S32 c = {a.x / b.x, a.y / b.y}; return c; } -inline Vec2S32 scale_2s32 (Vec2S32 v, S32 s) { Vec2S32 c = {v.x * s, v.y * s }; return c; } -inline S32 dot_2s32 (Vec2S32 a, Vec2S32 b) { S32 c = a.x * b.x + a.y * b.y; return c; } -inline S32 length_squared_2s32(Vec2S32 v) { S32 c = v.x * v.x + v.y * v.y; return c; } -inline S32 length_2s32 (Vec2S32 v) { S32 c = (S32)sqrt_f32((F32)v.x*(F32)v.x + (F32)v.y*(F32)v.y); return c; } -inline Vec2S32 normalize_2s32 (Vec2S32 v) { v = scale_2s32(v, (S32)(1.f / length_2s32(v))); return v; } -inline Vec2S32 mix_2s32 (Vec2S32 a, Vec2S32 b, F32 t) { Vec2S32 c = {(S32)mix_1f32((F32)a.x, (F32)b.x, t), (S32)mix_1f32((F32)a.y, (F32)b.y, t)}; return c; } +#define md_v2s32(x, y) md_vec_2s32((x), (y)) +inline MD_Vec2S32 md_vec_2s32 (MD_S32 x, MD_S32 y) { MD_Vec2S32 v = { x, y }; return v; } +inline MD_Vec2S32 md_add_2s32 (MD_Vec2S32 a, MD_Vec2S32 b) { MD_Vec2S32 c = {a.x + b.x, a.y + b.y}; return c; } +inline MD_Vec2S32 md_sub_2s32 (MD_Vec2S32 a, MD_Vec2S32 b) { MD_Vec2S32 c = {a.x - b.x, a.y - b.y}; return c; } +inline MD_Vec2S32 md_mul_2s32 (MD_Vec2S32 a, MD_Vec2S32 b) { MD_Vec2S32 c = {a.x * b.x, a.y * b.y}; return c; } +inline MD_Vec2S32 md_div_2s32 (MD_Vec2S32 a, MD_Vec2S32 b) { MD_Vec2S32 c = {a.x / b.x, a.y / b.y}; return c; } +inline MD_Vec2S32 md_scale_2s32 (MD_Vec2S32 v, MD_S32 s) { MD_Vec2S32 c = {v.x * s, v.y * s }; return c; } +inline MD_S32 md_dot_2s32 (MD_Vec2S32 a, MD_Vec2S32 b) { MD_S32 c = a.x * b.x + a.y * b.y; return c; } +inline MD_S32 md_length_squared_2s32(MD_Vec2S32 v) { MD_S32 c = v.x * v.x + v.y * v.y; return c; } +inline MD_S32 md_length_2s32 (MD_Vec2S32 v) { MD_S32 c = (MD_S32)md_sqrt_f32((MD_F32)v.x*(MD_F32)v.x + (MD_F32)v.y*(MD_F32)v.y); return c; } +inline MD_Vec2S32 md_normalize_2s32 (MD_Vec2S32 v) { v = md_scale_2s32(v, (MD_S32)(1.f / md_length_2s32(v))); return v; } +inline MD_Vec2S32 md_mix_2s32 (MD_Vec2S32 a, MD_Vec2S32 b, MD_F32 t) { MD_Vec2S32 c = {(MD_S32)md_mix_1f32((MD_F32)a.x, (MD_F32)b.x, t), (MD_S32)md_mix_1f32((MD_F32)a.y, (MD_F32)b.y, t)}; return c; } -#define v2s16(x, y) vec_2s16((x), (y)) -inline Vec2S16 vec_2s16 (S16 x, S16 y) { Vec2S16 v = { x, y }; return v; } -inline Vec2S16 add_2s16 (Vec2S16 a, Vec2S16 b) { Vec2S16 c = {(S16)(a.x + b.x), (S16)(a.y + b.y)}; return c; } -inline Vec2S16 sub_2s16 (Vec2S16 a, Vec2S16 b) { Vec2S16 c = {(S16)(a.x - b.x), (S16)(a.y - b.y)}; return c; } -inline Vec2S16 mul_2s16 (Vec2S16 a, Vec2S16 b) { Vec2S16 c = {(S16)(a.x * b.x), (S16)(a.y * b.y)}; return c; } -inline Vec2S16 div_2s16 (Vec2S16 a, Vec2S16 b) { Vec2S16 c = {(S16)(a.x / b.x), (S16)(a.y / b.y)}; return c; } -inline Vec2S16 scale_2s16 (Vec2S16 v, S16 s) { Vec2S16 c = {(S16)(v.x * s ), (S16)(v.y * s )}; return c; } -inline S16 dot_2s16 (Vec2S16 a, Vec2S16 b) { S16 c = a.x * b.x + a.y * b.y; return c; } -inline S16 length_squared_2s16(Vec2S16 v) { S16 c = v.x * v.x + v.y * v.y; return c; } -inline S16 length_2s16 (Vec2S16 v) { S16 c = (S16)sqrt_f32((F32)(v.x*v.x + v.y*v.y)); return c; } -inline Vec2S16 normalize_2s16 (Vec2S16 v) { v = scale_2s16(v, (S16)(1.f / length_2s16(v))); return v; } -inline Vec2S16 mix_2s16 (Vec2S16 a, Vec2S16 b, F32 t) { Vec2S16 c = {(S16)mix_1f32((F32)a.x, (F32)b.x, t), (S16)mix_1f32((F32)a.y, (F32)b.y, t)}; return c; } +#define md_v2s16(x, y) md_vec_2s16((x), (y)) +inline MD_Vec2S16 md_vec_2s16 (MD_S16 x, MD_S16 y) { MD_Vec2S16 v = { x, y }; return v; } +inline MD_Vec2S16 md_add_2s16 (MD_Vec2S16 a, MD_Vec2S16 b) { MD_Vec2S16 c = {(MD_S16)(a.x + b.x), (MD_S16)(a.y + b.y)}; return c; } +inline MD_Vec2S16 md_sub_2s16 (MD_Vec2S16 a, MD_Vec2S16 b) { MD_Vec2S16 c = {(MD_S16)(a.x - b.x), (MD_S16)(a.y - b.y)}; return c; } +inline MD_Vec2S16 md_mul_2s16 (MD_Vec2S16 a, MD_Vec2S16 b) { MD_Vec2S16 c = {(MD_S16)(a.x * b.x), (MD_S16)(a.y * b.y)}; return c; } +inline MD_Vec2S16 md_div_2s16 (MD_Vec2S16 a, MD_Vec2S16 b) { MD_Vec2S16 c = {(MD_S16)(a.x / b.x), (MD_S16)(a.y / b.y)}; return c; } +inline MD_Vec2S16 md_scale_2s16 (MD_Vec2S16 v, MD_S16 s) { MD_Vec2S16 c = {(MD_S16)(v.x * s ), (MD_S16)(v.y * s )}; return c; } +inline MD_S16 md_dot_2s16 (MD_Vec2S16 a, MD_Vec2S16 b) { MD_S16 c = a.x * b.x + a.y * b.y; return c; } +inline MD_S16 md_length_squared_2s16(MD_Vec2S16 v) { MD_S16 c = v.x * v.x + v.y * v.y; return c; } +inline MD_S16 md_length_2s16 (MD_Vec2S16 v) { MD_S16 c = (MD_S16)md_sqrt_f32((MD_F32)(v.x*v.x + v.y*v.y)); return c; } +inline MD_Vec2S16 md_normalize_2s16 (MD_Vec2S16 v) { v = md_scale_2s16(v, (MD_S16)(1.f / md_length_2s16(v))); return v; } +inline MD_Vec2S16 md_mix_2s16 (MD_Vec2S16 a, MD_Vec2S16 b, MD_F32 t) { MD_Vec2S16 c = {(MD_S16)md_mix_1f32((MD_F32)a.x, (MD_F32)b.x, t), (MD_S16)md_mix_1f32((MD_F32)a.y, (MD_F32)b.y, t)}; return c; } -#define vec2(a, b) _Generic(a, S16: vec_2s16, S32: vec_2s32, S64: vec_2s64, F32: vec_2f32 )((a), (b)) -#define add_vec2(a, b) _Generic(a, S16: add_2s16, S32: add_2s32, S64: add_2s64, F32: add_2f32 )((a), (b)) -#define sub_vec2(a, b) _Generic(a, S16: sub_2s16, S32: sub_2s32, S64: sub_2s64, F32: sub_2f32 )((a), (b)) -#define mul_vec2(a, b) _Generic(a, S16: mul_2s16, S32: mul_2s32, S64: mul_2s64, F32: mul_2f32 )((a), (b)) -#define div_vec2(a, b) _Generic(a, S16: div_2s16, S32: div_2s32, S64: div_2s64, F32: div_2f32 )((a), (b)) -#define scale_vec2(v, s) _Generic(v, S16: scale_2s16, S32: scale_2s32, S64: scale_2s64, F32: scale_2f32 )((v), (s)) -#define dot_vec2(a, b) _Generic(a, S16: dot_2s16, S32: dot_2s32, S64: dot_2s64, F32: dot_2f32 )((a), (b)) -#define length_squared_vec2(v) _Generic(v, S16: length_squared_2s16, S32: length_squared_2s32, S64: length_squared_2s64, F32: length_squared_2f32)((v)) -#define length_vec2(v) _Generic(v, S16: length_2s16, S32: length_2s32, S64: length_2s64, F32: length_2f32 )((v)) -#define normalize_vec2(v) _Generic(v, S16: normalize_2s16, S32: normalize_2s32, S64: normalize_2s64, F32: normalize_2f32 )((v)) -#define mix_vec2(a, b, t) _Generic(a, S16: mix_2s16, S32: mix_2s32, S64: mix_2s64, F32: mix_2f32 )((a), (b), (t)) +#define md_vec2(a, b) _Generic(a, MD_S16: md_vec_2s16, MD_S32: md_vec_2s32, MD_S64: md_vec_2s64, MD_F32: md_vec_2f32 )((a), (b)) +#define md_add_vec2(a, b) _Generic(a, MD_S16: md_add_2s16, MD_S32: md_add_2s32, MD_S64: md_add_2s64, MD_F32: md_add_2f32 )((a), (b)) +#define md_sub_vec2(a, b) _Generic(a, MD_S16: md_sub_2s16, MD_S32: md_sub_2s32, MD_S64: md_sub_2s64, MD_F32: md_sub_2f32 )((a), (b)) +#define md_mul_vec2(a, b) _Generic(a, MD_S16: md_mul_2s16, MD_S32: md_mul_2s32, MD_S64: md_mul_2s64, MD_F32: md_mul_2f32 )((a), (b)) +#define md_div_vec2(a, b) _Generic(a, MD_S16: md_div_2s16, MD_S32: md_div_2s32, MD_S64: md_div_2s64, MD_F32: md_div_2f32 )((a), (b)) +#define md_scale_vec2(v, s) _Generic(v, MD_S16: md_scale_2s16, MD_S32: md_scale_2s32, MD_S64: md_scale_2s64, MD_F32: md_scale_2f32 )((v), (s)) +#define md_dot_vec2(a, b) _Generic(a, MD_S16: md_dot_2s16, MD_S32: md_dot_2s32, MD_S64: md_dot_2s64, MD_F32: md_dot_2f32 )((a), (b)) +#define md_length_squared_vec2(v) _Generic(v, MD_S16: md_length_squared_2s16, MD_S32: md_length_squared_2s32, MD_S64: md_length_squared_2s64, MD_F32: md_length_squared_2f32)((v)) +#define md_length_vec2(v) _Generic(v, MD_S16: md_length_2s16, MD_S32: md_length_2s32, MD_S64: md_length_2s64, MD_F32: md_length_2f32 )((v)) +#define md_normalize_vec2(v) _Generic(v, MD_S16: md_normalize_2s16, MD_S32: md_normalize_2s32, MD_S64: md_normalize_2s64, MD_F32: md_normalize_2f32 )((v)) +#define md_mix_vec2(a, b, t) _Generic(a, MD_S16: md_mix_2s16, MD_S32: md_mix_2s32, MD_S64: md_mix_2s64, MD_F32: md_mix_2f32 )((a), (b), (t)) // ==================== 3D Vectors ==================== -#define v3f32(x, y, z) vec_3f32((x), (y), (z)) -inline Vec3F32 vec_3f32 (F32 x, F32 y, F32 z) { Vec3F32 v = {x, y, z}; return v; } -inline Vec3F32 add_3f32 (Vec3F32 a, Vec3F32 b) { Vec3F32 c = {a.x + b.x, a.y + b.y, a.z + b.z}; return c; } -inline Vec3F32 sub_3f32 (Vec3F32 a, Vec3F32 b) { Vec3F32 c = {a.x - b.x, a.y - b.y, a.z - b.z}; return c; } -inline Vec3F32 mul_3f32 (Vec3F32 a, Vec3F32 b) { Vec3F32 c = {a.x * b.x, a.y * b.y, a.z * b.z}; return c; } -inline Vec3F32 div_3f32 (Vec3F32 a, Vec3F32 b) { Vec3F32 c = {a.x / b.x, a.y / b.y, a.z / b.z}; return c; } -inline Vec3F32 scale_3f32 (Vec3F32 v, F32 s) { Vec3F32 c = {v.x * s, v.y * s, v.z * s}; return c; } -inline F32 dot_3f32 (Vec3F32 a, Vec3F32 b) { F32 c = a.x * b.x + a.y * b.y + a.z * b.z; return c; } -inline F32 length_squared_3f32(Vec3F32 v) { F32 c = v.x * v.x + v.y * v.y + v.z * v.z; return c; } -inline F32 length_3f32 (Vec3F32 v) { F32 c = sqrt_f32(v.x * v.x + v.y * v.y + v.z * v.z); return c; } -inline Vec3F32 normalize_3f32 (Vec3F32 v) { v = scale_3f32(v, 1.f / length_3f32(v)); return v; } -inline Vec3F32 mix_3f32 (Vec3F32 a, Vec3F32 b, F32 t) { Vec3F32 c = {mix_1f32(a.x, b.x, t), mix_1f32(a.y, b.y, t), mix_1f32(a.z, b.z, t)}; return c; } -inline Vec3F32 cross_3f32 (Vec3F32 a, Vec3F32 b) { Vec3F32 c = {a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z, a.x * b.y - a.y * b.x}; return c; } +#define md_v3f32(x, y, z) md_vec_3f32((x), (y), (z)) +inline MD_Vec3F32 md_vec_3f32 (MD_F32 x, MD_F32 y, MD_F32 z) { MD_Vec3F32 v = {x, y, z}; return v; } +inline MD_Vec3F32 md_add_3f32 (MD_Vec3F32 a, MD_Vec3F32 b) { MD_Vec3F32 c = {a.x + b.x, a.y + b.y, a.z + b.z}; return c; } +inline MD_Vec3F32 md_sub_3f32 (MD_Vec3F32 a, MD_Vec3F32 b) { MD_Vec3F32 c = {a.x - b.x, a.y - b.y, a.z - b.z}; return c; } +inline MD_Vec3F32 md_mul_3f32 (MD_Vec3F32 a, MD_Vec3F32 b) { MD_Vec3F32 c = {a.x * b.x, a.y * b.y, a.z * b.z}; return c; } +inline MD_Vec3F32 md_div_3f32 (MD_Vec3F32 a, MD_Vec3F32 b) { MD_Vec3F32 c = {a.x / b.x, a.y / b.y, a.z / b.z}; return c; } +inline MD_Vec3F32 md_scale_3f32 (MD_Vec3F32 v, MD_F32 s) { MD_Vec3F32 c = {v.x * s, v.y * s, v.z * s}; return c; } +inline MD_F32 md_dot_3f32 (MD_Vec3F32 a, MD_Vec3F32 b) { MD_F32 c = a.x * b.x + a.y * b.y + a.z * b.z; return c; } +inline MD_F32 md_length_squared_3f32(MD_Vec3F32 v) { MD_F32 c = v.x * v.x + v.y * v.y + v.z * v.z; return c; } +inline MD_F32 md_length_3f32 (MD_Vec3F32 v) { MD_F32 c = md_sqrt_f32(v.x * v.x + v.y * v.y + v.z * v.z); return c; } +inline MD_Vec3F32 md_normalize_3f32 (MD_Vec3F32 v) { v = md_scale_3f32(v, 1.f / md_length_3f32(v)); return v; } +inline MD_Vec3F32 md_mix_3f32 (MD_Vec3F32 a, MD_Vec3F32 b, MD_F32 t) { MD_Vec3F32 c = {md_mix_1f32(a.x, b.x, t), md_mix_1f32(a.y, b.y, t), md_mix_1f32(a.z, b.z, t)}; return c; } +inline MD_Vec3F32 md_cross_3f32 (MD_Vec3F32 a, MD_Vec3F32 b) { MD_Vec3F32 c = {a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z, a.x * b.y - a.y * b.x}; return c; } -#define v3s32(x, y, z) vec_3s32((x), (y), (z)) -inline Vec3S32 vec_3s32 (S32 x, S32 y, S32 z) { Vec3S32 v = {x, y, z}; return v; } -inline Vec3S32 add_3s32 (Vec3S32 a, Vec3S32 b) { Vec3S32 c = {a.x + b.x, a.y + b.y, a.z + b.z}; return c; } -inline Vec3S32 sub_3s32 (Vec3S32 a, Vec3S32 b) { Vec3S32 c = {a.x - b.x, a.y - b.y, a.z - b.z}; return c; } -inline Vec3S32 mul_3s32 (Vec3S32 a, Vec3S32 b) { Vec3S32 c = {a.x * b.x, a.y * b.y, a.z * b.z}; return c; } -inline Vec3S32 div_3s32 (Vec3S32 a, Vec3S32 b) { Vec3S32 c = {a.x / b.x, a.y / b.y, a.z / b.z}; return c; } -inline Vec3S32 scale_3s32 (Vec3S32 v, S32 s) { Vec3S32 c = {v.x * s, v.y * s, v.z * s }; return c; } -inline S32 dot_3s32 (Vec3S32 a, Vec3S32 b) { S32 c = a.x * b.x + a.y * b.y + a.z * b.z; return c; } -inline S32 length_squared_3s32(Vec3S32 v) { S32 c = v.x * v.x + v.y * v.y + v.z * v.z; return c; } -inline S32 length_3s32 (Vec3S32 v) { S32 c = (S32)sqrt_f32((F32)(v.x * v.x + v.y * v.y + v.z * v.z)); return c; } -inline Vec3S32 normalize_3s32 (Vec3S32 v) { v = scale_3s32(v, (S32)(1.f / length_3s32(v))); return v; } -inline Vec3S32 mix_3s32 (Vec3S32 a, Vec3S32 b, F32 t) { Vec3S32 c = {(S32)mix_1f32((F32)a.x, (F32)b.x, t), (S32)mix_1f32((F32)a.y, (F32)b.y, t), (S32)mix_1f32((F32)a.z, (F32)b.z, t)}; return c; } -inline Vec3S32 cross_3s32 (Vec3S32 a, Vec3S32 b) { Vec3S32 c = {a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z, a.x * b.y - a.y * b.x}; return c; } +#define md_v3s32(x, y, z) md_vec_3s32((x), (y), (z)) +inline MD_Vec3S32 md_vec_3s32 (MD_S32 x, MD_S32 y, MD_S32 z) { MD_Vec3S32 v = {x, y, z}; return v; } +inline MD_Vec3S32 md_add_3s32 (MD_Vec3S32 a, MD_Vec3S32 b) { MD_Vec3S32 c = {a.x + b.x, a.y + b.y, a.z + b.z}; return c; } +inline MD_Vec3S32 md_sub_3s32 (MD_Vec3S32 a, MD_Vec3S32 b) { MD_Vec3S32 c = {a.x - b.x, a.y - b.y, a.z - b.z}; return c; } +inline MD_Vec3S32 md_mul_3s32 (MD_Vec3S32 a, MD_Vec3S32 b) { MD_Vec3S32 c = {a.x * b.x, a.y * b.y, a.z * b.z}; return c; } +inline MD_Vec3S32 md_div_3s32 (MD_Vec3S32 a, MD_Vec3S32 b) { MD_Vec3S32 c = {a.x / b.x, a.y / b.y, a.z / b.z}; return c; } +inline MD_Vec3S32 md_scale_3s32 (MD_Vec3S32 v, MD_S32 s) { MD_Vec3S32 c = {v.x * s, v.y * s, v.z * s }; return c; } +inline MD_S32 md_dot_3s32 (MD_Vec3S32 a, MD_Vec3S32 b) { MD_S32 c = a.x * b.x + a.y * b.y + a.z * b.z; return c; } +inline MD_S32 md_length_squared_3s32(MD_Vec3S32 v) { MD_S32 c = v.x * v.x + v.y * v.y + v.z * v.z; return c; } +inline MD_S32 md_length_3s32 (MD_Vec3S32 v) { MD_S32 c = (MD_S32)md_sqrt_f32((MD_F32)(v.x * v.x + v.y * v.y + v.z * v.z)); return c; } +inline MD_Vec3S32 md_normalize_3s32 (MD_Vec3S32 v) { v = md_scale_3s32(v, (MD_S32)(1.f / md_length_3s32(v))); return v; } +inline MD_Vec3S32 md_mix_3s32 (MD_Vec3S32 a, MD_Vec3S32 b, MD_F32 t) { MD_Vec3S32 c = {(MD_S32)md_mix_1f32((MD_F32)a.x, (MD_F32)b.x, t), (MD_S32)md_mix_1f32((MD_F32)a.y, (MD_F32)b.y, t), (MD_S32)md_mix_1f32((MD_F32)a.z, (MD_F32)b.z, t)}; return c; } +inline MD_Vec3S32 md_cross_3s32 (MD_Vec3S32 a, MD_Vec3S32 b) { MD_Vec3S32 c = {a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z, a.x * b.y - a.y * b.x}; return c; } -#define vec3(a, b, c) _Generic(a, S32: vec_3s32, F32: vec_3f32 )((a), (b), (c)) -#define add_vec3(a, b) _Generic(a, S32: add_3s32, F32: add_3f32 )((a), (b)) -#define sub_vec3(a, b) _Generic(a, S32: sub_3s32, F32: sub_3f32 )((a), (b)) -#define mul_vec3(a, b) _Generic(a, S32: mul_3s32, F32: mul_3f32 )((a), (b)) -#define div_vec3(a, b) _Generic(a, S32: div_3s32, F32: div_3f32 )((a), (b)) -#define scale_vec3(v, s) _Generic(v, S32: scale_3s32, F32: scale_3f32 )((v), (s)) -#define dot_vec3(a, b) _Generic(a, S32: dot_3s32, F32: dot_3f32 )((a), (b)) -#define length_squared_vec3(v) _Generic(v, S32: length_squared_3s32, F32: length_squared_3f32)((v)) -#define length_vec3(v) _Generic(v, S32: length_3s32, F32: length_3f32 )((v)) -#define normalize_vec3(v) _Generic(v, S32: normalize_3s32, F32: normalize_3f32 )((v)) -#define mix_vec3(a, b, t) _Generic(a, S32: mix_3s32, F32: mix_3f32 )((a), (b), (t)) -#define cross_vec3(a, b) _Generic(a, S32: cross_3s32, F32: cross_3f32 )((a), (b)) +#define md_vec3(a, b, c) _Generic(a, MD_S32: md_vec_3s32, MD_F32: md_vec_3f32 )((a), (b), (c)) +#define md_add_vec3(a, b) _Generic(a, MD_S32: md_add_3s32, MD_F32: md_add_3f32 )((a), (b)) +#define md_sub_vec3(a, b) _Generic(a, MD_S32: md_sub_3s32, MD_F32: md_sub_3f32 )((a), (b)) +#define md_mul_vec3(a, b) _Generic(a, MD_S32: md_mul_3s32, MD_F32: md_mul_3f32 )((a), (b)) +#define md_div_vec3(a, b) _Generic(a, MD_S32: md_div_3s32, MD_F32: md_div_3f32 )((a), (b)) +#define md_scale_vec3(v, s) _Generic(v, MD_S32: md_scale_3s32, MD_F32: md_scale_3f32 )((v), (s)) +#define md_dot_vec3(a, b) _Generic(a, MD_S32: md_dot_3s32, MD_F32: md_dot_3f32 )((a), (b)) +#define md_length_squared_vec3(v) _Generic(v, MD_S32: md_length_squared_3s32, MD_F32: md_length_squared_3f32)((v)) +#define md_length_vec3(v) _Generic(v, MD_S32: md_length_3s32, MD_F32: md_length_3f32 )((v)) +#define md_normalize_vec3(v) _Generic(v, MD_S32: md_normalize_3s32, MD_F32: md_normalize_3f32 )((v)) +#define md_mix_vec3(a, b, t) _Generic(a, MD_S32: md_mix_3s32, MD_F32: md_mix_3f32 )((a), (b), (t)) +#define md_cross_vec3(a, b) _Generic(a, MD_S32: md_cross_3s32, MD_F32: md_cross_3f32 )((a), (b)) // ==================== 4D Vectors ==================== -#define v4f32(x, y, z, w) vec_4f32((x), (y), (z), (w)) -inline Vec4F32 vec_4f32 (F32 x, F32 y, F32 z, F32 w) { Vec4F32 v = {x, y, z, w}; return v; } -inline Vec4F32 add_4f32 (Vec4F32 a, Vec4F32 b) { Vec4F32 c = {a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w}; return c; } -inline Vec4F32 sub_4f32 (Vec4F32 a, Vec4F32 b) { Vec4F32 c = {a.x - b.x, a.y - b.y, a.z - b.z, a.w - b.w}; return c; } -inline Vec4F32 mul_4f32 (Vec4F32 a, Vec4F32 b) { Vec4F32 c = {a.x * b.x, a.y * b.y, a.z * b.z, a.w * b.w}; return c; } -inline Vec4F32 div_4f32 (Vec4F32 a, Vec4F32 b) { Vec4F32 c = {a.x / b.x, a.y / b.y, a.z / b.z, a.w / b.w}; return c; } -inline Vec4F32 scale_4f32 (Vec4F32 v, F32 s) { Vec4F32 c = {v.x * s, v.y * s, v.z * s, v.w * s }; return c; } -inline F32 dot_4f32 (Vec4F32 a, Vec4F32 b) { F32 c = a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w; return c; } -inline F32 length_squared_4f32(Vec4F32 v) { F32 c = v.x * v.x + v.y * v.y + v.z * v.z + v.w * v.w; return c; } -inline F32 length_4f32 (Vec4F32 v) { F32 c = sqrt_f32(v.x * v.x + v.y * v.y + v.z * v.z + v.w * v.w); return c; } -inline Vec4F32 normalize_4f32 (Vec4F32 v) { v = scale_4f32(v, 1.f / length_4f32(v)); return v; } -inline Vec4F32 mix_4f32 (Vec4F32 a, Vec4F32 b, F32 t) { Vec4F32 c = {mix_1f32(a.x, b.x, t), mix_1f32(a.y, b.y, t), mix_1f32(a.z, b.z, t), mix_1f32(a.w, b.w, t)}; return c; } +#define md_v4f32(x, y, z, w) md_vec_4f32((x), (y), (z), (w)) +inline MD_Vec4F32 md_vec_4f32 (MD_F32 x, MD_F32 y, MD_F32 z, MD_F32 w) { MD_Vec4F32 v = {x, y, z, w}; return v; } +inline MD_Vec4F32 md_add_4f32 (MD_Vec4F32 a, MD_Vec4F32 b) { MD_Vec4F32 c = {a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w}; return c; } +inline MD_Vec4F32 md_sub_4f32 (MD_Vec4F32 a, MD_Vec4F32 b) { MD_Vec4F32 c = {a.x - b.x, a.y - b.y, a.z - b.z, a.w - b.w}; return c; } +inline MD_Vec4F32 md_mul_4f32 (MD_Vec4F32 a, MD_Vec4F32 b) { MD_Vec4F32 c = {a.x * b.x, a.y * b.y, a.z * b.z, a.w * b.w}; return c; } +inline MD_Vec4F32 md_div_4f32 (MD_Vec4F32 a, MD_Vec4F32 b) { MD_Vec4F32 c = {a.x / b.x, a.y / b.y, a.z / b.z, a.w / b.w}; return c; } +inline MD_Vec4F32 md_scale_4f32 (MD_Vec4F32 v, MD_F32 s) { MD_Vec4F32 c = {v.x * s, v.y * s, v.z * s, v.w * s }; return c; } +inline MD_F32 md_dot_4f32 (MD_Vec4F32 a, MD_Vec4F32 b) { MD_F32 c = a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w; return c; } +inline MD_F32 md_length_squared_4f32(MD_Vec4F32 v) { MD_F32 c = v.x * v.x + v.y * v.y + v.z * v.z + v.w * v.w; return c; } +inline MD_F32 md_length_4f32 (MD_Vec4F32 v) { MD_F32 c = md_sqrt_f32(v.x * v.x + v.y * v.y + v.z * v.z + v.w * v.w); return c; } +inline MD_Vec4F32 md_normalize_4f32 (MD_Vec4F32 v) { v = md_scale_4f32(v, 1.f / md_length_4f32(v)); return v; } +inline MD_Vec4F32 md_mix_4f32 (MD_Vec4F32 a, MD_Vec4F32 b, MD_F32 t) { MD_Vec4F32 c = {md_mix_1f32(a.x, b.x, t), md_mix_1f32(a.y, b.y, t), md_mix_1f32(a.z, b.z, t), md_mix_1f32(a.w, b.w, t)}; return c; } -#define v4s32(x, y, z, w) vec_4s32((x), (y), (z), (w)) -inline Vec4S32 vec_4s32 (S32 x, S32 y, S32 z, S32 w) { Vec4S32 v = {x, y, z, w}; return v; } -inline Vec4S32 add_4s32 (Vec4S32 a, Vec4S32 b) { Vec4S32 c = {a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w}; return c; } -inline Vec4S32 sub_4s32 (Vec4S32 a, Vec4S32 b) { Vec4S32 c = {a.x - b.x, a.y - b.y, a.z - b.z, a.w - b.w}; return c; } -inline Vec4S32 mul_4s32 (Vec4S32 a, Vec4S32 b) { Vec4S32 c = {a.x * b.x, a.y * b.y, a.z * b.z, a.w * b.w}; return c; } -inline Vec4S32 div_4s32 (Vec4S32 a, Vec4S32 b) { Vec4S32 c = {a.x / b.x, a.y / b.y, a.z / b.z, a.w / b.w}; return c; } -inline Vec4S32 scale_4s32 (Vec4S32 v, S32 s) { Vec4S32 c = {v.x * s, v.y * s, v.z * s, v.w * s }; return c; } -inline S32 dot_4s32 (Vec4S32 a, Vec4S32 b) { S32 c = a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w; return c; } -inline S32 length_squared_4s32(Vec4S32 v) { S32 c = v.x * v.x + v.y * v.y + v.z * v.z + v.w * v.w; return c; } -inline S32 length_4s32 (Vec4S32 v) { S32 c = (S32)sqrt_f32((F32)(v.x * v.x + v.y * v.y + v.z * v.z + v.w * v.w)); return c; } -inline Vec4S32 normalize_4s32 (Vec4S32 v) { v = scale_4s32(v, (S32)(1.f / length_4s32(v))); return v; } -inline Vec4S32 mix_4s32 (Vec4S32 a, Vec4S32 b, F32 t) { Vec4S32 c = {(S32)mix_1f32((F32)a.x, (F32)b.x, t), (S32)mix_1f32((F32)a.y, (F32)b.y, t), (S32)mix_1f32((F32)a.z, (F32)b.z, t), (S32)mix_1f32((F32)a.w, (F32)b.w, t)}; return c; } +#define v4s32(x, y, z, w) md_vec_4s32((x), (y), (z), (w)) +inline MD_Vec4S32 md_vec_4s32 (MD_S32 x, MD_S32 y, MD_S32 z, MD_S32 w) { MD_Vec4S32 v = {x, y, z, w}; return v; } +inline MD_Vec4S32 md_add_4s32 (MD_Vec4S32 a, MD_Vec4S32 b) { MD_Vec4S32 c = {a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w}; return c; } +inline MD_Vec4S32 md_sub_4s32 (MD_Vec4S32 a, MD_Vec4S32 b) { MD_Vec4S32 c = {a.x - b.x, a.y - b.y, a.z - b.z, a.w - b.w}; return c; } +inline MD_Vec4S32 md_mul_4s32 (MD_Vec4S32 a, MD_Vec4S32 b) { MD_Vec4S32 c = {a.x * b.x, a.y * b.y, a.z * b.z, a.w * b.w}; return c; } +inline MD_Vec4S32 md_div_4s32 (MD_Vec4S32 a, MD_Vec4S32 b) { MD_Vec4S32 c = {a.x / b.x, a.y / b.y, a.z / b.z, a.w / b.w}; return c; } +inline MD_Vec4S32 md_scale_4s32 (MD_Vec4S32 v, MD_S32 s) { MD_Vec4S32 c = {v.x * s, v.y * s, v.z * s, v.w * s }; return c; } +inline MD_S32 md_dot_4s32 (MD_Vec4S32 a, MD_Vec4S32 b) { MD_S32 c = a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w; return c; } +inline MD_S32 md_length_squared_4s32(MD_Vec4S32 v) { MD_S32 c = v.x * v.x + v.y * v.y + v.z * v.z + v.w * v.w; return c; } +inline MD_S32 md_length_4s32 (MD_Vec4S32 v) { MD_S32 c = (MD_S32)md_sqrt_f32((MD_F32)(v.x * v.x + v.y * v.y + v.z * v.z + v.w * v.w)); return c; } +inline MD_Vec4S32 md_normalize_4s32 (MD_Vec4S32 v) { v = md_scale_4s32(v, (MD_S32)(1.f / md_length_4s32(v))); return v; } +inline MD_Vec4S32 md_mix_4s32 (MD_Vec4S32 a, MD_Vec4S32 b, MD_F32 t) { MD_Vec4S32 c = {(MD_S32)md_mix_1f32((MD_F32)a.x, (MD_F32)b.x, t), (MD_S32)md_mix_1f32((MD_F32)a.y, (MD_F32)b.y, t), (MD_S32)md_mix_1f32((MD_F32)a.z, (MD_F32)b.z, t), (MD_S32)md_mix_1f32((MD_F32)a.w, (MD_F32)b.w, t)}; return c; } -#define vec4(a, b, c, d) _Generic(a, S32: vec_4s32, F32: vec_4f32 )((a), (b), (c), (d)) -#define add_vec4(a, b) _Generic(a, S32: add_4s32, F32: add_4f32 )((a), (b)) -#define sub_vec4(a, b) _Generic(a, S32: sub_4s32, F32: sub_4f32 )((a), (b)) -#define mul_vec4(a, b) _Generic(a, S32: mul_4s32, F32: mul_4f32 )((a), (b)) -#define div_vec4(a, b) _Generic(a, S32: div_4s32, F32: div_4f32 )((a), (b)) -#define scale_vec4(v, s) _Generic(v, S32: scale_4s32, F32: scale_4f32 )((v), (s)) -#define dot_vec4(a, b) _Generic(a, S32: dot_4s32, F32: dot_4f32 )((a), (b)) -#define length_squared_vec4(v) _Generic(v, S32: length_squared_4s32, F32: length_squared_4f32)((v)) -#define length_vec4(v) _Generic(v, S32: length_4s32, F32: length_4f32 )((v)) -#define normalize_vec4(v) _Generic(v, S32: normalize_4s32, F32: normalize_4f32 )((v)) -#define mix_vec4(a, b, t) _Generic(a, S32: mix_4s32, F32: mix_4f32 )((a), (b), (t)) +#define md_vec4(a, b, c, d) _Generic(a, MD_S32: md_vec_4s32, MD_F32: md_vec_4f32 )((a), (b), (c), (d)) +#define md_add_vec4(a, b) _Generic(a, MD_S32: md_add_4s32, MD_F32: md_add_4f32 )((a), (b)) +#define md_sub_vec4(a, b) _Generic(a, MD_S32: md_sub_4s32, MD_F32: md_sub_4f32 )((a), (b)) +#define md_mul_vec4(a, b) _Generic(a, MD_S32: md_mul_4s32, MD_F32: md_mul_4f32 )((a), (b)) +#define md_div_vec4(a, b) _Generic(a, MD_S32: md_div_4s32, MD_F32: md_div_4f32 )((a), (b)) +#define md_scale_vec4(v, s) _Generic(v, MD_S32: md_scale_4s32, MD_F32: md_scale_4f32 )((v), (s)) +#define md_dot_vec4(a, b) _Generic(a, MD_S32: md_dot_4s32, MD_F32: md_dot_4f32 )((a), (b)) +#define md_length_squared_vec4(v) _Generic(v, MD_S32: md_length_squared_4s32, MD_F32: md_length_squared_4f32)((v)) +#define md_length_vec4(v) _Generic(v, MD_S32: md_length_4s32, MD_F32: md_length_4f32 )((v)) +#define md_normalize_vec4(v) _Generic(v, MD_S32: md_normalize_4s32, MD_F32: md_normalize_4f32 )((v)) +#define md_mix_vec4(a, b, t) _Generic(a, MD_S32: md_mix_4s32, MD_F32: md_mix_4f32 )((a), (b), (t)) //////////////////////////////// //~ rjf: Matrix Ops // ==================== 3x3 Matrix ==================== -inline Mat3x3F32 mat_3x3f32 (F32 diag) { Mat3x3F32 res = {0}; res.v[0][0] = diag; res.v[1][1] = diag; res.v[2][2] = diag; return res; } -inline Mat3x3F32 make_translate_3x3f32(Vec2F32 delta) { Mat3x3F32 mat = mat_3x3f32(1.f); mat.v[2][0] = delta.x; mat.v[2][1] = delta.y; return mat; } -inline Mat3x3F32 make_scale_3x3f32 (Vec2F32 scale) { Mat3x3F32 mat = mat_3x3f32(1.f); mat.v[0][0] = scale.x; mat.v[1][1] = scale.y; return mat; } -inline Mat3x3F32 mul_3x3f32 (Mat3x3F32 a, Mat3x3F32 b) { Mat3x3F32 c = {0}; for(int j = 0; j < 3; j += 1) for(int i = 0; i < 3; i += 1) { c.v[i][j] = (a.v[0][j]*b.v[i][0] + a.v[1][j] * b.v[i][1] + a.v[2][j] * b.v[i][2]); } return c; } +inline MD_Mat3x3F32 md_mat_3x3f32 (MD_F32 diag) { MD_Mat3x3F32 res = {0}; res.v[0][0] = diag; res.v[1][1] = diag; res.v[2][2] = diag; return res; } +inline MD_Mat3x3F32 md_make_translate_3x3f32(MD_Vec2F32 delta) { MD_Mat3x3F32 mat = md_mat_3x3f32(1.f); mat.v[2][0] = delta.x; mat.v[2][1] = delta.y; return mat; } +inline MD_Mat3x3F32 md_make_scale_3x3f32 (MD_Vec2F32 scale) { MD_Mat3x3F32 mat = md_mat_3x3f32(1.f); mat.v[0][0] = scale.x; mat.v[1][1] = scale.y; return mat; } +inline MD_Mat3x3F32 md_mul_3x3f32 (MD_Mat3x3F32 a, MD_Mat3x3F32 b) { MD_Mat3x3F32 c = {0}; for(int j = 0; j < 3; j += 1) for(int i = 0; i < 3; i += 1) { c.v[i][j] = (a.v[0][j]*b.v[i][0] + a.v[1][j] * b.v[i][1] + a.v[2][j] * b.v[i][2]); } return c; } -inline Mat4x4F32 mat_4x4f32 (F32 diag) { Mat4x4F32 res = {0}; res.v[0][0] = diag; res.v[1][1] = diag; res.v[2][2] = diag; res.v[3][3] = diag; return res; } -inline Mat4x4F32 make_translate_4x4f32(Vec3F32 delta) { Mat4x4F32 res = mat_4x4f32(1.f); res.v[3][0] = delta.x; res.v[3][1] = delta.y; res.v[3][2] = delta.z; return res; } -inline Mat4x4F32 make_scale_4x4f32 (Vec3F32 scale) { Mat4x4F32 res = mat_4x4f32(1.f); res.v[0][0] = scale.x; res.v[1][1] = scale.y; res.v[2][2] = scale.z; return res; } +inline MD_Mat4x4F32 md_mat_4x4f32 (MD_F32 diag) { MD_Mat4x4F32 res = {0}; res.v[0][0] = diag; res.v[1][1] = diag; res.v[2][2] = diag; res.v[3][3] = diag; return res; } +inline MD_Mat4x4F32 md_make_translate_4x4f32(MD_Vec3F32 delta) { MD_Mat4x4F32 res = md_mat_4x4f32(1.f); res.v[3][0] = delta.x; res.v[3][1] = delta.y; res.v[3][2] = delta.z; return res; } +inline MD_Mat4x4F32 md_make_scale_4x4f32 (MD_Vec3F32 scale) { MD_Mat4x4F32 res = md_mat_4x4f32(1.f); res.v[0][0] = scale.x; res.v[1][1] = scale.y; res.v[2][2] = scale.z; return res; } // ==================== 4x4 Matrix ==================== -Mat4x4F32 make_perspective_4x4f32 (F32 fov, F32 aspect_ratio, F32 near_z, F32 far_z); -Mat4x4F32 make_orthographic_4x4f32(F32 left, F32 right, F32 bottom, F32 top, F32 near_z, F32 far_z); -Mat4x4F32 make_look_at_4x4f32 (Vec3F32 eye, Vec3F32 center, Vec3F32 up); -Mat4x4F32 make_rotate_4x4f32 (Vec3F32 axis, F32 turns); +MD_Mat4x4F32 md_make_perspective_4x4f32 (MD_F32 fov, MD_F32 aspect_ratio, MD_F32 near_z, MD_F32 far_z); +MD_Mat4x4F32 md_make_orthographic_4x4f32(MD_F32 left, MD_F32 right, MD_F32 bottom, MD_F32 top, MD_F32 near_z, MD_F32 far_z); +MD_Mat4x4F32 md_make_look_at_4x4f32 (MD_Vec3F32 eye, MD_Vec3F32 center, MD_Vec3F32 up); +MD_Mat4x4F32 md_make_rotate_4x4f32 (MD_Vec3F32 axis, MD_F32 turns); -Mat4x4F32 mul_4x4f32 (Mat4x4F32 a, Mat4x4F32 b); -Mat4x4F32 scale_4x4f32 (Mat4x4F32 m, F32 scale); -Mat4x4F32 inverse_4x4f32 (Mat4x4F32 m); -Mat4x4F32 derotate_4x4f32(Mat4x4F32 mat); +MD_Mat4x4F32 md_mul_4x4f32 (MD_Mat4x4F32 a, MD_Mat4x4F32 b); +MD_Mat4x4F32 md_scale_4x4f32 (MD_Mat4x4F32 m, MD_F32 scale); +MD_Mat4x4F32 md_inverse_4x4f32 (MD_Mat4x4F32 m); +MD_Mat4x4F32 md_derotate_4x4f32(MD_Mat4x4F32 mat); -inline Mat4x4F32 -make_perspective_4x4f32(F32 fov, F32 aspect_ratio, F32 near_z, F32 far_z) { - F32 tan_theta_over_2 = tan_f32(fov / 2); - F32 q_tan_theta_over_2 = 1 / tan_theta_over_2; - F32 q_near_far_z = 1 / (near_z - far_z); - Mat4x4F32 - result = mat_4x4f32(1.f); +inline MD_Mat4x4F32 +md_make_perspective_4x4f32(MD_F32 fov, MD_F32 aspect_ratio, MD_F32 near_z, MD_F32 far_z) { + MD_F32 tan_theta_over_2 = md_tan_f32(fov / 2); + MD_F32 q_tan_theta_over_2 = 1 / tan_theta_over_2; + MD_F32 q_near_far_z = 1 / (near_z - far_z); + MD_Mat4x4F32 + result = md_mat_4x4f32(1.f); result.v[0][0] = q_tan_theta_over_2; result.v[1][1] = aspect_ratio * q_tan_theta_over_2; result.v[2][3] = 1.f; @@ -620,9 +620,9 @@ make_perspective_4x4f32(F32 fov, F32 aspect_ratio, F32 near_z, F32 far_z) { return result; } -inline Mat4x4F32 -make_orthographic_4x4f32(F32 left, F32 right, F32 bottom, F32 top, F32 near_z, F32 far_z) { - Mat4x4F32 result = mat_4x4f32(1.f); +inline MD_Mat4x4F32 +md_make_orthographic_4x4f32(MD_F32 left, MD_F32 right, MD_F32 bottom, MD_F32 top, MD_F32 near_z, MD_F32 far_z) { + MD_Mat4x4F32 result = md_mat_4x4f32(1.f); result.v[0][0] = 2.f / (right - left); result.v[1][1] = 2.f / (top - bottom); @@ -636,36 +636,36 @@ make_orthographic_4x4f32(F32 left, F32 right, F32 bottom, F32 top, F32 near_z, F return result; } -inline Mat4x4F32 -make_look_at_4x4f32(Vec3F32 eye, Vec3F32 center, Vec3F32 up) { - Mat4x4F32 result; - Vec3F32 f = normalize_3f32(sub_3f32(eye, center)); - Vec3F32 s = normalize_3f32(cross_3f32(f, up)); - Vec3F32 u = cross_3f32(s, f); +inline MD_Mat4x4F32 +md_make_look_at_4x4f32(MD_Vec3F32 eye, MD_Vec3F32 center, MD_Vec3F32 up) { + MD_Mat4x4F32 result; + MD_Vec3F32 f = md_normalize_3f32(md_sub_3f32(eye, center)); + MD_Vec3F32 s = md_normalize_3f32(md_cross_3f32(f, up)); + MD_Vec3F32 u = md_cross_3f32(s, f); result.v[0][0] = s.x; result.v[0][1] = u.x; result.v[0][2] = -f.x; result.v[0][3] = 0.0f; result.v[1][0] = s.y; result.v[1][1] = u.y; result.v[1][2] = -f.y; result.v[1][3] = 0.0f; result.v[2][0] = s.z; result.v[2][1] = u.z; result.v[2][2] = -f.z; result.v[2][3] = 0.0f; - result.v[3][0] = -dot_3f32(s, eye); result.v[3][1] = -dot_3f32(u, eye); result.v[3][2] = dot_3f32(f, eye); result.v[3][3] = 1.0f; + result.v[3][0] = -md_dot_3f32(s, eye); result.v[3][1] = -md_dot_3f32(u, eye); result.v[3][2] = md_dot_3f32(f, eye); result.v[3][3] = 1.0f; return result; } -inline Mat4x4F32 -make_rotate_4x4f32(Vec3F32 axis, F32 turns) { - axis = normalize_3f32(axis); - F32 sin_theta = sin_f32(turns); - F32 cos_theta = cos_f32(turns); - F32 cos_value = 1.f - cos_theta; - F32 mul_x_sint = axis.x * sin_theta; - F32 mul_y_sint = axis.y * sin_theta; - F32 mul_z_sint = axis.z * sin_theta; - F32 mul_xx_cos = axis.x * axis.x * cos_value; - F32 mul_yy_cos = axis.y * axis.y * cos_value; - F32 mul_zz_cos = axis.z * axis.z * cos_value; - F32 mul_xy_cos = axis.x * axis.y * cos_value; - F32 mul_xz_cos = axis.x * axis.z * cos_value; - F32 mul_yz_cos = axis.y * axis.z * cos_value; - Mat4x4F32 - result = mat_4x4f32(1.f); +inline MD_Mat4x4F32 +md_make_rotate_4x4f32(MD_Vec3F32 axis, MD_F32 turns) { + axis = md_normalize_3f32(axis); + MD_F32 sin_theta = md_sin_f32(turns); + MD_F32 cos_theta = md_cos_f32(turns); + MD_F32 cos_value = 1.f - cos_theta; + MD_F32 mul_x_sint = axis.x * sin_theta; + MD_F32 mul_y_sint = axis.y * sin_theta; + MD_F32 mul_z_sint = axis.z * sin_theta; + MD_F32 mul_xx_cos = axis.x * axis.x * cos_value; + MD_F32 mul_yy_cos = axis.y * axis.y * cos_value; + MD_F32 mul_zz_cos = axis.z * axis.z * cos_value; + MD_F32 mul_xy_cos = axis.x * axis.y * cos_value; + MD_F32 mul_xz_cos = axis.x * axis.z * cos_value; + MD_F32 mul_yz_cos = axis.y * axis.z * cos_value; + MD_Mat4x4F32 + result = md_mat_4x4f32(1.f); result.v[0][0] = mul_xx_cos + cos_theta; result.v[0][1] = mul_xy_cos + mul_z_sint; result.v[0][2] = mul_xz_cos - mul_y_sint; @@ -678,9 +678,9 @@ make_rotate_4x4f32(Vec3F32 axis, F32 turns) { return result; } -inline Mat4x4F32 -mul_4x4f32(Mat4x4F32 a, Mat4x4F32 b) { - Mat4x4F32 c = {0}; +inline MD_Mat4x4F32 +md_mul_4x4f32(MD_Mat4x4F32 a, MD_Mat4x4F32 b) { + MD_Mat4x4F32 c = {0}; for(int j = 0; j < 4; j += 1) for(int i = 0; i < 4; i += 1) { c.v[i][j] = (a.v[0][j] * b.v[i][0] + a.v[1][j] * b.v[i][1] + a.v[2][j] * b.v[i][2] + a.v[3][j] * b.v[i][3]); @@ -688,8 +688,8 @@ mul_4x4f32(Mat4x4F32 a, Mat4x4F32 b) { return c; } -inline Mat4x4F32 -scale_4x4f32(Mat4x4F32 m, F32 scale) { +inline MD_Mat4x4F32 +md_scale_4x4f32(MD_Mat4x4F32 m, MD_F32 scale) { for(int j = 0; j < 4; j += 1) for(int i = 0; i < 4; i += 1) { m.v[i][j] *= scale; @@ -697,70 +697,70 @@ scale_4x4f32(Mat4x4F32 m, F32 scale) { return m; } -inline Mat4x4F32 -inverse_4x4f32(Mat4x4F32 m) { - F32 coef00 = m.v[2][2] * m.v[3][3] - m.v[3][2] * m.v[2][3]; - F32 coef02 = m.v[1][2] * m.v[3][3] - m.v[3][2] * m.v[1][3]; - F32 coef03 = m.v[1][2] * m.v[2][3] - m.v[2][2] * m.v[1][3]; - F32 coef04 = m.v[2][1] * m.v[3][3] - m.v[3][1] * m.v[2][3]; - F32 coef06 = m.v[1][1] * m.v[3][3] - m.v[3][1] * m.v[1][3]; - F32 coef07 = m.v[1][1] * m.v[2][3] - m.v[2][1] * m.v[1][3]; - F32 coef08 = m.v[2][1] * m.v[3][2] - m.v[3][1] * m.v[2][2]; - F32 coef10 = m.v[1][1] * m.v[3][2] - m.v[3][1] * m.v[1][2]; - F32 coef11 = m.v[1][1] * m.v[2][2] - m.v[2][1] * m.v[1][2]; - F32 coef12 = m.v[2][0] * m.v[3][3] - m.v[3][0] * m.v[2][3]; - F32 coef14 = m.v[1][0] * m.v[3][3] - m.v[3][0] * m.v[1][3]; - F32 coef15 = m.v[1][0] * m.v[2][3] - m.v[2][0] * m.v[1][3]; - F32 coef16 = m.v[2][0] * m.v[3][2] - m.v[3][0] * m.v[2][2]; - F32 coef18 = m.v[1][0] * m.v[3][2] - m.v[3][0] * m.v[1][2]; - F32 coef19 = m.v[1][0] * m.v[2][2] - m.v[2][0] * m.v[1][2]; - F32 coef20 = m.v[2][0] * m.v[3][1] - m.v[3][0] * m.v[2][1]; - F32 coef22 = m.v[1][0] * m.v[3][1] - m.v[3][0] * m.v[1][1]; - F32 coef23 = m.v[1][0] * m.v[2][1] - m.v[2][0] * m.v[1][1]; +inline MD_Mat4x4F32 +md_inverse_4x4f32(MD_Mat4x4F32 m) { + MD_F32 coef00 = m.v[2][2] * m.v[3][3] - m.v[3][2] * m.v[2][3]; + MD_F32 coef02 = m.v[1][2] * m.v[3][3] - m.v[3][2] * m.v[1][3]; + MD_F32 coef03 = m.v[1][2] * m.v[2][3] - m.v[2][2] * m.v[1][3]; + MD_F32 coef04 = m.v[2][1] * m.v[3][3] - m.v[3][1] * m.v[2][3]; + MD_F32 coef06 = m.v[1][1] * m.v[3][3] - m.v[3][1] * m.v[1][3]; + MD_F32 coef07 = m.v[1][1] * m.v[2][3] - m.v[2][1] * m.v[1][3]; + MD_F32 coef08 = m.v[2][1] * m.v[3][2] - m.v[3][1] * m.v[2][2]; + MD_F32 coef10 = m.v[1][1] * m.v[3][2] - m.v[3][1] * m.v[1][2]; + MD_F32 coef11 = m.v[1][1] * m.v[2][2] - m.v[2][1] * m.v[1][2]; + MD_F32 coef12 = m.v[2][0] * m.v[3][3] - m.v[3][0] * m.v[2][3]; + MD_F32 coef14 = m.v[1][0] * m.v[3][3] - m.v[3][0] * m.v[1][3]; + MD_F32 coef15 = m.v[1][0] * m.v[2][3] - m.v[2][0] * m.v[1][3]; + MD_F32 coef16 = m.v[2][0] * m.v[3][2] - m.v[3][0] * m.v[2][2]; + MD_F32 coef18 = m.v[1][0] * m.v[3][2] - m.v[3][0] * m.v[1][2]; + MD_F32 coef19 = m.v[1][0] * m.v[2][2] - m.v[2][0] * m.v[1][2]; + MD_F32 coef20 = m.v[2][0] * m.v[3][1] - m.v[3][0] * m.v[2][1]; + MD_F32 coef22 = m.v[1][0] * m.v[3][1] - m.v[3][0] * m.v[1][1]; + MD_F32 coef23 = m.v[1][0] * m.v[2][1] - m.v[2][0] * m.v[1][1]; - Vec4F32 fac0 = { coef00, coef00, coef02, coef03 }; - Vec4F32 fac1 = { coef04, coef04, coef06, coef07 }; - Vec4F32 fac2 = { coef08, coef08, coef10, coef11 }; - Vec4F32 fac3 = { coef12, coef12, coef14, coef15 }; - Vec4F32 fac4 = { coef16, coef16, coef18, coef19 }; - Vec4F32 fac5 = { coef20, coef20, coef22, coef23 }; + MD_Vec4F32 fac0 = { coef00, coef00, coef02, coef03 }; + MD_Vec4F32 fac1 = { coef04, coef04, coef06, coef07 }; + MD_Vec4F32 fac2 = { coef08, coef08, coef10, coef11 }; + MD_Vec4F32 fac3 = { coef12, coef12, coef14, coef15 }; + MD_Vec4F32 fac4 = { coef16, coef16, coef18, coef19 }; + MD_Vec4F32 fac5 = { coef20, coef20, coef22, coef23 }; - Vec4F32 vec0 = { m.v[1][0], m.v[0][0], m.v[0][0], m.v[0][0] }; - Vec4F32 vec1 = { m.v[1][1], m.v[0][1], m.v[0][1], m.v[0][1] }; - Vec4F32 vec2 = { m.v[1][2], m.v[0][2], m.v[0][2], m.v[0][2] }; - Vec4F32 vec3 = { m.v[1][3], m.v[0][3], m.v[0][3], m.v[0][3] }; + MD_Vec4F32 vec0 = { m.v[1][0], m.v[0][0], m.v[0][0], m.v[0][0] }; + MD_Vec4F32 vec1 = { m.v[1][1], m.v[0][1], m.v[0][1], m.v[0][1] }; + MD_Vec4F32 md_vec2 = { m.v[1][2], m.v[0][2], m.v[0][2], m.v[0][2] }; + MD_Vec4F32 md_vec3 = { m.v[1][3], m.v[0][3], m.v[0][3], m.v[0][3] }; - Vec4F32 inv0 = add_4f32(sub_4f32(mul_4f32(vec1, fac0), mul_4f32(vec2, fac1)), mul_4f32(vec3, fac2)); - Vec4F32 inv1 = add_4f32(sub_4f32(mul_4f32(vec0, fac0), mul_4f32(vec2, fac3)), mul_4f32(vec3, fac4)); - Vec4F32 inv2 = add_4f32(sub_4f32(mul_4f32(vec0, fac1), mul_4f32(vec1, fac3)), mul_4f32(vec3, fac5)); - Vec4F32 inv3 = add_4f32(sub_4f32(mul_4f32(vec0, fac2), mul_4f32(vec1, fac4)), mul_4f32(vec2, fac5)); + MD_Vec4F32 inv0 = md_add_4f32(md_sub_4f32(md_mul_4f32(vec1, fac0), md_mul_4f32(md_vec2, fac1)), md_mul_4f32(md_vec3, fac2)); + MD_Vec4F32 inv1 = md_add_4f32(md_sub_4f32(md_mul_4f32(vec0, fac0), md_mul_4f32(md_vec2, fac3)), md_mul_4f32(md_vec3, fac4)); + MD_Vec4F32 inv2 = md_add_4f32(md_sub_4f32(md_mul_4f32(vec0, fac1), md_mul_4f32(vec1, fac3)), md_mul_4f32(md_vec3, fac5)); + MD_Vec4F32 inv3 = md_add_4f32(md_sub_4f32(md_mul_4f32(vec0, fac2), md_mul_4f32(vec1, fac4)), md_mul_4f32(md_vec2, fac5)); - Vec4F32 sign_a = { +1, -1, +1, -1 }; - Vec4F32 sign_b = { -1, +1, -1, +1 }; + MD_Vec4F32 sign_a = { +1, -1, +1, -1 }; + MD_Vec4F32 sign_b = { -1, +1, -1, +1 }; - Mat4x4F32 inverse; - for(U32 i = 0; i < 4; i += 1) { + MD_Mat4x4F32 inverse; + for(MD_U32 i = 0; i < 4; i += 1) { inverse.v[0][i] = inv0.v[i] * sign_a.v[i]; inverse.v[1][i] = inv1.v[i] * sign_b.v[i]; inverse.v[2][i] = inv2.v[i] * sign_a.v[i]; inverse.v[3][i] = inv3.v[i] * sign_b.v[i]; } - Vec4F32 row0 = { inverse.v[0][0], inverse.v[1][0], inverse.v[2][0], inverse.v[3][0] }; - Vec4F32 m0 = { m.v[0][0], m.v[0][1], m.v[0][2], m.v[0][3] }; - Vec4F32 dot0 = mul_4f32(m0, row0); - F32 dot1 = (dot0.x + dot0.y) + (dot0.z + dot0.w); + MD_Vec4F32 row0 = { inverse.v[0][0], inverse.v[1][0], inverse.v[2][0], inverse.v[3][0] }; + MD_Vec4F32 m0 = { m.v[0][0], m.v[0][1], m.v[0][2], m.v[0][3] }; + MD_Vec4F32 dot0 = md_mul_4f32(m0, row0); + MD_F32 dot1 = (dot0.x + dot0.y) + (dot0.z + dot0.w); - F32 one_over_det = 1 / dot1; - return scale_4x4f32(inverse, one_over_det); + MD_F32 one_over_det = 1 / dot1; + return md_scale_4x4f32(inverse, one_over_det); } -inline Mat4x4F32 -derotate_4x4f32(Mat4x4F32 mat) { - Vec3F32 scale = { - length_3f32(v3f32(mat.v[0][0], mat.v[0][1], mat.v[0][2])), - length_3f32(v3f32(mat.v[1][0], mat.v[1][1], mat.v[1][2])), - length_3f32(v3f32(mat.v[2][0], mat.v[2][1], mat.v[2][2])), +inline MD_Mat4x4F32 +md_derotate_4x4f32(MD_Mat4x4F32 mat) { + MD_Vec3F32 scale = { + md_length_3f32(md_v3f32(mat.v[0][0], mat.v[0][1], mat.v[0][2])), + md_length_3f32(md_v3f32(mat.v[1][0], mat.v[1][1], mat.v[1][2])), + md_length_3f32(md_v3f32(mat.v[2][0], mat.v[2][1], mat.v[2][2])), }; mat.v[0][0] = scale.x; mat.v[1][0] = 0.f; mat.v[2][0] = 0.f; mat.v[0][1] = 0.f; mat.v[1][1] = scale.y; mat.v[2][1] = 0.f; @@ -773,171 +773,171 @@ derotate_4x4f32(Mat4x4F32 mat) { // ==================== 1D Ranges ==================== -#define r1u32(min, max) rng_1u32((min), (max)) -inline Rng1U32 rng_1u32 (U32 min, U32 max) { Rng1U32 r = {min, max}; if(r.min > r.max) { swap(U32, r.min, r.max); } return r; } -inline Rng1U32 shift_1u32 (Rng1U32 r, U32 x) { r.min += x; r.max += x; return r; } -inline Rng1U32 pad_1u32 (Rng1U32 r, U32 x) { r.min -= x; r.max += x; return r; } -inline U32 center_1u32 (Rng1U32 r) { U32 c = (r.min + r.max) / 2; return c; } -inline B32 contains_1u32 (Rng1U32 r, U32 x) { B32 c = (r.min <= x && x < r.max); return c; } -inline U32 dim_1u32 (Rng1U32 r) { U32 c = r.max - r.min; return c; } -inline Rng1U32 union_1u32 (Rng1U32 a, Rng1U32 b) { Rng1U32 c = {md_min(a.min, b.min), md_min(a.max, b.max)}; return c; } -inline Rng1U32 intersect_1u32(Rng1U32 a, Rng1U32 b) { Rng1U32 c = {md_max(a.min, b.min), md_min(a.max, b.max)}; return c; } -inline U32 clamp_1u32 (Rng1U32 r, U32 v) { v = clamp(r.min, v, r.max); return v; } +#define md_r1u32(md_min, md_max) md_rng_1u32((md_min), (md_max)) +inline MD_Rng1U32 md_rng_1u32 (MD_U32 md_min, MD_U32 md_max) { MD_Rng1U32 r = {md_min, md_max}; if(r.md_min > r.md_max) { md_swap(MD_U32, r.md_min, r.md_max); } return r; } +inline MD_Rng1U32 md_shift_1u32 (MD_Rng1U32 r, MD_U32 x) { r.md_min += x; r.md_max += x; return r; } +inline MD_Rng1U32 md_pad_1u32 (MD_Rng1U32 r, MD_U32 x) { r.md_min -= x; r.md_max += x; return r; } +inline MD_U32 md_center_1u32 (MD_Rng1U32 r) { MD_U32 c = (r.md_min + r.md_max) / 2; return c; } +inline MD_B32 md_contains_1u32 (MD_Rng1U32 r, MD_U32 x) { MD_B32 c = (r.md_min <= x && x < r.md_max); return c; } +inline MD_U32 md_dim_1u32 (MD_Rng1U32 r) { MD_U32 c = r.md_max - r.md_min; return c; } +inline MD_Rng1U32 md_union_1u32 (MD_Rng1U32 a, MD_Rng1U32 b) { MD_Rng1U32 c = {md_min(a.md_min, b.md_min), md_min(a.md_max, b.md_max)}; return c; } +inline MD_Rng1U32 md_intersect_1u32(MD_Rng1U32 a, MD_Rng1U32 b) { MD_Rng1U32 c = {md_max(a.md_min, b.md_min), md_min(a.md_max, b.md_max)}; return c; } +inline MD_U32 md_clamp_1u32 (MD_Rng1U32 r, MD_U32 v) { v = md_clamp(r.md_min, v, r.md_max); return v; } -#define r1s32(min, max) rng_1s32((min), (max)) -inline Rng1S32 rng_1s32 (S32 min, S32 max) { Rng1S32 r = {min, max}; if(r.min > r.max) { swap(S32, r.min, r.max); } return r; } -inline Rng1S32 shift_1s32 (Rng1S32 r, S32 x) { r.min += x; r.max += x; return r; } -inline Rng1S32 pad_1s32 (Rng1S32 r, S32 x) { r.min -= x; r.max += x; return r; } -inline S32 center_1s32 (Rng1S32 r) { S32 c = (r.min+r.max) / 2; return c; } -inline B32 contains_1s32 (Rng1S32 r, S32 x) { B32 c = (r.min <= x && x < r.max); return c; } -inline S32 dim_1s32 (Rng1S32 r) { S32 c = r.max-r.min; return c; } -inline Rng1S32 union_1s32 (Rng1S32 a, Rng1S32 b) { Rng1S32 c = {md_min(a.min, b.min), md_max(a.max, b.max)}; return c; } -inline Rng1S32 intersect_1s32(Rng1S32 a, Rng1S32 b) { Rng1S32 c = {md_max(a.min, b.min), md_min(a.max, b.max)}; return c; } -inline S32 clamp_1s32 (Rng1S32 r, S32 v) { v = clamp(r.min, v, r.max); return v; } +#define md_r1s32(md_min, md_max) md_rng_1s32((md_min), (md_max)) +inline MD_Rng1S32 md_rng_1s32 (MD_S32 md_min, MD_S32 md_max) { MD_Rng1S32 r = {md_min, md_max}; if(r.md_min > r.md_max) { md_swap(MD_S32, r.md_min, r.md_max); } return r; } +inline MD_Rng1S32 md_shift_1s32 (MD_Rng1S32 r, MD_S32 x) { r.md_min += x; r.md_max += x; return r; } +inline MD_Rng1S32 md_pad_1s32 (MD_Rng1S32 r, MD_S32 x) { r.md_min -= x; r.md_max += x; return r; } +inline MD_S32 md_center_1s32 (MD_Rng1S32 r) { MD_S32 c = (r.md_min+r.md_max) / 2; return c; } +inline MD_B32 md_contains_1s32 (MD_Rng1S32 r, MD_S32 x) { MD_B32 c = (r.md_min <= x && x < r.md_max); return c; } +inline MD_S32 md_dim_1s32 (MD_Rng1S32 r) { MD_S32 c = r.md_max-r.md_min; return c; } +inline MD_Rng1S32 md_union_1s32 (MD_Rng1S32 a, MD_Rng1S32 b) { MD_Rng1S32 c = {md_min(a.md_min, b.md_min), md_max(a.md_max, b.md_max)}; return c; } +inline MD_Rng1S32 md_intersect_1s32(MD_Rng1S32 a, MD_Rng1S32 b) { MD_Rng1S32 c = {md_max(a.md_min, b.md_min), md_min(a.md_max, b.md_max)}; return c; } +inline MD_S32 md_clamp_1s32 (MD_Rng1S32 r, MD_S32 v) { v = md_clamp(r.md_min, v, r.md_max); return v; } -#define r1u64(min, max) rng_1u64((min), (max)) -inline Rng1U64 rng_1u64 (U64 min, U64 max) { Rng1U64 r = {min, max}; if(r.min > r.max) { swap(U64, r.min, r.max); } return r; } -inline Rng1U64 shift_1u64 (Rng1U64 r, U64 x) { r.min += x; r.max += x; return r; } -inline Rng1U64 pad_1u64 (Rng1U64 r, U64 x) { r.min -= x; r.max += x; return r; } -inline U64 center_1u64 (Rng1U64 r) { U64 c = (r.min + r.max)/2; return c; } -inline B32 contains_1u64 (Rng1U64 r, U64 x) { B32 c = (r.min <= x && x < r.max); return c; } -inline U64 dim_1u64 (Rng1U64 r) { U64 c = r.max-r.min; return c; } -inline Rng1U64 union_1u64 (Rng1U64 a, Rng1U64 b) { Rng1U64 c = {md_min(a.min, b.min), md_max(a.max, b.max)}; return c; } -inline Rng1U64 intersect_1u64(Rng1U64 a, Rng1U64 b) { Rng1U64 c = {md_max(a.min, b.min), md_min(a.max, b.max)}; return c; } -inline U64 clamp_1u64 (Rng1U64 r, U64 v) { v = clamp(r.min, v, r.max); return v; } +#define md_r1u64(md_min, md_max) md_rng_1u64((md_min), (md_max)) +inline MD_Rng1U64 md_rng_1u64 (MD_U64 md_min, MD_U64 md_max) { MD_Rng1U64 r = {md_min, md_max}; if(r.md_min > r.md_max) { md_swap(MD_U64, r.md_min, r.md_max); } return r; } +inline MD_Rng1U64 md_shift_1u64 (MD_Rng1U64 r, MD_U64 x) { r.md_min += x; r.md_max += x; return r; } +inline MD_Rng1U64 md_pad_1u64 (MD_Rng1U64 r, MD_U64 x) { r.md_min -= x; r.md_max += x; return r; } +inline MD_U64 md_center_1u64 (MD_Rng1U64 r) { MD_U64 c = (r.md_min + r.md_max)/2; return c; } +inline MD_B32 md_contains_1u64 (MD_Rng1U64 r, MD_U64 x) { MD_B32 c = (r.md_min <= x && x < r.md_max); return c; } +inline MD_U64 md_dim_1u64 (MD_Rng1U64 r) { MD_U64 c = r.md_max-r.md_min; return c; } +inline MD_Rng1U64 md_union_1u64 (MD_Rng1U64 a, MD_Rng1U64 b) { MD_Rng1U64 c = {md_min(a.md_min, b.md_min), md_max(a.md_max, b.md_max)}; return c; } +inline MD_Rng1U64 md_intersect_1u64(MD_Rng1U64 a, MD_Rng1U64 b) { MD_Rng1U64 c = {md_max(a.md_min, b.md_min), md_min(a.md_max, b.md_max)}; return c; } +inline MD_U64 md_clamp_1u64 (MD_Rng1U64 r, MD_U64 v) { v = md_clamp(r.md_min, v, r.md_max); return v; } -#define r1s64(min, max) rng_1s64((min), (max)) -inline Rng1S64 rng_1s64 (S64 min, S64 max) { Rng1S64 r = {min, max}; if(r.min > r.max) { swap(S64, r.min, r.max); } return r; } -inline Rng1S64 shift_1s64 (Rng1S64 r, S64 x) { r.min += x; r.max += x; return r; } -inline Rng1S64 pad_1s64 (Rng1S64 r, S64 x) { r.min -= x; r.max += x; return r; } -inline S64 center_1s64 (Rng1S64 r) { S64 c = (r.min + r.max) / 2; return c; } -inline B32 contains_1s64 (Rng1S64 r, S64 x) { B32 c = (r.min <= x && x < r.max); return c; } -inline S64 dim_1s64 (Rng1S64 r) { S64 c = r.max - r.min; return c; } -inline Rng1S64 union_1s64 (Rng1S64 a, Rng1S64 b) { Rng1S64 c = {md_min(a.min, b.min), md_max(a.max, b.max)}; return c; } -inline Rng1S64 intersect_1s64(Rng1S64 a, Rng1S64 b) { Rng1S64 c = {md_max(a.min, b.min), md_min(a.max, b.max)}; return c; } -inline S64 clamp_1s64 (Rng1S64 r, S64 v) { v = clamp(r.min, v, r.max); return v;} +#define md_r1s64(md_min, md_max) md_rng_1s64((md_min), (md_max)) +inline Rng1S64 md_rng_1s64 (MD_S64 md_min, MD_S64 md_max) { Rng1S64 r = {md_min, md_max}; if(r.md_min > r.md_max) { md_swap(MD_S64, r.md_min, r.md_max); } return r; } +inline Rng1S64 md_shift_1s64 (Rng1S64 r, MD_S64 x) { r.md_min += x; r.md_max += x; return r; } +inline Rng1S64 md_pad_1s64 (Rng1S64 r, MD_S64 x) { r.md_min -= x; r.md_max += x; return r; } +inline MD_S64 md_center_1s64 (Rng1S64 r) { MD_S64 c = (r.md_min + r.md_max) / 2; return c; } +inline MD_B32 md_contains_1s64 (Rng1S64 r, MD_S64 x) { MD_B32 c = (r.md_min <= x && x < r.md_max); return c; } +inline MD_S64 md_dim_1s64 (Rng1S64 r) { MD_S64 c = r.md_max - r.md_min; return c; } +inline Rng1S64 md_union_1s64 (Rng1S64 a, Rng1S64 b) { Rng1S64 c = {md_min(a.md_min, b.md_min), md_max(a.md_max, b.md_max)}; return c; } +inline Rng1S64 md_intersect_1s64(Rng1S64 a, Rng1S64 b) { Rng1S64 c = {md_max(a.md_min, b.md_min), md_min(a.md_max, b.md_max)}; return c; } +inline MD_S64 md_clamp_1s64 (Rng1S64 r, MD_S64 v) { v = md_clamp(r.md_min, v, r.md_max); return v;} -#define r1f32(min, max) rng_1f32((min), (max)) -inline Rng1F32 rng_1f32 (F32 min, F32 max) { Rng1F32 r = {min, max}; if(r.min > r.max) { swap(F32, r.min, r.max); } return r; } -inline Rng1F32 shift_1f32 (Rng1F32 r, F32 x) { r.min += x; r.max += x; return r; } -inline Rng1F32 pad_1f32 (Rng1F32 r, F32 x) { r.min -= x; r.max += x; return r; } -inline F32 center_1f32 (Rng1F32 r) { F32 c = (r.min + r.max) / 2; return c; } -inline B32 contains_1f32 (Rng1F32 r, F32 x) { B32 c = (r.min <= x && x < r.max); return c; } -inline F32 dim_1f32 (Rng1F32 r) { F32 c = r.max - r.min; return c; } -inline Rng1F32 union_1f32 (Rng1F32 a, Rng1F32 b) { Rng1F32 c = {md_min(a.min, b.min), md_max(a.max, b.max)}; return c; } -inline Rng1F32 intersect_1f32(Rng1F32 a, Rng1F32 b) { Rng1F32 c = {md_max(a.min, b.min), md_min(a.max, b.max)}; return c; } -inline F32 clamp_1f32 (Rng1F32 r, F32 v) { v = clamp(r.min, v, r.max); return v; } +#define md_r1f32(md_min, md_max) md_rng_1f32((md_min), (md_max)) +inline Rng1F32 md_rng_1f32 (MD_F32 md_min, MD_F32 md_max) { Rng1F32 r = {md_min, md_max}; if(r.md_min > r.md_max) { md_swap(MD_F32, r.md_min, r.md_max); } return r; } +inline Rng1F32 md_shift_1f32 (Rng1F32 r, MD_F32 x) { r.md_min += x; r.md_max += x; return r; } +inline Rng1F32 md_pad_1f32 (Rng1F32 r, MD_F32 x) { r.md_min -= x; r.md_max += x; return r; } +inline MD_F32 md_center_1f32 (Rng1F32 r) { MD_F32 c = (r.md_min + r.md_max) / 2; return c; } +inline MD_B32 md_contains_1f32 (Rng1F32 r, MD_F32 x) { MD_B32 c = (r.md_min <= x && x < r.md_max); return c; } +inline MD_F32 md_dim_1f32 (Rng1F32 r) { MD_F32 c = r.md_max - r.md_min; return c; } +inline Rng1F32 md_union_1f32 (Rng1F32 a, Rng1F32 b) { Rng1F32 c = {md_min(a.md_min, b.md_min), md_max(a.md_max, b.md_max)}; return c; } +inline Rng1F32 md_intersect_1f32(Rng1F32 a, Rng1F32 b) { Rng1F32 c = {md_max(a.md_min, b.md_min), md_min(a.md_max, b.md_max)}; return c; } +inline MD_F32 md_clamp_1f32 (Rng1F32 r, MD_F32 v) { v = md_clamp(r.md_min, v, r.md_max); return v; } // ==================== 2D Ranges ==================== -#define r2s16(min, max) rng_2s16((min), (max)) -#define r2s16p(x, y, z, w) r2s16(v2s16((x), (y)), v2s16((z), (w))) -inline Rng2S16 rng_2s16 (Vec2S16 min, Vec2S16 max) { Rng2S16 r = {min, max}; return r; } -inline Rng2S16 shift_2s16 (Rng2S16 r, Vec2S16 x) { r.min = add_2s16(r.min, x); r.max = add_2s16(r.max, x); return r; } -inline Rng2S16 pad_2s16 (Rng2S16 r, S16 x) { Vec2S16 xv = {x, x}; r.min = sub_2s16(r.min, xv); r.max = add_2s16(r.max, xv); return r; } -inline Vec2S16 center_2s16 (Rng2S16 r) { Vec2S16 c = {(S16)((r.min.x + r.max.x) / 2), (S16)((r.min.y + r.max.y) / 2)}; return c; } -inline B32 contains_2s16 (Rng2S16 r, Vec2S16 x) { B32 c = (r.min.x <= x.x && x.x < r.max.x && r.min.y <= x.y && x.y < r.max.y); return c; } -inline Vec2S16 dim_2s16 (Rng2S16 r) { Vec2S16 dim = {(S16)(r.max.x - r.min.x), (S16)(r.max.y - r.min.y)}; return dim; } -inline Rng2S16 union_2s16 (Rng2S16 a, Rng2S16 b) { Rng2S16 c; c.p0.x = md_min(a.min.x, b.min.x); c.p0.y = md_min(a.min.y, b.min.y); c.p1.x = md_max(a.max.x, b.max.x); c.p1.y = md_max(a.max.y, b.max.y); return c; } -inline Rng2S16 intersect_2s16(Rng2S16 a, Rng2S16 b) { Rng2S16 c; c.p0.x = md_max(a.min.x, b.min.x); c.p0.y = md_max(a.min.y, b.min.y); c.p1.x = md_min(a.max.x, b.max.x); c.p1.y = md_min(a.max.y, b.max.y); return c; } -inline Vec2S16 clamp_2s16 (Rng2S16 r, Vec2S16 v) { v.x = clamp(r.min.x, v.x, r.max.x); v.y = clamp(r.min.y, v.y, r.max.y); return v; } +#define md_r2s16(md_min, md_max) md_rng_2s16((md_min), (md_max)) +#define md_r2s16p(x, y, z, w) md_r2s16(md_v2s16((x), (y)), md_v2s16((z), (w))) +inline MD_Rng2S16 md_rng_2s16 (MD_Vec2S16 md_min, MD_Vec2S16 md_max) { MD_Rng2S16 r = {md_min, md_max}; return r; } +inline MD_Rng2S16 md_shift_2s16 (MD_Rng2S16 r, MD_Vec2S16 x) { r.md_min = md_add_2s16(r.md_min, x); r.md_max = md_add_2s16(r.md_max, x); return r; } +inline MD_Rng2S16 md_pad_2s16 (MD_Rng2S16 r, MD_S16 x) { MD_Vec2S16 xv = {x, x}; r.md_min = md_sub_2s16(r.md_min, xv); r.md_max = md_add_2s16(r.md_max, xv); return r; } +inline MD_Vec2S16 md_center_2s16 (MD_Rng2S16 r) { MD_Vec2S16 c = {(MD_S16)((r.md_min.x + r.md_max.x) / 2), (MD_S16)((r.md_min.y + r.md_max.y) / 2)}; return c; } +inline MD_B32 md_contains_2s16 (MD_Rng2S16 r, MD_Vec2S16 x) { MD_B32 c = (r.md_min.x <= x.x && x.x < r.md_max.x && r.md_min.y <= x.y && x.y < r.md_max.y); return c; } +inline MD_Vec2S16 md_dim_2s16 (MD_Rng2S16 r) { MD_Vec2S16 dim = {(MD_S16)(r.md_max.x - r.md_min.x), (MD_S16)(r.md_max.y - r.md_min.y)}; return dim; } +inline MD_Rng2S16 md_union_2s16 (MD_Rng2S16 a, MD_Rng2S16 b) { MD_Rng2S16 c; c.p0.x = md_min(a.md_min.x, b.md_min.x); c.p0.y = md_min(a.md_min.y, b.md_min.y); c.p1.x = md_max(a.md_max.x, b.md_max.x); c.p1.y = md_max(a.md_max.y, b.md_max.y); return c; } +inline MD_Rng2S16 md_intersect_2s16(MD_Rng2S16 a, MD_Rng2S16 b) { MD_Rng2S16 c; c.p0.x = md_max(a.md_min.x, b.md_min.x); c.p0.y = md_max(a.md_min.y, b.md_min.y); c.p1.x = md_min(a.md_max.x, b.md_max.x); c.p1.y = md_min(a.md_max.y, b.md_max.y); return c; } +inline MD_Vec2S16 md_clamp_2s16 (MD_Rng2S16 r, MD_Vec2S16 v) { v.x = md_clamp(r.md_min.x, v.x, r.md_max.x); v.y = md_clamp(r.md_min.y, v.y, r.md_max.y); return v; } -#define r2s32(min, max) rng_2s32((min), (max)) -#define r2s32p(x, y, z, w) r2s32(v2s32((x), (y)), v2s32((z), (w))) -inline Rng2S32 rng_2s32 (Vec2S32 min, Vec2S32 max) { Rng2S32 r = {min, max}; return r; } -inline Rng2S32 shift_2s32 (Rng2S32 r, Vec2S32 x) { r.min = add_2s32(r.min, x); r.max = add_2s32(r.max, x); return r; } -inline Rng2S32 pad_2s32 (Rng2S32 r, S32 x) { Vec2S32 xv = {x, x}; r.min = sub_2s32(r.min, xv); r.max = add_2s32(r.max, xv); return r; } -inline Vec2S32 center_2s32 (Rng2S32 r) { Vec2S32 c = {(r.min.x + r.max.x) / 2, (r.min.y + r.max.y) / 2}; return c; } -inline B32 contains_2s32 (Rng2S32 r, Vec2S32 x) { B32 c = (r.min.x <= x.x && x.x < r.max.x && r.min.y <= x.y && x.y < r.max.y); return c; } -inline Vec2S32 dim_2s32 (Rng2S32 r) { Vec2S32 dim = {r.max.x - r.min.x, r.max.y - r.min.y}; return dim; } -inline Rng2S32 union_2s32 (Rng2S32 a, Rng2S32 b) { Rng2S32 c; c.p0.x = md_min(a.min.x, b.min.x); c.p0.y = md_min(a.min.y, b.min.y); c.p1.x = md_max(a.max.x, b.max.x); c.p1.y = md_max(a.max.y, b.max.y); return c; } -inline Rng2S32 intersect_2s32(Rng2S32 a, Rng2S32 b) { Rng2S32 c; c.p0.x = md_max(a.min.x, b.min.x); c.p0.y = md_max(a.min.y, b.min.y); c.p1.x = md_min(a.max.x, b.max.x); c.p1.y = md_min(a.max.y, b.max.y); return c; } -inline Vec2S32 clamp_2s32 (Rng2S32 r, Vec2S32 v) { v.x = clamp(r.min.x, v.x, r.max.x); v.y = clamp(r.min.y, v.y, r.max.y); return v; } +#define md_r2s32(md_min, md_max) md_rng_2s32((md_min), (md_max)) +#define md_r2s32p(x, y, z, w) md_r2s32(md_v2s32((x), (y)), md_v2s32((z), (w))) +inline MD_Rng2S32 md_rng_2s32 (MD_Vec2S32 md_min, MD_Vec2S32 md_max) { MD_Rng2S32 r = {md_min, md_max}; return r; } +inline MD_Rng2S32 md_shift_2s32 (MD_Rng2S32 r, MD_Vec2S32 x) { r.md_min = md_add_2s32(r.md_min, x); r.md_max = md_add_2s32(r.md_max, x); return r; } +inline MD_Rng2S32 md_pad_2s32 (MD_Rng2S32 r, MD_S32 x) { MD_Vec2S32 xv = {x, x}; r.md_min = md_sub_2s32(r.md_min, xv); r.md_max = md_add_2s32(r.md_max, xv); return r; } +inline MD_Vec2S32 md_center_2s32 (MD_Rng2S32 r) { MD_Vec2S32 c = {(r.md_min.x + r.md_max.x) / 2, (r.md_min.y + r.md_max.y) / 2}; return c; } +inline MD_B32 md_contains_2s32 (MD_Rng2S32 r, MD_Vec2S32 x) { MD_B32 c = (r.md_min.x <= x.x && x.x < r.md_max.x && r.md_min.y <= x.y && x.y < r.md_max.y); return c; } +inline MD_Vec2S32 md_dim_2s32 (MD_Rng2S32 r) { MD_Vec2S32 dim = {r.md_max.x - r.md_min.x, r.md_max.y - r.md_min.y}; return dim; } +inline MD_Rng2S32 md_union_2s32 (MD_Rng2S32 a, MD_Rng2S32 b) { MD_Rng2S32 c; c.p0.x = md_min(a.md_min.x, b.md_min.x); c.p0.y = md_min(a.md_min.y, b.md_min.y); c.p1.x = md_max(a.md_max.x, b.md_max.x); c.p1.y = md_max(a.md_max.y, b.md_max.y); return c; } +inline MD_Rng2S32 md_intersect_2s32(MD_Rng2S32 a, MD_Rng2S32 b) { MD_Rng2S32 c; c.p0.x = md_max(a.md_min.x, b.md_min.x); c.p0.y = md_max(a.md_min.y, b.md_min.y); c.p1.x = md_min(a.md_max.x, b.md_max.x); c.p1.y = md_min(a.md_max.y, b.md_max.y); return c; } +inline MD_Vec2S32 md_clamp_2s32 (MD_Rng2S32 r, MD_Vec2S32 v) { v.x = md_clamp(r.md_min.x, v.x, r.md_max.x); v.y = md_clamp(r.md_min.y, v.y, r.md_max.y); return v; } -#define r2s64(min, max) rng_2s64((min), (max)) -#define r2s64p(x, y, z, w) r2s64(v2s64((x), (y)), v2s64((z), (w))) -inline Rng2S64 rng_2s64 (Vec2S64 min, Vec2S64 max) { Rng2S64 r = {min, max}; return r; } -inline Rng2S64 shift_2s64 (Rng2S64 r, Vec2S64 x) { r.min = add_2s64(r.min, x); r.max = add_2s64(r.max, x); return r; } -inline Rng2S64 pad_2s64 (Rng2S64 r, S64 x) { Vec2S64 xv = {x, x}; r.min = sub_2s64(r.min, xv); r.max = add_2s64(r.max, xv); return r; } -inline Vec2S64 center_2s64 (Rng2S64 r) { Vec2S64 c = {(r.min.x + r.max.x) / 2, (r.min.y + r.max.y) / 2}; return c; } -inline B32 contains_2s64 (Rng2S64 r, Vec2S64 x) { B32 c = (r.min.x <= x.x && x.x < r.max.x && r.min.y <= x.y && x.y < r.max.y); return c; } -inline Vec2S64 dim_2s64 (Rng2S64 r) { Vec2S64 dim = {r.max.x - r.min.x, r.max.y - r.min.y}; return dim; } -inline Rng2S64 union_2s64 (Rng2S64 a, Rng2S64 b) { Rng2S64 c; c.p0.x = md_min(a.min.x, b.min.x); c.p0.y = md_min(a.min.y, b.min.y); c.p1.x = md_max(a.max.x, b.max.x); c.p1.y = md_max(a.max.y, b.max.y); return c; } -inline Rng2S64 intersect_2s64(Rng2S64 a, Rng2S64 b) { Rng2S64 c; c.p0.x = md_max(a.min.x, b.min.x); c.p0.y = md_max(a.min.y, b.min.y); c.p1.x = md_min(a.max.x, b.max.x); c.p1.y = md_min(a.max.y, b.max.y); return c; } -inline Vec2S64 clamp_2s64 (Rng2S64 r, Vec2S64 v) { v.x = clamp(r.min.x, v.x, r.max.x); v.y = clamp(r.min.y, v.y, r.max.y); return v; } +#define md_r2s64(md_min, md_max) md_rng_2s64((md_min), (md_max)) +#define md_r2s64p(x, y, z, w) md_r2s64(md_v2s64((x), (y)), md_v2s64((z), (w))) +inline MD_Rng2S64 md_rng_2s64 (MD_Vec2S64 md_min, MD_Vec2S64 md_max) { MD_Rng2S64 r = {md_min, md_max}; return r; } +inline MD_Rng2S64 md_shift_2s64 (MD_Rng2S64 r, MD_Vec2S64 x) { r.md_min = md_add_2s64(r.md_min, x); r.md_max = md_add_2s64(r.md_max, x); return r; } +inline MD_Rng2S64 md_pad_2s64 (MD_Rng2S64 r, MD_S64 x) { MD_Vec2S64 xv = {x, x}; r.md_min = md_sub_2s64(r.md_min, xv); r.md_max = md_add_2s64(r.md_max, xv); return r; } +inline MD_Vec2S64 md_center_2s64 (MD_Rng2S64 r) { MD_Vec2S64 c = {(r.md_min.x + r.md_max.x) / 2, (r.md_min.y + r.md_max.y) / 2}; return c; } +inline MD_B32 md_contains_2s64 (MD_Rng2S64 r, MD_Vec2S64 x) { MD_B32 c = (r.md_min.x <= x.x && x.x < r.md_max.x && r.md_min.y <= x.y && x.y < r.md_max.y); return c; } +inline MD_Vec2S64 md_dim_2s64 (MD_Rng2S64 r) { MD_Vec2S64 dim = {r.md_max.x - r.md_min.x, r.md_max.y - r.md_min.y}; return dim; } +inline MD_Rng2S64 md_union_2s64 (MD_Rng2S64 a, MD_Rng2S64 b) { MD_Rng2S64 c; c.p0.x = md_min(a.md_min.x, b.md_min.x); c.p0.y = md_min(a.md_min.y, b.md_min.y); c.p1.x = md_max(a.md_max.x, b.md_max.x); c.p1.y = md_max(a.md_max.y, b.md_max.y); return c; } +inline MD_Rng2S64 md_intersect_2s64(MD_Rng2S64 a, MD_Rng2S64 b) { MD_Rng2S64 c; c.p0.x = md_max(a.md_min.x, b.md_min.x); c.p0.y = md_max(a.md_min.y, b.md_min.y); c.p1.x = md_min(a.md_max.x, b.md_max.x); c.p1.y = md_min(a.md_max.y, b.md_max.y); return c; } +inline MD_Vec2S64 md_clamp_2s64 (MD_Rng2S64 r, MD_Vec2S64 v) { v.x = md_clamp(r.md_min.x, v.x, r.md_max.x); v.y = md_clamp(r.md_min.y, v.y, r.md_max.y); return v; } //////////////////////////////// //~ rjf: Miscellaneous Ops -Vec3F32 hsv_from_rgb (Vec3F32 rgb); -Vec3F32 rgb_from_hsv (Vec3F32 hsv); -Vec4F32 hsva_from_rgba(Vec4F32 rgba); -Vec4F32 rgba_from_hsva(Vec4F32 hsva); -Vec4F32 rgba_from_u32 (U32 hex); -U32 u32_from_rgba (Vec4F32 rgba); +MD_Vec3F32 md_hsv_from_rgb (MD_Vec3F32 rgb); +MD_Vec3F32 md_rgb_from_hsv (MD_Vec3F32 hsv); +MD_Vec4F32 md_hsva_from_rgba(MD_Vec4F32 rgba); +MD_Vec4F32 md_rgba_from_hsva(MD_Vec4F32 hsva); +MD_Vec4F32 md_rgba_from_u32 (MD_U32 hex); +MD_U32 md_u32_from_rgba (MD_Vec4F32 rgba); -inline Vec3F32 -hsv_from_rgb(Vec3F32 rgb) +inline MD_Vec3F32 +md_hsv_from_rgb(MD_Vec3F32 rgb) { - F32 c_max = md_max(rgb.x, md_max(rgb.y, rgb.z)); - F32 c_min = md_min(rgb.x, md_min(rgb.y, rgb.z)); - F32 delta = c_max - c_min; - F32 q_delta = 1.0f / delta; - F32 h = ( + MD_F32 c_max = md_max(rgb.x, md_max(rgb.y, rgb.z)); + MD_F32 c_min = md_min(rgb.x, md_min(rgb.y, rgb.z)); + MD_F32 delta = c_max - c_min; + MD_F32 q_delta = 1.0f / delta; + MD_F32 h = ( (delta == 0.f) ? 0.f : - (c_max == rgb.x) ? mod_f32((rgb.y - rgb.z) * q_delta + 6.f, 6.f) : + (c_max == rgb.x) ? md_mod_f32((rgb.y - rgb.z) * q_delta + 6.f, 6.f) : (c_max == rgb.y) ? (rgb.z - rgb.x) * q_delta + 2.f : (c_max == rgb.z) ? (rgb.x - rgb.y) * q_delta + 4.f : 0.f ); - F32 s = (c_max == 0.f) ? 0.f : (delta / c_max); - F32 v = c_max; - Vec3F32 hsv = {h * (1.0f / 6.f), s, v}; + MD_F32 s = (c_max == 0.f) ? 0.f : (delta / c_max); + MD_F32 v = c_max; + MD_Vec3F32 hsv = {h * (1.0f / 6.f), s, v}; return hsv; } -inline Vec3F32 -rgb_from_hsv(Vec3F32 hsv) { - F32 h = mod_f32(hsv.x * 360.f, 360.f); - F32 s = hsv.y; - F32 v = hsv.z; - F32 c = v * s; - F32 x = c * (1.f - abs_f32(mod_f32(h / 60.f, 2.f) - 1.f)); - F32 m = v - c; - F32 r = 0; - F32 g = 0; - F32 b = 0; +inline MD_Vec3F32 +md_rgb_from_hsv(MD_Vec3F32 hsv) { + MD_F32 h = md_mod_f32(hsv.x * 360.f, 360.f); + MD_F32 s = hsv.y; + MD_F32 v = hsv.z; + MD_F32 c = v * s; + MD_F32 x = c * (1.f - md_abs_f32(md_mod_f32(h / 60.f, 2.f) - 1.f)); + MD_F32 m = v - c; + MD_F32 r = 0; + MD_F32 g = 0; + MD_F32 b = 0; if ((h >= 0.f && h < 60.f ) || (h >= 360.f && h < 420.f)) { r = c; g = x; b = 0; } else if ( h >= 60.f && h < 120.f) { r = x; g = c; b = 0; } else if ( h >= 120.f && h < 180.f) { r = 0; g = c; b = x; } else if ( h >= 180.f && h < 240.f ) { r = 0; g = x; b = c; } else if ( h >= 240.f && h < 300.f ) { r = x; g = 0; b = c; } else if ((h >= 300.f && h <= 360.f) || (h >= -60.f && h <= 0.f)) { r = c; g = 0; b = x; } - Vec3F32 rgb = {r + m, g + m, b + m}; + MD_Vec3F32 rgb = {r + m, g + m, b + m}; return(rgb); } -inline Vec4F32 -hsva_from_rgba(Vec4F32 rgba) { - Vec3F32 rgb = v3f32(rgba.x, rgba.y, rgba.z); - Vec3F32 hsv = hsv_from_rgb(rgb); - Vec4F32 hsva = v4f32(hsv.x, hsv.y, hsv.z, rgba.w); +inline MD_Vec4F32 +md_hsva_from_rgba(MD_Vec4F32 rgba) { + MD_Vec3F32 rgb = md_v3f32(rgba.x, rgba.y, rgba.z); + MD_Vec3F32 hsv = md_hsv_from_rgb(rgb); + MD_Vec4F32 hsva = md_v4f32(hsv.x, hsv.y, hsv.z, rgba.w); return hsva; } -inline Vec4F32 -rgba_from_hsva(Vec4F32 hsva) +inline MD_Vec4F32 +md_rgba_from_hsva(MD_Vec4F32 hsva) { - Vec3F32 hsv = v3f32(hsva.x, hsva.y, hsva.z); - Vec3F32 rgb = rgb_from_hsv(hsv); - Vec4F32 rgba = v4f32(rgb.x, rgb.y, rgb.z, hsva.w); + MD_Vec3F32 hsv = md_v3f32(hsva.x, hsva.y, hsva.z); + MD_Vec3F32 rgb = md_rgb_from_hsv(hsv); + MD_Vec4F32 rgba = md_v4f32(rgb.x, rgb.y, rgb.z, hsva.w); return rgba; } -inline Vec4F32 -rgba_from_u32(U32 hex) +inline MD_Vec4F32 +md_rgba_from_u32(MD_U32 hex) { - Vec4F32 result = v4f32( + MD_Vec4F32 result = md_v4f32( ((hex&0xff000000) >> 24) / 255.f, ((hex&0x00ff0000) >> 16) / 255.f, ((hex&0x0000ff00) >> 8) / 255.f, @@ -945,18 +945,18 @@ rgba_from_u32(U32 hex) return result; } -inline U32 -u32_from_rgba(Vec4F32 rgba) +inline MD_U32 +md_u32_from_rgba(MD_Vec4F32 rgba) { - U32 result = 0; - result |= ((U32)((U8)(rgba.x * 255.f))) << 24; - result |= ((U32)((U8)(rgba.y * 255.f))) << 16; - result |= ((U32)((U8)(rgba.z * 255.f))) << 8; - result |= ((U32)((U8)(rgba.w * 255.f))) << 0; + MD_U32 result = 0; + result |= ((MD_U32)((MD_U8)(rgba.x * 255.f))) << 24; + result |= ((MD_U32)((MD_U8)(rgba.y * 255.f))) << 16; + result |= ((MD_U32)((MD_U8)(rgba.z * 255.f))) << 8; + result |= ((MD_U32)((MD_U8)(rgba.w * 255.f))) << 0; return result; } -#define rgba_from_u32_lit_comp(h) \ +#define md_rgba_from_u32_lit_comp(h) \ { \ (((h) & 0xff000000) >> 24) / 255.f, \ (((h) & 0x00ff0000) >> 16) / 255.f, \ @@ -967,33 +967,33 @@ u32_from_rgba(Vec4F32 rgba) //////////////////////////////// //~ rjf: List Type Functions -void rng1s64_list_push__arena (Arena* arena, Rng1S64List* list, Rng1S64 rng); -void rng1s64_list_push__ainfo (AllocatorInfo ainfo, Rng1S64List* list, Rng1S64 rng); -Rng1S64Array rng1s64_array_from_list_push__arena(Arena* arena, Rng1S64List* list); -Rng1S64Array rng1s64_array_from_list_push__ainfo(AllocatorInfo ainfo, Rng1S64List* list); +void md_rng1s64_list_push__arena (MD_Arena* arena, MD_Rng1S64List* list, Rng1S64 rng); +void md_rng1s64_list_push__ainfo (MD_AllocatorInfo ainfo, MD_Rng1S64List* list, Rng1S64 rng); +MD_Rng1S64Array md_rng1s64_array_from_list_push__arena(MD_Arena* arena, MD_Rng1S64List* list); +MD_Rng1S64Array md_rng1s64_array_from_list_push__ainfo(MD_AllocatorInfo ainfo, MD_Rng1S64List* list); -#define rng1s64_list_push(allocator, list, rng) _Generic(allocator, Arena*: rng1s64_list_push__arena, AllocatorInfo: rng1s64_list_push__ainfo, default: assert_generic_sel_fail) generic_call(allocator, list, rng) -#define rng1s64_array_from_list_push(allocator, list) _Generic(allocator, Arena*: rng1s64_array_from_list_push__arena, AllocatorInfo: rng1s64_array_from_list_push__ainfo, default: assert_generic_sel_fail) generic_call(allocator, list) +#define rng1s64_list_push(allocator, list, rng) _Generic(allocator, MD_Arena*: md_rng1s64_list_push__arena, MD_AllocatorInfo: md_rng1s64_list_push__ainfo, default: md_assert_generic_sel_fail) md_generic_call(allocator, list, rng) +#define md_rng1s64_array_from_list_push(allocator, list) _Generic(allocator, MD_Arena*: md_rng1s64_array_from_list_push__arena, MD_AllocatorInfo: md_rng1s64_array_from_list_push__ainfo, default: md_assert_generic_sel_fail) md_generic_call(allocator, list) -force_inline void rng1s64_list_push__arena (Arena* arena, Rng1S64List* list, Rng1S64 rng) { rng1s64_list_push__ainfo (arena_allocator(arena), list, rng); } -force_inline Rng1S64Array rng1s64_array_from_list_push__arena(Arena* arena, Rng1S64List* list) { return rng1s64_array_from_list_push__ainfo(arena_allocator(arena), list); } +md_force_inline void md_rng1s64_list_push__arena (MD_Arena* arena, MD_Rng1S64List* list, Rng1S64 rng) { md_rng1s64_list_push__ainfo (md_arena_allocator(arena), list, rng); } +md_force_inline MD_Rng1S64Array md_rng1s64_array_from_list_push__arena(MD_Arena* arena, MD_Rng1S64List* list) { return md_rng1s64_array_from_list_push__ainfo(md_arena_allocator(arena), list); } inline void -rng1s64_list_alloc(AllocatorInfo ainfo, Rng1S64List* list, Rng1S64 rng) { - Rng1S64Node* n = alloc_array(ainfo, Rng1S64Node, 1); - memory_copy_struct(&n->v, &rng); - sll_queue_push(list->first, list->last, n); +md_rng1s64_list_alloc(MD_AllocatorInfo ainfo, MD_Rng1S64List* list, Rng1S64 rng) { + MD_Rng1S64Node* n = md_alloc_array(ainfo, MD_Rng1S64Node, 1); + md_memory_copy_struct(&n->v, &rng); + md_sll_queue_push(list->first, list->last, n); list->count += 1; } -inline Rng1S64Array -rng1s64_array_from_list_alloc(AllocatorInfo ainfo, Rng1S64List* list) { - Rng1S64Array +inline MD_Rng1S64Array +md_rng1s64_array_from_list_alloc(MD_AllocatorInfo ainfo, MD_Rng1S64List* list) { + MD_Rng1S64Array arr = {0}; arr.count = list->count; - arr.v = alloc_array_no_zero(ainfo, Rng1S64, arr.count); - U64 idx = 0; - for (Rng1S64Node* n = list->first; n != 0; n = n->next) { + arr.v = md_alloc_array_no_zero(ainfo, Rng1S64, arr.count); + MD_U64 idx = 0; + for (MD_Rng1S64Node* n = list->first; n != 0; n = n->next) { arr.v[idx] = n->v; idx += 1; } diff --git a/source/base/memory.h b/source/base/memory.h index 9b6005d..8597f74 100644 --- a/source/base/memory.h +++ b/source/base/memory.h @@ -11,51 +11,51 @@ //~ rjf: Units #ifndef KILOBTYES -#define KILOBYTES( x ) ( ( x ) * ( S64 )( 1024 ) ) +#define MD_KILOBYTES( x ) ( ( x ) * ( MD_S64 )( 1024 ) ) #endif -#ifndef MEGABYTES -#define MEGABYTES( x ) ( MD_KILOBYTES( x ) * ( S64 )( 1024 ) ) +#ifndef MD_MEGABYTES +#define MD_MEGABYTES( x ) ( MD_KILOBYTES( x ) * ( MD_S64 )( 1024 ) ) #endif -#ifndef GIGABYTES -#define GIGABYTES( x ) ( MD_MEGABYTES( x ) * ( S64 )( 1024 ) ) +#ifndef MD_GIGABYTES +#define MD_GIGABYTES( x ) ( MD_MEGABYTES( x ) * ( MD_S64 )( 1024 ) ) #endif -#ifndef TERABYTES -#define TERABYTES( x ) ( MD_GIGABYTES( x ) * ( S64 )( 1024 ) ) +#ifndef MD_TERABYTES +#define MD_TERABYTES( x ) ( MD_GIGABYTES( x ) * ( MD_S64 )( 1024 ) ) #endif -#ifndef KB -#define KB(n) (((U64)(n)) << 10) +#ifndef MD_KB +#define MD_KB(n) (((MD_U64)(n)) << 10) #endif -#ifndef MB -#define MB(n) (((U64)(n)) << 20) +#ifndef MD_MB +#define MD_MB(n) (((MD_U64)(n)) << 20) #endif -#ifndef GB -#define GB(n) (((U64)(n)) << 30) +#ifndef MD_GB +#define MD_GB(n) (((MD_U64)(n)) << 30) #endif -#ifndef TB -#define TB(n) (((U64)(n)) << 40) +#ifndef MD_TB +#define MD_TB(n) (((MD_U64)(n)) << 40) #endif -#ifndef thosuand +#ifndef md_thousand #define thousand(n) ((n) * 1000) #endif -#ifndef million -#define million(n) ((n) * 1000000) +#ifndef md_million +#define md_million(n) ((n) * 1000000) #endif -#ifndef billion -#define billion(n) ((n) * 1000000000) +#ifndef md_billion +#define md_billion(n) ((n) * 1000000000) #endif //////////////////////////////// //~ rjf: Type -> Alignment -#ifndef align_of -# if COMPILER_MSVC -# define align_of(T) __alignof(T) -# elif COMPILER_CLANG -# define align_of(T) __alignof(T) -# elif COMPILER_GCC -# define align_of(T) __alignof__(T) +#ifndef md_align_of +# if MD_COMPILER_MSVC +# define md_align_of(T) __alignof(T) +# elif MD_COMPILER_CLANG +# define md_align_of(T) __alignof(T) +# elif MD_COMPILER_GCC +# define md_align_of(T) __alignof__(T) # else # error AlignOf not defined for this compiler. # endif @@ -64,17 +64,17 @@ //////////////////////////////// //~ rjf: Member Offsets -#ifndef member -#define member(T, m) ( ((T*) 0)->m ) +#ifndef md_member +#define md_member(T, m) ( ((T*) 0)->m ) #endif -#ifndef offset_of -#define offset_of(T, m) int_from_ptr(& member(T, m)) +#ifndef md_offset_of +#define md_offset_of(T, m) md_int_from_ptr(& md_member(T, m)) #endif -#ifndef member_from_offset -#define member_from_offset(T, ptr, off) (T) ((((U8 *) ptr) + (off))) +#ifndef md_member_from_offset +#define md_member_from_offset(T, ptr, off) (T) ((((MD_U8 *) ptr) + (off))) #endif -#ifndef cast_from_member -#define cast_from_member(T, m, ptr) (T*) (((U8*)ptr) - offset_of(T, m)) +#ifndef md_cast_from_member +#define md_cast_from_member(T, m, ptr) (T*) (((MD_U8*)ptr) - md_offset_of(T, m)) #endif //////////////////////////////// @@ -82,8 +82,8 @@ // TODO(Ed): Review usage of memmove here...(I guess wanting to avoid overlap faults..) -#ifndef memory_copy -# if OS_WINDOWS +#ifndef md_memory_copy +# if MD_OS_WINDOWS void* memcpy_intrinsic(void* dest, const void* src, size_t count) { if (dest == NULL || src == NULL || count == 0) { @@ -93,82 +93,82 @@ __movsb((unsigned char*)dest, (const unsigned char*)src, count); return dest; } -# define memory_copy(dst, src, size) memcpy_intrinsic((dst), (src), (size)) +# define md_memory_copy(dst, src, size) memcpy_intrinsic((dst), (src), (size)) # else -# define memory_copy(dst, src, size) memmove((dst), (src), (size)) +# define md_memory_copy(dst, src, size) memmove((dst), (src), (size)) # endif #endif -#ifndef memory_set +#ifndef md_memory_set # if USE_VENDOR_MEMORY_OPS -# define memory_set(dst, byte, size) memset((dst), (byte), (size)) +# define md_memory_set(dst, byte, size) memset((dst), (byte), (size)) # else -# define memory_set(dst, byte, size) mem_set((dst), (byte), (size)) +# define md_memory_set(dst, byte, size) md_mem_set((dst), (byte), (size)) # endif #endif -#ifndef memory_compare -#define memory_compare(a, b, size) memcmp((a), (b), (size)) +#ifndef md_memory_compare +#define md_memory_compare(a, b, size) memcmp((a), (b), (size)) #endif -#ifndef memory_str_len -#define memory_str_len(ptr) cstr_len(ptr) +#ifndef md_memory_str_len +#define md_memory_str_len(ptr) cstr_len(ptr) #endif -#ifndef memory_copy_struct -#define memory_copy_struct(d, s) memory_copy((d), (s), sizeof( *(d))) +#ifndef md_memory_copy_struct +#define md_memory_copy_struct(d, s) md_memory_copy((d), (s), sizeof( *(d))) #endif -#ifndef memory_copy_array -#define memory_copy_array(d, s) memory_copy((d), (s), sizeof( d)) +#ifndef md_memory_copy_array +#define md_memory_copy_array(d, s) md_memory_copy((d), (s), sizeof( d)) #endif -#ifndef memory_copy_type -#define memory_copy_type(d, s, c) memory_copy((d), (s), sizeof( *(d)) * (c)) +#ifndef md_memory_copy_type +#define md_memory_copy_type(d, s, c) md_memory_copy((d), (s), sizeof( *(d)) * (c)) #endif -#ifndef memory_zero -#define memory_zero(s,z) memory_set((s), 0, (z)) +#ifndef md_memory_zero +#define md_memory_zero(s,z) md_memory_set((s), 0, (z)) #endif -#ifndef memory_zero_struct -#define memory_zero_struct(s) memory_zero((s), sizeof( *(s))) +#ifndef md_memory_zero_struct +#define md_memory_zero_struct(s) md_memory_zero((s), sizeof( *(s))) #endif -#ifndef memory_zero_array -#define memory_zero_array(a) memory_zero((a), sizeof(a)) +#ifndef md_memory_zero_array +#define md_memory_zero_array(a) md_memory_zero((a), sizeof(a)) #endif -#ifndef memory_zero_type -#define memory_zero_type(m, c) memory_zero((m), sizeof( *(m)) * (c)) +#ifndef md_memory_zero_type +#define md_memory_zero_type(m, c) md_memory_zero((m), sizeof( *(m)) * (c)) #endif -#ifndef memory_match -#define memory_match(a, b, z) (memory_compare((a), (b), (z)) == 0) +#ifndef md_memory_match +#define md_memory_match(a, b, z) (md_memory_compare((a), (b), (z)) == 0) #endif -#ifndef memory_match_struct -#define memory_match_struct(a, b) memory_match((a), (b), sizeof(*(a))) +#ifndef md_memory_match_struct +#define md_memory_match_struct(a, b) md_memory_match((a), (b), sizeof(*(a))) #endif -#ifndef memory_match_array -#define memory_match_array(a, b) memory_match((a), (b), sizeof(a)) +#ifndef md_memory_match_array +#define md_memory_match_array(a, b) md_memory_match((a), (b), sizeof(a)) #endif -#ifndef memory_read -#define memory_read(T, p, e) ( ((p) + sizeof(T) <= (e)) ? ( *(T*)(p)) : (0) ) +#ifndef md_memory_read +#define md_memory_read(T, p, e) ( ((p) + sizeof(T) <= (e)) ? ( *(T*)(p)) : (0) ) #endif -#ifndef memory_consume -#define memory_consume(T, p, e) ( ((p) + sizeof(T) <= (e)) ? ((p) += sizeof(T), *(T*)((p) - sizeof(T))) : ((p) = (e),0) ) +#ifndef md_memory_consume +#define md_memory_consume(T, p, e) ( ((p) + sizeof(T) <= (e)) ? ((p) += sizeof(T), *(T*)((p) - sizeof(T))) : ((p) = (e),0) ) #endif //////////////////////////////// //~ rjf: Memory Functions -inline B32 -memory_is_zero(void* ptr, U64 size) +inline MD_B32 +md_memory_is_zero(void* ptr, MD_U64 size) { - B32 result = 1; + MD_B32 result = 1; // break down size - U64 extra = (size & 0x7); - U64 count8 = (size >> 3); + MD_U64 extra = (size & 0x7); + MD_U64 count8 = (size >> 3); // check with 8-byte stride - U64* p64 = (U64*)ptr; + MD_U64* p64 = (MD_U64*)ptr; if (result) { - for (U64 i = 0; i < count8; i += 1, p64 += 1) { + for (MD_U64 i = 0; i < count8; i += 1, p64 += 1) { if (*p64 != 0){ result = 0; goto done; @@ -179,8 +179,8 @@ memory_is_zero(void* ptr, U64 size) // check extra if (result) { - U8* p8 = (U8*)p64; - for (U64 i = 0; i < extra; i += 1, p8 += 1) { + MD_U8* p8 = (MD_U8*)p64; + for (MD_U64 i = 0; i < extra; i += 1, p8 += 1) { if (*p8 != 0) { result = 0; goto done; @@ -193,41 +193,41 @@ done:; } inline -void* mem_move( void* destination, void const* source, SSIZE byte_count ) +void* md_mem_move( void* destination, void const* source, MD_SSIZE byte_count ) { if ( destination == NULL ) { return NULL; } - U8* dest_ptr = rcast( U8*, destination); - U8 const* src_ptr = rcast( U8 const*, source); + MD_U8* dest_ptr = md_rcast( MD_U8*, destination); + MD_U8 const* src_ptr = md_rcast( MD_U8 const*, source); if ( dest_ptr == src_ptr ) return dest_ptr; // NOTE: Non-overlapping if ( src_ptr + byte_count <= dest_ptr || dest_ptr + byte_count <= src_ptr ) { - return memory_copy( dest_ptr, src_ptr, byte_count ); + return md_memory_copy( dest_ptr, src_ptr, byte_count ); } if ( dest_ptr < src_ptr ) { - if ( scast(UPTR, src_ptr) % size_of( SSIZE ) == scast(UPTR, dest_ptr) % size_of( SSIZE ) ) + if ( md_scast(MD_UPTR, src_ptr) % size_of( MD_SSIZE ) == md_scast(MD_UPTR, dest_ptr) % size_of( MD_SSIZE ) ) { - while ( pcast( UPTR, dest_ptr) % size_of( SSIZE ) ) + while ( md_pcast( MD_UPTR, dest_ptr) % size_of( MD_SSIZE ) ) { if ( ! byte_count-- ) return destination; *dest_ptr++ = *src_ptr++; } - while ( byte_count >= size_of( SSIZE ) ) + while ( byte_count >= size_of( MD_SSIZE ) ) { - * rcast(SSIZE*, dest_ptr) = * rcast(SSIZE const*, src_ptr); - byte_count -= size_of( SSIZE ); - dest_ptr += size_of( SSIZE ); - src_ptr += size_of( SSIZE ); + * md_rcast(MD_SSIZE*, dest_ptr) = * md_rcast(MD_SSIZE const*, src_ptr); + byte_count -= size_of( MD_SSIZE ); + dest_ptr += size_of( MD_SSIZE ); + src_ptr += size_of( MD_SSIZE ); } } for ( ; byte_count; byte_count-- ) @@ -235,19 +235,19 @@ void* mem_move( void* destination, void const* source, SSIZE byte_count ) } else { - if ( ( scast(UPTR, src_ptr) % size_of( SSIZE ) ) == ( scast(UPTR, dest_ptr) % size_of( SSIZE ) ) ) + if ( ( md_scast(MD_UPTR, src_ptr) % size_of( MD_SSIZE ) ) == ( md_scast(MD_UPTR, dest_ptr) % size_of( MD_SSIZE ) ) ) { - while ( scast(UPTR, dest_ptr + byte_count ) % size_of( SSIZE ) ) + while ( md_scast(MD_UPTR, dest_ptr + byte_count ) % size_of( MD_SSIZE ) ) { if ( ! byte_count-- ) return destination; dest_ptr[ byte_count ] = src_ptr[ byte_count ]; } - while ( byte_count >= size_of( SSIZE ) ) + while ( byte_count >= size_of( MD_SSIZE ) ) { - byte_count -= size_of( SSIZE ); - * rcast(SSIZE*, dest_ptr + byte_count ) = * rcast( SSIZE const*, src_ptr + byte_count ); + byte_count -= size_of( MD_SSIZE ); + * md_rcast(MD_SSIZE*, dest_ptr + byte_count ) = * md_rcast( MD_SSIZE const*, src_ptr + byte_count ); } } while ( byte_count ) @@ -258,16 +258,16 @@ void* mem_move( void* destination, void const* source, SSIZE byte_count ) } inline -void* mem_set( void* destination, U8 fill_byte, SSIZE byte_count ) +void* md_mem_set( void* destination, MD_U8 fill_byte, MD_SSIZE byte_count ) { if ( destination == NULL ) { return NULL; } - SSIZE align_offset; - U8* dest_ptr = rcast( U8*, destination); - U32 fill_word = ( ( U32 )-1 ) / 255 * fill_byte; + MD_SSIZE align_offset; + MD_U8* dest_ptr = md_rcast( MD_U8*, destination); + MD_U32 fill_word = ( ( MD_U32 )-1 ) / 255 * fill_byte; if ( byte_count == 0 ) return destination; @@ -285,44 +285,44 @@ void* mem_set( void* destination, U8 fill_byte, SSIZE byte_count ) if ( byte_count < 9 ) return destination; - align_offset = -scast(SPTR, dest_ptr ) & 3; + align_offset = -md_scast(MD_SPTR, dest_ptr ) & 3; dest_ptr += align_offset; byte_count -= align_offset; byte_count &= -4; - * rcast( U32*, ( dest_ptr + 0 ) ) = fill_word; - * rcast( U32*, ( dest_ptr + byte_count - 4 ) ) = fill_word; + * md_rcast( MD_U32*, ( dest_ptr + 0 ) ) = fill_word; + * md_rcast( MD_U32*, ( dest_ptr + byte_count - 4 ) ) = fill_word; if ( byte_count < 9 ) return destination; - * rcast( U32*, dest_ptr + 4 ) = fill_word; - * rcast( U32*, dest_ptr + 8 ) = fill_word; - * rcast( U32*, dest_ptr + byte_count - 12 ) = fill_word; - * rcast( U32*, dest_ptr + byte_count - 8 ) = fill_word; + * md_rcast( MD_U32*, dest_ptr + 4 ) = fill_word; + * md_rcast( MD_U32*, dest_ptr + 8 ) = fill_word; + * md_rcast( MD_U32*, dest_ptr + byte_count - 12 ) = fill_word; + * md_rcast( MD_U32*, dest_ptr + byte_count - 8 ) = fill_word; if ( byte_count < 25 ) return destination; - * rcast( U32*, dest_ptr + 12 ) = fill_word; - * rcast( U32*, dest_ptr + 16 ) = fill_word; - * rcast( U32*, dest_ptr + 20 ) = fill_word; - * rcast( U32*, dest_ptr + 24 ) = fill_word; - * rcast( U32*, dest_ptr + byte_count - 28 ) = fill_word; - * rcast( U32*, dest_ptr + byte_count - 24 ) = fill_word; - * rcast( U32*, dest_ptr + byte_count - 20 ) = fill_word; - * rcast( U32*, dest_ptr + byte_count - 16 ) = fill_word; + * md_rcast( MD_U32*, dest_ptr + 12 ) = fill_word; + * md_rcast( MD_U32*, dest_ptr + 16 ) = fill_word; + * md_rcast( MD_U32*, dest_ptr + 20 ) = fill_word; + * md_rcast( MD_U32*, dest_ptr + 24 ) = fill_word; + * md_rcast( MD_U32*, dest_ptr + byte_count - 28 ) = fill_word; + * md_rcast( MD_U32*, dest_ptr + byte_count - 24 ) = fill_word; + * md_rcast( MD_U32*, dest_ptr + byte_count - 20 ) = fill_word; + * md_rcast( MD_U32*, dest_ptr + byte_count - 16 ) = fill_word; - align_offset = 24 + scast(UPTR, dest_ptr ) & 4; + align_offset = 24 + md_scast(MD_UPTR, dest_ptr ) & 4; dest_ptr += align_offset; byte_count -= align_offset; { - U64 fill_doubleword = ( scast( U64, fill_word) << 32 ) | fill_word; + MD_U64 fill_doubleword = ( md_scast( MD_U64, fill_word) << 32 ) | fill_word; while ( byte_count > 31 ) { - * rcast( U64*, dest_ptr + 0 ) = fill_doubleword; - * rcast( U64*, dest_ptr + 8 ) = fill_doubleword; - * rcast( U64*, dest_ptr + 16 ) = fill_doubleword; - * rcast( U64*, dest_ptr + 24 ) = fill_doubleword; + * md_rcast( MD_U64*, dest_ptr + 0 ) = fill_doubleword; + * md_rcast( MD_U64*, dest_ptr + 8 ) = fill_doubleword; + * md_rcast( MD_U64*, dest_ptr + 16 ) = fill_doubleword; + * md_rcast( MD_U64*, dest_ptr + 24 ) = fill_doubleword; byte_count -= 32; dest_ptr += 32; @@ -335,25 +335,25 @@ void* mem_set( void* destination, U8 fill_byte, SSIZE byte_count ) //////////////////////////////// //~ rjf: Atomic Operations -#ifndef ins_atomic_u64_eval -# if OS_WINDOWS -# if ARCH_X64 -# define ins_atomic_u64_eval(x) InterlockedAdd64((volatile __int64 *)(x), 0) -# define ins_atomic_u64_inc_eval(x) InterlockedIncrement64((volatile __int64 *)(x)) -# define ins_atomic_u64_dec_eval(x) InterlockedDecrement64((volatile __int64 *)(x)) -# define ins_atomic_u64_eval_assign(x,c) InterlockedExchange64((volatile __int64 *)(x), (c)) -# define ins_atomic_u64_add_eval(x,c) InterlockedAdd64((volatile __int64 *)(x), c) -# define ins_atomic_u64_eval_cond_assign(x,k,c) InterlockedCompareExchange64((volatile __int64 *)(x), (k), (c)) -# define ins_atomic_u32_eval(x,c) InterlockedAdd((volatile LONG *)(x), 0) -# define ins_atomic_u32_eval_assign(x,c) InterlockedExchange((volatile LONG *)(x), (c)) -# define ins_atomic_u32_eval_cond_assign(x,k,c) InterlockedCompareExchange((volatile LONG *)(x), (k), (c)) -# define ins_atomic_ptr_eval_assign(x,c) (void*) ins_atomic_u64_eval_assign((volatile __int64 *)(x), (__int64)(c)) +#ifndef md_ins_atomic_u64_eval +# if MD_OS_WINDOWS +# if MD_ARCH_X64 +# define md_ins_atomic_u64_eval(x) InterlockedAdd64((volatile __int64 *)(x), 0) +# define md_ins_atomic_u64_inc_eval(x) InterlockedIncrement64((volatile __int64 *)(x)) +# define md_ins_atomic_u64_dec_eval(x) InterlockedDecrement64((volatile __int64 *)(x)) +# define md_ins_atomic_u64_eval_assign(x,c) InterlockedExchange64((volatile __int64 *)(x), (c)) +# define md_ins_atomic_u64_add_eval(x,c) InterlockedAdd64((volatile __int64 *)(x), c) +# define md_ins_atomic_u64_eval_cond_assign(x,k,c) InterlockedCompareExchange64((volatile __int64 *)(x), (k), (c)) +# define md_ins_atomic_u32_eval(x,c) InterlockedAdd((volatile LONG *)(x), 0) +# define md_ins_atomic_u32_eval_assign(x,c) InterlockedExchange((volatile LONG *)(x), (c)) +# define md_ins_atomic_u32_eval_cond_assign(x,k,c) InterlockedCompareExchange((volatile LONG *)(x), (k), (c)) +# define md_ins_atomic_ptr_eval_assign(x,c) (void*) md_ins_atomic_u64_eval_assign((volatile __int64 *)(x), (__int64)(c)) # else # error Atomic intrinsics not defined for this operating system / architecture combination. # endif -# elif OS_LINUX -# if ARCH_X64 -# define ins_atomic_u64_inc_eval(x) __sync_fetch_and_add((volatile U64 *)(x), 1) +# elif MD_OS_LINUX +# if MD_ARCH_X64 +# define md_ins_atomic_u64_inc_eval(x) __sync_fetch_and_add((volatile MD_U64 *)(x), 1) # else # error Atomic intrinsics not defined for this operating system / architecture combination. # endif @@ -367,11 +367,11 @@ void* mem_set( void* destination, U8 fill_byte, SSIZE byte_count ) //- rjf: linked list macro helpers -#ifndef check_nil -#define check_nil(nil, p) ((p) == 0 || (p) == nil) +#ifndef md_check_nil +#define md_check_nil(nil, p) ((p) == 0 || (p) == nil) #endif -#ifndef set_nil -#define set_nil(nil, p) ((p) = nil) +#ifndef md_set_nil +#define md_set_nil(nil, p) ((p) = nil) #endif //- rjf: doubly-linked-lists @@ -380,10 +380,10 @@ void* mem_set( void* destination, U8 fill_byte, SSIZE byte_count ) #define MD_LINKED_LIST_PURE_MACRO 0 #endif -#ifndef dll_insert_npz +#ifndef md_dll_insert_npz // TODO(Ed): Review... inline void -dll__insert_npz( +md_dll__insert_npz( void* nil, void** f, void** f_prev, void** l, void** l_next, @@ -391,7 +391,7 @@ dll__insert_npz( void* n, void** n_prev, void** n_next ) { - if (check_nil(nil, *f)) { + if (md_check_nil(nil, *f)) { *f = n; *l = n; *n_prev = nil; @@ -399,7 +399,7 @@ dll__insert_npz( } else { - if (check_nil(nil, p)) { + if (md_check_nil(nil, p)) { *n_next = *f; *f_prev = n; *f = n; @@ -415,7 +415,7 @@ dll__insert_npz( } else { - if ( ! check_nil(nil, p) && check_nil(nil, *p_next)) { + if ( ! md_check_nil(nil, p) && md_check_nil(nil, *p_next)) { *p_next_prev = n; } *n_next = *p_next; @@ -428,32 +428,32 @@ dll__insert_npz( #if ! MD_LINKED_LIST_PURE_MACRO // insert next-previous with nil -#define dll_insert_npz(nil, f, l, p, n, next, prev) dll__insert_npz(nil, &f, &f->prev, &l, &l->next, p, &p->next, &p->next->prev, n, &n->prev, &n->next) +#define md_dll_insert_npz(nil, f, l, p, n, next, prev) md_dll__insert_npz(nil, &f, &f->prev, &l, &l->next, p, &p->next, &p->next->prev, n, &n->prev, &n->next) #else // insert next-previous with nil -#define dll_insert_npz(nil, f, l, p, n, next, prev) \ +#define md_dll_insert_npz(nil, f, l, p, n, next, prev) \ ( \ - check_nil(nil, f) ? ( \ + md_check_nil(nil, f) ? ( \ (f) = (l) = (n), \ - set_nil(nil, (n)->next), \ - set_nil(nil, (n)->prev) \ + md_set_nil(nil, (n)->next), \ + md_set_nil(nil, (n)->prev) \ ) \ : ( \ - check_nil(nil, p) ? ( \ + md_check_nil(nil, p) ? ( \ (n)->next = (f), \ (f)->prev = (n), \ (f) = (n), \ - set_nil(nil,(n)->prev) \ + md_set_nil(nil,(n)->prev) \ ) \ : ((p) == (l)) ? ( \ (l)->next = (n), \ (n)->prev = (l), \ (l) = (n), \ - set_nil(nil, (n)->next) \ + md_set_nil(nil, (n)->next) \ ) \ : ( \ ( \ - ( ! check_nil(nil, p) && check_nil(nil, (p)->next) ) ? \ + ( ! md_check_nil(nil, p) && md_check_nil(nil, (p)->next) ) ? \ (0) \ : ( (p)->next->prev = (n) ) \ ), \ @@ -465,22 +465,22 @@ dll__insert_npz( ) // ! MD_LINKED_LIST_PURE_MACRO #endif -// dll_insert_npz +// md_dll_insert_npz #endif -#ifndef dll_push_back_npz +#ifndef md_dll_push_back_npz // push-back next-previous with nil -#define dll_push_back_npz(nil, f, l, n, next, prev) dll_insert_npz(nil, f, l, l, n, next, prev) +#define md_dll_push_back_npz(nil, f, l, n, next, prev) md_dll_insert_npz(nil, f, l, l, n, next, prev) #endif -#ifndef dll_push_front_npz +#ifndef md_dll_push_front_npz // push-fornt next-previous with nil -#define dll_push_front_npz(nil, f, l, n, next, prev) dll_insert_npz(nil, l, f, f, n, prev, next) +#define md_dll_push_front_npz(nil, f, l, n, next, prev) md_dll_insert_npz(nil, l, f, f, n, prev, next) #endif -#ifndef dll_remove_npz +#ifndef md_dll_remove_npz inline void -dll__remove_npz( +md_dll__remove_npz( void* nil, void** f, void** l, void* l_prev, @@ -494,20 +494,20 @@ dll__remove_npz( if (n == *l) { *l = l_prev; } - if (check_nil(nil, n_prev)) { + if (md_check_nil(nil, n_prev)) { *n_prev_next = n_next; } - if (! check_nil(nil, n_next)) { + if (! md_check_nil(nil, n_next)) { *n_next_prev = n_prev; } } #if ! MD_LINKED_LIST_PURE_MACRO // remove next-previous with nil -#define dll_remove_npz(nil, f, l, n, next, prev) dll__remove_npz(nil, &f, &l, l->prev, n, n->next, &n->next->prev, n->prev, &n->prev->next) +#define md_dll_remove_npz(nil, f, l, n, next, prev) md_dll__remove_npz(nil, &f, &l, l->prev, n, n->next, &n->next->prev, n->prev, &n->prev->next) #else // remove next-previous with nil -#define dll_remove_npz(nil, f, l, n, next, prev) \ +#define md_dll_remove_npz(nil, f, l, n, next, prev) \ ( \ ( \ (n) == (f) ? \ @@ -520,33 +520,33 @@ dll__remove_npz( : (0) \ ), \ ( \ - check_nil(nil,(n)->prev) ? \ + md_check_nil(nil,(n)->prev) ? \ (0) \ : ((n)->prev->next = (n)->next) \ ), \ ( \ - check_nil(nil,(n)->next) ? \ + md_check_nil(nil,(n)->next) ? \ (0) \ : ((n)->next->prev = (n)->prev) \ ) \ ) // ! MD_LINKED_LIST_PURE_MACRO #endif -// dll_remove_npz +// md_dll_remove_npz #endif //- rjf: singly-linked, doubly-headed lists (queues) -#ifndef sll_queue_push_nz +#ifndef md_sll_queue_push_nz inline void -sll__queue_push_nz( +md_sll__queue_push_nz( void* nil, void** f, void** l, void** l_next, void* n, void** n_next ) { - if (check_nil(nil, *f)) { + if (md_check_nil(nil, *f)) { *f = n; *l = n; *n_next = nil; @@ -560,29 +560,29 @@ sll__queue_push_nz( // queue-push next with nil #if ! MD_LINKED_LIST_PURE_MACRO -#define sll_queue_push_nz(nil, f, l, n, next) sll__queue_push_nz(nil, &f, &l, &l->next, n, &n->next) +#define md_sll_queue_push_nz(nil, f, l, n, next) md_sll__queue_push_nz(nil, &f, &l, &l->next, n, &n->next) #else -#define sll_queue_push_nz(nil, f, l, n, next) \ +#define md_sll_queue_push_nz(nil, f, l, n, next) \ ( \ - check_nil(nil, f) ? ( \ + md_check_nil(nil, f) ? ( \ (f) = (l) = (n), \ - set_nil(nil, (n)->next) \ + md_set_nil(nil, (n)->next) \ ) \ : ( \ (l)->next=(n), \ (l) = (n), \ - set_nil(nil,(n)->next) \ + md_set_nil(nil,(n)->next) \ ) \ ) // ! MD_LINKED_LIST_PURE_MACRO #endif -// sll_queue_push_nz +// md_sll_queue_push_nz #endif -#ifndef sll_queue_push_front_nz +#ifndef md_sll_queue_push_front_nz inline void -sll__queue_push_front_nz(void* nil, void** f, void** l, void* n, void** n_next) { - if (check_nil(nil, *f)) { +md_sll__queue_push_front_nz(void* nil, void** f, void** l, void* n, void** n_next) { + if (md_check_nil(nil, *f)) { *f = n; *l = n; *n_next = nil; @@ -595,13 +595,13 @@ sll__queue_push_front_nz(void* nil, void** f, void** l, void* n, void** n_next) // queue-push-front next with nil #if ! MD_LINKED_LIST_PURE_MACRO -#define sll_queue_push_front_nz(nil, f, l, n, next) sll__queue_push_front_nz(nil, &f, &l, n, &n->next) +#define md_sll_queue_push_front_nz(nil, f, l, n, next) md_sll__queue_push_front_nz(nil, &f, &l, n, &n->next) #else -#define sll_queue_push_front_nz(nil, f, l, n, next) \ +#define md_sll_queue_push_front_nz(nil, f, l, n, next) \ ( \ - check_nil(nil, f) ? ( \ + md_check_nil(nil, f) ? ( \ (f) = (l) = (n), \ - set_nil(nil,(n)->next) \ + md_set_nil(nil,(n)->next) \ ) \ : ( \ (n)->next = (f), \ @@ -612,9 +612,9 @@ sll__queue_push_front_nz(void* nil, void** f, void** l, void* n, void** n_next) #endif #endif -#ifndef sll_queue_pop_nz +#ifndef md_sll_queue_pop_nz inline void -sll__queue_pop_nz(void* nil, void** f, void* f_next, void** l) +md_sll__queue_pop_nz(void* nil, void** f, void* f_next, void** l) { if (*f == *l) { *f = nil; @@ -627,13 +627,13 @@ sll__queue_pop_nz(void* nil, void** f, void* f_next, void** l) // queue-pop next with nil #if ! MD_LINKED_LIST_PURE_MACRO -#define sll_queue_pop_nz(nil, f, l, next) sll__queue_pop_nz(nil, &f, f->next, &l) +#define md_sll_queue_pop_nz(nil, f, l, next) md_sll__queue_pop_nz(nil, &f, f->next, &l) #else -#define sll_queue_pop_nz(nil, f, l, next) \ +#define md_sll_queue_pop_nz(nil, f, l, next) \ ( \ (f) == (l) ? ( \ - set_nil(nil,f), \ - set_nil(nil,l) \ + md_set_nil(nil,f), \ + md_set_nil(nil,l) \ ) \ : ( \ (f)=(f)->next \ @@ -641,214 +641,214 @@ sll__queue_pop_nz(void* nil, void** f, void* f_next, void** l) ) // ! MD_LINKED_LIST_PURE_MACRO #endif -// sll_queue_pop_nz +// md_sll_queue_pop_nz #endif //- rjf: singly-linked, singly-headed lists (stacks) -#ifndef sll_stack_push_n -#define sll_stack_push_n(f,n,next) ( (n)->next = (f), (f) = (n) ) +#ifndef md_sll_stack_push_n +#define md_sll_stack_push_n(f,n,next) ( (n)->next = (f), (f) = (n) ) #endif -#ifndef sll_stack_pop_n -#define sll_stack_pop_n(f,next) ( (f) = (f)->next ) +#ifndef md_sll_stack_pop_n +#define md_sll_stack_pop_n(f,next) ( (f) = (f)->next ) #endif //- rjf: doubly-linked-list helpers -#ifndef dll_insert_np -#define dll_insert_np(f, l, p, n, next, prev) dll_insert_npz (0, f, l, p, n, next, prev) +#ifndef md_dll_insert_np +#define md_dll_insert_np(f, l, p, n, next, prev) md_dll_insert_npz (0, f, l, p, n, next, prev) #endif -#ifndef dll_push_back_np -#define dll_push_back_np(f, l, n, next, prev) dll_push_back_npz (0, f, l, n, next, prev) +#ifndef md_dll_push_back_np +#define md_dll_push_back_np(f, l, n, next, prev) md_dll_push_back_npz (0, f, l, n, next, prev) #endif -#ifndef dll_push_front_np -#define dll_push_front_np(f, l, n, next, prev) dll_push_front_npz(0, f, l, n, next, prev) +#ifndef md_dll_push_front_np +#define md_dll_push_front_np(f, l, n, next, prev) md_dll_push_front_npz(0, f, l, n, next, prev) #endif -#ifndef dll_remove_np -#define dll_remove_np(f, l, n, next, prev) dll_remove_npz (0, f, l, n, next, prev) +#ifndef md_dll_remove_np +#define md_dll_remove_np(f, l, n, next, prev) md_dll_remove_npz (0, f, l, n, next, prev) #endif -#ifndef dll_insert -#define dll_insert(f, l, p, n) dll_insert_npz (0, f, l, p, n, next, prev) +#ifndef md_dll_insert +#define md_dll_insert(f, l, p, n) md_dll_insert_npz (0, f, l, p, n, next, prev) #endif -#ifndef dll_push_back -#define dll_push_back(f, l, n) dll_push_back_npz (0, f, l, n, next, prev) +#ifndef md_dll_push_back +#define md_dll_push_back(f, l, n) md_dll_push_back_npz (0, f, l, n, next, prev) #endif -#ifndef dll_push_front -#define dll_push_front(f, l, n) dll_push_front_npz(0, f, l, n, next, prev) +#ifndef md_dll_push_front +#define md_dll_push_front(f, l, n) md_dll_push_front_npz(0, f, l, n, next, prev) #endif -#ifndef dll_remove -#define dll_remove(f, l, n) dll_remove_npz (0, f, l, n, next, prev) +#ifndef md_dll_remove +#define md_dll_remove(f, l, n) md_dll_remove_npz (0, f, l, n, next, prev) #endif //- rjf: singly-linked, doubly-headed list helpers -#ifndef sll_queue_push_n -#define sll_queue_push_n(f, l, n, next) sll_queue_push_nz (0, f, l, n, next) +#ifndef md_sll_queue_push_n +#define md_sll_queue_push_n(f, l, n, next) md_sll_queue_push_nz (0, f, l, n, next) #endif -#ifndef sll_queue_push_front_n -#define sll_queue_push_front_n(f, l, n, next) sll_queue_push_front_nz(0, f, l, n, next) +#ifndef md_sll_queue_push_front_n +#define md_sll_queue_push_front_n(f, l, n, next) md_sll_queue_push_front_nz(0, f, l, n, next) #endif -#ifndef sll_queue_pop_n -#define sll_queue_pop_n(f, l, next) sll_queue_pop_nzs (0, f, l, next) +#ifndef md_sll_queue_pop_n +#define md_sll_queue_pop_n(f, l, next) md_sll_queue_pop_nzs (0, f, l, next) #endif -#ifndef sll_queue_push -#define sll_queue_push(f, l, n) sll_queue_push_nz (0, f, l, n, next) +#ifndef md_sll_queue_push +#define md_sll_queue_push(f, l, n) md_sll_queue_push_nz (0, f, l, n, next) #endif -#ifndef sll_queue_push_front -#define sll_queue_push_front(f, l ,n) sll_queue_push_front_nz(0, f, l, n, next) +#ifndef md_sll_queue_push_front +#define md_sll_queue_push_front(f, l ,n) md_sll_queue_push_front_nz(0, f, l, n, next) #endif -#ifndef sll_queue_pop -#define sll_queue_pop(f, l) sll_queue_pop_nz (0, f, l, next) +#ifndef md_sll_queue_pop +#define md_sll_queue_pop(f, l) md_sll_queue_pop_nz (0, f, l, next) #endif //- rjf: singly-linked, singly-headed list helpers -#ifndef sll_stack_push -#define sll_stack_push(f, n) sll_stack_push_n(f, n, next) +#ifndef md_sll_stack_push +#define md_sll_stack_push(f, n) md_sll_stack_push_n(f, n, next) #endif -#ifndef sll_stack_pop -#define sll_stack_pop(f) sll_stack_pop_n (f, next) +#ifndef md_sll_stack_pop +#define md_sll_stack_pop(f) md_sll_stack_pop_n (f, next) #endif //////////////////////////////// //~ rjf: Address Sanitizer Markup -#ifndef NO_ASAN -# if COMPILER_MSVC +#ifndef MD_NO_ASAN +# if MD_COMPILER_MSVC # if defined(__SANITIZE_ADDRESS__) -# define ASAN_ENABLED 1 -# define NO_ASAN __declspec(no_sanitize_address) +# define MD_ASAN_ENABLED 1 +# define MD_NO_ASAN __declspec(no_sanitize_address) # else -# define NO_ASAN +# define MD_NO_ASAN # endif -# elif COMPILER_CLANG +# elif MD_COMPILER_CLANG # if defined(__has_feature) # if __has_feature(address_sanitizer) || defined(__SANITIZE_ADDRESS__) -# define ASAN_ENABLED 1 +# define MD_ASAN_ENABLED 1 # endif # endif -# define NO_ASAN __attribute__((no_sanitize("address"))) +# define MD_NO_ASAN __attribute__((no_sanitize("address"))) # else -# define NO_ASAN +# define MD_NO_ASAN # endif #endif -#ifndef asan_poison_memory_region +#ifndef md_asan_poison_memory_region # if MD_ASAN_ENABLED # pragma comment(lib, "clang_rt.asan-x86_64.lib") MD_C_API void __asan_poison_memory_region(void const volatile *addr, size_t size); MD_C_API void __asan_unpoison_memory_region(void const volatile *addr, size_t size); -# define asan_poison_memory_region(addr, size) __asan_poison_memory_region((addr), (size)) -# define asan_unpoison_memory_region(addr, size) __asan_unpoison_memory_region((addr), (size)) +# define md_asan_poison_memory_region(addr, size) __asan_poison_memory_region((addr), (size)) +# define md_asan_unpoison_memory_region(addr, size) __asan_unpoison_memory_region((addr), (size)) # else -# define asan_poison_memory_region(addr, size) ((void)(addr), (void)(size)) -# define asan_unpoison_memory_region(addr, size) ((void)(addr), (void)(size)) +# define md_asan_poison_memory_region(addr, size) ((void)(addr), (void)(size)) +# define md_asan_unpoison_memory_region(addr, size) ((void)(addr), (void)(size)) # endif #endif //////////////////////////////// //~ rjf: Misc. Helper Macros -#ifndef array_count -#define array_count(a) (sizeof(a) / sizeof((a)[0])) +#ifndef md_array_count +#define md_array_count(a) (sizeof(a) / sizeof((a)[0])) #endif -#ifndef ceil_integer_div -#define ceil_integer_div(a,b) (((a) + (b) - 1) / (b)) +#ifndef md_ceil_integer_div +#define md_ceil_integer_div(a,b) (((a) + (b) - 1) / (b)) #endif -#ifndef swap -#define swap(T, a, b) do { T t__ = a; a = b; b = t__; } while(0) +#ifndef md_swap +#define md_swap(T, a, b) do { T t__ = a; a = b; b = t__; } while(0) #endif -#ifndef int_from_ptr -# if ARCH_64BIT -# define int_from_ptr(ptr) ((U64)(ptr)) -# elif ARCH_32BIT -# define int_from_ptr(ptr) ((U32)(ptr)) +#ifndef md_int_from_ptr +# if MD_ARCH_64BIT +# define md_int_from_ptr(ptr) ((MD_U64)(ptr)) +# elif MD_ARCH_32BIT +# define md_int_from_ptr(ptr) ((MD_U32)(ptr)) # else # error Missing pointer-to-integer cast for this architecture. # endif #endif -#ifndef ptr_from_int -#define ptr_from_int(i) (void*)((U8*)0 + (i)) +#ifndef md_ptr_from_int +#define md_ptr_from_int(i) (void*)((MD_U8*)0 + (i)) #endif -#ifndef compose_64bit -#define compose_64bit(a,b) ((((U64)a) << 32) | ((U64)b)); +#ifndef md_compose_64bit +#define md_compose_64bit(a,b) ((((MD_U64)a) << 32) | ((MD_U64)b)); #endif -#ifndef align_pow2 -#define align_pow2(x,b) (((x) + (b) - 1) & ( ~((b) - 1))) +#ifndef md_align_pow2 +#define md_align_pow2(x,b) (((x) + (b) - 1) & ( ~((b) - 1))) #endif -#ifndef align_down_pow2 -#define align_down_pow2(x,b) ((x) & (~((b) - 1))) +#ifndef md_align_down_pow2 +#define md_align_down_pow2(x,b) ((x) & (~((b) - 1))) #endif -#ifndef align_pad_pow2 -#define align_pad_pow2(x,b) ((0-(x)) & ((b) - 1)) +#ifndef md_align_pad_pow2 +#define md_align_pad_pow2(x,b) ((0-(x)) & ((b) - 1)) #endif -#ifndef is_pow2 -#define is_pow2(x) ((x) != 0 && ((x ) & ((x) - 1)) == 0) +#ifndef md_is_pow2 +#define md_is_pow2(x) ((x) != 0 && ((x ) & ((x) - 1)) == 0) #endif -#ifndef is_pow2_or_zero -#define is_pow2_or_zero(x) ((((x) - 1) & (x)) == 0) +#ifndef md_is_pow2_or_zero +#define md_is_pow2_or_zero(x) ((((x) - 1) & (x)) == 0) #endif -#ifndef extract_bit -#define extract_bit(word, idx) (((word) >> (idx)) & 1) +#ifndef md_extract_bit +#define md_extract_bit(word, idx) (((word) >> (idx)) & 1) #endif -#ifndef zero_struct -# if LANG_CPP -# define zero_struct {} +#ifndef md_zero_struct +# if MD_LANG_CPP +# define md_zero_struct {} # else -# define zero_struct {0} +# define md_zero_struct {0} # endif #endif -#ifndef this_function_name -# if COMPILER_MSVC && COMPILER_MSVC_YEAR < 2015 -# define this_function_name "unknown" +#ifndef md_this_function_name +# if MD_COMPILER_MSVC && MD_COMPILER_MSVC_YEAR < 2015 +# define md_this_function_name "unknown" # else -# define this_function_name __func__ +# define md_this_function_name __func__ # endif #endif -#ifndef read_only -# if COMPILER_MSVC || (COMPILER_CLANG && OS_WINDOWS) +#ifndef md_read_only +# if MD_COMPILER_MSVC || (MD_COMPILER_CLANG && MD_OS_WINDOWS) # pragma section(".rdata$", read) -# define read_only __declspec(allocate(".rdata$")) -# elif (COMPILER_CLANG && OS_LINUX) -# define read_only __attribute__((section(".rodata"))) +# define md_read_only __declspec(allocate(".rdata$")) +# elif (MD_COMPILER_CLANG && MD_OS_LINUX) +# define md_read_only __attribute__((section(".rodata"))) # else // NOTE(rjf): I don't know of a useful way to do this in GCC land. // __attribute__((section(".rodata"))) looked promising, but it introduces a // strange warning about malformed section attributes, and it doesn't look // like writing to that section reliably produces access violations, strangely // enough. (It does on Clang) -# define read_only +# define md_read_only # endif #endif -#ifndef local_persist -#define local_persist static +#ifndef md_local_persist +#define md_local_persist static #endif -#if COMPILER_MSVC -# define thread_static __declspec(thread) -#elif COMPILER_CLANG || COMPILER_GCC -# define thread_static __thread +#if MD_COMPILER_MSVC +# define md_thread_static __declspec(thread) +#elif MD_COMPILER_CLANG || MD_COMPILER_GCC +# define md_thread_static __thread #endif -#if COMPILER_CPP +#if MD_COMPILER_CPP // Already Defined -#elif COMPILER_C && __STDC_VERSION__ >= 201112L -# define thread_local _Thread_local -#elif COMPILER_MSVC -# define thread_local __declspec(thread) -#elif COMPILER_CLANG -# define thread_local __thread +#elif MD_COMPILER_C && __STDC_VERSION__ >= 201112L +# define md_thread_local _Thread_local +#elif MD_COMPILER_MSVC +# define md_thread_local __declspec(thread) +#elif MD_COMPILER_CLANG +# define md_thread_local __thread #else # error "No thread local support" #endif @@ -857,41 +857,41 @@ sll__queue_pop_nz(void* nil, void** f, void* f_next, void** l) //////////////////////////////// //~ rjf: Safe Casts -inline U16 -safe_cast_u16(U32 x) { - assert_always(x <= MAX_U16); - U16 result = (U16)x; +inline MD_U16 +md_safe_cast_u16(MD_U32 x) { + md_assert_always(x <= MD_MAX_U16); + MD_U16 result = (MD_U16)x; return result; } -inline U32 -safe_cast_u32(U64 x) { - assert_always(x <= MAX_U32); - U32 result = (U32)x; +inline MD_U32 +md_safe_cast_u32(MD_U64 x) { + md_assert_always(x <= MD_MAX_U32); + MD_U32 result = (MD_U32)x; return result; } -inline S32 -safe_cast_s32(S64 x) { - assert_always(x <= MAX_S32); - S32 result = (S32)x; +inline MD_S32 +md_safe_cast_s32(MD_S64 x) { + md_assert_always(x <= MD_MAX_S32); + MD_S32 result = (MD_S32)x; return result; } //////////////////////////////// //~ rjf: Large Base Type Functions -inline U128 u128_zero (void) { U128 v = {0}; return v; } -inline U128 u128_make (U64 v0, U64 v1) { U128 v = {v0, v1}; return v; } -inline B32 u128_match(U128 a, U128 b) { return memory_match_struct(&a, &b); } +inline U128 md_u128_zero (void) { U128 v = {0}; return v; } +inline U128 md_u128_make (MD_U64 v0, MD_U64 v1) { U128 v = {v0, v1}; return v; } +inline MD_B32 md_u128_match(U128 a, U128 b) { return md_memory_match_struct(&a, &b); } //////////////////////////////// //~ rjf: Bit Patterns -inline U32 u32_from_u64_saturate(U64 x) { U32 x32 = (x > MAX_U32) ? MAX_U32 : (U32)x; return(x32); } +inline MD_U32 md_u32_from_u64_saturate(MD_U64 x) { MD_U32 x32 = (x > MD_MAX_U32) ? MD_MAX_U32 : (MD_U32)x; return(x32); } -inline U64 -u64_up_to_pow2(U64 x) { +inline MD_U64 +md_u64_up_to_pow2(MD_U64 x) { if (x == 0) { x = 1; } @@ -908,48 +908,48 @@ u64_up_to_pow2(U64 x) { return(x); } -inline S32 -extend_sign32(U32 x, U32 size) { - U32 high_bit = size * 8; - U32 shift = 32 - high_bit; - S32 result = ((S32)x << shift) >> shift; +inline MD_S32 +md_extend_sign32(MD_U32 x, MD_U32 size) { + MD_U32 high_bit = size * 8; + MD_U32 shift = 32 - high_bit; + MD_S32 result = ((MD_S32)x << shift) >> shift; return result; } -inline S64 -extend_sign64(U64 x, U64 size) { - U64 high_bit = size * 8; - U64 shift = 64 - high_bit; - S64 result = ((S64)x << shift) >> shift; +inline MD_S64 +md_extend_sign64(MD_U64 x, MD_U64 size) { + MD_U64 high_bit = size * 8; + MD_U64 shift = 64 - high_bit; + MD_S64 result = ((MD_S64)x << shift) >> shift; return result; } -inline F32 inf32 (void) { union { U32 u; F32 f; } x; x.u = EXPONENT32; return(x.f); } -inline F32 neg_inf32(void) { union { U32 u; F32 f; } x; x.u = SIGN32 | EXPONENT32; return(x.f); } +inline MD_F32 md_inf32 (void) { union { MD_U32 u; MD_F32 f; } x; x.u = MD_EXPONENT32; return(x.f); } +inline MD_F32 md_neg_inf32(void) { union { MD_U32 u; MD_F32 f; } x; x.u = MD_SIGN32 | MD_EXPONENT32; return(x.f); } -inline U16 -bswap_u16(U16 x) +inline MD_U16 +md_bswap_u16(MD_U16 x) { - U16 result = (((x & 0xFF00) >> 8) | + MD_U16 result = (((x & 0xFF00) >> 8) | ((x & 0x00FF) << 8)); return result; } -inline U32 -bswap_u32(U32 x) +inline MD_U32 +md_bswap_u32(MD_U32 x) { - U32 result = (((x & 0xFF000000) >> 24) | + MD_U32 result = (((x & 0xFF000000) >> 24) | ((x & 0x00FF0000) >> 8) | ((x & 0x0000FF00) << 8) | ((x & 0x000000FF) << 24)); return result; } -inline U64 -bswap_u64(U64 x) +inline MD_U64 +md_bswap_u64(MD_U64 x) { // TODO(nick): naive bswap, replace with something that is faster like an intrinsic - U64 result = (((x & 0xFF00000000000000ULL) >> 56) | + MD_U64 result = (((x & 0xFF00000000000000ULL) >> 56) | ((x & 0x00FF000000000000ULL) >> 40) | ((x & 0x0000FF0000000000ULL) >> 24) | ((x & 0x000000FF00000000ULL) >> 8) | @@ -960,34 +960,34 @@ bswap_u64(U64 x) return result; } -#if ARCH_LITTLE_ENDIAN -# define from_be_u16(x) bswap_u16(x) -# define from_be_u32(x) bswap_u32(x) -# define from_be_u64(x) bswap_u64(x) +#if MD_ARCH_LITTLE_ENDIAN +# define md_from_be_u16(x) md_bswap_u16(x) +# define md_from_be_u32(x) md_bswap_u32(x) +# define md_from_be_u64(x) md_bswap_u64(x) #else -# define from_be_u16(x) (x) -# define from_be_u32(x) (x) -# define from_be_u64(x) (x) +# define md_from_be_u16(x) (x) +# define md_from_be_u32(x) (x) +# define md_from_be_u64(x) (x) #endif -#if COMPILER_MSVC || (COMPILER_CLANG && OS_WINDOWS) - inline U64 count_bits_set16(U16 val) { return __popcnt16(val); } - inline U64 count_bits_set32(U32 val) { return __popcnt (val); } - inline U64 count_bits_set64(U64 val) { return __popcnt64(val); } +#if MD_COMPILER_MSVC || (MD_COMPILER_CLANG && MD_OS_WINDOWS) + inline MD_U64 md_count_bits_set16(MD_U16 val) { return __popcnt16(val); } + inline MD_U64 md_count_bits_set32(MD_U32 val) { return __popcnt (val); } + inline MD_U64 md_count_bits_set64(MD_U64 val) { return __popcnt64(val); } - inline U64 ctz32(U32 mask) { unsigned long idx; _BitScanForward (&idx, mask); return idx; } - inline U64 ctz64(U64 mask) { unsigned long idx; _BitScanForward64(&idx, mask); return idx; } - inline U64 clz32(U32 mask) { unsigned long idx; _BitScanReverse (&idx, mask); return 31 - idx; } - inline U64 clz64(U64 mask) { unsigned long idx; _BitScanReverse64(&idx, mask); return 63 - idx; } -#elif COMPILER_CLANG || COMPILER_GCC - inline U64 count_bits_set16(U16 val) { NotImplemented; return 0; } - inline U64 count_bits_set32(U32 val) { NotImplemented; return 0; } - inline U64 count_bits_set64(U64 val) { NotImplemented; return 0; } + inline MD_U64 md_ctz32(MD_U32 mask) { unsigned long idx; _BitScanForward (&idx, mask); return idx; } + inline MD_U64 md_ctz64(MD_U64 mask) { unsigned long idx; _BitScanForward64(&idx, mask); return idx; } + inline MD_U64 md_clz32(MD_U32 mask) { unsigned long idx; _BitScanReverse (&idx, mask); return 31 - idx; } + inline MD_U64 md_clz64(MD_U64 mask) { unsigned long idx; _BitScanReverse64(&idx, mask); return 63 - idx; } +#elif MD_COMPILER_CLANG || MD_COMPILER_GCC + inline MD_U64 md_count_bits_set16(MD_U16 val) { NotImplemented; return 0; } + inline MD_U64 md_count_bits_set32(MD_U32 val) { NotImplemented; return 0; } + inline MD_U64 md_count_bits_set64(MD_U64 val) { NotImplemented; return 0; } - inline U64 ctz32(U32 val) { NotImplemented; return 0; } - inline U64 ctz64(U32 val) { NotImplemented; return 0; } - inline U64 clz32(U32 val) { NotImplemented; return 0; } - inline U64 clz64(U64 val) { NotImplemented; return 0; } + inline MD_U64 md_ctz32(MD_U32 val) { NotImplemented; return 0; } + inline MD_U64 md_ctz64(MD_U32 val) { NotImplemented; return 0; } + inline MD_U64 md_clz32(MD_U32 val) { NotImplemented; return 0; } + inline MD_U64 md_clz64(MD_U64 val) { NotImplemented; return 0; } #else # error "Bit intrinsic functions not defined for this compiler." #endif diff --git a/source/base/memory_substrate.c b/source/base/memory_substrate.c index 64ec253..0d9e27f 100644 --- a/source/base/memory_substrate.c +++ b/source/base/memory_substrate.c @@ -5,15 +5,15 @@ #endif void* -default_resize_align( AllocatorInfo a, void* old_memory, SSIZE old_size, SSIZE new_size, SSIZE alignment ) +md_default_resize_align( MD_AllocatorInfo a, void* old_memory, MD_SSIZE old_size, MD_SSIZE new_size, MD_SSIZE alignment ) { if ( ! old_memory ) - return alloc_align( a, new_size, alignment ); + return md_alloc_align( a, new_size, alignment ); if ( new_size == 0 ) { - alloc_free( a, old_memory ); - return nullptr; + md_alloc_free( a, old_memory ); + return md_nullptr; } if ( new_size < old_size ) @@ -25,12 +25,12 @@ default_resize_align( AllocatorInfo a, void* old_memory, SSIZE old_size, SSIZE n } else { - void* new_memory = alloc_align( a, new_size, alignment ); + void* new_memory = md_alloc_align( a, new_size, alignment ); if ( ! new_memory ) - return nullptr; + return md_nullptr; - mem_move( new_memory, old_memory, md_min( new_size, old_size ) ); - alloc_free( a, old_memory ); + md_mem_move( new_memory, old_memory, md_min( new_size, old_size ) ); + md_alloc_free( a, old_memory ); return new_memory; } } @@ -41,73 +41,73 @@ default_resize_align( AllocatorInfo a, void* old_memory, SSIZE old_size, SSIZE n typedef struct _heap_stats _heap_stats; struct _heap_stats { - U32 magic; - SSIZE used_memory; - SSIZE alloc_count; + MD_U32 magic; + MD_SSIZE used_memory; + MD_SSIZE md_alloc_count; }; -global _heap_stats _heap_stats_info; +md_global _heap_stats _heap_stats_info; void -heap_stats_init( void ) +md_heap_stats_init( void ) { - memory_zero_struct( &_heap_stats_info ); + md_memory_zero_struct( &_heap_stats_info ); _heap_stats_info.magic = GEN_HEAP_STATS_MAGIC; } -SSIZE +MD_SSIZE heap_stats_used_memory( void ) { - assert_msg( _heap_stats_info.magic == GEN_HEAP_STATS_MAGIC, "heap_stats is not initialised yet, call heap_stats_init first!" ); + md_assert_msg( _heap_stats_info.magic == GEN_HEAP_STATS_MAGIC, "heap_stats is not initialised yet, call md_heap_stats_init first!" ); return _heap_stats_info.used_memory; } -SSIZE -heap_stats_alloc_count( void ) +MD_SSIZE +md_heap_stats_alloc_count( void ) { - assert_msg( _heap_stats_info.magic == GEN_HEAP_STATS_MAGIC, "heap_stats is not initialised yet, call heap_stats_init first!" ); - return _heap_stats_info.alloc_count; + md_assert_msg( _heap_stats_info.magic == GEN_HEAP_STATS_MAGIC, "heap_stats is not initialised yet, call md_heap_stats_init first!" ); + return _heap_stats_info.md_alloc_count; } void -heap_stats_check( void ) +md_heap_stats_check( void ) { - assert_msg( _heap_stats_info.magic == GEN_HEAP_STATS_MAGIC, "heap_stats is not initialised yet, call heap_stats_init first!" ); - assert( _heap_stats_info.used_memory == 0 ); - assert( _heap_stats_info.alloc_count == 0 ); + md_assert_msg( _heap_stats_info.magic == GEN_HEAP_STATS_MAGIC, "heap_stats is not initialised yet, call md_heap_stats_init first!" ); + md_assert( _heap_stats_info.used_memory == 0 ); + md_assert( _heap_stats_info.md_alloc_count == 0 ); } typedef struct _heap_alloc_info _heap_alloc_info; struct _heap_alloc_info { - SSIZE size; + MD_SSIZE size; void* physical_start; }; #endif void* -heap_allocator_proc( void* allocator_data, AllocatorMode mode, SSIZE size, SSIZE alignment, void* old_memory, SSIZE old_size, U64 flags ) +md_heap_allocator_proc( void* allocator_data, MD_AllocatorMode mode, MD_SSIZE size, MD_SSIZE alignment, void* old_memory, MD_SSIZE old_size, MD_U64 flags ) { - void* ptr = nullptr; + void* ptr = md_nullptr; // unused( allocator_data ); // unused( old_size ); if ( ! alignment ) alignment = MD_DEFAULT_MEMORY_ALIGNMENT; #ifdef MD_HEAP_ANALYSIS - ssize alloc_info_size = size_of( _heap_alloc_info ); - ssize alloc_info_remainder = ( alloc_info_size % alignment ); - ssize track_size = max( alloc_info_size, alignment ) + alloc_info_remainder; + ssize md_alloc_info_size = size_of( _heap_alloc_info ); + ssize md_alloc_info_remainder = ( md_alloc_info_size % alignment ); + ssize track_size = md_max( md_alloc_info_size, alignment ) + md_alloc_info_remainder; switch ( type ) { case EAllocatorMode_FREE : { if ( ! old_memory ) break; - _heap_alloc_info* alloc_info = rcast( _heap_alloc_info*, old_memory) - 1; - _heap_stats_info.used_memory -= alloc_info->size; - _heap_stats_info.alloc_count--; - old_memory = alloc_info->physical_start; + _heap_alloc_info* md_alloc_info = md_rcast( _heap_alloc_info*, old_memory) - 1; + _heap_stats_info.used_memory -= md_alloc_info->size; + _heap_stats_info.md_alloc_count--; + old_memory = md_alloc_info->physical_start; } break; case EAllocatorMode_ALLOC : @@ -122,27 +122,27 @@ heap_allocator_proc( void* allocator_data, AllocatorMode mode, SSIZE size, SSIZE switch ( mode ) { - #if defined( COMPILER_MSVC ) || ( defined( COMPILER_GCC ) && defined( OS_WINDOWS ) ) || ( defined( COMPILER_TINYC ) && defined( OS_WINDOWS ) ) - case AllocatorMode_Alloc: + #if defined( MD_COMPILER_MSVC ) || ( defined( MD_COMPILER_GCC ) && defined( MD_OS_WINDOWS ) ) || ( defined( MD_COMPILER_TINYC ) && defined( MD_OS_WINDOWS ) ) + case MD_AllocatorMode_Alloc: { ptr = _aligned_malloc( size, alignment ); - if ( flags & ALLOCATOR_FLAG_CLEAR_TO_ZERO ) - memory_zero( ptr, size ); + if ( flags & MD_ALLOCATOR_FLAG_CLEAR_TO_ZERO ) + md_memory_zero( ptr, size ); } break; - case AllocatorMode_Free: + case MD_AllocatorMode_Free: _aligned_free( old_memory ); break; - case AllocatorMode_Resize: + case MD_AllocatorMode_Resize: { - AllocatorInfo a = heap(); - ptr = default_resize_align( a, old_memory, old_size, size, alignment ); + MD_AllocatorInfo a = md_heap(); + ptr = md_default_resize_align( a, old_memory, old_size, size, alignment ); } break; - #elif defined( OS_LINUX ) && ! defined( CPU_ARM ) && ! defined( COMPILER_TINYC ) + #elif defined( MD_OS_LINUX ) && ! defined( CPU_ARM ) && ! defined( MD_COMPILER_TINYC ) case EAllocation_ALLOC : { ptr = aligned_alloc( alignment, ( size + alignment - 1 ) & ~( alignment - 1 ) ); @@ -162,8 +162,8 @@ heap_allocator_proc( void* allocator_data, AllocatorMode mode, SSIZE size, SSIZE case EAllocation_RESIZE : { - AllocatorInfo a = heap(); - ptr = default_resize_align( a, old_memory, old_size, size, alignment ); + MD_AllocatorInfo a = md_heap(); + ptr = md_default_resize_align( a, old_memory, old_size, size, alignment ); } break; #else @@ -171,7 +171,7 @@ heap_allocator_proc( void* allocator_data, AllocatorMode mode, SSIZE size, SSIZE { posix_memalign( &ptr, alignment, size ); - if ( flags & ALLOCATOR_FLAG_CLEAR_TO_ZERO ) + if ( flags & MD_ALLOCATOR_FLAG_CLEAR_TO_ZERO ) { zero_size( ptr, size ); } @@ -186,89 +186,89 @@ heap_allocator_proc( void* allocator_data, AllocatorMode mode, SSIZE size, SSIZE case EAllocType_RESIZE : { - AllocatorInfo a = heap(); - ptr = default_resize_align( a, old_memory, old_size, size, alignment ); + MD_AllocatorInfo a = md_heap(); + ptr = md_default_resize_align( a, old_memory, old_size, size, alignment ); } break; #endif - case AllocatorMode_FreeAll: + case MD_AllocatorMode_FreeAll: break; - case AllocatorMode_QueryType: - return (void*) AllocatorType_Heap; + case MD_AllocatorMode_QueryType: + return (void*) MD_AllocatorType_Heap; - case AllocatorMode_QuerySupport: + case MD_AllocatorMode_QuerySupport: return (void*) ( - AllocatorQuery_Alloc | AllocatorQuery_Free | AllocatorQuery_Resize | AllocatorQuery_ResizeGrow | AllocatorQuery_ResizeShrink + MD_AllocatorQuery_Alloc | MD_AllocatorQuery_Free | MD_AllocatorQuery_Resize | MD_AllocatorQuery_ResizeGrow | MD_AllocatorQuery_ResizeShrink ); } #ifdef GEN_HEAP_ANALYSIS - if ( type == AllocatorMode_Alloc ) + if ( type == MD_AllocatorMode_Alloc ) { - _heap_alloc_info* alloc_info = rcast( _heap_alloc_info*, rcast( char*, ptr) + alloc_info_remainder ); - zero_item( alloc_info ); - alloc_info->size = size - track_size; - alloc_info->physical_start = ptr; - ptr = rcast( void*, alloc_info + 1 ); - _heap_stats_info.used_memory += alloc_info->size; - _heap_stats_info.alloc_count++; + _heap_alloc_info* md_alloc_info = md_rcast( _heap_alloc_info*, md_rcast( char*, ptr) + md_alloc_info_remainder ); + zero_item( md_alloc_info ); + md_alloc_info->size = size - track_size; + md_alloc_info->physical_start = ptr; + ptr = md_rcast( void*, md_alloc_info + 1 ); + _heap_stats_info.used_memory += md_alloc_info->size; + _heap_stats_info.md_alloc_count++; } #endif return ptr; } -VArena* -varena__alloc(VArenaParams params) +MD_VArena* +md_varena__alloc(MD_VArenaParams params) { if (params.reserve_size == 0) { - params.reserve_size = VARENA_DEFAULT_RESERVE; + params.reserve_size = MD_VARENA_DEFAULT_RESERVE; } if (params.commit_size == 0) { - params.commit_size = VARENA_DEFAULT_COMMIT; + params.commit_size = MD_VARENA_DEFAULT_COMMIT; } // rjf: round up reserve/commit sizes - U64 reserve_size = params.reserve_size; - U64 commit_size = params.commit_size; + MD_U64 reserve_size = params.reserve_size; + MD_U64 commit_size = params.commit_size; - void* base = nullptr; - if (params.flags & VArenaFlag_LargePages) + void* base = md_nullptr; + if (params.flags & MD_VArenaFlag_LargePages) { - reserve_size = align_pow2(reserve_size, os_get_system_info()->large_page_size); - commit_size = align_pow2(commit_size, os_get_system_info()->large_page_size); + reserve_size = md_align_pow2(reserve_size, md_os_get_system_info()->large_page_size); + commit_size = md_align_pow2(commit_size, md_os_get_system_info()->large_page_size); - base = os_reserve_large(reserve_size); - os_commit_large(base, commit_size); - asan_poison_memory_region(base, params.commit_size); + base = md_os_reserve_large(reserve_size); + md_os_commit_large(base, commit_size); + md_asan_poison_memory_region(base, params.commit_size); } else { - reserve_size = align_pow2(reserve_size, os_get_system_info()->page_size); - commit_size = align_pow2(commit_size, os_get_system_info()->page_size); + reserve_size = md_align_pow2(reserve_size, md_os_get_system_info()->page_size); + commit_size = md_align_pow2(commit_size, md_os_get_system_info()->page_size); - base = os_reserve(reserve_size); - B32 commit_result = os_commit(base, commit_size); - assert(commit_result == 1); - asan_poison_memory_region(base, params.commit_size); + base = md_os_reserve(reserve_size); + MD_B32 commit_result = md_os_commit(base, commit_size); + md_assert(commit_result == 1); + md_asan_poison_memory_region(base, params.commit_size); } // NOTE(Ed): Panic on varena creation failure - #if OS_FEATURE_GRAPHICAL - if(unlikely(base == 0)) + #if MD_OS_FEATURE_GRAPHICAL + if(md_unlikely(base == 0)) { - os_graphical_message(1, str8_lit("Fatal Allocation Failure"), str8_lit("Unexpected memory allocation failure.")); - os_abort(1); + md_os_graphical_message(1, md_str8_lit("Fatal Allocation Failure"), md_str8_lit("Unexpected memory allocation failure.")); + md_os_abort(1); } #endif - SPTR header_size = align_pow2(size_of(VArena), MD_DEFAULT_MEMORY_ALIGNMENT); - asan_unpoison_memory_region(base, header_size); + MD_SPTR header_size = md_align_pow2(size_of(MD_VArena), MD_DEFAULT_MEMORY_ALIGNMENT); + md_asan_unpoison_memory_region(base, header_size); - VArena* vm = rcast(VArena*, base); - vm->reserve_start = rcast(SPTR, base) + header_size; + MD_VArena* vm = md_rcast(MD_VArena*, base); + vm->reserve_start = md_rcast(MD_SPTR, base) + header_size; vm->reserve = reserve_size; vm->commit_size = params.commit_size; vm->committed = commit_size; @@ -278,50 +278,50 @@ varena__alloc(VArenaParams params) } void -varena_release(VArena* arena) +md_varena_release(MD_VArena* arena) { - os_release(arena, arena->reserve); - arena = nullptr; + md_os_release(arena, arena->reserve); + arena = md_nullptr; } void* -varena_allocator_proc(void* allocator_data, AllocatorMode mode, SSIZE requested_size, SSIZE alignment, void* old_memory, SSIZE old_size, U64 flags) +md_varena_allocator_proc(void* allocator_data, MD_AllocatorMode mode, MD_SSIZE requested_size, MD_SSIZE alignment, void* old_memory, MD_SSIZE old_size, MD_U64 flags) { - OS_SystemInfo const* info = os_get_system_info(); + MD_OS_SystemInfo const* info = md_os_get_system_info(); - VArena* vm = rcast(VArena*, allocator_data); + MD_VArena* vm = md_rcast(MD_VArena*, allocator_data); - void* allocated_mem = nullptr; + void* allocated_mem = md_nullptr; switch (mode) { - case AllocatorMode_Alloc: + case MD_AllocatorMode_Alloc: { - assert_msg(requested_size != 0, "requested_size is 0"); + md_assert_msg(requested_size != 0, "requested_size is 0"); - requested_size = align_pow2(requested_size, alignment); + requested_size = md_align_pow2(requested_size, alignment); - UPTR current_offset = vm->reserve_start + vm->commit_used; - UPTR size_to_allocate = requested_size; - UPTR to_be_used = vm->commit_used + size_to_allocate; - SPTR reserve_left = vm->reserve - vm->committed; - assert(to_be_used < reserve_left); + MD_UPTR current_offset = vm->reserve_start + vm->commit_used; + MD_UPTR size_to_allocate = requested_size; + MD_UPTR to_be_used = vm->commit_used + size_to_allocate; + MD_SPTR reserve_left = vm->reserve - vm->committed; + md_assert(to_be_used < reserve_left); - UPTR header_offset = vm->reserve_start - scast(UPTR, vm); + MD_UPTR header_offset = vm->reserve_start - md_scast(MD_UPTR, vm); - UPTR commit_left = vm->committed - vm->commit_used - header_offset; - B32 needs_more_commited = commit_left < size_to_allocate; + MD_UPTR commit_left = vm->committed - vm->commit_used - header_offset; + MD_B32 needs_more_commited = commit_left < size_to_allocate; if (needs_more_commited) { - UPTR next_commit_size; - if (vm->flags & VArenaFlag_LargePages) { - next_commit_size = reserve_left > 0 ? md_max(vm->commit_size, size_to_allocate) : scast(UPTR, align_pow2( abs(reserve_left), os_get_system_info()->large_page_size)); + MD_UPTR next_commit_size; + if (vm->flags & MD_VArenaFlag_LargePages) { + next_commit_size = reserve_left > 0 ? md_max(vm->commit_size, size_to_allocate) : md_scast(MD_UPTR, md_align_pow2( abs(reserve_left), md_os_get_system_info()->large_page_size)); } else { - next_commit_size = reserve_left > 0 ? md_max(vm->commit_size, size_to_allocate) : scast(UPTR, align_pow2(abs(reserve_left), os_get_system_info()->page_size)); + next_commit_size = reserve_left > 0 ? md_max(vm->commit_size, size_to_allocate) : md_scast(MD_UPTR, md_align_pow2(abs(reserve_left), md_os_get_system_info()->page_size)); } if (next_commit_size) { - void* next_commit_start = rcast(void*, rcast(UPTR, vm) + vm->committed); - B32 commit_result = os_commit(next_commit_start, next_commit_size); + void* next_commit_start = md_rcast(void*, md_rcast(MD_UPTR, vm) + vm->committed); + MD_B32 commit_result = md_os_commit(next_commit_start, next_commit_size); if (commit_result == false) { break; } @@ -329,60 +329,60 @@ varena_allocator_proc(void* allocator_data, AllocatorMode mode, SSIZE requested_ } } - allocated_mem = rcast(void*, current_offset); + allocated_mem = md_rcast(void*, current_offset); vm->commit_used += size_to_allocate; } break; - case AllocatorMode_Free: + case MD_AllocatorMode_Free: { } break; - case AllocatorMode_FreeAll: + case MD_AllocatorMode_FreeAll: { vm->commit_used = 0; } break; - case AllocatorMode_Resize: + case MD_AllocatorMode_Resize: { - assert(old_memory != nullptr); - assert(old_size > 0); - assert_msg(old_size == requested_size, "Requested resize when none needed"); + md_assert(old_memory != md_nullptr); + md_assert(old_size > 0); + md_assert_msg(old_size == requested_size, "Requested md_resize when none needed"); - requested_size = align_pow2(requested_size, alignment); - old_size = align_pow2(old_size, alignment); + requested_size = md_align_pow2(requested_size, alignment); + old_size = md_align_pow2(old_size, alignment); - UPTR old_memory_offset = scast(UPTR, old_memory) + scast(UPTR, old_size); - UPTR current_offset = scast(UPTR, vm->reserve_start) + scast(UPTR, vm->commit_used); + MD_UPTR old_memory_offset = md_scast(MD_UPTR, old_memory) + md_scast(MD_UPTR, old_size); + MD_UPTR current_offset = md_scast(MD_UPTR, vm->reserve_start) + md_scast(MD_UPTR, vm->commit_used); - assert_msg(old_memory_offset == current_offset, "Cannot resize existing allocation in VArena unless it was the last allocated"); + md_assert_msg(old_memory_offset == current_offset, "Cannot md_resize existing allocation in MD_VArena unless it was the last allocated"); - B32 requested_shrink = requested_size >= old_size; + MD_B32 requested_shrink = requested_size >= old_size; if (requested_shrink) { - vm->commit_used -= rcast(UPTR, align_pow2(requested_size, alignment)); + vm->commit_used -= md_rcast(MD_UPTR, md_align_pow2(requested_size, alignment)); allocated_mem = old_memory; break; } - UPTR size_to_allocate = requested_size - old_size, alignment; + MD_UPTR size_to_allocate = requested_size - old_size, alignment; - UPTR header_offset = vm->reserve_start - scast(UPTR, vm); - UPTR commit_left = vm->committed - vm->commit_used - header_offset; - B32 needs_more_commited = commit_left < size_to_allocate; + MD_UPTR header_offset = vm->reserve_start - md_scast(MD_UPTR, vm); + MD_UPTR commit_left = vm->committed - vm->commit_used - header_offset; + MD_B32 needs_more_commited = commit_left < size_to_allocate; if (needs_more_commited) { - SPTR reserve_left = vm->reserve - vm->committed; - UPTR next_commit_size; - if (vm->flags & VArenaFlag_LargePages) { - next_commit_size = reserve_left > 0 ? vm->commit_size : scast(UPTR, align_pow2( -reserve_left, os_get_system_info()->large_page_size)); + MD_SPTR reserve_left = vm->reserve - vm->committed; + MD_UPTR next_commit_size; + if (vm->flags & MD_VArenaFlag_LargePages) { + next_commit_size = reserve_left > 0 ? vm->commit_size : md_scast(MD_UPTR, md_align_pow2( -reserve_left, md_os_get_system_info()->large_page_size)); } else { - next_commit_size = reserve_left > 0 ? vm->commit_size : scast(UPTR, align_pow2(abs(reserve_left), os_get_system_info()->page_size)); + next_commit_size = reserve_left > 0 ? vm->commit_size : md_scast(MD_UPTR, md_align_pow2(abs(reserve_left), md_os_get_system_info()->page_size)); } if (next_commit_size) { - B32 commit_result = os_commit(vm, next_commit_size); + MD_B32 commit_result = md_os_commit(vm, next_commit_size); if (commit_result == false) { break; } @@ -394,16 +394,16 @@ varena_allocator_proc(void* allocator_data, AllocatorMode mode, SSIZE requested_ } break; - case AllocatorMode_QueryType: + case MD_AllocatorMode_QueryType: { - return (void*) AllocatorType_VArena; + return (void*) MD_AllocatorType_VArena; } break; - case AllocatorMode_QuerySupport: + case MD_AllocatorMode_QuerySupport: { return (void*) ( - AllocatorQuery_Alloc | AllocatorQuery_FreeAll | AllocatorQuery_Resize | AllocatorQuery_ResizeGrow | AllocatorQuery_ResizeShrink + MD_AllocatorQuery_Alloc | MD_AllocatorQuery_FreeAll | MD_AllocatorQuery_Resize | MD_AllocatorQuery_ResizeGrow | MD_AllocatorQuery_ResizeShrink ); } break; @@ -412,54 +412,54 @@ varena_allocator_proc(void* allocator_data, AllocatorMode mode, SSIZE requested_ } void* -farena_allocator_proc(void* allocator_data, AllocatorMode mode, SSIZE size, SSIZE alignment, void* old_memory, SSIZE old_size, U64 flags) +farena_allocator_proc(void* allocator_data, MD_AllocatorMode mode, MD_SSIZE size, MD_SSIZE alignment, void* old_memory, MD_SSIZE old_size, MD_U64 flags) { - FArena* arena = rcast(FArena*, allocator_data); + MD_FArena* arena = md_rcast(MD_FArena*, allocator_data); - void* allocated_mem = nullptr; + void* allocated_mem = md_nullptr; switch (mode) { - case AllocatorMode_Alloc: + case MD_AllocatorMode_Alloc: { - SPTR end = scast(SPTR, arena->slice.data) + arena->used; - SSIZE total_size = align_pow2(size, alignment); + MD_SPTR end = md_scast(MD_SPTR, arena->slice.data) + arena->used; + MD_SSIZE total_size = md_align_pow2(size, alignment); if (arena->used + total_size > arena->slice.len ) { // Out of memory return allocated_mem; } - allocated_mem = scast(void*, end); + allocated_mem = md_scast(void*, end); arena->used += total_size; } break; - case AllocatorMode_Free: + case MD_AllocatorMode_Free: { } break; - case AllocatorMode_FreeAll: + case MD_AllocatorMode_FreeAll: { arena->used = 0; } break; - case AllocatorMode_Resize: + case MD_AllocatorMode_Resize: { - assert(old_memory != nullptr); - assert(old_size > 0); - assert_msg(old_size == size, "Requested resize when none needed"); + md_assert(old_memory != md_nullptr); + md_assert(old_size > 0); + md_assert_msg(old_size == size, "Requested md_resize when none needed"); - size = align_pow2(size, alignment); - old_size = align_pow2(size, alignment); + size = md_align_pow2(size, alignment); + old_size = md_align_pow2(size, alignment); - SPTR old_memory_offset = scast(SPTR, old_memory) + old_size; - SPTR current_offset = scast(SPTR, arena->slice.data) + arena->used; + MD_SPTR old_memory_offset = md_scast(MD_SPTR, old_memory) + old_size; + MD_SPTR current_offset = md_scast(MD_SPTR, arena->slice.data) + arena->used; - assert_msg(old_memory_offset == current_offset, "Cannot resize existing allocation in VArena unless it was the last allocated"); + md_assert_msg(old_memory_offset == current_offset, "Cannot md_resize existing allocation in MD_VArena unless it was the last allocated"); - B32 requested_shrink = size >= old_size; + MD_B32 requested_shrink = size >= old_size; if (requested_shrink) { arena->used -= size; @@ -472,13 +472,13 @@ farena_allocator_proc(void* allocator_data, AllocatorMode mode, SSIZE size, SSIZ } break; - case AllocatorMode_QueryType: - return (void*) AllocatorType_FArena; + case MD_AllocatorMode_QueryType: + return (void*) MD_AllocatorType_FArena; break; - case AllocatorMode_QuerySupport: + case MD_AllocatorMode_QuerySupport: return (void*) ( - AllocatorQuery_Alloc | AllocatorQuery_FreeAll | AllocatorQuery_Resize | AllocatorQuery_ResizeGrow | AllocatorQuery_ResizeShrink + MD_AllocatorQuery_Alloc | MD_AllocatorQuery_FreeAll | MD_AllocatorQuery_Resize | MD_AllocatorQuery_ResizeGrow | MD_AllocatorQuery_ResizeShrink ); break; } diff --git a/source/base/memory_substrate.h b/source/base/memory_substrate.h index 8ceb087..1a43c58 100644 --- a/source/base/memory_substrate.h +++ b/source/base/memory_substrate.h @@ -14,57 +14,57 @@ // Users can override the underlying memory allocator used, even for the HMH arena memory strategy. #ifndef MD__ONES -#define MD__ONES ( scast( GEN_NS usize, - 1) / MD_U8_MAX ) +#define MD__ONES ( md_scast( GEN_NS usize, - 1) / MD_U8_MAX ) #define MD__HIGHS ( MD__ONES * ( MD_U8_MAX / 2 + 1 ) ) #define MD__HAS_ZERO( x ) ( ( ( x ) - MD__ONES ) & ~( x ) & MD__HIGHS ) #endif -// Return value of allocator_type -typedef U64 AllocatorType; +// Return value of md_allocator_type +typedef MD_U64 MD_AllocatorType; enum { - AllocatorType_Heap = 0, // Genreal heap allocator - AllocatorType_VArena = 1, // Arena allocator backed by virtual address space - AllocatorType_FArena = 2, // Fixed arena backed back by a fixed size block of memory (usually a byte slice) - AllocatorType_Arena = 3, // Composite arena used originally by RAD Debugger & Metadesk + MD_AllocatorType_Heap = 0, // Genreal md_heap allocator + MD_AllocatorType_VArena = 1, // MD_Arena allocator backed by virtual address space + MD_AllocatorType_FArena = 2, // Fixed arena backed back by a fixed size block of memory (usually a byte slice) + MD_AllocatorType_Arena = 3, // Composite arena used originally by RAD Debugger & Metadesk }; -typedef U32 AllocatorMode; -enum AllocatorMode +typedef MD_U32 MD_AllocatorMode; +enum MD_AllocatorMode { - AllocatorMode_Alloc, - AllocatorMode_Free, - AllocatorMode_FreeAll, - AllocatorMode_Resize, - AllocatorMode_QueryType, - AllocatorMode_QuerySupport, + MD_AllocatorMode_Alloc, + MD_AllocatorMode_Free, + MD_AllocatorMode_FreeAll, + MD_AllocatorMode_Resize, + MD_AllocatorMode_QueryType, + MD_AllocatorMode_QuerySupport, }; -typedef U64 AllocatorQueryFlags; +typedef MD_U64 MD_AllocatorQueryFlags; enum { - AllocatorQuery_Alloc = (1 << 0), - AllocatorQuery_Free = (1 << 1), - AllocatorQuery_FreeAll = (1 << 2), - AllocatorQuery_Resize = (1 << 3), // Supports both grow and shrink - AllocatorQuery_ResizeShrink = (1 << 4), - AllocatorQuery_ResizeGrow = (1 << 5), + MD_AllocatorQuery_Alloc = (1 << 0), + MD_AllocatorQuery_Free = (1 << 1), + MD_AllocatorQuery_FreeAll = (1 << 2), + MD_AllocatorQuery_Resize = (1 << 3), // Supports both grow and shrink + MD_AllocatorQuery_ResizeShrink = (1 << 4), + MD_AllocatorQuery_ResizeGrow = (1 << 5), }; -typedef void*(AllocatorProc)( void* allocator_data, AllocatorMode type, SSIZE size, SSIZE alignment, void* old_memory, SSIZE old_size, U64 flags ); +typedef void*(MD_AllocatorProc)( void* allocator_data, MD_AllocatorMode type, MD_SSIZE size, MD_SSIZE alignment, void* old_memory, MD_SSIZE old_size, MD_U64 flags ); -typedef struct AllocatorInfo AllocatorInfo; -struct AllocatorInfo +typedef struct MD_AllocatorInfo MD_AllocatorInfo; +struct MD_AllocatorInfo { - AllocatorProc* proc; + MD_AllocatorProc* proc; void* data; }; // Overridable by the user by defining MD_OVERRIDE_DEFAULT_ALLOCATOR -AllocatorInfo default_allocator(); +MD_AllocatorInfo md_default_allocator(); enum AllocFlag { - ALLOCATOR_FLAG_CLEAR_TO_ZERO = (1 << 0), + MD_ALLOCATOR_FLAG_CLEAR_TO_ZERO = (1 << 0), }; #ifndef MD_DEFAULT_MEMORY_ALIGNMENT @@ -72,222 +72,222 @@ enum AllocFlag #endif #ifndef MD_DEFAULT_ALLOCATOR_FLAGS -# define MD_DEFAULT_ALLOCATOR_FLAGS ( ALLOCATOR_FLAG_CLEAR_TO_ZERO ) +# define MD_DEFAULT_ALLOCATOR_FLAGS ( MD_ALLOCATOR_FLAG_CLEAR_TO_ZERO ) #endif // Retrieve which type of allocator -AllocatorType allocator_type(AllocatorInfo a); +MD_AllocatorType md_allocator_type(MD_AllocatorInfo a); // Retreive which modes the allocator supports -AllocatorQueryFlags allocator_query_support(AllocatorInfo a); +MD_AllocatorQueryFlags md_allocator_query_support(MD_AllocatorInfo a); // Allocate memory with default alignment. -void* alloc( AllocatorInfo a, SSIZE size ); +void* md_alloc( MD_AllocatorInfo a, MD_SSIZE size ); // Allocate memory with specified alignment. -void* alloc_align( AllocatorInfo a, SSIZE size, SSIZE alignment ); +void* md_alloc_align( MD_AllocatorInfo a, MD_SSIZE size, MD_SSIZE alignment ); // Free allocated memory. -void alloc_free( AllocatorInfo a, void* ptr ); +void md_alloc_free( MD_AllocatorInfo a, void* ptr ); // Free all memory allocated by an allocator. -void free_all( AllocatorInfo a ); +void md_free_all( MD_AllocatorInfo a ); // Resize an allocated memory. -void* resize( AllocatorInfo a, void* ptr, SSIZE old_size, SSIZE new_size ); +void* md_resize( MD_AllocatorInfo a, void* ptr, MD_SSIZE old_size, MD_SSIZE new_size ); // Resize an allocated memory with specified alignment. -void* resize_align( AllocatorInfo a, void* ptr, SSIZE old_size, SSIZE new_size, SSIZE alignment ); +void* md_resize_align( MD_AllocatorInfo a, void* ptr, MD_SSIZE old_size, MD_SSIZE new_size, MD_SSIZE alignment ); -#ifndef alloc_item +#ifndef md_alloc_item // Allocate memory for an item. -#define alloc_item(allocator, Type) (Type*)memory_zero(alloc(allocator, size_of(Type)), size_of(Type)) +#define md_alloc_item(allocator, Type) (Type*)md_memory_zero(md_alloc(allocator, size_of(Type)), size_of(Type)) // Allocate memory for an item. -#define alloc_item_no_zero( allocator, Type ) (Type*) alloc(allocator, size_of(Type)) +#define md_alloc_item_no_zero( allocator, Type ) (Type*) md_alloc(allocator, size_of(Type)) #endif -#ifndef alloc_array +#ifndef md_alloc_array // Allocate memory for an array of items. -#define alloc_array( allocator_, Type, count ) (Type*)memory_zero(alloc( allocator_, size_of(Type) * (count) ), size_of(Type) * (count)) +#define md_alloc_array( allocator_, Type, count ) (Type*)md_memory_zero(md_alloc( allocator_, size_of(Type) * (count) ), size_of(Type) * (count)) // Allocate memory for an array of items. (Don't zero initialize) -#define alloc_array_no_zero( allocator_, Type, count ) (Type*) alloc( allocator_, size_of(Type) * (count) ) +#define md_alloc_array_no_zero( allocator_, Type, count ) (Type*) md_alloc( allocator_, size_of(Type) * (count) ) #endif // Allocate/Resize memory using default options. -// Use this if you don't need a "fancy" resize allocation -void* default_resize_align( AllocatorInfo a, void* ptr, SSIZE old_size, SSIZE new_size, SSIZE alignment ); +// Use this if you don't need a "fancy" md_resize allocation +void* md_default_resize_align( MD_AllocatorInfo a, void* ptr, MD_SSIZE old_size, MD_SSIZE new_size, MD_SSIZE alignment ); #ifdef MD_HEAP_ANALYSIS -/* heap memory analysis tools */ +/* md_heap memory analysis tools */ /* define GEN_HEAP_ANALYSIS to enable this feature */ /* call zpl_heap_stats_init at the beginning of the entry point */ /* you can call zpl_heap_stats_check near the end of the execution to validate any possible leaks */ -MD_API void heap_stats_init( void ); -MD_API SSIZE heap_stats_used_memory( void ); -MD_API SSIZE heap_stats_alloc_count( void ); -MD_API void heap_stats_check( void ); +MD_API void md_heap_stats_init( void ); +MD_API MD_SSIZE heap_stats_used_memory( void ); +MD_API MD_SSIZE md_heap_stats_alloc_count( void ); +MD_API void md_heap_stats_check( void ); #endif -MD_API void* heap_allocator_proc( void* allocator_data, AllocatorMode mode, SSIZE size, SSIZE alignment, void* old_memory, SSIZE old_size, U64 flags ); +MD_API void* md_heap_allocator_proc( void* allocator_data, MD_AllocatorMode mode, MD_SSIZE size, MD_SSIZE alignment, void* old_memory, MD_SSIZE old_size, MD_U64 flags ); -#ifndef heap -// The heap allocator backed by the platform vendor's malloc & free. -#define heap() (AllocatorInfo){ heap_allocator_proc, nullptr } +#ifndef md_heap +// The md_heap allocator backed by the platform vendor's md_malloc & free. +#define md_heap() (MD_AllocatorInfo){ md_heap_allocator_proc, md_nullptr } #endif #ifndef md_malloc -// Helper to allocate memory using heap allocator. -#define md_malloc( sz ) alloc( heap(), sz ) +// Helper to allocate memory using md_heap allocator. +#define md_malloc( sz ) md_alloc( md_heap(), sz ) #endif #ifndef md_free -// Helper to free memory allocated by heap allocator. -#define md_free( ptr ) alloc_free( heap(), ptr ) +// Helper to free memory allocated by md_heap allocator. +#define md_free( ptr ) md_alloc_free( md_heap(), ptr ) #endif -/* Virtual Memory Arena +/* Virtual Memory MD_Arena This is separate from the composite arena used by HMH/Casey Muratori/RJF This arena stricly manages one reservation of the process's virtual address space. - Segregating this from composite Arena style causes more moremoy to be used for "allocator headers", however it allows + Segregating this from composite MD_Arena style causes more moremoy to be used for "allocator headers", however it allows users of a library to have greater control over the allocation strategy used from their side instead of the library itself. - Like with the composite Arena, the VArena has its struct as the header of the reserve of memory. + Like with the composite MD_Arena, the MD_VArena has its struct as the header of the reserve of memory. */ -#ifndef VARENA_DEFUALT_RESERVE -#define VARENA_DEFAULT_RESERVE MB(64) +#ifndef MD_VARENA_DEFUALT_RESERVE +#define MD_VARENA_DEFAULT_RESERVE MD_MB(64) #endif -#ifndef VARENA_DEFUALT_COMMIT -#define VARENA_DEFAULT_COMMIT KB(64) +#ifndef MD_VARENA_DEFUALT_COMMIT +#define MD_VARENA_DEFAULT_COMMIT MD_KB(64) #endif -typedef U32 VArenaFlags; +typedef MD_U32 MD_VArenaFlags; enum { - VArenaFlag_LargePages = (1 << 0), + MD_VArenaFlag_LargePages = (1 << 0), }; -typedef struct VArenaParams VArenaParams; -struct VArenaParams +typedef struct MD_VArenaParams MD_VArenaParams; +struct MD_VArenaParams { - U64 base_addr; - VArenaFlags flags; - U64 reserve_size; - U64 commit_size; + MD_U64 base_addr; + MD_VArenaFlags flags; + MD_U64 reserve_size; + MD_U64 commit_size; }; -typedef struct VArena VArena; -struct VArena +typedef struct MD_VArena MD_VArena; +struct MD_VArena { - SSIZE reserve_start; - SSIZE reserve; - SSIZE commit_size; - SSIZE committed; - SSIZE commit_used; - VArenaFlags flags; + MD_SSIZE reserve_start; + MD_SSIZE reserve; + MD_SSIZE commit_size; + MD_SSIZE committed; + MD_SSIZE commit_used; + MD_VArenaFlags flags; }; -MD_API VArena* varena__alloc(VArenaParams params PARAM_DEFAULT); -#define varena_alloc(...) varena__alloc( (VArenaParams){__VA_ARGS__} ) +MD_API MD_VArena* md_varena__alloc(MD_VArenaParams params MD_PARAM_DEFAULT); +#define md_varena_alloc(...) md_varena__alloc( (MD_VArenaParams){__VA_ARGS__} ) -MD_API void varena_commit (VArena* vm, SSIZE commit_size); -MD_API void varena_release(VArena* vm); +MD_API void md_varena_commit (MD_VArena* vm, MD_SSIZE commit_size); +MD_API void md_varena_release(MD_VArena* vm); -force_inline void varena_rewind(VArena* vm, SSIZE pos) { vm->commit_used = pos; } +md_force_inline void varena_rewind(MD_VArena* vm, MD_SSIZE pos) { vm->commit_used = pos; } -MD_API void* varena_allocator_proc(void* allocator_data, AllocatorMode mode, SSIZE size, SSIZE alignment, void* old_memory, SSIZE old_size, U64 flags); +MD_API void* md_varena_allocator_proc(void* allocator_data, MD_AllocatorMode mode, MD_SSIZE size, MD_SSIZE alignment, void* old_memory, MD_SSIZE old_size, MD_U64 flags); -#define varena_allocator(vm) (AllocatorInfo) { varena_allocator_proc, vm } +#define md_varena_allocator(vm) (MD_AllocatorInfo) { md_varena_allocator_proc, vm } -typedef struct ByteSlice ByteSlice; -struct ByteSlice +typedef struct MD_ByteSlice MD_ByteSlice; +struct MD_ByteSlice { - U8* data; - SSIZE len; + MD_U8* data; + MD_SSIZE len; }; -#define mem_to_byteslice(data, len) (ByteSlice){ (U8*)(data), (SSIZE)(len) } +#define md_mem_to_byteslice(data, len) (MD_ByteSlice){ (MD_U8*)(data), (MD_SSIZE)(len) } // Fixed size arena -typedef struct FArena FArena; -struct FArena +typedef struct MD_FArena MD_FArena; +struct MD_FArena { - ByteSlice slice; - SSIZE used; + MD_ByteSlice slice; + MD_SSIZE used; }; -#define farena_from_byteslice(slice) (FArena) { slice, 0 } -#define farena_from_memory(data, len) (FArena) { mem_to_byteslice(data, len), 0 } +#define md_farena_from_byteslice(slice) (MD_FArena) { slice, 0 } +#define md_farena_from_memory(data, len) (MD_FArena) { md_mem_to_byteslice(data, len), 0 } -MD_API void* farena_allocator_proc(void* allocator_data, AllocatorMode mode, SSIZE size, SSIZE alignment, void* old_memory, SSIZE old_size, U64 flags); +MD_API void* farena_allocator_proc(void* allocator_data, MD_AllocatorMode mode, MD_SSIZE size, MD_SSIZE alignment, void* old_memory, MD_SSIZE old_size, MD_U64 flags); -#define farena_allocator(arena) (AllocatorInfo){ farena_allocator_proc, & arena } +#define farena_allocator(arena) (MD_AllocatorInfo){ farena_allocator_proc, & arena } // Inlines -inline AllocatorType -allocator_type(AllocatorInfo a) { - if (a.proc == nullptr) { - a = default_allocator(); +inline MD_AllocatorType +md_allocator_type(MD_AllocatorInfo a) { + if (a.proc == md_nullptr) { + a = md_default_allocator(); } - return (AllocatorType) a.proc(a.data, AllocatorMode_QueryType, 0, 0, nullptr, 0, MD_DEFAULT_ALLOCATOR_FLAGS); + return (MD_AllocatorType) a.proc(a.data, MD_AllocatorMode_QueryType, 0, 0, md_nullptr, 0, MD_DEFAULT_ALLOCATOR_FLAGS); } -inline AllocatorQueryFlags -allocator_query_support(AllocatorInfo a) { - if (a.proc == nullptr) { - a = default_allocator(); +inline MD_AllocatorQueryFlags +md_allocator_query_support(MD_AllocatorInfo a) { + if (a.proc == md_nullptr) { + a = md_default_allocator(); } - return (AllocatorType) a.proc(a.data, AllocatorMode_QuerySupport, 0, 0, nullptr, 0, MD_DEFAULT_ALLOCATOR_FLAGS); + return (MD_AllocatorType) a.proc(a.data, MD_AllocatorMode_QuerySupport, 0, 0, md_nullptr, 0, MD_DEFAULT_ALLOCATOR_FLAGS); } inline void* -alloc_align( AllocatorInfo a, SSIZE size, SSIZE alignment ) { - if (a.proc == nullptr) { - a = default_allocator(); +md_alloc_align( MD_AllocatorInfo a, MD_SSIZE size, MD_SSIZE alignment ) { + if (a.proc == md_nullptr) { + a = md_default_allocator(); } - return a.proc( a.data, AllocatorMode_Alloc, size, alignment, nullptr, 0, MD_DEFAULT_ALLOCATOR_FLAGS ); + return a.proc( a.data, MD_AllocatorMode_Alloc, size, alignment, md_nullptr, 0, MD_DEFAULT_ALLOCATOR_FLAGS ); } inline void* -alloc( AllocatorInfo a, SSIZE size ) { - if (a.proc == nullptr) { - a = default_allocator(); +md_alloc( MD_AllocatorInfo a, MD_SSIZE size ) { + if (a.proc == md_nullptr) { + a = md_default_allocator(); } - return alloc_align( a, size, MD_DEFAULT_MEMORY_ALIGNMENT ); + return md_alloc_align( a, size, MD_DEFAULT_MEMORY_ALIGNMENT ); } inline void -alloc_free( AllocatorInfo a, void* ptr ) { - if (a.proc == nullptr) { - a = default_allocator(); +md_alloc_free( MD_AllocatorInfo a, void* ptr ) { + if (a.proc == md_nullptr) { + a = md_default_allocator(); } - if ( ptr != nullptr ) { - a.proc( a.data, AllocatorMode_Free, 0, 0, ptr, 0, MD_DEFAULT_ALLOCATOR_FLAGS ); + if ( ptr != md_nullptr ) { + a.proc( a.data, MD_AllocatorMode_Free, 0, 0, ptr, 0, MD_DEFAULT_ALLOCATOR_FLAGS ); } } inline void -free_all( AllocatorInfo a ) { - if (a.proc == nullptr) { - a = default_allocator(); +md_free_all( MD_AllocatorInfo a ) { + if (a.proc == md_nullptr) { + a = md_default_allocator(); } - a.proc( a.data, AllocatorMode_FreeAll, 0, 0, nullptr, 0, MD_DEFAULT_ALLOCATOR_FLAGS ); + a.proc( a.data, MD_AllocatorMode_FreeAll, 0, 0, md_nullptr, 0, MD_DEFAULT_ALLOCATOR_FLAGS ); } inline void* -resize( AllocatorInfo a, void* ptr, SSIZE old_size, SSIZE new_size ) { - if (a.proc == nullptr) { - a = default_allocator(); +md_resize( MD_AllocatorInfo a, void* ptr, MD_SSIZE old_size, MD_SSIZE new_size ) { + if (a.proc == md_nullptr) { + a = md_default_allocator(); } - return resize_align( a, ptr, old_size, new_size, MD_DEFAULT_ALLOCATOR_FLAGS ); + return md_resize_align( a, ptr, old_size, new_size, MD_DEFAULT_ALLOCATOR_FLAGS ); } inline void* -resize_align( AllocatorInfo a, void* ptr, SSIZE old_size, SSIZE new_size, SSIZE alignment ) { - if (a.proc == nullptr) { - a = default_allocator(); +md_resize_align( MD_AllocatorInfo a, void* ptr, MD_SSIZE old_size, MD_SSIZE new_size, MD_SSIZE alignment ) { + if (a.proc == md_nullptr) { + a = md_default_allocator(); } - return a.proc( a.data, AllocatorMode_Resize, new_size, alignment, ptr, old_size, MD_DEFAULT_ALLOCATOR_FLAGS ); + return a.proc( a.data, MD_AllocatorMode_Resize, new_size, alignment, ptr, old_size, MD_DEFAULT_ALLOCATOR_FLAGS ); } diff --git a/source/base/platform.h b/source/base/platform.h index b854883..50c6c23 100644 --- a/source/base/platform.h +++ b/source/base/platform.h @@ -6,13 +6,13 @@ #include #include -#if defined( OS_WINDOWS ) +#if defined( MD_OS_WINDOWS ) # include # include # include #endif -#if LANG_C +#if MD_LANG_C # include # include #endif diff --git a/source/base/profiling.h b/source/base/profiling.h index f0b75a2..5f866d5 100644 --- a/source/base/profiling.h +++ b/source/base/profiling.h @@ -9,20 +9,20 @@ //////////////////////////////// //~ rjf: Zero Settings -#if !defined(PROFILE_TELEMETRY) -# define PROFILE_TELEMETRY 0 +#if !defined(MD_PROFILE_TELEMETRY) +# define MD_PROFILE_TELEMETRY 0 #endif -#if !defined(MARKUP_LAYER_COLOR) -# define MARKUP_LAYER_COLOR 1.00f, 0.00f, 1.00f +#if !defined(MD_MARKUP_LAYER_COLOR) +# define MD_MARKUP_LAYER_COLOR 1.00f, 0.00f, 1.00f #endif //////////////////////////////// //~ rjf: Third Party Includes -#if PROFILE_TELEMETRY +#if MD_PROFILE_TELEMETRY # include "rad_tm.h" -# if OS_WINDOWS +# if MD_OS_WINDOWS # pragma comment(lib, "rad_tm_win64.lib") # endif #endif @@ -30,21 +30,21 @@ //////////////////////////////// //~ rjf: Telemetry Profile Defines -#if PROFILE_TELEMETRY -# define prof_begin(...) tmEnter(0, 0, __VA_ARGS__) -# define prof_begin_dynamic(...) (TM_API_PTR ? TM_API_PTR->_tmEnterZoneV_Core(0, 0, __FILE__, &g_telemetry_filename_id, __LINE__, __VA_ARGS__) : (void)0) -# define prof_end(...) (TM_API_PTR ? TM_API_PTR->_tmLeaveZone(0) : (void)0) -# define prof_tick(...) tmTick(0) -# define prof_is_capturing(...) tmRunning() -# define prof_begin_capture(...) tmOpen(0, __VA_ARGS__, __DATE__, "localhost", TMCT_TCP, TELEMETRY_DEFAULT_PORT, TMOF_INIT_NETWORKING|TMOF_CAPTURE_CONTEXT_SWITCHES, 100) -# define prof_end_capture(...) tmClose(0) -# define prof_thread_name(...) (TM_API_PTR ? TM_API_PTR->_tmThreadName(0, 0, __VA_ARGS__) : (void)0) -# define prof_msg(...) (TM_API_PTR ? TM_API_PTR->_tmMessageV_Core(0, TMMF_ICON_NOTE, __FILE__, &g_telemetry_filename_id, __LINE__, __VA_ARGS__) : (void)0) -# define prof_begin_lock_wait(...) tmStartWaitForLock(0, 0, __VA_ARGS__) -# define prof_end_lock_wait(...) tmEndWaitForLock(0) -# define prof_lock_take(...) tmAcquiredLock(0, 0, __VA_ARGS__) -# define prof_lock_drop(...) tmReleasedLock(0, __VA_ARGS__) -# define prof_color(color) tmZoneColorSticky(color) +#if MD_PROFILE_TELEMETRY +# define md_prof_begin(...) tmEnter(0, 0, __VA_ARGS__) +# define md_prof_begin_dynamic(...) (TM_API_PTR ? TM_API_PTR->_tmEnterZoneV_Core(0, 0, __FILE__, &g_telemetry_filename_id, __LINE__, __VA_ARGS__) : (void)0) +# define md_prof_end(...) (TM_API_PTR ? TM_API_PTR->_tmLeaveZone(0) : (void)0) +# define md_prof_tick(...) tmTick(0) +# define md_prof_is_capturing(...) tmRunning() +# define md_prof_begin_capture(...) tmOpen(0, __VA_ARGS__, __DATE__, "localhost", TMCT_TCP, TELEMETRY_DEFAULT_PORT, TMOF_INIT_NETWORKING|TMOF_CAPTURE_CONTEXT_SWITCHES, 100) +# define md_prof_end_capture(...) tmClose(0) +# define md_prof_thread_name(...) (TM_API_PTR ? TM_API_PTR->_tmThreadName(0, 0, __VA_ARGS__) : (void)0) +# define md_prof_msg(...) (TM_API_PTR ? TM_API_PTR->_tmMessageV_Core(0, TMMF_ICON_NOTE, __FILE__, &g_telemetry_filename_id, __LINE__, __VA_ARGS__) : (void)0) +# define md_prof_begin_lock_wait(...) tmStartWaitForLock(0, 0, __VA_ARGS__) +# define md_prof_end_lock_wait(...) tmEndWaitForLock(0) +# define md_prof_lock_take(...) tmAcquiredLock(0, 0, __VA_ARGS__) +# define md_prof_lock_drop(...) tmReleasedLock(0, __VA_ARGS__) +# define md_prof_color(color) tmZoneColorSticky(color) #endif // TODO(Ed): Support spall? @@ -53,25 +53,25 @@ //////////////////////////////// //~ rjf: Zeroify Undefined Defines -#if !defined(prof_begin) -# define prof_begin(...) (0) -# define prof_begin_dynamic(...) (0) -# define prof_end(...) (0) -# define prof_tick(...) (0) -# define prof_is_capturing(...) (0) -# define prof_begin_capture(...) (0) -# define prof_end_capture(...) (0) -# define prof_thread_name(...) (0) -# define prof_msg(...) (0) -# define prof_end_lock_wait(...) (0) -# define prof_end_lock_wait(...) (0) -# define prof_lock_take(...) (0) -# define prof_lock_drop(...) (0) -# define prof_color(...) (0) +#if !defined(md_prof_begin) +# define md_prof_begin(...) (0) +# define md_prof_begin_dynamic(...) (0) +# define md_prof_end(...) (0) +# define md_prof_tick(...) (0) +# define md_prof_is_capturing(...) (0) +# define md_prof_begin_capture(...) (0) +# define md_prof_end_capture(...) (0) +# define md_prof_thread_name(...) (0) +# define md_prof_msg(...) (0) +# define md_prof_end_lock_wait(...) (0) +# define md_prof_end_lock_wait(...) (0) +# define md_prof_lock_take(...) (0) +# define md_prof_lock_drop(...) (0) +# define md_prof_color(...) (0) #endif //////////////////////////////// //~ rjf: Helper Wrappers -#define prof_begin_function(...) prof_begin(this_function_name) -#define prof_scope(...) defer_loop(prof_begin_dynamic(__VA_ARGS__), ProfEnd()) +#define md_prof_begin_function(...) md_prof_begin(md_this_function_name) +#define md_prof_scope(...) md_defer_loop(md_prof_begin_dynamic(__VA_ARGS__), ProfEnd()) diff --git a/source/base/ring.h b/source/base/ring.h index d38aae8..0793955 100644 --- a/source/base/ring.h +++ b/source/base/ring.h @@ -6,41 +6,41 @@ //////////////////////////////// //~ rjf: Non-Fancy Ring Buffer Reads/Writes -U64 ring_write(U8* ring_base, U64 ring_size, U64 ring_pos, void* src_data, U64 src_data_size); -U64 ring_read (U8* ring_base, U64 ring_size, U64 ring_pos, void* dst_data, U64 read_size); +MD_U64 md_ring_write(MD_U8* md_ring_base, MD_U64 md_ring_size, MD_U64 md_ring_pos, void* src_data, MD_U64 src_data_size); +MD_U64 md_ring_read (MD_U8* md_ring_base, MD_U64 md_ring_size, MD_U64 md_ring_pos, void* dst_data, MD_U64 read_size); -#define ring_write_struct(ring_base, ring_size, ring_pos, ptr) ring_write((ring_base), (ring_size), (ring_pos), (ptr), sizeof(*(ptr))) -#define ring_read_struct(ring_base, ring_size, ring_pos, ptr) ring_read ((ring_base), (ring_size), (ring_pos), (ptr), sizeof(*(ptr))) +#define md_ring_write_struct(md_ring_base, md_ring_size, md_ring_pos, ptr) md_ring_write((md_ring_base), (md_ring_size), (md_ring_pos), (ptr), sizeof(*(ptr))) +#define md_ring_read_struct(md_ring_base, md_ring_size, md_ring_pos, ptr) md_ring_read ((md_ring_base), (md_ring_size), (md_ring_pos), (ptr), sizeof(*(ptr))) //////////////////////////////// //~ rjf: Non-Fancy Ring Buffer Reads/Writes -inline U64 -ring_write(U8* ring_base, U64 ring_size, U64 ring_pos, void* src_data, U64 src_data_size) { - assert(src_data_size <= ring_size); +inline MD_U64 +md_ring_write(MD_U8* md_ring_base, MD_U64 md_ring_size, MD_U64 md_ring_pos, void* src_data, MD_U64 src_data_size) { + md_assert(src_data_size <= md_ring_size); { - U64 ring_off = ring_pos % ring_size; - U64 bytes_before_split = ring_size - ring_off; - U64 pre_split_bytes = min(bytes_before_split, src_data_size); - U64 pst_split_bytes = src_data_size - pre_split_bytes; + MD_U64 md_ring_off = md_ring_pos % md_ring_size; + MD_U64 bytes_before_split = md_ring_size - md_ring_off; + MD_U64 pre_split_bytes = md_min(bytes_before_split, src_data_size); + MD_U64 pst_split_bytes = src_data_size - pre_split_bytes; void* pre_split_data = src_data; - void* pst_split_data = ((U8*)src_data + pre_split_bytes); - memory_copy(ring_base + ring_off, pre_split_data, pre_split_bytes); - memory_copy(ring_base + 0, pst_split_data, pst_split_bytes); + void* pst_split_data = ((MD_U8*)src_data + pre_split_bytes); + md_memory_copy(md_ring_base + md_ring_off, pre_split_data, pre_split_bytes); + md_memory_copy(md_ring_base + 0, pst_split_data, pst_split_bytes); } return src_data_size; } -inline U64 -ring_read(U8* ring_base, U64 ring_size, U64 ring_pos, void* dst_data, U64 read_size) { - assert(read_size <= ring_size); +inline MD_U64 +md_ring_read(MD_U8* md_ring_base, MD_U64 md_ring_size, MD_U64 md_ring_pos, void* dst_data, MD_U64 read_size) { + md_assert(read_size <= md_ring_size); { - U64 ring_off = ring_pos % ring_size; - U64 bytes_before_split = ring_size-ring_off; - U64 pre_split_bytes = min(bytes_before_split, read_size); - U64 pst_split_bytes = read_size - pre_split_bytes; - memory_copy(dst_data, ring_base+ring_off, pre_split_bytes); - memory_copy((U8*)dst_data + pre_split_bytes, ring_base + 0, pst_split_bytes); + MD_U64 md_ring_off = md_ring_pos % md_ring_size; + MD_U64 bytes_before_split = md_ring_size-md_ring_off; + MD_U64 pre_split_bytes = md_min(bytes_before_split, read_size); + MD_U64 pst_split_bytes = read_size - pre_split_bytes; + md_memory_copy(dst_data, md_ring_base+md_ring_off, pre_split_bytes); + md_memory_copy((MD_U8*)dst_data + pre_split_bytes, md_ring_base + 0, pst_split_bytes); } return read_size; } diff --git a/source/base/sort.h b/source/base/sort.h index 2e8a9bd..15e3677 100644 --- a/source/base/sort.h +++ b/source/base/sort.h @@ -5,6 +5,6 @@ //////////////////////////////// //~ rjf: Sorts -#ifndef quick_sort -#define quick_sort(ptr, count, element_size, cmp_function) qsort((ptr), (count), (element_size), (int (*)(const void *, const void *))(cmp_function)) +#ifndef md_quick_sort +#define md_quick_sort(ptr, count, element_size, cmp_function) qsort((ptr), (count), (element_size), (int (*)(const void *, const void *))(cmp_function)) #endif diff --git a/source/base/space.h b/source/base/space.h index 88370a2..9a07ff3 100644 --- a/source/base/space.h +++ b/source/base/space.h @@ -6,62 +6,62 @@ //////////////////////////////// //~ rjf: Basic Types & Spaces -typedef enum Dimension Dimension; -enum Dimension +typedef enum MD_Dimension MD_Dimension; +enum MD_Dimension { - Dimension_X, - Dimension_Y, - Dimension_Z, - Dimension_W, + MD_Dimension_X, + MD_Dimension_Y, + MD_Dimension_Z, + MD_Dimension_W, }; -typedef enum Side Side; -enum Side +typedef enum MD_Side MD_Side; +enum MD_Side { - Side_Invalid = -1, - Side_Min, - Side_Max, - Side_COUNT, + MD_Side_Invalid = -1, + MD_Side_Min, + MD_Side_Max, + MD_Side_COUNT, }; -#define side_flip(s) ((Side)(!(s))) +#define side_flip(s) ((MD_Side)(!(s))) -typedef enum Axis2 Axis2; -enum Axis2 +typedef enum MD_Axis2 MD_Axis2; +enum MD_Axis2 { - Axis2_Invalid = -1, - Axis2_X, - Axis2_Y, - Axis2_COUNT, + MD_Axis2_Invalid = -1, + MD_Axis2_X, + MD_Axis2_Y, + MD_Axis2_COUNT, }; -#define axis2_flip(a) ((Axis2)(!(a))) +#define axis2_flip(a) ((MD_Axis2)(!(a))) -typedef enum Corner Corner; -enum Corner +typedef enum MD_corner MD_corner; +enum MD_corner { - Corner_Invalid = -1, - Corner_00, - Corner_01, - Corner_10, - Corner_11, - Corner_COUNT + MD_Corner_Invalid = -1, + MD_Corner_00, + MD_Corner_01, + MD_Corner_10, + MD_Corner_11, + MD_Corner_COUNT }; -typedef enum Dir2 Dir2; -enum Dir2 +typedef enum MD_Dir2 MD_Dir2; +enum MD_Dir2 { - Dir2_Invalid = -1, - Dir2_Left, - Dir2_Up, - Dir2_Right, - Dir2_Down, - Dir2_COUNT + MD_Dir2_Invalid = -1, + MD_Dir2_Left, + MD_Dir2_Up, + MD_Dir2_Right, + MD_Dir2_Down, + MD_Dir2_COUNT }; -#define axis2_from_dir2(d) (((d) & 1) ? Axis2_Y : Axis2_X) -#define side_from_dir2(d) (((d) < Dir2_Right) ? Side_Min : Side_Max) +#define md_axis2_from_dir2(d) (((d) & 1) ? MD_Axis2_Y : MD_Axis2_X) +#define md_side_from_dir2(d) (((d) < MD_Dir2_Right) ? MD_Side_Min : MD_Side_Max) //////////////////////////////// //~ rjf: Enum -> Sign -inline S32 sign_from_side_S32(Side side) { return((side == Side_Min) ? -1 : 1 ); } -inline F32 sign_from_side_F32(Side side) { return((side == Side_Min) ? -1.f : 1.f); } +inline MD_S32 md_sign_from_side_S32(MD_Side side) { return((side == MD_Side_Min) ? -1 : 1 ); } +inline MD_F32 md_sign_from_side_F32(MD_Side side) { return((side == MD_Side_Min) ? -1.f : 1.f); } diff --git a/source/base/strings.c b/source/base/strings.c index fd756a0..4fb8fde 100644 --- a/source/base/strings.c +++ b/source/base/strings.c @@ -15,27 +15,27 @@ //////////////////////////////// //~ rjf: String Matching -B32 -str8_match(String8 a, String8 b, StringMatchFlags flags) +MD_B32 +md_str8_match(MD_String8 a, MD_String8 b, MD_StringMatchFlags flags) { - B32 result = 0; - if (a.size == b.size || (flags & StringMatchFlag_RightSideSloppy)) + MD_B32 result = 0; + if (a.size == b.size || (flags & MD_StringMatchFlag_RightSideSloppy)) { - B32 case_insensitive = (flags & StringMatchFlag_CaseInsensitive); - B32 slash_insensitive = (flags & StringMatchFlag_SlashInsensitive); - U64 size = min(a.size, b.size); + MD_B32 case_insensitive = (flags & MD_StringMatchFlag_CaseInsensitive); + MD_B32 slash_insensitive = (flags & MD_StringMatchFlag_SlashInsensitive); + MD_U64 size = md_min(a.size, b.size); result = 1; - for (U64 i = 0; i < size; i += 1) + for (MD_U64 i = 0; i < size; i += 1) { - U8 at = a.str[i]; - U8 bt = b.str[i]; + MD_U8 at = a.str[i]; + MD_U8 bt = b.str[i]; if (case_insensitive) { - at = char_to_upper(at); - bt = char_to_upper(bt); + at = md_char_to_upper(at); + bt = md_char_to_upper(bt); } if (slash_insensitive) { - at = char_to_correct_slash(at); - bt = char_to_correct_slash(bt); + at = md_char_to_correct_slash(at); + bt = md_char_to_correct_slash(bt); } if (at != bt) { result = 0; @@ -46,49 +46,49 @@ str8_match(String8 a, String8 b, StringMatchFlags flags) return(result); } -U64 -str8_find_needle(String8 string, U64 start_pos, String8 needle, StringMatchFlags flags) +MD_U64 +md_str8_find_needle(MD_String8 string, MD_U64 start_pos, MD_String8 needle, MD_StringMatchFlags flags) { - U8* p = string.str + start_pos; - U64 stop_offset = max(string.size + 1, needle.size) - needle.size; - U8* stop_p = string.str + stop_offset; + MD_U8* p = string.str + start_pos; + MD_U64 stop_offset = md_max(string.size + 1, needle.size) - needle.size; + MD_U8* stop_p = string.str + stop_offset; if (needle.size > 0) { - U8* string_opl = string.str + string.size; - String8 needle_tail = str8_skip(needle, 1); - StringMatchFlags adjusted_flags = flags | StringMatchFlag_RightSideSloppy; - U8 needle_first_char_adjusted = needle.str[0]; - if (adjusted_flags & StringMatchFlag_CaseInsensitive) { - needle_first_char_adjusted = char_to_upper(needle_first_char_adjusted); + MD_U8* md_string_opl = string.str + string.size; + MD_String8 needle_tail = md_str8_skip(needle, 1); + MD_StringMatchFlags adjusted_flags = flags | MD_StringMatchFlag_RightSideSloppy; + MD_U8 needle_first_char_adjusted = needle.str[0]; + if (adjusted_flags & MD_StringMatchFlag_CaseInsensitive) { + needle_first_char_adjusted = md_char_to_upper(needle_first_char_adjusted); } for (;p < stop_p; p += 1) { - U8 haystack_char_adjusted = *p; - if(adjusted_flags & StringMatchFlag_CaseInsensitive) { - haystack_char_adjusted = char_to_upper(haystack_char_adjusted); + MD_U8 haystack_char_adjusted = *p; + if(adjusted_flags & MD_StringMatchFlag_CaseInsensitive) { + haystack_char_adjusted = md_char_to_upper(haystack_char_adjusted); } if (haystack_char_adjusted == needle_first_char_adjusted) { - if (str8_match(str8_range(p + 1, string_opl), needle_tail, adjusted_flags)){ + if (md_str8_match(md_str8_range(p + 1, md_string_opl), needle_tail, adjusted_flags)){ break; } } } } - U64 result = string.size; + MD_U64 result = string.size; if (p < stop_p){ - result = (U64)(p - string.str); + result = (MD_U64)(p - string.str); } return(result); } -U64 -str8_find_needle_reverse(String8 string, U64 start_pos, String8 needle, StringMatchFlags flags) { - U64 result = 0; - for (S64 i = string.size - start_pos - needle.size; i >= 0; --i) +MD_U64 +md_str8_find_needle_reverse(MD_String8 string, MD_U64 start_pos, MD_String8 needle, MD_StringMatchFlags flags) { + MD_U64 result = 0; + for (MD_S64 i = string.size - start_pos - needle.size; i >= 0; --i) { - String8 haystack = str8_substr(string, rng_1u64(i, i + needle.size)); - if (str8_match(haystack, needle, flags)) { - result = (U64)i + needle.size; + MD_String8 haystack = md_str8_substr(string, md_rng_1u64(i, i + needle.size)); + if (md_str8_match(haystack, needle, flags)) { + result = (MD_U64)i + needle.size; break; } } @@ -98,55 +98,55 @@ str8_find_needle_reverse(String8 string, U64 start_pos, String8 needle, StringMa //////////////////////////////// //~ rjf: String Slicing -String8 -str8_skip_chop_whitespace(String8 string) +MD_String8 +md_str8_skip_chop_whitespace(MD_String8 string) { - U8* first = string.str; - U8* opl = first + string.size; + MD_U8* first = string.str; + MD_U8* opl = first + string.size; for (; first < opl; first += 1) { - if ( ! char_is_space(*first)) { break;} + if ( ! md_char_is_space(*first)) { break;} } for (; opl > first; ){ opl -= 1; - if ( ! char_is_space(*opl)) { opl += 1; break; } + if ( ! md_char_is_space(*opl)) { opl += 1; break; } } - String8 result = str8_range(first, opl); + MD_String8 result = md_str8_range(first, opl); return(result); } //////////////////////////////// //~ rjf: String Formatting & Copying -String8 -str8_cat__ainfo(AllocatorInfo ainfo, String8 s1, String8 s2) +MD_String8 +md_str8_cat__ainfo(MD_AllocatorInfo ainfo, MD_String8 s1, MD_String8 s2) { - String8 str; + MD_String8 str; str.size = s1.size + s2.size; - str.str = alloc_array_no_zero(ainfo, U8, str.size + 1); - memory_copy(str.str, s1.str, s1.size); - memory_copy(str.str + s1.size, s2.str, s2.size); + str.str = md_alloc_array_no_zero(ainfo, MD_U8, str.size + 1); + md_memory_copy(str.str, s1.str, s1.size); + md_memory_copy(str.str + s1.size, s2.str, s2.size); str.str[str.size] = 0; return str; } -String8 -str8_copy__ainfo(AllocatorInfo ainfo, String8 s) +MD_String8 +md_str8_copy__ainfo(MD_AllocatorInfo ainfo, MD_String8 s) { - String8 str; + MD_String8 str; str.size = s.size; - str.str = alloc_array_no_zero(ainfo, U8, str.size + 1); - memory_copy(str.str, s.str, s.size); + str.str = md_alloc_array_no_zero(ainfo, MD_U8, str.size + 1); + md_memory_copy(str.str, s.str, s.size); str.str[str.size] = 0; return(str); } -String8 -str8fv__ainfo(AllocatorInfo ainfo, char* fmt, va_list args){ +MD_String8 +md_str8fv__ainfo(MD_AllocatorInfo ainfo, char* fmt, va_list args){ va_list args2; va_copy(args2, args); - U32 needed_bytes = md_vsnprintf(0, 0, fmt, args) + 1; - String8 result = {0}; - result.str = alloc_array_no_zero(ainfo, U8, needed_bytes); + MD_U32 needed_bytes = md_vsnprintf(0, 0, fmt, args) + 1; + MD_String8 result = {0}; + result.str = md_alloc_array_no_zero(ainfo, MD_U8, needed_bytes); result.size = md_vsnprintf((char*)result.str, needed_bytes, fmt, args2); result.str[result.size] = 0; va_end(args2); @@ -158,12 +158,12 @@ str8fv__ainfo(AllocatorInfo ainfo, char* fmt, va_list args){ //- rjf: string -> integer -S64 -sign_from_str8(String8 string, String8* string_tail) +MD_S64 +md_sign_from_str8(MD_String8 string, MD_String8* md_string_tail) { // count negative signs - U64 neg_count = 0; - U64 i = 0; + MD_U64 neg_count = 0; + MD_U64 i = 0; for (; i < string.size; i += 1){ if (string.str[i] == '-') { neg_count += 1; @@ -173,20 +173,20 @@ sign_from_str8(String8 string, String8* string_tail) } } // output part of string after signs - *string_tail = str8_skip(string, i); + *md_string_tail = md_str8_skip(string, i); // output integer sign - S64 sign = (neg_count & 1)?-1:+1; + MD_S64 sign = (neg_count & 1)?-1:+1; return(sign); } -B32 -str8_is_integer(String8 string, U32 radix){ - B32 result = 0; +MD_B32 +md_str8_is_integer(MD_String8 string, MD_U32 radix){ + MD_B32 result = 0; if (string.size > 0 && (1 < radix && radix <= 16)) { result = 1; - for (U64 i = 0; i < string.size; i += 1) { - U8 c = string.str[i]; - if ( ! (c < 0x80) || integer_symbol_reverse(c) >= radix){ + for (MD_U64 i = 0; i < string.size; i += 1) { + MD_U8 c = string.str[i]; + if ( ! (c < 0x80) || md_integer_symbol_reverse(c) >= radix){ result = 0; break; } @@ -195,37 +195,37 @@ str8_is_integer(String8 string, U32 radix){ return(result); } -B32 -try_u64_from_str8_c_rules(String8 string, U64 *x) +MD_B32 +md_try_u64_from_str8_c_rules(MD_String8 string, MD_U64 *x) { - B32 is_integer = 0; - if (str8_is_integer(string, 10)) { + MD_B32 is_integer = 0; + if (md_str8_is_integer(string, 10)) { is_integer = 1; - *x = u64_from_str8(string, 10); + *x = md_u64_from_str8(string, 10); } else { - String8 hex_string = str8_skip(string, 2); - if (str8_match(str8_prefix(string, 2), str8_lit("0x"), 0) && - str8_is_integer(hex_string, 0x10)) + MD_String8 hex_string = md_str8_skip(string, 2); + if (md_str8_match(md_str8_prefix(string, 2), md_str8_lit("0x"), 0) && + md_str8_is_integer(hex_string, 0x10)) { is_integer = 1; - *x = u64_from_str8(hex_string, 0x10); + *x = md_u64_from_str8(hex_string, 0x10); } - else if (str8_match(str8_prefix(string, 2), str8_lit("0b"), 0) && - str8_is_integer(hex_string, 2)) + else if (md_str8_match(md_str8_prefix(string, 2), md_str8_lit("0b"), 0) && + md_str8_is_integer(hex_string, 2)) { is_integer = 1; - *x = u64_from_str8(hex_string, 2); + *x = md_u64_from_str8(hex_string, 2); } else { - String8 oct_string = str8_skip(string, 1); - if (str8_match(str8_prefix(string, 1), str8_lit("0"), 0) && - str8_is_integer(hex_string, 010)) + MD_String8 oct_string = md_str8_skip(string, 1); + if (md_str8_match(md_str8_prefix(string, 1), md_str8_lit("0"), 0) && + md_str8_is_integer(hex_string, 010)) { is_integer = 1; - *x = u64_from_str8(oct_string, 010); + *x = md_u64_from_str8(oct_string, 010); } } } @@ -234,40 +234,40 @@ try_u64_from_str8_c_rules(String8 string, U64 *x) //- rjf: integer -> string -String8 -str8_from_memory_size__ainfo(AllocatorInfo ainfo, SSIZE z) { - String8 result = {0}; - if (z < KB(1)) { - result = str8f(ainfo, "%llu b", z); +MD_String8 +md_str8_from_memory_size__ainfo(MD_AllocatorInfo ainfo, MD_SSIZE z) { + MD_String8 result = {0}; + if (z < MD_KB(1)) { + result = md_str8f(ainfo, "%llu b", z); } - else if (z < MB(1)) { - result = str8f(ainfo, "%llu.%02llu Kb", z / KB(1), ((100 * z) / KB(1)) % 100); + else if (z < MD_MB(1)) { + result = md_str8f(ainfo, "%llu.%02llu Kb", z / MD_KB(1), ((100 * z) / MD_KB(1)) % 100); } - else if (z < GB(1)) { - result = str8f(ainfo, "%llu.%02llu Mb", z / MB(1), ((100 * z) / MB(1)) % 100); + else if (z < MD_GB(1)) { + result = md_str8f(ainfo, "%llu.%02llu Mb", z / MD_MB(1), ((100 * z) / MD_MB(1)) % 100); } else{ - result = str8f(ainfo, "%llu.%02llu Gb", z / GB(1), ((100 * z) / GB(1)) % 100); + result = md_str8f(ainfo, "%llu.%02llu Gb", z / MD_GB(1), ((100 * z) / MD_GB(1)) % 100); } return(result); } -String8 -str8_from_u64__ainfo(AllocatorInfo ainfo, U64 u64, U32 radix, U8 min_digits, U8 digit_group_separator) +MD_String8 +md_str8_from_u64__ainfo(MD_AllocatorInfo ainfo, MD_U64 u64, MD_U32 radix, MD_U8 min_digits, MD_U8 digit_group_separator) { - String8 result = {0}; + MD_String8 result = {0}; { // rjf: prefix - String8 prefix = {0}; + MD_String8 prefix = {0}; switch(radix) { - case 16:{prefix = str8_lit("0x");}break; - case 8: {prefix = str8_lit("0o");}break; - case 2: {prefix = str8_lit("0b");}break; + case 16:{prefix = md_str8_lit("0x");}break; + case 8: {prefix = md_str8_lit("0o");}break; + case 2: {prefix = md_str8_lit("0b");}break; } // rjf: determine # of chars between separators - U8 digit_group_size = 3; + MD_U8 digit_group_size = 3; switch(radix) { default:break; @@ -278,11 +278,11 @@ str8_from_u64__ainfo(AllocatorInfo ainfo, U64 u64, U32 radix, U8 min_digits, U8 } // rjf: prep - U64 needed_leading_0s = 0; + MD_U64 needed_leading_0s = 0; { - U64 needed_digits = 1; + MD_U64 needed_digits = 1; { - U64 u64_reduce = u64; + MD_U64 u64_reduce = u64; for(;;) { u64_reduce /= radix; @@ -293,7 +293,7 @@ str8_from_u64__ainfo(AllocatorInfo ainfo, U64 u64, U32 radix, U8 min_digits, U8 } } needed_leading_0s = (min_digits > needed_digits) ? min_digits - needed_digits : 0; - U64 needed_separators = 0; + MD_U64 needed_separators = 0; if (digit_group_separator != 0) { needed_separators = (needed_digits + needed_leading_0s) / digit_group_size; @@ -303,22 +303,22 @@ str8_from_u64__ainfo(AllocatorInfo ainfo, U64 u64, U32 radix, U8 min_digits, U8 } } result.size = prefix.size + needed_leading_0s + needed_separators + needed_digits; - result.str = alloc_array_no_zero(ainfo, U8, result.size + 1); + result.str = md_alloc_array_no_zero(ainfo, MD_U8, result.size + 1); result.str[result.size] = 0; } // rjf: fill contents { - U64 u64_reduce = u64; - U64 digits_until_separator = digit_group_size; - for (U64 idx = 0; idx < result.size; idx += 1) + MD_U64 u64_reduce = u64; + MD_U64 digits_until_separator = digit_group_size; + for (MD_U64 idx = 0; idx < result.size; idx += 1) { if(digits_until_separator == 0 && digit_group_separator != 0) { result.str[result.size - idx - 1] = digit_group_separator; digits_until_separator = digit_group_size + 1; } else { - result.str[result.size - idx - 1] = char_to_lower(integer_symbols(u64_reduce % radix)); + result.str[result.size - idx - 1] = md_char_to_lower(md_integer_symbols(u64_reduce % radix)); u64_reduce /= radix; } digits_until_separator -= 1; @@ -326,7 +326,7 @@ str8_from_u64__ainfo(AllocatorInfo ainfo, U64 u64, U32 radix, U8 min_digits, U8 break; } } - for(U64 leading_0_idx = 0; leading_0_idx < needed_leading_0s; leading_0_idx += 1) + for(MD_U64 leading_0_idx = 0; leading_0_idx < needed_leading_0s; leading_0_idx += 1) { result.str[prefix.size + leading_0_idx] = '0'; } @@ -335,24 +335,24 @@ str8_from_u64__ainfo(AllocatorInfo ainfo, U64 u64, U32 radix, U8 min_digits, U8 // rjf: fill prefix if(prefix.size != 0) { - memory_copy(result.str, prefix.str, prefix.size); + md_memory_copy(result.str, prefix.str, prefix.size); } } return result; } -String8 -str8_from_s64__ainfo(AllocatorInfo ainfo, S64 s64, U32 radix, U8 min_digits, U8 digit_group_separator) +MD_String8 +md_str8_from_s64__ainfo(MD_AllocatorInfo ainfo, MD_S64 s64, MD_U32 radix, MD_U8 min_digits, MD_U8 digit_group_separator) { - String8 result = {0}; + MD_String8 result = {0}; if(s64 < 0) { - U8 bytes[KB(1)]; - FArena scratch = farena_from_memory(bytes, size_of(bytes)); - String8 numeric_part = str8_from_u64(farena_allocator(scratch), (U64)(-s64), radix, min_digits, digit_group_separator); - result = str8f(ainfo, "-%S", numeric_part); + MD_U8 bytes[MD_KB(1)]; + MD_FArena scratch = md_farena_from_memory(bytes, size_of(bytes)); + MD_String8 numeric_part = md_str8_from_u64(farena_allocator(scratch), (MD_U64)(-s64), radix, min_digits, digit_group_separator); + result = md_str8f(ainfo, "-%S", numeric_part); } else { - result = str8_from_u64(ainfo, (U64)s64, radix, min_digits, digit_group_separator); + result = md_str8_from_u64(ainfo, (MD_U64)s64, radix, min_digits, digit_group_separator); } return result; } @@ -360,16 +360,16 @@ str8_from_s64__ainfo(AllocatorInfo ainfo, S64 s64, U32 radix, U8 min_digits, U8 //////////////////////////////// //~ rjf: String <=> Float Conversions -F64 -f64_from_str8(String8 string) +MD_F64 +md_f64_from_str8(MD_String8 string) { // TODO(rjf): crappy implementation for now that just uses atof. - F64 result = 0; + MD_F64 result = 0; if (string.size > 0) { // rjf: find starting pos of numeric string, as well as sign - F64 sign = +1.0; - //U64 first_numeric = 0; + MD_F64 sign = +1.0; + //MD_U64 first_numeric = 0; if(string.str[0] == '-') { //first_numeric = 1; @@ -382,11 +382,11 @@ f64_from_str8(String8 string) } // rjf: gather numerics - U64 num_valid_chars = 0; + MD_U64 num_valid_chars = 0; char buffer[64]; - for(U64 idx = 0; idx < string.size && num_valid_chars < sizeof(buffer)-1; idx += 1) + for(MD_U64 idx = 0; idx < string.size && num_valid_chars < sizeof(buffer)-1; idx += 1) { - if(char_is_digit(string.str[idx], 10) || string.str[idx] == '.') + if(md_char_is_digit(string.str[idx], 10) || string.str[idx] == '.') { buffer[num_valid_chars] = string.str[idx]; num_valid_chars += 1; @@ -406,11 +406,11 @@ f64_from_str8(String8 string) //~ rjf: String List Construction Functions void -str8_list_concat_in_place(String8List* list, String8List* to_push) { - if(to_push->node_count != 0) +md_str8_list_concat_in_place(MD_String8List* list, MD_String8List* to_push) { + if(to_push->md_node_count != 0) { if (list->last) { - list->node_count += to_push->node_count; + list->md_node_count += to_push->md_node_count; list->total_size += to_push->total_size; list->last->next = to_push->first; list->last = to_push->last; @@ -418,43 +418,43 @@ str8_list_concat_in_place(String8List* list, String8List* to_push) { else { *list = *to_push; } - memory_zero_struct(to_push); + md_memory_zero_struct(to_push); } } -String8Node* -str8_list_aligner__ainfo(AllocatorInfo ainfo, String8List* list, U64 min, U64 align) { - String8Node* node = alloc_array_no_zero(ainfo, String8Node, 1); - U64 new_size = list->total_size + min; - U64 increase_size = 0; +MD_String8Node* +md_str8_list_aligner__ainfo(MD_AllocatorInfo ainfo, MD_String8List* list, MD_U64 md_min, MD_U64 align) { + MD_String8Node* node = md_alloc_array_no_zero(ainfo, MD_String8Node, 1); + MD_U64 new_size = list->total_size + md_min; + MD_U64 increase_size = 0; if (align > 1) { - // NOTE(allen): assert is power of 2 - assert(((align - 1) & align) == 0); - U64 mask = align - 1; + // NOTE(allen): md_assert is power of 2 + md_assert(((align - 1) & align) == 0); + MD_U64 mask = align - 1; new_size += mask; new_size &= (~mask); increase_size = new_size - list->total_size; } - local_persist const U8 zeroes_buffer[64] = {0}; - assert(increase_size <= array_count(zeroes_buffer)); + md_local_persist const MD_U8 zeroes_buffer[64] = {0}; + md_assert(increase_size <= md_array_count(zeroes_buffer)); - sll_queue_push(list->first, list->last, node); - list->node_count += 1; + md_sll_queue_push(list->first, list->last, node); + list->md_node_count += 1; list->total_size = new_size; - node->string.str = (U8*)zeroes_buffer; + node->string.str = (MD_U8*)zeroes_buffer; node->string.size = increase_size; return(node); } -String8List -str8_list_copy__ainfo(AllocatorInfo ainfo, String8List* list) { - String8List result = {0}; - for (String8Node* node = list->first; node != 0; node = node->next) { - String8Node* new_node = alloc_array_no_zero(ainfo, String8Node, 1); - String8 new_string = str8_copy(ainfo, node->string); - str8_list_push_node_set_string(&result, new_node, new_string); +MD_String8List +md_str8_list_copy__ainfo(MD_AllocatorInfo ainfo, MD_String8List* list) { + MD_String8List result = {0}; + for (MD_String8Node* node = list->first; node != 0; node = node->next) { + MD_String8Node* new_node = md_alloc_array_no_zero(ainfo, MD_String8Node, 1); + MD_String8 new_string = md_str8_copy(ainfo, node->string); + md_str8_list_push_node_set_string(&result, new_node, new_string); } return(result); } @@ -462,23 +462,23 @@ str8_list_copy__ainfo(AllocatorInfo ainfo, String8List* list) { //////////////////////////////// //~ rjf: String Splitting & Joining -String8List -str8_split__ainfo(AllocatorInfo ainfo, String8 string, U8* split_chars, U64 split_char_count, StringSplitFlags flags) +MD_String8List +md_str8_split__ainfo(MD_AllocatorInfo ainfo, MD_String8 string, MD_U8* split_chars, MD_U64 split_char_count, MD_StringSplitFlags flags) { - String8List list = {0}; + MD_String8List list = {0}; - B32 keep_empties = (flags & StringSplitFlag_KeepEmpties); + MD_B32 keep_empties = (flags & MD_StringSplitFlag_KeepEmpties); - U8* ptr = string.str; - U8* opl = string.str + string.size; + MD_U8* ptr = string.str; + MD_U8* opl = string.str + string.size; for (;ptr < opl;) { - U8* first = ptr; + MD_U8* first = ptr; for (;ptr < opl; ptr += 1) { - U8 c = *ptr; - B32 is_split = 0; - for (U64 i = 0; i < split_char_count; i += 1) { + MD_U8 c = *ptr; + MD_B32 is_split = 0; + for (MD_U64 i = 0; i < split_char_count; i += 1) { if (split_chars[i] == c) { is_split = 1; break; @@ -489,45 +489,45 @@ str8_split__ainfo(AllocatorInfo ainfo, String8 string, U8* split_chars, U64 spli } } - String8 string = str8_range(first, ptr); + MD_String8 string = md_str8_range(first, ptr); if (keep_empties || string.size > 0){ - str8_list_push(ainfo, &list, string); + md_str8_list_push(ainfo, &list, string); } ptr += 1; } return(list); } -String8 -str8_list_join__ainfo(AllocatorInfo ainfo, String8List* list, StringJoin* optional_params) +MD_String8 +md_str8_list_join__ainfo(MD_AllocatorInfo ainfo, MD_String8List* list, MD_StringJoin* optional_params) { - StringJoin join = {0}; - if (optional_params != nullptr) { - memory_copy_struct(&join, optional_params); + MD_StringJoin join = {0}; + if (optional_params != md_nullptr) { + md_memory_copy_struct(&join, optional_params); } - U64 sep_count = 0; - if (list->node_count > 0){ - sep_count = list->node_count - 1; + MD_U64 sep_count = 0; + if (list->md_node_count > 0){ + sep_count = list->md_node_count - 1; } - String8 result; + MD_String8 result; result.size = join.pre.size + join.post.size + sep_count * join.sep.size + list->total_size; - U8* ptr = result.str = alloc_array_no_zero(ainfo, U8, result.size + 1); - memory_copy(ptr, join.pre.str, join.pre.size); + MD_U8* ptr = result.str = md_alloc_array_no_zero(ainfo, MD_U8, result.size + 1); + md_memory_copy(ptr, join.pre.str, join.pre.size); ptr += join.pre.size; - for (String8Node *node = list->first; node != 0; node = node->next) { - memory_copy(ptr, node->string.str, node->string.size); + for (MD_String8Node *node = list->first; node != 0; node = node->next) { + md_memory_copy(ptr, node->string.str, node->string.size); ptr += node->string.size; if (node->next != 0) { - memory_copy(ptr, join.sep.str, join.sep.size); + md_memory_copy(ptr, join.sep.str, join.sep.size); ptr += join.sep.size; } } - memory_copy(ptr, join.post.str, join.post.size); + md_memory_copy(ptr, join.post.str, join.post.size); ptr += join.post.size; *ptr = 0; return(result); @@ -536,16 +536,16 @@ str8_list_join__ainfo(AllocatorInfo ainfo, String8List* list, StringJoin* option //////////////////////////////// //~ rjf: String Path Helpers -String8 -str8_chop_last_slash(String8 string) { +MD_String8 +md_str8_chop_last_slash(MD_String8 string) { if (string.size > 0) { - U8* ptr = string.str + string.size - 1; + MD_U8* ptr = string.str + string.size - 1; for (;ptr >= string.str; ptr -= 1) { if (*ptr == '/' || *ptr == '\\') break; } if (ptr >= string.str) { - string.size = (U64)(ptr - string.str); + string.size = (MD_U64)(ptr - string.str); } else { string.size = 0; @@ -554,82 +554,82 @@ str8_chop_last_slash(String8 string) { return(string); } -String8 -str8_skip_last_slash(String8 string) { +MD_String8 +md_str8_skip_last_slash(MD_String8 string) { if (string.size > 0) { - U8* ptr = string.str + string.size - 1; + MD_U8* ptr = string.str + string.size - 1; for (;ptr >= string.str; ptr -= 1) { if (*ptr == '/' || *ptr == '\\') break; } if (ptr >= string.str) { ptr += 1; - string.size = (U64)(string.str + string.size - ptr); + string.size = (MD_U64)(string.str + string.size - ptr); string.str = ptr; } } return(string); } -String8 -str8_chop_last_dot(String8 string) { - String8 result = string; - U64 p = string.size; +MD_String8 +md_str8_chop_last_dot(MD_String8 string) { + MD_String8 result = string; + MD_U64 p = string.size; for (;p > 0;) { p -= 1; if (string.str[p] == '.') { - result = str8_prefix(string, p); + result = md_str8_prefix(string, p); break; } } return(result); } -String8 -str8_skip_last_dot(String8 string) { - String8 result = string; - U64 p = string.size; +MD_String8 +md_str8_skip_last_dot(MD_String8 string) { + MD_String8 result = string; + MD_U64 p = string.size; for (;p > 0;) { p -= 1; if (string.str[p] == '.') { - result = str8_skip(string, p + 1); + result = md_str8_skip(string, p + 1); break; } } return(result); } -PathStyle -path_style_from_str8(String8 string) { - PathStyle result = PathStyle_Relative; +MD_PathStyle +md_path_style_from_str8(MD_String8 string) { + MD_PathStyle result = MD_PathStyle_Relative; if (string.size >= 1 && string.str[0] == '/') { - result = PathStyle_UnixAbsolute; + result = MD_PathStyle_UnixAbsolute; } - else if (string.size >= 2 && char_is_alpha(string.str[0]) && string.str[1] == ':') + else if (string.size >= 2 && md_char_is_alpha(string.str[0]) && string.str[1] == ':') { - if (string.size == 2 || char_is_slash(string.str[2])) { - result = PathStyle_WindowsAbsolute; + if (string.size == 2 || md_char_is_slash(string.str[2])) { + result = MD_PathStyle_WindowsAbsolute; } } return(result); } void -str8_path_list_resolve_dots_in_place(String8List* path, PathStyle style) +md_str8_path_list_resolve_dots_in_place(MD_String8List* path, MD_PathStyle style) { - TempArena scratch = scratch_begin(0, 0); - String8MetaNode* stack = 0; - String8MetaNode* free_meta_node = 0; - String8Node* first = path->first; + MD_TempArena scratch = md_scratch_begin(0, 0); + MD_String8MetaNode* stack = 0; + MD_String8MetaNode* free_meta_node = 0; + MD_String8Node* first = path->first; - memory_zero_struct(path); - for (String8Node* node = first, *next = 0; node != 0; node = next) + md_memory_zero_struct(path); + for (MD_String8Node* node = first, *next = 0; node != 0; node = next) { // save next now next = node->next; // cases: - if (node == first && style == PathStyle_WindowsAbsolute){ + if (node == first && style == MD_PathStyle_WindowsAbsolute){ goto save_without_stack; } @@ -650,32 +650,32 @@ str8_path_list_resolve_dots_in_place(String8List* path, PathStyle style) // handlers: save_with_stack: { - str8_list_push_node(path, node); + md_str8_list_push_node(path, node); - String8MetaNode *stack_node = free_meta_node; + MD_String8MetaNode *stack_node = free_meta_node; if (stack_node != 0){ - sll_stack_pop(free_meta_node); + md_sll_stack_pop(free_meta_node); } else{ - stack_node = push_array_no_zero(scratch.arena, String8MetaNode, 1); + stack_node = md_push_array__no_zero(scratch.arena, MD_String8MetaNode, 1); } - sll_stack_push(stack, stack_node); + md_sll_stack_push(stack, stack_node); stack_node->node = node; continue; } save_without_stack: { - str8_list_push_node(path, node); + md_str8_list_push_node(path, node); continue; } eliminate_stack_top: { - path->node_count -= 1; + path->md_node_count -= 1; path->total_size -= stack->node->string.size; - sll_stack_pop(stack); + md_sll_stack_pop(stack); if (stack == 0) { path->last = path->first; } @@ -689,38 +689,38 @@ str8_path_list_resolve_dots_in_place(String8List* path, PathStyle style) scratch_end(scratch); } -String8 -str8_path_list_join_by_style__ainfo(AllocatorInfo ainfo, String8List* path, PathStyle style) { - StringJoin params = {0}; +MD_String8 +md_str8_path_list_join_by_style__ainfo(MD_AllocatorInfo ainfo, MD_String8List* path, MD_PathStyle style) { + MD_StringJoin params = {0}; switch (style) { - case PathStyle_Relative: - case PathStyle_WindowsAbsolute: + case MD_PathStyle_Relative: + case MD_PathStyle_WindowsAbsolute: { - params.sep = str8_lit("/"); + params.sep = md_str8_lit("/"); } break; - case PathStyle_UnixAbsolute: + case MD_PathStyle_UnixAbsolute: { - params.pre = str8_lit("/"); - params.sep = str8_lit("/"); + params.pre = md_str8_lit("/"); + params.sep = md_str8_lit("/"); } break; } - String8 result = str8_list_join(ainfo, path, ¶ms ); + MD_String8 result = md_str8_list_join(ainfo, path, ¶ms ); return(result); } //////////////////////////////// //~ rjf: UTF-8 & UTF-16 Decoding/Encoding -UnicodeDecode -utf8_decode(U8* str, U64 max) +MD_UnicodeDecode +md_utf8_decode(MD_U8* str, MD_U64 md_max) { - UnicodeDecode result = {1, MAX_U32}; - U8 byte = str[0]; - U8 byte_class = utf8_class(byte >> 3); + MD_UnicodeDecode result = {1, MD_MAX_U32}; + MD_U8 byte = str[0]; + MD_U8 byte_class = md_utf8_class(byte >> 3); switch (byte_class) { case 1: @@ -731,13 +731,13 @@ utf8_decode(U8* str, U64 max) case 2: { - if (2 < max) + if (2 < md_max) { - U8 cont_byte = str[1]; - if (utf8_class(cont_byte >> 3) == 0) + MD_U8 cont_byte = str[1]; + if (md_utf8_class(cont_byte >> 3) == 0) { - result.codepoint = (byte & BITMASK5) << 6; - result.codepoint |= (cont_byte & BITMASK6); + result.codepoint = (byte & MD_BITMASK5) << 6; + result.codepoint |= (cont_byte & MD_BITMASK6); result.inc = 2; } } @@ -746,15 +746,15 @@ utf8_decode(U8* str, U64 max) case 3: { - if (2 < max) + if (2 < md_max) { - U8 cont_byte[2] = {str[1], str[2]}; - if (utf8_class(cont_byte[0] >> 3) == 0 && - utf8_class(cont_byte[1] >> 3) == 0) + MD_U8 cont_byte[2] = {str[1], str[2]}; + if (md_utf8_class(cont_byte[0] >> 3) == 0 && + md_utf8_class(cont_byte[1] >> 3) == 0) { - result.codepoint = (byte & BITMASK4) << 12; - result.codepoint |= ((cont_byte[0] & BITMASK6) << 6); - result.codepoint |= (cont_byte[1] & BITMASK6); + result.codepoint = (byte & MD_BITMASK4) << 12; + result.codepoint |= ((cont_byte[0] & MD_BITMASK6) << 6); + result.codepoint |= (cont_byte[1] & MD_BITMASK6); result.inc = 3; } } @@ -763,17 +763,17 @@ utf8_decode(U8* str, U64 max) case 4: { - if (3 < max) + if (3 < md_max) { - U8 cont_byte[3] = {str[1], str[2], str[3]}; - if (utf8_class(cont_byte[0] >> 3) == 0 && - utf8_class(cont_byte[1] >> 3) == 0 && - utf8_class(cont_byte[2] >> 3) == 0) + MD_U8 cont_byte[3] = {str[1], str[2], str[3]}; + if (md_utf8_class(cont_byte[0] >> 3) == 0 && + md_utf8_class(cont_byte[1] >> 3) == 0 && + md_utf8_class(cont_byte[2] >> 3) == 0) { - result.codepoint = (byte & BITMASK3) << 18; - result.codepoint |= ((cont_byte[0] & BITMASK6) << 12); - result.codepoint |= ((cont_byte[1] & BITMASK6) << 6); - result.codepoint |= (cont_byte[2] & BITMASK6); + result.codepoint = (byte & MD_BITMASK3) << 18; + result.codepoint |= ((cont_byte[0] & MD_BITMASK6) << 12); + result.codepoint |= ((cont_byte[1] & MD_BITMASK6) << 6); + result.codepoint |= (cont_byte[2] & MD_BITMASK6); result.inc = 4; } } @@ -782,30 +782,30 @@ utf8_decode(U8* str, U64 max) return(result); } -U32 -utf8_encode(U8* str, U32 codepoint) +MD_U32 +md_utf8_encode(MD_U8* str, MD_U32 codepoint) { - U32 inc = 0; + MD_U32 inc = 0; if (codepoint <= 0x7F){ - str[0] = (U8)codepoint; + str[0] = (MD_U8)codepoint; inc = 1; } else if (codepoint <= 0x7FF){ - str[0] = (BITMASK2 << 6) | ((codepoint >> 6) & BITMASK5); - str[1] = BIT8 | (codepoint & BITMASK6); + str[0] = (MD_BITMASK2 << 6) | ((codepoint >> 6) & MD_BITMASK5); + str[1] = MD_BIT8 | (codepoint & MD_BITMASK6); inc = 2; } else if (codepoint <= 0xFFFF){ - str[0] = (BITMASK3 << 5) | ((codepoint >> 12) & BITMASK4); - str[1] = BIT8 | ((codepoint >> 6) & BITMASK6); - str[2] = BIT8 | ( codepoint & BITMASK6); + str[0] = (MD_BITMASK3 << 5) | ((codepoint >> 12) & MD_BITMASK4); + str[1] = MD_BIT8 | ((codepoint >> 6) & MD_BITMASK6); + str[2] = MD_BIT8 | ( codepoint & MD_BITMASK6); inc = 3; } else if (codepoint <= 0x10FFFF){ - str[0] = (BITMASK4 << 4) | ((codepoint >> 18) & BITMASK3); - str[1] = BIT8 | ((codepoint >> 12) & BITMASK6); - str[2] = BIT8 | ((codepoint >> 6) & BITMASK6); - str[3] = BIT8 | ( codepoint & BITMASK6); + str[0] = (MD_BITMASK4 << 4) | ((codepoint >> 18) & MD_BITMASK3); + str[1] = MD_BIT8 | ((codepoint >> 12) & MD_BITMASK6); + str[2] = MD_BIT8 | ((codepoint >> 6) & MD_BITMASK6); + str[3] = MD_BIT8 | ( codepoint & MD_BITMASK6); inc = 4; } else{ @@ -815,19 +815,19 @@ utf8_encode(U8* str, U32 codepoint) return(inc); } -U32 -utf16_encode(U16* str, U32 codepoint) { - U32 inc = 1; - if (codepoint == MAX_U32) { - str[0] = (U16)'?'; +MD_U32 +md_utf16_encode(MD_U16* str, MD_U32 codepoint) { + MD_U32 inc = 1; + if (codepoint == MD_MAX_U32) { + str[0] = (MD_U16)'?'; } else if (codepoint < 0x10000) { - str[0] = (U16)codepoint; + str[0] = (MD_U16)codepoint; } else { - U32 v = codepoint - 0x10000; - str[0] = safe_cast_u16(0xD800 + (v >> 10)); - str[1] = safe_cast_u16(0xDC00 + (v & BITMASK10)); + MD_U32 v = codepoint - 0x10000; + str[0] = md_safe_cast_u16(0xD800 + (v >> 10)); + str[1] = md_safe_cast_u16(0xDC00 + (v & MD_BITMASK10)); inc = 2; } return(inc); @@ -838,144 +838,144 @@ utf16_encode(U16* str, U32 codepoint) { // NOTE(Ed): These utilize arena's pop rewinding, so we'll keep the codepath diverged from _alloc paths -String8 -str8_from_str16__arena(Arena* arena, String16 in) { - U64 cap = in.size * 3; - U8* str = push_array_no_zero(arena, U8, cap + 1); - U16* ptr = in.str; - U16* opl = ptr + in.size; - U64 size = 0; - UnicodeDecode consume; +MD_String8 +md_str8_from_str16__arena(MD_Arena* arena, MD_String16 in) { + MD_U64 cap = in.size * 3; + MD_U8* str = md_push_array__no_zero(arena, MD_U8, cap + 1); + MD_U16* ptr = in.str; + MD_U16* opl = ptr + in.size; + MD_U64 size = 0; + MD_UnicodeDecode consume; for (;ptr < opl; ptr += consume.inc) { - consume = utf16_decode(ptr, opl - ptr); - size += utf8_encode(str + size, consume.codepoint); + consume = md_utf16_decode(ptr, opl - ptr); + size += md_utf8_encode(str + size, consume.codepoint); } str[size] = 0; - arena_pop(arena, (cap - size)); - return(str8(str, size)); + md_arena_pop(arena, (cap - size)); + return(md_str8(str, size)); } -String16 -str16_from_str8__arena(Arena* arena, String8 in) { - U64 cap = in.size * 2; - U16* str = push_array_no_zero(arena, U16, cap + 1); - U8* ptr = in.str; - U8* opl = ptr + in.size; - U64 size = 0; - UnicodeDecode consume; +MD_String16 +md_str16_from_str8__arena(MD_Arena* arena, MD_String8 in) { + MD_U64 cap = in.size * 2; + MD_U16* str = md_push_array__no_zero(arena, MD_U16, cap + 1); + MD_U8* ptr = in.str; + MD_U8* opl = ptr + in.size; + MD_U64 size = 0; + MD_UnicodeDecode consume; for (;ptr < opl; ptr += consume.inc) { - consume = utf8_decode(ptr, opl - ptr); - size += utf16_encode(str + size, consume.codepoint); + consume = md_utf8_decode(ptr, opl - ptr); + size += md_utf16_encode(str + size, consume.codepoint); } str[size] = 0; - arena_pop(arena, (cap - size)*2); - return(str16(str, size)); + md_arena_pop(arena, (cap - size)*2); + return(md_str16(str, size)); } -String8 -str8_from_str32__arena(Arena* arena, String32 in){ - U64 cap = in.size * 4; - U8* str = push_array_no_zero(arena, U8, cap + 1); - U32* ptr = in.str; - U32* opl = ptr + in.size; - U64 size = 0; +MD_String8 +md_str8_from_str32__arena(MD_Arena* arena, MD_String32 in){ + MD_U64 cap = in.size * 4; + MD_U8* str = md_push_array__no_zero(arena, MD_U8, cap + 1); + MD_U32* ptr = in.str; + MD_U32* opl = ptr + in.size; + MD_U64 size = 0; for (;ptr < opl; ptr += 1){ - size += utf8_encode(str + size, *ptr); + size += md_utf8_encode(str + size, *ptr); } str[size] = 0; - arena_pop(arena, (cap - size)); - return(str8(str, size)); + md_arena_pop(arena, (cap - size)); + return(md_str8(str, size)); } -String32 -str32_from_str8__arena(Arena* arena, String8 in){ - U64 cap = in.size; - U32* str = push_array_no_zero(arena, U32, cap + 1); - U8* ptr = in.str; - U8* opl = ptr + in.size; - U64 size = 0; - UnicodeDecode consume; +MD_String32 +md_str32_from_str8__arena(MD_Arena* arena, MD_String8 in){ + MD_U64 cap = in.size; + MD_U32* str = md_push_array__no_zero(arena, MD_U32, cap + 1); + MD_U8* ptr = in.str; + MD_U8* opl = ptr + in.size; + MD_U64 size = 0; + MD_UnicodeDecode consume; for (;ptr < opl; ptr += consume.inc){ - consume = utf8_decode(ptr, opl - ptr); + consume = md_utf8_decode(ptr, opl - ptr); str[size] = consume.codepoint; size += 1; } str[size] = 0; - arena_pop(arena, (cap - size)*4); + md_arena_pop(arena, (cap - size)*4); return(str32(str, size)); } -String8 -str8_from_str16__ainfo(AllocatorInfo ainfo, String16 in) { - U64 cap = in.size * 3; - U8* str = alloc_array_no_zero(ainfo, U8, cap + 1); - U16* ptr = in.str; - U16* opl = ptr + in.size; - U64 size = 0; - UnicodeDecode consume; +MD_String8 +md_str8_from_str16__ainfo(MD_AllocatorInfo ainfo, MD_String16 in) { + MD_U64 cap = in.size * 3; + MD_U8* str = md_alloc_array_no_zero(ainfo, MD_U8, cap + 1); + MD_U16* ptr = in.str; + MD_U16* opl = ptr + in.size; + MD_U64 size = 0; + MD_UnicodeDecode consume; for (;ptr < opl; ptr += consume.inc) { - consume = utf16_decode(ptr, opl - ptr); - size += utf8_encode(str + size, consume.codepoint); + consume = md_utf16_decode(ptr, opl - ptr); + size += md_utf8_encode(str + size, consume.codepoint); } str[size] = 0; - if (allocator_query_support(ainfo) & AllocatorQuery_ResizeShrink) { - resize(ainfo, str, cap + 1, (cap - size)); + if (md_allocator_query_support(ainfo) & MD_AllocatorQuery_ResizeShrink) { + md_resize(ainfo, str, cap + 1, (cap - size)); } - return(str8(str, size)); + return(md_str8(str, size)); } -String16 -str16_from_str8__ainfo(AllocatorInfo ainfo, String8 in) { - U64 cap = in.size * 2; - U16* str = alloc_array_no_zero(ainfo, U16, cap + 1); - U8* ptr = in.str; - U8* opl = ptr + in.size; - U64 size = 0; - UnicodeDecode consume; +MD_String16 +md_str16_from_str8__ainfo(MD_AllocatorInfo ainfo, MD_String8 in) { + MD_U64 cap = in.size * 2; + MD_U16* str = md_alloc_array_no_zero(ainfo, MD_U16, cap + 1); + MD_U8* ptr = in.str; + MD_U8* opl = ptr + in.size; + MD_U64 size = 0; + MD_UnicodeDecode consume; for (;ptr < opl; ptr += consume.inc) { - consume = utf8_decode(ptr, opl - ptr); - size += utf16_encode(str + size, consume.codepoint); + consume = md_utf8_decode(ptr, opl - ptr); + size += md_utf16_encode(str + size, consume.codepoint); } str[size] = 0; - if (allocator_query_support(ainfo) & AllocatorQuery_ResizeShrink) { - resize(ainfo, str, cap + 1, (cap - size)); + if (md_allocator_query_support(ainfo) & MD_AllocatorQuery_ResizeShrink) { + md_resize(ainfo, str, cap + 1, (cap - size)); } - return(str16(str, size)); + return(md_str16(str, size)); } -String8 -str8_from_str32__ainfo(AllocatorInfo ainfo, String32 in){ - U64 cap = in.size * 4; - U8* str = alloc_array_no_zero(ainfo, U8, cap + 1); - U32* ptr = in.str; - U32* opl = ptr + in.size; - U64 size = 0; +MD_String8 +md_str8_from_str32__ainfo(MD_AllocatorInfo ainfo, MD_String32 in){ + MD_U64 cap = in.size * 4; + MD_U8* str = md_alloc_array_no_zero(ainfo, MD_U8, cap + 1); + MD_U32* ptr = in.str; + MD_U32* opl = ptr + in.size; + MD_U64 size = 0; for (;ptr < opl; ptr += 1){ - size += utf8_encode(str + size, *ptr); + size += md_utf8_encode(str + size, *ptr); } str[size] = 0; - if (allocator_query_support(ainfo) & AllocatorQuery_ResizeShrink) { - resize(ainfo, str, cap + 1, (cap - size)); + if (md_allocator_query_support(ainfo) & MD_AllocatorQuery_ResizeShrink) { + md_resize(ainfo, str, cap + 1, (cap - size)); } - return(str8(str, size)); + return(md_str8(str, size)); } -String32 -str32_from_str8__ainfo(AllocatorInfo ainfo, String8 in){ - U64 cap = in.size; - U32* str = alloc_array_no_zero(ainfo, U32, cap + 1); - U8* ptr = in.str; - U8* opl = ptr + in.size; - U64 size = 0; - UnicodeDecode consume; +MD_String32 +md_str32_from_str8__ainfo(MD_AllocatorInfo ainfo, MD_String8 in){ + MD_U64 cap = in.size; + MD_U32* str = md_alloc_array_no_zero(ainfo, MD_U32, cap + 1); + MD_U8* ptr = in.str; + MD_U8* opl = ptr + in.size; + MD_U64 size = 0; + MD_UnicodeDecode consume; for (;ptr < opl; ptr += consume.inc){ - consume = utf8_decode(ptr, opl - ptr); + consume = md_utf8_decode(ptr, opl - ptr); str[size] = consume.codepoint; size += 1; } str[size] = 0; - if (allocator_query_support(ainfo) & AllocatorQuery_ResizeShrink) { - resize(ainfo, str, cap + 1, (cap - size)); + if (md_allocator_query_support(ainfo) & MD_AllocatorQuery_ResizeShrink) { + md_resize(ainfo, str, cap + 1, (cap - size)); } return(str32(str, size)); } @@ -983,41 +983,41 @@ str32_from_str8__ainfo(AllocatorInfo ainfo, String8 in){ //////////////////////////////// //~ String -> Enum Conversions -typedef struct OS_EnumMap OS_EnumMap; -struct OS_EnumMap +typedef struct MD_OS_EnumMap MD_OS_EnumMap; +struct MD_OS_EnumMap { - String8 string; - OperatingSystem os; + MD_String8 string; + MD_OperatingSystem os; }; -read_only global OS_EnumMap g_os_enum_map[] = +md_read_only md_global MD_OS_EnumMap g_os_enum_map[] = { - { str8_lit_comp(""), OperatingSystem_Null }, - { str8_lit_comp("Windows"), OperatingSystem_Windows, }, - { str8_lit_comp("Linux"), OperatingSystem_Linux, }, - { str8_lit_comp("Mac"), OperatingSystem_Mac, }, + { md_str8_lit_comp(""), MD_OperatingSystem_Null }, + { md_str8_lit_comp("Windows"), MD_OperatingSystem_Windows, }, + { md_str8_lit_comp("Linux"), MD_OperatingSystem_Linux, }, + { md_str8_lit_comp("Mac"), MD_OperatingSystem_Mac, }, }; -md_static_assert(array_count(g_os_enum_map) == OperatingSystem_COUNT, g_os_enum_map_count_check); +md_static_assert(md_array_count(g_os_enum_map) == MD_OperatingSystem_COUNT, g_os_enum_map_count_check); -OperatingSystem -operating_system_from_string(String8 string) +MD_OperatingSystem +md_operating_system_from_string(MD_String8 string) { - for (U64 i = 0; i < array_count(g_os_enum_map); ++i) { - if(str8_match(g_os_enum_map[i].string, string, StringMatchFlag_CaseInsensitive)) { + for (MD_U64 i = 0; i < md_array_count(g_os_enum_map); ++i) { + if(md_str8_match(g_os_enum_map[i].string, string, MD_StringMatchFlag_CaseInsensitive)) { return g_os_enum_map[i].os; } } - return OperatingSystem_Null; + return MD_OperatingSystem_Null; } //////////////////////////////// //~ rjf: Time Types -> String -String8 -date_time_string__ainfo(AllocatorInfo ainfo, DateTime* date_time) { - char* mon_str = (char*)string_from_month(date_time->month).str; +MD_String8 +md_date_time_string__ainfo(MD_AllocatorInfo ainfo, MD_DateTime* date_time) { + char* mon_str = (char*)md_string_from_month(date_time->month).str; - U32 adjusted_hour = date_time->hour % 12; + MD_U32 adjusted_hour = date_time->hour % 12; if (adjusted_hour == 0){ adjusted_hour = 12; } @@ -1027,88 +1027,88 @@ date_time_string__ainfo(AllocatorInfo ainfo, DateTime* date_time) { ampm = "pm"; } - String8 result = str8f(ainfo, + MD_String8 result = md_str8f(ainfo, "%d %s %d, %02d:%02d:%02d %s", date_time->day, mon_str, date_time->year, - adjusted_hour, date_time->min, date_time->sec, ampm + adjusted_hour, date_time->md_min, date_time->sec, ampm ); return(result); } -String8 -file_name_date_time_string__ainfo(AllocatorInfo ainfo, DateTime* date_time) { - char* mon_str = (char*)string_from_month(date_time->month).str; +MD_String8 +md_file_name_date_time_string__ainfo(MD_AllocatorInfo ainfo, MD_DateTime* date_time) { + char* mon_str = (char*)md_string_from_month(date_time->month).str; - String8 result = str8f(ainfo, + MD_String8 result = md_str8f(ainfo, "%d-%s-%0d--%02d-%02d-%02d", date_time->year, mon_str, date_time->day, - date_time->hour, date_time->min, date_time->sec + date_time->hour, date_time->md_min, date_time->sec ); return(result); } -String8 -string_from_elapsed_time__ainfo(AllocatorInfo ainfo, DateTime dt) { - TempArena scratch = scratch_begin(ainfo); +MD_String8 +md_string_from_elapsed_time__ainfo(MD_AllocatorInfo ainfo, MD_DateTime dt) { + MD_TempArena scratch = md_scratch_begin(ainfo); - String8List list = {0}; + MD_String8List list = {0}; if (dt.year) { - str8_list_pushf(scratch.arena, &list, "%dy", dt.year); - str8_list_pushf(scratch.arena, &list, "%um", dt.mon); - str8_list_pushf(scratch.arena, &list, "%ud", dt.day); + md_str8_list_pushf(scratch.arena, &list, "%dy", dt.year); + md_str8_list_pushf(scratch.arena, &list, "%um", dt.mon); + md_str8_list_pushf(scratch.arena, &list, "%ud", dt.day); } else if (dt.mon) { - str8_list_pushf(scratch.arena, &list, "%um", dt.mon); - str8_list_pushf(scratch.arena, &list, "%ud", dt.day); + md_str8_list_pushf(scratch.arena, &list, "%um", dt.mon); + md_str8_list_pushf(scratch.arena, &list, "%ud", dt.day); } else if (dt.day) { - str8_list_pushf(scratch.arena, &list, "%ud", dt.day); + md_str8_list_pushf(scratch.arena, &list, "%ud", dt.day); } - str8_list_pushf(scratch.arena, &list, "%u:%u:%u:%u ms", dt.hour, dt.min, dt.sec, dt.msec); + md_str8_list_pushf(scratch.arena, &list, "%u:%u:%u:%u ms", dt.hour, dt.md_min, dt.sec, dt.msec); - StringJoin join = { str8_lit_comp(""), str8_lit_comp(" "), str8_lit_comp("") }; - String8 result = str8_list_join(ainfo, &list, &join); + MD_StringJoin join = { md_str8_lit_comp(""), md_str8_lit_comp(" "), md_str8_lit_comp("") }; + MD_String8 result = md_str8_list_join(ainfo, &list, &join); return(result); } //////////////////////////////// //~ Globally Unique Ids -B32 -try_guid_from_string(String8 string, Guid* guid_out) +MD_B32 +md_try_guid_from_string(MD_String8 string, MD_Guid* md_guid_out) { - TempArena scratch = scratch_begin(0,0); - B32 is_parsed = 0; + MD_TempArena scratch = md_scratch_begin(0,0); + MD_B32 is_parsed = 0; - String8List list = str8_split_by_string_chars(scratch.arena, string, str8_lit("-"), StringSplitFlag_KeepEmpties); - if(list.node_count == 5) + MD_String8List list = md_str8_split_by_string_chars(scratch.arena, string, md_str8_lit("-"), MD_StringSplitFlag_KeepEmpties); + if(list.md_node_count == 5) { - String8 data1_str = list.first->string; - String8 data2_str = list.first->next->string; - String8 data3_str = list.first->next->next->string; - String8 data4_hi_str = list.first->next->next->next->string; - String8 data4_lo_str = list.first->next->next->next->next->string; - if( str8_is_integer(data1_str, 16) && - str8_is_integer(data2_str, 16) && - str8_is_integer(data3_str, 16) && - str8_is_integer(data4_hi_str, 16) && - str8_is_integer(data4_lo_str, 16) ) + MD_String8 data1_str = list.first->string; + MD_String8 data2_str = list.first->next->string; + MD_String8 data3_str = list.first->next->next->string; + MD_String8 data4_hi_str = list.first->next->next->next->string; + MD_String8 data4_lo_str = list.first->next->next->next->next->string; + if( md_str8_is_integer(data1_str, 16) && + md_str8_is_integer(data2_str, 16) && + md_str8_is_integer(data3_str, 16) && + md_str8_is_integer(data4_hi_str, 16) && + md_str8_is_integer(data4_lo_str, 16) ) { - U64 data1 = u64_from_str8(data1_str, 16); - U64 data2 = u64_from_str8(data2_str, 16); - U64 data3 = u64_from_str8(data3_str, 16); - U64 data4_hi = u64_from_str8(data4_hi_str, 16); - U64 data4_lo = u64_from_str8(data4_lo_str, 16); - if( data1 <= MAX_U32 && - data2 <= MAX_U16 && - data3 <= MAX_U16 && - data4_hi <= MAX_U16 && + MD_U64 data1 = md_u64_from_str8(data1_str, 16); + MD_U64 data2 = md_u64_from_str8(data2_str, 16); + MD_U64 data3 = md_u64_from_str8(data3_str, 16); + MD_U64 data4_hi = md_u64_from_str8(data4_hi_str, 16); + MD_U64 data4_lo = md_u64_from_str8(data4_lo_str, 16); + if( data1 <= MD_MAX_U32 && + data2 <= MD_MAX_U16 && + data3 <= MD_MAX_U16 && + data4_hi <= MD_MAX_U16 && data4_lo <= 0xffffffffffff ) { - guid_out->data1 = (U32)data1; - guid_out->data2 = (U16)data2; - guid_out->data3 = (U16)data3; + md_guid_out->data1 = (MD_U32)data1; + md_guid_out->data2 = (MD_U16)data2; + md_guid_out->data3 = (MD_U16)data3; - U64 data4 = (data4_hi << 48) | data4_lo; - memory_copy(&guid_out->data4[0], &data4, sizeof(data4)); + MD_U64 data4 = (data4_hi << 48) | data4_lo; + md_memory_copy(&md_guid_out->data4[0], &data4, sizeof(data4)); is_parsed = 1; } } @@ -1120,31 +1120,31 @@ try_guid_from_string(String8 string, Guid* guid_out) //////////////////////////////// //~ rjf: Basic Text Indentation -String8 -indented_from_string__ainfo(AllocatorInfo ainfo, String8 string) +MD_String8 +md_indented_from_string__ainfo(MD_AllocatorInfo ainfo, MD_String8 string) { - TempArena scratch = scratch_begin(ainfo); + MD_TempArena scratch = md_scratch_begin(ainfo); - local_persist U8 indentation_bytes[] = " "; - String8List indented_strings = {0}; + md_local_persist MD_U8 indentation_bytes[] = " "; + MD_String8List indented_strings = {0}; - S64 depth = 0; - S64 next_depth = 0; - U64 line_begin_off = 0; - for(U64 off = 0; off <= string.size; off += 1) + MD_S64 depth = 0; + MD_S64 next_depth = 0; + MD_U64 line_begin_off = 0; + for(MD_U64 off = 0; off <= string.size; off += 1) { - U8 byte = off width_this_line) { - String8 line = str8_substr(string, line_range); + MD_String8 line = md_str8_substr(string, line_range); if (wrapped_indent_level > 0){ - line = str8f(ainfo, "%.*s%S", wrapped_indent_level, spaces, line); + line = md_str8f(ainfo, "%.*s%S", wrapped_indent_level, spaces, line); } - str8_list_push(ainfo, &list, line); - line_range = r1u64(line_range.max + 1, candidate_line_range.max); - wrapped_indent_level = clamp_top(64, wrap_indent); + md_str8_list_push(ainfo, &list, line); + line_range = md_r1u64(line_range.md_max + 1, candidate_line_range.md_max); + wrapped_indent_level = md_clamp_top(64, wrap_indent); } else{ line_range = candidate_line_range; } } } - if (line_range.min < string.size && line_range.max > line_range.min) { - String8 line = str8_substr(string, line_range); + if (line_range.md_min < string.size && line_range.md_max > line_range.md_min) { + MD_String8 line = md_str8_substr(string, line_range); if (wrapped_indent_level > 0) { - line = str8f(ainfo, "%.*s%S", wrapped_indent_level, spaces, line); + line = md_str8f(ainfo, "%.*s%S", wrapped_indent_level, spaces, line); } - str8_list_push(ainfo, &list, line); + md_str8_list_push(ainfo, &list, line); } return list; } @@ -1325,49 +1325,49 @@ wrapped_lines_from_string__ainfo(AllocatorInfo ainfo, String8 string, U64 first_ //////////////////////////////// //~ rjf: String <-> Color -Vec4F32 -rgba_from_hex_string_4f32(String8 hex_string) +MD_Vec4F32 +md_rgba_from_hex_string_4f32(MD_String8 hex_string) { - U8 byte_text[8] = {0}; - U64 byte_text_idx = 0; - for(U64 idx = 0; idx < hex_string.size && byte_text_idx < array_count(byte_text); idx += 1) + MD_U8 byte_text[8] = {0}; + MD_U64 byte_text_idx = 0; + for(MD_U64 idx = 0; idx < hex_string.size && byte_text_idx < md_array_count(byte_text); idx += 1) { - if(char_is_digit(hex_string.str[idx], 16)) { - byte_text[byte_text_idx] = char_to_lower(hex_string.str[idx]); + if(md_char_is_digit(hex_string.str[idx], 16)) { + byte_text[byte_text_idx] = md_char_to_lower(hex_string.str[idx]); byte_text_idx += 1; } } - U8 byte_vals[4] = {0}; - for(U64 idx = 0; idx < 4; idx += 1) { - byte_vals[idx] = (U8)u64_from_str8(str8(&byte_text[idx*2], 2), 16); + MD_U8 byte_vals[4] = {0}; + for(MD_U64 idx = 0; idx < 4; idx += 1) { + byte_vals[idx] = (MD_U8)md_u64_from_str8(md_str8(&byte_text[idx*2], 2), 16); } - Vec4F32 rgba = v4f32(byte_vals[0] / 255.f, byte_vals[1] / 255.f, byte_vals[2] / 255.f, byte_vals[3] / 255.f); + MD_Vec4F32 rgba = md_v4f32(byte_vals[0] / 255.f, byte_vals[1] / 255.f, byte_vals[2] / 255.f, byte_vals[3] / 255.f); return rgba; } //////////////////////////////// //~ rjf: String Fuzzy Matching -FuzzyMatchRangeList -fuzzy_match_find__ainfo(AllocatorInfo ainfo, String8 needle, String8 haystack) +MD_FuzzyMatchRangeList +md_fuzzy_match_find__ainfo(MD_AllocatorInfo ainfo, MD_String8 needle, MD_String8 haystack) { - TempArena scratch = scratch_begin(ainfo); - String8List needles = str8_split(scratch.arena, needle, (U8*)" ", 1, 0); - FuzzyMatchRangeList + MD_TempArena scratch = md_scratch_begin(ainfo); + MD_String8List needles = md_str8_split(scratch.arena, needle, (MD_U8*)" ", 1, 0); + MD_FuzzyMatchRangeList result = {0}; - result.needle_part_count = needles.node_count; - for(String8Node* needle_n = needles.first; needle_n != 0; needle_n = needle_n->next) + result.needle_part_count = needles.md_node_count; + for(MD_String8Node* needle_n = needles.first; needle_n != 0; needle_n = needle_n->next) { - U64 find_pos = 0; + MD_U64 find_pos = 0; for(;find_pos < haystack.size;) { - find_pos = str8_find_needle(haystack, find_pos, needle_n->string, StringMatchFlag_CaseInsensitive); - B32 is_in_gathered_ranges = 0; - for (FuzzyMatchRangeNode* n = result.first; n != 0; n = n->next) + find_pos = md_str8_find_needle(haystack, find_pos, needle_n->string, MD_StringMatchFlag_CaseInsensitive); + MD_B32 is_in_gathered_ranges = 0; + for (MD_FuzzyMatchRangeNode* n = result.first; n != 0; n = n->next) { - if (n->range.min <= find_pos && find_pos < n->range.max) { + if (n->range.md_min <= find_pos && find_pos < n->range.md_max) { is_in_gathered_ranges = 1; - find_pos = n->range.max; + find_pos = n->range.md_max; break; } } @@ -1376,26 +1376,26 @@ fuzzy_match_find__ainfo(AllocatorInfo ainfo, String8 needle, String8 haystack) } } if (find_pos < haystack.size) { - Rng1U64 range = r1u64(find_pos, find_pos+needle_n->string.size); - FuzzyMatchRangeNode* n = push_array(scratch.arena, FuzzyMatchRangeNode, 1); + MD_Rng1U64 range = md_r1u64(find_pos, find_pos+needle_n->string.size); + MD_FuzzyMatchRangeNode* n = md_push_array_(scratch.arena, MD_FuzzyMatchRangeNode, 1); n->range = range; - sll_queue_push(result.first, result.last, n); + md_sll_queue_push(result.first, result.last, n); result.count += 1; - result.total_dim += dim_1u64(range); + result.total_dim += md_dim_1u64(range); } } - temp_end(scratch); + md_temp_end(scratch); return result; } -FuzzyMatchRangeList -fuzzy_match_range_list_copy__ainfo(AllocatorInfo ainfo, FuzzyMatchRangeList* src) +MD_FuzzyMatchRangeList +md_fuzzy_match_range_list_copy__ainfo(MD_AllocatorInfo ainfo, MD_FuzzyMatchRangeList* src) { - FuzzyMatchRangeList dst = {0}; - for(FuzzyMatchRangeNode* src_n = src->first; src_n != 0; src_n = src_n->next) + MD_FuzzyMatchRangeList dst = {0}; + for(MD_FuzzyMatchRangeNode* src_n = src->first; src_n != 0; src_n = src_n->next) { - FuzzyMatchRangeNode* dst_n = alloc_array(ainfo, FuzzyMatchRangeNode, 1); - sll_queue_push(dst.first, dst.last, dst_n); + MD_FuzzyMatchRangeNode* dst_n = md_alloc_array(ainfo, MD_FuzzyMatchRangeNode, 1); + md_sll_queue_push(dst.first, dst.last, dst_n); dst_n->range = src_n->range; } dst.count = src->count; @@ -1407,42 +1407,42 @@ fuzzy_match_range_list_copy__ainfo(AllocatorInfo ainfo, FuzzyMatchRangeList* src //////////////////////////////// //~ NOTE(allen): Serialization Helpers -U64 -str8_serial_push_align__ainfo(AllocatorInfo ainfo, String8List* srl, U64 align) { - assert(is_pow2(align)); - U64 pos = srl->total_size; - U64 new_pos = align_pow2(pos, align); - U64 size = (new_pos - pos); +MD_U64 +md_str8_serial_push_align__ainfo(MD_AllocatorInfo ainfo, MD_String8List* srl, MD_U64 align) { + md_assert(md_is_pow2(align)); + MD_U64 pos = srl->total_size; + MD_U64 new_pos = md_align_pow2(pos, align); + MD_U64 size = (new_pos - pos); if(size != 0) { - U8* buf = alloc_array(ainfo, U8, size); + MD_U8* buf = md_alloc_array(ainfo, MD_U8, size); - String8* str = &srl->last->string; + MD_String8* str = &srl->last->string; if (str->str + str->size == buf) { srl->last->string.size += size; srl->total_size += size; } else { - str8_list_push(ainfo, srl, str8(buf, size)); + md_str8_list_push(ainfo, srl, md_str8(buf, size)); } } return size; } void* -str8_serial_push_size__ainfo(AllocatorInfo ainfo, String8List* srl, U64 size) { +md_str8_serial_push_size__ainfo(MD_AllocatorInfo ainfo, MD_String8List* srl, MD_U64 size) { void* result = 0; if(size != 0) { - U8* buf = alloc_array_no_zero(ainfo, U8, size); - String8* str = &srl->last->string; + MD_U8* buf = md_alloc_array_no_zero(ainfo, MD_U8, size); + MD_String8* str = &srl->last->string; if (str->str + str->size == buf) { srl->last->string.size += size; srl->total_size += size; } else { - str8_list_push(ainfo, srl, str8(buf, size)); + md_str8_list_push(ainfo, srl, md_str8(buf, size)); } result = buf; } @@ -1450,55 +1450,55 @@ str8_serial_push_size__ainfo(AllocatorInfo ainfo, String8List* srl, U64 size) { } void -str8_serial_alloc_u64__ainfo(AllocatorInfo ainfo, String8List* srl, U64 x) { - U8* buf = alloc_array_no_zero(ainfo, U8, 8); - memory_copy(buf, &x, 8); - String8* str = &srl->last->string; +md_str8_serial_alloc_u64__ainfo(MD_AllocatorInfo ainfo, MD_String8List* srl, MD_U64 x) { + MD_U8* buf = md_alloc_array_no_zero(ainfo, MD_U8, 8); + md_memory_copy(buf, &x, 8); + MD_String8* str = &srl->last->string; if (str->str + str->size == buf) { srl->last->string.size += 8; srl->total_size += 8; } else { - str8_list_push(ainfo, srl, str8(buf, 8)); + md_str8_list_push(ainfo, srl, md_str8(buf, 8)); } } void -str8_serial_alloc_u32__ainfo(AllocatorInfo ainfo, String8List* srl, U32 x) { - U8* buf = alloc_array_no_zero(ainfo, U8, 4); - memory_copy(buf, &x, 4); - String8 *str = &srl->last->string; +md_str8_serial_alloc_u32__ainfo(MD_AllocatorInfo ainfo, MD_String8List* srl, MD_U32 x) { + MD_U8* buf = md_alloc_array_no_zero(ainfo, MD_U8, 4); + md_memory_copy(buf, &x, 4); + MD_String8 *str = &srl->last->string; if (str->str + str->size == buf) { srl->last->string.size += 4; srl->total_size += 4; } else { - str8_list_push(ainfo, srl, str8(buf, 4)); + md_str8_list_push(ainfo, srl, md_str8(buf, 4)); } } //////////////////////////////// //~ rjf: Deserialization Helpers -U64 -str8_deserial_read(String8 string, U64 off, void *read_dst, U64 read_size, U64 granularity) { - U64 bytes_left = string.size - min(off, string.size); - U64 actually_readable_size = min(bytes_left, read_size); - U64 legally_readable_size = actually_readable_size - actually_readable_size % granularity; +MD_U64 +md_str8_deserial_read(MD_String8 string, MD_U64 off, void *read_dst, MD_U64 read_size, MD_U64 granularity) { + MD_U64 bytes_left = string.size - md_min(off, string.size); + MD_U64 actually_readable_size = md_min(bytes_left, read_size); + MD_U64 legally_readable_size = actually_readable_size - actually_readable_size % granularity; if(legally_readable_size > 0) { - memory_copy(read_dst, string.str + off, legally_readable_size); + md_memory_copy(read_dst, string.str + off, legally_readable_size); } return legally_readable_size; } -U64 -str8_deserial_find_first_match(String8 string, U64 off, U16 scan_val) { - U64 cursor = off; +MD_U64 +md_str8_deserial_find_first_match(MD_String8 string, MD_U64 off, MD_U16 scan_val) { + MD_U64 cursor = off; for (;;) { - U16 val = 0; - str8_deserial_read_struct(string, cursor, &val); + MD_U16 val = 0; + md_str8_deserial_read_struct(string, cursor, &val); if (val == scan_val) { break; } @@ -1507,47 +1507,47 @@ str8_deserial_find_first_match(String8 string, U64 off, U16 scan_val) { return cursor; } -U64 -str8_deserial_read_cstr(String8 string, U64 off, String8* cstr_out) { - U64 cstr_size = 0; +MD_U64 +md_str8_deserial_read_cstr(MD_String8 string, MD_U64 off, MD_String8* cstr_out) { + MD_U64 cstr_size = 0; if (off < string.size) { - U8* ptr = string.str + off; - U8* cap = string.str + string.size; - *cstr_out = str8_cstring_capped(ptr, cap); + MD_U8* ptr = string.str + off; + MD_U8* cap = string.str + string.size; + *cstr_out = md_str8_cstring_capped(ptr, cap); cstr_size = (cstr_out->size + 1); } return cstr_size; } -U64 -str8_deserial_read_windows_utf16_string16(String8 string, U64 off, String16* str_out) +MD_U64 +md_str8_deserial_read_windows_utf16_string16(MD_String8 string, MD_U64 off, MD_String16* md_str_out) { - U64 null_off = str8_deserial_find_first_match(string, off, 0); - U64 size = null_off - off; - U16 *str = (U16*)str8_deserial_get_raw_ptr(string, off, size); - U64 count = size / sizeof(*str); + MD_U64 null_off = md_str8_deserial_find_first_match(string, off, 0); + MD_U64 size = null_off - off; + MD_U16 *str = (MD_U16*)md_str8_deserial_get_raw_ptr(string, off, size); + MD_U64 count = size / sizeof(*str); - *str_out = str16(str, count); + *md_str_out = md_str16(str, count); - U64 read_size_with_null = size + sizeof(*str); + MD_U64 read_size_with_null = size + sizeof(*str); return read_size_with_null; } -U64 -str8_deserial_read_uleb128(String8 string, U64 off, U64 *value_out) { - U64 value = 0; - U64 shift = 0; - U64 cursor = off; +MD_U64 +md_str8_deserial_read_uleb128(MD_String8 string, MD_U64 off, MD_U64 *value_out) { + MD_U64 value = 0; + MD_U64 shift = 0; + MD_U64 cursor = off; for(;;) { - U8 byte = 0; - U64 bytes_read = str8_deserial_read_struct(string, cursor, &byte); + MD_U8 byte = 0; + MD_U64 bytes_read = md_str8_deserial_read_struct(string, cursor, &byte); if (bytes_read != sizeof(byte)) { break; } - U8 val = byte & 0x7fu; - value |= ((U64)val) << shift; + MD_U8 val = byte & 0x7fu; + value |= ((MD_U64)val) << shift; cursor += bytes_read; shift += 7u; @@ -1557,26 +1557,26 @@ str8_deserial_read_uleb128(String8 string, U64 off, U64 *value_out) { } if(value_out != 0) { *value_out = value; } - U64 bytes_read = cursor - off; + MD_U64 bytes_read = cursor - off; return bytes_read; } -U64 -str8_deserial_read_sleb128(String8 string, U64 off, S64 *value_out) +MD_U64 +md_str8_deserial_read_sleb128(MD_String8 string, MD_U64 off, MD_S64 *value_out) { - U64 value = 0; - U64 shift = 0; - U64 cursor = off; + MD_U64 value = 0; + MD_U64 shift = 0; + MD_U64 cursor = off; for(;;) { - U8 byte; - U64 bytes_read = str8_deserial_read_struct(string, cursor, &byte); + MD_U8 byte; + MD_U64 bytes_read = md_str8_deserial_read_struct(string, cursor, &byte); if (bytes_read != sizeof(byte)) { break; } - U8 val = byte & 0x7fu; - value |= ((U64)val) << shift; + MD_U8 val = byte & 0x7fu; + value |= ((MD_U64)val) << shift; cursor += bytes_read; shift += 7u; @@ -1584,13 +1584,13 @@ str8_deserial_read_sleb128(String8 string, U64 off, S64 *value_out) if ((byte & 0x80u) == 0) { if (shift < sizeof(value) * 8 && (byte & 0x40u) != 0) { - value |= -(S64)(1ull << shift); + value |= -(MD_S64)(1ull << shift); } break; } } if (value_out != 0) { *value_out = value; } - U64 bytes_read = cursor - off; + MD_U64 bytes_read = cursor - off; return bytes_read; } diff --git a/source/base/strings.h b/source/base/strings.h index 009d1ad..b03ccb3 100644 --- a/source/base/strings.h +++ b/source/base/strings.h @@ -23,147 +23,147 @@ //////////////////////////////// //~ rjf: String Types -typedef struct String8 String8; -struct String8 +typedef struct MD_String8 MD_String8; +struct MD_String8 { - U8* str; - U64 size; + MD_U8* str; + MD_U64 size; }; -typedef struct String16 String16; -struct String16 +typedef struct MD_String16 MD_String16; +struct MD_String16 { - U16* str; - U64 size; + MD_U16* str; + MD_U64 size; }; -typedef struct String32 String32; -struct String32 +typedef struct MD_String32 MD_String32; +struct MD_String32 { - U32* str; - U64 size; + MD_U32* str; + MD_U64 size; }; //////////////////////////////// //~ rjf: String List & Array Types -typedef struct String8Node String8Node; -struct String8Node +typedef struct MD_String8Node MD_String8Node; +struct MD_String8Node { - String8Node* next; - String8 string; + MD_String8Node* next; + MD_String8 string; }; -typedef struct String8MetaNode String8MetaNode; -struct String8MetaNode +typedef struct MD_String8MetaNode MD_String8MetaNode; +struct MD_String8MetaNode { - String8MetaNode* next; - String8Node* node; + MD_String8MetaNode* next; + MD_String8Node* node; }; -typedef struct String8List String8List; -struct String8List +typedef struct MD_String8List MD_String8List; +struct MD_String8List { - String8Node* first; - String8Node* last; - U64 node_count; - U64 total_size; + MD_String8Node* first; + MD_String8Node* last; + MD_U64 md_node_count; + MD_U64 total_size; }; -typedef struct String8Array String8Array; -struct String8Array +typedef struct MD_String8Array MD_String8Array; +struct MD_String8Array { - String8* v; - U64 count; + MD_String8* v; + MD_U64 count; }; //////////////////////////////// //~ rjf: String Matching, Splitting, & Joining Types -typedef U32 StringMatchFlags; +typedef MD_U32 MD_StringMatchFlags; enum { - StringMatchFlag_CaseInsensitive = (1 << 0), - StringMatchFlag_RightSideSloppy = (1 << 1), - StringMatchFlag_SlashInsensitive = (1 << 2), + MD_StringMatchFlag_CaseInsensitive = (1 << 0), + MD_StringMatchFlag_RightSideSloppy = (1 << 1), + MD_StringMatchFlag_SlashInsensitive = (1 << 2), }; -typedef U32 StringSplitFlags; +typedef MD_U32 MD_StringSplitFlags; enum { - StringSplitFlag_KeepEmpties = (1 << 0), + MD_StringSplitFlag_KeepEmpties = (1 << 0), }; -typedef enum PathStyle +typedef enum MD_PathStyle { - PathStyle_Relative, - PathStyle_WindowsAbsolute, - PathStyle_UnixAbsolute, + MD_PathStyle_Relative, + MD_PathStyle_WindowsAbsolute, + MD_PathStyle_UnixAbsolute, -#if OS_WINDOWS - PathStyle_SystemAbsolute = PathStyle_WindowsAbsolute -#elif OS_LINUX - PathStyle_SystemAbsolute = PathStyle_UnixAbsolute +#if MD_OS_WINDOWS + MD_PathStyle_SystemAbsolute = MD_PathStyle_WindowsAbsolute +#elif MD_OS_LINUX + MD_PathStyle_SystemAbsolute = MD_PathStyle_UnixAbsolute #else # error "absolute path style is undefined for this OS" #endif } -PathStyle; +MD_PathStyle; -typedef struct StringJoin StringJoin; -struct StringJoin +typedef struct MD_StringJoin MD_StringJoin; +struct MD_StringJoin { - String8 pre; - String8 sep; - String8 post; + MD_String8 pre; + MD_String8 sep; + MD_String8 post; }; //////////////////////////////// //~ rjf: UTF Decoding Types -typedef struct UnicodeDecode UnicodeDecode; -struct UnicodeDecode +typedef struct MD_UnicodeDecode MD_UnicodeDecode; +struct MD_UnicodeDecode { - U32 inc; - U32 codepoint; + MD_U32 inc; + MD_U32 codepoint; }; //////////////////////////////// //~ rjf: String Fuzzy Matching Types -typedef struct FuzzyMatchRangeNode FuzzyMatchRangeNode; -struct FuzzyMatchRangeNode +typedef struct MD_FuzzyMatchRangeNode MD_FuzzyMatchRangeNode; +struct MD_FuzzyMatchRangeNode { - FuzzyMatchRangeNode* next; - Rng1U64 range; + MD_FuzzyMatchRangeNode* next; + MD_Rng1U64 range; }; -typedef struct FuzzyMatchRangeList FuzzyMatchRangeList; -struct FuzzyMatchRangeList +typedef struct MD_FuzzyMatchRangeList MD_FuzzyMatchRangeList; +struct MD_FuzzyMatchRangeList { - FuzzyMatchRangeNode* first; - FuzzyMatchRangeNode* last; - U64 count; - U64 needle_part_count; - U64 total_dim; + MD_FuzzyMatchRangeNode* first; + MD_FuzzyMatchRangeNode* last; + MD_U64 count; + MD_U64 needle_part_count; + MD_U64 total_dim; }; //////////////////////////////// //~ NOTE(allen): String <-> Integer Tables -inline U8 -integer_symbols(U8 value) { - local_persist - U8 lookup_table[16] = { +inline MD_U8 +md_integer_symbols(MD_U8 value) { + md_local_persist + MD_U8 lookup_table[16] = { '0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F', }; return lookup_table[value]; } -inline U8 -base64(U8 value) { - local_persist - U8 lookup_table[64] = { +inline MD_U8 +md_base64(MD_U8 value) { + md_local_persist + MD_U8 lookup_table[64] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', @@ -174,10 +174,10 @@ base64(U8 value) { return lookup_table[value]; } -inline U8 -base64_reverse(U8 value) { - local_persist - U8 lookup_table[128] = { +inline MD_U8 +md_base64_reverse(MD_U8 value) { + md_local_persist + MD_U8 lookup_table[128] = { 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF, 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF, 0xFF,0xFF,0xFF,0xFF,0x3F,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF, @@ -191,10 +191,10 @@ base64_reverse(U8 value) { } // NOTE(allen): Includes reverses for uppercase and lowercase hex. -inline U8 -integer_symbol_reverse(U8 value) { - local_persist - U8 lookup_table[128] = { +inline MD_U8 +md_integer_symbol_reverse(MD_U8 value) { + md_local_persist + MD_U8 lookup_table[128] = { 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF, 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF, 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF, @@ -210,20 +210,20 @@ integer_symbol_reverse(U8 value) { //////////////////////////////// //~ rjf: Character Classification & Conversion Functions -inline B32 char_is_space (U8 c) { return(c == ' ' || c == '\n' || c == '\t' || c == '\r' || c == '\f' || c == '\v'); } -inline B32 char_is_upper (U8 c) { return('A' <= c && c <= 'Z'); } -inline B32 char_is_lower (U8 c) { return('a' <= c && c <= 'z'); } -inline B32 char_is_alpha (U8 c) { return(char_is_upper(c) || char_is_lower(c)); } -inline B32 char_is_slash (U8 c) { return(c == '/' || c == '\\'); } -inline U8 char_to_lower (U8 c) { if (char_is_upper(c)) { c += ('a' - 'A'); } return(c); } -inline U8 char_to_upper (U8 c) { if (char_is_lower(c)) { c += ('A' - 'a'); } return(c); } -inline U8 char_to_correct_slash(U8 c) { if (char_is_slash(c)) { c = '/'; } return(c); } +inline MD_B32 md_char_is_space (MD_U8 c) { return(c == ' ' || c == '\n' || c == '\t' || c == '\r' || c == '\f' || c == '\v'); } +inline MD_B32 md_char_is_upper (MD_U8 c) { return('A' <= c && c <= 'Z'); } +inline MD_B32 md_char_is_lower (MD_U8 c) { return('a' <= c && c <= 'z'); } +inline MD_B32 md_char_is_alpha (MD_U8 c) { return(md_char_is_upper(c) || md_char_is_lower(c)); } +inline MD_B32 md_char_is_slash (MD_U8 c) { return(c == '/' || c == '\\'); } +inline MD_U8 md_char_to_lower (MD_U8 c) { if (md_char_is_upper(c)) { c += ('a' - 'A'); } return(c); } +inline MD_U8 md_char_to_upper (MD_U8 c) { if (md_char_is_lower(c)) { c += ('A' - 'a'); } return(c); } +inline MD_U8 md_char_to_correct_slash(MD_U8 c) { if (md_char_is_slash(c)) { c = '/'; } return(c); } -inline B32 -char_is_digit(U8 c, U32 base) { - B32 result = 0; +inline MD_B32 +md_char_is_digit(MD_U8 c, MD_U32 base) { + MD_B32 result = 0; if (0 < base && base <= 16) { - U8 val = integer_symbol_reverse(c); + MD_U8 val = md_integer_symbol_reverse(c); if (val < base) { result = 1; } @@ -234,69 +234,69 @@ char_is_digit(U8 c, U32 base) { //////////////////////////////// //~ rjf: C-String Measurement -inline U64 cstring8_length (U8* c) { U8* p = c; for (; *p != 0; p += 1); return(p - c); } -inline U64 cstring16_length(U16* c) { U16* p = c; for (; *p != 0; p += 1); return(p - c); } -inline U64 cstring32_length(U32* c) { U32* p = c; for (; *p != 0; p += 1); return(p - c); } +inline MD_U64 md_cstring8_length (MD_U8* c) { MD_U8* p = c; for (; *p != 0; p += 1); return(p - c); } +inline MD_U64 md_cstring16_length(MD_U16* c) { MD_U16* p = c; for (; *p != 0; p += 1); return(p - c); } +inline MD_U64 md_cstring32_length(MD_U32* c) { MD_U32* p = c; for (; *p != 0; p += 1); return(p - c); } -#define cstring_length(c) _Generic(c, U8*: cstring8_length, U16*: cstring16_length, U32*: cstring32_length)(c) +#define md_cstring_length(c) _Generic(c, MD_U8*: md_cstring8_length, MD_U16*: md_cstring16_length, MD_U32*: md_cstring32_length)(c) //////////////////////////////// //~ rjf: String Constructors -#define str8_lit(S) str8((U8*)(S), sizeof(S) - 1) -#define str8_lit_comp(S) { (U8*)(S), sizeof(S) - 1, } -#define str8_varg(S) (int)((S).size), ((S).str) +#define md_str8_lit(S) md_str8((MD_U8*)(S), sizeof(S) - 1) +#define md_str8_lit_comp(S) { (MD_U8*)(S), sizeof(S) - 1, } +#define md_str8_varg(S) (int)((S).size), ((S).str) -#define str8_array(S, C) str8((U8*)(S), sizeof(*(S)) * (C)) -#define str8_array_fixed(S) str8((U8*)(S), sizeof(S)) -#define str8_struct(S) str8((U8*)(S), sizeof(*(S))) +#define md_str8_array(S, C) md_str8((MD_U8*)(S), sizeof(*(S)) * (C)) +#define md_str8_array_fixed(S) md_str8((MD_U8*)(S), sizeof(S)) +#define md_str8_struct(S) md_str8((MD_U8*)(S), sizeof(*(S))) -inline String8 str8 (U8* str, U64 size) { String8 result = {str, size}; return(result); } -inline String8 str8_range (U8* first, U8* one_past_last) { String8 result = {first, (U64)(one_past_last - first)}; return(result); } -inline String8 str8_zero (void) { String8 result = {0}; return(result); } -inline String16 str16 (U16* str, U64 size) { String16 result = {str, size}; return(result); } -inline String16 str16_range (U16* first, U16* one_past_last) { String16 result = {first, (U64)(one_past_last - first)}; return(result); } -inline String16 str16_zero (void) { String16 result = {0}; return(result); } -inline String32 str32 (U32* str, U64 size) { String32 result = {str, size}; return(result); } -inline String32 str32_range (U32* first, U32* one_past_last) { String32 result = {first, (U64)(one_past_last - first)}; return(result); } -inline String32 str32_zero (void) { String32 result = {0}; return(result); } -inline String8 str8_cstring (char* c) { String8 result = {(U8*) c, cstring8_length ((U8*) c)}; return(result); } -inline String16 str16_cstring(U16* c) { String16 result = {(U16*)c, cstring16_length((U16*)c)}; return(result); } -inline String32 str32_cstring(U32* c) { String32 result = {(U32*)c, cstring32_length((U32*)c)}; return(result); } +inline MD_String8 md_str8 (MD_U8* str, MD_U64 size) { MD_String8 result = {str, size}; return(result); } +inline MD_String8 md_str8_range (MD_U8* first, MD_U8* one_past_last) { MD_String8 result = {first, (MD_U64)(one_past_last - first)}; return(result); } +inline MD_String8 md_str8_zero (void) { MD_String8 result = {0}; return(result); } +inline MD_String16 md_str16 (MD_U16* str, MD_U64 size) { MD_String16 result = {str, size}; return(result); } +inline MD_String16 md_str16_range (MD_U16* first, MD_U16* one_past_last) { MD_String16 result = {first, (MD_U64)(one_past_last - first)}; return(result); } +inline MD_String16 md_str16_zero (void) { MD_String16 result = {0}; return(result); } +inline MD_String32 str32 (MD_U32* str, MD_U64 size) { MD_String32 result = {str, size}; return(result); } +inline MD_String32 md_str32_range (MD_U32* first, MD_U32* one_past_last) { MD_String32 result = {first, (MD_U64)(one_past_last - first)}; return(result); } +inline MD_String32 md_str32_zero (void) { MD_String32 result = {0}; return(result); } +inline MD_String8 md_str8_cstring (char* c) { MD_String8 result = {(MD_U8*) c, md_cstring8_length ((MD_U8*) c)}; return(result); } +inline MD_String16 md_str16_cstring(MD_U16* c) { MD_String16 result = {(MD_U16*)c, md_cstring16_length((MD_U16*)c)}; return(result); } +inline MD_String32 md_str32_cstring(MD_U32* c) { MD_String32 result = {(MD_U32*)c, md_cstring32_length((MD_U32*)c)}; return(result); } -#define str_range(str, one_past_last) _Generic(str, U8: str8_range, U16: str16_range, U32: str32_range )(str, one_past_last) -#define str_cstring(c) _Generic(c, U8: str8_cstring, U16: str16_cstring, U32: str32_cstring)(c) +#define md_str_range(str, one_past_last) _Generic(str, MD_U8: md_str8_range, MD_U16: md_str16_range, MD_U32: md_str32_range )(str, one_past_last) +#define md_str_cstring(c) _Generic(c, MD_U8: md_str8_cstring, MD_U16: md_str16_cstring, MD_U32: md_str32_cstring)(c) -String8 str8_cstring_capped (void* cstr, void* cap); -String16 str16_cstring_capped (void* cstr, void* cap); -String8 str8_cstring_capped_reverse(void* raw_start, void* raw_cap); +MD_String8 md_str8_cstring_capped (void* cstr, void* cap); +MD_String16 md_str16_cstring_capped (void* cstr, void* cap); +MD_String8 md_str8_cstring_capped_reverse(void* raw_start, void* raw_cap); -inline String8 -str8_cstring_capped(void* cstr, void* cap) { +inline MD_String8 +md_str8_cstring_capped(void* cstr, void* cap) { char* ptr = (char*)cstr; char* opl = (char*)cap; for (;ptr < opl && *ptr != 0; ptr += 1); - U64 size = (U64)(ptr - (char *)cstr); - String8 result = {(U8*)cstr, size}; + MD_U64 size = (MD_U64)(ptr - (char *)cstr); + MD_String8 result = {(MD_U8*)cstr, size}; return result; } -inline String16 -str16_cstring_capped(void* cstr, void* cap) +inline MD_String16 +md_str16_cstring_capped(void* cstr, void* cap) { - U16* ptr = (U16*)cstr; - U16* opl = (U16*)cap; + MD_U16* ptr = (MD_U16*)cstr; + MD_U16* opl = (MD_U16*)cap; for (;ptr < opl && *ptr != 0; ptr += 1); - U64 size = (U64)(ptr - (U16 *)cstr); - String16 result = str16(cstr, size); + MD_U64 size = (MD_U64)(ptr - (MD_U16 *)cstr); + MD_String16 result = md_str16(cstr, size); return result; } -inline String8 -str8_cstring_capped_reverse(void* raw_start, void* raw_cap) +inline MD_String8 +md_str8_cstring_capped_reverse(void* raw_start, void* raw_cap) { - U8* start = raw_start; - U8* ptr = raw_cap; + MD_U8* start = raw_start; + MD_U8* ptr = raw_cap; for (; ptr > start; ) { ptr -= 1; @@ -304,47 +304,47 @@ str8_cstring_capped_reverse(void* raw_start, void* raw_cap) break; } } - U64 size = (U64)(ptr - start); - String8 result = str8(start, size); + MD_U64 size = (MD_U64)(ptr - start); + MD_String8 result = md_str8(start, size); return result; } //////////////////////////////// //~ rjf: String Formatting & Copying -String8 str8_cat__arena (Arena* arena, String8 s1, String8 s2); -String8 str8_copy__arena(Arena* arena, String8 s); -String8 str8fv__arena (Arena* arena, char* fmt, va_list args); -String8 str8f__arena (Arena* arena, char* fmt, ...); +MD_String8 md_str8_cat__arena (MD_Arena* arena, MD_String8 s1, MD_String8 s2); +MD_String8 md_str8_copy__arena(MD_Arena* arena, MD_String8 s); +MD_String8 md_str8fv__arena (MD_Arena* arena, char* fmt, va_list args); +MD_String8 md_str8f__arena (MD_Arena* arena, char* fmt, ...); -MD_API String8 str8_cat__ainfo (AllocatorInfo ainfo, String8 s1, String8 s2); -MD_API String8 str8_copy__ainfo(AllocatorInfo ainfo, String8 s); -MD_API String8 str8fv__ainfo (AllocatorInfo ainfo, char* fmt, va_list args); - String8 str8f__ainfo (AllocatorInfo ainfo, char* fmt, ...); +MD_API MD_String8 md_str8_cat__ainfo (MD_AllocatorInfo ainfo, MD_String8 s1, MD_String8 s2); +MD_API MD_String8 md_str8_copy__ainfo(MD_AllocatorInfo ainfo, MD_String8 s); +MD_API MD_String8 md_str8fv__ainfo (MD_AllocatorInfo ainfo, char* fmt, va_list args); + MD_String8 md_str8f__ainfo (MD_AllocatorInfo ainfo, char* fmt, ...); -#define str8_cat(allocator, s1, s2) _Generic(allocator, Arena*: str8_cat__arena, AllocatorInfo: str8_cat__ainfo, default: assert_generic_sel_fail) generic_call(allocator, s1, s2) -#define str8_copy(allocator, s) _Generic(allocator, Arena*: str8_copy__arena, AllocatorInfo: str8_copy__ainfo, default: assert_generic_sel_fail) generic_call(allocator, s) -#define str8fv(allocator, fmt, args) _Generic(allocator, Arena*: str8fv__arena, AllocatorInfo: str8fv__ainfo , default: assert_generic_sel_fail) generic_call(allocator, fmt, args) -#define str8f(allocator, fmt, ...) _Generic(allocator, Arena*: str8f__arena, AllocatorInfo: str8f__ainfo , default: assert_generic_sel_fail) generic_call(allocator, fmt, __VA_ARGS__) +#define md_str8_cat(allocator, s1, s2) _Generic(allocator, MD_Arena*: md_str8_cat__arena, MD_AllocatorInfo: md_str8_cat__ainfo, default: md_assert_generic_sel_fail) md_generic_call(allocator, s1, s2) +#define md_str8_copy(allocator, s) _Generic(allocator, MD_Arena*: md_str8_copy__arena, MD_AllocatorInfo: md_str8_copy__ainfo, default: md_assert_generic_sel_fail) md_generic_call(allocator, s) +#define md_str8fv(allocator, fmt, args) _Generic(allocator, MD_Arena*: md_str8fv__arena, MD_AllocatorInfo: md_str8fv__ainfo , default: md_assert_generic_sel_fail) md_generic_call(allocator, fmt, args) +#define md_str8f(allocator, fmt, ...) _Generic(allocator, MD_Arena*: md_str8f__arena, MD_AllocatorInfo: md_str8f__ainfo , default: md_assert_generic_sel_fail) md_generic_call(allocator, fmt, __VA_ARGS__) -force_inline String8 str8_cat__arena (Arena* arena, String8 s1, String8 s2) { return str8_cat__ainfo (arena_allocator(arena), s1, s2); } -force_inline String8 str8_copy__arena(Arena* arena, String8 s) { return str8_copy__ainfo(arena_allocator(arena), s); } -force_inline String8 str8fv__arena (Arena* arena, char* fmt, va_list args){ return str8fv__ainfo (arena_allocator(arena), fmt, args); } +md_force_inline MD_String8 md_str8_cat__arena (MD_Arena* arena, MD_String8 s1, MD_String8 s2) { return md_str8_cat__ainfo (md_arena_allocator(arena), s1, s2); } +md_force_inline MD_String8 md_str8_copy__arena(MD_Arena* arena, MD_String8 s) { return md_str8_copy__ainfo(md_arena_allocator(arena), s); } +md_force_inline MD_String8 md_str8fv__arena (MD_Arena* arena, char* fmt, va_list args){ return md_str8fv__ainfo (md_arena_allocator(arena), fmt, args); } -inline String8 -str8f__arena(Arena *arena, char *fmt, ...) { +inline MD_String8 +md_str8f__arena(MD_Arena *arena, char *fmt, ...) { va_list args; va_start(args, fmt); - String8 result = str8fv(arena, fmt, args); + MD_String8 result = md_str8fv(arena, fmt, args); va_end(args); return(result); } -inline String8 -str8f__ainfo(AllocatorInfo ainfo, char *fmt, ...) { +inline MD_String8 +md_str8f__ainfo(MD_AllocatorInfo ainfo, char *fmt, ...) { va_list args; va_start(args, fmt); - String8 result = str8fv(ainfo, fmt, args); + MD_String8 result = md_str8fv(ainfo, fmt, args); va_end(args); return(result); } @@ -352,48 +352,48 @@ str8f__ainfo(AllocatorInfo ainfo, char *fmt, ...) { //////////////////////////////// //~ rjf: String Slicing -MD_API String8 str8_skip_chop_whitespace(String8 string); +MD_API MD_String8 md_str8_skip_chop_whitespace(MD_String8 string); -String8 str8_substr (String8 str, Rng1U64 range); -String8 str8_prefix (String8 str, U64 size); -String8 str8_skip (String8 str, U64 amt); -String8 str8_postfix(String8 str, U64 size); -String8 str8_chop (String8 str, U64 amt); +MD_String8 md_str8_substr (MD_String8 str, MD_Rng1U64 range); +MD_String8 md_str8_prefix (MD_String8 str, MD_U64 size); +MD_String8 md_str8_skip (MD_String8 str, MD_U64 amt); +MD_String8 md_str8_postfix(MD_String8 str, MD_U64 size); +MD_String8 md_str8_chop (MD_String8 str, MD_U64 amt); -inline String8 -str8_substr(String8 str, Rng1U64 range){ - range.min = clamp_top(range.min, str.size); - range.max = clamp_top(range.max, str.size); - str.str += range.min; - str.size = dim_1u64(range); +inline MD_String8 +md_str8_substr(MD_String8 str, MD_Rng1U64 range){ + range.md_min = md_clamp_top(range.md_min, str.size); + range.md_max = md_clamp_top(range.md_max, str.size); + str.str += range.md_min; + str.size = md_dim_1u64(range); return(str); } -inline String8 -str8_prefix(String8 str, U64 size){ - str.size = clamp_top(size, str.size); +inline MD_String8 +md_str8_prefix(MD_String8 str, MD_U64 size){ + str.size = md_clamp_top(size, str.size); return(str); } -inline String8 -str8_skip(String8 str, U64 amt){ - amt = clamp_top(amt, str.size); +inline MD_String8 +md_str8_skip(MD_String8 str, MD_U64 amt){ + amt = md_clamp_top(amt, str.size); str.str += amt; str.size -= amt; return(str); } -inline String8 -str8_postfix(String8 str, U64 size){ - size = clamp_top(size, str.size); +inline MD_String8 +md_str8_postfix(MD_String8 str, MD_U64 size){ + size = md_clamp_top(size, str.size); str.str = (str.str + str.size) - size; str.size = size; return(str); } -inline String8 -str8_chop(String8 str, U64 amt){ - amt = clamp_top(amt, str.size); +inline MD_String8 +md_str8_chop(MD_String8 str, MD_U64 amt){ + amt = md_clamp_top(amt, str.size); str.size -= amt; return(str); } @@ -401,34 +401,34 @@ str8_chop(String8 str, U64 amt){ //////////////////////////////// //~ rjf: String Stylization -inline String8 upper_from_str8__arena (Arena* arena, String8 string) { string = str8_copy(arena, string); for(U64 idx = 0; idx < string.size; idx += 1) { string.str[idx] = char_to_upper(string.str[idx]); } return string; } -inline String8 lower_from_str8__arena (Arena* arena, String8 string) { string = str8_copy(arena, string); for(U64 idx = 0; idx < string.size; idx += 1) { string.str[idx] = char_to_lower(string.str[idx]); } return string; } -inline String8 backslashed_from_str8__arena(Arena* arena, String8 string) { string = str8_copy(arena, string); for(U64 idx = 0; idx < string.size; idx += 1) { string.str[idx] = char_is_slash(string.str[idx]) ? '\\' : string.str[idx]; } return string; } +inline MD_String8 md_upper_fromstr8__arena (MD_Arena* arena, MD_String8 string) { string = md_str8_copy(arena, string); for(MD_U64 idx = 0; idx < string.size; idx += 1) { string.str[idx] = md_char_to_upper(string.str[idx]); } return string; } +inline MD_String8 md_lower_fromstr8__arena (MD_Arena* arena, MD_String8 string) { string = md_str8_copy(arena, string); for(MD_U64 idx = 0; idx < string.size; idx += 1) { string.str[idx] = md_char_to_lower(string.str[idx]); } return string; } +inline MD_String8 md_backslashed_from_str8__arena(MD_Arena* arena, MD_String8 string) { string = md_str8_copy(arena, string); for(MD_U64 idx = 0; idx < string.size; idx += 1) { string.str[idx] = md_char_is_slash(string.str[idx]) ? '\\' : string.str[idx]; } return string; } -inline String8 upper_from_str8__ainfo (AllocatorInfo ainfo, String8 string) { string = str8_copy(ainfo, string); for(U64 idx = 0; idx < string.size; idx += 1) { string.str[idx] = char_to_upper(string.str[idx]); } return string; } -inline String8 lower_from_str8__ainfo (AllocatorInfo ainfo, String8 string) { string = str8_copy(ainfo, string); for(U64 idx = 0; idx < string.size; idx += 1) { string.str[idx] = char_to_lower(string.str[idx]); } return string; } -inline String8 backslashed_from_str8__ainfo(AllocatorInfo ainfo, String8 string) { string = str8_copy(ainfo, string); for(U64 idx = 0; idx < string.size; idx += 1) { string.str[idx] = char_is_slash(string.str[idx]) ? '\\' : string.str[idx]; } return string; } +inline MD_String8 md_upper_fromstr8__ainfo (MD_AllocatorInfo ainfo, MD_String8 string) { string = md_str8_copy(ainfo, string); for(MD_U64 idx = 0; idx < string.size; idx += 1) { string.str[idx] = md_char_to_upper(string.str[idx]); } return string; } +inline MD_String8 md_lower_fromstr8__ainfo (MD_AllocatorInfo ainfo, MD_String8 string) { string = md_str8_copy(ainfo, string); for(MD_U64 idx = 0; idx < string.size; idx += 1) { string.str[idx] = md_char_to_lower(string.str[idx]); } return string; } +inline MD_String8 md_backslashed_from_str8__ainfo(MD_AllocatorInfo ainfo, MD_String8 string) { string = md_str8_copy(ainfo, string); for(MD_U64 idx = 0; idx < string.size; idx += 1) { string.str[idx] = md_char_is_slash(string.str[idx]) ? '\\' : string.str[idx]; } return string; } -#define upper_from_str8(allocator, string) _Generic(allocator, Arena*: upper_from_str8__arena, AllocatorInfo: upper_from_str8__ainfo, default: assert_generic_sel_fail) generic_call(allocator, string) -#define lower_from_str8(allocator, string) _Generic(allocator, Arena*: lower_from_str8__arena, AllocatorInfo: lower_from_str8__ainfo, default: assert_generic_sel_fail) generic_call(allocator, string) -#define backslashed_from_str8(allocator, string) _Generic(allocator, Arena*: backslashed_from_str8__arena, AllocatorInfo: backslashed_from_str8__ainfo , default: assert_generic_sel_fail) generic_call(allocator, string) +#define md_upper_fromstr8(allocator, string) _Generic(allocator, MD_Arena*: md_upper_fromstr8__arena, MD_AllocatorInfo: md_upper_fromstr8__ainfo, default: md_assert_generic_sel_fail) md_generic_call(allocator, string) +#define md_lower_fromstr8(allocator, string) _Generic(allocator, MD_Arena*: md_lower_fromstr8__arena, MD_AllocatorInfo: md_lower_fromstr8__ainfo, default: md_assert_generic_sel_fail) md_generic_call(allocator, string) +#define md_backslashed_from_str8(allocator, string) _Generic(allocator, MD_Arena*: md_backslashed_from_str8__arena, MD_AllocatorInfo: md_backslashed_from_str8__ainfo , default: md_assert_generic_sel_fail) md_generic_call(allocator, string) //////////////////////////////// //~ rjf: String Matching -#define str8_match_lit(a_lit, b, flags) str8_match(str8_lit(a_lit), (b), (flags)) -#define str8_match_cstr(a_cstr, b, flags) str8_match(str8_cstring(a_cstr), (b), (flags)) -#define str8_ends_with_lit(string, end_lit, flags) str8_ends_with((string), str8_lit(end_lit), (flags)) +#define md_str8_match_lit(a_lit, b, flags) md_str8_match(md_str8_lit(a_lit), (b), (flags)) +#define md_str8_match_cstr(a_cstr, b, flags) md_str8_match(md_str8_cstring(a_cstr), (b), (flags)) +#define md_str8_ends_with_lit(string, end_lit, flags) md_str8_ends_with((string), md_str8_lit(end_lit), (flags)) -MD_API B32 str8_match (String8 a, String8 b, StringMatchFlags flags); -MD_API U64 str8_find_needle (String8 string, U64 start_pos, String8 needle, StringMatchFlags flags); -MD_API U64 str8_find_needle_reverse(String8 string, U64 start_pos, String8 needle, StringMatchFlags flags); - B32 str8_ends_with (String8 string, String8 end, StringMatchFlags flags); +MD_API MD_B32 md_str8_match (MD_String8 a, MD_String8 b, MD_StringMatchFlags flags); +MD_API MD_U64 md_str8_find_needle (MD_String8 string, MD_U64 start_pos, MD_String8 needle, MD_StringMatchFlags flags); +MD_API MD_U64 md_str8_find_needle_reverse(MD_String8 string, MD_U64 start_pos, MD_String8 needle, MD_StringMatchFlags flags); + MD_B32 md_str8_ends_with (MD_String8 string, MD_String8 end, MD_StringMatchFlags flags); -inline B32 -str8_ends_with(String8 string, String8 end, StringMatchFlags flags) { - String8 postfix = str8_postfix(string, end.size); - B32 is_match = str8_match(end, postfix, flags); +inline MD_B32 +md_str8_ends_with(MD_String8 string, MD_String8 end, MD_StringMatchFlags flags) { + MD_String8 postfix = md_str8_postfix(string, end.size); + MD_B32 is_match = md_str8_match(end, postfix, flags); return is_match; } @@ -436,161 +436,161 @@ str8_ends_with(String8 string, String8 end, StringMatchFlags flags) { //~ rjf: String <=> Integer Conversions //- rjf: string -> integer -MD_API S64 sign_from_str8 (String8 string, String8* string_tail); -MD_API B32 str8_is_integer(String8 string, U32 radix); - U64 u64_from_str8 (String8 string, U32 radix); - S64 s64_from_str8 (String8 string, U32 radix); - U32 u32_from_str8 (String8 string, U32 radix); - S32 s32_from_str8 (String8 string, U32 radix); +MD_API MD_S64 md_sign_from_str8 (MD_String8 string, MD_String8* md_string_tail); +MD_API MD_B32 md_str8_is_integer(MD_String8 string, MD_U32 radix); + MD_U64 md_u64_from_str8 (MD_String8 string, MD_U32 radix); + MD_S64 md_s64_from_str8 (MD_String8 string, MD_U32 radix); + MD_U32 md_u32_from_str8 (MD_String8 string, MD_U32 radix); + MD_S32 s32_from_str8 (MD_String8 string, MD_U32 radix); -MD_API B32 try_u64_from_str8_c_rules(String8 string, U64* x); - B32 try_s64_from_str8_c_rules(String8 string, S64* x); +MD_API MD_B32 md_try_u64_from_str8_c_rules(MD_String8 string, MD_U64* x); + MD_B32 md_try_s64_from_str8_c_rules(MD_String8 string, MD_S64* x); //- rjf: integer -> string -String8 str8_from_memory_size__arena(Arena* arena, SSIZE z); -String8 str8_from_u64__arena (Arena* arena, U64 u64, U32 radix, U8 min_digits, U8 digit_group_separator); -String8 str8_from_s64__arena (Arena* arena, S64 s64, U32 radix, U8 min_digits, U8 digit_group_separator); +MD_String8 md_str8_from_memory_size__arena(MD_Arena* arena, MD_SSIZE z); +MD_String8 md_str8_from_u64__arena (MD_Arena* arena, MD_U64 u64, MD_U32 radix, MD_U8 min_digits, MD_U8 digit_group_separator); +MD_String8 md_str8_from_s64__arena (MD_Arena* arena, MD_S64 s64, MD_U32 radix, MD_U8 min_digits, MD_U8 digit_group_separator); -String8 str8_from_bits_u32__arena(Arena* arena, U32 x); -String8 str8_from_bits_u64__arena(Arena* arena, U64 x); +MD_String8 md_str8_from_bits_u32__arena(MD_Arena* arena, MD_U32 x); +MD_String8 md_str8_from_bits_u64__arena(MD_Arena* arena, MD_U64 x); -MD_API String8 str8_from_memory_size__ainfo(AllocatorInfo ainfo, SSIZE z); -MD_API String8 str8_from_u64__ainfo (AllocatorInfo ainfo, U64 u64, U32 radix, U8 min_digits, U8 digit_group_separator); -MD_API String8 str8_from_s64__ainfo (AllocatorInfo ainfo, S64 u64, U32 radix, U8 min_digits, U8 digit_group_separator); +MD_API MD_String8 md_str8_from_memory_size__ainfo(MD_AllocatorInfo ainfo, MD_SSIZE z); +MD_API MD_String8 md_str8_from_u64__ainfo (MD_AllocatorInfo ainfo, MD_U64 u64, MD_U32 radix, MD_U8 min_digits, MD_U8 digit_group_separator); +MD_API MD_String8 md_str8_from_s64__ainfo (MD_AllocatorInfo ainfo, MD_S64 u64, MD_U32 radix, MD_U8 min_digits, MD_U8 digit_group_separator); -String8 str8_from_bits_u32__ainfo(AllocatorInfo ainfo, U32 x); -String8 str8_from_bits_u64__ainfo(AllocatorInfo ainfo, U64 x); +MD_String8 md_str8_from_bits_u32__ainfo(MD_AllocatorInfo ainfo, MD_U32 x); +MD_String8 md_str8_from_bits_u64__ainfo(MD_AllocatorInfo ainfo, MD_U64 x); -#define str8_from_memory_size(allocator, z) _Generic(allocator, Arena*: str8_from_memory_size__arena, AllocatorInfo: str8_from_memory_size__ainfo, default: assert_generic_sel_fail) generic_call(allocator, z) -#define str8_from_u64(allocator, u64, radix, min_digits, digit_group_separator) _Generic(allocator, Arena*: str8_from_u64__arena, AllocatorInfo: str8_from_u64__ainfo, default: assert_generic_sel_fail) generic_call(allocator, u64, radix, min_digits, digit_group_separator) -#define str8_from_s64(allocator, s64, radix, min_digits, digit_group_separator) _Generic(allocator, Arena*: str8_from_s64__arena, AllocatorInfo: str8_from_s64__ainfo , default: assert_generic_sel_fail) generic_call(allocator, s64, radix, min_digits, digit_group_separator) +#define md_str8_from_memory_size(allocator, z) _Generic(allocator, MD_Arena*: md_str8_from_memory_size__arena, MD_AllocatorInfo: md_str8_from_memory_size__ainfo, default: md_assert_generic_sel_fail) md_generic_call(allocator, z) +#define md_str8_from_u64(allocator, u64, radix, min_digits, digit_group_separator) _Generic(allocator, MD_Arena*: md_str8_from_u64__arena, MD_AllocatorInfo: md_str8_from_u64__ainfo, default: md_assert_generic_sel_fail) md_generic_call(allocator, u64, radix, min_digits, digit_group_separator) +#define md_str8_from_s64(allocator, s64, radix, min_digits, digit_group_separator) _Generic(allocator, MD_Arena*: md_str8_from_s64__arena, MD_AllocatorInfo: md_str8_from_s64__ainfo , default: md_assert_generic_sel_fail) md_generic_call(allocator, s64, radix, min_digits, digit_group_separator) -#define str8_from_bits_u32(allocator, x) _Generic(allocator, Arena*: str8_from_bits_u32__arena, AllocatorInfo: str8_from_bits_u32__ainfo, default: assert_generic_sel_fail) generic_call(allocator, x) -#define str8_from_bits_u64(allocator, x) _Generic(allocator, Arena*: str8_from_bits_u64__arena, AllocatorInfo: str8_from_bits_u64__ainfo, default: assert_generic_sel_fail) generic_call(allocator, x) +#define md_str8_from_bits_u32(allocator, x) _Generic(allocator, MD_Arena*: md_str8_from_bits_u32__arena, MD_AllocatorInfo: md_str8_from_bits_u32__ainfo, default: md_assert_generic_sel_fail) md_generic_call(allocator, x) +#define md_str8_from_bits_u64(allocator, x) _Generic(allocator, MD_Arena*: md_str8_from_bits_u64__arena, MD_AllocatorInfo: md_str8_from_bits_u64__ainfo, default: md_assert_generic_sel_fail) md_generic_call(allocator, x) -force_inline String8 str8_from_memory_size__arena(Arena* arena, SSIZE z) { return str8_from_memory_size__ainfo(arena_allocator(arena), z); } -force_inline String8 str8_from_u64__arena (Arena* arena, U64 u64, U32 radix, U8 min_digits, U8 digit_group_separator) { return str8_from_u64__ainfo (arena_allocator(arena), u64, radix, min_digits, digit_group_separator); } -force_inline String8 str8_from_s64__arena (Arena* arena, S64 s64, U32 radix, U8 min_digits, U8 digit_group_separator) { return str8_from_s64__ainfo (arena_allocator(arena), s64, radix, min_digits, digit_group_separator); } +md_force_inline MD_String8 md_str8_from_memory_size__arena(MD_Arena* arena, MD_SSIZE z) { return md_str8_from_memory_size__ainfo(md_arena_allocator(arena), z); } +md_force_inline MD_String8 md_str8_from_u64__arena (MD_Arena* arena, MD_U64 u64, MD_U32 radix, MD_U8 min_digits, MD_U8 digit_group_separator) { return md_str8_from_u64__ainfo (md_arena_allocator(arena), u64, radix, min_digits, digit_group_separator); } +md_force_inline MD_String8 md_str8_from_s64__arena (MD_Arena* arena, MD_S64 s64, MD_U32 radix, MD_U8 min_digits, MD_U8 digit_group_separator) { return md_str8_from_s64__ainfo (md_arena_allocator(arena), s64, radix, min_digits, digit_group_separator); } -inline S64 -s64_from_str8(String8 string, U32 radix) { - S64 sign = sign_from_str8(string, &string); - S64 x = (S64)u64_from_str8(string, radix) * sign; +inline MD_S64 +md_s64_from_str8(MD_String8 string, MD_U32 radix) { + MD_S64 sign = md_sign_from_str8(string, &string); + MD_S64 x = (MD_S64)md_u64_from_str8(string, radix) * sign; return(x); } -inline U64 -u64_from_str8(String8 string, U32 radix) { - U64 x = 0; +inline MD_U64 +md_u64_from_str8(MD_String8 string, MD_U32 radix) { + MD_U64 x = 0; if (1 < radix && radix <= 16) { - for (U64 i = 0; i < string.size; i += 1) { + for (MD_U64 i = 0; i < string.size; i += 1) { x *= radix; - x += integer_symbol_reverse(string.str[i]&0x7F); + x += md_integer_symbol_reverse(string.str[i]&0x7F); } } return(x); } -inline U32 -u32_from_str8(String8 string, U32 radix) { - U64 x64 = u64_from_str8(string, radix); - U32 x32 = safe_cast_u32(x64); +inline MD_U32 +md_u32_from_str8(MD_String8 string, MD_U32 radix) { + MD_U64 x64 = md_u64_from_str8(string, radix); + MD_U32 x32 = md_safe_cast_u32(x64); return x32; } -inline S32 -s32_from_str8(String8 string, U32 radix) { - S64 x64 = s64_from_str8(string, radix); - S32 x32 = safe_cast_s32(x64); +inline MD_S32 +s32_from_str8(MD_String8 string, MD_U32 radix) { + MD_S64 x64 = md_s64_from_str8(string, radix); + MD_S32 x32 = md_safe_cast_s32(x64); return x32; } -inline B32 -try_s64_from_str8_c_rules(String8 string, S64* x) { - String8 string_tail = {0}; - S64 sign = sign_from_str8(string, &string_tail); - U64 x_u64 = 0; - B32 is_integer = try_u64_from_str8_c_rules(string_tail, &x_u64); +inline MD_B32 +md_try_s64_from_str8_c_rules(MD_String8 string, MD_S64* x) { + MD_String8 md_string_tail = {0}; + MD_S64 sign = md_sign_from_str8(string, &md_string_tail); + MD_U64 x_u64 = 0; + MD_B32 is_integer = md_try_u64_from_str8_c_rules(md_string_tail, &x_u64); *x = x_u64*sign; return(is_integer); } -inline String8 -str8_from_bits_u32__arena(Arena* arena, U32 x) +inline MD_String8 +md_str8_from_bits_u32__arena(MD_Arena* arena, MD_U32 x) { - U8 c0 = 'a' + ((x >> 28) & 0xf); - U8 c1 = 'a' + ((x >> 24) & 0xf); - U8 c2 = 'a' + ((x >> 20) & 0xf); - U8 c3 = 'a' + ((x >> 16) & 0xf); - U8 c4 = 'a' + ((x >> 12) & 0xf); - U8 c5 = 'a' + ((x >> 8) & 0xf); - U8 c6 = 'a' + ((x >> 4) & 0xf); - U8 c7 = 'a' + ((x >> 0) & 0xf); - String8 result = str8f(arena, "%c%c%c%c%c%c%c%c", c0, c1, c2, c3, c4, c5, c6, c7); + MD_U8 c0 = 'a' + ((x >> 28) & 0xf); + MD_U8 c1 = 'a' + ((x >> 24) & 0xf); + MD_U8 c2 = 'a' + ((x >> 20) & 0xf); + MD_U8 c3 = 'a' + ((x >> 16) & 0xf); + MD_U8 c4 = 'a' + ((x >> 12) & 0xf); + MD_U8 c5 = 'a' + ((x >> 8) & 0xf); + MD_U8 c6 = 'a' + ((x >> 4) & 0xf); + MD_U8 c7 = 'a' + ((x >> 0) & 0xf); + MD_String8 result = md_str8f(arena, "%c%c%c%c%c%c%c%c", c0, c1, c2, c3, c4, c5, c6, c7); return result; } -inline String8 -str8_from_bits_u64__arena(Arena* arena, U64 x) +inline MD_String8 +md_str8_from_bits_u64__arena(MD_Arena* arena, MD_U64 x) { - U8 c0 = 'a' + ((x >> 60) & 0xf); - U8 c1 = 'a' + ((x >> 56) & 0xf); - U8 c2 = 'a' + ((x >> 52) & 0xf); - U8 c3 = 'a' + ((x >> 48) & 0xf); - U8 c4 = 'a' + ((x >> 44) & 0xf); - U8 c5 = 'a' + ((x >> 40) & 0xf); - U8 c6 = 'a' + ((x >> 36) & 0xf); - U8 c7 = 'a' + ((x >> 32) & 0xf); - U8 c8 = 'a' + ((x >> 28) & 0xf); - U8 c9 = 'a' + ((x >> 24) & 0xf); - U8 ca = 'a' + ((x >> 20) & 0xf); - U8 cb = 'a' + ((x >> 16) & 0xf); - U8 cc = 'a' + ((x >> 12) & 0xf); - U8 cd = 'a' + ((x >> 8) & 0xf); - U8 ce = 'a' + ((x >> 4) & 0xf); - U8 cf = 'a' + ((x >> 0) & 0xf); - String8 result = str8f(arena, + MD_U8 c0 = 'a' + ((x >> 60) & 0xf); + MD_U8 c1 = 'a' + ((x >> 56) & 0xf); + MD_U8 c2 = 'a' + ((x >> 52) & 0xf); + MD_U8 c3 = 'a' + ((x >> 48) & 0xf); + MD_U8 c4 = 'a' + ((x >> 44) & 0xf); + MD_U8 c5 = 'a' + ((x >> 40) & 0xf); + MD_U8 c6 = 'a' + ((x >> 36) & 0xf); + MD_U8 c7 = 'a' + ((x >> 32) & 0xf); + MD_U8 c8 = 'a' + ((x >> 28) & 0xf); + MD_U8 c9 = 'a' + ((x >> 24) & 0xf); + MD_U8 ca = 'a' + ((x >> 20) & 0xf); + MD_U8 cb = 'a' + ((x >> 16) & 0xf); + MD_U8 cc = 'a' + ((x >> 12) & 0xf); + MD_U8 cd = 'a' + ((x >> 8) & 0xf); + MD_U8 ce = 'a' + ((x >> 4) & 0xf); + MD_U8 cf = 'a' + ((x >> 0) & 0xf); + MD_String8 result = md_str8f(arena, "%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c", c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, ca, cb, cc, cd, ce, cf ); return result; } -inline String8 -str8_from_bits_u32__ainfo(AllocatorInfo ainfo, U32 x) +inline MD_String8 +md_str8_from_bits_u32__ainfo(MD_AllocatorInfo ainfo, MD_U32 x) { - U8 c0 = 'a' + ((x >> 28) & 0xf); - U8 c1 = 'a' + ((x >> 24) & 0xf); - U8 c2 = 'a' + ((x >> 20) & 0xf); - U8 c3 = 'a' + ((x >> 16) & 0xf); - U8 c4 = 'a' + ((x >> 12) & 0xf); - U8 c5 = 'a' + ((x >> 8) & 0xf); - U8 c6 = 'a' + ((x >> 4) & 0xf); - U8 c7 = 'a' + ((x >> 0) & 0xf); - String8 result = str8f(ainfo, "%c%c%c%c%c%c%c%c", c0, c1, c2, c3, c4, c5, c6, c7); + MD_U8 c0 = 'a' + ((x >> 28) & 0xf); + MD_U8 c1 = 'a' + ((x >> 24) & 0xf); + MD_U8 c2 = 'a' + ((x >> 20) & 0xf); + MD_U8 c3 = 'a' + ((x >> 16) & 0xf); + MD_U8 c4 = 'a' + ((x >> 12) & 0xf); + MD_U8 c5 = 'a' + ((x >> 8) & 0xf); + MD_U8 c6 = 'a' + ((x >> 4) & 0xf); + MD_U8 c7 = 'a' + ((x >> 0) & 0xf); + MD_String8 result = md_str8f(ainfo, "%c%c%c%c%c%c%c%c", c0, c1, c2, c3, c4, c5, c6, c7); return result; } -inline String8 -str8_from_bits_u64__ainfo(AllocatorInfo ainfo, U64 x) +inline MD_String8 +md_str8_from_bits_u64__ainfo(MD_AllocatorInfo ainfo, MD_U64 x) { - U8 c0 = 'a' + ((x >> 60) & 0xf); - U8 c1 = 'a' + ((x >> 56) & 0xf); - U8 c2 = 'a' + ((x >> 52) & 0xf); - U8 c3 = 'a' + ((x >> 48) & 0xf); - U8 c4 = 'a' + ((x >> 44) & 0xf); - U8 c5 = 'a' + ((x >> 40) & 0xf); - U8 c6 = 'a' + ((x >> 36) & 0xf); - U8 c7 = 'a' + ((x >> 32) & 0xf); - U8 c8 = 'a' + ((x >> 28) & 0xf); - U8 c9 = 'a' + ((x >> 24) & 0xf); - U8 ca = 'a' + ((x >> 20) & 0xf); - U8 cb = 'a' + ((x >> 16) & 0xf); - U8 cc = 'a' + ((x >> 12) & 0xf); - U8 cd = 'a' + ((x >> 8) & 0xf); - U8 ce = 'a' + ((x >> 4) & 0xf); - U8 cf = 'a' + ((x >> 0) & 0xf); - String8 result = str8f(ainfo, + MD_U8 c0 = 'a' + ((x >> 60) & 0xf); + MD_U8 c1 = 'a' + ((x >> 56) & 0xf); + MD_U8 c2 = 'a' + ((x >> 52) & 0xf); + MD_U8 c3 = 'a' + ((x >> 48) & 0xf); + MD_U8 c4 = 'a' + ((x >> 44) & 0xf); + MD_U8 c5 = 'a' + ((x >> 40) & 0xf); + MD_U8 c6 = 'a' + ((x >> 36) & 0xf); + MD_U8 c7 = 'a' + ((x >> 32) & 0xf); + MD_U8 c8 = 'a' + ((x >> 28) & 0xf); + MD_U8 c9 = 'a' + ((x >> 24) & 0xf); + MD_U8 ca = 'a' + ((x >> 20) & 0xf); + MD_U8 cb = 'a' + ((x >> 16) & 0xf); + MD_U8 cc = 'a' + ((x >> 12) & 0xf); + MD_U8 cd = 'a' + ((x >> 8) & 0xf); + MD_U8 ce = 'a' + ((x >> 4) & 0xf); + MD_U8 cf = 'a' + ((x >> 0) & 0xf); + MD_String8 result = md_str8f(ainfo, "%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c", c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, ca, cb, cc, cd, ce, cf ); @@ -600,131 +600,131 @@ str8_from_bits_u64__ainfo(AllocatorInfo ainfo, U64 x) //////////////////////////////// //~ rjf: String <=> Float Conversions -F64 f64_from_str8(String8 string); +MD_F64 md_f64_from_str8(MD_String8 string); //////////////////////////////// //~ rjf: String List Construction Functions -#define str8_list_first(list) ((list)->first ? (list)->first->string : str8_zero()) +#define md_str8_list_first(list) ((list)->first ? (list)->first->string : md_str8_zero()) -String8Node* str8_list_push_node (String8List* list, String8Node* node); -String8Node* str8_list_push_node_set_string (String8List* list, String8Node* node, String8 string); -String8Node* str8_list_push_node_front (String8List* list, String8Node* node); -String8Node* str8_list_push_node_front_set_string(String8List* list, String8Node* node, String8 string); -void str8_list_concat_in_place (String8List* list, String8List* to_push); +MD_String8Node* md_str8_list_push_node (MD_String8List* list, MD_String8Node* node); +MD_String8Node* md_str8_list_push_node_set_string (MD_String8List* list, MD_String8Node* node, MD_String8 string); +MD_String8Node* md_str8_list_push_node_front (MD_String8List* list, MD_String8Node* node); +MD_String8Node* md_str8_list_push_node_front_set_string(MD_String8List* list, MD_String8Node* node, MD_String8 string); +void md_str8_list_concat_in_place (MD_String8List* list, MD_String8List* to_push); -inline String8Node* -str8_list_push_node(String8List* list, String8Node* node) { - sll_queue_push(list->first, list->last, node); - list->node_count += 1; +inline MD_String8Node* +md_str8_list_push_node(MD_String8List* list, MD_String8Node* node) { + md_sll_queue_push(list->first, list->last, node); + list->md_node_count += 1; list->total_size += node->string.size; return(node); } -inline String8Node* -str8_list_push_node_set_string(String8List* list, String8Node* node, String8 string) { - sll_queue_push(list->first, list->last, node); - list->node_count += 1; +inline MD_String8Node* +md_str8_list_push_node_set_string(MD_String8List* list, MD_String8Node* node, MD_String8 string) { + md_sll_queue_push(list->first, list->last, node); + list->md_node_count += 1; list->total_size += string.size; node->string = string; return(node); } -inline String8Node* -str8_list_push_node_front(String8List* list, String8Node* node) { - sll_queue_push_front(list->first, list->last, node); - list->node_count += 1; +inline MD_String8Node* +md_str8_list_push_node_front(MD_String8List* list, MD_String8Node* node) { + md_sll_queue_push_front(list->first, list->last, node); + list->md_node_count += 1; list->total_size += node->string.size; return(node); } -inline String8Node* -str8_list_push_node_front_set_string(String8List* list, String8Node* node, String8 string) { - sll_queue_push_front(list->first, list->last, node); - list->node_count += 1; +inline MD_String8Node* +md_str8_list_push_node_front_set_string(MD_String8List* list, MD_String8Node* node, MD_String8 string) { + md_sll_queue_push_front(list->first, list->last, node); + list->md_node_count += 1; list->total_size += string.size; node->string = string; return(node); } -String8Node* str8_list_aligner__arena(Arena* arena, String8List* list, U64 min, U64 align); -String8List str8_list_copy__arena (Arena* arena, String8List* list); +MD_String8Node* md_str8_list_aligner__arena(MD_Arena* arena, MD_String8List* list, MD_U64 md_min, MD_U64 align); +MD_String8List md_str8_list_copy__arena (MD_Arena* arena, MD_String8List* list); -String8Node* str8_list_push__arena (Arena* arena, String8List* list, String8 string); -String8Node* str8_list_push_front__arena (Arena* arena, String8List* list, String8 string); -String8Node* str8_list_pushf__arena (Arena* arena, String8List* list, char* fmt, ...); -String8Node* str8_list_push_frontf__arena(Arena* arena, String8List* list, char* fmt, ...); +MD_String8Node* md_str8_list_push__arena (MD_Arena* arena, MD_String8List* list, MD_String8 string); +MD_String8Node* md_str8_list_push_front__arena (MD_Arena* arena, MD_String8List* list, MD_String8 string); +MD_String8Node* md_str8_list_pushf__arena (MD_Arena* arena, MD_String8List* list, char* fmt, ...); +MD_String8Node* md_str8_list_push_frontf__arena(MD_Arena* arena, MD_String8List* list, char* fmt, ...); -MD_API String8Node* str8_list_aligner__ainfo(AllocatorInfo ainfo, String8List* list, U64 min, U64 align); -MD_API String8List str8_list_copy__ainfo (AllocatorInfo ainfo, String8List* list); +MD_API MD_String8Node* md_str8_list_aligner__ainfo(MD_AllocatorInfo ainfo, MD_String8List* list, MD_U64 md_min, MD_U64 align); +MD_API MD_String8List md_str8_list_copy__ainfo (MD_AllocatorInfo ainfo, MD_String8List* list); -String8Node* str8_list_push__ainfo (AllocatorInfo ainfo, String8List* list, String8 string); -String8Node* str8_list_push_front__ainfo (AllocatorInfo ainfo, String8List* list, String8 string); -String8Node* str8_list_pushf__ainfo (AllocatorInfo ainfo, String8List* list, char* fmt, ...); -String8Node* str8_list_push_frontf__ainfo(AllocatorInfo ainfo, String8List* list, char* fmt, ...); +MD_String8Node* md_str8_list_push__ainfo (MD_AllocatorInfo ainfo, MD_String8List* list, MD_String8 string); +MD_String8Node* md_str8_list_push_front__ainfo (MD_AllocatorInfo ainfo, MD_String8List* list, MD_String8 string); +MD_String8Node* md_str8_list_pushf__ainfo (MD_AllocatorInfo ainfo, MD_String8List* list, char* fmt, ...); +MD_String8Node* md_str8_list_push_frontf__ainfo(MD_AllocatorInfo ainfo, MD_String8List* list, char* fmt, ...); -#define str8_list_aligner(allocator, list, min, align) _Generic(allocator, Arena*: str8_list_aligner__arena, AllocatorInfo: str8_list_aligner__ainfo, default: assert_generic_sel_fail) generic_call(allocator, list, min, align) -#define str8_list_copy(allocator, list) _Generic(allocator, Arena*: str8_list_copy__arena, AllocatorInfo: str8_list_copy__ainfo, default: assert_generic_sel_fail) generic_call(allocator, list) -#define str8_list_push(allocator, list, string) _Generic(allocator, Arena*: str8_list_push__arena, AllocatorInfo: str8_list_push__ainfo, default: assert_generic_sel_fail) generic_call(allocator, list, string) -#define str8_list_push_front(allocator, list, string) _Generic(allocator, Arena*: str8_list_push_front__arena, AllocatorInfo: str8_list_push_front__ainfo, default: assert_generic_sel_fail) generic_call(allocator, list, string) -#define str8_list_pushf(allocator, list, fmt, ...) _Generic(allocator, Arena*: str8_list_pushf__arena, AllocatorInfo: str8_list_pushf__ainfo, default: assert_generic_sel_fail) generic_call(allocator, list, fmt, __VA_ARGS__) -#define str8_list_push_frontf(allocaotr, list, fmt, ...) _Generic(allocator, Arena*: str8_list_push_frontf__arena, AllocatorInfo: str8_list_push_frontf__ainfo, default: assert_generic_sel_fail) generic_call(allocator, list, fmt, __VA_ARGS__) +#define md_str8_list_aligner(allocator, list, md_min, align) _Generic(allocator, MD_Arena*: md_str8_list_aligner__arena, MD_AllocatorInfo: md_str8_list_aligner__ainfo, default: md_assert_generic_sel_fail) md_generic_call(allocator, list, md_min, align) +#define md_str8_list_copy(allocator, list) _Generic(allocator, MD_Arena*: md_str8_list_copy__arena, MD_AllocatorInfo: md_str8_list_copy__ainfo, default: md_assert_generic_sel_fail) md_generic_call(allocator, list) +#define md_str8_list_push(allocator, list, string) _Generic(allocator, MD_Arena*: md_str8_list_push__arena, MD_AllocatorInfo: md_str8_list_push__ainfo, default: md_assert_generic_sel_fail) md_generic_call(allocator, list, string) +#define md_str8_list_push_front(allocator, list, string) _Generic(allocator, MD_Arena*: md_str8_list_push_front__arena, MD_AllocatorInfo: md_str8_list_push_front__ainfo, default: md_assert_generic_sel_fail) md_generic_call(allocator, list, string) +#define md_str8_list_pushf(allocator, list, fmt, ...) _Generic(allocator, MD_Arena*: md_str8_list_pushf__arena, MD_AllocatorInfo: md_str8_list_pushf__ainfo, default: md_assert_generic_sel_fail) md_generic_call(allocator, list, fmt, __VA_ARGS__) +#define md_str8_list_push_frontf(allocaotr, list, fmt, ...) _Generic(allocator, MD_Arena*: md_str8_list_push_frontf__arena, MD_AllocatorInfo: md_str8_list_push_frontf__ainfo, default: md_assert_generic_sel_fail) md_generic_call(allocator, list, fmt, __VA_ARGS__) -force_inline String8Node* str8_list_ligner__arena (Arena* arena, String8List* list, U64 min, U64 align) { return str8_list_aligner__ainfo (arena_allocator(arena), list, min, align); } -force_inline String8List str8_list_copy__arena (Arena* arena, String8List* list) { return str8_list_copy__ainfo (arena_allocator(arena), list); } -force_inline String8Node* str8_list_push__arena (Arena* arena, String8List* list, String8 string) { return str8_list_push__ainfo (arena_allocator(arena), list, string); } -force_inline String8Node* str8_list_push_front__arena(Arena* arena, String8List* list, String8 string) { return str8_list_push_front__ainfo(arena_allocator(arena), list, string); } +md_force_inline MD_String8Node* md_str8_list_ligner__arena (MD_Arena* arena, MD_String8List* list, MD_U64 md_min, MD_U64 align) { return md_str8_list_aligner__ainfo (md_arena_allocator(arena), list, md_min, align); } +md_force_inline MD_String8List md_str8_list_copy__arena (MD_Arena* arena, MD_String8List* list) { return md_str8_list_copy__ainfo (md_arena_allocator(arena), list); } +md_force_inline MD_String8Node* md_str8_list_push__arena (MD_Arena* arena, MD_String8List* list, MD_String8 string) { return md_str8_list_push__ainfo (md_arena_allocator(arena), list, string); } +md_force_inline MD_String8Node* md_str8_list_push_front__arena(MD_Arena* arena, MD_String8List* list, MD_String8 string) { return md_str8_list_push_front__ainfo(md_arena_allocator(arena), list, string); } -inline String8Node* -str8_list_pushf__arena(Arena *arena, String8List *list, char *fmt, ...) { +inline MD_String8Node* +md_str8_list_pushf__arena(MD_Arena *arena, MD_String8List *list, char *fmt, ...) { va_list args; va_start(args, fmt); - String8 string = str8fv(arena, fmt, args); - String8Node* result = str8_list_push(arena, list, string); + MD_String8 string = md_str8fv(arena, fmt, args); + MD_String8Node* result = md_str8_list_push(arena, list, string); va_end(args); return(result); } -inline String8Node* -str8_list_push_frontf__arena(Arena *arena, String8List *list, char *fmt, ...) { +inline MD_String8Node* +md_str8_list_push_frontf__arena(MD_Arena *arena, MD_String8List *list, char *fmt, ...) { va_list args; va_start(args, fmt); - String8 string = str8fv(arena, fmt, args); - String8Node* result = str8_list_push_front(arena, list, string); + MD_String8 string = md_str8fv(arena, fmt, args); + MD_String8Node* result = md_str8_list_push_front(arena, list, string); va_end(args); return(result); } -inline String8Node* -str8_list_push__ainfo(AllocatorInfo ainfo, String8List* list, String8 string) { - String8Node* node = alloc_array_no_zero(ainfo, String8Node, 1); - str8_list_push_node_set_string(list, node, string); +inline MD_String8Node* +md_str8_list_push__ainfo(MD_AllocatorInfo ainfo, MD_String8List* list, MD_String8 string) { + MD_String8Node* node = md_alloc_array_no_zero(ainfo, MD_String8Node, 1); + md_str8_list_push_node_set_string(list, node, string); return(node); } -inline String8Node* -str8_list_push_front__ainfo(AllocatorInfo ainfo, String8List* list, String8 string) { - String8Node *node = alloc_array_no_zero(ainfo, String8Node, 1); - str8_list_push_node_front_set_string(list, node, string); +inline MD_String8Node* +md_str8_list_push_front__ainfo(MD_AllocatorInfo ainfo, MD_String8List* list, MD_String8 string) { + MD_String8Node *node = md_alloc_array_no_zero(ainfo, MD_String8Node, 1); + md_str8_list_push_node_front_set_string(list, node, string); return(node); } -inline String8Node* -str8_list_pushf__ainfo(AllocatorInfo ainfo, String8List* list, char* fmt, ...) { +inline MD_String8Node* +md_str8_list_pushf__ainfo(MD_AllocatorInfo ainfo, MD_String8List* list, char* fmt, ...) { va_list args; va_start(args, fmt); - String8 string = str8fv(ainfo, fmt, args); - String8Node* result = str8_list_push(ainfo, list, string); + MD_String8 string = md_str8fv(ainfo, fmt, args); + MD_String8Node* result = md_str8_list_push(ainfo, list, string); va_end(args); return(result); } -inline String8Node* -str8_list_push_frontf__ainfo(AllocatorInfo ainfo, String8List* list, char* fmt, ...) { +inline MD_String8Node* +md_str8_list_push_frontf__ainfo(MD_AllocatorInfo ainfo, MD_String8List* list, char* fmt, ...) { va_list args; va_start(args, fmt); - String8 string = str8fv(ainfo, fmt, args); - String8Node* result = str8_list_push_front(ainfo, list, string); + MD_String8 string = md_str8fv(ainfo, fmt, args); + MD_String8Node* result = md_str8_list_push_front(ainfo, list, string); va_end(args); return(result); } @@ -732,52 +732,52 @@ str8_list_push_frontf__ainfo(AllocatorInfo ainfo, String8List* list, char* fmt, //////////////////////////////// //~ rjf: String Splitting & Joining - String8List str8_split__arena(Arena* arena, String8 string, U8* split_chars, U64 split_char_count, StringSplitFlags flags); -MD_API String8List str8_split__ainfo(AllocatorInfo ainfo, String8 string, U8* split_chars, U64 split_char_count, StringSplitFlags flags); + MD_String8List md_str8_split__arena(MD_Arena* arena, MD_String8 string, MD_U8* split_chars, MD_U64 split_char_count, MD_StringSplitFlags flags); +MD_API MD_String8List md_str8_split__ainfo(MD_AllocatorInfo ainfo, MD_String8 string, MD_U8* split_chars, MD_U64 split_char_count, MD_StringSplitFlags flags); -String8List str8_split_by_string_chars__arena (Arena* arena, String8 string, String8 split_chars, StringSplitFlags flags); -String8List str8_split_by_string_chars__ainfo (AllocatorInfo ainfo, String8 string, String8 split_chars, StringSplitFlags flags); -String8List str8_list_split_by_string_chars__arena(Arena* arena, String8List list, String8 split_chars, StringSplitFlags flags); -String8List str8_list_split_by_string_chars__ainfo(AllocatorInfo ainfo, String8List list, String8 split_chars, StringSplitFlags flags); +MD_String8List md_str8_split_by_string_chars__arena (MD_Arena* arena, MD_String8 string, MD_String8 split_chars, MD_StringSplitFlags flags); +MD_String8List md_str8_split_by_string_chars__ainfo (MD_AllocatorInfo ainfo, MD_String8 string, MD_String8 split_chars, MD_StringSplitFlags flags); +MD_String8List md_str8_list_split_by_string_chars__arena(MD_Arena* arena, MD_String8List list, MD_String8 split_chars, MD_StringSplitFlags flags); +MD_String8List md_str8_list_split_by_string_chars__ainfo(MD_AllocatorInfo ainfo, MD_String8List list, MD_String8 split_chars, MD_StringSplitFlags flags); - String8 str8_list_join__arena (Arena* arena, String8List* list, StringJoin* optional_params); -MD_API String8 str8_list_join__ainfo (AllocatorInfo ainfo, String8List* list, StringJoin* optional_params); - void str8_list_from_flags__arena(Arena* arena, String8List* list, U32 flags, String8* flag_string_table, U32 flag_string_count); - void str8_list_from_flags__ainfo(AllocatorInfo ainfo, String8List* list, U32 flags, String8* flag_string_table, U32 flag_string_count); + MD_String8 md_str8_list_join__arena (MD_Arena* arena, MD_String8List* list, MD_StringJoin* optional_params); +MD_API MD_String8 md_str8_list_join__ainfo (MD_AllocatorInfo ainfo, MD_String8List* list, MD_StringJoin* optional_params); + void md_str8_list_from_flags__arena(MD_Arena* arena, MD_String8List* list, MD_U32 flags, MD_String8* flag_string_table, MD_U32 flag_string_count); + void md_str8_list_from_flags__ainfo(MD_AllocatorInfo ainfo, MD_String8List* list, MD_U32 flags, MD_String8* flag_string_table, MD_U32 flag_string_count); -#define str8_split(allocator, string, split_chars, split_char_count, flags) _Generic(allocator, Arena*: str8_split__arena, AllocatorInfo: str8_split__ainfo, default: assert_generic_sel_fail) generic_call(allocator, string, split_chars, split_char_count, flags) -#define str8_split_by_string_chars(allocator, string, split_chars, flags) _Generic(allocator, Arena*: str8_split_by_string_chars__arena, AllocatorInfo: str8_split_by_string_chars__ainfo, default: assert_generic_sel_fail) generic_call(allocator, string, split_chars, flags) -#define str8_list_split_by_string_chars(allocator, list, split_chars, flags) _Generic(allocator, Arena*: str8_list_split_by_string_chars__arena, AllocatorInfo: str8_list_split_by_string_chars__ainfo, default: assert_generic_sel_fail) generic_call(allocator, list, split_chars, flags) -#define str8_list_join(allocator, list, params) _Generic(allocator, Arena*: str8_list_join__arena, AllocatorInfo: str8_list_join__ainfo, default: assert_generic_sel_fail) generic_call(allocator, list, params ) +#define md_str8_split(allocator, string, split_chars, split_char_count, flags) _Generic(allocator, MD_Arena*: md_str8_split__arena, MD_AllocatorInfo: md_str8_split__ainfo, default: md_assert_generic_sel_fail) md_generic_call(allocator, string, split_chars, split_char_count, flags) +#define md_str8_split_by_string_chars(allocator, string, split_chars, flags) _Generic(allocator, MD_Arena*: md_str8_split_by_string_chars__arena, MD_AllocatorInfo: md_str8_split_by_string_chars__ainfo, default: md_assert_generic_sel_fail) md_generic_call(allocator, string, split_chars, flags) +#define md_str8_list_split_by_string_chars(allocator, list, split_chars, flags) _Generic(allocator, MD_Arena*: md_str8_list_split_by_string_chars__arena, MD_AllocatorInfo: md_str8_list_split_by_string_chars__ainfo, default: md_assert_generic_sel_fail) md_generic_call(allocator, list, split_chars, flags) +#define md_str8_list_join(allocator, list, params) _Generic(allocator, MD_Arena*: md_str8_list_join__arena, MD_AllocatorInfo: md_str8_list_join__ainfo, default: md_assert_generic_sel_fail) md_generic_call(allocator, list, params ) -force_inline String8List str8_split__arena (Arena* arena, String8 string, U8* split_chars, U64 split_char_count, StringSplitFlags flags) { return str8_split__ainfo (arena_allocator(arena), string, split_chars, split_char_count, flags); } -force_inline String8List str8_split_by_string_chars__arena (Arena* arena, String8 string, String8 split_chars, StringSplitFlags flags) { return str8_split_by_string_chars__ainfo (arena_allocator(arena), string, split_chars, flags); } -force_inline String8List str8_list_split_by_string_chars__arena(Arena* arena, String8List list, String8 split_chars, StringSplitFlags flags) { return str8_list_split_by_string_chars__ainfo (arena_allocator(arena), list, split_chars, flags); } -force_inline void str8_list_from_flags__arena (Arena* arena, String8List* list, U32 flags, String8* flag_string_table, U32 flag_string_count) { str8_list_from_flags__ainfo (arena_allocator(arena), list, flags, flag_string_table, flag_string_count); } -force_inline String8 str8_list_join__arena (Arena* arena, String8List* list, StringJoin* optional_params) { return str8_list_join__ainfo (arena_allocator(arena), list, optional_params); } +md_force_inline MD_String8List md_str8_split__arena (MD_Arena* arena, MD_String8 string, MD_U8* split_chars, MD_U64 split_char_count, MD_StringSplitFlags flags) { return md_str8_split__ainfo (md_arena_allocator(arena), string, split_chars, split_char_count, flags); } +md_force_inline MD_String8List md_str8_split_by_string_chars__arena (MD_Arena* arena, MD_String8 string, MD_String8 split_chars, MD_StringSplitFlags flags) { return md_str8_split_by_string_chars__ainfo (md_arena_allocator(arena), string, split_chars, flags); } +md_force_inline MD_String8List md_str8_list_split_by_string_chars__arena(MD_Arena* arena, MD_String8List list, MD_String8 split_chars, MD_StringSplitFlags flags) { return md_str8_list_split_by_string_chars__ainfo (md_arena_allocator(arena), list, split_chars, flags); } +md_force_inline void md_str8_list_from_flags__arena (MD_Arena* arena, MD_String8List* list, MD_U32 flags, MD_String8* flag_string_table, MD_U32 flag_string_count) { md_str8_list_from_flags__ainfo (md_arena_allocator(arena), list, flags, flag_string_table, flag_string_count); } +md_force_inline MD_String8 md_str8_list_join__arena (MD_Arena* arena, MD_String8List* list, MD_StringJoin* optional_params) { return md_str8_list_join__ainfo (md_arena_allocator(arena), list, optional_params); } -inline String8List -str8_split_by_string_chars__ainfo(AllocatorInfo ainfo, String8 string, String8 split_chars, StringSplitFlags flags) { - String8List list = str8_split(ainfo, string, split_chars.str, split_chars.size, flags); +inline MD_String8List +md_str8_split_by_string_chars__ainfo(MD_AllocatorInfo ainfo, MD_String8 string, MD_String8 split_chars, MD_StringSplitFlags flags) { + MD_String8List list = md_str8_split(ainfo, string, split_chars.str, split_chars.size, flags); return list; } -inline String8List -str8_list_split_by_string_chars__ainfo(AllocatorInfo ainfo, String8List list, String8 split_chars, StringSplitFlags flags) { - String8List result = {0}; - for (String8Node *node = list.first; node != 0; node = node->next){ - String8List split = str8_split_by_string_chars(ainfo, node->string, split_chars, flags); - str8_list_concat_in_place(&result, &split); +inline MD_String8List +md_str8_list_split_by_string_chars__ainfo(MD_AllocatorInfo ainfo, MD_String8List list, MD_String8 split_chars, MD_StringSplitFlags flags) { + MD_String8List result = {0}; + for (MD_String8Node *node = list.first; node != 0; node = node->next){ + MD_String8List split = md_str8_split_by_string_chars(ainfo, node->string, split_chars, flags); + md_str8_list_concat_in_place(&result, &split); } return result; } void -str8_list_from_flags__ainfo(AllocatorInfo ainfo, String8List* list, U32 flags, String8* flag_string_table, U32 flag_string_count) { - for (U32 i = 0; i < flag_string_count; i += 1) { - U32 flag = (1 << i); +md_str8_list_from_flags__ainfo(MD_AllocatorInfo ainfo, MD_String8List* list, MD_U32 flags, MD_String8* flag_string_table, MD_U32 flag_string_count) { + for (MD_U32 i = 0; i < flag_string_count; i += 1) { + MD_U32 flag = (1 << i); if (flags & flag) { - str8_list_push(ainfo, list, flag_string_table[i]); + md_str8_list_push(ainfo, list, flag_string_table[i]); } } } @@ -785,79 +785,79 @@ str8_list_from_flags__ainfo(AllocatorInfo ainfo, String8List* list, U32 flags, S //////////////////////////////// //~ rjf; String Arrays -#define str8_array_from_list(allocator, list) _Generic(allocator, Arena*: str8_array_from_list__arena, AllocatorInfo: str8_array_from_list__ainfo, default: assert_generic_sel_fail) generic_call(allocator, list) -#define str8_array_reserve(allocator, count) _Generic(allocaotr, Arena*: str8_array_reserve__arena AllocatorInfo: str8_array_reserve__ainfo, default: assert_generic_sel_fail) generic_call(allocator, count) +#define md_str8_array_from_list(allocator, list) _Generic(allocator, MD_Arena*: md_str8_array_from_list__arena, MD_AllocatorInfo: md_str8_array_from_list__ainfo, default: md_assert_generic_sel_fail) md_generic_call(allocator, list) +#define md_str8_array_reserve(allocator, count) _Generic(allocaotr, MD_Arena*: md_str8_array_reserve__arena MD_AllocatorInfo: md_str8_array_reserve__ainfo, default: md_assert_generic_sel_fail) md_generic_call(allocator, count) -inline String8Array -str8_array_from_list__ainfo(AllocatorInfo ainfo, String8List* list) { - String8Array array; - array.count = list->node_count; - array.v = alloc_array_no_zero(ainfo, String8, array.count); - U64 idx = 0; - for(String8Node *n = list->first; n != 0; n = n->next, idx += 1) { +inline MD_String8Array +md_str8_array_from_list__ainfo(MD_AllocatorInfo ainfo, MD_String8List* list) { + MD_String8Array array; + array.count = list->md_node_count; + array.v = md_alloc_array_no_zero(ainfo, MD_String8, array.count); + MD_U64 idx = 0; + for(MD_String8Node *n = list->first; n != 0; n = n->next, idx += 1) { array.v[idx] = n->string; } return array; } -inline String8Array -str8_array_reserve__ainfo(AllocatorInfo ainfo, U64 count) { - String8Array arr; +inline MD_String8Array +md_str8_array_reserve__ainfo(MD_AllocatorInfo ainfo, MD_U64 count) { + MD_String8Array arr; arr.count = 0; - arr.v = alloc_array(ainfo, String8, count); + arr.v = md_alloc_array(ainfo, MD_String8, count); return arr; } -force_inline String8Array str8_array_from_list__arena(Arena* arena, String8List* list) { return str8_array_from_list__ainfo(arena_allocator(arena), list); } -force_inline String8Array str8_array_reserve__arena (Arena* arena, U64 count) { return str8_array_reserve__ainfo (arena_allocator(arena), count); } +md_force_inline MD_String8Array md_str8_array_from_list__arena(MD_Arena* arena, MD_String8List* list) { return md_str8_array_from_list__ainfo(md_arena_allocator(arena), list); } +md_force_inline MD_String8Array md_str8_array_reserve__arena (MD_Arena* arena, MD_U64 count) { return md_str8_array_reserve__ainfo (md_arena_allocator(arena), count); } //////////////////////////////// //~ rjf: String Path Helpers -MD_API String8 str8_chop_last_slash(String8 string); -MD_API String8 str8_skip_last_slash(String8 string); -MD_API String8 str8_chop_last_dot (String8 string); -MD_API String8 str8_skip_last_dot (String8 string); +MD_API MD_String8 md_str8_chop_last_slash(MD_String8 string); +MD_API MD_String8 md_str8_skip_last_slash(MD_String8 string); +MD_API MD_String8 md_str8_chop_last_dot (MD_String8 string); +MD_API MD_String8 md_str8_skip_last_dot (MD_String8 string); -force_inline String8List str8_split_path__arena(Arena* arena, String8 string) { String8List result = str8_split(arena, string, (U8*)"/\\", 2, 0); return(result); } -force_inline String8List str8_split_path__ainfo(AllocatorInfo ainfo, String8 string) { String8List result = str8_split(ainfo, string, (U8*)"/\\", 2, 0); return(result); } +md_force_inline MD_String8List md_str8_split_path__arena(MD_Arena* arena, MD_String8 string) { MD_String8List result = md_str8_split(arena, string, (MD_U8*)"/\\", 2, 0); return(result); } +md_force_inline MD_String8List md_str8_split_path__ainfo(MD_AllocatorInfo ainfo, MD_String8 string) { MD_String8List result = md_str8_split(ainfo, string, (MD_U8*)"/\\", 2, 0); return(result); } -#define str8_split_path(allocator, string) _Generic(allocator, Arena*: str8_split_path__arena, AllocatorInfo: str8_split_path__ainfo, default: assert_generic_sel_fail) generic_call(allocator, string) +#define md_str8_split_path(allocator, string) _Generic(allocator, MD_Arena*: md_str8_split_path__arena, MD_AllocatorInfo: md_str8_split_path__ainfo, default: md_assert_generic_sel_fail) md_generic_call(allocator, string) -MD_API PathStyle path_style_from_str8 (String8 string); -MD_API void str8_path_list_resolve_dots_in_place( String8List* path, PathStyle style); -MD_API String8 str8_path_list_join_by_style__arena (Arena* arena, String8List* path, PathStyle style); -MD_API String8 str8_path_list_join_by_style__ainfo (AllocatorInfo ainfo, String8List* path, PathStyle style); +MD_API MD_PathStyle md_path_style_from_str8 (MD_String8 string); +MD_API void md_str8_path_list_resolve_dots_in_place( MD_String8List* path, MD_PathStyle style); +MD_API MD_String8 md_str8_path_list_join_by_style__arena (MD_Arena* arena, MD_String8List* path, MD_PathStyle style); +MD_API MD_String8 md_str8_path_list_join_by_style__ainfo (MD_AllocatorInfo ainfo, MD_String8List* path, MD_PathStyle style); -#define str8_path_list_join_by_style(allocator, path, style) _Generic(allocator, Arena*: str8_path_list_join_by_style__arena, AllocatorInfo: str8_split_path__ainfo, default: assert_generic_sel_fail) generic_call(allocator, path, style) +#define md_str8_path_list_join_by_style(allocator, path, style) _Generic(allocator, MD_Arena*: md_str8_path_list_join_by_style__arena, MD_AllocatorInfo: md_str8_split_path__ainfo, default: md_assert_generic_sel_fail) md_generic_call(allocator, path, style) -force_inline String8 str8_path_list_join_by_style__arena(Arena* arena, String8List* path, PathStyle style) { return str8_path_list_join_by_style__ainfo(arena_allocator(arena), path, style); } +md_force_inline MD_String8 md_str8_path_list_join_by_style__arena(MD_Arena* arena, MD_String8List* path, MD_PathStyle style) { return md_str8_path_list_join_by_style__ainfo(md_arena_allocator(arena), path, style); } //////////////////////////////// //~ rjf: UTF-8 & UTF-16 Decoding/Encoding -inline U8 -utf8_class(U8 value) +inline MD_U8 +md_utf8_class(MD_U8 value) { - local_persist - U8 lookup_table[32] = { + md_local_persist + MD_U8 lookup_table[32] = { 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,2,2,2,2,3,3,4,5, }; return lookup_table[value]; } -MD_API UnicodeDecode utf8_decode (U8* str, U64 max); - UnicodeDecode utf16_decode (U16* str, U64 max); -MD_API U32 utf8_encode (U8* str, U32 codepoint); -MD_API U32 utf16_encode (U16* str, U32 codepoint); - U32 utf8_from_utf32_single(U8* buffer, U32 character); +MD_API MD_UnicodeDecode md_utf8_decode (MD_U8* str, MD_U64 md_max); + MD_UnicodeDecode md_utf16_decode (MD_U16* str, MD_U64 md_max); +MD_API MD_U32 md_utf8_encode (MD_U8* str, MD_U32 codepoint); +MD_API MD_U32 md_utf16_encode (MD_U16* str, MD_U32 codepoint); + MD_U32 md_utf8_from_utf32_single(MD_U8* buffer, MD_U32 character); -inline UnicodeDecode -utf16_decode(U16* str, U64 max) { - UnicodeDecode result = {1, MAX_U32}; +inline MD_UnicodeDecode +md_utf16_decode(MD_U16* str, MD_U64 md_max) { + MD_UnicodeDecode result = {1, MD_MAX_U32}; result.codepoint = str[0]; result.inc = 1; - if (max > 1 && 0xD800 <= str[0] && str[0] < 0xDC00 && 0xDC00 <= str[1] && str[1] < 0xE000) { + if (md_max > 1 && 0xD800 <= str[0] && str[0] < 0xDC00 && 0xDC00 <= str[1] && str[1] < 0xE000) { result.codepoint = ((str[0] - 0xD800) << 10) | ((str[1] - 0xDC00) + 0x10000); result.inc = 2; @@ -865,93 +865,93 @@ utf16_decode(U16* str, U64 max) { return(result); } -inline U32 utf8_from_utf32_single(U8* buffer, U32 character){ return(utf8_encode(buffer, character)); } +inline MD_U32 md_utf8_from_utf32_single(MD_U8* buffer, MD_U32 character){ return(md_utf8_encode(buffer, character)); } //////////////////////////////// //~ rjf: Unicode String Conversions -#define str8_from_str16(allocator, string_in) _Generic(allocator, Arena*: str8_from_str16__arena, AllocatorInfo: str8_from_str16__ainfo, default: assert_generic_sel_fail) generic_call(allocator, string_in) -#define str16_from_str8(allocator, string_in) _Generic(allocator, Arena*: str16_from_str8__arena, AllocatorInfo: str16_from_str8__ainfo, default: assert_generic_sel_fail) generic_call(allocator, string_in) -#define str8_from_str32(allocator, string_in) _Generic(allocator, Arena*: str8_from_str32__arena, AllocatorInfo: str8_from_str32__ainfo, default: assert_generic_sel_fail) generic_call(allocator, string_in) -#define str32_from_str8(allocator, string_in) _Generic(allocator, Arena*: str32_from_str8__arena, AllocatorInfo: str32_from_str8__ainfo, default: assert_generic_sel_fail) generic_call(allocator, string_in) +#define md_str8_from_str16(allocator, md_string_in) _Generic(allocator, MD_Arena*: md_str8_from_str16__arena, MD_AllocatorInfo: md_str8_from_str16__ainfo, default: md_assert_generic_sel_fail) md_generic_call(allocator, md_string_in) +#define md_str16_from_str8(allocator, md_string_in) _Generic(allocator, MD_Arena*: md_str16_from_str8__arena, MD_AllocatorInfo: md_str16_from_str8__ainfo, default: md_assert_generic_sel_fail) md_generic_call(allocator, md_string_in) +#define md_str8_from_str32(allocator, md_string_in) _Generic(allocator, MD_Arena*: md_str8_from_str32__arena, MD_AllocatorInfo: md_str8_from_str32__ainfo, default: md_assert_generic_sel_fail) md_generic_call(allocator, md_string_in) +#define md_str32_from_str8(allocator, md_string_in) _Generic(allocator, MD_Arena*: md_str32_from_str8__arena, MD_AllocatorInfo: md_str32_from_str8__ainfo, default: md_assert_generic_sel_fail) md_generic_call(allocator, md_string_in) -MD_API String8 str8_from_str16__arena(Arena* arena, String16 in); -MD_API String16 str16_from_str8__arena(Arena* arena, String8 in); -MD_API String8 str8_from_str32__arena(Arena* arena, String32 in); -MD_API String32 str32_from_str8__arena(Arena* arena, String8 in); +MD_API MD_String8 md_str8_from_str16__arena(MD_Arena* arena, MD_String16 in); +MD_API MD_String16 md_str16_from_str8__arena(MD_Arena* arena, MD_String8 in); +MD_API MD_String8 md_str8_from_str32__arena(MD_Arena* arena, MD_String32 in); +MD_API MD_String32 md_str32_from_str8__arena(MD_Arena* arena, MD_String8 in); -MD_API String8 str8_from_str16__ainfo(AllocatorInfo ainfo, String16 in); -MD_API String16 str16_from_str8__ainfo(AllocatorInfo ainfo, String8 in); -MD_API String8 str8_from_str32__ainfo(AllocatorInfo ainfo, String32 in); -MD_API String32 str32_from_str8__ainfo(AllocatorInfo ainfo, String8 in); +MD_API MD_String8 md_str8_from_str16__ainfo(MD_AllocatorInfo ainfo, MD_String16 in); +MD_API MD_String16 md_str16_from_str8__ainfo(MD_AllocatorInfo ainfo, MD_String8 in); +MD_API MD_String8 md_str8_from_str32__ainfo(MD_AllocatorInfo ainfo, MD_String32 in); +MD_API MD_String32 md_str32_from_str8__ainfo(MD_AllocatorInfo ainfo, MD_String8 in); //////////////////////////////// //~ String -> Enum Conversions -MD_API OperatingSystem operating_system_from_string(String8 string); +MD_API MD_OperatingSystem md_operating_system_from_string(MD_String8 string); //////////////////////////////// //~ rjf: Basic Types & Space Enum -> String Conversions -String8 string_from_dimension (Dimension dimension); -String8 string_from_side (Side side); -String8 string_from_operating_system(OperatingSystem os); -String8 string_from_architecture (Arch arch); +MD_String8 md_string_from_dimension (MD_Dimension dimension); +MD_String8 md_string_from_side (MD_Side side); +MD_String8 md_string_from_operating_system(MD_OperatingSystem os); +MD_String8 md_string_from_architecture (MD_Arch arch); -inline String8 -string_from_dimension(Dimension dimension) { - local_persist String8 strings[] = { - str8_lit_comp("X"), - str8_lit_comp("Y"), - str8_lit_comp("Z"), - str8_lit_comp("W"), +inline MD_String8 +md_string_from_dimension(MD_Dimension dimension) { + md_local_persist MD_String8 strings[] = { + md_str8_lit_comp("X"), + md_str8_lit_comp("Y"), + md_str8_lit_comp("Z"), + md_str8_lit_comp("W"), }; - String8 result = str8_lit("error"); - if ((U32)dimension < 4) { + MD_String8 result = md_str8_lit("error"); + if ((MD_U32)dimension < 4) { result = strings[dimension]; } return(result); } -inline String8 -string_from_side(Side side) { - local_persist String8 strings[] = { - str8_lit_comp("Min"), - str8_lit_comp("Max"), +inline MD_String8 +md_string_from_side(MD_Side side) { + md_local_persist MD_String8 strings[] = { + md_str8_lit_comp("Min"), + md_str8_lit_comp("Max"), }; - String8 result = str8_lit("error"); - if ((U32)side < 2) { + MD_String8 result = md_str8_lit("error"); + if ((MD_U32)side < 2) { result = strings[side]; } return(result); } -inline String8 -string_from_operating_system(OperatingSystem os) { - local_persist String8 strings[] = { - str8_lit_comp("Null"), - str8_lit_comp("Windows"), - str8_lit_comp("Linux"), - str8_lit_comp("Mac"), +inline MD_String8 +md_string_from_operating_system(MD_OperatingSystem os) { + md_local_persist MD_String8 strings[] = { + md_str8_lit_comp("Null"), + md_str8_lit_comp("Windows"), + md_str8_lit_comp("Linux"), + md_str8_lit_comp("Mac"), }; - String8 result = str8_lit("error"); - if (os < OperatingSystem_COUNT) { + MD_String8 result = md_str8_lit("error"); + if (os < MD_OperatingSystem_COUNT) { result = strings[os]; } return(result); } -inline String8 -string_from_architecture(Arch arch) { - local_persist String8 strings[] = { - str8_lit_comp("Null"), - str8_lit_comp("x64"), - str8_lit_comp("x86"), - str8_lit_comp("arm64"), - str8_lit_comp("arm32"), +inline MD_String8 +md_string_from_architecture(MD_Arch arch) { + md_local_persist MD_String8 strings[] = { + md_str8_lit_comp("Null"), + md_str8_lit_comp("x64"), + md_str8_lit_comp("x86"), + md_str8_lit_comp("arm64"), + md_str8_lit_comp("arm32"), }; - String8 result = str8_lit("error"); - if (arch < Arch_COUNT) { + MD_String8 result = md_str8_lit("error"); + if (arch < MD_Arch_COUNT) { result = strings[arch]; } return(result); @@ -960,71 +960,71 @@ string_from_architecture(Arch arch) { //////////////////////////////// //~ rjf: Time Types -> String -inline String8 -string_from_week_day(WeekDay week_day) +inline MD_String8 +md_string_from_week_day(MD_WeekDay week_day) { - local_persist String8 strings[] = { - str8_lit_comp("Sun"), - str8_lit_comp("Mon"), - str8_lit_comp("Tue"), - str8_lit_comp("Wed"), - str8_lit_comp("Thu"), - str8_lit_comp("Fri"), - str8_lit_comp("Sat"), + md_local_persist MD_String8 strings[] = { + md_str8_lit_comp("Sun"), + md_str8_lit_comp("Mon"), + md_str8_lit_comp("Tue"), + md_str8_lit_comp("Wed"), + md_str8_lit_comp("Thu"), + md_str8_lit_comp("Fri"), + md_str8_lit_comp("Sat"), }; - String8 result = str8_lit("Err"); - if ((U32)week_day < WeekDay_COUNT) { + MD_String8 result = md_str8_lit("Err"); + if ((MD_U32)week_day < MD_WeekDay_COUNT) { result = strings[week_day]; } return(result); } -inline String8 -string_from_month(Month month) +inline MD_String8 +md_string_from_month(MD_Month month) { - local_persist String8 strings[] = { - str8_lit_comp("Jan"), - str8_lit_comp("Feb"), - str8_lit_comp("Mar"), - str8_lit_comp("Apr"), - str8_lit_comp("May"), - str8_lit_comp("Jun"), - str8_lit_comp("Jul"), - str8_lit_comp("Aug"), - str8_lit_comp("Sep"), - str8_lit_comp("Oct"), - str8_lit_comp("Nov"), - str8_lit_comp("Dec"), + md_local_persist MD_String8 strings[] = { + md_str8_lit_comp("Jan"), + md_str8_lit_comp("Feb"), + md_str8_lit_comp("Mar"), + md_str8_lit_comp("Apr"), + md_str8_lit_comp("May"), + md_str8_lit_comp("Jun"), + md_str8_lit_comp("Jul"), + md_str8_lit_comp("Aug"), + md_str8_lit_comp("Sep"), + md_str8_lit_comp("Oct"), + md_str8_lit_comp("Nov"), + md_str8_lit_comp("Dec"), }; - String8 result = str8_lit("Err"); - if ((U32)month < Month_COUNT) { + MD_String8 result = md_str8_lit("Err"); + if ((MD_U32)month < MD_Month_COUNT) { result = strings[month]; } return(result); } -String8 date_time_string__arena (Arena* arena, DateTime* date_time); -String8 file_name_date_time_string__arena(Arena* arena, DateTime* date_time); -String8 string_from_elapsed_time__arena (Arena* arena, DateTime date_time); +MD_String8 md_date_time_string__arena (MD_Arena* arena, MD_DateTime* date_time); +MD_String8 md_file_name_date_time_string__arena(MD_Arena* arena, MD_DateTime* date_time); +MD_String8 md_string_from_elapsed_time__arena (MD_Arena* arena, MD_DateTime date_time); -MD_API String8 date_time_string__ainfo (AllocatorInfo ainfo, DateTime* date_time); -MD_API String8 file_name_date_time_string__ainfo(AllocatorInfo ainfo, DateTime* date_time); -MD_API String8 string_from_elapsed_time__ainfo (AllocatorInfo ainfo, DateTime date_time); +MD_API MD_String8 md_date_time_string__ainfo (MD_AllocatorInfo ainfo, MD_DateTime* date_time); +MD_API MD_String8 md_file_name_date_time_string__ainfo(MD_AllocatorInfo ainfo, MD_DateTime* date_time); +MD_API MD_String8 md_string_from_elapsed_time__ainfo (MD_AllocatorInfo ainfo, MD_DateTime date_time); -#define date_time_string(allocator, date_time) _Generic(allocator, Arena*: date_time_string__arena, AllocatorInfo: date_time_string__ainfo, default: assert_generic_sel_fail) generic_call(allocator, date_time) -#define file_name_date_time_string(allocator, date_time) _Generic(allocator, Arena*: file_name_date_time_string__arena, AllocatorInfo: file_name_date_time_string__ainfo, default: assert_generic_sel_fail) generic_call(allocator, date_time) -#define string_from_elapsed_time(allocator, date_time) _Generic(allocator, Arena*: string_from_elapsed_time__arena, AllocatorInfo: string_from_elapsed_time__ainfo, default: assert_generic_sel_fail) generic_call(allocator, date_time) +#define md_date_time_string(allocator, date_time) _Generic(allocator, MD_Arena*: md_date_time_string__arena, MD_AllocatorInfo: md_date_time_string__ainfo, default: md_assert_generic_sel_fail) md_generic_call(allocator, date_time) +#define file_name_date_time_string(allocator, date_time) _Generic(allocator, MD_Arena*: md_file_name_date_time_string__arena, MD_AllocatorInfo: md_file_name_date_time_string__ainfo, default: md_assert_generic_sel_fail) md_generic_call(allocator, date_time) +#define md_string_from_elapsed_time(allocator, date_time) _Generic(allocator, MD_Arena*: md_string_from_elapsed_time__arena, MD_AllocatorInfo: md_string_from_elapsed_time__ainfo, default: md_assert_generic_sel_fail) md_generic_call(allocator, date_time) -force_inline String8 push_date_time_string__arena (Arena* arena, DateTime* date_time) { return date_time_string__ainfo (arena_allocator(arena), date_time); } -force_inline String8 push_file_name_date_time_string__arena(Arena* arena, DateTime* date_time) { return file_name_date_time_string__ainfo(arena_allocator(arena), date_time); } -force_inline String8 string_from_elapsed_time__arena (Arena* arena, DateTime dt) { return string_from_elapsed_time__ainfo (arena_allocator(arena), dt); } +md_force_inline MD_String8 md_push_date_time_string__arena (MD_Arena* arena, MD_DateTime* date_time) { return md_date_time_string__ainfo (md_arena_allocator(arena), date_time); } +md_force_inline MD_String8 md_push_file_name_date_time_string__arena(MD_Arena* arena, MD_DateTime* date_time) { return md_file_name_date_time_string__ainfo(md_arena_allocator(arena), date_time); } +md_force_inline MD_String8 md_string_from_elapsed_time__arena (MD_Arena* arena, MD_DateTime dt) { return md_string_from_elapsed_time__ainfo (md_arena_allocator(arena), dt); } //////////////////////////////// //~ Globally Unique Ids -inline String8 -string_from_guid__arena(Arena* arena, Guid guid) { - String8 result = str8f(arena, +inline MD_String8 +md_string_from_guid__arena(MD_Arena* arena, MD_Guid guid) { + MD_String8 result = md_str8f(arena, "%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X", guid.data1, guid.data2, @@ -1041,9 +1041,9 @@ string_from_guid__arena(Arena* arena, Guid guid) { return result; } -inline String8 -string_from_guid__ainfo(AllocatorInfo ainfo, Guid guid) { - String8 result = str8f(ainfo, +inline MD_String8 +md_string_from_guid__ainfo(MD_AllocatorInfo ainfo, MD_Guid guid) { + MD_String8 result = md_str8f(ainfo, "%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X", guid.data1, guid.data2, @@ -1060,229 +1060,229 @@ string_from_guid__ainfo(AllocatorInfo ainfo, Guid guid) { return result; } -#define string_from_guid(allocator, guid) _Generic(allocator, Arena*: string_from_guid__arena, AllocatorInfo: string_from_guid__ainfo, default: assert_generic_sel_fail) generic_call(allocator, guid) +#define md_string_from_guid(allocator, guid) _Generic(allocator, MD_Arena*: md_string_from_guid__arena, MD_AllocatorInfo: md_string_from_guid__ainfo, default: md_assert_generic_sel_fail) md_generic_call(allocator, guid) -inline Guid guid_from_string(String8 string) { Guid guid = {0}; try_guid_from_string(string, &guid); return guid; } +inline MD_Guid md_guid_from_string(MD_String8 string) { MD_Guid guid = {0}; md_try_guid_from_string(string, &guid); return guid; } -MD_API B32 try_guid_from_string(String8 string, Guid* guid_out); +MD_API MD_B32 md_try_guid_from_string(MD_String8 string, MD_Guid* md_guid_out); //////////////////////////////// //~ rjf: Basic Text Indentation - String8 indented_from_string__arena(Arena* arena, String8 string); -MD_API String8 indented_from_string__ainfo(AllocatorInfo arena, String8 string); + MD_String8 md_indented_from_string__arena(MD_Arena* arena, MD_String8 string); +MD_API MD_String8 md_indented_from_string__ainfo(MD_AllocatorInfo arena, MD_String8 string); -#define indented_from_string(allocator, string) _Generic(allocator, Arena*: indented_from_string__arena, AllocatorInfo: indented_from_string__ainfo, default: assert_generic_sel_fail) generic_call(allocator, string) +#define md_indented_from_string(allocator, string) _Generic(allocator, MD_Arena*: md_indented_from_string__arena, MD_AllocatorInfo: md_indented_from_string__ainfo, default: md_assert_generic_sel_fail) md_generic_call(allocator, string) -force_inline String8 indented_from_string__arena(Arena* arena, String8 string) { return indented_from_string__ainfo(arena_allocator(arena), string); } +md_force_inline MD_String8 md_indented_from_string__arena(MD_Arena* arena, MD_String8 string) { return md_indented_from_string__ainfo(md_arena_allocator(arena), string); } //////////////////////////////// //~ rjf: Text Escaping - String8 escaped_from_raw_str8__arena(Arena* arena, String8 string); -MD_API String8 escaped_from_raw_str8__ainfo(AllocatorInfo ainfo, String8 string); - String8 raw_from_escaped_str8__arena(Arena* arena, String8 string); -MD_API String8 raw_from_escaped_str8__ainfo(AllocatorInfo ainfo, String8 string); + MD_String8 md_escaped_from_raw_str8__arena(MD_Arena* arena, MD_String8 string); +MD_API MD_String8 md_escaped_from_raw_str8__ainfo(MD_AllocatorInfo ainfo, MD_String8 string); + MD_String8 md_raw_from__escaped_str8__arena(MD_Arena* arena, MD_String8 string); +MD_API MD_String8 md_raw_from__escaped_str8__ainfo(MD_AllocatorInfo ainfo, MD_String8 string); -#define escaped_from_raw_str8(allocator, string) _Generic(allocator, Arena*: escaped_from_raw_str8__arena, AllocatorInfo: escaped_from_raw_str8__ainfo(, default): assert_generic_sel_fail) generic_call(allocator, string) -#define raw_from_escaped_str8(allocator, string) _Generic(allocator, Arena*: raw_from_escaped_str8__arena, AllocatorInfo: raw_from_escaped_str8__ainfo(, default): assert_generic_sel_fail) generic_call(allocator, string) +#define md_escaped_from_raw_str8(allocator, string) _Generic(allocator, MD_Arena*: md_escaped_from_raw_str8__arena, MD_AllocatorInfo: md_escaped_from_raw_str8__ainfo(, default): md_assert_generic_sel_fail) md_generic_call(allocator, string) +#define md_raw_from__escaped_str8(allocator, string) _Generic(allocator, MD_Arena*: md_raw_from__escaped_str8__arena, MD_AllocatorInfo: md_raw_from__escaped_str8__ainfo(, default): md_assert_generic_sel_fail) md_generic_call(allocator, string) -force_inline String8 escaped_from_raw_str8__arena(Arena* arena, String8 string) { return escaped_from_raw_str8__ainfo(arena_allocator(arena), string); } -force_inline String8 raw_from_escaped_str8__arena(Arena* arena, String8 string) { return raw_from_escaped_str8__ainfo(arena_allocator(arena), string); } +md_force_inline MD_String8 md_escaped_from_raw_str8__arena(MD_Arena* arena, MD_String8 string) { return md_escaped_from_raw_str8__ainfo(md_arena_allocator(arena), string); } +md_force_inline MD_String8 md_raw_from__escaped_str8__arena(MD_Arena* arena, MD_String8 string) { return md_raw_from__escaped_str8__ainfo(md_arena_allocator(arena), string); } //////////////////////////////// //~ rjf: Text Wrapping - String8List wrapped_lines_from_string__arena(Arena* arena, String8 string, U64 first_line_max_width, U64 max_width, U64 wrap_indent); -MD_API String8List wrapped_lines_from_string__ainfo(AllocatorInfo ainfo, String8 string, U64 first_line_max_width, U64 max_width, U64 wrap_indent); + MD_String8List md_wrapped_lines_from_string__arena(MD_Arena* arena, MD_String8 string, MD_U64 first_line_max_width, MD_U64 max_width, MD_U64 wrap_indent); +MD_API MD_String8List md_wrapped_lines_from_string__ainfo(MD_AllocatorInfo ainfo, MD_String8 string, MD_U64 first_line_max_width, MD_U64 max_width, MD_U64 wrap_indent); -#define wrapped_lines_from_string(allocator, string, first_line_max_width, max_width, wrap_indent) \ -_Generic(allocator, Arena*: wrapped_lines_from_string__arena, AllocatorInfo: wrapped_lines_from_string__ainfo, default: assert_generic_sel_fail) generic_call(allocator, string, first_line_max_width, max_width, wrap_indent) +#define md_wrapped_lines_from_string(allocator, string, first_line_max_width, max_width, wrap_indent) \ +_Generic(allocator, MD_Arena*: md_wrapped_lines_from_string__arena, MD_AllocatorInfo: md_wrapped_lines_from_string__ainfo, default: md_assert_generic_sel_fail) md_generic_call(allocator, string, first_line_max_width, max_width, wrap_indent) -force_inline String8List wrapped_lines_from_string__arena(Arena* arena, String8 string, U64 first_line_max_width, U64 max_width, U64 wrap_indent) { return wrapped_lines_from_string__ainfo(arena_allocator(arena), string, first_line_max_width, max_width, wrap_indent); } +md_force_inline MD_String8List md_wrapped_lines_from_string__arena(MD_Arena* arena, MD_String8 string, MD_U64 first_line_max_width, MD_U64 max_width, MD_U64 wrap_indent) { return md_wrapped_lines_from_string__ainfo(md_arena_allocator(arena), string, first_line_max_width, max_width, wrap_indent); } //////////////////////////////// //~ rjf: String <-> Color -inline String8 hex_string_from_rgba_4f32__arena(Arena* arena, Vec4F32 rgba) { String8 hex_string = str8f(arena, "%02x%02x%02x%02x", (U8)(rgba.x * 255.f), (U8)(rgba.y * 255.f), (U8)(rgba.z * 255.f), (U8)(rgba.w * 255.f)); return hex_string; } -inline String8 hex_string_from_rgba_4f32__ainfo(AllocatorInfo ainfo, Vec4F32 rgba) { String8 hex_string = str8f(ainfo, "%02x%02x%02x%02x", (U8)(rgba.x * 255.f), (U8)(rgba.y * 255.f), (U8)(rgba.z * 255.f), (U8)(rgba.w * 255.f)); return hex_string; } +inline MD_String8 md_hex_string_from_rgba_4f32__arena(MD_Arena* arena, MD_Vec4F32 rgba) { MD_String8 hex_string = md_str8f(arena, "%02x%02x%02x%02x", (MD_U8)(rgba.x * 255.f), (MD_U8)(rgba.y * 255.f), (MD_U8)(rgba.z * 255.f), (MD_U8)(rgba.w * 255.f)); return hex_string; } +inline MD_String8 md_hex_string_from_rgba_4f32__ainfo(MD_AllocatorInfo ainfo, MD_Vec4F32 rgba) { MD_String8 hex_string = md_str8f(ainfo, "%02x%02x%02x%02x", (MD_U8)(rgba.x * 255.f), (MD_U8)(rgba.y * 255.f), (MD_U8)(rgba.z * 255.f), (MD_U8)(rgba.w * 255.f)); return hex_string; } -#define hex_string_from_rgba_4f32(allocator, rgba) _Generic(allocator, Arena*: hex_string_from_rgba_4f32__arena, AllocatorInfo: hex_string_from_rgba_4f32__ainfo, default: assert_generic_sel_fail) generic_call(allocator, rgba) +#define md_hex_string_from_rgba_4f32(allocator, rgba) _Generic(allocator, MD_Arena*: md_hex_string_from_rgba_4f32__arena, MD_AllocatorInfo: md_hex_string_from_rgba_4f32__ainfo, default: md_assert_generic_sel_fail) md_generic_call(allocator, rgba) -MD_API Vec4F32 rgba_from_hex_string_4f32(String8 hex_string); +MD_API MD_Vec4F32 md_rgba_from_hex_string_4f32(MD_String8 hex_string); //////////////////////////////// //~ rjf: String Fuzzy Matching - FuzzyMatchRangeList fuzzy_match_find__arena (Arena* arena, String8 needle, String8 haystack); -MD_API FuzzyMatchRangeList fuzzy_match_find__ainfo (AllocatorInfo ainfo, String8 needle, String8 haystack); - FuzzyMatchRangeList fuzzy_match_range_list_copy__arena(Arena* arena, FuzzyMatchRangeList* src); -MD_API FuzzyMatchRangeList fuzzy_match_range_list_copy__ainfo(AllocatorInfo ainfo, FuzzyMatchRangeList* src); + MD_FuzzyMatchRangeList md_fuzzy_match_find__arena (MD_Arena* arena, MD_String8 needle, MD_String8 haystack); +MD_API MD_FuzzyMatchRangeList md_fuzzy_match_find__ainfo (MD_AllocatorInfo ainfo, MD_String8 needle, MD_String8 haystack); + MD_FuzzyMatchRangeList md_fuzzy_match_range_list_copy__arena(MD_Arena* arena, MD_FuzzyMatchRangeList* src); +MD_API MD_FuzzyMatchRangeList md_fuzzy_match_range_list_copy__ainfo(MD_AllocatorInfo ainfo, MD_FuzzyMatchRangeList* src); -#define fuzzy_match_find(allocator, needle, haystack) _Generic(allocator, Arena*: fuzzy_match_find__arena, AllocatorInfo: fuzzy_match_find__ainfo) generic_call(allocator, needle, haystack) -#define fuzzy_match_range_list_copy(allocator, src) _Generic(allocator, Arena*: fuzzy_match_range_list_copy__arena, AllocatorInfo: fuzzy_match_range_list_copy__ainfo) generic_call(allocator, src) +#define md_fuzzy_match_find(allocator, needle, haystack) _Generic(allocator, MD_Arena*: md_fuzzy_match_find__arena, MD_AllocatorInfo: md_fuzzy_match_find__ainfo) md_generic_call(allocator, needle, haystack) +#define md_fuzzy_match_range_list_copy(allocator, src) _Generic(allocator, MD_Arena*: md_fuzzy_match_range_list_copy__arena, MD_AllocatorInfo: md_fuzzy_match_range_list_copy__ainfo) md_generic_call(allocator, src) -force_inline FuzzyMatchRangeList fuzzy_match_find__arena (Arena *arena, String8 needle, String8 haystack) { return fuzzy_match_find__ainfo (arena_allocator(arena), needle, haystack); } -force_inline FuzzyMatchRangeList fuzzy_match_range_list_copy__arena(Arena* arena, FuzzyMatchRangeList* src) { return fuzzy_match_range_list_copy__ainfo(arena_allocator(arena), src); } +md_force_inline MD_FuzzyMatchRangeList md_fuzzy_match_find__arena (MD_Arena *arena, MD_String8 needle, MD_String8 haystack) { return md_fuzzy_match_find__ainfo (md_arena_allocator(arena), needle, haystack); } +md_force_inline MD_FuzzyMatchRangeList md_fuzzy_match_range_list_copy__arena(MD_Arena* arena, MD_FuzzyMatchRangeList* src) { return md_fuzzy_match_range_list_copy__ainfo(md_arena_allocator(arena), src); } //////////////////////////////// //~ NOTE(allen): Serialization Helpers -#define str8_serial_push_array(allocator, srl, ptr, count) str8_serial_push_data (allocator, srl, ptr, sizeof(*(ptr)) * (count)) -#define str8_serial_push_struct(allocator, srl, ptr) str8_serial_push_array(allocator, srl, ptr, 1) +#define md_str8_serial_push_array(allocator, srl, ptr, count) md_str8_serial_push_data (allocator, srl, ptr, sizeof(*(ptr)) * (count)) +#define md_str8_serial_push_struct(allocator, srl, ptr) md_str8_serial_push_array(allocator, srl, ptr, 1) inline void -str8_serial_write_to_dst(String8List* srl, void* out) { - U8* ptr = (U8*)out; - for (String8Node *node = srl->first; node != 0; node = node->next) +md_str8_serial_write_to_dst(MD_String8List* srl, void* out) { + MD_U8* ptr = (MD_U8*)out; + for (MD_String8Node *node = srl->first; node != 0; node = node->next) { - U64 size = node->string.size; - memory_copy(ptr, node->string.str, size); + MD_U64 size = node->string.size; + md_memory_copy(ptr, node->string.str, size); ptr += size; } } -void str8_serial_begin__arena (Arena* arena, String8List* srl); -String8 str8_serial_end__arena (Arena* arena, String8List* srl); -U64 str8_serial_push_align__arena (Arena* arena, String8List* srl, U64 align); -void* str8_serial_push_size__arena (Arena* arena, String8List* srl, U64 size); -void* str8_serial_push_data__arena (Arena* arena, String8List* srl, void* data, U64 size); -void str8_serial_push_data_list__arena(Arena* arena, String8List* srl, String8Node* first); -void str8_serial_push_u64__arena (Arena* arena, String8List* srl, U64 x); -void str8_serial_push_u32__arena (Arena* arena, String8List* srl, U32 x); -void str8_serial_push_u16__arena (Arena* arena, String8List* srl, U16 x); -void str8_serial_push_u8__arena (Arena* arena, String8List* srl, U8 x); -void str8_serial_push_cstr__arena (Arena* arena, String8List* srl, String8 str); -void str8_serial_push_string__arena (Arena* arena, String8List* srl, String8 str); +void md_str8_serial_begin__arena (MD_Arena* arena, MD_String8List* srl); +MD_String8 md_str8_serial_end__arena (MD_Arena* arena, MD_String8List* srl); +MD_U64 md_str8_serial_push_align__arena (MD_Arena* arena, MD_String8List* srl, MD_U64 align); +void* md_str8_serial_push_size__arena (MD_Arena* arena, MD_String8List* srl, MD_U64 size); +void* md_str8_serial_push_data__arena (MD_Arena* arena, MD_String8List* srl, void* data, MD_U64 size); +void md_str8_serial_push_data_list__arena(MD_Arena* arena, MD_String8List* srl, MD_String8Node* first); +void md_str8_serial_push_u64__arena (MD_Arena* arena, MD_String8List* srl, MD_U64 x); +void md_str8_serial_push_u32__arena (MD_Arena* arena, MD_String8List* srl, MD_U32 x); +void md_str8_serial_push_u16__arena (MD_Arena* arena, MD_String8List* srl, MD_U16 x); +void md_str8_serial_push_u8__arena (MD_Arena* arena, MD_String8List* srl, MD_U8 x); +void md_str8_serial_push_cstr__arena (MD_Arena* arena, MD_String8List* srl, MD_String8 str); +void md_str8_serial_push_string__arena (MD_Arena* arena, MD_String8List* srl, MD_String8 str); - void str8_serial_begin__ainfo (AllocatorInfo ainfo, String8List* srl); - String8 str8_serial_end__ainfo (AllocatorInfo ainfo, String8List* srl); -MD_API U64 str8_serial_push_align__ainfo (AllocatorInfo ainfo, String8List* srl, U64 align); -MD_API void* str8_serial_push_size__ainfo (AllocatorInfo ainfo, String8List* srl, U64 size); - void* str8_serial_push_data__ainfo (AllocatorInfo ainfo, String8List* srl, void* data, U64 size); - void str8_serial_push_data_list__ainfo(AllocatorInfo ainfo, String8List* srl, String8Node* first); -MD_API void str8_serial_push_u64__ainfo (AllocatorInfo ainfo, String8List* srl, U64 x); -MD_API void str8_serial_push_u32__ainfo (AllocatorInfo ainfo, String8List* srl, U32 x); - void str8_serial_push_u16__ainfo (AllocatorInfo ainfo, String8List* srl, U16 x); - void str8_serial_push_u8__ainfo (AllocatorInfo ainfo, String8List* srl, U8 x); - void str8_serial_push_cstr__ainfo (AllocatorInfo ainfo, String8List* srl, String8 str); - void str8_serial_push_string__ainfo (AllocatorInfo ainfo, String8List* srl, String8 str); + void md_str8_serial_begin__ainfo (MD_AllocatorInfo ainfo, MD_String8List* srl); + MD_String8 md_str8_serial_end__ainfo (MD_AllocatorInfo ainfo, MD_String8List* srl); +MD_API MD_U64 md_str8_serial_push_align__ainfo (MD_AllocatorInfo ainfo, MD_String8List* srl, MD_U64 align); +MD_API void* md_str8_serial_push_size__ainfo (MD_AllocatorInfo ainfo, MD_String8List* srl, MD_U64 size); + void* md_str8_serial_push_data__ainfo (MD_AllocatorInfo ainfo, MD_String8List* srl, void* data, MD_U64 size); + void md_str8_serial_push_data_list__ainfo(MD_AllocatorInfo ainfo, MD_String8List* srl, MD_String8Node* first); +MD_API void md_str8_serial_push_u64__ainfo (MD_AllocatorInfo ainfo, MD_String8List* srl, MD_U64 x); +MD_API void md_str8_serial_push_u32__ainfo (MD_AllocatorInfo ainfo, MD_String8List* srl, MD_U32 x); + void md_str8_serial_push_u16__ainfo (MD_AllocatorInfo ainfo, MD_String8List* srl, MD_U16 x); + void md_str8_serial_push_u8__ainfo (MD_AllocatorInfo ainfo, MD_String8List* srl, MD_U8 x); + void md_str8_serial_push_cstr__ainfo (MD_AllocatorInfo ainfo, MD_String8List* srl, MD_String8 str); + void md_str8_serial_push_string__ainfo (MD_AllocatorInfo ainfo, MD_String8List* srl, MD_String8 str); -#define str8_serial_begin(allocator, srl) _Generic(allocator, Arena*: str8_serial_begin__arena, AllocatorInfo: str8_serial_begin__ainfo, default: assert_generic_sel_fail) generic_call(allocator, srl) -#define str8_serial_end(allocator, srl) _Generic(allocator, Arena*: str8_serial_end__arena, AllocatorInfo: str8_serial_end__ainfo, default: assert_generic_sel_fail) generic_call(allocator, srl) -#define str8_serial_push_align(allocator, srl, align) _Generic(allocator, Arena*: str8_serial_push_align__arena, AllocatorInfo: str8_serial_push_align__ainfo, default: assert_generic_sel_fail) generic_call(allocator, srl, align) -#define str8_serial_push_size(allocator, srl, size) _Generic(allocator, Arena*: str8_serial_push_size__arena, AllocatorInfo: str8_serial_push_size__ainfo, default: assert_generic_sel_fail) generic_call(allocator, srl, size) -#define str8_serial_push_data(allocator, srl, data, usize) _Generic(allocator, Arena*: str8_serial_push_data__arena, AllocatorInfo: str8_serial_push_data__ainfo, default: assert_generic_sel_fail) generic_call(allocator, srl, data, usize) -#define str8_serial_push_data_list(allocator, srl, first) _Generic(allocator, Arena*: str8_serial_push_data_list__arena, AllocatorInfo: str8_serial_push_data_list__ainfo, default: assert_generic_sel_fail) generic_call(allocator, srl, first) -#define str8_serial_push_u64(allocator, srl, x) _Generic(allocator, Arena*: str8_serial_push_u64__arena, AllocatorInfo: str8_serial_push_u64__ainfo, default: assert_generic_sel_fail) generic_call(allocator, srl, x) -#define str8_serial_push_u32(allocator, srl, x) _Generic(allocator, Arena*: str8_serial_push_u32__arena, AllocatorInfo: str8_serial_push_u32__ainfo, default: assert_generic_sel_fail) generic_call(allocator, srl, x) -#define str8_serial_push_u16(allocator, srl, x) _Generic(allocator, Arena*: str8_serial_push_u16__arena, AllocatorInfo: str8_serial_push_u16__ainfo, default: assert_generic_sel_fail) generic_call(allocator, srl, x) -#define str8_serial_push_u8(allocator, srl, x) _Generic(allocator, Arena*: str8_serial_push_u8__arena, AllocatorInfo: str8_serial_push_u8__ainfo, default: assert_generic_sel_fail) generic_call(allocator, srl, x) -#define str8_serial_push_cstr(allocator, srl, str) _Generic(allocator, Arena*: str8_serial_push_cstr__arena, AllocatorInfo: str8_serial_push_cstr__ainfo, default: assert_generic_sel_fail) generic_call(allocator, srl, str) -#define str8_serial_push_string(allocator, slr, str) _Generic(allocator, Arena*: str8_serial_push_string__arena, AllocatorInfo: str8_serial_push_string__ainfo, default: assert_generic_sel_fail) generic_call(allocator, srl, str) +#define md_str8_serial_begin(allocator, srl) _Generic(allocator, MD_Arena*: md_str8_serial_begin__arena, MD_AllocatorInfo: md_str8_serial_begin__ainfo, default: md_assert_generic_sel_fail) md_generic_call(allocator, srl) +#define md_str8_serial_end(allocator, srl) _Generic(allocator, MD_Arena*: md_str8_serial_end__arena, MD_AllocatorInfo: md_str8_serial_end__ainfo, default: md_assert_generic_sel_fail) md_generic_call(allocator, srl) +#define md_str8_serial_push_align(allocator, srl, align) _Generic(allocator, MD_Arena*: md_str8_serial_push_align__arena, MD_AllocatorInfo: md_str8_serial_push_align__ainfo, default: md_assert_generic_sel_fail) md_generic_call(allocator, srl, align) +#define md_str8_serial_push_size(allocator, srl, size) _Generic(allocator, MD_Arena*: md_str8_serial_push_size__arena, MD_AllocatorInfo: md_str8_serial_push_size__ainfo, default: md_assert_generic_sel_fail) md_generic_call(allocator, srl, size) +#define md_str8_serial_push_data(allocator, srl, data, usize) _Generic(allocator, MD_Arena*: md_str8_serial_push_data__arena, MD_AllocatorInfo: md_str8_serial_push_data__ainfo, default: md_assert_generic_sel_fail) md_generic_call(allocator, srl, data, usize) +#define md_str8_serial_push_data_list(allocator, srl, first) _Generic(allocator, MD_Arena*: md_str8_serial_push_data_list__arena, MD_AllocatorInfo: md_str8_serial_push_data_list__ainfo, default: md_assert_generic_sel_fail) md_generic_call(allocator, srl, first) +#define md_str8_serial_push_u64(allocator, srl, x) _Generic(allocator, MD_Arena*: md_str8_serial_push_u64__arena, MD_AllocatorInfo: md_str8_serial_push_u64__ainfo, default: md_assert_generic_sel_fail) md_generic_call(allocator, srl, x) +#define md_str8_serial_push_u32(allocator, srl, x) _Generic(allocator, MD_Arena*: md_str8_serial_push_u32__arena, MD_AllocatorInfo: md_str8_serial_push_u32__ainfo, default: md_assert_generic_sel_fail) md_generic_call(allocator, srl, x) +#define md_str8_serial_push_u16(allocator, srl, x) _Generic(allocator, MD_Arena*: md_str8_serial_push_u16__arena, MD_AllocatorInfo: md_str8_serial_push_u16__ainfo, default: md_assert_generic_sel_fail) md_generic_call(allocator, srl, x) +#define md_str8_serial_push_u8(allocator, srl, x) _Generic(allocator, MD_Arena*: md_str8_serial_push_u8__arena, MD_AllocatorInfo: md_str8_serial_push_u8__ainfo, default: md_assert_generic_sel_fail) md_generic_call(allocator, srl, x) +#define md_str8_serial_push_cstr(allocator, srl, str) _Generic(allocator, MD_Arena*: md_str8_serial_push_cstr__arena, MD_AllocatorInfo: md_str8_serial_push_cstr__ainfo, default: md_assert_generic_sel_fail) md_generic_call(allocator, srl, str) +#define md_str8_serial_push_string(allocator, slr, str) _Generic(allocator, MD_Arena*: md_str8_serial_push_string__arena, MD_AllocatorInfo: md_str8_serial_push_string__ainfo, default: md_assert_generic_sel_fail) md_generic_call(allocator, srl, str) -force_inline U64 str8_serial_push_align__arena(Arena* arena, String8List* srl, U64 align) { return str8_serial_push_align__ainfo(arena_allocator(arena), srl, align); } -force_inline void* str8_serial_push_size__arena (Arena* arena, String8List* srl, U64 size) { return str8_serial_push_size__ainfo (arena_allocator(arena), srl, size); } -force_inline void str8_serial_push_u64__arena (Arena* arena, String8List* srl, U64 x) { str8_serial_push_u64__ainfo (arena_allocator(arena), srl, x); } -force_inline void str8_serial_push_u32__arena (Arena* arena, String8List* srl, U32 x) { str8_serial_push_u32__ainfo (arena_allocator(arena), srl, x); } +md_force_inline MD_U64 md_str8_serial_push_align__arena(MD_Arena* arena, MD_String8List* srl, MD_U64 align) { return md_str8_serial_push_align__ainfo(md_arena_allocator(arena), srl, align); } +md_force_inline void* md_str8_serial_push_size__arena (MD_Arena* arena, MD_String8List* srl, MD_U64 size) { return md_str8_serial_push_size__ainfo (md_arena_allocator(arena), srl, size); } +md_force_inline void md_str8_serial_push_u64__arena (MD_Arena* arena, MD_String8List* srl, MD_U64 x) { md_str8_serial_push_u64__ainfo (md_arena_allocator(arena), srl, x); } +md_force_inline void md_str8_serial_push_u32__arena (MD_Arena* arena, MD_String8List* srl, MD_U32 x) { md_str8_serial_push_u32__ainfo (md_arena_allocator(arena), srl, x); } -force_inline void str8_serial_begin__arena(Arena* arena, String8List* srl) { str8_serial_begin__ainfo(arena_allocator(arena), srl); } -force_inline String8 str8_serial_end__arena (Arena* arena, String8List* srl) { return str8_serial_end__ainfo (arena_allocator(arena), srl); } +md_force_inline void md_str8_serial_begin__arena(MD_Arena* arena, MD_String8List* srl) { md_str8_serial_begin__ainfo(md_arena_allocator(arena), srl); } +md_force_inline MD_String8 md_str8_serial_end__arena (MD_Arena* arena, MD_String8List* srl) { return md_str8_serial_end__ainfo (md_arena_allocator(arena), srl); } -force_inline void str8_serial_push_u16__arena (Arena* arena, String8List* srl, U16 x) { str8_serial_push_data__arena(arena, srl, &x, sizeof(x)); } -force_inline void str8_serial_push_u8__arena (Arena* arena, String8List* srl, U8 x) { str8_serial_push_data__arena(arena, srl, &x, sizeof(x)); } -force_inline void str8_serial_push_cstr__arena (Arena* arena, String8List* srl, String8 str) { str8_serial_push_data__arena(arena, srl, str.str, str.size); str8_serial_push_u8__arena(arena, srl, 0); } -force_inline void str8_serial_push_string__arena(Arena* arena, String8List* srl, String8 str) { str8_serial_push_data__arena(arena, srl, str.str, str.size); } +md_force_inline void md_str8_serial_push_u16__arena (MD_Arena* arena, MD_String8List* srl, MD_U16 x) { md_str8_serial_push_data__arena(arena, srl, &x, sizeof(x)); } +md_force_inline void md_str8_serial_push_u8__arena (MD_Arena* arena, MD_String8List* srl, MD_U8 x) { md_str8_serial_push_data__arena(arena, srl, &x, sizeof(x)); } +md_force_inline void md_str8_serial_push_cstr__arena (MD_Arena* arena, MD_String8List* srl, MD_String8 str) { md_str8_serial_push_data__arena(arena, srl, str.str, str.size); md_str8_serial_push_u8__arena(arena, srl, 0); } +md_force_inline void md_str8_serial_push_string__arena(MD_Arena* arena, MD_String8List* srl, MD_String8 str) { md_str8_serial_push_data__arena(arena, srl, str.str, str.size); } -force_inline void str8_serial_push_u16__ainfo (AllocatorInfo ainfo, String8List* srl, U16 x) { str8_serial_push_data__ainfo(ainfo, srl, &x, sizeof(x)); } -force_inline void str8_serial_push_u8__ainfo (AllocatorInfo ainfo, String8List* srl, U8 x) { str8_serial_push_data__ainfo(ainfo, srl, &x, sizeof(x)); } -force_inline void str8_serial_push_cstr__ainfo (AllocatorInfo ainfo, String8List* srl, String8 str) { str8_serial_push_data__ainfo(ainfo, srl, str.str, str.size); str8_serial_push_u8__ainfo(ainfo, srl, 0); } -force_inline void str8_serial_push_string__ainfo(AllocatorInfo ainfo, String8List* srl, String8 str) { str8_serial_push_data__ainfo(ainfo, srl, str.str, str.size); } +md_force_inline void md_str8_serial_push_u16__ainfo (MD_AllocatorInfo ainfo, MD_String8List* srl, MD_U16 x) { md_str8_serial_push_data__ainfo(ainfo, srl, &x, sizeof(x)); } +md_force_inline void md_str8_serial_push_u8__ainfo (MD_AllocatorInfo ainfo, MD_String8List* srl, MD_U8 x) { md_str8_serial_push_data__ainfo(ainfo, srl, &x, sizeof(x)); } +md_force_inline void md_str8_serial_push_cstr__ainfo (MD_AllocatorInfo ainfo, MD_String8List* srl, MD_String8 str) { md_str8_serial_push_data__ainfo(ainfo, srl, str.str, str.size); md_str8_serial_push_u8__ainfo(ainfo, srl, 0); } +md_force_inline void md_str8_serial_push_string__ainfo(MD_AllocatorInfo ainfo, MD_String8List* srl, MD_String8 str) { md_str8_serial_push_data__ainfo(ainfo, srl, str.str, str.size); } inline void* -str8_serial_push_data__arena(Arena* arena, String8List* srl, void* data, U64 size) { - void* result = str8_serial_push_size__arena(arena, srl, size); +md_str8_serial_push_data__arena(MD_Arena* arena, MD_String8List* srl, void* data, MD_U64 size) { + void* result = md_str8_serial_push_size__arena(arena, srl, size); if(result != 0) { - memory_copy(result, data, size); + md_memory_copy(result, data, size); } return result; } inline void -str8_serial_push_data_list__arena(Arena* arena, String8List* srl, String8Node* first) { - for (String8Node* node = first; node != 0; node = node->next) { - str8_serial_push_data__arena(arena, srl, node->string.str, node->string.size); +md_str8_serial_push_data_list__arena(MD_Arena* arena, MD_String8List* srl, MD_String8Node* first) { + for (MD_String8Node* node = first; node != 0; node = node->next) { + md_str8_serial_push_data__arena(arena, srl, node->string.str, node->string.size); } } inline void -str8_serial_begin__ainfo(AllocatorInfo ainfo, String8List* srl) { - String8Node* node = alloc_array(ainfo, String8Node, 1); - node->string.str = alloc_array_no_zero(ainfo, U8, 0); +md_str8_serial_begin__ainfo(MD_AllocatorInfo ainfo, MD_String8List* srl) { + MD_String8Node* node = md_alloc_array(ainfo, MD_String8Node, 1); + node->string.str = md_alloc_array_no_zero(ainfo, MD_U8, 0); srl->first = srl->last = node; - srl->node_count = 1; + srl->md_node_count = 1; srl->total_size = 0; } -inline String8 -str8_serial_end_alloc(AllocatorInfo ainfo, String8List* srl) { - U64 size = srl->total_size; - U8* out = alloc_array_no_zero(ainfo, U8, size); - str8_serial_write_to_dst(srl, out); - String8 result = str8(out, size); +inline MD_String8 +md_str8_serial_end_alloc(MD_AllocatorInfo ainfo, MD_String8List* srl) { + MD_U64 size = srl->total_size; + MD_U8* out = md_alloc_array_no_zero(ainfo, MD_U8, size); + md_str8_serial_write_to_dst(srl, out); + MD_String8 result = md_str8(out, size); return result; } inline void* -str8_serial_push_data__ainfo(AllocatorInfo ainfo, String8List* srl, void* data, U64 size) { - void* result = str8_serial_push_size(ainfo, srl, size); +md_str8_serial_push_data__ainfo(MD_AllocatorInfo ainfo, MD_String8List* srl, void* data, MD_U64 size) { + void* result = md_str8_serial_push_size(ainfo, srl, size); if(result != 0) { - memory_copy(result, data, size); + md_memory_copy(result, data, size); } return result; } inline void -str8_serial_push_data_list__ainfo(AllocatorInfo ainfo, String8List* srl, String8Node* first) { - for (String8Node* node = first; node != 0; node = node->next) { - str8_serial_push_data__ainfo(ainfo, srl, node->string.str, node->string.size); +md_str8_serial_push_data_list__ainfo(MD_AllocatorInfo ainfo, MD_String8List* srl, MD_String8Node* first) { + for (MD_String8Node* node = first; node != 0; node = node->next) { + md_str8_serial_push_data__ainfo(ainfo, srl, node->string.str, node->string.size); } } //////////////////////////////// //~ rjf: Deserialization Helpers -#define str8_deserial_read_array(string, off, ptr, count) str8_deserial_read((string), (off), (ptr), sizeof(*(ptr)) * (count), sizeof( *(ptr))) -#define str8_deserial_read_struct(string, off, ptr) str8_deserial_read((string), (off), (ptr), sizeof(*(ptr)), sizeof( *(ptr))) +#define md_str8_deserial_read_array(string, off, ptr, count) md_str8_deserial_read((string), (off), (ptr), sizeof(*(ptr)) * (count), sizeof( *(ptr))) +#define md_str8_deserial_read_struct(string, off, ptr) md_str8_deserial_read((string), (off), (ptr), sizeof(*(ptr)), sizeof( *(ptr))) -MD_API U64 str8_deserial_read (String8 string, U64 off, void* read_dst, U64 read_size, U64 granularity); -MD_API U64 str8_deserial_find_first_match (String8 string, U64 off, U16 scan_val); - void* str8_deserial_get_raw_ptr (String8 string, U64 off, U64 size); -MD_API U64 str8_deserial_read_cstr (String8 string, U64 off, String8* cstr_out); -MD_API U64 str8_deserial_read_windows_utf16_string16(String8 string, U64 off, String16* str_out); - U64 str8_deserial_read_block (String8 string, U64 off, U64 size, String8* block_out); -MD_API U64 str8_deserial_read_uleb128 (String8 string, U64 off, U64* value_out); -MD_API U64 str8_deserial_read_sleb128 (String8 string, U64 off, S64* value_out); +MD_API MD_U64 md_str8_deserial_read (MD_String8 string, MD_U64 off, void* read_dst, MD_U64 read_size, MD_U64 granularity); +MD_API MD_U64 md_str8_deserial_find_first_match (MD_String8 string, MD_U64 off, MD_U16 scan_val); + void* md_str8_deserial_get_raw_ptr (MD_String8 string, MD_U64 off, MD_U64 size); +MD_API MD_U64 md_str8_deserial_read_cstr (MD_String8 string, MD_U64 off, MD_String8* cstr_out); +MD_API MD_U64 md_str8_deserial_read_windows_utf16_string16(MD_String8 string, MD_U64 off, MD_String16* md_str_out); + MD_U64 md_str8_deserial_read_block (MD_String8 string, MD_U64 off, MD_U64 size, MD_String8* block_out); +MD_API MD_U64 md_str8_deserial_read_uleb128 (MD_String8 string, MD_U64 off, MD_U64* value_out); +MD_API MD_U64 md_str8_deserial_read_sleb128 (MD_String8 string, MD_U64 off, MD_S64* value_out); -inline void* str8_deserial_get_raw_ptr(String8 string, U64 off, U64 size) { void* raw_ptr = 0; if (off + size <= string.size) { raw_ptr = string.str + off; } return raw_ptr; } -inline U64 str8_deserial_read_block (String8 string, U64 off, U64 size, String8* block_out) { Rng1U64 range = rng_1u64(off, off + size); *block_out = str8_substr(string, range); return block_out->size; } +inline void* md_str8_deserial_get_raw_ptr(MD_String8 string, MD_U64 off, MD_U64 size) { void* raw_ptr = 0; if (off + size <= string.size) { raw_ptr = string.str + off; } return raw_ptr; } +inline MD_U64 md_str8_deserial_read_block (MD_String8 string, MD_U64 off, MD_U64 size, MD_String8* block_out) { MD_Rng1U64 range = md_rng_1u64(off, off + size); *block_out = md_str8_substr(string, range); return block_out->size; } //////////////////////////////// // Second-order Generic Selectors -#define str8_from(allocator, in) \ +#define md_str8_from(allocator, in) \ _Generic((in), \ - SSIZE : _Generic(allocator, Arena*: str8_from_memory_size__arena, AllocatorInfo: str8_from_memory_size__ainfo, default: assert_generic_sel_fail), \ + MD_SSIZE : _Generic(allocator, MD_Arena*: md_str8_from_memory_size__arena, MD_AllocatorInfo: md_str8_from_memory_size__ainfo, default: md_assert_generic_sel_fail), \ _Generic_L2((in), \ - String16: _Generic(allocator, Arena*: str8_from_str16__arena, AllocatorInfo: str8_from_str16__ainfo, default: assert_generic_sel_fail), \ - String32: _Generic(allocator, Arena*: str8_from_str32__arena, AllocatorInfo: str8_from_str32__ainfo, default: assert_generic_sel_fail), \ - U64 : _Generic(allocator, Arena*: str8_from_u64__arena, AllocatorInfo: str8_from_u64__ainfo, default: assert_generic_sel_fail), \ - S64 : _Generic(allocator, Arena*: str8_from_s64__arena, AllocatorInfo: str8_from_s64__ainfo, default: assert_generic_sel_fail), \ - default : assert_generic_sel_fail) \ -) generic_call(allocator, in) + MD_String16: _Generic(allocator, MD_Arena*: md_str8_from_str16__arena, MD_AllocatorInfo: md_str8_from_str16__ainfo, default: md_assert_generic_sel_fail), \ + MD_String32: _Generic(allocator, MD_Arena*: md_str8_from_str32__arena, MD_AllocatorInfo: md_str8_from_str32__ainfo, default: md_assert_generic_sel_fail), \ + MD_U64 : _Generic(allocator, MD_Arena*: md_str8_from_u64__arena, MD_AllocatorInfo: md_str8_from_u64__ainfo, default: md_assert_generic_sel_fail), \ + MD_S64 : _Generic(allocator, MD_Arena*: md_str8_from_s64__arena, MD_AllocatorInfo: md_str8_from_s64__ainfo, default: md_assert_generic_sel_fail), \ + default : md_assert_generic_sel_fail) \ +) md_generic_call(allocator, in) -#define str16_from(allocator, in) \ +#define md_str16_from(allocator, in) \ _Generic(in, \ - String8: _Generic(allocator, Arena*: str16_from_str8__arena, AllocatorInfo: str16_from_str8__ainfo, default: assert_generic_sel_fail), \ - default: assert_generic_sel_fail \ -) generic_call(allocator, in) + MD_String8: _Generic(allocator, MD_Arena*: md_str16_from_str8__arena, MD_AllocatorInfo: md_str16_from_str8__ainfo, default: md_assert_generic_sel_fail), \ + default: md_assert_generic_sel_fail \ +) md_generic_call(allocator, in) diff --git a/source/base/text.c b/source/base/text.c index a2ba48d..0731f72 100644 --- a/source/base/text.c +++ b/source/base/text.c @@ -5,23 +5,23 @@ //////////////////////////////// //~ rjf: Text Path Helpers -String8TxtPtPair -str8_txt_pt_pair_from_string(String8 string) +MD_String8TxtPtPair +md_str8_txt_pt_pair_from_string(MD_String8 string) { - String8TxtPtPair pair = {0}; + MD_String8TxtPtPair pair = {0}; { - String8 file_part = {0}; - String8 line_part = {0}; - String8 col_part = {0}; + MD_String8 file_part = {0}; + MD_String8 line_part = {0}; + MD_String8 col_part = {0}; // rjf: grab file part - for(U64 idx = 0; idx <= string.size; idx += 1) + for(MD_U64 idx = 0; idx <= string.size; idx += 1) { - U8 byte = (idx < string.size) ? (string.str[idx ]) : 0; - U8 next_byte = ((idx + 1 < string.size) ? (string.str[idx + 1]) : 0); + MD_U8 byte = (idx < string.size) ? (string.str[idx ]) : 0; + MD_U8 next_byte = ((idx + 1 < string.size) ? (string.str[idx + 1]) : 0); if(byte == ':' && next_byte != '/' && next_byte != '\\') { - file_part = str8_prefix(string, idx); - line_part = str8_skip(string, idx+1); + file_part = md_str8_prefix(string, idx); + line_part = md_str8_skip(string, idx+1); break; } else if(byte == 0) { @@ -31,22 +31,22 @@ str8_txt_pt_pair_from_string(String8 string) } // rjf: grab line/column { - U64 colon_pos = str8_find_needle(line_part, 0, str8_lit(":"), 0); + MD_U64 colon_pos = md_str8_find_needle(line_part, 0, md_str8_lit(":"), 0); if(colon_pos < line_part.size) { - col_part = str8_skip (line_part, colon_pos + 1); - line_part = str8_prefix(line_part, colon_pos); + col_part = md_str8_skip (line_part, colon_pos + 1); + line_part = md_str8_prefix(line_part, colon_pos); } } // rjf: convert line/column strings to numerics - U64 line = 0; - U64 column = 0; - try_u64_from_str8_c_rules(line_part, &line); - try_u64_from_str8_c_rules(col_part, &column); + MD_U64 line = 0; + MD_U64 column = 0; + md_try_u64_from_str8_c_rules(line_part, &line); + md_try_u64_from_str8_c_rules(col_part, &column); // rjf: fill pair.string = file_part; - pair.pt = txt_pt((S64)line, (S64)column); + pair.pt = md_txt_pt((MD_S64)line, (MD_S64)column); if(pair.pt.line == 0) { pair.pt.line = 1; } if(pair.pt.column == 0) { pair.pt.column = 1; } } diff --git a/source/base/text.h b/source/base/text.h index 2ddf599..733398a 100644 --- a/source/base/text.h +++ b/source/base/text.h @@ -6,54 +6,54 @@ //////////////////////////////// //~ rjf: Text 2D Coordinates & Ranges -typedef struct TxtPt TxtPt; -struct TxtPt +typedef struct MD_TxtPt MD_TxtPt; +struct MD_TxtPt { - S64 line; - S64 column; + MD_S64 line; + MD_S64 column; }; -typedef struct TxtRng TxtRng; -struct TxtRng +typedef struct MD_TxtRng MD_TxtRng; +struct MD_TxtRng { - TxtPt min; - TxtPt max; + MD_TxtPt md_min; + MD_TxtPt md_max; }; //////////////////////////////// //~ rjf: String Pair Types -typedef struct String8TxtPtPair String8TxtPtPair; -struct String8TxtPtPair +typedef struct MD_String8TxtPtPair MD_String8TxtPtPair; +struct MD_String8TxtPtPair { - String8 string; - TxtPt pt; + MD_String8 string; + MD_TxtPt pt; }; //////////////////////////////// //~ rjf: Text Path Helpers -MD_API String8TxtPtPair str8_txt_pt_pair_from_string(String8 string); +MD_API MD_String8TxtPtPair md_str8_txt_pt_pair_from_string(MD_String8 string); //////////////////////////////// //~ rjf: Text 2D Coordinate/Range Functions -inline TxtPt txt_pt(S64 line, S64 column) { TxtPt p = { line, column }; return p; } +inline MD_TxtPt md_txt_pt(MD_S64 line, MD_S64 column) { MD_TxtPt p = { line, column }; return p; } -inline B32 txt_pt_match(TxtPt a, TxtPt b) { return a.line == b.line && a.column == b.column; } -inline TxtPt txt_pt_min (TxtPt a, TxtPt b) { TxtPt result = b; if (txt_pt_less_than(a, b)) { result = a; } return result; } -inline TxtPt txt_pt_max (TxtPt a, TxtPt b) { TxtPt result = a; if (txt_pt_less_than(a, b)) { result = b; } return result; } +inline MD_B32 md_txt_pt_match(MD_TxtPt a, MD_TxtPt b) { return a.line == b.line && a.column == b.column; } +inline MD_TxtPt md_txt_pt_min (MD_TxtPt a, MD_TxtPt b) { MD_TxtPt result = b; if (md_txt_pt_less_than(a, b)) { result = a; } return result; } +inline MD_TxtPt md_txt_pt_max (MD_TxtPt a, MD_TxtPt b) { MD_TxtPt result = a; if (md_txt_pt_less_than(a, b)) { result = b; } return result; } -B32 txt_pt_less_than (TxtPt a, TxtPt b); -TxtRng txt_rng (TxtPt min, TxtPt max); -TxtRng txt_rng_intersect(TxtRng a, TxtRng b); -TxtRng txt_rng_union (TxtRng a, TxtRng b); -B32 txt_rng_contains (TxtRng r, TxtPt pt); +MD_B32 md_txt_pt_less_than (MD_TxtPt a, MD_TxtPt b); +MD_TxtRng md_txt_rng (MD_TxtPt md_min, MD_TxtPt md_max); +MD_TxtRng md_txt_rng_intersect(MD_TxtRng a, MD_TxtRng b); +MD_TxtRng md_txt_rng_union (MD_TxtRng a, MD_TxtRng b); +MD_B32 md_txt_rng_contains (MD_TxtRng r, MD_TxtPt pt); -inline B32 -txt_pt_less_than(TxtPt a, TxtPt b) +inline MD_B32 +md_txt_pt_less_than(MD_TxtPt a, MD_TxtPt b) { - B32 result = 0; + MD_B32 result = 0; if (a.line < b.line) { result = 1; } @@ -63,44 +63,44 @@ txt_pt_less_than(TxtPt a, TxtPt b) return result; } -inline TxtRng -txt_rng(TxtPt min, TxtPt max) +inline MD_TxtRng +md_txt_rng(MD_TxtPt md_min, MD_TxtPt md_max) { - TxtRng range = {0}; - if(txt_pt_less_than(min, max)) { - range.min = min; - range.max = max; + MD_TxtRng range = {0}; + if(md_txt_pt_less_than(md_min, md_max)) { + range.md_min = md_min; + range.md_max = md_max; } else { - range.min = max; - range.max = min; + range.md_min = md_max; + range.md_max = md_min; } return range; } -inline TxtRng -txt_rng_intersect(TxtRng a, TxtRng b) +inline MD_TxtRng +md_txt_rng_intersect(MD_TxtRng a, MD_TxtRng b) { - TxtRng result = {0}; - result.min = txt_pt_max(a.min, b.min); - result.max = txt_pt_min(a.max, b.max); - if (txt_pt_less_than(result.max, result.min)) { + MD_TxtRng result = {0}; + result.md_min = md_txt_pt_max(a.md_min, b.md_min); + result.md_max = md_txt_pt_min(a.md_max, b.md_max); + if (md_txt_pt_less_than(result.md_max, result.md_min)) { MemoryZeroStruct(&result); } return result; } -inline TxtRng -txt_rng_union(TxtRng a, TxtRng b) +inline MD_TxtRng +md_txt_rng_union(MD_TxtRng a, MD_TxtRng b) { - TxtRng result = {0}; - result.min = txt_pt_min(a.min, b.min); - result.max = txt_pt_max(a.max, b.max); + MD_TxtRng result = {0}; + result.md_min = md_txt_pt_min(a.md_min, b.md_min); + result.md_max = md_txt_pt_max(a.md_max, b.md_max); return result; } -inline B32 -txt_rng_contains(TxtRng r, TxtPt pt) { - B32 result = ((txt_pt_less_than(r.min, pt) || txt_pt_match(r.min, pt)) && txt_pt_less_than(pt, r.max)); +inline MD_B32 +md_txt_rng_contains(MD_TxtRng r, MD_TxtPt pt) { + MD_B32 result = ((md_txt_pt_less_than(r.md_min, pt) || md_txt_pt_match(r.md_min, pt)) && md_txt_pt_less_than(pt, r.md_max)); return result; } diff --git a/source/base/thread_context.c b/source/base/thread_context.c index 749c0a6..84d6bf6 100644 --- a/source/base/thread_context.c +++ b/source/base/thread_context.c @@ -7,79 +7,79 @@ // Licensed under the MIT license (https://opensource.org/license/mit/) //////////////////////////////// -// NOTE(allen): Thread Context Functions +// NOTE(allen): Thread MD_Context Functions -MD_API_C thread_static TCTX* tctx_thread_local; +MD_API_C md_thread_static MD_TCTX* md_tctx_thread_local; #if ! MD_BUILD_SUPPLEMENTARY_UNIT -MD_API_C thread_static TCTX* tctx_thread_local = 0; +MD_API_C md_thread_static MD_TCTX* md_tctx_thread_local = 0; #endif void -tctx_init_and_equip(TCTX* tctx) +md_tctx_init_and_equip(MD_TCTX* md_tctx) { - // memory_zero_struct(tctx); + // md_memory_zero_struct(md_tctx); - Arena** arena_ptr = tctx->arenas; - for (U64 i = 0; i < array_count(tctx->arenas); i += 1, arena_ptr += 1) + MD_Arena** md_arena_ptr = md_tctx->arenas; + for (MD_U64 i = 0; i < md_array_count(md_tctx->arenas); i += 1, md_arena_ptr += 1) { - if (*arena_ptr == nullptr) + if (*md_arena_ptr == md_nullptr) { - VArena* vm = varena_alloc(.reserve_size = VARENA_DEFAULT_RESERVE, .commit_size = VARENA_DEFAULT_COMMIT); - *arena_ptr = arena_alloc(.backing = varena_allocator(vm)); + MD_VArena* vm = md_varena_alloc(.reserve_size = MD_VARENA_DEFAULT_RESERVE, .commit_size = MD_VARENA_DEFAULT_COMMIT); + *md_arena_ptr = md_arena_alloc(.backing = md_varena_allocator(vm)); } } - tctx_thread_local = tctx; + md_tctx_thread_local = md_tctx; } void -tctx_init_and_equip_alloc(TCTX* tctx, AllocatorInfo ainfo) +md_tctx_init_and_equip_alloc(MD_TCTX* md_tctx, MD_AllocatorInfo ainfo) { - memory_zero_struct(tctx); + md_memory_zero_struct(md_tctx); - Arena** arena_ptr = tctx->arenas; - for (U64 i = 0; i < array_count(tctx->arenas); i += 1, arena_ptr += 1) + MD_Arena** md_arena_ptr = md_tctx->arenas; + for (MD_U64 i = 0; i < md_array_count(md_tctx->arenas); i += 1, md_arena_ptr += 1) { - if (*arena_ptr == nullptr) + if (*md_arena_ptr == md_nullptr) { - *arena_ptr = arena_alloc(.backing = ainfo); + *md_arena_ptr = md_arena_alloc(.backing = ainfo); } } - tctx_thread_local = tctx; + md_tctx_thread_local = md_tctx; } void -tctx_release(void) { - for (U64 i = 0; i < array_count(tctx_thread_local->arenas); i += 1) { - arena_release(tctx_thread_local->arenas[i]); +md_tctx_release(void) { + for (MD_U64 i = 0; i < md_array_count(md_tctx_thread_local->arenas); i += 1) { + md_arena_release(md_tctx_thread_local->arenas[i]); } } -TCTX* -tctx_get_equipped(void){ - return(tctx_thread_local); +MD_TCTX* +md_tctx_get_equipped(void){ + return(md_tctx_thread_local); } -Arena* -tctx_get_scratch(Arena** conflicts, U64 count) +MD_Arena* +md_tctx_get_scratch(MD_Arena** conflicts, MD_U64 count) { - TCTX* tctx = tctx_get_equipped(); + MD_TCTX* md_tctx = md_tctx_get_equipped(); - Arena* result = 0; - Arena** arena_ptr = tctx->arenas; - for (U64 i = 0; i < array_count(tctx->arenas); i += 1, arena_ptr += 1) + MD_Arena* result = 0; + MD_Arena** md_arena_ptr = md_tctx->arenas; + for (MD_U64 i = 0; i < md_array_count(md_tctx->arenas); i += 1, md_arena_ptr += 1) { - Arena** conflict_ptr = conflicts; - B32 has_conflict = 0; - for (U64 j = 0; j < count; j += 1, conflict_ptr += 1) + MD_Arena** conflict_ptr = conflicts; + MD_B32 has_conflict = 0; + for (MD_U64 j = 0; j < count; j += 1, conflict_ptr += 1) { - if (*arena_ptr == *conflict_ptr) { + if (*md_arena_ptr == *conflict_ptr) { has_conflict = 1; break; } } if ( ! has_conflict){ - result = *arena_ptr; + result = *md_arena_ptr; break; } } diff --git a/source/base/thread_context.h b/source/base/thread_context.h index 771469c..1b8ceaf 100644 --- a/source/base/thread_context.h +++ b/source/base/thread_context.h @@ -8,83 +8,83 @@ // Licensed under the MIT license (https://opensource.org/license/mit/) //////////////////////////////// -// NOTE(allen): Thread Context +// NOTE(allen): Thread MD_Context -typedef struct TCTX TCTX; -struct TCTX +typedef struct MD_TCTX MD_TCTX; +struct MD_TCTX { - Arena* arenas[2]; + MD_Arena* arenas[2]; - U8 thread_name[32]; - U64 thread_name_size; + MD_U8 md_thread_name[32]; + MD_U64 thread_name_size; char* file_name; - U64 line_number; + MD_U64 line_number; }; //////////////////////////////// -// NOTE(allen): Thread Context Functions +// NOTE(allen): Thread MD_Context Functions -MD_API void tctx_init_and_equip (TCTX* tctx); -MD_API void tctx_init_and_equip_alloc(TCTX* tctx, AllocatorInfo ainfo); -MD_API void tctx_release (void); -MD_API TCTX* tctx_get_equipped (void); +MD_API void md_tctx_init_and_equip (MD_TCTX* md_tctx); +MD_API void md_tctx_init_and_equip_alloc(MD_TCTX* md_tctx, MD_AllocatorInfo ainfo); +MD_API void md_tctx_release (void); +MD_API MD_TCTX* md_tctx_get_equipped (void); -MD_API Arena* tctx_get_scratch(Arena** conflicts, U64 count); +MD_API MD_Arena* md_tctx_get_scratch(MD_Arena** conflicts, MD_U64 count); -void tctx_set_thread_name(String8 name); -String8 tctx_get_thread_name(void); +void md_tctx_set_thread_name(MD_String8 name); +MD_String8 md_tctx_get_thread_name(void); -void tctx_write_srcloc(char* file_name, U64 line_number); -void tctx_read_srcloc (char** file_name, U64* line_number); -#define tctx_write_this_srcloc() tctx_write_srcloc(__FILE__, __LINE__) +void md_tctx_write_srcloc(char* file_name, MD_U64 line_number); +void md_tctx_read_srcloc (char** file_name, MD_U64* line_number); +#define md_tctx_write_this_srcloc() md_tctx_write_srcloc(__FILE__, __LINE__) -typedef struct { U64 count; } Opt_ScratchBegin; +typedef struct { MD_U64 count; } Opt_ScratchBegin; -inline TempArena -scratch_begin__ainfo(AllocatorInfo ainfo, Opt_ScratchBegin opt) { - Arena* arena = extract_arena(ainfo); - TempArena scratch = temp_begin(tctx_get_scratch(&arena, arena != nullptr)); +inline MD_TempArena +md_scratch_begin__ainfo(MD_AllocatorInfo ainfo, Opt_ScratchBegin opt) { + MD_Arena* arena = md_extract_arena(ainfo); + MD_TempArena scratch = md_temp_begin(md_tctx_get_scratch(&arena, arena != md_nullptr)); return scratch; } -force_inline TempArena scratch_begin__arena(Arena** arena, Opt_ScratchBegin opt) { TempArena scratch = temp_begin(tctx_get_scratch(arena, opt.count)); return scratch; } +md_force_inline MD_TempArena md_scratch_begin__arena(MD_Arena** arena, Opt_ScratchBegin opt) { MD_TempArena scratch = md_temp_begin(md_tctx_get_scratch(arena, opt.count)); return scratch; } -#define scratch_begin(conflicts, ...) \ +#define md_scratch_begin(conflicts, ...) \ _Generic(conflicts, \ - int : scratch_begin__arena, \ - Arena** : scratch_begin__arena, \ - AllocatorInfo: scratch_begin__ainfo, \ - default : assert_generic_sel_fail \ -) generic_call(conflicts, (Opt_ScratchBegin){__VA_ARGS__}) + int : md_scratch_begin__arena, \ + MD_Arena** : md_scratch_begin__arena, \ + MD_AllocatorInfo: md_scratch_begin__ainfo, \ + default : md_assert_generic_sel_fail \ +) md_generic_call(conflicts, (Opt_ScratchBegin){__VA_ARGS__}) -#define scratch_end(scratch) temp_end(scratch) +#define scratch_end(scratch) md_temp_end(scratch) inline void -tctx_set_thread_name(String8 string){ - TCTX* tctx = tctx_get_equipped(); - U64 size = clamp_top(string.size, sizeof(tctx->thread_name)); - memory_copy(tctx->thread_name, string.str, size); - tctx->thread_name_size = size; +md_tctx_set_thread_name(MD_String8 string){ + MD_TCTX* md_tctx = md_tctx_get_equipped(); + MD_U64 size = md_clamp_top(string.size, sizeof(md_tctx->md_thread_name)); + md_memory_copy(md_tctx->md_thread_name, string.str, size); + md_tctx->thread_name_size = size; } -inline String8 -tctx_get_thread_name(void) { - TCTX* tctx = tctx_get_equipped(); - String8 result = str8(tctx->thread_name, tctx->thread_name_size); +inline MD_String8 +md_tctx_get_thread_name(void) { + MD_TCTX* md_tctx = md_tctx_get_equipped(); + MD_String8 result = md_str8(md_tctx->md_thread_name, md_tctx->thread_name_size); return(result); } inline void -tctx_write_srcloc(char* file_name, U64 line_number){ - TCTX *tctx = tctx_get_equipped(); - tctx->file_name = file_name; - tctx->line_number = line_number; +md_tctx_write_srcloc(char* file_name, MD_U64 line_number){ + MD_TCTX *md_tctx = md_tctx_get_equipped(); + md_tctx->file_name = file_name; + md_tctx->line_number = line_number; } inline void -tctx_read_srcloc(char** file_name, U64* line_number){ - TCTX* tctx = tctx_get_equipped(); - *file_name = tctx->file_name; - *line_number = tctx->line_number; +md_tctx_read_srcloc(char** file_name, MD_U64* line_number){ + MD_TCTX* md_tctx = md_tctx_get_equipped(); + *file_name = md_tctx->file_name; + *line_number = md_tctx->line_number; } diff --git a/source/base/time.c b/source/base/time.c index ffe5d4d..db3ecde 100644 --- a/source/base/time.c +++ b/source/base/time.c @@ -3,25 +3,25 @@ # include "time.h" #endif -DateTime -date_time_from_unix_time(U64 unix_time) +MD_DateTime +md_date_time_from_unix_time(MD_U64 unix_time) { - DateTime date = {0}; + MD_DateTime date = {0}; date.year = 1970; date.day = 1 + (unix_time / 86400); - date.sec = (U32) unix_time % 60; - date.min = (U32)(unix_time / 60) % 60; - date.hour = (U32)(unix_time / 3600) % 24; + date.sec = (MD_U32) unix_time % 60; + date.md_min = (MD_U32)(unix_time / 60) % 60; + date.hour = (MD_U32)(unix_time / 3600) % 24; for(;;) { for(date.month = 0; date.month < 12; ++date.month) { - U64 c = 0; + MD_U64 c = 0; switch(date.month) { - case Month_Jan: c = 31; break; - case Month_Feb: + case MD_Month_Jan: c = 31; break; + case MD_Month_Feb: { if((date.year % 4 == 0) && ((date.year % 100) != 0 || (date.year % 400) == 0)) { @@ -32,17 +32,17 @@ date_time_from_unix_time(U64 unix_time) c = 28; } } break; - case Month_Mar: c = 31; break; - case Month_Apr: c = 30; break; - case Month_May: c = 31; break; - case Month_Jun: c = 30; break; - case Month_Jul: c = 31; break; - case Month_Aug: c = 31; break; - case Month_Sep: c = 30; break; - case Month_Oct: c = 31; break; - case Month_Nov: c = 30; break; - case Month_Dec: c = 31; break; - default: invalid_path; + case MD_Month_Mar: c = 31; break; + case MD_Month_Apr: c = 30; break; + case MD_Month_May: c = 31; break; + case MD_Month_Jun: c = 30; break; + case MD_Month_Jul: c = 31; break; + case MD_Month_Aug: c = 31; break; + case MD_Month_Sep: c = 30; break; + case MD_Month_Oct: c = 31; break; + case MD_Month_Nov: c = 30; break; + case MD_Month_Dec: c = 31; break; + default: md_invalid_path; } if(date.day <= c) { diff --git a/source/base/time.h b/source/base/time.h index c580462..e1abbeb 100644 --- a/source/base/time.h +++ b/source/base/time.h @@ -6,110 +6,110 @@ //////////////////////////////// //~ allen: Time -typedef enum WeekDay WeekDay; -enum WeekDay +typedef enum MD_WeekDay MD_WeekDay; +enum MD_WeekDay { - WeekDay_Sun, - WeekDay_Mon, - WeekDay_Tue, - WeekDay_Wed, - WeekDay_Thu, - WeekDay_Fri, - WeekDay_Sat, - WeekDay_COUNT, + MD_WeekDay_Sun, + MD_WeekDay_Mon, + MD_WeekDay_Tue, + MD_WeekDay_Wed, + MD_WeekDay_Thu, + MD_WeekDay_Fri, + MD_WeekDay_Sat, + MD_WeekDay_COUNT, }; -typedef enum Month Month; -enum Month +typedef enum MD_Month MD_Month; +enum MD_Month { - Month_Jan, - Month_Feb, - Month_Mar, - Month_Apr, - Month_May, - Month_Jun, - Month_Jul, - Month_Aug, - Month_Sep, - Month_Oct, - Month_Nov, - Month_Dec, - Month_COUNT, + MD_Month_Jan, + MD_Month_Feb, + MD_Month_Mar, + MD_Month_Apr, + MD_Month_May, + MD_Month_Jun, + MD_Month_Jul, + MD_Month_Aug, + MD_Month_Sep, + MD_Month_Oct, + MD_Month_Nov, + MD_Month_Dec, + MD_Month_COUNT, }; -typedef struct DateTime DateTime; -struct DateTime +typedef struct MD_DateTime MD_DateTime; +struct MD_DateTime { - U16 micro_sec; // [0,999] - U16 msec; // [0,999] - U16 sec; // [0,60] - U16 min; // [0,59] - U16 hour; // [0,24] - U16 day; // [0,30] + MD_U16 micro_sec; // [0,999] + MD_U16 msec; // [0,999] + MD_U16 sec; // [0,60] + MD_U16 md_min; // [0,59] + MD_U16 hour; // [0,24] + MD_U16 day; // [0,30] union { - WeekDay week_day; - U32 wday; + MD_WeekDay week_day; + MD_U32 wday; }; union { - Month month; - U32 mon; + MD_Month month; + MD_U32 mon; }; - U32 year; // 1 = 1 CE, 0 = 1 BC + MD_U32 year; // 1 = 1 CE, 0 = 1 BC }; -typedef U64 DenseTime; +typedef MD_U64 MD_DenseTime; //////////////////////////////// //~ rjf: Time Functions -DenseTime dense_time_from_date_time (DateTime date_time); -DateTime date_time_from_dense_time (DenseTime time); -DateTime date_time_from_micro_seconds(U64 time); -DateTime date_time_from_unix_time (U64 unix_time); +MD_DenseTime md_dense_time_from_date_time (MD_DateTime date_time); +MD_DateTime md_date_time_from_dense_time (MD_DenseTime time); +MD_DateTime md_date_time_from_micro_seconds(MD_U64 time); +MD_DateTime md_date_time_from_unix_time (MD_U64 unix_time); //////////////////////////////// //~ rjf: Time Functions -inline DenseTime -dense_time_from_date_time(DateTime date_time) { - DenseTime result = 0; +inline MD_DenseTime +md_dense_time_from_date_time(MD_DateTime date_time) { + MD_DenseTime result = 0; result += date_time.year; result *= 12; result += date_time.mon; result *= 31; result += date_time.day; result *= 24; result += date_time.hour; result *= 60; - result += date_time.min; result *= 61; + result += date_time.md_min; result *= 61; result += date_time.sec; result *= 1000; result += date_time.msec; return(result); } -inline DateTime -date_time_from_dense_time(DenseTime time) { - DateTime result = {0}; +inline MD_DateTime +md_date_time_from_dense_time(MD_DenseTime time) { + MD_DateTime result = {0}; result.msec = time % 1000; time /= 1000; result.sec = time % 61; time /= 61; - result.min = time % 60; time /= 60; + result.md_min = time % 60; time /= 60; result.hour = time % 24; time /= 24; result.day = time % 31; time /= 31; result.mon = time % 12; time /= 12; - assert(time <= MAX_U32); - result.year = (U32)time; + md_assert(time <= MD_MAX_U32); + result.year = (MD_U32)time; return(result); } -inline DateTime -date_time_from_micro_seconds(U64 time){ - DateTime result = {0}; +inline MD_DateTime +md_date_time_from_micro_seconds(MD_U64 time){ + MD_DateTime result = {0}; result.micro_sec = time % 1000; time /= 1000; result.msec = time % 1000; time /= 1000; result.sec = time % 60; time /= 60; - result.min = time % 60; time /= 60; + result.md_min = time % 60; time /= 60; result.hour = time % 24; time /= 24; result.day = time % 31; time /= 31; result.mon = time % 12; time /= 12; - assert(time <= MAX_U32); - result.year = (U32)time; + md_assert(time <= MD_MAX_U32); + result.year = (MD_U32)time; return(result); } diff --git a/source/base/toolchain.h b/source/base/toolchain.h index 96cd09d..fdc8e5d 100644 --- a/source/base/toolchain.h +++ b/source/base/toolchain.h @@ -6,110 +6,110 @@ //////////////////////////////// //~ rjf: Toolchain/Environment Enums -typedef enum OperatingSystem OperatingSystem; -enum OperatingSystem +typedef enum MD_OperatingSystem MD_OperatingSystem; +enum MD_OperatingSystem { - OperatingSystem_Null, - OperatingSystem_Windows, - OperatingSystem_Linux, - OperatingSystem_Mac, - OperatingSystem_COUNT, + MD_OperatingSystem_Null, + MD_OperatingSystem_Windows, + MD_OperatingSystem_Linux, + MD_OperatingSystem_Mac, + MD_OperatingSystem_COUNT, }; -typedef enum ImageType ImageType; -enum ImageType +typedef enum MD_ImageType MD_ImageType; +enum MD_ImageType { - Image_Null, - Image_CoffPe, - Image_Elf32, - Image_Elf64, - Image_Macho + MD_Image_Null, + MD_Image_CoffPe, + MD_Image_Elf32, + MD_Image_Elf64, + MD_Image_Macho }; -typedef enum Arch Arch; -enum Arch +typedef enum MD_Arch MD_Arch; +enum MD_Arch { - Arch_Null, - Arch_x64, - Arch_x86, - Arch_arm64, - Arch_arm32, - Arch_COUNT, + MD_Arch_Null, + MD_Arch_x64, + MD_Arch_x86, + MD_Arch_arm64, + MD_Arch_arm32, + MD_Arch_COUNT, }; -typedef enum Compiler Compiler; -enum Compiler +typedef enum MD_Compiler MD_Compiler; +enum MD_Compiler { - Compiler_Null, - Compiler_msvc, - Compiler_gcc, - Compiler_clang, - Compiler_COUNT, + MD_Compiler_Null, + MD_Compiler_msvc, + MD_Compiler_gcc, + MD_Compiler_clang, + MD_Compiler_COUNT, }; //////////////////////////////// //~ rjf: Toolchain/Environment Enum Functions -inline U64 -bit_size_from_arch(Arch arch) +inline MD_U64 +md_bit_size_from_arch(MD_Arch arch) { // TODO(rjf): metacode - U64 arch_bitsize = 0; + MD_U64 arch_bitsize = 0; switch(arch) { - case Arch_x64: arch_bitsize = 64; break; - case Arch_x86: arch_bitsize = 32; break; - case Arch_arm64: arch_bitsize = 64; break; - case Arch_arm32: arch_bitsize = 32; break; + case MD_Arch_x64: arch_bitsize = 64; break; + case MD_Arch_x86: arch_bitsize = 32; break; + case MD_Arch_arm64: arch_bitsize = 64; break; + case MD_Arch_arm32: arch_bitsize = 32; break; default: break; } return arch_bitsize; } -inline U64 -max_instruction_size_from_arch(Arch arch) +inline MD_U64 +md_max_instruction_size_from_arch(MD_Arch arch) { // TODO(rjf): make this real return 64; } -inline OperatingSystem -operating_system_from_context(void) { - OperatingSystem os = OperatingSystem_Null; -#if OS_WINDOWS - os = OperatingSystem_Windows; -#elif OS_LINUX - os = OperatingSystem_Linux; -#elif OS_MAC - os = OperatingSystem_Mac; +inline MD_OperatingSystem +md_operating_system_from_context(void) { + MD_OperatingSystem os = MD_OperatingSystem_Null; +#if MD_OS_WINDOWS + os = MD_OperatingSystem_Windows; +#elif MD_OS_LINUX + os = MD_OperatingSystem_Linux; +#elif MD_OS_MAC + os = MD_OperatingSystem_Mac; #endif return os; } -inline Arch -arch_from_context(void) { - Arch arch = Arch_Null; -#if ARCH_X64 - arch = Arch_x64; -#elif ARCH_X86 - arch = Arch_x86; -#elif ARCH_ARM64 - arch = Arch_arm64; -#elif ARCH_ARM32 - arch = Arch_arm32; +inline MD_Arch +md_arch_from_contexto(void) { + MD_Arch arch = MD_Arch_Null; +#if MD_ARCH_X64 + arch = MD_Arch_x64; +#elif MD_ARCH_X86 + arch = MD_Arch_x86; +#elif MD_ARCH_ARM64 + arch = MD_Arch_arm64; +#elif MD_ARCH_ARM32 + arch = MD_Arch_arm32; #endif return arch; } -inline Compiler -compiler_from_context(void) { - Compiler compiler = Compiler_Null; -#if COMPILER_MSVC - compiler = Compiler_msvc; -#elif COMPILER_GCC - compiler = Compiler_gcc; -#elif COMPILER_CLANG - compiler = Compiler_clang; +inline MD_Compiler +md_compiler_from_context(void) { + MD_Compiler compiler = MD_Compiler_Null; +#if MD_COMPILER_MSVC + compiler = MD_Compiler_msvc; +#elif MD_COMPILER_GCC + compiler = MD_Compiler_gcc; +#elif MD_COMPILER_CLANG + compiler = MD_Compiler_clang; #endif return compiler; } diff --git a/source/mdesk/mdesk.c b/source/mdesk/mdesk.c index 599affe..eaa577c 100644 --- a/source/mdesk/mdesk.c +++ b/source/mdesk/mdesk.c @@ -7,18 +7,18 @@ // Licensed under the MIT license (https://opensource.org/license/mit/) //////////////////////////////// -// Context +// MD_Context -void init(Context* ctx) +void md_init(MD_Context* ctx) { if ( ! ctx->dont_init_os) { - os_init(& ctx->os_ctx, & ctx->thread_ctx); + md_os_init(& ctx->os_ctx, & ctx->thread_ctx); } } -void deinit(Context* ctx) +void md_deinit(MD_Context* ctx) { // Nothing for now } @@ -27,22 +27,22 @@ void deinit(Context* ctx) //~ rjf: Message Type Functions void -msg_list_push__ainfo(AllocatorInfo ainfo, MsgList* msgs, Node* node, MsgKind kind, String8 string) +md_msg_list_push__ainfo(MD_AllocatorInfo ainfo, MD_MsgList* msgs, MD_Node* node, MD_MsgKind kind, MD_String8 string) { - Msg* - msg = alloc_array(ainfo, Msg, 1); + MD_Msg* + msg = md_alloc_array(ainfo, MD_Msg, 1); msg->node = node; msg->kind = kind; msg->string = string; - sll_queue_push(msgs->first, msgs->last, msg); + md_sll_queue_push(msgs->first, msgs->last, msg); msgs->count += 1; msgs->worst_message_kind = md_max(kind, msgs->worst_message_kind); } void -msg_list_concat_in_place(MsgList* dst, MsgList* to_push) +md_msg_list_concat_in_place(MD_MsgList* dst, MD_MsgList* to_push) { if (to_push->first != 0) { @@ -53,100 +53,100 @@ msg_list_concat_in_place(MsgList* dst, MsgList* to_push) dst->worst_message_kind = md_max(dst->worst_message_kind, to_push->worst_message_kind); } else { - memory_copy_struct(dst, to_push); + md_memory_copy_struct(dst, to_push); } } - memory_zero_struct(to_push); + md_memory_zero_struct(to_push); } //////////////////////////////// -//~ rjf: Token Type Functions +//~ rjf: MD_Token Type Functions -String8 -content_string_from_token_flags_str8(TokenFlags flags, String8 string) +MD_String8 +content_string_from_token_flags_str8(MD_TokenFlags flags, MD_String8 string) { - U64 num_chop = 0; - U64 num_skip = 0; + MD_U64 num_chop = 0; + MD_U64 num_skip = 0; { - num_skip += 3 * !!(flags & TokenFlag_StringTriplet); - num_chop += 3 * !!(flags & TokenFlag_StringTriplet); - num_skip += 1 * (!(flags & TokenFlag_StringTriplet) && flags & TokenFlag_StringLiteral); - num_chop += 1 * (!(flags & TokenFlag_StringTriplet) && flags & TokenFlag_StringLiteral); + num_skip += 3 * !!(flags & MD_TokenFlag_StringTriplet); + num_chop += 3 * !!(flags & MD_TokenFlag_StringTriplet); + num_skip += 1 * (!(flags & MD_TokenFlag_StringTriplet) && flags & MD_TokenFlag_StringLiteral); + num_chop += 1 * (!(flags & MD_TokenFlag_StringTriplet) && flags & MD_TokenFlag_StringLiteral); } - String8 result = string; - result = str8_chop(result, num_chop); - result = str8_skip(result, num_skip); + MD_String8 result = string; + result = md_str8_chop(result, num_chop); + result = md_str8_skip(result, num_skip); return result; } -String8List -string_list_from_token_flags__ainfo(AllocatorInfo ainfo, TokenFlags flags) +MD_String8List +md_string_list_from_token_flags__ainfo(MD_AllocatorInfo ainfo, MD_TokenFlags flags) { - String8List strs = {0}; - if (flags & TokenFlag_Identifier ){ str8_list_push(ainfo, &strs, str8_lit("Identifier" )); } - if (flags & TokenFlag_Numeric ){ str8_list_push(ainfo, &strs, str8_lit("Numeric" )); } - if (flags & TokenFlag_StringLiteral ){ str8_list_push(ainfo, &strs, str8_lit("StringLiteral" )); } - if (flags & TokenFlag_Symbol ){ str8_list_push(ainfo, &strs, str8_lit("Symbol" )); } - if (flags & TokenFlag_Reserved ){ str8_list_push(ainfo, &strs, str8_lit("Reserved" )); } - if (flags & TokenFlag_Comment ){ str8_list_push(ainfo, &strs, str8_lit("Comment" )); } - if (flags & TokenFlag_Whitespace ){ str8_list_push(ainfo, &strs, str8_lit("Whitespace" )); } - if (flags & TokenFlag_Newline ){ str8_list_push(ainfo, &strs, str8_lit("Newline" )); } - if (flags & TokenFlag_BrokenComment ){ str8_list_push(ainfo, &strs, str8_lit("BrokenComment" )); } - if (flags & TokenFlag_BrokenStringLiteral ){ str8_list_push(ainfo, &strs, str8_lit("BrokenStringLiteral")); } - if (flags & TokenFlag_BadCharacter ){ str8_list_push(ainfo, &strs, str8_lit("BadCharacter" )); } + MD_String8List strs = {0}; + if (flags & MD_TokenFlag_Identifier ){ md_str8_list_push(ainfo, &strs, md_str8_lit("Identifier" )); } + if (flags & MD_TokenFlag_Numeric ){ md_str8_list_push(ainfo, &strs, md_str8_lit("Numeric" )); } + if (flags & MD_TokenFlag_StringLiteral ){ md_str8_list_push(ainfo, &strs, md_str8_lit("StringLiteral" )); } + if (flags & MD_TokenFlag_Symbol ){ md_str8_list_push(ainfo, &strs, md_str8_lit("Symbol" )); } + if (flags & MD_TokenFlag_Reserved ){ md_str8_list_push(ainfo, &strs, md_str8_lit("Reserved" )); } + if (flags & MD_TokenFlag_Comment ){ md_str8_list_push(ainfo, &strs, md_str8_lit("Comment" )); } + if (flags & MD_TokenFlag_Whitespace ){ md_str8_list_push(ainfo, &strs, md_str8_lit("Whitespace" )); } + if (flags & MD_TokenFlag_Newline ){ md_str8_list_push(ainfo, &strs, md_str8_lit("Newline" )); } + if (flags & MD_TokenFlag_BrokenComment ){ md_str8_list_push(ainfo, &strs, md_str8_lit("BrokenComment" )); } + if (flags & MD_TokenFlag_BrokenStringLiteral ){ md_str8_list_push(ainfo, &strs, md_str8_lit("BrokenStringLiteral")); } + if (flags & MD_TokenFlag_BadCharacter ){ md_str8_list_push(ainfo, &strs, md_str8_lit("BadCharacter" )); } return strs; } void -token_chunk_list_push__ainfo(AllocatorInfo ainfo, TokenChunkList* list, U64 cap, Token token) +md_token_chunk_list_push__ainfo(MD_AllocatorInfo ainfo, MD_TokenChunkList* list, MD_U64 cap, MD_Token token) { - TokenChunkNode* node = list->last; + MD_TokenChunkNode* node = list->last; if (node == 0 || node->count >= node->cap) { - node = alloc_array(ainfo, TokenChunkNode, 1); + node = md_alloc_array(ainfo, MD_TokenChunkNode, 1); node->cap = cap; - node->v = alloc_array_no_zero(ainfo, Token, cap); - sll_queue_push(list->first, list->last, node); + node->v = md_alloc_array_no_zero(ainfo, MD_Token, cap); + md_sll_queue_push(list->first, list->last, node); list->chunk_count += 1; } - memory_copy_struct(&node->v[node->count], &token); + md_memory_copy_struct(&node->v[node->count], &token); node->count += 1; list->total_token_count += 1; } -TokenArray -token_array_from_chunk_list__ainfo(AllocatorInfo ainfo, TokenChunkList* chunks) +MD_TokenArray +md_token_array_from_chunk_list__ainfo(MD_AllocatorInfo ainfo, MD_TokenChunkList* chunks) { - TokenArray result = {0}; + MD_TokenArray result = {0}; result.count = chunks->total_token_count; - result.v = alloc_array_no_zero(ainfo, Token, result.count); - U64 write_idx = 0; - for(TokenChunkNode *n = chunks->first; n != 0; n = n->next) + result.v = md_alloc_array_no_zero(ainfo, MD_Token, result.count); + MD_U64 write_idx = 0; + for(MD_TokenChunkNode *n = chunks->first; n != 0; n = n->next) { - memory_copy(result.v + write_idx, n->v, size_of(Token) * n->count); + md_memory_copy(result.v + write_idx, n->v, size_of(MD_Token) * n->count); write_idx += n->count; } return result; } //////////////////////////////// -//~ rjf: Node Type Functions +//~ rjf: MD_Node Type Functions //- rjf: iteration -NodeRec -node_rec_depth_first(Node* node, Node* subtree_root, U64 child_off, U64 sib_off) +MD_NodeRec +md_node_rec_depth_first(MD_Node* node, MD_Node* subtree_root, MD_U64 child_off, MD_U64 sib_off) { - NodeRec + MD_NodeRec rec = {0}; - rec.next = nil_node(); - if ( ! node_is_nil(*member_from_offset(Node**, node, child_off))) { - rec.next = *member_from_offset(Node**, node, child_off); - rec.push_count = 1; + rec.next = md_nil_node(); + if ( ! md_node_is_nil(*md_member_from_offset(MD_Node**, node, child_off))) { + rec.next = *md_member_from_offset(MD_Node**, node, child_off); + rec.md_push_count = 1; } - else for (Node* p = node; !node_is_nil(p) && p != subtree_root; p = p->parent, rec.pop_count += 1) + else for (MD_Node* p = node; !md_node_is_nil(p) && p != subtree_root; p = p->parent, rec.pop_count += 1) { - if ( ! node_is_nil(*member_from_offset(Node**, p, sib_off))) { - rec.next = *member_from_offset(Node**, p, sib_off); + if ( ! md_node_is_nil(*md_member_from_offset(MD_Node**, p, sib_off))) { + rec.next = *md_member_from_offset(MD_Node**, p, sib_off); break; } } @@ -156,34 +156,34 @@ node_rec_depth_first(Node* node, Node* subtree_root, U64 child_off, U64 sib_off) //- rjf: tree building void -unhook(Node* node) { - Node* parent = node->parent; - if ( ! node_is_nil(parent)) +md_unhook(MD_Node* node) { + MD_Node* parent = node->parent; + if ( ! md_node_is_nil(parent)) { - if (node->kind == NodeKind_Tag) dll_remove_npz(nil_node(), parent->first_tag, parent->last_tag, node, next, prev); - else dll_remove_npz(nil_node(), parent->first, parent->last, node, next, prev); - node->parent = nil_node(); + if (node->kind == MD_NodeKind_Tag) md_dll_remove_npz(md_nil_node(), parent->first_tag, parent->last_tag, node, next, prev); + else md_dll_remove_npz(md_nil_node(), parent->first, parent->last, node, next, prev); + node->parent = md_nil_node(); } } //- rjf: tree introspection -String8 -string_from_children__ainfo(AllocatorInfo ainfo, Node* root) +MD_String8 +md_string_from_children__ainfo(MD_AllocatorInfo ainfo, MD_Node* root) { - String8 result; - TempArena scratch = scratch_begin(ainfo); + MD_String8 result; + MD_TempArena scratch = md_scratch_begin(ainfo); { - String8List strs = {0}; - for each_node(child, root->first) + MD_String8List strs = {0}; + for md_each_node(child, root->first) { if (child->flags == child->prev->flags) { - str8_list_push(scratch.arena, &strs, str8_lit(" ")); + md_str8_list_push(scratch.arena, &strs, md_str8_lit(" ")); } - str8_list_push(scratch.arena, &strs, child->string); + md_str8_list_push(scratch.arena, &strs, child->string); } - result = str8_list_join(ainfo, &strs, 0); + result = md_str8_list_join(ainfo, &strs, 0); } scratch_end(scratch); return result; @@ -191,23 +191,23 @@ string_from_children__ainfo(AllocatorInfo ainfo, Node* root) //- rjf: tree comparison -B32 -node_match(Node* a, Node* b, StringMatchFlags flags) +MD_B32 +md_node_match(MD_Node* a, MD_Node* b, MD_StringMatchFlags flags) { - B32 result = 0; - if (a->kind == b->kind && str8_match(a->string, b->string, flags)) + MD_B32 result = 0; + if (a->kind == b->kind && md_str8_match(a->string, b->string, flags)) { result = 1; if (result) { result = result && a->flags == b->flags; } - if (result && a->kind != NodeKind_Tag) + if (result && a->kind != MD_NodeKind_Tag) { - for (Node* a_tag = a->first_tag, *b_tag = b->first_tag; !node_is_nil(a_tag) || !node_is_nil(b_tag); a_tag = a_tag->next, b_tag = b_tag->next) + for (MD_Node* a_tag = a->first_tag, *b_tag = b->first_tag; !md_node_is_nil(a_tag) || !md_node_is_nil(b_tag); a_tag = a_tag->next, b_tag = b_tag->next) { - if (node_match(a_tag, b_tag, flags)) + if (md_node_match(a_tag, b_tag, flags)) { - for (Node* a_tag_arg = a_tag->first, *b_tag_arg = b_tag->first; !node_is_nil(a_tag_arg) || !node_is_nil(b_tag_arg); a_tag_arg = a_tag_arg->next, b_tag_arg = b_tag_arg->next) + for (MD_Node* a_tag_arg = a_tag->first, *b_tag_arg = b_tag->first; !md_node_is_nil(a_tag_arg) || !md_node_is_nil(b_tag_arg); a_tag_arg = a_tag_arg->next, b_tag_arg = b_tag_arg->next) { if (!tree_match(a_tag_arg, b_tag_arg, flags)) { result = 0; @@ -227,13 +227,13 @@ node_match(Node* a, Node* b, StringMatchFlags flags) return result; } -B32 -tree_match(Node* a, Node* b, StringMatchFlags flags) +MD_B32 +tree_match(MD_Node* a, MD_Node* b, MD_StringMatchFlags flags) { - B32 result = node_match(a, b, flags); + MD_B32 result = md_node_match(a, b, flags); if (result) { - for(Node *a_child = a->first, *b_child = b->first; !node_is_nil(a_child) || !node_is_nil(b_child); a_child = a_child->next, b_child = b_child->next) + for(MD_Node *a_child = a->first, *b_child = b->first; !md_node_is_nil(a_child) || !md_node_is_nil(b_child); a_child = a_child->next, b_child = b_child->next) { if ( ! tree_match(a_child, b_child, flags)) { result = 0; @@ -247,36 +247,36 @@ tree_match(Node* a, Node* b, StringMatchFlags flags) //- rjf: tree duplication -Node* -tree_copy__ainfo(AllocatorInfo ainfo, Node* src_root) +MD_Node* +md_tree_copy__ainfo(MD_AllocatorInfo ainfo, MD_Node* src_root) { - Node* dst_root = nil_node(); - Node* dst_parent = dst_root; + MD_Node* dst_root = md_nil_node(); + MD_Node* dst_parent = dst_root; { - NodeRec rec = {0}; - for(Node* src = src_root; !node_is_nil(src); src = rec.next) + MD_NodeRec rec = {0}; + for(MD_Node* src = src_root; !md_node_is_nil(src); src = rec.next) { - Node* dst = alloc_array(ainfo, Node, 1); - dst->first = dst->last = dst->parent = dst->next = dst->prev = nil_node(); - dst->first_tag = dst->last_tag = nil_node(); + MD_Node* dst = md_alloc_array(ainfo, MD_Node, 1); + dst->first = dst->last = dst->parent = dst->next = dst->prev = md_nil_node(); + dst->first_tag = dst->last_tag = md_nil_node(); dst->kind = src->kind; dst->flags = src->flags; - dst->string = str8_copy(ainfo, src->string); - dst->raw_string = str8_copy(ainfo, src->raw_string); + dst->string = md_str8_copy(ainfo, src->string); + dst->raw_string = md_str8_copy(ainfo, src->raw_string); dst->src_offset = src->src_offset; dst->parent = dst_parent; - if (dst_parent != nil_node()) { - dll_push_back_npz(nil_node(), dst_parent->first, dst_parent->last, dst, next, prev); + if (dst_parent != md_nil_node()) { + md_dll_push_back_npz(md_nil_node(), dst_parent->first, dst_parent->last, dst, next, prev); } else { dst_root = dst_parent = dst; } - rec = node_rec_depth_first_pre(src, src_root); - if (rec.push_count != 0) { + rec = md_node_rec_depth_first_pre(src, src_root); + if (rec.md_push_count != 0) { dst_parent = dst; } - else for (U64 idx = 0; idx < rec.pop_count; idx += 1) { + else for (MD_U64 idx = 0; idx < rec.pop_count; idx += 1) { dst_parent = dst_parent->parent; } } @@ -287,38 +287,38 @@ tree_copy__ainfo(AllocatorInfo ainfo, Node* src_root) //////////////////////////////// //~ rjf: Text -> Tokens Functions -TokenizeResult -tokenize_from_text__ainfo(AllocatorInfo ainfo, String8 text) +MD_TokenizeResult +md_tokenize_from_text__ainfo(MD_AllocatorInfo ainfo, MD_String8 text) { - TempArena scratch = scratch_begin(ainfo); + MD_TempArena scratch = md_scratch_begin(ainfo); - TokenChunkList tokens = {0}; - MsgList msgs = {0}; + MD_TokenChunkList tokens = {0}; + MD_MsgList msgs = {0}; - U8* byte_first = text.str; - U8* byte_opl = byte_first + text.size; // one-past-last - U8* byte = byte_first; + MD_U8* byte_first = text.str; + MD_U8* byte_opl = byte_first + text.size; // one-past-last + MD_U8* byte = byte_first; //- rjf: scan string & produce tokens for (;byte < byte_opl;) { - TokenFlags token_flags = 0; - U8* token_start = 0; - U8* token_opl = 0; + MD_TokenFlags md_token_flags = 0; + MD_U8* md_token_start = 0; + MD_U8* md_token_opl = 0; #define is_whitespace(byte) (*byte == ' ' || *byte == '\t' || *byte == '\v' || *byte == '\r') //- rjf: whitespace - if (token_flags == 0 && is_whitespace(byte)) + if (md_token_flags == 0 && is_whitespace(byte)) { - token_flags = TokenFlag_Whitespace; - token_start = byte; - token_opl = byte; + md_token_flags = MD_TokenFlag_Whitespace; + md_token_start = byte; + md_token_opl = byte; byte += 1; for (;byte <= byte_opl; byte += 1) { - token_opl += 1; + md_token_opl += 1; if (byte == byte_opl || !is_whitespace(byte)) { break; } @@ -327,28 +327,28 @@ tokenize_from_text__ainfo(AllocatorInfo ainfo, String8 text) #undef is_whitspace //- rjf: newlines - if (token_flags == 0 && *byte == '\n') + if (md_token_flags == 0 && *byte == '\n') { - token_flags = TokenFlag_Newline; - token_start = byte; - token_opl = byte+1; + md_token_flags = MD_TokenFlag_Newline; + md_token_start = byte; + md_token_opl = byte+1; byte += 1; } //- rjf: single-line comments - if (token_flags == 0 && (byte + 1 < byte_opl && *byte == '/' && byte[1] == '/')) + if (md_token_flags == 0 && (byte + 1 < byte_opl && *byte == '/' && byte[1] == '/')) { - token_flags = TokenFlag_Comment; - token_start = byte; - token_opl = byte+2; + md_token_flags = MD_TokenFlag_Comment; + md_token_start = byte; + md_token_opl = byte+2; byte += 2; - B32 escaped = 0; + MD_B32 escaped = 0; for (;byte <= byte_opl; byte += 1) { - token_opl += 1; + md_token_opl += 1; if (byte == byte_opl) { break; } @@ -368,22 +368,22 @@ tokenize_from_text__ainfo(AllocatorInfo ainfo, String8 text) } //- rjf: multi-line comments - if (token_flags == 0 && (byte + 1 < byte_opl && *byte == '/' && byte[1] == '*')) + if (md_token_flags == 0 && (byte + 1 < byte_opl && *byte == '/' && byte[1] == '*')) { - token_flags = TokenFlag_Comment; - token_start = byte; - token_opl = byte + 2; + md_token_flags = MD_TokenFlag_Comment; + md_token_start = byte; + md_token_opl = byte + 2; byte += 2; for (;byte <= byte_opl; byte += 1) { - token_opl += 1; + md_token_opl += 1; if (byte == byte_opl) { - token_flags |= TokenFlag_BrokenComment; + md_token_flags |= MD_TokenFlag_BrokenComment; break; } if (byte + 1 < byte_opl && byte[0] == '*' && byte[1] == '/') { - token_opl += 2; + md_token_opl += 2; break; } } @@ -393,7 +393,7 @@ tokenize_from_text__ainfo(AllocatorInfo ainfo, String8 text) ('A' <= *byte && *byte <= 'Z') || \ ('a' <= *byte && *byte <= 'z') || \ *byte == '_' || \ - utf8_class(*byte >> 3) >= 2 \ + md_utf8_class(*byte >> 3) >= 2 \ ) #if 0 ( @@ -401,21 +401,21 @@ tokenize_from_text__ainfo(AllocatorInfo ainfo, String8 text) !('a' <= *byte && *byte <= 'z') && !('0' <= *byte && *byte <= '9') && *byte != '_' && - utf8_class(*byte>>3) < 2 + md_utf8_class(*byte>>3) < 2 ) #endif //- rjf: identifiers - if (token_flags == 0 && is_identifier(byte)) + if (md_token_flags == 0 && is_identifier(byte)) { - token_flags = TokenFlag_Identifier; - token_start = byte; - token_opl = byte; + md_token_flags = MD_TokenFlag_Identifier; + md_token_start = byte; + md_token_opl = byte; byte += 1; for(;byte <= byte_opl; byte += 1) { - token_opl += 1; + md_token_opl += 1; if (byte == byte_opl || !is_identifier(byte)) { break; } @@ -437,16 +437,16 @@ tokenize_from_text__ainfo(AllocatorInfo ainfo, String8 text) ) //- rjf: numerics - if (token_flags == 0 && is_numeric(byte)) + if (md_token_flags == 0 && is_numeric(byte)) { - token_flags = TokenFlag_Numeric; - token_start = byte; - token_opl = byte; + md_token_flags = MD_TokenFlag_Numeric; + md_token_start = byte; + md_token_opl = byte; byte += 1; for (;byte <= byte_opl; byte += 1) { - token_opl += 1; + md_token_opl += 1; if (byte == byte_opl || is_not_numeric(byte)) { break; } @@ -462,27 +462,27 @@ tokenize_from_text__ainfo(AllocatorInfo ainfo, String8 text) ) //- rjf: triplet string literals - if (token_flags == 0 && byte + 2 < byte_opl && is_triple_string_literal(byte)) + if (md_token_flags == 0 && byte + 2 < byte_opl && is_triple_string_literal(byte)) { - U8 literal_style = byte[0]; - token_flags = TokenFlag_StringLiteral | TokenFlag_StringTriplet; - token_flags |= (literal_style == '\'') * TokenFlag_StringSingleQuote; - token_flags |= (literal_style == '"') * TokenFlag_StringDoubleQuote; - token_flags |= (literal_style == '`') * TokenFlag_StringTick; - token_start = byte; - token_opl = byte + 3; + MD_U8 literal_style = byte[0]; + md_token_flags = MD_TokenFlag_StringLiteral | MD_TokenFlag_StringTriplet; + md_token_flags |= (literal_style == '\'') * MD_TokenFlag_StringSingleQuote; + md_token_flags |= (literal_style == '"') * MD_TokenFlag_StringDoubleQuote; + md_token_flags |= (literal_style == '`') * MD_TokenFlag_StringTick; + md_token_start = byte; + md_token_opl = byte + 3; byte += 3; for (;byte <= byte_opl; byte += 1) { if (byte == byte_opl) { - token_flags |= TokenFlag_BrokenStringLiteral; - token_opl = byte; + md_token_flags |= MD_TokenFlag_BrokenStringLiteral; + md_token_opl = byte; break; } if (byte + 2 < byte_opl && (byte[0] == literal_style && byte[1] == literal_style && byte[2] == literal_style)) { byte += 3; - token_opl = byte; + md_token_opl = byte; break; } } @@ -490,30 +490,30 @@ tokenize_from_text__ainfo(AllocatorInfo ainfo, String8 text) #undef is_triple_string_literal //- rjf: singlet string literals - if (token_flags == 0 && (byte[0] == '"' || byte[0] == '\'' || byte[0] == '`')) + if (md_token_flags == 0 && (byte[0] == '"' || byte[0] == '\'' || byte[0] == '`')) { - U8 literal_style = byte[0]; - token_flags = TokenFlag_StringLiteral; - token_flags |= (literal_style == '\'') * TokenFlag_StringSingleQuote; - token_flags |= (literal_style == '"') * TokenFlag_StringDoubleQuote; - token_flags |= (literal_style == '`') * TokenFlag_StringTick; - token_start = byte; - token_opl = byte + 1; + MD_U8 literal_style = byte[0]; + md_token_flags = MD_TokenFlag_StringLiteral; + md_token_flags |= (literal_style == '\'') * MD_TokenFlag_StringSingleQuote; + md_token_flags |= (literal_style == '"') * MD_TokenFlag_StringDoubleQuote; + md_token_flags |= (literal_style == '`') * MD_TokenFlag_StringTick; + md_token_start = byte; + md_token_opl = byte + 1; byte += 1; - B32 escaped = 0; + MD_B32 escaped = 0; for (;byte <= byte_opl; byte += 1) { if (byte == byte_opl || *byte == '\n') { - token_opl = byte; - token_flags |= TokenFlag_BrokenStringLiteral; + md_token_opl = byte; + md_token_flags |= MD_TokenFlag_BrokenStringLiteral; break; } if (!escaped && byte[0] == '\\') { escaped = 1; } else if (!escaped && byte[0] == literal_style) { - token_opl = byte+1; + md_token_opl = byte+1; byte += 1; break; } @@ -539,16 +539,16 @@ tokenize_from_text__ainfo(AllocatorInfo ainfo, String8 text) #endif //- rjf: non-reserved symbols - if (token_flags == 0 && is_non_reserved_symbol(byte)) + if (md_token_flags == 0 && is_non_reserved_symbol(byte)) { - token_flags = TokenFlag_Symbol; - token_start = byte; - token_opl = byte; + md_token_flags = MD_TokenFlag_Symbol; + md_token_start = byte; + md_token_opl = byte; byte += 1; for (;byte <= byte_opl; byte += 1) { - token_opl += 1; + md_token_opl += 1; if (byte == byte_opl || !is_non_reserved_symbol(byte)) { break; } @@ -568,49 +568,49 @@ tokenize_from_text__ainfo(AllocatorInfo ainfo, String8 text) ) //- rjf: reserved symbols - if (token_flags == 0 && is_reserved_symbol(byte)) { - token_flags = TokenFlag_Reserved; - token_start = byte; - token_opl = byte+1; + if (md_token_flags == 0 && is_reserved_symbol(byte)) { + md_token_flags = MD_TokenFlag_Reserved; + md_token_start = byte; + md_token_opl = byte+1; byte += 1; } #undef is_reserved_symbol //- rjf: bad characters in all other cases - if (token_flags == 0) { - token_flags = TokenFlag_BadCharacter; - token_start = byte; - token_opl = byte+1; + if (md_token_flags == 0) { + md_token_flags = MD_TokenFlag_BadCharacter; + md_token_start = byte; + md_token_opl = byte+1; byte += 1; } //- rjf; push token if formed - if (token_flags != 0 && token_start != 0 && token_opl > token_start) { - Token token = {{(U64)(token_start - byte_first), (U64)(token_opl - byte_first)}, token_flags}; - token_chunk_list_push(scratch.arena, &tokens, 4096, token); + if (md_token_flags != 0 && md_token_start != 0 && md_token_opl > md_token_start) { + MD_Token token = {{(MD_U64)(md_token_start - byte_first), (MD_U64)(md_token_opl - byte_first)}, md_token_flags}; + md_token_chunk_list_push(scratch.arena, &tokens, 4096, token); } //- rjf: push errors on unterminated comments - if (token_flags & TokenFlag_BrokenComment) + if (md_token_flags & MD_TokenFlag_BrokenComment) { - Node* error = push_node(ainfo, NodeKind_ErrorMarker, 0, str8_lit(""), str8_lit(""), token_start - byte_first); - String8 error_string = str8_lit("Unterminated comment."); - msg_list_push(ainfo, &msgs, error, MsgKind_Error, error_string); + MD_Node* error = md_push_node(ainfo, MD_NodeKind_ErrorMarker, 0, md_str8_lit(""), md_str8_lit(""), md_token_start - byte_first); + MD_String8 error_string = md_str8_lit("Unterminated comment."); + md_msg_list_push(ainfo, &msgs, error, MD_MsgKind_Error, error_string); } //- rjf: push errors on unterminated strings - if (token_flags & TokenFlag_BrokenStringLiteral) { - Node* error = push_node(ainfo, NodeKind_ErrorMarker, 0, str8_lit(""), str8_lit(""), token_start - byte_first); - String8 error_string = str8_lit("Unterminated string literal."); - msg_list_push(ainfo, &msgs, error, MsgKind_Error, error_string); + if (md_token_flags & MD_TokenFlag_BrokenStringLiteral) { + MD_Node* error = md_push_node(ainfo, MD_NodeKind_ErrorMarker, 0, md_str8_lit(""), md_str8_lit(""), md_token_start - byte_first); + MD_String8 error_string = md_str8_lit("Unterminated string literal."); + md_msg_list_push(ainfo, &msgs, error, MD_MsgKind_Error, error_string); } } //- rjf: bake, fill & return - TokenizeResult result = {0}; { - result.tokens = token_array_from_chunk_list(ainfo, &tokens); + MD_TokenizeResult result = {0}; { + result.tokens = md_token_array_from_chunk_list(ainfo, &tokens); result.msgs = msgs; } scratch_end(scratch); @@ -620,84 +620,84 @@ tokenize_from_text__ainfo(AllocatorInfo ainfo, String8 text) //////////////////////////////// //~ rjf: Tokens -> Tree Functions -typedef enum ParseWorkKind ParseWorkKind; -enum ParseWorkKind +typedef enum MD_ParseWorkKind MD_ParseWorkKind; +enum MD_ParseWorkKind { ParseWorkKind_Main, ParseWorkKind_MainImplicit, ParseWorkKind_NodeOptionalFollowUp, ParseWorkKind_NodeChildrenStyleScan, - ParseWorkKind_UnderlyingType = MAX_U32, + ParseWorkKind_UnderlyingType = MD_MAX_U32, }; -typedef struct ParseWorkNode ParseWorkNode; -struct ParseWorkNode +typedef struct MD_ParseWorkNode MD_ParseWorkNode; +struct MD_ParseWorkNode { - ParseWorkNode* next; - ParseWorkKind kind; - Node* parent; - Node* first_gathered_tag; - Node* last_gathered_tag; + MD_ParseWorkNode* next; + MD_ParseWorkKind kind; + MD_Node* parent; + MD_Node* first_gathered_tag; + MD_Node* last_gathered_tag; NodeFlags gathered_node_flags; - S32 counted_newlines; + MD_S32 counted_newlines; }; inline -void parse__work_push(ParseWorkKind work_kind, Node* work_parent, ParseWorkNode* work_top, ParseWorkNode* work_free, TempArena* scratch) +void md_parse__work_push(MD_ParseWorkKind work_kind, MD_Node* work_parent, MD_ParseWorkNode* work_top, MD_ParseWorkNode* work_free, MD_TempArena* scratch) { - ParseWorkNode* work_node = work_free; + MD_ParseWorkNode* work_node = work_free; if (work_node == 0) { - work_node = push_array(scratch->arena, ParseWorkNode, 1); + work_node = md_push_array_(scratch->arena, MD_ParseWorkNode, 1); } else { - sll_stack_pop(work_free); + md_sll_stack_pop(work_free); } work_node->kind = (work_kind); work_node->parent = (work_parent); - sll_stack_push(work_top, work_node); + md_sll_stack_push(work_top, work_node); } inline -void parse__work_pop(ParseWorkNode* work_top, ParseWorkNode* broken_work) { - sll_stack_pop(work_top); +void md_parse__work_pop(MD_ParseWorkNode* work_top, MD_ParseWorkNode* broken_work) { + md_sll_stack_pop(work_top); if (work_top == 0) { work_top = broken_work; } } -ParseResult -parse_from_text_tokens__ainfo(AllocatorInfo ainfo, String8 filename, String8 text, TokenArray tokens) +MD_ParseResult +md_parse_from_text_tokens__ainfo(MD_AllocatorInfo ainfo, MD_String8 filename, MD_String8 text, MD_TokenArray tokens) { - TempArena scratch = scratch_begin(ainfo); + MD_TempArena scratch = md_scratch_begin(ainfo); //- rjf: set up outputs - MsgList msgs = {0}; - Node* root = push_node(ainfo, NodeKind_File, 0, filename, text, 0); + MD_MsgList msgs = {0}; + MD_Node* root = md_push_node(ainfo, MD_NodeKind_File, 0, filename, text, 0); //- rjf: set up parse rule stack - ParseWorkNode first_work = { 0, ParseWorkKind_Main, root }; - ParseWorkNode broken_work = { 0, ParseWorkKind_Main, root }; - ParseWorkNode* work_top = &first_work; - ParseWorkNode* work_free = 0; + MD_ParseWorkNode first_work = { 0, ParseWorkKind_Main, root }; + MD_ParseWorkNode broken_work = { 0, ParseWorkKind_Main, root }; + MD_ParseWorkNode* work_top = &first_work; + MD_ParseWorkNode* work_free = 0; - #define parse_work_push(work_kind, work_parent) parse__work_push(work_kind, work_parent, work_top, work_free, &scratch) - #define parse_work_pop() parse__work_pop (work_top, &broken_work) + #define parse_work_push(work_kind, work_parent) md_parse__work_push(work_kind, work_parent, work_top, work_free, &scratch) + #define parse_work_pop() md_parse__work_pop (work_top, &broken_work) //- rjf: parse - Token* tokens_first = tokens.v; - Token* tokens_opl = tokens_first + tokens.count; - Token* token = tokens_first; + MD_Token* tokens_first = tokens.v; + MD_Token* tokens_opl = tokens_first + tokens.count; + MD_Token* token = tokens_first; for (;token < tokens_opl;) { //- rjf: unpack token - String8 token_string = str8_substr(text, token[0].range); + MD_String8 md_token_string = md_str8_substr(text, token[0].range); // Note(Ed): Each of the the follwoing conditionals will always terminate the iteration path to end_consume label. // TODO(Ed): Add opt-in support for whitespace awareness //- rjf: whitespace -> always no-op & inc - if (token->flags & TokenFlag_Whitespace) { + if (token->flags & MD_TokenFlag_Whitespace) { token += 1; goto end_consume; // @@ -705,7 +705,7 @@ parse_from_text_tokens__ainfo(AllocatorInfo ainfo, String8 filename, String8 tex // TODO(Ed): Add opt-in support for comment awareness //- rjf: comments -> always no-op & inc - if (token->flags & TokenFlagGroup_Comment) { + if (token->flags & MD_TokenFlagGroup_Comment) { token += 1; goto end_consume; // < // > @@ -715,8 +715,8 @@ parse_from_text_tokens__ainfo(AllocatorInfo ainfo, String8 filename, String8 tex //- rjf: [node follow up] : following label -> work top parent has children. // we need to scan for explicit delimiters, else parse an implicitly delimited set of children - if (work_top->kind == ParseWorkKind_NodeOptionalFollowUp && str8_match(token_string, str8_lit(":"), 0)) { - Node* parent = work_top->parent; + if (work_top->kind == ParseWorkKind_NodeOptionalFollowUp && md_str8_match(md_token_string, md_str8_lit(":"), 0)) { + MD_Node* parent = work_top->parent; parse_work_pop(); parse_work_push(ParseWorkKind_NodeChildrenStyleScan, parent); token += 1; @@ -732,19 +732,19 @@ parse_from_text_tokens__ainfo(AllocatorInfo ainfo, String8 filename, String8 tex // ..