public void EnterType(Metadata.DB_Type type)
{
if (string.IsNullOrEmpty(outNamespace))
{
Console.Error.WriteLine("未指定外部命名空间");
}
currentType = type;
}
void ConvertMemberCpp(Metadata.DB_Member member)
{
Metadata.DB_Type member_type = Model.GetType(member.typeName);
if (member.member_type == (int)Metadata.MemberTypes.Field)
{
if (member.is_static)
{
if (member_type.is_class)
{
AppendLine("Ref<" + GetCppTypeName(Model.GetType(member.type)) + "> " + GetCppTypeName(Model.GetType(member.declaring_type)) + "::" + member.name + ";");
}
else if (member_type.is_value_type)
{
Append(GetCppTypeName(Model.GetType(member.type)) + " " + GetCppTypeName(Model.GetType(member.declaring_type)) + "::" + member.name);
if (member.field_initializer != null)
{
sb.Append("=");
sb.Append(ExpressionToString(member.field_initializer));
}
sb.AppendLine(";");
}
}
}
else if (member.member_type == (int)Metadata.MemberTypes.Method)
{
Model.EnterMethod(member);
Metadata.DB_Type declare_type = Model.GetType(member.declaring_type);
if (!declare_type.is_generic_type_definition && member.method_body != null)
{
if (member.member_type == (int)Metadata.MemberTypes.Method)
{
sb.Append(string.Format("{0} {1}::{2}", member.type.IsVoid ? "void" : GetCppTypeWrapName(Model.GetType(member.type)), GetCppTypeName(Model.GetType(member.declaring_type)), member.name));
}
else
{
sb.Append(string.Format("{1}::{2}", "", GetCppTypeName(Model.GetType(member.declaring_type)), member.name));
}
sb.Append("(");
if (member.method_args != null)
{
for (int i = 0; i < member.method_args.Length; i++)
{
sb.Append(string.Format("{0} {1} {2}", GetCppTypeWrapName(Model.GetType(member.method_args[i].type)), member.method_args[i].is_ref ? "&" : "", member.method_args[i].name));
if (i < member.method_args.Length - 1)
{
sb.Append(",");
}
}
}
sb.AppendLine(")");
ConvertStatement(member.method_body);
}
Model.LeaveMethod();
}
}
public bool SupportType(IConverter Converter, Metadata.DB_Type type)
{
switch (type.name)
{
case "int32":
case "Object":
return(true);
}
return(false);
}
string GetCppTypeName(Metadata.DB_Type type)
{
ITypeConverter tc = Converter.GetTypeConverter(type);
if (tc != null)
{
string name;
if (tc.GetCppTypeName(out name))
{
return(name);
}
}
if (type.is_generic_paramter)
{
return(type.name);
}
if (type.is_generic_type)
{
StringBuilder sb = new StringBuilder();
//sb.Append(type._namespace);
//sb.Append("::");
sb.Append(type.name);
sb.Append("<");
for (int i = 0; i < type.generic_parameters.Count; i++)
{
sb.Append(GetCppTypeName(Model.GetType(type.generic_parameters[i])));
if (i < type.generic_parameters.Count - 1)
{
sb.Append(",");
}
}
sb.Append(">");
return(sb.ToString());
}
if (type.is_interface)
{
return /*type._namespace + "::" +*/ (type.name);
}
if (type.is_class)
{
return /*type._namespace + "::" +*/ (type.name);
}
if (type.is_value_type)
{
return /*type._namespace + "::" +*/ (type.name);
}
if (type.is_enum)
{
return /*type._namespace + "::" +*/ (type.name);
}
return(type.static_full_name);
}
public bool ConvertMethodExp(IConverter Converter, Metadata.DB_Type type, Metadata.Expression.MethodExp me, out string exp_string)
{
if (type.name == "Object")
{
if (me.Name == "ToString")
{
exp_string = string.Format("Object::ToString({1})", Converter.ExpressionToString(me.Caller));
return(true);
}
}
exp_string = "";
return(false);
}
public string GetTypeHeader(Metadata.DB_Type type)
{
TypeConfig tc = Converter.GetTypeConfig(type);
if (tc != null)
{
if (!string.IsNullOrEmpty(tc.header_path))
{
return(tc.header_path);
}
}
return(type.name + ".h");
}
string GetCppTypeWrapName(Metadata.DB_Type type)
{
if (type.GetRefType().IsVoid)
{
return("void");
}
if (type.is_value_type)
{
return(GetCppTypeName(type));
}
else
{
return(string.Format("{0}*", GetCppTypeName(type)));
}
}
public bool GetCppTypeName(IConverter Converter, Metadata.DB_Type type, out string name)
{
switch (type.name)
{
case "int32":
name = "UE_Int32";
break;
case "Object":
name = "UObject";
break;
default:
name = "";
return(false);
}
return(true);
}
void ConvertStatement(Metadata.DB_LocalDeclarationStatementSyntax bs)
{
Metadata.DB_Type type = Model.GetType(bs.Declaration.Type);
if (type.is_class)
{
Append("Ref<" + GetCppTypeName(type) + "> ");
}
else
{
Append(GetCppTypeName(type) + " ");
}
for (int i = 0; i < bs.Declaration.Variables.Count; i++)
{
sb.Append(ExpressionToString(bs.Declaration.Variables[i]));
if (i < bs.Declaration.Variables.Count - 2)
{
sb.Append(",");
}
Model.AddLocal(bs.Declaration.Variables[i].Identifier, Model.GetType(bs.Declaration.Type));
}
sb.AppendLine(";");
}
public void ConvertType(Metadata.DB_Type type)
{
string outputDir = Converter.GetProject().output_dir;
ITypeConverter tc = Converter.GetTypeConverter(type);
if (tc != null)
{
sb.Clear();
string content;
if (tc.ConvertTypeHeader(Converter, type, out content))
{
sb.Append(content);
System.IO.File.WriteAllText(System.IO.Path.Combine(outputDir, GetTypeHeader(type)), sb.ToString());
}
sb.Clear();
if (tc.ConvertTypeCpp(Converter, type, out content))
{
sb.Append(content);
System.IO.File.WriteAllText(System.IO.Path.Combine(outputDir, type.name + ".cpp"), sb.ToString());
}
}
else
{
sb.Clear();
ConvertTypeHeader(type);
//sb.Append(ConvertTypeHeader(type));
System.IO.File.WriteAllText(System.IO.Path.Combine(outputDir, GetTypeHeader(type)), sb.ToString());
sb.Clear();
ConvertTypeCpp(type);
//sb.Append(ConvertTypeCpp(type));
System.IO.File.WriteAllText(System.IO.Path.Combine(outputDir, type.name + ".cpp"), sb.ToString());
}
}
public void LeaveType()
{
currentType = null;
}
public bool ConvertTypeHeader(IConverter Converter, Metadata.DB_Type type, out string header)
{
header = "";
return(false);
}
public IndifierInfo GetIndifierInfo(string name, string name_space = "", EIndifierFlag flag = EIndifierFlag.IF_All)
{
IndifierInfo info = new IndifierInfo();
//在指定的命名空间查找标示符
if (!string.IsNullOrEmpty(name_space))
{
DB_Type type = Finder.FindType(name_space + "." + name);
if (type != null)
{
info.is_type = true;
info.type = type;
return(info);
}
return(null);
}
//查找本地变量
foreach (var v in stackLocalVariables)
{
if (v.ContainsKey(name))
{
info.is_var = true;
info.type = v[name];
return(info);
}
}
//泛型参数
if (currentMethod != null)
{
foreach (var gd in currentMethod.method_generic_parameter_definitions)
{
if (gd.type_name == name)
{
info.is_method_type_parameter = true;
Metadata.DB_Type constraintType = Finder.FindType(gd.constraint, this);
info.type = Metadata.DB_Type.MakeGenericParameterType(constraintType, name);
return(info);
}
}
}
//查找成员变量
if (currentType != null)
{
if ((flag & EIndifierFlag.IF_Local) != 0)
{
if (currentType.FindField(name, this) != null)
{
info.is_field = true;
info.type = GetType(currentType.FindField(name, this).typeName);
return(info);
}
if (currentType.FindProperty(name, this) != null)
{
info.is_property = true;
info.type = GetType(currentType.FindProperty(name, this).typeName);
return(info);
}
if (currentType.FindEvent(name, this) != null)
{
info.is_event = true;
info.type = GetType(currentType.FindEvent(name, this).typeName);
return(info);
}
}
if ((flag & EIndifierFlag.IF_Method) != 0)
{
List <DB_Member> methods = currentType.FindMethod(name, this);
if (methods.Count > 0)
{
info.is_method = true;
info.methods = methods;
return(info);
}
}
if ((flag & EIndifierFlag.IF_Type) != 0)
{
//查找泛型
if (currentType.is_generic_type_definition)
{
foreach (var gd in currentType.generic_parameter_definitions)
{
if (gd.type_name == name)
{
info.is_class_type_parameter = true;
Metadata.DB_Type constraintType = Finder.FindType(gd.constraint, this);
info.type = Metadata.DB_Type.MakeGenericParameterType(constraintType, name);
return(info);
}
}
}
else if (currentType.is_generic_type)
{
//泛型实例，已经被替换了参数，所以无需查找
}
//当前命名空间查找
foreach (var nsName in currentType.usingNamespace)
{
DB_Type type = FindTypeInNamespace(name, nsName);
if (type != null)
{
info.is_type = true;
info.type = type;
return(info);
}
}
}
}
if ((flag & EIndifierFlag.IF_Type) != 0)
{
//当前命名空间查找
if (!string.IsNullOrEmpty(outNamespace))
{
DB_Type type = FindTypeInNamespace(name, outNamespace);
if (type != null)
{
info.is_type = true;
info.type = type;
return(info);
}
}
foreach (var nsName in usingNamespace)
{
DB_Type type = FindTypeInNamespace(name, nsName);
if (type != null)
{
info.is_type = true;
info.type = type;
return(info);
}
}
}
return(null);
}
public DB_Type GetExpType(Expression.Exp exp, Expression.Exp outer = null)
{
if (exp is Metadata.Expression.ConstExp)
{
Metadata.Expression.ConstExp e = exp as Metadata.Expression.ConstExp;
int int_v;
if (int.TryParse(e.value, out int_v))
{
return(GetType("System.Int32"));
}
long long_v;
if (long.TryParse(e.value, out long_v))
{
return(GetType("System.Int64"));
}
bool b_v;
if (bool.TryParse(e.value, out b_v))
{
return(GetType("System.Boolean"));
}
float single_v;
if (float.TryParse(e.value, out single_v))
{
return(GetType("System.Single"));
}
double double_v;
if (double.TryParse(e.value, out double_v))
{
return(GetType("System.Double"));
}
if (e.value == "null")
{
return(GetType("System.Object"));
}
if (e.value.StartsWith("'"))
{
return(GetType("System.Char"));
}
return(GetType("System.String"));
}
else if (exp is Metadata.Expression.FieldExp)
{
Metadata.Expression.FieldExp e = exp as Metadata.Expression.FieldExp;
Metadata.DB_Type caller_type = GetExpType(e.Caller);
if (outer is MethodExp)
{
MethodExp methodExp = outer as MethodExp;
List <Metadata.DB_Type> argTypes = new List <Metadata.DB_Type>();
foreach (var t in methodExp.Args)
{
argTypes.Add(GetExpType(t));
}
Metadata.DB_Member member = caller_type.FindMethod(e.Name, argTypes, this);
return(GetType(member.typeName));
}
else
{
DB_Member field = caller_type.FindField(e.Name, this);
if (field == null)
{
field = caller_type.FindProperty(e.Name, this);
}
if (field == null)
{
return(null);
}
return(GetType(field.typeName));
}
}
else if (exp is Metadata.Expression.IndifierExp)
{
Metadata.Expression.IndifierExp e = exp as Metadata.Expression.IndifierExp;
IndifierInfo info = GetIndifierInfo(e.Name);
//if(outer is MethodExp)
//{
// MethodExp methodExp = outer as MethodExp;
// List<Metadata.DB_Type> argTypes = new List<Metadata.DB_Type>();
// foreach (var t in methodExp.Args)
// {
// argTypes.Add(GetExpType(t));
// }
// foreach(var m in info.methods)
// {
// if(m.MatchingParameter(argTypes,this))
// {
// return GetType(m.typeName);
// }
// }
//}
//else
{
return(info.type);
}
}
else if (exp is Metadata.Expression.MethodExp)
{
Metadata.Expression.MethodExp me = exp as Metadata.Expression.MethodExp;
List <Metadata.DB_Type> argTypes = new List <Metadata.DB_Type>();
foreach (var t in me.Args)
{
argTypes.Add(GetExpType(t));
}
if (me.Caller is FieldExp)
{
FieldExp fe = me.Caller as FieldExp;
Metadata.DB_Type caller_type = GetExpType(fe.Caller, fe);
return(GetType(caller_type.FindMethod(fe.Name, argTypes, this).typeName));
}
else if (me.Caller is IndifierExp)
{
IndifierExp ie = me.Caller as IndifierExp;
IndifierInfo info = GetIndifierInfo(ie.Name);
if (info.is_method)
{
foreach (var m in info.methods)
{
if (m.MatchingParameter(argTypes, this))
{
return(GetType(m.typeName));
}
}
}
else
{
return(info.type);
}
}
}
else if (exp is Metadata.Expression.ObjectCreateExp)
{
Metadata.Expression.ObjectCreateExp e = exp as Metadata.Expression.ObjectCreateExp;
return(GetType(e.Type));
}
else if (exp is Metadata.Expression.BaseExp)
{
return(GetType(currentType.base_type));
}
else if (exp is Metadata.Expression.ThisExp)
{
return(currentType);
}
else if (exp is Metadata.Expression.BinaryExpressionSyntax)
{
Metadata.Expression.BinaryExpressionSyntax me = exp as Metadata.Expression.BinaryExpressionSyntax;
Metadata.DB_Type caller_type = GetExpType(me.Left);
List <Metadata.DB_Type> argTypes = new List <Metadata.DB_Type>();
argTypes.Add(GetExpType(me.Right));
Metadata.DB_Member member = caller_type.FindMethod(me.OperatorToken, argTypes, this);
return(GetType(member.typeName));
}
else if (exp is Metadata.Expression.PostfixUnaryExpressionSyntax)
{
Metadata.Expression.PostfixUnaryExpressionSyntax me = exp as Metadata.Expression.PostfixUnaryExpressionSyntax;
Metadata.DB_Type caller_type = GetExpType(me.Operand);
List <Metadata.DB_Type> argTypes = new List <Metadata.DB_Type>();
argTypes.Add(caller_type);
Metadata.DB_Member member = caller_type.FindMethod(me.OperatorToken, argTypes, this);
return(GetType(member.typeName));
}
else if (exp is Metadata.Expression.PrefixUnaryExpressionSyntax)
{
Metadata.Expression.PrefixUnaryExpressionSyntax me = exp as Metadata.Expression.PrefixUnaryExpressionSyntax;
Metadata.DB_Type caller_type = GetExpType(me.Operand);
List <Metadata.DB_Type> argTypes = new List <Metadata.DB_Type>();
argTypes.Add(caller_type);
Metadata.DB_Member member = caller_type.FindMethod(me.OperatorToken, argTypes, this);
return(GetType(member.typeName));
}
else if (exp is Metadata.Expression.ParenthesizedExpressionSyntax)
{
Metadata.Expression.ParenthesizedExpressionSyntax pes = exp as Metadata.Expression.ParenthesizedExpressionSyntax;
return(GetExpType(pes.exp));
}
else if (exp is Metadata.Expression.ElementAccessExp)
{
Metadata.Expression.ElementAccessExp eae = exp as Metadata.Expression.ElementAccessExp;
Metadata.DB_Type caller_type = GetExpType(eae.exp);
List <Metadata.DB_Type> argTypes = new List <Metadata.DB_Type>();
foreach (var a in eae.args)
{
argTypes.Add(GetExpType(a));
}
return(GetType(caller_type.FindProperty("Index", this).type));
//string methodName = "";
//if(outer is Metadata.Expression.AssignmentExpressionSyntax && ((Metadata.Expression.AssignmentExpressionSyntax)outer).Left == exp)
//{
// methodName = "set_Index";
//}
//else
//{
// methodName = "get_Index";
//}
//Metadata.DB_Member member = caller_type.FindMethod(methodName, argTypes, this);
//return GetType(member.typeName);
}
else
{
Console.Error.WriteLine("无法确定表达式类型 " + exp.GetType().Name);
}
return(null);
}
public void AddLocal(string name, Metadata.DB_Type type)
{
stackLocalVariables.Peek().Add(name, type);
}
string ExpressionToString(Metadata.Expression.FieldExp es)
{
ITypeConverter tc = Converter.GetTypeConverter(Model.currentType);
if (tc != null)
{
string content;
if (tc.ConvertFieldExp(Converter, Model.currentType, es, out content))
{
return(content);
}
}
if (es.Caller == null) //本地变量或者类变量，或者全局类
{
return(es.Name);
}
else
{
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.Append(ExpressionToString(es.Caller));
Metadata.DB_Type caller_type = null;
if (es.Caller is Metadata.Expression.IndifierExp)
{
Metadata.Expression.IndifierExp ie = es.Caller as Metadata.Expression.IndifierExp;
Metadata.Model.IndifierInfo ii = Model.GetIndifierInfo(ie.Name);
if (ii.is_namespace || ii.is_type)
{
stringBuilder.Append("::");
caller_type = null;
}
else
{
caller_type = ii.type;
}
}
else
{
caller_type = Model.GetExpType(es.Caller);
}
if (caller_type != null)
{
if (caller_type.is_class)
{
//Metadata.DB_Member member = caller_type.members[es.Name];
//if (member.is_static)
stringBuilder.Append("->");
//else if (member.member_type == (int)Metadata.MemberTypes.Method)
//{
//}
}
else
{
stringBuilder.Append(".");
}
}
stringBuilder.Append(es.Name);
return(stringBuilder.ToString());
}
}
public void ConvertTypeHeader(Metadata.DB_Type type)
{
Model.EnterType(type);
//头文件
{
sb.Clear();
sb.AppendLine("#pragma once");
//包含头文件
HashSet <string> depTypes = Converter.GetTypeDependences(type);
HashSet <string> NoDeclareTypes = Converter.GetTypeDependencesNoDeclareType(type);
foreach (var t in depTypes)
{
Metadata.DB_Type depType = Model.GetType(t);
if (!depType.is_generic_paramter && t != type.static_full_name)
{
if (NoDeclareTypes.Contains(t))
{
sb.AppendLine("#include \"" + GetTypeHeader(depType) + "\"");
}
else
{
//前向声明
//sb.AppendLine("namespace " + depType._namespace);
//sb.AppendLine("{");
if (depType.is_generic_type_definition)
{
sb.Append("template");
sb.Append("<");
for (int i = 0; i < depType.generic_parameter_definitions.Count; i++)
{
sb.Append(depType.generic_parameter_definitions[i].type_name);
if (i < depType.generic_parameter_definitions.Count - 1)
{
sb.Append(",");
}
}
sb.AppendLine(">");
if (depType.is_value_type)
{
sb.AppendLine("struct " + depType.name + ";");
}
else
{
sb.AppendLine("class " + depType.name + ";");
}
}
else
{
if (depType.is_value_type)
{
sb.AppendLine("struct " + depType.name + ";");
}
else
{
sb.AppendLine("class " + depType.name + ";");
}
}
//sb.AppendLine("}");
}
}
}
if (HasCppAttribute(type.attributes))
{
//包含虚幻生成的头文件
AppendLine(string.Format("#include \"{0}.generated.h\"", type.name));
//属性
AppendLine(ConvertCppAttribute(type.attributes));
}
//sb.AppendLine(string.Format("namespace {0}{{", type._namespace));
{
//depth++;
if (type.is_enum)
{
Append(string.Format("enum {0}", type.name));
}
else
{
if (type.is_generic_type_definition)
{
Append("template<");
for (int i = 0; i < type.generic_parameter_definitions.Count; i++)
{
sb.Append("class " + type.generic_parameter_definitions[i].type_name);
if (i < type.generic_parameter_definitions.Count - 1)
{
sb.Append(",");
}
}
sb.AppendLine(">");
}
else if (type.is_value_type)
{
Append(string.Format("struct {0}", type.name));
}
else
{
Append(string.Format("class {0}", type.name));
}
if (!type.base_type.IsVoid && !type.is_value_type || type.interfaces.Count > 0)
{
sb.Append(":");
if (!type.base_type.IsVoid && !type.is_value_type)
{
sb.Append("public " + GetCppTypeName(Model.GetType(type.base_type)));
if (type.interfaces.Count > 0)
{
sb.Append(",");
}
}
for (int i = 0; i < type.interfaces.Count; i++)
{
sb.Append("public " + GetCppTypeName(Model.GetType(type.interfaces[i])));
if (i < type.interfaces.Count - 1)
{
sb.Append(",");
}
}
sb.AppendLine();
}
}
AppendLine("{");
{
depth++;
if (type.is_enum)
{
List <Metadata.DB_Member> members = type.members.Values.ToList();
//members.Sort((a, b) => { return a.order <= b.order ? -1 : 1; });
for (int i = 0; i < members.Count; i++)
{
Append(members[i].name);
if (i < members.Count - 1)
{
sb.Append(",");
}
sb.AppendLine();
}
}
else
{
if (HasCppAttribute(type.attributes))
{
AppendLine("GENERATED_BODY()");
}
foreach (var m in type.members.Values)
{
ConvertMemberHeader(m);
}
}
depth--;
}
TypeConfig tc = Converter.GetTypeConfig(type);
if (tc != null)
{
if (!string.IsNullOrEmpty(tc.ext_header))
{
AppendLine("#include \"" + tc.ext_header + "\"");
}
}
AppendLine("};");
//depth--;
}
//sb.AppendLine("}");
//System.IO.File.WriteAllText(System.IO.Path.Combine(outputDir, GetTypeHeader(type)), sb.ToString());
Model.LeaveType();
//return sb.ToString();
}
}
public bool ConvertTypeCpp(IConverter Converter, Metadata.DB_Type type, out string cpp)
{
cpp = "";
return(false);
}
void ConvertMemberHeader(Metadata.DB_Member member)
{
Metadata.DB_Type member_type = Model.GetType(member.typeName);
if (member.member_type == (int)Metadata.MemberTypes.Field)
{
AppendLine(GetModifierString(member.modifier) + ":");
//属性
AppendLine(ConvertCppAttribute(member.attributes));
if (member.is_static)
{
Append("static ");
}
else
{
Append("");
}
if (member_type.is_class)
{
AppendLine(string.Format("{0}* {1};", GetCppTypeWrapName(Model.GetType(member.type)), member.name));
}
else
{
AppendLine(string.Format("{0} {1};", GetCppTypeWrapName(Model.GetType(member.type)), member.name));
}
}
else if (member.member_type == (int)Metadata.MemberTypes.Method)
{
Model.EnterMethod(member);
AppendLine(GetModifierString(member.modifier) + ":");
//属性
AppendLine(ConvertCppAttribute(member.attributes));
if (member.is_static)
{
Append("static ");
}
else
{
Append("");
}
if (member.method_abstract)
{
sb.Append("abstract ");
}
if (member.method_virtual)
{
sb.Append("virtual ");
}
if (member.member_type == (int)Metadata.MemberTypes.Method)
{
sb.Append(string.Format("{1} {2}", "", member.type.IsVoid ? "void" : GetCppTypeWrapName(Model.GetType(member.type)), member.name));
}
else
{
sb.Append(string.Format("{0}", member.name));
}
sb.Append("(");
if (member.method_args != null)
{
for (int i = 0; i < member.method_args.Length; i++)
{
sb.Append(string.Format("{0} {1} {2}", GetCppTypeWrapName(Model.GetType(member.method_args[i].type)), member.method_args[i].is_ref ? "&" : "", member.method_args[i].name));
if (i < member.method_args.Length - 1)
{
sb.Append(",");
}
}
}
Metadata.DB_Type declare_type = Model.GetType(member.declaring_type);
if (declare_type.is_generic_type_definition)
{
sb.AppendLine(")");
ConvertStatement(member.method_body);
}
else
{
sb.AppendLine(");");
}
Model.LeaveMethod();
}
}
public bool ConvertFieldExp(IConverter Converter, Metadata.DB_Type type, Metadata.Expression.FieldExp fe, out string exp_string)
{
exp_string = "";
return(false);
}
public void ConvertTypeCpp(Metadata.DB_Type type)
{
Model.EnterType(type);
//StringBuilder sb = new StringBuilder();
//cpp文件
{
sb.Clear();
Project cfg = Converter.GetProject();
if (!type.is_enum && !type.is_generic_type_definition)
{
if (!string.IsNullOrEmpty(cfg.precompile_header))
{
sb.AppendLine(string.Format("#include \"{0}\"", cfg.precompile_header));
}
sb.AppendLine("#include \"" + GetTypeHeader(type) + "\"");
//sb.AppendLine(string.Format("namespace {0}{{", type._namespace));
//包含依赖的头文件
HashSet <string> depTypes = Converter.GetMethodBodyDependences(type);
HashSet <string> headDepTypes = Converter.GetTypeDependences(type);
foreach (var t in headDepTypes)
{
Metadata.DB_Type depType = Model.GetType(t);
if (!depType.is_generic_paramter && t != type.static_full_name)
{
sb.AppendLine("#include \"" + GetTypeHeader(depType) + "\"");
}
}
foreach (var t in depTypes)
{
if (!headDepTypes.Contains(t))
{
Metadata.DB_Type depType = Model.GetType(t);
if (!depType.is_generic_paramter && t != type.static_full_name)
{
sb.AppendLine("#include \"" + GetTypeHeader(depType) + "\"");
}
}
}
//foreach (var us in type.usingNamespace)
//{
// if(us!="UnrealEngine")
// sb.AppendLine("using namespace " + us + ";");
//}
TypeConfig tc = Converter.GetTypeConfig(type);
if (tc != null)
{
if (!string.IsNullOrEmpty(tc.ext_cpp))
{
AppendLine("#include \"" + tc.ext_cpp + "\"");
}
}
foreach (var m in type.members.Values)
{
ConvertMemberCpp(m);
}
//sb.AppendLine("}");
//System.IO.File.WriteAllText(System.IO.Path.Combine(outputDir, type.name + ".cpp"), sb.ToString());
}
Model.LeaveType();
//return sb.ToString();
}
}
