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

Corrected enum serialization of ecodetypes, eoperator, especifier, and etoktype, some more naming refactors for strbuilder... formatting

Browse Source
This commit is contained in:
Edward R. Gonzalez 2024-12-13 14:38:27 -05:00
parent 012fcb6bd5
commit bac57a5872
23 changed files with 942 additions and 1172 deletions
Show Stats Download Patch File Download Diff File 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
2. Create a code object using `make_code`.
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.

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 )
{
StrBuilder str = code_to_string(code);
StrBuilder str = code_to_strbuilder(code);
// const ssize len = str.length();
// log_fmt( "%s - print: %.*s\n", File.filename, len > 80 ? 80 : len, str.Data );
strbuilder_append_string( & builder->Buffer, str );

214
base/components/ast.cpp
View File

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

18
base/components/ast.hpp
View File

@ -260,7 +260,7 @@ bool code_is_body (Code code);
bool code_is_equal (Code code, Code other);
bool code_is_valid (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 );
Str code_type_str (Code self );
bool code_validate_body (Code self );
@ -295,17 +295,17 @@ struct Code
#if ! GEN_C_LIKE_CPP
Using_Code( Code );
forceinline void append(Code other) { return code_append(* this, other); }
forceinline Code* entry(u32 idx) { return code_entry(* this, idx); }
forceinline bool has_entries() { return code_has_entries(* this); }
forceinline StrBuilder to_string() { return code_to_string(* this); }
forceinline void to_string(StrBuilder& result) { return code_to_strbuilder_ptr(* this, & result); }
forceinline Str type_str() { return code_type_str(* this); }
forceinline bool validate_body() { return code_validate_body(*this); }
forceinline void append(Code other) { return code_append(* this, other); }
forceinline Code* entry(u32 idx) { return code_entry(* this, idx); }
forceinline bool has_entries() { return code_has_entries(* this); }
forceinline StrBuilder to_strbuilder() { return code_to_strbuilder(* this); }
forceinline void to_strbuilder(StrBuilder& result) { return code_to_strbuilder_ptr(* this, & result); }
forceinline Str type_str() { return code_type_str(* this); }
forceinline bool validate_body() { return code_validate_body(*this); }
#endif
Using_CodeOps( Code );
forceinline Code operator *() { return * this; } // Required for for-range iteration.
forceinline Code operator *() { return * this; } // Required to support for-range iteration.
forceinline AST* operator ->() { return ast; }
Code& operator ++();

278
base/components/code_serialization.cpp
View File

@ -4,7 +4,7 @@
#endif
inline
StrBuilder attributes_to_string(CodeAttributes attributes) {
StrBuilder attributes_to_strbuilder(CodeAttributes attributes) {
GEN_ASSERT(attributes);
char* raw = ccast(char*, str_duplicate( attributes->Content, GlobalAllocator ).Ptr);
StrBuilder result = { raw };
@ -18,7 +18,7 @@ void attributes_to_strbuilder_ref(CodeAttributes attributes, StrBuilder* result)
strbuilder_append_str(result, attributes->Content);
}
StrBuilder body_to_string(CodeBody body)
StrBuilder body_to_strbuilder(CodeBody body)
{
GEN_ASSERT(body);
StrBuilder result = strbuilder_make_reserve( GlobalAllocator, 128 );
@ -56,7 +56,7 @@ void body_to_strbuilder_ref( CodeBody body, StrBuilder* result )
while ( left -- )
{
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;
}
}
@ -72,7 +72,7 @@ void body_to_strbuilder_export( CodeBody body, StrBuilder* result )
while ( left-- )
{
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;
}
@ -80,7 +80,7 @@ void body_to_strbuilder_export( CodeBody body, StrBuilder* result )
}
inline
StrBuilder comment_to_string(CodeComment comment) {
StrBuilder comment_to_strbuilder(CodeComment comment) {
GEN_ASSERT(comment);
char* raw = ccast(char*, str_duplicate( comment->Content, GlobalAllocator ).Ptr);
StrBuilder result = { raw };
@ -94,7 +94,7 @@ void comment_to_strbuilder_ref(CodeComment comment, StrBuilder* result) {
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 );
switch (self->Type)
@ -120,17 +120,17 @@ void constructor_to_strbuilder_def(CodeConstructor self, StrBuilder* result )
}
if ( self->Params )
strbuilder_append_fmt( result, "( %SB )", params_to_string(self->Params) );
strbuilder_append_fmt( result, "( %SB )", params_to_strbuilder(self->Params) );
else
strbuilder_append_str( result, txt("()") );
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 )
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 )
@ -144,12 +144,12 @@ void constructor_to_strbuilder_fwd(CodeConstructor self, StrBuilder* result )
}
if ( self->Params )
strbuilder_append_fmt( result, "( %SB )", params_to_string(self->Params) );
strbuilder_append_fmt( result, "( %SB )", params_to_strbuilder(self->Params) );
else
strbuilder_append_fmt( result, "()");
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 )
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 class_to_string( CodeClass self )
StrBuilder class_to_strbuilder( CodeClass self )
{
StrBuilder result = strbuilder_make_reserve( GlobalAllocator, 512 );
switch ( self->Type )
@ -183,13 +183,13 @@ void class_to_strbuilder_def( CodeClass self, StrBuilder* result )
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 )
{
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);
if ( interface )
@ -197,7 +197,7 @@ void class_to_strbuilder_def( CodeClass self, StrBuilder* result )
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;
}
}
@ -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, "\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 ) )
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 ") );
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 );
@ -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 );
}
@ -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 destructor_to_string(CodeDestructor self)
StrBuilder destructor_to_strbuilder(CodeDestructor self)
{
StrBuilder result = strbuilder_make_reserve( GlobalAllocator, 128 );
switch ( self->Type )
@ -280,7 +280,7 @@ void destructor_to_strbuilder_def(CodeDestructor self, StrBuilder* result )
else
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 )
@ -295,7 +295,7 @@ void destructor_to_strbuilder_fwd(CodeDestructor self, StrBuilder* result )
if ( specifiers_has(self->Specs, Spec_Pure ) )
strbuilder_append_str( result, txt(" = 0;") );
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
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 enum_to_string(CodeEnum self)
StrBuilder enum_to_strbuilder(CodeEnum self)
{
StrBuilder result = strbuilder_make_reserve( GlobalAllocator, 512 );
switch ( self->Type )
@ -337,24 +337,24 @@ void enum_to_strbuilder_def(CodeEnum self, StrBuilder* result )
strbuilder_append_str( result, txt("enum ") );
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 )
strbuilder_append_fmt( result, "%S : %SB\n{\n%SB\n}"
, self->Name
, typename_to_string(self->UnderlyingType)
, body_to_string(self->Body)
, typename_to_strbuilder(self->UnderlyingType)
, body_to_strbuilder(self->Body)
);
else if ( self->UnderlyingTypeMacro )
strbuilder_append_fmt( result, "%S %SB\n{\n%SB\n}"
, self->Name
, code_to_string(self->UnderlyingTypeMacro)
, body_to_string(self->Body)
, code_to_strbuilder(self->UnderlyingTypeMacro)
, 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 ) )
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 ") );
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 )
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)
{
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
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 )
{
strbuilder_append_fmt( result, "%SB ", attributes_to_string(self->Attributes) );
strbuilder_append_fmt( result, "%SB ", attributes_to_strbuilder(self->Attributes) );
}
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
{
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
{
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 ) )
@ -427,9 +427,9 @@ void enum_to_strbuilder_class_fwd(CodeEnum self, StrBuilder* result )
strbuilder_append_str( result, txt("enum class ") );
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 ) )
{
@ -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);
char* raw = ccast(char*, str_duplicate( exec->Content, GlobalAllocator ).Ptr);
@ -448,15 +448,15 @@ StrBuilder exec_to_string(CodeExec exec)
return result;
}
void extern_to_string(CodeExtern self, StrBuilder* result )
void extern_to_strbuilder(CodeExtern self, StrBuilder* result )
{
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
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 );
}
@ -466,7 +466,7 @@ void include_to_strbuilder_ref( CodeInclude include, StrBuilder* result )
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 );
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 )
{
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 ] != ';' )
{
@ -488,7 +488,7 @@ void friend_to_strbuilder_ref(CodeFriend self, StrBuilder* result )
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 );
switch ( self->Type )
@ -509,7 +509,7 @@ void fn_to_strbuilder_def(CodeFn self, StrBuilder* result )
strbuilder_append_str( result, txt("export") );
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;
if ( self->Specs )
@ -530,13 +530,13 @@ void fn_to_strbuilder_def(CodeFn self, StrBuilder* result )
strbuilder_append_str( result, txt("\n") );
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
strbuilder_append_fmt( result, "%S(", self->Name );
if ( self->Params )
strbuilder_append_fmt( result, "%SB)", params_to_string(self->Params) );
strbuilder_append_fmt( result, "%SB)", params_to_strbuilder(self->Params) );
else
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 )
@ -562,7 +562,7 @@ void fn_to_strbuilder_fwd(CodeFn self, StrBuilder* result )
strbuilder_append_str( result, txt("export ") );
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;
if ( self->Specs )
@ -585,13 +585,13 @@ void fn_to_strbuilder_fwd(CodeFn self, StrBuilder* result )
}
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
strbuilder_append_fmt( result, "%S(", self->Name );
if ( self->Params )
strbuilder_append_fmt( result, "%SB)", params_to_string(self->Params) );
strbuilder_append_fmt( result, "%SB)", params_to_strbuilder(self->Params) );
else
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 )
strbuilder_append_str( result, txt(" = 0;") );
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 )
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 module_to_string(CodeModule self)
StrBuilder module_to_strbuilder(CodeModule self)
{
StrBuilder result = strbuilder_make_reserve( GlobalAllocator, 64 );
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 namespace_to_string(CodeNS self)
StrBuilder namespace_to_strbuilder(CodeNS self)
{
StrBuilder result = strbuilder_make_reserve( GlobalAllocator, 512 );
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 ))
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 );
switch ( self->Type )
@ -675,10 +675,10 @@ void code_op_to_strbuilder_def(CodeOperator self, StrBuilder* result )
strbuilder_append_str( result, txt("export ") );
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 )
strbuilder_append_fmt( result, "%SB ", attributes_to_string(self->Attributes) );
strbuilder_append_fmt( result, "%SB ", attributes_to_strbuilder(self->Attributes) );
if ( self->Specs )
{
@ -698,10 +698,10 @@ void code_op_to_strbuilder_def(CodeOperator self, StrBuilder* result )
}
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 )
strbuilder_append_fmt( result, "%SB)", params_to_string(self->Params) );
strbuilder_append_fmt( result, "%SB)", params_to_strbuilder(self->Params) );
else
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"
, 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 ") );
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 )
{
@ -748,10 +748,10 @@ void code_op_to_strbuilder_fwd(CodeOperator self, StrBuilder* result )
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 )
strbuilder_append_fmt( result, "%SB)", params_to_string(self->Params) );
strbuilder_append_fmt( result, "%SB)", params_to_strbuilder(self->Params) );
else
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 opcast_to_string(CodeOpCast self)
StrBuilder opcast_to_strbuilder(CodeOpCast self)
{
StrBuilder result = strbuilder_make_reserve( GlobalAllocator, 128 );
switch ( self->Type )
@ -803,9 +803,9 @@ void opcast_to_strbuilder_def(CodeOpCast self, StrBuilder* result )
}
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
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) )
{
@ -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;
}
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
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 )
@ -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) )
{
@ -858,12 +858,12 @@ void opcast_to_strbuilder_fwd(CodeOpCast self, StrBuilder* result )
}
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
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);
@ -888,30 +888,30 @@ void params_to_strbuilder_ref( CodeParams self, StrBuilder* result )
if ( self->ValueType == nullptr )
strbuilder_append_fmt( result, " %S", self->Name );
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 )
strbuilder_append_fmt( result, " %SB", typename_to_string(self->ValueType) );
strbuilder_append_fmt( result, " %SB", typename_to_strbuilder(self->ValueType) );
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 )
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 )
{
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);
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 pragma_to_string(CodePragma self)
StrBuilder pragma_to_strbuilder(CodePragma self)
{
GEN_ASSERT(self);
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 specifiers_to_string(CodeSpecifiers self)
StrBuilder specifiers_to_strbuilder(CodeSpecifiers self)
{
StrBuilder result = strbuilder_make_reserve( GlobalAllocator, 64 );
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);
@ -1037,14 +1037,14 @@ void struct_to_strbuilder_def( CodeStruct self, StrBuilder* result )
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 )
{
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);
if ( interface )
@ -1052,7 +1052,7 @@ void struct_to_strbuilder_def( CodeStruct self, StrBuilder* result )
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;
}
}
@ -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, "\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 ) )
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 ") );
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 );
@ -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);
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 ") );
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
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 );
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
if ( self->UnderlyingType->ReturnType )
strbuilder_append_string( result, code_to_string(self->UnderlyingType) );
strbuilder_append_string( result, code_to_strbuilder(self->UnderlyingType) );
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 )
{
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;
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;
}
}
@ -1156,7 +1156,7 @@ void typedef_to_strbuilder_ref(CodeTypedef self, StrBuilder* result )
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("") );
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->Attributes )
strbuilder_append_fmt( result, "%SB ", attributes_to_string(self->Attributes) );
strbuilder_append_fmt( result, "%SB ", attributes_to_strbuilder(self->Attributes) );
else
{
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
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;
@ -1184,13 +1184,13 @@ void typename_to_strbuilder_ref(CodeTypename self, StrBuilder* result )
if ( self->ReturnType && self->Params )
{
if ( self->Attributes )
strbuilder_append_fmt( result, "%SB ", attributes_to_string(self->Attributes) );
strbuilder_append_fmt( result, "%SB ", attributes_to_strbuilder(self->Attributes) );
else
{
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
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;
@ -1198,7 +1198,7 @@ void typename_to_strbuilder_ref(CodeTypename self, StrBuilder* result )
#endif
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 )
{
@ -1211,7 +1211,7 @@ void typename_to_strbuilder_ref(CodeTypename self, StrBuilder* result )
}
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
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 union_to_string(CodeUnion self)
StrBuilder union_to_strbuilder(CodeUnion self)
{
StrBuilder result = strbuilder_make_reserve( GlobalAllocator, 512 );
switch ( self->Type )
@ -1242,20 +1242,20 @@ void union_to_strbuilder_def(CodeUnion self, StrBuilder* result )
strbuilder_append_str( result, txt("union ") );
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 )
{
strbuilder_append_fmt( result, "%S\n{\n%SB\n}"
, self->Name
, body_to_string(self->Body)
, body_to_strbuilder(self->Body)
);
}
else
{
// Anonymous union
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 ") );
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 )
{
@ -1284,7 +1284,7 @@ void union_to_strbuilder_fwd(CodeUnion self, StrBuilder* result )
strbuilder_append_str( result, txt(";\n"));
}
StrBuilder using_to_string(CodeUsing self)
StrBuilder using_to_strbuilder(CodeUsing self)
{
GEN_ASSERT(self);
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 ") );
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 )
{
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 )
{
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;
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;
}
}
@ -1349,7 +1349,7 @@ void using_to_strbuilder_ns(CodeUsing self, StrBuilder* result )
}
inline
StrBuilder var_to_string(CodeVar self)
StrBuilder var_to_strbuilder(CodeVar self)
{
GEN_ASSERT(self);
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 )
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 );
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;
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;
}
}
@ -1386,14 +1386,14 @@ void var_to_strbuilder_ref(CodeVar self, StrBuilder* result )
if ( self->Value )
{
if ( self->VarParenthesizedInit )
strbuilder_append_fmt( result, "( %SB ", code_to_string(self->Value) );
strbuilder_append_fmt( result, "( %SB ", code_to_strbuilder(self->Value) );
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...
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 )
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 )
strbuilder_append_fmt( result, "%SB ", specifiers_to_string(self->Specs) );
strbuilder_append_fmt( result, "%SB ", specifiers_to_strbuilder(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 && 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;
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;
}
}
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->VarParenthesizedInit )
strbuilder_append_fmt( result, "( %SB ", code_to_string(self->Value) );
strbuilder_append_fmt( result, "( %SB ", code_to_strbuilder(self->Value) );
else
strbuilder_append_fmt( result, " = %SB", code_to_string(self->Value) );
strbuilder_append_fmt( result, " = %SB", code_to_strbuilder(self->Value) );
}
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 )
strbuilder_append_str( result, txt(" )"));
@ -1452,33 +1452,33 @@ void var_to_strbuilder_ref(CodeVar self, StrBuilder* result )
}
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 )
{
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;
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;
}
}
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->VarParenthesizedInit )
strbuilder_append_fmt( result, "( %SB ", code_to_string(self->Value) );
strbuilder_append_fmt( result, "( %SB ", code_to_strbuilder(self->Value) );
else
strbuilder_append_fmt( result, " = %SB", code_to_string(self->Value) );
strbuilder_append_fmt( result, " = %SB", code_to_strbuilder(self->Value) );
}
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 )
strbuilder_append_str( result, txt(" )"));

