ed/gencpp
1
0
Fork 0
mirror of https://github.com/Ed94/gencpp.git synced 2024-12-22 07:44:45 -08:00
Code Issues Packages Projects Releases Wiki Activity

HashTable non-parsed implemented.

Browse Source 
Improved the text to string macros!
This commit is contained in:
Edward R. Gonzalez 2023-07-01 00:23:40 -04:00
parent ef790fdda5
commit 4db9aadea7
9 changed files with 661 additions and 59 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
project/Bloat.hpp
View File

@ -36,6 +36,7 @@
// # define ZPL_MODULE_PARSER
#include "zpl.h"
using zpl::b32;
using zpl::s8;
using zpl::s16;
using zpl::s32;
@ -157,9 +158,9 @@ using zpl::str_len;
#define scast( Type_, Value_ ) static_cast< Type_ >( Value_ )
#define rcast( Type_, Value_ ) reinterpret_cast< Type_ >( Value_ )
#define pcast( Type_, Value_ ) ( * (Type_*)( & (Value_) ) )
#define txt_impl( Value_ ) #Value_
#define txt( Value_ ) txt_impl( Value_ )
#define txt_n_len( Value_ ) sizeof( txt_impl( Value_ ) ), txt_impl( Value_ )
#define txt_impl( ... ) #__VA_ARGS__
#define txt( ... ) txt_impl( __VA_ARGS__ )
#define txt_n_len( ... ) sizeof( txt_impl( __VA_ARGS__ ) ), txt_impl( __VA_ARGS__ )
#define do_once() \
do \
{ \
@ -513,7 +514,7 @@ char const* Msg_Invalid_Value = "INVALID VALUE PROVIDED";
return Data;
}
operator StrC()
operator StrC() const
{
return
{

46
project/gen.cpp
View File

@ -25,7 +25,6 @@ namespace gen
}
#pragma region Constants
#ifdef GEN_DEFINE_LIBRARY_CODE_CONSTANTS
Code type_ns(auto);
Code type_ns(void);
Code type_ns(int);
@ -33,6 +32,9 @@ namespace gen
Code type_ns(char);
Code type_ns(wchar_t);
#ifdef GEN_DEFINE_LIBRARY_CODE_CONSTANTS
Code type_ns(b32);
Code type_ns(s8);
Code type_ns(s16);
Code type_ns(s32);
@ -296,6 +298,7 @@ namespace gen
break;
case Untyped:
case Execution:
result.append( Content );
break;
@ -328,7 +331,6 @@ namespace gen
case Access_Private:
case Access_Protected:
case Access_Public:
result.append( indent );
result.append( Name );
break;
@ -508,10 +510,6 @@ namespace gen
}
break;
case Execution:
result.append( Content );
break;
case Export_Body:
{
result.append_fmt( "%sexport\n%s{\n", indent_str, indent_str );
@ -1107,6 +1105,8 @@ namespace gen
def_constant_code_type( wchar_t );
#ifdef GEN_DEFINE_LIBRARY_CODE_CONSTANTS
type_ns(b32) = def_type( name(b32) );
def_constant_code_type( s8 );
def_constant_code_type( s16 );
def_constant_code_type( s32 );
@ -1129,21 +1129,21 @@ namespace gen
access_private_write = ccast( Code, access_private );
access_private_write = make_code();
access_private_write->Type = ECode::Access_Private;
access_private_write->Name = get_cached_string( StrC::from("private") );
access_private_write->Name = get_cached_string( StrC::from("private:") );
access_private_write.lock();
Code&
access_protected_write = ccast( Code, access_protected );
access_protected_write = make_code();
access_protected_write->Type = ECode::Access_Protected;
access_protected_write->Name = get_cached_string( StrC::from("protected") );
access_protected_write->Name = get_cached_string( StrC::from("protected:") );
access_protected_write.lock();
Code&
access_public_write = ccast( Code, access_public );
access_public_write = make_code();
access_public_write->Type = ECode::Access_Public;
access_public_write->Name = get_cached_string( StrC::from("public") );
access_public_write->Name = get_cached_string( StrC::from("public:") );
access_public_write.lock();
module_global_fragment = make_code();
@ -2088,12 +2088,13 @@ namespace gen
switch ( body->Type )
{
case Function_Body:
case Execution:
case Untyped:
break;
default:
{
log_failure("gen::def_function: body must be either of Function_Body or Untyped type. %s", body->debug_str());
log_failure("gen::def_function: body must be either of Function_Body, Execution, or Untyped type. %s", body->debug_str());
return Code::Invalid;
}
}
@ -2193,12 +2194,6 @@ namespace gen
{
using namespace ECode;
if ( body && body->Type != Function_Body && body->Type != Untyped )
{
log_failure( "gen::def_operator: Body was provided but its not of function body type: %s", body->debug_str() );
return Code::Invalid;
}
if ( attributes && attributes->Type != Attributes )
{
log_failure( "gen::def_operator: Attributes was provided but its not of attributes type: %s", attributes->debug_str() );
@ -2227,6 +2222,20 @@ namespace gen
if ( body )
{
switch ( body->Type )
{
case Function_Body:
case Execution:
case Untyped:
break;
default:
{
log_failure("gen::def_operator: body must be either of Function_Body, Execution, or Untyped type. %s", body->debug_str());
return Code::Invalid;
}
}
result->Type = check_result == OpValidateResult::Global ?
Operator : Operator_Member;
@ -5270,7 +5279,10 @@ namespace gen
tokmap_clear( & tok_map );
return buf_size - remaining;
sw result = buf_size - remaining;
// buf[ result ] = '\0';
return result;
}
Code untyped_str( StrC content )

9
project/gen.hpp
View File

@ -866,6 +866,7 @@ namespace gen
{
local_persist thread_local
char buf[ZPL_PRINTF_MAXLEN] = { 0 };
mem_set( buf, 0, ZPL_PRINTF_MAXLEN );
va_list va;
va_start(va, fmt);
@ -1014,11 +1015,7 @@ namespace gen
# define name( Id_ ) { txt_n_len( Id_ ) }
// Same as name just used to indicate intention of literal for code instead of names.
# define code( Code_ ) { txt_n_len( Code_ ) }
# define code_args( num, ... ) num, (Code[num]){ __VA_ARGS__ }
# define enum_entry( id ) "\t" #id ",\n"
# define code( ... ) { txt_n_len( __VA_ARGS__ ) }
#pragma endregion Macros
#pragma region Constants
@ -1027,6 +1024,8 @@ namespace gen
{
// Predefined typename codes. Are set to readonly and are setup during gen::init()
extern Code type_ns( b32 );
extern Code type_ns( s8 );
extern Code type_ns( s16 );
extern Code type_ns( s32 );

61
test/NonParsed/Array.NonParsed.hpp
View File

@ -20,7 +20,7 @@ Code gen__array_base()
, def_specifiers( 2, ESpecifier::Static_Member, ESpecifier::Inline )
);
return def_global_body( code_args( 2, header, grow_formula ) );
return def_global_body( 2, header, grow_formula );
}
Code gen__array( StrC type, sw type_size )
@ -49,6 +49,10 @@ Code gen__array( StrC type, sw type_size )
Code t_type_ptr = def_type( type, __, spec_ptr );
Code t_type_ref = def_type( type, __, spec_ref );
Code t_alias = def_type( name(Type) );
Code t_alias_ptr = def_type( name(Type), __, spec_ptr );
Code t_alias_ref = def_type( name(Type), __, spec_ref );
Code t_header = def_type( name(Header) );
Code t_header_ptr = def_type( name(Header), __, spec_ptr );
Code t_header_ref = def_type( name(Header), __, spec_ref );
@ -56,7 +60,7 @@ Code gen__array( StrC type, sw type_size )
Code array;
{
Code using_type = def_using( name(Type), t_type );
Code data = def_variable( t_type_ptr, name(Data) );
Code data = def_variable( t_alias_ptr, name(Data) );
Code init;
{
@ -93,13 +97,13 @@ Code gen__array( StrC type, sw type_size )
Code append;
{
Code param_type;
if ( type_size <= 8 )
param_type = t_type;
else
param_type = t_type_ref;
// Code param_type;
// if ( type_size <= 64 )
// param_type = t_type;
// else
// param_type = t_type_ref;
append = def_function( name(append), def_param(param_type, name(value)), t_bool
append = def_function( name(append), def_param(t_alias, name(value)), t_bool
, untyped_str( code(
Header& header = get_header();
@ -124,7 +128,7 @@ Code gen__array( StrC type, sw type_size )
return Data[ header.Num - 1 ];
));
back = def_function( name(back), __, t_type_ref, body, spec_inline );
back = def_function( name(back), __, t_alias_ref, body, spec_inline );
}
Code clear = def_function( name(clear), __, t_void
@ -138,9 +142,9 @@ Code gen__array( StrC type, sw type_size )
Code fill;
{
Code params = def_params( 3
, def_param( t_uw, name(begin) )
, def_param( t_uw, name(end) )
, def_param( t_type, name(value) )
, def_param( t_uw, name(begin) )
, def_param( t_uw, name(end) )
, def_param( t_alias, name(value) )
);
Code body = untyped_str( code(
@ -185,6 +189,13 @@ Code gen__array( StrC type, sw type_size )
))
);
Code num = def_function( name(num), __, t_uw
, untyped_str( code(
return get_header().Num;
))
, spec_inline
);
Code pop;
{
Code body = untyped_str( code(
@ -197,6 +208,17 @@ Code gen__array( StrC type, sw type_size )
pop = def_function( name(pop), __, t_bool, body, spec_inline );
}
Code remove_at = def_function( name(remove_at), def_param( t_uw, name(idx)), t_void
, def_execution( code(
Header* header = & get_header();
ZPL_ASSERT( idx < header->Num );
mem_move( header + idx, header + idx + 1, sizeof( Type ) * ( header->Num - idx - 1 ) );
header->Num--;
))
, spec_inline
);
Code reserve = def_function( name(reserve), def_param( t_uw, name(new_capacity)), t_bool
, untyped_str( code(
Header& header = get_header();
@ -248,7 +270,7 @@ Code gen__array( StrC type, sw type_size )
zpl::free( header.Allocator, & header );
Data = (u8*) new_header + 1;
Data = (Type*) new_header + 1;
return true;
));
@ -256,7 +278,14 @@ Code gen__array( StrC type, sw type_size )
set_capacity = def_function( name(set_capacity), def_param( t_uw, name(new_capacity)), t_bool, body );
}
Code body = def_struct_body( 17
Code op_ptr = untyped_str( code(
operator Type*()
{
return Data;
}
));
Code body = def_struct_body( 20
, using_header
, using_type
, ct_grow_formula
@ -271,11 +300,15 @@ Code gen__array( StrC type, sw type_size )
, free
, get_header
, grow
, num
, pop
, remove_at
, reserve
, resize
, set_capacity
, op_ptr
, data
);
array = def_struct( name, body );

14
test/NonParsed/Buffer.NonParsed.hpp
View File

@ -15,7 +15,7 @@ Code gen__buffer_base()
, def_variable( t_uw, name(Num) )
));
return def_global_body( code_args( 1, header ) );
return def_global_body( 1, header );
}
Code gen__buffer( StrC type, sw type_size )
@ -97,13 +97,13 @@ Code gen__buffer( StrC type, sw type_size )
Code append;
{
Code param_type;
if ( type_size <= 8 )
param_type = t_type;
else
param_type = t_type_ref;
// Code param_type;
// if ( type_size <= 64 )
// param_type = t_type;
// else
// param_type = t_type_ref;
append = def_function( name(append), def_param( param_type, name(value)), t_void
append = def_function( name(append), def_param( t_type, name(value)), t_void
, untyped_str( code(
Header& header = get_header();
Data[ header.Num ] = value;

476
test/NonParsed/HashTable.NonParsed.hpp Normal file
View File

@ -0,0 +1,476 @@
#pragma once
#if gen_time
#include "gen.hpp"
#include "Array.NonParsed.hpp"
using namespace gen;
Code gen__hashtable_base()
{
Code hashIndex = def_variable( t_sw, name(HashIndex) );
Code entry_prev = def_variable( t_sw, name(PrevIndex) );
Code entry_index = def_variable( t_sw, name(EntryIndex) );
Code find_result = def_struct( name(HashTableFindResult), def_struct_body( 3
, hashIndex
, entry_prev
, entry_index
));
return find_result;
}
Code gen__hashtable( StrC type, sw type_size )
{
static Code t_allocator_info = def_type( name(AllocatorInfo) );
Code t_find_result = def_type( name(HashTableFindResult) );
StringCached name;
{
char const* name_str = str_fmt_buf( "HashTable_%s", type.Ptr );
s32 len = str_len( name_str );
name = get_cached_string({ len, name_str });
}
Code t_ht_type = def_type( name );
Code t_type = def_type( type );
Code t_type_ptr = def_type( type, __, spec_ptr );
Code t_type_ref = def_type( type, __, spec_ref );
// Hash table depends on array container for its entry structure.
Code t_ht_entry, ht_entry, array_ht_entry, t_array_ht_entry;
{
char const* name_str = str_fmt_buf( "HashTable_%s_Entry", type.Ptr );
s32 len = str_len( name_str );
StringCached ht_entry_name = get_cached_string({ len, name_str });
sw const entry_size = sizeof( u64 ) + sizeof( sw ) + type_size;
t_ht_entry = def_type( ht_entry_name );
ht_entry = def_struct( ht_entry_name, def_struct_body( 3
, def_variable( t_u64, name(Key))
, def_variable( t_sw, name(Next))
, def_variable( t_type, name(Value))
));
array_ht_entry = gen__array( ht_entry_name, entry_size );
t_array_ht_entry = def_type( array_ht_entry->Name );
}
Code hashtable;
{
Code using_entry = def_using( name(Entry), t_ht_entry );
Code using_array_entry = def_using( name(Array_Entry), t_array_ht_entry );
Code using_find_result = def_using( name(FindResult), t_find_result );
Code t_array_sw = def_type( name(Array_sw) );
Code t_array_entry = def_type( name(Array_Entry) );
Code hashes = def_variable( t_array_sw, name(Hashes) );
Code entries = def_variable( t_array_entry, name(Entries));
Code init;
{
char const* tmpl = txt(
<type> result = { 0 };
result.Hashes = Array_sw ::init( allocator );
result.Entries = Array_Entry::init( allocator );
return result;
);
Code body = def_execution( token_fmt( tmpl, 1, "type", name ) );
init = def_function( name(init), def_param( t_allocator_info, name(allocator)), t_ht_type, body, spec_static_member );
}
Code clear = def_function( name(clear), __, t_void
, def_execution( code(
if ( s32 idx = 0; idx < Hashes.num(), idx++ )
Hashes[ idx ] = -1;
Entries.clear();
))
);
Code destroy = def_function( name(destroy), __, t_void
, def_execution( code(
if ( Hashes )
Hashes .free();
if ( Entries )
Entries.free();
))
, spec_inline
);
Code get = def_function( name(get), def_param( t_u64, name(key)), t_type_ptr
, def_execution( code(
sw idx = find( key ).EntryIndex;
if ( idx > 0 )
return & Entries[ idx ].Value;
return nullptr;
))
);
Code using_map_proc;
{
char const* tmpl = txt(
void (*) ( u64 key, <type> value )
);
Code value = untyped_str( token_fmt( tmpl, 1, "type", t_type.to_string() ) );
using_map_proc = def_using ( name(MapProc), value);
}
Code map;
{
Code t_map_proc = def_type( name(MapProc) );
Code body = def_execution( code(
ZPL_ASSERT_NOT_NULL( map_proc );
for ( sw idx = 0; idx < Entries.num(); idx++ )
{
map_proc( Entries[ idx ].Key, Entries[ idx ].Value );
}
));
map = def_function( name(map), def_param( t_map_proc, name(map_proc) ), t_void, body );
}
Code using_map_mut_proc;
{
char const* tmpl = txt(
void (*) ( u64 key, <type> value )
);
Code value = untyped_str( token_fmt( tmpl, 1, "type", t_type_ptr.to_string() ) );
using_map_mut_proc = def_using ( name(MapMutProc), value);
}
Code map_mut;
{
Code t_map_mut_proc = def_type( name(MapMutProc));
Code body = def_execution( code(
ZPL_ASSERT_NOT_NULL( map_proc );
for ( sw idx = 0; idx < Entries.num(); idx++ )
{
map_proc( Entries[ idx ].Key, & Entries[ idx ].Value );
}
));
map_mut = def_function( name(map_mut), def_param( t_map_mut_proc, name(map_proc)), t_void, body );
}
Code grow = def_function( name(grow), __, t_void
, def_execution( code(
sw new_num = array_grow_formula( Entries.num() );
rehash( new_num );
))
, spec_inline
);
Code rehash;
{
char const* tmpl = txt(
sw idx;
sw last_added_index;
<type> new_ht = <type>::init( Hashes.get_header().Allocator );
new_ht.Hashes.resize( new_num );
new_ht.Entries.reserve( new_ht.Hashes.num() );
for ( idx = 0; idx < new_ht.Hashes.num(); ++idx )
new_ht.Hashes[ idx ] = -1;
for ( idx = 0; idx < Entries.num(); ++idx )
{
Entry& entry = Entries[ idx ];
FindResult find_result;
if ( new_ht.Hashes.num() == 0 )
new_ht.grow();
entry = Entries[ idx ];
find_result = new_ht.find( entry.Key );
last_added_index = new_ht.add_entry( entry.Key );
if ( find_result.PrevIndex < 0 )
new_ht.Hashes[ find_result.HashIndex ] = last_added_index;
else
new_ht.Entries[ find_result.PrevIndex ].Next = last_added_index;
new_ht.Entries[ last_added_index ].Next = find_result.EntryIndex;
new_ht.Entries[ last_added_index ].Value = entry.Value;
}
// <type>* old_ht = this;
// *this = new_ht;
// old_ht.destroy();
destroy();
Hashes = new_ht.Hashes;
Entries = new_ht.Entries;
);
Code body = def_execution( token_fmt( tmpl, 1, "type", name ) );
rehash = def_function( name(rehash), def_param( t_sw, name(new_num)), t_void, body, spec_inline);
}
Code rehash_fast;
{
char const* tmpl = txt(
sw idx;
for ( idx = 0; idx < Entries.num(); idx++ )
Entries[ idx ].Next = -1;
for ( idx = 0; idx < Hashes.num(); idx++ )
Hashes[ idx ] = -1;
for ( idx = 0; idx < Entries.num(); idx++ )
{
Entry* entry;
FindResult find_result;
}
);
Code body = def_execution( token_fmt( tmpl, 1, "type", name ) );
rehash_fast = def_function( name(rehash_fast), __, t_void, body );
}
Code remove = def_function( name(remove), def_param( t_u64, name(key)), t_void
, def_execution( code(
FindResult find_result = find( key);
if ( find_result.EntryIndex >= 0 )
{
Entries.remove_at( find_result.EntryIndex );
rehash_fast();
}
))
);
Code remove_entry = def_function( name(remove_entry), def_param( t_sw, name(idx)), t_void
, def_execution( code(
Entries.remove_at( idx );
))
);
Code set;
{
Code params = def_params( 2
, def_param( t_u64, name(key))
, def_param( t_type, name(value))
);
Code body = def_execution( code(
sw idx;
FindResult find_result;
if ( Hashes.num() == 0 )
grow();
find_result = find( key );
if ( find_result.EntryIndex >= 0 )
{
idx = find_result.EntryIndex;
}
else
{
idx = add_entry( key );
if ( find_result.PrevIndex >= 0 )
{
Entries[ find_result.PrevIndex ].Next = idx;
}
else
{
Hashes[ find_result.HashIndex ] = idx;
}
}
Entries[ idx ].Value = value;
if ( full() )
grow();
));
set = def_function( name(set), params, t_void, body );
}
Code slot = def_function( name(slot), def_param( t_u64, name(key)), t_sw
, def_execution( code(
for ( sw idx = 0; idx < Hashes.num(); ++idx )
if ( Hashes[ idx ] == key )
return idx;
return -1;
))
, spec_inline
);
Code add_entry = def_function( name(add_entry), def_param( t_u64, name(key)), t_sw
, def_execution( code(
sw idx;
Entry entry = { key, -1 };
idx = Entries.num();
Entries.append( entry );
return idx;
))
, spec_inline
);
Code find = def_function( name(find), def_param( t_u64, name(key)), t_find_result
, def_execution( code(
FindResult result = { -1, -1, -1 };
if ( Hashes.num() > 0 )
{
result.HashIndex = key % Hashes.num();
result.EntryIndex = Hashes[ result.HashIndex ];
while ( result.EntryIndex >= 0 )
{
if ( Entries[ result.EntryIndex ].Key == key )
break;
result.PrevIndex = result.EntryIndex;
result.EntryIndex = Entries[ result.EntryIndex ].Next;
}
}
return result;
))
);
Code full = def_function( name(full), __, t_b32
, def_execution( code(
return 0.75f * Hashes.num() < Entries.num();
))
, spec_inline
);
hashtable = def_struct( name, def_struct_body( 24
, using_entry
, using_array_entry
, using_find_result
, using_map_proc
, using_map_mut_proc
, init
, clear
, destroy
, get
, grow
, map
, map_mut
, rehash
, rehash_fast
, remove
, remove_entry
, set
, slot
, hashes
, entries
, access_protected
, add_entry
, find
, full
));
}
return def_global_body( 3, ht_entry, array_ht_entry, hashtable );
}
struct GenHashTableRequest
{
StrC Dependency;
StrC Type;
sw TypeSize;
};
Array(GenHashTableRequest) GenHashTableRequests;
void gen__hashtable_request( StrC type, sw size, StrC dep = {} )
{
do_once_start
array_init( GenHashTableRequests, g_allocator );
gen_array( sw );
do_once_end
// Make sure we don't already have a request for the type.
for ( sw idx = 0; idx < array_count( GenHashTableRequests ); ++idx )
{
StrC const reqest_type = GenHashTableRequests[ idx ].Type;
if ( reqest_type.Len != type.Len )
continue;
if ( str_compare( reqest_type.Ptr, type.Ptr, reqest_type.Len ) == 0 )
return;
}
GenHashTableRequest request = { dep, type, size};
array_append( GenHashTableRequests, request );
}
#define gen_hashtable( type ) gen__hashtable_request( { txt_n_len(type) }, sizeof( type ))
u32 gen_hashtable_file()
{
Builder
gen_buffer_file;
gen_buffer_file.open( "hashtable.gen.hpp" );
gen_buffer_file.print( def_include( StrC::from("Bloat.hpp")) );
gen_buffer_file.print( def_include( StrC::from("Array.NonParsed.hpp")) );
gen_buffer_file.print( def_include( StrC::from("array.gen.hpp")) );
gen_buffer_file.print( gen__hashtable_base());
GenHashTableRequest* current = GenHashTableRequests;
s32 left = array_count( GenHashTableRequests );
while (left--)
{
GenHashTableRequest const& request = * current;
Code generated_buffer = gen__hashtable( 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

81
test/NonParsed/Ring.NonParsed.hpp
View File

@ -35,6 +35,8 @@ Code gen__ring( StrC type, sw type_size )
Code ring;
{
Code using_type = def_using( name(Type), t_type );
Code backing = def_variable( t_allocator_info, name(Backing) );
Code capacity = def_variable( t_uw, name(Capacity) );
Code head = def_variable( t_uw, name(Head) );
@ -70,9 +72,84 @@ Code gen__ring( StrC type, sw type_size )
init = def_function( name(init), params, t_ring_type, body, spec_static_member );
}
ring = def_struct( name, def_struct_body( 6,
Code append = def_function( name(append), def_param( t_type, name(value)), t_void
, untyped_str( code(
Buffer[ Head ] = value;
Head = ( Head + 1 ) % Capacity;
if ( Head == Tail )
Tail = ( Tail + 1 ) % Capacity;
))
, spec_inline
);
Code appendv;
{
Code params = def_params( 2
, def_param( t_type_ptr, name(values))
, def_param( t_sw, name(num))
);
Code body = untyped_str( code(
for ( sw idx = 0; idx < num; idx++ )
append( values[ idx ] );
));
appendv = def_function( name(append), params, t_void, body, spec_inline );
}
Code empty = def_function( name(empty), __, t_bool
, def_execution( code(
return Head == Tail;
))
, spec_inline
);
Code free = def_function( name(free), __, t_void
, def_execution( code(
Buffer.free();
))
, spec_inline
);
Code full = def_function( name(full), __, t_bool
, def_execution( code(
return (Head + 1) % Capacity == Tail;
))
, spec_inline
);
Code get = def_function( name(get), __, t_type_ref
, def_execution( code(
Type& data = Buffer[ Tail ];
Tail = ( Tail + 1 ) % Capacity;
return data;
))
);
Code wipe = def_function( name(wipe), __, t_void
, def_execution( code(
Head = 0;
Tail = 0;
Buffer.wipe();
))
, spec_inline
);
ring = def_struct( name, def_struct_body( 14,
using_type,
init,
append,
appendv,
empty,
free,
full,
get,
wipe,
backing,
capacity,
head,
@ -110,7 +187,7 @@ void gen__ring_request( StrC type, sw size, StrC dep = {} )
return;
}
// Ring definition depends on a buffer definition.
// Ring definition depends on a array and buffer definition.
gen__buffer_request( type, size, dep );
GenRingRequest request = { dep, type, size};

20
test/NonParsed/Sanity.hpp
View File

@ -53,10 +53,10 @@ u32 gen_sanity()
Code fwd = def_enum( name(ETestEnum), NoCode, t_u8 );
Code def;
{
Code body = untyped_str( StrC::from(
enum_entry( A )
enum_entry( B )
enum_entry( C )
Code body = untyped_str( code(
A,
B,
C
));
def = def_enum( name(ETestEnum), body, t_u8 );
@ -162,10 +162,10 @@ u32 gen_sanity()
Code bitflagtest;
{
Code body = def_enum_body( 1, untyped_str( StrC::from(
enum_entry( A = 1 << 0 )
enum_entry( B = 1 << 1 )
enum_entry( C = 1 << 2 )
Code body = def_enum_body( 1, untyped_str( code(
A = 1 << 0,
B = 1 << 1,
C = 1 << 2
)));
bitflagtest = def_enum( name(EBitFlagtest), body, t_u8, EnumClass );
}
@ -173,10 +173,10 @@ u32 gen_sanity()
Code op_fwd, op_or;
{
Code params = def_params( code_args( 2,
Code params = def_params( 2,
def_param( t_bitflag, name(a) ),
def_param( t_bitflag, name(b) )
));
);
op_fwd = def_operator( EOperator::BOr, params, t_bitflag );
op_or = def_operator( EOperator::BOr, params, t_bitflag, untyped_str( code(

4
test/test.cpp
View File

@ -1,6 +1,7 @@
#include "Bloat.cpp"
#include "NonParsed\Array.NonParsed.hpp"
#include "NonParsed\Buffer.NonParsed.hpp"
#include "NonParsed\HashTable.NonParsed.hpp"
#include "NonParsed\Ring.NonParsed.hpp"
#include "NonParsed\Sanity.hpp"
@ -23,10 +24,13 @@ int gen_main()
gen_buffer( u8 );
gen_hashtable( u32 );
gen_ring( s16 );
gen_array_file();
gen_buffer_file();
gen_hashtable_file();
gen_ring_file();
gen::deinit();