String::is_equal added (bad last commit)

gen_c_library/c_library.cpp

@@ -90,6 +90,7 @@ CodeBody parse_file( const char* path )
 {
 	FileContents file = file_read_contents( GlobalAllocator, true, path );
 	CodeBody     code = parse_global_body( { file.size, (char const*)file.data } );
+	log_fmt("\nParsed: %s\n", path);
 	return code;
 }
 
@@ -126,7 +127,7 @@ int gen_main()
 		header.print( debug );
 
 		CodeBody parsed_memory = parse_file( project_dir "dependencies/memory.hpp" );
-		CodeBody memory        = def_body(ECode::Struct_Body);
+		CodeBody memory        = def_body(ECode::Global_Body);
 		for ( Code entry = parsed_memory.begin(); entry != parsed_memory.end(); ++ entry )
 		{
 			switch (entry->Type)
@@ -145,12 +146,31 @@ int gen_main()
 					CodeFn fn = entry.cast<CodeFn>();
 					s32 constexpr_found = fn->Specs.remove( ESpecifier::Constexpr );
 					if (constexpr_found > -1) {
-						log_fmt("Found constexpr proc\n");
+						log_fmt("Found constexpr: %S\n", entry->to_string());
 						fn->Specs.append(ESpecifier::Inline);
 					}
 					memory.append(entry);
 				}
 				break;
+				case ECode::Template:
+				{
+					CodeTemplate tmpl = entry.cast<CodeTemplate>();
+					if ( tmpl->Declaration->Name.contains(txt("swap")))
+					{
+						CodeBody macro_swap = parse_global_body( txt(R"(
+#define swap( a, b )              \
+	do                            \
+	{                             \
+		typeof( a ) temp = ( a ); \
+		( a )            = ( b ); \
+		( b )            = temp;  \
+	} while ( 0 )
+)"
+						));
+						memory.append(macro_swap);
+					}
+				}
+				break;
 				case ECode::Class:
 				case ECode::Struct:
 				{
@@ -175,17 +195,26 @@ int gen_main()
 				break;
 				case ECode::Preprocess_If:
 				{
-					ignore_preprocess_cond_block(txt("GEN_SUPPORT_CPP_MEMBER_FEATURES"), entry, parsed_memory );
+					b32 found = ignore_preprocess_cond_block(txt("GEN_SUPPORT_CPP_MEMBER_FEATURES"), entry, parsed_memory );
+					if (found) break;
+
+					memory.append(entry);
 				}
 				break;
 				case ECode::Preprocess_IfDef:
 				{
-					ignore_preprocess_cond_block(txt("GEN_INTELLISENSE_DIRECTIVES"), entry, parsed_memory );
+					b32 found = ignore_preprocess_cond_block(txt("GEN_INTELLISENSE_DIRECTIVES"), entry, parsed_memory );
+					if (found) break;
+
+					memory.append(entry);
 				}
 				break;
 				case ECode::Preprocess_Pragma:
 				{
-					swap_pragma_region_implementation( txt("FixedArena"), gen_fixed_arenas, entry, memory);
+					b32 found = swap_pragma_region_implementation( txt("FixedArena"), gen_fixed_arenas, entry, memory);
+					if (found) break;
+
+					memory.append(entry);
 				}
 				break;
 				default: {
@@ -194,26 +223,28 @@ int gen_main()
 				break;
 			}
 		}
-
-		header.print( memory );
+		header.print( dump_to_scratch_and_retireve(memory) );
 
 		Code string_ops = scan_file( project_dir "dependencies/string_ops.hpp" );
 		header.print( string_ops );
 
 		CodeBody printing_parsed = parse_file( project_dir "dependencies/printing.hpp" );
