private object UnaryOperation(CalculatorParser.ExpressionContext e, ITerminalNode op) { var n = e.Accept(this); //var varName = ""; //object varValue = null; switch (op.Symbol.Type) { case CalculatorParser.Not: return(!(bool)n); case CalculatorParser.Minus: if (n is int) { return(-(int)n); } else { return(-(float)n); } } return(n); }
public override object VisitExpression([NotNull] CalculatorParser.ExpressionContext context) { object result = null; if (context.children.Count == 1) { // If it is an Id, then return the value if (context.Id() != null) { try { result = GetValue(context.Id()); } catch (KeyNotFoundException e) { throw new Exception($"{context.Id().Accept(this) as string} is undeclared"); } return(result); } // Else let VisitTerminal handle it result = context.children[0].Accept(this); return(result); } var exprs = context.expression(); if (exprs.Length == 1) { //if (context.Id() != null) { // var d = exprs[0].Accept(this); // var s = context.Id().Accept(this); // result = ObjectOperation(d, s, CalculatorParser.Dot); // return result; //} // ++x, --x if (context.children[1] is ITerminalNode node && node.Symbol.Type == CalculatorParser.LeftParenthesis) { var func = context.expression()[0].Accept(this); var paramList = context.paramList() is null ? null : context.paramList().Accept(this) as List <object>; result = FuncOperation(func as IFunction, paramList as List <object>, m_iterStack); m_iterStack = null; m_iterName = ""; return(result); } var op = context.children[0] as ITerminalNode; result = UnaryOperation(exprs[0], op); return(result); } if (exprs.Length == 2) { object l = null; object r = null; var op = context.children[1] as ITerminalNode; if (op.Symbol.Type == CalculatorParser.Dot) { l = exprs[0].Accept(this); r = exprs[1].Id().Accept(this); result = ObjectOperation(l as Stack, r, op.Symbol.Type); return(result); } if (op.Symbol.Type == CalculatorParser.LeftBracket) { l = exprs[0].Accept(this); r = exprs[1].Accept(this); result = ObjectOperation(l as Stack, r, op.Symbol.Type); return(result); } l = exprs[0].Accept(this); r = exprs[1].Accept(this); return(BinaryOperation(l, r, op.Symbol.Type)); } throw new InvalidOperationException(); }
public override int VisitExpression([NotNull] ExpressionContext context) { return(HandleGroup(context.operand(), context.OPERATOR())); }
private double WalkRight(CalculatorParser.ExpressionContext context) { return(Visit(context.GetRuleContext <CalculatorParser.ExpressionContext>(1))); }
/// <summary> /// Visit a parse tree produced by <see cref="CalculatorParser.expression"/>. /// <para> /// The default implementation returns the result of calling <see cref="AbstractParseTreeVisitor{Result}.VisitChildren(IRuleNode)"/> /// on <paramref name="context"/>. /// </para> /// </summary> /// <param name="context">The parse tree.</param> /// <return>The visitor result.</return> public virtual Result VisitExpression([NotNull] CalculatorParser.ExpressionContext context) { return(VisitChildren(context)); }