public void Visit(AspNetBlockNode node)
{
// invalid! ignore
IsValid = false;
}
public void Visit(AspNetBlockNode node)
{
// don't bother recursing, but let's wrap in parens, just in case
// (since we don't know what will be inserted here)
m_needsParens = true;
}
public void Visit(AspNetBlockNode node)
{
// invalid! ignore
IsValid = false;
}
public void Visit(AspNetBlockNode node)
{
// nothing to do
}
public void Visit(AspNetBlockNode node)
{
// not applicable; terminate
}
public void Visit(AspNetBlockNode node)
{
// don't bother recursing, but let's wrap in parens, just in case
// (since we don't know what will be inserted here)
m_needsParens = true;
}
private AstNode ParseStatement(bool fSourceElement)
{
AstNode statement = null;
if (m_importantComments.Count > 0
&& m_settings.PreserveImportantComments
&& m_settings.IsModificationAllowed(TreeModifications.PreserveImportantComments))
{
// we have at least one important comment before the upcoming statement.
// pop the first important comment off the queue, return that node instead.
// don't advance the token -- we'll probably be coming back again for the next one (if any)
statement = new ImportantComment(m_importantComments[0], this);
m_importantComments.RemoveAt(0);
}
else
{
String id = null;
var isNewModule = m_newModule;
switch (m_currentToken.Token)
{
case JSToken.EndOfFile:
EOFError(JSError.ErrorEndOfFile);
throw new EndOfFileException(); // abort parsing, get back to the main parse routine
case JSToken.Semicolon:
// make an empty statement
statement = new EmptyStatement(m_currentToken.Clone(), this);
GetNextToken();
return statement;
case JSToken.RightCurly:
ReportError(JSError.SyntaxError);
SkipTokensAndThrow();
break;
case JSToken.LeftCurly:
return ParseBlock();
case JSToken.Debugger:
return ParseDebuggerStatement();
case JSToken.Var:
case JSToken.Const:
case JSToken.Let:
return ParseVariableStatement();
case JSToken.If:
return ParseIfStatement();
case JSToken.For:
return ParseForStatement();
case JSToken.Do:
return ParseDoStatement();
case JSToken.While:
return ParseWhileStatement();
case JSToken.Continue:
statement = ParseContinueStatement();
if (null == statement)
return new Block(CurrentPositionContext(), this);
else
return statement;
case JSToken.Break:
statement = ParseBreakStatement();
if (null == statement)
return new Block(CurrentPositionContext(), this);
else
return statement;
case JSToken.Return:
statement = ParseReturnStatement();
if (null == statement)
return new Block(CurrentPositionContext(), this);
else
return statement;
case JSToken.With:
return ParseWithStatement();
case JSToken.Switch:
return ParseSwitchStatement();
case JSToken.Throw:
statement = ParseThrowStatement();
if (statement == null)
return new Block(CurrentPositionContext(), this);
else
break;
case JSToken.Try:
return ParseTryStatement();
case JSToken.Function:
// parse a function declaration
FunctionObject function = ParseFunction(FunctionType.Declaration, m_currentToken.Clone());
function.IsSourceElement = fSourceElement;
return function;
case JSToken.Else:
ReportError(JSError.InvalidElse);
SkipTokensAndThrow();
break;
case JSToken.ConditionalCommentStart:
return ParseStatementLevelConditionalComment(fSourceElement);
case JSToken.ConditionalCompilationOn:
{
ConditionalCompilationOn ccOn = new ConditionalCompilationOn(m_currentToken.Clone(), this);
GetNextToken();
return ccOn;
}
case JSToken.ConditionalCompilationSet:
return ParseConditionalCompilationSet();
case JSToken.ConditionalCompilationIf:
return ParseConditionalCompilationIf(false);
case JSToken.ConditionalCompilationElseIf:
return ParseConditionalCompilationIf(true);
case JSToken.ConditionalCompilationElse:
{
ConditionalCompilationElse elseStatement = new ConditionalCompilationElse(m_currentToken.Clone(), this);
GetNextToken();
return elseStatement;
}
case JSToken.ConditionalCompilationEnd:
{
ConditionalCompilationEnd endStatement = new ConditionalCompilationEnd(m_currentToken.Clone(), this);
GetNextToken();
return endStatement;
}
default:
m_noSkipTokenSet.Add(NoSkipTokenSet.s_EndOfStatementNoSkipTokenSet);
bool exprError = false;
try
{
bool bAssign;
// if this statement starts with a function within parens, we want to know now
bool parenFunction = (m_currentToken.Token == JSToken.LeftParenthesis && PeekToken() == JSToken.Function);
statement = ParseUnaryExpression(out bAssign, false);
if (statement != null && parenFunction)
{
FunctionObject functionObject = statement.LeftHandSide as FunctionObject;
if (functionObject != null)
{
functionObject.LeftHandFunctionExpression = true;
}
}
// look for labels
if (statement is Lookup && JSToken.Colon == m_currentToken.Token)
{
// can be a label
id = statement.ToString();
if (m_labelTable.ContainsKey(id))
{
// there is already a label with that name. Ignore the current label
ReportError(JSError.BadLabel, statement.Context.Clone(), true);
id = null;
GetNextToken(); // skip over ':'
return new Block(CurrentPositionContext(), this);
}
else
{
var colonContext = m_currentToken.Clone();
GetNextToken();
int labelNestCount = m_labelTable.Count + 1;
m_labelTable.Add(id, new LabelInfo(m_blockType.Count, labelNestCount));
if (JSToken.EndOfFile != m_currentToken.Token)
{
statement = new LabeledStatement(statement.Context.Clone(), this)
{
Label = id,
ColonContext = colonContext,
NestCount = labelNestCount,
Statement = ParseStatement(fSourceElement)
};
}
else
{
// end of the file!
//just pass null for the labeled statement
statement = new LabeledStatement(statement.Context.Clone(), this)
{
Label = id,
ColonContext = colonContext,
NestCount = labelNestCount
};
}
m_labelTable.Remove(id);
return statement;
}
}
statement = ParseExpression(statement, false, bAssign, JSToken.None);
// if we just started a new module and this statement happens to be an expression statement...
if (isNewModule && statement.IsExpression)
{
// see if it's a constant wrapper
var constantWrapper = statement as ConstantWrapper;
if (constantWrapper != null && constantWrapper.PrimitiveType == PrimitiveType.String)
{
// we found a string constant expression statement right after the start of a new
// module. Let's make it a DirectivePrologue if it isn't already
if (!(statement is DirectivePrologue))
{
statement = new DirectivePrologue(constantWrapper.Value.ToString(), constantWrapper.Context, this)
{
MayHaveIssues = constantWrapper.MayHaveIssues
};
}
}
}
var binaryOp = statement as BinaryOperator;
if (binaryOp != null
&& (binaryOp.OperatorToken == JSToken.Equal || binaryOp.OperatorToken == JSToken.StrictEqual))
{
// an expression statement with equality operator? Doesn't really do anything.
// Did the developer intend this to be an assignment operator instead? Low-pri warning.
binaryOp.OperatorContext.IfNotNull(c => c.HandleError(JSError.SuspectEquality, false));
}
var lookup = statement as Lookup;
if (lookup != null
&& lookup.Name.StartsWith("<%=", StringComparison.Ordinal) && lookup.Name.EndsWith("%>", StringComparison.Ordinal))
{
// single lookup, but it's actually one or more ASP.NET blocks.
// convert back to an asp.net block node
statement = new AspNetBlockNode(statement.Context, this)
{
AspNetBlockText = lookup.Name
};
}
var aspNetBlock = statement as AspNetBlockNode;
if (aspNetBlock != null && JSToken.Semicolon == m_currentToken.Token)
{
aspNetBlock.IsTerminatedByExplicitSemicolon = true;
statement.IfNotNull(s => s.TerminatingContext = m_currentToken.Clone());
GetNextToken();
}
// we just parsed an expression statement. Now see if we have an appropriate
// semicolon to terminate it.
if (JSToken.Semicolon == m_currentToken.Token)
{
statement.IfNotNull(s => s.TerminatingContext = m_currentToken.Clone());
GetNextToken();
}
else if (m_foundEndOfLine || JSToken.RightCurly == m_currentToken.Token || JSToken.EndOfFile == m_currentToken.Token)
{
// semicolon insertion rules
// (if there was no statement parsed, then don't fire a warning)
// a right-curly or an end of line is something we don't WANT to throw a warning for.
// Just too common and doesn't really warrant a warning (in my opinion)
if (statement != null
&& JSToken.RightCurly != m_currentToken.Token && JSToken.EndOfFile != m_currentToken.Token)
{
ReportError(JSError.SemicolonInsertion, statement.Context.IfNotNull(c => c.FlattenToEnd()), true);
}
}
else
{
ReportError(JSError.NoSemicolon, true);
}
}
catch (RecoveryTokenException exc)
{
if (exc._partiallyComputedNode != null)
statement = exc._partiallyComputedNode;
if (statement == null)
{
m_noSkipTokenSet.Remove(NoSkipTokenSet.s_EndOfStatementNoSkipTokenSet);
exprError = true;
SkipTokensAndThrow();
}
if (IndexOfToken(NoSkipTokenSet.s_EndOfStatementNoSkipTokenSet, exc) == -1)
{
exc._partiallyComputedNode = statement;
throw;
}
}
finally
{
if (!exprError)
m_noSkipTokenSet.Remove(NoSkipTokenSet.s_EndOfStatementNoSkipTokenSet);
}
break;
}
}
return statement;
}
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 void Visit(AspNetBlockNode node)
{
// not applicable; terminate
}
public void Visit(AspNetBlockNode node)
{
// nothing to do
}