-		CodeBody printing        = def_body(ECode::Struct_Body);
+		CodeBody printing        = def_body(ECode::Global_Body);
 		for ( Code entry = printing_parsed.begin(); entry != printing_parsed.end(); ++ entry )
 		{
 			switch (entry->Type)
 			{
 				case ECode::Preprocess_IfDef:
 				{
-					ignore_preprocess_cond_block(txt("GEN_INTELLISENSE_DIRECTIVES"), entry, printing_parsed );
-				}
-			}
+					b32 found = ignore_preprocess_cond_block(txt("GEN_INTELLISENSE_DIRECTIVES"), entry, printing_parsed );
+					if (found) break;
 
-			if (entry->Type == ECode::Variable &&
-				contains(entry->Name, txt("Msg_Invalid_Value")))
+					printing.append(entry);
+				}
+				break;
+				case ECode::Variable:
+				{
+					if (contains(entry->Name, txt("Msg_Invalid_Value")))
 					{
 						CodeDefine define = def_define(entry->Name, entry->Value->Content);
 						printing.append(define);
@@ -221,38 +252,105 @@ int gen_main()
 					}
 					printing.append(entry);
 				}
-
-		header.print(printing);
-
-		CodeBody parsed_containers = parse_file( project_dir "dependencies/containers.hpp" );
-		CodeBody containers        = def_body(ECode::Struct_Body);
-		for ( Code entry = parsed_containers.begin(); entry != parsed_containers.end(); ++ entry )
-		{
-			switch ( entry->Type )
-			{
-				case ECode::Preprocess_Pragma:
-				{
-					bool found = false;
-
-					found = swap_pragma_region_implementation( txt("Array"), gen_array_base, entry, containers);
-					if (found) break;
-
-					found = swap_pragma_region_implementation( txt("Hashtable"), gen_hashtable_base, entry, containers);
-					if (found) break;
-
-					containers.append(entry);
-				}
+				break;
+				default:
+					printing.append(entry);
 				break;
 			}
 		}
+		header.print(dump_to_scratch_and_retireve(printing));
 
-		header.print(containers);
+		CodeBody containers = def_body(ECode::Global_Body);
+		{
+			containers.append( def_pragma(code(region Containers)));
+
+			containers.append( gen_array_base() );
+			containers.append( gen_hashtable_base() );
+
+			containers.append( def_pragma(code(endregion Containers)));
+		}
+		header.print(fmt_newline);
+		header.print(dump_to_scratch_and_retireve(containers));
+
+		Code hashing = scan_file( project_dir "dependencies/hashing.hpp" );
+		header.print( hashing );
+
+		CodeBody parsed_strings = parse_file( project_dir "dependencies/strings.hpp" );
+		CodeBody strings        = def_body(ECode::Global_Body);
+		for ( Code entry = parsed_strings.begin(); entry != parsed_strings.end(); ++ entry )
+		{
+			switch (entry->Type)
+			{
+				case ECode::Preprocess_If:
+				{
+					ignore_preprocess_cond_block(txt("! GEN_COMPILER_C"), entry, parsed_strings);
+				}
+				break;
+
+				case ECode::Preprocess_IfDef:
+				{
+					ignore_preprocess_cond_block(txt("GEN_INTELLISENSE_DIRECTIVES"), entry, parsed_strings );
+				}
+				break;
+
+				case ECode::Struct_Fwd:
+				{
+					if ( entry->Name.is_equal(txt("String")) )
+					{
+						CodeTypedef c_def = parse_typedef(code( typedef Type* String; ));
+						strings.append(c_def);
+						strings.append(fmt_newline);
+						++ entry;
+						continue;
+					}
+					strings.append(entry);
+				}
+				break;
+
+				default:
+					strings.append(entry);
+				break;
+			}
+		}
+		header.print(dump_to_scratch_and_retireve(strings));
+
+		Code filesystem = scan_file( project_dir "dependencies/filesystem.hpp" );
+		Code timing = scan_file( project_dir "dependencies/timing.hpp" );
+		header.print( filesystem );
+		header.print( timing );
+
+		header.print_fmt( "\nGEN_NS_END\n" );
+		header.print_fmt( roll_own_dependencies_guard_end );
+
+		Code types      = scan_file( project_dir "components/types.hpp" );
+		Code ast        = scan_file( project_dir "components/ast.hpp" );
+		Code ast_types  = scan_file( project_dir "components/ast_types.hpp" );
+		Code code_types = scan_file( project_dir "components/code_types.hpp" );
+		Code interface  = scan_file( project_dir "components/interface.hpp" );
+		Code inlines 	= scan_file( project_dir "components/inlines.hpp" );
+		Code header_end = scan_file( project_dir "components/header_end.hpp" );
+
+		CodeBody ecode       = gen_ecode     ( project_dir "enums/ECode.csv" );
+		CodeBody eoperator   = gen_eoperator ( project_dir "enums/EOperator.csv" );
+		CodeBody especifier  = gen_especifier( project_dir "enums/ESpecifier.csv" );
+		CodeBody ast_inlines = gen_ast_inlines();
+
+		header.print_fmt("#pragma region Types\n");
+		header.print( types );
+		header.print( fmt_newline );
+		header.print( dump_to_scratch_and_retireve( ecode ));
+		header.print( fmt_newline );
+		header.print( dump_to_scratch_and_retireve( eoperator ));
+		header.print( fmt_newline );
+		header.print( dump_to_scratch_and_retireve( especifier ));
+		header.print( fmt_newline );
+		header.print_fmt("#pragma endregion Types\n\n");
 	}
 
 	header.print( pop_ignores );
 	header.write();
 
