Compare commits

..

5 Commits

Author SHA1 Message Date
Ed_
ed0c0422ad Looking into what the library's convention for enums will be.
Most likely will just reduce them to C-enums with underlying type.
Otherwise there has to be a mechanism to drop the defs down to them anyways, and eliminate the namespace wraps.
2024-12-01 05:30:37 -05:00
Ed_
e5acac1d18 String member definitions not longer used in the base project 2024-12-01 03:06:30 -05:00
Ed_
c7b072266f progress on c_library.cpp 2024-12-01 01:40:31 -05:00
Ed_
a96d03eaed brought over the generators of array and hashtable for c-lib gen
From the old genc repo. Still need to fully check that its code is up to date
2024-12-01 01:40:14 -05:00
Ed_
0b4ccac8f9 Removed usage of hashtable member procs 2024-12-01 01:39:21 -05:00
29 changed files with 1565 additions and 719 deletions

View File

@ -39,7 +39,8 @@
"raylib.h": "c",
"*.m": "cpp",
"atomic": "cpp",
"gen.h": "c"
"gen.h": "c",
"string_ops.hpp": "c"
},
"C_Cpp.intelliSenseEngineFallback": "disabled",
"mesonbuild.configureOnOpen": true,

View File

@ -1,6 +1,7 @@
#define GEN_DEFINE_LIBRARY_CODE_CONSTANTS
#define GEN_ENFORCE_STRONG_CODE_TYPES
#define GEN_EXPOSE_BACKEND
#define GEN_SUPPORT_CPP_MEMBER_FEATURES 1
#include "../project/gen.cpp"
#include "helpers/push_ignores.inline.hpp"
@ -18,6 +19,8 @@ GEN_NS_END
#include "components/memory.fixed_arena.hpp"
#include "components/misc.hpp"
#include "components/containers.array.hpp"
#include "components/containers.hashtable.hpp"
using namespace gen;
@ -114,6 +117,14 @@ int gen_main()
Code basic_types = scan_file( project_dir "dependencies/basic_types.hpp" );
Code debug = scan_file( project_dir "dependencies/debug.hpp" );
header.print_fmt( roll_own_dependencies_guard_start );
header.print( platform );
header.print_fmt( "\nGEN_NS_BEGIN\n" );
header.print( macros );
header.print( basic_types );
header.print( debug );
CodeBody parsed_memory = parse_file( project_dir "dependencies/memory.hpp" );
CodeBody memory = def_body(ECode::Struct_Body);
for ( Code entry = parsed_memory.begin(); entry != parsed_memory.end(); ++ entry )
@ -164,7 +175,12 @@ int gen_main()
break;
case ECode::Preprocess_If:
{
ignore_preprocess_cond_block(txt("GEN_SUPPORT_CPP_MEMBER_FEATURES"), entry, memory );
ignore_preprocess_cond_block(txt("GEN_SUPPORT_CPP_MEMBER_FEATURES"), entry, parsed_memory );
}
break;
case ECode::Preprocess_IfDef:
{
ignore_preprocess_cond_block(txt("GEN_INTELLISENSE_DIRECTIVES"), entry, parsed_memory );
}
break;
case ECode::Preprocess_Pragma:
@ -179,14 +195,58 @@ int gen_main()
}
}
header.print_fmt( roll_own_dependencies_guard_start );
header.print( platform );
header.print_fmt( "\nGEN_NS_BEGIN\n" );
header.print( macros );
header.print( basic_types );
header.print( debug );
header.print( memory );
Code string_ops = scan_file( project_dir "dependencies/string_ops.hpp" );
header.print( string_ops );
CodeBody printing_parsed = parse_file( project_dir "dependencies/printing.hpp" );
CodeBody printing = def_body(ECode::Struct_Body);
for ( Code entry = printing_parsed.begin(); entry != printing_parsed.end(); ++ entry )
{
switch (entry->Type)
{
case ECode::Preprocess_IfDef:
{
ignore_preprocess_cond_block(txt("GEN_INTELLISENSE_DIRECTIVES"), entry, printing_parsed );
}
}
if (entry->Type == ECode::Variable &&
contains(entry->Name, txt("Msg_Invalid_Value")))
{
CodeDefine define = def_define(entry->Name, entry->Value->Content);
printing.append(define);
continue;
}
printing.append(entry);
}
header.print(printing);
CodeBody parsed_containers = parse_file( project_dir "dependencies/containers.hpp" );
CodeBody containers = def_body(ECode::Struct_Body);
for ( Code entry = parsed_containers.begin(); entry != parsed_containers.end(); ++ entry )
{
switch ( entry->Type )
{
case ECode::Preprocess_Pragma:
{
bool found = false;
found = swap_pragma_region_implementation( txt("Array"), gen_array_base, entry, containers);
if (found) break;
found = swap_pragma_region_implementation( txt("Hashtable"), gen_hashtable_base, entry, containers);
if (found) break;
containers.append(entry);
}
break;
}
}
header.print(containers);
}
header.print( pop_ignores );

View File

@ -0,0 +1,295 @@
#pragma once
#include "../project/gen.hpp"
using namespace gen;
CodeBody gen_array_base()
{
CodeTypedef td_header = parse_typedef( code( typedef struct ArrayHeader ArrayHeader; ));
CodeStruct header = parse_struct( code(
struct ArrayHeader
{
AllocatorInfo Allocator;
usize Capacity;
usize Num;
};
));
// Code grow_formula = untyped_str( txt( "#define gen_array_grow_formula( value ) ( 2 * value + 8 )\n" ));
Code get_header = untyped_str( txt( "#define array_get_header( Type, self ) ( (ArrayHeader*)( self ) - 1)\n" ));
return def_global_body( args( td_header, header, get_header ) );
};
CodeBody gen_array( StrC type, StrC array_name )
{
String array_type = String::fmt_buf( GlobalAllocator, "%.*s", array_name.Len, array_name.Ptr );
String fn = String::fmt_buf( GlobalAllocator, "%.*s", array_name.Len, array_name.Ptr );
str_to_lower(fn.Data);
#pragma push_macro( "GEN_ASSERT" )
#undef GEN_ASSERT
CodeBody result = parse_global_body( token_fmt( "array_type", (StrC)array_type, "fn", (StrC)fn, "type", (StrC)type
, stringize(
typedef <type>* <array_type>;
<array_type> <fn>_init ( AllocatorInfo allocator );
<array_type> <fn>_init_reserve ( AllocatorInfo allocator, usize capacity );
bool <fn>_append ( <array_type>* self, <type> value );
bool <fn>_append_items ( <array_type>* self, <type>* items, usize item_num );
bool <fn>_append_at ( <array_type>* self, <type> item, usize idx );
bool <fn>_append_items_at( <array_type>* self, <type>* items, usize item_num, usize idx );
<type>* <fn>_back ( <array_type> self );
void <fn>_clear ( <array_type> self );
bool <fn>_fill ( <array_type> self, usize begin, usize end, <type> value );
void <fn>_free ( <array_type> self );
bool <fn>_grow ( <array_type>* self, usize min_capacity );
usize <fn>_num ( <array_type> self );
<type> <fn>_pop ( <array_type> self );
bool <fn>_reserve ( <array_type>* self, usize new_capacity );
bool <fn>_resize ( <array_type>* self, usize num );
bool <fn>_set_capacity ( <array_type>* self, usize new_capacity );
<array_type> <fn>_init( AllocatorInfo allocator )
{
return <fn>_init_reserve( allocator, array_grow_formula( 0 ) );
}
<array_type> <fn>_init_reserve( AllocatorInfo allocator, usize capacity )
{
ArrayHeader* header = cast(ArrayHeader*, alloc( allocator, sizeof(ArrayHeader) + sizeof(<type>) * capacity ) );
if ( header == NULL )
return NULL;
header->Allocator = allocator;
header->Capacity = capacity;
header->Num = 0;
return cast( <type>*, header + 1 );
}
bool <fn>_append( <array_type>* self, <type> value )
{
ArrayHeader* header = get_header( * self );
if ( header->Num == header->Capacity )
{
if ( ! <fn>_grow( self, header->Capacity))
return false;
header = get_header( * self );
}
(* self)[ header->Num ] = value;
header->Num++;
return true;
}
bool <fn>_append_items( <array_type>* self, <type>* items, usize item_num )
{
ArrayHeader* header = get_header( * self );
if ( header->Num + item_num > header->Capacity )
{
if ( ! <fn>_grow( self, header->Capacity + item_num ))
return false;
header = get_header( * self );
}
mem_copy( (* self) + header->Num, items, sizeof(<type>) * item_num );
header->Num += item_num;
return true;
}
bool <fn>_append_at( <array_type>* self, <type> item, usize idx )
{
ArrayHeader* header = get_header( * self );
if ( idx >= header->Num )
idx = header->Num - 1;
if ( idx < 0 )
idx = 0;
if ( header->Capacity < header->Num + 1 )
{
if ( ! <fn>_grow( self, header->Capacity + 1 ) )
return false;
header = get_header( * self );
}
<array_type> target = (* self) + idx;
mem_move( target + 1, target, (header->Num - idx) * sizeof(<type>) );
header->Num++;
return true;
}
bool <fn>_append_items_at( <array_type>* self, <type>* items, usize item_num, usize idx )
{
ArrayHeader* header = get_header( * self );
if ( idx >= header->Num )
{
return <fn>_append_items( self, items, item_num );
}
if ( item_num > header->Capacity )
{
if ( ! <fn>_grow( self, item_num + header->Capacity ) )
return false;
header = get_header( * self );
}
<type>* target = (* self) + idx + item_num;
<type>* src = (* self) + idx;
mem_move( target, src, (header->Num - idx) * sizeof(<type>) );
mem_copy( src, items, item_num * sizeof(<type>) );
header->Num += item_num;
return true;
}
<type>* <fn>_back( <array_type> self )
{
ArrayHeader* header = get_header( self );
if ( header->Num == 0 )
return NULL;
return self + header->Num - 1;
}
void <fn>_clear( <array_type> self )
{
ArrayHeader* header = get_header( self );
header->Num = 0;
}
bool <fn>_fill( <array_type> self, usize begin, usize end, <type> value )
{
ArrayHeader* header = get_header( self );
if ( begin < 0 || end >= header->Num )
return false;
for ( ssize idx = begin; idx < end; idx ++ )
self[ idx ] = value;
return true;
}
void <fn>_free( <array_type> self )
{
ArrayHeader* header = get_header( self );
free( header->Allocator, header );
self = NULL;
}
bool <fn>_grow( <array_type>* self, usize min_capacity )
{
ArrayHeader* header = get_header( *self );
usize new_capacity = array_grow_formula( header->Capacity );
if ( new_capacity < min_capacity )
new_capacity = min_capacity;
return <fn>_set_capacity( self, new_capacity );
}
usize <fn>_num( <array_type> self )
{
return get_header(self)->Num;
}
<type> <fn>_pop( <array_type> self )
{
ArrayHeader* header = get_header( self );
GEN_ASSERT( header->Num > 0 );
<type> result = self[ header->Num - 1 ];
header->Num--;
return result;
}
void <fn>_remove_at( <array_type> self, usize idx )
{
ArrayHeader* header = get_header( self );
GEN_ASSERT( idx < header->Num );
mem_move( self + idx, self + idx + 1, sizeof( <type> ) * ( header->Num - idx - 1 ) );
header->Num--;
}
bool <fn>_reserve( <array_type>* self, usize new_capacity )
{
ArrayHeader* header = get_header( * self );
if ( header->Capacity < new_capacity )
return <fn>_set_capacity( self, new_capacity );
return true;
}
bool <fn>_resize( <array_type>* self, usize num )
{
ArrayHeader* header = get_header( * self );
if ( header->Capacity < num )
{
if ( ! <fn>_grow( self, num ) )
return false;
header = get_header( * self );
}
header->Num = num;
return true;
}
bool <fn>_set_capacity( <array_type>* self, usize new_capacity )
{
ArrayHeader* header = get_header( * self );
if ( new_capacity == header->Capacity )
return true;
if ( new_capacity < header->Num )
header->Num = new_capacity;
usize size = sizeof( ArrayHeader ) + sizeof( <type> ) * new_capacity;
ArrayHeader* new_header = cast( ArrayHeader*, alloc( header->Allocator, size ));
if ( new_header == NULL )
return false;
mem_move( new_header, header, sizeof( ArrayHeader ) + sizeof( <type> ) * header->Num );
free( header->Allocator, & header );
new_header->Capacity = new_capacity;
* self = cast( <type>*, new_header + 1 );
return true;
}
)));
#pragma pop_macro( "GEN_ASSERT" )
return def_global_body( args(
def_pragma( to_str( str_fmt_buf( "region %S", array_type ))),
fmt_newline,
result,
fmt_newline,
def_pragma( to_str( str_fmt_buf( "endregion %S", array_type ))),
fmt_newline
));
};
// CodeBody gen_

View File

