/// <summary>
/// Both the operands of this operator are constants. See if we can evaluate them
/// </summary>
/// <param name="left">left-side operand</param>
/// <param name="right">right-side operand</param>
private void EvalThisOperator(BinaryOperator node, ConstantWrapper left, ConstantWrapper right)
{
// we can evaluate these operators if we know both operands are literal
// number, boolean, string or null
ConstantWrapper newLiteral = null;
switch (node.OperatorToken)
{
case JSToken.Multiply:
newLiteral = Multiply(left, right);
break;
case JSToken.Divide:
newLiteral = Divide(left, right);
if (newLiteral != null && newLiteral.ToCode().Length > node.ToCode().Length)
{
// the result is bigger than the expression.
// eg: 1/3 is smaller than .333333333333333
// never mind.
newLiteral = null;
}
break;
case JSToken.Modulo:
newLiteral = Modulo(left, right);
if (newLiteral != null && newLiteral.ToCode().Length > node.ToCode().Length)
{
// the result is bigger than the expression.
// eg: 46.5%6.3 is smaller than 2.4000000000000012
// never mind.
newLiteral = null;
}
break;
case JSToken.Plus:
newLiteral = Plus(left, right);
break;
case JSToken.Minus:
newLiteral = Minus(left, right);
break;
case JSToken.LeftShift:
newLiteral = LeftShift(left, right);
break;
case JSToken.RightShift:
newLiteral = RightShift(left, right);
break;
case JSToken.UnsignedRightShift:
newLiteral = UnsignedRightShift(left, right);
break;
case JSToken.LessThan:
newLiteral = LessThan(left, right);
break;
case JSToken.LessThanEqual:
newLiteral = LessThanOrEqual(left, right);
break;
case JSToken.GreaterThan:
newLiteral = GreaterThan(left, right);
break;
case JSToken.GreaterThanEqual:
newLiteral = GreaterThanOrEqual(left, right);
break;
case JSToken.Equal:
newLiteral = Equal(left, right);
break;
case JSToken.NotEqual:
newLiteral = NotEqual(left, right);
break;
case JSToken.StrictEqual:
newLiteral = StrictEqual(left, right);
break;
case JSToken.StrictNotEqual:
newLiteral = StrictNotEqual(left, right);
break;
case JSToken.BitwiseAnd:
newLiteral = BitwiseAnd(left, right);
break;
case JSToken.BitwiseOr:
newLiteral = BitwiseOr(left, right);
break;
case JSToken.BitwiseXor:
newLiteral = BitwiseXor(left, right);
break;
case JSToken.LogicalAnd:
newLiteral = LogicalAnd(left, right);
break;
case JSToken.LogicalOr:
newLiteral = LogicalOr(left, right);
break;
default:
// an operator we don't want to evaluate
break;
}
// if we can combine them...
if (newLiteral != null)
{
// first we want to check if the new combination is a string literal, and if so, whether
// it's now the sole parameter of a member-bracket call operator. If so, instead of replacing our
// binary operation with the new constant, we'll replace the entire call with a member-dot
// expression
if (!ReplaceMemberBracketWithDot(node, newLiteral))
{
node.Parent.ReplaceChild(node, newLiteral);
}
}
}