#include "config.h"

#include "Parser.h"

#include "ASTBuilder.h"

#include "CodeBlock.h"

#include "Debugger.h"

#include "JSCJSValueInlines.h"

#include "Lexer.h"

#include "NodeInfo.h"

#include "SourceProvider.h"

#include "VM.h"

#include <utility>

#include <wtf/HashFunctions.h>

#include <wtf/OwnPtr.h>

#include <wtf/StringPrintStream.h>

#include <wtf/WTFThreadData.h>

#define updateErrorMessage(shouldPrintToken, ...) do {\

ASSERT(!hasError());\

StringPrintStream stream;\

if (shouldPrintToken) {\

printUnexpectedTokenText(stream); \

stream.print(". "); \

}\

stream.print(__VA_ARGS__);\

stream.print(".");\

setErrorMessage(stream.toString());\

} while (0)

#define propagateError() do { if (hasError()) return 0; } while (0)

#define internalFailWithMessage(shouldPrintToken, ...) do { if (!hasError()) updateErrorMessage(shouldPrintToken, __VA_ARGS__); return 0; } while (0)

#define handleErrorToken() do { if (m_token.m_type == EOFTOK || m_token.m_type & ErrorTokenFlag) { failDueToUnexpectedToken(); } } while (0)

#define failWithMessage(...) do { if (!hasError()) { handleErrorToken(); updateErrorMessage(true, __VA_ARGS__); } return 0; } while (0)

#define failWithStackOverflow() do { updateErrorMessage(false, "Stack exhausted"); m_hasStackOverflow = true; return 0; } while (0)

#define failIfFalse(cond, ...) do { if (!(cond)) { handleErrorToken(); internalFailWithMessage(true, __VA_ARGS__); } } while (0)

#define failIfTrue(cond, ...) do { if ((cond)) { handleErrorToken(); internalFailWithMessage(true, __VA_ARGS__); } } while (0)

#define failIfTrueIfStrict(cond, ...) do { if ((cond) && strictMode()) internalFailWithMessage(false, __VA_ARGS__); } while (0)

#define failIfFalseIfStrict(cond, ...) do { if ((!(cond)) && strictMode()) internalFailWithMessage(false, __VA_ARGS__); } while (0)

#define consumeOrFail(tokenType, ...) do { if (!consume(tokenType)) { handleErrorToken(); internalFailWithMessage(true, __VA_ARGS__); } } while (0)

#define consumeOrFailWithFlags(tokenType, flags, ...) do { if (!consume(tokenType, flags)) { handleErrorToken(); internalFailWithMessage(true, __VA_ARGS__); } } while (0)

#define matchOrFail(tokenType, ...) do { if (!match(tokenType)) { handleErrorToken(); internalFailWithMessage(true, __VA_ARGS__); } } while (0)

#define failIfStackOverflow() do { if (!canRecurse()) failWithStackOverflow(); } while (0)

#define semanticFail(...) do { internalFailWithMessage(false, __VA_ARGS__); } while (0)

#define semanticFailIfTrue(cond, ...) do { if ((cond)) internalFailWithMessage(false, __VA_ARGS__); } while (0)

#define semanticFailIfFalse(cond, ...) do { if (!(cond)) internalFailWithMessage(false, __VA_ARGS__); } while (0)

#define regexFail(failure) do { if (!hasError()) setErrorMessage(failure); return 0; } while (0)

#define failDueToUnexpectedToken() do {\

if (!hasError()) {\

StringPrintStream stream;\

printUnexpectedTokenText(stream); \

setErrorMessage(stream.toString());\

}\

return 0;\

} while (0)

#define handleProductionOrFail(token, tokenString, operation, production) do {\

consumeOrFail(token, "Expected '", tokenString, "' to ", operation, " a ", production);\

} while (0)

#define semanticFailureDueToKeyword(...) do { \

if (strictMode() && m_token.m_type == RESERVED_IF_STRICT) \

semanticFail("Cannot use the reserved word '", getToken(), "' as a ", __VA_ARGS__, " in strict mode"); \

if (m_token.m_type == RESERVED || m_token.m_type == RESERVED_IF_STRICT) \