-	format_file( "gen/gen.h" );
+	// format_file( "gen/gen.h" );
 
 	gen::deinit();
 	return 0;

gen_c_library/components/containers.array.hpp

@@ -19,7 +19,7 @@ CodeBody gen_array_base()
 	// Code grow_formula = untyped_str( txt( "#define gen_array_grow_formula( value ) ( 2 * value + 8 )\n" ));
 	Code get_header   = untyped_str( txt( "#define array_get_header( Type, self ) ( (ArrayHeader*)( self ) - 1)\n" ));
 
-	return def_global_body( args( td_header, header, get_header ) );
+	return def_global_body( args( fmt_newline, td_header, header, get_header, fmt_newline ) );
 };
 
 CodeBody gen_array( StrC type, StrC array_name )

gen_c_library/components/misc.hpp

@@ -7,9 +7,13 @@ using SwapContentProc = CodeBody(void);
 
 b32 ignore_preprocess_cond_block( StrC cond_sig, Code& entry_iter, CodeBody& body )
 {
+	b32 found = false;
 	CodePreprocessCond cond = entry_iter.cast<CodePreprocessCond>();
 	if ( cond->Content.contains(cond_sig) )
 	{
+		log_fmt("Preprocess cond found: %S\n", cond->Content);
+		found = true;
+
 		s32 depth = 1;
 		++ entry_iter; for(b32 continue_for = true; continue_for && entry_iter != body.end(); ) switch
 		(entry_iter->Type) {
@@ -34,7 +38,7 @@ b32 ignore_preprocess_cond_block( StrC cond_sig, Code& entry_iter, CodeBody& bod
 		}
 	}
 
-	return entry_iter != body.end();
+	return found;
 }
 
 bool swap_pragma_region_implementation( StrC region_name, SwapContentProc* swap_content, Code& entry_iter, CodeBody& body )

project/components/ast.hpp

@@ -165,6 +165,7 @@ struct Code
 	char const* debug_str();               \
 	Code        duplicate();			   \
 	bool        is_equal( Code other );    \
+	bool        is_body();                 \
 	bool        is_valid();                \
 	void        set_global();              \
 	String      to_string();               \
@@ -259,6 +260,7 @@ struct AST
 	Code&       entry      ( u32 idx );
 	bool        has_entries();
 	bool        is_equal   ( AST* other );
+	bool        is_body();
 	char const* type_str();
 	bool        validate_body();
 

project/components/code_types.hpp

@@ -11,6 +11,10 @@ struct CodeBody
 
 	void append( Code other )
 	{
+		if (other.is_body())
+		{
+			append( other.cast<CodeBody>() );
+		}
 		raw()->append( other.ast );
 	}
 	void append( CodeBody body )

project/components/gen/ast_inlines.hpp

@@ -24,6 +24,15 @@ inline Code Code::duplicate()
 	return { rcast( AST*, ast )->duplicate() };
 }
 
+inline bool Code::is_body()
+{
+	if ( ast == nullptr )
+	{
+		return rcast( AST*, ast )->is_body();
+	}
+	return false;
+}
+
 inline bool Code::is_equal( Code other )
 {
 	if ( ast == nullptr || other.ast == nullptr )
@@ -91,6 +100,15 @@ inline Code CodeBody::duplicate()
 	return { rcast( AST*, ast )->duplicate() };
 }
 
