mirror of
https://github.com/Ed94/gencpp.git
synced 2024-11-10 11:04:52 -08:00
Ed_
5e79e8ba65
Fleshed out initial version of AST::is_equal( AST* ) Setup the test directory with initial files for each major validation test.
276 lines
6.4 KiB
C++
276 lines
6.4 KiB
C++
#pragma once
|
|
|
|
#if GEN_TIME
|
|
#include "gen.hpp"
|
|
|
|
using namespace gen;
|
|
|
|
Code gen__buffer_base()
|
|
{
|
|
CodeType t_allocator_info = def_type( name(AllocatorInfo) );
|
|
|
|
Code header = def_struct( name(BufferHeader),
|
|
def_struct_body( args(
|
|
def_variable( t_allocator_info, name(Backing) )
|
|
, def_variable( t_uw, name(Capacity) )
|
|
, def_variable( t_uw, name(Num) )
|
|
)));
|
|
|
|
return def_global_body( 1, header );
|
|
}
|
|
|
|
Code gen__buffer( StrC type, sw type_size )
|
|
{
|
|
static CodeType t_allocator_info = def_type( name(AllocatorInfo));
|
|
|
|
static CodeUsing using_header = def_using( name(Header), def_type( name(BufferHeader) ) );
|
|
|
|
StrC name;
|
|
{
|
|
char const* name_str = str_fmt_buf( "Buffer_%s\0", type.Ptr );
|
|
s32 name_len = str_len( name_str );
|
|
|
|
name = { name_len, name_str };
|
|
};
|
|
|
|
CodeType t_buffer_type = def_type( name );
|
|
|
|
CodeType t_type = def_type( type );
|
|
CodeType t_type_ptr = def_type( type, __, spec_ptr );
|
|
CodeType t_type_ref = def_type( type, __, spec_ref );
|
|
|
|
CodeType t_header = def_type( name(Header) );
|
|
CodeType t_header_ptr = def_type( name(Header), __, spec_ptr );
|
|
CodeType t_header_ref = def_type( name(Header), __, spec_ref );
|
|
|
|
CodeStruct buffer = {0};
|
|
{
|
|
CodeUsing using_type = def_using( name(Type), t_type );
|
|
CodeVar data = def_variable( t_type_ptr, name(Data) );
|
|
|
|
CodeFn init;
|
|
{
|
|
CodeParam params = def_params( args(
|
|
def_param( t_allocator_info, name(allocator))
|
|
, def_param( t_sw, name(capacity))
|
|
));
|
|
|
|
Code body = def_execution( code(
|
|
Header* header = rcast( Header*, alloc( allocator, sizeof(Header) + capacity * sizeof(Type) ) );
|
|
|
|
if ( header == nullptr )
|
|
return { nullptr };
|
|
|
|
header->Backing = allocator;
|
|
header->Capacity = capacity;
|
|
header->Num = 0;
|
|
|
|
return { rcast( Type*, header + 1) };
|
|
));
|
|
|
|
init = def_function( name(init), params, t_buffer_type, body, spec_static_member );
|
|
}
|
|
|
|
CodeFn init_copy;
|
|
{
|
|
CodeParam params = def_params( args(
|
|
def_param( t_allocator_info, name(allocator))
|
|
, def_param( t_buffer_type, name(other))
|
|
));
|
|
|
|
init_copy = def_function( name(init), params, t_buffer_type
|
|
, def_execution( code(
|
|
Header& other_header = other.get_header();
|
|
Header* header = rcast( Header*, alloc( allocator, sizeof(Header) + other_header.Capacity * sizeof(Type) ) );
|
|
|
|
if ( header == nullptr )
|
|
return { nullptr };
|
|
|
|
header->Backing = allocator;
|
|
header->Capacity = other_header.Capacity;
|
|
header->Num = other_header.Num;
|
|
|
|
mem_copy( header + 1, other.Data, other_header.Num * sizeof(Type) );
|
|
return { rcast( Type*, header + 1) };
|
|
))
|
|
);
|
|
}
|
|
|
|
CodeFn append = def_function( name(append), def_param( t_type, name(value)), t_void
|
|
, def_execution( code(
|
|
Header& header = get_header();
|
|
Data[ header.Num ] = value;
|
|
header.Num++;
|
|
))
|
|
);
|
|
|
|
CodeFn appendv;
|
|
{
|
|
CodeParam params = def_params( args(
|
|
def_param( t_type_ptr, name( values))
|
|
, def_param( t_sw, name( num))
|
|
));
|
|
|
|
appendv = def_function( name(append), params, t_void
|
|
, def_execution( code(
|
|
Header& header = get_header();
|
|
|
|
GEN_ASSERT( header.Num + num <= header.Capacity);
|
|
|
|
mem_copy( Data + header.Num, values, num * sizeof( Type ) );
|
|
|
|
header.Num += num;
|
|
))
|
|
);
|
|
}
|
|
|
|
CodeFn clear = def_function( name(clear), __, t_void
|
|
, def_execution( code(
|
|
Header& header = get_header();
|
|
header.Num = 0;
|
|
))
|
|
);
|
|
|
|
CodeFn end = def_function( name(end), __, t_type_ref
|
|
, def_execution( code(
|
|
Header& header = get_header();
|
|
return Data[ header.Num - 1 ];
|
|
))
|
|
);
|
|
|
|
CodeFn free = def_function( name(free), __, t_void
|
|
, def_execution( code(
|
|
Header& header = get_header();
|
|
gen::free( header.Backing, & header );
|
|
))
|
|
);
|
|
|
|
CodeFn get_header = def_function( name(get_header), __, t_header_ref
|
|
, def_execution( code(
|
|
return * ( rcast( Header*, Data ) - 1 );
|
|
))
|
|
);
|
|
|
|
CodeFn num = def_function( name(num), __, t_sw
|
|
, def_execution( code(
|
|
return get_header().Num;
|
|
))
|
|
);
|
|
|
|
CodeFn pop = def_function( name(pop), __, t_type
|
|
, def_execution( code(
|
|
Header& header = get_header();
|
|
header.Num--;
|
|
return Data[ header.Num ];
|
|
))
|
|
);
|
|
|
|
CodeFn wipe = def_function( name(wipe), __, t_void
|
|
, def_execution( code(
|
|
Header& header = get_header();
|
|
header.Num = 0;
|
|
mem_set( Data, 0, header.Capacity * sizeof( Type ) );
|
|
))
|
|
);
|
|
|
|
CodeOpCast op_type_ptr = def_operator_cast( t_type_ptr, def_execution( code(
|
|
return Data;
|
|
)));
|
|
|
|
buffer = def_struct( name, def_struct_body( args(
|
|
using_header
|
|
, using_type
|
|
|
|
, init
|
|
, init_copy
|
|
, append
|
|
, appendv
|
|
, clear
|
|
, end
|
|
, free
|
|
, get_header
|
|
, num
|
|
, pop
|
|
, wipe
|
|
|
|
, op_type_ptr
|
|
|
|
, data
|
|
)));
|
|
}
|
|
|
|
return buffer;
|
|
}
|
|
|
|
struct GenBufferRequest
|
|
{
|
|
StrC Dependency;
|
|
StrC Type;
|
|
sw TypeSize;
|
|
};
|
|
Array<GenBufferRequest> GenBufferRequests;
|
|
|
|
void gen__buffer_request( StrC type, StrC dep = {} )
|
|
{
|
|
do_once_start
|
|
GenBufferRequests = Array<GenBufferRequest>::init( GlobalAllocator );
|
|
do_once_end
|
|
|
|
// Make sure we don't already have a request for the type.
|
|
for ( sw idx = 0; idx < GenBufferRequests.num(); ++idx )
|
|
{
|
|
StrC const reqest_type = GenBufferRequests[ idx ].Type;
|
|
|
|
if ( reqest_type.Len != type.Len )
|
|
continue;
|
|
|
|
if ( str_compare( reqest_type.Ptr, type.Ptr, reqest_type.Len ) == 0 )
|
|
return;
|
|
}
|
|
|
|
GenBufferRequest request = { dep, type};
|
|
GenBufferRequests.append( request );
|
|
}
|
|
#define gen_buffer( type ) gen__buffer_request( code(type))
|
|
|
|
u32 gen_buffer_file()
|
|
{
|
|
Builder
|
|
gen_buffer_file;
|
|
gen_buffer_file.open( "buffer.Upfront.gen.hpp" );
|
|
|
|
gen_buffer_file.print( def_include( txt("gen.hpp")) );
|
|
gen_buffer_file.print( def_using_namespace( name(gen)) );
|
|
|
|
gen_buffer_file.print( gen__buffer_base() );
|
|
|
|
GenBufferRequest* current = GenBufferRequests;
|
|
s32 left = GenBufferRequests.num();
|
|
while (left--)
|
|
{
|
|
GenBufferRequest const& request = * current;
|
|
|
|
Code generated_buffer = gen__buffer( current->Type, current->TypeSize );
|
|
|
|
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.Dependency );
|
|
|
|
gen_buffer_file.print( cmt );
|
|
gen_buffer_file.print( include );
|
|
}
|
|
|
|
gen_buffer_file.print( generated_buffer );
|
|
current++;
|
|
}
|
|
|
|
gen_buffer_file.write();
|
|
return 0;
|
|
}
|
|
|
|
#endif // GEN_TIME
|