semanticFail("Cannot use the reserved word '", getToken(), "' as a ", __VA_ARGS__); \

if (m_token.m_type & KeywordTokenFlag) \

semanticFail("Cannot use the keyword '", getToken(), "' as a ", __VA_ARGS__); \

} while (0)

using namespace std;

namespace JSC {

template <typename LexerType>

Parser<LexerType>::Parser(VM* vm, const SourceCode& source, FunctionParameters* parameters, const Identifier& name, JSParserStrictness strictness, JSParserMode parserMode)

: m_vm(vm)

, m_source(&source)

, m_stack(*vm, wtfThreadData().stack())

, m_hasStackOverflow(false)

, m_allowsIn(true)

, m_assignmentCount(0)

, m_nonLHSCount(0)

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

, m_statementDepth(0)

, m_nonTrivialExpressionCount(0)

, m_lastIdentifier(0)

, m_lastFunctionName(nullptr)

, m_sourceElements(0)

{

m_lexer = adoptPtr(new LexerType(vm));

m_arena = m_vm->parserArena.get();

m_lexer->setCode(source, m_arena);

m_token.m_location.line = source.firstLine();

m_token.m_location.startOffset = source.startOffset();

m_token.m_location.endOffset = source.startOffset();

m_token.m_location.lineStartOffset = source.startOffset();

m_functionCache = vm->addSourceProviderCache(source.provider());

ScopeRef scope = pushScope();

if (parserMode == JSParseFunctionCode)

scope->setIsFunction();

if (strictness == JSParseStrict)

scope->setStrictMode();

if (parameters) {

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

auto parameter = parameters->at(i);

if (!parameter->isBindingNode())

continue;

scope->declareParameter(&static_cast<BindingNode*>(parameter)->boundProperty());

}

}

if (!name.isNull())

scope->declareCallee(&name);

next();

}

template <typename LexerType>

Parser<LexerType>::~Parser()

{

}

template <typename LexerType>

String Parser<LexerType>::parseInner()

{

String parseError = String();

ASTBuilder context(const_cast<VM*>(m_vm), const_cast<SourceCode*>(m_source));

if (m_lexer->isReparsing())

m_statementDepth--;

ScopeRef scope = currentScope();

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

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

if (hasError())

parseError = m_errorMessage;

else

parseError = ASCIILiteral("Parser error");

}

IdentifierSet capturedVariables;

bool modifiedParameter = false;

scope->getCapturedVariables(capturedVariables, modifiedParameter);

CodeFeatures features = context.features();

if (scope->strictMode())

features |= StrictModeFeature;

if (scope->shadowsArguments())

features |= ShadowsArgumentsFeature;

if (modifiedParameter)

features |= ModifiedParameterFeature;

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

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 numConstants, IdentifierSet& capturedVars)

{

m_sourceElements = sourceElements;

m_varDeclarations = varStack;

m_funcDeclarations = funcStack;

m_capturedVariables.swap(capturedVars);

m_features = features;

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;

auto savePoint = createSavePoint();

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_vm->propertyNames->useStrictIdentifier == *directive) {

setStrictMode();

hasSetStrict = true;

if (!isValidStrictMode()) {

if (m_lastFunctionName) {

if (m_vm->propertyNames->arguments == *m_lastFunctionName)

semanticFail("Cannot name a function 'arguments' in strict mode");

if (m_vm->propertyNames->eval == *m_lastFunctionName)

semanticFail("Cannot name a function 'eval' in strict mode");

}

if (hasDeclaredVariable(m_vm->propertyNames->arguments))

semanticFail("Cannot declare a variable named 'arguments' in strict mode");

if (hasDeclaredVariable(m_vm->propertyNames->eval))

semanticFail("Cannot declare a variable named 'eval' in strict mode");

semanticFailIfFalse(isValidStrictMode(), "Invalid parameters or function name in strict mode");

}

restoreSavePoint(savePoint);

propagateError();

continue;

}

} else

seenNonDirective = true;

}

context.appendStatement(sourceElements, statement);

}

propagateError();

return sourceElements;

}

template <typename LexerType>

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

