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