private Expression ParseSimpleExpression() { var left = ParseTerm(); if (left == null) { //exception unexpected something TODO: deal with it return(null); } while (true) { var operatorToken = PeekToken(); if (operatorToken == null || !AdditiveOperators.Contains(operatorToken.Type)) { break; } NextToken(); var right = ParseTerm(); left = new AdditiveOperator(operatorToken, left, right); } return(left); }
public AstPrinterNode Visit(AdditiveOperator node) { var printer = new AstPrinterNode(node.ToString()); printer.AddChild(node.Left.Accept(this)); printer.AddChild(node.Right.Accept(this)); return(printer); }
public AdditiveExpression(Expression left) { leftExpression = left; rightExpression = null; additiveOperator = null; }
public AdditiveExpression(Expression left, Expression right, AdditiveOperator operatorValue) { leftExpression = left; rightExpression = right; additiveOperator = operatorValue; }
public bool Visit(AdditiveOperator node) { if (node.SymType != null) { return(true); } node.Left.Accept(this); node.Right.Accept(this); // we can use additive operators only with integer and float ('+', '-') and boolean ('or', 'xor') if (!(node.Left.SymType.Equals(SymbolStack.SymBool) && node.Right.SymType.Equals(SymbolStack.SymBool) || (node.Left.SymType.Equals(SymbolStack.SymInt) || node.Left.SymType.Equals(SymbolStack.SymFloat)) && (node.Right.SymType.Equals(SymbolStack.SymInt) || node.Right.SymType.Equals(SymbolStack.SymFloat)))) { throw new Exception(string.Format("({0}, {1}) semantic error: incompatible types: '{2}' {3} '{4}'", node.Token.Line, node.Token.Column, node.Left.SymType, node.Token.Value, node.Right.SymType)); } switch (node.Token.Type) { case TokenType.SumOperator: case TokenType.DifOperator: { if (node.Left.SymType.Equals(SymbolStack.SymBool) || node.Right.SymType.Equals(SymbolStack.SymBool)) { throw new Exception(string.Format( "({0}, {1}) semantic error: incompatible types: '{2}' {3} '{4}'", node.Token.Line, node.Token.Column, node.Left.SymType, node.Token.Value, node.Right.SymType)); } if (node.Left.SymType.Equals(SymbolStack.SymInt) && node.Right.SymType.Equals(SymbolStack.SymFloat)) { node.Left = new Cast(node.Left) { SymType = SymbolStack.SymFloat, IsLValue = false } } ; if (node.Right.SymType.Equals(SymbolStack.SymInt) && node.Left.SymType.Equals(SymbolStack.SymFloat)) { node.Right = new Cast(node.Right) { SymType = SymbolStack.SymFloat, IsLValue = false } } ; node.SymType = node.Left.SymType.Equals(SymbolStack.SymInt) && node.Right.SymType.Equals(SymbolStack.SymInt) ? SymbolStack.SymInt : SymbolStack.SymFloat; break; } case TokenType.Or: case TokenType.Xor: { if (!node.Left.SymType.Equals(SymbolStack.SymBool) || !node.Right.SymType.Equals(SymbolStack.SymBool)) { throw new Exception(string.Format( "({0}, {1}) semantic error: incompatible types: '{2}' {3} '{4}'", node.Token.Line, node.Token.Column, node.Left.SymType, node.Token.Value, node.Right.SymType)); } node.SymType = SymbolStack.SymBool; break; } default: { throw new Exception(string.Format( "({0}, {1}) semantic error: unhandled additive operator '{2}'", node.Token.Line, node.Token.Column, node.Token.Value)); } } node.IsLValue = false; return(true); }
public static Completion Calculate(IValue leftValue, AdditiveOperator additiveOperator, IValue rightValue) { IValue leftForToNumber, rightForToNumber; if (additiveOperator == AdditiveOperator.Add) { var lprim = leftValue.ToPrimitive(); if (lprim.IsAbrupt()) { return(lprim); } var rprim = rightValue.ToPrimitive(); if (rprim.IsAbrupt()) { return(rprim); } if (lprim.value is StringValue || rprim.value is StringValue) { var lstr = lprim.value !.ToJsString(); if (lstr.IsAbrupt()) { return(lstr); } var rstr = rprim.value !.ToJsString(); if (rstr.IsAbrupt()) { return(rstr); } return(Completion.NormalCompletion(new StringValue((lstr.value !as StringValue) !.@string + (rstr.value !as StringValue) !.@string))); } leftForToNumber = lprim.value !; rightForToNumber = rprim.value !; } else { leftForToNumber = leftValue; rightForToNumber = rightValue; } var lnum = leftForToNumber.ToNumber(); if (lnum.IsAbrupt()) { return(lnum); } var rnum = rightForToNumber.ToNumber(); if (rnum.IsAbrupt()) { return(rnum); } if (additiveOperator == AdditiveOperator.Add) { return(Completion.NormalCompletion(new NumberValue((lnum.value !as NumberValue) !.number + (rnum.value !as NumberValue) !.number))); } else { return(Completion.NormalCompletion(new NumberValue((lnum.value !as NumberValue) !.number - (rnum.value !as NumberValue) !.number))); } }
public AdditiveExpression(AbstractAdditiveExpression additiveExpression, AdditiveOperator additiveOperator, AbstractMultiplicativeExpression multiplicativeExpression, bool isStrictMode) : base(isStrictMode) { this.additiveExpression = additiveExpression; this.additiveOperator = additiveOperator; this.multiplicativeExpression = multiplicativeExpression; }