{

ASSERT(match(VAR));

JSTokenLocation location(tokenLocation());

int start = tokenLine();

int end = 0;

int scratch;

TreeDeconstructionPattern scratch1 = 0;

TreeExpression scratch2 = 0;

JSTextPosition scratch3;

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

propagateError();

failIfFalse(autoSemiColon(), "Expected ';' after var declaration");

return context.createVarStatement(location, varDecls, start, end);

}

template <typename LexerType>

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

{

ASSERT(match(CONSTTOKEN));

JSTokenLocation location(tokenLocation());

int start = tokenLine();

int end = 0;

TreeConstDeclList constDecls = parseConstDeclarationList(context);

propagateError();

failIfFalse(autoSemiColon(), "Expected ';' after const declaration");

return context.createConstStatement(location, 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, "Expected a statement following 'do'");

int endLine = tokenLine();

JSTokenLocation location(tokenLocation());

handleProductionOrFail(WHILE, "while", "end", "do-while loop");

handleProductionOrFail(OPENPAREN, "(", "start", "do-while loop condition");

semanticFailIfTrue(match(CLOSEPAREN), "Must provide an expression as a do-while loop condition");

TreeExpression expr = parseExpression(context);

failIfFalse(expr, "Unable to parse do-while loop condition");

handleProductionOrFail(CLOSEPAREN, ")", "end", "do-while loop condition");

if (match(SEMICOLON))

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

return context.createDoWhileStatement(location, statement, expr, startLine, endLine);

}

template <typename LexerType>

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

{

ASSERT(match(WHILE));

JSTokenLocation location(tokenLocation());

int startLine = tokenLine();

next();

handleProductionOrFail(OPENPAREN, "(", "start", "while loop condition");

semanticFailIfTrue(match(CLOSEPAREN), "Must provide an expression as a while loop condition");

TreeExpression expr = parseExpression(context);

failIfFalse(expr, "Unable to parse while loop condition");

int endLine = tokenLine();

handleProductionOrFail(CLOSEPAREN, ")", "end", "while loop condition");

const Identifier* unused = 0;

startLoop();

TreeStatement statement = parseStatement(context, unused);

endLoop();

failIfFalse(statement, "Expected a statement as the body of a while loop");

return context.createWhileStatement(location, expr, statement, startLine, endLine);

}

template <typename LexerType>

template <class TreeBuilder> TreeExpression Parser<LexerType>::parseVarDeclarationList(TreeBuilder& context, int& declarations, TreeDeconstructionPattern& lastPattern, TreeExpression& lastInitializer, JSTextPosition& identStart, JSTextPosition& initStart, JSTextPosition& initEnd)

{

TreeExpression varDecls = 0;

const Identifier* lastIdent;

do {

lastIdent = 0;

lastPattern = 0;

JSTokenLocation location(tokenLocation());

next();

TreeExpression node = 0;

declarations++;

bool hasInitializer = false;

if (match(IDENT)) {

JSTextPosition varStart = tokenStartPosition();

identStart = varStart;

const Identifier* name = m_token.m_data.ident;

lastIdent = name;

next();

hasInitializer = match(EQUAL);

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

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

if (hasInitializer) {

JSTextPosition varDivot = tokenStartPosition() + 1;

initStart = tokenStartPosition();

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

TreeExpression initializer = parseAssignmentExpression(context);

initEnd = lastTokenEndPosition();

lastInitializer = initializer;

failIfFalse(initializer, "Expected expression as the intializer for the variable '", name->impl(), "'");

node = context.createAssignResolve(location, *name, initializer, varStart, varDivot, lastTokenEndPosition());

}

} else {

lastIdent = 0;

auto pattern = parseDeconstructionPattern<DeconstructToVariables>(context);

failIfFalse(pattern, "Cannot parse this deconstruction pattern");

hasInitializer = match(EQUAL);

lastPattern = pattern;

if (hasInitializer) {

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

TreeExpression rhs = parseExpression(context);

node = context.createDeconstructingAssignment(location, pattern, rhs);

}

}

if (hasInitializer) {

if (!varDecls)

varDecls = node;

else

varDecls = context.combineCommaNodes(location, varDecls, node);

}

} while (match(COMMA));

if (lastIdent)

lastPattern = createBindingPattern<DeconstructToVariables>(context, *lastIdent, 0);

return varDecls;

}

