private void EvalThisOperator(JsBinaryOperator node, JsConstantWrapper left, JsConstantWrapper right)
{
// we can evaluate these operators if we know both operands are literal
// number, boolean, string or null
JsConstantWrapper 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))
{
ReplaceNodeWithLiteral(node, newLiteral);
}
}
}
