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

Compare commits

base: ed:e3172057d3173c0e78f75b1e4b9a65f7803ebe57
Branches Tags
ed:main
ed:Ed94-patch-1
ed:defines_n_macros_upgrades
ed:string_distinctings_refactor
ed:de_oop
ed:dev
ed:broken_changes
ed:preprocessor_support
ed:parser_context_stack
ed:designchanges_to_bettercodetypes
ed:v0.23-Alpha
ed:v0.22-Alpha
ed:v0.21-Alpha
ed:v0.20-Alpha
ed:v0.19-Alpha
ed:v0.18-Alpha
ed:v0.17-Alpha
ed:v0.16-Alpha
ed:v0.15-Alpha
ed:v0.14-Alpha
ed:v0.13-Alpha
ed:v0.12-Alpha
ed:v0.11-Alpha
ed:v0.10-Alpha
ed:v0.9-Alpha
ed:v0.8-Alpha
ed:v0.7-Alpha
ed:v0.6-Alpha
ed:v0.5-alpha
ed:v0.4-Alpha
ed:V0.3-Alpha
ed:V0.1-Alpha
ed:V0.2-Alpha
..
compare: ed:bac57a58722e25ff6943e99ee83ae32bde861b32
Branches Tags
ed:main
ed:Ed94-patch-1
ed:defines_n_macros_upgrades
ed:string_distinctings_refactor
ed:de_oop
ed:dev
ed:broken_changes
ed:preprocessor_support
ed:parser_context_stack
ed:designchanges_to_bettercodetypes
ed:v0.23-Alpha
ed:v0.22-Alpha
ed:v0.21-Alpha
ed:v0.20-Alpha
ed:v0.19-Alpha
ed:v0.18-Alpha
ed:v0.17-Alpha
ed:v0.16-Alpha
ed:v0.15-Alpha
ed:v0.14-Alpha
ed:v0.13-Alpha
ed:v0.12-Alpha
ed:v0.11-Alpha
ed:v0.10-Alpha
ed:v0.9-Alpha
ed:v0.8-Alpha
ed:v0.7-Alpha
ed:v0.6-Alpha
ed:v0.5-alpha
ed:v0.4-Alpha
ed:V0.3-Alpha
ed:V0.1-Alpha
ed:V0.2-Alpha

3 Commits
e3172057d3 ... bac57a5872

Author SHA1 Message Date
Ed_
bac57a5872 Corrected enum serialization of ecodetypes, eoperator, especifier, and etoktype, some more naming refactors for strbuilder... formatting 2024-12-13 14:38:27 -05:00
Ed_
012fcb6bd5 Corrected order of Str to how the slice type is defined in Odin and RAD Debugger (my reference on slice types) 2024-12-13 13:20:16 -05:00
Ed_
6ffdca8595 formatting, fixes from testing latest in Odin fork 2024-12-13 11:56:07 -05:00
30 changed files with 1098 additions and 1087 deletions
Show Stats Expand all files Collapse all files

2
base/Readme.md
View File

@ -148,7 +148,7 @@ The convention you'll see used throughout the upfront interface of the library i
1. Check name or parameters to make sure they are valid for the construction requested 1. Check name or parameters to make sure they are valid for the construction requested
2. Create a code object using `make_code`. 2. Create a code object using `make_code`.
3. Populate immediate fields (Name, Type, ModuleFlags, etc) 3. Populate immediate fields (Name, Type, ModuleFlags, etc)
4. Populate sub-entires using `add_entry`. If using the default serialization function `to_string`, follow the order at which entires are expected to appear (there is a strong ordering expected). 4. Populate sub-entires using `add_entry`. If using the default serialization function `to_strbuilder`, follow the order at which entires are expected to appear (there is a strong ordering expected).
Names or Content fields are interned strings and thus showed be cached using `get_cached_string` if its desired to preserve that behavior. Names or Content fields are interned strings and thus showed be cached using `get_cached_string` if its desired to preserve that behavior.

2
base/auxillary/builder.cpp
View File