+inline bool CodeBody::is_body()
+{
+	if ( ast == nullptr )
+	{
+		return rcast( AST*, ast )->is_body();
+	}
+	return false;
+}
+
 inline bool CodeBody::is_equal( Code other )
 {
 	if ( ast == nullptr || other.ast == nullptr )
@@ -158,6 +176,15 @@ inline Code CodeAttributes::duplicate()
 	return { rcast( AST*, ast )->duplicate() };
 }
 
+inline bool CodeAttributes::is_body()
+{
+	if ( ast == nullptr )
+	{
+		return rcast( AST*, ast )->is_body();
+	}
+	return false;
+}
+
 inline bool CodeAttributes::is_equal( Code other )
 {
 	if ( ast == nullptr || other.ast == nullptr )
@@ -245,6 +272,15 @@ inline Code CodeComment::duplicate()
 	return { rcast( AST*, ast )->duplicate() };
 }
 
+inline bool CodeComment::is_body()
+{
+	if ( ast == nullptr )
+	{
+		return rcast( AST*, ast )->is_body();
+	}
+	return false;
+}
+
 inline bool CodeComment::is_equal( Code other )
 {
 	if ( ast == nullptr || other.ast == nullptr )
@@ -332,6 +368,15 @@ inline Code CodeConstructor::duplicate()
 	return { rcast( AST*, ast )->duplicate() };
 }
 
+inline bool CodeConstructor::is_body()
+{
+	if ( ast == nullptr )
+	{
+		return rcast( AST*, ast )->is_body();
+	}
+	return false;
+}
+
 inline bool CodeConstructor::is_equal( Code other )
 {
 	if ( ast == nullptr || other.ast == nullptr )
@@ -419,6 +464,15 @@ inline Code CodeClass::duplicate()
 	return { rcast( AST*, ast )->duplicate() };
 }
 
+inline bool CodeClass::is_body()
+{
+	if ( ast == nullptr )
+	{
+		return rcast( AST*, ast )->is_body();
+	}
+	return false;
+}
+
 inline bool CodeClass::is_equal( Code other )
 {
 	if ( ast == nullptr || other.ast == nullptr )
@@ -486,6 +540,15 @@ inline Code CodeDefine::duplicate()
 	return { rcast( AST*, ast )->duplicate() };
 }
 
+inline bool CodeDefine::is_body()
+{
+	if ( ast == nullptr )
+	{
+		return rcast( AST*, ast )->is_body();
+	}
+	return false;
+}
+
 inline bool CodeDefine::is_equal( Code other )
 {
 	if ( ast == nullptr || other.ast == nullptr )
@@ -573,6 +636,15 @@ inline Code CodeDestructor::duplicate()
 	return { rcast( AST*, ast )->duplicate() };
 }
 
+inline bool CodeDestructor::is_body()
+{
+	if ( ast == nullptr )
+	{
+		return rcast( AST*, ast )->is_body();
+	}
+	return false;
+}
+
 inline bool CodeDestructor::is_equal( Code other )
 {
 	if ( ast == nullptr || other.ast == nullptr )
@@ -660,6 +732,15 @@ inline Code CodeEnum::duplicate()
 	return { rcast( AST*, ast )->duplicate() };
 }
 
+inline bool CodeEnum::is_body()
+{
+	if ( ast == nullptr )
+	{
+		return rcast( AST*, ast )->is_body();
+	}
+	return false;
+}
+
 inline bool CodeEnum::is_equal( Code other )
 {
 	if ( ast == nullptr || other.ast == nullptr )
@@ -747,6 +828,15 @@ inline Code CodeExec::duplicate()
 	return { rcast( AST*, ast )->duplicate() };
 }
 
+inline bool CodeExec::is_body()
+{
+	if ( ast == nullptr )
+	{
+		return rcast( AST*, ast )->is_body();
+	}
+	return false;
+}
+
 inline bool CodeExec::is_equal( Code other )
 {
 	if ( ast == nullptr || other.ast == nullptr )
@@ -834,6 +924,15 @@ inline Code CodeExtern::duplicate()
 	return { rcast( AST*, ast )->duplicate() };
 }
 
