mirror of
https://github.com/Ed94/gencpp.git
synced 2024-09-20 19:27:33 -07:00
1600 lines
34 KiB
C++
1600 lines
34 KiB
C++
/*
|
|
BLOAT.
|
|
|
|
This contians all definitions not directly related to the project.
|
|
*/
|
|
#pragma once
|
|
|
|
#ifdef BLOAT_IMPL
|
|
# define ZPL_IMPLEMENTATION
|
|
#endif
|
|
|
|
// TODO: This will be removed when making the library have zero dependencies.
|
|
#pragma region ZPL INCLUDE
|
|
#if __clang__
|
|
# pragma clang diagnostic push
|
|
# pragma clang diagnostic ignored "-Wmissing-braces"
|
|
# pragma clang diagnostic ignored "-Wbraced-scalar-init"
|
|
#endif
|
|
|
|
// # define ZPL_HEAP_ANALYSIS
|
|
# define ZPL_WRAP_IN_NAMESPACE
|
|
# define ZPL_NO_MATH_H
|
|
# define ZPL_CUSTOM_MODULES
|
|
# define ZPL_MODULE_ESSENTIALS
|
|
# define ZPL_MODULE_CORE
|
|
# define ZPL_MODULE_TIMER
|
|
# define ZPL_MODULE_HASHING
|
|
#include "zpl.h"
|
|
|
|
#undef Array
|
|
#undef heap
|
|
#undef alloc_item
|
|
#undef alloc_array
|
|
|
|
using zpl::b32;
|
|
using zpl::s8;
|
|
using zpl::s16;
|
|
using zpl::s32;
|
|
using zpl::s64;
|
|
using zpl::u8;
|
|
using zpl::u32;
|
|
using zpl::u64;
|
|
using zpl::uw;
|
|
using zpl::sw;
|
|
using zpl::sptr;
|
|
using zpl::uptr;
|
|
|
|
// using zpl::AllocType;
|
|
// using zpl::Arena;
|
|
// using zpl::AllocatorInfo;
|
|
// using zpl::ArrayHeader;
|
|
// using zpl::FileInfo;
|
|
// using zpl::FileError;
|
|
// using zpl::Pool;
|
|
// using zpl::String;
|
|
|
|
// using zpl::EAllocation_ALLOC;
|
|
// using zpl::EAllocation_FREE;
|
|
// using zpl::EAllocation_FREE_ALL;
|
|
// using zpl::EAllocation_RESIZE;
|
|
// using zpl::EFileMode_WRITE;
|
|
// using zpl::EFileError_NONE;
|
|
|
|
// using zpl::ZPL_ALLOCATOR_FLAG_CLEAR_TO_ZERO;
|
|
|
|
using zpl::align_forward;
|
|
using zpl::align_forward_i64;
|
|
// using zpl::alloc;
|
|
// using zpl::alloc_align;
|
|
// using zpl::arena_allocator;
|
|
// using zpl::arena_init_from_memory;
|
|
// using zpl::arena_init_from_allocator;
|
|
// using zpl::arena_free;
|
|
using zpl::assert_crash;
|
|
using zpl::char_first_occurence;
|
|
using zpl::char_is_alpha;
|
|
using zpl::char_is_alphanumeric;
|
|
using zpl::char_is_digit;
|
|
using zpl::char_is_hex_digit;
|
|
using zpl::char_is_space;
|
|
using zpl::crc32;
|
|
// using zpl::free_all;
|
|
using zpl::is_power_of_two;
|
|
using zpl::mem_copy;
|
|
using zpl::mem_move;
|
|
using zpl::mem_set;
|
|
using zpl::pointer_add;
|
|
// using zpl::pool_allocator;
|
|
// using zpl::pool_init;
|
|
// using zpl::pool_free;
|
|
using zpl::process_exit;
|
|
using zpl::str_compare;
|
|
using zpl::str_copy;
|
|
using zpl::str_fmt_buf;
|
|
using zpl::str_fmt_va;
|
|
using zpl::str_fmt_out_va;
|
|
using zpl::str_fmt_out_err_va;
|
|
using zpl::str_len;
|
|
using zpl::zero_size;
|
|
|
|
#if __clang__
|
|
# pragma clang diagnostic pop
|
|
#endif
|
|
#pragma endregion ZPL INCLUDE
|
|
|
|
|
|
#if __clang__
|
|
# pragma clang diagnostic ignored "-Wunused-const-variable"
|
|
# pragma clang diagnostic ignored "-Wswitch"
|
|
# pragma clang diagnostic ignored "-Wunused-variable"
|
|
# pragma clang diagnostic ignored "-Wunknown-pragmas"
|
|
# pragma clang diagnostic ignored "-Wvarargs"
|
|
# pragma clang diagnostic ignored "-Wunused-function"
|
|
#endif
|
|
|
|
|
|
#include "Banned.define.hpp"
|
|
|
|
|
|
#if defined(__GNUC__) || defined(__clang__)
|
|
// Supports 0-10 arguments
|
|
#define macro_num_args_impl( _0, \
|
|
_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
|
|
_11, _12, _13, _14, _15, _16, _17, _18, _19, _20, \
|
|
N, ... \
|
|
) N
|
|
// _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, \
|
|
// _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, \
|
|
// _41, _42, _43, _44, _45, _46, _47, _48, _49, _50,
|
|
|
|
// ## deletes preceding comma if _VA_ARGS__ is empty (GCC, Clang)
|
|
#define macro_num_args(...) \
|
|
macro_num_args_impl(_, ## __VA_ARGS__, \
|
|
20, 19, 18, 17, 16, 15, 14, 13, 12, 11, \
|
|
10, 9, 8, 7, 6, 5, 4, 3, 2, 1, \
|
|
0 \
|
|
)
|
|
// 50, 49, 48, 47, 46, 45, 44, 43, 42, 41, \
|
|
// 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, \
|
|
// 30, 29, 28, 27, 26, 25, 24, 23, 22, 21,
|
|
#else
|
|
// Supports 1-10 arguments
|
|
#define macro_num_args_impl( \
|
|
_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
|
|
_11, _12, _13, _14, _15, _16, _17, _18, _19, _20, \
|
|
N, ... \
|
|
) N
|
|
|
|
#define macro_num_args(...) \
|
|
macro_num_args_impl( __VA_ARGS__, \
|
|
20, 19, 18, 17, 16, 15, 14, 13, 12, 11, \
|
|
10, 9, 8, 7, 6, 5, 4, 3, 2, 1 \
|
|
)
|
|
#endif
|
|
|
|
#define macro_expand( Expanded_ ) Expanded_
|
|
|
|
#define bit( Value_ ) ( 1 << Value_ )
|
|
#define bitfield_is_equal( Type_, Field_, Mask_ ) ( (Type_(Mask_) & Type_(Field_)) == Type_(Mask_) )
|
|
#define forceinline ZPL_ALWAYS_INLINE
|
|
#define ccast( Type_, Value_ ) * const_cast< Type_* >( & (Value_) )
|
|
#define scast( Type_, Value_ ) static_cast< Type_ >( Value_ )
|
|
#define rcast( Type_, Value_ ) reinterpret_cast< Type_ >( Value_ )
|
|
#define pcast( Type_, Value_ ) ( * (Type_*)( & (Value_) ) )
|
|
#define GEN_STRINGIZE_VA( ... ) #__VA_ARGS__
|
|
#define txt( ... ) GEN_STRINGIZE_VA( __VA_ARGS__ )
|
|
#define txt_to_StrC( ... ) sizeof( GEN_STRINGIZE_VA( __VA_ARGS__ ) ), GEN_STRINGIZE_VA( __VA_ARGS__ )
|
|
#define do_once() \
|
|
do \
|
|
{ \
|
|
static \
|
|
bool Done = false; \
|
|
if ( Done ) \
|
|
return; \
|
|
Done = true; \
|
|
} \
|
|
while(0)
|
|
|
|
#define do_once_start \
|
|
do \
|
|
{ \
|
|
static \
|
|
bool Done = false; \
|
|
if ( Done ) \
|
|
break; \
|
|
Done = true;
|
|
|
|
#define do_once_end \
|
|
} \
|
|
while(0);
|
|
|
|
namespace gen
|
|
{
|
|
constexpr
|
|
char const* Msg_Invalid_Value = "INVALID VALUE PROVIDED";
|
|
|
|
#pragma region Memory
|
|
|
|
enum AllocType : u8
|
|
{
|
|
EAllocation_ALLOC,
|
|
EAllocation_FREE,
|
|
EAllocation_FREE_ALL,
|
|
EAllocation_RESIZE,
|
|
};
|
|
|
|
using AllocatorProc = void* ( void* allocator_data, AllocType type
|
|
, sw size, sw alignment
|
|
, void* old_memory, sw old_size
|
|
, u64 flags );
|
|
|
|
struct AllocatorInfo
|
|
{
|
|
AllocatorProc* Proc;
|
|
void* Data;
|
|
};
|
|
|
|
enum AllocFlag
|
|
{
|
|
ALLOCATOR_FLAG_CLEAR_TO_ZERO = bit( 0 ),
|
|
};
|
|
|
|
//! Allocate memory with default alignment.
|
|
ZPL_DEF_INLINE void* alloc( AllocatorInfo a, sw size );
|
|
|
|
//! Allocate memory with specified alignment.
|
|
ZPL_DEF_INLINE void* alloc_align( AllocatorInfo a, sw size, sw alignment );
|
|
|
|
//! Free allocated memory.
|
|
ZPL_DEF_INLINE void free( AllocatorInfo a, void* ptr );
|
|
|
|
//! Free all memory allocated by an allocator.
|
|
ZPL_DEF_INLINE void free_all( AllocatorInfo a );
|
|
|
|
//! Resize an allocated memory.
|
|
ZPL_DEF_INLINE void* resize( AllocatorInfo a, void* ptr, sw old_size, sw new_size );
|
|
|
|
//! Resize an allocated memory with specified alignment.
|
|
ZPL_DEF_INLINE void* resize_align( AllocatorInfo a, void* ptr, sw old_size, sw new_size, sw alignment );
|
|
|
|
#ifndef alloc_item
|
|
//! Allocate memory for an item.
|
|
# define alloc_item( allocator_, Type ) ( Type* )alloc( allocator_, size_of( Type ) )
|
|
|
|
//! Allocate memory for an array of items.
|
|
# define alloc_array( allocator_, Type, count ) ( Type* )alloc( allocator_, size_of( Type ) * ( count ) )
|
|
#endif
|
|
|
|
|
|
/* heap memory analysis tools */
|
|
/* define ZPL_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 */
|
|
void heap_stats_init( void );
|
|
sw heap_stats_used_memory( void );
|
|
sw heap_stats_alloc_count( void );
|
|
void heap_stats_check( void );
|
|
|
|
//! Allocate/Resize memory using default options.
|
|
|
|
//! Use this if you don't need a "fancy" resize allocation
|
|
ZPL_DEF_INLINE void* default_resize_align( AllocatorInfo a, void* ptr, sw old_size, sw new_size, sw alignment );
|
|
|
|
void* heap_allocator_proc( void* allocator_data, AllocType type, sw size, sw alignment, void* old_memory, sw old_size, u64 flags );
|
|
|
|
//! The heap allocator backed by operating system's memory manager.
|
|
constexpr AllocatorInfo heap( void ) { return { heap_allocator_proc, nullptr }; }
|
|
|
|
// #ifndef malloc
|
|
|
|
// //! Helper to allocate memory using heap allocator.
|
|
// # define malloc( sz ) ZPL_NS( alloc )( ZPL_NS( heap_allocator )(), sz )
|
|
|
|
// //! Helper to free memory allocated by heap allocator.
|
|
// # define mfree( ptr ) ZPL_NS( free )( ZPL_NS( heap_allocator )(), ptr )
|
|
|
|
// //! Alias to heap allocator.
|
|
// # define heap ZPL_NS( heap_allocator )
|
|
// #endif
|
|
|
|
ZPL_IMPL_INLINE void* alloc_align( AllocatorInfo a, sw size, sw alignment )
|
|
{
|
|
return a.Proc( a.Data, EAllocation_ALLOC, size, alignment, nullptr, 0, ZPL_DEFAULT_ALLOCATOR_FLAGS );
|
|
}
|
|
|
|
ZPL_IMPL_INLINE void* alloc( AllocatorInfo a, sw size )
|
|
{
|
|
return alloc_align( a, size, ZPL_DEFAULT_MEMORY_ALIGNMENT );
|
|
}
|
|
|
|
ZPL_IMPL_INLINE void free( AllocatorInfo a, void* ptr )
|
|
{
|
|
if ( ptr != nullptr )
|
|
a.Proc( a.Data, EAllocation_FREE, 0, 0, ptr, 0, ZPL_DEFAULT_ALLOCATOR_FLAGS );
|
|
}
|
|
|
|
ZPL_IMPL_INLINE void free_all( AllocatorInfo a )
|
|
{
|
|
a.Proc( a.Data, EAllocation_FREE_ALL, 0, 0, nullptr, 0, ZPL_DEFAULT_ALLOCATOR_FLAGS );
|
|
}
|
|
|
|
ZPL_IMPL_INLINE void* resize( AllocatorInfo a, void* ptr, sw old_size, sw new_size )
|
|
{
|
|
return resize_align( a, ptr, old_size, new_size, ZPL_DEFAULT_MEMORY_ALIGNMENT );
|
|
}
|
|
|
|
ZPL_IMPL_INLINE void* resize_align( AllocatorInfo a, void* ptr, sw old_size, sw new_size, sw alignment )
|
|
{
|
|
return a.Proc( a.Data, EAllocation_RESIZE, new_size, alignment, ptr, old_size, ZPL_DEFAULT_ALLOCATOR_FLAGS );
|
|
}
|
|
|
|
ZPL_IMPL_INLINE void* default_resize_align( AllocatorInfo a, void* old_memory, sw old_size, sw new_size, sw alignment )
|
|
{
|
|
if ( ! old_memory )
|
|
return alloc_align( a, new_size, alignment );
|
|
|
|
if ( new_size == 0 )
|
|
{
|
|
free( a, old_memory );
|
|
return nullptr;
|
|
}
|
|
|
|
if ( new_size < old_size )
|
|
new_size = old_size;
|
|
|
|
if ( old_size == new_size )
|
|
{
|
|
return old_memory;
|
|
}
|
|
else
|
|
{
|
|
void* new_memory = alloc_align( a, new_size, alignment );
|
|
if ( ! new_memory )
|
|
return nullptr;
|
|
mem_move( new_memory, old_memory, min( new_size, old_size ) );
|
|
free( a, old_memory );
|
|
return new_memory;
|
|
}
|
|
}
|
|
|
|
// ZPL_IMPL_INLINE AllocatorInfo heap( void )
|
|
// {
|
|
// AllocatorInfo a;
|
|
// a.Proc = heap_allocator_proc;
|
|
// a.Data = nullptr;
|
|
// return a;
|
|
// }
|
|
|
|
struct Arena
|
|
{
|
|
static
|
|
void* allocator_proc( void* allocator_data, AllocType type, sw size, sw alignment, void* old_memory, sw old_size, u64 flags );
|
|
|
|
static
|
|
Arena init_from_memory( void* start, sw size )
|
|
{
|
|
return
|
|
{
|
|
{ nullptr, nullptr },
|
|
start,
|
|
size,
|
|
0,
|
|
0
|
|
};
|
|
}
|
|
|
|
static
|
|
Arena init_from_allocator( AllocatorInfo backing, sw size )
|
|
{
|
|
Arena result =
|
|
{
|
|
backing,
|
|
alloc( backing, size),
|
|
size,
|
|
0,
|
|
0
|
|
};
|
|
return result;
|
|
}
|
|
|
|
static
|
|
Arena init_sub( Arena& parent, sw size )
|
|
{
|
|
return init_from_allocator( parent.Backing, size );
|
|
}
|
|
|
|
sw alignment_of( sw alignment )
|
|
{
|
|
sw alignment_offset, result_pointer, mask;
|
|
ZPL_ASSERT( is_power_of_two( alignment ) );
|
|
|
|
alignment_offset = 0;
|
|
result_pointer = (sw) PhysicalStart + TotalUsed;
|
|
mask = alignment - 1;
|
|
|
|
if ( result_pointer & mask )
|
|
alignment_offset = alignment - ( result_pointer & mask );
|
|
|
|
return alignment_offset;
|
|
}
|
|
|
|
void check()
|
|
{
|
|
ZPL_ASSERT( TempCount == 0 );
|
|
}
|
|
|
|
void free()
|
|
{
|
|
if ( Backing.Proc )
|
|
{
|
|
gen::free( Backing, PhysicalStart );
|
|
PhysicalStart = nullptr;
|
|
}
|
|
}
|
|
|
|
sw size_remaining( sw alignment )
|
|
{
|
|
sw result = TotalSize - ( TotalUsed + alignment_of( alignment ) );
|
|
return result;
|
|
}
|
|
|
|
AllocatorInfo Backing;
|
|
void* PhysicalStart;
|
|
sw TotalSize;
|
|
sw TotalUsed;
|
|
sw TempCount;
|
|
|
|
operator AllocatorInfo()
|
|
{
|
|
return { allocator_proc, this };
|
|
}
|
|
};
|
|
|
|
struct Pool
|
|
{
|
|
static
|
|
void* allocator_proc( void* allocator_data, AllocType type, sw size, sw alignment, void* old_memory, sw old_size, u64 flags );
|
|
|
|
static
|
|
Pool init( AllocatorInfo backing, sw num_blocks, sw block_size )
|
|
{
|
|
return init_align( backing, num_blocks, block_size, ZPL_DEFAULT_MEMORY_ALIGNMENT );
|
|
}
|
|
|
|
static
|
|
Pool init_align( AllocatorInfo backing, sw num_blocks, sw block_size, sw block_align );
|
|
|
|
void free()
|
|
{
|
|
if ( Backing.Proc )
|
|
{
|
|
gen::free( Backing, PhysicalStart );
|
|
}
|
|
}
|
|
|
|
AllocatorInfo Backing;
|
|
void* PhysicalStart;
|
|
void* FreeList;
|
|
sw BlockSize;
|
|
sw BlockAlign;
|
|
sw TotalSize;
|
|
sw NumBlocks;
|
|
|
|
operator AllocatorInfo()
|
|
{
|
|
return { allocator_proc, this };
|
|
}
|
|
};
|
|
|
|
#pragma endregion Memory
|
|
|
|
#pragma region Containers
|
|
#pragma push_macro("template")
|
|
#undef template
|
|
|
|
template<class Type>
|
|
struct Array
|
|
{
|
|
struct Header
|
|
{
|
|
AllocatorInfo Allocator;
|
|
uw Capacity;
|
|
uw Num;
|
|
};
|
|
|
|
static
|
|
Array init( AllocatorInfo allocator )
|
|
{
|
|
return init_reserve( allocator, grow_formula(0) );
|
|
}
|
|
|
|
static
|
|
Array init_reserve( AllocatorInfo allocator, sw capacity )
|
|
{
|
|
Header* header = rcast( Header*, alloc( allocator, sizeof(Header) + sizeof(Type) * capacity ));
|
|
|
|
if ( header == nullptr )
|
|
return { nullptr };
|
|
|
|
header->Allocator = allocator;
|
|
header->Capacity = capacity;
|
|
header->Num = 0;
|
|
|
|
return { rcast( Type*, header + 1) };
|
|
}
|
|
|
|
static
|
|
uw grow_formula( uw value )
|
|
{
|
|
return 2 * value + 8;
|
|
}
|
|
|
|
bool append( Type value )
|
|
{
|
|
Header* header = get_header();
|
|
|
|
if ( header->Num == header->Capacity )
|
|
{
|
|
if ( ! grow( header->Capacity ))
|
|
return false;
|
|
|
|
header = get_header();
|
|
}
|
|
|
|
Data[ header->Num ] = value;
|
|
header->Num++;
|
|
|
|
return true;
|
|
}
|
|
|
|
Type& back( void )
|
|
{
|
|
Header& header = * get_header();
|
|
return Data[ header.Num - 1 ];
|
|
}
|
|
|
|
void clear( void )
|
|
{
|
|
Header& header = * get_header();
|
|
header.Num = 0;
|
|
}
|
|
|
|
bool fill( uw begin, uw end, Type value )
|
|
{
|
|
Header& header = * get_header();
|
|
|
|
if ( begin < 0 || end >= header.Num )
|
|
return false;
|
|
|
|
for ( sw idx = begin; idx < end; idx++ )
|
|
{
|
|
Data[ idx ] = value;
|
|
}
|
|
// mem_set( Data + begin, value, end - begin)
|
|
|
|
return true;
|
|
}
|
|
|
|
void free( void )
|
|
{
|
|
Header& header = * get_header();
|
|
gen::free( header.Allocator, &header );
|
|
}
|
|
|
|
Header* get_header( void )
|
|
{
|
|
return rcast( Header*, Data ) - 1 ;
|
|
}
|
|
|
|
bool grow( uw min_capacity )
|
|
{
|
|
Header& header = * get_header();
|
|
uw new_capacity = grow_formula( header.Capacity );
|
|
|
|
if ( new_capacity < min_capacity )
|
|
new_capacity = min_capacity;
|
|
|
|
return set_capacity( new_capacity );
|
|
}
|
|
|
|
uw num( void )
|
|
{
|
|
return get_header()->Num;
|
|
}
|
|
|
|
bool pop( void )
|
|
{
|
|
Header& header = * get_header();
|
|
|
|
ZPL_ASSERT( header.Num > 0 );
|
|
header.Num--;
|
|
}
|
|
|
|
void remove_at( uw idx )
|
|
{
|
|
Header* header = get_header();
|
|
ZPL_ASSERT( idx < header->Num );
|
|
|
|
mem_move( header + idx, header + idx + 1, sizeof( Type ) * ( header->Num - idx - 1 ) );
|
|
header->Num--;
|
|
}
|
|
|
|
bool reserve( uw new_capacity )
|
|
{
|
|
Header& header = * get_header();
|
|
|
|
if ( header.Capacity < new_capacity )
|
|
return set_capacity( new_capacity );
|
|
|
|
return true;
|
|
}
|
|
|
|
bool resize( uw num )
|
|
{
|
|
Header* header = get_header();
|
|
|
|
if ( header->Capacity < num )
|
|
{
|
|
if ( ! grow( num ) )
|
|
return false;
|
|
}
|
|
|
|
header->Num = num;
|
|
return true;
|
|
}
|
|
|
|
bool set_capacity( uw new_capacity )
|
|
{
|
|
Header& header = * get_header();
|
|
|
|
if ( new_capacity == header.Capacity )
|
|
return true;
|
|
|
|
if ( new_capacity < header.Num )
|
|
header.Num = new_capacity;
|
|
|
|
sw size = sizeof( Header ) + sizeof( Type ) * new_capacity;
|
|
Header* new_header = reinterpret_cast< Header* >( alloc( header.Allocator, size ) );
|
|
|
|
if ( new_header == nullptr )
|
|
return false;
|
|
|
|
mem_move( new_header, &header, sizeof( Header ) + sizeof( Type ) * header.Num );
|
|
|
|
new_header->Capacity = new_capacity;
|
|
|
|
gen::free( header.Allocator, &header );
|
|
|
|
Data = rcast( Type*, new_header + 1);
|
|
return true;
|
|
}
|
|
|
|
Type* Data;
|
|
|
|
operator Type*()
|
|
{
|
|
return Data;
|
|
}
|
|
|
|
operator Type const*() const
|
|
{
|
|
return Data;
|
|
}
|
|
|
|
// For-range based support
|
|
|
|
Type* begin()
|
|
{
|
|
return Data;
|
|
}
|
|
|
|
Type* end()
|
|
{
|
|
return Data + get_header()->Num;
|
|
}
|
|
};
|
|
|
|
template<typename Type>
|
|
struct HashTable
|
|
{
|
|
struct FindResult
|
|
{
|
|
sw HashIndex;
|
|
sw PrevIndex;
|
|
sw EntryIndex;
|
|
};
|
|
|
|
struct Entry
|
|
{
|
|
u64 Key;
|
|
sw Next;
|
|
Type Value;
|
|
};
|
|
|
|
static
|
|
HashTable init( AllocatorInfo allocator )
|
|
{
|
|
HashTable<Type> result = { { nullptr }, { nullptr } };
|
|
|
|
result.Hashes = Array<sw>::init( allocator );
|
|
result.Entries = Array<Entry>::init( allocator );
|
|
|
|
return result;
|
|
}
|
|
|
|
void clear( void )
|
|
{
|
|
for ( sw idx = 0; idx < Hashes.num(); idx++ )
|
|
Hashes[ idx ] = -1;
|
|
|
|
Hashes.clear();
|
|
Entries.clear();
|
|
}
|
|
|
|
void destroy( void )
|
|
{
|
|
if ( Hashes && Hashes.get_header()->Capacity )
|
|
Hashes.free();
|
|
if ( Entries && Hashes.get_header()->Capacity )
|
|
Entries.free();
|
|
}
|
|
|
|
Type* get( u64 key )
|
|
{
|
|
sw idx = find( key ).EntryIndex;
|
|
if ( idx >= 0 )
|
|
return & Entries[ idx ].Value;
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
using MapProc = void (*)( u64 key, Type value );
|
|
|
|
void map( MapProc map_proc )
|
|
{
|
|
ZPL_ASSERT_NOT_NULL( map_proc );
|
|
|
|
for ( sw idx = 0; idx < Entries.num(); idx++ )
|
|
{
|
|
map_proc( Entries[ idx ].Key, Entries[ idx ].Value );
|
|
}
|
|
}
|
|
|
|
using MapMutProc = void (*)( u64 key, Type* value );
|
|
|
|
void map_mut( MapMutProc map_proc )
|
|
{
|
|
ZPL_ASSERT_NOT_NULL( map_proc );
|
|
|
|
for ( sw idx = 0; idx < Entries.num(); idx++ )
|
|
{
|
|
map_proc( Entries[ idx ].Key, & Entries[ idx ].Value );
|
|
}
|
|
}
|
|
|
|
void grow()
|
|
{
|
|
sw new_num = Array<Entry>::grow_formula( Entries.num() );
|
|
rehash( new_num );
|
|
}
|
|
|
|
void rehash( sw new_num )
|
|
{
|
|
sw idx;
|
|
sw last_added_index;
|
|
|
|
HashTable<Type> new_ht = init( Hashes.get_header()->Allocator );
|
|
|
|
new_ht.Hashes.resize( new_num );
|
|
new_ht.Entries.reserve( new_ht.Hashes.num() );
|
|
|
|
Array<sw>::Header* hash_header = new_ht.Hashes.get_header();
|
|
|
|
for ( idx = 0; idx < new_ht.Hashes.num(); ++idx )
|
|
new_ht.Hashes[ idx ] = -1;
|
|
|
|
for ( idx = 0; idx < Entries.num(); ++idx )
|
|
{
|
|
Entry& entry = Entries[ idx ];
|
|
|
|
FindResult find_result;
|
|
|
|
if ( new_ht.Hashes.num() == 0 )
|
|
new_ht.grow();
|
|
|
|
entry = Entries[ idx ];
|
|
find_result = new_ht.find( entry.Key );
|
|
last_added_index = new_ht.add_entry( entry.Key );
|
|
|
|
if ( find_result.PrevIndex < 0 )
|
|
new_ht.Hashes[ find_result.HashIndex ] = last_added_index;
|
|
|
|
else
|
|
new_ht.Entries[ find_result.PrevIndex ].Next = last_added_index;
|
|
|
|
new_ht.Entries[ last_added_index ].Next = find_result.EntryIndex;
|
|
new_ht.Entries[ last_added_index ].Value = entry.Value;
|
|
}
|
|
|
|
destroy();
|
|
// Hashes = new_ht.Hashes;
|
|
// Entries = new_ht.Entries;
|
|
*this = new_ht;
|
|
}
|
|
|
|
void rehash_fast()
|
|
{
|
|
sw idx;
|
|
|
|
for ( idx = 0; idx < Entries.num(); idx++ )
|
|
Entries[ idx ].Next = -1;
|
|
|
|
for ( idx = 0; idx < Hashes.num(); idx++ )
|
|
Hashes[ idx ] = -1;
|
|
|
|
for ( idx = 0; idx < Entries.num(); idx++ )
|
|
{
|
|
Entry* entry;
|
|
|
|
FindResult find_result;
|
|
}
|
|
}
|
|
|
|
void remove( u64 key )
|
|
{
|
|
FindResult find_result = find( key);
|
|
|
|
if ( find_result.EntryIndex >= 0 )
|
|
{
|
|
Entries.remove_at( find_result.EntryIndex );
|
|
rehash_fast();
|
|
}
|
|
}
|
|
|
|
void remove_entry( sw idx )
|
|
{
|
|
Entries.remove_at( idx );
|
|
}
|
|
|
|
void set( u64 key, Type value )
|
|
{
|
|
sw idx;
|
|
FindResult find_result;
|
|
|
|
if ( Hashes.num() == 0 )
|
|
grow();
|
|
|
|
find_result = find( key );
|
|
|
|
if ( find_result.EntryIndex >= 0 )
|
|
{
|
|
idx = find_result.EntryIndex;
|
|
}
|
|
else
|
|
{
|
|
idx = add_entry( key );
|
|
|
|
if ( find_result.PrevIndex >= 0 )
|
|
{
|
|
Entries[ find_result.PrevIndex ].Next = idx;
|
|
}
|
|
else
|
|
{
|
|
Hashes[ find_result.HashIndex ] = idx;
|
|
}
|
|
}
|
|
|
|
Entries[ idx ].Value = value;
|
|
|
|
if ( full() )
|
|
grow();
|
|
}
|
|
|
|
sw slot( u64 key )
|
|
{
|
|
for ( sw idx = 0; idx < Hashes.num(); ++idx )
|
|
if ( Hashes[ idx ] == key )
|
|
return idx;
|
|
|
|
return -1;
|
|
}
|
|
|
|
Array< sw> Hashes;
|
|
Array< Entry> Entries;
|
|
|
|
protected:
|
|
|
|
sw add_entry( u64 key )
|
|
{
|
|
sw idx;
|
|
Entry entry = { key, -1 };
|
|
|
|
idx = Entries.num();
|
|
Entries.append( entry );
|
|
return idx;
|
|
}
|
|
|
|
FindResult find( u64 key )
|
|
{
|
|
FindResult result = { -1, -1, -1 };
|
|
|
|
if ( Hashes.num() > 0 )
|
|
{
|
|
result.HashIndex = key % Hashes.num();
|
|
result.EntryIndex = Hashes[ result.HashIndex ];
|
|
|
|
while ( result.EntryIndex >= 0 )
|
|
{
|
|
if ( Entries[ result.EntryIndex ].Key == key )
|
|
break;
|
|
|
|
result.PrevIndex = result.EntryIndex;
|
|
result.EntryIndex = Entries[ result.EntryIndex ].Next;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
b32 full()
|
|
{
|
|
return 0.75f * Hashes.num() < Entries.num();
|
|
}
|
|
};
|
|
|
|
#pragma pop_macro("template")
|
|
#pragma endregion Containers
|
|
|
|
#pragma region String
|
|
// Constant string with length.
|
|
struct StrC
|
|
{
|
|
sw Len;
|
|
char const* Ptr;
|
|
|
|
static constexpr
|
|
StrC from( char const* str )
|
|
{
|
|
return { str_len( str ), str };
|
|
}
|
|
|
|
operator char const* () const
|
|
{
|
|
return Ptr;
|
|
}
|
|
};
|
|
|
|
// Dynamic String
|
|
// This is directly based off the ZPL string api.
|
|
// They used a header pattern
|
|
// I kept it for simplicty of porting but its not necessary to keep it that way.
|
|
struct String
|
|
{
|
|
struct Header
|
|
{
|
|
AllocatorInfo Allocator;
|
|
sw Length;
|
|
sw Capacity;
|
|
};
|
|
|
|
static
|
|
String make( AllocatorInfo allocator, char const* str )
|
|
{
|
|
sw length = str ? str_len( str ) : 0;
|
|
return make_length( allocator, str, length );
|
|
}
|
|
|
|
static
|
|
String make( AllocatorInfo allocator, StrC str )
|
|
{
|
|
return make_length( allocator, str.Ptr, str.Len );
|
|
}
|
|
|
|
static
|
|
String make_reserve( AllocatorInfo allocator, sw capacity )
|
|
{
|
|
constexpr sw header_size = sizeof( Header );
|
|
|
|
s32 alloc_size = header_size + capacity + 1;
|
|
void* allocation = alloc( allocator, alloc_size );
|
|
|
|
if ( allocation == nullptr )
|
|
return { nullptr };
|
|
|
|
mem_set( allocation, 0, alloc_size );
|
|
|
|
Header*
|
|
header = rcast(Header*, allocation);
|
|
header->Allocator = allocator;
|
|
header->Capacity = capacity;
|
|
header->Length = 0;
|
|
|
|
String result = { (char*)allocation + header_size };
|
|
return result;
|
|
}
|
|
|
|
static
|
|
String make_length( AllocatorInfo allocator, char const* str, sw length )
|
|
{
|
|
constexpr sw header_size = sizeof( Header );
|
|
|
|
s32 alloc_size = header_size + length + 1;
|
|
void* allocation = alloc( allocator, alloc_size );
|
|
|
|
if ( allocation == nullptr )
|
|
return { nullptr };
|
|
|
|
if ( ! str )
|
|
mem_set( allocation, 0, alloc_size );
|
|
|
|
Header&
|
|
header = * rcast(Header*, allocation);
|
|
header = { allocator, length, length };
|
|
|
|
String result = { rcast( char*, allocation) + header_size };
|
|
|
|
if ( length && str )
|
|
mem_copy( result, str, length );
|
|
|
|
result[ length ] = '\0';
|
|
|
|
return result;
|
|
}
|
|
|
|
static
|
|
String fmt( AllocatorInfo allocator, char* buf, sw buf_size, char const* fmt, ... )
|
|
{
|
|
va_list va;
|
|
va_start( va, fmt );
|
|
str_fmt_va( buf, buf_size, fmt, va );
|
|
va_end( va );
|
|
|
|
return make( allocator, buf );
|
|
}
|
|
|
|
static
|
|
String fmt_buf( AllocatorInfo allocator, char const* fmt, ... )
|
|
{
|
|
local_persist thread_local
|
|
char buf[ ZPL_PRINTF_MAXLEN ] = { 0 };
|
|
|
|
va_list va;
|
|
va_start( va, fmt );
|
|
str_fmt_va( buf, ZPL_PRINTF_MAXLEN, fmt, va );
|
|
va_end( va );
|
|
|
|
return make( allocator, buf );
|
|
}
|
|
|
|
static
|
|
String join( AllocatorInfo allocator, char const** parts, sw num_parts, char const* glue )
|
|
{
|
|
String result = make( allocator, "" );
|
|
|
|
for ( sw idx = 0; idx < num_parts; ++idx )
|
|
{
|
|
result.append( parts[ idx ] );
|
|
|
|
if ( idx < num_parts - 1 )
|
|
result.append( glue );
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
static
|
|
bool are_equal( String lhs, String rhs )
|
|
{
|
|
if ( lhs.length() != rhs.length() )
|
|
return false;
|
|
|
|
for ( sw idx = 0; idx < lhs.length(); ++idx )
|
|
if ( lhs[ idx ] != rhs[ idx ] )
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool make_space_for( char const* str, sw add_len )
|
|
{
|
|
sw available = avail_space();
|
|
|
|
// NOTE: Return if there is enough space left
|
|
if ( available >= add_len )
|
|
{
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
sw new_len, old_size, new_size;
|
|
|
|
void* ptr;
|
|
void* new_ptr;
|
|
|
|
AllocatorInfo allocator = get_header().Allocator;
|
|
Header* header = nullptr;
|
|
|
|
new_len = length() + add_len;
|
|
ptr = & get_header();
|
|
old_size = size_of( Header ) + length() + 1;
|
|
new_size = size_of( Header ) + new_len + 1;
|
|
|
|
new_ptr = resize( allocator, ptr, old_size, new_size );
|
|
|
|
if ( new_ptr == nullptr )
|
|
return false;
|
|
|
|
header = zpl_cast( Header* ) new_ptr;
|
|
header->Allocator = allocator;
|
|
header->Capacity = new_len;
|
|
|
|
Data = rcast( char*, header + 1 );
|
|
|
|
return str;
|
|
}
|
|
}
|
|
|
|
bool append( char const* str )
|
|
{
|
|
return append( str, str_len( str ) );
|
|
}
|
|
|
|
bool append( char const* str, sw length )
|
|
{
|
|
if ( sptr(str) > 0 )
|
|
{
|
|
sw curr_len = this->length();
|
|
|
|
if ( ! make_space_for( str, length ) )
|
|
return false;
|
|
|
|
Header& header = get_header();
|
|
|
|
mem_copy( Data + curr_len, str, length );
|
|
|
|
Data[ curr_len + length ] = '\0';
|
|
|
|
header.Length = curr_len + length;
|
|
}
|
|
|
|
return str;
|
|
}
|
|
|
|
bool append( StrC str)
|
|
{
|
|
return append( str.Ptr, str.Len );
|
|
}
|
|
|
|
bool append( const String other )
|
|
{
|
|
return append( other.Data, other.length() );
|
|
}
|
|
|
|
bool append_fmt( char const* fmt, ... )
|
|
{
|
|
sw res;
|
|
char buf[ ZPL_PRINTF_MAXLEN ] = { 0 };
|
|
|
|
va_list va;
|
|
va_start( va, fmt );
|
|
res = str_fmt_va( buf, count_of( buf ) - 1, fmt, va ) - 1;
|
|
va_end( va );
|
|
|
|
return append( buf, res );
|
|
}
|
|
|
|
sw avail_space() const
|
|
{
|
|
Header const&
|
|
header = * rcast( Header const*, Data - sizeof( Header ));
|
|
|
|
return header.Capacity - header.Length;
|
|
}
|
|
|
|
sw capacity() const
|
|
{
|
|
Header const&
|
|
header = * rcast( Header const*, Data - sizeof( Header ));
|
|
|
|
return header.Capacity;
|
|
}
|
|
|
|
void clear()
|
|
{
|
|
get_header().Length = 0;
|
|
}
|
|
|
|
String duplicate( AllocatorInfo allocator )
|
|
{
|
|
return make_length( allocator, Data, length() );
|
|
}
|
|
|
|
void free()
|
|
{
|
|
if ( ! Data )
|
|
return;
|
|
|
|
Header& header = get_header();
|
|
|
|
gen::free( header.Allocator, & header );
|
|
}
|
|
|
|
Header& get_header()
|
|
{
|
|
return *(Header*)(Data - sizeof(Header));
|
|
}
|
|
|
|
sw length() const
|
|
{
|
|
Header const&
|
|
header = * rcast( Header const*, Data - sizeof( Header ));
|
|
|
|
return header.Length;
|
|
}
|
|
|
|
void trim( char const* cut_set )
|
|
{
|
|
sw len = 0;
|
|
|
|
char* start_pos = Data;
|
|
char* end_pos = Data + length() - 1;
|
|
|
|
while ( start_pos <= end_pos && char_first_occurence( cut_set, *start_pos ) )
|
|
start_pos++;
|
|
|
|
while ( end_pos > start_pos && char_first_occurence( cut_set, *end_pos ) )
|
|
end_pos--;
|
|
|
|
len = scast( sw, ( start_pos > end_pos ) ? 0 : ( ( end_pos - start_pos ) + 1 ) );
|
|
|
|
if ( Data != start_pos )
|
|
mem_move( Data, start_pos, len );
|
|
|
|
Data[ len ] = '\0';
|
|
|
|
get_header().Length = len;
|
|
}
|
|
|
|
void trim_space()
|
|
{
|
|
return trim( " \t\r\n\v\f" );
|
|
}
|
|
|
|
// For-range support
|
|
|
|
char* begin()
|
|
{
|
|
return Data;
|
|
}
|
|
|
|
char* end()
|
|
{
|
|
Header const&
|
|
header = * rcast( Header const*, Data - sizeof( Header ));
|
|
|
|
return Data + header.Length;
|
|
}
|
|
|
|
operator bool()
|
|
{
|
|
return Data;
|
|
}
|
|
|
|
operator char* ()
|
|
{
|
|
return Data;
|
|
}
|
|
|
|
operator char const* () const
|
|
{
|
|
return Data;
|
|
}
|
|
|
|
operator StrC() const
|
|
{
|
|
return
|
|
{
|
|
length(),
|
|
Data
|
|
};
|
|
}
|
|
|
|
// Used with cached strings
|
|
// Essentially makes the string a string view.
|
|
String const& operator = ( String const& other ) const
|
|
{
|
|
if ( this == & other )
|
|
return *this;
|
|
|
|
String& this_ = ccast( String, *this );
|
|
|
|
this_.Data = other.Data;
|
|
|
|
return this_;
|
|
}
|
|
|
|
char& operator [] ( sw index )
|
|
{
|
|
return Data[ index ];
|
|
}
|
|
|
|
char const& operator [] ( sw index ) const
|
|
{
|
|
return Data[ index ];
|
|
}
|
|
|
|
char* Data = nullptr;
|
|
};
|
|
|
|
struct String_POD
|
|
{
|
|
char* Data;
|
|
|
|
operator String()
|
|
{
|
|
return * rcast(String*, this);
|
|
}
|
|
};
|
|
static_assert( sizeof( String_POD ) == sizeof( String ), "String is not a POD" );
|
|
#pragma endregion String
|
|
|
|
#pragma region File Handling
|
|
|
|
typedef u32 FileMode;
|
|
|
|
enum FileModeFlag
|
|
{
|
|
EFileMode_READ = bit( 0 ),
|
|
EFileMode_WRITE = bit( 1 ),
|
|
EFileMode_APPEND = bit( 2 ),
|
|
EFileMode_RW = bit( 3 ),
|
|
ZPL_FILE_MODES = EFileMode_READ | EFileMode_WRITE | EFileMode_APPEND | EFileMode_RW,
|
|
};
|
|
|
|
// NOTE: Only used internally and for the file operations
|
|
enum SeekWhenceType
|
|
{
|
|
ESeekWhence_BEGIN = 0,
|
|
ESeekWhence_CURRENT = 1,
|
|
ESeekWhence_END = 2,
|
|
};
|
|
|
|
enum FileError
|
|
{
|
|
EFileError_NONE,
|
|
EFileError_INVALID,
|
|
EFileError_INVALID_FILENAME,
|
|
EFileError_EXISTS,
|
|
EFileError_NOT_EXISTS,
|
|
EFileError_PERMISSION,
|
|
EFileError_TRUNCATION_FAILURE,
|
|
EFileError_NOT_EMPTY,
|
|
EFileError_NAME_TOO_LONG,
|
|
EFileError_UNKNOWN,
|
|
};
|
|
|
|
union FileDescriptor
|
|
{
|
|
void* p;
|
|
sptr i;
|
|
uptr u;
|
|
};
|
|
|
|
typedef struct FileOperations FileOperations;
|
|
|
|
#define ZPL_FILE_OPEN_PROC( name ) FileError name( FileDescriptor* fd, FileOperations* ops, FileMode mode, char const* filename )
|
|
#define ZPL_FILE_READ_AT_PROC( name ) b32 name( FileDescriptor fd, void* buffer, sw size, s64 offset, sw* bytes_read, b32 stop_at_newline )
|
|
#define ZPL_FILE_WRITE_AT_PROC( name ) b32 name( FileDescriptor fd, void const* buffer, sw size, s64 offset, sw* bytes_written )
|
|
#define ZPL_FILE_SEEK_PROC( name ) b32 name( FileDescriptor fd, s64 offset, SeekWhenceType whence, s64* new_offset )
|
|
#define ZPL_FILE_CLOSE_PROC( name ) void name( FileDescriptor fd )
|
|
|
|
typedef ZPL_FILE_OPEN_PROC( file_open_proc );
|
|
typedef ZPL_FILE_READ_AT_PROC( FileReadProc );
|
|
typedef ZPL_FILE_WRITE_AT_PROC( FileWriteProc );
|
|
typedef ZPL_FILE_SEEK_PROC( FileSeekProc );
|
|
typedef ZPL_FILE_CLOSE_PROC( FileCloseProc );
|
|
|
|
struct FileOperations
|
|
{
|
|
FileReadProc* read_at;
|
|
FileWriteProc* write_at;
|
|
FileSeekProc* seek;
|
|
FileCloseProc* close;
|
|
};
|
|
|
|
extern FileOperations const default_file_operations;
|
|
|
|
typedef u64 FileTime;
|
|
|
|
enum DirType
|
|
{
|
|
ZPL_DIR_TYPE_FILE,
|
|
ZPL_DIR_TYPE_FOLDER,
|
|
ZPL_DIR_TYPE_UNKNOWN,
|
|
};
|
|
|
|
struct DirInfo;
|
|
|
|
struct DirEntry
|
|
{
|
|
char const* FileName;
|
|
DirInfo* Info;
|
|
u8 Type;
|
|
};
|
|
|
|
struct DirInfo
|
|
{
|
|
char const* FullPath;
|
|
DirEntry* Entries; // zpl_array
|
|
|
|
// Internals
|
|
char** Filenames; // zpl_array
|
|
String Buffer;
|
|
};
|
|
|
|
struct FileInfo
|
|
{
|
|
FileOperations Ops;
|
|
FileDescriptor FD;
|
|
b32 IsTemp;
|
|
|
|
char const* Filename;
|
|
FileTime LastWriteTime;
|
|
DirEntry* Dir;
|
|
};
|
|
|
|
/**
|
|
* Closes the file
|
|
* @param file
|
|
*/
|
|
FileError file_close( FileInfo* file );
|
|
|
|
/**
|
|
* Returns the currently opened file's name
|
|
* @param file
|
|
*/
|
|
inline
|
|
char const* file_name( FileInfo* file )
|
|
{
|
|
return file->Filename ? file->Filename : "";
|
|
}
|
|
|
|
/**
|
|
* Opens a file using a specified mode
|
|
* @param file
|
|
* @param mode Access mode to use
|
|
* @param filename
|
|
*/
|
|
FileError file_open_mode( FileInfo* file, FileMode mode, char const* filename );
|
|
|
|
/**
|
|
* Seeks the file cursor from the beginning of file to a specific position
|
|
* @param file
|
|
* @param offset Offset to seek to
|
|
*/
|
|
ZPL_DEF_INLINE s64 file_seek( FileInfo* file, s64 offset );
|
|
|
|
/**
|
|
* Returns the length from the beginning of the file we've read so far
|
|
* @param file
|
|
* @return Our current position in file
|
|
*/
|
|
ZPL_DEF_INLINE s64 file_tell( FileInfo* file );
|
|
|
|
/**
|
|
* Writes to a file
|
|
* @param file
|
|
* @param buffer Buffer to read from
|
|
* @param size Size to read
|
|
*/
|
|
b32 file_write( FileInfo* file, void const* buffer, sw size );
|
|
|
|
/**
|
|
* Writes to file at a specific offset
|
|
* @param file
|
|
* @param buffer Buffer to read from
|
|
* @param size Size to write
|
|
* @param offset Offset to write to
|
|
* @param bytes_written How much data we've actually written
|
|
*/
|
|
ZPL_DEF_INLINE b32 file_write_at( FileInfo* file, void const* buffer, sw size, s64 offset );
|
|
|
|
/**
|
|
* Writes to file safely
|
|
* @param file
|
|
* @param buffer Buffer to read from
|
|
* @param size Size to write
|
|
* @param offset Offset to write to
|
|
* @param bytes_written How much data we've actually written
|
|
*/
|
|
ZPL_DEF_INLINE b32 file_write_at_check( FileInfo* file, void const* buffer, sw size, s64 offset, sw* bytes_written );
|
|
|
|
ZPL_IMPL_INLINE s64 file_seek( FileInfo* f, s64 offset )
|
|
{
|
|
s64 new_offset = 0;
|
|
|
|
if ( ! f->Ops.read_at )
|
|
f->Ops = default_file_operations;
|
|
|
|
f->Ops.seek( f->FD, offset, ESeekWhence_BEGIN, &new_offset );
|
|
|
|
return new_offset;
|
|
}
|
|
|
|
ZPL_IMPL_INLINE s64 file_tell( FileInfo* f )
|
|
{
|
|
s64 new_offset = 0;
|
|
|
|
if ( ! f->Ops.read_at )
|
|
f->Ops = default_file_operations;
|
|
|
|
f->Ops.seek( f->FD, 0, ESeekWhence_CURRENT, &new_offset );
|
|
|
|
return new_offset;
|
|
}
|
|
|
|
ZPL_IMPL_INLINE b32 file_write( FileInfo* f, void const* buffer, sw size )
|
|
{
|
|
s64 cur_offset = file_tell( f );
|
|
b32 result = file_write_at( f, buffer, size, file_tell( f ) );
|
|
|
|
file_seek( f, cur_offset + size );
|
|
|
|
return result;
|
|
}
|
|
|
|
ZPL_IMPL_INLINE b32 file_write_at( FileInfo* f, void const* buffer, sw size, s64 offset )
|
|
{
|
|
return file_write_at_check( f, buffer, size, offset, NULL );
|
|
}
|
|
|
|
ZPL_IMPL_INLINE b32 file_write_at_check( FileInfo* f, void const* buffer, sw size, s64 offset, sw* bytes_written )
|
|
{
|
|
if ( ! f->Ops.read_at )
|
|
f->Ops = default_file_operations;
|
|
return f->Ops.write_at( f->FD, buffer, size, offset, bytes_written );
|
|
}
|
|
|
|
void dirinfo_free( DirInfo* dir );
|
|
|
|
#pragma endregion File Handling
|
|
|
|
namespace Memory
|
|
{
|
|
// NOTE: This limits the size of the string that can be read from a file or generated to 10 megs.
|
|
// If you are generating a string larger than this, increase the size of the bucket here.
|
|
constexpr uw BucketSize = megabytes(10);
|
|
|
|
// Global allocator used for data with process lifetime.
|
|
extern AllocatorInfo GlobalAllocator;
|
|
|
|
// Heap allocator is being used for now to isolate errors from being memory related (tech debt till ready to address)
|
|
// #define g_allocator heap()
|
|
|
|
void setup();
|
|
void cleanup();
|
|
}
|
|
|
|
|
|
inline
|
|
sw log_fmt(char const* fmt, ...)
|
|
{
|
|
sw res;
|
|
va_list va;
|
|
|
|
va_start(va, fmt);
|
|
res = str_fmt_out_va(fmt, va);
|
|
va_end(va);
|
|
|
|
return res;
|
|
}
|
|
|
|
inline
|
|
sw fatal(char const* fmt, ...)
|
|
{
|
|
local_persist thread_local
|
|
char buf[ZPL_PRINTF_MAXLEN] = { 0 };
|
|
|
|
va_list va;
|
|
|
|
#if Build_Debug
|
|
va_start(va, fmt);
|
|
str_fmt_va(buf, ZPL_PRINTF_MAXLEN, fmt, va);
|
|
va_end(va);
|
|
|
|
assert_crash(buf);
|
|
return -1;
|
|
#else
|
|
va_start(va, fmt);
|
|
str_fmt_out_err_va( fmt, va);
|
|
va_end(va);
|
|
|
|
exit(1);
|
|
return -1;
|
|
#endif
|
|
}
|
|
|
|
// gen namespace
|
|
}
|