template <typename LexerType>

template <DeconstructionKind kind, class TreeBuilder> TreeDeconstructionPattern Parser<LexerType>::createBindingPattern(TreeBuilder& context, const Identifier& name, int depth)

{

ASSERT(!name.isEmpty());

ASSERT(!name.isNull());

ASSERT(name.impl()->isIdentifier());

if (depth) {

if (kind == DeconstructToVariables)

failIfFalseIfStrict(declareVariable(&name), "Cannot deconstruct to a variable named '", name.impl(), "' in strict mode");

if (kind == DeconstructToParameters) {

auto bindingResult = declareBoundParameter(&name);

if (bindingResult == Scope::StrictBindingFailed && strictMode()) {

semanticFailIfTrue(m_vm->propertyNames->arguments == name || m_vm->propertyNames->eval == name, "Cannot deconstruct to a parameter name '", name.impl(), "' in strict mode");

if (m_lastFunctionName && name == *m_lastFunctionName)

semanticFail("Cannot deconstruct to '", name.impl(), "' as it shadows the name of a strict mode function");

semanticFailureDueToKeyword("bound parameter name");

if (hasDeclaredParameter(name))

semanticFail("Cannot deconstruct to '", name.impl(), "' as it has already been declared");

semanticFail("Cannot bind to a parameter named '", name.impl(), "' in strict mode");

}

if (bindingResult == Scope::BindingFailed) {

semanticFailureDueToKeyword("bound parameter name");

if (hasDeclaredParameter(name))

semanticFail("Cannot deconstruct to '", name.impl(), "' as it has already been declared");

semanticFail("Cannot deconstruct to a parameter named '", name.impl(), "'");

}

}

context.addVar(&name, kind == DeconstructToParameters ? 0 : DeclarationStacks::HasInitializer);

} else {

if (kind == DeconstructToVariables) {

failIfFalseIfStrict(declareVariable(&name), "Cannot declare a variable named '", name.impl(), "' in strict mode");

context.addVar(&name, DeclarationStacks::HasInitializer);

}

if (kind == DeconstructToParameters) {

bool declarationResult = declareParameter(&name);

if (!declarationResult && strictMode()) {

semanticFailIfTrue(m_vm->propertyNames->arguments == name || m_vm->propertyNames->eval == name, "Cannot deconstruct to a parameter name '", name.impl(), "' in strict mode");

if (m_lastFunctionName && name == *m_lastFunctionName)

semanticFail("Cannot declare a parameter named '", name.impl(), "' as it shadows the name of a strict mode function");

semanticFailureDueToKeyword("parameter name");

if (hasDeclaredParameter(name))

semanticFail("Cannot declare a parameter named '", name.impl(), "' in strict mode as it has already been declared");

semanticFail("Cannot declare a parameter named '", name.impl(), "' in strict mode");

}

}

}

return context.createBindingLocation(m_token.m_location, name, m_token.m_endPosition, m_token.m_startPosition, m_token.m_endPosition);

}

template <typename LexerType>

template <DeconstructionKind kind, class TreeBuilder> TreeDeconstructionPattern Parser<LexerType>::parseDeconstructionPattern(TreeBuilder& context, int depth)

