Fix test project

BentouDev · Feb 11, 2024 · b1552d7 · b1552d7
1 parent b2e7472
commit b1552d7
Show file tree

Hide file tree

Showing 16 changed files with 144 additions and 167 deletions.
diff --git a/Source/Preprocessor/Core/Generator.cpp b/Source/Preprocessor/Core/Generator.cpp
@@ -196,6 +196,17 @@ fs::path Generator::BuildHeaderOutputPath(const std::string& include)
     return path;
 }
 
+fs::path Generator::BuildUnitOutputPath(const std::string& include)
+{
+    TMustacheView out_name_view(Context.Generator.CurrentPattern->UnitOutName);
+
+    fs::path path = Context.Generator.CurrentPattern->OutputDir;
+    std::string filename = out_name_view.render({ "header_name", include });
+    path.append(filename);
+
+    return path;
+}
+
 fs::path Generator::BuildClassOutputPath(std::shared_ptr<ClassInfo> type)
 {
     TMustacheView out_name_view(Context.Generator.CurrentPattern->ClassOutName);
@@ -260,8 +271,7 @@ void Generator::GenerateFiles()
         include_map[type->FromInclude].enums.push_back(type);
     }
 
-    for (auto& templ : Context.Generator.CurrentPattern->HeaderTemplates)
-    {
+    auto emit_per_file = [&]<typename TFunc>(const std::unique_ptr<MustacheTemplate>& templ, TFunc&& func) {
         if (templ->View)
         {
             for (auto& [include, data] : include_map)
@@ -286,18 +296,29 @@ void Generator::GenerateFiles()
                     }
                 }
 
+                mapped_data.set("header_path", include);
                 mapped_data.set("classes", classes);
                 mapped_data.set("enums", enums);
 
                 fs::path inc_path = include;
 
-                fs::path     path = BuildHeaderOutputPath(inc_path.filename().string());
+                fs::path path = func(inc_path.stem().string());
                 std::fstream file(path, std::ios_base::out);
 
                 file << templ->View->render(mapped_data);
                 file.close();
             }
         }
+    };
+
+    for (auto& templ : Context.Generator.CurrentPattern->HeaderTemplates)
+    {
+        emit_per_file(templ, [&](const std::string& include) { return BuildHeaderOutputPath(include); });
+    }
+
+    for (auto& templ : Context.Generator.CurrentPattern->UnitTemplates)
+    {
+        emit_per_file(templ, [&](const std::string& include) { return BuildUnitOutputPath(include); });
     }
 
     // Class templates

diff --git a/Source/Preprocessor/Core/Generator.h b/Source/Preprocessor/Core/Generator.h
@@ -27,6 +27,7 @@ class Generator
     TMustacheData BuildMethodData      (std::shared_ptr<ClassInfo>& type);
 
     fs::path      BuildHeaderOutputPath(const std::string& include_name);
+    fs::path      BuildUnitOutputPath(const std::string& include);
     fs::path      BuildClassOutputPath (std::shared_ptr<ClassInfo> type);
     fs::path      BuildEnumOutputPath  (std::shared_ptr<EnumInfo> type);
 

diff --git a/Source/Preprocessor/Core/Parsing/CursorHandlerFactory.cpp b/Source/Preprocessor/Core/Parsing/CursorHandlerFactory.cpp
@@ -299,7 +299,7 @@ namespace Handlers
                     continue;
                 }
                 // Comma separated attributes
-                else if (parthensis_depth == 0 && isCurrent(idx, ','))
+                else if (attribute_brackets_depth != 0 && parthensis_depth == 0 && isCurrent(idx, ','))
                 {
                     addAtrribute(current_attribute_begin, idx);
 

diff --git a/Source/Preprocessor/Core/SourcePattern.cpp b/Source/Preprocessor/Core/SourcePattern.cpp
@@ -24,6 +24,11 @@ void SourcePattern::LoadTemplates()
         LoadTemplate(templ);
     }
 
+    for (auto& templ : UnitTemplates)
+    {
+        LoadTemplate(templ);
+    }
+
     LoadTemplate(MainTemplate);
 }
 

