void Edit(Func <object, Tuple <bool, object> > func, ref Definition.Expression arr)
{
var r = func(arr);
if (r.Item2 != null)
{
arr = (Definition.Expression)r.Item2;
if (!r.Item1)
{
return;
}
}
var e = arr;
if (e == null)
{
return;
}
Edit(func, ref e.SelfType);
if (e is Definition.MemberAccessExpression)
{
var e_ = e as Definition.MemberAccessExpression;
Edit(func, ref e_.Expression);
for (int i = 0; i < e_.Types.Length; i++)
{
Edit(func, ref e_.Types[i]);
}
}
else if (e is Definition.GenericNameExpression)
{
var e_ = e as Definition.GenericNameExpression;
for (int i = 0; i < e_.Types.Length; i++)
{
Edit(func, ref e_.Types[i]);
}
}
else if (e is Definition.CastExpression)
{
var e_ = e as Definition.CastExpression;
Edit(func, ref e_.Type);
Edit(func, ref e_.Expression);
}
else if (e is Definition.LiteralExpression)
{
}
else if (e is Definition.InvocationExpression)
{
var e_ = e as Definition.InvocationExpression;
Edit(func, ref e_.Method);
for (int i = 0; i < e_.Args.Length; i++)
{
Edit(func, ref e_.Args[i]);
}
}
else if (e is Definition.ObjectCreationExpression)
{
var e_ = e as Definition.ObjectCreationExpression;
Edit(func, ref e_.Type);
for (int i = 0; i < e_.Args.Length; i++)
{
Edit(func, ref e_.Args[i]);
}
}
else if (e is Definition.AssignmentExpression)
{
var e_ = e as Definition.AssignmentExpression;
Edit(func, ref e_.Target);
Edit(func, ref e_.Expression);
}
else if (e is Definition.ElementAccessExpression)
{
var e_ = e as Definition.ElementAccessExpression;
Edit(func, ref e_.Value);
Edit(func, ref e_.Arg);
}
else if (e is Definition.ThisExpression)
{
}
else if (e is Definition.IdentifierNameExpression)
{
var e_ = e as Definition.IdentifierNameExpression;
Edit(func, ref e_.Type);
}
else if (e is Definition.BinaryExpression)
{
var e_ = e as Definition.BinaryExpression;
Edit(func, ref e_.Left);
Edit(func, ref e_.Right);
}
else if (e is Definition.PrefixUnaryExpression)
{
var e_ = e as Definition.PrefixUnaryExpression;
Edit(func, ref e_.Expression);
}
else if (e is Definition.PostfixUnaryExpression)
{
var e_ = e as Definition.PostfixUnaryExpression;
Edit(func, ref e_.Operand);
}
else if (e is Definition.BaseExpression)
{
}
else if (e is Definition.ObjectArrayCreationExpression)
{
var e_ = e as Definition.ObjectArrayCreationExpression;
Edit(func, ref e_.Type);
for (int i = 0; i < e_.Args.Length; i++)
{
Edit(func, ref e_.Args[i]);
}
}
else if (e is Definition.TypeExpression)
{
}
else if (e is Definition.InitializerExpression)
{
var e_ = e as Definition.InitializerExpression;
for (int i = 0; i < e_.Expressions.Length; i++)
{
Edit(func, ref e_.Expressions[i]);
}
}
else
{
throw new Exception();
}
}
string GetExpression(Definition.Expression e)
{
if (e == null)
{
return("");
}
if (e is Definition.BinaryExpression)
{
var e2 = (Definition.BinaryExpression)e;
// as 対応
if (e2.Operator == Definition.BinaryExpression.OperatorType.As)
{
return(string.Format("({0} instanceof {1}? ({1}){0}: null)", GetExpression(e2.Left), GetExpression(e2.Right)));
}
// 文字列の比較対応
if (
(e2.Left.SelfType as Definition.SimpleType)?.TypeName == "String" &&
(e2.Right.SelfType as Definition.SimpleType)?.TypeName == "String" &&
e2.Operator == Definition.BinaryExpression.OperatorType.Equals)
{
return(string.Format("({0}.equals({1}))", GetExpression(e2.Left), GetExpression(e2.Right)));
}
return(string.Format("({0} {1} {2})", GetExpression(e2.Left), GetBinaryExpressionOperator(e2.Operator), GetExpression(e2.Right)));
}
else if (e is Definition.AssignmentExpression)
{
var e2 = (Definition.AssignmentExpression)e;
if (e2.Type == Definition.AssignmentExpression.OperatorType.Simple)
{
return(string.Format("{0} = {1}", GetExpression(e2.Target), GetExpression(e2.Expression)));
}
else if (e2.Type == Definition.AssignmentExpression.OperatorType.Add)
{
return(string.Format("{0} += {1}", GetExpression(e2.Target), GetExpression(e2.Expression)));
}
else if (e2.Type == Definition.AssignmentExpression.OperatorType.Substract)
{
return(string.Format("{0} -= {1}", GetExpression(e2.Target), GetExpression(e2.Expression)));
}
else if (e2.Type == Definition.AssignmentExpression.OperatorType.Divide)
{
return(string.Format("{0} /= {1}", GetExpression(e2.Target), GetExpression(e2.Expression)));
}
else if (e2.Type == Definition.AssignmentExpression.OperatorType.Modulo)
{
return(string.Format("{0} %= {1}", GetExpression(e2.Target), GetExpression(e2.Expression)));
}
else
{
throw new Exception();
}
}
else if (e is Definition.CastExpression)
{
var e2 = (Definition.CastExpression)e;
return(string.Format("({0}){1}", GetTypeSpecifier(e2.Type), GetExpression(e2.Expression)));
}
else if (e is Definition.ElementAccessExpression)
{
var e2 = (Definition.ElementAccessExpression)e;
return(string.Format("{0}[{1}]", GetExpression(e2.Value), GetExpression(e2.Arg)));
}
else if (e is Definition.IdentifierNameExpression)
{
var e2 = (Definition.IdentifierNameExpression)e;
return(e2.Name);
}
else if (e is Definition.InvocationExpression)
{
var e2 = (Definition.InvocationExpression)e;
return(string.Format("{0}({1})", GetExpression(e2.Method), string.Join(", ", Array.ConvertAll(e2.Args, GetExpression))));
}
else if (e is Definition.LiteralExpression)
{
var e2 = (Definition.LiteralExpression)e;
return(ParseLiteralExpression(e2));
}
else if (e is Definition.MemberAccessExpression)
{
var e2 = (Definition.MemberAccessExpression)e;
var accessed = GetExpression(e2.Expression);
if (accessed != string.Empty)
{
accessed += ".";
}
var generic = string.Empty;
if (e2.Types.Count() > 0)
{
generic = string.Format("<{0}>", string.Join(",", e2.Types.Select(_ => GetTypeSpecifier(_))));
}
if (e2.EnumMember != null)
{
return(string.Format("{0}{1}.{2}", (e2.Enum.Namespace == null || e2.Enum.Namespace == "") ? "": e2.Enum.Namespace + ".", e2.Enum.Name, e2.EnumMember.Name));
}
else if (e2.Method != null)
{
if (e2.Method.IsStatic && e2.Class != null)
{
var fullname = string.Empty;
if (e2.Class.Namespace != "")
{
fullname = e2.Class.Namespace + "." + e2.Class.Name;
}
else
{
fullname = e2.Class.Name;
}
return(string.Format("{0}{1}{2}{3}", accessed, fullname + ".", generic, e2.Method.Name));
}
else if (e2.Method.IsStatic && e2.Struct != null)
{
var fullname = string.Empty;
if (e2.Struct.Namespace != "")
{
fullname = e2.Struct.Namespace + "." + e2.Struct.Name;
}
else
{
fullname = e2.Struct.Name;
}
return(string.Format("{0}{2}{1}", accessed, fullname + "." + e2.Method.Name, generic));
}
else
{
return(string.Format("{0}{2}{1}", accessed, e2.Method.Name, generic));
}
}
else if (e2.Property != null)
{
return(string.Format("{0}{2}{1}", accessed, e2.Property.Name, generic));
}
else if (e2.Expression != null)
{
return(string.Format("{0}{2}{1}", accessed, e2.Name, generic));
}
else
{
return(e2.Name);
}
}
else if (e is Definition.ObjectCreationExpression)
{
var e2 = (Definition.ObjectCreationExpression)e;
return(string.Format("new {0}({1})", GetTypeSpecifier(e2.Type), string.Join(", ", Array.ConvertAll(e2.Args, GetExpression))));
}
else if (e is Definition.PrefixUnaryExpression)
{
var e2 = (Definition.PrefixUnaryExpression)e;
return(string.Format("{0}{1}", GetPrefixUnaryExpressionOperator(e2.Type), GetExpression(e2.Expression)));
}
else if (e is Definition.PostfixUnaryExpression)
{
var e2 = (Definition.PostfixUnaryExpression)e;
return(string.Format("{0}{1}", GetExpression(e2.Operand), GetPostfixUnaryExpressionOperator(e2.Type)));
}
else if (e is Definition.ThisExpression)
{
return("this");
}
else if (e is Definition.BaseExpression)
{
return("super");
}
else if (e is Definition.ObjectCreationExpression)
{
var e2 = (Definition.ObjectCreationExpression)e;
var args = e2.Args.Select(_ => GetExpression(_));
return(string.Format("new {0}({1})", GetTypeSpecifier(e2.Type), string.Join(",", args)));
}
else if (e is Definition.ObjectArrayCreationExpression)
{
var e2 = (Definition.ObjectArrayCreationExpression)e;
var args = e2.Args.Select(_ => GetExpression(_));
return(string.Format("new {0}[{1}]", GetTypeSpecifier(e2.Type), string.Join(",", args)));
}
else if (e is Definition.GenericNameExpression)
{
var e2 = (Definition.GenericNameExpression)e;
if (e2.IsMethod)
{
return(string.Format("<{1}>{0}", e2.Name, string.Join(",", Array.ConvertAll(e2.Types, GetTypeSpecifier))));
}
else
{
return(string.Format("{0}<{1}>", e2.Name, string.Join(",", Array.ConvertAll(e2.Types, GetTypeSpecifier))));
}
}
else if (e is Definition.TypeExpression)
{
var e2 = (Definition.TypeExpression)e;
return(string.Format("{0}", GetTypeSpecifier(e2.SelfType)));
}
else if (e is Definition.InitializerExpression)
{
var e2 = (Definition.InitializerExpression)e;
return("{\n" + string.Format("{0}", string.Join(",\n", Array.ConvertAll(e2.Expressions, GetExpression))) + "}");
}
else
{
throw new NotImplementedException("unknown expression " + e.GetType().ToString());
}
}
Definition.Expression ConvertTypeName(Definition.Expression e)
{
if (e == null)
{
return(e);
}
e.SelfType = ConvertTypeName(e.SelfType);
if (e is Definition.MemberAccessExpression)
{
var e_ = e as Definition.MemberAccessExpression;
e_.Expression = ConvertTypeName(e_.Expression);
return(e_);
}
else if (e is Definition.GenericNameExpression)
{
var e_ = e as Definition.GenericNameExpression;
e_.Types = e_.Types.Select(_ => ConvertTypeName(_)).ToArray();
return(e_);
}
else if (e is Definition.CastExpression)
{
var e_ = e as Definition.CastExpression;
e_.Type = ConvertTypeName(e_.Type);
e_.Expression = ConvertTypeName(e_.Expression);
return(e_);
}
else if (e is Definition.LiteralExpression)
{
return(e);
}
else if (e is Definition.InvocationExpression)
{
var e_ = e as Definition.InvocationExpression;
e_.Method = ConvertTypeName(e_.Method);
e_.Args = e_.Args.Select(_ => ConvertTypeName(_)).ToArray();
return(e_);
}
else if (e is Definition.ObjectCreationExpression)
{
var e_ = e as Definition.ObjectCreationExpression;
e_.Type = ConvertTypeName(e_.Type);
e_.Args = e_.Args.Select(_ => ConvertTypeName(_)).ToArray();
return(e_);
}
else if (e is Definition.AssignmentExpression)
{
var e_ = e as Definition.AssignmentExpression;
e_.Target = ConvertTypeName(e_.Target);
e_.Expression = ConvertTypeName(e_.Expression);
return(e_);
}
else if (e is Definition.ElementAccessExpression)
{
var e_ = e as Definition.ElementAccessExpression;
e_.Value = ConvertTypeName(e_.Value);
e_.Arg = ConvertTypeName(e_.Arg);
return(e_);
}
else if (e is Definition.ThisExpression)
{
return(e);
}
else if (e is Definition.IdentifierNameExpression)
{
var e_ = e as Definition.IdentifierNameExpression;
e_.Type = ConvertTypeName(e_.Type);
return(e_);
}
else if (e is Definition.BinaryExpression)
{
var e_ = e as Definition.BinaryExpression;
e_.Left = ConvertTypeName(e_.Left);
e_.Right = ConvertTypeName(e_.Right);
return(e_);
}
else if (e is Definition.PrefixUnaryExpression)
{
var e_ = e as Definition.PrefixUnaryExpression;
e_.Expression = ConvertTypeName(e_.Expression);
return(e_);
}
else if (e is Definition.PostfixUnaryExpression)
{
var e_ = e as Definition.PostfixUnaryExpression;
e_.Operand = ConvertTypeName(e_.Operand);
return(e_);
}
else if (e is Definition.BaseExpression)
{
return(e);
}
else if (e is Definition.ObjectArrayCreationExpression)
{
var e_ = e as Definition.ObjectArrayCreationExpression;
e_.Type = ConvertTypeName(e_.Type);
e_.Args = e_.Args.Select(_ => ConvertTypeName(_)).ToArray();
return(e_);
}
else if (e is Definition.TypeExpression)
{
return(e);
}
else if (e is Definition.InitializerExpression)
{
var e_ = e as Definition.InitializerExpression;
e_.Expressions = e_.Expressions.Select(_ => ConvertTypeName(_)).ToArray();
return(e_);
}
throw new Exception();
}