@ -28,7 +28,7 @@ void builder_pad_lines( Builder* builder, s32 num )
void builder_print( Builder* builder, Code code ) void builder_print( Builder* builder, Code code )
{ {
StrBuilder str = code_to_string(code); StrBuilder str = code_to_strbuilder(code);
// const ssize len = str.length(); // const ssize len = str.length();
// log_fmt( "%s - print: %.*s\n", File.filename, len > 80 ? 80 : len, str.Data ); // log_fmt( "%s - print: %.*s\n", File.filename, len > 80 ? 80 : len, str.Data );
strbuilder_append_string( & builder->Buffer, str ); strbuilder_append_string( & builder->Buffer, str );

2
base/auxillary/scanner.cpp
View File

@ -118,7 +118,7 @@ Code scan_file( char const* path )
CodeBody parse_file( const char* path ) { CodeBody parse_file( const char* path ) {
FileContents file = file_read_contents( GlobalAllocator, true, path ); FileContents file = file_read_contents( GlobalAllocator, true, path );
Str content = { file.size, (char const*)file.data }; Str content = { (char const*)file.data, file.size };
CodeBody code = parse_global_body( content ); CodeBody code = parse_global_body( content );
log_fmt("\nParsed: %s\n", path); log_fmt("\nParsed: %s\n", path);
return code; return code;

6
base/base.cpp
View File

@ -41,6 +41,7 @@ int gen_main()
CodeBody ecode = gen_ecode ( "enums/ECodeTypes.csv" ); CodeBody ecode = gen_ecode ( "enums/ECodeTypes.csv" );
CodeBody eoperator = gen_eoperator ( "enums/EOperator.csv" ); CodeBody eoperator = gen_eoperator ( "enums/EOperator.csv" );
CodeBody especifier = gen_especifier( "enums/ESpecifier.csv" ); CodeBody especifier = gen_especifier( "enums/ESpecifier.csv" );
CodeBody etoktype = gen_etoktype ( "enums/ETokType.csv", "enums/AttributeTokens.csv" );
CodeBody ast_inlines = gen_ast_inlines(); CodeBody ast_inlines = gen_ast_inlines();
Builder header_ecode = builder_open( "components/gen/ecodetypes.hpp" ); Builder header_ecode = builder_open( "components/gen/ecodetypes.hpp" );
@ -57,6 +58,11 @@ int gen_main()
builder_print( & header_especifier, gen_component_header ); builder_print( & header_especifier, gen_component_header );
builder_print( & header_especifier, format(especifier) ); builder_print( & header_especifier, format(especifier) );
builder_write( & header_especifier); builder_write( & header_especifier);
Builder header_etoktype = builder_open( "components/gen/etoktype.cpp" );
builder_print( & header_etoktype, gen_component_header );
builder_print( & header_etoktype, format(etoktype) );
builder_write( & header_etoktype);
Builder header_ast_inlines = builder_open( "components/gen/ast_inlines.hpp" ); Builder header_ast_inlines = builder_open( "components/gen/ast_inlines.hpp" );
builder_print( & header_ast_inlines, gen_component_header ); builder_print( & header_ast_inlines, gen_component_header );

214
base/components/ast.cpp
View File

@ -62,11 +62,11 @@ Str code_debug_str(Code self)
if ( self->Next ) if ( self->Next )
strbuilder_append_fmt( result, "\n\tNext: %S %S", code_type_str(self->Prev), self->Prev->Name.Len ? self->Prev->Name : txt("Null") ); strbuilder_append_fmt( result, "\n\tNext: %S %S", code_type_str(self->Prev), self->Prev->Name.Len ? self->Prev->Name : txt("Null") );
strbuilder_append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : txt("Null") ); strbuilder_append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : txt("Null") );
strbuilder_append_fmt( result, "\n\tAttributes : %S", self->Attributes ? strbuilder_to_str( code_to_string(self->Attributes) ) : txt("Null") ); strbuilder_append_fmt( result, "\n\tAttributes : %S", self->Attributes ? strbuilder_to_str( code_to_strbuilder(self->Attributes) ) : txt("Null") );
strbuilder_append_fmt( result, "\n\tParentAccess: %S", self->ParentType ? access_spec_to_str( self->ParentAccess ) : txt("No Parent") ); strbuilder_append_fmt( result, "\n\tParentAccess: %S", self->ParentType ? access_spec_to_str( self->ParentAccess ) : txt("No Parent") );
strbuilder_append_fmt( result, "\n\tParentType : %S", self->ParentType ? code_type_str(self->ParentType) : txt("Null") ); strbuilder_append_fmt( result, "\n\tParentType : %S", self->ParentType ? code_type_str(self->ParentType) : txt("Null") );
strbuilder_append_fmt( result, "\n\tBody : %S", self->Body ? code_debug_str(self->Body) : txt("Null") ); strbuilder_append_fmt( result, "\n\tBody : %S", self->Body ? code_debug_str(self->Body) : txt("Null") );
break; break;
case CT_Class_Fwd: case CT_Class_Fwd:
@ -76,10 +76,10 @@ Str code_debug_str(Code self)
if ( self->Next ) if ( self->Next )
strbuilder_append_fmt( result, "\n\tNext: %S %S", code_type_str(self->Prev), self->Prev->Name.Len ? self->Prev->Name : txt("Null") ); strbuilder_append_fmt( result, "\n\tNext: %S %S", code_type_str(self->Prev), self->Prev->Name.Len ? self->Prev->Name : txt("Null") );
strbuilder_append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : txt("Null") ); strbuilder_append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : txt("Null") );
strbuilder_append_fmt( result, "\n\tAttributes : %S", self->Attributes ? strbuilder_to_str( code_to_string(self->Attributes) ) : txt("Null") ); strbuilder_append_fmt( result, "\n\tAttributes : %S", self->Attributes ? strbuilder_to_str( code_to_strbuilder(self->Attributes) ) : txt("Null") );
strbuilder_append_fmt( result, "\n\tParentAccess: %S", self->ParentType ? access_spec_to_str( self->ParentAccess ) : txt("No Parent") ); strbuilder_append_fmt( result, "\n\tParentAccess: %S", self->ParentType ? access_spec_to_str( self->ParentAccess ) : txt("No Parent") );
strbuilder_append_fmt( result, "\n\tParentType : %S", self->ParentType ? code_type_str(self->ParentType) : txt("Null") ); strbuilder_append_fmt( result, "\n\tParentType : %S", self->ParentType ? code_type_str(self->ParentType) : txt("Null") );
break; break;
case CT_Constructor: case CT_Constructor:
@ -88,11 +88,11 @@ Str code_debug_str(Code self)
if ( self->Next ) if ( self->Next )
strbuilder_append_fmt( result, "\n\tNext: %S %S", code_type_str(self->Prev), self->Prev->Name.Len ? self->Prev->Name : txt("Null") ); strbuilder_append_fmt( result, "\n\tNext: %S %S", code_type_str(self->Prev), self->Prev->Name.Len ? self->Prev->Name : txt("Null") );
strbuilder_append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : txt("Null") ); strbuilder_append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : txt("Null") );
strbuilder_append_fmt( result, "\n\tSpecs : %S", self->Specs ? strbuilder_to_str( code_to_string(self->Specs) ) : txt("Null") ); strbuilder_append_fmt( result, "\n\tSpecs : %S", self->Specs ? strbuilder_to_str( code_to_strbuilder(self->Specs) ) : txt("Null") );
strbuilder_append_fmt( result, "\n\tInitializerList: %S", self->InitializerList ? strbuilder_to_str( code_to_string(self->InitializerList) ) : txt("Null") ); strbuilder_append_fmt( result, "\n\tInitializerList: %S", self->InitializerList ? strbuilder_to_str( code_to_strbuilder(self->InitializerList) ) : txt("Null") );
strbuilder_append_fmt( result, "\n\tParams : %S", self->Params ? strbuilder_to_str( code_to_string(self->Params) ) : txt("Null") ); strbuilder_append_fmt( result, "\n\tParams : %S", self->Params ? strbuilder_to_str( code_to_strbuilder(self->Params) ) : txt("Null") );
strbuilder_append_fmt( result, "\n\tBody : %S", self->Body ? code_debug_str(self->Body) : txt("Null") ); strbuilder_append_fmt( result, "\n\tBody : %S", self->Body ? code_debug_str(self->Body) : txt("Null") );
break; break;
case CT_Constructor_Fwd: case CT_Constructor_Fwd:
@ -101,10 +101,10 @@ Str code_debug_str(Code self)
if ( self->Next ) if ( self->Next )
strbuilder_append_fmt( result, "\n\tNext: %S %S", code_type_str(self->Prev), self->Prev->Name.Len ? self->Prev->Name : txt("Null") ); strbuilder_append_fmt( result, "\n\tNext: %S %S", code_type_str(self->Prev), self->Prev->Name.Len ? self->Prev->Name : txt("Null") );
strbuilder_append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : txt("Null") ); strbuilder_append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : txt("Null") );
strbuilder_append_fmt( result, "\n\tSpecs : %S", self->Specs ? strbuilder_to_str( code_to_string(self->Specs) ) : txt("Null") ); strbuilder_append_fmt( result, "\n\tSpecs : %S", self->Specs ? strbuilder_to_str( code_to_strbuilder(self->Specs) ) : txt("Null") );
strbuilder_append_fmt( result, "\n\tInitializerList: %S", self->InitializerList ? strbuilder_to_str( code_to_string(self->InitializerList) ) : txt("Null") ); strbuilder_append_fmt( result, "\n\tInitializerList: %S", self->InitializerList ? strbuilder_to_str( code_to_strbuilder(self->InitializerList) ) : txt("Null") );
strbuilder_append_fmt( result, "\n\tParams : %S", self->Params ? strbuilder_to_str( code_to_string(self->Params) ) : txt("Null") ); strbuilder_append_fmt( result, "\n\tParams : %S", self->Params ? strbuilder_to_str( code_to_strbuilder(self->Params) ) : txt("Null") );
break; break;
case CT_Destructor: case CT_Destructor:
@ -113,9 +113,9 @@ Str code_debug_str(Code self)
if ( self->Next ) if ( self->Next )
strbuilder_append_fmt( result, "\n\tNext: %S %S", code_type_str(self->Prev), self->Prev->Name.Len ? self->Prev->Name : txt("Null") ); strbuilder_append_fmt( result, "\n\tNext: %S %S", code_type_str(self->Prev), self->Prev->Name.Len ? self->Prev->Name : txt("Null") );
strbuilder_append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : txt("Null") ); strbuilder_append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : txt("Null") );
strbuilder_append_fmt( result, "\n\tSpecs : %S", self->Specs ? strbuilder_to_str( code_to_string(self->Specs) ) : txt("Null") ); strbuilder_append_fmt( result, "\n\tSpecs : %S", self->Specs ? strbuilder_to_str( code_to_strbuilder(self->Specs) ) : txt("Null") );
strbuilder_append_fmt( result, "\n\tBody : %S", self->Body ? code_debug_str(self->Body) : txt("Null") ); strbuilder_append_fmt( result, "\n\tBody : %S", self->Body ? code_debug_str(self->Body) : txt("Null") );
break; break;
case CT_Destructor_Fwd: case CT_Destructor_Fwd:
@ -128,10 +128,10 @@ Str code_debug_str(Code self)
if ( self->Next ) if ( self->Next )
strbuilder_append_fmt( result, "\n\tNext: %S %S", code_type_str(self->Prev), self->Prev->Name.Len ? self->Prev->Name : txt("Null") ); strbuilder_append_fmt( result, "\n\tNext: %S %S", code_type_str(self->Prev), self->Prev->Name.Len ? self->Prev->Name : txt("Null") );
strbuilder_append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : txt("Null") ); strbuilder_append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : txt("Null") );
strbuilder_append_fmt( result, "\n\tAttributes : %S", self->Attributes ? strbuilder_to_str( code_to_string(self->Attributes) ) : txt("Null") ); strbuilder_append_fmt( result, "\n\tAttributes : %S", self->Attributes ? strbuilder_to_str( code_to_strbuilder(self->Attributes) ) : txt("Null") );
strbuilder_append_fmt( result, "\n\tUnderlying Type : %S", self->UnderlyingType ? strbuilder_to_str( code_to_string(self->UnderlyingType)) : txt("Null") ); strbuilder_append_fmt( result, "\n\tUnderlying Type : %S", self->UnderlyingType ? strbuilder_to_str( code_to_strbuilder(self->UnderlyingType)) : txt("Null") );
strbuilder_append_fmt( result, "\n\tBody : %S", self->Body ? code_debug_str(self->Body) : txt("Null") ); strbuilder_append_fmt( result, "\n\tBody : %S", self->Body ? code_debug_str(self->Body) : txt("Null") );
break; break;
case CT_Enum_Fwd: case CT_Enum_Fwd:
@ -141,9 +141,9 @@ Str code_debug_str(Code self)
if ( self->Next ) if ( self->Next )
strbuilder_append_fmt( result, "\n\tNext: %S %S", code_type_str(self->Prev), self->Prev->Name.Len ? self->Prev->Name : txt("Null") ); strbuilder_append_fmt( result, "\n\tNext: %S %S", code_type_str(self->Prev), self->Prev->Name.Len ? self->Prev->Name : txt("Null") );
strbuilder_append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : txt("Null") ); strbuilder_append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : txt("Null") );
strbuilder_append_fmt( result, "\n\tAttributes : %S", self->Attributes ? strbuilder_to_str( code_to_string(self->Attributes) ) : txt("Null") ); strbuilder_append_fmt( result, "\n\tAttributes : %S", self->Attributes ? strbuilder_to_str( code_to_strbuilder(self->Attributes) ) : txt("Null") );
strbuilder_append_fmt( result, "\n\tUnderlying Type : %S", self->UnderlyingType ? strbuilder_to_str( code_to_string(self->UnderlyingType)) : txt("Null") ); strbuilder_append_fmt( result, "\n\tUnderlying Type : %S", self->UnderlyingType ? strbuilder_to_str( code_to_strbuilder(self->UnderlyingType)) : txt("Null") );
break; break;
case CT_Extern_Linkage: case CT_Extern_Linkage:
@ -162,8 +162,8 @@ Str code_debug_str(Code self)
if ( self->Next ) if ( self->Next )
strbuilder_append_fmt( result, "\n\tNext: %S %S", code_type_str(self->Prev), self->Prev->Name.Len ? self->Prev->Name : txt("Null") ); strbuilder_append_fmt( result, "\n\tNext: %S %S", code_type_str(self->Prev), self->Prev->Name.Len ? self->Prev->Name : txt("Null") );
strbuilder_append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : txt("Null") ); strbuilder_append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : txt("Null") );
strbuilder_append_fmt( result, "\n\tDeclaration: %S", self->Declaration ? strbuilder_to_str( code_to_string(self->Declaration)) : txt("Null") ); strbuilder_append_fmt( result, "\n\tDeclaration: %S", self->Declaration ? strbuilder_to_str( code_to_strbuilder(self->Declaration)) : txt("Null") );
break; break;
case CT_Function: case CT_Function:
@ -172,12 +172,12 @@ Str code_debug_str(Code self)
if ( self->Next ) if ( self->Next )
strbuilder_append_fmt( result, "\n\tNext: %S %S", code_type_str(self->Prev), self->Prev->Name.Len ? self->Prev->Name : txt("Null") ); strbuilder_append_fmt( result, "\n\tNext: %S %S", code_type_str(self->Prev), self->Prev->Name.Len ? self->Prev->Name : txt("Null") );
strbuilder_append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : txt("Null") ); strbuilder_append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : txt("Null") );
strbuilder_append_fmt( result, "\n\tAttributes: %S", self->Attributes ? strbuilder_to_str( code_to_string(self->Attributes) ) : txt("Null") ); strbuilder_append_fmt( result, "\n\tAttributes: %S", self->Attributes ? strbuilder_to_str( code_to_strbuilder(self->Attributes) ) : txt("Null") );
strbuilder_append_fmt( result, "\n\tSpecs : %S", self->Specs ? strbuilder_to_str( code_to_string(self->Specs)) : txt("Null") ); strbuilder_append_fmt( result, "\n\tSpecs : %S", self->Specs ? strbuilder_to_str( code_to_strbuilder(self->Specs)) : txt("Null") );
strbuilder_append_fmt( result, "\n\tReturnType: %S", self->ReturnType ? strbuilder_to_str( code_to_string(self->ReturnType)) : txt("Null") ); strbuilder_append_fmt( result, "\n\tReturnType: %S", self->ReturnType ? strbuilder_to_str( code_to_strbuilder(self->ReturnType)) : txt("Null") );
strbuilder_append_fmt( result, "\n\tParams : %S", self->Params ? strbuilder_to_str( code_to_string(self->Params)) : txt("Null") ); strbuilder_append_fmt( result, "\n\tParams : %S", self->Params ? strbuilder_to_str( code_to_strbuilder(self->Params)) : txt("Null") );
strbuilder_append_fmt( result, "\n\tBody : %S", self->Body ? code_debug_str(self->Body) : txt("Null") ); strbuilder_append_fmt( result, "\n\tBody : %S", self->Body ? code_debug_str(self->Body) : txt("Null") );
break; break;
case CT_Function_Fwd: case CT_Function_Fwd:
@ -186,11 +186,11 @@ Str code_debug_str(Code self)
if ( self->Next ) if ( self->Next )
strbuilder_append_fmt( result, "\n\tNext: %S %S", code_type_str(self->Prev), self->Prev->Name.Len ? self->Prev->Name : txt("Null") ); strbuilder_append_fmt( result, "\n\tNext: %S %S", code_type_str(self->Prev), self->Prev->Name.Len ? self->Prev->Name : txt("Null") );
strbuilder_append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : txt("Null") ); strbuilder_append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : txt("Null") );
strbuilder_append_fmt( result, "\n\tAttributes: %S", self->Attributes ? strbuilder_to_str( code_to_string(self->Attributes) ) : txt("Null") ); strbuilder_append_fmt( result, "\n\tAttributes: %S", self->Attributes ? strbuilder_to_str( code_to_strbuilder(self->Attributes) ) : txt("Null") );
strbuilder_append_fmt( result, "\n\tSpecs : %S", self->Specs ? strbuilder_to_str( code_to_string(self->Specs)) : txt("Null") ); strbuilder_append_fmt( result, "\n\tSpecs : %S", self->Specs ? strbuilder_to_str( code_to_strbuilder(self->Specs)) : txt("Null") );
strbuilder_append_fmt( result, "\n\tReturnType: %S", self->ReturnType ? strbuilder_to_str( code_to_string(self->ReturnType)) : txt("Null") ); strbuilder_append_fmt( result, "\n\tReturnType: %S", self->ReturnType ? strbuilder_to_str( code_to_strbuilder(self->ReturnType)) : txt("Null") );
strbuilder_append_fmt( result, "\n\tParams : %S", self->Params ? strbuilder_to_str( code_to_string(self->Params)) : txt("Null") ); strbuilder_append_fmt( result, "\n\tParams : %S", self->Params ? strbuilder_to_str( code_to_strbuilder(self->Params)) : txt("Null") );
break; break;
case CT_Module: case CT_Module:
@ -207,12 +207,12 @@ Str code_debug_str(Code self)
if ( self->Next ) if ( self->Next )
strbuilder_append_fmt( result, "\n\tNext: %S %S", code_type_str(self->Prev), self->Prev->Name.Len ? self->Prev->Name : txt("Null") ); strbuilder_append_fmt( result, "\n\tNext: %S %S", code_type_str(self->Prev), self->Prev->Name.Len ? self->Prev->Name : txt("Null") );
strbuilder_append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : txt("Null") ); strbuilder_append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : txt("Null") );
strbuilder_append_fmt( result, "\n\tAttributes: %S", self->Attributes ? strbuilder_to_str( code_to_string(self->Attributes) ) : txt("Null") ); strbuilder_append_fmt( result, "\n\tAttributes: %S", self->Attributes ? strbuilder_to_str( code_to_strbuilder(self->Attributes) ) : txt("Null") );
strbuilder_append_fmt( result, "\n\tSpecs : %S", self->Specs ? strbuilder_to_str( code_to_string(self->Specs)) : txt("Null") ); strbuilder_append_fmt( result, "\n\tSpecs : %S", self->Specs ? strbuilder_to_str( code_to_strbuilder(self->Specs)) : txt("Null") );
strbuilder_append_fmt( result, "\n\tReturnType: %S", self->ReturnType ? strbuilder_to_str( code_to_string(self->ReturnType)) : txt("Null") ); strbuilder_append_fmt( result, "\n\tReturnType: %S", self->ReturnType ? strbuilder_to_str( code_to_strbuilder(self->ReturnType)) : txt("Null") );
strbuilder_append_fmt( result, "\n\tParams : %S", self->Params ? strbuilder_to_str( code_to_string(self->Params)) : txt("Null") ); strbuilder_append_fmt( result, "\n\tParams : %S", self->Params ? strbuilder_to_str( code_to_strbuilder(self->Params)) : txt("Null") );
strbuilder_append_fmt( result, "\n\tBody : %S", self->Body ? code_debug_str(self->Body) : txt("Null") ); strbuilder_append_fmt( result, "\n\tBody : %S", self->Body ? code_debug_str(self->Body) : txt("Null") );
strbuilder_append_fmt( result, "\n\tOp : %S", operator_to_str( self->Op ) ); strbuilder_append_fmt( result, "\n\tOp : %S", operator_to_str( self->Op ) );
break; break;
@ -223,11 +223,11 @@ Str code_debug_str(Code self)
if ( self->Next ) if ( self->Next )
strbuilder_append_fmt( result, "\n\tNext: %S %S", code_type_str(self->Prev), self->Prev->Name.Len ? self->Prev->Name : txt("Null") ); strbuilder_append_fmt( result, "\n\tNext: %S %S", code_type_str(self->Prev), self->Prev->Name.Len ? self->Prev->Name : txt("Null") );
strbuilder_append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : txt("Null") ); strbuilder_append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : txt("Null") );
strbuilder_append_fmt( result, "\n\tAttributes: %S", self->Attributes ? strbuilder_to_str( code_to_string(self->Attributes) ) : txt("Null") ); strbuilder_append_fmt( result, "\n\tAttributes: %S", self->Attributes ? strbuilder_to_str( code_to_strbuilder(self->Attributes) ) : txt("Null") );
strbuilder_append_fmt( result, "\n\tSpecs : %S", self->Specs ? strbuilder_to_str( code_to_string(self->Specs) ) : txt("Null") ); strbuilder_append_fmt( result, "\n\tSpecs : %S", self->Specs ? strbuilder_to_str( code_to_strbuilder(self->Specs) ) : txt("Null") );
strbuilder_append_fmt( result, "\n\tReturnType: %S", self->ReturnType ? strbuilder_to_str( code_to_string(self->ReturnType) ) : txt("Null") ); strbuilder_append_fmt( result, "\n\tReturnType: %S", self->ReturnType ? strbuilder_to_str( code_to_strbuilder(self->ReturnType) ) : txt("Null") );
strbuilder_append_fmt( result, "\n\tParams : %S", self->Params ? strbuilder_to_str( code_to_string(self->Params) ) : txt("Null") ); strbuilder_append_fmt( result, "\n\tParams : %S", self->Params ? strbuilder_to_str( code_to_strbuilder(self->Params) ) : txt("Null") );
strbuilder_append_fmt( result, "\n\tOp : %S", operator_to_str( self->Op ) ); strbuilder_append_fmt( result, "\n\tOp : %S", operator_to_str( self->Op ) );
break; break;
@ -237,10 +237,10 @@ Str code_debug_str(Code self)
if ( self->Next ) if ( self->Next )
strbuilder_append_fmt( result, "\n\tNext: %S %S", code_type_str(self->Prev), self->Prev->Name.Len ? self->Prev->Name : txt("Null") ); strbuilder_append_fmt( result, "\n\tNext: %S %S", code_type_str(self->Prev), self->Prev->Name.Len ? self->Prev->Name : txt("Null") );
strbuilder_append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : txt("Null") ); strbuilder_append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : txt("Null") );
strbuilder_append_fmt( result, "\n\tSpecs : %S", self->Specs ? strbuilder_to_str( code_to_string(self->Specs)) : txt("Null") ); strbuilder_append_fmt( result, "\n\tSpecs : %S", self->Specs ? strbuilder_to_str( code_to_strbuilder(self->Specs)) : txt("Null") );
strbuilder_append_fmt( result, "\n\tValueType : %S", self->ValueType ? strbuilder_to_str( code_to_string(self->ValueType)) : txt("Null") ); strbuilder_append_fmt( result, "\n\tValueType : %S", self->ValueType ? strbuilder_to_str( code_to_strbuilder(self->ValueType)) : txt("Null") );
strbuilder_append_fmt( result, "\n\tBody : %S", self->Body ? code_debug_str(self->Body) : txt("Null") ); strbuilder_append_fmt( result, "\n\tBody : %S", self->Body ? code_debug_str(self->Body) : txt("Null") );
break; break;
case CT_Operator_Cast_Fwd: case CT_Operator_Cast_Fwd:
@ -249,17 +249,17 @@ Str code_debug_str(Code self)
if ( self->Next ) if ( self->Next )
strbuilder_append_fmt( result, "\n\tNext: %S %S", code_type_str(self->Prev), self->Prev->Name.Len ? self->Prev->Name : txt("Null") ); strbuilder_append_fmt( result, "\n\tNext: %S %S", code_type_str(self->Prev), self->Prev->Name.Len ? self->Prev->Name : txt("Null") );
strbuilder_append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : txt("Null") ); strbuilder_append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : txt("Null") );
strbuilder_append_fmt( result, "\n\tSpecs : %S", self->Specs ? strbuilder_to_str( code_to_string(self->Specs)) : txt("Null") ); strbuilder_append_fmt( result, "\n\tSpecs : %S", self->Specs ? strbuilder_to_str( code_to_strbuilder(self->Specs)) : txt("Null") );
strbuilder_append_fmt( result, "\n\tValueType : %S", self->ValueType ? strbuilder_to_str( code_to_string(self->ValueType)) : txt("Null") ); strbuilder_append_fmt( result, "\n\tValueType : %S", self->ValueType ? strbuilder_to_str( code_to_strbuilder(self->ValueType)) : txt("Null") );
break; break;
case CT_Parameters: case CT_Parameters:
strbuilder_append_fmt( result, "\n\tNumEntries: %d", self->NumEntries ); strbuilder_append_fmt( result, "\n\tNumEntries: %d", self->NumEntries );
strbuilder_append_fmt( result, "\n\tLast : %S", self->Last->Name ); strbuilder_append_fmt( result, "\n\tLast : %S", self->Last->Name );
strbuilder_append_fmt( result, "\n\tNext : %S", self->Next->Name ); strbuilder_append_fmt( result, "\n\tNext : %S", self->Next->Name );
strbuilder_append_fmt( result, "\n\tValueType : %S", self->ValueType ? strbuilder_to_str( code_to_string(self->ValueType)) : txt("Null") ); strbuilder_append_fmt( result, "\n\tValueType : %S", self->ValueType ? strbuilder_to_str( code_to_strbuilder(self->ValueType)) : txt("Null") );
strbuilder_append_fmt( result, "\n\tValue : %S", self->Value ? strbuilder_to_str( code_to_string(self->Value)) : txt("Null") ); strbuilder_append_fmt( result, "\n\tValue : %S", self->Value ? strbuilder_to_str( code_to_strbuilder(self->Value)) : txt("Null") );
break; break;
case CT_Specifiers: case CT_Specifiers:
@ -285,8 +285,8 @@ Str code_debug_str(Code self)
if ( self->Next ) if ( self->Next )
strbuilder_append_fmt( result, "\n\tNext: %S %S", code_type_str(self->Prev), self->Prev->Name.Len ? self->Prev->Name : txt("Null") ); strbuilder_append_fmt( result, "\n\tNext: %S %S", code_type_str(self->Prev), self->Prev->Name.Len ? self->Prev->Name : txt("Null") );
strbuilder_append_fmt( result, "\n\tParams : %S", self->Params ? strbuilder_to_str( code_to_string(self->Params)) : txt("Null") ); strbuilder_append_fmt( result, "\n\tParams : %S", self->Params ? strbuilder_to_str( code_to_strbuilder(self->Params)) : txt("Null") );
strbuilder_append_fmt( result, "\n\tDeclaration: %S", self->Declaration ? strbuilder_to_str( code_to_string(self->Declaration)) : txt("Null") ); strbuilder_append_fmt( result, "\n\tDeclaration: %S", self->Declaration ? strbuilder_to_str( code_to_strbuilder(self->Declaration)) : txt("Null") );
break; break;
case CT_Typedef: case CT_Typedef:
@ -295,16 +295,16 @@ Str code_debug_str(Code self)
if ( self->Next ) if ( self->Next )
strbuilder_append_fmt( result, "\n\tNext: %S %S", code_type_str(self->Prev), self->Prev->Name.Len ? self->Prev->Name : txt("Null") ); strbuilder_append_fmt( result, "\n\tNext: %S %S", code_type_str(self->Prev), self->Prev->Name.Len ? self->Prev->Name : txt("Null") );
strbuilder_append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : txt("Null") ); strbuilder_append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : txt("Null") );
strbuilder_append_fmt( result, "\n\tUnderlyingType: %S", self->UnderlyingType ? strbuilder_to_str( code_to_string(self->UnderlyingType)) : txt("Null") ); strbuilder_append_fmt( result, "\n\tUnderlyingType: %S", self->UnderlyingType ? strbuilder_to_str( code_to_strbuilder(self->UnderlyingType)) : txt("Null") );
break; break;
case CT_Typename: case CT_Typename:
strbuilder_append_fmt( result, "\n\tAttributes : %S", self->Attributes ? strbuilder_to_str( code_to_string(self->Attributes) ) : txt("Null") ); strbuilder_append_fmt( result, "\n\tAttributes : %S", self->Attributes ? strbuilder_to_str( code_to_strbuilder(self->Attributes) ) : txt("Null") );
strbuilder_append_fmt( result, "\n\tSpecs : %S", self->Specs ? strbuilder_to_str( code_to_string(self->Specs)) : txt("Null") ); strbuilder_append_fmt( result, "\n\tSpecs : %S", self->Specs ? strbuilder_to_str( code_to_strbuilder(self->Specs)) : txt("Null") );
strbuilder_append_fmt( result, "\n\tReturnType : %S", self->ReturnType ? strbuilder_to_str( code_to_string(self->ReturnType)) : txt("Null") ); strbuilder_append_fmt( result, "\n\tReturnType : %S", self->ReturnType ? strbuilder_to_str( code_to_strbuilder(self->ReturnType)) : txt("Null") );
strbuilder_append_fmt( result, "\n\tParams : %S", self->Params ? strbuilder_to_str( code_to_string(self->Params)) : txt("Null") ); strbuilder_append_fmt( result, "\n\tParams : %S", self->Params ? strbuilder_to_str( code_to_strbuilder(self->Params)) : txt("Null") );
strbuilder_append_fmt( result, "\n\tArrExpr : %S", self->ArrExpr ? strbuilder_to_str( code_to_string(self->ArrExpr)) : txt("Null") ); strbuilder_append_fmt( result, "\n\tArrExpr : %S", self->ArrExpr ? strbuilder_to_str( code_to_strbuilder(self->ArrExpr)) : txt("Null") );
break; break;
case CT_Union: case CT_Union:
@ -313,8 +313,8 @@ Str code_debug_str(Code self)
if ( self->Next ) if ( self->Next )
strbuilder_append_fmt( result, "\n\tNext: %S %S", code_type_str(self->Prev), self->Prev->Name.Len ? self->Prev->Name : txt("Null") ); strbuilder_append_fmt( result, "\n\tNext: %S %S", code_type_str(self->Prev), self->Prev->Name.Len ? self->Prev->Name : txt("Null") );
strbuilder_append_fmt( result, "\n\tAttributes: %S", self->Attributes ? strbuilder_to_str( code_to_string(self->Attributes) ) : txt("Null") ); strbuilder_append_fmt( result, "\n\tAttributes: %S", self->Attributes ? strbuilder_to_str( code_to_strbuilder(self->Attributes) ) : txt("Null") );
strbuilder_append_fmt( result, "\n\tBody : %S", self->Body ? code_debug_str(self->Body) : txt("Null") ); strbuilder_append_fmt( result, "\n\tBody : %S", self->Body ? code_debug_str(self->Body) : txt("Null") );
break; break;
case CT_Using: case CT_Using:
@ -323,9 +323,9 @@ Str code_debug_str(Code self)
if ( self->Next ) if ( self->Next )
strbuilder_append_fmt( result, "\n\tNext: %S %S", code_type_str(self->Prev), self->Prev->Name.Len ? self->Prev->Name : txt("Null") ); strbuilder_append_fmt( result, "\n\tNext: %S %S", code_type_str(self->Prev), self->Prev->Name.Len ? self->Prev->Name : txt("Null") );
strbuilder_append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : txt("Null") ); strbuilder_append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : txt("Null") );
strbuilder_append_fmt( result, "\n\tAttributes : %S", self->Attributes ? strbuilder_to_str( code_to_string(self->Attributes) ) : txt("Null") ); strbuilder_append_fmt( result, "\n\tAttributes : %S", self->Attributes ? strbuilder_to_str( code_to_strbuilder(self->Attributes) ) : txt("Null") );
strbuilder_append_fmt( result, "\n\tUnderlyingType: %S", self->UnderlyingType ? strbuilder_to_str( code_to_string(self->UnderlyingType)) : txt("Null") ); strbuilder_append_fmt( result, "\n\tUnderlyingType: %S", self->UnderlyingType ? strbuilder_to_str( code_to_strbuilder(self->UnderlyingType)) : txt("Null") );
break; break;
case CT_Variable: case CT_Variable:
@ -333,10 +333,10 @@ Str code_debug_str(Code self)
if ( self->Parent && self->Parent->Type == CT_Variable ) if ( self->Parent && self->Parent->Type == CT_Variable )
{ {
// Its a NextVar // Its a NextVar
strbuilder_append_fmt( result, "\n\tSpecs : %S", self->Specs ? strbuilder_to_str( code_to_string(self->Specs)) : txt("Null") ); strbuilder_append_fmt( result, "\n\tSpecs : %S", self->Specs ? strbuilder_to_str( code_to_strbuilder(self->Specs)) : txt("Null") );
strbuilder_append_fmt( result, "\n\tValue : %S", self->Value ? strbuilder_to_str( code_to_string(self->Value)) : txt("Null") ); strbuilder_append_fmt( result, "\n\tValue : %S", self->Value ? strbuilder_to_str( code_to_strbuilder(self->Value)) : txt("Null") );
strbuilder_append_fmt( result, "\n\tBitfieldSize: %S", self->BitfieldSize ? strbuilder_to_str( code_to_string(self->BitfieldSize)) : txt("Null") ); strbuilder_append_fmt( result, "\n\tBitfieldSize: %S", self->BitfieldSize ? strbuilder_to_str( code_to_strbuilder(self->BitfieldSize)) : txt("Null") );
strbuilder_append_fmt( result, "\n\tNextVar : %S", self->NextVar ? code_debug_str(self->NextVar) : txt("Null") ); strbuilder_append_fmt( result, "\n\tNextVar : %S", self->NextVar ? code_debug_str(self->NextVar) : txt("Null") );
break; break;
} }
@ -345,13 +345,13 @@ Str code_debug_str(Code self)
if ( self->Next ) if ( self->Next )
strbuilder_append_fmt( result, "\n\tNext: %S %S", code_type_str(self->Prev), self->Prev->Name.Len ? self->Prev->Name : txt("Null") ); strbuilder_append_fmt( result, "\n\tNext: %S %S", code_type_str(self->Prev), self->Prev->Name.Len ? self->Prev->Name : txt("Null") );
strbuilder_append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : txt("Null") ); strbuilder_append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : txt("Null") );
strbuilder_append_fmt( result, "\n\tAttributes : %S", self->Attributes ? strbuilder_to_str( code_to_string(self->Attributes) ) : txt("Null") ); strbuilder_append_fmt( result, "\n\tAttributes : %S", self->Attributes ? strbuilder_to_str( code_to_strbuilder(self->Attributes) ) : txt("Null") );
strbuilder_append_fmt( result, "\n\tSpecs : %S", self->Specs ? strbuilder_to_str( code_to_string(self->Specs)) : txt("Null") ); strbuilder_append_fmt( result, "\n\tSpecs : %S", self->Specs ? strbuilder_to_str( code_to_strbuilder(self->Specs)) : txt("Null") );
strbuilder_append_fmt( result, "\n\tValueType : %S", self->ValueType ? strbuilder_to_str( code_to_string(self->ValueType)) : txt("Null") ); strbuilder_append_fmt( result, "\n\tValueType : %S", self->ValueType ? strbuilder_to_str( code_to_strbuilder(self->ValueType)) : txt("Null") );
strbuilder_append_fmt( result, "\n\tBitfieldSize: %S", self->BitfieldSize ? strbuilder_to_str( code_to_string(self->BitfieldSize)) : txt("Null") ); strbuilder_append_fmt( result, "\n\tBitfieldSize: %S", self->BitfieldSize ? strbuilder_to_str( code_to_strbuilder(self->BitfieldSize)) : txt("Null") );
strbuilder_append_fmt( result, "\n\tValue : %S", self->Value ? strbuilder_to_str( code_to_string(self->Value)) : txt("Null") ); strbuilder_append_fmt( result, "\n\tValue : %S", self->Value ? strbuilder_to_str( code_to_strbuilder(self->Value)) : txt("Null") );
strbuilder_append_fmt( result, "\n\tNextVar : %S", self->NextVar ? code_debug_str(self->NextVar) : txt("Null") ); strbuilder_append_fmt( result, "\n\tNextVar : %S", self->NextVar ? code_debug_str(self->NextVar) : txt("Null") );
break; break;
} }
@ -370,7 +370,7 @@ Code code_duplicate(Code self)
return result; return result;
} }
StrBuilder code_to_string(Code self) StrBuilder code_to_strbuilder(Code self)
{ {
StrBuilder result = strbuilder_make_str( GlobalAllocator, txt("") ); StrBuilder result = strbuilder_make_str( GlobalAllocator, txt("") );
code_to_strbuilder_ptr( self, & result ); code_to_strbuilder_ptr( self, & result );
@ -455,7 +455,7 @@ void code_to_strbuilder_ptr( Code self, StrBuilder* result )
break; break;
case CT_Extern_Linkage: case CT_Extern_Linkage:
extern_to_string(cast(CodeExtern, self), result ); extern_to_strbuilder(cast(CodeExtern, self), result );
break; break;
case CT_Friend: case CT_Friend:
@ -624,8 +624,8 @@ bool code_is_equal( Code self, Code other )
if ( self->val != other->val ) \ if ( self->val != other->val ) \
{ \ { \
log_fmt("\nAST::is_equal: Member - " #val " failed\n" \ log_fmt("\nAST::is_equal: Member - " #val " failed\n" \
"AST : %S\n" \ "AST : %S\n" \
"Other: %S\n" \ "Other: %S\n" \
, code_debug_str(self) \ , code_debug_str(self) \
,code_debug_str(other) \ ,code_debug_str(other) \
); \ ); \
@ -634,11 +634,11 @@ bool code_is_equal( Code self, Code other )
} }
#define check_member_str( str ) \ #define check_member_str( str ) \
if ( ! str_are_equal( self->str, other->str ) ) \ if ( ! str_are_equal( self->str, other->str ) ) \
{ \ { \
log_fmt("\nAST::is_equal: Member string - "#str " failed\n" \ log_fmt("\nAST::is_equal: Member string - "#str " failed\n" \
"AST : %S\n" \ "AST : %S\n" \
"Other: %S\n" \ "Other: %S\n" \
, code_debug_str(self) \ , code_debug_str(self) \
,code_debug_str(other) \ ,code_debug_str(other) \
); \ ); \
@ -647,21 +647,21 @@ bool code_is_equal( Code self, Code other )
} }
#define check_member_content( content ) \ #define check_member_content( content ) \
if ( ! str_are_equal( self->content, other->content )) \ if ( ! str_are_equal( self->content, other->content )) \
{ \ { \
log_fmt("\nAST::is_equal: Member content - "#content " failed\n" \ log_fmt("\nAST::is_equal: Member content - "#content " failed\n" \
"AST : %S\n" \ "AST : %S\n" \
"Other: %S\n" \ "Other: %S\n" \
, code_debug_str(self) \ , code_debug_str(self) \
, code_debug_str(other) \ , code_debug_str(other) \
); \ ); \
\ \
log_fmt("Content cannot be trusted to be unique with this check " \ log_fmt("Content cannot be trusted to be unique with this check " \
"so it must be verified by eye for now\n" \ "so it must be verified by eye for now\n" \
"AST Content:\n%S\n" \ "AST Content:\n%S\n" \
"Other Content:\n%S\n" \ "Other Content:\n%S\n" \
, str_visualize_whitespace(self->content, GlobalAllocator) \ , str_visualize_whitespace(self->content, GlobalAllocator) \
, str_visualize_whitespace(other->content, GlobalAllocator) \ , str_visualize_whitespace(other->content, GlobalAllocator) \
); \ ); \
} }
@ -671,9 +671,9 @@ bool code_is_equal( Code self, Code other )
if ( other->ast == nullptr ) \ if ( other->ast == nullptr ) \
{ \ { \
log_fmt("\nAST::is_equal: Failed for member " #ast " other equivalent param is null\n" \ log_fmt("\nAST::is_equal: Failed for member " #ast " other equivalent param is null\n" \
"AST : %S\n" \ "AST : %S\n" \
"Other: %S\n" \ "Other: %S\n" \
"For ast member: %S\n" \ "For ast member: %S\n" \
, code_debug_str(self) \ , code_debug_str(self) \
, code_debug_str(other) \ , code_debug_str(other) \
, code_debug_str(self->ast) \ , code_debug_str(self->ast) \
@ -685,10 +685,10 @@ bool code_is_equal( Code self, Code other )
if ( ! code_is_equal(self->ast, other->ast ) ) \ if ( ! code_is_equal(self->ast, other->ast ) ) \
{ \ { \
log_fmt( "\nAST::is_equal: Failed for " #ast"\n" \ log_fmt( "\nAST::is_equal: Failed for " #ast"\n" \
"AST : %S\n" \ "AST : %S\n" \
"Other: %S\n" \ "Other: %S\n" \
"For ast member: %S\n" \ "For ast member: %S\n" \
"other's ast member: %S\n" \ "other's ast member: %S\n" \
, code_debug_str(self) \ , code_debug_str(self) \
, code_debug_str(other) \ , code_debug_str(other) \
, code_debug_str(self->ast) \ , code_debug_str(self->ast) \

45
base/components/ast.hpp
View File

@ -242,7 +242,7 @@ GEN_NS_PARSER_END
// I have ideas for ways to pack that into the typedef/using ast, but for now just keeping it like this // I have ideas for ways to pack that into the typedef/using ast, but for now just keeping it like this
#define ParserTokenType GEN_NS_PARSER Token #define ParserTokenType GEN_NS_PARSER Token
typedef ParserTokenType Token; typedef ParserTokenType Token;
#undef ParserTokenType #undef ParserTokenType
#endif #endif
#if GEN_COMPILER_CPP #if GEN_COMPILER_CPP
@ -251,19 +251,19 @@ template< class Type> forceinline Type tmpl_cast( Code self ) { return * rcast(
#pragma region Code C-Interface #pragma region Code C-Interface
void code_append (Code code, Code other ); void code_append (Code code, Code other );
Str code_debug_str (Code code); Str code_debug_str (Code code);
Code code_duplicate (Code code); Code code_duplicate (Code code);
Code* code_entry (Code code, u32 idx ); Code* code_entry (Code code, u32 idx );
bool code_has_entries (Code code); bool code_has_entries (Code code);
bool code_is_body (Code code); bool code_is_body (Code code);
bool code_is_equal (Code code, Code other); bool code_is_equal (Code code, Code other);
bool code_is_valid (Code code); bool code_is_valid (Code code);
void code_set_global (Code code); void code_set_global (Code code);
StrBuilder code_to_string (Code self ); StrBuilder code_to_strbuilder (Code self );
void code_to_strbuilder_ptr(Code self, StrBuilder* result ); void code_to_strbuilder_ptr(Code self, StrBuilder* result );
Str code_type_str (Code self ); Str code_type_str (Code self );
bool code_validate_body(Code self ); bool code_validate_body (Code self );
#pragma endregion Code C-Interface #pragma endregion Code C-Interface
@ -278,7 +278,7 @@ struct Code
AST* ast; AST* ast;
# define Using_Code( Typename ) \ # define Using_Code( Typename ) \
forceinline Str debug_str() { return code_debug_str(* this); } \ forceinline Str debug_str() { return code_debug_str(* this); } \
forceinline Code duplicate() { return code_duplicate(* this); } \ forceinline Code duplicate() { return code_duplicate(* this); } \
forceinline bool is_equal( Code other ) { return code_is_equal(* this, other); } \ forceinline bool is_equal( Code other ) { return code_is_equal(* this, other); } \
forceinline bool is_body() { return code_is_body(* this); } \ forceinline bool is_body() { return code_is_body(* this); } \
@ -295,16 +295,17 @@ struct Code
#if ! GEN_C_LIKE_CPP #if ! GEN_C_LIKE_CPP
Using_Code( Code ); Using_Code( Code );
forceinline void append(Code other) { return code_append(* this, other); } forceinline void append(Code other) { return code_append(* this, other); }
forceinline Code* entry(u32 idx) { return code_entry(* this, idx); } forceinline Code* entry(u32 idx) { return code_entry(* this, idx); }
forceinline bool has_entries() { return code_has_entries(* this); } forceinline bool has_entries() { return code_has_entries(* this); }
forceinline StrBuilder to_string() { return code_to_string(* this); } forceinline StrBuilder to_strbuilder() { return code_to_strbuilder(* this); }
forceinline void to_string(StrBuilder& result) { return code_to_strbuilder_ptr(* this, & result); } forceinline void to_strbuilder(StrBuilder& result) { return code_to_strbuilder_ptr(* this, & result); }
forceinline Str type_str() { return code_type_str(* this); } forceinline Str type_str() { return code_type_str(* this); }
forceinline bool validate_body() { return code_validate_body(*this); } forceinline bool validate_body() { return code_validate_body(*this); }
#endif #endif
Using_CodeOps( Code ); Using_CodeOps( Code );
forceinline Code operator *() { return * this; } // Required to support for-range iteration.
forceinline AST* operator ->() { return ast; } forceinline AST* operator ->() { return ast; }
Code& operator ++(); Code& operator ++();

280
base/components/code_serialization.cpp
View File

@ -4,7 +4,7 @@
#endif #endif
inline inline
StrBuilder attributes_to_string(CodeAttributes attributes) { StrBuilder attributes_to_strbuilder(CodeAttributes attributes) {
GEN_ASSERT(attributes); GEN_ASSERT(attributes);
char* raw = ccast(char*, str_duplicate( attributes->Content, GlobalAllocator ).Ptr); char* raw = ccast(char*, str_duplicate( attributes->Content, GlobalAllocator ).Ptr);
StrBuilder result = { raw }; StrBuilder result = { raw };
@ -18,7 +18,7 @@ void attributes_to_strbuilder_ref(CodeAttributes attributes, StrBuilder* result)
strbuilder_append_str(result, attributes->Content); strbuilder_append_str(result, attributes->Content);
} }
StrBuilder body_to_string(CodeBody body) StrBuilder body_to_strbuilder(CodeBody body)
{ {
GEN_ASSERT(body); GEN_ASSERT(body);
StrBuilder result = strbuilder_make_reserve( GlobalAllocator, 128 ); StrBuilder result = strbuilder_make_reserve( GlobalAllocator, 128 );
@ -56,7 +56,7 @@ void body_to_strbuilder_ref( CodeBody body, StrBuilder* result )
while ( left -- ) while ( left -- )
{ {
code_to_strbuilder_ptr(curr, result); code_to_strbuilder_ptr(curr, result);
// strbuilder_append_fmt( result, "%SB", code_to_string(curr) ); // strbuilder_append_fmt( result, "%SB", code_to_strbuilder(curr) );
++curr; ++curr;
} }
} }
@ -72,7 +72,7 @@ void body_to_strbuilder_export( CodeBody body, StrBuilder* result )
while ( left-- ) while ( left-- )
{ {
code_to_strbuilder_ptr(curr, result); code_to_strbuilder_ptr(curr, result);
// strbuilder_append_fmt( result, "%SB", code_to_string(curr) ); // strbuilder_append_fmt( result, "%SB", code_to_strbuilder(curr) );
++curr; ++curr;
} }
@ -80,7 +80,7 @@ void body_to_strbuilder_export( CodeBody body, StrBuilder* result )
} }
inline inline
StrBuilder comment_to_string(CodeComment comment) { StrBuilder comment_to_strbuilder(CodeComment comment) {
GEN_ASSERT(comment); GEN_ASSERT(comment);
char* raw = ccast(char*, str_duplicate( comment->Content, GlobalAllocator ).Ptr); char* raw = ccast(char*, str_duplicate( comment->Content, GlobalAllocator ).Ptr);
StrBuilder result = { raw }; StrBuilder result = { raw };
@ -94,7 +94,7 @@ void comment_to_strbuilder_ref(CodeComment comment, StrBuilder* result) {
strbuilder_append_str(result, comment->Content); strbuilder_append_str(result, comment->Content);
} }
StrBuilder constructor_to_string(CodeConstructor self) StrBuilder constructor_to_strbuilder(CodeConstructor self)
{ {
StrBuilder result = strbuilder_make_reserve( GlobalAllocator, 128 ); StrBuilder result = strbuilder_make_reserve( GlobalAllocator, 128 );
switch (self->Type) switch (self->Type)
@ -120,17 +120,17 @@ void constructor_to_strbuilder_def(CodeConstructor self, StrBuilder* result )
} }
if ( self->Params ) if ( self->Params )
strbuilder_append_fmt( result, "( %SB )", params_to_string(self->Params) ); strbuilder_append_fmt( result, "( %SB )", params_to_strbuilder(self->Params) );
else else
strbuilder_append_str( result, txt("()") ); strbuilder_append_str( result, txt("()") );
if ( self->InitializerList ) if ( self->InitializerList )
strbuilder_append_fmt( result, " : %SB", code_to_string(self->InitializerList) ); strbuilder_append_fmt( result, " : %SB", code_to_strbuilder(self->InitializerList) );
if ( self->InlineCmt ) if ( self->InlineCmt )
strbuilder_append_fmt( result, " // %S", self->InlineCmt->Content ); strbuilder_append_fmt( result, " // %S", self->InlineCmt->Content );
strbuilder_append_fmt( result, "\n{\n%SB\n}\n", code_to_string(self->Body) ); strbuilder_append_fmt( result, "\n{\n%SB\n}\n", code_to_strbuilder(self->Body) );
} }
void constructor_to_strbuilder_fwd(CodeConstructor self, StrBuilder* result ) void constructor_to_strbuilder_fwd(CodeConstructor self, StrBuilder* result )
@ -144,12 +144,12 @@ void constructor_to_strbuilder_fwd(CodeConstructor self, StrBuilder* result )
} }
if ( self->Params ) if ( self->Params )
strbuilder_append_fmt( result, "( %SB )", params_to_string(self->Params) ); strbuilder_append_fmt( result, "( %SB )", params_to_strbuilder(self->Params) );
else else
strbuilder_append_fmt( result, "()"); strbuilder_append_fmt( result, "()");
if (self->Body) if (self->Body)
strbuilder_append_fmt( result, " = %SB", code_to_string(self->Body) ); strbuilder_append_fmt( result, " = %SB", code_to_strbuilder(self->Body) );
if ( self->InlineCmt ) if ( self->InlineCmt )
strbuilder_append_fmt( result, "; // %S\n", self->InlineCmt->Content ); strbuilder_append_fmt( result, "; // %S\n", self->InlineCmt->Content );
@ -157,7 +157,7 @@ void constructor_to_strbuilder_fwd(CodeConstructor self, StrBuilder* result )
strbuilder_append_str( result, txt(";\n") ); strbuilder_append_str( result, txt(";\n") );
} }
StrBuilder class_to_string( CodeClass self ) StrBuilder class_to_strbuilder( CodeClass self )
{ {
StrBuilder result = strbuilder_make_reserve( GlobalAllocator, 512 ); StrBuilder result = strbuilder_make_reserve( GlobalAllocator, 512 );
switch ( self->Type ) switch ( self->Type )
@ -183,13 +183,13 @@ void class_to_strbuilder_def( CodeClass self, StrBuilder* result )
if ( self->Attributes ) if ( self->Attributes )
{ {
strbuilder_append_fmt( result, "%SB ", attributes_to_string(self->Attributes) ); strbuilder_append_fmt( result, "%SB ", attributes_to_strbuilder(self->Attributes) );
} }
if ( self->ParentType ) if ( self->ParentType )
{ {
Str access_level = access_spec_to_str( self->ParentAccess ); Str access_level = access_spec_to_str( self->ParentAccess );
strbuilder_append_fmt( result, "%S : %S %SB", self->Name, access_level, typename_to_string(self->ParentType) ); strbuilder_append_fmt( result, "%S : %S %SB", self->Name, access_level, typename_to_strbuilder(self->ParentType) );
CodeTypename interface = cast(CodeTypename, self->ParentType->Next); CodeTypename interface = cast(CodeTypename, self->ParentType->Next);
if ( interface ) if ( interface )
@ -197,7 +197,7 @@ void class_to_strbuilder_def( CodeClass self, StrBuilder* result )
while ( interface ) while ( interface )
{ {
strbuilder_append_fmt( result, ", public %SB", typename_to_string(interface) ); strbuilder_append_fmt( result, ", public %SB", typename_to_strbuilder(interface) );
interface = interface->Next ? cast(CodeTypename, interface->Next) : NullCode; interface = interface->Next ? cast(CodeTypename, interface->Next) : NullCode;
} }
} }
@ -211,7 +211,7 @@ void class_to_strbuilder_def( CodeClass self, StrBuilder* result )
strbuilder_append_fmt( result, " // %S", self->InlineCmt->Content ); strbuilder_append_fmt( result, " // %S", self->InlineCmt->Content );
} }
strbuilder_append_fmt( result, "\n{\n%SB\n}", body_to_string(self->Body) ); strbuilder_append_fmt( result, "\n{\n%SB\n}", body_to_strbuilder(self->Body) );
if ( self->Parent == nullptr || ( self->Parent->Type != CT_Typedef && self->Parent->Type != CT_Variable ) ) if ( self->Parent == nullptr || ( self->Parent->Type != CT_Typedef && self->Parent->Type != CT_Variable ) )
strbuilder_append_str( result, txt(";\n") ); strbuilder_append_str( result, txt(";\n") );
@ -225,7 +225,7 @@ void class_to_strbuilder_fwd( CodeClass self, StrBuilder* result )
strbuilder_append_str( result, txt("export ") ); strbuilder_append_str( result, txt("export ") );
if ( self->Attributes ) if ( self->Attributes )
strbuilder_append_fmt( result, "class %SB %S", attributes_to_string(self->Attributes), self->Name ); strbuilder_append_fmt( result, "class %SB %S", attributes_to_strbuilder(self->Attributes), self->Name );
else strbuilder_append_fmt( result, "class %S", self->Name ); else strbuilder_append_fmt( result, "class %S", self->Name );
@ -239,7 +239,7 @@ void class_to_strbuilder_fwd( CodeClass self, StrBuilder* result )
} }
} }
StrBuilder define_to_string(CodeDefine define) StrBuilder define_to_strbuilder(CodeDefine define)
{ {
return strbuilder_fmt_buf( GlobalAllocator, "#define %S %S", define->Name, define->Content ); return strbuilder_fmt_buf( GlobalAllocator, "#define %S %S", define->Name, define->Content );
} }
@ -249,7 +249,7 @@ void define_to_strbuilder_ref(CodeDefine define, StrBuilder* result )
strbuilder_append_fmt( result, "#define %S %S", define->Name, define->Content ); strbuilder_append_fmt( result, "#define %S %S", define->Name, define->Content );
} }
StrBuilder destructor_to_string(CodeDestructor self) StrBuilder destructor_to_strbuilder(CodeDestructor self)
{ {
StrBuilder result = strbuilder_make_reserve( GlobalAllocator, 128 ); StrBuilder result = strbuilder_make_reserve( GlobalAllocator, 128 );
switch ( self->Type ) switch ( self->Type )
@ -280,7 +280,7 @@ void destructor_to_strbuilder_def(CodeDestructor self, StrBuilder* result )
else else
strbuilder_append_fmt( result, "~%S()", self->Parent->Name ); strbuilder_append_fmt( result, "~%S()", self->Parent->Name );
strbuilder_append_fmt( result, "\n{\n%SB\n}\n", code_to_string(self->Body) ); strbuilder_append_fmt( result, "\n{\n%SB\n}\n", code_to_strbuilder(self->Body) );
} }
void destructor_to_strbuilder_fwd(CodeDestructor self, StrBuilder* result ) void destructor_to_strbuilder_fwd(CodeDestructor self, StrBuilder* result )
@ -295,7 +295,7 @@ void destructor_to_strbuilder_fwd(CodeDestructor self, StrBuilder* result )
if ( specifiers_has(self->Specs, Spec_Pure ) ) if ( specifiers_has(self->Specs, Spec_Pure ) )
strbuilder_append_str( result, txt(" = 0;") ); strbuilder_append_str( result, txt(" = 0;") );
else if (self->Body) else if (self->Body)
strbuilder_append_fmt( result, " = %SB;", code_to_string(self->Body) ); strbuilder_append_fmt( result, " = %SB;", code_to_strbuilder(self->Body) );
} }
else else
strbuilder_append_fmt( result, "~%S();", self->Parent->Name ); strbuilder_append_fmt( result, "~%S();", self->Parent->Name );
@ -306,7 +306,7 @@ void destructor_to_strbuilder_fwd(CodeDestructor self, StrBuilder* result )
strbuilder_append_str( result, txt("\n")); strbuilder_append_str( result, txt("\n"));
} }
StrBuilder enum_to_string(CodeEnum self) StrBuilder enum_to_strbuilder(CodeEnum self)
{ {
StrBuilder result = strbuilder_make_reserve( GlobalAllocator, 512 ); StrBuilder result = strbuilder_make_reserve( GlobalAllocator, 512 );
switch ( self->Type ) switch ( self->Type )
@ -337,24 +337,24 @@ void enum_to_strbuilder_def(CodeEnum self, StrBuilder* result )
strbuilder_append_str( result, txt("enum ") ); strbuilder_append_str( result, txt("enum ") );
if ( self->Attributes ) if ( self->Attributes )
strbuilder_append_fmt( result, "%SB ", attributes_to_string(self->Attributes) ); strbuilder_append_fmt( result, "%SB ", attributes_to_strbuilder(self->Attributes) );
if ( self->UnderlyingType ) if ( self->UnderlyingType )
strbuilder_append_fmt( result, "%S : %SB\n{\n%SB\n}" strbuilder_append_fmt( result, "%S : %SB\n{\n%SB\n}"
, self->Name , self->Name
, typename_to_string(self->UnderlyingType) , typename_to_strbuilder(self->UnderlyingType)
, body_to_string(self->Body) , body_to_strbuilder(self->Body)
); );
else if ( self->UnderlyingTypeMacro ) else if ( self->UnderlyingTypeMacro )
strbuilder_append_fmt( result, "%S %SB\n{\n%SB\n}" strbuilder_append_fmt( result, "%S %SB\n{\n%SB\n}"
, self->Name , self->Name
, code_to_string(self->UnderlyingTypeMacro) , code_to_strbuilder(self->UnderlyingTypeMacro)
, body_to_string(self->Body) , body_to_strbuilder(self->Body)
); );
else strbuilder_append_fmt( result, "%S\n{\n%SB\n}", self->Name, body_to_string(self->Body) ); else strbuilder_append_fmt( result, "%S\n{\n%SB\n}", self->Name, body_to_strbuilder(self->Body) );
} }
else strbuilder_append_fmt( result, "enum %S\n{\n%SB\n}", self->Name, body_to_string(self->Body) ); else strbuilder_append_fmt( result, "enum %S\n{\n%SB\n}", self->Name, body_to_strbuilder(self->Body) );
if ( self->Parent == nullptr || ( self->Parent->Type != CT_Typedef && self->Parent->Type != CT_Variable ) ) if ( self->Parent == nullptr || ( self->Parent->Type != CT_Typedef && self->Parent->Type != CT_Variable ) )
strbuilder_append_str( result, txt(";\n")); strbuilder_append_str( result, txt(";\n"));
@ -366,14 +366,14 @@ void enum_to_strbuilder_fwd(CodeEnum self, StrBuilder* result )
strbuilder_append_str( result, txt("export ") ); strbuilder_append_str( result, txt("export ") );
if ( self->Attributes ) if ( self->Attributes )
strbuilder_append_fmt( result, "%SB ", attributes_to_string(self->Attributes) ); strbuilder_append_fmt( result, "%SB ", attributes_to_strbuilder(self->Attributes) );
if ( self->UnderlyingType ) if ( self->UnderlyingType )
strbuilder_append_fmt( result, "enum %S : %SB", self->Name, typename_to_string(self->UnderlyingType) ); strbuilder_append_fmt( result, "enum %S : %SB", self->Name, typename_to_strbuilder(self->UnderlyingType) );
else if (self->UnderlyingTypeMacro) else if (self->UnderlyingTypeMacro)
{ {
log_fmt("IDENTIFIED A UNDERLYING ENUM MACRO"); log_fmt("IDENTIFIED A UNDERLYING ENUM MACRO");
strbuilder_append_fmt( result, "enum %S %SB", self->Name, code_to_string(self->UnderlyingTypeMacro) ); strbuilder_append_fmt( result, "enum %S %SB", self->Name, code_to_strbuilder(self->UnderlyingTypeMacro) );
} }
else else
strbuilder_append_fmt( result, "enum %S", self->Name ); strbuilder_append_fmt( result, "enum %S", self->Name );
@ -398,21 +398,21 @@ void enum_to_strbuilder_class_def(CodeEnum self, StrBuilder* result )
if ( self->Attributes ) if ( self->Attributes )
{ {
strbuilder_append_fmt( result, "%SB ", attributes_to_string(self->Attributes) ); strbuilder_append_fmt( result, "%SB ", attributes_to_strbuilder(self->Attributes) );
} }
if ( self->UnderlyingType ) if ( self->UnderlyingType )
{ {
strbuilder_append_fmt( result, "%S : %SB\n{\n%SB\n}", self->Name, typename_to_string(self->UnderlyingType), body_to_string(self->Body) ); strbuilder_append_fmt( result, "%S : %SB\n{\n%SB\n}", self->Name, typename_to_strbuilder(self->UnderlyingType), body_to_strbuilder(self->Body) );
} }
else else
{ {
strbuilder_append_fmt( result, "%S\n{\n%SB\n}", self->Name, body_to_string(self->Body) ); strbuilder_append_fmt( result, "%S\n{\n%SB\n}", self->Name, body_to_strbuilder(self->Body) );
} }
} }
else else
{ {
strbuilder_append_fmt( result, "enum %S\n{\n%SB\n}", self->Name, body_to_string(self->Body) ); strbuilder_append_fmt( result, "enum %S\n{\n%SB\n}", self->Name, body_to_strbuilder(self->Body) );
} }
if ( self->Parent == nullptr || ( self->Parent->Type != CT_Typedef && self->Parent->Type != CT_Variable ) ) if ( self->Parent == nullptr || ( self->Parent->Type != CT_Typedef && self->Parent->Type != CT_Variable ) )
@ -427,9 +427,9 @@ void enum_to_strbuilder_class_fwd(CodeEnum self, StrBuilder* result )
strbuilder_append_str( result, txt("enum class ") ); strbuilder_append_str( result, txt("enum class ") );
if ( self->Attributes ) if ( self->Attributes )
strbuilder_append_fmt( result, "%SB ", attributes_to_string(self->Attributes) ); strbuilder_append_fmt( result, "%SB ", attributes_to_strbuilder(self->Attributes) );
strbuilder_append_fmt( result, "%S : %SB", self->Name, typename_to_string(self->UnderlyingType) ); strbuilder_append_fmt( result, "%S : %SB", self->Name, typename_to_strbuilder(self->UnderlyingType) );
if ( self->Parent == nullptr || ( self->Parent->Type != CT_Typedef && self->Parent->Type != CT_Variable ) ) if ( self->Parent == nullptr || ( self->Parent->Type != CT_Typedef && self->Parent->Type != CT_Variable ) )
{ {
@ -440,7 +440,7 @@ void enum_to_strbuilder_class_fwd(CodeEnum self, StrBuilder* result )
} }
} }
StrBuilder exec_to_string(CodeExec exec) StrBuilder exec_to_strbuilder(CodeExec exec)
{ {
GEN_ASSERT(exec); GEN_ASSERT(exec);
char* raw = ccast(char*, str_duplicate( exec->Content, GlobalAllocator ).Ptr); char* raw = ccast(char*, str_duplicate( exec->Content, GlobalAllocator ).Ptr);
@ -448,15 +448,15 @@ StrBuilder exec_to_string(CodeExec exec)
return result; return result;
} }
void extern_to_string(CodeExtern self, StrBuilder* result ) void extern_to_strbuilder(CodeExtern self, StrBuilder* result )
{ {
if ( self->Body ) if ( self->Body )
strbuilder_append_fmt( result, "extern \"%S\"\n{\n%SB\n}\n", self->Name, body_to_string(self->Body) ); strbuilder_append_fmt( result, "extern \"%S\"\n{\n%SB\n}\n", self->Name, body_to_strbuilder(self->Body) );
else else
strbuilder_append_fmt( result, "extern \"%S\"\n{}\n", self->Name ); strbuilder_append_fmt( result, "extern \"%S\"\n{}\n", self->Name );
} }
StrBuilder include_to_string(CodeInclude include) StrBuilder include_to_strbuilder(CodeInclude include)
{ {
return strbuilder_fmt_buf( GlobalAllocator, "#include %S\n", include->Content ); return strbuilder_fmt_buf( GlobalAllocator, "#include %S\n", include->Content );
} }
@ -466,7 +466,7 @@ void include_to_strbuilder_ref( CodeInclude include, StrBuilder* result )
strbuilder_append_fmt( result, "#include %S\n", include->Content ); strbuilder_append_fmt( result, "#include %S\n", include->Content );
} }
StrBuilder friend_to_string(CodeFriend self) StrBuilder friend_to_strbuilder(CodeFriend self)
{ {
StrBuilder result = strbuilder_make_reserve( GlobalAllocator, 256 ); StrBuilder result = strbuilder_make_reserve( GlobalAllocator, 256 );
friend_to_strbuilder_ref( self, & result ); friend_to_strbuilder_ref( self, & result );
@ -475,7 +475,7 @@ StrBuilder friend_to_string(CodeFriend self)
void friend_to_strbuilder_ref(CodeFriend self, StrBuilder* result ) void friend_to_strbuilder_ref(CodeFriend self, StrBuilder* result )
{ {
strbuilder_append_fmt( result, "friend %SB", code_to_string(self->Declaration) ); strbuilder_append_fmt( result, "friend %SB", code_to_strbuilder(self->Declaration) );
if ( self->Declaration->Type != CT_Function && self->Declaration->Type != CT_Operator && (* result)[ strbuilder_length(* result) - 1 ] != ';' ) if ( self->Declaration->Type != CT_Function && self->Declaration->Type != CT_Operator && (* result)[ strbuilder_length(* result) - 1 ] != ';' )
{ {
@ -488,7 +488,7 @@ void friend_to_strbuilder_ref(CodeFriend self, StrBuilder* result )
strbuilder_append_str( result, txt("\n")); strbuilder_append_str( result, txt("\n"));
} }
StrBuilder fn_to_string(CodeFn self) StrBuilder fn_to_strbuilder(CodeFn self)
{ {
StrBuilder result = strbuilder_make_reserve( GlobalAllocator, 512 ); StrBuilder result = strbuilder_make_reserve( GlobalAllocator, 512 );
switch ( self->Type ) switch ( self->Type )
@ -509,7 +509,7 @@ void fn_to_strbuilder_def(CodeFn self, StrBuilder* result )
strbuilder_append_str( result, txt("export") ); strbuilder_append_str( result, txt("export") );
if ( self->Attributes ) if ( self->Attributes )
strbuilder_append_fmt( result, " %SB ", attributes_to_string(self->Attributes) ); strbuilder_append_fmt( result, " %SB ", attributes_to_strbuilder(self->Attributes) );
bool prefix_specs = false; bool prefix_specs = false;
if ( self->Specs ) if ( self->Specs )
@ -530,13 +530,13 @@ void fn_to_strbuilder_def(CodeFn self, StrBuilder* result )
strbuilder_append_str( result, txt("\n") ); strbuilder_append_str( result, txt("\n") );
if ( self->ReturnType ) if ( self->ReturnType )
strbuilder_append_fmt( result, "%SB %S(", typename_to_string(self->ReturnType), self->Name ); strbuilder_append_fmt( result, "%SB %S(", typename_to_strbuilder(self->ReturnType), self->Name );
else else
strbuilder_append_fmt( result, "%S(", self->Name ); strbuilder_append_fmt( result, "%S(", self->Name );
if ( self->Params ) if ( self->Params )
strbuilder_append_fmt( result, "%SB)", params_to_string(self->Params) ); strbuilder_append_fmt( result, "%SB)", params_to_strbuilder(self->Params) );
else else
strbuilder_append_str( result, txt(")") ); strbuilder_append_str( result, txt(")") );
@ -553,7 +553,7 @@ void fn_to_strbuilder_def(CodeFn self, StrBuilder* result )
} }
} }
strbuilder_append_fmt( result, "\n{\n%SB\n}\n", body_to_string(self->Body) ); strbuilder_append_fmt( result, "\n{\n%SB\n}\n", body_to_strbuilder(self->Body) );
} }
void fn_to_strbuilder_fwd(CodeFn self, StrBuilder* result ) void fn_to_strbuilder_fwd(CodeFn self, StrBuilder* result )
@ -562,7 +562,7 @@ void fn_to_strbuilder_fwd(CodeFn self, StrBuilder* result )
strbuilder_append_str( result, txt("export ") ); strbuilder_append_str( result, txt("export ") );
if ( self->Attributes ) if ( self->Attributes )
strbuilder_append_fmt( result, "%SB ", attributes_to_string(self->Attributes) ); strbuilder_append_fmt( result, "%SB ", attributes_to_strbuilder(self->Attributes) );
b32 prefix_specs = false; b32 prefix_specs = false;
if ( self->Specs ) if ( self->Specs )
@ -585,13 +585,13 @@ void fn_to_strbuilder_fwd(CodeFn self, StrBuilder* result )
} }
if ( self->ReturnType ) if ( self->ReturnType )
strbuilder_append_fmt( result, "%SB %S(", typename_to_string(self->ReturnType), self->Name ); strbuilder_append_fmt( result, "%SB %S(", typename_to_strbuilder(self->ReturnType), self->Name );
else else
strbuilder_append_fmt( result, "%S(", self->Name ); strbuilder_append_fmt( result, "%S(", self->Name );
if ( self->Params ) if ( self->Params )
strbuilder_append_fmt( result, "%SB)", params_to_string(self->Params) ); strbuilder_append_fmt( result, "%SB)", params_to_strbuilder(self->Params) );
else else
strbuilder_append_str( result, txt(")") ); strbuilder_append_str( result, txt(")") );
@ -611,7 +611,7 @@ void fn_to_strbuilder_fwd(CodeFn self, StrBuilder* result )
if ( self->Specs && specifiers_has(self->Specs, Spec_Pure ) >= 0 ) if ( self->Specs && specifiers_has(self->Specs, Spec_Pure ) >= 0 )
strbuilder_append_str( result, txt(" = 0;") ); strbuilder_append_str( result, txt(" = 0;") );
else if (self->Body) else if (self->Body)
strbuilder_append_fmt( result, " = %SB;", body_to_string(self->Body) ); strbuilder_append_fmt( result, " = %SB;", body_to_strbuilder(self->Body) );
if ( self->InlineCmt ) if ( self->InlineCmt )
strbuilder_append_fmt( result, "; %S", self->InlineCmt->Content ); strbuilder_append_fmt( result, "; %S", self->InlineCmt->Content );
@ -619,7 +619,7 @@ void fn_to_strbuilder_fwd(CodeFn self, StrBuilder* result )
strbuilder_append_str( result, txt(";\n") ); strbuilder_append_str( result, txt(";\n") );
} }
StrBuilder module_to_string(CodeModule self) StrBuilder module_to_strbuilder(CodeModule self)
{ {
StrBuilder result = strbuilder_make_reserve( GlobalAllocator, 64 ); StrBuilder result = strbuilder_make_reserve( GlobalAllocator, 64 );
module_to_strbuilder_ref( self, & result ); module_to_strbuilder_ref( self, & result );
@ -637,7 +637,7 @@ void module_to_strbuilder_ref(CodeModule self, StrBuilder* result )
strbuilder_append_fmt( result, "%S;\n", self->Name ); strbuilder_append_fmt( result, "%S;\n", self->Name );
} }
StrBuilder namespace_to_string(CodeNS self) StrBuilder namespace_to_strbuilder(CodeNS self)
{ {
StrBuilder result = strbuilder_make_reserve( GlobalAllocator, 512 ); StrBuilder result = strbuilder_make_reserve( GlobalAllocator, 512 );
namespace_to_strbuilder_ref( self, & result ); namespace_to_strbuilder_ref( self, & result );
@ -649,10 +649,10 @@ void namespace_to_strbuilder_ref(CodeNS self, StrBuilder* result )
if ( bitfield_is_equal( u32, self->ModuleFlags, ModuleFlag_Export )) if ( bitfield_is_equal( u32, self->ModuleFlags, ModuleFlag_Export ))
strbuilder_append_str( result, txt("export ") ); strbuilder_append_str( result, txt("export ") );
strbuilder_append_fmt( result, "namespace %S\n{\n%SB\n}\n", self->Name, body_to_string(self->Body) ); strbuilder_append_fmt( result, "namespace %S\n{\n%SB\n}\n", self->Name, body_to_strbuilder(self->Body) );
} }
StrBuilder code_op_to_string(CodeOperator self) StrBuilder code_op_to_strbuilder(CodeOperator self)
{ {
StrBuilder result = strbuilder_make_reserve( GlobalAllocator, 512 ); StrBuilder result = strbuilder_make_reserve( GlobalAllocator, 512 );
switch ( self->Type ) switch ( self->Type )
@ -675,10 +675,10 @@ void code_op_to_strbuilder_def(CodeOperator self, StrBuilder* result )
strbuilder_append_str( result, txt("export ") ); strbuilder_append_str( result, txt("export ") );
if ( self->Attributes ) if ( self->Attributes )
strbuilder_append_fmt( result, "%SB ", attributes_to_string(self->Attributes) ); strbuilder_append_fmt( result, "%SB ", attributes_to_strbuilder(self->Attributes) );
if ( self->Attributes ) if ( self->Attributes )
strbuilder_append_fmt( result, "%SB ", attributes_to_string(self->Attributes) ); strbuilder_append_fmt( result, "%SB ", attributes_to_strbuilder(self->Attributes) );
if ( self->Specs ) if ( self->Specs )
{ {
@ -698,10 +698,10 @@ void code_op_to_strbuilder_def(CodeOperator self, StrBuilder* result )
} }
if ( self->ReturnType ) if ( self->ReturnType )
strbuilder_append_fmt( result, "%SB %S (", typename_to_string(self->ReturnType), self->Name ); strbuilder_append_fmt( result, "%SB %S (", typename_to_strbuilder(self->ReturnType), self->Name );
if ( self->Params ) if ( self->Params )
strbuilder_append_fmt( result, "%SB)", params_to_string(self->Params) ); strbuilder_append_fmt( result, "%SB)", params_to_strbuilder(self->Params) );
else else
strbuilder_append_str( result, txt(")") ); strbuilder_append_str( result, txt(")") );
@ -719,7 +719,7 @@ void code_op_to_strbuilder_def(CodeOperator self, StrBuilder* result )
} }
strbuilder_append_fmt( result, "\n{\n%SB\n}\n" strbuilder_append_fmt( result, "\n{\n%SB\n}\n"
, body_to_string(self->Body) , body_to_strbuilder(self->Body)
); );
} }
@ -729,7 +729,7 @@ void code_op_to_strbuilder_fwd(CodeOperator self, StrBuilder* result )
strbuilder_append_str( result, txt("export ") ); strbuilder_append_str( result, txt("export ") );
if ( self->Attributes ) if ( self->Attributes )
strbuilder_append_fmt( result, "%SB\n", attributes_to_string(self->Attributes) ); strbuilder_append_fmt( result, "%SB\n", attributes_to_strbuilder(self->Attributes) );
if ( self->Specs ) if ( self->Specs )
{ {
@ -748,10 +748,10 @@ void code_op_to_strbuilder_fwd(CodeOperator self, StrBuilder* result )
strbuilder_append_str( result, txt("\n") ); strbuilder_append_str( result, txt("\n") );
} }
strbuilder_append_fmt( result, "%SB %S (", typename_to_string(self->ReturnType), self->Name ); strbuilder_append_fmt( result, "%SB %S (", typename_to_strbuilder(self->ReturnType), self->Name );
if ( self->Params ) if ( self->Params )
strbuilder_append_fmt( result, "%SB)", params_to_string(self->Params) ); strbuilder_append_fmt( result, "%SB)", params_to_strbuilder(self->Params) );
else else
strbuilder_append_fmt( result, ")" ); strbuilder_append_fmt( result, ")" );
@ -774,7 +774,7 @@ void code_op_to_strbuilder_fwd(CodeOperator self, StrBuilder* result )
strbuilder_append_str( result, txt(";\n") ); strbuilder_append_str( result, txt(";\n") );
} }
StrBuilder opcast_to_string(CodeOpCast self) StrBuilder opcast_to_strbuilder(CodeOpCast self)
{ {
StrBuilder result = strbuilder_make_reserve( GlobalAllocator, 128 ); StrBuilder result = strbuilder_make_reserve( GlobalAllocator, 128 );
switch ( self->Type ) switch ( self->Type )
@ -803,9 +803,9 @@ void opcast_to_strbuilder_def(CodeOpCast self, StrBuilder* result )
} }
if ( self->Name.Ptr && self->Name.Len ) if ( self->Name.Ptr && self->Name.Len )
strbuilder_append_fmt( result, "%S operator %SB()", self->Name, typename_to_string(self->ValueType) ); strbuilder_append_fmt( result, "%S operator %SB()", self->Name, typename_to_strbuilder(self->ValueType) );
else else
strbuilder_append_fmt( result, "operator %SB()", typename_to_string(self->ValueType) ); strbuilder_append_fmt( result, "operator %SB()", typename_to_strbuilder(self->ValueType) );
for ( Specifier* spec = begin_CodeSpecifiers(self->Specs); spec != end_CodeSpecifiers(self->Specs); spec = next_CodeSpecifiers(self->Specs, spec) ) for ( Specifier* spec = begin_CodeSpecifiers(self->Specs); spec != end_CodeSpecifiers(self->Specs); spec = next_CodeSpecifiers(self->Specs, spec) )
{ {
@ -816,14 +816,14 @@ void opcast_to_strbuilder_def(CodeOpCast self, StrBuilder* result )
} }
} }
strbuilder_append_fmt( result, "\n{\n%SB\n}\n", body_to_string(self->Body) ); strbuilder_append_fmt( result, "\n{\n%SB\n}\n", body_to_strbuilder(self->Body) );
return; return;
} }
if ( self->Name.Ptr && self->Name.Len ) if ( self->Name.Ptr && self->Name.Len )
strbuilder_append_fmt( result, "%S operator %SB()\n{\n%SB\n}\n", self->Name, typename_to_string(self->ValueType), body_to_string(self->Body) ); strbuilder_append_fmt( result, "%S operator %SB()\n{\n%SB\n}\n", self->Name, typename_to_strbuilder(self->ValueType), body_to_strbuilder(self->Body) );
else else
strbuilder_append_fmt( result, "operator %SB()\n{\n%SB\n}\n", typename_to_string(self->ValueType), body_to_string(self->Body) ); strbuilder_append_fmt( result, "operator %SB()\n{\n%SB\n}\n", typename_to_strbuilder(self->ValueType), body_to_strbuilder(self->Body) );
} }
void opcast_to_strbuilder_fwd(CodeOpCast self, StrBuilder* result ) void opcast_to_strbuilder_fwd(CodeOpCast self, StrBuilder* result )
@ -839,7 +839,7 @@ void opcast_to_strbuilder_fwd(CodeOpCast self, StrBuilder* result )
} }
} }
strbuilder_append_fmt( result, "operator %SB()", typename_to_string(self->ValueType) ); strbuilder_append_fmt( result, "operator %SB()", typename_to_strbuilder(self->ValueType) );
for ( Specifier* spec = begin_CodeSpecifiers(self->Specs); spec != end_CodeSpecifiers(self->Specs); spec = next_CodeSpecifiers(self->Specs, spec) ) for ( Specifier* spec = begin_CodeSpecifiers(self->Specs); spec != end_CodeSpecifiers(self->Specs); spec = next_CodeSpecifiers(self->Specs, spec) )
{ {
@ -858,12 +858,12 @@ void opcast_to_strbuilder_fwd(CodeOpCast self, StrBuilder* result )
} }
if ( self->InlineCmt ) if ( self->InlineCmt )
strbuilder_append_fmt( result, "operator %SB(); %SB", typename_to_string(self->ValueType) ); strbuilder_append_fmt( result, "operator %SB(); %SB", typename_to_strbuilder(self->ValueType) );
else else
strbuilder_append_fmt( result, "operator %SB();\n", typename_to_string(self->ValueType) ); strbuilder_append_fmt( result, "operator %SB();\n", typename_to_strbuilder(self->ValueType) );
} }
StrBuilder params_to_string(CodeParams self) StrBuilder params_to_strbuilder(CodeParams self)
{ {
GEN_ASSERT(self); GEN_ASSERT(self);
GEN_ASSERT(self); GEN_ASSERT(self);
@ -888,30 +888,30 @@ void params_to_strbuilder_ref( CodeParams self, StrBuilder* result )
if ( self->ValueType == nullptr ) if ( self->ValueType == nullptr )
strbuilder_append_fmt( result, " %S", self->Name ); strbuilder_append_fmt( result, " %S", self->Name );
else else
strbuilder_append_fmt( result, " %SB %S", typename_to_string(self->ValueType), self->Name ); strbuilder_append_fmt( result, " %SB %S", typename_to_strbuilder(self->ValueType), self->Name );
} }
else if ( self->ValueType ) else if ( self->ValueType )
strbuilder_append_fmt( result, " %SB", typename_to_string(self->ValueType) ); strbuilder_append_fmt( result, " %SB", typename_to_strbuilder(self->ValueType) );
if ( self->PostNameMacro ) if ( self->PostNameMacro )
{ {
strbuilder_append_fmt( result, " %SB", code_to_string(self->PostNameMacro) ); strbuilder_append_fmt( result, " %SB", code_to_strbuilder(self->PostNameMacro) );
} }
if ( self->Value ) if ( self->Value )
strbuilder_append_fmt( result, " = %SB", code_to_string(self->Value) ); strbuilder_append_fmt( result, " = %SB", code_to_strbuilder(self->Value) );
if ( self->NumEntries - 1 > 0 ) if ( self->NumEntries - 1 > 0 )
{ {
for ( CodeParams param = begin_CodeParams(self->Next); param != end_CodeParams(self->Next); param = next_CodeParams(self->Next, param) ) for ( CodeParams param = begin_CodeParams(self->Next); param != end_CodeParams(self->Next); param = next_CodeParams(self->Next, param) )
{ {
strbuilder_append_fmt( result, ", %SB", params_to_string(param) ); strbuilder_append_fmt( result, ", %SB", params_to_strbuilder(param) );
} }
} }
} }
StrBuilder preprocess_to_string(CodePreprocessCond self) StrBuilder preprocess_to_strbuilder(CodePreprocessCond self)
{ {
GEN_ASSERT(self); GEN_ASSERT(self);
StrBuilder result = strbuilder_make_reserve( GlobalAllocator, 256 ); StrBuilder result = strbuilder_make_reserve( GlobalAllocator, 256 );
@ -975,7 +975,7 @@ void preprocess_to_strbuilder_endif(CodePreprocessCond cond, StrBuilder* result
strbuilder_append_str( result, txt("#endif\n") ); strbuilder_append_str( result, txt("#endif\n") );
} }
StrBuilder pragma_to_string(CodePragma self) StrBuilder pragma_to_strbuilder(CodePragma self)
{ {
GEN_ASSERT(self); GEN_ASSERT(self);
StrBuilder result = strbuilder_make_reserve( GlobalAllocator, 256 ); StrBuilder result = strbuilder_make_reserve( GlobalAllocator, 256 );
@ -988,7 +988,7 @@ void pragma_to_strbuilder_ref(CodePragma self, StrBuilder* result )
strbuilder_append_fmt( result, "#pragma %S\n", self->Content ); strbuilder_append_fmt( result, "#pragma %S\n", self->Content );
} }
StrBuilder specifiers_to_string(CodeSpecifiers self) StrBuilder specifiers_to_strbuilder(CodeSpecifiers self)
{ {
StrBuilder result = strbuilder_make_reserve( GlobalAllocator, 64 ); StrBuilder result = strbuilder_make_reserve( GlobalAllocator, 64 );
specifiers_to_strbuilder_ref( self, & result ); specifiers_to_strbuilder_ref( self, & result );
@ -1009,7 +1009,7 @@ void specifiers_to_strbuilder_ref( CodeSpecifiers self, StrBuilder* result )
} }
} }
StrBuilder struct_to_string(CodeStruct self) StrBuilder struct_to_strbuilder(CodeStruct self)
{ {
GEN_ASSERT(self); GEN_ASSERT(self);
GEN_ASSERT(self); GEN_ASSERT(self);
@ -1037,14 +1037,14 @@ void struct_to_strbuilder_def( CodeStruct self, StrBuilder* result )
if ( self->Attributes ) if ( self->Attributes )
{ {
strbuilder_append_fmt( result, "%SB ", attributes_to_string(self->Attributes) ); strbuilder_append_fmt( result, "%SB ", attributes_to_strbuilder(self->Attributes) );
} }
if ( self->ParentType ) if ( self->ParentType )
{ {
Str access_level = access_spec_to_str( self->ParentAccess ); Str access_level = access_spec_to_str( self->ParentAccess );
strbuilder_append_fmt( result, "%S : %S %SB", self->Name, access_level, typename_to_string(self->ParentType) ); strbuilder_append_fmt( result, "%S : %S %SB", self->Name, access_level, typename_to_strbuilder(self->ParentType) );
CodeTypename interface = cast(CodeTypename, self->ParentType->Next); CodeTypename interface = cast(CodeTypename, self->ParentType->Next);
if ( interface ) if ( interface )
@ -1052,7 +1052,7 @@ void struct_to_strbuilder_def( CodeStruct self, StrBuilder* result )
while ( interface ) while ( interface )
{ {
strbuilder_append_fmt( result, ", %SB", typename_to_string(interface) ); strbuilder_append_fmt( result, ", %SB", typename_to_strbuilder(interface) );
interface = interface->Next ? cast( CodeTypename, interface->Next) : NullCode; interface = interface->Next ? cast( CodeTypename, interface->Next) : NullCode;
} }
} }
@ -1066,7 +1066,7 @@ void struct_to_strbuilder_def( CodeStruct self, StrBuilder* result )
strbuilder_append_fmt( result, " // %S", self->InlineCmt->Content ); strbuilder_append_fmt( result, " // %S", self->InlineCmt->Content );
} }
strbuilder_append_fmt( result, "\n{\n%SB\n}", body_to_string(self->Body) ); strbuilder_append_fmt( result, "\n{\n%SB\n}", body_to_strbuilder(self->Body) );
if ( self->Parent == nullptr || ( self->Parent->Type != CT_Typedef && self->Parent->Type != CT_Variable ) ) if ( self->Parent == nullptr || ( self->Parent->Type != CT_Typedef && self->Parent->Type != CT_Variable ) )
strbuilder_append_str( result, txt(";\n")); strbuilder_append_str( result, txt(";\n"));
@ -1080,7 +1080,7 @@ void struct_to_strbuilder_fwd( CodeStruct self, StrBuilder* result )
strbuilder_append_str( result, txt("export ") ); strbuilder_append_str( result, txt("export ") );
if ( self->Attributes ) if ( self->Attributes )
strbuilder_append_fmt( result, "struct %SB %S", attributes_to_string(self->Attributes), self->Name ); strbuilder_append_fmt( result, "struct %SB %S", attributes_to_strbuilder(self->Attributes), self->Name );
else strbuilder_append_fmt( result, "struct %S", self->Name ); else strbuilder_append_fmt( result, "struct %S", self->Name );
@ -1093,7 +1093,7 @@ void struct_to_strbuilder_fwd( CodeStruct self, StrBuilder* result )
} }
} }
StrBuilder template_to_string(CodeTemplate self) StrBuilder template_to_strbuilder(CodeTemplate self)
{ {
GEN_ASSERT(self); GEN_ASSERT(self);
StrBuilder result = strbuilder_make_reserve( GlobalAllocator, 1024 ); StrBuilder result = strbuilder_make_reserve( GlobalAllocator, 1024 );
@ -1109,12 +1109,12 @@ void template_to_strbuilder_ref(CodeTemplate self, StrBuilder* result )
strbuilder_append_str( result, txt("export ") ); strbuilder_append_str( result, txt("export ") );
if ( self->Params ) if ( self->Params )
strbuilder_append_fmt( result, "template< %SB >\n%SB", params_to_string(self->Params), code_to_string(self->Declaration) ); strbuilder_append_fmt( result, "template< %SB >\n%SB", params_to_strbuilder(self->Params), code_to_strbuilder(self->Declaration) );
else else
strbuilder_append_fmt( result, "template<>\n%SB", code_to_string(self->Declaration) ); strbuilder_append_fmt( result, "template<>\n%SB", code_to_strbuilder(self->Declaration) );
} }
StrBuilder typedef_to_string(CodeTypedef self) StrBuilder typedef_to_strbuilder(CodeTypedef self)
{ {
StrBuilder result = strbuilder_make_reserve( GlobalAllocator, 128 ); StrBuilder result = strbuilder_make_reserve( GlobalAllocator, 128 );
typedef_to_strbuilder_ref( self, & result ); typedef_to_strbuilder_ref( self, & result );
@ -1130,18 +1130,18 @@ void typedef_to_strbuilder_ref(CodeTypedef self, StrBuilder* result )
// Determines if the typedef is a function typename // Determines if the typedef is a function typename
if ( self->UnderlyingType->ReturnType ) if ( self->UnderlyingType->ReturnType )
strbuilder_append_string( result, code_to_string(self->UnderlyingType) ); strbuilder_append_string( result, code_to_strbuilder(self->UnderlyingType) );
else else
strbuilder_append_fmt( result, "%SB %S", code_to_string(self->UnderlyingType), self->Name ); strbuilder_append_fmt( result, "%SB %S", code_to_strbuilder(self->UnderlyingType), self->Name );
if ( self->UnderlyingType->Type == CT_Typename && self->UnderlyingType->ArrExpr ) if ( self->UnderlyingType->Type == CT_Typename && self->UnderlyingType->ArrExpr )
{ {
strbuilder_append_fmt( result, "[ %SB ];", code_to_string(self->UnderlyingType->ArrExpr) ); strbuilder_append_fmt( result, "[ %SB ];", code_to_strbuilder(self->UnderlyingType->ArrExpr) );
Code next_arr_expr = self->UnderlyingType->ArrExpr->Next; Code next_arr_expr = self->UnderlyingType->ArrExpr->Next;
while ( next_arr_expr ) while ( next_arr_expr )
{ {
strbuilder_append_fmt( result, "[ %SB ];", code_to_string(next_arr_expr) ); strbuilder_append_fmt( result, "[ %SB ];", code_to_strbuilder(next_arr_expr) );
next_arr_expr = next_arr_expr->Next; next_arr_expr = next_arr_expr->Next;
} }
} }
@ -1156,7 +1156,7 @@ void typedef_to_strbuilder_ref(CodeTypedef self, StrBuilder* result )
strbuilder_append_str( result, txt("\n")); strbuilder_append_str( result, txt("\n"));
} }
StrBuilder typename_to_string(CodeTypename self) StrBuilder typename_to_strbuilder(CodeTypename self)
{ {
StrBuilder result = strbuilder_make_str( GlobalAllocator, txt("") ); StrBuilder result = strbuilder_make_str( GlobalAllocator, txt("") );
typename_to_strbuilder_ref( self, & result ); typename_to_strbuilder_ref( self, & result );
@ -1169,13 +1169,13 @@ void typename_to_strbuilder_ref(CodeTypename self, StrBuilder* result )
if ( self->ReturnType && self->Params ) if ( self->ReturnType && self->Params )
{ {
if ( self->Attributes ) if ( self->Attributes )
strbuilder_append_fmt( result, "%SB ", attributes_to_string(self->Attributes) ); strbuilder_append_fmt( result, "%SB ", attributes_to_strbuilder(self->Attributes) );
else else
{ {
if ( self->Specs ) if ( self->Specs )
strbuilder_append_fmt( result, "%SB ( %S ) ( %SB ) %SB", typename_to_string(self->ReturnType), self->Name, params_to_string(self->Params), specifiers_to_string(self->Specs) ); strbuilder_append_fmt( result, "%SB ( %S ) ( %SB ) %SB", typename_to_strbuilder(self->ReturnType), self->Name, params_to_strbuilder(self->Params), specifiers_to_strbuilder(self->Specs) );
else else
strbuilder_append_fmt( result, "%SB ( %S ) ( %SB )", typename_to_string(self->ReturnType), self->Name, params_to_string(self->Params) ); strbuilder_append_fmt( result, "%SB ( %S ) ( %SB )", typename_to_strbuilder(self->ReturnType), self->Name, params_to_strbuilder(self->Params) );
} }
break; break;
@ -1184,13 +1184,13 @@ void typename_to_strbuilder_ref(CodeTypename self, StrBuilder* result )
if ( self->ReturnType && self->Params ) if ( self->ReturnType && self->Params )
{ {
if ( self->Attributes ) if ( self->Attributes )
strbuilder_append_fmt( result, "%SB ", attributes_to_string(self->Attributes) ); strbuilder_append_fmt( result, "%SB ", attributes_to_strbuilder(self->Attributes) );
else else
{ {
if ( self->Specs ) if ( self->Specs )
strbuilder_append_fmt( result, "%SB %S ( %SB ) %SB", typename_to_string(self->ReturnType), self->Name, params_to_string(self->Params), specifiers_to_string(self->Specs) ); strbuilder_append_fmt( result, "%SB %S ( %SB ) %SB", typename_to_strbuilder(self->ReturnType), self->Name, params_to_strbuilder(self->Params), specifiers_to_strbuilder(self->Specs) );
else else
strbuilder_append_fmt( result, "%SB %S ( %SB )", typename_to_string(self->ReturnType), self->Name, params_to_string(self->Params) ); strbuilder_append_fmt( result, "%SB %S ( %SB )", typename_to_strbuilder(self->ReturnType), self->Name, params_to_strbuilder(self->Params) );
} }
return; return;
@ -1198,7 +1198,7 @@ void typename_to_strbuilder_ref(CodeTypename self, StrBuilder* result )
#endif #endif
if ( self->Attributes ) if ( self->Attributes )
strbuilder_append_fmt( result, "%SB ", attributes_to_string(self->Attributes) ); strbuilder_append_fmt( result, "%SB ", attributes_to_strbuilder(self->Attributes) );
switch ( self->TypeTag ) switch ( self->TypeTag )
{ {
@ -1211,7 +1211,7 @@ void typename_to_strbuilder_ref(CodeTypename self, StrBuilder* result )
} }
if ( self->Specs ) if ( self->Specs )
strbuilder_append_fmt( result, "%S %SB", self->Name, specifiers_to_string(self->Specs) ); strbuilder_append_fmt( result, "%S %SB", self->Name, specifiers_to_strbuilder(self->Specs) );
else else
strbuilder_append_fmt( result, "%S", self->Name ); strbuilder_append_fmt( result, "%S", self->Name );
@ -1219,7 +1219,7 @@ void typename_to_strbuilder_ref(CodeTypename self, StrBuilder* result )
strbuilder_append_str( result, txt("...")); strbuilder_append_str( result, txt("..."));
} }
StrBuilder union_to_string(CodeUnion self) StrBuilder union_to_strbuilder(CodeUnion self)
{ {
StrBuilder result = strbuilder_make_reserve( GlobalAllocator, 512 ); StrBuilder result = strbuilder_make_reserve( GlobalAllocator, 512 );
switch ( self->Type ) switch ( self->Type )
@ -1242,20 +1242,20 @@ void union_to_strbuilder_def(CodeUnion self, StrBuilder* result )
strbuilder_append_str( result, txt("union ") ); strbuilder_append_str( result, txt("union ") );
if ( self->Attributes ) if ( self->Attributes )
strbuilder_append_fmt( result, "%SB ", attributes_to_string(self->Attributes) ); strbuilder_append_fmt( result, "%SB ", attributes_to_strbuilder(self->Attributes) );
if ( self->Name.Len ) if ( self->Name.Len )
{ {
strbuilder_append_fmt( result, "%S\n{\n%SB\n}" strbuilder_append_fmt( result, "%S\n{\n%SB\n}"
, self->Name , self->Name
, body_to_string(self->Body) , body_to_strbuilder(self->Body)
); );
} }
else else
{ {
// Anonymous union // Anonymous union
strbuilder_append_fmt( result, "\n{\n%SB\n}" strbuilder_append_fmt( result, "\n{\n%SB\n}"
, body_to_string(self->Body) , body_to_strbuilder(self->Body)
); );
} }
@ -1273,7 +1273,7 @@ void union_to_strbuilder_fwd(CodeUnion self, StrBuilder* result )
strbuilder_append_str( result, txt("union ") ); strbuilder_append_str( result, txt("union ") );
if ( self->Attributes ) if ( self->Attributes )
strbuilder_append_fmt( result, "%SB ", attributes_to_string(self->Attributes) ); strbuilder_append_fmt( result, "%SB ", attributes_to_strbuilder(self->Attributes) );
if ( self->Name.Len ) if ( self->Name.Len )
{ {
@ -1284,7 +1284,7 @@ void union_to_strbuilder_fwd(CodeUnion self, StrBuilder* result )
strbuilder_append_str( result, txt(";\n")); strbuilder_append_str( result, txt(";\n"));
} }
StrBuilder using_to_string(CodeUsing self) StrBuilder using_to_strbuilder(CodeUsing self)
{ {
GEN_ASSERT(self); GEN_ASSERT(self);
StrBuilder result = strbuilder_make_reserve( GlobalAllocator, 128 ); StrBuilder result = strbuilder_make_reserve( GlobalAllocator, 128 );
@ -1308,20 +1308,20 @@ void using_to_strbuilder_ref(CodeUsing self, StrBuilder* result )
strbuilder_append_str( result, txt("export ") ); strbuilder_append_str( result, txt("export ") );
if ( self->Attributes ) if ( self->Attributes )
strbuilder_append_fmt( result, "%SB ", attributes_to_string(self->Attributes) ); strbuilder_append_fmt( result, "%SB ", attributes_to_strbuilder(self->Attributes) );
if ( self->UnderlyingType ) if ( self->UnderlyingType )
{ {
strbuilder_append_fmt( result, "using %S = %SB", self->Name, typename_to_string(self->UnderlyingType) ); strbuilder_append_fmt( result, "using %S = %SB", self->Name, typename_to_strbuilder(self->UnderlyingType) );
if ( self->UnderlyingType->ArrExpr ) if ( self->UnderlyingType->ArrExpr )
{ {
strbuilder_append_fmt( result, "[ %SB ]", code_to_string(self->UnderlyingType->ArrExpr) ); strbuilder_append_fmt( result, "[ %SB ]", code_to_strbuilder(self->UnderlyingType->ArrExpr) );
Code next_arr_expr = self->UnderlyingType->ArrExpr->Next; Code next_arr_expr = self->UnderlyingType->ArrExpr->Next;
while ( next_arr_expr ) while ( next_arr_expr )
{ {
strbuilder_append_fmt( result, "[ %SB ]", code_to_string(next_arr_expr) ); strbuilder_append_fmt( result, "[ %SB ]", code_to_strbuilder(next_arr_expr) );
next_arr_expr = next_arr_expr->Next; next_arr_expr = next_arr_expr->Next;
} }
} }
@ -1349,7 +1349,7 @@ void using_to_strbuilder_ns(CodeUsing self, StrBuilder* result )
} }
inline inline
StrBuilder var_to_string(CodeVar self) StrBuilder var_to_strbuilder(CodeVar self)
{ {
GEN_ASSERT(self); GEN_ASSERT(self);
StrBuilder result = strbuilder_make_reserve( GlobalAllocator, 256 ); StrBuilder result = strbuilder_make_reserve( GlobalAllocator, 256 );
@ -1367,18 +1367,18 @@ void var_to_strbuilder_ref(CodeVar self, StrBuilder* result )
// Its a comma-separated variable ( a NextVar ) // Its a comma-separated variable ( a NextVar )
if ( self->Specs ) if ( self->Specs )
strbuilder_append_fmt( result, "%SB ", specifiers_to_string(self->Specs) ); strbuilder_append_fmt( result, "%SB ", specifiers_to_strbuilder(self->Specs) );
strbuilder_append_str( result, self->Name ); strbuilder_append_str( result, self->Name );
if ( self->ValueType->ArrExpr ) if ( self->ValueType->ArrExpr )
{ {
strbuilder_append_fmt( result, "[ %SB ]", code_to_string(self->ValueType->ArrExpr) ); strbuilder_append_fmt( result, "[ %SB ]", code_to_strbuilder(self->ValueType->ArrExpr) );
Code next_arr_expr = self->ValueType->ArrExpr->Next; Code next_arr_expr = self->ValueType->ArrExpr->Next;
while ( next_arr_expr ) while ( next_arr_expr )
{ {
strbuilder_append_fmt( result, "[ %SB ]", code_to_string(next_arr_expr) ); strbuilder_append_fmt( result, "[ %SB ]", code_to_strbuilder(next_arr_expr) );
next_arr_expr = next_arr_expr->Next; next_arr_expr = next_arr_expr->Next;
} }
} }
@ -1386,14 +1386,14 @@ void var_to_strbuilder_ref(CodeVar self, StrBuilder* result )
if ( self->Value ) if ( self->Value )
{ {
if ( self->VarParenthesizedInit ) if ( self->VarParenthesizedInit )
strbuilder_append_fmt( result, "( %SB ", code_to_string(self->Value) ); strbuilder_append_fmt( result, "( %SB ", code_to_strbuilder(self->Value) );
else else
strbuilder_append_fmt( result, " = %SB", code_to_string(self->Value) ); strbuilder_append_fmt( result, " = %SB", code_to_strbuilder(self->Value) );
} }
// Keep the chain going... // Keep the chain going...
if ( self->NextVar ) if ( self->NextVar )
strbuilder_append_fmt( result, ", %SB", var_to_string(self->NextVar) ); strbuilder_append_fmt( result, ", %SB", var_to_strbuilder(self->NextVar) );
if ( self->VarParenthesizedInit ) if ( self->VarParenthesizedInit )
strbuilder_append_str( result, txt(" )")); strbuilder_append_str( result, txt(" )"));
@ -1407,38 +1407,38 @@ void var_to_strbuilder_ref(CodeVar self, StrBuilder* result )
if ( self->Attributes || self->Specs ) if ( self->Attributes || self->Specs )
{ {
if ( self->Attributes ) if ( self->Attributes )
strbuilder_append_fmt( result, "%SB ", specifiers_to_string(self->Specs) ); strbuilder_append_fmt( result, "%SB ", specifiers_to_strbuilder(self->Specs) );
if ( self->Specs ) if ( self->Specs )
strbuilder_append_fmt( result, "%SB\n", specifiers_to_string(self->Specs) ); strbuilder_append_fmt( result, "%SB\n", specifiers_to_strbuilder(self->Specs) );
strbuilder_append_fmt( result, "%SB %S", typename_to_string(self->ValueType), self->Name ); strbuilder_append_fmt( result, "%SB %S", typename_to_strbuilder(self->ValueType), self->Name );
if ( self->ValueType->ArrExpr ) if ( self->ValueType && self->ValueType->ArrExpr )
{ {
strbuilder_append_fmt( result, "[ %SB ]", code_to_string(self->ValueType->ArrExpr) ); strbuilder_append_fmt( result, "[ %SB ]", code_to_strbuilder(self->ValueType->ArrExpr) );
Code next_arr_expr = self->ValueType->ArrExpr->Next; Code next_arr_expr = self->ValueType->ArrExpr->Next;
while ( next_arr_expr ) while ( next_arr_expr )
{ {
strbuilder_append_fmt( result, "[ %SB ]", code_to_string(next_arr_expr) ); strbuilder_append_fmt( result, "[ %SB ]", code_to_strbuilder(next_arr_expr) );
next_arr_expr = next_arr_expr->Next; next_arr_expr = next_arr_expr->Next;
} }
} }
if ( self->BitfieldSize ) if ( self->BitfieldSize )
strbuilder_append_fmt( result, " : %SB", code_to_string(self->BitfieldSize) ); strbuilder_append_fmt( result, " : %SB", code_to_strbuilder(self->BitfieldSize) );
if ( self->Value ) if ( self->Value )
{ {
if ( self->VarParenthesizedInit ) if ( self->VarParenthesizedInit )
strbuilder_append_fmt( result, "( %SB ", code_to_string(self->Value) ); strbuilder_append_fmt( result, "( %SB ", code_to_strbuilder(self->Value) );
else else
strbuilder_append_fmt( result, " = %SB", code_to_string(self->Value) ); strbuilder_append_fmt( result, " = %SB", code_to_strbuilder(self->Value) );
} }
if ( self->NextVar ) if ( self->NextVar )
strbuilder_append_fmt( result, ", %SB", var_to_string(self->NextVar) ); strbuilder_append_fmt( result, ", %SB", var_to_strbuilder(self->NextVar) );
if ( self->VarParenthesizedInit ) if ( self->VarParenthesizedInit )
strbuilder_append_str( result, txt(" )")); strbuilder_append_str( result, txt(" )"));
@ -1452,33 +1452,33 @@ void var_to_strbuilder_ref(CodeVar self, StrBuilder* result )
} }
if ( self->BitfieldSize ) if ( self->BitfieldSize )
strbuilder_append_fmt( result, "%SB %S : %SB", typename_to_string(self->ValueType), self->Name, code_to_string(self->BitfieldSize) ); strbuilder_append_fmt( result, "%SB %S : %SB", typename_to_strbuilder(self->ValueType), self->Name, code_to_strbuilder(self->BitfieldSize) );
else if ( self->ValueType->ArrExpr ) else if ( self->ValueType->ArrExpr )
{ {
strbuilder_append_fmt( result, "%SB %S[ %SB ]", typename_to_string(self->ValueType), self->Name, code_to_string(self->ValueType->ArrExpr) ); strbuilder_append_fmt( result, "%SB %S[ %SB ]", typename_to_strbuilder(self->ValueType), self->Name, code_to_strbuilder(self->ValueType->ArrExpr) );
Code next_arr_expr = self->ValueType->ArrExpr->Next; Code next_arr_expr = self->ValueType->ArrExpr->Next;
while ( next_arr_expr ) while ( next_arr_expr )
{ {
strbuilder_append_fmt( result, "[ %SB ]", code_to_string(next_arr_expr) ); strbuilder_append_fmt( result, "[ %SB ]", code_to_strbuilder(next_arr_expr) );
next_arr_expr = next_arr_expr->Next; next_arr_expr = next_arr_expr->Next;
} }
} }
else else
strbuilder_append_fmt( result, "%SB %S", typename_to_string(self->ValueType), self->Name ); strbuilder_append_fmt( result, "%SB %S", typename_to_strbuilder(self->ValueType), self->Name );
if ( self->Value ) if ( self->Value )
{ {
if ( self->VarParenthesizedInit ) if ( self->VarParenthesizedInit )
strbuilder_append_fmt( result, "( %SB ", code_to_string(self->Value) ); strbuilder_append_fmt( result, "( %SB ", code_to_strbuilder(self->Value) );
else else
strbuilder_append_fmt( result, " = %SB", code_to_string(self->Value) ); strbuilder_append_fmt( result, " = %SB", code_to_strbuilder(self->Value) );
} }
if ( self->NextVar ) if ( self->NextVar )
strbuilder_append_fmt( result, ", %SB", var_to_string( self->NextVar) ); strbuilder_append_fmt( result, ", %SB", var_to_strbuilder( self->NextVar) );
if ( self->VarParenthesizedInit ) if ( self->VarParenthesizedInit )
strbuilder_append_str( result, txt(" )")); strbuilder_append_str( result, txt(" )"));

615
base/components/code_types.hpp
View File

File diff suppressed because it is too large Load Diff

46
base/components/gen/ast_inlines.hpp
View File

@ -64,7 +64,7 @@ inline AST_Attributes* CodeAttributes::operator->()
{ {
if ( ast == nullptr ) if ( ast == nullptr )
{ {
log_failure( "Attempt to dereference a nullptr!" ); log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr; return nullptr;
} }
return ast; return ast;
@ -95,7 +95,7 @@ inline AST_Comment* CodeComment::operator->()
{ {
if ( ast == nullptr ) if ( ast == nullptr )
{ {
log_failure( "Attempt to dereference a nullptr!" ); log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr; return nullptr;
} }
return ast; return ast;
@ -126,7 +126,7 @@ inline AST_Constructor* CodeConstructor::operator->()
{ {
if ( ast == nullptr ) if ( ast == nullptr )
{ {
log_failure( "Attempt to dereference a nullptr!" ); log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr; return nullptr;
} }
return ast; return ast;
@ -173,7 +173,7 @@ inline AST_Define* CodeDefine::operator->()
{ {
if ( ast == nullptr ) if ( ast == nullptr )
{ {
log_failure( "Attempt to dereference a nullptr!" ); log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr; return nullptr;
} }
return ast; return ast;
@ -204,7 +204,7 @@ inline AST_Destructor* CodeDestructor::operator->()
{ {
if ( ast == nullptr ) if ( ast == nullptr )
{ {
log_failure( "Attempt to dereference a nullptr!" ); log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr; return nullptr;
} }
return ast; return ast;
@ -235,7 +235,7 @@ inline AST_Enum* CodeEnum::operator->()
{ {
if ( ast == nullptr ) if ( ast == nullptr )
{ {
log_failure( "Attempt to dereference a nullptr!" ); log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr; return nullptr;
} }
return ast; return ast;
@ -266,7 +266,7 @@ inline AST_Exec* CodeExec::operator->()
{ {
if ( ast == nullptr ) if ( ast == nullptr )
{ {
log_failure( "Attempt to dereference a nullptr!" ); log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr; return nullptr;
} }
return ast; return ast;
@ -297,7 +297,7 @@ inline AST_Extern* CodeExtern::operator->()
{ {
if ( ast == nullptr ) if ( ast == nullptr )
{ {
log_failure( "Attempt to dereference a nullptr!" ); log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr; return nullptr;
} }
return ast; return ast;
@ -328,7 +328,7 @@ inline AST_Friend* CodeFriend::operator->()
{ {
if ( ast == nullptr ) if ( ast == nullptr )
{ {
log_failure( "Attempt to dereference a nullptr!" ); log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr; return nullptr;
} }
return ast; return ast;
@ -359,7 +359,7 @@ inline AST_Fn* CodeFn::operator->()
{ {
if ( ast == nullptr ) if ( ast == nullptr )
{ {
log_failure( "Attempt to dereference a nullptr!" ); log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr; return nullptr;
} }
return ast; return ast;
@ -390,7 +390,7 @@ inline AST_Include* CodeInclude::operator->()
{ {
if ( ast == nullptr ) if ( ast == nullptr )
{ {
log_failure( "Attempt to dereference a nullptr!" ); log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr; return nullptr;
} }
return ast; return ast;
@ -421,7 +421,7 @@ inline AST_Module* CodeModule::operator->()
{ {
if ( ast == nullptr ) if ( ast == nullptr )
{ {
log_failure( "Attempt to dereference a nullptr!" ); log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr; return nullptr;
} }
return ast; return ast;
@ -452,7 +452,7 @@ inline AST_NS* CodeNS::operator->()
{ {
if ( ast == nullptr ) if ( ast == nullptr )
{ {
log_failure( "Attempt to dereference a nullptr!" ); log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr; return nullptr;
} }
return ast; return ast;
@ -483,7 +483,7 @@ inline AST_Operator* CodeOperator::operator->()
{ {
if ( ast == nullptr ) if ( ast == nullptr )
{ {
log_failure( "Attempt to dereference a nullptr!" ); log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr; return nullptr;
} }
return ast; return ast;
@ -514,7 +514,7 @@ inline AST_OpCast* CodeOpCast::operator->()
{ {
if ( ast == nullptr ) if ( ast == nullptr )
{ {
log_failure( "Attempt to dereference a nullptr!" ); log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr; return nullptr;
} }
return ast; return ast;
@ -561,7 +561,7 @@ inline AST_Pragma* CodePragma::operator->()
{ {
if ( ast == nullptr ) if ( ast == nullptr )
{ {
log_failure( "Attempt to dereference a nullptr!" ); log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr; return nullptr;
} }
return ast; return ast;
@ -592,7 +592,7 @@ inline AST_PreprocessCond* CodePreprocessCond::operator->()
{ {
if ( ast == nullptr ) if ( ast == nullptr )
{ {
log_failure( "Attempt to dereference a nullptr!" ); log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr; return nullptr;
} }
return ast; return ast;
@ -655,7 +655,7 @@ inline AST_Template* CodeTemplate::operator->()
{ {
if ( ast == nullptr ) if ( ast == nullptr )
{ {
log_failure( "Attempt to dereference a nullptr!" ); log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr; return nullptr;
} }
return ast; return ast;
@ -686,7 +686,7 @@ inline AST_Typename* CodeTypename::operator->()
{ {
if ( ast == nullptr ) if ( ast == nullptr )
{ {
log_failure( "Attempt to dereference a nullptr!" ); log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr; return nullptr;
} }
return ast; return ast;
@ -717,7 +717,7 @@ inline AST_Typedef* CodeTypedef::operator->()
{ {
if ( ast == nullptr ) if ( ast == nullptr )
{ {
log_failure( "Attempt to dereference a nullptr!" ); log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr; return nullptr;
} }
return ast; return ast;
@ -748,7 +748,7 @@ inline AST_Union* CodeUnion::operator->()
{ {
if ( ast == nullptr ) if ( ast == nullptr )
{ {
log_failure( "Attempt to dereference a nullptr!" ); log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr; return nullptr;
} }
return ast; return ast;
@ -779,7 +779,7 @@ inline AST_Using* CodeUsing::operator->()
{ {
if ( ast == nullptr ) if ( ast == nullptr )
{ {
log_failure( "Attempt to dereference a nullptr!" ); log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr; return nullptr;
} }
return ast; return ast;
@ -810,7 +810,7 @@ inline AST_Var* CodeVar::operator->()
{ {
if ( ast == nullptr ) if ( ast == nullptr )
{ {
log_failure( "Attempt to dereference a nullptr!" ); log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr; return nullptr;
} }
return ast; return ast;

244
base/components/gen/ecodetypes.hpp
View File

@ -75,67 +75,67 @@ enum CodeType : u32
inline Str codetype_to_str( CodeType type ) inline Str codetype_to_str( CodeType type )
{ {
local_persist Str lookup[61] = { local_persist Str lookup[61] = {
{ sizeof( "Invalid" ), "Invalid" }, { "Invalid", sizeof( "Invalid" ) - 1 },
{ sizeof( "Untyped" ), "Untyped" }, { "Untyped", sizeof( "Untyped" ) - 1 },
{ sizeof( "NewLine" ), "NewLine" }, { "NewLine", sizeof( "NewLine" ) - 1 },
{ sizeof( "Comment" ), "Comment" }, { "Comment", sizeof( "Comment" ) - 1 },
{ sizeof( "Access_Private" ), "Access_Private" }, { "Access_Private", sizeof( "Access_Private" ) - 1 },
{ sizeof( "Access_Protected" ), "Access_Protected" }, { "Access_Protected", sizeof( "Access_Protected" ) - 1 },
{ sizeof( "Access_Public" ), "Access_Public" }, { "Access_Public", sizeof( "Access_Public" ) - 1 },
{ sizeof( "PlatformAttributes" ), "PlatformAttributes" }, { "PlatformAttributes", sizeof( "PlatformAttributes" ) - 1 },
{ sizeof( "Class" ), "Class" }, { "Class", sizeof( "Class" ) - 1 },
{ sizeof( "Class_Fwd" ), "Class_Fwd" }, { "Class_Fwd", sizeof( "Class_Fwd" ) - 1 },
{ sizeof( "Class_Body" ), "Class_Body" }, { "Class_Body", sizeof( "Class_Body" ) - 1 },
{ sizeof( "Constructor" ), "Constructor" }, { "Constructor", sizeof( "Constructor" ) - 1 },
{ sizeof( "Constructor_Fwd" ), "Constructor_Fwd" }, { "Constructor_Fwd", sizeof( "Constructor_Fwd" ) - 1 },
{ sizeof( "Destructor" ), "Destructor" }, { "Destructor", sizeof( "Destructor" ) - 1 },
{ sizeof( "Destructor_Fwd" ), "Destructor_Fwd" }, { "Destructor_Fwd", sizeof( "Destructor_Fwd" ) - 1 },
{ sizeof( "Enum" ), "Enum" }, { "Enum", sizeof( "Enum" ) - 1 },
{ sizeof( "Enum_Fwd" ), "Enum_Fwd" }, { "Enum_Fwd", sizeof( "Enum_Fwd" ) - 1 },
{ sizeof( "Enum_Body" ), "Enum_Body" }, { "Enum_Body", sizeof( "Enum_Body" ) - 1 },
{ sizeof( "Enum_Class" ), "Enum_Class" }, { "Enum_Class", sizeof( "Enum_Class" ) - 1 },
{ sizeof( "Enum_Class_Fwd" ), "Enum_Class_Fwd" }, { "Enum_Class_Fwd", sizeof( "Enum_Class_Fwd" ) - 1 },
{ sizeof( "Execution" ), "Execution" }, { "Execution", sizeof( "Execution" ) - 1 },
{ sizeof( "Export_Body" ), "Export_Body" }, { "Export_Body", sizeof( "Export_Body" ) - 1 },
{ sizeof( "Extern_Linkage" ), "Extern_Linkage" }, { "Extern_Linkage", sizeof( "Extern_Linkage" ) - 1 },
{ sizeof( "Extern_Linkage_Body" ), "Extern_Linkage_Body" }, { "Extern_Linkage_Body", sizeof( "Extern_Linkage_Body" ) - 1 },
{ sizeof( "Friend" ), "Friend" }, { "Friend", sizeof( "Friend" ) - 1 },
{ sizeof( "Function" ), "Function" }, { "Function", sizeof( "Function" ) - 1 },
{ sizeof( "Function_Fwd" ), "Function_Fwd" }, { "Function_Fwd", sizeof( "Function_Fwd" ) - 1 },
{ sizeof( "Function_Body" ), "Function_Body" }, { "Function_Body", sizeof( "Function_Body" ) - 1 },
{ sizeof( "Global_Body" ), "Global_Body" }, { "Global_Body", sizeof( "Global_Body" ) - 1 },
{ sizeof( "Module" ), "Module" }, { "Module", sizeof( "Module" ) - 1 },
{ sizeof( "Namespace" ), "Namespace" }, { "Namespace", sizeof( "Namespace" ) - 1 },
{ sizeof( "Namespace_Body" ), "Namespace_Body" }, { "Namespace_Body", sizeof( "Namespace_Body" ) - 1 },
{ sizeof( "Operator" ), "Operator" }, { "Operator", sizeof( "Operator" ) - 1 },
{ sizeof( "Operator_Fwd" ), "Operator_Fwd" }, { "Operator_Fwd", sizeof( "Operator_Fwd" ) - 1 },
{ sizeof( "Operator_Member" ), "Operator_Member" }, { "Operator_Member", sizeof( "Operator_Member" ) - 1 },
{ sizeof( "Operator_Member_Fwd" ), "Operator_Member_Fwd" }, { "Operator_Member_Fwd", sizeof( "Operator_Member_Fwd" ) - 1 },
{ sizeof( "Operator_Cast" ), "Operator_Cast" }, { "Operator_Cast", sizeof( "Operator_Cast" ) - 1 },
{ sizeof( "Operator_Cast_Fwd" ), "Operator_Cast_Fwd" }, { "Operator_Cast_Fwd", sizeof( "Operator_Cast_Fwd" ) - 1 },
{ sizeof( "Parameters" ), "Parameters" }, { "Parameters", sizeof( "Parameters" ) - 1 },
{ sizeof( "Preprocess_Define" ), "Preprocess_Define" }, { "Preprocess_Define", sizeof( "Preprocess_Define" ) - 1 },
{ sizeof( "Preprocess_Include" ), "Preprocess_Include" }, { "Preprocess_Include", sizeof( "Preprocess_Include" ) - 1 },
{ sizeof( "Preprocess_If" ), "Preprocess_If" }, { "Preprocess_If", sizeof( "Preprocess_If" ) - 1 },
{ sizeof( "Preprocess_IfDef" ), "Preprocess_IfDef" }, { "Preprocess_IfDef", sizeof( "Preprocess_IfDef" ) - 1 },
{ sizeof( "Preprocess_IfNotDef" ), "Preprocess_IfNotDef" }, { "Preprocess_IfNotDef", sizeof( "Preprocess_IfNotDef" ) - 1 },
{ sizeof( "Preprocess_ElIf" ), "Preprocess_ElIf" }, { "Preprocess_ElIf", sizeof( "Preprocess_ElIf" ) - 1 },
{ sizeof( "Preprocess_Else" ), "Preprocess_Else" }, { "Preprocess_Else", sizeof( "Preprocess_Else" ) - 1 },
{ sizeof( "Preprocess_EndIf" ), "Preprocess_EndIf" }, { "Preprocess_EndIf", sizeof( "Preprocess_EndIf" ) - 1 },
{ sizeof( "Preprocess_Pragma" ), "Preprocess_Pragma" }, { "Preprocess_Pragma", sizeof( "Preprocess_Pragma" ) - 1 },
{ sizeof( "Specifiers" ), "Specifiers" }, { "Specifiers", sizeof( "Specifiers" ) - 1 },
{ sizeof( "Struct" ), "Struct" }, { "Struct", sizeof( "Struct" ) - 1 },
{ sizeof( "Struct_Fwd" ), "Struct_Fwd" }, { "Struct_Fwd", sizeof( "Struct_Fwd" ) - 1 },
{ sizeof( "Struct_Body" ), "Struct_Body" }, { "Struct_Body", sizeof( "Struct_Body" ) - 1 },
{ sizeof( "Template" ), "Template" }, { "Template", sizeof( "Template" ) - 1 },
{ sizeof( "Typedef" ), "Typedef" }, { "Typedef", sizeof( "Typedef" ) - 1 },
{ sizeof( "Typename" ), "Typename" }, { "Typename", sizeof( "Typename" ) - 1 },
{ sizeof( "Union" ), "Union" }, { "Union", sizeof( "Union" ) - 1 },
{ sizeof( "Union_Fwd" ), "Union_Fwd" }, { "Union_Fwd", sizeof( "Union_Fwd" ) - 1 },
{ sizeof( "Union_Body" ), "Union_Body" }, { "Union_Body", sizeof( "Union_Body" ) - 1 },
{ sizeof( "Using" ), "Using" }, { "Using", sizeof( "Using" ) - 1 },
{ sizeof( "Using_Namespace" ), "Using_Namespace" }, { "Using_Namespace", sizeof( "Using_Namespace" ) - 1 },
{ sizeof( "Variable" ), "Variable" }, { "Variable", sizeof( "Variable" ) - 1 },
}; };
return lookup[type]; return lookup[type];
} }
@ -143,67 +143,67 @@ inline Str codetype_to_str( CodeType type )
inline Str codetype_to_keyword_str( CodeType type ) inline Str codetype_to_keyword_str( CodeType type )
{ {
local_persist Str lookup[61] = { local_persist Str lookup[61] = {
{ sizeof( "__NA__" ) - 1, "__NA__" }, { "__NA__", sizeof( "__NA__" ) - 1 },
{ sizeof( "__NA__" ) - 1, "__NA__" }, { "__NA__", sizeof( "__NA__" ) - 1 },
{ sizeof( "__NA__" ) - 1, "__NA__" }, { "__NA__", sizeof( "__NA__" ) - 1 },
{ sizeof( "//" ) - 1, "//" }, { "//", sizeof( "//" ) - 1 },
{ sizeof( "private" ) - 1, "private" }, { "private", sizeof( "private" ) - 1 },
{ sizeof( "protected" ) - 1, "protected" }, { "protected", sizeof( "protected" ) - 1 },
{ sizeof( "public" ) - 1, "public" }, { "public", sizeof( "public" ) - 1 },
{ sizeof( "__NA__" ) - 1, "__NA__" }, { "__NA__", sizeof( "__NA__" ) - 1 },
{ sizeof( "class" ) - 1, "class" }, { "class", sizeof( "class" ) - 1 },
{ sizeof( "clsss" ) - 1, "clsss" }, { "clsss", sizeof( "clsss" ) - 1 },
{ sizeof( "__NA__" ) - 1, "__NA__" }, { "__NA__", sizeof( "__NA__" ) - 1 },
{ sizeof( "__NA__" ) - 1, "__NA__" }, { "__NA__", sizeof( "__NA__" ) - 1 },
{ sizeof( "__NA__" ) - 1, "__NA__" }, { "__NA__", sizeof( "__NA__" ) - 1 },
{ sizeof( "__NA__" ) - 1, "__NA__" }, { "__NA__", sizeof( "__NA__" ) - 1 },
{ sizeof( "__NA__" ) - 1, "__NA__" }, { "__NA__", sizeof( "__NA__" ) - 1 },
{ sizeof( "enum" ) - 1, "enum" }, { "enum", sizeof( "enum" ) - 1 },
{ sizeof( "enum" ) - 1, "enum" }, { "enum", sizeof( "enum" ) - 1 },
{ sizeof( "__NA__" ) - 1, "__NA__" }, { "__NA__", sizeof( "__NA__" ) - 1 },
{ sizeof( "enum class" ) - 1, "enum class" }, { "enum class", sizeof( "enum class" ) - 1 },
{ sizeof( "enum class" ) - 1, "enum class" }, { "enum class", sizeof( "enum class" ) - 1 },
{ sizeof( "__NA__" ) - 1, "__NA__" }, { "__NA__", sizeof( "__NA__" ) - 1 },
{ sizeof( "__NA__" ) - 1, "__NA__" }, { "__NA__", sizeof( "__NA__" ) - 1 },
{ sizeof( "extern" ) - 1, "extern" }, { "extern", sizeof( "extern" ) - 1 },
{ sizeof( "extern" ) - 1, "extern" }, { "extern", sizeof( "extern" ) - 1 },
{ sizeof( "friend" ) - 1, "friend" }, { "friend", sizeof( "friend" ) - 1 },
{ sizeof( "__NA__" ) - 1, "__NA__" }, { "__NA__", sizeof( "__NA__" ) - 1 },
{ sizeof( "__NA__" ) - 1, "__NA__" }, { "__NA__", sizeof( "__NA__" ) - 1 },
{ sizeof( "__NA__" ) - 1, "__NA__" }, { "__NA__", sizeof( "__NA__" ) - 1 },
{ sizeof( "__NA__" ) - 1, "__NA__" }, { "__NA__", sizeof( "__NA__" ) - 1 },
{ sizeof( "module" ) - 1, "module" }, { "module", sizeof( "module" ) - 1 },
{ sizeof( "namespace" ) - 1, "namespace" }, { "namespace", sizeof( "namespace" ) - 1 },
{ sizeof( "__NA__" ) - 1, "__NA__" }, { "__NA__", sizeof( "__NA__" ) - 1 },
{ sizeof( "operator" ) - 1, "operator" }, { "operator", sizeof( "operator" ) - 1 },
{ sizeof( "operator" ) - 1, "operator" }, { "operator", sizeof( "operator" ) - 1 },
{ sizeof( "operator" ) - 1, "operator" }, { "operator", sizeof( "operator" ) - 1 },
{ sizeof( "operator" ) - 1, "operator" }, { "operator", sizeof( "operator" ) - 1 },
{ sizeof( "operator" ) - 1, "operator" }, { "operator", sizeof( "operator" ) - 1 },
{ sizeof( "operator" ) - 1, "operator" }, { "operator", sizeof( "operator" ) - 1 },
{ sizeof( "__NA__" ) - 1, "__NA__" }, { "__NA__", sizeof( "__NA__" ) - 1 },
{ sizeof( "define" ) - 1, "define" }, { "define", sizeof( "define" ) - 1 },
{ sizeof( "include" ) - 1, "include" }, { "include", sizeof( "include" ) - 1 },
{ sizeof( "if" ) - 1, "if" }, { "if", sizeof( "if" ) - 1 },
{ sizeof( "ifdef" ) - 1, "ifdef" }, { "ifdef", sizeof( "ifdef" ) - 1 },
{ sizeof( "ifndef" ) - 1, "ifndef" }, { "ifndef", sizeof( "ifndef" ) - 1 },
{ sizeof( "elif" ) - 1, "elif" }, { "elif", sizeof( "elif" ) - 1 },
{ sizeof( "else" ) - 1, "else" }, { "else", sizeof( "else" ) - 1 },
{ sizeof( "endif" ) - 1, "endif" }, { "endif", sizeof( "endif" ) - 1 },
{ sizeof( "pragma" ) - 1, "pragma" }, { "pragma", sizeof( "pragma" ) - 1 },
{ sizeof( "__NA__" ) - 1, "__NA__" }, { "__NA__", sizeof( "__NA__" ) - 1 },
{ sizeof( "struct" ) - 1, "struct" }, { "struct", sizeof( "struct" ) - 1 },
{ sizeof( "struct" ) - 1, "struct" }, { "struct", sizeof( "struct" ) - 1 },
{ sizeof( "__NA__" ) - 1, "__NA__" }, { "__NA__", sizeof( "__NA__" ) - 1 },
{ sizeof( "template" ) - 1, "template" }, { "template", sizeof( "template" ) - 1 },
{ sizeof( "typedef" ) - 1, "typedef" }, { "typedef", sizeof( "typedef" ) - 1 },
{ sizeof( "__NA__" ) - 1, "__NA__" }, { "__NA__", sizeof( "__NA__" ) - 1 },
{ sizeof( "union" ) - 1, "union" }, { "union", sizeof( "union" ) - 1 },
{ sizeof( "union" ) - 1, "union" }, { "union", sizeof( "union" ) - 1 },
{ sizeof( "__NA__" ) - 1, "__NA__" }, { "__NA__", sizeof( "__NA__" ) - 1 },
{ sizeof( "using" ) - 1, "using" }, { "using", sizeof( "using" ) - 1 },
{ sizeof( "using namespace" ) - 1, "using namespace" }, { "using namespace", sizeof( "using namespace" ) - 1 },
{ sizeof( "__NA__" ) - 1, "__NA__" }, { "__NA__", sizeof( "__NA__" ) - 1 },
}; };
return lookup[type]; return lookup[type];
} }

94
base/components/gen/eoperator.hpp
View File

@ -61,53 +61,53 @@ enum Operator : u32
inline Str operator_to_str( Operator op ) inline Str operator_to_str( Operator op )
{ {
local_persist Str lookup[47] = { local_persist Str lookup[47] = {
{ sizeof( "INVALID" ), "INVALID" }, { "INVALID", sizeof( "INVALID" ) - 1 },
{ sizeof( "=" ), "=" }, { "=", sizeof( "=" ) - 1 },
{ sizeof( "+=" ), "+=" }, { "+=", sizeof( "+=" ) - 1 },
{ sizeof( "-=" ), "-=" }, { "-=", sizeof( "-=" ) - 1 },
{ sizeof( "*=" ), "*=" }, { "*=", sizeof( "*=" ) - 1 },
{ sizeof( "/=" ), "/=" }, { "/=", sizeof( "/=" ) - 1 },
{ sizeof( "%=" ), "%=" }, { "%=", sizeof( "%=" ) - 1 },
{ sizeof( "&=" ), "&=" }, { "&=", sizeof( "&=" ) - 1 },
{ sizeof( "|=" ), "|=" }, { "|=", sizeof( "|=" ) - 1 },
{ sizeof( "^=" ), "^=" }, { "^=", sizeof( "^=" ) - 1 },
{ sizeof( "<<=" ), "<<=" }, { "<<=", sizeof( "<<=" ) - 1 },
{ sizeof( ">>=" ), ">>=" }, { ">>=", sizeof( ">>=" ) - 1 },
{ sizeof( "++" ), "++" }, { "++", sizeof( "++" ) - 1 },
{ sizeof( "--" ), "--" }, { "--", sizeof( "--" ) - 1 },
{ sizeof( "+" ), "+" }, { "+", sizeof( "+" ) - 1 },
{ sizeof( "-" ), "-" }, { "-", sizeof( "-" ) - 1 },
{ sizeof( "!" ), "!" }, { "!", sizeof( "!" ) - 1 },
{ sizeof( "+" ), "+" }, { "+", sizeof( "+" ) - 1 },
{ sizeof( "-" ), "-" }, { "-", sizeof( "-" ) - 1 },
{ sizeof( "*" ), "*" }, { "*", sizeof( "*" ) - 1 },
{ sizeof( "/" ), "/" }, { "/", sizeof( "/" ) - 1 },
{ sizeof( "%" ), "%" }, { "%", sizeof( "%" ) - 1 },
{ sizeof( "~" ), "~" }, { "~", sizeof( "~" ) - 1 },
{ sizeof( "&" ), "&" }, { "&", sizeof( "&" ) - 1 },
{ sizeof( "|" ), "|" }, { "|", sizeof( "|" ) - 1 },
{ sizeof( "^" ), "^" }, { "^", sizeof( "^" ) - 1 },
{ sizeof( "<<" ), "<<" }, { "<<", sizeof( "<<" ) - 1 },
{ sizeof( ">>" ), ">>" }, { ">>", sizeof( ">>" ) - 1 },
{ sizeof( "&&" ), "&&" }, { "&&", sizeof( "&&" ) - 1 },
{ sizeof( "||" ), "||" }, { "||", sizeof( "||" ) - 1 },
{ sizeof( "==" ), "==" }, { "==", sizeof( "==" ) - 1 },
{ sizeof( "!=" ), "!=" }, { "!=", sizeof( "!=" ) - 1 },
{ sizeof( "<" ), "<" }, { "<", sizeof( "<" ) - 1 },
{ sizeof( ">" ), ">" }, { ">", sizeof( ">" ) - 1 },
{ sizeof( "<=" ), "<=" }, { "<=", sizeof( "<=" ) - 1 },
{ sizeof( ">=" ), ">=" }, { ">=", sizeof( ">=" ) - 1 },
{ sizeof( "[]" ), "[]" }, { "[]", sizeof( "[]" ) - 1 },
{ sizeof( "*" ), "*" }, { "*", sizeof( "*" ) - 1 },
{ sizeof( "&" ), "&" }, { "&", sizeof( "&" ) - 1 },
{ sizeof( "->" ), "->" }, { "->", sizeof( "->" ) - 1 },
{ sizeof( "->*" ), "->*" }, { "->*", sizeof( "->*" ) - 1 },
{ sizeof( "()" ), "()" }, { "()", sizeof( "()" ) - 1 },
{ sizeof( "," ), "," }, { ",", sizeof( "," ) - 1 },
{ sizeof( "new" ), "new" }, { "new", sizeof( "new" ) - 1 },
{ sizeof( "new[]" ), "new[]" }, { "new[]", sizeof( "new[]" ) - 1 },
{ sizeof( "delete" ), "delete" }, { "delete", sizeof( "delete" ) - 1 },
{ sizeof( "delete[]" ), "delete[]" }, { "delete[]", sizeof( "delete[]" ) - 1 },
}; };
return lookup[op]; return lookup[op];
} }

54
base/components/gen/especifier.hpp
View File

@ -40,32 +40,32 @@ enum Specifier : u32
inline Str spec_to_str( Specifier type ) inline Str spec_to_str( Specifier type )
{ {
local_persist Str lookup[26] = { local_persist Str lookup[26] = {
{ sizeof( "INVALID" ), "INVALID" }, { "INVALID", sizeof( "INVALID" ) - 1 },
{ sizeof( "consteval" ), "consteval" }, { "consteval", sizeof( "consteval" ) - 1 },
{ sizeof( "constexpr" ), "constexpr" }, { "constexpr", sizeof( "constexpr" ) - 1 },
{ sizeof( "constinit" ), "constinit" }, { "constinit", sizeof( "constinit" ) - 1 },
{ sizeof( "explicit" ), "explicit" }, { "explicit", sizeof( "explicit" ) - 1 },
{ sizeof( "extern" ), "extern" }, { "extern", sizeof( "extern" ) - 1 },
{ sizeof( "forceinline" ), "forceinline" }, { "forceinline", sizeof( "forceinline" ) - 1 },
{ sizeof( "global" ), "global" }, { "global", sizeof( "global" ) - 1 },
{ sizeof( "inline" ), "inline" }, { "inline", sizeof( "inline" ) - 1 },
{ sizeof( "internal" ), "internal" }, { "internal", sizeof( "internal" ) - 1 },
{ sizeof( "local_persist" ), "local_persist" }, { "local_persist", sizeof( "local_persist" ) - 1 },
{ sizeof( "mutable" ), "mutable" }, { "mutable", sizeof( "mutable" ) - 1 },
{ sizeof( "neverinline" ), "neverinline" }, { "neverinline", sizeof( "neverinline" ) - 1 },
{ sizeof( "*" ), "*" }, { "*", sizeof( "*" ) - 1 },
{ sizeof( "&" ), "&" }, { "&", sizeof( "&" ) - 1 },
{ sizeof( "register" ), "register" }, { "register", sizeof( "register" ) - 1 },
{ sizeof( "&&" ), "&&" }, { "&&", sizeof( "&&" ) - 1 },
{ sizeof( "static" ), "static" }, { "static", sizeof( "static" ) - 1 },
{ sizeof( "thread_local" ), "thread_local" }, { "thread_local", sizeof( "thread_local" ) - 1 },
{ sizeof( "virtual" ), "virtual" }, { "virtual", sizeof( "virtual" ) - 1 },
{ sizeof( "const" ), "const" }, { "const", sizeof( "const" ) - 1 },
{ sizeof( "final" ), "final" }, { "final", sizeof( "final" ) - 1 },
{ sizeof( "noexcept" ), "noexcept" }, { "noexcept", sizeof( "noexcept" ) - 1 },
{ sizeof( "override" ), "override" }, { "override", sizeof( "override" ) - 1 },
{ sizeof( "= 0" ), "= 0" }, { "= 0", sizeof( "= 0" ) - 1 },
{ sizeof( "volatile" ), "volatile" }, { "volatile", sizeof( "volatile" ) - 1 },
}; };
return lookup[type]; return lookup[type];
} }
@ -81,7 +81,7 @@ inline Specifier str_to_specifier( Str str )
do_once_start for ( u32 index = 0; index < Spec_NumSpecifiers; index++ ) do_once_start for ( u32 index = 0; index < Spec_NumSpecifiers; index++ )
{ {
Str enum_str = spec_to_str( (Specifier)index ); Str enum_str = spec_to_str( (Specifier)index );
keymap[index] = crc32( enum_str.Ptr, enum_str.Len - 1 ); keymap[index] = crc32( enum_str.Ptr, enum_str.Len );
} }
do_once_end u32 hash = crc32( str.Ptr, str.Len ); do_once_end u32 hash = crc32( str.Ptr, str.Len );
for ( u32 index = 0; index < Spec_NumSpecifiers; index++ ) for ( u32 index = 0; index < Spec_NumSpecifiers; index++ )

198
base/components/gen/etoktype.cpp
View File

@ -114,103 +114,103 @@ enum TokType : u32
inline Str toktype_to_str( TokType type ) inline Str toktype_to_str( TokType type )
{ {
local_persist Str lookup[] = { local_persist Str lookup[] = {
{ sizeof( "__invalid__" ), "__invalid__" }, { "__invalid__", sizeof( "__invalid__" ) - 1 },
{ sizeof( "private" ), "private" }, { "private", sizeof( "private" ) - 1 },
{ sizeof( "protected" ), "protected" }, { "protected", sizeof( "protected" ) - 1 },
{ sizeof( "public" ), "public" }, { "public", sizeof( "public" ) - 1 },
{ sizeof( "." ), "." }, { ".", sizeof( "." ) - 1 },
{ sizeof( "::" ), "::" }, { "::", sizeof( "::" ) - 1 },
{ sizeof( "&" ), "&" }, { "&", sizeof( "&" ) - 1 },
{ sizeof( "&&" ), "&&" }, { "&&", sizeof( "&&" ) - 1 },
{ sizeof( ":" ), ":" }, { ":", sizeof( ":" ) - 1 },
{ sizeof( "[[" ), "[[" }, { "[[", sizeof( "[[" ) - 1 },
{ sizeof( "]]" ), "]]" }, { "]]", sizeof( "]]" ) - 1 },
{ sizeof( "{" ), "{" }, { "{", sizeof( "{" ) - 1 },
{ sizeof( "}" ), "}" }, { "}", sizeof( "}" ) - 1 },
{ sizeof( "[" ), "[" }, { "[", sizeof( "[" ) - 1 },
{ sizeof( "]" ), "]" }, { "]", sizeof( "]" ) - 1 },
{ sizeof( "(" ), "(" }, { "(", sizeof( "(" ) - 1 },
{ sizeof( ")" ), ")" }, { ")", sizeof( ")" ) - 1 },
{ sizeof( "__comment__" ), "__comment__" }, { "__comment__", sizeof( "__comment__" ) - 1 },
{ sizeof( "__comment_end__" ), "__comment_end__" }, { "__comment_end__", sizeof( "__comment_end__" ) - 1 },
{ sizeof( "__comment_start__" ), "__comment_start__" }, { "__comment_start__", sizeof( "__comment_start__" ) - 1 },
{ sizeof( "__character__" ), "__character__" }, { "__character__", sizeof( "__character__" ) - 1 },
{ sizeof( "," ), "," }, { ",", sizeof( "," ) - 1 },
{ sizeof( "class" ), "class" }, { "class", sizeof( "class" ) - 1 },
{ sizeof( "__attribute__" ), "__attribute__" }, { "__attribute__", sizeof( "__attribute__" ) - 1 },
{ sizeof( "__declspec" ), "__declspec" }, { "__declspec", sizeof( "__declspec" ) - 1 },
{ sizeof( "enum" ), "enum" }, { "enum", sizeof( "enum" ) - 1 },
{ sizeof( "extern" ), "extern" }, { "extern", sizeof( "extern" ) - 1 },
{ sizeof( "friend" ), "friend" }, { "friend", sizeof( "friend" ) - 1 },
{ sizeof( "module" ), "module" }, { "module", sizeof( "module" ) - 1 },
{ sizeof( "namespace" ), "namespace" }, { "namespace", sizeof( "namespace" ) - 1 },
{ sizeof( "operator" ), "operator" }, { "operator", sizeof( "operator" ) - 1 },
{ sizeof( "struct" ), "struct" }, { "struct", sizeof( "struct" ) - 1 },
{ sizeof( "template" ), "template" }, { "template", sizeof( "template" ) - 1 },
{ sizeof( "typedef" ), "typedef" }, { "typedef", sizeof( "typedef" ) - 1 },
{ sizeof( "using" ), "using" }, { "using", sizeof( "using" ) - 1 },
{ sizeof( "union" ), "union" }, { "union", sizeof( "union" ) - 1 },
{ sizeof( "__identifier__" ), "__identifier__" }, { "__identifier__", sizeof( "__identifier__" ) - 1 },
{ sizeof( "import" ), "import" }, { "import", sizeof( "import" ) - 1 },
{ sizeof( "export" ), "export" }, { "export", sizeof( "export" ) - 1 },
{ sizeof( "__new_line__" ), "__new_line__" }, { "__new_line__", sizeof( "__new_line__" ) - 1 },
{ sizeof( "__number__" ), "__number__" }, { "__number__", sizeof( "__number__" ) - 1 },
{ sizeof( "__operator__" ), "__operator__" }, { "__operator__", sizeof( "__operator__" ) - 1 },
{ sizeof( "#" ), "#" }, { "#", sizeof( "#" ) - 1 },
{ sizeof( "define" ), "define" }, { "define", sizeof( "define" ) - 1 },
{ sizeof( "if" ), "if" }, { "if", sizeof( "if" ) - 1 },
{ sizeof( "ifdef" ), "ifdef" }, { "ifdef", sizeof( "ifdef" ) - 1 },
{ sizeof( "ifndef" ), "ifndef" }, { "ifndef", sizeof( "ifndef" ) - 1 },
{ sizeof( "elif" ), "elif" }, { "elif", sizeof( "elif" ) - 1 },
{ sizeof( "else" ), "else" }, { "else", sizeof( "else" ) - 1 },
{ sizeof( "endif" ), "endif" }, { "endif", sizeof( "endif" ) - 1 },
{ sizeof( "include" ), "include" }, { "include", sizeof( "include" ) - 1 },
{ sizeof( "pragma" ), "pragma" }, { "pragma", sizeof( "pragma" ) - 1 },
{ sizeof( "__macro_content__" ), "__macro_content__" }, { "__macro_content__", sizeof( "__macro_content__" ) - 1 },
{ sizeof( "__macro__" ), "__macro__" }, { "__macro__", sizeof( "__macro__" ) - 1 },
{ sizeof( "__unsupported__" ), "__unsupported__" }, { "__unsupported__", sizeof( "__unsupported__" ) - 1 },
{ sizeof( "alignas" ), "alignas" }, { "alignas", sizeof( "alignas" ) - 1 },
{ sizeof( "const" ), "const" }, { "const", sizeof( "const" ) - 1 },
{ sizeof( "consteval" ), "consteval" }, { "consteval", sizeof( "consteval" ) - 1 },
{ sizeof( "constexpr" ), "constexpr" }, { "constexpr", sizeof( "constexpr" ) - 1 },
{ sizeof( "constinit" ), "constinit" }, { "constinit", sizeof( "constinit" ) - 1 },
{ sizeof( "explicit" ), "explicit" }, { "explicit", sizeof( "explicit" ) - 1 },
{ sizeof( "extern" ), "extern" }, { "extern", sizeof( "extern" ) - 1 },
{ sizeof( "final" ), "final" }, { "final", sizeof( "final" ) - 1 },
{ sizeof( "forceinline" ), "forceinline" }, { "forceinline", sizeof( "forceinline" ) - 1 },
{ sizeof( "global" ), "global" }, { "global", sizeof( "global" ) - 1 },
{ sizeof( "inline" ), "inline" }, { "inline", sizeof( "inline" ) - 1 },
{ sizeof( "internal" ), "internal" }, { "internal", sizeof( "internal" ) - 1 },
{ sizeof( "local_persist" ), "local_persist" }, { "local_persist", sizeof( "local_persist" ) - 1 },
{ sizeof( "mutable" ), "mutable" }, { "mutable", sizeof( "mutable" ) - 1 },
{ sizeof( "neverinline" ), "neverinline" }, { "neverinline", sizeof( "neverinline" ) - 1 },
{ sizeof( "override" ), "override" }, { "override", sizeof( "override" ) - 1 },
{ sizeof( "static" ), "static" }, { "static", sizeof( "static" ) - 1 },
{ sizeof( "thread_local" ), "thread_local" }, { "thread_local", sizeof( "thread_local" ) - 1 },
{ sizeof( "volatile" ), "volatile" }, { "volatile", sizeof( "volatile" ) - 1 },
{ sizeof( "virtual" ), "virtual" }, { "virtual", sizeof( "virtual" ) - 1 },
{ sizeof( "*" ), "*" }, { "*", sizeof( "*" ) - 1 },
{ sizeof( ";" ), ";" }, { ";", sizeof( ";" ) - 1 },
{ sizeof( "static_assert" ), "static_assert" }, { "static_assert", sizeof( "static_assert" ) - 1 },
{ sizeof( "__strbuilder__" ), "__strbuilder__" }, { "__string__", sizeof( "__string__" ) - 1 },
{ sizeof( "typename" ), "typename" }, { "typename", sizeof( "typename" ) - 1 },
{ sizeof( "unsigned" ), "unsigned" }, { "unsigned", sizeof( "unsigned" ) - 1 },
{ sizeof( "signed" ), "signed" }, { "signed", sizeof( "signed" ) - 1 },
{ sizeof( "short" ), "short" }, { "short", sizeof( "short" ) - 1 },
{ sizeof( "long" ), "long" }, { "long", sizeof( "long" ) - 1 },
{ sizeof( "bool" ), "bool" }, { "bool", sizeof( "bool" ) - 1 },
{ sizeof( "char" ), "char" }, { "char", sizeof( "char" ) - 1 },
{ sizeof( "int" ), "int" }, { "int", sizeof( "int" ) - 1 },
{ sizeof( "double" ), "double" }, { "double", sizeof( "double" ) - 1 },
{ sizeof( "__int8" ), "__int8" }, { "__int8", sizeof( "__int8" ) - 1 },
{ sizeof( "__int16" ), "__int16" }, { "__int16", sizeof( "__int16" ) - 1 },
{ sizeof( "__int32" ), "__int32" }, { "__int32", sizeof( "__int32" ) - 1 },
{ sizeof( "__int64" ), "__int64" }, { "__int64", sizeof( "__int64" ) - 1 },
{ sizeof( "_W64" ), "_W64" }, { "_W64", sizeof( "_W64" ) - 1 },
{ sizeof( "..." ), "..." }, { "...", sizeof( "..." ) - 1 },
{ sizeof( "__attrib_start__" ), "__attrib_start__" }, { "__attrib_start__", sizeof( "__attrib_start__" ) - 1 },
{ sizeof( "GEN_API_Export_Code" ), "GEN_API_Export_Code" }, { "GEN_API_Export_Code", sizeof( "GEN_API_Export_Code" ) - 1 },
{ sizeof( "GEN_API_Import_Code" ), "GEN_API_Import_Code" }, { "GEN_API_Import_Code", sizeof( "GEN_API_Import_Code" ) - 1 },
}; };
return lookup[type]; return lookup[type];
} }
@ -220,8 +220,8 @@ inline TokType str_to_toktype( Str str )
local_persist u32 keymap[Tok_NumTokens]; local_persist u32 keymap[Tok_NumTokens];
do_once_start for ( u32 index = 0; index < Tok_NumTokens; index++ ) do_once_start for ( u32 index = 0; index < Tok_NumTokens; index++ )
{ {
Str enum_str = toktype_to_str( (TokType)index ); Str enum_str = toktype_to_str( (TokType)index );
keymap[index] = crc32( enum_str.Ptr, enum_str.Len - 1 ); keymap[index] = crc32( enum_str.Ptr, enum_str.Len );
} }
do_once_end u32 hash = crc32( str.Ptr, str.Len ); do_once_end u32 hash = crc32( str.Ptr, str.Len );
for ( u32 index = 0; index < Tok_NumTokens; index++ ) for ( u32 index = 0; index < Tok_NumTokens; index++ )

2
base/components/inlines.hpp
View File

@ -408,7 +408,7 @@ Str token_fmt_impl( ssize num, ... )
ssize result = token_fmt_va(buf, GEN_PRINTF_MAXLEN, num, va); ssize result = token_fmt_va(buf, GEN_PRINTF_MAXLEN, num, va);
va_end(va); va_end(va);
Str str = { result, buf }; Str str = { buf, result };
return str; return str;
} }
#pragma endregion Interface #pragma endregion Interface

4
base/components/interface.hpp
View File

@ -289,12 +289,12 @@ Code untyped_token_fmt( s32 num_tokens, char const* fmt, ... );
#ifndef name #ifndef name
// Convienence for defining any name used with the gen api. // Convienence for defining any name used with the gen api.
// Lets you provide the length and string literal to the functions without the need for the DSL. // Lets you provide the length and string literal to the functions without the need for the DSL.
#define name( Id_ ) { sizeof(stringize( Id_ )) - 1, stringize(Id_) } #define name( Id_ ) { stringize(Id_), sizeof(stringize( Id_ )) - 1 }
#endif #endif
#ifndef code #ifndef code
// Same as name just used to indicate intention of literal for code instead of names. // Same as name just used to indicate intention of literal for code instead of names.
#define code( ... ) { sizeof(stringize(__VA_ARGS__)) - 1, stringize( __VA_ARGS__ ) } #define code( ... ) { stringize( __VA_ARGS__ ), sizeof(stringize(__VA_ARGS__)) - 1 }
#endif #endif
#ifndef args #ifndef args

2
base/components/interface.parsing.cpp
View File

@ -59,7 +59,7 @@ CodeConstructor parse_constructor( Str def )
break; break;
default : default :
log_failure( "Invalid specifier %s for variable\n%s", spec_to_str( spec ), parser_to_string(Context) ); log_failure( "Invalid specifier %s for variable\n%S", spec_to_str( spec ), parser_to_strbuilder(Context) );
parser_pop(& Context); parser_pop(& Context);
return InvalidCode; return InvalidCode;
} }

6
base/components/interface.untyped.cpp
View File

@ -138,8 +138,8 @@ Code untyped_fmt( char const* fmt, ...)
ssize length = c_str_fmt_va(buf, GEN_PRINTF_MAXLEN, fmt, va); ssize length = c_str_fmt_va(buf, GEN_PRINTF_MAXLEN, fmt, va);
va_end(va); va_end(va);
Str buf_str = { c_str_len_capped(fmt, MaxNameLength), fmt }; Str buf_str = { fmt, c_str_len_capped(fmt, MaxNameLength) };
Str uncapped_str = { length, buf }; Str uncapped_str = { buf, length };
Code Code
result = make_code(); result = make_code();
@ -172,7 +172,7 @@ Code untyped_token_fmt( s32 num_tokens, char const* fmt, ... )
ssize length = token_fmt_va(buf, GEN_PRINTF_MAXLEN, num_tokens, va); ssize length = token_fmt_va(buf, GEN_PRINTF_MAXLEN, num_tokens, va);
va_end(va); va_end(va);
Str buf_str = { length, buf }; Str buf_str = { buf, length };
Code Code
result = make_code(); result = make_code();

6
base/components/interface.upfront.cpp
View File

@ -461,7 +461,7 @@ CodeComment def_comment( Str content )
if ( * strbuilder_back(cmt_formatted) != '\n' ) if ( * strbuilder_back(cmt_formatted) != '\n' )
strbuilder_append_str( & cmt_formatted, txt("\n") ); strbuilder_append_str( & cmt_formatted, txt("\n") );
Str name = { strbuilder_length(cmt_formatted), cmt_formatted }; Str name = strbuilder_to_str(cmt_formatted);
Code Code
result = make_code(); result = make_code();
@ -589,7 +589,7 @@ CodeDefine def_define( Str name, Str content, Opts_def_define p )
if ( result->Name.Ptr[lex_id_len] == '(' ) if ( result->Name.Ptr[lex_id_len] == '(' )
break; break;
} }
Str lex_id = { lex_id_len, result->Name.Ptr }; Str lex_id = { result->Name.Ptr, lex_id_len };
array_append(PreprocessorDefines, lex_id ); array_append(PreprocessorDefines, lex_id );
} }
return result; return result;
@ -895,7 +895,7 @@ CodeOperator def_operator( Operator op, Str nspace, Opts_def_operator p )
else else
name = c_str_fmt_buf( "operator %.*s", op_str.Len, op_str.Ptr ); name = c_str_fmt_buf( "operator %.*s", op_str.Len, op_str.Ptr );
Str name_resolved = { c_str_len(name), name }; Str name_resolved = { name, c_str_len(name) };
CodeOperator CodeOperator
result = (CodeOperator) make_code(); result = (CodeOperator) make_code();

8
base/components/lexer.cpp
View File

@ -43,7 +43,7 @@ AccessSpec tok_to_access_specifier(Token tok)
Str tok_to_str(Token tok) Str tok_to_str(Token tok)
{ {
Str str = { tok.Length, tok.Text }; Str str = { tok.Text, tok.Length };
return str; return str;
} }
@ -92,7 +92,7 @@ bool tok_is_end_definition(Token tok)
return bitfield_is_equal( u32, tok.Flags, TF_EndDefinition ); return bitfield_is_equal( u32, tok.Flags, TF_EndDefinition );
} }
StrBuilder tok_to_string(Token tok) StrBuilder tok_to_strbuilder(Token tok)
{ {
StrBuilder result = strbuilder_make_reserve( GlobalAllocator, kilobytes(4) ); StrBuilder result = strbuilder_make_reserve( GlobalAllocator, kilobytes(4) );
@ -183,7 +183,7 @@ enum
struct LexContext struct LexContext
{ {
Str content; Str content;
s32 left; s32 left;
char const* scanner; char const* scanner;
s32 line; s32 line;
@ -620,7 +620,7 @@ TokArray lex( Str content )
#if 0 #if 0
if (Tokens.num()) if (Tokens.num())
{ {
log_fmt("\nLastTok: %SB", Tokens.back().to_string()); log_fmt("\nLastTok: %SB", Tokens.back().to_strbuilder());
} }
#endif #endif

168
base/components/parser.cpp
View File

@ -45,7 +45,7 @@ void parser_pop(ParseContext* ctx)
ctx->Scope = ctx->Scope->Prev; ctx->Scope = ctx->Scope->Prev;
} }
StrBuilder parser_to_string(ParseContext ctx) StrBuilder parser_to_strbuilder(ParseContext ctx)
{ {
StrBuilder result = strbuilder_make_reserve( GlobalAllocator, kilobytes(4) ); StrBuilder result = strbuilder_make_reserve( GlobalAllocator, kilobytes(4) );
@ -60,7 +60,7 @@ StrBuilder parser_to_string(ParseContext ctx)
length++; length++;
} }
Str scope_str = { length, scope_start.Text }; Str scope_str = { scope_start.Text, length };
StrBuilder line = strbuilder_make_str( GlobalAllocator, scope_str ); StrBuilder line = strbuilder_make_str( GlobalAllocator, scope_str );
strbuilder_append_fmt( & result, "\tScope : %s\n", line ); strbuilder_append_fmt( & result, "\tScope : %s\n", line );
strbuilder_free(& line); strbuilder_free(& line);
@ -68,7 +68,7 @@ StrBuilder parser_to_string(ParseContext ctx)
sptr dist = (sptr)last_valid.Text - (sptr)scope_start.Text + 2; sptr dist = (sptr)last_valid.Text - (sptr)scope_start.Text + 2;
sptr length_from_err = dist; sptr length_from_err = dist;
Str err_str = { length_from_err, last_valid.Text }; Str err_str = { last_valid.Text, length_from_err };
StrBuilder line_from_err = strbuilder_make_str( GlobalAllocator, err_str ); StrBuilder line_from_err = strbuilder_make_str( GlobalAllocator, err_str );
if ( length_from_err < 100 ) if ( length_from_err < 100 )
@ -102,7 +102,7 @@ bool lex__eat(TokArray* self, TokType type )
{ {
if ( array_num(self->Arr) - self->Idx <= 0 ) if ( array_num(self->Arr) - self->Idx <= 0 )
{ {
log_failure( "No tokens left.\n%s", parser_to_string(Context) ); log_failure( "No tokens left.\n%s", parser_to_strbuilder(Context) );
return false; return false;
} }
@ -122,14 +122,14 @@ bool lex__eat(TokArray* self, TokType type )
, at_idx.Length, at_idx.Text , at_idx.Length, at_idx.Text
, tok.Line , tok.Line
, tok.Column , tok.Column
, parser_to_string(Context) , parser_to_strbuilder(Context)
); );
GEN_DEBUG_TRAP();
return false; return false;
} }
#if 0 && GEN_BUILD_DEBUG #if 0 && GEN_BUILD_DEBUG
log_fmt("Ate: %SB\n", self->Arr[Idx].to_string() ); log_fmt("Ate: %SB\n", self->Arr[Idx].to_strbuilder() );
#endif #endif
self->Idx ++; self->Idx ++;
@ -515,7 +515,7 @@ Code parse_array_decl()
if ( check( Tok_Operator ) && currtok.Text[0] == '[' && currtok.Text[1] == ']' ) if ( check( Tok_Operator ) && currtok.Text[0] == '[' && currtok.Text[1] == ']' )
{ {
Code array_expr = untyped_str( tok_to_str(currtok) ); Code array_expr = untyped_str( txt(" ") );
eat( Tok_Operator ); eat( Tok_Operator );
// [] // []
@ -530,14 +530,14 @@ Code parse_array_decl()
if ( left == 0 ) if ( left == 0 )
{ {
log_failure( "Error, unexpected end of array declaration ( '[]' scope started )\n%s", parser_to_string(Context) ); log_failure( "Error, unexpected end of array declaration ( '[]' scope started )\n%s", parser_to_strbuilder(Context) );
parser_pop(& Context); parser_pop(& Context);
return InvalidCode; return InvalidCode;
} }
if ( currtok.Type == Tok_BraceSquare_Close ) if ( currtok.Type == Tok_BraceSquare_Close )
{ {
log_failure( "Error, empty array expression in definition\n%s", parser_to_string(Context) ); log_failure( "Error, empty array expression in definition\n%s", parser_to_strbuilder(Context) );
parser_pop(& Context); parser_pop(& Context);
return InvalidCode; return InvalidCode;
} }
@ -556,14 +556,14 @@ Code parse_array_decl()
if ( left == 0 ) if ( left == 0 )
{ {
log_failure( "Error, unexpected end of array declaration, expected ]\n%s", parser_to_string(Context) ); log_failure( "Error, unexpected end of array declaration, expected ]\n%s", parser_to_strbuilder(Context) );
parser_pop(& Context); parser_pop(& Context);
return InvalidCode; return InvalidCode;
} }
if ( currtok.Type != Tok_BraceSquare_Close ) if ( currtok.Type != Tok_BraceSquare_Close )
{ {
log_failure( "%s: Error, expected ] in array declaration, not %s\n%s", toktype_to_str( currtok.Type ), parser_to_string(Context) ); log_failure( "%s: Error, expected ] in array declaration, not %s\n%s", toktype_to_str( currtok.Type ), parser_to_strbuilder(Context) );
parser_pop(& Context); parser_pop(& Context);
return InvalidCode; return InvalidCode;
} }
@ -681,7 +681,7 @@ CodeAttributes parse_attributes()
if ( len > 0 ) if ( len > 0 )
{ {
Str attribute_txt = { len, start.Text }; Str attribute_txt = { start.Text, len };
parser_pop(& Context); parser_pop(& Context);
StrBuilder name_stripped = parser_strip_formatting( attribute_txt, parser_strip_formatting_dont_preserve_newlines ); StrBuilder name_stripped = parser_strip_formatting( attribute_txt, parser_strip_formatting_dont_preserve_newlines );
@ -704,7 +704,7 @@ Code parse_class_struct( TokType which, bool inplace_def )
{ {
if ( which != Tok_Decl_Class && which != Tok_Decl_Struct ) if ( which != Tok_Decl_Class && which != Tok_Decl_Struct )
{ {
log_failure( "Error, expected class or struct, not %s\n%s", toktype_to_str( which ), parser_to_string(Context) ); log_failure( "Error, expected class or struct, not %s\n%s", toktype_to_str( which ), parser_to_strbuilder(Context) );
return InvalidCode; return InvalidCode;
} }
@ -846,7 +846,7 @@ CodeBody parse_class_struct_body( TokType which, Token name )
case Tok_Statement_End: case Tok_Statement_End:
{ {
// TODO(Ed): Convert this to a general warning procedure // TODO(Ed): Convert this to a general warning procedure
log_fmt("Dangling end statement found %SB\n", tok_to_string(currtok_noskip)); log_fmt("Dangling end statement found %SB\n", tok_to_strbuilder(currtok_noskip));
eat( Tok_Statement_End ); eat( Tok_Statement_End );
continue; continue;
} }
@ -928,7 +928,7 @@ CodeBody parse_class_struct_body( TokType which, Token name )
case Tok_Operator: case Tok_Operator:
//if ( currtok.Text[0] != '~' ) //if ( currtok.Text[0] != '~' )
//{ //{
// log_failure( "Operator token found in global body but not destructor unary negation\n%s", to_string(Context) ); // log_failure( "Operator token found in global body but not destructor unary negation\n%s", to_strbuilder(Context) );
// return InvalidCode; // return InvalidCode;
//} //}
@ -1042,7 +1042,7 @@ CodeBody parse_class_struct_body( TokType which, Token name )
break; break;
default: default:
log_failure( "Invalid specifier %s for variable\n%s", spec_to_str(spec), parser_to_string(Context) ); log_failure( "Invalid specifier %S for variable\n%S", spec_to_str(spec), strbuilder_to_str( parser_to_strbuilder(Context)) );
parser_pop(& Context); parser_pop(& Context);
return InvalidCode; return InvalidCode;
} }
@ -1072,7 +1072,7 @@ CodeBody parse_class_struct_body( TokType which, Token name )
StrBuilder fused = strbuilder_make_reserve( GlobalAllocator, attributes->Content.Len + more_attributes->Content.Len ); StrBuilder fused = strbuilder_make_reserve( GlobalAllocator, attributes->Content.Len + more_attributes->Content.Len );
strbuilder_append_fmt( & fused, "%SB %SB", attributes->Content, more_attributes->Content ); strbuilder_append_fmt( & fused, "%SB %SB", attributes->Content, more_attributes->Content );
Str attrib_name = { strbuilder_length(fused), fused }; Str attrib_name = strbuilder_to_str(fused);
attributes->Name = get_cached_string( attrib_name ); attributes->Name = get_cached_string( attrib_name );
attributes->Content = attributes->Name; attributes->Content = attributes->Name;
// <Attributes> <Specifiers> <Attributes> // <Attributes> <Specifiers> <Attributes>
@ -1128,7 +1128,7 @@ CodeBody parse_class_struct_body( TokType which, Token name )
if ( member == Code_Invalid ) if ( member == Code_Invalid )
{ {
log_failure( "Failed to parse member\n%s", parser_to_string(Context) ); log_failure( "Failed to parse member\n%s", parser_to_strbuilder(Context) );
parser_pop(& Context); parser_pop(& Context);
return InvalidCode; return InvalidCode;
} }
@ -1162,7 +1162,7 @@ CodeBody parse_class_struct_body( TokType which, Token name )
if ( member == Code_Invalid ) if ( member == Code_Invalid )
{ {
log_failure( "Failed to parse member\n%s", parser_to_string(Context) ); log_failure( "Failed to parse member\n%s", parser_to_strbuilder(Context) );
parser_pop(& Context); parser_pop(& Context);
return InvalidCode; return InvalidCode;
} }
@ -1249,7 +1249,7 @@ Code parse_complicated_definition( TokType which )
return result; return result;
} }
log_failure( "Unsupported or bad member definition after %s declaration\n%s", toktype_to_str(which), parser_to_string(Context) ); log_failure( "Unsupported or bad member definition after %s declaration\n%s", toktype_to_str(which), parser_to_strbuilder(Context) );
parser_pop(& Context); parser_pop(& Context);
return InvalidCode; return InvalidCode;
} }
@ -1294,7 +1294,7 @@ Code parse_complicated_definition( TokType which )
if ( ! ok_to_parse ) if ( ! ok_to_parse )
{ {
log_failure( "Unsupported or bad member definition after %s declaration\n%s", toktype_to_str(which), parser_to_string(Context) ); log_failure( "Unsupported or bad member definition after %s declaration\n%s", toktype_to_str(which), parser_to_strbuilder(Context) );
parser_pop(& Context); parser_pop(& Context);
return InvalidCode; return InvalidCode;
} }
@ -1313,7 +1313,7 @@ Code parse_complicated_definition( TokType which )
&& ( tokens.Arr[idx - 4].Type != which)) && ( tokens.Arr[idx - 4].Type != which))
) )
{ {
log_failure( "Unsupported or bad member definition after %s declaration\n%s", toktype_to_str(which), parser_to_string(Context) ); log_failure( "Unsupported or bad member definition after %s declaration\n%s", toktype_to_str(which), parser_to_strbuilder(Context) );
parser_pop(& Context); parser_pop(& Context);
return InvalidCode; return InvalidCode;
} }
@ -1343,7 +1343,7 @@ Code parse_complicated_definition( TokType which )
} }
else else
{ {
log_failure( "Unsupported or bad member definition after %s declaration\n%SB", toktype_to_str(which).Ptr, parser_to_string(Context) ); log_failure( "Unsupported or bad member definition after %s declaration\n%SB", toktype_to_str(which).Ptr, parser_to_strbuilder(Context) );
parser_pop(& Context); parser_pop(& Context);
return InvalidCode; return InvalidCode;
} }
@ -1362,7 +1362,7 @@ CodeDefine parse_define()
if ( ! check( Tok_Identifier ) ) if ( ! check( Tok_Identifier ) )
{ {
log_failure( "Error, expected identifier after #define\n%s", parser_to_string(Context) ); log_failure( "Error, expected identifier after #define\n%s", parser_to_strbuilder(Context) );
parser_pop(& Context); parser_pop(& Context);
return InvalidCode; return InvalidCode;
} }
@ -1374,7 +1374,7 @@ CodeDefine parse_define()
if ( ! check( Tok_Preprocess_Content )) if ( ! check( Tok_Preprocess_Content ))
{ {
log_failure( "Error, expected content after #define %s\n%s", define->Name, parser_to_string(Context) ); log_failure( "Error, expected content after #define %s\n%s", define->Name, parser_to_strbuilder(Context) );
parser_pop(& Context); parser_pop(& Context);
return InvalidCode; return InvalidCode;
} }
@ -1409,7 +1409,7 @@ Code parse_assignment_expression()
if ( currtok.Type == Tok_Statement_End && currtok.Type != Tok_Comma ) if ( currtok.Type == Tok_Statement_End && currtok.Type != Tok_Comma )
{ {
log_failure( "Expected expression after assignment operator\n%s", parser_to_string(Context) ); log_failure( "Expected expression after assignment operator\n%s", parser_to_strbuilder(Context) );
parser_pop(& Context); parser_pop(& Context);
return InvalidCode; return InvalidCode;
} }
@ -1461,7 +1461,7 @@ Code parse_forward_or_definition( TokType which, bool is_inplace )
default: default:
log_failure( "Error, wrong token type given to parse_complicated_definition " log_failure( "Error, wrong token type given to parse_complicated_definition "
"(only supports class, enum, struct, union) \n%s" "(only supports class, enum, struct, union) \n%s"
, parser_to_string(Context) ); , parser_to_strbuilder(Context) );
return InvalidCode; return InvalidCode;
} }
@ -1552,7 +1552,7 @@ CodeFn parse_function_after_name(
default: default:
{ {
log_failure("Body must be either of Function_Body or Untyped type, %s\n%s", code_debug_str(body), parser_to_string(Context)); log_failure("Body must be either of Function_Body or Untyped type, %s\n%s", code_debug_str(body), parser_to_strbuilder(Context));
parser_pop(& Context); parser_pop(& Context);
return InvalidCode; return InvalidCode;
} }
@ -1616,7 +1616,7 @@ Code parse_function_body()
if ( len > 0 ) if ( len > 0 )
{ {
Str str = { len, start.Text }; Str str = { start.Text, len };
body_append( result, cast(Code, def_execution( str )) ); body_append( result, cast(Code, def_execution( str )) );
} }
@ -1661,7 +1661,7 @@ CodeBody parse_global_nspace( CodeType which )
{ {
case Tok_Comma: case Tok_Comma:
{ {
log_failure("Dangling comma found: %SB\nContext:\n%SB", tok_to_string(currtok), parser_to_string(Context)); log_failure("Dangling comma found: %SB\nContext:\n%SB", tok_to_strbuilder(currtok), parser_to_strbuilder(Context));
parser_pop( & Context); parser_pop( & Context);
return InvalidCode; return InvalidCode;
} }
@ -1669,7 +1669,7 @@ CodeBody parse_global_nspace( CodeType which )
case Tok_Statement_End: case Tok_Statement_End:
{ {
// TODO(Ed): Convert this to a general warning procedure // TODO(Ed): Convert this to a general warning procedure
log_fmt("Dangling end statement found %SB\n", tok_to_string(currtok_noskip)); log_fmt("Dangling end statement found %SB\n", tok_to_strbuilder(currtok_noskip));
eat( Tok_Statement_End ); eat( Tok_Statement_End );
continue; continue;
} }
@ -1695,7 +1695,7 @@ CodeBody parse_global_nspace( CodeType which )
case Tok_Decl_Extern_Linkage: case Tok_Decl_Extern_Linkage:
if ( which == CT_Extern_Linkage_Body ) if ( which == CT_Extern_Linkage_Body )
log_failure( "Nested extern linkage\n%s", parser_to_string(Context) ); log_failure( "Nested extern linkage\n%s", parser_to_strbuilder(Context) );
member = cast(Code, parser_parse_extern_link()); member = cast(Code, parser_parse_extern_link());
// extern "..." { ... } // extern "..." { ... }
@ -1788,7 +1788,7 @@ CodeBody parse_global_nspace( CodeType which )
case Tok_Module_Export: { case Tok_Module_Export: {
if ( which == CT_Export_Body ) if ( which == CT_Export_Body )
log_failure( "Nested export declaration\n%s", parser_to_string(Context) ); log_failure( "Nested export declaration\n%s", parser_to_strbuilder(Context) );
member = cast(Code, parser_parse_export_body()); member = cast(Code, parser_parse_export_body());
// export { ... } // export { ... }
@ -1858,7 +1858,7 @@ CodeBody parse_global_nspace( CodeType which )
default: default:
Str spec_str = spec_to_str(spec); Str spec_str = spec_to_str(spec);
log_failure( "Invalid specifier %.*s for variable\n%s", spec_str.Len, spec_str, parser_to_string(Context) ); log_failure( "Invalid specifier %S for variable\n%S", spec_str, strbuilder_to_str( parser_to_strbuilder(Context)) );
parser_pop(& Context); parser_pop(& Context);
return InvalidCode; return InvalidCode;
} }
@ -1941,7 +1941,7 @@ CodeBody parse_global_nspace( CodeType which )
if ( member == Code_Invalid ) if ( member == Code_Invalid )
{ {
log_failure( "Failed to parse member\n%s", parser_to_string(Context) ); log_failure( "Failed to parse member\n%s", parser_to_strbuilder(Context) );
parser_pop(& Context); parser_pop(& Context);
return InvalidCode; return InvalidCode;
} }
@ -1960,7 +1960,7 @@ CodeBody parse_global_nspace( CodeType which )
Member_Resolved_To_Lone_Macro: Member_Resolved_To_Lone_Macro:
if ( member == Code_Invalid ) if ( member == Code_Invalid )
{ {
log_failure( "Failed to parse member\nToken: %SB\nContext:\n%SB", tok_to_string(currtok_noskip), parser_to_string(Context) ); log_failure( "Failed to parse member\nToken: %SB\nContext:\n%SB", tok_to_strbuilder(currtok_noskip), parser_to_strbuilder(Context) );
parser_pop(& Context); parser_pop(& Context);
return InvalidCode; return InvalidCode;
} }
@ -2129,7 +2129,7 @@ Token parse_identifier( bool* possible_member_function )
Token invalid = { nullptr, 0, Tok_Invalid }; Token invalid = { nullptr, 0, Tok_Invalid };
if ( left == 0 ) if ( left == 0 )
{ {
log_failure( "Error, unexpected end of static symbol identifier\n%s", parser_to_string(Context) ); log_failure( "Error, unexpected end of static symbol identifier\n%s", parser_to_strbuilder(Context) );
parser_pop(& Context); parser_pop(& Context);
return invalid; return invalid;
} }
@ -2144,7 +2144,7 @@ Token parse_identifier( bool* possible_member_function )
return name; return name;
} }
log_failure( "Error, had a ~ operator after %SB but not a destructor\n%s", toktype_to_str( prevtok.Type ), parser_to_string(Context) ); log_failure( "Error, had a ~ operator after %SB but not a destructor\n%s", toktype_to_str( prevtok.Type ), parser_to_strbuilder(Context) );
parser_pop(& Context); parser_pop(& Context);
return invalid; return invalid;
} }
@ -2156,7 +2156,7 @@ Token parse_identifier( bool* possible_member_function )
else else
{ {
log_failure( "Found a member function pointer identifier but the parsing context did not expect it\n%s", parser_to_string(Context) ); log_failure( "Found a member function pointer identifier but the parsing context did not expect it\n%s", parser_to_strbuilder(Context) );
parser_pop(& Context); parser_pop(& Context);
return invalid; return invalid;
} }
@ -2164,7 +2164,7 @@ Token parse_identifier( bool* possible_member_function )
if ( currtok.Type != Tok_Identifier ) if ( currtok.Type != Tok_Identifier )
{ {
log_failure( "Error, expected static symbol identifier, not %s\n%s", toktype_to_str( currtok.Type ), parser_to_string(Context) ); log_failure( "Error, expected static symbol identifier, not %s\n%s", toktype_to_str( currtok.Type ), parser_to_strbuilder(Context) );
parser_pop(& Context); parser_pop(& Context);
return invalid; return invalid;
} }
@ -2195,7 +2195,7 @@ CodeInclude parse_include()
if ( ! check( Tok_String )) if ( ! check( Tok_String ))
{ {
log_failure( "Error, expected include string after #include\n%s", parser_to_string(Context) ); log_failure( "Error, expected include string after #include\n%s", parser_to_strbuilder(Context) );
parser_pop(& Context); parser_pop(& Context);
return InvalidCode; return InvalidCode;
} }
@ -2243,7 +2243,7 @@ CodeOperator parse_operator_after_ret_type(
&& currtok.Type != Tok_Ampersand && currtok.Type != Tok_Ampersand
&& currtok.Type != Tok_Ampersand_DBL ) && currtok.Type != Tok_Ampersand_DBL )
{ {
log_failure( "Expected operator after 'operator' keyword\n%s", parser_to_string(Context) ); log_failure( "Expected operator after 'operator' keyword\n%s", parser_to_strbuilder(Context) );
parser_pop(& Context); parser_pop(& Context);
return InvalidCode; return InvalidCode;
} }
@ -2391,7 +2391,7 @@ CodeOperator parse_operator_after_ret_type(
case '<': case '<':
{ {
if ( currtok.Text[1] == '=' ) if ( currtok.Text[1] == '=' )
op = Op_LEqual; op = Op_LesserEqual;
else if ( currtok.Text[1] == '<' ) else if ( currtok.Text[1] == '<' )
{ {
@ -2496,7 +2496,7 @@ CodeOperator parse_operator_after_ret_type(
{ {
if ( op == Op_Invalid ) if ( op == Op_Invalid )
{ {
log_failure( "Invalid operator '%s'\n%s", prevtok.Text, parser_to_string(Context) ); log_failure( "Invalid operator '%s'\n%s", prevtok.Text, parser_to_strbuilder(Context) );
parser_pop(& Context); parser_pop(& Context);
return InvalidCode; return InvalidCode;
} }
@ -2506,7 +2506,7 @@ CodeOperator parse_operator_after_ret_type(
if ( op == Op_Invalid ) if ( op == Op_Invalid )
{ {
log_failure( "Invalid operator '%s'\n%s", currtok.Text, parser_to_string(Context) ); log_failure( "Invalid operator '%s'\n%s", currtok.Text, parser_to_strbuilder(Context) );
parser_pop(& Context); parser_pop(& Context);
return InvalidCode; return InvalidCode;
} }
@ -2650,7 +2650,7 @@ Code parse_operator_function_or_variable( bool expects_function, CodeAttributes
{ {
if ( expects_function ) if ( expects_function )
{ {
log_failure( "Expected function declaration (consteval was used)\n%s", parser_to_string(Context) ); log_failure( "Expected function declaration (consteval was used)\n%s", parser_to_strbuilder(Context) );
parser_pop(& Context); parser_pop(& Context);
return InvalidCode; return InvalidCode;
} }
@ -2678,7 +2678,7 @@ CodePragma parse_pragma()
if ( ! check( Tok_Preprocess_Content )) if ( ! check( Tok_Preprocess_Content ))
{ {
log_failure( "Error, expected content after #pragma\n%s", parser_to_string(Context) ); log_failure( "Error, expected content after #pragma\n%s", parser_to_strbuilder(Context) );
parser_pop(& Context); parser_pop(& Context);
return InvalidCode; return InvalidCode;
} }
@ -2791,7 +2791,7 @@ CodeParams parse_params( bool use_template_capture )
if ( currtok.Type == Tok_Comma ) if ( currtok.Type == Tok_Comma )
{ {
log_failure( "Expected value after assignment operator\n%s.", parser_to_string(Context) ); log_failure( "Expected value after assignment operator\n%s.", parser_to_strbuilder(Context) );
parser_pop(& Context); parser_pop(& Context);
return InvalidCode; return InvalidCode;
} }
@ -2904,7 +2904,7 @@ CodeParams parse_params( bool use_template_capture )
if ( currtok.Type == Tok_Comma ) if ( currtok.Type == Tok_Comma )
{ {
log_failure( "Expected value after assignment operator\n%s", parser_to_string(Context) ); log_failure( "Expected value after assignment operator\n%s", parser_to_strbuilder(Context) );
parser_pop(& Context); parser_pop(& Context);
return InvalidCode; return InvalidCode;
} }
@ -2965,7 +2965,7 @@ CodeParams parse_params( bool use_template_capture )
{ {
if ( ! check( Tok_Operator ) || currtok.Text[ 0 ] != '>' ) if ( ! check( Tok_Operator ) || currtok.Text[ 0 ] != '>' )
{ {
log_failure( "Expected '<' after 'template' keyword\n%s", parser_to_string(Context) ); log_failure( "Expected '<' after 'template' keyword\n%s", parser_to_strbuilder(Context) );
parser_pop(& Context); parser_pop(& Context);
return InvalidCode; return InvalidCode;
} }
@ -2985,7 +2985,7 @@ CodePreprocessCond parse_preprocess_cond()
if ( ! tok_is_preprocess_cond(currtok) ) if ( ! tok_is_preprocess_cond(currtok) )
{ {
log_failure( "Error, expected preprocess conditional\n%s", parser_to_string(Context) ); log_failure( "Error, expected preprocess conditional\n%s", parser_to_strbuilder(Context) );
parser_pop(& Context); parser_pop(& Context);
return InvalidCode; return InvalidCode;
} }
@ -2998,7 +2998,7 @@ CodePreprocessCond parse_preprocess_cond()
if ( ! check( Tok_Preprocess_Content )) if ( ! check( Tok_Preprocess_Content ))
{ {
log_failure( "Error, expected content after #define\n%s", parser_to_string(Context) ); log_failure( "Error, expected content after #define\n%s", parser_to_strbuilder(Context) );
parser_pop(& Context); parser_pop(& Context);
return InvalidCode; return InvalidCode;
} }
@ -3157,7 +3157,7 @@ Code parse_static_assert()
content.Length = ( (sptr)prevtok.Text + prevtok.Length ) - (sptr)content.Text; content.Length = ( (sptr)prevtok.Text + prevtok.Length ) - (sptr)content.Text;
char const* str = c_str_fmt_buf( "%.*s\n", content.Length, content.Text ); char const* str = c_str_fmt_buf( "%.*s\n", content.Length, content.Text );
Str content_str = { content.Length + 1, str }; Str content_str = { str, content.Length + 1 };
assert->Content = get_cached_string( content_str ); assert->Content = get_cached_string( content_str );
assert->Name = assert->Content; assert->Name = assert->Content;
@ -3289,7 +3289,7 @@ CodeVar parse_variable_after_name(
if ( currtok.Type == Tok_Statement_End ) if ( currtok.Type == Tok_Statement_End )
{ {
log_failure( "Expected expression after bitfield \n%SB", parser_to_string(Context) ); log_failure( "Expected expression after bitfield \n%SB", parser_to_strbuilder(Context) );
parser_pop(& Context); parser_pop(& Context);
return InvalidCode; return InvalidCode;
} }
@ -3407,7 +3407,7 @@ CodeVar parse_variable_declaration_list()
{ {
log_failure( "Error, const specifier must come after pointer specifier for variable declaration proceeding comma\n" log_failure( "Error, const specifier must come after pointer specifier for variable declaration proceeding comma\n"
"(Parser will add and continue to specifiers, but will most likely fail to compile)\n%SB" "(Parser will add and continue to specifiers, but will most likely fail to compile)\n%SB"
, parser_to_string(Context) ); , parser_to_strbuilder(Context) );
specifiers_append(specifiers, spec ); specifiers_append(specifiers, spec );
} }
@ -3420,20 +3420,20 @@ CodeVar parse_variable_declaration_list()
default: default:
{ {
log_failure( "Error, invalid specifier '%s' proceeding comma\n" log_failure( "Error, invalid specifier '%S' proceeding comma\n"
"(Parser will add and continue to specifiers, but will most likely fail to compile)\n%S" "(Parser will add and continue to specifiers, but will most likely fail to compile)\n%S"
, tok_to_str(currtok), parser_to_string(Context) ); , tok_to_str(currtok), strbuilder_to_str( parser_to_strbuilder(Context)) );
continue; continue;
} }
break; break;
} }
// eat(currtok.Type);
if ( specifiers ) if ( specifiers )
specifiers_append(specifiers, spec ); specifiers_append(specifiers, spec );
else else
specifiers = def_specifier( spec ); specifiers = def_specifier( spec );
eat(currtok.Type);
} }
// , <Specifiers> // , <Specifiers>
@ -3586,7 +3586,7 @@ CodeDestructor parser_parse_destructor( CodeSpecifiers specifiers )
eat( Tok_Operator ); eat( Tok_Operator );
else else
{ {
log_failure( "Expected destructor '~' token\n%s", parser_to_string(Context) ); log_failure( "Expected destructor '~' token\n%s", parser_to_strbuilder(Context) );
parser_pop( & Context); parser_pop( & Context);
return InvalidCode; return InvalidCode;
} }
@ -3624,7 +3624,7 @@ CodeDestructor parser_parse_destructor( CodeSpecifiers specifiers )
} }
else else
{ {
log_failure( "Pure or default specifier expected due to '=' token\n%s", parser_to_string(Context) ); log_failure( "Pure or default specifier expected due to '=' token\n%s", parser_to_strbuilder(Context) );
parser_pop( & Context); parser_pop( & Context);
return InvalidCode; return InvalidCode;
} }
@ -3722,7 +3722,7 @@ CodeEnum parser_parse_enum( bool inplace_def )
type = parser_parse_type(parser_not_from_template, nullptr); type = parser_parse_type(parser_not_from_template, nullptr);
if ( cast(Code, type) == Code_Invalid ) if ( cast(Code, type) == Code_Invalid )
{ {
log_failure( "Failed to parse enum classifier\n%s", parser_to_string(Context) ); log_failure( "Failed to parse enum classifier\n%s", parser_to_strbuilder(Context) );
parser_pop(& Context); parser_pop(& Context);
return InvalidCode; return InvalidCode;
} }
@ -3755,7 +3755,7 @@ CodeEnum parser_parse_enum( bool inplace_def )
{ {
if ( ! expects_entry ) if ( ! expects_entry )
{ {
log_failure( "Did not expect an entry after last member of enum body.\n%s", parser_to_string(Context) ); log_failure( "Did not expect an entry after last member of enum body.\n%s", parser_to_strbuilder(Context) );
parser_pop(& Context); parser_pop(& Context);
break; break;
} }
@ -3862,7 +3862,7 @@ CodeEnum parser_parse_enum( bool inplace_def )
if ( member == Code_Invalid ) if ( member == Code_Invalid )
{ {
log_failure( "Failed to parse member\n%s", parser_to_string(Context) ); log_failure( "Failed to parse member\n%s", parser_to_strbuilder(Context) );
parser_pop(& Context); parser_pop(& Context);
return InvalidCode; return InvalidCode;
} }
@ -3957,7 +3957,7 @@ CodeExtern parser_parse_extern_link()
CodeBody entry = parser_parse_extern_link_body(); CodeBody entry = parser_parse_extern_link_body();
if ( cast(Code, entry) == Code_Invalid ) if ( cast(Code, entry) == Code_Invalid )
{ {
log_failure( "Failed to parse body\n%s", parser_to_string(Context) ); log_failure( "Failed to parse body\n%s", parser_to_strbuilder(Context) );
parser_pop(& Context); parser_pop(& Context);
return result; return result;
} }
@ -3998,7 +3998,7 @@ CodeFriend parser_parse_friend()
break; break;
default : default :
log_failure( "Invalid specifier %s for friend definition\n%s", spec_to_str( spec ), parser_to_string(Context) ); log_failure( "Invalid specifier %S for friend definition\n%S", spec_to_str( spec ), strbuilder_to_str( parser_to_strbuilder(Context)) );
parser_pop(& Context); parser_pop(& Context);
return InvalidCode; return InvalidCode;
} }
@ -4127,7 +4127,7 @@ CodeFn parser_parse_function()
break; break;
default: default:
log_failure( "Invalid specifier %s for functon\n%s", spec_to_str(spec), parser_to_string(Context) ); log_failure( "Invalid specifier %S for functon\n%SB", spec_to_str(spec), parser_to_strbuilder(Context) );
parser_pop(& Context); parser_pop(& Context);
return InvalidCode; return InvalidCode;
} }
@ -4238,7 +4238,7 @@ CodeOperator parser_parse_operator()
break; break;
default: default:
log_failure( "Invalid specifier " "%S" " for operator\n%SB", spec_to_str(spec), parser_to_string(Context) ); log_failure( "Invalid specifier " "%S" " for operator\n%SB", spec_to_str(spec), parser_to_strbuilder(Context) );
parser_pop(& Context); parser_pop(& Context);
return InvalidCode; return InvalidCode;
} }
@ -4490,7 +4490,7 @@ CodeTemplate parser_parse_template()
break; break;
default : default :
log_failure( "Invalid specifier %s for variable or function\n%s", spec_to_str( spec ), parser_to_string(Context) ); log_failure( "Invalid specifier %S for variable or function\n%SB", spec_to_str( spec ), parser_to_strbuilder(Context) );
parser_pop(& Context); parser_pop(& Context);
return InvalidCode; return InvalidCode;
} }
@ -4614,7 +4614,7 @@ CodeTypename parser_parse_type( bool from_template, bool* typedef_is_function )
if ( spec != Spec_Const ) if ( spec != Spec_Const )
{ {
log_failure( "Error, invalid specifier used in type definition: %S\n%SB", tok_to_str(currtok), parser_to_string(Context) ); log_failure( "Error, invalid specifier used in type definition: %S\n%SB", tok_to_str(currtok), parser_to_strbuilder(Context) );
parser_pop(& Context); parser_pop(& Context);
return InvalidCode; return InvalidCode;
} }
@ -4627,7 +4627,7 @@ CodeTypename parser_parse_type( bool from_template, bool* typedef_is_function )
if ( left == 0 ) if ( left == 0 )
{ {
log_failure( "Error, unexpected end of type definition\n%SB", parser_to_string(Context) ); log_failure( "Error, unexpected end of type definition\n%SB", parser_to_strbuilder(Context) );
parser_pop(& Context); parser_pop(& Context);
return InvalidCode; return InvalidCode;
} }
@ -4719,7 +4719,7 @@ else if ( currtok.Type == Tok_DeclType )
Context.Scope->Name = name; Context.Scope->Name = name;
if ( ! tok_is_valid(name) ) if ( ! tok_is_valid(name) )
{ {
log_failure( "Error, failed to type signature\n%s", parser_to_string(Context) ); log_failure( "Error, failed to type signature\n%s", parser_to_strbuilder(Context) );
parser_pop(& Context); parser_pop(& Context);
return InvalidCode; return InvalidCode;
} }
@ -4738,7 +4738,7 @@ else if ( currtok.Type == Tok_DeclType )
Context.Scope->Name = name; Context.Scope->Name = name;
if ( ! tok_is_valid(name) ) if ( ! tok_is_valid(name) )
{ {
log_failure( "Error, failed to type signature\n%s", parser_to_string(Context) ); log_failure( "Error, failed to type signature\n%s", parser_to_strbuilder(Context) );
parser_pop(& Context); parser_pop(& Context);
return InvalidCode; return InvalidCode;
} }
@ -4753,7 +4753,7 @@ else if ( currtok.Type == Tok_DeclType )
if ( spec != Spec_Const && spec != Spec_Ptr && spec != Spec_Ref && spec != Spec_RValue ) if ( spec != Spec_Const && spec != Spec_Ptr && spec != Spec_Ref && spec != Spec_RValue )
{ {
log_failure( "Error, invalid specifier used in type definition: %s\n%s", currtok.Text, parser_to_string(Context) ); log_failure( "Error, invalid specifier used in type definition: %S\n%SB", tok_to_str(currtok), parser_to_strbuilder(Context) );
parser_pop(& Context); parser_pop(& Context);
return InvalidCode; return InvalidCode;
} }
@ -4885,7 +4885,7 @@ else if ( currtok.Type == Tok_DeclType )
if ( spec != Spec_Ptr && spec != Spec_Ref && spec != Spec_RValue ) if ( spec != Spec_Ptr && spec != Spec_Ref && spec != Spec_RValue )
{ {
log_failure( "Error, invalid specifier used in type definition: %s\n%s", currtok.Text, to_string(Context) ); log_failure( "Error, invalid specifier used in type definition: %S\n%SB", toktype_to_str(currtok), to_strbuilder(Context) );
pop(& Context); pop(& Context);
return InvalidCode; return InvalidCode;
} }
@ -4955,7 +4955,7 @@ else if ( currtok.Type == Tok_DeclType )
// && spec != Spec_NoExcept // && spec != Spec_NoExcept
&& spec != Spec_RValue ) && spec != Spec_RValue )
{ {
log_failure( "Error, invalid specifier used in type definition: %S\n%SB", tok_to_str(currtok), parser_to_string(Context) ); log_failure( "Error, invalid specifier used in type definition: %S\n%S", tok_to_str(currtok), strbuilder_to_str( parser_to_strbuilder(Context)) );
parser_pop(& Context); parser_pop(& Context);
return InvalidCode; return InvalidCode;
} }
@ -4996,7 +4996,7 @@ else if ( currtok.Type == Tok_DeclType )
#ifdef GEN_USE_NEW_TYPENAME_PARSING #ifdef GEN_USE_NEW_TYPENAME_PARSING
if ( params_nested ) if ( params_nested )
{ {
name_stripped.append( params_nested->to_string() ); name_stripped.append( params_nested->to_strbuilder() );
} }
#endif #endif
@ -5082,7 +5082,7 @@ CodeTypedef parser_parse_typedef()
if ( currtok.Type == Tok_Identifier ) if ( currtok.Type == Tok_Identifier )
{ {
Str name_str = { name.Length, name.Text }; Str name_str = { name.Text, name.Length };
type = untyped_str(name_str); type = untyped_str(name_str);
name = currtok; name = currtok;
eat(Tok_Identifier); eat(Tok_Identifier);
@ -5161,7 +5161,7 @@ CodeTypedef parser_parse_typedef()
if ( ! ok_to_parse ) if ( ! ok_to_parse )
{ {
log_failure( "Unsupported or bad member definition after struct declaration\n%SB", parser_to_string(Context) ); log_failure( "Unsupported or bad member definition after struct declaration\n%SB", parser_to_strbuilder(Context) );
parser_pop(& Context); parser_pop(& Context);
return InvalidCode; return InvalidCode;
} }
@ -5187,7 +5187,7 @@ CodeTypedef parser_parse_typedef()
} }
else else
{ {
log_failure( "Unsupported or bad member definition after struct declaration\n%SB", parser_to_string(Context) ); log_failure( "Unsupported or bad member definition after struct declaration\n%SB", parser_to_strbuilder(Context) );
parser_pop(& Context); parser_pop(& Context);
return InvalidCode; return InvalidCode;
} }
@ -5208,7 +5208,7 @@ CodeTypedef parser_parse_typedef()
} }
else if ( ! is_function ) else if ( ! is_function )
{ {
log_failure( "Error, expected identifier for typedef\n%SB", parser_to_string(Context) ); log_failure( "Error, expected identifier for typedef\n%SB", parser_to_strbuilder(Context) );
parser_pop(& Context); parser_pop(& Context);
return InvalidCode; return InvalidCode;
} }
@ -5279,7 +5279,7 @@ CodeUnion parser_parse_union( bool inplace_def )
CodeAttributes attributes = parse_attributes(); CodeAttributes attributes = parse_attributes();
// <ModuleFlags> union <Attributes> // <ModuleFlags> union <Attributes>
Str name = { 0, nullptr }; Str name = { nullptr, 0 };
if ( check( Tok_Identifier ) ) if ( check( Tok_Identifier ) )
{ {
name = tok_to_str(currtok); name = tok_to_str(currtok);
@ -5544,7 +5544,7 @@ CodeVar parser_parse_variable()
break; break;
default: default:
log_failure( "Invalid specifier %s for variable\n%s", spec_to_str( spec ), parser_to_string(Context) ); log_failure( "Invalid specifier %S for variable\n%S", spec_to_str( spec ), strbuilder_to_str( parser_to_strbuilder(Context)) );
parser_pop(& Context); parser_pop(& Context);
return InvalidCode; return InvalidCode;
} }

18
base/components/types.hpp
View File

@ -48,13 +48,13 @@ Str access_spec_to_str( AccessSpec type )
{ {
local_persist local_persist
Str lookup[ (u32)AccessSpec_Num_AccessSpec ] = { Str lookup[ (u32)AccessSpec_Num_AccessSpec ] = {
{ sizeof("") - 1, "" }, { "", sizeof( "" ) - 1 },
{ sizeof("prviate") - 1, "private" }, { "private", sizeof("prviate") - 1 },
{ sizeof("protected") - 1, "private" }, { "private", sizeof("protected") - 1 },
{ sizeof("public") - 1, "public" }, { "public", sizeof("public") - 1 },
}; };
Str invalid = { sizeof("Invalid") - 1, "Invalid" }; Str invalid = { "Invalid", sizeof("Invalid") - 1 };
if ( type > AccessSpec_Public ) if ( type > AccessSpec_Public )
return invalid; return invalid;
@ -101,13 +101,13 @@ Str module_flag_to_str( ModuleFlag flag )
{ {
local_persist local_persist
Str lookup[ (u32)Num_ModuleFlags ] = { Str lookup[ (u32)Num_ModuleFlags ] = {
{ sizeof("__none__"), "__none__" }, { "__none__", sizeof("__none__") - 1 },
{ sizeof("export"), "export" }, { "export", sizeof("export") - 1 },
{ sizeof("import"), "import" }, { "import", sizeof("import") - 1 },
}; };
local_persist local_persist
Str invalid_flag = { sizeof("invalid"), "invalid" }; Str invalid_flag = { "invalid", sizeof("invalid") };
if ( flag > ModuleFlag_Import ) if ( flag > ModuleFlag_Import )
return invalid_flag; return invalid_flag;

20
base/dependencies/containers.hpp
View File

@ -102,16 +102,16 @@ struct Array
#endif #endif
#if GEN_COMPILER_CPP && 0 #if GEN_COMPILER_CPP && 0
template<class Type> bool append(Array<Type>& array, Array<Type> other) { return append( & array, other ); } template<class Type> bool append(Array<Type>& array, Array<Type> other) { return append( & array, other ); }
template<class Type> bool append(Array<Type>& array, Type value) { return append( & array, value ); } template<class Type> bool append(Array<Type>& array, Type value) { return append( & array, value ); }
template<class Type> bool append(Array<Type>& array, Type* items, usize item_num) { return append( & array, items, item_num ); } template<class Type> bool append(Array<Type>& array, Type* items, usize item_num) { return append( & array, items, item_num ); }
template<class Type> bool append_at(Array<Type>& array, Type item, usize idx) { return append_at( & array, item, idx ); } template<class Type> bool append_at(Array<Type>& array, Type item, usize idx) { return append_at( & array, item, idx ); }
template<class Type> bool append_at(Array<Type>& array, Type* items, usize item_num, usize idx) { return append_at( & array, items, item_num, idx ); } template<class Type> bool append_at(Array<Type>& array, Type* items, usize item_num, usize idx) { return append_at( & array, items, item_num, idx ); }
template<class Type> void free(Array<Type>& array) { return free( & array ); } template<class Type> void free(Array<Type>& array) { return free( & array ); }
template<class Type> bool grow(Array<Type>& array, usize min_capacity) { return grow( & array, min_capacity); } template<class Type> bool grow(Array<Type>& array, usize min_capacity) { return grow( & array, min_capacity); }
template<class Type> bool reserve(Array<Type>& array, usize new_capacity) { return reserve( & array, new_capacity); } template<class Type> bool reserve(Array<Type>& array, usize new_capacity) { return reserve( & array, new_capacity); }
template<class Type> bool resize(Array<Type>& array, usize num) { return resize( & array, num); } template<class Type> bool resize(Array<Type>& array, usize num) { return resize( & array, num); }
template<class Type> bool set_capacity(Array<Type>& array, usize new_capacity) { return set_capacity( & array, new_capacity); } template<class Type> bool set_capacity(Array<Type>& array, usize new_capacity) { return set_capacity( & array, new_capacity); }
template<class Type> forceinline Type* begin(Array<Type>& array) { return array; } template<class Type> forceinline Type* begin(Array<Type>& array) { return array; }
template<class Type> forceinline Type* end(Array<Type>& array) { return array + array_get_header(array)->Num; } template<class Type> forceinline Type* end(Array<Type>& array) { return array + array_get_header(array)->Num; }

8
base/dependencies/debug.hpp
View File

@ -11,8 +11,10 @@
#if GEN_BUILD_DEBUG #if GEN_BUILD_DEBUG
# if defined( GEN_COMPILER_MSVC ) # if defined( GEN_COMPILER_MSVC )
# if _MSC_VER < 1300 # if _MSC_VER < 1300
#pragma message("GEN_BUILD_DEBUG: __asm int 3")
# define GEN_DEBUG_TRAP() __asm int 3 /* Trap to debugger! */ # define GEN_DEBUG_TRAP() __asm int 3 /* Trap to debugger! */
# else # else
#pragma message("GEN_BUILD_DEBUG: __debugbreak()")
# define GEN_DEBUG_TRAP() __debugbreak() # define GEN_DEBUG_TRAP() __debugbreak()
# endif # endif
# elif defined( GEN_COMPILER_TINYC ) # elif defined( GEN_COMPILER_TINYC )
@ -21,6 +23,7 @@
# define GEN_DEBUG_TRAP() __builtin_trap() # define GEN_DEBUG_TRAP() __builtin_trap()
# endif # endif
#else #else
#pragma message("GEN_BUILD_DEBUG: omitted")
# define GEN_DEBUG_TRAP() # define GEN_DEBUG_TRAP()
#endif #endif
@ -48,7 +51,7 @@
local_persist thread_local \ local_persist thread_local \
char buf[GEN_PRINTF_MAXLEN] = { 0 }; \ char buf[GEN_PRINTF_MAXLEN] = { 0 }; \
\ \
c_str_fmt(buf, GEN_PRINTF_MAXLEN, __VA_ARGS__); \ c_str_fmt(buf, GEN_PRINTF_MAXLEN, __VA_ARGS__); \
GEN_PANIC(buf); \ GEN_PANIC(buf); \
} \ } \
while (0) while (0)
@ -57,7 +60,8 @@
# define GEN_FATAL( ... ) \ # define GEN_FATAL( ... ) \
do \ do \
{ \ { \
c_str_fmt_out_err( __VA_ARGS__ ); \ c_str_fmt_out_err( __VA_ARGS__ ); \
GEN_DEBUG_TRAP(); \
process_exit(1); \ process_exit(1); \
} \ } \
while (0) while (0)

62
base/dependencies/strings.hpp
View File

@ -18,8 +18,8 @@ Str str_visualize_whitespace(Str str, AllocatorInfo allocator);
// Constant string with length. // Constant string with length.
struct Str struct Str
{ {
ssize Len;
char const* Ptr; char const* Ptr;
ssize Len;
#if GEN_COMPILER_CPP #if GEN_COMPILER_CPP
forceinline operator char const* () const { return Ptr; } forceinline operator char const* () const { return Ptr; }
@ -40,9 +40,9 @@ struct Str
#ifndef txt #ifndef txt
# if GEN_COMPILER_CPP # if GEN_COMPILER_CPP
# define txt( text ) Str { sizeof( text ) - 1, ( text ) } # define txt( text ) Str { ( text ), sizeof( text ) - 1 }
# else # else
# define txt( text ) (Str){ sizeof( text ) - 1, ( text ) } # define txt( text ) (Str){ ( text ), sizeof( text ) - 1 }
# endif # endif
#endif #endif
@ -103,7 +103,7 @@ b32 str_starts_with(Str str, Str substring) {
inline inline
Str to_str_from_c_str( char const* bad_str ) { Str to_str_from_c_str( char const* bad_str ) {
Str result = { c_str_len( bad_str ), bad_str }; Str result = { bad_str, c_str_len( bad_str ) };
return result; return result;
} }
@ -170,7 +170,7 @@ struct StrBuilder
forceinline operator char*() { return Data; } forceinline operator char*() { return Data; }
forceinline operator char const*() const { return Data; } forceinline operator char const*() const { return Data; }
forceinline operator Str() const { return { strbuilder_length(* this), Data }; } forceinline operator Str() const { return { Data, strbuilder_length(* this) }; }
StrBuilder const& operator=(StrBuilder const& other) const { StrBuilder const& operator=(StrBuilder const& other) const {
if (this == &other) if (this == &other)
@ -222,31 +222,31 @@ struct StrBuilder
return strbuilder_make_length(allocator, buf, res); return strbuilder_make_length(allocator, buf, res);
} }
forceinline bool make_space_for(char const* str, ssize add_len) { return strbuilder_make_space_for(this, str, add_len); } forceinline bool make_space_for(char const* str, ssize add_len) { return strbuilder_make_space_for(this, str, add_len); }
forceinline bool append(char c) { return strbuilder_append_char(this, c); } forceinline bool append(char c) { return strbuilder_append_char(this, c); }
forceinline bool append(char const* str) { return strbuilder_append_c_str(this, str); } forceinline bool append(char const* str) { return strbuilder_append_c_str(this, str); }
forceinline bool append(char const* str, ssize length) { return strbuilder_append_c_str_len(this, str, length); } forceinline bool append(char const* str, ssize length) { return strbuilder_append_c_str_len(this, str, length); }
forceinline bool append(Str str) { return strbuilder_append_str(this, str); } forceinline bool append(Str str) { return strbuilder_append_str(this, str); }
forceinline bool append(const StrBuilder other) { return strbuilder_append_string(this, other); } forceinline bool append(const StrBuilder other) { return strbuilder_append_string(this, other); }
forceinline ssize avail_space() const { return strbuilder_avail_space(* this); } forceinline ssize avail_space() const { return strbuilder_avail_space(* this); }
forceinline char* back() { return strbuilder_back(* this); } forceinline char* back() { return strbuilder_back(* this); }
forceinline bool contains(Str substring) const { return strbuilder_contains_str(* this, substring); } forceinline bool contains(Str substring) const { return strbuilder_contains_str(* this, substring); }
forceinline bool contains(StrBuilder const& substring) const { return strbuilder_contains_string(* this, substring); } forceinline bool contains(StrBuilder const& substring) const { return strbuilder_contains_string(* this, substring); }
forceinline ssize capacity() const { return strbuilder_capacity(* this); } forceinline ssize capacity() const { return strbuilder_capacity(* this); }
forceinline void clear() { strbuilder_clear(* this); } forceinline void clear() { strbuilder_clear(* this); }
forceinline StrBuilder duplicate(AllocatorInfo allocator) const { return strbuilder_duplicate(* this, allocator); } forceinline StrBuilder duplicate(AllocatorInfo allocator) const { return strbuilder_duplicate(* this, allocator); }
forceinline void free() { strbuilder_free(this); } forceinline void free() { strbuilder_free(this); }
forceinline bool is_equal(StrBuilder const& other) const { return strbuilder_are_equal(* this, other); } forceinline bool is_equal(StrBuilder const& other) const { return strbuilder_are_equal(* this, other); }
forceinline bool is_equal(Str other) const { return strbuilder_are_equal_str(* this, other); } forceinline bool is_equal(Str other) const { return strbuilder_are_equal_str(* this, other); }
forceinline ssize length() const { return strbuilder_length(* this); } forceinline ssize length() const { return strbuilder_length(* this); }
forceinline b32 starts_with(Str substring) const { return strbuilder_starts_with_str(* this, substring); } forceinline b32 starts_with(Str substring) const { return strbuilder_starts_with_str(* this, substring); }
forceinline b32 starts_with(StrBuilder substring) const { return strbuilder_starts_with_string(* this, substring); } forceinline b32 starts_with(StrBuilder substring) const { return strbuilder_starts_with_string(* this, substring); }
forceinline void skip_line() { strbuilder_skip_line(* this); } forceinline void skip_line() { strbuilder_skip_line(* this); }
forceinline void strip_space() { strbuilder_strip_space(* this); } forceinline void strip_space() { strbuilder_strip_space(* this); }
forceinline Str to_str() { return { strbuilder_length(*this), Data}; } forceinline Str to_str() { return { Data, strbuilder_length(*this) }; }
forceinline void trim(char const* cut_set) { strbuilder_trim(* this, cut_set); } forceinline void trim(char const* cut_set) { strbuilder_trim(* this, cut_set); }
forceinline void trim_space() { strbuilder_trim_space(* this); } forceinline void trim_space() { strbuilder_trim_space(* this); }
forceinline StrBuilder visualize_whitespace() const { return strbuilder_visualize_whitespace(* this); } forceinline StrBuilder visualize_whitespace() const { return strbuilder_visualize_whitespace(* this); }
forceinline StrBuilderHeader& get_header() { return * strbuilder_get_header(* this); } forceinline StrBuilderHeader& get_header() { return * strbuilder_get_header(* this); }
bool append_fmt(char const* fmt, ...) { bool append_fmt(char const* fmt, ...) {
@ -621,7 +621,7 @@ void strip_space(StrBuilder str)
forceinline forceinline
Str strbuilder_to_str(StrBuilder str) { Str strbuilder_to_str(StrBuilder str) {
Str result = { strbuilder_length(str), (char const*)str }; Str result = { (char const*)str, strbuilder_length(str) };
return result; return result;
} }

36
base/helpers/base_codegen.hpp
View File

@ -22,8 +22,8 @@ CodeBody gen_ecode( char const* path, bool use_c_definition = false )
char const* keyword = csv_enum.Col_2[idx].string; char const* keyword = csv_enum.Col_2[idx].string;
// TODO(Ed): to_c_str_entries and the others in here didn't have proper sizing of the Str slice. // TODO(Ed): to_c_str_entries and the others in here didn't have proper sizing of the Str slice.
strbuilder_append_fmt( & enum_entries, "CT_%s,\n", code ); strbuilder_append_fmt( & enum_entries, "CT_%s,\n", code );
strbuilder_append_fmt( & to_c_str_entries, "{ sizeof(\"%s\"), \"%s\" },\n", code, code ); strbuilder_append_fmt( & to_c_str_entries, "{ \"%s\", sizeof(\"%s\") - 1 },\n", code, code );
strbuilder_append_fmt( & to_keyword_c_str_entries, "{ sizeof(\"%s\") - 1, \"%s\" },\n", keyword, keyword ); strbuilder_append_fmt( & to_keyword_c_str_entries, "{ \"%s\", sizeof(\"%s\") - 1 },\n", keyword, keyword );
} }
CodeEnum enum_code; CodeEnum enum_code;
@ -40,7 +40,7 @@ CodeBody gen_ecode( char const* path, bool use_c_definition = false )
#pragma push_macro("local_persist") #pragma push_macro("local_persist")
#undef local_persist #undef local_persist
Str lookup_size = strbuilder_to_str(strbuilder_fmt_buf(GlobalAllocator, "%d", array_num(csv_enum.Col_1) )); Str lookup_size = strbuilder_to_str(strbuilder_fmt_buf(GlobalAllocator, "%d", array_num(csv_enum.Col_1) ));
CodeBody to_c_str_fns = parse_global_body( token_fmt( CodeBody to_c_str_fns = parse_global_body( token_fmt(
"entries", strbuilder_to_str(to_c_str_entries) "entries", strbuilder_to_str(to_c_str_entries)
, "keywords", strbuilder_to_str(to_keyword_c_str_entries) , "keywords", strbuilder_to_str(to_keyword_c_str_entries)
@ -104,7 +104,7 @@ CodeBody gen_eoperator( char const* path, bool use_c_definition = false )
char const* enum_str = csv_enum.Col_1[idx].string; char const* enum_str = csv_enum.Col_1[idx].string;
char const* entry_to_str = csv_enum.Col_2[idx].string; char const* entry_to_str = csv_enum.Col_2[idx].string;
strbuilder_append_fmt( & enum_entries, "Op_%s,\n", enum_str ); strbuilder_append_fmt( & enum_entries, "Op_%s,\n", enum_str );
strbuilder_append_fmt( & to_c_str_entries, "{ sizeof(\"%s\"), \"%s\" },\n", entry_to_str, entry_to_str); strbuilder_append_fmt( & to_c_str_entries, "{ \"%s\", sizeof(\"%s\") - 1 },\n", entry_to_str, entry_to_str);
} }
CodeEnum enum_code; CodeEnum enum_code;
@ -181,7 +181,7 @@ CodeBody gen_especifier( char const* path, bool use_c_definition = false )
FixedArena_16KB scratch; fixed_arena_init(& scratch); FixedArena_16KB scratch; fixed_arena_init(& scratch);
AllocatorInfo scratch_info = fixed_arena_allocator_info(& scratch); AllocatorInfo scratch_info = fixed_arena_allocator_info(& scratch);
CSV_Columns2 csv_enum = parse_csv_two_columns( scratch_info, path ); CSV_Columns2 csv_enum = parse_csv_two_columns( scratch_info, path );
StrBuilder enum_entries = strbuilder_make_reserve( scratch_info, kilobytes(1) ); StrBuilder enum_entries = strbuilder_make_reserve( scratch_info, kilobytes(1) );
StrBuilder to_c_str_entries = strbuilder_make_reserve( scratch_info, kilobytes(1) ); StrBuilder to_c_str_entries = strbuilder_make_reserve( scratch_info, kilobytes(1) );
@ -190,7 +190,7 @@ CodeBody gen_especifier( char const* path, bool use_c_definition = false )
char const* enum_str = csv_enum.Col_1[idx].string; char const* enum_str = csv_enum.Col_1[idx].string;
char const* entry_to_str = csv_enum.Col_2[idx].string; char const* entry_to_str = csv_enum.Col_2[idx].string;
strbuilder_append_fmt( & enum_entries, "Spec_%s,\n", enum_str ); strbuilder_append_fmt( & enum_entries, "Spec_%s,\n", enum_str );
strbuilder_append_fmt( & to_c_str_entries, "{ sizeof(\"%s\"), \"%s\" },\n", entry_to_str, entry_to_str); strbuilder_append_fmt( & to_c_str_entries, "{ \"%s\", sizeof(\"%s\") - 1 },\n", entry_to_str, entry_to_str);
} }
CodeEnum enum_code; CodeEnum enum_code;
@ -267,7 +267,7 @@ CodeBody gen_especifier( char const* path, bool use_c_definition = false )
// We subtract 1 to remove the null terminator // We subtract 1 to remove the null terminator
// This is because the tokens lexed are not null terminated. // This is because the tokens lexed are not null terminated.
keymap[index] = crc32( enum_str.Ptr, enum_str.Len - 1); keymap[index] = crc32( enum_str.Ptr, enum_str.Len );
} }
do_once_end do_once_end
@ -317,7 +317,7 @@ CodeBody gen_especifier( char const* path, bool use_c_definition = false )
CodeBody gen_etoktype( char const* etok_path, char const* attr_path, bool use_c_definition = false ) CodeBody gen_etoktype( char const* etok_path, char const* attr_path, bool use_c_definition = false )
{ {
FixedArena_64KB scratch; fixed_arena_init(& scratch); FixedArena_64KB scratch; fixed_arena_init(& scratch);
AllocatorInfo scratch_info = fixed_arena_allocator_info(& scratch); AllocatorInfo scratch_info = fixed_arena_allocator_info(& scratch);
FileContents enum_content = file_read_contents( scratch_info, file_zero_terminate, etok_path ); FileContents enum_content = file_read_contents( scratch_info, file_zero_terminate, etok_path );
@ -330,15 +330,15 @@ CodeBody gen_etoktype( char const* etok_path, char const* attr_path, bool use_c_
CSV_Object csv_attr_nodes; CSV_Object csv_attr_nodes;
csv_parse( &csv_attr_nodes, rcast(char*, attrib_content.data), scratch_info, false ); csv_parse( &csv_attr_nodes, rcast(char*, attrib_content.data), scratch_info, false );
Array<ADT_Node> enum_strs = csv_enum_nodes.nodes[0].nodes; Array<ADT_Node> enum_strs = csv_enum_nodes.nodes[0].nodes;
Array<ADT_Node> enum_c_str_strs = csv_enum_nodes.nodes[1].nodes; Array<ADT_Node> enum_c_str_strs = csv_enum_nodes.nodes[1].nodes;
Array<ADT_Node> attribute_strs = csv_attr_nodes.nodes[0].nodes; Array<ADT_Node> attribute_strs = csv_attr_nodes.nodes[0].nodes;
Array<ADT_Node> attribute_c_str_strs = csv_attr_nodes.nodes[1].nodes; Array<ADT_Node> attribute_c_str_strs = csv_attr_nodes.nodes[1].nodes;
StrBuilder enum_entries = strbuilder_make_reserve( scratch_info, kilobytes(2) ); StrBuilder enum_entries = strbuilder_make_reserve( scratch_info, kilobytes(2) );
StrBuilder to_c_str_entries = strbuilder_make_reserve( scratch_info, kilobytes(4) ); StrBuilder to_c_str_entries = strbuilder_make_reserve( scratch_info, kilobytes(4) );
StrBuilder attribute_entries = strbuilder_make_reserve( scratch_info, kilobytes(2) ); StrBuilder attribute_entries = strbuilder_make_reserve( scratch_info, kilobytes(2) );
StrBuilder to_c_str_attributes = strbuilder_make_reserve( scratch_info, kilobytes(4) ); StrBuilder to_c_str_attributes = strbuilder_make_reserve( scratch_info, kilobytes(4) );
StrBuilder attribute_define_entries = strbuilder_make_reserve( scratch_info, kilobytes(4) ); StrBuilder attribute_define_entries = strbuilder_make_reserve( scratch_info, kilobytes(4) );
for (usize idx = 0; idx < array_num(enum_strs); idx++) for (usize idx = 0; idx < array_num(enum_strs); idx++)
@ -346,8 +346,8 @@ CodeBody gen_etoktype( char const* etok_path, char const* attr_path, bool use_c_
char const* enum_str = enum_strs[idx].string; char const* enum_str = enum_strs[idx].string;
char const* entry_to_str = enum_c_str_strs [idx].string; char const* entry_to_str = enum_c_str_strs [idx].string;
strbuilder_append_fmt( & enum_entries, "Tok_%s,\n", enum_str ); strbuilder_append_fmt( & enum_entries, "Tok_%s,\n", enum_str );
strbuilder_append_fmt( & to_c_str_entries, "{ sizeof(\"%s\"), \"%s\" },\n", entry_to_str, entry_to_str); strbuilder_append_fmt( & to_c_str_entries, "{ \"%s\", sizeof(\"%s\") - 1 },\n", entry_to_str, entry_to_str);
} }
for ( usize idx = 0; idx < array_num(attribute_strs); idx++ ) for ( usize idx = 0; idx < array_num(attribute_strs); idx++ )
@ -355,8 +355,8 @@ CodeBody gen_etoktype( char const* etok_path, char const* attr_path, bool use_c_
char const* attribute_str = attribute_strs[idx].string; char const* attribute_str = attribute_strs[idx].string;
char const* entry_to_str = attribute_c_str_strs [idx].string; char const* entry_to_str = attribute_c_str_strs [idx].string;
strbuilder_append_fmt( & attribute_entries, "Tok_Attribute_%s,\n", attribute_str ); strbuilder_append_fmt( & attribute_entries, "Tok_Attribute_%s,\n", attribute_str );
strbuilder_append_fmt( & to_c_str_attributes, "{ sizeof(\"%s\"), \"%s\" },\n", entry_to_str, entry_to_str); strbuilder_append_fmt( & to_c_str_attributes, "{ \"%s\", sizeof(\"%s\") - 1 },\n", entry_to_str, entry_to_str);
strbuilder_append_fmt( & attribute_define_entries, "Entry( Tok_Attribute_%s, \"%s\" )", attribute_str, entry_to_str ); strbuilder_append_fmt( & attribute_define_entries, "Entry( Tok_Attribute_%s, \"%s\" )", attribute_str, entry_to_str );
if ( idx < array_num(attribute_strs) - 1 ) if ( idx < array_num(attribute_strs) - 1 )
@ -429,7 +429,7 @@ CodeBody gen_etoktype( char const* etok_path, char const* attr_path, bool use_c_
// We subtract 1 to remove the null terminator // We subtract 1 to remove the null terminator
// This is because the tokens lexed are not null terminated. // This is because the tokens lexed are not null terminated.
keymap[index] = crc32( enum_str.Ptr, enum_str.Len - 1); keymap[index] = crc32( enum_str.Ptr, enum_str.Len);
} }
do_once_end do_once_end
@ -505,7 +505,7 @@ CodeBody gen_ast_inlines()
{ {
if ( ast == nullptr ) if ( ast == nullptr )
{ {
log_failure( "Attempt to dereference a nullptr!" ); log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr; return nullptr;
} }
return ast; return ast;

6
docs/AST_Design.md
View File

@ -46,13 +46,13 @@ The C/C++ interface procedures are located with `ast.hpp` (for the Code type), a
All code types can either serialize using a function of the pattern: All code types can either serialize using a function of the pattern:
```c ```c
StrBuilder <prefix>_to_string(Code code); StrBuilder <prefix>_to_strbuilder(Code code);
// or // or
<prefix>_to_string(Code code, StrBuilder& result); <prefix>_to_strbuilder(Code code, StrBuilder& result);
``` ```
Where the first generates strings allocated using Allocator_StringArena and the other appends an existing strings with their backed allocator. Where the first generates strings allocated using Allocator_StringArena and the other appends an existing strings with their backed allocator.
Serialization of for the AST is defined for `Code` in [`ast.chpp`](../base/components/ast.cpp) with `code_to_strbuilder_ptr` & `code_to_string`. Serialization of for the AST is defined for `Code` in [`ast.chpp`](../base/components/ast.cpp) with `code_to_strbuilder_ptr` & `code_to_strbuilder`.
Serializtion for the rest of the code types is within [`code_serialization.cpp`](../base/components/code_serialization.cpp). Serializtion for the rest of the code types is within [`code_serialization.cpp`](../base/components/code_serialization.cpp).
Gencpp's serialization does not provide coherent formatting of the code. The user should use a formatter after serializing. Gencpp's serialization does not provide coherent formatting of the code. The user should use a formatter after serializing.

26
gen_c_library/c_library.cpp
View File

@ -126,7 +126,7 @@ int gen_main()
if (fn->Specs) { if (fn->Specs) {
s32 constexpr_found = fn->Specs.remove( Spec_Constexpr ); s32 constexpr_found = fn->Specs.remove( Spec_Constexpr );
if (constexpr_found > -1) { if (constexpr_found > -1) {
//log_fmt("Found constexpr: %SB\n", entry.to_string()); //log_fmt("Found constexpr: %SB\n", entry.to_strbuilder());
fn->Specs.append(Spec_Inline); fn->Specs.append(Spec_Inline);
} }
} }
@ -549,9 +549,9 @@ do \
{ {
CodeTypename type = using_ver->UnderlyingType; CodeTypename type = using_ver->UnderlyingType;
CodeTypedef typedef_ver = parse_typedef(token_fmt( CodeTypedef typedef_ver = parse_typedef(token_fmt(
"ReturnType", to_string(type->ReturnType).to_str() "ReturnType", to_strbuilder(type->ReturnType).to_str()
, "Name" , using_ver->Name , "Name" , using_ver->Name
, "Parameters", to_string(type->Params).to_str() , "Parameters", to_strbuilder(type->Params).to_str()
, stringize( , stringize(
typedef <ReturnType>( * <Name>)(<Parameters>); typedef <ReturnType>( * <Name>)(<Parameters>);
))); )));
@ -646,7 +646,7 @@ do \
if (fn->Name.starts_with(txt("code_"))) if (fn->Name.starts_with(txt("code_")))
{ {
Str old_prefix = txt("code_"); Str old_prefix = txt("code_");
Str actual_name = { fn->Name.Len - old_prefix.Len, fn->Name.Ptr + old_prefix.Len }; Str actual_name = { fn->Name.Ptr + old_prefix.Len, fn->Name.Len - old_prefix.Len };
StrBuilder new_name = StrBuilder::fmt_buf(GlobalAllocator, "code__%S", actual_name ); StrBuilder new_name = StrBuilder::fmt_buf(GlobalAllocator, "code__%S", actual_name );
fn->Name = get_cached_string(new_name); fn->Name = get_cached_string(new_name);
@ -694,7 +694,7 @@ do \
s32 constexpr_found = var->Specs ? var->Specs.remove( Spec_Constexpr ) : - 1; s32 constexpr_found = var->Specs ? var->Specs.remove( Spec_Constexpr ) : - 1;
if (constexpr_found > -1) { if (constexpr_found > -1) {
//log_fmt("Found constexpr: %SB\n", entry.to_string()); //log_fmt("Found constexpr: %SB\n", entry.to_strbuilder());
if (var->Name.contains(txt("AST_ArrSpecs_Cap"))) if (var->Name.contains(txt("AST_ArrSpecs_Cap")))
{ {
Code def = untyped_str(txt( Code def = untyped_str(txt(
@ -716,7 +716,7 @@ R"(#define AST_ArrSpecs_Cap \
ast.append(def); ast.append(def);
break; break;
} }
CodeDefine def = def_define(var->Name, var->Value.to_string()); CodeDefine def = def_define(var->Name, var->Value.to_strbuilder());
ast.append(def); ast.append(def);
break; break;
} }
@ -796,7 +796,7 @@ R"(#define AST_ArrSpecs_Cap \
{ {
generic_selector.clear(); generic_selector.clear();
Str private_prefix = txt("code__"); Str private_prefix = txt("code__");
Str actual_name = { fn->Name.Len - private_prefix.Len, fn->Name.Ptr + private_prefix.Len }; Str actual_name = { fn->Name.Ptr + private_prefix.Len, fn->Name.Len - private_prefix.Len };
StrBuilder interface_name = StrBuilder::fmt_buf(GlobalAllocator, "code_%S", actual_name ); StrBuilder interface_name = StrBuilder::fmt_buf(GlobalAllocator, "code_%S", actual_name );
// Resolve generic's arguments // Resolve generic's arguments
@ -941,7 +941,7 @@ R"(#define <interface_name>( code ) _Generic( (code), \
{ {
// Convert the definition to use a default struct: https://vxtwitter.com/vkrajacic/status/1749816169736073295 // Convert the definition to use a default struct: https://vxtwitter.com/vkrajacic/status/1749816169736073295
Str prefix = txt("def_"); Str prefix = txt("def_");
Str actual_name = { fn->Name.Len - prefix.Len, fn->Name.Ptr + prefix.Len }; Str actual_name = { fn->Name.Ptr + prefix.Len, fn->Name.Len - prefix.Len };
Str new_name = StrBuilder::fmt_buf(GlobalAllocator, "def__%S", actual_name ).to_str(); Str new_name = StrBuilder::fmt_buf(GlobalAllocator, "def__%S", actual_name ).to_str();
// Resolve define's arguments // Resolve define's arguments
@ -1020,7 +1020,7 @@ R"(#define <interface_name>( code ) _Generic( (code), \
if (fn->Name.starts_with(txt("code_"))) if (fn->Name.starts_with(txt("code_")))
{ {
Str old_prefix = txt("code_"); Str old_prefix = txt("code_");
Str actual_name = { fn->Name.Len - old_prefix.Len, fn->Name.Ptr + old_prefix.Len }; Str actual_name = { fn->Name.Ptr + old_prefix.Len, fn->Name.Len - old_prefix.Len };
StrBuilder new_name = StrBuilder::fmt_buf(GlobalAllocator, "code__%S", actual_name ); StrBuilder new_name = StrBuilder::fmt_buf(GlobalAllocator, "code__%S", actual_name );
fn->Name = get_cached_string(new_name); fn->Name = get_cached_string(new_name);
@ -1175,7 +1175,7 @@ R"(#define <interface_name>( code ) _Generic( (code), \
if (fn->Name.starts_with(txt("code_"))) if (fn->Name.starts_with(txt("code_")))
{ {
Str old_prefix = txt("code_"); Str old_prefix = txt("code_");
Str actual_name = { fn->Name.Len - old_prefix.Len, fn->Name.Ptr + old_prefix.Len }; Str actual_name = { fn->Name.Ptr + old_prefix.Len, fn->Name.Len - old_prefix.Len };
StrBuilder new_name = StrBuilder::fmt_buf(GlobalAllocator, "code__%S", actual_name ); StrBuilder new_name = StrBuilder::fmt_buf(GlobalAllocator, "code__%S", actual_name );
fn->Name = get_cached_string(new_name); fn->Name = get_cached_string(new_name);
@ -1227,7 +1227,7 @@ R"(#define <interface_name>( code ) _Generic( (code), \
for ( CodeParams opt_param : fn->Params ) if (opt_param->ValueType->Name.starts_with(txt("Opts_"))) for ( CodeParams opt_param : fn->Params ) if (opt_param->ValueType->Name.starts_with(txt("Opts_")))
{ {
Str prefix = txt("def_"); Str prefix = txt("def_");
Str actual_name = { fn->Name.Len - prefix.Len, fn->Name.Ptr + prefix.Len }; Str actual_name = { fn->Name.Ptr + prefix.Len, fn->Name.Len - prefix.Len };
Str new_name = StrBuilder::fmt_buf(GlobalAllocator, "def__%S", actual_name ).to_str(); Str new_name = StrBuilder::fmt_buf(GlobalAllocator, "def__%S", actual_name ).to_str();
fn->Name = get_cached_string(new_name); fn->Name = get_cached_string(new_name);
@ -1319,7 +1319,7 @@ R"(#define <interface_name>( code ) _Generic( (code), \
Code define_ver = untyped_str(token_fmt( Code define_ver = untyped_str(token_fmt(
"name", var->Name "name", var->Name
, "value", var->Value->Content , "value", var->Value->Content
, "type", var->ValueType.to_string().to_str() , "type", var->ValueType.to_strbuilder().to_str()
, "#define <name> (<type>) <value>\n" , "#define <name> (<type>) <value>\n"
)); ));
src_lexer.append(define_ver); src_lexer.append(define_ver);
@ -1364,7 +1364,7 @@ R"(#define <interface_name>( code ) _Generic( (code), \
Code define_ver = untyped_str(token_fmt( Code define_ver = untyped_str(token_fmt(
"name", var->Name "name", var->Name
, "value", var->Value->Content , "value", var->Value->Content
, "type", var->ValueType.to_string().to_str() , "type", var->ValueType.to_strbuilder().to_str()
, "#define <name> (<type>) <value>\n" , "#define <name> (<type>) <value>\n"
)); ));
src_parser.append(define_ver); src_parser.append(define_ver);

7
gen_singleheader/singleheader.cpp
View File

@ -176,9 +176,9 @@ int gen_main()
Code timing = scan_file( path_base "dependencies/timing.cpp" ); Code timing = scan_file( path_base "dependencies/timing.cpp" );
header.print_fmt( roll_own_dependencies_guard_start ); header.print_fmt( roll_own_dependencies_guard_start );
header.print( impl_start );
header.print_fmt( "GEN_NS_BEGIN\n\n"); header.print_fmt( "GEN_NS_BEGIN\n\n");
header.print( impl_start );
header.print( debug ); header.print( debug );
header.print( string_ops ); header.print( string_ops );
header.print( printing ); header.print( printing );
@ -209,8 +209,7 @@ int gen_main()
Code parsing_interface = scan_file( path_base "components/interface.parsing.cpp" ); Code parsing_interface = scan_file( path_base "components/interface.parsing.cpp" );
Code untyped = scan_file( path_base "components/interface.untyped.cpp" ); Code untyped = scan_file( path_base "components/interface.untyped.cpp" );
CodeBody etoktype = gen_etoktype( path_base "enums/ETokType.csv", path_base "enums/AttributeTokens.csv" ); CodeBody etoktype = gen_etoktype( path_base "enums/ETokType.csv", path_base "enums/AttributeTokens.csv" );
CodeNS parser_nspace = def_namespace( name(parser), def_namespace_body( args(etoktype)) );
header.print_fmt( "\nGEN_NS_BEGIN\n"); header.print_fmt( "\nGEN_NS_BEGIN\n");
header.print( static_data ); header.print( static_data );
@ -225,7 +224,7 @@ int gen_main()
header.print( interface ); header.print( interface );
header.print( upfront ); header.print( upfront );
header.print_fmt( "\n#pragma region Parsing\n\n" ); header.print_fmt( "\n#pragma region Parsing\n\n" );
header.print( format(parser_nspace) ); header.print( format(etoktype) );
header.print( lexer ); header.print( lexer );
header.print( parser ); header.print( parser );
header.print( parsing_interface ); header.print( parsing_interface );

2
gen_unreal_engine/unreal.cpp
View File

@ -68,7 +68,7 @@ int gen_main()
CodeBody macros = def_body( CT_Global_Body ); CodeBody macros = def_body( CT_Global_Body );
{ {
FileContents content = file_read_contents( GlobalAllocator, true, path_base "dependencies/macros.hpp" ); FileContents content = file_read_contents( GlobalAllocator, true, path_base "dependencies/macros.hpp" );
CodeBody ori_macros = parse_global_body( Str { content.size, (char const*)content.data }); CodeBody ori_macros = parse_global_body( Str { (char const*)content.data, content.size });
for (Code code = ori_macros.begin(); for (Code code = ori_macros.begin();
code != ori_macros.end(); code != ori_macros.end();

2
scripts/genccp.natstepfilter
View File

@ -21,7 +21,7 @@
<Action>NoStepInto</Action> <Action>NoStepInto</Action>
</Function> </Function>
<Function> <Function>
<Name>gen::Code.*::to_string</Name> <Name>gen::Code.*::to_strbuilder</Name>
<Action>NoStepInto</Action> <Action>NoStepInto</Action>
</Function> </Function>
<Function> <Function>