ouczbs/cppast
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

refl meta update

Browse Source
This commit is contained in:
ouczbs 2024-07-27 14:22:51 +08:00
parent 74698bdea2
commit 28ebd58bc0
10 changed files with 199 additions and 255 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
src/refl/Gen.cs
View File

@ -11,27 +11,18 @@ namespace refl
public static Dictionary<string, StringBuilder> FileList = new Dictionary<string, StringBuilder>();
public static StringBuilder Meta = new StringBuilder();
public static StringBuilder Output = new StringBuilder();
private ClassMetaData data = new ClassMetaData();
private ClassMetaImplData data = new ClassMetaImplData();
private GenMeta meta = new GenMeta();
private GenMetaImpl metaImpl = new GenMetaImpl();
private GenMultyMeta multyMeta = new GenMultyMeta();
private Stack<string> nameSpaces = new Stack<string>();
public Gen() { }
public static string PreprocessTemplate(string template, string indent, string newline)
{
// 替换占位符
return template.Replace("{{ Indent }}", indent);
}
public static bool InitTemplate(string dir)
{
string meta_file = Path.Combine(dir, "meta.liquid");
string meta_impl_file = Path.Combine(dir, "meta_impl.liquid");
string multy_meta_file = Path.Combine(dir, "multy_meta.liquid");
var parser = new FluidParser();
return GenMeta.InitTemplate(meta_file, parser)
&& GenMetaImpl.InitTemplate(meta_impl_file, parser)
&& GenMultyMeta.InitTemplate(multy_meta_file, parser);
&& GenMetaImpl.InitTemplate(meta_impl_file, parser);
}
public void CheckDir(string? dir)
{
@ -43,12 +34,10 @@ namespace refl
public void InitFile(string file_name)
{
Meta.AppendLine("#pragma once");
Meta.AppendLine("namespace refl_impl{");
foreach (var name in ModuleMeta.NameSet)
{
var build = new StringBuilder();
build.AppendLine("#pragma once");
build.AppendLine("namespace refl_impl{");
FileList.Add(name, build);
}
}
@ -63,8 +52,6 @@ namespace refl
}
public void OutFile(string file_name, string? dir,string target)
{
Meta.AppendLine("");
Output.AppendLine("}");
foreach (var pair in FileList)
{
string path = $"{pair.Key}_{file_name}".ToLower();
@ -72,7 +59,6 @@ namespace refl
{
path = Path.Combine(dir, path);
}
pair.Value.AppendLine("}");
File.WriteAllText(path, pair.Value.ToString());
if (pair.Key == "Meta")
{
@ -119,19 +105,13 @@ namespace refl
}
return "";
}
public void GenClassMeta(ClassMeta cls, ClassMetaData data)
public void GenClassMeta(ClassMeta cls, ClassMetaImplData data)
{
string fullName = GenPrefix() + cls.Name;
data.FullName = fullName;
bool isMulty = meta.GenClassMeta(cls, data);
Meta.Append(metaImpl.GenClassMeta(cls, fullName, isMulty));
bool isMulty = metaImpl.GenClassMeta(cls, data);
Meta.Append(meta.GenClassMeta(cls, fullName, isMulty));
Meta.AppendLine("");
if (isMulty)
{
var res = multyMeta.GenClassMeta(cls, fullName);
Output.Append(res);
Output.AppendLine("");
}
}
}
}

85
src/refl/GenMeta.cs
View File

