public virtual void Visit(GroupingOperator node)
{
if (node != null && node.Operand != null)
{
// just totally ignore any parentheses
node.Operand.Accept(this);
}
}
public void Visit(GroupingOperator node)
{
// not TECHNICALLY valid! set the invalid flag, but
// still recurse the operand, just in case
IsValid = false;
if (node != null && node.Operand != null)
{
node.Operand.Accept(this);
}
}
public void Visit(GroupingOperator node)
{
if (node != null)
{
if (node.Operand != null)
{
node.Operand.Accept(this);
}
node.Index = NextOrderIndex;
}
}
public override void Visit(GroupingOperator node)
{
if (node != null)
{
if (m_measure)
{
// either we add one by putting a ! in front of the parens, or
// the expression itself can come out equal to less.
// save the current delta, check the operand, and if applying the
// logical not to the operand is MORE than just throwing a ! on the
// front, then we'll just return the +1 for the simple not.
var plusOne = m_delta + 1;
node.Operand.Accept(this);
if (m_delta > plusOne)
{
m_delta = plusOne;
}
}
else
{
// we need to know how we're going to do this, so we need
// to run another measurement.
m_measure = true;
m_delta = 0;
node.Operand.Accept(this);
m_measure = false;
// if the delta is greater than 1, then we are just going
// to wrap ourselves in a unary not. Otherwise we're going
// to replace ourselves with our operand and not it in-place.
if (m_delta > 1)
{
WrapWithLogicalNot(node);
}
else
{
node.Parent.ReplaceChild(node, node.Operand);
node.Operand.Accept(this);
}
}
}
}
public void Visit(GroupingOperator node)
{
// not TECHNICALLY valid! set the invalid flag, but
// still recurse the operand, just in case
IsValid = false;
if (node != null && node.Operand != null)
{
node.Operand.Accept(this);
}
}
public virtual void Visit(GroupingOperator node)
{
// definitely does NOT need parens, because we will
// output parens ourselves. And don't bother recursing.
}
public override void Visit(GroupingOperator node)
{
if (node != null)
{
// if the parent isn't null, we need to run some checks
// to see if we can be removed for being superfluous.
if (node.Parent != null)
{
var deleteParens = false;
if (node.Operand == null)
{
// delete self - no operand make the parens superfluous
// TODO: or should we leave them to preserve the "error"?
deleteParens = true;
}
else if (node.Parent is Block)
{
// function expressions and object literals need to keep the parens
// or they'll be mistaken for function delcarations and blocks, respectively.
// all others get axed.
if (!(node.Operand is FunctionObject) && !(node.Operand is ObjectLiteral))
{
// delete self
deleteParens = true;
}
}
else if (node.Parent is AstNodeList)
{
// keep the parens if the node is itself a comma-operator
// question: do we need to check for ANY comma-operators in the entire expression,
// or will precedence rules dictate that there will be parens lower down if this
// expression isn't a comma-operator?
var binOp = node.Operand as BinaryOperator;
if (binOp == null || binOp.OperatorToken != JSToken.Comma)
{
// delete self
deleteParens = true;
}
}
else if (node.Parent.IsExpression)
{
var targetPrecedence = node.Parent.Precedence;
var conditional = node.Parent as Conditional;
if (conditional != null)
{
// the conditional is weird in that the different parts need to be
// compared against different precedences, not the precedence of the
// conditional itself. The condition should be compared to logical-or,
// and the true/false expressions against assignment.
targetPrecedence = conditional.Condition == node
? OperatorPrecedence.LogicalOr
: OperatorPrecedence.Assignment;
}
if (targetPrecedence <= node.Operand.Precedence)
{
// if the target precedence is less than or equal to the
// precedence of the operand, then the parens are superfluous.
deleteParens = true;
}
}
else
{
// delete self
deleteParens = true;
}
if (deleteParens)
{
// delete the parens by replacing the grouping opertor node
// with its own operand
node.Parent.ReplaceChild(node, node.Operand);
}
}
// always recurse the operand
if (node.Operand != null)
{
node.Operand.Accept(this);
}
}
}
public override void Visit(GroupingOperator node)
{
if (node != null)
{
// if the parent isn't null, we need to run some checks
// to see if we can be removed for being superfluous.
if (node.Parent != null)
{
var deleteParens = false;
if (node.Operand == null)
{
// delete self - no operand make the parens superfluous
// TODO: or should we leave them to preserve the "error"?
deleteParens = true;
}
else if (node.Parent is Block)
{
// function expressions and object literals need to keep the parens
// or they'll be mistaken for function delcarations and blocks, respectively.
// all others get axed.
if (!(node.Operand is FunctionObject) && !(node.Operand is ObjectLiteral))
{
// delete self
deleteParens = true;
}
}
else if (node.Parent is AstNodeList)
{
// keep the parens if the node is itself a comma-operator
// question: do we need to check for ANY comma-operators in the entire expression,
// or will precedence rules dictate that there will be parens lower down if this
// expression isn't a comma-operator?
var binOp = node.Operand as BinaryOperator;
if (binOp == null || binOp.OperatorToken != JSToken.Comma)
{
// delete self
deleteParens = true;
}
}
else if (node.Parent.IsExpression)
{
var targetPrecedence = node.Parent.Precedence;
var conditional = node.Parent as Conditional;
if (conditional != null)
{
// the conditional is weird in that the different parts need to be
// compared against different precedences, not the precedence of the
// conditional itself. The condition should be compared to logical-or,
// and the true/false expressions against assignment.
targetPrecedence = conditional.Condition == node
? OperatorPrecedence.LogicalOr
: OperatorPrecedence.Assignment;
}
if (targetPrecedence <= node.Operand.Precedence)
{
// if the target precedence is less than or equal to the
// precedence of the operand, then the parens are superfluous.
deleteParens = true;
}
}
else
{
// delete self
deleteParens = true;
}
if (deleteParens)
{
// delete the parens by replacing the grouping opertor node
// with its own operand
node.Parent.ReplaceChild(node, node.Operand);
}
}
// always recurse the operand
if (node.Operand != null)
{
node.Operand.Accept(this);
}
}
}
public void Visit(GroupingOperator node)
{
if (node != null)
{
if (node.Operand != null)
{
node.Operand.Accept(this);
}
node.Index = NextOrderIndex;
}
}
public virtual void Visit(GroupingOperator node)
{
// definitely does NOT need parens, because we will
// output parens ourselves. And don't bother recursing.
}
private AstNode ParseLeftHandSideExpression(bool isMinus)
{
AstNode ast = null;
bool skipToken = true;
List<Context> newContexts = null;
TryItAgain:
// new expression
while (JSToken.New == m_currentToken.Token)
{
if (null == newContexts)
newContexts = new List<Context>(4);
newContexts.Add(m_currentToken.Clone());
GetNextToken();
}
JSToken token = m_currentToken.Token;
switch (token)
{
// primary expression
case JSToken.Identifier:
ast = new Lookup(m_currentToken.Clone(), this)
{
Name = m_scanner.Identifier
};
break;
case JSToken.ConditionalCommentStart:
// skip past the start to the next token
GetNextToken();
if (m_currentToken.Token == JSToken.ConditionalCompilationVariable)
{
// we have /*@id
ast = new ConstantWrapperPP(m_currentToken.Clone(), this)
{
VarName = m_currentToken.Code,
ForceComments = true
};
GetNextToken();
if (m_currentToken.Token == JSToken.ConditionalCommentEnd)
{
// skip past the closing comment
GetNextToken();
}
else
{
// we ONLY support /*@id@*/ in expressions right now. If there's not
// a closing comment after the ID, then we don't support it.
// throw an error, skip to the end of the comment, then ignore it and start
// looking for the next token.
CCTooComplicated(null);
goto TryItAgain;
}
}
else if (m_currentToken.Token == JSToken.ConditionalCommentEnd)
{
// empty conditional comment! Ignore.
GetNextToken();
goto TryItAgain;
}
else
{
// we DON'T have "/*@IDENT". We only support "/*@IDENT @*/", so since this isn't
// and id, throw the error, skip to the end of the comment, and ignore it
// by looping back and looking for the NEXT token.
m_currentToken.HandleError(JSError.ConditionalCompilationTooComplex);
// skip to end of conditional comment
while (m_currentToken.Token != JSToken.EndOfFile && m_currentToken.Token != JSToken.ConditionalCommentEnd)
{
GetNextToken();
}
GetNextToken();
goto TryItAgain;
}
break;
case JSToken.This:
ast = new ThisLiteral(m_currentToken.Clone(), this);
break;
case JSToken.StringLiteral:
ast = new ConstantWrapper(m_scanner.StringLiteralValue, PrimitiveType.String, m_currentToken.Clone(), this)
{
MayHaveIssues = m_scanner.LiteralHasIssues
};
break;
case JSToken.IntegerLiteral:
case JSToken.NumericLiteral:
{
Context numericContext = m_currentToken.Clone();
double doubleValue;
if (ConvertNumericLiteralToDouble(m_currentToken.Code, (token == JSToken.IntegerLiteral), out doubleValue))
{
// conversion worked fine
// check for some boundary conditions
var mayHaveIssues = m_scanner.LiteralHasIssues;
if (doubleValue == double.MaxValue)
{
ReportError(JSError.NumericMaximum, numericContext, true);
}
else if (isMinus && -doubleValue == double.MinValue)
{
ReportError(JSError.NumericMinimum, numericContext, true);
}
// create the constant wrapper from the value
ast = new ConstantWrapper(doubleValue, PrimitiveType.Number, numericContext, this)
{
MayHaveIssues = mayHaveIssues
};
}
else
{
// check to see if we went overflow
if (double.IsInfinity(doubleValue))
{
ReportError(JSError.NumericOverflow, numericContext, true);
}
// regardless, we're going to create a special constant wrapper
// that simply echos the input as-is
ast = new ConstantWrapper(m_currentToken.Code, PrimitiveType.Other, numericContext, this)
{
MayHaveIssues = true
};
}
break;
}
case JSToken.True:
ast = new ConstantWrapper(true, PrimitiveType.Boolean, m_currentToken.Clone(), this);
break;
case JSToken.False:
ast = new ConstantWrapper(false, PrimitiveType.Boolean, m_currentToken.Clone(), this);
break;
case JSToken.Null:
ast = new ConstantWrapper(null, PrimitiveType.Null, m_currentToken.Clone(), this);
break;
case JSToken.ConditionalCompilationVariable:
ast = new ConstantWrapperPP(m_currentToken.Clone(), this)
{
VarName = m_currentToken.Code,
ForceComments = false
};
break;
case JSToken.DivideAssign:
// normally this token is not allowed on the left-hand side of an expression.
// BUT, this might be the start of a regular expression that begins with an equals sign!
// we need to test to see if we can parse a regular expression, and if not, THEN
// we can fail the parse.
case JSToken.Divide:
// could it be a regexp?
String source = m_scanner.ScanRegExp();
if (source != null)
{
// parse the flags (if any)
String flags = m_scanner.ScanRegExpFlags();
// create the literal
ast = new RegExpLiteral(m_currentToken.Clone(), this)
{
Pattern = source,
PatternSwitches = flags
};
break;
}
goto default;
// expression
case JSToken.LeftParenthesis:
{
var groupingOp = new GroupingOperator(m_currentToken.Clone(), this);
ast = groupingOp;
GetNextToken();
m_noSkipTokenSet.Add(NoSkipTokenSet.s_ParenExpressionNoSkipToken);
try
{
// parse an expression
groupingOp.Operand = ParseExpression();
if (JSToken.RightParenthesis != m_currentToken.Token)
{
ReportError(JSError.NoRightParenthesis);
}
else
{
// add the closing paren to the expression context
ast.Context.UpdateWith(m_currentToken);
}
}
catch (RecoveryTokenException exc)
{
if (IndexOfToken(NoSkipTokenSet.s_ParenExpressionNoSkipToken, exc) == -1)
throw;
else
groupingOp.Operand = exc._partiallyComputedNode;
}
finally
{
m_noSkipTokenSet.Remove(NoSkipTokenSet.s_ParenExpressionNoSkipToken);
}
}
break;
// array initializer
case JSToken.LeftBracket:
Context listCtx = m_currentToken.Clone();
GetNextToken();
AstNodeList list = new AstNodeList(CurrentPositionContext(), this);
while (JSToken.RightBracket != m_currentToken.Token)
{
if (JSToken.Comma != m_currentToken.Token)
{
m_noSkipTokenSet.Add(NoSkipTokenSet.s_ArrayInitNoSkipTokenSet);
try
{
var expression = ParseExpression(true);
list.Append(expression);
if (JSToken.Comma != m_currentToken.Token)
{
if (JSToken.RightBracket != m_currentToken.Token)
{
ReportError(JSError.NoRightBracket);
}
break;
}
else
{
// we have a comma -- skip it after adding it as a terminator
// on the previous expression
expression.IfNotNull(e => e.TerminatingContext = m_currentToken.Clone());
GetNextToken();
// if the next token is the closing brackets, then we need to
// add a missing value to the array because we end in a comma and
// we need to keep it for cross-platform compat.
// TECHNICALLY, that puts an extra item into the array for most modern browsers, but not ALL.
if (m_currentToken.Token == JSToken.RightBracket)
{
list.Append(new ConstantWrapper(Missing.Value, PrimitiveType.Other, m_currentToken.Clone(), this));
}
}
}
catch (RecoveryTokenException exc)
{
if (exc._partiallyComputedNode != null)
list.Append(exc._partiallyComputedNode);
if (IndexOfToken(NoSkipTokenSet.s_ArrayInitNoSkipTokenSet, exc) == -1)
{
listCtx.UpdateWith(CurrentPositionContext());
exc._partiallyComputedNode = new ArrayLiteral(listCtx, this)
{
Elements = list
};
throw;
}
else
{
if (JSToken.RightBracket == m_currentToken.Token)
break;
}
}
finally
{
m_noSkipTokenSet.Remove(NoSkipTokenSet.s_ArrayInitNoSkipTokenSet);
}
}
else
{
// comma -- missing array item in the list
list.Append(new ConstantWrapper(Missing.Value, PrimitiveType.Other, m_currentToken.Clone(), this)
{
TerminatingContext = m_currentToken.Clone()
});
// skip over the comma
GetNextToken();
// if the next token is the closing brace, then we end with a comma -- and we need to
// add ANOTHER missing value to make sure this last comma doesn't get left off.
// TECHNICALLY, that puts an extra item into the array for most modern browsers, but not ALL.
if (m_currentToken.Token == JSToken.RightBracket)
{
list.Append(new ConstantWrapper(Missing.Value, PrimitiveType.Other, m_currentToken.Clone(), this));
}
}
}
listCtx.UpdateWith(m_currentToken);
ast = new ArrayLiteral(listCtx, this)
{
Elements = list
};
break;
// object initializer
case JSToken.LeftCurly:
Context objCtx = m_currentToken.Clone();
GetNextToken();
var propertyList = new AstNodeList(CurrentPositionContext(), this);
if (JSToken.RightCurly != m_currentToken.Token)
{
for (; ; )
{
ObjectLiteralField field = null;
AstNode value = null;
bool getterSetter = false;
string ident;
switch (m_currentToken.Token)
{
case JSToken.Identifier:
field = new ObjectLiteralField(m_scanner.Identifier, PrimitiveType.String, m_currentToken.Clone(), this);
break;
case JSToken.StringLiteral:
field = new ObjectLiteralField(m_scanner.StringLiteralValue, PrimitiveType.String, m_currentToken.Clone(), this)
{
MayHaveIssues = m_scanner.LiteralHasIssues
};
break;
case JSToken.IntegerLiteral:
case JSToken.NumericLiteral:
{
double doubleValue;
if (ConvertNumericLiteralToDouble(m_currentToken.Code, (m_currentToken.Token == JSToken.IntegerLiteral), out doubleValue))
{
// conversion worked fine
field = new ObjectLiteralField(
doubleValue,
PrimitiveType.Number,
m_currentToken.Clone(),
this
);
}
else
{
// something went wrong and we're not sure the string representation in the source is
// going to convert to a numeric value well
if (double.IsInfinity(doubleValue))
{
ReportError(JSError.NumericOverflow, m_currentToken.Clone(), true);
}
// use the source as the field name, not the numeric value
field = new ObjectLiteralField(
m_currentToken.Code,
PrimitiveType.Other,
m_currentToken.Clone(),
this);
}
break;
}
case JSToken.Get:
case JSToken.Set:
if (PeekToken() == JSToken.Colon)
{
// the field is either "get" or "set" and isn't the special Mozilla getter/setter
field = new ObjectLiteralField(m_currentToken.Code, PrimitiveType.String, m_currentToken.Clone(), this);
}
else
{
// ecma-script get/set property construct
getterSetter = true;
bool isGet = (m_currentToken.Token == JSToken.Get);
value = ParseFunction(
(JSToken.Get == m_currentToken.Token ? FunctionType.Getter : FunctionType.Setter),
m_currentToken.Clone()
);
FunctionObject funcExpr = value as FunctionObject;
if (funcExpr != null)
{
// getter/setter is just the literal name with a get/set flag
field = new GetterSetter(
funcExpr.Name,
isGet,
funcExpr.IdContext.Clone(),
this
);
}
else
{
ReportError(JSError.FunctionExpressionExpected);
}
}
break;
default:
// NOT: identifier token, string, number, or getter/setter.
// see if it's a token that COULD be an identifierName.
ident = m_scanner.Identifier;
if (JSScanner.IsValidIdentifier(ident))
{
// BY THE SPEC, if it's a valid identifierName -- which includes reserved words -- then it's
// okay for object literal syntax. However, reserved words here won't work in all browsers,
// so if it is a reserved word, let's throw a low-sev cross-browser warning on the code.
if (JSKeyword.CanBeIdentifier(m_currentToken.Token) == null)
{
ReportError(JSError.ObjectLiteralKeyword, m_currentToken.Clone(), true);
}
field = new ObjectLiteralField(ident, PrimitiveType.String, m_currentToken.Clone(), this);
}
else
{
// throw an error but use it anyway, since that's what the developer has going on
ReportError(JSError.NoMemberIdentifier, m_currentToken.Clone(), true);
field = new ObjectLiteralField(m_currentToken.Code, PrimitiveType.String, m_currentToken.Clone(), this);
}
break;
}
if (field != null)
{
if (!getterSetter)
{
GetNextToken();
}
m_noSkipTokenSet.Add(NoSkipTokenSet.s_ObjectInitNoSkipTokenSet);
try
{
if (!getterSetter)
{
// get the value
if (JSToken.Colon != m_currentToken.Token)
{
ReportError(JSError.NoColon, true);
value = ParseExpression(true);
}
else
{
field.ColonContext = m_currentToken.Clone();
GetNextToken();
value = ParseExpression(true);
}
}
// put the pair into the list of fields
var propCtx = field.Context.Clone().CombineWith(value.IfNotNull(v => v.Context));
var property = new ObjectLiteralProperty(propCtx, this)
{
Name = field,
Value = value
};
propertyList.Append(property);
if (JSToken.RightCurly == m_currentToken.Token)
{
break;
}
else
{
if (JSToken.Comma == m_currentToken.Token)
{
// skip the comma after adding it to the property as a terminating context
property.IfNotNull(p => p.TerminatingContext = m_currentToken.Clone());
GetNextToken();
// if the next token is the right-curly brace, then we ended
// the list with a comma, which is perfectly fine
if (m_currentToken.Token == JSToken.RightCurly)
{
break;
}
}
else
{
if (m_foundEndOfLine)
{
ReportError(JSError.NoRightCurly);
}
else
ReportError(JSError.NoComma, true);
SkipTokensAndThrow();
}
}
}
catch (RecoveryTokenException exc)
{
if (exc._partiallyComputedNode != null)
{
// the problem was in ParseExpression trying to determine value
value = exc._partiallyComputedNode;
var propCtx = field.Context.Clone().CombineWith(value.IfNotNull(v => v.Context));
var property = new ObjectLiteralProperty(propCtx, this)
{
Name = field,
Value = value
};
propertyList.Append(property);
}
if (IndexOfToken(NoSkipTokenSet.s_ObjectInitNoSkipTokenSet, exc) == -1)
{
exc._partiallyComputedNode = new ObjectLiteral(objCtx, this)
{
Properties = propertyList
};
throw;
}
else
{
if (JSToken.Comma == m_currentToken.Token)
GetNextToken();
if (JSToken.RightCurly == m_currentToken.Token)
break;
}
}
finally
{
m_noSkipTokenSet.Remove(NoSkipTokenSet.s_ObjectInitNoSkipTokenSet);
}
}
}
}
objCtx.UpdateWith(m_currentToken);
ast = new ObjectLiteral(objCtx, this)
{
Properties = propertyList
};
break;
// function expression
case JSToken.Function:
ast = ParseFunction(FunctionType.Expression, m_currentToken.Clone());
skipToken = false;
break;
case JSToken.AspNetBlock:
ast = new AspNetBlockNode(m_currentToken.Clone(), this)
{
AspNetBlockText = m_currentToken.Code
};
break;
default:
string identifier = JSKeyword.CanBeIdentifier(m_currentToken.Token);
if (null != identifier)
{
ast = new Lookup(m_currentToken.Clone(), this)
{
Name = identifier
};
}
else
{
ReportError(JSError.ExpressionExpected);
SkipTokensAndThrow();
}
break;
}
// can be a CallExpression, that is, followed by '.' or '(' or '['
if (skipToken)
GetNextToken();
return MemberExpression(ast, newContexts);
}
public override void Visit(GroupingOperator node)
{
if (node != null)
{
if (m_measure)
{
// either we add one by putting a ! in front of the parens, or
// the expression itself can come out equal to less.
// save the current delta, check the operand, and if applying the
// logical not to the operand is MORE than just throwing a ! on the
// front, then we'll just return the +1 for the simple not.
var plusOne = m_delta + 1;
node.Operand.Accept(this);
if (m_delta > plusOne)
{
m_delta = plusOne;
}
}
else
{
// we need to know how we're going to do this, so we need
// to run another measurement.
m_measure = true;
m_delta = 0;
node.Operand.Accept(this);
m_measure = false;
// if the delta is greater than 1, then we are just going
// to wrap ourselves in a unary not. Otherwise we're going
// to replace ourselves with our operand and not it in-place.
if (m_delta > 1)
{
WrapWithLogicalNot(node);
}
else
{
node.Parent.ReplaceChild(node, node.Operand);
node.Operand.Accept(this);
}
}
}
}
public virtual void Visit(GroupingOperator node)
{
if (node != null && node.Operand != null)
{
// just totally ignore any parentheses
node.Operand.Accept(this);
}
}