613
base/components/code_types.hpp
View File

File diff suppressed because it is too large Load Diff

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

@ -75,67 +75,67 @@ enum CodeType : u32
inline Str codetype_to_str( CodeType type )
{
local_persist Str lookup[61] = {
{ "Invalid", sizeof( "Invalid" ) },
{ "Untyped", sizeof( "Untyped" ) },
{ "NewLine", sizeof( "NewLine" ) },
{ "Comment", sizeof( "Comment" ) },
{ "Access_Private", sizeof( "Access_Private" ) },
{ "Access_Protected", sizeof( "Access_Protected" ) },
{ "Access_Public", sizeof( "Access_Public" ) },
{ "PlatformAttributes", sizeof( "PlatformAttributes" ) },
{ "Class", sizeof( "Class" ) },
{ "Class_Fwd", sizeof( "Class_Fwd" ) },
{ "Class_Body", sizeof( "Class_Body" ) },
{ "Constructor", sizeof( "Constructor" ) },
{ "Constructor_Fwd", sizeof( "Constructor_Fwd" ) },
{ "Destructor", sizeof( "Destructor" ) },
{ "Destructor_Fwd", sizeof( "Destructor_Fwd" ) },
{ "Enum", sizeof( "Enum" ) },
{ "Enum_Fwd", sizeof( "Enum_Fwd" ) },
{ "Enum_Body", sizeof( "Enum_Body" ) },
{ "Enum_Class", sizeof( "Enum_Class" ) },
{ "Enum_Class_Fwd", sizeof( "Enum_Class_Fwd" ) },
{ "Execution", sizeof( "Execution" ) },
{ "Export_Body", sizeof( "Export_Body" ) },
{ "Extern_Linkage", sizeof( "Extern_Linkage" ) },
{ "Extern_Linkage_Body", sizeof( "Extern_Linkage_Body" ) },
{ "Friend", sizeof( "Friend" ) },
{ "Function", sizeof( "Function" ) },
{ "Function_Fwd", sizeof( "Function_Fwd" ) },
{ "Function_Body", sizeof( "Function_Body" ) },
{ "Global_Body", sizeof( "Global_Body" ) },
{ "Module", sizeof( "Module" ) },
{ "Namespace", sizeof( "Namespace" ) },
{ "Namespace_Body", sizeof( "Namespace_Body" ) },
{ "Operator", sizeof( "Operator" ) },
{ "Operator_Fwd", sizeof( "Operator_Fwd" ) },
{ "Operator_Member", sizeof( "Operator_Member" ) },
{ "Operator_Member_Fwd", sizeof( "Operator_Member_Fwd" ) },
{ "Operator_Cast", sizeof( "Operator_Cast" ) },
{ "Operator_Cast_Fwd", sizeof( "Operator_Cast_Fwd" ) },
{ "Parameters", sizeof( "Parameters" ) },
{ "Preprocess_Define", sizeof( "Preprocess_Define" ) },
{ "Preprocess_Include", sizeof( "Preprocess_Include" ) },
{ "Preprocess_If", sizeof( "Preprocess_If" ) },
{ "Preprocess_IfDef", sizeof( "Preprocess_IfDef" ) },
{ "Preprocess_IfNotDef", sizeof( "Preprocess_IfNotDef" ) },
{ "Preprocess_ElIf", sizeof( "Preprocess_ElIf" ) },
{ "Preprocess_Else", sizeof( "Preprocess_Else" ) },
{ "Preprocess_EndIf", sizeof( "Preprocess_EndIf" ) },
{ "Preprocess_Pragma", sizeof( "Preprocess_Pragma" ) },
{ "Specifiers", sizeof( "Specifiers" ) },
{ "Struct", sizeof( "Struct" ) },
{ "Struct_Fwd", sizeof( "Struct_Fwd" ) },
{ "Struct_Body", sizeof( "Struct_Body" ) },
{ "Template", sizeof( "Template" ) },
{ "Typedef", sizeof( "Typedef" ) },
{ "Typename", sizeof( "Typename" ) },
{ "Union", sizeof( "Union" ) },
{ "Union_Fwd", sizeof( "Union_Fwd" ) },
{ "Union_Body", sizeof( "Union_Body" ) },
{ "Using", sizeof( "Using" ) },
{ "Using_Namespace", sizeof( "Using_Namespace" ) },
{ "Variable", sizeof( "Variable" ) },
{ "Invalid", sizeof( "Invalid" ) - 1 },
{ "Untyped", sizeof( "Untyped" ) - 1 },
{ "NewLine", sizeof( "NewLine" ) - 1 },
{ "Comment", sizeof( "Comment" ) - 1 },
{ "Access_Private", sizeof( "Access_Private" ) - 1 },
{ "Access_Protected", sizeof( "Access_Protected" ) - 1 },
{ "Access_Public", sizeof( "Access_Public" ) - 1 },
{ "PlatformAttributes", sizeof( "PlatformAttributes" ) - 1 },
{ "Class", sizeof( "Class" ) - 1 },
{ "Class_Fwd", sizeof( "Class_Fwd" ) - 1 },
{ "Class_Body", sizeof( "Class_Body" ) - 1 },
{ "Constructor", sizeof( "Constructor" ) - 1 },
{ "Constructor_Fwd", sizeof( "Constructor_Fwd" ) - 1 },
{ "Destructor", sizeof( "Destructor" ) - 1 },
{ "Destructor_Fwd", sizeof( "Destructor_Fwd" ) - 1 },
{ "Enum", sizeof( "Enum" ) - 1 },
{ "Enum_Fwd", sizeof( "Enum_Fwd" ) - 1 },
{ "Enum_Body", sizeof( "Enum_Body" ) - 1 },
{ "Enum_Class", sizeof( "Enum_Class" ) - 1 },
{ "Enum_Class_Fwd", sizeof( "Enum_Class_Fwd" ) - 1 },
{ "Execution", sizeof( "Execution" ) - 1 },
{ "Export_Body", sizeof( "Export_Body" ) - 1 },
{ "Extern_Linkage", sizeof( "Extern_Linkage" ) - 1 },
{ "Extern_Linkage_Body", sizeof( "Extern_Linkage_Body" ) - 1 },
{ "Friend", sizeof( "Friend" ) - 1 },
{ "Function", sizeof( "Function" ) - 1 },
{ "Function_Fwd", sizeof( "Function_Fwd" ) - 1 },
{ "Function_Body", sizeof( "Function_Body" ) - 1 },
{ "Global_Body", sizeof( "Global_Body" ) - 1 },
{ "Module", sizeof( "Module" ) - 1 },
{ "Namespace", sizeof( "Namespace" ) - 1 },
{ "Namespace_Body", sizeof( "Namespace_Body" ) - 1 },
{ "Operator", sizeof( "Operator" ) - 1 },
{ "Operator_Fwd", sizeof( "Operator_Fwd" ) - 1 },
{ "Operator_Member", sizeof( "Operator_Member" ) - 1 },
{ "Operator_Member_Fwd", sizeof( "Operator_Member_Fwd" ) - 1 },
{ "Operator_Cast", sizeof( "Operator_Cast" ) - 1 },
{ "Operator_Cast_Fwd", sizeof( "Operator_Cast_Fwd" ) - 1 },
{ "Parameters", sizeof( "Parameters" ) - 1 },
{ "Preprocess_Define", sizeof( "Preprocess_Define" ) - 1 },
{ "Preprocess_Include", sizeof( "Preprocess_Include" ) - 1 },
{ "Preprocess_If", sizeof( "Preprocess_If" ) - 1 },
{ "Preprocess_IfDef", sizeof( "Preprocess_IfDef" ) - 1 },
{ "Preprocess_IfNotDef", sizeof( "Preprocess_IfNotDef" ) - 1 },
{ "Preprocess_ElIf", sizeof( "Preprocess_ElIf" ) - 1 },
{ "Preprocess_Else", sizeof( "Preprocess_Else" ) - 1 },
{ "Preprocess_EndIf", sizeof( "Preprocess_EndIf" ) - 1 },
{ "Preprocess_Pragma", sizeof( "Preprocess_Pragma" ) - 1 },
{ "Specifiers", sizeof( "Specifiers" ) - 1 },
{ "Struct", sizeof( "Struct" ) - 1 },
{ "Struct_Fwd", sizeof( "Struct_Fwd" ) - 1 },
{ "Struct_Body", sizeof( "Struct_Body" ) - 1 },
{ "Template", sizeof( "Template" ) - 1 },
{ "Typedef", sizeof( "Typedef" ) - 1 },
{ "Typename", sizeof( "Typename" ) - 1 },
{ "Union", sizeof( "Union" ) - 1 },
{ "Union_Fwd", sizeof( "Union_Fwd" ) - 1 },
{ "Union_Body", sizeof( "Union_Body" ) - 1 },
{ "Using", sizeof( "Using" ) - 1 },
{ "Using_Namespace", sizeof( "Using_Namespace" ) - 1 },
{ "Variable", sizeof( "Variable" ) - 1 },
};
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 )
{
local_persist Str lookup[47] = {
{ "INVALID", sizeof( "INVALID" ) },
{ "=", sizeof( "=" ) },
{ "+=", sizeof( "+=" ) },
{ "-=", sizeof( "-=" ) },
{ "*=", sizeof( "*=" ) },
{ "/=", sizeof( "/=" ) },
{ "%=", sizeof( "%=" ) },
{ "&=", sizeof( "&=" ) },
{ "|=", sizeof( "|=" ) },
{ "^=", sizeof( "^=" ) },
{ "<<=", sizeof( "<<=" ) },
{ ">>=", sizeof( ">>=" ) },
{ "++", sizeof( "++" ) },
{ "--", sizeof( "--" ) },
{ "+", sizeof( "+" ) },
{ "-", sizeof( "-" ) },
{ "!", sizeof( "!" ) },
{ "+", sizeof( "+" ) },
{ "-", sizeof( "-" ) },
{ "*", sizeof( "*" ) },
{ "/", sizeof( "/" ) },
{ "%", sizeof( "%" ) },
{ "~", sizeof( "~" ) },
{ "&", sizeof( "&" ) },
{ "|", sizeof( "|" ) },
{ "^", sizeof( "^" ) },
{ "<<", sizeof( "<<" ) },
{ ">>", sizeof( ">>" ) },
{ "&&", sizeof( "&&" ) },
{ "||", sizeof( "||" ) },
{ "==", sizeof( "==" ) },
{ "!=", sizeof( "!=" ) },
{ "<", sizeof( "<" ) },
{ ">", sizeof( ">" ) },
{ "<=", sizeof( "<=" ) },
{ ">=", sizeof( ">=" ) },
{ "[]", sizeof( "[]" ) },
{ "*", sizeof( "*" ) },
{ "&", sizeof( "&" ) },
{ "->", sizeof( "->" ) },
{ "->*", sizeof( "->*" ) },
{ "()", sizeof( "()" ) },
{ ",", sizeof( "," ) },
{ "new", sizeof( "new" ) },
{ "new[]", sizeof( "new[]" ) },
{ "delete", sizeof( "delete" ) },
{ "delete[]", sizeof( "delete[]" ) },
{ "INVALID", sizeof( "INVALID" ) - 1 },
{ "=", sizeof( "=" ) - 1 },
{ "+=", sizeof( "+=" ) - 1 },
{ "-=", sizeof( "-=" ) - 1 },
{ "*=", sizeof( "*=" ) - 1 },
{ "/=", sizeof( "/=" ) - 1 },
{ "%=", sizeof( "%=" ) - 1 },
{ "&=", sizeof( "&=" ) - 1 },
{ "|=", sizeof( "|=" ) - 1 },
{ "^=", sizeof( "^=" ) - 1 },
{ "<<=", sizeof( "<<=" ) - 1 },
{ ">>=", sizeof( ">>=" ) - 1 },
{ "++", sizeof( "++" ) - 1 },
{ "--", sizeof( "--" ) - 1 },
{ "+", sizeof( "+" ) - 1 },
{ "-", sizeof( "-" ) - 1 },
{ "!", sizeof( "!" ) - 1 },
{ "+", sizeof( "+" ) - 1 },
{ "-", sizeof( "-" ) - 1 },
{ "*", sizeof( "*" ) - 1 },
{ "/", sizeof( "/" ) - 1 },
{ "%", sizeof( "%" ) - 1 },
{ "~", sizeof( "~" ) - 1 },
{ "&", sizeof( "&" ) - 1 },
{ "|", sizeof( "|" ) - 1 },
{ "^", sizeof( "^" ) - 1 },
{ "<<", sizeof( "<<" ) - 1 },
{ ">>", sizeof( ">>" ) - 1 },
{ "&&", sizeof( "&&" ) - 1 },
{ "||", sizeof( "||" ) - 1 },
{ "==", sizeof( "==" ) - 1 },
{ "!=", sizeof( "!=" ) - 1 },
{ "<", sizeof( "<" ) - 1 },
{ ">", sizeof( ">" ) - 1 },
{ "<=", sizeof( "<=" ) - 1 },
{ ">=", sizeof( ">=" ) - 1 },
{ "[]", sizeof( "[]" ) - 1 },
{ "*", sizeof( "*" ) - 1 },
{ "&", sizeof( "&" ) - 1 },
{ "->", sizeof( "->" ) - 1 },
{ "->*", sizeof( "->*" ) - 1 },
{ "()", sizeof( "()" ) - 1 },
{ ",", sizeof( "," ) - 1 },
{ "new", sizeof( "new" ) - 1 },
{ "new[]", sizeof( "new[]" ) - 1 },
{ "delete", sizeof( "delete" ) - 1 },
{ "delete[]", sizeof( "delete[]" ) - 1 },
};
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 )
{
local_persist Str lookup[26] = {
{ "INVALID", sizeof( "INVALID" ) },
{ "consteval", sizeof( "consteval" ) },
{ "constexpr", sizeof( "constexpr" ) },
{ "constinit", sizeof( "constinit" ) },
{ "explicit", sizeof( "explicit" ) },
{ "extern", sizeof( "extern" ) },
{ "forceinline", sizeof( "forceinline" ) },
{ "global", sizeof( "global" ) },
{ "inline", sizeof( "inline" ) },
{ "internal", sizeof( "internal" ) },
{ "local_persist", sizeof( "local_persist" ) },
{ "mutable", sizeof( "mutable" ) },
{ "neverinline", sizeof( "neverinline" ) },
{ "*", sizeof( "*" ) },
{ "&", sizeof( "&" ) },
{ "register", sizeof( "register" ) },
{ "&&", sizeof( "&&" ) },
{ "static", sizeof( "static" ) },
{ "thread_local", sizeof( "thread_local" ) },
{ "virtual", sizeof( "virtual" ) },
{ "const", sizeof( "const" ) },
{ "final", sizeof( "final" ) },
{ "noexcept", sizeof( "noexcept" ) },
{ "override", sizeof( "override" ) },
{ "= 0", sizeof( "= 0" ) },
{ "volatile", sizeof( "volatile" ) },
{ "INVALID", sizeof( "INVALID" ) - 1 },
{ "consteval", sizeof( "consteval" ) - 1 },
{ "constexpr", sizeof( "constexpr" ) - 1 },
{ "constinit", sizeof( "constinit" ) - 1 },
{ "explicit", sizeof( "explicit" ) - 1 },
{ "extern", sizeof( "extern" ) - 1 },
{ "forceinline", sizeof( "forceinline" ) - 1 },
{ "global", sizeof( "global" ) - 1 },
{ "inline", sizeof( "inline" ) - 1 },
{ "internal", sizeof( "internal" ) - 1 },
{ "local_persist", sizeof( "local_persist" ) - 1 },
{ "mutable", sizeof( "mutable" ) - 1 },
{ "neverinline", sizeof( "neverinline" ) - 1 },
{ "*", sizeof( "*" ) - 1 },
{ "&", sizeof( "&" ) - 1 },
{ "register", sizeof( "register" ) - 1 },
{ "&&", sizeof( "&&" ) - 1 },
{ "static", sizeof( "static" ) - 1 },
{ "thread_local", sizeof( "thread_local" ) - 1 },
{ "virtual", sizeof( "virtual" ) - 1 },
{ "const", sizeof( "const" ) - 1 },
{ "final", sizeof( "final" ) - 1 },
{ "noexcept", sizeof( "noexcept" ) - 1 },
{ "override", sizeof( "override" ) - 1 },
{ "= 0", sizeof( "= 0" ) - 1 },
{ "volatile", sizeof( "volatile" ) - 1 },
};
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++ )
{
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 );
for ( u32 index = 0; index < Spec_NumSpecifiers; index++ )

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

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