+inline bool CodeExtern::is_body()
+{
+	if ( ast == nullptr )
+	{
+		return rcast( AST*, ast )->is_body();
+	}
+	return false;
+}
+
 inline bool CodeExtern::is_equal( Code other )
 {
 	if ( ast == nullptr || other.ast == nullptr )
@@ -921,6 +1020,15 @@ inline Code CodeFriend::duplicate()
 	return { rcast( AST*, ast )->duplicate() };
 }
 
+inline bool CodeFriend::is_body()
+{
+	if ( ast == nullptr )
+	{
+		return rcast( AST*, ast )->is_body();
+	}
+	return false;
+}
+
 inline bool CodeFriend::is_equal( Code other )
 {
 	if ( ast == nullptr || other.ast == nullptr )
@@ -1008,6 +1116,15 @@ inline Code CodeFn::duplicate()
 	return { rcast( AST*, ast )->duplicate() };
 }
 
+inline bool CodeFn::is_body()
+{
+	if ( ast == nullptr )
+	{
+		return rcast( AST*, ast )->is_body();
+	}
+	return false;
+}
+
 inline bool CodeFn::is_equal( Code other )
 {
 	if ( ast == nullptr || other.ast == nullptr )
@@ -1095,6 +1212,15 @@ inline Code CodeInclude::duplicate()
 	return { rcast( AST*, ast )->duplicate() };
 }
 
+inline bool CodeInclude::is_body()
+{
+	if ( ast == nullptr )
+	{
+		return rcast( AST*, ast )->is_body();
+	}
+	return false;
+}
+
 inline bool CodeInclude::is_equal( Code other )
 {
 	if ( ast == nullptr || other.ast == nullptr )
@@ -1182,6 +1308,15 @@ inline Code CodeModule::duplicate()
 	return { rcast( AST*, ast )->duplicate() };
 }
 
+inline bool CodeModule::is_body()
+{
+	if ( ast == nullptr )
+	{
+		return rcast( AST*, ast )->is_body();
+	}
+	return false;
+}
+
 inline bool CodeModule::is_equal( Code other )
 {
 	if ( ast == nullptr || other.ast == nullptr )
@@ -1269,6 +1404,15 @@ inline Code CodeNS::duplicate()
 	return { rcast( AST*, ast )->duplicate() };
 }
 
+inline bool CodeNS::is_body()
+{
+	if ( ast == nullptr )
+	{
+		return rcast( AST*, ast )->is_body();
+	}
+	return false;
+}
+
 inline bool CodeNS::is_equal( Code other )
 {
 	if ( ast == nullptr || other.ast == nullptr )
@@ -1356,6 +1500,15 @@ inline Code CodeOperator::duplicate()
 	return { rcast( AST*, ast )->duplicate() };
 }
 
+inline bool CodeOperator::is_body()
+{
+	if ( ast == nullptr )
+	{
+		return rcast( AST*, ast )->is_body();
+	}
+	return false;
+}
+
 inline bool CodeOperator::is_equal( Code other )
 {
 	if ( ast == nullptr || other.ast == nullptr )
@@ -1443,6 +1596,15 @@ inline Code CodeOpCast::duplicate()
 	return { rcast( AST*, ast )->duplicate() };
 }
 
+inline bool CodeOpCast::is_body()
+{
+	if ( ast == nullptr )
+	{
+		return rcast( AST*, ast )->is_body();
+	}
+	return false;
+}
+
 inline bool CodeOpCast::is_equal( Code other )
 {
 	if ( ast == nullptr || other.ast == nullptr )
@@ -1530,6 +1692,15 @@ inline Code CodeParam::duplicate()
 	return { rcast( AST*, ast )->duplicate() };
 }
 
+inline bool CodeParam::is_body()
+{
+	if ( ast == nullptr )
+	{
+		return rcast( AST*, ast )->is_body();
+	}
+	return false;
+}
+
 inline bool CodeParam::is_equal( Code other )
 {
 	if ( ast == nullptr || other.ast == nullptr )
@@ -1597,6 +1768,15 @@ inline Code CodePragma::duplicate()
 	return { rcast( AST*, ast )->duplicate() };
 }
 
