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)
{
// swap the operands and opposite operator
rightOperator.SwapOperands();
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);
}
}
}
}
private void EvalFarToTheLeft(BinaryOperator node, ConstantWrapper thisConstant, ConstantWrapper otherConstant, BinaryOperator leftOperator)
{
if (leftOperator.OperatorToken == JSToken.Minus)
{
if (node.OperatorToken == JSToken.Plus)
{
// minus-plus
// the minus will be a numeric operator, but if this constant is a string, it will be a
// string concatenation and we can't combine it.
if (thisConstant.PrimitiveType != PrimitiveType.String && thisConstant.PrimitiveType != PrimitiveType.Other)
{
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);
}
}
}
}
}
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);
}
}
}
}
}
private void EvalToTheLeft(BinaryOperator node, ConstantWrapper thisConstant, ConstantWrapper otherConstant, BinaryOperator leftOperator)
{
if (leftOperator.OperatorToken == JSToken.Plus && node.OperatorToken == JSToken.Plus)
{
// plus-plus
// the other operation goes first, so if the other constant is a string, then we know that
// operation will do a string concatenation, which will force our operation to be a string
// concatenation. If the other constant is not a string, then we won't know until runtime and
// we can't combine them.
if (otherConstant.IsStringLiteral)
{
// the other constant is a string -- so we can do the string concat and combine them
ConstantWrapper newLiteral = StringConcat(otherConstant, thisConstant);
if (newLiteral != null)
{
RotateFromLeft(node, leftOperator, newLiteral);
}
}
}
else if (leftOperator.OperatorToken == JSToken.Minus)
{
if (node.OperatorToken == JSToken.Plus)
{
// minus-plus
// the minus operator goes first and will always convert to number.
// if our constant is not a string, then it will be a numeric addition and we can combine them.
// if our constant is a string, then we'll end up doing a string concat, so we can't combine
if (!thisConstant.IsStringLiteral)
{
// two numeric operators. a-n1+n2 is the same as a-(n1-n2)
ConstantWrapper newLiteral = Minus(otherConstant, thisConstant);
if (newLiteral != null && NoOverflow(newLiteral))
{
// a-(-n) is numerically equivalent as a+n -- and takes fewer characters to represent.
// BUT we can't do that because that might change a numeric operation (the original minus)
// to a string concatenation if the unknown operand turns out to be a string!
RotateFromLeft(node, leftOperator, newLiteral);
}
else
{
// if the left-left is a constant, then we can try combining with it
ConstantWrapper leftLeft = leftOperator.Operand1 as ConstantWrapper;
if (leftLeft != null)
{
EvalFarToTheLeft(node, thisConstant, leftLeft, leftOperator);
}
}
}
}
else if (node.OperatorToken == JSToken.Minus)
{
// minus-minus. Both operations are numeric.
// (a-n1)-n2 => a-(n1+n2), so we can add the two constants and subtract from
// the left-hand non-constant.
ConstantWrapper newLiteral = NumericAddition(otherConstant, thisConstant);
if (newLiteral != null && NoOverflow(newLiteral))
{
// make it the new right-hand literal for the left-hand operator
// and make the left-hand operator replace our operator
RotateFromLeft(node, leftOperator, newLiteral);
}
else
{
// if the left-left is a constant, then we can try combining with it
ConstantWrapper leftLeft = leftOperator.Operand1 as ConstantWrapper;
if (leftLeft != null)
{
EvalFarToTheLeft(node, thisConstant, leftLeft, leftOperator);
}
}
}
}
else if (leftOperator.OperatorToken == node.OperatorToken
&& (node.OperatorToken == JSToken.Multiply || node.OperatorToken == JSToken.Divide))
{
// either multiply-multiply or divide-divide
// either way, we use the other operand and the product of the two constants.
// if the product blows up to an infinte value, then don't combine them because that
// could change the way the program goes at runtime, depending on the unknown value.
ConstantWrapper newLiteral = Multiply(otherConstant, thisConstant);
if (newLiteral != null && NoMultiplicativeOverOrUnderFlow(otherConstant, thisConstant, newLiteral))
{
RotateFromLeft(node, leftOperator, newLiteral);
}
}
else if ((leftOperator.OperatorToken == JSToken.Multiply && node.OperatorToken == JSToken.Divide)
|| (leftOperator.OperatorToken == JSToken.Divide && node.OperatorToken == JSToken.Multiply))
{
if (m_parser.Settings.IsModificationAllowed(TreeModifications.EvaluateNumericExpressions))
{
// get the two division operators
ConstantWrapper otherOverThis = Divide(otherConstant, thisConstant);
ConstantWrapper thisOverOther = Divide(thisConstant, otherConstant);
// get the lengths
int otherOverThisLength = otherOverThis != null ? otherOverThis.ToCode().Length : int.MaxValue;
int thisOverOtherLength = thisOverOther != null ? thisOverOther.ToCode().Length : int.MaxValue;
// we'll want to use whichever one is shorter, and whichever one does NOT involve an overflow
// or possible underflow
if (otherOverThis != null && NoMultiplicativeOverOrUnderFlow(otherConstant, thisConstant, otherOverThis)
&& (thisOverOther == null || otherOverThisLength < thisOverOtherLength))
{
// but only if it's smaller than the original expression
if (otherOverThisLength <= otherConstant.ToCode().Length + thisConstant.ToCode().Length + 1)
{
// same operator
RotateFromLeft(node, leftOperator, otherOverThis);
}
}
else if (thisOverOther != null && NoMultiplicativeOverOrUnderFlow(thisConstant, otherConstant, thisOverOther))
{
// but only if it's smaller than the original expression
if (thisOverOtherLength <= otherConstant.ToCode().Length + thisConstant.ToCode().Length + 1)
{
// opposite operator
leftOperator.OperatorToken = leftOperator.OperatorToken == JSToken.Multiply ? JSToken.Divide : JSToken.Multiply;
RotateFromLeft(node, leftOperator, thisOverOther);
}
}
}
}
else if (node.OperatorToken == leftOperator.OperatorToken
&& (node.OperatorToken == JSToken.BitwiseAnd || node.OperatorToken == JSToken.BitwiseOr || node.OperatorToken == JSToken.BitwiseXor))
{
// identical bitwise operators can be combined
ConstantWrapper newLiteral = null;
switch (node.OperatorToken)
{
case JSToken.BitwiseAnd:
newLiteral = BitwiseAnd(otherConstant, thisConstant);
break;
case JSToken.BitwiseOr:
newLiteral = BitwiseOr(otherConstant, thisConstant);
break;
case JSToken.BitwiseXor:
newLiteral = BitwiseXor(otherConstant, thisConstant);
break;
}
if (newLiteral != null)
{
RotateFromLeft(node, leftOperator, newLiteral);
}
}
}