diff --git a/Source/Preprocessor/Core/SourcePattern.h b/Source/Preprocessor/Core/SourcePattern.h
@@ -41,6 +41,7 @@ class SourcePattern
 
     std::unique_ptr<MustacheTemplate>              MainTemplate;
     std::vector<std::unique_ptr<MustacheTemplate>> HeaderTemplates;
+    std::vector<std::unique_ptr<MustacheTemplate>> UnitTemplates;
     std::vector<std::unique_ptr<MustacheTemplate>> ClassTemplates;
     std::vector<std::unique_ptr<MustacheTemplate>> EnumTemplates;
     std::vector<std::unique_ptr<SourceFile>>       Sources;
@@ -51,6 +52,7 @@ class SourcePattern
     fs::path    OutputDir;
     std::string MainOutName;
     std::string HeaderOutName;
+    std::string UnitOutName;
     std::string ClassOutName;
     std::string EnumOutName;
     bool        IncludeSourceHeader;

diff --git a/Source/Preprocessor/Utils/ArgumentParser.cpp b/Source/Preprocessor/Utils/ArgumentParser.cpp
@@ -227,7 +227,16 @@ void ArgumentParser::ParseTemplates(const nlohmann::json& parser, const fs::path
             }
         }
 
-        pattern->ClassOutName = element["class_file_name"].get<std::string>();
+        pattern->UnitOutName = try_get_str("unit_file_name");
+        if (auto itr = element.find("unit_template"); itr != element.end())
+        {
+            for (auto& tmpl : itr.value())
+            {
+                pattern->UnitTemplates.emplace_back(CreateTemplate(directory, tmpl.get<std::string>()));
+            }
+        }
+
+        pattern->ClassOutName = try_get_str("class_file_name");
         if (auto itr = element.find("class_template"); itr != element.end())
         {
             for (auto& tmpl : itr.value())
@@ -237,7 +246,7 @@ void ArgumentParser::ParseTemplates(const nlohmann::json& parser, const fs::path
             }
         }
 
