review comments

StructurePlan.txt

@@ -6,6 +6,11 @@ Have a cash system which will partially generate things
 
 Having as multiple .cpp and .hpp files does feel significantly better performance wise as it would allow to not recompile everything when something is changed and make it modular. In addition we would be able to remove need for registry if generated.hpp file would hold a reference to metadata. The downside is having a lot of files. BUT THREAAADING CAN BE IMPLEMENTED TO MAKE IT PARALLEL.
 
+Add supported list of attributes to our precompiler step, which will give warning based on if it is in there already or not.
+
+LLVM + clang; consider parsing AST myself vs let clang parse it; 
+
+
 2 During compilation populate unordered map with type - members
 
 Different types and info we need to keep track of:
@@ -16,6 +21,7 @@ Different types and info we need to keep track of:
 	4 Functions: -//-, const, static, virtual and co, pointer to function, 
 	5 Template instances: our concept thing, member functions and variables, allignment, size, name with parameters, 
 	6 Enums: underlying type, scoped?, values
+	7 unions?
 
 
 If we implement inheritance reflected_member - we will incur 8*virtual_func_num hidden bytes
@@ -25,3 +31,11 @@ Need to figure out which modifiers exactly can be used in the future.
 Need to add a way to manually add reflections.
 
 buffer_string,dynamic string
+
+Need to include namespace into strings
+
+For choices: Hash function, hash structure, compile vs runtime containers
+
+For choices, where to store runtime reflection data - BSS vs Heap vs Stack
+
+Names are made from recursive parents. No runtime reflected namespaces objects.

VisualStudio22-All.bat

@@ -1 +1,2 @@
-rythe-build-system\premake5 --file=rythe-build-system/premake5.lua vs2022 --workspace-name=reflection-experiments
+rythe-build-system\premake5 --file=rythe-build-system/premake5.lua vs2022 --workspace-name=reflection-experiments
+pause

applications/reflection-experiments/.rythe_project

@@ -2,15 +2,14 @@ local fs = dofile("filesystem.lua")
 
 local project = {
     additional_types = { "test" },
-    dependencies = { "public rythe/rythe-standard-library", "private third_party/clang-c:header-only" },
+    dependencies = { "public rythe/rythe-standard-library", "private third_party/clang-c:header-only", 
+     "private third_party/xxhash"},
     additional_link_targets = { "libclang" },
 }
 
 function project.init(proj, context)
-    local targetDir = fs.sanitize(fs.parentPath(_MAIN_SCRIPT_DIR) .. "/build/" .. _ACTION) .. fs.getPathSeperator()
-    local srcDir = fs.sanitize(fs.parentPath(_MAIN_SCRIPT_DIR) .. "/" .. proj.location .. "/src/test.hpp")
-    proj.post_build = { "xcopy \"" .. srcDir .. "\" \"" .. targetDir .. "\" /i /r /y /s /c" }
-
+    local srcDir = fs.sanitize(context.getProjectDir() .. "/src/target/")
+    proj.debug_args = { "--fpath=\"" .. srcDir .. "\"" }
     return proj
 end
 

applications/reflection-experiments/src/code_gen/example.h

@@ -0,0 +1,57 @@
+#pragma once
+#include "../runtime_reflection_containers/runtime_reflected_class.h"
+#include "../runtime_reflection_containers/runtime_reflected_variable.h"
+#include "../runtime_reflection_containers/runtime_reflected_function.h"
+
+/* This is example of generated from this file:
+namespace examle_namespace
+{
+    class target_class
+        {
+    public:
+        int int_variable;
+
+        void void_function(int int_parameter);
+
+        class nested_class
+                {
+                public:
+                    nested_class() : value(0) {}
+
+                    void set_value(int v)
+                    {
+                        value = v;
+                    }
+
+                    int get_value() const
+                    {
+                        return value;
+                    }
+
+                private:
+                    int value;
+                };
+    private:
+        char char_variable;
+    };
+}
+*/
+
+class example_file_generated
+{
+public:
+    void add_reflected_file()
+    {
+        // All defined types in this file should go in here.
+        static const runtime_reflected_class classes[2] = {
+            runtime_reflected_class(
+                rsl::dynamic_string::from_buffer("example_namespace::target_class"),
+                reflection_id(12875366372301390368, 31932944099034707, 15853025086180115556)),
+            runtime_reflected_class(
+                rsl::dynamic_string::from_buffer("example_namespace::target_class::nested_class"),
+                reflection_id(8627741348740311923, 10691473971882747459, 3168970719907517523))
+        };
+
+        for(auto reflected_class : classes) { context.add_type(&reflected_class); }
+    }
+};