235
base/components/gen/etoktype.hpp
View File

@ -1,235 +0,0 @@
#ifdef GEN_INTELLISENSE_DIRECTIVES
#pragma once
#include "components/types.hpp"
#endif
// This file was generated automatially by gencpp's bootstrap.cpp (See: https://github.com/Ed94/gencpp)
GEN_NS_PARSER_BEGIN
#define GEN_DEFINE_ATTRIBUTE_TOKENS Entry( Tok_Attribute_API_Export, "GEN_API_Export_Code" ) Entry( Tok_Attribute_API_Import, "GEN_API_Import_Code" )
enum TokType : u32
{
Tok_Invalid,
Tok_Access_Private,
Tok_Access_Protected,
Tok_Access_Public,
Tok_Access_MemberSymbol,
Tok_Access_StaticSymbol,
Tok_Ampersand,
Tok_Ampersand_DBL,
Tok_Assign_Classifer,
Tok_Attribute_Open,
Tok_Attribute_Close,
Tok_BraceCurly_Open,
Tok_BraceCurly_Close,
Tok_BraceSquare_Open,
Tok_BraceSquare_Close,
Tok_Capture_Start,
Tok_Capture_End,
Tok_Comment,
Tok_Comment_End,
Tok_Comment_Start,
Tok_Char,
Tok_Comma,
Tok_Decl_Class,
Tok_Decl_GNU_Attribute,
Tok_Decl_MSVC_Attribute,
Tok_Decl_Enum,
Tok_Decl_Extern_Linkage,
Tok_Decl_Friend,
Tok_Decl_Module,
Tok_Decl_Namespace,
Tok_Decl_Operator,
Tok_Decl_Struct,
Tok_Decl_Template,
Tok_Decl_Typedef,
Tok_Decl_Using,
Tok_Decl_Union,
Tok_Identifier,
Tok_Module_Import,
Tok_Module_Export,
Tok_NewLine,
Tok_Number,
Tok_Operator,
Tok_Preprocess_Hash,
Tok_Preprocess_Define,
Tok_Preprocess_If,
Tok_Preprocess_IfDef,
Tok_Preprocess_IfNotDef,
Tok_Preprocess_ElIf,
Tok_Preprocess_Else,
Tok_Preprocess_EndIf,
Tok_Preprocess_Include,
Tok_Preprocess_Pragma,
Tok_Preprocess_Content,
Tok_Preprocess_Macro,
Tok_Preprocess_Unsupported,
Tok_Spec_Alignas,
Tok_Spec_Const,
Tok_Spec_Consteval,
Tok_Spec_Constexpr,
Tok_Spec_Constinit,
Tok_Spec_Explicit,
Tok_Spec_Extern,
Tok_Spec_Final,
Tok_Spec_ForceInline,
Tok_Spec_Global,
Tok_Spec_Inline,
Tok_Spec_Internal_Linkage,
Tok_Spec_LocalPersist,
Tok_Spec_Mutable,
Tok_Spec_NeverInline,
Tok_Spec_Override,
Tok_Spec_Static,
Tok_Spec_ThreadLocal,
Tok_Spec_Volatile,
Tok_Spec_Virtual,
Tok_Star,
Tok_Statement_End,
Tok_StaticAssert,
Tok_String,
Tok_Type_Typename,
Tok_Type_Unsigned,
Tok_Type_Signed,
Tok_Type_Short,
Tok_Type_Long,
Tok_Type_bool,
Tok_Type_char,
Tok_Type_int,
Tok_Type_double,
Tok_Type_MS_int8,
Tok_Type_MS_int16,
Tok_Type_MS_int32,
Tok_Type_MS_int64,
Tok_Type_MS_W64,
Tok_Varadic_Argument,
Tok___Attributes_Start,
Tok_Attribute_API_Export,
Tok_Attribute_API_Import,
Tok_NumTokens
};
inline Str toktype_to_str( TokType type )
{
local_persist Str lookup[] = {
{ "__invalid__", sizeof( "__invalid__" ) },
{ "private", sizeof( "private" ) },
{ "protected", sizeof( "protected" ) },
{ "public", sizeof( "public" ) },
{ ".", sizeof( "." ) },
{ "::", sizeof( "::" ) },
{ "&", sizeof( "&" ) },
{ "&&", sizeof( "&&" ) },
{ ":", sizeof( ":" ) },
{ "[[", sizeof( "[[" ) },
{ "]]", sizeof( "]]" ) },
{ "{", sizeof( "{" ) },
{ "}", sizeof( "}" ) },
{ "[", sizeof( "[" ) },
{ "]", sizeof( "]" ) },
{ "(", sizeof( "(" ) },
{ ")", sizeof( ")" ) },
{ "__comment__", sizeof( "__comment__" ) },
{ "__comment_end__", sizeof( "__comment_end__" ) },
{ "__comment_start__", sizeof( "__comment_start__" ) },
{ "__character__", sizeof( "__character__" ) },
{ ",", sizeof( "," ) },
{ "class", sizeof( "class" ) },
{ "__attribute__", sizeof( "__attribute__" ) },
{ "__declspec", sizeof( "__declspec" ) },
{ "enum", sizeof( "enum" ) },
{ "extern", sizeof( "extern" ) },
{ "friend", sizeof( "friend" ) },
{ "module", sizeof( "module" ) },
{ "namespace", sizeof( "namespace" ) },
{ "operator", sizeof( "operator" ) },
{ "struct", sizeof( "struct" ) },
{ "template", sizeof( "template" ) },
{ "typedef", sizeof( "typedef" ) },
{ "using", sizeof( "using" ) },
{ "union", sizeof( "union" ) },
{ "__identifier__", sizeof( "__identifier__" ) },
{ "import", sizeof( "import" ) },
{ "export", sizeof( "export" ) },
{ "__new_line__", sizeof( "__new_line__" ) },
{ "__number__", sizeof( "__number__" ) },
{ "__operator__", sizeof( "__operator__" ) },
{ "#", sizeof( "#" ) },
{ "define", sizeof( "define" ) },
{ "if", sizeof( "if" ) },
{ "ifdef", sizeof( "ifdef" ) },
{ "ifndef", sizeof( "ifndef" ) },
{ "elif", sizeof( "elif" ) },
{ "else", sizeof( "else" ) },
{ "endif", sizeof( "endif" ) },
{ "include", sizeof( "include" ) },
{ "pragma", sizeof( "pragma" ) },
{ "__macro_content__", sizeof( "__macro_content__" ) },
{ "__macro__", sizeof( "__macro__" ) },
{ "__unsupported__", sizeof( "__unsupported__" ) },
{ "alignas", sizeof( "alignas" ) },
{ "const", sizeof( "const" ) },
{ "consteval", sizeof( "consteval" ) },
{ "constexpr", sizeof( "constexpr" ) },
{ "constinit", sizeof( "constinit" ) },
{ "explicit", sizeof( "explicit" ) },
{ "extern", sizeof( "extern" ) },
{ "final", sizeof( "final" ) },
{ "forceinline", sizeof( "forceinline" ) },
{ "global", sizeof( "global" ) },
{ "inline", sizeof( "inline" ) },
{ "internal", sizeof( "internal" ) },
{ "local_persist", sizeof( "local_persist" ) },
{ "mutable", sizeof( "mutable" ) },
{ "neverinline", sizeof( "neverinline" ) },
{ "override", sizeof( "override" ) },
{ "static", sizeof( "static" ) },
{ "thread_local", sizeof( "thread_local" ) },
{ "volatile", sizeof( "volatile" ) },
{ "virtual", sizeof( "virtual" ) },
{ "*", sizeof( "*" ) },
{ ";", sizeof( ";" ) },
{ "static_assert", sizeof( "static_assert" ) },
{ "__string__", sizeof( "__string__" ) },
{ "typename", sizeof( "typename" ) },
{ "unsigned", sizeof( "unsigned" ) },
{ "signed", sizeof( "signed" ) },
{ "short", sizeof( "short" ) },
{ "long", sizeof( "long" ) },
{ "bool", sizeof( "bool" ) },
{ "char", sizeof( "char" ) },
{ "int", sizeof( "int" ) },
{ "double", sizeof( "double" ) },
{ "__int8", sizeof( "__int8" ) },
{ "__int16", sizeof( "__int16" ) },
{ "__int32", sizeof( "__int32" ) },
{ "__int64", sizeof( "__int64" ) },
{ "_W64", sizeof( "_W64" ) },
{ "...", sizeof( "..." ) },
{ "__attrib_start__", sizeof( "__attrib_start__" ) },
{ "GEN_API_Export_Code", sizeof( "GEN_API_Export_Code" ) },
{ "GEN_API_Import_Code", sizeof( "GEN_API_Import_Code" ) },
};
return lookup[type];
}
inline TokType str_to_toktype( Str str )
{
local_persist u32 keymap[Tok_NumTokens];
do_once_start for ( u32 index = 0; index < Tok_NumTokens; index++ )
{
Str enum_str = toktype_to_str( (TokType)index );
keymap[index] = crc32( enum_str.Ptr, enum_str.Len - 1 );
}
do_once_end u32 hash = crc32( str.Ptr, str.Len );
for ( u32 index = 0; index < Tok_NumTokens; index++ )
{
if ( keymap[index] == hash )
return (TokType)index;
}
return Tok_Invalid;
}
GEN_NS_PARSER_END

