ed/gencpp
1
0
Fork 0
mirror of https://github.com/Ed94/gencpp.git synced 2024-11-12 20:04:52 -08:00
Code Issues Packages Projects Releases Wiki Activity

gencpp : General refactors to dependencies

Browse Source 
Mostly just cleanup and renaming of certain stuff (mostly in dependencies).

* Changed uw and sw to usize and ssize.
* Removed zpl_cast usage throughout dependencies
* No longer using GEN_DEF_INLINE & GEN_IMPL_INLINE
* header_start.hpp renamed to platform.hpp for depdendencies header.
This commit is contained in:
Edward R. Gonzalez 2024-10-27 18:58:37 -04:00
parent 00df336610
commit 2e5e31ed3b
49 changed files with 1059 additions and 988 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
Readme.md
View File

@ -67,7 +67,7 @@ Example using each construction interface:
Validation and construction through a functional interface.
```cpp
Code t_uw = def_type( name(uw) );
Code t_uw = def_type( name(usize) );
Code t_allocator = def_type( name(allocator) );
Code t_string_const = def_type( name(char), def_specifiers( args( ESpecifier::Const, ESpecifier::Ptr ) ));
@ -90,8 +90,8 @@ Validation through ast construction.
Code header = parse_struct( code(
struct ArrayHeader
{
uw Num;
uw Capacity;
usize Num;
usize Capacity;
allocator Allocator;
};
));
@ -106,8 +106,8 @@ No validation, just glorified text injection.
Code header = code_str(
struct ArrayHeader
{
uw Num;
uw Capacity;
usize Num;
usize Capacity;
allocator Allocator;
};
);
@ -123,8 +123,8 @@ All three constrcuton interfaces will generate the following C code:
```cpp
struct ArrayHeader
{
uw Num;
uw Capacity;
usize Num;
usize Capacity;
allocator Allocator;
};
```

4
docs/Readme.md
View File

@ -136,7 +136,7 @@ The width dictates how much the static array can hold before it must give way to
```cpp
constexpr static
uw ArrSpecs_Cap =
usize ArrSpecs_Cap =
(
AST_POD_Size
- sizeof(AST*) * 3
@ -158,7 +158,7 @@ Data Notes:
* Most of the work is just defining the allocation procedure:
```cpp
void* ( void* allocator_data, AllocType type, sw size, sw alignment, void* old_memory, sw old_size, u64 flags );
void* ( void* allocator_data, AllocType type, ssize size, ssize alignment, void* old_memory, ssize old_size, u64 flags );
```
* ASTs are wrapped for the user in a Code struct which is a wrapper for a AST* type.

10
gencpp.10x
View File

@ -6,6 +6,7 @@
<SyncFiles>true</SyncFiles>
<Recursive>true</Recursive>
<ShowEmptyFolders>true</ShowEmptyFolders>
<IncludeFilesWithoutExt>false</IncludeFilesWithoutExt>
<IsVirtual>false</IsVirtual>
<IsFolder>false</IsFolder>
<BuildCommand>pwsh ./scripts/build.ps1 msvc debug bootstrap</BuildCommand>
@ -14,12 +15,13 @@
<CleanCommand>pwsh ./scripts/clean.ps1</CleanCommand>
<BuildWorkingDirectory></BuildWorkingDirectory>
<CancelBuild></CancelBuild>
<RunCommand>./test/gen/build/gencpp.exe</RunCommand>
<RunCommandWorkingDirectory></RunCommandWorkingDirectory>
<Exe>./test/gen/build/gencpp.exe</Exe>
<Args></Args>
<WorkingDirectory></WorkingDirectory>
<DebugCommand>pwsh ./scripts/build.ps1</DebugCommand>
<ExePathCommand>./test/gen/build/gencpp.exe</ExePathCommand>
<DebugSln></DebugSln>
<UseVisualStudioEnvBat>true</UseVisualStudioEnvBat>
<CaptureExeOutput>false</CaptureExeOutput>
<Configurations>
<Configuration>Debug</Configuration>
<Configuration>Release</Configuration>
@ -44,6 +46,8 @@
<Define>GEN_SYSTEM_WINDOWS</Define>
<Define>GEN_INTELLISENSE_DIRECTIVES</Define>
<Define>GEN_EXECUTION_EXPRESSION_SUPPORT</Define>
<Define>GEN_BENCHMARK</Define>
<Define>GEN_COMPILER_MSVC</Define>
</Defines>
<ConfigProperties>
<ConfigAndPlatform>

4
project/auxillary/builder.cpp
View File

@ -27,14 +27,14 @@ void Builder::pad_lines( s32 num )
void Builder::print( Code code )
{
String str = code->to_string();
// const sw len = str.length();
// const ssize len = str.length();
// log_fmt( "%s - print: %.*s\n", File.filename, len > 80 ? 80 : len, str.Data );
Buffer.append( str );
}
void Builder::print_fmt( char const* fmt, ... )
{
sw res;
ssize res;
char buf[ GEN_PRINTF_MAXLEN ] = { 0 };
va_list va;

2
project/auxillary/scanner.hpp
View File

@ -17,7 +17,7 @@ Code scan_file( char const* path )
GEN_FATAL( "scan_file: Could not open: %s", path );
}
sw fsize = file_size( & file );
ssize fsize = file_size( & file );
if ( fsize <= 0 )
{
GEN_FATAL("scan_file: %s is empty", path );

13
project/bootstrap.cpp
View File

@ -29,7 +29,7 @@ int gen_main()
// gen_dep.hpp
{
Code header_start = scan_file( "dependencies/header_start.hpp" );
Code platform = scan_file( "dependencies/platform.hpp" );
Code macros = scan_file( "dependencies/macros.hpp" );
Code basic_types = scan_file( "dependencies/basic_types.hpp" );
Code debug = scan_file( "dependencies/debug.hpp" );
@ -45,8 +45,8 @@ int gen_main()
Builder
header = Builder::open("gen/gen.dep.hpp");
header.print_fmt( generation_notice );
header.print_fmt( "// This file is intended to be included within gen.hpp (There is no pragma diagnostic ignores)\n\n" );
header.print( header_start );
header.print_fmt( "// This file is intended to be included within gen.hpp (There is no pragma diagnostic ignores)\n" );
header.print( platform );
header.print_fmt( "\nGEN_NS_BEGIN\n" );
header.print( macros );
@ -80,7 +80,7 @@ int gen_main()
Builder
src = Builder::open( "gen/gen.dep.cpp" );
src.print_fmt( generation_notice );
src.print_fmt( "// This file is intended to be included within gen.cpp (There is no pragma diagnostic ignores)\n\n" );
src.print_fmt( "// This file is intended to be included within gen.cpp (There is no pragma diagnostic ignores)\n" );
src.print( src_start );
src.print_fmt( "\nGEN_NS_BEGIN\n" );
@ -203,7 +203,7 @@ int gen_main()
src.print_fmt( generation_notice );
src.print( push_ignores );
src.print( src_start );
src.print_fmt( "GEN_NS_BEGIN\n");
src.print_fmt( "\nGEN_NS_BEGIN\n");
src.print( static_data );
@ -278,12 +278,11 @@ int gen_main()
header.print_fmt( "\nGEN_NS_BEGIN\n" );
header.print( parsing );
header.print( scanner );
header.print_fmt( "GEN_NS_END\n" );
header.print_fmt( "\nGEN_NS_END\n" );
header.write();
}
// gen_scanner.cpp
if (1)
{
Code parsing = scan_file( "dependencies/parsing.cpp" );
Code scanner = scan_file( "auxillary/scanner.cpp" );

6
project/components/header_end.hpp
View File

@ -42,7 +42,7 @@ constexpr s32 InitSize_DataArrays = 16;
// NOTE: This limits the maximum size of an allocation
// If you are generating a string larger than this, increase the size of the bucket here.
constexpr uw Global_BucketSize = GEN_GLOBAL_BUCKET_SIZE;
constexpr usize Global_BucketSize = GEN_GLOBAL_BUCKET_SIZE;
constexpr s32 CodePool_NumBlocks = GEN_CODEPOOL_NUM_BLOCKS;
constexpr s32 SizePer_StringArena = GEN_SIZE_PER_STRING_ARENA;
@ -122,8 +122,8 @@ extern CodeType t_typename;
extern CodeType t_u32;
extern CodeType t_u64;
extern CodeType t_sw;
extern CodeType t_uw;
extern CodeType t_ssize;
extern CodeType t_usize;
extern CodeType t_f32;
extern CodeType t_f64;

4
project/components/inlines.hpp
View File

@ -193,7 +193,7 @@ CodeBody def_body( CodeT type )
}
inline
StrC token_fmt_impl( sw num, ... )
StrC token_fmt_impl( ssize num, ... )
{
local_persist thread_local
char buf[GEN_PRINTF_MAXLEN] = { 0 };
@ -201,7 +201,7 @@ StrC token_fmt_impl( sw num, ... )
va_list va;
va_start(va, num );
sw result = token_fmt_va(buf, GEN_PRINTF_MAXLEN, num, va);
ssize result = token_fmt_va(buf, GEN_PRINTF_MAXLEN, num, va);
va_end(va);
return { result, buf };

14
project/components/interface.cpp
View File

@ -9,7 +9,7 @@ internal void deinit();
}
internal
void* Global_Allocator_Proc( void* allocator_data, AllocType type, sw size, sw alignment, void* old_memory, sw old_size, u64 flags )
void* Global_Allocator_Proc( void* allocator_data, AllocType type, ssize size, ssize alignment, void* old_memory, ssize old_size, u64 flags )
{
Arena* last = & Global_AllocatorBuckets.back();
@ -169,8 +169,8 @@ void define_constants()
def_constant_code_type( u32 );
def_constant_code_type( u64 );
def_constant_code_type( sw );
def_constant_code_type( uw );
def_constant_code_type( ssize );
def_constant_code_type( usize );
def_constant_code_type( f32 );
def_constant_code_type( f64 );
@ -298,8 +298,8 @@ void init()
void deinit()
{
uw index = 0;
uw left = CodePools.num();
usize index = 0;
usize left = CodePools.num();
do
{
Pool* code_pool = & CodePools[index];
@ -372,9 +372,9 @@ AllocatorInfo get_string_allocator( s32 str_length )
{
Arena* last = & StringArenas.back();
uw size_req = str_length + sizeof(String::Header) + sizeof(char*);
usize size_req = str_length + sizeof(String::Header) + sizeof(char*);
if ( last->TotalUsed + sw(size_req) > last->TotalSize )
if ( last->TotalUsed + ssize(size_req) > last->TotalSize )
{
Arena new_arena = Arena::init_from_allocator( Allocator_StringArena, SizePer_StringArena );

4
project/components/interface.hpp
View File

@ -204,9 +204,9 @@ CodeVar parse_variable ( StrC var_def );
#pragma region Untyped text
sw token_fmt_va( char* buf, uw buf_size, s32 num_tokens, va_list va );
ssize token_fmt_va( char* buf, usize buf_size, s32 num_tokens, va_list va );
//! Do not use directly. Use the token_fmt macro instead.
StrC token_fmt_impl( sw, ... );
StrC token_fmt_impl( ssize, ... );
Code untyped_str ( StrC content);
Code untyped_fmt ( char const* fmt, ... );

14
project/components/interface.untyped.cpp
View File

@ -3,10 +3,10 @@
#include "interface.parsing.cpp"
#endif
sw token_fmt_va( char* buf, uw buf_size, s32 num_tokens, va_list va )
ssize token_fmt_va( char* buf, usize buf_size, s32 num_tokens, va_list va )
{
char const* buf_begin = buf;
sw remaining = buf_size;
ssize remaining = buf_size;
local_persist
Arena tok_map_arena;
@ -37,7 +37,7 @@ sw token_fmt_va( char* buf, uw buf_size, s32 num_tokens, va_list va )
while ( current )
{
sw len = 0;
ssize len = 0;
while ( current && current != '<' && remaining )
{
@ -68,7 +68,7 @@ sw token_fmt_va( char* buf, uw buf_size, s32 num_tokens, va_list va )
if ( value )
{
sw left = value->Len;
ssize left = value->Len;
char const* str = value->Ptr;
while ( left-- )
@ -97,7 +97,7 @@ sw token_fmt_va( char* buf, uw buf_size, s32 num_tokens, va_list va )
tok_map.clear();
tok_map_arena.free();
sw result = buf_size - remaining;
ssize result = buf_size - remaining;
return result;
}
@ -138,7 +138,7 @@ Code untyped_fmt( char const* fmt, ...)
va_list va;
va_start(va, fmt);
sw length = str_fmt_va(buf, GEN_PRINTF_MAXLEN, fmt, va);
ssize length = str_fmt_va(buf, GEN_PRINTF_MAXLEN, fmt, va);
va_end(va);
Code
@ -169,7 +169,7 @@ Code untyped_token_fmt( s32 num_tokens, ... )
va_list va;
va_start(va, num_tokens);
sw length = token_fmt_va(buf, GEN_PRINTF_MAXLEN, num_tokens, va);
ssize length = token_fmt_va(buf, GEN_PRINTF_MAXLEN, num_tokens, va);
va_end(va);
Code

4
project/components/static_data.cpp
View File

@ -97,8 +97,8 @@ global CodeType t_u16;
global CodeType t_u32;
global CodeType t_u64;
global CodeType t_sw;
global CodeType t_uw;
global CodeType t_ssize;
global CodeType t_usize;
global CodeType t_f32;
global CodeType t_f64;

2
project/components/types.hpp
View File

@ -3,7 +3,7 @@
#include "header_start.hpp"
#endif
using LogFailType = sw(*)(char const*, ...);
using LogFailType = ssize(*)(char const*, ...);
// By default this library will either crash or exit if an error is detected while generating codes.
// Even if set to not use GEN_FATAL, GEN_FATAL will still be used for memory failures as the library is unusable when they occur.

29
project/dependencies/basic_types.hpp
View File

@ -47,21 +47,21 @@
#if defined( GEN_COMPILER_MSVC )
# if _MSC_VER < 1300
typedef unsigned char u8;
typedef signed char s8;
typedef signed char s8;
typedef unsigned short u16;
typedef signed short s16;
typedef signed short s16;
typedef unsigned int u32;
typedef signed int s32;
typedef signed int s32;
# else
typedef unsigned __int8 u8;
typedef signed __int8 s8;
typedef signed __int8 s8;
typedef unsigned __int16 u16;
typedef signed __int16 s16;
typedef signed __int16 s16;
typedef unsigned __int32 u32;
typedef signed __int32 s32;
typedef signed __int32 s32;
# endif
typedef unsigned __int64 u64;
typedef signed __int64 s64;
typedef signed __int64 s64;
#else
# include <stdint.h>
@ -85,10 +85,10 @@ static_assert( sizeof( u16 ) == 2, "sizeof(u16) != 2" );
static_assert( sizeof( u32 ) == 4, "sizeof(u32) != 4" );
static_assert( sizeof( u64 ) == 8, "sizeof(u64) != 8" );
typedef size_t uw;
typedef ptrdiff_t sw;
typedef size_t usize;
typedef ptrdiff_t ssize;
static_assert( sizeof( uw ) == sizeof( sw ), "sizeof(uw) != sizeof(sw)" );
static_assert( sizeof( usize ) == sizeof( ssize ), "sizeof(usize) != sizeof(ssize)" );
// NOTE: (u)zpl_intptr is only here for semantic reasons really as this library will only support 32/64 bit OSes.
#if defined( _WIN64 )
@ -122,4 +122,13 @@ typedef s8 b8;
typedef s16 b16;
typedef s32 b32;
using mem_ptr = void*;
using mem_ptr_const = void const*;
template<typename Type> uptr to_uptr( Type* ptr ) { return (uptr)ptr; }
template<typename Type> sptr to_sptr( Type* ptr ) { return (sptr)ptr; }
template<typename Type> mem_ptr to_mem_ptr ( Type ptr ) { return (mem_ptr) ptr; }
template<typename Type> mem_ptr_const to_mem_ptr_const( Type ptr ) { return (mem_ptr_const)ptr; }
#pragma endregion Basic Types

92
project/dependencies/containers.hpp
View File

@ -5,10 +5,10 @@
#pragma region Containers
template<class TType> struct RemoveConst { typedef TType Type; };
template<class TType> struct RemoveConst<const TType> { typedef TType Type; };
template<class TType> struct RemoveConst<const TType[]> { typedef TType Type[]; };
template<class TType, uw Size> struct RemoveConst<const TType[Size]> { typedef TType Type[Size]; };
template<class TType> struct RemoveConst { typedef TType Type; };
template<class TType> struct RemoveConst<const TType> { typedef TType Type; };
template<class TType> struct RemoveConst<const TType[]> { typedef TType Type[]; };
template<class TType, usize Size> struct RemoveConst<const TType[Size]> { typedef TType Type[Size]; };
template<class TType>
using TRemoveConst = typename RemoveConst<TType>::Type;
@ -19,8 +19,8 @@ struct Array
struct Header
{
AllocatorInfo Allocator;
uw Capacity;
uw Num;
usize Capacity;
usize Num;
};
static
@ -30,7 +30,7 @@ struct Array
}
static
Array init_reserve( AllocatorInfo allocator, sw capacity )
Array init_reserve( AllocatorInfo allocator, ssize capacity )
{
Header* header = rcast( Header*, alloc( allocator, sizeof(Header) + sizeof(Type) * capacity ));
@ -45,7 +45,7 @@ struct Array
}
static
uw grow_formula( uw value )
usize grow_formula( usize value )
{
return 2 * value + 8;
}
@ -73,7 +73,7 @@ struct Array
return true;
}
bool append( Type* items, uw item_num )
bool append( Type* items, usize item_num )
{
Header* header = get_header();
@ -91,7 +91,7 @@ struct Array
return true;
}
bool append_at( Type item, uw idx )
bool append_at( Type item, usize idx )
{
Header* header = get_header();
@ -117,7 +117,7 @@ struct Array
return true;
}
bool append_at( Type* items, uw item_num, uw idx )
bool append_at( Type* items, usize item_num, usize idx )
{
Header* header = get_header();
@ -156,14 +156,14 @@ struct Array
header.Num = 0;
}
bool fill( uw begin, uw end, Type value )
bool fill( usize begin, usize end, Type value )
{
Header& header = * get_header();
if ( begin < 0 || end > header.Num )
return false;
for ( sw idx = sw(begin); idx < sw(end); idx++ )
for ( ssize idx = ssize(begin); idx < ssize(end); idx++ )
{
Data[ idx ] = value;
}
@ -184,10 +184,10 @@ struct Array
return rcast( Header*, const_cast<NonConstType*>(Data) ) - 1 ;
}
bool grow( uw min_capacity )
bool grow( usize min_capacity )
{
Header& header = * get_header();
uw new_capacity = grow_formula( header.Capacity );
usize new_capacity = grow_formula( header.Capacity );
if ( new_capacity < min_capacity )
new_capacity = min_capacity;
@ -195,7 +195,7 @@ struct Array
return set_capacity( new_capacity );
}
uw num( void )
usize num( void )
{
return get_header()->Num;
}
@ -208,7 +208,7 @@ struct Array
header.Num--;
}
void remove_at( uw idx )
void remove_at( usize idx )
{
Header* header = get_header();
GEN_ASSERT( idx < header->Num );
@ -217,7 +217,7 @@ struct Array
header->Num--;
}
bool reserve( uw new_capacity )
bool reserve( usize new_capacity )
{
Header& header = * get_header();
@ -227,7 +227,7 @@ struct Array
return true;
}
bool resize( uw num )
bool resize( usize num )
{
Header* header = get_header();
@ -243,7 +243,7 @@ struct Array
return true;
}
bool set_capacity( uw new_capacity )
bool set_capacity( usize new_capacity )
{
Header& header = * get_header();
@ -257,7 +257,7 @@ struct Array
return true;
}
sw size = sizeof( Header ) + sizeof( Type ) * new_capacity;
ssize size = sizeof( Header ) + sizeof( Type ) * new_capacity;
Header* new_header = rcast( Header*, alloc( header.Allocator, size ) );
if ( new_header == nullptr )
@ -305,15 +305,15 @@ struct HashTable
{
struct FindResult
{
sw HashIndex;
sw PrevIndex;
sw EntryIndex;
ssize HashIndex;
ssize PrevIndex;
ssize EntryIndex;
};
struct Entry
{
u64 Key;
sw Next;
ssize Next;
Type Value;
};
@ -327,11 +327,11 @@ struct HashTable
}
static
HashTable init_reserve( AllocatorInfo allocator, uw num )
HashTable init_reserve( AllocatorInfo allocator, usize num )
{
HashTable<Type> result = { { nullptr }, { nullptr } };
result.Hashes = Array<sw>::init_reserve( allocator, num );
result.Hashes = Array<ssize>::init_reserve( allocator, num );
result.Hashes.get_header()->Num = num;
result.Hashes.resize( num );
result.Hashes.fill( 0, num, -1);
@ -357,7 +357,7 @@ struct HashTable
Type* get( u64 key )
{
sw idx = find( key ).EntryIndex;
ssize idx = find( key ).EntryIndex;
if ( idx >= 0 )
return & Entries[ idx ].Value;
@ -370,7 +370,7 @@ struct HashTable
{
GEN_ASSERT_NOT_NULL( map_proc );
for ( sw idx = 0; idx < sw(Entries.num()); ++idx )
for ( ssize idx = 0; idx < ssize(Entries.num()); ++idx )
{
map_proc( Entries[ idx ].Key, Entries[ idx ].Value );
}
@ -382,7 +382,7 @@ struct HashTable
{
GEN_ASSERT_NOT_NULL( map_proc );
for ( sw idx = 0; idx < sw(Entries.num()); ++idx )
for ( ssize idx = 0; idx < ssize(Entries.num()); ++idx )
{
map_proc( Entries[ idx ].Key, & Entries[ idx ].Value );
}
@ -390,16 +390,16 @@ struct HashTable
void grow()
{
sw new_num = Array<Entry>::grow_formula( Entries.num() );
ssize new_num = Array<Entry>::grow_formula( Entries.num() );
rehash( new_num );
}
void rehash( sw new_num )
void rehash( ssize new_num )
{
sw last_added_index;
ssize last_added_index;
HashTable<Type> new_ht = init_reserve( Hashes.get_header()->Allocator, new_num );
for ( sw idx = 0; idx < sw(Entries.num()); ++idx )
for ( ssize idx = 0; idx < ssize(Entries.num()); ++idx )
{
FindResult find_result;
@ -422,15 +422,15 @@ struct HashTable
void rehash_fast()
{
sw idx;
ssize idx;
for ( idx = 0; idx < sw(Entries.num()); idx++ )
for ( idx = 0; idx < ssize(Entries.num()); idx++ )
Entries[ idx ].Next = -1;
for ( idx = 0; idx < sw(Hashes.num()); idx++ )
for ( idx = 0; idx < ssize(Hashes.num()); idx++ )
Hashes[ idx ] = -1;
for ( idx = 0; idx < sw(Entries.num()); idx++ )
for ( idx = 0; idx < ssize(Entries.num()); idx++ )
{
Entry* entry;
FindResult find_result;
@ -456,14 +456,14 @@ struct HashTable
}
}
void remove_entry( sw idx )
void remove_entry( ssize idx )
{
Entries.remove_at( idx );
}
void set( u64 key, Type value )
{
sw idx;
ssize idx;
FindResult find_result;
if ( full() )
@ -494,23 +494,23 @@ struct HashTable
grow();
}
sw slot( u64 key )
ssize slot( u64 key )
{
for ( sw idx = 0; idx < sw(Hashes.num()); ++idx )
for ( ssize idx = 0; idx < ssize(Hashes.num()); ++idx )
if ( Hashes[ idx ] == key )
return idx;
return -1;
}
Array< sw> Hashes;
Array< ssize> Hashes;
Array< Entry> Entries;
protected:
sw add_entry( u64 key )
ssize add_entry( u64 key )
{
sw idx;
ssize idx;
Entry entry = { key, -1 };
idx = Entries.num();
@ -542,7 +542,7 @@ protected:
b32 full()
{
uw critical_load = uw( CriticalLoadScale * f32(Hashes.num()) );
usize critical_load = usize( CriticalLoadScale * f32(Hashes.num()) );
b32 result = Entries.num() > critical_load;
return result;
}

10
project/dependencies/debug.hpp
View File

@ -24,7 +24,7 @@
{ \
if ( ! ( cond ) ) \
{ \
assert_handler( #cond, __FILE__, zpl_cast( s64 ) __LINE__, msg, ##__VA_ARGS__ ); \
assert_handler( #cond, __FILE__, scast( s64, __LINE__ ), msg, ##__VA_ARGS__ ); \
GEN_DEBUG_TRAP(); \
} \
} while ( 0 )
@ -34,10 +34,6 @@
// NOTE: Things that shouldn't happen with a message!
#define GEN_PANIC( msg, ... ) GEN_ASSERT_MSG( 0, msg, ##__VA_ARGS__ )
void assert_handler( char const* condition, char const* file, s32 line, char const* msg, ... );
s32 assert_crash( char const* condition );
void process_exit( u32 code );
#if Build_Debug
#define GEN_FATAL( ... ) \
do \
@ -60,4 +56,8 @@ void process_exit( u32 code );
while (0)
#endif
void assert_handler( char const* condition, char const* file, s32 line, char const* msg, ... );
s32 assert_crash( char const* condition );
void process_exit( u32 code );
#pragma endregion Debug

103
project/dependencies/filesystem.cpp
View File

@ -7,10 +7,11 @@
#if defined( GEN_SYSTEM_WINDOWS ) || defined( GEN_SYSTEM_CYGWIN )
internal wchar_t* _alloc_utf8_to_ucs2( AllocatorInfo a, char const* text, sw* w_len_ )
internal
wchar_t* _alloc_utf8_to_ucs2( AllocatorInfo a, char const* text, ssize* w_len_ )
{
wchar_t* w_text = NULL;
sw len = 0, w_len = 0, w_len1 = 0;
ssize len = 0, w_len = 0, w_len1 = 0;
if ( text == NULL )
{
if ( w_len_ )
@ -24,7 +25,7 @@ internal wchar_t* _alloc_utf8_to_ucs2( AllocatorInfo a, char const* text, sw* w_
*w_len_ = w_len;
return NULL;
}
w_len = MultiByteToWideChar( CP_UTF8, MB_ERR_INVALID_CHARS, text, zpl_cast( int ) len, NULL, 0 );
w_len = MultiByteToWideChar( CP_UTF8, MB_ERR_INVALID_CHARS, text, scast( int, len), NULL, 0 );
if ( w_len == 0 )
{
if ( w_len_ )
@ -32,7 +33,7 @@ internal wchar_t* _alloc_utf8_to_ucs2( AllocatorInfo a, char const* text, sw* w_
return NULL;
}
w_text = alloc_array( a, wchar_t, w_len + 1 );
w_len1 = MultiByteToWideChar( CP_UTF8, MB_ERR_INVALID_CHARS, text, zpl_cast( int ) len, w_text, zpl_cast( int ) w_len );
w_len1 = MultiByteToWideChar( CP_UTF8, MB_ERR_INVALID_CHARS, text, scast( int, len), w_text, scast( int, w_len) );
if ( w_len1 == 0 )
{
free( a, w_text );
@ -46,7 +47,8 @@ internal wchar_t* _alloc_utf8_to_ucs2( AllocatorInfo a, char const* text, sw* w_
return w_text;
}
internal GEN_FILE_SEEK_PROC( _win32_file_seek )
internal
GEN_FILE_SEEK_PROC( _win32_file_seek )
{
LARGE_INTEGER li_offset;
li_offset.QuadPart = offset;
@ -60,12 +62,13 @@ internal GEN_FILE_SEEK_PROC( _win32_file_seek )
return true;
}
internal GEN_FILE_READ_AT_PROC( _win32_file_read )
internal
GEN_FILE_READ_AT_PROC( _win32_file_read )
{
// unused( stop_at_newline );
b32 result = false;
_win32_file_seek( fd, offset, ESeekWhence_BEGIN, NULL );
DWORD size_ = zpl_cast( DWORD )( size > GEN_I32_MAX ? GEN_I32_MAX : size );
DWORD size_ = scast( DWORD, ( size > GEN_I32_MAX ? GEN_I32_MAX : size ));
DWORD bytes_read_;
if ( ReadFile( fd.p, buffer, size_, &bytes_read_, NULL ) )
{
@ -77,9 +80,10 @@ internal GEN_FILE_READ_AT_PROC( _win32_file_read )
return result;
}
internal GEN_FILE_WRITE_AT_PROC( _win32_file_write )
internal
GEN_FILE_WRITE_AT_PROC( _win32_file_write )
{
DWORD size_ = zpl_cast( DWORD )( size > GEN_I32_MAX ? GEN_I32_MAX : size );
DWORD size_ = scast( DWORD, ( size > GEN_I32_MAX ? GEN_I32_MAX : size ));
DWORD bytes_written_;
_win32_file_seek( fd, offset, ESeekWhence_BEGIN, NULL );
if ( WriteFile( fd.p, buffer, size_, &bytes_written_, NULL ) )
@ -91,14 +95,16 @@ internal GEN_FILE_WRITE_AT_PROC( _win32_file_write )
return false;
}
internal GEN_FILE_CLOSE_PROC( _win32_file_close )
internal
GEN_FILE_CLOSE_PROC( _win32_file_close )
{
CloseHandle( fd.p );
}
FileOperations const default_file_operations = { _win32_file_read, _win32_file_write, _win32_file_seek, _win32_file_close };
neverinline GEN_FILE_OPEN_PROC( _win32_file_open )
neverinline
GEN_FILE_OPEN_PROC( _win32_file_open )
{
DWORD desired_access;
DWORD creation_disposition;
@ -176,7 +182,8 @@ neverinline GEN_FILE_OPEN_PROC( _win32_file_open )
#else // POSIX
# include <fcntl.h>
internal GEN_FILE_SEEK_PROC( _posix_file_seek )
internal
GEN_FILE_SEEK_PROC( _posix_file_seek )
{
# if defined( GEN_SYSTEM_OSX )
s64 res = lseek( fd.i, offset, whence );
@ -190,10 +197,11 @@ internal GEN_FILE_SEEK_PROC( _posix_file_seek )
return true;
}
internal GEN_FILE_READ_AT_PROC( _posix_file_read )
internal
GEN_FILE_READ_AT_PROC( _posix_file_read )
{
unused( stop_at_newline );
sw res = pread( fd.i, buffer, size, offset );
ssize res = pread( fd.i, buffer, size, offset );
if ( res < 0 )
return false;
if ( bytes_read )
@ -201,19 +209,20 @@ internal GEN_FILE_READ_AT_PROC( _posix_file_read )
return true;
}
internal GEN_FILE_WRITE_AT_PROC( _posix_file_write )
internal
GEN_FILE_WRITE_AT_PROC( _posix_file_write )
{
sw res;
ssize res;
s64 curr_offset = 0;
_posix_file_seek( fd, 0, ESeekWhence_CURRENT, &curr_offset );
if ( curr_offset == offset )
{
// NOTE: Writing to stdout et al. doesn't like pwrite for numerous reasons
res = write( zpl_cast( int ) fd.i, buffer, size );
res = write( scast( int, fd.i), buffer, size );
}
else
{
res = pwrite( zpl_cast( int ) fd.i, buffer, size, offset );
res = pwrite( scast( int, fd.i), buffer, size, offset );
}
if ( res < 0 )
return false;
@ -222,14 +231,16 @@ internal GEN_FILE_WRITE_AT_PROC( _posix_file_write )
return true;
}
internal GEN_FILE_CLOSE_PROC( _posix_file_close )
internal
GEN_FILE_CLOSE_PROC( _posix_file_close )
{
close( fd.i );
}
FileOperations const default_file_operations = { _posix_file_read, _posix_file_write, _posix_file_seek, _posix_file_close };
neverinline GEN_FILE_OPEN_PROC( _posix_file_open )
neverinline
GEN_FILE_OPEN_PROC( _posix_file_open )
{
s32 os_mode;
switch ( mode & GEN_FILE_MODES )
@ -329,7 +340,7 @@ FileError file_close( FileInfo* f )
return EFileError_INVALID;
if ( f->filename )
free( heap(), zpl_cast( char* ) f->filename );
free( heap(), ccast( char*, f->filename ));
#if defined( GEN_SYSTEM_WINDOWS )
if ( f->fd.p == INVALID_HANDLE_VALUE )
@ -364,14 +375,14 @@ FileError file_close( FileInfo* f )
FileError file_new( FileInfo* f, FileDescriptor fd, FileOperations ops, char const* filename )
{
FileError err = EFileError_NONE;
sw len = str_len( filename );
ssize len = str_len( filename );
f->ops = ops;
f->fd = fd;
f->dir = nullptr;
f->last_write_time = 0;
f->filename = alloc_array( heap(), char, len + 1 );
mem_copy( zpl_cast( char* ) f->filename, zpl_cast( char* ) filename, len + 1 );
mem_copy( ccast( char*, f->filename), ccast( char*, filename), len + 1 );
return err;
}
@ -430,7 +441,7 @@ FileContents file_read_contents( AllocatorInfo a, b32 zero_terminate, char const
if ( file_open( &file, filepath ) == EFileError_NONE )
{
sw fsize = zpl_cast( sw ) file_size( &file );
ssize fsize = scast( ssize , file_size( &file ));
if ( fsize > 0 )
{
result.data = alloc( a, zero_terminate ? fsize + 1 : fsize );
@ -438,7 +449,7 @@ FileContents file_read_contents( AllocatorInfo a, b32 zero_terminate, char const
file_read_at( &file, result.data, result.size, 0 );
if ( zero_terminate )
{
u8* str = zpl_cast( u8* ) result.data;
u8* str = rcast( u8*, result.data);
str[ fsize ] = '\0';
}
}
@ -452,26 +463,28 @@ struct _memory_fd
{
u8 magic;
u8* buf; //< zpl_array OR plain buffer if we can't write
sw cursor;
ssize cursor;
AllocatorInfo allocator;
FileStreamFlags flags;
sw cap;
ssize cap;
};
#define GEN__FILE_STREAM_FD_MAGIC 37
GEN_DEF_INLINE FileDescriptor _file_stream_fd_make( _memory_fd* d );
GEN_DEF_INLINE _memory_fd* _file_stream_from_fd( FileDescriptor fd );
FileDescriptor _file_stream_fd_make( _memory_fd* d );
_memory_fd* _file_stream_from_fd( FileDescriptor fd );
GEN_IMPL_INLINE FileDescriptor _file_stream_fd_make( _memory_fd* d )
inline
FileDescriptor _file_stream_fd_make( _memory_fd* d )
{
FileDescriptor fd = { 0 };
fd.p = ( void* )d;
return fd;
}
GEN_IMPL_INLINE _memory_fd* _file_stream_from_fd( FileDescriptor fd )
inline
_memory_fd* _file_stream_from_fd( FileDescriptor fd )
{
_memory_fd* d = ( _memory_fd* )fd.p;
GEN_ASSERT( d->magic == GEN__FILE_STREAM_FD_MAGIC );
@ -506,7 +519,7 @@ b8 file_stream_new( FileInfo* file, AllocatorInfo allocator )
return true;
}
b8 file_stream_open( FileInfo* file, AllocatorInfo allocator, u8* buffer, sw size, FileStreamFlags flags )
b8 file_stream_open( FileInfo* file, AllocatorInfo allocator, u8* buffer, ssize size, FileStreamFlags flags )
{
GEN_ASSERT_NOT_NULL( file );
_memory_fd* d = ( _memory_fd* )alloc( allocator, size_of( _memory_fd ) );
@ -543,7 +556,7 @@ b8 file_stream_open( FileInfo* file, AllocatorInfo allocator, u8* buffer, sw siz
return true;
}
u8* file_stream_buf( FileInfo* file, sw* size )
u8* file_stream_buf( FileInfo* file, ssize* size )
{
GEN_ASSERT_NOT_NULL( file );
_memory_fd* d = _file_stream_from_fd( file->fd );
@ -552,10 +565,11 @@ u8* file_stream_buf( FileInfo* file, sw* size )
return d->buf;
}
internal GEN_FILE_SEEK_PROC( _memory_file_seek )
internal
GEN_FILE_SEEK_PROC( _memory_file_seek )
{
_memory_fd* d = _file_stream_from_fd( fd );
sw buflen = d->cap;
ssize buflen = d->cap;
if ( whence == ESeekWhence_BEGIN )
d->cursor = 0;
@ -568,7 +582,8 @@ internal GEN_FILE_SEEK_PROC( _memory_file_seek )
return true;
}
internal GEN_FILE_READ_AT_PROC( _memory_file_read )
internal
GEN_FILE_READ_AT_PROC( _memory_file_read )
{
// unused( stop_at_newline );
_memory_fd* d = _file_stream_from_fd( fd );
@ -578,23 +593,24 @@ internal GEN_FILE_READ_AT_PROC( _memory_file_read )
return true;
}
internal GEN_FILE_WRITE_AT_PROC( _memory_file_write )
internal
GEN_FILE_WRITE_AT_PROC( _memory_file_write )
{
_memory_fd* d = _file_stream_from_fd( fd );
if ( ! ( d->flags & ( EFileStream_CLONE_WRITABLE | EFileStream_WRITABLE ) ) )
return false;
sw buflen = d->cap;
sw extralen = max( 0, size - ( buflen - offset ) );
sw rwlen = size - extralen;
sw new_cap = buflen + extralen;
ssize buflen = d->cap;
ssize extralen = max( 0, size - ( buflen - offset ) );
ssize rwlen = size - extralen;
ssize new_cap = buflen + extralen;
if ( d->flags & EFileStream_CLONE_WRITABLE )
{
Array<u8> arr = { d->buf };
if ( arr.get_header()->Capacity < uw(new_cap) )
if ( arr.get_header()->Capacity < usize(new_cap) )
{
if ( ! arr.grow( ( s64 )( new_cap ) ) )
return false;
@ -622,7 +638,8 @@ internal GEN_FILE_WRITE_AT_PROC( _memory_file_write )
return true;
}
internal GEN_FILE_CLOSE_PROC( _memory_file_close )
internal
GEN_FILE_CLOSE_PROC( _memory_file_close )
{
_memory_fd* d = _file_stream_from_fd( fd );
AllocatorInfo allocator = d->allocator;

195
project/dependencies/filesystem.hpp
View File

@ -48,8 +48,8 @@ union FileDescriptor
typedef struct FileOperations FileOperations;
#define GEN_FILE_OPEN_PROC( name ) FileError name( FileDescriptor* fd, FileOperations* ops, FileMode mode, char const* filename )
#define GEN_FILE_READ_AT_PROC( name ) b32 name( FileDescriptor fd, void* buffer, sw size, s64 offset, sw* bytes_read, b32 stop_at_newline )
#define GEN_FILE_WRITE_AT_PROC( name ) b32 name( FileDescriptor fd, void const* buffer, sw size, s64 offset, sw* bytes_written )
#define GEN_FILE_READ_AT_PROC( name ) b32 name( FileDescriptor fd, void* buffer, ssize size, s64 offset, ssize* bytes_read, b32 stop_at_newline )
#define GEN_FILE_WRITE_AT_PROC( name ) b32 name( FileDescriptor fd, void const* buffer, ssize size, s64 offset, ssize* bytes_written )
#define GEN_FILE_SEEK_PROC( name ) b32 name( FileDescriptor fd, s64 offset, SeekWhenceType whence, s64* new_offset )
#define GEN_FILE_CLOSE_PROC( name ) void name( FileDescriptor fd )
@ -161,7 +161,7 @@ FileError file_open_mode( FileInfo* file, FileMode mode, char const* filename );
* @param buffer Buffer to read to
* @param size Size to read
*/
GEN_DEF_INLINE b32 file_read( FileInfo* file, void* buffer, sw size );
b32 file_read( FileInfo* file, void* buffer, ssize size );
/**
* Reads file at a specific offset
@ -171,7 +171,7 @@ GEN_DEF_INLINE b32 file_read( FileInfo* file, void* buffer, sw size );
* @param offset Offset to read from
* @param bytes_read How much data we've actually read
*/
GEN_DEF_INLINE b32 file_read_at( FileInfo* file, void* buffer, sw size, s64 offset );
b32 file_read_at( FileInfo* file, void* buffer, ssize size, s64 offset );
/**
* Reads file safely
@ -181,13 +181,13 @@ GEN_DEF_INLINE b32 file_read_at( FileInfo* file, void* buffer, sw size, s64 offs
* @param offset Offset to read from
* @param bytes_read How much data we've actually read
*/
GEN_DEF_INLINE b32 file_read_at_check( FileInfo* file, void* buffer, sw size, s64 offset, sw* bytes_read );
b32 file_read_at_check( FileInfo* file, void* buffer, ssize size, s64 offset, ssize* bytes_read );
struct FileContents
{
AllocatorInfo allocator;
void* data;
sw size;
ssize size;
};
constexpr b32 zero_terminate = true;
@ -214,20 +214,20 @@ s64 file_size( FileInfo* file );
* @param file
* @param offset Offset to seek to
*/
GEN_DEF_INLINE s64 file_seek( FileInfo* file, s64 offset );
s64 file_seek( FileInfo* file, s64 offset );
/**
* Seeks the file cursor to the end of the file
* @param file
*/
GEN_DEF_INLINE s64 file_seek_to_end( FileInfo* file );
s64 file_seek_to_end( FileInfo* file );
/**
* Returns the length from the beginning of the file we've read so far
* @param file
* @return Our current position in file
*/
GEN_DEF_INLINE s64 file_tell( FileInfo* file );
s64 file_tell( FileInfo* file );
/**
* Writes to a file
@ -235,7 +235,7 @@ GEN_DEF_INLINE s64 file_tell( FileInfo* file );
* @param buffer Buffer to read from
* @param size Size to read
*/
GEN_DEF_INLINE b32 file_write( FileInfo* file, void const* buffer, sw size );
b32 file_write( FileInfo* file, void const* buffer, ssize size );
/**
* Writes to file at a specific offset
@ -245,7 +245,7 @@ GEN_DEF_INLINE b32 file_write( FileInfo* file, void const* buffer, sw size );
* @param offset Offset to write to
* @param bytes_written How much data we've actually written
*/
GEN_DEF_INLINE b32 file_write_at( FileInfo* file, void const* buffer, sw size, s64 offset );
b32 file_write_at( FileInfo* file, void const* buffer, ssize size, s64 offset );
/**
* Writes to file safely
@ -255,86 +255,7 @@ GEN_DEF_INLINE b32 file_write_at( FileInfo* file, void const* buffer, sw size, s
* @param offset Offset to write to
* @param bytes_written How much data we've actually written
*/
GEN_DEF_INLINE b32 file_write_at_check( FileInfo* file, void const* buffer, sw size, s64 offset, sw* bytes_written );
GEN_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;
}
GEN_IMPL_INLINE s64 file_seek_to_end( FileInfo* f )
{
s64 new_offset = 0;
if ( ! f->ops.read_at )
f->ops = default_file_operations;
f->ops.seek( f->fd, 0, ESeekWhence_END, &new_offset );
return new_offset;
}
GEN_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;
}
GEN_IMPL_INLINE b32 file_read( FileInfo* f, void* buffer, sw size )
{
s64 cur_offset = file_tell( f );
b32 result = file_read_at( f, buffer, size, file_tell( f ) );
file_seek( f, cur_offset + size );
return result;
}
GEN_IMPL_INLINE b32 file_read_at( FileInfo* f, void* buffer, sw size, s64 offset )
{
return file_read_at_check( f, buffer, size, offset, NULL );
}
GEN_IMPL_INLINE b32 file_read_at_check( FileInfo* f, void* buffer, sw size, s64 offset, sw* bytes_read )
{
if ( ! f->ops.read_at )
f->ops = default_file_operations;
return f->ops.read_at( f->fd, buffer, size, offset, bytes_read, false );
}
GEN_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;
}
GEN_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 );
}
GEN_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 );
}
b32 file_write_at_check( FileInfo* file, void const* buffer, ssize size, s64 offset, ssize* bytes_written );
enum FileStreamFlags : u32
{
@ -361,15 +282,103 @@ b8 file_stream_new( FileInfo* file, AllocatorInfo allocator );
* @param size Buffer's size
* @param flags
*/
b8 file_stream_open( FileInfo* file, AllocatorInfo allocator, u8* buffer, sw size, FileStreamFlags flags );
b8 file_stream_open( FileInfo* file, AllocatorInfo allocator, u8* buffer, ssize size, FileStreamFlags flags );
/**
* Retrieves the stream's underlying buffer and buffer size.
* @param file memory stream
* @param size (Optional) buffer size
*/
u8* file_stream_buf( FileInfo* file, sw* size );
u8* file_stream_buf( FileInfo* file, ssize* size );
extern FileOperations const memory_file_operations;
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;
}
inline
s64 file_seek_to_end( FileInfo* f )
{
s64 new_offset = 0;
if ( ! f->ops.read_at )
f->ops = default_file_operations;
f->ops.seek( f->fd, 0, ESeekWhence_END, &new_offset );
return new_offset;
}
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;
}
inline
b32 file_read( FileInfo* f, void* buffer, ssize size )
{
s64 cur_offset = file_tell( f );
b32 result = file_read_at( f, buffer, size, file_tell( f ) );
file_seek( f, cur_offset + size );
return result;
}
inline
b32 file_read_at( FileInfo* f, void* buffer, ssize size, s64 offset )
{
return file_read_at_check( f, buffer, size, offset, NULL );
}
inline
b32 file_read_at_check( FileInfo* f, void* buffer, ssize size, s64 offset, ssize* bytes_read )
{
if ( ! f->ops.read_at )
f->ops = default_file_operations;
return f->ops.read_at( f->fd, buffer, size, offset, bytes_read, false );
}
inline
b32 file_write( FileInfo* f, void const* buffer, ssize 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;
}
inline
b32 file_write_at( FileInfo* f, void const* buffer, ssize size, s64 offset )
{
return file_write_at_check( f, buffer, size, offset, NULL );
}
inline
b32 file_write_at_check( FileInfo* f, void const* buffer, ssize size, s64 offset, ssize* bytes_written )
{
if ( ! f->ops.read_at )
f->ops = default_file_operations;
return f->ops.write_at( f->fd, buffer, size, offset, bytes_written );
}
#pragma endregion File Handling

16
project/dependencies/hashing.cpp
View File

@ -27,11 +27,11 @@ global u32 const _crc32_table[ 256 ] = {
0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d,
};
u32 crc32( void const* data, sw len )
u32 crc32( void const* data, ssize len )
{
sw remaining;
u32 result = ~( zpl_cast( u32 ) 0 );
u8 const* c = zpl_cast( u8 const* ) data;
ssize remaining;
u32 result = ~( scast( u32, 0) );
u8 const* c = rcast( u8 const*, data);
for ( remaining = len; remaining--; c++ )
result = ( result >> 8 ) ^ ( _crc32_table[ ( result ^ *c ) & 0xff ] );
return ~result;
@ -77,11 +77,11 @@ global u64 const _crc64_table[ 256 ] = {
0xa6df411fbfb21ca3ull, 0xdc0731d78f8795daull, 0x536fa08fdfd90e51ull, 0x29b7d047efec8728ull,
};
u64 crc64( void const* data, sw len )
u64 crc64( void const* data, ssize len )
{
sw remaining;
u64 result = ( zpl_cast( u64 ) 0 );
u8 const* c = zpl_cast( u8 const* ) data;
ssize remaining;
u64 result = ( scast( u64, 0) );
u8 const* c = rcast( u8 const*, data);
for ( remaining = len; remaining--; c++ )
result = ( result >> 8 ) ^ ( _crc64_table[ ( result ^ *c ) & 0xff ] );
return result;

4
project/dependencies/hashing.hpp
View File

@ -5,7 +5,7 @@
#pragma region Hashing
u32 crc32( void const* data, sw len );
u64 crc64( void const* data, sw len );
u32 crc32( void const* data, ssize len );
u64 crc64( void const* data, ssize len );
#pragma endregion Hashing

211
project/dependencies/macros.hpp
View File

@ -1,58 +1,77 @@
#ifdef GEN_INTELLISENSE_DIRECTIVES
# pragma once
# include "header_start.hpp"
# pragma once
#endif
#pragma region Macros
#define zpl_cast( Type ) ( Type )
// Keywords
#ifndef global
#define global static // Global variables
#endif
#ifndef internal
#define internal static // Internal linkage
#endif
#ifndef local_persist
#define local_persist static // Local Persisting variables
#pragma region ForceInline Definition
#ifdef GEN_COMPILER_MSVC
# define forceinline __forceinline
# define neverinline __declspec( noinline )
#elif defined(GEN_COMPILER_GCC)
# define forceinline inline __attribute__((__always_inline__))
# define neverinline __attribute__( ( __noinline__ ) )
#elif defined(GEN_COMPILER_CLANG)
#if __has_attribute(__always_inline__)
# define forceinline inline __attribute__((__always_inline__))
# define neverinline __attribute__( ( __noinline__ ) )
#else
# define forceinline
# define neverinline
#endif
#else
# define forceinline
# define neverinline
#endif
#pragma endregion ForceInline Definition
// Bits
#ifndef api_c
#define api_c extern "C"
#endif
#ifndef bit
#define bit( Value ) ( 1 << Value )
#define bitfield_is_equal( Type, Field, Mask ) ( (Type(Mask) & Type(Field)) == Type(Mask) )
#endif
// Casting
#ifndef ccast
#define ccast( Type, Value ) ( * const_cast< Type* >( & (Value) ) )
#define pcast( Type, Value ) ( * reinterpret_cast< Type* >( & ( Value ) ) )
#define rcast( Type, Value ) reinterpret_cast< Type >( Value )
#define scast( Type, Value ) static_cast< Type >( Value )
#define ccast( type, value ) ( const_cast< type >( (value) ) )
#endif
#ifndef pcast
#define pcast( type, value ) ( * reinterpret_cast< type* >( & ( value ) ) )
#endif
#ifndef rcast
#define rcast( type, value ) reinterpret_cast< type >( value )
#endif
#ifndef scast
#define scast( type, value ) static_cast< type >( value )
#endif
// Num Arguments (Varadics)
// #if defined(__GNUC__) || defined(__clang__)
// Supports 0-50 arguments
#ifndef stringize
#define stringize_va( ... ) #__VA_ARGS__
#define stringize( ... ) stringize_va( __VA_ARGS__ )
#endif
#ifndef do_once
#define do_once( statement ) for ( local_persist b32 once = true; once; once = false, (statement) )
#define do_once_start \
do \
{ \
local_persist \
bool done = false; \
if ( done ) \
break; \
done = true;
#define do_once_end \
} \
while(0);
#endif
#ifndef labeled_scope_start
#define labeled_scope_start if ( false ) {
#define labeled_scope_end }
#endif
#ifndef compiler_decorated_func_name
# ifdef COMPILER_CLANG
# define compiler_decorated_func_name __PRETTY_NAME__
# elif defined(COMPILER_MSVC)
# define compiler_decorated_func_name __FUNCDNAME__
# endif
#endif
#ifndef num_args_impl
#define num_args_impl( _0, \
_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
_11, _12, _13, _14, _15, _16, _17, _18, _19, _20, \
@ -67,7 +86,7 @@
N, ... \
) N
// ## deletes preceding comma if _VA_ARGS__ is empty (GCC, Clang)
// ## deletes preceding comma if _VA_ARGS__ is empty (GCC, Clang)
#define num_args(...) \
num_args_impl(_, ## __VA_ARGS__, \
100, 99, 98, 97, 96, 95, 94, 93, 92, 91, \
@ -82,93 +101,53 @@
10, 9, 8, 7, 6, 5, 4, 3, 2, 1, \
0 \
)
#endif
// #else
// This doesn't work on latest msvc so I had to use /Zc:preprocessor flag.
// Supports 1-50 arguments
// #define num_args_impl( \
// _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
// _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, \
// _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, \
// _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, \
// _61, _62, _63, _64, _65, _66, _67, _68, _69, _70, \
// _71, _72, _73, _74, _75, _76, _77, _78, _79, _80, \
// _81, _82, _83, _84, _85, _86, _87, _88, _89, _90, \
// _91, _92, _93, _94, _95, _96, _97, _98, _99, _100, \
// N, ... \
// ) N
// #define num_args(...) \
// num_args_impl( __VA_ARGS__, \
// 100, 99, 98, 97, 96, 95, 94, 93, 92, 91, \
// 90, 89, 88, 87, 86, 85, 84, 83, 82, 81, \
// 80, 79, 78, 77, 76, 75, 74, 73, 72, 71, \
// 70, 69, 68, 67, 66, 65, 64, 63, 62, 61, \
// 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, \
// 50, 49, 48, 47, 46, 45, 44, 43, 42, 41, \
// 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, \
// 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, \
// 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 \
// )
// #endif
// Stringizing
#define stringize_va( ... ) #__VA_ARGS__
#define stringize( ... ) stringize_va( __VA_ARGS__ )
// Function do once
#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);
#define labeled_scope_start if ( false ) {
#define labeled_scope_end }
#ifndef clamp
#define clamp( x, lower, upper ) min( max( ( x ), ( lower ) ), ( upper ) )
#define count_of( x ) ( ( size_of( x ) / size_of( 0 [ x ] ) ) / ( ( sw )( ! ( size_of( x ) % size_of( 0 [ x ] ) ) ) ) )
#endif
#ifndef count_of
#define count_of( x ) ( ( size_of( x ) / size_of( 0 [ x ] ) ) / ( ( ssize )( ! ( size_of( x ) % size_of( 0 [ x ] ) ) ) ) )
#endif
#ifndef is_between
#define is_between( x, lower, upper ) ( ( ( lower ) <= ( x ) ) && ( ( x ) <= ( upper ) ) )
#define max( a, b ) ( ( a ) > ( b ) ? ( a ) : ( b ) )
#define min( a, b ) ( ( a ) < ( b ) ? ( a ) : ( b ) )
#define size_of( x ) ( sw )( sizeof( x ) )
#endif
#ifndef size_of
#define size_of( x ) ( ssize )( sizeof( x ) )
#endif
#ifndef max
#define max( a, b ) ( (a > b) ? (a) : (b) )
#endif
#ifndef min
#define min( a, b ) ( (a < b) ? (a) : (b) )
#endif
#if defined( _MSC_VER ) || defined( GEN_COMPILER_TINYC )
# define offset_of( Type, element ) ( ( GEN_NS( gen_sw ) ) & ( ( ( Type* )0 )->element ) )
# define offset_of( Type, element ) ( ( GEN_NS( ssize ) ) & ( ( ( Type* )0 )->element ) )
#else
# define offset_of( Type, element ) __builtin_offsetof( Type, element )
#endif
template< class Type >
void swap( Type& a, Type& b )
{
Type tmp = a;
a = b;
b = tmp;
}
#ifndef forceinline
# ifdef GEN_COMPILER_MSVC
# define forceinline __forceinline
# define neverinline __declspec( noinline )
# elif defined(GEN_COMPILER_GCC)
# define forceinline inline __attribute__((__always_inline__))
# define neverinline __attribute__( ( __noinline__ ) )
# elif defined(GEN_COMPILER_CLANG)
# if __has_attribute(__always_inline__)
# define forceinline inline __attribute__((__always_inline__))
# define neverinline __attribute__( ( __noinline__ ) )
# else
# define forceinline
# define neverinline
# endif
# else
# define forceinline
# define neverinline
# endif
#endif
#pragma endregion Macros

100
project/dependencies/memory.cpp
View File

@ -5,7 +5,7 @@
#pragma region Memory
void* mem_copy( void* dest, void const* source, sw n )
void* mem_copy( void* dest, void const* source, ssize n )
{
if ( dest == NULL )
{
@ -15,25 +15,25 @@ void* mem_copy( void* dest, void const* source, sw n )
return memcpy( dest, source, n );
}
void const* mem_find( void const* data, u8 c, sw n )
void const* mem_find( void const* data, u8 c, ssize n )
{
u8 const* s = zpl_cast( u8 const* ) data;
while ( ( zpl_cast( uptr ) s & ( sizeof( uw ) - 1 ) ) && n && *s != c )
u8 const* s = rcast( u8 const*, data);
while ( ( rcast( uptr, s) & ( sizeof( usize ) - 1 ) ) && n && *s != c )
{
s++;
n--;
}
if ( n && *s != c )
{
sw const* w;
sw k = GEN__ONES * c;
w = zpl_cast( sw const* ) s;
while ( n >= size_of( sw ) && ! GEN__HAS_ZERO( *w ^ k ) )
ssize const* w;
ssize k = GEN__ONES * c;
w = rcast( ssize const*, s);
while ( n >= size_of( ssize ) && ! GEN__HAS_ZERO( *w ^ k ) )
{
w++;
n -= size_of( sw );
n -= size_of( ssize );
}
s = zpl_cast( u8 const* ) w;
s = rcast( u8 const*, w);
while ( n && *s != c )
{
s++;
@ -41,7 +41,7 @@ void const* mem_find( void const* data, u8 c, sw n )
}
}
return n ? zpl_cast( void const* ) s : NULL;
return n ? rcast( void const*, s ) : NULL;
}
#define GEN_HEAP_STATS_MAGIC 0xDEADC0DE
@ -49,8 +49,8 @@ void const* mem_find( void const* data, u8 c, sw n )
struct _heap_stats
{
u32 magic;
sw used_memory;
sw alloc_count;
ssize used_memory;
ssize alloc_count;
};
global _heap_stats _heap_stats_info;
@ -61,13 +61,13 @@ void heap_stats_init( void )
_heap_stats_info.magic = GEN_HEAP_STATS_MAGIC;
}
sw heap_stats_used_memory( void )
ssize heap_stats_used_memory( void )
{
GEN_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.used_memory;
}
sw heap_stats_alloc_count( void )
ssize heap_stats_alloc_count( void )
{
GEN_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;
@ -82,11 +82,11 @@ void heap_stats_check( void )
struct _heap_alloc_info
{
sw size;
ssize size;
void* physical_start;
};
void* heap_allocator_proc( void* allocator_data, AllocType type, sw size, sw alignment, void* old_memory, sw old_size, u64 flags )
void* heap_allocator_proc( void* allocator_data, AllocType type, ssize size, ssize alignment, void* old_memory, ssize old_size, u64 flags )
{
void* ptr = NULL;
// unused( allocator_data );
@ -95,16 +95,16 @@ void* heap_allocator_proc( void* allocator_data, AllocType type, sw size, sw ali
alignment = GEN_DEFAULT_MEMORY_ALIGNMENT;
#ifdef GEN_HEAP_ANALYSIS
sw alloc_info_size = size_of( _heap_alloc_info );
sw alloc_info_remainder = ( alloc_info_size % alignment );
sw track_size = max( alloc_info_size, alignment ) + alloc_info_remainder;
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;
switch ( type )
{
case EAllocation_FREE :
{
if ( ! old_memory )
break;
_heap_alloc_info* alloc_info = zpl_cast( _heap_alloc_info* ) old_memory - 1;
_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;
@ -195,11 +195,11 @@ void* heap_allocator_proc( void* allocator_data, AllocType type, sw size, sw ali
#ifdef GEN_HEAP_ANALYSIS
if ( type == EAllocation_ALLOC )
{
_heap_alloc_info* alloc_info = zpl_cast( _heap_alloc_info* )( zpl_cast( char* ) ptr + alloc_info_remainder );
_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 = zpl_cast( void* )( alloc_info + 1 );
ptr = rcast( void*, alloc_info + 1 );
_heap_stats_info.used_memory += alloc_info->size;
_heap_stats_info.alloc_count++;
}
@ -209,7 +209,7 @@ void* heap_allocator_proc( void* allocator_data, AllocType type, sw size, sw ali
}
#pragma region VirtualMemory
VirtualMemory vm_from_memory( void* data, sw size )
VirtualMemory vm_from_memory( void* data, ssize size )
{
VirtualMemory vm;
vm.data = data;
@ -218,7 +218,7 @@ VirtualMemory vm_from_memory( void* data, sw size )
}
#if defined( GEN_SYSTEM_WINDOWS )
VirtualMemory vm_alloc( void* addr, sw size )
VirtualMemory vm_alloc( void* addr, ssize size )
{
VirtualMemory vm;
GEN_ASSERT( size > 0 );
@ -234,7 +234,7 @@ b32 vm_free( VirtualMemory vm )
{
if ( VirtualQuery( vm.data, &info, size_of( info ) ) == 0 )
return false;
if ( info.BaseAddress != vm.data || info.AllocationBase != vm.data || info.State != MEM_COMMIT || info.RegionSize > zpl_cast( uw ) vm.size )
if ( info.BaseAddress != vm.data || info.AllocationBase != vm.data || info.State != MEM_COMMIT || info.RegionSize > scast( usize, vm.size) )
{
return false;
}
@ -246,7 +246,7 @@ b32 vm_free( VirtualMemory vm )
return true;
}
VirtualMemory vm_trim( VirtualMemory vm, sw lead_size, sw size )
VirtualMemory vm_trim( VirtualMemory vm, ssize lead_size, ssize size )
{
VirtualMemory new_vm = { 0 };
void* ptr;
@ -270,7 +270,7 @@ b32 vm_purge( VirtualMemory vm )
return true;
}
sw virtual_memory_page_size( sw* alignment_out )
ssize virtual_memory_page_size( ssize* alignment_out )
{
SYSTEM_INFO info;
GetSystemInfo( &info );
@ -285,7 +285,7 @@ sw virtual_memory_page_size( sw* alignment_out )
# ifndef MAP_ANONYMOUS
# define MAP_ANONYMOUS MAP_ANON
# endif
VirtualMemory vm_alloc( void* addr, sw size )
VirtualMemory vm_alloc( void* addr, ssize size )
{
VirtualMemory vm;
GEN_ASSERT( size > 0 );
@ -300,10 +300,10 @@ b32 vm_free( VirtualMemory vm )
return true;
}
VirtualMemory vm_trim( VirtualMemory vm, sw lead_size, sw size )
VirtualMemory vm_trim( VirtualMemory vm, ssize lead_size, ssize size )
{
void* ptr;
sw trail_size;
ssize trail_size;
GEN_ASSERT( vm.size >= lead_size + size );
ptr = pointer_add( vm.data, lead_size );
@ -322,10 +322,10 @@ b32 vm_purge( VirtualMemory vm )
return err != 0;
}
sw virtual_memory_page_size( sw* alignment_out )
ssize virtual_memory_page_size( ssize* alignment_out )
{
// TODO: Is this always true?
sw result = zpl_cast( sw ) sysconf( _SC_PAGE_SIZE );
ssize result = scast( ssize, sysconf( _SC_PAGE_SIZE ));
if ( alignment_out )
*alignment_out = result;
return result;
@ -334,7 +334,7 @@ sw virtual_memory_page_size( sw* alignment_out )
#pragma endregion VirtualMemory
void* Arena::allocator_proc( void* allocator_data, AllocType type, sw size, sw alignment, void* old_memory, sw old_size, u64 flags )
void* Arena::allocator_proc( void* allocator_data, AllocType type, ssize size, ssize alignment, void* old_memory, ssize old_size, u64 flags )
{
Arena* arena = rcast(Arena*, allocator_data);
void* ptr = NULL;
@ -346,10 +346,10 @@ void* Arena::allocator_proc( void* allocator_data, AllocType type, sw size, sw a
case EAllocation_ALLOC :
{
void* end = pointer_add( arena->PhysicalStart, arena->TotalUsed );
sw total_size = align_forward_i64( size, alignment );
ssize total_size = align_forward_i64( size, alignment );
// NOTE: Out of memory
if ( arena->TotalUsed + total_size > (sw) arena->TotalSize )
if ( arena->TotalUsed + total_size > (ssize) arena->TotalSize )
{
// zpl__printf_err("%s", "Arena out of memory\n");
GEN_FATAL("Arena out of memory! (Possibly could not fit for the largest size Arena!!)");
@ -384,9 +384,9 @@ void* Arena::allocator_proc( void* allocator_data, AllocType type, sw size, sw a
return ptr;
}
void* Pool::allocator_proc( void* allocator_data, AllocType type, sw size, sw alignment, void* old_memory, sw old_size, u64 flags )
void* Pool::allocator_proc( void* allocator_data, AllocType type, ssize size, ssize alignment, void* old_memory, ssize old_size, u64 flags )
{
Pool* pool = zpl_cast( Pool* ) allocator_data;
Pool* pool = rcast( Pool*, allocator_data);
void* ptr = NULL;
// unused( old_size );
@ -401,9 +401,9 @@ void* Pool::allocator_proc( void* allocator_data, AllocType type, sw size, sw al
GEN_ASSERT( alignment == pool->BlockAlign );
GEN_ASSERT( pool->FreeList != NULL );
next_free = *zpl_cast( uptr* ) pool->FreeList;
next_free = * rcast( uptr*, pool->FreeList);
ptr = pool->FreeList;
pool->FreeList = zpl_cast( void* ) next_free;
pool->FreeList = rcast( void*, next_free);
pool->TotalSize += pool->BlockSize;
if ( flags & ALLOCATOR_FLAG_CLEAR_TO_ZERO )
@ -417,8 +417,8 @@ void* Pool::allocator_proc( void* allocator_data, AllocType type, sw size, sw al
if ( old_memory == NULL )
return NULL;
next = zpl_cast( uptr* ) old_memory;
*next = zpl_cast( uptr ) pool->FreeList;
next = rcast( uptr*, old_memory);
*next = rcast( uptr, pool->FreeList);
pool->FreeList = old_memory;
pool->TotalSize -= pool->BlockSize;
}
@ -426,7 +426,7 @@ void* Pool::allocator_proc( void* allocator_data, AllocType type, sw size, sw al
case EAllocation_FREE_ALL :
{
sw actual_block_size, block_index;
ssize actual_block_size, block_index;
void* curr;
uptr* end;
@ -437,13 +437,13 @@ void* Pool::allocator_proc( void* allocator_data, AllocType type, sw size, sw al
curr = pool->PhysicalStart;
for ( block_index = 0; block_index < pool->NumBlocks - 1; block_index++ )
{
uptr* next = zpl_cast( uptr* ) curr;
*next = zpl_cast( uptr ) curr + actual_block_size;
uptr* next = rcast( uptr*, curr);
* next = rcast( uptr, curr) + actual_block_size;
curr = pointer_add( curr, actual_block_size );
}
end = zpl_cast( uptr* ) curr;
*end = zpl_cast( uptr ) NULL;
end = rcast( uptr*, curr);
* end = scast( uptr, NULL);
pool->FreeList = pool->PhysicalStart;
}
break;
@ -457,11 +457,11 @@ void* Pool::allocator_proc( void* allocator_data, AllocType type, sw size, sw al
return ptr;
}
Pool Pool::init_align( AllocatorInfo backing, sw num_blocks, sw block_size, sw block_align )
Pool Pool::init_align( AllocatorInfo backing, ssize num_blocks, ssize block_size, ssize block_align )
{
Pool pool = {};
sw actual_block_size, pool_size, block_index;
ssize actual_block_size, pool_size, block_index;
void *data, *curr;
uptr* end;
@ -497,7 +497,7 @@ Pool Pool::init_align( AllocatorInfo backing, sw num_blocks, sw block_size, sw b
void Pool::clear()
{
sw actual_block_size, block_index;
ssize actual_block_size, block_index;
void* curr;
uptr* end;

574
project/dependencies/memory.hpp
View File

@ -10,43 +10,51 @@
#define gigabytes( x ) ( megabytes( x ) * ( s64 )( 1024 ) )
#define terabytes( x ) ( gigabytes( x ) * ( s64 )( 1024 ) )
#define GEN__ONES ( zpl_cast( uw ) - 1 / GEN_U8_MAX )
#define GEN__ONES ( scast( GEN_NS usize, - 1) / GEN_U8_MAX )
#define GEN__HIGHS ( GEN__ONES * ( GEN_U8_MAX / 2 + 1 ) )
#define GEN__HAS_ZERO( x ) ( ( ( x )-GEN__ONES ) & ~( x )&GEN__HIGHS )
#define GEN__HAS_ZERO( x ) ( ( ( x ) - GEN__ONES ) & ~( x ) & GEN__HIGHS )
template< class Type >
void swap( Type& a, Type& b )
{
Type tmp = a;
a = b;
b = tmp;
}
//! Checks if value is power of 2.
GEN_DEF_INLINE b32 is_power_of_two( sw x );
b32 is_power_of_two( ssize x );
//! Aligns address to specified alignment.
GEN_DEF_INLINE void* align_forward( void* ptr, sw alignment );
void* align_forward( void* ptr, ssize alignment );
//! Aligns value to a specified alignment.
GEN_DEF_INLINE s64 align_forward_i64( s64 value, sw alignment );
s64 align_forward_i64( s64 value, ssize alignment );
//! Moves pointer forward by bytes.
GEN_DEF_INLINE void* pointer_add( void* ptr, sw bytes );
void* pointer_add( void* ptr, ssize bytes );
//! Moves pointer forward by bytes.
GEN_DEF_INLINE void const* pointer_add_const( void const* ptr, sw bytes );
void const* pointer_add_const( void const* ptr, ssize bytes );
//! Calculates difference between two addresses.
GEN_DEF_INLINE sw pointer_diff( void const* begin, void const* end );
ssize pointer_diff( void const* begin, void const* end );
//! Copy non-overlapping memory from source to destination.
void* mem_copy( void* dest, void const* source, sw size );
void* mem_copy( void* dest, void const* source, ssize size );
//! Search for a constant value within the size limit at memory location.
void const* mem_find( void const* data, u8 byte_value, sw size );
void const* mem_find( void const* data, u8 byte_value, ssize size );
//! Copy memory from source to destination.
GEN_DEF_INLINE void* mem_move( void* dest, void const* source, sw size );
void* mem_move( void* dest, void const* source, ssize size );
//! Set constant value at memory location with specified size.
GEN_DEF_INLINE void* mem_set( void* data, u8 byte_value, sw size );
void* mem_set( void* data, u8 byte_value, ssize size );
//! @param ptr Memory location to clear up.
//! @param size The size to clear up with.
GEN_DEF_INLINE void zero_size( void* ptr, sw size );
void zero_size( void* ptr, ssize size );
//! Clears up an item.
#define zero_item( t ) zero_size( ( t ), size_of( *( t ) ) ) // NOTE: Pass pointer of struct
@ -63,8 +71,8 @@ enum AllocType : u8
};
using AllocatorProc = void* ( void* allocator_data, AllocType type
, sw size, sw alignment
, void* old_memory, sw old_size
, ssize size, ssize alignment
, void* old_memory, ssize old_size
, u64 flags );
struct AllocatorInfo
@ -87,22 +95,22 @@ enum AllocFlag
#endif
//! Allocate memory with default alignment.
GEN_DEF_INLINE void* alloc( AllocatorInfo a, sw size );
void* alloc( AllocatorInfo a, ssize size );
//! Allocate memory with specified alignment.
GEN_DEF_INLINE void* alloc_align( AllocatorInfo a, sw size, sw alignment );
void* alloc_align( AllocatorInfo a, ssize size, ssize alignment );
//! Free allocated memory.
GEN_DEF_INLINE void free( AllocatorInfo a, void* ptr );
void free( AllocatorInfo a, void* ptr );
//! Free all memory allocated by an allocator.
GEN_DEF_INLINE void free_all( AllocatorInfo a );
void free_all( AllocatorInfo a );
//! Resize an allocated memory.
GEN_DEF_INLINE void* resize( AllocatorInfo a, void* ptr, sw old_size, sw new_size );
void* resize( AllocatorInfo a, void* ptr, ssize old_size, ssize new_size );
//! Resize an allocated memory with specified alignment.
GEN_DEF_INLINE void* resize_align( AllocatorInfo a, void* ptr, sw old_size, sw new_size, sw alignment );
void* resize_align( AllocatorInfo a, void* ptr, ssize old_size, ssize new_size, ssize alignment );
//! Allocate memory for an item.
#define alloc_item( allocator_, Type ) ( Type* )alloc( allocator_, size_of( Type ) )
@ -114,17 +122,17 @@ GEN_DEF_INLINE void* resize_align( AllocatorInfo a, void* ptr, sw old_size, sw n
/* 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 */
void heap_stats_init( void );
sw heap_stats_used_memory( void );
sw heap_stats_alloc_count( void );
void heap_stats_check( void );
void heap_stats_init( void );
ssize heap_stats_used_memory( void );
ssize 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
GEN_DEF_INLINE void* default_resize_align( AllocatorInfo a, void* ptr, sw old_size, sw new_size, sw alignment );
void* default_resize_align( AllocatorInfo a, void* ptr, ssize old_size, ssize new_size, ssize alignment );
void* heap_allocator_proc( void* allocator_data, AllocType type, sw size, sw alignment, void* old_memory, sw old_size, u64 flags );
void* heap_allocator_proc( void* allocator_data, AllocType type, ssize size, ssize alignment, void* old_memory, ssize old_size, u64 flags );
//! The heap allocator backed by operating system's memory manager.
constexpr AllocatorInfo heap( void ) { return { heap_allocator_proc, nullptr }; }
@ -135,270 +143,40 @@ constexpr AllocatorInfo heap( void ) { return { heap_allocator_proc, nullptr };
//! Helper to free memory allocated by heap allocator.
#define mfree( ptr ) free( heap(), ptr )
GEN_IMPL_INLINE b32 is_power_of_two( sw x )
{
if ( x <= 0 )
return false;
return ! ( x & ( x - 1 ) );
}
GEN_IMPL_INLINE void* align_forward( void* ptr, sw alignment )
{
uptr p;
GEN_ASSERT( is_power_of_two( alignment ) );
p = zpl_cast( uptr ) ptr;
return zpl_cast( void* )( ( p + ( alignment - 1 ) ) & ~( alignment - 1 ) );
}
GEN_IMPL_INLINE s64 align_forward_i64( s64 value, sw alignment )
{
return value + ( alignment - value % alignment ) % alignment;
}
GEN_IMPL_INLINE void* pointer_add( void* ptr, sw bytes )
{
return zpl_cast( void* )( zpl_cast( u8* ) ptr + bytes );
}
GEN_IMPL_INLINE void const* pointer_add_const( void const* ptr, sw bytes )
{
return zpl_cast( void const* )( zpl_cast( u8 const* ) ptr + bytes );
}
GEN_IMPL_INLINE sw pointer_diff( void const* begin, void const* end )
{
return zpl_cast( sw )( zpl_cast( u8 const* ) end - zpl_cast( u8 const* ) begin );
}
GEN_IMPL_INLINE void* mem_move( void* dest, void const* source, sw n )
{
if ( dest == NULL )
{
return NULL;
}
u8* d = zpl_cast( u8* ) dest;
u8 const* s = zpl_cast( u8 const* ) source;
if ( d == s )
return d;
if ( s + n <= d || d + n <= s ) // NOTE: Non-overlapping
return mem_copy( d, s, n );
if ( d < s )
{
if ( zpl_cast( uptr ) s % size_of( sw ) == zpl_cast( uptr ) d % size_of( sw ) )
{
while ( zpl_cast( uptr ) d % size_of( sw ) )
{
if ( ! n-- )
return dest;
*d++ = *s++;
}
while ( n >= size_of( sw ) )
{
*zpl_cast( sw* ) d = *zpl_cast( sw* ) s;
n -= size_of( sw );
d += size_of( sw );
s += size_of( sw );
}
}
for ( ; n; n-- )
*d++ = *s++;
}
else
{
if ( ( zpl_cast( uptr ) s % size_of( sw ) ) == ( zpl_cast( uptr ) d % size_of( sw ) ) )
{
while ( zpl_cast( uptr )( d + n ) % size_of( sw ) )
{
if ( ! n-- )
return dest;
d[ n ] = s[ n ];
}
while ( n >= size_of( sw ) )
{
n -= size_of( sw );
*zpl_cast( sw* )( d + n ) = *zpl_cast( sw* )( s + n );
}
}
while ( n )
n--, d[ n ] = s[ n ];
}
return dest;
}
GEN_IMPL_INLINE void* mem_set( void* dest, u8 c, sw n )
{
if ( dest == NULL )
{
return NULL;
}
u8* s = zpl_cast( u8* ) dest;
sw k;
u32 c32 = ( ( u32 )-1 ) / 255 * c;
if ( n == 0 )
return dest;
s[ 0 ] = s[ n - 1 ] = c;
if ( n < 3 )
return dest;
s[ 1 ] = s[ n - 2 ] = c;
s[ 2 ] = s[ n - 3 ] = c;
if ( n < 7 )
return dest;
s[ 3 ] = s[ n - 4 ] = c;
if ( n < 9 )
return dest;
k = -zpl_cast( sptr ) s & 3;
s += k;
n -= k;
n &= -4;
*zpl_cast( u32* )( s + 0 ) = c32;
*zpl_cast( u32* )( s + n - 4 ) = c32;
if ( n < 9 )
return dest;
*zpl_cast( u32* )( s + 4 ) = c32;
*zpl_cast( u32* )( s + 8 ) = c32;
*zpl_cast( u32* )( s + n - 12 ) = c32;
*zpl_cast( u32* )( s + n - 8 ) = c32;
if ( n < 25 )
return dest;
*zpl_cast( u32* )( s + 12 ) = c32;
*zpl_cast( u32* )( s + 16 ) = c32;
*zpl_cast( u32* )( s + 20 ) = c32;
*zpl_cast( u32* )( s + 24 ) = c32;
*zpl_cast( u32* )( s + n - 28 ) = c32;
*zpl_cast( u32* )( s + n - 24 ) = c32;
*zpl_cast( u32* )( s + n - 20 ) = c32;
*zpl_cast( u32* )( s + n - 16 ) = c32;
k = 24 + ( zpl_cast( uptr ) s & 4 );
s += k;
n -= k;
{
u64 c64 = ( zpl_cast( u64 ) c32 << 32 ) | c32;
while ( n > 31 )
{
*zpl_cast( u64* )( s + 0 ) = c64;
*zpl_cast( u64* )( s + 8 ) = c64;
*zpl_cast( u64* )( s + 16 ) = c64;
*zpl_cast( u64* )( s + 24 ) = c64;
n -= 32;
s += 32;
}
}
return dest;
}
GEN_IMPL_INLINE void* alloc_align( AllocatorInfo a, sw size, sw alignment )
{
return a.Proc( a.Data, EAllocation_ALLOC, size, alignment, nullptr, 0, GEN_DEFAULT_ALLOCATOR_FLAGS );
}
GEN_IMPL_INLINE void* alloc( AllocatorInfo a, sw size )
{
return alloc_align( a, size, GEN_DEFAULT_MEMORY_ALIGNMENT );
}
GEN_IMPL_INLINE void free( AllocatorInfo a, void* ptr )
{
if ( ptr != nullptr )
a.Proc( a.Data, EAllocation_FREE, 0, 0, ptr, 0, GEN_DEFAULT_ALLOCATOR_FLAGS );
}
GEN_IMPL_INLINE void free_all( AllocatorInfo a )
{
a.Proc( a.Data, EAllocation_FREE_ALL, 0, 0, nullptr, 0, GEN_DEFAULT_ALLOCATOR_FLAGS );
}
GEN_IMPL_INLINE void* resize( AllocatorInfo a, void* ptr, sw old_size, sw new_size )
{
return resize_align( a, ptr, old_size, new_size, GEN_DEFAULT_MEMORY_ALIGNMENT );
}
GEN_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, GEN_DEFAULT_ALLOCATOR_FLAGS );
}
GEN_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;
}
}
GEN_IMPL_INLINE void zero_size( void* ptr, sw size )
{
mem_set( ptr, 0, size );
}
struct VirtualMemory
{
void* data;
sw size;
ssize size;
};
//! Initialize virtual memory from existing data.
VirtualMemory vm_from_memory( void* data, sw size );
VirtualMemory vm_from_memory( void* data, ssize size );
//! Allocate virtual memory at address with size.
//! @param addr The starting address of the region to reserve. If NULL, it lets operating system to decide where to allocate it.
//! @param size The size to serve.
VirtualMemory vm_alloc( void* addr, sw size );
VirtualMemory vm_alloc( void* addr, ssize size );
//! Release the virtual memory.
b32 vm_free( VirtualMemory vm );
//! Trim virtual memory.
VirtualMemory vm_trim( VirtualMemory vm, sw lead_size, sw size );
VirtualMemory vm_trim( VirtualMemory vm, ssize lead_size, ssize size );
//! Purge virtual memory.
b32 gen_vm_purge( VirtualMemory vm );
//! Retrieve VM's page size and alignment.
sw gen_virtual_memory_page_size( sw* alignment_out );
ssize gen_virtual_memory_page_size( ssize* alignment_out );
struct Arena
{
static
void* allocator_proc( void* allocator_data, AllocType type, sw size, sw alignment, void* old_memory, sw old_size, u64 flags );
void* allocator_proc( void* allocator_data, AllocType type, ssize size, ssize alignment, void* old_memory, ssize old_size, u64 flags );
static
Arena init_from_memory( void* start, sw size )
Arena init_from_memory( void* start, ssize size )
{
return
{
@ -411,7 +189,7 @@ struct Arena
}
static
Arena init_from_allocator( AllocatorInfo backing, sw size )
Arena init_from_allocator( AllocatorInfo backing, ssize size )
{
Arena result =
{
@ -425,18 +203,18 @@ struct Arena
}
static
Arena init_sub( Arena& parent, sw size )
Arena init_sub( Arena& parent, ssize size )
{
return init_from_allocator( parent.Backing, size );
}
sw alignment_of( sw alignment )
ssize alignment_of( ssize alignment )
{
sw alignment_offset, result_pointer, mask;
ssize alignment_offset, result_pointer, mask;
GEN_ASSERT( is_power_of_two( alignment ) );
alignment_offset = 0;
result_pointer = (sw) PhysicalStart + TotalUsed;
result_pointer = (ssize) PhysicalStart + TotalUsed;
mask = alignment - 1;
if ( result_pointer & mask )
@ -463,17 +241,17 @@ struct Arena
}
}
sw size_remaining( sw alignment )
ssize size_remaining( ssize alignment )
{
sw result = TotalSize - ( TotalUsed + alignment_of( alignment ) );
ssize result = TotalSize - ( TotalUsed + alignment_of( alignment ) );
return result;
}
AllocatorInfo Backing;
void* PhysicalStart;
sw TotalSize;
sw TotalUsed;
sw TempCount;
ssize TotalSize;
ssize TotalUsed;
ssize TempCount;
operator AllocatorInfo()
{
@ -493,7 +271,7 @@ struct FixedArena
return result;
}
sw size_remaining( sw alignment )
ssize size_remaining( ssize alignment )
{
return arena.size_remaining( alignment );
}
@ -523,16 +301,16 @@ using Arena_4MB = FixedArena< megabytes( 4 ) >;
struct Pool
{
static
void* allocator_proc( void* allocator_data, AllocType type, sw size, sw alignment, void* old_memory, sw old_size, u64 flags );
void* allocator_proc( void* allocator_data, AllocType type, ssize size, ssize alignment, void* old_memory, ssize old_size, u64 flags );
static
Pool init( AllocatorInfo backing, sw num_blocks, sw block_size )
Pool init( AllocatorInfo backing, ssize num_blocks, ssize block_size )
{
return init_align( backing, num_blocks, block_size, GEN_DEFAULT_MEMORY_ALIGNMENT );
}
static
Pool init_align( AllocatorInfo backing, sw num_blocks, sw block_size, sw block_align );
Pool init_align( AllocatorInfo backing, ssize num_blocks, ssize block_size, ssize block_align );
void clear();
@ -547,10 +325,10 @@ struct Pool
AllocatorInfo Backing;
void* PhysicalStart;
void* FreeList;
sw BlockSize;
sw BlockAlign;
sw TotalSize;
sw NumBlocks;
ssize BlockSize;
ssize BlockAlign;
ssize TotalSize;
ssize NumBlocks;
operator AllocatorInfo()
{
@ -558,4 +336,236 @@ struct Pool
}
};
inline
b32 is_power_of_two( ssize x ) {
if ( x <= 0 )
return false;
return ! ( x & ( x - 1 ) );
}
inline
mem_ptr align_forward( void* ptr, ssize alignment )
{
GEN_ASSERT( is_power_of_two( alignment ) );
uptr p = to_uptr(ptr);
uptr forward = (p + ( alignment - 1 ) ) & ~( alignment - 1 );
return to_mem_ptr(forward);
}
inline s64 align_forward_i64( s64 value, ssize alignment ) { return value + ( alignment - value % alignment ) % alignment; }
inline void* pointer_add ( void* ptr, ssize bytes ) { return rcast(void*, rcast( u8*, ptr) + bytes ); }
inline void const* pointer_add_const( void const* ptr, ssize bytes ) { return rcast(void const*, rcast( u8 const*, ptr) + bytes ); }
inline sptr pointer_diff( mem_ptr_const begin, mem_ptr_const end ) {
return scast( ssize, rcast( u8 const*, end) - rcast(u8 const*, begin) );
}
inline
void* mem_move( void* destination, void const* source, ssize byte_count )
{
if ( destination == NULL )
{
return NULL;
}
u8* dest_ptr = rcast( u8*, destination);
u8 const* src_ptr = rcast( u8 const*, source);
if ( dest_ptr == src_ptr )
return dest_ptr;
if ( src_ptr + byte_count <= dest_ptr || dest_ptr + byte_count <= src_ptr ) // NOTE: Non-overlapping
return mem_copy( dest_ptr, src_ptr, byte_count );
if ( dest_ptr < src_ptr )
{
if ( to_uptr(src_ptr) % size_of( ssize ) == to_uptr(dest_ptr) % size_of( ssize ) )
{
while ( pcast( uptr, dest_ptr) % size_of( ssize ) )
{
if ( ! byte_count-- )
return destination;
*dest_ptr++ = *src_ptr++;
}
while ( byte_count >= size_of( 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 );
}
}
for ( ; byte_count; byte_count-- )
*dest_ptr++ = *src_ptr++;
}
else
{
if ( ( to_uptr(src_ptr) % size_of( ssize ) ) == ( to_uptr(dest_ptr) % size_of( ssize ) ) )
{
while ( to_uptr( dest_ptr + byte_count ) % size_of( ssize ) )
{
if ( ! byte_count-- )
return destination;
dest_ptr[ byte_count ] = src_ptr[ byte_count ];
}
while ( byte_count >= size_of( ssize ) )
{
byte_count -= size_of( ssize );
* rcast(ssize*, dest_ptr + byte_count ) = * rcast( ssize const*, src_ptr + byte_count );
}
}
while ( byte_count )
byte_count--, dest_ptr[ byte_count ] = src_ptr[ byte_count ];
}
return destination;
}
inline
void* mem_set( void* destination, u8 fill_byte, 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;
if ( byte_count == 0 )
return destination;
dest_ptr[ 0 ] = dest_ptr[ byte_count - 1 ] = fill_byte;
if ( byte_count < 3 )
return destination;
dest_ptr[ 1 ] = dest_ptr[ byte_count - 2 ] = fill_byte;
dest_ptr[ 2 ] = dest_ptr[ byte_count - 3 ] = fill_byte;
if ( byte_count < 7 )
return destination;
dest_ptr[ 3 ] = dest_ptr[ byte_count - 4 ] = fill_byte;
if ( byte_count < 9 )
return destination;
align_offset = -to_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;
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;
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;
align_offset = 24 + to_uptr( dest_ptr ) & 4;
dest_ptr += align_offset;
byte_count -= align_offset;
{
u64 fill_doubleword = ( scast( 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;
byte_count -= 32;
dest_ptr += 32;
}
}
return destination;
}
inline
void* alloc_align( AllocatorInfo a, ssize size, ssize alignment ) {
return a.Proc( a.Data, EAllocation_ALLOC, size, alignment, nullptr, 0, GEN_DEFAULT_ALLOCATOR_FLAGS );
}
inline
void* alloc( AllocatorInfo a, ssize size ) {
return alloc_align( a, size, GEN_DEFAULT_MEMORY_ALIGNMENT );
}
inline
void free( AllocatorInfo a, void* ptr ) {
if ( ptr != nullptr )
a.Proc( a.Data, EAllocation_FREE, 0, 0, ptr, 0, GEN_DEFAULT_ALLOCATOR_FLAGS );
}
inline
void free_all( AllocatorInfo a ) {
a.Proc( a.Data, EAllocation_FREE_ALL, 0, 0, nullptr, 0, GEN_DEFAULT_ALLOCATOR_FLAGS );
}
inline
void* resize( AllocatorInfo a, void* ptr, ssize old_size, ssize new_size ) {
return resize_align( a, ptr, old_size, new_size, GEN_DEFAULT_MEMORY_ALIGNMENT );
}
inline
void* resize_align( AllocatorInfo a, void* ptr, ssize old_size, ssize new_size, ssize alignment ) {
return a.Proc( a.Data, EAllocation_RESIZE, new_size, alignment, ptr, old_size, GEN_DEFAULT_ALLOCATOR_FLAGS );
}
inline
void* default_resize_align( AllocatorInfo a, void* old_memory, ssize old_size, ssize new_size, ssize 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;
}
}
inline
void zero_size( void* ptr, ssize size ) {
mem_set( ptr, 0, size );
}
#pragma endregion Memory

65
project/dependencies/parsing.cpp
View File

@ -36,7 +36,7 @@ u8 adt_destroy_branch( ADT_Node* node )
GEN_ASSERT_NOT_NULL( node );
if ( ( node->type == EADT_TYPE_OBJECT || node->type == EADT_TYPE_ARRAY ) && node->nodes )
{
for ( sw i = 0; i < scast(sw, node->nodes.num()); ++i )
for ( ssize i = 0; i < scast(ssize, node->nodes.num()); ++i )
{
adt_destroy_branch( node->nodes + i );
}
@ -66,7 +66,7 @@ ADT_Node* adt_find( ADT_Node* node, char const* name, b32 deep_search )
return NULL;
}
for ( sw i = 0; i < scast(sw, node->nodes.num()); i++ )
for ( ssize i = 0; i < scast(ssize, node->nodes.num()); i++ )
{
if ( ! str_compare( node->nodes[ i ].name, name ) )
{
@ -76,7 +76,7 @@ ADT_Node* adt_find( ADT_Node* node, char const* name, b32 deep_search )
if ( deep_search )
{
for ( sw i = 0; i < scast(sw, node->nodes.num()); i++ )
for ( ssize i = 0; i < scast(ssize, node->nodes.num()); i++ )
{
ADT_Node* res = adt_find( node->nodes + i, name, deep_search );
@ -111,7 +111,7 @@ internal ADT_Node* _adt_get_value( ADT_Node* node, char const* value )
file_stream_open( &tmp, heap(), ( u8* )back, size_of( back ), EFileStream_WRITABLE );
adt_print_number( &tmp, node );
sw fsize = 0;
ssize fsize = 0;
u8* buf = file_stream_buf( &tmp, &fsize );
if ( ! str_compare( ( char const* )buf, value ) )
@ -132,7 +132,7 @@ internal ADT_Node* _adt_get_value( ADT_Node* node, char const* value )
internal ADT_Node* _adt_get_field( ADT_Node* node, char* name, char* value )
{
for ( sw i = 0; i < scast(sw, node->nodes.num()); i++ )
for ( ssize i = 0; i < scast(ssize, node->nodes.num()); i++ )
{
if ( ! str_compare( node->nodes[ i ].name, name ) )
{
@ -207,7 +207,7 @@ ADT_Node* adt_query( ADT_Node* node, char const* uri )
/* run a value comparison against any child that is an object node */
else if ( node->type == EADT_TYPE_ARRAY )
{
for ( sw i = 0; i < scast(sw, node->nodes.num()); i++ )
for ( ssize i = 0; i < scast(ssize, node->nodes.num()); i++ )
{
ADT_Node* child = &node->nodes[ i ];
if ( child->type != EADT_TYPE_OBJECT )
@ -225,7 +225,7 @@ ADT_Node* adt_query( ADT_Node* node, char const* uri )
/* [value] */
else
{
for ( sw i = 0; i < scast(sw, node->nodes.num()); i++ )
for ( ssize i = 0; i < scast(ssize, node->nodes.num()); i++ )
{
ADT_Node* child = &node->nodes[ i ];
if ( _adt_get_value( child, l_b2 ) )
@ -256,8 +256,8 @@ ADT_Node* adt_query( ADT_Node* node, char const* uri )
/* handle array index lookup */
else
{
sw idx = ( sw )str_to_i64( buf, NULL, 10 );
if ( idx >= 0 && idx < scast(sw, node->nodes.num()) )
ssize idx = ( ssize )str_to_i64( buf, NULL, 10 );
if ( idx >= 0 && idx < scast(ssize, node->nodes.num()) )
{
found_node = &node->nodes[ idx ];
@ -272,7 +272,7 @@ ADT_Node* adt_query( ADT_Node* node, char const* uri )
return found_node;
}
ADT_Node* adt_alloc_at( ADT_Node* parent, sw index )
ADT_Node* adt_alloc_at( ADT_Node* parent, ssize index )
{
if ( ! parent || ( parent->type != EADT_TYPE_OBJECT && parent->type != EADT_TYPE_ARRAY ) )
{
@ -282,7 +282,7 @@ ADT_Node* adt_alloc_at( ADT_Node* parent, sw index )
if ( ! parent->nodes )
return NULL;
if ( index < 0 || index > scast(sw, parent->nodes.num()) )
if ( index < 0 || index > scast(ssize, parent->nodes.num()) )
return NULL;
ADT_Node o = { 0 };
@ -337,7 +337,7 @@ b8 adt_set_int( ADT_Node* obj, char const* name, s64 value )
return true;
}
ADT_Node* adt_move_node_at( ADT_Node* node, ADT_Node* new_parent, sw index )
ADT_Node* adt_move_node_at( ADT_Node* node, ADT_Node* new_parent, ssize index )
{
GEN_ASSERT_NOT_NULL( node );
GEN_ASSERT_NOT_NULL( new_parent );
@ -366,8 +366,8 @@ void adt_swap_nodes( ADT_Node* node, ADT_Node* other_node )
GEN_ASSERT_NOT_NULL( other_node );
ADT_Node* parent = node->parent;
ADT_Node* other_parent = other_node->parent;
sw index = ( pointer_diff( parent->nodes, node ) / size_of( ADT_Node ) );
sw index2 = ( pointer_diff( other_parent->nodes, other_node ) / size_of( ADT_Node ) );
ssize index = ( pointer_diff( parent->nodes, node ) / size_of( ADT_Node ) );
ssize index2 = ( pointer_diff( other_parent->nodes, other_node ) / size_of( ADT_Node ) );
ADT_Node temp = parent->nodes[ index ];
temp.parent = other_parent;
other_parent->nodes[ index2 ].parent = parent;
@ -380,7 +380,7 @@ void adt_remove_node( ADT_Node* node )
GEN_ASSERT_NOT_NULL( node );
GEN_ASSERT_NOT_NULL( node->parent );
ADT_Node* parent = node->parent;
sw index = ( pointer_diff( parent->nodes, node ) / size_of( ADT_Node ) );
ssize index = ( pointer_diff( parent->nodes, node ) / size_of( ADT_Node ) );
parent->nodes.remove_at( index );
}
@ -484,7 +484,7 @@ char* adt_parse_number( ADT_Node* node, char* base_str )
node_type = EADT_TYPE_INTEGER;
neg_zero = false;
sw ib = 0;
ssize ib = 0;
char buf[ 48 ] = { 0 };
if ( *e == '+' )
@ -550,7 +550,7 @@ char* adt_parse_number( ADT_Node* node, char* base_str )
f32 eb = 10;
char expbuf[ 6 ] = { 0 };
sw expi = 0;
ssize expi = 0;
if ( *e && ! ! str_find( "eE", *e ) )
{
@ -595,7 +595,7 @@ char* adt_parse_number( ADT_Node* node, char* base_str )
#ifndef GEN_PARSER_DISABLE_ANALYSIS
char *q = buf, *base_string = q, *base_string2 = q;
base_string = zpl_cast( char* ) str_skip( base_string, '.' );
base_string = ccast( char*, str_skip( base_string, '.' ));
*base_string = '\0';
base_string2 = base_string + 1;
char* base_string_off = base_string2;
@ -816,13 +816,13 @@ u8 csv_parse_delimiter( CSV_Object* root, char* text, AllocatorInfo allocator, b
char* beginChar;
char* endChar;
sw columnIndex = 0;
sw totalColumnIndex = 0;
ssize columnIndex = 0;
ssize totalColumnIndex = 0;
do
{
char delimiter = 0;
currentChar = zpl_cast( char* ) str_trim( currentChar, false );
currentChar = ccast( char*, str_trim( currentChar, false ));
if ( *currentChar == 0 )
break;
@ -846,7 +846,7 @@ u8 csv_parse_delimiter( CSV_Object* root, char* text, AllocatorInfo allocator, b
#endif
do
{
endChar = zpl_cast( char* ) str_skip( endChar, '"' );
endChar = ccast( char*, str_skip( endChar, '"' ));
if ( *endChar && *( endChar + 1 ) == '"' )
{
@ -865,7 +865,7 @@ u8 csv_parse_delimiter( CSV_Object* root, char* text, AllocatorInfo allocator, b
}
*endChar = 0;
currentChar = zpl_cast( char* ) str_trim( endChar + 1, true );
currentChar = ccast( char*, str_trim( endChar + 1, true ));
delimiter = * currentChar;
/* unescape escaped quotes (so that unescaped text escapes :) */
@ -902,7 +902,7 @@ u8 csv_parse_delimiter( CSV_Object* root, char* text, AllocatorInfo allocator, b
if ( * endChar )
{
currentChar = zpl_cast( char* ) str_trim( endChar, true );
currentChar = ccast( char*, str_trim( endChar, true ));
while ( char_is_space( *( endChar - 1 ) ) )
{
@ -946,7 +946,7 @@ u8 csv_parse_delimiter( CSV_Object* root, char* text, AllocatorInfo allocator, b
}
}
if ( columnIndex >= scast(sw, root->nodes.num()) )
if ( columnIndex >= scast(ssize, root->nodes.num()) )
{
adt_append_arr( root, NULL );
}
@ -989,7 +989,7 @@ u8 csv_parse_delimiter( CSV_Object* root, char* text, AllocatorInfo allocator, b
/* consider first row as a header. */
if ( has_header )
{
for ( sw i = 0; i < scast(sw, root->nodes.num()); i++ )
for ( ssize i = 0; i < scast(ssize, root->nodes.num()); i++ )
{
CSV_Object* col = root->nodes + i;
CSV_Object* hdr = col->nodes;
@ -1057,11 +1057,11 @@ void csv_write_delimiter( FileInfo* file, CSV_Object* obj, char delimiter )
GEN_ASSERT_NOT_NULL( file );
GEN_ASSERT_NOT_NULL( obj );
GEN_ASSERT( obj->nodes );
sw cols = obj->nodes.num();
ssize cols = obj->nodes.num();
if ( cols == 0 )
return;
sw rows = obj->nodes[ 0 ].nodes.num();
ssize rows = obj->nodes[ 0 ].nodes.num();
if ( rows == 0 )
return;
@ -1069,7 +1069,7 @@ void csv_write_delimiter( FileInfo* file, CSV_Object* obj, char delimiter )
if ( has_headers )
{
for ( sw i = 0; i < cols; i++ )
for ( ssize i = 0; i < cols; i++ )
{
_csv_write_header( file, &obj->nodes[ i ] );
if ( i + 1 != cols )
@ -1080,9 +1080,9 @@ void csv_write_delimiter( FileInfo* file, CSV_Object* obj, char delimiter )
str_fmt_file( file, "\n" );
}
for ( sw r = 0; r < rows; r++ )
for ( ssize r = 0; r < rows; r++ )
{
for ( sw i = 0; i < cols; i++ )
for ( ssize i = 0; i < cols; i++ )
{
_csv_write_record( file, &obj->nodes[ i ].nodes[ r ] );
if ( i + 1 != cols )
@ -1099,7 +1099,8 @@ String csv_write_string_delimiter( AllocatorInfo a, CSV_Object* obj, char delimi
FileInfo tmp;
file_stream_new( &tmp, a );
csv_write_delimiter( &tmp, obj, delimiter );
sw fsize;
ssize fsize;
u8* buf = file_stream_buf( &tmp, &fsize );
String output = String::make_length( a, ( char* )buf, fsize );
file_close( &tmp );

28
project/dependencies/parsing.hpp
View File

@ -178,7 +178,7 @@ ADT_Node* adt_find( ADT_Node* node, char const* name, b32 deep_search );
* @param index
* @return zpl_adt_node * node
*/
ADT_Node* adt_alloc_at( ADT_Node* parent, sw index );
ADT_Node* adt_alloc_at( ADT_Node* parent, ssize index );
/**
* @brief Allocate an unitialised node within a container.
@ -196,7 +196,7 @@ ADT_Node* adt_alloc( ADT_Node* parent );
* @param index
* @return zpl_adt_node * node
*/
ADT_Node* adt_move_node_at( ADT_Node* node, ADT_Node* new_parent, sw index );
ADT_Node* adt_move_node_at( ADT_Node* node, ADT_Node* new_parent, ssize index );
/**
* @brief Move an existing node to a new container.
@ -400,31 +400,33 @@ enum CSV_Error : u32
typedef ADT_Node CSV_Object;
GEN_DEF_INLINE u8 csv_parse( CSV_Object* root, char* text, AllocatorInfo allocator, b32 has_header );
u8 csv_parse_delimiter( CSV_Object* root, char* text, AllocatorInfo allocator, b32 has_header, char delim );
void csv_free( CSV_Object* obj );
u8 csv_parse( CSV_Object* root, char* text, AllocatorInfo allocator, b32 has_header );
u8 csv_parse_delimiter( CSV_Object* root, char* text, AllocatorInfo allocator, b32 has_header, char delim );
void csv_free( CSV_Object* obj );
GEN_DEF_INLINE void csv_write( FileInfo* file, CSV_Object* obj );
GEN_DEF_INLINE String csv_write_string( AllocatorInfo a, CSV_Object* obj );
void csv_write_delimiter( FileInfo* file, CSV_Object* obj, char delim );
String csv_write_string_delimiter( AllocatorInfo a, CSV_Object* obj, char delim );
void csv_write( FileInfo* file, CSV_Object* obj );
String csv_write_string( AllocatorInfo a, CSV_Object* obj );
void csv_write_delimiter( FileInfo* file, CSV_Object* obj, char delim );
String csv_write_string_delimiter( AllocatorInfo a, CSV_Object* obj, char delim );
/* inline */
GEN_IMPL_INLINE u8 csv_parse( CSV_Object* root, char* text, AllocatorInfo allocator, b32 has_header )
inline
u8 csv_parse( CSV_Object* root, char* text, AllocatorInfo allocator, b32 has_header )
{
return csv_parse_delimiter( root, text, allocator, has_header, ',' );
}
GEN_IMPL_INLINE void csv_write( FileInfo* file, CSV_Object* obj )
inline
void csv_write( FileInfo* file, CSV_Object* obj )
{
csv_write_delimiter( file, obj, ',' );
}
GEN_IMPL_INLINE String csv_write_string( AllocatorInfo a, CSV_Object* obj )
inline
String csv_write_string( AllocatorInfo a, CSV_Object* obj )
{
return csv_write_string_delimiter( a, obj, ',' );
}
#pragma endregion CSV

7
project/dependencies/header_start.hpp → project/dependencies/platform.hpp
View File

@ -1,4 +1,6 @@
#pragma once
#ifdef GEN_INTELLISENSE_DIRECTIVES
# pragma once
#endif
#pragma region Platform Detection
@ -99,9 +101,6 @@
# define GEN_GCC_VERSION_CHECK(major,minor,patch) (0)
#endif
#define GEN_DEF_INLINE static
#define GEN_IMPL_INLINE static inline
#pragma endregion Platform Detection
#pragma region Mandatory Includes

92
project/dependencies/printing.cpp
View File

@ -41,10 +41,10 @@ struct _format_info
s32 precision;
};
internal sw _print_string( char* text, sw max_len, _format_info* info, char const* str )
internal ssize _print_string( char* text, ssize max_len, _format_info* info, char const* str )
{
sw res = 0, len = 0;
sw remaining = max_len;
ssize res = 0, len = 0;
ssize remaining = max_len;
char* begin = text;
if ( str == NULL && max_len >= 6 )
@ -75,7 +75,7 @@ internal sw _print_string( char* text, sw max_len, _format_info* info, char cons
if ( info->width > res )
{
sw padding = info->width - len;
ssize padding = info->width - len;
char pad = ( info->flags & GEN_FMT_ZERO ) ? '0' : ' ';
while ( padding-- > 0 && remaining-- > 0 )
@ -86,7 +86,7 @@ internal sw _print_string( char* text, sw max_len, _format_info* info, char cons
{
if ( info && ( info->width > res ) )
{
sw padding = info->width - len;
ssize padding = info->width - len;
char pad = ( info->flags & GEN_FMT_ZERO ) ? '0' : ' ';
while ( padding-- > 0 && remaining-- > 0 )
*text++ = pad, res++;
@ -108,16 +108,16 @@ internal sw _print_string( char* text, sw max_len, _format_info* info, char cons
return res;
}
internal sw _print_char( char* text, sw max_len, _format_info* info, char arg )
internal ssize _print_char( char* text, ssize max_len, _format_info* info, char arg )
{
char str[ 2 ] = "";
str[ 0 ] = arg;
return _print_string( text, max_len, info, str );
}
internal sw _print_repeated_char( char* text, sw max_len, _format_info* info, char arg )
internal ssize _print_repeated_char( char* text, ssize max_len, _format_info* info, char arg )
{
sw res = 0;
ssize res = 0;
s32 rem = ( info ) ? ( info->width > 0 ) ? info->width : 1 : 1;
res = rem;
while ( rem-- > 0 )
@ -126,24 +126,24 @@ internal sw _print_repeated_char( char* text, sw max_len, _format_info* info, ch
return res;
}
internal sw _print_i64( char* text, sw max_len, _format_info* info, s64 value )
internal ssize _print_i64( char* text, ssize max_len, _format_info* info, s64 value )
{
char num[ 130 ];
i64_to_str( value, num, info ? info->base : 10 );
return _print_string( text, max_len, info, num );
}
internal sw _print_u64( char* text, sw max_len, _format_info* info, u64 value )
internal ssize _print_u64( char* text, ssize max_len, _format_info* info, u64 value )
{
char num[ 130 ];
u64_to_str( value, num, info ? info->base : 10 );
return _print_string( text, max_len, info, num );
}
internal sw _print_f64( char* text, sw max_len, _format_info* info, b32 is_hexadecimal, f64 arg )
internal ssize _print_f64( char* text, ssize max_len, _format_info* info, b32 is_hexadecimal, f64 arg )
{
// TODO: Handle exponent notation
sw width, len, remaining = max_len;
ssize width, len, remaining = max_len;
char* text_begin = text;
if ( arg )
@ -163,7 +163,7 @@ internal sw _print_f64( char* text, sw max_len, _format_info* info, b32 is_hexad
text++;
}
value = zpl_cast( u64 ) arg;
value = scast( u64, arg);
len = _print_u64( text, remaining, NULL, value );
text += len;
@ -184,14 +184,14 @@ internal sw _print_f64( char* text, sw max_len, _format_info* info, b32 is_hexad
text++;
while ( info->precision-- > 0 )
{
value = zpl_cast( u64 )( arg * mult );
value = scast( u64, arg * mult );
len = _print_u64( text, remaining, NULL, value );
text += len;
if ( len >= remaining )
remaining = min( remaining, 1 );
else
remaining -= len;
arg -= zpl_cast( f64 ) value / mult;
arg -= scast( f64, value / mult);
mult *= 10;
}
}
@ -239,15 +239,15 @@ internal sw _print_f64( char* text, sw max_len, _format_info* info, b32 is_hexad
return ( text - text_begin );
}
neverinline sw str_fmt_va( char* text, sw max_len, char const* fmt, va_list va )
neverinline ssize str_fmt_va( char* text, ssize max_len, char const* fmt, va_list va )
{
char const* text_begin = text;
sw remaining = max_len, res;
ssize remaining = max_len, res;
while ( *fmt )
{
_format_info info = { 0 };
sw len = 0;
ssize len = 0;
info.precision = -1;
while ( *fmt && *fmt != '%' && remaining )
@ -311,7 +311,7 @@ neverinline sw str_fmt_va( char* text, sw max_len, char const* fmt, va_list va )
}
else
{
info.width = zpl_cast( s32 ) str_to_i64( fmt, zpl_cast( char** ) & fmt, 10 );
info.width = scast( s32, str_to_i64( fmt, ccast( char**, & fmt), 10 ));
if ( info.width != 0 )
{
info.flags |= GEN_FMT_WIDTH;
@ -329,7 +329,7 @@ neverinline sw str_fmt_va( char* text, sw max_len, char const* fmt, va_list va )
}
else
{
info.precision = zpl_cast( s32 ) str_to_i64( fmt, zpl_cast( char** ) & fmt, 10 );
info.precision = scast( s32, str_to_i64( fmt, ccast( char**, & fmt), 10 ));
}
info.flags &= ~GEN_FMT_ZERO;
}
@ -411,7 +411,7 @@ neverinline sw str_fmt_va( char* text, sw max_len, char const* fmt, va_list va )
break;
case 'c' :
len = _print_char( text, remaining, &info, zpl_cast( char ) va_arg( va, int ) );
len = _print_char( text, remaining, &info, scast( char, va_arg( va, int ) ));
break;
case 's' :
@ -455,25 +455,25 @@ neverinline sw str_fmt_va( char* text, sw max_len, char const* fmt, va_list va )
switch ( info.flags & GEN_FMT_INTS )
{
case GEN_FMT_CHAR :
value = zpl_cast( u64 ) zpl_cast( u8 ) va_arg( va, int );
value = scast( u64, scast( u8, va_arg( va, int )));
break;
case GEN_FMT_SHORT :
value = zpl_cast( u64 ) zpl_cast( u16 ) va_arg( va, int );
value = scast( u64, scast( u16, va_arg( va, int )));
break;
case GEN_FMT_LONG :
value = zpl_cast( u64 ) va_arg( va, unsigned long );
case GEN_FMT_LONG:
value = scast( u64, va_arg( va, unsigned long ));
break;
case GEN_FMT_LLONG :
value = zpl_cast( u64 ) va_arg( va, unsigned long long );
value = scast( u64, va_arg( va, unsigned long long ));
break;
case GEN_FMT_SIZE :
value = zpl_cast( u64 ) va_arg( va, uw );
value = scast( u64, va_arg( va, usize ));
break;
case GEN_FMT_INTPTR :
value = zpl_cast( u64 ) va_arg( va, uptr );
value = scast( u64, va_arg( va, uptr ));
break;
default :
value = zpl_cast( u64 ) va_arg( va, unsigned int );
value = scast( u64, va_arg( va, unsigned int ));
break;
}
@ -485,25 +485,25 @@ neverinline sw str_fmt_va( char* text, sw max_len, char const* fmt, va_list va )
switch ( info.flags & GEN_FMT_INTS )
{
case GEN_FMT_CHAR :
value = zpl_cast( s64 ) zpl_cast( s8 ) va_arg( va, int );
value = scast( s64, scast( s8, va_arg( va, int )));
break;
case GEN_FMT_SHORT :
value = zpl_cast( s64 ) zpl_cast( s16 ) va_arg( va, int );
value = scast( s64, scast( s16, va_arg( va, int )));
break;
case GEN_FMT_LONG :
value = zpl_cast( s64 ) va_arg( va, long );
value = scast( s64, va_arg( va, long ));
break;
case GEN_FMT_LLONG :
value = zpl_cast( s64 ) va_arg( va, long long );
value = scast( s64, va_arg( va, long long ));
break;
case GEN_FMT_SIZE :
value = zpl_cast( s64 ) va_arg( va, uw );
value = scast( s64, va_arg( va, usize ));
break;
case GEN_FMT_INTPTR :
value = zpl_cast( s64 ) va_arg( va, uptr );
value = scast( s64, va_arg( va, uptr ));
break;
default :
value = zpl_cast( s64 ) va_arg( va, int );
value = scast( s64, va_arg( va, int ));
break;
}
@ -540,17 +540,17 @@ char* str_fmt_buf( char const* fmt, ... )
return str;
}
sw str_fmt_file_va( struct FileInfo* f, char const* fmt, va_list va )
ssize str_fmt_file_va( struct FileInfo* f, char const* fmt, va_list va )
{
local_persist thread_local char buf[ GEN_PRINTF_MAXLEN ];
sw len = str_fmt_va( buf, size_of( buf ), fmt, va );
ssize len = str_fmt_va( buf, size_of( buf ), fmt, va );
b32 res = file_write( f, buf, len - 1 ); // NOTE: prevent extra whitespace
return res ? len : -1;
}
sw str_fmt_file( struct FileInfo* f, char const* fmt, ... )
ssize str_fmt_file( struct FileInfo* f, char const* fmt, ... )
{
sw res;
ssize res;
va_list va;
va_start( va, fmt );
res = str_fmt_file_va( f, fmt, va );
@ -558,9 +558,9 @@ sw str_fmt_file( struct FileInfo* f, char const* fmt, ... )
return res;
}
sw str_fmt( char* str, sw n, char const* fmt, ... )
ssize str_fmt( char* str, ssize n, char const* fmt, ... )
{
sw res;
ssize res;
va_list va;
va_start( va, fmt );
res = str_fmt_va( str, n, fmt, va );
@ -568,19 +568,19 @@ sw str_fmt( char* str, sw n, char const* fmt, ... )
return res;
}
sw str_fmt_out_va( char const* fmt, va_list va )
ssize str_fmt_out_va( char const* fmt, va_list va )
{
return str_fmt_file_va( file_get_standard( EFileStandard_OUTPUT ), fmt, va );
}
sw str_fmt_out_err_va( char const* fmt, va_list va )
ssize str_fmt_out_err_va( char const* fmt, va_list va )
{
return str_fmt_file_va( file_get_standard( EFileStandard_ERROR ), fmt, va );
}
sw str_fmt_out_err( char const* fmt, ... )
ssize str_fmt_out_err( char const* fmt, ... )
{
sw res;
ssize res;
va_list va;
va_start( va, fmt );
res = str_fmt_out_err_va( fmt, va );

22
project/dependencies/printing.hpp
View File

@ -12,23 +12,23 @@ struct FileInfo;
#endif
// NOTE: A locally persisting buffer is used internally
char* str_fmt_buf ( char const* fmt, ... );
char* str_fmt_buf_va ( char const* fmt, va_list va );
sw str_fmt ( char* str, sw n, char const* fmt, ... );
sw str_fmt_va ( char* str, sw n, char const* fmt, va_list va );
sw str_fmt_out_va ( char const* fmt, va_list va );
sw str_fmt_out_err ( char const* fmt, ... );
sw str_fmt_out_err_va( char const* fmt, va_list va );
sw str_fmt_file ( FileInfo* f, char const* fmt, ... );
sw str_fmt_file_va ( FileInfo* f, char const* fmt, va_list va );
char* str_fmt_buf ( char const* fmt, ... );
char* str_fmt_buf_va ( char const* fmt, va_list va );
ssize str_fmt ( char* str, ssize n, char const* fmt, ... );
ssize str_fmt_va ( char* str, ssize n, char const* fmt, va_list va );
ssize str_fmt_out_va ( char const* fmt, va_list va );
ssize str_fmt_out_err ( char const* fmt, ... );
ssize str_fmt_out_err_va( char const* fmt, va_list va );
ssize str_fmt_file ( FileInfo* f, char const* fmt, ... );
ssize str_fmt_file_va ( FileInfo* f, char const* fmt, va_list va );
constexpr
char const* Msg_Invalid_Value = "INVALID VALUE PROVIDED";
inline
sw log_fmt(char const* fmt, ...)
ssize log_fmt(char const* fmt, ...)
{
sw res;
ssize res;
va_list va;
va_start(va, fmt);

8
project/dependencies/string_ops.cpp
View File

@ -7,7 +7,7 @@
#pragma region String Ops
internal
sw _scan_zpl_i64( const char* text, s32 base, s64* value )
ssize _scan_zpl_i64( const char* text, s32 base, s64* value )
{
const char* text_begin = text;
s64 result = 0;
@ -56,7 +56,7 @@ global const char _num_to_char_table[] =
s64 str_to_i64( const char* str, char** end_ptr, s32 base )
{
sw len;
ssize len;
s64 value;
if ( ! base )
@ -85,7 +85,7 @@ void i64_to_str( s64 value, char* string, s32 base )
value = -value;
}
v = zpl_cast( u64 ) value;
v = scast( u64, value);
if ( v != 0 )
{
while ( v > 0 )
@ -207,7 +207,7 @@ f64 str_to_f64( const char* str, char** end_ptr )
result = sign * ( frac ? ( value / scale ) : ( value * scale ) );
if ( end_ptr )
*end_ptr = zpl_cast( char* ) str;
* end_ptr = rcast( char*, ccast(char*, str) );
return result;
}

121
project/dependencies/string_ops.hpp
View File

@ -5,41 +5,42 @@
#pragma region String Ops
GEN_DEF_INLINE const char* char_first_occurence( const char* str, char c );
const char* char_first_occurence( const char* str, char c );
constexpr auto str_find = &char_first_occurence;
GEN_DEF_INLINE b32 char_is_alpha( char c );
GEN_DEF_INLINE b32 char_is_alphanumeric( char c );
GEN_DEF_INLINE b32 char_is_digit( char c );
GEN_DEF_INLINE b32 char_is_hex_digit( char c );
GEN_DEF_INLINE b32 char_is_space( char c );
GEN_DEF_INLINE char char_to_lower( char c );
GEN_DEF_INLINE char char_to_upper( char c );
b32 char_is_alpha( char c );
b32 char_is_alphanumeric( char c );
b32 char_is_digit( char c );
b32 char_is_hex_digit( char c );
b32 char_is_space( char c );
char char_to_lower( char c );
char char_to_upper( char c );
GEN_DEF_INLINE s32 digit_to_int( char c );
GEN_DEF_INLINE s32 hex_digit_to_int( char c );
s32 digit_to_int( char c );
s32 hex_digit_to_int( char c );
GEN_DEF_INLINE s32 str_compare( const char* s1, const char* s2 );
GEN_DEF_INLINE s32 str_compare( const char* s1, const char* s2, sw len );
GEN_DEF_INLINE char* str_copy( char* dest, const char* source, sw len );
GEN_DEF_INLINE sw str_copy_nulpad( char* dest, const char* source, sw len );
GEN_DEF_INLINE sw str_len( const char* str );
GEN_DEF_INLINE sw str_len( const char* str, sw max_len );
GEN_DEF_INLINE char* str_reverse( char* str ); // NOTE: ASCII only
GEN_DEF_INLINE char const* str_skip( char const* str, char c );
GEN_DEF_INLINE char const* str_skip_any( char const* str, char const* char_list );
GEN_DEF_INLINE char const* str_trim( char const* str, b32 catch_newline );
s32 str_compare( const char* s1, const char* s2 );
s32 str_compare( const char* s1, const char* s2, ssize len );
char* str_copy( char* dest, const char* source, ssize len );
ssize str_copy_nulpad( char* dest, const char* source, ssize len );
ssize str_len( const char* str );
ssize str_len( const char* str, ssize max_len );
char* str_reverse( char* str ); // NOTE: ASCII only
char const* str_skip( char const* str, char c );
char const* str_skip_any( char const* str, char const* char_list );
char const* str_trim( char const* str, b32 catch_newline );
// NOTE: ASCII only
GEN_DEF_INLINE void str_to_lower( char* str );
GEN_DEF_INLINE void str_to_upper( char* str );
void str_to_lower( char* str );
void str_to_upper( char* str );
s64 str_to_i64( const char* str, char** end_ptr, s32 base );
void i64_to_str( s64 value, char* string, s32 base );
void u64_to_str( u64 value, char* string, s32 base );
f64 str_to_f64( const char* str, char** end_ptr );
GEN_IMPL_INLINE const char* char_first_occurence( const char* s, char c )
inline
const char* char_first_occurence( const char* s, char c )
{
char ch = c;
for ( ; *s != ch; s++ )
@ -50,59 +51,67 @@ GEN_IMPL_INLINE const char* char_first_occurence( const char* s, char c )
return s;
}
GEN_IMPL_INLINE b32 char_is_alpha( char c )
inline
b32 char_is_alpha( char c )
{
if ( ( c >= 'A' && c <= 'Z' ) || ( c >= 'a' && c <= 'z' ) )
return true;
return false;
}
GEN_IMPL_INLINE b32 char_is_alphanumeric( char c )
inline
b32 char_is_alphanumeric( char c )
{
return char_is_alpha( c ) || char_is_digit( c );
}
GEN_IMPL_INLINE b32 char_is_digit( char c )
inline
b32 char_is_digit( char c )
{
if ( c >= '0' && c <= '9' )
return true;
return false;
}
GEN_IMPL_INLINE b32 char_is_hex_digit( char c )
inline
b32 char_is_hex_digit( char c )
{
if ( char_is_digit( c ) || ( c >= 'a' && c <= 'f' ) || ( c >= 'A' && c <= 'F' ) )
return true;
return false;
}
GEN_IMPL_INLINE b32 char_is_space( char c )
inline
b32 char_is_space( char c )
{
if ( c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == '\f' || c == '\v' )
return true;
return false;
}
GEN_IMPL_INLINE char char_to_lower( char c )
inline
char char_to_lower( char c )
{
if ( c >= 'A' && c <= 'Z' )
return 'a' + ( c - 'A' );
return c;
}
GEN_IMPL_INLINE char char_to_upper( char c )
inline char char_to_upper( char c )
{
if ( c >= 'a' && c <= 'z' )
return 'A' + ( c - 'a' );
return c;
}
GEN_IMPL_INLINE s32 digit_to_int( char c )
inline
s32 digit_to_int( char c )
{
return char_is_digit( c ) ? c - '0' : c - 'W';
}
GEN_IMPL_INLINE s32 hex_digit_to_int( char c )
inline
s32 hex_digit_to_int( char c )
{
if ( char_is_digit( c ) )
return digit_to_int( c );
@ -113,7 +122,8 @@ GEN_IMPL_INLINE s32 hex_digit_to_int( char c )
return -1;
}
GEN_IMPL_INLINE s32 str_compare( const char* s1, const char* s2 )
inline
s32 str_compare( const char* s1, const char* s2 )
{
while ( *s1 && ( *s1 == *s2 ) )
{
@ -122,7 +132,8 @@ GEN_IMPL_INLINE s32 str_compare( const char* s1, const char* s2 )
return *( u8* )s1 - *( u8* )s2;
}
GEN_IMPL_INLINE s32 str_compare( const char* s1, const char* s2, sw len )
inline
s32 str_compare( const char* s1, const char* s2, ssize len )
{
for ( ; len > 0; s1++, s2++, len-- )
{
@ -134,7 +145,8 @@ GEN_IMPL_INLINE s32 str_compare( const char* s1, const char* s2, sw len )
return 0;
}
GEN_IMPL_INLINE char* str_copy( char* dest, const char* source, sw len )
inline
char* str_copy( char* dest, const char* source, ssize len )
{
GEN_ASSERT_NOT_NULL( dest );
if ( source )
@ -154,9 +166,10 @@ GEN_IMPL_INLINE char* str_copy( char* dest, const char* source, sw len )
return dest;
}
GEN_IMPL_INLINE sw str_copy_nulpad( char* dest, const char* source, sw len )
inline
ssize str_copy_nulpad( char* dest, const char* source, ssize len )
{
sw result = 0;
ssize result = 0;
GEN_ASSERT_NOT_NULL( dest );
if ( source )
{
@ -178,7 +191,8 @@ GEN_IMPL_INLINE sw str_copy_nulpad( char* dest, const char* source, sw len )
return result;
}
GEN_IMPL_INLINE sw str_len( const char* str )
inline
ssize str_len( const char* str )
{
if ( str == NULL )
{
@ -190,17 +204,19 @@ GEN_IMPL_INLINE sw str_len( const char* str )
return str - p;
}
GEN_IMPL_INLINE sw str_len( const char* str, sw max_len )
inline
ssize str_len( const char* str, ssize max_len )
{
const char* end = zpl_cast( const char* ) mem_find( str, 0, max_len );
const char* end = rcast(const char*, mem_find( str, 0, max_len ));
if ( end )
return end - str;
return max_len;
}
GEN_IMPL_INLINE char* str_reverse( char* str )
inline
char* str_reverse( char* str )
{
sw len = str_len( str );
ssize len = str_len( str );
char* a = str + 0;
char* b = str + len - 1;
len /= 2;
@ -212,7 +228,8 @@ GEN_IMPL_INLINE char* str_reverse( char* str )
return str;
}
GEN_IMPL_INLINE char const* str_skip( char const* str, char c )
inline
char const* str_skip( char const* str, char c )
{
while ( *str && *str != c )
{
@ -221,11 +238,12 @@ GEN_IMPL_INLINE char const* str_skip( char const* str, char c )
return str;
}
GEN_IMPL_INLINE char const* str_skip_any( char const* str, char const* char_list )
inline
char const* str_skip_any( char const* str, char const* char_list )
{
char const* closest_ptr = zpl_cast( char const* ) pointer_add( ( void* )str, str_len( str ) );
sw char_list_count = str_len( char_list );
for ( sw i = 0; i < char_list_count; i++ )
char const* closest_ptr = rcast( char const*, pointer_add_const( rcast(void const*, str), str_len( str ) ));
ssize char_list_count = str_len( char_list );
for ( ssize i = 0; i < char_list_count; i++ )
{
char const* p = str_skip( str, char_list[ i ] );
closest_ptr = min( closest_ptr, p );
@ -233,7 +251,8 @@ GEN_IMPL_INLINE char const* str_skip_any( char const* str, char const* char_list
return closest_ptr;
}
GEN_IMPL_INLINE char const* str_trim( char const* str, b32 catch_newline )
inline
char const* str_trim( char const* str, b32 catch_newline )
{
while ( *str && char_is_space( *str ) && ( ! catch_newline || ( catch_newline && *str != '\n' ) ) )
{
@ -242,7 +261,8 @@ GEN_IMPL_INLINE char const* str_trim( char const* str, b32 catch_newline )
return str;
}
GEN_IMPL_INLINE void str_to_lower( char* str )
inline
void str_to_lower( char* str )
{
if ( ! str )
return;
@ -253,7 +273,8 @@ GEN_IMPL_INLINE void str_to_lower( char* str )
}
}
GEN_IMPL_INLINE void str_to_upper( char* str )
inline
void str_to_upper( char* str )
{
if ( ! str )
return;

20
project/dependencies/strings.cpp
View File

@ -5,7 +5,7 @@
#pragma region String
String String::fmt( AllocatorInfo allocator, char* buf, sw buf_size, char const* fmt, ... )
String String::fmt( AllocatorInfo allocator, char* buf, ssize buf_size, char const* fmt, ... )
{
va_list va;
va_start( va, fmt );
@ -15,9 +15,9 @@ String String::fmt( AllocatorInfo allocator, char* buf, sw buf_size, char const*
return make( allocator, buf );
}
String String::make_length( AllocatorInfo allocator, char const* str, sw length )
String String::make_length( AllocatorInfo allocator, char const* str, ssize length )
{
constexpr sw header_size = sizeof( Header );
constexpr ssize header_size = sizeof( Header );
s32 alloc_size = header_size + length + 1;
void* allocation = alloc( allocator, alloc_size );
@ -41,9 +41,9 @@ String String::make_length( AllocatorInfo allocator, char const* str, sw length
return result;
}
String String::make_reserve( AllocatorInfo allocator, sw capacity )
String String::make_reserve( AllocatorInfo allocator, ssize capacity )
{
constexpr sw header_size = sizeof( Header );
constexpr ssize header_size = sizeof( Header );
s32 alloc_size = header_size + capacity + 1;
void* allocation = alloc( allocator, alloc_size );
@ -78,7 +78,7 @@ String String::fmt_buf( AllocatorInfo allocator, char const* fmt, ... )
bool String::append_fmt( char const* fmt, ... )
{
sw res;
ssize res;
char buf[ GEN_PRINTF_MAXLEN ] = { 0 };
va_list va;
@ -89,9 +89,9 @@ bool String::append_fmt( char const* fmt, ... )
return append( buf, res );
}
bool String::make_space_for( char const* str, sw add_len )
bool String::make_space_for( char const* str, ssize add_len )
{
sw available = avail_space();
ssize available = avail_space();
// NOTE: Return if there is enough space left
if ( available >= add_len )
@ -100,7 +100,7 @@ bool String::make_space_for( char const* str, sw add_len )
}
else
{
sw new_len, old_size, new_size;
ssize new_len, old_size, new_size;
void* ptr;
void* new_ptr;
@ -118,7 +118,7 @@ bool String::make_space_for( char const* str, sw add_len )
if ( new_ptr == nullptr )
return false;
header = zpl_cast( Header* ) new_ptr;
header = rcast( Header*, new_ptr);
header->Allocator = allocator;
header->Capacity = new_len;

60
project/dependencies/strings.hpp
View File

@ -8,15 +8,15 @@
// Constant string with length.
struct StrC
{
sw Len;
ssize Len;
char const* Ptr;
operator char const* () const { return Ptr; }
char const& operator[]( sw index ) const { return Ptr[index]; }
operator char const* () const { return Ptr; }
char const& operator[]( ssize index ) const { return Ptr[index]; }
};
#define cast_to_strc( str ) * rcast( StrC*, (str) - sizeof(sw) )
#define txt( text ) StrC { sizeof( text ) - 1, ( text ) }
#define cast_to_strc( str ) * rcast( StrC*, (str) - sizeof(ssize) )
#define txt( text ) StrC { sizeof( text ) - 1, ( text ) }
inline
StrC to_str( char const* str )
@ -33,12 +33,12 @@ struct String
struct Header
{
AllocatorInfo Allocator;
sw Capacity;
sw Length;
ssize Capacity;
ssize Length;
};
static
uw grow_formula( uw value )
usize grow_formula( usize value )
{
// Using a very aggressive growth formula to reduce time mem_copying with recursive calls to append in this library.
return 4 * value + 8;
@ -47,7 +47,7 @@ struct String
static
String make( AllocatorInfo allocator, char const* str )
{
sw length = str ? str_len( str ) : 0;
ssize length = str ? str_len( str ) : 0;
return make_length( allocator, str, length );
}
@ -58,23 +58,23 @@ struct String
}
static
String make_reserve( AllocatorInfo allocator, sw capacity );
String make_reserve( AllocatorInfo allocator, ssize capacity );
static
String make_length( AllocatorInfo allocator, char const* str, sw length );
String make_length( AllocatorInfo allocator, char const* str, ssize length );
static
String fmt( AllocatorInfo allocator, char* buf, sw buf_size, char const* fmt, ... );
String fmt( AllocatorInfo allocator, char* buf, ssize buf_size, char const* fmt, ... );
static
String fmt_buf( AllocatorInfo allocator, char const* fmt, ... );
static
String join( AllocatorInfo allocator, char const** parts, sw num_parts, char const* glue )
String join( AllocatorInfo allocator, char const** parts, ssize num_parts, char const* glue )
{
String result = make( allocator, "" );
for ( sw idx = 0; idx < num_parts; ++idx )
for ( ssize idx = 0; idx < num_parts; ++idx )
{
result.append( parts[ idx ] );
@ -91,7 +91,7 @@ struct String
if ( lhs.length() != rhs.length() )
return false;
for ( sw idx = 0; idx < lhs.length(); ++idx )
for ( ssize idx = 0; idx < lhs.length(); ++idx )
if ( lhs[ idx ] != rhs[ idx ] )
return false;
@ -104,14 +104,14 @@ struct String
if ( lhs.length() != (rhs.Len) )
return false;
for ( sw idx = 0; idx < lhs.length(); ++idx )
for ( ssize 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 );
bool make_space_for( char const* str, ssize add_len );
bool append( char c )
{
@ -123,11 +123,11 @@ struct String
return append( str, str_len( str ) );
}
bool append( char const* str, sw length )
bool append( char const* str, ssize length )
{
if ( sptr(str) > 0 )
{
sw curr_len = this->length();
ssize curr_len = this->length();
if ( ! make_space_for( str, length ) )
return false;
@ -155,7 +155,7 @@ struct String
bool append_fmt( char const* fmt, ... );
sw avail_space() const
ssize avail_space() const
{
Header const&
header = * rcast( Header const*, Data - sizeof( Header ));
@ -168,7 +168,7 @@ struct String
return Data[ length() - 1 ];
}
sw capacity() const
ssize capacity() const
{
Header const&
header = * rcast( Header const*, Data - sizeof( Header ));
@ -201,7 +201,7 @@ struct String
return *(Header*)(Data - sizeof(Header));
}
sw length() const
ssize length() const
{
Header const&
header = * rcast( Header const*, Data - sizeof( Header ));
@ -273,7 +273,7 @@ struct String
void trim( char const* cut_set )
{
sw len = 0;
ssize len = 0;
char* start_pos = Data;
char* end_pos = Data + length() - 1;
@ -284,7 +284,7 @@ struct String
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 ) );
len = scast( ssize, ( start_pos > end_pos ) ? 0 : ( ( end_pos - start_pos ) + 1 ) );
if ( Data != start_pos )
mem_move( Data, start_pos, len );
@ -379,19 +379,19 @@ struct String
if ( this == & other )
return *this;
String& this_ = ccast( String, *this );
String*
this_ = ccast(String*, this);
this_->Data = other.Data;
this_.Data = other.Data;
return this_;
return *this;
}
char& operator [] ( sw index )
char& operator [] ( ssize index )
{
return Data[ index ];
}
char const& operator [] ( sw index ) const
char const& operator [] ( ssize index ) const
{
return Data[ index ];
}

2
project/dependencies/timing.cpp
View File

@ -23,7 +23,7 @@
{
u32 hi, lo;
__asm__ __volatile__( "rdtsc" : "=a"( lo ), "=d"( hi ) );
return ( zpl_cast( u64 ) lo ) | ( ( zpl_cast( u64 ) hi ) << 32 );
return ( scast( u64, lo ) | ( ( scast( u64, hi ) << 32 );
}
#elif defined( __powerpc__ )
u64 read_cpu_time_stamp_counter( void )

2
project/gen.dep.hpp
View File

@ -1,7 +1,7 @@
// This file is intended to be included within gen.hpp (There is no pragma diagnostic ignores)
#pragma once
#include "dependencies/header_start.hpp"
#include "dependencies/platform.hpp"
GEN_NS_BEGIN

8
project/helpers/helper.hpp
View File

@ -70,7 +70,7 @@ CodeBody gen_eoperator( char const* path )
String enum_entries = String::make_reserve( GlobalAllocator, kilobytes(1) );
String to_str_entries = String::make_reserve( GlobalAllocator, kilobytes(1) );
for (uw idx = 0; idx < enum_strs.num(); idx++)
for (usize idx = 0; idx < enum_strs.num(); idx++)
{
char const* enum_str = enum_strs[idx].string;
char const* entry_to_str = str_strs [idx].string;
@ -126,7 +126,7 @@ CodeBody gen_especifier( char const* path )
String enum_entries = String::make_reserve( GlobalAllocator, kilobytes(1) );
String to_str_entries = String::make_reserve( GlobalAllocator, kilobytes(1) );
for (uw idx = 0; idx < enum_strs.num(); idx++)
for (usize idx = 0; idx < enum_strs.num(); idx++)
{
char const* enum_str = enum_strs[idx].string;
char const* entry_to_str = str_strs [idx].string;
@ -241,7 +241,7 @@ CodeBody gen_etoktype( char const* etok_path, char const* attr_path )
String to_str_attributes = String::make_reserve( GlobalAllocator, kilobytes(4) );
String attribute_define_entries = String::make_reserve( GlobalAllocator, kilobytes(4) );
for (uw idx = 0; idx < enum_strs.num(); idx++)
for (usize idx = 0; idx < enum_strs.num(); idx++)
{
char const* enum_str = enum_strs[idx].string;
char const* entry_to_str = enum_str_strs [idx].string;
@ -250,7 +250,7 @@ CodeBody gen_etoktype( char const* etok_path, char const* attr_path )
to_str_entries.append_fmt( "{ sizeof(\"%s\"), \"%s\" },\n", entry_to_str, entry_to_str);
}
for ( uw idx = 0; idx < attribute_strs.num(); idx++ )
for ( usize idx = 0; idx < attribute_strs.num(); idx++ )
{
char const* attribute_str = attribute_strs[idx].string;
char const* entry_to_str = attribute_str_strs [idx].string;

2
project/helpers/undef.macros.hpp
View File

@ -24,8 +24,6 @@
#undef forceinline
#undef neverinline
#undef zpl_cast
#undef global
#undef internal
#undef local_persist

7
scripts/gencpp.refactor
View File

@ -43,9 +43,6 @@
// word GEN_COMPILER_MINGW, new_name
// word GEN_COMPILER_MSVC, new_name
// General
// word zpl_cast, new_name
// word global, new_name
// word internal, new_name
// word local_persist, new_name
@ -150,8 +147,8 @@
// word u16, new_name
// word u32, new_name
// word u64, new_name
// word uw, new_name
// word sw, new_name
// word usize, new_name
// word ssize, new_name
// word sptr, new_name
// word uptr, new_name
// word f32, new_name

24
scripts/package_release.ps1
View File

@ -64,5 +64,29 @@ Remove-Item -Path $path_release_content\gen.scanner.cpp
# Unreal
Copy-Item -Path $path_unreal_gen\* -Destination $path_release_content
Compress-Archive -Path $path_release_content\* -DestinationPath $path_release\gencpp_unreal.zip -Force
Remove-Item -Path $path_release_content\gen.dep.hpp
Remove-Item -Path $path_release_content\gen.dep.cpp
Remove-Item -Path $path_release_content\gen.hpp
Remove-Item -Path $path_release_content\gen.cpp
Remove-Item -Path $path_release_content\gen.builder.hpp
Remove-Item -Path $path_release_content\gen.builder.cpp
Remove-Item -Path $path_release_content\gen.scanner.hpp
Remove-Item -Path $path_release_content\gen.scanner.cpp
# As Is
Copy-Item -Path $path_project\gen.hpp -Destination $path_release_content
Copy-Item -Path $path_project\gen.cpp -Destination $path_release_content
Copy-Item -Path $path_project\gen.dep.hpp -Destination $path_release_content
Copy-Item -Path $path_project\gen.dep.cpp -Destination $path_release_content
Copy-Item -Path $path_project\auxillary\builder.hpp -Destination $path_release_content
Copy-Item -Path $path_project\auxillary\builder.cpp -Destination $path_release_content
Copy-Item -Path $path_project\auxillary\scanner.hpp -Destination $path_release_content
Copy-Item -Path $path_project\auxillary\scanner.cpp -Destination $path_release_content
Copy-Item -Path $path_project\components\* -Destination $path_release_content\components
Copy-Item -Path $path_project\dependencies\* -Destination $path_release_content\dependencies
Copy-Item -Path $path_project\enums\* -Destination $path_release_content\dependencies
Copy-Item -Path $path_project\helpers\* -Destination $path_release_content\dependencies
Compress-Archive -Path $path_release_content\* -DestinationPath $path_release\gencpp_as_is.zip -Force
Remove-Item -Path $path_release_content -Recurse

6
singleheader/singleheader.cpp
View File

@ -69,7 +69,7 @@ int gen_main()
if ( generate_gen_dep )
{
Code header_start = scan_file( project_dir "dependencies/header_start.hpp" );
Code platform = scan_file( project_dir "dependencies/platform.hpp" );
Code macros = scan_file( project_dir "dependencies/macros.hpp" );
Code basic_types = scan_file( project_dir "dependencies/basic_types.hpp" );
Code debug = scan_file( project_dir "dependencies/debug.hpp" );
@ -83,7 +83,9 @@ int gen_main()
Code timing = scan_file( project_dir "dependencies/timing.hpp" );
header.print_fmt( roll_own_dependencies_guard_start );
header.print( header_start );
header.print( fmt_newline );
header.print( platform );
header.print( fmt_newline );
header.print_fmt( "\nGEN_NS_BEGIN\n" );
header.print( macros );

30
test/_old/parsed/Array.Parsed.hpp
View File

@ -15,11 +15,11 @@ Code gen__array_base()
struct ArrayHeader
{
AllocatorInfo Allocator;
uw Capacity;
uw Num;
usize Capacity;
usize Num;
};
static inline uw array_grow_formula( uw value )
static inline usize array_grow_formula( usize value )
{
return 2 * value * 8;
}
@ -52,7 +52,7 @@ Code gen__array( StrC type )
}
static
<ArrayType> init_reserve( AllocatorInfo allocator, sw capacity )
<ArrayType> init_reserve( AllocatorInfo allocator, ssize capacity )
{
Header* header = rcast( Header*, alloc( allocator, sizeof(Header) + sizeof(Type) ));
@ -94,14 +94,14 @@ Code gen__array( StrC type )
header.Num = 0;
}
bool fill( uw begin, uw end, Type value )
bool fill( usize begin, usize end, Type value )
{
Header& header = get_header();
if ( begin < 0 || end >= header.Num )
return false;
for ( sw idx = begin; idx < end; idx++ )
for ( ssize idx = begin; idx < end; idx++ )
{
Data[ idx ] = value;
}
@ -120,10 +120,10 @@ Code gen__array( StrC type )
return *( reinterpret_cast< Header* >( Data ) - 1 );
}
bool grow( uw min_capacity )
bool grow( usize min_capacity )
{
Header& header = get_header();
uw new_capacity = grow_formula( header.Capacity );
usize new_capacity = grow_formula( header.Capacity );
if ( new_capacity < min_capacity )
new_capacity = 8;
@ -131,7 +131,7 @@ Code gen__array( StrC type )
return set_capacity( new_capacity );
}
uw num( void )
usize num( void )
{
return get_header().Num;
}
@ -144,7 +144,7 @@ Code gen__array( StrC type )
header.Num--;
}
void remove_at( uw idx )
void remove_at( usize idx )
{
Header* header = &get_header();
GEN_ASSERT( idx < header->Num );
@ -153,7 +153,7 @@ Code gen__array( StrC type )
header->Num--;
}
bool reserve( uw new_capacity )
bool reserve( usize new_capacity )
{
Header& header = get_header();
@ -163,7 +163,7 @@ Code gen__array( StrC type )
return true;
}
bool resize( uw num )
bool resize( usize num )
{
Header& header = get_header();
@ -177,7 +177,7 @@ Code gen__array( StrC type )
return true;
}
bool set_capacity( uw new_capacity )
bool set_capacity( usize new_capacity )
{
Header& header = get_header();
@ -187,7 +187,7 @@ Code gen__array( StrC type )
if ( new_capacity < header.Num )
header.Num = new_capacity;
sw size = sizeof( Header ) + sizeof( Type ) * new_capacity;
ssize size = sizeof( Header ) + sizeof( Type ) * new_capacity;
Header* new_header = rcast( Header*, alloc( header.Allocator, size ) );
if ( new_header == nullptr )
@ -233,7 +233,7 @@ void gen__array_request( StrC type, StrC dep = {} )
do_once_end
// Make sure we don't already have a request for the type.
for ( sw idx = 0; idx < GenArrayRequests.num(); ++idx )
for ( ssize idx = 0; idx < GenArrayRequests.num(); ++idx )
{
StrC const reqest_type = GenArrayRequests[ idx ].Type;

12
test/_old/parsed/Buffer.Parsed.hpp
View File

@ -15,8 +15,8 @@ Code gen__buffer_base()
struct BufferHeader
{
AllocatorInfo Backing;
uw Capacity;
uw Num;
usize Capacity;
usize Num;
};
));
}
@ -38,7 +38,7 @@ Code gen__buffer( StrC type )
using Header = BufferHeader;
using Type = <type>;
static <BufferName> init( AllocatorInfo allocator, sw capacity )
static <BufferName> init( AllocatorInfo allocator, ssize capacity )
{
Header* header = rcast( Header*, alloc( allocator, sizeof( Header ) + capacity * sizeof( Type ) ) );
@ -76,7 +76,7 @@ Code gen__buffer( StrC type )
header.Num++;
}
void append( Type* values, sw num )
void append( Type* values, ssize num )
{
Header& header = get_header();
GEN_ASSERT( header.Num + num <= header.Capacity);
@ -108,7 +108,7 @@ Code gen__buffer( StrC type )
return *( rcast( Header*, Data ) - 1 );
}
sw num( void )
ssize num( void )
{
return get_header().Num;
}
@ -147,7 +147,7 @@ void gen__buffer_request( StrC type, StrC dep = {} )
do_once_end
// Make sure we don't already have a request for the type.
for ( sw idx = 0; idx < GenBufferRequests.num(); ++idx )
for ( ssize idx = 0; idx < GenBufferRequests.num(); ++idx )
{
StrC const reqest_type = GenBufferRequests[ idx ].Type;

40
test/_old/parsed/HashTable.Parsed.hpp
View File

@ -15,9 +15,9 @@ Code gen__hashtable_base()
return parse_global_body( code(
struct HashTable_FindResult
{
sw HashIndex;
sw PrevIndex;
sw EntryIndex;
ssize HashIndex;
ssize PrevIndex;
ssize EntryIndex;
};
));
}
@ -37,7 +37,7 @@ Code gen__hashtable( StrC type )
struct <HashTableName>_Entry
{
u64 Key;
sw Next;
ssize Next;
<type> Value;
};
)
@ -86,7 +86,7 @@ Code gen__hashtable( StrC type )
Type* get( u64 key )
{
sw idx = find( key ).EntryIndex;
ssize idx = find( key ).EntryIndex;
if ( idx > 0 )
return &Entries[ idx ].Value;
@ -96,7 +96,7 @@ Code gen__hashtable( StrC type )
void grow( void )
{
sw new_num = array_grow_formula( Entries.num() );
ssize new_num = array_grow_formula( Entries.num() );
rehash( new_num );
}
@ -105,7 +105,7 @@ Code gen__hashtable( StrC type )
{
GEN_ASSERT_NOT_NULL( map_proc );
for ( sw idx = 0; idx < Entries.num(); idx++ )
for ( ssize idx = 0; idx < Entries.num(); idx++ )
{
map_proc( Entries[ idx ].Key, Entries[ idx ].Value );
}
@ -115,16 +115,16 @@ Code gen__hashtable( StrC type )
{
GEN_ASSERT_NOT_NULL( map_proc );
for ( sw idx = 0; idx < Entries.num(); idx++ )
for ( ssize idx = 0; idx < Entries.num(); idx++ )
{
map_proc( Entries[ idx ].Key, &Entries[ idx ].Value );
}
}
void rehash( sw new_num )
void rehash( ssize new_num )
{
sw idx;
sw last_added_index;
ssize idx;
ssize last_added_index;
HashTable_u32 new_ht = HashTable_u32::init( Hashes.get_header().Allocator );
new_ht.Hashes.resize( new_num );
@ -163,7 +163,7 @@ Code gen__hashtable( StrC type )
void rehash_fast( void )
{
sw idx;
ssize idx;
for ( idx = 0; idx < Entries.num(); idx++ )
Entries[ idx ].Next = -1;
@ -189,14 +189,14 @@ Code gen__hashtable( StrC type )
}
}
void remove_entry( sw idx )
void remove_entry( ssize idx )
{
Entries.remove_at( idx );
}
void set( u64 key, Type value )
{
sw idx;
ssize idx;
FindResult find_result;
if ( Hashes.num() == 0 )
@ -228,9 +228,9 @@ Code gen__hashtable( StrC type )
grow();
}
sw slot( u64 key )
ssize slot( u64 key )
{
for ( sw idx = 0; idx < Hashes.num(); ++idx )
for ( ssize idx = 0; idx < Hashes.num(); ++idx )
if ( Hashes[ idx ] == key )
return idx;
@ -242,9 +242,9 @@ Code gen__hashtable( StrC type )
protected:
sw add_entry( u64 key )
ssize add_entry( u64 key )
{
sw idx;
ssize idx;
Entry entry = { key, -1 };
idx = Entries.num();
Entries.append( entry );
@ -294,11 +294,11 @@ void gen__hashtable_request( StrC type, StrC dep = {} )
do_once_start
GenHashTableRequests = Array<GenHashTableRequest>::init( GlobalAllocator );
gen_array( sw );
gen_array( ssize );
do_once_end
// Make sure we don't already have a request for the type.
for ( sw idx = 0; idx < GenHashTableRequests.num(); ++idx )
for ( ssize idx = 0; idx < GenHashTableRequests.num(); ++idx )
{
StrC const reqest_type = GenHashTableRequests[ idx ].Type;

14
test/_old/parsed/Ring.Parsed.hpp
View File

@ -30,7 +30,7 @@ Code gen__ring( StrC type )
{
using Type = <type>;
static <RingName> init( AllocatorInfo allocator, uw max_size )
static <RingName> init( AllocatorInfo allocator, usize max_size )
{
<RingName> result = { 0 };
@ -52,9 +52,9 @@ Code gen__ring( StrC type )
Tail = ( Tail + 1 ) % Capacity;
}
inline void append( Type* values, sw num )
inline void append( Type* values, ssize num )
{
for ( sw idx = 0; idx < num; idx++ )
for ( ssize idx = 0; idx < num; idx++ )
append( values[ idx ] );
}
@ -88,9 +88,9 @@ Code gen__ring( StrC type )
}
AllocatorInfo Backing;
uw Capacity;
uw Head;
uw Tail;
usize Capacity;
usize Head;
usize Tail;
<BufferName> Buffer;
};
)
@ -113,7 +113,7 @@ void gen__ring_request( StrC type, StrC dep = {} )
do_once_end
// Make sure we don't already have a request for the type.
for ( sw idx = 0; idx < GenRingRequests.num(); ++idx )
for ( ssize idx = 0; idx < GenRingRequests.num(); ++idx )
{
StrC const reqest_type = GenRingRequests[ idx ].Type;

4
test/_old/parsed/test.parsing.cpp
View File

@ -23,14 +23,14 @@ int gen_main()
gen_sanity();
gen_array( u8 );
gen_array( sw );
gen_array( ssize );
gen_buffer( u8 );
gen_hashtable( u32 );
gen_ring( s16 );
gen_ring( uw );
gen_ring( usize );
gen_array_file();
gen_buffer_file();

8
test/_old/upfront/Array.Upfront.hpp
View File

@ -142,7 +142,7 @@ Code gen__array( StrC type )
if ( begin < 0 || end >= header.Num )
return false;
for ( sw idx = begin; idx < end; idx++ )
for ( ssize idx = begin; idx < end; idx++ )
{
Data[ idx ] = value;
}
@ -170,7 +170,7 @@ Code gen__array( StrC type )
, def_execution( code(
Header& header = * get_header();
uw new_capacity = grow_formula( header.Capacity );
usize new_capacity = grow_formula( header.Capacity );
if ( new_capacity < min_capacity )
new_capacity = 8;
@ -243,7 +243,7 @@ Code gen__array( StrC type )
if ( new_capacity < header.Num )
header.Num = new_capacity;
sw size = sizeof(Header) + sizeof(Type) * new_capacity;
ssize size = sizeof(Header) + sizeof(Type) * new_capacity;
Header* new_header = rcast( Header*, alloc( header.Allocator, size ));
if ( new_header == nullptr )
@ -314,7 +314,7 @@ void gen__array_request( StrC type, StrC dep = {} )
do_once_end
// Make sure we don't already have a request for the type.
for ( sw idx = 0; idx < GenArrayRequests.num(); ++idx )
for ( ssize idx = 0; idx < GenArrayRequests.num(); ++idx )
{
StrC const reqest_type = GenArrayRequests[ idx ].Type;

6
test/_old/upfront/Buffer.Upfront.hpp
View File

@ -19,7 +19,7 @@ Code gen__buffer_base()
return def_global_body( 1, header );
}
Code gen__buffer( StrC type, sw type_size )
Code gen__buffer( StrC type, ssize type_size )
{
static CodeType t_allocator_info = def_type( name(AllocatorInfo));
@ -206,7 +206,7 @@ struct GenBufferRequest
{
StrC Dependency;
StrC Type;
sw TypeSize;
ssize TypeSize;
};
Array<GenBufferRequest> GenBufferRequests;
@ -217,7 +217,7 @@ void gen__buffer_request( StrC type, StrC dep = {} )
do_once_end
// Make sure we don't already have a request for the type.
for ( sw idx = 0; idx < GenBufferRequests.num(); ++idx )
for ( ssize idx = 0; idx < GenBufferRequests.num(); ++idx )
{
StrC const reqest_type = GenBufferRequests[ idx ].Type;

24
test/_old/upfront/HashTable.Upfront.hpp
View File

@ -128,7 +128,7 @@ Code gen__hashtable( StrC type )
CodeFn get = def_function( name(get), def_param( t_u64, name(key)), t_type_ptr
, def_execution( code(
sw idx = find( key ).EntryIndex;
ssize idx = find( key ).EntryIndex;
if ( idx >= 0 )
return & Entries[ idx ].Value;
@ -153,7 +153,7 @@ Code gen__hashtable( StrC type )
Code body = def_execution( code(
GEN_ASSERT_NOT_NULL( map_proc );
for ( sw idx = 0; idx < Entries.num(); idx++ )
for ( ssize idx = 0; idx < Entries.num(); idx++ )
{
map_proc( Entries[ idx ].Key, Entries[ idx ].Value );
}
@ -179,7 +179,7 @@ Code gen__hashtable( StrC type )
Code body = def_execution( code(
GEN_ASSERT_NOT_NULL( map_proc );
for ( sw idx = 0; idx < Entries.num(); idx++ )
for ( ssize idx = 0; idx < Entries.num(); idx++ )
{
map_proc( Entries[ idx ].Key, & Entries[ idx ].Value );
}
@ -190,7 +190,7 @@ Code gen__hashtable( StrC type )
CodeFn grow = def_function( name(grow), __, t_void
, def_execution( code(
sw new_num = array_grow_formula( Entries.num() );
ssize new_num = array_grow_formula( Entries.num() );
rehash( new_num );
))
);
@ -198,8 +198,8 @@ Code gen__hashtable( StrC type )
CodeFn rehash;
{
char const* tmpl = stringize(
sw idx;
sw last_added_index;
ssize idx;
ssize last_added_index;
<type> new_ht = init_reserve( Hashes.get_header()->Allocator, new_num );
@ -242,7 +242,7 @@ Code gen__hashtable( StrC type )
CodeFn rehash_fast;
{
char const* tmpl = stringize(
sw idx;
ssize idx;
for ( idx = 0; idx < Entries.num(); idx++ )
Entries[ idx ].Next = -1;
@ -288,7 +288,7 @@ Code gen__hashtable( StrC type )
));
Code body = def_execution( code(
sw idx;
ssize idx;
FindResult find_result;
if ( Hashes.num() == 0 )
@ -325,7 +325,7 @@ Code gen__hashtable( StrC type )
CodeFn slot = def_function( name(slot), def_param( t_u64, name(key)), t_sw
, def_execution( code(
for ( sw idx = 0; idx < Hashes.num(); ++idx )
for ( ssize idx = 0; idx < Hashes.num(); ++idx )
if ( Hashes[ idx ] == key )
return idx;
@ -335,7 +335,7 @@ Code gen__hashtable( StrC type )
CodeFn add_entry = def_function( name(add_entry), def_param( t_u64, name(key)), t_sw
, def_execution( code(
sw idx;
ssize idx;
Entry entry = { key, -1 };
idx = Entries.num();
@ -421,11 +421,11 @@ void gen__hashtable_request( StrC type, StrC dep = {} )
do_once_start
GenHashTableRequests = Array<GenHashTableRequest>::init( GlobalAllocator );
gen_array( sw );
gen_array( ssize );
do_once_end
// Make sure we don't already have a request for the type.
for ( sw idx = 0; idx < GenHashTableRequests.num(); ++idx )
for ( ssize idx = 0; idx < GenHashTableRequests.num(); ++idx )
{
StrC const reqest_type = GenHashTableRequests[ idx ].Type;

4
test/_old/upfront/Ring.Upfront.hpp
View File

@ -87,7 +87,7 @@ Code gen__ring( StrC type )
);
Code body = def_execution( code(
for ( sw idx = 0; idx < num; idx++ )
for ( ssize idx = 0; idx < num; idx++ )
append( values[ idx ] );
));
@ -167,7 +167,7 @@ void gen__ring_request( StrC type, StrC dep = {} )
do_once_end
// Make sure we don't already have a request for the type.
for ( sw idx = 0; idx < GenRingRequests.num(); ++idx )
for ( ssize idx = 0; idx < GenRingRequests.num(); ++idx )
{
StrC const reqest_type = GenRingRequests[ idx ].Type;

2
test/_old/upfront/test.upfront.cpp
View File

@ -22,7 +22,7 @@ int gen_main()
gen_sanity_upfront();
gen_array( u8 );
gen_array( sw );
gen_array( ssize );
gen_buffer( u8 );