@ -0,0 +1,354 @@
#pragma once
#include "../project/gen.hpp"
#include "containers.array.hpp"
using namespace gen;
CodeBody gen_hashtable_base()
{
return parse_global_body( code(
typedef struct HT_FindResult HT_FindResult;
struct HT_FindResult
{
ssize HashIndex;
ssize PrevIndex;
ssize EntryIndex;
};
));
}
CodeBody gen_hashtable( StrC type, StrC hashtable_name )
{
String
fn = String::make_reserve( GlobalAllocator, hashtable_name.Len + sizeof("gen") );
fn.append_fmt( "%.*s", hashtable_name.Len, hashtable_name.Ptr );
str_to_lower(fn.Data);
String
tbl_type = String::make_reserve( GlobalAllocator, hashtable_name.Len + sizeof("gen") );
tbl_type.append_fmt( "%.*s", hashtable_name.Len, hashtable_name.Ptr );
String name_lower = String::make( GlobalAllocator, hashtable_name );
str_to_lower( name_lower.Data );
String hashtable_entry = String::fmt_buf( GlobalAllocator, "HTE_%.*s", hashtable_name.Len, hashtable_name.Ptr );
String entry_array_name = String::fmt_buf( GlobalAllocator, "Arr_HTE_%.*s", hashtable_name.Len, hashtable_name.Ptr );
String entry_array_fn_ns = String::fmt_buf( GlobalAllocator, "arr_hte_%.*s", name_lower.length(), name_lower.Data );
CodeBody hashtable_types = parse_global_body( token_fmt(
"type", (StrC) type,
"tbl_name", (StrC) hashtable_name,
"tbl_type", (StrC) tbl_type,
stringize(
typedef struct HTE_<tbl_name> HTE_<tbl_name>;
struct HTE_<tbl_name>
{
u64 Key;
ssize Next;
<type> Value;
};
typedef void (* <tbl_type>_MapProc) ( <tbl_type> self, u64 key, <type> value );
typedef void (* <tbl_type>_MapMutProc) ( <tbl_type> self, u64 key, <type>* value );
)));
CodeBody entry_array = gen_array( hashtable_entry, entry_array_name );
#pragma push_macro( "GEN_ASSERT" )
#pragma push_macro( "GEN_ASSERT_NOT_NULL" )
#undef GEN_ASSERT
#undef GEN_ASSERT_NOT_NULL
CodeBody hashtable_def = parse_global_body( token_fmt(
"type", (StrC) type,
"tbl_name", (StrC) hashtable_name,
"tbl_type", (StrC) tbl_type,
"fn", (StrC) fn,
"entry_type", (StrC) hashtable_entry,
"array_entry", (StrC) entry_array_name,
"fn_array", (StrC) entry_array_fn_ns,
stringize(
typedef struct <tbl_type> <tbl_type>;
struct <tbl_type>
{
Array_ssize Hashes;
<array_entry> Entries;
};
<tbl_type> <fn>_make ( AllocatorInfo allocator );
<tbl_type> <fn>_make_reserve( AllocatorInfo allocator, ssize num );
void <fn>_clear ( <tbl_type> self );
void <fn>_destroy ( <tbl_type> self );
<type>* <fn>_get ( <tbl_type> self, u64 key );
void <fn>_map ( <tbl_type> self, <tbl_type>_MapProc map_proc );
void <fn>_map_mut ( <tbl_type> self, <tbl_type>_MapMutProc map_proc );
void <fn>_grow ( <tbl_type>* self );
void <fn>_rehash ( <tbl_type>* self, ssize new_num );
void <fn>_rehash_fast ( <tbl_type> self );
void <fn>_remove ( <tbl_type> self, u64 key );
void <fn>_remove_entry( <tbl_type> self, ssize idx );
void <fn>_set ( <tbl_type>* self, u64 key, <type> value );
ssize <fn>_slot ( <tbl_type> self, u64 key );
ssize <fn>__add_entry( <tbl_type> self, u64 key );
HT_FindResult <fn>__find ( <tbl_type> self, u64 key );
b32 <fn>__full ( <tbl_type> self );
<tbl_type> <fn>_make( AllocatorInfo allocator )
{
<tbl_type>
result = { NULL, NULL };
result.Hashes = array_ssize_make( allocator );
result.Entries = <fn_array>_make( allocator );
return result;
}
<tbl_type> <fn>_make_reserve( AllocatorInfo allocator, ssize num )
{
<tbl_type>
result = { NULL, NULL };
result.Hashes = array_ssize_make_reserve( allocator, num );
result.Entries = <fn_array>_make_reserve( allocator, num );
return result;
}
void <fn>_clear( <tbl_type> self )
{
for ( ssize idx = 0; idx < array_header( self.Hashes )->Num; idx++ )
self.Hashes[idx] = -1;
array_ssize_clear( self.Hashes );
<fn_array>_clear( self.Entries );
}
void <fn>_destroy( <tbl_type> self )
{
if ( self.Hashes && self.Entries )
{
array_ssize_free( self.Hashes );
<fn_array>_free( self.Entries );
}
}
<type>* <fn>_get( <tbl_type> self, u64 key )
{
ssize idx = <fn>__find( self, key ).EntryIndex;
if ( idx > 0 )
return & self.Entries[idx].Value;
return NULL;
}
void <fn>_map( <tbl_type> self, <tbl_type>_MapProc map_proc )
{
GEN_ASSERT_NOT_NULL( map_proc );
for ( ssize idx = 0; idx < array_header( self.Entries )->Num; idx++ )
{
map_proc( self, self.Entries[idx].Key, self.Entries[idx].Value );
}
}
void <fn>_map_mut( <tbl_type> self, <tbl_type>_MapMutProc map_proc )
{
GEN_ASSERT_NOT_NULL( map_proc );
for ( ssize idx = 0; idx < array_header( self.Entries )->Num; idx++ )
{
map_proc( self, self.Entries[idx].Key, & self.Entries[idx].Value );
}
}
void <fn>_grow( <tbl_type>* self )
{
ssize new_num = array_grow_formula( array_header( self->Entries )->Num );
<fn>_rehash( self, new_num );
}
void <fn>_rehash( <tbl_type>* self, ssize new_num )
{
ssize idx;
ssize last_added_index;
ArrayHeader* old_hash_header = array_header( self->Hashes );
ArrayHeader* old_entries_header = array_header( self->Entries );
<tbl_type> new_tbl = <fn>_make_reserve( old_hash_header->Allocator, old_hash_header->Num );
ArrayHeader* new_hash_header = array_header( new_tbl.Hashes );
for ( idx = 0; idx < new_hash_header->Num; idx++ )
new_tbl.Hashes[idx] = -1;
for ( idx = 0; idx < old_entries_header->Num; idx++ )
{
<entry_type>* entry;
HT_FindResult find_result;
if ( new_hash_header->Num == 0 )
<fn>_grow( & new_tbl );
entry = & self->Entries[ idx ];
find_result = <fn>__find( new_tbl, entry->Key );
last_added_index = <fn>__add_entry( new_tbl, entry->Key );
if ( find_result.PrevIndex < 0 )
new_tbl.Hashes[ find_result.HashIndex ] = last_added_index;
else
new_tbl.Entries[ find_result.PrevIndex ].Next = last_added_index;
new_tbl.Entries[ last_added_index ].Next = find_result.EntryIndex;
new_tbl.Entries[ last_added_index ].Value = entry->Value;
}
<fn>_destroy( *self );
* self = new_tbl;
}
void <fn>_rehash_fast( <tbl_type> self )
{
ssize idx;
for ( idx = 0; idx < array_header( self.Entries )->Num; idx++ )
self.Entries[ idx ].Next = -1;
for ( idx = 0; idx < array_header( self.Hashes )->Num; idx++ )
self.Hashes[ idx ] = -1;
for ( idx = 0; idx < array_header( self.Entries )->Num; idx++ )
{
<entry_type>* entry;
HT_FindResult find_result;
entry = & self.Entries[ idx ];
find_result = <fn>__find( self, entry->Key );
if ( find_result.PrevIndex < 0 )
self.Hashes[ find_result.HashIndex ] = idx;
else
self.Entries[ find_result.PrevIndex ].Next = idx;
}
}
void <fn>_remove( <tbl_type> self, u64 key )
{
HT_FindResult find_result = <fn>__find( self, key );
if ( find_result.EntryIndex >= 0 )
{
<fn_array>_remove_at( self.Entries, find_result.EntryIndex );
<fn>_rehash_fast( self );
}
}
void <fn>_remove_entry( <tbl_type> self, ssize idx )
{
<fn_array>_remove_at( self.Entries, idx );
}
void <fn>_set( <tbl_type>* self, u64 key, <type> value )
{
ssize idx;
HT_FindResult find_result;
if ( array_header( self->Hashes )->Num == 0 )
<fn>_grow( self );
find_result = <fn>__find( * self, key );
if ( find_result.EntryIndex >= 0 )
{
idx = find_result.EntryIndex;
}
else
{
idx = <fn>__add_entry( * self, key );
if ( find_result.PrevIndex >= 0 )
{
self->Entries[ find_result.PrevIndex ].Next = idx;
}
else
{
self->Hashes[ find_result.HashIndex ] = idx;
}
}
self->Entries[ idx ].Value = value;
if ( <fn>__full( * self ) )
<fn>_grow( self );
}
ssize <fn>_slot( <tbl_type> self, u64 key )
{
for ( ssize idx = 0; idx < array_header( self.Hashes )->Num; ++idx )
if ( self.Hashes[ idx ] == key )
return idx;
return -1;
}
ssize <fn>__add_entry( <tbl_type> self, u64 key )
{
ssize idx;
<entry_type> entry = { key, -1 };
idx = array_header( self.Entries )->Num;
<fn_array>_append( & self.Entries, entry );
return idx;
}
HT_FindResult <fn>__find( <tbl_type> self, u64 key )
{
HT_FindResult result = { -1, -1, -1 };
ArrayHeader* hash_header = array_header( self.Hashes );
if ( hash_header->Num > 0 )
{
result.HashIndex = key % hash_header->Num;
result.EntryIndex = self.Hashes[ result.HashIndex ];
while ( result.EntryIndex >= 0 )
{
if ( self.Entries[ result.EntryIndex ].Key == key )
break;
result.PrevIndex = result.EntryIndex;
result.EntryIndex = self.Entries[ result.EntryIndex ].Next;
}
}
return result;
}
b32 <fn>__full( <tbl_type> self )
{
ArrayHeader* hash_header = array_header( self.Hashes );
ArrayHeader* entries_header = array_header( self.Entries );
return 0.75f * hash_header->Num < entries_header->Num;
}
)));
#pragma pop_macro( "GEN_ASSERT" )
#pragma pop_macro( "GEN_ASSERT_NOT_NULL" )
char const* cmt_str = str_fmt_buf( "Name: %.*s Type: %.*s"
, tbl_type.length(), tbl_type.Data
, type.Len, type.Ptr );
return def_global_body(args(
def_pragma( to_str( str_fmt_buf( "region %S", tbl_type ))),
fmt_newline,
hashtable_types,
fmt_newline,
entry_array,
hashtable_def,
fmt_newline,
def_pragma( to_str( str_fmt_buf( "endregion %S", tbl_type ))),
fmt_newline
));
}

View File

@ -6,6 +6,7 @@ using namespace gen;
CodeBody gen_fixed_arenas()
{
CodeBody result = def_body(ECode::Global_Body);
result.append(def_pragma(txt("region FixedArena")));
char const* template_struct = stringize(
struct FixedArena_<Name>
@ -115,5 +116,7 @@ CodeBody gen_fixed_arenas()
)"
)));
result.append(def_pragma(txt("endregion FixedArena")));
return result;
}

View File

@ -11,7 +11,7 @@ b32 ignore_preprocess_cond_block( StrC cond_sig, Code& entry_iter, CodeBody& bod
if ( cond->Content.contains(cond_sig) )
{
s32 depth = 1;
++ entry_iter; for(b32 continue_for = true; continue_for && entry_iter != body.end(); ++ entry_iter) switch
++ entry_iter; for(b32 continue_for = true; continue_for && entry_iter != body.end(); ) switch
(entry_iter->Type) {
case ECode::Preprocess_If:
case ECode::Preprocess_IfDef:
@ -24,24 +24,30 @@ b32 ignore_preprocess_cond_block( StrC cond_sig, Code& entry_iter, CodeBody& bod
depth --;
if (depth == 0) {
continue_for = false;
break;
}
}
break;
default:
++ entry_iter;
break;
}
}
return entry_iter != body.end();
}
void swap_pragma_region_implementation( StrC region_name, SwapContentProc* swap_content, Code& entry_iter, CodeBody& body )
bool swap_pragma_region_implementation( StrC region_name, SwapContentProc* swap_content, Code& entry_iter, CodeBody& body )
{
bool found = false;
CodePragma possible_region = entry_iter.cast<CodePragma>();
String region_sig = string_fmt_buf(GlobalAllocator, "region %s", region_name.Ptr);
String endregion_sig = string_fmt_buf(GlobalAllocator, "endregion %s", region_name.Ptr);
if ( possible_region->Content.contains(region_sig))
{
body.append(possible_region);
found = true;
// body.append(possible_region);
body.append(swap_content());
++ entry_iter; for(b32 continue_for = true; continue_for; ++entry_iter) switch
@ -50,12 +56,13 @@ void swap_pragma_region_implementation( StrC region_name, SwapContentProc* swap_
{
CodePragma possible_end_region = entry_iter.cast<CodePragma>();
if ( possible_end_region->Content.contains(endregion_sig) ) {
body.append(possible_end_region);
// body.append(possible_end_region);
continue_for = false;
}
}
break;
}
body.append(entry_iter);
}
body.append(entry_iter);
return found;
}

View File

@ -13,7 +13,7 @@ Builder Builder::open( char const* path )
return result;
}
result.Buffer = String::make_reserve( GlobalAllocator, Builder_StrBufferReserve );
result.Buffer = string_make_reserve( GlobalAllocator, Builder_StrBufferReserve );
// log_fmt("$Builder - Opened file: %s\n", result.File.filename );
return result;
@ -21,7 +21,7 @@ Builder Builder::open( char const* path )
void Builder::pad_lines( s32 num )
{
Buffer.append( "\n" );
append( Buffer, "\n" );
}
void Builder::print( Code code )
@ -29,7 +29,7 @@ void Builder::print( Code code )
String str = code->to_string();
// const ssize len = str.length();
// log_fmt( "%s - print: %.*s\n", File.filename, len > 80 ? 80 : len, str.Data );
Buffer.append( str );
append( Buffer, str );
}
void Builder::print_fmt( char const* fmt, ... )
@ -43,17 +43,17 @@ void Builder::print_fmt( char const* fmt, ... )
va_end( va );
// log_fmt( "$%s - print_fmt: %.*s\n", File.filename, res > 80 ? 80 : res, buf );
Buffer.append( buf, res );
append( Buffer, buf, res );
}
void Builder::write()
{
b32 result = file_write( & File, Buffer, Buffer.length() );
b32 result = file_write( & File, Buffer, length(Buffer) );
if ( result == false )
log_failure("gen::File::write - Failed to write to file: %s\n", file_name( & File ) );
log_fmt( "Generated: %s\n", File.filename );
file_close( & File );
Buffer.free();
free(Buffer);
}

View File

@ -23,9 +23,9 @@ Code scan_file( char const* path )
GEN_FATAL("scan_file: %s is empty", path );
}
String str = String::make_reserve( GlobalAllocator, fsize );
String str = string_make_reserve( GlobalAllocator, fsize );
file_read( & file, str, fsize );
str.get_header().Length = fsize;
get_header(str).Length = fsize;
// Skip GEN_INTELLISENSE_DIRECTIVES preprocessor blocks
// Its designed so that the directive should be the first thing in the file.
@ -97,12 +97,12 @@ Code scan_file( char const* path )
if ( (scanner + 2) >= ( str.Data + fsize ) )
{
mem_move( str, scanner, left );
str.get_header().Length = left;
get_header(str).Length = left;
break;
}
mem_move( str, scanner, left );
str.get_header().Length = left;
get_header(str).Length = left;
break;
}

View File

