/*
* Copyright (C) 1999-2001 Harri Porten (porten@kde.org)
* Copyright (C) 2001 Peter Kelly (pmk@post.com)
- * Copyright (C) 2003, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
+ * Copyright (C) 2003, 2006, 2007, 2008, 2009, 2010, 2013 Apple Inc. All rights reserved.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
#include "ASTBuilder.h"
#include "CodeBlock.h"
#include "Debugger.h"
-#include "JSGlobalData.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/WTFThreadData.h>
+#define fail() do { if (!hasError()) updateErrorMessage(); return 0; } while (0)
+#define failWithToken(tok) do { if (!hasError()) updateErrorMessage(tok); return 0; } while (0)
+#define failWithMessage(msg) do { if (!hasError()) updateErrorMessage(msg); return 0; } while (0)
+#define failWithNameAndMessage(before, name, after) do { if (!hasError()) updateErrorWithNameAndMessage(before, name, after); return 0; } while (0)
+#define failWithStackOverflow() do { updateErrorMessage("Stack exhausted"); m_hasStackOverflow = true; return 0; } while (0)
+#define failIfFalse(cond) do { if (!(cond)) fail(); } while (0)
+#define failIfFalseWithMessage(cond, msg) do { if (!(cond)) failWithMessage(msg); } while (0)
+#define failIfFalseWithNameAndMessage(cond, before, name, msg) do { if (!(cond)) failWithNameAndMessage(before, name, msg); } while (0)
+#define failIfTrue(cond) do { if ((cond)) fail(); } while (0)
+#define failIfTrueWithMessage(cond, msg) do { if ((cond)) failWithMessage(msg); } while (0)
+#define failIfTrueWithNameAndMessage(cond, before, name, msg) do { if ((cond)) failWithNameAndMessage(before, name, msg); } while (0)
+#define failIfTrueIfStrict(cond) do { if ((cond) && strictMode()) fail(); } while (0)
+#define failIfTrueIfStrictWithMessage(cond, msg) do { if ((cond) && strictMode()) failWithMessage(msg); } while (0)
+#define failIfTrueIfStrictWithNameAndMessage(cond, before, name, after) do { if ((cond) && strictMode()) failWithNameAndMessage(before, name, after); } while (0)
+#define failIfFalseIfStrict(cond) do { if ((!(cond)) && strictMode()) fail(); } while (0)
+#define failIfFalseIfStrictWithMessage(cond, msg) do { if ((!(cond)) && strictMode()) failWithMessage(msg); } while (0)
+#define failIfFalseIfStrictWithNameAndMessage(cond, before, name, after) do { if ((!(cond)) && strictMode()) failWithNameAndMessage(before, name, after); } while (0)
+#define consumeOrFail(tokenType) do { if (!consume(tokenType)) failWithToken(tokenType); } while (0)
+#define consumeOrFailWithFlags(tokenType, flags) do { if (!consume(tokenType, flags)) failWithToken(tokenType); } while (0)
+#define matchOrFail(tokenType) do { if (!match(tokenType)) failWithToken(tokenType); } while (0)
+#define failIfStackOverflow() do { if (!canRecurse()) failWithStackOverflow(); } while (0)
+
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)
+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(wtfThreadData().stack())
- , m_error(false)
- , m_errorMessage("Parse error")
+ , m_hasStackOverflow(false)
, m_allowsIn(true)
, m_lastLine(0)
, m_lastTokenEnd(0)
, m_lastIdentifier(0)
, m_sourceElements(0)
{
- m_lexer = adoptPtr(new LexerType(globalData));
- m_arena = m_globalData->parserArena.get();
+ m_lexer = adoptPtr(new LexerType(vm));
+ m_arena = m_vm->parserArena.get();
m_lexer->setCode(source, m_arena);
+ m_token.m_location.endOffset = source.startOffset();
+ m_token.m_location.lineStartOffset = source.startOffset();
- m_functionCache = source.provider()->cache();
+ m_functionCache = vm->addSourceProviderCache(source.provider());
ScopeRef scope = pushScope();
if (parserMode == JSParseFunctionCode)
scope->setIsFunction();
for (unsigned i = 0; i < parameters->size(); i++)
scope->declareParameter(¶meters->at(i));
}
+ if (!name.isNull())
+ scope->declareCallee(&name);
next();
- m_lexer->setLastLineNumber(tokenLine());
}
template <typename LexerType>
}
template <typename LexerType>
-UString Parser<LexerType>::parseInner()
+String Parser<LexerType>::parseInner()
{
- UString parseError = UString();
+ String parseError = String();
- unsigned oldFunctionCacheSize = m_functionCache ? m_functionCache->byteSize() : 0;
- ASTBuilder context(const_cast<JSGlobalData*>(m_globalData), const_cast<SourceCode*>(m_source));
+ 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))
- parseError = m_errorMessage;
+ if (!sourceElements || !consume(EOFTOK)) {
+ if (hasError())
+ parseError = m_errorMessage;
+ else
+ parseError = ASCIILiteral("Parser error");
+ }
IdentifierSet capturedVariables;
scope->getCapturedVariables(capturedVariables);
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);
bool seenNonDirective = false;
const Identifier* directive = 0;
unsigned directiveLiteralLength = 0;
- unsigned startOffset = m_token.m_info.startOffset;
+ unsigned startOffset = m_token.m_location.startOffset;
+ unsigned startLineStartOffset = m_token.m_location.lineStartOffset;
unsigned oldLastLineNumber = m_lexer->lastLineNumber();
unsigned oldLineNumber = m_lexer->lineNumber();
bool hasSetStrict = false;
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) {
+ if (!hasSetStrict && directiveLiteralLength == lengthOfUseStrictLiteral && m_vm->propertyNames->useStrictIdentifier == *directive) {
setStrictMode();
hasSetStrict = true;
failIfFalse(isValidStrictMode());
- m_lexer->setOffset(startOffset);
+ m_lexer->setOffset(startOffset, startLineStartOffset);
next();
m_lexer->setLastLineNumber(oldLastLineNumber);
m_lexer->setLineNumber(oldLineNumber);
- failIfTrue(m_error);
+ failIfTrue(hasError());
continue;
}
} else
}
context.appendStatement(sourceElements, statement);
}
-
- if (m_error)
- fail();
+
+ failIfTrue(hasError());
return sourceElements;
}
template <class TreeBuilder> TreeStatement Parser<LexerType>::parseVarDeclaration(TreeBuilder& context)
{
ASSERT(match(VAR));
+ JSTokenLocation location(tokenLocation());
int start = tokenLine();
int end = 0;
int scratch;
TreeExpression scratch2 = 0;
int scratch3 = 0;
TreeExpression varDecls = parseVarDeclarationList(context, scratch, scratch1, scratch2, scratch3, scratch3, scratch3);
- failIfTrue(m_error);
+ failIfTrue(hasError());
failIfFalse(autoSemiColon());
- return context.createVarStatement(m_lexer->lastLineNumber(), varDecls, start, end);
+ 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);
- failIfTrue(m_error);
+ failIfTrue(hasError());
failIfFalse(autoSemiColon());
- return context.createConstStatement(m_lexer->lastLineNumber(), constDecls, start, end);
+ return context.createConstStatement(location, constDecls, start, end);
}
template <typename LexerType>
endLoop();
failIfFalse(statement);
int endLine = tokenLine();
+ JSTokenLocation location(tokenLocation());
consumeOrFail(WHILE);
consumeOrFail(OPENPAREN);
TreeExpression expr = parseExpression(context);
consumeOrFail(CLOSEPAREN);
if (match(SEMICOLON))
next(); // Always performs automatic semicolon insertion.
- return context.createDoWhileStatement(m_lexer->lastLineNumber(), statement, expr, startLine, endLine);
+ 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();
consumeOrFail(OPENPAREN);
TreeStatement statement = parseStatement(context, unused);
endLoop();
failIfFalse(statement);
- return context.createWhileStatement(m_lexer->lastLineNumber(), expr, statement, startLine, endLine);
+ return context.createWhileStatement(location, expr, statement, startLine, endLine);
}
template <typename LexerType>
TreeExpression varDecls = 0;
do {
declarations++;
+ JSTokenLocation location(tokenLocation());
next();
matchOrFail(IDENT);
context.addVar(name, (hasInitializer || (!m_allowsIn && match(INTOKEN))) ? DeclarationStacks::HasInitializer : 0);
if (hasInitializer) {
int varDivot = tokenStart() + 1;
+ unsigned varLine = tokenLine();
+ unsigned varLineStart = tokenLineStart();
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());
+ TreeExpression node = context.createAssignResolve(location, *name, initializer, varStart, varDivot, lastTokenEnd(), varLine, varLineStart);
if (!varDecls)
varDecls = node;
else
- varDecls = context.combineCommaNodes(m_lexer->lastLineNumber(), varDecls, node);
+ varDecls = context.combineCommaNodes(location, varDecls, node);
}
} while (match(COMMA));
return varDecls;
TreeConstDeclList constDecls = 0;
TreeConstDeclList tail = 0;
do {
+ JSTokenLocation location(tokenLocation());
next();
matchOrFail(IDENT);
const Identifier* name = m_token.m_data.ident;
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);
+ tail = context.appendConstDecl(location, tail, name, initializer);
if (!constDecls)
constDecls = tail;
} while (match(COMMA));
template <class TreeBuilder> TreeStatement Parser<LexerType>::parseForStatement(TreeBuilder& context)
{
ASSERT(match(FOR));
+ JSTokenLocation location(tokenLocation());
int startLine = tokenLine();
next();
consumeOrFail(OPENPAREN);
int declarations = 0;
int declsStart = 0;
int declsEnd = 0;
+ unsigned declsLine = 0;
+ unsigned declsLineStart = 0;
TreeExpression decls = 0;
- bool hasDeclaration = false;
if (match(VAR)) {
/*
for (var IDENT in expression) statement
for (var IDENT = expression in expression) statement
for (var varDeclarationList; expressionOpt; expressionOpt)
*/
- hasDeclaration = true;
const Identifier* forInTarget = 0;
TreeExpression forInInitializer = 0;
m_allowsIn = false;
int initEnd = 0;
decls = parseVarDeclarationList(context, declarations, forInTarget, forInInitializer, declsStart, initStart, initEnd);
m_allowsIn = true;
- if (m_error)
- fail();
-
+ failIfTrue(hasError());
+
// Remainder of a standard for loop is handled identically
if (match(SEMICOLON))
goto standardForLoop;
// Handle for-in with var declaration
int inLocation = tokenStart();
+ unsigned inLine = tokenLine();
+ unsigned inLineStart = tokenLineStart();
consumeOrFail(INTOKEN);
TreeExpression expr = parseExpression(context);
endLoop();
failIfFalse(statement);
- return context.createForInLoop(m_lexer->lastLineNumber(), forInTarget, forInInitializer, expr, statement, declsStart, inLocation, exprEnd, initStart, initEnd, startLine, endLine);
+ return context.createForInLoop(location, forInTarget, forInInitializer, expr, statement, declsStart, inLocation, exprEnd, initStart, initEnd, startLine, endLine, inLine, inLineStart);
}
if (!match(SEMICOLON)) {
declsStart = tokenStart();
decls = parseExpression(context);
declsEnd = lastTokenEnd();
+ declsLine = lastTokenLine();
+ declsLineStart = lastTokenLineStart();
m_allowsIn = true;
failIfFalse(decls);
}
TreeStatement statement = parseStatement(context, unused);
endLoop();
failIfFalse(statement);
- return context.createForLoop(m_lexer->lastLineNumber(), decls, condition, increment, statement, hasDeclaration, startLine, endLine);
+ return context.createForLoop(location, decls, condition, increment, statement, startLine, endLine);
}
// For-in loop
endLoop();
failIfFalse(statement);
- return context.createForInLoop(m_lexer->lastLineNumber(), decls, expr, statement, declsStart, declsEnd, exprEnd, startLine, endLine);
+ return context.createForInLoop(location, decls, expr, statement, declsStart, declsEnd, exprEnd, startLine, endLine, declsLine, declsLineStart);
}
template <typename LexerType>
template <class TreeBuilder> TreeStatement Parser<LexerType>::parseBreakStatement(TreeBuilder& context)
{
ASSERT(match(BREAK));
+ JSTokenLocation location(tokenLocation());
int startCol = tokenStart();
int endCol = tokenEnd();
int startLine = tokenLine();
int endLine = tokenLine();
+ unsigned endLineStart = tokenLineStart();
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);
+ return context.createBreakStatement(location, startCol, endCol, startLine, endLine, endLineStart);
}
matchOrFail(IDENT);
const Identifier* ident = m_token.m_data.ident;
failIfFalseWithNameAndMessage(getLabel(ident), "Label", ident->impl(), "is not defined");
endCol = tokenEnd();
endLine = tokenLine();
+ endLineStart = tokenLineStart();
next();
failIfFalse(autoSemiColon());
- return context.createBreakStatement(m_lexer->lastLineNumber(), ident, startCol, endCol, startLine, endLine);
+ return context.createBreakStatement(location, ident, startCol, endCol, startLine, endLine, endLineStart);
}
template <typename LexerType>
template <class TreeBuilder> TreeStatement Parser<LexerType>::parseContinueStatement(TreeBuilder& context)
{
ASSERT(match(CONTINUE));
+ JSTokenLocation location(tokenLocation());
int startCol = tokenStart();
int endCol = tokenEnd();
int startLine = tokenLine();
int endLine = tokenLine();
+ unsigned endLineStart = tokenLineStart();
next();
if (autoSemiColon()) {
failIfFalseWithMessage(continueIsValid(), "'continue' is only valid inside a loop statement");
- return context.createContinueStatement(m_lexer->lastLineNumber(), startCol, endCol, startLine, endLine);
+ return context.createContinueStatement(location, startCol, endCol, startLine, endLine, endLineStart);
}
matchOrFail(IDENT);
const Identifier* ident = m_token.m_data.ident;
failIfFalseWithMessage(label->m_isLoop, "'continue' is only valid inside a loop statement");
endCol = tokenEnd();
endLine = tokenLine();
+ endLineStart = tokenLineStart();
next();
failIfFalse(autoSemiColon());
- return context.createContinueStatement(m_lexer->lastLineNumber(), ident, startCol, endCol, startLine, endLine);
+ return context.createContinueStatement(location, ident, startCol, endCol, startLine, endLine, endLineStart);
}
template <typename LexerType>
template <class TreeBuilder> TreeStatement Parser<LexerType>::parseReturnStatement(TreeBuilder& context)
{
ASSERT(match(RETURN));
+ JSTokenLocation location(tokenLocation());
failIfFalse(currentScope()->isFunction());
int startLine = tokenLine();
int endLine = startLine;
int start = tokenStart();
int end = tokenEnd();
+ unsigned divotLine = tokenLine();
+ unsigned divotLineStart = tokenLineStart();
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
if (match(SEMICOLON))
endLine = tokenLine();
if (autoSemiColon())
- return context.createReturnStatement(m_lexer->lastLineNumber(), 0, start, end, startLine, endLine);
+ return context.createReturnStatement(location, 0, start, end, startLine, endLine, divotLine, divotLineStart);
TreeExpression expr = parseExpression(context);
failIfFalse(expr);
end = lastTokenEnd();
+ divotLine = lastTokenLine();
+ divotLineStart = lastTokenLineStart();
if (match(SEMICOLON))
endLine = tokenLine();
failIfFalse(autoSemiColon());
- return context.createReturnStatement(m_lexer->lastLineNumber(), expr, start, end, startLine, endLine);
+ return context.createReturnStatement(location, expr, start, end, startLine, endLine, divotLine, divotLineStart);
}
template <typename LexerType>
template <class TreeBuilder> TreeStatement Parser<LexerType>::parseThrowStatement(TreeBuilder& context)
{
ASSERT(match(THROW));
+ JSTokenLocation location(tokenLocation());
int eStart = tokenStart();
int startLine = tokenLine();
next();
TreeExpression expr = parseExpression(context);
failIfFalse(expr);
int eEnd = lastTokenEnd();
+ unsigned divotLine = lastTokenLine();
+ unsigned divotLineStart = lastTokenLineStart();
int endLine = tokenLine();
failIfFalse(autoSemiColon());
- return context.createThrowStatement(m_lexer->lastLineNumber(), expr, eStart, eEnd, startLine, endLine);
+ return context.createThrowStatement(location, expr, eStart, eEnd, startLine, endLine, divotLine, divotLineStart);
}
template <typename LexerType>
template <class TreeBuilder> TreeStatement Parser<LexerType>::parseWithStatement(TreeBuilder& context)
{
ASSERT(match(WITH));
+ JSTokenLocation location(tokenLocation());
failIfTrueWithMessage(strictMode(), "'with' statements are not valid in strict mode");
currentScope()->setNeedsFullActivation();
int startLine = tokenLine();
TreeExpression expr = parseExpression(context);
failIfFalse(expr);
int end = lastTokenEnd();
-
+ unsigned divotLine = lastTokenLine();
+ unsigned divotLineStart = lastTokenLineStart();
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);
+ return context.createWithStatement(location, expr, statement, start, end, startLine, endLine, divotLine, divotLineStart);
}
template <typename LexerType>
template <class TreeBuilder> TreeStatement Parser<LexerType>::parseSwitchStatement(TreeBuilder& context)
{
ASSERT(match(SWITCH));
+ JSTokenLocation location(tokenLocation());
int startLine = tokenLine();
next();
consumeOrFail(OPENPAREN);
consumeOrFail(OPENBRACE);
startSwitch();
TreeClauseList firstClauses = parseSwitchClauses(context);
- failIfTrue(m_error);
+ failIfTrue(hasError());
TreeClause defaultClause = parseSwitchDefaultClause(context);
- failIfTrue(m_error);
+ failIfTrue(hasError());
TreeClauseList secondClauses = parseSwitchClauses(context);
- failIfTrue(m_error);
+ failIfTrue(hasError());
endSwitch();
consumeOrFail(CLOSEBRACE);
- return context.createSwitchStatement(m_lexer->lastLineNumber(), expr, firstClauses, defaultClause, secondClauses, startLine, endLine);
+ return context.createSwitchStatement(location, expr, firstClauses, defaultClause, secondClauses, startLine, endLine);
}
template <class TreeBuilder> TreeStatement Parser<LexerType>::parseTryStatement(TreeBuilder& context)
{
ASSERT(match(TRY));
+ JSTokenLocation location(tokenLocation());
TreeStatement tryBlock = 0;
- const Identifier* ident = &m_globalData->propertyNames->nullIdentifier;
+ const Identifier* ident = &m_vm->propertyNames->nullIdentifier;
TreeStatement catchBlock = 0;
TreeStatement finallyBlock = 0;
int firstLine = tokenLine();
failIfFalse(finallyBlock);
}
failIfFalse(catchBlock || finallyBlock);
- return context.createTryStatement(m_lexer->lastLineNumber(), tryBlock, ident, catchBlock, finallyBlock, firstLine, lastLine);
+ 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());
- return context.createDebugger(m_lexer->lastLineNumber(), startLine, endLine);
+ 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(m_lexer->lastLineNumber(), 0, start, m_lastLine);
+ return context.createBlockStatement(location, 0, start, m_lastLine);
}
TreeSourceElements subtree = parseSourceElements<DontCheckForStrictMode>(context);
failIfFalse(subtree);
matchOrFail(CLOSEBRACE);
next();
- return context.createBlockStatement(m_lexer->lastLineNumber(), subtree, start, m_lastLine);
+ return context.createBlockStatement(location, subtree, start, m_lastLine);
}
template <typename LexerType>
case FUNCTION:
failIfFalseIfStrictWithMessage(m_statementDepth == 1, "Functions cannot be declared in a nested block in strict mode");
return parseFunctionDeclaration(context);
- case SEMICOLON:
+ case SEMICOLON: {
+ JSTokenLocation location(tokenLocation());
next();
- return context.createEmptyStatement(m_lexer->lastLineNumber());
+ return context.createEmptyStatement(location);
+ }
case IF:
return parseIfStatement(context);
case DO:
case STRING:
directive = m_token.m_data.ident;
if (directiveLiteralLength)
- *directiveLiteralLength = m_token.m_info.endOffset - m_token.m_info.startOffset;
+ *directiveLiteralLength = m_token.m_location.endOffset - m_token.m_location.startOffset;
nonTrivialExpressionCount = m_nonTrivialExpressionCount;
default:
TreeStatement exprStatement = parseExpressionStatement(context);
template <typename LexerType>
template <class TreeBuilder> TreeFunctionBody Parser<LexerType>::parseFunctionBody(TreeBuilder& context)
{
+ JSTokenLocation startLocation(tokenLocation());
+ unsigned startColumn = tokenColumn();
+ next();
+
if (match(CLOSEBRACE))
- return context.createFunctionBody(m_lexer->lastLineNumber(), strictMode());
+ return context.createFunctionBody(startLocation, tokenLocation(), startColumn, strictMode());
DepthManager statementDepth(&m_statementDepth);
m_statementDepth = 0;
- typename TreeBuilder::FunctionBodyBuilder bodyBuilder(const_cast<JSGlobalData*>(m_globalData), m_lexer.get());
+ typename TreeBuilder::FunctionBodyBuilder bodyBuilder(const_cast<VM*>(m_vm), m_lexer.get());
failIfFalse(parseSourceElements<CheckForStrictMode>(bodyBuilder));
- return context.createFunctionBody(m_lexer->lastLineNumber(), strictMode());
+ return context.createFunctionBody(startLocation, tokenLocation(), startColumn, 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)
+template <FunctionRequirements requirements, bool nameIsInContainingScope, class TreeBuilder> bool Parser<LexerType>::parseFunctionInfo(TreeBuilder& context, const Identifier*& name, TreeFormalParameterList& parameters, TreeFunctionBody& body, unsigned& openBraceOffset, unsigned& closeBraceOffset, int& bodyStartLine, unsigned& bodyStartColumn)
{
AutoPopScopeRef functionScope(this, pushScope());
functionScope->setIsFunction();
+ int functionStart = m_token.m_location.startOffset;
if (match(IDENT)) {
name = m_token.m_data.ident;
next();
consumeOrFail(CLOSEPAREN);
matchOrFail(OPENBRACE);
- openBracePos = m_token.m_data.intValue;
+ openBraceOffset = m_token.m_data.offset;
bodyStartLine = tokenLine();
+ bodyStartColumn = m_token.m_data.offset - m_token.m_data.lineStartOffset;
+ JSTokenLocation startLocation(tokenLocation());
// 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 (const SourceProviderCacheItem* cachedInfo = TreeBuilder::CanUseFunctionCache ? findCachedFunctionInfo(openBraceOffset) : 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);
+ JSTokenLocation endLocation;
+
+ endLocation.line = cachedInfo->closeBraceLine;
+ endLocation.startOffset = cachedInfo->closeBraceOffset;
+ endLocation.lineStartOffset = cachedInfo->closeBraceLineStartOffset;
+ ASSERT(endLocation.startOffset >= endLocation.lineStartOffset);
+
+ body = context.createFunctionBody(startLocation, endLocation, bodyStartColumn, cachedInfo->strictMode);
- functionScope->restoreFunctionInfo(cachedInfo);
+ functionScope->restoreFromSourceProviderCache(cachedInfo);
failIfFalse(popScope(functionScope, TreeBuilder::NeedsFreeVariableInfo));
- closeBracePos = cachedInfo->closeBracePos;
+ closeBraceOffset = cachedInfo->closeBraceOffset;
+
+ context.setFunctionStart(body, functionStart);
m_token = cachedInfo->closeBraceToken();
- m_lexer->setOffset(m_token.m_info.endOffset);
- m_lexer->setLineNumber(m_token.m_info.line);
+
+ m_lexer->setOffset(m_token.m_location.endOffset, m_token.m_location.lineStartOffset);
+ m_lexer->setLineNumber(m_token.m_location.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");
+ failIfTrueWithNameAndMessage(m_vm->propertyNames->arguments == *name, "Function name", name->impl(), "is not valid in strict mode");
+ failIfTrueWithNameAndMessage(m_vm->propertyNames->eval == *name, "Function name", name->impl(), "is not valid in strict mode");
}
- closeBracePos = m_token.m_data.intValue;
+ closeBraceOffset = m_token.m_data.offset;
+ unsigned closeBraceLine = m_token.m_data.line;
+ unsigned closeBraceLineStartOffset = m_token.m_data.lineStartOffset;
// 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;
+ static const int minimumFunctionLengthToCache = 16;
OwnPtr<SourceProviderCacheItem> newInfo;
- int functionLength = closeBracePos - openBracePos;
+ int functionLength = closeBraceOffset - openBraceOffset;
if (TreeBuilder::CanUseFunctionCache && m_functionCache && functionLength > minimumFunctionLengthToCache) {
- newInfo = adoptPtr(new SourceProviderCacheItem(m_token.m_info.line, closeBracePos));
- functionScope->saveFunctionInfo(newInfo.get());
+ SourceProviderCacheItemCreationParameters parameters;
+ parameters.functionStart = functionStart;
+ parameters.closeBraceLine = closeBraceLine;
+ parameters.closeBraceOffset = closeBraceOffset;
+ parameters.closeBraceLineStartOffset = closeBraceLineStartOffset;
+ functionScope->fillParametersForSourceProviderCache(parameters);
+ newInfo = SourceProviderCacheItem::create(parameters);
+
}
+ context.setFunctionStart(body, functionStart);
failIfFalse(popScope(functionScope, TreeBuilder::NeedsFreeVariableInfo));
matchOrFail(CLOSEBRACE);
- if (newInfo) {
- unsigned approximateByteSize = newInfo->approximateByteSize();
- m_functionCache->add(openBracePos, newInfo.release(), approximateByteSize);
- }
+ if (newInfo)
+ m_functionCache->add(openBraceOffset, newInfo.release());
next();
return true;
template <class TreeBuilder> TreeStatement Parser<LexerType>::parseFunctionDeclaration(TreeBuilder& context)
{
ASSERT(match(FUNCTION));
+ JSTokenLocation location(tokenLocation());
next();
const Identifier* name = 0;
TreeFormalParameterList parameters = 0;
TreeFunctionBody body = 0;
- int openBracePos = 0;
- int closeBracePos = 0;
+ unsigned openBraceOffset = 0;
+ unsigned closeBraceOffset = 0;
int bodyStartLine = 0;
- failIfFalse((parseFunctionInfo<FunctionNeedsName, true>(context, name, parameters, body, openBracePos, closeBracePos, bodyStartLine)));
+ unsigned bodyStartColumn = 0;
+ failIfFalse((parseFunctionInfo<FunctionNeedsName, true>(context, name, parameters, body, openBraceOffset, closeBraceOffset, bodyStartLine, bodyStartColumn)));
failIfFalse(name);
failIfFalseIfStrict(declareVariable(name));
- return context.createFuncDeclStatement(m_lexer->lastLineNumber(), name, body, parameters, openBracePos, closeBracePos, bodyStartLine, m_lastLine);
+ return context.createFuncDeclStatement(location, name, body, parameters, openBraceOffset, closeBraceOffset, bodyStartLine, m_lastLine, bodyStartColumn);
}
struct LabelInfo {
- LabelInfo(const Identifier* ident, int start, int end)
+ LabelInfo(const Identifier* ident, unsigned start, unsigned end, unsigned divotLine, unsigned divotLineStart)
: m_ident(ident)
, m_start(start)
, m_end(end)
+ , m_divotLine(divotLine)
+ , m_divotLineStart(divotLineStart)
{
}
const Identifier* m_ident;
- int m_start;
- int m_end;
+ unsigned m_start;
+ unsigned m_end;
+ unsigned m_divotLine;
+ unsigned m_divotLineStart;
};
template <typename LexerType>
* special case that looks for a colon as the next character in the input.
*/
Vector<LabelInfo> labels;
-
+ JSTokenLocation location;
do {
int start = tokenStart();
- int startLine = tokenLine();
+ int startingLine = tokenLine();
+ location = tokenLocation();
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
TreeExpression expression = parseExpression(context);
failIfFalse(expression);
failIfFalse(autoSemiColon());
- return context.createExprStatement(m_lexer->lastLineNumber(), expression, startLine, m_lastLine);
+ return context.createExprStatement(location, expression, startingLine, m_lastLine);
}
const Identifier* ident = m_token.m_data.ident;
int end = tokenEnd();
+ unsigned divotLine = tokenLine();
+ unsigned divotLineStart = tokenLineStart();
next();
consumeOrFail(COLON);
if (!m_syntaxAlreadyValidated) {
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));
+ labels.append(LabelInfo(ident, start, end, divotLine, divotLineStart));
}
} while (match(IDENT));
bool isLoop = false;
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);
+ statement = context.createLabelStatement(location, info.m_ident, statement, info.m_start, info.m_end, info.m_divotLine, info.m_divotLineStart);
}
return statement;
}
template <class TreeBuilder> TreeStatement Parser<LexerType>::parseExpressionStatement(TreeBuilder& context)
{
int startLine = tokenLine();
+ JSTokenLocation location(tokenLocation());
TreeExpression expression = parseExpression(context);
failIfFalse(expression);
failIfFalse(autoSemiColon());
- return context.createExprStatement(m_lexer->lastLineNumber(), expression, startLine, m_lastLine);
+ return context.createExprStatement(location, expression, startLine, m_lastLine);
}
template <typename LexerType>
template <class TreeBuilder> TreeStatement Parser<LexerType>::parseIfStatement(TreeBuilder& context)
{
ASSERT(match(IF));
-
+ JSTokenLocation ifLocation(tokenLocation());
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);
-
+ return context.createIfStatement(ifLocation, condition, trueBlock, 0, start, end);
+
Vector<TreeExpression> exprStack;
Vector<pair<int, int> > posStack;
+ Vector<JSTokenLocation> tokenLocationStack;
Vector<TreeStatement> statementStack;
bool trailingElse = false;
do {
+ JSTokenLocation tempLocation = tokenLocation();
next();
if (!match(IF)) {
const Identifier* unused = 0;
}
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);
+ failIfFalse(innerTrueBlock);
+ tokenLocationStack.append(tempLocation);
exprStack.append(innerCondition);
posStack.append(make_pair(innerStart, innerEnd));
statementStack.append(innerTrueBlock);
} while (match(ELSE));
-
+
if (!trailingElse) {
TreeExpression condition = exprStack.last();
exprStack.removeLast();
statementStack.removeLast();
pair<int, int> pos = posStack.last();
posStack.removeLast();
- statementStack.append(context.createIfStatement(m_lexer->lastLineNumber(), condition, trueBlock, pos.first, pos.second));
+ JSTokenLocation elseLocation = tokenLocationStack.last();
+ tokenLocationStack.removeLast();
+ statementStack.append(context.createIfStatement(elseLocation, condition, trueBlock, 0, pos.first, pos.second));
}
-
+
while (!exprStack.isEmpty()) {
TreeExpression condition = exprStack.last();
exprStack.removeLast();
statementStack.removeLast();
pair<int, int> pos = posStack.last();
posStack.removeLast();
- statementStack.append(context.createIfStatement(m_lexer->lastLineNumber(), condition, trueBlock, falseBlock, pos.first, pos.second));
+ JSTokenLocation elseLocation = tokenLocationStack.last();
+ tokenLocationStack.removeLast();
+ statementStack.append(context.createIfStatement(elseLocation, condition, trueBlock, falseBlock, pos.first, pos.second));
}
-
- return context.createIfStatement(m_lexer->lastLineNumber(), condition, trueBlock, statementStack.last(), start, end);
+
+ return context.createIfStatement(ifLocation, condition, trueBlock, statementStack.last(), start, end);
}
template <typename LexerType>
template <class TreeBuilder> TreeExpression Parser<LexerType>::parseExpression(TreeBuilder& context)
{
failIfStackOverflow();
+ JSTokenLocation location(tokenLocation());
TreeExpression node = parseAssignmentExpression(context);
failIfFalse(node);
if (!match(COMMA))
m_nonLHSCount++;
TreeExpression right = parseAssignmentExpression(context);
failIfFalse(right);
- typename TreeBuilder::Comma commaNode = context.createCommaExpr(m_lexer->lastLineNumber(), node, right);
+ typename TreeBuilder::Comma commaNode = context.createCommaExpr(location, node, right);
while (match(COMMA)) {
next(TreeBuilder::DontBuildStrings);
right = parseAssignmentExpression(context);
{
failIfStackOverflow();
int start = tokenStart();
+ unsigned line = tokenLine();
+ unsigned lineStart = tokenLineStart();
+ JSTokenLocation location(tokenLocation());
int initialAssignmentCount = m_assignmentCount;
int initialNonLHSCount = m_nonLHSCount;
TreeExpression lhs = parseConditionalExpression(context);
}
m_nonTrivialExpressionCount++;
hadAssignment = true;
- context.assignmentStackAppend(assignmentStack, lhs, start, tokenStart(), m_assignmentCount, op);
+ context.assignmentStackAppend(assignmentStack, lhs, start, tokenStart(), line, lineStart, m_assignmentCount, op);
start = tokenStart();
+ line = tokenLine();
+ lineStart = tokenLineStart();
m_assignmentCount++;
next(TreeBuilder::DontBuildStrings);
if (strictMode() && m_lastIdentifier && context.isResolve(lhs)) {
- failIfTrueIfStrictWithMessage(m_globalData->propertyNames->eval == *m_lastIdentifier, "'eval' cannot be modified in strict mode");
- failIfTrueIfStrictWithMessage(m_globalData->propertyNames->arguments == *m_lastIdentifier, "'arguments' cannot be modified in strict mode");
+ failIfTrueIfStrictWithMessage(m_vm->propertyNames->eval == *m_lastIdentifier, "'eval' cannot be modified in strict mode");
+ failIfTrueIfStrictWithMessage(m_vm->propertyNames->arguments == *m_lastIdentifier, "'arguments' cannot be modified in strict mode");
declareWrite(m_lastIdentifier);
m_lastIdentifier = 0;
}
return lhs;
while (assignmentStack)
- lhs = context.createAssignment(m_lexer->lastLineNumber(), assignmentStack, lhs, initialAssignmentCount, m_assignmentCount, lastTokenEnd());
+ lhs = context.createAssignment(location, assignmentStack, lhs, initialAssignmentCount, m_assignmentCount, lastTokenEnd());
return lhs;
}
template <typename LexerType>
template <class TreeBuilder> TreeExpression Parser<LexerType>::parseConditionalExpression(TreeBuilder& context)
{
+ JSTokenLocation location(tokenLocation());
TreeExpression cond = parseBinaryExpression(context);
failIfFalse(cond);
if (!match(QUESTION))
TreeExpression rhs = parseAssignmentExpression(context);
failIfFalse(rhs);
- return context.createConditionalExpr(m_lexer->lastLineNumber(), cond, lhs, rhs);
+ return context.createConditionalExpr(location, cond, lhs, rhs);
}
ALWAYS_INLINE static bool isUnaryOp(JSTokenType token)
int operandStackDepth = 0;
int operatorStackDepth = 0;
typename TreeBuilder::BinaryExprContext binaryExprContext(context);
+ JSTokenLocation location(tokenLocation());
while (true) {
int exprStart = tokenStart();
int initialAssignments = m_assignmentCount;
TreeExpression current = parseUnaryExpression(context);
failIfFalse(current);
- context.appendBinaryExpressionInfo(operandStackDepth, current, exprStart, lastTokenEnd(), lastTokenEnd(), initialAssignments != m_assignmentCount);
+ context.appendBinaryExpressionInfo(operandStackDepth, current, exprStart, lastTokenEnd(), lastTokenEnd(), lastTokenLine(), lastTokenLineStart(), initialAssignments != m_assignmentCount);
int precedence = isBinaryOperator(m_token.m_type);
if (!precedence)
break;
typename TreeBuilder::BinaryOperand rhs = context.getFromOperandStack(-1);
typename TreeBuilder::BinaryOperand lhs = context.getFromOperandStack(-2);
context.shrinkOperandStackBy(operandStackDepth, 2);
- context.appendBinaryOperation(m_lexer->lastLineNumber(), operandStackDepth, operatorStackDepth, lhs, rhs);
+ context.appendBinaryOperation(location, operandStackDepth, operatorStackDepth, lhs, rhs);
context.operatorStackPop(operatorStackDepth);
}
context.operatorStackAppend(operatorStackDepth, operatorToken, precedence);
typename TreeBuilder::BinaryOperand rhs = context.getFromOperandStack(-1);
typename TreeBuilder::BinaryOperand lhs = context.getFromOperandStack(-2);
context.shrinkOperandStackBy(operandStackDepth, 2);
- context.appendBinaryOperation(m_lexer->lastLineNumber(), operandStackDepth, operatorStackDepth, lhs, rhs);
+ context.appendBinaryOperation(location, operandStackDepth, operatorStackDepth, lhs, rhs);
context.operatorStackPop(operatorStackDepth);
}
return context.popOperandStack(operandStackDepth);
wasIdent = true;
case STRING: {
const Identifier* ident = m_token.m_data.ident;
- if (complete || (wasIdent && (*ident == m_globalData->propertyNames->get || *ident == m_globalData->propertyNames->set)))
+ if (complete || (wasIdent && (*ident == m_vm->propertyNames->get || *ident == m_vm->propertyNames->set)))
nextExpectIdentifier(LexerFlagsIgnoreReservedWords);
else
nextExpectIdentifier(LexerFlagsIgnoreReservedWords | TreeBuilder::DontBuildKeywords);
const Identifier* accessorName = 0;
TreeFormalParameterList parameters = 0;
TreeFunctionBody body = 0;
- int openBracePos = 0;
- int closeBracePos = 0;
+ unsigned openBraceOffset = 0;
+ unsigned closeBraceOffset = 0;
int bodyStartLine = 0;
+ unsigned bodyStartColumn = 0;
PropertyNode::Type type;
- if (*ident == m_globalData->propertyNames->get)
+ if (*ident == m_vm->propertyNames->get)
type = PropertyNode::Getter;
- else if (*ident == m_globalData->propertyNames->set)
+ else if (*ident == m_vm->propertyNames->set)
type = PropertyNode::Setter;
else
fail();
numericPropertyName = m_token.m_data.doubleValue;
else
fail();
+ JSTokenLocation location(tokenLocation());
next();
- failIfFalse((parseFunctionInfo<FunctionNoRequirements, false>(context, accessorName, parameters, body, openBracePos, closeBracePos, bodyStartLine)));
+ failIfFalse((parseFunctionInfo<FunctionNoRequirements, false>(context, accessorName, parameters, body, openBraceOffset, closeBraceOffset, bodyStartLine, bodyStartColumn)));
if (stringPropertyName)
- return context.template createGetterOrSetterProperty<complete>(m_lexer->lastLineNumber(), type, stringPropertyName, parameters, body, openBracePos, closeBracePos, bodyStartLine, m_lastLine);
- return context.template createGetterOrSetterProperty<complete>(const_cast<JSGlobalData*>(m_globalData), m_lexer->lastLineNumber(), type, numericPropertyName, parameters, body, openBracePos, closeBracePos, bodyStartLine, m_lastLine);
+ return context.template createGetterOrSetterProperty<complete>(location, type, stringPropertyName, parameters, body, openBraceOffset, closeBraceOffset, bodyStartLine, m_lastLine, bodyStartColumn);
+ return context.template createGetterOrSetterProperty<complete>(const_cast<VM*>(m_vm), location, type, numericPropertyName, parameters, body, openBraceOffset, closeBraceOffset, bodyStartLine, m_lastLine, bodyStartColumn);
}
case NUMBER: {
double propertyName = m_token.m_data.doubleValue;
consumeOrFail(COLON);
TreeExpression node = parseAssignmentExpression(context);
failIfFalse(node);
- return context.template createProperty<complete>(const_cast<JSGlobalData*>(m_globalData), propertyName, node, PropertyNode::Constant);
+ return context.template createProperty<complete>(const_cast<VM*>(m_vm), propertyName, node, PropertyNode::Constant);
}
default:
failIfFalse(m_token.m_type & KeywordTokenFlag);
template <typename LexerType>
template <class TreeBuilder> TreeExpression Parser<LexerType>::parseObjectLiteral(TreeBuilder& context)
{
- int startOffset = m_token.m_data.intValue;
+ int startOffset = m_token.m_data.offset;
+ unsigned oldLineStartOffset = m_lexer->currentLineStartOffset();
unsigned oldLastLineNumber = m_lexer->lastLineNumber();
unsigned oldLineNumber = m_lexer->lineNumber();
consumeOrFailWithFlags(OPENBRACE, TreeBuilder::DontBuildStrings);
-
+ JSTokenLocation location(tokenLocation());
+
int oldNonLHSCount = m_nonLHSCount;
if (match(CLOSEBRACE)) {
next();
- return context.createObjectLiteral(m_lexer->lastLineNumber());
+ return context.createObjectLiteral(location);
}
TreeProperty property = parseProperty<false>(context);
failIfFalse(property);
if (!m_syntaxAlreadyValidated && context.getType(property) != PropertyNode::Constant) {
- m_lexer->setOffset(startOffset);
+ m_lexer->setOffset(startOffset, oldLineStartOffset);
next();
m_lexer->setLastLineNumber(oldLastLineNumber);
m_lexer->setLineNumber(oldLineNumber);
return parseStrictObjectLiteral(context);
}
- TreePropertyList propertyList = context.createPropertyList(m_lexer->lastLineNumber(), property);
+ TreePropertyList propertyList = context.createPropertyList(location, property);
TreePropertyList tail = propertyList;
while (match(COMMA)) {
next(TreeBuilder::DontBuildStrings);
// allow extra comma, see http://bugs.webkit.org/show_bug.cgi?id=5939
if (match(CLOSEBRACE))
break;
+ JSTokenLocation propertyLocation(tokenLocation());
property = parseProperty<false>(context);
failIfFalse(property);
if (!m_syntaxAlreadyValidated && context.getType(property) != PropertyNode::Constant) {
- m_lexer->setOffset(startOffset);
+ m_lexer->setOffset(startOffset, oldLineStartOffset);
next();
m_lexer->setLastLineNumber(oldLastLineNumber);
m_lexer->setLineNumber(oldLineNumber);
return parseStrictObjectLiteral(context);
}
- tail = context.createPropertyList(m_lexer->lastLineNumber(), property, tail);
+ tail = context.createPropertyList(propertyLocation, property, tail);
}
-
+
+ location = tokenLocation();
consumeOrFail(CLOSEBRACE);
m_nonLHSCount = oldNonLHSCount;
- return context.createObjectLiteral(m_lexer->lastLineNumber(), propertyList);
+ return context.createObjectLiteral(location, propertyList);
}
template <typename LexerType>
int oldNonLHSCount = m_nonLHSCount;
+ JSTokenLocation location(tokenLocation());
if (match(CLOSEBRACE)) {
next();
- return context.createObjectLiteral(m_lexer->lastLineNumber());
+ return context.createObjectLiteral(location);
}
TreeProperty property = parseProperty<true>(context);
if (!m_syntaxAlreadyValidated)
objectValidator.add(context.getName(property).impl(), context.getType(property));
- TreePropertyList propertyList = context.createPropertyList(m_lexer->lastLineNumber(), property);
+ TreePropertyList propertyList = context.createPropertyList(location, property);
TreePropertyList tail = propertyList;
while (match(COMMA)) {
next();
// allow extra comma, see http://bugs.webkit.org/show_bug.cgi?id=5939
if (match(CLOSEBRACE))
break;
+ JSTokenLocation propertyLocation(tokenLocation());
property = parseProperty<true>(context);
failIfFalse(property);
if (!m_syntaxAlreadyValidated) {
ObjectValidationMap::AddResult propertyEntry = objectValidator.add(context.getName(property).impl(), context.getType(property));
if (!propertyEntry.isNewEntry) {
- failIfTrue(propertyEntry.iterator->second == PropertyNode::Constant);
+ failIfTrue(propertyEntry.iterator->value == PropertyNode::Constant);
failIfTrue(context.getType(property) == PropertyNode::Constant);
- failIfTrue(context.getType(property) & propertyEntry.iterator->second);
- propertyEntry.iterator->second |= context.getType(property);
+ failIfTrue(context.getType(property) & propertyEntry.iterator->value);
+ propertyEntry.iterator->value |= context.getType(property);
}
}
- tail = context.createPropertyList(m_lexer->lastLineNumber(), property, tail);
+ tail = context.createPropertyList(propertyLocation, property, tail);
}
-
+
+ location = tokenLocation();
consumeOrFail(CLOSEBRACE);
m_nonLHSCount = oldNonLHSCount;
- return context.createObjectLiteral(m_lexer->lastLineNumber(), propertyList);
+ return context.createObjectLiteral(location, propertyList);
}
template <typename LexerType>
elisions++;
}
if (match(CLOSEBRACKET)) {
+ JSTokenLocation location(tokenLocation());
next(TreeBuilder::DontBuildStrings);
- return context.createArray(m_lexer->lastLineNumber(), elisions);
+ return context.createArray(location, elisions);
}
TreeExpression elem = parseAssignmentExpression(context);
}
if (match(CLOSEBRACKET)) {
+ JSTokenLocation location(tokenLocation());
next(TreeBuilder::DontBuildStrings);
- return context.createArray(m_lexer->lastLineNumber(), elisions, elementList);
+ return context.createArray(location, elisions, elementList);
}
TreeExpression elem = parseAssignmentExpression(context);
failIfFalse(elem);
tail = context.createElementList(tail, elisions, elem);
}
-
+
+ JSTokenLocation location(tokenLocation());
consumeOrFail(CLOSEBRACKET);
m_nonLHSCount = oldNonLHSCount;
- return context.createArray(m_lexer->lastLineNumber(), elementList);
+ return context.createArray(location, elementList);
}
template <typename LexerType>
return result;
}
case THISTOKEN: {
+ JSTokenLocation location(tokenLocation());
next();
- return context.thisExpr(m_lexer->lastLineNumber());
+ return context.thisExpr(location);
}
case IDENT: {
int start = tokenStart();
+ int line = tokenLine();
+ int lineStart = tokenLineStart();
const Identifier* ident = m_token.m_data.ident;
+ JSTokenLocation location(tokenLocation());
next();
- currentScope()->useVariable(ident, m_globalData->propertyNames->eval == *ident);
+ currentScope()->useVariable(ident, m_vm->propertyNames->eval == *ident);
m_lastIdentifier = ident;
- return context.createResolve(m_lexer->lastLineNumber(), ident, start);
+ return context.createResolve(location, ident, start, line, lineStart);
}
case STRING: {
const Identifier* ident = m_token.m_data.ident;
+ JSTokenLocation location(tokenLocation());
next();
- return context.createString(m_lexer->lastLineNumber(), ident);
+ return context.createString(location, ident);
}
case NUMBER: {
double d = m_token.m_data.doubleValue;
+ JSTokenLocation location(tokenLocation());
next();
- return context.createNumberExpr(m_lexer->lastLineNumber(), d);
+ return context.createNumberExpr(location, d);
}
case NULLTOKEN: {
+ JSTokenLocation location(tokenLocation());
next();
- return context.createNull(m_lexer->lastLineNumber());
+ return context.createNull(location);
}
case TRUETOKEN: {
+ JSTokenLocation location(tokenLocation());
next();
- return context.createBoolean(m_lexer->lastLineNumber(), true);
+ return context.createBoolean(location, true);
}
case FALSETOKEN: {
+ JSTokenLocation location(tokenLocation());
next();
- return context.createBoolean(m_lexer->lastLineNumber(), false);
+ return context.createBoolean(location, false);
}
case DIVEQUAL:
case DIVIDE: {
failIfFalse(m_lexer->scanRegExp(pattern, flags));
int start = tokenStart();
+ int line = tokenLine();
+ int lineStart = tokenLineStart();
+ JSTokenLocation location(tokenLocation());
next();
- TreeExpression re = context.createRegExp(m_lexer->lastLineNumber(), *pattern, *flags, start);
+ TreeExpression re = context.createRegExp(location, *pattern, *flags, start, line, lineStart);
if (!re) {
- const char* yarrErrorMsg = Yarr::checkSyntax(pattern->ustring());
- ASSERT(!m_errorMessage.isNull());
+ const char* yarrErrorMsg = Yarr::checkSyntax(pattern->string());
failWithMessage(yarrErrorMsg);
}
return re;
template <class TreeBuilder> TreeArguments Parser<LexerType>::parseArguments(TreeBuilder& context)
{
consumeOrFailWithFlags(OPENPAREN, TreeBuilder::DontBuildStrings);
+ JSTokenLocation location(tokenLocation());
if (match(CLOSEPAREN)) {
next(TreeBuilder::DontBuildStrings);
return context.createArguments();
TreeExpression firstArg = parseAssignmentExpression(context);
failIfFalse(firstArg);
- TreeArgumentsList argList = context.createArgumentsList(m_lexer->lastLineNumber(), firstArg);
+ TreeArgumentsList argList = context.createArgumentsList(location, firstArg);
TreeArgumentsList tail = argList;
while (match(COMMA)) {
+ JSTokenLocation argumentLocation(tokenLocation());
next(TreeBuilder::DontBuildStrings);
TreeExpression arg = parseAssignmentExpression(context);
failIfFalse(arg);
- tail = context.createArgumentsList(m_lexer->lastLineNumber(), tail, arg);
+ tail = context.createArgumentsList(argumentLocation, tail, arg);
}
consumeOrFail(CLOSEPAREN);
return context.createArguments(argList);
TreeExpression base = 0;
int start = tokenStart();
int expressionStart = start;
+ int expressionLine = tokenLine();
+ int expressionLineStart = tokenLineStart();
int newCount = 0;
+ JSTokenLocation location;
while (match(NEW)) {
next();
newCount++;
}
if (match(FUNCTION)) {
- const Identifier* name = &m_globalData->propertyNames->nullIdentifier;
+ const Identifier* name = &m_vm->propertyNames->nullIdentifier;
TreeFormalParameterList parameters = 0;
TreeFunctionBody body = 0;
- int openBracePos = 0;
- int closeBracePos = 0;
+ unsigned openBraceOffset = 0;
+ unsigned closeBraceOffset = 0;
int bodyStartLine = 0;
+ unsigned bodyStartColumn = 0;
+ location = tokenLocation();
next();
- failIfFalse((parseFunctionInfo<FunctionNoRequirements, false>(context, name, parameters, body, openBracePos, closeBracePos, bodyStartLine)));
- base = context.createFunctionExpr(m_lexer->lastLineNumber(), name, body, parameters, openBracePos, closeBracePos, bodyStartLine, m_lastLine);
+ failIfFalse((parseFunctionInfo<FunctionNoRequirements, false>(context, name, parameters, body, openBraceOffset, closeBraceOffset, bodyStartLine, bodyStartColumn)));
+ base = context.createFunctionExpr(location, name, body, parameters, openBraceOffset, closeBraceOffset, bodyStartLine, m_lastLine, bodyStartColumn);
} else
base = parsePrimaryExpression(context);
failIfFalse(base);
while (true) {
+ location = tokenLocation();
switch (m_token.m_type) {
case OPENBRACKET: {
m_nonTrivialExpressionCount++;
int expressionEnd = lastTokenEnd();
+ int expressionLine = lastTokenLine();
+ int expressionLineStart = lastTokenLineStart();
next();
int nonLHSCount = m_nonLHSCount;
int initialAssignments = m_assignmentCount;
TreeExpression property = parseExpression(context);
failIfFalse(property);
- base = context.createBracketAccess(m_lexer->lastLineNumber(), base, property, initialAssignments != m_assignmentCount, expressionStart, expressionEnd, tokenEnd());
+ base = context.createBracketAccess(location, base, property, initialAssignments != m_assignmentCount, expressionStart, expressionEnd, tokenEnd(), expressionLine, expressionLineStart);
consumeOrFail(CLOSEBRACKET);
m_nonLHSCount = nonLHSCount;
break;
if (newCount) {
newCount--;
int exprEnd = lastTokenEnd();
+ unsigned expressionLine = lastTokenLine();
+ unsigned expressionLineStart = lastTokenLineStart();
TreeArguments arguments = parseArguments(context);
failIfFalse(arguments);
- base = context.createNewExpr(m_lexer->lastLineNumber(), base, arguments, start, exprEnd, lastTokenEnd());
+ base = context.createNewExpr(location, base, arguments, start, exprEnd, lastTokenEnd(), expressionLine, expressionLineStart);
} else {
int expressionEnd = lastTokenEnd();
+ unsigned expressionLine = lastTokenLine();
+ int expressionLineStart = lastTokenLineStart();
TreeArguments arguments = parseArguments(context);
failIfFalse(arguments);
- base = context.makeFunctionCallNode(m_lexer->lastLineNumber(), base, arguments, expressionStart, expressionEnd, lastTokenEnd());
+ base = context.makeFunctionCallNode(location, base, arguments, expressionStart, expressionEnd, lastTokenEnd(), expressionLine, expressionLineStart);
}
m_nonLHSCount = nonLHSCount;
break;
case DOT: {
m_nonTrivialExpressionCount++;
int expressionEnd = lastTokenEnd();
+ expressionLineStart = lastTokenLineStart();
nextExpectIdentifier(LexerFlagsIgnoreReservedWords | TreeBuilder::DontBuildKeywords);
matchOrFail(IDENT);
- base = context.createDotAccess(m_lexer->lastLineNumber(), base, m_token.m_data.ident, expressionStart, expressionEnd, tokenEnd());
+ base = context.createDotAccess(location, base, m_token.m_data.ident, expressionStart, expressionEnd, tokenEnd(), expressionLine, expressionLineStart);
next();
break;
}
}
endMemberExpression:
while (newCount--)
- base = context.createNewExpr(m_lexer->lastLineNumber(), base, start, lastTokenEnd());
+ base = context.createNewExpr(location, base, start, lastTokenEnd(), expressionLine, expressionLineStart);
return base;
}
}
}
m_nonLHSCount++;
- context.appendUnaryToken(tokenStackDepth, m_token.m_type, tokenStart());
+ context.appendUnaryToken(tokenStackDepth, m_token.m_type, tokenStart(), tokenLine(), tokenLineStart());
next();
m_nonTrivialExpressionCount++;
}
int subExprStart = tokenStart();
+ int subExprLine = tokenLine();
+ int subExprLineStartPosition = tokenLineStart();
+ ASSERT(subExprStart >= subExprLineStartPosition);
+ JSTokenLocation location(tokenLocation());
TreeExpression expr = parseMemberExpression(context);
failIfFalse(expr);
bool isEvalOrArguments = false;
if (strictMode() && !m_syntaxAlreadyValidated) {
if (context.isResolve(expr))
- isEvalOrArguments = *m_lastIdentifier == m_globalData->propertyNames->eval || *m_lastIdentifier == m_globalData->propertyNames->arguments;
+ isEvalOrArguments = *m_lastIdentifier == m_vm->propertyNames->eval || *m_lastIdentifier == m_vm->propertyNames->arguments;
}
failIfTrueIfStrictWithNameAndMessage(isEvalOrArguments && modifiesExpr, "'", m_lastIdentifier->impl(), "' cannot be modified in strict mode");
switch (m_token.m_type) {
case PLUSPLUS:
m_nonTrivialExpressionCount++;
m_nonLHSCount++;
- expr = context.makePostfixNode(m_lexer->lastLineNumber(), expr, OpPlusPlus, subExprStart, lastTokenEnd(), tokenEnd());
+ expr = context.makePostfixNode(location, expr, OpPlusPlus, subExprStart, lastTokenEnd(), tokenEnd(), tokenLine(), tokenLineStart());
m_assignmentCount++;
failIfTrueIfStrictWithNameAndMessage(isEvalOrArguments, "'", m_lastIdentifier->impl(), "' cannot be modified in strict mode");
failIfTrueIfStrict(requiresLExpr);
case MINUSMINUS:
m_nonTrivialExpressionCount++;
m_nonLHSCount++;
- expr = context.makePostfixNode(m_lexer->lastLineNumber(), expr, OpMinusMinus, subExprStart, lastTokenEnd(), tokenEnd());
+ expr = context.makePostfixNode(location, expr, OpMinusMinus, subExprStart, lastTokenEnd(), tokenEnd(), tokenLine(), tokenLineStart());
m_assignmentCount++;
failIfTrueIfStrictWithNameAndMessage(isEvalOrArguments, "'", m_lastIdentifier->impl(), "' cannot be modified in strict mode");
failIfTrueIfStrict(requiresLExpr);
}
int end = lastTokenEnd();
-
+ int endLine = lastTokenLine();
+ int endLineStartPosition = lastTokenLineStart();
+
if (!TreeBuilder::CreatesAST && (m_syntaxAlreadyValidated || !strictMode()))
return expr;
-
+
+ location = tokenLocation();
+ location.line = m_lexer->lastLineNumber();
while (tokenStackDepth) {
switch (context.unaryTokenStackLastType(tokenStackDepth)) {
case EXCLAMATION:
- expr = context.createLogicalNot(m_lexer->lastLineNumber(), expr);
+ expr = context.createLogicalNot(location, expr);
break;
case TILDE:
- expr = context.makeBitwiseNotNode(m_lexer->lastLineNumber(), expr);
+ expr = context.makeBitwiseNotNode(location, expr);
break;
case MINUS:
- expr = context.makeNegateNode(m_lexer->lastLineNumber(), expr);
+ expr = context.makeNegateNode(location, expr);
break;
case PLUS:
- expr = context.createUnaryPlus(m_lexer->lastLineNumber(), expr);
+ expr = context.createUnaryPlus(location, expr);
break;
case PLUSPLUS:
case AUTOPLUSPLUS:
- expr = context.makePrefixNode(m_lexer->lastLineNumber(), expr, OpPlusPlus, context.unaryTokenStackLastStart(tokenStackDepth), subExprStart + 1, end);
+ expr = context.makePrefixNode(location, expr, OpPlusPlus, context.unaryTokenStackLastStart(tokenStackDepth), subExprStart + 1, end, subExprLine, subExprLineStartPosition);
m_assignmentCount++;
break;
case MINUSMINUS:
case AUTOMINUSMINUS:
- expr = context.makePrefixNode(m_lexer->lastLineNumber(), expr, OpMinusMinus, context.unaryTokenStackLastStart(tokenStackDepth), subExprStart + 1, end);
+ expr = context.makePrefixNode(location, expr, OpMinusMinus, context.unaryTokenStackLastStart(tokenStackDepth), subExprStart + 1, end, subExprLine, subExprLineStartPosition);
m_assignmentCount++;
break;
case TYPEOF:
- expr = context.makeTypeOfNode(m_lexer->lastLineNumber(), expr);
+ expr = context.makeTypeOfNode(location, expr);
break;
case VOIDTOKEN:
- expr = context.createVoid(m_lexer->lastLineNumber(), expr);
+ expr = context.createVoid(location, expr);
break;
case DELETETOKEN:
failIfTrueIfStrictWithNameAndMessage(context.isResolve(expr), "Cannot delete unqualified property", m_lastIdentifier->impl(), "in strict mode");
- expr = context.makeDeleteNode(m_lexer->lastLineNumber(), expr, context.unaryTokenStackLastStart(tokenStackDepth), end, end);
+ expr = context.makeDeleteNode(location, expr, context.unaryTokenStackLastStart(tokenStackDepth), end, end, endLine, endLineStartPosition);
break;
default:
// If we get here something has gone horribly horribly wrong
CRASH();
}
subExprStart = context.unaryTokenStackLastStart(tokenStackDepth);
+ subExprLineStartPosition = context.unaryTokenStackLastLineStartPosition(tokenStackDepth);
context.unaryTokenStackRemoveLast(tokenStackDepth);
}
return expr;
projects / apple / javascriptcore.git / blobdiff