public void EnterMethod(Metadata.DB_Member member)
{
currentMethod = member;
EnterBlock();
foreach (var arg in member.method_args)
{
AddLocal(arg.name, GetType(arg.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 void LeaveMethod()
{
LeaveBlock();
currentMethod = 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);
}
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();
}
}
