public void VisitStatement(DB_Type type, DB_Member member, DB_ReturnStatementSyntax statement, DB_StatementSyntax outer)
{
if (statement.Expression != null)
{
model.VisitExp(this, type, member, statement, statement.Expression, null);
}
}
void VisitDeclareVairable(DB_Type type, DB_Member method, DB_StatementSyntax statement, VariableDeclarationSyntax Declaration)
{
foreach (var e in Declaration.Variables)
{
model.AddLocal(e.Identifier, model.Finder.FindType(Declaration.Type, model));
model.VisitExp(this, type, method, statement, e.Initializer, null);
}
}
public void VisitExp(DB_Type type, DB_Member member, DB_StatementSyntax statement, ElementAccessExp exp, Exp outer)
{
model.VisitExp(this, type, member, statement, exp.exp, exp);
foreach (var e in exp.args)
{
model.VisitExp(this, type, member, statement, e, exp);
}
}
public void VisitExp(DB_Type type, DB_Member member, DB_StatementSyntax statement, IndifierExp exp, Exp outer)
{
Model.IndifierInfo info = model.GetIndifierInfo(exp.Name);
if (info.type != null)
{
typeRef.Add(info.type.GetRefType());
}
}
public void VisitStatement(DB_Type type, DB_Member member, DB_IfStatementSyntax statement, DB_StatementSyntax outer)
{
model.VisitExp(this, type, member, statement, statement.Condition, null);
model.VisitStatement(this, type, member, statement.Statement, statement);
if (statement.Else != null)
{
model.VisitStatement(this, type, member, statement.Else, statement);
}
}
public void VisitStatement(DB_Type type, DB_Member member, DB_BlockSyntax statement, DB_StatementSyntax outer)
{
model.EnterBlock();
foreach (var s in statement.List)
{
model.VisitStatement(this, type, member, s, statement);
}
model.LeaveBlock();
}
public void VisitExp(DB_Type type, DB_Member member, DB_StatementSyntax statement, ObjectCreateExp exp, Exp outer)
{
typeRef.Add(exp.Type);
foreach (var a in exp.Args)
{
model.VisitExp(this, type, member, statement, a, exp);
}
}
public void VisitMember(DB_Type type, DB_Member member)
{
if (member.member_type == (int)Metadata.MemberTypes.Method)
{
if (member.method_body != null)
{
model.VisitStatement(this, type, member, member.method_body, null);
}
}
}
public void VisitExp(DB_Type type, DB_Member member, DB_StatementSyntax statement, IndifierExp exp, Exp outer)
{
Model.IndifierInfo info = model.GetIndifierInfo(exp.Name);
if (info.is_class_type_parameter)
{
Console.Error.Write("未处理的类型参数标识符 " + exp.Name);
}
//if (info.type != null)
// typeRef.Add(info.type.GetRefType());
}
//public IMethodVisitor GetMethodVisitor() { return this; }
//public void VisitStatement(DB_Type type, DB_Member member, DB_BreakStatementSyntax statement, DB_StatementSyntax outer)
//{
// methodVisitor.VisitStatement(type, member, statement, outer);
//}
//public void VisitStatement(DB_Type type, DB_Member member, DB_BlockSyntax statement, DB_StatementSyntax outer)
//{
// methodVisitor.VisitStatement(type, member, statement, outer);
// EnterBlock();
// foreach (var s in statement.List)
// {
// VisitStatement(type, member,s, statement);
// }
// LeaveBlock();
//}
//public void VisitStatement(DB_Type type, DB_Member member, DB_DoStatementSyntax statement, DB_StatementSyntax outer)
//{
// methodVisitor.VisitStatement(type, member, statement, outer);
// DB_DoStatementSyntax ss = statement as DB_DoStatementSyntax;
// VisitExp(type, member, statement, ss.Condition,null);
// VisitStatement(type, member, ss.Statement,ss);
//}
//public void VisitStatement(DB_Type type, DB_Member member, DB_ExpressionStatementSyntax statement, DB_StatementSyntax outer)
//{
// methodVisitor.VisitStatement(type, member, statement, outer);
// VisitExp(type, member, statement, statement.Exp, null);
//}
//void VisitDeclareVairable(DB_Type type, DB_Member method, DB_StatementSyntax statement, VariableDeclarationSyntax Declaration)
//{
// foreach (var e in Declaration.Variables)
// {
// AddLocal(e.Identifier, Finder.FindType(Declaration.Type));
// VisitExp(type, method, statement, e.Initializer,null);
// }
//}
//public void VisitStatement(DB_Type type, DB_Member member, DB_ForStatementSyntax statement, DB_StatementSyntax outer)
//{
// methodVisitor.VisitStatement(type, member, statement, outer);
// EnterBlock();
// DB_ForStatementSyntax ss = statement as DB_ForStatementSyntax;
// if (ss.Declaration != null)
// {
// VisitDeclareVairable(type, member, statement, ss.Declaration);
// }
// VisitExp(type, member, statement, ss.Condition,null);
// foreach (var inc in ss.Incrementors)
// VisitExp(type, member, statement, inc,null);
// VisitStatement(type, member, ss.Statement,statement);
// LeaveBlock();
//}
//public void VisitStatement(DB_Type type, DB_Member member, DB_IfStatementSyntax statement, DB_StatementSyntax outer)
//{
// methodVisitor.VisitStatement(type, member, statement, outer);
// DB_IfStatementSyntax ss = statement as DB_IfStatementSyntax;
// VisitExp(type, member, statement, ss.Condition,null);
// VisitStatement(type, member, ss.Statement,ss);
// if (ss.Else != null)
// {
// VisitStatement(type, member, ss.Else,ss);
// }
//}
//public void VisitStatement(DB_Type type, DB_Member member, DB_LocalDeclarationStatementSyntax statement, DB_StatementSyntax outer)
//{
// methodVisitor.VisitStatement(type, member, statement, outer);
// DB_LocalDeclarationStatementSyntax ss = statement as DB_LocalDeclarationStatementSyntax;
// VisitDeclareVairable(type, member, statement, ss.Declaration);
//}
//public void VisitStatement(DB_Type type, DB_Member member, DB_ReturnStatementSyntax statement, DB_StatementSyntax outer)
//{
// methodVisitor.VisitStatement(type, member, statement, outer);
// DB_ReturnStatementSyntax ss = statement as DB_ReturnStatementSyntax;
// if (ss.Expression != null)
// {
// VisitExp(type, member, ss, ss.Expression,null);
// }
//}
//public void VisitStatement(DB_Type type, DB_Member member, DB_SwitchStatementSyntax statement, DB_StatementSyntax outer)
//{
// methodVisitor.VisitStatement(type, member, statement, outer);
// VisitExp(type, member, statement, statement.Expression,null);
// EnterBlock();
// foreach (var sec in statement.Sections)
// {
// foreach (var l in sec.Labels)
// {
// VisitExp(type, member, statement, l,null);
// }
// foreach (var s in sec.Statements)
// {
// VisitStatement(type, member, s, statement);
// }
// }
// LeaveBlock();
//}
//public void VisitStatement(DB_Type type, DB_Member member, DB_ThrowStatementSyntax statement, DB_StatementSyntax outer)
//{
// methodVisitor.VisitStatement(type, member, statement, outer);
// VisitExp(type, member, statement, statement.Expression,null);
//}
//public void VisitStatement(DB_Type type, DB_Member member, DB_TryStatementSyntax statement, DB_StatementSyntax outer)
//{
// methodVisitor.VisitStatement(type, member, statement, outer);
// DB_TryStatementSyntax ss = statement as DB_TryStatementSyntax;
// VisitStatement(type, member, ss.Block,statement);
// foreach (var c in ss.Catches)
// {
// VisitStatement(type, member, c.Block, statement);
// }
// if (ss.Finally != null)
// VisitStatement(type, member, ss.Finally.Block, statement);
//}
//public void VisitStatement(DB_Type type, DB_Member member, DB_WhileStatementSyntax statement, DB_StatementSyntax outer)
//{
// methodVisitor.VisitStatement(type, member, statement, outer);
// VisitExp(type, member, statement, statement.Condition,null);
// VisitStatement(type, member, statement.Statement, statement);
//}
//public void VisitExp(DB_Type type, DB_Member member, DB_StatementSyntax statement, Expression.AssignmentExpressionSyntax exp, Expression.Exp outer)
//{
// methodVisitor.VisitExp(type, member, statement, exp, outer);
//}
//public void VisitExp(DB_Type type, DB_Member member, DB_StatementSyntax statement, Expression.BaseExp exp, Expression.Exp outer)
//{
// methodVisitor.VisitExp(type, member, statement, exp, outer);
//}
//public void VisitExp(DB_Type type, DB_Member member, DB_StatementSyntax statement, Expression.BinaryExpressionSyntax exp, Expression.Exp outer)
//{
// methodVisitor.VisitExp(type, member, statement, exp, outer);
//}
//public void VisitExp(DB_Type type, DB_Member member, DB_StatementSyntax statement, Expression.ConstExp exp, Expression.Exp outer)
//{
// methodVisitor.VisitExp(type, member, statement, exp, outer);
//}
//public void VisitExp(DB_Type type, DB_Member member, DB_StatementSyntax statement, Expression.FieldExp exp, Expression.Exp outer)
//{
// methodVisitor.VisitExp(type, member, statement, exp, outer);
//}
//public void VisitExp(DB_Type type, DB_Member member, DB_StatementSyntax statement, Expression.MethodExp exp, Expression.Exp outer)
//{
// methodVisitor.VisitExp(type, member, statement, exp, outer);
// VisitExp(type, member, statement, exp.Caller,exp);
// List<DB_Type> argTypes = new List<DB_Type>();
// foreach (var a in exp.Args)
// {
// VisitExp(type, member, statement, a,null);
// }
//}
//public void VisitExp(DB_Type type, DB_Member member, DB_StatementSyntax statement, Expression.ObjectCreateExp exp, Expression.Exp outer)
//{
// methodVisitor.VisitExp(type, member, statement, exp, outer);
// foreach (var a in exp.Args)
// {
// VisitExp(type, member, statement, a, exp);
// }
//}
//public void VisitExp(DB_Type type, DB_Member member, DB_StatementSyntax statement, Expression.ParenthesizedExpressionSyntax exp, Expression.Exp outer)
//{
// methodVisitor.VisitExp(type, member, statement, exp, outer);
//}
//public void VisitExp(DB_Type type, DB_Member member, DB_StatementSyntax statement, Expression.PostfixUnaryExpressionSyntax exp, Expression.Exp outer)
//{
// methodVisitor.VisitExp(type, member, statement, exp, outer);
//}
//public void VisitExp(DB_Type type, DB_Member member, DB_StatementSyntax statement, Expression.PrefixUnaryExpressionSyntax exp, Expression.Exp outer)
//{
// methodVisitor.VisitExp(type, member, statement, exp, outer);
//}
//public void VisitExp(DB_Type type, DB_Member member, DB_StatementSyntax statement, Expression.ThisExp exp, Expression.Exp outer)
//{
// methodVisitor.VisitExp(type, member, statement, exp, outer);
//}
//public void VisitExp(DB_Type type, DB_Member member, DB_StatementSyntax statement, Expression.ThrowExp exp, Expression.Exp outer)
//{
// methodVisitor.VisitExp(type, member, statement, exp, outer);
//}
//public void VisitExp(DB_Type type, DB_Member member, DB_StatementSyntax statement, Expression.IndifierExp exp, Expression.Exp outer)
//{
// methodVisitor.VisitExp(type, member, statement, exp, outer);
//}
public void VisitStatement(IMethodVisitor visitor, DB_Type type, DB_Member method, DB_StatementSyntax statement, DB_StatementSyntax outer)
{
if (statement is DB_BlockSyntax)
{
visitor.VisitStatement(type, method, statement as DB_BlockSyntax, outer);
}
else if (statement is DB_IfStatementSyntax)
{
visitor.VisitStatement(type, method, statement as DB_IfStatementSyntax, outer);
}
else if (statement is DB_ForStatementSyntax)
{
visitor.VisitStatement(type, method, statement as DB_ForStatementSyntax, outer);
}
else if (statement is DB_LocalDeclarationStatementSyntax)
{
visitor.VisitStatement(type, method, statement as DB_LocalDeclarationStatementSyntax, outer);
}
else if (statement is DB_DoStatementSyntax)
{
visitor.VisitStatement(type, method, statement as DB_DoStatementSyntax, outer);
}
else if (statement is DB_ExpressionStatementSyntax)
{
visitor.VisitStatement(type, method, statement as DB_ExpressionStatementSyntax, outer);
}
else if (statement is DB_SwitchStatementSyntax)
{
visitor.VisitStatement(type, method, statement as DB_SwitchStatementSyntax, outer);
}
else if (statement is DB_WhileStatementSyntax)
{
visitor.VisitStatement(type, method, statement as DB_WhileStatementSyntax, outer);
}
else if (statement is DB_TryStatementSyntax)
{
visitor.VisitStatement(type, method, statement as DB_TryStatementSyntax, outer);
}
else if (statement is DB_ThrowStatementSyntax)
{
visitor.VisitStatement(type, method, statement as DB_ThrowStatementSyntax, outer);
}
else if (statement is DB_ReturnStatementSyntax)
{
visitor.VisitStatement(type, method, statement as DB_ReturnStatementSyntax, outer);
}
else
{
throw new NotSupportedException("不支持的语句 " + statement.GetType().Name);
}
}
public void VisitStatement(DB_Type type, DB_Member member, DB_TryStatementSyntax statement, DB_StatementSyntax outer)
{
foreach (var c in statement.Catches)
{
typeRef.Add(c.Type);
}
foreach (var c in statement.Catches)
{
model.VisitStatement(this, type, member, c.Block, statement);
}
if (statement.Finally != null)
{
model.VisitStatement(this, type, member, statement.Finally.Block, statement);
}
}
public void VisitStatement(DB_Type type, DB_Member member, DB_SwitchStatementSyntax statement, DB_StatementSyntax outer)
{
model.VisitExp(this, type, member, statement, statement.Expression, null);
foreach (var sec in statement.Sections)
{
foreach (var l in sec.Labels)
{
model.VisitExp(this, type, member, statement, l, null);
}
foreach (var s in sec.Statements)
{
model.VisitStatement(this, type, member, s, statement);
}
}
}
public void VisitExp(DB_Type type, DB_Member member, DB_StatementSyntax statement, MethodExp exp, Exp outer)
{
foreach (var a in exp.Args)
{
model.VisitExp(this, type, member, statement, a, exp);
}
if (exp.Caller is IndifierExp)
{
}
else
{
model.VisitExp(this, type, member, statement, exp.Caller, exp);
}
//DB_Type returnType = model.GetExpType(exp);
//if (returnType != null)
// typeRef.Add(returnType.GetRefType());
}
//public IMemberVisitor GetMemberVisitor() { return this; }
public void AcceptMemberVisitor(IMemberVisitor visitor, DB_Type type, DB_Member member)
{
IMemberVisitor memberVisitor = visitor;
if (memberVisitor != null)
{
if (member.member_type == (int)MemberTypes.Method)
{
EnterMethod(member);
memberVisitor.VisitMember(type, member);
LeaveMethod();
}
else
{
memberVisitor.VisitMember(type, member);
}
}
}
public void VisitStatement(DB_Type type, DB_Member member, DB_ForStatementSyntax statement, DB_StatementSyntax outer)
{
typeRef.Add(statement.Declaration.Type);
model.EnterBlock();
DB_ForStatementSyntax ss = statement as DB_ForStatementSyntax;
if (ss.Declaration != null)
{
VisitDeclareVairable(type, member, statement, ss.Declaration);
}
model.VisitExp(this, type, member, statement, ss.Condition, null);
foreach (var inc in ss.Incrementors)
{
model.VisitExp(this, type, member, statement, inc, null);
}
model.VisitStatement(this, type, member, ss.Statement, statement);
model.LeaveBlock();
}
public void VisitMember(DB_Type type, DB_Member m)
{
if (m.member_type == (int)Metadata.MemberTypes.Field)
{
result.Add(m.type);
}
else if (m.member_type == (int)Metadata.MemberTypes.Method)
{
if (!m.type.IsVoid)
{
result.Add(m.type);
}
foreach (var a in m.method_args)
{
result.Add(a.type);
}
}
else if (m.member_type == (int)Metadata.MemberTypes.Property)
{
result.Add(m.type);
}
}
public void VisitExp(DB_Type type, DB_Member member, DB_StatementSyntax statement, FieldExp exp, Exp outer)
{
//DB_Type caller = model.GetExpType(exp.Caller);
//typeRef.Add(caller.GetRefType());
//if (caller.members.ContainsKey(exp.Name))
//{
// typeRef.Add(caller.members[exp.Name].typeName);
//}
//else
//{
// List<DB_Member> methods = caller.FindMethod(exp.Name, model);
// if(methods.Count>0)
// {
// //typeRef.Add(caller.members[exp.Name].typeName);
// }
//}
model.VisitExp(this, type, member, statement, exp.Caller, exp);
}
public void VisitMember(DB_Type type, DB_Member member)
{
if (member.member_type == (int)Metadata.MemberTypes.Method)
{
if (member.method_body != null)
{
model.VisitStatement(this, type, member, member.method_body, null);
}
if (member.method_args != null)
{
foreach (var t in member.method_args)
{
t.type = ReplaceType(type, t.type);
}
}
}
if (!member.type.IsVoid)
{
member.type = ReplaceType(type, member.type);
}
}
public void VisitExp(IMethodVisitor visitor, DB_Type type, DB_Member method, DB_StatementSyntax statement, Expression.Exp exp, Expression.Exp outer)
{
if (exp is Expression.IndifierExp)
{
visitor.VisitExp(type, method, statement, exp as Expression.IndifierExp, outer);
}
else if (exp is Expression.FieldExp)
{
visitor.VisitExp(type, method, statement, exp as Expression.FieldExp, outer);
}
else if (exp is Expression.ObjectCreateExp)
{
visitor.VisitExp(type, method, statement, exp as Expression.ObjectCreateExp, outer);
}
else if (exp is Expression.ConstExp)
{
visitor.VisitExp(type, method, statement, exp as Expression.ConstExp, outer);
}
else if (exp is Expression.MethodExp)
{
visitor.VisitExp(type, method, statement, exp as Expression.MethodExp, outer);
}
else if (exp is Expression.ParenthesizedExpressionSyntax)
{
visitor.VisitExp(type, method, statement, exp as Expression.ParenthesizedExpressionSyntax, outer);
}
else if (exp is Expression.ThisExp)
{
visitor.VisitExp(type, method, statement, exp as Expression.ThisExp, outer);
}
else if (exp is Expression.BaseExp)
{
visitor.VisitExp(type, method, statement, exp as Expression.BaseExp, outer);
}
else if (exp is Expression.AssignmentExpressionSyntax)
{
visitor.VisitExp(type, method, statement, exp as Expression.AssignmentExpressionSyntax, outer);
}
else if (exp is Expression.BinaryExpressionSyntax)
{
visitor.VisitExp(type, method, statement, exp as Expression.BinaryExpressionSyntax, outer);
}
else if (exp is Expression.PostfixUnaryExpressionSyntax)
{
visitor.VisitExp(type, method, statement, exp as Expression.PostfixUnaryExpressionSyntax, outer);
}
else if (exp is Expression.PrefixUnaryExpressionSyntax)
{
visitor.VisitExp(type, method, statement, exp as Expression.PrefixUnaryExpressionSyntax, outer);
}
else if (exp is Expression.ThrowExp)
{
visitor.VisitExp(type, method, statement, exp as Expression.ThrowExp, outer);
}
else if (exp is Expression.ElementAccessExp)
{
visitor.VisitExp(type, method, statement, exp as Expression.ElementAccessExp, outer);
}
else
{
throw new NotSupportedException("不支持的表达式 " + exp.GetType().ToString());
}
}
public void VisitExp(DB_Type type, DB_Member member, DB_StatementSyntax statement, ThrowExp exp, Exp outer)
{
model.VisitExp(this, type, member, statement, exp.exp, exp);
}
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 VisitExp(DB_Type type, DB_Member member, DB_StatementSyntax statement, PrefixUnaryExpressionSyntax exp, Exp outer)
{
//throw new NotImplementedException();
}
public void VisitExp(DB_Type type, DB_Member member, DB_StatementSyntax statement, ThisExp exp, Exp outer)
{
typeRef.Add(type.GetRefType());
}
public void VisitStatement(DB_Type type, DB_Member member, DB_BreakStatementSyntax statement, DB_StatementSyntax outer)
{
//throw new NotImplementedException();
}
public void VisitExp(DB_Type type, DB_Member member, DB_StatementSyntax statement, ConstExp exp, Exp outer)
{
typeRef.Add(model.GetExpType(exp).GetRefType());
}
public void VisitExp(DB_Type type, DB_Member member, DB_StatementSyntax statement, BinaryExpressionSyntax exp, Exp outer)
{
model.VisitExp(this, type, member, statement, exp.Left, exp);
model.VisitExp(this, type, member, statement, exp.Right, exp);
}
public void VisitExp(DB_Type type, DB_Member member, DB_StatementSyntax statement, BaseExp exp, Exp outer)
{
typeRef.Add(type.base_type);
}
public void VisitStatement(DB_Type type, DB_Member member, DB_LocalDeclarationStatementSyntax statement, DB_StatementSyntax outer)
{
VisitDeclareVairable(type, member, statement, statement.Declaration);
}
