public string Visit(PyAst.UnaryExpression node)
{
string operatorText;
switch (node.Op)
{
case IronPython.Compiler.PythonOperator.Add: operatorText = "+"; break;
case IronPython.Compiler.PythonOperator.Subtract: operatorText = "-"; break;
case IronPython.Compiler.PythonOperator.Invert: operatorText = "~"; break;
case IronPython.Compiler.PythonOperator.Not:
return($"(not {Visit(node.Expression)})");
default:
throw new NotImplementedException($"Printing of operator {node.Op} not implemented");
}
return($"{operatorText}{Visit(node.Expression)}");
}
// factor: ('+'|'-'|'~') factor | power
private Expression ParseFactor() {
var start = _lookahead.Span.Start;
Expression ret;
switch (PeekToken().Kind) {
case TokenKind.Add:
NextToken();
ret = new UnaryExpression(PythonOperator.Pos, ParseFactor());
break;
case TokenKind.Subtract:
NextToken();
ret = FinishUnaryNegate();
break;
case TokenKind.Twiddle:
NextToken();
ret = new UnaryExpression(PythonOperator.Invert, ParseFactor());
break;
default:
return ParsePower();
}
ret.SetLoc(_globalParent, start, GetEnd());
return ret;
}
//not_test: 'not' not_test | comparison
private Expression ParseNotTest() {
if (MaybeEat(TokenKind.KeywordNot)) {
var start = GetStart();
Expression ret = new UnaryExpression(PythonOperator.Not, ParseNotTest());
ret.SetLoc(_globalParent, start, GetEnd());
return ret;
} else {
return ParseComparison();
}
}
internal UnaryOp(UnaryExpression expression)
: this() {
_op = (unaryop)Convert(expression.Op);
_operand = Convert(expression.Expression);
}
public override bool Walk(UnaryExpression node)
{
CommonWalk(node);
return true;
}
public override void PostWalk(UnaryExpression node)
{
string statement = Content();
switch (node.Op)
{
case IronPython.Compiler.PythonOperator.Negate:
Content("-{0}", statement);
break;
case IronPython.Compiler.PythonOperator.Not:
Content("!{0}", statement);
break;
case IronPython.Compiler.PythonOperator.In:
case IronPython.Compiler.PythonOperator.Invert:
case IronPython.Compiler.PythonOperator.Is:
case IronPython.Compiler.PythonOperator.IsNot:
case IronPython.Compiler.PythonOperator.None:
case IronPython.Compiler.PythonOperator.NotIn:
case IronPython.Compiler.PythonOperator.Pos:
case IronPython.Compiler.PythonOperator.TrueDivide:
default:
sink.Add(src, String.Format("Operator {0} is not supported.", node.Op), node.Span, UNSUPPORTED_OPERATOR, Severity.FatalError);
break;
}
CommonPostWalk(node);
}
// UnaryExpression
public bool Walk(UnaryExpression node)
{
return Process(node);
}
public void PostWalk(UnaryExpression node)
{
PostProcess(node);
}
object Deserialize(UnaryExpression expression)
{
object rhs = Deserialize(expression.Expression);
switch (expression.Op) {
case PythonOperator.Negate:
return Negate(rhs);
}
return rhs;
}
public virtual void PostWalk(UnaryExpression node)
{
}
// UnaryExpression
public virtual bool Walk(UnaryExpression node)
{
return true;
}
// UnaryExpression
public override bool Walk(UnaryExpression node)
{
node.Parent = _currentScope;
return(base.Walk(node));
}
// factor: ('+'|'-'|'~') factor | power
private Expression ParseFactor()
{
Token t = PeekToken();
Location start = GetStart();
Expression ret;
switch (t.Kind) {
case TokenKind.Add:
NextToken();
ret = new UnaryExpression(PythonOperator.Pos, ParseFactor());
break;
case TokenKind.Subtract:
NextToken();
ret = FinishUnaryNegate();
break;
case TokenKind.Twiddle:
NextToken();
ret = new UnaryExpression(PythonOperator.Invert, ParseFactor());
break;
default:
return ParsePower();
}
ret.SetLoc(GetExternal(), start, GetEnd());
return ret;
}
public override bool Walk(UnaryExpression node)
{
writer.WriteLine("Unary");
return base.Walk(node);
}
