private static IEnumerable <UnifiedExpression> CreateProcessAndAssignStatement(ProcessAndAssignStatement statement)
{
yield return(UnifiedBinaryExpression.Create(
CreatePhrase(statement.VariablePhrase),
UnifiedBinaryOperator.Create("=", UnifiedBinaryOperatorKind.Assign),
CreatePhrase(statement.ValuePhrase)));
}
CreateBinaryExpressionForRightAssociation(
XElement node,
Func <XElement, UnifiedExpression> firstCreateExpression,
Func <XElement, UnifiedExpression> otherCreateExpression,
IDictionary <string, UnifiedBinaryOperator> op2Kind)
{
var nodes = node.Elements().OddIndexElements().ToList();
var count = nodes.Count - 1;
var n = nodes[count];
var seed = count > 0
? otherCreateExpression(n)
: firstCreateExpression(n);
for (count--; count >= 0; count--)
{
n = nodes[count];
seed = UnifiedBinaryExpression.Create(
count > 0
? otherCreateExpression(n)
: firstCreateExpression(n),
op2Kind[n.NextElement().Value].DeepCopy(),
seed);
}
return(seed);
}
public static UnifiedExpression CreateAssignmentExpression(
XElement node)
{
Contract.Requires(node != null);
Contract.Requires(node.Name() == "assignment_expression");
/*
* assignment_expression
* : lvalue assignment_operator assignment_expression
| conditional_expression
*/
var first = node.FirstElement();
if (first.Name == "conditional_expression")
{
return(CreateConditionalExpression(first));
}
if (first.Name == "lvalue")
{
return(UnifiedBinaryExpression.Create(
CreateLvalue(first),
CreateAssignmentOperator(node.ElementAt(1)),
CreateAssignmentExpression(node.ElementAt(2))));
}
throw new InvalidOperationException();
}
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));
}
public void compares_different_blocks()
{
var o1 = UnifiedBlock.Create(
new UnifiedExpression[] {
UnifiedBinaryExpression.Create(
UnifiedVariableIdentifier.Create("n"),
UnifiedBinaryOperator.Create(
"=",
UnifiedBinaryOperatorKind.Assign),
UnifiedInt32Literal.Create(1)),
UnifiedReturn.Create(
UnifiedInt32Literal.Create(2)),
});
var o2 = UnifiedBlock.Create(
new UnifiedExpression[] {
UnifiedBinaryExpression.Create(
UnifiedVariableIdentifier.Create("n"),
UnifiedBinaryOperator.Create(
"=",
UnifiedBinaryOperatorKind.Assign),
UnifiedInt32Literal.Create(2)),
UnifiedReturn.Create(
UnifiedInt32Literal.Create(2)),
});
Assert.That(
StructuralEqualityComparer.StructuralEquals(o1, o2),
Is.False);
}
private static IEnumerable <UnifiedExpression> CreateAssignStatement(
AssignStatement statement)
{
yield return(UnifiedBinaryExpression.Create(
CreatePhrase(statement.Left),
UnifiedBinaryOperator.Create("=", UnifiedBinaryOperatorKind.Assign),
CreatePhrase(statement.Right)));
}
public UnifiedElement VisitIsExpression(IsExpression expr, object data)
{
var op = UnifiedBinaryOperator.Create(
"is", UnifiedBinaryOperatorKind.InstanceOf);
var value = expr.Expression.TryAcceptForExpression(this);
var type = LookupType(expr.Type);
return(UnifiedBinaryExpression.Create(value, op, type));
}
public UnifiedElement VisitBinaryOperatorExpression(
BinaryOperatorExpression expr, object data)
{
var op = LookupBinaryOperator(expr.Operator);
var left = expr.Left.TryAcceptForExpression(this);
var right = expr.Right.TryAcceptForExpression(this);
return(UnifiedBinaryExpression.Create(left, op, right));
}
public UnifiedElement VisitAssignmentExpression(
AssignmentExpression assign, object data)
{
var op = LookupAssignOperator(assign.Operator);
var left = assign.Left.TryAcceptForExpression(this);
var right = assign.Right.TryAcceptForExpression(this);
return(UnifiedBinaryExpression.Create(left, op, right));
}
private static UnifiedExpression CreateConditionSentenceSuffix(ConditionSentenceSuffix phrase)
{
Debug.Assert(phrase.SuffixPhrase.CompareType != CompareTypes.Not);
Debug.Assert(phrase.SuffixPhrase.CompareType != CompareTypes.None);
return(UnifiedBinaryExpression.Create(
CreatePhrase(phrase.LeftPhrase),
CreateConditionSuffixToken(phrase.SuffixPhrase),
CreatePhrase(phrase.RightPhrase)));
}
public UnifiedElement VisitAsExpression(
AsExpression asExpr, object data)
{
var op = UnifiedBinaryOperator.Create(
"as", UnifiedBinaryOperatorKind.As);
var value = asExpr.Expression.TryAcceptForExpression(this);
var type = LookupType(asExpr.Type);
return(UnifiedBinaryExpression.Create(value, op, type));
}
private static UnifiedExpression CreateMatch3(XElement node)
{
Contract.Requires(node != null);
Contract.Requires(node.Name() == "match3");
return(UnifiedBinaryExpression.Create(
CreateExpresion(node.FirstElement()),
UnifiedBinaryOperator.Create(
"=~", UnifiedBinaryOperatorKind.RegexEqual),
CreateExpresion(node.LastElement())));
}
private static UnifiedExpression CreateOpAsgnAnd(XElement node)
{
Contract.Requires(node != null);
Contract.Requires(node.Name() == "op_asgn_and");
// 優先順位の違いはASTの深さ（&& / and）
return(UnifiedBinaryExpression.Create(
CreateExpresion(node.FirstElement()),
UnifiedBinaryOperator.Create(
"&&=", UnifiedBinaryOperatorKind.AndAlsoAssign),
CreateExpresion(node.LastElement())));
}
private static UnifiedExpression CreateOpAsgnOr(XElement node)
{
Contract.Requires(node != null);
Contract.Requires(node.Name() == "op_asgn_or");
// 優先順位の違いはASTの深さ（|| / or）
return(UnifiedBinaryExpression.Create(
CreateExpresion(node.FirstElement()),
UnifiedBinaryOperator.Create(
"||=", UnifiedBinaryOperatorKind.OrElseAssign),
CreateExpresion(node.LastElement())));
}
public void compares_same_expressions_containing_null()
{
var o2 = UnifiedBinaryExpression.Create(
UnifiedVariableIdentifier.Create("n"), null,
UnifiedInt32Literal.Create(1));
var o1 = o2;
Assert.That(
StructuralEqualityComparer.StructuralEquals(o1, o2),
Is.True);
}
public void compares_same_expressions()
{
var o2 = UnifiedBinaryExpression.Create(
UnifiedVariableIdentifier.Create("n"),
UnifiedBinaryOperator.Create(
"-", UnifiedBinaryOperatorKind.Subtract),
UnifiedInt32Literal.Create(1));
var o1 = o2;
Assert.That(
StructuralEqualityComparer.StructuralEquals(o1, o2),
Is.True);
}
public static UnifiedBinaryExpression CreateAsgn(XElement node)
{
Contract.Requires(node != null);
Contract.Requires(
node.Name() == "lasgn" || node.Name() == "masgn" ||
node.Name() == "iasgn" ||
node.Name() == "gasgn" || node.Name() == "cvdecl" ||
node.Name() == "cdecl");
return(UnifiedBinaryExpression.Create(
CreateExpresion(node.FirstElement()),
UnifiedBinaryOperator.Create(
"=", UnifiedBinaryOperatorKind.Assign),
CreateExpresion(node.LastElement())));
}
private static UnifiedExpression CreateOpAsgn1(XElement node)
{
Contract.Requires(node != null);
Contract.Requires(node.Name() == "op_asgn1");
var expression = UnifiedIndexer.Create(
CreateExpresion(node.FirstElement()),
CreateArglist(node.NthElement(1)));
return(UnifiedBinaryExpression.Create(
expression,
Sign2BinaryOperator[node.NthElement(2).Value + "="].DeepCopy
(),
CreateExpresion(node.LastElement())));
}
public void compares_different_expressions_containing_null()
{
var o1 = UnifiedBinaryExpression.Create(
UnifiedVariableIdentifier.Create("n"), null,
UnifiedInt32Literal.Create(1));
var o2 = UnifiedBinaryExpression.Create(
UnifiedVariableIdentifier.Create("n"),
UnifiedBinaryOperator.Create(
null, UnifiedBinaryOperatorKind.Add),
UnifiedInt32Literal.Create(1));
Assert.That(
StructuralEqualityComparer.StructuralEquals(o1, o2),
Is.False);
}
/// <summary>
/// 指定したXMLノードから左結合のBinaryExpressionを作成します．
/// </summary>
/// <param name="node"> </param>
/// <param name="firstCreateExpression"> </param>
/// <param name="otherCreateExpression"> </param>
/// <param name="op2Kind"> </param>
/// <returns> </returns>
public static UnifiedExpression CreateBinaryExpression(
XElement node,
Func <XElement, UnifiedExpression> firstCreateExpression,
Func <XElement, UnifiedExpression> otherCreateExpression,
IDictionary <string, UnifiedBinaryOperator> op2Kind)
{
var nodes = node.Elements().OddIndexElements();
return(nodes.AggregateApartFirst(
firstCreateExpression,
(e, n) => UnifiedBinaryExpression.Create(
e,
op2Kind[n.PreviousElement().Value].DeepCopy(),
otherCreateExpression(n))));
}
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 void compares_different_calls()
{
var o1 =
UnifiedCall.Create(
UnifiedVariableIdentifier.Create("f"),
UnifiedSet <UnifiedArgument> .Create(
UnifiedArgument.Create(
UnifiedVariableIdentifier.Create(
"a"), null, null),
UnifiedArgument.Create(
UnifiedBinaryExpression.Create(
UnifiedVariableIdentifier.
Create("n"),
UnifiedBinaryOperator.Create
(
"-",
UnifiedBinaryOperatorKind
.Add),
UnifiedInt32Literal.Create(
1)
), null, null)));
var o2 =
UnifiedCall.Create(
UnifiedVariableIdentifier.Create("f"),
UnifiedSet <UnifiedArgument> .Create(
UnifiedArgument.Create(
UnifiedVariableIdentifier.Create(
"a"), null, null),
UnifiedArgument.Create(
UnifiedBinaryExpression.Create(
UnifiedVariableIdentifier.
Create("n2"),
UnifiedBinaryOperator.Create
(
"-",
UnifiedBinaryOperatorKind
.Add),
UnifiedInt32Literal.Create(
1)), null, null)));
Assert.That(
StructuralEqualityComparer.StructuralEquals(o1, o2),
Is.False);
}
