public UnifiedElement VisitUnaryOperatorExpression(
UnaryOperatorExpression unary, object data)
{
var op = LookupUnaryOperator(unary.Operator);
var operand = unary.Expression.TryAcceptForExpression(this);
return(UnifiedUnaryExpression.Create(operand, op));
}
private static UnifiedExpression CreateBlockPass(XElement node)
{
Contract.Requires(node != null);
Contract.Requires(node.Name() == "block_pass");
return(UnifiedUnaryExpression.Create(
CreateExpresion(node.FirstElement()),
UnifiedUnaryOperator.Create(
"&", UnifiedUnaryOperatorKind.BlockPass)));
}
private static UnifiedExpression CreateNot(XElement node)
{
Contract.Requires(node != null);
Contract.Requires(node.Name() == "not");
return(UnifiedUnaryExpression.Create(
CreateExpresion(node.FirstElement()),
UnifiedUnaryOperator.Create(
"!", UnifiedUnaryOperatorKind.Not)));
}
/// <summary>
/// 指定したXMLノードから演算子が項の前に付くUnaryExpressionを作成します．
/// </summary>
/// <param name="node"> </param>
/// <param name="createExpression"> </param>
/// <param name="op2Kind"> </param>
/// <returns> </returns>
public static UnifiedExpression CreatePrefixUnaryExpression(
XElement node,
Func <XElement, UnifiedExpression> createExpression,
IDictionary <string, UnifiedUnaryOperator> op2Kind)
{
return(UnifiedUnaryExpression.Create(
createExpression(node.NthElement(1)),
op2Kind[node.FirstElement().Value].DeepCopy()));
}
public static UnifiedExpression CreateUntil(XElement node)
{
Contract.Requires(node != null);
Contract.Requires(node.Name() == "until");
var cond =
UnifiedUnaryExpression.Create(
CreateExpresion(node.FirstElement()),
UnifiedUnaryOperator.Create(
"!", UnifiedUnaryOperatorKind.Not));
var secondNode = node.NthElement(1);
if (node.LastElement().Name() == "TrueClass")
{
return(UnifiedWhile.Create(cond, CreateSmartBlock(secondNode)));
}
return(UnifiedDoWhile.Create(cond, CreateSmartBlock(secondNode)));
}
public override bool Visit(
UnifiedUnaryExpression element, VisitorArgument arg)
{
if (element.Operator.Kind
== UnifiedUnaryOperatorKind.PostIncrementAssign ||
element.Operator.Kind
== UnifiedUnaryOperatorKind.PostDecrementAssign)
{
element.Operand.TryAccept(this, arg.Set(Paren));
element.Operator.TryAccept(this, arg);
}
else
{
element.Operator.TryAccept(this, arg);
element.Operand.TryAccept(this, arg.Set(Paren));
}
return(false);
}
//単項式
public override bool Visit(
UnifiedUnaryExpression element, VisitorArgument arg)
{
//後置演算子が付く場合 : a++ || a--
if (element.Operator.Kind
== UnifiedUnaryOperatorKind.PostIncrementAssign ||
element.Operator.Kind
== UnifiedUnaryOperatorKind.PostDecrementAssign)
{
element.Operand.TryAccept(this, arg.Set(Paren));
element.Operator.TryAccept(this, arg);
}
//それ以外の場合は前置演算子(または演算子なし)
else
{
element.Operator.TryAccept(this, arg);
element.Operand.TryAccept(this, arg.Set(Paren));
}
return(true);
}
public override bool Visit(
UnifiedUnaryExpression element, VisitorArgument arg)
{
var paren = GetRequiredParen(element)
? Tuple.Create("(", ")") : Tuple.Create("", "");
Writer.Write(paren.Item1);
if (element.Operator.Kind
== UnifiedUnaryOperatorKind.PostIncrementAssign ||
element.Operator.Kind
== UnifiedUnaryOperatorKind.PostDecrementAssign)
{
element.Operand.TryAccept(this, arg.Set(Paren));
element.Operator.TryAccept(this, arg);
}
else
{
element.Operator.TryAccept(this, arg);
element.Operand.TryAccept(this, arg.Set(Paren));
}
Writer.Write(paren.Item2);
return(true);
}
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);
}
//単項式
public override bool Visit(
UnifiedUnaryExpression element, VisitorArgument arg)
{
//後置演算子が付く場合 : a++ || a--
if (element.Operator.Kind
== UnifiedUnaryOperatorKind.PostIncrementAssign ||
element.Operator.Kind
== UnifiedUnaryOperatorKind.PostDecrementAssign) {
element.Operand.TryAccept(this, arg.Set(Paren));
element.Operator.TryAccept(this, arg);
}
//それ以外の場合は前置演算子(または演算子なし)
else {
element.Operator.TryAccept(this, arg);
element.Operand.TryAccept(this, arg.Set(Paren));
}
return true;
}
// 単項式(UnifiedUnaryExpression)
public override bool Visit(
UnifiedUnaryExpression element, VisitorArgument arg)
{
var paren = GetRequiredParen(element)
? Tuple.Create("(", ")") : Tuple.Create("", "");
Writer.Write(paren.Item1);
// TODO 後置演算子が++と--以外にないか確認
// 前置演算子か後置演算子かで、演算子を先に出力するか決定します
if (element.Operator.Kind
== UnifiedUnaryOperatorKind.PostIncrementAssign ||
element.Operator.Kind
== UnifiedUnaryOperatorKind.PostDecrementAssign) {
element.Operand.TryAccept(this, arg.Set(Paren));
element.Operator.TryAccept(this, arg);
} else {
element.Operator.TryAccept(this, arg);
element.Operand.TryAccept(this, arg.Set(Paren));
}
Writer.Write(paren.Item2);
return true;
}
public override bool Visit(
UnifiedUnaryExpression element, VisitorArgument arg)
{
if (element.Operator.Kind
== UnifiedUnaryOperatorKind.PostIncrementAssign ||
element.Operator.Kind
== UnifiedUnaryOperatorKind.PostDecrementAssign) {
element.Operand.TryAccept(this, arg.Set(Paren));
element.Operator.TryAccept(this, arg);
} else {
element.Operator.TryAccept(this, arg);
element.Operand.TryAccept(this, arg.Set(Paren));
}
return false;
}
