diff --git a/Readme.md b/Readme.md index d3ed9e7..b922e61 100644 --- a/Readme.md +++ b/Readme.md @@ -11,6 +11,14 @@ These build up a code AST to then serialize with a file builder, or can be trave This code base attempts follow the [handmade philosophy](https://handmade.network/manifesto). Its not meant to be a black box metaprogramming utility, it should be easy to integrate into a user's project domain. +## Langauge Bindings + +* [gencpp-odin](https://github.com/Ed94/gencpp-odin): Bindings for the odin programming language. + +## Utility Libraries + +* [UnrealGencpp](https://github.com/Ed94/UnrealGencpp): Setup as a plugin to integrate into Unreal Engine or Unreal Projects. + ## Documentation * [docs - General](./docs/Readme.md): Overview and additional docs diff --git a/base/Readme.md b/base/Readme.md index 9283ebe..242abf8 100644 --- a/base/Readme.md +++ b/base/Readme.md @@ -191,7 +191,7 @@ These require the following to be handled to the equivalent extent as the other 4. [ast.cpp](./components/ast.cpp): Need to review * `code_debug_str` * `code_is_equal` - * `code_to_strbuilder_ptr` + * `code_to_strbuilder_ref` * `code_validate_body` 5. [code_serialization.cpp](./components/code_serialization.cpp): Define serialization here. 6. [inlines.hpp](./components/inlines.hpp): Any inline definitions for the `struct Code` are defined here. diff --git a/base/auxiliary/builder.cpp b/base/auxiliary/builder.cpp index 02adda8..391f520 100644 --- a/base/auxiliary/builder.cpp +++ b/base/auxiliary/builder.cpp @@ -1,4 +1,4 @@ -#ifdef GEN_INTELLISENSE_DIRECTIVES +#ifdef INTELLISENSE_DIRECTIVES # include "builder.hpp" #endif diff --git a/base/auxiliary/builder.hpp b/base/auxiliary/builder.hpp index eb4b0bb..65d4d5b 100644 --- a/base/auxiliary/builder.hpp +++ b/base/auxiliary/builder.hpp @@ -1,4 +1,4 @@ -#ifdef GEN_INTELLISENSE_DIRECTIVES +#ifdef INTELLISENSE_DIRECTIVES # pragma once # include "helpers/push_ignores.inline.hpp" # include "components/header_start.hpp" diff --git a/base/auxiliary/gen_template.hpp b/base/auxiliary/gen_template.hpp index d64dcc2..04b5734 100644 --- a/base/auxiliary/gen_template.hpp +++ b/base/auxiliary/gen_template.hpp @@ -1,4 +1,4 @@ -#ifdef GEN_INTELLISENSE_DIRECTIVES +#ifdef INTELLISENSE_DIRECTIVES # pragma once # include "helpers/push_ignores.inline.hpp" # include "components/header_start.hpp" diff --git a/base/auxiliary/scanner.cpp b/base/auxiliary/scanner.cpp index 6cde239..de0fd7b 100644 --- a/base/auxiliary/scanner.cpp +++ b/base/auxiliary/scanner.cpp @@ -1,4 +1,4 @@ -#ifdef GEN_INTELLISENSE_DIRECTIVES +#ifdef INTELLISENSE_DIRECTIVES # include "scanner.hpp" #endif @@ -24,7 +24,7 @@ Code scan_file( char const* path ) file_read( & file, str, fsize ); strbuilder_get_header(str)->Length = fsize; - // Skip GEN_INTELLISENSE_DIRECTIVES preprocessor blocks + // Skip INTELLISENSE_DIRECTIVES preprocessor blocks // Its designed so that the directive should be the first thing in the file. // Anything that comes before it will also be omitted. { @@ -33,7 +33,7 @@ Code scan_file( char const* path ) #define move_fwd() do { ++ scanner; -- left; } while (0) const Str directive_start = txt( "ifdef" ); const Str directive_end = txt( "endif" ); - const Str def_intellisense = txt("GEN_INTELLISENSE_DIRECTIVES" ); + const Str def_intellisense = txt("INTELLISENSE_DIRECTIVES" ); bool found_directive = false; char const* scanner = (char const*)str; diff --git a/base/auxiliary/scanner.hpp b/base/auxiliary/scanner.hpp index 70f2ef7..72a57b3 100644 --- a/base/auxiliary/scanner.hpp +++ b/base/auxiliary/scanner.hpp @@ -1,4 +1,4 @@ -#ifdef GEN_INTELLISENSE_DIRECTIVES +#ifdef INTELLISENSE_DIRECTIVES # pragma once # include "helpers/push_ignores.inline.hpp" # include "components/header_start.hpp" diff --git a/base/base.cpp b/base/base.cpp index e62a7af..81433e4 100644 --- a/base/base.cpp +++ b/base/base.cpp @@ -30,7 +30,7 @@ int gen_main() gen::init( & ctx); CodeBody gen_component_header = def_global_body( args( - def_preprocess_cond( PreprocessCond_IfDef, txt("GEN_INTELLISENSE_DIRECTIVES") ), + def_preprocess_cond( PreprocessCond_IfDef, txt("INTELLISENSE_DIRECTIVES") ), pragma_once, def_include(txt("components/types.hpp")), preprocess_endif, diff --git a/base/components/ast.cpp b/base/components/ast.cpp index 55067bf..d8042b5 100644 --- a/base/components/ast.cpp +++ b/base/components/ast.cpp @@ -1,4 +1,4 @@ -#ifdef GEN_INTELLISENSE_DIRECTIVES +#ifdef INTELLISENSE_DIRECTIVES #pragma once #include "static_data.cpp" #endif @@ -379,11 +379,11 @@ Code code_duplicate(Code self) StrBuilder code_to_strbuilder(Code self) { StrBuilder result = strbuilder_make_str( _ctx->Allocator_Temp, txt("") ); - code_to_strbuilder_ptr( self, & result ); + code_to_strbuilder_ref( self, & result ); return result; } -void code_to_strbuilder_ptr( Code self, StrBuilder* result ) +void code_to_strbuilder_ref( Code self, StrBuilder* result ) { GEN_ASSERT(self != nullptr); local_persist thread_local diff --git a/base/components/ast.hpp b/base/components/ast.hpp index f81353a..2c9f9af 100644 --- a/base/components/ast.hpp +++ b/base/components/ast.hpp @@ -1,4 +1,4 @@ -#ifdef GEN_INTELLISENSE_DIRECTIVES +#ifdef INTELLISENSE_DIRECTIVES #pragma once #include "types.hpp" #include "gen/ecode.hpp" @@ -193,6 +193,7 @@ typedef AST_Stmt_If* CodeStmt_If; typedef AST_Stmt_For* CodeStmt_For; typedef AST_Stmt_Goto* CodeStmt_Goto; typedef AST_Stmt_Label* CodeStmt_Label; +typedef AST_Stmt_Lambda* CodeStmt_Lambda; typedef AST_Stmt_Switch* CodeStmt_Switch; typedef AST_Stmt_While* CodeStmt_While; #else @@ -208,6 +209,7 @@ struct CodeStmt_If; struct CodeStmt_For; struct CodeStmt_Goto; struct CodeStmt_Label; +struct CodeStmt_Lambda; struct CodeStmt_Switch; struct CodeStmt_While; #endif @@ -239,18 +241,18 @@ template< class Type> forceinline Type tmpl_cast( Code self ) { return * rcast( #pragma region Code C-Interface -GEN_API void code_append (Code code, Code other ); + void code_append (Code code, Code other ); GEN_API Str code_debug_str (Code code); GEN_API Code code_duplicate (Code code); -GEN_API Code* code_entry (Code code, u32 idx ); -GEN_API bool code_has_entries (Code code); -GEN_API bool code_is_body (Code code); + Code* code_entry (Code code, u32 idx ); + bool code_has_entries (Code code); + bool code_is_body (Code code); GEN_API bool code_is_equal (Code code, Code other); -GEN_API bool code_is_valid (Code code); -GEN_API void code_set_global (Code code); + bool code_is_valid (Code code); + void code_set_global (Code code); GEN_API StrBuilder code_to_strbuilder (Code self ); -GEN_API void code_to_strbuilder_ptr(Code self, StrBuilder* result ); -GEN_API Str code_type_str (Code self ); +GEN_API void code_to_strbuilder_ref(Code self, StrBuilder* result ); + Str code_type_str (Code self ); GEN_API bool code_validate_body (Code self ); #pragma endregion Code C-Interface @@ -287,7 +289,7 @@ struct Code 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 void to_strbuilder(StrBuilder& result) { return code_to_strbuilder_ref(* this, & result); } forceinline Str type_str() { return code_type_str(* this); } forceinline bool validate_body() { return code_validate_body(*this); } #endif @@ -399,7 +401,7 @@ struct AST Code Value; // Parameter, Variable }; union { - Code NextVar; // Variable; Possible way to handle comma separated variables declarations. ( , NextVar->Specs NextVar->Name NextVar->ArrExpr = NextVar->Value ) + Code NextVar; // Variable Code SuffixSpecs; // Typename, Function (Thanks Unreal) Code PostNameMacro; // Only used with parameters for specifically UE_REQUIRES (Thanks Unreal) }; diff --git a/base/components/ast_types.hpp b/base/components/ast_types.hpp index 54a5763..27bfae1 100644 --- a/base/components/ast_types.hpp +++ b/base/components/ast_types.hpp @@ -1,4 +1,4 @@ -#ifdef GEN_INTELLISENSE_DIRECTIVES +#ifdef INTELLISENSE_DIRECTIVES # pragma once # include "code_types.hpp" #endif @@ -227,7 +227,7 @@ struct AST_Enum Code Parent; CodeType Type; ModuleFlag ModuleFlags; - char _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ]; + char _PAD_UNUSED_[ sizeof(u32) ]; }; static_assert( sizeof(AST_Enum) == sizeof(AST), "ERROR: AST_Enum is not the same size as AST"); @@ -738,8 +738,8 @@ static_assert( sizeof(AST_PreprocessCond) == sizeof(AST), "ERROR: AST_Preprocess struct AST_Specifiers { Specifier ArrSpecs[ AST_ArrSpecs_Cap ]; - StrCached Name; CodeSpecifiers NextSpecs; + StrCached Name; Code Prev; Code Next; Token* Tok; @@ -1056,7 +1056,7 @@ struct AST_Typename CodeSpecifiers SpecsFuncSuffix; // Only used for function signatures }; }; - StrCached Name; + StrCached Name; Code Prev; Code Next; Token* Tok; @@ -1082,7 +1082,7 @@ struct AST_Typedef char _PAD_PROPERTIES_2_[ sizeof(AST*) * 3 ]; }; }; - StrCached Name; + StrCached Name; Code Prev; Code Next; Token* Tok; diff --git a/base/components/code_serialization.cpp b/base/components/code_serialization.cpp index f739202..9ec168b 100644 --- a/base/components/code_serialization.cpp +++ b/base/components/code_serialization.cpp @@ -1,23 +1,8 @@ -#ifdef GEN_INTELLISENSE_DIRECTIVES +#ifdef INTELLISENSE_DIRECTIVES #pragma once #include "ast.cpp" #endif -inline -StrBuilder attributes_to_strbuilder(CodeAttributes attributes) { - GEN_ASSERT(attributes); - char* raw = ccast(char*, str_duplicate( attributes->Content, _ctx->Allocator_Temp ).Ptr); - StrBuilder result = { raw }; - return result; -} - -inline -void attributes_to_strbuilder_ref(CodeAttributes attributes, StrBuilder* result) { - GEN_ASSERT(attributes); - GEN_ASSERT(result); - strbuilder_append_str(result, attributes->Content); -} - StrBuilder body_to_strbuilder(CodeBody body) { GEN_ASSERT(body); @@ -47,20 +32,6 @@ StrBuilder body_to_strbuilder(CodeBody body) return result; } -void body_to_strbuilder_ref( CodeBody body, StrBuilder* result ) -{ - GEN_ASSERT(body != nullptr); - GEN_ASSERT(result != nullptr); - Code curr = body->Front; - s32 left = body->NumEntries; - while ( left -- ) - { - code_to_strbuilder_ptr(curr, result); - // strbuilder_append_fmt( result, "%SB", code_to_strbuilder(curr) ); - ++curr; - } -} - void body_to_strbuilder_export( CodeBody body, StrBuilder* result ) { GEN_ASSERT(body != nullptr); @@ -71,7 +42,7 @@ void body_to_strbuilder_export( CodeBody body, StrBuilder* result ) s32 left = body->NumEntries; while ( left-- ) { - code_to_strbuilder_ptr(curr, result); + code_to_strbuilder_ref(curr, result); // strbuilder_append_fmt( result, "%SB", code_to_strbuilder(curr) ); ++curr; } @@ -79,23 +50,9 @@ void body_to_strbuilder_export( CodeBody body, StrBuilder* result ) strbuilder_append_fmt( result, "};\n" ); } -inline -StrBuilder comment_to_strbuilder(CodeComment comment) { - GEN_ASSERT(comment); - char* raw = ccast(char*, str_duplicate( comment->Content, _ctx->Allocator_Temp ).Ptr); - StrBuilder result = { raw }; - return result; -} - -inline -void comment_to_strbuilder_ref(CodeComment comment, StrBuilder* result) { - GEN_ASSERT(comment); - GEN_ASSERT(result); - strbuilder_append_str(result, comment->Content); -} - StrBuilder constructor_to_strbuilder(CodeConstructor self) { + GEN_ASSERT(self); StrBuilder result = strbuilder_make_reserve( _ctx->Allocator_Temp, 128 ); switch (self->Type) { @@ -111,6 +68,8 @@ StrBuilder constructor_to_strbuilder(CodeConstructor self) void constructor_to_strbuilder_def(CodeConstructor self, StrBuilder* result ) { + GEN_ASSERT(self); + GEN_ASSERT(result); Code ClassStructParent = self->Parent->Parent; if (ClassStructParent) { strbuilder_append_str( result, ClassStructParent->Name ); @@ -135,6 +94,8 @@ void constructor_to_strbuilder_def(CodeConstructor self, StrBuilder* result ) void constructor_to_strbuilder_fwd(CodeConstructor self, StrBuilder* result ) { + GEN_ASSERT(self); + GEN_ASSERT(result); Code ClassStructParent = self->Parent->Parent; if (ClassStructParent) { strbuilder_append_str( result, ClassStructParent->Name ); @@ -159,6 +120,7 @@ void constructor_to_strbuilder_fwd(CodeConstructor self, StrBuilder* result ) StrBuilder class_to_strbuilder( CodeClass self ) { + GEN_ASSERT(self); StrBuilder result = strbuilder_make_reserve( _ctx->Allocator_Temp, 512 ); switch ( self->Type ) { @@ -175,6 +137,7 @@ StrBuilder class_to_strbuilder( CodeClass self ) void class_to_strbuilder_def( CodeClass self, StrBuilder* result ) { GEN_ASSERT(self); + GEN_ASSERT(result); if ( bitfield_is_set( u32, self->ModuleFlags, ModuleFlag_Export )) strbuilder_append_str( result, txt("export ") ); @@ -189,7 +152,7 @@ void class_to_strbuilder_def( CodeClass self, StrBuilder* result ) if ( self->Name.Len ) strbuilder_append_str( result, self->Name ); - if (self->Specs && specifiers_has(self->Specs, Spec_Final) > -1) + if (self->Specs && specifiers_has(self->Specs, Spec_Final)) strbuilder_append_str(result, txt(" final")); if ( self->ParentType ) @@ -222,6 +185,7 @@ void class_to_strbuilder_def( CodeClass self, StrBuilder* result ) void class_to_strbuilder_fwd( CodeClass self, StrBuilder* result ) { GEN_ASSERT(self); + GEN_ASSERT(result); if ( bitfield_is_set( u32, self->ModuleFlags, ModuleFlag_Export )) strbuilder_append_str( result, txt("export ") ); @@ -241,13 +205,6 @@ void class_to_strbuilder_fwd( CodeClass self, StrBuilder* result ) } } -StrBuilder define_to_strbuilder(CodeDefine define) -{ - StrBuilder result = strbuilder_make_reserve( _ctx->Allocator_Temp, 512 ); - define_to_strbuilder_ref(define, & result); - return result; -} - void define_to_strbuilder_ref(CodeDefine define, StrBuilder* result ) { GEN_ASSERT(define); @@ -262,14 +219,6 @@ void define_to_strbuilder_ref(CodeDefine define, StrBuilder* result ) } } -StrBuilder define_params_to_strbuilder(CodeDefineParams params) -{ - GEN_ASSERT(params); - StrBuilder result = strbuilder_make_reserve( _ctx->Allocator_Temp, 128 ); - define_params_to_strbuilder_ref( params, & result ); - return result; -} - void define_params_to_strbuilder_ref(CodeDefineParams self, StrBuilder* result) { GEN_ASSERT(self); @@ -289,6 +238,7 @@ void define_params_to_strbuilder_ref(CodeDefineParams self, StrBuilder* result) StrBuilder destructor_to_strbuilder(CodeDestructor self) { + GEN_ASSERT(self); StrBuilder result = strbuilder_make_reserve( _ctx->Allocator_Temp, 128 ); switch ( self->Type ) { @@ -304,6 +254,8 @@ StrBuilder destructor_to_strbuilder(CodeDestructor self) void destructor_to_strbuilder_def(CodeDestructor self, StrBuilder* result ) { + GEN_ASSERT(self); + GEN_ASSERT(result); if ( self->Name.Len ) { strbuilder_append_fmt( result, "%S()", self->Name ); @@ -323,6 +275,8 @@ void destructor_to_strbuilder_def(CodeDestructor self, StrBuilder* result ) void destructor_to_strbuilder_fwd(CodeDestructor self, StrBuilder* result ) { + GEN_ASSERT(self); + GEN_ASSERT(result); if ( self->Specs ) { if ( specifiers_has(self->Specs, Spec_Virtual ) ) @@ -346,6 +300,7 @@ void destructor_to_strbuilder_fwd(CodeDestructor self, StrBuilder* result ) StrBuilder enum_to_strbuilder(CodeEnum self) { + GEN_ASSERT(self); StrBuilder result = strbuilder_make_reserve( _ctx->Allocator_Temp, 512 ); switch ( self->Type ) { @@ -367,6 +322,8 @@ StrBuilder enum_to_strbuilder(CodeEnum self) void enum_to_strbuilder_def(CodeEnum self, StrBuilder* result ) { + GEN_ASSERT(self); + GEN_ASSERT(result); if ( bitfield_is_set( u32, self->ModuleFlags, ModuleFlag_Export )) strbuilder_append_str( result, txt("export ") ); @@ -400,6 +357,8 @@ void enum_to_strbuilder_def(CodeEnum self, StrBuilder* result ) void enum_to_strbuilder_fwd(CodeEnum self, StrBuilder* result ) { + GEN_ASSERT(self); + GEN_ASSERT(result); if ( bitfield_is_set( u32, self->ModuleFlags, ModuleFlag_Export )) strbuilder_append_str( result, txt("export ") ); @@ -427,6 +386,8 @@ void enum_to_strbuilder_fwd(CodeEnum self, StrBuilder* result ) void enum_to_strbuilder_class_def(CodeEnum self, StrBuilder* result ) { + GEN_ASSERT(self); + GEN_ASSERT(result); if ( bitfield_is_set( u32, self->ModuleFlags, ModuleFlag_Export )) strbuilder_append_str( result, txt("export ") ); @@ -459,6 +420,8 @@ void enum_to_strbuilder_class_def(CodeEnum self, StrBuilder* result ) void enum_to_strbuilder_class_fwd(CodeEnum self, StrBuilder* result ) { + GEN_ASSERT(self); + GEN_ASSERT(result); if ( bitfield_is_set( u32, self->ModuleFlags, ModuleFlag_Export )) strbuilder_append_str( result, txt("export ") ); @@ -478,56 +441,9 @@ void enum_to_strbuilder_class_fwd(CodeEnum self, StrBuilder* result ) } } -StrBuilder exec_to_strbuilder(CodeExec exec) -{ - GEN_ASSERT(exec); - char* raw = ccast(char*, str_duplicate( exec->Content, _ctx->Allocator_Temp ).Ptr); - StrBuilder result = { raw }; - return 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_strbuilder(self->Body) ); - else - strbuilder_append_fmt( result, "extern \"%S\"\n{}\n", self->Name ); -} - -StrBuilder include_to_strbuilder(CodeInclude include) -{ - return strbuilder_fmt_buf( _ctx->Allocator_Temp, "#include %S\n", include->Content ); -} - -void include_to_strbuilder_ref( CodeInclude include, StrBuilder* result ) -{ - strbuilder_append_fmt( result, "#include %S\n", include->Content ); -} - -StrBuilder friend_to_strbuilder(CodeFriend self) -{ - StrBuilder result = strbuilder_make_reserve( _ctx->Allocator_Temp, 256 ); - friend_to_strbuilder_ref( self, & result ); - return result; -} - -void friend_to_strbuilder_ref(CodeFriend self, StrBuilder* result ) -{ - 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 ] != ';' ) - { - strbuilder_append_str( result, txt(";") ); - } - - if ( self->InlineCmt ) - strbuilder_append_fmt( result, " %S", self->InlineCmt->Content ); - else - strbuilder_append_str( result, txt("\n")); -} - StrBuilder fn_to_strbuilder(CodeFn self) { + GEN_ASSERT(self); StrBuilder result = strbuilder_make_reserve( _ctx->Allocator_Temp, 512 ); switch ( self->Type ) { @@ -543,6 +459,8 @@ StrBuilder fn_to_strbuilder(CodeFn self) void fn_to_strbuilder_def(CodeFn self, StrBuilder* result ) { + GEN_ASSERT(self); + GEN_ASSERT(result); if ( bitfield_is_set( u32, self->ModuleFlags, ModuleFlag_Export )) strbuilder_append_str( result, txt("export") ); @@ -600,6 +518,8 @@ void fn_to_strbuilder_def(CodeFn self, StrBuilder* result ) void fn_to_strbuilder_fwd(CodeFn self, StrBuilder* result ) { + GEN_ASSERT(self); + GEN_ASSERT(result); if ( bitfield_is_set( u32, self->ModuleFlags, ModuleFlag_Export )) strbuilder_append_str( result, txt("export ") ); @@ -649,9 +569,9 @@ void fn_to_strbuilder_fwd(CodeFn self, StrBuilder* result ) } } - if ( specifiers_has(self->Specs, Spec_Pure ) >= 0 ) + if ( specifiers_has(self->Specs, Spec_Pure ) ) strbuilder_append_str( result, txt(" = 0") ); - else if ( specifiers_has(self->Specs, Spec_Delete ) >= 0 ) + else if ( specifiers_has(self->Specs, Spec_Delete ) ) strbuilder_append_str( result, txt(" = delete") ); } @@ -668,15 +588,10 @@ void fn_to_strbuilder_fwd(CodeFn self, StrBuilder* result ) strbuilder_append_str( result, txt(";\n") ); } -StrBuilder module_to_strbuilder(CodeModule self) -{ - StrBuilder result = strbuilder_make_reserve( _ctx->Allocator_Temp, 64 ); - module_to_strbuilder_ref( self, & result ); - return result; -} - void module_to_strbuilder_ref(CodeModule self, StrBuilder* result ) { + GEN_ASSERT(self); + GEN_ASSERT(result); if (((scast(u32, ModuleFlag_Export) & scast(u32, self->ModuleFlags)) == scast(u32, ModuleFlag_Export))) strbuilder_append_str( result, txt("export ")); @@ -686,23 +601,9 @@ void module_to_strbuilder_ref(CodeModule self, StrBuilder* result ) strbuilder_append_fmt( result, "%S;\n", self->Name ); } -StrBuilder namespace_to_strbuilder(CodeNS self) -{ - StrBuilder result = strbuilder_make_reserve( _ctx->Allocator_Temp, 512 ); - namespace_to_strbuilder_ref( self, & result ); - return result; -} - -void namespace_to_strbuilder_ref(CodeNS self, StrBuilder* result ) -{ - if ( bitfield_is_set( 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_strbuilder(self->Body) ); -} - StrBuilder code_op_to_strbuilder(CodeOperator self) { + GEN_ASSERT(self); StrBuilder result = strbuilder_make_reserve( _ctx->Allocator_Temp, 512 ); switch ( self->Type ) { @@ -720,6 +621,8 @@ StrBuilder code_op_to_strbuilder(CodeOperator self) void code_op_to_strbuilder_def(CodeOperator self, StrBuilder* result ) { + GEN_ASSERT(self); + GEN_ASSERT(result); if ( bitfield_is_set( u32, self->ModuleFlags, ModuleFlag_Export )) strbuilder_append_str( result, txt("export ") ); @@ -774,6 +677,8 @@ void code_op_to_strbuilder_def(CodeOperator self, StrBuilder* result ) void code_op_to_strbuilder_fwd(CodeOperator self, StrBuilder* result ) { + GEN_ASSERT(self); + GEN_ASSERT(result); if ( bitfield_is_set( u32, self->ModuleFlags, ModuleFlag_Export )) strbuilder_append_str( result, txt("export ") ); @@ -825,6 +730,7 @@ void code_op_to_strbuilder_fwd(CodeOperator self, StrBuilder* result ) StrBuilder opcast_to_strbuilder(CodeOpCast self) { + GEN_ASSERT(self); StrBuilder result = strbuilder_make_reserve( _ctx->Allocator_Temp, 128 ); switch ( self->Type ) { @@ -840,6 +746,8 @@ StrBuilder opcast_to_strbuilder(CodeOpCast self) void opcast_to_strbuilder_def(CodeOpCast self, StrBuilder* result ) { + GEN_ASSERT(self); + GEN_ASSERT(result); if ( self->Specs ) { for ( Specifier* spec = begin_CodeSpecifiers(self->Specs); spec != end_CodeSpecifiers(self->Specs); spec = next_CodeSpecifiers(self->Specs, spec) ) @@ -877,6 +785,8 @@ void opcast_to_strbuilder_def(CodeOpCast self, StrBuilder* result ) void opcast_to_strbuilder_fwd(CodeOpCast self, StrBuilder* result ) { + GEN_ASSERT(self); + GEN_ASSERT(result); if ( self->Specs ) { for ( Specifier* spec = begin_CodeSpecifiers(self->Specs); spec != end_CodeSpecifiers(self->Specs); spec = next_CodeSpecifiers(self->Specs, spec) ) @@ -912,14 +822,6 @@ void opcast_to_strbuilder_fwd(CodeOpCast self, StrBuilder* result ) strbuilder_append_fmt( result, "operator %SB();\n", typename_to_strbuilder(self->ValueType) ); } -StrBuilder params_to_strbuilder(CodeParams self) -{ - GEN_ASSERT(self); - StrBuilder result = strbuilder_make_reserve( _ctx->Allocator_Temp, 128 ); - params_to_strbuilder_ref( self, & result ); - return result; -} - void params_to_strbuilder_ref( CodeParams self, StrBuilder* result ) { GEN_ASSERT(self); @@ -987,62 +889,6 @@ StrBuilder preprocess_to_strbuilder(CodePreprocessCond self) return result; } -void preprocess_to_strbuilder_if(CodePreprocessCond cond, StrBuilder* result ) -{ - GEN_ASSERT(cond); - strbuilder_append_fmt( result, "#if %S", cond->Content ); -} - -void preprocess_to_strbuilder_ifdef(CodePreprocessCond cond, StrBuilder* result ) -{ - GEN_ASSERT(cond); - strbuilder_append_fmt( result, "#ifdef %S\n", cond->Content ); -} - -void preprocess_to_strbuilder_ifndef(CodePreprocessCond cond, StrBuilder* result ) -{ - GEN_ASSERT(cond); - strbuilder_append_fmt( result, "#ifndef %S", cond->Content ); -} - -void preprocess_to_strbuilder_elif(CodePreprocessCond cond, StrBuilder* result ) -{ - GEN_ASSERT(cond); - strbuilder_append_fmt( result, "#elif %S\n", cond->Content ); -} - -void preprocess_to_strbuilder_else(CodePreprocessCond cond, StrBuilder* result ) -{ - GEN_ASSERT(cond); - strbuilder_append_str( result, txt("#else\n") ); -} - -void preprocess_to_strbuilder_endif(CodePreprocessCond cond, StrBuilder* result ) -{ - GEN_ASSERT(cond); - strbuilder_append_str( result, txt("#endif\n") ); -} - -StrBuilder pragma_to_strbuilder(CodePragma self) -{ - GEN_ASSERT(self); - StrBuilder result = strbuilder_make_reserve( _ctx->Allocator_Temp, 256 ); - pragma_to_strbuilder_ref( self, & result ); - return result; -} - -void pragma_to_strbuilder_ref(CodePragma self, StrBuilder* result ) -{ - strbuilder_append_fmt( result, "#pragma %S\n", self->Content ); -} - -StrBuilder specifiers_to_strbuilder(CodeSpecifiers self) -{ - StrBuilder result = strbuilder_make_reserve( _ctx->Allocator_Temp, 64 ); - specifiers_to_strbuilder_ref( self, & result ); - return result; -} - void specifiers_to_strbuilder_ref( CodeSpecifiers self, StrBuilder* result ) { GEN_ASSERT(self); @@ -1155,14 +1001,6 @@ void struct_to_strbuilder_fwd( CodeStruct self, StrBuilder* result ) } } -StrBuilder template_to_strbuilder(CodeTemplate self) -{ - GEN_ASSERT(self); - StrBuilder result = strbuilder_make_reserve( _ctx->Allocator_Temp, 1024 ); - template_to_strbuilder_ref( self, & result ); - return result; -} - void template_to_strbuilder_ref(CodeTemplate self, StrBuilder* result ) { GEN_ASSERT(self); @@ -1176,15 +1014,10 @@ void template_to_strbuilder_ref(CodeTemplate self, StrBuilder* result ) strbuilder_append_fmt( result, "template<>\n%SB", code_to_strbuilder(self->Declaration) ); } -StrBuilder typedef_to_strbuilder(CodeTypedef self) -{ - StrBuilder result = strbuilder_make_reserve( _ctx->Allocator_Temp, 128 ); - typedef_to_strbuilder_ref( self, & result ); - return result; -} - void typedef_to_strbuilder_ref(CodeTypedef self, StrBuilder* result ) { + GEN_ASSERT(self); + GEN_ASSERT(result); if ( bitfield_is_set( u32, self->ModuleFlags, ModuleFlag_Export )) strbuilder_append_str( result, txt("export ") ); @@ -1218,15 +1051,10 @@ void typedef_to_strbuilder_ref(CodeTypedef self, StrBuilder* result ) strbuilder_append_str( result, txt("\n")); } -StrBuilder typename_to_strbuilder(CodeTypename self) -{ - StrBuilder result = strbuilder_make_str( _ctx->Allocator_Temp, txt("") ); - typename_to_strbuilder_ref( self, & result ); - return result; -} - void typename_to_strbuilder_ref(CodeTypename self, StrBuilder* result ) { + GEN_ASSERT(self); + GEN_ASSERT(result); #if defined(GEN_USE_NEW_TYPENAME_PARSING) if ( self->ReturnType && self->Params ) { @@ -1283,6 +1111,7 @@ void typename_to_strbuilder_ref(CodeTypename self, StrBuilder* result ) StrBuilder union_to_strbuilder(CodeUnion self) { + GEN_ASSERT(self); StrBuilder result = strbuilder_make_reserve( _ctx->Allocator_Temp, 512 ); switch ( self->Type ) { @@ -1298,6 +1127,8 @@ StrBuilder union_to_strbuilder(CodeUnion self) void union_to_strbuilder_def(CodeUnion self, StrBuilder* result ) { + GEN_ASSERT(self); + GEN_ASSERT(result); if ( bitfield_is_set( u32, self->ModuleFlags, ModuleFlag_Export )) strbuilder_append_str( result, txt("export ") ); @@ -1346,22 +1177,6 @@ void union_to_strbuilder_fwd(CodeUnion self, StrBuilder* result ) strbuilder_append_str( result, txt(";\n")); } -StrBuilder using_to_strbuilder(CodeUsing self) -{ - GEN_ASSERT(self); - StrBuilder result = strbuilder_make_reserve( _ctx->Allocator_Temp, 128 ); - switch ( self->Type ) - { - case CT_Using: - using_to_strbuilder_ref( self, & result ); - break; - case CT_Using_Namespace: - using_to_strbuilder_ns( self, & result ); - break; - } - return result; -} - void using_to_strbuilder_ref(CodeUsing self, StrBuilder* result ) { GEN_ASSERT(self); @@ -1399,26 +1214,6 @@ void using_to_strbuilder_ref(CodeUsing self, StrBuilder* result ) strbuilder_append_str( result, txt("\n")); } -inline -void using_to_strbuilder_ns(CodeUsing self, StrBuilder* result ) -{ - GEN_ASSERT(self); - GEN_ASSERT(result); - if ( self->InlineCmt ) - strbuilder_append_fmt( result, "using namespace $SC; %S", self->Name, self->InlineCmt->Content ); - else - strbuilder_append_fmt( result, "using namespace %S;\n", self->Name ); -} - -inline -StrBuilder var_to_strbuilder(CodeVar self) -{ - GEN_ASSERT(self); - StrBuilder result = strbuilder_make_reserve( _ctx->Allocator_Temp, 256 ); - var_to_strbuilder_ref( self, & result ); - return result; -} - neverinline void var_to_strbuilder_ref(CodeVar self, StrBuilder* result ) { diff --git a/base/components/code_types.hpp b/base/components/code_types.hpp index 65c7254..212cff8 100644 --- a/base/components/code_types.hpp +++ b/base/components/code_types.hpp @@ -1,4 +1,4 @@ -#ifdef GEN_INTELLISENSE_DIRECTIVES +#ifdef INTELLISENSE_DIRECTIVES #pragma once #include "ast.hpp" #endif @@ -20,58 +20,59 @@ GEN_API void body_append ( CodeBody body, Code other ); GEN_API void body_append_body ( CodeBody body, CodeBody other ); GEN_API StrBuilder body_to_strbuilder ( CodeBody body ); -GEN_API void body_to_strbuilder_ref ( CodeBody body, StrBuilder* result ); + void body_to_strbuilder_ref ( CodeBody body, StrBuilder* result ); GEN_API void body_to_strbuilder_export( CodeBody body, StrBuilder* result ); -GEN_API Code begin_CodeBody( CodeBody body); -GEN_API Code end_CodeBody ( CodeBody body ); -GEN_API Code next_CodeBody ( CodeBody body, Code entry_iter ); +Code begin_CodeBody( CodeBody body); +Code end_CodeBody ( CodeBody body ); +Code next_CodeBody ( CodeBody body, Code entry_iter ); -GEN_API void class_add_interface ( CodeClass self, CodeTypename interface ); + void class_add_interface ( CodeClass self, CodeTypename interface ); GEN_API StrBuilder class_to_strbuilder ( CodeClass self ); GEN_API void class_to_strbuilder_def( CodeClass self, StrBuilder* result ); GEN_API void class_to_strbuilder_fwd( CodeClass self, StrBuilder* result ); -GEN_API void define_params_append (CodeDefineParams appendee, CodeDefineParams other ); -GEN_API CodeDefineParams define_params_get (CodeDefineParams params, s32 idx); -GEN_API bool define_params_has_entries (CodeDefineParams params ); -GEN_API StrBuilder define_params_to_strbuilder (CodeDefineParams params ); + void define_params_append (CodeDefineParams appendee, CodeDefineParams other ); + CodeDefineParams define_params_get (CodeDefineParams params, s32 idx); + bool define_params_has_entries (CodeDefineParams params ); + StrBuilder define_params_to_strbuilder (CodeDefineParams params ); GEN_API void define_params_to_strbuilder_ref(CodeDefineParams params, StrBuilder* result ); -GEN_API CodeDefineParams begin_CodeDefineParams(CodeDefineParams params); -GEN_API CodeDefineParams end_CodeDefineParams (CodeDefineParams params); -GEN_API CodeDefineParams next_CodeDefineParams (CodeDefineParams params, CodeDefineParams entry_iter); +CodeDefineParams begin_CodeDefineParams(CodeDefineParams params); +CodeDefineParams end_CodeDefineParams (CodeDefineParams params); +CodeDefineParams next_CodeDefineParams (CodeDefineParams params, CodeDefineParams entry_iter); -GEN_API void params_append (CodeParams appendee, CodeParams other ); -GEN_API CodeParams params_get (CodeParams params, s32 idx); -GEN_API bool params_has_entries (CodeParams params ); -GEN_API StrBuilder params_to_strbuilder (CodeParams params ); + void params_append (CodeParams appendee, CodeParams other ); + CodeParams params_get (CodeParams params, s32 idx); + bool params_has_entries (CodeParams params ); + StrBuilder params_to_strbuilder (CodeParams params ); GEN_API void params_to_strbuilder_ref(CodeParams params, StrBuilder* result ); -GEN_API CodeParams begin_CodeParams(CodeParams params); -GEN_API CodeParams end_CodeParams (CodeParams params); -GEN_API CodeParams next_CodeParams (CodeParams params, CodeParams entry_iter); +CodeParams begin_CodeParams(CodeParams params); +CodeParams end_CodeParams (CodeParams params); +CodeParams next_CodeParams (CodeParams params, CodeParams entry_iter); -GEN_API bool specifiers_append (CodeSpecifiers specifiers, Specifier spec); -GEN_API s32 specifiers_has (CodeSpecifiers specifiers, Specifier spec); -GEN_API s32 specifiers_remove (CodeSpecifiers specifiers, Specifier to_remove ); -GEN_API StrBuilder specifiers_to_strbuilder (CodeSpecifiers specifiers); + bool specifiers_append (CodeSpecifiers specifiers, Specifier spec); + bool specifiers_has (CodeSpecifiers specifiers, Specifier spec); + s32 specifiers_index_of (CodeSpecifiers specifiers, Specifier spec); + s32 specifiers_remove (CodeSpecifiers specifiers, Specifier to_remove ); + StrBuilder specifiers_to_strbuilder (CodeSpecifiers specifiers); GEN_API void specifiers_to_strbuilder_ref(CodeSpecifiers specifiers, StrBuilder* result); -GEN_API Specifier* begin_CodeSpecifiers(CodeSpecifiers specifiers); -GEN_API Specifier* end_CodeSpecifiers (CodeSpecifiers specifiers); -GEN_API Specifier* next_CodeSpecifiers (CodeSpecifiers specifiers, Specifier* spec_iter); +Specifier* begin_CodeSpecifiers(CodeSpecifiers specifiers); +Specifier* end_CodeSpecifiers (CodeSpecifiers specifiers); +Specifier* next_CodeSpecifiers (CodeSpecifiers specifiers, Specifier* spec_iter); -GEN_API void struct_add_interface (CodeStruct self, CodeTypename interface); + void struct_add_interface (CodeStruct self, CodeTypename interface); GEN_API StrBuilder struct_to_strbuilder (CodeStruct self); GEN_API void struct_to_strbuilder_fwd(CodeStruct self, StrBuilder* result); GEN_API void struct_to_strbuilder_def(CodeStruct self, StrBuilder* result); -GEN_API StrBuilder attributes_to_strbuilder (CodeAttributes attributes); -GEN_API void attributes_to_strbuilder_ref(CodeAttributes attributes, StrBuilder* result); + StrBuilder attributes_to_strbuilder (CodeAttributes attributes); + void attributes_to_strbuilder_ref(CodeAttributes attributes, StrBuilder* result); -GEN_API StrBuilder comment_to_strbuilder (CodeComment comment ); -GEN_API void comment_to_strbuilder_ref(CodeComment comment, StrBuilder* result ); + StrBuilder comment_to_strbuilder (CodeComment comment ); + void comment_to_strbuilder_ref(CodeComment comment, StrBuilder* result ); GEN_API StrBuilder constructor_to_strbuilder (CodeConstructor constructor); GEN_API void constructor_to_strbuilder_def(CodeConstructor constructor, StrBuilder* result ); @@ -90,66 +91,68 @@ GEN_API void enum_to_strbuilder_fwd (CodeEnum self, StrBuilder* resul GEN_API void enum_to_strbuilder_class_def(CodeEnum self, StrBuilder* result ); GEN_API void enum_to_strbuilder_class_fwd(CodeEnum self, StrBuilder* result ); -GEN_API StrBuilder exec_to_strbuilder (CodeExec exec); -GEN_API void exec_to_strbuilder_ref(CodeExec exec, StrBuilder* result); + StrBuilder exec_to_strbuilder (CodeExec exec); + void exec_to_strbuilder_ref(CodeExec exec, StrBuilder* result); -GEN_API void extern_to_strbuilder(CodeExtern self, StrBuilder* result); + void extern_to_strbuilder(CodeExtern self, StrBuilder* result); -GEN_API StrBuilder include_to_strbuilder (CodeInclude self); -GEN_API void include_to_strbuilder_ref(CodeInclude self, StrBuilder* result); + StrBuilder include_to_strbuilder (CodeInclude self); + void include_to_strbuilder_ref(CodeInclude self, StrBuilder* result); -GEN_API StrBuilder friend_to_strbuilder (CodeFriend self); -GEN_API void friend_to_strbuilder_ref(CodeFriend self, StrBuilder* result); + StrBuilder friend_to_strbuilder (CodeFriend self); + void friend_to_strbuilder_ref(CodeFriend self, StrBuilder* result); GEN_API StrBuilder fn_to_strbuilder (CodeFn self); GEN_API void fn_to_strbuilder_def(CodeFn self, StrBuilder* result); GEN_API void fn_to_strbuilder_fwd(CodeFn self, StrBuilder* result); -GEN_API StrBuilder module_to_strbuilder (CodeModule self); + StrBuilder module_to_strbuilder (CodeModule self); GEN_API void module_to_strbuilder_ref(CodeModule self, StrBuilder* result); -GEN_API StrBuilder namespace_to_strbuilder (CodeNS self); -GEN_API void namespace_to_strbuilder_ref(CodeNS self, StrBuilder* result); + StrBuilder namespace_to_strbuilder (CodeNS self); + void namespace_to_strbuilder_ref(CodeNS self, StrBuilder* result); GEN_API StrBuilder code_op_to_strbuilder (CodeOperator self); GEN_API void code_op_to_strbuilder_fwd(CodeOperator self, StrBuilder* result ); GEN_API void code_op_to_strbuilder_def(CodeOperator self, StrBuilder* result ); -GEN_API StrBuilder opcast_to_strbuilder (CodeOpCast op_cast ); +GEN_API StrBuilder opcast_to_strbuilder (CodeOpCast op_cast ); GEN_API void opcast_to_strbuilder_def(CodeOpCast op_cast, StrBuilder* result ); GEN_API void opcast_to_strbuilder_fwd(CodeOpCast op_cast, StrBuilder* result ); -GEN_API StrBuilder pragma_to_strbuilder (CodePragma self); -GEN_API void pragma_to_strbuilder_ref(CodePragma self, StrBuilder* result); + StrBuilder pragma_to_strbuilder (CodePragma self); + void pragma_to_strbuilder_ref(CodePragma self, StrBuilder* result); GEN_API StrBuilder preprocess_to_strbuilder (CodePreprocessCond cond); -GEN_API void preprocess_to_strbuilder_if (CodePreprocessCond cond, StrBuilder* result ); -GEN_API void preprocess_to_strbuilder_ifdef (CodePreprocessCond cond, StrBuilder* result ); -GEN_API void preprocess_to_strbuilder_ifndef(CodePreprocessCond cond, StrBuilder* result ); -GEN_API void preprocess_to_strbuilder_elif (CodePreprocessCond cond, StrBuilder* result ); -GEN_API void preprocess_to_strbuilder_else (CodePreprocessCond cond, StrBuilder* result ); -GEN_API void preprocess_to_strbuilder_endif (CodePreprocessCond cond, StrBuilder* result ); + void preprocess_to_strbuilder_if (CodePreprocessCond cond, StrBuilder* result ); + void preprocess_to_strbuilder_ifdef (CodePreprocessCond cond, StrBuilder* result ); + void preprocess_to_strbuilder_ifndef(CodePreprocessCond cond, StrBuilder* result ); + void preprocess_to_strbuilder_elif (CodePreprocessCond cond, StrBuilder* result ); + void preprocess_to_strbuilder_else (CodePreprocessCond cond, StrBuilder* result ); + void preprocess_to_strbuilder_endif (CodePreprocessCond cond, StrBuilder* result ); -GEN_API StrBuilder template_to_strbuilder (CodeTemplate self); + StrBuilder template_to_strbuilder (CodeTemplate self); GEN_API void template_to_strbuilder_ref(CodeTemplate self, StrBuilder* result); -GEN_API StrBuilder typename_to_strbuilder (CodeTypename self); -GEN_API void typename_to_strbuilder_ref(CodeTypename self, StrBuilder* result); - -GEN_API StrBuilder typedef_to_strbuilder (CodeTypedef self); + StrBuilder typedef_to_strbuilder (CodeTypedef self); GEN_API void typedef_to_strbuilder_ref(CodeTypedef self, StrBuilder* result ); + StrBuilder typename_to_strbuilder (CodeTypename self); +GEN_API void typename_to_strbuilder_ref(CodeTypename self, StrBuilder* result); + GEN_API StrBuilder union_to_strbuilder (CodeUnion self); GEN_API void union_to_strbuilder_def(CodeUnion self, StrBuilder* result); GEN_API void union_to_strbuilder_fwd(CodeUnion self, StrBuilder* result); -GEN_API StrBuilder using_to_strbuilder (CodeUsing op_cast ); + StrBuilder using_to_strbuilder (CodeUsing op_cast ); GEN_API void using_to_strbuilder_ref(CodeUsing op_cast, StrBuilder* result ); -GEN_API void using_to_strbuilder_ns (CodeUsing op_cast, StrBuilder* result ); + void using_to_strbuilder_ns (CodeUsing op_cast, StrBuilder* result ); -GEN_API StrBuilder var_to_strbuilder (CodeVar self); + StrBuilder var_to_strbuilder (CodeVar self); GEN_API void var_to_strbuilder_ref(CodeVar self, StrBuilder* result); +// TODO(Ed): Move C-Interface inlines here... + #pragma endregion Code Type C-Interface #if GEN_COMPILER_CPP diff --git a/base/components/constants.hpp b/base/components/constants.hpp new file mode 100644 index 0000000..0b4cd62 --- /dev/null +++ b/base/components/constants.hpp @@ -0,0 +1,85 @@ +#ifdef INTELLISENSE_DIRECTIVES +# pragma once +# include "interface.hpp" +#endif + +#pragma region Constants +// Predefined typename codes. Are set to readonly and are setup during gen::init() + +GEN_API extern Macro enum_underlying_macro; + +GEN_API extern Code access_public; +GEN_API extern Code access_protected; +GEN_API extern Code access_private; + +GEN_API extern CodeAttributes attrib_api_export; +GEN_API extern CodeAttributes attrib_api_import; + +GEN_API extern Code module_global_fragment; +GEN_API extern Code module_private_fragment; + +GEN_API extern Code fmt_newline; + +GEN_API extern CodePragma pragma_once; + +GEN_API extern CodeParams param_varadic; + +GEN_API extern CodePreprocessCond preprocess_else; +GEN_API extern CodePreprocessCond preprocess_endif; + +GEN_API extern CodeSpecifiers spec_const; +GEN_API extern CodeSpecifiers spec_consteval; +GEN_API extern CodeSpecifiers spec_constexpr; +GEN_API extern CodeSpecifiers spec_constinit; +GEN_API extern CodeSpecifiers spec_extern_linkage; +GEN_API extern CodeSpecifiers spec_final; +GEN_API extern CodeSpecifiers spec_forceinline; +GEN_API extern CodeSpecifiers spec_global; +GEN_API extern CodeSpecifiers spec_inline; +GEN_API extern CodeSpecifiers spec_internal_linkage; +GEN_API extern CodeSpecifiers spec_local_persist; +GEN_API extern CodeSpecifiers spec_mutable; +GEN_API extern CodeSpecifiers spec_neverinline; +GEN_API extern CodeSpecifiers spec_noexcept; +GEN_API extern CodeSpecifiers spec_override; +GEN_API extern CodeSpecifiers spec_ptr; +GEN_API extern CodeSpecifiers spec_pure; +GEN_API extern CodeSpecifiers spec_ref; +GEN_API extern CodeSpecifiers spec_register; +GEN_API extern CodeSpecifiers spec_rvalue; +GEN_API extern CodeSpecifiers spec_static_member; +GEN_API extern CodeSpecifiers spec_thread_local; +GEN_API extern CodeSpecifiers spec_virtual; +GEN_API extern CodeSpecifiers spec_volatile; + +GEN_API extern CodeTypename t_empty; // Used with varaidc parameters. (Exposing just in case its useful for another circumstance) +GEN_API extern CodeTypename t_auto; +GEN_API extern CodeTypename t_void; +GEN_API extern CodeTypename t_int; +GEN_API extern CodeTypename t_bool; +GEN_API extern CodeTypename t_char; +GEN_API extern CodeTypename t_wchar_t; +GEN_API extern CodeTypename t_class; +GEN_API extern CodeTypename t_typename; + +#ifdef GEN_DEFINE_LIBRARY_CODE_CONSTANTS + GEN_API extern CodeTypename t_b32; + + GEN_API extern CodeTypename t_s8; + GEN_API extern CodeTypename t_s16; + GEN_API extern CodeTypename t_s32; + GEN_API extern CodeTypename t_s64; + + GEN_API extern CodeTypename t_u8; + GEN_API extern CodeTypename t_u16; + GEN_API extern CodeTypename t_u32; + GEN_API extern CodeTypename t_u64; + + GEN_API extern CodeTypename t_ssize; + GEN_API extern CodeTypename t_usize; + + GEN_API extern CodeTypename t_f32; + GEN_API extern CodeTypename t_f64; +#endif + +#pragma endregion Constants diff --git a/base/components/gen/ast_inlines.hpp b/base/components/gen/ast_inlines.hpp index 435fa79..7ec01aa 100644 --- a/base/components/gen/ast_inlines.hpp +++ b/base/components/gen/ast_inlines.hpp @@ -1,4 +1,4 @@ -#ifdef GEN_INTELLISENSE_DIRECTIVES +#ifdef INTELLISENSE_DIRECTIVES #pragma once #include "components/types.hpp" #endif diff --git a/base/components/gen/ecodetypes.hpp b/base/components/gen/ecodetypes.hpp index 5d49068..139e615 100644 --- a/base/components/gen/ecodetypes.hpp +++ b/base/components/gen/ecodetypes.hpp @@ -1,4 +1,4 @@ -#ifdef GEN_INTELLISENSE_DIRECTIVES +#ifdef INTELLISENSE_DIRECTIVES #pragma once #include "components/types.hpp" #endif diff --git a/base/components/gen/eoperator.hpp b/base/components/gen/eoperator.hpp index e13688a..71bd68d 100644 --- a/base/components/gen/eoperator.hpp +++ b/base/components/gen/eoperator.hpp @@ -1,4 +1,4 @@ -#ifdef GEN_INTELLISENSE_DIRECTIVES +#ifdef INTELLISENSE_DIRECTIVES #pragma once #include "components/types.hpp" #endif diff --git a/base/components/gen/especifier.hpp b/base/components/gen/especifier.hpp index 201b895..e03e9d4 100644 --- a/base/components/gen/especifier.hpp +++ b/base/components/gen/especifier.hpp @@ -1,4 +1,4 @@ -#ifdef GEN_INTELLISENSE_DIRECTIVES +#ifdef INTELLISENSE_DIRECTIVES #pragma once #include "components/types.hpp" #endif diff --git a/base/components/gen/etoktype.hpp b/base/components/gen/etoktype.hpp index 747f834..1b2c17c 100644 --- a/base/components/gen/etoktype.hpp +++ b/base/components/gen/etoktype.hpp @@ -1,4 +1,4 @@ -#ifdef GEN_INTELLISENSE_DIRECTIVES +#ifdef INTELLISENSE_DIRECTIVES #pragma once #include "components/types.hpp" #endif diff --git a/base/components/header_end.hpp b/base/components/header_end.hpp index b1ae614..e69de29 100644 --- a/base/components/header_end.hpp +++ b/base/components/header_end.hpp @@ -1,88 +0,0 @@ -#ifdef GEN_INTELLISENSE_DIRECTIVES -#pragma once -#include "inlines.hpp" -#include "gen/ast_inlines.hpp" -#endif - -#pragma region Constants - -GEN_API extern Macro enum_underlying_macro; - -GEN_API extern Code access_public; -GEN_API extern Code access_protected; -GEN_API extern Code access_private; - -GEN_API extern CodeAttributes attrib_api_export; -GEN_API extern CodeAttributes attrib_api_import; - -GEN_API extern Code module_global_fragment; -GEN_API extern Code module_private_fragment; - -GEN_API extern Code fmt_newline; - -GEN_API extern CodePragma pragma_once; - -GEN_API extern CodeParams param_varadic; - -GEN_API extern CodePreprocessCond preprocess_else; -GEN_API extern CodePreprocessCond preprocess_endif; - -GEN_API extern CodeSpecifiers spec_const; -GEN_API extern CodeSpecifiers spec_consteval; -GEN_API extern CodeSpecifiers spec_constexpr; -GEN_API extern CodeSpecifiers spec_constinit; -GEN_API extern CodeSpecifiers spec_extern_linkage; -GEN_API extern CodeSpecifiers spec_final; -GEN_API extern CodeSpecifiers spec_forceinline; -GEN_API extern CodeSpecifiers spec_global; -GEN_API extern CodeSpecifiers spec_inline; -GEN_API extern CodeSpecifiers spec_internal_linkage; -GEN_API extern CodeSpecifiers spec_local_persist; -GEN_API extern CodeSpecifiers spec_mutable; -GEN_API extern CodeSpecifiers spec_neverinline; -GEN_API extern CodeSpecifiers spec_noexcept; -GEN_API extern CodeSpecifiers spec_override; -GEN_API extern CodeSpecifiers spec_ptr; -GEN_API extern CodeSpecifiers spec_pure; -GEN_API extern CodeSpecifiers spec_ref; -GEN_API extern CodeSpecifiers spec_register; -GEN_API extern CodeSpecifiers spec_rvalue; -GEN_API extern CodeSpecifiers spec_static_member; -GEN_API extern CodeSpecifiers spec_thread_local; -GEN_API extern CodeSpecifiers spec_virtual; -GEN_API extern CodeSpecifiers spec_volatile; - -GEN_API extern CodeTypename t_empty; // Used with varaidc parameters. (Exposing just in case its useful for another circumstance) -GEN_API extern CodeTypename t_auto; -GEN_API extern CodeTypename t_void; -GEN_API extern CodeTypename t_int; -GEN_API extern CodeTypename t_bool; -GEN_API extern CodeTypename t_char; -GEN_API extern CodeTypename t_wchar_t; -GEN_API extern CodeTypename t_class; -GEN_API extern CodeTypename t_typename; - -#ifdef GEN_DEFINE_LIBRARY_CODE_CONSTANTS - // Predefined typename codes. Are set to readonly and are setup during gen::init() - GEN_API extern Context* _ctx; - - GEN_API extern CodeTypename t_b32; - - GEN_API extern CodeTypename t_s8; - GEN_API extern CodeTypename t_s16; - GEN_API extern CodeTypename t_s32; - GEN_API extern CodeTypename t_s64; - - GEN_API extern CodeTypename t_u8; - GEN_API extern CodeTypename t_u16; - GEN_API extern CodeTypename t_u32; - GEN_API extern CodeTypename t_u64; - - GEN_API extern CodeTypename t_ssize; - GEN_API extern CodeTypename t_usize; - - GEN_API extern CodeTypename t_f32; - GEN_API extern CodeTypename t_f64; -#endif - -#pragma endregion Constants diff --git a/base/components/header_start.hpp b/base/components/header_start.hpp index 2a1754f..30a2b50 100644 --- a/base/components/header_start.hpp +++ b/base/components/header_start.hpp @@ -15,7 +15,7 @@ | \_____|\___}_l |_|\___} ,__/| ,__/ (_____/ \__\__/_|\__, |\___}\__,_l | | | | | | __} | | | l_l l_l {___/ | - ! ----------------------------------------------------------------------- VERSION: v0.23-Alpha | + ! ----------------------------------------------------------------------- VERSION: v0.25-Alpha | ! ============================================================================================ | ! WARNING: THIS IS AN ALPHA VERSION OF THE LIBRARY, USE AT YOUR OWN DISCRETION | ! NEVER DO CODE GENERATION WITHOUT AT LEAST HAVING CONTENT IN A CODEBASE UNDER VERSION CONTROL | diff --git a/base/components/inlines.hpp b/base/components/inlines.hpp index 87e2710..5bf6bf5 100644 --- a/base/components/inlines.hpp +++ b/base/components/inlines.hpp @@ -1,8 +1,318 @@ -#ifdef GEN_INTELLISENSE_DIRECTIVES +#ifdef INTELLISENSE_DIRECTIVES #pragma once #include "interface.hpp" #endif +#pragma region Serialization +inline +StrBuilder attributes_to_strbuilder(CodeAttributes attributes) { + GEN_ASSERT(attributes); + char* raw = ccast(char*, str_duplicate( attributes->Content, get_context()->Allocator_Temp ).Ptr); + StrBuilder result = { raw }; + return result; +} + +inline +void attributes_to_strbuilder_ref(CodeAttributes attributes, StrBuilder* result) { + GEN_ASSERT(attributes); + GEN_ASSERT(result); + strbuilder_append_str(result, attributes->Content); +} + +inline +StrBuilder comment_to_strbuilder(CodeComment comment) { + GEN_ASSERT(comment); + char* raw = ccast(char*, str_duplicate( comment->Content, get_context()->Allocator_Temp ).Ptr); + StrBuilder result = { raw }; + return result; +} + +inline +void body_to_strbuilder_ref( CodeBody body, StrBuilder* result ) +{ + GEN_ASSERT(body != nullptr); + GEN_ASSERT(result != nullptr); + Code curr = body->Front; + s32 left = body->NumEntries; + while ( left -- ) + { + code_to_strbuilder_ref(curr, result); + // strbuilder_append_fmt( result, "%SB", code_to_strbuilder(curr) ); + ++curr; + } +} + +inline +void comment_to_strbuilder_ref(CodeComment comment, StrBuilder* result) { + GEN_ASSERT(comment); + GEN_ASSERT(result); + strbuilder_append_str(result, comment->Content); +} + +inline +StrBuilder define_to_strbuilder(CodeDefine define) +{ + GEN_ASSERT(define); + StrBuilder result = strbuilder_make_reserve( _ctx->Allocator_Temp, 512 ); + define_to_strbuilder_ref(define, & result); + return result; +} + +inline +StrBuilder define_params_to_strbuilder(CodeDefineParams params) +{ + GEN_ASSERT(params); + StrBuilder result = strbuilder_make_reserve( _ctx->Allocator_Temp, 128 ); + define_params_to_strbuilder_ref( params, & result ); + return result; +} + +inline +StrBuilder exec_to_strbuilder(CodeExec exec) +{ + GEN_ASSERT(exec); + char* raw = ccast(char*, str_duplicate( exec->Content, _ctx->Allocator_Temp ).Ptr); + StrBuilder result = { raw }; + return result; +} + +inline +void exec_to_strbuilder_ref(CodeExec exec, StrBuilder* result) { + GEN_ASSERT(exec); + GEN_ASSERT(result); + strbuilder_append_str(result, exec->Content); +} + +inline +void extern_to_strbuilder(CodeExtern self, StrBuilder* result ) +{ + GEN_ASSERT(self); + GEN_ASSERT(result); + if ( 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 ); +} + +inline +StrBuilder friend_to_strbuilder(CodeFriend self) +{ + GEN_ASSERT(self); + StrBuilder result = strbuilder_make_reserve( _ctx->Allocator_Temp, 256 ); + friend_to_strbuilder_ref( self, & result ); + return result; +} + +inline +void friend_to_strbuilder_ref(CodeFriend self, StrBuilder* result ) +{ + GEN_ASSERT(self); + GEN_ASSERT(result); + 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 ] != ';' ) + { + strbuilder_append_str( result, txt(";") ); + } + + if ( self->InlineCmt ) + strbuilder_append_fmt( result, " %S", self->InlineCmt->Content ); + else + strbuilder_append_str( result, txt("\n")); +} + +inline +StrBuilder include_to_strbuilder(CodeInclude include) +{ + GEN_ASSERT(include); + return strbuilder_fmt_buf( _ctx->Allocator_Temp, "#include %S\n", include->Content ); +} + +inline +void include_to_strbuilder_ref( CodeInclude include, StrBuilder* result ) +{ + GEN_ASSERT(include); + GEN_ASSERT(result); + strbuilder_append_fmt( result, "#include %S\n", include->Content ); +} + +inline +StrBuilder module_to_strbuilder(CodeModule self) +{ + GEN_ASSERT(self); + StrBuilder result = strbuilder_make_reserve( _ctx->Allocator_Temp, 64 ); + module_to_strbuilder_ref( self, & result ); + return result; +} + +inline +StrBuilder namespace_to_strbuilder(CodeNS self) +{ + GEN_ASSERT(self); + StrBuilder result = strbuilder_make_reserve( _ctx->Allocator_Temp, 512 ); + namespace_to_strbuilder_ref( self, & result ); + return result; +} + +inline +void namespace_to_strbuilder_ref(CodeNS self, StrBuilder* result ) +{ + GEN_ASSERT(self); + GEN_ASSERT(result); + if ( bitfield_is_set( 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_strbuilder(self->Body) ); +} + +inline +StrBuilder params_to_strbuilder(CodeParams self) +{ + GEN_ASSERT(self); + StrBuilder result = strbuilder_make_reserve( _ctx->Allocator_Temp, 128 ); + params_to_strbuilder_ref( self, & result ); + return result; +} + +inline +StrBuilder pragma_to_strbuilder(CodePragma self) +{ + GEN_ASSERT(self); + StrBuilder result = strbuilder_make_reserve( _ctx->Allocator_Temp, 256 ); + pragma_to_strbuilder_ref( self, & result ); + return result; +} + +inline +void pragma_to_strbuilder_ref(CodePragma self, StrBuilder* result ) +{ + GEN_ASSERT(self); + GEN_ASSERT(result); + strbuilder_append_fmt( result, "#pragma %S\n", self->Content ); +} + +inline +void preprocess_to_strbuilder_if(CodePreprocessCond cond, StrBuilder* result ) +{ + GEN_ASSERT(cond); + GEN_ASSERT(result); + strbuilder_append_fmt( result, "#if %S", cond->Content ); +} + +inline +void preprocess_to_strbuilder_ifdef(CodePreprocessCond cond, StrBuilder* result ) +{ + GEN_ASSERT(cond); + GEN_ASSERT(result); + strbuilder_append_fmt( result, "#ifdef %S\n", cond->Content ); +} + +inline +void preprocess_to_strbuilder_ifndef(CodePreprocessCond cond, StrBuilder* result ) +{ + GEN_ASSERT(cond); + GEN_ASSERT(result); + strbuilder_append_fmt( result, "#ifndef %S", cond->Content ); +} + +inline +void preprocess_to_strbuilder_elif(CodePreprocessCond cond, StrBuilder* result ) +{ + GEN_ASSERT(cond); + GEN_ASSERT(result); + strbuilder_append_fmt( result, "#elif %S\n", cond->Content ); +} + +inline +void preprocess_to_strbuilder_else(CodePreprocessCond cond, StrBuilder* result ) +{ + GEN_ASSERT(cond); + GEN_ASSERT(result); + strbuilder_append_str( result, txt("#else\n") ); +} + +inline +void preprocess_to_strbuilder_endif(CodePreprocessCond cond, StrBuilder* result ) +{ + GEN_ASSERT(cond); + GEN_ASSERT(result); + strbuilder_append_str( result, txt("#endif\n") ); +} + +inline +StrBuilder specifiers_to_strbuilder(CodeSpecifiers self) +{ + GEN_ASSERT(self); + StrBuilder result = strbuilder_make_reserve( _ctx->Allocator_Temp, 64 ); + specifiers_to_strbuilder_ref( self, & result ); + return result; +} + +inline +StrBuilder template_to_strbuilder(CodeTemplate self) +{ + GEN_ASSERT(self); + StrBuilder result = strbuilder_make_reserve( _ctx->Allocator_Temp, 1024 ); + template_to_strbuilder_ref( self, & result ); + return result; +} + +inline +StrBuilder typedef_to_strbuilder(CodeTypedef self) +{ + GEN_ASSERT(self); + StrBuilder result = strbuilder_make_reserve( _ctx->Allocator_Temp, 128 ); + typedef_to_strbuilder_ref( self, & result ); + return result; +} + +inline +StrBuilder typename_to_strbuilder(CodeTypename self) +{ + GEN_ASSERT(self); + StrBuilder result = strbuilder_make_str( _ctx->Allocator_Temp, txt("") ); + typename_to_strbuilder_ref( self, & result ); + return result; +} + +inline +StrBuilder using_to_strbuilder(CodeUsing self) +{ + GEN_ASSERT(self); + StrBuilder result = strbuilder_make_reserve( _ctx->Allocator_Temp, 128 ); + switch ( self->Type ) + { + case CT_Using: + using_to_strbuilder_ref( self, & result ); + break; + case CT_Using_Namespace: + using_to_strbuilder_ns( self, & result ); + break; + } + return result; +} + +inline +void using_to_strbuilder_ns(CodeUsing self, StrBuilder* result ) +{ + GEN_ASSERT(self); + GEN_ASSERT(result); + if ( self->InlineCmt ) + strbuilder_append_fmt( result, "using namespace $S; %S", self->Name, self->InlineCmt->Content ); + else + strbuilder_append_fmt( result, "using namespace %S;\n", self->Name ); +} + +inline +StrBuilder var_to_strbuilder(CodeVar self) +{ + GEN_ASSERT(self); + StrBuilder result = strbuilder_make_reserve( get_context()->Allocator_Temp, 256 ); + var_to_strbuilder_ref( self, & result ); + return result; +} +#pragma endregion Serialization + #pragma region Code inline void code_append( Code self, Code other ) @@ -74,7 +384,7 @@ bool code_is_valid(Code self) return self != nullptr && self->Type != CT_Invalid; } forceinline -bool code_has_entries(AST* self) +bool code_has_entries(Code self) { GEN_ASSERT(self); return self->NumEntries > 0; @@ -169,12 +479,12 @@ void class_add_interface( CodeClass self, CodeTypename type ) // then you'll need to move this over to ParentType->next and update ParentAccess accordingly. } - while ( possible_slot != nullptr ) + while ( possible_slot->Next != nullptr ) { possible_slot = cast(CodeTypename, possible_slot->Next); } - possible_slot = type; + possible_slot->Next = cast(Code, type); } #pragma endregion CodeClass @@ -296,7 +606,17 @@ bool specifiers_append(CodeSpecifiers self, Specifier spec ) return true; } inline -s32 specifiers_has(CodeSpecifiers self, Specifier spec) +bool specifiers_has(CodeSpecifiers self, Specifier spec) +{ + GEN_ASSERT(self != nullptr); + for ( s32 idx = 0; idx < self->NumEntries; idx++ ) { + if ( self->ArrSpecs[ idx ] == spec ) + return true; + } + return false; +} +inline +s32 specifiers_index_of(CodeSpecifiers self, Specifier spec) { GEN_ASSERT(self != nullptr); for ( s32 idx = 0; idx < self->NumEntries; idx++ ) { @@ -378,12 +698,12 @@ void struct_add_interface(CodeStruct self, CodeTypename type ) // then you'll need to move this over to ParentType->next and update ParentAccess accordingly. } - while ( possible_slot != nullptr ) + while ( possible_slot->Next != nullptr ) { possible_slot = cast(CodeTypename, possible_slot->Next); } - possible_slot = type; + possible_slot->Next = cast(Code, type); } #pragma endregion Code diff --git a/base/components/interface.cpp b/base/components/interface.cpp index 78d29f7..b3eaf45 100644 --- a/base/components/interface.cpp +++ b/base/components/interface.cpp @@ -1,4 +1,4 @@ -#ifdef GEN_INTELLISENSE_DIRECTIVES +#ifdef INTELLISENSE_DIRECTIVES #pragma once #include "code_serialization.cpp" #endif diff --git a/base/components/interface.hpp b/base/components/interface.hpp index bd5fbba..7578f1c 100644 --- a/base/components/interface.hpp +++ b/base/components/interface.hpp @@ -1,4 +1,4 @@ -#ifdef GEN_INTELLISENSE_DIRECTIVES +#ifdef INTELLISENSE_DIRECTIVES #pragma once #include "ast_types.hpp" #endif @@ -99,6 +99,11 @@ struct Context s32 temp_serialize_indent; }; +// TODO(Ed): Eventually this library should opt out of an implicit context for baseline implementation +// This would automatically make it viable for multi-threaded purposes among other things +// An implicit context interface will be provided instead as wrapper procedures as convience. +GEN_API extern Context* _ctx; + // Initialize the library. There first ctx initialized must exist for lifetime of other contextes that come after as its the one that GEN_API void init(Context* ctx); @@ -194,7 +199,7 @@ GEN_API CodeEnum def_enum( Str name, Opts_def_enum opts GEN_PARAM_DEFAULT ); GEN_API CodeExec def_execution ( Str content ); GEN_API CodeExtern def_extern_link( Str name, CodeBody body ); -GEN_API CodeFriend def_friend ( Code symbol ); +GEN_API CodeFriend def_friend ( Code code ); struct Opts_def_function { CodeParams params; @@ -230,7 +235,7 @@ struct Opts_def_operator_cast { GEN_API CodeOpCast def_operator_cast( CodeTypename type, Opts_def_operator_cast opts GEN_PARAM_DEFAULT ); struct Opts_def_param { Code value; }; -GEN_API CodeParams def_param ( CodeTypename type, Str name, Opts_def_param opts GEN_PARAM_DEFAULT ); +GEN_API CodeParams def_param ( CodeTypename type, Str name, Opts_def_param opts GEN_PARAM_DEFAULT ); GEN_API CodePragma def_pragma( Str directive ); GEN_API CodePreprocessCond def_preprocess_cond( EPreprocessCond type, Str content ); @@ -244,7 +249,7 @@ GEN_API CodeTemplate def_template( CodeParams params, Code definition, Opts_def_ struct Opts_def_type { ETypenameTag type_tag; - Code arrayexpr; + Code array_expr; CodeSpecifiers specifiers; CodeAttributes attributes; }; @@ -280,7 +285,7 @@ struct Opts_def_variable GEN_API CodeVar def_variable( CodeTypename type, Str name, Opts_def_variable opts GEN_PARAM_DEFAULT ); // Constructs an empty body. Use AST::validate_body() to check if the body is was has valid entries. -GEN_API CodeBody def_body( CodeType type ); +CodeBody def_body( CodeType type ); // There are two options for defining a struct body, either varadically provided with the args macro to auto-deduce the arg num, /// or provide as an array of Code objects. @@ -388,7 +393,7 @@ GEN_API CodeVar parse_variable ( Str var_def ); GEN_API ssize token_fmt_va( char* buf, usize buf_size, s32 num_tokens, va_list va ); //! Do not use directly. Use the token_fmt macro instead. -GEN_API Str token_fmt_impl( ssize, ... ); +Str token_fmt_impl( ssize, ... ); GEN_API Code untyped_str( Str content); GEN_API Code untyped_fmt ( char const* fmt, ... ); diff --git a/base/components/interface.parsing.cpp b/base/components/interface.parsing.cpp index 72550b8..d5f4bef 100644 --- a/base/components/interface.parsing.cpp +++ b/base/components/interface.parsing.cpp @@ -1,4 +1,4 @@ -#ifdef GEN_INTELLISENSE_DIRECTIVES +#ifdef INTELLISENSE_DIRECTIVES #pragma once #include "gen/etoktype.cpp" #include "interface.upfront.cpp" diff --git a/base/components/interface.untyped.cpp b/base/components/interface.untyped.cpp index bc8afab..69d74bb 100644 --- a/base/components/interface.untyped.cpp +++ b/base/components/interface.untyped.cpp @@ -1,4 +1,4 @@ -#ifdef GEN_INTELLISENSE_DIRECTIVES +#ifdef INTELLISENSE_DIRECTIVES #pragma once #include "interface.parsing.cpp" #endif diff --git a/base/components/interface.upfront.cpp b/base/components/interface.upfront.cpp index 80fbeda..94af5f7 100644 --- a/base/components/interface.upfront.cpp +++ b/base/components/interface.upfront.cpp @@ -1,4 +1,4 @@ -#ifdef GEN_INTELLISENSE_DIRECTIVES +#ifdef INTELLISENSE_DIRECTIVES #pragma once #include "interface.cpp" #endif @@ -1114,7 +1114,7 @@ CodeTypename def_type( Str name, Opts_def_type p ) GEN_DEBUG_TRAP(); return InvalidCode; } - Code arrayexpr = p.arrayexpr; + Code array_expr = p.array_expr; CodeSpecifiers specifiers = p.specifiers; CodeAttributes attributes = p.attributes; if ( p.attributes && p.attributes->Type != CT_PlatformAttributes ) { @@ -1127,8 +1127,8 @@ CodeTypename def_type( Str name, Opts_def_type p ) GEN_DEBUG_TRAP(); return InvalidCode; } - if ( p.arrayexpr && p.arrayexpr->Type != CT_Untyped ) { - log_failure( "gen::def_type: arrayexpr is not of untyped type - %s", code_debug_str((Code)p.arrayexpr) ); + if ( p.array_expr && p.array_expr->Type != CT_Untyped ) { + log_failure( "gen::def_type: arrayexpr is not of untyped type - %s", code_debug_str((Code)p.array_expr) ); GEN_DEBUG_TRAP(); return InvalidCode; } @@ -1138,7 +1138,7 @@ CodeTypename def_type( Str name, Opts_def_type p ) result->Type = CT_Typename; result->Attributes = p.attributes; result->Specs = p.specifiers; - result->ArrExpr = p.arrayexpr; + result->ArrExpr = p.array_expr; result->TypeTag = p.type_tag; return result; } diff --git a/base/components/lexer.cpp b/base/components/lexer.cpp index a1b762a..f501f70 100644 --- a/base/components/lexer.cpp +++ b/base/components/lexer.cpp @@ -1,4 +1,4 @@ -#ifdef GEN_INTELLISENSE_DIRECTIVES +#ifdef INTELLISENSE_DIRECTIVES #pragma once #include "interface.upfront.cpp" #include "gen/etoktype.cpp" @@ -488,6 +488,10 @@ void lex_found_token( LexContext* ctx ) TokType type = str_to_toktype( ctx->token.Text ); + if (type == Tok_Preprocess_Define || type == Tok_Preprocess_Include) { + ctx->token.Flags |= TF_Identifier; + } + if (type <= Tok_Access_Public && type >= Tok_Access_Private ) { ctx->token.Flags |= TF_AccessSpecifier; } diff --git a/base/components/parser.cpp b/base/components/parser.cpp index a68f682..b064e04 100644 --- a/base/components/parser.cpp +++ b/base/components/parser.cpp @@ -1,4 +1,4 @@ -#ifdef GEN_INTELLISENSE_DIRECTIVES +#ifdef INTELLISENSE_DIRECTIVES #pragma once #include "gen/etoktype.cpp" #include "parser_case_macros.cpp" @@ -1365,8 +1365,10 @@ Code parse_assignment_expression() eat( currtok.Type ); } - expr_tok.Text.Len = ( ( sptr )currtok.Text.Ptr + currtok.Text.Len ) - ( sptr )expr_tok.Text.Ptr - 1; - expr = untyped_str( expr_tok.Text ); + if (left) { + expr_tok.Text.Len = ( ( sptr )currtok.Text.Ptr + currtok.Text.Len ) - ( sptr )expr_tok.Text.Ptr - 1; + } + expr = untyped_str( expr_tok.Text ); // = return expr; } @@ -2788,10 +2790,10 @@ CodeParams parse_params( bool use_template_capture ) } // ( - if ( check( Tok_Identifier ) ) + if ( check( Tok_Identifier ) || bitfield_is_set(u32, currtok.Flags, TF_Identifier) ) { name = currtok; - eat( Tok_Identifier ); + eat( currtok.Type ); // ( } @@ -2899,10 +2901,10 @@ CodeParams parse_params( bool use_template_capture ) name = NullToken; - if ( check( Tok_Identifier ) ) + if ( check( Tok_Identifier ) || bitfield_is_set(u32, currtok.Flags, TF_Identifier) ) { name = currtok; - eat( Tok_Identifier ); + eat( currtok.Type ); // ( = , } diff --git a/base/components/parser_types.hpp b/base/components/parser_types.hpp index 4ec8181..2393945 100644 --- a/base/components/parser_types.hpp +++ b/base/components/parser_types.hpp @@ -1,4 +1,4 @@ -#ifdef GEN_INTELLISENSE_DIRECTIVES +#ifdef INTELLISENSE_DIRECTIVES #pragma once #include "types.hpp" #include "gen/ecode.hpp" @@ -11,17 +11,18 @@ enum TokFlags : u32 { TF_Operator = bit(0), TF_Assign = bit(1), - TF_Preprocess = bit(2), - TF_Preprocess_Cond = bit(3), - TF_Attribute = bit(6), - TF_AccessOperator = bit(7), - TF_AccessSpecifier = bit(8), - TF_Specifier = bit(9), - TF_EndDefinition = bit(10), // Either ; or } - TF_Formatting = bit(11), - TF_Literal = bit(12), - TF_Macro_Functional = bit(13), - TF_Macro_Expects_Body = bit(14), + TF_Identifier = bit(2), + TF_Preprocess = bit(3), + TF_Preprocess_Cond = bit(4), + TF_Attribute = bit(5), + TF_AccessOperator = bit(6), + TF_AccessSpecifier = bit(7), + TF_Specifier = bit(8), + TF_EndDefinition = bit(9), // Either ; or } + TF_Formatting = bit(10), + TF_Literal = bit(11), + TF_Macro_Functional = bit(12), + TF_Macro_Expects_Body = bit(13), TF_Null = 0, TF_UnderlyingType = GEN_U32_MAX, diff --git a/base/components/static_data.cpp b/base/components/static_data.cpp index c5290e4..696b5e2 100644 --- a/base/components/static_data.cpp +++ b/base/components/static_data.cpp @@ -1,4 +1,4 @@ -#ifdef GEN_INTELLISENSE_DIRECTIVES +#ifdef INTELLISENSE_DIRECTIVES #pragma once #include "../gen.hpp" #endif diff --git a/base/components/types.hpp b/base/components/types.hpp index 3b69a80..18762ea 100644 --- a/base/components/types.hpp +++ b/base/components/types.hpp @@ -1,4 +1,4 @@ -#ifdef GEN_INTELLISENSE_DIRECTIVES +#ifdef INTELLISENSE_DIRECTIVES #pragma once #include "header_start.hpp" #endif diff --git a/base/dependencies/basic_types.hpp b/base/dependencies/basic_types.hpp index 79b8df3..0420d2e 100644 --- a/base/dependencies/basic_types.hpp +++ b/base/dependencies/basic_types.hpp @@ -1,4 +1,4 @@ -#ifdef GEN_INTELLISENSE_DIRECTIVES +#ifdef INTELLISENSE_DIRECTIVES # pragma once # include "macros.hpp" #endif diff --git a/base/dependencies/containers.hpp b/base/dependencies/containers.hpp index d6d91e1..6418ce5 100644 --- a/base/dependencies/containers.hpp +++ b/base/dependencies/containers.hpp @@ -1,4 +1,4 @@ -#ifdef GEN_INTELLISENSE_DIRECTIVES +#ifdef INTELLISENSE_DIRECTIVES # pragma once # include "printing.hpp" #endif @@ -416,7 +416,7 @@ bool array_set_capacity(Array* array, usize new_capacity) // These are intended for use in the base library of gencpp and the C-variant of the library // It provides a interoperability between the C++ and C implementation of arrays. (not letting these do any crazy substiution though) // They are undefined in gen.hpp and gen.cpp at the end of the files. -// We cpp library expects the user to use the regular calls as they can resolve the type fine. +// The cpp library expects the user to use the regular calls as they can resolve the type fine. #define array_init(type, allocator) array_init (allocator ) #define array_init_reserve(type, allocator, cap) array_init_reserve (allocator, cap) diff --git a/base/dependencies/debug.cpp b/base/dependencies/debug.cpp index b10a98a..464208a 100644 --- a/base/dependencies/debug.cpp +++ b/base/dependencies/debug.cpp @@ -1,4 +1,4 @@ -#ifdef GEN_INTELLISENSE_DIRECTIVES +#ifdef INTELLISENSE_DIRECTIVES # pragma once # include "src_start.cpp" #endif diff --git a/base/dependencies/debug.hpp b/base/dependencies/debug.hpp index 544ccf4..cb2970a 100644 --- a/base/dependencies/debug.hpp +++ b/base/dependencies/debug.hpp @@ -1,4 +1,4 @@ -#ifdef GEN_INTELLISENSE_DIRECTIVES +#ifdef INTELLISENSE_DIRECTIVES # pragma once # include "dependencies/platform.hpp" # include "dependencies/macros.hpp" diff --git a/base/dependencies/filesystem.cpp b/base/dependencies/filesystem.cpp index 5014d3d..a52c621 100644 --- a/base/dependencies/filesystem.cpp +++ b/base/dependencies/filesystem.cpp @@ -1,4 +1,4 @@ -#ifdef GEN_INTELLISENSE_DIRECTIVES +#ifdef INTELLISENSE_DIRECTIVES # pragma once # include "strings.cpp" #endif diff --git a/base/dependencies/filesystem.hpp b/base/dependencies/filesystem.hpp index 1caa47e..9d3676a 100644 --- a/base/dependencies/filesystem.hpp +++ b/base/dependencies/filesystem.hpp @@ -1,4 +1,4 @@ -#ifdef GEN_INTELLISENSE_DIRECTIVES +#ifdef INTELLISENSE_DIRECTIVES # pragma once # include "strings.hpp" #endif diff --git a/base/dependencies/hashing.cpp b/base/dependencies/hashing.cpp index 6ac5358..fab309b 100644 --- a/base/dependencies/hashing.cpp +++ b/base/dependencies/hashing.cpp @@ -1,4 +1,4 @@ -#ifdef GEN_INTELLISENSE_DIRECTIVES +#ifdef INTELLISENSE_DIRECTIVES # pragma once # include "memory.cpp" #endif diff --git a/base/dependencies/hashing.hpp b/base/dependencies/hashing.hpp index ee895de..2ba36e8 100644 --- a/base/dependencies/hashing.hpp +++ b/base/dependencies/hashing.hpp @@ -1,4 +1,4 @@ -#ifdef GEN_INTELLISENSE_DIRECTIVES +#ifdef INTELLISENSE_DIRECTIVES #pragma once #include "containers.hpp" #endif diff --git a/base/dependencies/macros.hpp b/base/dependencies/macros.hpp index 7ca0d77..c8ad2d7 100644 --- a/base/dependencies/macros.hpp +++ b/base/dependencies/macros.hpp @@ -1,4 +1,4 @@ -#ifdef GEN_INTELLISENSE_DIRECTIVES +#ifdef INTELLISENSE_DIRECTIVES # pragma once # include "platform.hpp" #endif @@ -26,7 +26,7 @@ #endif // GEN_API #ifndef global // Global variables -# ifdef GEN_DYN_EXPORT +# if defined(GEN_STATIC_LINK) || defined(GEN_DYN_LINK) # define global # else # define global static diff --git a/base/dependencies/memory.cpp b/base/dependencies/memory.cpp index fb4bf9c..8c32c81 100644 --- a/base/dependencies/memory.cpp +++ b/base/dependencies/memory.cpp @@ -1,4 +1,4 @@ -#ifdef GEN_INTELLISENSE_DIRECTIVES +#ifdef INTELLISENSE_DIRECTIVES # pragma once # include "printing.cpp" #endif @@ -84,7 +84,7 @@ void heap_stats_check( void ) typedef struct _heap_alloc_info _heap_alloc_info; struct _heap_alloc_info { - ssize size; + ssize size; void* physical_start; }; diff --git a/base/dependencies/memory.hpp b/base/dependencies/memory.hpp index b189970..eaad19d 100644 --- a/base/dependencies/memory.hpp +++ b/base/dependencies/memory.hpp @@ -1,4 +1,4 @@ -#ifdef GEN_INTELLISENSE_DIRECTIVES +#ifdef INTELLISENSE_DIRECTIVES # pragma once # include "debug.hpp" #endif diff --git a/base/dependencies/parsing.cpp b/base/dependencies/parsing.cpp index 255fe40..ce13e23 100644 --- a/base/dependencies/parsing.cpp +++ b/base/dependencies/parsing.cpp @@ -1,4 +1,4 @@ -#ifdef GEN_INTELLISENSE_DIRECTIVES +#ifdef INTELLISENSE_DIRECTIVES # pragma once # include "parsing.hpp" #endif diff --git a/base/dependencies/parsing.hpp b/base/dependencies/parsing.hpp index c69b26f..3ffe4ca 100644 --- a/base/dependencies/parsing.hpp +++ b/base/dependencies/parsing.hpp @@ -1,4 +1,4 @@ -#ifdef GEN_INTELLISENSE_DIRECTIVES +#ifdef INTELLISENSE_DIRECTIVES # pragma once # include "timing.hpp" #endif diff --git a/base/dependencies/platform.hpp b/base/dependencies/platform.hpp index 59259c6..bb3144a 100644 --- a/base/dependencies/platform.hpp +++ b/base/dependencies/platform.hpp @@ -1,4 +1,4 @@ -#ifdef GEN_INTELLISENSE_DIRECTIVES +#ifdef INTELLISENSE_DIRECTIVES # pragma once #endif diff --git a/base/dependencies/printing.cpp b/base/dependencies/printing.cpp index 01d083d..684f0ea 100644 --- a/base/dependencies/printing.cpp +++ b/base/dependencies/printing.cpp @@ -1,4 +1,4 @@ -#ifdef GEN_INTELLISENSE_DIRECTIVES +#ifdef INTELLISENSE_DIRECTIVES # pragma once # include "strbuilder_ops.cpp" #endif diff --git a/base/dependencies/printing.hpp b/base/dependencies/printing.hpp index 19b485f..5ddc20e 100644 --- a/base/dependencies/printing.hpp +++ b/base/dependencies/printing.hpp @@ -1,4 +1,4 @@ -#ifdef GEN_INTELLISENSE_DIRECTIVES +#ifdef INTELLISENSE_DIRECTIVES # pragma once # include "strbuilder_ops.hpp" #endif diff --git a/base/dependencies/src_start.cpp b/base/dependencies/src_start.cpp index 7fe3595..ab5e7a6 100644 --- a/base/dependencies/src_start.cpp +++ b/base/dependencies/src_start.cpp @@ -1,4 +1,4 @@ -#ifdef GEN_INTELLISENSE_DIRECTIVES +#ifdef INTELLISENSE_DIRECTIVES # pragma once # include "header_start.hpp" #endif diff --git a/base/dependencies/string_ops.cpp b/base/dependencies/string_ops.cpp index 36b7b69..47f11f1 100644 --- a/base/dependencies/string_ops.cpp +++ b/base/dependencies/string_ops.cpp @@ -1,4 +1,4 @@ -#ifdef GEN_INTELLISENSE_DIRECTIVES +#ifdef INTELLISENSE_DIRECTIVES # pragma once # include "debug.cpp" #endif diff --git a/base/dependencies/string_ops.hpp b/base/dependencies/string_ops.hpp index 0487186..78fa555 100644 --- a/base/dependencies/string_ops.hpp +++ b/base/dependencies/string_ops.hpp @@ -1,4 +1,4 @@ -#ifdef GEN_INTELLISENSE_DIRECTIVES +#ifdef INTELLISENSE_DIRECTIVES # pragma once # include "memory.hpp" #endif diff --git a/base/dependencies/strings.cpp b/base/dependencies/strings.cpp index 336671a..5bd3a47 100644 --- a/base/dependencies/strings.cpp +++ b/base/dependencies/strings.cpp @@ -1,4 +1,4 @@ -#ifdef GEN_INTELLISENSE_DIRECTIVES +#ifdef INTELLISENSE_DIRECTIVES # pragma once # include "hashing.cpp" #endif @@ -58,4 +58,120 @@ StrBuilder strbuilder_make_reserve( AllocatorInfo allocator, ssize capacity ) return result; } +bool strbuilder_make_space_for(StrBuilder* str, char const* to_append, ssize add_len) +{ + ssize available = strbuilder_avail_space(* str); + + if (available >= add_len) { + return true; + } + else + { + ssize new_len, old_size, new_size; + void* ptr; + void* new_ptr; + + AllocatorInfo allocator = strbuilder_get_header(* str)->Allocator; + StrBuilderHeader* header = nullptr; + + new_len = strbuilder_grow_formula(strbuilder_length(* str) + add_len); + ptr = strbuilder_get_header(* str); + old_size = size_of(StrBuilderHeader) + strbuilder_length(* str) + 1; + new_size = size_of(StrBuilderHeader) + new_len + 1; + + new_ptr = resize(allocator, ptr, old_size, new_size); + + if (new_ptr == nullptr) + return false; + + header = rcast(StrBuilderHeader*, new_ptr); + header->Allocator = allocator; + header->Capacity = new_len; + + char** Data = rcast(char**, str); + * Data = rcast(char*, header + 1); + + return true; + } +} + +bool strbuilder_append_c_str_len(StrBuilder* str, char const* c_str_to_append, ssize append_length) +{ + GEN_ASSERT(str != nullptr); + if ( rcast(sptr, c_str_to_append) > 0) + { + ssize curr_len = strbuilder_length(* str); + + if ( ! strbuilder_make_space_for(str, c_str_to_append, append_length)) + return false; + + StrBuilderHeader* header = strbuilder_get_header(* str); + + char* Data = * str; + mem_copy( Data + curr_len, c_str_to_append, append_length); + + Data[curr_len + append_length] = '\0'; + + header->Length = curr_len + append_length; + } + return c_str_to_append != nullptr; +} + +void strbuilder_trim(StrBuilder str, char const* cut_set) +{ + ssize len = 0; + + char* start_pos = str; + char* end_pos = scast(char*, str) + strbuilder_length(str) - 1; + + while (start_pos <= end_pos && char_first_occurence(cut_set, *start_pos)) + start_pos++; + + while (end_pos > start_pos && char_first_occurence(cut_set, *end_pos)) + end_pos--; + + len = scast(ssize, (start_pos > end_pos) ? 0 : ((end_pos - start_pos) + 1)); + + if (str != start_pos) + mem_move(str, start_pos, len); + + str[len] = '\0'; + + strbuilder_get_header(str)->Length = len; +} + +StrBuilder strbuilder_visualize_whitespace(StrBuilder const str) +{ + StrBuilderHeader* header = (StrBuilderHeader*)(scast(char const*, str) - sizeof(StrBuilderHeader)); + StrBuilder result = strbuilder_make_reserve(header->Allocator, strbuilder_length(str) * 2); // Assume worst case for space requirements. + + for (char const* c = strbuilder_begin(str); c != strbuilder_end(str); c = strbuilder_next(str, c)) + switch ( * c ) + { + case ' ': + strbuilder_append_str(& result, txt("·")); + break; + case '\t': + strbuilder_append_str(& result, txt("→")); + break; + case '\n': + strbuilder_append_str(& result, txt("↵")); + break; + case '\r': + strbuilder_append_str(& result, txt("⏎")); + break; + case '\v': + strbuilder_append_str(& result, txt("⇕")); + break; + case '\f': + strbuilder_append_str(& result, txt("⌂")); + break; + default: + strbuilder_append_char(& result, * c); + break; + } + + return result; +} + #pragma endregion StrBuilder diff --git a/base/dependencies/strings.hpp b/base/dependencies/strings.hpp index 039ffe2..866e944 100644 --- a/base/dependencies/strings.hpp +++ b/base/dependencies/strings.hpp @@ -1,4 +1,4 @@ -#ifdef GEN_INTELLISENSE_DIRECTIVES +#ifdef INTELLISENSE_DIRECTIVES # pragma once # include "hashing.hpp" #endif @@ -124,6 +124,10 @@ forceinline usize strbuilder_grow_formula(usize value); GEN_API StrBuilder strbuilder_make_reserve (AllocatorInfo allocator, ssize capacity); GEN_API StrBuilder strbuilder_make_length (AllocatorInfo allocator, char const* str, ssize length); +GEN_API bool strbuilder_make_space_for (StrBuilder* str, char const* to_append, ssize add_len); +GEN_API bool strbuilder_append_c_str_len (StrBuilder* str, char const* c_str_to_append, ssize length); +GEN_API void strbuilder_trim (StrBuilder str, char const* cut_set); +GEN_API StrBuilder strbuilder_visualize_whitespace(StrBuilder const str); StrBuilder strbuilder_make_c_str (AllocatorInfo allocator, char const* str); StrBuilder strbuilder_make_str (AllocatorInfo allocator, Str str); @@ -132,10 +136,8 @@ StrBuilder strbuilder_fmt_buf (AllocatorInfo allocator, char StrBuilder strbuilder_join (AllocatorInfo allocator, char const** parts, ssize num_parts, char const* glue); bool strbuilder_are_equal (StrBuilder const lhs, StrBuilder const rhs); bool strbuilder_are_equal_str (StrBuilder const lhs, Str rhs); -bool strbuilder_make_space_for (StrBuilder* str, char const* to_append, ssize add_len); bool strbuilder_append_char (StrBuilder* str, char c); bool strbuilder_append_c_str (StrBuilder* str, char const* c_str_to_append); -bool strbuilder_append_c_str_len (StrBuilder* str, char const* c_str_to_append, ssize length); bool strbuilder_append_str (StrBuilder* str, Str c_str_to_append); bool strbuilder_append_string (StrBuilder* str, StrBuilder const other); bool strbuilder_append_fmt (StrBuilder* str, char const* fmt, ...); @@ -154,9 +156,7 @@ b32 strbuilder_starts_with_string (StrBuilder const str, StrBuild void strbuilder_skip_line (StrBuilder str); void strbuilder_strip_space (StrBuilder str); Str strbuilder_to_str (StrBuilder str); -void strbuilder_trim (StrBuilder str, char const* cut_set); void strbuilder_trim_space (StrBuilder str); -StrBuilder strbuilder_visualize_whitespace(StrBuilder const str); struct StrBuilderHeader { AllocatorInfo Allocator; @@ -358,29 +358,6 @@ bool strbuilder_append_c_str(StrBuilder* str, char const* c_str_to_append) { return strbuilder_append_c_str_len(str, c_str_to_append, c_str_len(c_str_to_append)); } -inline -bool strbuilder_append_c_str_len(StrBuilder* str, char const* c_str_to_append, ssize append_length) -{ - GEN_ASSERT(str != nullptr); - if ( rcast(sptr, c_str_to_append) > 0) - { - ssize curr_len = strbuilder_length(* str); - - if ( ! strbuilder_make_space_for(str, c_str_to_append, append_length)) - return false; - - StrBuilderHeader* header = strbuilder_get_header(* str); - - char* Data = * str; - mem_copy( Data + curr_len, c_str_to_append, append_length); - - Data[curr_len + append_length] = '\0'; - - header->Length = curr_len + append_length; - } - return c_str_to_append != nullptr; -} - forceinline bool strbuilder_append_str(StrBuilder* str, Str c_str_to_append) { GEN_ASSERT(str != nullptr); @@ -522,44 +499,6 @@ ssize strbuilder_length(StrBuilder const str) return header->Length; } -inline -bool strbuilder_make_space_for(StrBuilder* str, char const* to_append, ssize add_len) -{ - ssize available = strbuilder_avail_space(* str); - - if (available >= add_len) { - return true; - } - else - { - ssize new_len, old_size, new_size; - void* ptr; - void* new_ptr; - - AllocatorInfo allocator = strbuilder_get_header(* str)->Allocator; - StrBuilderHeader* header = nullptr; - - new_len = strbuilder_grow_formula(strbuilder_length(* str) + add_len); - ptr = strbuilder_get_header(* str); - old_size = size_of(StrBuilderHeader) + strbuilder_length(* str) + 1; - new_size = size_of(StrBuilderHeader) + new_len + 1; - - new_ptr = resize(allocator, ptr, old_size, new_size); - - if (new_ptr == nullptr) - return false; - - header = rcast(StrBuilderHeader*, new_ptr); - header->Allocator = allocator; - header->Capacity = new_len; - - char** Data = rcast(char**, str); - * Data = rcast(char*, header + 1); - - return true; - } -} - forceinline b32 strbuilder_starts_with_str(StrBuilder const str, Str substring) { if (substring.Len > strbuilder_length(str)) @@ -627,69 +566,11 @@ Str strbuilder_to_str(StrBuilder str) { return result; } -inline -void strbuilder_trim(StrBuilder str, char const* cut_set) -{ - ssize len = 0; - - char* start_pos = str; - char* end_pos = scast(char*, str) + strbuilder_length(str) - 1; - - while (start_pos <= end_pos && char_first_occurence(cut_set, *start_pos)) - start_pos++; - - while (end_pos > start_pos && char_first_occurence(cut_set, *end_pos)) - end_pos--; - - len = scast(ssize, (start_pos > end_pos) ? 0 : ((end_pos - start_pos) + 1)); - - if (str != start_pos) - mem_move(str, start_pos, len); - - str[len] = '\0'; - - strbuilder_get_header(str)->Length = len; -} - forceinline void strbuilder_trim_space(StrBuilder str) { strbuilder_trim(str, " \t\r\n\v\f"); } -inline -StrBuilder strbuilder_visualize_whitespace(StrBuilder const str) -{ - StrBuilderHeader* header = (StrBuilderHeader*)(scast(char const*, str) - sizeof(StrBuilderHeader)); - StrBuilder result = strbuilder_make_reserve(header->Allocator, strbuilder_length(str) * 2); // Assume worst case for space requirements. - - for (char const* c = strbuilder_begin(str); c != strbuilder_end(str); c = strbuilder_next(str, c)) - switch ( * c ) - { - case ' ': - strbuilder_append_str(& result, txt("·")); - break; - case '\t': - strbuilder_append_str(& result, txt("→")); - break; - case '\n': - strbuilder_append_str(& result, txt("↵")); - break; - case '\r': - strbuilder_append_str(& result, txt("⏎")); - break; - case '\v': - strbuilder_append_str(& result, txt("⇕")); - break; - case '\f': - strbuilder_append_str(& result, txt("⌂")); - break; - default: - strbuilder_append_char(& result, * c); - break; - } - - return result; -} #pragma endregion StrBuilder #if GEN_COMPILER_CPP diff --git a/base/dependencies/timing.cpp b/base/dependencies/timing.cpp index 5258045..218c2ce 100644 --- a/base/dependencies/timing.cpp +++ b/base/dependencies/timing.cpp @@ -1,4 +1,4 @@ -#ifdef GEN_INTELLISENSE_DIRECTIVES +#ifdef INTELLISENSE_DIRECTIVES # pragma once # include "filesystem.cpp" #endif diff --git a/base/dependencies/timing.hpp b/base/dependencies/timing.hpp index cf7931c..f3bda8a 100644 --- a/base/dependencies/timing.hpp +++ b/base/dependencies/timing.hpp @@ -1,4 +1,4 @@ -#ifdef GEN_INTELLISENSE_DIRECTIVES +#ifdef INTELLISENSE_DIRECTIVES # pragma once # include "filesystem.hpp" #endif diff --git a/base/gen.hpp b/base/gen.hpp index 0ffb9af..8d3d5a9 100644 --- a/base/gen.hpp +++ b/base/gen.hpp @@ -29,9 +29,9 @@ GEN_NS_BEGIN #include "components/interface.hpp" +#include "components/constants.hpp" #include "components/inlines.hpp" #include "components/gen/ast_inlines.hpp" -#include "components/header_end.hpp" #include "auxiliary/builder.hpp" #include "auxiliary/scanner.hpp" diff --git a/base/helpers/base_codegen.hpp b/base/helpers/base_codegen.hpp index 07ba92e..533acfc 100644 --- a/base/helpers/base_codegen.hpp +++ b/base/helpers/base_codegen.hpp @@ -1,6 +1,6 @@ #pragma once -#if GEN_INTELLISENSE_DIRECTIVES +#if INTELLISENSE_DIRECTIVES # include "../gen.hpp" # include "misc.hpp" diff --git a/base/helpers/misc.hpp b/base/helpers/misc.hpp index 8292d64..2b949a7 100644 --- a/base/helpers/misc.hpp +++ b/base/helpers/misc.hpp @@ -1,6 +1,6 @@ #pragma once -#ifdef GEN_INTELLISENSE_DIRECTIVES +#ifdef INTELLISENSE_DIRECTIVES # define GEN_DEFINE_LIBRARY_CODE_CONSTANTS # define GEN_ENFORCE_STRONG_CODE_TYPES # define GEN_EXPOSE_BACKEND diff --git a/docs/AST_Design.md b/docs/AST_Design.md index 487d6dd..cd59272 100644 --- a/docs/AST_Design.md +++ b/docs/AST_Design.md @@ -53,7 +53,7 @@ StrBuilder _to_strbuilder(Code code); 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.cpp`](../base/components/ast.cpp) with `code_to_strbuilder_ptr` & `code_to_strbuilder`. +Serialization of for the AST is defined for `Code` in [`ast.cpp`](../base/components/ast.cpp) with `code_to_strbuilder_ref` & `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. diff --git a/gen_c_library/c_library.cpp b/gen_c_library/c_library.cpp index f03a8d6..591d79c 100644 --- a/gen_c_library/c_library.cpp +++ b/gen_c_library/c_library.cpp @@ -306,7 +306,7 @@ do \ break; case CT_Preprocess_IfDef: { - b32 found = ignore_preprocess_cond_block(txt("GEN_INTELLISENSE_DIRECTIVES"), entry, parsed_header_memory, header_memory ); + b32 found = ignore_preprocess_cond_block(txt("INTELLISENSE_DIRECTIVES"), entry, parsed_header_memory, header_memory ); if (found) break; header_memory.append(entry); @@ -334,7 +334,7 @@ do \ { case CT_Preprocess_IfDef: { - b32 found = ignore_preprocess_cond_block(txt("GEN_INTELLISENSE_DIRECTIVES"), entry, parsed_header_printing, header_printing ); + b32 found = ignore_preprocess_cond_block(txt("INTELLISENSE_DIRECTIVES"), entry, parsed_header_printing, header_printing ); if (found) break; header_printing.append(entry); @@ -391,7 +391,7 @@ do \ case CT_Preprocess_IfDef: { - ignore_preprocess_cond_block(txt("GEN_INTELLISENSE_DIRECTIVES"), entry, parsed_header_strings, header_strings ); + ignore_preprocess_cond_block(txt("INTELLISENSE_DIRECTIVES"), entry, parsed_header_strings, header_strings ); } break; @@ -472,7 +472,7 @@ do \ { case CT_Preprocess_IfDef: { - b32 found = ignore_preprocess_cond_block(txt("GEN_INTELLISENSE_DIRECTIVES"), entry, parsed_header_filesystem, header_filesystem ); + b32 found = ignore_preprocess_cond_block(txt("INTELLISENSE_DIRECTIVES"), entry, parsed_header_filesystem, header_filesystem ); if (found) break; header_filesystem.append(entry); @@ -509,7 +509,7 @@ do \ case CT_Variable: { CodeVar var = cast(CodeVar, entry); - if (var->Specs.has(Spec_Constexpr) > -1) + if (var->Specs.has(Spec_Constexpr)) { Opts_def_define opts = { {}, entry->Value->Content }; CodeDefine define = def_define(entry->Name, MT_Expression, opts); @@ -532,7 +532,7 @@ do \ { case CT_Preprocess_IfDef: { - b32 found = ignore_preprocess_cond_block(txt("GEN_INTELLISENSE_DIRECTIVES"), entry, parsed_header_parsing, header_parsing ); + b32 found = ignore_preprocess_cond_block(txt("INTELLISENSE_DIRECTIVES"), entry, parsed_header_parsing, header_parsing ); if (found) break; header_parsing.append(entry); @@ -640,7 +640,7 @@ do \ case CT_Preprocess_IfDef: { - b32 found = ignore_preprocess_cond_block(txt("GEN_INTELLISENSE_DIRECTIVES"), entry, parsed_types, types ); + b32 found = ignore_preprocess_cond_block(txt("INTELLISENSE_DIRECTIVES"), entry, parsed_types, types ); if (found) break; types.append(entry); @@ -702,7 +702,7 @@ do \ { case CT_Preprocess_IfDef: { - b32 found = ignore_preprocess_cond_block(txt("GEN_INTELLISENSE_DIRECTIVES"), entry, parsed_parser_types, parser_types ); + b32 found = ignore_preprocess_cond_block(txt("INTELLISENSE_DIRECTIVES"), entry, parsed_parser_types, parser_types ); if (found) break; parser_types.append(entry); @@ -769,7 +769,7 @@ do \ case CT_Variable: { CodeVar var = cast(CodeVar, entry); - if (var->Specs && var->Specs.has(Spec_Constexpr) > -1) { + if (var->Specs && var->Specs.has(Spec_Constexpr)) { Code define_ver = untyped_str(token_fmt( "name", var->Name , "value", var->Value->Content @@ -797,7 +797,7 @@ do \ { case CT_Preprocess_IfDef: { - b32 found = ignore_preprocess_cond_block(txt("GEN_INTELLISENSE_DIRECTIVES"), entry, parsed_ast, ast ); + b32 found = ignore_preprocess_cond_block(txt("INTELLISENSE_DIRECTIVES"), entry, parsed_ast, ast ); if (found) break; found = ignore_preprocess_cond_block(txt("GEN_EXECUTION_EXPRESSION_SUPPORT"), entry, parsed_ast, ast ); @@ -978,7 +978,7 @@ R"(#define AST_ArrSpecs_Cap \ ++ entry; // Skip a newline... break; } - found = ignore_preprocess_cond_block(txt("GEN_INTELLISENSE_DIRECTIVES"), entry, parsed_code_types, code_types ); + found = ignore_preprocess_cond_block(txt("INTELLISENSE_DIRECTIVES"), entry, parsed_code_types, code_types ); if (found) break; found = ignore_preprocess_cond_block(txt("GEN_EXECUTION_EXPRESSION_SUPPORT"), entry, parsed_code_types, code_types); @@ -1078,7 +1078,7 @@ R"(#define ( code ) _Generic( (code), \ case CT_Preprocess_If: case CT_Preprocess_IfDef: { - b32 found = ignore_preprocess_cond_block(txt("GEN_INTELLISENSE_DIRECTIVES"), entry, parsed_ast_types, ast_types ); + b32 found = ignore_preprocess_cond_block(txt("INTELLISENSE_DIRECTIVES"), entry, parsed_ast_types, ast_types ); if (found) break; found = ignore_preprocess_cond_block(txt("GEN_EXECUTION_EXPRESSION_SUPPORT"), entry, parsed_ast_types, ast_types); @@ -1132,7 +1132,7 @@ R"(#define ( code ) _Generic( (code), \ case CT_Preprocess_If: case CT_Preprocess_IfDef: { - b32 found = ignore_preprocess_cond_block(txt("GEN_INTELLISENSE_DIRECTIVES"), entry, parsed_interface, interface ); + b32 found = ignore_preprocess_cond_block(txt("INTELLISENSE_DIRECTIVES"), entry, parsed_interface, interface ); if (found) break; found = ignore_preprocess_cond_block(txt("GEN_COMPILER_CPP"), entry, parsed_interface, interface); @@ -1221,7 +1221,7 @@ R"(#define ( code ) _Generic( (code), \ case CT_Preprocess_If: case CT_Preprocess_IfDef: { - b32 found = ignore_preprocess_cond_block(txt("GEN_INTELLISENSE_DIRECTIVES"), entry, parsed_inlines, inlines ); + b32 found = ignore_preprocess_cond_block(txt("INTELLISENSE_DIRECTIVES"), entry, parsed_inlines, inlines ); if (found) break; found = ignore_preprocess_cond_block(txt("GEN_COMPILER_CPP"), entry, parsed_interface, interface); @@ -1257,16 +1257,16 @@ R"(#define ( code ) _Generic( (code), \ } s32 idx = 0; - CodeBody parsed_header_end = parse_file( path_base "components/header_end.hpp" ); - CodeBody header_end = def_body(CT_Global_Body); - for ( Code entry = parsed_header_end.begin(); entry != parsed_header_end.end(); ++ entry, ++ idx ) switch( entry->Type ) + CodeBody parsed_constants = parse_file( path_base "components/constants.hpp" ); + CodeBody constants = def_body(CT_Global_Body); + for ( Code entry = parsed_constants.begin(); entry != parsed_constants.end(); ++ entry, ++ idx ) switch( entry->Type ) { case CT_Preprocess_IfDef: { - b32 found = ignore_preprocess_cond_block(txt("GEN_INTELLISENSE_DIRECTIVES"), entry, parsed_header_end, header_end ); + b32 found = ignore_preprocess_cond_block(txt("INTELLISENSE_DIRECTIVES"), entry, parsed_constants, constants ); if (found) break; - header_end.append(entry); + constants.append(entry); } break; @@ -1278,18 +1278,18 @@ R"(#define ( code ) _Generic( (code), \ s32 constexpr_found = var->Specs.remove( Spec_Constexpr ); if (constexpr_found > -1) { - Opts_def_define opts = { {}, entry->Value->Content }; + Opts_def_define opts = { {}, entry->Value->Content }; CodeDefine define = def_define(entry->Name, MT_Expression, opts ); - header_end.append(define); + constants.append(define); continue; } } - header_end.append(entry); + constants.append(entry); } break; default: - header_end.append(entry); + constants.append(entry); break; } #pragma endregion Resolve Components @@ -1302,7 +1302,7 @@ R"(#define ( code ) _Generic( (code), \ { case CT_Preprocess_IfDef: { - b32 found = ignore_preprocess_cond_block(txt("GEN_INTELLISENSE_DIRECTIVES"), entry, parsed_header_builder, header_builder ); + b32 found = ignore_preprocess_cond_block(txt("INTELLISENSE_DIRECTIVES"), entry, parsed_header_builder, header_builder ); if (found) break; header_builder.append(entry); @@ -1446,7 +1446,7 @@ R"(#define ( code ) _Generic( (code), \ { case CT_Preprocess_IfDef: { - b32 found = ignore_preprocess_cond_block(txt("GEN_INTELLISENSE_DIRECTIVES"), entry, parsed_src_ast, src_ast ); + b32 found = ignore_preprocess_cond_block(txt("INTELLISENSE_DIRECTIVES"), entry, parsed_src_ast, src_ast ); if (found) break; src_ast.append(entry); @@ -1481,7 +1481,7 @@ R"(#define ( code ) _Generic( (code), \ { case CT_Preprocess_IfDef: { - b32 found = ignore_preprocess_cond_block(txt("GEN_INTELLISENSE_DIRECTIVES"), entry, parsed_src_upfront, src_upfront ); + b32 found = ignore_preprocess_cond_block(txt("INTELLISENSE_DIRECTIVES"), entry, parsed_src_upfront, src_upfront ); if (found) break; src_upfront.append(entry); @@ -1520,7 +1520,7 @@ R"(#define ( code ) _Generic( (code), \ { case CT_Preprocess_IfDef: { - b32 found = ignore_preprocess_cond_block(txt("GEN_INTELLISENSE_DIRECTIVES"), entry, parsed_src_lexer, src_lexer ); + b32 found = ignore_preprocess_cond_block(txt("INTELLISENSE_DIRECTIVES"), entry, parsed_src_lexer, src_lexer ); if (found) break; src_lexer.append(entry); @@ -1542,7 +1542,7 @@ R"(#define ( code ) _Generic( (code), \ case CT_Variable: { CodeVar var = cast(CodeVar, entry); - if (var->Specs && var->Specs.has(Spec_Constexpr) > -1) { + if (var->Specs && var->Specs.has(Spec_Constexpr)) { Code define_ver = untyped_str(token_fmt( "name", var->Name , "value", var->Value->Content @@ -1569,7 +1569,7 @@ R"(#define ( code ) _Generic( (code), \ { case CT_Preprocess_IfDef: { - b32 found = ignore_preprocess_cond_block(txt("GEN_INTELLISENSE_DIRECTIVES"), entry, parsed_src_parser, src_parser ); + b32 found = ignore_preprocess_cond_block(txt("INTELLISENSE_DIRECTIVES"), entry, parsed_src_parser, src_parser ); if (found) break; src_parser.append(entry); @@ -1587,7 +1587,7 @@ R"(#define ( code ) _Generic( (code), \ case CT_Variable: { CodeVar var = cast(CodeVar, entry); - if (var->Specs && var->Specs.has(Spec_Constexpr) > -1) { + if (var->Specs && var->Specs.has(Spec_Constexpr)) { Code define_ver = untyped_str(token_fmt( "name", var->Name , "value", var->Value->Content @@ -1673,11 +1673,11 @@ R"(#define ( code ) _Generic( (code), \ Code rf_ast_types = refactor_and_format(ast_types); Code rf_interface = refactor_and_format(interface); + Code rf_constants = refactor_and_format(constants); Code rf_inlines = refactor_and_format(inlines); Code rf_ht_preprocessor_macro = refactor_and_format(ht_preprocessor_macro); Code rf_array_string_cached = refactor_and_format(array_string_cached); - Code rf_header_end = refactor_and_format(header_end); Code rf_header_builder = refactor_and_format(header_builder); Code rf_header_scanner = refactor_and_format( scan_file( path_base "auxiliary/scanner.hpp" )); @@ -1788,6 +1788,7 @@ R"(#define ( code ) _Generic( (code), \ header.print( rf_ht_preprocessor_macro ); header.print( rf_interface ); + header.print( rf_constants ); header.print(fmt_newline); header.print_fmt("#pragma region Inlines\n"); @@ -1796,7 +1797,6 @@ R"(#define ( code ) _Generic( (code), \ header.print(fmt_newline); - header.print( rf_header_end ); header.print( rf_header_builder ); header.print( rf_header_scanner ); @@ -1882,6 +1882,9 @@ R"(#define ( code ) _Generic( (code), \ header.print( r_header_macros ); header.print( header_generic_macros ); + + header.print_fmt( "\nGEN_API_C_BEGIN\n" ); + header.print( r_header_basic_types ); header.print( r_header_debug ); header.print( rf_header_memory ); @@ -1895,6 +1898,7 @@ R"(#define ( code ) _Generic( (code), \ header.print( r_header_timing ); header.print(rf_header_parsing ); + header.print_fmt( "\nGEN_API_C_END\n" ); header.print_fmt( "\nGEN_NS_END\n" ); header.write(); } @@ -1949,7 +1953,17 @@ R"(#define ( code ) _Generic( (code), \ header.print( rf_ast_types ); header.print_fmt("\n#pragma endregion AST\n"); + header.print( fmt_newline); + header.print( rf_array_arena ); + header.print( fmt_newline); + header.print( rf_array_pool); + header.print( fmt_newline); + header.print( rf_array_string_cached ); + header.print( fmt_newline); + header.print( rf_ht_preprocessor_macro ); + header.print( rf_interface ); + header.print( rf_constants ); header.print(fmt_newline); header.print_fmt("#pragma region Inlines\n"); @@ -1957,9 +1971,7 @@ R"(#define ( code ) _Generic( (code), \ header.print_fmt("#pragma endregion Inlines\n"); header.print(fmt_newline); - header.print( rf_array_string_cached ); - header.print( rf_header_end ); header.print( rf_header_builder ); header.print( rf_header_scanner ); @@ -1976,11 +1988,6 @@ R"(#define ( code ) _Generic( (code), \ builder_print( src, src_start ); src.print_fmt( "\nGEN_NS_BEGIN\n"); - src.print( fmt_newline); - src.print( rf_array_arena ); - src.print( fmt_newline); - src.print( rf_array_pool); - src.print( r_src_static_data ); src.print( fmt_newline); @@ -1998,6 +2005,7 @@ R"(#define ( code ) _Generic( (code), \ src.print( fmt_newline); src.print( rf_array_code_typename ); src.print( fmt_newline); + src.print( r_src_parser_case_macros ); src.print( rf_src_parser ); src.print( r_src_parsing ); src.print_fmt( "\n#pragma endregion Parsing\n" ); diff --git a/gen_c_library/components/header_start.hpp b/gen_c_library/components/header_start.hpp index 268f644..ff8dd37 100644 --- a/gen_c_library/components/header_start.hpp +++ b/gen_c_library/components/header_start.hpp @@ -13,7 +13,7 @@ | \_____|\___}_l |_|\___} .__/| .__/ {_____/ \__\__/_l\__. |\___/\__,_l \____}{_____}{_____} | | | | | | __} | | | l_l l_l {___/ | - ! ----------------------------------------------------------------------- VERSION: v0.23-Alpha | + ! ----------------------------------------------------------------------- VERSION: v0.25-Alpha | ! ============================================================================================= | ! WARNING: THIS IS AN ALPHA VERSION OF THE LIBRARY, USE AT YOUR OWN DISCRETION | ! NEVER DO CODE GENERATION WITHOUT AT LEAST HAVING CONTENT IN A CODEBASE UNDER VERSION CONTROL | diff --git a/gen_c_library/gen_c_lib.c b/gen_c_library/gen_c_lib.c index 80b1e43..83a3b6d 100644 --- a/gen_c_library/gen_c_lib.c +++ b/gen_c_library/gen_c_lib.c @@ -1,3 +1,6 @@ #define GEN_IMPLEMENTATION #define GEN_DONT_ENFORCE_GEN_TIME_GUARD +#define GEN_DEFINE_LIBRARY_CORE_CONSTANTS +#define GEN_ENFORCE_STRONG_CODE_TYPES +#define GEN_EXPOSE_BACKEND #include "gen/gen_singleheader.h" diff --git a/gen_segmented/segmented.cpp b/gen_segmented/segmented.cpp index 0237720..7707419 100644 --- a/gen_segmented/segmented.cpp +++ b/gen_segmented/segmented.cpp @@ -114,7 +114,7 @@ int gen_main() } CodeBody gen_component_header = def_global_body( args( - def_preprocess_cond( PreprocessCond_IfDef, txt("GEN_INTELLISENSE_DIRECTIVES") ), + def_preprocess_cond( PreprocessCond_IfDef, txt("INTELLISENSE_DIRECTIVES") ), pragma_once, def_include(txt("components/types.hpp")), preprocess_endif, @@ -131,8 +131,8 @@ int gen_main() Code ast_types = scan_file( path_base "components/ast_types.hpp" ); Code code_types = scan_file( path_base "components/code_types.hpp" ); Code interface = scan_file( path_base "components/interface.hpp" ); + Code constants = scan_file( path_base "components/constants.hpp"); Code inlines = scan_file( path_base "components/inlines.hpp" ); - Code header_end = scan_file( path_base "components/header_end.hpp" ); CodeBody ecode = gen_ecode ( path_base "enums/ECodeTypes.csv" ); CodeBody eoperator = gen_eoperator ( path_base "enums/EOperator.csv" ); @@ -168,6 +168,7 @@ int gen_main() builder_print_fmt( header, "\n#pragma endregion AST\n" ); builder_print( header, interface ); + builder_print( header, constants ); builder_print_fmt( header, "\n#pragma region Inlines\n" ); builder_print( header, inlines ); @@ -176,7 +177,6 @@ int gen_main() builder_print( header, fmt_newline ); builder_print_fmt( header, "#pragma endregion Inlines\n" ); - builder_print( header, header_end ); builder_print_fmt( header, "\nGEN_NS_END\n\n" ); builder_print( header, pop_ignores ); builder_write(header); diff --git a/gen_singleheader/components/header_start.hpp b/gen_singleheader/components/header_start.hpp index 996d040..b6dccbb 100644 --- a/gen_singleheader/components/header_start.hpp +++ b/gen_singleheader/components/header_start.hpp @@ -15,7 +15,7 @@ | \_____|\___}_l |_|\___} ,__/| ,__/ (_____/ \__\__/_|\__, |\___}\__,_l | | Singleheader | | | | __} | | | l_l l_l {___/ | - ! ----------------------------------------------------------------------- VERSION: v0.23-Alpha | + ! ----------------------------------------------------------------------- VERSION: v0.25-Alpha | ! ============================================================================================ | ! WARNING: THIS IS AN ALPHA VERSION OF THE LIBRARY, USE AT YOUR OWN DISCRETION | ! NEVER DO CODE GENERATION WITHOUT AT LEAST HAVING CONTENT IN A CODEBASE UNDER VERSION CONTROL | diff --git a/gen_singleheader/singleheader.cpp b/gen_singleheader/singleheader.cpp index 2cce68c..df1f7f1 100644 --- a/gen_singleheader/singleheader.cpp +++ b/gen_singleheader/singleheader.cpp @@ -117,8 +117,8 @@ int gen_main() Code ast_types = scan_file( path_base "components/ast_types.hpp" ); Code code_types = scan_file( path_base "components/code_types.hpp" ); Code interface = scan_file( path_base "components/interface.hpp" ); + Code constants = scan_file( path_base "components/constants.hpp" ); Code inlines = scan_file( path_base "components/inlines.hpp" ); - Code header_end = scan_file( path_base "components/header_end.hpp" ); CodeBody ecode = gen_ecode ( path_base "enums/ECodeTypes.csv" ); CodeBody eoperator = gen_eoperator ( path_base "enums/EOperator.csv" ); @@ -149,6 +149,7 @@ int gen_main() header.print_fmt("\n#pragma endregion AST\n"); header.print( interface ); + header.print( constants ); header.print_fmt( "\n#pragma region Inlines\n" ); header.print( inlines ); @@ -156,8 +157,6 @@ int gen_main() header.print( fmt_newline ); header.print_fmt( "#pragma endregion Inlines\n" ); - header.print( header_end ); - if ( generate_builder ) { header.print( scan_file( path_base "auxiliary/builder.hpp" ) ); } diff --git a/gen_unreal_engine/components/header_start.hpp b/gen_unreal_engine/components/header_start.hpp index d88dccb..988dba5 100644 --- a/gen_unreal_engine/components/header_start.hpp +++ b/gen_unreal_engine/components/header_start.hpp @@ -16,7 +16,7 @@ | \_____|\___}_l |_|\___} ,__/| ,__/ (_____/ \__\__/_|\__, |\___}\__,_l | | Unreal Engine | | | | __} | | | l_l l_l {___/ | - ! ----------------------------------------------------------------------- VERSION: v0.23-Alpha | + ! ----------------------------------------------------------------------- VERSION: v0.25-Alpha | ! ============================================================================================ | ! WARNING: THIS IS AN ALPHA VERSION OF THE LIBRARY, USE AT YOUR OWN DISCRETION | ! NEVER DO CODE GENERATION WITHOUT AT LEAST HAVING CONTENT IN A CODEBASE UNDER VERSION CONTROL | diff --git a/gen_unreal_engine/enums/ESpecifier.csv b/gen_unreal_engine/enums/ESpecifier.csv index aa3d550..333d9dc 100644 --- a/gen_unreal_engine/enums/ESpecifier.csv +++ b/gen_unreal_engine/enums/ESpecifier.csv @@ -24,4 +24,5 @@ Final, final NoExceptions, noexcept Override, override Pure, = 0 +Delete, = delete Volatile, volatile diff --git a/gen_unreal_engine/unreal.cpp b/gen_unreal_engine/unreal.cpp index 48ff8bd..9927346 100644 --- a/gen_unreal_engine/unreal.cpp +++ b/gen_unreal_engine/unreal.cpp @@ -224,8 +224,8 @@ int gen_main() Code ast_types = scan_file( path_base "components/ast_types.hpp" ); Code code_types = scan_file( path_base "components/code_types.hpp" ); Code interface = scan_file( path_base "components/interface.hpp" ); + Code constants = scan_file( path_base "components/constants.hpp" ); Code inlines = scan_file( path_base "components/inlines.hpp" ); - Code header_end = scan_file( path_base "components/header_end.hpp" ); CodeBody ecode = gen_ecode ( path_base "enums/ECodeTypes.csv" ); CodeBody eoperator = gen_eoperator ( path_base "enums/EOperator.csv" ); @@ -266,6 +266,7 @@ int gen_main() header.print_fmt( "\n#pragma endregion AST\n" ); header.print( interface ); + header.print( constants ); header.print_fmt( "\n#pragma region Inlines\n" ); header.print( inlines ); @@ -274,7 +275,6 @@ int gen_main() header.print( fmt_newline ); header.print_fmt( "#pragma endregion Inlines\n" ); - header.print( header_end ); header.print_fmt( "\nGEN_NS_END\n\n" ); header.print( pop_ignores ); header.write(); diff --git a/scripts/build.ci.ps1 b/scripts/build.ci.ps1 index 507b3b1..3809bf3 100644 --- a/scripts/build.ci.ps1 +++ b/scripts/build.ci.ps1 @@ -172,7 +172,7 @@ if ( $segmented ) write-host `t $_ -ForegroundColor Green } } - write-host "`nBootstrap completed in $($time_taken.TotalMilliseconds) ms" + write-host "`nSegmented completed in $($time_taken.TotalMilliseconds) ms" } Pop-Location } @@ -263,6 +263,7 @@ if ( $c_lib_static ) $compiler_args += $flag_all_c $compiler_args += $flag_updated_cpp_macro $compiler_args += $flag_c11 + $compiler_args += ($flag_define + 'GEN_STATIC_LINK') $linker_args = @() $result = build-simple $path_build $includes $compiler_args $linker_args $unit $path_lib diff --git a/scripts/helpers/vendor_toolchain.ps1 b/scripts/helpers/vendor_toolchain.ps1 index d183b74..f1f1baa 100644 --- a/scripts/helpers/vendor_toolchain.ps1 +++ b/scripts/helpers/vendor_toolchain.ps1 @@ -564,6 +564,7 @@ if ( $vendor -match "msvc" ) # Check if output is a static library if ( $binary -match '\.lib$' ) { + write-host "Running archiver for $binary" $lib_args = @() $lib_args += $flag_nologo $lib_args += $flag_link_win_machine_64 diff --git a/test/c_library/test.c b/test/c_library/test.c index 89f7487..2dbf524 100644 --- a/test/c_library/test.c +++ b/test/c_library/test.c @@ -1,4 +1,4 @@ -#if GEN_INTELLISENSE_DIRECTIVES +#if INTELLISENSE_DIRECTIVES #include "../../gen_c_library/gen/gen_singleheader.h" #endif