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