-        pattern->EnumOutName = element["enum_file_name"].get<std::string>();
+        pattern->EnumOutName = try_get_str("enum_file_name");
 
         if (auto itr = element.find("enum_template"); itr != element.end())
         {

diff --git a/tests/zetsubou_build_step/config/agnes/inject.h b/tests/zetsubou_build_step/config/agnes/inject.h
diff --git a/tests/zetsubou_build_step/config/agnes/reflection_class.mustache b/tests/zetsubou_build_step/config/agnes/reflection_class.mustache
diff --git a/tests/zetsubou_build_step/config/agnes/reflection_enum.mustache b/tests/zetsubou_build_step/config/agnes/reflection_enum.mustache
diff --git a/tests/zetsubou_build_step/config/agnes/reflection_header.mustache b/tests/zetsubou_build_step/config/agnes/reflection_header.mustache
@@ -1,66 +1,19 @@
-#include <Reflection/ReflectionInfo.h>
+#include "{{header_path}}"
 
-namespace Meta::ReflectionData
+// Classes
+namespace Meta
 {
     {{#classes}}
-    class meta_{{class_name}} : public ClassInfo
-    {
-        static meta_{{class_name}} Data;
-
-        // private constructor
-        meta_{{class_name}}() {
-            Fields = {
-                {{#fields}}
-                    { {{name}}, &{{{canonical_name}}}::{{name}}, {{access}}, Meta::GetType<{{{type}}}> },
-                {{/fields}}
-            };
-            Methods = {
-                {{#methods}}
-                    { {{name}}, detail::MethodWrapper<decltype(&{{{canonical_name}}}::{{name}}), &{{{canonical_name}}}::{{name}}> },
-                {{/methods}}
-            };
-        }
-
-        const std::string Name = "{{class_name}}";
-        const std::string CanonicalName = "{{{canonical_name}}}";
-
-    public:
-        ClassInfo& Get() { return Data; }
-    };
-
-    TReflectionVector<Attribute> {{class_name}}Meta::Attributes = {
-        {{#attributes}}
-            {{{value}}},
-        {{/attributes}}
-    };
-
-    TReflectionVector<FieldInfo> {{class_name}}Meta::Fields = {
-        {{#fields}}
-            { {{name}}, &{{{canonical_name}}}::{{name}}, {{access}}, Meta::GetType<{{{type}}}> },
-        {{/fields}}
-    };
-
-    TReflectionVector<MethodInfo> {{class_name}}Meta::Methods = {
-        {{#methods}}
-            { {{name}}, detail::MethodWrapper<decltype(&{{{canonical_name}}}::{{name}}), &{{{canonical_name}}}::{{name}}> },
-        {{/methods}}
-    };
+    template<>
+    void RegisterClassRtti<typename {{{canonical_name}}}>();
     {{/classes}}
+}
 
+// Enums
+namespace Meta
+{
     {{#enums}}
-    class {{enum_name}}_Enum
-    {
-        std::vector<EnumValue> Values = {
-            {{#values}}
-               { {{name}}, {{value}} },
-            {{/values}}
-        };
-
-        std::vector<Attribute> Attributes = {
-            {{#attributes}}
-                {{value}},
-            {{/attributes}}
-        };
-    };
+    template<>
+    void RegisterEnumRtti<typename {{{canonical_name}}}>();
     {{/enums}}
 }
diff --git a/tests/zetsubou_build_step/config/agnes/reflection_main.mustache b/tests/zetsubou_build_step/config/agnes/reflection_main.mustache
@@ -1,13 +1,19 @@
 {{#includes}}
-#include "{{path}}.h"
+#include "{{path}}"
 {{/includes}}
 
 namespace Meta
 {
     void RegisterReflection()
     {
+        // Classes
         {{#classes}}
-        Meta::GetType<typename {{{canonical_name}}}>();
+        RegisterClassRtti<typename {{{canonical_name}}}>();
         {{/classes}}
+
+        // Enums
+        {{#enums}}
+        RegisterEnumRtti<typename {{{canonical_name}}}>();
+        {{/enums}}
     }
 }
diff --git a/tests/zetsubou_build_step/config/agnes/reflection_template.json b/tests/zetsubou_build_step/config/agnes/reflection_template.json
@@ -5,13 +5,10 @@
       "main_file_name" : "reflection_main.cpp",
 
       "header_template" : ["reflection_header.mustache"],
-      "header_file_name" : "{{header_name}}.gen.cpp",
+      "header_file_name" : "{{header_name}}.gen.h",
 
-      "class_template" : ["reflection_class.mustache"],
-      "class_file_name" : "{{class_name}}.gen.cpp",
-
-      "enum_template" : ["reflection_enum.mustache"],
-      "enum_file_name" : "{{enum_name}}.gen.cpp",
+      "unit_template" : ["reflection_unit.mustache"],
+      "unit_file_name" : "{{header_name}}.gen.cpp",
 
       "output_dir" : "Generated",
 

diff --git a/tests/zetsubou_build_step/config/agnes/reflection_unit.mustache b/tests/zetsubou_build_step/config/agnes/reflection_unit.mustache
@@ -1 +1,49 @@
-#include "{{output_file_name}}.h"
+#include "{{header_path}}"
+#include <iostream>
+
+// Classes
+namespace Meta
+{
+    {{#classes}}
+    template<>
+    void RegisterClassRtti<typename {{{canonical_name}}}>()
+    {
+        std::cout << "Class: " << "{{{canonical_name}}}" << std::endl;
+
+        std::cout << "    attributes:" << std::endl;
+        {{#attributes}}
+            std::cout << "        val: " << "{{value}}" << std::endl;
+        {{/attributes}}
+
+        std::cout << "    fields:" << std::endl;
+        {{#fields}}
+            std::cout << "        name: " << "{{name}}"  << " type: " << "{{{type}}}" << std::endl;
+        {{/fields}}
+
+        std::cout << std::endl;
+    }
+    {{/classes}}
+}
+
+// Enums
+namespace Meta
+{
+    {{#enums}}
+    template<>
+    void RegisterEnumRtti<typename {{{canonical_name}}}>()
+    {
+        std::cout << "Enum: " << "{{{canonical_name}}}" << std::endl;
+
+        std::cout << "    attributes:" << std::endl;
+        {{#attributes}}
+            std::cout << "        val: " << "{{value}}" << std::endl;
+        {{/attributes}}
+
+        std::cout << "    values:" << std::endl;
+        {{#values}}
+            std::cout << "        name: " << "{{name}}" << " val: " << "{{value}}" << std::endl;
+        {{/values}}
+        std::cout << std::endl;
+    }
+    {{/enums}}
+}