public void Visit(JsUnaryOperator node) { // if this is a postfix operator and there is an operand, recurse into it if (node != null && node.IsPostfix && node.Operand != null) { node.Operand.Accept(this); } }
public void Visit(JsUnaryOperator node) { if (node != null) { if (node.Operand != null) { node.Operand.Accept(this); } node.Index = NextOrderIndex; } }
public override void Visit(JsUnaryOperator node) { if (node != null && !node.OperatorInConditionalCompilationComment) { // if this is a unary logical-not operator, then we will just remove the // logical-not operation if (node.OperatorToken == JsToken.LogicalNot) { if (m_measure) { // measure // removes the not operator character, but also might remove parens that we would // no longer need. --m_delta; if (node.Operand is JsBinaryOperator || node.Operand is JsConditional || node.Operand is JsGroupingOperator) { // those operators are lesser-precedence than the logical-not coperator and would've // added parens that we now don't need m_delta -= 2; } } else { // convert // just replace the not with its own operand, unless the child // itself is a grouping operator, in which case we will replace it // with the grouping operand to get rid of the parens var grouping = node.Operand as JsGroupingOperator; if (grouping != null) { node.Parent.ReplaceChild(node, grouping.Operand); } else { node.Parent.ReplaceChild(node, node.Operand); } } } else { // same logic as most nodes for the other operators TypicalHandler(node); } } }
public void Visit(JsUnaryOperator node) { if (node != null) { // only a negation is allowed -- and even then, I'm not sure // if it has already been integrated into the numeric value yet. if (node.OperatorToken == JsToken.Minus) { m_writer.Write('-'); if (node.Operand != null) { node.Operand.Accept(this); } } else { // invalid! ignore IsValid = false; } } }
public void Visit(JsUnaryOperator node) { if (node != null) { if (node.Operand != null) { node.Operand.Accept(this); } node.Index = NextOrderIndex; } }
public void Visit(JsUnaryOperator node) { // lesser precedence than the new operator; use parens m_needsParens = true; }
public void Visit(JsUnaryOperator node) { // lesser precedence than the new operator; use parens m_needsParens = true; }
//--------------------------------------------------------------------------------------- // ParseUnaryExpression // // UnaryExpression : // PostfixExpression | // 'delete' UnaryExpression | // 'void' UnaryExpression | // 'typeof' UnaryExpression | // '++' UnaryExpression | // '--' UnaryExpression | // '+' UnaryExpression | // '-' UnaryExpression | // '~' UnaryExpression | // '!' UnaryExpression // //--------------------------------------------------------------------------------------- private JsAstNode ParseUnaryExpression(out bool isLeftHandSideExpr, bool isMinus) { isLeftHandSideExpr = false; bool dummy = false; JsContext exprCtx = null; JsAstNode expr = null; TryItAgain: JsAstNode ast = null; switch (m_currentToken.Token) { case JsToken.Void: exprCtx = m_currentToken.Clone(); GetNextToken(); expr = ParseUnaryExpression(out dummy, false); ast = new JsUnaryOperator(exprCtx.Clone().UpdateWith(expr.Context), this) { Operand = expr, OperatorContext = exprCtx, OperatorToken = JsToken.Void }; break; case JsToken.TypeOf: exprCtx = m_currentToken.Clone(); GetNextToken(); expr = ParseUnaryExpression(out dummy, false); ast = new JsUnaryOperator(exprCtx.Clone().UpdateWith(expr.Context), this) { Operand = expr, OperatorContext = exprCtx, OperatorToken = JsToken.TypeOf }; break; case JsToken.Plus: exprCtx = m_currentToken.Clone(); GetNextToken(); expr = ParseUnaryExpression(out dummy, false); ast = new JsUnaryOperator(exprCtx.Clone().UpdateWith(expr.Context), this) { Operand = expr, OperatorContext = exprCtx, OperatorToken = JsToken.Plus }; break; case JsToken.Minus: exprCtx = m_currentToken.Clone(); GetNextToken(); expr = ParseUnaryExpression(out dummy, true); ast = new JsUnaryOperator(exprCtx.Clone().UpdateWith(expr.Context), this) { Operand = expr, OperatorContext = exprCtx, OperatorToken = JsToken.Minus }; break; case JsToken.BitwiseNot: exprCtx = m_currentToken.Clone(); GetNextToken(); expr = ParseUnaryExpression(out dummy, false); ast = new JsUnaryOperator(exprCtx.Clone().UpdateWith(expr.Context), this) { Operand = expr, OperatorContext = exprCtx, OperatorToken = JsToken.BitwiseNot }; break; case JsToken.LogicalNot: exprCtx = m_currentToken.Clone(); GetNextToken(); expr = ParseUnaryExpression(out dummy, false); ast = new JsUnaryOperator(exprCtx.Clone().UpdateWith(expr.Context), this) { Operand = expr, OperatorContext = exprCtx, OperatorToken = JsToken.LogicalNot }; break; case JsToken.Delete: exprCtx = m_currentToken.Clone(); GetNextToken(); expr = ParseUnaryExpression(out dummy, false); ast = new JsUnaryOperator(exprCtx.Clone().UpdateWith(expr.Context), this) { Operand = expr, OperatorContext = exprCtx, OperatorToken = JsToken.Delete }; break; case JsToken.Increment: exprCtx = m_currentToken.Clone(); GetNextToken(); expr = ParseUnaryExpression(out dummy, false); ast = new JsUnaryOperator(exprCtx.Clone().UpdateWith(expr.Context), this) { Operand = expr, OperatorContext = exprCtx, OperatorToken = JsToken.Increment }; break; case JsToken.Decrement: exprCtx = m_currentToken.Clone(); GetNextToken(); expr = ParseUnaryExpression(out dummy, false); ast = new JsUnaryOperator(exprCtx.Clone().UpdateWith(expr.Context), this) { Operand = expr, OperatorContext = exprCtx, OperatorToken = JsToken.Decrement }; break; case JsToken.ConditionalCommentStart: // skip past the start to the next token exprCtx = m_currentToken.Clone(); GetNextToken(); if (m_currentToken.Token == JsToken.ConditionalCommentEnd) { // empty conditional-compilation comment -- ignore GetNextToken(); goto TryItAgain; } else if (m_currentToken.Token == JsToken.ConditionalCompilationOn) { // /*@cc_on -- check for @IDENT@*/ or !@*/ GetNextToken(); if (m_currentToken.Token == JsToken.ConditionalCompilationVariable) { // /*@cc_on@IDENT -- check for @*/ ast = new JsConstantWrapperPP(m_currentToken.Clone(), this) { VarName = m_currentToken.Code, ForceComments = true }; GetNextToken(); if (m_currentToken.Token == JsToken.ConditionalCommentEnd) { // skip the close and keep going GetNextToken(); } else { // too complicated CCTooComplicated(null); goto TryItAgain; } } else if (m_currentToken.Token == JsToken.LogicalNot) { // /*@cc_on! -- check for @*/ var operatorContext = m_currentToken.Clone(); GetNextToken(); if (m_currentToken.Token == JsToken.ConditionalCommentEnd) { // we have /*@cc_on!@*/ GetNextToken(); expr = ParseUnaryExpression(out dummy, false); exprCtx.UpdateWith(expr.Context); var unary = new JsUnaryOperator(exprCtx, this) { Operand = expr, OperatorContext = operatorContext, OperatorToken = JsToken.LogicalNot }; unary.OperatorInConditionalCompilationComment = true; unary.ConditionalCommentContainsOn = true; ast = unary; } else { // too complicated CCTooComplicated(null); goto TryItAgain; } } else { // too complicated CCTooComplicated(null); goto TryItAgain; } } else if (m_currentToken.Token == JsToken.LogicalNot) { // /*@! -- check for @*/ var operatorContext = m_currentToken.Clone(); GetNextToken(); if (m_currentToken.Token == JsToken.ConditionalCommentEnd) { // we have /*@!@*/ GetNextToken(); expr = ParseUnaryExpression(out dummy, false); exprCtx.UpdateWith(expr.Context); var unary = new JsUnaryOperator(exprCtx, this) { Operand = expr, OperatorContext = operatorContext, OperatorToken = JsToken.LogicalNot }; unary.OperatorInConditionalCompilationComment = true; ast = unary; } else { // too complicated CCTooComplicated(null); goto TryItAgain; } } else if (m_currentToken.Token == JsToken.ConditionalCompilationVariable) { // @IDENT -- check for @*/ ast = new JsConstantWrapperPP(m_currentToken.Clone(), this) { VarName = m_currentToken.Code, ForceComments = true }; GetNextToken(); if (m_currentToken.Token == JsToken.ConditionalCommentEnd) { // skip the close and keep going GetNextToken(); } else { // too complicated CCTooComplicated(null); goto TryItAgain; } } else { // we ONLY support /*@id@*/ or /*@cc_on@id@*/ or /*@!@*/ or /*@cc_on!@*/ in expressions right now. // throw an error, skip to the end of the comment, then ignore it and start // looking for the next token. CCTooComplicated(null); goto TryItAgain; } break; default: m_noSkipTokenSet.Add(NoSkipTokenSet.s_PostfixExpressionNoSkipTokenSet); try { ast = ParseLeftHandSideExpression(isMinus); } catch (RecoveryTokenException exc) { if (IndexOfToken(NoSkipTokenSet.s_PostfixExpressionNoSkipTokenSet, exc) == -1) { throw; } else { if (exc._partiallyComputedNode == null) SkipTokensAndThrow(); else ast = exc._partiallyComputedNode; } } finally { m_noSkipTokenSet.Remove(NoSkipTokenSet.s_PostfixExpressionNoSkipTokenSet); } ast = ParsePostfixExpression(ast, out isLeftHandSideExpr); break; } return ast; }
public override void Visit(JsBinaryOperator node) { if (node != null) { base.Visit(node); // see if this operation is subtracting zero from a lookup -- that is typically done to // coerce a value to numeric. There's a simpler way: unary plus operator. if (node.OperatorToken == JsToken.Minus && m_parser.Settings.IsModificationAllowed(JsTreeModifications.SimplifyStringToNumericConversion)) { JsLookup lookup = node.Operand1 as JsLookup; if (lookup != null) { JsConstantWrapper right = node.Operand2 as JsConstantWrapper; if (right != null && right.IsIntegerLiteral && right.ToNumber() == 0) { // okay, so we have "lookup - 0" // this is done frequently to force a value to be numeric. // There is an easier way: apply the unary + operator to it. // transform: lookup - 0 => +lookup var unary = new JsUnaryOperator(node.Context, m_parser) { Operand = lookup, OperatorToken = JsToken.Plus }; node.Parent.ReplaceChild(node, unary); // because we recursed at the top of this function, we don't need to Analyze // the new Unary node. This visitor's method for UnaryOperator only does something // if the operand is a constant -- and this one is a Lookup. And we already analyzed // the lookup. } } } else if ((node.OperatorToken == JsToken.StrictEqual || node.OperatorToken == JsToken.StrictNotEqual) && m_parser.Settings.IsModificationAllowed(JsTreeModifications.ReduceStrictOperatorIfTypesAreSame)) { JsPrimitiveType leftType = node.Operand1.FindPrimitiveType(); if (leftType != JsPrimitiveType.Other) { JsPrimitiveType rightType = node.Operand2.FindPrimitiveType(); if (leftType == rightType) { // the are the same known types. We can reduce the operators node.OperatorToken = node.OperatorToken == JsToken.StrictEqual ? JsToken.Equal : JsToken.NotEqual; } else if (rightType != JsPrimitiveType.Other) { // they are not the same, but they are both known. We can completely remove the operator // and replace it with true (!==) or false (===). // transform: x !== y => true // transform: x === y => false node.Context.HandleError(JsError.StrictComparisonIsAlwaysTrueOrFalse, false); node.Parent.ReplaceChild( node, new JsConstantWrapper(node.OperatorToken == JsToken.StrictNotEqual, JsPrimitiveType.Boolean, node.Context, m_parser)); // because we are essentially removing the node from the AST, be sure to detach any references JsDetachReferences.Apply(node); } } } else if (node.IsAssign) { var lookup = node.Operand1 as JsLookup; if (lookup != null) { if (lookup.VariableField != null && lookup.VariableField.InitializationOnly) { // the field is an initialization-only field -- we should NOT be assigning to it lookup.Context.HandleError(JsError.AssignmentToConstant, true); } else if (m_scopeStack.Peek().UseStrict) { if (lookup.VariableField == null || lookup.VariableField.FieldType == JsFieldType.UndefinedGlobal) { // strict mode cannot assign to undefined fields node.Operand1.Context.HandleError(JsError.StrictModeUndefinedVariable, true); } else if(lookup.VariableField.FieldType == JsFieldType.Arguments || (lookup.VariableField.FieldType == JsFieldType.Predefined && string.CompareOrdinal(lookup.Name, "eval") == 0)) { // strict mode cannot assign to lookup "eval" or "arguments" node.Operand1.Context.HandleError(JsError.StrictModeInvalidAssign, true); } } } } else if ((node.Parent is JsBlock || (node.Parent is JsCommaOperator && node.Parent.Parent is JsBlock)) && (node.OperatorToken == JsToken.LogicalOr || node.OperatorToken == JsToken.LogicalAnd)) { // this is an expression statement where the operator is || or && -- basically // it's a shortcut for an if-statement: // expr1&&expr2; ==> if(expr1)expr2; // expr1||expr2; ==> if(!expr1)expr2; // let's check to see if the not of expr1 is smaller. If so, we can not the expression // and change the operator var logicalNot = new JsLogicalNot(node.Operand1, node.Parser); if (logicalNot.Measure() < 0) { // it would be smaller! Change it. // transform: expr1&&expr2 => !expr1||expr2 // transform: expr1||expr2 => !expr1&&expr2 logicalNot.Apply(); node.OperatorToken = node.OperatorToken == JsToken.LogicalAnd ? JsToken.LogicalOr : JsToken.LogicalAnd; } } } }
public void Visit(JsUnaryOperator node) { if (node != null) { var symbol = StartSymbol(node); var isNoIn = m_noIn; m_noIn = false; if (node.IsPostfix) { if (node.Operand != null) { AcceptNodeWithParens(node.Operand, node.Operand.Precedence < node.Precedence); SetContextOutputPosition(node.Context, node.Operand.Context); } // the only postfix unary operators are ++ and --, and when in the postfix position, // line breaks are NOT allowed between the operand and the operator. // doesn't seem to need this flag set here, but set it anyways just in case. m_noLineBreaks = true; Output(OperatorString(node.OperatorToken)); MarkSegment(node, null, node.OperatorContext); m_startOfStatement = false; } else { if (node.OperatorInConditionalCompilationComment) { // if we haven't output a cc_on yet, we ALWAYS want to do it now, whether or not the // sources had one. Otherwise, we only only want to output one if we had one and we aren't // removing unneccesary ones. if (!m_outputCCOn || (node.ConditionalCommentContainsOn && !m_settings.IsModificationAllowed(JsTreeModifications.RemoveUnnecessaryCCOnStatements))) { // output it now and set the flag that we have output them Output("/*@cc_on"); m_outputCCOn = true; } else { Output("/*@"); } Output(OperatorString(node.OperatorToken)); MarkSegment(node, null, node.OperatorContext); SetContextOutputPosition(node.Context); Output("@*/"); } else { Output(OperatorString(node.OperatorToken)); MarkSegment(node, null, node.OperatorContext ?? node.Context); SetContextOutputPosition(node.Context); } m_startOfStatement = false; if (node.Operand != null) { AcceptNodeWithParens(node.Operand, node.Operand.Precedence < node.Precedence); } } m_noIn = isNoIn; EndSymbol(symbol); } }
public override void Visit(JsUnaryOperator node) { if (node != null && !node.OperatorInConditionalCompilationComment) { // if this is a unary logical-not operator, then we will just remove the // logical-not operation if (node.OperatorToken == JsToken.LogicalNot) { if (m_measure) { // measure // removes the not operator character, but also might remove parens that we would // no longer need. --m_delta; if (node.Operand is JsBinaryOperator || node.Operand is JsConditional || node.Operand is JsGroupingOperator) { // those operators are lesser-precedence than the logical-not coperator and would've // added parens that we now don't need m_delta -= 2; } } else { // convert // just replace the not with its own operand, unless the child // itself is a grouping operator, in which case we will replace it // with the grouping operand to get rid of the parens var grouping = node.Operand as JsGroupingOperator; if (grouping != null) { node.Parent.ReplaceChild(node, grouping.Operand); } else { node.Parent.ReplaceChild(node, node.Operand); } } } else { // same logic as most nodes for the other operators TypicalHandler(node); } } }
private void DoUnaryNode(JsUnaryOperator node) { if (!node.OperatorInConditionalCompilationComment && m_parser.Settings.IsModificationAllowed(JsTreeModifications.EvaluateNumericExpressions)) { var literalOperand = node.Operand as JsConstantWrapper; switch(node.OperatorToken) { case JsToken.Void: // see if our operand is a ConstantWrapper if (literalOperand != null) { // either number, string, boolean, or null. // the void operator evaluates its operand and returns undefined. Since evaluating a literal // does nothing, then it doesn't matter what the heck it is. Replace it with a zero -- a one- // character literal. node.Operand = new JsConstantWrapper(0, JsPrimitiveType.Number, node.Context, m_parser); } break; case JsToken.TypeOf: if (literalOperand != null) { // either number, string, boolean, or null. // the operand is a literal. Therefore we already know what the typeof // operator will return. Just short-circuit that behavior now and replace the operator // with a string literal of the proper value string typeName = null; if (literalOperand.IsStringLiteral) { // "string" typeName = "string"; } else if (literalOperand.IsNumericLiteral) { // "number" typeName = "number"; } else if (literalOperand.IsBooleanLiteral) { // "boolean" typeName = "boolean"; } else if (literalOperand.Value == null) { // "object" typeName = "object"; } if (!string.IsNullOrEmpty(typeName)) { ReplaceNodeWithLiteral(node, new JsConstantWrapper(typeName, JsPrimitiveType.String, node.Context, m_parser)); } } else if (node.Operand is JsObjectLiteral) { ReplaceNodeWithLiteral(node, new JsConstantWrapper("object", JsPrimitiveType.String, node.Context, m_parser)); } break; case JsToken.Plus: if (literalOperand != null) { try { // replace with a constant representing operand.ToNumber, ReplaceNodeWithLiteral(node, new JsConstantWrapper(literalOperand.ToNumber(), JsPrimitiveType.Number, node.Context, 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; case JsToken.Minus: if (literalOperand != null) { try { // replace with a constant representing the negative of operand.ToNumber ReplaceNodeWithLiteral(node, new JsConstantWrapper(-literalOperand.ToNumber(), JsPrimitiveType.Number, node.Context, 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; case JsToken.BitwiseNot: if (literalOperand != null) { try { // replace with a constant representing the bitwise-not of operant.ToInt32 ReplaceNodeWithLiteral(node, new JsConstantWrapper(Convert.ToDouble(~literalOperand.ToInt32()), JsPrimitiveType.Number, node.Context, 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; case JsToken.LogicalNot: if (literalOperand != null) { // replace with a constant representing the opposite of operand.ToBoolean try { ReplaceNodeWithLiteral(node, new JsConstantWrapper(!literalOperand.ToBoolean(), JsPrimitiveType.Boolean, node.Context, m_parser)); } catch (InvalidCastException) { // ignore any invalid cast exceptions } } break; } } }
private void DoBinaryOperator(JsBinaryOperator node) { if (m_parser.Settings.EvalLiteralExpressions) { // if this is an assign operator, an in, or an instanceof, then we won't // try to evaluate it if (!node.IsAssign && node.OperatorToken != JsToken.In && node.OperatorToken != JsToken.InstanceOf) { if (node.OperatorToken == JsToken.StrictEqual || node.OperatorToken == JsToken.StrictNotEqual) { // the operator is a strict equality (or not-equal). // check the primitive types of the two operands -- if they are known but not the same, we can // shortcut the whole process by just replacing this node with a boolean literal. var leftType = node.Operand1.FindPrimitiveType(); if (leftType != JsPrimitiveType.Other) { var rightType = node.Operand2.FindPrimitiveType(); if (rightType != JsPrimitiveType.Other) { // both sides are known if (leftType != rightType) { // they are not the same type -- replace with a boolean and bail ReplaceNodeWithLiteral( node, new JsConstantWrapper(node.OperatorToken == JsToken.StrictEqual ? false : true, JsPrimitiveType.Boolean, node.Context, m_parser)); return; } // they are the same type -- we can change the operator to simple equality/not equality node.OperatorToken = node.OperatorToken == JsToken.StrictEqual ? JsToken.Equal : JsToken.NotEqual; } } } // see if the left operand is a literal number, boolean, string, or null JsConstantWrapper left = node.Operand1 as JsConstantWrapper; if (left != null) { if (node.OperatorToken == JsToken.Comma) { // the comma operator evaluates the left, then evaluates the right and returns it. // but if the left is a literal, evaluating it doesn't DO anything, so we can replace the // entire operation with the right-hand operand JsConstantWrapper rightConstant = node.Operand2 as JsConstantWrapper; if (rightConstant != null) { // we'll replace the operator with the right-hand operand, BUT it's a constant, too. // first check to see if replacing this node with a constant will result in creating // a member-bracket operator that can be turned into a member-dot. If it is, then that // method will handle the replacement. But if it doesn't, then we should just replace // the comma with the right-hand operand. if (!ReplaceMemberBracketWithDot(node, rightConstant)) { ReplaceNodeWithLiteral(node, rightConstant); } } else if (node is JsCommaOperator) { // this is a collection of expression statements that we've joined together as // an extended comma operator. var list = node.Operand2 as JsAstNodeList; if (list == null) { // not a list, just a single item, so we can just // replace this entire node with the one element ReplaceNodeCheckParens(node, node.Operand2); } else if (list.Count == 1) { // If the list has a single element, then we can just // replace this entire node with the one element ReplaceNodeCheckParens(node, list[0]); } else if (list.Count == 0) { // the recursion ended up emptying the list, so we can just delete // this node altogether ReplaceNodeCheckParens(node, null); } else { // more than one item in the list // move the first item from the list to the left-hand side var firstItem = list[0]; list.RemoveAt(0); node.Operand1 = firstItem; // if there's only one item left in the list, we can get rid of the // extra list node and make it just the remaining node if (list.Count == 1) { firstItem = list[0]; list.RemoveAt(0); node.Operand2 = firstItem; } } } else { // replace the comma operator with the right-hand operand ReplaceNodeCheckParens(node, node.Operand2); } } else { // see if the right operand is a literal number, boolean, string, or null JsConstantWrapper right = node.Operand2 as JsConstantWrapper; if (right != null) { // then they are both constants and we can evaluate the operation EvalThisOperator(node, left, right); } else { // see if the right is a binary operator that can be combined with ours JsBinaryOperator rightBinary = node.Operand2 as JsBinaryOperator; if (rightBinary != null) { JsConstantWrapper rightLeft = rightBinary.Operand1 as JsConstantWrapper; if (rightLeft != null) { // eval our left and the right-hand binary's left and put the combined operation as // the child of the right-hand binary EvalToTheRight(node, left, rightLeft, rightBinary); } else { JsConstantWrapper rightRight = rightBinary.Operand2 as JsConstantWrapper; if (rightRight != null) { EvalFarToTheRight(node, left, rightRight, rightBinary); } } } } } } else { // left is not a constantwrapper. See if the right is JsConstantWrapper right = node.Operand2 as JsConstantWrapper; if (right != null) { // the right is a constant. See if the the left is a binary operator... JsBinaryOperator leftBinary = node.Operand1 as JsBinaryOperator; if (leftBinary != null) { // ...with a constant on the right, and the operators can be combined JsConstantWrapper leftRight = leftBinary.Operand2 as JsConstantWrapper; if (leftRight != null) { EvalToTheLeft(node, right, leftRight, leftBinary); } else { JsConstantWrapper leftLeft = leftBinary.Operand1 as JsConstantWrapper; if (leftLeft != null) { EvalFarToTheLeft(node, right, leftLeft, leftBinary); } } } else if (m_parser.Settings.IsModificationAllowed(JsTreeModifications.SimplifyStringToNumericConversion)) { // see if it's a lookup and this is a minus operation and the constant is a zero JsLookup lookup = node.Operand1 as JsLookup; if (lookup != null && node.OperatorToken == JsToken.Minus && right.IsIntegerLiteral && right.ToNumber() == 0) { // okay, so we have "lookup - 0" // this is done frequently to force a value to be numeric. // There is an easier way: apply the unary + operator to it. var unary = new JsUnaryOperator(node.Context, m_parser) { Operand = lookup, OperatorToken = JsToken.Plus }; ReplaceNodeCheckParens(node, unary); } } } // TODO: shouldn't we check if they BOTH are binary operators? (a*6)*(5*b) ==> a*30*b (for instance) } } } }
public override void Visit(JsUnaryOperator node) { if (node != null) { // depth-first base.Visit(node); DoUnaryNode(node); } }
public void Visit(JsUnaryOperator node) { // not applicable; terminate }
public void Visit(JsUnaryOperator node) { // not applicable; terminate }
//--------------------------------------------------------------------------------------- // ParsePostfixExpression // // PostfixExpression: // LeftHandSideExpression | // LeftHandSideExpression '++' | // LeftHandSideExpression '--' // //--------------------------------------------------------------------------------------- private JsAstNode ParsePostfixExpression(JsAstNode ast, out bool isLeftHandSideExpr) { isLeftHandSideExpr = true; JsContext exprCtx = null; if (null != ast) { if (!m_foundEndOfLine) { if (JsToken.Increment == m_currentToken.Token) { isLeftHandSideExpr = false; exprCtx = ast.Context.Clone(); exprCtx.UpdateWith(m_currentToken); ast = new JsUnaryOperator(exprCtx, this) { Operand = ast, OperatorToken = m_currentToken.Token, OperatorContext = m_currentToken.Clone(), IsPostfix = true }; GetNextToken(); } else if (JsToken.Decrement == m_currentToken.Token) { isLeftHandSideExpr = false; exprCtx = ast.Context.Clone(); exprCtx.UpdateWith(m_currentToken); ast = new JsUnaryOperator(exprCtx, this) { Operand = ast, OperatorToken = m_currentToken.Token, OperatorContext = m_currentToken.Clone(), IsPostfix = true }; GetNextToken(); } } } return ast; }
public void Visit(JsUnaryOperator node) { if (node != null) { // only a negation is allowed -- and even then, I'm not sure // if it has already been integrated into the numeric value yet. if (node.OperatorToken == JsToken.Minus) { m_writer.Write('-'); if (node.Operand != null) { node.Operand.Accept(this); } } else { // invalid! ignore IsValid = false; } } }
public override void Visit(JsUnaryOperator node) { if (node != null) { base.Visit(node); // strict mode has some restrictions if (node.OperatorToken == JsToken.Delete) { if (m_scopeStack.Peek().UseStrict) { // operand of a delete operator cannot be a variable name, argument name, or function name // which means it can't be a lookup if (node.Operand is JsLookup) { node.Context.HandleError(JsError.StrictModeInvalidDelete, true); } } } else if (node.OperatorToken == JsToken.Increment || node.OperatorToken == JsToken.Decrement) { var lookup = node.Operand as JsLookup; if (lookup != null) { if (lookup.VariableField != null && lookup.VariableField.InitializationOnly) { // can't increment or decrement a constant! lookup.Context.HandleError(JsError.AssignmentToConstant, true); } // and strict mode has some restrictions we want to check now if (m_scopeStack.Peek().UseStrict) { // the operator cannot be the eval function or arguments object. // that means the operator is a lookup, and the field for that lookup // is the arguments object or the predefined "eval" object. if (lookup.VariableField == null || lookup.VariableField.FieldType == JsFieldType.UndefinedGlobal || lookup.VariableField.FieldType == JsFieldType.Arguments || (lookup.VariableField.FieldType == JsFieldType.Predefined && string.CompareOrdinal(lookup.Name, "eval") == 0)) { node.Operand.Context.HandleError(JsError.StrictModeInvalidPreOrPost, true); } } } } else { // if the operand is a numeric literal JsConstantWrapper constantWrapper = node.Operand as JsConstantWrapper; if (constantWrapper != null && constantWrapper.IsNumericLiteral) { // get the value of the constant. We've already screened it for numeric, so // we don't have to worry about catching any errors double doubleValue = constantWrapper.ToNumber(); // if this is a unary minus... if (node.OperatorToken == JsToken.Minus && m_parser.Settings.IsModificationAllowed(JsTreeModifications.ApplyUnaryMinusToNumericLiteral)) { // negate the value constantWrapper.Value = -doubleValue; // replace us with the negated constant if (node.Parent.ReplaceChild(node, constantWrapper)) { // the context for the minus will include the number (its operand), // but the constant will just be the number. Update the context on // the constant to be a copy of the context on the operator constantWrapper.Context = node.Context.Clone(); } } else if (node.OperatorToken == JsToken.Plus && m_parser.Settings.IsModificationAllowed(JsTreeModifications.RemoveUnaryPlusOnNumericLiteral)) { // +NEG is still negative, +POS is still positive, and +0 is still 0. // so just get rid of the unary operator altogether if (node.Parent.ReplaceChild(node, constantWrapper)) { // the context for the unary will include the number (its operand), // but the constant will just be the number. Update the context on // the constant to be a copy of the context on the operator constantWrapper.Context = node.Context.Clone(); } } } } } }