#include "config.h"

#include "Parser.h"

#include "ASTBuilder.h"

#include "CodeBlock.h"

#include "Debugger.h"

#include "JSGlobalData.h"

#include "Lexer.h"

#include "NodeInfo.h"

#include "SourceProvider.h"

#include <utility>

#include <wtf/HashFunctions.h>

#include <wtf/OwnPtr.h>

#include <wtf/WTFThreadData.h>

using namespace std;

namespace JSC {

template <typename LexerType>

Parser<LexerType>::Parser(JSGlobalData* globalData, const SourceCode& source, FunctionParameters* parameters, JSParserStrictness strictness, JSParserMode parserMode)

: m_globalData(globalData)

, m_source(&source)

, m_stack(wtfThreadData().stack())

, m_error(false)

, m_errorMessage("Parse error")

, m_allowsIn(true)

, m_lastLine(0)

, m_lastTokenEnd(0)

, m_assignmentCount(0)

, m_nonLHSCount(0)

, m_syntaxAlreadyValidated(source.provider()->isValid())

, m_statementDepth(0)

, m_nonTrivialExpressionCount(0)

, m_lastIdentifier(0)

, m_sourceElements(0)

{

m_lexer = adoptPtr(new LexerType(globalData));

m_arena = m_globalData->parserArena.get();

m_lexer->setCode(source, m_arena);

m_functionCache = source.provider()->cache();

ScopeRef scope = pushScope();

if (parserMode == JSParseFunctionCode)

scope->setIsFunction();

if (strictness == JSParseStrict)

scope->setStrictMode();

if (parameters) {

for (unsigned i = 0; i < parameters->size(); i++)

scope->declareParameter(&parameters->at(i));

}

next();

m_lexer->setLastLineNumber(tokenLine());

}

template <typename LexerType>

Parser<LexerType>::~Parser()

{

}

template <typename LexerType>

UString Parser<LexerType>::parseInner()

{

UString parseError = UString();

unsigned oldFunctionCacheSize = m_functionCache ? m_functionCache->byteSize() : 0;

ASTBuilder context(const_cast<JSGlobalData*>(m_globalData), const_cast<SourceCode*>(m_source));

if (m_lexer->isReparsing())

m_statementDepth--;

ScopeRef scope = currentScope();

SourceElements* sourceElements = parseSourceElements<CheckForStrictMode>(context);

if (!sourceElements || !consume(EOFTOK))

parseError = m_errorMessage;

IdentifierSet capturedVariables;

scope->getCapturedVariables(capturedVariables);

CodeFeatures features = context.features();

if (scope->strictMode())

features |= StrictModeFeature;

if (scope->shadowsArguments())

features |= ShadowsArgumentsFeature;

unsigned functionCacheSize = m_functionCache ? m_functionCache->byteSize() : 0;

if (functionCacheSize != oldFunctionCacheSize)

m_lexer->sourceProvider()->notifyCacheSizeChanged(functionCacheSize - oldFunctionCacheSize);

didFinishParsing(sourceElements, context.varDeclarations(), context.funcDeclarations(), features,

m_lastLine, context.numConstants(), capturedVariables);

return parseError;

}

template <typename LexerType>

void Parser<LexerType>::didFinishParsing(SourceElements* sourceElements, ParserArenaData<DeclarationStacks::VarStack>* varStack,

ParserArenaData<DeclarationStacks::FunctionStack>* funcStack, CodeFeatures features, int lastLine, int numConstants, IdentifierSet& capturedVars)

{

m_sourceElements = sourceElements;

m_varDeclarations = varStack;

m_funcDeclarations = funcStack;

m_capturedVariables.swap(capturedVars);

m_features = features;

m_lastLine = lastLine;

m_numConstants = numConstants;

}

template <typename LexerType>

bool Parser<LexerType>::allowAutomaticSemicolon()

{

return match(CLOSEBRACE) || match(EOFTOK) || m_lexer->prevTerminator();

}

template <typename LexerType>

template <SourceElementsMode mode, class TreeBuilder> TreeSourceElements Parser<LexerType>::parseSourceElements(TreeBuilder& context)

{

const unsigned lengthOfUseStrictLiteral = 12; // "use strict".length

TreeSourceElements sourceElements = context.createSourceElements();

bool seenNonDirective = false;

const Identifier* directive = 0;

unsigned directiveLiteralLength = 0;

unsigned startOffset = m_token.m_info.startOffset;

unsigned oldLastLineNumber = m_lexer->lastLineNumber();

unsigned oldLineNumber = m_lexer->lineNumber();

bool hasSetStrict = false;

while (TreeStatement statement = parseStatement(context, directive, &directiveLiteralLength)) {

if (mode == CheckForStrictMode && !seenNonDirective) {

if (directive) {

// "use strict" must be the exact literal without escape sequences or line continuation.

if (!hasSetStrict && directiveLiteralLength == lengthOfUseStrictLiteral && m_globalData->propertyNames->useStrictIdentifier == *directive) {

setStrictMode();

hasSetStrict = true;

failIfFalse(isValidStrictMode());

m_lexer->setOffset(startOffset);

next();

m_lexer->setLastLineNumber(oldLastLineNumber);

m_lexer->setLineNumber(oldLineNumber);

failIfTrue(m_error);

continue;

}

} else

seenNonDirective = true;

}

context.appendStatement(sourceElements, statement);

}

if (m_error)

fail();

return sourceElements;

}

template <typename LexerType>

template <class TreeBuilder> TreeStatement Parser<LexerType>::parseVarDeclaration(TreeBuilder& context)

{

ASSERT(match(VAR));

int start = tokenLine();

int end = 0;

int scratch;

const Identifier* scratch1 = 0;

TreeExpression scratch2 = 0;

int scratch3 = 0;

TreeExpression varDecls = parseVarDeclarationList(context, scratch, scratch1, scratch2, scratch3, scratch3, scratch3);

failIfTrue(m_error);

failIfFalse(autoSemiColon());

return context.createVarStatement(m_lexer->lastLineNumber(), varDecls, start, end);

}

template <typename LexerType>

template <class TreeBuilder> TreeStatement Parser<LexerType>::parseConstDeclaration(TreeBuilder& context)

{

ASSERT(match(CONSTTOKEN));

int start = tokenLine();

int end = 0;

TreeConstDeclList constDecls = parseConstDeclarationList(context);

failIfTrue(m_error);

failIfFalse(autoSemiColon());

return context.createConstStatement(m_lexer->lastLineNumber(), constDecls, start, end);

}

template <typename LexerType>

template <class TreeBuilder> TreeStatement Parser<LexerType>::parseDoWhileStatement(TreeBuilder& context)

{

ASSERT(match(DO));

int startLine = tokenLine();

next();

const Identifier* unused = 0;

startLoop();

TreeStatement statement = parseStatement(context, unused);

endLoop();

failIfFalse(statement);

int endLine = tokenLine();

consumeOrFail(WHILE);

consumeOrFail(OPENPAREN);

TreeExpression expr = parseExpression(context);

failIfFalse(expr);

consumeOrFail(CLOSEPAREN);

if (match(SEMICOLON))

next(); // Always performs automatic semicolon insertion.

return context.createDoWhileStatement(m_lexer->lastLineNumber(), statement, expr, startLine, endLine);

}

template <typename LexerType>

template <class TreeBuilder> TreeStatement Parser<LexerType>::parseWhileStatement(TreeBuilder& context)

{

ASSERT(match(WHILE));

int startLine = tokenLine();

next();

consumeOrFail(OPENPAREN);

TreeExpression expr = parseExpression(context);

failIfFalse(expr);

int endLine = tokenLine();

consumeOrFail(CLOSEPAREN);

const Identifier* unused = 0;

startLoop();

TreeStatement statement = parseStatement(context, unused);

endLoop();

failIfFalse(statement);

return context.createWhileStatement(m_lexer->lastLineNumber(), expr, statement, startLine, endLine);

}

template <typename LexerType>

template <class TreeBuilder> TreeExpression Parser<LexerType>::parseVarDeclarationList(TreeBuilder& context, int& declarations, const Identifier*& lastIdent, TreeExpression& lastInitializer, int& identStart, int& initStart, int& initEnd)

{

TreeExpression varDecls = 0;

do {

declarations++;

next();

matchOrFail(IDENT);

int varStart = tokenStart();

identStart = varStart;

const Identifier* name = m_token.m_data.ident;

lastIdent = name;

next();

bool hasInitializer = match(EQUAL);

failIfFalseIfStrictWithNameAndMessage(declareVariable(name), "Cannot declare a variable named", name->impl(), "in strict mode.");

context.addVar(name, (hasInitializer || (!m_allowsIn && match(INTOKEN))) ? DeclarationStacks::HasInitializer : 0);

if (hasInitializer) {

int varDivot = tokenStart() + 1;

initStart = tokenStart();

next(TreeBuilder::DontBuildStrings); // consume '='

int initialAssignments = m_assignmentCount;

TreeExpression initializer = parseAssignmentExpression(context);

initEnd = lastTokenEnd();

lastInitializer = initializer;

failIfFalse(initializer);

TreeExpression node = context.createAssignResolve(m_lexer->lastLineNumber(), *name, initializer, initialAssignments != m_assignmentCount, varStart, varDivot, lastTokenEnd());

if (!varDecls)

varDecls = node;

else

varDecls = context.combineCommaNodes(m_lexer->lastLineNumber(), varDecls, node);

}

} while (match(COMMA));

return varDecls;

}

template <typename LexerType>

template <class TreeBuilder> TreeConstDeclList Parser<LexerType>::parseConstDeclarationList(TreeBuilder& context)

{

failIfTrue(strictMode());

TreeConstDeclList constDecls = 0;

TreeConstDeclList tail = 0;

do {

next();

matchOrFail(IDENT);

const Identifier* name = m_token.m_data.ident;

next();

bool hasInitializer = match(EQUAL);

declareVariable(name);

context.addVar(name, DeclarationStacks::IsConstant | (hasInitializer ? DeclarationStacks::HasInitializer : 0));

TreeExpression initializer = 0;

if (hasInitializer) {

next(TreeBuilder::DontBuildStrings); // consume '='

initializer = parseAssignmentExpression(context);

}

tail = context.appendConstDecl(m_lexer->lastLineNumber(), tail, name, initializer);

if (!constDecls)

constDecls = tail;

} while (match(COMMA));

return constDecls;

}

template <typename LexerType>

template <class TreeBuilder> TreeStatement Parser<LexerType>::parseForStatement(TreeBuilder& context)

{

ASSERT(match(FOR));

int startLine = tokenLine();

next();

consumeOrFail(OPENPAREN);

int nonLHSCount = m_nonLHSCount;

int declarations = 0;

int declsStart = 0;

int declsEnd = 0;

TreeExpression decls = 0;

bool hasDeclaration = false;

if (match(VAR)) {

/*

hasDeclaration = true;

const Identifier* forInTarget = 0;

TreeExpression forInInitializer = 0;

m_allowsIn = false;

int initStart = 0;

int initEnd = 0;

decls = parseVarDeclarationList(context, declarations, forInTarget, forInInitializer, declsStart, initStart, initEnd);

m_allowsIn = true;

if (m_error)

fail();

// Remainder of a standard for loop is handled identically

if (match(SEMICOLON))

goto standardForLoop;

failIfFalse(declarations == 1);

// Handle for-in with var declaration

int inLocation = tokenStart();

consumeOrFail(INTOKEN);

TreeExpression expr = parseExpression(context);

failIfFalse(expr);

int exprEnd = lastTokenEnd();

int endLine = tokenLine();

consumeOrFail(CLOSEPAREN);

const Identifier* unused = 0;

startLoop();

TreeStatement statement = parseStatement(context, unused);

endLoop();

failIfFalse(statement);

return context.createForInLoop(m_lexer->lastLineNumber(), forInTarget, forInInitializer, expr, statement, declsStart, inLocation, exprEnd, initStart, initEnd, startLine, endLine);

}

if (!match(SEMICOLON)) {

m_allowsIn = false;

declsStart = tokenStart();

decls = parseExpression(context);

declsEnd = lastTokenEnd();

m_allowsIn = true;

failIfFalse(decls);

}

if (match(SEMICOLON)) {

standardForLoop:

// Standard for loop

next();

TreeExpression condition = 0;

if (!match(SEMICOLON)) {

condition = parseExpression(context);

failIfFalse(condition);

}

consumeOrFail(SEMICOLON);

TreeExpression increment = 0;

if (!match(CLOSEPAREN)) {

increment = parseExpression(context);

failIfFalse(increment);

}

int endLine = tokenLine();

consumeOrFail(CLOSEPAREN);

const Identifier* unused = 0;

startLoop();

TreeStatement statement = parseStatement(context, unused);

endLoop();

failIfFalse(statement);

return context.createForLoop(m_lexer->lastLineNumber(), decls, condition, increment, statement, hasDeclaration, startLine, endLine);

}

// For-in loop

failIfFalse(nonLHSCount == m_nonLHSCount);

consumeOrFail(INTOKEN);

TreeExpression expr = parseExpression(context);

failIfFalse(expr);

int exprEnd = lastTokenEnd();

int endLine = tokenLine();

consumeOrFail(CLOSEPAREN);

const Identifier* unused = 0;

startLoop();

TreeStatement statement = parseStatement(context, unused);

endLoop();

failIfFalse(statement);

return context.createForInLoop(m_lexer->lastLineNumber(), decls, expr, statement, declsStart, declsEnd, exprEnd, startLine, endLine);

}

template <typename LexerType>

template <class TreeBuilder> TreeStatement Parser<LexerType>::parseBreakStatement(TreeBuilder& context)

{

ASSERT(match(BREAK));

int startCol = tokenStart();

int endCol = tokenEnd();

int startLine = tokenLine();

int endLine = tokenLine();

next();

if (autoSemiColon()) {

failIfFalseWithMessage(breakIsValid(), "'break' is only valid inside a switch or loop statement");

return context.createBreakStatement(m_lexer->lastLineNumber(), startCol, endCol, startLine, endLine);

}

matchOrFail(IDENT);

const Identifier* ident = m_token.m_data.ident;

failIfFalseWithNameAndMessage(getLabel(ident), "Label", ident->impl(), "is not defined");

endCol = tokenEnd();

endLine = tokenLine();

next();

failIfFalse(autoSemiColon());

return context.createBreakStatement(m_lexer->lastLineNumber(), ident, startCol, endCol, startLine, endLine);

}

template <typename LexerType>

template <class TreeBuilder> TreeStatement Parser<LexerType>::parseContinueStatement(TreeBuilder& context)

{

ASSERT(match(CONTINUE));

int startCol = tokenStart();

int endCol = tokenEnd();

int startLine = tokenLine();

int endLine = tokenLine();

next();

if (autoSemiColon()) {

failIfFalseWithMessage(continueIsValid(), "'continue' is only valid inside a loop statement");

return context.createContinueStatement(m_lexer->lastLineNumber(), startCol, endCol, startLine, endLine);

}

matchOrFail(IDENT);

const Identifier* ident = m_token.m_data.ident;

ScopeLabelInfo* label = getLabel(ident);

failIfFalseWithNameAndMessage(label, "Label", ident->impl(), "is not defined");

failIfFalseWithMessage(label->m_isLoop, "'continue' is only valid inside a loop statement");

endCol = tokenEnd();

endLine = tokenLine();

next();

failIfFalse(autoSemiColon());

return context.createContinueStatement(m_lexer->lastLineNumber(), ident, startCol, endCol, startLine, endLine);

}

template <typename LexerType>

template <class TreeBuilder> TreeStatement Parser<LexerType>::parseReturnStatement(TreeBuilder& context)

{

ASSERT(match(RETURN));

failIfFalse(currentScope()->isFunction());

int startLine = tokenLine();

int endLine = startLine;

int start = tokenStart();

int end = tokenEnd();

next();

// We do the auto semicolon check before attempting to parse an expression

// as we need to ensure the a line break after the return correctly terminates

// the statement

if (match(SEMICOLON))

endLine = tokenLine();

if (autoSemiColon())

return context.createReturnStatement(m_lexer->lastLineNumber(), 0, start, end, startLine, endLine);

TreeExpression expr = parseExpression(context);

failIfFalse(expr);

end = lastTokenEnd();

if (match(SEMICOLON))

endLine = tokenLine();

failIfFalse(autoSemiColon());

return context.createReturnStatement(m_lexer->lastLineNumber(), expr, start, end, startLine, endLine);

}

template <typename LexerType>

template <class TreeBuilder> TreeStatement Parser<LexerType>::parseThrowStatement(TreeBuilder& context)

{

ASSERT(match(THROW));

int eStart = tokenStart();

int startLine = tokenLine();

next();

failIfTrue(autoSemiColon());

TreeExpression expr = parseExpression(context);

failIfFalse(expr);

int eEnd = lastTokenEnd();

int endLine = tokenLine();

failIfFalse(autoSemiColon());

return context.createThrowStatement(m_lexer->lastLineNumber(), expr, eStart, eEnd, startLine, endLine);

}

template <typename LexerType>

template <class TreeBuilder> TreeStatement Parser<LexerType>::parseWithStatement(TreeBuilder& context)

{

ASSERT(match(WITH));

failIfTrueWithMessage(strictMode(), "'with' statements are not valid in strict mode");

currentScope()->setNeedsFullActivation();

int startLine = tokenLine();

next();

consumeOrFail(OPENPAREN);

int start = tokenStart();

TreeExpression expr = parseExpression(context);

failIfFalse(expr);

int end = lastTokenEnd();

int endLine = tokenLine();

consumeOrFail(CLOSEPAREN);

const Identifier* unused = 0;

TreeStatement statement = parseStatement(context, unused);

failIfFalse(statement);

return context.createWithStatement(m_lexer->lastLineNumber(), expr, statement, start, end, startLine, endLine);

}

template <typename LexerType>

template <class TreeBuilder> TreeStatement Parser<LexerType>::parseSwitchStatement(TreeBuilder& context)

{

ASSERT(match(SWITCH));

int startLine = tokenLine();

next();

consumeOrFail(OPENPAREN);

TreeExpression expr = parseExpression(context);

failIfFalse(expr);

int endLine = tokenLine();

consumeOrFail(CLOSEPAREN);

consumeOrFail(OPENBRACE);

startSwitch();

TreeClauseList firstClauses = parseSwitchClauses(context);

failIfTrue(m_error);

TreeClause defaultClause = parseSwitchDefaultClause(context);

failIfTrue(m_error);

TreeClauseList secondClauses = parseSwitchClauses(context);

failIfTrue(m_error);

endSwitch();

consumeOrFail(CLOSEBRACE);

return context.createSwitchStatement(m_lexer->lastLineNumber(), expr, firstClauses, defaultClause, secondClauses, startLine, endLine);

}

template <typename LexerType>

template <class TreeBuilder> TreeClauseList Parser<LexerType>::parseSwitchClauses(TreeBuilder& context)

{

if (!match(CASE))

return 0;

next();

TreeExpression condition = parseExpression(context);

failIfFalse(condition);

consumeOrFail(COLON);

TreeSourceElements statements = parseSourceElements<DontCheckForStrictMode>(context);

failIfFalse(statements);

TreeClause clause = context.createClause(condition, statements);

TreeClauseList clauseList = context.createClauseList(clause);

TreeClauseList tail = clauseList;

while (match(CASE)) {

next();

TreeExpression condition = parseExpression(context);

failIfFalse(condition);

consumeOrFail(COLON);

TreeSourceElements statements = parseSourceElements<DontCheckForStrictMode>(context);

failIfFalse(statements);

clause = context.createClause(condition, statements);

tail = context.createClauseList(tail, clause);

}

return clauseList;

}

template <typename LexerType>

template <class TreeBuilder> TreeClause Parser<LexerType>::parseSwitchDefaultClause(TreeBuilder& context)

{

if (!match(DEFAULT))

return 0;

next();

consumeOrFail(COLON);

TreeSourceElements statements = parseSourceElements<DontCheckForStrictMode>(context);

failIfFalse(statements);

return context.createClause(0, statements);

}

template <typename LexerType>

template <class TreeBuilder> TreeStatement Parser<LexerType>::parseTryStatement(TreeBuilder& context)

{

ASSERT(match(TRY));

TreeStatement tryBlock = 0;

const Identifier* ident = &m_globalData->propertyNames->nullIdentifier;

TreeStatement catchBlock = 0;

TreeStatement finallyBlock = 0;

int firstLine = tokenLine();

next();

matchOrFail(OPENBRACE);

tryBlock = parseBlockStatement(context);

failIfFalse(tryBlock);

int lastLine = m_lastLine;

if (match(CATCH)) {

currentScope()->setNeedsFullActivation();

next();

consumeOrFail(OPENPAREN);

matchOrFail(IDENT);

ident = m_token.m_data.ident;

next();

AutoPopScopeRef catchScope(this, pushScope());

failIfFalseIfStrictWithNameAndMessage(declareVariable(ident), "Cannot declare a variable named", ident->impl(), "in strict mode");

catchScope->preventNewDecls();

consumeOrFail(CLOSEPAREN);

matchOrFail(OPENBRACE);

catchBlock = parseBlockStatement(context);

failIfFalseWithMessage(catchBlock, "'try' must have a catch or finally block");

failIfFalse(popScope(catchScope, TreeBuilder::NeedsFreeVariableInfo));

}

if (match(FINALLY)) {

next();

matchOrFail(OPENBRACE);

finallyBlock = parseBlockStatement(context);

failIfFalse(finallyBlock);

}

failIfFalse(catchBlock || finallyBlock);

return context.createTryStatement(m_lexer->lastLineNumber(), tryBlock, ident, catchBlock, finallyBlock, firstLine, lastLine);

}

template <typename LexerType>

template <class TreeBuilder> TreeStatement Parser<LexerType>::parseDebuggerStatement(TreeBuilder& context)

{

ASSERT(match(DEBUGGER));

int startLine = tokenLine();

int endLine = startLine;

next();

if (match(SEMICOLON))

startLine = tokenLine();

failIfFalse(autoSemiColon());

return context.createDebugger(m_lexer->lastLineNumber(), startLine, endLine);

}

template <typename LexerType>

template <class TreeBuilder> TreeStatement Parser<LexerType>::parseBlockStatement(TreeBuilder& context)

{

ASSERT(match(OPENBRACE));

int start = tokenLine();

next();

if (match(CLOSEBRACE)) {

next();

return context.createBlockStatement(m_lexer->lastLineNumber(), 0, start, m_lastLine);

}

TreeSourceElements subtree = parseSourceElements<DontCheckForStrictMode>(context);

failIfFalse(subtree);

matchOrFail(CLOSEBRACE);

next();

return context.createBlockStatement(m_lexer->lastLineNumber(), subtree, start, m_lastLine);

}

template <typename LexerType>

template <class TreeBuilder> TreeStatement Parser<LexerType>::parseStatement(TreeBuilder& context, const Identifier*& directive, unsigned* directiveLiteralLength)

{

DepthManager statementDepth(&m_statementDepth);

m_statementDepth++;

directive = 0;

int nonTrivialExpressionCount = 0;

failIfStackOverflow();

switch (m_token.m_type) {

case OPENBRACE:

return parseBlockStatement(context);

case VAR:

return parseVarDeclaration(context);

case CONSTTOKEN:

return parseConstDeclaration(context);

case FUNCTION:

failIfFalseIfStrictWithMessage(m_statementDepth == 1, "Functions cannot be declared in a nested block in strict mode");

return parseFunctionDeclaration(context);

case SEMICOLON:

next();

return context.createEmptyStatement(m_lexer->lastLineNumber());

case IF:

return parseIfStatement(context);

case DO:

return parseDoWhileStatement(context);

case WHILE:

return parseWhileStatement(context);

case FOR:

return parseForStatement(context);

case CONTINUE:

return parseContinueStatement(context);

case BREAK:

return parseBreakStatement(context);

case RETURN:

return parseReturnStatement(context);

case WITH:

return parseWithStatement(context);

case SWITCH:

return parseSwitchStatement(context);

case THROW:

return parseThrowStatement(context);

case TRY:

return parseTryStatement(context);

case DEBUGGER:

return parseDebuggerStatement(context);

case EOFTOK:

case CASE:

case CLOSEBRACE:

case DEFAULT:

// These tokens imply the end of a set of source elements

return 0;

case IDENT:

return parseExpressionOrLabelStatement(context);

case STRING:

directive = m_token.m_data.ident;

if (directiveLiteralLength)

*directiveLiteralLength = m_token.m_info.endOffset - m_token.m_info.startOffset;

nonTrivialExpressionCount = m_nonTrivialExpressionCount;

default:

TreeStatement exprStatement = parseExpressionStatement(context);

if (directive && nonTrivialExpressionCount != m_nonTrivialExpressionCount)

directive = 0;

return exprStatement;

}

}

template <typename LexerType>

template <class TreeBuilder> TreeFormalParameterList Parser<LexerType>::parseFormalParameters(TreeBuilder& context)

{

matchOrFail(IDENT);

failIfFalseIfStrictWithNameAndMessage(declareParameter(m_token.m_data.ident), "Cannot declare a parameter named", m_token.m_data.ident->impl(), " in strict mode");

TreeFormalParameterList list = context.createFormalParameterList(*m_token.m_data.ident);

TreeFormalParameterList tail = list;

next();

while (match(COMMA)) {

next();

matchOrFail(IDENT);

const Identifier* ident = m_token.m_data.ident;

failIfFalseIfStrictWithNameAndMessage(declareParameter(ident), "Cannot declare a parameter named", ident->impl(), "in strict mode");

next();

tail = context.createFormalParameterList(tail, *ident);

}

return list;

}

template <typename LexerType>

template <class TreeBuilder> TreeFunctionBody Parser<LexerType>::parseFunctionBody(TreeBuilder& context)

{

if (match(CLOSEBRACE))

return context.createFunctionBody(m_lexer->lastLineNumber(), strictMode());

DepthManager statementDepth(&m_statementDepth);

m_statementDepth = 0;

typename TreeBuilder::FunctionBodyBuilder bodyBuilder(const_cast<JSGlobalData*>(m_globalData), m_lexer.get());

failIfFalse(parseSourceElements<CheckForStrictMode>(bodyBuilder));

return context.createFunctionBody(m_lexer->lastLineNumber(), strictMode());

}

template <typename LexerType>

template <FunctionRequirements requirements, bool nameIsInContainingScope, class TreeBuilder> bool Parser<LexerType>::parseFunctionInfo(TreeBuilder& context, const Identifier*& name, TreeFormalParameterList& parameters, TreeFunctionBody& body, int& openBracePos, int& closeBracePos, int& bodyStartLine)

{

AutoPopScopeRef functionScope(this, pushScope());

functionScope->setIsFunction();

if (match(IDENT)) {

name = m_token.m_data.ident;

next();

if (!nameIsInContainingScope)

failIfFalseIfStrict(functionScope->declareVariable(name));

} else if (requirements == FunctionNeedsName)

return false;

consumeOrFail(OPENPAREN);

if (!match(CLOSEPAREN)) {

parameters = parseFormalParameters(context);

failIfFalse(parameters);

}

consumeOrFail(CLOSEPAREN);

matchOrFail(OPENBRACE);

openBracePos = m_token.m_data.intValue;

bodyStartLine = tokenLine();

// If we know about this function already, we can use the cached info and skip the parser to the end of the function.

if (const SourceProviderCacheItem* cachedInfo = TreeBuilder::CanUseFunctionCache ? findCachedFunctionInfo(openBracePos) : 0) {

// If we're in a strict context, the cached function info must say it was strict too.

ASSERT(!strictMode() || cachedInfo->strictMode);

body = context.createFunctionBody(m_lexer->lastLineNumber(), cachedInfo->strictMode);

functionScope->restoreFunctionInfo(cachedInfo);

failIfFalse(popScope(functionScope, TreeBuilder::NeedsFreeVariableInfo));

closeBracePos = cachedInfo->closeBracePos;

m_token = cachedInfo->closeBraceToken();

m_lexer->setOffset(m_token.m_info.endOffset);

m_lexer->setLineNumber(m_token.m_info.line);

next();

return true;

}

next();

body = parseFunctionBody(context);

failIfFalse(body);

if (functionScope->strictMode() && name) {

failIfTrueWithNameAndMessage(m_globalData->propertyNames->arguments == *name, "Function name", name->impl(), "is not valid in strict mode");

failIfTrueWithNameAndMessage(m_globalData->propertyNames->eval == *name, "Function name", name->impl(), "is not valid in strict mode");

}

closeBracePos = m_token.m_data.intValue;

// Cache the tokenizer state and the function scope the first time the function is parsed.

// Any future reparsing can then skip the function.

static const int minimumFunctionLengthToCache = 64;

OwnPtr<SourceProviderCacheItem> newInfo;

int functionLength = closeBracePos - openBracePos;

if (TreeBuilder::CanUseFunctionCache && m_functionCache && functionLength > minimumFunctionLengthToCache) {

newInfo = adoptPtr(new SourceProviderCacheItem(m_token.m_info.line, closeBracePos));

functionScope->saveFunctionInfo(newInfo.get());

}

failIfFalse(popScope(functionScope, TreeBuilder::NeedsFreeVariableInfo));

matchOrFail(CLOSEBRACE);

if (newInfo) {

unsigned approximateByteSize = newInfo->approximateByteSize();

m_functionCache->add(openBracePos, newInfo.release(), approximateByteSize);

}

next();

return true;

}

template <typename LexerType>

template <class TreeBuilder> TreeStatement Parser<LexerType>::parseFunctionDeclaration(TreeBuilder& context)

{

ASSERT(match(FUNCTION));

next();

const Identifier* name = 0;

TreeFormalParameterList parameters = 0;

TreeFunctionBody body = 0;

int openBracePos = 0;

int closeBracePos = 0;

int bodyStartLine = 0;

failIfFalse((parseFunctionInfo<FunctionNeedsName, true>(context, name, parameters, body, openBracePos, closeBracePos, bodyStartLine)));

failIfFalse(name);

failIfFalseIfStrict(declareVariable(name));

return context.createFuncDeclStatement(m_lexer->lastLineNumber(), name, body, parameters, openBracePos, closeBracePos, bodyStartLine, m_lastLine);

}

struct LabelInfo {

};

template <typename LexerType>

template <class TreeBuilder> TreeStatement Parser<LexerType>::parseExpressionOrLabelStatement(TreeBuilder& context)

{

/* Expression and Label statements are ambiguous at LL(1), so we have a

Vector<LabelInfo> labels;

do {

int start = tokenStart();

int startLine = tokenLine();

if (!nextTokenIsColon()) {

// If we hit this path we're making a expression statement, which

// by definition can't make use of continue/break so we can just

// ignore any labels we might have accumulated.

TreeExpression expression = parseExpression(context);

failIfFalse(expression);

failIfFalse(autoSemiColon());

return context.createExprStatement(m_lexer->lastLineNumber(), expression, startLine, m_lastLine);

}

const Identifier* ident = m_token.m_data.ident;

int end = tokenEnd();

next();

consumeOrFail(COLON);

if (!m_syntaxAlreadyValidated) {

// This is O(N^2) over the current list of consecutive labels, but I

// have never seen more than one label in a row in the real world.

for (size_t i = 0; i < labels.size(); i++)

failIfTrue(ident->impl() == labels[i].m_ident->impl());

failIfTrue(getLabel(ident));

labels.append(LabelInfo(ident, start, end));

}

} while (match(IDENT));

bool isLoop = false;

switch (m_token.m_type) {

case FOR:

case WHILE:

case DO:

isLoop = true;

break;

default:

break;

}

const Identifier* unused = 0;

if (!m_syntaxAlreadyValidated) {

for (size_t i = 0; i < labels.size(); i++)

pushLabel(labels[i].m_ident, isLoop);

}

TreeStatement statement = parseStatement(context, unused);

if (!m_syntaxAlreadyValidated) {

for (size_t i = 0; i < labels.size(); i++)

popLabel();

}

failIfFalse(statement);

for (size_t i = 0; i < labels.size(); i++) {

const LabelInfo& info = labels[labels.size() - i - 1];

statement = context.createLabelStatement(m_lexer->lastLineNumber(), info.m_ident, statement, info.m_start, info.m_end);

}

return statement;

}

template <typename LexerType>

template <class TreeBuilder> TreeStatement Parser<LexerType>::parseExpressionStatement(TreeBuilder& context)

{

int startLine = tokenLine();

TreeExpression expression = parseExpression(context);

failIfFalse(expression);

failIfFalse(autoSemiColon());

return context.createExprStatement(m_lexer->lastLineNumber(), expression, startLine, m_lastLine);

}

template <typename LexerType>

template <class TreeBuilder> TreeStatement Parser<LexerType>::parseIfStatement(TreeBuilder& context)

{

ASSERT(match(IF));

int start = tokenLine();

next();

consumeOrFail(OPENPAREN);

TreeExpression condition = parseExpression(context);

failIfFalse(condition);

int end = tokenLine();

consumeOrFail(CLOSEPAREN);

const Identifier* unused = 0;

TreeStatement trueBlock = parseStatement(context, unused);

failIfFalse(trueBlock);

if (!match(ELSE))

return context.createIfStatement(m_lexer->lastLineNumber(), condition, trueBlock, start, end);

Vector<TreeExpression> exprStack;

Vector<pair<int, int> > posStack;

Vector<TreeStatement> statementStack;

bool trailingElse = false;

do {

next();

if (!match(IF)) {

const Identifier* unused = 0;

TreeStatement block = parseStatement(context, unused);

failIfFalse(block);

statementStack.append(block);

trailingElse = true;

break;

}

int innerStart = tokenLine();

next();

consumeOrFail(OPENPAREN);

TreeExpression innerCondition = parseExpression(context);

failIfFalse(innerCondition);

int innerEnd = tokenLine();

consumeOrFail(CLOSEPAREN);

const Identifier* unused = 0;

TreeStatement innerTrueBlock = parseStatement(context, unused);

failIfFalse(innerTrueBlock);

exprStack.append(innerCondition);

posStack.append(make_pair(innerStart, innerEnd));

statementStack.append(innerTrueBlock);

} while (match(ELSE));

if (!trailingElse) {

TreeExpression condition = exprStack.last();