//単項演算子
public override bool Visit(
UnifiedUnaryOperator element, VisitorArgument arg)
{
var kind = element.Kind;
switch (kind) {
case (UnifiedUnaryOperatorKind.Negate):
Writer.Write("-");
break;
case (UnifiedUnaryOperatorKind.Not):
Writer.Write("!");
break;
case (UnifiedUnaryOperatorKind.PostDecrementAssign):
case (UnifiedUnaryOperatorKind.PreDecrementAssign):
Writer.Write("--");
break;
case (UnifiedUnaryOperatorKind.PostIncrementAssign):
case (UnifiedUnaryOperatorKind.PreIncrementAssign):
Writer.Write("++");
break;
case (UnifiedUnaryOperatorKind.UnaryPlus):
Writer.Write("+");
break;
case (UnifiedUnaryOperatorKind.OnesComplement):
Writer.Write("~");
break;
case (UnifiedUnaryOperatorKind.Unknown):
Writer.Write(element.Sign);
break;
default:
throw new InvalidOperationException();
}
return false;
}
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)));
}
// Operator
public static UnifiedElement CreateUnaryOperator(XElement node)
{
Contract.Requires(node != null);
Contract.Requires(node.Name() == "unary_operator");
/*
* unary_operator
* : '&'
| '*'
| '+'
| '-'
| '~'
| '!'
*/
UnifiedUnaryOperatorKind kind;
switch (node.Value)
{
case "&":
kind = UnifiedUnaryOperatorKind.Address;
break;
case "*":
kind = UnifiedUnaryOperatorKind.Indirect;
break;
case "+":
kind = UnifiedUnaryOperatorKind.UnaryPlus;
break;
case "-":
kind = UnifiedUnaryOperatorKind.Negate;
break;
case "~":
kind = UnifiedUnaryOperatorKind.OnesComplement;
break;
case "!":
kind = UnifiedUnaryOperatorKind.Not;
break;
default:
throw new InvalidOperationException();
}
return(UnifiedUnaryOperator.Create(node.Value, kind));
}
private static UnifiedUnaryOperator LookupUnaryOperator(
UnaryOperatorType op)
{
switch (op)
{
case UnaryOperatorType.Not:
return(UnifiedUnaryOperator.Create(
"!", UnifiedUnaryOperatorKind.Not));
case UnaryOperatorType.BitNot:
return(UnifiedUnaryOperator.Create(
"!", UnifiedUnaryOperatorKind.OnesComplement));
case UnaryOperatorType.Plus:
return(UnifiedUnaryOperator.Create(
"+", UnifiedUnaryOperatorKind.UnaryPlus));
case UnaryOperatorType.Minus:
return(UnifiedUnaryOperator.Create(
"-", UnifiedUnaryOperatorKind.Negate));
case UnaryOperatorType.Increment:
return(UnifiedUnaryOperator.Create(
"++", UnifiedUnaryOperatorKind.PreIncrementAssign));
case UnaryOperatorType.PostIncrement:
return(UnifiedUnaryOperator.Create(
"++", UnifiedUnaryOperatorKind.PostIncrementAssign));
case UnaryOperatorType.Decrement:
return(UnifiedUnaryOperator.Create(
"--", UnifiedUnaryOperatorKind.PreDecrementAssign));
case UnaryOperatorType.PostDecrement:
return(UnifiedUnaryOperator.Create(
"--", UnifiedUnaryOperatorKind.PostDecrementAssign));
case UnaryOperatorType.AddressOf:
return(UnifiedUnaryOperator.Create(
"&", UnifiedUnaryOperatorKind.Address));
case UnaryOperatorType.Dereference:
return(UnifiedUnaryOperator.Create(
"*", UnifiedUnaryOperatorKind.Indirect));
}
throw new ArgumentException("Unknown operator: " + op);
}
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(
UnifiedUnaryOperator element, VisitorArgument arg)
{
var kind = element.Kind;
switch (kind)
{
case (UnifiedUnaryOperatorKind.Negate):
Writer.Write("-");
break;
case (UnifiedUnaryOperatorKind.Not):
Writer.Write("!");
break;
case (UnifiedUnaryOperatorKind.PostDecrementAssign):
case (UnifiedUnaryOperatorKind.PreDecrementAssign):
Writer.Write("--");
break;
case (UnifiedUnaryOperatorKind.PostIncrementAssign):
case (UnifiedUnaryOperatorKind.PreIncrementAssign):
Writer.Write("++");
break;
case (UnifiedUnaryOperatorKind.UnaryPlus):
Writer.Write("+");
break;
case (UnifiedUnaryOperatorKind.OnesComplement):
Writer.Write("~");
break;
case (UnifiedUnaryOperatorKind.Unknown):
Writer.Write(element.Sign);
break;
default:
throw new InvalidOperationException();
}
return(false);
}
CreatePrefixUnaryOperatorDictionaryForJava()
{
return(new[] {
// Arithmetic
UnifiedUnaryOperator.Create(
"+", UnifiedUnaryOperatorKind.UnaryPlus),
UnifiedUnaryOperator.Create(
"-", UnifiedUnaryOperatorKind.Negate),
UnifiedUnaryOperator.Create(
"++", UnifiedUnaryOperatorKind.PreIncrementAssign),
UnifiedUnaryOperator.Create(
"--", UnifiedUnaryOperatorKind.PreDecrementAssign),
// Bit
UnifiedUnaryOperator.Create(
"~", UnifiedUnaryOperatorKind.OnesComplement),
// Logical
UnifiedUnaryOperator.Create(
"!", UnifiedUnaryOperatorKind.Not),
UnifiedUnaryOperator.Create(
"not", UnifiedUnaryOperatorKind.Not),
}
.ToDictionary(o => o.Sign));
}
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);
}
