/// <summary>
/// Evaluate: (CONST [op] OTHER) [op] CONST
/// </summary>
/// <param name="thisConstant">second constant</param>
/// <param name="otherConstant">first constant</param>
/// <param name="leftOperator">first operator</param>
private void EvalFarToTheLeft(BinaryOperator node, ConstantWrapper thisConstant, ConstantWrapper otherConstant, BinaryOperator leftOperator)
{
if (leftOperator.OperatorToken == JSToken.Minus)
{
if (node.OperatorToken == JSToken.Plus)
{
// minus-plus
ConstantWrapper newLiteral = NumericAddition(otherConstant, thisConstant);
if (newLiteral != null && NoOverflow(newLiteral))
{
RotateFromRight(node, leftOperator, newLiteral);
}
}
else if (node.OperatorToken == JSToken.Minus)
{
// minus-minus
ConstantWrapper newLiteral = Minus(otherConstant, thisConstant);
if (newLiteral != null && NoOverflow(newLiteral))
{
RotateFromRight(node, leftOperator, newLiteral);
}
}
}
else if (node.OperatorToken == JSToken.Multiply)
{
if (leftOperator.OperatorToken == JSToken.Multiply || leftOperator.OperatorToken == JSToken.Divide)
{
ConstantWrapper newLiteral = Multiply(otherConstant, thisConstant);
if (newLiteral != null && NoMultiplicativeOverOrUnderFlow(otherConstant, thisConstant, newLiteral))
{
RotateFromRight(node, leftOperator, newLiteral);
}
}
}
else if (node.OperatorToken == JSToken.Divide)
{
if (leftOperator.OperatorToken == JSToken.Divide)
{
// divide-divide
ConstantWrapper newLiteral = Divide(otherConstant, thisConstant);
if (newLiteral != null && NoMultiplicativeOverOrUnderFlow(otherConstant, thisConstant, newLiteral)
&& newLiteral.ToCode().Length <= thisConstant.ToCode().Length + otherConstant.ToCode().Length + 1)
{
RotateFromRight(node, leftOperator, newLiteral);
}
}
else if (leftOperator.OperatorToken == JSToken.Multiply)
{
// mult-divide
ConstantWrapper otherOverThis = Divide(otherConstant, thisConstant);
ConstantWrapper thisOverOther = Divide(thisConstant, otherConstant);
int otherOverThisLength = otherOverThis != null ? otherOverThis.ToCode().Length : int.MaxValue;
int thisOverOtherLength = thisOverOther != null ? thisOverOther.ToCode().Length : int.MaxValue;
if (otherOverThis != null && NoMultiplicativeOverOrUnderFlow(otherConstant, thisConstant, otherOverThis)
&& (thisOverOther == null || otherOverThisLength < thisOverOtherLength))
{
if (otherOverThisLength <= thisConstant.ToCode().Length + otherConstant.ToCode().Length + 1)
{
RotateFromRight(node, leftOperator, otherOverThis);
}
}
else if (thisOverOther != null && NoMultiplicativeOverOrUnderFlow(thisConstant, otherConstant, thisOverOther))
{
if (thisOverOtherLength <= thisConstant.ToCode().Length + otherConstant.ToCode().Length + 1)
{
// swap the operands
leftOperator.SwapOperands();
// operator is the opposite
leftOperator.OperatorToken = JSToken.Divide;
RotateFromLeft(node, leftOperator, thisOverOther);
}
}
}
}
}
/// <summary>
/// Eval the two constants: CONST [op] (OTHER [op] CONST)
/// </summary>
/// <param name="thisConstant">first constant</param>
/// <param name="otherConstant">second constant</param>
/// <param name="rightOperator">second operator</param>
private void EvalFarToTheRight(BinaryOperator node, ConstantWrapper thisConstant, ConstantWrapper otherConstant, BinaryOperator rightOperator)
{
if (rightOperator.OperatorToken == JSToken.Minus)
{
if (node.OperatorToken == JSToken.Plus)
{
// plus-minus
// our constant cannot be a string, though
if (!thisConstant.IsStringLiteral)
{
ConstantWrapper newLiteral = Minus(otherConstant, thisConstant);
if (newLiteral != null && NoOverflow(newLiteral))
{
RotateFromLeft(node, rightOperator, newLiteral);
}
}
}
else if (node.OperatorToken == JSToken.Minus)
{
// minus-minus
ConstantWrapper newLiteral = NumericAddition(thisConstant, otherConstant);
if (newLiteral != null && NoOverflow(newLiteral))
{
// but we need to swap the left and right operands first
rightOperator.SwapOperands();
// then rotate the node up after replacing old with new
RotateFromRight(node, rightOperator, newLiteral);
}
}
}
else if (node.OperatorToken == JSToken.Multiply)
{
if (rightOperator.OperatorToken == JSToken.Multiply)
{
// mult-mult
ConstantWrapper newLiteral = Multiply(thisConstant, otherConstant);
if (newLiteral != null && NoMultiplicativeOverOrUnderFlow(thisConstant, otherConstant, newLiteral))
{
RotateFromLeft(node, rightOperator, newLiteral);
}
}
else if (rightOperator.OperatorToken == JSToken.Divide)
{
// mult-divide
ConstantWrapper otherOverThis = Divide(otherConstant, thisConstant);
ConstantWrapper thisOverOther = Divide(thisConstant, otherConstant);
int otherOverThisLength = otherOverThis != null ? otherOverThis.ToCode().Length : int.MaxValue;
int thisOverOtherLength = thisOverOther != null ? thisOverOther.ToCode().Length : int.MaxValue;
if (otherOverThis != null && NoMultiplicativeOverOrUnderFlow(otherConstant, thisConstant, otherOverThis)
&& (thisOverOther == null || otherOverThisLength < thisOverOtherLength))
{
if (otherOverThisLength <= thisConstant.ToCode().Length + otherConstant.ToCode().Length + 1)
{
// swap the operands, but keep the operator
RotateFromLeft(node, rightOperator, otherOverThis);
}
}
else if (thisOverOther != null && NoMultiplicativeOverOrUnderFlow(thisConstant, otherConstant, thisOverOther))
{
if (thisOverOtherLength <= thisConstant.ToCode().Length + otherConstant.ToCode().Length + 1)
{
// keep the order, but opposite operator
rightOperator.OperatorToken = JSToken.Multiply;
RotateFromRight(node, rightOperator, thisOverOther);
}
}
}
}
else if (node.OperatorToken == JSToken.Divide)
{
if (rightOperator.OperatorToken == JSToken.Multiply)
{
// divide-mult
ConstantWrapper newLiteral = Divide(thisConstant, otherConstant);
if (newLiteral != null && NoMultiplicativeOverOrUnderFlow(thisConstant, otherConstant, newLiteral)
&& newLiteral.ToCode().Length <= thisConstant.ToCode().Length + otherConstant.ToCode().Length + 1)
{
// swap the operands
rightOperator.SwapOperands();
// change the operator
rightOperator.OperatorToken = JSToken.Divide;
RotateFromRight(node, rightOperator, newLiteral);
}
}
else if (rightOperator.OperatorToken == JSToken.Divide)
{
// divide-divide
ConstantWrapper newLiteral = Multiply(thisConstant, otherConstant);
if (newLiteral != null && NoMultiplicativeOverOrUnderFlow(thisConstant, otherConstant, newLiteral))
{
// but we need to swap the left and right operands first
rightOperator.SwapOperands();
// then rotate the node up after replacing old with new
RotateFromRight(node, rightOperator, newLiteral);
}
}
}
}
/// <summary>
/// Evaluate: CONST [op] (CONST [op] OTHER)
/// </summary>
/// <param name="thisConstant">first constant</param>
/// <param name="otherConstant">second constant</param>
/// <param name="leftOperator">second operator</param>
private void EvalToTheRight(BinaryOperator node, ConstantWrapper thisConstant, ConstantWrapper otherConstant, BinaryOperator rightOperator)
{
if (node.OperatorToken == JSToken.Plus)
{
if (rightOperator.OperatorToken == JSToken.Plus && otherConstant.IsStringLiteral)
{
// plus-plus, and the other constant is a string. So the right operator will be a string-concat
// that generates a string. And since this is a plus-operator, then this operator will be a string-
// concat as well. So we can just combine the strings now and replace our node with the right-hand
// operation
ConstantWrapper newLiteral = StringConcat(thisConstant, otherConstant);
if (newLiteral != null)
{
RotateFromRight(node, rightOperator, newLiteral);
}
}
else if (rightOperator.OperatorToken == JSToken.Minus && !thisConstant.IsStringLiteral)
{
// plus-minus. Now, the minus operation happens first, and it will perform a numeric
// operation. The plus is NOT string, so that means it will also be a numeric operation
// and we can combine the operators numericly.
ConstantWrapper newLiteral = NumericAddition(thisConstant, otherConstant);
if (newLiteral != null && NoOverflow(newLiteral))
{
RotateFromRight(node, rightOperator, newLiteral);
}
else
{
ConstantWrapper rightRight = rightOperator.Operand2 as ConstantWrapper;
if (rightRight != null)
{
EvalFarToTheRight(node, thisConstant, rightRight, rightOperator);
}
}
}
}
else if (node.OperatorToken == JSToken.Minus && rightOperator.OperatorToken == JSToken.Minus)
{
// minus-minus
// both operations are numeric, so we can combine the constant operands. However, we
// can't combine them into a plus, so make sure we do the minus in the opposite direction
ConstantWrapper newLiteral = Minus(otherConstant, thisConstant);
if (newLiteral != null && NoOverflow(newLiteral))
{
rightOperator.SwapOperands();
RotateFromLeft(node, rightOperator, newLiteral);
}
else
{
ConstantWrapper rightRight = rightOperator.Operand2 as ConstantWrapper;
if (rightRight != null)
{
EvalFarToTheRight(node, thisConstant, rightRight, rightOperator);
}
}
}
else if (node.OperatorToken == JSToken.Multiply
&& (rightOperator.OperatorToken == JSToken.Multiply || rightOperator.OperatorToken == JSToken.Divide))
{
// multiply-divide or multiply-multiply
// multiply the operands and use the right-hand operator
ConstantWrapper newLiteral = Multiply(thisConstant, otherConstant);
if (newLiteral != null && NoMultiplicativeOverOrUnderFlow(thisConstant, otherConstant, newLiteral))
{
RotateFromRight(node, rightOperator, newLiteral);
}
}
else if (node.OperatorToken == JSToken.Divide)
{
if (rightOperator.OperatorToken == JSToken.Multiply)
{
// divide-multiply
ConstantWrapper newLiteral = Divide(thisConstant, otherConstant);
if (newLiteral != null && NoMultiplicativeOverOrUnderFlow(thisConstant, otherConstant, newLiteral)
&& newLiteral.ToCode().Length < thisConstant.ToCode().Length + otherConstant.ToCode().Length + 1)
{
// flip the operator: multiply becomes divide; devide becomes multiply
rightOperator.OperatorToken = JSToken.Divide;
RotateFromRight(node, rightOperator, newLiteral);
}
}
else if (rightOperator.OperatorToken == JSToken.Divide)
{
// divide-divide
// get constants for left/right and for right/left
ConstantWrapper leftOverRight = Divide(thisConstant, otherConstant);
ConstantWrapper rightOverLeft = Divide(otherConstant, thisConstant);
// get the lengths of the resulting code
int leftOverRightLength = leftOverRight != null ? leftOverRight.ToCode().Length : int.MaxValue;
int rightOverLeftLength = rightOverLeft != null ? rightOverLeft.ToCode().Length : int.MaxValue;
// try whichever is smaller
if (leftOverRight != null && NoMultiplicativeOverOrUnderFlow(thisConstant, otherConstant, leftOverRight)
&& (rightOverLeft == null || leftOverRightLength < rightOverLeftLength))
{
// use left-over-right.
// but only if the resulting value is smaller than the original expression
if (leftOverRightLength <= thisConstant.ToCode().Length + otherConstant.ToCode().Length + 1)
{
// We don't need to swap the operands, but we do need to switch the operator
rightOperator.OperatorToken = JSToken.Multiply;
RotateFromRight(node, rightOperator, leftOverRight);
}
}
else if (rightOverLeft != null && NoMultiplicativeOverOrUnderFlow(otherConstant, thisConstant, rightOverLeft))
{
// but only if the resulting value is smaller than the original expression
if (rightOverLeftLength <= thisConstant.ToCode().Length + otherConstant.ToCode().Length + 1)
{
// use right-over-left. Keep the operator, but swap the operands
rightOperator.SwapOperands();
RotateFromLeft(node, rightOperator, rightOverLeft);
}
}
}
}
}