public void Visit(ConditionalCompilationOn node)
{
if (node != null)
{
DoesRequire = false;
}
}
public void Visit(ConditionalCompilationOn node)
{
// starts with a '@cc_on', so we don't care
}
public void Visit(ConditionalCompilationOn node)
{
// preprocessor nodes are handled outside the real JavaScript parsing
}
//---------------------------------------------------------------------------------------
// ParseStatement
//
// OptionalStatement:
// Statement |
// <empty>
//
// Statement :
// Block |
// VariableStatement |
// EmptyStatement |
// ExpressionStatement |
// IfStatement |
// IterationStatement |
// ContinueStatement |
// BreakStatement |
// ReturnStatement |
// WithStatement |
// LabeledStatement |
// SwitchStatement |
// ThrowStatement |
// TryStatement |
// FunctionDeclaration
//
// IterationStatement :
// 'for' '(' ForLoopControl ')' | ===> ForStatement
// 'do' Statement 'while' '(' Expression ')' | ===> DoStatement
// 'while' '(' Expression ')' Statement ===> WhileStatement
//
//---------------------------------------------------------------------------------------
// ParseStatement deals with the end of statement issue (EOL vs ';') so if any of the
// ParseXXX routine does it as well, it should return directly from the switch statement
// without any further execution in the ParseStatement
private AstNode ParseStatement(bool fSourceElement)
{
AstNode statement = null;
if (m_scanner.HasImportantComments
&& 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_scanner.PopImportantComment(), this);
}
else
{
String id = null;
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 Block(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:
return ParseVariableStatement((FieldAttributes)0);
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());
// now, if we aren't parsing source elements (directly in global scope or function body)
// then we want to throw a warning that different browsers will treat this function declaration
// differently. Technically, this location is not allowed. IE and most other browsers will
// simply treat it like every other function declaration in this scope. Firefox, however, won't
// add this function declaration's name to the containing scope until the function declaration
// is actually "executed." So if you try to call it BEFORE, you will get a "not defined" error.
if (!fSourceElement)
{
ReportError(JSError.MisplacedFunctionDeclaration, function.IdContext, true);
}
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;
}
case JSToken.AspNetBlock:
return ParseAspNetBlock(consumeSemicolonIfPossible: true);
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 && m_scanner.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
{
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,
id,
labelNestCount,
ParseStatement(fSourceElement)
);
}
else
{
// end of the file!
//just pass null for the labeled statement
statement = new LabeledStatement(
statement.Context.Clone(),
this,
id,
labelNestCount,
null
);
}
m_labelTable.Remove(id);
return statement;
}
}
statement = ParseExpression(statement, false, bAssign, JSToken.None);
}
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;
}
if (JSToken.Semicolon == m_currentToken.Token)
{
statement.Context.UpdateWith(m_currentToken);
GetNextToken();
}
else if (!m_scanner.GotEndOfLine && JSToken.RightCurly != m_currentToken.Token && JSToken.EndOfFile != m_currentToken.Token)
{
ReportError(JSError.NoSemicolon, true);
}
}
return statement;
}
public override void Visit(ConditionalCompilationOn node)
{
// well, we've encountered a cc_on statement now
m_encounteredCCOn = true;
}
public void Visit(ConditionalCompilationOn node)
{
ReportError(node);
}
public void Visit(ConditionalCompilationOn node)
{
// invalid! ignore
IsValid = false;
}