+inline bool CodePragma::is_body()
+{
+	if ( ast == nullptr )
+	{
+		return rcast( AST*, ast )->is_body();
+	}
+	return false;
+}
+
 inline bool CodePragma::is_equal( Code other )
 {
 	if ( ast == nullptr || other.ast == nullptr )
@@ -1684,6 +1864,15 @@ inline Code CodePreprocessCond::duplicate()
 	return { rcast( AST*, ast )->duplicate() };
 }
 
+inline bool CodePreprocessCond::is_body()
+{
+	if ( ast == nullptr )
+	{
+		return rcast( AST*, ast )->is_body();
+	}
+	return false;
+}
+
 inline bool CodePreprocessCond::is_equal( Code other )
 {
 	if ( ast == nullptr || other.ast == nullptr )
@@ -1771,6 +1960,15 @@ inline Code CodeSpecifiers::duplicate()
 	return { rcast( AST*, ast )->duplicate() };
 }
 
+inline bool CodeSpecifiers::is_body()
+{
+	if ( ast == nullptr )
+	{
+		return rcast( AST*, ast )->is_body();
+	}
+	return false;
+}
+
 inline bool CodeSpecifiers::is_equal( Code other )
 {
 	if ( ast == nullptr || other.ast == nullptr )
@@ -1838,6 +2036,15 @@ inline Code CodeStruct::duplicate()
 	return { rcast( AST*, ast )->duplicate() };
 }
 
+inline bool CodeStruct::is_body()
+{
+	if ( ast == nullptr )
+	{
+		return rcast( AST*, ast )->is_body();
+	}
+	return false;
+}
+
 inline bool CodeStruct::is_equal( Code other )
 {
 	if ( ast == nullptr || other.ast == nullptr )
@@ -1905,6 +2112,15 @@ inline Code CodeTemplate::duplicate()
 	return { rcast( AST*, ast )->duplicate() };
 }
 
+inline bool CodeTemplate::is_body()
+{
+	if ( ast == nullptr )
+	{
+		return rcast( AST*, ast )->is_body();
+	}
+	return false;
+}
+
 inline bool CodeTemplate::is_equal( Code other )
 {
 	if ( ast == nullptr || other.ast == nullptr )
@@ -1992,6 +2208,15 @@ inline Code CodeType::duplicate()
 	return { rcast( AST*, ast )->duplicate() };
 }
 
+inline bool CodeType::is_body()
+{
+	if ( ast == nullptr )
+	{
+		return rcast( AST*, ast )->is_body();
+	}
+	return false;
+}
+
 inline bool CodeType::is_equal( Code other )
 {
 	if ( ast == nullptr || other.ast == nullptr )
@@ -2079,6 +2304,15 @@ inline Code CodeTypedef::duplicate()
 	return { rcast( AST*, ast )->duplicate() };
 }
 
+inline bool CodeTypedef::is_body()
+{
+	if ( ast == nullptr )
+	{
+		return rcast( AST*, ast )->is_body();
+	}
+	return false;
+}
+
 inline bool CodeTypedef::is_equal( Code other )
 {
 	if ( ast == nullptr || other.ast == nullptr )
@@ -2166,6 +2400,15 @@ inline Code CodeUnion::duplicate()
 	return { rcast( AST*, ast )->duplicate() };
 }
 
+inline bool CodeUnion::is_body()
+{
+	if ( ast == nullptr )
+	{
+		return rcast( AST*, ast )->is_body();
+	}
+	return false;
+}
+
 inline bool CodeUnion::is_equal( Code other )
 {
 	if ( ast == nullptr || other.ast == nullptr )
@@ -2253,6 +2496,15 @@ inline Code CodeUsing::duplicate()
 	return { rcast( AST*, ast )->duplicate() };
 }
 