@ -1,48 +1,32 @@
using System.IO;
using Fluid;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml.Linq;
using Fluid;
using System.Threading.Tasks;
using static System.Runtime.InteropServices.JavaScript.JSType;
namespace refl
{
internal class FieldMetaData
{
public string Name { get; set; }
public string Meta { get; set; }
public string Ref { get; set; }
public int Type { get; set; }
public FieldMetaData(FieldData data, int type)
{
Name = data.Name;
Meta = data.Meta;
Ref = data.Ref;
Type = type;
}
}
internal class ClassMetaData
internal class MetaClassData
{
public string Name { get; set; } = "";
public string ParentName { get; set; } = "";
public string FullName { get; set; } = "";
public string MetaName { get; set; } = "";
public int MetaType { get; set; } = 0;
public int MemberCount { get; set; } = 0;
public int CtorCount { get; set; } = 0;
public List<FieldMetaData> FieldList = new List<FieldMetaData>();
public bool IsMultyMeta { get; set; } = false;
public bool HasMeta { get; set; } = false;
public bool HasParent { get; set; } = false;
public List<string> MetaList = new List<string>();
}
internal class GenMeta
{
private static IFluidTemplate? template;
private static TemplateOptions options = new TemplateOptions();
private MetaClassData meta = new MetaClassData();
public static bool InitTemplate(string path, FluidParser parser)
{
var meta_string = File.ReadAllText(path);
meta_string = Gen.PreprocessTemplate(meta_string, "\t", "\r\n");
parser.TryParse(meta_string, out template, out var error);
options.MemberAccessStrategy.Register<FieldMetaData>();
if (!string.IsNullOrEmpty(error))
{
Console.WriteLine(error);
@ -50,45 +34,24 @@ namespace refl
}
return true;
}
public bool GenClassMeta(ClassMeta cls, ClassMetaData data)
public string GenClassMeta(ClassMeta cls, string fullName, bool isMulty)
{
data.Name = cls.Name;
data.ParentName = cls.ParentName;
bool isMulty = cls.Fields.Count > 1;
if(cls.Fields.Count == 1)
{
isMulty = cls.Fields.Keys.First() != "Meta";
}
meta.ParentName = cls.ParentName;
meta.Name = cls.Name;
meta.FullName = fullName;
meta.IsMultyMeta = isMulty;
meta.HasMeta = false;
meta.HasParent = cls.ParentName != "void";
foreach (var pair in cls.Fields)
{
data.FieldList.Clear();
foreach (var field in pair.Value.MemberList)
if (pair.Key.Equals("Meta"))
{
data.FieldList.Add(new FieldMetaData(field, 1));
meta.HasMeta = true;
}
foreach (var field in pair.Value.CtorList)
{
data.FieldList.Add(new FieldMetaData(field, 2));
meta.MetaList.Add(pair.Key);
}
foreach (var field in pair.Value.MethodList)
{
int type = string.IsNullOrEmpty(field.Ref) ? 3 : 4;
data.FieldList.Add(new FieldMetaData(field, type));
}
data.MemberCount = pair.Value.MemberList.Count;
data.CtorCount = pair.Value.CtorList.Count;
data.MetaType = isMulty ? 1 : 0;
if (isMulty && pair.Key.Equals("Meta"))
{
data.MetaType = 2;
}
data.MetaName = pair.Key;
var context = new TemplateContext(data, options);
var res = template.Render(context);
Gen.FileList[pair.Key].Append(res);
Gen.FileList[pair.Key].AppendLine("");
}
return isMulty;
var context = new TemplateContext(meta, options);
return template.Render(context);
}
}
}

80
src/refl/GenMetaImpl.cs
View File

@ -1,31 +1,46 @@
using Fluid;
using System;
using System.Collections.Generic;
using System.Linq;
using System.IO;
using System.Text;
using System.Threading.Tasks;
using static System.Runtime.InteropServices.JavaScript.JSType;
using System.Xml.Linq;
using Fluid;
namespace refl
{
internal class MetaImplClassData
internal class FieldMetaImplData
{
public string Name { get; set; }
public string Meta { get; set; }
public string Ref { get; set; }
public int Type { get; set; }
public FieldMetaImplData(FieldData data, int type)
{
Name = data.Name;
Meta = data.Meta;
Ref = data.Ref;
Type = type;
}
}
internal class ClassMetaImplData
{
public string Name { get; set; } = "";
public string FullName { get; set; } = "";
public bool IsMultyMeta { get; set; } = false;
public bool HasMeta { get; set; } = false;
public string MetaName { get; set; } = "";
public int MetaType { get; set; } = 0;
public int MemberCount { get; set; } = 0;
public int CtorCount { get; set; } = 0;
public List<FieldMetaImplData> FieldList = new List<FieldMetaImplData>();
}
internal class GenMetaImpl
{
private static IFluidTemplate? template;
private static TemplateOptions options = new TemplateOptions();
private MetaImplClassData impl = new MetaImplClassData();
public static bool InitTemplate(string path, FluidParser parser)
{
var meta_string = File.ReadAllText(path);
meta_string = Gen.PreprocessTemplate(meta_string, "\t", "\r\n");
parser.TryParse(meta_string, out template, out var error);
options.MemberAccessStrategy.Register<FieldMetaImplData>();
if (!string.IsNullOrEmpty(error))
{
Console.WriteLine(error);
@ -33,21 +48,44 @@ namespace refl
}
return true;
}
public string GenClassMeta(ClassMeta cls,string fullName, bool isMulty)
public bool GenClassMeta(ClassMeta cls, ClassMetaImplData data)
{
impl.Name = cls.Name;
impl.FullName = fullName;
impl.IsMultyMeta = isMulty;
impl.HasMeta = false;
data.Name = cls.Name;
bool isMulty = cls.Fields.Count > 1;
if (cls.Fields.Count == 1)
{
isMulty = cls.Fields.Keys.First() != "Meta";
}
foreach (var pair in cls.Fields)
{
if (pair.Key.Equals("Meta"))
data.FieldList.Clear();
foreach (var field in pair.Value.MemberList)
{
impl.HasMeta = true;
data.FieldList.Add(new FieldMetaImplData(field, 1));
}
foreach (var field in pair.Value.CtorList)
{
data.FieldList.Add(new FieldMetaImplData(field, 2));
}
var context = new TemplateContext(impl, options);
return template.Render(context);
foreach (var field in pair.Value.MethodList)
{
int type = string.IsNullOrEmpty(field.Ref) ? 3 : 4;
data.FieldList.Add(new FieldMetaImplData(field, type));
}
data.MemberCount = pair.Value.MemberList.Count;
data.CtorCount = pair.Value.CtorList.Count;
data.MetaType = isMulty ? 1 : 0;
if (isMulty && pair.Key.Equals("Meta"))
{
data.MetaType = 2;
}
data.MetaName = pair.Key;
var context = new TemplateContext(data, options);
var res = template.Render(context);
Gen.FileList[pair.Key].Append(res);
Gen.FileList[pair.Key].AppendLine("");
}
return isMulty;
}
}
}

