gencpp/test/Parsed/Array.Parsed.hpp

247 lines
4.8 KiB
C++
Raw Normal View History

#pragma once
#if gen_time
#include "gen.hpp"
using namespace gen;
Code gen__array_base()
{
Code array_base = parse_struct( code(
struct ArrayBase
{
struct Header
{
AllocatorInfo Allocator;
uw Capacity;
uw Num;
};
static inline
sw grow_formula( sw value )
{
return 2 * value * 8;
}
};
));
return array_base;
}
Code gen__array( s32 length, char const* type_str, sw type_size )
{
StrC tmpl = code(
struct Array_{type} : ArrayBase
{
using Type = {type};
Type* Data;
static Array_{type} init( AllocatorInfo allocator )
{
return init_reserve( allocator, grow_formula(0) );
}
static Array_{type} init_reserve( AllocatorInfo allocator, uw capacity )
{
Header* header = rcast( Header*, alloc( allocator, sizeof(Header) + sizeof(Type) ));
if ( header == nullptr )
return false;
header->Allocator = allocator;
header->Capacity = capacity;
header->Num = 0;
Array_{type} array;
array.Data = rcast( Type*, header + 1 );
return array;
}
bool append( Type const& value )
{
Header& header = get_header();
if ( header.Num == header.Capacity )
{
if ( ! grow( header.Allocator ))
return false;
}
data[ header.Num ] = value;
header.Num++;
return true;
}
Type& back()
{
Header& header = get_header();
return data[ header.Num - 1 ];
}
void clear()
{
Header& header = get_header();
header.Num = 0;
}
bool fill( uw begin, uw end, Type const& value )
{
Header& header = get_header();
if ( begin < 0 || end >= header.Num )
return false;
for ( uw idx = begin; idx < end; idx++ )
data[ idx ] = value;
return true;
}
void free()
{
Header& header = get_header();
::free( header.Allocator, & header );
}
Header& get_header()
{
return pcast( Header, Data - 1 );
}
bool grow( uw min_capacity )
{
Header& header = get_header();
uw new_capacity = grow_formula( header.Capacity );
if ( new_capacity < min_capacity )
new_capacity = min_capacity;
return set_capacity( new_capacity );
}
void pop()
{
Header& header = get_header();
assert_crash( header.Num > 0 );
header.Num--;
}
bool reserve( uw new_capacity )
{
Header& header = get_header();
if ( header.Capacity < new_capacity )
return set_capacity( new_capacity );
return true;
}
bool resize( uw num )
{
Header& header = get_header();
if ( header.Capacity < num )
if ( ! grow( num ))
return false;
header.Num = num;
return true;
}
bool set_capacity( uw new_capacity )
{
Header& header = get_header();
if ( new_capacity == header.Capacity )
return true;
if ( new_capacity < header.Num )
header.Num = new_capacity;
sw size = sizeof(Header) + sizeof(Type) * new_capacity;
Header* new_header = rcast( Header*, alloc( header.Allocator, size ));
if ( new_header == nullptr )
return false;
mem_move( new_header, & header, sizeof( Header ) + sizeof(Type) * header.Num );
new_header->Allocator = header.Allocator;
new_header->Num = header.Num;
new_header->Capacity = new_capacity;
::free( header );
*Data = new_header + 1;
return true;
}
}
);
char const* gen_from_tmpl = token_fmt( tmpl.Ptr, 1, "type", type_str );
s32 gen_from_tmpl_len = str_len( gen_from_tmpl );
Code array = parse_struct( { gen_from_tmpl_len, gen_from_tmpl } );
}
struct GenArrayRequest
{
s32 TypeLength;
char const* Type;
sw Size;
s32 DependencyLength;
char const* Dependency;
};
Array(GenArrayRequest) GenArrayRequests;
void gen__array_request( s32 type_len, char const* type_str, sw type_size, s32 dep_len, char const* dep )
{
GenArrayRequest request = { type_len, type_str, type_size, dep_len, dep };
array_append( GenArrayRequests, request );
}
#define Gen_Array( type ) gen__array_request( txt_n_len( type ), sizeof(type) )
u32 gen_array_file()
{
Builder
gen_array_file;
gen_array_file.open( "array.gen.hpp" );
GenArrayRequest* current = GenArrayRequests;
s32 left = array_count( GenArrayRequests );
while (left--)
{
GenArrayRequest const& request = * current;
Code generated_array = gen__array( request.TypeLength, request.Type, request.Size );
if ( request.Dependency )
{
char const* cmt_str = str_fmt_buf( "// Dependency for %s type", request.Type );
s32 cmt_len = str_len( cmt_str );
Code cmt = def_comment( { cmt_len, cmt_str } );
Code include = def_include( { request.DependencyLength, request.Dependency } );
gen_array_file.print( cmt );
gen_array_file.print( include );
}
gen_array_file.print( generated_array );
current++;
}
gen_array_file.write();
return 0;
}
#endif