{

failIfStackOverflow();

int nonLHSCount = m_nonLHSCount;

TreeDeconstructionPattern pattern;

switch (m_token.m_type) {

case OPENBRACKET: {

auto arrayPattern = context.createArrayPattern(m_token.m_location);

next();

failIfTrue(match(CLOSEBRACKET), "There must be at least one bound property in an array deconstruction pattern");

do {

while (match(COMMA)) {

context.appendArrayPatternSkipEntry(arrayPattern, m_token.m_location);

next();

}

propagateError();

JSTokenLocation location = m_token.m_location;

auto innerPattern = parseDeconstructionPattern<kind>(context, depth + 1);

failIfFalse(innerPattern, "Cannot parse this deconstruction pattern");

context.appendArrayPatternEntry(arrayPattern, location, innerPattern);

} while (consume(COMMA));

consumeOrFail(CLOSEBRACKET, "Expected either a closing ']' or a ',' following an element deconstruction pattern");

pattern = arrayPattern;

break;

}

case OPENBRACE: {

next();

failIfTrue(match(CLOSEBRACE), "There must be at least one bound property in an object deconstruction pattern");

auto objectPattern = context.createObjectPattern(m_token.m_location);

bool wasString = false;

do {

Identifier propertyName;

TreeDeconstructionPattern innerPattern = 0;

JSTokenLocation location = m_token.m_location;

if (match(IDENT)) {

propertyName = *m_token.m_data.ident;

next();

if (consume(COLON))

innerPattern = parseDeconstructionPattern<kind>(context, depth + 1);

else

innerPattern = createBindingPattern<kind>(context, propertyName, depth);

} else {

JSTokenType tokenType = m_token.m_type;

switch (m_token.m_type) {

case NUMBER:

propertyName = Identifier::from(m_vm, m_token.m_data.doubleValue);

break;

case STRING:

propertyName = *m_token.m_data.ident;

wasString = true;

break;

default:

if (m_token.m_type != RESERVED && m_token.m_type != RESERVED_IF_STRICT && !(m_token.m_type & KeywordTokenFlag))

failWithMessage("Expected a property name");

propertyName = *m_token.m_data.ident;

break;

}

next();

if (!consume(COLON)) {

semanticFailIfTrue(tokenType == RESERVED, "Cannot use abbreviated deconstruction syntax for reserved name '", propertyName.impl(), "'");

semanticFailIfTrue(tokenType == RESERVED_IF_STRICT, "Cannot use abbreviated deconstruction syntax for reserved name '", propertyName.impl(), "' in strict mode");

semanticFailIfTrue(tokenType & KeywordTokenFlag, "Cannot use abbreviated deconstruction syntax for keyword '", propertyName.impl(), "'");

failWithMessage("Expected a ':' prior to named property deconstruction");

}

innerPattern = parseDeconstructionPattern<kind>(context, depth + 1);

}

failIfFalse(innerPattern, "Cannot parse this deconstruction pattern");

context.appendObjectPatternEntry(objectPattern, location, wasString, propertyName, innerPattern);

} while (consume(COMMA));

consumeOrFail(CLOSEBRACE, "Expected either a closing '}' or an ',' after a property deconstruction pattern");

pattern = objectPattern;

break;

}

default: {

if (!match(IDENT)) {

semanticFailureDueToKeyword("variable name");

failWithMessage("Expected a parameter pattern or a ')' in parameter list");

}

pattern = createBindingPattern<kind>(context, *m_token.m_data.ident, depth);

next();

break;

}

}

m_nonLHSCount = nonLHSCount;

return pattern;

}

template <typename LexerType>

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

