public override void Visit(JsConstantWrapper node)
{
if (node != null)
{
// measure
if (node.PrimitiveType == JsPrimitiveType.Boolean)
{
if (m_measure)
{
// if we are converting true/false literals to !0/!1, then
// a logical-not doesn't add or subtract anything. But if we aren't,
// we need to add/subtract the difference in the length between the
// "true" and "false" strings
if (!m_parser.Settings.MinifyCode ||
!m_parser.Settings.IsModificationAllowed(JsTreeModifications.BooleanLiteralsToNotOperators))
{
// converting true to false adds a character, false to true subtracts
m_delta += node.ToBoolean() ? 1 : -1;
}
}
else
{
// convert - just flip the boolean value
node.Value = !node.ToBoolean();
}
}
else
{
// just the same typical operation as most other nodes for other types
TypicalHandler(node);
}
}
}
public override void Visit(JsConstantWrapper node)
{
if (node != null)
{
// no children, so don't bother calling the base.
if (node.PrimitiveType == JsPrimitiveType.Boolean &&
m_parser.Settings.IsModificationAllowed(JsTreeModifications.BooleanLiteralsToNotOperators))
{
node.Parent.ReplaceChild(node, new JsUnaryOperator(node.Context, m_parser)
{
Operand = new JsConstantWrapper(node.ToBoolean() ? 0 : 1, JsPrimitiveType.Number, node.Context, m_parser),
OperatorToken = JsToken.LogicalNot
});
}
}
}
public void Visit(JsConstantWrapper node)
{
if (node != null)
{
var symbol = StartSymbol(node);
var isNoIn = m_noIn;
m_noIn = false;
switch (node.PrimitiveType)
{
case JsPrimitiveType.Boolean:
Output(node.ToBoolean() ? "true" : "false");
break;
case JsPrimitiveType.Null:
Output("null");
break;
case JsPrimitiveType.Number:
if (node.Context == null || !node.Context.HasCode
|| (!node.MayHaveIssues && m_settings.IsModificationAllowed(JsTreeModifications.MinifyNumericLiterals)))
{
// apply minification to the literal to get it as small as possible
Output(NormalizeNumber(node.ToNumber(), node.Context));
}
else
{
// context is not null but we don't want to minify numeric literals.
// just use the original literal from the context.
Output(node.Context.Code);
}
break;
case JsPrimitiveType.Other:
Output(node.Value.ToString());
break;
case JsPrimitiveType.String:
if (node.Context == null || !node.Context.HasCode)
{
// escape the string value because we don't have a raw context value
// to show anyways
Output(InlineSafeString(EscapeString(node.Value.ToString())));
}
else if (!m_settings.IsModificationAllowed(JsTreeModifications.MinifyStringLiterals))
{
// we don't want to modify the strings at all!
Output(node.Context.Code);
}
else if (node.MayHaveIssues
|| (m_settings.AllowEmbeddedAspNetBlocks && node.StringContainsAspNetReplacement))
{
// we'd rather show the raw string, but make sure it's safe for inlining
Output(InlineSafeString(node.Context.Code));
}
else
{
// we'd rather show the escaped string
Output(InlineSafeString(EscapeString(node.Value.ToString())));
}
break;
}
MarkSegment(node, null, node.Context);
SetContextOutputPosition(node.Context);
m_startOfStatement = false;
m_noIn = isNoIn;
EndSymbol(symbol);
}
}
public override void Visit(JsConstantWrapper node)
{
if (node != null)
{
// measure
if (node.PrimitiveType == JsPrimitiveType.Boolean)
{
if (m_measure)
{
// if we are converting true/false literals to !0/!1, then
// a logical-not doesn't add or subtract anything. But if we aren't,
// we need to add/subtract the difference in the length between the
// "true" and "false" strings
if (!m_parser.Settings.MinifyCode
|| !m_parser.Settings.IsModificationAllowed(JsTreeModifications.BooleanLiteralsToNotOperators))
{
// converting true to false adds a character, false to true subtracts
m_delta += node.ToBoolean() ? 1 : -1;
}
}
else
{
// convert - just flip the boolean value
node.Value = !node.ToBoolean();
}
}
else
{
// just the same typical operation as most other nodes for other types
TypicalHandler(node);
}
}
}
private JsConstantWrapper StrictNotEqual(JsConstantWrapper left, JsConstantWrapper right)
{
JsConstantWrapper newLiteral = null;
if (m_parser.Settings.IsModificationAllowed(JsTreeModifications.EvaluateNumericExpressions))
{
JsPrimitiveType leftType = left.PrimitiveType;
if (leftType == right.PrimitiveType)
{
// the values are the same type
switch (leftType)
{
case JsPrimitiveType.Null:
// null !== null is false
newLiteral = new JsConstantWrapper(false, JsPrimitiveType.Boolean, null, m_parser);
break;
case JsPrimitiveType.Boolean:
// compare boolean values
newLiteral = new JsConstantWrapper(left.ToBoolean() != right.ToBoolean(), JsPrimitiveType.Boolean, null, m_parser);
break;
case JsPrimitiveType.String:
// compare string ordinally
if (left.IsOkayToCombine && right.IsOkayToCombine)
{
newLiteral = new JsConstantWrapper(string.CompareOrdinal(left.ToString(), right.ToString()) != 0, JsPrimitiveType.Boolean, null, m_parser);
}
break;
case JsPrimitiveType.Number:
try
{
// compare the values
// +0 and -0 are treated as "equal" in C#, so we don't need to test them separately.
// and NaN is always unequal to everything else, including itself.
if (left.IsOkayToCombine && right.IsOkayToCombine)
{
newLiteral = new JsConstantWrapper(left.ToNumber() != right.ToNumber(), JsPrimitiveType.Boolean, null, m_parser);
}
}
catch (InvalidCastException)
{
// some kind of casting in ToNumber caused a situation where we don't want
// to perform the combination on these operands
}
break;
}
}
else
{
// if they aren't the same type, they are not equal
newLiteral = new JsConstantWrapper(true, JsPrimitiveType.Boolean, null, m_parser);
}
}
return newLiteral;
}
private JsConstantWrapper LogicalOr(JsConstantWrapper left, JsConstantWrapper right)
{
JsConstantWrapper newLiteral = null;
if (m_parser.Settings.IsModificationAllowed(JsTreeModifications.EvaluateNumericExpressions))
{
try
{
// if the left-hand side evaluates to true, return the left-hand side.
// if the left-hand side is false, return the right-hand side.
newLiteral = left.ToBoolean() ? left : right;
}
catch (InvalidCastException)
{
// if we couldn't cast to bool, ignore
}
}
return newLiteral;
}
public override void Visit(JsConstantWrapper node)
{
if (node != null)
{
// no children, so don't bother calling the base.
if (node.PrimitiveType == JsPrimitiveType.Boolean
&& m_parser.Settings.IsModificationAllowed(JsTreeModifications.BooleanLiteralsToNotOperators))
{
node.Parent.ReplaceChild(node, new JsUnaryOperator(node.Context, m_parser)
{
Operand = new JsConstantWrapper(node.ToBoolean() ? 0 : 1, JsPrimitiveType.Number, node.Context, m_parser),
OperatorToken = JsToken.LogicalNot
});
}
}
}