public MathFuncNode VisitBinaryExpression(BinaryExpressionContext context) { MathFuncNode arg1 = Visit(context.expression(0)); MathFuncNode arg2 = Visit(context.expression(1)); KnownFuncType funcType; if (context.Plus() != null) { funcType = KnownFuncType.Add; } else if (context.Minus() != null) { funcType = KnownFuncType.Sub; var second = new FuncNode(KnownFuncType.Neg, new MathFuncNode[] { arg2 }); var result = new FuncNode(KnownFuncType.Add, new MathFuncNode[] { arg1, second }); return(result); } else if (context.Mult() != null) { funcType = KnownFuncType.Mult; } else if (context.Div() != null) { var second = new FuncNode(KnownFuncType.Pow, new MathFuncNode[] { arg2, new ValueNode(-1) }); var result = new FuncNode(KnownFuncType.Mult, new MathFuncNode[] { arg1, second }); return(result); } else { funcType = KnownFuncType.Pow; } return(new FuncNode(funcType, new MathFuncNode[] { arg1, arg2 })); }
public override Node VisitBinaryExpression(BinaryExpressionContext context) { var expression = new ExpressionNode(context.Start, _operatorFactory.CreateBinaryOperator(context.binaryOperator().Start)); expression.AddChild(Visit(context.expression(0))); expression.AddChild(Visit(context.expression(1))); return(expression); }
public ExpressionContext expression() { ExpressionContext _localctx = new ExpressionContext(Context, State); EnterRule(_localctx, 16, RULE_expression); int _la; try { State = 76; ErrorHandler.Sync(this); switch (Interpreter.AdaptivePredict(TokenStream, 6, Context)) { case 1: _localctx = new BinaryExpressionContext(_localctx); EnterOuterAlt(_localctx, 1); { State = 72; ((BinaryExpressionContext)_localctx).var = Match(ID); State = 73; ((BinaryExpressionContext)_localctx).@operator = TokenStream.LT(1); _la = TokenStream.LA(1); if (!(_la == T__9 || _la == T__10)) { ((BinaryExpressionContext)_localctx).@operator = ErrorHandler.RecoverInline(this); } else { ErrorHandler.ReportMatch(this); Consume(); } State = 74; Match(T__11); } break; case 2: _localctx = new UnaryExpressionContext(_localctx); EnterOuterAlt(_localctx, 2); { State = 75; ((UnaryExpressionContext)_localctx).var = Match(ID); } break; } } catch (RecognitionException re) { _localctx.exception = re; ErrorHandler.ReportError(this, re); ErrorHandler.Recover(this, re); } finally { ExitRule(); } return(_localctx); }
public override void ExitBinaryExpression([NotNull] BinaryExpressionContext context) { base.ExitBinaryExpression(context); var leftSideToken = (context.Parent as InstructionContext).Start; var rightSideToken = context.ID().Symbol; CheckValidVar(leftSideToken); CheckValidVar(rightSideToken); CheckVarsAreEqual( leftSideToken, rightSideToken, "Increment and decrement instructions must have the same var at both sides."); }
public override Expression VisitBinaryExpression(BinaryExpressionContext context) { var binaryOperator = context.binary_operator(); var left = Visit(context.expression(0)); var right = Visit(context.expression(1)); if (binaryOperator == null || binaryOperator.AND() != null) { return Expression.And(left, right); } if (binaryOperator.OR() != null) { return Expression.Or(left, right); } else if (binaryOperator.XOR() != null) { return Expression.ExclusiveOr(left, right); } return Expression.And(left, right); }
private ExpressionContext expression(int _p) { ParserRuleContext _parentctx = Context; int _parentState = State; ExpressionContext _localctx = new ExpressionContext(Context, _parentState); ExpressionContext _prevctx = _localctx; int _startState = 2; EnterRecursionRule(_localctx, 2, RULE_expression, _p); try { int _alt; EnterOuterAlt(_localctx, 1); { State = 24; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case LPAREN: { _localctx = new ParenExpressionContext(_localctx); Context = _localctx; _prevctx = _localctx; State = 14; Match(LPAREN); State = 15; expression(0); State = 16; Match(RPAREN); } break; case NOT: { _localctx = new NotExpressionContext(_localctx); Context = _localctx; _prevctx = _localctx; State = 18; Match(NOT); State = 19; expression(7); } break; case TRUE: case FALSE: { _localctx = new BoolExpressionContext(_localctx); Context = _localctx; _prevctx = _localctx; State = 20; @bool(); } break; case IDENTIFIER: { _localctx = new IdentifierExpressionContext(_localctx); Context = _localctx; _prevctx = _localctx; State = 21; Match(IDENTIFIER); } break; case DECIMAL: { _localctx = new DecimalExpressionContext(_localctx); Context = _localctx; _prevctx = _localctx; State = 22; Match(DECIMAL); } break; case STRING: { _localctx = new StringExpressionContext(_localctx); Context = _localctx; _prevctx = _localctx; State = 23; Match(STRING); } break; default: throw new NoViableAltException(this); } Context.Stop = TokenStream.LT(-1); State = 36; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream, 2, Context); while (_alt != 2 && _alt != global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER) { if (_alt == 1) { if (ParseListeners != null) { TriggerExitRuleEvent(); } _prevctx = _localctx; { State = 34; ErrorHandler.Sync(this); switch (Interpreter.AdaptivePredict(TokenStream, 1, Context)) { case 1: { _localctx = new ComparatorExpressionContext(new ExpressionContext(_parentctx, _parentState)); ((ComparatorExpressionContext)_localctx).left = _prevctx; PushNewRecursionContext(_localctx, _startState, RULE_expression); State = 26; if (!(Precpred(Context, 6))) { throw new FailedPredicateException(this, "Precpred(Context, 6)"); } State = 27; ((ComparatorExpressionContext)_localctx).op = comparator(); State = 28; ((ComparatorExpressionContext)_localctx).right = expression(7); } break; case 2: { _localctx = new BinaryExpressionContext(new ExpressionContext(_parentctx, _parentState)); ((BinaryExpressionContext)_localctx).left = _prevctx; PushNewRecursionContext(_localctx, _startState, RULE_expression); State = 30; if (!(Precpred(Context, 5))) { throw new FailedPredicateException(this, "Precpred(Context, 5)"); } State = 31; ((BinaryExpressionContext)_localctx).op = binary(); State = 32; ((BinaryExpressionContext)_localctx).right = expression(6); } break; } } } State = 38; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream, 2, Context); } } } catch (RecognitionException re) { _localctx.exception = re; ErrorHandler.ReportError(this, re); ErrorHandler.Recover(this, re); } finally { UnrollRecursionContexts(_parentctx); } return(_localctx); }