+inline bool CodeUsing::is_body()
+{
+	if ( ast == nullptr )
+	{
+		return rcast( AST*, ast )->is_body();
+	}
+	return false;
+}
+
 inline bool CodeUsing::is_equal( Code other )
 {
 	if ( ast == nullptr || other.ast == nullptr )
@@ -2340,6 +2592,15 @@ inline Code CodeVar::duplicate()
 	return { rcast( AST*, ast )->duplicate() };
 }
 
+inline bool CodeVar::is_body()
+{
+	if ( ast == nullptr )
+	{
+		return rcast( AST*, ast )->is_body();
+	}
+	return false;
+}
+
 inline bool CodeVar::is_equal( Code other )
 {
 	if ( ast == nullptr || other.ast == nullptr )

project/components/inlines.hpp

@@ -50,6 +50,25 @@ bool AST::has_entries()
 	return NumEntries > 0;
 }
 
+inline
+bool AST::is_body()
+{
+	switch (Type)
+	{
+		case ECode::Enum_Body:
+		case ECode::Class_Body:
+		case ECode::Union_Body:
+		case ECode::Export_Body:
+		case ECode::Global_Body:
+		case ECode::Struct_Body:
+		case ECode::Function_Body:
+		case ECode::Namespace_Body:
+		case ECode::Extern_Linkage_Body:
+			return true;
+	}
+	return false;
+}
+
 inline
 char const* AST::type_str()
 {

project/components/parser.cpp

@@ -4406,6 +4406,7 @@ CodeTemplate parse_template()
 	result->Params      = params;
 	result->Declaration = definition;
 	result->ModuleFlags = mflags;
+	// result->Name        = definition->Name;
 
 	Context.pop();
 	return result;

project/dependencies/containers.hpp

@@ -14,20 +14,17 @@ template<class TType>
 using TRemoveConst = typename RemoveConst<TType>::Type;
 
 #pragma region Array
-#if ! GEN_COMPILER_C
 #define Array(Type) Array<Type>
 
 // #define array_init(Type, ...)         array_init        <Type>(__VA_ARGS__)
 // #define array_init_reserve(Type, ...) array_init_reserve<Type>(__VA_ARGS__)
-#endif
 
 struct ArrayHeader;
 
 #if GEN_SUPPORT_CPP_MEMBER_FEATURES
-template<class Type> struct Array;
+	template<class Type> struct Array;
 #else
-template<class Type>
-using Array = Type*;
+	template<class Type> using Array = Type*;
 #endif
 
 usize array_grow_formula(ssize value);

project/dependencies/macros.hpp

@@ -205,7 +205,7 @@
 #	define foreach(Type, entry_id, iterable) for ( Type entry_id : iterable )
 #endif
 
-#if GENC_COMPILERC
+#if GEN_COMPILER_C
 #	if __STDC_VERSION__ >= 202311L
 #		define enum_underlying(type) : type
 #	else

project/dependencies/memory.hpp

@@ -14,23 +14,13 @@
 #define GEN__HIGHS         ( GEN__ONES * ( GEN_U8_MAX / 2 + 1 ) )
 #define GEN__HAS_ZERO( x ) ( ( ( x ) - GEN__ONES ) & ~( x ) & GEN__HIGHS )
 
-#if ! GEN_COMPILER_C
-	template< class Type >
-	void swap( Type& a, Type& b )
-	{
+template< class Type >
+void swap( Type& a, Type& b )
+{
 	Type tmp = a;
 	a = b;
 	b = tmp;
-	}
-#else
-	#define swap( a, b ) \
-	do {                 \
-		typeof(a)        \
-		temp = (a);      \
-		(a)  = (b);      \
-		(b)  = temp;     \
-	} while(0)
-#endif
+}
 
 //! Checks if value is power of 2.
 b32 is_power_of_two( ssize x );

project/dependencies/platform.hpp

@@ -106,7 +106,7 @@
 #  define GEN_GCC_VERSION_CHECK(major,minor,patch) (0)
 #endif
 
-#ifndef GEN_COMPIELR_C
+#ifndef GEN_COMPILER_C
 #	if defined(__STDC_VERSION__)
 #		define GEN_COMPILER_C 1
 #	else

project/dependencies/strings.hpp

@@ -11,8 +11,10 @@ struct StrC
 	ssize       Len;
 	char const* Ptr;
 
+#if ! GEN_COMPILER_C
 	operator char const* ()               const { return Ptr; }
 	char const& operator[]( ssize index ) const { return Ptr[index]; }
+#endif
 };
 
 #define cast_to_strc( str ) * rcast( StrC*, (str) - sizeof(ssize) )
