diff --git a/base/auxillary/builder.cpp b/base/auxillary/builder.cpp index 606ab33..02adda8 100644 --- a/base/auxillary/builder.cpp +++ b/base/auxillary/builder.cpp @@ -15,7 +15,9 @@ Builder builder_open( char const* path ) return result; } - result.Buffer = strbuilder_make_reserve( _ctx->Allocator_Temp, _ctx->InitSize_BuilderBuffer ); + Context* ctx = get_context(); + GEN_ASSERT_NOT_NULL(ctx); + result.Buffer = strbuilder_make_reserve( ctx->Allocator_Temp, ctx->InitSize_BuilderBuffer ); // log_fmt("$Builder - Opened file: %s\n", result.File.filename ); return result; diff --git a/base/auxillary/builder.hpp b/base/auxillary/builder.hpp index 1de05c3..1729fe0 100644 --- a/base/auxillary/builder.hpp +++ b/base/auxillary/builder.hpp @@ -25,13 +25,14 @@ Builder builder_open ( char const* path ); void builder_pad_lines ( Builder* builder, s32 num ); void builder_print ( Builder* builder, Code code ); void builder_print_fmt_va( Builder* builder, char const* fmt, va_list va ); -void builder_print_fmt ( Builder* builder, char const* fmt, ... ) { +void builder_write ( Builder* builder ); + +forceinline void builder_print_fmt ( Builder* builder, char const* fmt, ... ) { va_list va; va_start( va, fmt ); builder_print_fmt_va( builder, fmt, va ); va_end( va ); } -void builder_write( Builder* builder ); struct Builder { @@ -56,10 +57,10 @@ struct Builder }; #if GEN_COMPILER_CPP && ! GEN_C_LIKE_CPP -void builder_pad_lines( Builder& builder, s32 num ) { return builder_pad_lines(& builder, num); } -void builder_print ( Builder& builder, Code code ) { return builder_print(& builder, code); } -void builder_write ( Builder& builder ) { return builder_write(& builder ); } -void builder_print_fmt( Builder& builder, char const* fmt, ...) { +forceinline void builder_pad_lines( Builder& builder, s32 num ) { return builder_pad_lines(& builder, num); } +forceinline void builder_print ( Builder& builder, Code code ) { return builder_print(& builder, code); } +forceinline void builder_write ( Builder& builder ) { return builder_write(& builder ); } +forceinline void builder_print_fmt( Builder& builder, char const* fmt, ...) { va_list va; va_start( va, fmt ); builder_print_fmt_va( & builder, fmt, va ); diff --git a/base/auxillary/scanner.cpp b/base/auxillary/scanner.cpp index 94f5e48..6cde239 100644 --- a/base/auxillary/scanner.cpp +++ b/base/auxillary/scanner.cpp @@ -20,7 +20,7 @@ Code scan_file( char const* path ) GEN_FATAL("scan_file: %s is empty", path ); } - StrBuilder str = strbuilder_make_reserve( _ctx->Allocator_Temp, fsize ); + StrBuilder str = strbuilder_make_reserve( get_context()->Allocator_Temp, fsize ); file_read( & file, str, fsize ); strbuilder_get_header(str)->Length = fsize; @@ -117,7 +117,7 @@ Code scan_file( char const* path ) } CodeBody parse_file( const char* path ) { - FileContents file = file_read_contents( _ctx->Allocator_Temp, true, path ); + FileContents file = file_read_contents( get_context()->Allocator_Temp, true, path ); Str content = { (char const*)file.data, file.size }; CodeBody code = parse_global_body( content ); log_fmt("\nParsed: %s\n", path); diff --git a/base/components/ast.cpp b/base/components/ast.cpp index c538a4c..55067bf 100644 --- a/base/components/ast.cpp +++ b/base/components/ast.cpp @@ -36,7 +36,6 @@ Str code_debug_str(Code self) case CT_Execution: case CT_Comment: case CT_PlatformAttributes: - case CT_Preprocess_Define: case CT_Preprocess_Include: case CT_Preprocess_Pragma: case CT_Preprocess_If: @@ -52,6 +51,11 @@ Str code_debug_str(Code self) strbuilder_append_fmt( result, "\n\tContent: %S", self->Content ); break; + case CT_Preprocess_Define: + // TODO(ED): Needs implementaton + log_failure("code_debug_str: NOT IMPLEMENTED for CT_Preprocess_Define"); + break; + case CT_Class: case CT_Struct: if ( self->Prev ) @@ -259,6 +263,11 @@ Str code_debug_str(Code self) strbuilder_append_fmt( result, "\n\tValue : %S", self->Value ? strbuilder_to_str( code_to_strbuilder(self->Value)) : txt("Null") ); break; + case CT_Parameters_Define: + // TODO(ED): Needs implementaton + log_failure("code_debug_str: NOT IMPLEMENTED for CT_Parameters_Define"); + break; + case CT_Specifiers: { strbuilder_append_fmt( result, "\n\tNumEntries: %d", self->NumEntries ); @@ -497,6 +506,10 @@ void code_to_strbuilder_ptr( Code self, StrBuilder* result ) params_to_strbuilder_ref(cast(CodeParams, self), result ); break; + case CT_Parameters_Define: + define_params_to_strbuilder_ref(cast(CodeDefineParams, self), result); + break; + case CT_Preprocess_Define: define_to_strbuilder_ref(cast(CodeDefine, self), result ); break; @@ -987,11 +1000,17 @@ bool code_is_equal( Code self, Code other ) return true; } + case CT_Parameters_Define: + { + // TODO(ED): Needs implementaton + log_failure("code_is_equal: NOT IMPLEMENTED for CT_Parameters_Define"); + return false; + } + case CT_Preprocess_Define: { check_member_str( Name ); - check_member_content( Content ); - + check_member_content( Body->Content ); return true; } diff --git a/base/components/ast.hpp b/base/components/ast.hpp index ac39d08..007c52d 100644 --- a/base/components/ast.hpp +++ b/base/components/ast.hpp @@ -26,6 +26,7 @@ struct AST_Constructor; // struct AST_BaseClass; struct AST_Class; struct AST_Define; +struct AST_DefineParams; struct AST_Destructor; struct AST_Enum; struct AST_Exec; @@ -98,6 +99,7 @@ typedef AST_Comment* CodeComment; typedef AST_Class* CodeClass; typedef AST_Constructor* CodeConstructor; typedef AST_Define* CodeDefine; +typedef AST_DefineParams* CodeDefineParams; typedef AST_Destructor* CodeDestructor; typedef AST_Enum* CodeEnum; typedef AST_Exec* CodeExec; @@ -120,6 +122,7 @@ struct CodeComment; struct CodeClass; struct CodeConstructor; struct CodeDefine; +struct CodeDefineParams; struct CodeDestructor; struct CodeEnum; struct CodeExec; @@ -305,6 +308,7 @@ struct Code operator CodeClass() const; operator CodeConstructor() const; operator CodeDefine() const; + operator CodeDefineParams() const; operator CodeDestructor() const; operator CodeExec() const; operator CodeEnum() const; @@ -365,6 +369,7 @@ int AST_ArrSpecs_Cap = /* Simple AST POD with functionality to seralize into C++ syntax. + TODO(Ed): Eventually haven't a transparent AST like this will longer be viable once statements & expressions are in (most likely....) */ struct AST { @@ -372,7 +377,7 @@ struct AST struct { Code InlineCmt; // Class, Constructor, Destructor, Enum, Friend, Functon, Operator, OpCast, Struct, Typedef, Using, Variable - Code Attributes; // Class, Enum, Function, Struct, Typedef, Union, Using, Variable + Code Attributes; // Class, Enum, Function, Struct, Typedef, Union, Using, Variable // TODO(Ed): Parameters can have attributes Code Specs; // Destructor, Function, Operator, Typename, Variable union { Code InitializerList; // Constructor @@ -384,12 +389,12 @@ struct AST union { Code Macro; // Parameter Code BitfieldSize; // Variable (Class/Struct Data Member) - Code Params; // Constructor, Function, Operator, Template, Typename + Code Params; // Constructor, Define, Function, Operator, Template, Typename Code UnderlyingTypeMacro; // Enum }; union { Code ArrExpr; // Typename - Code Body; // Class, Constructor, Destructor, Enum, Friend, Function, Namespace, Struct, Union + Code Body; // Class, Constructor, Define, Destructor, Enum, Friend, Function, Namespace, Struct, Union Code Declaration; // Friend, Template Code Value; // Parameter, Variable }; diff --git a/base/components/ast_types.hpp b/base/components/ast_types.hpp index f11e72e..5efd39a 100644 --- a/base/components/ast_types.hpp +++ b/base/components/ast_types.hpp @@ -42,13 +42,14 @@ struct AST_Body }; static_assert( sizeof(AST_Body) == sizeof(AST), "ERROR: AST_Body is not the same size as AST"); +// TODO(Ed): Support chaining attributes (Use parameter linkage pattern) struct AST_Attributes { union { char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ]; StrCached Content; }; - StrCached Name; + StrCached Name; Code Prev; Code Next; Token* Tok; @@ -146,9 +147,15 @@ struct AST_Define { union { char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ]; - StrCached Content; + struct + { + char _PAD_PROPERTIES_ [ sizeof(AST*) * 4 ]; + CodeDefineParams Params; + Code Body; // Should be completely serialized for now to a: StrCached Content. + char _PAD_PROPERTIES_2_ [ sizeof(AST*) * 1 ]; + }; }; - StrCached Name; + StrCached Name; Code Prev; Code Next; Token* Tok; @@ -158,6 +165,22 @@ struct AST_Define }; static_assert( sizeof(AST_Define) == sizeof(AST), "ERROR: AST_Define is not the same size as AST"); +struct AST_DefineParams +{ + union { + char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ]; + }; + StrCached Name; + CodeDefineParams Last; + CodeDefineParams Next; + Token* Tok; + Code Parent; + CodeType Type; + char _PAD_UNUSED_[ sizeof(ModuleFlag) ]; + s32 NumEntries; +}; +static_assert( sizeof(AST_DefineParams) == sizeof(AST), "ERROR: AST_DefineParams is not the same size as AST"); + struct AST_Destructor { union { @@ -660,6 +683,7 @@ struct AST_Params char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ]; struct { + // TODO(Ed): Support attributes for parameters (Some prefix macros can be converted to that...) char _PAD_PROPERTIES_2_[ sizeof(AST*) * 3 ]; CodeTypename ValueType; Code Macro; @@ -668,7 +692,7 @@ struct AST_Params // char _PAD_PROPERTIES_3_[sizeof( AST* )]; }; }; - StrCached Name; + StrCached Name; CodeParams Last; CodeParams Next; Token* Tok; diff --git a/base/components/code_serialization.cpp b/base/components/code_serialization.cpp index 2161c21..94e601a 100644 --- a/base/components/code_serialization.cpp +++ b/base/components/code_serialization.cpp @@ -176,7 +176,7 @@ void class_to_strbuilder_def( CodeClass self, StrBuilder* result ) { GEN_ASSERT(self); - if ( bitfield_is_equal( u32, self->ModuleFlags, ModuleFlag_Export )) + if ( bitfield_is_set( u32, self->ModuleFlags, ModuleFlag_Export )) strbuilder_append_str( result, txt("export ") ); strbuilder_append_str( result, txt("class ") ); @@ -221,7 +221,7 @@ void class_to_strbuilder_fwd( CodeClass self, StrBuilder* result ) { GEN_ASSERT(self); - if ( bitfield_is_equal( u32, self->ModuleFlags, ModuleFlag_Export )) + if ( bitfield_is_set( u32, self->ModuleFlags, ModuleFlag_Export )) strbuilder_append_str( result, txt("export ") ); if ( self->Attributes ) @@ -241,12 +241,48 @@ void class_to_strbuilder_fwd( CodeClass self, StrBuilder* result ) StrBuilder define_to_strbuilder(CodeDefine define) { - return strbuilder_fmt_buf( _ctx->Allocator_Temp, "#define %S %S", define->Name, define->Content ); + 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 ) { - strbuilder_append_fmt( result, "#define %S %S", define->Name, define->Content ); + GEN_ASSERT(define); + GEN_ASSERT(define->Body); + GEN_ASSERT(define->Body->Content.Ptr && define->Body->Content.Len > 0); + if (define->Params) { + StrBuilder params_builder = define_params_to_strbuilder(define->Params); + strbuilder_append_fmt( result, "#define %S(%S) %S", define->Name, strbuilder_to_str(params_builder), define->Body->Content ); + } + else { + strbuilder_append_fmt( result, "#define %S %S", define->Name, define->Body->Content ); + } +} + +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); + GEN_ASSERT(result); + if ( self->Name.Ptr && self->Name.Len ) + { + strbuilder_append_fmt( result, " %S", self->Name ); + } + if ( self->NumEntries - 1 > 0 ) + { + for ( CodeDefineParams param = begin_CodeDefineParams(self->Next); param != end_CodeDefineParams(self->Next); param = next_CodeDefineParams(self->Next, param) ) + { + strbuilder_append_fmt( result, ", %SB", define_params_to_strbuilder(param) ); + } + } } StrBuilder destructor_to_strbuilder(CodeDestructor self) @@ -329,7 +365,7 @@ StrBuilder enum_to_strbuilder(CodeEnum self) void enum_to_strbuilder_def(CodeEnum self, StrBuilder* result ) { - if ( bitfield_is_equal( u32, self->ModuleFlags, ModuleFlag_Export )) + if ( bitfield_is_set( u32, self->ModuleFlags, ModuleFlag_Export )) strbuilder_append_str( result, txt("export ") ); if ( self->Attributes || self->UnderlyingType || self->UnderlyingTypeMacro ) @@ -362,7 +398,7 @@ void enum_to_strbuilder_def(CodeEnum self, StrBuilder* result ) void enum_to_strbuilder_fwd(CodeEnum self, StrBuilder* result ) { - if ( bitfield_is_equal( u32, self->ModuleFlags, ModuleFlag_Export )) + if ( bitfield_is_set( u32, self->ModuleFlags, ModuleFlag_Export )) strbuilder_append_str( result, txt("export ") ); if ( self->Attributes ) @@ -389,7 +425,7 @@ void enum_to_strbuilder_fwd(CodeEnum self, StrBuilder* result ) void enum_to_strbuilder_class_def(CodeEnum self, StrBuilder* result ) { - if ( bitfield_is_equal( u32, self->ModuleFlags, ModuleFlag_Export )) + if ( bitfield_is_set( u32, self->ModuleFlags, ModuleFlag_Export )) strbuilder_append_str( result, txt("export ") ); if ( self->Attributes || self->UnderlyingType ) @@ -421,7 +457,7 @@ void enum_to_strbuilder_class_def(CodeEnum self, StrBuilder* result ) void enum_to_strbuilder_class_fwd(CodeEnum self, StrBuilder* result ) { - if ( bitfield_is_equal( u32, self->ModuleFlags, ModuleFlag_Export )) + if ( bitfield_is_set( u32, self->ModuleFlags, ModuleFlag_Export )) strbuilder_append_str( result, txt("export ") ); strbuilder_append_str( result, txt("enum class ") ); @@ -505,7 +541,7 @@ StrBuilder fn_to_strbuilder(CodeFn self) void fn_to_strbuilder_def(CodeFn self, StrBuilder* result ) { - if ( bitfield_is_equal( u32, self->ModuleFlags, ModuleFlag_Export )) + if ( bitfield_is_set( u32, self->ModuleFlags, ModuleFlag_Export )) strbuilder_append_str( result, txt("export") ); if ( self->Attributes ) @@ -558,7 +594,7 @@ void fn_to_strbuilder_def(CodeFn self, StrBuilder* result ) void fn_to_strbuilder_fwd(CodeFn self, StrBuilder* result ) { - if ( bitfield_is_equal( u32, self->ModuleFlags, ModuleFlag_Export )) + if ( bitfield_is_set( u32, self->ModuleFlags, ModuleFlag_Export )) strbuilder_append_str( result, txt("export ") ); if ( self->Attributes ) @@ -646,7 +682,7 @@ StrBuilder namespace_to_strbuilder(CodeNS self) void namespace_to_strbuilder_ref(CodeNS self, StrBuilder* result ) { - if ( bitfield_is_equal( u32, self->ModuleFlags, ModuleFlag_Export )) + 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) ); @@ -671,7 +707,7 @@ StrBuilder code_op_to_strbuilder(CodeOperator self) void code_op_to_strbuilder_def(CodeOperator self, StrBuilder* result ) { - if ( bitfield_is_equal( u32, self->ModuleFlags, ModuleFlag_Export )) + if ( bitfield_is_set( u32, self->ModuleFlags, ModuleFlag_Export )) strbuilder_append_str( result, txt("export ") ); if ( self->Attributes ) @@ -725,7 +761,7 @@ void code_op_to_strbuilder_def(CodeOperator self, StrBuilder* result ) void code_op_to_strbuilder_fwd(CodeOperator self, StrBuilder* result ) { - if ( bitfield_is_equal( u32, self->ModuleFlags, ModuleFlag_Export )) + if ( bitfield_is_set( u32, self->ModuleFlags, ModuleFlag_Export )) strbuilder_append_str( result, txt("export ") ); if ( self->Attributes ) @@ -865,7 +901,6 @@ void opcast_to_strbuilder_fwd(CodeOpCast self, StrBuilder* result ) StrBuilder params_to_strbuilder(CodeParams self) { - GEN_ASSERT(self); GEN_ASSERT(self); StrBuilder result = strbuilder_make_reserve( _ctx->Allocator_Temp, 128 ); params_to_strbuilder_ref( self, & result ); @@ -1030,7 +1065,7 @@ void struct_to_strbuilder_def( CodeStruct self, StrBuilder* result ) { GEN_ASSERT(self); GEN_ASSERT(result); - if ( bitfield_is_equal( u32, self->ModuleFlags, ModuleFlag_Export )) + if ( bitfield_is_set( u32, self->ModuleFlags, ModuleFlag_Export )) strbuilder_append_str( result, txt("export ") ); strbuilder_append_str( result, txt("struct ") ); @@ -1076,7 +1111,7 @@ void struct_to_strbuilder_fwd( CodeStruct self, StrBuilder* result ) { GEN_ASSERT(self); GEN_ASSERT(result); - if ( bitfield_is_equal( u32, self->ModuleFlags, ModuleFlag_Export )) + if ( bitfield_is_set( u32, self->ModuleFlags, ModuleFlag_Export )) strbuilder_append_str( result, txt("export ") ); if ( self->Attributes ) @@ -1105,7 +1140,7 @@ void template_to_strbuilder_ref(CodeTemplate self, StrBuilder* result ) { GEN_ASSERT(self); GEN_ASSERT(result); - if ( bitfield_is_equal( u32, self->ModuleFlags, ModuleFlag_Export )) + if ( bitfield_is_set( u32, self->ModuleFlags, ModuleFlag_Export )) strbuilder_append_str( result, txt("export ") ); if ( self->Params ) @@ -1123,7 +1158,7 @@ StrBuilder typedef_to_strbuilder(CodeTypedef self) void typedef_to_strbuilder_ref(CodeTypedef self, StrBuilder* result ) { - if ( bitfield_is_equal( u32, self->ModuleFlags, ModuleFlag_Export )) + if ( bitfield_is_set( u32, self->ModuleFlags, ModuleFlag_Export )) strbuilder_append_str( result, txt("export ") ); strbuilder_append_str( result, txt("typedef ")); @@ -1236,7 +1271,7 @@ StrBuilder union_to_strbuilder(CodeUnion self) void union_to_strbuilder_def(CodeUnion self, StrBuilder* result ) { - if ( bitfield_is_equal( u32, self->ModuleFlags, ModuleFlag_Export )) + if ( bitfield_is_set( u32, self->ModuleFlags, ModuleFlag_Export )) strbuilder_append_str( result, txt("export ") ); strbuilder_append_str( result, txt("union ") ); @@ -1267,7 +1302,7 @@ void union_to_strbuilder_fwd(CodeUnion self, StrBuilder* result ) { GEN_ASSERT(self); GEN_ASSERT(result); - if ( bitfield_is_equal( u32, self->ModuleFlags, ModuleFlag_Export )) + if ( bitfield_is_set( u32, self->ModuleFlags, ModuleFlag_Export )) strbuilder_append_str( result, txt("export ") ); strbuilder_append_str( result, txt("union ") ); @@ -1304,7 +1339,7 @@ void using_to_strbuilder_ref(CodeUsing self, StrBuilder* result ) { GEN_ASSERT(self); GEN_ASSERT(result); - if ( bitfield_is_equal( u32, self->ModuleFlags, ModuleFlag_Export )) + if ( bitfield_is_set( u32, self->ModuleFlags, ModuleFlag_Export )) strbuilder_append_str( result, txt("export ") ); if ( self->Attributes ) @@ -1401,7 +1436,7 @@ void var_to_strbuilder_ref(CodeVar self, StrBuilder* result ) return; } - if ( bitfield_is_equal( u32, self->ModuleFlags, ModuleFlag_Export )) + if ( bitfield_is_set( u32, self->ModuleFlags, ModuleFlag_Export )) strbuilder_append_str( result, txt("export ") ); if ( self->Attributes || self->Specs ) diff --git a/base/components/code_types.hpp b/base/components/code_types.hpp index 414d8c7..26d5316 100644 --- a/base/components/code_types.hpp +++ b/base/components/code_types.hpp @@ -32,7 +32,17 @@ 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 params_append (CodeParams params, CodeParams param ); +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 ); +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); + +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 ); @@ -192,12 +202,11 @@ struct CodeParams { #if ! GEN_C_LIKE_CPP Using_Code( CodeParams ); - forceinline void append( CodeParams other ); - forceinline CodeParams get( s32 idx ); - forceinline bool has_entries(); - forceinline StrBuilder to_strbuilder(); - forceinline void to_strbuilder( StrBuilder& result ); - + forceinline void append( CodeParams other ) { return params_append(* this, other); } + forceinline CodeParams get( s32 idx ) { return params_get( * this, idx); } + forceinline bool has_entries() { return params_has_entries(* this); } + forceinline StrBuilder to_strbuilder() { return params_to_strbuilder(* this); } + forceinline void to_strbuilder( StrBuilder& result ) { return params_to_strbuilder_ref(*this, & result); } #endif Using_CodeOps( CodeParams ); forceinline CodeParams begin() { return begin_CodeParams(* this); } @@ -212,6 +221,29 @@ struct CodeParams AST_Params* ast; }; +struct CodeDefineParams +{ +#if ! GEN_C_LIKE_CPP + Using_Code( CodeDefineParams ); + forceinline void append( CodeDefineParams other ) { return params_append( cast(CodeParams, * this), cast(CodeParams, other)); } + forceinline CodeDefineParams get( s32 idx ) { return (CodeDefineParams) (Code) params_get( cast(CodeParams, * this), idx); } + forceinline bool has_entries() { return params_has_entries( cast(CodeParams, * this)); } + forceinline StrBuilder to_strbuilder() { return define_params_to_strbuilder(* this); } + forceinline void to_strbuilder( StrBuilder& result ) { return define_params_to_strbuilder_ref(* this, & result); } +#endif + Using_CodeOps( CodeDefineParams ); + forceinline CodeDefineParams begin() { return (CodeDefineParams) (Code) begin_CodeParams( cast(CodeParams, * this)); } + forceinline CodeDefineParams end() { return (CodeDefineParams) (Code) end_CodeParams( cast(CodeParams, * this)); } + forceinline operator Code() { return { (AST*)ast }; } + forceinline CodeDefineParams operator *() { return * this; } // Required to support for-range iteration. + forceinline AST_DefineParams* operator->() { + GEN_ASSERT(ast); + return ast; + } + forceinline CodeDefineParams& operator++(); + AST_DefineParams* ast; +}; + struct CodeSpecifiers { #if ! GEN_C_LIKE_CPP @@ -941,6 +973,7 @@ struct InvalidCode_ImplictCaster operator CodeClass () const { return cast(CodeClass, Code_Invalid); } operator CodeConstructor () const { return cast(CodeConstructor, Code_Invalid); } operator CodeDefine () const { return cast(CodeDefine, Code_Invalid); } + operator CodeDefineParams () const { return cast(CodeDefineParams, Code_Invalid); } operator CodeDestructor () const { return cast(CodeDestructor, Code_Invalid); } operator CodeExec () const { return cast(CodeExec, Code_Invalid); } operator CodeEnum () const { return cast(CodeEnum, Code_Invalid); } @@ -974,6 +1007,7 @@ struct NullCode_ImplicitCaster operator CodeClass () const { return {nullptr}; } operator CodeConstructor () const { return {nullptr}; } operator CodeDefine () const { return {nullptr}; } + operator CodeDefineParams () const { return {nullptr}; } operator CodeDestructor () const { return {nullptr}; } operator CodeExec () const { return {nullptr}; } operator CodeEnum () const { return {nullptr}; } @@ -1024,17 +1058,23 @@ forceinline StrBuilder to_strbuilder ( CodeClass self ) forceinline void to_strbuilder_def( CodeClass self, StrBuilder& result ) { return class_to_strbuilder_def(self, & result); } forceinline void to_strbuilder_fwd( CodeClass self, StrBuilder& result ) { return class_to_strbuilder_fwd(self, & result); } -forceinline void append (CodeParams params, CodeParams param ) { return params_append(params, param); } -forceinline CodeParams get (CodeParams params, s32 idx) { return params_get(params, idx); } -forceinline bool has_entries (CodeParams params ) { return params_has_entries(params); } -forceinline StrBuilder to_strbuilder(CodeParams params ) { return params_to_strbuilder(params); } -forceinline void to_strbuilder(CodeParams params, StrBuilder& result ) { return params_to_strbuilder_ref(params, & result); } +forceinline void append (CodeDefineParams appendee, CodeDefineParams other ) { params_append(cast(CodeParams, appendee), cast(CodeParams, other)); } +forceinline CodeDefineParams get (CodeDefineParams params, s32 idx) { return (CodeDefineParams) (Code) params_get(cast(CodeParams, params), idx); } +forceinline bool has_entries (CodeDefineParams params ) { return params_has_entries(cast(CodeParams, params)); } +forceinline StrBuilder to_strbuilder(CodeDefineParams params ) { return define_params_to_strbuilder(params); } +forceinline void to_strbuilder(CodeDefineParams params, StrBuilder& result ) { return define_params_to_strbuilder_ref(params, & result); } + +forceinline void append (CodeParams appendee, CodeParams other ) { return params_append(appendee, other); } +forceinline CodeParams get (CodeParams params, s32 idx) { return params_get(params, idx); } +forceinline bool has_entries (CodeParams params ) { return params_has_entries(params); } +forceinline StrBuilder to_strbuilder(CodeParams params ) { return params_to_strbuilder(params); } +forceinline void to_strbuilder(CodeParams params, StrBuilder& result ) { return params_to_strbuilder_ref(params, & result); } forceinline bool append (CodeSpecifiers specifiers, Specifier spec) { return specifiers_append(specifiers, spec); } forceinline s32 has (CodeSpecifiers specifiers, Specifier spec) { return specifiers_has(specifiers, spec); } forceinline s32 remove (CodeSpecifiers specifiers, Specifier to_remove ) { return specifiers_remove(specifiers, to_remove); } forceinline StrBuilder to_strbuilder(CodeSpecifiers specifiers) { return specifiers_to_strbuilder(specifiers); } -forceinline void to_strbuilder(CodeSpecifiers specifiers, StrBuilder& result) { return specifiers_to_strbuilder_ref(specifiers, & result); } +forceinline void to_strbuilder(CodeSpecifiers specifiers, StrBuilder& result) { return specifiers_to_strbuilder_ref(specifiers, & result); } forceinline void add_interface (CodeStruct self, CodeTypename interface) { return struct_add_interface(self, interface); } forceinline StrBuilder to_strbuilder (CodeStruct self) { return struct_to_strbuilder(self); } diff --git a/base/components/gen/ast_inlines.hpp b/base/components/gen/ast_inlines.hpp index 46e80ed..8f187b8 100644 --- a/base/components/gen/ast_inlines.hpp +++ b/base/components/gen/ast_inlines.hpp @@ -179,6 +179,22 @@ inline AST_Define* CodeDefine::operator->() return ast; } +inline CodeDefineParams& CodeDefineParams::operator=( Code other ) +{ + if ( other.ast != nullptr && other->Parent != nullptr ) + { + ast = rcast( decltype( ast ), code_duplicate( other ).ast ); + ast->Parent = { nullptr }; + } + ast = rcast( decltype( ast ), other.ast ); + return *this; +} + +inline CodeDefineParams::operator bool() +{ + return ast != nullptr; +} + inline CodeDestructor& CodeDestructor::operator=( Code other ) { if ( other.ast != nullptr && other->Parent != nullptr ) @@ -851,6 +867,11 @@ forceinline Code::operator CodeDefine() const return { (AST_Define*)ast }; } +forceinline Code::operator CodeDefineParams() const +{ + return { (AST_DefineParams*)ast }; +} + forceinline Code::operator CodeDestructor() const { return { (AST_Destructor*)ast }; diff --git a/base/components/gen/ecodetypes.hpp b/base/components/gen/ecodetypes.hpp index aaf6d0d..5973002 100644 --- a/base/components/gen/ecodetypes.hpp +++ b/base/components/gen/ecodetypes.hpp @@ -46,6 +46,7 @@ enum CodeType : u32 CT_Operator_Cast, CT_Operator_Cast_Fwd, CT_Parameters, + CT_Parameters_Define, CT_Preprocess_Define, CT_Preprocess_Include, CT_Preprocess_If, @@ -74,7 +75,7 @@ enum CodeType : u32 inline Str codetype_to_str( CodeType type ) { - local_persist Str lookup[61] = { + local_persist Str lookup[] = { { "Invalid", sizeof( "Invalid" ) - 1 }, { "Untyped", sizeof( "Untyped" ) - 1 }, { "NewLine", sizeof( "NewLine" ) - 1 }, @@ -114,6 +115,7 @@ inline Str codetype_to_str( CodeType type ) { "Operator_Cast", sizeof( "Operator_Cast" ) - 1 }, { "Operator_Cast_Fwd", sizeof( "Operator_Cast_Fwd" ) - 1 }, { "Parameters", sizeof( "Parameters" ) - 1 }, + { "Parameters_Define", sizeof( "Parameters_Define" ) - 1 }, { "Preprocess_Define", sizeof( "Preprocess_Define" ) - 1 }, { "Preprocess_Include", sizeof( "Preprocess_Include" ) - 1 }, { "Preprocess_If", sizeof( "Preprocess_If" ) - 1 }, @@ -142,7 +144,7 @@ inline Str codetype_to_str( CodeType type ) inline Str codetype_to_keyword_str( CodeType type ) { - local_persist Str lookup[61] = { + local_persist Str lookup[] = { { "__NA__", sizeof( "__NA__" ) - 1 }, { "__NA__", sizeof( "__NA__" ) - 1 }, { "__NA__", sizeof( "__NA__" ) - 1 }, @@ -182,6 +184,7 @@ inline Str codetype_to_keyword_str( CodeType type ) { "operator", sizeof( "operator" ) - 1 }, { "operator", sizeof( "operator" ) - 1 }, { "__NA__", sizeof( "__NA__" ) - 1 }, + { "__NA__", sizeof( "__NA__" ) - 1 }, { "define", sizeof( "define" ) - 1 }, { "include", sizeof( "include" ) - 1 }, { "if", sizeof( "if" ) - 1 }, diff --git a/base/components/gen/eoperator.hpp b/base/components/gen/eoperator.hpp index b447d7a..6a28f2b 100644 --- a/base/components/gen/eoperator.hpp +++ b/base/components/gen/eoperator.hpp @@ -60,7 +60,7 @@ enum Operator : u32 inline Str operator_to_str( Operator op ) { - local_persist Str lookup[47] = { + local_persist Str lookup[] = { { "INVALID", sizeof( "INVALID" ) - 1 }, { "=", sizeof( "=" ) - 1 }, { "+=", sizeof( "+=" ) - 1 }, diff --git a/base/components/gen/especifier.hpp b/base/components/gen/especifier.hpp index f75f94d..bfbcdd1 100644 --- a/base/components/gen/especifier.hpp +++ b/base/components/gen/especifier.hpp @@ -39,7 +39,7 @@ enum Specifier : u32 inline Str spec_to_str( Specifier type ) { - local_persist Str lookup[26] = { + local_persist Str lookup[] = { { "INVALID", sizeof( "INVALID" ) - 1 }, { "consteval", sizeof( "consteval" ) - 1 }, { "constexpr", sizeof( "constexpr" ) - 1 }, diff --git a/base/components/gen/etoktype.hpp b/base/components/gen/etoktype.hpp index 2f5ce6a..5b43e44 100644 --- a/base/components/gen/etoktype.hpp +++ b/base/components/gen/etoktype.hpp @@ -53,6 +53,7 @@ enum TokType : u32 Tok_Operator, Tok_Preprocess_Hash, Tok_Preprocess_Define, + Tok_Preprocess_Define_Param, Tok_Preprocess_If, Tok_Preprocess_IfDef, Tok_Preprocess_IfNotDef, @@ -62,7 +63,9 @@ enum TokType : u32 Tok_Preprocess_Include, Tok_Preprocess_Pragma, Tok_Preprocess_Content, - Tok_Preprocess_Macro, + Tok_Preprocess_Macro_Expr, + Tok_Preprocess_Macro_Stmt, + Tok_Preprocess_Macro_Typename, Tok_Preprocess_Unsupported, Tok_Spec_Alignas, Tok_Spec_Const, @@ -111,102 +114,105 @@ enum TokType : u32 inline Str toktype_to_str( TokType type ) { local_persist Str lookup[] = { - { "__invalid__", sizeof( "__invalid__" ) - 1 }, - { "private", sizeof( "private" ) - 1 }, - { "protected", sizeof( "protected" ) - 1 }, - { "public", sizeof( "public" ) - 1 }, - { ".", sizeof( "." ) - 1 }, - { "::", sizeof( "::" ) - 1 }, - { "&", sizeof( "&" ) - 1 }, - { "&&", sizeof( "&&" ) - 1 }, - { ":", sizeof( ":" ) - 1 }, - { "[[", sizeof( "[[" ) - 1 }, - { "]]", sizeof( "]]" ) - 1 }, - { "{", sizeof( "{" ) - 1 }, - { "}", sizeof( "}" ) - 1 }, - { "[", sizeof( "[" ) - 1 }, - { "]", sizeof( "]" ) - 1 }, - { "(", sizeof( "(" ) - 1 }, - { ")", sizeof( ")" ) - 1 }, - { "__comment__", sizeof( "__comment__" ) - 1 }, - { "__comment_end__", sizeof( "__comment_end__" ) - 1 }, - { "__comment_start__", sizeof( "__comment_start__" ) - 1 }, - { "__character__", sizeof( "__character__" ) - 1 }, - { ",", sizeof( "," ) - 1 }, - { "class", sizeof( "class" ) - 1 }, - { "__attribute__", sizeof( "__attribute__" ) - 1 }, - { "__declspec", sizeof( "__declspec" ) - 1 }, - { "enum", sizeof( "enum" ) - 1 }, - { "extern", sizeof( "extern" ) - 1 }, - { "friend", sizeof( "friend" ) - 1 }, - { "module", sizeof( "module" ) - 1 }, - { "namespace", sizeof( "namespace" ) - 1 }, - { "operator", sizeof( "operator" ) - 1 }, - { "struct", sizeof( "struct" ) - 1 }, - { "template", sizeof( "template" ) - 1 }, - { "typedef", sizeof( "typedef" ) - 1 }, - { "using", sizeof( "using" ) - 1 }, - { "union", sizeof( "union" ) - 1 }, - { "__identifier__", sizeof( "__identifier__" ) - 1 }, - { "import", sizeof( "import" ) - 1 }, - { "export", sizeof( "export" ) - 1 }, - { "__new_line__", sizeof( "__new_line__" ) - 1 }, - { "__number__", sizeof( "__number__" ) - 1 }, - { "__operator__", sizeof( "__operator__" ) - 1 }, - { "#", sizeof( "#" ) - 1 }, - { "define", sizeof( "define" ) - 1 }, - { "if", sizeof( "if" ) - 1 }, - { "ifdef", sizeof( "ifdef" ) - 1 }, - { "ifndef", sizeof( "ifndef" ) - 1 }, - { "elif", sizeof( "elif" ) - 1 }, - { "else", sizeof( "else" ) - 1 }, - { "endif", sizeof( "endif" ) - 1 }, - { "include", sizeof( "include" ) - 1 }, - { "pragma", sizeof( "pragma" ) - 1 }, - { "__macro_content__", sizeof( "__macro_content__" ) - 1 }, - { "__macro__", sizeof( "__macro__" ) - 1 }, - { "__unsupported__", sizeof( "__unsupported__" ) - 1 }, - { "alignas", sizeof( "alignas" ) - 1 }, - { "const", sizeof( "const" ) - 1 }, - { "consteval", sizeof( "consteval" ) - 1 }, - { "constexpr", sizeof( "constexpr" ) - 1 }, - { "constinit", sizeof( "constinit" ) - 1 }, - { "explicit", sizeof( "explicit" ) - 1 }, - { "extern", sizeof( "extern" ) - 1 }, - { "final", sizeof( "final" ) - 1 }, - { "forceinline", sizeof( "forceinline" ) - 1 }, - { "global", sizeof( "global" ) - 1 }, - { "inline", sizeof( "inline" ) - 1 }, - { "internal", sizeof( "internal" ) - 1 }, - { "local_persist", sizeof( "local_persist" ) - 1 }, - { "mutable", sizeof( "mutable" ) - 1 }, - { "neverinline", sizeof( "neverinline" ) - 1 }, - { "override", sizeof( "override" ) - 1 }, - { "static", sizeof( "static" ) - 1 }, - { "thread_local", sizeof( "thread_local" ) - 1 }, - { "volatile", sizeof( "volatile" ) - 1 }, - { "virtual", sizeof( "virtual" ) - 1 }, - { "*", sizeof( "*" ) - 1 }, - { ";", sizeof( ";" ) - 1 }, - { "static_assert", sizeof( "static_assert" ) - 1 }, - { "__string__", sizeof( "__string__" ) - 1 }, - { "typename", sizeof( "typename" ) - 1 }, - { "unsigned", sizeof( "unsigned" ) - 1 }, - { "signed", sizeof( "signed" ) - 1 }, - { "short", sizeof( "short" ) - 1 }, - { "long", sizeof( "long" ) - 1 }, - { "bool", sizeof( "bool" ) - 1 }, - { "char", sizeof( "char" ) - 1 }, - { "int", sizeof( "int" ) - 1 }, - { "double", sizeof( "double" ) - 1 }, - { "__int8", sizeof( "__int8" ) - 1 }, - { "__int16", sizeof( "__int16" ) - 1 }, - { "__int32", sizeof( "__int32" ) - 1 }, - { "__int64", sizeof( "__int64" ) - 1 }, - { "_W64", sizeof( "_W64" ) - 1 }, - { "...", sizeof( "..." ) - 1 }, - { "__attrib_start__", sizeof( "__attrib_start__" ) - 1 }, - { "GEN_API", sizeof( "GEN_API" ) - 1 }, + { "__invalid__", sizeof( "__invalid__" ) - 1 }, + { "private", sizeof( "private" ) - 1 }, + { "protected", sizeof( "protected" ) - 1 }, + { "public", sizeof( "public" ) - 1 }, + { ".", sizeof( "." ) - 1 }, + { "::", sizeof( "::" ) - 1 }, + { "&", sizeof( "&" ) - 1 }, + { "&&", sizeof( "&&" ) - 1 }, + { ":", sizeof( ":" ) - 1 }, + { "[[", sizeof( "[[" ) - 1 }, + { "]]", sizeof( "]]" ) - 1 }, + { "{", sizeof( "{" ) - 1 }, + { "}", sizeof( "}" ) - 1 }, + { "[", sizeof( "[" ) - 1 }, + { "]", sizeof( "]" ) - 1 }, + { "(", sizeof( "(" ) - 1 }, + { ")", sizeof( ")" ) - 1 }, + { "__comment__", sizeof( "__comment__" ) - 1 }, + { "__comment_end__", sizeof( "__comment_end__" ) - 1 }, + { "__comment_start__", sizeof( "__comment_start__" ) - 1 }, + { "__character__", sizeof( "__character__" ) - 1 }, + { ",", sizeof( "," ) - 1 }, + { "class", sizeof( "class" ) - 1 }, + { "__attribute__", sizeof( "__attribute__" ) - 1 }, + { "__declspec", sizeof( "__declspec" ) - 1 }, + { "enum", sizeof( "enum" ) - 1 }, + { "extern", sizeof( "extern" ) - 1 }, + { "friend", sizeof( "friend" ) - 1 }, + { "module", sizeof( "module" ) - 1 }, + { "namespace", sizeof( "namespace" ) - 1 }, + { "operator", sizeof( "operator" ) - 1 }, + { "struct", sizeof( "struct" ) - 1 }, + { "template", sizeof( "template" ) - 1 }, + { "typedef", sizeof( "typedef" ) - 1 }, + { "using", sizeof( "using" ) - 1 }, + { "union", sizeof( "union" ) - 1 }, + { "__identifier__", sizeof( "__identifier__" ) - 1 }, + { "import", sizeof( "import" ) - 1 }, + { "export", sizeof( "export" ) - 1 }, + { "__new_line__", sizeof( "__new_line__" ) - 1 }, + { "__number__", sizeof( "__number__" ) - 1 }, + { "__operator__", sizeof( "__operator__" ) - 1 }, + { "#", sizeof( "#" ) - 1 }, + { "define", sizeof( "define" ) - 1 }, + { "__define_param__", sizeof( "__define_param__" ) - 1 }, + { "if", sizeof( "if" ) - 1 }, + { "ifdef", sizeof( "ifdef" ) - 1 }, + { "ifndef", sizeof( "ifndef" ) - 1 }, + { "elif", sizeof( "elif" ) - 1 }, + { "else", sizeof( "else" ) - 1 }, + { "endif", sizeof( "endif" ) - 1 }, + { "include", sizeof( "include" ) - 1 }, + { "pragma", sizeof( "pragma" ) - 1 }, + { "__macro_content__", sizeof( "__macro_content__" ) - 1 }, + { "__macro_expression__", sizeof( "__macro_expression__" ) - 1 }, + { "__macro_statment__", sizeof( "__macro_statment__" ) - 1 }, + { "__macro_typename__", sizeof( "__macro_typename__" ) - 1 }, + { "__unsupported__", sizeof( "__unsupported__" ) - 1 }, + { "alignas", sizeof( "alignas" ) - 1 }, + { "const", sizeof( "const" ) - 1 }, + { "consteval", sizeof( "consteval" ) - 1 }, + { "constexpr", sizeof( "constexpr" ) - 1 }, + { "constinit", sizeof( "constinit" ) - 1 }, + { "explicit", sizeof( "explicit" ) - 1 }, + { "extern", sizeof( "extern" ) - 1 }, + { "final", sizeof( "final" ) - 1 }, + { "forceinline", sizeof( "forceinline" ) - 1 }, + { "global", sizeof( "global" ) - 1 }, + { "inline", sizeof( "inline" ) - 1 }, + { "internal", sizeof( "internal" ) - 1 }, + { "local_persist", sizeof( "local_persist" ) - 1 }, + { "mutable", sizeof( "mutable" ) - 1 }, + { "neverinline", sizeof( "neverinline" ) - 1 }, + { "override", sizeof( "override" ) - 1 }, + { "static", sizeof( "static" ) - 1 }, + { "thread_local", sizeof( "thread_local" ) - 1 }, + { "volatile", sizeof( "volatile" ) - 1 }, + { "virtual", sizeof( "virtual" ) - 1 }, + { "*", sizeof( "*" ) - 1 }, + { ";", sizeof( ";" ) - 1 }, + { "static_assert", sizeof( "static_assert" ) - 1 }, + { "__string__", sizeof( "__string__" ) - 1 }, + { "typename", sizeof( "typename" ) - 1 }, + { "unsigned", sizeof( "unsigned" ) - 1 }, + { "signed", sizeof( "signed" ) - 1 }, + { "short", sizeof( "short" ) - 1 }, + { "long", sizeof( "long" ) - 1 }, + { "bool", sizeof( "bool" ) - 1 }, + { "char", sizeof( "char" ) - 1 }, + { "int", sizeof( "int" ) - 1 }, + { "double", sizeof( "double" ) - 1 }, + { "__int8", sizeof( "__int8" ) - 1 }, + { "__int16", sizeof( "__int16" ) - 1 }, + { "__int32", sizeof( "__int32" ) - 1 }, + { "__int64", sizeof( "__int64" ) - 1 }, + { "_W64", sizeof( "_W64" ) - 1 }, + { "...", sizeof( "..." ) - 1 }, + { "__attrib_start__", sizeof( "__attrib_start__" ) - 1 }, + { "GEN_API", sizeof( "GEN_API" ) - 1 }, }; return lookup[type]; } diff --git a/base/components/header_end.hpp b/base/components/header_end.hpp index 703c1d9..282d4f8 100644 --- a/base/components/header_end.hpp +++ b/base/components/header_end.hpp @@ -6,7 +6,7 @@ #pragma region Constants -extern Str enum_underlying_sig; +extern Macro enum_underlying_macro; extern Code access_public; extern Code access_protected; diff --git a/base/components/inlines.hpp b/base/components/inlines.hpp index 7a74511..87e2710 100644 --- a/base/components/inlines.hpp +++ b/base/components/inlines.hpp @@ -257,6 +257,25 @@ CodeParams next_CodeParams(CodeParams params, CodeParams param_iter) } #pragma endregion CodeParams +#pragma region CodeDefineParams +forceinline void define_params_append (CodeDefineParams appendee, CodeDefineParams other ) { params_append( cast(CodeParams, appendee), cast(CodeParams, other) ); } +forceinline CodeDefineParams define_params_get (CodeDefineParams self, s32 idx ) { return (CodeDefineParams) (Code) params_get( cast(CodeParams, self), idx); } +forceinline bool define_params_has_entries(CodeDefineParams self) { return params_has_entries( cast(CodeParams, self)); } + +forceinline CodeDefineParams begin_CodeDefineParams(CodeDefineParams params) { return (CodeDefineParams) (Code) begin_CodeParams( cast(CodeParams, (Code)params)); } +forceinline CodeDefineParams end_CodeDefineParams (CodeDefineParams params) { return (CodeDefineParams) (Code) end_CodeParams ( cast(CodeParams, (Code)params)); } +forceinline CodeDefineParams next_CodeDefineParams (CodeDefineParams params, CodeDefineParams entry_iter) { return (CodeDefineParams) (Code) next_CodeParams ( cast(CodeParams, (Code)params), cast(CodeParams, (Code)entry_iter)); } + +#if GEN_COMPILER_CPP +forceinline +CodeDefineParams& CodeDefineParams::operator ++() +{ + * this = ast->Next; + return * this; +} +#endif +#pragma endregion CodeDefineParams + #pragma region CodeSpecifiers inline bool specifiers_append(CodeSpecifiers self, Specifier spec ) diff --git a/base/components/interface.cpp b/base/components/interface.cpp index e08b422..f0e97ee 100644 --- a/base/components/interface.cpp +++ b/base/components/interface.cpp @@ -179,37 +179,39 @@ void define_constants() #endif spec_const = def_specifier( Spec_Const); code_set_global( cast(Code, spec_const )); - spec_consteval = def_specifier( Spec_Consteval); code_set_global( cast(Code, spec_consteval ));; - spec_constexpr = def_specifier( Spec_Constexpr); code_set_global( cast(Code, spec_constexpr ));; - spec_constinit = def_specifier( Spec_Constinit); code_set_global( cast(Code, spec_constinit ));; - spec_extern_linkage = def_specifier( Spec_External_Linkage); code_set_global( cast(Code, spec_extern_linkage ));; - spec_final = def_specifier( Spec_Final); code_set_global( cast(Code, spec_final ));; - spec_forceinline = def_specifier( Spec_ForceInline); code_set_global( cast(Code, spec_forceinline ));; - spec_global = def_specifier( Spec_Global); code_set_global( cast(Code, spec_global ));; - spec_inline = def_specifier( Spec_Inline); code_set_global( cast(Code, spec_inline ));; - spec_internal_linkage = def_specifier( Spec_Internal_Linkage); code_set_global( cast(Code, spec_internal_linkage ));; - spec_local_persist = def_specifier( Spec_Local_Persist); code_set_global( cast(Code, spec_local_persist ));; - spec_mutable = def_specifier( Spec_Mutable); code_set_global( cast(Code, spec_mutable ));; - spec_neverinline = def_specifier( Spec_NeverInline); code_set_global( cast(Code, spec_neverinline ));; - spec_noexcept = def_specifier( Spec_NoExceptions); code_set_global( cast(Code, spec_noexcept ));; - spec_override = def_specifier( Spec_Override); code_set_global( cast(Code, spec_override ));; - spec_ptr = def_specifier( Spec_Ptr); code_set_global( cast(Code, spec_ptr ));; + spec_consteval = def_specifier( Spec_Consteval); code_set_global( cast(Code, spec_consteval )); + spec_constexpr = def_specifier( Spec_Constexpr); code_set_global( cast(Code, spec_constexpr )); + spec_constinit = def_specifier( Spec_Constinit); code_set_global( cast(Code, spec_constinit )); + spec_extern_linkage = def_specifier( Spec_External_Linkage); code_set_global( cast(Code, spec_extern_linkage )); + spec_final = def_specifier( Spec_Final); code_set_global( cast(Code, spec_final )); + spec_forceinline = def_specifier( Spec_ForceInline); code_set_global( cast(Code, spec_forceinline )); + spec_global = def_specifier( Spec_Global); code_set_global( cast(Code, spec_global )); + spec_inline = def_specifier( Spec_Inline); code_set_global( cast(Code, spec_inline )); + spec_internal_linkage = def_specifier( Spec_Internal_Linkage); code_set_global( cast(Code, spec_internal_linkage )); + spec_local_persist = def_specifier( Spec_Local_Persist); code_set_global( cast(Code, spec_local_persist )); + spec_mutable = def_specifier( Spec_Mutable); code_set_global( cast(Code, spec_mutable )); + spec_neverinline = def_specifier( Spec_NeverInline); code_set_global( cast(Code, spec_neverinline )); + spec_noexcept = def_specifier( Spec_NoExceptions); code_set_global( cast(Code, spec_noexcept )); + spec_override = def_specifier( Spec_Override); code_set_global( cast(Code, spec_override )); + spec_ptr = def_specifier( Spec_Ptr); code_set_global( cast(Code, spec_ptr )); spec_pure = def_specifier( Spec_Pure); code_set_global( cast(Code, spec_pure )); - spec_ref = def_specifier( Spec_Ref); code_set_global( cast(Code, spec_ref ));; - spec_register = def_specifier( Spec_Register); code_set_global( cast(Code, spec_register ));; - spec_rvalue = def_specifier( Spec_RValue); code_set_global( cast(Code, spec_rvalue ));; - spec_static_member = def_specifier( Spec_Static); code_set_global( cast(Code, spec_static_member ));; - spec_thread_local = def_specifier( Spec_Thread_Local); code_set_global( cast(Code, spec_thread_local ));; - spec_virtual = def_specifier( Spec_Virtual); code_set_global( cast(Code, spec_virtual ));; + spec_ref = def_specifier( Spec_Ref); code_set_global( cast(Code, spec_ref )); + spec_register = def_specifier( Spec_Register); code_set_global( cast(Code, spec_register )); + spec_rvalue = def_specifier( Spec_RValue); code_set_global( cast(Code, spec_rvalue )); + spec_static_member = def_specifier( Spec_Static); code_set_global( cast(Code, spec_static_member )); + spec_thread_local = def_specifier( Spec_Thread_Local); code_set_global( cast(Code, spec_thread_local )); + spec_virtual = def_specifier( Spec_Virtual); code_set_global( cast(Code, spec_virtual )); spec_volatile = def_specifier( Spec_Volatile); code_set_global( cast(Code, spec_volatile )); spec_local_persist = def_specifiers( 1, Spec_Local_Persist ); code_set_global(cast(Code, spec_local_persist)); - if (enum_underlying_sig.Len == 0) { - enum_underlying_sig = txt("enum_underlying("); + if (enum_underlying_macro.Name.Len == 0) { + enum_underlying_macro.Name = txt("enum_underlying"); + enum_underlying_macro.Type = MT_Expression; + enum_underlying_macro.Flags = MF_Functional; } - array_append( _ctx->PreprocessorDefines, enum_underlying_sig); + register_macro(enum_underlying_macro); } void init(Context* ctx) @@ -270,8 +272,8 @@ void init(Context* ctx) ctx->CodePool_NumBlocks = kilobytes(16); } - if (ctx->InitSize_LexArena == 0 ) { - ctx->InitSize_LexArena = megabytes(4); + if (ctx->InitSize_LexerTokens == 0 ) { + ctx->InitSize_LexerTokens = kilobytes(64); } if (ctx->SizePer_StringArena == 0) { ctx->SizePer_StringArena = megabytes(1); @@ -301,9 +303,6 @@ void init(Context* ctx) GEN_FATAL( "gen::init: Failed to initialize the code pool" ); array_append( ctx->CodePools, code_pool ); - // TODO(Ed): This is going to be phased out most likely. - ctx->LexArena = arena_init_from_allocator( ctx->Allocator_DyanmicContainers, ctx->InitSize_LexArena ); - // TODO(Ed): Eventually the string arenas needs to be phased out for a dedicated string slab allocator Arena strbuilder_arena = arena_init_from_allocator( ctx->Allocator_StrCache, ctx->SizePer_StringArena ); if ( strbuilder_arena.PhysicalStart == nullptr ) @@ -315,9 +314,12 @@ void init(Context* ctx) ctx->StrCache = hashtable_init(StrCached, ctx->Allocator_DyanmicContainers); if ( ctx->StrCache.Entries == nullptr ) GEN_FATAL( "gen::init: Failed to initialize the StringCache"); + + ctx->Macros = hashtable_init(Macro, ctx->Allocator_DyanmicContainers); + if (ctx->Macros.Hashes == nullptr || ctx->Macros.Entries == nullptr) { + GEN_FATAL( "gen::init: Failed to initialize the PreprocessMacros table" ); + } } - // Preprocessor Defines - ctx->PreprocessorDefines = array_init_reserve(StrCached, ctx->Allocator_DyanmicContainers, kilobytes(1) ); define_constants(); parser_init(); @@ -354,9 +356,7 @@ void deinit(Context* ctx) array_free( ctx->CodePools); array_free( ctx->StringArenas); - arena_free(& ctx->LexArena); - - array_free(ctx->PreprocessorDefines); + hashtable_destroy(ctx->Macros); left = array_num( ctx->Fallback_AllocatorBuckets); if (left) @@ -376,6 +376,13 @@ void deinit(Context* ctx) if (_ctx == ctx) _ctx = nullptr; -- context_counter; + + Context wipe = {}; + * ctx = wipe; +} + +Context* get_context() { + return _ctx; } void reset(Context* ctx) @@ -401,6 +408,7 @@ void reset(Context* ctx) while ( left--, left ); hashtable_clear(ctx->StrCache); + hashtable_clear(ctx->Macros); define_constants(); } @@ -463,10 +471,51 @@ Code make_code() return result; } -void set_preprocess_define( Str id, b32 is_functional ) { - StrBuilder builder = strbuilder_make_str( _ctx->Allocator_Temp, id ); - if (is_functional) { - strbuilder_append_char( & builder, '(' ); - } - array_append( _ctx->PreprocessorDefines, cache_str( strbuilder_to_str(builder)) ); +Macro* lookup_macro( Str name ) { + u32 key = crc32( name.Ptr, name.Len ); + return hashtable_get( _ctx->Macros, key ); +} + +void register_macro( Macro macro ) { + GEN_ASSERT_NOT_NULL(macro.Name.Ptr); + GEN_ASSERT(macro.Name.Len > 0); + u32 key = crc32( macro.Name.Ptr, macro.Name.Len ); + macro.Name = cache_str(macro.Name); + hashtable_set( _ctx->Macros, key, macro ); +} + +void register_macros( s32 num, ... ) +{ + GEN_ASSERT(num > 0); + va_list va; + va_start(va, num); + do + { + Macro macro = va_arg(va, Macro); + GEN_ASSERT_NOT_NULL(macro.Name.Ptr); + GEN_ASSERT(macro.Name.Len > 0); + macro.Name = cache_str(macro.Name); + + u32 key = crc32( macro.Name.Ptr, macro.Name.Len ); + hashtable_set( _ctx->Macros, key, macro ); + } + while (num--, num > 0); + va_end(va); +} + +void register_macros( s32 num, Macro* macros ) +{ + GEN_ASSERT(num > 0); + do + { + Macro macro = * macros; + GEN_ASSERT_NOT_NULL(macro.Name.Ptr); + GEN_ASSERT(macro.Name.Len > 0); + macro.Name = cache_str(macro.Name); + + u32 key = crc32( macro.Name.Ptr, macro.Name.Len ); + hashtable_set( _ctx->Macros, key, macro ); + ++ macros; + } + while (num--, num > 0); } diff --git a/base/components/interface.hpp b/base/components/interface.hpp index 99e8d1e..8a849ad 100644 --- a/base/components/interface.hpp +++ b/base/components/interface.hpp @@ -60,7 +60,7 @@ struct Context u32 CodePool_NumBlocks; // TODO(Ed): Review these... (No longer needed if using the proper allocation strategy) - u32 InitSize_LexArena; + u32 InitSize_LexerTokens; u32 SizePer_StringArena; // TODO(Ed): Symbol Table @@ -71,7 +71,7 @@ struct Context // Used by the lexer to persistently treat all these identifiers as preprocessor defines. // Populate with strings via gen::cache_str. // Functional defines must have format: id( ;at minimum to indicate that the define is only valid with arguments. - Array(StrCached) PreprocessorDefines; + MacroTable Macros; // Backend @@ -79,6 +79,8 @@ struct Context u32 InitSize_Fallback_Allocator_Bucket_Size; Array(Arena) Fallback_AllocatorBuckets; + StringTable token_fmt_map; + // Array(Token) LexerTokens; Array(Pool) CodePools; @@ -87,9 +89,6 @@ struct Context StringTable StrCache; // TODO(Ed): This needs to be just handled by a parser context - - Arena LexArena; - StringTable Lexer_defines; Array(Token) Lexer_Tokens; // TODO(Ed): Active parse context vs a parse result need to be separated conceptually @@ -103,15 +102,26 @@ GEN_API void init(Context* ctx); // However on Windows at least, it doesn't need to occur as the OS will clean up after the process. GEN_API void deinit(Context* ctx); +// Retrieves the active context (not usually needed, but here in case...) +GEN_API Context* get_context(); + // Clears the allocations, but doesn't free the memoery, then calls init() again. // Ease of use. GEN_API void reset(Context* ctx); GEN_API void set_context(Context* ctx); +// Mostly intended for the parser +GEN_API Macro* lookup_macro( Str Name ); + // Alternative way to add a preprocess define entry for the lexer & parser to utilize // if the user doesn't want to use def_define -GEN_API void set_preprocess_define( Str id, b32 is_functional ); +// Macros are tracked by name so if the name already exists the entry will be overwritten. +GEN_API void register_macro( Macro macro ); + +// Ease of use batch registration +GEN_API void register_macros( s32 num, ... ); +GEN_API void register_macros( s32 num, Macro* macros ); // Used internally to retrive or make string allocations. // Strings are stored in a series of string arenas of fixed size (SizePer_StringArena) @@ -150,9 +160,12 @@ struct Opts_def_constructor { GEN_API CodeConstructor def_constructor( Opts_def_constructor opts GEN_PARAM_DEFAULT ); struct Opts_def_define { - b32 dont_append_preprocess_defines; + CodeDefineParams params; + Str content; + MacroFlags flags; + b32 dont_register_to_preprocess_macros; }; -GEN_API CodeDefine def_define( Str name, Str content, Opts_def_define opts GEN_PARAM_DEFAULT ); +GEN_API CodeDefine def_define( Str name, MacroType type, Opts_def_define opts GEN_PARAM_DEFAULT ); struct Opts_def_destructor { Code body; @@ -263,28 +276,30 @@ GEN_API 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. -GEN_API CodeBody def_class_body ( s32 num, ... ); -GEN_API CodeBody def_class_body ( s32 num, Code* codes ); -GEN_API CodeBody def_enum_body ( s32 num, ... ); -GEN_API CodeBody def_enum_body ( s32 num, Code* codes ); -GEN_API CodeBody def_export_body ( s32 num, ... ); -GEN_API CodeBody def_export_body ( s32 num, Code* codes); -GEN_API CodeBody def_extern_link_body( s32 num, ... ); -GEN_API CodeBody def_extern_link_body( s32 num, Code* codes ); -GEN_API CodeBody def_function_body ( s32 num, ... ); -GEN_API CodeBody def_function_body ( s32 num, Code* codes ); -GEN_API CodeBody def_global_body ( s32 num, ... ); -GEN_API CodeBody def_global_body ( s32 num, Code* codes ); -GEN_API CodeBody def_namespace_body ( s32 num, ... ); -GEN_API CodeBody def_namespace_body ( s32 num, Code* codes ); -GEN_API CodeParams def_params ( s32 num, ... ); -GEN_API CodeParams def_params ( s32 num, CodeParams* params ); -GEN_API CodeSpecifiers def_specifiers ( s32 num, ... ); -GEN_API CodeSpecifiers def_specifiers ( s32 num, Specifier* specs ); -GEN_API CodeBody def_struct_body ( s32 num, ... ); -GEN_API CodeBody def_struct_body ( s32 num, Code* codes ); -GEN_API CodeBody def_union_body ( s32 num, ... ); -GEN_API CodeBody def_union_body ( s32 num, Code* codes ); +GEN_API CodeBody def_class_body ( s32 num, ... ); +GEN_API CodeBody def_class_body ( s32 num, Code* codes ); +GEN_API CodeDefineParams def_define_params ( s32 num, ... ); +GEN_API CodeDefineParams def_define_params ( s32 num, CodeDefineParams* codes ); +GEN_API CodeBody def_enum_body ( s32 num, ... ); +GEN_API CodeBody def_enum_body ( s32 num, Code* codes ); +GEN_API CodeBody def_export_body ( s32 num, ... ); +GEN_API CodeBody def_export_body ( s32 num, Code* codes); +GEN_API CodeBody def_extern_link_body( s32 num, ... ); +GEN_API CodeBody def_extern_link_body( s32 num, Code* codes ); +GEN_API CodeBody def_function_body ( s32 num, ... ); +GEN_API CodeBody def_function_body ( s32 num, Code* codes ); +GEN_API CodeBody def_global_body ( s32 num, ... ); +GEN_API CodeBody def_global_body ( s32 num, Code* codes ); +GEN_API CodeBody def_namespace_body ( s32 num, ... ); +GEN_API CodeBody def_namespace_body ( s32 num, Code* codes ); +GEN_API CodeParams def_params ( s32 num, ... ); +GEN_API CodeParams def_params ( s32 num, CodeParams* params ); +GEN_API CodeSpecifiers def_specifiers ( s32 num, ... ); +GEN_API CodeSpecifiers def_specifiers ( s32 num, Specifier* specs ); +GEN_API CodeBody def_struct_body ( s32 num, ... ); +GEN_API CodeBody def_struct_body ( s32 num, Code* codes ); +GEN_API CodeBody def_union_body ( s32 num, ... ); +GEN_API CodeBody def_union_body ( s32 num, Code* codes ); #pragma endregion Upfront @@ -326,6 +341,7 @@ CodeBody parse_file( Str path ); GEN_API CodeClass parse_class ( Str class_def ); GEN_API CodeConstructor parse_constructor ( Str constructor_def ); +GEN_API CodeDefine parse_define ( Str define_def ); GEN_API CodeDestructor parse_destructor ( Str destructor_def ); GEN_API CodeEnum parse_enum ( Str enum_def ); GEN_API CodeBody parse_export_body ( Str export_def ); @@ -367,12 +383,20 @@ GEN_API Code untyped_token_fmt( s32 num_tokens, char const* fmt, ... ); #ifndef name // Convienence for defining any name used with the gen api. // Lets you provide the length and string literal to the functions without the need for the DSL. -#define name( Id_ ) { stringize(Id_), sizeof(stringize( Id_ )) - 1 } +# if GEN_COMPILER_C +# define name( Id_ ) (Str){ stringize(Id_), sizeof(stringize( Id_ )) - 1 } +# else +# define name( Id_ ) Str { stringize(Id_), sizeof(stringize( Id_ )) - 1 } +# endif #endif #ifndef code // Same as name just used to indicate intention of literal for code instead of names. -#define code( ... ) { stringize( __VA_ARGS__ ), sizeof(stringize(__VA_ARGS__)) - 1 } +# if GEN_COMPILER_C +# define code( ... ) (Str){ stringize( __VA_ARGS__ ), sizeof(stringize(__VA_ARGS__)) - 1 } +# else +# define code( ... ) Str { stringize( __VA_ARGS__ ), sizeof(stringize(__VA_ARGS__)) - 1 } +# endif #endif #ifndef args diff --git a/base/components/interface.parsing.cpp b/base/components/interface.parsing.cpp index d96e0d6..eea7def 100644 --- a/base/components/interface.parsing.cpp +++ b/base/components/interface.parsing.cpp @@ -82,6 +82,21 @@ CodeConstructor parse_constructor( Str def ) return result; } +CodeDefine parse_define( Str def ) +{ + check_parse_args( def ); + + TokArray toks = lex( def ); + if ( toks.Arr == nullptr ) + return InvalidCode; + + _ctx->parser.Tokens = toks; + push_scope(); + CodeDefine result = parser_parse_define(); + parser_pop(& _ctx->parser); + return result; +} + CodeDestructor parse_destructor( Str def ) { check_parse_args( def ); diff --git a/base/components/interface.untyped.cpp b/base/components/interface.untyped.cpp index e95abf5..bc8afab 100644 --- a/base/components/interface.untyped.cpp +++ b/base/components/interface.untyped.cpp @@ -8,9 +8,8 @@ ssize token_fmt_va( char* buf, usize buf_size, s32 num_tokens, va_list va ) char const* buf_begin = buf; ssize remaining = buf_size; - local_persist StringTable tok_map; - do_once() { - tok_map = hashtable_init(Str, _ctx->Allocator_DyanmicContainers ); + if (_ctx->token_fmt_map.Hashes == nullptr) { + _ctx->token_fmt_map = hashtable_init(Str, _ctx->Allocator_DyanmicContainers ); } // Populate token pairs { @@ -22,7 +21,7 @@ ssize token_fmt_va( char* buf, usize buf_size, s32 num_tokens, va_list va ) Str value = va_arg( va, Str ); u32 key = crc32( token, c_str_len(token) ); - hashtable_set( tok_map, key, value ); + hashtable_set( _ctx->token_fmt_map, key, value ); } } @@ -57,8 +56,8 @@ ssize token_fmt_va( char* buf, usize buf_size, s32 num_tokens, va_list va ) char const* token = fmt + 1; - u32 key = crc32( token, tok_len ); - Str* value = hashtable_get(tok_map, key ); + u32 key = crc32( token, tok_len ); + Str* value = hashtable_get(_ctx->token_fmt_map, key ); if ( value ) { @@ -87,7 +86,7 @@ ssize token_fmt_va( char* buf, usize buf_size, s32 num_tokens, va_list va ) current = * fmt; } } - hashtable_clear(tok_map); + hashtable_clear(_ctx->token_fmt_map); ssize result = buf_size - remaining; return result; } diff --git a/base/components/interface.upfront.cpp b/base/components/interface.upfront.cpp index 0faec68..d064a8b 100644 --- a/base/components/interface.upfront.cpp +++ b/base/components/interface.upfront.cpp @@ -516,7 +516,6 @@ CodeClass def_class( Str name, Opts_def_struct p ) GEN_DEBUG_TRAP(); return InvalidCode; } - if ( p.attributes && p.attributes->Type != CT_PlatformAttributes ) { log_failure( "gen::def_class: attributes was not a 'PlatformAttributes' type: %s", code_debug_str(p.attributes) ); GEN_DEBUG_TRAP(); @@ -529,9 +528,12 @@ CodeClass def_class( Str name, Opts_def_struct p ) } CodeClass - result = (CodeClass) make_code(); - result->Name = cache_str( name ); - result->ModuleFlags = p.mflags; + result = (CodeClass) make_code(); + result->Name = cache_str( name ); + result->ModuleFlags = p.mflags; + result->Attributes = p.attributes; + result->ParentAccess = p.parent_access; + result->ParentType = p.parent; if ( p.body ) { switch ( p.body->Type ) @@ -552,44 +554,32 @@ CodeClass def_class( Str name, Opts_def_struct p ) else { result->Type = CT_Class_Fwd; } - - result->Attributes = p.attributes; - result->ParentAccess = p.parent_access; - result->ParentType = p.parent; - for (s32 idx = 0; idx < p.num_interfaces; idx++ ) { class_add_interface(result, p.interfaces[idx] ); } return result; } -CodeDefine def_define( Str name, Str content, Opts_def_define p ) +CodeDefine def_define( Str name, MacroType type, Opts_def_define p ) { if ( ! name_check( def_define, name ) ) { GEN_DEBUG_TRAP(); return InvalidCode; } - CodeDefine result = (CodeDefine) make_code(); result->Type = CT_Preprocess_Define; result->Name = cache_str( name ); - - if ( content.Len <= 0 || content.Ptr == nullptr ) - result->Content = cache_str( txt("") ); + result->Params = p.params; + if ( p.content.Len <= 0 || p.content.Ptr == nullptr ) + result->Body = untyped_str( txt("\n") ); else - result->Content = cache_str( strbuilder_to_str(strbuilder_fmt_buf(_ctx->Allocator_Temp, "%S\n", content)) ); + result->Body = untyped_str( strbuilder_to_str(strbuilder_fmt_buf(_ctx->Allocator_Temp, "%S\n", p.content)) ); - b32 append_preprocess_defines = ! p.dont_append_preprocess_defines; - if ( append_preprocess_defines ) { - // Add the define to PreprocessorDefines for usage in parsing - s32 lex_id_len = 0; - for (; lex_id_len < result->Name.Len; ++ lex_id_len ) { - if ( result->Name.Ptr[lex_id_len] == '(' ) - break; - } - Str lex_id = { result->Name.Ptr, lex_id_len }; - array_append(_ctx->PreprocessorDefines, cache_str(lex_id) ); + b32 register_define = ! p.dont_register_to_preprocess_macros; + if ( register_define ) { + Macro macro_entry = { result->Name, type, p.flags }; + register_macro(macro_entry); } return result; } @@ -1284,7 +1274,7 @@ CodeUsing def_using_namespace( Str name ) CodeVar def_variable( CodeTypename type, Str name, Opts_def_variable p ) { - if ( ! name_check( def_variable, name ) || null_check( def_variable, type ) ) { + if ( ! name_check( def_variable, name ) || ! null_check( def_variable, type ) ) { GEN_DEBUG_TRAP(); return InvalidCode; } @@ -1410,6 +1400,67 @@ CodeBody def_class_body( s32 num, Code* codes ) return result; } +CodeDefineParams def_define_params( s32 num, ... ) +{ + def_body_start( def_define_params ); + + va_list va; + va_start(va, num); + + Code_POD pod = va_arg(va, Code_POD); + CodeDefineParams param = pcast( CodeDefineParams, pod ); + + null_check( def_define_params, param ); + if ( param->Type != CT_Parameters_Define ) { + log_failure( "gen::def_define_params: param %d is not a parameter for a preprocessor define", num - num + 1 ); + return InvalidCode; + } + + CodeDefineParams result = (CodeDefineParams) code_duplicate(param); + while ( -- num ) + { + pod = va_arg(va, Code_POD); + param = pcast( CodeDefineParams, pod ); + if ( param->Type != CT_Parameters_Define ) { + log_failure( "gen::def_define_params: param %d is not a parameter for a preprocessor define", num - num + 1 ); + return InvalidCode; + } + define_params_append(result, param ); + } + va_end(va); + + return result; +} + +CodeDefineParams def_define_params( s32 num, CodeDefineParams* codes ) +{ + def_body_code_array_start( def_define_params ); + +# define check_current(current) \ + if ( current == nullptr ) { \ + log_failure("gen::def_define_params: Provide a null code in codes array"); \ + return InvalidCode; \ + } \ + if (current->Type != CT_Parameters_Define ) { \ + log_failure("gen::def_define_params: Code in coes array is not of paramter for preprocessor define type - %s", code_debug_str(current) ); \ + return InvalidCode; \ + } + CodeDefineParams current = (CodeDefineParams)code_duplicate(* codes); + check_current(current); + + CodeDefineParams + result = (CodeDefineParams) make_code(); + result->Name = current->Name; + result->Type = current->Type; + while( codes++, current = * codes, num--, num > 0 ) { + check_current(current); + define_params_append(result, current ); + } +# undef check_current + + return result; +} + CodeBody def_enum_body( s32 num, ... ) { def_body_start( def_enum_body ); diff --git a/base/components/lexer.cpp b/base/components/lexer.cpp index 206562c..07cf62f 100644 --- a/base/components/lexer.cpp +++ b/base/components/lexer.cpp @@ -112,6 +112,158 @@ void lexer_end_line( LexContext* ctx ) } #define end_line() lexer_end_line(ctx) +// TODO(Ed): We need to to attempt to recover from a lex failure? +s32 lex_preprocessor_define( LexContext* ctx ) +{ + Token name = { { ctx->scanner, 1 }, Tok_Identifier, ctx->line, ctx->column, TF_Preprocess }; + move_forward(); + + while ( ctx->left && ( char_is_alphanumeric((* ctx->scanner)) || (* ctx->scanner) == '_' ) ) { + move_forward(); + name.Text.Len++; + } + + Specifier spec = str_to_specifier( name.Text ); + TokType attrib = str_to_toktype( name.Text ); + b32 not_specifier = spec == Spec_Invalid; + b32 not_attribute = attrib <= Tok___Attributes_Start; + + Macro macro = { name.Text, MT_Expression, (MacroFlags)0 }; + Macro* registered_macro = lookup_macro(name.Text); + + if ( registered_macro == nullptr && not_specifier && not_attribute ) { + log_fmt("Warning: '%S' was not registered before the lexer processed its #define directive, it will be registered as a expression macro\n" + , name.Text + ); + // GEN_DEBUG_TRAP(); + } + array_append( _ctx->Lexer_Tokens, name ); + + if ( ctx->left && (* ctx->scanner) == '(' ) + { + if (registered_macro && ! macro_is_functional(* registered_macro)) { + log_fmt("Warning: %S registered macro is not flagged as functional yet the definition detects opening parenthesis '(' for arguments\n" + , name.Text + ); + // GEN_DEBUG_TRAP(); + } + else { + macro.Flags |= MF_Functional; + } + + Token opening_paren = { { ctx->scanner, 1 }, Tok_Capture_Start, ctx->line, ctx->column, TF_Preprocess }; + array_append( _ctx->Lexer_Tokens, opening_paren ); + move_forward(); + + Token last_parameter = {}; + // We need to tokenize the define's arguments now: + while( ctx->left && * ctx->scanner != ')') + { + skip_whitespace(); + + Str possible_varadic = { ctx->scanner, 3 }; + if ( ctx->left > 3 && str_are_equal( txt("..."), possible_varadic ) ) { + Token parameter = { { ctx->scanner, 3 }, Tok_Preprocess_Define_Param, ctx->line, ctx->column, TF_Preprocess }; + move_forward(); + move_forward(); + move_forward(); + + array_append(_ctx->Lexer_Tokens, parameter); + skip_whitespace(); + last_parameter = parameter; + + while ( (* ctx->scanner) == '\\' ) { + move_forward(); + skip_whitespace(); + } + if (* ctx->scanner != ')' ) + { + log_failure("lex_preprocessor_define(%d, %d): Expected a ')' after '...' (varaidc macro param) %S\n" + , ctx->line + , ctx->column + , name.Text + ); + return Lex_ReturnNull; + } + break; + } + else if ( (* ctx->scanner) == '\\' ) { + move_forward(); + skip_whitespace(); + continue; + } + else if ( char_is_alpha( (* ctx->scanner) ) || (* ctx->scanner) == '_' ) + { + Token parameter = { { ctx->scanner, 1 }, Tok_Preprocess_Define_Param, ctx->line, ctx->column, TF_Preprocess }; + move_forward(); + + while ( ctx->left && ( char_is_alphanumeric((* ctx->scanner)) || (* ctx->scanner) == '_' ) ) + { + move_forward(); + parameter.Text.Len++; + } + array_append(_ctx->Lexer_Tokens, parameter); + skip_whitespace(); + last_parameter = parameter; + } + else { + log_failure("lex_preprocessor_define(%d, %d): Expected a '_' or alpha character for a parameter name for %S\n" + , ctx->line + , ctx->column + , name.Text + ); + return Lex_ReturnNull; + } + + if (* ctx->scanner == ')' ) + break; + + // There should be a comma + if ( * ctx->scanner != ',' ) { + log_failure("lex_preprocessor_define(%d, %d): Expected a comma after parameter %S for %S\n" + , ctx->line + , ctx->column + , last_parameter.Text + , name.Text + ); + return Lex_ReturnNull; + } + Token comma = { { ctx->scanner, 1 }, Tok_Comma, ctx->line, ctx->column, TF_Preprocess }; + array_append(_ctx->Lexer_Tokens, comma); + move_forward(); + } + + if ( * ctx->scanner != ')' ) { + log_failure("lex_preprocessor_define(%d, %d): Expected a ')' after last_parameter %S for %S (ran out of characters...)\n" + , ctx->line + , ctx->column + , last_parameter.Text + , name.Text + ); + return Lex_ReturnNull; + } + Token closing_paren = { { ctx->scanner, 1 }, Tok_Capture_End, ctx->line, ctx->column, TF_Preprocess }; + array_append(_ctx->Lexer_Tokens, closing_paren); + move_forward(); + } + else if ( registered_macro && macro_is_functional( * registered_macro) ) { + if (registered_macro && ! macro_is_functional(* registered_macro)) { + log_fmt("Warning: %S registered macro is flagged as functional yet the definition detects no opening parenthesis '(' for arguments\n" + , name.Text + ); + GEN_DEBUG_TRAP(); + } + } + + if ( registered_macro == nullptr ) { + register_macro(macro); + } + + // Define's content handled by lex_preprocessor_directive (the original caller of this) + return Lex_Continue; +} + +// TODO(Ed): We need to to attempt to recover from a lex failure? forceinline s32 lex_preprocessor_directive( LexContext* ctx ) { @@ -215,28 +367,9 @@ s32 lex_preprocessor_directive( LexContext* ctx ) if ( ctx->token.Type == Tok_Preprocess_Define ) { - Token name = { { ctx->scanner, 0 }, Tok_Identifier, ctx->line, ctx->column, TF_Preprocess }; - - name.Text.Ptr = ctx->scanner; - name.Text.Len = 1; - move_forward(); - - while ( ctx->left && ( char_is_alphanumeric((* ctx->scanner)) || (* ctx->scanner) == '_' ) ) - { - move_forward(); - name.Text.Len++; - } - - if ( ctx->left && (* ctx->scanner) == '(' ) - { - move_forward(); - name.Text.Len++; - } - - array_append( _ctx->Lexer_Tokens, name ); - - u64 key = crc32( name.Text.Ptr, name.Text.Len ); - hashtable_set(ctx->defines, key, tok_to_str(name) ); + u32 result = lex_preprocessor_define(ctx); // handles: #define ( ) - define's content handled later on within this scope. + if (result != Lex_Continue) + return Lex_ReturnNull; } Token preprocess_content = { { ctx->scanner, 0 }, Tok_Preprocess_Content, ctx->line, ctx->column, TF_Preprocess }; @@ -286,7 +419,7 @@ s32 lex_preprocessor_directive( LexContext* ctx ) s32 within_string = false; s32 within_char = false; - // SkipWhitespace(); + // Consume preprocess content while ( ctx->left ) { if ( (* ctx->scanner) == '"' && ! within_char ) @@ -322,6 +455,7 @@ s32 lex_preprocessor_directive( LexContext* ctx ) , (* ctx->scanner), ctx->line, ctx->column , directive_str, preprocess_content.Line, preprocess_content.Column , content_str ); + return Lex_ReturnNull; break; } } @@ -349,30 +483,24 @@ s32 lex_preprocessor_directive( LexContext* ctx ) forceinline void lex_found_token( LexContext* ctx ) { - if ( ctx->token.Type != Tok_Invalid ) - { + if ( ctx->token.Type != Tok_Invalid ) { array_append( _ctx->Lexer_Tokens, ctx->token ); return; } TokType type = str_to_toktype( tok_to_str(ctx->token) ); - if (type <= Tok_Access_Public && type >= Tok_Access_Private ) - { + if (type <= Tok_Access_Public && type >= Tok_Access_Private ) { ctx->token.Flags |= TF_AccessSpecifier; } - - if ( type > Tok___Attributes_Start ) - { + if ( type > Tok___Attributes_Start ) { ctx->token.Flags |= TF_Attribute; } - if ( type == Tok_Decl_Extern_Linkage ) { skip_whitespace(); - if ( (* ctx->scanner) != '"' ) - { + if ( (* ctx->scanner) != '"' ) { type = Tok_Spec_Extern; ctx->token.Flags |= TF_Specifier; } @@ -381,7 +509,6 @@ void lex_found_token( LexContext* ctx ) array_append( _ctx->Lexer_Tokens, ctx->token ); return; } - if ( ( type <= Tok_Star && type >= Tok_Spec_Alignas) || type == Tok_Ampersand || type == Tok_Ampersand_DBL ) @@ -391,8 +518,6 @@ void lex_found_token( LexContext* ctx ) array_append( _ctx->Lexer_Tokens, ctx->token ); return; } - - if ( type != Tok_Invalid ) { ctx->token.Type = type; @@ -400,50 +525,31 @@ void lex_found_token( LexContext* ctx ) return; } - u64 key = 0; - if ( (* ctx->scanner) == '(') - key = crc32( ctx->token.Text.Ptr, ctx->token.Text.Len + 1 ); - else - key = crc32( ctx->token.Text.Ptr, ctx->token.Text.Len ); - - Str* define = hashtable_get(ctx->defines, key ); - if ( define ) - { - ctx->token.Type = Tok_Preprocess_Macro; - - // Want to ignore any arguments the define may have as they can be execution expressions. - if ( ctx->left && (* ctx->scanner) == '(' ) - { - move_forward(); - ctx->token.Text.Len++; - - s32 level = 0; - while ( ctx->left && ((* ctx->scanner) != ')' || level > 0) ) - { - if ( (* ctx->scanner) == '(' ) - level++; - - else if ( (* ctx->scanner) == ')' && level > 0 ) - level--; - - move_forward(); - ctx->token.Text.Len++; - } - - move_forward(); - ctx->token.Text.Len++; + Macro* macro = lookup_macro( ctx->token.Text ); + b32 has_args = ctx->left && (* ctx->scanner) == '('; + b32 resolved_to_macro = false; + if (macro) { + ctx->token.Type = macrotype_to_toktype(macro->Type); + b32 is_functional = macro_is_functional(* macro); + resolved_to_macro = has_args ? is_functional : ! is_functional; + if ( ! resolved_to_macro ) { + log_fmt("Info(%d, %d): %S identified as a macro but usage here does not resolve to one (interpreting as identifier)\n" + , ctx->token.Line + , ctx->token.Line + , macro->Name + ); + } + } + if ( resolved_to_macro ) + { + // TODO(Ed): When we introduce a macro AST (and expression support), we'll properly lex this section. + // Want to ignore any arguments the define may have as they can be execution expressions. + if ( has_args ) { + ctx->token.Flags |= TF_Macro_Functional; + } + if ( bitfield_is_set(MacroFlags, macro->Flags, MF_Allow_As_Attribute) ) { + ctx->token.Flags |= TF_Attribute; } - - //if ( (* ctx->scanner) == '\r' && ctx->scanner[1] == '\n' ) - //{ - // move_forward(); - // ctx->token..Text.Length++; - //} - //else if ( (* ctx->scanner) == '\n' ) - //{ - // move_forward(); - // ctx->token..Text.Length++; - //} } else { @@ -453,6 +559,7 @@ void lex_found_token( LexContext* ctx ) array_append( _ctx->Lexer_Tokens, ctx->token ); } +// TODO(Ed): We need to to attempt to recover from a lex failure? neverinline // TokArray lex( Array tokens, Str content ) TokArray lex( Str content ) @@ -461,7 +568,6 @@ TokArray lex( Str content ) c.content = content; c.left = content.Len; c.scanner = content.Ptr; - c.defines = _ctx->Lexer_defines; char const* word = c.scanner; s32 word_length = 0; @@ -477,26 +583,10 @@ TokArray lex( Str content ) return null_array; } - for ( StrCached* entry = array_begin(_ctx->PreprocessorDefines); entry != array_end(_ctx->PreprocessorDefines); entry = array_next(_ctx->PreprocessorDefines, entry)) - { - s32 length = 0; - char const* entry_scanner = (*entry).Ptr; - while ( entry->Len > length && (char_is_alphanumeric( *entry_scanner ) || *entry_scanner == '_') ) - { - entry_scanner++; - length ++; - } - if ( entry_scanner[0] == '(' ) - { - length++; - } - - u64 key = crc32( entry->Ptr, length ); - hashtable_set(c.defines, key, * entry ); - } - array_clear(_ctx->Lexer_Tokens); + b32 preprocess_args = true; + while (c.left ) { #if 0 @@ -938,7 +1028,7 @@ TokArray lex( Str content ) goto FoundToken; } - // Dash is unfortunatlly a bit more complicated... + // Dash is unfortunately a bit more complicated... case '-': { Str text = { c.scanner, 1 }; @@ -1075,8 +1165,7 @@ TokArray lex( Str content ) c.token.Text = text; move_forward(); - while ( c.left && ( char_is_alphanumeric((* ctx->scanner)) || (* ctx->scanner) == '_' ) ) - { + while ( c.left && ( char_is_alphanumeric((* ctx->scanner)) || (* ctx->scanner) == '_' ) ) { move_forward(); c.token.Text.Len++; } @@ -1102,8 +1191,7 @@ TokArray lex( Str content ) move_forward(); c.token.Text.Len++; - while ( c.left && char_is_hex_digit((* ctx->scanner)) ) - { + while ( c.left && char_is_hex_digit((* ctx->scanner)) ) { move_forward(); c.token.Text.Len++; } @@ -1111,8 +1199,7 @@ TokArray lex( Str content ) goto FoundToken; } - while ( c.left && char_is_digit((* ctx->scanner)) ) - { + while ( c.left && char_is_digit((* ctx->scanner)) ) { move_forward(); c.token.Text.Len++; } @@ -1122,8 +1209,7 @@ TokArray lex( Str content ) move_forward(); c.token.Text.Len++; - while ( c.left && char_is_digit((* ctx->scanner)) ) - { + while ( c.left && char_is_digit((* ctx->scanner)) ) { move_forward(); c.token.Text.Len++; } @@ -1141,8 +1227,7 @@ TokArray lex( Str content ) c.token.Text.Len++; // Handle 'll'/'LL' as a special case when we just processed an 'l'/'L' - if (c.left && (prev == 'l' || prev == 'L') && ((* ctx->scanner) == 'l' || (* ctx->scanner) == 'L')) - { + if (c.left && (prev == 'l' || prev == 'L') && ((* ctx->scanner) == 'l' || (* ctx->scanner) == 'L')) { move_forward(); c.token.Text.Len++; } @@ -1168,8 +1253,7 @@ TokArray lex( Str content ) log_failure( "Failed to lex token '%c' (%d, %d)\n%s", (* ctx->scanner), c.line, c.column, context_str ); // Skip to next whitespace since we can't know if anything else is valid until then. - while ( c.left && ! char_is_space( (* ctx->scanner) ) ) - { + while ( c.left && ! char_is_space( (* ctx->scanner) ) ) { move_forward(); } } @@ -1178,17 +1262,15 @@ TokArray lex( Str content ) { lex_found_token( ctx ); TokType last_type = array_back(_ctx->Lexer_Tokens)->Type; - if ( last_type == Tok_Preprocess_Macro ) + if ( last_type == Tok_Preprocess_Macro_Stmt || last_type == Tok_Preprocess_Macro_Expr ) { Token thanks_c = { { c.scanner, 0 }, Tok_Invalid, c.line, c.column, TF_Null }; c.token = thanks_c; - if ( (* ctx->scanner) == '\r') - { + if ( (* ctx->scanner) == '\r') { move_forward(); c.token.Text.Len = 1; } - - if ( (* ctx->scanner) == '\n' ) + if ( (* ctx->scanner) == '\n' ) { c.token.Type = Tok_NewLine; c.token.Text.Len++; @@ -1201,20 +1283,16 @@ TokArray lex( Str content ) } } - if ( array_num(_ctx->Lexer_Tokens) == 0 ) - { + if ( array_num(_ctx->Lexer_Tokens) == 0 ) { log_failure( "Failed to lex any tokens" ); - { - TokArray tok_array = {}; - return tok_array; - } + TokArray tok_array = {}; + return tok_array; } - hashtable_clear(_ctx->Lexer_defines); - // defines_map_arena.free(); TokArray result = { _ctx->Lexer_Tokens, 0 }; return result; } + #undef move_forward #undef skip_whitespace #undef end_line diff --git a/base/components/parser.cpp b/base/components/parser.cpp index 3c850f8..47b5813 100644 --- a/base/components/parser.cpp +++ b/base/components/parser.cpp @@ -64,12 +64,10 @@ StrBuilder parser_to_strbuilder(ParseContext ctx) s32 level = 0; do { - if ( curr_scope->Name.Ptr ) - { + if ( curr_scope->Name.Ptr ) { strbuilder_append_fmt(& result, "\t%d: %s, AST Name: %.*s\n", level, curr_scope->ProcName.Ptr, curr_scope->Name.Len, curr_scope->Name.Ptr ); } - else - { + else { strbuilder_append_fmt(& result, "\t%d: %s\n", level, curr_scope->ProcName.Ptr ); } @@ -82,8 +80,7 @@ StrBuilder parser_to_strbuilder(ParseContext ctx) bool lex__eat(TokArray* self, TokType type ) { - if ( array_num(self->Arr) - self->Idx <= 0 ) - { + if ( array_num(self->Arr) - self->Idx <= 0 ) { log_failure( "No tokens left.\n%s", parser_to_strbuilder(_ctx->parser) ); return false; } @@ -96,7 +93,15 @@ bool lex__eat(TokArray* self, TokType type ) self->Idx ++; } - if ( at_idx.Type != type ) + b32 not_accepted = at_idx.Type != type; + b32 is_identifier = at_idx.Type == Tok_Identifier; + if ( not_accepted ) + { + Macro* macro = lookup_macro(at_idx.Text); + b32 accept_as_identifier = macro && bitfield_is_set(MacroFlags, macro->Flags, MF_Allow_As_Identifier ); + not_accepted = type == Tok_Identifier && accept_as_identifier ? false : true; + } + if ( not_accepted ) { Token tok = * lex_current( self, lex_skip_formatting ); log_failure( "Parse Error, TokArray::eat, Expected: ' %s ' not ' %.*s ' (%d, %d)`\n%s" @@ -121,11 +126,7 @@ bool lex__eat(TokArray* self, TokType type ) internal void parser_init() { - _ctx->Lexer_Tokens = array_init_reserve(Token, arena_allocator_info( & _ctx->LexArena) - , ( _ctx->InitSize_LexArena - sizeof( ArrayHeader ) ) / sizeof(Token) - ); - - _ctx->Lexer_defines = hashtable_init_reserve(Str, _ctx->Allocator_DyanmicContainers, 256 ); + _ctx->Lexer_Tokens = array_init_reserve(Token, _ctx->Allocator_DyanmicContainers, _ctx->InitSize_LexerTokens ); } internal @@ -195,7 +196,6 @@ internal CodeComment parse_comment (); internal Code parse_complicated_definition ( TokType which ); internal CodeBody parse_class_struct_body ( TokType which, Token name ); internal Code parse_class_struct ( TokType which, bool inplace_def ); -internal CodeDefine parse_define (); internal Code parse_expression (); internal Code parse_forward_or_definition ( TokType which, bool is_inplace ); internal CodeFn parse_function_after_name ( ModuleFlag mflags, CodeAttributes attributes, CodeSpecifiers specifiers, CodeTypename ret_type, Token name ); @@ -204,19 +204,21 @@ internal CodeBody parse_global_nspace ( CodeType which internal Code parse_global_nspace_constructor_destructor( CodeSpecifiers specifiers ); internal Token parse_identifier ( bool* possible_member_function ); internal CodeInclude parse_include (); +internal Code parse_macro_as_definiton ( CodeAttributes attributes, CodeSpecifiers specifiers ); internal CodeOperator parse_operator_after_ret_type ( ModuleFlag mflags, CodeAttributes attributes, CodeSpecifiers specifiers, CodeTypename ret_type ); internal Code parse_operator_function_or_variable( bool expects_function, CodeAttributes attributes, CodeSpecifiers specifiers ); internal CodePragma parse_pragma (); internal CodeParams parse_params ( bool use_template_capture ); internal CodePreprocessCond parse_preprocess_cond (); -internal Code parse_simple_preprocess ( TokType which, bool dont_consume_braces ); +internal Code parse_simple_preprocess ( TokType which ); internal Code parse_static_assert (); internal void parse_template_args ( Token* token ); internal CodeVar parse_variable_after_name ( ModuleFlag mflags, CodeAttributes attributes, CodeSpecifiers specifiers, CodeTypename type, Str name ); internal CodeVar parse_variable_declaration_list (); -internal CodeClass parser_parse_class ( bool inplace_def ); +internal CodeClass parser_parse_class ( bool inplace_def ); internal CodeConstructor parser_parse_constructor ( CodeSpecifiers specifiers ); +internal CodeDefine parser_parse_define (); internal CodeDestructor parser_parse_destructor ( CodeSpecifiers specifiers ); internal CodeEnum parser_parse_enum ( bool inplace_def ); internal CodeBody parser_parse_export_body (); @@ -266,8 +268,7 @@ StrBuilder parser_strip_formatting( Str raw_text, bool preserve_newlines ) sptr last_cut = 0; char const* scanner = raw_text.Ptr; - if ( scanner[0] == ' ' ) - { + if ( scanner[0] == ' ' ) { move_fwd(); last_cut = 1; } @@ -477,8 +478,7 @@ StrBuilder parser_strip_formatting( Str raw_text, bool preserve_newlines ) move_fwd(); } - if ( last_cut < raw_text.Len ) - { + if ( last_cut < raw_text.Len ) { strbuilder_append_c_str_len( & content, cut_ptr, raw_text.Len - last_cut ); } @@ -579,7 +579,7 @@ CodeAttributes parse_attributes() s32 len = 0; // There can be more than one attribute. If there is flatten them to a single string. - // TODO(Ed): Support keeping an linked list of attributes similar to parameters + // TODO(Ed): Support chaining attributes (Use parameter linkage pattern) while ( left && tok_is_attribute(currtok) ) { if ( check( Tok_Attribute_Open ) ) @@ -684,8 +684,7 @@ CodeAttributes parse_attributes() internal Code parse_class_struct( TokType which, bool inplace_def ) { - if ( which != Tok_Decl_Class && which != Tok_Decl_Struct ) - { + if ( which != Tok_Decl_Class && which != Tok_Decl_Struct ) { log_failure( "Error, expected class or struct, not %s\n%s", toktype_to_str( which ), parser_to_strbuilder(_ctx->parser) ); return InvalidCode; } @@ -700,8 +699,7 @@ Code parse_class_struct( TokType which, bool inplace_def ) Code result = InvalidCode; - if ( check(Tok_Module_Export) ) - { + if ( check(Tok_Module_Export) ) { mflags = ModuleFlag_Export; eat( Tok_Module_Export ); } @@ -713,8 +711,7 @@ Code parse_class_struct( TokType which, bool inplace_def ) attributes = parse_attributes(); // - if ( check( Tok_Identifier ) ) - { + if ( check( Tok_Identifier ) ) { name = parse_identifier(nullptr); _ctx->parser.Scope->Name = name.Text; } @@ -733,8 +730,7 @@ Code parse_class_struct( TokType which, bool inplace_def ) eat( Tok_Assign_Classifer ); // : - if ( tok_is_access_specifier(currtok) ) - { + if ( tok_is_access_specifier(currtok) ) { access = tok_to_access_specifier(currtok); // : eat( currtok.Type ); @@ -749,8 +745,7 @@ Code parse_class_struct( TokType which, bool inplace_def ) eat( Tok_Comma ); // : , - if ( tok_is_access_specifier(currtok) ) - { + if ( tok_is_access_specifier(currtok) ) { eat(currtok.Type); } Token interface_tok = parse_identifier(nullptr); @@ -760,8 +755,7 @@ Code parse_class_struct( TokType which, bool inplace_def ) } } - if ( check( Tok_BraceCurly_Open ) ) - { + if ( check( Tok_BraceCurly_Open ) ) { body = parse_class_struct_body( which, name ); } // : , ... { } @@ -821,93 +815,91 @@ CodeBody parse_class_struct_body( TokType which, Token name ) if ( currtok_noskip.Type == Tok_Preprocess_Hash ) eat( Tok_Preprocess_Hash ); - b32 macro_found = true; - switch ( currtok_noskip.Type ) { - case Tok_Statement_End: - { + case Tok_Statement_End: { // TODO(Ed): Convert this to a general warning procedure log_fmt("Dangling end statement found %SB\n", tok_to_strbuilder(currtok_noskip)); eat( Tok_Statement_End ); continue; } - case Tok_NewLine: + case Tok_NewLine: { member = fmt_newline; eat( Tok_NewLine ); - break; - - case Tok_Comment: + break; + } + case Tok_Comment: { member = cast(Code, parse_comment()); - break; - - case Tok_Access_Public: + break; + } + case Tok_Access_Public: { member = access_public; eat( Tok_Access_Public ); eat( Tok_Assign_Classifer ); // public: - break; - - case Tok_Access_Protected: + break; + } + case Tok_Access_Protected: { member = access_protected; eat( Tok_Access_Protected ); eat( Tok_Assign_Classifer ); // protected: - break; - - case Tok_Access_Private: + break; + } + case Tok_Access_Private: { member = access_private; eat( Tok_Access_Private ); eat( Tok_Assign_Classifer ); // private: - break; - - case Tok_Decl_Class: + break; + } + case Tok_Decl_Class: { member = parse_complicated_definition( Tok_Decl_Class ); // class - break; - - case Tok_Decl_Enum: + break; + } + case Tok_Decl_Enum: { member = parse_complicated_definition( Tok_Decl_Enum ); // enum - break; - - case Tok_Decl_Friend: + break; + } + case Tok_Decl_Friend: { member = cast(Code, parser_parse_friend()); // friend - break; - - case Tok_Decl_Operator: + break; + } + case Tok_Decl_Operator: { member = cast(Code, parser_parse_operator_cast(NullCode)); // operator () - break; - - case Tok_Decl_Struct: + break; + } + case Tok_Decl_Struct: { member = parse_complicated_definition( Tok_Decl_Struct ); // struct - break; - - case Tok_Decl_Template: + break; + } + case Tok_Decl_Template: { member = cast(Code, parser_parse_template()); // template< ... > - break; - - case Tok_Decl_Typedef: + break; + } + case Tok_Decl_Typedef: { member = cast(Code, parser_parse_typedef()); // typedef - break; - - case Tok_Decl_Union: + break; + } + case Tok_Decl_Union: { member = parse_complicated_definition( Tok_Decl_Union ); // union - break; - - case Tok_Decl_Using: + break; + } + case Tok_Decl_Using: { member = cast(Code, parser_parse_using()); // using - break; - + break; + } case Tok_Operator: + { //if ( currtok.Text[0] != '~' ) //{ // log_failure( "Operator token found in global body but not destructor unary negation\n%s", to_strbuilder(_ctx->parser) ); @@ -916,17 +908,19 @@ CodeBody parse_class_struct_body( TokType which, Token name ) member = cast(Code, parser_parse_destructor(NullCode)); // ~() - break; - - case Tok_Preprocess_Define: - member = cast(Code, parse_define()); + break; + } + case Tok_Preprocess_Define: { + member = cast(Code, parser_parse_define()); // #define - break; - + break; + } case Tok_Preprocess_Include: + { member = cast(Code, parse_include()); // #include - break; + break; + } case Tok_Preprocess_If: case Tok_Preprocess_IfDef: @@ -936,38 +930,51 @@ CodeBody parse_class_struct_body( TokType which, Token name ) // # break; - case Tok_Preprocess_Else: + case Tok_Preprocess_Else: { member = cast(Code, preprocess_else); eat( Tok_Preprocess_Else ); // #else - break; - - case Tok_Preprocess_EndIf: + break; + } + case Tok_Preprocess_EndIf: { member = cast(Code, preprocess_endif); eat( Tok_Preprocess_EndIf ); // #endif - break; + break; + } - case Tok_Preprocess_Macro: - // - macro_found = true; - goto Preprocess_Macro_Bare_In_Body; - break; + case Tok_Preprocess_Macro_Stmt: { + member = cast(Code, parse_simple_preprocess( Tok_Preprocess_Macro_Stmt )); + break; + } + case Tok_Preprocess_Macro_Expr: { + log_failure("Unbounded macro expression residing in class/struct body\n%S", parser_to_strbuilder(_ctx->parser)); + return InvalidCode; + } - case Tok_Preprocess_Pragma: + // case Tok_Preprocess_Macro: + // // + // macro_found = true; + // goto Preprocess_Macro_Bare_In_Body; + // break; + + case Tok_Preprocess_Pragma: { member = cast(Code, parse_pragma()); // #pragma - break; + break; + } - case Tok_Preprocess_Unsupported: - member = cast(Code, parse_simple_preprocess( Tok_Preprocess_Unsupported, parser_consume_braces )); + case Tok_Preprocess_Unsupported: { + member = cast(Code, parse_simple_preprocess( Tok_Preprocess_Unsupported )); // # - break; + break; + } - case Tok_StaticAssert: + case Tok_StaticAssert: { member = parse_static_assert(); // static_assert - break; + break; + } case Tok_Attribute_Open: case Tok_Decl_GNU_Attribute: @@ -1060,6 +1067,7 @@ CodeBody parse_class_struct_body( TokType which, Token name ) } //! Fallthrough intentional case Tok_Identifier: + case Tok_Preprocess_Macro_Typename: case Tok_Spec_Const: case Tok_Type_Unsigned: case Tok_Type_Signed: @@ -1080,28 +1088,6 @@ CodeBody parse_class_struct_body( TokType which, Token name ) } } - if (macro_found) - { - Preprocess_Macro_Bare_In_Body: - b32 lone_macro = nexttok.Type == Tok_Statement_End || nexttok_noskip.Type == Tok_NewLine; - if (lone_macro) - { - member = cast(Code, parse_simple_preprocess( Tok_Preprocess_Macro, parser_consume_braces )); - // ; - - if ( member == Code_Invalid ) - { - log_failure( "Failed to parse member\n%s", parser_to_strbuilder(_ctx->parser) ); - parser_pop(& _ctx->parser); - return InvalidCode; - } - continue; - } - - // We have a macro but its most likely behaving as a typename - // operator ... // or @@ -1111,13 +1097,11 @@ CodeBody parse_class_struct_body( TokType which, Token name ) default: Token untyped_tok = currtok; - while ( left && currtok.Type != Tok_BraceCurly_Close ) { untyped_tok.Text.Len = ( (sptr)currtok.Text.Ptr + currtok.Text.Len ) - (sptr)untyped_tok.Text.Ptr; eat( currtok.Type ); } - member = untyped_str( tok_to_str(untyped_tok) ); // Something unknown break; @@ -1129,7 +1113,6 @@ CodeBody parse_class_struct_body( TokType which, Token name ) parser_pop(& _ctx->parser); return InvalidCode; } - body_append(result, member ); } @@ -1311,54 +1294,6 @@ Code parse_complicated_definition( TokType which ) } } -internal inline -CodeDefine parse_define() -{ - push_scope(); - eat( Tok_Preprocess_Define ); - // #define - - CodeDefine - define = (CodeDefine) make_code(); - define->Type = CT_Preprocess_Define; - - if ( ! check( Tok_Identifier ) ) - { - log_failure( "Error, expected identifier after #define\n%s", parser_to_strbuilder(_ctx->parser) ); - parser_pop(& _ctx->parser); - return InvalidCode; - } - - _ctx->parser.Scope->Name = currtok.Text; - define->Name = cache_str( tok_to_str(currtok) ); - eat( Tok_Identifier ); - // #define - - if ( ! check( Tok_Preprocess_Content )) - { - log_failure( "Error, expected content after #define %s\n%s", define->Name, parser_to_strbuilder(_ctx->parser) ); - parser_pop(& _ctx->parser); - return InvalidCode; - } - - if ( currtok.Text.Len == 0 ) - { - define->Content = cache_str( tok_to_str(currtok) ); - eat( Tok_Preprocess_Content ); - // #define - - parser_pop(& _ctx->parser); - return define; - } - - define->Content = cache_str( strbuilder_to_str( parser_strip_formatting( tok_to_str(currtok), parser_strip_formatting_dont_preserve_newlines )) ); - eat( Tok_Preprocess_Content ); - // #define - - parser_pop(& _ctx->parser); - return define; -} - internal inline Code parse_assignment_expression() { @@ -1694,7 +1629,7 @@ CodeBody parse_global_nspace( CodeType which ) break; case Tok_Preprocess_Define: - member = cast(Code, parse_define()); + member = cast(Code, parser_parse_define()); // #define ... break; @@ -1723,12 +1658,14 @@ CodeBody parse_global_nspace( CodeType which ) // #endif break; - case Tok_Preprocess_Macro: { - // - macro_found = true; - goto Preprocess_Macro_Bare_In_Body; + case Tok_Preprocess_Macro_Stmt: { + member = cast(Code, parse_simple_preprocess( Tok_Preprocess_Macro_Stmt )); + break; + } + case Tok_Preprocess_Macro_Expr: { + log_failure("Unbounded macro expression residing in class/struct body\n%S", parser_to_strbuilder(_ctx->parser)); + return InvalidCode; } - break; case Tok_Preprocess_Pragma: { member = cast(Code, parse_pragma()); @@ -1737,7 +1674,7 @@ CodeBody parse_global_nspace( CodeType which ) break; case Tok_Preprocess_Unsupported: { - member = cast(Code, parse_simple_preprocess( Tok_Preprocess_Unsupported, parser_consume_braces )); + member = cast(Code, parse_simple_preprocess( Tok_Preprocess_Unsupported )); // # ... } break; @@ -1774,7 +1711,7 @@ CodeBody parse_global_nspace( CodeType which ) // } //! Fallthrough intentional - GEN_PARSER_CLASS_GLOBAL_NSPACE_ALLOWED_MEMBER_TOK_SPECIFIERS_CASES: + GEN_PARSER_CLASS_GLOBAL_NSPACE_ALLOWED_MEMBER_TOK_SPECIFIER_CASES: { Specifier specs_found[16] = { Spec_NumSpecifiers }; s32 NumSpecifiers = 0; @@ -1787,7 +1724,7 @@ CodeBody parse_global_nspace( CodeType which ) switch ( spec ) { - GEN_PARSER_CLASS_GLOBAL_NSPACE_ALLOWED_MEMBER_SPECIFIERS_CASES: + GEN_PARSER_CLASS_GLOBAL_NSPACE_ALLOWED_MEMBER_SPECIFIER_CASES: break; case Spec_Consteval: @@ -1822,6 +1759,7 @@ CodeBody parse_global_nspace( CodeType which ) } //! Fallthrough intentional case Tok_Identifier: + case Tok_Preprocess_Macro_Typename: case Tok_Spec_Const: case Tok_Type_Long: case Tok_Type_Short: @@ -1873,34 +1811,11 @@ CodeBody parse_global_nspace( CodeType which ) } } - if (macro_found) - { - Preprocess_Macro_Bare_In_Body: - b32 lone_macro = nexttok.Type == Tok_Statement_End || nexttok_noskip.Type == Tok_NewLine; - if (lone_macro) - { - member = parse_simple_preprocess( Tok_Preprocess_Macro, parser_consume_braces ); - // ; - - if ( member == Code_Invalid ) - { - log_failure( "Failed to parse member\n%s", parser_to_strbuilder(_ctx->parser) ); - parser_pop(& _ctx->parser); - return InvalidCode; - } - goto Member_Resolved_To_Lone_Macro; - } - - // We have a macro but its most likely behaving as a typename - // ... } } - Member_Resolved_To_Lone_Macro: if ( member == Code_Invalid ) { log_failure( "Failed to parse member\nToken: %SB\nContext:\n%SB", tok_to_strbuilder(currtok_noskip), parser_to_strbuilder(_ctx->parser) ); @@ -2520,24 +2435,16 @@ Code parse_operator_function_or_variable( bool expects_function, CodeAttributes Code result = InvalidCode; -#ifndef GEN_PARSER_DISABLE_MACRO_FUNCTION_SIGNATURES - b32 lone_macro = false; - - if ( currtok.Type == Tok_Preprocess_Macro && ( nexttok.Type == Tok_Statement_End || nexttok.Type == Tok_Comment ) ) - { - // Were dealing with a lone macro after attributes/specifiers, there was a end statement ';' after. - result = parse_simple_preprocess( Tok_Preprocess_Macro, parser_consume_braces ); + Code macro_stmt = parse_macro_as_definiton(attributes, specifiers); + if (macro_stmt) { parser_pop(& _ctx->parser); - return result; - // + return macro_stmt; } -#endif CodeTypename type = parser_parse_type( parser_not_from_template, nullptr ); // - if ( type == InvalidCode ) - { + if ( type == InvalidCode ) { parser_pop(& _ctx->parser); return InvalidCode; } @@ -2583,7 +2490,40 @@ Code parse_operator_function_or_variable( bool expects_function, CodeAttributes // Example : // idx +1 +2 bool detected_comma = _ctx->parser.Tokens.Arr[ _ctx->parser.Tokens.Idx + 2 ].Type == Tok_Comma; - if ( detected_capture && ! detected_comma ) + + b32 detected_non_varadic_unpaired_param = detected_comma && nexttok.Type != Tok_Varadic_Argument; + if (! detected_non_varadic_unpaired_param && nexttok.Type == Tok_Preprocess_Macro_Expr) for( s32 break_scope = 0; break_scope == 0; ++ break_scope) + { + Macro* macro = lookup_macro( nexttok.Text ); + if (macro == nullptr || ! macro_is_functional(* macro)) + break; + + // ( ( + // Idx +1 +2 + s32 idx = _ctx->parser.Tokens.Idx + 1; + s32 level = 0; + + // Find end of the token expression + for ( ; idx < array_num(_ctx->parser.Tokens.Arr); idx++ ) + { + Token tok = _ctx->parser.Tokens.Arr[ idx ]; + + if ( tok.Type == Tok_Capture_Start ) + level++; + else if ( tok.Type == Tok_Capture_End && level > 0 ) + level--; + if (level == 0 && tok.Type == Tok_Capture_End) + break; + } + ++ idx; // Will incremnt to possible comma position + + if ( _ctx->parser.Tokens.Arr[ idx ].Type != Tok_Comma ) + break; + + detected_non_varadic_unpaired_param = true; + } + + if ( detected_capture && ! detected_non_varadic_unpaired_param ) { // Dealing with a function result = cast(Code, parse_function_after_name( ModuleFlag_None, attributes, specifiers, type, name )); @@ -2591,19 +2531,47 @@ Code parse_operator_function_or_variable( bool expects_function, CodeAttributes } else { - if ( expects_function ) - { + if ( expects_function ) { log_failure( "Expected function declaration (consteval was used)\n%s", parser_to_strbuilder(_ctx->parser) ); parser_pop(& _ctx->parser); return InvalidCode; } - // Dealing with a variable result = cast(Code, parse_variable_after_name( ModuleFlag_None, attributes, specifiers, type, tok_to_str(name) )); // ... } } + parser_pop(& _ctx->parser); + return result; +} + +internal +Code parse_macro_as_definiton( CodeAttributes attributes, CodeSpecifiers specifiers ) +{ + push_scope(); + + if (currtok.Type != Tok_Preprocess_Macro_Stmt ) { + parser_pop(& _ctx->parser); + return NullCode; + } + Macro* macro = lookup_macro(currtok.Text); + b32 can_resolve_to_definition = macro && bitfield_is_set(MacroFlags, macro->Flags, MF_Allow_As_Definition); + if ( ! can_resolve_to_definition) { + parser_pop(& _ctx->parser); + return NullCode; + } + + // TODO(Ed): When AST_Macro is made, have it support attributs and specifiers for when its behaving as a declaration/definition. + Code code = parse_simple_preprocess( Tok_Preprocess_Macro_Stmt ); + + // Attributes and sepcifiers will be collapsed into the macro's serialization. + StrBuilder resolved_definition = strbuilder_fmt_buf(_ctx->Allocator_Temp, "%S %S %S" + , attributes ? strbuilder_to_str( attributes_to_strbuilder(attributes)) : txt("") + , specifiers ? strbuilder_to_str( specifiers_to_strbuilder(specifiers)) : txt("") + , code->Content + ); + Code result = untyped_str( strbuilder_to_str(resolved_definition) ); parser_pop(& _ctx->parser); return result; } @@ -2619,8 +2587,7 @@ CodePragma parse_pragma() eat( Tok_Preprocess_Pragma ); // #pragma - if ( ! check( Tok_Preprocess_Content )) - { + if ( ! check( Tok_Preprocess_Content )) { log_failure( "Error, expected content after #pragma\n%s", parser_to_strbuilder(_ctx->parser) ); parser_pop(& _ctx->parser); return InvalidCode; @@ -2641,15 +2608,14 @@ CodeParams parse_params( bool use_template_capture ) { push_scope(); - if ( ! use_template_capture ) + if ( ! use_template_capture ) { eat( Tok_Capture_Start ); - // ( - - else - { + // ( + } + else { if ( check( Tok_Operator ) && currtok.Text.Ptr[ 0 ] == '<' ) eat( Tok_Operator ); - // < + // < } if ( ! use_template_capture && check( Tok_Capture_End ) ) @@ -2659,7 +2625,7 @@ CodeParams parse_params( bool use_template_capture ) parser_pop(& _ctx->parser); return NullCode; } - else if ( check( Tok_Operator ) && currtok.Text.Ptr[ 0 ] == '>' ) + else if ( check( Tok_Operator ) && currtok.Text.Ptr[ 0 ] == '>' ) { eat( Tok_Operator ); // > @@ -2687,13 +2653,14 @@ CodeParams parse_params( bool use_template_capture ) #define CheckEndParams() \ (use_template_capture ? (currtok.Text.Ptr[ 0 ] != '>') : (currtok.Type != Tok_Capture_End)) + // TODO(Ed): Use expression macros or this? macro as attribute? // Ex: Unreal has this type of macro: vvvvvvvvv // COREUOBJECT_API void CallFunction( FFrame& Stack, RESULT_DECL, UFunction* Function ); // and: vvvv // AddComponentByClass(UPARAM(meta = (AllowAbstract = "false")) TSubclassOf Class, bool bManualAttachment, ... - if ( check(Tok_Preprocess_Macro)) + if ( check(Tok_Preprocess_Macro_Expr)) { - macro = parse_simple_preprocess(Tok_Preprocess_Macro, parser_consume_braces); + macro = parse_simple_preprocess(Tok_Preprocess_Macro_Expr); // ( } if ( currtok.Type != Tok_Comma ) @@ -2713,27 +2680,28 @@ CodeParams parse_params( bool use_template_capture ) // ( } + // TODO(Ed): Use expression macro for this? // Unreal has yet another type of macro: // template::Value)> // class T ... and then ^this^ UE_REQUIRES shows up // So we need to consume that. - if ( check( Tok_Preprocess_Macro )) + if ( check( Tok_Preprocess_Macro_Expr )) { - post_name_macro = parse_simple_preprocess( Tok_Preprocess_Macro, parser_consume_braces ); + post_name_macro = parse_simple_preprocess( Tok_Preprocess_Macro_Expr ); + // ( } // In template captures you can have a typename have direct assignment without a name // typename = typename ... // Which would result in a static value type from a struct expansion (traditionally) - if ( ( name.Text.Ptr || use_template_capture ) && bitfield_is_equal( u32, currtok.Flags, TF_Assign ) ) + if ( ( name.Text.Ptr || use_template_capture ) && bitfield_is_set( u32, currtok.Flags, TF_Assign ) ) { eat( Tok_Operator ); - // ( = + // ( = Token value_tok = currtok; - if ( currtok.Type == Tok_Comma ) - { + if ( currtok.Type == Tok_Comma ) { log_failure( "Expected value after assignment operator\n%s.", parser_to_strbuilder(_ctx->parser) ); parser_pop(& _ctx->parser); return InvalidCode; @@ -2801,10 +2769,10 @@ CodeParams parse_params( bool use_template_capture ) // COREUOBJECT_API void CallFunction( FFrame& Stack, RESULT_DECL, UFunction* Function ); // and: vvvv // AddComponentByClass(UPARAM(meta = (AllowAbstract = "false")) TSubclassOf Class, bool bManualAttachment, ... - if ( check(Tok_Preprocess_Macro)) + if ( check(Tok_Preprocess_Macro_Expr)) { - macro = parse_simple_preprocess(Tok_Preprocess_Macro, parser_dont_consume_braces); - // ( + macro = parse_simple_preprocess(Tok_Preprocess_Macro_Expr); + // ( = , } if ( currtok.Type != Tok_Comma ) { @@ -2829,23 +2797,22 @@ CodeParams parse_params( bool use_template_capture ) // template::Value)> // class T ... and then ^this^ UE_REQUIRES shows up // So we need to consume that. - if ( check( Tok_Preprocess_Macro )) - { - post_name_macro = parse_simple_preprocess( Tok_Preprocess_Macro, parser_dont_consume_braces ); + if ( check( Tok_Preprocess_Macro_Expr )) { + post_name_macro = parse_simple_preprocess( Tok_Preprocess_Macro_Expr ); + // ( = , } // In template captures you can have a typename have direct assignment without a name // typename = typename ... // Which would result in a static value type from a struct expansion (traditionally) - if ( ( name.Text.Ptr || use_template_capture ) && bitfield_is_equal( u32, currtok.Flags, TF_Assign ) ) + if ( ( name.Text.Ptr || use_template_capture ) && bitfield_is_set( u32, currtok.Flags, TF_Assign ) ) { eat( Tok_Operator ); - // ( = , = + // ( = , = Token value_tok = currtok; - if ( currtok.Type == Tok_Comma ) - { + if ( currtok.Type == Tok_Comma ) { log_failure( "Expected value after assignment operator\n%s", parser_to_strbuilder(_ctx->parser) ); parser_pop(& _ctx->parser); return InvalidCode; @@ -2877,9 +2844,9 @@ CodeParams parse_params( bool use_template_capture ) } value = untyped_str( strbuilder_to_str(parser_strip_formatting( tok_to_str(value_tok), parser_strip_formatting_dont_preserve_newlines )) ); - // ( = , = + // ( = , = } - // ( = , = , .. + // ( = , = , .. } CodeParams param = ( CodeParams )make_code(); @@ -2900,21 +2867,20 @@ CodeParams parse_params( bool use_template_capture ) } if ( ! use_template_capture ) + { eat( Tok_Capture_End ); - // ( = , = , .. ) - + // ( = , = , .. ) + } else { - if ( ! check( Tok_Operator ) || currtok.Text.Ptr[ 0 ] != '>' ) - { + if ( ! check( Tok_Operator ) || currtok.Text.Ptr[ 0 ] != '>' ) { log_failure( "Expected '<' after 'template' keyword\n%s", parser_to_strbuilder(_ctx->parser) ); parser_pop(& _ctx->parser); return InvalidCode; } eat( Tok_Operator ); - // < = , = , .. > + // < = , = , .. > } - parser_pop(& _ctx->parser); return result; #undef context @@ -2955,18 +2921,46 @@ CodePreprocessCond parse_preprocess_cond() } internal -Code parse_simple_preprocess( TokType which, bool dont_consume_braces ) +Code parse_simple_preprocess( TokType which ) { // TODO(Ed): We can handle a macro a bit better than this. It's AST can be made more robust.. // Make an AST_Macro, it should have an Name be the macro itself, with the function body being an optional function body node. // If we want it to terminate or have an inline comment we can possbily use its parent typedef for that info... push_scope(); - Token tok = currtok; + Token full_macro = currtok; eat( which ); // - if ( ! dont_consume_braces && peektok.Type == Tok_BraceCurly_Open ) + Macro* macro = lookup_macro( full_macro.Text ); + if ( which != Tok_Preprocess_Unsupported && macro == nullptr ) { + log_failure("Expected the macro %S to be registered\n%S", full_macro, parser_to_strbuilder(_ctx->parser)); + return NullCode; + } + + // TODO(Ed) : Parse this properly later (expression and statement support) + if ( macro && macro_is_functional(* macro) ) + { + eat( Tok_Capture_Start ); + + s32 level = 0; + while ( left && ( currtok.Type != Tok_Capture_End || level > 0 ) ) + { + if ( currtok.Type == Tok_Capture_Start ) + level++; + + else if ( currtok.Type == Tok_Capture_End && level > 0 ) + level--; + + eat( currtok.Type ); + } + eat( Tok_Capture_End ); + // ( ) + + full_macro.Text.Len = ( (sptr)prevtok.Text.Ptr + prevtok.Text.Len ) - (sptr)full_macro.Text.Ptr; + } + + if ( macro && macro_expects_body(* macro) && peektok.Type == Tok_BraceCurly_Open ) { // Eat the block scope right after the macro. Were assuming the macro defines a function definition's signature eat( Tok_BraceCurly_Open ); @@ -2987,8 +2981,9 @@ Code parse_simple_preprocess( TokType which, bool dont_consume_braces ) eat( Tok_BraceCurly_Close ); // { } + // TODO(Ed): Review this? Str prev_proc = _ctx->parser.Scope->Prev->ProcName; - if ( c_str_compare_len( prev_proc.Ptr, "parser_parse_typedef", prev_proc.Len ) != 0 ) + if ( macro->Type == MT_Typename && c_str_compare_len( prev_proc.Ptr, "parser_parse_typedef", prev_proc.Len ) != 0 ) { if ( check( Tok_Statement_End )) { @@ -3002,7 +2997,7 @@ Code parse_simple_preprocess( TokType which, bool dont_consume_braces ) } } - tok.Text.Len = ( (sptr)prevtok.Text.Ptr + prevtok.Text.Len ) - (sptr)tok.Text.Ptr; + full_macro.Text.Len = ( (sptr)prevtok.Text.Ptr + prevtok.Text.Len ) - (sptr)full_macro.Text.Ptr; } else { @@ -3015,16 +3010,15 @@ Code parse_simple_preprocess( TokType which, bool dont_consume_braces ) // Do nothing goto Leave_Scope_Early; } - else if (str_contains(_ctx->parser.Scope->Prev->ProcName, txt("parser_parse_typedef"))) + else if (macro && macro->Type == MT_Typename && str_contains(_ctx->parser.Scope->Prev->ProcName, txt("parser_parse_typedef"))) { - // TODO(Ed): Reveiw the context for this? if ( peektok.Type == Tok_Statement_End ) { Token stmt_end = currtok; eat( Tok_Statement_End ); // ; - tok.Text.Len += prevtok.Text.Len; + full_macro.Text.Len += prevtok.Text.Len; // TODO(Ed): Reveiw the context for this? (ESPECIALLY THIS) if ( currtok_noskip.Type == Tok_Comment && currtok_noskip.Line == stmt_end.Line ) @@ -3032,7 +3026,7 @@ Code parse_simple_preprocess( TokType which, bool dont_consume_braces ) eat( Tok_Comment ); // ; - tok.Text.Len += prevtok.Text.Len; + full_macro.Text.Len += prevtok.Text.Len; } } } @@ -3041,24 +3035,19 @@ Code parse_simple_preprocess( TokType which, bool dont_consume_braces ) || str_contains(calling_proc, txt("parse_class_struct_body")) ) { - if (peektok.Type == Tok_Statement_End) + if (left && peektok.Type == Tok_Statement_End) { Token stmt_end = currtok; eat( Tok_Statement_End ); // ; - tok.Text.Len += prevtok.Text.Len; + full_macro.Text.Len += prevtok.Text.Len; } - } - // tok.Length = ( (sptr)prevtok.Text + prevtok.Length ) - (sptr)tok.Text; } Leave_Scope_Early: - - char const* content = c_str_fmt_buf( "%.*s ", tok.Text.Len, tok.Text.Ptr ); - - Code result = untyped_str( to_str_from_c_str(content) ); - _ctx->parser.Scope->Name = tok.Text; + Code result = untyped_str( full_macro.Text ); + _ctx->parser.Scope->Name = full_macro.Text; parser_pop(& _ctx->parser); return result; @@ -3153,19 +3142,18 @@ CodeVar parse_variable_after_name( , CodeAttributes attributes , CodeSpecifiers specifiers , CodeTypename type - , Str name + , Str name ) { push_scope(); Code array_expr = parse_array_decl(); - Code expr = { nullptr }; - Code bitfield_expr = { nullptr }; + Code expr = NullCode; + Code bitfield_expr = NullCode; b32 using_constructor_initializer = false; - if ( bitfield_is_equal( u32, currtok.Flags, TF_Assign ) ) - { + if ( bitfield_is_set( u32, currtok.Flags, TF_Assign ) ) { // = expr = parse_assignment_expression(); } @@ -3229,15 +3217,13 @@ CodeVar parse_variable_after_name( Token expr_tok = currtok; - if ( currtok.Type == Tok_Statement_End ) - { + if ( currtok.Type == Tok_Statement_End ) { log_failure( "Expected expression after bitfield \n%SB", parser_to_strbuilder(_ctx->parser) ); parser_pop(& _ctx->parser); return InvalidCode; } - while ( left && currtok.Type != Tok_Statement_End ) - { + while ( left && currtok.Type != Tok_Statement_End ) { eat( currtok.Type ); } @@ -3251,8 +3237,7 @@ CodeVar parse_variable_after_name( CodeComment inline_cmt = NullCode; if ( type ) { - if ( currtok.Type == Tok_Comma ) - { + if ( currtok.Type == Tok_Comma ) { // Were dealing with a statement with more than one declaration // This is only handled this way if its the first declaration // Otherwise its looped through in parse_variable_declaration_list @@ -3271,8 +3256,7 @@ CodeVar parse_variable_after_name( // { }, ...; // Check for inline comment : = ; // - if ( left && ( currtok_noskip.Type == Tok_Comment ) && currtok_noskip.Line == stmt_end.Line ) - { + if ( left && ( currtok_noskip.Type == Tok_Comment ) && currtok_noskip.Line == stmt_end.Line ) { inline_cmt = parse_comment(); // : , ...; // = , ...; @@ -3285,35 +3269,20 @@ CodeVar parse_variable_after_name( result->Type = CT_Variable; result->Name = cache_str( name ); result->ModuleFlags = mflags; + result->ValueType = type; + result->BitfieldSize = bitfield_expr; + result->Attributes = attributes; + result->Specs = specifiers; + result->Value = expr; + result->InlineCmt = inline_cmt; - // Type can be null if we're dealing with a declaration from a variable declaration-list - if ( type ) - result->ValueType = type; - - if (array_expr ) + if (array_expr) type->ArrExpr = array_expr; - if ( bitfield_expr ) - result->BitfieldSize = bitfield_expr; - - if ( attributes ) - result->Attributes = attributes; - - if ( specifiers ) - result->Specs = specifiers; - - if ( expr ) - result->Value = expr; - - if ( inline_cmt ) - result->InlineCmt = inline_cmt; - - if ( next_var ) - { + if ( next_var ) { result->NextVar = next_var; result->NextVar->Parent = cast(Code, result); } - result->VarParenthesizedInit = using_constructor_initializer; parser_pop(& _ctx->parser); @@ -3502,6 +3471,93 @@ CodeConstructor parser_parse_constructor( CodeSpecifiers specifiers ) return result; } +internal inline +CodeDefine parser_parse_define() +{ + push_scope(); + if ( check(Tok_Preprocess_Hash)) { + // If parse_define is called by the user the hash reach here. + eat(Tok_Preprocess_Hash); + } + + eat( Tok_Preprocess_Define ); + // #define + + CodeDefine + define = (CodeDefine) make_code(); + define->Type = CT_Preprocess_Define; + if ( ! check( Tok_Identifier ) ) { + log_failure( "Error, expected identifier after #define\n%s", parser_to_strbuilder(_ctx->parser) ); + parser_pop(& _ctx->parser); + return InvalidCode; + } + _ctx->parser.Scope->Name = currtok.Text; + define->Name = cache_str( tok_to_str(currtok) ); + eat( Tok_Identifier ); + // #define + + Macro* macro = lookup_macro(define->Name); + if (macro_is_functional(* macro)) { + eat( Tok_Capture_Start ); + // #define ( + + // We provide the define params even if empty to make sure '()' are serialized. + CodeDefineParams + params = (CodeDefineParams) make_code(); + params->Type = CT_Parameters_Define; + + if ( left && currtok.Type != Tok_Capture_End ) { + params->Name = currtok.Text; + params->NumEntries ++; + + eat( Tok_Preprocess_Define_Param ); + // #define ( + } + + while( left && currtok.Type != Tok_Capture_End ) { + eat( Tok_Comma ); + // #define ( , + + CodeDefineParams next_param = (CodeDefineParams) make_code(); + next_param->Type = CT_Parameters_Define; + next_param->Name = currtok.Text; + define_params_append(params, next_param); + + // #define ( , ... + eat( Tok_Preprocess_Define_Param ); + } + + eat( Tok_Capture_End ); + // #define ( ) + + define->Params = params; + } + + if ( ! check( Tok_Preprocess_Content )) + { + log_failure( "Error, expected content after #define %s\n%s", define->Name, parser_to_strbuilder(_ctx->parser) ); + parser_pop(& _ctx->parser); + return InvalidCode; + } + + if ( currtok.Text.Len == 0 ) + { + define->Body = untyped_str( txt("\n") ); + eat( Tok_Preprocess_Content ); + // #define ( ) + + parser_pop(& _ctx->parser); + return define; + } + + define->Body = untyped_str( strbuilder_to_str( parser_strip_formatting( tok_to_str(currtok), parser_strip_formatting_dont_preserve_newlines )) ); + eat( Tok_Preprocess_Content ); + // #define ( ) + + parser_pop(& _ctx->parser); + return define; +} + internal CodeDestructor parser_parse_destructor( CodeSpecifiers specifiers ) { @@ -3559,7 +3615,7 @@ CodeDestructor parser_parse_destructor( CodeSpecifiers specifiers ) specifiers_append(specifiers, Spec_Pure ); } - else if ( left && c_str_compare_len( upcoming.Text.Ptr, "default", sizeof("default") - 1 ) == 0) + else if ( left && c_str_compare_len( upcoming.Text.Ptr, "default", sizeof("default") - 1 ) == 0) { body = cast(CodeBody, parse_assignment_expression()); // ~< @@ -3575,8 +3631,10 @@ CodeDestructor parser_parse_destructor( CodeSpecifiers specifiers ) } if ( ! pure_virtual && check( Tok_BraceCurly_Open ) ) + { body = cast(CodeBody, parse_function_body()); - // ~() { ... } + // ~() { ... } + } else { Token stmt_end = currtok; @@ -3590,8 +3648,7 @@ CodeDestructor parser_parse_destructor( CodeSpecifiers specifiers ) CodeDestructor result = ( CodeDestructor )make_code(); - if ( tok_is_valid(prefix_identifier) ) - { + if ( tok_is_valid(prefix_identifier) ) { prefix_identifier.Text.Len += 1 + identifier.Text.Len; result->Name = cache_str( tok_to_str(prefix_identifier) ); } @@ -3599,8 +3656,7 @@ CodeDestructor parser_parse_destructor( CodeSpecifiers specifiers ) if ( specifiers ) result->Specs = specifiers; - if ( body && body->Type == CT_Function_Body ) - { + if ( body && body->Type == CT_Function_Body ) { result->Body = cast(Code, body); result->Type = CT_Destructor; } @@ -3670,13 +3726,13 @@ CodeEnum parser_parse_enum( bool inplace_def ) } // enum : } - else if ( currtok.Type == Tok_Preprocess_Macro ) + else if ( currtok.Type == Tok_Preprocess_Macro_Expr ) { // We'll support the enum_underlying macro - if ( str_contains( tok_to_str(currtok), enum_underlying_sig) ) + if ( str_contains( tok_to_str(currtok), enum_underlying_macro.Name) ) { use_macro_underlying = true; - underlying_macro = parse_simple_preprocess( Tok_Preprocess_Macro, parser_dont_consume_braces ); + underlying_macro = parse_simple_preprocess( Tok_Preprocess_Macro_Expr ); } } @@ -3717,7 +3773,7 @@ CodeEnum parser_parse_enum( bool inplace_def ) break; case Tok_Preprocess_Define: - member = cast(Code, parse_define()); + member = cast(Code, parser_parse_define()); // #define break; @@ -3739,10 +3795,11 @@ CodeEnum parser_parse_enum( bool inplace_def ) eat( Tok_Preprocess_EndIf ); break; - case Tok_Preprocess_Macro: - member = cast(Code, parse_simple_preprocess( Tok_Preprocess_Macro, parser_consume_braces)); + case Tok_Preprocess_Macro_Stmt: { + member = cast(Code, parse_simple_preprocess( Tok_Preprocess_Macro_Stmt )); // - break; + break; + } case Tok_Preprocess_Pragma: member = cast(Code, parse_pragma()); @@ -3750,11 +3807,12 @@ CodeEnum parser_parse_enum( bool inplace_def ) break; case Tok_Preprocess_Unsupported: - member = cast(Code, parse_simple_preprocess( Tok_Preprocess_Unsupported, parser_consume_braces )); + member = cast(Code, parse_simple_preprocess( Tok_Preprocess_Unsupported )); // # break; default: + { Token entry = currtok; eat( Tok_Identifier); @@ -3765,18 +3823,19 @@ CodeEnum parser_parse_enum( bool inplace_def ) eat( Tok_Operator ); // = - while ( currtok.Type != Tok_Comma && currtok.Type != Tok_BraceCurly_Close ) - { + while ( currtok.Type != Tok_Comma && currtok.Type != Tok_BraceCurly_Close ) { eat( currtok.Type ); } } // = // Unreal UMETA macro support - if ( currtok.Type == Tok_Preprocess_Macro ) - { - eat( Tok_Preprocess_Macro ); + if ( currtok.Type == Tok_Preprocess_Macro_Expr ) { + Code macro = parse_simple_preprocess( Tok_Preprocess_Macro_Expr ); // = + + // We're intentially ignoring this code as its going to be serialized as an untyped string with the rest of the enum "entry". + // TODO(Ed): We need a CodeEnumEntry, AST_EnumEntry types } if ( currtok.Type == Tok_Comma ) @@ -3799,11 +3858,11 @@ CodeEnum parser_parse_enum( bool inplace_def ) entry.Text.Len = ( (sptr)prev.Text.Ptr + prev.Text.Len ) - (sptr)entry.Text.Ptr; member = untyped_str( tok_to_str(entry) ); + } break; } - if ( member == Code_Invalid ) - { + if ( member == Code_Invalid ) { log_failure( "Failed to parse member\n%s", parser_to_strbuilder(_ctx->parser) ); parser_pop(& _ctx->parser); return InvalidCode; @@ -3952,8 +4011,7 @@ CodeFriend parser_parse_friend() eat( currtok.Type ); } - if ( NumSpecifiers ) - { + if ( NumSpecifiers ) { specifiers = def_specifiers( NumSpecifiers, specs_found ); } // @@ -3961,8 +4019,7 @@ CodeFriend parser_parse_friend() // Type declaration or return type CodeTypename type = parser_parse_type(parser_not_from_template, nullptr); - if ( cast(Code, type) == Code_Invalid ) - { + if ( cast(Code, type) == Code_Invalid ) { parser_pop(& _ctx->parser); return InvalidCode; } @@ -3992,8 +4049,7 @@ CodeFriend parser_parse_friend() } // Operator declaration or definition - if ( currtok.Type == Tok_Decl_Operator ) - { + if ( currtok.Type == Tok_Decl_Operator ) { op = parse_operator_after_ret_type( ModuleFlag_None, NullCode, specifiers, type ); } @@ -4040,8 +4096,7 @@ CodeFn parser_parse_function() CodeSpecifiers specifiers = { nullptr }; ModuleFlag mflags = ModuleFlag_None; - if ( check(Tok_Module_Export) ) - { + if ( check(Tok_Module_Export) ) { mflags = ModuleFlag_Export; eat( Tok_Module_Export ); } @@ -4073,15 +4128,20 @@ CodeFn parser_parse_function() eat( currtok.Type ); } - if ( NumSpecifiers ) - { + if ( NumSpecifiers ) { specifiers = def_specifiers( NumSpecifiers, specs_found ); } // + // Note(Ed): We're enforcing that using this codepath requires non-macro jank. + // Code macro_stmt = parse_macro_as_definiton(attributes, specifiers); + // if (macro_stmt) { + // parser_pop(& _ctx->parser); + // return macro_stmt; + // } + CodeTypename ret_type = parser_parse_type(parser_not_from_template, nullptr); - if ( cast(Code, ret_type) == Code_Invalid ) - { + if ( cast(Code, ret_type) == Code_Invalid ) { parser_pop(& _ctx->parser); return InvalidCode; } @@ -4089,8 +4149,7 @@ CodeFn parser_parse_function() Token name = parse_identifier(nullptr); _ctx->parser.Scope->Name = name.Text; - if ( ! tok_is_valid(name) ) - { + if ( ! tok_is_valid(name) ) { parser_pop(& _ctx->parser); return InvalidCode; } @@ -4116,8 +4175,7 @@ CodeNS parser_parse_namespace() // namespace CodeBody body = parse_global_nspace( CT_Namespace_Body ); - if ( cast(Code, body) == Code_Invalid ) - { + if ( cast(Code, body) == Code_Invalid ) { parser_pop(& _ctx->parser); return InvalidCode; } @@ -4146,8 +4204,7 @@ CodeOperator parser_parse_operator() Specifier specs_found[16] = { Spec_NumSpecifiers }; s32 NumSpecifiers = 0; - if ( check(Tok_Module_Export) ) - { + if ( check(Tok_Module_Export) ) { mflags = ModuleFlag_Export; eat( Tok_Module_Export ); } @@ -4179,8 +4236,7 @@ CodeOperator parser_parse_operator() eat( currtok.Type ); } - if ( NumSpecifiers ) - { + if ( NumSpecifiers ) { specifiers = def_specifiers( NumSpecifiers, specs_found ); } // @@ -4291,13 +4347,11 @@ CodeOpCast parser_parse_operator_cast( CodeSpecifiers specifiers ) if ( tok_is_valid(name) ) result->Name = cache_str( tok_to_str(name) ); - if (body) - { + if (body) { result->Type = CT_Operator_Cast; result->Body = cast(CodeBody, body); } - else - { + else { result->Type = CT_Operator_Cast_Fwd; } @@ -4328,8 +4382,7 @@ CodeTemplate parser_parse_template() ModuleFlag mflags = ModuleFlag_None; - if ( check( Tok_Module_Export ) ) - { + if ( check( Tok_Module_Export ) ) { mflags = ModuleFlag_Export; eat( Tok_Module_Export ); } @@ -4339,8 +4392,7 @@ CodeTemplate parser_parse_template() // template CodeParams params = parse_params( UseTemplateCapture ); - if ( cast(Code, params) == Code_Invalid ) - { + if ( cast(Code, params) == Code_Invalid ) { parser_pop(& _ctx->parser); return InvalidCode; } @@ -4422,8 +4474,7 @@ CodeTemplate parser_parse_template() eat( currtok.Type ); } - if ( NumSpecifiers ) - { + if ( NumSpecifiers ) { specifiers = def_specifiers( NumSpecifiers, specs_found ); } // template< > @@ -4436,7 +4487,7 @@ CodeTemplate parser_parse_template() if (is_in_global_nspace) { Code constructor_destructor = parse_global_nspace_constructor_destructor( specifiers ); - if ( constructor_destructor ) + if ( constructor_destructor ) { definition = constructor_destructor; // :: () { ... } @@ -4470,8 +4521,7 @@ CodeTemplate parser_parse_template() break; } - if ( found_operator_cast_outside_class_implmentation ) - { + if ( found_operator_cast_outside_class_implmentation ) { definition = cast(Code, parser_parse_operator_cast( specifiers )); // :: operator () { ... } break; @@ -4530,8 +4580,7 @@ CodeTypename parser_parse_type( bool from_template, bool* typedef_is_function ) { Specifier spec = str_to_specifier( tok_to_str(currtok) ); - if ( spec != Spec_Const ) - { + if ( spec != Spec_Const ) { log_failure( "Error, invalid specifier used in type definition: %S\n%SB", tok_to_str(currtok), parser_to_strbuilder(_ctx->parser) ); parser_pop(& _ctx->parser); return InvalidCode; @@ -4543,8 +4592,7 @@ CodeTypename parser_parse_type( bool from_template, bool* typedef_is_function ) } // - if ( left == 0 ) - { + if ( left == 0 ) { log_failure( "Error, unexpected end of type definition\n%SB", parser_to_strbuilder(_ctx->parser) ); parser_pop(& _ctx->parser); return InvalidCode; @@ -4643,16 +4691,17 @@ else if ( currtok.Type == Tok_DeclType ) } } } - else if ( currtok.Type == Tok_Preprocess_Macro ) { + // TODO(Ed): This needs updating + else if ( currtok.Type == Tok_Preprocess_Macro_Typename ) { // Typename is a macro name = currtok; - eat(Tok_Preprocess_Macro); + eat(Tok_Preprocess_Macro_Typename); } // The usual Identifier type signature that may have namespace qualifiers else { - name = parse_identifier(nullptr); + name = parse_identifier(nullptr); _ctx->parser.Scope->Name = name.Text; if ( ! tok_is_valid(name) ) { @@ -4986,25 +5035,36 @@ CodeTypedef parser_parse_typedef() const bool from_typedef = true; + // TODO(Ed): UPDATE MACRO USAGE HERE #if GEN_PARSER_DISABLE_MACRO_TYPEDEF if ( false ) #else - if ( check( Tok_Preprocess_Macro )) + b32 valid_macro = false; + valid_macro |= left && currtok.Type == Tok_Preprocess_Macro_Typename; + valid_macro |= left && currtok.Type == Tok_Preprocess_Macro_Stmt; + // if (currtok.Type == Tok_Preprocess_Macro_Stmt) + // { + // PreprocessMacro* macro = lookup_macro(currtok.Text); + // valid_macro |= macro && macro_expects_body(* macro)); + // } + + if ( valid_macro ) #endif { - type = cast(Code, t_empty); - name = currtok; + type = cast(Code, t_empty); + name = currtok; + Code macro = parse_simple_preprocess(currtok.Type); + name.Text.Len = macro->Content.Len; _ctx->parser.Scope->Name = name.Text; - eat( Tok_Preprocess_Macro ); // typedef if ( currtok.Type == Tok_Identifier ) { - type = untyped_str(name.Text); + type = macro; name = currtok; eat(Tok_Identifier); + // typedef } - // typedef } else { @@ -5198,7 +5258,7 @@ CodeUnion parser_parse_union( bool inplace_def ) Str name = { nullptr, 0 }; if ( check( Tok_Identifier ) ) -{ + { name = tok_to_str(currtok); _ctx->parser.Scope->Name = currtok.Text; eat( Tok_Identifier ); @@ -5251,7 +5311,7 @@ CodeUnion parser_parse_union( bool inplace_def ) break; case Tok_Preprocess_Define: - member = cast(Code, parse_define()); + member = cast(Code, parser_parse_define()); break; case Tok_Preprocess_If: @@ -5271,14 +5331,13 @@ CodeUnion parser_parse_union( bool inplace_def ) eat( Tok_Preprocess_EndIf ); break; - case Tok_Preprocess_Macro: - if ( nexttok.Type == Tok_Identifier ) { - // Its a variable with a macro typename - member = cast(Code, parser_parse_variable()); - break; - } + case Tok_Preprocess_Macro_Typename: + // Its a variable with a macro typename + member = cast(Code, parser_parse_variable()); + break; - member = parse_simple_preprocess( Tok_Preprocess_Macro, parser_consume_braces ); + case Tok_Preprocess_Macro_Stmt: + member = parse_simple_preprocess( Tok_Preprocess_Macro_Stmt ); break; case Tok_Preprocess_Pragma: @@ -5286,7 +5345,7 @@ CodeUnion parser_parse_union( bool inplace_def ) break; case Tok_Preprocess_Unsupported: - member = parse_simple_preprocess( Tok_Preprocess_Unsupported, parser_consume_braces ); + member = parse_simple_preprocess( Tok_Preprocess_Unsupported ); break; default: @@ -5349,7 +5408,7 @@ CodeUsing parser_parse_using() eat( Tok_Decl_Using ); // using - if ( currtok.Type == Tok_Decl_Namespace ) + if ( currtok.Type == Tok_Decl_Namespace ) { is_namespace = true; eat( Tok_Decl_Namespace ); @@ -5363,7 +5422,7 @@ CodeUsing parser_parse_using() if ( ! is_namespace ) { - if ( bitfield_is_equal( u32, currtok.Flags, TF_Assign ) ) + if ( bitfield_is_set( u32, currtok.Flags, TF_Assign ) ) { attributes = parse_attributes(); // using @@ -5384,8 +5443,7 @@ CodeUsing parser_parse_using() // using = ; CodeComment inline_cmt = NullCode; - if ( currtok_noskip.Type == Tok_Comment && currtok_noskip.Line == stmt_end.Line ) - { + if ( currtok_noskip.Type == Tok_Comment && currtok_noskip.Line == stmt_end.Line ) { inline_cmt = parse_comment(); } // using = ; @@ -5432,8 +5490,7 @@ CodeVar parser_parse_variable() CodeAttributes attributes = { nullptr }; CodeSpecifiers specifiers = { nullptr }; - if ( check(Tok_Module_Export) ) - { + if ( check(Tok_Module_Export) ) { mflags = ModuleFlag_Export; eat( Tok_Module_Export ); } @@ -5465,12 +5522,18 @@ CodeVar parser_parse_variable() eat( currtok.Type ); } - if ( NumSpecifiers ) - { + if ( NumSpecifiers ) { specifiers = def_specifiers( NumSpecifiers, specs_found ); } // + // Note(Ed): We're enforcing that using this codepath requires non-macro jank. + // Code macro_stmt = parse_macro_as_definiton(attributes, specifiers); + // if (macro_stmt) { + // parser_pop(& _ctx->parser); + // return macro_stmt; + // } + CodeTypename type = parser_parse_type(parser_not_from_template, nullptr); // diff --git a/base/components/parser_case_macros.cpp b/base/components/parser_case_macros.cpp index c2497c4..a84e401 100644 --- a/base/components/parser_case_macros.cpp +++ b/base/components/parser_case_macros.cpp @@ -25,7 +25,7 @@ case Spec_Static: \ case Spec_Volatile: \ case Spec_Virtual -#define GEN_PARSER_CLASS_GLOBAL_NSPACE_ALLOWED_MEMBER_TOK_SPECIFIERS_CASES \ +#define GEN_PARSER_CLASS_GLOBAL_NSPACE_ALLOWED_MEMBER_TOK_SPECIFIER_CASES \ case Tok_Spec_Consteval: \ case Tok_Spec_Constexpr: \ case Tok_Spec_Constinit: \ @@ -37,7 +37,7 @@ case Tok_Spec_Internal_Linkage: \ case Tok_Spec_NeverInline: \ case Tok_Spec_Static -#define GEN_PARSER_CLASS_GLOBAL_NSPACE_ALLOWED_MEMBER_SPECIFIERS_CASES \ +#define GEN_PARSER_CLASS_GLOBAL_NSPACE_ALLOWED_MEMBER_SPECIFIER_CASES \ case Spec_Constexpr: \ case Spec_Constinit: \ case Spec_ForceInline: \ diff --git a/base/components/parser_types.hpp b/base/components/parser_types.hpp index cb91e9a..f98291e 100644 --- a/base/components/parser_types.hpp +++ b/base/components/parser_types.hpp @@ -4,39 +4,24 @@ #include "gen/ecode.hpp" #include "gen/eoperator.hpp" #include "gen/especifier.hpp" +#include "gen/etoktype.hpp" #endif -enum MacroFlags : u32 -{ - // Can only be one of these at a time (required) - MF_Block_Start = bit(0), // Start of a "block" scope - MF_Block_End = bit(1), // End of a "block" scope - MF_Case_Statement = bit(2), // Used as a case statement (not utilized by the parser yet) - MF_Expression = bit(3), // Used as an expresssion (not utilized by the parser yet) - MF_Statement = bit(4), // Used a statement (will expect to be a lone macro) - MF_Expects_Body = bit(5), // Expects to consume a braced scope - MF_Typename = bit(6), // Behaves as a typename - - // Optional - MF_Functional = bit(7), - - MF_Null = 0, - MF_UnderlyingType = GEN_U32_MAX, -}; - 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_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_Null = 0, TF_UnderlyingType = GEN_U32_MAX, @@ -70,42 +55,42 @@ bool tok_is_valid( Token tok ) { forceinline bool tok_is_access_operator(Token tok) { - return bitfield_is_equal( u32, tok.Flags, TF_AccessOperator ); + return bitfield_is_set( u32, tok.Flags, TF_AccessOperator ); } forceinline bool tok_is_access_specifier(Token tok) { - return bitfield_is_equal( u32, tok.Flags, TF_AccessSpecifier ); + return bitfield_is_set( u32, tok.Flags, TF_AccessSpecifier ); } forceinline bool tok_is_attribute(Token tok) { - return bitfield_is_equal( u32, tok.Flags, TF_Attribute ); + return bitfield_is_set( u32, tok.Flags, TF_Attribute ); } forceinline bool tok_is_operator(Token tok) { - return bitfield_is_equal( u32, tok.Flags, TF_Operator ); + return bitfield_is_set( u32, tok.Flags, TF_Operator ); } forceinline bool tok_is_preprocessor(Token tok) { - return bitfield_is_equal( u32, tok.Flags, TF_Preprocess ); + return bitfield_is_set( u32, tok.Flags, TF_Preprocess ); } forceinline bool tok_is_preprocess_cond(Token tok) { - return bitfield_is_equal( u32, tok.Flags, TF_Preprocess_Cond ); + return bitfield_is_set( u32, tok.Flags, TF_Preprocess_Cond ); } forceinline bool tok_is_specifier(Token tok) { - return bitfield_is_equal( u32, tok.Flags, TF_Specifier ); + return bitfield_is_set( u32, tok.Flags, TF_Specifier ); } forceinline bool tok_is_end_definition(Token tok) { - return bitfield_is_equal( u32, tok.Flags, TF_EndDefinition ); + return bitfield_is_set( u32, tok.Flags, TF_EndDefinition ); } StrBuilder tok_to_strbuilder(Token tok); @@ -123,7 +108,7 @@ struct LexContext char const* scanner; s32 line; s32 column; - StringTable defines; + // StringTable defines; Token token; }; @@ -141,3 +126,100 @@ struct ParseContext TokArray Tokens; StackNode* Scope; }; + +enum MacroType : u16 +{ + MT_Expression, // A macro is assumed to be a expression if not resolved. + MT_Statement, + MT_Typename, + MT_Attribute, // More of a note to the parser than anythign else (attributes should be defined in the user attribues def). + MT_Specifier, // More of a note to the parser than anythign else (specifiers should be defined in the user attribues def). + MT_Block_Start, // Not Supported yet + MT_Block_End, // Not Supported yet + MT_Case_Statement, // Not Supported yet + + MT_UnderlyingType = GEN_U16_MAX, +}; + +forceinline +TokType macrotype_to_toktype( MacroType type ) { + switch ( type ) { + case MT_Statement : return Tok_Preprocess_Macro_Stmt; + case MT_Expression : return Tok_Preprocess_Macro_Expr; + case MT_Typename : return Tok_Preprocess_Macro_Typename; + } + // All others unsupported for now. + return Tok_Invalid; +} + +inline +Str macrotype_to_str( MacroType type ) +{ + local_persist + Str lookup[] = { + { "Statement", sizeof("Statement") - 1 }, + { "Expression", sizeof("Expression") - 1 }, + { "Typename", sizeof("Typename") - 1 }, + { "Attribute(Macro)", sizeof("Attribute(Macro)") - 1 }, + { "Specifier(Macro)", sizeof("Specifier(Macro)") - 1 }, + { "Block_Start", sizeof("Block_Start") - 1 }, + { "Block_End", sizeof("Block_End") - 1 }, + { "Case_Statement", sizeof("Case_Statement") - 1 }, + }; + local_persist + Str invalid = { "Invalid", sizeof("Invalid") }; + if ( type > MT_Case_Statement ) + return invalid; + + return lookup[ type ]; +} + +enum EMacroFlags : u16 +{ + MF_Functional = bit(0), // Macro has parameters (args expected to be passed) + MF_Expects_Body = bit(1), // Expects to assign a braced scope to its body. + + // lex__eat wil treat this macro as an identifier if the parser attempts to consume it as one. + // ^^^ This is a kludge because we don't support push/pop macro pragmas rn. + MF_Allow_As_Identifier = bit(2), + + // lex__eat wil treat this macro as an attribute if the parser attempts to consume it as one. + // ^^^ This a kludge because unreal has a macro that behaves as both a 'statement' and an attribute (UE_DEPRECATED, PRAGMA_ENABLE_DEPRECATION_WARNINGS, etc) + // TODO(Ed): We can keep the MF_Allow_As_Attribute flag for macros, however, we need to add the ability of AST_Attributes to chain themselves. + // Its thats already a thing in the standard language anyway + // & it would allow UE_DEPRECATED, (UE_PROPERTY / UE_FUNCTION) to chain themselves as attributes of a resolved member function/varaible definition + MF_Allow_As_Attribute = bit(3), + + // When a macro is encountered after attributs and specifiers while parsing a function, or variable: + // It will consume the macro and treat it as resolving the definition. (Yes this is for Unreal Engine) + // (MUST BE OF MT_Statement TYPE) + MF_Allow_As_Definition = bit(4), + + MF_Null = 0, + MF_UnderlyingType = GEN_U16_MAX, +}; +typedef u16 MacroFlags; + +struct Macro +{ + StrCached Name; + MacroType Type; + MacroFlags Flags; +}; + +forceinline +b32 macro_is_functional( Macro macro ) { + return bitfield_is_set( b16, macro.Flags, MF_Functional ); +} + +forceinline +b32 macro_expects_body( Macro macro ) { + return bitfield_is_set( b16, macro.Flags, MF_Expects_Body ); +} + +#if GEN_COMPILER_CPP && ! GEN_C_LIKE_CPP +forceinline b32 is_functional( Macro macro ) { return bitfield_is_set( b16, macro.Flags, MF_Functional ); } +forceinline b32 expects_body ( Macro macro ) { return bitfield_is_set( b16, macro.Flags, MF_Expects_Body ); } +#endif + +typedef HashTable(Macro) MacroTable; diff --git a/base/components/static_data.cpp b/base/components/static_data.cpp index cad615c..3c9c0f1 100644 --- a/base/components/static_data.cpp +++ b/base/components/static_data.cpp @@ -9,7 +9,7 @@ global Context* _ctx; #pragma region Constants global u32 context_counter; -global Str enum_underlying_sig; +global Macro enum_underlying_macro; global Code Code_Global; global Code Code_Invalid; diff --git a/base/dependencies/containers.hpp b/base/dependencies/containers.hpp index 13386e6..a84d148 100644 --- a/base/dependencies/containers.hpp +++ b/base/dependencies/containers.hpp @@ -143,6 +143,7 @@ Array array_init_reserve(AllocatorInfo allocator, ssize capacity) return {rcast(Type*, header + 1)}; } +forceinline usize array_grow_formula(ssize value) { return 2 * value + 8; } @@ -202,7 +203,7 @@ bool array_append_at(Array* array, Type item, usize idx) ArrayHeader* header = array_get_header(* array); ssize slot = idx; - if (slot >= header->Num) + if (slot >= (ssize)(header->Num)) slot = header->Num - 1; if (slot < 0) @@ -354,7 +355,6 @@ bool array_reserve(Array* array, usize new_capacity) { GEN_ASSERT( array != nullptr); GEN_ASSERT(* array != nullptr); - GEN_ASSERT(num > 0) ArrayHeader* header = array_get_header(array); if (header->Capacity < new_capacity) @@ -763,7 +763,7 @@ HashTableFindResult hashtable__find(HashTable table, u64 key) } template forceinline -bool hashtable_full(HashTable table) { +b32 hashtable_full(HashTable table) { GEN_ASSERT_NOT_NULL(table.Hashes); GEN_ASSERT_NOT_NULL(table.Entries); usize critical_load = usize(HashTable_CriticalLoadScale * f32(array_num(table.Hashes))); diff --git a/base/dependencies/debug.hpp b/base/dependencies/debug.hpp index 6870261..858b277 100644 --- a/base/dependencies/debug.hpp +++ b/base/dependencies/debug.hpp @@ -44,7 +44,7 @@ // NOTE: Things that shouldn't happen with a message! #define GEN_PANIC( msg, ... ) GEN_ASSERT_MSG( 0, msg, ##__VA_ARGS__ ) -#if GEN_BULD_DEBUG +#if GEN_BUILD_DEBUG #define GEN_FATAL( ... ) \ do \ { \ diff --git a/base/dependencies/macros.hpp b/base/dependencies/macros.hpp index 78bbe30..f582d65 100644 --- a/base/dependencies/macros.hpp +++ b/base/dependencies/macros.hpp @@ -34,8 +34,8 @@ #endif #ifndef bit -#define bit( Value ) ( 1 << Value ) -#define bitfield_is_equal( Type, Field, Mask ) ( (scast(Type, Mask) & scast(Type, Field)) == scast(Type, Mask) ) +#define bit( Value ) ( 1 << Value ) +#define bitfield_is_set( Type, Field, Mask ) ( (scast(Type, Mask) & scast(Type, Field)) == scast(Type, Mask) ) #endif // Mainly intended for forcing the base library to utilize only C-valid constructs or type coercion @@ -86,14 +86,16 @@ #define stringize( ... ) stringize_va( __VA_ARGS__ ) #endif -#ifndef do_once -#define do_once() \ - static int __do_once_counter_##__LINE__ = 0; \ - for(; __do_once_counter_##__LINE__ != 1; __do_once_counter_##__LINE__ = 1 ) \ +#define src_line_str stringize(__LINE__) -#define do_once_defer( expression ) \ - static int __do_once_counter_##__LINE__ = 0; \ - for(; __do_once_counter_##__LINE__ != 1; __do_once_counter_##__LINE__ = 1, (expression)) \ +#ifndef do_once +#define do_once() \ + static int __do_once_counter_##src_line_str = 0; \ + for(; __do_once_counter_##src_line_str != 1; __do_once_counter_##src_line_str = 1 ) \ + +#define do_once_defer( expression ) \ + static int __do_once_counter_##src_line_str = 0; \ + for(; __do_once_counter_##src_line_str != 1; __do_once_counter_##src_line_str = 1, (expression)) \ #define do_once_start \ do \ @@ -248,9 +250,9 @@ # if ! GEN_COMPILER_C # define typeof decltype # elif defined(_MSC_VER) -# define typeof(x) __typeof__(x) +# define typeof __typeof__ # elif defined(__GNUC__) || defined(__clang__) -# define typeof(x) __typeof__(x) +# define typeof __typeof__ # else # error "Compiler not supported" # endif diff --git a/base/dependencies/memory.cpp b/base/dependencies/memory.cpp index 3d8ad2d..b38097a 100644 --- a/base/dependencies/memory.cpp +++ b/base/dependencies/memory.cpp @@ -346,25 +346,25 @@ void* arena_allocator_proc( void* allocator_data, AllocType type, ssize size, ss switch ( type ) { case EAllocation_ALLOC : + { + void* end = pointer_add( arena->PhysicalStart, arena->TotalUsed ); + ssize total_size = align_forward_s64( size, alignment ); + + // NOTE: Out of memory + if ( arena->TotalUsed + total_size > (ssize) arena->TotalSize ) { - void* end = pointer_add( arena->PhysicalStart, arena->TotalUsed ); - ssize total_size = align_forward_s64( size, alignment ); - - // NOTE: Out of memory - if ( arena->TotalUsed + total_size > (ssize) arena->TotalSize ) - { - // zpl__printf_err("%s", "Arena out of memory\n"); - GEN_FATAL("Arena out of memory! (Possibly could not fit for the largest size Arena!!)"); - return nullptr; - } - - ptr = align_forward( end, alignment ); - arena->TotalUsed += total_size; - - if ( flags & ALLOCATOR_FLAG_CLEAR_TO_ZERO ) - zero_size( ptr, size ); + // zpl__printf_err("%s", "Arena out of memory\n"); + GEN_FATAL("Arena out of memory! (Possibly could not fit for the largest size Arena!!)"); } - break; + + + ptr = align_forward( end, alignment ); + arena->TotalUsed += total_size; + + if ( flags & ALLOCATOR_FLAG_CLEAR_TO_ZERO ) + zero_size( ptr, size ); + } + break; case EAllocation_FREE : // NOTE: Free all at once diff --git a/base/dependencies/memory.hpp b/base/dependencies/memory.hpp index 9304b21..ff04129 100644 --- a/base/dependencies/memory.hpp +++ b/base/dependencies/memory.hpp @@ -225,11 +225,10 @@ forceinline ssize size_remaining(Arena& arena, ssize alignment) { return // This id is defined by Unreal for asserts #pragma push_macro("check") #undef check -forceinline void check(Arena& arena) { return arena_check(& arena); }; +forceinline void check(Arena& arena) { return arena_check(& arena); } #pragma pop_macro("check") #endif - inline AllocatorInfo arena_allocator_info( Arena* arena ) { GEN_ASSERT(arena != nullptr); @@ -392,9 +391,9 @@ void pool_clear(Pool* pool); void pool_free(Pool* pool); #if GEN_COMPILER_CPP && ! GEN_C_LIKE_CPP -AllocatorInfo allocator_info(Pool& pool) { return pool_allocator_info(& pool); } -void clear(Pool& pool) { return pool_clear(& pool); } -void free(Pool& pool) { return pool_free(& pool); } +forceinline AllocatorInfo allocator_info(Pool& pool) { return pool_allocator_info(& pool); } +forceinline void clear(Pool& pool) { return pool_clear(& pool); } +forceinline void free(Pool& pool) { return pool_free(& pool); } #endif struct Pool diff --git a/base/dependencies/strings.hpp b/base/dependencies/strings.hpp index 788a553..76b7ce1 100644 --- a/base/dependencies/strings.hpp +++ b/base/dependencies/strings.hpp @@ -40,9 +40,9 @@ struct Str #ifndef txt # if GEN_COMPILER_CPP -# define txt( text ) Str { ( text ), sizeof( text ) - 1 } +# define txt( text ) GEN_NS Str { ( text ), sizeof( text ) - 1 } # else -# define txt( text ) (Str){ ( text ), sizeof( text ) - 1 } +# define txt( text ) (GEN_NS Str){ ( text ), sizeof( text ) - 1 } # endif #endif @@ -392,6 +392,7 @@ bool strbuilder_append_string(StrBuilder* str, StrBuilder const other) { return strbuilder_append_c_str_len(str, (char const*)other, strbuilder_length(other)); } +inline bool strbuilder_append_fmt(StrBuilder* str, char const* fmt, ...) { GEN_ASSERT(str != nullptr); ssize res; diff --git a/base/enums/ECodeTypes.csv b/base/enums/ECodeTypes.csv index fe30838..d1ca2d6 100644 --- a/base/enums/ECodeTypes.csv +++ b/base/enums/ECodeTypes.csv @@ -37,6 +37,7 @@ Operator_Member_Fwd, "operator" Operator_Cast, "operator" Operator_Cast_Fwd, "operator" Parameters, "__NA__" +Parameters_Define, "__NA__" Preprocess_Define, "define" Preprocess_Include, "include" Preprocess_If, "if" diff --git a/base/enums/ETokType.csv b/base/enums/ETokType.csv index d3c28fe..5ce4c78 100644 --- a/base/enums/ETokType.csv +++ b/base/enums/ETokType.csv @@ -1,95 +1,98 @@ -Invalid, "__invalid__" -Access_Private, "private" -Access_Protected, "protected" -Access_Public, "public" -Access_MemberSymbol, "." -Access_StaticSymbol, "::" -Ampersand, "&" -Ampersand_DBL, "&&" -Assign_Classifer, ":" -Attribute_Open, "[[" -Attribute_Close, "]]" -BraceCurly_Open, "{" -BraceCurly_Close, "}" -BraceSquare_Open, "[" -BraceSquare_Close, "]" -Capture_Start, "(" -Capture_End, ")" -Comment, "__comment__" -Comment_End, "__comment_end__" -Comment_Start, "__comment_start__" -Char, "__character__" -Comma, "," -Decl_Class, "class" -Decl_GNU_Attribute, "__attribute__" -Decl_MSVC_Attribute, "__declspec" -Decl_Enum, "enum" -Decl_Extern_Linkage, "extern" -Decl_Friend, "friend" -Decl_Module, "module" -Decl_Namespace, "namespace" -Decl_Operator, "operator" -Decl_Struct, "struct" -Decl_Template, "template" -Decl_Typedef, "typedef" -Decl_Using, "using" -Decl_Union, "union" -Identifier, "__identifier__" -Module_Import, "import" -Module_Export, "export" -NewLine, "__new_line__" -Number, "__number__" -Operator, "__operator__" -Preprocess_Hash, "#" -Preprocess_Define, "define" -Preprocess_If, "if" -Preprocess_IfDef, "ifdef" -Preprocess_IfNotDef, "ifndef" -Preprocess_ElIf, "elif" -Preprocess_Else, "else" -Preprocess_EndIf, "endif" -Preprocess_Include, "include" -Preprocess_Pragma, "pragma" -Preprocess_Content, "__macro_content__" -Preprocess_Macro, "__macro__" -Preprocess_Unsupported, "__unsupported__" -Spec_Alignas, "alignas" -Spec_Const, "const" -Spec_Consteval, "consteval" -Spec_Constexpr, "constexpr" -Spec_Constinit, "constinit" -Spec_Explicit, "explicit" -Spec_Extern, "extern" -Spec_Final, "final" -Spec_ForceInline, "forceinline" -Spec_Global, "global" -Spec_Inline, "inline" -Spec_Internal_Linkage, "internal" -Spec_LocalPersist, "local_persist" -Spec_Mutable, "mutable" -Spec_NeverInline, "neverinline" -Spec_Override, "override" -Spec_Static, "static" -Spec_ThreadLocal, "thread_local" -Spec_Volatile, "volatile" -Spec_Virtual, "virtual" -Star, "*" -Statement_End, ";" -StaticAssert, "static_assert" -String, "__string__" -Type_Typename, "typename" -Type_Unsigned, "unsigned" -Type_Signed, "signed" -Type_Short, "short" -Type_Long, "long" -Type_bool, "bool" -Type_char, "char" -Type_int, "int" -Type_double, "double" -Type_MS_int8, "__int8" -Type_MS_int16, "__int16" -Type_MS_int32, "__int32" -Type_MS_int64, "__int64" -Type_MS_W64, "_W64" -Varadic_Argument, "..." -__Attributes_Start, "__attrib_start__" +Invalid, "__invalid__" +Access_Private, "private" +Access_Protected, "protected" +Access_Public, "public" +Access_MemberSymbol, "." +Access_StaticSymbol, "::" +Ampersand, "&" +Ampersand_DBL, "&&" +Assign_Classifer, ":" +Attribute_Open, "[[" +Attribute_Close, "]]" +BraceCurly_Open, "{" +BraceCurly_Close, "}" +BraceSquare_Open, "[" +BraceSquare_Close, "]" +Capture_Start, "(" +Capture_End, ")" +Comment, "__comment__" +Comment_End, "__comment_end__" +Comment_Start, "__comment_start__" +Char, "__character__" +Comma, "," +Decl_Class, "class" +Decl_GNU_Attribute, "__attribute__" +Decl_MSVC_Attribute, "__declspec" +Decl_Enum, "enum" +Decl_Extern_Linkage, "extern" +Decl_Friend, "friend" +Decl_Module, "module" +Decl_Namespace, "namespace" +Decl_Operator, "operator" +Decl_Struct, "struct" +Decl_Template, "template" +Decl_Typedef, "typedef" +Decl_Using, "using" +Decl_Union, "union" +Identifier, "__identifier__" +Module_Import, "import" +Module_Export, "export" +NewLine, "__new_line__" +Number, "__number__" +Operator, "__operator__" +Preprocess_Hash, "#" +Preprocess_Define, "define" +Preprocess_Define_Param, "__define_param__" +Preprocess_If, "if" +Preprocess_IfDef, "ifdef" +Preprocess_IfNotDef, "ifndef" +Preprocess_ElIf, "elif" +Preprocess_Else, "else" +Preprocess_EndIf, "endif" +Preprocess_Include, "include" +Preprocess_Pragma, "pragma" +Preprocess_Content, "__macro_content__" +Preprocess_Macro_Expr, "__macro_expression__" +Preprocess_Macro_Stmt, "__macro_statment__" +Preprocess_Macro_Typename, "__macro_typename__" +Preprocess_Unsupported, "__unsupported__" +Spec_Alignas, "alignas" +Spec_Const, "const" +Spec_Consteval, "consteval" +Spec_Constexpr, "constexpr" +Spec_Constinit, "constinit" +Spec_Explicit, "explicit" +Spec_Extern, "extern" +Spec_Final, "final" +Spec_ForceInline, "forceinline" +Spec_Global, "global" +Spec_Inline, "inline" +Spec_Internal_Linkage, "internal" +Spec_LocalPersist, "local_persist" +Spec_Mutable, "mutable" +Spec_NeverInline, "neverinline" +Spec_Override, "override" +Spec_Static, "static" +Spec_ThreadLocal, "thread_local" +Spec_Volatile, "volatile" +Spec_Virtual, "virtual" +Star, "*" +Statement_End, ";" +StaticAssert, "static_assert" +String, "__string__" +Type_Typename, "typename" +Type_Unsigned, "unsigned" +Type_Signed, "signed" +Type_Short, "short" +Type_Long, "long" +Type_bool, "bool" +Type_char, "char" +Type_int, "int" +Type_double, "double" +Type_MS_int8, "__int8" +Type_MS_int16, "__int16" +Type_MS_int32, "__int32" +Type_MS_int64, "__int64" +Type_MS_W64, "_W64" +Varadic_Argument, "..." +__Attributes_Start, "__attrib_start__" diff --git a/base/helpers/base_codegen.hpp b/base/helpers/base_codegen.hpp index 8b69c89..10d1765 100644 --- a/base/helpers/base_codegen.hpp +++ b/base/helpers/base_codegen.hpp @@ -47,7 +47,7 @@ CodeBody gen_ecode( char const* path, bool use_c_definition = false ) Str codetype_to_str( CodeType type ) { local_persist - Str lookup[] = { + Str lookup[] = { }; return lookup[ type ]; @@ -57,7 +57,7 @@ CodeBody gen_ecode( char const* path, bool use_c_definition = false ) Str codetype_to_keyword_str( CodeType type ) { local_persist - Str lookup[ ] = { + Str lookup[] = { }; return lookup[ type ]; @@ -139,7 +139,7 @@ CodeBody gen_eoperator( char const* path, bool use_c_definition = false ) Str operator_to_str( Operator op ) { local_persist - Str lookup[] = { + Str lookup[] = { }; @@ -237,7 +237,7 @@ CodeBody gen_especifier( char const* path, bool use_c_definition = false ) Str spec_to_str( Specifier type ) { local_persist - Str lookup[] = { + Str lookup[] = { }; @@ -283,7 +283,7 @@ CodeBody gen_especifier( char const* path, bool use_c_definition = false ) body_append(result, enum_code); if (use_c_definition) { - CodeTypedef specifier_t = parse_typedef( code(typedef u32 Specifier; )); + CodeTypedef specifier_t = parse_typedef( code(typedef enum Specifier Specifier; )); body_append(result, specifier_t); } @@ -353,7 +353,7 @@ CodeBody gen_etoktype( char const* etok_path, char const* attr_path, bool use_c_ #pragma push_macro("GEN_DEFINE_ATTRIBUTE_TOKENS") #undef GEN_DEFINE_ATTRIBUTE_TOKENS - CodeDefine attribute_entires_def = def_define( name(GEN_DEFINE_ATTRIBUTE_TOKENS), strbuilder_to_str(attribute_define_entries) ); + CodeDefine attribute_entires_def = def_define( name(GEN_DEFINE_ATTRIBUTE_TOKENS), MT_Statement, { {}, strbuilder_to_str(attribute_define_entries) } ); #pragma pop_macro("GEN_DEFINE_ATTRIBUTE_TOKENS") // We cannot parse this enum, it has Attribute names as enums @@ -499,59 +499,60 @@ CodeBody gen_ast_inlines() #pragma pop_macro("GEN_NS") #pragma pop_macro("CodeInvalid") - CodeBody impl_code = parse_global_body( token_fmt( "typename", Str name(Code), code_impl_tmpl )); - CodeBody impl_code_body = parse_global_body( token_fmt( "typename", Str name(CodeBody), code_impl_tmpl )); - CodeBody impl_code_attr = parse_global_body( token_fmt( "typename", Str name(CodeAttributes), code_impl_tmpl )); - CodeBody impl_code_cmt = parse_global_body( token_fmt( "typename", Str name(CodeComment), code_impl_tmpl )); - CodeBody impl_code_constr = parse_global_body( token_fmt( "typename", Str name(CodeConstructor), code_impl_tmpl )); - CodeBody impl_code_class = parse_global_body( token_fmt( "typename", Str name(CodeClass), code_impl_tmpl )); - CodeBody impl_code_define = parse_global_body( token_fmt( "typename", Str name(CodeDefine), code_impl_tmpl )); - CodeBody impl_code_destruct = parse_global_body( token_fmt( "typename", Str name(CodeDestructor), code_impl_tmpl )); - CodeBody impl_code_enum = parse_global_body( token_fmt( "typename", Str name(CodeEnum), code_impl_tmpl )); - CodeBody impl_code_exec = parse_global_body( token_fmt( "typename", Str name(CodeExec), code_impl_tmpl )); - CodeBody impl_code_extern = parse_global_body( token_fmt( "typename", Str name(CodeExtern), code_impl_tmpl )); - CodeBody impl_code_include = parse_global_body( token_fmt( "typename", Str name(CodeInclude), code_impl_tmpl )); - CodeBody impl_code_friend = parse_global_body( token_fmt( "typename", Str name(CodeFriend), code_impl_tmpl )); - CodeBody impl_code_fn = parse_global_body( token_fmt( "typename", Str name(CodeFn), code_impl_tmpl )); - CodeBody impl_code_module = parse_global_body( token_fmt( "typename", Str name(CodeModule), code_impl_tmpl )); - CodeBody impl_code_ns = parse_global_body( token_fmt( "typename", Str name(CodeNS), code_impl_tmpl )); - CodeBody impl_code_op = parse_global_body( token_fmt( "typename", Str name(CodeOperator), code_impl_tmpl )); - CodeBody impl_code_opcast = parse_global_body( token_fmt( "typename", Str name(CodeOpCast), code_impl_tmpl )); - CodeBody impl_code_params = parse_global_body( token_fmt( "typename", Str name(CodeParams), code_impl_tmpl )); - CodeBody impl_code_pragma = parse_global_body( token_fmt( "typename", Str name(CodePragma), code_impl_tmpl )); - CodeBody impl_code_precond = parse_global_body( token_fmt( "typename", Str name(CodePreprocessCond), code_impl_tmpl )); - CodeBody impl_code_specs = parse_global_body( token_fmt( "typename", Str name(CodeSpecifiers), code_impl_tmpl )); - CodeBody impl_code_struct = parse_global_body( token_fmt( "typename", Str name(CodeStruct), code_impl_tmpl )); - CodeBody impl_code_tmpl = parse_global_body( token_fmt( "typename", Str name(CodeTemplate), code_impl_tmpl )); - CodeBody impl_code_type = parse_global_body( token_fmt( "typename", Str name(CodeTypename), code_impl_tmpl )); - CodeBody impl_code_typedef = parse_global_body( token_fmt( "typename", Str name(CodeTypedef), code_impl_tmpl )); - CodeBody impl_code_union = parse_global_body( token_fmt( "typename", Str name(CodeUnion), code_impl_tmpl )); - CodeBody impl_code_using = parse_global_body( token_fmt( "typename", Str name(CodeUsing), code_impl_tmpl )); - CodeBody impl_code_var = parse_global_body( token_fmt( "typename", Str name(CodeVar), code_impl_tmpl )); + CodeBody impl_code = parse_global_body( token_fmt( "typename", name(Code), code_impl_tmpl )); + CodeBody impl_code_body = parse_global_body( token_fmt( "typename", name(CodeBody), code_impl_tmpl )); + CodeBody impl_code_attr = parse_global_body( token_fmt( "typename", name(CodeAttributes), code_impl_tmpl )); + CodeBody impl_code_cmt = parse_global_body( token_fmt( "typename", name(CodeComment), code_impl_tmpl )); + CodeBody impl_code_constr = parse_global_body( token_fmt( "typename", name(CodeConstructor), code_impl_tmpl )); + CodeBody impl_code_class = parse_global_body( token_fmt( "typename", name(CodeClass), code_impl_tmpl )); + CodeBody impl_code_define = parse_global_body( token_fmt( "typename", name(CodeDefine), code_impl_tmpl )); + CodeBody impl_code_define_params = parse_global_body( token_fmt( "typename", name(CodeDefineParams), code_impl_tmpl )); + CodeBody impl_code_destruct = parse_global_body( token_fmt( "typename", name(CodeDestructor), code_impl_tmpl )); + CodeBody impl_code_enum = parse_global_body( token_fmt( "typename", name(CodeEnum), code_impl_tmpl )); + CodeBody impl_code_exec = parse_global_body( token_fmt( "typename", name(CodeExec), code_impl_tmpl )); + CodeBody impl_code_extern = parse_global_body( token_fmt( "typename", name(CodeExtern), code_impl_tmpl )); + CodeBody impl_code_include = parse_global_body( token_fmt( "typename", name(CodeInclude), code_impl_tmpl )); + CodeBody impl_code_friend = parse_global_body( token_fmt( "typename", name(CodeFriend), code_impl_tmpl )); + CodeBody impl_code_fn = parse_global_body( token_fmt( "typename", name(CodeFn), code_impl_tmpl )); + CodeBody impl_code_module = parse_global_body( token_fmt( "typename", name(CodeModule), code_impl_tmpl )); + CodeBody impl_code_ns = parse_global_body( token_fmt( "typename", name(CodeNS), code_impl_tmpl )); + CodeBody impl_code_op = parse_global_body( token_fmt( "typename", name(CodeOperator), code_impl_tmpl )); + CodeBody impl_code_opcast = parse_global_body( token_fmt( "typename", name(CodeOpCast), code_impl_tmpl )); + CodeBody impl_code_params = parse_global_body( token_fmt( "typename", name(CodeParams), code_impl_tmpl )); + CodeBody impl_code_pragma = parse_global_body( token_fmt( "typename", name(CodePragma), code_impl_tmpl )); + CodeBody impl_code_precond = parse_global_body( token_fmt( "typename", name(CodePreprocessCond), code_impl_tmpl )); + CodeBody impl_code_specs = parse_global_body( token_fmt( "typename", name(CodeSpecifiers), code_impl_tmpl )); + CodeBody impl_code_struct = parse_global_body( token_fmt( "typename", name(CodeStruct), code_impl_tmpl )); + CodeBody impl_code_tmpl = parse_global_body( token_fmt( "typename", name(CodeTemplate), code_impl_tmpl )); + CodeBody impl_code_type = parse_global_body( token_fmt( "typename", name(CodeTypename), code_impl_tmpl )); + CodeBody impl_code_typedef = parse_global_body( token_fmt( "typename", name(CodeTypedef), code_impl_tmpl )); + CodeBody impl_code_union = parse_global_body( token_fmt( "typename", name(CodeUnion), code_impl_tmpl )); + CodeBody impl_code_using = parse_global_body( token_fmt( "typename", name(CodeUsing), code_impl_tmpl )); + CodeBody impl_code_var = parse_global_body( token_fmt( "typename", name(CodeVar), code_impl_tmpl )); - body_append(impl_code_attr, parse_global_body( token_fmt( "typename", Str name(Attributes), codetype_impl_tmpl ))); - body_append(impl_code_cmt, parse_global_body( token_fmt( "typename", Str name(Comment), codetype_impl_tmpl ))); - body_append(impl_code_constr, parse_global_body( token_fmt( "typename", Str name(Constructor), codetype_impl_tmpl ))); - body_append(impl_code_define, parse_global_body( token_fmt( "typename", Str name(Define), codetype_impl_tmpl ))); - body_append(impl_code_destruct, parse_global_body( token_fmt( "typename", Str name(Destructor), codetype_impl_tmpl ))); - body_append(impl_code_enum, parse_global_body( token_fmt( "typename", Str name(Enum), codetype_impl_tmpl ))); - body_append(impl_code_exec, parse_global_body( token_fmt( "typename", Str name(Exec), codetype_impl_tmpl ))); - body_append(impl_code_extern, parse_global_body( token_fmt( "typename", Str name(Extern), codetype_impl_tmpl ))); - body_append(impl_code_include, parse_global_body( token_fmt( "typename", Str name(Include), codetype_impl_tmpl ))); - body_append(impl_code_friend, parse_global_body( token_fmt( "typename", Str name(Friend), codetype_impl_tmpl ))); - body_append(impl_code_fn, parse_global_body( token_fmt( "typename", Str name(Fn), codetype_impl_tmpl ))); - body_append(impl_code_module, parse_global_body( token_fmt( "typename", Str name(Module), codetype_impl_tmpl ))); - body_append(impl_code_ns, parse_global_body( token_fmt( "typename", Str name(NS), codetype_impl_tmpl ))); - body_append(impl_code_op, parse_global_body( token_fmt( "typename", Str name(Operator), codetype_impl_tmpl ))); - body_append(impl_code_opcast, parse_global_body( token_fmt( "typename", Str name(OpCast), codetype_impl_tmpl ))); - body_append(impl_code_pragma, parse_global_body( token_fmt( "typename", Str name(Pragma), codetype_impl_tmpl ))); - body_append(impl_code_precond, parse_global_body( token_fmt( "typename", Str name(PreprocessCond), codetype_impl_tmpl ))); - body_append(impl_code_tmpl, parse_global_body( token_fmt( "typename", Str name(Template), codetype_impl_tmpl ))); - body_append(impl_code_type, parse_global_body( token_fmt( "typename", Str name(Typename), codetype_impl_tmpl ))); - body_append(impl_code_typedef, parse_global_body( token_fmt( "typename", Str name(Typedef), codetype_impl_tmpl ))); - body_append(impl_code_union, parse_global_body( token_fmt( "typename", Str name(Union), codetype_impl_tmpl ))); - body_append(impl_code_using, parse_global_body( token_fmt( "typename", Str name(Using), codetype_impl_tmpl ))); - body_append(impl_code_var, parse_global_body( token_fmt( "typename", Str name(Var), codetype_impl_tmpl ))); + body_append(impl_code_attr, parse_global_body( token_fmt( "typename", name(Attributes), codetype_impl_tmpl ))); + body_append(impl_code_cmt, parse_global_body( token_fmt( "typename", name(Comment), codetype_impl_tmpl ))); + body_append(impl_code_constr, parse_global_body( token_fmt( "typename", name(Constructor), codetype_impl_tmpl ))); + body_append(impl_code_define, parse_global_body( token_fmt( "typename", name(Define), codetype_impl_tmpl ))); + body_append(impl_code_destruct, parse_global_body( token_fmt( "typename", name(Destructor), codetype_impl_tmpl ))); + body_append(impl_code_enum, parse_global_body( token_fmt( "typename", name(Enum), codetype_impl_tmpl ))); + body_append(impl_code_exec, parse_global_body( token_fmt( "typename", name(Exec), codetype_impl_tmpl ))); + body_append(impl_code_extern, parse_global_body( token_fmt( "typename", name(Extern), codetype_impl_tmpl ))); + body_append(impl_code_include, parse_global_body( token_fmt( "typename", name(Include), codetype_impl_tmpl ))); + body_append(impl_code_friend, parse_global_body( token_fmt( "typename", name(Friend), codetype_impl_tmpl ))); + body_append(impl_code_fn, parse_global_body( token_fmt( "typename", name(Fn), codetype_impl_tmpl ))); + body_append(impl_code_module, parse_global_body( token_fmt( "typename", name(Module), codetype_impl_tmpl ))); + body_append(impl_code_ns, parse_global_body( token_fmt( "typename", name(NS), codetype_impl_tmpl ))); + body_append(impl_code_op, parse_global_body( token_fmt( "typename", name(Operator), codetype_impl_tmpl ))); + body_append(impl_code_opcast, parse_global_body( token_fmt( "typename", name(OpCast), codetype_impl_tmpl ))); + body_append(impl_code_pragma, parse_global_body( token_fmt( "typename", name(Pragma), codetype_impl_tmpl ))); + body_append(impl_code_precond, parse_global_body( token_fmt( "typename", name(PreprocessCond), codetype_impl_tmpl ))); + body_append(impl_code_tmpl, parse_global_body( token_fmt( "typename", name(Template), codetype_impl_tmpl ))); + body_append(impl_code_type, parse_global_body( token_fmt( "typename", name(Typename), codetype_impl_tmpl ))); + body_append(impl_code_typedef, parse_global_body( token_fmt( "typename", name(Typedef), codetype_impl_tmpl ))); + body_append(impl_code_union, parse_global_body( token_fmt( "typename", name(Union), codetype_impl_tmpl ))); + body_append(impl_code_using, parse_global_body( token_fmt( "typename", name(Using), codetype_impl_tmpl ))); + body_append(impl_code_var, parse_global_body( token_fmt( "typename", name(Var), codetype_impl_tmpl ))); #pragma push_macro("forceinline") #undef forceinline @@ -563,34 +564,35 @@ CodeBody gen_ast_inlines() ); #pragma pop_macro("forceinline") - CodeBody impl_cast_body = parse_global_body( token_fmt( "typename", Str name(Body), cast_tmpl )); - CodeBody impl_cast_attribute = parse_global_body( token_fmt( "typename", Str name(Attributes), cast_tmpl )); - CodeBody impl_cast_cmt = parse_global_body( token_fmt( "typename", Str name(Comment), cast_tmpl )); - CodeBody impl_cast_constr = parse_global_body( token_fmt( "typename", Str name(Constructor), cast_tmpl )); - CodeBody impl_cast_class = parse_global_body( token_fmt( "typename", Str name(Class), cast_tmpl )); - CodeBody impl_cast_define = parse_global_body( token_fmt( "typename", Str name(Define), cast_tmpl )); - CodeBody impl_cast_destruct = parse_global_body( token_fmt( "typename", Str name(Destructor), cast_tmpl )); - CodeBody impl_cast_enum = parse_global_body( token_fmt( "typename", Str name(Enum), cast_tmpl )); - CodeBody impl_cast_exec = parse_global_body( token_fmt( "typename", Str name(Exec), cast_tmpl )); - CodeBody impl_cast_extern = parse_global_body( token_fmt( "typename", Str name(Extern), cast_tmpl )); - CodeBody impl_cast_friend = parse_global_body( token_fmt( "typename", Str name(Friend), cast_tmpl )); - CodeBody impl_cast_fn = parse_global_body( token_fmt( "typename", Str name(Fn), cast_tmpl )); - CodeBody impl_cast_include = parse_global_body( token_fmt( "typename", Str name(Include), cast_tmpl )); - CodeBody impl_cast_module = parse_global_body( token_fmt( "typename", Str name(Module), cast_tmpl )); - CodeBody impl_cast_ns = parse_global_body( token_fmt( "typename", Str name(NS), cast_tmpl )); - CodeBody impl_cast_op = parse_global_body( token_fmt( "typename", Str name(Operator), cast_tmpl )); - CodeBody impl_cast_opcast = parse_global_body( token_fmt( "typename", Str name(OpCast), cast_tmpl )); - CodeBody impl_cast_params = parse_global_body( token_fmt( "typename", Str name(Params), cast_tmpl )); - CodeBody impl_cast_pragma = parse_global_body( token_fmt( "typename", Str name(Pragma), cast_tmpl )); - CodeBody impl_cast_precond = parse_global_body( token_fmt( "typename", Str name(PreprocessCond), cast_tmpl )); - CodeBody impl_cast_specs = parse_global_body( token_fmt( "typename", Str name(Specifiers), cast_tmpl )); - CodeBody impl_cast_struct = parse_global_body( token_fmt( "typename", Str name(Struct), cast_tmpl )); - CodeBody impl_cast_tmpl = parse_global_body( token_fmt( "typename", Str name(Template), cast_tmpl )); - CodeBody impl_cast_type = parse_global_body( token_fmt( "typename", Str name(Typename), cast_tmpl )); - CodeBody impl_cast_typedef = parse_global_body( token_fmt( "typename", Str name(Typedef), cast_tmpl )); - CodeBody impl_cast_union = parse_global_body( token_fmt( "typename", Str name(Union), cast_tmpl )); - CodeBody impl_cast_using = parse_global_body( token_fmt( "typename", Str name(Using), cast_tmpl )); - CodeBody impl_cast_var = parse_global_body( token_fmt( "typename", Str name(Var), cast_tmpl )); + CodeBody impl_cast_body = parse_global_body( token_fmt( "typename", name(Body), cast_tmpl )); + CodeBody impl_cast_attribute = parse_global_body( token_fmt( "typename", name(Attributes), cast_tmpl )); + CodeBody impl_cast_cmt = parse_global_body( token_fmt( "typename", name(Comment), cast_tmpl )); + CodeBody impl_cast_constr = parse_global_body( token_fmt( "typename", name(Constructor), cast_tmpl )); + CodeBody impl_cast_class = parse_global_body( token_fmt( "typename", name(Class), cast_tmpl )); + CodeBody impl_cast_define = parse_global_body( token_fmt( "typename", name(Define), cast_tmpl )); + CodeBody impl_cast_define_params = parse_global_body( token_fmt( "typename", name(DefineParams), cast_tmpl )); + CodeBody impl_cast_destruct = parse_global_body( token_fmt( "typename", name(Destructor), cast_tmpl )); + CodeBody impl_cast_enum = parse_global_body( token_fmt( "typename", name(Enum), cast_tmpl )); + CodeBody impl_cast_exec = parse_global_body( token_fmt( "typename", name(Exec), cast_tmpl )); + CodeBody impl_cast_extern = parse_global_body( token_fmt( "typename", name(Extern), cast_tmpl )); + CodeBody impl_cast_friend = parse_global_body( token_fmt( "typename", name(Friend), cast_tmpl )); + CodeBody impl_cast_fn = parse_global_body( token_fmt( "typename", name(Fn), cast_tmpl )); + CodeBody impl_cast_include = parse_global_body( token_fmt( "typename", name(Include), cast_tmpl )); + CodeBody impl_cast_module = parse_global_body( token_fmt( "typename", name(Module), cast_tmpl )); + CodeBody impl_cast_ns = parse_global_body( token_fmt( "typename", name(NS), cast_tmpl )); + CodeBody impl_cast_op = parse_global_body( token_fmt( "typename", name(Operator), cast_tmpl )); + CodeBody impl_cast_opcast = parse_global_body( token_fmt( "typename", name(OpCast), cast_tmpl )); + CodeBody impl_cast_params = parse_global_body( token_fmt( "typename", name(Params), cast_tmpl )); + CodeBody impl_cast_pragma = parse_global_body( token_fmt( "typename", name(Pragma), cast_tmpl )); + CodeBody impl_cast_precond = parse_global_body( token_fmt( "typename", name(PreprocessCond), cast_tmpl )); + CodeBody impl_cast_specs = parse_global_body( token_fmt( "typename", name(Specifiers), cast_tmpl )); + CodeBody impl_cast_struct = parse_global_body( token_fmt( "typename", name(Struct), cast_tmpl )); + CodeBody impl_cast_tmpl = parse_global_body( token_fmt( "typename", name(Template), cast_tmpl )); + CodeBody impl_cast_type = parse_global_body( token_fmt( "typename", name(Typename), cast_tmpl )); + CodeBody impl_cast_typedef = parse_global_body( token_fmt( "typename", name(Typedef), cast_tmpl )); + CodeBody impl_cast_union = parse_global_body( token_fmt( "typename", name(Union), cast_tmpl )); + CodeBody impl_cast_using = parse_global_body( token_fmt( "typename", name(Using), cast_tmpl )); + CodeBody impl_cast_var = parse_global_body( token_fmt( "typename", name(Var), cast_tmpl )); CodeBody result = def_global_body( args( def_pragma( txt("region generated code inline implementation")), @@ -602,6 +604,7 @@ CodeBody gen_ast_inlines() impl_code_constr, impl_code_class, impl_code_define, + impl_code_define_params, impl_code_destruct, impl_code_enum, impl_code_exec, @@ -636,6 +639,7 @@ CodeBody gen_ast_inlines() impl_cast_constr, impl_cast_class, impl_cast_define, + impl_cast_define_params, impl_cast_destruct, impl_cast_enum, impl_cast_exec, diff --git a/base/helpers/undef.macros.h b/base/helpers/undef.macros.h index e31d308..0bc7a48 100644 --- a/base/helpers/undef.macros.h +++ b/base/helpers/undef.macros.h @@ -41,7 +41,7 @@ #undef local_persist #undef bit -#undef bitfield_is_equal +#undef bitfield_is_set #undef cast diff --git a/gen_c_library/c_library.cpp b/gen_c_library/c_library.cpp index 8c7e2b3..275ddff 100644 --- a/gen_c_library/c_library.cpp +++ b/gen_c_library/c_library.cpp @@ -65,19 +65,123 @@ int gen_main() Context ctx {}; gen::init(& ctx); - ctx.PreprocessorDefines.append(txt("GEN_API_C_BEGIN")); - ctx.PreprocessorDefines.append(txt("GEN_API_C_END")); - ctx.PreprocessorDefines.append(txt("Array(")); - ctx.PreprocessorDefines.append(txt("HashTable(")); - ctx.PreprocessorDefines.append(txt("GEN_NS_PARSER")); - ctx.PreprocessorDefines.append(txt("GEN_NS_PARSER_BEGIN")); - ctx.PreprocessorDefines.append(txt("GEN_NS_PARSER_END")); - ctx.PreprocessorDefines.append(txt("Using_Code(")); - ctx.PreprocessorDefines.append(txt("Using_CodeOps(")); - ctx.PreprocessorDefines.append(txt("GEN_OPTIMIZE_MAPPINGS_BEGIN")); - ctx.PreprocessorDefines.append(txt("GEN_OPITMIZE_MAPPINGS_END")); - ctx.PreprocessorDefines.append(txt("GEN_PARAM_DEFAULT")); - //PreprocessorDefines.append(txt("GEN_EXECUTION_EXPRESSION_SUPPORT")); + register_macros( args( + (Macro { txt("bit"), MT_Expression, MF_Functional }), + (Macro { txt("bitfield_is_set"), MT_Expression, MF_Functional }), + (Macro { txt("GEN_C_LIKE_CPP"), MT_Expression, MF_Null }), + (Macro { txt("cast"), MT_Expression, MF_Functional }), + (Macro { txt("ccast"), MT_Expression, MF_Functional }), + (Macro { txt("rcast"), MT_Expression, MF_Functional }), + (Macro { txt("pcast"), MT_Expression, MF_Functional }), + (Macro { txt("scast"), MT_Expression, MF_Functional }), + (Macro { txt("stringize_va"), MT_Expression, MF_Functional }), + (Macro { txt("stringize"), MT_Expression, MF_Functional }), + (Macro { txt("do_once"), MT_Expression, MF_Functional }), + (Macro { txt("do_once_defer"), MT_Expression, MF_Functional }), + (Macro { txt("do_once_start"), MT_Statement, MF_Null }), + (Macro { txt("do_once_end"), MT_Statement, MF_Null }), + (Macro { txt("labeled_scope_start"), MT_Statement, MF_Null }), + (Macro { txt("labeled_scope_end"), MT_Statement, MF_Null }), + (Macro { txt("compiler_decorated_func_name"), MT_Expression, MF_Null }), + (Macro { txt("num_args_impl"), MT_Expression, MF_Functional }), + (Macro { txt("num_args"), MT_Expression, MF_Functional }), + (Macro { txt("count_of"), MT_Expression, MF_Functional }), + (Macro { txt("clamp"), MT_Expression, MF_Functional }), + (Macro { txt("is_between"), MT_Expression, MF_Functional }), + (Macro { txt("size_of"), MT_Expression, MF_Functional }), + (Macro { txt("min"), MT_Expression, MF_Functional }), + (Macro { txt("max"), MT_Expression, MF_Functional }), + (Macro { txt("offset_of"), MT_Expression, MF_Functional }), + (Macro { txt("static_assert"), MT_Statement, MF_Functional }), + (Macro { txt("typeof"), MT_Expression, MF_Null }), + (Macro { txt("GEN_API_C_BEGIN"), MT_Statement, MF_Null }), + (Macro { txt("GEN_API_C_END"), MT_Statement, MF_Null }), + (Macro { txt("nullptr"), MT_Expression, MF_Null }), + (Macro { txt("GEN_REMOVE_PTR"), MT_Expression, MF_Functional }), + (Macro { txt("GEN_PARAM_DEFAULT"), MT_Expression, MF_Null }), + (Macro { txt("struct_init"), MT_Expression, MF_Functional }), + (Macro { txt("GEN_OPTIMIZE_MAPPINGS_BEGIN"), MT_Statement, MF_Null }), + (Macro { txt("GEN_OPITMIZE_MAPPINGS_END"), MT_Statement, MF_Null }), + (Macro { txt("Array"), MT_Typename, MF_Functional }), + (Macro { txt("HashTable"), MT_Typename, MF_Functional }), + (Macro { txt("Using_Code"), MT_Statement, MF_Functional }), + (Macro { txt("Using_CodeOps"), MT_Statement, MF_Functional }), + (Macro { txt("kilobytes"), MT_Expression, MF_Functional }), + (Macro { txt("megabytes"), MT_Expression, MF_Functional }), + (Macro { txt("gigabytes"), MT_Expression, MF_Functional }), + (Macro { txt("terabytes"), MT_Expression, MF_Functional }), + (Macro { txt("GEN__ONES"), MT_Expression, MF_Null }), + (Macro { txt("GEN__HIGHS"), MT_Expression, MF_Null }), + (Macro { txt("GEN__HAS_ZERO"), MT_Expression, MF_Functional }), + (Macro { txt("zero_item"), MT_Expression, MF_Functional }), + (Macro { txt("zero_array"), MT_Expression, MF_Functional }), + (Macro { txt("GEN_DEFAULT_MEMORY_ALIGNMENT"), MT_Expression, MF_Null }), + (Macro { txt("GEN_DEFAULT_ALLOCATOR_FLAGS"), MT_Expression, MF_Null }), + (Macro { txt("alloc_item"), MT_Expression, MF_Functional }), + (Macro { txt("alloc_array"), MT_Expression, MF_Functional }), + (Macro { txt("malloc"), MT_Expression, MF_Functional }), + (Macro { txt("mfree"), MT_Expression, MF_Functional }), + (Macro { txt("GEN_PRINTF_MAXLEN"), MT_Expression, MF_Null }), + (Macro { txt("cast_to_str"), MT_Expression, MF_Functional }), + (Macro { txt("current"), MT_Expression, MF_Null }), + (Macro { txt("txt"), MT_Expression, MF_Functional }), + (Macro { txt("GEN_FILE_OPEN_PROC"), MT_Statement, MF_Functional | MF_Expects_Body }), + (Macro { txt("GEN_FILE_READ_AT_PROC"), MT_Statement, MF_Functional | MF_Expects_Body }), + (Macro { txt("GEN_FILE_WRITE_AT_PROC"), MT_Statement, MF_Functional | MF_Expects_Body }), + (Macro { txt("GEN_FILE_SEEK_PROC"), MT_Statement, MF_Functional | MF_Expects_Body }), + (Macro { txt("GEN_FILE_CLOSE_PROC"), MT_Statement, MF_Functional | MF_Expects_Body }), + (Macro { txt("log_failure"), MT_Expression, MF_Null }), + (Macro { txt("operator"), MT_Expression, MF_Null }), + (Macro { txt("InvalidCode"), MT_Expression, MF_Null }), + (Macro { txt("NullCode"), MT_Expression, MF_Null }), + (Macro { txt("Verify_POD"), MT_Expression, MF_Functional }), + (Macro { txt("gen_main"), MT_Statement, MF_Null }) + )); + register_macros( args( + (Macro { txt("name"), MT_Expression, MF_Functional }), + (Macro { txt("code"), MT_Expression, MF_Functional }), + (Macro { txt("args"), MT_Expression, MF_Functional }), + (Macro { txt("code_str"), MT_Expression, MF_Functional }), + (Macro { txt("code_fmt"), MT_Expression, MF_Functional }), + (Macro { txt("parse_fmt"), MT_Expression, MF_Functional }), + (Macro { txt("token_fmt"), MT_Expression, MF_Functional }), + (Macro { txt("check_member_val"), MT_Expression, MF_Functional }), + (Macro { txt("check_member_str"), MT_Expression, MF_Functional }), + (Macro { txt("check_member_content"), MT_Expression, MF_Functional }), + (Macro { txt("check_member_ast"), MT_Expression, MF_Functional }), + (Macro { txt("check_params"), MT_Expression, MF_Functional }), + (Macro { txt("check_param_eq_ret"), MT_Expression, MF_Functional }), + (Macro { txt("specs"), MT_Expression, MF_Functional | MF_Allow_As_Identifier }), + (Macro { txt("name_check"), MT_Expression, MF_Functional }), + (Macro { txt("null_check"), MT_Expression, MF_Functional }), + (Macro { txt("def_body_start"), MT_Expression, MF_Functional }), + (Macro { txt("def_body_code_array_start"), MT_Expression, MF_Functional }), + (Macro { txt("move_forward"), MT_Expression, MF_Functional }), + (Macro { txt("skip_whitespace"), MT_Expression, MF_Functional }), + (Macro { txt("end_line"), MT_Expression, MF_Functional }), + (Macro { txt("check_parse_args"), MT_Expression, MF_Functional }), + (Macro { txt("currtok_noskip"), MT_Expression, MF_Null }), + (Macro { txt("currtok"), MT_Expression, MF_Null }), + (Macro { txt("peektok"), MT_Expression, MF_Null }), + (Macro { txt("prevtok"), MT_Expression, MF_Null }), + (Macro { txt("nexttok"), MT_Expression, MF_Null }), + (Macro { txt("nexttok_noskip"), MT_Expression, MF_Null }), + (Macro { txt("eat"), MT_Expression, MF_Functional }), + (Macro { txt("left"), MT_Expression, MF_Null | MF_Allow_As_Identifier }), + (Macro { txt("def_assign"), MT_Expression, MF_Functional }), + (Macro { txt("CHECK_WAS_DEFINED"), MT_Expression, MF_Null }), + (Macro { txt("check_noskip"), MT_Expression, MF_Functional }), + (Macro { txt("check"), MT_Expression, MF_Functional | MF_Allow_As_Identifier }), + (Macro { txt("push_scope"), MT_Expression, MF_Functional }), + (Macro { txt("cut_length"), MT_Expression, MF_Null }), + (Macro { txt("cut_ptr"), MT_Expression, MF_Null }), + (Macro { txt("pos"), MT_Expression, MF_Null }), + (Macro { txt("move_fwd"), MT_Expression, MF_Functional }), + (Macro { txt("Entry"), MT_Expression, MF_Functional }), + (Macro { txt("CheckEndParams"), MT_Expression, MF_Functional }), + (Macro { txt("UseTemplateCapture"), MT_Expression, MF_Null }), + (Macro { txt("check_current"), MT_Expression, MF_Functional }) + )); Code push_ignores = scan_file( path_base "helpers/push_ignores.inline.hpp" ); Code pop_ignores = scan_file( path_base "helpers/pop_ignores.inline.hpp" ); @@ -139,8 +243,8 @@ int gen_main() CodeTemplate tmpl = cast(CodeTemplate, entry); if ( tmpl->Declaration->Name.contains(txt("swap"))) { - log_fmt("SWAPPED"); - CodeBody macro_swap = parse_global_body( txt(R"( + register_macro({ txt("swap"), MT_Expression, MF_Functional }); + CodeDefine macro_swap = parse_define( txt(R"( #define swap( a, b ) \ do \ { \ @@ -241,7 +345,8 @@ do \ { if ( str_contains(entry->Name, txt("Msg_Invalid_Value"))) { - CodeDefine define = def_define(entry->Name, entry->Value->Content); + Opts_def_define opts = { {}, entry->Value->Content }; + CodeDefine define = def_define(entry->Name, MT_Expression, opts ); header_printing.append(define); continue; } @@ -407,7 +512,8 @@ do \ CodeVar var = cast(CodeVar, entry); if (var->Specs.has(Spec_Constexpr) > -1) { - CodeDefine define = def_define(entry->Name, entry->Value->Content); + Opts_def_define opts = { {}, entry->Value->Content }; + CodeDefine define = def_define(entry->Name, MT_Expression, opts); header_filesystem.append(define); continue; } @@ -811,7 +917,8 @@ R"(#define AST_ArrSpecs_Cap \ ast.append(def); break; } - CodeDefine def = def_define(var->Name, var->Value.to_strbuilder()); + Opts_def_define opts = { {}, var->Value.to_strbuilder() }; + CodeDefine def = def_define(var->Name, MT_Expression, opts ); ast.append(def); break; } @@ -832,6 +939,7 @@ R"(#define AST_ArrSpecs_Cap \ txt("CodeClass"), txt("CodeConstructor"), txt("CodeDefine"), + txt("CodeDefineParams"), txt("CodeDestructor"), txt("CodeEnum"), txt("CodeExec"), @@ -1005,8 +1113,9 @@ R"(#define ( code ) _Generic( (code), \ break; } - CodeBody array_arena = gen_array(txt("gen_Arena"), txt("Array_gen_Arena")); - CodeBody array_pool = gen_array(txt("gen_Pool"), txt("Array_gen_Pool")); + CodeBody array_arena = gen_array(txt("gen_Arena"), txt("Array_gen_Arena")); + CodeBody array_pool = gen_array(txt("gen_Pool"), txt("Array_gen_Pool")); + CodeBody ht_preprocessor_macro = gen_hashtable(txt("gen_Macro"), txt("MacroTable")); CodeBody parsed_interface = parse_file( path_base "components/interface.hpp" ); CodeBody interface = def_body(CT_Global_Body); @@ -1209,8 +1318,10 @@ R"(#define ( code ) _Generic( (code), \ if (var->Specs) { s32 constexpr_found = var->Specs.remove( Spec_Constexpr ); - if (constexpr_found > -1) { - CodeDefine define = def_define(entry->Name, entry->Value->Content); + if (constexpr_found > -1) + { + Opts_def_define opts = { {}, entry->Value->Content }; + CodeDefine define = def_define(entry->Name, MT_Expression, opts ); header_end.append(define); continue; } @@ -1244,11 +1355,37 @@ R"(#define ( code ) _Generic( (code), \ Code src_static_data = scan_file( path_base "components/static_data.cpp" ); Code src_ast_case_macros = scan_file( path_base "components/ast_case_macros.cpp" ); Code src_code_serialization = scan_file( path_base "components/code_serialization.cpp" ); - Code src_interface = scan_file( path_base "components/interface.cpp" ); + Code src_parsing_interface = scan_file( path_base "components/interface.parsing.cpp" ); Code src_untyped = scan_file( path_base "components/interface.untyped.cpp" ); Code src_parser_case_macros = scan_file( path_base "components/parser_case_macros.cpp" ); + CodeBody parsed_src_interface = parse_file( path_base "components/interface.cpp" ); + CodeBody src_interface = def_body(CT_Global_Body); + for ( Code entry = parsed_src_interface.begin(); entry != parsed_src_interface.end(); ++ entry ) switch( entry ->Type ) + { + case CT_Function: + { + CodeFn fn = cast(CodeFn, entry); + Code prev = entry->Prev; + for ( CodeParams arr_param : fn->Params ) + { + b32 repeat_register_macros = fn->Name.is_equal(txt("register_macros")) && arr_param->Name.is_equal(txt("num")) && ! arr_param->Next->Name.is_equal(txt("...")); + if ( repeat_register_macros ) { + // rename second definition so there isn't a symbol conflict + StrBuilder postfix_arr = StrBuilder::fmt_buf(_ctx->Allocator_Temp, "%S_arr", fn->Name); + fn->Name = cache_str(postfix_arr.to_str()); + } + } + src_interface.append(fn); + } + break; + + default: + src_interface.append(entry); + break; + } + CodeBody parsed_src_ast = parse_file( path_base "components/ast.cpp" ); CodeBody src_ast = def_body(CT_Global_Body); for ( Code entry = parsed_src_ast.begin(); entry != parsed_src_ast.end(); ++ entry ) switch( entry ->Type ) @@ -1308,26 +1445,22 @@ R"(#define ( code ) _Generic( (code), \ Code prev = entry->Prev; for ( CodeParams arr_param : fn->Params ) - if ( fn->Name.starts_with(txt("def_")) - && ( (arr_param->ValueType->Name.starts_with(txt("Specifier")) && fn->Params->NumEntries > 1) - || arr_param->ValueType->Name.starts_with(txt("Code")) ) - ) - { + { + b32 repeat_def_array = fn->Name.starts_with(txt("def_")) && arr_param->Name.is_equal(txt("num")) && ! arr_param->Next->Name.is_equal(txt("...")); + if ( repeat_def_array ) { // rename second definition so there isn't a symbol conflict StrBuilder postfix_arr = StrBuilder::fmt_buf(_ctx->Allocator_Temp, "%S_arr", fn->Name); fn->Name = cache_str(postfix_arr.to_str()); - postfix_arr.free(); } - + } for ( CodeParams opt_param : fn->Params ) if (opt_param->ValueType->Name.starts_with(txt("Opts_"))) { + // The frontend names are warapped in macros so we need to give it the intenral symbol name Str prefix = txt("def_"); Str actual_name = { fn->Name.Ptr + prefix.Len, fn->Name.Len - prefix.Len }; Str new_name = StrBuilder::fmt_buf(_ctx->Allocator_Temp, "def__%S", actual_name ).to_str(); - fn->Name = cache_str(new_name); } - src_upfront.append(fn); } break; @@ -1478,10 +1611,11 @@ R"(#define ( code ) _Generic( (code), \ Code rf_interface = refactor_and_format(interface); Code rf_inlines = refactor_and_format(inlines); - 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 "auxillary/scanner.hpp" )); + 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 "auxillary/scanner.hpp" )); Code r_src_dep_start = refactor(src_dep_start); Code r_src_debug = refactor(src_debug); @@ -1503,7 +1637,7 @@ R"(#define ( code ) _Generic( (code), \ Code r_src_code_serialization = refactor(src_code_serialization); Code r_src_parser_case_macros = refactor(src_parser_case_macros); - Code r_src_interface = refactor(src_interface); + Code r_src_interface = refactor_and_format(src_interface); Code r_src_upfront = refactor_and_format(src_upfront); Code r_src_lexer = refactor_and_format(src_lexer); Code rf_array_code_typename = refactor_and_format(array_code_typename); @@ -1586,6 +1720,8 @@ R"(#define ( code ) _Generic( (code), \ 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(fmt_newline); diff --git a/gen_c_library/c_library.refactor b/gen_c_library/c_library.refactor index 1c98342..1dc2e85 100644 --- a/gen_c_library/c_library.refactor +++ b/gen_c_library/c_library.refactor @@ -21,7 +21,7 @@ word global, gen_global word internal, gen_internal word local_persist, gen_local_persist word bit, gen_bit -word bitfield_is_equal, gen_bitfield_is_equal +word bitfield_is_set, gen_bitfield_is_set word cast, gen_cast word ccast, gen_ccast word pcast, gen_pcast @@ -310,6 +310,14 @@ word spec_to_str, gen_spec_to_str word spec_is_trailing, gen_spec_is_trailing // word str_to_specifier, gen_str_to_specifier +word MacroType, gen_MacroType +word EMacroFlags, gen_EMacroFlags +word MacroFlags, gen_MacroFlags +word Macro, gen_Macro + +namespace macro_, gen_macro_ +namespace macrotype, gen_macrotype_ + // AST word AST, gen_AST @@ -325,6 +333,7 @@ word CodeComment, gen_CodeComment word CodeClass, gen_CodeClass word CodeConstructor, gen_CodeConstructor word CodeDefine, gen_CodeDefine +word CodeDefineParams, gen_CodeDefineParams word CodeDestructor, gen_CodeDestructor word CodeEnum, gen_CodeEnum word CodeExec, gen_CodeExec diff --git a/gen_c_library/components/containers.array.hpp b/gen_c_library/components/containers.array.hpp index 2317375..e2fd8b3 100644 --- a/gen_c_library/components/containers.array.hpp +++ b/gen_c_library/components/containers.array.hpp @@ -22,9 +22,9 @@ CodeBody gen_array_base() Code get_header = untyped_str( txt( "#define array_get_header( self ) ( (ArrayHeader*)( self ) - 1)\n" )); Code type_define = untyped_str( txt( "#define Array(Type) gen_Array_##Type\n")); - Code array_begin = def_define(txt("array_begin(array)"), code( (array) )); - Code array_end = def_define(txt("array_end(array)"), code( (array + array_get_header(array)->Num ) )); - Code array_next = def_define(txt("array_next(array, entry)"), code( (entry + 1) )); + Code array_begin = def_define(txt("array_begin(array)"), MT_Expression, { {}, code( (array) ) } ); + Code array_end = def_define(txt("array_end(array)"), MT_Expression, { {}, code( (array + array_get_header(array)->Num ) ) } ); + Code array_next = def_define(txt("array_next(array, entry)"), MT_Expression, { {}, code( (entry + 1) ) } ); return def_global_body( args( fmt_newline, diff --git a/gen_c_library/components/containers.hashtable.hpp b/gen_c_library/components/containers.hashtable.hpp index 000a995..8303eb7 100644 --- a/gen_c_library/components/containers.hashtable.hpp +++ b/gen_c_library/components/containers.hashtable.hpp @@ -19,7 +19,7 @@ CodeBody gen_hashtable_base() )); Code define_type = untyped_str(txt( -R"(#define HashTable(_type) struct _type +R"(#define HashTable(_type) struct gen_HashTable_##_type )" )); diff --git a/gen_c_library/components/memory.fixed_arena.hpp b/gen_c_library/components/memory.fixed_arena.hpp index 262f06d..f61b720 100644 --- a/gen_c_library/components/memory.fixed_arena.hpp +++ b/gen_c_library/components/memory.fixed_arena.hpp @@ -89,7 +89,14 @@ CodeBody gen_fixed_arenas() result.append(arena_interface_2mb); result.append(arena_interface_4mb); - CodeDefine def = def_define(txt("fixed_arena_allocator_info(fixed_arena)"), txt("( (AllocatorInfo) { arena_allocator_proc, & (fixed_arena)->arena } )")); + register_macros( args( + ( Macro { txt("fixed_arena_allocator_info"), MT_Expression, MF_Functional }), + ( Macro { txt("fixed_arena_init"), MT_Expression, MF_Functional }), + ( Macro { txt("fixed_arena_free"), MT_Expression, MF_Functional }), + ( Macro { txt("fixed_arena_size_remaining"), MT_Expression, MF_Functional }) + )); + + CodeDefine def = parse_define(txt("#define fixed_arena_allocator_info(fixed_arena) ( (AllocatorInfo) { arena_allocator_proc, & (fixed_arena)->arena } )\n")); result.append(def); result.append(fmt_newline); diff --git a/gen_c_library/components/misc.hpp b/gen_c_library/components/misc.hpp index bd06189..b288663 100644 --- a/gen_c_library/components/misc.hpp +++ b/gen_c_library/components/misc.hpp @@ -7,12 +7,13 @@ void convert_cpp_enum_to_c( CodeEnum to_convert, CodeBody to_append ) { #pragma push_macro("enum_underlying") #undef enum_underlying + StrCached type = to_convert->UnderlyingType ? to_convert->UnderlyingType.to_strbuilder().to_str() : to_convert->Name; + CodeTypedef tdef = parse_typedef(token_fmt("type", type, "name", to_convert->Name, stringize( typedef enum ; ))); if (to_convert->UnderlyingType) { to_convert->UnderlyingTypeMacro = untyped_str(token_fmt("type", to_convert->UnderlyingType->Name, stringize(enum_underlying()))); to_convert->UnderlyingType = CodeTypename{nullptr}; } - CodeTypedef tdef = parse_typedef(token_fmt("name", to_convert->Name, stringize( typedef enum ; ))); to_append.append(to_convert); to_append.append(tdef); #pragma pop_macro("enum_underlying") diff --git a/gen_unreal_engine/components/parser_case_macros.cpp b/gen_unreal_engine/components/parser_case_macros.cpp index e0b48af..4d71614 100644 --- a/gen_unreal_engine/components/parser_case_macros.cpp +++ b/gen_unreal_engine/components/parser_case_macros.cpp @@ -27,7 +27,7 @@ case Spec_Static: \ case Spec_Volatile: \ case Spec_Virtual -#define GEN_PARSER_CLASS_GLOBAL_NSPACE_ALLOWED_MEMBER_TOK_SPECIFIERS_CASES \ +#define GEN_PARSER_CLASS_GLOBAL_NSPACE_ALLOWED_MEMBER_TOK_SPECIFIER_CASES \ case Tok_Spec_Consteval: \ case Tok_Spec_Constexpr: \ case Tok_Spec_Constinit: \ @@ -40,7 +40,7 @@ case Tok_Spec_Internal_Linkage: \ case Tok_Spec_NeverInline: \ case Tok_Spec_Static -#define GEN_PARSER_CLASS_GLOBAL_NSPACE_ALLOWED_MEMBER_SPECIFIERS_CASES \ +#define GEN_PARSER_CLASS_GLOBAL_NSPACE_ALLOWED_MEMBER_SPECIFIER_CASES \ case Spec_Constexpr: \ case Spec_Constinit: \ case Spec_ForceInline: \ diff --git a/gen_unreal_engine/enums/AttributeTokens.csv b/gen_unreal_engine/enums/AttributeTokens.csv index 49f51a4..4ac524b 100644 --- a/gen_unreal_engine/enums/AttributeTokens.csv +++ b/gen_unreal_engine/enums/AttributeTokens.csv @@ -4,4 +4,3 @@ COREUOBJECT_API, COREUOBJECT_API ENGINE_API, ENGINE_API GAMEPLAYABILITIES_API, GAMEPLAYABILITIES_API UMG_API, UMG_API -UE_DEPRECATED, UE_DEPRECATED diff --git a/gen_unreal_engine/enums/ETokType.csv b/gen_unreal_engine/enums/ETokType.csv index d57ad95..cd8b917 100644 --- a/gen_unreal_engine/enums/ETokType.csv +++ b/gen_unreal_engine/enums/ETokType.csv @@ -42,6 +42,7 @@ Number, "__number__" Operator, "__operator__" Preprocess_Hash, "#" Preprocess_Define, "define" +Preprocess_Define_Param, "__define_param__" Preprocess_If, "if" Preprocess_IfDef, "ifdef" Preprocess_IfNotDef, "ifndef" @@ -51,7 +52,9 @@ Preprocess_EndIf, "endif" Preprocess_Include, "include" Preprocess_Pragma, "pragma" Preprocess_Content, "__macro_content__" -Preprocess_Macro, "__macro__" +Preprocess_Macro_Expr, "__macro_expression__" +Preprocess_Macro_Stmt, "__macro_statment__" +Preprocess_Macro_Typename, "__macro_typename__" Preprocess_Unsupported, "__unsupported__" Spec_Alignas, "alignas" Spec_Const, "const" diff --git a/gen_unreal_engine/unreal.cpp b/gen_unreal_engine/unreal.cpp index 9640340..2afa5ae 100644 --- a/gen_unreal_engine/unreal.cpp +++ b/gen_unreal_engine/unreal.cpp @@ -64,6 +64,45 @@ int gen_main() Code ue_forceinline = code_str(FORCEINLINE); // Code + register_macros( args( + (Macro { txt("bit"), MT_Expression, MF_Functional }), + (Macro { txt("bitfield_is_set"), MT_Expression, MF_Functional }), + (Macro { txt("GEN_C_LIKE_CPP"), MT_Expression, MF_Null }), + (Macro { txt("cast"), MT_Expression, MF_Functional }), + (Macro { txt("ccast"), MT_Expression, MF_Functional }), + (Macro { txt("rcast"), MT_Expression, MF_Functional }), + (Macro { txt("pcast"), MT_Expression, MF_Functional }), + (Macro { txt("scast"), MT_Expression, MF_Functional }), + (Macro { txt("stringize_va"), MT_Expression, MF_Functional }), + (Macro { txt("stringize"), MT_Expression, MF_Functional }), + (Macro { txt("do_once"), MT_Expression, MF_Functional }), + (Macro { txt("do_once_defer"), MT_Expression, MF_Functional }), + (Macro { txt("do_once_start"), MT_Statement, MF_Null }), + (Macro { txt("do_once_end"), MT_Statement, MF_Null }), + (Macro { txt("labeled_scope_start"), MT_Statement, MF_Null }), + (Macro { txt("labeled_scope_end"), MT_Statement, MF_Null }), + (Macro { txt("compiler_decorated_func_name"), MT_Expression, MF_Null }), + (Macro { txt("num_args_impl"), MT_Expression, MF_Functional }), + (Macro { txt("num_args"), MT_Expression, MF_Functional }), + (Macro { txt("count_of"), MT_Expression, MF_Functional }), + (Macro { txt("clamp"), MT_Expression, MF_Functional }), + (Macro { txt("is_between"), MT_Expression, MF_Functional }), + (Macro { txt("size_of"), MT_Expression, MF_Functional }), + (Macro { txt("min"), MT_Expression, MF_Functional }), + (Macro { txt("max"), MT_Expression, MF_Functional }), + (Macro { txt("offset_of"), MT_Expression, MF_Functional }), + (Macro { txt("static_assert"), MT_Statement, MF_Functional }), + (Macro { txt("typeof"), MT_Expression, MF_Null }), + (Macro { txt("GEN_API_C_BEGIN"), MT_Statement, MF_Null }), + (Macro { txt("GEN_API_C_END"), MT_Statement, MF_Null }), + (Macro { txt("nullptr"), MT_Expression, MF_Null }), + (Macro { txt("GEN_REMOVE_PTR"), MT_Expression, MF_Functional }), + (Macro { txt("GEN_PARAM_DEFAULT"), MT_Expression, MF_Null }), + (Macro { txt("struct_init"), MT_Expression, MF_Functional }), + (Macro { txt("GEN_OPTIMIZE_MAPPINGS_BEGIN"), MT_Statement, MF_Null }), + (Macro { txt("GEN_OPITMIZE_MAPPINGS_END"), MT_Statement, MF_Null }) + )); + // gen_dep.hpp { CodeBody macros = def_body( CT_Global_Body ); @@ -108,6 +147,7 @@ int gen_main() Code strings = scan_file( path_base "dependencies/strings.hpp" ); Code filesystem = scan_file( path_base "dependencies/filesystem.hpp" ); Code timing = scan_file( path_base "dependencies/timing.hpp" ); + Code parsing = scan_file( path_base "dependencies/parsing.hpp" ); Builder header = Builder::open("gen/gen.dep.hpp"); @@ -129,6 +169,7 @@ int gen_main() header.print( strings ); header.print( filesystem ); header.print( timing ); + header.print(parsing); header.print_fmt( "\nGEN_NS_END\n" ); header.print( fmt_newline ); @@ -147,6 +188,7 @@ int gen_main() Code strings = scan_file( path_base "dependencies/strings.cpp" ); Code filesystem = scan_file( path_base "dependencies/filesystem.cpp" ); Code timing = scan_file( path_base "dependencies/timing.cpp" ); + Code parsing = scan_file( path_base "dependencies/parsing.cpp" ); Builder src = Builder::open( "gen/gen.dep.cpp" ); @@ -165,6 +207,7 @@ int gen_main() src.print( strings ); src.print( filesystem ); src.print( timing ); + src.print( parsing ); src.print_fmt( "\nGEN_NS_END\n" ); src.print( fmt_newline ); @@ -271,14 +314,20 @@ int gen_main() src.print_fmt( "\n#pragma region Interface\n" ); src.print( interface ); + src.print( upfront ); + src.print_fmt( "\n#pragma region Parsing\n\n" ); src.print( lexer ); src.print( parser_case_macros ); src.print( parser ); src.print( parsing_interface ); - src.print( untyped ); src.print_fmt( "\n#pragma endregion Parsing\n\n" ); + + src.print_fmt( "\n#pragma region Untyped\n\n" ); + src.print( untyped ); + src.print_fmt( "#pragma endregion \n\n" ); + src.print_fmt( "#pragma endregion Interface\n\n" ); src.print_fmt( "GEN_NS_END\n\n"); @@ -325,7 +374,6 @@ int gen_main() // gen_scanner.hpp { - Code parsing = scan_file( path_base "dependencies/parsing.hpp" ); Code scanner = scan_file( path_base "auxillary/scanner.hpp" ); Builder @@ -336,7 +384,6 @@ int gen_main() header.print( fmt_newline ); header.print( def_include( txt("gen.hpp") ) ); header.print_fmt( "\nGEN_NS_BEGIN\n" ); - header.print( parsing ); header.print( scanner ); header.print_fmt( "\nGEN_NS_END\n" ); header.print( fmt_newline ); @@ -346,7 +393,6 @@ int gen_main() // gen.scanner.cpp { - Code parsing = scan_file( path_base "dependencies/parsing.cpp" ); Code scanner = scan_file( path_base "auxillary/scanner.cpp" ); Builder @@ -356,8 +402,7 @@ int gen_main() src.print( fmt_newline ); src.print( def_include( txt("gen.scanner.hpp") ) ); src.print_fmt( "\nGEN_NS_BEGIN\n" ); - src.print( parsing ); - // src.print( scanner ); + src.print( scanner ); src.print_fmt( "\nGEN_NS_END\n" ); src.print( fmt_newline ); src.print( pop_ignores );