mirror of
https://github.com/Ed94/gencpp.git
synced 2024-12-22 15:54:45 -08:00
Compare commits
4 Commits
ed0c0422ad
...
9e88cb8724
Author | SHA1 | Date | |
---|---|---|---|
9e88cb8724 | |||
f61c1c560d | |||
8ef982003a | |||
31691b1466 |
@ -90,6 +90,7 @@ CodeBody parse_file( const char* path )
|
||||
{
|
||||
FileContents file = file_read_contents( GlobalAllocator, true, path );
|
||||
CodeBody code = parse_global_body( { file.size, (char const*)file.data } );
|
||||
log_fmt("\nParsed: %s\n", path);
|
||||
return code;
|
||||
}
|
||||
|
||||
@ -126,7 +127,7 @@ int gen_main()
|
||||
header.print( debug );
|
||||
|
||||
CodeBody parsed_memory = parse_file( project_dir "dependencies/memory.hpp" );
|
||||
CodeBody memory = def_body(ECode::Struct_Body);
|
||||
CodeBody memory = def_body(ECode::Global_Body);
|
||||
for ( Code entry = parsed_memory.begin(); entry != parsed_memory.end(); ++ entry )
|
||||
{
|
||||
switch (entry->Type)
|
||||
@ -145,12 +146,31 @@ int gen_main()
|
||||
CodeFn fn = entry.cast<CodeFn>();
|
||||
s32 constexpr_found = fn->Specs.remove( ESpecifier::Constexpr );
|
||||
if (constexpr_found > -1) {
|
||||
log_fmt("Found constexpr proc\n");
|
||||
log_fmt("Found constexpr: %S\n", entry->to_string());
|
||||
fn->Specs.append(ESpecifier::Inline);
|
||||
}
|
||||
memory.append(entry);
|
||||
}
|
||||
break;
|
||||
case ECode::Template:
|
||||
{
|
||||
CodeTemplate tmpl = entry.cast<CodeTemplate>();
|
||||
if ( tmpl->Declaration->Name.contains(txt("swap")))
|
||||
{
|
||||
CodeBody macro_swap = parse_global_body( txt(R"(
|
||||
#define swap( a, b ) \
|
||||
do \
|
||||
{ \
|
||||
typeof( a ) temp = ( a ); \
|
||||
( a ) = ( b ); \
|
||||
( b ) = temp; \
|
||||
} while ( 0 )
|
||||
)"
|
||||
));
|
||||
memory.append(macro_swap);
|
||||
}
|
||||
}
|
||||
break;
|
||||
case ECode::Class:
|
||||
case ECode::Struct:
|
||||
{
|
||||
@ -175,17 +195,26 @@ int gen_main()
|
||||
break;
|
||||
case ECode::Preprocess_If:
|
||||
{
|
||||
ignore_preprocess_cond_block(txt("GEN_SUPPORT_CPP_MEMBER_FEATURES"), entry, parsed_memory );
|
||||
b32 found = ignore_preprocess_cond_block(txt("GEN_SUPPORT_CPP_MEMBER_FEATURES"), entry, parsed_memory );
|
||||
if (found) break;
|
||||
|
||||
memory.append(entry);
|
||||
}
|
||||
break;
|
||||
case ECode::Preprocess_IfDef:
|
||||
{
|
||||
ignore_preprocess_cond_block(txt("GEN_INTELLISENSE_DIRECTIVES"), entry, parsed_memory );
|
||||
b32 found = ignore_preprocess_cond_block(txt("GEN_INTELLISENSE_DIRECTIVES"), entry, parsed_memory );
|
||||
if (found) break;
|
||||
|
||||
memory.append(entry);
|
||||
}
|
||||
break;
|
||||
case ECode::Preprocess_Pragma:
|
||||
{
|
||||
swap_pragma_region_implementation( txt("FixedArena"), gen_fixed_arenas, entry, memory);
|
||||
b32 found = swap_pragma_region_implementation( txt("FixedArena"), gen_fixed_arenas, entry, memory);
|
||||
if (found) break;
|
||||
|
||||
memory.append(entry);
|
||||
}
|
||||
break;
|
||||
default: {
|
||||
@ -194,26 +223,28 @@ int gen_main()
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
header.print( memory );
|
||||
header.print( dump_to_scratch_and_retireve(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);
|
||||
CodeBody printing = def_body(ECode::Global_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 );
|
||||
}
|
||||
}
|
||||
b32 found = ignore_preprocess_cond_block(txt("GEN_INTELLISENSE_DIRECTIVES"), entry, printing_parsed );
|
||||
if (found) break;
|
||||
|
||||
if (entry->Type == ECode::Variable &&
|
||||
contains(entry->Name, txt("Msg_Invalid_Value")))
|
||||
printing.append(entry);
|
||||
}
|
||||
break;
|
||||
case ECode::Variable:
|
||||
{
|
||||
if (contains(entry->Name, txt("Msg_Invalid_Value")))
|
||||
{
|
||||
CodeDefine define = def_define(entry->Name, entry->Value->Content);
|
||||
printing.append(define);
|
||||
@ -221,38 +252,105 @@ int gen_main()
|
||||
}
|
||||
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;
|
||||
default:
|
||||
printing.append(entry);
|
||||
break;
|
||||
}
|
||||
}
|
||||
header.print(dump_to_scratch_and_retireve(printing));
|
||||
|
||||
header.print(containers);
|
||||
CodeBody containers = def_body(ECode::Global_Body);
|
||||
{
|
||||
containers.append( def_pragma(code(region Containers)));
|
||||
|
||||
containers.append( gen_array_base() );
|
||||
containers.append( gen_hashtable_base() );
|
||||
|
||||
containers.append( def_pragma(code(endregion Containers)));
|
||||
}
|
||||
header.print(fmt_newline);
|
||||
header.print(dump_to_scratch_and_retireve(containers));
|
||||
|
||||
Code hashing = scan_file( project_dir "dependencies/hashing.hpp" );
|
||||
header.print( hashing );
|
||||
|
||||
CodeBody parsed_strings = parse_file( project_dir "dependencies/strings.hpp" );
|
||||
CodeBody strings = def_body(ECode::Global_Body);
|
||||
for ( Code entry = parsed_strings.begin(); entry != parsed_strings.end(); ++ entry )
|
||||
{
|
||||
switch (entry->Type)
|
||||
{
|
||||
case ECode::Preprocess_If:
|
||||
{
|
||||
ignore_preprocess_cond_block(txt("! GEN_COMPILER_C"), entry, parsed_strings);
|
||||
}
|
||||
break;
|
||||
|
||||
case ECode::Preprocess_IfDef:
|
||||
{
|
||||
ignore_preprocess_cond_block(txt("GEN_INTELLISENSE_DIRECTIVES"), entry, parsed_strings );
|
||||
}
|
||||
break;
|
||||
|
||||
case ECode::Struct_Fwd:
|
||||
{
|
||||
if ( entry->Name.is_equal(txt("String")) )
|
||||
{
|
||||
CodeTypedef c_def = parse_typedef(code( typedef Type* String; ));
|
||||
strings.append(c_def);
|
||||
strings.append(fmt_newline);
|
||||
++ entry;
|
||||
continue;
|
||||
}
|
||||
strings.append(entry);
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
strings.append(entry);
|
||||
break;
|
||||
}
|
||||
}
|
||||
header.print(dump_to_scratch_and_retireve(strings));
|
||||
|
||||
Code filesystem = scan_file( project_dir "dependencies/filesystem.hpp" );
|
||||
Code timing = scan_file( project_dir "dependencies/timing.hpp" );
|
||||
header.print( filesystem );
|
||||
header.print( timing );
|
||||
|
||||
header.print_fmt( "\nGEN_NS_END\n" );
|
||||
header.print_fmt( roll_own_dependencies_guard_end );
|
||||
|
||||
Code types = scan_file( project_dir "components/types.hpp" );
|
||||
Code ast = scan_file( project_dir "components/ast.hpp" );
|
||||
Code ast_types = scan_file( project_dir "components/ast_types.hpp" );
|
||||
Code code_types = scan_file( project_dir "components/code_types.hpp" );
|
||||
Code interface = scan_file( project_dir "components/interface.hpp" );
|
||||
Code inlines = scan_file( project_dir "components/inlines.hpp" );
|
||||
Code header_end = scan_file( project_dir "components/header_end.hpp" );
|
||||
|
||||
CodeBody ecode = gen_ecode ( project_dir "enums/ECode.csv" );
|
||||
CodeBody eoperator = gen_eoperator ( project_dir "enums/EOperator.csv" );
|
||||
CodeBody especifier = gen_especifier( project_dir "enums/ESpecifier.csv" );
|
||||
CodeBody ast_inlines = gen_ast_inlines();
|
||||
|
||||
header.print_fmt("#pragma region Types\n");
|
||||
header.print( types );
|
||||
header.print( fmt_newline );
|
||||
header.print( dump_to_scratch_and_retireve( ecode ));
|
||||
header.print( fmt_newline );
|
||||
header.print( dump_to_scratch_and_retireve( eoperator ));
|
||||
header.print( fmt_newline );
|
||||
header.print( dump_to_scratch_and_retireve( especifier ));
|
||||
header.print( fmt_newline );
|
||||
header.print_fmt("#pragma endregion Types\n\n");
|
||||
}
|
||||
|
||||
header.print( pop_ignores );
|
||||
header.write();
|
||||
|
||||
format_file( "gen/gen.h" );
|
||||
// format_file( "gen/gen.h" );
|
||||
|
||||
gen::deinit();
|
||||
return 0;
|
||||
|
@ -19,7 +19,7 @@ CodeBody gen_array_base()
|
||||
// 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 ) );
|
||||
return def_global_body( args( fmt_newline, td_header, header, get_header, fmt_newline ) );
|
||||
};
|
||||
|
||||
CodeBody gen_array( StrC type, StrC array_name )
|
||||
|
@ -7,9 +7,13 @@ using SwapContentProc = CodeBody(void);
|
||||
|
||||
b32 ignore_preprocess_cond_block( StrC cond_sig, Code& entry_iter, CodeBody& body )
|
||||
{
|
||||
b32 found = false;
|
||||
CodePreprocessCond cond = entry_iter.cast<CodePreprocessCond>();
|
||||
if ( cond->Content.contains(cond_sig) )
|
||||
{
|
||||
log_fmt("Preprocess cond found: %S\n", cond->Content);
|
||||
found = true;
|
||||
|
||||
s32 depth = 1;
|
||||
++ entry_iter; for(b32 continue_for = true; continue_for && entry_iter != body.end(); ) switch
|
||||
(entry_iter->Type) {
|
||||
@ -34,7 +38,7 @@ b32 ignore_preprocess_cond_block( StrC cond_sig, Code& entry_iter, CodeBody& bod
|
||||
}
|
||||
}
|
||||
|
||||
return entry_iter != body.end();
|
||||
return found;
|
||||
}
|
||||
|
||||
bool swap_pragma_region_implementation( StrC region_name, SwapContentProc* swap_content, Code& entry_iter, CodeBody& body )
|
||||
|
@ -165,6 +165,7 @@ struct Code
|
||||
char const* debug_str(); \
|
||||
Code duplicate(); \
|
||||
bool is_equal( Code other ); \
|
||||
bool is_body(); \
|
||||
bool is_valid(); \
|
||||
void set_global(); \
|
||||
String to_string(); \
|
||||
@ -259,6 +260,7 @@ struct AST
|
||||
Code& entry ( u32 idx );
|
||||
bool has_entries();
|
||||
bool is_equal ( AST* other );
|
||||
bool is_body();
|
||||
char const* type_str();
|
||||
bool validate_body();
|
||||
|
||||
|
@ -11,6 +11,10 @@ struct CodeBody
|
||||
|
||||
void append( Code other )
|
||||
{
|
||||
if (other.is_body())
|
||||
{
|
||||
append( other.cast<CodeBody>() );
|
||||
}
|
||||
raw()->append( other.ast );
|
||||
}
|
||||
void append( CodeBody body )
|
||||
|
@ -24,6 +24,15 @@ inline Code Code::duplicate()
|
||||
return { rcast( AST*, ast )->duplicate() };
|
||||
}
|
||||
|
||||
inline bool Code::is_body()
|
||||
{
|
||||
if ( ast == nullptr )
|
||||
{
|
||||
return rcast( AST*, ast )->is_body();
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
inline bool Code::is_equal( Code other )
|
||||
{
|
||||
if ( ast == nullptr || other.ast == nullptr )
|
||||
@ -91,6 +100,15 @@ inline Code CodeBody::duplicate()
|
||||
return { rcast( AST*, ast )->duplicate() };
|
||||
}
|
||||
|
||||
inline bool CodeBody::is_body()
|
||||
{
|
||||
if ( ast == nullptr )
|
||||
{
|
||||
return rcast( AST*, ast )->is_body();
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
inline bool CodeBody::is_equal( Code other )
|
||||
{
|
||||
if ( ast == nullptr || other.ast == nullptr )
|
||||
@ -158,6 +176,15 @@ inline Code CodeAttributes::duplicate()
|
||||
return { rcast( AST*, ast )->duplicate() };
|
||||
}
|
||||
|
||||
inline bool CodeAttributes::is_body()
|
||||
{
|
||||
if ( ast == nullptr )
|
||||
{
|
||||
return rcast( AST*, ast )->is_body();
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
inline bool CodeAttributes::is_equal( Code other )
|
||||
{
|
||||
if ( ast == nullptr || other.ast == nullptr )
|
||||
@ -245,6 +272,15 @@ inline Code CodeComment::duplicate()
|
||||
return { rcast( AST*, ast )->duplicate() };
|
||||
}
|
||||
|
||||
inline bool CodeComment::is_body()
|
||||
{
|
||||
if ( ast == nullptr )
|
||||
{
|
||||
return rcast( AST*, ast )->is_body();
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
inline bool CodeComment::is_equal( Code other )
|
||||
{
|
||||
if ( ast == nullptr || other.ast == nullptr )
|
||||
@ -332,6 +368,15 @@ inline Code CodeConstructor::duplicate()
|
||||
return { rcast( AST*, ast )->duplicate() };
|
||||
}
|
||||
|
||||
inline bool CodeConstructor::is_body()
|
||||
{
|
||||
if ( ast == nullptr )
|
||||
{
|
||||
return rcast( AST*, ast )->is_body();
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
inline bool CodeConstructor::is_equal( Code other )
|
||||
{
|
||||
if ( ast == nullptr || other.ast == nullptr )
|
||||
@ -419,6 +464,15 @@ inline Code CodeClass::duplicate()
|
||||
return { rcast( AST*, ast )->duplicate() };
|
||||
}
|
||||
|
||||
inline bool CodeClass::is_body()
|
||||
{
|
||||
if ( ast == nullptr )
|
||||
{
|
||||
return rcast( AST*, ast )->is_body();
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
inline bool CodeClass::is_equal( Code other )
|
||||
{
|
||||
if ( ast == nullptr || other.ast == nullptr )
|
||||
@ -486,6 +540,15 @@ inline Code CodeDefine::duplicate()
|
||||
return { rcast( AST*, ast )->duplicate() };
|
||||
}
|
||||
|
||||
inline bool CodeDefine::is_body()
|
||||
{
|
||||
if ( ast == nullptr )
|
||||
{
|
||||
return rcast( AST*, ast )->is_body();
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
inline bool CodeDefine::is_equal( Code other )
|
||||
{
|
||||
if ( ast == nullptr || other.ast == nullptr )
|
||||
@ -573,6 +636,15 @@ inline Code CodeDestructor::duplicate()
|
||||
return { rcast( AST*, ast )->duplicate() };
|
||||
}
|
||||
|
||||
inline bool CodeDestructor::is_body()
|
||||
{
|
||||
if ( ast == nullptr )
|
||||
{
|
||||
return rcast( AST*, ast )->is_body();
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
inline bool CodeDestructor::is_equal( Code other )
|
||||
{
|
||||
if ( ast == nullptr || other.ast == nullptr )
|
||||
@ -660,6 +732,15 @@ inline Code CodeEnum::duplicate()
|
||||
return { rcast( AST*, ast )->duplicate() };
|
||||
}
|
||||
|
||||
inline bool CodeEnum::is_body()
|
||||
{
|
||||
if ( ast == nullptr )
|
||||
{
|
||||
return rcast( AST*, ast )->is_body();
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
inline bool CodeEnum::is_equal( Code other )
|
||||
{
|
||||
if ( ast == nullptr || other.ast == nullptr )
|
||||
@ -747,6 +828,15 @@ inline Code CodeExec::duplicate()
|
||||
return { rcast( AST*, ast )->duplicate() };
|
||||
}
|
||||
|
||||
inline bool CodeExec::is_body()
|
||||
{
|
||||
if ( ast == nullptr )
|
||||
{
|
||||
return rcast( AST*, ast )->is_body();
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
inline bool CodeExec::is_equal( Code other )
|
||||
{
|
||||
if ( ast == nullptr || other.ast == nullptr )
|
||||
@ -834,6 +924,15 @@ inline Code CodeExtern::duplicate()
|
||||
return { rcast( AST*, ast )->duplicate() };
|
||||
}
|
||||
|
||||
inline bool CodeExtern::is_body()
|
||||
{
|
||||
if ( ast == nullptr )
|
||||
{
|
||||
return rcast( AST*, ast )->is_body();
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
inline bool CodeExtern::is_equal( Code other )
|
||||
{
|
||||
if ( ast == nullptr || other.ast == nullptr )
|
||||
@ -921,6 +1020,15 @@ inline Code CodeFriend::duplicate()
|
||||
return { rcast( AST*, ast )->duplicate() };
|
||||
}
|
||||
|
||||
inline bool CodeFriend::is_body()
|
||||
{
|
||||
if ( ast == nullptr )
|
||||
{
|
||||
return rcast( AST*, ast )->is_body();
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
inline bool CodeFriend::is_equal( Code other )
|
||||
{
|
||||
if ( ast == nullptr || other.ast == nullptr )
|
||||
@ -1008,6 +1116,15 @@ inline Code CodeFn::duplicate()
|
||||
return { rcast( AST*, ast )->duplicate() };
|
||||
}
|
||||
|
||||
inline bool CodeFn::is_body()
|
||||
{
|
||||
if ( ast == nullptr )
|
||||
{
|
||||
return rcast( AST*, ast )->is_body();
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
inline bool CodeFn::is_equal( Code other )
|
||||
{
|
||||
if ( ast == nullptr || other.ast == nullptr )
|
||||
@ -1095,6 +1212,15 @@ inline Code CodeInclude::duplicate()
|
||||
return { rcast( AST*, ast )->duplicate() };
|
||||
}
|
||||
|
||||
inline bool CodeInclude::is_body()
|
||||
{
|
||||
if ( ast == nullptr )
|
||||
{
|
||||
return rcast( AST*, ast )->is_body();
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
inline bool CodeInclude::is_equal( Code other )
|
||||
{
|
||||
if ( ast == nullptr || other.ast == nullptr )
|
||||
@ -1182,6 +1308,15 @@ inline Code CodeModule::duplicate()
|
||||
return { rcast( AST*, ast )->duplicate() };
|
||||
}
|
||||
|
||||
inline bool CodeModule::is_body()
|
||||
{
|
||||
if ( ast == nullptr )
|
||||
{
|
||||
return rcast( AST*, ast )->is_body();
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
inline bool CodeModule::is_equal( Code other )
|
||||
{
|
||||
if ( ast == nullptr || other.ast == nullptr )
|
||||
@ -1269,6 +1404,15 @@ inline Code CodeNS::duplicate()
|
||||
return { rcast( AST*, ast )->duplicate() };
|
||||
}
|
||||
|
||||
inline bool CodeNS::is_body()
|
||||
{
|
||||
if ( ast == nullptr )
|
||||
{
|
||||
return rcast( AST*, ast )->is_body();
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
inline bool CodeNS::is_equal( Code other )
|
||||
{
|
||||
if ( ast == nullptr || other.ast == nullptr )
|
||||
@ -1356,6 +1500,15 @@ inline Code CodeOperator::duplicate()
|
||||
return { rcast( AST*, ast )->duplicate() };
|
||||
}
|
||||
|
||||
inline bool CodeOperator::is_body()
|
||||
{
|
||||
if ( ast == nullptr )
|
||||
{
|
||||
return rcast( AST*, ast )->is_body();
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
inline bool CodeOperator::is_equal( Code other )
|
||||
{
|
||||
if ( ast == nullptr || other.ast == nullptr )
|
||||
@ -1443,6 +1596,15 @@ inline Code CodeOpCast::duplicate()
|
||||
return { rcast( AST*, ast )->duplicate() };
|
||||
}
|
||||
|
||||
inline bool CodeOpCast::is_body()
|
||||
{
|
||||
if ( ast == nullptr )
|
||||
{
|
||||
return rcast( AST*, ast )->is_body();
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
inline bool CodeOpCast::is_equal( Code other )
|
||||
{
|
||||
if ( ast == nullptr || other.ast == nullptr )
|
||||
@ -1530,6 +1692,15 @@ inline Code CodeParam::duplicate()
|
||||
return { rcast( AST*, ast )->duplicate() };
|
||||
}
|
||||
|
||||
inline bool CodeParam::is_body()
|
||||
{
|
||||
if ( ast == nullptr )
|
||||
{
|
||||
return rcast( AST*, ast )->is_body();
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
inline bool CodeParam::is_equal( Code other )
|
||||
{
|
||||
if ( ast == nullptr || other.ast == nullptr )
|
||||
@ -1597,6 +1768,15 @@ inline Code CodePragma::duplicate()
|
||||
return { rcast( AST*, ast )->duplicate() };
|
||||
}
|
||||
|
||||
inline bool CodePragma::is_body()
|
||||
{
|
||||
if ( ast == nullptr )
|
||||
{
|
||||
return rcast( AST*, ast )->is_body();
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
inline bool CodePragma::is_equal( Code other )
|
||||
{
|
||||
if ( ast == nullptr || other.ast == nullptr )
|
||||
@ -1684,6 +1864,15 @@ inline Code CodePreprocessCond::duplicate()
|
||||
return { rcast( AST*, ast )->duplicate() };
|
||||
}
|
||||
|
||||
inline bool CodePreprocessCond::is_body()
|
||||
{
|
||||
if ( ast == nullptr )
|
||||
{
|
||||
return rcast( AST*, ast )->is_body();
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
inline bool CodePreprocessCond::is_equal( Code other )
|
||||
{
|
||||
if ( ast == nullptr || other.ast == nullptr )
|
||||
@ -1771,6 +1960,15 @@ inline Code CodeSpecifiers::duplicate()
|
||||
return { rcast( AST*, ast )->duplicate() };
|
||||
}
|
||||
|
||||
inline bool CodeSpecifiers::is_body()
|
||||
{
|
||||
if ( ast == nullptr )
|
||||
{
|
||||
return rcast( AST*, ast )->is_body();
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
inline bool CodeSpecifiers::is_equal( Code other )
|
||||
{
|
||||
if ( ast == nullptr || other.ast == nullptr )
|
||||
@ -1838,6 +2036,15 @@ inline Code CodeStruct::duplicate()
|
||||
return { rcast( AST*, ast )->duplicate() };
|
||||
}
|
||||
|
||||
inline bool CodeStruct::is_body()
|
||||
{
|
||||
if ( ast == nullptr )
|
||||
{
|
||||
return rcast( AST*, ast )->is_body();
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
inline bool CodeStruct::is_equal( Code other )
|
||||
{
|
||||
if ( ast == nullptr || other.ast == nullptr )
|
||||
@ -1905,6 +2112,15 @@ inline Code CodeTemplate::duplicate()
|
||||
return { rcast( AST*, ast )->duplicate() };
|
||||
}
|
||||
|
||||
inline bool CodeTemplate::is_body()
|
||||
{
|
||||
if ( ast == nullptr )
|
||||
{
|
||||
return rcast( AST*, ast )->is_body();
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
inline bool CodeTemplate::is_equal( Code other )
|
||||
{
|
||||
if ( ast == nullptr || other.ast == nullptr )
|
||||
@ -1992,6 +2208,15 @@ inline Code CodeType::duplicate()
|
||||
return { rcast( AST*, ast )->duplicate() };
|
||||
}
|
||||
|
||||
inline bool CodeType::is_body()
|
||||
{
|
||||
if ( ast == nullptr )
|
||||
{
|
||||
return rcast( AST*, ast )->is_body();
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
inline bool CodeType::is_equal( Code other )
|
||||
{
|
||||
if ( ast == nullptr || other.ast == nullptr )
|
||||
@ -2079,6 +2304,15 @@ inline Code CodeTypedef::duplicate()
|
||||
return { rcast( AST*, ast )->duplicate() };
|
||||
}
|
||||
|
||||
inline bool CodeTypedef::is_body()
|
||||
{
|
||||
if ( ast == nullptr )
|
||||
{
|
||||
return rcast( AST*, ast )->is_body();
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
inline bool CodeTypedef::is_equal( Code other )
|
||||
{
|
||||
if ( ast == nullptr || other.ast == nullptr )
|
||||
@ -2166,6 +2400,15 @@ inline Code CodeUnion::duplicate()
|
||||
return { rcast( AST*, ast )->duplicate() };
|
||||
}
|
||||
|
||||
inline bool CodeUnion::is_body()
|
||||
{
|
||||
if ( ast == nullptr )
|
||||
{
|
||||
return rcast( AST*, ast )->is_body();
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
inline bool CodeUnion::is_equal( Code other )
|
||||
{
|
||||
if ( ast == nullptr || other.ast == nullptr )
|
||||
@ -2253,6 +2496,15 @@ inline Code CodeUsing::duplicate()
|
||||
return { rcast( AST*, ast )->duplicate() };
|
||||
}
|
||||
|
||||
inline bool CodeUsing::is_body()
|
||||
{
|
||||
if ( ast == nullptr )
|
||||
{
|
||||
return rcast( AST*, ast )->is_body();
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
inline bool CodeUsing::is_equal( Code other )
|
||||
{
|
||||
if ( ast == nullptr || other.ast == nullptr )
|
||||
@ -2340,6 +2592,15 @@ inline Code CodeVar::duplicate()
|
||||
return { rcast( AST*, ast )->duplicate() };
|
||||
}
|
||||
|
||||
inline bool CodeVar::is_body()
|
||||
{
|
||||
if ( ast == nullptr )
|
||||
{
|
||||
return rcast( AST*, ast )->is_body();
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
inline bool CodeVar::is_equal( Code other )
|
||||
{
|
||||
if ( ast == nullptr || other.ast == nullptr )
|
||||
|
@ -50,6 +50,25 @@ bool AST::has_entries()
|
||||
return NumEntries > 0;
|
||||
}
|
||||
|
||||
inline
|
||||
bool AST::is_body()
|
||||
{
|
||||
switch (Type)
|
||||
{
|
||||
case ECode::Enum_Body:
|
||||
case ECode::Class_Body:
|
||||
case ECode::Union_Body:
|
||||
case ECode::Export_Body:
|
||||
case ECode::Global_Body:
|
||||
case ECode::Struct_Body:
|
||||
case ECode::Function_Body:
|
||||
case ECode::Namespace_Body:
|
||||
case ECode::Extern_Linkage_Body:
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
inline
|
||||
char const* AST::type_str()
|
||||
{
|
||||
|
@ -4406,6 +4406,7 @@ CodeTemplate parse_template()
|
||||
result->Params = params;
|
||||
result->Declaration = definition;
|
||||
result->ModuleFlags = mflags;
|
||||
// result->Name = definition->Name;
|
||||
|
||||
Context.pop();
|
||||
return result;
|
||||
|
@ -14,20 +14,17 @@ template<class TType>
|
||||
using TRemoveConst = typename RemoveConst<TType>::Type;
|
||||
|
||||
#pragma region Array
|
||||
#if ! GEN_COMPILER_C
|
||||
#define Array(Type) Array<Type>
|
||||
|
||||
// #define array_init(Type, ...) array_init <Type>(__VA_ARGS__)
|
||||
// #define array_init_reserve(Type, ...) array_init_reserve<Type>(__VA_ARGS__)
|
||||
#endif
|
||||
|
||||
struct ArrayHeader;
|
||||
|
||||
#if GEN_SUPPORT_CPP_MEMBER_FEATURES
|
||||
template<class Type> struct Array;
|
||||
template<class Type> struct Array;
|
||||
#else
|
||||
template<class Type>
|
||||
using Array = Type*;
|
||||
template<class Type> using Array = Type*;
|
||||
#endif
|
||||
|
||||
usize array_grow_formula(ssize value);
|
||||
|
@ -205,7 +205,7 @@
|
||||
# define foreach(Type, entry_id, iterable) for ( Type entry_id : iterable )
|
||||
#endif
|
||||
|
||||
#if GENC_COMPILERC
|
||||
#if GEN_COMPILER_C
|
||||
# if __STDC_VERSION__ >= 202311L
|
||||
# define enum_underlying(type) : type
|
||||
# else
|
||||
|
@ -14,23 +14,13 @@
|
||||
#define GEN__HIGHS ( GEN__ONES * ( GEN_U8_MAX / 2 + 1 ) )
|
||||
#define GEN__HAS_ZERO( x ) ( ( ( x ) - GEN__ONES ) & ~( x ) & GEN__HIGHS )
|
||||
|
||||
#if ! GEN_COMPILER_C
|
||||
template< class Type >
|
||||
void swap( Type& a, Type& b )
|
||||
{
|
||||
template< class Type >
|
||||
void swap( Type& a, Type& b )
|
||||
{
|
||||
Type tmp = a;
|
||||
a = b;
|
||||
b = tmp;
|
||||
}
|
||||
#else
|
||||
#define swap( a, b ) \
|
||||
do { \
|
||||
typeof(a) \
|
||||
temp = (a); \
|
||||
(a) = (b); \
|
||||
(b) = temp; \
|
||||
} while(0)
|
||||
#endif
|
||||
}
|
||||
|
||||
//! Checks if value is power of 2.
|
||||
b32 is_power_of_two( ssize x );
|
||||
|
@ -106,7 +106,7 @@
|
||||
# define GEN_GCC_VERSION_CHECK(major,minor,patch) (0)
|
||||
#endif
|
||||
|
||||
#ifndef GEN_COMPIELR_C
|
||||
#ifndef GEN_COMPILER_C
|
||||
# if defined(__STDC_VERSION__)
|
||||
# define GEN_COMPILER_C 1
|
||||
# else
|
||||
|
@ -11,8 +11,10 @@ struct StrC
|
||||
ssize Len;
|
||||
char const* Ptr;
|
||||
|
||||
#if ! GEN_COMPILER_C
|
||||
operator char const* () const { return Ptr; }
|
||||
char const& operator[]( ssize index ) const { return Ptr[index]; }
|
||||
#endif
|
||||
};
|
||||
|
||||
#define cast_to_strc( str ) * rcast( StrC*, (str) - sizeof(ssize) )
|
||||
@ -29,12 +31,7 @@ StrC to_str( char const* str ) {
|
||||
// I kept it for simplicty of porting but its not necessary to keep it that way.
|
||||
#pragma region String
|
||||
struct StringHeader;
|
||||
|
||||
#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);
|
||||
@ -44,8 +41,8 @@ String string_fmt(AllocatorInfo allocator, char* buf, ssize buf_size, cha
|
||||
String string_fmt_buf(AllocatorInfo allocator, char const* fmt, ...);
|
||||
String string_join(AllocatorInfo allocator, char const** parts, ssize num_parts, char const* glue);
|
||||
usize string_grow_formula(usize value);
|
||||
bool are_equal(String lhs, String rhs);
|
||||
bool are_equal(String lhs, StrC rhs);
|
||||
bool are_equal(String const& lhs, String const& rhs);
|
||||
bool are_equal(String const& lhs, StrC rhs);
|
||||
bool make_space_for(String& str, char const* to_append, ssize add_len);
|
||||
bool append(String& str, char c);
|
||||
bool append(String& str, char const* str_to_append);
|
||||
@ -111,8 +108,6 @@ struct String
|
||||
forceinline static String make_length(AllocatorInfo a, char const* s, ssize l) { return GEN_NS string_make_length(a, s, l); }
|
||||
forceinline static String join(AllocatorInfo a, char const** p, ssize n, char const* g) { return GEN_NS string_join(a, p, n, g); }
|
||||
forceinline static usize grow_formula(usize value) { return GEN_NS string_grow_formula(value); }
|
||||
forceinline static bool are_equal(String lhs, String rhs) { return GEN_NS are_equal(lhs, rhs); }
|
||||
forceinline static bool are_equal(String lhs, StrC rhs) { return GEN_NS are_equal(lhs, rhs); }
|
||||
|
||||
static
|
||||
String fmt(AllocatorInfo allocator, char* buf, ssize buf_size, char const* fmt, ...) {
|
||||
@ -148,6 +143,8 @@ struct String
|
||||
forceinline void clear() { GEN_NS clear(*this); }
|
||||
forceinline String duplicate(AllocatorInfo allocator) const { return GEN_NS duplicate(*this, allocator); }
|
||||
forceinline void free() { GEN_NS free(*this); }
|
||||
forceinline bool is_equal(String const& other) const { return GEN_NS are_equal(* this, other); }
|
||||
forceinline bool is_equal(StrC other) const { return GEN_NS are_equal(* this, other); }
|
||||
forceinline ssize length() const { return GEN_NS length(*this); }
|
||||
forceinline b32 starts_with(StrC substring) const { return GEN_NS starts_with(*this, substring); }
|
||||
forceinline b32 starts_with(String substring) const { return GEN_NS starts_with(*this, substring); }
|
||||
@ -289,7 +286,7 @@ bool append_fmt(String& str, char const* fmt, ...) {
|
||||
}
|
||||
|
||||
inline
|
||||
bool are_equal(String lhs, String rhs)
|
||||
bool are_equal(String const& lhs, String const& rhs)
|
||||
{
|
||||
if (length(lhs) != length(rhs))
|
||||
return false;
|
||||
@ -302,7 +299,7 @@ bool are_equal(String lhs, String rhs)
|
||||
}
|
||||
|
||||
inline
|
||||
bool are_equal(String lhs, StrC rhs)
|
||||
bool are_equal(String const& lhs, StrC rhs)
|
||||
{
|
||||
if (length(lhs) != (rhs.Len))
|
||||
return false;
|
||||
|
@ -368,6 +368,15 @@ CodeBody gen_ast_inlines()
|
||||
return { rcast(AST*, ast)->duplicate() };
|
||||
}
|
||||
inline
|
||||
bool <typename>::is_body()
|
||||
{
|
||||
if ( ast == nullptr )
|
||||
{
|
||||
return rcast(AST*, ast)->is_body();
|
||||
}
|
||||
return false;
|
||||
}
|
||||
inline
|
||||
bool <typename>::is_equal( Code other )
|
||||
{
|
||||
if ( ast == nullptr || other.ast == nullptr )
|
||||
|
Loading…
Reference in New Issue
Block a user