public override bool Visit(UnifiedProperty element, VisitorArgument arg)
{
element.Owner.TryAccept(this, arg);
Writer.Write(element.Delimiter);
element.Name.TryAccept(this, arg);
return(false);
}
private static UnifiedExpression CreateAttrasgn(XElement node)
{
Contract.Requires(node != null);
Contract.Requires(node.Name() == "attrasgn");
var left = CreateExpresion(node.FirstElement());
var name = node.NthElement(1);
var args = CreateArglist(node.LastElement());
var right = args[args.Count - 1].Value;
args.RemoveAt(args.Count - 1);
right.RemoveSelf();
UnifiedExpression expression;
if (name.Value == "[]=")
{
expression = UnifiedIndexer.Create(left, args);
}
else
{
var propName = name.Value;
propName = propName.Substring(0, propName.Length - 1);
expression = UnifiedProperty.Create(
".", left, UnifiedVariableIdentifier.Create(propName));
}
return(UnifiedBinaryExpression.Create(
expression,
UnifiedBinaryOperator.Create(
"=", UnifiedBinaryOperatorKind.Assign),
right));
}
private static UnifiedExpression CreateColon3(XElement node)
{
Contract.Requires(node != null);
Contract.Requires(node.Name() == "colon3");
return(UnifiedProperty.Create(
"::", null, CreateExpresion(node.FirstElement())));
}
public UnifiedElement VisitMemberReferenceExpression(
MemberReferenceExpression propExpr, object data)
{
var target = propExpr.Target.TryAcceptForExpression(this);
var name = propExpr.MemberName.ToVariableIdentifier();
return(UnifiedProperty.Create(".", target, name));
}
private static UnifiedExpression CreateDefs(XElement node)
{
Contract.Requires(node != null);
Contract.Requires(node.Name() == "defs");
var owner = CreateExpresion(node.NthElement(0));
var target = UnifiedFunctionDefinition.Create(
null, null, null, null,
CreateSymbol(node.NthElement(1)),
CreateArgs(node.NthElement(2)), null,
CreateScope(node.NthElement(3)));
return(UnifiedProperty.Create(".", owner, target));
}
public static UnifiedCall CreateCall(XElement node)
{
Contract.Requires(node != null);
Contract.Requires(node.Name() == "call");
// TODO: 演算子への変換
var receiver = CreateExpresion(node.NthElement(0));
var secondNode = node.NthElement(1);
return(UnifiedCall.Create(
receiver != null
? UnifiedProperty.Create(
".", receiver, CreateExpresion(secondNode))
: CreateExpresion(secondNode),
CreateArglist(node.NthElement(2))));
}
private static UnifiedExpression CreateOpAsgn2(XElement node)
{
Contract.Requires(node != null);
Contract.Requires(node.Name() == "op_asgn2");
var propName = node.NthElement(1).Value;
var expression = UnifiedProperty.Create(
".", CreateExpresion(node.FirstElement()),
UnifiedVariableIdentifier.Create(
propName.Substring(0, propName.Length - 1)));
return(UnifiedBinaryExpression.Create(
expression,
Sign2BinaryOperator[node.NthElement(2).Value + "="].DeepCopy
(),
CreateExpresion(node.LastElement())));
}
public UnifiedElement VisitNamespaceDeclaration(
NamespaceDeclaration dec, object data)
{
var ns = dec.Identifiers
.Select(
ident =>
ident.Name.ToVariableIdentifier() as
UnifiedExpression)
.Aggregate(
(left, right) =>
UnifiedProperty.Create(".", left, right));
var body = dec.Members
.Select(mem => mem.TryAcceptForExpression(this))
.ToBlock();
return(UnifiedNamespaceDefinition.Create(name: ns, body: body));
}
internal static UnifiedType LookupType(AstType type)
{
Contract.Requires <ArgumentNullException>(type != null);
Contract.Ensures(Contract.Result <UnifiedType>() != null);
var prim = type as PrimitiveType;
if (prim != null)
{
return(UnifiedType.Create(prim.Keyword));
}
var sim = type as SimpleType;
if (sim != null)
{
return(UnifiedType.Create(sim.Identifier));
}
var com = type as ComposedType;
if (com != null)
{
var uType = LookupType(com.BaseType);
foreach (var aSpec in com.ArraySpecifiers)
{
uType = uType.WrapRectangleArray(aSpec.Dimensions);
}
return(uType);
}
var mem = type as MemberType;
if (mem != null)
{
var target = LookupType(mem.Target);
var name = mem.MemberName.ToVariableIdentifier();
return
(UnifiedType.Create(
UnifiedProperty.Create(".", target, name)));
}
if (type == AstType.Null)
{
return(UnifiedType.Create());
}
throw new NotImplementedException("LookupType");
}
public UnifiedElement VisitMemberType(
MemberType memberType, object data)
{
var ident = UnifiedTypeIdentifier.Create(memberType.MemberName);
var target = memberType.Target.TryAcceptForExpression(this);
var uProp =
UnifiedType.Create(
UnifiedProperty.Create(".", target, ident));
// TODO: Send a Patch to NRefactory
if (ReferenceEquals(memberType.TypeArguments, null))
{
return(uProp);
}
var uTypeArgs =
memberType.TypeArguments.AcceptVisitorAsTypeArgs(this, data);
return(uProp.WrapGeneric(uTypeArgs));
}
public static UnifiedExpression CreatePostfixExpression(XElement node)
{
Contract.Requires(node != null);
Contract.Requires(node.Name() == "postfix_expression");
/*
* postfix_expression
* : primary_expression
* ( '[' expression ']'
| '(' ')'
| '(' argument_expression_list ')'
| '.' IDENTIFIER
| '->' IDENTIFIER
| '++'
| '--'
| )*
*/
var result =
CreatePrimaryExpression(node.Element("primary_expression"));
var elements = node.Elements().Skip(1); //先頭以外のすべての要素を取得
var length = elements.Count();
for (var i = 0; i < length; i++)
{
switch (elements.ElementAt(i++).Value)
{
case "[":
result = UnifiedIndexer.Create(
result,
UnifiedSet <UnifiedArgument> .Create(
UnifiedArgument.Create(
CreateExpression(
elements.ElementAt(i++)).
ElementAt(0))));
i++; // ']'読み飛ばし
break;
case "(":
if (elements.ElementAt(i).Name == "argument_expression_list")
{
result = UnifiedCall.Create(
result,
CreateArgumentExpressionList(
elements.ElementAt(i++)));
}
else
{
result = UnifiedCall.Create(
result, UnifiedSet <UnifiedArgument> .Create());
}
i++; // ')'読み飛ばし
break;
case ".":
result = UnifiedProperty.Create(
".", result,
UnifiedIdentifier.CreateVariable(
elements.ElementAt(i++).Value));
break;
case "->":
result = UnifiedProperty.Create(
"->", result,
UnifiedIdentifier.CreateVariable(
elements.ElementAt(i++).Value));
// TODO ポインタ型に展開してから処理するのか？
break;
case "++":
result = UnifiedUnaryExpression.Create(
result,
UnifiedUnaryOperator.Create(
"++",
UnifiedUnaryOperatorKind.PostIncrementAssign));
break;
case "--":
result = UnifiedUnaryExpression.Create(
result,
UnifiedUnaryOperator.Create(
"--",
UnifiedUnaryOperatorKind.PostDecrementAssign));
break;
default:
throw new InvalidOperationException();
}
}
return(result);
}
//プロパティ : e.g. A.B
public override bool Visit(UnifiedProperty element, VisitorArgument arg)
{
element.Owner.TryAccept(this, arg);
Writer.Write(element.Delimiter);
element.Name.TryAccept(this, arg);
return true;
}