@ -1,6 +1,7 @@
#define GEN_DEFINE_LIBRARY_CODE_CONSTANTS
#define GEN_ENFORCE_STRONG_CODE_TYPES
#define GEN_EXPOSE_BACKEND
#define GEN_SUPPORT_CPP_MEMBER_FEATURES 0
#include "gen.cpp"
#include "helpers/push_ignores.inline.hpp"
@ -24,20 +25,20 @@ constexpr char const* generation_notice =
void format_file( char const* path )
{
String resolved_path = String::make(GlobalAllocator, to_str(path));
String resolved_path = string_make(GlobalAllocator, to_str(path));
String style_arg = String::make(GlobalAllocator, txt("-style=file:"));
style_arg.append("../scripts/.clang-format ");
String style_arg = string_make(GlobalAllocator, txt("-style=file:"));
append( style_arg, "../scripts/.clang-format ");
// Need to execute clang format on the generated file to get it to match the original.
#define clang_format "clang-format "
#define cf_format_inplace "-i "
#define cf_verbose "-verbose "
String command = String::make( GlobalAllocator, clang_format );
command.append( cf_format_inplace );
command.append( cf_verbose );
command.append( style_arg );
command.append( resolved_path );
String command = string_make( GlobalAllocator, clang_format );
append( command, cf_format_inplace );
append( command, cf_verbose );
append( command, style_arg );
append( command, resolved_path );
log_fmt("\tRunning clang-format on file:\n");
system( command );
log_fmt("\tclang-format finished reformatting.\n");

View File

@ -9,16 +9,16 @@ Code Code::Invalid;
// This serializes all the data-members in a "debug" format, where each member is printed with its associated value.
char const* AST::debug_str()
{
String result = String::make_reserve( GlobalAllocator, kilobytes(1) );
String result = string_make_reserve( GlobalAllocator, kilobytes(1) );
if ( Parent )
result.append_fmt( "\n\tParent : %S %S", Parent->type_str(), Name ? Name : "" );
append_fmt( result, "\n\tParent : %S %S", Parent->type_str(), Name ? Name : "" );
else
result.append_fmt( "\n\tParent : %S", "Null" );
append_fmt( result, "\n\tParent : %S", "Null" );
result.append_fmt( "\n\tName : %S", Name ? Name : "Null" );
result.append_fmt( "\n\tType : %S", type_str() );
result.append_fmt( "\n\tModule Flags : %S", to_str( ModuleFlags ) );
append_fmt( result, "\n\tName : %S", Name ? Name : "Null" );
append_fmt( result, "\n\tType : %S", type_str() );
append_fmt( result, "\n\tModule Flags : %S", to_str( ModuleFlags ) );
switch ( Type )
{
@ -30,9 +30,9 @@ char const* AST::debug_str()
case Access_Protected:
case Access_Public:
if ( Prev )
result.append_fmt( "\n\tPrev: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
append_fmt( result, "\n\tPrev: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
if ( Next )
result.append_fmt( "\n\tNext: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
append_fmt( result, "\n\tNext: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
break;
case Untyped:
@ -48,74 +48,74 @@ char const* AST::debug_str()
case Preprocess_IfDef:
case Preprocess_IfNotDef:
if ( Prev )
result.append_fmt( "\n\tPrev: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
append_fmt( result, "\n\tPrev: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
if ( Next )
result.append_fmt( "\n\tNext: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
append_fmt( result, "\n\tNext: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
result.append_fmt( "\n\tContent: %S", Content );
append_fmt( result, "\n\tContent: %S", Content );
break;
case Class:
case Struct:
if ( Prev )
result.append_fmt( "\n\tPrev: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
append_fmt( result, "\n\tPrev: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
if ( Next )
result.append_fmt( "\n\tNext: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
append_fmt( result, "\n\tNext: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
result.append_fmt( "\n\tInlineCmd : %S", InlineCmt ? InlineCmt->Content : "Null" );
result.append_fmt( "\n\tAttributes : %S", Attributes ? Attributes->to_string() : "Null" );
result.append_fmt( "\n\tParentAccess: %s", ParentType ? to_str( ParentAccess ) : "No Parent" );
result.append_fmt( "\n\tParentType : %s", ParentType ? ParentType->type_str() : "Null" );
result.append_fmt( "\n\tBody : %S", Body ? Body->debug_str() : "Null" );
append_fmt( result, "\n\tInlineCmd : %S", InlineCmt ? InlineCmt->Content : "Null" );
append_fmt( result, "\n\tAttributes : %S", Attributes ? Attributes->to_string() : "Null" );
append_fmt( result, "\n\tParentAccess: %s", ParentType ? to_str( ParentAccess ) : "No Parent" );
append_fmt( result, "\n\tParentType : %s", ParentType ? ParentType->type_str() : "Null" );
append_fmt( result, "\n\tBody : %S", Body ? Body->debug_str() : "Null" );
break;
case Class_Fwd:
case Struct_Fwd:
if ( Prev )
result.append_fmt( "\n\tPrev: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
append_fmt( result, "\n\tPrev: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
if ( Next )
result.append_fmt( "\n\tNext: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
append_fmt( result, "\n\tNext: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
result.append_fmt( "\n\tInlineCmd : %S", InlineCmt ? InlineCmt->Content : "Null" );
result.append_fmt( "\n\tAttributes : %S", Attributes ? Attributes->to_string() : "Null" );
result.append_fmt( "\n\tParentAccess: %s", ParentType ? to_str( ParentAccess ) : "No Parent" );
result.append_fmt( "\n\tParentType : %s", ParentType ? ParentType->type_str() : "Null" );
append_fmt( result, "\n\tInlineCmd : %S", InlineCmt ? InlineCmt->Content : "Null" );
append_fmt( result, "\n\tAttributes : %S", Attributes ? Attributes->to_string() : "Null" );
append_fmt( result, "\n\tParentAccess: %s", ParentType ? to_str( ParentAccess ) : "No Parent" );
append_fmt( result, "\n\tParentType : %s", ParentType ? ParentType->type_str() : "Null" );
break;
case Constructor:
if ( Prev )
result.append_fmt( "\n\tPrev: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
append_fmt( result, "\n\tPrev: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
if ( Next )
result.append_fmt( "\n\tNext: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
append_fmt( result, "\n\tNext: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
result.append_fmt( "\n\tInlineCmt : %S", InlineCmt ? InlineCmt->Content : "Null" );
result.append_fmt( "\n\tSpecs : %S", Specs ? Specs->to_string() : "Null" );
result.append_fmt( "\n\tInitializerList: %S", InitializerList ? InitializerList->to_string() : "Null" );
result.append_fmt( "\n\tParams : %S", Params ? Params->to_string() : "Null" );
result.append_fmt( "\n\tBody : %S", Body ? Body->debug_str() : "Null" );
append_fmt( result, "\n\tInlineCmt : %S", InlineCmt ? InlineCmt->Content : "Null" );
append_fmt( result, "\n\tSpecs : %S", Specs ? Specs->to_string() : "Null" );
append_fmt( result, "\n\tInitializerList: %S", InitializerList ? InitializerList->to_string() : "Null" );
append_fmt( result, "\n\tParams : %S", Params ? Params->to_string() : "Null" );
append_fmt( result, "\n\tBody : %S", Body ? Body->debug_str() : "Null" );
break;
case Constructor_Fwd:
if ( Prev )
result.append_fmt( "\n\tPrev: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
append_fmt( result, "\n\tPrev: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
if ( Next )
result.append_fmt( "\n\tNext: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
append_fmt( result, "\n\tNext: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
result.append_fmt( "\n\tInlineCmt : %S", InlineCmt ? InlineCmt->Content : "Null" );
result.append_fmt( "\n\tSpecs : %S", Specs ? Specs->to_string() : "Null" );
result.append_fmt( "\n\tInitializerList: %S", InitializerList ? InitializerList->to_string() : "Null" );
result.append_fmt( "\n\tParams : %S", Params ? Params->to_string() : "Null" );
append_fmt( result, "\n\tInlineCmt : %S", InlineCmt ? InlineCmt->Content : "Null" );
append_fmt( result, "\n\tSpecs : %S", Specs ? Specs->to_string() : "Null" );
append_fmt( result, "\n\tInitializerList: %S", InitializerList ? InitializerList->to_string() : "Null" );
append_fmt( result, "\n\tParams : %S", Params ? Params->to_string() : "Null" );
break;
case Destructor:
if ( Prev )
result.append_fmt( "\n\tPrev: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
append_fmt( result, "\n\tPrev: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
if ( Next )
result.append_fmt( "\n\tNext: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
append_fmt( result, "\n\tNext: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
result.append_fmt( "\n\tInlineCmt : %S", InlineCmt ? InlineCmt->Content : "Null" );
result.append_fmt( "\n\tSpecs : %S", Specs ? Specs->to_string() : "Null" );
result.append_fmt( "\n\tBody : %S", Body ? Body->debug_str() : "Null" );
append_fmt( result, "\n\tInlineCmt : %S", InlineCmt ? InlineCmt->Content : "Null" );
append_fmt( result, "\n\tSpecs : %S", Specs ? Specs->to_string() : "Null" );
append_fmt( result, "\n\tBody : %S", Body ? Body->debug_str() : "Null" );
break;
case Destructor_Fwd:
@ -124,208 +124,208 @@ char const* AST::debug_str()
case Enum:
case Enum_Class:
if ( Prev )
result.append_fmt( "\n\tPrev: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
append_fmt( result, "\n\tPrev: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
if ( Next )
result.append_fmt( "\n\tNext: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
append_fmt( result, "\n\tNext: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
result.append_fmt( "\n\tInlineCmt : %S", InlineCmt ? InlineCmt->Content : "Null" );
result.append_fmt( "\n\tAttributes : %S", Attributes ? Attributes->to_string() : "Null" );
result.append_fmt( "\n\tUnderlying Type : %S", UnderlyingType ? UnderlyingType->to_string() : "Null" );
result.append_fmt( "\n\tBody : %S", Body ? Body->debug_str() : "Null" );
append_fmt( result, "\n\tInlineCmt : %S", InlineCmt ? InlineCmt->Content : "Null" );
append_fmt( result, "\n\tAttributes : %S", Attributes ? Attributes->to_string() : "Null" );
append_fmt( result, "\n\tUnderlying Type : %S", UnderlyingType ? UnderlyingType->to_string() : "Null" );
append_fmt( result, "\n\tBody : %S", Body ? Body->debug_str() : "Null" );
break;
case Enum_Fwd:
case Enum_Class_Fwd:
if ( Prev )
result.append_fmt( "\n\tPrev: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
append_fmt( result, "\n\tPrev: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
if ( Next )
result.append_fmt( "\n\tNext: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
append_fmt( result, "\n\tNext: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
result.append_fmt( "\n\tInlineCmt : %S", InlineCmt ? InlineCmt->Content : "Null" );
result.append_fmt( "\n\tAttributes : %S", Attributes ? Attributes->to_string() : "Null" );
result.append_fmt( "\n\tUnderlying Type : %S", UnderlyingType ? UnderlyingType->to_string() : "Null" );
append_fmt( result, "\n\tInlineCmt : %S", InlineCmt ? InlineCmt->Content : "Null" );
append_fmt( result, "\n\tAttributes : %S", Attributes ? Attributes->to_string() : "Null" );
append_fmt( result, "\n\tUnderlying Type : %S", UnderlyingType ? UnderlyingType->to_string() : "Null" );
break;
case Extern_Linkage:
case Namespace:
if ( Prev )
result.append_fmt( "\n\tPrev: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
append_fmt( result, "\n\tPrev: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
if ( Next )
result.append_fmt( "\n\tNext: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
append_fmt( result, "\n\tNext: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
result.append_fmt( "\n\tBody: %S", Body ? Body->debug_str() : "Null" );
append_fmt( result, "\n\tBody: %S", Body ? Body->debug_str() : "Null" );
break;
case Friend:
if ( Prev )
result.append_fmt( "\n\tPrev: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
append_fmt( result, "\n\tPrev: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
if ( Next )
result.append_fmt( "\n\tNext: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
append_fmt( result, "\n\tNext: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
result.append_fmt( "\n\tInlineCmt : %S", InlineCmt ? InlineCmt->Content : "Null" );
result.append_fmt( "\n\tDeclaration: %S", Declaration ? Declaration->to_string() : "Null" );
append_fmt( result, "\n\tInlineCmt : %S", InlineCmt ? InlineCmt->Content : "Null" );
append_fmt( result, "\n\tDeclaration: %S", Declaration ? Declaration->to_string() : "Null" );
break;
case Function:
if ( Prev )
result.append_fmt( "\n\tPrev: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
append_fmt( result, "\n\tPrev: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
if ( Next )
result.append_fmt( "\n\tNext: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
append_fmt( result, "\n\tNext: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
result.append_fmt( "\n\tInlineCmt : %S", InlineCmt ? InlineCmt->Content : "Null" );
result.append_fmt( "\n\tAttributes: %S", Attributes ? Attributes->to_string() : "Null" );
result.append_fmt( "\n\tSpecs : %S", Specs ? Specs->to_string() : "Null" );
result.append_fmt( "\n\tReturnType: %S", ReturnType ? ReturnType->to_string() : "Null" );
result.append_fmt( "\n\tParams : %S", Params ? Params->to_string() : "Null" );
result.append_fmt( "\n\tBody : %S", Body ? Body->debug_str() : "Null" );
append_fmt( result, "\n\tInlineCmt : %S", InlineCmt ? InlineCmt->Content : "Null" );
append_fmt( result, "\n\tAttributes: %S", Attributes ? Attributes->to_string() : "Null" );
append_fmt( result, "\n\tSpecs : %S", Specs ? Specs->to_string() : "Null" );
append_fmt( result, "\n\tReturnType: %S", ReturnType ? ReturnType->to_string() : "Null" );
append_fmt( result, "\n\tParams : %S", Params ? Params->to_string() : "Null" );
append_fmt( result, "\n\tBody : %S", Body ? Body->debug_str() : "Null" );
break;
case Function_Fwd:
if ( Prev )
result.append_fmt( "\n\tPrev: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
append_fmt( result, "\n\tPrev: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
if ( Next )
result.append_fmt( "\n\tNext: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
append_fmt( result, "\n\tNext: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
result.append_fmt( "\n\tInlineCmt : %S", InlineCmt ? InlineCmt->Content : "Null" );
result.append_fmt( "\n\tAttributes: %S", Attributes ? Attributes->to_string() : "Null" );
result.append_fmt( "\n\tSpecs : %S", Specs ? Specs->to_string() : "Null" );
result.append_fmt( "\n\tReturnType: %S", ReturnType ? ReturnType->to_string() : "Null" );
result.append_fmt( "\n\tParams : %S", Params ? Params->to_string() : "Null" );
append_fmt( result, "\n\tInlineCmt : %S", InlineCmt ? InlineCmt->Content : "Null" );
append_fmt( result, "\n\tAttributes: %S", Attributes ? Attributes->to_string() : "Null" );
append_fmt( result, "\n\tSpecs : %S", Specs ? Specs->to_string() : "Null" );
append_fmt( result, "\n\tReturnType: %S", ReturnType ? ReturnType->to_string() : "Null" );
append_fmt( result, "\n\tParams : %S", Params ? Params->to_string() : "Null" );
break;
case Module:
if ( Prev )
result.append_fmt( "\n\tPrev: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
append_fmt( result, "\n\tPrev: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
if ( Next )
result.append_fmt( "\n\tNext: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
append_fmt( result, "\n\tNext: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
break;
case Operator:
case Operator_Member:
if ( Prev )
result.append_fmt( "\n\tPrev: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
append_fmt( result, "\n\tPrev: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
if ( Next )
result.append_fmt( "\n\tNext: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
append_fmt( result, "\n\tNext: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
result.append_fmt( "\n\tInlineCmt : %S", InlineCmt ? InlineCmt->Content : "Null" );
result.append_fmt( "\n\tAttributes: %S", Attributes ? Attributes->to_string() : "Null" );
result.append_fmt( "\n\tSpecs : %S", Specs ? Specs->to_string() : "Null" );
result.append_fmt( "\n\tReturnType: %S", ReturnType ? ReturnType->to_string() : "Null" );
result.append_fmt( "\n\tParams : %S", Params ? Params->to_string() : "Null" );
result.append_fmt( "\n\tBody : %S", Body ? Body->debug_str() : "Null" );
result.append_fmt( "\n\tOp : %S", to_str( Op ) );
append_fmt( result, "\n\tInlineCmt : %S", InlineCmt ? InlineCmt->Content : "Null" );
append_fmt( result, "\n\tAttributes: %S", Attributes ? Attributes->to_string() : "Null" );
append_fmt( result, "\n\tSpecs : %S", Specs ? Specs->to_string() : "Null" );
append_fmt( result, "\n\tReturnType: %S", ReturnType ? ReturnType->to_string() : "Null" );
append_fmt( result, "\n\tParams : %S", Params ? Params->to_string() : "Null" );
append_fmt( result, "\n\tBody : %S", Body ? Body->debug_str() : "Null" );
append_fmt( result, "\n\tOp : %S", to_str( Op ) );
break;
case Operator_Fwd:
case Operator_Member_Fwd:
if ( Prev )
result.append_fmt( "\n\tPrev: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
append_fmt( result, "\n\tPrev: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
if ( Next )
result.append_fmt( "\n\tNext: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
append_fmt( result, "\n\tNext: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
result.append_fmt( "\n\tInlineCmt : %S", InlineCmt ? InlineCmt->Content : "Null" );
result.append_fmt( "\n\tAttributes: %S", Attributes ? Attributes->to_string() : "Null" );
result.append_fmt( "\n\tSpecs : %S", Specs ? Specs->to_string() : "Null" );
result.append_fmt( "\n\tReturnType: %S", ReturnType ? ReturnType->to_string() : "Null" );
result.append_fmt( "\n\tParams : %S", Params ? Params->to_string() : "Null" );
result.append_fmt( "\n\tOp : %S", to_str( Op ) );
append_fmt( result, "\n\tInlineCmt : %S", InlineCmt ? InlineCmt->Content : "Null" );
append_fmt( result, "\n\tAttributes: %S", Attributes ? Attributes->to_string() : "Null" );
append_fmt( result, "\n\tSpecs : %S", Specs ? Specs->to_string() : "Null" );
append_fmt( result, "\n\tReturnType: %S", ReturnType ? ReturnType->to_string() : "Null" );
append_fmt( result, "\n\tParams : %S", Params ? Params->to_string() : "Null" );
append_fmt( result, "\n\tOp : %S", to_str( Op ) );
break;
case Operator_Cast:
if ( Prev )
result.append_fmt( "\n\tPrev: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
append_fmt( result, "\n\tPrev: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
if ( Next )
result.append_fmt( "\n\tNext: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
append_fmt( result, "\n\tNext: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
result.append_fmt( "\n\tInlineCmt : %S", InlineCmt ? InlineCmt->Content : "Null" );
result.append_fmt( "\n\tSpecs : %S", Specs ? Specs->to_string() : "Null" );
result.append_fmt( "\n\tValueType : %S", ValueType ? ValueType->to_string() : "Null" );
result.append_fmt( "\n\tBody : %S", Body ? Body->debug_str() : "Null" );
append_fmt( result, "\n\tInlineCmt : %S", InlineCmt ? InlineCmt->Content : "Null" );
append_fmt( result, "\n\tSpecs : %S", Specs ? Specs->to_string() : "Null" );
append_fmt( result, "\n\tValueType : %S", ValueType ? ValueType->to_string() : "Null" );
append_fmt( result, "\n\tBody : %S", Body ? Body->debug_str() : "Null" );
break;
case Operator_Cast_Fwd:
if ( Prev )
result.append_fmt( "\n\tPrev: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
append_fmt( result, "\n\tPrev: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
if ( Next )
result.append_fmt( "\n\tNext: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
append_fmt( result, "\n\tNext: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
result.append_fmt( "\n\tInlineCmt : %S", InlineCmt ? InlineCmt->Content : "Null" );
result.append_fmt( "\n\tSpecs : %S", Specs ? Specs->to_string() : "Null" );
result.append_fmt( "\n\tValueType : %S", ValueType ? ValueType->to_string() : "Null" );
append_fmt( result, "\n\tInlineCmt : %S", InlineCmt ? InlineCmt->Content : "Null" );
append_fmt( result, "\n\tSpecs : %S", Specs ? Specs->to_string() : "Null" );
append_fmt( result, "\n\tValueType : %S", ValueType ? ValueType->to_string() : "Null" );
break;
case Parameters:
result.append_fmt( "\n\tNumEntries: %d", NumEntries );
result.append_fmt( "\n\tLast : %S", Last->Name );
result.append_fmt( "\n\tNext : %S", Next->Name );
result.append_fmt( "\n\tValueType : %S", ValueType ? ValueType->to_string() : "Null" );
result.append_fmt( "\n\tValue : %S", Value ? Value->to_string() : "Null" );
append_fmt( result, "\n\tNumEntries: %d", NumEntries );
append_fmt( result, "\n\tLast : %S", Last->Name );
append_fmt( result, "\n\tNext : %S", Next->Name );
append_fmt( result, "\n\tValueType : %S", ValueType ? ValueType->to_string() : "Null" );
append_fmt( result, "\n\tValue : %S", Value ? Value->to_string() : "Null" );
break;
case Specifiers:
{
result.append_fmt( "\n\tNumEntries: %d", NumEntries );
result.append( "\n\tArrSpecs: " );
append_fmt( result, "\n\tNumEntries: %d", NumEntries );
GEN_NS append( result, "\n\tArrSpecs: " );
s32 idx = 0;
s32 left = NumEntries;
while ( left-- )
{
StrC spec = ESpecifier::to_str( ArrSpecs[idx] );
result.append_fmt( "%.*s, ", spec.Len, spec.Ptr );
append_fmt( result, "%.*s, ", spec.Len, spec.Ptr );
idx++;
}
result.append_fmt( "\n\tNextSpecs: %S", NextSpecs ? NextSpecs->debug_str() : "Null" );
append_fmt( result, "\n\tNextSpecs: %S", NextSpecs ? NextSpecs->debug_str() : "Null" );
}
break;
case Template:
if ( Prev )
result.append_fmt( "\n\tPrev: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
append_fmt( result, "\n\tPrev: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
if ( Next )
result.append_fmt( "\n\tNext: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
append_fmt( result, "\n\tNext: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
result.append_fmt( "\n\tParams : %S", Params ? Params->to_string() : "Null" );
result.append_fmt( "\n\tDeclaration: %S", Declaration ? Declaration->to_string() : "Null" );
append_fmt( result, "\n\tParams : %S", Params ? Params->to_string() : "Null" );
append_fmt( result, "\n\tDeclaration: %S", Declaration ? Declaration->to_string() : "Null" );
break;
case Typedef:
if ( Prev )
result.append_fmt( "\n\tPrev: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
append_fmt( result, "\n\tPrev: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
if ( Next )
result.append_fmt( "\n\tNext: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
append_fmt( result, "\n\tNext: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
result.append_fmt( "\n\tInlineCmt : %S", InlineCmt ? InlineCmt->Content : "Null" );
result.append_fmt( "\n\tUnderlyingType: %S", UnderlyingType ? UnderlyingType->to_string() : "Null" );
append_fmt( result, "\n\tInlineCmt : %S", InlineCmt ? InlineCmt->Content : "Null" );
append_fmt( result, "\n\tUnderlyingType: %S", UnderlyingType ? UnderlyingType->to_string() : "Null" );
break;
case Typename:
result.append_fmt( "\n\tAttributes : %S", Attributes ? Attributes->to_string() : "Null" );
result.append_fmt( "\n\tSpecs : %S", Specs ? Specs->to_string() : "Null" );
result.append_fmt( "\n\tReturnType : %S", ReturnType ? ReturnType->to_string() : "Null" );
result.append_fmt( "\n\tParams : %S", Params ? Params->to_string() : "Null" );
result.append_fmt( "\n\tArrExpr : %S", ArrExpr ? ArrExpr->to_string() : "Null" );
append_fmt( result, "\n\tAttributes : %S", Attributes ? Attributes->to_string() : "Null" );
append_fmt( result, "\n\tSpecs : %S", Specs ? Specs->to_string() : "Null" );
append_fmt( result, "\n\tReturnType : %S", ReturnType ? ReturnType->to_string() : "Null" );
append_fmt( result, "\n\tParams : %S", Params ? Params->to_string() : "Null" );
append_fmt( result, "\n\tArrExpr : %S", ArrExpr ? ArrExpr->to_string() : "Null" );
break;
case Union:
if ( Prev )
result.append_fmt( "\n\tPrev: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
append_fmt( result, "\n\tPrev: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
if ( Next )
result.append_fmt( "\n\tNext: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
append_fmt( result, "\n\tNext: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
result.append_fmt( "\n\tAttributes: %S", Attributes ? Attributes->to_string() : "Null" );
result.append_fmt( "\n\tBody : %S", Body ? Body->debug_str() : "Null" );
append_fmt( result, "\n\tAttributes: %S", Attributes ? Attributes->to_string() : "Null" );
append_fmt( result, "\n\tBody : %S", Body ? Body->debug_str() : "Null" );
break;
case Using:
if ( Prev )
result.append_fmt( "\n\tPrev: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
append_fmt( result, "\n\tPrev: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
if ( Next )
result.append_fmt( "\n\tNext: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
append_fmt( result, "\n\tNext: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
result.append_fmt( "\n\tInlineCmt : %S", InlineCmt ? InlineCmt->Content : "Null" );
result.append_fmt( "\n\tAttributes : %S", Attributes ? Attributes->to_string() : "Null" );
result.append_fmt( "\n\tUnderlyingType: %S", UnderlyingType ? UnderlyingType->to_string() : "Null" );
append_fmt( result, "\n\tInlineCmt : %S", InlineCmt ? InlineCmt->Content : "Null" );
append_fmt( result, "\n\tAttributes : %S", Attributes ? Attributes->to_string() : "Null" );
append_fmt( result, "\n\tUnderlyingType: %S", UnderlyingType ? UnderlyingType->to_string() : "Null" );
break;
case Variable:
@ -333,25 +333,25 @@ char const* AST::debug_str()
if ( Parent && Parent->Type == Variable )
{
// Its a NextVar
result.append_fmt( "\n\tSpecs : %S", Specs ? Specs->to_string() : "Null" );
result.append_fmt( "\n\tValue : %S", Value ? Value->to_string() : "Null" );
result.append_fmt( "\n\tBitfieldSize: %S", BitfieldSize ? BitfieldSize->to_string() : "Null" );
result.append_fmt( "\n\tNextVar : %S", NextVar ? NextVar->debug_str() : "Null" );
append_fmt( result, "\n\tSpecs : %S", Specs ? Specs->to_string() : "Null" );
append_fmt( result, "\n\tValue : %S", Value ? Value->to_string() : "Null" );
append_fmt( result, "\n\tBitfieldSize: %S", BitfieldSize ? BitfieldSize->to_string() : "Null" );
append_fmt( result, "\n\tNextVar : %S", NextVar ? NextVar->debug_str() : "Null" );
break;
}
if ( Prev )
result.append_fmt( "\n\tPrev: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
append_fmt( result, "\n\tPrev: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
if ( Next )
result.append_fmt( "\n\tNext: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
append_fmt( result, "\n\tNext: %S %S", Prev->type_str(), Prev->Name ? Prev->Name : "Null" );
result.append_fmt( "\n\tInlineCmt : %S", InlineCmt ? InlineCmt->Content : "Null" );
result.append_fmt( "\n\tAttributes : %S", Attributes ? Attributes->to_string() : "Null" );
result.append_fmt( "\n\tSpecs : %S", Specs ? Specs->to_string() : "Null" );
result.append_fmt( "\n\tValueType : %S", ValueType ? ValueType->to_string() : "Null" );
result.append_fmt( "\n\tBitfieldSize: %S", BitfieldSize ? BitfieldSize->to_string() : "Null" );
result.append_fmt( "\n\tValue : %S", Value ? Value->to_string() : "Null" );
result.append_fmt( "\n\tNextVar : %S", NextVar ? NextVar->debug_str() : "Null" );
append_fmt( result, "\n\tInlineCmt : %S", InlineCmt ? InlineCmt->Content : "Null" );
append_fmt( result, "\n\tAttributes : %S", Attributes ? Attributes->to_string() : "Null" );
append_fmt( result, "\n\tSpecs : %S", Specs ? Specs->to_string() : "Null" );
append_fmt( result, "\n\tValueType : %S", ValueType ? ValueType->to_string() : "Null" );
append_fmt( result, "\n\tBitfieldSize: %S", BitfieldSize ? BitfieldSize->to_string() : "Null" );
append_fmt( result, "\n\tValue : %S", Value ? Value->to_string() : "Null" );
append_fmt( result, "\n\tNextVar : %S", NextVar ? NextVar->debug_str() : "Null" );
break;
}
@ -372,7 +372,7 @@ AST* AST::duplicate()
String AST::to_string()
{
String result = String::make( GlobalAllocator, "" );
String result = string_make( GlobalAllocator, "" );
to_string( result );
return result;
}
@ -390,25 +390,25 @@ void AST::to_string( String& result )
#ifdef GEN_DONT_ALLOW_INVALID_CODE
log_failure("Attempted to serialize invalid code! - %S", Parent ? Parent->debug_str() : Name );
#else
result.append_fmt( "Invalid Code!" );
append_fmt( result, "Invalid Code!" );
#endif
break;
case NewLine:
result.append("\n");
GEN_NS append( result,"\n");
break;
case Untyped:
case Execution:
case Comment:
case PlatformAttributes:
result.append( Content );
GEN_NS append( result, Content );
break;
case Access_Private:
case Access_Protected:
case Access_Public:
result.append( Name );
GEN_NS append( result, Name );
break;
case Class:
@ -659,8 +659,8 @@ bool AST::is_equal( AST* other )
"so it must be verified by eye for now\n" \
"AST Content:\n%S\n" \
"Other Content:\n%S\n" \
, content.visualize_whitespace() \
, other->content.visualize_whitespace() \
, visualize_whitespace(content) \
, visualize_whitespace(other->content) \
); \
}

View File

@ -376,7 +376,8 @@ struct AST
OperatorT Op;
AccessSpec ParentAccess;
s32 NumEntries;
s32 VarConstructorInit; // Used by variables to know that initialization is using a constructor expression instead of an assignment expression.
s32 VarConstructorInit; // Used by variables to know that initialization is using a constructor expression instead of an assignment expression.
b32 EnumUnderlyingMacro; // Used by enums incase the user wants to wrap underlying type specification in a macro
};
};

View File

@ -174,7 +174,7 @@ struct AST_Enum
CodeAttributes Attributes;
char _PAD_SPEC_ [ sizeof(AST*) ];
CodeType UnderlyingType;
char _PAD_PARAMS_[ sizeof(AST*) ];
Code UnderlyingTypeMacro;
CodeBody Body;
char _PAD_PROPERTIES_2_[ sizeof(AST*) ];
};
@ -186,7 +186,7 @@ struct AST_Enum
StringCached Name;
CodeT Type;
ModuleFlag ModuleFlags;
char _PAD_UNUSED_[ sizeof(u32) ];
b32 EnumUnderlyingMacro;
};
static_assert( sizeof(AST_Enum) == sizeof(AST), "ERROR: AST_Enum is not the same size as AST");

File diff suppressed because it is too large Load Diff

View File

@ -78,7 +78,7 @@ void CodeClass::add_interface( CodeType type )
if ( possible_slot.ast )
{
// Were adding an interface to parent type, so we need to make sure the parent type is public.
ast->ParentAccess = AccessSpec::Public;
ast->ParentAccess = AccessSpec_Public;
// If your planning on adding a proper parent,
// then you'll need to move this over to ParentType->next and update ParentAccess accordingly.
}
@ -151,7 +151,7 @@ void CodeStruct::add_interface( CodeType type )
if ( possible_slot.ast )
{
// Were adding an interface to parent type, so we need to make sure the parent type is public.
ast->ParentAccess = AccessSpec::Public;
ast->ParentAccess = AccessSpec_Public;
// If your planning on adding a proper parent,
// then you'll need to move this over to ParentType->next and update ParentAccess accordingly.
}

View File

@ -74,16 +74,16 @@ void* Global_Allocator_Proc( void* allocator_data, AllocType type, ssize size, s
internal
void define_constants()
{
Code::Global = make_code();
Code::Global->Name = get_cached_string( txt("Global Code") );
Code::Global->Content = Code::Global->Name;
Code::Global = make_code();
scast(String, Code::Global->Name) = get_cached_string( txt("Global Code") );
scast(String, Code::Global->Content) = Code::Global->Name;
Code::Invalid = make_code();
Code::Invalid.set_global();
t_empty = (CodeType) make_code();
t_empty->Type = ECode::Typename;
t_empty->Name = get_cached_string( txt("") );
t_empty = (CodeType) make_code();
t_empty->Type = ECode::Typename;
t_empty->Name = get_cached_string( txt("") );
t_empty.set_global();
access_private = make_code();
@ -226,6 +226,10 @@ void define_constants()
# pragma pop_macro("local_persist")
# pragma pop_macro("neverinline")
# pragma push_macro("enum_underlying")
# pragma pop_macro("enum_underlying")
# undef def_constant_spec
}
@ -282,7 +286,7 @@ void init()
// Setup the hash tables
{
StringCache = StringTable::init( Allocator_StringTable );
StringCache = hashtable_init<StringCached>(Allocator_StringTable);
if ( StringCache.Entries == nullptr )
GEN_FATAL( "gen::init: Failed to initialize the StringCache");
@ -317,7 +321,7 @@ void deinit()
}
while ( left--, left );
StringCache.destroy();
destroy(StringCache);
free(CodePools);
free(StringArenas);
@ -392,14 +396,14 @@ StringCached get_cached_string( StrC str )
s32 hash_length = str.Len > kilobytes(1) ? kilobytes(1) : str.Len;
u64 key = crc32( str.Ptr, hash_length );
{
StringCached* result = StringCache.get( key );
StringCached* result = get(StringCache, key );
if ( result )
return * result;
}
String result = String::make( get_string_allocator( str.Len ), str );
StringCache.set( key, result );
String result = string_make( get_string_allocator( str.Len ), str );
set<StringCached>(StringCache, key, result );
return result;
}

View File

@ -44,9 +44,9 @@ CodeComment def_comment ( StrC content );
CodeClass def_class( StrC name
, Code body = NoCode
, CodeType parent = NoCode, AccessSpec access = AccessSpec::Default
, CodeType parent = NoCode, AccessSpec access = AccessSpec_Default
, CodeAttributes attributes = NoCode
, ModuleFlag mflags = ModuleFlag::None
, ModuleFlag mflags = ModuleFlag_None
, CodeType* interfaces = nullptr, s32 num_interfaces = 0 );
CodeConstructor def_constructor( CodeParam params = NoCode, Code initializer_list = NoCode, Code body = NoCode );
@ -56,9 +56,9 @@ CodeDefine def_define( StrC name, StrC content );
CodeDestructor def_destructor( Code body = NoCode, CodeSpecifiers specifiers = NoCode );
CodeEnum def_enum( StrC name
, Code body = NoCode, CodeType type = NoCode
, EnumT specifier = EnumRegular, CodeAttributes attributes = NoCode
, ModuleFlag mflags = ModuleFlag::None );
, Code body = NoCode, CodeType type = NoCode
, EnumT specifier = EnumDecl_Regular, CodeAttributes attributes = NoCode
, ModuleFlag mflags = ModuleFlag_None );
CodeExec def_execution ( StrC content );
CodeExtern def_extern_link( StrC name, Code body );
@ -67,16 +67,16 @@ CodeFriend def_friend ( Code symbol );
CodeFn def_function( StrC name
, CodeParam params = NoCode, CodeType ret_type = NoCode, Code body = NoCode
, CodeSpecifiers specifiers = NoCode, CodeAttributes attributes = NoCode
, ModuleFlag mflags = ModuleFlag::None );
, ModuleFlag mflags = ModuleFlag_None );
CodeInclude def_include ( StrC content, bool foreign = false );
CodeModule def_module ( StrC name, ModuleFlag mflags = ModuleFlag::None );
CodeNS def_namespace( StrC name, Code body, ModuleFlag mflags = ModuleFlag::None );
CodeModule def_module ( StrC name, ModuleFlag mflags = ModuleFlag_None );
CodeNS def_namespace( StrC name, Code body, ModuleFlag mflags = ModuleFlag_None );
CodeOperator def_operator( OperatorT op, StrC nspace
, CodeParam params = NoCode, CodeType ret_type = NoCode, Code body = NoCode
, CodeSpecifiers specifiers = NoCode, CodeAttributes attributes = NoCode
, ModuleFlag mflags = ModuleFlag::None );
, ModuleFlag mflags = ModuleFlag_None );
CodeOpCast def_operator_cast( CodeType type, Code body = NoCode, CodeSpecifiers specs = NoCode );
@ -89,27 +89,27 @@ CodeSpecifiers def_specifier( SpecifierT specifier );
CodeStruct def_struct( StrC name
, Code body = NoCode
, CodeType parent = NoCode, AccessSpec access = AccessSpec::Default
, CodeType parent = NoCode, AccessSpec access = AccessSpec_Default
, CodeAttributes attributes = NoCode
, ModuleFlag mflags = ModuleFlag::None
, ModuleFlag mflags = ModuleFlag_None
, CodeType* interfaces = nullptr, s32 num_interfaces = 0 );
CodeTemplate def_template( CodeParam params, Code definition, ModuleFlag mflags = ModuleFlag::None );
CodeTemplate def_template( CodeParam params, Code definition, ModuleFlag mflags = ModuleFlag_None );
CodeType def_type ( StrC name, Code arrayexpr = NoCode, CodeSpecifiers specifiers = NoCode, CodeAttributes attributes = NoCode );
CodeTypedef def_typedef( StrC name, Code type, CodeAttributes attributes = NoCode, ModuleFlag mflags = ModuleFlag::None );
CodeTypedef def_typedef( StrC name, Code type, CodeAttributes attributes = NoCode, ModuleFlag mflags = ModuleFlag_None );
CodeUnion def_union( StrC name, Code body, CodeAttributes attributes = NoCode, ModuleFlag mflags = ModuleFlag::None );
CodeUnion def_union( StrC name, Code body, CodeAttributes attributes = NoCode, ModuleFlag mflags = ModuleFlag_None );
CodeUsing def_using( StrC name, CodeType type = NoCode
, CodeAttributes attributess = NoCode
, ModuleFlag mflags = ModuleFlag::None );
, ModuleFlag mflags = ModuleFlag_None );
CodeUsing def_using_namespace( StrC name );
CodeVar def_variable( CodeType type, StrC name, Code value = NoCode
, CodeSpecifiers specifiers = NoCode, CodeAttributes attributes = NoCode
, ModuleFlag mflags = ModuleFlag::None );
, ModuleFlag mflags = ModuleFlag_None );
// Constructs an empty body. Use AST::validate_body() to check if the body is was has valid entries.
CodeBody def_body( CodeT type );

View File

@ -6,7 +6,7 @@
ssize token_fmt_va( char* buf, usize buf_size, s32 num_tokens, va_list va )
{
char const* buf_begin = buf;
ssize remaining = buf_size;
ssize remaining = buf_size;
local_persist
Arena tok_map_arena;
@ -17,7 +17,7 @@ ssize token_fmt_va( char* buf, usize buf_size, s32 num_tokens, va_list va )
char tok_map_mem[ TokenFmt_TokenMap_MemSize ];
tok_map_arena = arena_init_from_memory( tok_map_mem, sizeof(tok_map_mem) );
tok_map = HashTable<StrC>::init( allocator_info(tok_map_arena) );
tok_map = hashtable_init<StrC>( allocator_info(tok_map_arena) );
s32 left = num_tokens - 1;
@ -28,7 +28,7 @@ ssize token_fmt_va( char* buf, usize buf_size, s32 num_tokens, va_list va )
u32 key = crc32( token, str_len(token) );
tok_map.set( key, value );
set(tok_map, key, value );
}
}
@ -64,7 +64,7 @@ ssize token_fmt_va( char* buf, usize buf_size, s32 num_tokens, va_list va )
char const* token = fmt + 1;
u32 key = crc32( token, tok_len );
StrC* value = tok_map.get( key );
StrC* value = get(tok_map, key );
if ( value )
{
@ -94,7 +94,7 @@ ssize token_fmt_va( char* buf, usize buf_size, s32 num_tokens, va_list va )
}
}
tok_map.clear();
clear(tok_map);
free(tok_map_arena);
ssize result = buf_size - remaining;

View File

@ -458,7 +458,7 @@ CodeComment def_comment( StrC content )
static char line[ MaxCommentLineLength ];
String cmt_formatted = String::make_reserve( GlobalAllocator, kilobytes(1) );
String cmt_formatted = string_make_reserve( GlobalAllocator, kilobytes(1) );
char const* end = content.Ptr + content.Len;
char const* scanner = content.Ptr;
s32 curr = 0;
@ -474,15 +474,15 @@ CodeComment def_comment( StrC content )
length++;
str_copy( line, scanner, length );
cmt_formatted.append_fmt( "//%.*s", length, line );
append_fmt(cmt_formatted, "//%.*s", length, line );
mem_set( line, 0, MaxCommentLineLength );
scanner += length;
}
while ( scanner <= end );
if ( cmt_formatted.back() != '\n' )
cmt_formatted.append( "\n" );
if ( back(cmt_formatted) != '\n' )
append( cmt_formatted, "\n" );
Code
result = make_code();
@ -490,7 +490,7 @@ CodeComment def_comment( StrC content )
result->Name = get_cached_string( cmt_formatted );
result->Content = result->Name;
cmt_formatted.free();
free(cmt_formatted);
return (CodeComment) result;
}
@ -719,14 +719,14 @@ CodeEnum def_enum( StrC name
return CodeInvalid;
}
result->Type = specifier == EnumClass ?
result->Type = specifier == EnumDecl_Class ?
Enum_Class : Enum;
result->Body = body;
}
else
{
result->Type = specifier == EnumClass ?
result->Type = specifier == EnumDecl_Class ?
Enum_Class_Fwd : Enum_Fwd;
}
@ -1145,16 +1145,16 @@ CodePreprocessCond def_preprocess_cond( EPreprocessCond type, StrC expr )
switch (type)
{
case EPreprocessCond::If:
case PreprocessCond_If:
result->Type = Preprocess_If;
break;
case EPreprocessCond::IfDef:
case PreprocessCond_IfDef:
result->Type = Preprocess_IfDef;
break;
case EPreprocessCond::IfNotDef:
case PreprocessCond_IfNotDef:
result->Type = Preprocess_IfNotDef;
break;
case EPreprocessCond::ElIf:
case PreprocessCond_ElIf:
result->Type = Preprocess_ElIf;
break;
}

View File

@ -89,11 +89,11 @@ struct Token
String to_string()
{
String result = String::make_reserve( GlobalAllocator, kilobytes(4) );
String result = string_make_reserve( GlobalAllocator, kilobytes(4) );
StrC type_str = ETokType::to_str( Type );
result.append_fmt( "Line: %d Column: %d, Type: %.*s Content: %.*s"
append_fmt( result, "Line: %d Column: %d, Type: %.*s Content: %.*s"
, Line, Column
, type_str.Len, type_str.Ptr
, Length, Text
@ -341,7 +341,7 @@ s32 lex_preprocessor_directive(
append(Tokens, name );
u64 key = crc32( name.Text, name.Length );
defines.set( key, name );
set<StrC>(defines, key, name );
}
Token preprocess_content = { scanner, 0, TokType::Preprocess_Content, line, column, TF_Preprocess };
@ -352,7 +352,7 @@ s32 lex_preprocessor_directive(
if ( current != '"' && current != '<' )
{
String directive_str = String::fmt_buf( GlobalAllocator, "%.*s", min( 80, left + preprocess_content.Length ), token.Text );
String directive_str = string_fmt_buf( GlobalAllocator, "%.*s", min( 80, left + preprocess_content.Length ), token.Text );
log_failure( "gen::Parser::lex: Expected '\"' or '<' after #include, not '%c' (%d, %d)\n%s"
, current
@ -419,8 +419,8 @@ s32 lex_preprocessor_directive(
}
else
{
String directive_str = String::make_length( GlobalAllocator, token.Text, token.Length );
String content_str = String::fmt_buf( GlobalAllocator, "%.*s", min( 400, left + preprocess_content.Length ), preprocess_content.Text );
String directive_str = string_make_length( GlobalAllocator, token.Text, token.Length );
String content_str = string_fmt_buf( GlobalAllocator, "%.*s", min( 400, left + preprocess_content.Length ), preprocess_content.Text );
log_failure( "gen::Parser::lex: Invalid escape sequence '\\%c' (%d, %d)"
" in preprocessor directive '%s' (%d, %d)\n%s"
@ -516,7 +516,7 @@ void lex_found_token( StrC& content
else
key = crc32( token.Text, token.Length );
StrC* define = defines.get( key );
StrC* define = get(defines, key );
if ( define )
{
token.Type = TokType::Preprocess_Macro;
@ -586,7 +586,7 @@ TokArray lex( StrC content )
{
s32 length = 0;
char const* scanner = entry.Data;
while ( entry.length() > length && (char_is_alphanumeric( *scanner ) || *scanner == '_') )
while ( GEN_NS length(entry) > length && (char_is_alphanumeric( *scanner ) || *scanner == '_') )
{
scanner++;
length ++;
@ -597,7 +597,7 @@ TokArray lex( StrC content )
}
u64 key = crc32( entry.Data, length );
defines.set( key, entry );
set<StrC>(defines, key, entry );
}
clear(Tokens);
@ -678,7 +678,7 @@ TokArray lex( StrC content )
}
else
{
String context_str = String::fmt_buf( GlobalAllocator, "%s", scanner, min( 100, left ) );
String context_str = string_fmt_buf( GlobalAllocator, "%s", scanner, min( 100, left ) );
log_failure( "gen::lex: invalid varadic argument, expected '...' got '..%c' (%d, %d)\n%s", current, line, column, context_str );
}
@ -1239,7 +1239,7 @@ TokArray lex( StrC content )
);
}
String context_str = String::fmt_buf( GlobalAllocator, "%.*s", min( 100, left ), scanner );
String context_str = string_fmt_buf( GlobalAllocator, "%.*s", min( 100, left ), scanner );
log_failure( "Failed to lex token '%c' (%d, %d)\n%s", current, line, column, context_str );
// Skip to next whitespace since we can't know if anything else is valid until then.
@ -1259,7 +1259,7 @@ TokArray lex( StrC content )
return { { nullptr }, 0 };
}
defines.clear();
clear(defines);
// defines_map_arena.free();
return { Tokens, 0 };
}

View File

@ -45,7 +45,7 @@ struct ParseContext
String to_string()
{
String result = String::make_reserve( GlobalAllocator, kilobytes(4) );
String result = string_make_reserve( GlobalAllocator, kilobytes(4) );
Token scope_start = Scope->Start;
Token last_valid = Tokens.Idx >= num(Tokens.Arr) ? Tokens.Arr[num(Tokens.Arr) -1] : Tokens.current();
@ -58,18 +58,18 @@ struct ParseContext
length++;
}
String line = String::make( GlobalAllocator, { length, scope_start.Text } );
result.append_fmt("\tScope : %s\n", line );
line.free();
String line = string_make( GlobalAllocator, { length, scope_start.Text } );
append_fmt( result, "\tScope : %s\n", line );
free(line);
sptr dist = (sptr)last_valid.Text - (sptr)scope_start.Text + 2;
sptr length_from_err = dist;
String line_from_err = String::make( GlobalAllocator, { length_from_err, last_valid.Text } );
String line_from_err = string_make( GlobalAllocator, { length_from_err, last_valid.Text } );
if ( length_from_err < 100 )
result.append_fmt("\t(%d, %d):%*c\n", last_valid.Line, last_valid.Column, length_from_err, '^' );
append_fmt(result, "\t(%d, %d):%*c\n", last_valid.Line, last_valid.Column, length_from_err, '^' );
else
result.append_fmt("\t(%d, %d)\n", last_valid.Line, last_valid.Column );
append_fmt(result, "\t(%d, %d)\n", last_valid.Line, last_valid.Column );
StackNode* curr_scope = Scope;
s32 level = 0;
@ -77,11 +77,11 @@ struct ParseContext
{
if ( curr_scope->Name )
{
result.append_fmt("\t%d: %s, AST Name: %.*s\n", level, curr_scope->ProcName.Ptr, curr_scope->Name.Length, curr_scope->Name.Text );
append_fmt(result, "\t%d: %s, AST Name: %.*s\n", level, curr_scope->ProcName.Ptr, curr_scope->Name.Length, curr_scope->Name.Text );
}
else
{
result.append_fmt("\t%d: %s\n", level, curr_scope->ProcName.Ptr );
append_fmt(result, "\t%d: %s\n", level, curr_scope->ProcName.Ptr );
}
curr_scope = curr_scope->Prev;
@ -137,7 +137,7 @@ void init()
);
fixed_arena_init(defines_map_arena);
defines = HashTable<StrC>::init_reserve( allocator_info(defines_map_arena), 256 );
defines = hashtable_init_reserve<StrC>( allocator_info(defines_map_arena), 256 );
}
internal
@ -243,7 +243,7 @@ constexpr bool strip_formatting_dont_preserve_newlines = false;
internal
String strip_formatting( StrC raw_text, bool preserve_newlines = true )
{
String content = String::make_reserve( GlobalAllocator, raw_text.Len );
String content = string_make_reserve( GlobalAllocator, raw_text.Len );
if ( raw_text.Len == 0 )
return content;
@ -290,7 +290,7 @@ String strip_formatting( StrC raw_text, bool preserve_newlines = true )
if ( tokleft )
move_fwd();
content.append( cut_ptr, cut_length );
append( content, cut_ptr, cut_length );
last_cut = sptr( scanner ) - sptr( raw_text.Ptr );
continue;
}
@ -312,7 +312,7 @@ String strip_formatting( StrC raw_text, bool preserve_newlines = true )
if ( tokleft )
move_fwd();
content.append( cut_ptr, cut_length );
append( content, cut_ptr, cut_length );
last_cut = sptr( scanner ) - sptr( raw_text.Ptr );
continue;
}
@ -326,7 +326,7 @@ String strip_formatting( StrC raw_text, bool preserve_newlines = true )
scanner += 2;
tokleft -= 2;
content.append( cut_ptr, cut_length );
append( content, cut_ptr, cut_length );
last_cut = sptr( scanner ) - sptr( raw_text.Ptr );
continue;
}
@ -345,7 +345,7 @@ String strip_formatting( StrC raw_text, bool preserve_newlines = true )
if (tokleft)
move_fwd();
content.append( cut_ptr, cut_length );
append( content, cut_ptr, cut_length );
last_cut = sptr( scanner ) - sptr( raw_text.Ptr );
continue;
}
@ -354,10 +354,10 @@ String strip_formatting( StrC raw_text, bool preserve_newlines = true )
if (scanner[0] == '\t')
{
if (pos > last_cut)
content.append(cut_ptr, cut_length);
append( content, cut_ptr, cut_length);
if ( content.back() != ' ' )
content.append(' ');
if ( back( content ) != ' ' )
append( content, ' ');
move_fwd();
last_cut = sptr(scanner) - sptr(raw_text.Ptr);
@ -373,17 +373,17 @@ String strip_formatting( StrC raw_text, bool preserve_newlines = true )
scanner += 2;
tokleft -= 2;
content.append( cut_ptr, cut_length );
append( content, cut_ptr, cut_length );
last_cut = sptr( scanner ) - sptr( raw_text.Ptr );
continue;
}
if ( pos > last_cut )
content.append( cut_ptr, cut_length );
append( content, cut_ptr, cut_length );
// Replace with a space
if ( content.back() != ' ' )
content.append( ' ' );
if ( back( content ) != ' ' )
append( content, ' ' );
scanner += 2;
tokleft -= 2;
@ -400,17 +400,17 @@ String strip_formatting( StrC raw_text, bool preserve_newlines = true )
move_fwd();
content.append( cut_ptr, cut_length );
append( content, cut_ptr, cut_length );
last_cut = sptr( scanner ) - sptr( raw_text.Ptr );
continue;
}
if ( pos > last_cut )
content.append( cut_ptr, cut_length );
append( content, cut_ptr, cut_length );
// Replace with a space
if ( content.back() != ' ' )
content.append( ' ' );
if ( back( content ) != ' ' )
append( content, ' ' );
move_fwd();
@ -421,7 +421,7 @@ String strip_formatting( StrC raw_text, bool preserve_newlines = true )
// Escaped newlines
if ( scanner[0] == '\\' )
{
content.append( cut_ptr, cut_length );
append( content, cut_ptr, cut_length );
s32 amount_to_skip = 1;
if ( tokleft > 1 && scanner[1] == '\n' )
@ -448,7 +448,7 @@ String strip_formatting( StrC raw_text, bool preserve_newlines = true )
// Consectuive spaces
if ( tokleft > 1 && char_is_space( scanner[0] ) && char_is_space( scanner[ 1 ] ) )
{
content.append( cut_ptr, cut_length );
append( content, cut_ptr, cut_length );
do
{
move_fwd();
@ -458,8 +458,8 @@ String strip_formatting( StrC raw_text, bool preserve_newlines = true )
last_cut = sptr( scanner ) - sptr( raw_text.Ptr );
// Preserve only 1 space of formattting
if ( content.back() != ' ' )
content.append( ' ' );
if ( back( content ) != ' ' )
append( content, ' ' );
continue;
}
@ -469,7 +469,7 @@ String strip_formatting( StrC raw_text, bool preserve_newlines = true )
if ( last_cut < raw_text.Len )
{
content.append( cut_ptr, raw_text.Len - last_cut );
append( content, cut_ptr, raw_text.Len - last_cut );
}
#undef cut_ptr
@ -682,17 +682,17 @@ Code parse_class_struct( TokType which, bool inplace_def = false )
Token name { nullptr, 0, TokType::Invalid };
AccessSpec access = AccessSpec::Default;
AccessSpec access = AccessSpec_Default;
CodeType parent = { nullptr };
CodeBody body = { nullptr };
CodeAttributes attributes = { nullptr };
ModuleFlag mflags = ModuleFlag::None;
ModuleFlag mflags = ModuleFlag_None;
CodeClass result = CodeInvalid;
if ( check(TokType::Module_Export) )
{
mflags = ModuleFlag::Export;
mflags = ModuleFlag_Export;
eat( TokType::Module_Export );
}
// <ModuleFlags>
@ -1039,8 +1039,8 @@ CodeBody parse_class_struct_body( TokType which, Token name )
if ( attributes )
{
String fused = String::make_reserve( GlobalAllocator, attributes->Content.length() + more_attributes->Content.length() );
fused.append_fmt( "%S %S", attributes->Content, more_attributes->Content );
String fused = string_make_reserve( GlobalAllocator, length(attributes->Content) + length(more_attributes->Content) );
append_fmt( fused, "%S %S", attributes->Content, more_attributes->Content );
attributes->Name = get_cached_string(fused);
attributes->Content = attributes->Name;
@ -1484,8 +1484,8 @@ CodeFn parse_function_after_name(
using namespace ECode;
String
name_stripped = String::make( GlobalAllocator, name );
name_stripped.strip_space();
name_stripped = string_make( GlobalAllocator, name );
strip_space(name_stripped);
CodeFn
result = (CodeFn) make_code();
@ -2534,7 +2534,7 @@ Code parse_operator_function_or_variable( bool expects_function, CodeAttributes
if ( found_operator )
{
// Dealing with an operator overload
result = parse_operator_after_ret_type( ModuleFlag::None, attributes, specifiers, type );
result = parse_operator_after_ret_type( ModuleFlag_None, attributes, specifiers, type );
// <Attributes> <Specifiers> <ReturnType> operator ...
}
else
@ -2552,7 +2552,7 @@ Code parse_operator_function_or_variable( bool expects_function, CodeAttributes
if ( detected_capture && ! detected_comma )
{
// Dealing with a function
result = parse_function_after_name( ModuleFlag::None, attributes, specifiers, type, name );
result = parse_function_after_name( ModuleFlag_None, attributes, specifiers, type, name );
// <Attributes> <Specifiers> <ReturnType> <Name> ( ...
}
else
@ -2565,7 +2565,7 @@ Code parse_operator_function_or_variable( bool expects_function, CodeAttributes
}
// Dealing with a variable
result = parse_variable_after_name( ModuleFlag::None, attributes, specifiers, type, name );
result = parse_variable_after_name( ModuleFlag_None, attributes, specifiers, type, name );
// <Attributes> <Specifiers> <ValueType> <Name> ...
}
}
@ -3319,7 +3319,7 @@ CodeVar parse_variable_declaration_list()
eat( TokType::Identifier );
// , <Specifiers> <Name>
CodeVar var = parse_variable_after_name( ModuleFlag::None, NoCode, specifiers, NoCode, name );
CodeVar var = parse_variable_after_name( ModuleFlag_None, NoCode, specifiers, NoCode, name );
// , <Specifiers> <Name> ...
if ( ! result )
@ -3589,6 +3589,8 @@ CodeEnum parse_enum( bool inplace_def )
}
// enum <class> <Attributes> <Name>
b32 use_macro_underlying = false;
Code underlying_macro = { nullptr };
if ( currtok.Type == TokType::Assign_Classifer )
{
eat( TokType::Assign_Classifer );
@ -3603,6 +3605,17 @@ CodeEnum parse_enum( bool inplace_def )
}
// enum <class> <Attributes> <Name> : <UnderlyingType>
}
else if ( currtok.Type == TokType::Preprocess_Define )
{
// We'll support the enum_underlying macro
StrC sig = txt("enum_underlying");
if (currtok.Length >= sig.Len && str_compare(currtok.Text, sig.Ptr, sig.Len) == 0 )
{
use_macro_underlying = true;
underlying_macro = parse_simple_preprocess( ETokType::Preprocess_Macro);
}
}
CodeBody body = { nullptr };
@ -3770,11 +3783,18 @@ CodeEnum parse_enum( bool inplace_def )
result->Attributes = attributes;
if ( type )
result->UnderlyingType = type;
{
result->EnumUnderlyingMacro = use_macro_underlying;
if ( use_macro_underlying )
result->UnderlyingTypeMacro = underlying_macro;
else
result->UnderlyingType = type;
}
if ( inline_cmt )
result->InlineCmt = inline_cmt;
Context.pop();
return result;
}
@ -3860,7 +3880,7 @@ CodeFriend parse_friend()
Context.Scope->Name = name;
// friend <ReturnType> <Name>
function = parse_function_after_name( ModuleFlag::None, NoCode, NoCode, type, name );
function = parse_function_after_name( ModuleFlag_None, NoCode, NoCode, type, name );
// Parameter list
// CodeParam params = parse_params();
@ -3914,11 +3934,11 @@ CodeFn parse_function()
CodeAttributes attributes = { nullptr };
CodeSpecifiers specifiers = { nullptr };
ModuleFlag mflags = ModuleFlag::None;
ModuleFlag mflags = ModuleFlag_None;
if ( check(TokType::Module_Export) )
{
mflags = ModuleFlag::Export;
mflags = ModuleFlag_Export;
eat( TokType::Module_Export );
}
// <export>
@ -4024,14 +4044,14 @@ CodeOperator parse_operator()
CodeAttributes attributes = { nullptr };
CodeSpecifiers specifiers = { nullptr };
ModuleFlag mflags = ModuleFlag::None;
ModuleFlag mflags = ModuleFlag_None;
SpecifierT specs_found[16] { ESpecifier::NumSpecifiers };
s32 NumSpecifiers = 0;
if ( check(TokType::Module_Export) )
{
mflags = ModuleFlag::Export;
mflags = ModuleFlag_Export;
eat( TokType::Module_Export );
}
// <export>
@ -4114,7 +4134,7 @@ CodeOpCast parse_operator_cast( CodeSpecifiers specifiers )
Code type = parse_type();
// <Specifiers> <Qualifier> :: ... operator <UnderlyingType>
Context.Scope->Name = { type->Name.Data, type->Name.length() };
Context.Scope->Name = { type->Name.Data, length(type->Name) };
eat( TokType::Capture_Start );
eat( TokType::Capture_End );
@ -4212,11 +4232,11 @@ CodeTemplate parse_template()
push_scope();
ModuleFlag mflags = ModuleFlag::None;
ModuleFlag mflags = ModuleFlag_None;
if ( check( TokType::Module_Export ) )
{
mflags = ModuleFlag::Export;
mflags = ModuleFlag_Export;
eat( TokType::Module_Export );
}
// <export> template
@ -4855,11 +4875,11 @@ CodeTypedef parse_typedef()
Code array_expr = { nullptr };
Code type = { nullptr };
ModuleFlag mflags = ModuleFlag::None;
ModuleFlag mflags = ModuleFlag_None;
if ( check(TokType::Module_Export) )
{
mflags = ModuleFlag::Export;
mflags = ModuleFlag_Export;
eat( TokType::Module_Export );
}
// <ModuleFlags>
@ -5050,11 +5070,11 @@ CodeUnion parse_union( bool inplace_def )
{
push_scope();
ModuleFlag mflags = ModuleFlag::None;
ModuleFlag mflags = ModuleFlag_None;
if ( check(TokType::Module_Export) )
{
mflags = ModuleFlag::Export;
mflags = ModuleFlag_Export;
eat( TokType::Module_Export );
}
// <ModuleFlags>
@ -5199,12 +5219,12 @@ CodeUsing parse_using()
bool is_namespace = false;
ModuleFlag mflags = ModuleFlag::None;
ModuleFlag mflags = ModuleFlag_None;
CodeAttributes attributes = { nullptr };
if ( check(TokType::Module_Export) )
{
mflags = ModuleFlag::Export;
mflags = ModuleFlag_Export;
eat( TokType::Module_Export );
}
// <ModuleFlags>
@ -5293,13 +5313,13 @@ CodeVar parse_variable()
SpecifierT specs_found[16] { ESpecifier::NumSpecifiers };
s32 NumSpecifiers = 0;
ModuleFlag mflags = ModuleFlag::None;
ModuleFlag mflags = ModuleFlag_None;
CodeAttributes attributes = { nullptr };
CodeSpecifiers specifiers = { nullptr };
if ( check(TokType::Module_Export) )
{
mflags = ModuleFlag::Export;
mflags = ModuleFlag_Export;
eat( TokType::Module_Export );
}
// <ModuleFlags>

View File

@ -13,63 +13,71 @@ using LogFailType = ssize(*)(char const*, ...);
#define log_failure GEN_FATAL
#endif
enum class AccessSpec : u32
enum AccessSpec enum_underlying(u32)
{
Default,
Private,
Protected,
Public,
AccessSpec_Default,
AccessSpec_Private,
AccessSpec_Protected,
AccessSpec_Public,
Num_AccessSpec,
Invalid,
AccessSpec_Num_AccessSpec,
AccessSpec_Invalid,
AccessSpec_SizeDef = GEN_U32_MAX,
};
static_assert( size_of(AccessSpec) == size_of(u32));
inline
char const* to_str( AccessSpec type )
{
local_persist
char const* lookup[ (u32)AccessSpec::Num_AccessSpec ] = {
char const* lookup[ (u32)AccessSpec_Num_AccessSpec ] = {
"",
"private",
"protected",
"public",
};
if ( type > AccessSpec::Public )
if ( type > AccessSpec_Public )
return "Invalid";
return lookup[ (u32)type ];
}
enum CodeFlag : u32
enum CodeFlag enum_underlying(u32)
{
None = 0,
FunctionType = bit(0),
ParamPack = bit(1),
Module_Export = bit(2),
Module_Import = bit(3),
CodeFlag_None = 0,
CodeFlag_FunctionType = bit(0),
CodeFlag_ParamPack = bit(1),
CodeFlag_Module_Export = bit(2),
CodeFlag_Module_Import = bit(3),
CodeFlag_SizeDef = GEN_U32_MAX,
};
static_assert( size_of(CodeFlag) == size_of(u32));
// Used to indicate if enum definitoin is an enum class or regular enum.
enum class EnumT : u8
enum EnumDecl enum_underlying(u8)
{
Regular,
Class
EnumDecl_Regular,
EnumDecl_Class,
EnumT_SizeDef = GEN_U8_MAX,
};
typedef u8 EnumT;
constexpr EnumT EnumClass = EnumT::Class;
constexpr EnumT EnumRegular = EnumT::Regular;
enum class ModuleFlag : u32
enum ModuleFlag enum_underlying(u32)
{
None = 0,
Export = bit(0),
Import = bit(1),
ModuleFlag_None = 0,
ModuleFlag_Export = bit(0),
ModuleFlag_Import = bit(1),
Num_ModuleFlags,
Invalid,
ModuleFlag_Invalid,
ModuleFlag_SizeDef = GEN_U32_MAX,
};
static_assert( size_of(ModuleFlag) == size_of(u32));
inline
StrC to_str( ModuleFlag flag )
@ -81,7 +89,7 @@ StrC to_str( ModuleFlag flag )
{ sizeof("import"), "import" },
};
if ( flag > ModuleFlag::Import )
if ( flag > ModuleFlag_Import )
return { sizeof("invalid"), "invalid" };
return lookup[ (u32)flag ];
@ -93,15 +101,13 @@ ModuleFlag operator|( ModuleFlag A, ModuleFlag B)
return (ModuleFlag)( (u32)A | (u32)B );
}
enum class EPreprocessCond : u32
enum EPreprocessCond enum_underlying(u32)
{
If,
IfDef,
IfNotDef,
ElIf
};
PreprocessCond_If,
PreprocessCond_IfDef,
PreprocessCond_IfNotDef,
PreprocessCond_ElIf,
constexpr EPreprocessCond PreprocessCond_If = EPreprocessCond::If;
constexpr EPreprocessCond PreprocessCond_IfDef = EPreprocessCond::IfDef;
constexpr EPreprocessCond PreprocessCond_IfNotDef = EPreprocessCond::IfNotDef;
constexpr EPreprocessCond PreprocessCond_ElIf = EPreprocessCond::ElIf;
EPreprocessCond_SizeDef = GEN_U32_MAX,
};
static_assert( size_of(EPreprocessCond) == size_of(u32));

View File

@ -352,6 +352,28 @@ bool set_capacity(Array<Type>& array, usize new_capacity)
Data = rcast(Type*, new_header + 1);
return true;
}
#define array_init(Type, allocator) array_init<Type>(allocator)
#define array_init(Type, allocator) array_init<Type>(allocator)
#define array_init_reserve(Type, allocator, capacity) array_init_reserve<Type>(allocator, capacity)
#define array_append(Type, array, other) append<Type>(array, other)
#define array_append_value(Type, array, value) append<Type>(array, value)
#define array_append_items(Type, array, items, item_num) append<Type>(array, items, item_num)
#define array_append_at(Type, array, item, idx) append_at<Type>(array, item, idx)
#define array_append_items_at(Type, array, items, num, idx) append_at<Type>(array, items, num, idx)
#define array_back(Type, array) back<Type>(array)
#define array_clear(Type, array) clear<Type>(array)
#define array_fill(Type, array, begin, end, value) fill<Type>(array, begin, end, value)
#define array_free(Type, array) free<Type>(array)
#define array_grow(Type, array, min_capacity) grow<Type>(array, min_capacity)
#define array_num(Type, array) num<Type>(array)
#define array_pop(Type, array) pop<Type>(array)
#define array_remove_at(Type, array, idx) remove_at<Type>(array, idx)
#define array_reserve(Type, array, new_capacity) reserve<Type>(array, new_capacity)
#define array_resize(Type, array, num) resize<Type>(array, num)
#define array_set_capacity(Type, array, new_capacity) set_capacity<Type>(array, new_capacity)
#define array_get_header(array) get_header(array)
#pragma endregion Array
// TODO(Ed) : This thing needs ALOT of work.
@ -372,7 +394,8 @@ struct HashTableEntry {
Type Value;
};
// Forward declarations for all lifted functions
#define HashTableEntry(Type) HashTableEntry<Type>
template<class Type> HashTable<Type> hashtable_init(AllocatorInfo allocator);
template<class Type> HashTable<Type> hashtable_init_reserve(AllocatorInfo allocator, usize num);
template<class Type> void clear(HashTable<Type>& table);
@ -399,7 +422,7 @@ struct HashTable
Array<ssize> Hashes;
Array<HashTableEntry<Type>> Entries;
#if 1
#if GEN_SUPPORT_CPP_MEMBER_FEATURES
#pragma region Member Mapping
forceinline static HashTable init(AllocatorInfo allocator) { return GEN_NS hashtable_init<Type>(allocator); }
forceinline static HashTable init_reserve(AllocatorInfo allocator, usize num) { return GEN_NS hashtable_init_reserve<Type>(allocator, num); }
@ -634,6 +657,25 @@ bool full(HashTable<Type>& table) {
b32 result = num(table.Entries) > critical_load;
return result;
}
#define hashtable_init(Type, allocator) hashtable_init<Type>(allocator)
#define hashtable_init_reserve(Type, allocator, num) hashtable_init_reserve<Type>(allocator, num)
#define hashtable_clear(Type, table) clear<Type>(table)
#define hashtable_destroy(Type, table) destroy<Type>(table)
#define hashtable_get(Type, table, key) get<Type>(table, key)
#define hashtable_grow(Type, table) grow<Type>(table)
#define hashtable_rehash(Type, table, new_num) rehash<Type>(table, new_num)
#define hashtable_rehash_fast(Type, table) rehash_fast<Type>(table)
#define hashtable_remove(Type, table, key) remove<Type>(table, key)
#define hashtable_remove_entry(Type, table, idx) remove_entry<Type>(table, idx)
#define hashtable_set(Type, table, key, value) set<Type>(table, key, value)
#define hashtable_slot(Type, table, key) slot<Type>(table, key)
#define hashtable_add_entry(Type, table, key) add_entry<Type>(table, key)
#define hashtable_find(Type, table, key) find<Type>(table, key)
#define hashtable_full(Type, table) full<Type>(table)
#define hashtable_map(Type, table, map_proc) map<Type>(table, map_proc)
#define hashtable_map_mut(Type, table, map_proc) map_mut<Type>(table, map_proc)
#pragma endregion HashTable
#pragma endregion Containers

View File

@ -205,4 +205,14 @@
# define foreach(Type, entry_id, iterable) for ( Type entry_id : iterable )
#endif
#if GENC_COMPILERC
# if __STDC_VERSION__ >= 202311L
# define enum_underlying(type) : type
# else
# define enum_underlying(type)
# endif
#else
# define enum_underlying(type) : type
#endif
#pragma endregion Macros

View File

@ -447,7 +447,7 @@ char* adt_parse_number_strict( ADT_Node* node, char* base_str )
while ( *e )
++e;
while ( *p && ( str_find( "eE.+-", *p ) || char_is_hex_digit( *p ) ) )
while ( *p && ( char_first_occurence( "eE.+-", *p ) || char_is_hex_digit( *p ) ) )
{
++p;
}
@ -476,7 +476,7 @@ char* adt_parse_number( ADT_Node* node, char* base_str )
u8 node_props = 0;
/* skip false positives and special cases */
if ( ! ! str_find( "eE", *p ) || ( ! ! str_find( ".+-", *p ) && ! char_is_hex_digit( *( p + 1 ) ) && *( p + 1 ) != '.' ) )
if ( ! ! char_first_occurence( "eE", *p ) || ( ! ! char_first_occurence( ".+-", *p ) && ! char_is_hex_digit( *( p + 1 ) ) && *( p + 1 ) != '.' ) )
{
return ++base_str;
}
@ -552,7 +552,7 @@ char* adt_parse_number( ADT_Node* node, char* base_str )
char expbuf[ 6 ] = { 0 };
ssize expi = 0;
if ( *e && ! ! str_find( "eE", *e ) )
if ( *e && ! ! char_first_occurence( "eE", *e ) )
{
++e;
if ( *e == '+' || *e == '-' || char_is_digit( *e ) )
@ -748,7 +748,7 @@ ADT_Error adt_print_string( FileInfo* file, ADT_Node* node, char const* escaped_
{
p = str_skip_any( p, escaped_chars );
_adt_fprintf( file, "%.*s", pointer_diff( b, p ), b );
if ( *p && ! ! str_find( escaped_chars, *p ) )
if ( *p && ! ! char_first_occurence( escaped_chars, *p ) )
{
_adt_fprintf( file, "%s%c", escape_symbol, *p );
p++;
@ -1102,7 +1102,7 @@ String csv_write_string_delimiter( AllocatorInfo a, CSV_Object* obj, char delimi
ssize fsize;
u8* buf = file_stream_buf( &tmp, &fsize );
String output = String::make_length( a, ( char* )buf, fsize );
String output = string_make_length( a, ( char* )buf, fsize );
file_close( &tmp );
return output;
}

View File

@ -1,5 +1,3 @@
#define GEN_SUPPORT_CPP_MEMBER_FEATURES 1
#ifdef GEN_INTELLISENSE_DIRECTIVES
# pragma once
#endif
@ -78,13 +76,18 @@
/* Platform compiler */
#if defined( _MSC_VER )
# define GEN_COMPILER_MSVC 1
# define GEN_COMPILER_CLANG 0
# define GEN_COMPILER_MSVC 1
# define GEN_COMPILER_GCC 0
#elif defined( __GNUC__ )
# define GEN_COMPILER_GCC 1
# define GEN_COMPILER_CLANG 0
# define GEN_COMPILER_MSVC 0
# define GEN_COMPILER_GCC 1
#elif defined( __clang__ )
# define GEN_COMPILER_CLANG 1
#elif defined( __MINGW32__ )
# define GEN_COMPILER_MINGW 1
# define GEN_COMPILER_MSVC 0
# define GEN_COMPILER_GCC 1
#else
# error Unknown compiler
#endif
@ -124,11 +127,23 @@
#pragma endregion Mandatory Includes
#if GEN_DONT_USE_NAMESPACE || GEN_COMPILER_C
# define GEN_NS
# define GEN_NS_BEGIN
# define GEN_NS_END
#if GEN_DONT_USE_NAMESPACE
# if GEN_COMPILER_C
# define GEN_NS_ENUM_BEGIN
# define GEN_NS_ENUM_END
# define GEN_NS
# define GEN_NS_BEGIN
# define GEN_NS_END
# else
# define GEN_NS_ENUM_BEGIN namespace gen_internal_enums {
# define GEN_NS_ENUM_END }
# define GEN_NS ::
# define GEN_NS_BEGIN
# define GEN_NS_END
# endif
#else
# define GEN_NS_ENUM_BEGIN namespace gen_internal_enums {
# define GEN_NS_ENUM_END }
# define GEN_NS gen::
# define GEN_NS_BEGIN namespace gen {
# define GEN_NS_END }

View File

@ -422,7 +422,7 @@ neverinline ssize str_fmt_va( char* text, ssize max_len, char const* fmt, va_lis
{
String gen_str = String { va_arg( va, char*) };
info.precision = gen_str.length();
info.precision = length(gen_str);
len = _print_string( text, remaining, &info, gen_str );
}
break;

View File

@ -6,7 +6,6 @@
#pragma region String Ops
const char* char_first_occurence( const char* str, char c );
constexpr auto str_find = &char_first_occurence;
b32 char_is_alpha( char c );
b32 char_is_alphanumeric( char c );

View File

@ -8,7 +8,7 @@
// Constant string with length.
struct StrC
{
ssize Len;
ssize Len;
char const* Ptr;
operator char const* () const { return Ptr; }
@ -28,10 +28,14 @@ StrC to_str( char const* str ) {
// They used a header pattern
// I kept it for simplicty of porting but its not necessary to keep it that way.
#pragma region String
struct String;
struct StringHeader;
// Forward declarations for all file-scope functions
#if GEN_COMPILER_C
typedef char* String;
#else
struct String;
#endif
String string_make(AllocatorInfo allocator, char const* str);
String string_make(AllocatorInfo allocator, StrC str);
String string_make_reserve(AllocatorInfo allocator, ssize capacity);
@ -73,11 +77,33 @@ struct StringHeader {
ssize Length;
};
#if ! GEN_COMPILER_C
struct String
{
char* Data;
#if 1
forceinline operator bool() { return Data != nullptr; }
forceinline operator char*() { return Data; }
forceinline operator char const*() const { return Data; }
forceinline operator StrC() const { return { GEN_NS length(* this), Data }; }
String const& operator=(String const& other) const {
if (this == &other)
return *this;
String* this_ = ccast(String*, this);
this_->Data = other.Data;
return *this;
}
forceinline char& operator[](ssize index) { return Data[index]; }
forceinline char const& operator[](ssize index) const { return Data[index]; }
forceinline char* begin() const { return Data; }
forceinline char* end() const { return Data + GEN_NS length(* this); }
#if GEN_SUPPORT_CPP_MEMBER_FEATURES
#pragma region Member Mapping
forceinline static String make(AllocatorInfo allocator, char const* str) { return GEN_NS string_make(allocator, str); }
forceinline static String make(AllocatorInfo allocator, StrC str) { return GEN_NS string_make(allocator, str); }
@ -143,30 +169,14 @@ struct String
return GEN_NS append(*this, buf, res);
}
forceinline operator bool() { return Data != nullptr; }
forceinline operator char*() { return Data; }
forceinline operator char const*() const { return Data; }
forceinline operator StrC() const { return { length(), Data }; }
String const& operator=(String const& other) const {
if (this == &other)
return *this;
String* this_ = ccast(String*, this);
this_->Data = other.Data;
return *this;
}
forceinline char& operator[](ssize index) { return Data[index]; }
forceinline char const& operator[](ssize index) const { return Data[index]; }
forceinline char* begin() const { return Data; }
forceinline char* end() const { return Data + length(); }
#pragma endregion Member Mapping
#endif
};
#endif
inline char* begin(String& str) { return str; }
inline char* end(String& str) { return scast(char*, str) + length(str); }
inline char* next(String& str) { return scast(char*, str) + 1; }
inline
usize string_grow_formula(usize value) {
@ -247,9 +257,9 @@ bool append(String& str, char const* str_to_append, ssize append_length)
StringHeader& header = get_header(str);
mem_copy(str.Data + curr_len, str_to_append, append_length);
mem_copy( scast(char*, str) + curr_len, str_to_append, append_length);
str.Data[curr_len + append_length] = '\0';
str[curr_len + append_length] = '\0';
header.Length = curr_len + append_length;
}
@ -263,7 +273,19 @@ bool append(String& str, StrC str_to_append) {
inline
bool append(String& str, const String other) {
return append(str, other.Data, length(other));
return append(str, other, length(other));
}
bool append_fmt(String& str, char const* fmt, ...) {
ssize res;
char buf[GEN_PRINTF_MAXLEN] = { 0 };
va_list va;
va_start(va, fmt);
res = str_fmt_va(buf, count_of(buf) - 1, fmt, va) - 1;
va_end(va);
return append(str, buf, res);
}
inline
@ -294,7 +316,7 @@ bool are_equal(String lhs, StrC rhs)
inline
ssize avail_space(String const& str) {
StringHeader const& header = *rcast(StringHeader const*, str.Data - sizeof(StringHeader));
StringHeader const& header = *rcast(StringHeader const*, scast(char const*, str) - sizeof(StringHeader));
return header.Capacity - header.Length;
}
@ -306,7 +328,7 @@ char& back(String& str) {
inline
bool contains(String const& str, StrC substring)
{
StringHeader const& header = *rcast(StringHeader const*, str.Data - sizeof(StringHeader));
StringHeader const& header = *rcast(StringHeader const*, scast(char const*, str) - sizeof(StringHeader));
if (substring.Len > header.Length)
return false;
@ -326,7 +348,7 @@ bool contains(String const& str, StrC substring)
inline
bool contains(String const& str, String const& substring)
{
StringHeader const& header = *rcast(StringHeader const*, str.Data - sizeof(StringHeader));
StringHeader const& header = *rcast(StringHeader const*, scast(char const*, str) - sizeof(StringHeader));
if (length(substring) > header.Length)
return false;
@ -345,7 +367,7 @@ bool contains(String const& str, String const& substring)
inline
ssize capacity(String const& str) {
StringHeader const& header = *rcast(StringHeader const*, str.Data - sizeof(StringHeader));
StringHeader const& header = *rcast(StringHeader const*, scast(char const*, str) - sizeof(StringHeader));
return header.Capacity;
}
@ -356,7 +378,7 @@ void clear(String& str) {
inline
String duplicate(String const& str, AllocatorInfo allocator) {
return string_make_length(allocator, str.Data, length(str));
return string_make_length(allocator, str, length(str));
}
inline
@ -376,7 +398,7 @@ StringHeader& get_header(String& str) {
inline
ssize length(String const& str)
{
StringHeader const& header = *rcast(StringHeader const*, str.Data - sizeof(StringHeader));
StringHeader const& header = *rcast(StringHeader const*, scast(char const*, str) - sizeof(StringHeader));
return header.Length;
}
@ -511,10 +533,10 @@ void trim_space(String& str) {
inline
String visualize_whitespace(String const& str)
{
StringHeader* header = (StringHeader*)(str.Data - sizeof(StringHeader));
StringHeader* header = (StringHeader*)(scast(char const*, str) - sizeof(StringHeader));
String result = string_make_reserve(header->Allocator, length(str) * 2); // Assume worst case for space requirements.
for (char c : str) switch (c)
for (auto c : str) switch (c)
{
case ' ':
append(result, txt("·"));
@ -549,10 +571,10 @@ struct String_POD {
static_assert( sizeof( String_POD ) == sizeof( String ), "String is not a POD" );
// Implements basic string interning. Data structure is based off the ZPL Hashtable.
using StringTable = HashTable<String const>;
typedef HashTable<String const> StringTable;
// Represents strings cached with the string table.
// Should never be modified, if changed string is desired, cache_string( str ) another.
using StringCached = String const;
typedef String const StringCached;
#pragma endregion Strings

View File

@ -20,14 +20,14 @@ CodeBody gen_ecode( char const* path )
Array<ADT_Node> enum_strs = csv_nodes.nodes[0].nodes;
String enum_entries = String::make_reserve( GlobalAllocator, kilobytes(1) );
String to_str_entries = String::make_reserve( GlobalAllocator, kilobytes(1) );
String enum_entries = string_make_reserve( GlobalAllocator, kilobytes(1) );
String to_str_entries = string_make_reserve( GlobalAllocator, kilobytes(1) );
for ( ADT_Node node : enum_strs )
{
char const* code = node.string;
enum_entries.append_fmt( "%s,\n", code );
to_str_entries.append_fmt( "{ sizeof(\"%s\"), \"%s\" },\n", code, code );
append_fmt( enum_entries, "%s,\n", code );
append_fmt( to_str_entries, "{ sizeof(\"%s\"), \"%s\" },\n", code, code );
}
CodeEnum enum_code = parse_enum(gen::token_fmt_impl((3 + 1) / 2, "entries", (StrC)enum_entries, "enum Type : u32 { <entries> NumTypes };"));
@ -67,16 +67,16 @@ CodeBody gen_eoperator( char const* path )
Array<ADT_Node> enum_strs = csv_nodes.nodes[0].nodes;
Array<ADT_Node> str_strs = csv_nodes.nodes[1].nodes;
String enum_entries = String::make_reserve( GlobalAllocator, kilobytes(1) );
String to_str_entries = String::make_reserve( GlobalAllocator, kilobytes(1) );
String enum_entries = string_make_reserve( GlobalAllocator, kilobytes(1) );
String to_str_entries = string_make_reserve( GlobalAllocator, kilobytes(1) );
for (usize idx = 0; idx < num(enum_strs); idx++)
{
char const* enum_str = enum_strs[idx].string;
char const* entry_to_str = str_strs [idx].string;
enum_entries.append_fmt( "%s,\n", enum_str );
to_str_entries.append_fmt( "{ sizeof(\"%s\"), \"%s\" },\n", entry_to_str, entry_to_str);
append_fmt( enum_entries, "%s,\n", enum_str );
append_fmt( to_str_entries, "{ sizeof(\"%s\"), \"%s\" },\n", entry_to_str, entry_to_str);
}
CodeEnum enum_code = parse_enum(token_fmt("entries", (StrC)enum_entries, stringize(
@ -123,16 +123,16 @@ CodeBody gen_especifier( char const* path )
Array<ADT_Node> enum_strs = csv_nodes.nodes[0].nodes;
Array<ADT_Node> str_strs = csv_nodes.nodes[1].nodes;
String enum_entries = String::make_reserve( GlobalAllocator, kilobytes(1) );
String to_str_entries = String::make_reserve( GlobalAllocator, kilobytes(1) );
String enum_entries = string_make_reserve( GlobalAllocator, kilobytes(1) );
String to_str_entries = string_make_reserve( GlobalAllocator, kilobytes(1) );
for (usize idx = 0; idx < num(enum_strs); idx++)
{
char const* enum_str = enum_strs[idx].string;
char const* entry_to_str = str_strs [idx].string;
enum_entries.append_fmt( "%s,\n", enum_str );
to_str_entries.append_fmt( "{ sizeof(\"%s\"), \"%s\" },\n", entry_to_str, entry_to_str);
append_fmt( enum_entries, "%s,\n", enum_str );
append_fmt( to_str_entries, "{ sizeof(\"%s\"), \"%s\" },\n", entry_to_str, entry_to_str);
}
CodeEnum enum_code = parse_enum(token_fmt("entries", (StrC)enum_entries, stringize(
@ -237,19 +237,19 @@ CodeBody gen_etoktype( char const* etok_path, char const* attr_path )
Array<ADT_Node> attribute_strs = csv_attr_nodes.nodes[0].nodes;
Array<ADT_Node> attribute_str_strs = csv_attr_nodes.nodes[1].nodes;
String enum_entries = String::make_reserve( GlobalAllocator, kilobytes(2) );
String to_str_entries = String::make_reserve( GlobalAllocator, kilobytes(4) );
String attribute_entries = String::make_reserve( GlobalAllocator, kilobytes(2) );
String to_str_attributes = String::make_reserve( GlobalAllocator, kilobytes(4) );
String attribute_define_entries = String::make_reserve( GlobalAllocator, kilobytes(4) );
String enum_entries = string_make_reserve( GlobalAllocator, kilobytes(2) );
String to_str_entries = string_make_reserve( GlobalAllocator, kilobytes(4) );
String attribute_entries = string_make_reserve( GlobalAllocator, kilobytes(2) );
String to_str_attributes = string_make_reserve( GlobalAllocator, kilobytes(4) );
String attribute_define_entries = string_make_reserve( GlobalAllocator, kilobytes(4) );
for (usize idx = 0; idx < num(enum_strs); idx++)
{
char const* enum_str = enum_strs[idx].string;
char const* entry_to_str = enum_str_strs [idx].string;
enum_entries.append_fmt( "%s,\n", enum_str );
to_str_entries.append_fmt( "{ sizeof(\"%s\"), \"%s\" },\n", entry_to_str, entry_to_str);
append_fmt( enum_entries, "%s,\n", enum_str );
append_fmt( to_str_entries, "{ sizeof(\"%s\"), \"%s\" },\n", entry_to_str, entry_to_str);
}
for ( usize idx = 0; idx < num(attribute_strs); idx++ )
@ -257,14 +257,14 @@ CodeBody gen_etoktype( char const* etok_path, char const* attr_path )
char const* attribute_str = attribute_strs[idx].string;
char const* entry_to_str = attribute_str_strs [idx].string;
attribute_entries.append_fmt( "Attribute_%s,\n", attribute_str );
to_str_attributes.append_fmt( "{ sizeof(\"%s\"), \"%s\" },\n", entry_to_str, entry_to_str);
attribute_define_entries.append_fmt( "Entry( Attribute_%s, \"%s\" )", attribute_str, entry_to_str );
append_fmt( attribute_entries, "Attribute_%s,\n", attribute_str );
append_fmt( to_str_attributes, "{ sizeof(\"%s\"), \"%s\" },\n", entry_to_str, entry_to_str);
append_fmt( attribute_define_entries, "Entry( Attribute_%s, \"%s\" )", attribute_str, entry_to_str );
if ( idx < num(attribute_strs) - 1 )
attribute_define_entries.append( " \\\n");
append( attribute_define_entries, " \\\n");
else
attribute_define_entries.append( "\n");
append( attribute_define_entries, "\n");
}
#pragma push_macro("GEN_DEFINE_ATTRIBUTE_TOKENS")