46
src/refl/GenMultyMeta.cs
View File

@ -1,46 +0,0 @@
using Fluid;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace refl
{
internal class MultyMetaClassData
{
public string Name { get; set; } = "";
public string FullName { get; set; } = "";
public List<string> MetaList = new List<string>();
}
internal class GenMultyMeta
{
private static IFluidTemplate? template;
private static TemplateOptions options = new TemplateOptions();
public static bool InitTemplate(string path, FluidParser parser)
{
var meta_string = File.ReadAllText(path);
meta_string = Gen.PreprocessTemplate(meta_string, "\t", "\r\n");
parser.TryParse(meta_string, out template, out var error);
if (!string.IsNullOrEmpty(error))
{
Console.WriteLine(error);
return false;
}
return true;
}
public string GenClassMeta(ClassMeta cls, string fullName)
{
MultyMetaClassData data = new MultyMetaClassData();
data.Name = cls.Name;
data.FullName = fullName;
foreach (var pair in cls.Fields)
{
data.MetaList.Add(pair.Key);
}
var context = new TemplateContext(data, options);
return template.Render(context);
}
}
}

2
src/refl/_install.bat
View File

@ -1,6 +1,6 @@
@echo off
set "source_dir=%CD%" REM 当前目录
set "destination_dir=F:\ouczbs\zengine\tools\refl" REM 指定目标目录
set "destination_dir=F:\engine\zengine\tools\refl" REM 指定目标目录
xcopy "%source_dir%\bin\Release\net8.0\win-x64\*" "%destination_dir%\" /Y
xcopy "%source_dir%\template\*" "%destination_dir%\template\" /Y
pause

7
src/refl/cpp/macro.h
View File

@ -1,9 +1,7 @@
#pragma once
#if !defined(__cppast)
#define __cppast(...)
#else
#endif
#define __Meta(...) __cppast(Meta=__VA_ARGS__)
#define UPROPERTY(...) __Meta(__VA_ARGS__)
#define UFUNCTION(...) __Meta(__VA_ARGS__)
@ -39,8 +37,3 @@ struct vec3{
vec3(){}
}
*/
namespace refl_impl {
struct Meta {};
struct vkMeta {};
struct dxMeta {};
}

44
src/refl/cpp/vertex.h
View File