{

failIfTrue(strictMode(), "Const declarations are not supported in strict mode");

TreeConstDeclList constDecls = 0;

TreeConstDeclList tail = 0;

do {

JSTokenLocation location(tokenLocation());

next();

matchOrFail(IDENT, "Expected an identifier name in const declaration");

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(location, 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));

JSTokenLocation location(tokenLocation());

int startLine = tokenLine();

next();

handleProductionOrFail(OPENPAREN, "(", "start", "for-loop header");

int nonLHSCount = m_nonLHSCount;

int declarations = 0;

JSTextPosition declsStart;

JSTextPosition declsEnd;

TreeExpression decls = 0;

if (match(VAR)) {

/*

TreeDeconstructionPattern forInTarget = 0;

TreeExpression forInInitializer = 0;

m_allowsIn = false;

JSTextPosition initStart;

JSTextPosition initEnd;

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

m_allowsIn = true;

propagateError();

// Remainder of a standard for loop is handled identically

if (match(SEMICOLON))

goto standardForLoop;

failIfFalse(declarations == 1, "must declare variables after 'var'");

failIfTrue(forInInitializer, "Cannot use initialiser syntax in a for-in loop");

// Handle for-in with var declaration

JSTextPosition inLocation = tokenStartPosition();

bool isOfEnumeration = false;

if (!consume(INTOKEN)) {

failIfFalse(match(IDENT) && *m_token.m_data.ident == m_vm->propertyNames->of, "Expected either 'in' or 'of' in enumeration syntax");

isOfEnumeration = true;

next();

}

TreeExpression expr = parseExpression(context);

failIfFalse(expr, "Expected expression to enumerate");

JSTextPosition exprEnd = lastTokenEndPosition();

int endLine = tokenLine();

handleProductionOrFail(CLOSEPAREN, ")", "end", (isOfEnumeration ? "for-of header" : "for-in header"));

const Identifier* unused = 0;

startLoop();

TreeStatement statement = parseStatement(context, unused);

endLoop();

failIfFalse(statement, "Expected statement as body of for-", isOfEnumeration ? "of" : "in", " statement");

if (isOfEnumeration)

return context.createForOfLoop(location, forInTarget, expr, statement, declsStart, inLocation, exprEnd, startLine, endLine);

return context.createForInLoop(location, forInTarget, expr, statement, declsStart, inLocation, exprEnd, startLine, endLine);

}

if (!match(SEMICOLON)) {

m_allowsIn = false;

declsStart = tokenStartPosition();

decls = parseExpression(context);

declsEnd = lastTokenEndPosition();

m_allowsIn = true;

failIfFalse(decls, "Cannot parse for loop declarations");

}

if (match(SEMICOLON)) {

standardForLoop:

// Standard for loop

next();

TreeExpression condition = 0;

if (!match(SEMICOLON)) {

condition = parseExpression(context);

failIfFalse(condition, "Cannot parse for loop condition expression");

}

consumeOrFail(SEMICOLON, "Expected a ';' after the for loop condition expression");

TreeExpression increment = 0;

if (!match(CLOSEPAREN)) {

increment = parseExpression(context);

failIfFalse(increment, "Cannot parse for loop iteration expression");

}

int endLine = tokenLine();

handleProductionOrFail(CLOSEPAREN, ")", "end", "for-loop header");

const Identifier* unused = 0;

startLoop();

TreeStatement statement = parseStatement(context, unused);

endLoop();

failIfFalse(statement, "Expected a statement as the body of a for loop");

return context.createForLoop(location, decls, condition, increment, statement, startLine, endLine);

}

// For-in loop

failIfFalse(nonLHSCount == m_nonLHSCount, "Expected a reference on the left hand side of an enumeration statement");

bool isOfEnumeration = false;

if (!consume(INTOKEN)) {

failIfFalse(match(IDENT) && *m_token.m_data.ident == m_vm->propertyNames->of, "Expected either 'in' or 'of' in enumeration syntax");

isOfEnumeration = true;

next();

}

TreeExpression expr = parseExpression(context);

failIfFalse(expr, "Cannot parse subject for-", isOfEnumeration ? "of" : "in", " statement");

JSTextPosition exprEnd = lastTokenEndPosition();

int endLine = tokenLine();

handleProductionOrFail(CLOSEPAREN, ")", "end", (isOfEnumeration ? "for-of header" : "for-in header"));

const Identifier* unused = 0;

startLoop();

TreeStatement statement = parseStatement(context, unused);

endLoop();

failIfFalse(statement, "Expected a statement as the body of a for-", isOfEnumeration ? "of" : "in", "loop");

if (isOfEnumeration)

return context.createForOfLoop(location, decls, expr, statement, declsStart, declsEnd, exprEnd, startLine, endLine);

return context.createForInLoop(location, decls, expr, statement, declsStart, declsEnd, exprEnd, startLine, endLine);

}

template <typename LexerType>

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

{

ASSERT(match(BREAK));

JSTokenLocation location(tokenLocation());

JSTextPosition start = tokenStartPosition();

JSTextPosition end = tokenEndPosition();

next();

if (autoSemiColon()) {

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

return context.createBreakStatement(location, start, end);

}

matchOrFail(IDENT, "Expected an identifier as the target for a break statement");

const Identifier* ident = m_token.m_data.ident;

semanticFailIfFalse(getLabel(ident), "Cannot use the undeclared label '", ident->impl(), "'");

end = tokenEndPosition();

next();

failIfFalse(autoSemiColon(), "Expected a ';' following a targeted break statement");

return context.createBreakStatement(location, ident, start, end);

}

template <typename LexerType>

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

{

ASSERT(match(CONTINUE));

JSTokenLocation location(tokenLocation());

JSTextPosition start = tokenStartPosition();

JSTextPosition end = tokenEndPosition();

next();

if (autoSemiColon()) {

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

return context.createContinueStatement(location, start, end);

}

matchOrFail(IDENT, "Expected an identifier as the target for a continue statement");

const Identifier* ident = m_token.m_data.ident;

ScopeLabelInfo* label = getLabel(ident);

semanticFailIfFalse(label, "Cannot use the undeclared label '", ident->impl(), "'");

semanticFailIfFalse(label->m_isLoop, "Cannot continue to the label '", ident->impl(), "' as it is not targeting a loop");

end = tokenEndPosition();

next();

failIfFalse(autoSemiColon(), "Expected a ';' following a targeted continue statement");

return context.createContinueStatement(location, ident, start, end);

}

template <typename LexerType>

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

{

ASSERT(match(RETURN));

JSTokenLocation location(tokenLocation());

semanticFailIfFalse(currentScope()->isFunction(), "Return statements are only valid inside functions");

JSTextPosition start = tokenStartPosition();

JSTextPosition end = tokenEndPosition();

next();

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

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

// the statement

if (match(SEMICOLON))

end = tokenEndPosition();

if (autoSemiColon())

return context.createReturnStatement(location, 0, start, end);

TreeExpression expr = parseExpression(context);

failIfFalse(expr, "Cannot parse the return expression");

end = lastTokenEndPosition();

if (match(SEMICOLON))

end = tokenEndPosition();

if (!autoSemiColon())

failWithMessage("Expected a ';' following a return statement");

return context.createReturnStatement(location, expr, start, end);

}

template <typename LexerType>

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

{

ASSERT(match(THROW));

JSTokenLocation location(tokenLocation());

JSTextPosition start = tokenStartPosition();

next();

failIfTrue(match(SEMICOLON), "Expected expression after 'throw'");

semanticFailIfTrue(autoSemiColon(), "Cannot have a newline after 'throw'");

TreeExpression expr = parseExpression(context);

failIfFalse(expr, "Cannot parse expression for throw statement");

JSTextPosition end = lastTokenEndPosition();

failIfFalse(autoSemiColon(), "Expected a ';' after a throw statement");

return context.createThrowStatement(location, expr, start, end);

}

template <typename LexerType>

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

{

ASSERT(match(WITH));

JSTokenLocation location(tokenLocation());

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

currentScope()->setNeedsFullActivation();

int startLine = tokenLine();

next();

handleProductionOrFail(OPENPAREN, "(", "start", "subject of a 'with' statement");

int start = tokenStart();

TreeExpression expr = parseExpression(context);

failIfFalse(expr, "Cannot parse 'with' subject expression");

JSTextPosition end = lastTokenEndPosition();

int endLine = tokenLine();

handleProductionOrFail(CLOSEPAREN, ")", "start", "subject of a 'with' statement");

const Identifier* unused = 0;

TreeStatement statement = parseStatement(context, unused);

failIfFalse(statement, "A 'with' statement must have a body");

return context.createWithStatement(location, expr, statement, start, end, startLine, endLine);

}

template <typename LexerType>

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

{

ASSERT(match(SWITCH));

JSTokenLocation location(tokenLocation());

int startLine = tokenLine();

next();

handleProductionOrFail(OPENPAREN, "(", "start", "subject of a 'switch'");

TreeExpression expr = parseExpression(context);

failIfFalse(expr, "Cannot parse switch subject expression");

int endLine = tokenLine();

handleProductionOrFail(CLOSEPAREN, ")", "end", "subject of a 'switch'");

handleProductionOrFail(OPENBRACE, "{", "start", "body of a 'switch'");

startSwitch();

TreeClauseList firstClauses = parseSwitchClauses(context);

propagateError();

TreeClause defaultClause = parseSwitchDefaultClause(context);

propagateError();

TreeClauseList secondClauses = parseSwitchClauses(context);

propagateError();

endSwitch();

handleProductionOrFail(CLOSEBRACE, "}", "end", "body of a 'switch'");

return context.createSwitchStatement(location, 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, "Cannot parse switch clause");

consumeOrFail(COLON, "Expected a ':' after switch clause expression");

TreeSourceElements statements = parseSourceElements<DontCheckForStrictMode>(context);

failIfFalse(statements, "Cannot parse the body of a switch clause");

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

TreeClauseList clauseList = context.createClauseList(clause);

TreeClauseList tail = clauseList;

while (match(CASE)) {

next();

TreeExpression condition = parseExpression(context);

failIfFalse(condition, "Cannot parse switch case expression");

consumeOrFail(COLON, "Expected a ':' after switch clause expression");

TreeSourceElements statements = parseSourceElements<DontCheckForStrictMode>(context);

failIfFalse(statements, "Cannot parse the body of a switch clause");

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, "Expected a ':' after switch default clause");

TreeSourceElements statements = parseSourceElements<DontCheckForStrictMode>(context);

failIfFalse(statements, "Cannot parse the body of a switch default clause");

return context.createClause(0, statements);

}

template <typename LexerType>

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

{

ASSERT(match(TRY));

JSTokenLocation location(tokenLocation());

TreeStatement tryBlock = 0;

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

TreeStatement catchBlock = 0;

TreeStatement finallyBlock = 0;

int firstLine = tokenLine();

next();

matchOrFail(OPENBRACE, "Expected a block statement as body of a try statement");

tryBlock = parseBlockStatement(context);

failIfFalse(tryBlock, "Cannot parse the body of try block");

int lastLine = m_lastTokenEndPosition.line;

if (match(CATCH)) {

currentScope()->setNeedsFullActivation();

next();

handleProductionOrFail(OPENPAREN, "(", "start", "'catch' target");

if (!match(IDENT)) {

semanticFailureDueToKeyword("catch variable name");

failWithMessage("Expected identifier name as catch target");

}

ident = m_token.m_data.ident;

next();

AutoPopScopeRef catchScope(this, pushScope());

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

catchScope->preventNewDecls();

handleProductionOrFail(CLOSEPAREN, ")", "end", "'catch' target");

matchOrFail(OPENBRACE, "Expected exception handler to be a block statement");

catchBlock = parseBlockStatement(context);

failIfFalse(catchBlock, "Unable to parse 'catch' block");

failIfFalse(popScope(catchScope, TreeBuilder::NeedsFreeVariableInfo), "Parse error");

}

if (match(FINALLY)) {

next();

matchOrFail(OPENBRACE, "Expected block statement for finally body");

finallyBlock = parseBlockStatement(context);

failIfFalse(finallyBlock, "Cannot parse finally body");

}

failIfFalse(catchBlock || finallyBlock, "Try statements must have at least a catch or finally block");

return context.createTryStatement(location, tryBlock, ident, catchBlock, finallyBlock, firstLine, lastLine);

}

template <typename LexerType>

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

{

ASSERT(match(DEBUGGER));

JSTokenLocation location(tokenLocation());

int startLine = tokenLine();

int endLine = startLine;

next();

if (match(SEMICOLON))

startLine = tokenLine();

failIfFalse(autoSemiColon(), "Debugger keyword must be followed by a ';'");

return context.createDebugger(location, startLine, endLine);

}

template <typename LexerType>

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

{

ASSERT(match(OPENBRACE));

JSTokenLocation location(tokenLocation());

int start = tokenLine();

next();

if (match(CLOSEBRACE)) {

next();

return context.createBlockStatement(location, 0, start, m_lastTokenEndPosition.line);

}

TreeSourceElements subtree = parseSourceElements<DontCheckForStrictMode>(context);

failIfFalse(subtree, "Cannot parse the body of the block statement");

matchOrFail(CLOSEBRACE, "Expected a closing '}' at the end of a block statement");

next();

return context.createBlockStatement(location, subtree, start, m_lastTokenEndPosition.line);

}

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:

failIfFalseIfStrict(m_statementDepth == 1, "Nested functions cannot be declared in strict mode");

return parseFunctionDeclaration(context);

case SEMICOLON: {

JSTokenLocation location(tokenLocation());

next();

return context.createEmptyStatement(location);

}

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_location.endOffset - m_token.m_location.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)

{