applications/reflection-experiments/src/code_gen/reflection_code_generator.cpp

@@ -0,0 +1,183 @@
+#include "reflection_code_generator.h"
+#include "D:/MyProjects/reflection-experiments/applications/reflection-experiments/src/target/test.hpp"
+#include <fstream>
+#include <iostream>
+#include <stdio.h>
+
+#include "../runtime_reflection_containers/runtime_reflected_variable.h"
+
+const rsl::dynamic_string reflection_code_generator::generate_variable(
+    [[maybe_unused]] runtime_reflected_variable parsed_variable)
+{
+    /*
+    std::string        pad = "    ";
+    std::ostringstream out;
+
+    out << "rythe::reflection_containers::runtime_reflected_variable(\n";
+
+    const char* name = parsed_variable.get_name().data();
+    out << pad << "\"" << name << "\"\n";
+
+    const char* name_space = parsed_variable.get_namespace().data();
+    out << pad << "\"" << name_space << "\"\n";
+
+    switch(parsed_variable.get_access_modifier())
+    {
+        case reflection_properties::access_modifier::public_access:
+            out << pad << "reflection_properties::acess_modifier::public_access,\n";
+            break;
+        case reflection_properties::access_modifier::protected_access:
+            out << pad << "reflection_properties::acess_modifier::protected_access,\n";
+            break;
+        case reflection_properties::access_modifier::private_access:
+            out << pad << "reflection_properties::acess_modifier::private_access,\n";
+            break;
+        default:
+            out << pad << "reflection_properties::acess_modifier::public_access,\n";
+            break;
+    }
+
+    out << pad << (parsed_variable.get_is_static() ? "true" : "false") << ",\n";
+    out << pad << (parsed_variable.get_is_const() ? "true" : "false") << ",\n";
+    out << pad << (parsed_variable.get_is_array() ? "true" : "false") << ",\n";
+    out << pad << parsed_variable.get_array_size() << ",\n";
+
+    out << pad << parsed_variable.get_offset() << ",\n";
+    out << pad << parsed_variable.get_size() << ",\n";
+    out << pad << parsed_variable.get_alignment() << ",\n";
+
+    //const char* type_str = parsed_variable.get_type_id().get_type().data();
+    //out << pad << "reflection_id(rsl::dynamic_string::from_string_length(" << type_str << ")),\n";
+
+    const auto& attributes = parsed_variable.get_attributes();
+    out << pad << "rsl::dynamic_array<rsl::dynamic_string>{";
+    if(!attributes.empty()) { out << "\n"; }
+    for (int i = 0; i < attributes.size(); ++i) {
+        const char* attribute = attributes[i].data();
+        out << pad << "    rsl::dynamic_string::from_buffer(" 
+            << attribute << ", " << (attribute ? attributes.size() : 0) << ")";
+        if (i + 1 < attributes) out << ",";
+        out << "\n";
+    }
+
+    if(!attributes.empty()) { out << pad; }
+    out << "}\n";
+
+    out << "    )";
+
+    std::string string = out.str();
+    return rsl::dynamic_string::from_buffer(string.c_str(), string.size());
+    */
+    return {};
+}
+
+reflection_code_generator::reflection_code_generator() {}
+
+reflection_code_generator::~reflection_code_generator() {}
+
+void reflection_code_generator::generate_reflected_file(const compile_reflected_file& compile_file)
+{
+    const rsl::string_view source_location = compile_file.get_source_location();
+    std::ofstream          file(get_gen_source_file(source_location).data());
+    if(!file.is_open()) { std::cout << "Could not open file " << source_location.data() << " for writing.\n"; }
+
+    file << "#include \"runtime_reflected_variable.hpp\"\n";
+    file << "using namespace rythe::reflection_containers;\n\n";
+    file << "void generate_variable(rythe::reflection_containers::runtime_reflected_variable parsed_variable) {\n";
+    //file << "    auto var = " << generate_variable(parsed_variable).data() << ";\n";
+    file << "}\n";
+}
+
+rsl::dynamic_string reflection_code_generator::get_gen_source_file(rsl::string_view source_location)
+{
+    if(source_location.size() >= 256)
+    {
+        std::cout << "source_path is too long\n";
+        return {};
+    }
+
+    char buffer[256];
+    std::memcpy(buffer, source_location.data(), source_location.size());
+    buffer[source_location.size()] = '\0';
+
+    char* lastSlash = std::strrchr(buffer, '/');
+    if(lastSlash != nullptr) { *lastSlash = '\0'; }
+
+    strcat_s(buffer, sizeof(buffer), "/generated");
+
+    return rsl::dynamic_string::from_buffer(buffer, std::strlen(buffer));
+}
+
+
+/*
+rsl::dynamic_string reflection_code_generator::generate_variable(rythe::reflection_containers::runtime_reflected_variable parsed_variable) {
+
+    std::string pad = "    ";
+    std::ostringstream out;
+
+    out << "rythe::reflection_containers::runtime_reflected_variable(\n";
+
+    const char* name = parsed_variable.get_source_location().data();
+    out << pad << "\"" << name << "\"\n";
+
+    const char* name_space = parsed_variable.get_namespace().data();
+    out << pad << "\"" << name_space << "\"\n";
+
+    switch (parsed_variable.get_access_modifier()) {
+        case reflection_properties::acess_modifier::public_access:
+            out << pad << "reflection_properties::acess_modifier::public_access,\n"; break;
+        case reflection_properties::acess_modifier::protected_access:
+            out << pad << "reflection_properties::acess_modifier::protected_access,\n"; break;
+        case reflection_properties::acess_modifier::private_access:
+            out << pad << "reflection_properties::acess_modifier::private_access,\n"; break;
+        default:
+            out << pad << "reflection_properties::acess_modifier::public_access,\n"; break;
+    }
+
+    out << pad << (parsed_variable.get_is_static() ? "true" : "false") << ",\n";
+    out << pad << (parsed_variable.get_is_const() ? "true" : "false") << ",\n";
+    out << pad << (parsed_variable.get_is_array() ? "true" : "false") << ",\n";
+    out << pad << parsed_variable.get_array_size() << ",\n";
+
+    out << pad << parsed_variable.get_offset() << ",\n";
+    out << pad << parsed_variable.get_size() << ",\n";
+    out << pad << parsed_variable.get_alignment() << ",\n";
+
+    const char* type_str = parsed_variable.get_type_id().get_type().data();
+    out << pad << "reflection_id(rsl::dynamic_string::from_buffer("
+        << type_str << ", " << (type_str ? std::strlen(type_str) : 0) << ")),\n";
+
+    const auto& attributes = parsed_variable.get_attributes();
+    out << pad << "rsl::dynamic_array<rsl::dynamic_string>{";
+    if (!attributes.empty()) out << "\n";
+    for (int i = 0; i < attributes.size(); ++i) {
+        const char* attribute = attributes[i].data();
+        out << pad << "    rsl::dynamic_string::from_buffer(" 
+            << attribute << ", " << (attribute ? attributes.size() : 0) << ")";
+        if (i + 1 < attributes) out << ",";
+        out << "\n";
+    }
+    if (!attributes.empty()) out << pad;
+    out << "}\n";
+
+    out << "    )";
+
+    std::string string = out.str();
+    return rsl::dynamic_string::from_buffer(string.c_str(), string.size());
+}
+*/
+
+void reflection_code_generator::generate_reflected_variable_file(
+    const runtime_reflected_variable& parsed_variable,
+    const std::string&                outFile)
+{
+    std::cout << "reflection_code_generator::generate_reflected_variable_file\n";
+    std::ofstream file(outFile);
+    if(!file.is_open()) { std::cout << "Could not open file " << outFile << " for writing.\n"; }
+
+    file << "#include \"runtime_reflected_variable.hpp\"\n";
+    file << "using namespace rythe::reflection_containers;\n\n";
+    file << "void generate_variable(rythe::reflection_containers::runtime_reflected_variable parsed_variable) {\n";
+    file << "    auto var = " << generate_variable(parsed_variable).data() << ";\n";
+    file << "}\n";
+}

applications/reflection-experiments/src/code_gen/reflection_code_generator.h

@@ -0,0 +1,21 @@
+#pragma once
+#include "../runtime_reflection_containers/runtime_reflected_variable.h"
+#include <sstream>
+#include <rsl/containers>
+#include "../compiletime_reflection_containers/compile_reflected_file.h"
+
+class reflection_code_generator
+{
+public:
+    const rsl::dynamic_string generate_variable(runtime_reflected_variable parsed_variable);
+
+    reflection_code_generator();
+    ~reflection_code_generator();
+
+    void generate_reflected_variable_file(
+        const runtime_reflected_variable& parsed_variable,
+        const std::string&                outFile);
+
+    void                       generate_reflected_file(const compile_reflected_file& file);
+    static rsl::dynamic_string get_gen_source_file(rsl::string_view source_location);
+};

applications/reflection-experiments/src/compiletime_reflection_containers.h

@@ -0,0 +1,5 @@
+#pragme once
+
+#include "compiletime_reflection_containers/compile_reflected_class.h"
+#include "compiletime_reflection_containers/compile_reflected_file.h"
+#include "reflection_id/reflection_id.h"