@ -2,10 +2,42 @@
#include "type.h"
#include "guid.h"
#include "resource_bundle.h"
namespace api {
using pmr::Name;
enum class EModuleFlag : uint32_t {
Reload = 1,
};
ENABLE_BITMASK_OPERATORS(EModuleFlag);
struct ModuleInfo {
UPROPERTY()
EModuleFlag flag{ 0 };
UPROPERTY()
Name name; //!< name of the plugin
UPROPERTY()
Name prettyname; //!< formatted name of the plugin
UPROPERTY()
Name core_version; //!< version of the engine
UPROPERTY()
Name version; // !< version of the plugin
UPROPERTY()
Name linking; // !< linking of the plugin
UPROPERTY()
Name license; //!< license of the plugin
UPROPERTY()
Name url; //!< url of the plugin
UPROPERTY()
Name copyright; //!< copyright of the plugin
public:
bool IsReload() {
return !!(flag & EModuleFlag::Reload);
}
};
}
namespace engineapi
{
struct SerializedMeta
{
UPROPERTY_vk({})
UPROPERTY({})
Guid guid;
UPROPERTY({})
@ -13,10 +45,12 @@ namespace engineapi
UPROPERTY({})
string t_hash{};
UPROPERTY({})
string metadata;
refl::Any meta;
bool operator==(const SerializedMeta& other)const {
return guid == other.guid && name == other.name && t_hash == other.t_hash;
}
};
struct ResourceBundle;
struct MetaBundle
{
UPROPERTY({})
@ -26,6 +60,12 @@ namespace engineapi
template<typename T>
const SerializedMeta* FetchMeta() const;
template<typename T>
const SerializedMeta* FetchMeta(const string_view& asset_name) const;
template<typename T>
void Add(RscHandle<T>);
bool operator==(const MetaBundle& other)const;
bool operator!=(const MetaBundle& other)const;
};
}
#include "meta_bundle.inl"

90
src/refl/template/meta.liquid
View File

@ -1,66 +1,24 @@
{{ Indent }}template<> struct _Static<{{FullName}},{{MetaName}}> {
{{ Indent }} using T = {{FullName}};
{{ Indent }} consteval static auto __MakeStaticFields() {
{{ Indent }} return std::array{
{{ Indent }} {%- for field in FieldList %}
{{ Indent }} {%- if field.Type == 1 %}
{{ Indent }} refl::StaticMemberField(&T::{{field.Name}}, FName("{{field.Name}}"), {{field.Meta}}),
{{ Indent }} {%- elsif field.Type == 2 %}
{{ Indent }} refl::StaticCtorField((T::{{field.Ref}})nullptr,{{field.Meta}}),
{{ Indent }} {%- elsif field.Type == 3 %}
{{ Indent }} refl::StaticMethodField(&T::{{field.Name}}, FName("{{field.Name}}"), {{field.Meta}}),
{{ Indent }} {%- else %}
{{ Indent }} refl::StaticMethodField((T::{{field.Ref}})&T::{{field.Name}}, FName("{{field.Name}}"), {{field.Meta}}),
{{ Indent }} {%- endif %}
{{ Indent }} {%- endfor %}
{{ Indent }} };
{{ Indent }} };
{{ Indent }}
{{ Indent }} consteval static int Size() {
{{ Indent }} return refl::fetch_meta_size<_Static<T,{{MetaName}}>>();
{{ Indent }} };
{{ Indent }} consteval static int MemberCount() {
{{ Indent }} return {{MemberCount}};
{{ Indent }} };
{{ Indent }} consteval static int CtorCount() {
{{ Indent }} return {{CtorCount}};
{{ Indent }} };
{{ Indent }}};
{{ Indent }}
{{ Indent }}template<> struct _Meta<{{FullName}},{{MetaName}}> : public refl::MetaHelp {
{{ Indent }} using T = {{FullName}};
{{ Indent }} using MyParent = {{ ParentName }};
{{ Indent }} using MyStatic = _Static<T,{{MetaName}}>;
{{ Indent }}{%-if IsMultyMeta %}
{{ Indent }} using MyMetas = class _Multy<T>;
{{ Indent }}{%- endif %}
{{ Indent }} inline static char s_data[MyStatic::Size()]{};
{{ Indent }} static auto __MakeFields() {
{{ Indent }} char* memory = &s_data[0];
{{ Indent }} return std::array{
{{ Indent }} {%- for field in FieldList %}
{{ Indent }} {%- if field.Type == 1 %}
{{ Indent }} MemberField(&T::{{field.Name}}, FName("{{field.Name}}"), memory, {{field.Meta}}),
{{ Indent }} {%- elsif field.Type == 2 %}
{{ Indent }} CtorField((T::{{field.Ref}})nullptr, memory, {{field.Meta}}),
{{ Indent }} {%- elsif field.Type == 3 %}
{{ Indent }} MethodField(&T::{{field.Name}}, FName("{{field.Name}}"), memory, {{field.Meta}}),
{{ Indent }} {%- else %}
{{ Indent }} MethodField((T::{{field.Ref}})&T::{{field.Name}}, FName("{{field.Name}}"), memory, {{field.Meta}}),
{{ Indent }} {%- endif %}
{{ Indent }} {%- endfor %}
{{ Indent }} };
{{ Indent }} };
{{ Indent }}};
{{ Indent }}{%- if MetaType == 1 %}
{{ Indent }}const refl::UClass* _Multy<{{FullName}}>::get_{{ MetaName }}()
{{ Indent }}{
{{ Indent }} static const auto s_cls = refl::UClass_Meta<T, _Meta<T,{{ MetaName }}>>();
{{ Indent }} return &s_cls;
{{ Indent }}};
{{ Indent }}{%- elsif MetaType == 2 %}
{{ Indent }}inline const refl::UClass* _Multy<{{FullName}}>::get_{{ MetaName }}()
{{ Indent }}{
{{ Indent }} return &refl::TypeInfo<T>::StaticClass;
{{ Indent }}};
{{ Indent }}{%- endif %}
namespace refl{
template<> struct Meta<{{FullName}}>{
{%- if HasParent %}
using Parent = {{ ParentName }};
{%- endif %}
using T = {{FullName}};
{%- if HasMeta %}
using Impl = gen::MetaImpl<T, string_hash("Meta")>;
{%- endif %}
{%- if IsMultyMeta %}
{%- for Meta in MetaList %}
static const UClass* get_{{Meta}}();
{%- endfor %}
static const UClass* GetMeta(Name name) {
{%- for Meta in MetaList %}
if (name == string_hash("{{Meta}}")) {
return get_{{Meta}}();
}
{%- endfor %}
return nullptr;
}
{%- endif %}
};
}

