private static void RecurseParameters(AstNodeList parameterList, AstNode node)
{
if (node != null)
{
// if this is a comma operator, then we need to
var binOp = node as BinaryOperator;
if (binOp != null && binOp.OperatorToken == JSToken.Comma)
{
// there are two or more parameters - recurse the list so we get them added left to right,
// converting each one to a binding object
RecurseParameters(parameterList, binOp.Operand1);
// comma operators can flatten lots of commas to an element on the left, and subsequent
// elements in a list on the right.
var rightList = binOp.Operand2 as AstNodeList;
if (rightList != null)
{
foreach (var listItem in rightList.Children)
{
parameterList.Append(ConvertToParameter(listItem, parameterList.Count));
}
}
else
{
// nope, just a single item
parameterList.Append(ConvertToParameter(binOp.Operand2, parameterList.Count));
}
}
else
{
// nope; single operand to convert to a parameter
parameterList.Append(ConvertToParameter(node, 0));
}
}
}
public static AstNode CombineWithComma(SourceContext context, AstNode operand1, AstNode operand2)
{
var comma = new CommaExpression(context);
// if the left is a comma-operator already....
var leftBinary = operand1 as BinaryExpression;
var rightBinary = operand2 as BinaryExpression;
if (leftBinary != null && leftBinary.OperatorToken == JSToken.Comma)
{
// the left-hand side is already a comma operator. Instead of nesting these, we're
// going to combine them
// move the old list's left-hand side to our left-hand side
comma.Operand1 = leftBinary.Operand1;
AstNodeList list;
if (rightBinary != null && rightBinary.OperatorToken == JSToken.Comma)
{
// the right is ALSO a comma operator. Create a new list, append all the rest of the operands
// and set our right-hand side to be the list
list = new AstNodeList(leftBinary.Context.FlattenToStart());
list.Append(leftBinary.Operand2).Append(rightBinary.Operand1).Append(rightBinary.Operand2);
}
else
{
// the right is not a comma operator.
// see if the left-hand side already has a list we can use
list = leftBinary.Operand2 as AstNodeList;
if (list == null)
{
// it's not a list already
// create a new list with the left's right and our right and set it to our right
list = new AstNodeList(leftBinary.Operand2.Context.FlattenToStart());
list.Append(leftBinary.Operand2);
}
// and add our right-hand operand to the end of the list
list.Append(operand2);
}
// set the list on the right
comma.Operand2 = list;
}
else if (rightBinary != null && rightBinary.OperatorToken == JSToken.Comma)
{
// the left hand side is NOT a comma operator.
comma.Operand1 = operand1;
// the right-hand side is already a comma-operator, but the left is not.
// see if it already has a list we can reuse
var rightList = rightBinary.Operand2 as AstNodeList;
if (rightList != null)
{
// it does. Prepend its right-hand operand and use the list
rightList.Insert(0, rightBinary.Operand1);
}
else
{
// it's not -- create a new list containing the operands
rightList = new AstNodeList(rightBinary.Context);
rightList.Append(rightBinary.Operand1);
rightList.Append(rightBinary.Operand2);
}
comma.Operand2 = rightList;
}
else
{
comma.Operand1 = operand1;
comma.Operand2 = operand2;
}
return(comma);
}
static AstNode CreateSplitNodeFromEnd(AstNodeList nodeList, int ndx)
{
AstNode newNode;
if (ndx == nodeList.Count - 1)
{
// the LAST one can be broken. Pull it off the list and we will just
// insert it after the current node.
newNode = nodeList[ndx];
nodeList.RemoveAt(ndx);
}
else if (ndx == nodeList.Count - 2)
{
// the PENULTIMATE item can be broken. So create a new comma operator
// with the just the last two item and we'll insert it after the current node
var left = nodeList[ndx];
nodeList.RemoveAt(ndx);
var right = nodeList[ndx];
nodeList.RemoveAt(ndx);
newNode = new CommaExpression(left.Context.FlattenToStart())
{
Operand1 = left,
Operand2 = right
};
}
else
{
// at least three items will be pulled off, which means there will
// be at least two items on the right, so we'll create a new astlist to
// insert those items into a new comma operator
var left = nodeList[ndx];
nodeList.RemoveAt(ndx);
// if we were passed zero, then just reuse the node list.
// otherwise we need to create a new one and move the items
// from the index position over.
AstNodeList right;
if (ndx == 0)
{
right = nodeList;
}
else
{
right = new AstNodeList(nodeList[ndx].Context.FlattenToStart());
while (ndx < nodeList.Count)
{
var temp = nodeList[ndx];
nodeList.RemoveAt(ndx);
right.Append(temp);
}
}
newNode = new CommaExpression(left.Context.FlattenToStart())
{
Operand1 = left,
Operand2 = right
};
}
return(newNode);
}
//---------------------------------------------------------------------------------------
// ParseExpressionList
//
// Given a starting this.currentToken '(' or '[', parse a list of expression separated by
// ',' until matching ')' or ']'
//---------------------------------------------------------------------------------------
private AstNodeList ParseExpressionList(JSToken terminator)
{
Context listCtx = m_currentToken.Clone();
GetNextToken();
AstNodeList list = new AstNodeList(listCtx, this);
if (terminator != m_currentToken.Token)
{
for (; ; )
{
m_noSkipTokenSet.Add(NoSkipTokenSet.s_ExpressionListNoSkipTokenSet);
try
{
AstNode item;
if (JSToken.Comma == m_currentToken.Token)
{
item = new ConstantWrapper(Missing.Value, PrimitiveType.Other, m_currentToken.Clone(), this);
list.Append(item);
}
else if (terminator == m_currentToken.Token)
{
break;
}
else
{
item = ParseExpression(true);
list.Append(item);
}
if (terminator == m_currentToken.Token)
{
break;
}
else
{
if (JSToken.Comma == m_currentToken.Token)
{
item.IfNotNull(n => n.TerminatingContext = m_currentToken.Clone());
}
else
{
if (terminator == JSToken.RightParenthesis)
{
// in ASP+ it's easy to write a semicolon at the end of an expression
// not realizing it is going to go inside a function call
// (ie. Response.Write()), so make a special check here
if (JSToken.Semicolon == m_currentToken.Token)
{
if (JSToken.RightParenthesis == PeekToken())
{
ReportError(JSError.UnexpectedSemicolon, true);
GetNextToken();
break;
}
}
ReportError(JSError.NoRightParenthesisOrComma);
}
else
{
ReportError(JSError.NoRightBracketOrComma);
}
SkipTokensAndThrow();
}
}
}
catch (RecoveryTokenException exc)
{
if (exc._partiallyComputedNode != null)
list.Append(exc._partiallyComputedNode);
if (IndexOfToken(NoSkipTokenSet.s_ExpressionListNoSkipTokenSet, exc) == -1)
{
exc._partiallyComputedNode = list;
throw;
}
}
finally
{
m_noSkipTokenSet.Remove(NoSkipTokenSet.s_ExpressionListNoSkipTokenSet);
}
GetNextToken();
}
}
listCtx.UpdateWith(m_currentToken);
return list;
}
//---------------------------------------------------------------------------------------
// MemberExpression
//
// Accessor :
// <empty> |
// Arguments Accessor
// '[' Expression ']' Accessor |
// '.' Identifier Accessor |
//
// Don't have this function throwing an exception without checking all the calling sites.
// There is state in instance variable that is saved on the calling stack in some function
// (i.e ParseFunction and ParseClass) and you don't want to blow up the stack
//---------------------------------------------------------------------------------------
private AstNode MemberExpression(AstNode expression, List<Context> newContexts)
{
for (; ; )
{
m_noSkipTokenSet.Add(NoSkipTokenSet.s_MemberExprNoSkipTokenSet);
try
{
switch (m_currentToken.Token)
{
case JSToken.LeftParenthesis:
AstNodeList args = null;
RecoveryTokenException callError = null;
m_noSkipTokenSet.Add(NoSkipTokenSet.s_ParenToken);
try
{
args = ParseExpressionList(JSToken.RightParenthesis);
}
catch (RecoveryTokenException exc)
{
args = (AstNodeList)exc._partiallyComputedNode;
if (IndexOfToken(NoSkipTokenSet.s_ParenToken, exc) == -1)
callError = exc; // thrown later on
}
finally
{
m_noSkipTokenSet.Remove(NoSkipTokenSet.s_ParenToken);
}
expression = new CallNode(expression.Context.CombineWith(args.Context), this)
{
Function = expression,
Arguments = args,
InBrackets = false
};
if (null != newContexts && newContexts.Count > 0)
{
(newContexts[newContexts.Count - 1]).UpdateWith(expression.Context);
if (!(expression is CallNode))
{
expression = new CallNode(newContexts[newContexts.Count - 1], this)
{
Function = expression,
Arguments = new AstNodeList(CurrentPositionContext(), this)
};
}
else
{
expression.Context = newContexts[newContexts.Count - 1];
}
((CallNode)expression).IsConstructor = true;
newContexts.RemoveAt(newContexts.Count - 1);
}
if (callError != null)
{
callError._partiallyComputedNode = expression;
throw callError;
}
GetNextToken();
break;
case JSToken.LeftBracket:
m_noSkipTokenSet.Add(NoSkipTokenSet.s_BracketToken);
try
{
//
// ROTOR parses a[b,c] as a call to a, passing in the arguments b and c.
// the correct parse is a member lookup on a of c -- the "b,c" should be
// a single expression with a comma operator that evaluates b but only
// returns c.
// So we'll change the default behavior from parsing an expression list to
// parsing a single expression, but returning a single-item list (or an empty
// list if there is no expression) so the rest of the code will work.
//
//args = ParseExpressionList(JSToken.RightBracket);
GetNextToken();
args = new AstNodeList(CurrentPositionContext(), this);
AstNode accessor = ParseExpression();
if (accessor != null)
{
args.Append(accessor);
}
}
catch (RecoveryTokenException exc)
{
if (IndexOfToken(NoSkipTokenSet.s_BracketToken, exc) == -1)
{
if (exc._partiallyComputedNode != null)
{
exc._partiallyComputedNode =
new CallNode(expression.Context.CombineWith(m_currentToken.Clone()), this)
{
Function = expression,
Arguments = (AstNodeList)exc._partiallyComputedNode,
InBrackets = true
};
}
else
{
exc._partiallyComputedNode = expression;
}
throw;
}
else
args = (AstNodeList)exc._partiallyComputedNode;
}
finally
{
m_noSkipTokenSet.Remove(NoSkipTokenSet.s_BracketToken);
}
expression = new CallNode(expression.Context.CombineWith(m_currentToken.Clone()), this)
{
Function = expression,
Arguments = args,
InBrackets = true
};
// there originally was code here in the ROTOR sources that checked the new context list and
// changed this member call to a constructor call, effectively combining the two. I believe they
// need to remain separate.
// remove the close bracket token
GetNextToken();
break;
case JSToken.AccessField:
ConstantWrapper id = null;
Context nameContext = m_currentToken.Clone();
GetNextToken();
if (JSToken.Identifier != m_currentToken.Token)
{
string identifier = JSKeyword.CanBeIdentifier(m_currentToken.Token);
if (null != identifier)
{
// don't report an error here -- it's actually okay to have a property name
// that is a keyword which is okay to be an identifier. For instance,
// jQuery has a commonly-used method named "get" to make an ajax request
//ForceReportInfo(JSError.KeywordUsedAsIdentifier);
id = new ConstantWrapper(identifier, PrimitiveType.String, m_currentToken.Clone(), this);
}
else if (JSScanner.IsValidIdentifier(m_currentToken.Code))
{
// it must be a keyword, because it can't technically be an identifier,
// but it IS a valid identifier format. Throw a warning but still
// create the constant wrapper so we can output it as-is
ReportError(JSError.KeywordUsedAsIdentifier, m_currentToken.Clone(), true);
id = new ConstantWrapper(m_currentToken.Code, PrimitiveType.String, m_currentToken.Clone(), this);
}
else
{
ReportError(JSError.NoIdentifier);
SkipTokensAndThrow(expression);
}
}
else
{
id = new ConstantWrapper(m_scanner.Identifier, PrimitiveType.String, m_currentToken.Clone(), this);
}
GetNextToken();
expression = new Member(expression.Context.CombineWith(id.Context), this)
{
Root = expression,
Name = id.Context.Code,
NameContext = nameContext.CombineWith(id.Context)
};
break;
default:
if (null != newContexts)
{
while (newContexts.Count > 0)
{
(newContexts[newContexts.Count - 1]).UpdateWith(expression.Context);
expression = new CallNode(newContexts[newContexts.Count - 1], this)
{
Function = expression,
Arguments = new AstNodeList(CurrentPositionContext(), this)
};
((CallNode)expression).IsConstructor = true;
newContexts.RemoveAt(newContexts.Count - 1);
}
}
return expression;
}
}
catch (RecoveryTokenException exc)
{
if (IndexOfToken(NoSkipTokenSet.s_MemberExprNoSkipTokenSet, exc) != -1)
expression = exc._partiallyComputedNode;
else
{
Debug.Assert(exc._partiallyComputedNode == expression);
throw;
}
}
finally
{
m_noSkipTokenSet.Remove(NoSkipTokenSet.s_MemberExprNoSkipTokenSet);
}
}
}
/// <summary>
/// Parse the source code using the given settings, getting back an abstract syntax tree Block node as the root
/// representing the list of statements in the source code.
/// </summary>
/// <param name="settings">code settings to use to process the source code</param>
/// <returns>root Block node representing the top-level statements</returns>
public Block Parse(CodeSettings settings)
{
// initialize the scanner with our settings
// make sure the RawTokens setting is OFF or we won't be able to create our AST
InitializeScanner(settings);
// make sure we initialize the global scope's strict mode to our flag, whether or not it
// is true. This means if the setting is false, we will RESET the flag to false if we are
// reusing the scope and a previous Parse call had code that set it to strict with a
// program directive.
GlobalScope.UseStrict = m_settings.StrictMode;
// make sure the global scope knows about our known global names
GlobalScope.SetAssumedGlobals(m_settings);
// start of a new module
m_newModule = true;
Block scriptBlock;
Block returnBlock;
switch (m_settings.SourceMode)
{
case JavaScriptSourceMode.Program:
// simply parse a block of statements
returnBlock = scriptBlock = ParseStatements();
break;
case JavaScriptSourceMode.Expression:
// create a block, get the first token, add in the parse of a single expression,
// and we'll go fron there.
returnBlock = scriptBlock = new Block(CurrentPositionContext(), this);
GetNextToken();
try
{
var expr = ParseExpression();
if (expr != null)
{
scriptBlock.Append(expr);
scriptBlock.UpdateWith(expr.Context);
}
}
catch (EndOfFileException)
{
Debug.WriteLine("EOF");
}
break;
case JavaScriptSourceMode.EventHandler:
// we're going to create the global block, add in a function expression with a single
// parameter named "event", and then we're going to parse the input as the body of that
// function expression. We're going to resolve the global block, but only return the body
// of the function.
scriptBlock = new Block(null, this);
var parameters = new AstNodeList(null, this);
parameters.Append(new ParameterDeclaration(null, this)
{
Name = "event",
RenameNotAllowed = true
});
var funcExpression = new FunctionObject(null, this)
{
FunctionType = FunctionType.Expression,
ParameterDeclarations = parameters
};
scriptBlock.Append(funcExpression);
returnBlock = ParseStatements();
funcExpression.Body = returnBlock;
break;
default:
Debug.Fail("Unexpected source mode enumeration");
return null;
}
// resolve everything
ResolutionVisitor.Apply(scriptBlock, GlobalScope, m_settings);
if (scriptBlock != null && Settings.MinifyCode)
{
// this visitor doesn't just reorder scopes. It also combines the adjacent var variables,
// unnests blocks, identifies prologue directives, and sets the strict mode on scopes.
ReorderScopeVisitor.Apply(scriptBlock, this);
// analyze the entire node tree (needed for hypercrunch)
// root to leaf (top down)
var analyzeVisitor = new AnalyzeNodeVisitor(this);
scriptBlock.Accept(analyzeVisitor);
// analyze the scope chain (also needed for hypercrunch)
// root to leaf (top down)
m_globalScope.AnalyzeScope();
// if we want to crunch any names....
if (m_settings.LocalRenaming != LocalRenaming.KeepAll
&& m_settings.IsModificationAllowed(TreeModifications.LocalRenaming))
{
// then do a top-down traversal of the scope tree. For each field that had not
// already been crunched (globals and outers will already be crunched), crunch
// the name with a crunch iterator that does not use any names in the verboten set.
m_globalScope.AutoRenameFields();
}
// if we want to evaluate literal expressions, do so now
if (m_settings.EvalLiteralExpressions)
{
var visitor = new EvaluateLiteralVisitor(this);
scriptBlock.Accept(visitor);
}
// if any of the conditions we check for in the final pass are available, then
// make the final pass
if (m_settings.IsModificationAllowed(TreeModifications.BooleanLiteralsToNotOperators))
{
var visitor = new FinalPassVisitor(this);
scriptBlock.Accept(visitor);
}
// we want to walk all the scopes to make sure that any generated
// variables that haven't been crunched have been assigned valid
// variable names that don't collide with any existing variables.
m_globalScope.ValidateGeneratedNames();
}
if (returnBlock.Parent != null)
{
returnBlock.Parent = null;
}
return returnBlock;
}
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);
}
private FunctionObject ParseFunction(FunctionType functionType, Context fncCtx)
{
Lookup name = null;
AstNodeList formalParameters = null;
Block body = null;
bool inExpression = (functionType == FunctionType.Expression);
Context paramsContext = null;
GetNextToken();
// get the function name or make an anonymous function if in expression "position"
if (JSToken.Identifier == m_currentToken.Token)
{
name = new Lookup(m_currentToken.Clone(), this)
{
Name = m_scanner.Identifier
};
GetNextToken();
}
else
{
string identifier = JSKeyword.CanBeIdentifier(m_currentToken.Token);
if (null != identifier)
{
name = new Lookup(m_currentToken.Clone(), this)
{
Name = identifier
};
GetNextToken();
}
else
{
if (!inExpression)
{
// if this isn't a function expression, then we need to throw an error because
// function DECLARATIONS always need a valid identifier name
ReportError(JSError.NoIdentifier, m_currentToken.Clone(), true);
// BUT if the current token is a left paren, we don't want to use it as the name.
// (fix for issue #14152)
if (m_currentToken.Token != JSToken.LeftParenthesis
&& m_currentToken.Token != JSToken.LeftCurly)
{
identifier = m_currentToken.Code;
name = new Lookup(CurrentPositionContext(), this)
{
Name = identifier
};
GetNextToken();
}
}
}
}
// make a new state and save the old one
List<BlockType> blockType = m_blockType;
m_blockType = new List<BlockType>(16);
Dictionary<string, LabelInfo> labelTable = m_labelTable;
m_labelTable = new Dictionary<string, LabelInfo>();
try
{
// get the formal parameters
if (JSToken.LeftParenthesis != m_currentToken.Token)
{
// we expect a left paren at this point for standard cross-browser support.
// BUT -- some versions of IE allow an object property expression to be a function name, like window.onclick.
// we still want to throw the error, because it syntax errors on most browsers, but we still want to
// be able to parse it and return the intended results.
// Skip to the open paren and use whatever is in-between as the function name. Doesn't matter that it's
// an invalid identifier; it won't be accessible as a valid field anyway.
bool expandedIndentifier = false;
while (m_currentToken.Token != JSToken.LeftParenthesis
&& m_currentToken.Token != JSToken.LeftCurly
&& m_currentToken.Token != JSToken.Semicolon
&& m_currentToken.Token != JSToken.EndOfFile)
{
name.Context.UpdateWith(m_currentToken);
GetNextToken();
expandedIndentifier = true;
}
// if we actually expanded the identifier context, then we want to report that
// the function name needs to be an identifier. Otherwise we didn't expand the
// name, so just report that we expected an open paren at this point.
if (expandedIndentifier)
{
name.Name = name.Context.Code;
name.Context.HandleError(JSError.FunctionNameMustBeIdentifier, false);
}
else
{
ReportError(JSError.NoLeftParenthesis, true);
}
}
if (m_currentToken.Token == JSToken.LeftParenthesis)
{
// create the parameter list
formalParameters = new AstNodeList(m_currentToken.Clone(), this);
paramsContext = m_currentToken.Clone();
// skip the open paren
GetNextToken();
// create the list of arguments and update the context
while (JSToken.RightParenthesis != m_currentToken.Token)
{
String id = null;
m_noSkipTokenSet.Add(NoSkipTokenSet.s_FunctionDeclNoSkipTokenSet);
try
{
ParameterDeclaration paramDecl = null;
if (JSToken.Identifier != m_currentToken.Token && (id = JSKeyword.CanBeIdentifier(m_currentToken.Token)) == null)
{
if (JSToken.LeftCurly == m_currentToken.Token)
{
ReportError(JSError.NoRightParenthesis);
break;
}
else if (JSToken.Comma == m_currentToken.Token)
{
// We're missing an argument (or previous argument was malformed and
// we skipped to the comma.) Keep trying to parse the argument list --
// we will skip the comma below.
ReportError(JSError.SyntaxError, true);
}
else
{
ReportError(JSError.SyntaxError, true);
SkipTokensAndThrow();
}
}
else
{
if (null == id)
{
id = m_scanner.Identifier;
}
paramDecl = new ParameterDeclaration(m_currentToken.Clone(), this)
{
Name = id,
Position = formalParameters.Count
};
formalParameters.Append(paramDecl);
GetNextToken();
}
// got an arg, it should be either a ',' or ')'
if (JSToken.RightParenthesis == m_currentToken.Token)
{
break;
}
else if (JSToken.Comma == m_currentToken.Token)
{
// append the comma context as the terminator for the parameter
paramDecl.IfNotNull(p => p.TerminatingContext = m_currentToken.Clone());
}
else
{
// deal with error in some "intelligent" way
if (JSToken.LeftCurly == m_currentToken.Token)
{
ReportError(JSError.NoRightParenthesis);
break;
}
else
{
if (JSToken.Identifier == m_currentToken.Token)
{
// it's possible that the guy was writing the type in C/C++ style (i.e. int x)
ReportError(JSError.NoCommaOrTypeDefinitionError);
}
else
ReportError(JSError.NoComma);
}
}
GetNextToken();
}
catch (RecoveryTokenException exc)
{
if (IndexOfToken(NoSkipTokenSet.s_FunctionDeclNoSkipTokenSet, exc) == -1)
throw;
}
finally
{
m_noSkipTokenSet.Remove(NoSkipTokenSet.s_FunctionDeclNoSkipTokenSet);
}
}
fncCtx.UpdateWith(m_currentToken);
GetNextToken();
}
// read the function body of non-abstract functions.
if (JSToken.LeftCurly != m_currentToken.Token)
ReportError(JSError.NoLeftCurly, true);
m_blockType.Add(BlockType.Block);
m_noSkipTokenSet.Add(NoSkipTokenSet.s_BlockNoSkipTokenSet);
m_noSkipTokenSet.Add(NoSkipTokenSet.s_StartStatementNoSkipTokenSet);
try
{
// parse the block locally to get the exact end of function
body = new Block(m_currentToken.Clone(), this);
body.BraceOnNewLine = m_foundEndOfLine;
GetNextToken();
var possibleDirectivePrologue = true;
while (JSToken.RightCurly != m_currentToken.Token)
{
try
{
// function body's are SourceElements (Statements + FunctionDeclarations)
var statement = ParseStatement(true);
if (possibleDirectivePrologue)
{
var constantWrapper = statement as ConstantWrapper;
if (constantWrapper != null && constantWrapper.PrimitiveType == PrimitiveType.String)
{
// if it's already a directive prologues, we're good to go
if (!(constantWrapper is DirectivePrologue))
{
// make the statement a directive prologue instead of a constant wrapper
statement = new DirectivePrologue(constantWrapper.Value.ToString(), constantWrapper.Context, constantWrapper.Parser)
{
MayHaveIssues = constantWrapper.MayHaveIssues
};
}
}
else if (!m_newModule)
{
// no longer considering constant wrappers
possibleDirectivePrologue = false;
}
}
else if (m_newModule)
{
// we scanned into a new module -- we might find directive prologues again
possibleDirectivePrologue = true;
}
// add it to the body
body.Append(statement);
}
catch (RecoveryTokenException exc)
{
if (exc._partiallyComputedNode != null)
{
body.Append(exc._partiallyComputedNode);
}
if (IndexOfToken(NoSkipTokenSet.s_StartStatementNoSkipTokenSet, exc) == -1)
throw;
}
}
// make sure any important comments before the closing brace are kept
if (m_importantComments.Count > 0
&& m_settings.PreserveImportantComments
&& m_settings.IsModificationAllowed(TreeModifications.PreserveImportantComments))
{
// we have important comments before the EOF. Add the comment(s) to the program.
foreach (var importantComment in m_importantComments)
{
body.Append(new ImportantComment(importantComment, this));
}
m_importantComments.Clear();
}
body.Context.UpdateWith(m_currentToken);
fncCtx.UpdateWith(m_currentToken);
}
catch (EndOfFileException)
{
// if we get an EOF here, we never had a chance to find the closing curly-brace
fncCtx.HandleError(JSError.UnclosedFunction, true);
}
catch (RecoveryTokenException exc)
{
if (IndexOfToken(NoSkipTokenSet.s_BlockNoSkipTokenSet, exc) == -1)
{
exc._partiallyComputedNode = new FunctionObject(fncCtx, this)
{
FunctionType = (inExpression ? FunctionType.Expression : FunctionType.Declaration),
IdContext = name.IfNotNull(n => n.Context),
Name = name.IfNotNull(n => n.Name),
ParameterDeclarations = formalParameters,
ParametersContext = paramsContext,
Body = body
};
throw;
}
}
finally
{
m_blockType.RemoveAt(m_blockType.Count - 1);
m_noSkipTokenSet.Remove(NoSkipTokenSet.s_StartStatementNoSkipTokenSet);
m_noSkipTokenSet.Remove(NoSkipTokenSet.s_BlockNoSkipTokenSet);
}
GetNextToken();
}
finally
{
// restore state
m_blockType = blockType;
m_labelTable = labelTable;
}
return new FunctionObject(fncCtx, this)
{
FunctionType = functionType,
IdContext = name.IfNotNull(n => n.Context),
Name = name.IfNotNull(n => n.Name),
ParameterDeclarations = formalParameters,
ParametersContext = paramsContext,
Body = body
};
}
private AstNode ParseSwitchStatement()
{
Context switchCtx = m_currentToken.Clone();
AstNode expr = null;
AstNodeList cases = null;
var braceOnNewLine = false;
Context braceContext = null;
m_blockType.Add(BlockType.Switch);
try
{
// read switch(expr)
GetNextToken();
if (JSToken.LeftParenthesis != m_currentToken.Token)
ReportError(JSError.NoLeftParenthesis);
GetNextToken();
m_noSkipTokenSet.Add(NoSkipTokenSet.s_BlockConditionNoSkipTokenSet);
m_noSkipTokenSet.Add(NoSkipTokenSet.s_SwitchNoSkipTokenSet);
try
{
expr = ParseExpression();
if (JSToken.RightParenthesis != m_currentToken.Token)
{
ReportError(JSError.NoRightParenthesis);
}
GetNextToken();
if (JSToken.LeftCurly != m_currentToken.Token)
{
ReportError(JSError.NoLeftCurly);
}
braceOnNewLine = m_foundEndOfLine;
braceContext = m_currentToken.Clone();
GetNextToken();
}
catch (RecoveryTokenException exc)
{
if (IndexOfToken(NoSkipTokenSet.s_BlockConditionNoSkipTokenSet, exc) == -1
&& IndexOfToken(NoSkipTokenSet.s_SwitchNoSkipTokenSet, exc) == -1)
{
// give up
exc._partiallyComputedNode = null;
throw;
}
else
{
if (exc._partiallyComputedNode == null)
expr = new ConstantWrapper(true, PrimitiveType.Boolean, CurrentPositionContext(), this);
else
expr = exc._partiallyComputedNode;
if (IndexOfToken(NoSkipTokenSet.s_BlockConditionNoSkipTokenSet, exc) != -1)
{
if (exc._token == JSToken.RightParenthesis)
GetNextToken();
if (JSToken.LeftCurly != m_currentToken.Token)
{
ReportError(JSError.NoLeftCurly);
}
braceOnNewLine = m_foundEndOfLine;
braceContext = m_currentToken.Clone();
GetNextToken();
}
}
}
finally
{
m_noSkipTokenSet.Remove(NoSkipTokenSet.s_SwitchNoSkipTokenSet);
m_noSkipTokenSet.Remove(NoSkipTokenSet.s_BlockConditionNoSkipTokenSet);
}
// parse the switch body
cases = new AstNodeList(CurrentPositionContext(), this);
bool defaultStatement = false;
m_noSkipTokenSet.Add(NoSkipTokenSet.s_BlockNoSkipTokenSet);
try
{
while (JSToken.RightCurly != m_currentToken.Token)
{
SwitchCase caseClause = null;
AstNode caseValue = null;
var caseCtx = m_currentToken.Clone();
Context colonContext = null;
m_noSkipTokenSet.Add(NoSkipTokenSet.s_CaseNoSkipTokenSet);
try
{
if (JSToken.Case == m_currentToken.Token)
{
// get the case
GetNextToken();
caseValue = ParseExpression();
}
else if (JSToken.Default == m_currentToken.Token)
{
// get the default
if (defaultStatement)
{
// we report an error but we still accept the default
ReportError(JSError.DupDefault, true);
}
else
{
defaultStatement = true;
}
GetNextToken();
}
else
{
// This is an error, there is no case or default. Assume a default was missing and keep going
defaultStatement = true;
ReportError(JSError.BadSwitch);
}
if (JSToken.Colon != m_currentToken.Token)
{
ReportError(JSError.NoColon);
}
else
{
colonContext = m_currentToken.Clone();
}
// read the statements inside the case or default
GetNextToken();
}
catch (RecoveryTokenException exc)
{
// right now we can only get here for the 'case' statement
if (IndexOfToken(NoSkipTokenSet.s_CaseNoSkipTokenSet, exc) == -1)
{
// ignore the current case or default
exc._partiallyComputedNode = null;
throw;
}
else
{
caseValue = exc._partiallyComputedNode;
if (exc._token == JSToken.Colon)
{
GetNextToken();
}
}
}
finally
{
m_noSkipTokenSet.Remove(NoSkipTokenSet.s_CaseNoSkipTokenSet);
}
m_blockType.Add(BlockType.Block);
try
{
var statements = new Block(m_currentToken.Clone(), this);
m_noSkipTokenSet.Add(NoSkipTokenSet.s_SwitchNoSkipTokenSet);
m_noSkipTokenSet.Add(NoSkipTokenSet.s_StartStatementNoSkipTokenSet);
try
{
while (JSToken.RightCurly != m_currentToken.Token && JSToken.Case != m_currentToken.Token && JSToken.Default != m_currentToken.Token)
{
try
{
// parse a Statement, not a SourceElement
statements.Append(ParseStatement(false));
}
catch (RecoveryTokenException exc)
{
if (exc._partiallyComputedNode != null)
{
statements.Append(exc._partiallyComputedNode);
exc._partiallyComputedNode = null;
}
if (IndexOfToken(NoSkipTokenSet.s_StartStatementNoSkipTokenSet, exc) == -1)
{
throw;
}
}
}
}
catch (RecoveryTokenException exc)
{
if (IndexOfToken(NoSkipTokenSet.s_SwitchNoSkipTokenSet, exc) == -1)
{
caseClause = new SwitchCase(caseCtx, this)
{
CaseValue = caseValue,
ColonContext = colonContext,
Statements = statements
};
cases.Append(caseClause);
throw;
}
}
finally
{
m_noSkipTokenSet.Remove(NoSkipTokenSet.s_StartStatementNoSkipTokenSet);
m_noSkipTokenSet.Remove(NoSkipTokenSet.s_SwitchNoSkipTokenSet);
}
caseCtx.UpdateWith(statements.Context);
caseClause = new SwitchCase(caseCtx, this)
{
CaseValue = caseValue,
ColonContext = colonContext,
Statements = statements
};
cases.Append(caseClause);
}
finally
{
m_blockType.RemoveAt(m_blockType.Count - 1);
}
}
}
catch (RecoveryTokenException exc)
{
if (IndexOfToken(NoSkipTokenSet.s_BlockNoSkipTokenSet, exc) == -1)
{
//save what you can a rethrow
switchCtx.UpdateWith(CurrentPositionContext());
exc._partiallyComputedNode = new Switch(switchCtx, this)
{
Expression = expr,
BraceContext = braceContext,
Cases = cases,
BraceOnNewLine = braceOnNewLine
};
throw;
}
}
finally
{
m_noSkipTokenSet.Remove(NoSkipTokenSet.s_BlockNoSkipTokenSet);
}
switchCtx.UpdateWith(m_currentToken);
GetNextToken();
}
finally
{
m_blockType.RemoveAt(m_blockType.Count - 1);
}
return new Switch(switchCtx, this)
{
Expression = expr,
BraceContext = braceContext,
Cases = cases,
BraceOnNewLine = braceOnNewLine
};
}