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