50
src/refl/template/meta_impl.liquid
View File

@ -1,9 +1,41 @@
{{ Indent }}template<> struct MetaImpl<{{FullName}}>{
{{ Indent }} using T = {{FullName}};
{{ Indent }}{%- if HasMeta %}
{{ Indent }} using MyMeta = _Meta<T, Meta>;
{{ Indent }}{%- endif %}
{{ Indent }}{%- if IsMultyMeta %}
{{ Indent }} using MyMetas = _Multy<T>;
{{ Indent }}{%- endif %}
{{ Indent }}};
namespace gen{
template<> struct MetaImpl<{{FullName}}, string_hash("{{MetaName}}")> : public refl::MetaHelp {
using T = {{FullName}};
consteval static int MemberCount() { return {{MemberCount}}; };
consteval static int CtorCount() { return {{CtorCount}}; };
consteval static auto Fields(){
return std::make_tuple({% for field in FieldList %}FProperty(&T::{{field.Name}},"{{field.Name}}"){% unless forloop.last %}, {% endunless %}{% endfor %});
}
static auto MakeFields() {
return std::array{
{%- for field in FieldList %}
{%- if field.Type == 1 %}
MemberField(&T::{{field.Name}}, FName("{{field.Name}}"), {{field.Meta}}),
{%- elsif field.Type == 2 %}
CtorField((T::{{field.Ref}})nullptr, {{field.Meta}}),
{%- elsif field.Type == 3 %}
MethodField(&T::{{field.Name}}, FName("{{field.Name}}"), {{field.Meta}}),
{%- else %}
MethodField((T::{{field.Ref}})&T::{{field.Name}}, FName("{{field.Name}}"), {{field.Meta}}),
{%- endif %}
{%- endfor %}
};
};
};
}
{%- if MetaType == 1 %}
namespace refl{
const UClass* Meta<{{FullName}}>::get_{{ MetaName }}()
{
static const UClass_Meta<T, gen::MetaImpl<T, string_hash("{{ MetaName }}")>> s_cls{};
return &s_cls;
};
}
{%- elsif MetaType == 2 %}
namespace refl{
inline const UClass* Meta<{{FullName}}>::get_{{ MetaName }}()
{
return &TypeInfo<T>::StaticClass;
};
}
{%- endif %}

14
src/refl/template/multy_meta.liquid
View File

@ -1,14 +0,0 @@
{{ Indent }}template<> struct _Multy<{{FullName}}>{
{{ Indent }} using T = {{FullName}};
{{ Indent }}{%- for Meta in MetaList %}
{{ Indent }} static const refl::UClass* get_{{Meta}}();
{{ Indent }}{%- endfor %}
{{ Indent }} static const refl::UClass* GetMeta(const Name& name) {
{{ Indent }}{%- for Meta in MetaList %}
{{ Indent }} if (name == FName("{{Meta}}")) {
{{ Indent }} return get_{{Meta}}();
{{ Indent }} }
{{ Indent }}{%- endfor %}
{{ Indent }} return nullptr;
{{ Indent }} }
{{ Indent }}};