2
base/components/interface.hpp
View File

@ -294,7 +294,7 @@ Code untyped_token_fmt( s32 num_tokens, char const* fmt, ... );
#ifndef code
// Same as name just used to indicate intention of literal for code instead of names.
#define code( ... ) { stringize( __VA_ARGS__ ), sizeof(stringize(__VA_ARGS__)) - 1 }
#define code( ... ) { stringize( __VA_ARGS__ ), sizeof(stringize(__VA_ARGS__)) - 1 }
#endif
#ifndef args

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

@ -59,7 +59,7 @@ CodeConstructor parse_constructor( Str def )
break;
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);
return InvalidCode;
}

6
base/components/lexer.cpp
View File

@ -92,7 +92,7 @@ bool tok_is_end_definition(Token tok)
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) );
@ -183,7 +183,7 @@ enum
struct LexContext
{
Str content;
Str content;
s32 left;
char const* scanner;
s32 line;
@ -620,7 +620,7 @@ TokArray lex( Str content )
#if 0
if (Tokens.num())
{
log_fmt("\nLastTok: %SB", Tokens.back().to_string());
log_fmt("\nLastTok: %SB", Tokens.back().to_strbuilder());
}
#endif

142
base/components/parser.cpp
View File

@ -45,7 +45,7 @@ void parser_pop(ParseContext* ctx)
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) );
@ -102,7 +102,7 @@ bool lex__eat(TokArray* self, TokType type )
{
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;
}
@ -122,14 +122,14 @@ bool lex__eat(TokArray* self, TokType type )
, at_idx.Length, at_idx.Text
, tok.Line
, tok.Column
, parser_to_string(Context)
, parser_to_strbuilder(Context)
);
GEN_DEBUG_TRAP();
return false;
}
#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
self->Idx ++;
@ -530,14 +530,14 @@ Code parse_array_decl()
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);
return InvalidCode;
}
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);
return InvalidCode;
}
@ -556,14 +556,14 @@ Code parse_array_decl()
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);
return InvalidCode;
}
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);
return InvalidCode;
}
@ -704,7 +704,7 @@ Code parse_class_struct( TokType which, bool inplace_def )
{
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;
}
@ -846,7 +846,7 @@ CodeBody parse_class_struct_body( TokType which, Token name )
case Tok_Statement_End:
{
// 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 );
continue;
}
@ -928,7 +928,7 @@ CodeBody parse_class_struct_body( TokType which, Token name )
case Tok_Operator:
//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;
//}
@ -1042,7 +1042,7 @@ CodeBody parse_class_struct_body( TokType which, Token name )
break;
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);
return InvalidCode;
}
@ -1128,7 +1128,7 @@ CodeBody parse_class_struct_body( TokType which, Token name )
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);
return InvalidCode;
}
@ -1162,7 +1162,7 @@ CodeBody parse_class_struct_body( TokType which, Token name )
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);
return InvalidCode;
}
@ -1249,7 +1249,7 @@ Code parse_complicated_definition( TokType which )
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);
return InvalidCode;
}
@ -1294,7 +1294,7 @@ Code parse_complicated_definition( TokType which )
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);
return InvalidCode;
}
@ -1313,7 +1313,7 @@ Code parse_complicated_definition( TokType 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);
return InvalidCode;
}
@ -1343,7 +1343,7 @@ Code parse_complicated_definition( TokType which )
}
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);
return InvalidCode;
}
@ -1362,7 +1362,7 @@ CodeDefine parse_define()
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);
return InvalidCode;
}
@ -1374,7 +1374,7 @@ CodeDefine parse_define()
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);
return InvalidCode;
}
@ -1409,7 +1409,7 @@ Code parse_assignment_expression()
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);
return InvalidCode;
}
@ -1461,7 +1461,7 @@ Code parse_forward_or_definition( TokType which, bool is_inplace )
default:
log_failure( "Error, wrong token type given to parse_complicated_definition "
"(only supports class, enum, struct, union) \n%s"
, parser_to_string(Context) );
, parser_to_strbuilder(Context) );
return InvalidCode;
}
@ -1552,7 +1552,7 @@ CodeFn parse_function_after_name(
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);
return InvalidCode;
}
@ -1661,7 +1661,7 @@ CodeBody parse_global_nspace( CodeType which )
{
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);
return InvalidCode;
}
@ -1669,7 +1669,7 @@ CodeBody parse_global_nspace( CodeType which )
case Tok_Statement_End:
{
// 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 );
continue;
}
@ -1695,7 +1695,7 @@ CodeBody parse_global_nspace( CodeType which )
case Tok_Decl_Extern_Linkage:
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());
// extern "..." { ... }
@ -1788,7 +1788,7 @@ CodeBody parse_global_nspace( CodeType which )
case Tok_Module_Export: {
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());
// export { ... }
@ -1858,7 +1858,7 @@ CodeBody parse_global_nspace( CodeType which )
default:
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);
return InvalidCode;
}
@ -1941,7 +1941,7 @@ CodeBody parse_global_nspace( CodeType which )
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);
return InvalidCode;
}
@ -1960,7 +1960,7 @@ CodeBody parse_global_nspace( CodeType which )
Member_Resolved_To_Lone_Macro:
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);
return InvalidCode;
}
@ -2129,7 +2129,7 @@ Token parse_identifier( bool* possible_member_function )
Token invalid = { nullptr, 0, Tok_Invalid };
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);
return invalid;
}
@ -2144,7 +2144,7 @@ Token parse_identifier( bool* possible_member_function )
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);
return invalid;
}
@ -2156,7 +2156,7 @@ Token parse_identifier( bool* possible_member_function )
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);
return invalid;
}
@ -2164,7 +2164,7 @@ Token parse_identifier( bool* possible_member_function )
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);
return invalid;
}
@ -2195,7 +2195,7 @@ CodeInclude parse_include()
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);
return InvalidCode;
}
@ -2243,7 +2243,7 @@ CodeOperator parse_operator_after_ret_type(
&& currtok.Type != Tok_Ampersand
&& 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);
return InvalidCode;
}
@ -2496,7 +2496,7 @@ CodeOperator parse_operator_after_ret_type(
{
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);
return InvalidCode;
}
@ -2506,7 +2506,7 @@ CodeOperator parse_operator_after_ret_type(
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);
return InvalidCode;
}
@ -2650,7 +2650,7 @@ Code parse_operator_function_or_variable( bool expects_function, CodeAttributes
{
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);
return InvalidCode;
}
@ -2678,7 +2678,7 @@ CodePragma parse_pragma()
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);
return InvalidCode;
}
@ -2791,7 +2791,7 @@ CodeParams parse_params( bool use_template_capture )
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);
return InvalidCode;
}
@ -2904,7 +2904,7 @@ CodeParams parse_params( bool use_template_capture )
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);
return InvalidCode;
}
@ -2965,7 +2965,7 @@ CodeParams parse_params( bool use_template_capture )
{
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);
return InvalidCode;
}
@ -2985,7 +2985,7 @@ CodePreprocessCond parse_preprocess_cond()
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);
return InvalidCode;
}
@ -2998,7 +2998,7 @@ CodePreprocessCond parse_preprocess_cond()
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);
return InvalidCode;
}
@ -3289,7 +3289,7 @@ CodeVar parse_variable_after_name(
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);
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"
"(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 );
}
@ -3420,9 +3420,9 @@ CodeVar parse_variable_declaration_list()
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"
, tok_to_str(currtok), parser_to_string(Context) );
, tok_to_str(currtok), strbuilder_to_str( parser_to_strbuilder(Context)) );
continue;
}
break;
@ -3586,7 +3586,7 @@ CodeDestructor parser_parse_destructor( CodeSpecifiers specifiers )
eat( Tok_Operator );
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);
return InvalidCode;
}
@ -3624,7 +3624,7 @@ CodeDestructor parser_parse_destructor( CodeSpecifiers specifiers )
}
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);
return InvalidCode;
}
@ -3722,7 +3722,7 @@ CodeEnum parser_parse_enum( bool inplace_def )
type = parser_parse_type(parser_not_from_template, nullptr);
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);
return InvalidCode;
}
@ -3755,7 +3755,7 @@ CodeEnum parser_parse_enum( bool inplace_def )
{
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);
break;
}
@ -3862,7 +3862,7 @@ CodeEnum parser_parse_enum( bool inplace_def )
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);
return InvalidCode;
}
@ -3957,7 +3957,7 @@ CodeExtern parser_parse_extern_link()
CodeBody entry = parser_parse_extern_link_body();
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);
return result;
}
@ -3998,7 +3998,7 @@ CodeFriend parser_parse_friend()
break;
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);
return InvalidCode;
}
@ -4127,7 +4127,7 @@ CodeFn parser_parse_function()
break;
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);
return InvalidCode;
}
@ -4238,7 +4238,7 @@ CodeOperator parser_parse_operator()
break;
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);
return InvalidCode;
}
@ -4490,7 +4490,7 @@ CodeTemplate parser_parse_template()
break;
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);
return InvalidCode;
}
@ -4614,7 +4614,7 @@ CodeTypename parser_parse_type( bool from_template, bool* typedef_is_function )
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);
return InvalidCode;
}
@ -4627,7 +4627,7 @@ CodeTypename parser_parse_type( bool from_template, bool* typedef_is_function )
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);
return InvalidCode;
}
@ -4719,7 +4719,7 @@ else if ( currtok.Type == Tok_DeclType )
Context.Scope->Name = 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);
return InvalidCode;
}
@ -4738,7 +4738,7 @@ else if ( currtok.Type == Tok_DeclType )
Context.Scope->Name = 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);
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 )
{
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);
return InvalidCode;
}
@ -4885,7 +4885,7 @@ else if ( currtok.Type == Tok_DeclType )
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);
return InvalidCode;
}
@ -4955,7 +4955,7 @@ else if ( currtok.Type == Tok_DeclType )
// && spec != Spec_NoExcept
&& 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);
return InvalidCode;
}
@ -4996,7 +4996,7 @@ else if ( currtok.Type == Tok_DeclType )
#ifdef GEN_USE_NEW_TYPENAME_PARSING
if ( params_nested )
{
name_stripped.append( params_nested->to_string() );
name_stripped.append( params_nested->to_strbuilder() );
}
#endif
@ -5161,7 +5161,7 @@ CodeTypedef parser_parse_typedef()
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);
return InvalidCode;
}
@ -5187,7 +5187,7 @@ CodeTypedef parser_parse_typedef()
}
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);
return InvalidCode;
}
@ -5208,7 +5208,7 @@ CodeTypedef parser_parse_typedef()
}
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);
return InvalidCode;
}
@ -5544,7 +5544,7 @@ CodeVar parser_parse_variable()
break;
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);
return InvalidCode;
}

