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); }