@@ -29,12 +31,7 @@ StrC to_str( char const* str ) {
 // I kept it for simplicty of porting but its not necessary to keep it that way.
 #pragma region String
 struct StringHeader;
-
-#if GEN_COMPILER_C
-typedef char* String;
-#else
 struct String;
-#endif
 
 String        string_make(AllocatorInfo allocator, char const* str);
 String        string_make(AllocatorInfo allocator, StrC str);
@@ -44,8 +41,8 @@ String        string_fmt(AllocatorInfo allocator, char* buf, ssize buf_size, cha
 String        string_fmt_buf(AllocatorInfo allocator, char const* fmt, ...);
 String        string_join(AllocatorInfo allocator, char const** parts, ssize num_parts, char const* glue);
 usize         string_grow_formula(usize value);
-bool          are_equal(String lhs, String rhs);
-bool          are_equal(String lhs, StrC rhs);
+bool          are_equal(String const& lhs, String const& rhs);
+bool          are_equal(String const& lhs, StrC rhs);
 bool          make_space_for(String& str, char const* to_append, ssize add_len);
 bool          append(String& str, char c);
 bool          append(String& str, char const* str_to_append);
@@ -111,8 +108,6 @@ struct String
 	forceinline static String make_length(AllocatorInfo a, char const* s, ssize l)          { return GEN_NS string_make_length(a, s, l); }
 	forceinline static String join(AllocatorInfo a, char const** p, ssize n, char const* g) { return GEN_NS string_join(a, p, n, g); }
 	forceinline static usize  grow_formula(usize value)                                     { return GEN_NS string_grow_formula(value); }
-	forceinline static bool   are_equal(String lhs, String rhs)                             { return GEN_NS are_equal(lhs, rhs); }
-	forceinline static bool   are_equal(String lhs, StrC rhs)                               { return GEN_NS are_equal(lhs, rhs); }
 
 	static
 	String fmt(AllocatorInfo allocator, char* buf, ssize buf_size, char const* fmt, ...) {
@@ -148,6 +143,8 @@ struct String
 	forceinline void          clear()                                        { GEN_NS clear(*this); }
 	forceinline String        duplicate(AllocatorInfo allocator) const       { return GEN_NS duplicate(*this, allocator); }
 	forceinline void          free()                                         { GEN_NS free(*this); }
+	forceinline bool          is_equal(String const& other) const            { return GEN_NS are_equal(* this, other); }
+	forceinline bool          is_equal(StrC other) const                     { return GEN_NS are_equal(* this, other); }
 	forceinline ssize         length() const                                 { return GEN_NS length(*this); }
 	forceinline b32           starts_with(StrC substring) const              { return GEN_NS starts_with(*this, substring); }
 	forceinline b32           starts_with(String substring) const            { return GEN_NS starts_with(*this, substring); }
@@ -289,7 +286,7 @@ bool append_fmt(String& str, char const* fmt, ...) {
 }
 
 inline
-bool are_equal(String lhs, String rhs)
+bool are_equal(String const& lhs, String const& rhs)
 {
 	if (length(lhs) != length(rhs))
 		return false;
@@ -302,7 +299,7 @@ bool are_equal(String lhs, String rhs)
 }
 
 inline
-bool are_equal(String lhs, StrC rhs)
+bool are_equal(String const& lhs, StrC rhs)
 {
 	if (length(lhs) != (rhs.Len))
 		return false;

project/helpers/helper.hpp

@@ -368,6 +368,15 @@ CodeBody gen_ast_inlines()
 			return { rcast(AST*, ast)->duplicate() };
 		}
 		inline
+		bool <typename>::is_body()
+		{
+			if ( ast == nullptr )
+			{
+				return rcast(AST*, ast)->is_body();
+			}
+			return false;
+		}
+		inline
 		bool <typename>::is_equal( Code other )
 		{
 			if ( ast == nullptr || other.ast == nullptr )