2
base/components/types.hpp
View File

@ -102,7 +102,7 @@ Str module_flag_to_str( ModuleFlag flag )
local_persist
Str lookup[ (u32)Num_ModuleFlags ] = {
{ "__none__", sizeof("__none__") - 1 },
{ "export", sizeof("export") - 1 },
{ "export", sizeof("export") - 1 },
{ "import", sizeof("import") - 1 },
};

20
base/dependencies/containers.hpp
View File

@ -102,16 +102,16 @@ struct Array
#endif
#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, 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_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> 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 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 set_capacity(Array<Type>& array, usize new_capacity) { return set_capacity( & array, new_capacity); }
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* 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* 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> 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 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> forceinline Type* begin(Array<Type>& array) { return array; }
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 defined( GEN_COMPILER_MSVC )
# if _MSC_VER < 1300
#pragma message("GEN_BUILD_DEBUG: __asm int 3")
# define GEN_DEBUG_TRAP() __asm int 3 /* Trap to debugger! */
# else
#pragma message("GEN_BUILD_DEBUG: __debugbreak()")
# define GEN_DEBUG_TRAP() __debugbreak()
# endif
# elif defined( GEN_COMPILER_TINYC )
@ -21,6 +23,7 @@
# define GEN_DEBUG_TRAP() __builtin_trap()
# endif
#else
#pragma message("GEN_BUILD_DEBUG: omitted")
# define GEN_DEBUG_TRAP()
#endif
@ -48,7 +51,7 @@
local_persist thread_local \
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); \
} \
while (0)
@ -57,7 +60,8 @@
# define GEN_FATAL( ... ) \
do \
{ \
c_str_fmt_out_err( __VA_ARGS__ ); \
c_str_fmt_out_err( __VA_ARGS__ ); \
GEN_DEBUG_TRAP(); \
process_exit(1); \
} \
while (0)

50
base/dependencies/strings.hpp
View File

@ -222,31 +222,31 @@ struct StrBuilder
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 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, 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(const StrBuilder other) { return strbuilder_append_string(this, other); }
forceinline ssize avail_space() const { return strbuilder_avail_space(* this); }
forceinline char* back() { return strbuilder_back(* this); }
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 ssize capacity() const { return strbuilder_capacity(* this); }
forceinline void clear() { strbuilder_clear(* this); }
forceinline StrBuilder duplicate(AllocatorInfo allocator) const { return strbuilder_duplicate(* this, allocator); }
forceinline void free() { strbuilder_free(this); }
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 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(StrBuilder substring) const { return strbuilder_starts_with_string(* this, substring); }
forceinline void skip_line() { strbuilder_skip_line(* this); }
forceinline void strip_space() { strbuilder_strip_space(* this); }
forceinline Str to_str() { return { Data, strbuilder_length(*this) }; }
forceinline void trim(char const* cut_set) { strbuilder_trim(* this, cut_set); }
forceinline void trim_space() { strbuilder_trim_space(* this); }
forceinline StrBuilder visualize_whitespace() const { return strbuilder_visualize_whitespace(* this); }
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 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(Str str) { return strbuilder_append_str(this, str); }
forceinline bool append(const StrBuilder other) { return strbuilder_append_string(this, other); }
forceinline ssize avail_space() const { return strbuilder_avail_space(* this); }
forceinline char* back() { return strbuilder_back(* this); }
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 ssize capacity() const { return strbuilder_capacity(* this); }
forceinline void clear() { strbuilder_clear(* this); }
forceinline StrBuilder duplicate(AllocatorInfo allocator) const { return strbuilder_duplicate(* this, allocator); }
forceinline void free() { strbuilder_free(this); }
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 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(StrBuilder substring) const { return strbuilder_starts_with_string(* this, substring); }
forceinline void skip_line() { strbuilder_skip_line(* this); }
forceinline void strip_space() { strbuilder_strip_space(* this); }
forceinline Str to_str() { return { Data, strbuilder_length(*this) }; }
forceinline void trim(char const* cut_set) { strbuilder_trim(* this, cut_set); }
forceinline void trim_space() { strbuilder_trim_space(* this); }
forceinline StrBuilder visualize_whitespace() const { return strbuilder_visualize_whitespace(* this); }
forceinline StrBuilderHeader& get_header() { return * strbuilder_get_header(* this); }
bool append_fmt(char const* fmt, ...) {

32
base/helpers/base_codegen.hpp
View File

@ -22,7 +22,7 @@ CodeBody gen_ecode( char const* path, bool use_c_definition = false )
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.
strbuilder_append_fmt( & enum_entries, "CT_%s,\n", code );
strbuilder_append_fmt( & to_c_str_entries, "{ \"%s\", sizeof(\"%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, "{ \"%s\", sizeof(\"%s\") - 1 },\n", keyword, keyword );
}
@ -40,7 +40,7 @@ CodeBody gen_ecode( char const* path, bool use_c_definition = false )
#pragma push_macro("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(
"entries", strbuilder_to_str(to_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* entry_to_str = csv_enum.Col_2[idx].string;
strbuilder_append_fmt( & enum_entries, "Op_%s,\n", enum_str );
strbuilder_append_fmt( & to_c_str_entries, "{ \"%s\", sizeof(\"%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;
@ -181,7 +181,7 @@ CodeBody gen_especifier( char const* path, bool use_c_definition = false )
FixedArena_16KB scratch; fixed_arena_init(& 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 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* entry_to_str = csv_enum.Col_2[idx].string;
strbuilder_append_fmt( & enum_entries, "Spec_%s,\n", enum_str );
strbuilder_append_fmt( & to_c_str_entries, "{ \"%s\", sizeof(\"%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;
@ -267,7 +267,7 @@ CodeBody gen_especifier( char const* path, bool use_c_definition = false )
// We subtract 1 to remove the null terminator
// 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
@ -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 )
{
FixedArena_64KB scratch; fixed_arena_init(& scratch);
FixedArena_64KB scratch; fixed_arena_init(& scratch);
AllocatorInfo scratch_info = fixed_arena_allocator_info(& scratch);
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_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> 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;
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 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) );
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* entry_to_str = enum_c_str_strs [idx].string;
strbuilder_append_fmt( & enum_entries, "Tok_%s,\n", enum_str );
strbuilder_append_fmt( & to_c_str_entries, "{ \"%s\", sizeof(\"%s\") },\n", entry_to_str, entry_to_str);
strbuilder_append_fmt( & enum_entries, "Tok_%s,\n", enum_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++ )
@ -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* entry_to_str = attribute_c_str_strs [idx].string;
strbuilder_append_fmt( & attribute_entries, "Tok_Attribute_%s,\n", attribute_str );
strbuilder_append_fmt( & to_c_str_attributes, "{ \"%s\", sizeof(\"%s\") },\n", entry_to_str, entry_to_str);
strbuilder_append_fmt( & attribute_entries, "Tok_Attribute_%s,\n", attribute_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 );
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
// 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

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:
```c
StrBuilder <prefix>_to_string(Code code);
StrBuilder <prefix>_to_strbuilder(Code code);
// 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.
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).
Gencpp's serialization does not provide coherent formatting of the code. The user should use a formatter after serializing.

14
gen_c_library/c_library.cpp
View File

@ -126,7 +126,7 @@ int gen_main()
if (fn->Specs) {
s32 constexpr_found = fn->Specs.remove( Spec_Constexpr );
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);
}
}
@ -549,9 +549,9 @@ do \
{
CodeTypename type = using_ver->UnderlyingType;
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
, "Parameters", to_string(type->Params).to_str()
, "Parameters", to_strbuilder(type->Params).to_str()
, stringize(
typedef <ReturnType>( * <Name>)(<Parameters>);
)));
@ -694,7 +694,7 @@ do \
s32 constexpr_found = var->Specs ? var->Specs.remove( Spec_Constexpr ) : - 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")))
{
Code def = untyped_str(txt(
@ -716,7 +716,7 @@ R"(#define AST_ArrSpecs_Cap \
ast.append(def);
break;
}
CodeDefine def = def_define(var->Name, var->Value.to_string());
CodeDefine def = def_define(var->Name, var->Value.to_strbuilder());
ast.append(def);
break;
}
@ -1319,7 +1319,7 @@ R"(#define <interface_name>( code ) _Generic( (code), \
Code define_ver = untyped_str(token_fmt(
"name", var->Name
, "value", var->Value->Content
, "type", var->ValueType.to_string().to_str()
, "type", var->ValueType.to_strbuilder().to_str()
, "#define <name> (<type>) <value>\n"
));
src_lexer.append(define_ver);
@ -1364,7 +1364,7 @@ R"(#define <interface_name>( code ) _Generic( (code), \
Code define_ver = untyped_str(token_fmt(
"name", var->Name
, "value", var->Value->Content
, "type", var->ValueType.to_string().to_str()
, "type", var->ValueType.to_strbuilder().to_str()
, "#define <name> (<type>) <value>\n"
));
src_parser.append(define_ver);

2
scripts/genccp.natstepfilter
View File

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